Subversion Repositories or1k

/* This version ported to the Linux-MTD system by dwmw2@infradead.org

 * $Id: ftl.c,v 1.1.1.1 2004-04-15 01:51:38 phoenix Exp $

 *

 * Fixes: Arnaldo Carvalho de Melo <acme@conectiva.com.br>

 * - fixes some leaks on failure in build_maps and ftl_notify_add, cleanups

 *

 * Based on:

 */

/*======================================================================

    A Flash Translation Layer memory card driver

    This driver implements a disk-like block device driver with an

    apparent block size of 512 bytes for flash memory cards.

    ftl_cs.c 1.62 2000/02/01 00:59:04

    The contents of this file are subject to the Mozilla Public

    License Version 1.1 (the "License"); you may not use this file

    except in compliance with the License. You may obtain a copy of

    the License at http://www.mozilla.org/MPL/

    Software distributed under the License is distributed on an "AS

    IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or

    implied. See the License for the specific language governing

    rights and limitations under the License.

    The initial developer of the original code is David A. Hinds

    <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds

    are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.

    Alternatively, the contents of this file may be used under the

    terms of the GNU General Public License version 2 (the "GPL"), in

    which case the provisions of the GPL are applicable instead of the

    above.  If you wish to allow the use of your version of this file

    only under the terms of the GPL and not to allow others to use

    your version of this file under the MPL, indicate your decision

    by deleting the provisions above and replace them with the notice

    and other provisions required by the GPL.  If you do not delete

    the provisions above, a recipient may use your version of this

    file under either the MPL or the GPL.

    LEGAL NOTE: The FTL format is patented by M-Systems.  They have

    granted a license for its use with PCMCIA devices:

     "M-Systems grants a royalty-free, non-exclusive license under

      any presently existing M-Systems intellectual property rights

      necessary for the design and development of FTL-compatible

      drivers, file systems and utilities using the data formats with

      PCMCIA PC Cards as described in the PCMCIA Flash Translation

      Layer (FTL) Specification."

    Use of the FTL format for non-PCMCIA applications may be an

    infringement of these patents.  For additional information,

    contact M-Systems (http://www.m-sys.com) directly.

======================================================================*/

#include <linux/module.h>

#include <linux/mtd/compatmac.h>

#include <linux/mtd/mtd.h>

/*#define PSYCHO_DEBUG */

#include <linux/kernel.h>

#include <linux/sched.h>

#include <linux/ptrace.h>

#include <linux/slab.h>

#include <linux/string.h>

#include <linux/timer.h>

#include <linux/major.h>

#include <linux/fs.h>

#include <linux/ioctl.h>

#include <linux/hdreg.h>

#if (LINUX_VERSION_CODE >= 0x20100)

#include <linux/vmalloc.h>

#endif

#if (LINUX_VERSION_CODE >= 0x20303)

#include <linux/blkpg.h>

#endif

#include <linux/mtd/ftl.h>

/*====================================================================*/

/* Stuff which really ought to be in compatmac.h */

#if (LINUX_VERSION_CODE < 0x20328)

#define register_disk(dev, drive, minors, ops, size) \

    do { (dev)->part[(drive)*(minors)].nr_sects = size; \

        if (size == 0) (dev)->part[(drive)*(minors)].start_sect = -1; \

        resetup_one_dev(dev, drive); } while (0)

#endif

#if (LINUX_VERSION_CODE < 0x20320)

#define BLK_DEFAULT_QUEUE(n)    blk_dev[n].request_fn

#define blk_init_queue(q, req)  q = (req)

#define blk_cleanup_queue(q)    q = NULL

#define request_arg_t           void

#else

#define request_arg_t           request_queue_t *q

#endif

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,14)

#define BLK_INC_USE_COUNT MOD_INC_USE_COUNT

#define BLK_DEC_USE_COUNT MOD_DEC_USE_COUNT

#else

#define BLK_INC_USE_COUNT do {} while(0)

