[deliverable/linux.git] / drivers / mtd / devices / bcm47xxsflash.c

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/mtd/mtd.h>
#include <linux/platform_device.h>
#include <linux/bcma/bcma.h>

#include "bcm47xxsflash.h"

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Serial flash driver for BCMA bus");

static const char * const probes[] = { "bcm47xxpart", NULL };

/**************************************************
 * Various helpers
 **************************************************/

static void bcm47xxsflash_cmd(struct bcm47xxsflash *b47s, u32 opcode)
{
	int i;

	b47s->cc_write(b47s, BCMA_CC_FLASHCTL, BCMA_CC_FLASHCTL_START | opcode);
	for (i = 0; i < 1000; i++) {
		if (!(b47s->cc_read(b47s, BCMA_CC_FLASHCTL) &
		      BCMA_CC_FLASHCTL_BUSY))
			return;
		cpu_relax();
	}
	pr_err("Control command failed (timeout)!\n");
}

static int bcm47xxsflash_poll(struct bcm47xxsflash *b47s, int timeout)
{
	unsigned long deadline = jiffies + timeout;

	do {
		switch (b47s->type) {
		case BCM47XXSFLASH_TYPE_ST:
			bcm47xxsflash_cmd(b47s, OPCODE_ST_RDSR);
			if (!(b47s->cc_read(b47s, BCMA_CC_FLASHDATA) &
			      SR_ST_WIP))
				return 0;
			break;
		case BCM47XXSFLASH_TYPE_ATMEL:
			bcm47xxsflash_cmd(b47s, OPCODE_AT_STATUS);
			if (b47s->cc_read(b47s, BCMA_CC_FLASHDATA) &
			    SR_AT_READY)
				return 0;
			break;
		}

		cpu_relax();
		udelay(1);
	} while (!time_after_eq(jiffies, deadline));

	pr_err("Timeout waiting for flash to be ready!\n");

	return -EBUSY;
}

/**************************************************
 * MTD ops
 **************************************************/

static int bcm47xxsflash_erase(struct mtd_info *mtd, struct erase_info *erase)
{
	struct bcm47xxsflash *b47s = mtd->priv;
	int err;

	switch (b47s->type) {
	case BCM47XXSFLASH_TYPE_ST:
		bcm47xxsflash_cmd(b47s, OPCODE_ST_WREN);
		b47s->cc_write(b47s, BCMA_CC_FLASHADDR, erase->addr);
		/* Newer flashes have "sub-sectors" which can be erased
		 * independently with a new command: ST_SSE. The ST_SE command
		 * erases 64KB just as before.
		 */
		if (b47s->blocksize < (64 * 1024))
			bcm47xxsflash_cmd(b47s, OPCODE_ST_SSE);
		else
			bcm47xxsflash_cmd(b47s, OPCODE_ST_SE);
		break;
	case BCM47XXSFLASH_TYPE_ATMEL:
		b47s->cc_write(b47s, BCMA_CC_FLASHADDR, erase->addr << 1);
		bcm47xxsflash_cmd(b47s, OPCODE_AT_PAGE_ERASE);
		break;
	}

	err = bcm47xxsflash_poll(b47s, HZ);
	if (err)
		erase->state = MTD_ERASE_FAILED;
	else
		erase->state = MTD_ERASE_DONE;

	if (erase->callback)
		erase->callback(erase);

	return err;
}

static int bcm47xxsflash_read(struct mtd_info *mtd, loff_t from, size_t len,
			      size_t *retlen, u_char *buf)
{
	struct bcm47xxsflash *b47s = mtd->priv;

	/* Check address range */
	if ((from + len) > mtd->size)
		return -EINVAL;

	memcpy_fromio(buf, (void __iomem *)KSEG0ADDR(b47s->window + from),
		      len);
	*retlen = len;

	return len;
}

