Quelle  bcm47xxsflash.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/ioport.h>
#include <linux/mtd/mtd.h>
#include <linux/platform_device.h>
#include <linux/bcma/bcma.h>

#include "bcm47xxsflash.h"

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Serial flash driver for BCMA bus");

static const char * const probes[] = { "bcm47xxpart", NULL };

/**************************************************
 * Various helpers
 **************************************************/

static void bcm47xxsflash_cmd(struct bcm47xxsflash *b47s, u32 opcode)
{
 int i;

 b47s->cc_write(b47s, BCMA_CC_FLASHCTL, BCMA_CC_FLASHCTL_START | opcode);
 for (i = 0; i < 1000; i++) {
  if (!(b47s->cc_read(b47s, BCMA_CC_FLASHCTL) &
        BCMA_CC_FLASHCTL_BUSY))
   return;
  cpu_relax();
 }
 pr_err("Control command failed (timeout)!\n");
}

static int bcm47xxsflash_poll(struct bcm47xxsflash *b47s, int timeout)
{
 unsigned long deadline = jiffies + timeout;

 do {
  switch (b47s->type) {
  case BCM47XXSFLASH_TYPE_ST:
   bcm47xxsflash_cmd(b47s, OPCODE_ST_RDSR);
   if (!(b47s->cc_read(b47s, BCMA_CC_FLASHDATA) &
         SR_ST_WIP))
    return 0;
   break;
  case BCM47XXSFLASH_TYPE_ATMEL:
   bcm47xxsflash_cmd(b47s, OPCODE_AT_STATUS);
   if (b47s->cc_read(b47s, BCMA_CC_FLASHDATA) &
       SR_AT_READY)
    return 0;
   break;
  }

  cpu_relax();
  udelay(1);
 } while (!time_after_eq(jiffies, deadline));

 pr_err("Timeout waiting for flash to be ready!\n");

 return -EBUSY;
}

/**************************************************
 * MTD ops
 **************************************************/

static int bcm47xxsflash_erase(struct mtd_info *mtd, struct erase_info *erase)
{
 struct bcm47xxsflash *b47s = mtd->priv;

 switch (b47s->type) {
 case BCM47XXSFLASH_TYPE_ST:
  bcm47xxsflash_cmd(b47s, OPCODE_ST_WREN);
  b47s->cc_write(b47s, BCMA_CC_FLASHADDR, erase->addr);
  /* Newer flashes have "sub-sectors" which can be erased
 * independently with a new command: ST_SSE. The ST_SE command
 * erases 64KB just as before.
 */
  if (b47s->blocksize < (64 * 1024))
   bcm47xxsflash_cmd(b47s, OPCODE_ST_SSE);
  else
   bcm47xxsflash_cmd(b47s, OPCODE_ST_SE);
  break;
 case BCM47XXSFLASH_TYPE_ATMEL:
  b47s->cc_write(b47s, BCMA_CC_FLASHADDR, erase->addr << 1);
  bcm47xxsflash_cmd(b47s, OPCODE_AT_PAGE_ERASE);
  break;
 }

 return bcm47xxsflash_poll(b47s, HZ);
}

static int bcm47xxsflash_read(struct mtd_info *mtd, loff_t from, size_t len,
         size_t *retlen, u_char *buf)
{
 struct bcm47xxsflash *b47s = mtd->priv;
 size_t orig_len = len;

 /* Check address range */
 if ((from + len) > mtd->size)
  return -EINVAL;

 /* Read as much as possible using fast MMIO window */
 if (from < BCM47XXSFLASH_WINDOW_SZ) {
  size_t memcpy_len;

  memcpy_len = min(len, (size_t)(BCM47XXSFLASH_WINDOW_SZ - from));
  memcpy_fromio(buf, b47s->window + from, memcpy_len);
  from += memcpy_len;
  len -= memcpy_len;
  buf += memcpy_len;
 }

 /* Use indirect access for content out of the window */
 for (; len; len--) {
  b47s->cc_write(b47s, BCMA_CC_FLASHADDR, from++);
  bcm47xxsflash_cmd(b47s, OPCODE_ST_READ4B);
  *buf++ = b47s->cc_read(b47s, BCMA_CC_FLASHDATA);
 }

 *retlen = orig_len;

 return orig_len;
}

