Lines Matching refs:chip
109 struct nand_chip *chip = mtd->priv; in check_offs_len() local
113 if (ofs & ((1ULL << chip->phys_erase_shift) - 1)) { in check_offs_len()
119 if (len & ((1ULL << chip->phys_erase_shift) - 1)) { in check_offs_len()
135 struct nand_chip *chip = mtd->priv; in nand_release_device() local
138 spin_lock(&chip->controller->lock); in nand_release_device()
139 chip->controller->active = NULL; in nand_release_device()
140 chip->state = FL_READY; in nand_release_device()
141 wake_up(&chip->controller->wq); in nand_release_device()
142 spin_unlock(&chip->controller->lock); in nand_release_device()
153 struct nand_chip *chip = mtd->priv; in nand_read_byte() local
154 return readb(chip->IO_ADDR_R); in nand_read_byte()
166 struct nand_chip *chip = mtd->priv; in nand_read_byte16() local
167 return (uint8_t) cpu_to_le16(readw(chip->IO_ADDR_R)); in nand_read_byte16()
178 struct nand_chip *chip = mtd->priv; in nand_read_word() local
179 return readw(chip->IO_ADDR_R); in nand_read_word()
191 struct nand_chip *chip = mtd->priv; in nand_select_chip() local
195 chip->cmd_ctrl(mtd, NAND_CMD_NONE, 0 | NAND_CTRL_CHANGE); in nand_select_chip()
214 struct nand_chip *chip = mtd->priv; in nand_write_byte() local
216 chip->write_buf(mtd, &byte, 1); in nand_write_byte()
228 struct nand_chip *chip = mtd->priv; in nand_write_byte16() local
247 chip->write_buf(mtd, (uint8_t *)&word, 2); in nand_write_byte16()
260 struct nand_chip *chip = mtd->priv; in nand_write_buf() local
262 iowrite8_rep(chip->IO_ADDR_W, buf, len); in nand_write_buf()
275 struct nand_chip *chip = mtd->priv; in nand_read_buf() local
277 ioread8_rep(chip->IO_ADDR_R, buf, len); in nand_read_buf()
290 struct nand_chip *chip = mtd->priv; in nand_write_buf16() local
293 iowrite16_rep(chip->IO_ADDR_W, p, len >> 1); in nand_write_buf16()
306 struct nand_chip *chip = mtd->priv; in nand_read_buf16() local
309 ioread16_rep(chip->IO_ADDR_R, p, len >> 1); in nand_read_buf16()
323 struct nand_chip *chip = mtd->priv; in nand_block_bad() local
326 if (chip->bbt_options & NAND_BBT_SCANLASTPAGE) in nand_block_bad()
329 page = (int)(ofs >> chip->page_shift) & chip->pagemask; in nand_block_bad()
332 chipnr = (int)(ofs >> chip->chip_shift); in nand_block_bad()
337 chip->select_chip(mtd, chipnr); in nand_block_bad()
341 if (chip->options & NAND_BUSWIDTH_16) { in nand_block_bad()
342 chip->cmdfunc(mtd, NAND_CMD_READOOB, in nand_block_bad()
343 chip->badblockpos & 0xFE, page); in nand_block_bad()
344 bad = cpu_to_le16(chip->read_word(mtd)); in nand_block_bad()
345 if (chip->badblockpos & 0x1) in nand_block_bad()
350 chip->cmdfunc(mtd, NAND_CMD_READOOB, chip->badblockpos, in nand_block_bad()
352 bad = chip->read_byte(mtd); in nand_block_bad()
355 if (likely(chip->badblockbits == 8)) in nand_block_bad()
358 res = hweight8(bad) < chip->badblockbits; in nand_block_bad()
360 page = (int)(ofs >> chip->page_shift) & chip->pagemask; in nand_block_bad()
362 } while (!res && i < 2 && (chip->bbt_options & NAND_BBT_SCAN2NDPAGE)); in nand_block_bad()
365 chip->select_chip(mtd, -1); in nand_block_bad()
383 struct nand_chip *chip = mtd->priv; in nand_default_block_markbad() local
390 ops.ooboffs = chip->badblockpos; in nand_default_block_markbad()
391 if (chip->options & NAND_BUSWIDTH_16) { in nand_default_block_markbad()
400 if (chip->bbt_options & NAND_BBT_SCANLASTPAGE) in nand_default_block_markbad()
409 } while ((chip->bbt_options & NAND_BBT_SCAN2NDPAGE) && i < 2); in nand_default_block_markbad()
433 struct nand_chip *chip = mtd->priv; in nand_block_markbad_lowlevel() local
436 if (!(chip->bbt_options & NAND_BBT_NO_OOB_BBM)) { in nand_block_markbad_lowlevel()
443 einfo.len = 1ULL << chip->phys_erase_shift; in nand_block_markbad_lowlevel()
448 ret = chip->block_markbad(mtd, ofs); in nand_block_markbad_lowlevel()
453 if (chip->bbt) { in nand_block_markbad_lowlevel()
474 struct nand_chip *chip = mtd->priv; in nand_check_wp() local
477 if (chip->options & NAND_BROKEN_XD) in nand_check_wp()
481 chip->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1); in nand_check_wp()
482 return (chip->read_byte(mtd) & NAND_STATUS_WP) ? 0 : 1; in nand_check_wp()
494 struct nand_chip *chip = mtd->priv; in nand_block_isreserved() local
496 if (!chip->bbt) in nand_block_isreserved()
515 struct nand_chip *chip = mtd->priv; in nand_block_checkbad() local
517 if (!chip->bbt) in nand_block_checkbad()
518 return chip->block_bad(mtd, ofs, getchip); in nand_block_checkbad()
534 struct nand_chip *chip = mtd->priv; in panic_nand_wait_ready() local
539 if (chip->dev_ready(mtd)) in panic_nand_wait_ready()
554 struct nand_chip *chip = mtd->priv; in nand_wait_ready() local
564 if (chip->dev_ready(mtd)) in nand_wait_ready()
585 register struct nand_chip *chip = mtd->priv; in nand_wait_status_ready() local
589 if ((chip->read_byte(mtd) & NAND_STATUS_READY)) in nand_wait_status_ready()
608 register struct nand_chip *chip = mtd->priv; in nand_command() local
626 chip->cmd_ctrl(mtd, readcmd, ctrl); in nand_command()
629 chip->cmd_ctrl(mtd, command, ctrl); in nand_command()
636 if (chip->options & NAND_BUSWIDTH_16 && in nand_command()
639 chip->cmd_ctrl(mtd, column, ctrl); in nand_command()
643 chip->cmd_ctrl(mtd, page_addr, ctrl); in nand_command()
645 chip->cmd_ctrl(mtd, page_addr >> 8, ctrl); in nand_command()
647 if (chip->chipsize > (32 << 20)) in nand_command()
648 chip->cmd_ctrl(mtd, page_addr >> 16, ctrl); in nand_command()
650 chip->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE); in nand_command()
666 if (chip->dev_ready) in nand_command()
668 udelay(chip->chip_delay); in nand_command()
669 chip->cmd_ctrl(mtd, NAND_CMD_STATUS, in nand_command()
671 chip->cmd_ctrl(mtd, in nand_command()
683 if (!chip->dev_ready) { in nand_command()
684 udelay(chip->chip_delay); in nand_command()
711 register struct nand_chip *chip = mtd->priv; in nand_command_lp() local
720 chip->cmd_ctrl(mtd, command, NAND_NCE | NAND_CLE | NAND_CTRL_CHANGE); in nand_command_lp()
728 if (chip->options & NAND_BUSWIDTH_16 && in nand_command_lp()
731 chip->cmd_ctrl(mtd, column, ctrl); in nand_command_lp()
733 chip->cmd_ctrl(mtd, column >> 8, ctrl); in nand_command_lp()
736 chip->cmd_ctrl(mtd, page_addr, ctrl); in nand_command_lp()
737 chip->cmd_ctrl(mtd, page_addr >> 8, in nand_command_lp()
740 if (chip->chipsize > (128 << 20)) in nand_command_lp()
741 chip->cmd_ctrl(mtd, page_addr >> 16, in nand_command_lp()
745 chip->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE); in nand_command_lp()
763 if (chip->dev_ready) in nand_command_lp()
765 udelay(chip->chip_delay); in nand_command_lp()
766 chip->cmd_ctrl(mtd, NAND_CMD_STATUS, in nand_command_lp()
768 chip->cmd_ctrl(mtd, NAND_CMD_NONE, in nand_command_lp()
776 chip->cmd_ctrl(mtd, NAND_CMD_RNDOUTSTART, in nand_command_lp()
778 chip->cmd_ctrl(mtd, NAND_CMD_NONE, in nand_command_lp()
783 chip->cmd_ctrl(mtd, NAND_CMD_READSTART, in nand_command_lp()
785 chip->cmd_ctrl(mtd, NAND_CMD_NONE, in nand_command_lp()
794 if (!chip->dev_ready) { in nand_command_lp()
795 udelay(chip->chip_delay); in nand_command_lp()
817 static void panic_nand_get_device(struct nand_chip *chip, in panic_nand_get_device() argument
821 chip->controller->active = chip; in panic_nand_get_device()
822 chip->state = new_state; in panic_nand_get_device()
835 struct nand_chip *chip = mtd->priv; in nand_get_device() local
836 spinlock_t *lock = &chip->controller->lock; in nand_get_device()
837 wait_queue_head_t *wq = &chip->controller->wq; in nand_get_device()
843 if (!chip->controller->active) in nand_get_device()
844 chip->controller->active = chip; in nand_get_device()
846 if (chip->controller->active == chip && chip->state == FL_READY) { in nand_get_device()
847 chip->state = new_state; in nand_get_device()
852 if (chip->controller->active->state == FL_PM_SUSPENDED) { in nand_get_device()
853 chip->state = FL_PM_SUSPENDED; in nand_get_device()
876 static void panic_nand_wait(struct mtd_info *mtd, struct nand_chip *chip, in panic_nand_wait() argument
881 if (chip->dev_ready) { in panic_nand_wait()
882 if (chip->dev_ready(mtd)) in panic_nand_wait()
885 if (chip->read_byte(mtd) & NAND_STATUS_READY) in panic_nand_wait()
899 static int nand_wait(struct mtd_info *mtd, struct nand_chip *chip) in nand_wait() argument
913 chip->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1); in nand_wait()
916 panic_nand_wait(mtd, chip, timeo); in nand_wait()
920 if (chip->dev_ready) { in nand_wait()
921 if (chip->dev_ready(mtd)) in nand_wait()
924 if (chip->read_byte(mtd) & NAND_STATUS_READY) in nand_wait()
932 status = (int)chip->read_byte(mtd); in nand_wait()
955 struct nand_chip *chip = mtd->priv; in __nand_unlock() local
958 page = ofs >> chip->page_shift; in __nand_unlock()
959 chip->cmdfunc(mtd, NAND_CMD_UNLOCK1, -1, page & chip->pagemask); in __nand_unlock()
962 page = (ofs + len) >> chip->page_shift; in __nand_unlock()
963 chip->cmdfunc(mtd, NAND_CMD_UNLOCK2, -1, in __nand_unlock()
964 (page | invert) & chip->pagemask); in __nand_unlock()
967 status = chip->waitfunc(mtd, chip); in __nand_unlock()
990 struct nand_chip *chip = mtd->priv; in nand_unlock() local
1005 chipnr = ofs >> chip->chip_shift; in nand_unlock()
1007 chip->select_chip(mtd, chipnr); in nand_unlock()
1016 chip->cmdfunc(mtd, NAND_CMD_RESET, -1, -1); in nand_unlock()
1029 chip->select_chip(mtd, -1); in nand_unlock()
1053 struct nand_chip *chip = mtd->priv; in nand_lock() local
1064 chipnr = ofs >> chip->chip_shift; in nand_lock()
1066 chip->select_chip(mtd, chipnr); in nand_lock()
1075 chip->cmdfunc(mtd, NAND_CMD_RESET, -1, -1); in nand_lock()
1087 page = ofs >> chip->page_shift; in nand_lock()
1088 chip->cmdfunc(mtd, NAND_CMD_LOCK, -1, page & chip->pagemask); in nand_lock()
1091 status = chip->waitfunc(mtd, chip); in nand_lock()
1103 chip->select_chip(mtd, -1); in nand_lock()
1248 static int nand_read_page_raw(struct mtd_info *mtd, struct nand_chip *chip, in nand_read_page_raw() argument
1251 chip->read_buf(mtd, buf, mtd->writesize); in nand_read_page_raw()
1253 chip->read_buf(mtd, chip->oob_poi, mtd->oobsize); in nand_read_page_raw()
1268 struct nand_chip *chip, uint8_t *buf, in nand_read_page_raw_syndrome() argument
1271 int eccsize = chip->ecc.size; in nand_read_page_raw_syndrome()
1272 int eccbytes = chip->ecc.bytes; in nand_read_page_raw_syndrome()
1273 uint8_t *oob = chip->oob_poi; in nand_read_page_raw_syndrome()
1276 for (steps = chip->ecc.steps; steps > 0; steps--) { in nand_read_page_raw_syndrome()
1277 chip->read_buf(mtd, buf, eccsize); in nand_read_page_raw_syndrome()
1280 if (chip->ecc.prepad) { in nand_read_page_raw_syndrome()
1281 chip->read_buf(mtd, oob, chip->ecc.prepad); in nand_read_page_raw_syndrome()
1282 oob += chip->ecc.prepad; in nand_read_page_raw_syndrome()
1285 chip->read_buf(mtd, oob, eccbytes); in nand_read_page_raw_syndrome()
1288 if (chip->ecc.postpad) { in nand_read_page_raw_syndrome()
1289 chip->read_buf(mtd, oob, chip->ecc.postpad); in nand_read_page_raw_syndrome()
1290 oob += chip->ecc.postpad; in nand_read_page_raw_syndrome()
1294 size = mtd->oobsize - (oob - chip->oob_poi); in nand_read_page_raw_syndrome()
1296 chip->read_buf(mtd, oob, size); in nand_read_page_raw_syndrome()
1309 static int nand_read_page_swecc(struct mtd_info *mtd, struct nand_chip *chip, in nand_read_page_swecc() argument
1312 int i, eccsize = chip->ecc.size; in nand_read_page_swecc()
1313 int eccbytes = chip->ecc.bytes; in nand_read_page_swecc()
1314 int eccsteps = chip->ecc.steps; in nand_read_page_swecc()
1316 uint8_t *ecc_calc = chip->buffers->ecccalc; in nand_read_page_swecc()
1317 uint8_t *ecc_code = chip->buffers->ecccode; in nand_read_page_swecc()
1318 uint32_t *eccpos = chip->ecc.layout->eccpos; in nand_read_page_swecc()
1321 chip->ecc.read_page_raw(mtd, chip, buf, 1, page); in nand_read_page_swecc()
1324 chip->ecc.calculate(mtd, p, &ecc_calc[i]); in nand_read_page_swecc()
1326 for (i = 0; i < chip->ecc.total; i++) in nand_read_page_swecc()
1327 ecc_code[i] = chip->oob_poi[eccpos[i]]; in nand_read_page_swecc()
1329 eccsteps = chip->ecc.steps; in nand_read_page_swecc()
1335 stat = chip->ecc.correct(mtd, p, &ecc_code[i], &ecc_calc[i]); in nand_read_page_swecc()
1355 static int nand_read_subpage(struct mtd_info *mtd, struct nand_chip *chip, in nand_read_subpage() argument
1360 uint32_t *eccpos = chip->ecc.layout->eccpos; in nand_read_subpage()
1364 int busw = (chip->options & NAND_BUSWIDTH_16) ? 2 : 1; in nand_read_subpage()
1369 start_step = data_offs / chip->ecc.size; in nand_read_subpage()
1370 end_step = (data_offs + readlen - 1) / chip->ecc.size; in nand_read_subpage()
1372 index = start_step * chip->ecc.bytes; in nand_read_subpage()
1375 datafrag_len = num_steps * chip->ecc.size; in nand_read_subpage()
1376 eccfrag_len = num_steps * chip->ecc.bytes; in nand_read_subpage()
1378 data_col_addr = start_step * chip->ecc.size; in nand_read_subpage()
1381 chip->cmdfunc(mtd, NAND_CMD_RNDOUT, data_col_addr, -1); in nand_read_subpage()
1384 chip->read_buf(mtd, p, datafrag_len); in nand_read_subpage()
1387 for (i = 0; i < eccfrag_len ; i += chip->ecc.bytes, p += chip->ecc.size) in nand_read_subpage()
1388 chip->ecc.calculate(mtd, p, &chip->buffers->ecccalc[i]); in nand_read_subpage()
1401 chip->cmdfunc(mtd, NAND_CMD_RNDOUT, mtd->writesize, -1); in nand_read_subpage()
1402 chip->read_buf(mtd, chip->oob_poi, mtd->oobsize); in nand_read_subpage()
1412 if (eccpos[index + (num_steps * chip->ecc.bytes)] & (busw - 1)) in nand_read_subpage()
1415 chip->cmdfunc(mtd, NAND_CMD_RNDOUT, in nand_read_subpage()
1417 chip->read_buf(mtd, &chip->oob_poi[aligned_pos], aligned_len); in nand_read_subpage()
1421 chip->buffers->ecccode[i] = chip->oob_poi[eccpos[i + index]]; in nand_read_subpage()
1424 for (i = 0; i < eccfrag_len ; i += chip->ecc.bytes, p += chip->ecc.size) { in nand_read_subpage()
1427 stat = chip->ecc.correct(mtd, p, in nand_read_subpage()
1428 &chip->buffers->ecccode[i], &chip->buffers->ecccalc[i]); in nand_read_subpage()
1449 static int nand_read_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip, in nand_read_page_hwecc() argument
1452 int i, eccsize = chip->ecc.size; in nand_read_page_hwecc()
1453 int eccbytes = chip->ecc.bytes; in nand_read_page_hwecc()
1454 int eccsteps = chip->ecc.steps; in nand_read_page_hwecc()
1456 uint8_t *ecc_calc = chip->buffers->ecccalc; in nand_read_page_hwecc()
1457 uint8_t *ecc_code = chip->buffers->ecccode; in nand_read_page_hwecc()
1458 uint32_t *eccpos = chip->ecc.layout->eccpos; in nand_read_page_hwecc()
1462 chip->ecc.hwctl(mtd, NAND_ECC_READ); in nand_read_page_hwecc()
1463 chip->read_buf(mtd, p, eccsize); in nand_read_page_hwecc()
1464 chip->ecc.calculate(mtd, p, &ecc_calc[i]); in nand_read_page_hwecc()
1466 chip->read_buf(mtd, chip->oob_poi, mtd->oobsize); in nand_read_page_hwecc()
1468 for (i = 0; i < chip->ecc.total; i++) in nand_read_page_hwecc()
1469 ecc_code[i] = chip->oob_poi[eccpos[i]]; in nand_read_page_hwecc()
1471 eccsteps = chip->ecc.steps; in nand_read_page_hwecc()
1477 stat = chip->ecc.correct(mtd, p, &ecc_code[i], &ecc_calc[i]); in nand_read_page_hwecc()
1503 struct nand_chip *chip, uint8_t *buf, int oob_required, int page) in nand_read_page_hwecc_oob_first() argument
1505 int i, eccsize = chip->ecc.size; in nand_read_page_hwecc_oob_first()
1506 int eccbytes = chip->ecc.bytes; in nand_read_page_hwecc_oob_first()
1507 int eccsteps = chip->ecc.steps; in nand_read_page_hwecc_oob_first()
1509 uint8_t *ecc_code = chip->buffers->ecccode; in nand_read_page_hwecc_oob_first()
1510 uint32_t *eccpos = chip->ecc.layout->eccpos; in nand_read_page_hwecc_oob_first()
1511 uint8_t *ecc_calc = chip->buffers->ecccalc; in nand_read_page_hwecc_oob_first()
1515 chip->cmdfunc(mtd, NAND_CMD_READOOB, 0, page); in nand_read_page_hwecc_oob_first()
1516 chip->read_buf(mtd, chip->oob_poi, mtd->oobsize); in nand_read_page_hwecc_oob_first()
1517 chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page); in nand_read_page_hwecc_oob_first()
1519 for (i = 0; i < chip->ecc.total; i++) in nand_read_page_hwecc_oob_first()
1520 ecc_code[i] = chip->oob_poi[eccpos[i]]; in nand_read_page_hwecc_oob_first()
1525 chip->ecc.hwctl(mtd, NAND_ECC_READ); in nand_read_page_hwecc_oob_first()
1526 chip->read_buf(mtd, p, eccsize); in nand_read_page_hwecc_oob_first()
1527 chip->ecc.calculate(mtd, p, &ecc_calc[i]); in nand_read_page_hwecc_oob_first()
1529 stat = chip->ecc.correct(mtd, p, &ecc_code[i], NULL); in nand_read_page_hwecc_oob_first()
1551 static int nand_read_page_syndrome(struct mtd_info *mtd, struct nand_chip *chip, in nand_read_page_syndrome() argument
1554 int i, eccsize = chip->ecc.size; in nand_read_page_syndrome()
1555 int eccbytes = chip->ecc.bytes; in nand_read_page_syndrome()
1556 int eccsteps = chip->ecc.steps; in nand_read_page_syndrome()
1558 uint8_t *oob = chip->oob_poi; in nand_read_page_syndrome()
1564 chip->ecc.hwctl(mtd, NAND_ECC_READ); in nand_read_page_syndrome()
1565 chip->read_buf(mtd, p, eccsize); in nand_read_page_syndrome()
1567 if (chip->ecc.prepad) { in nand_read_page_syndrome()
1568 chip->read_buf(mtd, oob, chip->ecc.prepad); in nand_read_page_syndrome()
1569 oob += chip->ecc.prepad; in nand_read_page_syndrome()
1572 chip->ecc.hwctl(mtd, NAND_ECC_READSYN); in nand_read_page_syndrome()
1573 chip->read_buf(mtd, oob, eccbytes); in nand_read_page_syndrome()
1574 stat = chip->ecc.correct(mtd, p, oob, NULL); in nand_read_page_syndrome()
1585 if (chip->ecc.postpad) { in nand_read_page_syndrome()
1586 chip->read_buf(mtd, oob, chip->ecc.postpad); in nand_read_page_syndrome()
1587 oob += chip->ecc.postpad; in nand_read_page_syndrome()
1592 i = mtd->oobsize - (oob - chip->oob_poi); in nand_read_page_syndrome()
1594 chip->read_buf(mtd, oob, i); in nand_read_page_syndrome()
1606 static uint8_t *nand_transfer_oob(struct nand_chip *chip, uint8_t *oob, in nand_transfer_oob() argument
1613 memcpy(oob, chip->oob_poi + ops->ooboffs, len); in nand_transfer_oob()
1617 struct nand_oobfree *free = chip->ecc.layout->oobfree; in nand_transfer_oob()
1636 memcpy(oob, chip->oob_poi + boffs, bytes); in nand_transfer_oob()
1658 struct nand_chip *chip = mtd->priv; in nand_setup_read_retry() local
1662 if (retry_mode >= chip->read_retries) in nand_setup_read_retry()
1665 if (!chip->setup_read_retry) in nand_setup_read_retry()
1668 return chip->setup_read_retry(mtd, retry_mode); in nand_setup_read_retry()
1683 struct nand_chip *chip = mtd->priv; in nand_do_read_ops() local
1696 chipnr = (int)(from >> chip->chip_shift); in nand_do_read_ops()
1697 chip->select_chip(mtd, chipnr); in nand_do_read_ops()
1699 realpage = (int)(from >> chip->page_shift); in nand_do_read_ops()
1700 page = realpage & chip->pagemask; in nand_do_read_ops()
1716 else if (chip->options & NAND_USE_BOUNCE_BUFFER) in nand_do_read_ops()
1722 if (realpage != chip->pagebuf || oob) { in nand_do_read_ops()
1723 bufpoi = use_bufpoi ? chip->buffers->databuf : buf; in nand_do_read_ops()
1730 chip->cmdfunc(mtd, NAND_CMD_READ0, 0x00, page); in nand_do_read_ops()
1737 ret = chip->ecc.read_page_raw(mtd, chip, bufpoi, in nand_do_read_ops()
1740 else if (!aligned && NAND_HAS_SUBPAGE_READ(chip) && in nand_do_read_ops()
1742 ret = chip->ecc.read_subpage(mtd, chip, in nand_do_read_ops()
1746 ret = chip->ecc.read_page(mtd, chip, bufpoi, in nand_do_read_ops()
1751 chip->pagebuf = -1; in nand_do_read_ops()
1759 if (!NAND_HAS_SUBPAGE_READ(chip) && !oob && in nand_do_read_ops()
1762 chip->pagebuf = realpage; in nand_do_read_ops()
1763 chip->pagebuf_bitflips = ret; in nand_do_read_ops()
1766 chip->pagebuf = -1; in nand_do_read_ops()
1768 memcpy(buf, chip->buffers->databuf + col, bytes); in nand_do_read_ops()
1775 oob = nand_transfer_oob(chip, in nand_do_read_ops()
1781 if (chip->options & NAND_NEED_READRDY) { in nand_do_read_ops()
1783 if (!chip->dev_ready) in nand_do_read_ops()
1784 udelay(chip->chip_delay); in nand_do_read_ops()
1790 if (retry_mode + 1 < chip->read_retries) { in nand_do_read_ops()
1808 memcpy(buf, chip->buffers->databuf + col, bytes); in nand_do_read_ops()
1811 chip->pagebuf_bitflips); in nand_do_read_ops()
1832 page = realpage & chip->pagemask; in nand_do_read_ops()
1836 chip->select_chip(mtd, -1); in nand_do_read_ops()
1837 chip->select_chip(mtd, chipnr); in nand_do_read_ops()
1840 chip->select_chip(mtd, -1); in nand_do_read_ops()
1888 static int nand_read_oob_std(struct mtd_info *mtd, struct nand_chip *chip, in nand_read_oob_std() argument
1891 chip->cmdfunc(mtd, NAND_CMD_READOOB, 0, page); in nand_read_oob_std()
1892 chip->read_buf(mtd, chip->oob_poi, mtd->oobsize); in nand_read_oob_std()
1903 static int nand_read_oob_syndrome(struct mtd_info *mtd, struct nand_chip *chip, in nand_read_oob_syndrome() argument
1907 int chunk = chip->ecc.bytes + chip->ecc.prepad + chip->ecc.postpad; in nand_read_oob_syndrome()
1908 int eccsize = chip->ecc.size; in nand_read_oob_syndrome()
1909 uint8_t *bufpoi = chip->oob_poi; in nand_read_oob_syndrome()
1912 chip->cmdfunc(mtd, NAND_CMD_READ0, chip->ecc.size, page); in nand_read_oob_syndrome()
1913 for (i = 0; i < chip->ecc.steps; i++) { in nand_read_oob_syndrome()
1917 chip->cmdfunc(mtd, NAND_CMD_RNDOUT, pos, -1); in nand_read_oob_syndrome()
1919 chip->cmdfunc(mtd, NAND_CMD_READ0, pos, page); in nand_read_oob_syndrome()
1923 chip->read_buf(mtd, bufpoi, toread); in nand_read_oob_syndrome()
1928 chip->read_buf(mtd, bufpoi, length); in nand_read_oob_syndrome()
1939 static int nand_write_oob_std(struct mtd_info *mtd, struct nand_chip *chip, in nand_write_oob_std() argument
1943 const uint8_t *buf = chip->oob_poi; in nand_write_oob_std()
1946 chip->cmdfunc(mtd, NAND_CMD_SEQIN, mtd->writesize, page); in nand_write_oob_std()
1947 chip->write_buf(mtd, buf, length); in nand_write_oob_std()
1949 chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1); in nand_write_oob_std()
1951 status = chip->waitfunc(mtd, chip); in nand_write_oob_std()
1964 struct nand_chip *chip, int page) in nand_write_oob_syndrome() argument
1966 int chunk = chip->ecc.bytes + chip->ecc.prepad + chip->ecc.postpad; in nand_write_oob_syndrome()
1967 int eccsize = chip->ecc.size, length = mtd->oobsize; in nand_write_oob_syndrome()
1968 int i, len, pos, status = 0, sndcmd = 0, steps = chip->ecc.steps; in nand_write_oob_syndrome()
1969 const uint8_t *bufpoi = chip->oob_poi; in nand_write_oob_syndrome()
1976 if (!chip->ecc.prepad && !chip->ecc.postpad) { in nand_write_oob_syndrome()
1982 chip->cmdfunc(mtd, NAND_CMD_SEQIN, pos, page); in nand_write_oob_syndrome()
1991 chip->write_buf(mtd, (uint8_t *)&fill, in nand_write_oob_syndrome()
1997 chip->cmdfunc(mtd, NAND_CMD_RNDIN, pos, -1); in nand_write_oob_syndrome()
2002 chip->write_buf(mtd, bufpoi, len); in nand_write_oob_syndrome()
2007 chip->write_buf(mtd, bufpoi, length); in nand_write_oob_syndrome()
2009 chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1); in nand_write_oob_syndrome()
2010 status = chip->waitfunc(mtd, chip); in nand_write_oob_syndrome()
2027 struct nand_chip *chip = mtd->priv; in nand_do_read_oob() local
2040 len = chip->ecc.layout->oobavail; in nand_do_read_oob()
2052 ops->ooboffs + readlen > ((mtd->size >> chip->page_shift) - in nand_do_read_oob()
2053 (from >> chip->page_shift)) * len)) { in nand_do_read_oob()
2059 chipnr = (int)(from >> chip->chip_shift); in nand_do_read_oob()
2060 chip->select_chip(mtd, chipnr); in nand_do_read_oob()
2063 realpage = (int)(from >> chip->page_shift); in nand_do_read_oob()
2064 page = realpage & chip->pagemask; in nand_do_read_oob()
2068 ret = chip->ecc.read_oob_raw(mtd, chip, page); in nand_do_read_oob()
2070 ret = chip->ecc.read_oob(mtd, chip, page); in nand_do_read_oob()
2076 buf = nand_transfer_oob(chip, buf, ops, len); in nand_do_read_oob()
2078 if (chip->options & NAND_NEED_READRDY) { in nand_do_read_oob()
2080 if (!chip->dev_ready) in nand_do_read_oob()
2081 udelay(chip->chip_delay); in nand_do_read_oob()
2093 page = realpage & chip->pagemask; in nand_do_read_oob()
2097 chip->select_chip(mtd, -1); in nand_do_read_oob()
2098 chip->select_chip(mtd, chipnr); in nand_do_read_oob()
2101 chip->select_chip(mtd, -1); in nand_do_read_oob()
2169 static int nand_write_page_raw(struct mtd_info *mtd, struct nand_chip *chip, in nand_write_page_raw() argument
2172 chip->write_buf(mtd, buf, mtd->writesize); in nand_write_page_raw()
2174 chip->write_buf(mtd, chip->oob_poi, mtd->oobsize); in nand_write_page_raw()
2190 struct nand_chip *chip, in nand_write_page_raw_syndrome() argument
2194 int eccsize = chip->ecc.size; in nand_write_page_raw_syndrome()
2195 int eccbytes = chip->ecc.bytes; in nand_write_page_raw_syndrome()
2196 uint8_t *oob = chip->oob_poi; in nand_write_page_raw_syndrome()
2199 for (steps = chip->ecc.steps; steps > 0; steps--) { in nand_write_page_raw_syndrome()
2200 chip->write_buf(mtd, buf, eccsize); in nand_write_page_raw_syndrome()
2203 if (chip->ecc.prepad) { in nand_write_page_raw_syndrome()
2204 chip->write_buf(mtd, oob, chip->ecc.prepad); in nand_write_page_raw_syndrome()
2205 oob += chip->ecc.prepad; in nand_write_page_raw_syndrome()
2208 chip->write_buf(mtd, oob, eccbytes); in nand_write_page_raw_syndrome()
2211 if (chip->ecc.postpad) { in nand_write_page_raw_syndrome()
2212 chip->write_buf(mtd, oob, chip->ecc.postpad); in nand_write_page_raw_syndrome()
2213 oob += chip->ecc.postpad; in nand_write_page_raw_syndrome()
2217 size = mtd->oobsize - (oob - chip->oob_poi); in nand_write_page_raw_syndrome()
2219 chip->write_buf(mtd, oob, size); in nand_write_page_raw_syndrome()
2231 static int nand_write_page_swecc(struct mtd_info *mtd, struct nand_chip *chip, in nand_write_page_swecc() argument
2235 int i, eccsize = chip->ecc.size; in nand_write_page_swecc()
2236 int eccbytes = chip->ecc.bytes; in nand_write_page_swecc()
2237 int eccsteps = chip->ecc.steps; in nand_write_page_swecc()
2238 uint8_t *ecc_calc = chip->buffers->ecccalc; in nand_write_page_swecc()
2240 uint32_t *eccpos = chip->ecc.layout->eccpos; in nand_write_page_swecc()
2244 chip->ecc.calculate(mtd, p, &ecc_calc[i]); in nand_write_page_swecc()
2246 for (i = 0; i < chip->ecc.total; i++) in nand_write_page_swecc()
2247 chip->oob_poi[eccpos[i]] = ecc_calc[i]; in nand_write_page_swecc()
2249 return chip->ecc.write_page_raw(mtd, chip, buf, 1, page); in nand_write_page_swecc()
2260 static int nand_write_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip, in nand_write_page_hwecc() argument
2264 int i, eccsize = chip->ecc.size; in nand_write_page_hwecc()
2265 int eccbytes = chip->ecc.bytes; in nand_write_page_hwecc()
2266 int eccsteps = chip->ecc.steps; in nand_write_page_hwecc()
2267 uint8_t *ecc_calc = chip->buffers->ecccalc; in nand_write_page_hwecc()
2269 uint32_t *eccpos = chip->ecc.layout->eccpos; in nand_write_page_hwecc()
2272 chip->ecc.hwctl(mtd, NAND_ECC_WRITE); in nand_write_page_hwecc()
2273 chip->write_buf(mtd, p, eccsize); in nand_write_page_hwecc()
2274 chip->ecc.calculate(mtd, p, &ecc_calc[i]); in nand_write_page_hwecc()
2277 for (i = 0; i < chip->ecc.total; i++) in nand_write_page_hwecc()
2278 chip->oob_poi[eccpos[i]] = ecc_calc[i]; in nand_write_page_hwecc()
2280 chip->write_buf(mtd, chip->oob_poi, mtd->oobsize); in nand_write_page_hwecc()
2297 struct nand_chip *chip, uint32_t offset, in nand_write_subpage_hwecc() argument
2301 uint8_t *oob_buf = chip->oob_poi; in nand_write_subpage_hwecc()
2302 uint8_t *ecc_calc = chip->buffers->ecccalc; in nand_write_subpage_hwecc()
2303 int ecc_size = chip->ecc.size; in nand_write_subpage_hwecc()
2304 int ecc_bytes = chip->ecc.bytes; in nand_write_subpage_hwecc()
2305 int ecc_steps = chip->ecc.steps; in nand_write_subpage_hwecc()
2306 uint32_t *eccpos = chip->ecc.layout->eccpos; in nand_write_subpage_hwecc()
2314 chip->ecc.hwctl(mtd, NAND_ECC_WRITE); in nand_write_subpage_hwecc()
2317 chip->write_buf(mtd, buf, ecc_size); in nand_write_subpage_hwecc()
2323 chip->ecc.calculate(mtd, buf, ecc_calc); in nand_write_subpage_hwecc()
2337 ecc_calc = chip->buffers->ecccalc; in nand_write_subpage_hwecc()
2338 for (i = 0; i < chip->ecc.total; i++) in nand_write_subpage_hwecc()
2339 chip->oob_poi[eccpos[i]] = ecc_calc[i]; in nand_write_subpage_hwecc()
2342 chip->write_buf(mtd, chip->oob_poi, mtd->oobsize); in nand_write_subpage_hwecc()
2360 struct nand_chip *chip, in nand_write_page_syndrome() argument
2364 int i, eccsize = chip->ecc.size; in nand_write_page_syndrome()
2365 int eccbytes = chip->ecc.bytes; in nand_write_page_syndrome()
2366 int eccsteps = chip->ecc.steps; in nand_write_page_syndrome()
2368 uint8_t *oob = chip->oob_poi; in nand_write_page_syndrome()
2372 chip->ecc.hwctl(mtd, NAND_ECC_WRITE); in nand_write_page_syndrome()
2373 chip->write_buf(mtd, p, eccsize); in nand_write_page_syndrome()
2375 if (chip->ecc.prepad) { in nand_write_page_syndrome()
2376 chip->write_buf(mtd, oob, chip->ecc.prepad); in nand_write_page_syndrome()
2377 oob += chip->ecc.prepad; in nand_write_page_syndrome()
2380 chip->ecc.calculate(mtd, p, oob); in nand_write_page_syndrome()
2381 chip->write_buf(mtd, oob, eccbytes); in nand_write_page_syndrome()
2384 if (chip->ecc.postpad) { in nand_write_page_syndrome()
2385 chip->write_buf(mtd, oob, chip->ecc.postpad); in nand_write_page_syndrome()
2386 oob += chip->ecc.postpad; in nand_write_page_syndrome()
2391 i = mtd->oobsize - (oob - chip->oob_poi); in nand_write_page_syndrome()
2393 chip->write_buf(mtd, oob, i); in nand_write_page_syndrome()
2410 static int nand_write_page(struct mtd_info *mtd, struct nand_chip *chip, in nand_write_page() argument
2416 if (!(chip->options & NAND_NO_SUBPAGE_WRITE) && in nand_write_page()
2417 chip->ecc.write_subpage) in nand_write_page()
2422 chip->cmdfunc(mtd, NAND_CMD_SEQIN, 0x00, page); in nand_write_page()
2425 status = chip->ecc.write_page_raw(mtd, chip, buf, in nand_write_page()
2428 status = chip->ecc.write_subpage(mtd, chip, offset, data_len, in nand_write_page()
2431 status = chip->ecc.write_page(mtd, chip, buf, oob_required, in nand_write_page()
2443 if (!cached || !NAND_HAS_CACHEPROG(chip)) { in nand_write_page()
2445 chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1); in nand_write_page()
2446 status = chip->waitfunc(mtd, chip); in nand_write_page()
2451 if ((status & NAND_STATUS_FAIL) && (chip->errstat)) in nand_write_page()
2452 status = chip->errstat(mtd, chip, FL_WRITING, status, in nand_write_page()
2458 chip->cmdfunc(mtd, NAND_CMD_CACHEDPROG, -1, -1); in nand_write_page()
2459 status = chip->waitfunc(mtd, chip); in nand_write_page()
2475 struct nand_chip *chip = mtd->priv; in nand_fill_oob() local
2481 memset(chip->oob_poi, 0xff, mtd->oobsize); in nand_fill_oob()
2487 memcpy(chip->oob_poi + ops->ooboffs, oob, len); in nand_fill_oob()
2491 struct nand_oobfree *free = chip->ecc.layout->oobfree; in nand_fill_oob()
2510 memcpy(chip->oob_poi + boffs, oob, bytes); in nand_fill_oob()
2521 #define NOTALIGNED(x) ((x & (chip->subpagesize - 1)) != 0)
2535 struct nand_chip *chip = mtd->priv; in nand_do_write_ops() local
2560 chipnr = (int)(to >> chip->chip_shift); in nand_do_write_ops()
2561 chip->select_chip(mtd, chipnr); in nand_do_write_ops()
2569 realpage = (int)(to >> chip->page_shift); in nand_do_write_ops()
2570 page = realpage & chip->pagemask; in nand_do_write_ops()
2571 blockmask = (1 << (chip->phys_erase_shift - chip->page_shift)) - 1; in nand_do_write_ops()
2574 if (to <= ((loff_t)chip->pagebuf << chip->page_shift) && in nand_do_write_ops()
2575 ((loff_t)chip->pagebuf << chip->page_shift) < (to + ops->len)) in nand_do_write_ops()
2576 chip->pagebuf = -1; in nand_do_write_ops()
2593 else if (chip->options & NAND_USE_BOUNCE_BUFFER) in nand_do_write_ops()
2605 chip->pagebuf = -1; in nand_do_write_ops()
2606 memset(chip->buffers->databuf, 0xff, mtd->writesize); in nand_do_write_ops()
2607 memcpy(&chip->buffers->databuf[column], buf, bytes); in nand_do_write_ops()
2608 wbuf = chip->buffers->databuf; in nand_do_write_ops()
2617 memset(chip->oob_poi, 0xff, mtd->oobsize); in nand_do_write_ops()
2619 ret = chip->write_page(mtd, chip, column, bytes, wbuf, in nand_do_write_ops()
2633 page = realpage & chip->pagemask; in nand_do_write_ops()
2637 chip->select_chip(mtd, -1); in nand_do_write_ops()
2638 chip->select_chip(mtd, chipnr); in nand_do_write_ops()
2647 chip->select_chip(mtd, -1); in nand_do_write_ops()
2665 struct nand_chip *chip = mtd->priv; in panic_nand_write() local
2670 panic_nand_wait(mtd, chip, 400); in panic_nand_write()
2673 panic_nand_get_device(chip, mtd, FL_WRITING); in panic_nand_write()
2725 struct nand_chip *chip = mtd->priv; in nand_do_write_oob() local
2731 len = chip->ecc.layout->oobavail; in nand_do_write_oob()
2751 ((mtd->size >> chip->page_shift) - in nand_do_write_oob()
2752 (to >> chip->page_shift)) * len)) { in nand_do_write_oob()
2758 chipnr = (int)(to >> chip->chip_shift); in nand_do_write_oob()
2759 chip->select_chip(mtd, chipnr); in nand_do_write_oob()
2762 page = (int)(to >> chip->page_shift); in nand_do_write_oob()
2770 chip->cmdfunc(mtd, NAND_CMD_RESET, -1, -1); in nand_do_write_oob()
2774 chip->select_chip(mtd, -1); in nand_do_write_oob()
2779 if (page == chip->pagebuf) in nand_do_write_oob()
2780 chip->pagebuf = -1; in nand_do_write_oob()
2785 status = chip->ecc.write_oob_raw(mtd, chip, page & chip->pagemask); in nand_do_write_oob()
2787 status = chip->ecc.write_oob(mtd, chip, page & chip->pagemask); in nand_do_write_oob()
2789 chip->select_chip(mtd, -1); in nand_do_write_oob()
2850 struct nand_chip *chip = mtd->priv; in single_erase() local
2852 chip->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page); in single_erase()
2853 chip->cmdfunc(mtd, NAND_CMD_ERASE2, -1, -1); in single_erase()
2855 return chip->waitfunc(mtd, chip); in single_erase()
2882 struct nand_chip *chip = mtd->priv; in nand_erase_nand() local
2896 page = (int)(instr->addr >> chip->page_shift); in nand_erase_nand()
2897 chipnr = (int)(instr->addr >> chip->chip_shift); in nand_erase_nand()
2900 pages_per_block = 1 << (chip->phys_erase_shift - chip->page_shift); in nand_erase_nand()
2903 chip->select_chip(mtd, chipnr); in nand_erase_nand()
2921 chip->page_shift, 0, allowbbt)) { in nand_erase_nand()
2932 if (page <= chip->pagebuf && chip->pagebuf < in nand_erase_nand()
2934 chip->pagebuf = -1; in nand_erase_nand()
2936 status = chip->erase(mtd, page & chip->pagemask); in nand_erase_nand()
2942 if ((status & NAND_STATUS_FAIL) && (chip->errstat)) in nand_erase_nand()
2943 status = chip->errstat(mtd, chip, FL_ERASING, in nand_erase_nand()
2952 ((loff_t)page << chip->page_shift); in nand_erase_nand()
2957 len -= (1ULL << chip->phys_erase_shift); in nand_erase_nand()
2961 if (len && !(page & chip->pagemask)) { in nand_erase_nand()
2963 chip->select_chip(mtd, -1); in nand_erase_nand()
2964 chip->select_chip(mtd, chipnr); in nand_erase_nand()
2974 chip->select_chip(mtd, -1); in nand_erase_nand()
3038 static int nand_onfi_set_features(struct mtd_info *mtd, struct nand_chip *chip, in nand_onfi_set_features() argument
3044 if (!chip->onfi_version || in nand_onfi_set_features()
3045 !(le16_to_cpu(chip->onfi_params.opt_cmd) in nand_onfi_set_features()
3049 chip->cmdfunc(mtd, NAND_CMD_SET_FEATURES, addr, -1); in nand_onfi_set_features()
3051 chip->write_byte(mtd, subfeature_param[i]); in nand_onfi_set_features()
3053 status = chip->waitfunc(mtd, chip); in nand_onfi_set_features()
3066 static int nand_onfi_get_features(struct mtd_info *mtd, struct nand_chip *chip, in nand_onfi_get_features() argument
3071 if (!chip->onfi_version || in nand_onfi_get_features()
3072 !(le16_to_cpu(chip->onfi_params.opt_cmd) in nand_onfi_get_features()
3076 chip->cmdfunc(mtd, NAND_CMD_GET_FEATURES, addr, -1); in nand_onfi_get_features()
3078 *subfeature_param++ = chip->read_byte(mtd); in nand_onfi_get_features()
3097 struct nand_chip *chip = mtd->priv; in nand_resume() local
3099 if (chip->state == FL_PM_SUSPENDED) in nand_resume()
3117 static void nand_set_defaults(struct nand_chip *chip, int busw) in nand_set_defaults() argument
3120 if (!chip->chip_delay) in nand_set_defaults()
3121 chip->chip_delay = 20; in nand_set_defaults()
3124 if (chip->cmdfunc == NULL) in nand_set_defaults()
3125 chip->cmdfunc = nand_command; in nand_set_defaults()
3128 if (chip->waitfunc == NULL) in nand_set_defaults()
3129 chip->waitfunc = nand_wait; in nand_set_defaults()
3131 if (!chip->select_chip) in nand_set_defaults()
3132 chip->select_chip = nand_select_chip; in nand_set_defaults()
3135 if (!chip->onfi_set_features) in nand_set_defaults()
3136 chip->onfi_set_features = nand_onfi_set_features; in nand_set_defaults()
3137 if (!chip->onfi_get_features) in nand_set_defaults()
3138 chip->onfi_get_features = nand_onfi_get_features; in nand_set_defaults()
3141 if (!chip->read_byte || chip->read_byte == nand_read_byte) in nand_set_defaults()
3142 chip->read_byte = busw ? nand_read_byte16 : nand_read_byte; in nand_set_defaults()
3143 if (!chip->read_word) in nand_set_defaults()
3144 chip->read_word = nand_read_word; in nand_set_defaults()
3145 if (!chip->block_bad) in nand_set_defaults()
3146 chip->block_bad = nand_block_bad; in nand_set_defaults()
3147 if (!chip->block_markbad) in nand_set_defaults()
3148 chip->block_markbad = nand_default_block_markbad; in nand_set_defaults()
3149 if (!chip->write_buf || chip->write_buf == nand_write_buf) in nand_set_defaults()
3150 chip->write_buf = busw ? nand_write_buf16 : nand_write_buf; in nand_set_defaults()
3151 if (!chip->write_byte || chip->write_byte == nand_write_byte) in nand_set_defaults()
3152 chip->write_byte = busw ? nand_write_byte16 : nand_write_byte; in nand_set_defaults()
3153 if (!chip->read_buf || chip->read_buf == nand_read_buf) in nand_set_defaults()
3154 chip->read_buf = busw ? nand_read_buf16 : nand_read_buf; in nand_set_defaults()
3155 if (!chip->scan_bbt) in nand_set_defaults()
3156 chip->scan_bbt = nand_default_bbt; in nand_set_defaults()
3158 if (!chip->controller) { in nand_set_defaults()
3159 chip->controller = &chip->hwcontrol; in nand_set_defaults()
3160 spin_lock_init(&chip->controller->lock); in nand_set_defaults()
3161 init_waitqueue_head(&chip->controller->wq); in nand_set_defaults()
3198 struct nand_chip *chip, struct nand_onfi_params *p) in nand_flash_detect_ext_param_page() argument
3214 chip->cmdfunc(mtd, NAND_CMD_PARAM, 0, -1); in nand_flash_detect_ext_param_page()
3217 chip->cmdfunc(mtd, NAND_CMD_RNDOUT, in nand_flash_detect_ext_param_page()
3221 chip->read_buf(mtd, (uint8_t *)ep, len); in nand_flash_detect_ext_param_page()
3258 chip->ecc_strength_ds = ecc->ecc_bits; in nand_flash_detect_ext_param_page()
3259 chip->ecc_step_ds = 1 << ecc->codeword_size; in nand_flash_detect_ext_param_page()
3269 struct nand_chip *chip = mtd->priv; in nand_setup_read_retry_micron() local
3272 return chip->onfi_set_features(mtd, chip, ONFI_FEATURE_ADDR_READ_RETRY, in nand_setup_read_retry_micron()
3279 static void nand_onfi_detect_micron(struct nand_chip *chip, in nand_onfi_detect_micron() argument
3287 chip->read_retries = micron->read_retry_options; in nand_onfi_detect_micron()
3288 chip->setup_read_retry = nand_setup_read_retry_micron; in nand_onfi_detect_micron()
3294 static int nand_flash_detect_onfi(struct mtd_info *mtd, struct nand_chip *chip, in nand_flash_detect_onfi() argument
3297 struct nand_onfi_params *p = &chip->onfi_params; in nand_flash_detect_onfi()
3302 chip->cmdfunc(mtd, NAND_CMD_READID, 0x20, -1); in nand_flash_detect_onfi()
3303 if (chip->read_byte(mtd) != 'O' || chip->read_byte(mtd) != 'N' || in nand_flash_detect_onfi()
3304 chip->read_byte(mtd) != 'F' || chip->read_byte(mtd) != 'I') in nand_flash_detect_onfi()
3307 chip->cmdfunc(mtd, NAND_CMD_PARAM, 0, -1); in nand_flash_detect_onfi()
3310 ((uint8_t *)p)[j] = chip->read_byte(mtd); in nand_flash_detect_onfi()
3325 chip->onfi_version = 23; in nand_flash_detect_onfi()
3327 chip->onfi_version = 22; in nand_flash_detect_onfi()
3329 chip->onfi_version = 21; in nand_flash_detect_onfi()
3331 chip->onfi_version = 20; in nand_flash_detect_onfi()
3333 chip->onfi_version = 10; in nand_flash_detect_onfi()
3335 if (!chip->onfi_version) { in nand_flash_detect_onfi()
3358 chip->chipsize = 1 << (fls(le32_to_cpu(p->blocks_per_lun)) - 1); in nand_flash_detect_onfi()
3359 chip->chipsize *= (uint64_t)mtd->erasesize * p->lun_count; in nand_flash_detect_onfi()
3360 chip->bits_per_cell = p->bits_per_cell; in nand_flash_detect_onfi()
3362 if (onfi_feature(chip) & ONFI_FEATURE_16_BIT_BUS) in nand_flash_detect_onfi()
3368 chip->ecc_strength_ds = p->ecc_bits; in nand_flash_detect_onfi()
3369 chip->ecc_step_ds = 512; in nand_flash_detect_onfi()
3370 } else if (chip->onfi_version >= 21 && in nand_flash_detect_onfi()
3371 (onfi_feature(chip) & ONFI_FEATURE_EXT_PARAM_PAGE)) { in nand_flash_detect_onfi()
3379 if (mtd->writesize > 512 && chip->cmdfunc == nand_command) in nand_flash_detect_onfi()
3380 chip->cmdfunc = nand_command_lp; in nand_flash_detect_onfi()
3383 if (nand_flash_detect_ext_param_page(mtd, chip, p)) in nand_flash_detect_onfi()
3390 nand_onfi_detect_micron(chip, p); in nand_flash_detect_onfi()
3398 static int nand_flash_detect_jedec(struct mtd_info *mtd, struct nand_chip *chip, in nand_flash_detect_jedec() argument
3401 struct nand_jedec_params *p = &chip->jedec_params; in nand_flash_detect_jedec()
3407 chip->cmdfunc(mtd, NAND_CMD_READID, 0x40, -1); in nand_flash_detect_jedec()
3408 if (chip->read_byte(mtd) != 'J' || chip->read_byte(mtd) != 'E' || in nand_flash_detect_jedec()
3409 chip->read_byte(mtd) != 'D' || chip->read_byte(mtd) != 'E' || in nand_flash_detect_jedec()
3410 chip->read_byte(mtd) != 'C') in nand_flash_detect_jedec()
3413 chip->cmdfunc(mtd, NAND_CMD_PARAM, 0x40, -1); in nand_flash_detect_jedec()
3416 ((uint8_t *)p)[j] = chip->read_byte(mtd); in nand_flash_detect_jedec()
3431 chip->jedec_version = 10; in nand_flash_detect_jedec()
3433 chip->jedec_version = 1; /* vendor specific version */ in nand_flash_detect_jedec()
3435 if (!chip->jedec_version) { in nand_flash_detect_jedec()
3454 chip->chipsize = 1 << (fls(le32_to_cpu(p->blocks_per_lun)) - 1); in nand_flash_detect_jedec()
3455 chip->chipsize *= (uint64_t)mtd->erasesize * p->lun_count; in nand_flash_detect_jedec()
3456 chip->bits_per_cell = p->bits_per_cell; in nand_flash_detect_jedec()
3458 if (jedec_feature(chip) & JEDEC_FEATURE_16_BIT_BUS) in nand_flash_detect_jedec()
3467 chip->ecc_strength_ds = ecc->ecc_bits; in nand_flash_detect_jedec()
3468 chip->ecc_step_ds = 1 << ecc->codeword_size; in nand_flash_detect_jedec()
3550 static void nand_decode_ext_id(struct mtd_info *mtd, struct nand_chip *chip, in nand_decode_ext_id() argument
3555 chip->bits_per_cell = nand_get_bits_per_cell(id_data[2]); in nand_decode_ext_id()
3571 !nand_is_slc(chip) && id_data[5] != 0x00) { in nand_decode_ext_id()
3606 !nand_is_slc(chip)) { in nand_decode_ext_id()
3669 nand_is_slc(chip) && in nand_decode_ext_id()
3683 static void nand_decode_id(struct mtd_info *mtd, struct nand_chip *chip, in nand_decode_id() argument
3695 chip->bits_per_cell = 1; in nand_decode_id()
3717 struct nand_chip *chip, u8 id_data[8]) in nand_decode_bbm_options() argument
3722 if (mtd->writesize > 512 || (chip->options & NAND_BUSWIDTH_16)) in nand_decode_bbm_options()
3723 chip->badblockpos = NAND_LARGE_BADBLOCK_POS; in nand_decode_bbm_options()
3725 chip->badblockpos = NAND_SMALL_BADBLOCK_POS; in nand_decode_bbm_options()
3733 if (!nand_is_slc(chip) && in nand_decode_bbm_options()
3736 chip->bbt_options |= NAND_BBT_SCANLASTPAGE; in nand_decode_bbm_options()
3737 else if ((nand_is_slc(chip) && in nand_decode_bbm_options()
3745 chip->bbt_options |= NAND_BBT_SCAN2NDPAGE; in nand_decode_bbm_options()
3753 static bool find_full_id_nand(struct mtd_info *mtd, struct nand_chip *chip, in find_full_id_nand() argument
3761 chip->bits_per_cell = nand_get_bits_per_cell(id_data[2]); in find_full_id_nand()
3762 chip->chipsize = (uint64_t)type->chipsize << 20; in find_full_id_nand()
3763 chip->options |= type->options; in find_full_id_nand()
3764 chip->ecc_strength_ds = NAND_ECC_STRENGTH(type); in find_full_id_nand()
3765 chip->ecc_step_ds = NAND_ECC_STEP(type); in find_full_id_nand()
3766 chip->onfi_timing_mode_default = in find_full_id_nand()
3783 struct nand_chip *chip, in nand_get_flash_type() argument
3792 chip->select_chip(mtd, 0); in nand_get_flash_type()
3798 chip->cmdfunc(mtd, NAND_CMD_RESET, -1, -1); in nand_get_flash_type()
3801 chip->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1); in nand_get_flash_type()
3804 *maf_id = chip->read_byte(mtd); in nand_get_flash_type()
3805 *dev_id = chip->read_byte(mtd); in nand_get_flash_type()
3814 chip->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1); in nand_get_flash_type()
3818 id_data[i] = chip->read_byte(mtd); in nand_get_flash_type()
3831 if (find_full_id_nand(mtd, chip, type, id_data, &busw)) in nand_get_flash_type()
3838 chip->onfi_version = 0; in nand_get_flash_type()
3841 if (nand_flash_detect_onfi(mtd, chip, &busw)) in nand_get_flash_type()
3845 if (nand_flash_detect_jedec(mtd, chip, &busw)) in nand_get_flash_type()
3855 chip->chipsize = (uint64_t)type->chipsize << 20; in nand_get_flash_type()
3859 nand_decode_ext_id(mtd, chip, id_data, &busw); in nand_get_flash_type()
3861 nand_decode_id(mtd, chip, type, id_data, &busw); in nand_get_flash_type()
3864 chip->options |= type->options; in nand_get_flash_type()
3871 chip->options &= ~NAND_SAMSUNG_LP_OPTIONS; in nand_get_flash_type()
3880 if (chip->options & NAND_BUSWIDTH_AUTO) { in nand_get_flash_type()
3881 WARN_ON(chip->options & NAND_BUSWIDTH_16); in nand_get_flash_type()
3882 chip->options |= busw; in nand_get_flash_type()
3883 nand_set_defaults(chip, busw); in nand_get_flash_type()
3884 } else if (busw != (chip->options & NAND_BUSWIDTH_16)) { in nand_get_flash_type()
3893 (chip->options & NAND_BUSWIDTH_16) ? 16 : 8, in nand_get_flash_type()
3898 nand_decode_bbm_options(mtd, chip, id_data); in nand_get_flash_type()
3901 chip->page_shift = ffs(mtd->writesize) - 1; in nand_get_flash_type()
3903 chip->pagemask = (chip->chipsize >> chip->page_shift) - 1; in nand_get_flash_type()
3905 chip->bbt_erase_shift = chip->phys_erase_shift = in nand_get_flash_type()
3907 if (chip->chipsize & 0xffffffff) in nand_get_flash_type()
3908 chip->chip_shift = ffs((unsigned)chip->chipsize) - 1; in nand_get_flash_type()
3910 chip->chip_shift = ffs((unsigned)(chip->chipsize >> 32)); in nand_get_flash_type()
3911 chip->chip_shift += 32 - 1; in nand_get_flash_type()
3914 chip->badblockbits = 8; in nand_get_flash_type()
3915 chip->erase = single_erase; in nand_get_flash_type()
3918 if (mtd->writesize > 512 && chip->cmdfunc == nand_command) in nand_get_flash_type()
3919 chip->cmdfunc = nand_command_lp; in nand_get_flash_type()
3924 if (chip->onfi_version) in nand_get_flash_type()
3926 chip->onfi_params.model); in nand_get_flash_type()
3927 else if (chip->jedec_version) in nand_get_flash_type()
3929 chip->jedec_params.model); in nand_get_flash_type()
3935 (int)(chip->chipsize >> 20), nand_is_slc(chip) ? "SLC" : "MLC", in nand_get_flash_type()
3940 static int nand_dt_init(struct mtd_info *mtd, struct nand_chip *chip, in nand_dt_init() argument
3946 chip->options |= NAND_BUSWIDTH_16; in nand_dt_init()
3949 chip->bbt_options |= NAND_BBT_USE_FLASH; in nand_dt_init()
3962 chip->ecc.mode = ecc_mode; in nand_dt_init()
3965 chip->ecc.strength = ecc_strength; in nand_dt_init()
3968 chip->ecc.size = ecc_step; in nand_dt_init()
3987 struct nand_chip *chip = mtd->priv; in nand_scan_ident() local
3991 if (chip->flash_node) { in nand_scan_ident()
3992 ret = nand_dt_init(mtd, chip, chip->flash_node); in nand_scan_ident()
4001 nand_set_defaults(chip, chip->options & NAND_BUSWIDTH_16); in nand_scan_ident()
4004 type = nand_get_flash_type(mtd, chip, &nand_maf_id, in nand_scan_ident()
4008 if (!(chip->options & NAND_SCAN_SILENT_NODEV)) in nand_scan_ident()
4010 chip->select_chip(mtd, -1); in nand_scan_ident()
4014 chip->select_chip(mtd, -1); in nand_scan_ident()
4018 chip->select_chip(mtd, i); in nand_scan_ident()
4020 chip->cmdfunc(mtd, NAND_CMD_RESET, -1, -1); in nand_scan_ident()
4022 chip->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1); in nand_scan_ident()
4024 if (nand_maf_id != chip->read_byte(mtd) || in nand_scan_ident()
4025 nand_dev_id != chip->read_byte(mtd)) { in nand_scan_ident()
4026 chip->select_chip(mtd, -1); in nand_scan_ident()
4029 chip->select_chip(mtd, -1); in nand_scan_ident()
4035 chip->numchips = i; in nand_scan_ident()
4036 mtd->size = i * chip->chipsize; in nand_scan_ident()
4058 struct nand_chip *chip = mtd->priv; in nand_ecc_strength_good() local
4059 struct nand_ecc_ctrl *ecc = &chip->ecc; in nand_ecc_strength_good()
4062 if (ecc->size == 0 || chip->ecc_step_ds == 0) in nand_ecc_strength_good()
4071 ds_corr = (mtd->writesize * chip->ecc_strength_ds) / chip->ecc_step_ds; in nand_ecc_strength_good()
4073 return corr >= ds_corr && ecc->strength >= chip->ecc_strength_ds; in nand_ecc_strength_good()
4087 struct nand_chip *chip = mtd->priv; in nand_scan_tail() local
4088 struct nand_ecc_ctrl *ecc = &chip->ecc; in nand_scan_tail()
4092 BUG_ON((chip->bbt_options & NAND_BBT_NO_OOB_BBM) && in nand_scan_tail()
4093 !(chip->bbt_options & NAND_BBT_USE_FLASH)); in nand_scan_tail()
4095 if (!(chip->options & NAND_OWN_BUFFERS)) { in nand_scan_tail()
4104 chip->buffers = nbuf; in nand_scan_tail()
4106 if (!chip->buffers) in nand_scan_tail()
4111 chip->oob_poi = chip->buffers->databuf + mtd->writesize; in nand_scan_tail()
4137 if (!chip->write_page) in nand_scan_tail()
4138 chip->write_page = nand_write_page; in nand_scan_tail()
4310 if (!(chip->options & NAND_NO_SUBPAGE_WRITE) && nand_is_slc(chip)) { in nand_scan_tail()
4322 chip->subpagesize = mtd->writesize >> mtd->subpage_sft; in nand_scan_tail()
4325 chip->state = FL_READY; in nand_scan_tail()
4328 chip->pagebuf = -1; in nand_scan_tail()
4334 if (chip->page_shift > 9) in nand_scan_tail()
4335 chip->options |= NAND_SUBPAGE_READ; in nand_scan_tail()
4343 mtd->type = nand_is_slc(chip) ? MTD_NANDFLASH : MTD_MLCNANDFLASH; in nand_scan_tail()
4344 mtd->flags = (chip->options & NAND_ROM) ? MTD_CAP_ROM : in nand_scan_tail()
4378 if (chip->options & NAND_SKIP_BBTSCAN) in nand_scan_tail()
4382 return chip->scan_bbt(mtd); in nand_scan_tail()
4424 struct nand_chip *chip = mtd->priv; in nand_release() local
4426 if (chip->ecc.mode == NAND_ECC_SOFT_BCH) in nand_release()
4427 nand_bch_free((struct nand_bch_control *)chip->ecc.priv); in nand_release()
4432 kfree(chip->bbt); in nand_release()
4433 if (!(chip->options & NAND_OWN_BUFFERS)) in nand_release()
4434 kfree(chip->buffers); in nand_release()
4437 if (chip->badblock_pattern && chip->badblock_pattern->options in nand_release()
4439 kfree(chip->badblock_pattern); in nand_release()