mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1063 lines
30 KiB
1063 lines
30 KiB
/* This version ported to the Linux-MTD system by [email protected] |
|
* |
|
* Fixes: Arnaldo Carvalho de Melo <[email protected]> |
|
* - 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 |
|
<[email protected]>. 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 <linux/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 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 |
|
|
|
/*====================================================================== |
|
|
|
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_array(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_array(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(array_size(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_array(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->addr = xfer->Offset; |
|
erase->len = 1 << part->header.EraseUnitSize; |
|
|
|
ret = mtd_erase(part->mbd.mtd, erase); |
|
if (!ret) { |
|
xfer->state = XFER_ERASED; |
|
xfer->EraseCount++; |
|
} else { |
|
xfer->state = XFER_FAILED; |
|
pr_notice("ftl_cs: erase failed: err = %d\n", ret); |
|
} |
|
|
|
kfree(erase); |
|
|
|
return ret; |
|
} /* erase_xfer */ |
|
|
|
/*====================================================================== |
|
|
|
Prepare_xfer() takes a freshly erased transfer unit and gives |
|
it an appropriate header. |
|
|
|
======================================================================*/ |
|
|
|
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 = DIV_ROUND_UP(part->BlocksPerUnit * sizeof(uint32_t) + |
|
le32_to_cpu(part->header.BAMOffset), 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*/ |
|
swap(xfer->EraseCount, eun->EraseCount); |
|
swap(xfer->Offset, eun->Offset); |
|
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->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; |
|
} |
|
|
|
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, |
|
}; |
|
|
|
module_mtd_blktrans(ftl_tr); |
|
|
|
MODULE_LICENSE("Dual MPL/GPL"); |
|
MODULE_AUTHOR("David Hinds <[email protected]>"); |
|
MODULE_DESCRIPTION("Support code for Flash Translation Layer, used on PCMCIA devices");
|
|
|