static int bcm47xxsflash_write_st(struct mtd_info *mtd, u32 offset, size_t len,
				  const u_char *buf)
{
	struct bcm47xxsflash *b47s = mtd->priv;
	int written = 0;

	/* Enable writes */
	bcm47xxsflash_cmd(b47s, OPCODE_ST_WREN);

	/* Write first byte */
	b47s->cc_write(b47s, BCMA_CC_FLASHADDR, offset);
	b47s->cc_write(b47s, BCMA_CC_FLASHDATA, *buf++);

	/* Program page */
	if (b47s->bcma_cc->core->id.rev < 20) {
		bcm47xxsflash_cmd(b47s, OPCODE_ST_PP);
		return 1; /* 1B written */
	}

	/* Program page and set CSA (on newer chips we can continue writing) */
	bcm47xxsflash_cmd(b47s, OPCODE_ST_CSA | OPCODE_ST_PP);
	offset++;
	len--;
	written++;

	while (len > 0) {
		/* Page boundary, another function call is needed */
		if ((offset & 0xFF) == 0)
			break;

		bcm47xxsflash_cmd(b47s, OPCODE_ST_CSA | *buf++);
		offset++;
		len--;
		written++;
	}

	/* All done, drop CSA & poll */
	b47s->cc_write(b47s, BCMA_CC_FLASHCTL, 0);
	udelay(1);
	if (bcm47xxsflash_poll(b47s, HZ / 10))
		pr_err("Flash rejected dropping CSA\n");

	return written;
}

static int bcm47xxsflash_write_at(struct mtd_info *mtd, u32 offset, size_t len,
				  const u_char *buf)
{
	struct bcm47xxsflash *b47s = mtd->priv;
	u32 mask = b47s->blocksize - 1;
	u32 page = (offset & ~mask) << 1;
	u32 byte = offset & mask;
	int written = 0;

	/* If we don't overwrite whole page, read it to the buffer first */
	if (byte || (len < b47s->blocksize)) {
		int err;

		b47s->cc_write(b47s, BCMA_CC_FLASHADDR, page);
		bcm47xxsflash_cmd(b47s, OPCODE_AT_BUF1_LOAD);
		/* 250 us for AT45DB321B */
		err = bcm47xxsflash_poll(b47s, HZ / 1000);
		if (err) {
			pr_err("Timeout reading page 0x%X info buffer\n", page);
			return err;
		}
	}

	/* Change buffer content with our data */
	while (len > 0) {
		/* Page boundary, another function call is needed */
		if (byte == b47s->blocksize)
			break;

		b47s->cc_write(b47s, BCMA_CC_FLASHADDR, byte++);
		b47s->cc_write(b47s, BCMA_CC_FLASHDATA, *buf++);
		bcm47xxsflash_cmd(b47s, OPCODE_AT_BUF1_WRITE);
		len--;
		written++;
	}

	/* Program page with the buffer content */
	b47s->cc_write(b47s, BCMA_CC_FLASHADDR, page);
	bcm47xxsflash_cmd(b47s, OPCODE_AT_BUF1_PROGRAM);

	return written;
}

static int bcm47xxsflash_write(struct mtd_info *mtd, loff_t to, size_t len,
			       size_t *retlen, const u_char *buf)
{
	struct bcm47xxsflash *b47s = mtd->priv;
	int written;

	/* Writing functions can return without writing all passed data, for
	 * example when the hardware is too old or when we git page boundary.
	 */
	while (len > 0) {
		switch (b47s->type) {
		case BCM47XXSFLASH_TYPE_ST:
			written = bcm47xxsflash_write_st(mtd, to, len, buf);
			break;
		case BCM47XXSFLASH_TYPE_ATMEL:
			written = bcm47xxsflash_write_at(mtd, to, len, buf);
			break;
		default:
			BUG_ON(1);
		}
		if (written < 0) {
			pr_err("Error writing at offset 0x%llX\n", to);
			return written;
		}
		to += (loff_t)written;
		len -= written;
		*retlen += written;
		buf += written;
	}

	return 0;
}

static void bcm47xxsflash_fill_mtd(struct bcm47xxsflash *b47s)
{
	struct mtd_info *mtd = &b47s->mtd;

	mtd->priv = b47s;
	mtd->name = "bcm47xxsflash";
	mtd->owner = THIS_MODULE;

	mtd->type = MTD_NORFLASH;
	mtd->flags = MTD_CAP_NORFLASH;
	mtd->size = b47s->size;
	mtd->erasesize = b47s->blocksize;
	mtd->writesize = 1;
	mtd->writebufsize = 1;

	mtd->_erase = bcm47xxsflash_erase;
	mtd->_read = bcm47xxsflash_read;
	mtd->_write = bcm47xxsflash_write;
}

/**************************************************
 * BCMA
 **************************************************/