#define BLK_DEC_USE_COUNT do {} while(0)

#endif

/*====================================================================*/

/* Parameters that can be set with 'insmod' */

static int shuffle_freq = 50;

MODULE_PARM(shuffle_freq, "i");

/*====================================================================*/

/* Major device # for FTL device */

#ifndef FTL_MAJOR

#define FTL_MAJOR       44

#endif

/* Funky stuff for setting up a block device */

#define MAJOR_NR                FTL_MAJOR

#define DEVICE_NAME             "ftl"

#define DEVICE_REQUEST          do_ftl_request

#define DEVICE_ON(device)

#define DEVICE_OFF(device)

#define DEVICE_NR(minor)        ((minor)>>5)

#define REGION_NR(minor)        (((minor)>>3)&3)

#define PART_NR(minor)          ((minor)&7)

#define MINOR_NR(dev,reg,part)  (((dev)<<5)+((reg)<<3)+(part))

#include <linux/blk.h>

/*====================================================================*/

/* Maximum number of separate memory devices we'll allow */

#define MAX_DEV         4

/* Maximum number of regions per device */

#define MAX_REGION      4

/* Maximum number of partitions in an FTL region */

#define PART_BITS       3

#define MAX_PART        8

/* Maximum number of outstanding erase requests per socket */

#define MAX_ERASE       8

/* Sector size -- shouldn't need to change */

#define SECTOR_SIZE     512

/* Each memory region corresponds to a minor device */

typedef struct partition_t {

    struct mtd_info     *mtd;

    u_int32_t           state;

    u_int32_t           *VirtualBlockMap;

    u_int32_t           *VirtualPageMap;

    u_int32_t           FreeTotal;

    struct eun_info_t {

        u_int32_t               Offset;

        u_int32_t               EraseCount;

        u_int32_t               Free;

        u_int32_t               Deleted;

    } *EUNInfo;

    struct xfer_info_t {

        u_int32_t               Offset;

        u_int32_t               EraseCount;

        u_int16_t               state;

    } *XferInfo;

    u_int16_t           bam_index;

    u_int32_t           *bam_cache;

    u_int16_t           DataUnits;

    u_int32_t           BlocksPerUnit;

    erase_unit_header_t header;

#if 0

    region_info_t       region;

    memory_handle_t     handle;

#endif

    atomic_t            open;

} partition_t;

partition_t *myparts[MAX_MTD_DEVICES];

static void ftl_notify_add(struct mtd_info *mtd);

static void ftl_notify_remove(struct mtd_info *mtd);

void ftl_freepart(partition_t *part);

static struct mtd_notifier ftl_notifier = {

        add:    ftl_notify_add,

        remove: ftl_notify_remove,

};

/* Partition state flags */

#define FTL_FORMATTED   0x01

/* Transfer unit states */

#define XFER_UNKNOWN    0x00

#define XFER_ERASING    0x01

#define XFER_ERASED     0x02

#define XFER_PREPARED   0x03

#define XFER_FAILED     0x04

static struct hd_struct ftl_hd[MINOR_NR(MAX_DEV, 0, 0)];

static int ftl_sizes[MINOR_NR(MAX_DEV, 0, 0)];

static int ftl_blocksizes[MINOR_NR(MAX_DEV, 0, 0)];

static struct gendisk ftl_gendisk = {

    major:              FTL_MAJOR,

    major_name:         "ftl",

    minor_shift:        PART_BITS,

    max_p:              MAX_PART,

#if (LINUX_VERSION_CODE < 0x20328)

    max_nr:             MAX_DEV*MAX_PART,

#endif

    part:               ftl_hd,

    sizes:              ftl_sizes,

};

/*====================================================================*/

static int ftl_ioctl(struct inode *inode, struct file *file,

                     u_int cmd, u_long arg);

static int ftl_open(struct inode *inode, struct file *file);

static release_t ftl_close(struct inode *inode, struct file *file);

static int ftl_reread_partitions(int minor);

