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