drivers/mtd/sm_ftl.c

   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                         return -EIO;
 779
 780                 /* Test to see if block is erased. It is enough to test
 781                         first sector, because erase happens in one shot */
 782                 if (sm_block_erased(&oob)) {
 783                         kfifo_in(&zone->free_sectors,
 784                                 (unsigned char *)&block, 2);
 785                         continue;
 786                 }
 787
 788                 /* If block is marked as bad, skip it */
 789                 /* This assumes we can trust first sector*/
 790                 /* However the way the block valid status is defined, ensures
 791                         very low probability of failure here */
 792                 if (!sm_block_valid(&oob)) {
 793                         dbg("PH %04d <-> <marked bad>", block);
 794                         continue;
 795                 }
 796
 797
 798                 lba = sm_read_lba(&oob);
 799
 800                 /* Invalid LBA means that block is damaged. */
 801                 /* We can try to erase it, or mark it as bad, but
 802                         lets leave that to recovery application */
 803                 if (lba == -2 || lba >= ftl->max_lba) {
 804                         dbg("PH %04d <-> LBA %04d(bad)", block, lba);
 805                         continue;
 806                 }
 807
 808
 809                 /* If there is no collision,
 810                         just put the sector in the FTL table */
 811                 if (zone->lba_to_phys_table[lba] < 0) {
 812                         dbg_verbose("PH %04d <-> LBA %04d", block, lba);
 813                         zone->lba_to_phys_table[lba] = block;
 814                         continue;
 815                 }
 816
 817                 sm_printk("collision"
 818                         " of LBA %d between blocks %d and %d in zone %d",
 819                         lba, zone->lba_to_phys_table[lba], block, zone_num);
 820
 821                 /* Test that this block is valid*/
 822                 if (sm_check_block(ftl, zone_num, block))
 823                         continue;
 824
 825                 /* Test now the old block */
 826                 if (sm_check_block(ftl, zone_num,
 827                                         zone->lba_to_phys_table[lba])) {
 828                         zone->lba_to_phys_table[lba] = block;
 829                         continue;
 830                 }
 831
 832                 /* If both blocks are valid and share same LBA, it means that
 833                         they hold different versions of same data. It not
 834                         known which is more recent, thus just erase one of them
 835                 */
 836                 sm_printk("both blocks are valid, erasing the later");
 837                 sm_erase_block(ftl, zone_num, block, 1);
 838         }
 839
 840         dbg("zone initialized");
 841         zone->initialized = 1;
 842
 843         /* No free sectors, means that the zone is heavily damaged, write won't
 844                 work, but it can still can be (partially) read */
 845         if (!kfifo_len(&zone->free_sectors)) {
 846                 sm_printk("no free blocks in zone %d", zone_num);
 847                 return 0;
 848         }
 849
 850         /* Randomize first block we write to */
 851         get_random_bytes(&i, 2);
 852         i %= (kfifo_len(&zone->free_sectors) / 2);
 853
 854         while (i--) {
 855                 len = kfifo_out(&zone->free_sectors,
 856                                         (unsigned char *)&block, 2);
 857                 WARN_ON(len != 2);
 858                 kfifo_in(&zone->free_sectors, (const unsigned char *)&block, 2);
 859         }
 860         return 0;
 861 }
 862
 863 /* Get and automatically initialize an FTL mapping for one zone */
 864 static struct ftl_zone *sm_get_zone(struct sm_ftl *ftl, int zone_num)
 865 {
 866         struct ftl_zone *zone;
 867         int error;
 868
 869         BUG_ON(zone_num >= ftl->zone_count);
 870         zone = &ftl->zones[zone_num];
 871
 872         if (!zone->initialized) {
 873                 error = sm_init_zone(ftl, zone_num);
 874
 875                 if (error)
 876                         return ERR_PTR(error);
 877         }
 878         return zone;
 879 }
 880
 881
 882 /* ----------------- cache handling ------------------------------------------*/
 883
 884 /* Initialize the one block cache */
 885 static void sm_cache_init(struct sm_ftl *ftl)
 886 {
 887         ftl->cache_data_invalid_bitmap = 0xFFFFFFFF;
 888         ftl->cache_clean = 1;
 889         ftl->cache_zone = -1;
 890         ftl->cache_block = -1;
 891         /*memset(ftl->cache_data, 0xAA, ftl->block_size);*/
 892 }
 893
 894 /* Put sector in one block cache */
 895 static void sm_cache_put(struct sm_ftl *ftl, char *buffer, int boffset)
 896 {
 897         memcpy(ftl->cache_data + boffset, buffer, SM_SECTOR_SIZE);
 898         clear_bit(boffset / SM_SECTOR_SIZE, &ftl->cache_data_invalid_bitmap);
 899         ftl->cache_clean = 0;
 900 }
 901
 902 /* Read a sector from the cache */
 903 static int sm_cache_get(struct sm_ftl *ftl, char *buffer, int boffset)
 904 {
 905         if (test_bit(boffset / SM_SECTOR_SIZE,
 906                 &ftl->cache_data_invalid_bitmap))
 907                         return -1;
 908
 909         memcpy(buffer, ftl->cache_data + boffset, SM_SECTOR_SIZE);
 910         return 0;
 911 }
 912
 913 /* Write the cache to hardware */
 914 static int sm_cache_flush(struct sm_ftl *ftl)
 915 {
 916         struct ftl_zone *zone;
 917
 918         int sector_num;
 919         uint16_t write_sector;
 920         int zone_num = ftl->cache_zone;
 921         int block_num;
 922
 923         if (ftl->cache_clean)
 924                 return 0;
 925
 926         if (ftl->unstable)
 927                 return -EIO;
 928
 929         BUG_ON(zone_num < 0);
 930         zone = &ftl->zones[zone_num];
 931         block_num = zone->lba_to_phys_table[ftl->cache_block];
 932
 933
 934         /* Try to read all unread areas of the cache block*/
 935         for_each_set_bit(sector_num, &ftl->cache_data_invalid_bitmap,
 936                 ftl->block_size / SM_SECTOR_SIZE) {
 937
 938                 if (!sm_read_sector(ftl,
 939                         zone_num, block_num, sector_num * SM_SECTOR_SIZE,
 940                         ftl->cache_data + sector_num * SM_SECTOR_SIZE, NULL))
 941                                 clear_bit(sector_num,
 942                                         &ftl->cache_data_invalid_bitmap);
 943         }
 944 restart:
 945
 946         if (ftl->unstable)
 947                 return -EIO;
 948
 949         /* If there are no spare blocks, */
 950         /* we could still continue by erasing/writing the current block,
 951                 but for such worn out media it doesn't worth the trouble,
 952                         and the dangers */
 953         if (kfifo_out(&zone->free_sectors,
 954                                 (unsigned char *)&write_sector, 2) != 2) {
 955                 dbg("no free sectors for write!");
 956                 return -EIO;
 957         }
 958
 959
 960         if (sm_write_block(ftl, ftl->cache_data, zone_num, write_sector,
 961                 ftl->cache_block, ftl->cache_data_invalid_bitmap))
 962                         goto restart;
 963
 964         /* Update the FTL table */
 965         zone->lba_to_phys_table[ftl->cache_block] = write_sector;
 966
 967         /* Write succesfull, so erase and free the old block */
 968         if (block_num > 0)
 969                 sm_erase_block(ftl, zone_num, block_num, 1);
 970
 971         sm_cache_init(ftl);
 972         return 0;
 973 }
 974
 975
 976 /* flush timer, runs a second after last write */
 977 static void sm_cache_flush_timer(struct timer_list *t)
 978 {
 979         struct sm_ftl *ftl = from_timer(ftl, t, timer);
 980         queue_work(cache_flush_workqueue, &ftl->flush_work);
 981 }
 982
 983 /* cache flush work, kicked by timer */
 984 static void sm_cache_flush_work(struct work_struct *work)
 985 {
 986         struct sm_ftl *ftl = container_of(work, struct sm_ftl, flush_work);
 987         mutex_lock(&ftl->mutex);
 988         sm_cache_flush(ftl);
 989         mutex_unlock(&ftl->mutex);
 990         return;
 991 }
 992
 993 /* ---------------- outside interface -------------------------------------- */
 994
 995 /* outside interface: read a sector */
 996 static int sm_read(struct mtd_blktrans_dev *dev,
 997                    unsigned long sect_no, char *buf)
 998 {
 999         struct sm_ftl *ftl = dev->priv;
1000         struct ftl_zone *zone;
1001         int error = 0, in_cache = 0;
1002         int zone_num, block, boffset;
1003
1004         sm_break_offset(ftl, sect_no << 9, &zone_num, &block, &boffset);
1005         mutex_lock(&ftl->mutex);
1006
1007
1008         zone = sm_get_zone(ftl, zone_num);
1009         if (IS_ERR(zone)) {
1010                 error = PTR_ERR(zone);
1011                 goto unlock;
1012         }
1013
1014         /* Have to look at cache first */
1015         if (ftl->cache_zone == zone_num && ftl->cache_block == block) {
1016                 in_cache = 1;
1017                 if (!sm_cache_get(ftl, buf, boffset))
1018                         goto unlock;
1019         }
1020
1021         /* Translate the block and return if doesn't exist in the table */
1022         block = zone->lba_to_phys_table[block];
1023
1024         if (block == -1) {
1025                 memset(buf, 0xFF, SM_SECTOR_SIZE);
1026                 goto unlock;
1027         }
1028
1029         if (sm_read_sector(ftl, zone_num, block, boffset, buf, NULL)) {
1030                 error = -EIO;
1031                 goto unlock;
1032         }
1033
1034         if (in_cache)
1035                 sm_cache_put(ftl, buf, boffset);
1036 unlock:
1037         mutex_unlock(&ftl->mutex);
1038         return error;
1039 }
1040
1041 /* outside interface: write a sector */
1042 static int sm_write(struct mtd_blktrans_dev *dev,
1043                                 unsigned long sec_no, char *buf)
1044 {
1045         struct sm_ftl *ftl = dev->priv;
1046         struct ftl_zone *zone;
1047         int error = 0, zone_num, block, boffset;
1048
1049         BUG_ON(ftl->readonly);
1050         sm_break_offset(ftl, sec_no << 9, &zone_num, &block, &boffset);
1051
1052         /* No need in flush thread running now */
1053         del_timer(&ftl->timer);
1054         mutex_lock(&ftl->mutex);
1055
1056         zone = sm_get_zone(ftl, zone_num);
1057         if (IS_ERR(zone)) {
1058                 error = PTR_ERR(zone);
1059                 goto unlock;
1060         }
1061
1062         /* If entry is not in cache, flush it */
1063         if (ftl->cache_block != block || ftl->cache_zone != zone_num) {
1064
1065                 error = sm_cache_flush(ftl);
1066                 if (error)
1067                         goto unlock;
1068
1069                 ftl->cache_block = block;
1070                 ftl->cache_zone = zone_num;
1071         }
1072
1073         sm_cache_put(ftl, buf, boffset);
1074 unlock:
1075         mod_timer(&ftl->timer, jiffies + msecs_to_jiffies(cache_timeout));
1076         mutex_unlock(&ftl->mutex);
1077         return error;
1078 }
1079
1080 /* outside interface: flush everything */
1081 static int sm_flush(struct mtd_blktrans_dev *dev)
1082 {
1083         struct sm_ftl *ftl = dev->priv;
1084         int retval;
1085
1086         mutex_lock(&ftl->mutex);
1087         retval =  sm_cache_flush(ftl);
1088         mutex_unlock(&ftl->mutex);
1089         return retval;
1090 }
1091
1092 /* outside interface: device is released */
1093 static void sm_release(struct mtd_blktrans_dev *dev)
1094 {
1095         struct sm_ftl *ftl = dev->priv;
1096
1097         mutex_lock(&ftl->mutex);
1098         del_timer_sync(&ftl->timer);
1099         cancel_work_sync(&ftl->flush_work);
1100         sm_cache_flush(ftl);
1101         mutex_unlock(&ftl->mutex);
1102 }
1103
1104 /* outside interface: get geometry */
1105 static int sm_getgeo(struct mtd_blktrans_dev *dev, struct hd_geometry *geo)
1106 {
1107         struct sm_ftl *ftl = dev->priv;
1108         geo->heads = ftl->heads;
1109         geo->sectors = ftl->sectors;
1110         geo->cylinders = ftl->cylinders;
1111         return 0;
1112 }
1113
1114 /* external interface: main initialization function */
1115 static void sm_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd)
1116 {
1117         struct mtd_blktrans_dev *trans;
1118         struct sm_ftl *ftl;
1119
1120         /* Allocate & initialize our private structure */
1121         ftl = kzalloc(sizeof(struct sm_ftl), GFP_KERNEL);
1122         if (!ftl)
1123                 goto error1;
1124
1125
1126         mutex_init(&ftl->mutex);
1127         timer_setup(&ftl->timer, sm_cache_flush_timer, 0);
1128         INIT_WORK(&ftl->flush_work, sm_cache_flush_work);
1129
1130         /* Read media information */
1131         if (sm_get_media_info(ftl, mtd)) {
1132                 dbg("found unsupported mtd device, aborting");
1133                 goto error2;
1134         }
1135
1136
1137         /* Allocate temporary CIS buffer for read retry support */
1138         ftl->cis_buffer = kzalloc(SM_SECTOR_SIZE, GFP_KERNEL);
1139         if (!ftl->cis_buffer)
1140                 goto error2;
1141
1142         /* Allocate zone array, it will be initialized on demand */
1143         ftl->zones = kcalloc(ftl->zone_count, sizeof(struct ftl_zone),
1144                                                                 GFP_KERNEL);
1145         if (!ftl->zones)
1146                 goto error3;
1147
1148         /* Allocate the cache*/
1149         ftl->cache_data = kzalloc(ftl->block_size, GFP_KERNEL);
1150
1151         if (!ftl->cache_data)
1152                 goto error4;
1153
1154         sm_cache_init(ftl);
1155
1156
1157         /* Allocate upper layer structure and initialize it */
1158         trans = kzalloc(sizeof(struct mtd_blktrans_dev), GFP_KERNEL);
1159         if (!trans)
1160                 goto error5;
1161
1162         ftl->trans = trans;
1163         trans->priv = ftl;
1164
1165         trans->tr = tr;
1166         trans->mtd = mtd;
1167         trans->devnum = -1;
1168         trans->size = (ftl->block_size * ftl->max_lba * ftl->zone_count) >> 9;
1169         trans->readonly = ftl->readonly;
1170
1171         if (sm_find_cis(ftl)) {
1172                 dbg("CIS not found on mtd device, aborting");
1173                 goto error6;
1174         }
1175
1176         ftl->disk_attributes = sm_create_sysfs_attributes(ftl);
1177         if (!ftl->disk_attributes)
1178                 goto error6;
1179         trans->disk_attributes = ftl->disk_attributes;
1180
1181         sm_printk("Found %d MiB xD/SmartMedia FTL on mtd%d",
1182                 (int)(mtd->size / (1024 * 1024)), mtd->index);
1183
1184         dbg("FTL layout:");
1185         dbg("%d zone(s), each consists of %d blocks (+%d spares)",
1186                 ftl->zone_count, ftl->max_lba,
1187                 ftl->zone_size - ftl->max_lba);
1188         dbg("each block consists of %d bytes",
1189                 ftl->block_size);
1190
1191
1192         /* Register device*/
1193         if (add_mtd_blktrans_dev(trans)) {
1194                 dbg("error in mtdblktrans layer");
1195                 goto error6;
1196         }
1197         return;
1198 error6:
1199         kfree(trans);
1200 error5:
1201         kfree(ftl->cache_data);
1202 error4:
1203         kfree(ftl->zones);
1204 error3:
1205         kfree(ftl->cis_buffer);
1206 error2:
1207         kfree(ftl);
1208 error1:
1209         return;
1210 }
1211
1212 /* main interface: device {surprise,} removal */
1213 static void sm_remove_dev(struct mtd_blktrans_dev *dev)
1214 {
1215         struct sm_ftl *ftl = dev->priv;
1216         int i;
1217
1218         del_mtd_blktrans_dev(dev);
1219         ftl->trans = NULL;
1220
1221         for (i = 0 ; i < ftl->zone_count; i++) {
1222
1223                 if (!ftl->zones[i].initialized)
1224                         continue;
1225
1226                 kfree(ftl->zones[i].lba_to_phys_table);
1227                 kfifo_free(&ftl->zones[i].free_sectors);
1228         }
1229
1230         sm_delete_sysfs_attributes(ftl);
1231         kfree(ftl->cis_buffer);
1232         kfree(ftl->zones);
1233         kfree(ftl->cache_data);
1234         kfree(ftl);
1235 }
1236
1237 static struct mtd_blktrans_ops sm_ftl_ops = {
1238         .name           = "smblk",
1239         .major          = 0,
1240         .part_bits      = SM_FTL_PARTN_BITS,
1241         .blksize        = SM_SECTOR_SIZE,
1242         .getgeo         = sm_getgeo,
1243
1244         .add_mtd        = sm_add_mtd,
1245         .remove_dev     = sm_remove_dev,
1246
1247         .readsect       = sm_read,
1248         .writesect      = sm_write,
1249
1250         .flush          = sm_flush,
1251         .release        = sm_release,
1252
1253         .owner          = THIS_MODULE,
1254 };
1255
1256 static __init int sm_module_init(void)
1257 {
1258         int error = 0;
1259
1260         cache_flush_workqueue = create_freezable_workqueue("smflush");
1261         if (!cache_flush_workqueue)
1262                 return -ENOMEM;
1263
1264         error = register_mtd_blktrans(&sm_ftl_ops);
1265         if (error)
1266                 destroy_workqueue(cache_flush_workqueue);
1267         return error;
1268
1269 }
1270
1271 static void __exit sm_module_exit(void)
1272 {
1273         destroy_workqueue(cache_flush_workqueue);
1274         deregister_mtd_blktrans(&sm_ftl_ops);
1275 }
1276
1277 module_init(sm_module_init);
1278 module_exit(sm_module_exit);
1279
1280 MODULE_LICENSE("GPL");
1281 MODULE_AUTHOR("Maxim Levitsky <maximlevitsky@gmail.com>");
1282 MODULE_DESCRIPTION("Smartmedia/xD mtd translation layer");