static int bcm47xxsflash_bcma_cc_read(struct bcm47xxsflash *b47s, u16 offset)
{
	return bcma_cc_read32(b47s->bcma_cc, offset);
}

static void bcm47xxsflash_bcma_cc_write(struct bcm47xxsflash *b47s, u16 offset,
					u32 value)
{
	bcma_cc_write32(b47s->bcma_cc, offset, value);
}

static int bcm47xxsflash_bcma_probe(struct platform_device *pdev)
{
	struct bcma_sflash *sflash = dev_get_platdata(&pdev->dev);
	struct bcm47xxsflash *b47s;
	int err;

	b47s = devm_kzalloc(&pdev->dev, sizeof(*b47s), GFP_KERNEL);
	if (!b47s)
		return -ENOMEM;
	sflash->priv = b47s;

	b47s->bcma_cc = container_of(sflash, struct bcma_drv_cc, sflash);
	b47s->cc_read = bcm47xxsflash_bcma_cc_read;
	b47s->cc_write = bcm47xxsflash_bcma_cc_write;

	switch (b47s->bcma_cc->capabilities & BCMA_CC_CAP_FLASHT) {
	case BCMA_CC_FLASHT_STSER:
		b47s->type = BCM47XXSFLASH_TYPE_ST;
		break;
	case BCMA_CC_FLASHT_ATSER:
		b47s->type = BCM47XXSFLASH_TYPE_ATMEL;
		break;
	}

	b47s->window = sflash->window;
	b47s->blocksize = sflash->blocksize;
	b47s->numblocks = sflash->numblocks;
	b47s->size = sflash->size;
	bcm47xxsflash_fill_mtd(b47s);

	err = mtd_device_parse_register(&b47s->mtd, probes, NULL, NULL, 0);
	if (err) {
		pr_err("Failed to register MTD device: %d\n", err);
		return err;
	}

	if (bcm47xxsflash_poll(b47s, HZ / 10))
		pr_warn("Serial flash busy\n");

	return 0;
}

static int bcm47xxsflash_bcma_remove(struct platform_device *pdev)
{
	struct bcma_sflash *sflash = dev_get_platdata(&pdev->dev);
	struct bcm47xxsflash *b47s = sflash->priv;

	mtd_device_unregister(&b47s->mtd);

	return 0;
}

static struct platform_driver bcma_sflash_driver = {
	.probe	= bcm47xxsflash_bcma_probe,
	.remove = bcm47xxsflash_bcma_remove,
	.driver = {
		.name = "bcma_sflash",
		.owner = THIS_MODULE,
	},
};

/**************************************************
 * Init
 **************************************************/

module_platform_driver(bcma_sflash_driver);
Commit	Line	Data
5fe42d5b RM	1	#include <linux/kernel.h>
	2	#include <linux/module.h>
	3	#include <linux/slab.h>
bddcb5e7	4	#include <linux/delay.h>
5fe42d5b RM	5	#include <linux/mtd/mtd.h>
	6	#include <linux/platform_device.h>
	7	#include <linux/bcma/bcma.h>
	8
a2f74a7d RM	9	#include "bcm47xxsflash.h"
a2f74a7d RM	10
5fe42d5b RM	11	MODULE_LICENSE("GPL");
	12	MODULE_DESCRIPTION("Serial flash driver for BCMA bus");
	13
afffeec9	14	static const char * const probes[] = { "bcm47xxpart", NULL };
5fe42d5b	15
bddcb5e7 RM	16	/**************************************************
	17	* Various helpers
	18	**************************************************/
	19
	20	static void bcm47xxsflash_cmd(struct bcm47xxsflash *b47s, u32 opcode)
	21	{
	22	int i;
	23
	24	b47s->cc_write(b47s, BCMA_CC_FLASHCTL, BCMA_CC_FLASHCTL_START \| opcode);
	25	for (i = 0; i < 1000; i++) {
	26	if (!(b47s->cc_read(b47s, BCMA_CC_FLASHCTL) &
	27	BCMA_CC_FLASHCTL_BUSY))
	28	return;
	29	cpu_relax();
	30	}
	31	pr_err("Control command failed (timeout)!\n");
	32	}
	33
	34	static int bcm47xxsflash_poll(struct bcm47xxsflash *b47s, int timeout)
	35	{
	36	unsigned long deadline = jiffies + timeout;
	37
	38	do {
	39	switch (b47s->type) {
	40	case BCM47XXSFLASH_TYPE_ST:
	41	bcm47xxsflash_cmd(b47s, OPCODE_ST_RDSR);
	42	if (!(b47s->cc_read(b47s, BCMA_CC_FLASHDATA) &
	43	SR_ST_WIP))
	44	return 0;
	45	break;
	46	case BCM47XXSFLASH_TYPE_ATMEL:
	47	bcm47xxsflash_cmd(b47s, OPCODE_AT_STATUS);
	48	if (b47s->cc_read(b47s, BCMA_CC_FLASHDATA) &
	49	SR_AT_READY)
	50	return 0;
	51	break;
	52	}
	53
	54	cpu_relax();
	55	udelay(1);
	56	} while (!time_after_eq(jiffies, deadline));
	57
	58	pr_err("Timeout waiting for flash to be ready!\n");
	59
	60	return -EBUSY;
	61	}
	62
	63	/**************************************************
	64	* MTD ops
	65	**************************************************/
	66
