mtd: powernv: Add powernv flash MTD abstraction driver
authorCyril Bur <cyrilbur@gmail.com>
Tue, 2 Jun 2015 04:26:09 +0000 (14:26 +1000)
committerMichael Ellerman <mpe@ellerman.id.au>
Thu, 11 Jun 2015 03:23:30 +0000 (13:23 +1000)
Powerpc powernv platforms allow access to certain system flash devices
through a firmwarwe interface. This change adds an mtd driver for these
flash devices.

Minor updates from Jeremy Kerr and Joel Stanley.

Signed-off-by: Cyril Bur <cyrilbur@gmail.com>
Signed-off-by: Joel Stanley <joel@jms.id.au>
Signed-off-by: Jeremy Kerr <jk@ozlabs.org>
Reviewed-by: Neelesh Gupta <neelegup@linux.vnet.ibm.com>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
drivers/mtd/devices/Kconfig
drivers/mtd/devices/Makefile
drivers/mtd/devices/powernv_flash.c [new file with mode: 0644]

index c49d0b127fefb32c38539810247ff4adc5adc0fa..f73c41697a00e387f500e2f029cd6bc0299f2b57 100644 (file)
@@ -195,6 +195,14 @@ config MTD_BLOCK2MTD
          Testing MTD users (eg JFFS2) on large media and media that might
          be removed during a write (using the floppy drive).
 
+config MTD_POWERNV_FLASH
+       tristate "powernv flash MTD driver"
+       depends on PPC_POWERNV
+       help
+         This provides an MTD device to access flash on powernv OPAL
+         platforms from Linux. This device abstracts away the
+         firmware interface for flash access.
+
 comment "Disk-On-Chip Device Drivers"
 
 config MTD_DOCG3
index f0b0e611d1d6a564b460af1f68c965906f629223..7912d3a0ee343b045daf1dbdf9ae93061afad4eb 100644 (file)
@@ -16,6 +16,7 @@ obj-$(CONFIG_MTD_SPEAR_SMI)   += spear_smi.o
 obj-$(CONFIG_MTD_SST25L)       += sst25l.o
 obj-$(CONFIG_MTD_BCM47XXSFLASH)        += bcm47xxsflash.o
 obj-$(CONFIG_MTD_ST_SPI_FSM)    += st_spi_fsm.o
+obj-$(CONFIG_MTD_POWERNV_FLASH)        += powernv_flash.o
 
 
 CFLAGS_docg3.o                 += -I$(src)
