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 static int powernv_flash_async_op(struct mtd_info *mtd, enum flash_op op, 51 loff_t offset, size_t len, size_t *retlen, u_char *buf) 52 { 53 struct powernv_flash *info = (struct powernv_flash *)mtd->priv; 54 struct device *dev = &mtd->dev; 55 int token; 56 struct opal_msg msg; 57 int rc; 58 59 dev_dbg(dev, "%s(op=%d, offset=0x%llx, len=%zu)\n", 60 __func__, op, offset, len); 61 62 token = opal_async_get_token_interruptible(); 63 if (token < 0) { 64 if (token != -ERESTARTSYS) 65 dev_err(dev, "Failed to get an async token\n"); 66 67 return token; 68 } 69 70 switch (op) { 71 case FLASH_OP_READ: 72 rc = opal_flash_read(info->id, offset, __pa(buf), len, token); 73 break; 74 case FLASH_OP_WRITE: 75 rc = opal_flash_write(info->id, offset, __pa(buf), len, token); 76 break; 77 case FLASH_OP_ERASE: 78 rc = opal_flash_erase(info->id, offset, len, token); 79 break; 80 default: 81 BUG_ON(1); 82 } 83 84 if (rc != OPAL_ASYNC_COMPLETION) { 85 dev_err(dev, "opal_flash_async_op(op=%d) failed (rc %d)\n", 86 op, rc); 87 opal_async_release_token(token); 88 return -EIO; 89 } 90 91 rc = opal_async_wait_response(token, &msg); 92 opal_async_release_token(token); 93 if (rc) { 94 dev_err(dev, "opal async wait failed (rc %d)\n", rc); 95 return -EIO; 96 } 97 98 rc = be64_to_cpu(msg.params[1]); 99 if (rc == OPAL_SUCCESS) { 100 rc = 0; 101 if (retlen) 102 *retlen = len; 103 } else { 104 rc = -EIO; 105 } 106 107 return rc; 108 } 109 110 /** 111 * @mtd: the device 112 * @from: the offset to read from 113 * @len: the number of bytes to read 114 * @retlen: the number of bytes actually read 115 * @buf: the filled in buffer 116 * 117 * Returns 0 if read successful, or -ERRNO if an error occurred 118 */ 119 static int powernv_flash_read(struct mtd_info *mtd, loff_t from, size_t len, 120 size_t *retlen, u_char *buf) 121 { 122 return powernv_flash_async_op(mtd, FLASH_OP_READ, from, 123 len, retlen, buf); 124 } 125 126 /** 127 * @mtd: the device 128 * @to: the offset to write to 129 * @len: the number of bytes to write 130 * @retlen: the number of bytes actually written 131 * @buf: the buffer to get bytes from 132 * 133 * Returns 0 if write successful, -ERRNO if error occurred 134 */ 135 static int powernv_flash_write(struct mtd_info *mtd, loff_t to, size_t len, 136 size_t *retlen, const u_char *buf) 137 { 138 return powernv_flash_async_op(mtd, FLASH_OP_WRITE, to, 139 len, retlen, (u_char *)buf); 140 } 141 142 /** 143 * @mtd: the device 144 * @erase: the erase info 145 * Returns 0 if erase successful or -ERRNO if an error occurred 146 */ 147 static int powernv_flash_erase(struct mtd_info *mtd, struct erase_info *erase) 148 { 149 int rc; 150 151 erase->state = MTD_ERASING; 152 153 /* todo: register our own notifier to do a true async implementation */ 154 rc = powernv_flash_async_op(mtd, FLASH_OP_ERASE, erase->addr, 155 erase->len, NULL, NULL); 156 157 if (rc) { 158 erase->fail_addr = erase->addr; 159 erase->state = MTD_ERASE_FAILED; 160 } else { 161 erase->state = MTD_ERASE_DONE; 162 } 163 mtd_erase_callback(erase); 164 return rc; 165 } 166 167 /** 168 * powernv_flash_set_driver_info - Fill the mtd_info structure and docg3 169 * structure @pdev: The platform device 170 * @mtd: The structure to fill 171 */ 172 static int powernv_flash_set_driver_info(struct device *dev, 173 struct mtd_info *mtd) 174 { 175 u64 size; 176 u32 erase_size; 177 int rc; 178 179 rc = of_property_read_u32(dev->of_node, "ibm,flash-block-size", 180 &erase_size); 181 if (rc) { 182 dev_err(dev, "couldn't get resource block size information\n"); 183 return rc; 184 } 185 186 rc = of_property_read_u64(dev->of_node, "reg", &size); 187 if (rc) { 188 dev_err(dev, "couldn't get resource size information\n"); 189 return rc; 190 } 191 192 /* 193 * Going to have to check what details I need to set and how to 194 * get them 195 */ 196 mtd->name = of_get_property(dev->of_node, "name", NULL); 197 mtd->type = MTD_NORFLASH; 198 mtd->flags = MTD_WRITEABLE; 199 mtd->size = size; 200 mtd->erasesize = erase_size; 201 mtd->writebufsize = mtd->writesize = 1; 202 mtd->owner = THIS_MODULE; 203 mtd->_erase = powernv_flash_erase; 204 mtd->_read = powernv_flash_read; 205 mtd->_write = powernv_flash_write; 206 mtd->dev.parent = dev; 207 return 0; 208 } 209 210 /** 211 * powernv_flash_probe 212 * @pdev: platform device 213 * 214 * Returns 0 on success, -ENOMEM, -ENXIO on error 215 */ 216 static int powernv_flash_probe(struct platform_device *pdev) 217 { 218 struct device *dev = &pdev->dev; 219 struct powernv_flash *data; 220 int ret; 221 222 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); 223 if (!data) { 224 ret = -ENOMEM; 225 goto out; 226 } 227 data->mtd.priv = data; 228 229 ret = of_property_read_u32(dev->of_node, "ibm,opal-id", &(data->id)); 230 if (ret) { 231 dev_err(dev, "no device property 'ibm,opal-id'\n"); 232 goto out; 233 } 234 235 ret = powernv_flash_set_driver_info(dev, &data->mtd); 236 if (ret) 237 goto out; 238 239 dev_set_drvdata(dev, data); 240 241 /* 242 * The current flash that skiboot exposes is one contiguous flash chip 243 * with an ffs partition at the start, it should prove easier for users 244 * to deal with partitions or not as they see fit 245 */ 246 ret = mtd_device_register(&data->mtd, NULL, 0); 247 248 out: 249 return ret; 250 } 251 252 /** 253 * op_release - Release the driver 254 * @pdev: the platform device 255 * 256 * Returns 0 257 */ 258 static int powernv_flash_release(struct platform_device *pdev) 259 { 260 struct powernv_flash *data = dev_get_drvdata(&(pdev->dev)); 261 262 /* All resources should be freed automatically */ 263 return mtd_device_unregister(&(data->mtd)); 264 } 265 266 static const struct of_device_id powernv_flash_match[] = { 267 { .compatible = "ibm,opal-flash" }, 268 {} 269 }; 270 271 static struct platform_driver powernv_flash_driver = { 272 .driver = { 273 .name = "powernv_flash", 274 .of_match_table = powernv_flash_match, 275 }, 276 .remove = powernv_flash_release, 277 .probe = powernv_flash_probe, 278 }; 279 280 module_platform_driver(powernv_flash_driver); 281 282 MODULE_DEVICE_TABLE(of, powernv_flash_match); 283 MODULE_LICENSE("GPL"); 284 MODULE_AUTHOR("Cyril Bur <cyril.bur@au1.ibm.com>"); 285 MODULE_DESCRIPTION("MTD abstraction for OPAL flash"); 286