Lines Matching refs:ns
190 #define NS_IS_INITIALIZED(ns) ((ns)->geom.totsz != 0)
193 #define NS_STATUS_OK(ns) (NAND_STATUS_READY | (NAND_STATUS_WP * ((ns)->lines.wp == 0)))
196 #define NS_STATUS_FAILED(ns) (NAND_STATUS_FAIL | NS_STATUS_OK(ns))
199 #define NS_RAW_OFFSET(ns) \
200 (((ns)->regs.row * (ns)->geom.pgszoob) + (ns)->regs.column)
203 #define NS_RAW_OFFSET_OOB(ns) (NS_RAW_OFFSET(ns) + ns->geom.pgsz)
489 DEFINE_SHOW_ATTRIBUTE(ns);
493 * @ns: nandsim device description object
498 static int ns_debugfs_create(struct nandsim *ns)
513 ns->dent = debugfs_create_file("nandsim_wear_report", 0400, root, ns,
515 if (IS_ERR_OR_NULL(ns->dent)) {
523 static void ns_debugfs_remove(struct nandsim *ns)
525 debugfs_remove_recursive(ns->dent);
534 static int __init ns_alloc_device(struct nandsim *ns)
553 ns->pages_written =
555 BITS_TO_LONGS(ns->geom.pgnum)));
556 if (!ns->pages_written) {
561 ns->file_buf = kmalloc(ns->geom.pgszoob, GFP_KERNEL);
562 if (!ns->file_buf) {
567 ns->cfile = cfile;
572 vfree(ns->pages_written);
579 ns->pages = vmalloc(array_size(sizeof(union ns_mem), ns->geom.pgnum));
580 if (!ns->pages) {
584 for (i = 0; i < ns->geom.pgnum; i++) {
585 ns->pages[i].byte = NULL;
587 ns->nand_pages_slab = kmem_cache_create("nandsim",
588 ns->geom.pgszoob, 0, 0, NULL);
589 if (!ns->nand_pages_slab) {
598 vfree(ns->pages);
606 static void ns_free_device(struct nandsim *ns)
610 if (ns->cfile) {
611 kfree(ns->file_buf);
612 vfree(ns->pages_written);
613 filp_close(ns->cfile, NULL);
617 if (ns->pages) {
618 for (i = 0; i < ns->geom.pgnum; i++) {
619 if (ns->pages[i].byte)
620 kmem_cache_free(ns->nand_pages_slab,
621 ns->pages[i].byte);
623 kmem_cache_destroy(ns->nand_pages_slab);
624 vfree(ns->pages);
641 struct nandsim *ns = nand_get_controller_data(chip);
646 if (NS_IS_INITIALIZED(ns)) {
652 ns->busw = chip->options & NAND_BUSWIDTH_16 ? 16 : 8;
653 ns->geom.totsz = mtd->size;
654 ns->geom.pgsz = mtd->writesize;
655 ns->geom.oobsz = mtd->oobsize;
656 ns->geom.secsz = mtd->erasesize;
657 ns->geom.pgszoob = ns->geom.pgsz + ns->geom.oobsz;
658 ns->geom.pgnum = div_u64(ns->geom.totsz, ns->geom.pgsz);
659 ns->geom.totszoob = ns->geom.totsz + (uint64_t)ns->geom.pgnum * ns->geom.oobsz;
660 ns->geom.secshift = ffs(ns->geom.secsz) - 1;
661 ns->geom.pgshift = chip->page_shift;
662 ns->geom.pgsec = ns->geom.secsz / ns->geom.pgsz;
663 ns->geom.secszoob = ns->geom.secsz + ns->geom.oobsz * ns->geom.pgsec;
664 ns->options = 0;
666 if (ns->geom.pgsz == 512) {
667 ns->options |= OPT_PAGE512;
668 if (ns->busw == 8)
669 ns->options |= OPT_PAGE512_8BIT;
670 } else if (ns->geom.pgsz == 2048) {
671 ns->options |= OPT_PAGE2048;
672 } else if (ns->geom.pgsz == 4096) {
673 ns->options |= OPT_PAGE4096;
675 NS_ERR("init_nandsim: unknown page size %u\n", ns->geom.pgsz);
679 if (ns->options & OPT_SMALLPAGE) {
680 if (ns->geom.totsz <= (32 << 20)) {
681 ns->geom.pgaddrbytes = 3;
682 ns->geom.secaddrbytes = 2;
684 ns->geom.pgaddrbytes = 4;
685 ns->geom.secaddrbytes = 3;
688 if (ns->geom.totsz <= (128 << 20)) {
689 ns->geom.pgaddrbytes = 4;
690 ns->geom.secaddrbytes = 2;
692 ns->geom.pgaddrbytes = 5;
693 ns->geom.secaddrbytes = 3;
698 if (parts_num > ARRAY_SIZE(ns->partitions)) {
702 remains = ns->geom.totsz;
705 uint64_t part_sz = (uint64_t)parts[i] * ns->geom.secsz;
711 ns->partitions[i].name = ns_get_partition_name(i);
712 if (!ns->partitions[i].name) {
716 ns->partitions[i].offset = next_offset;
717 ns->partitions[i].size = part_sz;
718 next_offset += ns->partitions[i].size;
719 remains -= ns->partitions[i].size;
721 ns->nbparts = parts_num;
723 if (parts_num + 1 > ARRAY_SIZE(ns->partitions)) {
728 ns->partitions[i].name = ns_get_partition_name(i);
729 if (!ns->partitions[i].name) {
734 ns->partitions[i].offset = next_offset;
735 ns->partitions[i].size = remains;
736 ns->nbparts += 1;
739 if (ns->busw == 16)
743 (unsigned long long)ns->geom.totsz >> 20);
744 printk("page size: %u bytes\n", ns->geom.pgsz);
745 printk("OOB area size: %u bytes\n", ns->geom.oobsz);
746 printk("sector size: %u KiB\n", ns->geom.secsz >> 10);
747 printk("pages number: %u\n", ns->geom.pgnum);
748 printk("pages per sector: %u\n", ns->geom.pgsec);
749 printk("bus width: %u\n", ns->busw);
750 printk("bits in sector size: %u\n", ns->geom.secshift);
751 printk("bits in page size: %u\n", ns->geom.pgshift);
752 printk("bits in OOB size: %u\n", ffs(ns->geom.oobsz) - 1);
754 (unsigned long long)ns->geom.totszoob >> 10);
755 printk("page address bytes: %u\n", ns->geom.pgaddrbytes);
756 printk("sector address bytes: %u\n", ns->geom.secaddrbytes);
757 printk("options: %#x\n", ns->options);
759 ret = ns_alloc_device(ns);
764 ns->buf.byte = kmalloc(ns->geom.pgszoob, GFP_KERNEL);
765 if (!ns->buf.byte) {
767 ns->geom.pgszoob);
771 memset(ns->buf.byte, 0xFF, ns->geom.pgszoob);
776 ns_free_device(ns);
778 for (i = 0; i < ARRAY_SIZE(ns->partitions); ++i)
779 kfree(ns->partitions[i].name);
787 static void ns_free(struct nandsim *ns)
791 for (i = 0; i < ARRAY_SIZE(ns->partitions); ++i)
792 kfree(ns->partitions[i].name);
794 kfree(ns->buf.byte);
795 ns_free_device(ns);
800 static int ns_parse_badblocks(struct nandsim *ns, struct mtd_info *mtd)
817 offset = (loff_t)erase_block_no * ns->geom.secsz;
1143 static inline void ns_accept_addr_byte(struct nandsim *ns, u_char bt)
1147 if (ns->regs.count < (ns->geom.pgaddrbytes - ns->geom.secaddrbytes))
1148 ns->regs.column |= (byte << 8 * ns->regs.count);
1150 ns->regs.row |= (byte << 8 * (ns->regs.count -
1151 ns->geom.pgaddrbytes +
1152 ns->geom.secaddrbytes));
1161 static inline void ns_switch_to_ready_state(struct nandsim *ns, u_char status)
1166 ns->state = STATE_READY;
1167 ns->nxstate = STATE_UNKNOWN;
1168 ns->op = NULL;
1169 ns->npstates = 0;
1170 ns->stateidx = 0;
1171 ns->regs.num = 0;
1172 ns->regs.count = 0;
1173 ns->regs.off = 0;
1174 ns->regs.row = 0;
1175 ns->regs.column = 0;
1176 ns->regs.status = status;
1185 * correspondent states chain. In this case ns->npstates = 0;
1189 * case the ns->pstates[] array contains previous states.
1193 * ns->pstates[0], ... ns->pstates[ns->npstates], ns->state
1196 * ns->ops, ns->state, ns->nxstate are initialized, ns->npstate is
1200 * ns->pstates.
1206 * ns->pstates[0], ... ns->pstates[ns->npstates], <address input>
1221 static int ns_find_operation(struct nandsim *ns, uint32_t flag)
1230 if (!(ns->options & ops[i].reqopts))
1235 if (!(ops[i].states[ns->npstates] & STATE_ADDR_MASK))
1238 if (NS_STATE(ns->state) != NS_STATE(ops[i].states[ns->npstates]))
1242 for (j = 0; j < ns->npstates; j++)
1243 if (NS_STATE(ops[i].states[j]) != NS_STATE(ns->pstates[j])
1244 && (ns->options & ops[idx].reqopts)) {
1257 ns->op = &ops[idx].states[0];
1264 * state must be the next state (ns->nxstate).
1266 ns->stateidx = ns->npstates - 1;
1268 ns->stateidx = ns->npstates;
1270 ns->npstates = 0;
1271 ns->state = ns->op[ns->stateidx];
1272 ns->nxstate = ns->op[ns->stateidx + 1];
1274 idx, ns_get_state_name(ns->state),
1275 ns_get_state_name(ns->nxstate));
1281 if (ns->npstates != 0) {
1283 ns_get_state_name(ns->state));
1284 ns->npstates = 0;
1285 return ns_find_operation(ns, 0);
1289 ns_switch_to_ready_state(ns, NS_STATUS_FAILED(ns));
1301 ns->pstates[ns->npstates++] = ns->state;
1306 static void ns_put_pages(struct nandsim *ns)
1310 for (i = 0; i < ns->held_cnt; i++)
1311 put_page(ns->held_pages[i]);
1315 static int ns_get_pages(struct nandsim *ns, struct file *file, size_t count,
1326 ns->held_cnt = 0;
1336 ns_put_pages(ns);
1341 ns->held_pages[ns->held_cnt++] = page;
1346 static ssize_t ns_read_file(struct nandsim *ns, struct file *file, void *buf,
1353 err = ns_get_pages(ns, file, count, pos);
1359 ns_put_pages(ns);
1363 static ssize_t ns_write_file(struct nandsim *ns, struct file *file, void *buf,
1370 err = ns_get_pages(ns, file, count, pos);
1376 ns_put_pages(ns);
1383 static inline union ns_mem *NS_GET_PAGE(struct nandsim *ns)
1385 return &(ns->pages[ns->regs.row]);
1391 static inline u_char *NS_PAGE_BYTE_OFF(struct nandsim *ns)
1393 return NS_GET_PAGE(ns)->byte + ns->regs.column + ns->regs.off;
1396 static int ns_do_read_error(struct nandsim *ns, int num)
1398 unsigned int page_no = ns->regs.row;
1401 prandom_bytes(ns->buf.byte, num);
1408 static void ns_do_bit_flips(struct nandsim *ns, int num)
1416 ns->buf.byte[pos / 8] ^= (1 << (pos % 8));
1419 pos, ns->regs.row, ns->regs.column + ns->regs.off,
1428 static void ns_read_page(struct nandsim *ns, int num)
1432 if (ns->cfile) {
1433 if (!test_bit(ns->regs.row, ns->pages_written)) {
1434 NS_DBG("read_page: page %d not written\n", ns->regs.row);
1435 memset(ns->buf.byte, 0xFF, num);
1441 ns->regs.row, ns->regs.column + ns->regs.off);
1442 if (ns_do_read_error(ns, num))
1444 pos = (loff_t)NS_RAW_OFFSET(ns) + ns->regs.off;
1445 tx = ns_read_file(ns, ns->cfile, ns->buf.byte, num,
1448 NS_ERR("read_page: read error for page %d ret %ld\n", ns->regs.row, (long)tx);
1451 ns_do_bit_flips(ns, num);
1456 mypage = NS_GET_PAGE(ns);
1458 NS_DBG("read_page: page %d not allocated\n", ns->regs.row);
1459 memset(ns->buf.byte, 0xFF, num);
1462 ns->regs.row, ns->regs.column + ns->regs.off);
1463 if (ns_do_read_error(ns, num))
1465 memcpy(ns->buf.byte, NS_PAGE_BYTE_OFF(ns), num);
1466 ns_do_bit_flips(ns, num);
1473 static void ns_erase_sector(struct nandsim *ns)
1478 if (ns->cfile) {
1479 for (i = 0; i < ns->geom.pgsec; i++)
1480 if (__test_and_clear_bit(ns->regs.row + i,
1481 ns->pages_written)) {
1482 NS_DBG("erase_sector: freeing page %d\n", ns->regs.row + i);
1487 mypage = NS_GET_PAGE(ns);
1488 for (i = 0; i < ns->geom.pgsec; i++) {
1490 NS_DBG("erase_sector: freeing page %d\n", ns->regs.row+i);
1491 kmem_cache_free(ns->nand_pages_slab, mypage->byte);
1501 static int ns_prog_page(struct nandsim *ns, int num)
1507 if (ns->cfile) {
1512 NS_DBG("prog_page: writing page %d\n", ns->regs.row);
1513 pg_off = ns->file_buf + ns->regs.column + ns->regs.off;
1514 off = (loff_t)NS_RAW_OFFSET(ns) + ns->regs.off;
1515 if (!test_bit(ns->regs.row, ns->pages_written)) {
1517 memset(ns->file_buf, 0xff, ns->geom.pgszoob);
1520 tx = ns_read_file(ns, ns->cfile, pg_off, num, off);
1522 NS_ERR("prog_page: read error for page %d ret %ld\n", ns->regs.row, (long)tx);
1527 pg_off[i] &= ns->buf.byte[i];
1529 loff_t pos = (loff_t)ns->regs.row * ns->geom.pgszoob;
1530 tx = ns_write_file(ns, ns->cfile, ns->file_buf,
1531 ns->geom.pgszoob, pos);
1532 if (tx != ns->geom.pgszoob) {
1533 NS_ERR("prog_page: write error for page %d ret %ld\n", ns->regs.row, (long)tx);
1536 __set_bit(ns->regs.row, ns->pages_written);
1538 tx = ns_write_file(ns, ns->cfile, pg_off, num, off);
1540 NS_ERR("prog_page: write error for page %d ret %ld\n", ns->regs.row, (long)tx);
1547 mypage = NS_GET_PAGE(ns);
1549 NS_DBG("prog_page: allocating page %d\n", ns->regs.row);
1556 mypage->byte = kmem_cache_alloc(ns->nand_pages_slab, GFP_NOFS);
1558 NS_ERR("prog_page: error allocating memory for page %d\n", ns->regs.row);
1561 memset(mypage->byte, 0xFF, ns->geom.pgszoob);
1564 pg_off = NS_PAGE_BYTE_OFF(ns);
1566 pg_off[i] &= ns->buf.byte[i];
1576 static int ns_do_state_action(struct nandsim *ns, uint32_t action)
1579 int busdiv = ns->busw == 8 ? 1 : 2;
1585 if (action != ACTION_SECERASE && ns->regs.row >= ns->geom.pgnum) {
1586 NS_WARN("do_state_action: wrong page number (%#x)\n", ns->regs.row);
1598 if (ns->regs.column >= (ns->geom.pgszoob - ns->regs.off)) {
1602 num = ns->geom.pgszoob - ns->regs.off - ns->regs.column;
1603 ns_read_page(ns, num);
1606 num, NS_RAW_OFFSET(ns) + ns->regs.off);
1608 if (ns->regs.off == 0)
1609 NS_LOG("read page %d\n", ns->regs.row);
1610 else if (ns->regs.off < ns->geom.pgsz)
1611 NS_LOG("read page %d (second half)\n", ns->regs.row);
1613 NS_LOG("read OOB of page %d\n", ns->regs.row);
1616 NS_UDELAY(input_cycle * ns->geom.pgsz / 1000 / busdiv);
1625 if (ns->lines.wp) {
1630 if (ns->regs.row >= ns->geom.pgnum - ns->geom.pgsec
1631 || (ns->regs.row & ~(ns->geom.secsz - 1))) {
1632 NS_ERR("do_state_action: wrong sector address (%#x)\n", ns->regs.row);
1636 ns->regs.row = (ns->regs.row <<
1637 8 * (ns->geom.pgaddrbytes - ns->geom.secaddrbytes)) | ns->regs.column;
1638 ns->regs.column = 0;
1640 erase_block_no = ns->regs.row >> (ns->geom.secshift - ns->geom.pgshift);
1643 ns->regs.row, NS_RAW_OFFSET(ns));
1646 ns_erase_sector(ns);
1665 if (ns->lines.wp) {
1670 num = ns->geom.pgszoob - ns->regs.off - ns->regs.column;
1671 if (num != ns->regs.count) {
1673 ns->regs.count, num);
1677 if (ns_prog_page(ns, num) == -1)
1680 page_no = ns->regs.row;
1683 num, ns->regs.row, ns->regs.column, NS_RAW_OFFSET(ns) + ns->regs.off);
1684 NS_LOG("programm page %d\n", ns->regs.row);
1687 NS_UDELAY(output_cycle * ns->geom.pgsz / 1000 / busdiv);
1698 ns->regs.off = 0;
1702 if (!(ns->options & OPT_PAGE512_8BIT)) {
1707 NS_DBG("do_state_action: set internal offset to %d\n", ns->geom.pgsz/2);
1708 ns->regs.off = ns->geom.pgsz/2;
1712 NS_DBG("do_state_action: set internal offset to %d\n", ns->geom.pgsz);
1713 ns->regs.off = ns->geom.pgsz;
1726 static void ns_switch_state(struct nandsim *ns)
1728 if (ns->op) {
1734 ns->stateidx += 1;
1735 ns->state = ns->nxstate;
1736 ns->nxstate = ns->op[ns->stateidx + 1];
1740 ns_get_state_name(ns->state),
1741 ns_get_state_name(ns->nxstate));
1744 if ((ns->state & ACTION_MASK) &&
1745 ns_do_state_action(ns, ns->state) < 0) {
1746 ns_switch_to_ready_state(ns, NS_STATUS_FAILED(ns));
1760 ns->state = ns_get_state_by_command(ns->regs.command);
1764 if (ns_find_operation(ns, 0))
1767 if ((ns->state & ACTION_MASK) &&
1768 ns_do_state_action(ns, ns->state) < 0) {
1769 ns_switch_to_ready_state(ns, NS_STATUS_FAILED(ns));
1775 if ((ns->nxstate & STATE_ADDR_MASK) && ns->busw == 16) {
1777 ns->regs.column <<= 1;
1780 if (NS_STATE(ns->nxstate) == STATE_READY) {
1785 u_char status = NS_STATUS_OK(ns);
1788 if ((ns->state & (STATE_DATAIN_MASK | STATE_DATAOUT_MASK))
1789 && ns->regs.count != ns->regs.num) {
1791 ns->regs.num - ns->regs.count);
1792 status = NS_STATUS_FAILED(ns);
1797 ns_switch_to_ready_state(ns, status);
1800 } else if (ns->nxstate & (STATE_DATAIN_MASK | STATE_DATAOUT_MASK)) {
1805 ns->state = ns->nxstate;
1806 ns->nxstate = ns->op[++ns->stateidx + 1];
1807 ns->regs.num = ns->regs.count = 0;
1811 ns_get_state_name(ns->state),
1812 ns_get_state_name(ns->nxstate));
1818 switch (NS_STATE(ns->state)) {
1821 ns->regs.num = ns->geom.pgszoob - ns->regs.off - ns->regs.column;
1825 ns->regs.num = ns->geom.idbytes;
1829 ns->regs.count = ns->regs.num = 0;
1836 } else if (ns->nxstate & STATE_ADDR_MASK) {
1842 ns->regs.count = 0;
1844 switch (NS_STATE(ns->nxstate)) {
1846 ns->regs.num = ns->geom.pgaddrbytes;
1850 ns->regs.num = ns->geom.secaddrbytes;
1854 ns->regs.num = 1;
1859 ns->regs.num = ns->geom.pgaddrbytes - ns->geom.secaddrbytes;
1870 ns->regs.num = 0;
1871 ns->regs.count = 0;
1877 struct nandsim *ns = nand_get_controller_data(chip);
1881 if (!ns->lines.ce) {
1885 if (ns->lines.ale || ns->lines.cle) {
1889 if (!(ns->state & STATE_DATAOUT_MASK)) {
1891 ns_get_state_name(ns->state), (uint)outb);
1896 if (NS_STATE(ns->state) == STATE_DATAOUT_STATUS) {
1897 NS_DBG("read_byte: return %#x status\n", ns->regs.status);
1898 return ns->regs.status;
1902 if (ns->regs.count == ns->regs.num) {
1907 switch (NS_STATE(ns->state)) {
1909 if (ns->busw == 8) {
1910 outb = ns->buf.byte[ns->regs.count];
1911 ns->regs.count += 1;
1913 outb = (u_char)cpu_to_le16(ns->buf.word[ns->regs.count >> 1]);
1914 ns->regs.count += 2;
1918 NS_DBG("read_byte: read ID byte %d, total = %d\n", ns->regs.count, ns->regs.num);
1919 outb = ns->ids[ns->regs.count];
1920 ns->regs.count += 1;
1926 if (ns->regs.count == ns->regs.num) {
1929 if (NS_STATE(ns->nxstate) == STATE_READY)
1930 ns_switch_state(ns);
1938 struct nandsim *ns = nand_get_controller_data(chip);
1941 if (!ns->lines.ce) {
1945 if (ns->lines.ale && ns->lines.cle) {
1950 if (ns->lines.cle == 1) {
1957 ns_switch_to_ready_state(ns, NS_STATUS_OK(ns));
1967 if (NS_STATE(ns->state) == STATE_DATAOUT_STATUS
1968 || NS_STATE(ns->state) == STATE_DATAOUT) {
1969 int row = ns->regs.row;
1971 ns_switch_state(ns);
1973 ns->regs.row = row;
1977 if (NS_STATE(ns->nxstate) != STATE_UNKNOWN && !(ns->nxstate & STATE_CMD_MASK)) {
1979 if (!(ns->regs.command == NAND_CMD_READID &&
1980 NS_STATE(ns->state) == STATE_DATAOUT_ID && ns->regs.count == 2)) {
1988 ns_get_state_name(ns->nxstate));
1990 ns_switch_to_ready_state(ns, NS_STATUS_FAILED(ns));
1995 ns->regs.command = byte;
1996 ns_switch_state(ns);
1998 } else if (ns->lines.ale == 1) {
2003 if (NS_STATE(ns->nxstate) == STATE_UNKNOWN) {
2007 if (ns_find_operation(ns, 1) < 0)
2010 if ((ns->state & ACTION_MASK) &&
2011 ns_do_state_action(ns, ns->state) < 0) {
2012 ns_switch_to_ready_state(ns,
2013 NS_STATUS_FAILED(ns));
2017 ns->regs.count = 0;
2018 switch (NS_STATE(ns->nxstate)) {
2020 ns->regs.num = ns->geom.pgaddrbytes;
2023 ns->regs.num = ns->geom.secaddrbytes;
2026 ns->regs.num = 1;
2034 if (!(ns->nxstate & STATE_ADDR_MASK)) {
2036 (uint)byte, ns_get_state_name(ns->nxstate));
2037 ns_switch_to_ready_state(ns, NS_STATUS_FAILED(ns));
2042 if (ns->regs.count == ns->regs.num) {
2044 ns_switch_to_ready_state(ns, NS_STATUS_FAILED(ns));
2048 ns_accept_addr_byte(ns, byte);
2050 ns->regs.count += 1;
2053 (uint)byte, ns->regs.count, ns->regs.num);
2055 if (ns->regs.count == ns->regs.num) {
2056 NS_DBG("address (%#x, %#x) is accepted\n", ns->regs.row, ns->regs.column);
2057 ns_switch_state(ns);
2066 if (!(ns->state & STATE_DATAIN_MASK)) {
2068 (uint)byte, ns_get_state_name(ns->state),
2070 ns_switch_to_ready_state(ns, NS_STATUS_FAILED(ns));
2075 if (ns->regs.count == ns->regs.num) {
2077 ns->regs.num);
2081 if (ns->busw == 8) {
2082 ns->buf.byte[ns->regs.count] = byte;
2083 ns->regs.count += 1;
2085 ns->buf.word[ns->regs.count >> 1] = cpu_to_le16((uint16_t)byte);
2086 ns->regs.count += 2;
2096 struct nandsim *ns = nand_get_controller_data(chip);
2099 if (!(ns->state & STATE_DATAIN_MASK)) {
2101 ns_get_state_name(ns->state));
2102 ns_switch_to_ready_state(ns, NS_STATUS_FAILED(ns));
2107 if (ns->regs.count + len > ns->regs.num) {
2109 ns_switch_to_ready_state(ns, NS_STATUS_FAILED(ns));
2113 memcpy(ns->buf.byte + ns->regs.count, buf, len);
2114 ns->regs.count += len;
2116 if (ns->regs.count == ns->regs.num) {
2117 NS_DBG("write_buf: %d bytes were written\n", ns->regs.count);
2123 struct nandsim *ns = nand_get_controller_data(chip);
2126 if (!ns->lines.ce) {
2130 if (ns->lines.ale || ns->lines.cle) {
2134 if (!(ns->state & STATE_DATAOUT_MASK)) {
2136 ns_get_state_name(ns->state));
2140 if (NS_STATE(ns->state) != STATE_DATAOUT) {
2150 if (ns->regs.count + len > ns->regs.num) {
2152 ns_switch_to_ready_state(ns, NS_STATUS_FAILED(ns));
2156 memcpy(buf, ns->buf.byte + ns->regs.count, len);
2157 ns->regs.count += len;
2159 if (ns->regs.count == ns->regs.num) {
2160 if (NS_STATE(ns->nxstate) == STATE_READY)
2161 ns_switch_state(ns);
2173 struct nandsim *ns = nand_get_controller_data(chip);
2178 ns->lines.ce = 1;
2182 ns->lines.cle = 0;
2183 ns->lines.ale = 0;
2187 ns->lines.cle = 1;
2191 ns->lines.ale = 1;
2261 struct nandsim *ns;
2269 ns = kzalloc(sizeof(struct nandsim), GFP_KERNEL);
2270 if (!ns) {
2274 chip = &ns->chip;
2276 nand_set_controller_data(chip, (void *)ns);
2301 ns->geom.idbytes = 8;
2303 ns->geom.idbytes = 6;
2305 ns->geom.idbytes = 4;
2307 ns->geom.idbytes = 2;
2308 ns->regs.status = NS_STATUS_OK(ns);
2309 ns->nxstate = STATE_UNKNOWN;
2310 ns->options |= OPT_PAGE512; /* temporary value */
2311 memcpy(ns->ids, id_bytes, sizeof(ns->ids));
2313 ns->busw = 16;
2331 nand_controller_init(&ns->base);
2332 ns->base.ops = &ns_controller_ops;
2333 chip->controller = &ns->base;
2374 ret = ns_parse_badblocks(ns, nsmtd);
2379 ret = mtd_device_register(nsmtd, &ns->partitions[0], ns->nbparts);
2383 ret = ns_debugfs_create(ns);
2392 ns_free(ns);
2413 kfree(ns);
2426 struct nandsim *ns = nand_get_controller_data(chip);
2429 ns_debugfs_remove(ns);
2431 ns_free(ns);
2450 kfree(ns);