Root/target/linux/brcm47xx/patches-3.0/0019-mtd-bcm47xx-add-serial-flash-driver.patch

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

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