[deliverable/linux.git] / include / linux / bcma / bcma.h

#ifndef LINUX_BCMA_H_
#define LINUX_BCMA_H_

#include <linux/pci.h>
#include <linux/mod_devicetable.h>

#include <linux/bcma/bcma_driver_chipcommon.h>
#include <linux/bcma/bcma_driver_pci.h>
#include <linux/ssb/ssb.h> /* SPROM sharing */

#include "bcma_regs.h"

struct bcma_device;
struct bcma_bus;

enum bcma_hosttype {
	BCMA_HOSTTYPE_NONE,
	BCMA_HOSTTYPE_PCI,
	BCMA_HOSTTYPE_SDIO,
};

struct bcma_chipinfo {
	u16 id;
	u8 rev;
	u8 pkg;
};

enum bcma_clkmode {
	BCMA_CLKMODE_FAST,
	BCMA_CLKMODE_DYNAMIC,
};

struct bcma_host_ops {
	u8 (*read8)(struct bcma_device *core, u16 offset);
	u16 (*read16)(struct bcma_device *core, u16 offset);
	u32 (*read32)(struct bcma_device *core, u16 offset);
	void (*write8)(struct bcma_device *core, u16 offset, u8 value);
	void (*write16)(struct bcma_device *core, u16 offset, u16 value);
	void (*write32)(struct bcma_device *core, u16 offset, u32 value);
#ifdef CONFIG_BCMA_BLOCKIO
	void (*block_read)(struct bcma_device *core, void *buffer,
			   size_t count, u16 offset, u8 reg_width);
	void (*block_write)(struct bcma_device *core, const void *buffer,
			    size_t count, u16 offset, u8 reg_width);
#endif
	/* Agent ops */
	u32 (*aread32)(struct bcma_device *core, u16 offset);
	void (*awrite32)(struct bcma_device *core, u16 offset, u32 value);
};

/* Core manufacturers */
#define BCMA_MANUF_ARM			0x43B
#define BCMA_MANUF_MIPS			0x4A7
#define BCMA_MANUF_BCM			0x4BF

/* Core class values. */
#define BCMA_CL_SIM			0x0
#define BCMA_CL_EROM			0x1
#define BCMA_CL_CORESIGHT		0x9
#define BCMA_CL_VERIF			0xB
#define BCMA_CL_OPTIMO			0xD
#define BCMA_CL_GEN			0xE
#define BCMA_CL_PRIMECELL		0xF