static int bcm47xxsflash_write_st(struct mtd_info *mtd, u32 offset, size_t len,
      const u_char *buf)
{
 struct bcm47xxsflash *b47s = mtd->priv;
 int written = 0;

 /* Enable writes */
 bcm47xxsflash_cmd(b47s, OPCODE_ST_WREN);

 /* Write first byte */
 b47s->cc_write(b47s, BCMA_CC_FLASHADDR, offset);
 b47s->cc_write(b47s, BCMA_CC_FLASHDATA, *buf++);

 /* Program page */
 if (b47s->bcma_cc->core->id.rev < 20) {
  bcm47xxsflash_cmd(b47s, OPCODE_ST_PP);
  return 1; /* 1B written */
 }

 /* Program page and set CSA (on newer chips we can continue writing) */
 bcm47xxsflash_cmd(b47s, OPCODE_ST_CSA | OPCODE_ST_PP);
 offset++;
 len--;
 written++;

 while (len > 0) {
  /* Page boundary, another function call is needed */
  if ((offset & 0xFF) == 0)
   break;

  bcm47xxsflash_cmd(b47s, OPCODE_ST_CSA | *buf++);
  offset++;
  len--;
  written++;
 }

 /* All done, drop CSA & poll */
 b47s->cc_write(b47s, BCMA_CC_FLASHCTL, 0);
 udelay(1);
 if (bcm47xxsflash_poll(b47s, HZ / 10))
  pr_err("Flash rejected dropping CSA\n");

 return written;
}

static int bcm47xxsflash_write_at(struct mtd_info *mtd, u32 offset, size_t len,
      const u_char *buf)
{
 struct bcm47xxsflash *b47s = mtd->priv;
 u32 mask = b47s->blocksize - 1;
 u32 page = (offset & ~mask) << 1;
 u32 byte = offset & mask;
 int written = 0;

 /* If we don't overwrite whole page, read it to the buffer first */
 if (byte || (len < b47s->blocksize)) {
  int err;

  b47s->cc_write(b47s, BCMA_CC_FLASHADDR, page);
  bcm47xxsflash_cmd(b47s, OPCODE_AT_BUF1_LOAD);
  /* 250 us for AT45DB321B */
  err = bcm47xxsflash_poll(b47s, HZ / 1000);
  if (err) {
   pr_err("Timeout reading page 0x%X info buffer\n", page);
   return err;
  }
 }

 /* Change buffer content with our data */
 while (len > 0) {
  /* Page boundary, another function call is needed */
  if (byte == b47s->blocksize)
   break;

  b47s->cc_write(b47s, BCMA_CC_FLASHADDR, byte++);
  b47s->cc_write(b47s, BCMA_CC_FLASHDATA, *buf++);
  bcm47xxsflash_cmd(b47s, OPCODE_AT_BUF1_WRITE);
  len--;
  written++;
 }

 /* Program page with the buffer content */
 b47s->cc_write(b47s, BCMA_CC_FLASHADDR, page);
 bcm47xxsflash_cmd(b47s, OPCODE_AT_BUF1_PROGRAM);

 return written;
}

static int bcm47xxsflash_write(struct mtd_info *mtd, loff_t to, size_t len,
          size_t *retlen, const u_char *buf)
{
 struct bcm47xxsflash *b47s = mtd->priv;
 int written;

 /* Writing functions can return without writing all passed data, for
 * example when the hardware is too old or when we git page boundary.
 */
 while (len > 0) {
  switch (b47s->type) {
  case BCM47XXSFLASH_TYPE_ST:
   written = bcm47xxsflash_write_st(mtd, to, len, buf);
   break;
  case BCM47XXSFLASH_TYPE_ATMEL:
   written = bcm47xxsflash_write_at(mtd, to, len, buf);
   break;
  default:
   BUG_ON(1);
  }
  if (written < 0) {
   pr_err("Error writing at offset 0x%llX\n", to);
   return written;
  }
  to += (loff_t)written;
  len -= written;
  *retlen += written;
  buf += written;
 }

 return 0;
}

static void bcm47xxsflash_fill_mtd(struct bcm47xxsflash *b47s,
       struct device *dev)
{
 struct mtd_info *mtd = &b47s->mtd;

