1 /* 2 * inftlcore.c -- Linux driver for Inverse Flash Translation Layer (INFTL) 3 * 4 * Copyright © 2002, Greg Ungerer (gerg@snapgear.com) 5 * 6 * Based heavily on the nftlcore.c code which is: 7 * Copyright © 1999 Machine Vision Holdings, Inc. 8 * Copyright © 1999 David Woodhouse <dwmw2@infradead.org> 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License as published by 12 * the Free Software Foundation; either version 2 of the License, or 13 * (at your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU General Public License for more details. 19 * 20 * You should have received a copy of the GNU General Public License 21 * along with this program; if not, write to the Free Software 22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 23 */ 24 25 #include <linux/kernel.h> 26 #include <linux/module.h> 27 #include <linux/delay.h> 28 #include <linux/slab.h> 29 #include <linux/sched.h> 30 #include <linux/init.h> 31 #include <linux/kmod.h> 32 #include <linux/hdreg.h> 33 #include <linux/mtd/mtd.h> 34 #include <linux/mtd/nftl.h> 35 #include <linux/mtd/inftl.h> 36 #include <linux/mtd/rawnand.h> 37 #include <linux/uaccess.h> 38 #include <asm/errno.h> 39 #include <asm/io.h> 40 41 /* 42 * Maximum number of loops while examining next block, to have a 43 * chance to detect consistency problems (they should never happen 44 * because of the checks done in the mounting. 45 */ 46 #define MAX_LOOPS 10000 47 48 static void inftl_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd) 49 { 50 struct INFTLrecord *inftl; 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 if (!mtd->_block_isbad) { 60 printk(KERN_ERR 61 "INFTL 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("INFTL: add_mtd for %s\n", mtd->name); 67 68 inftl = kzalloc(sizeof(*inftl), GFP_KERNEL); 69 70 if (!inftl) 71 return; 72 73 inftl->mbd.mtd = mtd; 74 inftl->mbd.devnum = -1; 75 76 inftl->mbd.tr = tr; 77 78 if (INFTL_mount(inftl) < 0) { 79 printk(KERN_WARNING "INFTL: could not mount device\n"); 80 kfree(inftl); 81 return; 82 } 83 84 /* OK, it's a new one. Set up all the data structures. */ 85 86 /* Calculate geometry */ 87 inftl->cylinders = 1024; 88 inftl->heads = 16; 89 90 temp = inftl->cylinders * inftl->heads; 91 inftl->sectors = inftl->mbd.size / temp; 92 if (inftl->mbd.size % temp) { 93 inftl->sectors++; 94 temp = inftl->cylinders * inftl->sectors; 95 inftl->heads = inftl->mbd.size / temp; 96 97 if (inftl->mbd.size % temp) { 98 inftl->heads++; 99 temp = inftl->heads * inftl->sectors; 100 inftl->cylinders = inftl->mbd.size / temp; 101 } 102 } 103 104 if (inftl->mbd.size != inftl->heads * inftl->cylinders * inftl->sectors) { 105 /* 106 Oh no we don't have 107 mbd.size == heads * cylinders * sectors 108 */ 109 printk(KERN_WARNING "INFTL: cannot calculate a geometry to " 110 "match size of 0x%lx.\n", inftl->mbd.size); 111 printk(KERN_WARNING "INFTL: using C:%d H:%d S:%d " 112 "(== 0x%lx sects)\n", 113 inftl->cylinders, inftl->heads , inftl->sectors, 114 (long)inftl->cylinders * (long)inftl->heads * 115 (long)inftl->sectors ); 116 } 117 118 if (add_mtd_blktrans_dev(&inftl->mbd)) { 119 kfree(inftl->PUtable); 120 kfree(inftl->VUtable); 121 kfree(inftl); 122 return; 123 } 124 #ifdef PSYCHO_DEBUG 125 printk(KERN_INFO "INFTL: Found new inftl%c\n", inftl->mbd.devnum + 'a'); 126 #endif 127 return; 128 } 129 130 static void inftl_remove_dev(struct mtd_blktrans_dev *dev) 131 { 132 struct INFTLrecord *inftl = (void *)dev; 133 134 pr_debug("INFTL: remove_dev (i=%d)\n", dev->devnum); 135 136 del_mtd_blktrans_dev(dev); 137 138 kfree(inftl->PUtable); 139 kfree(inftl->VUtable); 140 } 141 142 /* 143 * Actual INFTL access routines. 144 */ 145 146 /* 147 * Read oob data from flash 148 */ 149 int inftl_read_oob(struct mtd_info *mtd, loff_t offs, size_t len, 150 size_t *retlen, uint8_t *buf) 151 { 152 struct mtd_oob_ops ops; 153 int res; 154 155 ops.mode = MTD_OPS_PLACE_OOB; 156 ops.ooboffs = offs & (mtd->writesize - 1); 157 ops.ooblen = len; 158 ops.oobbuf = buf; 159 ops.datbuf = NULL; 160 161 res = mtd_read_oob(mtd, offs & ~(mtd->writesize - 1), &ops); 162 *retlen = ops.oobretlen; 163 return res; 164 } 165 166 /* 167 * Write oob data to flash 168 */ 169 int inftl_write_oob(struct mtd_info *mtd, loff_t offs, size_t len, 170 size_t *retlen, uint8_t *buf) 171 { 172 struct mtd_oob_ops ops; 173 int res; 174 175 ops.mode = MTD_OPS_PLACE_OOB; 176 ops.ooboffs = offs & (mtd->writesize - 1); 177 ops.ooblen = len; 178 ops.oobbuf = buf; 179 ops.datbuf = NULL; 180 181 res = mtd_write_oob(mtd, offs & ~(mtd->writesize - 1), &ops); 182 *retlen = ops.oobretlen; 183 return res; 184 } 185 186 /* 187 * Write data and oob to flash 188 */ 189 static int inftl_write(struct mtd_info *mtd, loff_t offs, size_t len, 190 size_t *retlen, uint8_t *buf, uint8_t *oob) 191 { 192 struct mtd_oob_ops ops; 193 int res; 194 195 ops.mode = MTD_OPS_PLACE_OOB; 196 ops.ooboffs = offs; 197 ops.ooblen = mtd->oobsize; 198 ops.oobbuf = oob; 199 ops.datbuf = buf; 200 ops.len = len; 201 202 res = mtd_write_oob(mtd, offs & ~(mtd->writesize - 1), &ops); 203 *retlen = ops.retlen; 204 return res; 205 } 206 207 /* 208 * INFTL_findfreeblock: Find a free Erase Unit on the INFTL partition. 209 * This function is used when the give Virtual Unit Chain. 210 */ 211 static u16 INFTL_findfreeblock(struct INFTLrecord *inftl, int desperate) 212 { 213 u16 pot = inftl->LastFreeEUN; 214 int silly = inftl->nb_blocks; 215 216 pr_debug("INFTL: INFTL_findfreeblock(inftl=%p,desperate=%d)\n", 217 inftl, desperate); 218 219 /* 220 * Normally, we force a fold to happen before we run out of free 221 * blocks completely. 222 */ 223 if (!desperate && inftl->numfreeEUNs < 2) { 224 pr_debug("INFTL: there are too few free EUNs (%d)\n", 225 inftl->numfreeEUNs); 226 return BLOCK_NIL; 227 } 228 229 /* Scan for a free block */ 230 do { 231 if (inftl->PUtable[pot] == BLOCK_FREE) { 232 inftl->LastFreeEUN = pot; 233 return pot; 234 } 235 236 if (++pot > inftl->lastEUN) 237 pot = 0; 238 239 if (!silly--) { 240 printk(KERN_WARNING "INFTL: no free blocks found! " 241 "EUN range = %d - %d\n", 0, inftl->LastFreeEUN); 242 return BLOCK_NIL; 243 } 244 } while (pot != inftl->LastFreeEUN); 245 246 return BLOCK_NIL; 247 } 248 249 static u16 INFTL_foldchain(struct INFTLrecord *inftl, unsigned thisVUC, unsigned pendingblock) 250 { 251 u16 BlockMap[MAX_SECTORS_PER_UNIT]; 252 unsigned char BlockDeleted[MAX_SECTORS_PER_UNIT]; 253 unsigned int thisEUN, prevEUN, status; 254 struct mtd_info *mtd = inftl->mbd.mtd; 255 int block, silly; 256 unsigned int targetEUN; 257 struct inftl_oob oob; 258 size_t retlen; 259 260 pr_debug("INFTL: INFTL_foldchain(inftl=%p,thisVUC=%d,pending=%d)\n", 261 inftl, thisVUC, pendingblock); 262 263 memset(BlockMap, 0xff, sizeof(BlockMap)); 264 memset(BlockDeleted, 0, sizeof(BlockDeleted)); 265 266 thisEUN = targetEUN = inftl->VUtable[thisVUC]; 267 268 if (thisEUN == BLOCK_NIL) { 269 printk(KERN_WARNING "INFTL: trying to fold non-existent " 270 "Virtual Unit Chain %d!\n", thisVUC); 271 return BLOCK_NIL; 272 } 273 274 /* 275 * Scan to find the Erase Unit which holds the actual data for each 276 * 512-byte block within the Chain. 277 */ 278 silly = MAX_LOOPS; 279 while (thisEUN < inftl->nb_blocks) { 280 for (block = 0; block < inftl->EraseSize/SECTORSIZE; block ++) { 281 if ((BlockMap[block] != BLOCK_NIL) || 282 BlockDeleted[block]) 283 continue; 284 285 if (inftl_read_oob(mtd, (thisEUN * inftl->EraseSize) 286 + (block * SECTORSIZE), 16, &retlen, 287 (char *)&oob) < 0) 288 status = SECTOR_IGNORE; 289 else 290 status = oob.b.Status | oob.b.Status1; 291 292 switch(status) { 293 case SECTOR_FREE: 294 case SECTOR_IGNORE: 295 break; 296 case SECTOR_USED: 297 BlockMap[block] = thisEUN; 298 continue; 299 case SECTOR_DELETED: 300 BlockDeleted[block] = 1; 301 continue; 302 default: 303 printk(KERN_WARNING "INFTL: unknown status " 304 "for block %d in EUN %d: %x\n", 305 block, thisEUN, status); 306 break; 307 } 308 } 309 310 if (!silly--) { 311 printk(KERN_WARNING "INFTL: infinite loop in Virtual " 312 "Unit Chain 0x%x\n", thisVUC); 313 return BLOCK_NIL; 314 } 315 316 thisEUN = inftl->PUtable[thisEUN]; 317 } 318 319 /* 320 * OK. We now know the location of every block in the Virtual Unit 321 * Chain, and the Erase Unit into which we are supposed to be copying. 322 * Go for it. 323 */ 324 pr_debug("INFTL: folding chain %d into unit %d\n", thisVUC, targetEUN); 325 326 for (block = 0; block < inftl->EraseSize/SECTORSIZE ; block++) { 327 unsigned char movebuf[SECTORSIZE]; 328 int ret; 329 330 /* 331 * If it's in the target EUN already, or if it's pending write, 332 * do nothing. 333 */ 334 if (BlockMap[block] == targetEUN || (pendingblock == 335 (thisVUC * (inftl->EraseSize / SECTORSIZE) + block))) { 336 continue; 337 } 338 339 /* 340 * Copy only in non free block (free blocks can only 341 * happen in case of media errors or deleted blocks). 342 */ 343 if (BlockMap[block] == BLOCK_NIL) 344 continue; 345 346 ret = mtd_read(mtd, 347 (inftl->EraseSize * BlockMap[block]) + (block * SECTORSIZE), 348 SECTORSIZE, 349 &retlen, 350 movebuf); 351 if (ret < 0 && !mtd_is_bitflip(ret)) { 352 ret = mtd_read(mtd, 353 (inftl->EraseSize * BlockMap[block]) + (block * SECTORSIZE), 354 SECTORSIZE, 355 &retlen, 356 movebuf); 357 if (ret != -EIO) 358 pr_debug("INFTL: error went away on retry?\n"); 359 } 360 memset(&oob, 0xff, sizeof(struct inftl_oob)); 361 oob.b.Status = oob.b.Status1 = SECTOR_USED; 362 363 inftl_write(inftl->mbd.mtd, (inftl->EraseSize * targetEUN) + 364 (block * SECTORSIZE), SECTORSIZE, &retlen, 365 movebuf, (char *)&oob); 366 } 367 368 /* 369 * Newest unit in chain now contains data from _all_ older units. 370 * So go through and erase each unit in chain, oldest first. (This 371 * is important, by doing oldest first if we crash/reboot then it 372 * it is relatively simple to clean up the mess). 373 */ 374 pr_debug("INFTL: want to erase virtual chain %d\n", thisVUC); 375 376 for (;;) { 377 /* Find oldest unit in chain. */ 378 thisEUN = inftl->VUtable[thisVUC]; 379 prevEUN = BLOCK_NIL; 380 while (inftl->PUtable[thisEUN] != BLOCK_NIL) { 381 prevEUN = thisEUN; 382 thisEUN = inftl->PUtable[thisEUN]; 383 } 384 385 /* Check if we are all done */ 386 if (thisEUN == targetEUN) 387 break; 388 389 /* Unlink the last block from the chain. */ 390 inftl->PUtable[prevEUN] = BLOCK_NIL; 391 392 /* Now try to erase it. */ 393 if (INFTL_formatblock(inftl, thisEUN) < 0) { 394 /* 395 * Could not erase : mark block as reserved. 396 */ 397 inftl->PUtable[thisEUN] = BLOCK_RESERVED; 398 } else { 399 /* Correctly erased : mark it as free */ 400 inftl->PUtable[thisEUN] = BLOCK_FREE; 401 inftl->numfreeEUNs++; 402 } 403 } 404 405 return targetEUN; 406 } 407 408 static u16 INFTL_makefreeblock(struct INFTLrecord *inftl, unsigned pendingblock) 409 { 410 /* 411 * This is the part that needs some cleverness applied. 412 * For now, I'm doing the minimum applicable to actually 413 * get the thing to work. 414 * Wear-levelling and other clever stuff needs to be implemented 415 * and we also need to do some assessment of the results when 416 * the system loses power half-way through the routine. 417 */ 418 u16 LongestChain = 0; 419 u16 ChainLength = 0, thislen; 420 u16 chain, EUN; 421 422 pr_debug("INFTL: INFTL_makefreeblock(inftl=%p," 423 "pending=%d)\n", inftl, pendingblock); 424 425 for (chain = 0; chain < inftl->nb_blocks; chain++) { 426 EUN = inftl->VUtable[chain]; 427 thislen = 0; 428 429 while (EUN <= inftl->lastEUN) { 430 thislen++; 431 EUN = inftl->PUtable[EUN]; 432 if (thislen > 0xff00) { 433 printk(KERN_WARNING "INFTL: endless loop in " 434 "Virtual Chain %d: Unit %x\n", 435 chain, EUN); 436 /* 437 * Actually, don't return failure. 438 * Just ignore this chain and get on with it. 439 */ 440 thislen = 0; 441 break; 442 } 443 } 444 445 if (thislen > ChainLength) { 446 ChainLength = thislen; 447 LongestChain = chain; 448 } 449 } 450 451 if (ChainLength < 2) { 452 printk(KERN_WARNING "INFTL: no Virtual Unit Chains available " 453 "for folding. Failing request\n"); 454 return BLOCK_NIL; 455 } 456 457 return INFTL_foldchain(inftl, LongestChain, pendingblock); 458 } 459 460 static int nrbits(unsigned int val, int bitcount) 461 { 462 int i, total = 0; 463 464 for (i = 0; (i < bitcount); i++) 465 total += (((0x1 << i) & val) ? 1 : 0); 466 return total; 467 } 468 469 /* 470 * INFTL_findwriteunit: Return the unit number into which we can write 471 * for this block. Make it available if it isn't already. 472 */ 473 static inline u16 INFTL_findwriteunit(struct INFTLrecord *inftl, unsigned block) 474 { 475 unsigned int thisVUC = block / (inftl->EraseSize / SECTORSIZE); 476 unsigned int thisEUN, writeEUN, prev_block, status; 477 unsigned long blockofs = (block * SECTORSIZE) & (inftl->EraseSize -1); 478 struct mtd_info *mtd = inftl->mbd.mtd; 479 struct inftl_oob oob; 480 struct inftl_bci bci; 481 unsigned char anac, nacs, parity; 482 size_t retlen; 483 int silly, silly2 = 3; 484 485 pr_debug("INFTL: INFTL_findwriteunit(inftl=%p,block=%d)\n", 486 inftl, block); 487 488 do { 489 /* 490 * Scan the media to find a unit in the VUC which has 491 * a free space for the block in question. 492 */ 493 writeEUN = BLOCK_NIL; 494 thisEUN = inftl->VUtable[thisVUC]; 495 silly = MAX_LOOPS; 496 497 while (thisEUN <= inftl->lastEUN) { 498 inftl_read_oob(mtd, (thisEUN * inftl->EraseSize) + 499 blockofs, 8, &retlen, (char *)&bci); 500 501 status = bci.Status | bci.Status1; 502 pr_debug("INFTL: status of block %d in EUN %d is %x\n", 503 block , writeEUN, status); 504 505 switch(status) { 506 case SECTOR_FREE: 507 writeEUN = thisEUN; 508 break; 509 case SECTOR_DELETED: 510 case SECTOR_USED: 511 /* Can't go any further */ 512 goto hitused; 513 case SECTOR_IGNORE: 514 break; 515 default: 516 /* 517 * Invalid block. Don't use it any more. 518 * Must implement. 519 */ 520 break; 521 } 522 523 if (!silly--) { 524 printk(KERN_WARNING "INFTL: infinite loop in " 525 "Virtual Unit Chain 0x%x\n", thisVUC); 526 return BLOCK_NIL; 527 } 528 529 /* Skip to next block in chain */ 530 thisEUN = inftl->PUtable[thisEUN]; 531 } 532 533 hitused: 534 if (writeEUN != BLOCK_NIL) 535 return writeEUN; 536 537 538 /* 539 * OK. We didn't find one in the existing chain, or there 540 * is no existing chain. Allocate a new one. 541 */ 542 writeEUN = INFTL_findfreeblock(inftl, 0); 543 544 if (writeEUN == BLOCK_NIL) { 545 /* 546 * That didn't work - there were no free blocks just 547 * waiting to be picked up. We're going to have to fold 548 * a chain to make room. 549 */ 550 thisEUN = INFTL_makefreeblock(inftl, block); 551 552 /* 553 * Hopefully we free something, lets try again. 554 * This time we are desperate... 555 */ 556 pr_debug("INFTL: using desperate==1 to find free EUN " 557 "to accommodate write to VUC %d\n", 558 thisVUC); 559 writeEUN = INFTL_findfreeblock(inftl, 1); 560 if (writeEUN == BLOCK_NIL) { 561 /* 562 * Ouch. This should never happen - we should 563 * always be able to make some room somehow. 564 * If we get here, we've allocated more storage 565 * space than actual media, or our makefreeblock 566 * routine is missing something. 567 */ 568 printk(KERN_WARNING "INFTL: cannot make free " 569 "space.\n"); 570 #ifdef DEBUG 571 INFTL_dumptables(inftl); 572 INFTL_dumpVUchains(inftl); 573 #endif 574 return BLOCK_NIL; 575 } 576 } 577 578 /* 579 * Insert new block into virtual chain. Firstly update the 580 * block headers in flash... 581 */ 582 anac = 0; 583 nacs = 0; 584 thisEUN = inftl->VUtable[thisVUC]; 585 if (thisEUN != BLOCK_NIL) { 586 inftl_read_oob(mtd, thisEUN * inftl->EraseSize 587 + 8, 8, &retlen, (char *)&oob.u); 588 anac = oob.u.a.ANAC + 1; 589 nacs = oob.u.a.NACs + 1; 590 } 591 592 prev_block = inftl->VUtable[thisVUC]; 593 if (prev_block < inftl->nb_blocks) 594 prev_block -= inftl->firstEUN; 595 596 parity = (nrbits(thisVUC, 16) & 0x1) ? 0x1 : 0; 597 parity |= (nrbits(prev_block, 16) & 0x1) ? 0x2 : 0; 598 parity |= (nrbits(anac, 8) & 0x1) ? 0x4 : 0; 599 parity |= (nrbits(nacs, 8) & 0x1) ? 0x8 : 0; 600 601 oob.u.a.virtualUnitNo = cpu_to_le16(thisVUC); 602 oob.u.a.prevUnitNo = cpu_to_le16(prev_block); 603 oob.u.a.ANAC = anac; 604 oob.u.a.NACs = nacs; 605 oob.u.a.parityPerField = parity; 606 oob.u.a.discarded = 0xaa; 607 608 inftl_write_oob(mtd, writeEUN * inftl->EraseSize + 8, 8, 609 &retlen, (char *)&oob.u); 610 611 /* Also back up header... */ 612 oob.u.b.virtualUnitNo = cpu_to_le16(thisVUC); 613 oob.u.b.prevUnitNo = cpu_to_le16(prev_block); 614 oob.u.b.ANAC = anac; 615 oob.u.b.NACs = nacs; 616 oob.u.b.parityPerField = parity; 617 oob.u.b.discarded = 0xaa; 618 619 inftl_write_oob(mtd, writeEUN * inftl->EraseSize + 620 SECTORSIZE * 4 + 8, 8, &retlen, (char *)&oob.u); 621 622 inftl->PUtable[writeEUN] = inftl->VUtable[thisVUC]; 623 inftl->VUtable[thisVUC] = writeEUN; 624 625 inftl->numfreeEUNs--; 626 return writeEUN; 627 628 } while (silly2--); 629 630 printk(KERN_WARNING "INFTL: error folding to make room for Virtual " 631 "Unit Chain 0x%x\n", thisVUC); 632 return BLOCK_NIL; 633 } 634 635 /* 636 * Given a Virtual Unit Chain, see if it can be deleted, and if so do it. 637 */ 638 static void INFTL_trydeletechain(struct INFTLrecord *inftl, unsigned thisVUC) 639 { 640 struct mtd_info *mtd = inftl->mbd.mtd; 641 unsigned char BlockUsed[MAX_SECTORS_PER_UNIT]; 642 unsigned char BlockDeleted[MAX_SECTORS_PER_UNIT]; 643 unsigned int thisEUN, status; 644 int block, silly; 645 struct inftl_bci bci; 646 size_t retlen; 647 648 pr_debug("INFTL: INFTL_trydeletechain(inftl=%p," 649 "thisVUC=%d)\n", inftl, thisVUC); 650 651 memset(BlockUsed, 0, sizeof(BlockUsed)); 652 memset(BlockDeleted, 0, sizeof(BlockDeleted)); 653 654 thisEUN = inftl->VUtable[thisVUC]; 655 if (thisEUN == BLOCK_NIL) { 656 printk(KERN_WARNING "INFTL: trying to delete non-existent " 657 "Virtual Unit Chain %d!\n", thisVUC); 658 return; 659 } 660 661 /* 662 * Scan through the Erase Units to determine whether any data is in 663 * each of the 512-byte blocks within the Chain. 664 */ 665 silly = MAX_LOOPS; 666 while (thisEUN < inftl->nb_blocks) { 667 for (block = 0; block < inftl->EraseSize/SECTORSIZE; block++) { 668 if (BlockUsed[block] || BlockDeleted[block]) 669 continue; 670 671 if (inftl_read_oob(mtd, (thisEUN * inftl->EraseSize) 672 + (block * SECTORSIZE), 8 , &retlen, 673 (char *)&bci) < 0) 674 status = SECTOR_IGNORE; 675 else 676 status = bci.Status | bci.Status1; 677 678 switch(status) { 679 case SECTOR_FREE: 680 case SECTOR_IGNORE: 681 break; 682 case SECTOR_USED: 683 BlockUsed[block] = 1; 684 continue; 685 case SECTOR_DELETED: 686 BlockDeleted[block] = 1; 687 continue; 688 default: 689 printk(KERN_WARNING "INFTL: unknown status " 690 "for block %d in EUN %d: 0x%x\n", 691 block, thisEUN, status); 692 } 693 } 694 695 if (!silly--) { 696 printk(KERN_WARNING "INFTL: infinite loop in Virtual " 697 "Unit Chain 0x%x\n", thisVUC); 698 return; 699 } 700 701 thisEUN = inftl->PUtable[thisEUN]; 702 } 703 704 for (block = 0; block < inftl->EraseSize/SECTORSIZE; block++) 705 if (BlockUsed[block]) 706 return; 707 708 /* 709 * For each block in the chain free it and make it available 710 * for future use. Erase from the oldest unit first. 711 */ 712 pr_debug("INFTL: deleting empty VUC %d\n", thisVUC); 713 714 for (;;) { 715 u16 *prevEUN = &inftl->VUtable[thisVUC]; 716 thisEUN = *prevEUN; 717 718 /* If the chain is all gone already, we're done */ 719 if (thisEUN == BLOCK_NIL) { 720 pr_debug("INFTL: Empty VUC %d for deletion was already absent\n", thisEUN); 721 return; 722 } 723 724 /* Find oldest unit in chain. */ 725 while (inftl->PUtable[thisEUN] != BLOCK_NIL) { 726 BUG_ON(thisEUN >= inftl->nb_blocks); 727 728 prevEUN = &inftl->PUtable[thisEUN]; 729 thisEUN = *prevEUN; 730 } 731 732 pr_debug("Deleting EUN %d from VUC %d\n", 733 thisEUN, thisVUC); 734 735 if (INFTL_formatblock(inftl, thisEUN) < 0) { 736 /* 737 * Could not erase : mark block as reserved. 738 */ 739 inftl->PUtable[thisEUN] = BLOCK_RESERVED; 740 } else { 741 /* Correctly erased : mark it as free */ 742 inftl->PUtable[thisEUN] = BLOCK_FREE; 743 inftl->numfreeEUNs++; 744 } 745 746 /* Now sort out whatever was pointing to it... */ 747 *prevEUN = BLOCK_NIL; 748 749 /* Ideally we'd actually be responsive to new 750 requests while we're doing this -- if there's 751 free space why should others be made to wait? */ 752 cond_resched(); 753 } 754 755 inftl->VUtable[thisVUC] = BLOCK_NIL; 756 } 757 758 static int INFTL_deleteblock(struct INFTLrecord *inftl, unsigned block) 759 { 760 unsigned int thisEUN = inftl->VUtable[block / (inftl->EraseSize / SECTORSIZE)]; 761 unsigned long blockofs = (block * SECTORSIZE) & (inftl->EraseSize - 1); 762 struct mtd_info *mtd = inftl->mbd.mtd; 763 unsigned int status; 764 int silly = MAX_LOOPS; 765 size_t retlen; 766 struct inftl_bci bci; 767 768 pr_debug("INFTL: INFTL_deleteblock(inftl=%p," 769 "block=%d)\n", inftl, block); 770 771 while (thisEUN < inftl->nb_blocks) { 772 if (inftl_read_oob(mtd, (thisEUN * inftl->EraseSize) + 773 blockofs, 8, &retlen, (char *)&bci) < 0) 774 status = SECTOR_IGNORE; 775 else 776 status = bci.Status | bci.Status1; 777 778 switch (status) { 779 case SECTOR_FREE: 780 case SECTOR_IGNORE: 781 break; 782 case SECTOR_DELETED: 783 thisEUN = BLOCK_NIL; 784 goto foundit; 785 case SECTOR_USED: 786 goto foundit; 787 default: 788 printk(KERN_WARNING "INFTL: unknown status for " 789 "block %d in EUN %d: 0x%x\n", 790 block, thisEUN, status); 791 break; 792 } 793 794 if (!silly--) { 795 printk(KERN_WARNING "INFTL: infinite loop in Virtual " 796 "Unit Chain 0x%x\n", 797 block / (inftl->EraseSize / SECTORSIZE)); 798 return 1; 799 } 800 thisEUN = inftl->PUtable[thisEUN]; 801 } 802 803 foundit: 804 if (thisEUN != BLOCK_NIL) { 805 loff_t ptr = (thisEUN * inftl->EraseSize) + blockofs; 806 807 if (inftl_read_oob(mtd, ptr, 8, &retlen, (char *)&bci) < 0) 808 return -EIO; 809 bci.Status = bci.Status1 = SECTOR_DELETED; 810 if (inftl_write_oob(mtd, ptr, 8, &retlen, (char *)&bci) < 0) 811 return -EIO; 812 INFTL_trydeletechain(inftl, block / (inftl->EraseSize / SECTORSIZE)); 813 } 814 return 0; 815 } 816 817 static int inftl_writeblock(struct mtd_blktrans_dev *mbd, unsigned long block, 818 char *buffer) 819 { 820 struct INFTLrecord *inftl = (void *)mbd; 821 unsigned int writeEUN; 822 unsigned long blockofs = (block * SECTORSIZE) & (inftl->EraseSize - 1); 823 size_t retlen; 824 struct inftl_oob oob; 825 char *p, *pend; 826 827 pr_debug("INFTL: inftl_writeblock(inftl=%p,block=%ld," 828 "buffer=%p)\n", inftl, block, buffer); 829 830 /* Is block all zero? */ 831 pend = buffer + SECTORSIZE; 832 for (p = buffer; p < pend && !*p; p++) 833 ; 834 835 if (p < pend) { 836 writeEUN = INFTL_findwriteunit(inftl, block); 837 838 if (writeEUN == BLOCK_NIL) { 839 printk(KERN_WARNING "inftl_writeblock(): cannot find " 840 "block to write to\n"); 841 /* 842 * If we _still_ haven't got a block to use, 843 * we're screwed. 844 */ 845 return 1; 846 } 847 848 memset(&oob, 0xff, sizeof(struct inftl_oob)); 849 oob.b.Status = oob.b.Status1 = SECTOR_USED; 850 851 inftl_write(inftl->mbd.mtd, (writeEUN * inftl->EraseSize) + 852 blockofs, SECTORSIZE, &retlen, (char *)buffer, 853 (char *)&oob); 854 /* 855 * need to write SECTOR_USED flags since they are not written 856 * in mtd_writeecc 857 */ 858 } else { 859 INFTL_deleteblock(inftl, block); 860 } 861 862 return 0; 863 } 864 865 static int inftl_readblock(struct mtd_blktrans_dev *mbd, unsigned long block, 866 char *buffer) 867 { 868 struct INFTLrecord *inftl = (void *)mbd; 869 unsigned int thisEUN = inftl->VUtable[block / (inftl->EraseSize / SECTORSIZE)]; 870 unsigned long blockofs = (block * SECTORSIZE) & (inftl->EraseSize - 1); 871 struct mtd_info *mtd = inftl->mbd.mtd; 872 unsigned int status; 873 int silly = MAX_LOOPS; 874 struct inftl_bci bci; 875 size_t retlen; 876 877 pr_debug("INFTL: inftl_readblock(inftl=%p,block=%ld," 878 "buffer=%p)\n", inftl, block, buffer); 879 880 while (thisEUN < inftl->nb_blocks) { 881 if (inftl_read_oob(mtd, (thisEUN * inftl->EraseSize) + 882 blockofs, 8, &retlen, (char *)&bci) < 0) 883 status = SECTOR_IGNORE; 884 else 885 status = bci.Status | bci.Status1; 886 887 switch (status) { 888 case SECTOR_DELETED: 889 thisEUN = BLOCK_NIL; 890 goto foundit; 891 case SECTOR_USED: 892 goto foundit; 893 case SECTOR_FREE: 894 case SECTOR_IGNORE: 895 break; 896 default: 897 printk(KERN_WARNING "INFTL: unknown status for " 898 "block %ld in EUN %d: 0x%04x\n", 899 block, thisEUN, status); 900 break; 901 } 902 903 if (!silly--) { 904 printk(KERN_WARNING "INFTL: infinite loop in " 905 "Virtual Unit Chain 0x%lx\n", 906 block / (inftl->EraseSize / SECTORSIZE)); 907 return 1; 908 } 909 910 thisEUN = inftl->PUtable[thisEUN]; 911 } 912 913 foundit: 914 if (thisEUN == BLOCK_NIL) { 915 /* The requested block is not on the media, return all 0x00 */ 916 memset(buffer, 0, SECTORSIZE); 917 } else { 918 size_t retlen; 919 loff_t ptr = (thisEUN * inftl->EraseSize) + blockofs; 920 int ret = mtd_read(mtd, ptr, SECTORSIZE, &retlen, buffer); 921 922 /* Handle corrected bit flips gracefully */ 923 if (ret < 0 && !mtd_is_bitflip(ret)) 924 return -EIO; 925 } 926 return 0; 927 } 928 929 static int inftl_getgeo(struct mtd_blktrans_dev *dev, struct hd_geometry *geo) 930 { 931 struct INFTLrecord *inftl = (void *)dev; 932 933 geo->heads = inftl->heads; 934 geo->sectors = inftl->sectors; 935 geo->cylinders = inftl->cylinders; 936 937 return 0; 938 } 939 940 static struct mtd_blktrans_ops inftl_tr = { 941 .name = "inftl", 942 .major = INFTL_MAJOR, 943 .part_bits = INFTL_PARTN_BITS, 944 .blksize = 512, 945 .getgeo = inftl_getgeo, 946 .readsect = inftl_readblock, 947 .writesect = inftl_writeblock, 948 .add_mtd = inftl_add_mtd, 949 .remove_dev = inftl_remove_dev, 950 .owner = THIS_MODULE, 951 }; 952 953 static int __init init_inftl(void) 954 { 955 return register_mtd_blktrans(&inftl_tr); 956 } 957 958 static void __exit cleanup_inftl(void) 959 { 960 deregister_mtd_blktrans(&inftl_tr); 961 } 962 963 module_init(init_inftl); 964 module_exit(cleanup_inftl); 965 966 MODULE_LICENSE("GPL"); 967 MODULE_AUTHOR("Greg Ungerer <gerg@snapgear.com>, David Woodhouse <dwmw2@infradead.org>, Fabrice Bellard <fabrice.bellard@netgem.com> et al."); 968 MODULE_DESCRIPTION("Support code for Inverse Flash Translation Layer, used on M-Systems DiskOnChip 2000, Millennium and Millennium Plus"); 969