/* Core-ID values. */
#define BCMA_CORE_OOB_ROUTER		0x367	/* Out of band */
#define BCMA_CORE_INVALID		0x700
#define BCMA_CORE_CHIPCOMMON		0x800
#define BCMA_CORE_ILINE20		0x801
#define BCMA_CORE_SRAM			0x802
#define BCMA_CORE_SDRAM			0x803
#define BCMA_CORE_PCI			0x804
#define BCMA_CORE_MIPS			0x805
#define BCMA_CORE_ETHERNET		0x806
#define BCMA_CORE_V90			0x807
#define BCMA_CORE_USB11_HOSTDEV		0x808
#define BCMA_CORE_ADSL			0x809
#define BCMA_CORE_ILINE100		0x80A
#define BCMA_CORE_IPSEC			0x80B
#define BCMA_CORE_UTOPIA		0x80C
#define BCMA_CORE_PCMCIA		0x80D
#define BCMA_CORE_INTERNAL_MEM		0x80E
#define BCMA_CORE_MEMC_SDRAM		0x80F
#define BCMA_CORE_OFDM			0x810
#define BCMA_CORE_EXTIF			0x811
#define BCMA_CORE_80211			0x812
#define BCMA_CORE_PHY_A			0x813
#define BCMA_CORE_PHY_B			0x814
#define BCMA_CORE_PHY_G			0x815
#define BCMA_CORE_MIPS_3302		0x816
#define BCMA_CORE_USB11_HOST		0x817
#define BCMA_CORE_USB11_DEV		0x818
#define BCMA_CORE_USB20_HOST		0x819
#define BCMA_CORE_USB20_DEV		0x81A
#define BCMA_CORE_SDIO_HOST		0x81B
#define BCMA_CORE_ROBOSWITCH		0x81C
#define BCMA_CORE_PARA_ATA		0x81D
#define BCMA_CORE_SATA_XORDMA		0x81E
#define BCMA_CORE_ETHERNET_GBIT		0x81F
#define BCMA_CORE_PCIE			0x820
#define BCMA_CORE_PHY_N			0x821
#define BCMA_CORE_SRAM_CTL		0x822
#define BCMA_CORE_MINI_MACPHY		0x823
#define BCMA_CORE_ARM_1176		0x824
#define BCMA_CORE_ARM_7TDMI		0x825
#define BCMA_CORE_PHY_LP		0x826
#define BCMA_CORE_PMU			0x827
#define BCMA_CORE_PHY_SSN		0x828
#define BCMA_CORE_SDIO_DEV		0x829
#define BCMA_CORE_ARM_CM3		0x82A
#define BCMA_CORE_PHY_HT		0x82B
#define BCMA_CORE_MIPS_74K		0x82C
#define BCMA_CORE_MAC_GBIT		0x82D
#define BCMA_CORE_DDR12_MEM_CTL		0x82E
#define BCMA_CORE_PCIE_RC		0x82F	/* PCIe Root Complex */
#define BCMA_CORE_OCP_OCP_BRIDGE	0x830
#define BCMA_CORE_SHARED_COMMON		0x831
#define BCMA_CORE_OCP_AHB_BRIDGE	0x832
#define BCMA_CORE_SPI_HOST		0x833
#define BCMA_CORE_I2S			0x834
#define BCMA_CORE_SDR_DDR1_MEM_CTL	0x835	/* SDR/DDR1 memory controller core */
#define BCMA_CORE_SHIM			0x837	/* SHIM component in ubus/6362 */
#define BCMA_CORE_DEFAULT		0xFFF

#define BCMA_MAX_NR_CORES		16

struct bcma_device {
	struct bcma_bus *bus;
	struct bcma_device_id id;

	struct device dev;
	struct device *dma_dev;
	unsigned int irq;
	bool dev_registered;

	u8 core_index;

	u32 addr;
	u32 wrap;

	void *drvdata;
	struct list_head list;
};

static inline void *bcma_get_drvdata(struct bcma_device *core)
{
	return core->drvdata;
}
static inline void bcma_set_drvdata(struct bcma_device *core, void *drvdata)
{
	core->drvdata = drvdata;
}

struct bcma_driver {
	const char *name;
	const struct bcma_device_id *id_table;

	int (*probe)(struct bcma_device *dev);
	void (*remove)(struct bcma_device *dev);
	int (*suspend)(struct bcma_device *dev, pm_message_t state);
	int (*resume)(struct bcma_device *dev);
	void (*shutdown)(struct bcma_device *dev);

	struct device_driver drv;
};
extern
int __bcma_driver_register(struct bcma_driver *drv, struct module *owner);
static inline int bcma_driver_register(struct bcma_driver *drv)
{
	return __bcma_driver_register(drv, THIS_MODULE);
}
extern void bcma_driver_unregister(struct bcma_driver *drv);

struct bcma_bus {
	/* The MMIO area. */
	void __iomem *mmio;

	const struct bcma_host_ops *ops;

	enum bcma_hosttype hosttype;
	union {
		/* Pointer to the PCI bus (only for BCMA_HOSTTYPE_PCI) */
		struct pci_dev *host_pci;
		/* Pointer to the SDIO device (only for BCMA_HOSTTYPE_SDIO) */
		struct sdio_func *host_sdio;
	};

	struct bcma_chipinfo chipinfo;

	struct bcma_device *mapped_core;
	struct list_head cores;
	u8 nr_cores;
	u8 init_done:1;

	struct bcma_drv_cc drv_cc;
	struct bcma_drv_pci drv_pci;

	/* We decided to share SPROM struct with SSB as long as we do not need
	 * any hacks for BCMA. This simplifies drivers code. */
	struct ssb_sprom sprom;
};

