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> 9 10 #include "bcm47xxsflash.h" 11 12 MODULE_LICENSE("GPL"); 13 MODULE_DESCRIPTION("Serial flash driver for BCMA bus"); 14 15 static const char * const probes[] = { "bcm47xxpart", NULL }; 16 17 /************************************************** 18 * Various helpers 19 **************************************************/ 20 21 static void bcm47xxsflash_cmd(struct bcm47xxsflash *b47s, u32 opcode) 22 { 23 int i; 24 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)) 29 return; 30 cpu_relax(); 31 } 32 pr_err("Control command failed (timeout)!\n"); 33 } 34 35 static int bcm47xxsflash_poll(struct bcm47xxsflash *b47s, int timeout) 36 { 37 unsigned long deadline = jiffies + timeout; 38 39 do { 40 switch (b47s->type) { 41 case BCM47XXSFLASH_TYPE_ST: 42 bcm47xxsflash_cmd(b47s, OPCODE_ST_RDSR); 43 if (!(b47s->cc_read(b47s, BCMA_CC_FLASHDATA) & 44 SR_ST_WIP)) 45 return 0; 46 break; 47 case BCM47XXSFLASH_TYPE_ATMEL: 48 bcm47xxsflash_cmd(b47s, OPCODE_AT_STATUS); 49 if (b47s->cc_read(b47s, BCMA_CC_FLASHDATA) & 50 SR_AT_READY) 51 return 0; 52 break; 53 } 54 55 cpu_relax(); 56 udelay(1); 57 } while (!time_after_eq(jiffies, deadline)); 58 59 pr_err("Timeout waiting for flash to be ready!\n"); 60 61 return -EBUSY; 62 } 63 64 /************************************************** 65 * MTD ops 66 **************************************************/ 67 68 static int bcm47xxsflash_erase(struct mtd_info *mtd, struct erase_info *erase) 69 { 70 struct bcm47xxsflash *b47s = mtd->priv; 71 72 switch (b47s->type) { 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. 79 */ 80 if (b47s->blocksize < (64 * 1024)) 81 bcm47xxsflash_cmd(b47s, OPCODE_ST_SSE); 82 else 83 bcm47xxsflash_cmd(b47s, OPCODE_ST_SE); 84 break; 85 case BCM47XXSFLASH_TYPE_ATMEL: 86 b47s->cc_write(b47s, BCMA_CC_FLASHADDR, erase->addr << 1); 87 bcm47xxsflash_cmd(b47s, OPCODE_AT_PAGE_ERASE); 88 break; 89 } 90 91 return bcm47xxsflash_poll(b47s, HZ); 92 } 93 94 static int bcm47xxsflash_read(struct mtd_info *mtd, loff_t from, size_t len, 95 size_t *retlen, u_char *buf) 96 { 97 struct bcm47xxsflash *b47s = mtd->priv; 98 size_t orig_len = len; 99 100 /* Check address range */ 101 if ((from + len) > mtd->size) 102 return -EINVAL; 103 104 /* Read as much as possible using fast MMIO window */ 105 if (from < BCM47XXSFLASH_WINDOW_SZ) { 106 size_t memcpy_len; 107 108 memcpy_len = min(len, (size_t)(BCM47XXSFLASH_WINDOW_SZ - from)); 109 memcpy_fromio(buf, b47s->window + from, memcpy_len); 110 from += memcpy_len; 111 len -= memcpy_len; 112 buf += memcpy_len; 113 } 114 115 /* Use indirect access for content out of the window */ 116 for (; len; len--) { 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); 120 } 121 122 *retlen = orig_len; 123 124 return orig_len; 125 } 126 127 static int bcm47xxsflash_write_st(struct mtd_info *mtd, u32 offset, size_t len, 128 const u_char *buf) 129 { 130 struct bcm47xxsflash *b47s = mtd->priv; 131 int written = 0; 132 133 /* Enable writes */ 134 bcm47xxsflash_cmd(b47s, OPCODE_ST_WREN); 135 136 /* Write first byte */ 137 b47s->cc_write(b47s, BCMA_CC_FLASHADDR, offset); 138 b47s->cc_write(b47s, BCMA_CC_FLASHDATA, *buf++); 139 140 /* Program page */ 141 if (b47s->bcma_cc->core->id.rev < 20) { 142 bcm47xxsflash_cmd(b47s, OPCODE_ST_PP); 143 return 1; /* 1B written */ 144 } 145 146 /* Program page and set CSA (on newer chips we can continue writing) */ 147 bcm47xxsflash_cmd(b47s, OPCODE_ST_CSA | OPCODE_ST_PP); 148 offset++; 149 len--; 150 written++; 151 152 while (len > 0) { 153 /* Page boundary, another function call is needed */ 154 if ((offset & 0xFF) == 0) 155 break; 156 157 bcm47xxsflash_cmd(b47s, OPCODE_ST_CSA | *buf++); 158 offset++; 159 len--; 160 written++; 161 } 162 163 /* All done, drop CSA & poll */ 164 b47s->cc_write(b47s, BCMA_CC_FLASHCTL, 0); 165 udelay(1); 166 if (bcm47xxsflash_poll(b47s, HZ / 10)) 167 pr_err("Flash rejected dropping CSA\n"); 168 169 return written; 170 } 171 172 static int bcm47xxsflash_write_at(struct mtd_info *mtd, u32 offset, size_t len, 173 const u_char *buf) 174 { 175 struct bcm47xxsflash *b47s = mtd->priv; 176 u32 mask = b47s->blocksize - 1; 177 u32 page = (offset & ~mask) << 1; 178 u32 byte = offset & mask; 179 int written = 0; 180 181 /* If we don't overwrite whole page, read it to the buffer first */ 182 if (byte || (len < b47s->blocksize)) { 183 int err; 184 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); 189 if (err) { 190 pr_err("Timeout reading page 0x%X info buffer\n", page); 191 return err; 192 } 193 } 194 195 /* Change buffer content with our data */ 196 while (len > 0) { 197 /* Page boundary, another function call is needed */ 198 if (byte == b47s->blocksize) 199 break; 200 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); 204 len--; 205 written++; 206 } 207 208 /* Program page with the buffer content */ 209 b47s->cc_write(b47s, BCMA_CC_FLASHADDR, page); 210 bcm47xxsflash_cmd(b47s, OPCODE_AT_BUF1_PROGRAM); 211 212 return written; 213 } 214 215 static int bcm47xxsflash_write(struct mtd_info *mtd, loff_t to, size_t len, 216 size_t *retlen, const u_char *buf) 217 { 218 struct bcm47xxsflash *b47s = mtd->priv; 219 int written; 220 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. 223 */ 224 while (len > 0) { 225 switch (b47s->type) { 226 case BCM47XXSFLASH_TYPE_ST: 227 written = bcm47xxsflash_write_st(mtd, to, len, buf); 228 break; 229 case BCM47XXSFLASH_TYPE_ATMEL: 230 written = bcm47xxsflash_write_at(mtd, to, len, buf); 231 break; 232 default: 233 BUG_ON(1); 234 } 235 if (written < 0) { 236 pr_err("Error writing at offset 0x%llX\n", to); 237 return written; 238 } 239 to += (loff_t)written; 240 len -= written; 241 *retlen += written; 242 buf += written; 243 } 244 245 return 0; 246 } 247 248 static void bcm47xxsflash_fill_mtd(struct bcm47xxsflash *b47s, 249 struct device *dev) 250 { 251 struct mtd_info *mtd = &b47s->mtd; 252 253 mtd->priv = b47s; 254 mtd->dev.parent = dev; 255 mtd->name = "bcm47xxsflash"; 256 257 mtd->type = MTD_NORFLASH; 258 mtd->flags = MTD_CAP_NORFLASH; 259 mtd->size = b47s->size; 260 mtd->erasesize = b47s->blocksize; 261 mtd->writesize = 1; 262 mtd->writebufsize = 1; 263 264 mtd->_erase = bcm47xxsflash_erase; 265 mtd->_read = bcm47xxsflash_read; 266 mtd->_write = bcm47xxsflash_write; 267 } 268 269 /************************************************** 270 * BCMA 271 **************************************************/ 272 273 static int bcm47xxsflash_bcma_cc_read(struct bcm47xxsflash *b47s, u16 offset) 274 { 275 return bcma_cc_read32(b47s->bcma_cc, offset); 276 } 277 278 static void bcm47xxsflash_bcma_cc_write(struct bcm47xxsflash *b47s, u16 offset, 279 u32 value) 280 { 281 bcma_cc_write32(b47s->bcma_cc, offset, value); 282 } 283 284 static int bcm47xxsflash_bcma_probe(struct platform_device *pdev) 285 { 286 struct device *dev = &pdev->dev; 287 struct bcma_sflash *sflash = dev_get_platdata(dev); 288 struct bcm47xxsflash *b47s; 289 struct resource *res; 290 int err; 291 292 b47s = devm_kzalloc(dev, sizeof(*b47s), GFP_KERNEL); 293 if (!b47s) 294 return -ENOMEM; 295 296 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 297 if (!res) { 298 dev_err(dev, "invalid resource\n"); 299 return -EINVAL; 300 } 301 if (!devm_request_mem_region(dev, res->start, resource_size(res), 302 res->name)) { 303 dev_err(dev, "can't request region for resource %pR\n", res); 304 return -EBUSY; 305 } 306 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; 310 311 /* 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. 316 * 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. 320 */ 321 if (b47s->bcma_cc->core->id.rev == 54) 322 b47s->window = ioremap_nocache(res->start, resource_size(res)); 323 else 324 b47s->window = ioremap_cache(res->start, resource_size(res)); 325 if (!b47s->window) { 326 dev_err(dev, "ioremap failed for resource %pR\n", res); 327 return -ENOMEM; 328 } 329 330 switch (b47s->bcma_cc->capabilities & BCMA_CC_CAP_FLASHT) { 331 case BCMA_CC_FLASHT_STSER: 332 b47s->type = BCM47XXSFLASH_TYPE_ST; 333 break; 334 case BCMA_CC_FLASHT_ATSER: 335 b47s->type = BCM47XXSFLASH_TYPE_ATMEL; 336 break; 337 } 338 339 b47s->blocksize = sflash->blocksize; 340 b47s->numblocks = sflash->numblocks; 341 b47s->size = sflash->size; 342 bcm47xxsflash_fill_mtd(b47s, &pdev->dev); 343 344 platform_set_drvdata(pdev, b47s); 345 346 err = mtd_device_parse_register(&b47s->mtd, probes, NULL, NULL, 0); 347 if (err) { 348 pr_err("Failed to register MTD device: %d\n", err); 349 iounmap(b47s->window); 350 return err; 351 } 352 353 if (bcm47xxsflash_poll(b47s, HZ / 10)) 354 pr_warn("Serial flash busy\n"); 355 356 return 0; 357 } 358 359 static int bcm47xxsflash_bcma_remove(struct platform_device *pdev) 360 { 361 struct bcm47xxsflash *b47s = platform_get_drvdata(pdev); 362 363 mtd_device_unregister(&b47s->mtd); 364 iounmap(b47s->window); 365 366 return 0; 367 } 368 369 static struct platform_driver bcma_sflash_driver = { 370 .probe = bcm47xxsflash_bcma_probe, 371 .remove = bcm47xxsflash_bcma_remove, 372 .driver = { 373 .name = "bcma_sflash", 374 }, 375 }; 376 377 /************************************************** 378 * Init 379 **************************************************/ 380 381 module_platform_driver(bcma_sflash_driver); 382