static void ftl_erase_callback(struct erase_info *done);

#if LINUX_VERSION_CODE < 0x20326

static struct file_operations ftl_blk_fops = {

    open:       ftl_open,

    release:    ftl_close,

    ioctl:      ftl_ioctl,

    read:       block_read,

    write:      block_write,

    fsync:      block_fsync

};

#else

static struct block_device_operations ftl_blk_fops = {

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,14)

    owner:      THIS_MODULE,

#endif

    open:       ftl_open,

    release:    ftl_close,

    ioctl:      ftl_ioctl,

};

#endif

/*======================================================================

    Scan_header() checks to see if a memory region contains an FTL

    partition.  build_maps() reads all the erase unit headers, builds

    the erase unit map, and then builds the virtual page map.

======================================================================*/

static int scan_header(partition_t *part)

{

    erase_unit_header_t header;

    loff_t offset, max_offset;

    int ret;

    part->header.FormattedSize = 0;

    max_offset = (0x100000<part->mtd->size)?0x100000:part->mtd->size;

    /* Search first megabyte for a valid FTL header */

    for (offset = 0;

         (offset + sizeof(header)) < max_offset;

         offset += part->mtd->erasesize ? : 0x2000) {

        ret = part->mtd->read(part->mtd, offset, sizeof(header), &ret,

                              (unsigned char *)&header);

        if (ret)

            return ret;

        if (strcmp(header.DataOrgTuple+3, "FTL100") == 0) break;

    }

    if (offset == max_offset) {

        printk(KERN_NOTICE "ftl_cs: FTL header not found.\n");

        return -ENOENT;

    }

    if ((le16_to_cpu(header.NumEraseUnits) > 65536) || header.BlockSize != 9 ||

        (header.EraseUnitSize < 10) || (header.EraseUnitSize > 31) ||

        (header.NumTransferUnits >= le16_to_cpu(header.NumEraseUnits))) {

        printk(KERN_NOTICE "ftl_cs: FTL header corrupt!\n");

        return -1;

    }

    if ((1 << header.EraseUnitSize) != part->mtd->erasesize) {

        printk(KERN_NOTICE "ftl: FTL EraseUnitSize %x != MTD erasesize %x\n",

               1 << header.EraseUnitSize,part->mtd->erasesize);

        return -1;

    }

    part->header = header;

    return 0;

}

static int build_maps(partition_t *part)