extern inline u32 bcma_read8(struct bcma_device *core, u16 offset)
{
	return core->bus->ops->read8(core, offset);
}
extern inline u32 bcma_read16(struct bcma_device *core, u16 offset)
{
	return core->bus->ops->read16(core, offset);
}
extern inline u32 bcma_read32(struct bcma_device *core, u16 offset)
{
	return core->bus->ops->read32(core, offset);
}
extern inline
void bcma_write8(struct bcma_device *core, u16 offset, u32 value)
{
	core->bus->ops->write8(core, offset, value);
}
extern inline
void bcma_write16(struct bcma_device *core, u16 offset, u32 value)
{
	core->bus->ops->write16(core, offset, value);
}
extern inline
void bcma_write32(struct bcma_device *core, u16 offset, u32 value)
{
	core->bus->ops->write32(core, offset, value);
}
#ifdef CONFIG_BCMA_BLOCKIO
extern inline void bcma_block_read(struct bcma_device *core, void *buffer,
				   size_t count, u16 offset, u8 reg_width)
{
	core->bus->ops->block_read(core, buffer, count, offset, reg_width);
}
extern inline void bcma_block_write(struct bcma_device *core, const void *buffer,
				    size_t count, u16 offset, u8 reg_width)
{
	core->bus->ops->block_write(core, buffer, count, offset, reg_width);
}
#endif
extern inline u32 bcma_aread32(struct bcma_device *core, u16 offset)
{
	return core->bus->ops->aread32(core, offset);
}
extern inline
void bcma_awrite32(struct bcma_device *core, u16 offset, u32 value)
{
	core->bus->ops->awrite32(core, offset, value);
}

#define bcma_mask32(cc, offset, mask) \
	bcma_write32(cc, offset, bcma_read32(cc, offset) & (mask))
#define bcma_set32(cc, offset, set) \
	bcma_write32(cc, offset, bcma_read32(cc, offset) | (set))
#define bcma_maskset32(cc, offset, mask, set) \
	bcma_write32(cc, offset, (bcma_read32(cc, offset) & (mask)) | (set))

extern bool bcma_core_is_enabled(struct bcma_device *core);
extern void bcma_core_disable(struct bcma_device *core, u32 flags);
extern int bcma_core_enable(struct bcma_device *core, u32 flags);
extern void bcma_core_set_clockmode(struct bcma_device *core,
				    enum bcma_clkmode clkmode);
extern void bcma_core_pll_ctl(struct bcma_device *core, u32 req, u32 status,
			      bool on);
#define BCMA_DMA_TRANSLATION_MASK	0xC0000000
#define  BCMA_DMA_TRANSLATION_NONE	0x00000000
#define  BCMA_DMA_TRANSLATION_DMA32_CMT	0x40000000 /* Client Mode Translation for 32-bit DMA */
#define  BCMA_DMA_TRANSLATION_DMA64_CMT	0x80000000 /* Client Mode Translation for 64-bit DMA */
extern u32 bcma_core_dma_translation(struct bcma_device *core);

#endif /* LINUX_BCMA_H_ */
Commit	Line	Data
8369ae33 RM	1	#ifndef LINUX_BCMA_H_
	2	#define LINUX_BCMA_H_
	3
	4	#include <linux/pci.h>
	5	#include <linux/mod_devicetable.h>
	6
	7	#include <linux/bcma/bcma_driver_chipcommon.h>
	8	#include <linux/bcma/bcma_driver_pci.h>
27f18dc2	9	#include <linux/ssb/ssb.h> /* SPROM sharing */
8369ae33 RM	10
	11	#include "bcma_regs.h"
	12
	13	struct bcma_device;
	14	struct bcma_bus;
	15
	16	enum bcma_hosttype {
	17	BCMA_HOSTTYPE_NONE,
	18	BCMA_HOSTTYPE_PCI,
	19	BCMA_HOSTTYPE_SDIO,
	20	};
	21
	22	struct bcma_chipinfo {
	23	u16 id;
	24	u8 rev;
	25	u8 pkg;
	26	};
	27
