root/drivers/mtd/devices/bcm47xxsflash.c

DEFINITIONS

1. bcm47xxsflash_cmd
2. bcm47xxsflash_poll
3. bcm47xxsflash_erase
4. bcm47xxsflash_read
5. bcm47xxsflash_write_st
6. bcm47xxsflash_write_at
7. bcm47xxsflash_write
8. bcm47xxsflash_fill_mtd
9. bcm47xxsflash_bcma_cc_read
10. bcm47xxsflash_bcma_cc_write
11. bcm47xxsflash_bcma_probe
12. bcm47xxsflash_bcma_remove

   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);