1 #include <linux/kernel.h>
2 #include <linux/module.h>
3 #include <linux/slab.h>
4 #include <linux/delay.h>
5 #include <linux/ioport.h>
6 #include <linux/mtd/mtd.h>
7 #include <linux/platform_device.h>
8 #include <linux/bcma/bcma.h>
10 #include "bcm47xxsflash.h"
12 MODULE_LICENSE("GPL");
13 MODULE_DESCRIPTION("Serial flash driver for BCMA bus");
15 static const char * const probes[] = { "bcm47xxpart", NULL };
17 /**************************************************
19 **************************************************/
21 static void bcm47xxsflash_cmd(struct bcm47xxsflash *b47s, u32 opcode)
25 b47s->cc_write(b47s, BCMA_CC_FLASHCTL, BCMA_CC_FLASHCTL_START | opcode);
26 for (i = 0; i < 1000; i++) {
27 if (!(b47s->cc_read(b47s, BCMA_CC_FLASHCTL) &
28 BCMA_CC_FLASHCTL_BUSY))
32 pr_err("Control command failed (timeout)!\n");
35 static int bcm47xxsflash_poll(struct bcm47xxsflash *b47s, int timeout)
37 unsigned long deadline = jiffies + timeout;
41 case BCM47XXSFLASH_TYPE_ST:
42 bcm47xxsflash_cmd(b47s, OPCODE_ST_RDSR);
43 if (!(b47s->cc_read(b47s, BCMA_CC_FLASHDATA) &
47 case BCM47XXSFLASH_TYPE_ATMEL:
48 bcm47xxsflash_cmd(b47s, OPCODE_AT_STATUS);
49 if (b47s->cc_read(b47s, BCMA_CC_FLASHDATA) &
57 } while (!time_after_eq(jiffies, deadline));
59 pr_err("Timeout waiting for flash to be ready!\n");
64 /**************************************************
66 **************************************************/
68 static int bcm47xxsflash_erase(struct mtd_info *mtd, struct erase_info *erase)
70 struct bcm47xxsflash *b47s = mtd->priv;
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.
80 if (b47s->blocksize < (64 * 1024))
81 bcm47xxsflash_cmd(b47s, OPCODE_ST_SSE);
83 bcm47xxsflash_cmd(b47s, OPCODE_ST_SE);
85 case BCM47XXSFLASH_TYPE_ATMEL:
86 b47s->cc_write(b47s, BCMA_CC_FLASHADDR, erase->addr << 1);
87 bcm47xxsflash_cmd(b47s, OPCODE_AT_PAGE_ERASE);
91 return bcm47xxsflash_poll(b47s, HZ);
94 static int bcm47xxsflash_read(struct mtd_info *mtd, loff_t from, size_t len,
95 size_t *retlen, u_char *buf)
97 struct bcm47xxsflash *b47s = mtd->priv;
98 size_t orig_len = len;
100 /* Check address range */
101 if ((from + len) > mtd->size)
104 /* Read as much as possible using fast MMIO window */
105 if (from < BCM47XXSFLASH_WINDOW_SZ) {
108 memcpy_len = min(len, (size_t)(BCM47XXSFLASH_WINDOW_SZ - from));
109 memcpy_fromio(buf, b47s->window + from, memcpy_len);
115 /* Use indirect access for content out of the window */
117 b47s->cc_write(b47s, BCMA_CC_FLASHADDR, from++);
118 bcm47xxsflash_cmd(b47s, OPCODE_ST_READ4B);
119 *buf++ = b47s->cc_read(b47s, BCMA_CC_FLASHDATA);
127 static int bcm47xxsflash_write_st(struct mtd_info *mtd, u32 offset, size_t len,
130 struct bcm47xxsflash *b47s = mtd->priv;
134 bcm47xxsflash_cmd(b47s, OPCODE_ST_WREN);
136 /* Write first byte */
137 b47s->cc_write(b47s, BCMA_CC_FLASHADDR, offset);
138 b47s->cc_write(b47s, BCMA_CC_FLASHDATA, *buf++);
141 if (b47s->bcma_cc->core->id.rev < 20) {
142 bcm47xxsflash_cmd(b47s, OPCODE_ST_PP);
143 return 1; /* 1B written */
146 /* Program page and set CSA (on newer chips we can continue writing) */
147 bcm47xxsflash_cmd(b47s, OPCODE_ST_CSA | OPCODE_ST_PP);
153 /* Page boundary, another function call is needed */
154 if ((offset & 0xFF) == 0)
157 bcm47xxsflash_cmd(b47s, OPCODE_ST_CSA | *buf++);
163 /* All done, drop CSA & poll */
164 b47s->cc_write(b47s, BCMA_CC_FLASHCTL, 0);
166 if (bcm47xxsflash_poll(b47s, HZ / 10))
167 pr_err("Flash rejected dropping CSA\n");
172 static int bcm47xxsflash_write_at(struct mtd_info *mtd, u32 offset, size_t len,
175 struct bcm47xxsflash *b47s = mtd->priv;
176 u32 mask = b47s->blocksize - 1;
177 u32 page = (offset & ~mask) << 1;
178 u32 byte = offset & mask;
181 /* If we don't overwrite whole page, read it to the buffer first */
182 if (byte || (len < b47s->blocksize)) {
185 b47s->cc_write(b47s, BCMA_CC_FLASHADDR, page);
186 bcm47xxsflash_cmd(b47s, OPCODE_AT_BUF1_LOAD);
187 /* 250 us for AT45DB321B */
188 err = bcm47xxsflash_poll(b47s, HZ / 1000);
190 pr_err("Timeout reading page 0x%X info buffer\n", page);
195 /* Change buffer content with our data */
197 /* Page boundary, another function call is needed */
198 if (byte == b47s->blocksize)
201 b47s->cc_write(b47s, BCMA_CC_FLASHADDR, byte++);
202 b47s->cc_write(b47s, BCMA_CC_FLASHDATA, *buf++);
203 bcm47xxsflash_cmd(b47s, OPCODE_AT_BUF1_WRITE);
208 /* Program page with the buffer content */
209 b47s->cc_write(b47s, BCMA_CC_FLASHADDR, page);
210 bcm47xxsflash_cmd(b47s, OPCODE_AT_BUF1_PROGRAM);
215 static int bcm47xxsflash_write(struct mtd_info *mtd, loff_t to, size_t len,
216 size_t *retlen, const u_char *buf)
218 struct bcm47xxsflash *b47s = mtd->priv;
221 /* Writing functions can return without writing all passed data, for
222 * example when the hardware is too old or when we git page boundary.
225 switch (b47s->type) {
226 case BCM47XXSFLASH_TYPE_ST:
227 written = bcm47xxsflash_write_st(mtd, to, len, buf);
229 case BCM47XXSFLASH_TYPE_ATMEL:
230 written = bcm47xxsflash_write_at(mtd, to, len, buf);
236 pr_err("Error writing at offset 0x%llX\n", to);
239 to += (loff_t)written;
248 static void bcm47xxsflash_fill_mtd(struct bcm47xxsflash *b47s,
251 struct mtd_info *mtd = &b47s->mtd;
254 mtd->dev.parent = dev;
255 mtd->name = "bcm47xxsflash";
257 mtd->type = MTD_NORFLASH;
258 mtd->flags = MTD_CAP_NORFLASH;
259 mtd->size = b47s->size;
260 mtd->erasesize = b47s->blocksize;
262 mtd->writebufsize = 1;
264 mtd->_erase = bcm47xxsflash_erase;
265 mtd->_read = bcm47xxsflash_read;
266 mtd->_write = bcm47xxsflash_write;
269 /**************************************************
271 **************************************************/
273 static int bcm47xxsflash_bcma_cc_read(struct bcm47xxsflash *b47s, u16 offset)
275 return bcma_cc_read32(b47s->bcma_cc, offset);
278 static void bcm47xxsflash_bcma_cc_write(struct bcm47xxsflash *b47s, u16 offset,
281 bcma_cc_write32(b47s->bcma_cc, offset, value);
284 static int bcm47xxsflash_bcma_probe(struct platform_device *pdev)
286 struct device *dev = &pdev->dev;
287 struct bcma_sflash *sflash = dev_get_platdata(dev);
288 struct bcm47xxsflash *b47s;
289 struct resource *res;
292 b47s = devm_kzalloc(dev, sizeof(*b47s), GFP_KERNEL);
296 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
298 dev_err(dev, "invalid resource\n");
301 if (!devm_request_mem_region(dev, res->start, resource_size(res),
303 dev_err(dev, "can't request region for resource %pR\n", res);
307 b47s->bcma_cc = container_of(sflash, struct bcma_drv_cc, sflash);
308 b47s->cc_read = bcm47xxsflash_bcma_cc_read;
309 b47s->cc_write = bcm47xxsflash_bcma_cc_write;
312 * On old MIPS devices cache was magically invalidated when needed,
313 * allowing us to use cached access and gain some performance. Trying
314 * the same on ARM based BCM53573 results in flash corruptions, we need
315 * to use uncached access for it.
317 * It may be arch specific, but right now there is only 1 ARM SoC using
318 * this driver, so let's follow Broadcom's reference code and check
319 * ChipCommon revision.
321 if (b47s->bcma_cc->core->id.rev == 54)
322 b47s->window = ioremap_nocache(res->start, resource_size(res));
324 b47s->window = ioremap_cache(res->start, resource_size(res));
326 dev_err(dev, "ioremap failed for resource %pR\n", res);
330 switch (b47s->bcma_cc->capabilities & BCMA_CC_CAP_FLASHT) {
331 case BCMA_CC_FLASHT_STSER:
332 b47s->type = BCM47XXSFLASH_TYPE_ST;
334 case BCMA_CC_FLASHT_ATSER:
335 b47s->type = BCM47XXSFLASH_TYPE_ATMEL;
339 b47s->blocksize = sflash->blocksize;
340 b47s->numblocks = sflash->numblocks;
341 b47s->size = sflash->size;
342 bcm47xxsflash_fill_mtd(b47s, &pdev->dev);
344 platform_set_drvdata(pdev, b47s);
346 err = mtd_device_parse_register(&b47s->mtd, probes, NULL, NULL, 0);
348 pr_err("Failed to register MTD device: %d\n", err);
349 iounmap(b47s->window);
353 if (bcm47xxsflash_poll(b47s, HZ / 10))
354 pr_warn("Serial flash busy\n");
359 static int bcm47xxsflash_bcma_remove(struct platform_device *pdev)
361 struct bcm47xxsflash *b47s = platform_get_drvdata(pdev);
363 mtd_device_unregister(&b47s->mtd);
364 iounmap(b47s->window);
369 static struct platform_driver bcma_sflash_driver = {
370 .probe = bcm47xxsflash_bcma_probe,
371 .remove = bcm47xxsflash_bcma_remove,
373 .name = "bcma_sflash",
377 /**************************************************
379 **************************************************/
381 module_platform_driver(bcma_sflash_driver);