c0fcbc56 RM	67	static int bcm47xxsflash_erase(struct mtd_info mtd, struct erase_info erase)
	68	{
	69	struct bcm47xxsflash *b47s = mtd->priv;
	70	int err;
	71
	72	switch (b47s->type) {
	73	case BCM47XXSFLASH_TYPE_ST:
	74	bcm47xxsflash_cmd(b47s, OPCODE_ST_WREN);
	75	b47s->cc_write(b47s, BCMA_CC_FLASHADDR, erase->addr);
	76	/* Newer flashes have "sub-sectors" which can be erased
	77	* independently with a new command: ST_SSE. The ST_SE command
	78	* erases 64KB just as before.
	79	*/
	80	if (b47s->blocksize < (64 * 1024))
	81	bcm47xxsflash_cmd(b47s, OPCODE_ST_SSE);
	82	else
	83	bcm47xxsflash_cmd(b47s, OPCODE_ST_SE);
	84	break;
	85	case BCM47XXSFLASH_TYPE_ATMEL:
	86	b47s->cc_write(b47s, BCMA_CC_FLASHADDR, erase->addr << 1);
	87	bcm47xxsflash_cmd(b47s, OPCODE_AT_PAGE_ERASE);
	88	break;
	89	}
	90
	91	err = bcm47xxsflash_poll(b47s, HZ);
	92	if (err)
	93	erase->state = MTD_ERASE_FAILED;
	94	else
	95	erase->state = MTD_ERASE_DONE;
	96
	97	if (erase->callback)
	98	erase->callback(erase);
	99
	100	return err;
	101	}
	102
5fe42d5b RM	103	static int bcm47xxsflash_read(struct mtd_info *mtd, loff_t from, size_t len,
	104	size_t retlen, u_char buf)
	105	{
a2f74a7d	106	struct bcm47xxsflash *b47s = mtd->priv;
5fe42d5b RM	107
	108	/* Check address range */
	109	if ((from + len) > mtd->size)
	110	return -EINVAL;
	111
a2f74a7d	112	memcpy_fromio(buf, (void __iomem *)KSEG0ADDR(b47s->window + from),
5fe42d5b	113	len);
60aca067	114	*retlen = len;
5fe42d5b RM	115
	116	return len;
	117	}
	118
