33 #include <linux/mtd/map.h>
114 struct mtd_info *cfi_cmdset_0020(struct map_info *map, int primary)
116 	struct cfi_private *cfi = map->fldrv_priv;
128 		extp = (struct cfi_pri_intelext*)cfi_read_pri(map, adr, sizeof(*extp), "ST Microelectronics");
142 		extp->FeatureSupport = cfi32_to_cpu(map, extp->FeatureSupport);
143 		extp->BlkStatusRegMask = cfi32_to_cpu(map,
163 	return cfi_staa_setup(map);
167 static struct mtd_info *cfi_staa_setup(struct map_info *map)
169 	struct cfi_private *cfi = map->fldrv_priv;
183 	mtd->priv = map;
242 	map->fldrv = &cfi_staa_chipdrv;
244 	mtd->name = map->name;
249 static inline int do_read_onechip(struct map_info *map, struct flchip *chip, loff_t adr, size_t len, u_char *buf)
256 	struct cfi_private *cfi = map->fldrv_priv;
261 	cmd_addr = adr & ~(map_bankwidth(map)-1);
278 		map_write (map, CMD(0xb0), cmd_addr);
284 		map_write(map, CMD(0x70), cmd_addr);
289 			status = map_read(map, cmd_addr);
290 			if (map_word_andequal(map, status, status_OK, status_OK))
295 				map_write(map, CMD(0xd0), cmd_addr);
297 				map_write(map, CMD(0x70), cmd_addr);
312 		map_write(map, CMD(0xff), cmd_addr);
326 		map_write(map, CMD(0x70), cmd_addr);
330 		status = map_read(map, cmd_addr);
331 		if (map_word_andequal(map, status, status_OK, status_OK)) {
332 			map_write(map, CMD(0xff), cmd_addr);
362 	map_copy_from(map, buf, adr, len);
375 		map_write(map, CMD(0xd0), cmd_addr);
376 		map_write(map, CMD(0x70), cmd_addr);
386 	struct map_info *map = mtd->priv;
387 	struct cfi_private *cfi = map->fldrv_priv;
407 		ret = do_read_onechip(map, &cfi->chips[chipnum], ofs, thislen, buf);
421 static int do_write_buffer(struct map_info *map, struct flchip *chip,
424 	struct cfi_private *cfi = map->fldrv_priv;
431         if (adr & (map_bankwidth(map)-1))
460 		map_write(map, CMD(0x70), cmd_adr);
463 	printk("%s: 1 status[%x]\n", __func__, map_read(map, cmd_adr));
467 		status = map_read(map, cmd_adr);
468 		if (map_word_andequal(map, status, status_OK, status_OK))
474                                status.x[0], map_read(map, cmd_adr).x[0]);
495 	ENABLE_VPP(map);
496 	map_write(map, CMD(0xe8), cmd_adr);
501 		status = map_read(map, cmd_adr);
502 		if (map_word_andequal(map, status, status_OK, status_OK))
511 			DISABLE_VPP(map);
512                         map_write(map, CMD(0x70), cmd_adr);
521 	map_write(map, CMD(len/map_bankwidth(map)-1), cmd_adr );
525 	     z += map_bankwidth(map), buf += map_bankwidth(map)) {
527 		d = map_word_load(map, buf);
528 		map_write(map, d, adr+z);
531 	map_write(map, CMD(0xd0), cmd_adr);
553 		status = map_read(map, cmd_adr);
554 		if (map_word_andequal(map, status, status_OK, status_OK))
560                         map_write(map, CMD(0x50), cmd_adr);
562                         map_write(map, CMD(0x70), adr);
564 			DISABLE_VPP(map);
585 	DISABLE_VPP(map);
589         if (map_word_bitsset(map, status, CMD(0x3a))) {
594 		map_write(map, CMD(0x50), cmd_adr);
596 		map_write(map, CMD(0x70), adr);
599 		return map_word_bitsset(map, status, CMD(0x02)) ? -EROFS : -EIO;
610 	struct map_info *map = mtd->priv;
611 	struct cfi_private *cfi = map->fldrv_priv;
621 	printk("%s: map_bankwidth(map)[%x]\n", __func__, map_bankwidth(map));
634                 ret = do_write_buffer(map, &cfi->chips[chipnum],
733 static inline int do_erase_oneblock(struct map_info *map, struct flchip *chip, unsigned long adr)
735 	struct cfi_private *cfi = map->fldrv_priv;
756 		map_write(map, CMD(0x70), adr);
760 		status = map_read(map, adr);
761 		if (map_word_andequal(map, status, status_OK, status_OK))
788 	ENABLE_VPP(map);
790 	map_write(map, CMD(0x50), adr);
793 	map_write(map, CMD(0x20), adr);
794 	map_write(map, CMD(0xD0), adr);
818 		status = map_read(map, adr);
819 		if (map_word_andequal(map, status, status_OK, status_OK))
824 			map_write(map, CMD(0x70), adr);
826 			printk(KERN_ERR "waiting for erase to complete timed out. Xstatus = %lx, status = %lx.\n", status.x[0], map_read(map, adr).x[0]);
827 			DISABLE_VPP(map);
838 	DISABLE_VPP(map);
842 	map_write(map, CMD(0x70), adr);
844 	status = map_read(map, adr);
847 	if (map_word_bitsset(map, status, CMD(0x3a))) {
849 		if (!map_word_equal(map, status, CMD(chipstatus))) {
851 			for (w=0; w<map_words(map); w++) {
860 		map_write(map, CMD(0x50), adr);
861 		map_write(map, CMD(0x70), adr);
893 {	struct map_info *map = mtd->priv;
894 	struct cfi_private *cfi = map->fldrv_priv;
950 		ret = do_erase_oneblock(map, &cfi->chips[chipnum], adr);
975 	struct map_info *map = mtd->priv;
976 	struct cfi_private *cfi = map->fldrv_priv;
1032 static inline int do_lock_oneblock(struct map_info *map, struct flchip *chip, unsigned long adr)
1034 	struct cfi_private *cfi = map->fldrv_priv;
1053 		map_write(map, CMD(0x70), adr);
1057 		status = map_read(map, adr);
1058 		if (map_word_andequal(map, status, status_OK, status_OK))
1085 	ENABLE_VPP(map);
1086 	map_write(map, CMD(0x60), adr);
1087 	map_write(map, CMD(0x01), adr);
1100 		status = map_read(map, adr);
1101 		if (map_word_andequal(map, status, status_OK, status_OK))
1106 			map_write(map, CMD(0x70), adr);
1108 			printk(KERN_ERR "waiting for lock to complete timed out. Xstatus = %lx, status = %lx.\n", status.x[0], map_read(map, adr).x[0]);
1109 			DISABLE_VPP(map);
1122 	DISABLE_VPP(map);
1129 	struct map_info *map = mtd->priv;
1130 	struct cfi_private *cfi = map->fldrv_priv;
1149 		cfi_send_gen_cmd(0x90, 0x55, 0, map, cfi, cfi->device_type, NULL);
1150 		printk("before lock: block status register is %x\n",cfi_read_query(map, adr+(2*ofs_factor)));
1151 		cfi_send_gen_cmd(0xff, 0x55, 0, map, cfi, cfi->device_type, NULL);
1154 		ret = do_lock_oneblock(map, &cfi->chips[chipnum], adr);
1157 		cfi_send_gen_cmd(0x90, 0x55, 0, map, cfi, cfi->device_type, NULL);
1158 		printk("after lock: block status register is %x\n",cfi_read_query(map, adr+(2*ofs_factor)));
1159 		cfi_send_gen_cmd(0xff, 0x55, 0, map, cfi, cfi->device_type, NULL);
1178 static inline int do_unlock_oneblock(struct map_info *map, struct flchip *chip, unsigned long adr)
1180 	struct cfi_private *cfi = map->fldrv_priv;
1199 		map_write(map, CMD(0x70), adr);
1203 		status = map_read(map, adr);
1204 		if (map_word_andequal(map, status, status_OK, status_OK))
1231 	ENABLE_VPP(map);
1232 	map_write(map, CMD(0x60), adr);
1233 	map_write(map, CMD(0xD0), adr);
1246 		status = map_read(map, adr);
1247 		if (map_word_andequal(map, status, status_OK, status_OK))
1252 			map_write(map, CMD(0x70), adr);
1254 			printk(KERN_ERR "waiting for unlock to complete timed out. Xstatus = %lx, status = %lx.\n", status.x[0], map_read(map, adr).x[0]);
1255 			DISABLE_VPP(map);
1268 	DISABLE_VPP(map);
1275 	struct map_info *map = mtd->priv;
1276 	struct cfi_private *cfi = map->fldrv_priv;
1291 		cfi_send_gen_cmd(0x90, 0x55, 0, map, cfi, cfi->device_type, NULL);
1293 			printk("before unlock %x: block status register is %x\n",temp_adr,cfi_read_query(map, temp_adr+(2*ofs_factor)));
1297 		cfi_send_gen_cmd(0xff, 0x55, 0, map, cfi, cfi->device_type, NULL);
1301 	ret = do_unlock_oneblock(map, &cfi->chips[chipnum], adr);
1304 	cfi_send_gen_cmd(0x90, 0x55, 0, map, cfi, cfi->device_type, NULL);
1305 	printk("after unlock: block status register is %x\n",cfi_read_query(map, adr+(2*ofs_factor)));
1306 	cfi_send_gen_cmd(0xff, 0x55, 0, map, cfi, cfi->device_type, NULL);
1314 	struct map_info *map = mtd->priv;
1315 	struct cfi_private *cfi = map->fldrv_priv;
1372 	struct map_info *map = mtd->priv;
1373 	struct cfi_private *cfi = map->fldrv_priv;
1385 			map_write(map, CMD(0xFF), 0);
1396 	struct map_info *map = mtd->priv;
1397 	struct cfi_private *cfi = map->fldrv_priv;

Indexes created Fri May 10 11:38:11 MDT 2024