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.98 2005/11/07 11:14:21 gleixner Exp $ */ 5 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 */ 11 12 #define PRERELEASE 13 14 #include <linux/kernel.h> 15 #include <linux/module.h> 16 #include <asm/errno.h> 17 #include <asm/io.h> 18 #include <asm/uaccess.h> 19 #include <linux/miscdevice.h> 20 #include <linux/delay.h> 21 #include <linux/slab.h> 22 #include <linux/init.h> 23 #include <linux/hdreg.h> 24 25 #include <linux/kmod.h> 26 #include <linux/mtd/mtd.h> 27 #include <linux/mtd/nand.h> 28 #include <linux/mtd/nftl.h> 29 #include <linux/mtd/blktrans.h> 30 31 /* maximum number of loops while examining next block, to have a 32 chance to detect consistency problems (they should never happen 33 because of the checks done in the mounting */ 34 35 #define MAX_LOOPS 10000 36 37 38 static void nftl_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd) 39 { 40 struct NFTLrecord *nftl; 41 unsigned long temp; 42 43 if (mtd->type != MTD_NANDFLASH) 44 return; 45 /* OK, this is moderately ugly. But probably safe. Alternatives? */ 46 if (memcmp(mtd->name, "DiskOnChip", 10)) 47 return; 48 49 if (!mtd->block_isbad) { 50 printk(KERN_ERR 51 "NFTL no longer supports the old DiskOnChip drivers loaded via docprobe.\n" 52 "Please use the new diskonchip driver under the NAND subsystem.\n"); 53 return; 54 } 55 56 DEBUG(MTD_DEBUG_LEVEL1, "NFTL: add_mtd for %s\n", mtd->name); 57 58 nftl = kzalloc(sizeof(struct NFTLrecord), GFP_KERNEL); 59 60 if (!nftl) { 61 printk(KERN_WARNING "NFTL: out of memory for data structures\n"); 62 return; 63 } 64 65 nftl->mbd.mtd = mtd; 66 nftl->mbd.devnum = -1; 67 68 nftl->mbd.tr = tr; 69 70 if (NFTL_mount(nftl) < 0) { 71 printk(KERN_WARNING "NFTL: could not mount device\n"); 72 kfree(nftl); 73 return; 74 } 75 76 /* OK, it's a new one. Set up all the data structures. */ 77 78 /* Calculate geometry */ 79 nftl->cylinders = 1024; 80 nftl->heads = 16; 81 82 temp = nftl->cylinders * nftl->heads; 83 nftl->sectors = nftl->mbd.size / temp; 84 if (nftl->mbd.size % temp) { 85 nftl->sectors++; 86 temp = nftl->cylinders * nftl->sectors; 87 nftl->heads = nftl->mbd.size / temp; 88 89 if (nftl->mbd.size % temp) { 90 nftl->heads++; 91 temp = nftl->heads * nftl->sectors; 92 nftl->cylinders = nftl->mbd.size / temp; 93 } 94 } 95 96 if (nftl->mbd.size != nftl->heads * nftl->cylinders * nftl->sectors) { 97 /* 98 Oh no we don't have 99 mbd.size == heads * cylinders * sectors 100 */ 101 printk(KERN_WARNING "NFTL: cannot calculate a geometry to " 102 "match size of 0x%lx.\n", nftl->mbd.size); 103 printk(KERN_WARNING "NFTL: using C:%d H:%d S:%d " 104 "(== 0x%lx sects)\n", 105 nftl->cylinders, nftl->heads , nftl->sectors, 106 (long)nftl->cylinders * (long)nftl->heads * 107 (long)nftl->sectors ); 108 } 109 110 if (add_mtd_blktrans_dev(&nftl->mbd)) { 111 kfree(nftl->ReplUnitTable); 112 kfree(nftl->EUNtable); 113 kfree(nftl); 114 return; 115 } 116 #ifdef PSYCHO_DEBUG 117 printk(KERN_INFO "NFTL: Found new nftl%c\n", nftl->mbd.devnum + 'a'); 118 #endif 119 } 120 121 static void nftl_remove_dev(struct mtd_blktrans_dev *dev) 122 { 123 struct NFTLrecord *nftl = (void *)dev; 124 125 DEBUG(MTD_DEBUG_LEVEL1, "NFTL: remove_dev (i=%d)\n", dev->devnum); 126 127 del_mtd_blktrans_dev(dev); 128 kfree(nftl->ReplUnitTable); 129 kfree(nftl->EUNtable); 130 kfree(nftl); 131 } 132 133 /* 134 * Read oob data from flash 135 */ 136 int nftl_read_oob(struct mtd_info *mtd, loff_t offs, size_t len, 137 size_t *retlen, uint8_t *buf) 138 { 139 struct mtd_oob_ops ops; 140 int res; 141 142 ops.mode = MTD_OOB_PLACE; 143 ops.ooboffs = offs & (mtd->writesize - 1); 144 ops.ooblen = len; 145 ops.oobbuf = buf; 146 ops.datbuf = NULL; 147 148 res = mtd->read_oob(mtd, offs & ~(mtd->writesize - 1), &ops); 149 *retlen = ops.oobretlen; 150 return res; 151 } 152 153 /* 154 * Write oob data to flash 155 */ 156 int nftl_write_oob(struct mtd_info *mtd, loff_t offs, size_t len, 157 size_t *retlen, uint8_t *buf) 158 { 159 struct mtd_oob_ops ops; 160 int res; 161 162 ops.mode = MTD_OOB_PLACE; 163 ops.ooboffs = offs & (mtd->writesize - 1); 164 ops.ooblen = len; 165 ops.oobbuf = buf; 166 ops.datbuf = NULL; 167 168 res = mtd->write_oob(mtd, offs & ~(mtd->writesize - 1), &ops); 169 *retlen = ops.oobretlen; 170 return res; 171 } 172 173 #ifdef CONFIG_NFTL_RW 174 175 /* 176 * Write data and oob to flash 177 */ 178 static int nftl_write(struct mtd_info *mtd, loff_t offs, size_t len, 179 size_t *retlen, uint8_t *buf, uint8_t *oob) 180 { 181 struct mtd_oob_ops ops; 182 int res; 183 184 ops.mode = MTD_OOB_PLACE; 185 ops.ooboffs = offs; 186 ops.ooblen = mtd->oobsize; 187 ops.oobbuf = oob; 188 ops.datbuf = buf; 189 ops.len = len; 190 191 res = mtd->write_oob(mtd, offs & ~(mtd->writesize - 1), &ops); 192 *retlen = ops.retlen; 193 return res; 194 } 195 196 /* Actual NFTL access routines */ 197 /* NFTL_findfreeblock: Find a free Erase Unit on the NFTL partition. This function is used 198 * when the give Virtual Unit Chain 199 */ 200 static u16 NFTL_findfreeblock(struct NFTLrecord *nftl, int desperate ) 201 { 202 /* For a given Virtual Unit Chain: find or create a free block and 203 add it to the chain */ 204 /* We're passed the number of the last EUN in the chain, to save us from 205 having to look it up again */ 206 u16 pot = nftl->LastFreeEUN; 207 int silly = nftl->nb_blocks; 208 209 /* Normally, we force a fold to happen before we run out of free blocks completely */ 210 if (!desperate && nftl->numfreeEUNs < 2) { 211 DEBUG(MTD_DEBUG_LEVEL1, "NFTL_findfreeblock: there are too few free EUNs\n"); 212 return 0xffff; 213 } 214 215 /* Scan for a free block */ 216 do { 217 if (nftl->ReplUnitTable[pot] == BLOCK_FREE) { 218 nftl->LastFreeEUN = pot; 219 nftl->numfreeEUNs--; 220 return pot; 221 } 222 223 /* This will probably point to the MediaHdr unit itself, 224 right at the beginning of the partition. But that unit 225 (and the backup unit too) should have the UCI set 226 up so that it's not selected for overwriting */ 227 if (++pot > nftl->lastEUN) 228 pot = le16_to_cpu(nftl->MediaHdr.FirstPhysicalEUN); 229 230 if (!silly--) { 231 printk("Argh! No free blocks found! LastFreeEUN = %d, " 232 "FirstEUN = %d\n", nftl->LastFreeEUN, 233 le16_to_cpu(nftl->MediaHdr.FirstPhysicalEUN)); 234 return 0xffff; 235 } 236 } while (pot != nftl->LastFreeEUN); 237 238 return 0xffff; 239 } 240 241 static u16 NFTL_foldchain (struct NFTLrecord *nftl, unsigned thisVUC, unsigned pendingblock ) 242 { 243 struct mtd_info *mtd = nftl->mbd.mtd; 244 u16 BlockMap[MAX_SECTORS_PER_UNIT]; 245 unsigned char BlockLastState[MAX_SECTORS_PER_UNIT]; 246 unsigned char BlockFreeFound[MAX_SECTORS_PER_UNIT]; 247 unsigned int thisEUN; 248 int block; 249 int silly; 250 unsigned int targetEUN; 251 struct nftl_oob oob; 252 int inplace = 1; 253 size_t retlen; 254 255 memset(BlockMap, 0xff, sizeof(BlockMap)); 256 memset(BlockFreeFound, 0, sizeof(BlockFreeFound)); 257 258 thisEUN = nftl->EUNtable[thisVUC]; 259 260 if (thisEUN == BLOCK_NIL) { 261 printk(KERN_WARNING "Trying to fold non-existent " 262 "Virtual Unit Chain %d!\n", thisVUC); 263 return BLOCK_NIL; 264 } 265 266 /* Scan to find the Erase Unit which holds the actual data for each 267 512-byte block within the Chain. 268 */ 269 silly = MAX_LOOPS; 270 targetEUN = BLOCK_NIL; 271 while (thisEUN <= nftl->lastEUN ) { 272 unsigned int status, foldmark; 273 274 targetEUN = thisEUN; 275 for (block = 0; block < nftl->EraseSize / 512; block ++) { 276 nftl_read_oob(mtd, (thisEUN * nftl->EraseSize) + 277 (block * 512), 16 , &retlen, 278 (char *)&oob); 279 if (block == 2) { 280 foldmark = oob.u.c.FoldMark | oob.u.c.FoldMark1; 281 if (foldmark == FOLD_MARK_IN_PROGRESS) { 282 DEBUG(MTD_DEBUG_LEVEL1, 283 "Write Inhibited on EUN %d\n", thisEUN); 284 inplace = 0; 285 } else { 286 /* There's no other reason not to do inplace, 287 except ones that come later. So we don't need 288 to preserve inplace */ 289 inplace = 1; 290 } 291 } 292 status = oob.b.Status | oob.b.Status1; 293 BlockLastState[block] = status; 294 295 switch(status) { 296 case SECTOR_FREE: 297 BlockFreeFound[block] = 1; 298 break; 299 300 case SECTOR_USED: 301 if (!BlockFreeFound[block]) 302 BlockMap[block] = thisEUN; 303 else 304 printk(KERN_WARNING 305 "SECTOR_USED found after SECTOR_FREE " 306 "in Virtual Unit Chain %d for block %d\n", 307 thisVUC, block); 308 break; 309 case SECTOR_DELETED: 310 if (!BlockFreeFound[block]) 311 BlockMap[block] = BLOCK_NIL; 312 else 313 printk(KERN_WARNING 314 "SECTOR_DELETED found after SECTOR_FREE " 315 "in Virtual Unit Chain %d for block %d\n", 316 thisVUC, block); 317 break; 318 319 case SECTOR_IGNORE: 320 break; 321 default: 322 printk("Unknown status for block %d in EUN %d: %x\n", 323 block, thisEUN, status); 324 } 325 } 326 327 if (!silly--) { 328 printk(KERN_WARNING "Infinite loop in Virtual Unit Chain 0x%x\n", 329 thisVUC); 330 return BLOCK_NIL; 331 } 332 333 thisEUN = nftl->ReplUnitTable[thisEUN]; 334 } 335 336 if (inplace) { 337 /* We're being asked to be a fold-in-place. Check 338 that all blocks which actually have data associated 339 with them (i.e. BlockMap[block] != BLOCK_NIL) are 340 either already present or SECTOR_FREE in the target 341 block. If not, we're going to have to fold out-of-place 342 anyway. 343 */ 344 for (block = 0; block < nftl->EraseSize / 512 ; block++) { 345 if (BlockLastState[block] != SECTOR_FREE && 346 BlockMap[block] != BLOCK_NIL && 347 BlockMap[block] != targetEUN) { 348 DEBUG(MTD_DEBUG_LEVEL1, "Setting inplace to 0. VUC %d, " 349 "block %d was %x lastEUN, " 350 "and is in EUN %d (%s) %d\n", 351 thisVUC, block, BlockLastState[block], 352 BlockMap[block], 353 BlockMap[block]== targetEUN ? "==" : "!=", 354 targetEUN); 355 inplace = 0; 356 break; 357 } 358 } 359 360 if (pendingblock >= (thisVUC * (nftl->EraseSize / 512)) && 361 pendingblock < ((thisVUC + 1)* (nftl->EraseSize / 512)) && 362 BlockLastState[pendingblock - (thisVUC * (nftl->EraseSize / 512))] != 363 SECTOR_FREE) { 364 DEBUG(MTD_DEBUG_LEVEL1, "Pending write not free in EUN %d. " 365 "Folding out of place.\n", targetEUN); 366 inplace = 0; 367 } 368 } 369 370 if (!inplace) { 371 DEBUG(MTD_DEBUG_LEVEL1, "Cannot fold Virtual Unit Chain %d in place. " 372 "Trying out-of-place\n", thisVUC); 373 /* We need to find a targetEUN to fold into. */ 374 targetEUN = NFTL_findfreeblock(nftl, 1); 375 if (targetEUN == BLOCK_NIL) { 376 /* Ouch. Now we're screwed. We need to do a 377 fold-in-place of another chain to make room 378 for this one. We need a better way of selecting 379 which chain to fold, because makefreeblock will 380 only ask us to fold the same one again. 381 */ 382 printk(KERN_WARNING 383 "NFTL_findfreeblock(desperate) returns 0xffff.\n"); 384 return BLOCK_NIL; 385 } 386 } else { 387 /* We put a fold mark in the chain we are folding only if we 388 fold in place to help the mount check code. If we do not fold in 389 place, it is possible to find the valid chain by selecting the 390 longer one */ 391 oob.u.c.FoldMark = oob.u.c.FoldMark1 = cpu_to_le16(FOLD_MARK_IN_PROGRESS); 392 oob.u.c.unused = 0xffffffff; 393 nftl_write_oob(mtd, (nftl->EraseSize * targetEUN) + 2 * 512 + 8, 394 8, &retlen, (char *)&oob.u); 395 } 396 397 /* OK. We now know the location of every block in the Virtual Unit Chain, 398 and the Erase Unit into which we are supposed to be copying. 399 Go for it. 400 */ 401 DEBUG(MTD_DEBUG_LEVEL1,"Folding chain %d into unit %d\n", thisVUC, targetEUN); 402 for (block = 0; block < nftl->EraseSize / 512 ; block++) { 403 unsigned char movebuf[512]; 404 int ret; 405 406 /* If it's in the target EUN already, or if it's pending write, do nothing */ 407 if (BlockMap[block] == targetEUN || 408 (pendingblock == (thisVUC * (nftl->EraseSize / 512) + block))) { 409 continue; 410 } 411 412 /* copy only in non free block (free blocks can only 413 happen in case of media errors or deleted blocks) */ 414 if (BlockMap[block] == BLOCK_NIL) 415 continue; 416 417 ret = mtd->read(mtd, (nftl->EraseSize * BlockMap[block]) + (block * 512), 418 512, &retlen, movebuf); 419 if (ret < 0 && ret != -EUCLEAN) { 420 ret = mtd->read(mtd, (nftl->EraseSize * BlockMap[block]) 421 + (block * 512), 512, &retlen, 422 movebuf); 423 if (ret != -EIO) 424 printk("Error went away on retry.\n"); 425 } 426 memset(&oob, 0xff, sizeof(struct nftl_oob)); 427 oob.b.Status = oob.b.Status1 = SECTOR_USED; 428 429 nftl_write(nftl->mbd.mtd, (nftl->EraseSize * targetEUN) + 430 (block * 512), 512, &retlen, movebuf, (char *)&oob); 431 } 432 433 /* add the header so that it is now a valid chain */ 434 oob.u.a.VirtUnitNum = oob.u.a.SpareVirtUnitNum = cpu_to_le16(thisVUC); 435 oob.u.a.ReplUnitNum = oob.u.a.SpareReplUnitNum = 0xffff; 436 437 nftl_write_oob(mtd, (nftl->EraseSize * targetEUN) + 8, 438 8, &retlen, (char *)&oob.u); 439 440 /* OK. We've moved the whole lot into the new block. Now we have to free the original blocks. */ 441 442 /* At this point, we have two different chains for this Virtual Unit, and no way to tell 443 them apart. If we crash now, we get confused. However, both contain the same data, so we 444 shouldn't actually lose data in this case. It's just that when we load up on a medium which 445 has duplicate chains, we need to free one of the chains because it's not necessary any more. 446 */ 447 thisEUN = nftl->EUNtable[thisVUC]; 448 DEBUG(MTD_DEBUG_LEVEL1,"Want to erase\n"); 449 450 /* For each block in the old chain (except the targetEUN of course), 451 free it and make it available for future use */ 452 while (thisEUN <= nftl->lastEUN && thisEUN != targetEUN) { 453 unsigned int EUNtmp; 454 455 EUNtmp = nftl->ReplUnitTable[thisEUN]; 456 457 if (NFTL_formatblock(nftl, thisEUN) < 0) { 458 /* could not erase : mark block as reserved 459 */ 460 nftl->ReplUnitTable[thisEUN] = BLOCK_RESERVED; 461 } else { 462 /* correctly erased : mark it as free */ 463 nftl->ReplUnitTable[thisEUN] = BLOCK_FREE; 464 nftl->numfreeEUNs++; 465 } 466 thisEUN = EUNtmp; 467 } 468 469 /* Make this the new start of chain for thisVUC */ 470 nftl->ReplUnitTable[targetEUN] = BLOCK_NIL; 471 nftl->EUNtable[thisVUC] = targetEUN; 472 473 return targetEUN; 474 } 475 476 static u16 NFTL_makefreeblock( struct NFTLrecord *nftl , unsigned pendingblock) 477 { 478 /* This is the part that needs some cleverness applied. 479 For now, I'm doing the minimum applicable to actually 480 get the thing to work. 481 Wear-levelling and other clever stuff needs to be implemented 482 and we also need to do some assessment of the results when 483 the system loses power half-way through the routine. 484 */ 485 u16 LongestChain = 0; 486 u16 ChainLength = 0, thislen; 487 u16 chain, EUN; 488 489 for (chain = 0; chain < le32_to_cpu(nftl->MediaHdr.FormattedSize) / nftl->EraseSize; chain++) { 490 EUN = nftl->EUNtable[chain]; 491 thislen = 0; 492 493 while (EUN <= nftl->lastEUN) { 494 thislen++; 495 //printk("VUC %d reaches len %d with EUN %d\n", chain, thislen, EUN); 496 EUN = nftl->ReplUnitTable[EUN] & 0x7fff; 497 if (thislen > 0xff00) { 498 printk("Endless loop in Virtual Chain %d: Unit %x\n", 499 chain, EUN); 500 } 501 if (thislen > 0xff10) { 502 /* Actually, don't return failure. Just ignore this chain and 503 get on with it. */ 504 thislen = 0; 505 break; 506 } 507 } 508 509 if (thislen > ChainLength) { 510 //printk("New longest chain is %d with length %d\n", chain, thislen); 511 ChainLength = thislen; 512 LongestChain = chain; 513 } 514 } 515 516 if (ChainLength < 2) { 517 printk(KERN_WARNING "No Virtual Unit Chains available for folding. " 518 "Failing request\n"); 519 return 0xffff; 520 } 521 522 return NFTL_foldchain (nftl, LongestChain, pendingblock); 523 } 524 525 /* NFTL_findwriteunit: Return the unit number into which we can write 526 for this block. Make it available if it isn't already 527 */ 528 static inline u16 NFTL_findwriteunit(struct NFTLrecord *nftl, unsigned block) 529 { 530 u16 lastEUN; 531 u16 thisVUC = block / (nftl->EraseSize / 512); 532 struct mtd_info *mtd = nftl->mbd.mtd; 533 unsigned int writeEUN; 534 unsigned long blockofs = (block * 512) & (nftl->EraseSize -1); 535 size_t retlen; 536 int silly, silly2 = 3; 537 struct nftl_oob oob; 538 539 do { 540 /* Scan the media to find a unit in the VUC which has 541 a free space for the block in question. 542 */ 543 544 /* This condition catches the 0x[7f]fff cases, as well as 545 being a sanity check for past-end-of-media access 546 */ 547 lastEUN = BLOCK_NIL; 548 writeEUN = nftl->EUNtable[thisVUC]; 549 silly = MAX_LOOPS; 550 while (writeEUN <= nftl->lastEUN) { 551 struct nftl_bci bci; 552 size_t retlen; 553 unsigned int status; 554 555 lastEUN = writeEUN; 556 557 nftl_read_oob(mtd, 558 (writeEUN * nftl->EraseSize) + blockofs, 559 8, &retlen, (char *)&bci); 560 561 DEBUG(MTD_DEBUG_LEVEL2, "Status of block %d in EUN %d is %x\n", 562 block , writeEUN, le16_to_cpu(bci.Status)); 563 564 status = bci.Status | bci.Status1; 565 switch(status) { 566 case SECTOR_FREE: 567 return writeEUN; 568 569 case SECTOR_DELETED: 570 case SECTOR_USED: 571 case SECTOR_IGNORE: 572 break; 573 default: 574 // Invalid block. Don't use it any more. Must implement. 575 break; 576 } 577 578 if (!silly--) { 579 printk(KERN_WARNING 580 "Infinite loop in Virtual Unit Chain 0x%x\n", 581 thisVUC); 582 return 0xffff; 583 } 584 585 /* Skip to next block in chain */ 586 writeEUN = nftl->ReplUnitTable[writeEUN]; 587 } 588 589 /* OK. We didn't find one in the existing chain, or there 590 is no existing chain. */ 591 592 /* Try to find an already-free block */ 593 writeEUN = NFTL_findfreeblock(nftl, 0); 594 595 if (writeEUN == BLOCK_NIL) { 596 /* That didn't work - there were no free blocks just 597 waiting to be picked up. We're going to have to fold 598 a chain to make room. 599 */ 600 601 /* First remember the start of this chain */ 602 //u16 startEUN = nftl->EUNtable[thisVUC]; 603 604 //printk("Write to VirtualUnitChain %d, calling makefreeblock()\n", thisVUC); 605 writeEUN = NFTL_makefreeblock(nftl, 0xffff); 606 607 if (writeEUN == BLOCK_NIL) { 608 /* OK, we accept that the above comment is 609 lying - there may have been free blocks 610 last time we called NFTL_findfreeblock(), 611 but they are reserved for when we're 612 desperate. Well, now we're desperate. 613 */ 614 DEBUG(MTD_DEBUG_LEVEL1, "Using desperate==1 to find free EUN to accommodate write to VUC %d\n", thisVUC); 615 writeEUN = NFTL_findfreeblock(nftl, 1); 616 } 617 if (writeEUN == BLOCK_NIL) { 618 /* Ouch. This should never happen - we should 619 always be able to make some room somehow. 620 If we get here, we've allocated more storage 621 space than actual media, or our makefreeblock 622 routine is missing something. 623 */ 624 printk(KERN_WARNING "Cannot make free space.\n"); 625 return BLOCK_NIL; 626 } 627 //printk("Restarting scan\n"); 628 lastEUN = BLOCK_NIL; 629 continue; 630 } 631 632 /* We've found a free block. Insert it into the chain. */ 633 634 if (lastEUN != BLOCK_NIL) { 635 thisVUC |= 0x8000; /* It's a replacement block */ 636 } else { 637 /* The first block in a new chain */ 638 nftl->EUNtable[thisVUC] = writeEUN; 639 } 640 641 /* set up the actual EUN we're writing into */ 642 /* Both in our cache... */ 643 nftl->ReplUnitTable[writeEUN] = BLOCK_NIL; 644 645 /* ... and on the flash itself */ 646 nftl_read_oob(mtd, writeEUN * nftl->EraseSize + 8, 8, 647 &retlen, (char *)&oob.u); 648 649 oob.u.a.VirtUnitNum = oob.u.a.SpareVirtUnitNum = cpu_to_le16(thisVUC); 650 651 nftl_write_oob(mtd, writeEUN * nftl->EraseSize + 8, 8, 652 &retlen, (char *)&oob.u); 653 654 /* we link the new block to the chain only after the 655 block is ready. It avoids the case where the chain 656 could point to a free block */ 657 if (lastEUN != BLOCK_NIL) { 658 /* Both in our cache... */ 659 nftl->ReplUnitTable[lastEUN] = writeEUN; 660 /* ... and on the flash itself */ 661 nftl_read_oob(mtd, (lastEUN * nftl->EraseSize) + 8, 662 8, &retlen, (char *)&oob.u); 663 664 oob.u.a.ReplUnitNum = oob.u.a.SpareReplUnitNum 665 = cpu_to_le16(writeEUN); 666 667 nftl_write_oob(mtd, (lastEUN * nftl->EraseSize) + 8, 668 8, &retlen, (char *)&oob.u); 669 } 670 671 return writeEUN; 672 673 } while (silly2--); 674 675 printk(KERN_WARNING "Error folding to make room for Virtual Unit Chain 0x%x\n", 676 thisVUC); 677 return 0xffff; 678 } 679 680 static int nftl_writeblock(struct mtd_blktrans_dev *mbd, unsigned long block, 681 char *buffer) 682 { 683 struct NFTLrecord *nftl = (void *)mbd; 684 u16 writeEUN; 685 unsigned long blockofs = (block * 512) & (nftl->EraseSize - 1); 686 size_t retlen; 687 struct nftl_oob oob; 688 689 writeEUN = NFTL_findwriteunit(nftl, block); 690 691 if (writeEUN == BLOCK_NIL) { 692 printk(KERN_WARNING 693 "NFTL_writeblock(): Cannot find block to write to\n"); 694 /* If we _still_ haven't got a block to use, we're screwed */ 695 return 1; 696 } 697 698 memset(&oob, 0xff, sizeof(struct nftl_oob)); 699 oob.b.Status = oob.b.Status1 = SECTOR_USED; 700 701 nftl_write(nftl->mbd.mtd, (writeEUN * nftl->EraseSize) + blockofs, 702 512, &retlen, (char *)buffer, (char *)&oob); 703 return 0; 704 } 705 #endif /* CONFIG_NFTL_RW */ 706 707 static int nftl_readblock(struct mtd_blktrans_dev *mbd, unsigned long block, 708 char *buffer) 709 { 710 struct NFTLrecord *nftl = (void *)mbd; 711 struct mtd_info *mtd = nftl->mbd.mtd; 712 u16 lastgoodEUN; 713 u16 thisEUN = nftl->EUNtable[block / (nftl->EraseSize / 512)]; 714 unsigned long blockofs = (block * 512) & (nftl->EraseSize - 1); 715 unsigned int status; 716 int silly = MAX_LOOPS; 717 size_t retlen; 718 struct nftl_bci bci; 719 720 lastgoodEUN = BLOCK_NIL; 721 722 if (thisEUN != BLOCK_NIL) { 723 while (thisEUN < nftl->nb_blocks) { 724 if (nftl_read_oob(mtd, (thisEUN * nftl->EraseSize) + 725 blockofs, 8, &retlen, 726 (char *)&bci) < 0) 727 status = SECTOR_IGNORE; 728 else 729 status = bci.Status | bci.Status1; 730 731 switch (status) { 732 case SECTOR_FREE: 733 /* no modification of a sector should follow a free sector */ 734 goto the_end; 735 case SECTOR_DELETED: 736 lastgoodEUN = BLOCK_NIL; 737 break; 738 case SECTOR_USED: 739 lastgoodEUN = thisEUN; 740 break; 741 case SECTOR_IGNORE: 742 break; 743 default: 744 printk("Unknown status for block %ld in EUN %d: %x\n", 745 block, thisEUN, status); 746 break; 747 } 748 749 if (!silly--) { 750 printk(KERN_WARNING "Infinite loop in Virtual Unit Chain 0x%lx\n", 751 block / (nftl->EraseSize / 512)); 752 return 1; 753 } 754 thisEUN = nftl->ReplUnitTable[thisEUN]; 755 } 756 } 757 758 the_end: 759 if (lastgoodEUN == BLOCK_NIL) { 760 /* the requested block is not on the media, return all 0x00 */ 761 memset(buffer, 0, 512); 762 } else { 763 loff_t ptr = (lastgoodEUN * nftl->EraseSize) + blockofs; 764 size_t retlen; 765 int res = mtd->read(mtd, ptr, 512, &retlen, buffer); 766 767 if (res < 0 && res != -EUCLEAN) 768 return -EIO; 769 } 770 return 0; 771 } 772 773 static int nftl_getgeo(struct mtd_blktrans_dev *dev, struct hd_geometry *geo) 774 { 775 struct NFTLrecord *nftl = (void *)dev; 776 777 geo->heads = nftl->heads; 778 geo->sectors = nftl->sectors; 779 geo->cylinders = nftl->cylinders; 780 781 return 0; 782 } 783 784 /**************************************************************************** 785 * 786 * Module stuff 787 * 788 ****************************************************************************/ 789 790 791 static struct mtd_blktrans_ops nftl_tr = { 792 .name = "nftl", 793 .major = NFTL_MAJOR, 794 .part_bits = NFTL_PARTN_BITS, 795 .blksize = 512, 796 .getgeo = nftl_getgeo, 797 .readsect = nftl_readblock, 798 #ifdef CONFIG_NFTL_RW 799 .writesect = nftl_writeblock, 800 #endif 801 .add_mtd = nftl_add_mtd, 802 .remove_dev = nftl_remove_dev, 803 .owner = THIS_MODULE, 804 }; 805 806 extern char nftlmountrev[]; 807 808 static int __init init_nftl(void) 809 { 810 printk(KERN_INFO "NFTL driver: nftlcore.c $Revision: 1.98 $, nftlmount.c %s\n", nftlmountrev); 811 812 return register_mtd_blktrans(&nftl_tr); 813 } 814 815 static void __exit cleanup_nftl(void) 816 { 817 deregister_mtd_blktrans(&nftl_tr); 818 } 819 820 module_init(init_nftl); 821 module_exit(cleanup_nftl); 822 823 MODULE_LICENSE("GPL"); 824 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>, Fabrice Bellard <fabrice.bellard@netgem.com> et al."); 825 MODULE_DESCRIPTION("Support code for NAND Flash Translation Layer, used on M-Systems DiskOnChip 2000 and Millennium"); 826