mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-21 16:29:59 +00:00
![Artem Bityutskiy](/assets/img/avatar_default.png)
This patch teaches 'mtd_sync()' to do nothing when the MTD driver does not have the '->sync()' method, which allows us to remove all direct 'mtd->sync' accesses. Signed-off-by: Artem Bityutskiy <artem.bityutskiy@linux.intel.com> Signed-off-by: David Woodhouse <David.Woodhouse@intel.com>
1118 lines
32 KiB
C
1118 lines
32 KiB
C
/* This version ported to the Linux-MTD system by dwmw2@infradead.org
|
|
*
|
|
* 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 © 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 directly. M-Systems since acquired by Sandisk.
|
|
|
|
======================================================================*/
|
|
#include <linux/mtd/blktrans.h>
|
|
#include <linux/module.h>
|
|
#include <linux/mtd/mtd.h>
|
|
/*#define PSYCHO_DEBUG */
|
|
|
|
#include <linux/kernel.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/init.h>
|
|
#include <linux/hdreg.h>
|
|
#include <linux/vmalloc.h>
|
|
#include <linux/blkpg.h>
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <linux/mtd/ftl.h>
|
|
|
|
/*====================================================================*/
|
|
|
|
/* Parameters that can be set with 'insmod' */
|
|
static int shuffle_freq = 50;
|
|
module_param(shuffle_freq, int, 0);
|
|
|
|
/*====================================================================*/
|
|
|
|
/* Major device # for FTL device */
|
|
#ifndef FTL_MAJOR
|
|
#define FTL_MAJOR 44
|
|
#endif
|
|
|
|
|
|
/*====================================================================*/
|
|
|
|
/* 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 4
|
|
|
|
/* 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_blktrans_dev mbd;
|
|
uint32_t state;
|
|
uint32_t *VirtualBlockMap;
|
|
uint32_t *VirtualPageMap;
|
|
uint32_t FreeTotal;
|
|
struct eun_info_t {
|
|
uint32_t Offset;
|
|
uint32_t EraseCount;
|
|
uint32_t Free;
|
|
uint32_t Deleted;
|
|
} *EUNInfo;
|
|
struct xfer_info_t {
|
|
uint32_t Offset;
|
|
uint32_t EraseCount;
|
|
uint16_t state;
|
|
} *XferInfo;
|
|
uint16_t bam_index;
|
|
uint32_t *bam_cache;
|
|
uint16_t DataUnits;
|
|
uint32_t BlocksPerUnit;
|
|
erase_unit_header_t header;
|
|
} partition_t;
|
|
|
|
/* 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 void ftl_erase_callback(struct erase_info *done);
|
|
|
|
|
|
/*======================================================================
|
|
|
|
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;
|
|
size_t ret;
|
|
int err;
|
|
part->header.FormattedSize = 0;
|
|
max_offset = (0x100000<part->mbd.mtd->size)?0x100000:part->mbd.mtd->size;
|
|
/* Search first megabyte for a valid FTL header */
|
|
for (offset = 0;
|
|
(offset + sizeof(header)) < max_offset;
|
|
offset += part->mbd.mtd->erasesize ? : 0x2000) {
|
|
|
|
err = mtd_read(part->mbd.mtd, offset, sizeof(header), &ret,
|
|
(unsigned char *)&header);
|
|
|
|
if (err)
|
|
return err;
|
|
|
|
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 (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->mbd.mtd->erasesize) {
|
|
printk(KERN_NOTICE "ftl: FTL EraseUnitSize %x != MTD erasesize %x\n",
|
|
1 << header.EraseUnitSize,part->mbd.mtd->erasesize);
|
|
return -1;
|
|
}
|
|
part->header = header;
|
|
return 0;
|
|
}
|
|
|
|
static int build_maps(partition_t *part)
|
|
{
|
|
erase_unit_header_t header;
|
|
uint16_t xvalid, xtrans, i;
|
|
unsigned 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 = mtd_read(part->mbd.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(uint32_t));
|
|
if (!part->VirtualBlockMap)
|
|
goto out_XferInfo;
|
|
|
|
memset(part->VirtualBlockMap, 0xff, blocks * sizeof(uint32_t));
|
|
part->BlocksPerUnit = (1 << header.EraseUnitSize) >> header.BlockSize;
|
|
|
|
part->bam_cache = kmalloc(part->BlocksPerUnit * sizeof(uint32_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 = mtd_read(part->mbd.mtd, offset,
|
|
part->BlocksPerUnit * sizeof(uint32_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,
|
|
uint16_t xfernum)
|
|
{
|
|
int ret;
|
|
struct xfer_info_t *xfer;
|
|
struct erase_info *erase;
|
|
|
|
xfer = &part->XferInfo[xfernum];
|
|
pr_debug("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->mtd = part->mbd.mtd;
|
|
erase->callback = ftl_erase_callback;
|
|
erase->addr = xfer->Offset;
|
|
erase->len = 1 << part->header.EraseUnitSize;
|
|
erase->priv = (u_long)part;
|
|
|
|
ret = mtd_erase(part->mbd.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;
|
|
uint32_t ctl;
|
|
ssize_t retlen;
|
|
loff_t offset;
|
|
|
|
xfer = &part->XferInfo[i];
|
|
xfer->state = XFER_FAILED;
|
|
|
|
pr_debug("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 = mtd_write(part->mbd.mtd, xfer->Offset, sizeof(header), &retlen,
|
|
(u_char *)&header);
|
|
|
|
if (ret) {
|
|
return ret;
|
|
}
|
|
|
|
/* Write the BAM stub */
|
|
nbam = (part->BlocksPerUnit * sizeof(uint32_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(uint32_t)) {
|
|
|
|
ret = mtd_write(part->mbd.mtd, offset, sizeof(uint32_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, uint16_t srcunit,
|
|
uint16_t xferunit)
|
|
{
|
|
u_char buf[SECTOR_SIZE];
|
|
struct eun_info_t *eun;
|
|
struct xfer_info_t *xfer;
|
|
uint32_t src, dest, free, i;
|
|
uint16_t unit;
|
|
int ret;
|
|
ssize_t retlen;
|
|
loff_t offset;
|
|
uint16_t srcunitswap = cpu_to_le16(srcunit);
|
|
|
|
eun = &part->EUNInfo[srcunit];
|
|
xfer = &part->XferInfo[xferunit];
|
|
pr_debug("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 = mtd_read(part->mbd.mtd, offset,
|
|
part->BlocksPerUnit * sizeof(uint32_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 = mtd_write(part->mbd.mtd, offset, sizeof(uint16_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 = mtd_read(part->mbd.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 = mtd_write(part->mbd.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 = mtd_write(part->mbd.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 = mtd_write(part->mbd.mtd, xfer->Offset + 20, sizeof(uint16_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;
|
|
part->FreeTotal -= eun->Free;
|
|
part->FreeTotal += free;
|
|
eun->Free = free;
|
|
eun->Deleted = 0;
|
|
|
|
/* Now, the cache should be valid for the new block */
|
|
part->bam_index = srcunit;
|
|
|
|
return 0;
|
|
} /* copy_erase_unit */
|
|
|
|
/*======================================================================
|
|
|
|
reclaim_block() picks a full erase unit and a transfer unit and
|
|
then calls copy_erase_unit() to copy one to the other. Then, it
|
|
schedules an erase on the expired block.
|
|
|
|
What's a good way to decide which transfer unit and which erase
|
|
unit to use? Beats me. My way is to always pick the transfer
|
|
unit with the fewest erases, and usually pick the data unit with
|
|
the most deleted blocks. But with a small probability, pick the
|
|
oldest data unit instead. This means that we generally postpone
|
|
the next reclamation as long as possible, but shuffle static
|
|
stuff around a bit for wear leveling.
|
|
|
|
======================================================================*/
|
|
|
|
static int reclaim_block(partition_t *part)
|
|
{
|
|
uint16_t i, eun, xfer;
|
|
uint32_t best;
|
|
int queued, ret;
|
|
|
|
pr_debug("ftl_cs: reclaiming space...\n");
|
|
pr_debug("NumTransferUnits == %x\n", part->header.NumTransferUnits);
|
|
/* Pick the least erased transfer unit */
|
|
best = 0xffffffff; xfer = 0xffff;
|
|
do {
|
|
queued = 0;
|
|
for (i = 0; i < part->header.NumTransferUnits; i++) {
|
|
int n=0;
|
|
if (part->XferInfo[i].state == XFER_UNKNOWN) {
|
|
pr_debug("XferInfo[%d].state == XFER_UNKNOWN\n",i);
|
|
n=1;
|
|
erase_xfer(part, i);
|
|
}
|
|
if (part->XferInfo[i].state == XFER_ERASING) {
|
|
pr_debug("XferInfo[%d].state == XFER_ERASING\n",i);
|
|
n=1;
|
|
queued = 1;
|
|
}
|
|
else if (part->XferInfo[i].state == XFER_ERASED) {
|
|
pr_debug("XferInfo[%d].state == XFER_ERASED\n",i);
|
|
n=1;
|
|
prepare_xfer(part, i);
|
|
}
|
|
if (part->XferInfo[i].state == XFER_PREPARED) {
|
|
pr_debug("XferInfo[%d].state == XFER_PREPARED\n",i);
|
|
n=1;
|
|
if (part->XferInfo[i].EraseCount <= best) {
|
|
best = part->XferInfo[i].EraseCount;
|
|
xfer = i;
|
|
}
|
|
}
|
|
if (!n)
|
|
pr_debug("XferInfo[%d].state == %x\n",i, part->XferInfo[i].state);
|
|
|
|
}
|
|
if (xfer == 0xffff) {
|
|
if (queued) {
|
|
pr_debug("ftl_cs: waiting for transfer "
|
|
"unit to be prepared...\n");
|
|
mtd_sync(part->mbd.mtd);
|
|
} else {
|
|
static int ne = 0;
|
|
if (++ne < 5)
|
|
printk(KERN_NOTICE "ftl_cs: reclaim failed: no "
|
|
"suitable transfer units!\n");
|
|
else
|
|
pr_debug("ftl_cs: reclaim failed: no "
|
|
"suitable transfer units!\n");
|
|
|
|
return -EIO;
|
|
}
|
|
}
|
|
} while (xfer == 0xffff);
|
|
|
|
eun = 0;
|
|
if ((jiffies % shuffle_freq) == 0) {
|
|
pr_debug("ftl_cs: recycling freshest block...\n");
|
|
best = 0xffffffff;
|
|
for (i = 0; i < part->DataUnits; i++)
|
|
if (part->EUNInfo[i].EraseCount <= best) {
|
|
best = part->EUNInfo[i].EraseCount;
|
|
eun = i;
|
|
}
|
|
} else {
|
|
best = 0;
|
|
for (i = 0; i < part->DataUnits; i++)
|
|
if (part->EUNInfo[i].Deleted >= best) {
|
|
best = part->EUNInfo[i].Deleted;
|
|
eun = i;
|
|
}
|
|
if (best == 0) {
|
|
static int ne = 0;
|
|
if (++ne < 5)
|
|
printk(KERN_NOTICE "ftl_cs: reclaim failed: "
|
|
"no free blocks!\n");
|
|
else
|
|
pr_debug("ftl_cs: reclaim failed: "
|
|
"no free blocks!\n");
|
|
|
|
return -EIO;
|
|
}
|
|
}
|
|
ret = copy_erase_unit(part, eun, xfer);
|
|
if (!ret)
|
|
erase_xfer(part, xfer);
|
|
else
|
|
printk(KERN_NOTICE "ftl_cs: copy_erase_unit failed!\n");
|
|
return ret;
|
|
} /* reclaim_block */
|
|
|
|
/*======================================================================
|
|
|
|
Find_free() searches for a free block. If necessary, it updates
|
|
the BAM cache for the erase unit containing the free block. It
|
|
returns the block index -- the erase unit is just the currently
|
|
cached unit. If there are no free blocks, it returns 0 -- this
|
|
is never a valid data block because it contains the header.
|
|
|
|
======================================================================*/
|
|
|
|
#ifdef PSYCHO_DEBUG
|
|
static void dump_lists(partition_t *part)
|
|
{
|
|
int i;
|
|
printk(KERN_DEBUG "ftl_cs: Free total = %d\n", part->FreeTotal);
|
|
for (i = 0; i < part->DataUnits; i++)
|
|
printk(KERN_DEBUG "ftl_cs: unit %d: %d phys, %d free, "
|
|
"%d deleted\n", i,
|
|
part->EUNInfo[i].Offset >> part->header.EraseUnitSize,
|
|
part->EUNInfo[i].Free, part->EUNInfo[i].Deleted);
|
|
}
|
|
#endif
|
|
|
|
static uint32_t find_free(partition_t *part)
|
|
{
|
|
uint16_t stop, eun;
|
|
uint32_t blk;
|
|
size_t retlen;
|
|
int ret;
|
|
|
|
/* Find an erase unit with some free space */
|
|
stop = (part->bam_index == 0xffff) ? 0 : part->bam_index;
|
|
eun = stop;
|
|
do {
|
|
if (part->EUNInfo[eun].Free != 0) break;
|
|
/* Wrap around at end of table */
|
|
if (++eun == part->DataUnits) eun = 0;
|
|
} while (eun != stop);
|
|
|
|
if (part->EUNInfo[eun].Free == 0)
|
|
return 0;
|
|
|
|
/* Is this unit's BAM cached? */
|
|
if (eun != part->bam_index) {
|
|
/* Invalidate cache */
|
|
part->bam_index = 0xffff;
|
|
|
|
ret = mtd_read(part->mbd.mtd,
|
|
part->EUNInfo[eun].Offset + le32_to_cpu(part->header.BAMOffset),
|
|
part->BlocksPerUnit * sizeof(uint32_t),
|
|
&retlen,
|
|
(u_char *)(part->bam_cache));
|
|
|
|
if (ret) {
|
|
printk(KERN_WARNING"ftl: Error reading BAM in find_free\n");
|
|
return 0;
|
|
}
|
|
part->bam_index = eun;
|
|
}
|
|
|
|
/* Find a free block */
|
|
for (blk = 0; blk < part->BlocksPerUnit; blk++)
|
|
if (BLOCK_FREE(le32_to_cpu(part->bam_cache[blk]))) break;
|
|
if (blk == part->BlocksPerUnit) {
|
|
#ifdef PSYCHO_DEBUG
|
|
static int ne = 0;
|
|
if (++ne == 1)
|
|
dump_lists(part);
|
|
#endif
|
|
printk(KERN_NOTICE "ftl_cs: bad free list!\n");
|
|
return 0;
|
|
}
|
|
pr_debug("ftl_cs: found free block at %d in %d\n", blk, eun);
|
|
return blk;
|
|
|
|
} /* find_free */
|
|
|
|
|
|
/*======================================================================
|
|
|
|
Read a series of sectors from an FTL partition.
|
|
|
|
======================================================================*/
|
|
|
|
static int ftl_read(partition_t *part, caddr_t buffer,
|
|
u_long sector, u_long nblocks)
|
|
{
|
|
uint32_t log_addr, bsize;
|
|
u_long i;
|
|
int ret;
|
|
size_t offset, retlen;
|
|
|
|
pr_debug("ftl_cs: ftl_read(0x%p, 0x%lx, %ld)\n",
|
|
part, sector, nblocks);
|
|
if (!(part->state & FTL_FORMATTED)) {
|
|
printk(KERN_NOTICE "ftl_cs: bad partition\n");
|
|
return -EIO;
|
|
}
|
|
bsize = 1 << part->header.EraseUnitSize;
|
|
|
|
for (i = 0; i < nblocks; i++) {
|
|
if (((sector+i) * SECTOR_SIZE) >= le32_to_cpu(part->header.FormattedSize)) {
|
|
printk(KERN_NOTICE "ftl_cs: bad read offset\n");
|
|
return -EIO;
|
|
}
|
|
log_addr = part->VirtualBlockMap[sector+i];
|
|
if (log_addr == 0xffffffff)
|
|
memset(buffer, 0, SECTOR_SIZE);
|
|
else {
|
|
offset = (part->EUNInfo[log_addr / bsize].Offset
|
|
+ (log_addr % bsize));
|
|
ret = mtd_read(part->mbd.mtd, offset, SECTOR_SIZE, &retlen,
|
|
(u_char *)buffer);
|
|
|
|
if (ret) {
|
|
printk(KERN_WARNING "Error reading MTD device in ftl_read()\n");
|
|
return ret;
|
|
}
|
|
}
|
|
buffer += SECTOR_SIZE;
|
|
}
|
|
return 0;
|
|
} /* ftl_read */
|
|
|
|
/*======================================================================
|
|
|
|
Write a series of sectors to an FTL partition
|
|
|
|
======================================================================*/
|
|
|
|
static int set_bam_entry(partition_t *part, uint32_t log_addr,
|
|
uint32_t virt_addr)
|
|
{
|
|
uint32_t bsize, blk, le_virt_addr;
|
|
#ifdef PSYCHO_DEBUG
|
|
uint32_t old_addr;
|
|
#endif
|
|
uint16_t eun;
|
|
int ret;
|
|
size_t retlen, offset;
|
|
|
|
pr_debug("ftl_cs: set_bam_entry(0x%p, 0x%x, 0x%x)\n",
|
|
part, log_addr, virt_addr);
|
|
bsize = 1 << part->header.EraseUnitSize;
|
|
eun = log_addr / bsize;
|
|
blk = (log_addr % bsize) / SECTOR_SIZE;
|
|
offset = (part->EUNInfo[eun].Offset + blk * sizeof(uint32_t) +
|
|
le32_to_cpu(part->header.BAMOffset));
|
|
|
|
#ifdef PSYCHO_DEBUG
|
|
ret = mtd_read(part->mbd.mtd, offset, sizeof(uint32_t), &retlen,
|
|
(u_char *)&old_addr);
|
|
if (ret) {
|
|
printk(KERN_WARNING"ftl: Error reading old_addr in set_bam_entry: %d\n",ret);
|
|
return ret;
|
|
}
|
|
old_addr = le32_to_cpu(old_addr);
|
|
|
|
if (((virt_addr == 0xfffffffe) && !BLOCK_FREE(old_addr)) ||
|
|
((virt_addr == 0) && (BLOCK_TYPE(old_addr) != BLOCK_DATA)) ||
|
|
(!BLOCK_DELETED(virt_addr) && (old_addr != 0xfffffffe))) {
|
|
static int ne = 0;
|
|
if (++ne < 5) {
|
|
printk(KERN_NOTICE "ftl_cs: set_bam_entry() inconsistency!\n");
|
|
printk(KERN_NOTICE "ftl_cs: log_addr = 0x%x, old = 0x%x"
|
|
", new = 0x%x\n", log_addr, old_addr, virt_addr);
|
|
}
|
|
return -EIO;
|
|
}
|
|
#endif
|
|
le_virt_addr = cpu_to_le32(virt_addr);
|
|
if (part->bam_index == eun) {
|
|
#ifdef PSYCHO_DEBUG
|
|
if (le32_to_cpu(part->bam_cache[blk]) != old_addr) {
|
|
static int ne = 0;
|
|
if (++ne < 5) {
|
|
printk(KERN_NOTICE "ftl_cs: set_bam_entry() "
|
|
"inconsistency!\n");
|
|
printk(KERN_NOTICE "ftl_cs: log_addr = 0x%x, cache"
|
|
" = 0x%x\n",
|
|
le32_to_cpu(part->bam_cache[blk]), old_addr);
|
|
}
|
|
return -EIO;
|
|
}
|
|
#endif
|
|
part->bam_cache[blk] = le_virt_addr;
|
|
}
|
|
ret = mtd_write(part->mbd.mtd, offset, sizeof(uint32_t), &retlen,
|
|
(u_char *)&le_virt_addr);
|
|
|
|
if (ret) {
|
|
printk(KERN_NOTICE "ftl_cs: set_bam_entry() failed!\n");
|
|
printk(KERN_NOTICE "ftl_cs: log_addr = 0x%x, new = 0x%x\n",
|
|
log_addr, virt_addr);
|
|
}
|
|
return ret;
|
|
} /* set_bam_entry */
|
|
|
|
static int ftl_write(partition_t *part, caddr_t buffer,
|
|
u_long sector, u_long nblocks)
|
|
{
|
|
uint32_t bsize, log_addr, virt_addr, old_addr, blk;
|
|
u_long i;
|
|
int ret;
|
|
size_t retlen, offset;
|
|
|
|
pr_debug("ftl_cs: ftl_write(0x%p, %ld, %ld)\n",
|
|
part, sector, nblocks);
|
|
if (!(part->state & FTL_FORMATTED)) {
|
|
printk(KERN_NOTICE "ftl_cs: bad partition\n");
|
|
return -EIO;
|
|
}
|
|
/* See if we need to reclaim space, before we start */
|
|
while (part->FreeTotal < nblocks) {
|
|
ret = reclaim_block(part);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
|
|
bsize = 1 << part->header.EraseUnitSize;
|
|
|
|
virt_addr = sector * SECTOR_SIZE | BLOCK_DATA;
|
|
for (i = 0; i < nblocks; i++) {
|
|
if (virt_addr >= le32_to_cpu(part->header.FormattedSize)) {
|
|
printk(KERN_NOTICE "ftl_cs: bad write offset\n");
|
|
return -EIO;
|
|
}
|
|
|
|
/* Grab a free block */
|
|
blk = find_free(part);
|
|
if (blk == 0) {
|
|
static int ne = 0;
|
|
if (++ne < 5)
|
|
printk(KERN_NOTICE "ftl_cs: internal error: "
|
|
"no free blocks!\n");
|
|
return -ENOSPC;
|
|
}
|
|
|
|
/* Tag the BAM entry, and write the new block */
|
|
log_addr = part->bam_index * bsize + blk * SECTOR_SIZE;
|
|
part->EUNInfo[part->bam_index].Free--;
|
|
part->FreeTotal--;
|
|
if (set_bam_entry(part, log_addr, 0xfffffffe))
|
|
return -EIO;
|
|
part->EUNInfo[part->bam_index].Deleted++;
|
|
offset = (part->EUNInfo[part->bam_index].Offset +
|
|
blk * SECTOR_SIZE);
|
|
ret = mtd_write(part->mbd.mtd, offset, SECTOR_SIZE, &retlen, buffer);
|
|
|
|
if (ret) {
|
|
printk(KERN_NOTICE "ftl_cs: block write failed!\n");
|
|
printk(KERN_NOTICE "ftl_cs: log_addr = 0x%x, virt_addr"
|
|
" = 0x%x, Offset = 0x%zx\n", log_addr, virt_addr,
|
|
offset);
|
|
return -EIO;
|
|
}
|
|
|
|
/* Only delete the old entry when the new entry is ready */
|
|
old_addr = part->VirtualBlockMap[sector+i];
|
|
if (old_addr != 0xffffffff) {
|
|
part->VirtualBlockMap[sector+i] = 0xffffffff;
|
|
part->EUNInfo[old_addr/bsize].Deleted++;
|
|
if (set_bam_entry(part, old_addr, 0))
|
|
return -EIO;
|
|
}
|
|
|
|
/* Finally, set up the new pointers */
|
|
if (set_bam_entry(part, log_addr, virt_addr))
|
|
return -EIO;
|
|
part->VirtualBlockMap[sector+i] = log_addr;
|
|
part->EUNInfo[part->bam_index].Deleted--;
|
|
|
|
buffer += SECTOR_SIZE;
|
|
virt_addr += SECTOR_SIZE;
|
|
}
|
|
return 0;
|
|
} /* ftl_write */
|
|
|
|
static int ftl_getgeo(struct mtd_blktrans_dev *dev, struct hd_geometry *geo)
|
|
{
|
|
partition_t *part = (void *)dev;
|
|
u_long sect;
|
|
|
|
/* Sort of arbitrary: round size down to 4KiB boundary */
|
|
sect = le32_to_cpu(part->header.FormattedSize)/SECTOR_SIZE;
|
|
|
|
geo->heads = 1;
|
|
geo->sectors = 8;
|
|
geo->cylinders = sect >> 3;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int ftl_readsect(struct mtd_blktrans_dev *dev,
|
|
unsigned long block, char *buf)
|
|
{
|
|
return ftl_read((void *)dev, buf, block, 1);
|
|
}
|
|
|
|
static int ftl_writesect(struct mtd_blktrans_dev *dev,
|
|
unsigned long block, char *buf)
|
|
{
|
|
return ftl_write((void *)dev, buf, block, 1);
|
|
}
|
|
|
|
static int ftl_discardsect(struct mtd_blktrans_dev *dev,
|
|
unsigned long sector, unsigned nr_sects)
|
|
{
|
|
partition_t *part = (void *)dev;
|
|
uint32_t bsize = 1 << part->header.EraseUnitSize;
|
|
|
|
pr_debug("FTL erase sector %ld for %d sectors\n",
|
|
sector, nr_sects);
|
|
|
|
while (nr_sects) {
|
|
uint32_t old_addr = part->VirtualBlockMap[sector];
|
|
if (old_addr != 0xffffffff) {
|
|
part->VirtualBlockMap[sector] = 0xffffffff;
|
|
part->EUNInfo[old_addr/bsize].Deleted++;
|
|
if (set_bam_entry(part, old_addr, 0))
|
|
return -EIO;
|
|
}
|
|
nr_sects--;
|
|
sector++;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
/*====================================================================*/
|
|
|
|
static void ftl_freepart(partition_t *part)
|
|
{
|
|
vfree(part->VirtualBlockMap);
|
|
part->VirtualBlockMap = NULL;
|
|
kfree(part->VirtualPageMap);
|
|
part->VirtualPageMap = NULL;
|
|
kfree(part->EUNInfo);
|
|
part->EUNInfo = NULL;
|
|
kfree(part->XferInfo);
|
|
part->XferInfo = NULL;
|
|
kfree(part->bam_cache);
|
|
part->bam_cache = NULL;
|
|
} /* ftl_freepart */
|
|
|
|
static void ftl_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd)
|
|
{
|
|
partition_t *partition;
|
|
|
|
partition = kzalloc(sizeof(partition_t), GFP_KERNEL);
|
|
|
|
if (!partition) {
|
|
printk(KERN_WARNING "No memory to scan for FTL on %s\n",
|
|
mtd->name);
|
|
return;
|
|
}
|
|
|
|
partition->mbd.mtd = mtd;
|
|
|
|
if ((scan_header(partition) == 0) &&
|
|
(build_maps(partition) == 0)) {
|
|
|
|
partition->state = FTL_FORMATTED;
|
|
#ifdef PCMCIA_DEBUG
|
|
printk(KERN_INFO "ftl_cs: opening %d KiB FTL partition\n",
|
|
le32_to_cpu(partition->header.FormattedSize) >> 10);
|
|
#endif
|
|
partition->mbd.size = le32_to_cpu(partition->header.FormattedSize) >> 9;
|
|
|
|
partition->mbd.tr = tr;
|
|
partition->mbd.devnum = -1;
|
|
if (!add_mtd_blktrans_dev((void *)partition))
|
|
return;
|
|
}
|
|
|
|
ftl_freepart(partition);
|
|
kfree(partition);
|
|
}
|
|
|
|
static void ftl_remove_dev(struct mtd_blktrans_dev *dev)
|
|
{
|
|
del_mtd_blktrans_dev(dev);
|
|
ftl_freepart((partition_t *)dev);
|
|
}
|
|
|
|
static struct mtd_blktrans_ops ftl_tr = {
|
|
.name = "ftl",
|
|
.major = FTL_MAJOR,
|
|
.part_bits = PART_BITS,
|
|
.blksize = SECTOR_SIZE,
|
|
.readsect = ftl_readsect,
|
|
.writesect = ftl_writesect,
|
|
.discard = ftl_discardsect,
|
|
.getgeo = ftl_getgeo,
|
|
.add_mtd = ftl_add_mtd,
|
|
.remove_dev = ftl_remove_dev,
|
|
.owner = THIS_MODULE,
|
|
};
|
|
|
|
static int __init init_ftl(void)
|
|
{
|
|
return register_mtd_blktrans(&ftl_tr);
|
|
}
|
|
|
|
static void __exit cleanup_ftl(void)
|
|
{
|
|
deregister_mtd_blktrans(&ftl_tr);
|
|
}
|
|
|
|
module_init(init_ftl);
|
|
module_exit(cleanup_ftl);
|
|
|
|
|
|
MODULE_LICENSE("Dual MPL/GPL");
|
|
MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
|
|
MODULE_DESCRIPTION("Support code for Flash Translation Layer, used on PCMCIA devices");
|