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