{

    erase_unit_header_t header;

    u_int16_t xvalid, xtrans, i;

    u_int blocks, j;

    int hdr_ok, ret = -1;

    ssize_t retval;

    loff_t offset;

    /* Set up erase unit maps */

    part->DataUnits = le16_to_cpu(part->header.NumEraseUnits) -

        part->header.NumTransferUnits;

    part->EUNInfo = kmalloc(part->DataUnits * sizeof(struct eun_info_t),

                            GFP_KERNEL);

    if (!part->EUNInfo)

            goto out;

    for (i = 0; i < part->DataUnits; i++)

        part->EUNInfo[i].Offset = 0xffffffff;

    part->XferInfo =

        kmalloc(part->header.NumTransferUnits * sizeof(struct xfer_info_t),

                GFP_KERNEL);

    if (!part->XferInfo)

            goto out_EUNInfo;

    xvalid = xtrans = 0;

    for (i = 0; i < le16_to_cpu(part->header.NumEraseUnits); i++) {

        offset = ((i + le16_to_cpu(part->header.FirstPhysicalEUN))

                      << part->header.EraseUnitSize);

        ret = part->mtd->read(part->mtd, offset, sizeof(header), &retval,

                              (unsigned char *)&header);

        if (ret)

            goto out_XferInfo;

        ret = -1;

        /* Is this a transfer partition? */

        hdr_ok = (strcmp(header.DataOrgTuple+3, "FTL100") == 0);

        if (hdr_ok && (le16_to_cpu(header.LogicalEUN) < part->DataUnits) &&

            (part->EUNInfo[le16_to_cpu(header.LogicalEUN)].Offset == 0xffffffff)) {

            part->EUNInfo[le16_to_cpu(header.LogicalEUN)].Offset = offset;

            part->EUNInfo[le16_to_cpu(header.LogicalEUN)].EraseCount =

                le32_to_cpu(header.EraseCount);

            xvalid++;

        } else {

            if (xtrans == part->header.NumTransferUnits) {

                printk(KERN_NOTICE "ftl_cs: format error: too many "

                       "transfer units!\n");

                goto out_XferInfo;

            }

            if (hdr_ok && (le16_to_cpu(header.LogicalEUN) == 0xffff)) {

                part->XferInfo[xtrans].state = XFER_PREPARED;

                part->XferInfo[xtrans].EraseCount = le32_to_cpu(header.EraseCount);

            } else {

                part->XferInfo[xtrans].state = XFER_UNKNOWN;

                /* Pick anything reasonable for the erase count */

                part->XferInfo[xtrans].EraseCount =

                    le32_to_cpu(part->header.EraseCount);

            }

            part->XferInfo[xtrans].Offset = offset;

            xtrans++;

        }

    }

    /* Check for format trouble */

    header = part->header;

    if ((xtrans != header.NumTransferUnits) ||

        (xvalid+xtrans != le16_to_cpu(header.NumEraseUnits))) {

        printk(KERN_NOTICE "ftl_cs: format error: erase units "

               "don't add up!\n");

        goto out_XferInfo;

    }

    /* Set up virtual page map */

    blocks = le32_to_cpu(header.FormattedSize) >> header.BlockSize;

    part->VirtualBlockMap = vmalloc(blocks * sizeof(u_int32_t));

    if (!part->VirtualBlockMap)

            goto out_XferInfo;

    memset(part->VirtualBlockMap, 0xff, blocks * sizeof(u_int32_t));

    part->BlocksPerUnit = (1 << header.EraseUnitSize) >> header.BlockSize;

    part->bam_cache = kmalloc(part->BlocksPerUnit * sizeof(u_int32_t),

                              GFP_KERNEL);

    if (!part->bam_cache)

            goto out_VirtualBlockMap;

    part->bam_index = 0xffff;

    part->FreeTotal = 0;

    for (i = 0; i < part->DataUnits; i++) {

        part->EUNInfo[i].Free = 0;

        part->EUNInfo[i].Deleted = 0;

        offset = part->EUNInfo[i].Offset + le32_to_cpu(header.BAMOffset);

        ret = part->mtd->read(part->mtd, offset,

                              part->BlocksPerUnit * sizeof(u_int32_t), &retval,

                              (unsigned char *)part->bam_cache);

        if (ret)

                goto out_bam_cache;

        for (j = 0; j < part->BlocksPerUnit; j++) {

            if (BLOCK_FREE(le32_to_cpu(part->bam_cache[j]))) {

                part->EUNInfo[i].Free++;

                part->FreeTotal++;

            } else if ((BLOCK_TYPE(le32_to_cpu(part->bam_cache[j])) == BLOCK_DATA) &&

                     (BLOCK_NUMBER(le32_to_cpu(part->bam_cache[j])) < blocks))

                part->VirtualBlockMap[BLOCK_NUMBER(le32_to_cpu(part->bam_cache[j]))] =

                    (i << header.EraseUnitSize) + (j << header.BlockSize);

            else if (BLOCK_DELETED(le32_to_cpu(part->bam_cache[j])))

                part->EUNInfo[i].Deleted++;

        }

    }

    ret = 0;

    goto out;

out_bam_cache:

    kfree(part->bam_cache);

out_VirtualBlockMap:

    vfree(part->VirtualBlockMap);

out_XferInfo:

    kfree(part->XferInfo);

out_EUNInfo:

    kfree(part->EUNInfo);

out:

    return ret;

} /* build_maps */

