Lines Matching refs:map
35 #include <linux/mtd/map.h>
99 static int chip_ready (struct map_info *map, struct flchip *chip, unsigned long adr, int mode);
100 static int get_chip(struct map_info *map, struct flchip *chip, unsigned long adr, int mode);
101 static void put_chip(struct map_info *map, struct flchip *chip, unsigned long adr);
174 struct map_info *map = mtd->priv;
175 struct cfi_private *cfi = map->fldrv_priv;
214 struct map_info *map = mtd->priv;
215 struct cfi_private *cfi = map->fldrv_priv;
226 struct map_info *map = mtd->priv;
227 struct cfi_private *cfi = map->fldrv_priv;
239 struct map_info *map = mtd->priv;
240 struct cfi_private *cfi = map->fldrv_priv;
252 struct map_info *map = mtd->priv;
253 struct cfi_private *cfi = map->fldrv_priv;
261 struct map_info *map = mtd->priv;
262 struct cfi_private *cfi = map->fldrv_priv;
281 struct map_info *map = mtd->priv;
282 struct cfi_private *cfi = map->fldrv_priv;
289 map_write(map, CMD(0x60), 0);
290 map_write(map, CMD(0x04), 0);
301 struct map_info *map = mtd->priv;
302 if (!mtd->_point && map_is_linear(map)) {
310 struct map_info *map = mtd->priv;
311 struct cfi_private *cfi = map->fldrv_priv;
324 struct map_info *map = mtd->priv;
325 struct cfi_private *cfi = map->fldrv_priv;
393 read_pri_intelext(struct map_info *map, __u16 adr)
395 struct cfi_private *cfi = map->fldrv_priv;
401 extp = (struct cfi_pri_intelext *)cfi_read_pri(map, adr, extp_size, "Intel/Sharp");
498 struct mtd_info *cfi_cmdset_0001(struct map_info *map, int primary)
500 struct cfi_private *cfi = map->fldrv_priv;
507 mtd->priv = map;
521 mtd->name = map->name;
536 extp = read_pri_intelext(map, adr);
607 map->fldrv = &cfi_intelext_chipdrv;
611 struct mtd_info *cfi_cmdset_0003(struct map_info *map, int primary) __attribute__((alias("cfi_cmdset_0001")));
612 struct mtd_info *cfi_cmdset_0200(struct map_info *map, int primary) __attribute__((alias("cfi_cmdset_0001")));
619 struct map_info *map = mtd->priv;
620 struct cfi_private *cfi = map->fldrv_priv;
700 struct map_info *map = mtd->priv;
760 map->name, mtd->writesize,
813 map->name, cfi->numchips, cfi->interleave,
816 map->fldrv_priv = newcfi;
827 static int chip_ready (struct map_info *map, struct flchip *chip, unsigned long adr, int mode)
830 struct cfi_private *cfi = map->fldrv_priv;
843 status = map_read(map, adr);
844 if (map_word_andequal(map, status, status_OK, status_OK))
849 if (chip->priv && map_word_andequal(map, status, status_PWS, status_PWS))
882 map_write(map, CMD(0xB0), chip->in_progress_block_addr);
889 map_write(map, CMD(0x70), chip->in_progress_block_addr);
894 status = map_read(map, chip->in_progress_block_addr);
895 if (map_word_andequal(map, status, status_OK, status_OK))
901 put_chip(map, chip, adr);
903 "suspended: status = 0x%lx\n", map->name, status.x[0]);
944 static int get_chip(struct map_info *map, struct flchip *chip, unsigned long adr, int mode)
990 ret = chip_ready(map, contender, contender->start, mode);
1006 put_chip(map, contender, contender->start);
1033 ret = chip_ready(map, chip, adr, mode);
1040 static void put_chip(struct map_info *map, struct flchip *chip, unsigned long adr)
1042 struct cfi_private *cfi = map->fldrv_priv;
1056 put_chip(map, loaner, loaner->start);
1090 map_write(map, CMD(0xd0), chip->in_progress_block_addr);
1091 map_write(map, CMD(0x70), chip->in_progress_block_addr);
1106 printk(KERN_ERR "%s: put_chip() called with oldstate %d!!\n", map->name, chip->oldstate);
1124 static void xip_disable(struct map_info *map, struct flchip *chip,
1128 (void) map_read(map, adr); /* ensure mmu mapping is up to date */
1132 static void __xipram xip_enable(struct map_info *map, struct flchip *chip,
1135 struct cfi_private *cfi = map->fldrv_priv;
1137 map_write(map, CMD(0xff), adr);
1140 (void) map_read(map, adr);
1159 struct map_info *map, struct flchip *chip,
1162 struct cfi_private *cfi = map->fldrv_priv;
1191 map_write(map, CMD(0xb0), adr);
1192 map_write(map, CMD(0x70), adr);
1204 status = map_read(map, adr);
1205 } while (!map_word_andequal(map, status, OK, OK));
1210 if (!map_word_bitsset(map, status, CMD(0x40)))
1215 if (!map_word_bitsset(map, status, CMD(0x04)))
1221 map_write(map, CMD(0xff), adr);
1222 (void) map_read(map, adr);
1249 map_write(map, CMD(0xd0), adr);
1250 map_write(map, CMD(0x70), adr);
1261 status = map_read(map, adr);
1263 } while (!map_word_andequal(map, status, OK, OK)
1276 #define XIP_INVAL_CACHED_RANGE(map, from, size) \
1277 INVALIDATE_CACHED_RANGE(map, from, size)
1279 #define INVAL_CACHE_AND_WAIT(map, chip, cmd_adr, inval_adr, inval_len, usec, usec_max) \
1280 xip_wait_for_operation(map, chip, cmd_adr, usec_max)
1284 #define xip_disable(map, chip, adr)
1285 #define xip_enable(map, chip, adr)
1290 struct map_info *map, struct flchip *chip,
1294 struct cfi_private *cfi = map->fldrv_priv;
1301 INVALIDATE_CACHED_RANGE(map, inval_adr, inval_len);
1323 status = map_read(map, cmd_adr);
1324 if (map_word_andequal(map, status, status_OK, status_OK))
1338 map_write(map, CMD(0x70), cmd_adr);
1369 #define WAIT_TIMEOUT(map, chip, adr, udelay, udelay_max) \
1370 INVAL_CACHE_AND_WAIT(map, chip, adr, 0, 0, udelay, udelay_max);
1373 static int do_point_onechip (struct map_info *map, struct flchip *chip, loff_t adr, size_t len)
1376 struct cfi_private *cfi = map->fldrv_priv;
1382 cmd_addr = adr & ~(map_bankwidth(map)-1);
1386 ret = get_chip(map, chip, cmd_addr, FL_POINT);
1390 map_write(map, CMD(0xff), cmd_addr);
1403 struct map_info *map = mtd->priv;
1404 struct cfi_private *cfi = map->fldrv_priv;
1409 if (!map->virt)
1418 *virt = map->virt + cfi->chips[chipnum].start + ofs;
1420 *phys = map->phys + cfi->chips[chipnum].start + ofs;
1439 ret = do_point_onechip(map, &cfi->chips[chipnum], ofs, thislen);
1455 struct map_info *map = mtd->priv;
1456 struct cfi_private *cfi = map->fldrv_priv;
1485 printk(KERN_ERR "%s: Error: unpoint called on non pointed region\n", map->name);
1489 put_chip(map, chip, chip->start);
1500 static inline int do_read_onechip(struct map_info *map, struct flchip *chip, loff_t adr, size_t len, u_char *buf)
1503 struct cfi_private *cfi = map->fldrv_priv;
1509 cmd_addr = adr & ~(map_bankwidth(map)-1);
1512 ret = get_chip(map, chip, cmd_addr, FL_READY);
1519 map_write(map, CMD(0xff), cmd_addr);
1524 map_copy_from(map, buf, adr, len);
1526 put_chip(map, chip, cmd_addr);
1534 struct map_info *map = mtd->priv;
1535 struct cfi_private *cfi = map->fldrv_priv;
1555 ret = do_read_onechip(map, &cfi->chips[chipnum], ofs, thislen, buf);
1569 static int __xipram do_write_oneword(struct map_info *map, struct flchip *chip,
1572 struct cfi_private *cfi = map->fldrv_priv;
1590 ret = get_chip(map, chip, adr, mode);
1596 XIP_INVAL_CACHED_RANGE(map, adr, map_bankwidth(map));
1597 ENABLE_VPP(map);
1598 xip_disable(map, chip, adr);
1599 map_write(map, write_cmd, adr);
1600 map_write(map, datum, adr);
1603 ret = INVAL_CACHE_AND_WAIT(map, chip, adr,
1604 adr, map_bankwidth(map),
1608 xip_enable(map, chip, adr);
1609 printk(KERN_ERR "%s: word write error (status timeout)\n", map->name);
1614 status = map_read(map, adr);
1615 if (map_word_bitsset(map, status, CMD(0x1a))) {
1619 map_write(map, CMD(0x50), adr);
1620 map_write(map, CMD(0x70), adr);
1621 xip_enable(map, chip, adr);
1626 printk(KERN_ERR "%s: word write error (bad VPP)\n", map->name);
1629 printk(KERN_ERR "%s: word write error (status 0x%lx)\n", map->name, chipstatus);
1636 xip_enable(map, chip, adr);
1637 out: DISABLE_VPP(map);
1638 put_chip(map, chip, adr);
1646 struct map_info *map = mtd->priv;
1647 struct cfi_private *cfi = map->fldrv_priv;
1656 if (ofs & (map_bankwidth(map)-1)) {
1657 unsigned long bus_ofs = ofs & ~(map_bankwidth(map)-1);
1662 n = min_t(int, len, map_bankwidth(map)-gap);
1663 datum = map_word_ff(map);
1664 datum = map_word_load_partial(map, datum, buf, gap, n);
1666 ret = do_write_oneword(map, &cfi->chips[chipnum],
1684 while(len >= map_bankwidth(map)) {
1685 map_word datum = map_word_load(map, buf);
1687 ret = do_write_oneword(map, &cfi->chips[chipnum],
1692 ofs += map_bankwidth(map);
1693 buf += map_bankwidth(map);
1694 (*retlen) += map_bankwidth(map);
1695 len -= map_bankwidth(map);
1705 if (len & (map_bankwidth(map)-1)) {
1708 datum = map_word_ff(map);
1709 datum = map_word_load_partial(map, datum, buf, 0, len);
1711 ret = do_write_oneword(map, &cfi->chips[chipnum],
1723 static int __xipram do_write_buffer(struct map_info *map, struct flchip *chip,
1727 struct cfi_private *cfi = map->fldrv_priv;
1751 ret = get_chip(map, chip, cmd_adr, FL_WRITING);
1757 XIP_INVAL_CACHED_RANGE(map, initial_adr, initial_len);
1758 ENABLE_VPP(map);
1759 xip_disable(map, chip, cmd_adr);
1766 map_write(map, CMD(0x70), cmd_adr);
1769 status = map_read(map, cmd_adr);
1770 if (map_word_bitsset(map, status, CMD(0x30))) {
1771 xip_enable(map, chip, cmd_adr);
1773 xip_disable(map, chip, cmd_adr);
1774 map_write(map, CMD(0x50), cmd_adr);
1775 map_write(map, CMD(0x70), cmd_adr);
1779 map_write(map, write_cmd, cmd_adr);
1780 ret = WAIT_TIMEOUT(map, chip, cmd_adr, 0, 0);
1783 map_word Xstatus = map_read(map, cmd_adr);
1784 map_write(map, CMD(0x70), cmd_adr);
1786 status = map_read(map, cmd_adr);
1787 map_write(map, CMD(0x50), cmd_adr);
1788 map_write(map, CMD(0x70), cmd_adr);
1789 xip_enable(map, chip, cmd_adr);
1791 map->name, Xstatus.x[0], status.x[0]);
1796 word_gap = (-adr & (map_bankwidth(map)-1));
1797 words = DIV_ROUND_UP(len - word_gap, map_bankwidth(map));
1801 word_gap = map_bankwidth(map) - word_gap;
1803 datum = map_word_ff(map);
1807 map_write(map, CMD(words), cmd_adr );
1813 int n = map_bankwidth(map) - word_gap;
1819 if (!word_gap && len < map_bankwidth(map))
1820 datum = map_word_ff(map);
1822 datum = map_word_load_partial(map, datum,
1828 if (!len || word_gap == map_bankwidth(map)) {
1829 map_write(map, datum, adr);
1830 adr += map_bankwidth(map);
1844 map_write(map, CMD(0xd0), cmd_adr);
1847 ret = INVAL_CACHE_AND_WAIT(map, chip, cmd_adr,
1852 map_write(map, CMD(0x70), cmd_adr);
1854 xip_enable(map, chip, cmd_adr);
1855 printk(KERN_ERR "%s: buffer write error (status timeout)\n", map->name);
1860 status = map_read(map, cmd_adr);
1861 if (map_word_bitsset(map, status, CMD(0x1a))) {
1865 map_write(map, CMD(0x50), cmd_adr);
1866 map_write(map, CMD(0x70), cmd_adr);
1867 xip_enable(map, chip, cmd_adr);
1872 printk(KERN_ERR "%s: buffer write error (bad VPP)\n", map->name);
1875 printk(KERN_ERR "%s: buffer write error (status 0x%lx)\n", map->name, chipstatus);
1882 xip_enable(map, chip, cmd_adr);
1883 out: DISABLE_VPP(map);
1884 put_chip(map, chip, cmd_adr);
1892 struct map_info *map = mtd->priv;
1893 struct cfi_private *cfi = map->fldrv_priv;
1916 ret = do_write_buffer(map, &cfi->chips[chipnum],
1952 static int __xipram do_erase_oneblock(struct map_info *map, struct flchip *chip,
1955 struct cfi_private *cfi = map->fldrv_priv;
1964 ret = get_chip(map, chip, adr, FL_ERASING);
1970 XIP_INVAL_CACHED_RANGE(map, adr, len);
1971 ENABLE_VPP(map);
1972 xip_disable(map, chip, adr);
1975 map_write(map, CMD(0x50), adr);
1978 map_write(map, CMD(0x20), adr);
1979 map_write(map, CMD(0xD0), adr);
1985 ret = INVAL_CACHE_AND_WAIT(map, chip, adr,
1990 map_write(map, CMD(0x70), adr);
1992 xip_enable(map, chip, adr);
1993 printk(KERN_ERR "%s: block erase error: (status timeout)\n", map->name);
1998 map_write(map, CMD(0x70), adr);
2000 status = map_read(map, adr);
2003 if (map_word_bitsset(map, status, CMD(0x3a))) {
2007 map_write(map, CMD(0x50), adr);
2008 map_write(map, CMD(0x70), adr);
2009 xip_enable(map, chip, adr);
2012 printk(KERN_ERR "%s: block erase error: (bad command sequence, status 0x%lx)\n", map->name, chipstatus);
2019 printk(KERN_ERR "%s: block erase error: (bad VPP)\n", map->name);
2023 DISABLE_VPP(map);
2024 put_chip(map, chip, adr);
2028 printk(KERN_ERR "%s: block erase failed at 0x%08lx (status 0x%lx)\n", map->name, adr, chipstatus);
2035 xip_enable(map, chip, adr);
2036 out: DISABLE_VPP(map);
2037 put_chip(map, chip, adr);
2050 struct map_info *map = mtd->priv;
2051 struct cfi_private *cfi = map->fldrv_priv;
2060 ret = get_chip(map, chip, chip->start, FL_SYNCING);
2089 static int __xipram do_getlockstatus_oneblock(struct map_info *map,
2094 struct cfi_private *cfi = map->fldrv_priv;
2098 xip_disable(map, chip, adr+(2*ofs_factor));
2099 map_write(map, CMD(0x90), adr+(2*ofs_factor));
2101 status = cfi_read_query(map, adr+(2*ofs_factor));
2102 xip_enable(map, chip, 0);
2107 static int __xipram do_printlockstatus_oneblock(struct map_info *map,
2113 adr, do_getlockstatus_oneblock(map, chip, adr, len, thunk));
2121 static int __xipram do_xxlock_oneblock(struct map_info *map, struct flchip *chip,
2124 struct cfi_private *cfi = map->fldrv_priv;
2132 ret = get_chip(map, chip, adr, FL_LOCKING);
2138 ENABLE_VPP(map);
2139 xip_disable(map, chip, adr);
2141 map_write(map, CMD(0x60), adr);
2143 map_write(map, CMD(0x01), adr);
2146 map_write(map, CMD(0xD0), adr);
2165 ret = WAIT_TIMEOUT(map, chip, adr, mdelay, mdelay * 1000);
2167 map_write(map, CMD(0x70), adr);
2169 xip_enable(map, chip, adr);
2170 printk(KERN_ERR "%s: block unlock error: (status timeout)\n", map->name);
2174 xip_enable(map, chip, adr);
2175 out: DISABLE_VPP(map);
2176 put_chip(map, chip, adr);
2238 typedef int (*otp_op_t)(struct map_info *map, struct flchip *chip,
2243 do_otp_read(struct map_info *map, struct flchip *chip, u_long offset,
2246 struct cfi_private *cfi = map->fldrv_priv;
2250 ret = get_chip(map, chip, chip->start, FL_JEDEC_QUERY);
2257 INVALIDATE_CACHED_RANGE(map, chip->start + offset, size);
2259 xip_disable(map, chip, chip->start);
2261 map_write(map, CMD(0x90), chip->start);
2264 map_copy_from(map, buf, chip->start + offset, size);
2265 xip_enable(map, chip, chip->start);
2268 INVALIDATE_CACHED_RANGE(map, chip->start + offset, size);
2270 put_chip(map, chip, chip->start);
2276 do_otp_write(struct map_info *map, struct flchip *chip, u_long offset,
2282 unsigned long bus_ofs = offset & ~(map_bankwidth(map)-1);
2284 int n = min_t(int, size, map_bankwidth(map)-gap);
2285 map_word datum = map_word_ff(map);
2287 datum = map_word_load_partial(map, datum, buf, gap, n);
2288 ret = do_write_oneword(map, chip, bus_ofs, datum, FL_OTP_WRITE);
2301 do_otp_lock(struct map_info *map, struct flchip *chip, u_long offset,
2304 struct cfi_private *cfi = map->fldrv_priv;
2311 datum = map_word_ff(map);
2312 datum = map_word_clr(map, datum, CMD(1 << grpno));
2313 return do_write_oneword(map, chip, prot, datum, FL_OTP_WRITE);
2320 struct map_info *map = mtd->priv;
2321 struct cfi_private *cfi = map->fldrv_priv;
2395 ret = do_otp_read(map, chip,
2398 map_bankwidth(map),
2406 !map_word_bitsset(map, lockword,
2421 ret = action(map, chip, data_offset,
2527 struct map_info *map = mtd->priv;
2528 struct cfi_private *cfi = map->fldrv_priv;
2550 map_write(map, CMD(0xFF), cfi->chips[i].start);
2622 struct map_info *map = mtd->priv;
2623 struct cfi_private *cfi = map->fldrv_priv;
2638 map_write(map, CMD(0xFF), cfi->chips[i].start);
2653 struct map_info *map = mtd->priv;
2654 struct cfi_private *cfi = map->fldrv_priv;
2664 ret = get_chip(map, chip, chip->start, FL_SHUTDOWN);
2666 map_write(map, CMD(0xff), chip->start);
2668 put_chip(map, chip, chip->start);
2688 struct map_info *map = mtd->priv;
2689 struct cfi_private *cfi = map->fldrv_priv;