1 /* 2 * Simple MTD partitioning layer 3 * 4 * (C) 2000 Nicolas Pitre <nico@cam.org> 5 * 6 * This code is GPL 7 * 8 * 02-21-2002 Thomas Gleixner <gleixner@autronix.de> 9 * added support for read_oob, write_oob 10 */ 11 12 #include <common.h> 13 #include <malloc.h> 14 #include <asm/errno.h> 15 16 #include <linux/types.h> 17 #include <linux/list.h> 18 #include <linux/mtd/mtd.h> 19 #include <linux/mtd/partitions.h> 20 #include <linux/mtd/compat.h> 21 22 /* Our partition linked list */ 23 struct list_head mtd_partitions; 24 25 /* Our partition node structure */ 26 struct mtd_part { 27 struct mtd_info mtd; 28 struct mtd_info *master; 29 uint64_t offset; 30 int index; 31 struct list_head list; 32 int registered; 33 }; 34 35 /* 36 * Given a pointer to the MTD object in the mtd_part structure, we can retrieve 37 * the pointer to that structure with this macro. 38 */ 39 #define PART(x) ((struct mtd_part *)(x)) 40 41 42 /* 43 * MTD methods which simply translate the effective address and pass through 44 * to the _real_ device. 45 */ 46 47 static int part_read(struct mtd_info *mtd, loff_t from, size_t len, 48 size_t *retlen, u_char *buf) 49 { 50 struct mtd_part *part = PART(mtd); 51 struct mtd_ecc_stats stats; 52 int res; 53 54 stats = part->master->ecc_stats; 55 56 if (from >= mtd->size) 57 len = 0; 58 else if (from + len > mtd->size) 59 len = mtd->size - from; 60 res = part->master->read(part->master, from + part->offset, 61 len, retlen, buf); 62 if (unlikely(res)) { 63 if (res == -EUCLEAN) 64 mtd->ecc_stats.corrected += part->master->ecc_stats.corrected - stats.corrected; 65 if (res == -EBADMSG) 66 mtd->ecc_stats.failed += part->master->ecc_stats.failed - stats.failed; 67 } 68 return res; 69 } 70 71 static int part_read_oob(struct mtd_info *mtd, loff_t from, 72 struct mtd_oob_ops *ops) 73 { 74 struct mtd_part *part = PART(mtd); 75 int res; 76 77 if (from >= mtd->size) 78 return -EINVAL; 79 if (ops->datbuf && from + ops->len > mtd->size) 80 return -EINVAL; 81 res = part->master->read_oob(part->master, from + part->offset, ops); 82 83 if (unlikely(res)) { 84 if (res == -EUCLEAN) 85 mtd->ecc_stats.corrected++; 86 if (res == -EBADMSG) 87 mtd->ecc_stats.failed++; 88 } 89 return res; 90 } 91 92 static int part_read_user_prot_reg(struct mtd_info *mtd, loff_t from, 93 size_t len, size_t *retlen, u_char *buf) 94 { 95 struct mtd_part *part = PART(mtd); 96 return part->master->read_user_prot_reg(part->master, from, 97 len, retlen, buf); 98 } 99 100 static int part_get_user_prot_info(struct mtd_info *mtd, 101 struct otp_info *buf, size_t len) 102 { 103 struct mtd_part *part = PART(mtd); 104 return part->master->get_user_prot_info(part->master, buf, len); 105 } 106 107 static int part_read_fact_prot_reg(struct mtd_info *mtd, loff_t from, 108 size_t len, size_t *retlen, u_char *buf) 109 { 110 struct mtd_part *part = PART(mtd); 111 return part->master->read_fact_prot_reg(part->master, from, 112 len, retlen, buf); 113 } 114 115 static int part_get_fact_prot_info(struct mtd_info *mtd, struct otp_info *buf, 116 size_t len) 117 { 118 struct mtd_part *part = PART(mtd); 119 return part->master->get_fact_prot_info(part->master, buf, len); 120 } 121 122 static int part_write(struct mtd_info *mtd, loff_t to, size_t len, 123 size_t *retlen, const u_char *buf) 124 { 125 struct mtd_part *part = PART(mtd); 126 if (!(mtd->flags & MTD_WRITEABLE)) 127 return -EROFS; 128 if (to >= mtd->size) 129 len = 0; 130 else if (to + len > mtd->size) 131 len = mtd->size - to; 132 return part->master->write(part->master, to + part->offset, 133 len, retlen, buf); 134 } 135 136 static int part_panic_write(struct mtd_info *mtd, loff_t to, size_t len, 137 size_t *retlen, const u_char *buf) 138 { 139 struct mtd_part *part = PART(mtd); 140 if (!(mtd->flags & MTD_WRITEABLE)) 141 return -EROFS; 142 if (to >= mtd->size) 143 len = 0; 144 else if (to + len > mtd->size) 145 len = mtd->size - to; 146 return part->master->panic_write(part->master, to + part->offset, 147 len, retlen, buf); 148 } 149 150 static int part_write_oob(struct mtd_info *mtd, loff_t to, 151 struct mtd_oob_ops *ops) 152 { 153 struct mtd_part *part = PART(mtd); 154 155 if (!(mtd->flags & MTD_WRITEABLE)) 156 return -EROFS; 157 158 if (to >= mtd->size) 159 return -EINVAL; 160 if (ops->datbuf && to + ops->len > mtd->size) 161 return -EINVAL; 162 return part->master->write_oob(part->master, to + part->offset, ops); 163 } 164 165 static int part_write_user_prot_reg(struct mtd_info *mtd, loff_t from, 166 size_t len, size_t *retlen, u_char *buf) 167 { 168 struct mtd_part *part = PART(mtd); 169 return part->master->write_user_prot_reg(part->master, from, 170 len, retlen, buf); 171 } 172 173 static int part_lock_user_prot_reg(struct mtd_info *mtd, loff_t from, 174 size_t len) 175 { 176 struct mtd_part *part = PART(mtd); 177 return part->master->lock_user_prot_reg(part->master, from, len); 178 } 179 180 static int part_erase(struct mtd_info *mtd, struct erase_info *instr) 181 { 182 struct mtd_part *part = PART(mtd); 183 int ret; 184 if (!(mtd->flags & MTD_WRITEABLE)) 185 return -EROFS; 186 if (instr->addr >= mtd->size) 187 return -EINVAL; 188 instr->addr += part->offset; 189 ret = part->master->erase(part->master, instr); 190 if (ret) { 191 if (instr->fail_addr != MTD_FAIL_ADDR_UNKNOWN) 192 instr->fail_addr -= part->offset; 193 instr->addr -= part->offset; 194 } 195 return ret; 196 } 197 198 void mtd_erase_callback(struct erase_info *instr) 199 { 200 if (instr->mtd->erase == part_erase) { 201 struct mtd_part *part = PART(instr->mtd); 202 203 if (instr->fail_addr != MTD_FAIL_ADDR_UNKNOWN) 204 instr->fail_addr -= part->offset; 205 instr->addr -= part->offset; 206 } 207 if (instr->callback) 208 instr->callback(instr); 209 } 210 211 static int part_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len) 212 { 213 struct mtd_part *part = PART(mtd); 214 if ((len + ofs) > mtd->size) 215 return -EINVAL; 216 return part->master->lock(part->master, ofs + part->offset, len); 217 } 218 219 static int part_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len) 220 { 221 struct mtd_part *part = PART(mtd); 222 if ((len + ofs) > mtd->size) 223 return -EINVAL; 224 return part->master->unlock(part->master, ofs + part->offset, len); 225 } 226 227 static void part_sync(struct mtd_info *mtd) 228 { 229 struct mtd_part *part = PART(mtd); 230 part->master->sync(part->master); 231 } 232 233 static int part_suspend(struct mtd_info *mtd) 234 { 235 struct mtd_part *part = PART(mtd); 236 return part->master->suspend(part->master); 237 } 238 239 static void part_resume(struct mtd_info *mtd) 240 { 241 struct mtd_part *part = PART(mtd); 242 part->master->resume(part->master); 243 } 244 245 static int part_block_isbad(struct mtd_info *mtd, loff_t ofs) 246 { 247 struct mtd_part *part = PART(mtd); 248 if (ofs >= mtd->size) 249 return -EINVAL; 250 ofs += part->offset; 251 return part->master->block_isbad(part->master, ofs); 252 } 253 254 static int part_block_markbad(struct mtd_info *mtd, loff_t ofs) 255 { 256 struct mtd_part *part = PART(mtd); 257 int res; 258 259 if (!(mtd->flags & MTD_WRITEABLE)) 260 return -EROFS; 261 if (ofs >= mtd->size) 262 return -EINVAL; 263 ofs += part->offset; 264 res = part->master->block_markbad(part->master, ofs); 265 if (!res) 266 mtd->ecc_stats.badblocks++; 267 return res; 268 } 269 270 /* 271 * This function unregisters and destroy all slave MTD objects which are 272 * attached to the given master MTD object. 273 */ 274 275 int del_mtd_partitions(struct mtd_info *master) 276 { 277 struct mtd_part *slave, *next; 278 279 list_for_each_entry_safe(slave, next, &mtd_partitions, list) 280 if (slave->master == master) { 281 list_del(&slave->list); 282 if (slave->registered) 283 del_mtd_device(&slave->mtd); 284 kfree(slave); 285 } 286 287 return 0; 288 } 289 290 static struct mtd_part *add_one_partition(struct mtd_info *master, 291 const struct mtd_partition *part, int partno, 292 uint64_t cur_offset) 293 { 294 struct mtd_part *slave; 295 296 /* allocate the partition structure */ 297 slave = kzalloc(sizeof(*slave), GFP_KERNEL); 298 if (!slave) { 299 printk(KERN_ERR"memory allocation error while creating partitions for \"%s\"\n", 300 master->name); 301 del_mtd_partitions(master); 302 return NULL; 303 } 304 list_add(&slave->list, &mtd_partitions); 305 306 /* set up the MTD object for this partition */ 307 slave->mtd.type = master->type; 308 slave->mtd.flags = master->flags & ~part->mask_flags; 309 slave->mtd.size = part->size; 310 slave->mtd.writesize = master->writesize; 311 slave->mtd.oobsize = master->oobsize; 312 slave->mtd.oobavail = master->oobavail; 313 slave->mtd.subpage_sft = master->subpage_sft; 314 315 slave->mtd.name = part->name; 316 slave->mtd.owner = master->owner; 317 318 slave->mtd.read = part_read; 319 slave->mtd.write = part_write; 320 321 if (master->panic_write) 322 slave->mtd.panic_write = part_panic_write; 323 324 if (master->read_oob) 325 slave->mtd.read_oob = part_read_oob; 326 if (master->write_oob) 327 slave->mtd.write_oob = part_write_oob; 328 if (master->read_user_prot_reg) 329 slave->mtd.read_user_prot_reg = part_read_user_prot_reg; 330 if (master->read_fact_prot_reg) 331 slave->mtd.read_fact_prot_reg = part_read_fact_prot_reg; 332 if (master->write_user_prot_reg) 333 slave->mtd.write_user_prot_reg = part_write_user_prot_reg; 334 if (master->lock_user_prot_reg) 335 slave->mtd.lock_user_prot_reg = part_lock_user_prot_reg; 336 if (master->get_user_prot_info) 337 slave->mtd.get_user_prot_info = part_get_user_prot_info; 338 if (master->get_fact_prot_info) 339 slave->mtd.get_fact_prot_info = part_get_fact_prot_info; 340 if (master->sync) 341 slave->mtd.sync = part_sync; 342 if (!partno && master->suspend && master->resume) { 343 slave->mtd.suspend = part_suspend; 344 slave->mtd.resume = part_resume; 345 } 346 if (master->lock) 347 slave->mtd.lock = part_lock; 348 if (master->unlock) 349 slave->mtd.unlock = part_unlock; 350 if (master->block_isbad) 351 slave->mtd.block_isbad = part_block_isbad; 352 if (master->block_markbad) 353 slave->mtd.block_markbad = part_block_markbad; 354 slave->mtd.erase = part_erase; 355 slave->master = master; 356 slave->offset = part->offset; 357 slave->index = partno; 358 359 if (slave->offset == MTDPART_OFS_APPEND) 360 slave->offset = cur_offset; 361 if (slave->offset == MTDPART_OFS_NXTBLK) { 362 slave->offset = cur_offset; 363 if (mtd_mod_by_eb(cur_offset, master) != 0) { 364 /* Round up to next erasesize */ 365 slave->offset = (mtd_div_by_eb(cur_offset, master) + 1) * master->erasesize; 366 printk(KERN_NOTICE "Moving partition %d: " 367 "0x%012llx -> 0x%012llx\n", partno, 368 (unsigned long long)cur_offset, (unsigned long long)slave->offset); 369 } 370 } 371 if (slave->mtd.size == MTDPART_SIZ_FULL) 372 slave->mtd.size = master->size - slave->offset; 373 374 printk(KERN_NOTICE "0x%012llx-0x%012llx : \"%s\"\n", (unsigned long long)slave->offset, 375 (unsigned long long)(slave->offset + slave->mtd.size), slave->mtd.name); 376 377 /* let's do some sanity checks */ 378 if (slave->offset >= master->size) { 379 /* let's register it anyway to preserve ordering */ 380 slave->offset = 0; 381 slave->mtd.size = 0; 382 printk(KERN_ERR"mtd: partition \"%s\" is out of reach -- disabled\n", 383 part->name); 384 goto out_register; 385 } 386 if (slave->offset + slave->mtd.size > master->size) { 387 slave->mtd.size = master->size - slave->offset; 388 printk(KERN_WARNING"mtd: partition \"%s\" extends beyond the end of device \"%s\" -- size truncated to %#llx\n", 389 part->name, master->name, (unsigned long long)slave->mtd.size); 390 } 391 if (master->numeraseregions > 1) { 392 /* Deal with variable erase size stuff */ 393 int i, max = master->numeraseregions; 394 u64 end = slave->offset + slave->mtd.size; 395 struct mtd_erase_region_info *regions = master->eraseregions; 396 397 /* Find the first erase regions which is part of this 398 * partition. */ 399 for (i = 0; i < max && regions[i].offset <= slave->offset; i++) 400 ; 401 /* The loop searched for the region _behind_ the first one */ 402 i--; 403 404 /* Pick biggest erasesize */ 405 for (; i < max && regions[i].offset < end; i++) { 406 if (slave->mtd.erasesize < regions[i].erasesize) { 407 slave->mtd.erasesize = regions[i].erasesize; 408 } 409 } 410 BUG_ON(slave->mtd.erasesize == 0); 411 } else { 412 /* Single erase size */ 413 slave->mtd.erasesize = master->erasesize; 414 } 415 416 if ((slave->mtd.flags & MTD_WRITEABLE) && 417 mtd_mod_by_eb(slave->offset, &slave->mtd)) { 418 /* Doesn't start on a boundary of major erase size */ 419 /* FIXME: Let it be writable if it is on a boundary of 420 * _minor_ erase size though */ 421 slave->mtd.flags &= ~MTD_WRITEABLE; 422 printk(KERN_WARNING"mtd: partition \"%s\" doesn't start on an erase block boundary -- force read-only\n", 423 part->name); 424 } 425 if ((slave->mtd.flags & MTD_WRITEABLE) && 426 mtd_mod_by_eb(slave->mtd.size, &slave->mtd)) { 427 slave->mtd.flags &= ~MTD_WRITEABLE; 428 printk(KERN_WARNING"mtd: partition \"%s\" doesn't end on an erase block -- force read-only\n", 429 part->name); 430 } 431 432 slave->mtd.ecclayout = master->ecclayout; 433 if (master->block_isbad) { 434 uint64_t offs = 0; 435 436 while (offs < slave->mtd.size) { 437 if (master->block_isbad(master, 438 offs + slave->offset)) 439 slave->mtd.ecc_stats.badblocks++; 440 offs += slave->mtd.erasesize; 441 } 442 } 443 444 out_register: 445 if (part->mtdp) { 446 /* store the object pointer (caller may or may not register it*/ 447 *part->mtdp = &slave->mtd; 448 slave->registered = 0; 449 } else { 450 /* register our partition */ 451 add_mtd_device(&slave->mtd); 452 slave->registered = 1; 453 } 454 return slave; 455 } 456 457 /* 458 * This function, given a master MTD object and a partition table, creates 459 * and registers slave MTD objects which are bound to the master according to 460 * the partition definitions. 461 * 462 * We don't register the master, or expect the caller to have done so, 463 * for reasons of data integrity. 464 */ 465 466 int add_mtd_partitions(struct mtd_info *master, 467 const struct mtd_partition *parts, 468 int nbparts) 469 { 470 struct mtd_part *slave; 471 uint64_t cur_offset = 0; 472 int i; 473 474 /* 475 * Need to init the list here, since LIST_INIT() does not 476 * work on platforms where relocation has problems (like MIPS 477 * & PPC). 478 */ 479 if (mtd_partitions.next == NULL) 480 INIT_LIST_HEAD(&mtd_partitions); 481 482 printk(KERN_NOTICE "Creating %d MTD partitions on \"%s\":\n", nbparts, master->name); 483 484 for (i = 0; i < nbparts; i++) { 485 slave = add_one_partition(master, parts + i, i, cur_offset); 486 if (!slave) 487 return -ENOMEM; 488 cur_offset = slave->offset + slave->mtd.size; 489 } 490 491 return 0; 492 } 493