开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
ftl.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：40k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

ftl.c：源码内容
  1. /* This version ported to the Linux-MTD system by dwmw2@infradead.org
  2.  * $Id: ftl.c,v 1.43 2002/02/13 15:31:37 dwmw2 Exp $
  3.  *
  4.  * Fixes: Arnaldo Carvalho de Melo <acme@conectiva.com.br>
  5.  * - fixes some leaks on failure in build_maps and ftl_notify_add, cleanups
  6.  *
  7.  * Based on:
  8.  */
  9. /*======================================================================
  11.     A Flash Translation Layer memory card driver
  13.     This driver implements a disk-like block device driver with an
  14.     apparent block size of 512 bytes for flash memory cards.
  16.     ftl_cs.c 1.62 2000/02/01 00:59:04
  18.     The contents of this file are subject to the Mozilla Public
  19.     License Version 1.1 (the "License"); you may not use this file
  20.     except in compliance with the License. You may obtain a copy of
  21.     the License at http://www.mozilla.org/MPL/
  23.     Software distributed under the License is distributed on an "AS
  24.     IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  25.     implied. See the License for the specific language governing
  26.     rights and limitations under the License.
  28.     The initial developer of the original code is David A. Hinds
  29.     <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
  30.     are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
  32.     Alternatively, the contents of this file may be used under the
  33.     terms of the GNU General Public License version 2 (the "GPL"), in
  34.     which case the provisions of the GPL are applicable instead of the
  35.     above.  If you wish to allow the use of your version of this file
  36.     only under the terms of the GPL and not to allow others to use
  37.     your version of this file under the MPL, indicate your decision
  38.     by deleting the provisions above and replace them with the notice
  39.     and other provisions required by the GPL.  If you do not delete
  40.     the provisions above, a recipient may use your version of this
  41.     file under either the MPL or the GPL.
  43.     LEGAL NOTE: The FTL format is patented by M-Systems.  They have
  44.     granted a license for its use with PCMCIA devices:
  46.      "M-Systems grants a royalty-free, non-exclusive license under
  47.       any presently existing M-Systems intellectual property rights
  48.       necessary for the design and development of FTL-compatible
  49.       drivers, file systems and utilities using the data formats with
  50.       PCMCIA PC Cards as described in the PCMCIA Flash Translation
  51.       Layer (FTL) Specification."
  53.     Use of the FTL format for non-PCMCIA applications may be an
  54.     infringement of these patents.  For additional information,
  55.     contact M-Systems (http://www.m-sys.com) directly.
  56.       
  57. ======================================================================*/
  58. #include <linux/module.h>
  59. #include <linux/mtd/compatmac.h>
  60. #include <linux/mtd/mtd.h>
  61. /*#define PSYCHO_DEBUG */
  63. #include <linux/kernel.h>
  64. #include <linux/sched.h>
  65. #include <linux/ptrace.h>
  66. #include <linux/slab.h>
  67. #include <linux/string.h>
  68. #include <linux/timer.h>
  69. #include <linux/major.h>
  70. #include <linux/fs.h>
  71. #include <linux/ioctl.h>
  72. #include <linux/hdreg.h>
  73. #include <stdarg.h>
  75. #if (LINUX_VERSION_CODE >= 0x20100)
  76. #include <linux/vmalloc.h>
  77. #endif
  78. #if (LINUX_VERSION_CODE >= 0x20303)
  79. #include <linux/blkpg.h>
  80. #endif
  82. #include <linux/mtd/ftl.h>
  83. /*====================================================================*/
  84. /* Stuff which really ought to be in compatmac.h */
  86. #if (LINUX_VERSION_CODE < 0x20328)
  87. #define register_disk(dev, drive, minors, ops, size) 
  88.     do { (dev)->part[(drive)*(minors)].nr_sects = size; 
  89.         if (size == 0) (dev)->part[(drive)*(minors)].start_sect = -1; 
  90.         resetup_one_dev(dev, drive); } while (0)
  91. #endif
  93. #if (LINUX_VERSION_CODE < 0x20320)
  94. #define BLK_DEFAULT_QUEUE(n)    blk_dev[n].request_fn
  95. #define blk_init_queue(q, req)  q = (req)
  96. #define blk_cleanup_queue(q)    q = NULL
  97. #define request_arg_t           void
  98. #else
  99. #define request_arg_t           request_queue_t *q
  100. #endif
  102. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,14)
  103. #define BLK_INC_USE_COUNT MOD_INC_USE_COUNT
  104. #define BLK_DEC_USE_COUNT MOD_DEC_USE_COUNT
  105. #else
  106. #define BLK_INC_USE_COUNT do {} while(0)
  107. #define BLK_DEC_USE_COUNT do {} while(0)
  108. #endif
  110. /*====================================================================*/
  112. /* Parameters that can be set with 'insmod' */
  113. static int shuffle_freq = 50;
  114. MODULE_PARM(shuffle_freq, "i");
  116. /*====================================================================*/
  118. /* Major device # for FTL device */
  119. #ifndef FTL_MAJOR
  120. #define FTL_MAJOR 44
  121. #endif
  123. /* Funky stuff for setting up a block device */
  124. #define MAJOR_NR FTL_MAJOR
  125. #define DEVICE_NAME "ftl"
  126. #define DEVICE_REQUEST do_ftl_request
  127. #define DEVICE_ON(device)
  128. #define DEVICE_OFF(device)
  130. #define DEVICE_NR(minor) ((minor)>>5)
  131. #define REGION_NR(minor) (((minor)>>3)&3)
  132. #define PART_NR(minor) ((minor)&7)
  133. #define MINOR_NR(dev,reg,part) (((dev)<<5)+((reg)<<3)+(part))
  135. #include <linux/blk.h>
  137. /*====================================================================*/
  139. /* Maximum number of separate memory devices we'll allow */
  140. #define MAX_DEV 4
  142. /* Maximum number of regions per device */
  143. #define MAX_REGION 4
  145. /* Maximum number of partitions in an FTL region */
  146. #define PART_BITS 3
  147. #define MAX_PART 8
  149. /* Maximum number of outstanding erase requests per socket */
  150. #define MAX_ERASE 8
  152. /* Sector size -- shouldn't need to change */
  153. #define SECTOR_SIZE 512
  156. /* Each memory region corresponds to a minor device */
  157. typedef struct partition_t {
  158.     struct mtd_info *mtd;
  159.     u_int32_t state;
  160.     u_int32_t *VirtualBlockMap;
  161.     u_int32_t *VirtualPageMap;
  162.     u_int32_t FreeTotal;
  163.     struct eun_info_t {
  164. u_int32_t Offset;
  165. u_int32_t EraseCount;
  166. u_int32_t Free;
  167. u_int32_t Deleted;
  168.     } *EUNInfo;
  169.     struct xfer_info_t {
  170. u_int32_t Offset;
  171. u_int32_t EraseCount;
  172. u_int16_t state;
  173.     } *XferInfo;
  174.     u_int16_t bam_index;
  175.     u_int32_t *bam_cache;
  176.     u_int16_t DataUnits;
  177.     u_int32_t BlocksPerUnit;
  178.     erase_unit_header_t header;
  179. #if 0
  180.     region_info_t region;
  181.     memory_handle_t handle;
  182. #endif
  183.     atomic_t open;
  184. } partition_t;
  186. partition_t *myparts[MAX_MTD_DEVICES];
  188. static void ftl_notify_add(struct mtd_info *mtd);
  189. static void ftl_notify_remove(struct mtd_info *mtd);
  191. void ftl_freepart(partition_t *part);
  193. static struct mtd_notifier ftl_notifier = {
  194. add: ftl_notify_add,
  195. remove: ftl_notify_remove,
  196. };
  198. /* Partition state flags */
  199. #define FTL_FORMATTED 0x01
  201. /* Transfer unit states */
  202. #define XFER_UNKNOWN 0x00
  203. #define XFER_ERASING 0x01
  204. #define XFER_ERASED 0x02
  205. #define XFER_PREPARED 0x03
  206. #define XFER_FAILED 0x04
  208. static struct hd_struct ftl_hd[MINOR_NR(MAX_DEV, 0, 0)];
  209. static int ftl_sizes[MINOR_NR(MAX_DEV, 0, 0)];
  210. static int ftl_blocksizes[MINOR_NR(MAX_DEV, 0, 0)];
  212. static struct gendisk ftl_gendisk = {
  213.     major: FTL_MAJOR,
  214.     major_name: "ftl",
  215.     minor_shift: PART_BITS,
  216.     max_p: MAX_PART,
  217. #if (LINUX_VERSION_CODE < 0x20328)
  218.     max_nr: MAX_DEV*MAX_PART,
  219. #endif
  220.     part: ftl_hd,
  221.     sizes: ftl_sizes,
  222. };
  224. /*====================================================================*/
  226. static int ftl_ioctl(struct inode *inode, struct file *file,
  227.      u_int cmd, u_long arg);
  228. static int ftl_open(struct inode *inode, struct file *file);
  229. static release_t ftl_close(struct inode *inode, struct file *file);
  230. static int ftl_reread_partitions(int minor);
  232. static void ftl_erase_callback(struct erase_info *done);
  234. #if LINUX_VERSION_CODE < 0x20326
  235. static struct file_operations ftl_blk_fops = {
  236.     open: ftl_open,
  237.     release: ftl_close,
  238.     ioctl: ftl_ioctl,
  239.     read: block_read,
  240.     write: block_write,
  241.     fsync: block_fsync
  242. };
  243. #else
  244. static struct block_device_operations ftl_blk_fops = {
  245. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,14)
  246.     owner: THIS_MODULE,
  247. #endif
  248.     open: ftl_open,
  249.     release: ftl_close,
  250.     ioctl: ftl_ioctl,
  251. };
  252. #endif
  254. /*======================================================================
  256.     Scan_header() checks to see if a memory region contains an FTL
  257.     partition.  build_maps() reads all the erase unit headers, builds
  258.     the erase unit map, and then builds the virtual page map.
  259.     
  260. ======================================================================*/
  262. static int scan_header(partition_t *part)
  263. {
  264.     erase_unit_header_t header;
  265.     loff_t offset, max_offset;
  266.     int ret;
  267.     part->header.FormattedSize = 0;
  268.     max_offset = (0x100000<part->mtd->size)?0x100000:part->mtd->size;
  269.     /* Search first megabyte for a valid FTL header */
  270.     for (offset = 0;
  271.  (offset + sizeof(header)) < max_offset;
  272.  offset += part->mtd->erasesize ? : 0x2000) {
  274. ret = part->mtd->read(part->mtd, offset, sizeof(header), &ret, 
  275.       (unsigned char *)&header);
  277. if (ret) 
  278.     return ret;
  280. if (strcmp(header.DataOrgTuple+3, "FTL100") == 0) break;
  281.     }
  283.     if (offset == max_offset) {
  284. printk(KERN_NOTICE "ftl_cs: FTL header not found.n");
  285. return -ENOENT;
  286.     }
  287.     if ((le16_to_cpu(header.NumEraseUnits) > 65536) || header.BlockSize != 9 ||
  288. (header.EraseUnitSize < 10) || (header.EraseUnitSize > 31) ||
  289. (header.NumTransferUnits >= le16_to_cpu(header.NumEraseUnits))) {
  290. printk(KERN_NOTICE "ftl_cs: FTL header corrupt!n");
  291. return -1;
  292.     }
  293.     if ((1 << header.EraseUnitSize) != part->mtd->erasesize) {
  294. printk(KERN_NOTICE "ftl: FTL EraseUnitSize %x != MTD erasesize %xn",
  295.        1 << header.EraseUnitSize,part->mtd->erasesize);
  296. return -1;
  297.     }
  298.     part->header = header;
  299.     return 0;
  300. }
  302. static int build_maps(partition_t *part)
  303. {
  304.     erase_unit_header_t header;
  305.     u_int16_t xvalid, xtrans, i;
  306.     u_int blocks, j;
  307.     int hdr_ok, ret = -1;
  308.     ssize_t retval;
  309.     loff_t offset;
  311.     /* Set up erase unit maps */
  312.     part->DataUnits = le16_to_cpu(part->header.NumEraseUnits) -
  313. part->header.NumTransferUnits;
  314.     part->EUNInfo = kmalloc(part->DataUnits * sizeof(struct eun_info_t),
  315.     GFP_KERNEL);
  316.     if (!part->EUNInfo)
  317.     goto out;
  318.     for (i = 0; i < part->DataUnits; i++)
  319. part->EUNInfo[i].Offset = 0xffffffff;
  320.     part->XferInfo =
  321. kmalloc(part->header.NumTransferUnits * sizeof(struct xfer_info_t),
  322. GFP_KERNEL);
  323.     if (!part->XferInfo)
  324.     goto out_EUNInfo;
  326.     xvalid = xtrans = 0;
  327.     for (i = 0; i < le16_to_cpu(part->header.NumEraseUnits); i++) {
  328. offset = ((i + le16_to_cpu(part->header.FirstPhysicalEUN))
  329.       << part->header.EraseUnitSize);
  330. ret = part->mtd->read(part->mtd, offset, sizeof(header), &retval, 
  331.       (unsigned char *)&header);
  333. if (ret) 
  334.     goto out_XferInfo;
  336. ret = -1;
  337. /* Is this a transfer partition? */
  338. hdr_ok = (strcmp(header.DataOrgTuple+3, "FTL100") == 0);
  339. if (hdr_ok && (le16_to_cpu(header.LogicalEUN) < part->DataUnits) &&
  340.     (part->EUNInfo[le16_to_cpu(header.LogicalEUN)].Offset == 0xffffffff)) {
  341.     part->EUNInfo[le16_to_cpu(header.LogicalEUN)].Offset = offset;
  342.     part->EUNInfo[le16_to_cpu(header.LogicalEUN)].EraseCount =
  343. le32_to_cpu(header.EraseCount);
  344.     xvalid++;
  345. } else {
  346.     if (xtrans == part->header.NumTransferUnits) {
  347. printk(KERN_NOTICE "ftl_cs: format error: too many "
  348.        "transfer units!n");
  349. goto out_XferInfo;
  350.     }
  351.     if (hdr_ok && (le16_to_cpu(header.LogicalEUN) == 0xffff)) {
  352. part->XferInfo[xtrans].state = XFER_PREPARED;
  353. part->XferInfo[xtrans].EraseCount = le32_to_cpu(header.EraseCount);
  354.     } else {
  355. part->XferInfo[xtrans].state = XFER_UNKNOWN;
  356. /* Pick anything reasonable for the erase count */
  357. part->XferInfo[xtrans].EraseCount =
  358.     le32_to_cpu(part->header.EraseCount);
  359.     }
  360.     part->XferInfo[xtrans].Offset = offset;
  361.     xtrans++;
  362. }
  363.     }
  364.     /* Check for format trouble */
  365.     header = part->header;
  366.     if ((xtrans != header.NumTransferUnits) ||
  367. (xvalid+xtrans != le16_to_cpu(header.NumEraseUnits))) {
  368. printk(KERN_NOTICE "ftl_cs: format error: erase units "
  369.        "don't add up!n");
  370. goto out_XferInfo;
  371.     }
  372.     
  373.     /* Set up virtual page map */
  374.     blocks = le32_to_cpu(header.FormattedSize) >> header.BlockSize;
  375.     part->VirtualBlockMap = vmalloc(blocks * sizeof(u_int32_t));
  376.     if (!part->VirtualBlockMap)
  377.     goto out_XferInfo;
  379.     memset(part->VirtualBlockMap, 0xff, blocks * sizeof(u_int32_t));
  380.     part->BlocksPerUnit = (1 << header.EraseUnitSize) >> header.BlockSize;
  382.     part->bam_cache = kmalloc(part->BlocksPerUnit * sizeof(u_int32_t),
  383.       GFP_KERNEL);
  384.     if (!part->bam_cache)
  385.     goto out_VirtualBlockMap;
  387.     part->bam_index = 0xffff;
  388.     part->FreeTotal = 0;
  390.     for (i = 0; i < part->DataUnits; i++) {
  391. part->EUNInfo[i].Free = 0;
  392. part->EUNInfo[i].Deleted = 0;
  393. offset = part->EUNInfo[i].Offset + le32_to_cpu(header.BAMOffset);
  395. ret = part->mtd->read(part->mtd, offset,  
  396.       part->BlocksPerUnit * sizeof(u_int32_t), &retval, 
  397.       (unsigned char *)part->bam_cache);
  399. if (ret) 
  400. goto out_bam_cache;
  402. for (j = 0; j < part->BlocksPerUnit; j++) {
  403.     if (BLOCK_FREE(le32_to_cpu(part->bam_cache[j]))) {
  404. part->EUNInfo[i].Free++;
  405. part->FreeTotal++;
  406.     } else if ((BLOCK_TYPE(le32_to_cpu(part->bam_cache[j])) == BLOCK_DATA) &&
  407.      (BLOCK_NUMBER(le32_to_cpu(part->bam_cache[j])) < blocks))
  408. part->VirtualBlockMap[BLOCK_NUMBER(le32_to_cpu(part->bam_cache[j]))] =
  409.     (i << header.EraseUnitSize) + (j << header.BlockSize);
  410.     else if (BLOCK_DELETED(le32_to_cpu(part->bam_cache[j])))
  411. part->EUNInfo[i].Deleted++;
  412. }
  413.     }
  414.     
  415.     ret = 0;
  416.     goto out;
  418. out_bam_cache:
  419.     kfree(part->bam_cache);
  420. out_VirtualBlockMap:
  421.     vfree(part->VirtualBlockMap);
  422. out_XferInfo:
  423.     kfree(part->XferInfo);
  424. out_EUNInfo:
  425.     kfree(part->EUNInfo);
  426. out:
  427.     return ret;
  428. } /* build_maps */
  430. /*======================================================================
  432.     Erase_xfer() schedules an asynchronous erase operation for a
  433.     transfer unit.
  434.     
  435. ======================================================================*/
  437. static int erase_xfer(partition_t *part,
  438.       u_int16_t xfernum)
  439. {
  440.     int ret;
  441.     struct xfer_info_t *xfer;
  442.     struct erase_info *erase;
  444.     xfer = &part->XferInfo[xfernum];
  445.     DEBUG(1, "ftl_cs: erasing xfer unit at 0x%xn", xfer->Offset);
  446.     xfer->state = XFER_ERASING;
  448.     /* Is there a free erase slot? Always in MTD. */
  449.     
  450.     
  451.     erase=kmalloc(sizeof(struct erase_info), GFP_KERNEL);
  452.     if (!erase) 
  453.             return -ENOMEM;
  455.     erase->callback = ftl_erase_callback;
  456.     erase->addr = xfer->Offset;
  457.     erase->len = 1 << part->header.EraseUnitSize;
  458.     erase->priv = (u_long)part;
  459.     
  460.     ret = part->mtd->erase(part->mtd, erase);
  462.     if (!ret)
  463.     xfer->EraseCount++;
  464.     else
  465.     kfree(erase);
  467.     return ret;
  468. } /* erase_xfer */
  470. /*======================================================================
  472.     Prepare_xfer() takes a freshly erased transfer unit and gives
  473.     it an appropriate header.
  474.     
  475. ======================================================================*/
  477. static void ftl_erase_callback(struct erase_info *erase)
  478. {
  479.     partition_t *part;
  480.     struct xfer_info_t *xfer;
  481.     int i;
  482.     
  483.     /* Look up the transfer unit */
  484.     part = (partition_t *)(erase->priv);
  486.     for (i = 0; i < part->header.NumTransferUnits; i++)
  487. if (part->XferInfo[i].Offset == erase->addr) break;
  489.     if (i == part->header.NumTransferUnits) {
  490. printk(KERN_NOTICE "ftl_cs: internal error: "
  491.        "erase lookup failed!n");
  492. return;
  493.     }
  495.     xfer = &part->XferInfo[i];
  496.     if (erase->state == MTD_ERASE_DONE)
  497. xfer->state = XFER_ERASED;
  498.     else {
  499. xfer->state = XFER_FAILED;
  500. printk(KERN_NOTICE "ftl_cs: erase failed: state = %dn",
  501.        erase->state);
  502.     }
  504.     kfree(erase);
  506. } /* ftl_erase_callback */
  508. static int prepare_xfer(partition_t *part, int i)
  509. {
  510.     erase_unit_header_t header;
  511.     struct xfer_info_t *xfer;
  512.     int nbam, ret;
  513.     u_int32_t ctl;
  514.     ssize_t retlen;
  515.     loff_t offset;
  517.     xfer = &part->XferInfo[i];
  518.     xfer->state = XFER_FAILED;
  519.     
  520.     DEBUG(1, "ftl_cs: preparing xfer unit at 0x%xn", xfer->Offset);
  522.     /* Write the transfer unit header */
  523.     header = part->header;
  524.     header.LogicalEUN = cpu_to_le16(0xffff);
  525.     header.EraseCount = cpu_to_le32(xfer->EraseCount);
  527.     ret = part->mtd->write(part->mtd, xfer->Offset, sizeof(header),
  528.    &retlen, (u_char *)&header);
  530.     if (ret) {
  531. return ret;
  532.     }
  534.     /* Write the BAM stub */
  535.     nbam = (part->BlocksPerUnit * sizeof(u_int32_t) +
  536.     le32_to_cpu(part->header.BAMOffset) + SECTOR_SIZE - 1) / SECTOR_SIZE;
  538.     offset = xfer->Offset + le32_to_cpu(part->header.BAMOffset);
  539.     ctl = cpu_to_le32(BLOCK_CONTROL);
  541.     for (i = 0; i < nbam; i++, offset += sizeof(u_int32_t)) {
  543. ret = part->mtd->write(part->mtd, offset, sizeof(u_int32_t), 
  544.        &retlen, (u_char *)&ctl);
  546. if (ret)
  547.     return ret;
  548.     }
  549.     xfer->state = XFER_PREPARED;
  550.     return 0;
  551.     
  552. } /* prepare_xfer */
  554. /*======================================================================
  556.     Copy_erase_unit() takes a full erase block and a transfer unit,
  557.     copies everything to the transfer unit, then swaps the block
  558.     pointers.
  560.     All data blocks are copied to the corresponding blocks in the
  561.     target unit, so the virtual block map does not need to be
  562.     updated.
  563.     
  564. ======================================================================*/
  566. static int copy_erase_unit(partition_t *part, u_int16_t srcunit,
  567.    u_int16_t xferunit)
  568. {
  569.     u_char buf[SECTOR_SIZE];
  570.     struct eun_info_t *eun;
  571.     struct xfer_info_t *xfer;
  572.     u_int32_t src, dest, free, i;
  573.     u_int16_t unit;
  574.     int ret;
  575.     ssize_t retlen;
  576.     loff_t offset;
  577.     u_int16_t srcunitswap = cpu_to_le16(srcunit);
  579.     eun = &part->EUNInfo[srcunit];
  580.     xfer = &part->XferInfo[xferunit];
  581.     DEBUG(2, "ftl_cs: copying block 0x%x to 0x%xn",
  582.   eun->Offset, xfer->Offset);
  584.     
  585.     /* Read current BAM */
  586.     if (part->bam_index != srcunit) {
  588. offset = eun->Offset + le32_to_cpu(part->header.BAMOffset);
  590. ret = part->mtd->read(part->mtd, offset, 
  591.       part->BlocksPerUnit * sizeof(u_int32_t),
  592.       &retlen, (u_char *) (part->bam_cache));
  594. /* mark the cache bad, in case we get an error later */
  595. part->bam_index = 0xffff;
  597. if (ret) {
  598.     printk( KERN_WARNING "ftl: Failed to read BAM cache in copy_erase_unit()!n");                
  599.     return ret;
  600. }
  601.     }
  602.     
  603.     /* Write the LogicalEUN for the transfer unit */
  604.     xfer->state = XFER_UNKNOWN;
  605.     offset = xfer->Offset + 20; /* Bad! */
  606.     unit = cpu_to_le16(0x7fff);
  608.     ret = part->mtd->write(part->mtd, offset, sizeof(u_int16_t),
  609.    &retlen, (u_char *) &unit);
  610.     
  611.     if (ret) {
  612. printk( KERN_WARNING "ftl: Failed to write back to BAM cache in copy_erase_unit()!n");
  613. return ret;
  614.     }
  615.     
  616.     /* Copy all data blocks from source unit to transfer unit */
  617.     src = eun->Offset; dest = xfer->Offset;
  619.     free = 0;
  620.     ret = 0;
  621.     for (i = 0; i < part->BlocksPerUnit; i++) {
  622. switch (BLOCK_TYPE(le32_to_cpu(part->bam_cache[i]))) {
  623. case BLOCK_CONTROL:
  624.     /* This gets updated later */
  625.     break;
  626. case BLOCK_DATA:
  627. case BLOCK_REPLACEMENT:
  628.     ret = part->mtd->read(part->mtd, src, SECTOR_SIZE,
  629.                         &retlen, (u_char *) buf);
  630.     if (ret) {
  631. printk(KERN_WARNING "ftl: Error reading old xfer unit in copy_erase_unitn");
  632. return ret;
  633.             }
  636.     ret = part->mtd->write(part->mtd, dest, SECTOR_SIZE,
  637.                         &retlen, (u_char *) buf);
  638.     if (ret)  {
  639. printk(KERN_WARNING "ftl: Error writing new xfer unit in copy_erase_unitn");
  640. return ret;
  641.             }
  643.     break;
  644. default:
  645.     /* All other blocks must be free */
  646.     part->bam_cache[i] = cpu_to_le32(0xffffffff);
  647.     free++;
  648.     break;
  649. }
  650. src += SECTOR_SIZE;
  651. dest += SECTOR_SIZE;
  652.     }
  654.     /* Write the BAM to the transfer unit */
  655.     ret = part->mtd->write(part->mtd, xfer->Offset + le32_to_cpu(part->header.BAMOffset), 
  656.                     part->BlocksPerUnit * sizeof(int32_t), &retlen, 
  657.     (u_char *)part->bam_cache);
  658.     if (ret) {
  659. printk( KERN_WARNING "ftl: Error writing BAM in copy_erase_unitn");
  660. return ret;
  661.     }
  663.     
  664.     /* All clear? Then update the LogicalEUN again */
  665.     ret = part->mtd->write(part->mtd, xfer->Offset + 20, sizeof(u_int16_t),
  666.    &retlen, (u_char *)&srcunitswap);
  668.     if (ret) {
  669. printk(KERN_WARNING "ftl: Error writing new LogicalEUN in copy_erase_unitn");
  670. return ret;
  671.     }    
  672.     
  673.     
  674.     /* Update the maps and usage stats*/
  675.     i = xfer->EraseCount;
  676.     xfer->EraseCount = eun->EraseCount;
  677.     eun->EraseCount = i;
  678.     i = xfer->Offset;
  679.     xfer->Offset = eun->Offset;
  680.     eun->Offset = i;
  681.     part->FreeTotal -= eun->Free;
  682.     part->FreeTotal += free;
  683.     eun->Free = free;
  684.     eun->Deleted = 0;
  685.     
  686.     /* Now, the cache should be valid for the new block */
  687.     part->bam_index = srcunit;
  688.     
  689.     return 0;
  690. } /* copy_erase_unit */
  692. /*======================================================================
  694.     reclaim_block() picks a full erase unit and a transfer unit and
  695.     then calls copy_erase_unit() to copy one to the other.  Then, it
  696.     schedules an erase on the expired block.
  698.     What's a good way to decide which transfer unit and which erase
  699.     unit to use?  Beats me.  My way is to always pick the transfer
  700.     unit with the fewest erases, and usually pick the data unit with
  701.     the most deleted blocks.  But with a small probability, pick the
  702.     oldest data unit instead.  This means that we generally postpone
  703.     the next reclaimation as long as possible, but shuffle static
  704.     stuff around a bit for wear leveling.
  705.     
  706. ======================================================================*/
  708. static int reclaim_block(partition_t *part)
  709. {
  710.     u_int16_t i, eun, xfer;
  711.     u_int32_t best;
  712.     int queued, ret;
  714.     DEBUG(0, "ftl_cs: reclaiming space...n");
  715.     DEBUG(3, "NumTransferUnits == %xn", part->header.NumTransferUnits);
  716.     /* Pick the least erased transfer unit */
  717.     best = 0xffffffff; xfer = 0xffff;
  718.     do {
  719. queued = 0;
  720. for (i = 0; i < part->header.NumTransferUnits; i++) {
  721.     int n=0;
  722.     if (part->XferInfo[i].state == XFER_UNKNOWN) {
  723. DEBUG(3,"XferInfo[%d].state == XFER_UNKNOWNn",i);
  724. n=1;
  725. erase_xfer(part, i);
  726.     }
  727.     if (part->XferInfo[i].state == XFER_ERASING) {
  728. DEBUG(3,"XferInfo[%d].state == XFER_ERASINGn",i);
  729. n=1;
  730. queued = 1;
  731.     }
  732.     else if (part->XferInfo[i].state == XFER_ERASED) {
  733. DEBUG(3,"XferInfo[%d].state == XFER_ERASEDn",i);
  734. n=1;
  735. prepare_xfer(part, i);
  736.     }
  737.     if (part->XferInfo[i].state == XFER_PREPARED) {
  738. DEBUG(3,"XferInfo[%d].state == XFER_PREPAREDn",i);
  739. n=1;
  740. if (part->XferInfo[i].EraseCount <= best) {
  741.     best = part->XferInfo[i].EraseCount;
  742.     xfer = i;
  743. }
  744.     }
  745. if (!n)
  746.     DEBUG(3,"XferInfo[%d].state == %xn",i, part->XferInfo[i].state);
  748. }
  749. if (xfer == 0xffff) {
  750.     if (queued) {
  751. DEBUG(1, "ftl_cs: waiting for transfer "
  752.       "unit to be prepared...n");
  753. if (part->mtd->sync)
  754. part->mtd->sync(part->mtd);
  755.     } else {
  756. static int ne = 0;
  757. if (++ne < 5)
  758.     printk(KERN_NOTICE "ftl_cs: reclaim failed: no "
  759.    "suitable transfer units!n");
  760. else
  761.     DEBUG(1, "ftl_cs: reclaim failed: no "
  762.   "suitable transfer units!n");
  764. return -EIO;
  765.     }
  766. }
  767.     } while (xfer == 0xffff);
  769.     eun = 0;
  770.     if ((jiffies % shuffle_freq) == 0) {
  771. DEBUG(1, "ftl_cs: recycling freshest block...n");
  772. best = 0xffffffff;
  773. for (i = 0; i < part->DataUnits; i++)
  774.     if (part->EUNInfo[i].EraseCount <= best) {
  775. best = part->EUNInfo[i].EraseCount;
  776. eun = i;
  777.     }
  778.     } else {
  779. best = 0;
  780. for (i = 0; i < part->DataUnits; i++)
  781.     if (part->EUNInfo[i].Deleted >= best) {
  782. best = part->EUNInfo[i].Deleted;
  783. eun = i;
  784.     }
  785. if (best == 0) {
  786.     static int ne = 0;
  787.     if (++ne < 5)
  788. printk(KERN_NOTICE "ftl_cs: reclaim failed: "
  789.        "no free blocks!n");
  790.     else
  791. DEBUG(1,"ftl_cs: reclaim failed: "
  792.        "no free blocks!n");
  794.     return -EIO;
  795. }
  796.     }
  797.     ret = copy_erase_unit(part, eun, xfer);
  798.     if (!ret)
  799. erase_xfer(part, xfer);
  800.     else
  801. printk(KERN_NOTICE "ftl_cs: copy_erase_unit failed!n");
  802.     return ret;
  803. } /* reclaim_block */
  805. /*======================================================================
  807.     Find_free() searches for a free block.  If necessary, it updates
  808.     the BAM cache for the erase unit containing the free block.  It
  809.     returns the block index -- the erase unit is just the currently
  810.     cached unit.  If there are no free blocks, it returns 0 -- this
  811.     is never a valid data block because it contains the header.
  812.     
  813. ======================================================================*/
  815. #ifdef PSYCHO_DEBUG
  816. static void dump_lists(partition_t *part)
  817. {
  818.     int i;
  819.     printk(KERN_DEBUG "ftl_cs: Free total = %dn", part->FreeTotal);
  820.     for (i = 0; i < part->DataUnits; i++)
  821. printk(KERN_DEBUG "ftl_cs:   unit %d: %d phys, %d free, "
  822.        "%d deletedn", i,
  823.        part->EUNInfo[i].Offset >> part->header.EraseUnitSize,
  824.        part->EUNInfo[i].Free, part->EUNInfo[i].Deleted);
  825. }
  826. #endif
  828. static u_int32_t find_free(partition_t *part)
  829. {
  830.     u_int16_t stop, eun;
  831.     u_int32_t blk;
  832.     size_t retlen;
  833.     int ret;
  834.     
  835.     /* Find an erase unit with some free space */
  836.     stop = (part->bam_index == 0xffff) ? 0 : part->bam_index;
  837.     eun = stop;
  838.     do {
  839. if (part->EUNInfo[eun].Free != 0) break;
  840. /* Wrap around at end of table */
  841. if (++eun == part->DataUnits) eun = 0;
  842.     } while (eun != stop);
  844.     if (part->EUNInfo[eun].Free == 0)
  845. return 0;
  846.     
  847.     /* Is this unit's BAM cached? */
  848.     if (eun != part->bam_index) {
  849. /* Invalidate cache */
  850. part->bam_index = 0xffff;
  852. ret = part->mtd->read(part->mtd, 
  853.        part->EUNInfo[eun].Offset + le32_to_cpu(part->header.BAMOffset),
  854.        part->BlocksPerUnit * sizeof(u_int32_t),
  855.        &retlen, (u_char *) (part->bam_cache));
  857. if (ret) {
  858.     printk(KERN_WARNING"ftl: Error reading BAM in find_freen");
  859.     return 0;
  860. }
  861. part->bam_index = eun;
  862.     }
  864.     /* Find a free block */
  865.     for (blk = 0; blk < part->BlocksPerUnit; blk++)
  866. if (BLOCK_FREE(le32_to_cpu(part->bam_cache[blk]))) break;
  867.     if (blk == part->BlocksPerUnit) {
  868. #ifdef PSYCHO_DEBUG
  869. static int ne = 0;
  870. if (++ne == 1)
  871.     dump_lists(part);
  872. #endif
  873. printk(KERN_NOTICE "ftl_cs: bad free list!n");
  874. return 0;
  875.     }
  876.     DEBUG(2, "ftl_cs: found free block at %d in %dn", blk, eun);
  877.     return blk;
  878.     
  879. } /* find_free */
  881. /*======================================================================
  883.     This gets a memory handle for the region corresponding to the
  884.     minor device number.
  885.     
  886. ======================================================================*/
  888. static int ftl_open(struct inode *inode, struct file *file)
  889. {
  890.     int minor = MINOR(inode->i_rdev);
  891.     partition_t *partition;
  893.     if (minor>>4 >= MAX_MTD_DEVICES)
  894. return -ENODEV;
  896.     partition = myparts[minor>>4];
  898.     if (!partition)
  899. return -ENODEV;
  901.     if (partition->state != FTL_FORMATTED)
  902. return -ENXIO;
  903.     
  904.     if (ftl_gendisk.part[minor].nr_sects == 0)
  905. return -ENXIO;
  907.     BLK_INC_USE_COUNT;
  909.     if (!get_mtd_device(partition->mtd, -1)) {
  910.     BLK_DEC_USE_COUNT;
  911.     return -ENXIO;
  912.     }
  913.     
  914.     if ((file->f_mode & 2) && !(partition->mtd->flags & MTD_CLEAR_BITS) ) {
  915.     put_mtd_device(partition->mtd);
  916.     BLK_DEC_USE_COUNT;
  917.             return -EROFS;
  918.     }
  919.     
  920.     DEBUG(0, "ftl_cs: ftl_open(%d)n", minor);
  922.     atomic_inc(&partition->open);
  924.     return 0;
  925. }
  927. /*====================================================================*/
  929. static release_t ftl_close(struct inode *inode, struct file *file)
  930. {
  931.     int minor = MINOR(inode->i_rdev);
  932.     partition_t *part = myparts[minor >> 4];
  933.     int i;
  934.     
  935.     DEBUG(0, "ftl_cs: ftl_close(%d)n", minor);
  937.     /* Wait for any pending erase operations to complete */
  938.     if (part->mtd->sync)
  939.     part->mtd->sync(part->mtd);
  940.     
  941.     for (i = 0; i < part->header.NumTransferUnits; i++) {
  942. if (part->XferInfo[i].state == XFER_ERASED)
  943.     prepare_xfer(part, i);
  944.     }
  946.     atomic_dec(&part->open);
  948.     put_mtd_device(part->mtd);
  949.     BLK_DEC_USE_COUNT;
  950.     release_return(0);
  951. } /* ftl_close */
  954. /*======================================================================
  956.     Read a series of sectors from an FTL partition.
  957.     
  958. ======================================================================*/
  960. static int ftl_read(partition_t *part, caddr_t buffer,
  961.     u_long sector, u_long nblocks)
  962. {
  963.     u_int32_t log_addr, bsize;
  964.     u_long i;
  965.     int ret;
  966.     size_t offset, retlen;
  967.     
  968.     DEBUG(2, "ftl_cs: ftl_read(0x%p, 0x%lx, %ld)n",
  969.   part, sector, nblocks);
  970.     if (!(part->state & FTL_FORMATTED)) {
  971. printk(KERN_NOTICE "ftl_cs: bad partitionn");
  972. return -EIO;
  973.     }
  974.     bsize = 1 << part->header.EraseUnitSize;
  976.     for (i = 0; i < nblocks; i++) {
  977. if (((sector+i) * SECTOR_SIZE) >= le32_to_cpu(part->header.FormattedSize)) {
  978.     printk(KERN_NOTICE "ftl_cs: bad read offsetn");
  979.     return -EIO;
  980. }
  981. log_addr = part->VirtualBlockMap[sector+i];
  982. if (log_addr == 0xffffffff)
  983.     memset(buffer, 0, SECTOR_SIZE);
  984. else {
  985.     offset = (part->EUNInfo[log_addr / bsize].Offset
  986.   + (log_addr % bsize));
  987.     ret = part->mtd->read(part->mtd, offset, SECTOR_SIZE,
  988.    &retlen, (u_char *) buffer);
  990.     if (ret) {
  991. printk(KERN_WARNING "Error reading MTD device in ftl_read()n");
  992. return ret;
  993.     }
  994. }
  995. buffer += SECTOR_SIZE;
  996.     }
  997.     return 0;
  998. } /* ftl_read */
  1000. /*======================================================================
  1002.     Write a series of sectors to an FTL partition
  1003.     
  1004. ======================================================================*/
  1006. static int set_bam_entry(partition_t *part, u_int32_t log_addr,
  1007.  u_int32_t virt_addr)
  1008. {
  1009.     u_int32_t bsize, blk, le_virt_addr;
  1010. #ifdef PSYCHO_DEBUG
  1011.     u_int32_t old_addr;
  1012. #endif
  1013.     u_int16_t eun;
  1014.     int ret;
  1015.     size_t retlen, offset;
  1017.     DEBUG(2, "ftl_cs: set_bam_entry(0x%p, 0x%x, 0x%x)n",
  1018.   part, log_addr, virt_addr);
  1019.     bsize = 1 << part->header.EraseUnitSize;
  1020.     eun = log_addr / bsize;
  1021.     blk = (log_addr % bsize) / SECTOR_SIZE;
  1022.     offset = (part->EUNInfo[eun].Offset + blk * sizeof(u_int32_t) +
  1023.   le32_to_cpu(part->header.BAMOffset));
  1024.     
  1025. #ifdef PSYCHO_DEBUG
  1026.     ret = part->mtd->read(part->mtd, offset, sizeof(u_int32_t),
  1027.                         &retlen, (u_char *)&old_addr);
  1028.     if (ret) {
  1029. printk(KERN_WARNING"ftl: Error reading old_addr in set_bam_entry: %dn",ret);
  1030. return ret;
  1031.     }
  1032.     old_addr = le32_to_cpu(old_addr);
  1034.     if (((virt_addr == 0xfffffffe) && !BLOCK_FREE(old_addr)) ||
  1035. ((virt_addr == 0) && (BLOCK_TYPE(old_addr) != BLOCK_DATA)) ||
  1036. (!BLOCK_DELETED(virt_addr) && (old_addr != 0xfffffffe))) {
  1037. static int ne = 0;
  1038. if (++ne < 5) {
  1039.     printk(KERN_NOTICE "ftl_cs: set_bam_entry() inconsistency!n");
  1040.     printk(KERN_NOTICE "ftl_cs:   log_addr = 0x%x, old = 0x%x"
  1041.    ", new = 0x%xn", log_addr, old_addr, virt_addr);
  1042. }
  1043. return -EIO;
  1044.     }
  1045. #endif
  1046.     le_virt_addr = cpu_to_le32(virt_addr);
  1047.     if (part->bam_index == eun) {
  1048. #ifdef PSYCHO_DEBUG
  1049. if (le32_to_cpu(part->bam_cache[blk]) != old_addr) {
  1050.     static int ne = 0;
  1051.     if (++ne < 5) {
  1052. printk(KERN_NOTICE "ftl_cs: set_bam_entry() "
  1053.        "inconsistency!n");
  1054. printk(KERN_NOTICE "ftl_cs:   log_addr = 0x%x, cache"
  1055.        " = 0x%xn",
  1056.        le32_to_cpu(part->bam_cache[blk]), old_addr);
  1057.     }
  1058.     return -EIO;
  1059. }
  1060. #endif
  1061. part->bam_cache[blk] = le_virt_addr;
  1062.     }
  1063.     ret = part->mtd->write(part->mtd, offset, sizeof(u_int32_t),
  1064.                             &retlen, (u_char *)&le_virt_addr);
  1066.     if (ret) {
  1067. printk(KERN_NOTICE "ftl_cs: set_bam_entry() failed!n");
  1068. printk(KERN_NOTICE "ftl_cs:   log_addr = 0x%x, new = 0x%xn",
  1069.        log_addr, virt_addr);
  1070.     }
  1071.     return ret;
  1072. } /* set_bam_entry */
  1074. static int ftl_write(partition_t *part, caddr_t buffer,
  1075.      u_long sector, u_long nblocks)
  1076. {
  1077.     u_int32_t bsize, log_addr, virt_addr, old_addr, blk;
  1078.     u_long i;
  1079.     int ret;
  1080.     size_t retlen, offset;
  1082.     DEBUG(2, "ftl_cs: ftl_write(0x%p, %ld, %ld)n",
  1083.   part, sector, nblocks);
  1084.     if (!(part->state & FTL_FORMATTED)) {
  1085. printk(KERN_NOTICE "ftl_cs: bad partitionn");
  1086. return -EIO;
  1087.     }
  1088.     /* See if we need to reclaim space, before we start */
  1089.     while (part->FreeTotal < nblocks) {
  1090. ret = reclaim_block(part);
  1091. if (ret)
  1092.     return ret;
  1093.     }
  1094.     
  1095.     bsize = 1 << part->header.EraseUnitSize;
  1097.     virt_addr = sector * SECTOR_SIZE | BLOCK_DATA;
  1098.     for (i = 0; i < nblocks; i++) {
  1099. if (virt_addr >= le32_to_cpu(part->header.FormattedSize)) {
  1100.     printk(KERN_NOTICE "ftl_cs: bad write offsetn");
  1101.     return -EIO;
  1102. }
  1104. /* Grab a free block */
  1105. blk = find_free(part);
  1106. if (blk == 0) {
  1107.     static int ne = 0;
  1108.     if (++ne < 5)
  1109. printk(KERN_NOTICE "ftl_cs: internal error: "
  1110.        "no free blocks!n");
  1111.     return -ENOSPC;
  1112. }
  1114. /* Tag the BAM entry, and write the new block */
  1115. log_addr = part->bam_index * bsize + blk * SECTOR_SIZE;
  1116. part->EUNInfo[part->bam_index].Free--;
  1117. part->FreeTotal--;
  1118. if (set_bam_entry(part, log_addr, 0xfffffffe)) 
  1119.     return -EIO;
  1120. part->EUNInfo[part->bam_index].Deleted++;
  1121. offset = (part->EUNInfo[part->bam_index].Offset +
  1122.       blk * SECTOR_SIZE);
  1123. ret = part->mtd->write(part->mtd, offset, SECTOR_SIZE, &retlen, 
  1124.                                      buffer);
  1126. if (ret) {
  1127.     printk(KERN_NOTICE "ftl_cs: block write failed!n");
  1128.     printk(KERN_NOTICE "ftl_cs:   log_addr = 0x%x, virt_addr"
  1129.    " = 0x%x, Offset = 0x%xn", log_addr, virt_addr,
  1130.    offset);
  1131.     return -EIO;
  1132. }
  1134. /* Only delete the old entry when the new entry is ready */
  1135. old_addr = part->VirtualBlockMap[sector+i];
  1136. if (old_addr != 0xffffffff) {
  1137.     part->VirtualBlockMap[sector+i] = 0xffffffff;
  1138.     part->EUNInfo[old_addr/bsize].Deleted++;
  1139.     if (set_bam_entry(part, old_addr, 0))
  1140. return -EIO;
  1141. }
  1143. /* Finally, set up the new pointers */
  1144. if (set_bam_entry(part, log_addr, virt_addr))
  1145.     return -EIO;
  1146. part->VirtualBlockMap[sector+i] = log_addr;
  1147. part->EUNInfo[part->bam_index].Deleted--;
  1149. buffer += SECTOR_SIZE;
  1150. virt_addr += SECTOR_SIZE;
  1151.     }
  1152.     return 0;
  1153. } /* ftl_write */
  1155. /*======================================================================
  1157.     IOCTL calls for getting device parameters.
  1159. ======================================================================*/
  1161. static int ftl_ioctl(struct inode *inode, struct file *file,
  1162.      u_int cmd, u_long arg)
  1163. {
  1164.     struct hd_geometry *geo = (struct hd_geometry *)arg;
  1165.     int ret = 0, minor = MINOR(inode->i_rdev);
  1166.     partition_t *part= myparts[minor >> 4];
  1167.     u_long sect;
  1169.     if (!part)
  1170. return -ENODEV; /* How? */
  1172.     switch (cmd) {
  1173.     case HDIO_GETGEO:
  1174. ret = verify_area(VERIFY_WRITE, (long *)arg, sizeof(*geo));
  1175. if (ret) return ret;
  1176. /* Sort of arbitrary: round size down to 4K boundary */
  1177. sect = le32_to_cpu(part->header.FormattedSize)/SECTOR_SIZE;
  1178. put_user(1, (char *)&geo->heads);
  1179. put_user(8, (char *)&geo->sectors);
  1180. put_user((sect>>3), (short *)&geo->cylinders);
  1181. put_user(ftl_hd[minor].start_sect, (u_long *)&geo->start);
  1182. break;
  1183.     case BLKGETSIZE:
  1184. ret = put_user(ftl_hd[minor].nr_sects, (unsigned long *)arg);
  1185. break;
  1186. #ifdef BLKGETSIZE64
  1187.     case BLKGETSIZE64:
  1188. ret = put_user((u64)ftl_hd[minor].nr_sects << 9, (u64 *)arg);
  1189. break;
  1190. #endif
  1191.     case BLKRRPART:
  1192. ret = ftl_reread_partitions(minor);
  1193. break;
  1194. #if (LINUX_VERSION_CODE < 0x20303)
  1195.     case BLKFLSBUF:
  1196. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
  1197. if (!capable(CAP_SYS_ADMIN)) return -EACCES;
  1198. #endif
  1199. fsync_dev(inode->i_rdev);
  1200. invalidate_buffers(inode->i_rdev);
  1201. break;
  1202.     RO_IOCTLS(inode->i_rdev, arg);
  1203. #else
  1204.     case BLKROSET:
  1205.     case BLKROGET:
  1206.     case BLKFLSBUF:
  1207. ret = blk_ioctl(inode->i_rdev, cmd, arg);
  1208. break;
  1209. #endif
  1210.     default:
  1211. ret = -EINVAL;
  1212.     }
  1214.     return ret;
  1215. } /* ftl_ioctl */
  1217. /*======================================================================
  1219.     Handler for block device requests
  1221. ======================================================================*/
  1223. static int ftl_reread_partitions(int minor)
  1224. {
  1225.     partition_t *part = myparts[minor >> 4];
  1226.     int i, whole;
  1228.     DEBUG(0, "ftl_cs: ftl_reread_partition(%d)n", minor);
  1229.     if ((atomic_read(&part->open) > 1)) {
  1230.     return -EBUSY;
  1231.     }
  1232.     whole = minor & ~(MAX_PART-1);
  1234.     i = MAX_PART - 1;
  1235.     while (i-- > 0) {
  1236. if (ftl_hd[whole+i].nr_sects > 0) {
  1237.     kdev_t rdev = MKDEV(FTL_MAJOR, whole+i);
  1239.     invalidate_device(rdev, 1);
  1240. }
  1241. ftl_hd[whole+i].start_sect = 0;
  1242. ftl_hd[whole+i].nr_sects = 0;
  1243.     }
  1245.     scan_header(part);
  1247.     register_disk(&ftl_gendisk, whole >> PART_BITS, MAX_PART,
  1248.   &ftl_blk_fops, le32_to_cpu(part->header.FormattedSize)/SECTOR_SIZE);
  1250. #ifdef PCMCIA_DEBUG
  1251.     for (i = 0; i < MAX_PART; i++) {
  1252. if (ftl_hd[whole+i].nr_sects > 0)
  1253.     printk(KERN_INFO "  %d: start %ld size %ldn", i,
  1254.    ftl_hd[whole+i].start_sect,
  1255.    ftl_hd[whole+i].nr_sects);
  1256.     }
  1257. #endif
  1258.     return 0;
  1259. }
  1261. /*======================================================================
  1263.     Handler for block device requests
  1265. ======================================================================*/
  1267. static void do_ftl_request(request_arg_t)
  1268. {
  1269.     int ret, minor;
  1270.     partition_t *part;
  1272.     do {
  1273.       //     sti();
  1274. INIT_REQUEST;
  1276. minor = MINOR(CURRENT->rq_dev);
  1278. part = myparts[minor >> 4];
  1279. if (part) {
  1280.   ret = 0;
  1281.   
  1282.   switch (CURRENT->cmd) {
  1283.   case READ:
  1284.     ret = ftl_read(part, CURRENT->buffer,
  1285.    CURRENT->sector+ftl_hd[minor].start_sect,
  1286.    CURRENT->current_nr_sectors);
  1287.     if (ret) printk("ftl_read returned %dn", ret);
  1288.     break;
  1289.     
  1290.   case WRITE:
  1291.     ret = ftl_write(part, CURRENT->buffer,
  1292.     CURRENT->sector+ftl_hd[minor].start_sect,
  1293.     CURRENT->current_nr_sectors);
  1294.     if (ret) printk("ftl_write returned %dn", ret);
  1295.     break;
  1296.     
  1297.   default:
  1298.     panic("ftl_cs: unknown block command!n");
  1299.     
  1300.   }
  1301. } else {
  1302.   ret = 1;
  1303.   printk("NULL part in ftl_requestn");
  1304. }
  1305.  
  1306. if (!ret) {
  1307.   CURRENT->sector += CURRENT->current_nr_sectors;
  1308. }
  1310. end_request((ret == 0) ? 1 : 0);
  1311.     } while (1);
  1312. } /* do_ftl_request */
  1314. /*====================================================================*/
  1316. void ftl_freepart(partition_t *part)
  1317. {
  1318.     if (part->VirtualBlockMap) {
  1319. vfree(part->VirtualBlockMap);
  1320. part->VirtualBlockMap = NULL;
  1321.     }
  1322.     if (part->VirtualPageMap) {
  1323. kfree(part->VirtualPageMap);
  1324. part->VirtualPageMap = NULL;
  1325.     }
  1326.     if (part->EUNInfo) {
  1327. kfree(part->EUNInfo);
  1328. part->EUNInfo = NULL;
  1329.     }
  1330.     if (part->XferInfo) {
  1331. kfree(part->XferInfo);
  1332. part->XferInfo = NULL;
  1333.     }
  1334.     if (part->bam_cache) {
  1335. kfree(part->bam_cache);
  1336. part->bam_cache = NULL;
  1337.     }
  1338.     
  1339. } /* ftl_freepart */
  1341. static void ftl_notify_add(struct mtd_info *mtd)
  1342. {
  1343. partition_t *partition;
  1344. int device;
  1346. for (device=0; device < MAX_MTD_DEVICES && myparts[device]; device++)
  1347. ;
  1349. if (device == MAX_MTD_DEVICES) {
  1350. printk(KERN_NOTICE "Maximum number of FTL partitions reachedn"
  1351.        "Not scanning <%s>n", mtd->name);
  1352. return;
  1353. }
  1355. partition = kmalloc(sizeof(partition_t), GFP_KERNEL);
  1357. if (!partition) {
  1358. printk(KERN_WARNING "No memory to scan for FTL on %sn",
  1359.        mtd->name);
  1360. return;
  1361. }    
  1363. memset(partition, 0, sizeof(partition_t));
  1365. partition->mtd = mtd;
  1367. if ((scan_header(partition) == 0) && 
  1368.     (build_maps(partition) == 0)) {
  1370. partition->state = FTL_FORMATTED;
  1371. atomic_set(&partition->open, 0);
  1372. myparts[device] = partition;
  1373. ftl_reread_partitions(device << 4);
  1374. #ifdef PCMCIA_DEBUG
  1375. printk(KERN_INFO "ftl_cs: opening %d kb FTL partitionn",
  1376.        le32_to_cpu(partition->header.FormattedSize) >> 10);
  1377. #endif
  1378. } else
  1379. kfree(partition);
  1380. }
  1382. static void ftl_notify_remove(struct mtd_info *mtd)
  1383. {
  1384.         int i,j;
  1386. /* Q: What happens if you try to remove a device which has
  1387.  *    a currently-open FTL partition on it?
  1388.  *
  1389.  * A: You don't. The ftl_open routine is responsible for
  1390.  *    increasing the use count of the driver module which
  1391.  *    it uses.
  1392.  */
  1394. /* That's the theory, anyway :) */
  1396. for (i=0; i< MAX_MTD_DEVICES; i++)
  1397. if (myparts[i] && myparts[i]->mtd == mtd) {
  1399. if (myparts[i]->state == FTL_FORMATTED)
  1400. ftl_freepart(myparts[i]);
  1402. myparts[i]->state = 0;
  1403. for (j=0; j<16; j++) {
  1404. ftl_gendisk.part[j].nr_sects=0;
  1405. ftl_gendisk.part[j].start_sect=0;
  1406. }
  1407. kfree(myparts[i]);
  1408. myparts[i] = NULL;
  1409. }
  1410. }
  1412. int init_ftl(void)
  1413. {
  1414.     int i;
  1416.     memset(myparts, 0, sizeof(myparts));
  1417.     
  1418.     DEBUG(0, "$Id: ftl.c,v 1.43 2002/02/13 15:31:37 dwmw2 Exp $n");
  1419.     
  1420.     if (register_blkdev(FTL_MAJOR, "ftl", &ftl_blk_fops)) {
  1421. printk(KERN_NOTICE "ftl_cs: unable to grab major "
  1422.        "device number!n");
  1423. return -EAGAIN;
  1424.     }
  1425.     
  1426.     for (i = 0; i < MINOR_NR(MAX_DEV, 0, 0); i++)
  1427. ftl_blocksizes[i] = 1024;
  1428.     for (i = 0; i < MAX_DEV*MAX_PART; i++) {
  1429. ftl_hd[i].nr_sects = 0;
  1430. ftl_hd[i].start_sect = 0;
  1431.     }
  1432.     blksize_size[FTL_MAJOR] = ftl_blocksizes;
  1433.     ftl_gendisk.major = FTL_MAJOR;
  1434.     blk_init_queue(BLK_DEFAULT_QUEUE(FTL_MAJOR), &do_ftl_request);
  1435.     add_gendisk(&ftl_gendisk);
  1436.     
  1437.     register_mtd_user(&ftl_notifier);
  1438.     
  1439.     return 0;
  1440. }
  1442. static void __exit cleanup_ftl(void)
  1443. {
  1444.     unregister_mtd_user(&ftl_notifier);
  1446.     unregister_blkdev(FTL_MAJOR, "ftl");
  1447.     blk_cleanup_queue(BLK_DEFAULT_QUEUE(FTL_MAJOR));
  1448.     blksize_size[FTL_MAJOR] = NULL;
  1450.     del_gendisk(&ftl_gendisk);
  1451. }
  1453. module_init(init_ftl);
  1454. module_exit(cleanup_ftl);
  1457. MODULE_LICENSE("Dual MPL/GPL");
  1458. MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
  1459. MODULE_DESCRIPTION("Support code for Flash Translation Layer, used on PCMCIA devices and M-Systems DiskOnChip 1000");