mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-10-30 16:07:39 +00:00
a152056c91
I got the following panic on my fsl p5020ds board. Unable to handle kernel paging request for data at address 0x7375627379737465 Faulting instruction address: 0xc000000000100778 Oops: Kernel access of bad area, sig: 11 [#1] SMP NR_CPUS=24 CoreNet Generic Modules linked in: CPU: 0 PID: 1 Comm: swapper/0 Not tainted 3.15.0-next-20140613 #145 task: c0000000fe080000 ti: c0000000fe088000 task.ti: c0000000fe088000 NIP: c000000000100778 LR: c00000000010073c CTR: 0000000000000000 REGS: c0000000fe08aa00 TRAP: 0300 Not tainted (3.15.0-next-20140613) MSR: 0000000080029000 <CE,EE,ME> CR: 24ad2e24 XER: 00000000 DEAR: 7375627379737465 ESR: 0000000000000000 SOFTE: 1 GPR00: c0000000000c99b0 c0000000fe08ac80 c0000000009598e0 c0000000fe001d80 GPR04: 00000000000000d0 0000000000000913 c000000007902b20 0000000000000000 GPR08: c0000000feaae888 0000000000000000 0000000007091000 0000000000200200 GPR12: 0000000028ad2e28 c00000000fff4000 c0000000007abe08 0000000000000000 GPR16: c0000000007ab160 c0000000007aaf98 c00000000060ba68 c0000000007abda8 GPR20: c0000000007abde8 c0000000feaea6f8 c0000000feaea708 c0000000007abd10 GPR24: c000000000989370 c0000000008c6228 00000000000041ed c0000000fe00a400 GPR28: c00000000017c1cc 00000000000000d0 7375627379737465 c0000000fe001d80 NIP [c000000000100778] .__kmalloc_track_caller+0x70/0x168 LR [c00000000010073c] .__kmalloc_track_caller+0x34/0x168 Call Trace: [c0000000fe08ac80] [c00000000087e6b8] uevent_sock_list+0x0/0x10 (unreliable) [c0000000fe08ad20] [c0000000000c99b0] .kstrdup+0x44/0x90 [c0000000fe08adc0] [c00000000017c1cc] .__kernfs_new_node+0x4c/0x130 [c0000000fe08ae70] [c00000000017d7e4] .kernfs_new_node+0x2c/0x64 [c0000000fe08aef0] [c00000000017db00] .kernfs_create_dir_ns+0x34/0xc8 [c0000000fe08af80] [c00000000018067c] .sysfs_create_dir_ns+0x58/0xcc [c0000000fe08b010] [c0000000002c711c] .kobject_add_internal+0xc8/0x384 [c0000000fe08b0b0] [c0000000002c7644] .kobject_add+0x64/0xc8 [c0000000fe08b140] [c000000000355ebc] .device_add+0x11c/0x654 [c0000000fe08b200] [c0000000002b5988] .add_disk+0x20c/0x4b4 [c0000000fe08b2c0] [c0000000003a21d4] .add_mtd_blktrans_dev+0x340/0x514 [c0000000fe08b350] [c0000000003a3410] .mtdblock_add_mtd+0x74/0xb4 [c0000000fe08b3e0] [c0000000003a32cc] .blktrans_notify_add+0x64/0x94 [c0000000fe08b470] [c00000000039b5b4] .add_mtd_device+0x1d4/0x368 [c0000000fe08b520] [c00000000039b830] .mtd_device_parse_register+0xe8/0x104 [c0000000fe08b5c0] [c0000000003b8408] .of_flash_probe+0x72c/0x734 [c0000000fe08b750] [c00000000035ba40] .platform_drv_probe+0x38/0x84 [c0000000fe08b7d0] [c0000000003599a4] .really_probe+0xa4/0x29c [c0000000fe08b870] [c000000000359d3c] .__driver_attach+0x100/0x104 [c0000000fe08b900] [c00000000035746c] .bus_for_each_dev+0x84/0xe4 [c0000000fe08b9a0] [c0000000003593c0] .driver_attach+0x24/0x38 [c0000000fe08ba10] [c000000000358f24] .bus_add_driver+0x1c8/0x2ac [c0000000fe08bab0] [c00000000035a3a4] .driver_register+0x8c/0x158 [c0000000fe08bb30] [c00000000035b9f4] .__platform_driver_register+0x6c/0x80 [c0000000fe08bba0] [c00000000084e080] .of_flash_driver_init+0x1c/0x30 [c0000000fe08bc10] [c000000000001864] .do_one_initcall+0xbc/0x238 [c0000000fe08bd00] [c00000000082cdc0] .kernel_init_freeable+0x188/0x268 [c0000000fe08bdb0] [c0000000000020a0] .kernel_init+0x1c/0xf7c [c0000000fe08be30] [c000000000000884] .ret_from_kernel_thread+0x58/0xd4 Instruction dump: 41bd0010 480000c8 4bf04eb5 60000000 e94d0028 e93f0000 7cc95214 e8a60008 7fc9502a 2fbe0000 419e00c8 e93f0022 <7f7e482a> 39200000 88ed06b2 992d06b2 ---[ end trace b4c9a94804a42d40 ]--- It seems that the corrupted partition header on my mtd device triggers a bug in the ftl. In function build_maps() it will allocate the buffers needed by the mtd partition, but if something goes wrong such as kmalloc failure, mtd read error or invalid partition header parameter, it will free all allocated buffers and then return non-zero. In my case, it seems that partition header parameter 'NumTransferUnits' is invalid. And the ftl_freepart() is a function which free all the partition buffers allocated by build_maps(). Given the build_maps() is a self cleaning function, so there is no need to invoke this function even if build_maps() return with error. Otherwise it will causes the buffers to be freed twice and then weird things would happen. Cc: stable@vger.kernel.org Signed-off-by: Kevin Hao <haokexin@gmail.com> Signed-off-by: Brian Norris <computersforpeace@gmail.com>
1114 lines
31 KiB
C
1114 lines
31 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 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->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,
|
|
};
|
|
|
|
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");
|