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