blob: a664118f6aad37743cd6f2979ed9603838bcd2df [file] [log] [blame]
/*
* Copyright (C) 2011-2014 Freescale Semiconductor, Inc. All Rights Reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <linux/cdev.h>
#include <linux/circ_buf.h>
#include <linux/clk.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/dma-mapping.h>
#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/genalloc.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/mxc_mlb.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/platform_device.h>
#include <linux/poll.h>
#include <linux/regulator/consumer.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/uaccess.h>
#define DRIVER_NAME "mxc_mlb150"
/*
* MLB module memory map registers define
*/
#define REG_MLBC0 0x0
#define MLBC0_MLBEN (0x1)
#define MLBC0_MLBCLK_MASK (0x7 << 2)
#define MLBC0_MLBCLK_SHIFT (2)
#define MLBC0_MLBPEN (0x1 << 5)
#define MLBC0_MLBLK (0x1 << 7)
#define MLBC0_ASYRETRY (0x1 << 12)
#define MLBC0_CTLRETRY (0x1 << 12)
#define MLBC0_FCNT_MASK (0x7 << 15)
#define MLBC0_FCNT_SHIFT (15)
#define REG_MLBPC0 0x8
#define MLBPC0_MCLKHYS (0x1 << 11)
#define REG_MS0 0xC
#define REG_MS1 0x14
#define REG_MSS 0x20
#define MSS_RSTSYSCMD (0x1)
#define MSS_LKSYSCMD (0x1 << 1)
#define MSS_ULKSYSCMD (0x1 << 2)
#define MSS_CSSYSCMD (0x1 << 3)
#define MSS_SWSYSCMD (0x1 << 4)
#define MSS_SERVREQ (0x1 << 5)
#define REG_MSD 0x24
#define REG_MIEN 0x2C
#define MIEN_ISOC_PE (0x1)
#define MIEN_ISOC_BUFO (0x1 << 1)
#define MIEN_SYNC_PE (0x1 << 16)
#define MIEN_ARX_DONE (0x1 << 17)
#define MIEN_ARX_PE (0x1 << 18)
#define MIEN_ARX_BREAK (0x1 << 19)
#define MIEN_ATX_DONE (0x1 << 20)
#define MIEN_ATX_PE (0x1 << 21)
#define MIEN_ATX_BREAK (0x1 << 22)
#define MIEN_CRX_DONE (0x1 << 24)
#define MIEN_CRX_PE (0x1 << 25)
#define MIEN_CRX_BREAK (0x1 << 26)
#define MIEN_CTX_DONE (0x1 << 27)
#define MIEN_CTX_PE (0x1 << 28)
#define MIEN_CTX_BREAK (0x1 << 29)
#define REG_MLBPC2 0x34
#define REG_MLBPC1 0x38
#define MLBPC1_VAL (0x00000888)
#define REG_MLBC1 0x3C
#define MLBC1_LOCK (0x1 << 6)
#define MLBC1_CLKM (0x1 << 7)
#define MLBC1_NDA_MASK (0xFF << 8)
#define MLBC1_NDA_SHIFT (8)
#define REG_HCTL 0x80
#define HCTL_RST0 (0x1)
#define HCTL_RST1 (0x1 << 1)
#define HCTL_EN (0x1 << 15)
#define REG_HCMR0 0x88
#define REG_HCMR1 0x8C
#define REG_HCER0 0x90
#define REG_HCER1 0x94
#define REG_HCBR0 0x98
#define REG_HCBR1 0x9C
#define REG_MDAT0 0xC0
#define REG_MDAT1 0xC4
#define REG_MDAT2 0xC8
#define REG_MDAT3 0xCC
#define REG_MDWE0 0xD0
#define REG_MDWE1 0xD4
#define REG_MDWE2 0xD8
#define REG_MDWE3 0xDC
#define REG_MCTL 0xE0
#define MCTL_XCMP (0x1)
#define REG_MADR 0xE4
#define MADR_WNR (0x1 << 31)
#define MADR_TB (0x1 << 30)
#define MADR_ADDR_MASK (0x7f << 8)
#define MADR_ADDR_SHIFT (0)
#define REG_ACTL 0x3C0
#define ACTL_MPB (0x1 << 4)
#define ACTL_DMAMODE (0x1 << 2)
#define ACTL_SMX (0x1 << 1)
#define ACTL_SCE (0x1)
#define REG_ACSR0 0x3D0
#define REG_ACSR1 0x3D4
#define REG_ACMR0 0x3D8
#define REG_ACMR1 0x3DC
#define REG_CAT_MDATn(ch) (REG_MDAT0 + ((ch % 8) >> 1) * 4)
#define REG_CAT_MDWEn(ch) (REG_MDWE0 + ((ch % 8) >> 1) * 4)
#define INT_AHB0_CH_START (0)
#define INT_AHB1_CH_START (32)
#define LOGIC_CH_NUM (64)
#define BUF_CDT_OFFSET (0x0)
#define BUF_ADT_OFFSET (0x40)
#define BUF_CAT_MLB_OFFSET (0x80)
#define BUF_CAT_HBI_OFFSET (0x88)
#define BUF_CTR_END_OFFSET (0x8F)
#define CAT_MODE_RX (0x1 << 0)
#define CAT_MODE_TX (0x1 << 1)
#define CAT_MODE_INBOUND_DMA (0x1 << 8)
#define CAT_MODE_OUTBOUND_DMA (0x1 << 9)
#define CH_SYNC_DEFAULT_QUAD (1)
#define CH_SYNC_MAX_QUAD (15)
#define CH_SYNC_CDT_BUF_DEP (CH_SYNC_DEFAULT_QUAD * 4 * 4)
#define CH_SYNC_ADT_BUF_MULTI (4)
#define CH_SYNC_ADT_BUF_DEP (CH_SYNC_CDT_BUF_DEP * CH_SYNC_ADT_BUF_MULTI)
#define CH_SYNC_BUF_SZ (CH_SYNC_MAX_QUAD * 4 * 4 * \
CH_SYNC_ADT_BUF_MULTI)
#define CH_CTRL_CDT_BUF_DEP (64)
#define CH_CTRL_ADT_BUF_DEP (CH_CTRL_CDT_BUF_DEP)
#define CH_CTRL_BUF_SZ (CH_CTRL_ADT_BUF_DEP)
#define CH_ASYNC_MDP_PACKET_LEN (1024)
#define CH_ASYNC_MEP_PACKET_LEN (1536)
#define CH_ASYNC_CDT_BUF_DEP (CH_ASYNC_MEP_PACKET_LEN)
#define CH_ASYNC_ADT_BUF_DEP (CH_ASYNC_CDT_BUF_DEP)
#define CH_ASYNC_BUF_SZ (CH_ASYNC_ADT_BUF_DEP)
#define CH_ISOC_BLK_SIZE_188 (188)
#define CH_ISOC_BLK_SIZE_196 (196)
#define CH_ISOC_BLK_SIZE (CH_ISOC_BLK_SIZE_188)
#define CH_ISOC_BLK_NUM (1)
#define CH_ISOC_CDT_BUF_DEP (CH_ISOC_BLK_SIZE * CH_ISOC_BLK_NUM)
#define CH_ISOC_ADT_BUF_DEP (CH_ISOC_CDT_BUF_DEP)
#define CH_ISOC_BUF_SZ (1024)
#define CH_SYNC_DBR_BUF_OFFSET (0x0)
#define CH_CTRL_DBR_BUF_OFFSET (CH_SYNC_DBR_BUF_OFFSET + \
2 * (CH_SYNC_MAX_QUAD * 4 * 4))
#define CH_ASYNC_DBR_BUF_OFFSET (CH_CTRL_DBR_BUF_OFFSET + \
2 * CH_CTRL_CDT_BUF_DEP)
#define CH_ISOC_DBR_BUF_OFFSET (CH_ASYNC_DBR_BUF_OFFSET + \
2 * CH_ASYNC_CDT_BUF_DEP)
#define DBR_BUF_START 0x00000
#define CDT_LEN (16)
#define ADT_LEN (16)
#define CAT_LEN (2)
#define CDT_SZ (CDT_LEN * LOGIC_CH_NUM)
#define ADT_SZ (ADT_LEN * LOGIC_CH_NUM)
#define CAT_SZ (CAT_LEN * LOGIC_CH_NUM * 2)
#define CDT_BASE(base) (base + BUF_CDT_OFFSET)
#define ADT_BASE(base) (base + BUF_ADT_OFFSET)
#define CAT_MLB_BASE(base) (base + BUF_CAT_MLB_OFFSET)
#define CAT_HBI_BASE(base) (base + BUF_CAT_HBI_OFFSET)
#define CDTn_ADDR(base, n) (base + BUF_CDT_OFFSET + n * CDT_LEN)
#define ADTn_ADDR(base, n) (base + BUF_ADT_OFFSET + n * ADT_LEN)
#define CATn_MLB_ADDR(base, n) (base + BUF_CAT_MLB_OFFSET + n * CAT_LEN)
#define CATn_HBI_ADDR(base, n) (base + BUF_CAT_HBI_OFFSET + n * CAT_LEN)
#define CAT_CL_SHIFT (0x0)
#define CAT_CT_SHIFT (8)
#define CAT_CE (0x1 << 11)
#define CAT_RNW (0x1 << 12)
#define CAT_MT (0x1 << 13)
#define CAT_FCE (0x1 << 14)
#define CAT_MFE (0x1 << 14)
#define CDT_WSBC_SHIFT (14)
#define CDT_WPC_SHIFT (11)
#define CDT_RSBC_SHIFT (30)
#define CDT_RPC_SHIFT (27)
#define CDT_WPC_1_SHIFT (12)
#define CDT_RPC_1_SHIFT (28)
#define CDT_WPTR_SHIFT (0)
#define CDT_SYNC_WSTS_MASK (0x0000f000)
#define CDT_SYNC_WSTS_SHIFT (12)
#define CDT_CTRL_ASYNC_WSTS_MASK (0x0000f000)
#define CDT_CTRL_ASYNC_WSTS_SHIFT (12)
#define CDT_ISOC_WSTS_MASK (0x0000e000)
#define CDT_ISOC_WSTS_SHIFT (13)
#define CDT_RPTR_SHIFT (16)
#define CDT_SYNC_RSTS_MASK (0xf0000000)
#define CDT_SYNC_RSTS_SHIFT (28)
#define CDT_CTRL_ASYNC_RSTS_MASK (0xf0000000)
#define CDT_CTRL_ASYNC_RSTS_SHIFT (28)
#define CDT_ISOC_RSTS_MASK (0xe0000000)
#define CDT_ISOC_RSTS_SHIFT (29)
#define CDT_CTRL_ASYNC_WSTS_1 (0x1 << 14)
#define CDT_CTRL_ASYNC_RSTS_1 (0x1 << 15)
#define CDT_BD_SHIFT (0)
#define CDT_BA_SHIFT (16)
#define CDT_BS_SHIFT (0)
#define CDT_BF_SHIFT (31)
#define ADT_PG (0x1 << 13)
#define ADT_LE (0x1 << 14)
#define ADT_CE (0x1 << 15)
#define ADT_BD1_SHIFT (0)
#define ADT_ERR1 (0x1 << 13)
#define ADT_DNE1 (0x1 << 14)
#define ADT_RDY1 (0x1 << 15)
#define ADT_BD2_SHIFT (16)
#define ADT_ERR2 (0x1 << 29)
#define ADT_DNE2 (0x1 << 30)
#define ADT_RDY2 (0x1 << 31)
#define ADT_BA1_SHIFT (0x0)
#define ADT_BA2_SHIFT (0x0)
#define ADT_PS1 (0x1 << 12)
#define ADT_PS2 (0x1 << 28)
#define ADT_MEP1 (0x1 << 11)
#define ADT_MEP2 (0x1 << 27)
#define MLB_MINOR_DEVICES 4
#define MLB_CONTROL_DEV_NAME "ctrl"
#define MLB_ASYNC_DEV_NAME "async"
#define MLB_SYNC_DEV_NAME "sync"
#define MLB_ISOC_DEV_NAME "isoc"
#define TX_CHANNEL 0
#define RX_CHANNEL 1
#define TRANS_RING_NODES (1 << 3)
#define MLB_QUIRK_MLB150 (1 << 0)
enum MLB_CTYPE {
MLB_CTYPE_SYNC,
MLB_CTYPE_CTRL,
MLB_CTYPE_ASYNC,
MLB_CTYPE_ISOC,
};
enum CLK_SPEED {
CLK_256FS,
CLK_512FS,
CLK_1024FS,
CLK_2048FS,
CLK_3072FS,
CLK_4096FS,
CLK_6144FS,
CLK_8192FS,
};
enum MLB_INDEX {
IMX6Q_MLB = 0,
IMX6SX_MLB,
};
struct mlb_ringbuf {
s8 *virt_bufs[TRANS_RING_NODES];
u32 phy_addrs[TRANS_RING_NODES];
s32 head;
s32 tail;
s32 unit_size;
s32 total_size;
rwlock_t rb_lock ____cacheline_aligned; /* ring index lock */
};
struct mlb_channel_info {
/* Input MLB channel address */
u32 address;
/* Internal AHB channel label */
u32 cl;
/* DBR buf head */
u32 dbr_buf_head;
};
struct mlb_dev_info {
/* device node name */
const char dev_name[20];
/* channel type */
const unsigned int channel_type;
/* ch fps */
enum CLK_SPEED fps;
/* channel info for tx/rx */
struct mlb_channel_info channels[2];
/* ring buffer */
u8 *rbuf_base_virt;
u32 rbuf_base_phy;
struct mlb_ringbuf rx_rbuf;
struct mlb_ringbuf tx_rbuf;
/* exception event */
unsigned long ex_event;
/* tx busy indicator */
unsigned long tx_busy;
/* channel started up or not */
atomic_t on;
/* device open count */
atomic_t opencnt;
/* wait queue head for channel */
wait_queue_head_t rx_wq;
wait_queue_head_t tx_wq;
/* TX OK */
s32 tx_ok;
/* spinlock for event access */
spinlock_t event_lock;
/*
* Block size for isoc mode
* This variable can be configured in ioctl
*/
u32 isoc_blksz;
/*
* Quads number for sync mode
* This variable can be confifured in ioctl
*/
u32 sync_quad;
/* Buffer depth in cdt */
u32 cdt_buf_dep;
/* Buffer depth in adt */
u32 adt_buf_dep;
/* Buffer size to hold data */
u32 buf_size;
};
struct mlb_data {
struct device *dev;
struct mlb_dev_info *devinfo;
#ifdef CONFIG_ARCH_MXC_ARM64
struct clk *ipg;
struct clk *hclk;
#endif
struct clk *mlb;
struct cdev cdev;
struct class *class; /* device class */
dev_t firstdev;
#ifdef CONFIG_REGULATOR
struct regulator *nvcc;
#endif
void __iomem *membase; /* mlb module base address */
struct gen_pool *iram_pool;
u32 iram_size;
int irq_ahb0;
int irq_ahb1;
int irq_mlb;
u32 quirk_flag;
bool use_iram;
};
/*
* For optimization, we use fixed channel label for
* input channels of each mode
* SYNC: CL = 0 for RX, CL = 64 for TX
* CTRL: CL = 1 for RX, CL = 65 for TX
* ASYNC: CL = 2 for RX, CL = 66 for TX
* ISOC: CL = 3 for RX, CL = 67 for TX
*/
#define SYNC_RX_CL_AHB0 0
#define CTRL_RX_CL_AHB0 1
#define ASYNC_RX_CL_AHB0 2
#define ISOC_RX_CL_AHB0 3
#define SYNC_TX_CL_AHB0 4
#define CTRL_TX_CL_AHB0 5
#define ASYNC_TX_CL_AHB0 6
#define ISOC_TX_CL_AHB0 7
#define SYNC_RX_CL_AHB1 32
#define CTRL_RX_CL_AHB1 33
#define ASYNC_RX_CL_AHB1 34
#define ISOC_RX_CL_AHB1 35
#define SYNC_TX_CL_AHB1 36
#define CTRL_TX_CL_AHB1 37
#define ASYNC_TX_CL_AHB1 38
#define ISOC_TX_CL_AHB1 39
#define SYNC_RX_CL SYNC_RX_CL_AHB0
#define CTRL_RX_CL CTRL_RX_CL_AHB0
#define ASYNC_RX_CL ASYNC_RX_CL_AHB0
#define ISOC_RX_CL ISOC_RX_CL_AHB0
#define SYNC_TX_CL SYNC_TX_CL_AHB0
#define CTRL_TX_CL CTRL_TX_CL_AHB0
#define ASYNC_TX_CL ASYNC_TX_CL_AHB0
#define ISOC_TX_CL ISOC_TX_CL_AHB0
static struct mlb_dev_info mlb_devinfo[MLB_MINOR_DEVICES] = {
{
.dev_name = MLB_SYNC_DEV_NAME,
.channel_type = MLB_CTYPE_SYNC,
.channels = {
[0] = {
.cl = SYNC_TX_CL,
.dbr_buf_head = CH_SYNC_DBR_BUF_OFFSET,
},
[1] = {
.cl = SYNC_RX_CL,
.dbr_buf_head = CH_SYNC_DBR_BUF_OFFSET
+ CH_SYNC_BUF_SZ,
},
},
.rx_rbuf = {
.unit_size = CH_SYNC_BUF_SZ,
.rb_lock =
__RW_LOCK_UNLOCKED(mlb_devinfo[0].rx_rbuf.rb_lock),
},
.tx_rbuf = {
.unit_size = CH_SYNC_BUF_SZ,
.rb_lock =
__RW_LOCK_UNLOCKED(mlb_devinfo[0].tx_rbuf.rb_lock),
},
.cdt_buf_dep = CH_SYNC_CDT_BUF_DEP,
.adt_buf_dep = CH_SYNC_ADT_BUF_DEP,
.buf_size = CH_SYNC_BUF_SZ,
.on = ATOMIC_INIT(0),
.opencnt = ATOMIC_INIT(0),
.event_lock = __SPIN_LOCK_UNLOCKED(mlb_devinfo[0].event_lock),
},
{
.dev_name = MLB_CONTROL_DEV_NAME,
.channel_type = MLB_CTYPE_CTRL,
.channels = {
[0] = {
.cl = CTRL_TX_CL,
.dbr_buf_head = CH_CTRL_DBR_BUF_OFFSET,
},
[1] = {
.cl = CTRL_RX_CL,
.dbr_buf_head = CH_CTRL_DBR_BUF_OFFSET
+ CH_CTRL_BUF_SZ,
},
},
.rx_rbuf = {
.unit_size = CH_CTRL_BUF_SZ,
.rb_lock =
__RW_LOCK_UNLOCKED(mlb_devinfo[1].rx_rbuf.rb_lock),
},
.tx_rbuf = {
.unit_size = CH_CTRL_BUF_SZ,
.rb_lock =
__RW_LOCK_UNLOCKED(mlb_devinfo[1].tx_rbuf.rb_lock),
},
.cdt_buf_dep = CH_CTRL_CDT_BUF_DEP,
.adt_buf_dep = CH_CTRL_ADT_BUF_DEP,
.buf_size = CH_CTRL_BUF_SZ,
.on = ATOMIC_INIT(0),
.opencnt = ATOMIC_INIT(0),
.event_lock = __SPIN_LOCK_UNLOCKED(mlb_devinfo[1].event_lock),
},
{
.dev_name = MLB_ASYNC_DEV_NAME,
.channel_type = MLB_CTYPE_ASYNC,
.channels = {
[0] = {
.cl = ASYNC_TX_CL,
.dbr_buf_head = CH_ASYNC_DBR_BUF_OFFSET,
},
[1] = {
.cl = ASYNC_RX_CL,
.dbr_buf_head = CH_ASYNC_DBR_BUF_OFFSET
+ CH_ASYNC_BUF_SZ,
},
},
.rx_rbuf = {
.unit_size = CH_ASYNC_BUF_SZ,
.rb_lock =
__RW_LOCK_UNLOCKED(mlb_devinfo[2].rx_rbuf.rb_lock),
},
.tx_rbuf = {
.unit_size = CH_ASYNC_BUF_SZ,
.rb_lock =
__RW_LOCK_UNLOCKED(mlb_devinfo[2].tx_rbuf.rb_lock),
},
.cdt_buf_dep = CH_ASYNC_CDT_BUF_DEP,
.adt_buf_dep = CH_ASYNC_ADT_BUF_DEP,
.buf_size = CH_ASYNC_BUF_SZ,
.on = ATOMIC_INIT(0),
.opencnt = ATOMIC_INIT(0),
.event_lock = __SPIN_LOCK_UNLOCKED(mlb_devinfo[2].event_lock),
},
{
.dev_name = MLB_ISOC_DEV_NAME,
.channel_type = MLB_CTYPE_ISOC,
.channels = {
[0] = {
.cl = ISOC_TX_CL,
.dbr_buf_head = CH_ISOC_DBR_BUF_OFFSET,
},
[1] = {
.cl = ISOC_RX_CL,
.dbr_buf_head = CH_ISOC_DBR_BUF_OFFSET
+ CH_ISOC_BUF_SZ,
},
},
.rx_rbuf = {
.unit_size = CH_ISOC_BUF_SZ,
.rb_lock =
__RW_LOCK_UNLOCKED(mlb_devinfo[3].rx_rbuf.rb_lock),
},
.tx_rbuf = {
.unit_size = CH_ISOC_BUF_SZ,
.rb_lock =
__RW_LOCK_UNLOCKED(mlb_devinfo[3].tx_rbuf.rb_lock),
},
.cdt_buf_dep = CH_ISOC_CDT_BUF_DEP,
.adt_buf_dep = CH_ISOC_ADT_BUF_DEP,
.buf_size = CH_ISOC_BUF_SZ,
.on = ATOMIC_INIT(0),
.opencnt = ATOMIC_INIT(0),
.event_lock = __SPIN_LOCK_UNLOCKED(mlb_devinfo[3].event_lock),
.isoc_blksz = CH_ISOC_BLK_SIZE_188,
},
};
static void __iomem *mlb_base;
DEFINE_SPINLOCK(ctr_lock);
#ifdef DEBUG
#define DUMP_REG(reg) pr_debug(#reg": 0x%08x\n", __raw_readl(mlb_base + reg))
static void mlb150_dev_dump_reg(void)
{
pr_debug("mxc_mlb150: Dump registers:\n");
DUMP_REG(REG_MLBC0);
DUMP_REG(REG_MLBPC0);
DUMP_REG(REG_MS0);
DUMP_REG(REG_MS1);
DUMP_REG(REG_MSS);
DUMP_REG(REG_MSD);
DUMP_REG(REG_MIEN);
DUMP_REG(REG_MLBPC2);
DUMP_REG(REG_MLBPC1);
DUMP_REG(REG_MLBC1);
DUMP_REG(REG_HCTL);
DUMP_REG(REG_HCMR0);
DUMP_REG(REG_HCMR1);
DUMP_REG(REG_HCER0);
DUMP_REG(REG_HCER1);
DUMP_REG(REG_HCBR0);
DUMP_REG(REG_HCBR1);
DUMP_REG(REG_MDAT0);
DUMP_REG(REG_MDAT1);
DUMP_REG(REG_MDAT2);
DUMP_REG(REG_MDAT3);
DUMP_REG(REG_MDWE0);
DUMP_REG(REG_MDWE1);
DUMP_REG(REG_MDWE2);
DUMP_REG(REG_MDWE3);
DUMP_REG(REG_MCTL);
DUMP_REG(REG_MADR);
DUMP_REG(REG_ACTL);
DUMP_REG(REG_ACSR0);
DUMP_REG(REG_ACSR1);
DUMP_REG(REG_ACMR0);
DUMP_REG(REG_ACMR1);
}
static void mlb150_dev_dump_hex(const u8 *buf, u32 len)
{
print_hex_dump(KERN_DEBUG, "CTR DUMP:",
DUMP_PREFIX_OFFSET, 8, 1, buf, len, 0);
}
#endif
static inline void mlb150_dev_enable_ctr_write(u32 mdat0_bits_en,
u32 mdat1_bits_en, u32 mdat2_bits_en, u32 mdat3_bits_en)
{
__raw_writel(mdat0_bits_en, mlb_base + REG_MDWE0);
__raw_writel(mdat1_bits_en, mlb_base + REG_MDWE1);
__raw_writel(mdat2_bits_en, mlb_base + REG_MDWE2);
__raw_writel(mdat3_bits_en, mlb_base + REG_MDWE3);
}
#ifdef DEBUG
static inline u8 mlb150_dev_dbr_read(u32 dbr_addr)
{
s32 timeout = 1000;
u8 dbr_val = 0;
unsigned long flags;
spin_lock_irqsave(&ctr_lock, flags);
__raw_writel(MADR_TB | dbr_addr,
mlb_base + REG_MADR);
while ((!(__raw_readl(mlb_base + REG_MCTL)
& MCTL_XCMP)) &&
timeout--)
;
if (0 == timeout) {
spin_unlock_irqrestore(&ctr_lock, flags);
return -ETIME;
}
dbr_val = __raw_readl(mlb_base + REG_MDAT0) & 0x000000ff;
__raw_writel(0, mlb_base + REG_MCTL);
spin_unlock_irqrestore(&ctr_lock, flags);
return dbr_val;
}
static inline s32 mlb150_dev_dbr_write(u32 dbr_addr, u8 dbr_val)
{
s32 timeout = 1000;
u32 mdat0 = dbr_val & 0x000000ff;
unsigned long flags;
spin_lock_irqsave(&ctr_lock, flags);
__raw_writel(mdat0, mlb_base + REG_MDAT0);
__raw_writel(MADR_WNR | MADR_TB | dbr_addr,
mlb_base + REG_MADR);
while ((!(__raw_readl(mlb_base + REG_MCTL)
& MCTL_XCMP)) &&
timeout--)
;
if (timeout <= 0) {
spin_unlock_irqrestore(&ctr_lock, flags);
return -ETIME;
}
__raw_writel(0, mlb_base + REG_MCTL);
spin_unlock_irqrestore(&ctr_lock, flags);
return 0;
}
static inline s32 mlb150_dev_dbr_dump(u32 addr, u32 size)
{
u8 *dump_buf = NULL;
u8 *buf_ptr = NULL;
s32 i;
dump_buf = kzalloc(size, GFP_KERNEL);
if (!dump_buf) {
pr_err("can't allocate enough memory\n");
return -ENOMEM;
}
for (i = 0, buf_ptr = dump_buf;
i < size; ++i, ++buf_ptr)
*buf_ptr = mlb150_dev_dbr_read(addr + i);
mlb150_dev_dump_hex(dump_buf, size);
kfree(dump_buf);
return 0;
}
#endif
static s32 mlb150_dev_ctr_read(u32 ctr_offset, u32 *ctr_val)
{
s32 timeout = 1000;
unsigned long flags;
spin_lock_irqsave(&ctr_lock, flags);
__raw_writel(ctr_offset, mlb_base + REG_MADR);
while ((!(__raw_readl(mlb_base + REG_MCTL)
& MCTL_XCMP)) &&
timeout--)
;
if (timeout <= 0) {
spin_unlock_irqrestore(&ctr_lock, flags);
pr_debug("mxc_mlb150: Read CTR timeout\n");
return -ETIME;
}
ctr_val[0] = __raw_readl(mlb_base + REG_MDAT0);
ctr_val[1] = __raw_readl(mlb_base + REG_MDAT1);
ctr_val[2] = __raw_readl(mlb_base + REG_MDAT2);
ctr_val[3] = __raw_readl(mlb_base + REG_MDAT3);
__raw_writel(0, mlb_base + REG_MCTL);
spin_unlock_irqrestore(&ctr_lock, flags);
return 0;
}
static s32 mlb150_dev_ctr_write(u32 ctr_offset, const u32 *ctr_val)
{
s32 timeout = 1000;
unsigned long flags;
spin_lock_irqsave(&ctr_lock, flags);
__raw_writel(ctr_val[0], mlb_base + REG_MDAT0);
__raw_writel(ctr_val[1], mlb_base + REG_MDAT1);
__raw_writel(ctr_val[2], mlb_base + REG_MDAT2);
__raw_writel(ctr_val[3], mlb_base + REG_MDAT3);
__raw_writel(MADR_WNR | ctr_offset,
mlb_base + REG_MADR);
while ((!(__raw_readl(mlb_base + REG_MCTL)
& MCTL_XCMP)) &&
timeout--)
;
if (timeout <= 0) {
spin_unlock_irqrestore(&ctr_lock, flags);
pr_debug("mxc_mlb150: Write CTR timeout\n");
return -ETIME;
}
__raw_writel(0, mlb_base + REG_MCTL);
spin_unlock_irqrestore(&ctr_lock, flags);
#ifdef DEBUG_CTR
{
u32 ctr_rd[4] = { 0 };
if (!mlb150_dev_ctr_read(ctr_offset, ctr_rd)) {
if (ctr_val[0] == ctr_rd[0] &&
ctr_val[1] == ctr_rd[1] &&
ctr_val[2] == ctr_rd[2] &&
ctr_val[3] == ctr_rd[3])
return 0;
else {
pr_debug("mxc_mlb150: ctr write failed\n");
pr_debug("offset: 0x%x\n", ctr_offset);
pr_debug("Write: 0x%x 0x%x 0x%x 0x%x\n",
ctr_val[3], ctr_val[2],
ctr_val[1], ctr_val[0]);
pr_debug("Read: 0x%x 0x%x 0x%x 0x%x\n",
ctr_rd[3], ctr_rd[2],
ctr_rd[1], ctr_rd[0]);
return -EBADE;
}
} else {
pr_debug("mxc_mlb150: ctr read failed\n");
return -EBADE;
}
}
#endif
return 0;
}
#ifdef DEBUG
static s32 mlb150_dev_cat_read(u32 ctr_offset, u32 ch, u16 *cat_val)
{
u16 ctr_val[8] = { 0 };
if (mlb150_dev_ctr_read(ctr_offset, (u32 *)ctr_val))
return -ETIME;
/*
* Use u16 array to get u32 array value,
* need to convert
*/
cat_val = ctr_val[ch % 8];
return 0;
}
#endif
static s32 mlb150_dev_cat_write(u32 ctr_offset, u32 ch, const u16 cat_val)
{
u16 ctr_val[8] = { 0 };
if (mlb150_dev_ctr_read(ctr_offset, (u32 *)ctr_val))
return -ETIME;
ctr_val[ch % 8] = cat_val;
if (mlb150_dev_ctr_write(ctr_offset, (u32 *)ctr_val))
return -ETIME;
return 0;
}
#define mlb150_dev_cat_mlb_read(ch, cat_val) \
mlb150_dev_cat_read(BUF_CAT_MLB_OFFSET + (ch >> 3), ch, cat_val)
#define mlb150_dev_cat_mlb_write(ch, cat_val) \
mlb150_dev_cat_write(BUF_CAT_MLB_OFFSET + (ch >> 3), ch, cat_val)
#define mlb150_dev_cat_hbi_read(ch, cat_val) \
mlb150_dev_cat_read(BUF_CAT_HBI_OFFSET + (ch >> 3), ch, cat_val)
#define mlb150_dev_cat_hbi_write(ch, cat_val) \
mlb150_dev_cat_write(BUF_CAT_HBI_OFFSET + (ch >> 3), ch, cat_val)
#define mlb150_dev_cdt_read(ch, cdt_val) \
mlb150_dev_ctr_read(BUF_CDT_OFFSET + ch, cdt_val)
#define mlb150_dev_cdt_write(ch, cdt_val) \
mlb150_dev_ctr_write(BUF_CDT_OFFSET + ch, cdt_val)
#define mlb150_dev_adt_read(ch, adt_val) \
mlb150_dev_ctr_read(BUF_ADT_OFFSET + ch, adt_val)
#define mlb150_dev_adt_write(ch, adt_val) \
mlb150_dev_ctr_write(BUF_ADT_OFFSET + ch, adt_val)
static s32 mlb150_dev_get_adt_sts(u32 ch)
{
s32 timeout = 1000;
unsigned long flags;
u32 reg;
spin_lock_irqsave(&ctr_lock, flags);
__raw_writel(BUF_ADT_OFFSET + ch,
mlb_base + REG_MADR);
while ((!(__raw_readl(mlb_base + REG_MCTL)
& MCTL_XCMP)) &&
timeout--)
;
if (timeout <= 0) {
spin_unlock_irqrestore(&ctr_lock, flags);
pr_debug("mxc_mlb150: Read CTR timeout\n");
return -ETIME;
}
reg = __raw_readl(mlb_base + REG_MDAT1);
__raw_writel(0, mlb_base + REG_MCTL);
spin_unlock_irqrestore(&ctr_lock, flags);
#ifdef DEBUG_ADT
pr_debug("mxc_mlb150: Get ch %d adt sts: 0x%08x\n", ch, reg);
#endif
return reg;
}
#ifdef DEBUG
static void mlb150_dev_dump_ctr_tbl(u32 ch_start, u32 ch_end)
{
u32 i = 0;
u32 ctr_val[4] = { 0 };
pr_debug("mxc_mlb150: CDT Table");
for (i = BUF_CDT_OFFSET + ch_start;
i < BUF_CDT_OFFSET + ch_end;
++i) {
mlb150_dev_ctr_read(i, ctr_val);
pr_debug("CTR 0x%02x: 0x%08x, 0x%08x, 0x%08x, 0x%08x\n",
i, ctr_val[3], ctr_val[2], ctr_val[1], ctr_val[0]);
}
pr_debug("mxc_mlb150: ADT Table");
for (i = BUF_ADT_OFFSET + ch_start;
i < BUF_ADT_OFFSET + ch_end;
++i) {
mlb150_dev_ctr_read(i, ctr_val);
pr_debug("CTR 0x%02x: 0x%08x, 0x%08x, 0x%08x, 0x%08x\n",
i, ctr_val[3], ctr_val[2], ctr_val[1], ctr_val[0]);
}
pr_debug("mxc_mlb150: CAT MLB Table");
for (i = BUF_CAT_MLB_OFFSET + (ch_start >> 3);
i <= BUF_CAT_MLB_OFFSET + ((ch_end + 8) >> 3);
++i) {
mlb150_dev_ctr_read(i, ctr_val);
pr_debug("CTR 0x%02x: 0x%08x, 0x%08x, 0x%08x, 0x%08x\n",
i, ctr_val[3], ctr_val[2], ctr_val[1], ctr_val[0]);
}
pr_debug("mxc_mlb150: CAT HBI Table");
for (i = BUF_CAT_HBI_OFFSET + (ch_start >> 3);
i <= BUF_CAT_HBI_OFFSET + ((ch_end + 8) >> 3);
++i) {
mlb150_dev_ctr_read(i, ctr_val);
pr_debug("CTR 0x%02x: 0x%08x, 0x%08x, 0x%08x, 0x%08x\n",
i, ctr_val[3], ctr_val[2], ctr_val[1], ctr_val[0]);
}
}
#endif
/*
* Initial the MLB module device
*/
static inline void mlb150_dev_enable_dma_irq(u32 enable)
{
u32 ch_rx_mask = (1 << SYNC_RX_CL_AHB0) | (1 << CTRL_RX_CL_AHB0)
| (1 << ASYNC_RX_CL_AHB0) | (1 << ISOC_RX_CL_AHB0)
| (1 << SYNC_TX_CL_AHB0) | (1 << CTRL_TX_CL_AHB0)
| (1 << ASYNC_TX_CL_AHB0) | (1 << ISOC_TX_CL_AHB0);
u32 ch_tx_mask = (1 << (SYNC_RX_CL_AHB1 - INT_AHB1_CH_START)) |
(1 << (CTRL_RX_CL_AHB1 - INT_AHB1_CH_START)) |
(1 << (ASYNC_RX_CL_AHB1 - INT_AHB1_CH_START)) |
(1 << (ISOC_RX_CL_AHB1 - INT_AHB1_CH_START)) |
(1 << (SYNC_TX_CL_AHB1 - INT_AHB1_CH_START)) |
(1 << (CTRL_TX_CL_AHB1 - INT_AHB1_CH_START)) |
(1 << (ASYNC_TX_CL_AHB1 - INT_AHB1_CH_START)) |
(1 << (ISOC_TX_CL_AHB1 - INT_AHB1_CH_START));
if (enable) {
__raw_writel(ch_rx_mask, mlb_base + REG_ACMR0);
__raw_writel(ch_tx_mask, mlb_base + REG_ACMR1);
} else {
__raw_writel(0x0, mlb_base + REG_ACMR0);
__raw_writel(0x0, mlb_base + REG_ACMR1);
}
}
static void mlb150_dev_init_ir_amba_ahb(void)
{
u32 reg = 0;
/*
* Step 1. Program the ACMRn registers to enable interrupts from all
* active DMA channels
*/
mlb150_dev_enable_dma_irq(1);
/*
* Step 2. Select the status clear method:
* ACTL.SCE = 0, hardware clears on read
* ACTL.SCE = 1, software writes a '1' to clear
* We only support DMA MODE 1
*/
reg = __raw_readl(mlb_base + REG_ACTL);
reg |= ACTL_DMAMODE;
#ifdef MULTIPLE_PACKAGE_MODE
reg |= REG_ACTL_MPB;
#endif
/*
* Step 3. Select 1 or 2 interrupt signals:
* ACTL.SMX = 0: one interrupt for channels 0 - 31 on ahb_init[0]
* and another interrupt for channels 32 - 63 on ahb_init[1]
* ACTL.SMX = 1: singel interrupt all channels on ahb_init[0]
*/
reg &= ~ACTL_SMX;
__raw_writel(reg, mlb_base + REG_ACTL);
}
static inline void mlb150_dev_enable_ir_mlb(u32 enable)
{
/*
* Step 1, Select the MSn to be cleared by software,
* writing a '0' to the appropriate bits
*/
__raw_writel(0, mlb_base + REG_MS0);
__raw_writel(0, mlb_base + REG_MS1);
/*
* Step 1, Program MIEN to enable protocol error
* interrupts for all active MLB channels
*/
if (enable)
__raw_writel(MIEN_CTX_PE |
MIEN_CRX_PE | MIEN_ATX_PE |
MIEN_ARX_PE | MIEN_SYNC_PE |
MIEN_ISOC_PE,
mlb_base + REG_MIEN);
else
__raw_writel(0, mlb_base + REG_MIEN);
}
static inline void mlb150_enable_pll(struct mlb_data *drvdata)
{
u32 c0_val;
__raw_writel(MLBPC1_VAL,
drvdata->membase + REG_MLBPC1);
c0_val = __raw_readl(drvdata->membase + REG_MLBC0);
if (c0_val & MLBC0_MLBPEN) {
c0_val &= ~MLBC0_MLBPEN;
__raw_writel(c0_val,
drvdata->membase + REG_MLBC0);
}
c0_val |= (MLBC0_MLBPEN);
__raw_writel(c0_val, drvdata->membase + REG_MLBC0);
}
static inline void mlb150_disable_pll(struct mlb_data *drvdata)
{
u32 c0_val;
c0_val = __raw_readl(drvdata->membase + REG_MLBC0);
__raw_writel(0x0, drvdata->membase + REG_MLBPC1);
c0_val &= ~MLBC0_MLBPEN;
__raw_writel(c0_val, drvdata->membase + REG_MLBC0);
}
static void mlb150_dev_reset_cdt(void)
{
int i = 0;
u32 ctr_val[4] = { 0 };
mlb150_dev_enable_ctr_write(0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff);
for (i = 0; i < (LOGIC_CH_NUM); ++i)
mlb150_dev_ctr_write(BUF_CDT_OFFSET + i, ctr_val);
}
static s32 mlb150_dev_init_ch_cdt(struct mlb_dev_info *pdevinfo, u32 ch,
enum MLB_CTYPE ctype, u32 ch_func)
{
u32 cdt_val[4] = { 0 };
/* a. Set the 14-bit base address (BA) */
pr_debug("mxc_mlb150: ctype: %d, ch: %d, dbr_buf_head: 0x%08x",
ctype, ch, pdevinfo->channels[ch_func].dbr_buf_head);
cdt_val[3] = (pdevinfo->channels[ch_func].dbr_buf_head)
<< CDT_BA_SHIFT;
/*
* b. Set the 12-bit or 13-bit buffer depth (BD)
* BD = buffer depth in bytes - 1
* For synchronous channels: (BD + 1) = 4 * m * bpf
* For control channels: (BD + 1) >= max packet length (64)
* For asynchronous channels: (BD + 1) >= max packet length
* 1024 for a MOST Data packet (MDP);
* 1536 for a MOST Ethernet Packet (MEP)
* For isochronous channels: (BD + 1) mod (BS + 1) = 0
* BS
*/
if (MLB_CTYPE_ISOC == ctype)
cdt_val[1] |= (pdevinfo->isoc_blksz - 1);
/* BD */
cdt_val[3] |= (pdevinfo->cdt_buf_dep - 1) << CDT_BD_SHIFT;
pr_debug("mxc_mlb150: Set CDT val of channel %d, type: %d: "
"0x%08x 0x%08x 0x%08x 0x%08x\n",
ch, ctype, cdt_val[3], cdt_val[2], cdt_val[1], cdt_val[0]);
if (mlb150_dev_cdt_write(ch, cdt_val))
return -ETIME;
#ifdef DEBUG_CTR
{
u32 cdt_rd[4] = { 0 };
if (!mlb150_dev_cdt_read(ch, cdt_rd)) {
pr_debug("mxc_mlb150: CDT val of channel %d: "
"0x%08x 0x%08x 0x%08x 0x%08x\n",
ch, cdt_rd[3], cdt_rd[2], cdt_rd[1], cdt_rd[0]);
if (cdt_rd[3] == cdt_val[3] &&
cdt_rd[2] == cdt_val[2] &&
cdt_rd[1] == cdt_val[1] &&
cdt_rd[0] == cdt_val[0]) {
pr_debug("mxc_mlb150: set cdt succeed!\n");
return 0;
} else {
pr_debug("mxc_mlb150: set cdt failed!\n");
return -EBADE;
}
} else {
pr_debug("mxc_mlb150: Read CDT val of channel %d failed\n",
ch);
return -EBADE;
}
}
#endif
return 0;
}
static s32 mlb150_dev_init_ch_cat(u32 ch, u32 cl,
u32 cat_mode, enum MLB_CTYPE ctype)
{
u16 cat_val = 0;
#ifdef DEBUG_CTR
u16 cat_rd = 0;
#endif
cat_val = CAT_CE | (ctype << CAT_CT_SHIFT) | cl;
if (cat_mode & CAT_MODE_OUTBOUND_DMA)
cat_val |= CAT_RNW;
if (MLB_CTYPE_SYNC == ctype)
cat_val |= CAT_MT;
switch (cat_mode) {
case CAT_MODE_RX | CAT_MODE_INBOUND_DMA:
case CAT_MODE_TX | CAT_MODE_OUTBOUND_DMA:
pr_debug("mxc_mlb150: set CAT val of channel %d, type: %d: 0x%04x\n",
ch, ctype, cat_val);
if (mlb150_dev_cat_mlb_write(ch, cat_val))
return -ETIME;
#ifdef DEBUG_CTR
if (!mlb150_dev_cat_mlb_read(ch, &cat_rd))
pr_debug("mxc_mlb150: CAT val of mlb channel %d: 0x%04x",
ch, cat_rd);
else {
pr_debug("mxc_mlb150: Read CAT of mlb channel %d failed\n",
ch);
return -EBADE;
}
#endif
break;
case CAT_MODE_TX | CAT_MODE_INBOUND_DMA:
case CAT_MODE_RX | CAT_MODE_OUTBOUND_DMA:
pr_debug("mxc_mlb150: set CAT val of channel %d, type: %d: 0x%04x\n",
cl, ctype, cat_val);
if (mlb150_dev_cat_hbi_write(cl, cat_val))
return -ETIME;
#ifdef DEBUG_CTR
if (!mlb150_dev_cat_hbi_read(cl, &cat_rd))
pr_debug("mxc_mlb150: CAT val of hbi channel %d: 0x%04x",
cl, cat_rd);
else {
pr_debug("mxc_mlb150: Read CAT of hbi channel %d failed\n",
cl);
return -EBADE;
}
#endif
break;
default:
return EBADRQC;
}
#ifdef DEBUG_CTR
{
if (cat_val == cat_rd) {
pr_debug("mxc_mlb150: set cat succeed!\n");
return 0;
} else {
pr_debug("mxc_mlb150: set cat failed!\n");
return -EBADE;
}
}
#endif
return 0;
}
static void mlb150_dev_reset_cat(void)
{
int i = 0;
u32 ctr_val[4] = { 0 };
mlb150_dev_enable_ctr_write(0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff);
for (i = 0; i < (LOGIC_CH_NUM >> 3); ++i) {
mlb150_dev_ctr_write(BUF_CAT_MLB_OFFSET + i, ctr_val);
mlb150_dev_ctr_write(BUF_CAT_HBI_OFFSET + i, ctr_val);
}
}
static void mlb150_dev_init_rfb(struct mlb_dev_info *pdevinfo, u32 rx_ch,
u32 tx_ch, enum MLB_CTYPE ctype)
{
u32 rx_cl = pdevinfo->channels[RX_CHANNEL].cl;
u32 tx_cl = pdevinfo->channels[TX_CHANNEL].cl;
/* Step 1, Initialize all bits of CAT to '0' */
mlb150_dev_reset_cat();
mlb150_dev_reset_cdt();
/*
* Step 2, Initialize logical channel
* Step 3, Program the CDT for channel N
*/
mlb150_dev_init_ch_cdt(pdevinfo, rx_cl, ctype, RX_CHANNEL);
mlb150_dev_init_ch_cdt(pdevinfo, tx_cl, ctype, TX_CHANNEL);
/* Step 4&5, Program the CAT for the inbound and outbound DMA */
mlb150_dev_init_ch_cat(rx_ch, rx_cl,
CAT_MODE_RX | CAT_MODE_INBOUND_DMA,
ctype);
mlb150_dev_init_ch_cat(rx_ch, rx_cl,
CAT_MODE_RX | CAT_MODE_OUTBOUND_DMA,
ctype);
mlb150_dev_init_ch_cat(tx_ch, tx_cl,
CAT_MODE_TX | CAT_MODE_INBOUND_DMA,
ctype);
mlb150_dev_init_ch_cat(tx_ch, tx_cl,
CAT_MODE_TX | CAT_MODE_OUTBOUND_DMA,
ctype);
}
static void mlb150_dev_reset_adt(void)
{
int i = 0;
u32 ctr_val[4] = { 0 };
mlb150_dev_enable_ctr_write(0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff);
for (i = 0; i < (LOGIC_CH_NUM); ++i)
mlb150_dev_ctr_write(BUF_ADT_OFFSET + i, ctr_val);
}
static void mlb150_dev_reset_whole_ctr(void)
{
mlb150_dev_enable_ctr_write(0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff);
mlb150_dev_reset_cdt();
mlb150_dev_reset_adt();
mlb150_dev_reset_cat();
}
#define CLR_REG(reg) __raw_writel(0x0, mlb_base + reg)
static void mlb150_dev_reset_all_regs(void)
{
CLR_REG(REG_MLBC0);
CLR_REG(REG_MLBPC0);
CLR_REG(REG_MS0);
CLR_REG(REG_MS1);
CLR_REG(REG_MSS);
CLR_REG(REG_MSD);
CLR_REG(REG_MIEN);
CLR_REG(REG_MLBPC2);
CLR_REG(REG_MLBPC1);
CLR_REG(REG_MLBC1);
CLR_REG(REG_HCTL);
CLR_REG(REG_HCMR0);
CLR_REG(REG_HCMR1);
CLR_REG(REG_HCER0);
CLR_REG(REG_HCER1);
CLR_REG(REG_HCBR0);
CLR_REG(REG_HCBR1);
CLR_REG(REG_MDAT0);
CLR_REG(REG_MDAT1);
CLR_REG(REG_MDAT2);
CLR_REG(REG_MDAT3);
CLR_REG(REG_MDWE0);
CLR_REG(REG_MDWE1);
CLR_REG(REG_MDWE2);
CLR_REG(REG_MDWE3);
CLR_REG(REG_MCTL);
CLR_REG(REG_MADR);
CLR_REG(REG_ACTL);
CLR_REG(REG_ACSR0);
CLR_REG(REG_ACSR1);
CLR_REG(REG_ACMR0);
CLR_REG(REG_ACMR1);
}
static inline s32 mlb150_dev_pipo_start(struct mlb_ringbuf *rbuf,
u32 ahb_ch, u32 buf_addr)
{
u32 ctr_val[4] = { 0 };
ctr_val[1] |= ADT_RDY1;
ctr_val[2] = buf_addr;
if (mlb150_dev_adt_write(ahb_ch, ctr_val))
return -ETIME;
return 0;
}
static inline s32 mlb150_dev_pipo_next(u32 ahb_ch, enum MLB_CTYPE ctype,
u32 dne_sts, u32 buf_addr)
{
u32 ctr_val[4] = { 0 };
if (MLB_CTYPE_ASYNC == ctype ||
MLB_CTYPE_CTRL == ctype) {
ctr_val[1] |= ADT_PS1;
ctr_val[1] |= ADT_PS2;
}
/*
* Clear DNE1 and ERR1
* Set the page ready bit (RDY1)
*/
if (dne_sts & ADT_DNE1) {
ctr_val[1] |= ADT_RDY2;
ctr_val[3] = buf_addr;
} else {
ctr_val[1] |= ADT_RDY1;
ctr_val[2] = buf_addr;
}
if (mlb150_dev_adt_write(ahb_ch, ctr_val))
return -ETIME;
return 0;
}
static inline s32 mlb150_dev_pipo_stop(struct mlb_ringbuf *rbuf, u32 ahb_ch)
{
u32 ctr_val[4] = { 0 };
unsigned long flags;
write_lock_irqsave(&rbuf->rb_lock, flags);
rbuf->head = rbuf->tail = 0;
write_unlock_irqrestore(&rbuf->rb_lock, flags);
if (mlb150_dev_adt_write(ahb_ch, ctr_val))
return -ETIME;
return 0;
}
static s32 mlb150_dev_init_ch_amba_ahb(struct mlb_dev_info *pdevinfo,
struct mlb_channel_info *chinfo,
enum MLB_CTYPE ctype)
{
u32 ctr_val[4] = { 0 };
/* a. Set the 32-bit base address (BA1) */
ctr_val[3] = 0;
ctr_val[2] = 0;
ctr_val[1] = (pdevinfo->adt_buf_dep - 1) << ADT_BD1_SHIFT;
ctr_val[1] |= (pdevinfo->adt_buf_dep - 1) << ADT_BD2_SHIFT;
if (MLB_CTYPE_ASYNC == ctype ||
MLB_CTYPE_CTRL == ctype) {
ctr_val[1] |= ADT_PS1;
ctr_val[1] |= ADT_PS2;
}
ctr_val[0] |= (ADT_LE | ADT_CE);
pr_debug("mxc_mlb150: Set ADT val of channel %d, ctype: %d: "
"0x%08x 0x%08x 0x%08x 0x%08x\n",
chinfo->cl, ctype, ctr_val[3], ctr_val[2],
ctr_val[1], ctr_val[0]);
if (mlb150_dev_adt_write(chinfo->cl, ctr_val))
return -ETIME;
#ifdef DEBUG_CTR
{
u32 ctr_rd[4] = { 0 };
if (!mlb150_dev_adt_read(chinfo->cl, ctr_rd)) {
pr_debug("mxc_mlb150: ADT val of channel %d: "
"0x%08x 0x%08x 0x%08x 0x%08x\n",
chinfo->cl, ctr_rd[3], ctr_rd[2],
ctr_rd[1], ctr_rd[0]);
if (ctr_rd[3] == ctr_val[3] &&
ctr_rd[2] == ctr_val[2] &&
ctr_rd[1] == ctr_val[1] &&
ctr_rd[0] == ctr_val[0]) {
pr_debug("mxc_mlb150: set adt succeed!\n");
return 0;
} else {
pr_debug("mxc_mlb150: set adt failed!\n");
return -EBADE;
}
} else {
pr_debug("mxc_mlb150: Read ADT val of channel %d failed\n",
chinfo->cl);
return -EBADE;
}
}
#endif
return 0;
}
static void mlb150_dev_init_amba_ahb(struct mlb_dev_info *pdevinfo,
enum MLB_CTYPE ctype)
{
struct mlb_channel_info *tx_chinfo = &pdevinfo->channels[TX_CHANNEL];
struct mlb_channel_info *rx_chinfo = &pdevinfo->channels[RX_CHANNEL];
/* Step 1, Initialize all bits of the ADT to '0' */
mlb150_dev_reset_adt();
/*
* Step 2, Select a logic channel
* Step 3, Program the AMBA AHB block ping page for channel N
* Step 4, Program the AMBA AHB block pong page for channel N
*/
mlb150_dev_init_ch_amba_ahb(pdevinfo, rx_chinfo, ctype);
mlb150_dev_init_ch_amba_ahb(pdevinfo, tx_chinfo, ctype);
}
static void mlb150_dev_exit(void)
{
u32 c0_val, hctl_val;
/* Disable EN bits */
c0_val = __raw_readl(mlb_base + REG_MLBC0);
c0_val &= ~(MLBC0_MLBEN | MLBC0_MLBPEN);
__raw_writel(c0_val, mlb_base + REG_MLBC0);
hctl_val = __raw_readl(mlb_base + REG_HCTL);
hctl_val &= ~HCTL_EN;
__raw_writel(hctl_val, mlb_base + REG_HCTL);
__raw_writel(0x0, mlb_base + REG_HCMR0);
__raw_writel(0x0, mlb_base + REG_HCMR1);
mlb150_dev_enable_dma_irq(0);
mlb150_dev_enable_ir_mlb(0);
}
static void mlb150_dev_init(void)
{
u32 c0_val;
u32 ch_rx_mask = (1 << SYNC_RX_CL_AHB0) | (1 << CTRL_RX_CL_AHB0)
| (1 << ASYNC_RX_CL_AHB0) | (1 << ISOC_RX_CL_AHB0)
| (1 << SYNC_TX_CL_AHB0) | (1 << CTRL_TX_CL_AHB0)
| (1 << ASYNC_TX_CL_AHB0) | (1 << ISOC_TX_CL_AHB0);
u32 ch_tx_mask = (1 << (SYNC_RX_CL_AHB1 - INT_AHB1_CH_START)) |
(1 << (CTRL_RX_CL_AHB1 - INT_AHB1_CH_START)) |
(1 << (ASYNC_RX_CL_AHB1 - INT_AHB1_CH_START)) |
(1 << (ISOC_RX_CL_AHB1 - INT_AHB1_CH_START)) |
(1 << (SYNC_TX_CL_AHB1 - INT_AHB1_CH_START)) |
(1 << (CTRL_TX_CL_AHB1 - INT_AHB1_CH_START)) |
(1 << (ASYNC_TX_CL_AHB1 - INT_AHB1_CH_START)) |
(1 << (ISOC_TX_CL_AHB1 - INT_AHB1_CH_START));
/* Disable EN bits */
mlb150_dev_exit();
/*
* Step 1. Initialize CTR and registers
* a. Set all bit of the CTR (CAT, CDT, and ADT) to 0.
*/
mlb150_dev_reset_whole_ctr();
/* a. Set all bit of the CTR (CAT, CDT, and ADT) to 0. */
mlb150_dev_reset_all_regs();
/*
* Step 2, Configure the MediaLB interface
* Select pin mode and clock, 3-pin and 256fs
*/
c0_val = __raw_readl(mlb_base + REG_MLBC0);
c0_val &= ~(MLBC0_MLBPEN | MLBC0_MLBCLK_MASK);
__raw_writel(c0_val, mlb_base + REG_MLBC0);
c0_val |= MLBC0_MLBEN;
__raw_writel(c0_val, mlb_base + REG_MLBC0);
/* Step 3, Configure the HBI interface */
__raw_writel(ch_rx_mask, mlb_base + REG_HCMR0);
__raw_writel(ch_tx_mask, mlb_base + REG_HCMR1);
__raw_writel(HCTL_EN, mlb_base + REG_HCTL);
mlb150_dev_init_ir_amba_ahb();
mlb150_dev_enable_ir_mlb(1);
}
static s32 mlb150_dev_unmute_syn_ch(u32 rx_ch, u32 rx_cl, u32 tx_ch, u32 tx_cl)
{
u32 timeout = 10000;
/*
* Check that MediaLB clock is running (MLBC1.CLKM = 0)
* If MLBC1.CLKM = 1, clear the register bit, wait one
* APB or I/O clock cycle and repeat the check
*/
while ((__raw_readl(mlb_base + REG_MLBC1) & MLBC1_CLKM)
&& --timeout)
__raw_writel(~MLBC1_CLKM, mlb_base + REG_MLBC1);
if (0 == timeout)
return -ETIME;
timeout = 10000;
/* Poll for MLB lock (MLBC0.MLBLK = 1) */
while (!(__raw_readl(mlb_base + REG_MLBC0) & MLBC0_MLBLK)
&& --timeout)
;
if (0 == timeout)
return -ETIME;
/* Unmute synchronous channel(s) */
mlb150_dev_cat_mlb_write(rx_ch, CAT_CE | rx_cl);
mlb150_dev_cat_mlb_write(tx_ch,
CAT_CE | tx_cl | CAT_RNW);
mlb150_dev_cat_hbi_write(rx_cl,
CAT_CE | rx_cl | CAT_RNW);
mlb150_dev_cat_hbi_write(tx_cl, CAT_CE | tx_cl);
return 0;
}
/* In case the user calls channel shutdown, but rx or tx is not completed yet */
static s32 mlb150_trans_complete_check(struct mlb_dev_info *pdevinfo)
{
struct mlb_ringbuf *rx_rbuf = &pdevinfo->rx_rbuf;
struct mlb_ringbuf *tx_rbuf = &pdevinfo->tx_rbuf;
s32 timeout = 1024;
while (timeout--) {
read_lock(&tx_rbuf->rb_lock);
if (!CIRC_CNT(tx_rbuf->head, tx_rbuf->tail, TRANS_RING_NODES)) {
read_unlock(&tx_rbuf->rb_lock);
break;
} else
read_unlock(&tx_rbuf->rb_lock);
}
if (timeout <= 0) {
pr_debug("TX complete check timeout!\n");
return -ETIME;
}
timeout = 1024;
while (timeout--) {
read_lock(&rx_rbuf->rb_lock);
if (!CIRC_CNT(rx_rbuf->head, rx_rbuf->tail, TRANS_RING_NODES)) {
read_unlock(&rx_rbuf->rb_lock);
break;
} else
read_unlock(&rx_rbuf->rb_lock);
}
if (timeout <= 0) {
pr_debug("RX complete check timeout!\n");
return -ETIME;
}
/*
* Interrupt from TX can only inform that the data is sent
* to AHB bus, not mean that it is sent to MITB. Thus we add
* a delay here for data to be completed sent.
*/
udelay(1000);
return 0;
}
/*
* Enable/Disable the MLB IRQ
*/
static void mxc_mlb150_irq_enable(struct mlb_data *drvdata, u8 enable)
{
if (enable) {
enable_irq(drvdata->irq_ahb0);
enable_irq(drvdata->irq_mlb);
if (drvdata->irq_ahb1 > 0)
enable_irq(drvdata->irq_ahb1);
} else {
disable_irq(drvdata->irq_ahb0);
disable_irq(drvdata->irq_mlb);
if (drvdata->irq_ahb1 > 0)
disable_irq(drvdata->irq_ahb1);
}
}
/*
* Enable the MLB channel
*/
static s32 mlb_channel_enable(struct mlb_data *drvdata,
int chan_dev_id, int on)
{
struct mlb_dev_info *pdevinfo = drvdata->devinfo;
struct mlb_channel_info *tx_chinfo = &pdevinfo->channels[TX_CHANNEL];
struct mlb_channel_info *rx_chinfo = &pdevinfo->channels[RX_CHANNEL];
u32 tx_ch = tx_chinfo->address;
u32 rx_ch = rx_chinfo->address;
u32 tx_cl = tx_chinfo->cl;
u32 rx_cl = rx_chinfo->cl;
s32 ret = 0;
/*
* setup the direction, enable, channel type,
* mode select, channel address and mask buf start
*/
if (on) {
u32 ctype = pdevinfo->channel_type;
mlb150_dev_enable_ctr_write(0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff);
mlb150_dev_init_rfb(pdevinfo, rx_ch, tx_ch, ctype);
mlb150_dev_init_amba_ahb(pdevinfo, ctype);
#ifdef DEBUG
mlb150_dev_dump_ctr_tbl(0, tx_chinfo->cl + 1);
#endif
/* Synchronize and unmute synchrouous channel */
if (MLB_CTYPE_SYNC == ctype) {
ret = mlb150_dev_unmute_syn_ch(rx_ch, rx_cl,
tx_ch, tx_cl);
if (ret)
return ret;
}
mlb150_dev_enable_ctr_write(0x0, ADT_RDY1 | ADT_DNE1 |
ADT_ERR1 | ADT_PS1 |
ADT_RDY2 | ADT_DNE2 | ADT_ERR2 | ADT_PS2,
0xffffffff, 0xffffffff);
if (pdevinfo->fps >= CLK_2048FS)
mlb150_enable_pll(drvdata);
atomic_set(&pdevinfo->on, 1);
#ifdef DEBUG
mlb150_dev_dump_reg();
mlb150_dev_dump_ctr_tbl(0, tx_chinfo->cl + 1);
#endif
/* Init RX ADT */
mlb150_dev_pipo_start(&pdevinfo->rx_rbuf, rx_cl,
pdevinfo->rx_rbuf.phy_addrs[0]);
} else {
mlb150_dev_pipo_stop(&pdevinfo->rx_rbuf, rx_cl);
mlb150_dev_enable_dma_irq(0);
mlb150_dev_enable_ir_mlb(0);
mlb150_dev_reset_cat();
atomic_set(&pdevinfo->on, 0);
if (pdevinfo->fps >= CLK_2048FS)
mlb150_disable_pll(drvdata);
}
return 0;
}
/*
* MLB interrupt handler
*/
static void mlb_rx_isr(s32 ctype, u32 ahb_ch, struct mlb_dev_info *pdevinfo)
{
struct mlb_ringbuf *rx_rbuf = &pdevinfo->rx_rbuf;
s32 head, tail, adt_sts;
u32 rx_buf_ptr;
#ifdef DEBUG_RX
pr_debug("mxc_mlb150: mlb_rx_isr\n");
#endif
read_lock(&rx_rbuf->rb_lock);
head = (rx_rbuf->head + 1) & (TRANS_RING_NODES - 1);
tail = ACCESS_ONCE(rx_rbuf->tail);
read_unlock(&rx_rbuf->rb_lock);
if (CIRC_SPACE(head, tail, TRANS_RING_NODES) >= 1) {
rx_buf_ptr = rx_rbuf->phy_addrs[head];
/* commit the item before incrementing the head */
smp_wmb();
write_lock(&rx_rbuf->rb_lock);
rx_rbuf->head = head;
write_unlock(&rx_rbuf->rb_lock);
/* wake up the reader */
wake_up_interruptible(&pdevinfo->rx_wq);
} else {
rx_buf_ptr = rx_rbuf->phy_addrs[head];
pr_debug("drop RX package, due to no space, (%d,%d)\n",
head, tail);
}
adt_sts = mlb150_dev_get_adt_sts(ahb_ch);
/* Set ADT for RX */
mlb150_dev_pipo_next(ahb_ch, ctype, adt_sts, rx_buf_ptr);
}
static void mlb_tx_isr(s32 ctype, u32 ahb_ch, struct mlb_dev_info *pdevinfo)
{
struct mlb_ringbuf *tx_rbuf = &pdevinfo->tx_rbuf;
s32 head, tail, adt_sts;
u32 tx_buf_ptr;
read_lock(&tx_rbuf->rb_lock);
head = ACCESS_ONCE(tx_rbuf->head);
tail = (tx_rbuf->tail + 1) & (TRANS_RING_NODES - 1);
read_unlock(&tx_rbuf->rb_lock);
smp_mb();
write_lock(&tx_rbuf->rb_lock);
tx_rbuf->tail = tail;
write_unlock(&tx_rbuf->rb_lock);
/* check the current tx buffer is available or not */
if (CIRC_CNT(head, tail, TRANS_RING_NODES) >= 1) {
/* read index before reading contents at that index */
smp_read_barrier_depends();
tx_buf_ptr = tx_rbuf->phy_addrs[tail];
wake_up_interruptible(&pdevinfo->tx_wq);
adt_sts = mlb150_dev_get_adt_sts(ahb_ch);
/* Set ADT for TX */
mlb150_dev_pipo_next(ahb_ch, ctype, adt_sts, tx_buf_ptr);
}
}
static irqreturn_t mlb_ahb_isr(int irq, void *dev_id)
{
u32 acsr0, hcer0;
u32 ch_mask = (1 << SYNC_RX_CL) | (1 << CTRL_RX_CL)
| (1 << ASYNC_RX_CL) | (1 << ISOC_RX_CL)
| (1 << SYNC_TX_CL) | (1 << CTRL_TX_CL)
| (1 << ASYNC_TX_CL) | (1 << ISOC_TX_CL);
/*
* Step 5, Read the ACSRn registers to determine which channel or
* channels are causing the interrupt
*/
acsr0 = __raw_readl(mlb_base + REG_ACSR0);
hcer0 = __raw_readl(mlb_base + REG_HCER0);
/*
* Step 6, If ACTL.SCE = 1, write the result of step 5 back to ACSR0
* and ACSR1 to clear the interrupt
* We'll not set ACTL_SCE
*/
if (ch_mask & hcer0)
pr_err("CH encounters an AHB error: 0x%x\n", hcer0);
if ((1 << SYNC_RX_CL) & acsr0)
mlb_rx_isr(MLB_CTYPE_SYNC, SYNC_RX_CL,
&mlb_devinfo[MLB_CTYPE_SYNC]);
if ((1 << CTRL_RX_CL) & acsr0)
mlb_rx_isr(MLB_CTYPE_CTRL, CTRL_RX_CL,
&mlb_devinfo[MLB_CTYPE_CTRL]);
if ((1 << ASYNC_RX_CL) & acsr0)
mlb_rx_isr(MLB_CTYPE_ASYNC, ASYNC_RX_CL,
&mlb_devinfo[MLB_CTYPE_ASYNC]);
if ((1 << ISOC_RX_CL) & acsr0)
mlb_rx_isr(MLB_CTYPE_ISOC, ISOC_RX_CL,
&mlb_devinfo[MLB_CTYPE_ISOC]);
if ((1 << SYNC_TX_CL) & acsr0)
mlb_tx_isr(MLB_CTYPE_SYNC, SYNC_TX_CL,
&mlb_devinfo[MLB_CTYPE_SYNC]);
if ((1 << CTRL_TX_CL) & acsr0)
mlb_tx_isr(MLB_CTYPE_CTRL, CTRL_TX_CL,
&mlb_devinfo[MLB_CTYPE_CTRL]);
if ((1 << ASYNC_TX_CL) & acsr0)
mlb_tx_isr(MLB_CTYPE_ASYNC, ASYNC_TX_CL,
&mlb_devinfo[MLB_CTYPE_ASYNC]);
if ((1 << ISOC_TX_CL) & acsr0)
mlb_tx_isr(MLB_CTYPE_ASYNC, ISOC_TX_CL,
&mlb_devinfo[MLB_CTYPE_ISOC]);
return IRQ_HANDLED;
}
static irqreturn_t mlb_isr(int irq, void *dev_id)
{
u32 rx_int_sts, tx_int_sts, ms0,
ms1, tx_cis, rx_cis, ctype;
int minor;
u32 cdt_val[4] = { 0 };
/*
* Step 4, Read the MSn register to determine which channel(s)
* are causing the interrupt
*/
ms0 = __raw_readl(mlb_base + REG_MS0);
ms1 = __raw_readl(mlb_base + REG_MS1);
/*
* The MLB150_MS0, MLB150_MS1 registers need to be cleared. In
* the spec description, the registers should be cleared when
* enabling interrupt. In fact, we also should clear it in ISR.
*/
__raw_writel(0, mlb_base + REG_MS0);
__raw_writel(0, mlb_base + REG_MS1);
pr_debug("mxc_mlb150: mlb interrupt:0x%08x 0x%08x\n",
(u32)ms0, (u32)ms1);
for (minor = 0; minor < MLB_MINOR_DEVICES; minor++) {
struct mlb_dev_info *pdevinfo = &mlb_devinfo[minor];
u32 rx_mlb_ch = pdevinfo->channels[RX_CHANNEL].address;
u32 tx_mlb_ch = pdevinfo->channels[TX_CHANNEL].address;
u32 rx_mlb_cl = pdevinfo->channels[RX_CHANNEL].cl;
u32 tx_mlb_cl = pdevinfo->channels[TX_CHANNEL].cl;
tx_cis = rx_cis = 0;
ctype = pdevinfo->channel_type;
rx_int_sts = (rx_mlb_ch < 31) ? ms0 : ms1;
tx_int_sts = (tx_mlb_ch < 31) ? ms0 : ms1;
pr_debug("mxc_mlb150: channel interrupt: "
"tx %d: 0x%08x, rx %d: 0x%08x\n",
tx_mlb_ch, (u32)tx_int_sts, rx_mlb_ch, (u32)rx_int_sts);
/* Get tx channel interrupt status */
if (tx_int_sts & (1 << (tx_mlb_ch % 32))) {
mlb150_dev_cdt_read(tx_mlb_cl, cdt_val);
pr_debug("mxc_mlb150: TX_CH: %d, cdt_val[3]: 0x%08x, "
"cdt_val[2]: 0x%08x, "
"cdt_val[1]: 0x%08x, "
"cdt_val[0]: 0x%08x\n",
tx_mlb_ch, cdt_val[3], cdt_val[2],
cdt_val[1], cdt_val[0]);
switch (ctype) {
case MLB_CTYPE_SYNC:
tx_cis = (cdt_val[2] & CDT_SYNC_WSTS_MASK)
>> CDT_SYNC_WSTS_SHIFT;
/*
* Clear RSTS/WSTS errors to resume
* channel operation
* a. For synchronous channels: WSTS[3] = 0
*/
cdt_val[2] &= ~(0x8 << CDT_SYNC_WSTS_SHIFT);
break;
case MLB_CTYPE_CTRL:
case MLB_CTYPE_ASYNC:
tx_cis = (cdt_val[2] &
CDT_CTRL_ASYNC_WSTS_MASK)
>> CDT_CTRL_ASYNC_WSTS_SHIFT;
tx_cis = (cdt_val[3] & CDT_CTRL_ASYNC_WSTS_1) ?
(tx_cis | (0x1 << 4)) : tx_cis;
/*
* b. For async and ctrl channels:
* RSTS[4]/WSTS[4] = 0
* and RSTS[2]/WSTS[2] = 0
*/
cdt_val[3] &= ~CDT_CTRL_ASYNC_WSTS_1;
cdt_val[2] &=
~(0x4 << CDT_CTRL_ASYNC_WSTS_SHIFT);
break;
case MLB_CTYPE_ISOC:
tx_cis = (cdt_val[2] & CDT_ISOC_WSTS_MASK)
>> CDT_ISOC_WSTS_SHIFT;
/* c. For isoc channels: WSTS[2:1] = 0x00 */
cdt_val[2] &= ~(0x6 << CDT_ISOC_WSTS_SHIFT);
break;
default:
break;
}
mlb150_dev_cdt_write(tx_mlb_ch, cdt_val);
}
/* Get rx channel interrupt status */
if (rx_int_sts & (1 << (rx_mlb_ch % 32))) {
mlb150_dev_cdt_read(rx_mlb_cl, cdt_val);
pr_debug("mxc_mlb150: RX_CH: %d, cdt_val[3]: 0x%08x, "
"cdt_val[2]: 0x%08x, "
"cdt_val[1]: 0x%08x, "
"cdt_val[0]: 0x%08x\n",
rx_mlb_ch, cdt_val[3], cdt_val[2],
cdt_val[1], cdt_val[0]);
switch (ctype) {
case MLB_CTYPE_SYNC:
rx_cis = (cdt_val[2] & CDT_SYNC_RSTS_MASK)
>> CDT_SYNC_RSTS_SHIFT;
cdt_val[2] &= ~(0x8 << CDT_SYNC_WSTS_SHIFT);
break;
case MLB_CTYPE_CTRL:
case MLB_CTYPE_ASYNC:
rx_cis =
(cdt_val[2] & CDT_CTRL_ASYNC_RSTS_MASK)
>> CDT_CTRL_ASYNC_RSTS_SHIFT;
rx_cis = (cdt_val[3] & CDT_CTRL_ASYNC_RSTS_1) ?
(rx_cis | (0x1 << 4)) : rx_cis;
cdt_val[3] &= ~CDT_CTRL_ASYNC_RSTS_1;
cdt_val[2] &=
~(0x4 << CDT_CTRL_ASYNC_RSTS_SHIFT);
break;
case MLB_CTYPE_ISOC:
rx_cis = (cdt_val[2] & CDT_ISOC_RSTS_MASK)
>> CDT_ISOC_RSTS_SHIFT;
cdt_val[2] &= ~(0x6 << CDT_ISOC_WSTS_SHIFT);
break;
default:
break;
}
mlb150_dev_cdt_write(rx_mlb_ch, cdt_val);
}
if (!tx_cis && !rx_cis)
continue;
/* fill exception event */
spin_lock(&pdevinfo->event_lock);
pdevinfo->ex_event |= (rx_cis << 16) | tx_cis;
spin_unlock(&pdevinfo->event_lock);
}
return IRQ_HANDLED;
}
static int mxc_mlb150_open(struct inode *inode, struct file *filp)
{
int minor, ring_buf_size, buf_size, j, ret;
void *buf_addr;
dma_addr_t phy_addr;
struct mlb_dev_info *pdevinfo = NULL;
struct mlb_channel_info *pchinfo = NULL;
struct mlb_data *drvdata;
minor = MINOR(inode->i_rdev);
drvdata = container_of(inode->i_cdev, struct mlb_data, cdev);
drvdata->use_iram = true;
if (minor < 0 || minor >= MLB_MINOR_DEVICES) {
pr_err("no device\n");
return -ENODEV;
}
/* open for each channel device */
if (atomic_cmpxchg(&mlb_devinfo[minor].opencnt, 0, 1) != 0) {
pr_err("busy\n");
return -EBUSY;
}
#ifdef CONFIG_ARCH_MXC_ARM64
clk_prepare_enable(drvdata->ipg);
clk_prepare_enable(drvdata->hclk);
#endif
clk_prepare_enable(drvdata->mlb);
/* initial MLB module */
mlb150_dev_init();
pdevinfo = &mlb_devinfo[minor];
pchinfo = &pdevinfo->channels[TX_CHANNEL];
ring_buf_size = pdevinfo->buf_size;
buf_size = ring_buf_size * (TRANS_RING_NODES * 2);
buf_addr = gen_pool_dma_alloc(drvdata->iram_pool, buf_size, &phy_addr);
if (!buf_addr) {
drvdata->use_iram = false;
buf_addr = dma_alloc_coherent(drvdata->dev, buf_size, &phy_addr, GFP_KERNEL);
if (!buf_addr) {
ret = -ENOMEM;
pr_err("can not alloc rx/tx buffers: %d\n", buf_size);
return ret;
}
}
pr_debug("IRAM Range: Virt 0x%p - 0x%p, Phys 0x%x - 0x%x, size: 0x%x\n",
buf_addr, (buf_addr + buf_size - 1), (u32)phy_addr,
(u32)(phy_addr + buf_size - 1), buf_size);
pdevinfo->rbuf_base_virt = buf_addr;
pdevinfo->rbuf_base_phy = phy_addr;
drvdata->iram_size = drvdata->use_iram ? buf_size : 0;
memset(buf_addr, 0, buf_size);
for (j = 0; j < (TRANS_RING_NODES);
++j, buf_addr += ring_buf_size, phy_addr += ring_buf_size) {
pdevinfo->rx_rbuf.virt_bufs[j] = buf_addr;
pdevinfo->rx_rbuf.phy_addrs[j] = phy_addr;
pr_debug("RX Ringbuf[%d]: 0x%p 0x%x\n",
j, buf_addr, (u32)phy_addr);
}
pdevinfo->rx_rbuf.unit_size = ring_buf_size;
pdevinfo->rx_rbuf.total_size = buf_size;
for (j = 0; j < (TRANS_RING_NODES);
++j, buf_addr += ring_buf_size, phy_addr += ring_buf_size) {
pdevinfo->tx_rbuf.virt_bufs[j] = buf_addr;
pdevinfo->tx_rbuf.phy_addrs[j] = phy_addr;
pr_debug("TX Ringbuf[%d]: 0x%p 0x%x\n",
j, buf_addr, (u32)phy_addr);
}
pdevinfo->tx_rbuf.unit_size = ring_buf_size;
pdevinfo->tx_rbuf.total_size = buf_size;
/* reset the buffer read/write ptr */
pdevinfo->rx_rbuf.head = pdevinfo->rx_rbuf.tail = 0;
pdevinfo->tx_rbuf.head = pdevinfo->tx_rbuf.tail = 0;
pdevinfo->ex_event = 0;
pdevinfo->tx_ok = 0;
init_waitqueue_head(&pdevinfo->rx_wq);
init_waitqueue_head(&pdevinfo->tx_wq);
drvdata = container_of(inode->i_cdev, struct mlb_data, cdev);
drvdata->devinfo = pdevinfo;
mxc_mlb150_irq_enable(drvdata, 1);
filp->private_data = drvdata;
return 0;
}
static int mxc_mlb150_release(struct inode *inode, struct file *filp)
{
int minor;
struct mlb_data *drvdata = filp->private_data;
struct mlb_dev_info *pdevinfo = drvdata->devinfo;
minor = MINOR(inode->i_rdev);
mxc_mlb150_irq_enable(drvdata, 0);
#ifdef DEBUG
mlb150_dev_dump_reg();
mlb150_dev_dump_ctr_tbl(0, pdevinfo->channels[TX_CHANNEL].cl + 1);
#endif
if (drvdata->use_iram)
gen_pool_free(drvdata->iram_pool,
(ulong)pdevinfo->rbuf_base_virt, drvdata->iram_size);
mlb150_dev_exit();
atomic_set(&pdevinfo->on, 0);
clk_disable_unprepare(drvdata->mlb);
#ifdef CONFIG_ARCH_MXC_ARM64
clk_disable_unprepare(drvdata->hclk);
clk_disable_unprepare(drvdata->ipg);
#endif
/* decrease the open count */
atomic_set(&pdevinfo->opencnt, 0);
drvdata->devinfo = NULL;
return 0;
}
static long mxc_mlb150_ioctl(struct file *filp,
unsigned int cmd, unsigned long arg)
{
//struct inode *inode = filp->f_dentry->d_inode;
struct inode *inode = file_inode(filp);
struct mlb_data *drvdata = filp->private_data;
struct mlb_dev_info *pdevinfo = drvdata->devinfo;
void __user *argp = (void __user *)arg;
unsigned long flags, event;
int minor;
minor = MINOR(inode->i_rdev);
switch (cmd) {
case MLB_CHAN_SETADDR:
{
unsigned int caddr;
/* get channel address from user space */
if (copy_from_user(&caddr, argp, sizeof(caddr))) {
pr_err("mxc_mlb150: copy from user failed\n");
return -EFAULT;
}
pdevinfo->channels[TX_CHANNEL].address =
(caddr >> 16) & 0xFFFF;
pdevinfo->channels[RX_CHANNEL].address = caddr & 0xFFFF;
pr_debug("mxc_mlb150: set ch addr, tx: %d, rx: %d\n",
pdevinfo->channels[TX_CHANNEL].address,
pdevinfo->channels[RX_CHANNEL].address);
break;
}
case MLB_CHAN_STARTUP:
if (atomic_read(&pdevinfo->on)) {
pr_debug("mxc_mlb150: channel alreadly startup\n");
break;
}
if (mlb_channel_enable(drvdata, minor, 1))
return -EFAULT;
break;
case MLB_CHAN_SHUTDOWN:
if (atomic_read(&pdevinfo->on) == 0) {
pr_debug("mxc_mlb150: channel areadly shutdown\n");
break;
}
mlb150_trans_complete_check(pdevinfo);
mlb_channel_enable(drvdata, minor, 0);
break;
case MLB_CHAN_GETEVENT:
/* get and clear the ex_event */
spin_lock_irqsave(&pdevinfo->event_lock, flags);
event = pdevinfo->ex_event;
pdevinfo->ex_event = 0;
spin_unlock_irqrestore(&pdevinfo->event_lock, flags);
if (event) {
if (copy_to_user(argp, &event, sizeof(event))) {
pr_err("mxc_mlb150: copy to user failed\n");
return -EFAULT;
}
} else
return -EAGAIN;
break;
case MLB_SET_ISOC_BLKSIZE_188:
pdevinfo->isoc_blksz = 188;
pdevinfo->cdt_buf_dep = pdevinfo->adt_buf_dep =
pdevinfo->isoc_blksz * CH_ISOC_BLK_NUM;
break;
case MLB_SET_ISOC_BLKSIZE_196:
pdevinfo->isoc_blksz = 196;
pdevinfo->cdt_buf_dep = pdevinfo->adt_buf_dep =
pdevinfo->isoc_blksz * CH_ISOC_BLK_NUM;
break;
case MLB_SET_SYNC_QUAD:
{
u32 quad;
if (copy_from_user(&quad, argp, sizeof(quad))) {
pr_err("mxc_mlb150: get quad number "
"from user failed\n");
return -EFAULT;
}
if (quad <= 0 || quad > 3) {
pr_err("mxc_mlb150: Invalid Quadlets!"
"Quadlets in Sync mode can "
"only be 1, 2, 3\n");
return -EINVAL;
}
pdevinfo->sync_quad = quad;
/* Each quadlets is 4 bytes */
pdevinfo->cdt_buf_dep = quad * 4 * 4;
pdevinfo->adt_buf_dep =
pdevinfo->cdt_buf_dep * CH_SYNC_ADT_BUF_MULTI;
}
break;
case MLB_SET_FPS:
{
u32 fps, c0_val;
/* get fps from user space */
if (copy_from_user(&fps, argp, sizeof(fps))) {
pr_err("mxc_mlb150: copy from user failed\n");
return -EFAULT;
}
if ((fps > 1024) &&
!(drvdata->quirk_flag & MLB_QUIRK_MLB150)) {
pr_err("mxc_mlb150: not support fps %d\n", fps);
return -EINVAL;
}
c0_val = __raw_readl(mlb_base + REG_MLBC0);
c0_val &= ~MLBC0_MLBCLK_MASK;
/* check fps value */
switch (fps) {
case 256:
case 512:
case 1024:
pdevinfo->fps = fps >> 9;
c0_val &= ~MLBC0_MLBPEN;
c0_val |= (fps >> 9)
<< MLBC0_MLBCLK_SHIFT;
if (1024 == fps) {
/*
* Invert output clock phase
* in 1024 fps
*/
__raw_writel(0x1,
mlb_base + REG_MLBPC2);
}
break;
case 2048:
case 3072:
case 4096:
pdevinfo->fps = (fps >> 10) + 1;
c0_val |= ((fps >> 10) + 1)
<< MLBC0_MLBCLK_SHIFT;
break;
case 6144:
pdevinfo->fps = fps >> 10;
c0_val |= ((fps >> 10) + 1)
<< MLBC0_MLBCLK_SHIFT;
break;
case 8192:
pdevinfo->fps = (fps >> 10) - 1;
c0_val |= ((fps >> 10) - 1)
<< MLBC0_MLBCLK_SHIFT;
break;
default:
pr_debug("mxc_mlb150: invalid fps argument: %d\n",
fps);
return -EINVAL;
}
__raw_writel(c0_val, mlb_base + REG_MLBC0);
pr_debug("mxc_mlb150: set fps to %d, MLBC0: 0x%08x\n",
fps,
(u32)__raw_readl(mlb_base + REG_MLBC0));
break;
}
case MLB_GET_VER:
{
u32 version;
/* get MLB device module version */
version = 0x03030003;
pr_debug("mxc_mlb150: get version: 0x%08x\n",
version);
if (copy_to_user(argp, &version, sizeof(version))) {
pr_err("mxc_mlb150: copy to user failed\n");
return -EFAULT;
}
break;
}
case MLB_SET_DEVADDR:
{
u32 c1_val;
u8 devaddr;
/* get MLB device address from user space */
if (copy_from_user
(&devaddr, argp, sizeof(unsigned char))) {
pr_err("mxc_mlb150: copy from user failed\n");
return -EFAULT;
}
c1_val = __raw_readl(mlb_base + REG_MLBC1);
c1_val &= ~MLBC1_NDA_MASK;
c1_val |= devaddr << MLBC1_NDA_SHIFT;
__raw_writel(c1_val, mlb_base + REG_MLBC1);
pr_debug("mxc_mlb150: set dev addr, dev addr: %d, "
"MLBC1: 0x%08x\n", devaddr,
(u32)__raw_readl(mlb_base + REG_MLBC1));
break;
}
case MLB_IRQ_DISABLE:
{
disable_irq(drvdata->irq_mlb);
break;
}
case MLB_IRQ_ENABLE:
{
enable_irq(drvdata->irq_mlb);
break;
}
default:
pr_info("mxc_mlb150: Invalid ioctl command\n");
return -EINVAL;
}
return 0;
}
/*
* MLB read routine
* Read the current received data from queued buffer,
* and free this buffer for hw to fill ingress data.
*/
static ssize_t mxc_mlb150_read(struct file *filp, char __user *buf,
size_t count, loff_t *f_pos)
{
int size;
struct mlb_data *drvdata = filp->private_data;
struct mlb_dev_info *pdevinfo = drvdata->devinfo;
struct mlb_ringbuf *rx_rbuf = &pdevinfo->rx_rbuf;
int head, tail;
unsigned long flags;
read_lock_irqsave(&rx_rbuf->rb_lock, flags);
head = ACCESS_ONCE(rx_rbuf->head);
tail = rx_rbuf->tail;
read_unlock_irqrestore(&rx_rbuf->rb_lock, flags);
/* check the current rx buffer is available or not */
if (0 == CIRC_CNT(head, tail, TRANS_RING_NODES)) {
if (filp->f_flags & O_NONBLOCK)
return -EAGAIN;
do {
DEFINE_WAIT(__wait);
for (;;) {
prepare_to_wait(&pdevinfo->rx_wq,
&__wait, TASK_INTERRUPTIBLE);
read_lock_irqsave(&rx_rbuf->rb_lock, flags);
if (CIRC_CNT(rx_rbuf->head, rx_rbuf->tail,
TRANS_RING_NODES) > 0) {
read_unlock_irqrestore(&rx_rbuf->rb_lock,
flags);
break;
}
read_unlock_irqrestore(&rx_rbuf->rb_lock,
flags);
if (!signal_pending(current)) {
schedule();
continue;
}
return -ERESTARTSYS;
}
finish_wait(&pdevinfo->rx_wq, &__wait);
} while (0);
}
/* read index before reading contents at that index */
smp_read_barrier_depends();
size = pdevinfo->adt_buf_dep;
if (size > count) {
/* the user buffer is too small */
pr_warn("mxc_mlb150: received data size is biggerthan size:"
"%d, count: %d\n", size, (int)count);
return -EINVAL;
}
/* extract one item from the buffer */
if (copy_to_user(buf, rx_rbuf->virt_bufs[tail], size)) {
pr_err("mxc_mlb150: copy from user failed\n");
return -EFAULT;
}
/* finish reading descriptor before incrementing tail */
smp_mb();
write_lock_irqsave(&rx_rbuf->rb_lock, flags);
rx_rbuf->tail = (tail + 1) & (TRANS_RING_NODES - 1);
write_unlock_irqrestore(&rx_rbuf->rb_lock, flags);
*f_pos = 0;
return size;
}
/*
* MLB write routine
* Copy the user data to tx channel buffer,
* and prepare the channel current/next buffer ptr.
*/
static ssize_t mxc_mlb150_write(struct file *filp, const char __user *buf,
size_t count, loff_t *f_pos)
{
s32 ret = 0;
struct mlb_channel_info *pchinfo = NULL;
struct mlb_data *drvdata = filp->private_data;
struct mlb_dev_info *pdevinfo = drvdata->devinfo;
struct mlb_ringbuf *tx_rbuf = &pdevinfo->tx_rbuf;
int head, tail;
unsigned long flags;
/*
* minor = MINOR(filp->f_dentry->d_inode->i_rdev);
*/
pchinfo = &pdevinfo->channels[TX_CHANNEL];
if (count > pdevinfo->buf_size) {
/* too many data to write */
pr_warning("mxc_mlb150: overflow write data\n");
return -EFBIG;
}
*f_pos = 0;
read_lock_irqsave(&tx_rbuf->rb_lock, flags);
head = tx_rbuf->head;
tail = ACCESS_ONCE(tx_rbuf->tail);
read_unlock_irqrestore(&tx_rbuf->rb_lock, flags);
if (0 == CIRC_SPACE(head, tail, TRANS_RING_NODES)) {
if (filp->f_flags & O_NONBLOCK)
return -EAGAIN;
do {
DEFINE_WAIT(__wait);
for (;;) {
prepare_to_wait(&pdevinfo->tx_wq,
&__wait, TASK_INTERRUPTIBLE);
read_lock_irqsave(&tx_rbuf->rb_lock, flags);
if (CIRC_SPACE(tx_rbuf->head, tx_rbuf->tail,
TRANS_RING_NODES) > 0) {
read_unlock_irqrestore(&tx_rbuf->rb_lock,
flags);
break;
}
read_unlock_irqrestore(&tx_rbuf->rb_lock,
flags);
if (!signal_pending(current)) {
schedule();
continue;
}
return -ERESTARTSYS;
}
finish_wait(&pdevinfo->tx_wq, &__wait);
} while (0);
}
if (copy_from_user((void *)tx_rbuf->virt_bufs[head], buf, count)) {
read_unlock_irqrestore(&tx_rbuf->rb_lock, flags);
pr_err("mxc_mlb: copy from user failed\n");
ret = -EFAULT;
goto out;
}
write_lock_irqsave(&tx_rbuf->rb_lock, flags);
smp_wmb();
tx_rbuf->head = (head + 1) & (TRANS_RING_NODES - 1);
write_unlock_irqrestore(&tx_rbuf->rb_lock, flags);
if (0 == CIRC_CNT(head, tail, TRANS_RING_NODES)) {
u32 tx_buf_ptr, ahb_ch;
s32 adt_sts;
u32 ctype = pdevinfo->channel_type;
/* read index before reading contents at that index */
smp_read_barrier_depends();
tx_buf_ptr = tx_rbuf->phy_addrs[tail];
ahb_ch = pdevinfo->channels[TX_CHANNEL].cl;
adt_sts = mlb150_dev_get_adt_sts(ahb_ch);
/* Set ADT for TX */
mlb150_dev_pipo_next(ahb_ch, ctype, adt_sts, tx_buf_ptr);
}
ret = count;
out:
return ret;
}
static unsigned int mxc_mlb150_poll(struct file *filp,
struct poll_table_struct *wait)
{
int minor;
unsigned int ret = 0;
struct mlb_data *drvdata = filp->private_data;
struct mlb_dev_info *pdevinfo = drvdata->devinfo;
struct mlb_ringbuf *tx_rbuf = &pdevinfo->tx_rbuf;
struct mlb_ringbuf *rx_rbuf = &pdevinfo->rx_rbuf;
int head, tail;
unsigned long flags;
minor = MINOR(file_inode(filp)->i_rdev);
poll_wait(filp, &pdevinfo->rx_wq, wait);
poll_wait(filp, &pdevinfo->tx_wq, wait);
read_lock_irqsave(&tx_rbuf->rb_lock, flags);
head = tx_rbuf->head;
tail = tx_rbuf->tail;
read_unlock_irqrestore(&tx_rbuf->rb_lock, flags);
/* check the tx buffer is avaiable or not */
if (CIRC_SPACE(head, tail, TRANS_RING_NODES) >= 1)
ret |= POLLOUT | POLLWRNORM;
read_lock_irqsave(&rx_rbuf->rb_lock, flags);
head = rx_rbuf->head;
tail = rx_rbuf->tail;
read_unlock_irqrestore(&rx_rbuf->rb_lock, flags);
/* check the rx buffer filled or not */
if (CIRC_CNT(head, tail, TRANS_RING_NODES) >= 1)
ret |= POLLIN | POLLRDNORM;
/* check the exception event */
if (pdevinfo->ex_event)
ret |= POLLIN | POLLRDNORM;
return ret;
}
/*
* char dev file operations structure
*/
static const struct file_operations mxc_mlb150_fops = {
.owner = THIS_MODULE,
.open = mxc_mlb150_open,
.release = mxc_mlb150_release,
.unlocked_ioctl = mxc_mlb150_ioctl,
.poll = mxc_mlb150_poll,
.read = mxc_mlb150_read,
.write = mxc_mlb150_write,
};
static struct platform_device_id imx_mlb150_devtype[] = {
{
.name = "imx6q-mlb150",
.driver_data = MLB_QUIRK_MLB150,
}, {
.name = "imx6sx-mlb50",
.driver_data = 0,
}, {
/* sentinel */
}
};
MODULE_DEVICE_TABLE(platform, imx_mlb150_devtype);
static const struct of_device_id mlb150_imx_dt_ids[] = {
{ .compatible = "fsl,imx6q-mlb150",
.data = &imx_mlb150_devtype[IMX6Q_MLB], },
{ .compatible = "fsl,imx6sx-mlb50",
.data = &imx_mlb150_devtype[IMX6SX_MLB], },
{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, mlb150_imx_dt_ids);
/*
* This function is called whenever the MLB device is detected.
*/
static int mxc_mlb150_probe(struct platform_device *pdev)
{
int ret, mlb_major, i;
struct mlb_data *drvdata;
struct resource *res;
struct device_node *np = pdev->dev.of_node;
const struct of_device_id *of_id;
drvdata = devm_kzalloc(&pdev->dev, sizeof(struct mlb_data),
GFP_KERNEL);
if (!drvdata) {
dev_err(&pdev->dev, "can't allocate enough memory\n");
return -ENOMEM;
}
drvdata->dev = &pdev->dev;
of_id = of_match_device(mlb150_imx_dt_ids, &pdev->dev);
if (of_id)
pdev->id_entry = of_id->data;
else
return -EINVAL;
/*
* Register MLB lld as four character devices
*/
ret = alloc_chrdev_region(&drvdata->firstdev, 0,
MLB_MINOR_DEVICES, "mxc_mlb150");
if (ret < 0) {
dev_err(&pdev->dev, "alloc region error\n");
goto err_reg;
}
mlb_major = MAJOR(drvdata->firstdev);
dev_dbg(&pdev->dev, "MLB device major: %d\n", mlb_major);
cdev_init(&drvdata->cdev, &mxc_mlb150_fops);
drvdata->cdev.owner = THIS_MODULE;
ret = cdev_add(&drvdata->cdev, drvdata->firstdev, MLB_MINOR_DEVICES);
if (ret) {
dev_err(&pdev->dev, "can't add cdev\n");
goto err_reg;
}
/* create class and device for udev information */
drvdata->class = class_create(THIS_MODULE, "mlb150");
if (IS_ERR(drvdata->class)) {
dev_err(&pdev->dev, "failed to create device class\n");
ret = -ENOMEM;
goto err_class;
}
for (i = 0; i < MLB_MINOR_DEVICES; i++) {
struct device *class_dev;
class_dev = device_create(drvdata->class, NULL,
MKDEV(mlb_major, i),
NULL, mlb_devinfo[i].dev_name);
if (IS_ERR(class_dev)) {
dev_err(&pdev->dev, "failed to create mlb150 %s"
" class device\n", mlb_devinfo[i].dev_name);
ret = -ENOMEM;
goto err_dev;
}
}
drvdata->quirk_flag = pdev->id_entry->driver_data;
/* ahb0 irq */
drvdata->irq_ahb0 = platform_get_irq(pdev, 1);
if (drvdata->irq_ahb0 < 0) {
dev_err(&pdev->dev, "No ahb0 irq line provided\n");
goto err_dev;
}
dev_dbg(&pdev->dev, "ahb0_irq: %d\n", drvdata->irq_ahb0);
if (devm_request_irq(&pdev->dev, drvdata->irq_ahb0, mlb_ahb_isr,
0, "mlb_ahb0", NULL)) {
dev_err(&pdev->dev, "can't claim irq %d\n", drvdata->irq_ahb0);
goto err_dev;
}
/* ahb1 irq */
drvdata->irq_ahb1 = platform_get_irq(pdev, 2);
dev_dbg(&pdev->dev, "ahb1_irq: %d\n", drvdata->irq_ahb1);
if (drvdata->irq_ahb1 > 0) {
if (devm_request_irq(&pdev->dev, drvdata->irq_ahb1, mlb_ahb_isr,
0, "mlb_ahb1", NULL)) {
dev_err(&pdev->dev, "can't claim irq %d\n", drvdata->irq_ahb1);
goto err_dev;
}
}
/* mlb irq */
drvdata->irq_mlb = platform_get_irq(pdev, 0);
if (drvdata->irq_mlb < 0) {
dev_err(&pdev->dev, "No mlb irq line provided\n");
goto err_dev;
}
dev_dbg(&pdev->dev, "mlb_irq: %d\n", drvdata->irq_mlb);
if (devm_request_irq(&pdev->dev, drvdata->irq_mlb, mlb_isr,
0, "mlb", NULL)) {
dev_err(&pdev->dev, "can't claim irq %d\n", drvdata->irq_mlb);
goto err_dev;
}
/* ioremap from phy mlb to kernel space */
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
dev_err(&pdev->dev, "can't get device resources\n");
ret = -ENOENT;
goto err_dev;
}
mlb_base = devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(mlb_base)) {
dev_err(&pdev->dev,
"failed to get ioremap base\n");
ret = PTR_ERR(mlb_base);
goto err_dev;
}
drvdata->membase = mlb_base;
#ifdef CONFIG_REGULATOR
drvdata->nvcc = devm_regulator_get(&pdev->dev, "reg_nvcc");
if (!IS_ERR(drvdata->nvcc)) {
regulator_set_voltage(drvdata->nvcc, 2500000, 2500000);
dev_err(&pdev->dev, "enalbe regulator\n");
ret = regulator_enable(drvdata->nvcc);
if (ret) {
dev_err(&pdev->dev, "vdd set voltage error\n");
goto err_dev;
}
}
#endif
#ifdef CONFIG_ARCH_MXC_ARM64
drvdata->ipg = devm_clk_get(&pdev->dev, "ipg");
if (IS_ERR(drvdata->ipg)) {
dev_err(&pdev->dev, "unable to get mlb ipg clock\n");
ret = PTR_ERR(drvdata->ipg);
goto err_dev;
};
drvdata->hclk = devm_clk_get(&pdev->dev, "hclk");
if (IS_ERR(drvdata->hclk)) {
dev_err(&pdev->dev, "unable to get mlb hclk clock\n");
ret = PTR_ERR(drvdata->hclk);
goto err_dev;
};
#endif
drvdata->mlb = devm_clk_get(&pdev->dev, "mlb");
if (IS_ERR(drvdata->mlb)) {
dev_err(&pdev->dev, "unable to get mlb clock\n");
ret = PTR_ERR(drvdata->mlb);
goto err_dev;
}
drvdata->iram_pool = of_gen_pool_get(np, "iram", 0);
if (!drvdata->iram_pool)
dev_warn(&pdev->dev, "no iram assigned, using external mem\n");
drvdata->devinfo = NULL;
mxc_mlb150_irq_enable(drvdata, 0);
platform_set_drvdata(pdev, drvdata);
return 0;
err_dev:
for (--i; i >= 0; i--)
device_destroy(drvdata->class, MKDEV(mlb_major, i));
class_destroy(drvdata->class);
err_class:
cdev_del(&drvdata->cdev);
err_reg:
unregister_chrdev_region(drvdata->firstdev, MLB_MINOR_DEVICES);
return ret;
}
static int mxc_mlb150_remove(struct platform_device *pdev)
{
int i;
struct mlb_data *drvdata = platform_get_drvdata(pdev);
struct mlb_dev_info *pdevinfo = drvdata->devinfo;
if (pdevinfo && atomic_read(&pdevinfo->opencnt))
clk_disable_unprepare(drvdata->mlb);
/* disable mlb power */
#ifdef CONFIG_REGULATOR
if (!IS_ERR(drvdata->nvcc))
regulator_disable(drvdata->nvcc);
#endif
/* destroy mlb device class */
for (i = MLB_MINOR_DEVICES - 1; i >= 0; i--)
device_destroy(drvdata->class,
MKDEV(MAJOR(drvdata->firstdev), i));
class_destroy(drvdata->class);
cdev_del(&drvdata->cdev);
/* Unregister the two MLB devices */
unregister_chrdev_region(drvdata->firstdev, MLB_MINOR_DEVICES);
return 0;
}
#ifdef CONFIG_PM
static int mxc_mlb150_suspend(struct platform_device *pdev, pm_message_t state)
{
struct mlb_data *drvdata = platform_get_drvdata(pdev);
struct mlb_dev_info *pdevinfo = drvdata->devinfo;
if (pdevinfo && atomic_read(&pdevinfo->opencnt)) {
mlb150_dev_exit();
clk_disable_unprepare(drvdata->mlb);
}
return 0;
}
static int mxc_mlb150_resume(struct platform_device *pdev)
{
struct mlb_data *drvdata = platform_get_drvdata(pdev);
struct mlb_dev_info *pdevinfo = drvdata->devinfo;
if (pdevinfo && atomic_read(&pdevinfo->opencnt)) {
clk_prepare_enable(drvdata->mlb);
mlb150_dev_init();
}
return 0;
}
#else
#define mxc_mlb150_suspend NULL
#define mxc_mlb150_resume NULL
#endif
/*
* platform driver structure for MLB
*/
static struct platform_driver mxc_mlb150_driver = {
.driver = {
.name = DRIVER_NAME,
.owner = THIS_MODULE,
.of_match_table = mlb150_imx_dt_ids,
},
.probe = mxc_mlb150_probe,
.remove = mxc_mlb150_remove,
.suspend = mxc_mlb150_suspend,
.resume = mxc_mlb150_resume,
.id_table = imx_mlb150_devtype,
};
static int __init mxc_mlb150_init(void)
{
return platform_driver_register(&mxc_mlb150_driver);
}
static void __exit mxc_mlb150_exit(void)
{
platform_driver_unregister(&mxc_mlb150_driver);
}
module_init(mxc_mlb150_init);
module_exit(mxc_mlb150_exit);
MODULE_AUTHOR("Freescale Semiconductor, Inc.");
MODULE_DESCRIPTION("MLB150 low level driver");
MODULE_LICENSE("GPL");