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