Lines Matching defs:map
35 #include <linux/mtd/map.h>
97 static int get_chip(struct map_info *map, struct flchip *chip, unsigned long adr, int mode);
98 static void put_chip(struct map_info *map, struct flchip *chip, unsigned long adr);
129 static int cfi_check_err_status(struct map_info *map, struct flchip *chip,
132 struct cfi_private *cfi = map->fldrv_priv;
138 cfi_send_gen_cmd(0x70, cfi->addr_unlock1, chip->start, map, cfi,
140 status = map_read(map, adr);
143 if (!map_word_bitsset(map, status, CMD(CFI_SR_DRB)))
146 if (map_word_bitsset(map, status, CMD(0x3a))) {
151 map->name, chipstatus);
154 map->name, chipstatus);
157 map->name, chipstatus);
160 map->name, chipstatus);
226 struct map_info *map = mtd->priv;
227 struct cfi_private *cfi = map->fldrv_priv;
236 map->name, cfi->mfr, cfi->id);
256 " detected\n", map->name);
260 printk(KERN_WARNING "%s: JEDEC Device ID is 0x%02X. Assuming broken CFI table.\n", map->name, cfi->id);
267 " deduced %s from Device ID\n", map->name, major, minor,
276 struct map_info *map = mtd->priv;
277 struct cfi_private *cfi = map->fldrv_priv;
292 struct map_info *map = mtd->priv;
293 struct cfi_private *cfi = map->fldrv_priv;
330 struct map_info *map = mtd->priv;
331 struct cfi_private *cfi = map->fldrv_priv;
352 struct map_info *map = mtd->priv;
353 struct cfi_private *cfi = map->fldrv_priv;
366 struct map_info *map = mtd->priv;
367 struct cfi_private *cfi = map->fldrv_priv;
377 struct map_info *map = mtd->priv;
378 struct cfi_private *cfi = map->fldrv_priv;
390 struct map_info *map = mtd->priv;
391 struct cfi_private *cfi = map->fldrv_priv;
406 struct map_info *map = mtd->priv;
407 struct cfi_private *cfi = map->fldrv_priv;
418 struct map_info *map = mtd->priv;
419 struct cfi_private *cfi = map->fldrv_priv;
430 struct map_info *map = mtd->priv;
431 struct cfi_private *cfi = map->fldrv_priv;
444 struct map_info *map = mtd->priv;
445 struct cfi_private *cfi = map->fldrv_priv;
557 static void cfi_fixup_m29ew_erase_suspend(struct map_info *map,
560 struct cfi_private *cfi = map->fldrv_priv;
563 map_write(map, CMD(0xF0), adr);
600 struct mtd_info *cfi_cmdset_0002(struct map_info *map, int primary)
602 struct cfi_private *cfi = map->fldrv_priv;
603 struct device_node __maybe_unused *np = map->device_node;
610 mtd->priv = map;
627 mtd->name = map->name;
642 extp = (struct cfi_pri_amdstd*)cfi_read_pri(map, adr, sizeof(*extp), "Amd/Fujitsu");
697 map->name, bootloc);
702 printk(KERN_WARNING "%s: Swapping erase regions for top-boot CFI table.\n", map->name);
755 map->fldrv = &cfi_amdstd_chipdrv;
759 struct mtd_info *cfi_cmdset_0006(struct map_info *map, int primary) __attribute__((alias("cfi_cmdset_0002")));
760 struct mtd_info *cfi_cmdset_0701(struct map_info *map, int primary) __attribute__((alias("cfi_cmdset_0002")));
767 struct map_info *map = mtd->priv;
768 struct cfi_private *cfi = map->fldrv_priv;
831 static int __xipram chip_ready(struct map_info *map, struct flchip *chip,
834 struct cfi_private *cfi = map->fldrv_priv;
844 cfi_send_gen_cmd(0x70, cfi->addr_unlock1, chip->start, map, cfi,
846 curd = map_read(map, addr);
848 return map_word_andequal(map, curd, ready, ready);
851 oldd = map_read(map, addr);
852 curd = map_read(map, addr);
854 ret = map_word_equal(map, oldd, curd);
859 return map_word_equal(map, curd, *expected);
862 static int __xipram chip_good(struct map_info *map, struct flchip *chip,
865 struct cfi_private *cfi = map->fldrv_priv;
871 return chip_ready(map, chip, addr, datum);
874 static int get_chip(struct map_info *map, struct flchip *chip, unsigned long adr, int mode)
877 struct cfi_private *cfi = map->fldrv_priv;
888 if (chip_ready(map, chip, adr, NULL))
922 map_write(map, CMD(0xB0), chip->in_progress_block_addr);
927 if (chip_ready(map, chip, adr, NULL))
936 put_chip(map, chip, adr);
980 static void put_chip(struct map_info *map, struct flchip *chip, unsigned long adr)
982 struct cfi_private *cfi = map->fldrv_priv;
986 cfi_fixup_m29ew_erase_suspend(map,
988 map_write(map, cfi->sector_erase_cmd, chip->in_progress_block_addr);
1021 static void xip_disable(struct map_info *map, struct flchip *chip,
1025 (void) map_read(map, adr); /* ensure mmu mapping is up to date */
1029 static void __xipram xip_enable(struct map_info *map, struct flchip *chip,
1032 struct cfi_private *cfi = map->fldrv_priv;
1035 map_write(map, CMD(0xf0), adr);
1038 (void) map_read(map, adr);
1056 static void __xipram xip_udelay(struct map_info *map, struct flchip *chip,
1059 struct cfi_private *cfi = map->fldrv_priv;
1080 map_write(map, CMD(0xb0), adr);
1093 status = map_read(map, adr);
1094 } while (!map_word_andequal(map, status, OK, OK));
1098 if (!map_word_bitsset(map, status, CMD(0x40)))
1102 map_write(map, CMD(0xf0), adr);
1103 (void) map_read(map, adr);
1130 cfi_fixup_m29ew_erase_suspend(map, adr);
1132 map_write(map, cfi->sector_erase_cmd, adr);
1143 status = map_read(map, adr);
1144 } while (!map_word_andequal(map, status, OK, OK)
1148 #define UDELAY(map, chip, adr, usec) xip_udelay(map, chip, adr, usec)
1157 #define XIP_INVAL_CACHED_RANGE(map, from, size) \
1158 INVALIDATE_CACHED_RANGE(map, from, size)
1160 #define INVALIDATE_CACHE_UDELAY(map, chip, adr, len, usec) \
1161 UDELAY(map, chip, adr, usec)
1182 #define xip_disable(map, chip, adr)
1183 #define xip_enable(map, chip, adr)
1186 #define UDELAY(map, chip, adr, usec) \
1193 #define INVALIDATE_CACHE_UDELAY(map, chip, adr, len, usec) \
1196 INVALIDATE_CACHED_RANGE(map, adr, len); \
1203 static inline int do_read_onechip(struct map_info *map, struct flchip *chip, loff_t adr, size_t len, u_char *buf)
1206 struct cfi_private *cfi = map->fldrv_priv;
1212 cmd_addr = adr & ~(map_bankwidth(map)-1);
1215 ret = get_chip(map, chip, cmd_addr, FL_READY);
1222 map_write(map, CMD(0xf0), cmd_addr);
1226 map_copy_from(map, buf, adr, len);
1228 put_chip(map, chip, cmd_addr);
1237 struct map_info *map = mtd->priv;
1238 struct cfi_private *cfi = map->fldrv_priv;
1258 ret = do_read_onechip(map, &cfi->chips[chipnum], ofs, thislen, buf);
1272 typedef int (*otp_op_t)(struct map_info *map, struct flchip *chip,
1275 static inline void otp_enter(struct map_info *map, struct flchip *chip,
1278 struct cfi_private *cfi = map->fldrv_priv;
1280 cfi_send_gen_cmd(0xAA, cfi->addr_unlock1, chip->start, map, cfi,
1282 cfi_send_gen_cmd(0x55, cfi->addr_unlock2, chip->start, map, cfi,
1284 cfi_send_gen_cmd(0x88, cfi->addr_unlock1, chip->start, map, cfi,
1287 INVALIDATE_CACHED_RANGE(map, chip->start + adr, len);
1290 static inline void otp_exit(struct map_info *map, struct flchip *chip,
1293 struct cfi_private *cfi = map->fldrv_priv;
1295 cfi_send_gen_cmd(0xAA, cfi->addr_unlock1, chip->start, map, cfi,
1297 cfi_send_gen_cmd(0x55, cfi->addr_unlock2, chip->start, map, cfi,
1299 cfi_send_gen_cmd(0x90, cfi->addr_unlock1, chip->start, map, cfi,
1301 cfi_send_gen_cmd(0x00, cfi->addr_unlock1, chip->start, map, cfi,
1304 INVALIDATE_CACHED_RANGE(map, chip->start + adr, len);
1307 static inline int do_read_secsi_onechip(struct map_info *map,
1333 otp_enter(map, chip, adr, len);
1334 map_copy_from(map, buf, adr, len);
1335 otp_exit(map, chip, adr, len);
1345 struct map_info *map = mtd->priv;
1346 struct cfi_private *cfi = map->fldrv_priv;
1367 ret = do_read_secsi_onechip(map, &cfi->chips[chipnum], ofs,
1382 static int __xipram do_write_oneword(struct map_info *map, struct flchip *chip,
1386 static int do_otp_write(struct map_info *map, struct flchip *chip, loff_t adr,
1391 unsigned long bus_ofs = adr & ~(map_bankwidth(map)-1);
1393 int n = min_t(int, len, map_bankwidth(map) - gap);
1394 map_word datum = map_word_ff(map);
1396 if (n != map_bankwidth(map)) {
1398 otp_enter(map, chip, bus_ofs, map_bankwidth(map));
1399 datum = map_read(map, bus_ofs);
1400 otp_exit(map, chip, bus_ofs, map_bankwidth(map));
1403 datum = map_word_load_partial(map, datum, buf, gap, n);
1404 ret = do_write_oneword(map, chip, bus_ofs, datum, FL_OTP_WRITE);
1416 static int do_otp_lock(struct map_info *map, struct flchip *chip, loff_t adr,
1419 struct cfi_private *cfi = map->fldrv_priv;
1429 ret = get_chip(map, chip, chip->start, FL_LOCKING);
1437 cfi_send_gen_cmd(0xAA, cfi->addr_unlock1, chip->start, map, cfi,
1439 cfi_send_gen_cmd(0x55, cfi->addr_unlock2, chip->start, map, cfi,
1441 cfi_send_gen_cmd(0x40, cfi->addr_unlock1, chip->start, map, cfi,
1445 lockreg = cfi_read_query(map, 0);
1452 map_write(map, CMD(0xA0), chip->start);
1453 map_write(map, CMD(lockreg), chip->start);
1458 if (chip_ready(map, chip, adr, NULL))
1466 UDELAY(map, chip, 0, 1);
1470 map_write(map, CMD(0x90), chip->start);
1471 map_write(map, CMD(0x00), chip->start);
1474 put_chip(map, chip, chip->start);
1484 struct map_info *map = mtd->priv;
1485 struct cfi_private *cfi = map->fldrv_priv;
1511 ret = get_chip(map, chip, base, FL_CFI_QUERY);
1516 cfi_qry_mode_on(base, map, cfi);
1517 otp = cfi_read_query(map, base + 0x3 * ofs_factor);
1518 cfi_qry_mode_off(base, map, cfi);
1519 put_chip(map, chip, base);
1532 ret = get_chip(map, chip, base, FL_LOCKING);
1540 chip->start, map, cfi,
1543 chip->start, map, cfi,
1546 chip->start, map, cfi,
1549 lockreg = cfi_read_query(map, 0);
1551 map_write(map, CMD(0x90), chip->start);
1552 map_write(map, CMD(0x00), chip->start);
1553 put_chip(map, chip, chip->start);
1582 ret = action(map, chip, otpoffset + from, size, buf,
1644 static int __xipram do_write_oneword_once(struct map_info *map,
1662 cfi_send_gen_cmd(0xAA, cfi->addr_unlock1, chip->start, map, cfi, cfi->device_type, NULL);
1663 cfi_send_gen_cmd(0x55, cfi->addr_unlock2, chip->start, map, cfi, cfi->device_type, NULL);
1664 cfi_send_gen_cmd(0xA0, cfi->addr_unlock1, chip->start, map, cfi, cfi->device_type, NULL);
1665 map_write(map, datum, adr);
1668 INVALIDATE_CACHE_UDELAY(map, chip,
1669 adr, map_bankwidth(map),
1694 !chip_good(map, chip, adr, &datum)) {
1695 xip_enable(map, chip, adr);
1697 xip_disable(map, chip, adr);
1702 if (chip_good(map, chip, adr, &datum)) {
1703 if (cfi_check_err_status(map, chip, adr))
1709 UDELAY(map, chip, adr, 1);
1715 static int __xipram do_write_oneword_start(struct map_info *map,
1723 ret = get_chip(map, chip, adr, mode);
1730 otp_enter(map, chip, adr, map_bankwidth(map));
1735 static void __xipram do_write_oneword_done(struct map_info *map,
1740 otp_exit(map, chip, adr, map_bankwidth(map));
1743 DISABLE_VPP(map);
1744 put_chip(map, chip, adr);
1749 static int __xipram do_write_oneword_retry(struct map_info *map,
1754 struct cfi_private *cfi = map->fldrv_priv;
1765 oldd = map_read(map, adr);
1766 if (map_word_equal(map, oldd, datum)) {
1771 XIP_INVAL_CACHED_RANGE(map, adr, map_bankwidth(map));
1772 ENABLE_VPP(map);
1773 xip_disable(map, chip, adr);
1776 ret = do_write_oneword_once(map, chip, adr, datum, mode, cfi);
1779 map_write(map, CMD(0xF0), chip->start);
1787 xip_enable(map, chip, adr);
1792 static int __xipram do_write_oneword(struct map_info *map, struct flchip *chip,
1803 ret = do_write_oneword_start(map, chip, adr, mode);
1807 ret = do_write_oneword_retry(map, chip, adr, datum, mode);
1809 do_write_oneword_done(map, chip, adr, mode);
1818 struct map_info *map = mtd->priv;
1819 struct cfi_private *cfi = map->fldrv_priv;
1830 if (ofs & (map_bankwidth(map)-1)) {
1831 unsigned long bus_ofs = ofs & ~(map_bankwidth(map)-1);
1851 tmp_buf = map_read(map, bus_ofs+chipstart);
1856 n = min_t(int, len, map_bankwidth(map)-i);
1858 tmp_buf = map_word_load_partial(map, tmp_buf, buf, i, n);
1860 ret = do_write_oneword(map, &cfi->chips[chipnum],
1879 while(len >= map_bankwidth(map)) {
1882 datum = map_word_load(map, buf);
1884 ret = do_write_oneword(map, &cfi->chips[chipnum],
1889 ofs += map_bankwidth(map);
1890 buf += map_bankwidth(map);
1891 (*retlen) += map_bankwidth(map);
1892 len -= map_bankwidth(map);
1904 if (len & (map_bankwidth(map)-1)) {
1921 tmp_buf = map_read(map, ofs + chipstart);
1925 tmp_buf = map_word_load_partial(map, tmp_buf, buf, 0, len);
1927 ret = do_write_oneword(map, &cfi->chips[chipnum],
1939 static int __xipram do_write_buffer_wait(struct map_info *map,
1974 !chip_good(map, chip, adr, &datum)) {
1981 if (chip_good(map, chip, adr, &datum)) {
1982 if (cfi_check_err_status(map, chip, adr))
1988 UDELAY(map, chip, adr, 1);
1994 static void __xipram do_write_buffer_reset(struct map_info *map,
2006 cfi_send_gen_cmd(0xAA, cfi->addr_unlock1, chip->start, map, cfi,
2008 cfi_send_gen_cmd(0x55, cfi->addr_unlock2, chip->start, map, cfi,
2010 cfi_send_gen_cmd(0xF0, cfi->addr_unlock1, chip->start, map, cfi,
2019 static int __xipram do_write_buffer(struct map_info *map, struct flchip *chip,
2023 struct cfi_private *cfi = map->fldrv_priv;
2033 ret = get_chip(map, chip, adr, FL_WRITING);
2039 datum = map_word_load(map, buf);
2044 XIP_INVAL_CACHED_RANGE(map, adr, len);
2045 ENABLE_VPP(map);
2046 xip_disable(map, chip, cmd_adr);
2048 cfi_send_gen_cmd(0xAA, cfi->addr_unlock1, chip->start, map, cfi, cfi->device_type, NULL);
2049 cfi_send_gen_cmd(0x55, cfi->addr_unlock2, chip->start, map, cfi, cfi->device_type, NULL);
2052 map_write(map, CMD(0x25), cmd_adr);
2057 words = len / map_bankwidth(map);
2058 map_write(map, CMD(words - 1), cmd_adr);
2061 while(z < words * map_bankwidth(map)) {
2062 datum = map_word_load(map, buf);
2063 map_write(map, datum, adr + z);
2065 z += map_bankwidth(map);
2066 buf += map_bankwidth(map);
2068 z -= map_bankwidth(map);
2073 map_write(map, CMD(0x29), cmd_adr);
2076 INVALIDATE_CACHE_UDELAY(map, chip,
2077 adr, map_bankwidth(map),
2080 ret = do_write_buffer_wait(map, chip, adr, datum);
2082 do_write_buffer_reset(map, chip, cfi);
2084 xip_enable(map, chip, adr);
2087 DISABLE_VPP(map);
2088 put_chip(map, chip, adr);
2098 struct map_info *map = mtd->priv;
2099 struct cfi_private *cfi = map->fldrv_priv;
2109 if (ofs & (map_bankwidth(map)-1)) {
2110 size_t local_len = (-ofs)&(map_bankwidth(map)-1);
2130 while (len >= map_bankwidth(map) * 2) {
2136 if (size % map_bankwidth(map))
2137 size -= size % map_bankwidth(map);
2139 ret = do_write_buffer(map, &cfi->chips[chipnum],
2179 static int cfi_amdstd_panic_wait(struct map_info *map, struct flchip *chip,
2182 struct cfi_private *cfi = map->fldrv_priv;
2190 if (chip->state == FL_READY && chip_ready(map, chip, adr, NULL))
2203 map_write(map, CMD(0xF0), chip->start);
2207 if (chip_ready(map, chip, adr, NULL))
2231 static int do_panic_write_oneword(struct map_info *map, struct flchip *chip,
2235 struct cfi_private *cfi = map->fldrv_priv;
2243 ret = cfi_amdstd_panic_wait(map, chip, adr);
2256 oldd = map_read(map, adr);
2257 if (map_word_equal(map, oldd, datum)) {
2262 ENABLE_VPP(map);
2265 cfi_send_gen_cmd(0xAA, cfi->addr_unlock1, chip->start, map, cfi, cfi->device_type, NULL);
2266 cfi_send_gen_cmd(0x55, cfi->addr_unlock2, chip->start, map, cfi, cfi->device_type, NULL);
2267 cfi_send_gen_cmd(0xA0, cfi->addr_unlock1, chip->start, map, cfi, cfi->device_type, NULL);
2268 map_write(map, datum, adr);
2271 if (chip_ready(map, chip, adr, NULL))
2277 if (!chip_ready(map, chip, adr, &datum) ||
2278 cfi_check_err_status(map, chip, adr)) {
2280 map_write(map, CMD(0xF0), chip->start);
2290 DISABLE_VPP(map);
2310 struct map_info *map = mtd->priv;
2311 struct cfi_private *cfi = map->fldrv_priv;
2321 if (ofs & (map_bankwidth(map) - 1)) {
2322 unsigned long bus_ofs = ofs & ~(map_bankwidth(map) - 1);
2327 ret = cfi_amdstd_panic_wait(map, &cfi->chips[chipnum], bus_ofs);
2332 tmp_buf = map_read(map, bus_ofs + chipstart);
2335 n = min_t(int, len, map_bankwidth(map) - i);
2337 tmp_buf = map_word_load_partial(map, tmp_buf, buf, i, n);
2339 ret = do_panic_write_oneword(map, &cfi->chips[chipnum],
2358 while (len >= map_bankwidth(map)) {
2361 datum = map_word_load(map, buf);
2363 ret = do_panic_write_oneword(map, &cfi->chips[chipnum],
2368 ofs += map_bankwidth(map);
2369 buf += map_bankwidth(map);
2370 (*retlen) += map_bankwidth(map);
2371 len -= map_bankwidth(map);
2384 if (len & (map_bankwidth(map) - 1)) {
2387 ret = cfi_amdstd_panic_wait(map, &cfi->chips[chipnum], ofs);
2391 tmp_buf = map_read(map, ofs + chipstart);
2393 tmp_buf = map_word_load_partial(map, tmp_buf, buf, 0, len);
2395 ret = do_panic_write_oneword(map, &cfi->chips[chipnum],
2411 static int __xipram do_erase_chip(struct map_info *map, struct flchip *chip)
2413 struct cfi_private *cfi = map->fldrv_priv;
2419 map_word datum = map_word_ff(map);
2424 ret = get_chip(map, chip, adr, FL_ERASING);
2433 XIP_INVAL_CACHED_RANGE(map, adr, map->size);
2434 ENABLE_VPP(map);
2435 xip_disable(map, chip, adr);
2438 cfi_send_gen_cmd(0xAA, cfi->addr_unlock1, chip->start, map, cfi, cfi->device_type, NULL);
2439 cfi_send_gen_cmd(0x55, cfi->addr_unlock2, chip->start, map, cfi, cfi->device_type, NULL);
2440 cfi_send_gen_cmd(0x80, cfi->addr_unlock1, chip->start, map, cfi, cfi->device_type, NULL);
2441 cfi_send_gen_cmd(0xAA, cfi->addr_unlock1, chip->start, map, cfi, cfi->device_type, NULL);
2442 cfi_send_gen_cmd(0x55, cfi->addr_unlock2, chip->start, map, cfi, cfi->device_type, NULL);
2443 cfi_send_gen_cmd(0x10, cfi->addr_unlock1, chip->start, map, cfi, cfi->device_type, NULL);
2448 chip->in_progress_block_mask = ~(map->size - 1);
2450 INVALIDATE_CACHE_UDELAY(map, chip,
2451 adr, map->size,
2474 if (chip_ready(map, chip, adr, &datum)) {
2475 if (cfi_check_err_status(map, chip, adr))
2488 UDELAY(map, chip, adr, 1000000/HZ);
2493 map_write(map, CMD(0xF0), chip->start);
2503 xip_enable(map, chip, adr);
2504 DISABLE_VPP(map);
2505 put_chip(map, chip, adr);
2512 static int __xipram do_erase_oneblock(struct map_info *map, struct flchip *chip, unsigned long adr, int len, void *thunk)
2514 struct cfi_private *cfi = map->fldrv_priv;
2519 map_word datum = map_word_ff(map);
2524 ret = get_chip(map, chip, adr, FL_ERASING);
2533 XIP_INVAL_CACHED_RANGE(map, adr, len);
2534 ENABLE_VPP(map);
2535 xip_disable(map, chip, adr);
2538 cfi_send_gen_cmd(0xAA, cfi->addr_unlock1, chip->start, map, cfi, cfi->device_type, NULL);
2539 cfi_send_gen_cmd(0x55, cfi->addr_unlock2, chip->start, map, cfi, cfi->device_type, NULL);
2540 cfi_send_gen_cmd(0x80, cfi->addr_unlock1, chip->start, map, cfi, cfi->device_type, NULL);
2541 cfi_send_gen_cmd(0xAA, cfi->addr_unlock1, chip->start, map, cfi, cfi->device_type, NULL);
2542 cfi_send_gen_cmd(0x55, cfi->addr_unlock2, chip->start, map, cfi, cfi->device_type, NULL);
2543 map_write(map, cfi->sector_erase_cmd, adr);
2550 INVALIDATE_CACHE_UDELAY(map, chip,
2574 if (chip_ready(map, chip, adr, &datum)) {
2575 if (cfi_check_err_status(map, chip, adr))
2588 UDELAY(map, chip, adr, 1000000/HZ);
2593 map_write(map, CMD(0xF0), chip->start);
2603 xip_enable(map, chip, adr);
2604 DISABLE_VPP(map);
2605 put_chip(map, chip, adr);
2620 struct map_info *map = mtd->priv;
2621 struct cfi_private *cfi = map->fldrv_priv;
2629 return do_erase_chip(map, &cfi->chips[0]);
2632 static int do_atmel_lock(struct map_info *map, struct flchip *chip,
2635 struct cfi_private *cfi = map->fldrv_priv;
2639 ret = get_chip(map, chip, adr + chip->start, FL_LOCKING);
2646 cfi_send_gen_cmd(0xAA, cfi->addr_unlock1, chip->start, map, cfi,
2648 cfi_send_gen_cmd(0x55, cfi->addr_unlock2, chip->start, map, cfi,
2650 cfi_send_gen_cmd(0x80, cfi->addr_unlock1, chip->start, map, cfi,
2652 cfi_send_gen_cmd(0xAA, cfi->addr_unlock1, chip->start, map, cfi,
2654 cfi_send_gen_cmd(0x55, cfi->addr_unlock2, chip->start, map, cfi,
2656 map_write(map, CMD(0x40), chip->start + adr);
2659 put_chip(map, chip, adr + chip->start);
2667 static int do_atmel_unlock(struct map_info *map, struct flchip *chip,
2670 struct cfi_private *cfi = map->fldrv_priv;
2674 ret = get_chip(map, chip, adr + chip->start, FL_UNLOCKING);
2681 cfi_send_gen_cmd(0xAA, cfi->addr_unlock1, chip->start, map, cfi,
2683 map_write(map, CMD(0x70), adr);
2686 put_chip(map, chip, adr + chip->start);
2718 static int __maybe_unused do_ppb_xxlock(struct map_info *map,
2722 struct cfi_private *cfi = map->fldrv_priv;
2728 ret = get_chip(map, chip, adr, FL_LOCKING);
2736 cfi_send_gen_cmd(0xAA, cfi->addr_unlock1, chip->start, map, cfi,
2738 cfi_send_gen_cmd(0x55, cfi->addr_unlock2, chip->start, map, cfi,
2741 cfi_send_gen_cmd(0xC0, cfi->addr_unlock1, chip->start, map, cfi,
2746 map_write(map, CMD(0xA0), adr);
2747 map_write(map, CMD(0x00), adr);
2754 map_write(map, CMD(0x80), chip->start);
2755 map_write(map, CMD(0x30), chip->start);
2759 ret = !cfi_read_query(map, adr);
2768 if (chip_ready(map, chip, adr, NULL))
2777 UDELAY(map, chip, adr, 1);
2781 map_write(map, CMD(0x90), chip->start);
2782 map_write(map, CMD(0x00), chip->start);
2785 put_chip(map, chip, adr);
2802 struct map_info *map = mtd->priv;
2803 struct cfi_private *cfi = map->fldrv_priv;
2851 map, &cfi->chips[chipnum], adr, 0,
2895 do_ppb_xxlock(map, sect[i].chip, sect[i].adr, 0,
2912 struct map_info *map = mtd->priv;
2913 struct cfi_private *cfi = map->fldrv_priv;
2974 struct map_info *map = mtd->priv;
2975 struct cfi_private *cfi = map->fldrv_priv;
3029 struct map_info *map = mtd->priv;
3030 struct cfi_private *cfi = map->fldrv_priv;
3042 map_write(map, CMD(0xF0), chip->start);
3061 struct map_info *map = mtd->priv;
3062 struct cfi_private *cfi = map->fldrv_priv;
3072 ret = get_chip(map, chip, chip->start, FL_SHUTDOWN);
3074 map_write(map, CMD(0xF0), chip->start);
3076 put_chip(map, chip, chip->start);
3099 struct map_info *map = mtd->priv;
3100 struct cfi_private *cfi = map->fldrv_priv;