1 /*
2  * Common Flash Interface support:
3  *   Intel Extended Vendor Command Set (ID 0x0001)
4  *
5  * (C) 2000 Red Hat. GPL'd
6  *
7  *
8  * 10/10/2000	Nicolas Pitre <nico@fluxnic.net>
9  * 	- completely revamped method functions so they are aware and
10  * 	  independent of the flash geometry (buswidth, interleave, etc.)
11  * 	- scalability vs code size is completely set at compile-time
12  * 	  (see include/linux/mtd/cfi.h for selection)
13  *	- optimized write buffer method
14  * 02/05/2002	Christopher Hoover <ch@hpl.hp.com>/<ch@murgatroid.com>
15  *	- reworked lock/unlock/erase support for var size flash
16  * 21/03/2007   Rodolfo Giometti <giometti@linux.it>
17  * 	- auto unlock sectors on resume for auto locking flash on power up
18  */
19 
20 #include <linux/module.h>
21 #include <linux/types.h>
22 #include <linux/kernel.h>
23 #include <linux/sched.h>
24 #include <asm/io.h>
25 #include <asm/byteorder.h>
26 
27 #include <linux/errno.h>
28 #include <linux/slab.h>
29 #include <linux/delay.h>
30 #include <linux/interrupt.h>
31 #include <linux/reboot.h>
32 #include <linux/bitmap.h>
33 #include <linux/mtd/xip.h>
34 #include <linux/mtd/map.h>
35 #include <linux/mtd/mtd.h>
36 #include <linux/mtd/cfi.h>
37 
38 /* #define CMDSET0001_DISABLE_ERASE_SUSPEND_ON_WRITE */
39 /* #define CMDSET0001_DISABLE_WRITE_SUSPEND */
40 
41 // debugging, turns off buffer write mode if set to 1
42 #define FORCE_WORD_WRITE 0
43 
44 /* Intel chips */
45 #define I82802AB	0x00ad
46 #define I82802AC	0x00ac
47 #define PF38F4476	0x881c
48 #define M28F00AP30	0x8963
49 /* STMicroelectronics chips */
50 #define M50LPW080       0x002F
51 #define M50FLW080A	0x0080
52 #define M50FLW080B	0x0081
53 /* Atmel chips */
54 #define AT49BV640D	0x02de
55 #define AT49BV640DT	0x02db
56 /* Sharp chips */
57 #define LH28F640BFHE_PTTL90	0x00b0
58 #define LH28F640BFHE_PBTL90	0x00b1
59 #define LH28F640BFHE_PTTL70A	0x00b2
60 #define LH28F640BFHE_PBTL70A	0x00b3
61 
62 static int cfi_intelext_read (struct mtd_info *, loff_t, size_t, size_t *, u_char *);
63 static int cfi_intelext_write_words(struct mtd_info *, loff_t, size_t, size_t *, const u_char *);
64 static int cfi_intelext_write_buffers(struct mtd_info *, loff_t, size_t, size_t *, const u_char *);
65 static int cfi_intelext_writev(struct mtd_info *, const struct kvec *, unsigned long, loff_t, size_t *);
66 static int cfi_intelext_erase_varsize(struct mtd_info *, struct erase_info *);
67 static void cfi_intelext_sync (struct mtd_info *);
68 static int cfi_intelext_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len);
69 static int cfi_intelext_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len);
70 static int cfi_intelext_is_locked(struct mtd_info *mtd, loff_t ofs,
71 				  uint64_t len);
72 #ifdef CONFIG_MTD_OTP
73 static int cfi_intelext_read_fact_prot_reg (struct mtd_info *, loff_t, size_t, size_t *, u_char *);
74 static int cfi_intelext_read_user_prot_reg (struct mtd_info *, loff_t, size_t, size_t *, u_char *);
75 static int cfi_intelext_write_user_prot_reg (struct mtd_info *, loff_t, size_t, size_t *, u_char *);
76 static int cfi_intelext_lock_user_prot_reg (struct mtd_info *, loff_t, size_t);
77 static int cfi_intelext_get_fact_prot_info(struct mtd_info *, size_t,
78 					   size_t *, struct otp_info *);
79 static int cfi_intelext_get_user_prot_info(struct mtd_info *, size_t,
80 					   size_t *, struct otp_info *);
81 #endif
82 static int cfi_intelext_suspend (struct mtd_info *);
83 static void cfi_intelext_resume (struct mtd_info *);
84 static int cfi_intelext_reboot (struct notifier_block *, unsigned long, void *);
85 
86 static void cfi_intelext_destroy(struct mtd_info *);
87 
88 struct mtd_info *cfi_cmdset_0001(struct map_info *, int);
89 
90 static struct mtd_info *cfi_intelext_setup (struct mtd_info *);
91 static int cfi_intelext_partition_fixup(struct mtd_info *, struct cfi_private **);
92 
93 static int cfi_intelext_point (struct mtd_info *mtd, loff_t from, size_t len,
94 		     size_t *retlen, void **virt, resource_size_t *phys);
95 static int cfi_intelext_unpoint(struct mtd_info *mtd, loff_t from, size_t len);
96 
97 static int chip_ready (struct map_info *map, struct flchip *chip, unsigned long adr, int mode);
98 static int get_chip(struct map_info *map, struct flchip *chip, unsigned long adr, int mode);
99 static void put_chip(struct map_info *map, struct flchip *chip, unsigned long adr);
100 #include "fwh_lock.h"
101 
102 
103 
104 /*
105  *  *********** SETUP AND PROBE BITS  ***********
106  */
107 
108 static struct mtd_chip_driver cfi_intelext_chipdrv = {
109 	.probe		= NULL, /* Not usable directly */
110 	.destroy	= cfi_intelext_destroy,
111 	.name		= "cfi_cmdset_0001",
112 	.module		= THIS_MODULE
113 };
114 
115 /* #define DEBUG_LOCK_BITS */
116 /* #define DEBUG_CFI_FEATURES */
117 
118 #ifdef DEBUG_CFI_FEATURES
119 static void cfi_tell_features(struct cfi_pri_intelext *extp)
120 {
121 	int i;
122 	printk("  Extended Query version %c.%c\n", extp->MajorVersion, extp->MinorVersion);
123 	printk("  Feature/Command Support:      %4.4X\n", extp->FeatureSupport);
124 	printk("     - Chip Erase:              %s\n", extp->FeatureSupport&1?"supported":"unsupported");
125 	printk("     - Suspend Erase:           %s\n", extp->FeatureSupport&2?"supported":"unsupported");
126 	printk("     - Suspend Program:         %s\n", extp->FeatureSupport&4?"supported":"unsupported");
127 	printk("     - Legacy Lock/Unlock:      %s\n", extp->FeatureSupport&8?"supported":"unsupported");
128 	printk("     - Queued Erase:            %s\n", extp->FeatureSupport&16?"supported":"unsupported");
129 	printk("     - Instant block lock:      %s\n", extp->FeatureSupport&32?"supported":"unsupported");
130 	printk("     - Protection Bits:         %s\n", extp->FeatureSupport&64?"supported":"unsupported");
131 	printk("     - Page-mode read:          %s\n", extp->FeatureSupport&128?"supported":"unsupported");
132 	printk("     - Synchronous read:        %s\n", extp->FeatureSupport&256?"supported":"unsupported");
133 	printk("     - Simultaneous operations: %s\n", extp->FeatureSupport&512?"supported":"unsupported");
134 	printk("     - Extended Flash Array:    %s\n", extp->FeatureSupport&1024?"supported":"unsupported");
135 	for (i=11; i<32; i++) {
136 		if (extp->FeatureSupport & (1<<i))
137 			printk("     - Unknown Bit %X:      supported\n", i);
138 	}
139 
140 	printk("  Supported functions after Suspend: %2.2X\n", extp->SuspendCmdSupport);
141 	printk("     - Program after Erase Suspend: %s\n", extp->SuspendCmdSupport&1?"supported":"unsupported");
142 	for (i=1; i<8; i++) {
143 		if (extp->SuspendCmdSupport & (1<<i))
144 			printk("     - Unknown Bit %X:               supported\n", i);
145 	}
146 
147 	printk("  Block Status Register Mask: %4.4X\n", extp->BlkStatusRegMask);
148 	printk("     - Lock Bit Active:      %s\n", extp->BlkStatusRegMask&1?"yes":"no");
149 	printk("     - Lock-Down Bit Active: %s\n", extp->BlkStatusRegMask&2?"yes":"no");
150 	for (i=2; i<3; i++) {
151 		if (extp->BlkStatusRegMask & (1<<i))
152 			printk("     - Unknown Bit %X Active: yes\n",i);
153 	}
154 	printk("     - EFA Lock Bit:         %s\n", extp->BlkStatusRegMask&16?"yes":"no");
155 	printk("     - EFA Lock-Down Bit:    %s\n", extp->BlkStatusRegMask&32?"yes":"no");
156 	for (i=6; i<16; i++) {
157 		if (extp->BlkStatusRegMask & (1<<i))
158 			printk("     - Unknown Bit %X Active: yes\n",i);
159 	}
160 
161 	printk("  Vcc Logic Supply Optimum Program/Erase Voltage: %d.%d V\n",
162 	       extp->VccOptimal >> 4, extp->VccOptimal & 0xf);
163 	if (extp->VppOptimal)
164 		printk("  Vpp Programming Supply Optimum Program/Erase Voltage: %d.%d V\n",
165 		       extp->VppOptimal >> 4, extp->VppOptimal & 0xf);
166 }
167 #endif
168 
169 /* Atmel chips don't use the same PRI format as Intel chips */
170 static void fixup_convert_atmel_pri(struct mtd_info *mtd)
171 {
172 	struct map_info *map = mtd->priv;
173 	struct cfi_private *cfi = map->fldrv_priv;
174 	struct cfi_pri_intelext *extp = cfi->cmdset_priv;
175 	struct cfi_pri_atmel atmel_pri;
176 	uint32_t features = 0;
177 
178 	/* Reverse byteswapping */
179 	extp->FeatureSupport = cpu_to_le32(extp->FeatureSupport);
180 	extp->BlkStatusRegMask = cpu_to_le16(extp->BlkStatusRegMask);
181 	extp->ProtRegAddr = cpu_to_le16(extp->ProtRegAddr);
182 
183 	memcpy(&atmel_pri, extp, sizeof(atmel_pri));
184 	memset((char *)extp + 5, 0, sizeof(*extp) - 5);
185 
186 	printk(KERN_ERR "atmel Features: %02x\n", atmel_pri.Features);
187 
188 	if (atmel_pri.Features & 0x01) /* chip erase supported */
189 		features |= (1<<0);
190 	if (atmel_pri.Features & 0x02) /* erase suspend supported */
191 		features |= (1<<1);
192 	if (atmel_pri.Features & 0x04) /* program suspend supported */
193 		features |= (1<<2);
194 	if (atmel_pri.Features & 0x08) /* simultaneous operations supported */
195 		features |= (1<<9);
196 	if (atmel_pri.Features & 0x20) /* page mode read supported */
197 		features |= (1<<7);
198 	if (atmel_pri.Features & 0x40) /* queued erase supported */
199 		features |= (1<<4);
200 	if (atmel_pri.Features & 0x80) /* Protection bits supported */
201 		features |= (1<<6);
202 
203 	extp->FeatureSupport = features;
204 
205 	/* burst write mode not supported */
206 	cfi->cfiq->BufWriteTimeoutTyp = 0;
207 	cfi->cfiq->BufWriteTimeoutMax = 0;
208 }
209 
210 static void fixup_at49bv640dx_lock(struct mtd_info *mtd)
211 {
212 	struct map_info *map = mtd->priv;
213 	struct cfi_private *cfi = map->fldrv_priv;
214 	struct cfi_pri_intelext *cfip = cfi->cmdset_priv;
215 
216 	cfip->FeatureSupport |= (1 << 5);
217 	mtd->flags |= MTD_POWERUP_LOCK;
218 }
219 
220 #ifdef CMDSET0001_DISABLE_ERASE_SUSPEND_ON_WRITE
221 /* Some Intel Strata Flash prior to FPO revision C has bugs in this area */
222 static void fixup_intel_strataflash(struct mtd_info *mtd)
223 {
224 	struct map_info *map = mtd->priv;
225 	struct cfi_private *cfi = map->fldrv_priv;
226 	struct cfi_pri_intelext *extp = cfi->cmdset_priv;
227 
228 	printk(KERN_WARNING "cfi_cmdset_0001: Suspend "
229 	                    "erase on write disabled.\n");
230 	extp->SuspendCmdSupport &= ~1;
231 }
232 #endif
233 
234 #ifdef CMDSET0001_DISABLE_WRITE_SUSPEND
235 static void fixup_no_write_suspend(struct mtd_info *mtd)
236 {
237 	struct map_info *map = mtd->priv;
238 	struct cfi_private *cfi = map->fldrv_priv;
239 	struct cfi_pri_intelext *cfip = cfi->cmdset_priv;
240 
241 	if (cfip && (cfip->FeatureSupport&4)) {
242 		cfip->FeatureSupport &= ~4;
243 		printk(KERN_WARNING "cfi_cmdset_0001: write suspend disabled\n");
244 	}
245 }
246 #endif
247 
248 static void fixup_st_m28w320ct(struct mtd_info *mtd)
249 {
250 	struct map_info *map = mtd->priv;
251 	struct cfi_private *cfi = map->fldrv_priv;
252 
253 	cfi->cfiq->BufWriteTimeoutTyp = 0;	/* Not supported */
254 	cfi->cfiq->BufWriteTimeoutMax = 0;	/* Not supported */
255 }
256 
257 static void fixup_st_m28w320cb(struct mtd_info *mtd)
258 {
259 	struct map_info *map = mtd->priv;
260 	struct cfi_private *cfi = map->fldrv_priv;
261 
262 	/* Note this is done after the region info is endian swapped */
263 	cfi->cfiq->EraseRegionInfo[1] =
264 		(cfi->cfiq->EraseRegionInfo[1] & 0xffff0000) | 0x3e;
265 };
266 
267 static int is_LH28F640BF(struct cfi_private *cfi)
268 {
269 	/* Sharp LH28F640BF Family */
270 	if (cfi->mfr == CFI_MFR_SHARP && (
271 	    cfi->id == LH28F640BFHE_PTTL90 || cfi->id == LH28F640BFHE_PBTL90 ||
272 	    cfi->id == LH28F640BFHE_PTTL70A || cfi->id == LH28F640BFHE_PBTL70A))
273 		return 1;
274 	return 0;
275 }
276 
277 static void fixup_LH28F640BF(struct mtd_info *mtd)
278 {
279 	struct map_info *map = mtd->priv;
280 	struct cfi_private *cfi = map->fldrv_priv;
281 	struct cfi_pri_intelext *extp = cfi->cmdset_priv;
282 
283 	/* Reset the Partition Configuration Register on LH28F640BF
284 	 * to a single partition (PCR = 0x000): PCR is embedded into A0-A15. */
285 	if (is_LH28F640BF(cfi)) {
286 		printk(KERN_INFO "Reset Partition Config. Register: 1 Partition of 4 planes\n");
287 		map_write(map, CMD(0x60), 0);
288 		map_write(map, CMD(0x04), 0);
289 
290 		/* We have set one single partition thus
291 		 * Simultaneous Operations are not allowed */
292 		printk(KERN_INFO "cfi_cmdset_0001: Simultaneous Operations disabled\n");
293 		extp->FeatureSupport &= ~512;
294 	}
295 }
296 
297 static void fixup_use_point(struct mtd_info *mtd)
298 {
299 	struct map_info *map = mtd->priv;
300 	if (!mtd->_point && map_is_linear(map)) {
301 		mtd->_point   = cfi_intelext_point;
302 		mtd->_unpoint = cfi_intelext_unpoint;
303 	}
304 }
305 
306 static void fixup_use_write_buffers(struct mtd_info *mtd)
307 {
308 	struct map_info *map = mtd->priv;
309 	struct cfi_private *cfi = map->fldrv_priv;
310 	if (cfi->cfiq->BufWriteTimeoutTyp) {
311 		printk(KERN_INFO "Using buffer write method\n" );
312 		mtd->_write = cfi_intelext_write_buffers;
313 		mtd->_writev = cfi_intelext_writev;
314 	}
315 }
316 
317 /*
318  * Some chips power-up with all sectors locked by default.
319  */
320 static void fixup_unlock_powerup_lock(struct mtd_info *mtd)
321 {
322 	struct map_info *map = mtd->priv;
323 	struct cfi_private *cfi = map->fldrv_priv;
324 	struct cfi_pri_intelext *cfip = cfi->cmdset_priv;
325 
326 	if (cfip->FeatureSupport&32) {
327 		printk(KERN_INFO "Using auto-unlock on power-up/resume\n" );
328 		mtd->flags |= MTD_POWERUP_LOCK;
329 	}
330 }
331 
332 static struct cfi_fixup cfi_fixup_table[] = {
333 	{ CFI_MFR_ATMEL, CFI_ID_ANY, fixup_convert_atmel_pri },
334 	{ CFI_MFR_ATMEL, AT49BV640D, fixup_at49bv640dx_lock },
335 	{ CFI_MFR_ATMEL, AT49BV640DT, fixup_at49bv640dx_lock },
336 #ifdef CMDSET0001_DISABLE_ERASE_SUSPEND_ON_WRITE
337 	{ CFI_MFR_ANY, CFI_ID_ANY, fixup_intel_strataflash },
338 #endif
339 #ifdef CMDSET0001_DISABLE_WRITE_SUSPEND
340 	{ CFI_MFR_ANY, CFI_ID_ANY, fixup_no_write_suspend },
341 #endif
342 #if !FORCE_WORD_WRITE
343 	{ CFI_MFR_ANY, CFI_ID_ANY, fixup_use_write_buffers },
344 #endif
345 	{ CFI_MFR_ST, 0x00ba, /* M28W320CT */ fixup_st_m28w320ct },
346 	{ CFI_MFR_ST, 0x00bb, /* M28W320CB */ fixup_st_m28w320cb },
347 	{ CFI_MFR_INTEL, CFI_ID_ANY, fixup_unlock_powerup_lock },
348 	{ CFI_MFR_SHARP, CFI_ID_ANY, fixup_unlock_powerup_lock },
349 	{ CFI_MFR_SHARP, CFI_ID_ANY, fixup_LH28F640BF },
350 	{ 0, 0, NULL }
351 };
352 
353 static struct cfi_fixup jedec_fixup_table[] = {
354 	{ CFI_MFR_INTEL, I82802AB,   fixup_use_fwh_lock },
355 	{ CFI_MFR_INTEL, I82802AC,   fixup_use_fwh_lock },
356 	{ CFI_MFR_ST,    M50LPW080,  fixup_use_fwh_lock },
357 	{ CFI_MFR_ST,    M50FLW080A, fixup_use_fwh_lock },
358 	{ CFI_MFR_ST,    M50FLW080B, fixup_use_fwh_lock },
359 	{ 0, 0, NULL }
360 };
361 static struct cfi_fixup fixup_table[] = {
362 	/* The CFI vendor ids and the JEDEC vendor IDs appear
363 	 * to be common.  It is like the devices id's are as
364 	 * well.  This table is to pick all cases where
365 	 * we know that is the case.
366 	 */
367 	{ CFI_MFR_ANY, CFI_ID_ANY, fixup_use_point },
368 	{ 0, 0, NULL }
369 };
370 
371 static void cfi_fixup_major_minor(struct cfi_private *cfi,
372 						struct cfi_pri_intelext *extp)
373 {
374 	if (cfi->mfr == CFI_MFR_INTEL &&
375 			cfi->id == PF38F4476 && extp->MinorVersion == '3')
376 		extp->MinorVersion = '1';
377 }
378 
379 static int cfi_is_micron_28F00AP30(struct cfi_private *cfi, struct flchip *chip)
380 {
381 	/*
382 	 * Micron(was Numonyx) 1Gbit bottom boot are buggy w.r.t
383 	 * Erase Supend for their small Erase Blocks(0x8000)
384 	 */
385 	if (cfi->mfr == CFI_MFR_INTEL && cfi->id == M28F00AP30)
386 		return 1;
387 	return 0;
388 }
389 
390 static inline struct cfi_pri_intelext *
391 read_pri_intelext(struct map_info *map, __u16 adr)
392 {
393 	struct cfi_private *cfi = map->fldrv_priv;
394 	struct cfi_pri_intelext *extp;
395 	unsigned int extra_size = 0;
396 	unsigned int extp_size = sizeof(*extp);
397 
398  again:
399 	extp = (struct cfi_pri_intelext *)cfi_read_pri(map, adr, extp_size, "Intel/Sharp");
400 	if (!extp)
401 		return NULL;
402 
403 	cfi_fixup_major_minor(cfi, extp);
404 
405 	if (extp->MajorVersion != '1' ||
406 	    (extp->MinorVersion < '0' || extp->MinorVersion > '5')) {
407 		printk(KERN_ERR "  Unknown Intel/Sharp Extended Query "
408 		       "version %c.%c.\n",  extp->MajorVersion,
409 		       extp->MinorVersion);
410 		kfree(extp);
411 		return NULL;
412 	}
413 
414 	/* Do some byteswapping if necessary */
415 	extp->FeatureSupport = le32_to_cpu(extp->FeatureSupport);
416 	extp->BlkStatusRegMask = le16_to_cpu(extp->BlkStatusRegMask);
417 	extp->ProtRegAddr = le16_to_cpu(extp->ProtRegAddr);
418 
419 	if (extp->MinorVersion >= '0') {
420 		extra_size = 0;
421 
422 		/* Protection Register info */
423 		extra_size += (extp->NumProtectionFields - 1) *
424 			      sizeof(struct cfi_intelext_otpinfo);
425 	}
426 
427 	if (extp->MinorVersion >= '1') {
428 		/* Burst Read info */
429 		extra_size += 2;
430 		if (extp_size < sizeof(*extp) + extra_size)
431 			goto need_more;
432 		extra_size += extp->extra[extra_size - 1];
433 	}
434 
435 	if (extp->MinorVersion >= '3') {
436 		int nb_parts, i;
437 
438 		/* Number of hardware-partitions */
439 		extra_size += 1;
440 		if (extp_size < sizeof(*extp) + extra_size)
441 			goto need_more;
442 		nb_parts = extp->extra[extra_size - 1];
443 
444 		/* skip the sizeof(partregion) field in CFI 1.4 */
445 		if (extp->MinorVersion >= '4')
446 			extra_size += 2;
447 
448 		for (i = 0; i < nb_parts; i++) {
449 			struct cfi_intelext_regioninfo *rinfo;
450 			rinfo = (struct cfi_intelext_regioninfo *)&extp->extra[extra_size];
451 			extra_size += sizeof(*rinfo);
452 			if (extp_size < sizeof(*extp) + extra_size)
453 				goto need_more;
454 			rinfo->NumIdentPartitions=le16_to_cpu(rinfo->NumIdentPartitions);
455 			extra_size += (rinfo->NumBlockTypes - 1)
456 				      * sizeof(struct cfi_intelext_blockinfo);
457 		}
458 
459 		if (extp->MinorVersion >= '4')
460 			extra_size += sizeof(struct cfi_intelext_programming_regioninfo);
461 
462 		if (extp_size < sizeof(*extp) + extra_size) {
463 			need_more:
464 			extp_size = sizeof(*extp) + extra_size;
465 			kfree(extp);
466 			if (extp_size > 4096) {
467 				printk(KERN_ERR
468 					"%s: cfi_pri_intelext is too fat\n",
469 					__func__);
470 				return NULL;
471 			}
472 			goto again;
473 		}
474 	}
475 
476 	return extp;
477 }
478 
479 struct mtd_info *cfi_cmdset_0001(struct map_info *map, int primary)
480 {
481 	struct cfi_private *cfi = map->fldrv_priv;
482 	struct mtd_info *mtd;
483 	int i;
484 
485 	mtd = kzalloc(sizeof(*mtd), GFP_KERNEL);
486 	if (!mtd)
487 		return NULL;
488 	mtd->priv = map;
489 	mtd->type = MTD_NORFLASH;
490 
491 	/* Fill in the default mtd operations */
492 	mtd->_erase   = cfi_intelext_erase_varsize;
493 	mtd->_read    = cfi_intelext_read;
494 	mtd->_write   = cfi_intelext_write_words;
495 	mtd->_sync    = cfi_intelext_sync;
496 	mtd->_lock    = cfi_intelext_lock;
497 	mtd->_unlock  = cfi_intelext_unlock;
498 	mtd->_is_locked = cfi_intelext_is_locked;
499 	mtd->_suspend = cfi_intelext_suspend;
500 	mtd->_resume  = cfi_intelext_resume;
501 	mtd->flags   = MTD_CAP_NORFLASH;
502 	mtd->name    = map->name;
503 	mtd->writesize = 1;
504 	mtd->writebufsize = cfi_interleave(cfi) << cfi->cfiq->MaxBufWriteSize;
505 
506 	mtd->reboot_notifier.notifier_call = cfi_intelext_reboot;
507 
508 	if (cfi->cfi_mode == CFI_MODE_CFI) {
509 		/*
510 		 * It's a real CFI chip, not one for which the probe
511 		 * routine faked a CFI structure. So we read the feature
512 		 * table from it.
513 		 */
514 		__u16 adr = primary?cfi->cfiq->P_ADR:cfi->cfiq->A_ADR;
515 		struct cfi_pri_intelext *extp;
516 
517 		extp = read_pri_intelext(map, adr);
518 		if (!extp) {
519 			kfree(mtd);
520 			return NULL;
521 		}
522 
523 		/* Install our own private info structure */
524 		cfi->cmdset_priv = extp;
525 
526 		cfi_fixup(mtd, cfi_fixup_table);
527 
528 #ifdef DEBUG_CFI_FEATURES
529 		/* Tell the user about it in lots of lovely detail */
530 		cfi_tell_features(extp);
531 #endif
532 
533 		if(extp->SuspendCmdSupport & 1) {
534 			printk(KERN_NOTICE "cfi_cmdset_0001: Erase suspend on write enabled\n");
535 		}
536 	}
537 	else if (cfi->cfi_mode == CFI_MODE_JEDEC) {
538 		/* Apply jedec specific fixups */
539 		cfi_fixup(mtd, jedec_fixup_table);
540 	}
541 	/* Apply generic fixups */
542 	cfi_fixup(mtd, fixup_table);
543 
544 	for (i=0; i< cfi->numchips; i++) {
545 		if (cfi->cfiq->WordWriteTimeoutTyp)
546 			cfi->chips[i].word_write_time =
547 				1<<cfi->cfiq->WordWriteTimeoutTyp;
548 		else
549 			cfi->chips[i].word_write_time = 50000;
550 
551 		if (cfi->cfiq->BufWriteTimeoutTyp)
552 			cfi->chips[i].buffer_write_time =
553 				1<<cfi->cfiq->BufWriteTimeoutTyp;
554 		/* No default; if it isn't specified, we won't use it */
555 
556 		if (cfi->cfiq->BlockEraseTimeoutTyp)
557 			cfi->chips[i].erase_time =
558 				1000<<cfi->cfiq->BlockEraseTimeoutTyp;
559 		else
560 			cfi->chips[i].erase_time = 2000000;
561 
562 		if (cfi->cfiq->WordWriteTimeoutTyp &&
563 		    cfi->cfiq->WordWriteTimeoutMax)
564 			cfi->chips[i].word_write_time_max =
565 				1<<(cfi->cfiq->WordWriteTimeoutTyp +
566 				    cfi->cfiq->WordWriteTimeoutMax);
567 		else
568 			cfi->chips[i].word_write_time_max = 50000 * 8;
569 
570 		if (cfi->cfiq->BufWriteTimeoutTyp &&
571 		    cfi->cfiq->BufWriteTimeoutMax)
572 			cfi->chips[i].buffer_write_time_max =
573 				1<<(cfi->cfiq->BufWriteTimeoutTyp +
574 				    cfi->cfiq->BufWriteTimeoutMax);
575 
576 		if (cfi->cfiq->BlockEraseTimeoutTyp &&
577 		    cfi->cfiq->BlockEraseTimeoutMax)
578 			cfi->chips[i].erase_time_max =
579 				1000<<(cfi->cfiq->BlockEraseTimeoutTyp +
580 				       cfi->cfiq->BlockEraseTimeoutMax);
581 		else
582 			cfi->chips[i].erase_time_max = 2000000 * 8;
583 
584 		cfi->chips[i].ref_point_counter = 0;
585 		init_waitqueue_head(&(cfi->chips[i].wq));
586 	}
587 
588 	map->fldrv = &cfi_intelext_chipdrv;
589 
590 	return cfi_intelext_setup(mtd);
591 }
592 struct mtd_info *cfi_cmdset_0003(struct map_info *map, int primary) __attribute__((alias("cfi_cmdset_0001")));
593 struct mtd_info *cfi_cmdset_0200(struct map_info *map, int primary) __attribute__((alias("cfi_cmdset_0001")));
594 EXPORT_SYMBOL_GPL(cfi_cmdset_0001);
595 EXPORT_SYMBOL_GPL(cfi_cmdset_0003);
596 EXPORT_SYMBOL_GPL(cfi_cmdset_0200);
597 
598 static struct mtd_info *cfi_intelext_setup(struct mtd_info *mtd)
599 {
600 	struct map_info *map = mtd->priv;
601 	struct cfi_private *cfi = map->fldrv_priv;
602 	unsigned long offset = 0;
603 	int i,j;
604 	unsigned long devsize = (1<<cfi->cfiq->DevSize) * cfi->interleave;
605 
606 	//printk(KERN_DEBUG "number of CFI chips: %d\n", cfi->numchips);
607 
608 	mtd->size = devsize * cfi->numchips;
609 
610 	mtd->numeraseregions = cfi->cfiq->NumEraseRegions * cfi->numchips;
611 	mtd->eraseregions = kcalloc(mtd->numeraseregions,
612 				    sizeof(struct mtd_erase_region_info),
613 				    GFP_KERNEL);
614 	if (!mtd->eraseregions)
615 		goto setup_err;
616 
617 	for (i=0; i<cfi->cfiq->NumEraseRegions; i++) {
618 		unsigned long ernum, ersize;
619 		ersize = ((cfi->cfiq->EraseRegionInfo[i] >> 8) & ~0xff) * cfi->interleave;
620 		ernum = (cfi->cfiq->EraseRegionInfo[i] & 0xffff) + 1;
621 
622 		if (mtd->erasesize < ersize) {
623 			mtd->erasesize = ersize;
624 		}
625 		for (j=0; j<cfi->numchips; j++) {
626 			mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].offset = (j*devsize)+offset;
627 			mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].erasesize = ersize;
628 			mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].numblocks = ernum;
629 			mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].lockmap = kmalloc(ernum / 8 + 1, GFP_KERNEL);
630 			if (!mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].lockmap)
631 				goto setup_err;
632 		}
633 		offset += (ersize * ernum);
634 	}
635 
636 	if (offset != devsize) {
637 		/* Argh */
638 		printk(KERN_WARNING "Sum of regions (%lx) != total size of set of interleaved chips (%lx)\n", offset, devsize);
639 		goto setup_err;
640 	}
641 
642 	for (i=0; i<mtd->numeraseregions;i++){
643 		printk(KERN_DEBUG "erase region %d: offset=0x%llx,size=0x%x,blocks=%d\n",
644 		       i,(unsigned long long)mtd->eraseregions[i].offset,
645 		       mtd->eraseregions[i].erasesize,
646 		       mtd->eraseregions[i].numblocks);
647 	}
648 
649 #ifdef CONFIG_MTD_OTP
650 	mtd->_read_fact_prot_reg = cfi_intelext_read_fact_prot_reg;
651 	mtd->_read_user_prot_reg = cfi_intelext_read_user_prot_reg;
652 	mtd->_write_user_prot_reg = cfi_intelext_write_user_prot_reg;
653 	mtd->_lock_user_prot_reg = cfi_intelext_lock_user_prot_reg;
654 	mtd->_get_fact_prot_info = cfi_intelext_get_fact_prot_info;
655 	mtd->_get_user_prot_info = cfi_intelext_get_user_prot_info;
656 #endif
657 
658 	/* This function has the potential to distort the reality
659 	   a bit and therefore should be called last. */
660 	if (cfi_intelext_partition_fixup(mtd, &cfi) != 0)
661 		goto setup_err;
662 
663 	__module_get(THIS_MODULE);
664 	register_reboot_notifier(&mtd->reboot_notifier);
665 	return mtd;
666 
667  setup_err:
668 	if (mtd->eraseregions)
669 		for (i=0; i<cfi->cfiq->NumEraseRegions; i++)
670 			for (j=0; j<cfi->numchips; j++)
671 				kfree(mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].lockmap);
672 	kfree(mtd->eraseregions);
673 	kfree(mtd);
674 	kfree(cfi->cmdset_priv);
675 	return NULL;
676 }
677 
678 static int cfi_intelext_partition_fixup(struct mtd_info *mtd,
679 					struct cfi_private **pcfi)
680 {
681 	struct map_info *map = mtd->priv;
682 	struct cfi_private *cfi = *pcfi;
683 	struct cfi_pri_intelext *extp = cfi->cmdset_priv;
684 
685 	/*
686 	 * Probing of multi-partition flash chips.
687 	 *
688 	 * To support multiple partitions when available, we simply arrange
689 	 * for each of them to have their own flchip structure even if they
690 	 * are on the same physical chip.  This means completely recreating
691 	 * a new cfi_private structure right here which is a blatent code
692 	 * layering violation, but this is still the least intrusive
693 	 * arrangement at this point. This can be rearranged in the future
694 	 * if someone feels motivated enough.  --nico
695 	 */
696 	if (extp && extp->MajorVersion == '1' && extp->MinorVersion >= '3'
697 	    && extp->FeatureSupport & (1 << 9)) {
698 		struct cfi_private *newcfi;
699 		struct flchip *chip;
700 		struct flchip_shared *shared;
701 		int offs, numregions, numparts, partshift, numvirtchips, i, j;
702 
703 		/* Protection Register info */
704 		offs = (extp->NumProtectionFields - 1) *
705 		       sizeof(struct cfi_intelext_otpinfo);
706 
707 		/* Burst Read info */
708 		offs += extp->extra[offs+1]+2;
709 
710 		/* Number of partition regions */
711 		numregions = extp->extra[offs];
712 		offs += 1;
713 
714 		/* skip the sizeof(partregion) field in CFI 1.4 */
715 		if (extp->MinorVersion >= '4')
716 			offs += 2;
717 
718 		/* Number of hardware partitions */
719 		numparts = 0;
720 		for (i = 0; i < numregions; i++) {
721 			struct cfi_intelext_regioninfo *rinfo;
722 			rinfo = (struct cfi_intelext_regioninfo *)&extp->extra[offs];
723 			numparts += rinfo->NumIdentPartitions;
724 			offs += sizeof(*rinfo)
725 				+ (rinfo->NumBlockTypes - 1) *
726 				  sizeof(struct cfi_intelext_blockinfo);
727 		}
728 
729 		if (!numparts)
730 			numparts = 1;
731 
732 		/* Programming Region info */
733 		if (extp->MinorVersion >= '4') {
734 			struct cfi_intelext_programming_regioninfo *prinfo;
735 			prinfo = (struct cfi_intelext_programming_regioninfo *)&extp->extra[offs];
736 			mtd->writesize = cfi->interleave << prinfo->ProgRegShift;
737 			mtd->flags &= ~MTD_BIT_WRITEABLE;
738 			printk(KERN_DEBUG "%s: program region size/ctrl_valid/ctrl_inval = %d/%d/%d\n",
739 			       map->name, mtd->writesize,
740 			       cfi->interleave * prinfo->ControlValid,
741 			       cfi->interleave * prinfo->ControlInvalid);
742 		}
743 
744 		/*
745 		 * All functions below currently rely on all chips having
746 		 * the same geometry so we'll just assume that all hardware
747 		 * partitions are of the same size too.
748 		 */
749 		partshift = cfi->chipshift - __ffs(numparts);
750 
751 		if ((1 << partshift) < mtd->erasesize) {
752 			printk( KERN_ERR
753 				"%s: bad number of hw partitions (%d)\n",
754 				__func__, numparts);
755 			return -EINVAL;
756 		}
757 
758 		numvirtchips = cfi->numchips * numparts;
759 		newcfi = kmalloc(struct_size(newcfi, chips, numvirtchips),
760 				 GFP_KERNEL);
761 		if (!newcfi)
762 			return -ENOMEM;
763 		shared = kmalloc_array(cfi->numchips,
764 				       sizeof(struct flchip_shared),
765 				       GFP_KERNEL);
766 		if (!shared) {
767 			kfree(newcfi);
768 			return -ENOMEM;
769 		}
770 		memcpy(newcfi, cfi, sizeof(struct cfi_private));
771 		newcfi->numchips = numvirtchips;
772 		newcfi->chipshift = partshift;
773 
774 		chip = &newcfi->chips[0];
775 		for (i = 0; i < cfi->numchips; i++) {
776 			shared[i].writing = shared[i].erasing = NULL;
777 			mutex_init(&shared[i].lock);
778 			for (j = 0; j < numparts; j++) {
779 				*chip = cfi->chips[i];
780 				chip->start += j << partshift;
781 				chip->priv = &shared[i];
782 				/* those should be reset too since
783 				   they create memory references. */
784 				init_waitqueue_head(&chip->wq);
785 				mutex_init(&chip->mutex);
786 				chip++;
787 			}
788 		}
789 
790 		printk(KERN_DEBUG "%s: %d set(s) of %d interleaved chips "
791 				  "--> %d partitions of %d KiB\n",
792 				  map->name, cfi->numchips, cfi->interleave,
793 				  newcfi->numchips, 1<<(newcfi->chipshift-10));
794 
795 		map->fldrv_priv = newcfi;
796 		*pcfi = newcfi;
797 		kfree(cfi);
798 	}
799 
800 	return 0;
801 }
802 
803 /*
804  *  *********** CHIP ACCESS FUNCTIONS ***********
805  */
806 static int chip_ready (struct map_info *map, struct flchip *chip, unsigned long adr, int mode)
807 {
808 	DECLARE_WAITQUEUE(wait, current);
809 	struct cfi_private *cfi = map->fldrv_priv;
810 	map_word status, status_OK = CMD(0x80), status_PWS = CMD(0x01);
811 	struct cfi_pri_intelext *cfip = cfi->cmdset_priv;
812 	unsigned long timeo = jiffies + HZ;
813 
814 	/* Prevent setting state FL_SYNCING for chip in suspended state. */
815 	if (mode == FL_SYNCING && chip->oldstate != FL_READY)
816 		goto sleep;
817 
818 	switch (chip->state) {
819 
820 	case FL_STATUS:
821 		for (;;) {
822 			status = map_read(map, adr);
823 			if (map_word_andequal(map, status, status_OK, status_OK))
824 				break;
825 
826 			/* At this point we're fine with write operations
827 			   in other partitions as they don't conflict. */
828 			if (chip->priv && map_word_andequal(map, status, status_PWS, status_PWS))
829 				break;
830 
831 			mutex_unlock(&chip->mutex);
832 			cfi_udelay(1);
833 			mutex_lock(&chip->mutex);
834 			/* Someone else might have been playing with it. */
835 			return -EAGAIN;
836 		}
837 		/* Fall through */
838 	case FL_READY:
839 	case FL_CFI_QUERY:
840 	case FL_JEDEC_QUERY:
841 		return 0;
842 
843 	case FL_ERASING:
844 		if (!cfip ||
845 		    !(cfip->FeatureSupport & 2) ||
846 		    !(mode == FL_READY || mode == FL_POINT ||
847 		     (mode == FL_WRITING && (cfip->SuspendCmdSupport & 1))))
848 			goto sleep;
849 
850 		/* Do not allow suspend iff read/write to EB address */
851 		if ((adr & chip->in_progress_block_mask) ==
852 		    chip->in_progress_block_addr)
853 			goto sleep;
854 
855 		/* do not suspend small EBs, buggy Micron Chips */
856 		if (cfi_is_micron_28F00AP30(cfi, chip) &&
857 		    (chip->in_progress_block_mask == ~(0x8000-1)))
858 			goto sleep;
859 
860 		/* Erase suspend */
861 		map_write(map, CMD(0xB0), chip->in_progress_block_addr);
862 
863 		/* If the flash has finished erasing, then 'erase suspend'
864 		 * appears to make some (28F320) flash devices switch to
865 		 * 'read' mode.  Make sure that we switch to 'read status'
866 		 * mode so we get the right data. --rmk
867 		 */
868 		map_write(map, CMD(0x70), chip->in_progress_block_addr);
869 		chip->oldstate = FL_ERASING;
870 		chip->state = FL_ERASE_SUSPENDING;
871 		chip->erase_suspended = 1;
872 		for (;;) {
873 			status = map_read(map, chip->in_progress_block_addr);
874 			if (map_word_andequal(map, status, status_OK, status_OK))
875 			        break;
876 
877 			if (time_after(jiffies, timeo)) {
878 				/* Urgh. Resume and pretend we weren't here.
879 				 * Make sure we're in 'read status' mode if it had finished */
880 				put_chip(map, chip, adr);
881 				printk(KERN_ERR "%s: Chip not ready after erase "
882 				       "suspended: status = 0x%lx\n", map->name, status.x[0]);
883 				return -EIO;
884 			}
885 
886 			mutex_unlock(&chip->mutex);
887 			cfi_udelay(1);
888 			mutex_lock(&chip->mutex);
889 			/* Nobody will touch it while it's in state FL_ERASE_SUSPENDING.
890 			   So we can just loop here. */
891 		}
892 		chip->state = FL_STATUS;
893 		return 0;
894 
895 	case FL_XIP_WHILE_ERASING:
896 		if (mode != FL_READY && mode != FL_POINT &&
897 		    (mode != FL_WRITING || !cfip || !(cfip->SuspendCmdSupport&1)))
898 			goto sleep;
899 		chip->oldstate = chip->state;
900 		chip->state = FL_READY;
901 		return 0;
902 
903 	case FL_SHUTDOWN:
904 		/* The machine is rebooting now,so no one can get chip anymore */
905 		return -EIO;
906 	case FL_POINT:
907 		/* Only if there's no operation suspended... */
908 		if (mode == FL_READY && chip->oldstate == FL_READY)
909 			return 0;
910 		/* Fall through */
911 	default:
912 	sleep:
913 		set_current_state(TASK_UNINTERRUPTIBLE);
914 		add_wait_queue(&chip->wq, &wait);
915 		mutex_unlock(&chip->mutex);
916 		schedule();
917 		remove_wait_queue(&chip->wq, &wait);
918 		mutex_lock(&chip->mutex);
919 		return -EAGAIN;
920 	}
921 }
922 
923 static int get_chip(struct map_info *map, struct flchip *chip, unsigned long adr, int mode)
924 {
925 	int ret;
926 	DECLARE_WAITQUEUE(wait, current);
927 
928  retry:
929 	if (chip->priv &&
930 	    (mode == FL_WRITING || mode == FL_ERASING || mode == FL_OTP_WRITE
931 	    || mode == FL_SHUTDOWN) && chip->state != FL_SYNCING) {
932 		/*
933 		 * OK. We have possibility for contention on the write/erase
934 		 * operations which are global to the real chip and not per
935 		 * partition.  So let's fight it over in the partition which
936 		 * currently has authority on the operation.
937 		 *
938 		 * The rules are as follows:
939 		 *
940 		 * - any write operation must own shared->writing.
941 		 *
942 		 * - any erase operation must own _both_ shared->writing and
943 		 *   shared->erasing.
944 		 *
945 		 * - contention arbitration is handled in the owner's context.
946 		 *
947 		 * The 'shared' struct can be read and/or written only when
948 		 * its lock is taken.
949 		 */
950 		struct flchip_shared *shared = chip->priv;
951 		struct flchip *contender;
952 		mutex_lock(&shared->lock);
953 		contender = shared->writing;
954 		if (contender && contender != chip) {
955 			/*
956 			 * The engine to perform desired operation on this
957 			 * partition is already in use by someone else.
958 			 * Let's fight over it in the context of the chip
959 			 * currently using it.  If it is possible to suspend,
960 			 * that other partition will do just that, otherwise
961 			 * it'll happily send us to sleep.  In any case, when
962 			 * get_chip returns success we're clear to go ahead.
963 			 */
964 			ret = mutex_trylock(&contender->mutex);
965 			mutex_unlock(&shared->lock);
966 			if (!ret)
967 				goto retry;
968 			mutex_unlock(&chip->mutex);
969 			ret = chip_ready(map, contender, contender->start, mode);
970 			mutex_lock(&chip->mutex);
971 
972 			if (ret == -EAGAIN) {
973 				mutex_unlock(&contender->mutex);
974 				goto retry;
975 			}
976 			if (ret) {
977 				mutex_unlock(&contender->mutex);
978 				return ret;
979 			}
980 			mutex_lock(&shared->lock);
981 
982 			/* We should not own chip if it is already
983 			 * in FL_SYNCING state. Put contender and retry. */
984 			if (chip->state == FL_SYNCING) {
985 				put_chip(map, contender, contender->start);
986 				mutex_unlock(&contender->mutex);
987 				goto retry;
988 			}
989 			mutex_unlock(&contender->mutex);
990 		}
991 
992 		/* Check if we already have suspended erase
993 		 * on this chip. Sleep. */
994 		if (mode == FL_ERASING && shared->erasing
995 		    && shared->erasing->oldstate == FL_ERASING) {
996 			mutex_unlock(&shared->lock);
997 			set_current_state(TASK_UNINTERRUPTIBLE);
998 			add_wait_queue(&chip->wq, &wait);
999 			mutex_unlock(&chip->mutex);
1000 			schedule();
1001 			remove_wait_queue(&chip->wq, &wait);
1002 			mutex_lock(&chip->mutex);
1003 			goto retry;
1004 		}
1005 
1006 		/* We now own it */
1007 		shared->writing = chip;
1008 		if (mode == FL_ERASING)
1009 			shared->erasing = chip;
1010 		mutex_unlock(&shared->lock);
1011 	}
1012 	ret = chip_ready(map, chip, adr, mode);
1013 	if (ret == -EAGAIN)
1014 		goto retry;
1015 
1016 	return ret;
1017 }
1018 
1019 static void put_chip(struct map_info *map, struct flchip *chip, unsigned long adr)
1020 {
1021 	struct cfi_private *cfi = map->fldrv_priv;
1022 
1023 	if (chip->priv) {
1024 		struct flchip_shared *shared = chip->priv;
1025 		mutex_lock(&shared->lock);
1026 		if (shared->writing == chip && chip->oldstate == FL_READY) {
1027 			/* We own the ability to write, but we're done */
1028 			shared->writing = shared->erasing;
1029 			if (shared->writing && shared->writing != chip) {
1030 				/* give back ownership to who we loaned it from */
1031 				struct flchip *loaner = shared->writing;
1032 				mutex_lock(&loaner->mutex);
1033 				mutex_unlock(&shared->lock);
1034 				mutex_unlock(&chip->mutex);
1035 				put_chip(map, loaner, loaner->start);
1036 				mutex_lock(&chip->mutex);
1037 				mutex_unlock(&loaner->mutex);
1038 				wake_up(&chip->wq);
1039 				return;
1040 			}
1041 			shared->erasing = NULL;
1042 			shared->writing = NULL;
1043 		} else if (shared->erasing == chip && shared->writing != chip) {
1044 			/*
1045 			 * We own the ability to erase without the ability
1046 			 * to write, which means the erase was suspended
1047 			 * and some other partition is currently writing.
1048 			 * Don't let the switch below mess things up since
1049 			 * we don't have ownership to resume anything.
1050 			 */
1051 			mutex_unlock(&shared->lock);
1052 			wake_up(&chip->wq);
1053 			return;
1054 		}
1055 		mutex_unlock(&shared->lock);
1056 	}
1057 
1058 	switch(chip->oldstate) {
1059 	case FL_ERASING:
1060 		/* What if one interleaved chip has finished and the
1061 		   other hasn't? The old code would leave the finished
1062 		   one in READY mode. That's bad, and caused -EROFS
1063 		   errors to be returned from do_erase_oneblock because
1064 		   that's the only bit it checked for at the time.
1065 		   As the state machine appears to explicitly allow
1066 		   sending the 0x70 (Read Status) command to an erasing
1067 		   chip and expecting it to be ignored, that's what we
1068 		   do. */
1069 		map_write(map, CMD(0xd0), chip->in_progress_block_addr);
1070 		map_write(map, CMD(0x70), chip->in_progress_block_addr);
1071 		chip->oldstate = FL_READY;
1072 		chip->state = FL_ERASING;
1073 		break;
1074 
1075 	case FL_XIP_WHILE_ERASING:
1076 		chip->state = chip->oldstate;
1077 		chip->oldstate = FL_READY;
1078 		break;
1079 
1080 	case FL_READY:
1081 	case FL_STATUS:
1082 	case FL_JEDEC_QUERY:
1083 		break;
1084 	default:
1085 		printk(KERN_ERR "%s: put_chip() called with oldstate %d!!\n", map->name, chip->oldstate);
1086 	}
1087 	wake_up(&chip->wq);
1088 }
1089 
1090 #ifdef CONFIG_MTD_XIP
1091 
1092 /*
1093  * No interrupt what so ever can be serviced while the flash isn't in array
1094  * mode.  This is ensured by the xip_disable() and xip_enable() functions
1095  * enclosing any code path where the flash is known not to be in array mode.
1096  * And within a XIP disabled code path, only functions marked with __xipram
1097  * may be called and nothing else (it's a good thing to inspect generated
1098  * assembly to make sure inline functions were actually inlined and that gcc
1099  * didn't emit calls to its own support functions). Also configuring MTD CFI
1100  * support to a single buswidth and a single interleave is also recommended.
1101  */
1102 
1103 static void xip_disable(struct map_info *map, struct flchip *chip,
1104 			unsigned long adr)
1105 {
1106 	/* TODO: chips with no XIP use should ignore and return */
1107 	(void) map_read(map, adr); /* ensure mmu mapping is up to date */
1108 	local_irq_disable();
1109 }
1110 
1111 static void __xipram xip_enable(struct map_info *map, struct flchip *chip,
1112 				unsigned long adr)
1113 {
1114 	struct cfi_private *cfi = map->fldrv_priv;
1115 	if (chip->state != FL_POINT && chip->state != FL_READY) {
1116 		map_write(map, CMD(0xff), adr);
1117 		chip->state = FL_READY;
1118 	}
1119 	(void) map_read(map, adr);
1120 	xip_iprefetch();
1121 	local_irq_enable();
1122 }
1123 
1124 /*
1125  * When a delay is required for the flash operation to complete, the
1126  * xip_wait_for_operation() function is polling for both the given timeout
1127  * and pending (but still masked) hardware interrupts.  Whenever there is an
1128  * interrupt pending then the flash erase or write operation is suspended,
1129  * array mode restored and interrupts unmasked.  Task scheduling might also
1130  * happen at that point.  The CPU eventually returns from the interrupt or
1131  * the call to schedule() and the suspended flash operation is resumed for
1132  * the remaining of the delay period.
1133  *
1134  * Warning: this function _will_ fool interrupt latency tracing tools.
1135  */
1136 
1137 static int __xipram xip_wait_for_operation(
1138 		struct map_info *map, struct flchip *chip,
1139 		unsigned long adr, unsigned int chip_op_time_max)
1140 {
1141 	struct cfi_private *cfi = map->fldrv_priv;
1142 	struct cfi_pri_intelext *cfip = cfi->cmdset_priv;
1143 	map_word status, OK = CMD(0x80);
1144 	unsigned long usec, suspended, start, done;
1145 	flstate_t oldstate, newstate;
1146 
1147        	start = xip_currtime();
1148 	usec = chip_op_time_max;
1149 	if (usec == 0)
1150 		usec = 500000;
1151 	done = 0;
1152 
1153 	do {
1154 		cpu_relax();
1155 		if (xip_irqpending() && cfip &&
1156 		    ((chip->state == FL_ERASING && (cfip->FeatureSupport&2)) ||
1157 		     (chip->state == FL_WRITING && (cfip->FeatureSupport&4))) &&
1158 		    (cfi_interleave_is_1(cfi) || chip->oldstate == FL_READY)) {
1159 			/*
1160 			 * Let's suspend the erase or write operation when
1161 			 * supported.  Note that we currently don't try to
1162 			 * suspend interleaved chips if there is already
1163 			 * another operation suspended (imagine what happens
1164 			 * when one chip was already done with the current
1165 			 * operation while another chip suspended it, then
1166 			 * we resume the whole thing at once).  Yes, it
1167 			 * can happen!
1168 			 */
1169 			usec -= done;
1170 			map_write(map, CMD(0xb0), adr);
1171 			map_write(map, CMD(0x70), adr);
1172 			suspended = xip_currtime();
1173 			do {
1174 				if (xip_elapsed_since(suspended) > 100000) {
1175 					/*
1176 					 * The chip doesn't want to suspend
1177 					 * after waiting for 100 msecs.
1178 					 * This is a critical error but there
1179 					 * is not much we can do here.
1180 					 */
1181 					return -EIO;
1182 				}
1183 				status = map_read(map, adr);
1184 			} while (!map_word_andequal(map, status, OK, OK));
1185 
1186 			/* Suspend succeeded */
1187 			oldstate = chip->state;
1188 			if (oldstate == FL_ERASING) {
1189 				if (!map_word_bitsset(map, status, CMD(0x40)))
1190 					break;
1191 				newstate = FL_XIP_WHILE_ERASING;
1192 				chip->erase_suspended = 1;
1193 			} else {
1194 				if (!map_word_bitsset(map, status, CMD(0x04)))
1195 					break;
1196 				newstate = FL_XIP_WHILE_WRITING;
1197 				chip->write_suspended = 1;
1198 			}
1199 			chip->state = newstate;
1200 			map_write(map, CMD(0xff), adr);
1201 			(void) map_read(map, adr);
1202 			xip_iprefetch();
1203 			local_irq_enable();
1204 			mutex_unlock(&chip->mutex);
1205 			xip_iprefetch();
1206 			cond_resched();
1207 
1208 			/*
1209 			 * We're back.  However someone else might have
1210 			 * decided to go write to the chip if we are in
1211 			 * a suspended erase state.  If so let's wait
1212 			 * until it's done.
1213 			 */
1214 			mutex_lock(&chip->mutex);
1215 			while (chip->state != newstate) {
1216 				DECLARE_WAITQUEUE(wait, current);
1217 				set_current_state(TASK_UNINTERRUPTIBLE);
1218 				add_wait_queue(&chip->wq, &wait);
1219 				mutex_unlock(&chip->mutex);
1220 				schedule();
1221 				remove_wait_queue(&chip->wq, &wait);
1222 				mutex_lock(&chip->mutex);
1223 			}
1224 			/* Disallow XIP again */
1225 			local_irq_disable();
1226 
1227 			/* Resume the write or erase operation */
1228 			map_write(map, CMD(0xd0), adr);
1229 			map_write(map, CMD(0x70), adr);
1230 			chip->state = oldstate;
1231 			start = xip_currtime();
1232 		} else if (usec >= 1000000/HZ) {
1233 			/*
1234 			 * Try to save on CPU power when waiting delay
1235 			 * is at least a system timer tick period.
1236 			 * No need to be extremely accurate here.
1237 			 */
1238 			xip_cpu_idle();
1239 		}
1240 		status = map_read(map, adr);
1241 		done = xip_elapsed_since(start);
1242 	} while (!map_word_andequal(map, status, OK, OK)
1243 		 && done < usec);
1244 
1245 	return (done >= usec) ? -ETIME : 0;
1246 }
1247 
1248 /*
1249  * The INVALIDATE_CACHED_RANGE() macro is normally used in parallel while
1250  * the flash is actively programming or erasing since we have to poll for
1251  * the operation to complete anyway.  We can't do that in a generic way with
1252  * a XIP setup so do it before the actual flash operation in this case
1253  * and stub it out from INVAL_CACHE_AND_WAIT.
1254  */
1255 #define XIP_INVAL_CACHED_RANGE(map, from, size)  \
1256 	INVALIDATE_CACHED_RANGE(map, from, size)
1257 
1258 #define INVAL_CACHE_AND_WAIT(map, chip, cmd_adr, inval_adr, inval_len, usec, usec_max) \
1259 	xip_wait_for_operation(map, chip, cmd_adr, usec_max)
1260 
1261 #else
1262 
1263 #define xip_disable(map, chip, adr)
1264 #define xip_enable(map, chip, adr)
1265 #define XIP_INVAL_CACHED_RANGE(x...)
1266 #define INVAL_CACHE_AND_WAIT inval_cache_and_wait_for_operation
1267 
1268 static int inval_cache_and_wait_for_operation(
1269 		struct map_info *map, struct flchip *chip,
1270 		unsigned long cmd_adr, unsigned long inval_adr, int inval_len,
1271 		unsigned int chip_op_time, unsigned int chip_op_time_max)
1272 {
1273 	struct cfi_private *cfi = map->fldrv_priv;
1274 	map_word status, status_OK = CMD(0x80);
1275 	int chip_state = chip->state;
1276 	unsigned int timeo, sleep_time, reset_timeo;
1277 
1278 	mutex_unlock(&chip->mutex);
1279 	if (inval_len)
1280 		INVALIDATE_CACHED_RANGE(map, inval_adr, inval_len);
1281 	mutex_lock(&chip->mutex);
1282 
1283 	timeo = chip_op_time_max;
1284 	if (!timeo)
1285 		timeo = 500000;
1286 	reset_timeo = timeo;
1287 	sleep_time = chip_op_time / 2;
1288 
1289 	for (;;) {
1290 		if (chip->state != chip_state) {
1291 			/* Someone's suspended the operation: sleep */
1292 			DECLARE_WAITQUEUE(wait, current);
1293 			set_current_state(TASK_UNINTERRUPTIBLE);
1294 			add_wait_queue(&chip->wq, &wait);
1295 			mutex_unlock(&chip->mutex);
1296 			schedule();
1297 			remove_wait_queue(&chip->wq, &wait);
1298 			mutex_lock(&chip->mutex);
1299 			continue;
1300 		}
1301 
1302 		status = map_read(map, cmd_adr);
1303 		if (map_word_andequal(map, status, status_OK, status_OK))
1304 			break;
1305 
1306 		if (chip->erase_suspended && chip_state == FL_ERASING)  {
1307 			/* Erase suspend occurred while sleep: reset timeout */
1308 			timeo = reset_timeo;
1309 			chip->erase_suspended = 0;
1310 		}
1311 		if (chip->write_suspended && chip_state == FL_WRITING)  {
1312 			/* Write suspend occurred while sleep: reset timeout */
1313 			timeo = reset_timeo;
1314 			chip->write_suspended = 0;
1315 		}
1316 		if (!timeo) {
1317 			map_write(map, CMD(0x70), cmd_adr);
1318 			chip->state = FL_STATUS;
1319 			return -ETIME;
1320 		}
1321 
1322 		/* OK Still waiting. Drop the lock, wait a while and retry. */
1323 		mutex_unlock(&chip->mutex);
1324 		if (sleep_time >= 1000000/HZ) {
1325 			/*
1326 			 * Half of the normal delay still remaining
1327 			 * can be performed with a sleeping delay instead
1328 			 * of busy waiting.
1329 			 */
1330 			msleep(sleep_time/1000);
1331 			timeo -= sleep_time;
1332 			sleep_time = 1000000/HZ;
1333 		} else {
1334 			udelay(1);
1335 			cond_resched();
1336 			timeo--;
1337 		}
1338 		mutex_lock(&chip->mutex);
1339 	}
1340 
1341 	/* Done and happy. */
1342  	chip->state = FL_STATUS;
1343 	return 0;
1344 }
1345 
1346 #endif
1347 
1348 #define WAIT_TIMEOUT(map, chip, adr, udelay, udelay_max) \
1349 	INVAL_CACHE_AND_WAIT(map, chip, adr, 0, 0, udelay, udelay_max);
1350 
1351 
1352 static int do_point_onechip (struct map_info *map, struct flchip *chip, loff_t adr, size_t len)
1353 {
1354 	unsigned long cmd_addr;
1355 	struct cfi_private *cfi = map->fldrv_priv;
1356 	int ret;
1357 
1358 	adr += chip->start;
1359 
1360 	/* Ensure cmd read/writes are aligned. */
1361 	cmd_addr = adr & ~(map_bankwidth(map)-1);
1362 
1363 	mutex_lock(&chip->mutex);
1364 
1365 	ret = get_chip(map, chip, cmd_addr, FL_POINT);
1366 
1367 	if (!ret) {
1368 		if (chip->state != FL_POINT && chip->state != FL_READY)
1369 			map_write(map, CMD(0xff), cmd_addr);
1370 
1371 		chip->state = FL_POINT;
1372 		chip->ref_point_counter++;
1373 	}
1374 	mutex_unlock(&chip->mutex);
1375 
1376 	return ret;
1377 }
1378 
1379 static int cfi_intelext_point(struct mtd_info *mtd, loff_t from, size_t len,
1380 		size_t *retlen, void **virt, resource_size_t *phys)
1381 {
1382 	struct map_info *map = mtd->priv;
1383 	struct cfi_private *cfi = map->fldrv_priv;
1384 	unsigned long ofs, last_end = 0;
1385 	int chipnum;
1386 	int ret;
1387 
1388 	if (!map->virt)
1389 		return -EINVAL;
1390 
1391 	/* Now lock the chip(s) to POINT state */
1392 
1393 	/* ofs: offset within the first chip that the first read should start */
1394 	chipnum = (from >> cfi->chipshift);
1395 	ofs = from - (chipnum << cfi->chipshift);
1396 
1397 	*virt = map->virt + cfi->chips[chipnum].start + ofs;
1398 	if (phys)
1399 		*phys = map->phys + cfi->chips[chipnum].start + ofs;
1400 
1401 	while (len) {
1402 		unsigned long thislen;
1403 
1404 		if (chipnum >= cfi->numchips)
1405 			break;
1406 
1407 		/* We cannot point across chips that are virtually disjoint */
1408 		if (!last_end)
1409 			last_end = cfi->chips[chipnum].start;
1410 		else if (cfi->chips[chipnum].start != last_end)
1411 			break;
1412 
1413 		if ((len + ofs -1) >> cfi->chipshift)
1414 			thislen = (1<<cfi->chipshift) - ofs;
1415 		else
1416 			thislen = len;
1417 
1418 		ret = do_point_onechip(map, &cfi->chips[chipnum], ofs, thislen);
1419 		if (ret)
1420 			break;
1421 
1422 		*retlen += thislen;
1423 		len -= thislen;
1424 
1425 		ofs = 0;
1426 		last_end += 1 << cfi->chipshift;
1427 		chipnum++;
1428 	}
1429 	return 0;
1430 }
1431 
1432 static int cfi_intelext_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
1433 {
1434 	struct map_info *map = mtd->priv;
1435 	struct cfi_private *cfi = map->fldrv_priv;
1436 	unsigned long ofs;
1437 	int chipnum, err = 0;
1438 
1439 	/* Now unlock the chip(s) POINT state */
1440 
1441 	/* ofs: offset within the first chip that the first read should start */
1442 	chipnum = (from >> cfi->chipshift);
1443 	ofs = from - (chipnum <<  cfi->chipshift);
1444 
1445 	while (len && !err) {
1446 		unsigned long thislen;
1447 		struct flchip *chip;
1448 
1449 		chip = &cfi->chips[chipnum];
1450 		if (chipnum >= cfi->numchips)
1451 			break;
1452 
1453 		if ((len + ofs -1) >> cfi->chipshift)
1454 			thislen = (1<<cfi->chipshift) - ofs;
1455 		else
1456 			thislen = len;
1457 
1458 		mutex_lock(&chip->mutex);
1459 		if (chip->state == FL_POINT) {
1460 			chip->ref_point_counter--;
1461 			if(chip->ref_point_counter == 0)
1462 				chip->state = FL_READY;
1463 		} else {
1464 			printk(KERN_ERR "%s: Error: unpoint called on non pointed region\n", map->name);
1465 			err = -EINVAL;
1466 		}
1467 
1468 		put_chip(map, chip, chip->start);
1469 		mutex_unlock(&chip->mutex);
1470 
1471 		len -= thislen;
1472 		ofs = 0;
1473 		chipnum++;
1474 	}
1475 
1476 	return err;
1477 }
1478 
1479 static inline int do_read_onechip(struct map_info *map, struct flchip *chip, loff_t adr, size_t len, u_char *buf)
1480 {
1481 	unsigned long cmd_addr;
1482 	struct cfi_private *cfi = map->fldrv_priv;
1483 	int ret;
1484 
1485 	adr += chip->start;
1486 
1487 	/* Ensure cmd read/writes are aligned. */
1488 	cmd_addr = adr & ~(map_bankwidth(map)-1);
1489 
1490 	mutex_lock(&chip->mutex);
1491 	ret = get_chip(map, chip, cmd_addr, FL_READY);
1492 	if (ret) {
1493 		mutex_unlock(&chip->mutex);
1494 		return ret;
1495 	}
1496 
1497 	if (chip->state != FL_POINT && chip->state != FL_READY) {
1498 		map_write(map, CMD(0xff), cmd_addr);
1499 
1500 		chip->state = FL_READY;
1501 	}
1502 
1503 	map_copy_from(map, buf, adr, len);
1504 
1505 	put_chip(map, chip, cmd_addr);
1506 
1507 	mutex_unlock(&chip->mutex);
1508 	return 0;
1509 }
1510 
1511 static int cfi_intelext_read (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf)
1512 {
1513 	struct map_info *map = mtd->priv;
1514 	struct cfi_private *cfi = map->fldrv_priv;
1515 	unsigned long ofs;
1516 	int chipnum;
1517 	int ret = 0;
1518 
1519 	/* ofs: offset within the first chip that the first read should start */
1520 	chipnum = (from >> cfi->chipshift);
1521 	ofs = from - (chipnum <<  cfi->chipshift);
1522 
1523 	while (len) {
1524 		unsigned long thislen;
1525 
1526 		if (chipnum >= cfi->numchips)
1527 			break;
1528 
1529 		if ((len + ofs -1) >> cfi->chipshift)
1530 			thislen = (1<<cfi->chipshift) - ofs;
1531 		else
1532 			thislen = len;
1533 
1534 		ret = do_read_onechip(map, &cfi->chips[chipnum], ofs, thislen, buf);
1535 		if (ret)
1536 			break;
1537 
1538 		*retlen += thislen;
1539 		len -= thislen;
1540 		buf += thislen;
1541 
1542 		ofs = 0;
1543 		chipnum++;
1544 	}
1545 	return ret;
1546 }
1547 
1548 static int __xipram do_write_oneword(struct map_info *map, struct flchip *chip,
1549 				     unsigned long adr, map_word datum, int mode)
1550 {
1551 	struct cfi_private *cfi = map->fldrv_priv;
1552 	map_word status, write_cmd;
1553 	int ret;
1554 
1555 	adr += chip->start;
1556 
1557 	switch (mode) {
1558 	case FL_WRITING:
1559 		write_cmd = (cfi->cfiq->P_ID != P_ID_INTEL_PERFORMANCE) ? CMD(0x40) : CMD(0x41);
1560 		break;
1561 	case FL_OTP_WRITE:
1562 		write_cmd = CMD(0xc0);
1563 		break;
1564 	default:
1565 		return -EINVAL;
1566 	}
1567 
1568 	mutex_lock(&chip->mutex);
1569 	ret = get_chip(map, chip, adr, mode);
1570 	if (ret) {
1571 		mutex_unlock(&chip->mutex);
1572 		return ret;
1573 	}
1574 
1575 	XIP_INVAL_CACHED_RANGE(map, adr, map_bankwidth(map));
1576 	ENABLE_VPP(map);
1577 	xip_disable(map, chip, adr);
1578 	map_write(map, write_cmd, adr);
1579 	map_write(map, datum, adr);
1580 	chip->state = mode;
1581 
1582 	ret = INVAL_CACHE_AND_WAIT(map, chip, adr,
1583 				   adr, map_bankwidth(map),
1584 				   chip->word_write_time,
1585 				   chip->word_write_time_max);
1586 	if (ret) {
1587 		xip_enable(map, chip, adr);
1588 		printk(KERN_ERR "%s: word write error (status timeout)\n", map->name);
1589 		goto out;
1590 	}
1591 
1592 	/* check for errors */
1593 	status = map_read(map, adr);
1594 	if (map_word_bitsset(map, status, CMD(0x1a))) {
1595 		unsigned long chipstatus = MERGESTATUS(status);
1596 
1597 		/* reset status */
1598 		map_write(map, CMD(0x50), adr);
1599 		map_write(map, CMD(0x70), adr);
1600 		xip_enable(map, chip, adr);
1601 
1602 		if (chipstatus & 0x02) {
1603 			ret = -EROFS;
1604 		} else if (chipstatus & 0x08) {
1605 			printk(KERN_ERR "%s: word write error (bad VPP)\n", map->name);
1606 			ret = -EIO;
1607 		} else {
1608 			printk(KERN_ERR "%s: word write error (status 0x%lx)\n", map->name, chipstatus);
1609 			ret = -EINVAL;
1610 		}
1611 
1612 		goto out;
1613 	}
1614 
1615 	xip_enable(map, chip, adr);
1616  out:	DISABLE_VPP(map);
1617 	put_chip(map, chip, adr);
1618 	mutex_unlock(&chip->mutex);
1619 	return ret;
1620 }
1621 
1622 
1623 static int cfi_intelext_write_words (struct mtd_info *mtd, loff_t to , size_t len, size_t *retlen, const u_char *buf)
1624 {
1625 	struct map_info *map = mtd->priv;
1626 	struct cfi_private *cfi = map->fldrv_priv;
1627 	int ret;
1628 	int chipnum;
1629 	unsigned long ofs;
1630 
1631 	chipnum = to >> cfi->chipshift;
1632 	ofs = to  - (chipnum << cfi->chipshift);
1633 
1634 	/* If it's not bus-aligned, do the first byte write */
1635 	if (ofs & (map_bankwidth(map)-1)) {
1636 		unsigned long bus_ofs = ofs & ~(map_bankwidth(map)-1);
1637 		int gap = ofs - bus_ofs;
1638 		int n;
1639 		map_word datum;
1640 
1641 		n = min_t(int, len, map_bankwidth(map)-gap);
1642 		datum = map_word_ff(map);
1643 		datum = map_word_load_partial(map, datum, buf, gap, n);
1644 
1645 		ret = do_write_oneword(map, &cfi->chips[chipnum],
1646 					       bus_ofs, datum, FL_WRITING);
1647 		if (ret)
1648 			return ret;
1649 
1650 		len -= n;
1651 		ofs += n;
1652 		buf += n;
1653 		(*retlen) += n;
1654 
1655 		if (ofs >> cfi->chipshift) {
1656 			chipnum ++;
1657 			ofs = 0;
1658 			if (chipnum == cfi->numchips)
1659 				return 0;
1660 		}
1661 	}
1662 
1663 	while(len >= map_bankwidth(map)) {
1664 		map_word datum = map_word_load(map, buf);
1665 
1666 		ret = do_write_oneword(map, &cfi->chips[chipnum],
1667 				       ofs, datum, FL_WRITING);
1668 		if (ret)
1669 			return ret;
1670 
1671 		ofs += map_bankwidth(map);
1672 		buf += map_bankwidth(map);
1673 		(*retlen) += map_bankwidth(map);
1674 		len -= map_bankwidth(map);
1675 
1676 		if (ofs >> cfi->chipshift) {
1677 			chipnum ++;
1678 			ofs = 0;
1679 			if (chipnum == cfi->numchips)
1680 				return 0;
1681 		}
1682 	}
1683 
1684 	if (len & (map_bankwidth(map)-1)) {
1685 		map_word datum;
1686 
1687 		datum = map_word_ff(map);
1688 		datum = map_word_load_partial(map, datum, buf, 0, len);
1689 
1690 		ret = do_write_oneword(map, &cfi->chips[chipnum],
1691 				       ofs, datum, FL_WRITING);
1692 		if (ret)
1693 			return ret;
1694 
1695 		(*retlen) += len;
1696 	}
1697 
1698 	return 0;
1699 }
1700 
1701 
1702 static int __xipram do_write_buffer(struct map_info *map, struct flchip *chip,
1703 				    unsigned long adr, const struct kvec **pvec,
1704 				    unsigned long *pvec_seek, int len)
1705 {
1706 	struct cfi_private *cfi = map->fldrv_priv;
1707 	map_word status, write_cmd, datum;
1708 	unsigned long cmd_adr;
1709 	int ret, wbufsize, word_gap, words;
1710 	const struct kvec *vec;
1711 	unsigned long vec_seek;
1712 	unsigned long initial_adr;
1713 	int initial_len = len;
1714 
1715 	wbufsize = cfi_interleave(cfi) << cfi->cfiq->MaxBufWriteSize;
1716 	adr += chip->start;
1717 	initial_adr = adr;
1718 	cmd_adr = adr & ~(wbufsize-1);
1719 
1720 	/* Sharp LH28F640BF chips need the first address for the
1721 	 * Page Buffer Program command. See Table 5 of
1722 	 * LH28F320BF, LH28F640BF, LH28F128BF Series (Appendix FUM00701) */
1723 	if (is_LH28F640BF(cfi))
1724 		cmd_adr = adr;
1725 
1726 	/* Let's determine this according to the interleave only once */
1727 	write_cmd = (cfi->cfiq->P_ID != P_ID_INTEL_PERFORMANCE) ? CMD(0xe8) : CMD(0xe9);
1728 
1729 	mutex_lock(&chip->mutex);
1730 	ret = get_chip(map, chip, cmd_adr, FL_WRITING);
1731 	if (ret) {
1732 		mutex_unlock(&chip->mutex);
1733 		return ret;
1734 	}
1735 
1736 	XIP_INVAL_CACHED_RANGE(map, initial_adr, initial_len);
1737 	ENABLE_VPP(map);
1738 	xip_disable(map, chip, cmd_adr);
1739 
1740 	/* §4.8 of the 28FxxxJ3A datasheet says "Any time SR.4 and/or SR.5 is set
1741 	   [...], the device will not accept any more Write to Buffer commands".
1742 	   So we must check here and reset those bits if they're set. Otherwise
1743 	   we're just pissing in the wind */
1744 	if (chip->state != FL_STATUS) {
1745 		map_write(map, CMD(0x70), cmd_adr);
1746 		chip->state = FL_STATUS;
1747 	}
1748 	status = map_read(map, cmd_adr);
1749 	if (map_word_bitsset(map, status, CMD(0x30))) {
1750 		xip_enable(map, chip, cmd_adr);
1751 		printk(KERN_WARNING "SR.4 or SR.5 bits set in buffer write (status %lx). Clearing.\n", status.x[0]);
1752 		xip_disable(map, chip, cmd_adr);
1753 		map_write(map, CMD(0x50), cmd_adr);
1754 		map_write(map, CMD(0x70), cmd_adr);
1755 	}
1756 
1757 	chip->state = FL_WRITING_TO_BUFFER;
1758 	map_write(map, write_cmd, cmd_adr);
1759 	ret = WAIT_TIMEOUT(map, chip, cmd_adr, 0, 0);
1760 	if (ret) {
1761 		/* Argh. Not ready for write to buffer */
1762 		map_word Xstatus = map_read(map, cmd_adr);
1763 		map_write(map, CMD(0x70), cmd_adr);
1764 		chip->state = FL_STATUS;
1765 		status = map_read(map, cmd_adr);
1766 		map_write(map, CMD(0x50), cmd_adr);
1767 		map_write(map, CMD(0x70), cmd_adr);
1768 		xip_enable(map, chip, cmd_adr);
1769 		printk(KERN_ERR "%s: Chip not ready for buffer write. Xstatus = %lx, status = %lx\n",
1770 				map->name, Xstatus.x[0], status.x[0]);
1771 		goto out;
1772 	}
1773 
1774 	/* Figure out the number of words to write */
1775 	word_gap = (-adr & (map_bankwidth(map)-1));
1776 	words = DIV_ROUND_UP(len - word_gap, map_bankwidth(map));
1777 	if (!word_gap) {
1778 		words--;
1779 	} else {
1780 		word_gap = map_bankwidth(map) - word_gap;
1781 		adr -= word_gap;
1782 		datum = map_word_ff(map);
1783 	}
1784 
1785 	/* Write length of data to come */
1786 	map_write(map, CMD(words), cmd_adr );
1787 
1788 	/* Write data */
1789 	vec = *pvec;
1790 	vec_seek = *pvec_seek;
1791 	do {
1792 		int n = map_bankwidth(map) - word_gap;
1793 		if (n > vec->iov_len - vec_seek)
1794 			n = vec->iov_len - vec_seek;
1795 		if (n > len)
1796 			n = len;
1797 
1798 		if (!word_gap && len < map_bankwidth(map))
1799 			datum = map_word_ff(map);
1800 
1801 		datum = map_word_load_partial(map, datum,
1802 					      vec->iov_base + vec_seek,
1803 					      word_gap, n);
1804 
1805 		len -= n;
1806 		word_gap += n;
1807 		if (!len || word_gap == map_bankwidth(map)) {
1808 			map_write(map, datum, adr);
1809 			adr += map_bankwidth(map);
1810 			word_gap = 0;
1811 		}
1812 
1813 		vec_seek += n;
1814 		if (vec_seek == vec->iov_len) {
1815 			vec++;
1816 			vec_seek = 0;
1817 		}
1818 	} while (len);
1819 	*pvec = vec;
1820 	*pvec_seek = vec_seek;
1821 
1822 	/* GO GO GO */
1823 	map_write(map, CMD(0xd0), cmd_adr);
1824 	chip->state = FL_WRITING;
1825 
1826 	ret = INVAL_CACHE_AND_WAIT(map, chip, cmd_adr,
1827 				   initial_adr, initial_len,
1828 				   chip->buffer_write_time,
1829 				   chip->buffer_write_time_max);
1830 	if (ret) {
1831 		map_write(map, CMD(0x70), cmd_adr);
1832 		chip->state = FL_STATUS;
1833 		xip_enable(map, chip, cmd_adr);
1834 		printk(KERN_ERR "%s: buffer write error (status timeout)\n", map->name);
1835 		goto out;
1836 	}
1837 
1838 	/* check for errors */
1839 	status = map_read(map, cmd_adr);
1840 	if (map_word_bitsset(map, status, CMD(0x1a))) {
1841 		unsigned long chipstatus = MERGESTATUS(status);
1842 
1843 		/* reset status */
1844 		map_write(map, CMD(0x50), cmd_adr);
1845 		map_write(map, CMD(0x70), cmd_adr);
1846 		xip_enable(map, chip, cmd_adr);
1847 
1848 		if (chipstatus & 0x02) {
1849 			ret = -EROFS;
1850 		} else if (chipstatus & 0x08) {
1851 			printk(KERN_ERR "%s: buffer write error (bad VPP)\n", map->name);
1852 			ret = -EIO;
1853 		} else {
1854 			printk(KERN_ERR "%s: buffer write error (status 0x%lx)\n", map->name, chipstatus);
1855 			ret = -EINVAL;
1856 		}
1857 
1858 		goto out;
1859 	}
1860 
1861 	xip_enable(map, chip, cmd_adr);
1862  out:	DISABLE_VPP(map);
1863 	put_chip(map, chip, cmd_adr);
1864 	mutex_unlock(&chip->mutex);
1865 	return ret;
1866 }
1867 
1868 static int cfi_intelext_writev (struct mtd_info *mtd, const struct kvec *vecs,
1869 				unsigned long count, loff_t to, size_t *retlen)
1870 {
1871 	struct map_info *map = mtd->priv;
1872 	struct cfi_private *cfi = map->fldrv_priv;
1873 	int wbufsize = cfi_interleave(cfi) << cfi->cfiq->MaxBufWriteSize;
1874 	int ret;
1875 	int chipnum;
1876 	unsigned long ofs, vec_seek, i;
1877 	size_t len = 0;
1878 
1879 	for (i = 0; i < count; i++)
1880 		len += vecs[i].iov_len;
1881 
1882 	if (!len)
1883 		return 0;
1884 
1885 	chipnum = to >> cfi->chipshift;
1886 	ofs = to - (chipnum << cfi->chipshift);
1887 	vec_seek = 0;
1888 
1889 	do {
1890 		/* We must not cross write block boundaries */
1891 		int size = wbufsize - (ofs & (wbufsize-1));
1892 
1893 		if (size > len)
1894 			size = len;
1895 		ret = do_write_buffer(map, &cfi->chips[chipnum],
1896 				      ofs, &vecs, &vec_seek, size);
1897 		if (ret)
1898 			return ret;
1899 
1900 		ofs += size;
1901 		(*retlen) += size;
1902 		len -= size;
1903 
1904 		if (ofs >> cfi->chipshift) {
1905 			chipnum ++;
1906 			ofs = 0;
1907 			if (chipnum == cfi->numchips)
1908 				return 0;
1909 		}
1910 
1911 		/* Be nice and reschedule with the chip in a usable state for other
1912 		   processes. */
1913 		cond_resched();
1914 
1915 	} while (len);
1916 
1917 	return 0;
1918 }
1919 
1920 static int cfi_intelext_write_buffers (struct mtd_info *mtd, loff_t to,
1921 				       size_t len, size_t *retlen, const u_char *buf)
1922 {
1923 	struct kvec vec;
1924 
1925 	vec.iov_base = (void *) buf;
1926 	vec.iov_len = len;
1927 
1928 	return cfi_intelext_writev(mtd, &vec, 1, to, retlen);
1929 }
1930 
1931 static int __xipram do_erase_oneblock(struct map_info *map, struct flchip *chip,
1932 				      unsigned long adr, int len, void *thunk)
1933 {
1934 	struct cfi_private *cfi = map->fldrv_priv;
1935 	map_word status;
1936 	int retries = 3;
1937 	int ret;
1938 
1939 	adr += chip->start;
1940 
1941  retry:
1942 	mutex_lock(&chip->mutex);
1943 	ret = get_chip(map, chip, adr, FL_ERASING);
1944 	if (ret) {
1945 		mutex_unlock(&chip->mutex);
1946 		return ret;
1947 	}
1948 
1949 	XIP_INVAL_CACHED_RANGE(map, adr, len);
1950 	ENABLE_VPP(map);
1951 	xip_disable(map, chip, adr);
1952 
1953 	/* Clear the status register first */
1954 	map_write(map, CMD(0x50), adr);
1955 
1956 	/* Now erase */
1957 	map_write(map, CMD(0x20), adr);
1958 	map_write(map, CMD(0xD0), adr);
1959 	chip->state = FL_ERASING;
1960 	chip->erase_suspended = 0;
1961 	chip->in_progress_block_addr = adr;
1962 	chip->in_progress_block_mask = ~(len - 1);
1963 
1964 	ret = INVAL_CACHE_AND_WAIT(map, chip, adr,
1965 				   adr, len,
1966 				   chip->erase_time,
1967 				   chip->erase_time_max);
1968 	if (ret) {
1969 		map_write(map, CMD(0x70), adr);
1970 		chip->state = FL_STATUS;
1971 		xip_enable(map, chip, adr);
1972 		printk(KERN_ERR "%s: block erase error: (status timeout)\n", map->name);
1973 		goto out;
1974 	}
1975 
1976 	/* We've broken this before. It doesn't hurt to be safe */
1977 	map_write(map, CMD(0x70), adr);
1978 	chip->state = FL_STATUS;
1979 	status = map_read(map, adr);
1980 
1981 	/* check for errors */
1982 	if (map_word_bitsset(map, status, CMD(0x3a))) {
1983 		unsigned long chipstatus = MERGESTATUS(status);
1984 
1985 		/* Reset the error bits */
1986 		map_write(map, CMD(0x50), adr);
1987 		map_write(map, CMD(0x70), adr);
1988 		xip_enable(map, chip, adr);
1989 
1990 		if ((chipstatus & 0x30) == 0x30) {
1991 			printk(KERN_ERR "%s: block erase error: (bad command sequence, status 0x%lx)\n", map->name, chipstatus);
1992 			ret = -EINVAL;
1993 		} else if (chipstatus & 0x02) {
1994 			/* Protection bit set */
1995 			ret = -EROFS;
1996 		} else if (chipstatus & 0x8) {
1997 			/* Voltage */
1998 			printk(KERN_ERR "%s: block erase error: (bad VPP)\n", map->name);
1999 			ret = -EIO;
2000 		} else if (chipstatus & 0x20 && retries--) {
2001 			printk(KERN_DEBUG "block erase failed at 0x%08lx: status 0x%lx. Retrying...\n", adr, chipstatus);
2002 			DISABLE_VPP(map);
2003 			put_chip(map, chip, adr);
2004 			mutex_unlock(&chip->mutex);
2005 			goto retry;
2006 		} else {
2007 			printk(KERN_ERR "%s: block erase failed at 0x%08lx (status 0x%lx)\n", map->name, adr, chipstatus);
2008 			ret = -EIO;
2009 		}
2010 
2011 		goto out;
2012 	}
2013 
2014 	xip_enable(map, chip, adr);
2015  out:	DISABLE_VPP(map);
2016 	put_chip(map, chip, adr);
2017 	mutex_unlock(&chip->mutex);
2018 	return ret;
2019 }
2020 
2021 static int cfi_intelext_erase_varsize(struct mtd_info *mtd, struct erase_info *instr)
2022 {
2023 	return cfi_varsize_frob(mtd, do_erase_oneblock, instr->addr,
2024 				instr->len, NULL);
2025 }
2026 
2027 static void cfi_intelext_sync (struct mtd_info *mtd)
2028 {
2029 	struct map_info *map = mtd->priv;
2030 	struct cfi_private *cfi = map->fldrv_priv;
2031 	int i;
2032 	struct flchip *chip;
2033 	int ret = 0;
2034 
2035 	for (i=0; !ret && i<cfi->numchips; i++) {
2036 		chip = &cfi->chips[i];
2037 
2038 		mutex_lock(&chip->mutex);
2039 		ret = get_chip(map, chip, chip->start, FL_SYNCING);
2040 
2041 		if (!ret) {
2042 			chip->oldstate = chip->state;
2043 			chip->state = FL_SYNCING;
2044 			/* No need to wake_up() on this state change -
2045 			 * as the whole point is that nobody can do anything
2046 			 * with the chip now anyway.
2047 			 */
2048 		}
2049 		mutex_unlock(&chip->mutex);
2050 	}
2051 
2052 	/* Unlock the chips again */
2053 
2054 	for (i--; i >=0; i--) {
2055 		chip = &cfi->chips[i];
2056 
2057 		mutex_lock(&chip->mutex);
2058 
2059 		if (chip->state == FL_SYNCING) {
2060 			chip->state = chip->oldstate;
2061 			chip->oldstate = FL_READY;
2062 			wake_up(&chip->wq);
2063 		}
2064 		mutex_unlock(&chip->mutex);
2065 	}
2066 }
2067 
2068 static int __xipram do_getlockstatus_oneblock(struct map_info *map,
2069 						struct flchip *chip,
2070 						unsigned long adr,
2071 						int len, void *thunk)
2072 {
2073 	struct cfi_private *cfi = map->fldrv_priv;
2074 	int status, ofs_factor = cfi->interleave * cfi->device_type;
2075 
2076 	adr += chip->start;
2077 	xip_disable(map, chip, adr+(2*ofs_factor));
2078 	map_write(map, CMD(0x90), adr+(2*ofs_factor));
2079 	chip->state = FL_JEDEC_QUERY;
2080 	status = cfi_read_query(map, adr+(2*ofs_factor));
2081 	xip_enable(map, chip, 0);
2082 	return status;
2083 }
2084 
2085 #ifdef DEBUG_LOCK_BITS
2086 static int __xipram do_printlockstatus_oneblock(struct map_info *map,
2087 						struct flchip *chip,
2088 						unsigned long adr,
2089 						int len, void *thunk)
2090 {
2091 	printk(KERN_DEBUG "block status register for 0x%08lx is %x\n",
2092 	       adr, do_getlockstatus_oneblock(map, chip, adr, len, thunk));
2093 	return 0;
2094 }
2095 #endif
2096 
2097 #define DO_XXLOCK_ONEBLOCK_LOCK		((void *) 1)
2098 #define DO_XXLOCK_ONEBLOCK_UNLOCK	((void *) 2)
2099 
2100 static int __xipram do_xxlock_oneblock(struct map_info *map, struct flchip *chip,
2101 				       unsigned long adr, int len, void *thunk)
2102 {
2103 	struct cfi_private *cfi = map->fldrv_priv;
2104 	struct cfi_pri_intelext *extp = cfi->cmdset_priv;
2105 	int mdelay;
2106 	int ret;
2107 
2108 	adr += chip->start;
2109 
2110 	mutex_lock(&chip->mutex);
2111 	ret = get_chip(map, chip, adr, FL_LOCKING);
2112 	if (ret) {
2113 		mutex_unlock(&chip->mutex);
2114 		return ret;
2115 	}
2116 
2117 	ENABLE_VPP(map);
2118 	xip_disable(map, chip, adr);
2119 
2120 	map_write(map, CMD(0x60), adr);
2121 	if (thunk == DO_XXLOCK_ONEBLOCK_LOCK) {
2122 		map_write(map, CMD(0x01), adr);
2123 		chip->state = FL_LOCKING;
2124 	} else if (thunk == DO_XXLOCK_ONEBLOCK_UNLOCK) {
2125 		map_write(map, CMD(0xD0), adr);
2126 		chip->state = FL_UNLOCKING;
2127 	} else
2128 		BUG();
2129 
2130 	/*
2131 	 * If Instant Individual Block Locking supported then no need
2132 	 * to delay.
2133 	 */
2134 	/*
2135 	 * Unlocking may take up to 1.4 seconds on some Intel flashes. So
2136 	 * lets use a max of 1.5 seconds (1500ms) as timeout.
2137 	 *
2138 	 * See "Clear Block Lock-Bits Time" on page 40 in
2139 	 * "3 Volt Intel StrataFlash Memory" 28F128J3,28F640J3,28F320J3 manual
2140 	 * from February 2003
2141 	 */
2142 	mdelay = (!extp || !(extp->FeatureSupport & (1 << 5))) ? 1500 : 0;
2143 
2144 	ret = WAIT_TIMEOUT(map, chip, adr, mdelay, mdelay * 1000);
2145 	if (ret) {
2146 		map_write(map, CMD(0x70), adr);
2147 		chip->state = FL_STATUS;
2148 		xip_enable(map, chip, adr);
2149 		printk(KERN_ERR "%s: block unlock error: (status timeout)\n", map->name);
2150 		goto out;
2151 	}
2152 
2153 	xip_enable(map, chip, adr);
2154  out:	DISABLE_VPP(map);
2155 	put_chip(map, chip, adr);
2156 	mutex_unlock(&chip->mutex);
2157 	return ret;
2158 }
2159 
2160 static int cfi_intelext_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
2161 {
2162 	int ret;
2163 
2164 #ifdef DEBUG_LOCK_BITS
2165 	printk(KERN_DEBUG "%s: lock status before, ofs=0x%08llx, len=0x%08X\n",
2166 	       __func__, ofs, len);
2167 	cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
2168 		ofs, len, NULL);
2169 #endif
2170 
2171 	ret = cfi_varsize_frob(mtd, do_xxlock_oneblock,
2172 		ofs, len, DO_XXLOCK_ONEBLOCK_LOCK);
2173 
2174 #ifdef DEBUG_LOCK_BITS
2175 	printk(KERN_DEBUG "%s: lock status after, ret=%d\n",
2176 	       __func__, ret);
2177 	cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
2178 		ofs, len, NULL);
2179 #endif
2180 
2181 	return ret;
2182 }
2183 
2184 static int cfi_intelext_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
2185 {
2186 	int ret;
2187 
2188 #ifdef DEBUG_LOCK_BITS
2189 	printk(KERN_DEBUG "%s: lock status before, ofs=0x%08llx, len=0x%08X\n",
2190 	       __func__, ofs, len);
2191 	cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
2192 		ofs, len, NULL);
2193 #endif
2194 
2195 	ret = cfi_varsize_frob(mtd, do_xxlock_oneblock,
2196 					ofs, len, DO_XXLOCK_ONEBLOCK_UNLOCK);
2197 
2198 #ifdef DEBUG_LOCK_BITS
2199 	printk(KERN_DEBUG "%s: lock status after, ret=%d\n",
2200 	       __func__, ret);
2201 	cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
2202 		ofs, len, NULL);
2203 #endif
2204 
2205 	return ret;
2206 }
2207 
2208 static int cfi_intelext_is_locked(struct mtd_info *mtd, loff_t ofs,
2209 				  uint64_t len)
2210 {
2211 	return cfi_varsize_frob(mtd, do_getlockstatus_oneblock,
2212 				ofs, len, NULL) ? 1 : 0;
2213 }
2214 
2215 #ifdef CONFIG_MTD_OTP
2216 
2217 typedef int (*otp_op_t)(struct map_info *map, struct flchip *chip,
2218 			u_long data_offset, u_char *buf, u_int size,
2219 			u_long prot_offset, u_int groupno, u_int groupsize);
2220 
2221 static int __xipram
2222 do_otp_read(struct map_info *map, struct flchip *chip, u_long offset,
2223 	    u_char *buf, u_int size, u_long prot, u_int grpno, u_int grpsz)
2224 {
2225 	struct cfi_private *cfi = map->fldrv_priv;
2226 	int ret;
2227 
2228 	mutex_lock(&chip->mutex);
2229 	ret = get_chip(map, chip, chip->start, FL_JEDEC_QUERY);
2230 	if (ret) {
2231 		mutex_unlock(&chip->mutex);
2232 		return ret;
2233 	}
2234 
2235 	/* let's ensure we're not reading back cached data from array mode */
2236 	INVALIDATE_CACHED_RANGE(map, chip->start + offset, size);
2237 
2238 	xip_disable(map, chip, chip->start);
2239 	if (chip->state != FL_JEDEC_QUERY) {
2240 		map_write(map, CMD(0x90), chip->start);
2241 		chip->state = FL_JEDEC_QUERY;
2242 	}
2243 	map_copy_from(map, buf, chip->start + offset, size);
2244 	xip_enable(map, chip, chip->start);
2245 
2246 	/* then ensure we don't keep OTP data in the cache */
2247 	INVALIDATE_CACHED_RANGE(map, chip->start + offset, size);
2248 
2249 	put_chip(map, chip, chip->start);
2250 	mutex_unlock(&chip->mutex);
2251 	return 0;
2252 }
2253 
2254 static int
2255 do_otp_write(struct map_info *map, struct flchip *chip, u_long offset,
2256 	     u_char *buf, u_int size, u_long prot, u_int grpno, u_int grpsz)
2257 {
2258 	int ret;
2259 
2260 	while (size) {
2261 		unsigned long bus_ofs = offset & ~(map_bankwidth(map)-1);
2262 		int gap = offset - bus_ofs;
2263 		int n = min_t(int, size, map_bankwidth(map)-gap);
2264 		map_word datum = map_word_ff(map);
2265 
2266 		datum = map_word_load_partial(map, datum, buf, gap, n);
2267 		ret = do_write_oneword(map, chip, bus_ofs, datum, FL_OTP_WRITE);
2268 		if (ret)
2269 			return ret;
2270 
2271 		offset += n;
2272 		buf += n;
2273 		size -= n;
2274 	}
2275 
2276 	return 0;
2277 }
2278 
2279 static int
2280 do_otp_lock(struct map_info *map, struct flchip *chip, u_long offset,
2281 	    u_char *buf, u_int size, u_long prot, u_int grpno, u_int grpsz)
2282 {
2283 	struct cfi_private *cfi = map->fldrv_priv;
2284 	map_word datum;
2285 
2286 	/* make sure area matches group boundaries */
2287 	if (size != grpsz)
2288 		return -EXDEV;
2289 
2290 	datum = map_word_ff(map);
2291 	datum = map_word_clr(map, datum, CMD(1 << grpno));
2292 	return do_write_oneword(map, chip, prot, datum, FL_OTP_WRITE);
2293 }
2294 
2295 static int cfi_intelext_otp_walk(struct mtd_info *mtd, loff_t from, size_t len,
2296 				 size_t *retlen, u_char *buf,
2297 				 otp_op_t action, int user_regs)
2298 {
2299 	struct map_info *map = mtd->priv;
2300 	struct cfi_private *cfi = map->fldrv_priv;
2301 	struct cfi_pri_intelext *extp = cfi->cmdset_priv;
2302 	struct flchip *chip;
2303 	struct cfi_intelext_otpinfo *otp;
2304 	u_long devsize, reg_prot_offset, data_offset;
2305 	u_int chip_num, chip_step, field, reg_fact_size, reg_user_size;
2306 	u_int groups, groupno, groupsize, reg_fact_groups, reg_user_groups;
2307 	int ret;
2308 
2309 	*retlen = 0;
2310 
2311 	/* Check that we actually have some OTP registers */
2312 	if (!extp || !(extp->FeatureSupport & 64) || !extp->NumProtectionFields)
2313 		return -ENODATA;
2314 
2315 	/* we need real chips here not virtual ones */
2316 	devsize = (1 << cfi->cfiq->DevSize) * cfi->interleave;
2317 	chip_step = devsize >> cfi->chipshift;
2318 	chip_num = 0;
2319 
2320 	/* Some chips have OTP located in the _top_ partition only.
2321 	   For example: Intel 28F256L18T (T means top-parameter device) */
2322 	if (cfi->mfr == CFI_MFR_INTEL) {
2323 		switch (cfi->id) {
2324 		case 0x880b:
2325 		case 0x880c:
2326 		case 0x880d:
2327 			chip_num = chip_step - 1;
2328 		}
2329 	}
2330 
2331 	for ( ; chip_num < cfi->numchips; chip_num += chip_step) {
2332 		chip = &cfi->chips[chip_num];
2333 		otp = (struct cfi_intelext_otpinfo *)&extp->extra[0];
2334 
2335 		/* first OTP region */
2336 		field = 0;
2337 		reg_prot_offset = extp->ProtRegAddr;
2338 		reg_fact_groups = 1;
2339 		reg_fact_size = 1 << extp->FactProtRegSize;
2340 		reg_user_groups = 1;
2341 		reg_user_size = 1 << extp->UserProtRegSize;
2342 
2343 		while (len > 0) {
2344 			/* flash geometry fixup */
2345 			data_offset = reg_prot_offset + 1;
2346 			data_offset *= cfi->interleave * cfi->device_type;
2347 			reg_prot_offset *= cfi->interleave * cfi->device_type;
2348 			reg_fact_size *= cfi->interleave;
2349 			reg_user_size *= cfi->interleave;
2350 
2351 			if (user_regs) {
2352 				groups = reg_user_groups;
2353 				groupsize = reg_user_size;
2354 				/* skip over factory reg area */
2355 				groupno = reg_fact_groups;
2356 				data_offset += reg_fact_groups * reg_fact_size;
2357 			} else {
2358 				groups = reg_fact_groups;
2359 				groupsize = reg_fact_size;
2360 				groupno = 0;
2361 			}
2362 
2363 			while (len > 0 && groups > 0) {
2364 				if (!action) {
2365 					/*
2366 					 * Special case: if action is NULL
2367 					 * we fill buf with otp_info records.
2368 					 */
2369 					struct otp_info *otpinfo;
2370 					map_word lockword;
2371 					len -= sizeof(struct otp_info);
2372 					if (len <= 0)
2373 						return -ENOSPC;
2374 					ret = do_otp_read(map, chip,
2375 							  reg_prot_offset,
2376 							  (u_char *)&lockword,
2377 							  map_bankwidth(map),
2378 							  0, 0,  0);
2379 					if (ret)
2380 						return ret;
2381 					otpinfo = (struct otp_info *)buf;
2382 					otpinfo->start = from;
2383 					otpinfo->length = groupsize;
2384 					otpinfo->locked =
2385 					   !map_word_bitsset(map, lockword,
2386 							     CMD(1 << groupno));
2387 					from += groupsize;
2388 					buf += sizeof(*otpinfo);
2389 					*retlen += sizeof(*otpinfo);
2390 				} else if (from >= groupsize) {
2391 					from -= groupsize;
2392 					data_offset += groupsize;
2393 				} else {
2394 					int size = groupsize;
2395 					data_offset += from;
2396 					size -= from;
2397 					from = 0;
2398 					if (size > len)
2399 						size = len;
2400 					ret = action(map, chip, data_offset,
2401 						     buf, size, reg_prot_offset,
2402 						     groupno, groupsize);
2403 					if (ret < 0)
2404 						return ret;
2405 					buf += size;
2406 					len -= size;
2407 					*retlen += size;
2408 					data_offset += size;
2409 				}
2410 				groupno++;
2411 				groups--;
2412 			}
2413 
2414 			/* next OTP region */
2415 			if (++field == extp->NumProtectionFields)
2416 				break;
2417 			reg_prot_offset = otp->ProtRegAddr;
2418 			reg_fact_groups = otp->FactGroups;
2419 			reg_fact_size = 1 << otp->FactProtRegSize;
2420 			reg_user_groups = otp->UserGroups;
2421 			reg_user_size = 1 << otp->UserProtRegSize;
2422 			otp++;
2423 		}
2424 	}
2425 
2426 	return 0;
2427 }
2428 
2429 static int cfi_intelext_read_fact_prot_reg(struct mtd_info *mtd, loff_t from,
2430 					   size_t len, size_t *retlen,
2431 					    u_char *buf)
2432 {
2433 	return cfi_intelext_otp_walk(mtd, from, len, retlen,
2434 				     buf, do_otp_read, 0);
2435 }
2436 
2437 static int cfi_intelext_read_user_prot_reg(struct mtd_info *mtd, loff_t from,
2438 					   size_t len, size_t *retlen,
2439 					    u_char *buf)
2440 {
2441 	return cfi_intelext_otp_walk(mtd, from, len, retlen,
2442 				     buf, do_otp_read, 1);
2443 }
2444 
2445 static int cfi_intelext_write_user_prot_reg(struct mtd_info *mtd, loff_t from,
2446 					    size_t len, size_t *retlen,
2447 					     u_char *buf)
2448 {
2449 	return cfi_intelext_otp_walk(mtd, from, len, retlen,
2450 				     buf, do_otp_write, 1);
2451 }
2452 
2453 static int cfi_intelext_lock_user_prot_reg(struct mtd_info *mtd,
2454 					   loff_t from, size_t len)
2455 {
2456 	size_t retlen;
2457 	return cfi_intelext_otp_walk(mtd, from, len, &retlen,
2458 				     NULL, do_otp_lock, 1);
2459 }
2460 
2461 static int cfi_intelext_get_fact_prot_info(struct mtd_info *mtd, size_t len,
2462 					   size_t *retlen, struct otp_info *buf)
2463 
2464 {
2465 	return cfi_intelext_otp_walk(mtd, 0, len, retlen, (u_char *)buf,
2466 				     NULL, 0);
2467 }
2468 
2469 static int cfi_intelext_get_user_prot_info(struct mtd_info *mtd, size_t len,
2470 					   size_t *retlen, struct otp_info *buf)
2471 {
2472 	return cfi_intelext_otp_walk(mtd, 0, len, retlen, (u_char *)buf,
2473 				     NULL, 1);
2474 }
2475 
2476 #endif
2477 
2478 static void cfi_intelext_save_locks(struct mtd_info *mtd)
2479 {
2480 	struct mtd_erase_region_info *region;
2481 	int block, status, i;
2482 	unsigned long adr;
2483 	size_t len;
2484 
2485 	for (i = 0; i < mtd->numeraseregions; i++) {
2486 		region = &mtd->eraseregions[i];
2487 		if (!region->lockmap)
2488 			continue;
2489 
2490 		for (block = 0; block < region->numblocks; block++){
2491 			len = region->erasesize;
2492 			adr = region->offset + block * len;
2493 
2494 			status = cfi_varsize_frob(mtd,
2495 					do_getlockstatus_oneblock, adr, len, NULL);
2496 			if (status)
2497 				set_bit(block, region->lockmap);
2498 			else
2499 				clear_bit(block, region->lockmap);
2500 		}
2501 	}
2502 }
2503 
2504 static int cfi_intelext_suspend(struct mtd_info *mtd)
2505 {
2506 	struct map_info *map = mtd->priv;
2507 	struct cfi_private *cfi = map->fldrv_priv;
2508 	struct cfi_pri_intelext *extp = cfi->cmdset_priv;
2509 	int i;
2510 	struct flchip *chip;
2511 	int ret = 0;
2512 
2513 	if ((mtd->flags & MTD_POWERUP_LOCK)
2514 	    && extp && (extp->FeatureSupport & (1 << 5)))
2515 		cfi_intelext_save_locks(mtd);
2516 
2517 	for (i=0; !ret && i<cfi->numchips; i++) {
2518 		chip = &cfi->chips[i];
2519 
2520 		mutex_lock(&chip->mutex);
2521 
2522 		switch (chip->state) {
2523 		case FL_READY:
2524 		case FL_STATUS:
2525 		case FL_CFI_QUERY:
2526 		case FL_JEDEC_QUERY:
2527 			if (chip->oldstate == FL_READY) {
2528 				/* place the chip in a known state before suspend */
2529 				map_write(map, CMD(0xFF), cfi->chips[i].start);
2530 				chip->oldstate = chip->state;
2531 				chip->state = FL_PM_SUSPENDED;
2532 				/* No need to wake_up() on this state change -
2533 				 * as the whole point is that nobody can do anything
2534 				 * with the chip now anyway.
2535 				 */
2536 			} else {
2537 				/* There seems to be an operation pending. We must wait for it. */
2538 				printk(KERN_NOTICE "Flash device refused suspend due to pending operation (oldstate %d)\n", chip->oldstate);
2539 				ret = -EAGAIN;
2540 			}
2541 			break;
2542 		default:
2543 			/* Should we actually wait? Once upon a time these routines weren't
2544 			   allowed to. Or should we return -EAGAIN, because the upper layers
2545 			   ought to have already shut down anything which was using the device
2546 			   anyway? The latter for now. */
2547 			printk(KERN_NOTICE "Flash device refused suspend due to active operation (state %d)\n", chip->state);
2548 			ret = -EAGAIN;
2549 		case FL_PM_SUSPENDED:
2550 			break;
2551 		}
2552 		mutex_unlock(&chip->mutex);
2553 	}
2554 
2555 	/* Unlock the chips again */
2556 
2557 	if (ret) {
2558 		for (i--; i >=0; i--) {
2559 			chip = &cfi->chips[i];
2560 
2561 			mutex_lock(&chip->mutex);
2562 
2563 			if (chip->state == FL_PM_SUSPENDED) {
2564 				/* No need to force it into a known state here,
2565 				   because we're returning failure, and it didn't
2566 				   get power cycled */
2567 				chip->state = chip->oldstate;
2568 				chip->oldstate = FL_READY;
2569 				wake_up(&chip->wq);
2570 			}
2571 			mutex_unlock(&chip->mutex);
2572 		}
2573 	}
2574 
2575 	return ret;
2576 }
2577 
2578 static void cfi_intelext_restore_locks(struct mtd_info *mtd)
2579 {
2580 	struct mtd_erase_region_info *region;
2581 	int block, i;
2582 	unsigned long adr;
2583 	size_t len;
2584 
2585 	for (i = 0; i < mtd->numeraseregions; i++) {
2586 		region = &mtd->eraseregions[i];
2587 		if (!region->lockmap)
2588 			continue;
2589 
2590 		for_each_clear_bit(block, region->lockmap, region->numblocks) {
2591 			len = region->erasesize;
2592 			adr = region->offset + block * len;
2593 			cfi_intelext_unlock(mtd, adr, len);
2594 		}
2595 	}
2596 }
2597 
2598 static void cfi_intelext_resume(struct mtd_info *mtd)
2599 {
2600 	struct map_info *map = mtd->priv;
2601 	struct cfi_private *cfi = map->fldrv_priv;
2602 	struct cfi_pri_intelext *extp = cfi->cmdset_priv;
2603 	int i;
2604 	struct flchip *chip;
2605 
2606 	for (i=0; i<cfi->numchips; i++) {
2607 
2608 		chip = &cfi->chips[i];
2609 
2610 		mutex_lock(&chip->mutex);
2611 
2612 		/* Go to known state. Chip may have been power cycled */
2613 		if (chip->state == FL_PM_SUSPENDED) {
2614 			/* Refresh LH28F640BF Partition Config. Register */
2615 			fixup_LH28F640BF(mtd);
2616 			map_write(map, CMD(0xFF), cfi->chips[i].start);
2617 			chip->oldstate = chip->state = FL_READY;
2618 			wake_up(&chip->wq);
2619 		}
2620 
2621 		mutex_unlock(&chip->mutex);
2622 	}
2623 
2624 	if ((mtd->flags & MTD_POWERUP_LOCK)
2625 	    && extp && (extp->FeatureSupport & (1 << 5)))
2626 		cfi_intelext_restore_locks(mtd);
2627 }
2628 
2629 static int cfi_intelext_reset(struct mtd_info *mtd)
2630 {
2631 	struct map_info *map = mtd->priv;
2632 	struct cfi_private *cfi = map->fldrv_priv;
2633 	int i, ret;
2634 
2635 	for (i=0; i < cfi->numchips; i++) {
2636 		struct flchip *chip = &cfi->chips[i];
2637 
2638 		/* force the completion of any ongoing operation
2639 		   and switch to array mode so any bootloader in
2640 		   flash is accessible for soft reboot. */
2641 		mutex_lock(&chip->mutex);
2642 		ret = get_chip(map, chip, chip->start, FL_SHUTDOWN);
2643 		if (!ret) {
2644 			map_write(map, CMD(0xff), chip->start);
2645 			chip->state = FL_SHUTDOWN;
2646 			put_chip(map, chip, chip->start);
2647 		}
2648 		mutex_unlock(&chip->mutex);
2649 	}
2650 
2651 	return 0;
2652 }
2653 
2654 static int cfi_intelext_reboot(struct notifier_block *nb, unsigned long val,
2655 			       void *v)
2656 {
2657 	struct mtd_info *mtd;
2658 
2659 	mtd = container_of(nb, struct mtd_info, reboot_notifier);
2660 	cfi_intelext_reset(mtd);
2661 	return NOTIFY_DONE;
2662 }
2663 
2664 static void cfi_intelext_destroy(struct mtd_info *mtd)
2665 {
2666 	struct map_info *map = mtd->priv;
2667 	struct cfi_private *cfi = map->fldrv_priv;
2668 	struct mtd_erase_region_info *region;
2669 	int i;
2670 	cfi_intelext_reset(mtd);
2671 	unregister_reboot_notifier(&mtd->reboot_notifier);
2672 	kfree(cfi->cmdset_priv);
2673 	kfree(cfi->cfiq);
2674 	kfree(cfi->chips[0].priv);
2675 	kfree(cfi);
2676 	for (i = 0; i < mtd->numeraseregions; i++) {
2677 		region = &mtd->eraseregions[i];
2678 		kfree(region->lockmap);
2679 	}
2680 	kfree(mtd->eraseregions);
2681 }
2682 
2683 MODULE_LICENSE("GPL");
2684 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org> et al.");
2685 MODULE_DESCRIPTION("MTD chip driver for Intel/Sharp flash chips");
2686 MODULE_ALIAS("cfi_cmdset_0003");
2687 MODULE_ALIAS("cfi_cmdset_0200");
2688