/*======================================================================

    Erase_xfer() schedules an asynchronous erase operation for a

    transfer unit.

======================================================================*/

static int erase_xfer(partition_t *part,

                      u_int16_t xfernum)

{

    int ret;

    struct xfer_info_t *xfer;

    struct erase_info *erase;

    xfer = &part->XferInfo[xfernum];

    DEBUG(1, "ftl_cs: erasing xfer unit at 0x%x\n", xfer->Offset);

    xfer->state = XFER_ERASING;

    /* Is there a free erase slot? Always in MTD. */

    erase=kmalloc(sizeof(struct erase_info), GFP_KERNEL);

    if (!erase)

            return -ENOMEM;

    erase->callback = ftl_erase_callback;

    erase->addr = xfer->Offset;

    erase->len = 1 << part->header.EraseUnitSize;

    erase->priv = (u_long)part;

    ret = part->mtd->erase(part->mtd, erase);

    if (!ret)

            xfer->EraseCount++;

    else

            kfree(erase);

    return ret;

} /* erase_xfer */

/*======================================================================

    Prepare_xfer() takes a freshly erased transfer unit and gives

    it an appropriate header.

======================================================================*/

static void ftl_erase_callback(struct erase_info *erase)

{

    partition_t *part;

    struct xfer_info_t *xfer;

    int i;

    /* Look up the transfer unit */

    part = (partition_t *)(erase->priv);

    for (i = 0; i < part->header.NumTransferUnits; i++)

        if (part->XferInfo[i].Offset == erase->addr) break;

    if (i == part->header.NumTransferUnits) {

        printk(KERN_NOTICE "ftl_cs: internal error: "

               "erase lookup failed!\n");

        return;

    }

    xfer = &part->XferInfo[i];

    if (erase->state == MTD_ERASE_DONE)

        xfer->state = XFER_ERASED;

    else {

        xfer->state = XFER_FAILED;

        printk(KERN_NOTICE "ftl_cs: erase failed: state = %d\n",

               erase->state);

    }

    kfree(erase);

} /* ftl_erase_callback */

static int prepare_xfer(partition_t *part, int i)

{

    erase_unit_header_t header;

    struct xfer_info_t *xfer;

    int nbam, ret;

    u_int32_t ctl;

    ssize_t retlen;

    loff_t offset;

    xfer = &part->XferInfo[i];

    xfer->state = XFER_FAILED;

    DEBUG(1, "ftl_cs: preparing xfer unit at 0x%x\n", xfer->Offset);

    /* Write the transfer unit header */

    header = part->header;

    header.LogicalEUN = cpu_to_le16(0xffff);

    header.EraseCount = cpu_to_le32(xfer->EraseCount);

    ret = part->mtd->write(part->mtd, xfer->Offset, sizeof(header),

                           &retlen, (u_char *)&header);

    if (ret) {

        return ret;

    }

    /* Write the BAM stub */

    nbam = (part->BlocksPerUnit * sizeof(u_int32_t) +

            le32_to_cpu(part->header.BAMOffset) + SECTOR_SIZE - 1) / SECTOR_SIZE;

    offset = xfer->Offset + le32_to_cpu(part->header.BAMOffset);

    ctl = cpu_to_le32(BLOCK_CONTROL);

    for (i = 0; i < nbam; i++, offset += sizeof(u_int32_t)) {

        ret = part->mtd->write(part->mtd, offset, sizeof(u_int32_t),

                               &retlen, (u_char *)&ctl);

        if (ret)

            return ret;

    }

    xfer->state = XFER_PREPARED;

    return 0;

} /* prepare_xfer */

/*======================================================================

    Copy_erase_unit() takes a full erase block and a transfer unit,

    copies everything to the transfer unit, then swaps the block

    pointers.

    All data blocks are copied to the corresponding blocks in the

    target unit, so the virtual block map does not need to be

    updated.

======================================================================*/

static int copy_erase_unit(partition_t *part, u_int16_t srcunit,

                           u_int16_t xferunit)

