Lines Matching refs:ns
189 #define NS_IS_INITIALIZED(ns) ((ns)->geom.totsz != 0)
192 #define NS_STATUS_OK(ns) (NAND_STATUS_READY | (NAND_STATUS_WP * ((ns)->lines.wp == 0)))
195 #define NS_STATUS_FAILED(ns) (NAND_STATUS_FAIL | NS_STATUS_OK(ns))
198 #define NS_RAW_OFFSET(ns) \
199 (((ns)->regs.row * (ns)->geom.pgszoob) + (ns)->regs.column)
202 #define NS_RAW_OFFSET_OOB(ns) (NS_RAW_OFFSET(ns) + ns->geom.pgsz)
205 #define NS_PAGE_BYTE_SHIFT(ns) ((ns)->regs.column + (ns)->regs.off)
491 DEFINE_SHOW_ATTRIBUTE(ns);
495 * @ns: nandsim device description object
500 static int ns_debugfs_create(struct nandsim *ns)
515 ns->dent = debugfs_create_file("nandsim_wear_report", 0400, root, ns,
517 if (IS_ERR_OR_NULL(ns->dent)) {
525 static void ns_debugfs_remove(struct nandsim *ns)
527 debugfs_remove_recursive(ns->dent);
536 static int __init ns_alloc_device(struct nandsim *ns)
555 ns->pages_written =
557 BITS_TO_LONGS(ns->geom.pgnum)));
558 if (!ns->pages_written) {
563 ns->file_buf = kmalloc(ns->geom.pgszoob, GFP_KERNEL);
564 if (!ns->file_buf) {
569 ns->cfile = cfile;
574 vfree(ns->pages_written);
581 ns->pages = vmalloc(array_size(sizeof(union ns_mem), ns->geom.pgnum));
582 if (!ns->pages) {
586 for (i = 0; i < ns->geom.pgnum; i++) {
587 ns->pages[i].byte = NULL;
589 ns->nand_pages_slab = kmem_cache_create("nandsim",
590 ns->geom.pgszoob, 0, 0, NULL);
591 if (!ns->nand_pages_slab) {
600 vfree(ns->pages);
608 static void ns_free_device(struct nandsim *ns)
612 if (ns->cfile) {
613 kfree(ns->file_buf);
614 vfree(ns->pages_written);
615 filp_close(ns->cfile, NULL);
619 if (ns->pages) {
620 for (i = 0; i < ns->geom.pgnum; i++) {
621 if (ns->pages[i].byte)
622 kmem_cache_free(ns->nand_pages_slab,
623 ns->pages[i].byte);
625 kmem_cache_destroy(ns->nand_pages_slab);
626 vfree(ns->pages);
643 struct nandsim *ns = nand_get_controller_data(chip);
648 if (NS_IS_INITIALIZED(ns)) {
654 ns->busw = chip->options & NAND_BUSWIDTH_16 ? 16 : 8;
655 ns->geom.totsz = mtd->size;
656 ns->geom.pgsz = mtd->writesize;
657 ns->geom.oobsz = mtd->oobsize;
658 ns->geom.secsz = mtd->erasesize;
659 ns->geom.pgszoob = ns->geom.pgsz + ns->geom.oobsz;
660 ns->geom.pgnum = div_u64(ns->geom.totsz, ns->geom.pgsz);
661 ns->geom.totszoob = ns->geom.totsz + (uint64_t)ns->geom.pgnum * ns->geom.oobsz;
662 ns->geom.secshift = ffs(ns->geom.secsz) - 1;
663 ns->geom.pgshift = chip->page_shift;
664 ns->geom.pgsec = ns->geom.secsz / ns->geom.pgsz;
665 ns->geom.secszoob = ns->geom.secsz + ns->geom.oobsz * ns->geom.pgsec;
666 ns->options = 0;
668 if (ns->geom.pgsz == 512) {
669 ns->options |= OPT_PAGE512;
670 if (ns->busw == 8)
671 ns->options |= OPT_PAGE512_8BIT;
672 } else if (ns->geom.pgsz == 2048) {
673 ns->options |= OPT_PAGE2048;
674 } else if (ns->geom.pgsz == 4096) {
675 ns->options |= OPT_PAGE4096;
677 NS_ERR("init_nandsim: unknown page size %u\n", ns->geom.pgsz);
681 if (ns->options & OPT_SMALLPAGE) {
682 if (ns->geom.totsz <= (32 << 20)) {
683 ns->geom.pgaddrbytes = 3;
684 ns->geom.secaddrbytes = 2;
686 ns->geom.pgaddrbytes = 4;
687 ns->geom.secaddrbytes = 3;
690 if (ns->geom.totsz <= (128 << 20)) {
691 ns->geom.pgaddrbytes = 4;
692 ns->geom.secaddrbytes = 2;
694 ns->geom.pgaddrbytes = 5;
695 ns->geom.secaddrbytes = 3;
700 if (parts_num > ARRAY_SIZE(ns->partitions)) {
704 remains = ns->geom.totsz;
707 uint64_t part_sz = (uint64_t)parts[i] * ns->geom.secsz;
713 ns->partitions[i].name = ns_get_partition_name(i);
714 if (!ns->partitions[i].name) {
718 ns->partitions[i].offset = next_offset;
719 ns->partitions[i].size = part_sz;
720 next_offset += ns->partitions[i].size;
721 remains -= ns->partitions[i].size;
723 ns->nbparts = parts_num;
725 if (parts_num + 1 > ARRAY_SIZE(ns->partitions)) {
730 ns->partitions[i].name = ns_get_partition_name(i);
731 if (!ns->partitions[i].name) {
736 ns->partitions[i].offset = next_offset;
737 ns->partitions[i].size = remains;
738 ns->nbparts += 1;
741 if (ns->busw == 16)
745 (unsigned long long)ns->geom.totsz >> 20);
746 printk("page size: %u bytes\n", ns->geom.pgsz);
747 printk("OOB area size: %u bytes\n", ns->geom.oobsz);
748 printk("sector size: %u KiB\n", ns->geom.secsz >> 10);
749 printk("pages number: %u\n", ns->geom.pgnum);
750 printk("pages per sector: %u\n", ns->geom.pgsec);
751 printk("bus width: %u\n", ns->busw);
752 printk("bits in sector size: %u\n", ns->geom.secshift);
753 printk("bits in page size: %u\n", ns->geom.pgshift);
754 printk("bits in OOB size: %u\n", ffs(ns->geom.oobsz) - 1);
756 (unsigned long long)ns->geom.totszoob >> 10);
757 printk("page address bytes: %u\n", ns->geom.pgaddrbytes);
758 printk("sector address bytes: %u\n", ns->geom.secaddrbytes);
759 printk("options: %#x\n", ns->options);
761 ret = ns_alloc_device(ns);
766 ns->buf.byte = kmalloc(ns->geom.pgszoob, GFP_KERNEL);
767 if (!ns->buf.byte) {
769 ns->geom.pgszoob);
773 memset(ns->buf.byte, 0xFF, ns->geom.pgszoob);
778 ns_free_device(ns);
780 for (i = 0; i < ARRAY_SIZE(ns->partitions); ++i)
781 kfree(ns->partitions[i].name);
789 static void ns_free(struct nandsim *ns)
793 for (i = 0; i < ARRAY_SIZE(ns->partitions); ++i)
794 kfree(ns->partitions[i].name);
796 kfree(ns->buf.byte);
797 ns_free_device(ns);
802 static int ns_parse_badblocks(struct nandsim *ns, struct mtd_info *mtd)
819 offset = (loff_t)erase_block_no * ns->geom.secsz;
1138 static inline void ns_accept_addr_byte(struct nandsim *ns, u_char bt)
1142 if (ns->regs.count < (ns->geom.pgaddrbytes - ns->geom.secaddrbytes))
1143 ns->regs.column |= (byte << 8 * ns->regs.count);
1145 ns->regs.row |= (byte << 8 * (ns->regs.count -
1146 ns->geom.pgaddrbytes +
1147 ns->geom.secaddrbytes));
1156 static inline void ns_switch_to_ready_state(struct nandsim *ns, u_char status)
1161 ns->state = STATE_READY;
1162 ns->nxstate = STATE_UNKNOWN;
1163 ns->op = NULL;
1164 ns->npstates = 0;
1165 ns->stateidx = 0;
1166 ns->regs.num = 0;
1167 ns->regs.count = 0;
1168 ns->regs.off = 0;
1169 ns->regs.row = 0;
1170 ns->regs.column = 0;
1171 ns->regs.status = status;
1180 * correspondent states chain. In this case ns->npstates = 0;
1184 * case the ns->pstates[] array contains previous states.
1188 * ns->pstates[0], ... ns->pstates[ns->npstates], ns->state
1191 * ns->ops, ns->state, ns->nxstate are initialized, ns->npstate is
1195 * ns->pstates.
1201 * ns->pstates[0], ... ns->pstates[ns->npstates], <address input>
1216 static int ns_find_operation(struct nandsim *ns, uint32_t flag)
1225 if (!(ns->options & ops[i].reqopts))
1230 if (!(ops[i].states[ns->npstates] & STATE_ADDR_MASK))
1233 if (NS_STATE(ns->state) != NS_STATE(ops[i].states[ns->npstates]))
1237 for (j = 0; j < ns->npstates; j++)
1238 if (NS_STATE(ops[i].states[j]) != NS_STATE(ns->pstates[j])
1239 && (ns->options & ops[idx].reqopts)) {
1252 ns->op = &ops[idx].states[0];
1259 * state must be the next state (ns->nxstate).
1261 ns->stateidx = ns->npstates - 1;
1263 ns->stateidx = ns->npstates;
1265 ns->npstates = 0;
1266 ns->state = ns->op[ns->stateidx];
1267 ns->nxstate = ns->op[ns->stateidx + 1];
1269 idx, ns_get_state_name(ns->state),
1270 ns_get_state_name(ns->nxstate));
1276 if (ns->npstates != 0) {
1278 ns_get_state_name(ns->state));
1279 ns->npstates = 0;
1280 return ns_find_operation(ns, 0);
1284 ns_switch_to_ready_state(ns, NS_STATUS_FAILED(ns));
1296 ns->pstates[ns->npstates++] = ns->state;
1301 static void ns_put_pages(struct nandsim *ns)
1305 for (i = 0; i < ns->held_cnt; i++)
1306 put_page(ns->held_pages[i]);
1310 static int ns_get_pages(struct nandsim *ns, struct file *file, size_t count,
1321 ns->held_cnt = 0;
1331 ns_put_pages(ns);
1336 ns->held_pages[ns->held_cnt++] = page;
1341 static ssize_t ns_read_file(struct nandsim *ns, struct file *file, void *buf,
1348 err = ns_get_pages(ns, file, count, pos);
1354 ns_put_pages(ns);
1358 static ssize_t ns_write_file(struct nandsim *ns, struct file *file, void *buf,
1365 err = ns_get_pages(ns, file, count, pos);
1371 ns_put_pages(ns);
1378 static inline union ns_mem *NS_GET_PAGE(struct nandsim *ns)
1380 return &(ns->pages[ns->regs.row]);
1386 static inline u_char *NS_PAGE_BYTE_OFF(struct nandsim *ns)
1388 return NS_GET_PAGE(ns)->byte + NS_PAGE_BYTE_SHIFT(ns);
1391 static int ns_do_read_error(struct nandsim *ns, int num)
1393 unsigned int page_no = ns->regs.row;
1396 get_random_bytes(ns->buf.byte, num);
1403 static void ns_do_bit_flips(struct nandsim *ns, int num)
1411 ns->buf.byte[pos / 8] ^= (1 << (pos % 8));
1414 pos, ns->regs.row, NS_PAGE_BYTE_SHIFT(ns),
1423 static void ns_read_page(struct nandsim *ns, int num)
1427 if (ns->cfile) {
1428 if (!test_bit(ns->regs.row, ns->pages_written)) {
1429 NS_DBG("read_page: page %d not written\n", ns->regs.row);
1430 memset(ns->buf.byte, 0xFF, num);
1436 ns->regs.row, NS_PAGE_BYTE_SHIFT(ns));
1437 if (ns_do_read_error(ns, num))
1439 pos = (loff_t)NS_RAW_OFFSET(ns) + ns->regs.off;
1440 tx = ns_read_file(ns, ns->cfile, ns->buf.byte, num,
1443 NS_ERR("read_page: read error for page %d ret %ld\n", ns->regs.row, (long)tx);
1446 ns_do_bit_flips(ns, num);
1451 mypage = NS_GET_PAGE(ns);
1453 NS_DBG("read_page: page %d not allocated\n", ns->regs.row);
1454 memset(ns->buf.byte, 0xFF, num);
1457 ns->regs.row, NS_PAGE_BYTE_SHIFT(ns));
1458 if (ns_do_read_error(ns, num))
1460 memcpy(ns->buf.byte, NS_PAGE_BYTE_OFF(ns), num);
1461 ns_do_bit_flips(ns, num);
1468 static void ns_erase_sector(struct nandsim *ns)
1473 if (ns->cfile) {
1474 for (i = 0; i < ns->geom.pgsec; i++)
1475 if (__test_and_clear_bit(ns->regs.row + i,
1476 ns->pages_written)) {
1477 NS_DBG("erase_sector: freeing page %d\n", ns->regs.row + i);
1482 mypage = NS_GET_PAGE(ns);
1483 for (i = 0; i < ns->geom.pgsec; i++) {
1485 NS_DBG("erase_sector: freeing page %d\n", ns->regs.row+i);
1486 kmem_cache_free(ns->nand_pages_slab, mypage->byte);
1496 static int ns_prog_page(struct nandsim *ns, int num)
1502 if (ns->cfile) {
1507 NS_DBG("prog_page: writing page %d\n", ns->regs.row);
1508 pg_off = ns->file_buf + NS_PAGE_BYTE_SHIFT(ns);
1509 off = (loff_t)NS_RAW_OFFSET(ns) + ns->regs.off;
1510 if (!test_bit(ns->regs.row, ns->pages_written)) {
1512 memset(ns->file_buf, 0xff, ns->geom.pgszoob);
1515 tx = ns_read_file(ns, ns->cfile, pg_off, num, off);
1517 NS_ERR("prog_page: read error for page %d ret %ld\n", ns->regs.row, (long)tx);
1522 pg_off[i] &= ns->buf.byte[i];
1524 loff_t pos = (loff_t)ns->regs.row * ns->geom.pgszoob;
1525 tx = ns_write_file(ns, ns->cfile, ns->file_buf,
1526 ns->geom.pgszoob, pos);
1527 if (tx != ns->geom.pgszoob) {
1528 NS_ERR("prog_page: write error for page %d ret %ld\n", ns->regs.row, (long)tx);
1531 __set_bit(ns->regs.row, ns->pages_written);
1533 tx = ns_write_file(ns, ns->cfile, pg_off, num, off);
1535 NS_ERR("prog_page: write error for page %d ret %ld\n", ns->regs.row, (long)tx);
1542 mypage = NS_GET_PAGE(ns);
1544 NS_DBG("prog_page: allocating page %d\n", ns->regs.row);
1551 mypage->byte = kmem_cache_alloc(ns->nand_pages_slab, GFP_NOFS);
1553 NS_ERR("prog_page: error allocating memory for page %d\n", ns->regs.row);
1556 memset(mypage->byte, 0xFF, ns->geom.pgszoob);
1559 pg_off = NS_PAGE_BYTE_OFF(ns);
1561 pg_off[i] &= ns->buf.byte[i];
1571 static int ns_do_state_action(struct nandsim *ns, uint32_t action)
1574 int busdiv = ns->busw == 8 ? 1 : 2;
1580 if (action != ACTION_SECERASE && ns->regs.row >= ns->geom.pgnum) {
1581 NS_WARN("do_state_action: wrong page number (%#x)\n", ns->regs.row);
1593 if (ns->regs.column >= (ns->geom.pgszoob - ns->regs.off)) {
1597 num = ns->geom.pgszoob - NS_PAGE_BYTE_SHIFT(ns);
1598 ns_read_page(ns, num);
1601 num, NS_RAW_OFFSET(ns) + ns->regs.off);
1603 if (ns->regs.off == 0)
1604 NS_LOG("read page %d\n", ns->regs.row);
1605 else if (ns->regs.off < ns->geom.pgsz)
1606 NS_LOG("read page %d (second half)\n", ns->regs.row);
1608 NS_LOG("read OOB of page %d\n", ns->regs.row);
1611 NS_UDELAY(input_cycle * ns->geom.pgsz / 1000 / busdiv);
1620 if (ns->lines.wp) {
1625 if (ns->regs.row >= ns->geom.pgnum - ns->geom.pgsec
1626 || (ns->regs.row & ~(ns->geom.secsz - 1))) {
1627 NS_ERR("do_state_action: wrong sector address (%#x)\n", ns->regs.row);
1631 ns->regs.row = (ns->regs.row <<
1632 8 * (ns->geom.pgaddrbytes - ns->geom.secaddrbytes)) | ns->regs.column;
1633 ns->regs.column = 0;
1635 erase_block_no = ns->regs.row >> (ns->geom.secshift - ns->geom.pgshift);
1638 ns->regs.row, NS_RAW_OFFSET(ns));
1641 ns_erase_sector(ns);
1660 if (ns->lines.wp) {
1665 num = ns->geom.pgszoob - NS_PAGE_BYTE_SHIFT(ns);
1666 if (num != ns->regs.count) {
1668 ns->regs.count, num);
1672 if (ns_prog_page(ns, num) == -1)
1675 page_no = ns->regs.row;
1678 num, ns->regs.row, ns->regs.column, NS_RAW_OFFSET(ns) + ns->regs.off);
1679 NS_LOG("programm page %d\n", ns->regs.row);
1682 NS_UDELAY(output_cycle * ns->geom.pgsz / 1000 / busdiv);
1693 ns->regs.off = 0;
1697 if (!(ns->options & OPT_PAGE512_8BIT)) {
1702 NS_DBG("do_state_action: set internal offset to %d\n", ns->geom.pgsz/2);
1703 ns->regs.off = ns->geom.pgsz/2;
1707 NS_DBG("do_state_action: set internal offset to %d\n", ns->geom.pgsz);
1708 ns->regs.off = ns->geom.pgsz;
1721 static void ns_switch_state(struct nandsim *ns)
1723 if (ns->op) {
1729 ns->stateidx += 1;
1730 ns->state = ns->nxstate;
1731 ns->nxstate = ns->op[ns->stateidx + 1];
1735 ns_get_state_name(ns->state),
1736 ns_get_state_name(ns->nxstate));
1747 ns->state = ns_get_state_by_command(ns->regs.command);
1751 if (ns_find_operation(ns, 0))
1756 if ((ns->state & ACTION_MASK) &&
1757 ns_do_state_action(ns, ns->state) < 0) {
1758 ns_switch_to_ready_state(ns, NS_STATUS_FAILED(ns));
1763 if ((ns->nxstate & STATE_ADDR_MASK) && ns->busw == 16) {
1765 ns->regs.column <<= 1;
1768 if (NS_STATE(ns->nxstate) == STATE_READY) {
1773 u_char status = NS_STATUS_OK(ns);
1776 if ((ns->state & (STATE_DATAIN_MASK | STATE_DATAOUT_MASK))
1777 && ns->regs.count != ns->regs.num) {
1779 ns->regs.num - ns->regs.count);
1780 status = NS_STATUS_FAILED(ns);
1785 ns_switch_to_ready_state(ns, status);
1788 } else if (ns->nxstate & (STATE_DATAIN_MASK | STATE_DATAOUT_MASK)) {
1793 ns->state = ns->nxstate;
1794 ns->nxstate = ns->op[++ns->stateidx + 1];
1795 ns->regs.num = ns->regs.count = 0;
1799 ns_get_state_name(ns->state),
1800 ns_get_state_name(ns->nxstate));
1806 switch (NS_STATE(ns->state)) {
1809 ns->regs.num = ns->geom.pgszoob - NS_PAGE_BYTE_SHIFT(ns);
1813 ns->regs.num = ns->geom.idbytes;
1817 ns->regs.count = ns->regs.num = 0;
1824 } else if (ns->nxstate & STATE_ADDR_MASK) {
1830 ns->regs.count = 0;
1832 switch (NS_STATE(ns->nxstate)) {
1834 ns->regs.num = ns->geom.pgaddrbytes;
1838 ns->regs.num = ns->geom.secaddrbytes;
1842 ns->regs.num = 1;
1847 ns->regs.num = ns->geom.pgaddrbytes - ns->geom.secaddrbytes;
1858 ns->regs.num = 0;
1859 ns->regs.count = 0;
1865 struct nandsim *ns = nand_get_controller_data(chip);
1869 if (!ns->lines.ce) {
1873 if (ns->lines.ale || ns->lines.cle) {
1877 if (!(ns->state & STATE_DATAOUT_MASK)) {
1879 ns_get_state_name(ns->state), (uint)outb);
1884 if (NS_STATE(ns->state) == STATE_DATAOUT_STATUS) {
1885 NS_DBG("read_byte: return %#x status\n", ns->regs.status);
1886 return ns->regs.status;
1890 if (ns->regs.count == ns->regs.num) {
1895 switch (NS_STATE(ns->state)) {
1897 if (ns->busw == 8) {
1898 outb = ns->buf.byte[ns->regs.count];
1899 ns->regs.count += 1;
1901 outb = (u_char)cpu_to_le16(ns->buf.word[ns->regs.count >> 1]);
1902 ns->regs.count += 2;
1906 NS_DBG("read_byte: read ID byte %d, total = %d\n", ns->regs.count, ns->regs.num);
1907 outb = ns->ids[ns->regs.count];
1908 ns->regs.count += 1;
1914 if (ns->regs.count == ns->regs.num) {
1917 if (NS_STATE(ns->nxstate) == STATE_READY)
1918 ns_switch_state(ns);
1926 struct nandsim *ns = nand_get_controller_data(chip);
1929 if (!ns->lines.ce) {
1933 if (ns->lines.ale && ns->lines.cle) {
1938 if (ns->lines.cle == 1) {
1945 ns_switch_to_ready_state(ns, NS_STATUS_OK(ns));
1955 if (NS_STATE(ns->state) == STATE_DATAOUT_STATUS
1956 || NS_STATE(ns->state) == STATE_DATAOUT) {
1957 int row = ns->regs.row;
1959 ns_switch_state(ns);
1961 ns->regs.row = row;
1965 if (NS_STATE(ns->nxstate) != STATE_UNKNOWN && !(ns->nxstate & STATE_CMD_MASK)) {
1967 if (!(ns->regs.command == NAND_CMD_READID &&
1968 NS_STATE(ns->state) == STATE_DATAOUT_ID && ns->regs.count == 2)) {
1976 ns_get_state_name(ns->nxstate));
1978 ns_switch_to_ready_state(ns, NS_STATUS_FAILED(ns));
1983 ns->regs.command = byte;
1984 ns_switch_state(ns);
1986 } else if (ns->lines.ale == 1) {
1991 if (NS_STATE(ns->nxstate) == STATE_UNKNOWN) {
1995 if (ns_find_operation(ns, 1) < 0)
1998 if ((ns->state & ACTION_MASK) &&
1999 ns_do_state_action(ns, ns->state) < 0) {
2000 ns_switch_to_ready_state(ns,
2001 NS_STATUS_FAILED(ns));
2005 ns->regs.count = 0;
2006 switch (NS_STATE(ns->nxstate)) {
2008 ns->regs.num = ns->geom.pgaddrbytes;
2011 ns->regs.num = ns->geom.secaddrbytes;
2014 ns->regs.num = 1;
2022 if (!(ns->nxstate & STATE_ADDR_MASK)) {
2024 (uint)byte, ns_get_state_name(ns->nxstate));
2025 ns_switch_to_ready_state(ns, NS_STATUS_FAILED(ns));
2030 if (ns->regs.count == ns->regs.num) {
2032 ns_switch_to_ready_state(ns, NS_STATUS_FAILED(ns));
2036 ns_accept_addr_byte(ns, byte);
2038 ns->regs.count += 1;
2041 (uint)byte, ns->regs.count, ns->regs.num);
2043 if (ns->regs.count == ns->regs.num) {
2044 NS_DBG("address (%#x, %#x) is accepted\n", ns->regs.row, ns->regs.column);
2045 ns_switch_state(ns);
2054 if (!(ns->state & STATE_DATAIN_MASK)) {
2056 (uint)byte, ns_get_state_name(ns->state),
2058 ns_switch_to_ready_state(ns, NS_STATUS_FAILED(ns));
2063 if (ns->regs.count == ns->regs.num) {
2065 ns->regs.num);
2069 if (ns->busw == 8) {
2070 ns->buf.byte[ns->regs.count] = byte;
2071 ns->regs.count += 1;
2073 ns->buf.word[ns->regs.count >> 1] = cpu_to_le16((uint16_t)byte);
2074 ns->regs.count += 2;
2084 struct nandsim *ns = nand_get_controller_data(chip);
2087 if (!(ns->state & STATE_DATAIN_MASK)) {
2089 ns_get_state_name(ns->state));
2090 ns_switch_to_ready_state(ns, NS_STATUS_FAILED(ns));
2095 if (ns->regs.count + len > ns->regs.num) {
2097 ns_switch_to_ready_state(ns, NS_STATUS_FAILED(ns));
2101 memcpy(ns->buf.byte + ns->regs.count, buf, len);
2102 ns->regs.count += len;
2104 if (ns->regs.count == ns->regs.num) {
2105 NS_DBG("write_buf: %d bytes were written\n", ns->regs.count);
2111 struct nandsim *ns = nand_get_controller_data(chip);
2114 if (!ns->lines.ce) {
2118 if (ns->lines.ale || ns->lines.cle) {
2122 if (!(ns->state & STATE_DATAOUT_MASK)) {
2124 ns_get_state_name(ns->state));
2128 if (NS_STATE(ns->state) != STATE_DATAOUT) {
2138 if (ns->regs.count + len > ns->regs.num) {
2140 ns_switch_to_ready_state(ns, NS_STATUS_FAILED(ns));
2144 memcpy(buf, ns->buf.byte + ns->regs.count, len);
2145 ns->regs.count += len;
2147 if (ns->regs.count == ns->regs.num) {
2148 if (NS_STATE(ns->nxstate) == STATE_READY)
2149 ns_switch_state(ns);
2161 struct nandsim *ns = nand_get_controller_data(chip);
2181 ns->lines.ce = 1;
2185 ns->lines.cle = 0;
2186 ns->lines.ale = 0;
2190 ns->lines.cle = 1;
2194 ns->lines.ale = 1;
2264 struct nandsim *ns;
2272 ns = kzalloc(sizeof(struct nandsim), GFP_KERNEL);
2273 if (!ns) {
2277 chip = &ns->chip;
2279 nand_set_controller_data(chip, (void *)ns);
2304 ns->geom.idbytes = 8;
2306 ns->geom.idbytes = 6;
2308 ns->geom.idbytes = 4;
2310 ns->geom.idbytes = 2;
2311 ns->regs.status = NS_STATUS_OK(ns);
2312 ns->nxstate = STATE_UNKNOWN;
2313 ns->options |= OPT_PAGE512; /* temporary value */
2314 memcpy(ns->ids, id_bytes, sizeof(ns->ids));
2316 ns->busw = 16;
2334 nand_controller_init(&ns->base);
2335 ns->base.ops = &ns_controller_ops;
2336 chip->controller = &ns->base;
2377 ret = ns_parse_badblocks(ns, nsmtd);
2382 ret = mtd_device_register(nsmtd, &ns->partitions[0], ns->nbparts);
2386 ret = ns_debugfs_create(ns);
2395 ns_free(ns);
2416 kfree(ns);
2429 struct nandsim *ns = nand_get_controller_data(chip);
2432 ns_debugfs_remove(ns);
2434 ns_free(ns);
2453 kfree(ns);