drivers/mtd/devices/powernv_flash.c

   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
  30 struct powernv_flash {
  31         struct mtd_info mtd;
  32         u32 id;
  33 };
  34
  35 enum 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  */
  46 static 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);
 123 out:
 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  */
 138 static 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  */
 155 static 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  */
 168 static 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  */
 185 static 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  */
 230 static 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  */
 268 static int 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         return mtd_device_unregister(&(data->mtd));
 274 }
 275
 276 static const struct of_device_id powernv_flash_match[] = {
 277         { .compatible = "ibm,opal-flash" },
 278         {}
 279 };
 280
 281 static struct platform_driver powernv_flash_driver = {
 282         .driver         = {
 283                 .name           = "powernv_flash",
 284                 .of_match_table = powernv_flash_match,
 285         },
 286         .remove         = powernv_flash_release,
 287         .probe          = powernv_flash_probe,
 288 };
 289
 290 module_platform_driver(powernv_flash_driver);
 291
 292 MODULE_DEVICE_TABLE(of, powernv_flash_match);
 293 MODULE_LICENSE("GPL");
 294 MODULE_AUTHOR("Cyril Bur <cyril.bur@au1.ibm.com>");
 295 MODULE_DESCRIPTION("MTD abstraction for OPAL flash");