Lines Matching refs:chip
110 struct nand_chip *chip = mtd->priv; in check_offs_len() local
114 if (ofs & ((1ULL << chip->phys_erase_shift) - 1)) { in check_offs_len()
120 if (len & ((1ULL << chip->phys_erase_shift) - 1)) { in check_offs_len()
136 struct nand_chip *chip = mtd->priv; in nand_release_device() local
139 spin_lock(&chip->controller->lock); in nand_release_device()
140 chip->controller->active = NULL; in nand_release_device()
141 chip->state = FL_READY; in nand_release_device()
142 wake_up(&chip->controller->wq); in nand_release_device()
143 spin_unlock(&chip->controller->lock); in nand_release_device()
154 struct nand_chip *chip = mtd->priv; in nand_read_byte() local
155 return readb(chip->IO_ADDR_R); in nand_read_byte()
167 struct nand_chip *chip = mtd->priv; in nand_read_byte16() local
168 return (uint8_t) cpu_to_le16(readw(chip->IO_ADDR_R)); in nand_read_byte16()
179 struct nand_chip *chip = mtd->priv; in nand_read_word() local
180 return readw(chip->IO_ADDR_R); in nand_read_word()
192 struct nand_chip *chip = mtd->priv; in nand_select_chip() local
196 chip->cmd_ctrl(mtd, NAND_CMD_NONE, 0 | NAND_CTRL_CHANGE); in nand_select_chip()
215 struct nand_chip *chip = mtd->priv; in nand_write_byte() local
217 chip->write_buf(mtd, &byte, 1); in nand_write_byte()
229 struct nand_chip *chip = mtd->priv; in nand_write_byte16() local
248 chip->write_buf(mtd, (uint8_t *)&word, 2); in nand_write_byte16()
261 struct nand_chip *chip = mtd->priv; in nand_write_buf() local
263 iowrite8_rep(chip->IO_ADDR_W, buf, len); in nand_write_buf()
276 struct nand_chip *chip = mtd->priv; in nand_read_buf() local
278 ioread8_rep(chip->IO_ADDR_R, buf, len); in nand_read_buf()
291 struct nand_chip *chip = mtd->priv; in nand_write_buf16() local
294 iowrite16_rep(chip->IO_ADDR_W, p, len >> 1); in nand_write_buf16()
307 struct nand_chip *chip = mtd->priv; in nand_read_buf16() local
310 ioread16_rep(chip->IO_ADDR_R, p, len >> 1); in nand_read_buf16()
324 struct nand_chip *chip = mtd->priv; in nand_block_bad() local
327 if (chip->bbt_options & NAND_BBT_SCANLASTPAGE) in nand_block_bad()
330 page = (int)(ofs >> chip->page_shift) & chip->pagemask; in nand_block_bad()
333 chipnr = (int)(ofs >> chip->chip_shift); in nand_block_bad()
338 chip->select_chip(mtd, chipnr); in nand_block_bad()
342 if (chip->options & NAND_BUSWIDTH_16) { in nand_block_bad()
343 chip->cmdfunc(mtd, NAND_CMD_READOOB, in nand_block_bad()
344 chip->badblockpos & 0xFE, page); in nand_block_bad()
345 bad = cpu_to_le16(chip->read_word(mtd)); in nand_block_bad()
346 if (chip->badblockpos & 0x1) in nand_block_bad()
351 chip->cmdfunc(mtd, NAND_CMD_READOOB, chip->badblockpos, in nand_block_bad()
353 bad = chip->read_byte(mtd); in nand_block_bad()
356 if (likely(chip->badblockbits == 8)) in nand_block_bad()
359 res = hweight8(bad) < chip->badblockbits; in nand_block_bad()
361 page = (int)(ofs >> chip->page_shift) & chip->pagemask; in nand_block_bad()
363 } while (!res && i < 2 && (chip->bbt_options & NAND_BBT_SCAN2NDPAGE)); in nand_block_bad()
366 chip->select_chip(mtd, -1); in nand_block_bad()
384 struct nand_chip *chip = mtd->priv; in nand_default_block_markbad() local
391 ops.ooboffs = chip->badblockpos; in nand_default_block_markbad()
392 if (chip->options & NAND_BUSWIDTH_16) { in nand_default_block_markbad()
401 if (chip->bbt_options & NAND_BBT_SCANLASTPAGE) in nand_default_block_markbad()
410 } while ((chip->bbt_options & NAND_BBT_SCAN2NDPAGE) && i < 2); in nand_default_block_markbad()
434 struct nand_chip *chip = mtd->priv; in nand_block_markbad_lowlevel() local
437 if (!(chip->bbt_options & NAND_BBT_NO_OOB_BBM)) { in nand_block_markbad_lowlevel()
444 einfo.len = 1ULL << chip->phys_erase_shift; in nand_block_markbad_lowlevel()
449 ret = chip->block_markbad(mtd, ofs); in nand_block_markbad_lowlevel()
454 if (chip->bbt) { in nand_block_markbad_lowlevel()
475 struct nand_chip *chip = mtd->priv; in nand_check_wp() local
478 if (chip->options & NAND_BROKEN_XD) in nand_check_wp()
482 chip->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1); in nand_check_wp()
483 return (chip->read_byte(mtd) & NAND_STATUS_WP) ? 0 : 1; in nand_check_wp()
495 struct nand_chip *chip = mtd->priv; in nand_block_isreserved() local
497 if (!chip->bbt) in nand_block_isreserved()
516 struct nand_chip *chip = mtd->priv; in nand_block_checkbad() local
518 if (!chip->bbt) in nand_block_checkbad()
519 return chip->block_bad(mtd, ofs, getchip); in nand_block_checkbad()
535 struct nand_chip *chip = mtd->priv; in panic_nand_wait_ready() local
540 if (chip->dev_ready(mtd)) in panic_nand_wait_ready()
550 struct nand_chip *chip = mtd->priv; in nand_wait_ready() local
560 if (chip->dev_ready(mtd)) in nand_wait_ready()
577 register struct nand_chip *chip = mtd->priv; in nand_wait_status_ready() local
581 if ((chip->read_byte(mtd) & NAND_STATUS_READY)) in nand_wait_status_ready()
600 register struct nand_chip *chip = mtd->priv; in nand_command() local
618 chip->cmd_ctrl(mtd, readcmd, ctrl); in nand_command()
621 chip->cmd_ctrl(mtd, command, ctrl); in nand_command()
628 if (chip->options & NAND_BUSWIDTH_16 && in nand_command()
631 chip->cmd_ctrl(mtd, column, ctrl); in nand_command()
635 chip->cmd_ctrl(mtd, page_addr, ctrl); in nand_command()
637 chip->cmd_ctrl(mtd, page_addr >> 8, ctrl); in nand_command()
639 if (chip->chipsize > (32 << 20)) in nand_command()
640 chip->cmd_ctrl(mtd, page_addr >> 16, ctrl); in nand_command()
642 chip->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE); in nand_command()
658 if (chip->dev_ready) in nand_command()
660 udelay(chip->chip_delay); in nand_command()
661 chip->cmd_ctrl(mtd, NAND_CMD_STATUS, in nand_command()
663 chip->cmd_ctrl(mtd, in nand_command()
675 if (!chip->dev_ready) { in nand_command()
676 udelay(chip->chip_delay); in nand_command()
703 register struct nand_chip *chip = mtd->priv; in nand_command_lp() local
712 chip->cmd_ctrl(mtd, command, NAND_NCE | NAND_CLE | NAND_CTRL_CHANGE); in nand_command_lp()
720 if (chip->options & NAND_BUSWIDTH_16 && in nand_command_lp()
723 chip->cmd_ctrl(mtd, column, ctrl); in nand_command_lp()
725 chip->cmd_ctrl(mtd, column >> 8, ctrl); in nand_command_lp()
728 chip->cmd_ctrl(mtd, page_addr, ctrl); in nand_command_lp()
729 chip->cmd_ctrl(mtd, page_addr >> 8, in nand_command_lp()
732 if (chip->chipsize > (128 << 20)) in nand_command_lp()
733 chip->cmd_ctrl(mtd, page_addr >> 16, in nand_command_lp()
737 chip->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE); in nand_command_lp()
755 if (chip->dev_ready) in nand_command_lp()
757 udelay(chip->chip_delay); in nand_command_lp()
758 chip->cmd_ctrl(mtd, NAND_CMD_STATUS, in nand_command_lp()
760 chip->cmd_ctrl(mtd, NAND_CMD_NONE, in nand_command_lp()
768 chip->cmd_ctrl(mtd, NAND_CMD_RNDOUTSTART, in nand_command_lp()
770 chip->cmd_ctrl(mtd, NAND_CMD_NONE, in nand_command_lp()
775 chip->cmd_ctrl(mtd, NAND_CMD_READSTART, in nand_command_lp()
777 chip->cmd_ctrl(mtd, NAND_CMD_NONE, in nand_command_lp()
786 if (!chip->dev_ready) { in nand_command_lp()
787 udelay(chip->chip_delay); in nand_command_lp()
809 static void panic_nand_get_device(struct nand_chip *chip, in panic_nand_get_device() argument
813 chip->controller->active = chip; in panic_nand_get_device()
814 chip->state = new_state; in panic_nand_get_device()
827 struct nand_chip *chip = mtd->priv; in nand_get_device() local
828 spinlock_t *lock = &chip->controller->lock; in nand_get_device()
829 wait_queue_head_t *wq = &chip->controller->wq; in nand_get_device()
835 if (!chip->controller->active) in nand_get_device()
836 chip->controller->active = chip; in nand_get_device()
838 if (chip->controller->active == chip && chip->state == FL_READY) { in nand_get_device()
839 chip->state = new_state; in nand_get_device()
844 if (chip->controller->active->state == FL_PM_SUSPENDED) { in nand_get_device()
845 chip->state = FL_PM_SUSPENDED; in nand_get_device()
868 static void panic_nand_wait(struct mtd_info *mtd, struct nand_chip *chip, in panic_nand_wait() argument
873 if (chip->dev_ready) { in panic_nand_wait()
874 if (chip->dev_ready(mtd)) in panic_nand_wait()
877 if (chip->read_byte(mtd) & NAND_STATUS_READY) in panic_nand_wait()
893 static int nand_wait(struct mtd_info *mtd, struct nand_chip *chip) in nand_wait() argument
896 int status, state = chip->state; in nand_wait()
907 chip->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1); in nand_wait()
910 panic_nand_wait(mtd, chip, timeo); in nand_wait()
914 if (chip->dev_ready) { in nand_wait()
915 if (chip->dev_ready(mtd)) in nand_wait()
918 if (chip->read_byte(mtd) & NAND_STATUS_READY) in nand_wait()
926 status = (int)chip->read_byte(mtd); in nand_wait()
949 struct nand_chip *chip = mtd->priv; in __nand_unlock() local
952 page = ofs >> chip->page_shift; in __nand_unlock()
953 chip->cmdfunc(mtd, NAND_CMD_UNLOCK1, -1, page & chip->pagemask); in __nand_unlock()
956 page = (ofs + len) >> chip->page_shift; in __nand_unlock()
957 chip->cmdfunc(mtd, NAND_CMD_UNLOCK2, -1, in __nand_unlock()
958 (page | invert) & chip->pagemask); in __nand_unlock()
961 status = chip->waitfunc(mtd, chip); in __nand_unlock()
984 struct nand_chip *chip = mtd->priv; in nand_unlock() local
999 chipnr = ofs >> chip->chip_shift; in nand_unlock()
1001 chip->select_chip(mtd, chipnr); in nand_unlock()
1010 chip->cmdfunc(mtd, NAND_CMD_RESET, -1, -1); in nand_unlock()
1023 chip->select_chip(mtd, -1); in nand_unlock()
1047 struct nand_chip *chip = mtd->priv; in nand_lock() local
1058 chipnr = ofs >> chip->chip_shift; in nand_lock()
1060 chip->select_chip(mtd, chipnr); in nand_lock()
1069 chip->cmdfunc(mtd, NAND_CMD_RESET, -1, -1); in nand_lock()
1081 page = ofs >> chip->page_shift; in nand_lock()
1082 chip->cmdfunc(mtd, NAND_CMD_LOCK, -1, page & chip->pagemask); in nand_lock()
1085 status = chip->waitfunc(mtd, chip); in nand_lock()
1097 chip->select_chip(mtd, -1); in nand_lock()
1114 static int nand_read_page_raw(struct mtd_info *mtd, struct nand_chip *chip, in nand_read_page_raw() argument
1117 chip->read_buf(mtd, buf, mtd->writesize); in nand_read_page_raw()
1119 chip->read_buf(mtd, chip->oob_poi, mtd->oobsize); in nand_read_page_raw()
1134 struct nand_chip *chip, uint8_t *buf, in nand_read_page_raw_syndrome() argument
1137 int eccsize = chip->ecc.size; in nand_read_page_raw_syndrome()
1138 int eccbytes = chip->ecc.bytes; in nand_read_page_raw_syndrome()
1139 uint8_t *oob = chip->oob_poi; in nand_read_page_raw_syndrome()
1142 for (steps = chip->ecc.steps; steps > 0; steps--) { in nand_read_page_raw_syndrome()
1143 chip->read_buf(mtd, buf, eccsize); in nand_read_page_raw_syndrome()
1146 if (chip->ecc.prepad) { in nand_read_page_raw_syndrome()
1147 chip->read_buf(mtd, oob, chip->ecc.prepad); in nand_read_page_raw_syndrome()
1148 oob += chip->ecc.prepad; in nand_read_page_raw_syndrome()
1151 chip->read_buf(mtd, oob, eccbytes); in nand_read_page_raw_syndrome()
1154 if (chip->ecc.postpad) { in nand_read_page_raw_syndrome()
1155 chip->read_buf(mtd, oob, chip->ecc.postpad); in nand_read_page_raw_syndrome()
1156 oob += chip->ecc.postpad; in nand_read_page_raw_syndrome()
1160 size = mtd->oobsize - (oob - chip->oob_poi); in nand_read_page_raw_syndrome()
1162 chip->read_buf(mtd, oob, size); in nand_read_page_raw_syndrome()
1175 static int nand_read_page_swecc(struct mtd_info *mtd, struct nand_chip *chip, in nand_read_page_swecc() argument
1178 int i, eccsize = chip->ecc.size; in nand_read_page_swecc()
1179 int eccbytes = chip->ecc.bytes; in nand_read_page_swecc()
1180 int eccsteps = chip->ecc.steps; in nand_read_page_swecc()
1182 uint8_t *ecc_calc = chip->buffers->ecccalc; in nand_read_page_swecc()
1183 uint8_t *ecc_code = chip->buffers->ecccode; in nand_read_page_swecc()
1184 uint32_t *eccpos = chip->ecc.layout->eccpos; in nand_read_page_swecc()
1187 chip->ecc.read_page_raw(mtd, chip, buf, 1, page); in nand_read_page_swecc()
1190 chip->ecc.calculate(mtd, p, &ecc_calc[i]); in nand_read_page_swecc()
1192 for (i = 0; i < chip->ecc.total; i++) in nand_read_page_swecc()
1193 ecc_code[i] = chip->oob_poi[eccpos[i]]; in nand_read_page_swecc()
1195 eccsteps = chip->ecc.steps; in nand_read_page_swecc()
1201 stat = chip->ecc.correct(mtd, p, &ecc_code[i], &ecc_calc[i]); in nand_read_page_swecc()
1221 static int nand_read_subpage(struct mtd_info *mtd, struct nand_chip *chip, in nand_read_subpage() argument
1226 uint32_t *eccpos = chip->ecc.layout->eccpos; in nand_read_subpage()
1230 int busw = (chip->options & NAND_BUSWIDTH_16) ? 2 : 1; in nand_read_subpage()
1235 start_step = data_offs / chip->ecc.size; in nand_read_subpage()
1236 end_step = (data_offs + readlen - 1) / chip->ecc.size; in nand_read_subpage()
1238 index = start_step * chip->ecc.bytes; in nand_read_subpage()
1241 datafrag_len = num_steps * chip->ecc.size; in nand_read_subpage()
1242 eccfrag_len = num_steps * chip->ecc.bytes; in nand_read_subpage()
1244 data_col_addr = start_step * chip->ecc.size; in nand_read_subpage()
1247 chip->cmdfunc(mtd, NAND_CMD_RNDOUT, data_col_addr, -1); in nand_read_subpage()
1250 chip->read_buf(mtd, p, datafrag_len); in nand_read_subpage()
1253 for (i = 0; i < eccfrag_len ; i += chip->ecc.bytes, p += chip->ecc.size) in nand_read_subpage()
1254 chip->ecc.calculate(mtd, p, &chip->buffers->ecccalc[i]); in nand_read_subpage()
1267 chip->cmdfunc(mtd, NAND_CMD_RNDOUT, mtd->writesize, -1); in nand_read_subpage()
1268 chip->read_buf(mtd, chip->oob_poi, mtd->oobsize); in nand_read_subpage()
1278 if (eccpos[index + (num_steps * chip->ecc.bytes)] & (busw - 1)) in nand_read_subpage()
1281 chip->cmdfunc(mtd, NAND_CMD_RNDOUT, in nand_read_subpage()
1283 chip->read_buf(mtd, &chip->oob_poi[aligned_pos], aligned_len); in nand_read_subpage()
1287 chip->buffers->ecccode[i] = chip->oob_poi[eccpos[i + index]]; in nand_read_subpage()
1290 for (i = 0; i < eccfrag_len ; i += chip->ecc.bytes, p += chip->ecc.size) { in nand_read_subpage()
1293 stat = chip->ecc.correct(mtd, p, in nand_read_subpage()
1294 &chip->buffers->ecccode[i], &chip->buffers->ecccalc[i]); in nand_read_subpage()
1315 static int nand_read_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip, in nand_read_page_hwecc() argument
1318 int i, eccsize = chip->ecc.size; in nand_read_page_hwecc()
1319 int eccbytes = chip->ecc.bytes; in nand_read_page_hwecc()
1320 int eccsteps = chip->ecc.steps; in nand_read_page_hwecc()
1322 uint8_t *ecc_calc = chip->buffers->ecccalc; in nand_read_page_hwecc()
1323 uint8_t *ecc_code = chip->buffers->ecccode; in nand_read_page_hwecc()
1324 uint32_t *eccpos = chip->ecc.layout->eccpos; in nand_read_page_hwecc()
1328 chip->ecc.hwctl(mtd, NAND_ECC_READ); in nand_read_page_hwecc()
1329 chip->read_buf(mtd, p, eccsize); in nand_read_page_hwecc()
1330 chip->ecc.calculate(mtd, p, &ecc_calc[i]); in nand_read_page_hwecc()
1332 chip->read_buf(mtd, chip->oob_poi, mtd->oobsize); in nand_read_page_hwecc()
1334 for (i = 0; i < chip->ecc.total; i++) in nand_read_page_hwecc()
1335 ecc_code[i] = chip->oob_poi[eccpos[i]]; in nand_read_page_hwecc()
1337 eccsteps = chip->ecc.steps; in nand_read_page_hwecc()
1343 stat = chip->ecc.correct(mtd, p, &ecc_code[i], &ecc_calc[i]); in nand_read_page_hwecc()
1369 struct nand_chip *chip, uint8_t *buf, int oob_required, int page) in nand_read_page_hwecc_oob_first() argument
1371 int i, eccsize = chip->ecc.size; in nand_read_page_hwecc_oob_first()
1372 int eccbytes = chip->ecc.bytes; in nand_read_page_hwecc_oob_first()
1373 int eccsteps = chip->ecc.steps; in nand_read_page_hwecc_oob_first()
1375 uint8_t *ecc_code = chip->buffers->ecccode; in nand_read_page_hwecc_oob_first()
1376 uint32_t *eccpos = chip->ecc.layout->eccpos; in nand_read_page_hwecc_oob_first()
1377 uint8_t *ecc_calc = chip->buffers->ecccalc; in nand_read_page_hwecc_oob_first()
1381 chip->cmdfunc(mtd, NAND_CMD_READOOB, 0, page); in nand_read_page_hwecc_oob_first()
1382 chip->read_buf(mtd, chip->oob_poi, mtd->oobsize); in nand_read_page_hwecc_oob_first()
1383 chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page); in nand_read_page_hwecc_oob_first()
1385 for (i = 0; i < chip->ecc.total; i++) in nand_read_page_hwecc_oob_first()
1386 ecc_code[i] = chip->oob_poi[eccpos[i]]; in nand_read_page_hwecc_oob_first()
1391 chip->ecc.hwctl(mtd, NAND_ECC_READ); in nand_read_page_hwecc_oob_first()
1392 chip->read_buf(mtd, p, eccsize); in nand_read_page_hwecc_oob_first()
1393 chip->ecc.calculate(mtd, p, &ecc_calc[i]); in nand_read_page_hwecc_oob_first()
1395 stat = chip->ecc.correct(mtd, p, &ecc_code[i], NULL); in nand_read_page_hwecc_oob_first()
1417 static int nand_read_page_syndrome(struct mtd_info *mtd, struct nand_chip *chip, in nand_read_page_syndrome() argument
1420 int i, eccsize = chip->ecc.size; in nand_read_page_syndrome()
1421 int eccbytes = chip->ecc.bytes; in nand_read_page_syndrome()
1422 int eccsteps = chip->ecc.steps; in nand_read_page_syndrome()
1424 uint8_t *oob = chip->oob_poi; in nand_read_page_syndrome()
1430 chip->ecc.hwctl(mtd, NAND_ECC_READ); in nand_read_page_syndrome()
1431 chip->read_buf(mtd, p, eccsize); in nand_read_page_syndrome()
1433 if (chip->ecc.prepad) { in nand_read_page_syndrome()
1434 chip->read_buf(mtd, oob, chip->ecc.prepad); in nand_read_page_syndrome()
1435 oob += chip->ecc.prepad; in nand_read_page_syndrome()
1438 chip->ecc.hwctl(mtd, NAND_ECC_READSYN); in nand_read_page_syndrome()
1439 chip->read_buf(mtd, oob, eccbytes); in nand_read_page_syndrome()
1440 stat = chip->ecc.correct(mtd, p, oob, NULL); in nand_read_page_syndrome()
1451 if (chip->ecc.postpad) { in nand_read_page_syndrome()
1452 chip->read_buf(mtd, oob, chip->ecc.postpad); in nand_read_page_syndrome()
1453 oob += chip->ecc.postpad; in nand_read_page_syndrome()
1458 i = mtd->oobsize - (oob - chip->oob_poi); in nand_read_page_syndrome()
1460 chip->read_buf(mtd, oob, i); in nand_read_page_syndrome()
1472 static uint8_t *nand_transfer_oob(struct nand_chip *chip, uint8_t *oob, in nand_transfer_oob() argument
1479 memcpy(oob, chip->oob_poi + ops->ooboffs, len); in nand_transfer_oob()
1483 struct nand_oobfree *free = chip->ecc.layout->oobfree; in nand_transfer_oob()
1502 memcpy(oob, chip->oob_poi + boffs, bytes); in nand_transfer_oob()
1524 struct nand_chip *chip = mtd->priv; in nand_setup_read_retry() local
1528 if (retry_mode >= chip->read_retries) in nand_setup_read_retry()
1531 if (!chip->setup_read_retry) in nand_setup_read_retry()
1534 return chip->setup_read_retry(mtd, retry_mode); in nand_setup_read_retry()
1549 struct nand_chip *chip = mtd->priv; in nand_do_read_ops() local
1562 chipnr = (int)(from >> chip->chip_shift); in nand_do_read_ops()
1563 chip->select_chip(mtd, chipnr); in nand_do_read_ops()
1565 realpage = (int)(from >> chip->page_shift); in nand_do_read_ops()
1566 page = realpage & chip->pagemask; in nand_do_read_ops()
1582 else if (chip->options & NAND_USE_BOUNCE_BUFFER) in nand_do_read_ops()
1588 if (realpage != chip->pagebuf || oob) { in nand_do_read_ops()
1589 bufpoi = use_bufpoi ? chip->buffers->databuf : buf; in nand_do_read_ops()
1596 chip->cmdfunc(mtd, NAND_CMD_READ0, 0x00, page); in nand_do_read_ops()
1603 ret = chip->ecc.read_page_raw(mtd, chip, bufpoi, in nand_do_read_ops()
1606 else if (!aligned && NAND_HAS_SUBPAGE_READ(chip) && in nand_do_read_ops()
1608 ret = chip->ecc.read_subpage(mtd, chip, in nand_do_read_ops()
1612 ret = chip->ecc.read_page(mtd, chip, bufpoi, in nand_do_read_ops()
1617 chip->pagebuf = -1; in nand_do_read_ops()
1625 if (!NAND_HAS_SUBPAGE_READ(chip) && !oob && in nand_do_read_ops()
1628 chip->pagebuf = realpage; in nand_do_read_ops()
1629 chip->pagebuf_bitflips = ret; in nand_do_read_ops()
1632 chip->pagebuf = -1; in nand_do_read_ops()
1634 memcpy(buf, chip->buffers->databuf + col, bytes); in nand_do_read_ops()
1641 oob = nand_transfer_oob(chip, in nand_do_read_ops()
1647 if (chip->options & NAND_NEED_READRDY) { in nand_do_read_ops()
1649 if (!chip->dev_ready) in nand_do_read_ops()
1650 udelay(chip->chip_delay); in nand_do_read_ops()
1656 if (retry_mode + 1 < chip->read_retries) { in nand_do_read_ops()
1674 memcpy(buf, chip->buffers->databuf + col, bytes); in nand_do_read_ops()
1677 chip->pagebuf_bitflips); in nand_do_read_ops()
1698 page = realpage & chip->pagemask; in nand_do_read_ops()
1702 chip->select_chip(mtd, -1); in nand_do_read_ops()
1703 chip->select_chip(mtd, chipnr); in nand_do_read_ops()
1706 chip->select_chip(mtd, -1); in nand_do_read_ops()
1754 static int nand_read_oob_std(struct mtd_info *mtd, struct nand_chip *chip, in nand_read_oob_std() argument
1757 chip->cmdfunc(mtd, NAND_CMD_READOOB, 0, page); in nand_read_oob_std()
1758 chip->read_buf(mtd, chip->oob_poi, mtd->oobsize); in nand_read_oob_std()
1769 static int nand_read_oob_syndrome(struct mtd_info *mtd, struct nand_chip *chip, in nand_read_oob_syndrome() argument
1773 int chunk = chip->ecc.bytes + chip->ecc.prepad + chip->ecc.postpad; in nand_read_oob_syndrome()
1774 int eccsize = chip->ecc.size; in nand_read_oob_syndrome()
1775 uint8_t *bufpoi = chip->oob_poi; in nand_read_oob_syndrome()
1778 chip->cmdfunc(mtd, NAND_CMD_READ0, chip->ecc.size, page); in nand_read_oob_syndrome()
1779 for (i = 0; i < chip->ecc.steps; i++) { in nand_read_oob_syndrome()
1783 chip->cmdfunc(mtd, NAND_CMD_RNDOUT, pos, -1); in nand_read_oob_syndrome()
1785 chip->cmdfunc(mtd, NAND_CMD_READ0, pos, page); in nand_read_oob_syndrome()
1789 chip->read_buf(mtd, bufpoi, toread); in nand_read_oob_syndrome()
1794 chip->read_buf(mtd, bufpoi, length); in nand_read_oob_syndrome()
1805 static int nand_write_oob_std(struct mtd_info *mtd, struct nand_chip *chip, in nand_write_oob_std() argument
1809 const uint8_t *buf = chip->oob_poi; in nand_write_oob_std()
1812 chip->cmdfunc(mtd, NAND_CMD_SEQIN, mtd->writesize, page); in nand_write_oob_std()
1813 chip->write_buf(mtd, buf, length); in nand_write_oob_std()
1815 chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1); in nand_write_oob_std()
1817 status = chip->waitfunc(mtd, chip); in nand_write_oob_std()
1830 struct nand_chip *chip, int page) in nand_write_oob_syndrome() argument
1832 int chunk = chip->ecc.bytes + chip->ecc.prepad + chip->ecc.postpad; in nand_write_oob_syndrome()
1833 int eccsize = chip->ecc.size, length = mtd->oobsize; in nand_write_oob_syndrome()
1834 int i, len, pos, status = 0, sndcmd = 0, steps = chip->ecc.steps; in nand_write_oob_syndrome()
1835 const uint8_t *bufpoi = chip->oob_poi; in nand_write_oob_syndrome()
1842 if (!chip->ecc.prepad && !chip->ecc.postpad) { in nand_write_oob_syndrome()
1848 chip->cmdfunc(mtd, NAND_CMD_SEQIN, pos, page); in nand_write_oob_syndrome()
1857 chip->write_buf(mtd, (uint8_t *)&fill, in nand_write_oob_syndrome()
1863 chip->cmdfunc(mtd, NAND_CMD_RNDIN, pos, -1); in nand_write_oob_syndrome()
1868 chip->write_buf(mtd, bufpoi, len); in nand_write_oob_syndrome()
1873 chip->write_buf(mtd, bufpoi, length); in nand_write_oob_syndrome()
1875 chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1); in nand_write_oob_syndrome()
1876 status = chip->waitfunc(mtd, chip); in nand_write_oob_syndrome()
1893 struct nand_chip *chip = mtd->priv; in nand_do_read_oob() local
1906 len = chip->ecc.layout->oobavail; in nand_do_read_oob()
1918 ops->ooboffs + readlen > ((mtd->size >> chip->page_shift) - in nand_do_read_oob()
1919 (from >> chip->page_shift)) * len)) { in nand_do_read_oob()
1925 chipnr = (int)(from >> chip->chip_shift); in nand_do_read_oob()
1926 chip->select_chip(mtd, chipnr); in nand_do_read_oob()
1929 realpage = (int)(from >> chip->page_shift); in nand_do_read_oob()
1930 page = realpage & chip->pagemask; in nand_do_read_oob()
1934 ret = chip->ecc.read_oob_raw(mtd, chip, page); in nand_do_read_oob()
1936 ret = chip->ecc.read_oob(mtd, chip, page); in nand_do_read_oob()
1942 buf = nand_transfer_oob(chip, buf, ops, len); in nand_do_read_oob()
1944 if (chip->options & NAND_NEED_READRDY) { in nand_do_read_oob()
1946 if (!chip->dev_ready) in nand_do_read_oob()
1947 udelay(chip->chip_delay); in nand_do_read_oob()
1959 page = realpage & chip->pagemask; in nand_do_read_oob()
1963 chip->select_chip(mtd, -1); in nand_do_read_oob()
1964 chip->select_chip(mtd, chipnr); in nand_do_read_oob()
1967 chip->select_chip(mtd, -1); in nand_do_read_oob()
2034 static int nand_write_page_raw(struct mtd_info *mtd, struct nand_chip *chip, in nand_write_page_raw() argument
2037 chip->write_buf(mtd, buf, mtd->writesize); in nand_write_page_raw()
2039 chip->write_buf(mtd, chip->oob_poi, mtd->oobsize); in nand_write_page_raw()
2054 struct nand_chip *chip, in nand_write_page_raw_syndrome() argument
2057 int eccsize = chip->ecc.size; in nand_write_page_raw_syndrome()
2058 int eccbytes = chip->ecc.bytes; in nand_write_page_raw_syndrome()
2059 uint8_t *oob = chip->oob_poi; in nand_write_page_raw_syndrome()
2062 for (steps = chip->ecc.steps; steps > 0; steps--) { in nand_write_page_raw_syndrome()
2063 chip->write_buf(mtd, buf, eccsize); in nand_write_page_raw_syndrome()
2066 if (chip->ecc.prepad) { in nand_write_page_raw_syndrome()
2067 chip->write_buf(mtd, oob, chip->ecc.prepad); in nand_write_page_raw_syndrome()
2068 oob += chip->ecc.prepad; in nand_write_page_raw_syndrome()
2071 chip->write_buf(mtd, oob, eccbytes); in nand_write_page_raw_syndrome()
2074 if (chip->ecc.postpad) { in nand_write_page_raw_syndrome()
2075 chip->write_buf(mtd, oob, chip->ecc.postpad); in nand_write_page_raw_syndrome()
2076 oob += chip->ecc.postpad; in nand_write_page_raw_syndrome()
2080 size = mtd->oobsize - (oob - chip->oob_poi); in nand_write_page_raw_syndrome()
2082 chip->write_buf(mtd, oob, size); in nand_write_page_raw_syndrome()
2093 static int nand_write_page_swecc(struct mtd_info *mtd, struct nand_chip *chip, in nand_write_page_swecc() argument
2096 int i, eccsize = chip->ecc.size; in nand_write_page_swecc()
2097 int eccbytes = chip->ecc.bytes; in nand_write_page_swecc()
2098 int eccsteps = chip->ecc.steps; in nand_write_page_swecc()
2099 uint8_t *ecc_calc = chip->buffers->ecccalc; in nand_write_page_swecc()
2101 uint32_t *eccpos = chip->ecc.layout->eccpos; in nand_write_page_swecc()
2105 chip->ecc.calculate(mtd, p, &ecc_calc[i]); in nand_write_page_swecc()
2107 for (i = 0; i < chip->ecc.total; i++) in nand_write_page_swecc()
2108 chip->oob_poi[eccpos[i]] = ecc_calc[i]; in nand_write_page_swecc()
2110 return chip->ecc.write_page_raw(mtd, chip, buf, 1); in nand_write_page_swecc()
2120 static int nand_write_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip, in nand_write_page_hwecc() argument
2123 int i, eccsize = chip->ecc.size; in nand_write_page_hwecc()
2124 int eccbytes = chip->ecc.bytes; in nand_write_page_hwecc()
2125 int eccsteps = chip->ecc.steps; in nand_write_page_hwecc()
2126 uint8_t *ecc_calc = chip->buffers->ecccalc; in nand_write_page_hwecc()
2128 uint32_t *eccpos = chip->ecc.layout->eccpos; in nand_write_page_hwecc()
2131 chip->ecc.hwctl(mtd, NAND_ECC_WRITE); in nand_write_page_hwecc()
2132 chip->write_buf(mtd, p, eccsize); in nand_write_page_hwecc()
2133 chip->ecc.calculate(mtd, p, &ecc_calc[i]); in nand_write_page_hwecc()
2136 for (i = 0; i < chip->ecc.total; i++) in nand_write_page_hwecc()
2137 chip->oob_poi[eccpos[i]] = ecc_calc[i]; in nand_write_page_hwecc()
2139 chip->write_buf(mtd, chip->oob_poi, mtd->oobsize); in nand_write_page_hwecc()
2155 struct nand_chip *chip, uint32_t offset, in nand_write_subpage_hwecc() argument
2159 uint8_t *oob_buf = chip->oob_poi; in nand_write_subpage_hwecc()
2160 uint8_t *ecc_calc = chip->buffers->ecccalc; in nand_write_subpage_hwecc()
2161 int ecc_size = chip->ecc.size; in nand_write_subpage_hwecc()
2162 int ecc_bytes = chip->ecc.bytes; in nand_write_subpage_hwecc()
2163 int ecc_steps = chip->ecc.steps; in nand_write_subpage_hwecc()
2164 uint32_t *eccpos = chip->ecc.layout->eccpos; in nand_write_subpage_hwecc()
2172 chip->ecc.hwctl(mtd, NAND_ECC_WRITE); in nand_write_subpage_hwecc()
2175 chip->write_buf(mtd, buf, ecc_size); in nand_write_subpage_hwecc()
2181 chip->ecc.calculate(mtd, buf, ecc_calc); in nand_write_subpage_hwecc()
2195 ecc_calc = chip->buffers->ecccalc; in nand_write_subpage_hwecc()
2196 for (i = 0; i < chip->ecc.total; i++) in nand_write_subpage_hwecc()
2197 chip->oob_poi[eccpos[i]] = ecc_calc[i]; in nand_write_subpage_hwecc()
2200 chip->write_buf(mtd, chip->oob_poi, mtd->oobsize); in nand_write_subpage_hwecc()
2217 struct nand_chip *chip, in nand_write_page_syndrome() argument
2220 int i, eccsize = chip->ecc.size; in nand_write_page_syndrome()
2221 int eccbytes = chip->ecc.bytes; in nand_write_page_syndrome()
2222 int eccsteps = chip->ecc.steps; in nand_write_page_syndrome()
2224 uint8_t *oob = chip->oob_poi; in nand_write_page_syndrome()
2228 chip->ecc.hwctl(mtd, NAND_ECC_WRITE); in nand_write_page_syndrome()
2229 chip->write_buf(mtd, p, eccsize); in nand_write_page_syndrome()
2231 if (chip->ecc.prepad) { in nand_write_page_syndrome()
2232 chip->write_buf(mtd, oob, chip->ecc.prepad); in nand_write_page_syndrome()
2233 oob += chip->ecc.prepad; in nand_write_page_syndrome()
2236 chip->ecc.calculate(mtd, p, oob); in nand_write_page_syndrome()
2237 chip->write_buf(mtd, oob, eccbytes); in nand_write_page_syndrome()
2240 if (chip->ecc.postpad) { in nand_write_page_syndrome()
2241 chip->write_buf(mtd, oob, chip->ecc.postpad); in nand_write_page_syndrome()
2242 oob += chip->ecc.postpad; in nand_write_page_syndrome()
2247 i = mtd->oobsize - (oob - chip->oob_poi); in nand_write_page_syndrome()
2249 chip->write_buf(mtd, oob, i); in nand_write_page_syndrome()
2266 static int nand_write_page(struct mtd_info *mtd, struct nand_chip *chip, in nand_write_page() argument
2272 if (!(chip->options & NAND_NO_SUBPAGE_WRITE) && in nand_write_page()
2273 chip->ecc.write_subpage) in nand_write_page()
2278 chip->cmdfunc(mtd, NAND_CMD_SEQIN, 0x00, page); in nand_write_page()
2281 status = chip->ecc.write_page_raw(mtd, chip, buf, in nand_write_page()
2284 status = chip->ecc.write_subpage(mtd, chip, offset, data_len, in nand_write_page()
2287 status = chip->ecc.write_page(mtd, chip, buf, oob_required); in nand_write_page()
2298 if (!cached || !NAND_HAS_CACHEPROG(chip)) { in nand_write_page()
2300 chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1); in nand_write_page()
2301 status = chip->waitfunc(mtd, chip); in nand_write_page()
2306 if ((status & NAND_STATUS_FAIL) && (chip->errstat)) in nand_write_page()
2307 status = chip->errstat(mtd, chip, FL_WRITING, status, in nand_write_page()
2313 chip->cmdfunc(mtd, NAND_CMD_CACHEDPROG, -1, -1); in nand_write_page()
2314 status = chip->waitfunc(mtd, chip); in nand_write_page()
2330 struct nand_chip *chip = mtd->priv; in nand_fill_oob() local
2336 memset(chip->oob_poi, 0xff, mtd->oobsize); in nand_fill_oob()
2342 memcpy(chip->oob_poi + ops->ooboffs, oob, len); in nand_fill_oob()
2346 struct nand_oobfree *free = chip->ecc.layout->oobfree; in nand_fill_oob()
2365 memcpy(chip->oob_poi + boffs, oob, bytes); in nand_fill_oob()
2376 #define NOTALIGNED(x) ((x & (chip->subpagesize - 1)) != 0)
2390 struct nand_chip *chip = mtd->priv; in nand_do_write_ops() local
2415 chipnr = (int)(to >> chip->chip_shift); in nand_do_write_ops()
2416 chip->select_chip(mtd, chipnr); in nand_do_write_ops()
2424 realpage = (int)(to >> chip->page_shift); in nand_do_write_ops()
2425 page = realpage & chip->pagemask; in nand_do_write_ops()
2426 blockmask = (1 << (chip->phys_erase_shift - chip->page_shift)) - 1; in nand_do_write_ops()
2429 if (to <= ((loff_t)chip->pagebuf << chip->page_shift) && in nand_do_write_ops()
2430 ((loff_t)chip->pagebuf << chip->page_shift) < (to + ops->len)) in nand_do_write_ops()
2431 chip->pagebuf = -1; in nand_do_write_ops()
2448 else if (chip->options & NAND_USE_BOUNCE_BUFFER) in nand_do_write_ops()
2460 chip->pagebuf = -1; in nand_do_write_ops()
2461 memset(chip->buffers->databuf, 0xff, mtd->writesize); in nand_do_write_ops()
2462 memcpy(&chip->buffers->databuf[column], buf, bytes); in nand_do_write_ops()
2463 wbuf = chip->buffers->databuf; in nand_do_write_ops()
2472 memset(chip->oob_poi, 0xff, mtd->oobsize); in nand_do_write_ops()
2474 ret = chip->write_page(mtd, chip, column, bytes, wbuf, in nand_do_write_ops()
2488 page = realpage & chip->pagemask; in nand_do_write_ops()
2492 chip->select_chip(mtd, -1); in nand_do_write_ops()
2493 chip->select_chip(mtd, chipnr); in nand_do_write_ops()
2502 chip->select_chip(mtd, -1); in nand_do_write_ops()
2520 struct nand_chip *chip = mtd->priv; in panic_nand_write() local
2525 panic_nand_wait(mtd, chip, 400); in panic_nand_write()
2528 panic_nand_get_device(chip, mtd, FL_WRITING); in panic_nand_write()
2580 struct nand_chip *chip = mtd->priv; in nand_do_write_oob() local
2586 len = chip->ecc.layout->oobavail; in nand_do_write_oob()
2606 ((mtd->size >> chip->page_shift) - in nand_do_write_oob()
2607 (to >> chip->page_shift)) * len)) { in nand_do_write_oob()
2613 chipnr = (int)(to >> chip->chip_shift); in nand_do_write_oob()
2614 chip->select_chip(mtd, chipnr); in nand_do_write_oob()
2617 page = (int)(to >> chip->page_shift); in nand_do_write_oob()
2625 chip->cmdfunc(mtd, NAND_CMD_RESET, -1, -1); in nand_do_write_oob()
2629 chip->select_chip(mtd, -1); in nand_do_write_oob()
2634 if (page == chip->pagebuf) in nand_do_write_oob()
2635 chip->pagebuf = -1; in nand_do_write_oob()
2640 status = chip->ecc.write_oob_raw(mtd, chip, page & chip->pagemask); in nand_do_write_oob()
2642 status = chip->ecc.write_oob(mtd, chip, page & chip->pagemask); in nand_do_write_oob()
2644 chip->select_chip(mtd, -1); in nand_do_write_oob()
2705 struct nand_chip *chip = mtd->priv; in single_erase() local
2707 chip->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page); in single_erase()
2708 chip->cmdfunc(mtd, NAND_CMD_ERASE2, -1, -1); in single_erase()
2710 return chip->waitfunc(mtd, chip); in single_erase()
2737 struct nand_chip *chip = mtd->priv; in nand_erase_nand() local
2751 page = (int)(instr->addr >> chip->page_shift); in nand_erase_nand()
2752 chipnr = (int)(instr->addr >> chip->chip_shift); in nand_erase_nand()
2755 pages_per_block = 1 << (chip->phys_erase_shift - chip->page_shift); in nand_erase_nand()
2758 chip->select_chip(mtd, chipnr); in nand_erase_nand()
2776 chip->page_shift, 0, allowbbt)) { in nand_erase_nand()
2787 if (page <= chip->pagebuf && chip->pagebuf < in nand_erase_nand()
2789 chip->pagebuf = -1; in nand_erase_nand()
2791 status = chip->erase(mtd, page & chip->pagemask); in nand_erase_nand()
2797 if ((status & NAND_STATUS_FAIL) && (chip->errstat)) in nand_erase_nand()
2798 status = chip->errstat(mtd, chip, FL_ERASING, in nand_erase_nand()
2807 ((loff_t)page << chip->page_shift); in nand_erase_nand()
2812 len -= (1ULL << chip->phys_erase_shift); in nand_erase_nand()
2816 if (len && !(page & chip->pagemask)) { in nand_erase_nand()
2818 chip->select_chip(mtd, -1); in nand_erase_nand()
2819 chip->select_chip(mtd, chipnr); in nand_erase_nand()
2829 chip->select_chip(mtd, -1); in nand_erase_nand()
2893 static int nand_onfi_set_features(struct mtd_info *mtd, struct nand_chip *chip, in nand_onfi_set_features() argument
2899 if (!chip->onfi_version || in nand_onfi_set_features()
2900 !(le16_to_cpu(chip->onfi_params.opt_cmd) in nand_onfi_set_features()
2904 chip->cmdfunc(mtd, NAND_CMD_SET_FEATURES, addr, -1); in nand_onfi_set_features()
2906 chip->write_byte(mtd, subfeature_param[i]); in nand_onfi_set_features()
2908 status = chip->waitfunc(mtd, chip); in nand_onfi_set_features()
2921 static int nand_onfi_get_features(struct mtd_info *mtd, struct nand_chip *chip, in nand_onfi_get_features() argument
2926 if (!chip->onfi_version || in nand_onfi_get_features()
2927 !(le16_to_cpu(chip->onfi_params.opt_cmd) in nand_onfi_get_features()
2934 chip->cmdfunc(mtd, NAND_CMD_GET_FEATURES, addr, -1); in nand_onfi_get_features()
2936 *subfeature_param++ = chip->read_byte(mtd); in nand_onfi_get_features()
2955 struct nand_chip *chip = mtd->priv; in nand_resume() local
2957 if (chip->state == FL_PM_SUSPENDED) in nand_resume()
2975 static void nand_set_defaults(struct nand_chip *chip, int busw) in nand_set_defaults() argument
2978 if (!chip->chip_delay) in nand_set_defaults()
2979 chip->chip_delay = 20; in nand_set_defaults()
2982 if (chip->cmdfunc == NULL) in nand_set_defaults()
2983 chip->cmdfunc = nand_command; in nand_set_defaults()
2986 if (chip->waitfunc == NULL) in nand_set_defaults()
2987 chip->waitfunc = nand_wait; in nand_set_defaults()
2989 if (!chip->select_chip) in nand_set_defaults()
2990 chip->select_chip = nand_select_chip; in nand_set_defaults()
2993 if (!chip->onfi_set_features) in nand_set_defaults()
2994 chip->onfi_set_features = nand_onfi_set_features; in nand_set_defaults()
2995 if (!chip->onfi_get_features) in nand_set_defaults()
2996 chip->onfi_get_features = nand_onfi_get_features; in nand_set_defaults()
2999 if (!chip->read_byte || chip->read_byte == nand_read_byte) in nand_set_defaults()
3000 chip->read_byte = busw ? nand_read_byte16 : nand_read_byte; in nand_set_defaults()
3001 if (!chip->read_word) in nand_set_defaults()
3002 chip->read_word = nand_read_word; in nand_set_defaults()
3003 if (!chip->block_bad) in nand_set_defaults()
3004 chip->block_bad = nand_block_bad; in nand_set_defaults()
3005 if (!chip->block_markbad) in nand_set_defaults()
3006 chip->block_markbad = nand_default_block_markbad; in nand_set_defaults()
3007 if (!chip->write_buf || chip->write_buf == nand_write_buf) in nand_set_defaults()
3008 chip->write_buf = busw ? nand_write_buf16 : nand_write_buf; in nand_set_defaults()
3009 if (!chip->write_byte || chip->write_byte == nand_write_byte) in nand_set_defaults()
3010 chip->write_byte = busw ? nand_write_byte16 : nand_write_byte; in nand_set_defaults()
3011 if (!chip->read_buf || chip->read_buf == nand_read_buf) in nand_set_defaults()
3012 chip->read_buf = busw ? nand_read_buf16 : nand_read_buf; in nand_set_defaults()
3013 if (!chip->scan_bbt) in nand_set_defaults()
3014 chip->scan_bbt = nand_default_bbt; in nand_set_defaults()
3016 if (!chip->controller) { in nand_set_defaults()
3017 chip->controller = &chip->hwcontrol; in nand_set_defaults()
3018 spin_lock_init(&chip->controller->lock); in nand_set_defaults()
3019 init_waitqueue_head(&chip->controller->wq); in nand_set_defaults()
3056 struct nand_chip *chip, struct nand_onfi_params *p) in nand_flash_detect_ext_param_page() argument
3072 chip->cmdfunc(mtd, NAND_CMD_PARAM, 0, -1); in nand_flash_detect_ext_param_page()
3075 chip->cmdfunc(mtd, NAND_CMD_RNDOUT, in nand_flash_detect_ext_param_page()
3079 chip->read_buf(mtd, (uint8_t *)ep, len); in nand_flash_detect_ext_param_page()
3116 chip->ecc_strength_ds = ecc->ecc_bits; in nand_flash_detect_ext_param_page()
3117 chip->ecc_step_ds = 1 << ecc->codeword_size; in nand_flash_detect_ext_param_page()
3127 struct nand_chip *chip = mtd->priv; in nand_setup_read_retry_micron() local
3130 return chip->onfi_set_features(mtd, chip, ONFI_FEATURE_ADDR_READ_RETRY, in nand_setup_read_retry_micron()
3137 static void nand_onfi_detect_micron(struct nand_chip *chip, in nand_onfi_detect_micron() argument
3145 chip->read_retries = micron->read_retry_options; in nand_onfi_detect_micron()
3146 chip->setup_read_retry = nand_setup_read_retry_micron; in nand_onfi_detect_micron()
3152 static int nand_flash_detect_onfi(struct mtd_info *mtd, struct nand_chip *chip, in nand_flash_detect_onfi() argument
3155 struct nand_onfi_params *p = &chip->onfi_params; in nand_flash_detect_onfi()
3160 chip->cmdfunc(mtd, NAND_CMD_READID, 0x20, -1); in nand_flash_detect_onfi()
3161 if (chip->read_byte(mtd) != 'O' || chip->read_byte(mtd) != 'N' || in nand_flash_detect_onfi()
3162 chip->read_byte(mtd) != 'F' || chip->read_byte(mtd) != 'I') in nand_flash_detect_onfi()
3165 chip->cmdfunc(mtd, NAND_CMD_PARAM, 0, -1); in nand_flash_detect_onfi()
3168 ((uint8_t *)p)[j] = chip->read_byte(mtd); in nand_flash_detect_onfi()
3183 chip->onfi_version = 23; in nand_flash_detect_onfi()
3185 chip->onfi_version = 22; in nand_flash_detect_onfi()
3187 chip->onfi_version = 21; in nand_flash_detect_onfi()
3189 chip->onfi_version = 20; in nand_flash_detect_onfi()
3191 chip->onfi_version = 10; in nand_flash_detect_onfi()
3193 if (!chip->onfi_version) { in nand_flash_detect_onfi()
3216 chip->chipsize = 1 << (fls(le32_to_cpu(p->blocks_per_lun)) - 1); in nand_flash_detect_onfi()
3217 chip->chipsize *= (uint64_t)mtd->erasesize * p->lun_count; in nand_flash_detect_onfi()
3218 chip->bits_per_cell = p->bits_per_cell; in nand_flash_detect_onfi()
3220 if (onfi_feature(chip) & ONFI_FEATURE_16_BIT_BUS) in nand_flash_detect_onfi()
3226 chip->ecc_strength_ds = p->ecc_bits; in nand_flash_detect_onfi()
3227 chip->ecc_step_ds = 512; in nand_flash_detect_onfi()
3228 } else if (chip->onfi_version >= 21 && in nand_flash_detect_onfi()
3229 (onfi_feature(chip) & ONFI_FEATURE_EXT_PARAM_PAGE)) { in nand_flash_detect_onfi()
3237 if (mtd->writesize > 512 && chip->cmdfunc == nand_command) in nand_flash_detect_onfi()
3238 chip->cmdfunc = nand_command_lp; in nand_flash_detect_onfi()
3241 if (nand_flash_detect_ext_param_page(mtd, chip, p)) in nand_flash_detect_onfi()
3248 nand_onfi_detect_micron(chip, p); in nand_flash_detect_onfi()
3256 static int nand_flash_detect_jedec(struct mtd_info *mtd, struct nand_chip *chip, in nand_flash_detect_jedec() argument
3259 struct nand_jedec_params *p = &chip->jedec_params; in nand_flash_detect_jedec()
3265 chip->cmdfunc(mtd, NAND_CMD_READID, 0x40, -1); in nand_flash_detect_jedec()
3266 if (chip->read_byte(mtd) != 'J' || chip->read_byte(mtd) != 'E' || in nand_flash_detect_jedec()
3267 chip->read_byte(mtd) != 'D' || chip->read_byte(mtd) != 'E' || in nand_flash_detect_jedec()
3268 chip->read_byte(mtd) != 'C') in nand_flash_detect_jedec()
3271 chip->cmdfunc(mtd, NAND_CMD_PARAM, 0x40, -1); in nand_flash_detect_jedec()
3274 ((uint8_t *)p)[j] = chip->read_byte(mtd); in nand_flash_detect_jedec()
3289 chip->jedec_version = 10; in nand_flash_detect_jedec()
3291 chip->jedec_version = 1; /* vendor specific version */ in nand_flash_detect_jedec()
3293 if (!chip->jedec_version) { in nand_flash_detect_jedec()
3312 chip->chipsize = 1 << (fls(le32_to_cpu(p->blocks_per_lun)) - 1); in nand_flash_detect_jedec()
3313 chip->chipsize *= (uint64_t)mtd->erasesize * p->lun_count; in nand_flash_detect_jedec()
3314 chip->bits_per_cell = p->bits_per_cell; in nand_flash_detect_jedec()
3316 if (jedec_feature(chip) & JEDEC_FEATURE_16_BIT_BUS) in nand_flash_detect_jedec()
3325 chip->ecc_strength_ds = ecc->ecc_bits; in nand_flash_detect_jedec()
3326 chip->ecc_step_ds = 1 << ecc->codeword_size; in nand_flash_detect_jedec()
3408 static void nand_decode_ext_id(struct mtd_info *mtd, struct nand_chip *chip, in nand_decode_ext_id() argument
3413 chip->bits_per_cell = nand_get_bits_per_cell(id_data[2]); in nand_decode_ext_id()
3429 !nand_is_slc(chip) && id_data[5] != 0x00) { in nand_decode_ext_id()
3464 !nand_is_slc(chip)) { in nand_decode_ext_id()
3527 nand_is_slc(chip) && in nand_decode_ext_id()
3541 static void nand_decode_id(struct mtd_info *mtd, struct nand_chip *chip, in nand_decode_id() argument
3553 chip->bits_per_cell = 1; in nand_decode_id()
3575 struct nand_chip *chip, u8 id_data[8]) in nand_decode_bbm_options() argument
3580 if (mtd->writesize > 512 || (chip->options & NAND_BUSWIDTH_16)) in nand_decode_bbm_options()
3581 chip->badblockpos = NAND_LARGE_BADBLOCK_POS; in nand_decode_bbm_options()
3583 chip->badblockpos = NAND_SMALL_BADBLOCK_POS; in nand_decode_bbm_options()
3591 if (!nand_is_slc(chip) && in nand_decode_bbm_options()
3594 chip->bbt_options |= NAND_BBT_SCANLASTPAGE; in nand_decode_bbm_options()
3595 else if ((nand_is_slc(chip) && in nand_decode_bbm_options()
3603 chip->bbt_options |= NAND_BBT_SCAN2NDPAGE; in nand_decode_bbm_options()
3611 static bool find_full_id_nand(struct mtd_info *mtd, struct nand_chip *chip, in find_full_id_nand() argument
3619 chip->bits_per_cell = nand_get_bits_per_cell(id_data[2]); in find_full_id_nand()
3620 chip->chipsize = (uint64_t)type->chipsize << 20; in find_full_id_nand()
3621 chip->options |= type->options; in find_full_id_nand()
3622 chip->ecc_strength_ds = NAND_ECC_STRENGTH(type); in find_full_id_nand()
3623 chip->ecc_step_ds = NAND_ECC_STEP(type); in find_full_id_nand()
3624 chip->onfi_timing_mode_default = in find_full_id_nand()
3641 struct nand_chip *chip, in nand_get_flash_type() argument
3650 chip->select_chip(mtd, 0); in nand_get_flash_type()
3656 chip->cmdfunc(mtd, NAND_CMD_RESET, -1, -1); in nand_get_flash_type()
3659 chip->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1); in nand_get_flash_type()
3662 *maf_id = chip->read_byte(mtd); in nand_get_flash_type()
3663 *dev_id = chip->read_byte(mtd); in nand_get_flash_type()
3672 chip->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1); in nand_get_flash_type()
3676 id_data[i] = chip->read_byte(mtd); in nand_get_flash_type()
3689 if (find_full_id_nand(mtd, chip, type, id_data, &busw)) in nand_get_flash_type()
3696 chip->onfi_version = 0; in nand_get_flash_type()
3699 if (nand_flash_detect_onfi(mtd, chip, &busw)) in nand_get_flash_type()
3703 if (nand_flash_detect_jedec(mtd, chip, &busw)) in nand_get_flash_type()
3713 chip->chipsize = (uint64_t)type->chipsize << 20; in nand_get_flash_type()
3715 if (!type->pagesize && chip->init_size) { in nand_get_flash_type()
3717 busw = chip->init_size(mtd, chip, id_data); in nand_get_flash_type()
3720 nand_decode_ext_id(mtd, chip, id_data, &busw); in nand_get_flash_type()
3722 nand_decode_id(mtd, chip, type, id_data, &busw); in nand_get_flash_type()
3725 chip->options |= type->options; in nand_get_flash_type()
3732 chip->options &= ~NAND_SAMSUNG_LP_OPTIONS; in nand_get_flash_type()
3741 if (chip->options & NAND_BUSWIDTH_AUTO) { in nand_get_flash_type()
3742 WARN_ON(chip->options & NAND_BUSWIDTH_16); in nand_get_flash_type()
3743 chip->options |= busw; in nand_get_flash_type()
3744 nand_set_defaults(chip, busw); in nand_get_flash_type()
3745 } else if (busw != (chip->options & NAND_BUSWIDTH_16)) { in nand_get_flash_type()
3754 (chip->options & NAND_BUSWIDTH_16) ? 16 : 8, in nand_get_flash_type()
3759 nand_decode_bbm_options(mtd, chip, id_data); in nand_get_flash_type()
3762 chip->page_shift = ffs(mtd->writesize) - 1; in nand_get_flash_type()
3764 chip->pagemask = (chip->chipsize >> chip->page_shift) - 1; in nand_get_flash_type()
3766 chip->bbt_erase_shift = chip->phys_erase_shift = in nand_get_flash_type()
3768 if (chip->chipsize & 0xffffffff) in nand_get_flash_type()
3769 chip->chip_shift = ffs((unsigned)chip->chipsize) - 1; in nand_get_flash_type()
3771 chip->chip_shift = ffs((unsigned)(chip->chipsize >> 32)); in nand_get_flash_type()
3772 chip->chip_shift += 32 - 1; in nand_get_flash_type()
3775 chip->badblockbits = 8; in nand_get_flash_type()
3776 chip->erase = single_erase; in nand_get_flash_type()
3779 if (mtd->writesize > 512 && chip->cmdfunc == nand_command) in nand_get_flash_type()
3780 chip->cmdfunc = nand_command_lp; in nand_get_flash_type()
3785 if (chip->onfi_version) in nand_get_flash_type()
3787 chip->onfi_params.model); in nand_get_flash_type()
3788 else if (chip->jedec_version) in nand_get_flash_type()
3790 chip->jedec_params.model); in nand_get_flash_type()
3796 (int)(chip->chipsize >> 20), nand_is_slc(chip) ? "SLC" : "MLC", in nand_get_flash_type()
3816 struct nand_chip *chip = mtd->priv; in nand_scan_ident() local
3820 nand_set_defaults(chip, chip->options & NAND_BUSWIDTH_16); in nand_scan_ident()
3823 type = nand_get_flash_type(mtd, chip, &nand_maf_id, in nand_scan_ident()
3827 if (!(chip->options & NAND_SCAN_SILENT_NODEV)) in nand_scan_ident()
3829 chip->select_chip(mtd, -1); in nand_scan_ident()
3833 chip->select_chip(mtd, -1); in nand_scan_ident()
3837 chip->select_chip(mtd, i); in nand_scan_ident()
3839 chip->cmdfunc(mtd, NAND_CMD_RESET, -1, -1); in nand_scan_ident()
3841 chip->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1); in nand_scan_ident()
3843 if (nand_maf_id != chip->read_byte(mtd) || in nand_scan_ident()
3844 nand_dev_id != chip->read_byte(mtd)) { in nand_scan_ident()
3845 chip->select_chip(mtd, -1); in nand_scan_ident()
3848 chip->select_chip(mtd, -1); in nand_scan_ident()
3854 chip->numchips = i; in nand_scan_ident()
3855 mtd->size = i * chip->chipsize; in nand_scan_ident()
3877 struct nand_chip *chip = mtd->priv; in nand_ecc_strength_good() local
3878 struct nand_ecc_ctrl *ecc = &chip->ecc; in nand_ecc_strength_good()
3881 if (ecc->size == 0 || chip->ecc_step_ds == 0) in nand_ecc_strength_good()
3890 ds_corr = (mtd->writesize * chip->ecc_strength_ds) / chip->ecc_step_ds; in nand_ecc_strength_good()
3892 return corr >= ds_corr && ecc->strength >= chip->ecc_strength_ds; in nand_ecc_strength_good()
3906 struct nand_chip *chip = mtd->priv; in nand_scan_tail() local
3907 struct nand_ecc_ctrl *ecc = &chip->ecc; in nand_scan_tail()
3911 BUG_ON((chip->bbt_options & NAND_BBT_NO_OOB_BBM) && in nand_scan_tail()
3912 !(chip->bbt_options & NAND_BBT_USE_FLASH)); in nand_scan_tail()
3914 if (!(chip->options & NAND_OWN_BUFFERS)) { in nand_scan_tail()
3923 chip->buffers = nbuf; in nand_scan_tail()
3925 if (!chip->buffers) in nand_scan_tail()
3930 chip->oob_poi = chip->buffers->databuf + mtd->writesize; in nand_scan_tail()
3956 if (!chip->write_page) in nand_scan_tail()
3957 chip->write_page = nand_write_page; in nand_scan_tail()
4129 if (!(chip->options & NAND_NO_SUBPAGE_WRITE) && nand_is_slc(chip)) { in nand_scan_tail()
4141 chip->subpagesize = mtd->writesize >> mtd->subpage_sft; in nand_scan_tail()
4144 chip->state = FL_READY; in nand_scan_tail()
4147 chip->pagebuf = -1; in nand_scan_tail()
4153 if (chip->page_shift > 9) in nand_scan_tail()
4154 chip->options |= NAND_SUBPAGE_READ; in nand_scan_tail()
4162 mtd->type = nand_is_slc(chip) ? MTD_NANDFLASH : MTD_MLCNANDFLASH; in nand_scan_tail()
4163 mtd->flags = (chip->options & NAND_ROM) ? MTD_CAP_ROM : in nand_scan_tail()
4197 if (chip->options & NAND_SKIP_BBTSCAN) in nand_scan_tail()
4201 return chip->scan_bbt(mtd); in nand_scan_tail()
4250 struct nand_chip *chip = mtd->priv; in nand_release() local
4252 if (chip->ecc.mode == NAND_ECC_SOFT_BCH) in nand_release()
4253 nand_bch_free((struct nand_bch_control *)chip->ecc.priv); in nand_release()
4258 kfree(chip->bbt); in nand_release()
4259 if (!(chip->options & NAND_OWN_BUFFERS)) in nand_release()
4260 kfree(chip->buffers); in nand_release()
4263 if (chip->badblock_pattern && chip->badblock_pattern->options in nand_release()
4265 kfree(chip->badblock_pattern); in nand_release()