drivers/mtd/sm

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
sm_attr_show
sm_create_sysfs_attributes
sm_delete_sysfs_attributes
sm_get_lba
sm_read_lba
sm_write_lba
sm_mkoffset
sm_break_offset
sm_correct_sector
sm_read_sector
sm_write_sector
sm_write_block
sm_mark_block_bad
sm_erase_block
sm_check_block
sm_get_media_info
sm_read_cis
sm_find_cis
sm_recheck_media
sm_init_zone
sm_get_zone
sm_cache_init
sm_cache_put
sm_cache_get
sm_cache_flush
sm_cache_flush_timer
sm_cache_flush_work
sm_read
sm_write
sm_flush
sm_release
sm_getgeo
sm_add_mtd
sm_remove_dev
sm_module_init
sm_module_exit
   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright © 2009 - Maxim Levitsky
   4  * SmartMedia/xD translation layer
   5  */
   6 
   7 #include <linux/kernel.h>
   8 #include <linux/module.h>
   9 #include <linux/random.h>
  10 #include <linux/hdreg.h>
  11 #include <linux/kthread.h>
  12 #include <linux/freezer.h>
  13 #include <linux/sysfs.h>
  14 #include <linux/bitops.h>
  15 #include <linux/slab.h>
  16 #include <linux/mtd/nand_ecc.h>
  17 #include "nand/raw/sm_common.h"
  18 #include "sm_ftl.h"
  19 
  20 
  21 
  22 static struct workqueue_struct *cache_flush_workqueue;
  23 
  24 static int cache_timeout = 1000;
  25 module_param(cache_timeout, int, S_IRUGO);
  26 MODULE_PARM_DESC(cache_timeout,
  27         "Timeout (in ms) for cache flush (1000 ms default");
  28 
  29 static int debug;
  30 module_param(debug, int, S_IRUGO | S_IWUSR);
  31 MODULE_PARM_DESC(debug, "Debug level (0-2)");
  32 
  33 
  34 /* ------------------- sysfs attributes ---------------------------------- */
  35 struct sm_sysfs_attribute {
  36         struct device_attribute dev_attr;
  37         char *data;
  38         int len;
  39 };
  40 
  41 static ssize_t sm_attr_show(struct device *dev, struct device_attribute *attr,
  42                      char *buf)
  43 {
  44         struct sm_sysfs_attribute *sm_attr =
  45                 container_of(attr, struct sm_sysfs_attribute, dev_attr);
  46 
  47         strncpy(buf, sm_attr->data, sm_attr->len);
  48         return sm_attr->len;
  49 }
  50 
  51 
  52 #define NUM_ATTRIBUTES 1
  53 #define SM_CIS_VENDOR_OFFSET 0x59
  54 static struct attribute_group *sm_create_sysfs_attributes(struct sm_ftl *ftl)
  55 {
  56         struct attribute_group *attr_group;
  57         struct attribute **attributes;
  58         struct sm_sysfs_attribute *vendor_attribute;
  59         char *vendor;
  60 
  61         vendor = kstrndup(ftl->cis_buffer + SM_CIS_VENDOR_OFFSET,
  62                           SM_SMALL_PAGE - SM_CIS_VENDOR_OFFSET, GFP_KERNEL);
  63         if (!vendor)
  64                 goto error1;
  65 
  66         /* Initialize sysfs attributes */
  67         vendor_attribute =
  68                 kzalloc(sizeof(struct sm_sysfs_attribute), GFP_KERNEL);
  69         if (!vendor_attribute)
  70                 goto error2;
  71 
  72         sysfs_attr_init(&vendor_attribute->dev_attr.attr);
  73 
  74         vendor_attribute->data = vendor;
  75         vendor_attribute->len = strlen(vendor);
  76         vendor_attribute->dev_attr.attr.name = "vendor";
  77         vendor_attribute->dev_attr.attr.mode = S_IRUGO;
  78         vendor_attribute->dev_attr.show = sm_attr_show;
  79 
  80 
  81         /* Create array of pointers to the attributes */
  82         attributes = kcalloc(NUM_ATTRIBUTES + 1, sizeof(struct attribute *),
  83                                                                 GFP_KERNEL);
  84         if (!attributes)
  85                 goto error3;
  86         attributes[0] = &vendor_attribute->dev_attr.attr;
  87 
  88         /* Finally create the attribute group */
  89         attr_group = kzalloc(sizeof(struct attribute_group), GFP_KERNEL);
  90         if (!attr_group)
  91                 goto error4;
  92         attr_group->attrs = attributes;
  93         return attr_group;
  94 error4:
  95         kfree(attributes);
  96 error3:
  97         kfree(vendor_attribute);
  98 error2:
  99         kfree(vendor);
 100 error1:
 101         return NULL;
 102 }
 103 
 104 static void sm_delete_sysfs_attributes(struct sm_ftl *ftl)
 105 {
 106         struct attribute **attributes = ftl->disk_attributes->attrs;
 107         int i;
 108 
 109         for (i = 0; attributes[i] ; i++) {
 110 
 111                 struct device_attribute *dev_attr = container_of(attributes[i],
 112                         struct device_attribute, attr);
 113 
 114                 struct sm_sysfs_attribute *sm_attr =
 115                         container_of(dev_attr,
 116                                 struct sm_sysfs_attribute, dev_attr);
 117 
 118                 kfree(sm_attr->data);
 119                 kfree(sm_attr);
 120         }
 121 
 122         kfree(ftl->disk_attributes->attrs);
 123         kfree(ftl->disk_attributes);
 124 }
 125 
 126 
 127 /* ----------------------- oob helpers -------------------------------------- */
 128 
 129 static int sm_get_lba(uint8_t *lba)
 130 {
 131         /* check fixed bits */
 132         if ((lba[0] & 0xF8) != 0x10)
 133                 return -2;
 134 
 135         /* check parity - endianness doesn't matter */
 136         if (hweight16(*(uint16_t *)lba) & 1)
 137                 return -2;
 138 
 139         return (lba[1] >> 1) | ((lba[0] & 0x07) << 7);
 140 }
 141 
 142 
 143 /*
 144  * Read LBA associated with block
 145  * returns -1, if block is erased
 146  * returns -2 if error happens
 147  */
 148 static int sm_read_lba(struct sm_oob *oob)
 149 {
 150         static const uint32_t erased_pattern[4] = {
 151                 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF };
 152 
 153         uint16_t lba_test;
 154         int lba;
 155 
 156         /* First test for erased block */
 157         if (!memcmp(oob, erased_pattern, SM_OOB_SIZE))
 158                 return -1;
 159 
 160         /* Now check is both copies of the LBA differ too much */
 161         lba_test = *(uint16_t *)oob->lba_copy1 ^ *(uint16_t*)oob->lba_copy2;
 162         if (lba_test && !is_power_of_2(lba_test))
 163                 return -2;
 164 
 165         /* And read it */
 166         lba = sm_get_lba(oob->lba_copy1);
 167 
 168         if (lba == -2)
 169                 lba = sm_get_lba(oob->lba_copy2);
 170 
 171         return lba;
 172 }
 173 
 174 static void sm_write_lba(struct sm_oob *oob, uint16_t lba)
 175 {
 176         uint8_t tmp[2];
 177 
 178         WARN_ON(lba >= 1000);
 179 
 180         tmp[0] = 0x10 | ((lba >> 7) & 0x07);
 181         tmp[1] = (lba << 1) & 0xFF;
 182 
 183         if (hweight16(*(uint16_t *)tmp) & 0x01)
 184                 tmp[1] |= 1;
 185 
 186         oob->lba_copy1[0] = oob->lba_copy2[0] = tmp[0];
 187         oob->lba_copy1[1] = oob->lba_copy2[1] = tmp[1];
 188 }
 189 
 190 
 191 /* Make offset from parts */
 192 static loff_t sm_mkoffset(struct sm_ftl *ftl, int zone, int block, int boffset)
 193 {
 194         WARN_ON(boffset & (SM_SECTOR_SIZE - 1));
 195         WARN_ON(zone < 0 || zone >= ftl->zone_count);
 196         WARN_ON(block >= ftl->zone_size);
 197         WARN_ON(boffset >= ftl->block_size);
 198 
 199         if (block == -1)
 200                 return -1;
 201 
 202         return (zone * SM_MAX_ZONE_SIZE + block) * ftl->block_size + boffset;
 203 }
 204 
 205 /* Breaks offset into parts */
 206 static void sm_break_offset(struct sm_ftl *ftl, loff_t loffset,
 207                             int *zone, int *block, int *boffset)
 208 {
 209         u64 offset = loffset;
 210         *boffset = do_div(offset, ftl->block_size);
 211         *block = do_div(offset, ftl->max_lba);
 212         *zone = offset >= ftl->zone_count ? -1 : offset;
 213 }
 214 
 215 /* ---------------------- low level IO ------------------------------------- */
 216 
 217 static int sm_correct_sector(uint8_t *buffer, struct sm_oob *oob)
 218 {
 219         uint8_t ecc[3];
 220 
 221         __nand_calculate_ecc(buffer, SM_SMALL_PAGE, ecc,
 222                              IS_ENABLED(CONFIG_MTD_NAND_ECC_SW_HAMMING_SMC));
 223         if (__nand_correct_data(buffer, ecc, oob->ecc1, SM_SMALL_PAGE,
 224                                 IS_ENABLED(CONFIG_MTD_NAND_ECC_SW_HAMMING_SMC)) < 0)
 225                 return -EIO;
 226 
 227         buffer += SM_SMALL_PAGE;
 228 
 229         __nand_calculate_ecc(buffer, SM_SMALL_PAGE, ecc,
 230                              IS_ENABLED(CONFIG_MTD_NAND_ECC_SW_HAMMING_SMC));
 231         if (__nand_correct_data(buffer, ecc, oob->ecc2, SM_SMALL_PAGE,
 232                                 IS_ENABLED(CONFIG_MTD_NAND_ECC_SW_HAMMING_SMC)) < 0)
 233                 return -EIO;
 234         return 0;
 235 }
 236 
 237 /* Reads a sector + oob*/
 238 static int sm_read_sector(struct sm_ftl *ftl,
 239                           int zone, int block, int boffset,
 240                           uint8_t *buffer, struct sm_oob *oob)
 241 {
 242         struct mtd_info *mtd = ftl->trans->mtd;
 243         struct mtd_oob_ops ops;
 244         struct sm_oob tmp_oob;
 245         int ret = -EIO;
 246         int try = 0;
 247 
 248         /* FTL can contain -1 entries that are by default filled with bits */
 249         if (block == -1) {
 250                 memset(buffer, 0xFF, SM_SECTOR_SIZE);
 251                 return 0;
 252         }
 253 
 254         /* User might not need the oob, but we do for data verification */
 255         if (!oob)
 256                 oob = &tmp_oob;
 257 
 258         ops.mode = ftl->smallpagenand ? MTD_OPS_RAW : MTD_OPS_PLACE_OOB;
 259         ops.ooboffs = 0;
 260         ops.ooblen = SM_OOB_SIZE;
 261         ops.oobbuf = (void *)oob;
 262         ops.len = SM_SECTOR_SIZE;
 263         ops.datbuf = buffer;
 264 
 265 again:
 266         if (try++) {
 267                 /* Avoid infinite recursion on CIS reads, sm_recheck_media
 268                         won't help anyway */
 269                 if (zone == 0 && block == ftl->cis_block && boffset ==
 270                         ftl->cis_boffset)
 271                         return ret;
 272 
 273                 /* Test if media is stable */
 274                 if (try == 3 || sm_recheck_media(ftl))
 275                         return ret;
 276         }
 277 
 278         /* Unfortunately, oob read will _always_ succeed,
 279                 despite card removal..... */
 280         ret = mtd_read_oob(mtd, sm_mkoffset(ftl, zone, block, boffset), &ops);
 281 
 282         /* Test for unknown errors */
 283         if (ret != 0 && !mtd_is_bitflip_or_eccerr(ret)) {
 284                 dbg("read of block %d at zone %d, failed due to error (%d)",
 285                         block, zone, ret);
 286                 goto again;
 287         }
 288 
 289         /* Do a basic test on the oob, to guard against returned garbage */
 290         if (oob->reserved != 0xFFFFFFFF && !is_power_of_2(~oob->reserved))
 291                 goto again;
 292 
 293         /* This should never happen, unless there is a bug in the mtd driver */
 294         WARN_ON(ops.oobretlen != SM_OOB_SIZE);
 295         WARN_ON(buffer && ops.retlen != SM_SECTOR_SIZE);
 296 
 297         if (!buffer)
 298                 return 0;
 299 
 300         /* Test if sector marked as bad */
 301         if (!sm_sector_valid(oob)) {
 302                 dbg("read of block %d at zone %d, failed because it is marked"
 303                         " as bad" , block, zone);
 304                 goto again;
 305         }
 306 
 307         /* Test ECC*/
 308         if (mtd_is_eccerr(ret) ||
 309                 (ftl->smallpagenand && sm_correct_sector(buffer, oob))) {
 310 
 311                 dbg("read of block %d at zone %d, failed due to ECC error",
 312                         block, zone);
 313                 goto again;
 314         }
 315 
 316         return 0;
 317 }
 318 
 319 /* Writes a sector to media */
 320 static int sm_write_sector(struct sm_ftl *ftl,
 321                            int zone, int block, int boffset,
 322                            uint8_t *buffer, struct sm_oob *oob)
 323 {
 324         struct mtd_oob_ops ops;
 325         struct mtd_info *mtd = ftl->trans->mtd;
 326         int ret;
 327 
 328         BUG_ON(ftl->readonly);
 329 
 330         if (zone == 0 && (block == ftl->cis_block || block == 0)) {
 331                 dbg("attempted to write the CIS!");
 332                 return -EIO;
 333         }
 334 
 335         if (ftl->unstable)
 336                 return -EIO;
 337 
 338         ops.mode = ftl->smallpagenand ? MTD_OPS_RAW : MTD_OPS_PLACE_OOB;
 339         ops.len = SM_SECTOR_SIZE;
 340         ops.datbuf = buffer;
 341         ops.ooboffs = 0;
 342         ops.ooblen = SM_OOB_SIZE;
 343         ops.oobbuf = (void *)oob;
 344 
 345         ret = mtd_write_oob(mtd, sm_mkoffset(ftl, zone, block, boffset), &ops);
 346 
 347         /* Now we assume that hardware will catch write bitflip errors */
 348 
 349         if (ret) {
 350                 dbg("write to block %d at zone %d, failed with error %d",
 351                         block, zone, ret);
 352 
 353                 sm_recheck_media(ftl);
 354                 return ret;
 355         }
 356 
 357         /* This should never happen, unless there is a bug in the driver */
 358         WARN_ON(ops.oobretlen != SM_OOB_SIZE);
 359         WARN_ON(buffer && ops.retlen != SM_SECTOR_SIZE);
 360 
 361         return 0;
 362 }
 363 
 364 /* ------------------------ block IO ------------------------------------- */
 365 
 366 /* Write a block using data and lba, and invalid sector bitmap */
 367 static int sm_write_block(struct sm_ftl *ftl, uint8_t *buf,
 368                           int zone, int block, int lba,
 369                           unsigned long invalid_bitmap)
 370 {
 371         struct sm_oob oob;
 372         int boffset;
 373         int retry = 0;
 374 
 375         /* Initialize the oob with requested values */
 376         memset(&oob, 0xFF, SM_OOB_SIZE);
 377         sm_write_lba(&oob, lba);
 378 restart:
 379         if (ftl->unstable)
 380                 return -EIO;
 381 
 382         for (boffset = 0; boffset < ftl->block_size;
 383                                 boffset += SM_SECTOR_SIZE) {
 384 
 385                 oob.data_status = 0xFF;
 386 
 387                 if (test_bit(boffset / SM_SECTOR_SIZE, &invalid_bitmap)) {
 388 
 389                         sm_printk("sector %d of block at LBA %d of zone %d"
 390                                 " couldn't be read, marking it as invalid",
 391                                 boffset / SM_SECTOR_SIZE, lba, zone);
 392 
 393                         oob.data_status = 0;
 394                 }
 395 
 396                 if (ftl->smallpagenand) {
 397                         __nand_calculate_ecc(buf + boffset, SM_SMALL_PAGE,
 398                                         oob.ecc1,
 399                                         IS_ENABLED(CONFIG_MTD_NAND_ECC_SW_HAMMING_SMC));
 400 
 401                         __nand_calculate_ecc(buf + boffset + SM_SMALL_PAGE,
 402                                         SM_SMALL_PAGE, oob.ecc2,
 403                                         IS_ENABLED(CONFIG_MTD_NAND_ECC_SW_HAMMING_SMC));
 404                 }
 405                 if (!sm_write_sector(ftl, zone, block, boffset,
 406                                                         buf + boffset, &oob))
 407                         continue;
 408 
 409                 if (!retry) {
 410 
 411                         /* If write fails. try to erase the block */
 412                         /* This is safe, because we never write in blocks
 413                                 that contain valuable data.
 414                         This is intended to repair block that are marked
 415                         as erased, but that isn't fully erased*/
 416 
 417                         if (sm_erase_block(ftl, zone, block, 0))
 418                                 return -EIO;
 419 
 420                         retry = 1;
 421                         goto restart;
 422                 } else {
 423                         sm_mark_block_bad(ftl, zone, block);
 424                         return -EIO;
 425                 }
 426         }
 427         return 0;
 428 }
 429 
 430 
 431 /* Mark whole block at offset 'offs' as bad. */
 432 static void sm_mark_block_bad(struct sm_ftl *ftl, int zone, int block)
 433 {
 434         struct sm_oob oob;
 435         int boffset;
 436 
 437         memset(&oob, 0xFF, SM_OOB_SIZE);
 438         oob.block_status = 0xF0;
 439 
 440         if (ftl->unstable)
 441                 return;
 442 
 443         if (sm_recheck_media(ftl))
 444                 return;
 445 
 446         sm_printk("marking block %d of zone %d as bad", block, zone);
 447 
 448         /* We aren't checking the return value, because we don't care */
 449         /* This also fails on fake xD cards, but I guess these won't expose
 450                 any bad blocks till fail completely */
 451         for (boffset = 0; boffset < ftl->block_size; boffset += SM_SECTOR_SIZE)
 452                 sm_write_sector(ftl, zone, block, boffset, NULL, &oob);
 453 }
 454 
 455 /*
 456  * Erase a block within a zone
 457  * If erase succeeds, it updates free block fifo, otherwise marks block as bad
 458  */
 459 static int sm_erase_block(struct sm_ftl *ftl, int zone_num, uint16_t block,
 460                           int put_free)
 461 {
 462         struct ftl_zone *zone = &ftl->zones[zone_num];
 463         struct mtd_info *mtd = ftl->trans->mtd;
 464         struct erase_info erase;
 465 
 466         erase.addr = sm_mkoffset(ftl, zone_num, block, 0);
 467         erase.len = ftl->block_size;
 468 
 469         if (ftl->unstable)
 470                 return -EIO;
 471 
 472         BUG_ON(ftl->readonly);
 473 
 474         if (zone_num == 0 && (block == ftl->cis_block || block == 0)) {
 475                 sm_printk("attempted to erase the CIS!");
 476                 return -EIO;
 477         }
 478 
 479         if (mtd_erase(mtd, &erase)) {
 480                 sm_printk("erase of block %d in zone %d failed",
 481                                                         block, zone_num);
 482                 goto error;
 483         }
 484 
 485         if (put_free)
 486                 kfifo_in(&zone->free_sectors,
 487                         (const unsigned char *)&block, sizeof(block));
 488 
 489         return 0;
 490 error:
 491         sm_mark_block_bad(ftl, zone_num, block);
 492         return -EIO;
 493 }
 494 
 495 /* Thoroughly test that block is valid. */
 496 static int sm_check_block(struct sm_ftl *ftl, int zone, int block)
 497 {
 498         int boffset;
 499         struct sm_oob oob;
 500         int lbas[] = { -3, 0, 0, 0 };
 501         int i = 0;
 502         int test_lba;
 503 
 504 
 505         /* First just check that block doesn't look fishy */
 506         /* Only blocks that are valid or are sliced in two parts, are
 507                 accepted */
 508         for (boffset = 0; boffset < ftl->block_size;
 509                                         boffset += SM_SECTOR_SIZE) {
 510 
 511                 /* This shouldn't happen anyway */
 512                 if (sm_read_sector(ftl, zone, block, boffset, NULL, &oob))
 513                         return -2;
 514 
 515                 test_lba = sm_read_lba(&oob);
 516 
 517                 if (lbas[i] != test_lba)
 518                         lbas[++i] = test_lba;
 519 
 520                 /* If we found three different LBAs, something is fishy */
 521                 if (i == 3)
 522                         return -EIO;
 523         }
 524 
 525         /* If the block is sliced (partially erased usually) erase it */
 526         if (i == 2) {
 527                 sm_erase_block(ftl, zone, block, 1);
 528                 return 1;
 529         }
 530 
 531         return 0;
 532 }
 533 
 534 /* ----------------- media scanning --------------------------------- */
 535 static const struct chs_entry chs_table[] = {
 536         { 1,    125,  4,  4  },
 537         { 2,    125,  4,  8  },
 538         { 4,    250,  4,  8  },
 539         { 8,    250,  4,  16 },
 540         { 16,   500,  4,  16 },
 541         { 32,   500,  8,  16 },
 542         { 64,   500,  8,  32 },
 543         { 128,  500,  16, 32 },
 544         { 256,  1000, 16, 32 },
 545         { 512,  1015, 32, 63 },
 546         { 1024, 985,  33, 63 },
 547         { 2048, 985,  33, 63 },
 548         { 0 },
 549 };
 550 
 551 
 552 static const uint8_t cis_signature[] = {
 553         0x01, 0x03, 0xD9, 0x01, 0xFF, 0x18, 0x02, 0xDF, 0x01, 0x20
 554 };
 555 /* Find out media parameters.
 556  * This ideally has to be based on nand id, but for now device size is enough */
 557 static int sm_get_media_info(struct sm_ftl *ftl, struct mtd_info *mtd)
 558 {
 559         int i;
 560         int size_in_megs = mtd->size / (1024 * 1024);
 561 
 562         ftl->readonly = mtd->type == MTD_ROM;
 563 
 564         /* Manual settings for very old devices */
 565         ftl->zone_count = 1;
 566         ftl->smallpagenand = 0;
 567 
 568         switch (size_in_megs) {
 569         case 1:
 570                 /* 1 MiB flash/rom SmartMedia card (256 byte pages)*/
 571                 ftl->zone_size = 256;
 572                 ftl->max_lba = 250;
 573                 ftl->block_size = 8 * SM_SECTOR_SIZE;
 574                 ftl->smallpagenand = 1;
 575 
 576                 break;
 577         case 2:
 578                 /* 2 MiB flash SmartMedia (256 byte pages)*/
 579                 if (mtd->writesize == SM_SMALL_PAGE) {
 580                         ftl->zone_size = 512;
 581                         ftl->max_lba = 500;
 582                         ftl->block_size = 8 * SM_SECTOR_SIZE;
 583                         ftl->smallpagenand = 1;
 584                 /* 2 MiB rom SmartMedia */
 585                 } else {
 586 
 587                         if (!ftl->readonly)
 588                                 return -ENODEV;
 589 
 590                         ftl->zone_size = 256;
 591                         ftl->max_lba = 250;
 592                         ftl->block_size = 16 * SM_SECTOR_SIZE;
 593                 }
 594                 break;
 595         case 4:
 596                 /* 4 MiB flash/rom SmartMedia device */
 597                 ftl->zone_size = 512;
 598                 ftl->max_lba = 500;
 599                 ftl->block_size = 16 * SM_SECTOR_SIZE;
 600                 break;
 601         case 8:
 602                 /* 8 MiB flash/rom SmartMedia device */
 603                 ftl->zone_size = 1024;
 604                 ftl->max_lba = 1000;
 605                 ftl->block_size = 16 * SM_SECTOR_SIZE;
 606         }
 607 
 608         /* Minimum xD size is 16MiB. Also, all xD cards have standard zone
 609            sizes. SmartMedia cards exist up to 128 MiB and have same layout*/
 610         if (size_in_megs >= 16) {
 611                 ftl->zone_count = size_in_megs / 16;
 612                 ftl->zone_size = 1024;
 613                 ftl->max_lba = 1000;
 614                 ftl->block_size = 32 * SM_SECTOR_SIZE;
 615         }
 616 
 617         /* Test for proper write,erase and oob sizes */
 618         if (mtd->erasesize > ftl->block_size)
 619                 return -ENODEV;
 620 
 621         if (mtd->writesize > SM_SECTOR_SIZE)
 622                 return -ENODEV;
 623 
 624         if (ftl->smallpagenand && mtd->oobsize < SM_SMALL_OOB_SIZE)
 625                 return -ENODEV;
 626 
 627         if (!ftl->smallpagenand && mtd->oobsize < SM_OOB_SIZE)
 628                 return -ENODEV;
 629 
 630         /* We use OOB */
 631         if (!mtd_has_oob(mtd))
 632                 return -ENODEV;
 633 
 634         /* Find geometry information */
 635         for (i = 0 ; i < ARRAY_SIZE(chs_table) ; i++) {
 636                 if (chs_table[i].size == size_in_megs) {
 637                         ftl->cylinders = chs_table[i].cyl;
 638                         ftl->heads = chs_table[i].head;
 639                         ftl->sectors = chs_table[i].sec;
 640                         return 0;
 641                 }
 642         }
 643 
 644         sm_printk("media has unknown size : %dMiB", size_in_megs);
 645         ftl->cylinders = 985;
 646         ftl->heads =  33;
 647         ftl->sectors = 63;
 648         return 0;
 649 }
 650 
 651 /* Validate the CIS */
 652 static int sm_read_cis(struct sm_ftl *ftl)
 653 {
 654         struct sm_oob oob;
 655 
 656         if (sm_read_sector(ftl,
 657                 0, ftl->cis_block, ftl->cis_boffset, ftl->cis_buffer, &oob))
 658                         return -EIO;
 659 
 660         if (!sm_sector_valid(&oob) || !sm_block_valid(&oob))
 661                 return -EIO;
 662 
 663         if (!memcmp(ftl->cis_buffer + ftl->cis_page_offset,
 664                         cis_signature, sizeof(cis_signature))) {
 665                 return 0;
 666         }
 667 
 668         return -EIO;
 669 }
 670 
 671 /* Scan the media for the CIS */
 672 static int sm_find_cis(struct sm_ftl *ftl)
 673 {
 674         struct sm_oob oob;
 675         int block, boffset;
 676         int block_found = 0;
 677         int cis_found = 0;
 678 
 679         /* Search for first valid block */
 680         for (block = 0 ; block < ftl->zone_size - ftl->max_lba ; block++) {
 681 
 682                 if (sm_read_sector(ftl, 0, block, 0, NULL, &oob))
 683                         continue;
 684 
 685                 if (!sm_block_valid(&oob))
 686                         continue;
 687                 block_found = 1;
 688                 break;
 689         }
 690 
 691         if (!block_found)
 692                 return -EIO;
 693 
 694         /* Search for first valid sector in this block */
 695         for (boffset = 0 ; boffset < ftl->block_size;
 696                                                 boffset += SM_SECTOR_SIZE) {
 697 
 698                 if (sm_read_sector(ftl, 0, block, boffset, NULL, &oob))
 699                         continue;
 700 
 701                 if (!sm_sector_valid(&oob))
 702                         continue;
 703                 break;
 704         }
 705 
 706         if (boffset == ftl->block_size)
 707                 return -EIO;
 708 
 709         ftl->cis_block = block;
 710         ftl->cis_boffset = boffset;
 711         ftl->cis_page_offset = 0;
 712 
 713         cis_found = !sm_read_cis(ftl);
 714 
 715         if (!cis_found) {
 716                 ftl->cis_page_offset = SM_SMALL_PAGE;
 717                 cis_found = !sm_read_cis(ftl);
 718         }
 719 
 720         if (cis_found) {
 721                 dbg("CIS block found at offset %x",
 722                         block * ftl->block_size +
 723                                 boffset + ftl->cis_page_offset);
 724                 return 0;
 725         }
 726         return -EIO;
 727 }
 728 
 729 /* Basic test to determine if underlying mtd device if functional */
 730 static int sm_recheck_media(struct sm_ftl *ftl)
 731 {
 732         if (sm_read_cis(ftl)) {
 733 
 734                 if (!ftl->unstable) {
 735                         sm_printk("media unstable, not allowing writes");
 736                         ftl->unstable = 1;
 737                 }
 738                 return -EIO;
 739         }
 740         return 0;
 741 }
 742 
 743 /* Initialize a FTL zone */
 744 static int sm_init_zone(struct sm_ftl *ftl, int zone_num)
 745 {
 746         struct ftl_zone *zone = &ftl->zones[zone_num];
 747         struct sm_oob oob;
 748         uint16_t block;
 749         int lba;
 750         int i = 0;
 751         int len;
 752 
 753         dbg("initializing zone %d", zone_num);
 754 
 755         /* Allocate memory for FTL table */
 756         zone->lba_to_phys_table = kmalloc_array(ftl->max_lba, 2, GFP_KERNEL);
 757 
 758         if (!zone->lba_to_phys_table)
 759                 return -ENOMEM;
 760         memset(zone->lba_to_phys_table, -1, ftl->max_lba * 2);
 761 
 762 
 763         /* Allocate memory for free sectors FIFO */
 764         if (kfifo_alloc(&zone->free_sectors, ftl->zone_size * 2, GFP_KERNEL)) {
 765                 kfree(zone->lba_to_phys_table);
 766                 return -ENOMEM;
 767         }
 768 
 769         /* Now scan the zone */
 770         for (block = 0 ; block < ftl->zone_size ; block++) {
 771 
 772                 /* Skip blocks till the CIS (including) */
 773                 if (zone_num == 0 && block <= ftl->cis_block)
 774                         continue;
 775 
 776                 /* Read the oob of first sector */
 777                 if (sm_read_sector(ftl, zone_num, block, 0, NULL, &oob)) {
 778                         kfifo_free(&zone->free_sectors);
 779                         kfree(zone->lba_to_phys_table);
 780                         return -EIO;
 781                 }
 782 
 783                 /* Test to see if block is erased. It is enough to test
 784                         first sector, because erase happens in one shot */
 785                 if (sm_block_erased(&oob)) {
 786                         kfifo_in(&zone->free_sectors,
 787                                 (unsigned char *)&block, 2);
 788                         continue;
 789                 }
 790 
 791                 /* If block is marked as bad, skip it */
 792                 /* This assumes we can trust first sector*/
 793                 /* However the way the block valid status is defined, ensures
 794                         very low probability of failure here */
 795                 if (!sm_block_valid(&oob)) {
 796                         dbg("PH %04d <-> <marked bad>", block);
 797                         continue;
 798                 }
 799 
 800 
 801                 lba = sm_read_lba(&oob);
 802 
 803                 /* Invalid LBA means that block is damaged. */
 804                 /* We can try to erase it, or mark it as bad, but
 805                         lets leave that to recovery application */
 806                 if (lba == -2 || lba >= ftl->max_lba) {
 807                         dbg("PH %04d <-> LBA %04d(bad)", block, lba);
 808                         continue;
 809                 }
 810 
 811 
 812                 /* If there is no collision,
 813                         just put the sector in the FTL table */
 814                 if (zone->lba_to_phys_table[lba] < 0) {
 815                         dbg_verbose("PH %04d <-> LBA %04d", block, lba);
 816                         zone->lba_to_phys_table[lba] = block;
 817                         continue;
 818                 }
 819 
 820                 sm_printk("collision"
 821                         " of LBA %d between blocks %d and %d in zone %d",
 822                         lba, zone->lba_to_phys_table[lba], block, zone_num);
 823 
 824                 /* Test that this block is valid*/
 825                 if (sm_check_block(ftl, zone_num, block))
 826                         continue;
 827 
 828                 /* Test now the old block */
 829                 if (sm_check_block(ftl, zone_num,
 830                                         zone->lba_to_phys_table[lba])) {
 831                         zone->lba_to_phys_table[lba] = block;
 832                         continue;
 833                 }
 834 
 835                 /* If both blocks are valid and share same LBA, it means that
 836                         they hold different versions of same data. It not
 837                         known which is more recent, thus just erase one of them
 838                 */
 839                 sm_printk("both blocks are valid, erasing the later");
 840                 sm_erase_block(ftl, zone_num, block, 1);
 841         }
 842 
 843         dbg("zone initialized");
 844         zone->initialized = 1;
 845 
 846         /* No free sectors, means that the zone is heavily damaged, write won't
 847                 work, but it can still can be (partially) read */
 848         if (!kfifo_len(&zone->free_sectors)) {
 849                 sm_printk("no free blocks in zone %d", zone_num);
 850                 return 0;
 851         }
 852 
 853         /* Randomize first block we write to */
 854         get_random_bytes(&i, 2);
 855         i %= (kfifo_len(&zone->free_sectors) / 2);
 856 
 857         while (i--) {
 858                 len = kfifo_out(&zone->free_sectors,
 859                                         (unsigned char *)&block, 2);
 860                 WARN_ON(len != 2);
 861                 kfifo_in(&zone->free_sectors, (const unsigned char *)&block, 2);
 862         }
 863         return 0;
 864 }
 865 
 866 /* Get and automatically initialize an FTL mapping for one zone */
 867 static struct ftl_zone *sm_get_zone(struct sm_ftl *ftl, int zone_num)
 868 {
 869         struct ftl_zone *zone;
 870         int error;
 871 
 872         BUG_ON(zone_num >= ftl->zone_count);
 873         zone = &ftl->zones[zone_num];
 874 
 875         if (!zone->initialized) {
 876                 error = sm_init_zone(ftl, zone_num);
 877 
 878                 if (error)
 879                         return ERR_PTR(error);
 880         }
 881         return zone;
 882 }
 883 
 884 
 885 /* ----------------- cache handling ------------------------------------------*/
 886 
 887 /* Initialize the one block cache */
 888 static void sm_cache_init(struct sm_ftl *ftl)
 889 {
 890         ftl->cache_data_invalid_bitmap = 0xFFFFFFFF;
 891         ftl->cache_clean = 1;
 892         ftl->cache_zone = -1;
 893         ftl->cache_block = -1;
 894         /*memset(ftl->cache_data, 0xAA, ftl->block_size);*/
 895 }
 896 
 897 /* Put sector in one block cache */
 898 static void sm_cache_put(struct sm_ftl *ftl, char *buffer, int boffset)
 899 {
 900         memcpy(ftl->cache_data + boffset, buffer, SM_SECTOR_SIZE);
 901         clear_bit(boffset / SM_SECTOR_SIZE, &ftl->cache_data_invalid_bitmap);
 902         ftl->cache_clean = 0;
 903 }
 904 
 905 /* Read a sector from the cache */
 906 static int sm_cache_get(struct sm_ftl *ftl, char *buffer, int boffset)
 907 {
 908         if (test_bit(boffset / SM_SECTOR_SIZE,
 909                 &ftl->cache_data_invalid_bitmap))
 910                         return -1;
 911 
 912         memcpy(buffer, ftl->cache_data + boffset, SM_SECTOR_SIZE);
 913         return 0;
 914 }
 915 
 916 /* Write the cache to hardware */
 917 static int sm_cache_flush(struct sm_ftl *ftl)
 918 {
 919         struct ftl_zone *zone;
 920 
 921         int sector_num;
 922         uint16_t write_sector;
 923         int zone_num = ftl->cache_zone;
 924         int block_num;
 925 
 926         if (ftl->cache_clean)
 927                 return 0;
 928 
 929         if (ftl->unstable)
 930                 return -EIO;
 931 
 932         BUG_ON(zone_num < 0);
 933         zone = &ftl->zones[zone_num];
 934         block_num = zone->lba_to_phys_table[ftl->cache_block];
 935 
 936 
 937         /* Try to read all unread areas of the cache block*/
 938         for_each_set_bit(sector_num, &ftl->cache_data_invalid_bitmap,
 939                 ftl->block_size / SM_SECTOR_SIZE) {
 940 
 941                 if (!sm_read_sector(ftl,
 942                         zone_num, block_num, sector_num * SM_SECTOR_SIZE,
 943                         ftl->cache_data + sector_num * SM_SECTOR_SIZE, NULL))
 944                                 clear_bit(sector_num,
 945                                         &ftl->cache_data_invalid_bitmap);
 946         }
 947 restart:
 948 
 949         if (ftl->unstable)
 950                 return -EIO;
 951 
 952         /* If there are no spare blocks, */
 953         /* we could still continue by erasing/writing the current block,
 954                 but for such worn out media it doesn't worth the trouble,
 955                         and the dangers */
 956         if (kfifo_out(&zone->free_sectors,
 957                                 (unsigned char *)&write_sector, 2) != 2) {
 958                 dbg("no free sectors for write!");
 959                 return -EIO;
 960         }
 961 
 962 
 963         if (sm_write_block(ftl, ftl->cache_data, zone_num, write_sector,
 964                 ftl->cache_block, ftl->cache_data_invalid_bitmap))
 965                         goto restart;
 966 
 967         /* Update the FTL table */
 968         zone->lba_to_phys_table[ftl->cache_block] = write_sector;
 969 
 970         /* Write succesfull, so erase and free the old block */
 971         if (block_num > 0)
 972                 sm_erase_block(ftl, zone_num, block_num, 1);
 973 
 974         sm_cache_init(ftl);
 975         return 0;
 976 }
 977 
 978 
 979 /* flush timer, runs a second after last write */
 980 static void sm_cache_flush_timer(struct timer_list *t)
 981 {
 982         struct sm_ftl *ftl = from_timer(ftl, t, timer);
 983         queue_work(cache_flush_workqueue, &ftl->flush_work);
 984 }
 985 
 986 /* cache flush work, kicked by timer */
 987 static void sm_cache_flush_work(struct work_struct *work)
 988 {
 989         struct sm_ftl *ftl = container_of(work, struct sm_ftl, flush_work);
 990         mutex_lock(&ftl->mutex);
 991         sm_cache_flush(ftl);
 992         mutex_unlock(&ftl->mutex);
 993         return;
 994 }
 995 
 996 /* ---------------- outside interface -------------------------------------- */
 997 
 998 /* outside interface: read a sector */
 999 static int sm_read(struct mtd_blktrans_dev *dev,
1000                    unsigned long sect_no, char *buf)
1001 {
1002         struct sm_ftl *ftl = dev->priv;
1003         struct ftl_zone *zone;
1004         int error = 0, in_cache = 0;
1005         int zone_num, block, boffset;
1006 
1007         sm_break_offset(ftl, sect_no << 9, &zone_num, &block, &boffset);
1008         mutex_lock(&ftl->mutex);
1009 
1010 
1011         zone = sm_get_zone(ftl, zone_num);
1012         if (IS_ERR(zone)) {
1013                 error = PTR_ERR(zone);
1014                 goto unlock;
1015         }
1016 
1017         /* Have to look at cache first */
1018         if (ftl->cache_zone == zone_num && ftl->cache_block == block) {
1019                 in_cache = 1;
1020                 if (!sm_cache_get(ftl, buf, boffset))
1021                         goto unlock;
1022         }
1023 
1024         /* Translate the block and return if doesn't exist in the table */
1025         block = zone->lba_to_phys_table[block];
1026 
1027         if (block == -1) {
1028                 memset(buf, 0xFF, SM_SECTOR_SIZE);
1029                 goto unlock;
1030         }
1031 
1032         if (sm_read_sector(ftl, zone_num, block, boffset, buf, NULL)) {
1033                 error = -EIO;
1034                 goto unlock;
1035         }
1036 
1037         if (in_cache)
1038                 sm_cache_put(ftl, buf, boffset);
1039 unlock:
1040         mutex_unlock(&ftl->mutex);
1041         return error;
1042 }
1043 
1044 /* outside interface: write a sector */
1045 static int sm_write(struct mtd_blktrans_dev *dev,
1046                                 unsigned long sec_no, char *buf)
1047 {
1048         struct sm_ftl *ftl = dev->priv;
1049         struct ftl_zone *zone;
1050         int error = 0, zone_num, block, boffset;
1051 
1052         BUG_ON(ftl->readonly);
1053         sm_break_offset(ftl, sec_no << 9, &zone_num, &block, &boffset);
1054 
1055         /* No need in flush thread running now */
1056         del_timer(&ftl->timer);
1057         mutex_lock(&ftl->mutex);
1058 
1059         zone = sm_get_zone(ftl, zone_num);
1060         if (IS_ERR(zone)) {
1061                 error = PTR_ERR(zone);
1062                 goto unlock;
1063         }
1064 
1065         /* If entry is not in cache, flush it */
1066         if (ftl->cache_block != block || ftl->cache_zone != zone_num) {
1067 
1068                 error = sm_cache_flush(ftl);
1069                 if (error)
1070                         goto unlock;
1071 
1072                 ftl->cache_block = block;
1073                 ftl->cache_zone = zone_num;
1074         }
1075 
1076         sm_cache_put(ftl, buf, boffset);
1077 unlock:
1078         mod_timer(&ftl->timer, jiffies + msecs_to_jiffies(cache_timeout));
1079         mutex_unlock(&ftl->mutex);
1080         return error;
1081 }
1082 
1083 /* outside interface: flush everything */
1084 static int sm_flush(struct mtd_blktrans_dev *dev)
1085 {
1086         struct sm_ftl *ftl = dev->priv;
1087         int retval;
1088 
1089         mutex_lock(&ftl->mutex);
1090         retval =  sm_cache_flush(ftl);
1091         mutex_unlock(&ftl->mutex);
1092         return retval;
1093 }
1094 
1095 /* outside interface: device is released */
1096 static void sm_release(struct mtd_blktrans_dev *dev)
1097 {
1098         struct sm_ftl *ftl = dev->priv;
1099 
1100         mutex_lock(&ftl->mutex);
1101         del_timer_sync(&ftl->timer);
1102         cancel_work_sync(&ftl->flush_work);
1103         sm_cache_flush(ftl);
1104         mutex_unlock(&ftl->mutex);
1105 }
1106 
1107 /* outside interface: get geometry */
1108 static int sm_getgeo(struct mtd_blktrans_dev *dev, struct hd_geometry *geo)
1109 {
1110         struct sm_ftl *ftl = dev->priv;
1111         geo->heads = ftl->heads;
1112         geo->sectors = ftl->sectors;
1113         geo->cylinders = ftl->cylinders;
1114         return 0;
1115 }
1116 
1117 /* external interface: main initialization function */
1118 static void sm_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd)
1119 {
1120         struct mtd_blktrans_dev *trans;
1121         struct sm_ftl *ftl;
1122 
1123         /* Allocate & initialize our private structure */
1124         ftl = kzalloc(sizeof(struct sm_ftl), GFP_KERNEL);
1125         if (!ftl)
1126                 goto error1;
1127 
1128 
1129         mutex_init(&ftl->mutex);
1130         timer_setup(&ftl->timer, sm_cache_flush_timer, 0);
1131         INIT_WORK(&ftl->flush_work, sm_cache_flush_work);
1132 
1133         /* Read media information */
1134         if (sm_get_media_info(ftl, mtd)) {
1135                 dbg("found unsupported mtd device, aborting");
1136                 goto error2;
1137         }
1138 
1139 
1140         /* Allocate temporary CIS buffer for read retry support */
1141         ftl->cis_buffer = kzalloc(SM_SECTOR_SIZE, GFP_KERNEL);
1142         if (!ftl->cis_buffer)
1143                 goto error2;
1144 
1145         /* Allocate zone array, it will be initialized on demand */
1146         ftl->zones = kcalloc(ftl->zone_count, sizeof(struct ftl_zone),
1147                                                                 GFP_KERNEL);
1148         if (!ftl->zones)
1149                 goto error3;
1150 
1151         /* Allocate the cache*/
1152         ftl->cache_data = kzalloc(ftl->block_size, GFP_KERNEL);
1153 
1154         if (!ftl->cache_data)
1155                 goto error4;
1156 
1157         sm_cache_init(ftl);
1158 
1159 
1160         /* Allocate upper layer structure and initialize it */
1161         trans = kzalloc(sizeof(struct mtd_blktrans_dev), GFP_KERNEL);
1162         if (!trans)
1163                 goto error5;
1164 
1165         ftl->trans = trans;
1166         trans->priv = ftl;
1167 
1168         trans->tr = tr;
1169         trans->mtd = mtd;
1170         trans->devnum = -1;
1171         trans->size = (ftl->block_size * ftl->max_lba * ftl->zone_count) >> 9;
1172         trans->readonly = ftl->readonly;
1173 
1174         if (sm_find_cis(ftl)) {
1175                 dbg("CIS not found on mtd device, aborting");
1176                 goto error6;
1177         }
1178 
1179         ftl->disk_attributes = sm_create_sysfs_attributes(ftl);
1180         if (!ftl->disk_attributes)
1181                 goto error6;
1182         trans->disk_attributes = ftl->disk_attributes;
1183 
1184         sm_printk("Found %d MiB xD/SmartMedia FTL on mtd%d",
1185                 (int)(mtd->size / (1024 * 1024)), mtd->index);
1186 
1187         dbg("FTL layout:");
1188         dbg("%d zone(s), each consists of %d blocks (+%d spares)",
1189                 ftl->zone_count, ftl->max_lba,
1190                 ftl->zone_size - ftl->max_lba);
1191         dbg("each block consists of %d bytes",
1192                 ftl->block_size);
1193 
1194 
1195         /* Register device*/
1196         if (add_mtd_blktrans_dev(trans)) {
1197                 dbg("error in mtdblktrans layer");
1198                 goto error6;
1199         }
1200         return;
1201 error6:
1202         kfree(trans);
1203 error5:
1204         kfree(ftl->cache_data);
1205 error4:
1206         kfree(ftl->zones);
1207 error3:
1208         kfree(ftl->cis_buffer);
1209 error2:
1210         kfree(ftl);
1211 error1:
1212         return;
1213 }
1214 
1215 /* main interface: device {surprise,} removal */
1216 static void sm_remove_dev(struct mtd_blktrans_dev *dev)
1217 {
1218         struct sm_ftl *ftl = dev->priv;
1219         int i;
1220 
1221         del_mtd_blktrans_dev(dev);
1222         ftl->trans = NULL;
1223 
1224         for (i = 0 ; i < ftl->zone_count; i++) {
1225 
1226                 if (!ftl->zones[i].initialized)
1227                         continue;
1228 
1229                 kfree(ftl->zones[i].lba_to_phys_table);
1230                 kfifo_free(&ftl->zones[i].free_sectors);
1231         }
1232 
1233         sm_delete_sysfs_attributes(ftl);
1234         kfree(ftl->cis_buffer);
1235         kfree(ftl->zones);
1236         kfree(ftl->cache_data);
1237         kfree(ftl);
1238 }
1239 
1240 static struct mtd_blktrans_ops sm_ftl_ops = {
1241         .name           = "smblk",
1242         .major          = 0,
1243         .part_bits      = SM_FTL_PARTN_BITS,
1244         .blksize        = SM_SECTOR_SIZE,
1245         .getgeo         = sm_getgeo,
1246 
1247         .add_mtd        = sm_add_mtd,
1248         .remove_dev     = sm_remove_dev,
1249 
1250         .readsect       = sm_read,
1251         .writesect      = sm_write,
1252 
1253         .flush          = sm_flush,
1254         .release        = sm_release,
1255 
1256         .owner          = THIS_MODULE,
1257 };
1258 
1259 static __init int sm_module_init(void)
1260 {
1261         int error = 0;
1262 
1263         cache_flush_workqueue = create_freezable_workqueue("smflush");
1264         if (!cache_flush_workqueue)
1265                 return -ENOMEM;
1266 
1267         error = register_mtd_blktrans(&sm_ftl_ops);
1268         if (error)
1269                 destroy_workqueue(cache_flush_workqueue);
1270         return error;
1271 
1272 }
1273 
1274 static void __exit sm_module_exit(void)
1275 {
1276         destroy_workqueue(cache_flush_workqueue);
1277         deregister_mtd_blktrans(&sm_ftl_ops);
1278 }
1279 
1280 module_init(sm_module_init);
1281 module_exit(sm_module_exit);
1282 
1283 MODULE_LICENSE("GPL");
1284 MODULE_AUTHOR("Maxim Levitsky <maximlevitsky@gmail.com>");
1285 MODULE_DESCRIPTION("Smartmedia/xD mtd translation layer");
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/mtd/sm_ftl.c

DEFINITIONS
