Root/target/linux/brcm47xx/patches-3.3/052-mtd-add-serial-flash-driver.patch

1--- a/drivers/mtd/maps/Kconfig
2+++ b/drivers/mtd/maps/Kconfig
3@@ -257,6 +257,15 @@ config MTD_BCM47XX_PFLASH
4     help
5       Support for bcm47xx parallel flash
6 
7+config MTD_BCM47XX_SFLASH
8+ tristate "bcm47xx serial flash support"
9+ default y
10+ depends on BCM47XX
11+ select MTD_PARTITIONS
12+ select MTD_BCM47XX_PARTS
13+ help
14+ Support for bcm47xx parallel flash
15+
16 config MTD_DILNETPC
17     tristate "CFI Flash device mapped on DIL/Net PC"
18     depends on X86 && MTD_CFI_INTELEXT && BROKEN
19--- a/drivers/mtd/maps/Makefile
20+++ b/drivers/mtd/maps/Makefile
21@@ -58,3 +58,4 @@ obj-$(CONFIG_MTD_GPIO_ADDR) += gpio-addr
22 obj-$(CONFIG_MTD_LATCH_ADDR) += latch-addr-flash.o
23 obj-$(CONFIG_MTD_LANTIQ) += lantiq-flash.o
24 obj-$(CONFIG_MTD_BCM47XX_PFLASH)+= bcm47xx-pflash.o
25+obj-$(CONFIG_MTD_BCM47XX_SFLASH)+= bcm47xx-sflash.o
26--- /dev/null
27+++ b/drivers/mtd/maps/bcm47xx-sflash.c
28@@ -0,0 +1,270 @@
29+/*
30+ * Broadcom SiliconBackplane chipcommon serial flash interface
31+ *
32+ * Copyright 2011, 2012, Hauke Mehrtens <hauke@hauke-m.de>
33+ * Copyright 2006, Broadcom Corporation
34+ * All Rights Reserved.
35+ *
36+ * Licensed under the GNU/GPL. See COPYING for details.
37+ */
38+
39+#define pr_fmt(fmt) "bcm47xx_sflash: " fmt
40+#include <linux/module.h>
41+#include <linux/slab.h>
42+#include <linux/ioport.h>
43+#include <linux/sched.h>
44+#include <linux/mtd/mtd.h>
45+#include <linux/mtd/map.h>
46+#include <linux/mtd/partitions.h>
47+#include <linux/errno.h>
48+#include <linux/delay.h>
49+#include <linux/platform_device.h>
50+#include <linux/mtd/bcm47xx_sflash.h>
51+
52+static int
53+sflash_mtd_poll(struct bcm47xx_sflash *sflash, unsigned int offset, int timeout)
54+{
55+ unsigned long now = jiffies;
56+
57+ for (;;) {
58+ if (!sflash->poll(sflash, offset)) {
59+ break;
60+ }
61+ if (time_after(jiffies, now + timeout)) {
62+ pr_err("timeout while polling\n");
63+ return -ETIMEDOUT;
64+
65+ }
66+ cpu_relax();
67+ udelay(1);
68+ }
69+
70+ return 0;
71+}
72+
73+static int
74+sflash_mtd_read(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf)
75+{
76+ struct bcm47xx_sflash *sflash = (struct bcm47xx_sflash *)mtd->priv;
77+
78+ /* Check address range */
79+ if (!len)
80+ return 0;
81+
82+ if ((from + len) > mtd->size)
83+ return -EINVAL;
84+
85+ *retlen = 0;
86+ while (len) {
87+ int ret = sflash->read(sflash, from, len, buf);
88+ if (ret < 0)
89+ return ret;
90+
91+ from += (loff_t) ret;
92+ len -= ret;
93+ buf += ret;
94+ *retlen += ret;
95+ }
96+
97+ return 0;
98+}
99+
100+static int
101+sflash_mtd_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf)
102+{
103+ int bytes;
104+ int ret;
105+ struct bcm47xx_sflash *sflash = (struct bcm47xx_sflash *)mtd->priv;
106+
107+ /* Check address range */
108+ if (!len)
109+ return 0;
110+
111+ if ((to + len) > mtd->size)
112+ return -EINVAL;
113+
114+ *retlen = 0;
115+ while (len) {
116+ ret = sflash->write(sflash, to, len, buf);
117+ if (ret < 0)
118+ return ret;
119+
120+ bytes = ret;
121+
122+ ret = sflash_mtd_poll(sflash, (unsigned int) to, HZ / 10);
123+ if (ret)
124+ return ret;
125+
126+ to += (loff_t) bytes;
127+ len -= bytes;
128+ buf += bytes;
129+ *retlen += bytes;
130+ }
131+
132+ return 0;
133+}
134+
135+static int
136+sflash_mtd_erase(struct mtd_info *mtd, struct erase_info *erase)
137+{
138+ struct bcm47xx_sflash *sflash = (struct bcm47xx_sflash *) mtd->priv;
139+ int i, j, ret = 0;
140+ unsigned int addr, len;
141+
142+ /* Check address range */
143+ if (!erase->len)
144+ return 0;
145+ if ((erase->addr + erase->len) > mtd->size)
146+ return -EINVAL;
147+
148+ addr = erase->addr;
149+ len = erase->len;
150+
151+ /* Ensure that requested regions are aligned */
152+ for (i = 0; i < mtd->numeraseregions; i++) {
153+ for (j = 0; j < mtd->eraseregions[i].numblocks; j++) {
154+ if (addr == mtd->eraseregions[i].offset +
155+ mtd->eraseregions[i].erasesize * j &&
156+ len >= mtd->eraseregions[i].erasesize) {
157+ ret = sflash->erase(sflash, addr);
158+ if (ret < 0)
159+ break;
160+ ret = sflash_mtd_poll(sflash, addr, 10 * HZ);
161+ if (ret)
162+ break;
163+ addr += mtd->eraseregions[i].erasesize;
164+ len -= mtd->eraseregions[i].erasesize;
165+ }
166+ }
167+ if (ret)
168+ break;
169+ }
170+
171+ /* Set erase status */
172+ if (ret)
173+ erase->state = MTD_ERASE_FAILED;
174+ else
175+ erase->state = MTD_ERASE_DONE;
176+
177+ /* Call erase callback */
178+ if (erase->callback)
179+ erase->callback(erase);
180+
181+ return ret;
182+}
183+
184+static const char *probes[] = { "bcm47xx", NULL };
185+
186+static int bcm47xx_sflash_probe(struct platform_device *pdev)
187+{
188+ struct bcm47xx_sflash *sflash = dev_get_platdata(&pdev->dev);
189+ struct mtd_info *mtd;
190+ struct mtd_erase_region_info *eraseregions;
191+ int ret = 0;
192+
193+ mtd = kzalloc(sizeof(struct mtd_info), GFP_KERNEL);
194+ if (!mtd){
195+ ret = -ENOMEM;
196+ goto err_out;
197+ }
198+
199+ eraseregions = kzalloc(sizeof(struct mtd_erase_region_info), GFP_KERNEL);
200+ if (!eraseregions) {
201+ ret = -ENOMEM;
202+ goto err_free_mtd;
203+ }
204+
205+ pr_info("found serial flash: blocksize=%dKB, numblocks=%d, size=%dKB\n",
206+ sflash->blocksize / 1024, sflash->numblocks, sflash->size / 1024);
207+
208+ /* Setup region info */
209+ eraseregions->offset = 0;
210+ eraseregions->erasesize = sflash->blocksize;
211+ eraseregions->numblocks = sflash->numblocks;
212+ if (eraseregions->erasesize > mtd->erasesize)
213+ mtd->erasesize = eraseregions->erasesize;
214+ mtd->size = sflash->size;
215+ mtd->numeraseregions = 1;
216+
217+ /* Register with MTD */
218+ mtd->name = "bcm47xx-sflash";
219+ mtd->type = MTD_NORFLASH;
220+ mtd->flags = MTD_CAP_NORFLASH;
221+ mtd->eraseregions = eraseregions;
222+ mtd->erase = sflash_mtd_erase;
223+ mtd->read = sflash_mtd_read;
224+ mtd->write = sflash_mtd_write;
225+ mtd->writesize = 1;
226+ mtd->priv = sflash;
227+ ret = dev_set_drvdata(&pdev->dev, mtd);
228+ mtd->owner = THIS_MODULE;
229+ if (ret) {
230+ pr_err("adding private data failed\n");
231+ goto err_free_eraseregions;
232+ }
233+
234+ ret = mtd_device_parse_register(mtd, probes, NULL, NULL, 0);
235+
236+ if (ret) {
237+ pr_err("mtd_device_register failed\n");
238+ goto err_free_eraseregions;
239+ }
240+ return 0;
241+
242+err_free_eraseregions:
243+ kfree(eraseregions);
244+err_free_mtd:
245+ kfree(mtd);
246+err_out:
247+ return ret;
248+}
249+
250+static int __devexit bcm47xx_sflash_remove(struct platform_device *pdev)
251+{
252+ struct mtd_info *mtd = dev_get_drvdata(&pdev->dev);
253+
254+ if (mtd) {
255+ mtd_device_unregister(mtd);
256+ map_destroy(mtd);
257+ kfree(mtd->eraseregions);
258+ kfree(mtd);
259+ dev_set_drvdata(&pdev->dev, NULL);
260+ }
261+ return 0;
262+}
263+
264+static const struct platform_device_id bcm47xx_sflash_table[] = {
265+ { "bcm47xx-sflash", 0 },
266+ { }
267+};
268+MODULE_DEVICE_TABLE(platform, bcm47xx_sflash_table);
269+
270+static struct platform_driver bcm47xx_sflash_driver = {
271+ .id_table = bcm47xx_sflash_table,
272+ .probe = bcm47xx_sflash_probe,
273+ .remove = __devexit_p(bcm47xx_sflash_remove),
274+ .driver = {
275+ .name = "bcm47xx-sflash",
276+ .owner = THIS_MODULE,
277+ },
278+};
279+
280+static int __init init_bcm47xx_sflash(void)
281+{
282+ int ret = platform_driver_register(&bcm47xx_sflash_driver);
283+
284+ if (ret)
285+ pr_err("error registering platform driver: %i\n", ret);
286+ return ret;
287+}
288+
289+static void __exit exit_bcm47xx_sflash(void)
290+{
291+ platform_driver_unregister(&bcm47xx_sflash_driver);
292+}
293+
294+module_init(init_bcm47xx_sflash);
295+module_exit(exit_bcm47xx_sflash);
296+
297+MODULE_LICENSE("GPL");
298+MODULE_DESCRIPTION("BCM47XX serial flash driver");
299--- /dev/null
300+++ b/include/linux/mtd/bcm47xx_sflash.h
301@@ -0,0 +1,34 @@
302+#ifndef LINUX_MTD_BCM47XX_SFLASH_H_
303+#define LINUX_MTD_BCM47XX_SFLASH_H_
304+
305+#include <linux/mtd/mtd.h>
306+
307+enum bcm47xx_sflash_type {
308+ BCM47XX_SFLASH_SSB,
309+ BCM47XX_SFLASH_BCMA,
310+};
311+
312+struct ssb_chipcommon;
313+struct bcma_drv_cc;
314+
315+struct bcm47xx_sflash {
316+ enum bcm47xx_sflash_type type;
317+ union {
318+ struct ssb_chipcommon *scc;
319+ struct bcma_drv_cc *bcc;
320+ };
321+
322+ bool present;
323+ u16 numblocks;
324+ u32 window;
325+ u32 blocksize;
326+ u32 size;
327+
328+ int (*read)(struct bcm47xx_sflash *dev, u32 offset, u32 len, u8 *buf);
329+ int (*poll)(struct bcm47xx_sflash *dev, u32 offset);
330+ int (*write)(struct bcm47xx_sflash *dev, u32 offset, u32 len, const u8 *buf);
331+ int (*erase)(struct bcm47xx_sflash *dev, u32 offset);
332+
333+ struct mtd_info *mtd;
334+};
335+#endif /* LINUX_MTD_BCM47XX_SFLASH_H_ */
336

Archive Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl



interactive