 mtd->priv = b47s;
 mtd->dev.parent = dev;
 mtd->name = "bcm47xxsflash";

 mtd->type = MTD_NORFLASH;
 mtd->flags = MTD_CAP_NORFLASH;
 mtd->size = b47s->size;
 mtd->erasesize = b47s->blocksize;
 mtd->writesize = 1;
 mtd->writebufsize = 1;

 mtd->_erase = bcm47xxsflash_erase;
 mtd->_read = bcm47xxsflash_read;
 mtd->_write = bcm47xxsflash_write;
}

/**************************************************
 * BCMA
 **************************************************/

static int bcm47xxsflash_bcma_cc_read(struct bcm47xxsflash *b47s, u16 offset)
{
 return bcma_cc_read32(b47s->bcma_cc, offset);
}

static void bcm47xxsflash_bcma_cc_write(struct bcm47xxsflash *b47s, u16 offset,
     u32 value)
{
 bcma_cc_write32(b47s->bcma_cc, offset, value);
}

static int bcm47xxsflash_bcma_probe(struct platform_device *pdev)
{
 struct device *dev = &pdev->dev;
 struct bcma_sflash *sflash = dev_get_platdata(dev);
 struct bcm47xxsflash *b47s;
 struct resource *res;
 int err;

 b47s = devm_kzalloc(dev, sizeof(*b47s), GFP_KERNEL);
 if (!b47s)
  return -ENOMEM;

 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 if (!res) {
  dev_err(dev, "invalid resource\n");
  return -EINVAL;
 }
 if (!devm_request_mem_region(dev, res->start, resource_size(res),
         res->name)) {
  dev_err(dev, "can't request region for resource %pR\n", res);
  return -EBUSY;
 }

 b47s->bcma_cc = container_of(sflash, struct bcma_drv_cc, sflash);
 b47s->cc_read = bcm47xxsflash_bcma_cc_read;
 b47s->cc_write = bcm47xxsflash_bcma_cc_write;

 /*
 * On old MIPS devices cache was magically invalidated when needed,
 * allowing us to use cached access and gain some performance. Trying
 * the same on ARM based BCM53573 results in flash corruptions, we need
 * to use uncached access for it.
 *
 * It may be arch specific, but right now there is only 1 ARM SoC using
 * this driver, so let's follow Broadcom's reference code and check
 * ChipCommon revision.
 */
 if (b47s->bcma_cc->core->id.rev == 54)
  b47s->window = ioremap(res->start, resource_size(res));
 else
  b47s->window = ioremap_cache(res->start, resource_size(res));
 if (!b47s->window) {
  dev_err(dev, "ioremap failed for resource %pR\n", res);
  return -ENOMEM;
 }

 switch (b47s->bcma_cc->capabilities & BCMA_CC_CAP_FLASHT) {
 case BCMA_CC_FLASHT_STSER:
  b47s->type = BCM47XXSFLASH_TYPE_ST;
  break;
 case BCMA_CC_FLASHT_ATSER:
  b47s->type = BCM47XXSFLASH_TYPE_ATMEL;
  break;
 }

 b47s->blocksize = sflash->blocksize;
 b47s->numblocks = sflash->numblocks;
 b47s->size = sflash->size;
 bcm47xxsflash_fill_mtd(b47s, &pdev->dev);

 platform_set_drvdata(pdev, b47s);

 err = mtd_device_parse_register(&b47s->mtd, probes, NULL, NULL, 0);
 if (err) {
  pr_err("Failed to register MTD device: %d\n", err);
  iounmap(b47s->window);
  return err;
 }

 if (bcm47xxsflash_poll(b47s, HZ / 10))
  pr_warn("Serial flash busy\n");

 return 0;
}

static void bcm47xxsflash_bcma_remove(struct platform_device *pdev)
{
 struct bcm47xxsflash *b47s = platform_get_drvdata(pdev);

 mtd_device_unregister(&b47s->mtd);
 iounmap(b47s->window);
}

static struct platform_driver bcma_sflash_driver = {
 .probe = bcm47xxsflash_bcma_probe,
 .remove = bcm47xxsflash_bcma_remove,
 .driver = {
  .name = "bcma_sflash",
 },
};

/**************************************************
 * Init
 **************************************************/

module_platform_driver(bcma_sflash_driver);