drivers/mtd/sm_ftl.c

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