/* * Multiblock erase if number of blocks to erase is 2 or more. * Maximum number of blocks for simultaneous erase is 64.
*/ #define MB_ERASE_MIN_BLK_COUNT 2 #define MB_ERASE_MAX_BLK_COUNT 64
module_param_array(flex_bdry, int, NULL, 0400);
MODULE_PARM_DESC(flex_bdry, "SLC Boundary information for Flex-OneNAND" "Syntax:flex_bdry=DIE_BDRY,LOCK,..." "DIE_BDRY: SLC boundary of the die" "LOCK: Locking information for SLC boundary" " : 0->Set boundary in unlocked status" " : 1->Set boundary in locked status");
module_param(otp, int, 0400);
MODULE_PARM_DESC(otp, "Corresponding behaviour of OneNAND in OTP" "Syntax : otp=LOCK_TYPE" "LOCK_TYPE : Keys issued, for specific OTP Lock type" " : 0 -> Default (No Blocks Locked)" " : 1 -> OTP Block lock" " : 2 -> 1st Block lock" " : 3 -> BOTH OTP Block and 1st Block lock");
/* * flexonenand_oob_128 - oob info for Flex-Onenand with 4KB page * For now, we expose only 64 out of 80 ecc bytes
*/ staticint flexonenand_ooblayout_ecc(struct mtd_info *mtd, int section, struct mtd_oob_region *oobregion)
{ if (section > 7) return -ERANGE;
staticint onenand_ooblayout_128_free(struct mtd_info *mtd, int section, struct mtd_oob_region *oobregion)
{ if (section >= 8) return -ERANGE;
/* * free bytes are using the spare area fields marked as * "Managed by internal ECC logic for Logical Sector Number area"
*/
oobregion->offset = (section * 16) + 2;
oobregion->length = 3;
/** * onenand_buffer_address - [DEFAULT] Get buffer address * @dataram1: DataRAM index * @sectors: the sector address * @count: the number of sectors * Return: the start buffer value * * Setup Start Buffer Register (F200h)
*/ staticint onenand_buffer_address(int dataram1, int sectors, int count)
{ int bsa, bsc;
/** * flexonenand_block- For given address return block number * @this: - OneNAND device structure * @addr: - Address for which block number is needed
*/ staticunsigned flexonenand_block(struct onenand_chip *this, loff_t addr)
{ unsigned boundary, blk, die = 0;
if (ONENAND_IS_DDP(this) && addr >= this->diesize[0]) {
die = 1;
addr -= this->diesize[0];
}
/** * flexonenand_addr - Return address of the block * @this: OneNAND device structure * @block: Block number on Flex-OneNAND * * Return address of the block
*/ static loff_t flexonenand_addr(struct onenand_chip *this, int block)
{
loff_t ofs = 0; int die = 0, boundary;
if (ONENAND_IS_DDP(this) && block >= this->density_mask) {
block -= this->density_mask;
die = 1;
ofs = this->diesize[0];
}
loff_t onenand_addr(struct onenand_chip *this, int block)
{ if (!FLEXONENAND(this)) return (loff_t)block << this->erase_shift; return flexonenand_addr(this, block);
}
EXPORT_SYMBOL(onenand_addr);
/** * onenand_get_density - [DEFAULT] Get OneNAND density * @dev_id: OneNAND device ID * * Get OneNAND density from device ID
*/ staticinlineint onenand_get_density(int dev_id)
{ int density = dev_id >> ONENAND_DEVICE_DENSITY_SHIFT; return (density & ONENAND_DEVICE_DENSITY_MASK);
}
/** * flexonenand_region - [Flex-OneNAND] Return erase region of addr * @mtd: MTD device structure * @addr: address whose erase region needs to be identified
*/ int flexonenand_region(struct mtd_info *mtd, loff_t addr)
{ int i;
for (i = 0; i < mtd->numeraseregions; i++) if (addr < mtd->eraseregions[i].offset) break; return i - 1;
}
EXPORT_SYMBOL(flexonenand_region);
/** * onenand_command - [DEFAULT] Send command to OneNAND device * @mtd: MTD device structure * @cmd: the command to be sent * @addr: offset to read from or write to * @len: number of bytes to read or write * * Send command to OneNAND device. This function is used for middle/large page * devices (1KB/2KB Bytes per page)
*/ staticint onenand_command(struct mtd_info *mtd, int cmd, loff_t addr, size_t len)
{ struct onenand_chip *this = mtd->priv; int value, block, page;
/* Address translation */ switch (cmd) { case ONENAND_CMD_UNLOCK: case ONENAND_CMD_LOCK: case ONENAND_CMD_LOCK_TIGHT: case ONENAND_CMD_UNLOCK_ALL:
block = -1;
page = -1; break;
case FLEXONENAND_CMD_PI_ACCESS: /* addr contains die index */
block = addr * this->density_mask;
page = -1; break;
case ONENAND_CMD_ERASE: case ONENAND_CMD_MULTIBLOCK_ERASE: case ONENAND_CMD_ERASE_VERIFY: case ONENAND_CMD_BUFFERRAM: case ONENAND_CMD_OTP_ACCESS:
block = onenand_block(this, addr);
page = -1; break;
default:
block = onenand_block(this, addr); if (FLEXONENAND(this))
page = (int) (addr - onenand_addr(this, block))>>\
this->page_shift; else
page = (int) (addr >> this->page_shift); if (ONENAND_IS_2PLANE(this)) { /* Make the even block number */
block &= ~1; /* Is it the odd plane? */ if (addr & this->writesize)
block++;
page >>= 1;
}
page &= this->page_mask; break;
}
/* NOTE: The setting order of the registers is very important! */ if (cmd == ONENAND_CMD_BUFFERRAM) { /* Select DataRAM for DDP */
value = onenand_bufferram_address(this, block);
this->write_word(value, this->base + ONENAND_REG_START_ADDRESS2);
if (ONENAND_IS_2PLANE(this) || ONENAND_IS_4KB_PAGE(this)) /* It is always BufferRAM0 */
ONENAND_SET_BUFFERRAM0(this); else /* Switch to the next data buffer */
ONENAND_SET_NEXT_BUFFERRAM(this);
return 0;
}
if (block != -1) { /* Write 'DFS, FBA' of Flash */
value = onenand_block_address(this, block);
this->write_word(value, this->base + ONENAND_REG_START_ADDRESS1);
/* Select DataRAM for DDP */
value = onenand_bufferram_address(this, block);
this->write_word(value, this->base + ONENAND_REG_START_ADDRESS2);
}
if (page != -1) { /* Now we use page size operation */ int sectors = 0, count = 0; int dataram;
switch (cmd) { case FLEXONENAND_CMD_RECOVER_LSB: case ONENAND_CMD_READ: case ONENAND_CMD_READOOB: if (ONENAND_IS_4KB_PAGE(this)) /* It is always BufferRAM0 */
dataram = ONENAND_SET_BUFFERRAM0(this); else
dataram = ONENAND_SET_NEXT_BUFFERRAM(this); break;
/** * onenand_read_ecc - return ecc status * @this: onenand chip structure
*/ staticinlineint onenand_read_ecc(struct onenand_chip *this)
{ int ecc, i, result = 0;
if (!FLEXONENAND(this) && !ONENAND_IS_4KB_PAGE(this)) return this->read_word(this->base + ONENAND_REG_ECC_STATUS);
for (i = 0; i < 4; i++) {
ecc = this->read_word(this->base + ONENAND_REG_ECC_STATUS + i*2); if (likely(!ecc)) continue; if (ecc & FLEXONENAND_UNCORRECTABLE_ERROR) return ONENAND_ECC_2BIT_ALL; else
result = ONENAND_ECC_1BIT_ALL;
}
return result;
}
/** * onenand_wait - [DEFAULT] wait until the command is done * @mtd: MTD device structure * @state: state to select the max. timeout value * * Wait for command done. This applies to all OneNAND command * Read can take up to 30us, erase up to 2ms and program up to 350us * according to general OneNAND specs
*/ staticint onenand_wait(struct mtd_info *mtd, int state)
{ struct onenand_chip * this = mtd->priv; unsignedlong timeout; unsignedint flags = ONENAND_INT_MASTER; unsignedint interrupt = 0; unsignedint ctrl;
/* The 20 msec is enough */
timeout = jiffies + msecs_to_jiffies(20); while (time_before(jiffies, timeout)) {
interrupt = this->read_word(this->base + ONENAND_REG_INTERRUPT);
if (interrupt & flags) break;
if (state != FL_READING && state != FL_PREPARING_ERASE)
cond_resched();
} /* To get correct interrupt status in timeout case */
interrupt = this->read_word(this->base + ONENAND_REG_INTERRUPT);
/* * In the Spec. it checks the controller status first * However if you get the correct information in case of * power off recovery (POR) test, it should read ECC status first
*/ if (interrupt & ONENAND_INT_READ) { int ecc = onenand_read_ecc(this); if (ecc) { if (ecc & ONENAND_ECC_2BIT_ALL) {
printk(KERN_ERR "%s: ECC error = 0x%04x\n",
__func__, ecc);
mtd->ecc_stats.failed++; return -EBADMSG;
} elseif (ecc & ONENAND_ECC_1BIT_ALL) {
printk(KERN_DEBUG "%s: correctable ECC error = 0x%04x\n",
__func__, ecc);
mtd->ecc_stats.corrected++;
}
}
} elseif (state == FL_READING) {
printk(KERN_ERR "%s: read timeout! ctrl=0x%04x intr=0x%04x\n",
__func__, ctrl, interrupt); return -EIO;
}
/* If there's controller error, it's a real error */ if (ctrl & ONENAND_CTRL_ERROR) {
printk(KERN_ERR "%s: controller error = 0x%04x\n",
__func__, ctrl); if (ctrl & ONENAND_CTRL_LOCK)
printk(KERN_ERR "%s: it's locked error.\n", __func__); return -EIO;
}
return 0;
}
/* * onenand_interrupt - [DEFAULT] onenand interrupt handler * @irq: onenand interrupt number * @dev_id: interrupt data * * complete the work
*/ static irqreturn_t onenand_interrupt(int irq, void *data)
{ struct onenand_chip *this = data;
/* To handle shared interrupt */ if (!this->complete.done)
complete(&this->complete);
return IRQ_HANDLED;
}
/* * onenand_interrupt_wait - [DEFAULT] wait until the command is done * @mtd: MTD device structure * @state: state to select the max. timeout value * * Wait for command done.
*/ staticint onenand_interrupt_wait(struct mtd_info *mtd, int state)
{ struct onenand_chip *this = mtd->priv;
wait_for_completion(&this->complete);
return onenand_wait(mtd, state);
}
/* * onenand_try_interrupt_wait - [DEFAULT] try interrupt wait * @mtd: MTD device structure * @state: state to select the max. timeout value * * Try interrupt based wait (It is used one-time)
*/ staticint onenand_try_interrupt_wait(struct mtd_info *mtd, int state)
{ struct onenand_chip *this = mtd->priv; unsignedlong remain, timeout;
/* We use interrupt wait first */
this->wait = onenand_interrupt_wait;
timeout = msecs_to_jiffies(100);
remain = wait_for_completion_timeout(&this->complete, timeout); if (!remain) {
printk(KERN_INFO "OneNAND: There's no interrupt. " "We use the normal wait\n");
/* Release the irq */
free_irq(this->irq, this);
this->wait = onenand_wait;
}
return onenand_wait(mtd, state);
}
/* * onenand_setup_wait - [OneNAND Interface] setup onenand wait method * @mtd: MTD device structure * * There's two method to wait onenand work * 1. polling - read interrupt status register * 2. interrupt - use the kernel interrupt method
*/ staticvoid onenand_setup_wait(struct mtd_info *mtd)
{ struct onenand_chip *this = mtd->priv; int syscfg;
init_completion(&this->complete);
if (this->irq <= 0) {
this->wait = onenand_wait; return;
}
if (request_irq(this->irq, &onenand_interrupt,
IRQF_SHARED, "onenand", this)) { /* If we can't get irq, use the normal wait */
this->wait = onenand_wait; return;
}
/** * onenand_bufferram_offset - [DEFAULT] BufferRAM offset * @mtd: MTD data structure * @area: BufferRAM area * @return offset given area * * Return BufferRAM offset given area
*/ staticinlineint onenand_bufferram_offset(struct mtd_info *mtd, int area)
{ struct onenand_chip *this = mtd->priv;
if (ONENAND_CURRENT_BUFFERRAM(this)) { /* Note: the 'this->writesize' is a real page size */ if (area == ONENAND_DATARAM) return this->writesize; if (area == ONENAND_SPARERAM) return mtd->oobsize;
}
return 0;
}
/** * onenand_read_bufferram - [OneNAND Interface] Read the bufferram area * @mtd: MTD data structure * @area: BufferRAM area * @buffer: the databuffer to put/get data * @offset: offset to read from or write to * @count: number of bytes to read/write * * Read the BufferRAM area
*/ staticint onenand_read_bufferram(struct mtd_info *mtd, int area, unsignedchar *buffer, int offset, size_t count)
{ struct onenand_chip *this = mtd->priv; void __iomem *bufferram;
bufferram = this->base + area;
bufferram += onenand_bufferram_offset(mtd, area);
if (ONENAND_CHECK_BYTE_ACCESS(count)) { unsignedshort word;
/* Align with word(16-bit) size */
count--;
/* Read word and save byte */
word = this->read_word(bufferram + offset + count);
buffer[count] = (word & 0xff);
}
memcpy(buffer, bufferram + offset, count);
return 0;
}
/** * onenand_sync_read_bufferram - [OneNAND Interface] Read the bufferram area with Sync. Burst mode * @mtd: MTD data structure * @area: BufferRAM area * @buffer: the databuffer to put/get data * @offset: offset to read from or write to * @count: number of bytes to read/write * * Read the BufferRAM area with Sync. Burst Mode
*/ staticint onenand_sync_read_bufferram(struct mtd_info *mtd, int area, unsignedchar *buffer, int offset, size_t count)
{ struct onenand_chip *this = mtd->priv; void __iomem *bufferram;
bufferram = this->base + area;
bufferram += onenand_bufferram_offset(mtd, area);
this->mmcontrol(mtd, ONENAND_SYS_CFG1_SYNC_READ);
if (ONENAND_CHECK_BYTE_ACCESS(count)) { unsignedshort word;
/* Align with word(16-bit) size */
count--;
/* Read word and save byte */
word = this->read_word(bufferram + offset + count);
buffer[count] = (word & 0xff);
}
memcpy(buffer, bufferram + offset, count);
this->mmcontrol(mtd, 0);
return 0;
}
/** * onenand_write_bufferram - [OneNAND Interface] Write the bufferram area * @mtd: MTD data structure * @area: BufferRAM area * @buffer: the databuffer to put/get data * @offset: offset to read from or write to * @count: number of bytes to read/write * * Write the BufferRAM area
*/ staticint onenand_write_bufferram(struct mtd_info *mtd, int area, constunsignedchar *buffer, int offset, size_t count)
{ struct onenand_chip *this = mtd->priv; void __iomem *bufferram;
bufferram = this->base + area;
bufferram += onenand_bufferram_offset(mtd, area);
if (ONENAND_CHECK_BYTE_ACCESS(count)) { unsignedshort word; int byte_offset;
/* Read word and save byte */
word = this->read_word(bufferram + byte_offset);
word = (word & ~0xff) | buffer[count];
this->write_word(word, bufferram + byte_offset);
}
memcpy(bufferram + offset, buffer, count);
return 0;
}
/** * onenand_get_2x_blockpage - [GENERIC] Get blockpage at 2x program mode * @mtd: MTD data structure * @addr: address to check * @return blockpage address * * Get blockpage address at 2x program mode
*/ staticint onenand_get_2x_blockpage(struct mtd_info *mtd, loff_t addr)
{ struct onenand_chip *this = mtd->priv; int blockpage, block, page;
/* Calculate the even block number */
block = (int) (addr >> this->erase_shift) & ~1; /* Is it the odd plane? */ if (addr & this->writesize)
block++;
page = (int) (addr >> (this->page_shift + 1)) & this->page_mask;
blockpage = (block << 7) | page;
return blockpage;
}
/** * onenand_check_bufferram - [GENERIC] Check BufferRAM information * @mtd: MTD data structure * @addr: address to check * @return 1 if there are valid data, otherwise 0 * * Check bufferram if there is data we required
*/ staticint onenand_check_bufferram(struct mtd_info *mtd, loff_t addr)
{ struct onenand_chip *this = mtd->priv; int blockpage, found = 0; unsignedint i;
/* Is there valid data? */
i = ONENAND_CURRENT_BUFFERRAM(this); if (this->bufferram[i].blockpage == blockpage)
found = 1; else { /* Check another BufferRAM */
i = ONENAND_NEXT_BUFFERRAM(this); if (this->bufferram[i].blockpage == blockpage) {
ONENAND_SET_NEXT_BUFFERRAM(this);
found = 1;
}
}
if (found && ONENAND_IS_DDP(this)) { /* Select DataRAM for DDP */ int block = onenand_block(this, addr); int value = onenand_bufferram_address(this, block);
this->write_word(value, this->base + ONENAND_REG_START_ADDRESS2);
}
return found;
}
/** * onenand_update_bufferram - [GENERIC] Update BufferRAM information * @mtd: MTD data structure * @addr: address to update * @valid: valid flag * * Update BufferRAM information
*/ staticvoid onenand_update_bufferram(struct mtd_info *mtd, loff_t addr, int valid)
{ struct onenand_chip *this = mtd->priv; int blockpage; unsignedint i;
/* Invalidate another BufferRAM */
i = ONENAND_NEXT_BUFFERRAM(this); if (this->bufferram[i].blockpage == blockpage)
this->bufferram[i].blockpage = -1;
/* Update BufferRAM */
i = ONENAND_CURRENT_BUFFERRAM(this); if (valid)
this->bufferram[i].blockpage = blockpage; else
this->bufferram[i].blockpage = -1;
}
/** * onenand_invalidate_bufferram - [GENERIC] Invalidate BufferRAM information * @mtd: MTD data structure * @addr: start address to invalidate * @len: length to invalidate * * Invalidate BufferRAM information
*/ staticvoid onenand_invalidate_bufferram(struct mtd_info *mtd, loff_t addr, unsignedint len)
{ struct onenand_chip *this = mtd->priv; int i;
loff_t end_addr = addr + len;
/* Invalidate BufferRAM */ for (i = 0; i < MAX_BUFFERRAM; i++) {
loff_t buf_addr = this->bufferram[i].blockpage << this->page_shift; if (buf_addr >= addr && buf_addr < end_addr)
this->bufferram[i].blockpage = -1;
}
}
/** * onenand_get_device - [GENERIC] Get chip for selected access * @mtd: MTD device structure * @new_state: the state which is requested * * Get the device and lock it for exclusive access
*/ staticint onenand_get_device(struct mtd_info *mtd, int new_state)
{ struct onenand_chip *this = mtd->priv;
DECLARE_WAITQUEUE(wait, current);
/* * Grab the lock and see if the device is available
*/ while (1) {
spin_lock(&this->chip_lock); if (this->state == FL_READY) {
this->state = new_state;
spin_unlock(&this->chip_lock); if (new_state != FL_PM_SUSPENDED && this->enable)
this->enable(mtd); break;
} if (new_state == FL_PM_SUSPENDED) {
spin_unlock(&this->chip_lock); return (this->state == FL_PM_SUSPENDED) ? 0 : -EAGAIN;
}
set_current_state(TASK_UNINTERRUPTIBLE);
add_wait_queue(&this->wq, &wait);
spin_unlock(&this->chip_lock);
schedule();
remove_wait_queue(&this->wq, &wait);
}
return 0;
}
/** * onenand_release_device - [GENERIC] release chip * @mtd: MTD device structure * * Deselect, release chip lock and wake up anyone waiting on the device
*/ staticvoid onenand_release_device(struct mtd_info *mtd)
{ struct onenand_chip *this = mtd->priv;
if (this->state != FL_PM_SUSPENDED && this->disable)
this->disable(mtd); /* Release the chip */
spin_lock(&this->chip_lock);
this->state = FL_READY;
wake_up(&this->wq);
spin_unlock(&this->chip_lock);
}
/** * onenand_transfer_auto_oob - [INTERN] oob auto-placement transfer * @mtd: MTD device structure * @buf: destination address * @column: oob offset to read from * @thislen: oob length to read
*/ staticint onenand_transfer_auto_oob(struct mtd_info *mtd, uint8_t *buf, int column, int thislen)
{ struct onenand_chip *this = mtd->priv;
/** * onenand_recover_lsb - [Flex-OneNAND] Recover LSB page data * @mtd: MTD device structure * @addr: address to recover * @status: return value from onenand_wait / onenand_bbt_wait * * MLC NAND Flash cell has paired pages - LSB page and MSB page. LSB page has * lower page address and MSB page has higher page address in paired pages. * If power off occurs during MSB page program, the paired LSB page data can * become corrupt. LSB page recovery read is a way to read LSB page though page * data are corrupted. When uncorrectable error occurs as a result of LSB page * read after power up, issue LSB page recovery read.
*/ staticint onenand_recover_lsb(struct mtd_info *mtd, loff_t addr, int status)
{ struct onenand_chip *this = mtd->priv; int i;
/* Recovery is only for Flex-OneNAND */ if (!FLEXONENAND(this)) return status;
/* check if we failed due to uncorrectable error */ if (!mtd_is_eccerr(status) && status != ONENAND_BBT_READ_ECC_ERROR) return status;
/* check if address lies in MLC region */
i = flexonenand_region(mtd, addr); if (mtd->eraseregions[i].erasesize < (1 << this->erase_shift)) return status;
/* We are attempting to reread, so decrement stats.failed * which was incremented by onenand_wait due to read failure
*/
printk(KERN_INFO "%s: Attempting to recover from uncorrectable read\n",
__func__);
mtd->ecc_stats.failed--;
/* Do not allow reads past end of device */ if (from + len > mtd->size) {
printk(KERN_ERR "%s: Attempt read beyond end of device\n",
__func__);
ops->retlen = 0;
ops->oobretlen = 0; return -EINVAL;
}
stats = mtd->ecc_stats;
while (read < len) {
cond_resched();
thislen = min_t(int, writesize, len - read);
column = from & (writesize - 1); if (column + thislen > writesize)
thislen = writesize - column;
if (!onenand_check_bufferram(mtd, from)) {
this->command(mtd, ONENAND_CMD_READ, from, writesize);
ret = this->wait(mtd, FL_READING); if (unlikely(ret))
ret = onenand_recover_lsb(mtd, from, ret);
onenand_update_bufferram(mtd, from, !ret); if (mtd_is_eccerr(ret))
ret = 0; if (ret) break;
}
/* * Return success, if no ECC failures, else -EBADMSG * fs driver will take care of that, because * retlen == desired len and result == -EBADMSG
*/
ops->retlen = read;
ops->oobretlen = oobread;
if (ret) return ret;
if (mtd->ecc_stats.failed - stats.failed) return -EBADMSG;
/* return max bitflips per ecc step; ONENANDs correct 1 bit only */ return mtd->ecc_stats.corrected != stats.corrected ? 1 : 0;
}
/** * onenand_read_ops_nolock - [OneNAND Interface] OneNAND read main and/or out-of-band * @mtd: MTD device structure * @from: offset to read from * @ops: oob operation description structure * * OneNAND read main and/or out-of-band data
*/ staticint onenand_read_ops_nolock(struct mtd_info *mtd, loff_t from, struct mtd_oob_ops *ops)
{ struct onenand_chip *this = mtd->priv; struct mtd_ecc_stats stats;
size_t len = ops->len;
size_t ooblen = ops->ooblen;
u_char *buf = ops->datbuf;
u_char *oobbuf = ops->oobbuf; int read = 0, column, thislen; int oobread = 0, oobcolumn, thisooblen, oobsize; int ret = 0, boundary = 0; int writesize = this->writesize;
pr_debug("%s: from = 0x%08x, len = %i\n", __func__, (unsignedint)from,
(int)len);
/* Do not allow reads past end of device */ if ((from + len) > mtd->size) {
printk(KERN_ERR "%s: Attempt read beyond end of device\n",
__func__);
ops->retlen = 0;
ops->oobretlen = 0; return -EINVAL;
}
stats = mtd->ecc_stats;
/* Read-while-load method */
/* Do first load to bufferRAM */ if (read < len) { if (!onenand_check_bufferram(mtd, from)) {
this->command(mtd, ONENAND_CMD_READ, from, writesize);
ret = this->wait(mtd, FL_READING);
onenand_update_bufferram(mtd, from, !ret); if (mtd_is_eccerr(ret))
ret = 0;
}
}
thislen = min_t(int, writesize, len - read);
column = from & (writesize - 1); if (column + thislen > writesize)
thislen = writesize - column;
while (!ret) { /* If there is more to load then start next load */
from += thislen; if (read + thislen < len) {
this->command(mtd, ONENAND_CMD_READ, from, writesize); /* * Chip boundary handling in DDP * Now we issued chip 1 read and pointed chip 1 * bufferram so we have to point chip 0 bufferram.
*/ if (ONENAND_IS_DDP(this) &&
unlikely(from == (this->chipsize >> 1))) {
this->write_word(ONENAND_DDP_CHIP0, this->base + ONENAND_REG_START_ADDRESS2);
boundary = 1;
} else
boundary = 0;
ONENAND_SET_PREV_BUFFERRAM(this);
} /* While load is going, read from last bufferRAM */
this->read_bufferram(mtd, ONENAND_DATARAM, buf, column, thislen);
/* Read oob area if needed */ if (oobbuf) {
thisooblen = oobsize - oobcolumn;
thisooblen = min_t(int, thisooblen, ooblen - oobread);
/* See if we are done */
read += thislen; if (read == len) break; /* Set up for next read from bufferRAM */ if (unlikely(boundary))
this->write_word(ONENAND_DDP_CHIP1, this->base + ONENAND_REG_START_ADDRESS2);
ONENAND_SET_NEXT_BUFFERRAM(this);
buf += thislen;
thislen = min_t(int, writesize, len - read);
column = 0;
cond_resched(); /* Now wait for load */
ret = this->wait(mtd, FL_READING);
onenand_update_bufferram(mtd, from, !ret); if (mtd_is_eccerr(ret))
ret = 0;
}
/* * Return success, if no ECC failures, else -EBADMSG * fs driver will take care of that, because * retlen == desired len and result == -EBADMSG
*/
ops->retlen = read;
ops->oobretlen = oobread;
if (ret) return ret;
if (mtd->ecc_stats.failed - stats.failed) return -EBADMSG;
/* return max bitflips per ecc step; ONENANDs correct 1 bit only */ return mtd->ecc_stats.corrected != stats.corrected ? 1 : 0;
}
/** * onenand_read_oob_nolock - [MTD Interface] OneNAND read out-of-band * @mtd: MTD device structure * @from: offset to read from * @ops: oob operation description structure * * OneNAND read out-of-band data from the spare area
*/ staticint onenand_read_oob_nolock(struct mtd_info *mtd, loff_t from, struct mtd_oob_ops *ops)
{ struct onenand_chip *this = mtd->priv; struct mtd_ecc_stats stats; int read = 0, thislen, column, oobsize;
size_t len = ops->ooblen; unsignedint mode = ops->mode;
u_char *buf = ops->oobbuf; int ret = 0, readcmd;
from += ops->ooboffs;
pr_debug("%s: from = 0x%08x, len = %i\n", __func__, (unsignedint)from,
(int)len);
/* Initialize return length value */
ops->oobretlen = 0;
/** * onenand_bbt_read_oob - [MTD Interface] OneNAND read out-of-band for bbt scan * @mtd: MTD device structure * @from: offset to read from * @ops: oob operation description structure * * OneNAND read out-of-band data from the spare area for bbt scan
*/ int onenand_bbt_read_oob(struct mtd_info *mtd, loff_t from, struct mtd_oob_ops *ops)
{ struct onenand_chip *this = mtd->priv; int read = 0, thislen, column; int ret = 0, readcmd;
size_t len = ops->ooblen;
u_char *buf = ops->oobbuf;
pr_debug("%s: from = 0x%08x, len = %zi\n", __func__, (unsignedint)from,
len);
/* Initialize return value */
ops->oobretlen = 0;
/* Do not allow reads past end of device */ if (unlikely((from + len) > mtd->size)) {
printk(KERN_ERR "%s: Attempt read beyond end of device\n",
__func__); return ONENAND_BBT_READ_FATAL_ERROR;
}
/* Grab the lock and see if the device is available */
onenand_get_device(mtd, FL_READING);
this->command(mtd, readcmd, to, mtd->oobsize);
onenand_update_bufferram(mtd, to, 0);
status = this->wait(mtd, FL_READING); if (status) return status;
this->read_bufferram(mtd, ONENAND_SPARERAM, oob_buf, 0, mtd->oobsize); for (i = 0; i < mtd->oobsize; i++) if (buf[i] != 0xFF && buf[i] != oob_buf[i]) return -EBADMSG;
return 0;
}
/** * onenand_verify - [GENERIC] verify the chip contents after a write * @mtd: MTD device structure * @buf: the databuffer to verify * @addr: offset to read from * @len: number of bytes to read and compare
*/ staticint onenand_verify(struct mtd_info *mtd, const u_char *buf, loff_t addr, size_t len)
{ struct onenand_chip *this = mtd->priv; int ret = 0; int thislen, column;
for (i = 0; i < 2000; i++) {
interrupt = this->read_word(this->base + ONENAND_REG_INTERRUPT); if (interrupt & ONENAND_INT_MASTER) break;
udelay(10);
}
}
/** * onenand_panic_write - [MTD Interface] write buffer to FLASH in a panic context * @mtd: MTD device structure * @to: offset to write to * @len: number of bytes to write * @retlen: pointer to variable to store the number of written bytes * @buf: the data to write * * Write with ECC
*/ staticint onenand_panic_write(struct mtd_info *mtd, loff_t to, size_t len,
size_t *retlen, const u_char *buf)
{ struct onenand_chip *this = mtd->priv; int column, subpage; int written = 0;
if (this->state == FL_PM_SUSPENDED) return -EBUSY;
/* Wait for any existing operation to clear */
onenand_panic_wait(mtd);
pr_debug("%s: to = 0x%08x, len = %i\n", __func__, (unsignedint)to,
(int)len);
/* Reject writes, which are not page aligned */ if (unlikely(NOTALIGNED(to) || NOTALIGNED(len))) {
printk(KERN_ERR "%s: Attempt to write not page aligned data\n",
__func__); return -EINVAL;
}
column = to & (mtd->writesize - 1);
/* Loop until all data write */ while (written < len) { int thislen = min_t(int, mtd->writesize - column, len - written);
u_char *wbuf = (u_char *) buf;
this->command(mtd, ONENAND_CMD_BUFFERRAM, to, thislen);
this->command(mtd, ONENAND_CMD_PROG, to, mtd->writesize);
onenand_panic_wait(mtd);
/* In partial page write we don't update bufferram */
onenand_update_bufferram(mtd, to, !subpage); if (ONENAND_IS_2PLANE(this)) {
ONENAND_SET_BUFFERRAM1(this);
onenand_update_bufferram(mtd, to + this->writesize, !subpage);
}
written += thislen;
if (written == len) break;
column = 0;
to += thislen;
buf += thislen;
}
*retlen = written; return 0;
}
/** * onenand_fill_auto_oob - [INTERN] oob auto-placement transfer * @mtd: MTD device structure * @oob_buf: oob buffer * @buf: source address * @column: oob offset to write to * @thislen: oob length to write
*/ staticint onenand_fill_auto_oob(struct mtd_info *mtd, u_char *oob_buf, const u_char *buf, int column, int thislen)
{ return mtd_ooblayout_set_databytes(mtd, buf, oob_buf, column, thislen);
}
/** * onenand_write_ops_nolock - [OneNAND Interface] write main and/or out-of-band * @mtd: MTD device structure * @to: offset to write to * @ops: oob operation description structure * * Write main and/or oob with ECC
*/ staticint onenand_write_ops_nolock(struct mtd_info *mtd, loff_t to, struct mtd_oob_ops *ops)
{ struct onenand_chip *this = mtd->priv; int written = 0, column, thislen = 0, subpage = 0; int prev = 0, prevlen = 0, prev_subpage = 0, first = 1; int oobwritten = 0, oobcolumn, thisooblen, oobsize;
size_t len = ops->len;
size_t ooblen = ops->ooblen; const u_char *buf = ops->datbuf; const u_char *oob = ops->oobbuf;
u_char *oobbuf; int ret = 0, cmd;
pr_debug("%s: to = 0x%08x, len = %i\n", __func__, (unsignedint)to,
(int)len);
/* Initialize retlen, in case of early exit */
ops->retlen = 0;
ops->oobretlen = 0;
/* Reject writes, which are not page aligned */ if (unlikely(NOTALIGNED(to) || NOTALIGNED(len))) {
printk(KERN_ERR "%s: Attempt to write not page aligned data\n",
__func__); return -EINVAL;
}
/* Check zero length */ if (!len) return 0;
oobsize = mtd_oobavail(mtd, ops);
oobcolumn = to & (mtd->oobsize - 1);
column = to & (mtd->writesize - 1);
/* Loop until all data write */ while (1) { if (written < len) {
u_char *wbuf = (u_char *) buf;
/* * 2 PLANE, MLC, and Flex-OneNAND do not support * write-while-program feature.
*/ if (!ONENAND_IS_2PLANE(this) && !ONENAND_IS_4KB_PAGE(this) && !first) {
ONENAND_SET_PREV_BUFFERRAM(this);
ret = this->wait(mtd, FL_WRITING);
/* In partial page write we don't update bufferram */
onenand_update_bufferram(mtd, prev, !ret && !prev_subpage); if (ret) {
written -= prevlen;
printk(KERN_ERR "%s: write failed %d\n",
__func__, ret); break;
}
if (written == len) { /* Only check verify write turn on */
ret = onenand_verify(mtd, buf - len, to - len, len); if (ret)
printk(KERN_ERR "%s: verify failed %d\n",
__func__, ret); break;
}
ONENAND_SET_NEXT_BUFFERRAM(this);
}
this->ongoing = 0;
cmd = ONENAND_CMD_PROG;
/* Exclude 1st OTP and OTP blocks for cache program feature */ if (ONENAND_IS_CACHE_PROGRAM(this) &&
likely(onenand_block(this, to) != 0) &&
ONENAND_IS_4KB_PAGE(this) &&
((written + thislen) < len)) {
cmd = ONENAND_CMD_2X_CACHE_PROG;
this->ongoing = 1;
}
this->command(mtd, cmd, to, mtd->writesize);
/* * 2 PLANE, MLC, and Flex-OneNAND wait here
*/ if (ONENAND_IS_2PLANE(this) || ONENAND_IS_4KB_PAGE(this)) {
ret = this->wait(mtd, FL_WRITING);
/* In partial page write we don't update bufferram */
onenand_update_bufferram(mtd, to, !ret && !subpage); if (ret) {
printk(KERN_ERR "%s: write failed %d\n",
__func__, ret); break;
}
/* Only check verify write turn on */
ret = onenand_verify(mtd, buf, to, thislen); if (ret) {
printk(KERN_ERR "%s: verify failed %d\n",
__func__, ret); break;
}
if (unlikely(column >= oobsize)) {
printk(KERN_ERR "%s: Attempted to start write outside oob\n",
__func__); return -EINVAL;
}
/* For compatibility with NAND: Do not allow write past end of page */ if (unlikely(column + len > oobsize)) {
printk(KERN_ERR "%s: Attempt to write past end of page\n",
__func__); return -EINVAL;
}
/* Loop until all data write */ while (written < len) { int thislen = min_t(int, oobsize, len - written);
cond_resched();
this->command(mtd, ONENAND_CMD_BUFFERRAM, to, mtd->oobsize);
/* We send data to spare ram with oobsize
* to prevent byte access */
memset(oobbuf, 0xff, mtd->oobsize); if (mode == MTD_OPS_AUTO_OOB)
onenand_fill_auto_oob(mtd, oobbuf, buf, column, thislen); else
memcpy(oobbuf + column, buf, thislen);
this->write_bufferram(mtd, ONENAND_SPARERAM, oobbuf, 0, mtd->oobsize);
if (ONENAND_IS_4KB_PAGE(this)) { /* Set main area of DataRAM to 0xff*/
memset(this->page_buf, 0xff, mtd->writesize);
this->write_bufferram(mtd, ONENAND_DATARAM,
this->page_buf, 0, mtd->writesize);
}
this->command(mtd, oobcmd, to, mtd->oobsize);
onenand_update_bufferram(mtd, to, 0); if (ONENAND_IS_2PLANE(this)) {
ONENAND_SET_BUFFERRAM1(this);
onenand_update_bufferram(mtd, to + this->writesize, 0);
}
ret = this->wait(mtd, FL_WRITING); if (ret) {
printk(KERN_ERR "%s: write failed %d\n", __func__, ret); break;
}
ret = onenand_verify_oob(mtd, oobbuf, to); if (ret) {
printk(KERN_ERR "%s: verify failed %d\n",
__func__, ret); break;
}
written += thislen; if (written == len) break;
to += mtd->writesize;
buf += thislen;
column = 0;
}
ops->oobretlen = written;
return ret;
}
/** * onenand_write_oob - [MTD Interface] NAND write data and/or out-of-band * @mtd: MTD device structure * @to: offset to write * @ops: oob operation description structure
*/ staticint onenand_write_oob(struct mtd_info *mtd, loff_t to, struct mtd_oob_ops *ops)
{ int ret;
switch (ops->mode) { case MTD_OPS_PLACE_OOB: case MTD_OPS_AUTO_OOB: break; case MTD_OPS_RAW: /* Not implemented yet */ default: return -EINVAL;
}
onenand_get_device(mtd, FL_WRITING); if (ops->datbuf)
ret = onenand_write_ops_nolock(mtd, to, ops); else
ret = onenand_write_oob_nolock(mtd, to, ops);
onenand_release_device(mtd);
return ret;
}
/** * onenand_block_isbad_nolock - [GENERIC] Check if a block is marked bad * @mtd: MTD device structure * @ofs: offset from device start * @allowbbt: 1, if its allowed to access the bbt area * * Check, if the block is bad. Either by reading the bad block table or * calling of the scan function.
*/ staticint onenand_block_isbad_nolock(struct mtd_info *mtd, loff_t ofs, int allowbbt)
{ struct onenand_chip *this = mtd->priv; struct bbm_info *bbm = this->bbm;
/* Return info from the table */ return bbm->isbad_bbt(mtd, ofs, allowbbt);
}
staticint onenand_multiblock_erase_verify(struct mtd_info *mtd, struct erase_info *instr)
{ struct onenand_chip *this = mtd->priv;
loff_t addr = instr->addr; int len = instr->len; unsignedint block_size = (1 << this->erase_shift); int ret = 0;
while (len) {
this->command(mtd, ONENAND_CMD_ERASE_VERIFY, addr, block_size);
ret = this->wait(mtd, FL_VERIFYING_ERASE); if (ret) {
printk(KERN_ERR "%s: Failed verify, block %d\n",
__func__, onenand_block(this, addr));
instr->fail_addr = addr; return -1;
}
len -= block_size;
addr += block_size;
} return 0;
}
/** * onenand_multiblock_erase - [INTERN] erase block(s) using multiblock erase * @mtd: MTD device structure * @instr: erase instruction * @block_size: block size * * Erase one or more blocks up to 64 block at a time
*/ staticint onenand_multiblock_erase(struct mtd_info *mtd, struct erase_info *instr, unsignedint block_size)
{ struct onenand_chip *this = mtd->priv;
loff_t addr = instr->addr; int len = instr->len; int eb_count = 0; int ret = 0; int bdry_block = 0;
/* Pre-check bbs */ while (len) { /* Check if we have a bad block, we do not erase bad blocks */ if (onenand_block_isbad_nolock(mtd, addr, 0)) {
printk(KERN_WARNING "%s: attempt to erase a bad block " "at addr 0x%012llx\n",
__func__, (unsignedlonglong) addr); return -EIO;
}
len -= block_size;
addr += block_size;
}
len = instr->len;
addr = instr->addr;
/* loop over 64 eb batches */ while (len) { struct erase_info verify_instr = *instr; int max_eb_count = MB_ERASE_MAX_BLK_COUNT;
verify_instr.addr = addr;
verify_instr.len = 0;
/* do not cross chip boundary */ if (bdry_block) { int this_block = (addr >> this->erase_shift);
len -= block_size;
addr += block_size;
eb_count++;
}
/* last block of 64-eb series */
cond_resched();
this->command(mtd, ONENAND_CMD_ERASE, addr, block_size);
onenand_invalidate_bufferram(mtd, addr, block_size);
ret = this->wait(mtd, FL_ERASING); /* Check if it is write protected */ if (ret) {
printk(KERN_ERR "%s: Failed erase, block %d\n",
__func__, onenand_block(this, addr));
instr->fail_addr = MTD_FAIL_ADDR_UNKNOWN; return -EIO;
}
len -= block_size;
addr += block_size;
eb_count++;
/** * onenand_block_by_block_erase - [INTERN] erase block(s) using regular erase * @mtd: MTD device structure * @instr: erase instruction * @region: erase region * @block_size: erase block size * * Erase one or more blocks one block at a time
*/ staticint onenand_block_by_block_erase(struct mtd_info *mtd, struct erase_info *instr, struct mtd_erase_region_info *region, unsignedint block_size)
{ struct onenand_chip *this = mtd->priv;
loff_t addr = instr->addr; int len = instr->len;
loff_t region_end = 0; int ret = 0;
if (region) { /* region is set for Flex-OneNAND */
region_end = region->offset + region->erasesize * region->numblocks;
}
/* Loop through the blocks */ while (len) {
cond_resched();
/* Check if we have a bad block, we do not erase bad blocks */ if (onenand_block_isbad_nolock(mtd, addr, 0)) {
printk(KERN_WARNING "%s: attempt to erase a bad block " "at addr 0x%012llx\n",
__func__, (unsignedlonglong) addr); return -EIO;
}
if (FLEXONENAND(this)) { /* Find the eraseregion of this address */ int i = flexonenand_region(mtd, addr);
region = &mtd->eraseregions[i];
block_size = region->erasesize;
/* Start address within region must align on block boundary. * Erase region's start offset is always block start address.
*/
region_offset = region->offset;
} else
block_size = 1 << this->erase_shift;
/* Start address must align on block boundary */ if (unlikely((addr - region_offset) & (block_size - 1))) {
printk(KERN_ERR "%s: Unaligned address\n", __func__); return -EINVAL;
}
/* Length must align on block boundary */ if (unlikely(len & (block_size - 1))) {
printk(KERN_ERR "%s: Length not block aligned\n", __func__); return -EINVAL;
}
/* Grab the lock and see if the device is available */
onenand_get_device(mtd, FL_ERASING);
if (ONENAND_IS_4KB_PAGE(this) || region ||
instr->len < MB_ERASE_MIN_BLK_COUNT * block_size) { /* region is set for Flex-OneNAND (no mb erase) */
ret = onenand_block_by_block_erase(mtd, instr,
region, block_size);
} else {
ret = onenand_multiblock_erase(mtd, instr, block_size);
}
/* Deselect and wake up anyone waiting on the device */
onenand_release_device(mtd);
return ret;
}
/** * onenand_sync - [MTD Interface] sync * @mtd: MTD device structure * * Sync is actually a wait for chip ready function
*/ staticvoid onenand_sync(struct mtd_info *mtd)
{
pr_debug("%s: called\n", __func__);
/* Grab the lock and see if the device is available */
onenand_get_device(mtd, FL_SYNCING);
/* Release it and go back */
onenand_release_device(mtd);
}
/** * onenand_block_isbad - [MTD Interface] Check whether the block at the given offset is bad * @mtd: MTD device structure * @ofs: offset relative to mtd start * * Check whether the block is bad
*/ staticint onenand_block_isbad(struct mtd_info *mtd, loff_t ofs)
{ int ret;
/** * onenand_default_block_markbad - [DEFAULT] mark a block bad * @mtd: MTD device structure * @ofs: offset from device start * * This is the default implementation, which can be overridden by * a hardware specific driver.
*/ staticint onenand_default_block_markbad(struct mtd_info *mtd, loff_t ofs)
{ struct onenand_chip *this = mtd->priv; struct bbm_info *bbm = this->bbm;
u_char buf[2] = {0, 0}; struct mtd_oob_ops ops = {
.mode = MTD_OPS_PLACE_OOB,
.ooblen = 2,
.oobbuf = buf,
.ooboffs = 0,
}; int block;
/* Get block number */
block = onenand_block(this, ofs); if (bbm->bbt)
bbm->bbt[block >> 2] |= 0x01 << ((block & 0x03) << 1);
/* We write two bytes, so we don't have to mess with 16-bit access */
ofs += mtd->oobsize + (this->badblockpos & ~0x01); /* FIXME : What to do when marking SLC block in partition * with MLC erasesize? For now, it is not advisable to * create partitions containing both SLC and MLC regions.
*/ return onenand_write_oob_nolock(mtd, ofs, &ops);
}
/** * onenand_block_markbad - [MTD Interface] Mark the block at the given offset as bad * @mtd: MTD device structure * @ofs: offset relative to mtd start * * Mark the block as bad
*/ staticint onenand_block_markbad(struct mtd_info *mtd, loff_t ofs)
{ struct onenand_chip *this = mtd->priv; int ret;
ret = onenand_block_isbad(mtd, ofs); if (ret) { /* If it was bad already, return success and do nothing */ if (ret > 0) return 0; return ret;
}
onenand_get_device(mtd, FL_WRITING);
ret = this->block_markbad(mtd, ofs);
onenand_release_device(mtd); return ret;
}
/** * onenand_do_lock_cmd - [OneNAND Interface] Lock or unlock block(s) * @mtd: MTD device structure * @ofs: offset relative to mtd start * @len: number of bytes to lock or unlock * @cmd: lock or unlock command * * Lock or unlock one or more blocks
*/ staticint onenand_do_lock_cmd(struct mtd_info *mtd, loff_t ofs, size_t len, int cmd)
{ struct onenand_chip *this = mtd->priv; int start, end, block, value, status; int wp_status_mask;
/* Don't check lock status */ if (this->options & ONENAND_SKIP_UNLOCK_CHECK) return;
/* Check lock status */ if (onenand_check_lock_status(this)) return;
/* Workaround for all block unlock in DDP */ if (ONENAND_IS_DDP(this) && !FLEXONENAND(this)) { /* All blocks on another chip */
ofs = this->chipsize >> 1;
len = this->chipsize >> 1;
}
}
/** * onenand_otp_command - Send OTP specific command to OneNAND device * @mtd: MTD device structure * @cmd: the command to be sent * @addr: offset to read from or write to * @len: number of bytes to read or write
*/ staticint onenand_otp_command(struct mtd_info *mtd, int cmd, loff_t addr,
size_t len)
{ struct onenand_chip *this = mtd->priv; int value, block, page;
if (ONENAND_IS_2PLANE(this)) { /* Make the even block number */
block &= ~1; /* Is it the odd plane? */ if (addr & this->writesize)
block++;
page >>= 1;
}
page &= this->page_mask; break;
}
if (block != -1) { /* Write 'DFS, FBA' of Flash */
value = onenand_block_address(this, block);
this->write_word(value, this->base +
ONENAND_REG_START_ADDRESS1);
}
if (page != -1) { /* Now we use page size operation */ int sectors = 4, count = 4; int dataram;
/* We send data to spare ram with oobsize
* to prevent byte access */
memcpy(oobbuf + column, buf, thislen);
/* * Write Data into DataRAM * Add: 8th Word * in sector0/spare/page0 * DQ=XXFCh
*/
this->write_bufferram(mtd, ONENAND_SPARERAM,
oobbuf, 0, mtd->oobsize);
onenand_otp_command(mtd, ONENAND_CMD_PROGOOB, to, mtd->oobsize);
onenand_update_bufferram(mtd, to, 0); if (ONENAND_IS_2PLANE(this)) {
ONENAND_SET_BUFFERRAM1(this);
onenand_update_bufferram(mtd, to + this->writesize, 0);
}
ret = this->wait(mtd, FL_WRITING); if (ret) {
printk(KERN_ERR "%s: write failed %d\n", __func__, ret); break;
}
/** * do_otp_write - [DEFAULT] Write OTP block area * @mtd: MTD device structure * @to: The offset to write * @len: number of bytes to write * @retlen: pointer to variable to store the number of write bytes * @buf: the databuffer to put/get data * * Write OTP block area.
*/ staticint do_otp_write(struct mtd_info *mtd, loff_t to, size_t len,
size_t *retlen, u_char *buf)
{ struct onenand_chip *this = mtd->priv; unsignedchar *pbuf = buf; int ret; struct mtd_oob_ops ops = { };
/* Force buffer page aligned */ if (len < mtd->writesize) {
memcpy(this->page_buf, buf, len);
memset(this->page_buf + len, 0xff, mtd->writesize - len);
pbuf = this->page_buf;
len = mtd->writesize;
}
/** * do_otp_lock - [DEFAULT] Lock OTP block area * @mtd: MTD device structure * @from: The offset to lock * @len: number of bytes to lock * @retlen: pointer to variable to store the number of lock bytes * @buf: the databuffer to put/get data * * Lock OTP block area.
*/ staticint do_otp_lock(struct mtd_info *mtd, loff_t from, size_t len,
size_t *retlen, u_char *buf)
{ struct onenand_chip *this = mtd->priv; struct mtd_oob_ops ops = { }; int ret;
if (FLEXONENAND(this)) {
/* Enter OTP access mode */
this->command(mtd, ONENAND_CMD_OTP_ACCESS, 0, 0);
this->wait(mtd, FL_OTPING); /* * For Flex-OneNAND, we write lock mark to 1st word of sector 4 of * main area of page 49.
*/
ops.len = mtd->writesize;
ops.ooblen = 0;
ops.datbuf = buf;
ops.oobbuf = NULL;
ret = onenand_write_ops_nolock(mtd, mtd->writesize * 49, &ops);
*retlen = ops.retlen;
/** * onenand_otp_walk - [DEFAULT] Handle OTP operation * @mtd: MTD device structure * @from: The offset to read/write * @len: number of bytes to read/write * @retlen: pointer to variable to store the number of read bytes * @buf: the databuffer to put/get data * @action: do given action * @mode: specify user and factory * * Handle OTP operation.
*/ staticint onenand_otp_walk(struct mtd_info *mtd, loff_t from, size_t len,
size_t *retlen, u_char *buf,
otp_op_t action, int mode)
{ struct onenand_chip *this = mtd->priv; int otp_pages; int density; int ret = 0;
*retlen = 0;
density = onenand_get_density(this->device_id); if (density < ONENAND_DEVICE_DENSITY_512Mb)
otp_pages = 20; else
otp_pages = 50;
if (mode == MTD_OTP_FACTORY) {
from += mtd->writesize * otp_pages;
otp_pages = ONENAND_PAGES_PER_BLOCK - otp_pages;
}
/* Check User/Factory boundary */ if (mode == MTD_OTP_USER) { if (mtd->writesize * otp_pages < from + len) return 0;
} else { if (mtd->writesize * otp_pages < len) return 0;
}
onenand_get_device(mtd, FL_OTPING); while (len > 0 && otp_pages > 0) { if (!action) { /* OTP Info functions */ struct otp_info *otpinfo;
len -= sizeof(struct otp_info); if (len <= 0) {
ret = -ENOSPC; break;
}
ret = action(mtd, from, len, &tmp_retlen, buf); if (ret) break;
buf += tmp_retlen;
len -= tmp_retlen;
*retlen += tmp_retlen;
}
otp_pages--;
}
onenand_release_device(mtd);
return ret;
}
/** * onenand_get_fact_prot_info - [MTD Interface] Read factory OTP info * @mtd: MTD device structure * @len: number of bytes to read * @retlen: pointer to variable to store the number of read bytes * @buf: the databuffer to put/get data * * Read factory OTP info.
*/ staticint onenand_get_fact_prot_info(struct mtd_info *mtd, size_t len,
size_t *retlen, struct otp_info *buf)
{ return onenand_otp_walk(mtd, 0, len, retlen, (u_char *) buf, NULL,
MTD_OTP_FACTORY);
}
/** * onenand_read_fact_prot_reg - [MTD Interface] Read factory OTP area * @mtd: MTD device structure * @from: The offset to read * @len: number of bytes to read * @retlen: pointer to variable to store the number of read bytes * @buf: the databuffer to put/get data * * Read factory OTP area.
*/ staticint onenand_read_fact_prot_reg(struct mtd_info *mtd, loff_t from,
size_t len, size_t *retlen, u_char *buf)
{ return onenand_otp_walk(mtd, from, len, retlen, buf, do_otp_read, MTD_OTP_FACTORY);
}
/** * onenand_get_user_prot_info - [MTD Interface] Read user OTP info * @mtd: MTD device structure * @retlen: pointer to variable to store the number of read bytes * @len: number of bytes to read * @buf: the databuffer to put/get data * * Read user OTP info.
*/ staticint onenand_get_user_prot_info(struct mtd_info *mtd, size_t len,
size_t *retlen, struct otp_info *buf)
{ return onenand_otp_walk(mtd, 0, len, retlen, (u_char *) buf, NULL,
MTD_OTP_USER);
}
/** * onenand_read_user_prot_reg - [MTD Interface] Read user OTP area * @mtd: MTD device structure * @from: The offset to read * @len: number of bytes to read * @retlen: pointer to variable to store the number of read bytes * @buf: the databuffer to put/get data * * Read user OTP area.
*/ staticint onenand_read_user_prot_reg(struct mtd_info *mtd, loff_t from,
size_t len, size_t *retlen, u_char *buf)
{ return onenand_otp_walk(mtd, from, len, retlen, buf, do_otp_read, MTD_OTP_USER);
}
/** * onenand_write_user_prot_reg - [MTD Interface] Write user OTP area * @mtd: MTD device structure * @from: The offset to write * @len: number of bytes to write * @retlen: pointer to variable to store the number of write bytes * @buf: the databuffer to put/get data * * Write user OTP area.
*/ staticint onenand_write_user_prot_reg(struct mtd_info *mtd, loff_t from,
size_t len, size_t *retlen, const u_char *buf)
{ return onenand_otp_walk(mtd, from, len, retlen, (u_char *)buf,
do_otp_write, MTD_OTP_USER);
}
/** * onenand_lock_user_prot_reg - [MTD Interface] Lock user OTP area * @mtd: MTD device structure * @from: The offset to lock * @len: number of bytes to unlock * * Write lock mark on spare area in page 0 in OTP block
*/ staticint onenand_lock_user_prot_reg(struct mtd_info *mtd, loff_t from,
size_t len)
{ struct onenand_chip *this = mtd->priv;
u_char *buf = FLEXONENAND(this) ? this->page_buf : this->oob_buf;
size_t retlen; int ret; unsignedint otp_lock_offset = ONENAND_OTP_LOCK_OFFSET;
memset(buf, 0xff, FLEXONENAND(this) ? this->writesize
: mtd->oobsize); /* * Write lock mark to 8th word of sector0 of page0 of the spare0. * We write 16 bytes spare area instead of 2 bytes. * For Flex-OneNAND, we write lock mark to 1st word of sector 4 of * main area of page 49.
*/
from = 0;
len = FLEXONENAND(this) ? mtd->writesize : 16;
/* * Note: OTP lock operation * OTP block : 0xXXFC XX 1111 1100 * 1st block : 0xXXF3 (If chip support) XX 1111 0011 * Both : 0xXXF0 (If chip support) XX 1111 0000
*/ if (FLEXONENAND(this))
otp_lock_offset = FLEXONENAND_OTP_LOCK_OFFSET;
ret = onenand_otp_walk(mtd, from, len, &retlen, buf, do_otp_lock, MTD_OTP_USER);
return ret ? : retlen;
}
#endif/* CONFIG_MTD_ONENAND_OTP */
/** * onenand_check_features - Check and set OneNAND features * @mtd: MTD data structure * * Check and set OneNAND features * - lock scheme * - two plane
*/ staticvoid onenand_check_features(struct mtd_info *mtd)
{ struct onenand_chip *this = mtd->priv; unsignedint density, process, numbufs;
/* Lock scheme depends on density and process */
density = onenand_get_density(this->device_id);
process = this->version_id >> ONENAND_VERSION_PROCESS_SHIFT;
numbufs = this->read_word(this->base + ONENAND_REG_NUM_BUFFERS) >> 8;
/* Lock scheme */ switch (density) { case ONENAND_DEVICE_DENSITY_8Gb:
this->options |= ONENAND_HAS_NOP_1;
fallthrough; case ONENAND_DEVICE_DENSITY_4Gb: if (ONENAND_IS_DDP(this))
this->options |= ONENAND_HAS_2PLANE; elseif (numbufs == 1) {
this->options |= ONENAND_HAS_4KB_PAGE;
this->options |= ONENAND_HAS_CACHE_PROGRAM; /* * There are two different 4KiB pagesize chips * and no way to detect it by H/W config values. * * To detect the correct NOP for each chips, * It should check the version ID as workaround. * * Now it has as following * KFM4G16Q4M has NOP 4 with version ID 0x0131 * KFM4G16Q5M has NOP 1 with versoin ID 0x013e
*/ if ((this->version_id & 0xf) == 0xe)
this->options |= ONENAND_HAS_NOP_1;
}
this->options |= ONENAND_HAS_UNLOCK_ALL; break;
case ONENAND_DEVICE_DENSITY_2Gb: /* 2Gb DDP does not have 2 plane */ if (!ONENAND_IS_DDP(this))
this->options |= ONENAND_HAS_2PLANE;
this->options |= ONENAND_HAS_UNLOCK_ALL; break;
case ONENAND_DEVICE_DENSITY_1Gb: /* A-Die has all block unlock */ if (process)
this->options |= ONENAND_HAS_UNLOCK_ALL; break;
default: /* Some OneNAND has continuous lock scheme */ if (!process)
this->options |= ONENAND_HAS_CONT_LOCK; break;
}
/* The MLC has 4KiB pagesize. */ if (ONENAND_IS_MLC(this))
this->options |= ONENAND_HAS_4KB_PAGE;
if (ONENAND_IS_4KB_PAGE(this))
this->options &= ~ONENAND_HAS_2PLANE;
if (FLEXONENAND(this)) {
this->options &= ~ONENAND_HAS_CONT_LOCK;
this->options |= ONENAND_HAS_UNLOCK_ALL;
}
if (this->options & ONENAND_HAS_CONT_LOCK)
printk(KERN_DEBUG "Lock scheme is Continuous Lock\n"); if (this->options & ONENAND_HAS_UNLOCK_ALL)
printk(KERN_DEBUG "Chip support all block unlock\n"); if (this->options & ONENAND_HAS_2PLANE)
printk(KERN_DEBUG "Chip has 2 plane\n"); if (this->options & ONENAND_HAS_4KB_PAGE)
printk(KERN_DEBUG "Chip has 4KiB pagesize\n"); if (this->options & ONENAND_HAS_CACHE_PROGRAM)
printk(KERN_DEBUG "Chip has cache program feature\n");
}
/** * onenand_print_device_info - Print device & version ID * @device: device ID * @version: version ID * * Print device & version ID
*/ staticvoid onenand_print_device_info(int device, int version)
{ int vcc, demuxed, ddp, density, flexonenand;
/** * flexonenand_check_blocks_erased - Check if blocks are erased * @mtd: mtd info structure * @start: first erase block to check * @end: last erase block to check * * Converting an unerased block from MLC to SLC * causes byte values to change. Since both data and its ECC * have changed, reads on the block give uncorrectable error. * This might lead to the block being detected as bad. * * Avoid this by ensuring that the block to be converted is * erased.
*/ staticint flexonenand_check_blocks_erased(struct mtd_info *mtd, int start, int end)
{ struct onenand_chip *this = mtd->priv; int i, ret; int block; struct mtd_oob_ops ops = {
.mode = MTD_OPS_PLACE_OOB,
.ooboffs = 0,
.ooblen = mtd->oobsize,
.datbuf = NULL,
.oobbuf = this->oob_buf,
};
loff_t addr;
printk(KERN_DEBUG "Check blocks from %d to %d\n", start, end);
for (block = start; block <= end; block++) {
addr = flexonenand_addr(this, block); if (onenand_block_isbad_nolock(mtd, addr, 0)) continue;
/* * Since main area write results in ECC write to spare, * it is sufficient to check only ECC bytes for change.
*/
ret = onenand_read_oob_nolock(mtd, addr, &ops); if (ret) return ret;
for (i = 0; i < mtd->oobsize; i++) if (this->oob_buf[i] != 0xff) break;
if (i != mtd->oobsize) {
printk(KERN_WARNING "%s: Block %d not erased.\n",
__func__, block); return 1;
}
}
return 0;
}
/* * flexonenand_set_boundary - Writes the SLC boundary
*/ staticint flexonenand_set_boundary(struct mtd_info *mtd, int die, int boundary, int lock)
{ struct onenand_chip *this = mtd->priv; int ret, density, blksperdie, old, new, thisboundary;
loff_t addr;
/* Change only once for SDP Flex-OneNAND */ if (die && (!ONENAND_IS_DDP(this))) return 0;
/* boundary value of -1 indicates no required change */ if (boundary < 0 || boundary == this->boundary[die]) return 0;
this->command(mtd, ONENAND_CMD_ERASE, addr, 0);
ret = this->wait(mtd, FL_ERASING); if (ret) {
printk(KERN_ERR "%s: Failed PI erase for Die %d\n",
__func__, die); goto out;
}
this->write_word(boundary, this->base + ONENAND_DATARAM);
this->command(mtd, ONENAND_CMD_PROG, addr, 0);
ret = this->wait(mtd, FL_WRITING); if (ret) {
printk(KERN_ERR "%s: Failed PI write for Die %d\n",
__func__, die); goto out;
}
this->command(mtd, FLEXONENAND_CMD_PI_UPDATE, die, 0);
ret = this->wait(mtd, FL_WRITING);
out:
this->write_word(ONENAND_CMD_RESET, this->base + ONENAND_REG_COMMAND);
this->wait(mtd, FL_RESETTING); if (!ret) /* Recalculate device size on boundary change*/
flexonenand_get_size(mtd);
return ret;
}
/** * onenand_chip_probe - [OneNAND Interface] The generic chip probe * @mtd: MTD device structure * * OneNAND detection method: * Compare the values from command with ones from register
*/ staticint onenand_chip_probe(struct mtd_info *mtd)
{ struct onenand_chip *this = mtd->priv; int bram_maf_id, bram_dev_id, maf_id, dev_id; int syscfg;
/* Save system configuration 1 */
syscfg = this->read_word(this->base + ONENAND_REG_SYS_CFG1); /* Clear Sync. Burst Read mode to read BootRAM */
this->write_word((syscfg & ~ONENAND_SYS_CFG1_SYNC_READ & ~ONENAND_SYS_CFG1_SYNC_WRITE), this->base + ONENAND_REG_SYS_CFG1);
/* Send the command for reading device ID from BootRAM */
this->write_word(ONENAND_CMD_READID, this->base + ONENAND_BOOTRAM);
/* Check OneNAND features */
onenand_check_features(mtd);
density = onenand_get_density(dev_id); if (FLEXONENAND(this)) {
this->dies = ONENAND_IS_DDP(this) ? 2 : 1; /* Maximum possible erase regions */
mtd->numeraseregions = this->dies << 1;
mtd->eraseregions =
kcalloc(this->dies << 1, sizeof(struct mtd_erase_region_info),
GFP_KERNEL); if (!mtd->eraseregions) return -ENOMEM;
}
/* * For Flex-OneNAND, chipsize represents maximum possible device size. * mtd->size represents the actual device size.
*/
this->chipsize = (16 << density) << 20;
/* OneNAND page size & block size */ /* The data buffer size is equal to page size */
mtd->writesize = this->read_word(this->base + ONENAND_REG_DATA_BUFFER_SIZE); /* We use the full BufferRAM */ if (ONENAND_IS_4KB_PAGE(this))
mtd->writesize <<= 1;
mtd->oobsize = mtd->writesize >> 5; /* Pages per a block are always 64 in OneNAND */
mtd->erasesize = mtd->writesize << 6; /* * Flex-OneNAND SLC area has 64 pages per block. * Flex-OneNAND MLC area has 128 pages per block. * Expose MLC erase size to find erase_shift and page_mask.
*/ if (FLEXONENAND(this))
mtd->erasesize <<= 1;
this->erase_shift = ffs(mtd->erasesize) - 1;
this->page_shift = ffs(mtd->writesize) - 1;
this->page_mask = (1 << (this->erase_shift - this->page_shift)) - 1; /* Set density mask. it is used for DDP */ if (ONENAND_IS_DDP(this))
this->density_mask = this->chipsize >> (this->erase_shift + 1); /* It's real page size */
this->writesize = mtd->writesize;
/* REVISIT: Multichip handling */
if (FLEXONENAND(this))
flexonenand_get_size(mtd); else
mtd->size = this->chipsize;
/* * We emulate the 4KiB page and 256KiB erase block size * But oobsize is still 64 bytes. * It is only valid if you turn on 2X program support, * Otherwise it will be ignored by compiler.
*/ if (ONENAND_IS_2PLANE(this)) {
mtd->writesize <<= 1;
mtd->erasesize <<= 1;
}
if (this->state == FL_PM_SUSPENDED)
onenand_release_device(mtd); else
printk(KERN_ERR "%s: resume() called for the chip which is not " "in suspended state\n", __func__);
}
/** * onenand_scan - [OneNAND Interface] Scan for the OneNAND device * @mtd: MTD device structure * @maxchips: Number of chips to scan for * * This fills out all the not initialized function pointers * with the defaults. * The flash ID is read and the mtd/chip structures are * filled with the appropriate values.
*/ int onenand_scan(struct mtd_info *mtd, int maxchips)
{ int i, ret; struct onenand_chip *this = mtd->priv;
if (!this->read_word)
this->read_word = onenand_readw; if (!this->write_word)
this->write_word = onenand_writew;
if (!this->command)
this->command = onenand_command; if (!this->wait)
onenand_setup_wait(mtd); if (!this->bbt_wait)
this->bbt_wait = onenand_bbt_wait; if (!this->unlock_all)
this->unlock_all = onenand_unlock_all;
if (!this->chip_probe)
this->chip_probe = onenand_chip_probe;
if (!this->read_bufferram)
this->read_bufferram = onenand_read_bufferram; if (!this->write_bufferram)
this->write_bufferram = onenand_write_bufferram;
if (!this->block_markbad)
this->block_markbad = onenand_default_block_markbad; if (!this->scan_bbt)
this->scan_bbt = onenand_default_bbt;
if (onenand_probe(mtd)) return -ENXIO;
/* Set Sync. Burst Read after probing */ if (this->mmcontrol) {
printk(KERN_INFO "OneNAND Sync. Burst Read support\n");
this->read_bufferram = onenand_sync_read_bufferram;
}
/* Allocate buffers, if necessary */ if (!this->page_buf) {
this->page_buf = kzalloc(mtd->writesize, GFP_KERNEL); if (!this->page_buf) return -ENOMEM; #ifdef CONFIG_MTD_ONENAND_VERIFY_WRITE
this->verify_buf = kzalloc(mtd->writesize, GFP_KERNEL); if (!this->verify_buf) {
kfree(this->page_buf); return -ENOMEM;
} #endif
this->options |= ONENAND_PAGEBUF_ALLOC;
} if (!this->oob_buf) {
this->oob_buf = kzalloc(mtd->oobsize, GFP_KERNEL); if (!this->oob_buf) { if (this->options & ONENAND_PAGEBUF_ALLOC) {
this->options &= ~ONENAND_PAGEBUF_ALLOC; #ifdef CONFIG_MTD_ONENAND_VERIFY_WRITE
kfree(this->verify_buf); #endif
kfree(this->page_buf);
} return -ENOMEM;
}
this->options |= ONENAND_OOBBUF_ALLOC;
}
/* * The number of bytes available for a client to place data into * the out of band area
*/
ret = mtd_ooblayout_count_freebytes(mtd); if (ret < 0)
ret = 0;
/* Unlock whole block */ if (!(this->options & ONENAND_SKIP_INITIAL_UNLOCKING))
this->unlock_all(mtd);
/* Set the bad block marker position */
this->badblockpos = ONENAND_BADBLOCK_POS;
ret = this->scan_bbt(mtd); if ((!FLEXONENAND(this)) || ret) return ret;
/* Change Flex-OneNAND boundaries if required */ for (i = 0; i < MAX_DIES; i++)
flexonenand_set_boundary(mtd, i, flex_bdry[2 * i],
flex_bdry[(2 * i) + 1]);
return 0;
}
/** * onenand_release - [OneNAND Interface] Free resources held by the OneNAND device * @mtd: MTD device structure
*/ void onenand_release(struct mtd_info *mtd)
{ struct onenand_chip *this = mtd->priv;
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.