13134f48 RM	119	static int bcm47xxsflash_write_st(struct mtd_info *mtd, u32 offset, size_t len,
	120	const u_char *buf)
	121	{
	122	struct bcm47xxsflash *b47s = mtd->priv;
	123	int written = 0;
	124
	125	/* Enable writes */
	126	bcm47xxsflash_cmd(b47s, OPCODE_ST_WREN);
	127
	128	/* Write first byte */
	129	b47s->cc_write(b47s, BCMA_CC_FLASHADDR, offset);
	130	b47s->cc_write(b47s, BCMA_CC_FLASHDATA, *buf++);
	131
	132	/* Program page */
	133	if (b47s->bcma_cc->core->id.rev < 20) {
	134	bcm47xxsflash_cmd(b47s, OPCODE_ST_PP);
	135	return 1; /* 1B written */
	136	}
	137
	138	/* Program page and set CSA (on newer chips we can continue writing) */
	139	bcm47xxsflash_cmd(b47s, OPCODE_ST_CSA \| OPCODE_ST_PP);
	140	offset++;
	141	len--;
	142	written++;
	143
	144	while (len > 0) {
	145	/* Page boundary, another function call is needed */
	146	if ((offset & 0xFF) == 0)
	147	break;
	148
	149	bcm47xxsflash_cmd(b47s, OPCODE_ST_CSA \| *buf++);
	150	offset++;
	151	len--;
	152	written++;
	153	}
	154
	155	/* All done, drop CSA & poll */
	156	b47s->cc_write(b47s, BCMA_CC_FLASHCTL, 0);
	157	udelay(1);
	158	if (bcm47xxsflash_poll(b47s, HZ / 10))
	159	pr_err("Flash rejected dropping CSA\n");
	160
	161	return written;
	162	}
	163
	164	static int bcm47xxsflash_write_at(struct mtd_info *mtd, u32 offset, size_t len,
	165	const u_char *buf)
	166	{
	167	struct bcm47xxsflash *b47s = mtd->priv;
	168	u32 mask = b47s->blocksize - 1;
	169	u32 page = (offset & ~mask) << 1;
	170	u32 byte = offset & mask;
	171	int written = 0;
	172
	173	/* If we don't overwrite whole page, read it to the buffer first */
	174	if (byte \|\| (len < b47s->blocksize)) {
	175	int err;
	176
	177	b47s->cc_write(b47s, BCMA_CC_FLASHADDR, page);
	178	bcm47xxsflash_cmd(b47s, OPCODE_AT_BUF1_LOAD);
	179	/* 250 us for AT45DB321B */
	180	err = bcm47xxsflash_poll(b47s, HZ / 1000);
	181	if (err) {
	182	pr_err("Timeout reading page 0x%X info buffer\n", page);
183	return err;
184	}
185	}
186
187	/* Change buffer content with our data */
188	while (len > 0) {
189	/* Page boundary, another function call is needed */
190	if (byte == b47s->blocksize)
191	break;
192
193	b47s->cc_write(b47s, BCMA_CC_FLASHADDR, byte++);
194	b47s->cc_write(b47s, BCMA_CC_FLASHDATA, *buf++);
195	bcm47xxsflash_cmd(b47s, OPCODE_AT_BUF1_WRITE);
196	len--;
197	written++;
198	}
199
200	/* Program page with the buffer content */
201	b47s->cc_write(b47s, BCMA_CC_FLASHADDR, page);
202	bcm47xxsflash_cmd(b47s, OPCODE_AT_BUF1_PROGRAM);
203
204	return written;
205	}
206
207	static int bcm47xxsflash_write(struct mtd_info *mtd, loff_t to, size_t len,
208	size_t retlen, const u_char buf)
209	{
210	struct bcm47xxsflash *b47s = mtd->priv;
211	int written;
212
213	/* Writing functions can return without writing all passed data, for
214	* example when the hardware is too old or when we git page boundary.
215	*/
216	while (len > 0) {
217	switch (b47s->type) {
218	case BCM47XXSFLASH_TYPE_ST:
219	written = bcm47xxsflash_write_st(mtd, to, len, buf);
220	break;
221	case BCM47XXSFLASH_TYPE_ATMEL:
222	written = bcm47xxsflash_write_at(mtd, to, len, buf);
223	break;
224	default:
225	BUG_ON(1);
226	}
227	if (written < 0) {
228	pr_err("Error writing at offset 0x%llX\n", to);
229	return written;
230	}
231	to += (loff_t)written;
232	len -= written;
233	*retlen += written;
234	buf += written;
235	}
236
237	return 0;
238	}
239
a2f74a7d	240	static void bcm47xxsflash_fill_mtd(struct bcm47xxsflash *b47s)
5fe42d5b	241	{
a2f74a7d RM	242	struct mtd_info *mtd = &b47s->mtd;
	243
	244	mtd->priv = b47s;
5fe42d5b RM	245	mtd->name = "bcm47xxsflash";
5fe42d5b RM	246	mtd->owner = THIS_MODULE;
5fe42d5b	247
13134f48 RM	248	mtd->type = MTD_NORFLASH;
13134f48 RM	249	mtd->flags = MTD_CAP_NORFLASH;
c0fcbc56 RM	250	mtd->size = b47s->size;
c0fcbc56 RM	251	mtd->erasesize = b47s->blocksize;
13134f48 RM	252	mtd->writesize = 1;
13134f48 RM	253	mtd->writebufsize = 1;
c0fcbc56 RM	254
	255	mtd->_erase = bcm47xxsflash_erase;
	256	mtd->_read = bcm47xxsflash_read;
13134f48	257	mtd->_write = bcm47xxsflash_write;
5fe42d5b RM	258	}
5fe42d5b RM	259
f1a7c9d3 RM	260	/**************************************************
	261	* BCMA
	262	**************************************************/
	263