7424dd0d RM	28	enum bcma_clkmode {
	29	BCMA_CLKMODE_FAST,
	30	BCMA_CLKMODE_DYNAMIC,
	31	};
	32
8369ae33 RM	33	struct bcma_host_ops {
	34	u8 (read8)(struct bcma_device core, u16 offset);
	35	u16 (read16)(struct bcma_device core, u16 offset);
	36	u32 (read32)(struct bcma_device core, u16 offset);
	37	void (write8)(struct bcma_device core, u16 offset, u8 value);
	38	void (write16)(struct bcma_device core, u16 offset, u16 value);
	39	void (write32)(struct bcma_device core, u16 offset, u32 value);
9d75ef0f RM	40	#ifdef CONFIG_BCMA_BLOCKIO
	41	void (block_read)(struct bcma_device core, void *buffer,
	42	size_t count, u16 offset, u8 reg_width);
	43	void (block_write)(struct bcma_device core, const void *buffer,
	44	size_t count, u16 offset, u8 reg_width);
	45	#endif
8369ae33 RM	46	/* Agent ops */
	47	u32 (aread32)(struct bcma_device core, u16 offset);
	48	void (awrite32)(struct bcma_device core, u16 offset, u32 value);
	49	};
	50
	51	/* Core manufacturers */
	52	#define BCMA_MANUF_ARM 0x43B
	53	#define BCMA_MANUF_MIPS 0x4A7
	54	#define BCMA_MANUF_BCM 0x4BF
	55
	56	/* Core class values. */
	57	#define BCMA_CL_SIM 0x0
	58	#define BCMA_CL_EROM 0x1
	59	#define BCMA_CL_CORESIGHT 0x9
	60	#define BCMA_CL_VERIF 0xB
	61	#define BCMA_CL_OPTIMO 0xD
	62	#define BCMA_CL_GEN 0xE
	63	#define BCMA_CL_PRIMECELL 0xF
	64
	65	/* Core-ID values. */
	66	#define BCMA_CORE_OOB_ROUTER 0x367 /* Out of band */
	67	#define BCMA_CORE_INVALID 0x700
	68	#define BCMA_CORE_CHIPCOMMON 0x800
	69	#define BCMA_CORE_ILINE20 0x801
	70	#define BCMA_CORE_SRAM 0x802
	71	#define BCMA_CORE_SDRAM 0x803
	72	#define BCMA_CORE_PCI 0x804
	73	#define BCMA_CORE_MIPS 0x805
	74	#define BCMA_CORE_ETHERNET 0x806
	75	#define BCMA_CORE_V90 0x807
	76	#define BCMA_CORE_USB11_HOSTDEV 0x808
	77	#define BCMA_CORE_ADSL 0x809
	78	#define BCMA_CORE_ILINE100 0x80A
	79	#define BCMA_CORE_IPSEC 0x80B
	80	#define BCMA_CORE_UTOPIA 0x80C
	81	#define BCMA_CORE_PCMCIA 0x80D
	82	#define BCMA_CORE_INTERNAL_MEM 0x80E
	83	#define BCMA_CORE_MEMC_SDRAM 0x80F
	84	#define BCMA_CORE_OFDM 0x810
	85	#define BCMA_CORE_EXTIF 0x811
	86	#define BCMA_CORE_80211 0x812
	87	#define BCMA_CORE_PHY_A 0x813
	88	#define BCMA_CORE_PHY_B 0x814
	89	#define BCMA_CORE_PHY_G 0x815
	90	#define BCMA_CORE_MIPS_3302 0x816
	91	#define BCMA_CORE_USB11_HOST 0x817
	92	#define BCMA_CORE_USB11_DEV 0x818
	93	#define BCMA_CORE_USB20_HOST 0x819
	94	#define BCMA_CORE_USB20_DEV 0x81A
	95	#define BCMA_CORE_SDIO_HOST 0x81B
	96	#define BCMA_CORE_ROBOSWITCH 0x81C
	97	#define BCMA_CORE_PARA_ATA 0x81D
	98	#define BCMA_CORE_SATA_XORDMA 0x81E
	99	#define BCMA_CORE_ETHERNET_GBIT 0x81F
	100	#define BCMA_CORE_PCIE 0x820
	101	#define BCMA_CORE_PHY_N 0x821
	102	#define BCMA_CORE_SRAM_CTL 0x822
	103	#define BCMA_CORE_MINI_MACPHY 0x823
	104	#define BCMA_CORE_ARM_1176 0x824
	105	#define BCMA_CORE_ARM_7TDMI 0x825
	106	#define BCMA_CORE_PHY_LP 0x826
	107	#define BCMA_CORE_PMU 0x827
	108	#define BCMA_CORE_PHY_SSN 0x828
	109	#define BCMA_CORE_SDIO_DEV 0x829
