1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * OPAL PNOR flash MTD abstraction
4 *
5 * Copyright IBM 2015
6 */
7
8#include <linux/kernel.h>
9#include <linux/module.h>
10#include <linux/errno.h>
11#include <linux/of.h>
12#include <linux/of_address.h>
13#include <linux/platform_device.h>
14#include <linux/string.h>
15#include <linux/slab.h>
16#include <linux/mtd/mtd.h>
17#include <linux/mtd/partitions.h>
18
19#include <linux/debugfs.h>
20#include <linux/seq_file.h>
21
22#include <asm/opal.h>
23
24
25/*
26 * This driver creates the a Linux MTD abstraction for platform PNOR flash
27 * backed by OPAL calls
28 */
29
30struct powernv_flash {
31	struct mtd_info	mtd;
32	u32 id;
33};
34
35enum flash_op {
36	FLASH_OP_READ,
37	FLASH_OP_WRITE,
38	FLASH_OP_ERASE,
39};
40
41/*
42 * Don't return -ERESTARTSYS if we can't get a token, the MTD core
43 * might have split up the call from userspace and called into the
44 * driver more than once, we'll already have done some amount of work.
45 */
46static int powernv_flash_async_op(struct mtd_info *mtd, enum flash_op op,
47		loff_t offset, size_t len, size_t *retlen, u_char *buf)
48{
49	struct powernv_flash *info = (struct powernv_flash *)mtd->priv;
50	struct device *dev = &mtd->dev;
51	int token;
52	struct opal_msg msg;
53	int rc;
54
55	dev_dbg(dev, "%s(op=%d, offset=0x%llx, len=%zu)\n",
56			__func__, op, offset, len);
57
58	token = opal_async_get_token_interruptible();
59	if (token < 0) {
60		if (token != -ERESTARTSYS)
61			dev_err(dev, "Failed to get an async token\n");
62		else
63			token = -EINTR;
64		return token;
65	}
66
67	switch (op) {
68	case FLASH_OP_READ:
69		rc = opal_flash_read(info->id, offset, __pa(buf), len, token);
70		break;
71	case FLASH_OP_WRITE:
72		rc = opal_flash_write(info->id, offset, __pa(buf), len, token);
73		break;
74	case FLASH_OP_ERASE:
75		rc = opal_flash_erase(info->id, offset, len, token);
76		break;
77	default:
78		WARN_ON_ONCE(1);
79		opal_async_release_token(token);
80		return -EIO;
81	}
82
83	if (rc == OPAL_ASYNC_COMPLETION) {
84		rc = opal_async_wait_response_interruptible(token, &msg);
85		if (rc) {
86			/*
87			 * If we return the mtd core will free the
88			 * buffer we've just passed to OPAL but OPAL
89			 * will continue to read or write from that
90			 * memory.
91			 * It may be tempting to ultimately return 0
92			 * if we're doing a read or a write since we
93			 * are going to end up waiting until OPAL is
94			 * done. However, because the MTD core sends
95			 * us the userspace request in chunks, we need
96			 * it to know we've been interrupted.
97			 */
98			rc = -EINTR;
99			if (opal_async_wait_response(token, &msg))
100				dev_err(dev, "opal_async_wait_response() failed\n");
101			goto out;
102		}
103		rc = opal_get_async_rc(msg);
104	}
105
106	/*
107	 * OPAL does mutual exclusion on the flash, it will return
108	 * OPAL_BUSY.
109	 * During firmware updates by the service processor OPAL may
110	 * be (temporarily) prevented from accessing the flash, in
111	 * this case OPAL will also return OPAL_BUSY.
112	 * Both cases aren't errors exactly but the flash could have
113	 * changed, userspace should be informed.
114	 */
115	if (rc != OPAL_SUCCESS && rc != OPAL_BUSY)
116		dev_err(dev, "opal_flash_async_op(op=%d) failed (rc %d)\n",
117				op, rc);
118
119	if (rc == OPAL_SUCCESS && retlen)
120		*retlen = len;
121
122	rc = opal_error_code(rc);
123out:
124	opal_async_release_token(token);
125	return rc;
126}
127
128/**
129 * powernv_flash_read
130 * @mtd: the device
131 * @from: the offset to read from
132 * @len: the number of bytes to read
133 * @retlen: the number of bytes actually read
134 * @buf: the filled in buffer
135 *
136 * Returns 0 if read successful, or -ERRNO if an error occurred
137 */
138static int powernv_flash_read(struct mtd_info *mtd, loff_t from, size_t len,
139	     size_t *retlen, u_char *buf)
140{
141	return powernv_flash_async_op(mtd, FLASH_OP_READ, from,
142			len, retlen, buf);
143}
144
145/**
146 * powernv_flash_write
147 * @mtd: the device
148 * @to: the offset to write to
149 * @len: the number of bytes to write
150 * @retlen: the number of bytes actually written
151 * @buf: the buffer to get bytes from
152 *
153 * Returns 0 if write successful, -ERRNO if error occurred
154 */
155static int powernv_flash_write(struct mtd_info *mtd, loff_t to, size_t len,
156		     size_t *retlen, const u_char *buf)
157{
158	return powernv_flash_async_op(mtd, FLASH_OP_WRITE, to,
159			len, retlen, (u_char *)buf);
160}
161
162/**
163 * powernv_flash_erase
164 * @mtd: the device
165 * @erase: the erase info
166 * Returns 0 if erase successful or -ERRNO if an error occurred
167 */
168static int powernv_flash_erase(struct mtd_info *mtd, struct erase_info *erase)
169{
170	int rc;
171
172	rc =  powernv_flash_async_op(mtd, FLASH_OP_ERASE, erase->addr,
173			erase->len, NULL, NULL);
174	if (rc)
175		erase->fail_addr = erase->addr;
176
177	return rc;
178}
179
180/**
181 * powernv_flash_set_driver_info - Fill the mtd_info structure and docg3
182 * @dev: The device structure
183 * @mtd: The structure to fill
184 */
185static int powernv_flash_set_driver_info(struct device *dev,
186		struct mtd_info *mtd)
187{
188	u64 size;
189	u32 erase_size;
190	int rc;
191
192	rc = of_property_read_u32(dev->of_node, "ibm,flash-block-size",
193			&erase_size);
194	if (rc) {
195		dev_err(dev, "couldn't get resource block size information\n");
196		return rc;
197	}
198
199	rc = of_property_read_u64(dev->of_node, "reg", &size);
200	if (rc) {
201		dev_err(dev, "couldn't get resource size information\n");
202		return rc;
203	}
204
205	/*
206	 * Going to have to check what details I need to set and how to
207	 * get them
208	 */
209	mtd->name = devm_kasprintf(dev, GFP_KERNEL, "%pOFP", dev->of_node);
210	mtd->type = MTD_NORFLASH;
211	mtd->flags = MTD_WRITEABLE;
212	mtd->size = size;
213	mtd->erasesize = erase_size;
214	mtd->writebufsize = mtd->writesize = 1;
215	mtd->owner = THIS_MODULE;
216	mtd->_erase = powernv_flash_erase;
217	mtd->_read = powernv_flash_read;
218	mtd->_write = powernv_flash_write;
219	mtd->dev.parent = dev;
220	mtd_set_of_node(mtd, dev->of_node);
221	return 0;
222}
223
224/**
225 * powernv_flash_probe
226 * @pdev: platform device
227 *
228 * Returns 0 on success, -ENOMEM, -ENXIO on error
229 */
230static int powernv_flash_probe(struct platform_device *pdev)
231{
232	struct device *dev = &pdev->dev;
233	struct powernv_flash *data;
234	int ret;
235
236	data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
237	if (!data)
238		return -ENOMEM;
239
240	data->mtd.priv = data;
241
242	ret = of_property_read_u32(dev->of_node, "ibm,opal-id", &(data->id));
243	if (ret) {
244		dev_err(dev, "no device property 'ibm,opal-id'\n");
245		return ret;
246	}
247
248	ret = powernv_flash_set_driver_info(dev, &data->mtd);
249	if (ret)
250		return ret;
251
252	dev_set_drvdata(dev, data);
253
254	/*
255	 * The current flash that skiboot exposes is one contiguous flash chip
256	 * with an ffs partition at the start, it should prove easier for users
257	 * to deal with partitions or not as they see fit
258	 */
259	return mtd_device_register(&data->mtd, NULL, 0);
260}
261
262/**
263 * op_release - Release the driver
264 * @pdev: the platform device
265 *
266 * Returns 0
267 */
268static void powernv_flash_release(struct platform_device *pdev)
269{
270	struct powernv_flash *data = dev_get_drvdata(&(pdev->dev));
271
272	/* All resources should be freed automatically */
273	WARN_ON(mtd_device_unregister(&data->mtd));
274}
275
276static const struct of_device_id powernv_flash_match[] = {
277	{ .compatible = "ibm,opal-flash" },
278	{}
279};
280
281static struct platform_driver powernv_flash_driver = {
282	.driver		= {
283		.name		= "powernv_flash",
284		.of_match_table	= powernv_flash_match,
285	},
286	.remove_new	= powernv_flash_release,
287	.probe		= powernv_flash_probe,
288};
289
290module_platform_driver(powernv_flash_driver);
291
292MODULE_DEVICE_TABLE(of, powernv_flash_match);
293MODULE_LICENSE("GPL");
294MODULE_AUTHOR("Cyril Bur <cyril.bur@au1.ibm.com>");
295MODULE_DESCRIPTION("MTD abstraction for OPAL flash");
296