265dfbd9 RM	264	static int bcm47xxsflash_bcma_cc_read(struct bcm47xxsflash *b47s, u16 offset)
	265	{
	266	return bcma_cc_read32(b47s->bcma_cc, offset);
	267	}
	268
	269	static void bcm47xxsflash_bcma_cc_write(struct bcm47xxsflash *b47s, u16 offset,
	270	u32 value)
	271	{
	272	bcma_cc_write32(b47s->bcma_cc, offset, value);
	273	}
	274
f1a7c9d3	275	static int bcm47xxsflash_bcma_probe(struct platform_device *pdev)
5fe42d5b RM	276	{
5fe42d5b RM	277	struct bcma_sflash *sflash = dev_get_platdata(&pdev->dev);
a2f74a7d	278	struct bcm47xxsflash *b47s;
5fe42d5b RM	279	int err;
5fe42d5b RM	280
d2b1bd14 LC	281	b47s = devm_kzalloc(&pdev->dev, sizeof(*b47s), GFP_KERNEL);
	282	if (!b47s)
	283	return -ENOMEM;
a2f74a7d RM	284	sflash->priv = b47s;
a2f74a7d RM	285
41c81536	286	b47s->bcma_cc = container_of(sflash, struct bcma_drv_cc, sflash);
265dfbd9 RM	287	b47s->cc_read = bcm47xxsflash_bcma_cc_read;
265dfbd9 RM	288	b47s->cc_write = bcm47xxsflash_bcma_cc_write;
41c81536	289
1f816bc7 RM	290	switch (b47s->bcma_cc->capabilities & BCMA_CC_CAP_FLASHT) {
	291	case BCMA_CC_FLASHT_STSER:
	292	b47s->type = BCM47XXSFLASH_TYPE_ST;
	293	break;
	294	case BCMA_CC_FLASHT_ATSER:
	295	b47s->type = BCM47XXSFLASH_TYPE_ATMEL;
	296	break;
	297	}
	298
a2f74a7d RM	299	b47s->window = sflash->window;
	300	b47s->blocksize = sflash->blocksize;
	301	b47s->numblocks = sflash->numblocks;
	302	b47s->size = sflash->size;
	303	bcm47xxsflash_fill_mtd(b47s);
5fe42d5b	304
a2f74a7d	305	err = mtd_device_parse_register(&b47s->mtd, probes, NULL, NULL, 0);
5fe42d5b RM	306	if (err) {
5fe42d5b RM	307	pr_err("Failed to register MTD device: %d\n", err);
d2b1bd14	308	return err;
5fe42d5b RM	309	}
5fe42d5b RM	310
bddcb5e7 RM	311	if (bcm47xxsflash_poll(b47s, HZ / 10))
	312	pr_warn("Serial flash busy\n");
	313
5fe42d5b	314	return 0;
5fe42d5b RM	315	}
5fe42d5b RM	316
f1a7c9d3	317	static int bcm47xxsflash_bcma_remove(struct platform_device *pdev)
5fe42d5b RM	318	{
5fe42d5b RM	319	struct bcma_sflash *sflash = dev_get_platdata(&pdev->dev);
a2f74a7d	320	struct bcm47xxsflash *b47s = sflash->priv;
5fe42d5b	321
a2f74a7d	322	mtd_device_unregister(&b47s->mtd);
5fe42d5b RM	323
	324	return 0;
	325	}
	326
	327	static struct platform_driver bcma_sflash_driver = {
f1a7c9d3 RM	328	.probe = bcm47xxsflash_bcma_probe,
f1a7c9d3 RM	329	.remove = bcm47xxsflash_bcma_remove,
5fe42d5b RM	330	.driver = {
	331	.name = "bcma_sflash",
	332	.owner = THIS_MODULE,
	333	},
	334	};
	335
f1a7c9d3 RM	336	/**************************************************
	337	* Init
	338	**************************************************/
	339
8268df26	340	module_platform_driver(bcma_sflash_driver);