1 --- a/drivers/mtd/devices/bcm47xxsflash.c
2 +++ b/drivers/mtd/devices/bcm47xxsflash.c
4 -#include <linux/kernel.h>
6 + * Broadcom SiliconBackplane chipcommon serial flash interface
8 + * Copyright 2011, 2012, Hauke Mehrtens <hauke@hauke-m.de>
9 + * Copyright 2006, Broadcom Corporation
10 + * All Rights Reserved.
12 + * Licensed under the GNU/GPL. See COPYING for details.
15 +#define pr_fmt(fmt) "bcm47xxsflash: " fmt
16 #include <linux/module.h>
17 #include <linux/slab.h>
18 +#include <linux/ioport.h>
19 +#include <linux/sched.h>
20 #include <linux/mtd/mtd.h>
21 +#include <linux/mtd/map.h>
22 +#include <linux/mtd/partitions.h>
23 +#include <linux/errno.h>
24 +#include <linux/delay.h>
25 #include <linux/platform_device.h>
26 -#include <linux/bcma/bcma.h>
28 -#include "bcm47xxsflash.h"
29 +#include <linux/mtd/bcm47xxsflash.h>
31 MODULE_LICENSE("GPL");
32 -MODULE_DESCRIPTION("Serial flash driver for BCMA bus");
33 +MODULE_DESCRIPTION("BCM47XX serial flash driver");
35 static const char *probes[] = { "bcm47xxpart", NULL };
38 +sflash_mtd_poll(struct bcm47xxsflash *sflash, unsigned int offset, int timeout)
40 + unsigned long now = jiffies;
43 + if (!sflash->poll(sflash, offset)) {
46 + if (time_after(jiffies, now + timeout)) {
47 + pr_err("timeout while polling\n");
58 static int bcm47xxsflash_read(struct mtd_info *mtd, loff_t from, size_t len,
59 size_t *retlen, u_char *buf)
61 - struct bcm47xxsflash *b47s = mtd->priv;
62 + struct bcm47xxsflash *sflash = (struct bcm47xxsflash *)mtd->priv;
64 /* Check address range */
68 if ((from + len) > mtd->size)
71 - memcpy_fromio(buf, (void __iomem *)KSEG0ADDR(b47s->window + from),
72 + memcpy_fromio(buf, (void __iomem *)KSEG0ADDR(sflash->window + from),
79 -static void bcm47xxsflash_fill_mtd(struct bcm47xxsflash *b47s)
81 +sflash_mtd_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf)
83 - struct mtd_info *mtd = &b47s->mtd;
86 + struct bcm47xxsflash *sflash = (struct bcm47xxsflash *)mtd->priv;
89 - mtd->name = "bcm47xxsflash";
90 - mtd->owner = THIS_MODULE;
91 - mtd->type = MTD_ROM;
92 - mtd->size = b47s->size;
93 - mtd->_read = bcm47xxsflash_read;
94 + /* Check address range */
98 + if ((to + len) > mtd->size)
103 + ret = sflash->write(sflash, to, len, buf);
109 + ret = sflash_mtd_poll(sflash, (unsigned int) to, HZ / 10);
113 + to += (loff_t) bytes;
119 - /* TODO: implement writing support and verify/change following code */
120 - mtd->flags = MTD_CAP_ROM;
121 - mtd->writebufsize = mtd->writesize = 1;
126 +sflash_mtd_erase(struct mtd_info *mtd, struct erase_info *erase)
128 + struct bcm47xxsflash *sflash = (struct bcm47xxsflash *) mtd->priv;
130 + unsigned int addr, len;
132 + /* Check address range */
135 + if ((erase->addr + erase->len) > mtd->size)
138 + addr = erase->addr;
141 + /* Ensure that requested regions are aligned */
142 + for (i = 0; i < mtd->numeraseregions; i++) {
143 + for (j = 0; j < mtd->eraseregions[i].numblocks; j++) {
144 + if (addr == mtd->eraseregions[i].offset +
145 + mtd->eraseregions[i].erasesize * j &&
146 + len >= mtd->eraseregions[i].erasesize) {
147 + ret = sflash->erase(sflash, addr);
150 + ret = sflash_mtd_poll(sflash, addr, 10 * HZ);
153 + addr += mtd->eraseregions[i].erasesize;
154 + len -= mtd->eraseregions[i].erasesize;
161 + /* Set erase status */
163 + erase->state = MTD_ERASE_FAILED;
165 + erase->state = MTD_ERASE_DONE;
167 + /* Call erase callback */
168 + if (erase->callback)
169 + erase->callback(erase);
174 /**************************************************
175 @@ -50,53 +156,94 @@ static void bcm47xxsflash_fill_mtd(struc
177 static int bcm47xxsflash_bcma_probe(struct platform_device *pdev)
179 - struct bcma_sflash *sflash = dev_get_platdata(&pdev->dev);
180 - struct bcm47xxsflash *b47s;
182 + struct bcm47xxsflash *sflash = dev_get_platdata(&pdev->dev);
183 + struct mtd_info *mtd;
184 + struct mtd_erase_region_info *eraseregions;
187 + mtd = kzalloc(sizeof(struct mtd_info), GFP_KERNEL);
193 - b47s = kzalloc(sizeof(*b47s), GFP_KERNEL);
198 - sflash->priv = b47s;
200 - b47s->window = sflash->window;
201 - b47s->blocksize = sflash->blocksize;
202 - b47s->numblocks = sflash->numblocks;
203 - b47s->size = sflash->size;
204 - bcm47xxsflash_fill_mtd(b47s);
206 - err = mtd_device_parse_register(&b47s->mtd, probes, NULL, NULL, 0);
208 - pr_err("Failed to register MTD device: %d\n", err);
210 + eraseregions = kzalloc(sizeof(struct mtd_erase_region_info), GFP_KERNEL);
211 + if (!eraseregions) {
216 + pr_info("found serial flash: blocksize=%dKB, numblocks=%d, size=%dKB\n",
217 + sflash->blocksize / 1024, sflash->numblocks, sflash->size / 1024);
219 + /* Setup region info */
220 + eraseregions->offset = 0;
221 + eraseregions->erasesize = sflash->blocksize;
222 + eraseregions->numblocks = sflash->numblocks;
223 + if (eraseregions->erasesize > mtd->erasesize)
224 + mtd->erasesize = eraseregions->erasesize;
225 + mtd->size = sflash->size;
226 + mtd->numeraseregions = 1;
228 + /* Register with MTD */
229 + mtd->name = "bcm47xx-sflash";
230 + mtd->type = MTD_NORFLASH;
231 + mtd->flags = MTD_CAP_NORFLASH;
232 + mtd->eraseregions = eraseregions;
233 + mtd->_erase = sflash_mtd_erase;
234 + mtd->_read = bcm47xxsflash_read;
235 + mtd->_write = sflash_mtd_write;
236 + mtd->writesize = 1;
237 + mtd->priv = sflash;
238 + ret = dev_set_drvdata(&pdev->dev, mtd);
239 + mtd->owner = THIS_MODULE;
241 + pr_err("adding private data failed\n");
242 + goto err_free_eraseregions;
245 + ret = mtd_device_parse_register(mtd, probes, NULL, NULL, 0);
248 + pr_err("mtd_device_register failed\n");
249 + goto err_free_eraseregions;
257 +err_free_eraseregions:
258 + kfree(eraseregions);
265 static int bcm47xxsflash_bcma_remove(struct platform_device *pdev)
267 - struct bcma_sflash *sflash = dev_get_platdata(&pdev->dev);
268 - struct bcm47xxsflash *b47s = sflash->priv;
270 - mtd_device_unregister(&b47s->mtd);
272 + struct mtd_info *mtd = dev_get_drvdata(&pdev->dev);
275 + mtd_device_unregister(mtd);
277 + kfree(mtd->eraseregions);
279 + dev_set_drvdata(&pdev->dev, NULL);
284 +static const struct platform_device_id bcm47xxsflash_table[] = {
285 + { "bcm47xx-sflash", 0 },
288 +MODULE_DEVICE_TABLE(platform, bcm47xxsflash_table);
290 static struct platform_driver bcma_sflash_driver = {
291 + .id_table = bcm47xxsflash_table,
292 .probe = bcm47xxsflash_bcma_probe,
293 .remove = bcm47xxsflash_bcma_remove,
295 - .name = "bcma_sflash",
296 + .name = "bcm47xx-sflash",
297 .owner = THIS_MODULE,
300 @@ -111,8 +258,7 @@ static int __init bcm47xxsflash_init(voi
302 err = platform_driver_register(&bcma_sflash_driver);
304 - pr_err("Failed to register BCMA serial flash driver: %d\n",
306 + pr_err("error registering platform driver: %i\n", err);
311 +++ b/include/linux/mtd/bcm47xxsflash.h
313 +#ifndef LINUX_MTD_BCM47XX_SFLASH_H_
314 +#define LINUX_MTD_BCM47XX_SFLASH_H_
316 +#include <linux/mtd/mtd.h>
318 +enum bcm47xxsflash_type {
319 + BCM47XX_SFLASH_SSB,
320 + BCM47XX_SFLASH_BCMA,
323 +struct ssb_chipcommon;
326 +struct bcm47xxsflash {
327 + enum bcm47xxsflash_type type;
329 + struct ssb_chipcommon *scc;
330 + struct bcma_drv_cc *bcc;
339 + int (*poll)(struct bcm47xxsflash *dev, u32 offset);
340 + int (*write)(struct bcm47xxsflash *dev, u32 offset, u32 len, const u8 *buf);
341 + int (*erase)(struct bcm47xxsflash *dev, u32 offset);
343 + struct mtd_info *mtd;
345 +#endif /* LINUX_MTD_BCM47XX_SFLASH_H_ */