1 /* 2 * linux/drivers/mtd/onenand/onenand_base.c 3 * 4 * Copyright (C) 2005-2007 Samsung Electronics 5 * Kyungmin Park <kyungmin.park@samsung.com> 6 * 7 * Credits: 8 * Adrian Hunter <ext-adrian.hunter@nokia.com>: 9 * auto-placement support, read-while load support, various fixes 10 * Copyright (C) Nokia Corporation, 2007 11 * 12 * Rohit Hagargundgi <h.rohit at samsung.com>, 13 * Amul Kumar Saha <amul.saha@samsung.com>: 14 * Flex-OneNAND support 15 * Copyright (C) Samsung Electronics, 2009 16 * 17 * This program is free software; you can redistribute it and/or modify 18 * it under the terms of the GNU General Public License version 2 as 19 * published by the Free Software Foundation. 20 */ 21 22 #include <common.h> 23 #include <watchdog.h> 24 #include <linux/compat.h> 25 #include <linux/mtd/mtd.h> 26 #include "linux/mtd/flashchip.h" 27 #include <linux/mtd/onenand.h> 28 29 #include <asm/io.h> 30 #include <linux/errno.h> 31 #include <malloc.h> 32 33 /* It should access 16-bit instead of 8-bit */ 34 static void *memcpy_16(void *dst, const void *src, unsigned int len) 35 { 36 void *ret = dst; 37 short *d = dst; 38 const short *s = src; 39 40 len >>= 1; 41 while (len-- > 0) 42 *d++ = *s++; 43 return ret; 44 } 45 46 /** 47 * onenand_oob_128 - oob info for Flex-Onenand with 4KB page 48 * For now, we expose only 64 out of 80 ecc bytes 49 */ 50 static struct nand_ecclayout onenand_oob_128 = { 51 .eccbytes = 64, 52 .eccpos = { 53 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 54 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 55 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 56 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 57 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 58 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 59 102, 103, 104, 105 60 }, 61 .oobfree = { 62 {2, 4}, {18, 4}, {34, 4}, {50, 4}, 63 {66, 4}, {82, 4}, {98, 4}, {114, 4} 64 } 65 }; 66 67 /** 68 * onenand_oob_64 - oob info for large (2KB) page 69 */ 70 static struct nand_ecclayout onenand_oob_64 = { 71 .eccbytes = 20, 72 .eccpos = { 73 8, 9, 10, 11, 12, 74 24, 25, 26, 27, 28, 75 40, 41, 42, 43, 44, 76 56, 57, 58, 59, 60, 77 }, 78 .oobfree = { 79 {2, 3}, {14, 2}, {18, 3}, {30, 2}, 80 {34, 3}, {46, 2}, {50, 3}, {62, 2} 81 } 82 }; 83 84 /** 85 * onenand_oob_32 - oob info for middle (1KB) page 86 */ 87 static struct nand_ecclayout onenand_oob_32 = { 88 .eccbytes = 10, 89 .eccpos = { 90 8, 9, 10, 11, 12, 91 24, 25, 26, 27, 28, 92 }, 93 .oobfree = { {2, 3}, {14, 2}, {18, 3}, {30, 2} } 94 }; 95 96 /* 97 * Warning! This array is used with the memcpy_16() function, thus 98 * it must be aligned to 2 bytes. GCC can make this array unaligned 99 * as the array is made of unsigned char, which memcpy16() doesn't 100 * like and will cause unaligned access. 101 */ 102 static const unsigned char __aligned(2) ffchars[] = { 103 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 104 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 16 */ 105 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 106 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 32 */ 107 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 108 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 48 */ 109 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 110 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 64 */ 111 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 112 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 80 */ 113 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 114 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 96 */ 115 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 116 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 112 */ 117 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 118 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 128 */ 119 }; 120 121 /** 122 * onenand_readw - [OneNAND Interface] Read OneNAND register 123 * @param addr address to read 124 * 125 * Read OneNAND register 126 */ 127 static unsigned short onenand_readw(void __iomem * addr) 128 { 129 return readw(addr); 130 } 131 132 /** 133 * onenand_writew - [OneNAND Interface] Write OneNAND register with value 134 * @param value value to write 135 * @param addr address to write 136 * 137 * Write OneNAND register with value 138 */ 139 static void onenand_writew(unsigned short value, void __iomem * addr) 140 { 141 writew(value, addr); 142 } 143 144 /** 145 * onenand_block_address - [DEFAULT] Get block address 146 * @param device the device id 147 * @param block the block 148 * @return translated block address if DDP, otherwise same 149 * 150 * Setup Start Address 1 Register (F100h) 151 */ 152 static int onenand_block_address(struct onenand_chip *this, int block) 153 { 154 /* Device Flash Core select, NAND Flash Block Address */ 155 if (block & this->density_mask) 156 return ONENAND_DDP_CHIP1 | (block ^ this->density_mask); 157 158 return block; 159 } 160 161 /** 162 * onenand_bufferram_address - [DEFAULT] Get bufferram address 163 * @param device the device id 164 * @param block the block 165 * @return set DBS value if DDP, otherwise 0 166 * 167 * Setup Start Address 2 Register (F101h) for DDP 168 */ 169 static int onenand_bufferram_address(struct onenand_chip *this, int block) 170 { 171 /* Device BufferRAM Select */ 172 if (block & this->density_mask) 173 return ONENAND_DDP_CHIP1; 174 175 return ONENAND_DDP_CHIP0; 176 } 177 178 /** 179 * onenand_page_address - [DEFAULT] Get page address 180 * @param page the page address 181 * @param sector the sector address 182 * @return combined page and sector address 183 * 184 * Setup Start Address 8 Register (F107h) 185 */ 186 static int onenand_page_address(int page, int sector) 187 { 188 /* Flash Page Address, Flash Sector Address */ 189 int fpa, fsa; 190 191 fpa = page & ONENAND_FPA_MASK; 192 fsa = sector & ONENAND_FSA_MASK; 193 194 return ((fpa << ONENAND_FPA_SHIFT) | fsa); 195 } 196 197 /** 198 * onenand_buffer_address - [DEFAULT] Get buffer address 199 * @param dataram1 DataRAM index 200 * @param sectors the sector address 201 * @param count the number of sectors 202 * @return the start buffer value 203 * 204 * Setup Start Buffer Register (F200h) 205 */ 206 static int onenand_buffer_address(int dataram1, int sectors, int count) 207 { 208 int bsa, bsc; 209 210 /* BufferRAM Sector Address */ 211 bsa = sectors & ONENAND_BSA_MASK; 212 213 if (dataram1) 214 bsa |= ONENAND_BSA_DATARAM1; /* DataRAM1 */ 215 else 216 bsa |= ONENAND_BSA_DATARAM0; /* DataRAM0 */ 217 218 /* BufferRAM Sector Count */ 219 bsc = count & ONENAND_BSC_MASK; 220 221 return ((bsa << ONENAND_BSA_SHIFT) | bsc); 222 } 223 224 /** 225 * flexonenand_block - Return block number for flash address 226 * @param this - OneNAND device structure 227 * @param addr - Address for which block number is needed 228 */ 229 static unsigned int flexonenand_block(struct onenand_chip *this, loff_t addr) 230 { 231 unsigned int boundary, blk, die = 0; 232 233 if (ONENAND_IS_DDP(this) && addr >= this->diesize[0]) { 234 die = 1; 235 addr -= this->diesize[0]; 236 } 237 238 boundary = this->boundary[die]; 239 240 blk = addr >> (this->erase_shift - 1); 241 if (blk > boundary) 242 blk = (blk + boundary + 1) >> 1; 243 244 blk += die ? this->density_mask : 0; 245 return blk; 246 } 247 248 unsigned int onenand_block(struct onenand_chip *this, loff_t addr) 249 { 250 if (!FLEXONENAND(this)) 251 return addr >> this->erase_shift; 252 return flexonenand_block(this, addr); 253 } 254 255 /** 256 * flexonenand_addr - Return address of the block 257 * @this: OneNAND device structure 258 * @block: Block number on Flex-OneNAND 259 * 260 * Return address of the block 261 */ 262 static loff_t flexonenand_addr(struct onenand_chip *this, int block) 263 { 264 loff_t ofs = 0; 265 int die = 0, boundary; 266 267 if (ONENAND_IS_DDP(this) && block >= this->density_mask) { 268 block -= this->density_mask; 269 die = 1; 270 ofs = this->diesize[0]; 271 } 272 273 boundary = this->boundary[die]; 274 ofs += (loff_t) block << (this->erase_shift - 1); 275 if (block > (boundary + 1)) 276 ofs += (loff_t) (block - boundary - 1) 277 << (this->erase_shift - 1); 278 return ofs; 279 } 280 281 loff_t onenand_addr(struct onenand_chip *this, int block) 282 { 283 if (!FLEXONENAND(this)) 284 return (loff_t) block << this->erase_shift; 285 return flexonenand_addr(this, block); 286 } 287 288 /** 289 * flexonenand_region - [Flex-OneNAND] Return erase region of addr 290 * @param mtd MTD device structure 291 * @param addr address whose erase region needs to be identified 292 */ 293 int flexonenand_region(struct mtd_info *mtd, loff_t addr) 294 { 295 int i; 296 297 for (i = 0; i < mtd->numeraseregions; i++) 298 if (addr < mtd->eraseregions[i].offset) 299 break; 300 return i - 1; 301 } 302 303 /** 304 * onenand_get_density - [DEFAULT] Get OneNAND density 305 * @param dev_id OneNAND device ID 306 * 307 * Get OneNAND density from device ID 308 */ 309 static inline int onenand_get_density(int dev_id) 310 { 311 int density = dev_id >> ONENAND_DEVICE_DENSITY_SHIFT; 312 return (density & ONENAND_DEVICE_DENSITY_MASK); 313 } 314 315 /** 316 * onenand_command - [DEFAULT] Send command to OneNAND device 317 * @param mtd MTD device structure 318 * @param cmd the command to be sent 319 * @param addr offset to read from or write to 320 * @param len number of bytes to read or write 321 * 322 * Send command to OneNAND device. This function is used for middle/large page 323 * devices (1KB/2KB Bytes per page) 324 */ 325 static int onenand_command(struct mtd_info *mtd, int cmd, loff_t addr, 326 size_t len) 327 { 328 struct onenand_chip *this = mtd->priv; 329 int value; 330 int block, page; 331 332 /* Now we use page size operation */ 333 int sectors = 0, count = 0; 334 335 /* Address translation */ 336 switch (cmd) { 337 case ONENAND_CMD_UNLOCK: 338 case ONENAND_CMD_LOCK: 339 case ONENAND_CMD_LOCK_TIGHT: 340 case ONENAND_CMD_UNLOCK_ALL: 341 block = -1; 342 page = -1; 343 break; 344 345 case FLEXONENAND_CMD_PI_ACCESS: 346 /* addr contains die index */ 347 block = addr * this->density_mask; 348 page = -1; 349 break; 350 351 case ONENAND_CMD_ERASE: 352 case ONENAND_CMD_BUFFERRAM: 353 block = onenand_block(this, addr); 354 page = -1; 355 break; 356 357 case FLEXONENAND_CMD_READ_PI: 358 cmd = ONENAND_CMD_READ; 359 block = addr * this->density_mask; 360 page = 0; 361 break; 362 363 default: 364 block = onenand_block(this, addr); 365 page = (int) (addr 366 - onenand_addr(this, block)) >> this->page_shift; 367 page &= this->page_mask; 368 break; 369 } 370 371 /* NOTE: The setting order of the registers is very important! */ 372 if (cmd == ONENAND_CMD_BUFFERRAM) { 373 /* Select DataRAM for DDP */ 374 value = onenand_bufferram_address(this, block); 375 this->write_word(value, 376 this->base + ONENAND_REG_START_ADDRESS2); 377 378 if (ONENAND_IS_4KB_PAGE(this)) 379 ONENAND_SET_BUFFERRAM0(this); 380 else 381 /* Switch to the next data buffer */ 382 ONENAND_SET_NEXT_BUFFERRAM(this); 383 384 return 0; 385 } 386 387 if (block != -1) { 388 /* Write 'DFS, FBA' of Flash */ 389 value = onenand_block_address(this, block); 390 this->write_word(value, 391 this->base + ONENAND_REG_START_ADDRESS1); 392 393 /* Select DataRAM for DDP */ 394 value = onenand_bufferram_address(this, block); 395 this->write_word(value, 396 this->base + ONENAND_REG_START_ADDRESS2); 397 } 398 399 if (page != -1) { 400 int dataram; 401 402 switch (cmd) { 403 case FLEXONENAND_CMD_RECOVER_LSB: 404 case ONENAND_CMD_READ: 405 case ONENAND_CMD_READOOB: 406 if (ONENAND_IS_4KB_PAGE(this)) 407 dataram = ONENAND_SET_BUFFERRAM0(this); 408 else 409 dataram = ONENAND_SET_NEXT_BUFFERRAM(this); 410 411 break; 412 413 default: 414 dataram = ONENAND_CURRENT_BUFFERRAM(this); 415 break; 416 } 417 418 /* Write 'FPA, FSA' of Flash */ 419 value = onenand_page_address(page, sectors); 420 this->write_word(value, 421 this->base + ONENAND_REG_START_ADDRESS8); 422 423 /* Write 'BSA, BSC' of DataRAM */ 424 value = onenand_buffer_address(dataram, sectors, count); 425 this->write_word(value, this->base + ONENAND_REG_START_BUFFER); 426 } 427 428 /* Interrupt clear */ 429 this->write_word(ONENAND_INT_CLEAR, this->base + ONENAND_REG_INTERRUPT); 430 /* Write command */ 431 this->write_word(cmd, this->base + ONENAND_REG_COMMAND); 432 433 return 0; 434 } 435 436 /** 437 * onenand_read_ecc - return ecc status 438 * @param this onenand chip structure 439 */ 440 static int onenand_read_ecc(struct onenand_chip *this) 441 { 442 int ecc, i; 443 444 if (!FLEXONENAND(this)) 445 return this->read_word(this->base + ONENAND_REG_ECC_STATUS); 446 447 for (i = 0; i < 4; i++) { 448 ecc = this->read_word(this->base 449 + ((ONENAND_REG_ECC_STATUS + i) << 1)); 450 if (likely(!ecc)) 451 continue; 452 if (ecc & FLEXONENAND_UNCORRECTABLE_ERROR) 453 return ONENAND_ECC_2BIT_ALL; 454 } 455 456 return 0; 457 } 458 459 /** 460 * onenand_wait - [DEFAULT] wait until the command is done 461 * @param mtd MTD device structure 462 * @param state state to select the max. timeout value 463 * 464 * Wait for command done. This applies to all OneNAND command 465 * Read can take up to 30us, erase up to 2ms and program up to 350us 466 * according to general OneNAND specs 467 */ 468 static int onenand_wait(struct mtd_info *mtd, int state) 469 { 470 struct onenand_chip *this = mtd->priv; 471 unsigned int interrupt = 0; 472 unsigned int ctrl; 473 474 /* Wait at most 20ms ... */ 475 u32 timeo = (CONFIG_SYS_HZ * 20) / 1000; 476 u32 time_start = get_timer(0); 477 do { 478 WATCHDOG_RESET(); 479 if (get_timer(time_start) > timeo) 480 return -EIO; 481 interrupt = this->read_word(this->base + ONENAND_REG_INTERRUPT); 482 } while ((interrupt & ONENAND_INT_MASTER) == 0); 483 484 ctrl = this->read_word(this->base + ONENAND_REG_CTRL_STATUS); 485 486 if (interrupt & ONENAND_INT_READ) { 487 int ecc = onenand_read_ecc(this); 488 if (ecc & ONENAND_ECC_2BIT_ALL) { 489 printk("onenand_wait: ECC error = 0x%04x\n", ecc); 490 return -EBADMSG; 491 } 492 } 493 494 if (ctrl & ONENAND_CTRL_ERROR) { 495 printk("onenand_wait: controller error = 0x%04x\n", ctrl); 496 if (ctrl & ONENAND_CTRL_LOCK) 497 printk("onenand_wait: it's locked error = 0x%04x\n", 498 ctrl); 499 500 return -EIO; 501 } 502 503 504 return 0; 505 } 506 507 /** 508 * onenand_bufferram_offset - [DEFAULT] BufferRAM offset 509 * @param mtd MTD data structure 510 * @param area BufferRAM area 511 * @return offset given area 512 * 513 * Return BufferRAM offset given area 514 */ 515 static inline int onenand_bufferram_offset(struct mtd_info *mtd, int area) 516 { 517 struct onenand_chip *this = mtd->priv; 518 519 if (ONENAND_CURRENT_BUFFERRAM(this)) { 520 if (area == ONENAND_DATARAM) 521 return mtd->writesize; 522 if (area == ONENAND_SPARERAM) 523 return mtd->oobsize; 524 } 525 526 return 0; 527 } 528 529 /** 530 * onenand_read_bufferram - [OneNAND Interface] Read the bufferram area 531 * @param mtd MTD data structure 532 * @param area BufferRAM area 533 * @param buffer the databuffer to put/get data 534 * @param offset offset to read from or write to 535 * @param count number of bytes to read/write 536 * 537 * Read the BufferRAM area 538 */ 539 static int onenand_read_bufferram(struct mtd_info *mtd, loff_t addr, int area, 540 unsigned char *buffer, int offset, 541 size_t count) 542 { 543 struct onenand_chip *this = mtd->priv; 544 void __iomem *bufferram; 545 546 bufferram = this->base + area; 547 bufferram += onenand_bufferram_offset(mtd, area); 548 549 memcpy_16(buffer, bufferram + offset, count); 550 551 return 0; 552 } 553 554 /** 555 * onenand_sync_read_bufferram - [OneNAND Interface] Read the bufferram area with Sync. Burst mode 556 * @param mtd MTD data structure 557 * @param area BufferRAM area 558 * @param buffer the databuffer to put/get data 559 * @param offset offset to read from or write to 560 * @param count number of bytes to read/write 561 * 562 * Read the BufferRAM area with Sync. Burst Mode 563 */ 564 static int onenand_sync_read_bufferram(struct mtd_info *mtd, loff_t addr, int area, 565 unsigned char *buffer, int offset, 566 size_t count) 567 { 568 struct onenand_chip *this = mtd->priv; 569 void __iomem *bufferram; 570 571 bufferram = this->base + area; 572 bufferram += onenand_bufferram_offset(mtd, area); 573 574 this->mmcontrol(mtd, ONENAND_SYS_CFG1_SYNC_READ); 575 576 memcpy_16(buffer, bufferram + offset, count); 577 578 this->mmcontrol(mtd, 0); 579 580 return 0; 581 } 582 583 /** 584 * onenand_write_bufferram - [OneNAND Interface] Write the bufferram area 585 * @param mtd MTD data structure 586 * @param area BufferRAM area 587 * @param buffer the databuffer to put/get data 588 * @param offset offset to read from or write to 589 * @param count number of bytes to read/write 590 * 591 * Write the BufferRAM area 592 */ 593 static int onenand_write_bufferram(struct mtd_info *mtd, loff_t addr, int area, 594 const unsigned char *buffer, int offset, 595 size_t count) 596 { 597 struct onenand_chip *this = mtd->priv; 598 void __iomem *bufferram; 599 600 bufferram = this->base + area; 601 bufferram += onenand_bufferram_offset(mtd, area); 602 603 memcpy_16(bufferram + offset, buffer, count); 604 605 return 0; 606 } 607 608 /** 609 * onenand_get_2x_blockpage - [GENERIC] Get blockpage at 2x program mode 610 * @param mtd MTD data structure 611 * @param addr address to check 612 * @return blockpage address 613 * 614 * Get blockpage address at 2x program mode 615 */ 616 static int onenand_get_2x_blockpage(struct mtd_info *mtd, loff_t addr) 617 { 618 struct onenand_chip *this = mtd->priv; 619 int blockpage, block, page; 620 621 /* Calculate the even block number */ 622 block = (int) (addr >> this->erase_shift) & ~1; 623 /* Is it the odd plane? */ 624 if (addr & this->writesize) 625 block++; 626 page = (int) (addr >> (this->page_shift + 1)) & this->page_mask; 627 blockpage = (block << 7) | page; 628 629 return blockpage; 630 } 631 632 /** 633 * onenand_check_bufferram - [GENERIC] Check BufferRAM information 634 * @param mtd MTD data structure 635 * @param addr address to check 636 * @return 1 if there are valid data, otherwise 0 637 * 638 * Check bufferram if there is data we required 639 */ 640 static int onenand_check_bufferram(struct mtd_info *mtd, loff_t addr) 641 { 642 struct onenand_chip *this = mtd->priv; 643 int blockpage, found = 0; 644 unsigned int i; 645 646 if (ONENAND_IS_2PLANE(this)) 647 blockpage = onenand_get_2x_blockpage(mtd, addr); 648 else 649 blockpage = (int) (addr >> this->page_shift); 650 651 /* Is there valid data? */ 652 i = ONENAND_CURRENT_BUFFERRAM(this); 653 if (this->bufferram[i].blockpage == blockpage) 654 found = 1; 655 else { 656 /* Check another BufferRAM */ 657 i = ONENAND_NEXT_BUFFERRAM(this); 658 if (this->bufferram[i].blockpage == blockpage) { 659 ONENAND_SET_NEXT_BUFFERRAM(this); 660 found = 1; 661 } 662 } 663 664 if (found && ONENAND_IS_DDP(this)) { 665 /* Select DataRAM for DDP */ 666 int block = onenand_block(this, addr); 667 int value = onenand_bufferram_address(this, block); 668 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS2); 669 } 670 671 return found; 672 } 673 674 /** 675 * onenand_update_bufferram - [GENERIC] Update BufferRAM information 676 * @param mtd MTD data structure 677 * @param addr address to update 678 * @param valid valid flag 679 * 680 * Update BufferRAM information 681 */ 682 static int onenand_update_bufferram(struct mtd_info *mtd, loff_t addr, 683 int valid) 684 { 685 struct onenand_chip *this = mtd->priv; 686 int blockpage; 687 unsigned int i; 688 689 if (ONENAND_IS_2PLANE(this)) 690 blockpage = onenand_get_2x_blockpage(mtd, addr); 691 else 692 blockpage = (int)(addr >> this->page_shift); 693 694 /* Invalidate another BufferRAM */ 695 i = ONENAND_NEXT_BUFFERRAM(this); 696 if (this->bufferram[i].blockpage == blockpage) 697 this->bufferram[i].blockpage = -1; 698 699 /* Update BufferRAM */ 700 i = ONENAND_CURRENT_BUFFERRAM(this); 701 if (valid) 702 this->bufferram[i].blockpage = blockpage; 703 else 704 this->bufferram[i].blockpage = -1; 705 706 return 0; 707 } 708 709 /** 710 * onenand_invalidate_bufferram - [GENERIC] Invalidate BufferRAM information 711 * @param mtd MTD data structure 712 * @param addr start address to invalidate 713 * @param len length to invalidate 714 * 715 * Invalidate BufferRAM information 716 */ 717 static void onenand_invalidate_bufferram(struct mtd_info *mtd, loff_t addr, 718 unsigned int len) 719 { 720 struct onenand_chip *this = mtd->priv; 721 int i; 722 loff_t end_addr = addr + len; 723 724 /* Invalidate BufferRAM */ 725 for (i = 0; i < MAX_BUFFERRAM; i++) { 726 loff_t buf_addr = this->bufferram[i].blockpage << this->page_shift; 727 728 if (buf_addr >= addr && buf_addr < end_addr) 729 this->bufferram[i].blockpage = -1; 730 } 731 } 732 733 /** 734 * onenand_get_device - [GENERIC] Get chip for selected access 735 * @param mtd MTD device structure 736 * @param new_state the state which is requested 737 * 738 * Get the device and lock it for exclusive access 739 */ 740 static void onenand_get_device(struct mtd_info *mtd, int new_state) 741 { 742 /* Do nothing */ 743 } 744 745 /** 746 * onenand_release_device - [GENERIC] release chip 747 * @param mtd MTD device structure 748 * 749 * Deselect, release chip lock and wake up anyone waiting on the device 750 */ 751 static void onenand_release_device(struct mtd_info *mtd) 752 { 753 /* Do nothing */ 754 } 755 756 /** 757 * onenand_transfer_auto_oob - [INTERN] oob auto-placement transfer 758 * @param mtd MTD device structure 759 * @param buf destination address 760 * @param column oob offset to read from 761 * @param thislen oob length to read 762 */ 763 static int onenand_transfer_auto_oob(struct mtd_info *mtd, uint8_t *buf, 764 int column, int thislen) 765 { 766 struct onenand_chip *this = mtd->priv; 767 struct nand_oobfree *free; 768 int readcol = column; 769 int readend = column + thislen; 770 int lastgap = 0; 771 unsigned int i; 772 uint8_t *oob_buf = this->oob_buf; 773 774 free = this->ecclayout->oobfree; 775 for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES_LARGE && free->length; 776 i++, free++) { 777 if (readcol >= lastgap) 778 readcol += free->offset - lastgap; 779 if (readend >= lastgap) 780 readend += free->offset - lastgap; 781 lastgap = free->offset + free->length; 782 } 783 this->read_bufferram(mtd, 0, ONENAND_SPARERAM, oob_buf, 0, mtd->oobsize); 784 free = this->ecclayout->oobfree; 785 for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES_LARGE && free->length; 786 i++, free++) { 787 int free_end = free->offset + free->length; 788 if (free->offset < readend && free_end > readcol) { 789 int st = max_t(int,free->offset,readcol); 790 int ed = min_t(int,free_end,readend); 791 int n = ed - st; 792 memcpy(buf, oob_buf + st, n); 793 buf += n; 794 } else if (column == 0) 795 break; 796 } 797 return 0; 798 } 799 800 /** 801 * onenand_recover_lsb - [Flex-OneNAND] Recover LSB page data 802 * @param mtd MTD device structure 803 * @param addr address to recover 804 * @param status return value from onenand_wait 805 * 806 * MLC NAND Flash cell has paired pages - LSB page and MSB page. LSB page has 807 * lower page address and MSB page has higher page address in paired pages. 808 * If power off occurs during MSB page program, the paired LSB page data can 809 * become corrupt. LSB page recovery read is a way to read LSB page though page 810 * data are corrupted. When uncorrectable error occurs as a result of LSB page 811 * read after power up, issue LSB page recovery read. 812 */ 813 static int onenand_recover_lsb(struct mtd_info *mtd, loff_t addr, int status) 814 { 815 struct onenand_chip *this = mtd->priv; 816 int i; 817 818 /* Recovery is only for Flex-OneNAND */ 819 if (!FLEXONENAND(this)) 820 return status; 821 822 /* check if we failed due to uncorrectable error */ 823 if (!mtd_is_eccerr(status) && status != ONENAND_BBT_READ_ECC_ERROR) 824 return status; 825 826 /* check if address lies in MLC region */ 827 i = flexonenand_region(mtd, addr); 828 if (mtd->eraseregions[i].erasesize < (1 << this->erase_shift)) 829 return status; 830 831 printk("onenand_recover_lsb:" 832 "Attempting to recover from uncorrectable read\n"); 833 834 /* Issue the LSB page recovery command */ 835 this->command(mtd, FLEXONENAND_CMD_RECOVER_LSB, addr, this->writesize); 836 return this->wait(mtd, FL_READING); 837 } 838 839 /** 840 * onenand_read_ops_nolock - [OneNAND Interface] OneNAND read main and/or out-of-band 841 * @param mtd MTD device structure 842 * @param from offset to read from 843 * @param ops oob operation description structure 844 * 845 * OneNAND read main and/or out-of-band data 846 */ 847 static int onenand_read_ops_nolock(struct mtd_info *mtd, loff_t from, 848 struct mtd_oob_ops *ops) 849 { 850 struct onenand_chip *this = mtd->priv; 851 struct mtd_ecc_stats stats; 852 size_t len = ops->len; 853 size_t ooblen = ops->ooblen; 854 u_char *buf = ops->datbuf; 855 u_char *oobbuf = ops->oobbuf; 856 int read = 0, column, thislen; 857 int oobread = 0, oobcolumn, thisooblen, oobsize; 858 int ret = 0, boundary = 0; 859 int writesize = this->writesize; 860 861 MTDDEBUG(MTD_DEBUG_LEVEL3, "onenand_read_ops_nolock: from = 0x%08x, len = %i\n", (unsigned int) from, (int) len); 862 863 if (ops->mode == MTD_OPS_AUTO_OOB) 864 oobsize = this->ecclayout->oobavail; 865 else 866 oobsize = mtd->oobsize; 867 868 oobcolumn = from & (mtd->oobsize - 1); 869 870 /* Do not allow reads past end of device */ 871 if ((from + len) > mtd->size) { 872 printk(KERN_ERR "onenand_read_ops_nolock: Attempt read beyond end of device\n"); 873 ops->retlen = 0; 874 ops->oobretlen = 0; 875 return -EINVAL; 876 } 877 878 stats = mtd->ecc_stats; 879 880 /* Read-while-load method */ 881 /* Note: We can't use this feature in MLC */ 882 883 /* Do first load to bufferRAM */ 884 if (read < len) { 885 if (!onenand_check_bufferram(mtd, from)) { 886 this->main_buf = buf; 887 this->command(mtd, ONENAND_CMD_READ, from, writesize); 888 ret = this->wait(mtd, FL_READING); 889 if (unlikely(ret)) 890 ret = onenand_recover_lsb(mtd, from, ret); 891 onenand_update_bufferram(mtd, from, !ret); 892 if (ret == -EBADMSG) 893 ret = 0; 894 } 895 } 896 897 thislen = min_t(int, writesize, len - read); 898 column = from & (writesize - 1); 899 if (column + thislen > writesize) 900 thislen = writesize - column; 901 902 while (!ret) { 903 /* If there is more to load then start next load */ 904 from += thislen; 905 if (!ONENAND_IS_4KB_PAGE(this) && read + thislen < len) { 906 this->main_buf = buf + thislen; 907 this->command(mtd, ONENAND_CMD_READ, from, writesize); 908 /* 909 * Chip boundary handling in DDP 910 * Now we issued chip 1 read and pointed chip 1 911 * bufferam so we have to point chip 0 bufferam. 912 */ 913 if (ONENAND_IS_DDP(this) && 914 unlikely(from == (this->chipsize >> 1))) { 915 this->write_word(ONENAND_DDP_CHIP0, this->base + ONENAND_REG_START_ADDRESS2); 916 boundary = 1; 917 } else 918 boundary = 0; 919 ONENAND_SET_PREV_BUFFERRAM(this); 920 } 921 922 /* While load is going, read from last bufferRAM */ 923 this->read_bufferram(mtd, from - thislen, ONENAND_DATARAM, buf, column, thislen); 924 925 /* Read oob area if needed */ 926 if (oobbuf) { 927 thisooblen = oobsize - oobcolumn; 928 thisooblen = min_t(int, thisooblen, ooblen - oobread); 929 930 if (ops->mode == MTD_OPS_AUTO_OOB) 931 onenand_transfer_auto_oob(mtd, oobbuf, oobcolumn, thisooblen); 932 else 933 this->read_bufferram(mtd, 0, ONENAND_SPARERAM, oobbuf, oobcolumn, thisooblen); 934 oobread += thisooblen; 935 oobbuf += thisooblen; 936 oobcolumn = 0; 937 } 938 939 if (ONENAND_IS_4KB_PAGE(this) && (read + thislen < len)) { 940 this->command(mtd, ONENAND_CMD_READ, from, writesize); 941 ret = this->wait(mtd, FL_READING); 942 if (unlikely(ret)) 943 ret = onenand_recover_lsb(mtd, from, ret); 944 onenand_update_bufferram(mtd, from, !ret); 945 if (mtd_is_eccerr(ret)) 946 ret = 0; 947 } 948 949 /* See if we are done */ 950 read += thislen; 951 if (read == len) 952 break; 953 /* Set up for next read from bufferRAM */ 954 if (unlikely(boundary)) 955 this->write_word(ONENAND_DDP_CHIP1, this->base + ONENAND_REG_START_ADDRESS2); 956 if (!ONENAND_IS_4KB_PAGE(this)) 957 ONENAND_SET_NEXT_BUFFERRAM(this); 958 buf += thislen; 959 thislen = min_t(int, writesize, len - read); 960 column = 0; 961 962 if (!ONENAND_IS_4KB_PAGE(this)) { 963 /* Now wait for load */ 964 ret = this->wait(mtd, FL_READING); 965 onenand_update_bufferram(mtd, from, !ret); 966 if (mtd_is_eccerr(ret)) 967 ret = 0; 968 } 969 } 970 971 /* 972 * Return success, if no ECC failures, else -EBADMSG 973 * fs driver will take care of that, because 974 * retlen == desired len and result == -EBADMSG 975 */ 976 ops->retlen = read; 977 ops->oobretlen = oobread; 978 979 if (ret) 980 return ret; 981 982 if (mtd->ecc_stats.failed - stats.failed) 983 return -EBADMSG; 984 985 /* return max bitflips per ecc step; ONENANDs correct 1 bit only */ 986 return mtd->ecc_stats.corrected != stats.corrected ? 1 : 0; 987 } 988 989 /** 990 * onenand_read_oob_nolock - [MTD Interface] OneNAND read out-of-band 991 * @param mtd MTD device structure 992 * @param from offset to read from 993 * @param ops oob operation description structure 994 * 995 * OneNAND read out-of-band data from the spare area 996 */ 997 static int onenand_read_oob_nolock(struct mtd_info *mtd, loff_t from, 998 struct mtd_oob_ops *ops) 999 { 1000 struct onenand_chip *this = mtd->priv; 1001 struct mtd_ecc_stats stats; 1002 int read = 0, thislen, column, oobsize; 1003 size_t len = ops->ooblen; 1004 unsigned int mode = ops->mode; 1005 u_char *buf = ops->oobbuf; 1006 int ret = 0, readcmd; 1007 1008 from += ops->ooboffs; 1009 1010 MTDDEBUG(MTD_DEBUG_LEVEL3, "onenand_read_oob_nolock: from = 0x%08x, len = %i\n", (unsigned int) from, (int) len); 1011 1012 /* Initialize return length value */ 1013 ops->oobretlen = 0; 1014 1015 if (mode == MTD_OPS_AUTO_OOB) 1016 oobsize = this->ecclayout->oobavail; 1017 else 1018 oobsize = mtd->oobsize; 1019 1020 column = from & (mtd->oobsize - 1); 1021 1022 if (unlikely(column >= oobsize)) { 1023 printk(KERN_ERR "onenand_read_oob_nolock: Attempted to start read outside oob\n"); 1024 return -EINVAL; 1025 } 1026 1027 /* Do not allow reads past end of device */ 1028 if (unlikely(from >= mtd->size || 1029 column + len > ((mtd->size >> this->page_shift) - 1030 (from >> this->page_shift)) * oobsize)) { 1031 printk(KERN_ERR "onenand_read_oob_nolock: Attempted to read beyond end of device\n"); 1032 return -EINVAL; 1033 } 1034 1035 stats = mtd->ecc_stats; 1036 1037 readcmd = ONENAND_IS_4KB_PAGE(this) ? 1038 ONENAND_CMD_READ : ONENAND_CMD_READOOB; 1039 1040 while (read < len) { 1041 thislen = oobsize - column; 1042 thislen = min_t(int, thislen, len); 1043 1044 this->spare_buf = buf; 1045 this->command(mtd, readcmd, from, mtd->oobsize); 1046 1047 onenand_update_bufferram(mtd, from, 0); 1048 1049 ret = this->wait(mtd, FL_READING); 1050 if (unlikely(ret)) 1051 ret = onenand_recover_lsb(mtd, from, ret); 1052 1053 if (ret && ret != -EBADMSG) { 1054 printk(KERN_ERR "onenand_read_oob_nolock: read failed = 0x%x\n", ret); 1055 break; 1056 } 1057 1058 if (mode == MTD_OPS_AUTO_OOB) 1059 onenand_transfer_auto_oob(mtd, buf, column, thislen); 1060 else 1061 this->read_bufferram(mtd, 0, ONENAND_SPARERAM, buf, column, thislen); 1062 1063 read += thislen; 1064 1065 if (read == len) 1066 break; 1067 1068 buf += thislen; 1069 1070 /* Read more? */ 1071 if (read < len) { 1072 /* Page size */ 1073 from += mtd->writesize; 1074 column = 0; 1075 } 1076 } 1077 1078 ops->oobretlen = read; 1079 1080 if (ret) 1081 return ret; 1082 1083 if (mtd->ecc_stats.failed - stats.failed) 1084 return -EBADMSG; 1085 1086 return 0; 1087 } 1088 1089 /** 1090 * onenand_read - [MTD Interface] MTD compability function for onenand_read_ecc 1091 * @param mtd MTD device structure 1092 * @param from offset to read from 1093 * @param len number of bytes to read 1094 * @param retlen pointer to variable to store the number of read bytes 1095 * @param buf the databuffer to put data 1096 * 1097 * This function simply calls onenand_read_ecc with oob buffer and oobsel = NULL 1098 */ 1099 int onenand_read(struct mtd_info *mtd, loff_t from, size_t len, 1100 size_t * retlen, u_char * buf) 1101 { 1102 struct mtd_oob_ops ops = { 1103 .len = len, 1104 .ooblen = 0, 1105 .datbuf = buf, 1106 .oobbuf = NULL, 1107 }; 1108 int ret; 1109 1110 onenand_get_device(mtd, FL_READING); 1111 ret = onenand_read_ops_nolock(mtd, from, &ops); 1112 onenand_release_device(mtd); 1113 1114 *retlen = ops.retlen; 1115 return ret; 1116 } 1117 1118 /** 1119 * onenand_read_oob - [MTD Interface] OneNAND read out-of-band 1120 * @param mtd MTD device structure 1121 * @param from offset to read from 1122 * @param ops oob operations description structure 1123 * 1124 * OneNAND main and/or out-of-band 1125 */ 1126 int onenand_read_oob(struct mtd_info *mtd, loff_t from, 1127 struct mtd_oob_ops *ops) 1128 { 1129 int ret; 1130 1131 switch (ops->mode) { 1132 case MTD_OPS_PLACE_OOB: 1133 case MTD_OPS_AUTO_OOB: 1134 break; 1135 case MTD_OPS_RAW: 1136 /* Not implemented yet */ 1137 default: 1138 return -EINVAL; 1139 } 1140 1141 onenand_get_device(mtd, FL_READING); 1142 if (ops->datbuf) 1143 ret = onenand_read_ops_nolock(mtd, from, ops); 1144 else 1145 ret = onenand_read_oob_nolock(mtd, from, ops); 1146 onenand_release_device(mtd); 1147 1148 return ret; 1149 } 1150 1151 /** 1152 * onenand_bbt_wait - [DEFAULT] wait until the command is done 1153 * @param mtd MTD device structure 1154 * @param state state to select the max. timeout value 1155 * 1156 * Wait for command done. 1157 */ 1158 static int onenand_bbt_wait(struct mtd_info *mtd, int state) 1159 { 1160 struct onenand_chip *this = mtd->priv; 1161 unsigned int interrupt; 1162 unsigned int ctrl; 1163 1164 /* Wait at most 20ms ... */ 1165 u32 timeo = (CONFIG_SYS_HZ * 20) / 1000; 1166 u32 time_start = get_timer(0); 1167 do { 1168 WATCHDOG_RESET(); 1169 if (get_timer(time_start) > timeo) 1170 return ONENAND_BBT_READ_FATAL_ERROR; 1171 interrupt = this->read_word(this->base + ONENAND_REG_INTERRUPT); 1172 } while ((interrupt & ONENAND_INT_MASTER) == 0); 1173 1174 /* To get correct interrupt status in timeout case */ 1175 interrupt = this->read_word(this->base + ONENAND_REG_INTERRUPT); 1176 ctrl = this->read_word(this->base + ONENAND_REG_CTRL_STATUS); 1177 1178 if (interrupt & ONENAND_INT_READ) { 1179 int ecc = onenand_read_ecc(this); 1180 if (ecc & ONENAND_ECC_2BIT_ALL) { 1181 printk(KERN_INFO "onenand_bbt_wait: ecc error = 0x%04x" 1182 ", controller = 0x%04x\n", ecc, ctrl); 1183 return ONENAND_BBT_READ_ERROR; 1184 } 1185 } else { 1186 printk(KERN_ERR "onenand_bbt_wait: read timeout!" 1187 "ctrl=0x%04x intr=0x%04x\n", ctrl, interrupt); 1188 return ONENAND_BBT_READ_FATAL_ERROR; 1189 } 1190 1191 /* Initial bad block case: 0x2400 or 0x0400 */ 1192 if (ctrl & ONENAND_CTRL_ERROR) { 1193 printk(KERN_DEBUG "onenand_bbt_wait: controller error = 0x%04x\n", ctrl); 1194 return ONENAND_BBT_READ_ERROR; 1195 } 1196 1197 return 0; 1198 } 1199 1200 /** 1201 * onenand_bbt_read_oob - [MTD Interface] OneNAND read out-of-band for bbt scan 1202 * @param mtd MTD device structure 1203 * @param from offset to read from 1204 * @param ops oob operation description structure 1205 * 1206 * OneNAND read out-of-band data from the spare area for bbt scan 1207 */ 1208 int onenand_bbt_read_oob(struct mtd_info *mtd, loff_t from, 1209 struct mtd_oob_ops *ops) 1210 { 1211 struct onenand_chip *this = mtd->priv; 1212 int read = 0, thislen, column; 1213 int ret = 0, readcmd; 1214 size_t len = ops->ooblen; 1215 u_char *buf = ops->oobbuf; 1216 1217 MTDDEBUG(MTD_DEBUG_LEVEL3, "onenand_bbt_read_oob: from = 0x%08x, len = %zi\n", (unsigned int) from, len); 1218 1219 readcmd = ONENAND_IS_4KB_PAGE(this) ? 1220 ONENAND_CMD_READ : ONENAND_CMD_READOOB; 1221 1222 /* Initialize return value */ 1223 ops->oobretlen = 0; 1224 1225 /* Do not allow reads past end of device */ 1226 if (unlikely((from + len) > mtd->size)) { 1227 printk(KERN_ERR "onenand_bbt_read_oob: Attempt read beyond end of device\n"); 1228 return ONENAND_BBT_READ_FATAL_ERROR; 1229 } 1230 1231 /* Grab the lock and see if the device is available */ 1232 onenand_get_device(mtd, FL_READING); 1233 1234 column = from & (mtd->oobsize - 1); 1235 1236 while (read < len) { 1237 1238 thislen = mtd->oobsize - column; 1239 thislen = min_t(int, thislen, len); 1240 1241 this->spare_buf = buf; 1242 this->command(mtd, readcmd, from, mtd->oobsize); 1243 1244 onenand_update_bufferram(mtd, from, 0); 1245 1246 ret = this->bbt_wait(mtd, FL_READING); 1247 if (unlikely(ret)) 1248 ret = onenand_recover_lsb(mtd, from, ret); 1249 1250 if (ret) 1251 break; 1252 1253 this->read_bufferram(mtd, 0, ONENAND_SPARERAM, buf, column, thislen); 1254 read += thislen; 1255 if (read == len) 1256 break; 1257 1258 buf += thislen; 1259 1260 /* Read more? */ 1261 if (read < len) { 1262 /* Update Page size */ 1263 from += this->writesize; 1264 column = 0; 1265 } 1266 } 1267 1268 /* Deselect and wake up anyone waiting on the device */ 1269 onenand_release_device(mtd); 1270 1271 ops->oobretlen = read; 1272 return ret; 1273 } 1274 1275 1276 #ifdef CONFIG_MTD_ONENAND_VERIFY_WRITE 1277 /** 1278 * onenand_verify_oob - [GENERIC] verify the oob contents after a write 1279 * @param mtd MTD device structure 1280 * @param buf the databuffer to verify 1281 * @param to offset to read from 1282 */ 1283 static int onenand_verify_oob(struct mtd_info *mtd, const u_char *buf, loff_t to) 1284 { 1285 struct onenand_chip *this = mtd->priv; 1286 u_char *oob_buf = this->oob_buf; 1287 int status, i, readcmd; 1288 1289 readcmd = ONENAND_IS_4KB_PAGE(this) ? 1290 ONENAND_CMD_READ : ONENAND_CMD_READOOB; 1291 1292 this->command(mtd, readcmd, to, mtd->oobsize); 1293 onenand_update_bufferram(mtd, to, 0); 1294 status = this->wait(mtd, FL_READING); 1295 if (status) 1296 return status; 1297 1298 this->read_bufferram(mtd, 0, ONENAND_SPARERAM, oob_buf, 0, mtd->oobsize); 1299 for (i = 0; i < mtd->oobsize; i++) 1300 if (buf[i] != 0xFF && buf[i] != oob_buf[i]) 1301 return -EBADMSG; 1302 1303 return 0; 1304 } 1305 1306 /** 1307 * onenand_verify - [GENERIC] verify the chip contents after a write 1308 * @param mtd MTD device structure 1309 * @param buf the databuffer to verify 1310 * @param addr offset to read from 1311 * @param len number of bytes to read and compare 1312 */ 1313 static int onenand_verify(struct mtd_info *mtd, const u_char *buf, loff_t addr, size_t len) 1314 { 1315 struct onenand_chip *this = mtd->priv; 1316 void __iomem *dataram; 1317 int ret = 0; 1318 int thislen, column; 1319 1320 while (len != 0) { 1321 thislen = min_t(int, this->writesize, len); 1322 column = addr & (this->writesize - 1); 1323 if (column + thislen > this->writesize) 1324 thislen = this->writesize - column; 1325 1326 this->command(mtd, ONENAND_CMD_READ, addr, this->writesize); 1327 1328 onenand_update_bufferram(mtd, addr, 0); 1329 1330 ret = this->wait(mtd, FL_READING); 1331 if (ret) 1332 return ret; 1333 1334 onenand_update_bufferram(mtd, addr, 1); 1335 1336 dataram = this->base + ONENAND_DATARAM; 1337 dataram += onenand_bufferram_offset(mtd, ONENAND_DATARAM); 1338 1339 if (memcmp(buf, dataram + column, thislen)) 1340 return -EBADMSG; 1341 1342 len -= thislen; 1343 buf += thislen; 1344 addr += thislen; 1345 } 1346 1347 return 0; 1348 } 1349 #else 1350 #define onenand_verify(...) (0) 1351 #define onenand_verify_oob(...) (0) 1352 #endif 1353 1354 #define NOTALIGNED(x) ((x & (this->subpagesize - 1)) != 0) 1355 1356 /** 1357 * onenand_fill_auto_oob - [INTERN] oob auto-placement transfer 1358 * @param mtd MTD device structure 1359 * @param oob_buf oob buffer 1360 * @param buf source address 1361 * @param column oob offset to write to 1362 * @param thislen oob length to write 1363 */ 1364 static int onenand_fill_auto_oob(struct mtd_info *mtd, u_char *oob_buf, 1365 const u_char *buf, int column, int thislen) 1366 { 1367 struct onenand_chip *this = mtd->priv; 1368 struct nand_oobfree *free; 1369 int writecol = column; 1370 int writeend = column + thislen; 1371 int lastgap = 0; 1372 unsigned int i; 1373 1374 free = this->ecclayout->oobfree; 1375 for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES_LARGE && free->length; 1376 i++, free++) { 1377 if (writecol >= lastgap) 1378 writecol += free->offset - lastgap; 1379 if (writeend >= lastgap) 1380 writeend += free->offset - lastgap; 1381 lastgap = free->offset + free->length; 1382 } 1383 free = this->ecclayout->oobfree; 1384 for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES_LARGE && free->length; 1385 i++, free++) { 1386 int free_end = free->offset + free->length; 1387 if (free->offset < writeend && free_end > writecol) { 1388 int st = max_t(int,free->offset,writecol); 1389 int ed = min_t(int,free_end,writeend); 1390 int n = ed - st; 1391 memcpy(oob_buf + st, buf, n); 1392 buf += n; 1393 } else if (column == 0) 1394 break; 1395 } 1396 return 0; 1397 } 1398 1399 /** 1400 * onenand_write_ops_nolock - [OneNAND Interface] write main and/or out-of-band 1401 * @param mtd MTD device structure 1402 * @param to offset to write to 1403 * @param ops oob operation description structure 1404 * 1405 * Write main and/or oob with ECC 1406 */ 1407 static int onenand_write_ops_nolock(struct mtd_info *mtd, loff_t to, 1408 struct mtd_oob_ops *ops) 1409 { 1410 struct onenand_chip *this = mtd->priv; 1411 int written = 0, column, thislen, subpage; 1412 int oobwritten = 0, oobcolumn, thisooblen, oobsize; 1413 size_t len = ops->len; 1414 size_t ooblen = ops->ooblen; 1415 const u_char *buf = ops->datbuf; 1416 const u_char *oob = ops->oobbuf; 1417 u_char *oobbuf; 1418 int ret = 0; 1419 1420 MTDDEBUG(MTD_DEBUG_LEVEL3, "onenand_write_ops_nolock: to = 0x%08x, len = %i\n", (unsigned int) to, (int) len); 1421 1422 /* Initialize retlen, in case of early exit */ 1423 ops->retlen = 0; 1424 ops->oobretlen = 0; 1425 1426 /* Reject writes, which are not page aligned */ 1427 if (unlikely(NOTALIGNED(to) || NOTALIGNED(len))) { 1428 printk(KERN_ERR "onenand_write_ops_nolock: Attempt to write not page aligned data\n"); 1429 return -EINVAL; 1430 } 1431 1432 if (ops->mode == MTD_OPS_AUTO_OOB) 1433 oobsize = this->ecclayout->oobavail; 1434 else 1435 oobsize = mtd->oobsize; 1436 1437 oobcolumn = to & (mtd->oobsize - 1); 1438 1439 column = to & (mtd->writesize - 1); 1440 1441 /* Loop until all data write */ 1442 while (written < len) { 1443 u_char *wbuf = (u_char *) buf; 1444 1445 thislen = min_t(int, mtd->writesize - column, len - written); 1446 thisooblen = min_t(int, oobsize - oobcolumn, ooblen - oobwritten); 1447 1448 this->command(mtd, ONENAND_CMD_BUFFERRAM, to, thislen); 1449 1450 /* Partial page write */ 1451 subpage = thislen < mtd->writesize; 1452 if (subpage) { 1453 memset(this->page_buf, 0xff, mtd->writesize); 1454 memcpy(this->page_buf + column, buf, thislen); 1455 wbuf = this->page_buf; 1456 } 1457 1458 this->write_bufferram(mtd, to, ONENAND_DATARAM, wbuf, 0, mtd->writesize); 1459 1460 if (oob) { 1461 oobbuf = this->oob_buf; 1462 1463 /* We send data to spare ram with oobsize 1464 * * to prevent byte access */ 1465 memset(oobbuf, 0xff, mtd->oobsize); 1466 if (ops->mode == MTD_OPS_AUTO_OOB) 1467 onenand_fill_auto_oob(mtd, oobbuf, oob, oobcolumn, thisooblen); 1468 else 1469 memcpy(oobbuf + oobcolumn, oob, thisooblen); 1470 1471 oobwritten += thisooblen; 1472 oob += thisooblen; 1473 oobcolumn = 0; 1474 } else 1475 oobbuf = (u_char *) ffchars; 1476 1477 this->write_bufferram(mtd, 0, ONENAND_SPARERAM, oobbuf, 0, mtd->oobsize); 1478 1479 this->command(mtd, ONENAND_CMD_PROG, to, mtd->writesize); 1480 1481 ret = this->wait(mtd, FL_WRITING); 1482 1483 /* In partial page write we don't update bufferram */ 1484 onenand_update_bufferram(mtd, to, !ret && !subpage); 1485 if (ONENAND_IS_2PLANE(this)) { 1486 ONENAND_SET_BUFFERRAM1(this); 1487 onenand_update_bufferram(mtd, to + this->writesize, !ret && !subpage); 1488 } 1489 1490 if (ret) { 1491 printk(KERN_ERR "onenand_write_ops_nolock: write filaed %d\n", ret); 1492 break; 1493 } 1494 1495 /* Only check verify write turn on */ 1496 ret = onenand_verify(mtd, buf, to, thislen); 1497 if (ret) { 1498 printk(KERN_ERR "onenand_write_ops_nolock: verify failed %d\n", ret); 1499 break; 1500 } 1501 1502 written += thislen; 1503 1504 if (written == len) 1505 break; 1506 1507 column = 0; 1508 to += thislen; 1509 buf += thislen; 1510 } 1511 1512 ops->retlen = written; 1513 1514 return ret; 1515 } 1516 1517 /** 1518 * onenand_write_oob_nolock - [INTERN] OneNAND write out-of-band 1519 * @param mtd MTD device structure 1520 * @param to offset to write to 1521 * @param len number of bytes to write 1522 * @param retlen pointer to variable to store the number of written bytes 1523 * @param buf the data to write 1524 * @param mode operation mode 1525 * 1526 * OneNAND write out-of-band 1527 */ 1528 static int onenand_write_oob_nolock(struct mtd_info *mtd, loff_t to, 1529 struct mtd_oob_ops *ops) 1530 { 1531 struct onenand_chip *this = mtd->priv; 1532 int column, ret = 0, oobsize; 1533 int written = 0, oobcmd; 1534 u_char *oobbuf; 1535 size_t len = ops->ooblen; 1536 const u_char *buf = ops->oobbuf; 1537 unsigned int mode = ops->mode; 1538 1539 to += ops->ooboffs; 1540 1541 MTDDEBUG(MTD_DEBUG_LEVEL3, "onenand_write_oob_nolock: to = 0x%08x, len = %i\n", (unsigned int) to, (int) len); 1542 1543 /* Initialize retlen, in case of early exit */ 1544 ops->oobretlen = 0; 1545 1546 if (mode == MTD_OPS_AUTO_OOB) 1547 oobsize = this->ecclayout->oobavail; 1548 else 1549 oobsize = mtd->oobsize; 1550 1551 column = to & (mtd->oobsize - 1); 1552 1553 if (unlikely(column >= oobsize)) { 1554 printk(KERN_ERR "onenand_write_oob_nolock: Attempted to start write outside oob\n"); 1555 return -EINVAL; 1556 } 1557 1558 /* For compatibility with NAND: Do not allow write past end of page */ 1559 if (unlikely(column + len > oobsize)) { 1560 printk(KERN_ERR "onenand_write_oob_nolock: " 1561 "Attempt to write past end of page\n"); 1562 return -EINVAL; 1563 } 1564 1565 /* Do not allow reads past end of device */ 1566 if (unlikely(to >= mtd->size || 1567 column + len > ((mtd->size >> this->page_shift) - 1568 (to >> this->page_shift)) * oobsize)) { 1569 printk(KERN_ERR "onenand_write_oob_nolock: Attempted to write past end of device\n"); 1570 return -EINVAL; 1571 } 1572 1573 oobbuf = this->oob_buf; 1574 1575 oobcmd = ONENAND_IS_4KB_PAGE(this) ? 1576 ONENAND_CMD_PROG : ONENAND_CMD_PROGOOB; 1577 1578 /* Loop until all data write */ 1579 while (written < len) { 1580 int thislen = min_t(int, oobsize, len - written); 1581 1582 this->command(mtd, ONENAND_CMD_BUFFERRAM, to, mtd->oobsize); 1583 1584 /* We send data to spare ram with oobsize 1585 * to prevent byte access */ 1586 memset(oobbuf, 0xff, mtd->oobsize); 1587 if (mode == MTD_OPS_AUTO_OOB) 1588 onenand_fill_auto_oob(mtd, oobbuf, buf, column, thislen); 1589 else 1590 memcpy(oobbuf + column, buf, thislen); 1591 this->write_bufferram(mtd, 0, ONENAND_SPARERAM, oobbuf, 0, mtd->oobsize); 1592 1593 if (ONENAND_IS_4KB_PAGE(this)) { 1594 /* Set main area of DataRAM to 0xff*/ 1595 memset(this->page_buf, 0xff, mtd->writesize); 1596 this->write_bufferram(mtd, 0, ONENAND_DATARAM, 1597 this->page_buf, 0, mtd->writesize); 1598 } 1599 1600 this->command(mtd, oobcmd, to, mtd->oobsize); 1601 1602 onenand_update_bufferram(mtd, to, 0); 1603 if (ONENAND_IS_2PLANE(this)) { 1604 ONENAND_SET_BUFFERRAM1(this); 1605 onenand_update_bufferram(mtd, to + this->writesize, 0); 1606 } 1607 1608 ret = this->wait(mtd, FL_WRITING); 1609 if (ret) { 1610 printk(KERN_ERR "onenand_write_oob_nolock: write failed %d\n", ret); 1611 break; 1612 } 1613 1614 ret = onenand_verify_oob(mtd, oobbuf, to); 1615 if (ret) { 1616 printk(KERN_ERR "onenand_write_oob_nolock: verify failed %d\n", ret); 1617 break; 1618 } 1619 1620 written += thislen; 1621 if (written == len) 1622 break; 1623 1624 to += mtd->writesize; 1625 buf += thislen; 1626 column = 0; 1627 } 1628 1629 ops->oobretlen = written; 1630 1631 return ret; 1632 } 1633 1634 /** 1635 * onenand_write - [MTD Interface] compability function for onenand_write_ecc 1636 * @param mtd MTD device structure 1637 * @param to offset to write to 1638 * @param len number of bytes to write 1639 * @param retlen pointer to variable to store the number of written bytes 1640 * @param buf the data to write 1641 * 1642 * Write with ECC 1643 */ 1644 int onenand_write(struct mtd_info *mtd, loff_t to, size_t len, 1645 size_t * retlen, const u_char * buf) 1646 { 1647 struct mtd_oob_ops ops = { 1648 .len = len, 1649 .ooblen = 0, 1650 .datbuf = (u_char *) buf, 1651 .oobbuf = NULL, 1652 }; 1653 int ret; 1654 1655 onenand_get_device(mtd, FL_WRITING); 1656 ret = onenand_write_ops_nolock(mtd, to, &ops); 1657 onenand_release_device(mtd); 1658 1659 *retlen = ops.retlen; 1660 return ret; 1661 } 1662 1663 /** 1664 * onenand_write_oob - [MTD Interface] OneNAND write out-of-band 1665 * @param mtd MTD device structure 1666 * @param to offset to write to 1667 * @param ops oob operation description structure 1668 * 1669 * OneNAND write main and/or out-of-band 1670 */ 1671 int onenand_write_oob(struct mtd_info *mtd, loff_t to, 1672 struct mtd_oob_ops *ops) 1673 { 1674 int ret; 1675 1676 switch (ops->mode) { 1677 case MTD_OPS_PLACE_OOB: 1678 case MTD_OPS_AUTO_OOB: 1679 break; 1680 case MTD_OPS_RAW: 1681 /* Not implemented yet */ 1682 default: 1683 return -EINVAL; 1684 } 1685 1686 onenand_get_device(mtd, FL_WRITING); 1687 if (ops->datbuf) 1688 ret = onenand_write_ops_nolock(mtd, to, ops); 1689 else 1690 ret = onenand_write_oob_nolock(mtd, to, ops); 1691 onenand_release_device(mtd); 1692 1693 return ret; 1694 1695 } 1696 1697 /** 1698 * onenand_block_isbad_nolock - [GENERIC] Check if a block is marked bad 1699 * @param mtd MTD device structure 1700 * @param ofs offset from device start 1701 * @param allowbbt 1, if its allowed to access the bbt area 1702 * 1703 * Check, if the block is bad, Either by reading the bad block table or 1704 * calling of the scan function. 1705 */ 1706 static int onenand_block_isbad_nolock(struct mtd_info *mtd, loff_t ofs, int allowbbt) 1707 { 1708 struct onenand_chip *this = mtd->priv; 1709 struct bbm_info *bbm = this->bbm; 1710 1711 /* Return info from the table */ 1712 return bbm->isbad_bbt(mtd, ofs, allowbbt); 1713 } 1714 1715 1716 /** 1717 * onenand_erase - [MTD Interface] erase block(s) 1718 * @param mtd MTD device structure 1719 * @param instr erase instruction 1720 * 1721 * Erase one ore more blocks 1722 */ 1723 int onenand_erase(struct mtd_info *mtd, struct erase_info *instr) 1724 { 1725 struct onenand_chip *this = mtd->priv; 1726 unsigned int block_size; 1727 loff_t addr = instr->addr; 1728 unsigned int len = instr->len; 1729 int ret = 0, i; 1730 struct mtd_erase_region_info *region = NULL; 1731 unsigned int region_end = 0; 1732 1733 MTDDEBUG(MTD_DEBUG_LEVEL3, "onenand_erase: start = 0x%08x, len = %i\n", 1734 (unsigned int) addr, len); 1735 1736 if (FLEXONENAND(this)) { 1737 /* Find the eraseregion of this address */ 1738 i = flexonenand_region(mtd, addr); 1739 region = &mtd->eraseregions[i]; 1740 1741 block_size = region->erasesize; 1742 region_end = region->offset 1743 + region->erasesize * region->numblocks; 1744 1745 /* Start address within region must align on block boundary. 1746 * Erase region's start offset is always block start address. 1747 */ 1748 if (unlikely((addr - region->offset) & (block_size - 1))) { 1749 MTDDEBUG(MTD_DEBUG_LEVEL0, "onenand_erase:" 1750 " Unaligned address\n"); 1751 return -EINVAL; 1752 } 1753 } else { 1754 block_size = 1 << this->erase_shift; 1755 1756 /* Start address must align on block boundary */ 1757 if (unlikely(addr & (block_size - 1))) { 1758 MTDDEBUG(MTD_DEBUG_LEVEL0, "onenand_erase:" 1759 "Unaligned address\n"); 1760 return -EINVAL; 1761 } 1762 } 1763 1764 /* Length must align on block boundary */ 1765 if (unlikely(len & (block_size - 1))) { 1766 MTDDEBUG (MTD_DEBUG_LEVEL0, 1767 "onenand_erase: Length not block aligned\n"); 1768 return -EINVAL; 1769 } 1770 1771 /* Grab the lock and see if the device is available */ 1772 onenand_get_device(mtd, FL_ERASING); 1773 1774 /* Loop throught the pages */ 1775 instr->state = MTD_ERASING; 1776 1777 while (len) { 1778 1779 /* Check if we have a bad block, we do not erase bad blocks */ 1780 if (instr->priv == 0 && onenand_block_isbad_nolock(mtd, addr, 0)) { 1781 printk(KERN_WARNING "onenand_erase: attempt to erase" 1782 " a bad block at addr 0x%08x\n", 1783 (unsigned int) addr); 1784 instr->state = MTD_ERASE_FAILED; 1785 goto erase_exit; 1786 } 1787 1788 this->command(mtd, ONENAND_CMD_ERASE, addr, block_size); 1789 1790 onenand_invalidate_bufferram(mtd, addr, block_size); 1791 1792 ret = this->wait(mtd, FL_ERASING); 1793 /* Check, if it is write protected */ 1794 if (ret) { 1795 if (ret == -EPERM) 1796 MTDDEBUG (MTD_DEBUG_LEVEL0, "onenand_erase: " 1797 "Device is write protected!!!\n"); 1798 else 1799 MTDDEBUG (MTD_DEBUG_LEVEL0, "onenand_erase: " 1800 "Failed erase, block %d\n", 1801 onenand_block(this, addr)); 1802 instr->state = MTD_ERASE_FAILED; 1803 instr->fail_addr = addr; 1804 1805 goto erase_exit; 1806 } 1807 1808 len -= block_size; 1809 addr += block_size; 1810 1811 if (addr == region_end) { 1812 if (!len) 1813 break; 1814 region++; 1815 1816 block_size = region->erasesize; 1817 region_end = region->offset 1818 + region->erasesize * region->numblocks; 1819 1820 if (len & (block_size - 1)) { 1821 /* This has been checked at MTD 1822 * partitioning level. */ 1823 printk("onenand_erase: Unaligned address\n"); 1824 goto erase_exit; 1825 } 1826 } 1827 } 1828 1829 instr->state = MTD_ERASE_DONE; 1830 1831 erase_exit: 1832 1833 ret = instr->state == MTD_ERASE_DONE ? 0 : -EIO; 1834 /* Do call back function */ 1835 if (!ret) 1836 mtd_erase_callback(instr); 1837 1838 /* Deselect and wake up anyone waiting on the device */ 1839 onenand_release_device(mtd); 1840 1841 return ret; 1842 } 1843 1844 /** 1845 * onenand_sync - [MTD Interface] sync 1846 * @param mtd MTD device structure 1847 * 1848 * Sync is actually a wait for chip ready function 1849 */ 1850 void onenand_sync(struct mtd_info *mtd) 1851 { 1852 MTDDEBUG (MTD_DEBUG_LEVEL3, "onenand_sync: called\n"); 1853 1854 /* Grab the lock and see if the device is available */ 1855 onenand_get_device(mtd, FL_SYNCING); 1856 1857 /* Release it and go back */ 1858 onenand_release_device(mtd); 1859 } 1860 1861 /** 1862 * onenand_block_isbad - [MTD Interface] Check whether the block at the given offset is bad 1863 * @param mtd MTD device structure 1864 * @param ofs offset relative to mtd start 1865 * 1866 * Check whether the block is bad 1867 */ 1868 int onenand_block_isbad(struct mtd_info *mtd, loff_t ofs) 1869 { 1870 int ret; 1871 1872 /* Check for invalid offset */ 1873 if (ofs > mtd->size) 1874 return -EINVAL; 1875 1876 onenand_get_device(mtd, FL_READING); 1877 ret = onenand_block_isbad_nolock(mtd,ofs, 0); 1878 onenand_release_device(mtd); 1879 return ret; 1880 } 1881 1882 /** 1883 * onenand_default_block_markbad - [DEFAULT] mark a block bad 1884 * @param mtd MTD device structure 1885 * @param ofs offset from device start 1886 * 1887 * This is the default implementation, which can be overridden by 1888 * a hardware specific driver. 1889 */ 1890 static int onenand_default_block_markbad(struct mtd_info *mtd, loff_t ofs) 1891 { 1892 struct onenand_chip *this = mtd->priv; 1893 struct bbm_info *bbm = this->bbm; 1894 u_char buf[2] = {0, 0}; 1895 struct mtd_oob_ops ops = { 1896 .mode = MTD_OPS_PLACE_OOB, 1897 .ooblen = 2, 1898 .oobbuf = buf, 1899 .ooboffs = 0, 1900 }; 1901 int block; 1902 1903 /* Get block number */ 1904 block = onenand_block(this, ofs); 1905 if (bbm->bbt) 1906 bbm->bbt[block >> 2] |= 0x01 << ((block & 0x03) << 1); 1907 1908 /* We write two bytes, so we dont have to mess with 16 bit access */ 1909 ofs += mtd->oobsize + (bbm->badblockpos & ~0x01); 1910 return onenand_write_oob_nolock(mtd, ofs, &ops); 1911 } 1912 1913 /** 1914 * onenand_block_markbad - [MTD Interface] Mark the block at the given offset as bad 1915 * @param mtd MTD device structure 1916 * @param ofs offset relative to mtd start 1917 * 1918 * Mark the block as bad 1919 */ 1920 int onenand_block_markbad(struct mtd_info *mtd, loff_t ofs) 1921 { 1922 int ret; 1923 1924 ret = onenand_block_isbad(mtd, ofs); 1925 if (ret) { 1926 /* If it was bad already, return success and do nothing */ 1927 if (ret > 0) 1928 return 0; 1929 return ret; 1930 } 1931 1932 ret = mtd_block_markbad(mtd, ofs); 1933 return ret; 1934 } 1935 1936 /** 1937 * onenand_do_lock_cmd - [OneNAND Interface] Lock or unlock block(s) 1938 * @param mtd MTD device structure 1939 * @param ofs offset relative to mtd start 1940 * @param len number of bytes to lock or unlock 1941 * @param cmd lock or unlock command 1942 * 1943 * Lock or unlock one or more blocks 1944 */ 1945 static int onenand_do_lock_cmd(struct mtd_info *mtd, loff_t ofs, size_t len, int cmd) 1946 { 1947 struct onenand_chip *this = mtd->priv; 1948 int start, end, block, value, status; 1949 1950 start = onenand_block(this, ofs); 1951 end = onenand_block(this, ofs + len); 1952 1953 /* Continuous lock scheme */ 1954 if (this->options & ONENAND_HAS_CONT_LOCK) { 1955 /* Set start block address */ 1956 this->write_word(start, 1957 this->base + ONENAND_REG_START_BLOCK_ADDRESS); 1958 /* Set end block address */ 1959 this->write_word(end - 1, 1960 this->base + ONENAND_REG_END_BLOCK_ADDRESS); 1961 /* Write unlock command */ 1962 this->command(mtd, cmd, 0, 0); 1963 1964 /* There's no return value */ 1965 this->wait(mtd, FL_UNLOCKING); 1966 1967 /* Sanity check */ 1968 while (this->read_word(this->base + ONENAND_REG_CTRL_STATUS) 1969 & ONENAND_CTRL_ONGO) 1970 continue; 1971 1972 /* Check lock status */ 1973 status = this->read_word(this->base + ONENAND_REG_WP_STATUS); 1974 if (!(status & ONENAND_WP_US)) 1975 printk(KERN_ERR "wp status = 0x%x\n", status); 1976 1977 return 0; 1978 } 1979 1980 /* Block lock scheme */ 1981 for (block = start; block < end; block++) { 1982 /* Set block address */ 1983 value = onenand_block_address(this, block); 1984 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS1); 1985 /* Select DataRAM for DDP */ 1986 value = onenand_bufferram_address(this, block); 1987 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS2); 1988 1989 /* Set start block address */ 1990 this->write_word(block, 1991 this->base + ONENAND_REG_START_BLOCK_ADDRESS); 1992 /* Write unlock command */ 1993 this->command(mtd, ONENAND_CMD_UNLOCK, 0, 0); 1994 1995 /* There's no return value */ 1996 this->wait(mtd, FL_UNLOCKING); 1997 1998 /* Sanity check */ 1999 while (this->read_word(this->base + ONENAND_REG_CTRL_STATUS) 2000 & ONENAND_CTRL_ONGO) 2001 continue; 2002 2003 /* Check lock status */ 2004 status = this->read_word(this->base + ONENAND_REG_WP_STATUS); 2005 if (!(status & ONENAND_WP_US)) 2006 printk(KERN_ERR "block = %d, wp status = 0x%x\n", 2007 block, status); 2008 } 2009 2010 return 0; 2011 } 2012 2013 #ifdef ONENAND_LINUX 2014 /** 2015 * onenand_lock - [MTD Interface] Lock block(s) 2016 * @param mtd MTD device structure 2017 * @param ofs offset relative to mtd start 2018 * @param len number of bytes to unlock 2019 * 2020 * Lock one or more blocks 2021 */ 2022 static int onenand_lock(struct mtd_info *mtd, loff_t ofs, size_t len) 2023 { 2024 int ret; 2025 2026 onenand_get_device(mtd, FL_LOCKING); 2027 ret = onenand_do_lock_cmd(mtd, ofs, len, ONENAND_CMD_LOCK); 2028 onenand_release_device(mtd); 2029 return ret; 2030 } 2031 2032 /** 2033 * onenand_unlock - [MTD Interface] Unlock block(s) 2034 * @param mtd MTD device structure 2035 * @param ofs offset relative to mtd start 2036 * @param len number of bytes to unlock 2037 * 2038 * Unlock one or more blocks 2039 */ 2040 static int onenand_unlock(struct mtd_info *mtd, loff_t ofs, size_t len) 2041 { 2042 int ret; 2043 2044 onenand_get_device(mtd, FL_LOCKING); 2045 ret = onenand_do_lock_cmd(mtd, ofs, len, ONENAND_CMD_UNLOCK); 2046 onenand_release_device(mtd); 2047 return ret; 2048 } 2049 #endif 2050 2051 /** 2052 * onenand_check_lock_status - [OneNAND Interface] Check lock status 2053 * @param this onenand chip data structure 2054 * 2055 * Check lock status 2056 */ 2057 static int onenand_check_lock_status(struct onenand_chip *this) 2058 { 2059 unsigned int value, block, status; 2060 unsigned int end; 2061 2062 end = this->chipsize >> this->erase_shift; 2063 for (block = 0; block < end; block++) { 2064 /* Set block address */ 2065 value = onenand_block_address(this, block); 2066 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS1); 2067 /* Select DataRAM for DDP */ 2068 value = onenand_bufferram_address(this, block); 2069 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS2); 2070 /* Set start block address */ 2071 this->write_word(block, this->base + ONENAND_REG_START_BLOCK_ADDRESS); 2072 2073 /* Check lock status */ 2074 status = this->read_word(this->base + ONENAND_REG_WP_STATUS); 2075 if (!(status & ONENAND_WP_US)) { 2076 printk(KERN_ERR "block = %d, wp status = 0x%x\n", block, status); 2077 return 0; 2078 } 2079 } 2080 2081 return 1; 2082 } 2083 2084 /** 2085 * onenand_unlock_all - [OneNAND Interface] unlock all blocks 2086 * @param mtd MTD device structure 2087 * 2088 * Unlock all blocks 2089 */ 2090 static void onenand_unlock_all(struct mtd_info *mtd) 2091 { 2092 struct onenand_chip *this = mtd->priv; 2093 loff_t ofs = 0; 2094 size_t len = mtd->size; 2095 2096 if (this->options & ONENAND_HAS_UNLOCK_ALL) { 2097 /* Set start block address */ 2098 this->write_word(0, this->base + ONENAND_REG_START_BLOCK_ADDRESS); 2099 /* Write unlock command */ 2100 this->command(mtd, ONENAND_CMD_UNLOCK_ALL, 0, 0); 2101 2102 /* There's no return value */ 2103 this->wait(mtd, FL_LOCKING); 2104 2105 /* Sanity check */ 2106 while (this->read_word(this->base + ONENAND_REG_CTRL_STATUS) 2107 & ONENAND_CTRL_ONGO) 2108 continue; 2109 2110 /* Check lock status */ 2111 if (onenand_check_lock_status(this)) 2112 return; 2113 2114 /* Workaround for all block unlock in DDP */ 2115 if (ONENAND_IS_DDP(this) && !FLEXONENAND(this)) { 2116 /* All blocks on another chip */ 2117 ofs = this->chipsize >> 1; 2118 len = this->chipsize >> 1; 2119 } 2120 } 2121 2122 onenand_do_lock_cmd(mtd, ofs, len, ONENAND_CMD_UNLOCK); 2123 } 2124 2125 2126 /** 2127 * onenand_check_features - Check and set OneNAND features 2128 * @param mtd MTD data structure 2129 * 2130 * Check and set OneNAND features 2131 * - lock scheme 2132 * - two plane 2133 */ 2134 static void onenand_check_features(struct mtd_info *mtd) 2135 { 2136 struct onenand_chip *this = mtd->priv; 2137 unsigned int density, process; 2138 2139 /* Lock scheme depends on density and process */ 2140 density = onenand_get_density(this->device_id); 2141 process = this->version_id >> ONENAND_VERSION_PROCESS_SHIFT; 2142 2143 /* Lock scheme */ 2144 switch (density) { 2145 case ONENAND_DEVICE_DENSITY_4Gb: 2146 if (ONENAND_IS_DDP(this)) 2147 this->options |= ONENAND_HAS_2PLANE; 2148 else 2149 this->options |= ONENAND_HAS_4KB_PAGE; 2150 2151 case ONENAND_DEVICE_DENSITY_2Gb: 2152 /* 2Gb DDP don't have 2 plane */ 2153 if (!ONENAND_IS_DDP(this)) 2154 this->options |= ONENAND_HAS_2PLANE; 2155 this->options |= ONENAND_HAS_UNLOCK_ALL; 2156 2157 case ONENAND_DEVICE_DENSITY_1Gb: 2158 /* A-Die has all block unlock */ 2159 if (process) 2160 this->options |= ONENAND_HAS_UNLOCK_ALL; 2161 break; 2162 2163 default: 2164 /* Some OneNAND has continuous lock scheme */ 2165 if (!process) 2166 this->options |= ONENAND_HAS_CONT_LOCK; 2167 break; 2168 } 2169 2170 if (ONENAND_IS_MLC(this)) 2171 this->options |= ONENAND_HAS_4KB_PAGE; 2172 2173 if (ONENAND_IS_4KB_PAGE(this)) 2174 this->options &= ~ONENAND_HAS_2PLANE; 2175 2176 if (FLEXONENAND(this)) { 2177 this->options &= ~ONENAND_HAS_CONT_LOCK; 2178 this->options |= ONENAND_HAS_UNLOCK_ALL; 2179 } 2180 2181 if (this->options & ONENAND_HAS_CONT_LOCK) 2182 printk(KERN_DEBUG "Lock scheme is Continuous Lock\n"); 2183 if (this->options & ONENAND_HAS_UNLOCK_ALL) 2184 printk(KERN_DEBUG "Chip support all block unlock\n"); 2185 if (this->options & ONENAND_HAS_2PLANE) 2186 printk(KERN_DEBUG "Chip has 2 plane\n"); 2187 if (this->options & ONENAND_HAS_4KB_PAGE) 2188 printk(KERN_DEBUG "Chip has 4KiB pagesize\n"); 2189 2190 } 2191 2192 /** 2193 * onenand_print_device_info - Print device ID 2194 * @param device device ID 2195 * 2196 * Print device ID 2197 */ 2198 char *onenand_print_device_info(int device, int version) 2199 { 2200 int vcc, demuxed, ddp, density, flexonenand; 2201 char *dev_info = malloc(80); 2202 char *p = dev_info; 2203 2204 vcc = device & ONENAND_DEVICE_VCC_MASK; 2205 demuxed = device & ONENAND_DEVICE_IS_DEMUX; 2206 ddp = device & ONENAND_DEVICE_IS_DDP; 2207 density = onenand_get_density(device); 2208 flexonenand = device & DEVICE_IS_FLEXONENAND; 2209 p += sprintf(dev_info, "%s%sOneNAND%s %dMB %sV 16-bit (0x%02x)", 2210 demuxed ? "" : "Muxed ", 2211 flexonenand ? "Flex-" : "", 2212 ddp ? "(DDP)" : "", 2213 (16 << density), vcc ? "2.65/3.3" : "1.8", device); 2214 2215 sprintf(p, "\nOneNAND version = 0x%04x", version); 2216 printk("%s\n", dev_info); 2217 2218 return dev_info; 2219 } 2220 2221 static const struct onenand_manufacturers onenand_manuf_ids[] = { 2222 {ONENAND_MFR_NUMONYX, "Numonyx"}, 2223 {ONENAND_MFR_SAMSUNG, "Samsung"}, 2224 }; 2225 2226 /** 2227 * onenand_check_maf - Check manufacturer ID 2228 * @param manuf manufacturer ID 2229 * 2230 * Check manufacturer ID 2231 */ 2232 static int onenand_check_maf(int manuf) 2233 { 2234 int size = ARRAY_SIZE(onenand_manuf_ids); 2235 int i; 2236 #ifdef ONENAND_DEBUG 2237 char *name; 2238 #endif 2239 2240 for (i = 0; i < size; i++) 2241 if (manuf == onenand_manuf_ids[i].id) 2242 break; 2243 2244 #ifdef ONENAND_DEBUG 2245 if (i < size) 2246 name = onenand_manuf_ids[i].name; 2247 else 2248 name = "Unknown"; 2249 2250 printk(KERN_DEBUG "OneNAND Manufacturer: %s (0x%0x)\n", name, manuf); 2251 #endif 2252 2253 return i == size; 2254 } 2255 2256 /** 2257 * flexonenand_get_boundary - Reads the SLC boundary 2258 * @param onenand_info - onenand info structure 2259 * 2260 * Fill up boundary[] field in onenand_chip 2261 **/ 2262 static int flexonenand_get_boundary(struct mtd_info *mtd) 2263 { 2264 struct onenand_chip *this = mtd->priv; 2265 unsigned int die, bdry; 2266 int syscfg, locked; 2267 2268 /* Disable ECC */ 2269 syscfg = this->read_word(this->base + ONENAND_REG_SYS_CFG1); 2270 this->write_word((syscfg | 0x0100), this->base + ONENAND_REG_SYS_CFG1); 2271 2272 for (die = 0; die < this->dies; die++) { 2273 this->command(mtd, FLEXONENAND_CMD_PI_ACCESS, die, 0); 2274 this->wait(mtd, FL_SYNCING); 2275 2276 this->command(mtd, FLEXONENAND_CMD_READ_PI, die, 0); 2277 this->wait(mtd, FL_READING); 2278 2279 bdry = this->read_word(this->base + ONENAND_DATARAM); 2280 if ((bdry >> FLEXONENAND_PI_UNLOCK_SHIFT) == 3) 2281 locked = 0; 2282 else 2283 locked = 1; 2284 this->boundary[die] = bdry & FLEXONENAND_PI_MASK; 2285 2286 this->command(mtd, ONENAND_CMD_RESET, 0, 0); 2287 this->wait(mtd, FL_RESETING); 2288 2289 printk(KERN_INFO "Die %d boundary: %d%s\n", die, 2290 this->boundary[die], locked ? "(Locked)" : "(Unlocked)"); 2291 } 2292 2293 /* Enable ECC */ 2294 this->write_word(syscfg, this->base + ONENAND_REG_SYS_CFG1); 2295 return 0; 2296 } 2297 2298 /** 2299 * flexonenand_get_size - Fill up fields in onenand_chip and mtd_info 2300 * boundary[], diesize[], mtd->size, mtd->erasesize, 2301 * mtd->eraseregions 2302 * @param mtd - MTD device structure 2303 */ 2304 static void flexonenand_get_size(struct mtd_info *mtd) 2305 { 2306 struct onenand_chip *this = mtd->priv; 2307 int die, i, eraseshift, density; 2308 int blksperdie, maxbdry; 2309 loff_t ofs; 2310 2311 density = onenand_get_density(this->device_id); 2312 blksperdie = ((loff_t)(16 << density) << 20) >> (this->erase_shift); 2313 blksperdie >>= ONENAND_IS_DDP(this) ? 1 : 0; 2314 maxbdry = blksperdie - 1; 2315 eraseshift = this->erase_shift - 1; 2316 2317 mtd->numeraseregions = this->dies << 1; 2318 2319 /* This fills up the device boundary */ 2320 flexonenand_get_boundary(mtd); 2321 die = 0; 2322 ofs = 0; 2323 i = -1; 2324 for (; die < this->dies; die++) { 2325 if (!die || this->boundary[die-1] != maxbdry) { 2326 i++; 2327 mtd->eraseregions[i].offset = ofs; 2328 mtd->eraseregions[i].erasesize = 1 << eraseshift; 2329 mtd->eraseregions[i].numblocks = 2330 this->boundary[die] + 1; 2331 ofs += mtd->eraseregions[i].numblocks << eraseshift; 2332 eraseshift++; 2333 } else { 2334 mtd->numeraseregions -= 1; 2335 mtd->eraseregions[i].numblocks += 2336 this->boundary[die] + 1; 2337 ofs += (this->boundary[die] + 1) << (eraseshift - 1); 2338 } 2339 if (this->boundary[die] != maxbdry) { 2340 i++; 2341 mtd->eraseregions[i].offset = ofs; 2342 mtd->eraseregions[i].erasesize = 1 << eraseshift; 2343 mtd->eraseregions[i].numblocks = maxbdry ^ 2344 this->boundary[die]; 2345 ofs += mtd->eraseregions[i].numblocks << eraseshift; 2346 eraseshift--; 2347 } else 2348 mtd->numeraseregions -= 1; 2349 } 2350 2351 /* Expose MLC erase size except when all blocks are SLC */ 2352 mtd->erasesize = 1 << this->erase_shift; 2353 if (mtd->numeraseregions == 1) 2354 mtd->erasesize >>= 1; 2355 2356 printk(KERN_INFO "Device has %d eraseregions\n", mtd->numeraseregions); 2357 for (i = 0; i < mtd->numeraseregions; i++) 2358 printk(KERN_INFO "[offset: 0x%08llx, erasesize: 0x%05x," 2359 " numblocks: %04u]\n", mtd->eraseregions[i].offset, 2360 mtd->eraseregions[i].erasesize, 2361 mtd->eraseregions[i].numblocks); 2362 2363 for (die = 0, mtd->size = 0; die < this->dies; die++) { 2364 this->diesize[die] = (loff_t) (blksperdie << this->erase_shift); 2365 this->diesize[die] -= (loff_t) (this->boundary[die] + 1) 2366 << (this->erase_shift - 1); 2367 mtd->size += this->diesize[die]; 2368 } 2369 } 2370 2371 /** 2372 * flexonenand_check_blocks_erased - Check if blocks are erased 2373 * @param mtd_info - mtd info structure 2374 * @param start - first erase block to check 2375 * @param end - last erase block to check 2376 * 2377 * Converting an unerased block from MLC to SLC 2378 * causes byte values to change. Since both data and its ECC 2379 * have changed, reads on the block give uncorrectable error. 2380 * This might lead to the block being detected as bad. 2381 * 2382 * Avoid this by ensuring that the block to be converted is 2383 * erased. 2384 */ 2385 static int flexonenand_check_blocks_erased(struct mtd_info *mtd, 2386 int start, int end) 2387 { 2388 struct onenand_chip *this = mtd->priv; 2389 int i, ret; 2390 int block; 2391 struct mtd_oob_ops ops = { 2392 .mode = MTD_OPS_PLACE_OOB, 2393 .ooboffs = 0, 2394 .ooblen = mtd->oobsize, 2395 .datbuf = NULL, 2396 .oobbuf = this->oob_buf, 2397 }; 2398 loff_t addr; 2399 2400 printk(KERN_DEBUG "Check blocks from %d to %d\n", start, end); 2401 2402 for (block = start; block <= end; block++) { 2403 addr = flexonenand_addr(this, block); 2404 if (onenand_block_isbad_nolock(mtd, addr, 0)) 2405 continue; 2406 2407 /* 2408 * Since main area write results in ECC write to spare, 2409 * it is sufficient to check only ECC bytes for change. 2410 */ 2411 ret = onenand_read_oob_nolock(mtd, addr, &ops); 2412 if (ret) 2413 return ret; 2414 2415 for (i = 0; i < mtd->oobsize; i++) 2416 if (this->oob_buf[i] != 0xff) 2417 break; 2418 2419 if (i != mtd->oobsize) { 2420 printk(KERN_WARNING "Block %d not erased.\n", block); 2421 return 1; 2422 } 2423 } 2424 2425 return 0; 2426 } 2427 2428 /** 2429 * flexonenand_set_boundary - Writes the SLC boundary 2430 * @param mtd - mtd info structure 2431 */ 2432 int flexonenand_set_boundary(struct mtd_info *mtd, int die, 2433 int boundary, int lock) 2434 { 2435 struct onenand_chip *this = mtd->priv; 2436 int ret, density, blksperdie, old, new, thisboundary; 2437 loff_t addr; 2438 2439 if (die >= this->dies) 2440 return -EINVAL; 2441 2442 if (boundary == this->boundary[die]) 2443 return 0; 2444 2445 density = onenand_get_density(this->device_id); 2446 blksperdie = ((16 << density) << 20) >> this->erase_shift; 2447 blksperdie >>= ONENAND_IS_DDP(this) ? 1 : 0; 2448 2449 if (boundary >= blksperdie) { 2450 printk("flexonenand_set_boundary:" 2451 "Invalid boundary value. " 2452 "Boundary not changed.\n"); 2453 return -EINVAL; 2454 } 2455 2456 /* Check if converting blocks are erased */ 2457 old = this->boundary[die] + (die * this->density_mask); 2458 new = boundary + (die * this->density_mask); 2459 ret = flexonenand_check_blocks_erased(mtd, min(old, new) 2460 + 1, max(old, new)); 2461 if (ret) { 2462 printk(KERN_ERR "flexonenand_set_boundary: Please erase blocks before boundary change\n"); 2463 return ret; 2464 } 2465 2466 this->command(mtd, FLEXONENAND_CMD_PI_ACCESS, die, 0); 2467 this->wait(mtd, FL_SYNCING); 2468 2469 /* Check is boundary is locked */ 2470 this->command(mtd, FLEXONENAND_CMD_READ_PI, die, 0); 2471 ret = this->wait(mtd, FL_READING); 2472 2473 thisboundary = this->read_word(this->base + ONENAND_DATARAM); 2474 if ((thisboundary >> FLEXONENAND_PI_UNLOCK_SHIFT) != 3) { 2475 printk(KERN_ERR "flexonenand_set_boundary: boundary locked\n"); 2476 goto out; 2477 } 2478 2479 printk(KERN_INFO "flexonenand_set_boundary: Changing die %d boundary: %d%s\n", 2480 die, boundary, lock ? "(Locked)" : "(Unlocked)"); 2481 2482 boundary &= FLEXONENAND_PI_MASK; 2483 boundary |= lock ? 0 : (3 << FLEXONENAND_PI_UNLOCK_SHIFT); 2484 2485 addr = die ? this->diesize[0] : 0; 2486 this->command(mtd, ONENAND_CMD_ERASE, addr, 0); 2487 ret = this->wait(mtd, FL_ERASING); 2488 if (ret) { 2489 printk("flexonenand_set_boundary:" 2490 "Failed PI erase for Die %d\n", die); 2491 goto out; 2492 } 2493 2494 this->write_word(boundary, this->base + ONENAND_DATARAM); 2495 this->command(mtd, ONENAND_CMD_PROG, addr, 0); 2496 ret = this->wait(mtd, FL_WRITING); 2497 if (ret) { 2498 printk("flexonenand_set_boundary:" 2499 "Failed PI write for Die %d\n", die); 2500 goto out; 2501 } 2502 2503 this->command(mtd, FLEXONENAND_CMD_PI_UPDATE, die, 0); 2504 ret = this->wait(mtd, FL_WRITING); 2505 out: 2506 this->write_word(ONENAND_CMD_RESET, this->base + ONENAND_REG_COMMAND); 2507 this->wait(mtd, FL_RESETING); 2508 if (!ret) 2509 /* Recalculate device size on boundary change*/ 2510 flexonenand_get_size(mtd); 2511 2512 return ret; 2513 } 2514 2515 /** 2516 * onenand_chip_probe - [OneNAND Interface] Probe the OneNAND chip 2517 * @param mtd MTD device structure 2518 * 2519 * OneNAND detection method: 2520 * Compare the the values from command with ones from register 2521 */ 2522 static int onenand_chip_probe(struct mtd_info *mtd) 2523 { 2524 struct onenand_chip *this = mtd->priv; 2525 int bram_maf_id, bram_dev_id, maf_id, dev_id; 2526 int syscfg; 2527 2528 /* Save system configuration 1 */ 2529 syscfg = this->read_word(this->base + ONENAND_REG_SYS_CFG1); 2530 2531 /* Clear Sync. Burst Read mode to read BootRAM */ 2532 this->write_word((syscfg & ~ONENAND_SYS_CFG1_SYNC_READ), 2533 this->base + ONENAND_REG_SYS_CFG1); 2534 2535 /* Send the command for reading device ID from BootRAM */ 2536 this->write_word(ONENAND_CMD_READID, this->base + ONENAND_BOOTRAM); 2537 2538 /* Read manufacturer and device IDs from BootRAM */ 2539 bram_maf_id = this->read_word(this->base + ONENAND_BOOTRAM + 0x0); 2540 bram_dev_id = this->read_word(this->base + ONENAND_BOOTRAM + 0x2); 2541 2542 /* Reset OneNAND to read default register values */ 2543 this->write_word(ONENAND_CMD_RESET, this->base + ONENAND_BOOTRAM); 2544 2545 /* Wait reset */ 2546 if (this->wait(mtd, FL_RESETING)) 2547 return -ENXIO; 2548 2549 /* Restore system configuration 1 */ 2550 this->write_word(syscfg, this->base + ONENAND_REG_SYS_CFG1); 2551 2552 /* Check manufacturer ID */ 2553 if (onenand_check_maf(bram_maf_id)) 2554 return -ENXIO; 2555 2556 /* Read manufacturer and device IDs from Register */ 2557 maf_id = this->read_word(this->base + ONENAND_REG_MANUFACTURER_ID); 2558 dev_id = this->read_word(this->base + ONENAND_REG_DEVICE_ID); 2559 2560 /* Check OneNAND device */ 2561 if (maf_id != bram_maf_id || dev_id != bram_dev_id) 2562 return -ENXIO; 2563 2564 return 0; 2565 } 2566 2567 /** 2568 * onenand_probe - [OneNAND Interface] Probe the OneNAND device 2569 * @param mtd MTD device structure 2570 * 2571 * OneNAND detection method: 2572 * Compare the the values from command with ones from register 2573 */ 2574 int onenand_probe(struct mtd_info *mtd) 2575 { 2576 struct onenand_chip *this = mtd->priv; 2577 int dev_id, ver_id; 2578 int density; 2579 int ret; 2580 2581 ret = this->chip_probe(mtd); 2582 if (ret) 2583 return ret; 2584 2585 /* Read device IDs from Register */ 2586 dev_id = this->read_word(this->base + ONENAND_REG_DEVICE_ID); 2587 ver_id = this->read_word(this->base + ONENAND_REG_VERSION_ID); 2588 this->technology = this->read_word(this->base + ONENAND_REG_TECHNOLOGY); 2589 2590 /* Flash device information */ 2591 mtd->name = onenand_print_device_info(dev_id, ver_id); 2592 this->device_id = dev_id; 2593 this->version_id = ver_id; 2594 2595 /* Check OneNAND features */ 2596 onenand_check_features(mtd); 2597 2598 density = onenand_get_density(dev_id); 2599 if (FLEXONENAND(this)) { 2600 this->dies = ONENAND_IS_DDP(this) ? 2 : 1; 2601 /* Maximum possible erase regions */ 2602 mtd->numeraseregions = this->dies << 1; 2603 mtd->eraseregions = malloc(sizeof(struct mtd_erase_region_info) 2604 * (this->dies << 1)); 2605 if (!mtd->eraseregions) 2606 return -ENOMEM; 2607 } 2608 2609 /* 2610 * For Flex-OneNAND, chipsize represents maximum possible device size. 2611 * mtd->size represents the actual device size. 2612 */ 2613 this->chipsize = (16 << density) << 20; 2614 2615 /* OneNAND page size & block size */ 2616 /* The data buffer size is equal to page size */ 2617 mtd->writesize = 2618 this->read_word(this->base + ONENAND_REG_DATA_BUFFER_SIZE); 2619 /* We use the full BufferRAM */ 2620 if (ONENAND_IS_4KB_PAGE(this)) 2621 mtd->writesize <<= 1; 2622 2623 mtd->oobsize = mtd->writesize >> 5; 2624 /* Pagers per block is always 64 in OneNAND */ 2625 mtd->erasesize = mtd->writesize << 6; 2626 /* 2627 * Flex-OneNAND SLC area has 64 pages per block. 2628 * Flex-OneNAND MLC area has 128 pages per block. 2629 * Expose MLC erase size to find erase_shift and page_mask. 2630 */ 2631 if (FLEXONENAND(this)) 2632 mtd->erasesize <<= 1; 2633 2634 this->erase_shift = ffs(mtd->erasesize) - 1; 2635 this->page_shift = ffs(mtd->writesize) - 1; 2636 this->ppb_shift = (this->erase_shift - this->page_shift); 2637 this->page_mask = (mtd->erasesize / mtd->writesize) - 1; 2638 /* Set density mask. it is used for DDP */ 2639 if (ONENAND_IS_DDP(this)) 2640 this->density_mask = this->chipsize >> (this->erase_shift + 1); 2641 /* It's real page size */ 2642 this->writesize = mtd->writesize; 2643 2644 /* REVIST: Multichip handling */ 2645 2646 if (FLEXONENAND(this)) 2647 flexonenand_get_size(mtd); 2648 else 2649 mtd->size = this->chipsize; 2650 2651 mtd->flags = MTD_CAP_NANDFLASH; 2652 mtd->_erase = onenand_erase; 2653 mtd->_read = onenand_read; 2654 mtd->_write = onenand_write; 2655 mtd->_read_oob = onenand_read_oob; 2656 mtd->_write_oob = onenand_write_oob; 2657 mtd->_sync = onenand_sync; 2658 mtd->_block_isbad = onenand_block_isbad; 2659 mtd->_block_markbad = onenand_block_markbad; 2660 mtd->writebufsize = mtd->writesize; 2661 2662 return 0; 2663 } 2664 2665 /** 2666 * onenand_scan - [OneNAND Interface] Scan for the OneNAND device 2667 * @param mtd MTD device structure 2668 * @param maxchips Number of chips to scan for 2669 * 2670 * This fills out all the not initialized function pointers 2671 * with the defaults. 2672 * The flash ID is read and the mtd/chip structures are 2673 * filled with the appropriate values. 2674 */ 2675 int onenand_scan(struct mtd_info *mtd, int maxchips) 2676 { 2677 int i; 2678 struct onenand_chip *this = mtd->priv; 2679 2680 if (!this->read_word) 2681 this->read_word = onenand_readw; 2682 if (!this->write_word) 2683 this->write_word = onenand_writew; 2684 2685 if (!this->command) 2686 this->command = onenand_command; 2687 if (!this->wait) 2688 this->wait = onenand_wait; 2689 if (!this->bbt_wait) 2690 this->bbt_wait = onenand_bbt_wait; 2691 2692 if (!this->read_bufferram) 2693 this->read_bufferram = onenand_read_bufferram; 2694 if (!this->write_bufferram) 2695 this->write_bufferram = onenand_write_bufferram; 2696 2697 if (!this->chip_probe) 2698 this->chip_probe = onenand_chip_probe; 2699 2700 if (!this->block_markbad) 2701 this->block_markbad = onenand_default_block_markbad; 2702 if (!this->scan_bbt) 2703 this->scan_bbt = onenand_default_bbt; 2704 2705 if (onenand_probe(mtd)) 2706 return -ENXIO; 2707 2708 /* Set Sync. Burst Read after probing */ 2709 if (this->mmcontrol) { 2710 printk(KERN_INFO "OneNAND Sync. Burst Read support\n"); 2711 this->read_bufferram = onenand_sync_read_bufferram; 2712 } 2713 2714 /* Allocate buffers, if necessary */ 2715 if (!this->page_buf) { 2716 this->page_buf = kzalloc(mtd->writesize, GFP_KERNEL); 2717 if (!this->page_buf) { 2718 printk(KERN_ERR "onenand_scan(): Can't allocate page_buf\n"); 2719 return -ENOMEM; 2720 } 2721 this->options |= ONENAND_PAGEBUF_ALLOC; 2722 } 2723 if (!this->oob_buf) { 2724 this->oob_buf = kzalloc(mtd->oobsize, GFP_KERNEL); 2725 if (!this->oob_buf) { 2726 printk(KERN_ERR "onenand_scan: Can't allocate oob_buf\n"); 2727 if (this->options & ONENAND_PAGEBUF_ALLOC) { 2728 this->options &= ~ONENAND_PAGEBUF_ALLOC; 2729 kfree(this->page_buf); 2730 } 2731 return -ENOMEM; 2732 } 2733 this->options |= ONENAND_OOBBUF_ALLOC; 2734 } 2735 2736 this->state = FL_READY; 2737 2738 /* 2739 * Allow subpage writes up to oobsize. 2740 */ 2741 switch (mtd->oobsize) { 2742 case 128: 2743 this->ecclayout = &onenand_oob_128; 2744 mtd->subpage_sft = 0; 2745 break; 2746 2747 case 64: 2748 this->ecclayout = &onenand_oob_64; 2749 mtd->subpage_sft = 2; 2750 break; 2751 2752 case 32: 2753 this->ecclayout = &onenand_oob_32; 2754 mtd->subpage_sft = 1; 2755 break; 2756 2757 default: 2758 printk(KERN_WARNING "No OOB scheme defined for oobsize %d\n", 2759 mtd->oobsize); 2760 mtd->subpage_sft = 0; 2761 /* To prevent kernel oops */ 2762 this->ecclayout = &onenand_oob_32; 2763 break; 2764 } 2765 2766 this->subpagesize = mtd->writesize >> mtd->subpage_sft; 2767 2768 /* 2769 * The number of bytes available for a client to place data into 2770 * the out of band area 2771 */ 2772 this->ecclayout->oobavail = 0; 2773 2774 for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES_LARGE && 2775 this->ecclayout->oobfree[i].length; i++) 2776 this->ecclayout->oobavail += 2777 this->ecclayout->oobfree[i].length; 2778 mtd->oobavail = this->ecclayout->oobavail; 2779 2780 mtd->ecclayout = this->ecclayout; 2781 2782 /* Unlock whole block */ 2783 onenand_unlock_all(mtd); 2784 2785 return this->scan_bbt(mtd); 2786 } 2787 2788 /** 2789 * onenand_release - [OneNAND Interface] Free resources held by the OneNAND device 2790 * @param mtd MTD device structure 2791 */ 2792 void onenand_release(struct mtd_info *mtd) 2793 { 2794 } 2795