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