110	#define BCMA_CORE_ARM_CM3 0x82A
111	#define BCMA_CORE_PHY_HT 0x82B
112	#define BCMA_CORE_MIPS_74K 0x82C
113	#define BCMA_CORE_MAC_GBIT 0x82D
114	#define BCMA_CORE_DDR12_MEM_CTL 0x82E
115	#define BCMA_CORE_PCIE_RC 0x82F /* PCIe Root Complex */
116	#define BCMA_CORE_OCP_OCP_BRIDGE 0x830
117	#define BCMA_CORE_SHARED_COMMON 0x831
118	#define BCMA_CORE_OCP_AHB_BRIDGE 0x832
119	#define BCMA_CORE_SPI_HOST 0x833
120	#define BCMA_CORE_I2S 0x834
121	#define BCMA_CORE_SDR_DDR1_MEM_CTL 0x835 /* SDR/DDR1 memory controller core */
122	#define BCMA_CORE_SHIM 0x837 /* SHIM component in ubus/6362 */
123	#define BCMA_CORE_DEFAULT 0xFFF
124
125	#define BCMA_MAX_NR_CORES 16
126
127	struct bcma_device {
128	struct bcma_bus *bus;
129	struct bcma_device_id id;
130
131	struct device dev;
1bdcd095 RM	132	struct device *dma_dev;
1bdcd095 RM	133	unsigned int irq;
8369ae33 RM	134	bool dev_registered;
	135
	136	u8 core_index;
	137
	138	u32 addr;
	139	u32 wrap;
	140
	141	void *drvdata;
	142	struct list_head list;
	143	};
	144
	145	static inline void bcma_get_drvdata(struct bcma_device core)
	146	{
	147	return core->drvdata;
	148	}
	149	static inline void bcma_set_drvdata(struct bcma_device core, void drvdata)
	150	{
	151	core->drvdata = drvdata;
	152	}
	153
	154	struct bcma_driver {
	155	const char *name;
	156	const struct bcma_device_id *id_table;
	157
	158	int (probe)(struct bcma_device dev);
	159	void (remove)(struct bcma_device dev);
	160	int (suspend)(struct bcma_device dev, pm_message_t state);
	161	int (resume)(struct bcma_device dev);
	162	void (shutdown)(struct bcma_device dev);
	163
	164	struct device_driver drv;
	165	};
	166	extern
	167	int __bcma_driver_register(struct bcma_driver drv, struct module owner);
	168	static inline int bcma_driver_register(struct bcma_driver *drv)
	169	{
	170	return __bcma_driver_register(drv, THIS_MODULE);
	171	}
	172	extern void bcma_driver_unregister(struct bcma_driver *drv);
	173
	174	struct bcma_bus {
	175	/* The MMIO area. */
	176	void __iomem *mmio;
	177
	178	const struct bcma_host_ops *ops;
	179
	180	enum bcma_hosttype hosttype;
	181	union {
	182	/* Pointer to the PCI bus (only for BCMA_HOSTTYPE_PCI) */
	183	struct pci_dev *host_pci;
	184	/* Pointer to the SDIO device (only for BCMA_HOSTTYPE_SDIO) */
	185	struct sdio_func *host_sdio;
	186	};
	187
	188	struct bcma_chipinfo chipinfo;
	189
	190	struct bcma_device *mapped_core;
	191	struct list_head cores;
	192	u8 nr_cores;
517f43e5	193	u8 init_done:1;
8369ae33 RM	194
	195	struct bcma_drv_cc drv_cc;
	196	struct bcma_drv_pci drv_pci;
27f18dc2 RM	197
	198	/* We decided to share SPROM struct with SSB as long as we do not need
	199	* any hacks for BCMA. This simplifies drivers code. */
	200	struct ssb_sprom sprom;
8369ae33 RM	201	};
	202
	203	extern inline u32 bcma_read8(struct bcma_device *core, u16 offset)
	204	{
	205	return core->bus->ops->read8(core, offset);
	206	}
	207	extern inline u32 bcma_read16(struct bcma_device *core, u16 offset)
	208	{
	209	return core->bus->ops->read16(core, offset);
	210	}
	211	extern inline u32 bcma_read32(struct bcma_device *core, u16 offset)
	212	{
	213	return core->bus->ops->read32(core, offset);
	214	}
	215	extern inline
	216	void bcma_write8(struct bcma_device *core, u16 offset, u32 value)
	217	{
	218	core->bus->ops->write8(core, offset, value);
	219	}
	220	extern inline
	221	void bcma_write16(struct bcma_device *core, u16 offset, u32 value)
	222	{
	223	core->bus->ops->write16(core, offset, value);
	224	}
	225	extern inline
	226	void bcma_write32(struct bcma_device *core, u16 offset, u32 value)
	227	{
	228	core->bus->ops->write32(core, offset, value);
	229	}