{

    u_char buf[SECTOR_SIZE];

    struct eun_info_t *eun;

    struct xfer_info_t *xfer;

    u_int32_t src, dest, free, i;

    u_int16_t unit;

    int ret;

    ssize_t retlen;

    loff_t offset;

    u_int16_t srcunitswap = cpu_to_le16(srcunit);

    eun = &part->EUNInfo[srcunit];

    xfer = &part->XferInfo[xferunit];

    DEBUG(2, "ftl_cs: copying block 0x%x to 0x%x\n",

          eun->Offset, xfer->Offset);

    /* Read current BAM */

    if (part->bam_index != srcunit) {

        offset = eun->Offset + le32_to_cpu(part->header.BAMOffset);

        ret = part->mtd->read(part->mtd, offset,

                              part->BlocksPerUnit * sizeof(u_int32_t),

                              &retlen, (u_char *) (part->bam_cache));

        /* mark the cache bad, in case we get an error later */

        part->bam_index = 0xffff;

        if (ret) {

            printk( KERN_WARNING "ftl: Failed to read BAM cache in copy_erase_unit()!\n");

            return ret;

        }

    }

    /* Write the LogicalEUN for the transfer unit */

    xfer->state = XFER_UNKNOWN;

    offset = xfer->Offset + 20; /* Bad! */

    unit = cpu_to_le16(0x7fff);

    ret = part->mtd->write(part->mtd, offset, sizeof(u_int16_t),

                           &retlen, (u_char *) &unit);

    if (ret) {

        printk( KERN_WARNING "ftl: Failed to write back to BAM cache in copy_erase_unit()!\n");

        return ret;

    }

    /* Copy all data blocks from source unit to transfer unit */

    src = eun->Offset; dest = xfer->Offset;

    free = 0;

    ret = 0;

    for (i = 0; i < part->BlocksPerUnit; i++) {

        switch (BLOCK_TYPE(le32_to_cpu(part->bam_cache[i]))) {

        case BLOCK_CONTROL:

            /* This gets updated later */

            break;

        case BLOCK_DATA:

        case BLOCK_REPLACEMENT:

            ret = part->mtd->read(part->mtd, src, SECTOR_SIZE,

                        &retlen, (u_char *) buf);

            if (ret) {

                printk(KERN_WARNING "ftl: Error reading old xfer unit in copy_erase_unit\n");

                return ret;

            }

            ret = part->mtd->write(part->mtd, dest, SECTOR_SIZE,

                        &retlen, (u_char *) buf);

            if (ret)  {

                printk(KERN_WARNING "ftl: Error writing new xfer unit in copy_erase_unit\n");

                return ret;

            }

            break;

        default:

            /* All other blocks must be free */

            part->bam_cache[i] = cpu_to_le32(0xffffffff);

            free++;

            break;

        }

        src += SECTOR_SIZE;

        dest += SECTOR_SIZE;

    }

    /* Write the BAM to the transfer unit */

    ret = part->mtd->write(part->mtd, xfer->Offset + le32_to_cpu(part->header.BAMOffset),

                    part->BlocksPerUnit * sizeof(int32_t), &retlen,

                    (u_char *)part->bam_cache);

    if (ret) {

        printk( KERN_WARNING "ftl: Error writing BAM in copy_erase_unit\n");

        return ret;

    }

    /* All clear? Then update the LogicalEUN again */

    ret = part->mtd->write(part->mtd, xfer->Offset + 20, sizeof(u_int16_t),

                           &retlen, (u_char *)&srcunitswap);

    if (ret) {

        printk(KERN_WARNING "ftl: Error writing new LogicalEUN in copy_erase_unit\n");

        return ret;

    }

    /* Update the maps and usage stats*/

    i = xfer->EraseCount;

    xfer->EraseCount = eun->EraseCount;

    eun->EraseCount = i;

    i = xfer->Offset;

    xfer->Offset = eun->Offset;

    eun->Offset = i;