drivers/mtd/ftl.c

   1 /* This version ported to the Linux-MTD system by dwmw2@infradead.org
   2  *
   3  * Fixes: Arnaldo Carvalho de Melo <acme@conectiva.com.br>
   4  * - fixes some leaks on failure in build_maps and ftl_notify_add, cleanups
   5  *
   6  * Based on:
   7  */
   8 /*======================================================================
   9
  10     A Flash Translation Layer memory card driver
  11
  12     This driver implements a disk-like block device driver with an
  13     apparent block size of 512 bytes for flash memory cards.
  14
  15     ftl_cs.c 1.62 2000/02/01 00:59:04
  16
  17     The contents of this file are subject to the Mozilla Public
  18     License Version 1.1 (the "License"); you may not use this file
  19     except in compliance with the License. You may obtain a copy of
  20     the License at http://www.mozilla.org/MPL/
  21
  22     Software distributed under the License is distributed on an "AS
  23     IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  24     implied. See the License for the specific language governing
  25     rights and limitations under the License.
  26
  27     The initial developer of the original code is David A. Hinds
  28     <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
  29     are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
  30
  31     Alternatively, the contents of this file may be used under the
  32     terms of the GNU General Public License version 2 (the "GPL"), in
  33     which case the provisions of the GPL are applicable instead of the
  34     above.  If you wish to allow the use of your version of this file
  35     only under the terms of the GPL and not to allow others to use
  36     your version of this file under the MPL, indicate your decision
  37     by deleting the provisions above and replace them with the notice
  38     and other provisions required by the GPL.  If you do not delete
  39     the provisions above, a recipient may use your version of this
  40     file under either the MPL or the GPL.
  41
  42     LEGAL NOTE: The FTL format is patented by M-Systems.  They have
  43     granted a license for its use with PCMCIA devices:
  44
  45      "M-Systems grants a royalty-free, non-exclusive license under
  46       any presently existing M-Systems intellectual property rights
  47       necessary for the design and development of FTL-compatible
  48       drivers, file systems and utilities using the data formats with
  49       PCMCIA PC Cards as described in the PCMCIA Flash Translation
  50       Layer (FTL) Specification."
  51
  52     Use of the FTL format for non-PCMCIA applications may be an
  53     infringement of these patents.  For additional information,
  54     contact M-Systems (http://www.m-sys.com) directly.
  55
  56 ======================================================================*/
  57 #include <linux/mtd/blktrans.h>
  58 #include <linux/module.h>
  59 #include <linux/mtd/mtd.h>
  60 /*#define PSYCHO_DEBUG */
  61
  62 #include <linux/kernel.h>
  63 #include <linux/ptrace.h>
  64 #include <linux/slab.h>
  65 #include <linux/string.h>
  66 #include <linux/timer.h>
  67 #include <linux/major.h>
  68 #include <linux/fs.h>
  69 #include <linux/init.h>
  70 #include <linux/hdreg.h>
  71 #include <linux/vmalloc.h>
  72 #include <linux/blkpg.h>
  73 #include <asm/uaccess.h>
  74
  75 #include <linux/mtd/ftl.h>
  76
  77 /*====================================================================*/
  78
  79 /* Parameters that can be set with 'insmod' */
  80 static int shuffle_freq = 50;
  81 module_param(shuffle_freq, int, 0);
  82
  83 /*====================================================================*/
  84
  85 /* Major device # for FTL device */
  86 #ifndef FTL_MAJOR
  87 #define FTL_MAJOR       44
  88 #endif
  89
  90
  91 /*====================================================================*/
  92
  93 /* Maximum number of separate memory devices we'll allow */
  94 #define MAX_DEV         4
  95
  96 /* Maximum number of regions per device */
  97 #define MAX_REGION      4
  98
  99 /* Maximum number of partitions in an FTL region */
 100 #define PART_BITS       4
 101
 102 /* Maximum number of outstanding erase requests per socket */
 103 #define MAX_ERASE       8
 104
 105 /* Sector size -- shouldn't need to change */
 106 #define SECTOR_SIZE     512
 107
 108
 109 /* Each memory region corresponds to a minor device */
 110 typedef struct partition_t {
 111     struct mtd_blktrans_dev mbd;
 112     uint32_t            state;
 113     uint32_t            *VirtualBlockMap;
 114     uint32_t            *VirtualPageMap;
 115     uint32_t            FreeTotal;
 116     struct eun_info_t {
 117         uint32_t                Offset;
 118         uint32_t                EraseCount;
 119         uint32_t                Free;
 120         uint32_t                Deleted;
 121     } *EUNInfo;
 122     struct xfer_info_t {
 123         uint32_t                Offset;
 124         uint32_t                EraseCount;
 125         uint16_t                state;
 126     } *XferInfo;
 127     uint16_t            bam_index;
 128     uint32_t            *bam_cache;
 129     uint16_t            DataUnits;
 130     uint32_t            BlocksPerUnit;
 131     erase_unit_header_t header;
 132 } partition_t;
 133
 134 /* Partition state flags */
 135 #define FTL_FORMATTED   0x01
 136
 137 /* Transfer unit states */
 138 #define XFER_UNKNOWN    0x00
 139 #define XFER_ERASING    0x01
 140 #define XFER_ERASED     0x02
 141 #define XFER_PREPARED   0x03
 142 #define XFER_FAILED     0x04
 143
 144 /*====================================================================*/
 145
 146
 147 static void ftl_erase_callback(struct erase_info *done);
 148
 149
 150 /*======================================================================
 151
 152     Scan_header() checks to see if a memory region contains an FTL
 153     partition.  build_maps() reads all the erase unit headers, builds
 154     the erase unit map, and then builds the virtual page map.
 155
 156 ======================================================================*/
 157
 158 static int scan_header(partition_t *part)
 159 {
 160     erase_unit_header_t header;
 161     loff_t offset, max_offset;
 162     size_t ret;
 163     int err;
 164     part->header.FormattedSize = 0;
 165     max_offset = (0x100000<part->mbd.mtd->size)?0x100000:part->mbd.mtd->size;
 166     /* Search first megabyte for a valid FTL header */
 167     for (offset = 0;
 168          (offset + sizeof(header)) < max_offset;
 169          offset += part->mbd.mtd->erasesize ? : 0x2000) {
 170
 171         err = part->mbd.mtd->read(part->mbd.mtd, offset, sizeof(header), &ret,
 172                               (unsigned char *)&header);
 173
 174         if (err)
 175             return err;
 176
 177         if (strcmp(header.DataOrgTuple+3, "FTL100") == 0) break;
 178     }
 179
 180     if (offset == max_offset) {
 181         printk(KERN_NOTICE "ftl_cs: FTL header not found.\n");
 182         return -ENOENT;
 183     }
 184     if (header.BlockSize != 9 ||
 185         (header.EraseUnitSize < 10) || (header.EraseUnitSize > 31) ||
 186         (header.NumTransferUnits >= le16_to_cpu(header.NumEraseUnits))) {
 187         printk(KERN_NOTICE "ftl_cs: FTL header corrupt!\n");
 188         return -1;
 189     }
 190     if ((1 << header.EraseUnitSize) != part->mbd.mtd->erasesize) {
 191         printk(KERN_NOTICE "ftl: FTL EraseUnitSize %x != MTD erasesize %x\n",
 192                1 << header.EraseUnitSize,part->mbd.mtd->erasesize);
 193         return -1;
 194     }
 195     part->header = header;
 196     return 0;
 197 }
 198
 199 static int build_maps(partition_t *part)
 200 {
 201     erase_unit_header_t header;
 202     uint16_t xvalid, xtrans, i;
 203     unsigned blocks, j;
 204     int hdr_ok, ret = -1;
 205     ssize_t retval;
 206     loff_t offset;
 207
 208     /* Set up erase unit maps */
 209     part->DataUnits = le16_to_cpu(part->header.NumEraseUnits) -
 210         part->header.NumTransferUnits;
 211     part->EUNInfo = kmalloc(part->DataUnits * sizeof(struct eun_info_t),
 212                             GFP_KERNEL);
 213     if (!part->EUNInfo)
 214             goto out;
 215     for (i = 0; i < part->DataUnits; i++)
 216         part->EUNInfo[i].Offset = 0xffffffff;
 217     part->XferInfo =
 218         kmalloc(part->header.NumTransferUnits * sizeof(struct xfer_info_t),
 219                 GFP_KERNEL);
 220     if (!part->XferInfo)
 221             goto out_EUNInfo;
 222
 223     xvalid = xtrans = 0;
 224     for (i = 0; i < le16_to_cpu(part->header.NumEraseUnits); i++) {
 225         offset = ((i + le16_to_cpu(part->header.FirstPhysicalEUN))
 226                       << part->header.EraseUnitSize);
 227         ret = part->mbd.mtd->read(part->mbd.mtd, offset, sizeof(header), &retval,
 228                               (unsigned char *)&header);
 229
 230         if (ret)
 231             goto out_XferInfo;
 232
 233         ret = -1;
 234         /* Is this a transfer partition? */
 235         hdr_ok = (strcmp(header.DataOrgTuple+3, "FTL100") == 0);
 236         if (hdr_ok && (le16_to_cpu(header.LogicalEUN) < part->DataUnits) &&
 237             (part->EUNInfo[le16_to_cpu(header.LogicalEUN)].Offset == 0xffffffff)) {
 238             part->EUNInfo[le16_to_cpu(header.LogicalEUN)].Offset = offset;
 239             part->EUNInfo[le16_to_cpu(header.LogicalEUN)].EraseCount =
 240                 le32_to_cpu(header.EraseCount);
 241             xvalid++;
 242         } else {
 243             if (xtrans == part->header.NumTransferUnits) {
 244                 printk(KERN_NOTICE "ftl_cs: format error: too many "
 245                        "transfer units!\n");
 246                 goto out_XferInfo;
 247             }
 248             if (hdr_ok && (le16_to_cpu(header.LogicalEUN) == 0xffff)) {
 249                 part->XferInfo[xtrans].state = XFER_PREPARED;
 250                 part->XferInfo[xtrans].EraseCount = le32_to_cpu(header.EraseCount);
 251             } else {
 252                 part->XferInfo[xtrans].state = XFER_UNKNOWN;
 253                 /* Pick anything reasonable for the erase count */
 254                 part->XferInfo[xtrans].EraseCount =
 255                     le32_to_cpu(part->header.EraseCount);
 256             }
 257             part->XferInfo[xtrans].Offset = offset;
 258             xtrans++;
 259         }
 260     }
 261     /* Check for format trouble */
 262     header = part->header;
 263     if ((xtrans != header.NumTransferUnits) ||
 264         (xvalid+xtrans != le16_to_cpu(header.NumEraseUnits))) {
 265         printk(KERN_NOTICE "ftl_cs: format error: erase units "
 266                "don't add up!\n");
 267         goto out_XferInfo;
 268     }
 269
 270     /* Set up virtual page map */
 271     blocks = le32_to_cpu(header.FormattedSize) >> header.BlockSize;
 272     part->VirtualBlockMap = vmalloc(blocks * sizeof(uint32_t));
 273     if (!part->VirtualBlockMap)
 274             goto out_XferInfo;
 275
 276     memset(part->VirtualBlockMap, 0xff, blocks * sizeof(uint32_t));
 277     part->BlocksPerUnit = (1 << header.EraseUnitSize) >> header.BlockSize;
 278
 279     part->bam_cache = kmalloc(part->BlocksPerUnit * sizeof(uint32_t),
 280                               GFP_KERNEL);
 281     if (!part->bam_cache)
 282             goto out_VirtualBlockMap;
 283
 284     part->bam_index = 0xffff;
 285     part->FreeTotal = 0;
 286
 287     for (i = 0; i < part->DataUnits; i++) {
 288         part->EUNInfo[i].Free = 0;
 289         part->EUNInfo[i].Deleted = 0;
 290         offset = part->EUNInfo[i].Offset + le32_to_cpu(header.BAMOffset);
 291
 292         ret = part->mbd.mtd->read(part->mbd.mtd, offset,
 293                               part->BlocksPerUnit * sizeof(uint32_t), &retval,
 294                               (unsigned char *)part->bam_cache);
 295
 296         if (ret)
 297                 goto out_bam_cache;
 298
 299         for (j = 0; j < part->BlocksPerUnit; j++) {
 300             if (BLOCK_FREE(le32_to_cpu(part->bam_cache[j]))) {
 301                 part->EUNInfo[i].Free++;
 302                 part->FreeTotal++;
 303             } else if ((BLOCK_TYPE(le32_to_cpu(part->bam_cache[j])) == BLOCK_DATA) &&
 304                      (BLOCK_NUMBER(le32_to_cpu(part->bam_cache[j])) < blocks))
 305                 part->VirtualBlockMap[BLOCK_NUMBER(le32_to_cpu(part->bam_cache[j]))] =
 306                     (i << header.EraseUnitSize) + (j << header.BlockSize);
 307             else if (BLOCK_DELETED(le32_to_cpu(part->bam_cache[j])))
 308                 part->EUNInfo[i].Deleted++;
 309         }
 310     }
 311
 312     ret = 0;
 313     goto out;
 314
 315 out_bam_cache:
 316     kfree(part->bam_cache);
 317 out_VirtualBlockMap:
 318     vfree(part->VirtualBlockMap);
 319 out_XferInfo:
 320     kfree(part->XferInfo);
 321 out_EUNInfo:
 322     kfree(part->EUNInfo);
 323 out:
 324     return ret;
 325 } /* build_maps */
 326
 327 /*======================================================================
 328
 329     Erase_xfer() schedules an asynchronous erase operation for a
 330     transfer unit.
 331
 332 ======================================================================*/
 333
 334 static int erase_xfer(partition_t *part,
 335                       uint16_t xfernum)
 336 {
 337     int ret;
 338     struct xfer_info_t *xfer;
 339     struct erase_info *erase;
 340
 341     xfer = &part->XferInfo[xfernum];
 342     DEBUG(1, "ftl_cs: erasing xfer unit at 0x%x\n", xfer->Offset);
 343     xfer->state = XFER_ERASING;
 344
 345     /* Is there a free erase slot? Always in MTD. */
 346
 347
 348     erase=kmalloc(sizeof(struct erase_info), GFP_KERNEL);
 349     if (!erase)
 350             return -ENOMEM;
 351
 352     erase->mtd = part->mbd.mtd;
 353     erase->callback = ftl_erase_callback;
 354     erase->addr = xfer->Offset;
 355     erase->len = 1 << part->header.EraseUnitSize;
 356     erase->priv = (u_long)part;
 357
 358     ret = part->mbd.mtd->erase(part->mbd.mtd, erase);
 359
 360     if (!ret)
 361             xfer->EraseCount++;
 362     else
 363             kfree(erase);
 364
 365     return ret;
 366 } /* erase_xfer */
 367
 368 /*======================================================================
 369
 370     Prepare_xfer() takes a freshly erased transfer unit and gives
 371     it an appropriate header.
 372
 373 ======================================================================*/
 374
 375 static void ftl_erase_callback(struct erase_info *erase)
 376 {
 377     partition_t *part;
 378     struct xfer_info_t *xfer;
 379     int i;
 380
 381     /* Look up the transfer unit */
 382     part = (partition_t *)(erase->priv);
 383
 384     for (i = 0; i < part->header.NumTransferUnits; i++)
 385         if (part->XferInfo[i].Offset == erase->addr) break;
 386
 387     if (i == part->header.NumTransferUnits) {
 388         printk(KERN_NOTICE "ftl_cs: internal error: "
 389                "erase lookup failed!\n");
 390         return;
 391     }
 392
 393     xfer = &part->XferInfo[i];
 394     if (erase->state == MTD_ERASE_DONE)
 395         xfer->state = XFER_ERASED;
 396     else {
 397         xfer->state = XFER_FAILED;
 398         printk(KERN_NOTICE "ftl_cs: erase failed: state = %d\n",
 399                erase->state);
 400     }
 401
 402     kfree(erase);
 403
 404 } /* ftl_erase_callback */
 405
 406 static int prepare_xfer(partition_t *part, int i)
 407 {
 408     erase_unit_header_t header;
 409     struct xfer_info_t *xfer;
 410     int nbam, ret;
 411     uint32_t ctl;
 412     ssize_t retlen;
 413     loff_t offset;
 414
 415     xfer = &part->XferInfo[i];
 416     xfer->state = XFER_FAILED;
 417
 418     DEBUG(1, "ftl_cs: preparing xfer unit at 0x%x\n", xfer->Offset);
 419
 420     /* Write the transfer unit header */
 421     header = part->header;
 422     header.LogicalEUN = cpu_to_le16(0xffff);
 423     header.EraseCount = cpu_to_le32(xfer->EraseCount);
 424
 425     ret = part->mbd.mtd->write(part->mbd.mtd, xfer->Offset, sizeof(header),
 426                            &retlen, (u_char *)&header);
 427
 428     if (ret) {
 429         return ret;
 430     }
 431
 432     /* Write the BAM stub */
 433     nbam = (part->BlocksPerUnit * sizeof(uint32_t) +
 434             le32_to_cpu(part->header.BAMOffset) + SECTOR_SIZE - 1) / SECTOR_SIZE;
 435
 436     offset = xfer->Offset + le32_to_cpu(part->header.BAMOffset);
 437     ctl = cpu_to_le32(BLOCK_CONTROL);
 438
 439     for (i = 0; i < nbam; i++, offset += sizeof(uint32_t)) {
 440
 441         ret = part->mbd.mtd->write(part->mbd.mtd, offset, sizeof(uint32_t),
 442                                &retlen, (u_char *)&ctl);
 443
 444         if (ret)
 445             return ret;
 446     }
 447     xfer->state = XFER_PREPARED;
 448     return 0;
 449
 450 } /* prepare_xfer */
 451
 452 /*======================================================================
 453
 454     Copy_erase_unit() takes a full erase block and a transfer unit,
 455     copies everything to the transfer unit, then swaps the block
 456     pointers.
 457
 458     All data blocks are copied to the corresponding blocks in the
 459     target unit, so the virtual block map does not need to be
 460     updated.
 461
 462 ======================================================================*/
 463
 464 static int copy_erase_unit(partition_t *part, uint16_t srcunit,
 465                            uint16_t xferunit)
 466 {
 467     u_char buf[SECTOR_SIZE];
 468     struct eun_info_t *eun;
 469     struct xfer_info_t *xfer;
 470     uint32_t src, dest, free, i;
 471     uint16_t unit;
 472     int ret;
 473     ssize_t retlen;
 474     loff_t offset;
 475     uint16_t srcunitswap = cpu_to_le16(srcunit);
 476
 477     eun = &part->EUNInfo[srcunit];
 478     xfer = &part->XferInfo[xferunit];
 479     DEBUG(2, "ftl_cs: copying block 0x%x to 0x%x\n",
 480           eun->Offset, xfer->Offset);
 481
 482
 483     /* Read current BAM */
 484     if (part->bam_index != srcunit) {
 485
 486         offset = eun->Offset + le32_to_cpu(part->header.BAMOffset);
 487
 488         ret = part->mbd.mtd->read(part->mbd.mtd, offset,
 489                               part->BlocksPerUnit * sizeof(uint32_t),
 490                               &retlen, (u_char *) (part->bam_cache));
 491
 492         /* mark the cache bad, in case we get an error later */
 493         part->bam_index = 0xffff;
 494
 495         if (ret) {
 496             printk( KERN_WARNING "ftl: Failed to read BAM cache in copy_erase_unit()!\n");
 497             return ret;
 498         }
 499     }
 500
 501     /* Write the LogicalEUN for the transfer unit */
 502     xfer->state = XFER_UNKNOWN;
 503     offset = xfer->Offset + 20; /* Bad! */
 504     unit = cpu_to_le16(0x7fff);
 505
 506     ret = part->mbd.mtd->write(part->mbd.mtd, offset, sizeof(uint16_t),
 507                            &retlen, (u_char *) &unit);
 508
 509     if (ret) {
 510         printk( KERN_WARNING "ftl: Failed to write back to BAM cache in copy_erase_unit()!\n");
 511         return ret;
 512     }
 513
 514     /* Copy all data blocks from source unit to transfer unit */
 515     src = eun->Offset; dest = xfer->Offset;
 516
 517     free = 0;
 518     ret = 0;
 519     for (i = 0; i < part->BlocksPerUnit; i++) {
 520         switch (BLOCK_TYPE(le32_to_cpu(part->bam_cache[i]))) {
 521         case BLOCK_CONTROL:
 522             /* This gets updated later */
 523             break;
 524         case BLOCK_DATA:
 525         case BLOCK_REPLACEMENT:
 526             ret = part->mbd.mtd->read(part->mbd.mtd, src, SECTOR_SIZE,
 527                         &retlen, (u_char *) buf);
 528             if (ret) {
 529                 printk(KERN_WARNING "ftl: Error reading old xfer unit in copy_erase_unit\n");
 530                 return ret;
 531             }
 532
 533
 534             ret = part->mbd.mtd->write(part->mbd.mtd, dest, SECTOR_SIZE,
 535                         &retlen, (u_char *) buf);
 536             if (ret)  {
 537                 printk(KERN_WARNING "ftl: Error writing new xfer unit in copy_erase_unit\n");
 538                 return ret;
 539             }
 540
 541             break;
 542         default:
 543             /* All other blocks must be free */
 544             part->bam_cache[i] = cpu_to_le32(0xffffffff);
 545             free++;
 546             break;
 547         }
 548         src += SECTOR_SIZE;
 549         dest += SECTOR_SIZE;
 550     }
 551
 552     /* Write the BAM to the transfer unit */
 553     ret = part->mbd.mtd->write(part->mbd.mtd, xfer->Offset + le32_to_cpu(part->header.BAMOffset),
 554                     part->BlocksPerUnit * sizeof(int32_t), &retlen,
 555                     (u_char *)part->bam_cache);
 556     if (ret) {
 557         printk( KERN_WARNING "ftl: Error writing BAM in copy_erase_unit\n");
 558         return ret;
 559     }
 560
 561
 562     /* All clear? Then update the LogicalEUN again */
 563     ret = part->mbd.mtd->write(part->mbd.mtd, xfer->Offset + 20, sizeof(uint16_t),
 564                            &retlen, (u_char *)&srcunitswap);
 565
 566     if (ret) {
 567         printk(KERN_WARNING "ftl: Error writing new LogicalEUN in copy_erase_unit\n");
 568         return ret;
 569     }
 570
 571
 572     /* Update the maps and usage stats*/
 573     i = xfer->EraseCount;
 574     xfer->EraseCount = eun->EraseCount;
 575     eun->EraseCount = i;
 576     i = xfer->Offset;
 577     xfer->Offset = eun->Offset;
 578     eun->Offset = i;
 579     part->FreeTotal -= eun->Free;
 580     part->FreeTotal += free;
 581     eun->Free = free;
 582     eun->Deleted = 0;
 583
 584     /* Now, the cache should be valid for the new block */
 585     part->bam_index = srcunit;
 586
 587     return 0;
 588 } /* copy_erase_unit */
 589
 590 /*======================================================================
 591
 592     reclaim_block() picks a full erase unit and a transfer unit and
 593     then calls copy_erase_unit() to copy one to the other.  Then, it
 594     schedules an erase on the expired block.
 595
 596     What's a good way to decide which transfer unit and which erase
 597     unit to use?  Beats me.  My way is to always pick the transfer
 598     unit with the fewest erases, and usually pick the data unit with
 599     the most deleted blocks.  But with a small probability, pick the
 600     oldest data unit instead.  This means that we generally postpone
 601     the next reclaimation as long as possible, but shuffle static
 602     stuff around a bit for wear leveling.
 603
 604 ======================================================================*/
 605
 606 static int reclaim_block(partition_t *part)
 607 {
 608     uint16_t i, eun, xfer;
 609     uint32_t best;
 610     int queued, ret;
 611
 612     DEBUG(0, "ftl_cs: reclaiming space...\n");
 613     DEBUG(3, "NumTransferUnits == %x\n", part->header.NumTransferUnits);
 614     /* Pick the least erased transfer unit */
 615     best = 0xffffffff; xfer = 0xffff;
 616     do {
 617         queued = 0;
 618         for (i = 0; i < part->header.NumTransferUnits; i++) {
 619             int n=0;
 620             if (part->XferInfo[i].state == XFER_UNKNOWN) {
 621                 DEBUG(3,"XferInfo[%d].state == XFER_UNKNOWN\n",i);
 622                 n=1;
 623                 erase_xfer(part, i);
 624             }
 625             if (part->XferInfo[i].state == XFER_ERASING) {
 626                 DEBUG(3,"XferInfo[%d].state == XFER_ERASING\n",i);
 627                 n=1;
 628                 queued = 1;
 629             }
 630             else if (part->XferInfo[i].state == XFER_ERASED) {
 631                 DEBUG(3,"XferInfo[%d].state == XFER_ERASED\n",i);
 632                 n=1;
 633                 prepare_xfer(part, i);
 634             }
 635             if (part->XferInfo[i].state == XFER_PREPARED) {
 636                 DEBUG(3,"XferInfo[%d].state == XFER_PREPARED\n",i);
 637                 n=1;
 638                 if (part->XferInfo[i].EraseCount <= best) {
 639                     best = part->XferInfo[i].EraseCount;
 640                     xfer = i;
 641                 }
 642             }
 643                 if (!n)
 644                     DEBUG(3,"XferInfo[%d].state == %x\n",i, part->XferInfo[i].state);
 645
 646         }
 647         if (xfer == 0xffff) {
 648             if (queued) {
 649                 DEBUG(1, "ftl_cs: waiting for transfer "
 650                       "unit to be prepared...\n");
 651                 if (part->mbd.mtd->sync)
 652                         part->mbd.mtd->sync(part->mbd.mtd);
 653             } else {
 654                 static int ne = 0;
 655                 if (++ne < 5)
 656                     printk(KERN_NOTICE "ftl_cs: reclaim failed: no "
 657                            "suitable transfer units!\n");
 658                 else
 659                     DEBUG(1, "ftl_cs: reclaim failed: no "
 660                           "suitable transfer units!\n");
 661
 662                 return -EIO;
 663             }
 664         }
 665     } while (xfer == 0xffff);
 666
 667     eun = 0;
 668     if ((jiffies % shuffle_freq) == 0) {
 669         DEBUG(1, "ftl_cs: recycling freshest block...\n");
 670         best = 0xffffffff;
 671         for (i = 0; i < part->DataUnits; i++)
 672             if (part->EUNInfo[i].EraseCount <= best) {
 673                 best = part->EUNInfo[i].EraseCount;
 674                 eun = i;
 675             }
 676     } else {
 677         best = 0;
 678         for (i = 0; i < part->DataUnits; i++)
 679             if (part->EUNInfo[i].Deleted >= best) {
 680                 best = part->EUNInfo[i].Deleted;
 681                 eun = i;
 682             }
 683         if (best == 0) {
 684             static int ne = 0;
 685             if (++ne < 5)
 686                 printk(KERN_NOTICE "ftl_cs: reclaim failed: "
 687                        "no free blocks!\n");
 688             else
 689                 DEBUG(1,"ftl_cs: reclaim failed: "
 690                        "no free blocks!\n");
 691
 692             return -EIO;
 693         }
 694     }
 695     ret = copy_erase_unit(part, eun, xfer);
 696     if (!ret)
 697         erase_xfer(part, xfer);
 698     else
 699         printk(KERN_NOTICE "ftl_cs: copy_erase_unit failed!\n");
 700     return ret;
 701 } /* reclaim_block */
 702
 703 /*======================================================================
 704
 705     Find_free() searches for a free block.  If necessary, it updates
 706     the BAM cache for the erase unit containing the free block.  It
 707     returns the block index -- the erase unit is just the currently
 708     cached unit.  If there are no free blocks, it returns 0 -- this
 709     is never a valid data block because it contains the header.
 710
 711 ======================================================================*/
 712
 713 #ifdef PSYCHO_DEBUG
 714 static void dump_lists(partition_t *part)
 715 {
 716     int i;
 717     printk(KERN_DEBUG "ftl_cs: Free total = %d\n", part->FreeTotal);
 718     for (i = 0; i < part->DataUnits; i++)
 719         printk(KERN_DEBUG "ftl_cs:   unit %d: %d phys, %d free, "
 720                "%d deleted\n", i,
 721                part->EUNInfo[i].Offset >> part->header.EraseUnitSize,
 722                part->EUNInfo[i].Free, part->EUNInfo[i].Deleted);
 723 }
 724 #endif
 725
 726 static uint32_t find_free(partition_t *part)
 727 {
 728     uint16_t stop, eun;
 729     uint32_t blk;
 730     size_t retlen;
 731     int ret;
 732
 733     /* Find an erase unit with some free space */
 734     stop = (part->bam_index == 0xffff) ? 0 : part->bam_index;
 735     eun = stop;
 736     do {
 737         if (part->EUNInfo[eun].Free != 0) break;
 738         /* Wrap around at end of table */
 739         if (++eun == part->DataUnits) eun = 0;
 740     } while (eun != stop);
 741
 742     if (part->EUNInfo[eun].Free == 0)
 743         return 0;
 744
 745     /* Is this unit's BAM cached? */
 746     if (eun != part->bam_index) {
 747         /* Invalidate cache */
 748         part->bam_index = 0xffff;
 749
 750         ret = part->mbd.mtd->read(part->mbd.mtd,
 751                        part->EUNInfo[eun].Offset + le32_to_cpu(part->header.BAMOffset),
 752                        part->BlocksPerUnit * sizeof(uint32_t),
 753                        &retlen, (u_char *) (part->bam_cache));
 754
 755         if (ret) {
 756             printk(KERN_WARNING"ftl: Error reading BAM in find_free\n");
 757             return 0;
 758         }
 759         part->bam_index = eun;
 760     }
 761
 762     /* Find a free block */
 763     for (blk = 0; blk < part->BlocksPerUnit; blk++)
 764         if (BLOCK_FREE(le32_to_cpu(part->bam_cache[blk]))) break;
 765     if (blk == part->BlocksPerUnit) {
 766 #ifdef PSYCHO_DEBUG
 767         static int ne = 0;
 768         if (++ne == 1)
 769             dump_lists(part);
 770 #endif
 771         printk(KERN_NOTICE "ftl_cs: bad free list!\n");
 772         return 0;
 773     }
 774     DEBUG(2, "ftl_cs: found free block at %d in %d\n", blk, eun);
 775     return blk;
 776
 777 } /* find_free */
 778
 779
 780 /*======================================================================
 781
 782     Read a series of sectors from an FTL partition.
 783
 784 ======================================================================*/
 785
 786 static int ftl_read(partition_t *part, caddr_t buffer,
 787                     u_long sector, u_long nblocks)
 788 {
 789     uint32_t log_addr, bsize;
 790     u_long i;
 791     int ret;
 792     size_t offset, retlen;
 793
 794     DEBUG(2, "ftl_cs: ftl_read(0x%p, 0x%lx, %ld)\n",
 795           part, sector, nblocks);
 796     if (!(part->state & FTL_FORMATTED)) {
 797         printk(KERN_NOTICE "ftl_cs: bad partition\n");
 798         return -EIO;
 799     }
 800     bsize = 1 << part->header.EraseUnitSize;
 801
 802     for (i = 0; i < nblocks; i++) {
 803         if (((sector+i) * SECTOR_SIZE) >= le32_to_cpu(part->header.FormattedSize)) {
 804             printk(KERN_NOTICE "ftl_cs: bad read offset\n");
 805             return -EIO;
 806         }
 807         log_addr = part->VirtualBlockMap[sector+i];
 808         if (log_addr == 0xffffffff)
 809             memset(buffer, 0, SECTOR_SIZE);
 810         else {
 811             offset = (part->EUNInfo[log_addr / bsize].Offset
 812                           + (log_addr % bsize));
 813             ret = part->mbd.mtd->read(part->mbd.mtd, offset, SECTOR_SIZE,
 814                            &retlen, (u_char *) buffer);
 815
 816             if (ret) {
 817                 printk(KERN_WARNING "Error reading MTD device in ftl_read()\n");
 818                 return ret;
 819             }
 820         }
 821         buffer += SECTOR_SIZE;
 822     }
 823     return 0;
 824 } /* ftl_read */
 825
 826 /*======================================================================
 827
 828     Write a series of sectors to an FTL partition
 829
 830 ======================================================================*/
 831
 832 static int set_bam_entry(partition_t *part, uint32_t log_addr,
 833                          uint32_t virt_addr)
 834 {
 835     uint32_t bsize, blk, le_virt_addr;
 836 #ifdef PSYCHO_DEBUG
 837     uint32_t old_addr;
 838 #endif
 839     uint16_t eun;
 840     int ret;
 841     size_t retlen, offset;
 842
 843     DEBUG(2, "ftl_cs: set_bam_entry(0x%p, 0x%x, 0x%x)\n",
 844           part, log_addr, virt_addr);
 845     bsize = 1 << part->header.EraseUnitSize;
 846     eun = log_addr / bsize;
 847     blk = (log_addr % bsize) / SECTOR_SIZE;
 848     offset = (part->EUNInfo[eun].Offset + blk * sizeof(uint32_t) +
 849                   le32_to_cpu(part->header.BAMOffset));
 850
 851 #ifdef PSYCHO_DEBUG
 852     ret = part->mbd.mtd->read(part->mbd.mtd, offset, sizeof(uint32_t),
 853                         &retlen, (u_char *)&old_addr);
 854     if (ret) {
 855         printk(KERN_WARNING"ftl: Error reading old_addr in set_bam_entry: %d\n",ret);
 856         return ret;
 857     }
 858     old_addr = le32_to_cpu(old_addr);
 859
 860     if (((virt_addr == 0xfffffffe) && !BLOCK_FREE(old_addr)) ||
 861         ((virt_addr == 0) && (BLOCK_TYPE(old_addr) != BLOCK_DATA)) ||
 862         (!BLOCK_DELETED(virt_addr) && (old_addr != 0xfffffffe))) {
 863         static int ne = 0;
 864         if (++ne < 5) {
 865             printk(KERN_NOTICE "ftl_cs: set_bam_entry() inconsistency!\n");
 866             printk(KERN_NOTICE "ftl_cs:   log_addr = 0x%x, old = 0x%x"
 867                    ", new = 0x%x\n", log_addr, old_addr, virt_addr);
 868         }
 869         return -EIO;
 870     }
 871 #endif
 872     le_virt_addr = cpu_to_le32(virt_addr);
 873     if (part->bam_index == eun) {
 874 #ifdef PSYCHO_DEBUG
 875         if (le32_to_cpu(part->bam_cache[blk]) != old_addr) {
 876             static int ne = 0;
 877             if (++ne < 5) {
 878                 printk(KERN_NOTICE "ftl_cs: set_bam_entry() "
 879                        "inconsistency!\n");
 880                 printk(KERN_NOTICE "ftl_cs:   log_addr = 0x%x, cache"
 881                        " = 0x%x\n",
 882                        le32_to_cpu(part->bam_cache[blk]), old_addr);
 883             }
 884             return -EIO;
 885         }
 886 #endif
 887         part->bam_cache[blk] = le_virt_addr;
 888     }
 889     ret = part->mbd.mtd->write(part->mbd.mtd, offset, sizeof(uint32_t),
 890                             &retlen, (u_char *)&le_virt_addr);
 891
 892     if (ret) {
 893         printk(KERN_NOTICE "ftl_cs: set_bam_entry() failed!\n");
 894         printk(KERN_NOTICE "ftl_cs:   log_addr = 0x%x, new = 0x%x\n",
 895                log_addr, virt_addr);
 896     }
 897     return ret;
 898 } /* set_bam_entry */
 899
 900 static int ftl_write(partition_t *part, caddr_t buffer,
 901                      u_long sector, u_long nblocks)
 902 {
 903     uint32_t bsize, log_addr, virt_addr, old_addr, blk;
 904     u_long i;
 905     int ret;
 906     size_t retlen, offset;
 907
 908     DEBUG(2, "ftl_cs: ftl_write(0x%p, %ld, %ld)\n",
 909           part, sector, nblocks);
 910     if (!(part->state & FTL_FORMATTED)) {
 911         printk(KERN_NOTICE "ftl_cs: bad partition\n");
 912         return -EIO;
 913     }
 914     /* See if we need to reclaim space, before we start */
 915     while (part->FreeTotal < nblocks) {
 916         ret = reclaim_block(part);
 917         if (ret)
 918             return ret;
 919     }
 920
 921     bsize = 1 << part->header.EraseUnitSize;
 922
 923     virt_addr = sector * SECTOR_SIZE | BLOCK_DATA;
 924     for (i = 0; i < nblocks; i++) {
 925         if (virt_addr >= le32_to_cpu(part->header.FormattedSize)) {
 926             printk(KERN_NOTICE "ftl_cs: bad write offset\n");
 927             return -EIO;
 928         }
 929
 930         /* Grab a free block */
 931         blk = find_free(part);
 932         if (blk == 0) {
 933             static int ne = 0;
 934             if (++ne < 5)
 935                 printk(KERN_NOTICE "ftl_cs: internal error: "
 936                        "no free blocks!\n");
 937             return -ENOSPC;
 938         }
 939
 940         /* Tag the BAM entry, and write the new block */
 941         log_addr = part->bam_index * bsize + blk * SECTOR_SIZE;
 942         part->EUNInfo[part->bam_index].Free--;
 943         part->FreeTotal--;
 944         if (set_bam_entry(part, log_addr, 0xfffffffe))
 945             return -EIO;
 946         part->EUNInfo[part->bam_index].Deleted++;
 947         offset = (part->EUNInfo[part->bam_index].Offset +
 948                       blk * SECTOR_SIZE);
 949         ret = part->mbd.mtd->write(part->mbd.mtd, offset, SECTOR_SIZE, &retlen,
 950                                      buffer);
 951
 952         if (ret) {
 953             printk(KERN_NOTICE "ftl_cs: block write failed!\n");
 954             printk(KERN_NOTICE "ftl_cs:   log_addr = 0x%x, virt_addr"
 955                    " = 0x%x, Offset = 0x%zx\n", log_addr, virt_addr,
 956                    offset);
 957             return -EIO;
 958         }
 959
 960         /* Only delete the old entry when the new entry is ready */
 961         old_addr = part->VirtualBlockMap[sector+i];
 962         if (old_addr != 0xffffffff) {
 963             part->VirtualBlockMap[sector+i] = 0xffffffff;
 964             part->EUNInfo[old_addr/bsize].Deleted++;
 965             if (set_bam_entry(part, old_addr, 0))
 966                 return -EIO;
 967         }
 968
 969         /* Finally, set up the new pointers */
 970         if (set_bam_entry(part, log_addr, virt_addr))
 971             return -EIO;
 972         part->VirtualBlockMap[sector+i] = log_addr;
 973         part->EUNInfo[part->bam_index].Deleted--;
 974
 975         buffer += SECTOR_SIZE;
 976         virt_addr += SECTOR_SIZE;
 977     }
 978     return 0;
 979 } /* ftl_write */
 980
 981 static int ftl_getgeo(struct mtd_blktrans_dev *dev, struct hd_geometry *geo)
 982 {
 983         partition_t *part = (void *)dev;
 984         u_long sect;
 985
 986         /* Sort of arbitrary: round size down to 4KiB boundary */
 987         sect = le32_to_cpu(part->header.FormattedSize)/SECTOR_SIZE;
 988
 989         geo->heads = 1;
 990         geo->sectors = 8;
 991         geo->cylinders = sect >> 3;
 992
 993         return 0;
 994 }
 995
 996 static int ftl_readsect(struct mtd_blktrans_dev *dev,
 997                               unsigned long block, char *buf)
 998 {
 999         return ftl_read((void *)dev, buf, block, 1);
1000 }
1001
1002 static int ftl_writesect(struct mtd_blktrans_dev *dev,
1003                               unsigned long block, char *buf)
1004 {
1005         return ftl_write((void *)dev, buf, block, 1);
1006 }
1007
1008 static int ftl_discardsect(struct mtd_blktrans_dev *dev,
1009                            unsigned long sector, unsigned nr_sects)
1010 {
1011         partition_t *part = (void *)dev;
1012         uint32_t bsize = 1 << part->header.EraseUnitSize;
1013
1014         DEBUG(1, "FTL erase sector %ld for %d sectors\n",
1015               sector, nr_sects);
1016
1017         while (nr_sects) {
1018                 uint32_t old_addr = part->VirtualBlockMap[sector];
1019                 if (old_addr != 0xffffffff) {
1020                         part->VirtualBlockMap[sector] = 0xffffffff;
1021                         part->EUNInfo[old_addr/bsize].Deleted++;
1022                         if (set_bam_entry(part, old_addr, 0))
1023                                 return -EIO;
1024                 }
1025                 nr_sects--;
1026                 sector++;
1027         }
1028
1029         return 0;
1030 }
1031 /*====================================================================*/
1032
1033 static void ftl_freepart(partition_t *part)
1034 {
1035         vfree(part->VirtualBlockMap);
1036         part->VirtualBlockMap = NULL;
1037         kfree(part->VirtualPageMap);
1038         part->VirtualPageMap = NULL;
1039         kfree(part->EUNInfo);
1040         part->EUNInfo = NULL;
1041         kfree(part->XferInfo);
1042         part->XferInfo = NULL;
1043         kfree(part->bam_cache);
1044         part->bam_cache = NULL;
1045 } /* ftl_freepart */
1046
1047 static void ftl_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd)
1048 {
1049         partition_t *partition;
1050
1051         partition = kzalloc(sizeof(partition_t), GFP_KERNEL);
1052
1053         if (!partition) {
1054                 printk(KERN_WARNING "No memory to scan for FTL on %s\n",
1055                        mtd->name);
1056                 return;
1057         }
1058
1059         partition->mbd.mtd = mtd;
1060
1061         if ((scan_header(partition) == 0) &&
1062             (build_maps(partition) == 0)) {
1063
1064                 partition->state = FTL_FORMATTED;
1065 #ifdef PCMCIA_DEBUG
1066                 printk(KERN_INFO "ftl_cs: opening %d KiB FTL partition\n",
1067                        le32_to_cpu(partition->header.FormattedSize) >> 10);
1068 #endif
1069                 partition->mbd.size = le32_to_cpu(partition->header.FormattedSize) >> 9;
1070
1071                 partition->mbd.tr = tr;
1072                 partition->mbd.devnum = -1;
1073                 if (!add_mtd_blktrans_dev((void *)partition))
1074                         return;
1075         }
1076
1077         ftl_freepart(partition);
1078         kfree(partition);
1079 }
1080
1081 static void ftl_remove_dev(struct mtd_blktrans_dev *dev)
1082 {
1083         del_mtd_blktrans_dev(dev);
1084         ftl_freepart((partition_t *)dev);
1085 }
1086
1087 static struct mtd_blktrans_ops ftl_tr = {
1088         .name           = "ftl",
1089         .major          = FTL_MAJOR,
1090         .part_bits      = PART_BITS,
1091         .blksize        = SECTOR_SIZE,
1092         .readsect       = ftl_readsect,
1093         .writesect      = ftl_writesect,
1094         .discard        = ftl_discardsect,
1095         .getgeo         = ftl_getgeo,
1096         .add_mtd        = ftl_add_mtd,
1097         .remove_dev     = ftl_remove_dev,
1098         .owner          = THIS_MODULE,
1099 };
1100
1101 static int __init init_ftl(void)
1102 {
1103         return register_mtd_blktrans(&ftl_tr);
1104 }
1105
1106 static void __exit cleanup_ftl(void)
1107 {
1108         deregister_mtd_blktrans(&ftl_tr);
1109 }
1110
1111 module_init(init_ftl);
1112 module_exit(cleanup_ftl);
1113
1114
1115 MODULE_LICENSE("Dual MPL/GPL");
1116 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
1117 MODULE_DESCRIPTION("Support code for Flash Translation Layer, used on PCMCIA devices");