drivers/mtd/devices/powernv_flash.c - kernel/bruno - Git at Google

 /*
  * 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");
	/*
	* 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");