9d75ef0f RM	230	#ifdef CONFIG_BCMA_BLOCKIO
	231	extern inline void bcma_block_read(struct bcma_device core, void buffer,
	232	size_t count, u16 offset, u8 reg_width)
	233	{
	234	core->bus->ops->block_read(core, buffer, count, offset, reg_width);
	235	}
	236	extern inline void bcma_block_write(struct bcma_device core, const void buffer,
	237	size_t count, u16 offset, u8 reg_width)
	238	{
	239	core->bus->ops->block_write(core, buffer, count, offset, reg_width);
	240	}
	241	#endif
8369ae33 RM	242	extern inline u32 bcma_aread32(struct bcma_device *core, u16 offset)
	243	{
	244	return core->bus->ops->aread32(core, offset);
	245	}
	246	extern inline
	247	void bcma_awrite32(struct bcma_device *core, u16 offset, u32 value)
	248	{
	249	core->bus->ops->awrite32(core, offset, value);
	250	}
	251
3de1a774 RM	252	#define bcma_mask32(cc, offset, mask) \
	253	bcma_write32(cc, offset, bcma_read32(cc, offset) & (mask))
	254	#define bcma_set32(cc, offset, set) \
	255	bcma_write32(cc, offset, bcma_read32(cc, offset) \| (set))
	256	#define bcma_maskset32(cc, offset, mask, set) \
	257	bcma_write32(cc, offset, (bcma_read32(cc, offset) & (mask)) \| (set))
	258
8369ae33	259	extern bool bcma_core_is_enabled(struct bcma_device *core);
e3ae0cac	260	extern void bcma_core_disable(struct bcma_device *core, u32 flags);
8369ae33	261	extern int bcma_core_enable(struct bcma_device *core, u32 flags);
7424dd0d RM	262	extern void bcma_core_set_clockmode(struct bcma_device *core,
7424dd0d RM	263	enum bcma_clkmode clkmode);
6f53912f RM	264	extern void bcma_core_pll_ctl(struct bcma_device *core, u32 req, u32 status,
6f53912f RM	265	bool on);
05aec233 RM	266	#define BCMA_DMA_TRANSLATION_MASK 0xC0000000
	267	#define BCMA_DMA_TRANSLATION_NONE 0x00000000
	268	#define BCMA_DMA_TRANSLATION_DMA32_CMT 0x40000000 /* Client Mode Translation for 32-bit DMA */
	269	#define BCMA_DMA_TRANSLATION_DMA64_CMT 0x80000000 /* Client Mode Translation for 64-bit DMA */
	270	extern u32 bcma_core_dma_translation(struct bcma_device *core);
3de1a774	271
8369ae33	272	#endif /* LINUX_BCMA_H_ */