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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
nftlcore.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：31k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

nftlcore.c：源码内容
  1. /* Linux driver for NAND Flash Translation Layer      */
  2. /* (c) 1999 Machine Vision Holdings, Inc.             */
  3. /* Author: David Woodhouse <dwmw2@infradead.org>      */
  4. /* $Id: nftlcore.c,v 1.86 2002/03/06 14:38:17 dwmw2 Exp $ */
  6. /*
  7.   The contents of this file are distributed under the GNU General
  8.   Public License version 2. The author places no additional
  9.   restrictions of any kind on it.
  10.  */
  12. #define PRERELEASE
  14. #include <linux/config.h>
  15. #include <linux/kernel.h>
  16. #include <linux/module.h>
  17. #include <asm/errno.h>
  18. #include <asm/io.h>
  19. #include <asm/uaccess.h>
  20. #include <linux/miscdevice.h>
  21. #include <linux/pci.h>
  22. #include <linux/delay.h>
  23. #include <linux/slab.h>
  24. #include <linux/sched.h>
  25. #include <linux/init.h>
  26. #include <linux/blkpg.h>
  28. #ifdef CONFIG_KMOD
  29. #include <linux/kmod.h>
  30. #endif
  31. #include <linux/mtd/mtd.h>
  32. #include <linux/mtd/nftl.h>
  33. #include <linux/mtd/compatmac.h>
  35. /* maximum number of loops while examining next block, to have a
  36.    chance to detect consistency problems (they should never happen
  37.    because of the checks done in the mounting */
  39. #define MAX_LOOPS 10000
  41. /* NFTL block device stuff */
  42. #define MAJOR_NR NFTL_MAJOR
  43. #define DEVICE_REQUEST nftl_request
  44. #define DEVICE_OFF(device)
  47. #include <linux/blk.h>
  48. #include <linux/hdreg.h>
  50. /* Linux-specific block device functions */
  52. /* I _HATE_ the Linux block device setup more than anything else I've ever
  53.  *  encountered, except ...
  54.  */
  56. static int nftl_sizes[256];
  57. static int nftl_blocksizes[256];
  59. /* .. for the Linux partition table handling. */
  60. struct hd_struct part_table[256];
  62. #if LINUX_VERSION_CODE < 0x20328
  63. static void dummy_init (struct gendisk *crap)
  64. {}
  65. #endif
  67. static struct gendisk nftl_gendisk = {
  68. major: MAJOR_NR,
  69. major_name: "nftl",
  70. minor_shift: NFTL_PARTN_BITS, /* Bits to shift to get real from partition */
  71. max_p: (1<<NFTL_PARTN_BITS)-1, /* Number of partitions per real */
  72. #if LINUX_VERSION_CODE < 0x20328
  73. max_nr: MAX_NFTLS,      /* maximum number of real */
  74. init: dummy_init,     /* init function */
  75. #endif
  76. part: part_table,     /* hd struct */
  77. sizes: nftl_sizes,     /* block sizes */
  78. };
  80. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,14)
  81. #define BLK_INC_USE_COUNT MOD_INC_USE_COUNT
  82. #define BLK_DEC_USE_COUNT MOD_DEC_USE_COUNT
  83. #else
  84. #define BLK_INC_USE_COUNT do {} while(0)
  85. #define BLK_DEC_USE_COUNT do {} while(0)
  86. #endif
  88. struct NFTLrecord *NFTLs[MAX_NFTLS];
  90. static void NFTL_setup(struct mtd_info *mtd)
  91. {
  92. int i;
  93. struct NFTLrecord *nftl;
  94. unsigned long temp;
  95. int firstfree = -1;
  97. DEBUG(MTD_DEBUG_LEVEL1,"NFTL_setupn");
  99. for (i = 0; i < MAX_NFTLS; i++) {
  100. if (!NFTLs[i] && firstfree == -1)
  101. firstfree = i;
  102. else if (NFTLs[i] && NFTLs[i]->mtd == mtd) {
  103. /* This is a Spare Media Header for an NFTL we've already found */
  104. DEBUG(MTD_DEBUG_LEVEL1, "MTD already mounted as NFTLn");
  105. return;
  106. }
  107. }
  108.         if (firstfree == -1) {
  109. printk(KERN_WARNING "No more NFTL slot availablen");
  110. return;
  111.         }
  113. nftl = kmalloc(sizeof(struct NFTLrecord), GFP_KERNEL);
  114. if (!nftl) {
  115. printk(KERN_WARNING "Out of memory for NFTL data structuresn");
  116. return;
  117. }
  119. init_MUTEX(&nftl->mutex);
  121. nftl->mtd = mtd;
  123.         if (NFTL_mount(nftl) < 0) {
  124. printk(KERN_WARNING "Could not mount NFTL devicen");
  125. kfree(nftl);
  126. return;
  127.         }
  129. /* OK, it's a new one. Set up all the data structures. */
  130. #ifdef PSYCHO_DEBUG
  131. printk("Found new NFTL nftl%cn", firstfree + 'a');
  132. #endif
  134.         /* linux stuff */
  135. nftl->usecount = 0;
  136. nftl->cylinders = 1024;
  137. nftl->heads = 16;
  139. temp = nftl->cylinders * nftl->heads;
  140. nftl->sectors = nftl->nr_sects / temp;
  141. if (nftl->nr_sects % temp) {
  142. nftl->sectors++;
  143. temp = nftl->cylinders * nftl->sectors;
  144. nftl->heads = nftl->nr_sects / temp;
  146. if (nftl->nr_sects % temp) {
  147. nftl->heads++;
  148. temp = nftl->heads * nftl->sectors;
  149. nftl->cylinders = nftl->nr_sects / temp;
  150. }
  151. }
  153. if (nftl->nr_sects != nftl->heads * nftl->cylinders * nftl->sectors) {
  154. printk(KERN_WARNING "Cannot calculate an NFTL geometry to "
  155.        "match size of 0x%lx.n", nftl->nr_sects);
  156. printk(KERN_WARNING "Using C:%d H:%d S:%d (== 0x%lx sects)n", 
  157.        nftl->cylinders, nftl->heads , nftl->sectors, 
  158.        (long)nftl->cylinders * (long)nftl->heads * (long)nftl->sectors );
  160. /* Oh no we don't have nftl->nr_sects = nftl->heads * nftl->cylinders * nftl->sectors; */
  161. }
  162. NFTLs[firstfree] = nftl;
  163. /* Finally, set up the block device sizes */
  164. nftl_sizes[firstfree * 16] = nftl->nr_sects;
  165. //nftl_blocksizes[firstfree*16] = 512;
  166. part_table[firstfree * 16].nr_sects = nftl->nr_sects;
  168. nftl_gendisk.nr_real++;
  170. /* partition check ... */
  171. #if LINUX_VERSION_CODE < 0x20328
  172. resetup_one_dev(&nftl_gendisk, firstfree);
  173. #else
  174. grok_partitions(&nftl_gendisk, firstfree, 1<<NFTL_PARTN_BITS, nftl->nr_sects);
  175. #endif
  176. }
  178. static void NFTL_unsetup(int i)
  179. {
  180. struct NFTLrecord *nftl = NFTLs[i];
  182. DEBUG(MTD_DEBUG_LEVEL1, "NFTL_unsetup %dn", i);
  184. NFTLs[i] = NULL;
  186. if (nftl->ReplUnitTable)
  187. kfree(nftl->ReplUnitTable);
  188. if (nftl->EUNtable)
  189. kfree(nftl->EUNtable);
  190.       
  191. nftl_gendisk.nr_real--;
  192. kfree(nftl);
  193. }
  195. /* Search the MTD device for NFTL partitions */
  196. static void NFTL_notify_add(struct mtd_info *mtd)
  197. {
  198. DEBUG(MTD_DEBUG_LEVEL1, "NFTL_notify_add for %sn", mtd->name);
  200. if (mtd) {
  201. if (!mtd->read_oob) {
  202. /* If this MTD doesn't have out-of-band data,
  203.    then there's no point continuing */
  204. DEBUG(MTD_DEBUG_LEVEL1, "No OOB data, quittingn");
  205. return;
  206. }
  207. DEBUG(MTD_DEBUG_LEVEL3, "mtd->read = %p, size = %d, erasesize = %dn", 
  208.       mtd->read, mtd->size, mtd->erasesize);
  210.                 NFTL_setup(mtd);
  211. }
  212. }
  214. static void NFTL_notify_remove(struct mtd_info *mtd)
  215. {
  216. int i;
  218. for (i = 0; i < MAX_NFTLS; i++) {
  219. if (NFTLs[i] && NFTLs[i]->mtd == mtd)
  220. NFTL_unsetup(i);
  221. }
  222. }
  224. #ifdef CONFIG_NFTL_RW
  226. /* Actual NFTL access routines */
  227. /* NFTL_findfreeblock: Find a free Erase Unit on the NFTL partition. This function is used
  228.  * when the give Virtual Unit Chain
  229.  */
  230. static u16 NFTL_findfreeblock(struct NFTLrecord *nftl, int desperate )
  231. {
  232. /* For a given Virtual Unit Chain: find or create a free block and
  233.    add it to the chain */
  234. /* We're passed the number of the last EUN in the chain, to save us from
  235.    having to look it up again */
  236. u16 pot = nftl->LastFreeEUN;
  237. int silly = nftl->nb_blocks;
  239. /* Normally, we force a fold to happen before we run out of free blocks completely */
  240. if (!desperate && nftl->numfreeEUNs < 2) {
  241. DEBUG(MTD_DEBUG_LEVEL1, "NFTL_findfreeblock: there are too few free EUNsn");
  242. return 0xffff;
  243. }
  245. /* Scan for a free block */
  246. do {
  247. if (nftl->ReplUnitTable[pot] == BLOCK_FREE) {
  248. nftl->LastFreeEUN = pot;
  249. nftl->numfreeEUNs--;
  250. return pot;
  251. }
  253. /* This will probably point to the MediaHdr unit itself,
  254.    right at the beginning of the partition. But that unit
  255.    (and the backup unit too) should have the UCI set
  256.    up so that it's not selected for overwriting */
  257. if (++pot > nftl->lastEUN)
  258. pot = le16_to_cpu(nftl->MediaHdr.FirstPhysicalEUN);
  260. if (!silly--) {
  261. printk("Argh! No free blocks found! LastFreeEUN = %d, "
  262.        "FirstEUN = %dn", nftl->LastFreeEUN, 
  263.        le16_to_cpu(nftl->MediaHdr.FirstPhysicalEUN));
  264. return 0xffff;
  265. }
  266. } while (pot != nftl->LastFreeEUN);
  268. return 0xffff;
  269. }
  271. static u16 NFTL_foldchain (struct NFTLrecord *nftl, unsigned thisVUC, unsigned pendingblock )
  272. {
  273. u16 BlockMap[MAX_SECTORS_PER_UNIT];
  274. unsigned char BlockLastState[MAX_SECTORS_PER_UNIT];
  275. unsigned char BlockFreeFound[MAX_SECTORS_PER_UNIT];
  276. unsigned int thisEUN;
  277. int block;
  278. int silly;
  279. unsigned int targetEUN;
  280. struct nftl_oob oob;
  281. int inplace = 1;
  282.         size_t retlen;
  284. memset(BlockMap, 0xff, sizeof(BlockMap));
  285. memset(BlockFreeFound, 0, sizeof(BlockFreeFound));
  287. thisEUN = nftl->EUNtable[thisVUC];
  289. if (thisEUN == BLOCK_NIL) {
  290. printk(KERN_WARNING "Trying to fold non-existent "
  291.        "Virtual Unit Chain %d!n", thisVUC);
  292. return BLOCK_NIL;
  293. }
  295. /* Scan to find the Erase Unit which holds the actual data for each
  296.    512-byte block within the Chain.
  297. */
  298.         silly = MAX_LOOPS;
  299. targetEUN = BLOCK_NIL;
  300. while (thisEUN <= nftl->lastEUN ) {
  301.                 unsigned int status, foldmark;
  303. targetEUN = thisEUN;
  304. for (block = 0; block < nftl->EraseSize / 512; block ++) {
  305. MTD_READOOB(nftl->mtd,
  306.     (thisEUN * nftl->EraseSize) + (block * 512),
  307.     16 , &retlen, (char *)&oob);
  308. if (block == 2) {
  309.                                 foldmark = oob.u.c.FoldMark | oob.u.c.FoldMark1;
  310.                                 if (foldmark == FOLD_MARK_IN_PROGRESS) {
  311.                                         DEBUG(MTD_DEBUG_LEVEL1, 
  312.                                               "Write Inhibited on EUN %dn", thisEUN);
  313. inplace = 0;
  314. } else {
  315. /* There's no other reason not to do inplace,
  316.    except ones that come later. So we don't need
  317.    to preserve inplace */
  318. inplace = 1;
  319. }
  320. }
  321.                         status = oob.b.Status | oob.b.Status1;
  322. BlockLastState[block] = status;
  324. switch(status) {
  325. case SECTOR_FREE:
  326. BlockFreeFound[block] = 1;
  327. break;
  329. case SECTOR_USED:
  330. if (!BlockFreeFound[block])
  331. BlockMap[block] = thisEUN;
  332. else
  333. printk(KERN_WARNING 
  334.        "SECTOR_USED found after SECTOR_FREE "
  335.        "in Virtual Unit Chain %d for block %dn",
  336.        thisVUC, block);
  337. break;
  338. case SECTOR_DELETED:
  339. if (!BlockFreeFound[block])
  340. BlockMap[block] = BLOCK_NIL;
  341. else
  342. printk(KERN_WARNING 
  343.        "SECTOR_DELETED found after SECTOR_FREE "
  344.        "in Virtual Unit Chain %d for block %dn",
  345.        thisVUC, block);
  346. break;
  348. case SECTOR_IGNORE:
  349. break;
  350. default:
  351. printk("Unknown status for block %d in EUN %d: %xn",
  352.        block, thisEUN, status);
  353. }
  354. }
  356. if (!silly--) {
  357. printk(KERN_WARNING "Infinite loop in Virtual Unit Chain 0x%xn",
  358.        thisVUC);
  359. return BLOCK_NIL;
  360. }
  362. thisEUN = nftl->ReplUnitTable[thisEUN];
  363. }
  365. if (inplace) {
  366. /* We're being asked to be a fold-in-place. Check
  367.    that all blocks which actually have data associated
  368.    with them (i.e. BlockMap[block] != BLOCK_NIL) are 
  369.    either already present or SECTOR_FREE in the target
  370.    block. If not, we're going to have to fold out-of-place
  371.    anyway.
  372. */
  373. for (block = 0; block < nftl->EraseSize / 512 ; block++) {
  374. if (BlockLastState[block] != SECTOR_FREE &&
  375.     BlockMap[block] != BLOCK_NIL &&
  376.     BlockMap[block] != targetEUN) {
  377. DEBUG(MTD_DEBUG_LEVEL1, "Setting inplace to 0. VUC %d, "
  378.       "block %d was %x lastEUN, "
  379.       "and is in EUN %d (%s) %dn",
  380.       thisVUC, block, BlockLastState[block],
  381.       BlockMap[block], 
  382.       BlockMap[block]== targetEUN ? "==" : "!=",
  383.       targetEUN);
  384. inplace = 0;
  385. break;
  386. }
  387. }
  389. if (pendingblock >= (thisVUC * (nftl->EraseSize / 512)) &&
  390.     pendingblock < ((thisVUC + 1)* (nftl->EraseSize / 512)) &&
  391.     BlockLastState[pendingblock - (thisVUC * (nftl->EraseSize / 512))] !=
  392.     SECTOR_FREE) {
  393. DEBUG(MTD_DEBUG_LEVEL1, "Pending write not free in EUN %d. "
  394.       "Folding out of place.n", targetEUN);
  395. inplace = 0;
  396. }
  397. }
  399. if (!inplace) {
  400. DEBUG(MTD_DEBUG_LEVEL1, "Cannot fold Virtual Unit Chain %d in place. "
  401.       "Trying out-of-placen", thisVUC);
  402. /* We need to find a targetEUN to fold into. */
  403. targetEUN = NFTL_findfreeblock(nftl, 1);
  404. if (targetEUN == BLOCK_NIL) {
  405. /* Ouch. Now we're screwed. We need to do a 
  406.    fold-in-place of another chain to make room
  407.    for this one. We need a better way of selecting
  408.    which chain to fold, because makefreeblock will 
  409.    only ask us to fold the same one again.
  410. */
  411. printk(KERN_WARNING
  412.        "NFTL_findfreeblock(desperate) returns 0xffff.n");
  413. return BLOCK_NIL;
  414. }
  415. } else {
  416.             /* We put a fold mark in the chain we are folding only if
  417.                we fold in place to help the mount check code. If we do
  418.                not fold in place, it is possible to find the valid
  419.                chain by selecting the longer one */
  420.             oob.u.c.FoldMark = oob.u.c.FoldMark1 = cpu_to_le16(FOLD_MARK_IN_PROGRESS);
  421.             oob.u.c.unused = 0xffffffff;
  422.             MTD_WRITEOOB(nftl->mtd, (nftl->EraseSize * targetEUN) + 2 * 512 + 8, 
  423.                          8, &retlen, (char *)&oob.u);
  424.         }
  426. /* OK. We now know the location of every block in the Virtual Unit Chain,
  427.    and the Erase Unit into which we are supposed to be copying.
  428.    Go for it.
  429. */
  430. DEBUG(MTD_DEBUG_LEVEL1,"Folding chain %d into unit %dn", thisVUC, targetEUN);
  431. for (block = 0; block < nftl->EraseSize / 512 ; block++) {
  432. unsigned char movebuf[512];
  433. int ret;
  435. /* If it's in the target EUN already, or if it's pending write, do nothing */
  436. if (BlockMap[block] == targetEUN ||
  437.     (pendingblock == (thisVUC * (nftl->EraseSize / 512) + block))) {
  438. continue;
  439. }
  441.                 /* copy only in non free block (free blocks can only
  442.                    happen in case of media errors or deleted blocks) */
  443.                 if (BlockMap[block] == BLOCK_NIL)
  444.                         continue;
  445.                 
  446.                 ret = MTD_READECC(nftl->mtd, (nftl->EraseSize * BlockMap[block])
  447.                                   + (block * 512), 512, &retlen, movebuf, (char *)&oob); 
  448.                 if (ret < 0) {
  449.                     ret = MTD_READECC(nftl->mtd, (nftl->EraseSize * BlockMap[block])
  450.                                       + (block * 512), 512, &retlen,
  451.                                       movebuf, (char *)&oob); 
  452.                     if (ret != -EIO) 
  453.                         printk("Error went away on retry.n");
  454.                 }
  455.                 MTD_WRITEECC(nftl->mtd, (nftl->EraseSize * targetEUN) + (block * 512),
  456.                              512, &retlen, movebuf, (char *)&oob);
  457. }
  458.         
  459.         /* add the header so that it is now a valid chain */
  460.         oob.u.a.VirtUnitNum = oob.u.a.SpareVirtUnitNum
  461.                 = cpu_to_le16(thisVUC);
  462.         oob.u.a.ReplUnitNum = oob.u.a.SpareReplUnitNum = 0xffff;
  463.         
  464.         MTD_WRITEOOB(nftl->mtd, (nftl->EraseSize * targetEUN) + 8, 
  465.                      8, &retlen, (char *)&oob.u);
  467. /* OK. We've moved the whole lot into the new block. Now we have to free the original blocks. */
  469. /* At this point, we have two different chains for this Virtual Unit, and no way to tell 
  470.    them apart. If we crash now, we get confused. However, both contain the same data, so we
  471.    shouldn't actually lose data in this case. It's just that when we load up on a medium which
  472.    has duplicate chains, we need to free one of the chains because it's not necessary any more.
  473. */
  474. thisEUN = nftl->EUNtable[thisVUC];
  475. DEBUG(MTD_DEBUG_LEVEL1,"Want to erasen");
  477. /* For each block in the old chain (except the targetEUN of course), 
  478.    free it and make it available for future use */
  479. while (thisEUN <= nftl->lastEUN && thisEUN != targetEUN) {
  480. unsigned int EUNtmp;
  482.                 EUNtmp = nftl->ReplUnitTable[thisEUN];
  484.                 if (NFTL_formatblock(nftl, thisEUN) < 0) {
  485. /* could not erase : mark block as reserved
  486.  * FixMe: Update Bad Unit Table on disk
  487.  */
  488. nftl->ReplUnitTable[thisEUN] = BLOCK_RESERVED;
  489.                 } else {
  490. /* correctly erased : mark it as free */
  491. nftl->ReplUnitTable[thisEUN] = BLOCK_FREE;
  492. nftl->numfreeEUNs++;
  493.                 }
  494.                 thisEUN = EUNtmp;
  495. }
  497. /* Make this the new start of chain for thisVUC */
  498. nftl->ReplUnitTable[targetEUN] = BLOCK_NIL;
  499. nftl->EUNtable[thisVUC] = targetEUN;
  501. return targetEUN;
  502. }
  504. u16 NFTL_makefreeblock( struct NFTLrecord *nftl , unsigned pendingblock)
  505. {
  506. /* This is the part that needs some cleverness applied. 
  507.    For now, I'm doing the minimum applicable to actually
  508.    get the thing to work.
  509.    Wear-levelling and other clever stuff needs to be implemented
  510.    and we also need to do some assessment of the results when
  511.    the system loses power half-way through the routine.
  512. */
  513. u16 LongestChain = 0;
  514. u16 ChainLength = 0, thislen;
  515. u16 chain, EUN;
  517. for (chain = 0; chain < le32_to_cpu(nftl->MediaHdr.FormattedSize) / nftl->EraseSize; chain++) {
  518. EUN = nftl->EUNtable[chain];
  519. thislen = 0;
  521. while (EUN <= nftl->lastEUN) {
  522. thislen++;
  523. //printk("VUC %d reaches len %d with EUN %dn", chain, thislen, EUN);
  524. EUN = nftl->ReplUnitTable[EUN] & 0x7fff;
  525. if (thislen > 0xff00) {
  526. printk("Endless loop in Virtual Chain %d: Unit %xn",
  527.        chain, EUN);
  528. }
  529. if (thislen > 0xff10) {
  530. /* Actually, don't return failure. Just ignore this chain and
  531.    get on with it. */
  532. thislen = 0;
  533. break;
  534. }
  535. }
  537. if (thislen > ChainLength) {
  538. //printk("New longest chain is %d with length %dn", chain, thislen);
  539. ChainLength = thislen;
  540. LongestChain = chain;
  541. }
  542. }
  544. if (ChainLength < 2) {
  545. printk(KERN_WARNING "No Virtual Unit Chains available for folding. "
  546.        "Failing requestn");
  547. return 0xffff;
  548. }
  550. return NFTL_foldchain (nftl, LongestChain, pendingblock);
  551. }
  553. /* NFTL_findwriteunit: Return the unit number into which we can write 
  554.                        for this block. Make it available if it isn't already
  555. */
  556. static inline u16 NFTL_findwriteunit(struct NFTLrecord *nftl, unsigned block)
  557. {
  558. u16 lastEUN;
  559. u16 thisVUC = block / (nftl->EraseSize / 512);
  560. unsigned int writeEUN;
  561. unsigned long blockofs = (block * 512) & (nftl->EraseSize -1);
  562. size_t retlen;
  563. int silly, silly2 = 3;
  564. struct nftl_oob oob;
  566. do {
  567. /* Scan the media to find a unit in the VUC which has
  568.    a free space for the block in question.
  569. */
  571. /* This condition catches the 0x[7f]fff cases, as well as 
  572.    being a sanity check for past-end-of-media access
  573. */
  574. lastEUN = BLOCK_NIL;
  575. writeEUN = nftl->EUNtable[thisVUC];
  576.                 silly = MAX_LOOPS;
  577. while (writeEUN <= nftl->lastEUN) {
  578. struct nftl_bci bci;
  579. size_t retlen;
  580.                         unsigned int status;
  582. lastEUN = writeEUN;
  584. MTD_READOOB(nftl->mtd, (writeEUN * nftl->EraseSize) + blockofs,
  585.     8, &retlen, (char *)&bci);
  587. DEBUG(MTD_DEBUG_LEVEL2, "Status of block %d in EUN %d is %xn",
  588.       block , writeEUN, le16_to_cpu(bci.Status));
  590.                         status = bci.Status | bci.Status1;
  591. switch(status) {
  592. case SECTOR_FREE:
  593. return writeEUN;
  595. case SECTOR_DELETED:
  596. case SECTOR_USED:
  597. case SECTOR_IGNORE:
  598. break;
  599. default:
  600. // Invalid block. Don't use it any more. Must implement.
  601. break;
  602. }
  604. if (!silly--) { 
  605. printk(KERN_WARNING
  606.        "Infinite loop in Virtual Unit Chain 0x%xn",
  607.        thisVUC);
  608. return 0xffff;
  609. }
  611. /* Skip to next block in chain */
  612. writeEUN = nftl->ReplUnitTable[writeEUN];
  613. }
  615. /* OK. We didn't find one in the existing chain, or there 
  616.    is no existing chain. */
  618. /* Try to find an already-free block */
  619. writeEUN = NFTL_findfreeblock(nftl, 0);
  621. if (writeEUN == BLOCK_NIL) {
  622. /* That didn't work - there were no free blocks just
  623.    waiting to be picked up. We're going to have to fold
  624.    a chain to make room.
  625. */
  627. /* First remember the start of this chain */
  628. //u16 startEUN = nftl->EUNtable[thisVUC];
  630. //printk("Write to VirtualUnitChain %d, calling makefreeblock()n", thisVUC);
  631. writeEUN = NFTL_makefreeblock(nftl, 0xffff);
  633. if (writeEUN == BLOCK_NIL) {
  634. /* OK, we accept that the above comment is 
  635.    lying - there may have been free blocks
  636.    last time we called NFTL_findfreeblock(),
  637.    but they are reserved for when we're
  638.    desperate. Well, now we're desperate.
  639. */
  640. DEBUG(MTD_DEBUG_LEVEL1, "Using desperate==1 to find free EUN to accommodate write to VUC %dn", thisVUC);
  641. writeEUN = NFTL_findfreeblock(nftl, 1);
  642. }
  643. if (writeEUN == BLOCK_NIL) {
  644. /* Ouch. This should never happen - we should
  645.    always be able to make some room somehow. 
  646.    If we get here, we've allocated more storage 
  647.    space than actual media, or our makefreeblock
  648.    routine is missing something.
  649. */
  650. printk(KERN_WARNING "Cannot make free space.n");
  651. return BLOCK_NIL;
  652. }
  653. //printk("Restarting scann");
  654. lastEUN = BLOCK_NIL;
  655. continue;
  656. }
  658. /* We've found a free block. Insert it into the chain. */
  660. if (lastEUN != BLOCK_NIL) {
  661.                     thisVUC |= 0x8000; /* It's a replacement block */
  662. } else {
  663.                     /* The first block in a new chain */
  664.                     nftl->EUNtable[thisVUC] = writeEUN;
  665. }
  667. /* set up the actual EUN we're writing into */
  668. /* Both in our cache... */
  669. nftl->ReplUnitTable[writeEUN] = BLOCK_NIL;
  671. /* ... and on the flash itself */
  672. MTD_READOOB(nftl->mtd, writeEUN * nftl->EraseSize + 8, 8,
  673.     &retlen, (char *)&oob.u);
  675. oob.u.a.VirtUnitNum = oob.u.a.SpareVirtUnitNum = cpu_to_le16(thisVUC);
  677. MTD_WRITEOOB(nftl->mtd, writeEUN * nftl->EraseSize + 8, 8,
  678.                              &retlen, (char *)&oob.u);
  680.                 /* we link the new block to the chain only after the
  681.                    block is ready. It avoids the case where the chain
  682.                    could point to a free block */
  683.                 if (lastEUN != BLOCK_NIL) {
  684. /* Both in our cache... */
  685. nftl->ReplUnitTable[lastEUN] = writeEUN;
  686. /* ... and on the flash itself */
  687. MTD_READOOB(nftl->mtd, (lastEUN * nftl->EraseSize) + 8,
  688.     8, &retlen, (char *)&oob.u);
  690. oob.u.a.ReplUnitNum = oob.u.a.SpareReplUnitNum
  691. = cpu_to_le16(writeEUN);
  693. MTD_WRITEOOB(nftl->mtd, (lastEUN * nftl->EraseSize) + 8,
  694.      8, &retlen, (char *)&oob.u);
  695. }
  697. return writeEUN;
  699. } while (silly2--);
  701. printk(KERN_WARNING "Error folding to make room for Virtual Unit Chain 0x%xn",
  702.        thisVUC);
  703. return 0xffff;
  704. }
  706. static int NFTL_writeblock(struct NFTLrecord *nftl, unsigned block, char *buffer)
  707. {
  708. u16 writeEUN;
  709. unsigned long blockofs = (block * 512) & (nftl->EraseSize - 1);
  710. size_t retlen;
  711. u8 eccbuf[6];
  713. writeEUN = NFTL_findwriteunit(nftl, block);
  715. if (writeEUN == BLOCK_NIL) {
  716. printk(KERN_WARNING
  717.        "NFTL_writeblock(): Cannot find block to write ton");
  718. /* If we _still_ haven't got a block to use, we're screwed */
  719. return 1;
  720. }
  722. MTD_WRITEECC(nftl->mtd, (writeEUN * nftl->EraseSize) + blockofs,
  723.      512, &retlen, (char *)buffer, (char *)eccbuf);
  724.         /* no need to write SECTOR_USED flags since they are written in mtd_writeecc */
  726. return 0;
  727. }
  728. #endif /* CONFIG_NFTL_RW */
  730. static int NFTL_readblock(struct NFTLrecord *nftl, unsigned block, char *buffer)
  731. {
  732. u16 lastgoodEUN;
  733. u16 thisEUN = nftl->EUNtable[block / (nftl->EraseSize / 512)];
  734. unsigned long blockofs = (block * 512) & (nftl->EraseSize - 1);
  735.         unsigned int status;
  736. int silly = MAX_LOOPS;
  737.         size_t retlen;
  738.         struct nftl_bci bci;
  740. lastgoodEUN = BLOCK_NIL;
  742.         if (thisEUN != BLOCK_NIL) {
  743. while (thisEUN < nftl->nb_blocks) {
  744. if (MTD_READOOB(nftl->mtd, (thisEUN * nftl->EraseSize) + blockofs,
  745. 8, &retlen, (char *)&bci) < 0)
  746. status = SECTOR_IGNORE;
  747. else
  748. status = bci.Status | bci.Status1;
  750. switch (status) {
  751. case SECTOR_FREE:
  752. /* no modification of a sector should follow a free sector */
  753. goto the_end;
  754. case SECTOR_DELETED:
  755. lastgoodEUN = BLOCK_NIL;
  756. break;
  757. case SECTOR_USED:
  758. lastgoodEUN = thisEUN;
  759. break;
  760. case SECTOR_IGNORE:
  761. break;
  762. default:
  763. printk("Unknown status for block %d in EUN %d: %xn",
  764.        block, thisEUN, status);
  765. break;
  766. }
  768. if (!silly--) {
  769. printk(KERN_WARNING "Infinite loop in Virtual Unit Chain 0x%xn",
  770.        block / (nftl->EraseSize / 512));
  771. return 1;
  772. }
  773. thisEUN = nftl->ReplUnitTable[thisEUN];
  774. }
  775.         }
  777.  the_end:
  778. if (lastgoodEUN == BLOCK_NIL) {
  779. /* the requested block is not on the media, return all 0x00 */
  780. memset(buffer, 0, 512);
  781. } else {
  782. loff_t ptr = (lastgoodEUN * nftl->EraseSize) + blockofs;
  783. size_t retlen;
  784. u_char eccbuf[6];
  785. if (MTD_READECC(nftl->mtd, ptr, 512, &retlen, buffer, eccbuf))
  786. return -EIO;
  787. }
  788. return 0;
  789. }
  791. static int nftl_ioctl(struct inode * inode, struct file * file, unsigned int cmd, unsigned long arg)
  792. {
  793. struct NFTLrecord *nftl;
  794. int p;
  796. nftl = NFTLs[MINOR(inode->i_rdev) >> NFTL_PARTN_BITS];
  798. if (!nftl) return -EINVAL;
  800. switch (cmd) {
  801. case HDIO_GETGEO: {
  802. struct hd_geometry g;
  804. g.heads = nftl->heads;
  805. g.sectors = nftl->sectors;
  806. g.cylinders = nftl->cylinders;
  807. g.start = part_table[MINOR(inode->i_rdev)].start_sect;
  808. return copy_to_user((void *)arg, &g, sizeof g) ? -EFAULT : 0;
  809. }
  810. case BLKGETSIZE:   /* Return device size */
  811. return put_user(part_table[MINOR(inode->i_rdev)].nr_sects,
  812.                                 (unsigned long *) arg);
  814. #ifdef BLKGETSIZE64
  815. case BLKGETSIZE64:
  816. return put_user((u64)part_table[MINOR(inode->i_rdev)].nr_sects << 9,
  817.                                 (u64 *)arg);
  818. #endif
  820. case BLKFLSBUF:
  821. if (!capable(CAP_SYS_ADMIN)) return -EACCES;
  822. fsync_dev(inode->i_rdev);
  823. invalidate_buffers(inode->i_rdev);
  824. if (nftl->mtd->sync)
  825. nftl->mtd->sync(nftl->mtd);
  826. return 0;
  828. case BLKRRPART:
  829. if (!capable(CAP_SYS_ADMIN)) return -EACCES;
  830. if (nftl->usecount > 1) return -EBUSY;
  831. /* 
  832.  * We have to flush all buffers and invalidate caches,
  833.  * or we won't be able to re-use the partitions,
  834.  * if there was a change and we don't want to reboot
  835.  */
  836. p = (1<<NFTL_PARTN_BITS) - 1;
  837. while (p-- > 0) {
  838. kdev_t devp = MKDEV(MAJOR(inode->i_dev), MINOR(inode->i_dev)+p);
  839. if (part_table[p].nr_sects > 0)
  840. invalidate_device (devp, 1);
  842. part_table[MINOR(inode->i_dev)+p].start_sect = 0;
  843. part_table[MINOR(inode->i_dev)+p].nr_sects = 0;
  844. }
  846. #if LINUX_VERSION_CODE < 0x20328
  847. resetup_one_dev(&nftl_gendisk, MINOR(inode->i_rdev) >> NFTL_PARTN_BITS);
  848. #else
  849. grok_partitions(&nftl_gendisk, MINOR(inode->i_rdev) >> NFTL_PARTN_BITS,
  850. 1<<NFTL_PARTN_BITS, nftl->nr_sects);
  851. #endif
  852. return 0;
  854. #if (LINUX_VERSION_CODE < 0x20303)
  855. RO_IOCTLS(inode->i_rdev, arg);  /* ref. linux/blk.h */
  856. #else
  857. case BLKROSET:
  858. case BLKROGET:
  859. case BLKSSZGET:
  860. return blk_ioctl(inode->i_rdev, cmd, arg);
  861. #endif
  863. default:
  864. return -EINVAL;
  865. }
  866. }
  868. void nftl_request(RQFUNC_ARG)
  869. {
  870. unsigned int dev, block, nsect;
  871. struct NFTLrecord *nftl;
  872. char *buffer;
  873. struct request *req;
  874. int res;
  876. while (1) {
  877. INIT_REQUEST; /* blk.h */
  878. req = CURRENT;
  880. /* We can do this because the generic code knows not to
  881.    touch the request at the head of the queue */
  882. spin_unlock_irq(&io_request_lock);
  884. DEBUG(MTD_DEBUG_LEVEL2, "NFTL_requestn");
  885. DEBUG(MTD_DEBUG_LEVEL3, "NFTL %s request, from sector 0x%04lx for 0x%04lx sectorsn",
  886.       (req->cmd == READ) ? "Read " : "Write",
  887.       req->sector, req->current_nr_sectors);
  889. dev = MINOR(req->rq_dev);
  890. block = req->sector;
  891. nsect = req->current_nr_sectors;
  892. buffer = req->buffer;
  893. res = 1; /* succeed */
  895. if (dev >= MAX_NFTLS * (1<<NFTL_PARTN_BITS)) {
  896. /* there is no such partition */
  897. printk("nftl: bad minor number: device = %sn",
  898.        kdevname(req->rq_dev));
  899. res = 0; /* fail */
  900. goto repeat;
  901. }
  903. nftl = NFTLs[dev / (1<<NFTL_PARTN_BITS)];
  904. DEBUG(MTD_DEBUG_LEVEL3, "Waiting for mutexn");
  905. down(&nftl->mutex);
  906. DEBUG(MTD_DEBUG_LEVEL3, "Got mutexn");
  908. if (block + nsect > part_table[dev].nr_sects) {
  909. /* access past the end of device */
  910. printk("nftl%c%d: bad access: block = %d, count = %dn",
  911.        (MINOR(req->rq_dev)>>6)+'a', dev & 0xf, block, nsect);
  912. up(&nftl->mutex);
  913. res = 0; /* fail */
  914. goto repeat;
  915. }
  917. block += part_table[dev].start_sect;
  919. if (req->cmd == READ) {
  920. DEBUG(MTD_DEBUG_LEVEL2, "NFTL read request of 0x%x sectors @ %x "
  921.       "(req->nr_sectors == %lx)n", nsect, block, req->nr_sectors);
  923. for ( ; nsect > 0; nsect-- , block++, buffer += 512) {
  924. /* Read a single sector to req->buffer + (512 * i) */
  925. if (NFTL_readblock(nftl, block, buffer)) {
  926. DEBUG(MTD_DEBUG_LEVEL2, "NFTL read request failedn");
  927. up(&nftl->mutex);
  928. res = 0;
  929. goto repeat;
  930. }
  931. }
  933. DEBUG(MTD_DEBUG_LEVEL2,"NFTL read request completed OKn");
  934. up(&nftl->mutex);
  935. goto repeat;
  936. } else if (req->cmd == WRITE) {
  937. DEBUG(MTD_DEBUG_LEVEL2, "NFTL write request of 0x%x sectors @ %x "
  938.       "(req->nr_sectors == %lx)n", nsect, block,
  939.       req->nr_sectors);
  940. #ifdef CONFIG_NFTL_RW
  941. for ( ; nsect > 0; nsect-- , block++, buffer += 512) {
  942. /* Read a single sector to req->buffer + (512 * i) */
  943. if (NFTL_writeblock(nftl, block, buffer)) {
  944. DEBUG(MTD_DEBUG_LEVEL1,"NFTL write request failedn");
  945. up(&nftl->mutex);
  946. res = 0;
  947. goto repeat;
  948. }
  949. }
  950. DEBUG(MTD_DEBUG_LEVEL2,"NFTL write request completed OKn");
  951. #else
  952. res = 0; /* Writes always fail */
  953. #endif /* CONFIG_NFTL_RW */
  954. up(&nftl->mutex);
  955. goto repeat;
  956. } else {
  957. DEBUG(MTD_DEBUG_LEVEL0, "NFTL unknown requestn");
  958. up(&nftl->mutex);
  959. res = 0;
  960. goto repeat;
  961. }
  962. repeat: 
  963. DEBUG(MTD_DEBUG_LEVEL3, "end_request(%d)n", res);
  964. spin_lock_irq(&io_request_lock);
  965. end_request(res);
  966. }
  967. }
  969. static int nftl_open(struct inode *ip, struct file *fp)
  970. {
  971. int nftlnum = MINOR(ip->i_rdev) >> NFTL_PARTN_BITS;
  972. struct NFTLrecord *thisNFTL;
  973. thisNFTL = NFTLs[nftlnum];
  975. DEBUG(MTD_DEBUG_LEVEL2,"NFTL_openn");
  977. #ifdef CONFIG_KMOD
  978. if (!thisNFTL && nftlnum == 0) {
  979. request_module("docprobe");
  980. thisNFTL = NFTLs[nftlnum];
  981. }
  982. #endif
  983. if (!thisNFTL) {
  984. DEBUG(MTD_DEBUG_LEVEL2,"ENODEV: thisNFTL = %d, minor = %d, ip = %p, fp = %pn", 
  985.       nftlnum, ip->i_rdev, ip, fp);
  986. return -ENODEV;
  987. }
  989. #ifndef CONFIG_NFTL_RW
  990. if (fp->f_mode & FMODE_WRITE)
  991. return -EROFS;
  992. #endif /* !CONFIG_NFTL_RW */
  994. thisNFTL->usecount++;
  995. BLK_INC_USE_COUNT;
  996. if (!get_mtd_device(thisNFTL->mtd, -1)) {
  997. BLK_DEC_USE_COUNT;
  998. return -ENXIO;
  999. }
  1001. return 0;
  1002. }
  1004. static int nftl_release(struct inode *inode, struct file *fp)
  1005. {
  1006. struct NFTLrecord *thisNFTL;
  1008. thisNFTL = NFTLs[MINOR(inode->i_rdev) / 16];
  1010. DEBUG(MTD_DEBUG_LEVEL2, "NFTL_releasen");
  1012. if (thisNFTL->mtd->sync)
  1013. thisNFTL->mtd->sync(thisNFTL->mtd);
  1014. thisNFTL->usecount--;
  1015. BLK_DEC_USE_COUNT;
  1017. put_mtd_device(thisNFTL->mtd);
  1019. return 0;
  1020. }
  1021. #if LINUX_VERSION_CODE < 0x20326
  1022. static struct file_operations nftl_fops = {
  1023. read: block_read,
  1024. write: block_write,
  1025. ioctl: nftl_ioctl,
  1026. open: nftl_open,
  1027. release: nftl_release,
  1028. fsync: block_fsync,
  1029. };
  1030. #else
  1031. static struct block_device_operations nftl_fops = 
  1032. {
  1033. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,14)
  1034. owner: THIS_MODULE,
  1035. #endif
  1036. open: nftl_open,
  1037. release: nftl_release,
  1038. ioctl:  nftl_ioctl
  1039. };
  1040. #endif
  1044. /****************************************************************************
  1045.  *
  1046.  * Module stuff
  1047.  *
  1048.  ****************************************************************************/
  1050. static struct mtd_notifier nftl_notifier = {
  1051. add: NFTL_notify_add,
  1052. remove: NFTL_notify_remove
  1053. };
  1055. extern char nftlmountrev[];
  1057. int __init init_nftl(void)
  1058. {
  1059. int i;
  1061. #ifdef PRERELEASE 
  1062. printk(KERN_INFO "NFTL driver: nftlcore.c $Revision: 1.86 $, nftlmount.c %sn", nftlmountrev);
  1063. #endif
  1065. if (register_blkdev(MAJOR_NR, "nftl", &nftl_fops)){
  1066. printk("unable to register NFTL block device on major %dn", MAJOR_NR);
  1067. return -EBUSY;
  1068. } else {
  1069. blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), &nftl_request);
  1071. /* set block size to 1kB each */
  1072. for (i = 0; i < 256; i++) {
  1073. nftl_blocksizes[i] = 1024;
  1074. }
  1075. blksize_size[MAJOR_NR] = nftl_blocksizes;
  1077. add_gendisk(&nftl_gendisk);
  1078. }
  1080. register_mtd_user(&nftl_notifier);
  1082. return 0;
  1083. }
  1085. static void __exit cleanup_nftl(void)
  1086. {
  1087.    unregister_mtd_user(&nftl_notifier);
  1088.    unregister_blkdev(MAJOR_NR, "nftl");
  1089.   
  1090.    blk_cleanup_queue(BLK_DEFAULT_QUEUE(MAJOR_NR));
  1092. del_gendisk(&nftl_gendisk);
  1093. }
  1095. module_init(init_nftl);
  1096. module_exit(cleanup_nftl);
  1098. MODULE_LICENSE("GPL");
  1099. MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>, Fabrice Bellard <fabrice.bellard@netgem.com> et al.");
  1100. MODULE_DESCRIPTION("Support code for NAND Flash Translation Layer, used on M-Systems DiskOnChip 2000 and Millennium");