diff --git a/drivers/mtd/devices/powernv_flash.c b/drivers/mtd/devices/powernv_flash.c
new file mode 100644 (file)
index 0000000..d5b870b
--- /dev/null
@@ -0,0 +1,285 @@
+/*
+ * OPAL PNOR flash MTD abstraction
+ *
+ * Copyright IBM 2015
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/platform_device.h>
+#include <linux/string.h>
+#include <linux/slab.h>
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/partitions.h>
+
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
+
+#include <asm/opal.h>
+
+
+/*
+ * This driver creates the a Linux MTD abstraction for platform PNOR flash
+ * backed by OPAL calls
+ */
+
+struct powernv_flash {
+       struct mtd_info mtd;
+       u32 id;
+};
+
+enum flash_op {
+       FLASH_OP_READ,
+       FLASH_OP_WRITE,
+       FLASH_OP_ERASE,
+};
+
+static int powernv_flash_async_op(struct mtd_info *mtd, enum flash_op op,
+               loff_t offset, size_t len, size_t *retlen, u_char *buf)
+{
+       struct powernv_flash *info = (struct powernv_flash *)mtd->priv;
+       struct device *dev = &mtd->dev;
+       int token;
+       struct opal_msg msg;
+       int rc;
+
+       dev_dbg(dev, "%s(op=%d, offset=0x%llx, len=%zu)\n",
+                       __func__, op, offset, len);
+
+       token = opal_async_get_token_interruptible();
+       if (token < 0) {
+               if (token != -ERESTARTSYS)
+                       dev_err(dev, "Failed to get an async token\n");
+
+               return token;
+       }
+
+       switch (op) {
+       case FLASH_OP_READ:
+               rc = opal_flash_read(info->id, offset, __pa(buf), len, token);
+               break;
+       case FLASH_OP_WRITE:
+               rc = opal_flash_write(info->id, offset, __pa(buf), len, token);
+               break;
+       case FLASH_OP_ERASE:
+               rc = opal_flash_erase(info->id, offset, len, token);
+               break;
+       default:
+               BUG_ON(1);
+       }
+
+       if (rc != OPAL_ASYNC_COMPLETION) {
+               dev_err(dev, "opal_flash_async_op(op=%d) failed (rc %d)\n",
+                               op, rc);
+               opal_async_release_token(token);
+               return -EIO;
+       }
+
+       rc = opal_async_wait_response(token, &msg);
+       opal_async_release_token(token);
+       if (rc) {
+               dev_err(dev, "opal async wait failed (rc %d)\n", rc);
+               return -EIO;
+       }
+
+       rc = be64_to_cpu(msg.params[1]);
+       if (rc == OPAL_SUCCESS) {
+               rc = 0;
+               if (retlen)
+                       *retlen = len;
+       } else {
+               rc = -EIO;
+       }
+
+       return rc;
+}
+
+/**
+ * @mtd: the device
+ * @from: the offset to read from
+ * @len: the number of bytes to read
+ * @retlen: the number of bytes actually read
+ * @buf: the filled in buffer
+ *
+ * Returns 0 if read successful, or -ERRNO if an error occurred
+ */
+static int powernv_flash_read(struct mtd_info *mtd, loff_t from, size_t len,
+            size_t *retlen, u_char *buf)
+{
+       return powernv_flash_async_op(mtd, FLASH_OP_READ, from,
+                       len, retlen, buf);
+}
+
+/**
+ * @mtd: the device
+ * @to: the offset to write to
+ * @len: the number of bytes to write
+ * @retlen: the number of bytes actually written
+ * @buf: the buffer to get bytes from
+ *
+ * Returns 0 if write successful, -ERRNO if error occurred
+ */
+static int powernv_flash_write(struct mtd_info *mtd, loff_t to, size_t len,
+                    size_t *retlen, const u_char *buf)
+{
+       return powernv_flash_async_op(mtd, FLASH_OP_WRITE, to,
+                       len, retlen, (u_char *)buf);
+}
+
+/**
+ * @mtd: the device
+ * @erase: the erase info
+ * Returns 0 if erase successful or -ERRNO if an error occurred
+ */
+static int powernv_flash_erase(struct mtd_info *mtd, struct erase_info *erase)
+{
+       int rc;
+
+       erase->state = MTD_ERASING;
+
+       /* todo: register our own notifier to do a true async implementation */
+       rc =  powernv_flash_async_op(mtd, FLASH_OP_ERASE, erase->addr,
+                       erase->len, NULL, NULL);
+
+       if (rc) {
+               erase->fail_addr = erase->addr;
+               erase->state = MTD_ERASE_FAILED;
+       } else {
+               erase->state = MTD_ERASE_DONE;
+       }
+       mtd_erase_callback(erase);
+       return rc;
+}
+
+/**
+ * powernv_flash_set_driver_info - Fill the mtd_info structure and docg3
+ * structure @pdev: The platform device
+ * @mtd: The structure to fill
+ */
+static int powernv_flash_set_driver_info(struct device *dev,
+               struct mtd_info *mtd)
+{
+       u64 size;
+       u32 erase_size;
+       int rc;
+
+       rc = of_property_read_u32(dev->of_node, "ibm,flash-block-size",
+                       &erase_size);
+       if (rc) {
+               dev_err(dev, "couldn't get resource block size information\n");
+               return rc;
+       }
+
+       rc = of_property_read_u64(dev->of_node, "reg", &size);
+       if (rc) {
+               dev_err(dev, "couldn't get resource size information\n");
+               return rc;
+       }
+
+       /*
+        * Going to have to check what details I need to set and how to
+        * get them
+        */
+       mtd->name = of_get_property(dev->of_node, "name", NULL);
+       mtd->type = MTD_NORFLASH;
+       mtd->flags = MTD_WRITEABLE;
+       mtd->size = size;
+       mtd->erasesize = erase_size;
+       mtd->writebufsize = mtd->writesize = 1;
+       mtd->owner = THIS_MODULE;
+       mtd->_erase = powernv_flash_erase;
+       mtd->_read = powernv_flash_read;
+       mtd->_write = powernv_flash_write;
+       mtd->dev.parent = dev;
+       return 0;
+}
+
+/**
+ * powernv_flash_probe
+ * @pdev: platform device
+ *
+ * Returns 0 on success, -ENOMEM, -ENXIO on error
+ */
+static int powernv_flash_probe(struct platform_device *pdev)
+{
+       struct device *dev = &pdev->dev;
+       struct powernv_flash *data;
+       int ret;
+
+       data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
+       if (!data) {
+               ret = -ENOMEM;
+               goto out;
+       }
+       data->mtd.priv = data;
+
+       ret = of_property_read_u32(dev->of_node, "ibm,opal-id", &(data->id));
+       if (ret) {
+               dev_err(dev, "no device property 'ibm,opal-id'\n");
+               goto out;
+       }
+
+       ret = powernv_flash_set_driver_info(dev, &data->mtd);
+       if (ret)
+               goto out;
+
+       dev_set_drvdata(dev, data);
+
+       /*
+        * The current flash that skiboot exposes is one contiguous flash chip
+        * with an ffs partition at the start, it should prove easier for users
+        * to deal with partitions or not as they see fit
+        */
+       ret = mtd_device_register(&data->mtd, NULL, 0);
+
+out:
+       return ret;
+}
+
+/**
+ * op_release - Release the driver
+ * @pdev: the platform device
+ *
+ * Returns 0
+ */
+static int powernv_flash_release(struct platform_device *pdev)
+{
+       struct powernv_flash *data = dev_get_drvdata(&(pdev->dev));
+
+       /* All resources should be freed automatically */
+       return mtd_device_unregister(&(data->mtd));
+}
+
+static const struct of_device_id powernv_flash_match[] = {
+       { .compatible = "ibm,opal-flash" },
+       {}
+};
+
+static struct platform_driver powernv_flash_driver = {
+       .driver         = {
+               .name           = "powernv_flash",
+               .of_match_table = powernv_flash_match,
+       },
+       .remove         = powernv_flash_release,
+       .probe          = powernv_flash_probe,
+};
+
+module_platform_driver(powernv_flash_driver);
+
+MODULE_DEVICE_TABLE(of, powernv_flash_match);
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Cyril Bur <cyril.bur@au1.ibm.com>");
+MODULE_DESCRIPTION("MTD abstraction for OPAL flash");