Root/target/linux/brcm47xx/patches-3.3/027-mtd-bcm47xx-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,263 @@
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 <bcm47xx.h>
51+#include <bus.h>
52+
53+static int
54+sflash_mtd_poll(struct bcm47xx_sflash *sflash, unsigned int offset, int timeout)
55+{
56+ unsigned long now = jiffies;
57+
58+ for (;;) {
59+ if (!sflash->poll(sflash, offset)) {
60+ break;
61+ }
62+ if (time_after(jiffies, now + timeout)) {
63+ pr_err("timeout while polling\n");
64+ return -ETIMEDOUT;
65+
66+ }
67+ cpu_relax();
68+ udelay(1);
69+ }
70+
71+ return 0;
72+}
73+
74+static int
75+sflash_mtd_read(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf)
76+{
77+ struct bcm47xx_sflash *sflash = (struct bcm47xx_sflash *)mtd->priv;
78+
79+ /* Check address range */
80+ if (!len)
81+ return 0;
82+
83+ if ((from + len) > mtd->size)
84+ return -EINVAL;
85+
86+ *retlen = 0;
87+ while (len) {
88+ int ret = sflash->read(sflash, from, len, buf);
89+ if (ret < 0)
90+ return ret;
91+
92+ from += (loff_t) ret;
93+ len -= ret;
94+ buf += ret;
95+ *retlen += ret;
96+ }
97+
98+ return 0;
99+}
100+
101+static int
102+sflash_mtd_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf)
103+{
104+ int bytes;
105+ int ret;
106+ struct bcm47xx_sflash *sflash = (struct bcm47xx_sflash *)mtd->priv;
107+
108+ /* Check address range */
109+ if (!len)
110+ return 0;
111+
112+ if ((to + len) > mtd->size)
113+ return -EINVAL;
114+
115+ *retlen = 0;
116+ while (len) {
117+ ret = sflash->write(sflash, to, len, buf);
118+ if (ret < 0)
119+ return ret;
120+
121+ bytes = ret;
122+
123+ ret = sflash_mtd_poll(sflash, (unsigned int) to, HZ / 10);
124+ if (ret)
125+ return ret;
126+
127+ to += (loff_t) bytes;
128+ len -= bytes;
129+ buf += bytes;
130+ *retlen += bytes;
131+ }
132+
133+ return 0;
134+}
135+
136+static int
137+sflash_mtd_erase(struct mtd_info *mtd, struct erase_info *erase)
138+{
139+ struct bcm47xx_sflash *sflash = (struct bcm47xx_sflash *) mtd->priv;
140+ int i, j, ret = 0;
141+ unsigned int addr, len;
142+
143+ /* Check address range */
144+ if (!erase->len)
145+ return 0;
146+ if ((erase->addr + erase->len) > mtd->size)
147+ return -EINVAL;
148+
149+ addr = erase->addr;
150+ len = erase->len;
151+
152+ /* Ensure that requested regions are aligned */
153+ for (i = 0; i < mtd->numeraseregions; i++) {
154+ for (j = 0; j < mtd->eraseregions[i].numblocks; j++) {
155+ if (addr == mtd->eraseregions[i].offset +
156+ mtd->eraseregions[i].erasesize * j &&
157+ len >= mtd->eraseregions[i].erasesize) {
158+ ret = sflash->erase(sflash, addr);
159+ if (ret < 0)
160+ break;
161+ ret = sflash_mtd_poll(sflash, addr, 10 * HZ);
162+ if (ret)
163+ break;
164+ addr += mtd->eraseregions[i].erasesize;
165+ len -= mtd->eraseregions[i].erasesize;
166+ }
167+ }
168+ if (ret)
169+ break;
170+ }
171+
172+ /* Set erase status */
173+ if (ret)
174+ erase->state = MTD_ERASE_FAILED;
175+ else
176+ erase->state = MTD_ERASE_DONE;
177+
178+ /* Call erase callback */
179+ if (erase->callback)
180+ erase->callback(erase);
181+
182+ return ret;
183+}
184+
185+static const char *probes[] = { "bcm47xx", NULL };
186+
187+static int bcm47xx_sflash_probe(struct platform_device *pdev)
188+{
189+ struct bcm47xx_sflash *sflash = dev_get_platdata(&pdev->dev);
190+ struct mtd_info *mtd;
191+ struct mtd_erase_region_info *eraseregions;
192+ int ret = 0;
193+
194+ mtd = kzalloc(sizeof(struct mtd_info), GFP_KERNEL);
195+ if (!mtd){
196+ ret = -ENOMEM;
197+ goto err_out;
198+ }
199+
200+ eraseregions = kzalloc(sizeof(struct mtd_erase_region_info), GFP_KERNEL);
201+ if (!eraseregions) {
202+ ret = -ENOMEM;
203+ goto err_free_mtd;
204+ }
205+
206+ pr_info("found serial flash: blocksize=%dKB, numblocks=%d, size=%dKB\n",
207+ sflash->blocksize / 1024, sflash->numblocks, sflash->size / 1024);
208+
209+ /* Setup region info */
210+ eraseregions->offset = 0;
211+ eraseregions->erasesize = sflash->blocksize;
212+ eraseregions->numblocks = sflash->numblocks;
213+ if (eraseregions->erasesize > mtd->erasesize)
214+ mtd->erasesize = eraseregions->erasesize;
215+ mtd->size = sflash->size;
216+ mtd->numeraseregions = 1;
217+
218+ /* Register with MTD */
219+ mtd->name = "bcm47xx-sflash";
220+ mtd->type = MTD_NORFLASH;
221+ mtd->flags = MTD_CAP_NORFLASH;
222+ mtd->eraseregions = eraseregions;
223+ mtd->erase = sflash_mtd_erase;
224+ mtd->read = sflash_mtd_read;
225+ mtd->write = sflash_mtd_write;
226+ mtd->writesize = 1;
227+ mtd->priv = sflash;
228+ ret = dev_set_drvdata(&pdev->dev, mtd);
229+ mtd->owner = THIS_MODULE;
230+ if (ret) {
231+ pr_err("adding private data failed\n");
232+ goto err_free_eraseregions;
233+ }
234+
235+ ret = mtd_device_parse_register(mtd, probes, NULL, NULL, 0);
236+
237+ if (ret) {
238+ pr_err("mtd_device_register failed\n");
239+ goto err_free_eraseregions;
240+ }
241+ return 0;
242+
243+err_free_eraseregions:
244+ kfree(eraseregions);
245+err_free_mtd:
246+ kfree(mtd);
247+err_out:
248+ return ret;
249+}
250+
251+static int __devexit bcm47xx_sflash_remove(struct platform_device *pdev)
252+{
253+ struct mtd_info *mtd = dev_get_drvdata(&pdev->dev);
254+
255+ if (mtd) {
256+ mtd_device_unregister(mtd);
257+ map_destroy(mtd);
258+ kfree(mtd->eraseregions);
259+ kfree(mtd);
260+ dev_set_drvdata(&pdev->dev, NULL);
261+ }
262+ return 0;
263+}
264+
265+static struct platform_driver bcm47xx_sflash_driver = {
266+ .remove = __devexit_p(bcm47xx_sflash_remove),
267+ .driver = {
268+ .name = "bcm47xx_sflash",
269+ .owner = THIS_MODULE,
270+ },
271+};
272+
273+static int __init init_bcm47xx_sflash(void)
274+{
275+ int ret = platform_driver_probe(&bcm47xx_sflash_driver, bcm47xx_sflash_probe);
276+
277+ if (ret)
278+ pr_err("error registering platform driver: %i\n", ret);
279+ return ret;
280+}
281+
282+static void __exit exit_bcm47xx_sflash(void)
283+{
284+ platform_driver_unregister(&bcm47xx_sflash_driver);
285+}
286+
287+module_init(init_bcm47xx_sflash);
288+module_exit(exit_bcm47xx_sflash);
289+
290+MODULE_LICENSE("GPL");
291+MODULE_DESCRIPTION("BCM47XX parallel flash driver");
292

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