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