mtd: powernv: Add powernv flash MTD abstraction driver (1cbb4a1c) · Commits · e / devices / android_kernel_fairphone_FP3

drivers/mtd/devices/Kconfig

+8 −0

Original line number	Diff line number	Diff line
		@@ -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

drivers/mtd/devices/Makefile

+1 −0

Original line number	Diff line number	Diff line
		@@ -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)

drivers/mtd/devices/powernv_flash.c

0 → 100644

+285 −0

Original line number	Diff line number	Diff line
		/*
		* 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");