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         erase->state = MTD_ERASING;
 179
 180         /* todo: register our own notifier to do a true async implementation */
 181         rc =  powernv_flash_async_op(mtd, FLASH_OP_ERASE, erase->addr,
 182                         erase->len, NULL, NULL);
 183
 184         if (rc) {
 185                 erase->fail_addr = erase->addr;
 186                 erase->state = MTD_ERASE_FAILED;
 187         } else {
 188                 erase->state = MTD_ERASE_DONE;
 189         }
 190         mtd_erase_callback(erase);
 191         return rc;
 192 }
 193
 194 /**
 195  * powernv_flash_set_driver_info - Fill the mtd_info structure and docg3
 196  * structure @pdev: The platform device
 197  * @mtd: The structure to fill
 198  */
 199 static int powernv_flash_set_driver_info(struct device *dev,
 200                 struct mtd_info *mtd)
 201 {
 202         u64 size;
 203         u32 erase_size;
 204         int rc;
 205
 206         rc = of_property_read_u32(dev->of_node, "ibm,flash-block-size",
 207                         &erase_size);
 208         if (rc) {
 209                 dev_err(dev, "couldn't get resource block size information\n");
 210                 return rc;
 211         }
 212
 213         rc = of_property_read_u64(dev->of_node, "reg", &size);
 214         if (rc) {
 215                 dev_err(dev, "couldn't get resource size information\n");
 216                 return rc;
 217         }
 218
 219         /*
 220          * Going to have to check what details I need to set and how to
 221          * get them
 222          */
 223         mtd->name = of_get_property(dev->of_node, "name", NULL);
 224         mtd->type = MTD_NORFLASH;
 225         mtd->flags = MTD_WRITEABLE;
 226         mtd->size = size;
 227         mtd->erasesize = erase_size;
 228         mtd->writebufsize = mtd->writesize = 1;
 229         mtd->owner = THIS_MODULE;
 230         mtd->_erase = powernv_flash_erase;
 231         mtd->_read = powernv_flash_read;
 232         mtd->_write = powernv_flash_write;
 233         mtd->dev.parent = dev;
 234         return 0;
 235 }
 236
 237 /**
 238  * powernv_flash_probe
 239  * @pdev: platform device
 240  *
 241  * Returns 0 on success, -ENOMEM, -ENXIO on error
 242  */
 243 static int powernv_flash_probe(struct platform_device *pdev)
 244 {
 245         struct device *dev = &pdev->dev;
 246         struct powernv_flash *data;
 247         int ret;
 248
 249         data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
 250         if (!data)
 251                 return -ENOMEM;
 252
 253         data->mtd.priv = data;
 254
 255         ret = of_property_read_u32(dev->of_node, "ibm,opal-id", &(data->id));
 256         if (ret) {
 257                 dev_err(dev, "no device property 'ibm,opal-id'\n");
 258                 return ret;
 259         }
 260
 261         ret = powernv_flash_set_driver_info(dev, &data->mtd);
 262         if (ret)
 263                 return ret;
 264
 265         dev_set_drvdata(dev, data);
 266
 267         /*
 268          * The current flash that skiboot exposes is one contiguous flash chip
 269          * with an ffs partition at the start, it should prove easier for users
 270          * to deal with partitions or not as they see fit
 271          */
 272         return mtd_device_register(&data->mtd, NULL, 0);
 273 }
 274
 275 /**
 276  * op_release - Release the driver
 277  * @pdev: the platform device
 278  *
 279  * Returns 0
 280  */
 281 static int powernv_flash_release(struct platform_device *pdev)
 282 {
 283         struct powernv_flash *data = dev_get_drvdata(&(pdev->dev));
 284
 285         /* All resources should be freed automatically */
 286         return mtd_device_unregister(&(data->mtd));
 287 }
 288
 289 static const struct of_device_id powernv_flash_match[] = {
 290         { .compatible = "ibm,opal-flash" },
 291         {}
 292 };
 293
 294 static struct platform_driver powernv_flash_driver = {
 295         .driver         = {
 296                 .name           = "powernv_flash",
 297                 .of_match_table = powernv_flash_match,
 298         },
 299         .remove         = powernv_flash_release,
 300         .probe          = powernv_flash_probe,
 301 };
 302
 303 module_platform_driver(powernv_flash_driver);
 304
 305 MODULE_DEVICE_TABLE(of, powernv_flash_match);
 306 MODULE_LICENSE("GPL");
 307 MODULE_AUTHOR("Cyril Bur <cyril.bur@au1.ibm.com>");
 308 MODULE_DESCRIPTION("MTD abstraction for OPAL flash");