2 * linux/drivers/mtd/onenand/onenand_base.c
4 * Copyright (C) 2005-2007 Samsung Electronics
5 * Kyungmin Park <kyungmin.park@samsung.com>
8 * Adrian Hunter <ext-adrian.hunter@nokia.com>:
9 * auto-placement support, read-while load support, various fixes
10 * Copyright (C) Nokia Corporation, 2007
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
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.
25 #include <dm/devres.h>
26 #include <linux/bitops.h>
27 #include <linux/compat.h>
28 #include <linux/mtd/mtd.h>
29 #include "linux/mtd/flashchip.h"
30 #include <linux/mtd/onenand.h>
33 #include <linux/errno.h>
36 /* It should access 16-bit instead of 8-bit */
37 static void *memcpy_16(void *dst, const void *src, unsigned int len)
50 * onenand_oob_128 - oob info for Flex-Onenand with 4KB page
51 * For now, we expose only 64 out of 80 ecc bytes
53 static struct nand_ecclayout onenand_oob_128 = {
56 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
57 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
58 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
59 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
60 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
61 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
65 {2, 4}, {18, 4}, {34, 4}, {50, 4},
66 {66, 4}, {82, 4}, {98, 4}, {114, 4}
71 * onenand_oob_64 - oob info for large (2KB) page
73 static struct nand_ecclayout onenand_oob_64 = {
82 {2, 3}, {14, 2}, {18, 3}, {30, 2},
83 {34, 3}, {46, 2}, {50, 3}, {62, 2}
88 * onenand_oob_32 - oob info for middle (1KB) page
90 static struct nand_ecclayout onenand_oob_32 = {
96 .oobfree = { {2, 3}, {14, 2}, {18, 3}, {30, 2} }
100 * Warning! This array is used with the memcpy_16() function, thus
101 * it must be aligned to 2 bytes. GCC can make this array unaligned
102 * as the array is made of unsigned char, which memcpy16() doesn't
103 * like and will cause unaligned access.
105 static const unsigned char __aligned(2) ffchars[] = {
106 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
107 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 16 */
108 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
109 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 32 */
110 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
111 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 48 */
112 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
113 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 64 */
114 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
115 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 80 */
116 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
117 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 96 */
118 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
119 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 112 */
120 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
121 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 128 */
125 * onenand_readw - [OneNAND Interface] Read OneNAND register
126 * @param addr address to read
128 * Read OneNAND register
130 static unsigned short onenand_readw(void __iomem * addr)
136 * onenand_writew - [OneNAND Interface] Write OneNAND register with value
137 * @param value value to write
138 * @param addr address to write
140 * Write OneNAND register with value
142 static void onenand_writew(unsigned short value, void __iomem * addr)
148 * onenand_block_address - [DEFAULT] Get block address
149 * @param device the device id
150 * @param block the block
151 * @return translated block address if DDP, otherwise same
153 * Setup Start Address 1 Register (F100h)
155 static int onenand_block_address(struct onenand_chip *this, int block)
157 /* Device Flash Core select, NAND Flash Block Address */
158 if (block & this->density_mask)
159 return ONENAND_DDP_CHIP1 | (block ^ this->density_mask);
165 * onenand_bufferram_address - [DEFAULT] Get bufferram address
166 * @param device the device id
167 * @param block the block
168 * @return set DBS value if DDP, otherwise 0
170 * Setup Start Address 2 Register (F101h) for DDP
172 static int onenand_bufferram_address(struct onenand_chip *this, int block)
174 /* Device BufferRAM Select */
175 if (block & this->density_mask)
176 return ONENAND_DDP_CHIP1;
178 return ONENAND_DDP_CHIP0;
182 * onenand_page_address - [DEFAULT] Get page address
183 * @param page the page address
184 * @param sector the sector address
185 * @return combined page and sector address
187 * Setup Start Address 8 Register (F107h)
189 static int onenand_page_address(int page, int sector)
191 /* Flash Page Address, Flash Sector Address */
194 fpa = page & ONENAND_FPA_MASK;
195 fsa = sector & ONENAND_FSA_MASK;
197 return ((fpa << ONENAND_FPA_SHIFT) | fsa);
201 * onenand_buffer_address - [DEFAULT] Get buffer address
202 * @param dataram1 DataRAM index
203 * @param sectors the sector address
204 * @param count the number of sectors
205 * @return the start buffer value
207 * Setup Start Buffer Register (F200h)
209 static int onenand_buffer_address(int dataram1, int sectors, int count)
213 /* BufferRAM Sector Address */
214 bsa = sectors & ONENAND_BSA_MASK;
217 bsa |= ONENAND_BSA_DATARAM1; /* DataRAM1 */
219 bsa |= ONENAND_BSA_DATARAM0; /* DataRAM0 */
221 /* BufferRAM Sector Count */
222 bsc = count & ONENAND_BSC_MASK;
224 return ((bsa << ONENAND_BSA_SHIFT) | bsc);
228 * flexonenand_block - Return block number for flash address
229 * @param this - OneNAND device structure
230 * @param addr - Address for which block number is needed
232 static unsigned int flexonenand_block(struct onenand_chip *this, loff_t addr)
234 unsigned int boundary, blk, die = 0;
236 if (ONENAND_IS_DDP(this) && addr >= this->diesize[0]) {
238 addr -= this->diesize[0];
241 boundary = this->boundary[die];
243 blk = addr >> (this->erase_shift - 1);
245 blk = (blk + boundary + 1) >> 1;
247 blk += die ? this->density_mask : 0;
251 unsigned int onenand_block(struct onenand_chip *this, loff_t addr)
253 if (!FLEXONENAND(this))
254 return addr >> this->erase_shift;
255 return flexonenand_block(this, addr);
259 * flexonenand_addr - Return address of the block
260 * @this: OneNAND device structure
261 * @block: Block number on Flex-OneNAND
263 * Return address of the block
265 static loff_t flexonenand_addr(struct onenand_chip *this, int block)
268 int die = 0, boundary;
270 if (ONENAND_IS_DDP(this) && block >= this->density_mask) {
271 block -= this->density_mask;
273 ofs = this->diesize[0];
276 boundary = this->boundary[die];
277 ofs += (loff_t) block << (this->erase_shift - 1);
278 if (block > (boundary + 1))
279 ofs += (loff_t) (block - boundary - 1)
280 << (this->erase_shift - 1);
284 loff_t onenand_addr(struct onenand_chip *this, int block)
286 if (!FLEXONENAND(this))
287 return (loff_t) block << this->erase_shift;
288 return flexonenand_addr(this, block);
292 * flexonenand_region - [Flex-OneNAND] Return erase region of addr
293 * @param mtd MTD device structure
294 * @param addr address whose erase region needs to be identified
296 int flexonenand_region(struct mtd_info *mtd, loff_t addr)
300 for (i = 0; i < mtd->numeraseregions; i++)
301 if (addr < mtd->eraseregions[i].offset)
307 * onenand_get_density - [DEFAULT] Get OneNAND density
308 * @param dev_id OneNAND device ID
310 * Get OneNAND density from device ID
312 static inline int onenand_get_density(int dev_id)
314 int density = dev_id >> ONENAND_DEVICE_DENSITY_SHIFT;
315 return (density & ONENAND_DEVICE_DENSITY_MASK);
319 * onenand_command - [DEFAULT] Send command to OneNAND device
320 * @param mtd MTD device structure
321 * @param cmd the command to be sent
322 * @param addr offset to read from or write to
323 * @param len number of bytes to read or write
325 * Send command to OneNAND device. This function is used for middle/large page
326 * devices (1KB/2KB Bytes per page)
328 static int onenand_command(struct mtd_info *mtd, int cmd, loff_t addr,
331 struct onenand_chip *this = mtd->priv;
335 /* Now we use page size operation */
336 int sectors = 0, count = 0;
338 /* Address translation */
340 case ONENAND_CMD_UNLOCK:
341 case ONENAND_CMD_LOCK:
342 case ONENAND_CMD_LOCK_TIGHT:
343 case ONENAND_CMD_UNLOCK_ALL:
348 case FLEXONENAND_CMD_PI_ACCESS:
349 /* addr contains die index */
350 block = addr * this->density_mask;
354 case ONENAND_CMD_ERASE:
355 case ONENAND_CMD_BUFFERRAM:
356 block = onenand_block(this, addr);
360 case FLEXONENAND_CMD_READ_PI:
361 cmd = ONENAND_CMD_READ;
362 block = addr * this->density_mask;
367 block = onenand_block(this, addr);
369 - onenand_addr(this, block)) >> this->page_shift;
370 page &= this->page_mask;
374 /* NOTE: The setting order of the registers is very important! */
375 if (cmd == ONENAND_CMD_BUFFERRAM) {
376 /* Select DataRAM for DDP */
377 value = onenand_bufferram_address(this, block);
378 this->write_word(value,
379 this->base + ONENAND_REG_START_ADDRESS2);
381 if (ONENAND_IS_4KB_PAGE(this))
382 ONENAND_SET_BUFFERRAM0(this);
384 /* Switch to the next data buffer */
385 ONENAND_SET_NEXT_BUFFERRAM(this);
391 /* Write 'DFS, FBA' of Flash */
392 value = onenand_block_address(this, block);
393 this->write_word(value,
394 this->base + ONENAND_REG_START_ADDRESS1);
396 /* Select DataRAM for DDP */
397 value = onenand_bufferram_address(this, block);
398 this->write_word(value,
399 this->base + ONENAND_REG_START_ADDRESS2);
406 case FLEXONENAND_CMD_RECOVER_LSB:
407 case ONENAND_CMD_READ:
408 case ONENAND_CMD_READOOB:
409 if (ONENAND_IS_4KB_PAGE(this))
410 dataram = ONENAND_SET_BUFFERRAM0(this);
412 dataram = ONENAND_SET_NEXT_BUFFERRAM(this);
417 dataram = ONENAND_CURRENT_BUFFERRAM(this);
421 /* Write 'FPA, FSA' of Flash */
422 value = onenand_page_address(page, sectors);
423 this->write_word(value,
424 this->base + ONENAND_REG_START_ADDRESS8);
426 /* Write 'BSA, BSC' of DataRAM */
427 value = onenand_buffer_address(dataram, sectors, count);
428 this->write_word(value, this->base + ONENAND_REG_START_BUFFER);
431 /* Interrupt clear */
432 this->write_word(ONENAND_INT_CLEAR, this->base + ONENAND_REG_INTERRUPT);
434 this->write_word(cmd, this->base + ONENAND_REG_COMMAND);
440 * onenand_read_ecc - return ecc status
441 * @param this onenand chip structure
443 static int onenand_read_ecc(struct onenand_chip *this)
447 if (!FLEXONENAND(this))
448 return this->read_word(this->base + ONENAND_REG_ECC_STATUS);
450 for (i = 0; i < 4; i++) {
451 ecc = this->read_word(this->base
452 + ((ONENAND_REG_ECC_STATUS + i) << 1));
455 if (ecc & FLEXONENAND_UNCORRECTABLE_ERROR)
456 return ONENAND_ECC_2BIT_ALL;
463 * onenand_wait - [DEFAULT] wait until the command is done
464 * @param mtd MTD device structure
465 * @param state state to select the max. timeout value
467 * Wait for command done. This applies to all OneNAND command
468 * Read can take up to 30us, erase up to 2ms and program up to 350us
469 * according to general OneNAND specs
471 static int onenand_wait(struct mtd_info *mtd, int state)
473 struct onenand_chip *this = mtd->priv;
474 unsigned int interrupt = 0;
477 /* Wait at most 20ms ... */
478 u32 timeo = (CONFIG_SYS_HZ * 20) / 1000;
479 u32 time_start = get_timer(0);
482 if (get_timer(time_start) > timeo)
484 interrupt = this->read_word(this->base + ONENAND_REG_INTERRUPT);
485 } while ((interrupt & ONENAND_INT_MASTER) == 0);
487 ctrl = this->read_word(this->base + ONENAND_REG_CTRL_STATUS);
489 if (interrupt & ONENAND_INT_READ) {
490 int ecc = onenand_read_ecc(this);
491 if (ecc & ONENAND_ECC_2BIT_ALL) {
492 printk("onenand_wait: ECC error = 0x%04x\n", ecc);
497 if (ctrl & ONENAND_CTRL_ERROR) {
498 printk("onenand_wait: controller error = 0x%04x\n", ctrl);
499 if (ctrl & ONENAND_CTRL_LOCK)
500 printk("onenand_wait: it's locked error = 0x%04x\n",
511 * onenand_bufferram_offset - [DEFAULT] BufferRAM offset
512 * @param mtd MTD data structure
513 * @param area BufferRAM area
514 * @return offset given area
516 * Return BufferRAM offset given area
518 static inline int onenand_bufferram_offset(struct mtd_info *mtd, int area)
520 struct onenand_chip *this = mtd->priv;
522 if (ONENAND_CURRENT_BUFFERRAM(this)) {
523 if (area == ONENAND_DATARAM)
524 return mtd->writesize;
525 if (area == ONENAND_SPARERAM)
533 * onenand_read_bufferram - [OneNAND Interface] Read the bufferram area
534 * @param mtd MTD data structure
535 * @param area BufferRAM area
536 * @param buffer the databuffer to put/get data
537 * @param offset offset to read from or write to
538 * @param count number of bytes to read/write
540 * Read the BufferRAM area
542 static int onenand_read_bufferram(struct mtd_info *mtd, loff_t addr, int area,
543 unsigned char *buffer, int offset,
546 struct onenand_chip *this = mtd->priv;
547 void __iomem *bufferram;
549 bufferram = this->base + area;
550 bufferram += onenand_bufferram_offset(mtd, area);
552 memcpy_16(buffer, bufferram + offset, count);
558 * onenand_sync_read_bufferram - [OneNAND Interface] Read the bufferram area with Sync. Burst mode
559 * @param mtd MTD data structure
560 * @param area BufferRAM area
561 * @param buffer the databuffer to put/get data
562 * @param offset offset to read from or write to
563 * @param count number of bytes to read/write
565 * Read the BufferRAM area with Sync. Burst Mode
567 static int onenand_sync_read_bufferram(struct mtd_info *mtd, loff_t addr, int area,
568 unsigned char *buffer, int offset,
571 struct onenand_chip *this = mtd->priv;
572 void __iomem *bufferram;
574 bufferram = this->base + area;
575 bufferram += onenand_bufferram_offset(mtd, area);
577 this->mmcontrol(mtd, ONENAND_SYS_CFG1_SYNC_READ);
579 memcpy_16(buffer, bufferram + offset, count);
581 this->mmcontrol(mtd, 0);
587 * onenand_write_bufferram - [OneNAND Interface] Write the bufferram area
588 * @param mtd MTD data structure
589 * @param area BufferRAM area
590 * @param buffer the databuffer to put/get data
591 * @param offset offset to read from or write to
592 * @param count number of bytes to read/write
594 * Write the BufferRAM area
596 static int onenand_write_bufferram(struct mtd_info *mtd, loff_t addr, int area,
597 const unsigned char *buffer, int offset,
600 struct onenand_chip *this = mtd->priv;
601 void __iomem *bufferram;
603 bufferram = this->base + area;
604 bufferram += onenand_bufferram_offset(mtd, area);
606 memcpy_16(bufferram + offset, buffer, count);
612 * onenand_get_2x_blockpage - [GENERIC] Get blockpage at 2x program mode
613 * @param mtd MTD data structure
614 * @param addr address to check
615 * @return blockpage address
617 * Get blockpage address at 2x program mode
619 static int onenand_get_2x_blockpage(struct mtd_info *mtd, loff_t addr)
621 struct onenand_chip *this = mtd->priv;
622 int blockpage, block, page;
624 /* Calculate the even block number */
625 block = (int) (addr >> this->erase_shift) & ~1;
626 /* Is it the odd plane? */
627 if (addr & this->writesize)
629 page = (int) (addr >> (this->page_shift + 1)) & this->page_mask;
630 blockpage = (block << 7) | page;
636 * onenand_check_bufferram - [GENERIC] Check BufferRAM information
637 * @param mtd MTD data structure
638 * @param addr address to check
639 * @return 1 if there are valid data, otherwise 0
641 * Check bufferram if there is data we required
643 static int onenand_check_bufferram(struct mtd_info *mtd, loff_t addr)
645 struct onenand_chip *this = mtd->priv;
646 int blockpage, found = 0;
649 if (ONENAND_IS_2PLANE(this))
650 blockpage = onenand_get_2x_blockpage(mtd, addr);
652 blockpage = (int) (addr >> this->page_shift);
654 /* Is there valid data? */
655 i = ONENAND_CURRENT_BUFFERRAM(this);
656 if (this->bufferram[i].blockpage == blockpage)
659 /* Check another BufferRAM */
660 i = ONENAND_NEXT_BUFFERRAM(this);
661 if (this->bufferram[i].blockpage == blockpage) {
662 ONENAND_SET_NEXT_BUFFERRAM(this);
667 if (found && ONENAND_IS_DDP(this)) {
668 /* Select DataRAM for DDP */
669 int block = onenand_block(this, addr);
670 int value = onenand_bufferram_address(this, block);
671 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS2);
678 * onenand_update_bufferram - [GENERIC] Update BufferRAM information
679 * @param mtd MTD data structure
680 * @param addr address to update
681 * @param valid valid flag
683 * Update BufferRAM information
685 static int onenand_update_bufferram(struct mtd_info *mtd, loff_t addr,
688 struct onenand_chip *this = mtd->priv;
692 if (ONENAND_IS_2PLANE(this))
693 blockpage = onenand_get_2x_blockpage(mtd, addr);
695 blockpage = (int)(addr >> this->page_shift);
697 /* Invalidate another BufferRAM */
698 i = ONENAND_NEXT_BUFFERRAM(this);
699 if (this->bufferram[i].blockpage == blockpage)
700 this->bufferram[i].blockpage = -1;
702 /* Update BufferRAM */
703 i = ONENAND_CURRENT_BUFFERRAM(this);
705 this->bufferram[i].blockpage = blockpage;
707 this->bufferram[i].blockpage = -1;
713 * onenand_invalidate_bufferram - [GENERIC] Invalidate BufferRAM information
714 * @param mtd MTD data structure
715 * @param addr start address to invalidate
716 * @param len length to invalidate
718 * Invalidate BufferRAM information
720 static void onenand_invalidate_bufferram(struct mtd_info *mtd, loff_t addr,
723 struct onenand_chip *this = mtd->priv;
725 loff_t end_addr = addr + len;
727 /* Invalidate BufferRAM */
728 for (i = 0; i < MAX_BUFFERRAM; i++) {
729 loff_t buf_addr = this->bufferram[i].blockpage << this->page_shift;
731 if (buf_addr >= addr && buf_addr < end_addr)
732 this->bufferram[i].blockpage = -1;
737 * onenand_get_device - [GENERIC] Get chip for selected access
738 * @param mtd MTD device structure
739 * @param new_state the state which is requested
741 * Get the device and lock it for exclusive access
743 static void onenand_get_device(struct mtd_info *mtd, int new_state)
749 * onenand_release_device - [GENERIC] release chip
750 * @param mtd MTD device structure
752 * Deselect, release chip lock and wake up anyone waiting on the device
754 static void onenand_release_device(struct mtd_info *mtd)
760 * onenand_transfer_auto_oob - [INTERN] oob auto-placement transfer
761 * @param mtd MTD device structure
762 * @param buf destination address
763 * @param column oob offset to read from
764 * @param thislen oob length to read
766 static int onenand_transfer_auto_oob(struct mtd_info *mtd, uint8_t *buf,
767 int column, int thislen)
769 struct onenand_chip *this = mtd->priv;
770 struct nand_oobfree *free;
771 int readcol = column;
772 int readend = column + thislen;
775 uint8_t *oob_buf = this->oob_buf;
777 free = this->ecclayout->oobfree;
778 for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES_LARGE && free->length;
780 if (readcol >= lastgap)
781 readcol += free->offset - lastgap;
782 if (readend >= lastgap)
783 readend += free->offset - lastgap;
784 lastgap = free->offset + free->length;
786 this->read_bufferram(mtd, 0, ONENAND_SPARERAM, oob_buf, 0, mtd->oobsize);
787 free = this->ecclayout->oobfree;
788 for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES_LARGE && free->length;
790 int free_end = free->offset + free->length;
791 if (free->offset < readend && free_end > readcol) {
792 int st = max_t(int,free->offset,readcol);
793 int ed = min_t(int,free_end,readend);
795 memcpy(buf, oob_buf + st, n);
797 } else if (column == 0)
804 * onenand_recover_lsb - [Flex-OneNAND] Recover LSB page data
805 * @param mtd MTD device structure
806 * @param addr address to recover
807 * @param status return value from onenand_wait
809 * MLC NAND Flash cell has paired pages - LSB page and MSB page. LSB page has
810 * lower page address and MSB page has higher page address in paired pages.
811 * If power off occurs during MSB page program, the paired LSB page data can
812 * become corrupt. LSB page recovery read is a way to read LSB page though page
813 * data are corrupted. When uncorrectable error occurs as a result of LSB page
814 * read after power up, issue LSB page recovery read.
816 static int onenand_recover_lsb(struct mtd_info *mtd, loff_t addr, int status)
818 struct onenand_chip *this = mtd->priv;
821 /* Recovery is only for Flex-OneNAND */
822 if (!FLEXONENAND(this))
825 /* check if we failed due to uncorrectable error */
826 if (!mtd_is_eccerr(status) && status != ONENAND_BBT_READ_ECC_ERROR)
829 /* check if address lies in MLC region */
830 i = flexonenand_region(mtd, addr);
831 if (mtd->eraseregions[i].erasesize < (1 << this->erase_shift))
834 printk("onenand_recover_lsb:"
835 "Attempting to recover from uncorrectable read\n");
837 /* Issue the LSB page recovery command */
838 this->command(mtd, FLEXONENAND_CMD_RECOVER_LSB, addr, this->writesize);
839 return this->wait(mtd, FL_READING);
843 * onenand_read_ops_nolock - [OneNAND Interface] OneNAND read main and/or out-of-band
844 * @param mtd MTD device structure
845 * @param from offset to read from
846 * @param ops oob operation description structure
848 * OneNAND read main and/or out-of-band data
850 static int onenand_read_ops_nolock(struct mtd_info *mtd, loff_t from,
851 struct mtd_oob_ops *ops)
853 struct onenand_chip *this = mtd->priv;
854 struct mtd_ecc_stats stats;
855 size_t len = ops->len;
856 size_t ooblen = ops->ooblen;
857 u_char *buf = ops->datbuf;
858 u_char *oobbuf = ops->oobbuf;
859 int read = 0, column, thislen;
860 int oobread = 0, oobcolumn, thisooblen, oobsize;
861 int ret = 0, boundary = 0;
862 int writesize = this->writesize;
864 pr_debug("onenand_read_ops_nolock: from = 0x%08x, len = %i\n",
865 (unsigned int) from, (int) len);
867 if (ops->mode == MTD_OPS_AUTO_OOB)
868 oobsize = this->ecclayout->oobavail;
870 oobsize = mtd->oobsize;
872 oobcolumn = from & (mtd->oobsize - 1);
874 /* Do not allow reads past end of device */
875 if ((from + len) > mtd->size) {
876 printk(KERN_ERR "onenand_read_ops_nolock: Attempt read beyond end of device\n");
882 stats = mtd->ecc_stats;
884 /* Read-while-load method */
885 /* Note: We can't use this feature in MLC */
887 /* Do first load to bufferRAM */
889 if (!onenand_check_bufferram(mtd, from)) {
890 this->main_buf = buf;
891 this->command(mtd, ONENAND_CMD_READ, from, writesize);
892 ret = this->wait(mtd, FL_READING);
894 ret = onenand_recover_lsb(mtd, from, ret);
895 onenand_update_bufferram(mtd, from, !ret);
901 thislen = min_t(int, writesize, len - read);
902 column = from & (writesize - 1);
903 if (column + thislen > writesize)
904 thislen = writesize - column;
907 /* If there is more to load then start next load */
909 if (!ONENAND_IS_4KB_PAGE(this) && read + thislen < len) {
910 this->main_buf = buf + thislen;
911 this->command(mtd, ONENAND_CMD_READ, from, writesize);
913 * Chip boundary handling in DDP
914 * Now we issued chip 1 read and pointed chip 1
915 * bufferam so we have to point chip 0 bufferam.
917 if (ONENAND_IS_DDP(this) &&
918 unlikely(from == (this->chipsize >> 1))) {
919 this->write_word(ONENAND_DDP_CHIP0, this->base + ONENAND_REG_START_ADDRESS2);
923 ONENAND_SET_PREV_BUFFERRAM(this);
926 /* While load is going, read from last bufferRAM */
927 this->read_bufferram(mtd, from - thislen, ONENAND_DATARAM, buf, column, thislen);
929 /* Read oob area if needed */
931 thisooblen = oobsize - oobcolumn;
932 thisooblen = min_t(int, thisooblen, ooblen - oobread);
934 if (ops->mode == MTD_OPS_AUTO_OOB)
935 onenand_transfer_auto_oob(mtd, oobbuf, oobcolumn, thisooblen);
937 this->read_bufferram(mtd, 0, ONENAND_SPARERAM, oobbuf, oobcolumn, thisooblen);
938 oobread += thisooblen;
939 oobbuf += thisooblen;
943 if (ONENAND_IS_4KB_PAGE(this) && (read + thislen < len)) {
944 this->command(mtd, ONENAND_CMD_READ, from, writesize);
945 ret = this->wait(mtd, FL_READING);
947 ret = onenand_recover_lsb(mtd, from, ret);
948 onenand_update_bufferram(mtd, from, !ret);
949 if (mtd_is_eccerr(ret))
953 /* See if we are done */
957 /* Set up for next read from bufferRAM */
958 if (unlikely(boundary))
959 this->write_word(ONENAND_DDP_CHIP1, this->base + ONENAND_REG_START_ADDRESS2);
960 if (!ONENAND_IS_4KB_PAGE(this))
961 ONENAND_SET_NEXT_BUFFERRAM(this);
963 thislen = min_t(int, writesize, len - read);
966 if (!ONENAND_IS_4KB_PAGE(this)) {
967 /* Now wait for load */
968 ret = this->wait(mtd, FL_READING);
969 onenand_update_bufferram(mtd, from, !ret);
970 if (mtd_is_eccerr(ret))
976 * Return success, if no ECC failures, else -EBADMSG
977 * fs driver will take care of that, because
978 * retlen == desired len and result == -EBADMSG
981 ops->oobretlen = oobread;
986 if (mtd->ecc_stats.failed - stats.failed)
989 /* return max bitflips per ecc step; ONENANDs correct 1 bit only */
990 return mtd->ecc_stats.corrected != stats.corrected ? 1 : 0;
994 * onenand_read_oob_nolock - [MTD Interface] OneNAND read out-of-band
995 * @param mtd MTD device structure
996 * @param from offset to read from
997 * @param ops oob operation description structure
999 * OneNAND read out-of-band data from the spare area
1001 static int onenand_read_oob_nolock(struct mtd_info *mtd, loff_t from,
1002 struct mtd_oob_ops *ops)
1004 struct onenand_chip *this = mtd->priv;
1005 struct mtd_ecc_stats stats;
1006 int read = 0, thislen, column, oobsize;
1007 size_t len = ops->ooblen;
1008 unsigned int mode = ops->mode;
1009 u_char *buf = ops->oobbuf;
1010 int ret = 0, readcmd;
1012 from += ops->ooboffs;
1014 pr_debug("onenand_read_oob_nolock: from = 0x%08x, len = %i\n",
1015 (unsigned int) from, (int) len);
1017 /* Initialize return length value */
1020 if (mode == MTD_OPS_AUTO_OOB)
1021 oobsize = this->ecclayout->oobavail;
1023 oobsize = mtd->oobsize;
1025 column = from & (mtd->oobsize - 1);
1027 if (unlikely(column >= oobsize)) {
1028 printk(KERN_ERR "onenand_read_oob_nolock: Attempted to start read outside oob\n");
1032 /* Do not allow reads past end of device */
1033 if (unlikely(from >= mtd->size ||
1034 column + len > ((mtd->size >> this->page_shift) -
1035 (from >> this->page_shift)) * oobsize)) {
1036 printk(KERN_ERR "onenand_read_oob_nolock: Attempted to read beyond end of device\n");
1040 stats = mtd->ecc_stats;
1042 readcmd = ONENAND_IS_4KB_PAGE(this) ?
1043 ONENAND_CMD_READ : ONENAND_CMD_READOOB;
1045 while (read < len) {
1046 thislen = oobsize - column;
1047 thislen = min_t(int, thislen, len);
1049 this->spare_buf = buf;
1050 this->command(mtd, readcmd, from, mtd->oobsize);
1052 onenand_update_bufferram(mtd, from, 0);
1054 ret = this->wait(mtd, FL_READING);
1056 ret = onenand_recover_lsb(mtd, from, ret);
1058 if (ret && ret != -EBADMSG) {
1059 printk(KERN_ERR "onenand_read_oob_nolock: read failed = 0x%x\n", ret);
1063 if (mode == MTD_OPS_AUTO_OOB)
1064 onenand_transfer_auto_oob(mtd, buf, column, thislen);
1066 this->read_bufferram(mtd, 0, ONENAND_SPARERAM, buf, column, thislen);
1078 from += mtd->writesize;
1083 ops->oobretlen = read;
1088 if (mtd->ecc_stats.failed - stats.failed)
1095 * onenand_read - [MTD Interface] MTD compability function for onenand_read_ecc
1096 * @param mtd MTD device structure
1097 * @param from offset to read from
1098 * @param len number of bytes to read
1099 * @param retlen pointer to variable to store the number of read bytes
1100 * @param buf the databuffer to put data
1102 * This function simply calls onenand_read_ecc with oob buffer and oobsel = NULL
1104 int onenand_read(struct mtd_info *mtd, loff_t from, size_t len,
1105 size_t * retlen, u_char * buf)
1107 struct mtd_oob_ops ops = {
1115 onenand_get_device(mtd, FL_READING);
1116 ret = onenand_read_ops_nolock(mtd, from, &ops);
1117 onenand_release_device(mtd);
1119 *retlen = ops.retlen;
1124 * onenand_read_oob - [MTD Interface] OneNAND read out-of-band
1125 * @param mtd MTD device structure
1126 * @param from offset to read from
1127 * @param ops oob operations description structure
1129 * OneNAND main and/or out-of-band
1131 int onenand_read_oob(struct mtd_info *mtd, loff_t from,
1132 struct mtd_oob_ops *ops)
1136 switch (ops->mode) {
1137 case MTD_OPS_PLACE_OOB:
1138 case MTD_OPS_AUTO_OOB:
1141 /* Not implemented yet */
1146 onenand_get_device(mtd, FL_READING);
1148 ret = onenand_read_ops_nolock(mtd, from, ops);
1150 ret = onenand_read_oob_nolock(mtd, from, ops);
1151 onenand_release_device(mtd);
1157 * onenand_bbt_wait - [DEFAULT] wait until the command is done
1158 * @param mtd MTD device structure
1159 * @param state state to select the max. timeout value
1161 * Wait for command done.
1163 static int onenand_bbt_wait(struct mtd_info *mtd, int state)
1165 struct onenand_chip *this = mtd->priv;
1166 unsigned int interrupt;
1169 /* Wait at most 20ms ... */
1170 u32 timeo = (CONFIG_SYS_HZ * 20) / 1000;
1171 u32 time_start = get_timer(0);
1174 if (get_timer(time_start) > timeo)
1175 return ONENAND_BBT_READ_FATAL_ERROR;
1176 interrupt = this->read_word(this->base + ONENAND_REG_INTERRUPT);
1177 } while ((interrupt & ONENAND_INT_MASTER) == 0);
1179 /* To get correct interrupt status in timeout case */
1180 interrupt = this->read_word(this->base + ONENAND_REG_INTERRUPT);
1181 ctrl = this->read_word(this->base + ONENAND_REG_CTRL_STATUS);
1183 if (interrupt & ONENAND_INT_READ) {
1184 int ecc = onenand_read_ecc(this);
1185 if (ecc & ONENAND_ECC_2BIT_ALL) {
1186 printk(KERN_INFO "onenand_bbt_wait: ecc error = 0x%04x"
1187 ", controller = 0x%04x\n", ecc, ctrl);
1188 return ONENAND_BBT_READ_ERROR;
1191 printk(KERN_ERR "onenand_bbt_wait: read timeout!"
1192 "ctrl=0x%04x intr=0x%04x\n", ctrl, interrupt);
1193 return ONENAND_BBT_READ_FATAL_ERROR;
1196 /* Initial bad block case: 0x2400 or 0x0400 */
1197 if (ctrl & ONENAND_CTRL_ERROR) {
1198 printk(KERN_DEBUG "onenand_bbt_wait: controller error = 0x%04x\n", ctrl);
1199 return ONENAND_BBT_READ_ERROR;
1206 * onenand_bbt_read_oob - [MTD Interface] OneNAND read out-of-band for bbt scan
1207 * @param mtd MTD device structure
1208 * @param from offset to read from
1209 * @param ops oob operation description structure
1211 * OneNAND read out-of-band data from the spare area for bbt scan
1213 int onenand_bbt_read_oob(struct mtd_info *mtd, loff_t from,
1214 struct mtd_oob_ops *ops)
1216 struct onenand_chip *this = mtd->priv;
1217 int read = 0, thislen, column;
1218 int ret = 0, readcmd;
1219 size_t len = ops->ooblen;
1220 u_char *buf = ops->oobbuf;
1222 pr_debug("onenand_bbt_read_oob: from = 0x%08x, len = %zi\n",
1223 (unsigned int) from, len);
1225 readcmd = ONENAND_IS_4KB_PAGE(this) ?
1226 ONENAND_CMD_READ : ONENAND_CMD_READOOB;
1228 /* Initialize return value */
1231 /* Do not allow reads past end of device */
1232 if (unlikely((from + len) > mtd->size)) {
1233 printk(KERN_ERR "onenand_bbt_read_oob: Attempt read beyond end of device\n");
1234 return ONENAND_BBT_READ_FATAL_ERROR;
1237 /* Grab the lock and see if the device is available */
1238 onenand_get_device(mtd, FL_READING);
1240 column = from & (mtd->oobsize - 1);
1242 while (read < len) {
1244 thislen = mtd->oobsize - column;
1245 thislen = min_t(int, thislen, len);
1247 this->spare_buf = buf;
1248 this->command(mtd, readcmd, from, mtd->oobsize);
1250 onenand_update_bufferram(mtd, from, 0);
1252 ret = this->bbt_wait(mtd, FL_READING);
1254 ret = onenand_recover_lsb(mtd, from, ret);
1259 this->read_bufferram(mtd, 0, ONENAND_SPARERAM, buf, column, thislen);
1268 /* Update Page size */
1269 from += this->writesize;
1274 /* Deselect and wake up anyone waiting on the device */
1275 onenand_release_device(mtd);
1277 ops->oobretlen = read;
1282 #ifdef CONFIG_MTD_ONENAND_VERIFY_WRITE
1284 * onenand_verify_oob - [GENERIC] verify the oob contents after a write
1285 * @param mtd MTD device structure
1286 * @param buf the databuffer to verify
1287 * @param to offset to read from
1289 static int onenand_verify_oob(struct mtd_info *mtd, const u_char *buf, loff_t to)
1291 struct onenand_chip *this = mtd->priv;
1292 u_char *oob_buf = this->oob_buf;
1293 int status, i, readcmd;
1295 readcmd = ONENAND_IS_4KB_PAGE(this) ?
1296 ONENAND_CMD_READ : ONENAND_CMD_READOOB;
1298 this->command(mtd, readcmd, to, mtd->oobsize);
1299 onenand_update_bufferram(mtd, to, 0);
1300 status = this->wait(mtd, FL_READING);
1304 this->read_bufferram(mtd, 0, ONENAND_SPARERAM, oob_buf, 0, mtd->oobsize);
1305 for (i = 0; i < mtd->oobsize; i++)
1306 if (buf[i] != 0xFF && buf[i] != oob_buf[i])
1313 * onenand_verify - [GENERIC] verify the chip contents after a write
1314 * @param mtd MTD device structure
1315 * @param buf the databuffer to verify
1316 * @param addr offset to read from
1317 * @param len number of bytes to read and compare
1319 static int onenand_verify(struct mtd_info *mtd, const u_char *buf, loff_t addr, size_t len)
1321 struct onenand_chip *this = mtd->priv;
1322 void __iomem *dataram;
1324 int thislen, column;
1327 thislen = min_t(int, this->writesize, len);
1328 column = addr & (this->writesize - 1);
1329 if (column + thislen > this->writesize)
1330 thislen = this->writesize - column;
1332 this->command(mtd, ONENAND_CMD_READ, addr, this->writesize);
1334 onenand_update_bufferram(mtd, addr, 0);
1336 ret = this->wait(mtd, FL_READING);
1340 onenand_update_bufferram(mtd, addr, 1);
1342 dataram = this->base + ONENAND_DATARAM;
1343 dataram += onenand_bufferram_offset(mtd, ONENAND_DATARAM);
1345 if (memcmp(buf, dataram + column, thislen))
1356 #define onenand_verify(...) (0)
1357 #define onenand_verify_oob(...) (0)
1360 #define NOTALIGNED(x) ((x & (this->subpagesize - 1)) != 0)
1363 * onenand_fill_auto_oob - [INTERN] oob auto-placement transfer
1364 * @param mtd MTD device structure
1365 * @param oob_buf oob buffer
1366 * @param buf source address
1367 * @param column oob offset to write to
1368 * @param thislen oob length to write
1370 static int onenand_fill_auto_oob(struct mtd_info *mtd, u_char *oob_buf,
1371 const u_char *buf, int column, int thislen)
1373 struct onenand_chip *this = mtd->priv;
1374 struct nand_oobfree *free;
1375 int writecol = column;
1376 int writeend = column + thislen;
1380 free = this->ecclayout->oobfree;
1381 for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES_LARGE && free->length;
1383 if (writecol >= lastgap)
1384 writecol += free->offset - lastgap;
1385 if (writeend >= lastgap)
1386 writeend += free->offset - lastgap;
1387 lastgap = free->offset + free->length;
1389 free = this->ecclayout->oobfree;
1390 for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES_LARGE && free->length;
1392 int free_end = free->offset + free->length;
1393 if (free->offset < writeend && free_end > writecol) {
1394 int st = max_t(int,free->offset,writecol);
1395 int ed = min_t(int,free_end,writeend);
1397 memcpy(oob_buf + st, buf, n);
1399 } else if (column == 0)
1406 * onenand_write_ops_nolock - [OneNAND Interface] write main and/or out-of-band
1407 * @param mtd MTD device structure
1408 * @param to offset to write to
1409 * @param ops oob operation description structure
1411 * Write main and/or oob with ECC
1413 static int onenand_write_ops_nolock(struct mtd_info *mtd, loff_t to,
1414 struct mtd_oob_ops *ops)
1416 struct onenand_chip *this = mtd->priv;
1417 int written = 0, column, thislen, subpage;
1418 int oobwritten = 0, oobcolumn, thisooblen, oobsize;
1419 size_t len = ops->len;
1420 size_t ooblen = ops->ooblen;
1421 const u_char *buf = ops->datbuf;
1422 const u_char *oob = ops->oobbuf;
1426 pr_debug("onenand_write_ops_nolock: to = 0x%08x, len = %i\n",
1427 (unsigned int) to, (int) len);
1429 /* Initialize retlen, in case of early exit */
1433 /* Reject writes, which are not page aligned */
1434 if (unlikely(NOTALIGNED(to) || NOTALIGNED(len))) {
1435 printk(KERN_ERR "onenand_write_ops_nolock: Attempt to write not page aligned data\n");
1439 if (ops->mode == MTD_OPS_AUTO_OOB)
1440 oobsize = this->ecclayout->oobavail;
1442 oobsize = mtd->oobsize;
1444 oobcolumn = to & (mtd->oobsize - 1);
1446 column = to & (mtd->writesize - 1);
1448 /* Loop until all data write */
1449 while (written < len) {
1450 u_char *wbuf = (u_char *) buf;
1452 thislen = min_t(int, mtd->writesize - column, len - written);
1453 thisooblen = min_t(int, oobsize - oobcolumn, ooblen - oobwritten);
1455 this->command(mtd, ONENAND_CMD_BUFFERRAM, to, thislen);
1457 /* Partial page write */
1458 subpage = thislen < mtd->writesize;
1460 memset(this->page_buf, 0xff, mtd->writesize);
1461 memcpy(this->page_buf + column, buf, thislen);
1462 wbuf = this->page_buf;
1465 this->write_bufferram(mtd, to, ONENAND_DATARAM, wbuf, 0, mtd->writesize);
1468 oobbuf = this->oob_buf;
1470 /* We send data to spare ram with oobsize
1471 * * to prevent byte access */
1472 memset(oobbuf, 0xff, mtd->oobsize);
1473 if (ops->mode == MTD_OPS_AUTO_OOB)
1474 onenand_fill_auto_oob(mtd, oobbuf, oob, oobcolumn, thisooblen);
1476 memcpy(oobbuf + oobcolumn, oob, thisooblen);
1478 oobwritten += thisooblen;
1482 oobbuf = (u_char *) ffchars;
1484 this->write_bufferram(mtd, 0, ONENAND_SPARERAM, oobbuf, 0, mtd->oobsize);
1486 this->command(mtd, ONENAND_CMD_PROG, to, mtd->writesize);
1488 ret = this->wait(mtd, FL_WRITING);
1490 /* In partial page write we don't update bufferram */
1491 onenand_update_bufferram(mtd, to, !ret && !subpage);
1492 if (ONENAND_IS_2PLANE(this)) {
1493 ONENAND_SET_BUFFERRAM1(this);
1494 onenand_update_bufferram(mtd, to + this->writesize, !ret && !subpage);
1498 printk(KERN_ERR "onenand_write_ops_nolock: write filaed %d\n", ret);
1502 /* Only check verify write turn on */
1503 ret = onenand_verify(mtd, buf, to, thislen);
1505 printk(KERN_ERR "onenand_write_ops_nolock: verify failed %d\n", ret);
1519 ops->retlen = written;
1525 * onenand_write_oob_nolock - [INTERN] OneNAND write out-of-band
1526 * @param mtd MTD device structure
1527 * @param to offset to write to
1528 * @param len number of bytes to write
1529 * @param retlen pointer to variable to store the number of written bytes
1530 * @param buf the data to write
1531 * @param mode operation mode
1533 * OneNAND write out-of-band
1535 static int onenand_write_oob_nolock(struct mtd_info *mtd, loff_t to,
1536 struct mtd_oob_ops *ops)
1538 struct onenand_chip *this = mtd->priv;
1539 int column, ret = 0, oobsize;
1540 int written = 0, oobcmd;
1542 size_t len = ops->ooblen;
1543 const u_char *buf = ops->oobbuf;
1544 unsigned int mode = ops->mode;
1548 pr_debug("onenand_write_oob_nolock: to = 0x%08x, len = %i\n",
1549 (unsigned int) to, (int) len);
1551 /* Initialize retlen, in case of early exit */
1554 if (mode == MTD_OPS_AUTO_OOB)
1555 oobsize = this->ecclayout->oobavail;
1557 oobsize = mtd->oobsize;
1559 column = to & (mtd->oobsize - 1);
1561 if (unlikely(column >= oobsize)) {
1562 printk(KERN_ERR "onenand_write_oob_nolock: Attempted to start write outside oob\n");
1566 /* For compatibility with NAND: Do not allow write past end of page */
1567 if (unlikely(column + len > oobsize)) {
1568 printk(KERN_ERR "onenand_write_oob_nolock: "
1569 "Attempt to write past end of page\n");
1573 /* Do not allow reads past end of device */
1574 if (unlikely(to >= mtd->size ||
1575 column + len > ((mtd->size >> this->page_shift) -
1576 (to >> this->page_shift)) * oobsize)) {
1577 printk(KERN_ERR "onenand_write_oob_nolock: Attempted to write past end of device\n");
1581 oobbuf = this->oob_buf;
1583 oobcmd = ONENAND_IS_4KB_PAGE(this) ?
1584 ONENAND_CMD_PROG : ONENAND_CMD_PROGOOB;
1586 /* Loop until all data write */
1587 while (written < len) {
1588 int thislen = min_t(int, oobsize, len - written);
1590 this->command(mtd, ONENAND_CMD_BUFFERRAM, to, mtd->oobsize);
1592 /* We send data to spare ram with oobsize
1593 * to prevent byte access */
1594 memset(oobbuf, 0xff, mtd->oobsize);
1595 if (mode == MTD_OPS_AUTO_OOB)
1596 onenand_fill_auto_oob(mtd, oobbuf, buf, column, thislen);
1598 memcpy(oobbuf + column, buf, thislen);
1599 this->write_bufferram(mtd, 0, ONENAND_SPARERAM, oobbuf, 0, mtd->oobsize);
1601 if (ONENAND_IS_4KB_PAGE(this)) {
1602 /* Set main area of DataRAM to 0xff*/
1603 memset(this->page_buf, 0xff, mtd->writesize);
1604 this->write_bufferram(mtd, 0, ONENAND_DATARAM,
1605 this->page_buf, 0, mtd->writesize);
1608 this->command(mtd, oobcmd, to, mtd->oobsize);
1610 onenand_update_bufferram(mtd, to, 0);
1611 if (ONENAND_IS_2PLANE(this)) {
1612 ONENAND_SET_BUFFERRAM1(this);
1613 onenand_update_bufferram(mtd, to + this->writesize, 0);
1616 ret = this->wait(mtd, FL_WRITING);
1618 printk(KERN_ERR "onenand_write_oob_nolock: write failed %d\n", ret);
1622 ret = onenand_verify_oob(mtd, oobbuf, to);
1624 printk(KERN_ERR "onenand_write_oob_nolock: verify failed %d\n", ret);
1632 to += mtd->writesize;
1637 ops->oobretlen = written;
1643 * onenand_write - [MTD Interface] compability function for onenand_write_ecc
1644 * @param mtd MTD device structure
1645 * @param to offset to write to
1646 * @param len number of bytes to write
1647 * @param retlen pointer to variable to store the number of written bytes
1648 * @param buf the data to write
1652 int onenand_write(struct mtd_info *mtd, loff_t to, size_t len,
1653 size_t * retlen, const u_char * buf)
1655 struct mtd_oob_ops ops = {
1658 .datbuf = (u_char *) buf,
1663 onenand_get_device(mtd, FL_WRITING);
1664 ret = onenand_write_ops_nolock(mtd, to, &ops);
1665 onenand_release_device(mtd);
1667 *retlen = ops.retlen;
1672 * onenand_write_oob - [MTD Interface] OneNAND write out-of-band
1673 * @param mtd MTD device structure
1674 * @param to offset to write to
1675 * @param ops oob operation description structure
1677 * OneNAND write main and/or out-of-band
1679 int onenand_write_oob(struct mtd_info *mtd, loff_t to,
1680 struct mtd_oob_ops *ops)
1684 switch (ops->mode) {
1685 case MTD_OPS_PLACE_OOB:
1686 case MTD_OPS_AUTO_OOB:
1689 /* Not implemented yet */
1694 onenand_get_device(mtd, FL_WRITING);
1696 ret = onenand_write_ops_nolock(mtd, to, ops);
1698 ret = onenand_write_oob_nolock(mtd, to, ops);
1699 onenand_release_device(mtd);
1706 * onenand_block_isbad_nolock - [GENERIC] Check if a block is marked bad
1707 * @param mtd MTD device structure
1708 * @param ofs offset from device start
1709 * @param allowbbt 1, if its allowed to access the bbt area
1711 * Check, if the block is bad, Either by reading the bad block table or
1712 * calling of the scan function.
1714 static int onenand_block_isbad_nolock(struct mtd_info *mtd, loff_t ofs, int allowbbt)
1716 struct onenand_chip *this = mtd->priv;
1717 struct bbm_info *bbm = this->bbm;
1719 /* Return info from the table */
1720 return bbm->isbad_bbt(mtd, ofs, allowbbt);
1725 * onenand_erase - [MTD Interface] erase block(s)
1726 * @param mtd MTD device structure
1727 * @param instr erase instruction
1729 * Erase one ore more blocks
1731 int onenand_erase(struct mtd_info *mtd, struct erase_info *instr)
1733 struct onenand_chip *this = mtd->priv;
1734 unsigned int block_size;
1735 loff_t addr = instr->addr;
1736 unsigned int len = instr->len;
1738 struct mtd_erase_region_info *region = NULL;
1739 unsigned int region_end = 0;
1741 pr_debug("onenand_erase: start = 0x%08x, len = %i\n",
1742 (unsigned int) addr, len);
1744 if (FLEXONENAND(this)) {
1745 /* Find the eraseregion of this address */
1746 i = flexonenand_region(mtd, addr);
1747 region = &mtd->eraseregions[i];
1749 block_size = region->erasesize;
1750 region_end = region->offset
1751 + region->erasesize * region->numblocks;
1753 /* Start address within region must align on block boundary.
1754 * Erase region's start offset is always block start address.
1756 if (unlikely((addr - region->offset) & (block_size - 1))) {
1757 pr_debug("onenand_erase:" " Unaligned address\n");
1761 block_size = 1 << this->erase_shift;
1763 /* Start address must align on block boundary */
1764 if (unlikely(addr & (block_size - 1))) {
1765 pr_debug("onenand_erase:" "Unaligned address\n");
1770 /* Length must align on block boundary */
1771 if (unlikely(len & (block_size - 1))) {
1772 pr_debug("onenand_erase: Length not block aligned\n");
1776 /* Grab the lock and see if the device is available */
1777 onenand_get_device(mtd, FL_ERASING);
1779 /* Loop throught the pages */
1780 instr->state = MTD_ERASING;
1784 /* Check if we have a bad block, we do not erase bad blocks */
1785 if (instr->priv == 0 && onenand_block_isbad_nolock(mtd, addr, 0)) {
1786 printk(KERN_WARNING "onenand_erase: attempt to erase"
1787 " a bad block at addr 0x%08x\n",
1788 (unsigned int) addr);
1789 instr->state = MTD_ERASE_FAILED;
1793 this->command(mtd, ONENAND_CMD_ERASE, addr, block_size);
1795 onenand_invalidate_bufferram(mtd, addr, block_size);
1797 ret = this->wait(mtd, FL_ERASING);
1798 /* Check, if it is write protected */
1801 pr_debug("onenand_erase: "
1802 "Device is write protected!!!\n");
1804 pr_debug("onenand_erase: "
1805 "Failed erase, block %d\n",
1806 onenand_block(this, addr));
1807 instr->state = MTD_ERASE_FAILED;
1808 instr->fail_addr = addr;
1816 if (addr == region_end) {
1821 block_size = region->erasesize;
1822 region_end = region->offset
1823 + region->erasesize * region->numblocks;
1825 if (len & (block_size - 1)) {
1826 /* This has been checked at MTD
1827 * partitioning level. */
1828 printk("onenand_erase: Unaligned address\n");
1834 instr->state = MTD_ERASE_DONE;
1838 ret = instr->state == MTD_ERASE_DONE ? 0 : -EIO;
1839 /* Do call back function */
1841 mtd_erase_callback(instr);
1843 /* Deselect and wake up anyone waiting on the device */
1844 onenand_release_device(mtd);
1850 * onenand_sync - [MTD Interface] sync
1851 * @param mtd MTD device structure
1853 * Sync is actually a wait for chip ready function
1855 void onenand_sync(struct mtd_info *mtd)
1857 pr_debug("onenand_sync: called\n");
1859 /* Grab the lock and see if the device is available */
1860 onenand_get_device(mtd, FL_SYNCING);
1862 /* Release it and go back */
1863 onenand_release_device(mtd);
1867 * onenand_block_isbad - [MTD Interface] Check whether the block at the given offset is bad
1868 * @param mtd MTD device structure
1869 * @param ofs offset relative to mtd start
1871 * Check whether the block is bad
1873 int onenand_block_isbad(struct mtd_info *mtd, loff_t ofs)
1877 /* Check for invalid offset */
1878 if (ofs > mtd->size)
1881 onenand_get_device(mtd, FL_READING);
1882 ret = onenand_block_isbad_nolock(mtd,ofs, 0);
1883 onenand_release_device(mtd);
1888 * onenand_default_block_markbad - [DEFAULT] mark a block bad
1889 * @param mtd MTD device structure
1890 * @param ofs offset from device start
1892 * This is the default implementation, which can be overridden by
1893 * a hardware specific driver.
1895 static int onenand_default_block_markbad(struct mtd_info *mtd, loff_t ofs)
1897 struct onenand_chip *this = mtd->priv;
1898 struct bbm_info *bbm = this->bbm;
1899 u_char buf[2] = {0, 0};
1900 struct mtd_oob_ops ops = {
1901 .mode = MTD_OPS_PLACE_OOB,
1908 /* Get block number */
1909 block = onenand_block(this, ofs);
1911 bbm->bbt[block >> 2] |= 0x01 << ((block & 0x03) << 1);
1913 /* We write two bytes, so we dont have to mess with 16 bit access */
1914 ofs += mtd->oobsize + (bbm->badblockpos & ~0x01);
1915 return onenand_write_oob_nolock(mtd, ofs, &ops);
1919 * onenand_block_markbad - [MTD Interface] Mark the block at the given offset as bad
1920 * @param mtd MTD device structure
1921 * @param ofs offset relative to mtd start
1923 * Mark the block as bad
1925 int onenand_block_markbad(struct mtd_info *mtd, loff_t ofs)
1927 struct onenand_chip *this = mtd->priv;
1930 ret = onenand_block_isbad(mtd, ofs);
1932 /* If it was bad already, return success and do nothing */
1938 onenand_get_device(mtd, FL_WRITING);
1939 ret = this->block_markbad(mtd, ofs);
1940 onenand_release_device(mtd);
1946 * onenand_do_lock_cmd - [OneNAND Interface] Lock or unlock block(s)
1947 * @param mtd MTD device structure
1948 * @param ofs offset relative to mtd start
1949 * @param len number of bytes to lock or unlock
1950 * @param cmd lock or unlock command
1952 * Lock or unlock one or more blocks
1954 static int onenand_do_lock_cmd(struct mtd_info *mtd, loff_t ofs, size_t len, int cmd)
1956 struct onenand_chip *this = mtd->priv;
1957 int start, end, block, value, status;
1959 start = onenand_block(this, ofs);
1960 end = onenand_block(this, ofs + len);
1962 /* Continuous lock scheme */
1963 if (this->options & ONENAND_HAS_CONT_LOCK) {
1964 /* Set start block address */
1965 this->write_word(start,
1966 this->base + ONENAND_REG_START_BLOCK_ADDRESS);
1967 /* Set end block address */
1968 this->write_word(end - 1,
1969 this->base + ONENAND_REG_END_BLOCK_ADDRESS);
1970 /* Write unlock command */
1971 this->command(mtd, cmd, 0, 0);
1973 /* There's no return value */
1974 this->wait(mtd, FL_UNLOCKING);
1977 while (this->read_word(this->base + ONENAND_REG_CTRL_STATUS)
1978 & ONENAND_CTRL_ONGO)
1981 /* Check lock status */
1982 status = this->read_word(this->base + ONENAND_REG_WP_STATUS);
1983 if (!(status & ONENAND_WP_US))
1984 printk(KERN_ERR "wp status = 0x%x\n", status);
1989 /* Block lock scheme */
1990 for (block = start; block < end; block++) {
1991 /* Set block address */
1992 value = onenand_block_address(this, block);
1993 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS1);
1994 /* Select DataRAM for DDP */
1995 value = onenand_bufferram_address(this, block);
1996 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS2);
1998 /* Set start block address */
1999 this->write_word(block,
2000 this->base + ONENAND_REG_START_BLOCK_ADDRESS);
2001 /* Write unlock command */
2002 this->command(mtd, ONENAND_CMD_UNLOCK, 0, 0);
2004 /* There's no return value */
2005 this->wait(mtd, FL_UNLOCKING);
2008 while (this->read_word(this->base + ONENAND_REG_CTRL_STATUS)
2009 & ONENAND_CTRL_ONGO)
2012 /* Check lock status */
2013 status = this->read_word(this->base + ONENAND_REG_WP_STATUS);
2014 if (!(status & ONENAND_WP_US))
2015 printk(KERN_ERR "block = %d, wp status = 0x%x\n",
2022 #ifdef ONENAND_LINUX
2024 * onenand_lock - [MTD Interface] Lock block(s)
2025 * @param mtd MTD device structure
2026 * @param ofs offset relative to mtd start
2027 * @param len number of bytes to unlock
2029 * Lock one or more blocks
2031 static int onenand_lock(struct mtd_info *mtd, loff_t ofs, size_t len)
2035 onenand_get_device(mtd, FL_LOCKING);
2036 ret = onenand_do_lock_cmd(mtd, ofs, len, ONENAND_CMD_LOCK);
2037 onenand_release_device(mtd);
2042 * onenand_unlock - [MTD Interface] Unlock block(s)
2043 * @param mtd MTD device structure
2044 * @param ofs offset relative to mtd start
2045 * @param len number of bytes to unlock
2047 * Unlock one or more blocks
2049 static int onenand_unlock(struct mtd_info *mtd, loff_t ofs, size_t len)
2053 onenand_get_device(mtd, FL_LOCKING);
2054 ret = onenand_do_lock_cmd(mtd, ofs, len, ONENAND_CMD_UNLOCK);
2055 onenand_release_device(mtd);
2061 * onenand_check_lock_status - [OneNAND Interface] Check lock status
2062 * @param this onenand chip data structure
2066 static int onenand_check_lock_status(struct onenand_chip *this)
2068 unsigned int value, block, status;
2071 end = this->chipsize >> this->erase_shift;
2072 for (block = 0; block < end; block++) {
2073 /* Set block address */
2074 value = onenand_block_address(this, block);
2075 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS1);
2076 /* Select DataRAM for DDP */
2077 value = onenand_bufferram_address(this, block);
2078 this->write_word(value, this->base + ONENAND_REG_START_ADDRESS2);
2079 /* Set start block address */
2080 this->write_word(block, this->base + ONENAND_REG_START_BLOCK_ADDRESS);
2082 /* Check lock status */
2083 status = this->read_word(this->base + ONENAND_REG_WP_STATUS);
2084 if (!(status & ONENAND_WP_US)) {
2085 printk(KERN_ERR "block = %d, wp status = 0x%x\n", block, status);
2094 * onenand_unlock_all - [OneNAND Interface] unlock all blocks
2095 * @param mtd MTD device structure
2099 static void onenand_unlock_all(struct mtd_info *mtd)
2101 struct onenand_chip *this = mtd->priv;
2103 size_t len = mtd->size;
2105 if (this->options & ONENAND_HAS_UNLOCK_ALL) {
2106 /* Set start block address */
2107 this->write_word(0, this->base + ONENAND_REG_START_BLOCK_ADDRESS);
2108 /* Write unlock command */
2109 this->command(mtd, ONENAND_CMD_UNLOCK_ALL, 0, 0);
2111 /* There's no return value */
2112 this->wait(mtd, FL_LOCKING);
2115 while (this->read_word(this->base + ONENAND_REG_CTRL_STATUS)
2116 & ONENAND_CTRL_ONGO)
2119 /* Check lock status */
2120 if (onenand_check_lock_status(this))
2123 /* Workaround for all block unlock in DDP */
2124 if (ONENAND_IS_DDP(this) && !FLEXONENAND(this)) {
2125 /* All blocks on another chip */
2126 ofs = this->chipsize >> 1;
2127 len = this->chipsize >> 1;
2131 onenand_do_lock_cmd(mtd, ofs, len, ONENAND_CMD_UNLOCK);
2136 * onenand_check_features - Check and set OneNAND features
2137 * @param mtd MTD data structure
2139 * Check and set OneNAND features
2143 static void onenand_check_features(struct mtd_info *mtd)
2145 struct onenand_chip *this = mtd->priv;
2146 unsigned int density, process;
2148 /* Lock scheme depends on density and process */
2149 density = onenand_get_density(this->device_id);
2150 process = this->version_id >> ONENAND_VERSION_PROCESS_SHIFT;
2154 case ONENAND_DEVICE_DENSITY_4Gb:
2155 if (ONENAND_IS_DDP(this))
2156 this->options |= ONENAND_HAS_2PLANE;
2158 this->options |= ONENAND_HAS_4KB_PAGE;
2160 case ONENAND_DEVICE_DENSITY_2Gb:
2161 /* 2Gb DDP don't have 2 plane */
2162 if (!ONENAND_IS_DDP(this))
2163 this->options |= ONENAND_HAS_2PLANE;
2164 this->options |= ONENAND_HAS_UNLOCK_ALL;
2166 case ONENAND_DEVICE_DENSITY_1Gb:
2167 /* A-Die has all block unlock */
2169 this->options |= ONENAND_HAS_UNLOCK_ALL;
2173 /* Some OneNAND has continuous lock scheme */
2175 this->options |= ONENAND_HAS_CONT_LOCK;
2179 if (ONENAND_IS_MLC(this))
2180 this->options |= ONENAND_HAS_4KB_PAGE;
2182 if (ONENAND_IS_4KB_PAGE(this))
2183 this->options &= ~ONENAND_HAS_2PLANE;
2185 if (FLEXONENAND(this)) {
2186 this->options &= ~ONENAND_HAS_CONT_LOCK;
2187 this->options |= ONENAND_HAS_UNLOCK_ALL;
2190 if (this->options & ONENAND_HAS_CONT_LOCK)
2191 printk(KERN_DEBUG "Lock scheme is Continuous Lock\n");
2192 if (this->options & ONENAND_HAS_UNLOCK_ALL)
2193 printk(KERN_DEBUG "Chip support all block unlock\n");
2194 if (this->options & ONENAND_HAS_2PLANE)
2195 printk(KERN_DEBUG "Chip has 2 plane\n");
2196 if (this->options & ONENAND_HAS_4KB_PAGE)
2197 printk(KERN_DEBUG "Chip has 4KiB pagesize\n");
2202 * onenand_print_device_info - Print device ID
2203 * @param device device ID
2207 char *onenand_print_device_info(int device, int version)
2209 int vcc, demuxed, ddp, density, flexonenand;
2210 char *dev_info = malloc(80);
2213 vcc = device & ONENAND_DEVICE_VCC_MASK;
2214 demuxed = device & ONENAND_DEVICE_IS_DEMUX;
2215 ddp = device & ONENAND_DEVICE_IS_DDP;
2216 density = onenand_get_density(device);
2217 flexonenand = device & DEVICE_IS_FLEXONENAND;
2218 p += sprintf(dev_info, "%s%sOneNAND%s %dMB %sV 16-bit (0x%02x)",
2219 demuxed ? "" : "Muxed ",
2220 flexonenand ? "Flex-" : "",
2222 (16 << density), vcc ? "2.65/3.3" : "1.8", device);
2224 sprintf(p, "\nOneNAND version = 0x%04x", version);
2225 printk("%s\n", dev_info);
2230 static const struct onenand_manufacturers onenand_manuf_ids[] = {
2231 {ONENAND_MFR_NUMONYX, "Numonyx"},
2232 {ONENAND_MFR_SAMSUNG, "Samsung"},
2236 * onenand_check_maf - Check manufacturer ID
2237 * @param manuf manufacturer ID
2239 * Check manufacturer ID
2241 static int onenand_check_maf(int manuf)
2243 int size = ARRAY_SIZE(onenand_manuf_ids);
2245 #ifdef ONENAND_DEBUG
2249 for (i = 0; i < size; i++)
2250 if (manuf == onenand_manuf_ids[i].id)
2253 #ifdef ONENAND_DEBUG
2255 name = onenand_manuf_ids[i].name;
2259 printk(KERN_DEBUG "OneNAND Manufacturer: %s (0x%0x)\n", name, manuf);
2266 * flexonenand_get_boundary - Reads the SLC boundary
2267 * @param onenand_info - onenand info structure
2269 * Fill up boundary[] field in onenand_chip
2271 static int flexonenand_get_boundary(struct mtd_info *mtd)
2273 struct onenand_chip *this = mtd->priv;
2274 unsigned int die, bdry;
2278 syscfg = this->read_word(this->base + ONENAND_REG_SYS_CFG1);
2279 this->write_word((syscfg | 0x0100), this->base + ONENAND_REG_SYS_CFG1);
2281 for (die = 0; die < this->dies; die++) {
2282 this->command(mtd, FLEXONENAND_CMD_PI_ACCESS, die, 0);
2283 this->wait(mtd, FL_SYNCING);
2285 this->command(mtd, FLEXONENAND_CMD_READ_PI, die, 0);
2286 this->wait(mtd, FL_READING);
2288 bdry = this->read_word(this->base + ONENAND_DATARAM);
2289 if ((bdry >> FLEXONENAND_PI_UNLOCK_SHIFT) == 3)
2293 this->boundary[die] = bdry & FLEXONENAND_PI_MASK;
2295 this->command(mtd, ONENAND_CMD_RESET, 0, 0);
2296 this->wait(mtd, FL_RESETING);
2298 printk(KERN_INFO "Die %d boundary: %d%s\n", die,
2299 this->boundary[die], locked ? "(Locked)" : "(Unlocked)");
2303 this->write_word(syscfg, this->base + ONENAND_REG_SYS_CFG1);
2308 * flexonenand_get_size - Fill up fields in onenand_chip and mtd_info
2309 * boundary[], diesize[], mtd->size, mtd->erasesize,
2311 * @param mtd - MTD device structure
2313 static void flexonenand_get_size(struct mtd_info *mtd)
2315 struct onenand_chip *this = mtd->priv;
2316 int die, i, eraseshift, density;
2317 int blksperdie, maxbdry;
2320 density = onenand_get_density(this->device_id);
2321 blksperdie = ((loff_t)(16 << density) << 20) >> (this->erase_shift);
2322 blksperdie >>= ONENAND_IS_DDP(this) ? 1 : 0;
2323 maxbdry = blksperdie - 1;
2324 eraseshift = this->erase_shift - 1;
2326 mtd->numeraseregions = this->dies << 1;
2328 /* This fills up the device boundary */
2329 flexonenand_get_boundary(mtd);
2333 for (; die < this->dies; die++) {
2334 if (!die || this->boundary[die-1] != maxbdry) {
2336 mtd->eraseregions[i].offset = ofs;
2337 mtd->eraseregions[i].erasesize = 1 << eraseshift;
2338 mtd->eraseregions[i].numblocks =
2339 this->boundary[die] + 1;
2340 ofs += mtd->eraseregions[i].numblocks << eraseshift;
2343 mtd->numeraseregions -= 1;
2344 mtd->eraseregions[i].numblocks +=
2345 this->boundary[die] + 1;
2346 ofs += (this->boundary[die] + 1) << (eraseshift - 1);
2348 if (this->boundary[die] != maxbdry) {
2350 mtd->eraseregions[i].offset = ofs;
2351 mtd->eraseregions[i].erasesize = 1 << eraseshift;
2352 mtd->eraseregions[i].numblocks = maxbdry ^
2353 this->boundary[die];
2354 ofs += mtd->eraseregions[i].numblocks << eraseshift;
2357 mtd->numeraseregions -= 1;
2360 /* Expose MLC erase size except when all blocks are SLC */
2361 mtd->erasesize = 1 << this->erase_shift;
2362 if (mtd->numeraseregions == 1)
2363 mtd->erasesize >>= 1;
2365 printk(KERN_INFO "Device has %d eraseregions\n", mtd->numeraseregions);
2366 for (i = 0; i < mtd->numeraseregions; i++)
2367 printk(KERN_INFO "[offset: 0x%08llx, erasesize: 0x%05x,"
2368 " numblocks: %04u]\n", mtd->eraseregions[i].offset,
2369 mtd->eraseregions[i].erasesize,
2370 mtd->eraseregions[i].numblocks);
2372 for (die = 0, mtd->size = 0; die < this->dies; die++) {
2373 this->diesize[die] = (loff_t) (blksperdie << this->erase_shift);
2374 this->diesize[die] -= (loff_t) (this->boundary[die] + 1)
2375 << (this->erase_shift - 1);
2376 mtd->size += this->diesize[die];
2381 * flexonenand_check_blocks_erased - Check if blocks are erased
2382 * @param mtd_info - mtd info structure
2383 * @param start - first erase block to check
2384 * @param end - last erase block to check
2386 * Converting an unerased block from MLC to SLC
2387 * causes byte values to change. Since both data and its ECC
2388 * have changed, reads on the block give uncorrectable error.
2389 * This might lead to the block being detected as bad.
2391 * Avoid this by ensuring that the block to be converted is
2394 static int flexonenand_check_blocks_erased(struct mtd_info *mtd,
2397 struct onenand_chip *this = mtd->priv;
2400 struct mtd_oob_ops ops = {
2401 .mode = MTD_OPS_PLACE_OOB,
2403 .ooblen = mtd->oobsize,
2405 .oobbuf = this->oob_buf,
2409 printk(KERN_DEBUG "Check blocks from %d to %d\n", start, end);
2411 for (block = start; block <= end; block++) {
2412 addr = flexonenand_addr(this, block);
2413 if (onenand_block_isbad_nolock(mtd, addr, 0))
2417 * Since main area write results in ECC write to spare,
2418 * it is sufficient to check only ECC bytes for change.
2420 ret = onenand_read_oob_nolock(mtd, addr, &ops);
2424 for (i = 0; i < mtd->oobsize; i++)
2425 if (this->oob_buf[i] != 0xff)
2428 if (i != mtd->oobsize) {
2429 printk(KERN_WARNING "Block %d not erased.\n", block);
2438 * flexonenand_set_boundary - Writes the SLC boundary
2439 * @param mtd - mtd info structure
2441 int flexonenand_set_boundary(struct mtd_info *mtd, int die,
2442 int boundary, int lock)
2444 struct onenand_chip *this = mtd->priv;
2445 int ret, density, blksperdie, old, new, thisboundary;
2448 if (die >= this->dies)
2451 if (boundary == this->boundary[die])
2454 density = onenand_get_density(this->device_id);
2455 blksperdie = ((16 << density) << 20) >> this->erase_shift;
2456 blksperdie >>= ONENAND_IS_DDP(this) ? 1 : 0;
2458 if (boundary >= blksperdie) {
2459 printk("flexonenand_set_boundary:"
2460 "Invalid boundary value. "
2461 "Boundary not changed.\n");
2465 /* Check if converting blocks are erased */
2466 old = this->boundary[die] + (die * this->density_mask);
2467 new = boundary + (die * this->density_mask);
2468 ret = flexonenand_check_blocks_erased(mtd, min(old, new)
2469 + 1, max(old, new));
2471 printk(KERN_ERR "flexonenand_set_boundary: Please erase blocks before boundary change\n");
2475 this->command(mtd, FLEXONENAND_CMD_PI_ACCESS, die, 0);
2476 this->wait(mtd, FL_SYNCING);
2478 /* Check is boundary is locked */
2479 this->command(mtd, FLEXONENAND_CMD_READ_PI, die, 0);
2480 ret = this->wait(mtd, FL_READING);
2482 thisboundary = this->read_word(this->base + ONENAND_DATARAM);
2483 if ((thisboundary >> FLEXONENAND_PI_UNLOCK_SHIFT) != 3) {
2484 printk(KERN_ERR "flexonenand_set_boundary: boundary locked\n");
2488 printk(KERN_INFO "flexonenand_set_boundary: Changing die %d boundary: %d%s\n",
2489 die, boundary, lock ? "(Locked)" : "(Unlocked)");
2491 boundary &= FLEXONENAND_PI_MASK;
2492 boundary |= lock ? 0 : (3 << FLEXONENAND_PI_UNLOCK_SHIFT);
2494 addr = die ? this->diesize[0] : 0;
2495 this->command(mtd, ONENAND_CMD_ERASE, addr, 0);
2496 ret = this->wait(mtd, FL_ERASING);
2498 printk("flexonenand_set_boundary:"
2499 "Failed PI erase for Die %d\n", die);
2503 this->write_word(boundary, this->base + ONENAND_DATARAM);
2504 this->command(mtd, ONENAND_CMD_PROG, addr, 0);
2505 ret = this->wait(mtd, FL_WRITING);
2507 printk("flexonenand_set_boundary:"
2508 "Failed PI write for Die %d\n", die);
2512 this->command(mtd, FLEXONENAND_CMD_PI_UPDATE, die, 0);
2513 ret = this->wait(mtd, FL_WRITING);
2515 this->write_word(ONENAND_CMD_RESET, this->base + ONENAND_REG_COMMAND);
2516 this->wait(mtd, FL_RESETING);
2518 /* Recalculate device size on boundary change*/
2519 flexonenand_get_size(mtd);
2525 * onenand_chip_probe - [OneNAND Interface] Probe the OneNAND chip
2526 * @param mtd MTD device structure
2528 * OneNAND detection method:
2529 * Compare the the values from command with ones from register
2531 static int onenand_chip_probe(struct mtd_info *mtd)
2533 struct onenand_chip *this = mtd->priv;
2534 int bram_maf_id, bram_dev_id, maf_id, dev_id;
2537 /* Save system configuration 1 */
2538 syscfg = this->read_word(this->base + ONENAND_REG_SYS_CFG1);
2540 /* Clear Sync. Burst Read mode to read BootRAM */
2541 this->write_word((syscfg & ~ONENAND_SYS_CFG1_SYNC_READ),
2542 this->base + ONENAND_REG_SYS_CFG1);
2544 /* Send the command for reading device ID from BootRAM */
2545 this->write_word(ONENAND_CMD_READID, this->base + ONENAND_BOOTRAM);
2547 /* Read manufacturer and device IDs from BootRAM */
2548 bram_maf_id = this->read_word(this->base + ONENAND_BOOTRAM + 0x0);
2549 bram_dev_id = this->read_word(this->base + ONENAND_BOOTRAM + 0x2);
2551 /* Reset OneNAND to read default register values */
2552 this->write_word(ONENAND_CMD_RESET, this->base + ONENAND_BOOTRAM);
2555 if (this->wait(mtd, FL_RESETING))
2558 /* Restore system configuration 1 */
2559 this->write_word(syscfg, this->base + ONENAND_REG_SYS_CFG1);
2561 /* Check manufacturer ID */
2562 if (onenand_check_maf(bram_maf_id))
2565 /* Read manufacturer and device IDs from Register */
2566 maf_id = this->read_word(this->base + ONENAND_REG_MANUFACTURER_ID);
2567 dev_id = this->read_word(this->base + ONENAND_REG_DEVICE_ID);
2569 /* Check OneNAND device */
2570 if (maf_id != bram_maf_id || dev_id != bram_dev_id)
2577 * onenand_probe - [OneNAND Interface] Probe the OneNAND device
2578 * @param mtd MTD device structure
2580 * OneNAND detection method:
2581 * Compare the the values from command with ones from register
2583 int onenand_probe(struct mtd_info *mtd)
2585 struct onenand_chip *this = mtd->priv;
2590 ret = this->chip_probe(mtd);
2594 /* Read device IDs from Register */
2595 dev_id = this->read_word(this->base + ONENAND_REG_DEVICE_ID);
2596 ver_id = this->read_word(this->base + ONENAND_REG_VERSION_ID);
2597 this->technology = this->read_word(this->base + ONENAND_REG_TECHNOLOGY);
2599 /* Flash device information */
2600 mtd->name = onenand_print_device_info(dev_id, ver_id);
2601 this->device_id = dev_id;
2602 this->version_id = ver_id;
2604 /* Check OneNAND features */
2605 onenand_check_features(mtd);
2607 density = onenand_get_density(dev_id);
2608 if (FLEXONENAND(this)) {
2609 this->dies = ONENAND_IS_DDP(this) ? 2 : 1;
2610 /* Maximum possible erase regions */
2611 mtd->numeraseregions = this->dies << 1;
2612 mtd->eraseregions = malloc(sizeof(struct mtd_erase_region_info)
2613 * (this->dies << 1));
2614 if (!mtd->eraseregions)
2619 * For Flex-OneNAND, chipsize represents maximum possible device size.
2620 * mtd->size represents the actual device size.
2622 this->chipsize = (16 << density) << 20;
2624 /* OneNAND page size & block size */
2625 /* The data buffer size is equal to page size */
2627 this->read_word(this->base + ONENAND_REG_DATA_BUFFER_SIZE);
2628 /* We use the full BufferRAM */
2629 if (ONENAND_IS_4KB_PAGE(this))
2630 mtd->writesize <<= 1;
2632 mtd->oobsize = mtd->writesize >> 5;
2633 /* Pagers per block is always 64 in OneNAND */
2634 mtd->erasesize = mtd->writesize << 6;
2636 * Flex-OneNAND SLC area has 64 pages per block.
2637 * Flex-OneNAND MLC area has 128 pages per block.
2638 * Expose MLC erase size to find erase_shift and page_mask.
2640 if (FLEXONENAND(this))
2641 mtd->erasesize <<= 1;
2643 this->erase_shift = ffs(mtd->erasesize) - 1;
2644 this->page_shift = ffs(mtd->writesize) - 1;
2645 this->ppb_shift = (this->erase_shift - this->page_shift);
2646 this->page_mask = (mtd->erasesize / mtd->writesize) - 1;
2647 /* Set density mask. it is used for DDP */
2648 if (ONENAND_IS_DDP(this))
2649 this->density_mask = this->chipsize >> (this->erase_shift + 1);
2650 /* It's real page size */
2651 this->writesize = mtd->writesize;
2653 /* REVIST: Multichip handling */
2655 if (FLEXONENAND(this))
2656 flexonenand_get_size(mtd);
2658 mtd->size = this->chipsize;
2660 mtd->type = ONENAND_IS_MLC(this) ? MTD_MLCNANDFLASH : MTD_NANDFLASH;
2661 mtd->flags = MTD_CAP_NANDFLASH;
2662 mtd->_erase = onenand_erase;
2663 mtd->_read_oob = onenand_read_oob;
2664 mtd->_write_oob = onenand_write_oob;
2665 mtd->_sync = onenand_sync;
2666 mtd->_block_isbad = onenand_block_isbad;
2667 mtd->_block_markbad = onenand_block_markbad;
2668 mtd->writebufsize = mtd->writesize;
2674 * onenand_scan - [OneNAND Interface] Scan for the OneNAND device
2675 * @param mtd MTD device structure
2676 * @param maxchips Number of chips to scan for
2678 * This fills out all the not initialized function pointers
2679 * with the defaults.
2680 * The flash ID is read and the mtd/chip structures are
2681 * filled with the appropriate values.
2683 int onenand_scan(struct mtd_info *mtd, int maxchips)
2686 struct onenand_chip *this = mtd->priv;
2688 if (!this->read_word)
2689 this->read_word = onenand_readw;
2690 if (!this->write_word)
2691 this->write_word = onenand_writew;
2694 this->command = onenand_command;
2696 this->wait = onenand_wait;
2697 if (!this->bbt_wait)
2698 this->bbt_wait = onenand_bbt_wait;
2700 if (!this->read_bufferram)
2701 this->read_bufferram = onenand_read_bufferram;
2702 if (!this->write_bufferram)
2703 this->write_bufferram = onenand_write_bufferram;
2705 if (!this->chip_probe)
2706 this->chip_probe = onenand_chip_probe;
2708 if (!this->block_markbad)
2709 this->block_markbad = onenand_default_block_markbad;
2710 if (!this->scan_bbt)
2711 this->scan_bbt = onenand_default_bbt;
2713 if (onenand_probe(mtd))
2716 /* Set Sync. Burst Read after probing */
2717 if (this->mmcontrol) {
2718 printk(KERN_INFO "OneNAND Sync. Burst Read support\n");
2719 this->read_bufferram = onenand_sync_read_bufferram;
2722 /* Allocate buffers, if necessary */
2723 if (!this->page_buf) {
2724 this->page_buf = kzalloc(mtd->writesize, GFP_KERNEL);
2725 if (!this->page_buf) {
2726 printk(KERN_ERR "onenand_scan(): Can't allocate page_buf\n");
2729 this->options |= ONENAND_PAGEBUF_ALLOC;
2731 if (!this->oob_buf) {
2732 this->oob_buf = kzalloc(mtd->oobsize, GFP_KERNEL);
2733 if (!this->oob_buf) {
2734 printk(KERN_ERR "onenand_scan: Can't allocate oob_buf\n");
2735 if (this->options & ONENAND_PAGEBUF_ALLOC) {
2736 this->options &= ~ONENAND_PAGEBUF_ALLOC;
2737 kfree(this->page_buf);
2741 this->options |= ONENAND_OOBBUF_ALLOC;
2744 this->state = FL_READY;
2747 * Allow subpage writes up to oobsize.
2749 switch (mtd->oobsize) {
2751 this->ecclayout = &onenand_oob_128;
2752 mtd->subpage_sft = 0;
2756 this->ecclayout = &onenand_oob_64;
2757 mtd->subpage_sft = 2;
2761 this->ecclayout = &onenand_oob_32;
2762 mtd->subpage_sft = 1;
2766 printk(KERN_WARNING "No OOB scheme defined for oobsize %d\n",
2768 mtd->subpage_sft = 0;
2769 /* To prevent kernel oops */
2770 this->ecclayout = &onenand_oob_32;
2774 this->subpagesize = mtd->writesize >> mtd->subpage_sft;
2777 * The number of bytes available for a client to place data into
2778 * the out of band area
2780 this->ecclayout->oobavail = 0;
2782 for (i = 0; i < MTD_MAX_OOBFREE_ENTRIES_LARGE &&
2783 this->ecclayout->oobfree[i].length; i++)
2784 this->ecclayout->oobavail +=
2785 this->ecclayout->oobfree[i].length;
2786 mtd->oobavail = this->ecclayout->oobavail;
2788 mtd->ecclayout = this->ecclayout;
2790 /* Unlock whole block */
2791 onenand_unlock_all(mtd);
2793 return this->scan_bbt(mtd);
2797 * onenand_release - [OneNAND Interface] Free resources held by the OneNAND device
2798 * @param mtd MTD device structure
2800 void onenand_release(struct mtd_info *mtd)