1 /*
2  * Common Flash Interface support:
3  *   ST Advanced Architecture Command Set (ID 0x0020)
4  *
5  * (C) 2000 Red Hat. GPL'd
6  *
7  * 10/10/2000	Nicolas Pitre <nico@fluxnic.net>
8  * 	- completely revamped method functions so they are aware and
9  * 	  independent of the flash geometry (buswidth, interleave, etc.)
10  * 	- scalability vs code size is completely set at compile-time
11  * 	  (see include/linux/mtd/cfi.h for selection)
12  *	- optimized write buffer method
13  * 06/21/2002	Joern Engel <joern@wh.fh-wedel.de> and others
14  *	- modified Intel Command Set 0x0001 to support ST Advanced Architecture
15  *	  (command set 0x0020)
16  *	- added a writev function
17  * 07/13/2005	Joern Engel <joern@wh.fh-wedel.de>
18  * 	- Plugged memory leak in cfi_staa_writev().
19  */
20 
21 #include <linux/module.h>
22 #include <linux/types.h>
23 #include <linux/kernel.h>
24 #include <linux/sched.h>
25 #include <linux/init.h>
26 #include <asm/io.h>
27 #include <asm/byteorder.h>
28 
29 #include <linux/errno.h>
30 #include <linux/slab.h>
31 #include <linux/delay.h>
32 #include <linux/interrupt.h>
33 #include <linux/mtd/map.h>
34 #include <linux/mtd/cfi.h>
35 #include <linux/mtd/mtd.h>
36 
37 
38 static int cfi_staa_read(struct mtd_info *, loff_t, size_t, size_t *, u_char *);
39 static int cfi_staa_write_buffers(struct mtd_info *, loff_t, size_t, size_t *, const u_char *);
40 static int cfi_staa_writev(struct mtd_info *mtd, const struct kvec *vecs,
41 		unsigned long count, loff_t to, size_t *retlen);
42 static int cfi_staa_erase_varsize(struct mtd_info *, struct erase_info *);
43 static void cfi_staa_sync (struct mtd_info *);
44 static int cfi_staa_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len);
45 static int cfi_staa_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len);
46 static int cfi_staa_suspend (struct mtd_info *);
47 static void cfi_staa_resume (struct mtd_info *);
48 
49 static void cfi_staa_destroy(struct mtd_info *);
50 
51 struct mtd_info *cfi_cmdset_0020(struct map_info *, int);
52 
53 static struct mtd_info *cfi_staa_setup (struct map_info *);
54 
55 static struct mtd_chip_driver cfi_staa_chipdrv = {
56 	.probe		= NULL, /* Not usable directly */
57 	.destroy	= cfi_staa_destroy,
58 	.name		= "cfi_cmdset_0020",
59 	.module		= THIS_MODULE
60 };
61 
62 /* #define DEBUG_LOCK_BITS */
63 //#define DEBUG_CFI_FEATURES
64 
65 #ifdef DEBUG_CFI_FEATURES
cfi_tell_features(struct cfi_pri_intelext * extp)66 static void cfi_tell_features(struct cfi_pri_intelext *extp)
67 {
68         int i;
69         printk("  Feature/Command Support: %4.4X\n", extp->FeatureSupport);
70 	printk("     - Chip Erase:         %s\n", extp->FeatureSupport&1?"supported":"unsupported");
71 	printk("     - Suspend Erase:      %s\n", extp->FeatureSupport&2?"supported":"unsupported");
72 	printk("     - Suspend Program:    %s\n", extp->FeatureSupport&4?"supported":"unsupported");
73 	printk("     - Legacy Lock/Unlock: %s\n", extp->FeatureSupport&8?"supported":"unsupported");
74 	printk("     - Queued Erase:       %s\n", extp->FeatureSupport&16?"supported":"unsupported");
75 	printk("     - Instant block lock: %s\n", extp->FeatureSupport&32?"supported":"unsupported");
76 	printk("     - Protection Bits:    %s\n", extp->FeatureSupport&64?"supported":"unsupported");
77 	printk("     - Page-mode read:     %s\n", extp->FeatureSupport&128?"supported":"unsupported");
78 	printk("     - Synchronous read:   %s\n", extp->FeatureSupport&256?"supported":"unsupported");
79 	for (i=9; i<32; i++) {
80 		if (extp->FeatureSupport & (1<<i))
81 			printk("     - Unknown Bit %X:      supported\n", i);
82 	}
83 
84 	printk("  Supported functions after Suspend: %2.2X\n", extp->SuspendCmdSupport);
85 	printk("     - Program after Erase Suspend: %s\n", extp->SuspendCmdSupport&1?"supported":"unsupported");
86 	for (i=1; i<8; i++) {
87 		if (extp->SuspendCmdSupport & (1<<i))
88 			printk("     - Unknown Bit %X:               supported\n", i);
89 	}
90 
91 	printk("  Block Status Register Mask: %4.4X\n", extp->BlkStatusRegMask);
92 	printk("     - Lock Bit Active:      %s\n", extp->BlkStatusRegMask&1?"yes":"no");
93 	printk("     - Valid Bit Active:     %s\n", extp->BlkStatusRegMask&2?"yes":"no");
94 	for (i=2; i<16; i++) {
95 		if (extp->BlkStatusRegMask & (1<<i))
96 			printk("     - Unknown Bit %X Active: yes\n",i);
97 	}
98 
99 	printk("  Vcc Logic Supply Optimum Program/Erase Voltage: %d.%d V\n",
100 	       extp->VccOptimal >> 8, extp->VccOptimal & 0xf);
101 	if (extp->VppOptimal)
102 		printk("  Vpp Programming Supply Optimum Program/Erase Voltage: %d.%d V\n",
103 		       extp->VppOptimal >> 8, extp->VppOptimal & 0xf);
104 }
105 #endif
106 
107 /* This routine is made available to other mtd code via
108  * inter_module_register.  It must only be accessed through
109  * inter_module_get which will bump the use count of this module.  The
110  * addresses passed back in cfi are valid as long as the use count of
111  * this module is non-zero, i.e. between inter_module_get and
112  * inter_module_put.  Keith Owens <kaos@ocs.com.au> 29 Oct 2000.
113  */
cfi_cmdset_0020(struct map_info * map,int primary)114 struct mtd_info *cfi_cmdset_0020(struct map_info *map, int primary)
115 {
116 	struct cfi_private *cfi = map->fldrv_priv;
117 	int i;
118 
119 	if (cfi->cfi_mode) {
120 		/*
121 		 * It's a real CFI chip, not one for which the probe
122 		 * routine faked a CFI structure. So we read the feature
123 		 * table from it.
124 		 */
125 		__u16 adr = primary?cfi->cfiq->P_ADR:cfi->cfiq->A_ADR;
126 		struct cfi_pri_intelext *extp;
127 
128 		extp = (struct cfi_pri_intelext*)cfi_read_pri(map, adr, sizeof(*extp), "ST Microelectronics");
129 		if (!extp)
130 			return NULL;
131 
132 		if (extp->MajorVersion != '1' ||
133 		    (extp->MinorVersion < '0' || extp->MinorVersion > '3')) {
134 			printk(KERN_ERR "  Unknown ST Microelectronics"
135 			       " Extended Query version %c.%c.\n",
136 			       extp->MajorVersion, extp->MinorVersion);
137 			kfree(extp);
138 			return NULL;
139 		}
140 
141 		/* Do some byteswapping if necessary */
142 		extp->FeatureSupport = cfi32_to_cpu(map, extp->FeatureSupport);
143 		extp->BlkStatusRegMask = cfi32_to_cpu(map,
144 						extp->BlkStatusRegMask);
145 
146 #ifdef DEBUG_CFI_FEATURES
147 		/* Tell the user about it in lots of lovely detail */
148 		cfi_tell_features(extp);
149 #endif
150 
151 		/* Install our own private info structure */
152 		cfi->cmdset_priv = extp;
153 	}
154 
155 	for (i=0; i< cfi->numchips; i++) {
156 		cfi->chips[i].word_write_time = 128;
157 		cfi->chips[i].buffer_write_time = 128;
158 		cfi->chips[i].erase_time = 1024;
159 		cfi->chips[i].ref_point_counter = 0;
160 		init_waitqueue_head(&(cfi->chips[i].wq));
161 	}
162 
163 	return cfi_staa_setup(map);
164 }
165 EXPORT_SYMBOL_GPL(cfi_cmdset_0020);
166 
cfi_staa_setup(struct map_info * map)167 static struct mtd_info *cfi_staa_setup(struct map_info *map)
168 {
169 	struct cfi_private *cfi = map->fldrv_priv;
170 	struct mtd_info *mtd;
171 	unsigned long offset = 0;
172 	int i,j;
173 	unsigned long devsize = (1<<cfi->cfiq->DevSize) * cfi->interleave;
174 
175 	mtd = kzalloc(sizeof(*mtd), GFP_KERNEL);
176 	//printk(KERN_DEBUG "number of CFI chips: %d\n", cfi->numchips);
177 
178 	if (!mtd) {
179 		printk(KERN_ERR "Failed to allocate memory for MTD device\n");
180 		kfree(cfi->cmdset_priv);
181 		return NULL;
182 	}
183 
184 	mtd->priv = map;
185 	mtd->type = MTD_NORFLASH;
186 	mtd->size = devsize * cfi->numchips;
187 
188 	mtd->numeraseregions = cfi->cfiq->NumEraseRegions * cfi->numchips;
189 	mtd->eraseregions = kmalloc(sizeof(struct mtd_erase_region_info)
190 			* mtd->numeraseregions, GFP_KERNEL);
191 	if (!mtd->eraseregions) {
192 		printk(KERN_ERR "Failed to allocate memory for MTD erase region info\n");
193 		kfree(cfi->cmdset_priv);
194 		kfree(mtd);
195 		return NULL;
196 	}
197 
198 	for (i=0; i<cfi->cfiq->NumEraseRegions; i++) {
199 		unsigned long ernum, ersize;
200 		ersize = ((cfi->cfiq->EraseRegionInfo[i] >> 8) & ~0xff) * cfi->interleave;
201 		ernum = (cfi->cfiq->EraseRegionInfo[i] & 0xffff) + 1;
202 
203 		if (mtd->erasesize < ersize) {
204 			mtd->erasesize = ersize;
205 		}
206 		for (j=0; j<cfi->numchips; j++) {
207 			mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].offset = (j*devsize)+offset;
208 			mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].erasesize = ersize;
209 			mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].numblocks = ernum;
210 		}
211 		offset += (ersize * ernum);
212 		}
213 
214 		if (offset != devsize) {
215 			/* Argh */
216 			printk(KERN_WARNING "Sum of regions (%lx) != total size of set of interleaved chips (%lx)\n", offset, devsize);
217 			kfree(mtd->eraseregions);
218 			kfree(cfi->cmdset_priv);
219 			kfree(mtd);
220 			return NULL;
221 		}
222 
223 		for (i=0; i<mtd->numeraseregions;i++){
224 			printk(KERN_DEBUG "%d: offset=0x%llx,size=0x%x,blocks=%d\n",
225 			       i, (unsigned long long)mtd->eraseregions[i].offset,
226 			       mtd->eraseregions[i].erasesize,
227 			       mtd->eraseregions[i].numblocks);
228 		}
229 
230 	/* Also select the correct geometry setup too */
231 	mtd->erase = cfi_staa_erase_varsize;
232 	mtd->read = cfi_staa_read;
233         mtd->write = cfi_staa_write_buffers;
234 	mtd->writev = cfi_staa_writev;
235 	mtd->sync = cfi_staa_sync;
236 	mtd->lock = cfi_staa_lock;
237 	mtd->unlock = cfi_staa_unlock;
238 	mtd->suspend = cfi_staa_suspend;
239 	mtd->resume = cfi_staa_resume;
240 	mtd->flags = MTD_CAP_NORFLASH & ~MTD_BIT_WRITEABLE;
241 	mtd->writesize = 8; /* FIXME: Should be 0 for STMicro flashes w/out ECC */
242 	mtd->writebufsize = cfi_interleave(cfi) << cfi->cfiq->MaxBufWriteSize;
243 	map->fldrv = &cfi_staa_chipdrv;
244 	__module_get(THIS_MODULE);
245 	mtd->name = map->name;
246 	return mtd;
247 }
248 
249 
do_read_onechip(struct map_info * map,struct flchip * chip,loff_t adr,size_t len,u_char * buf)250 static inline int do_read_onechip(struct map_info *map, struct flchip *chip, loff_t adr, size_t len, u_char *buf)
251 {
252 	map_word status, status_OK;
253 	unsigned long timeo;
254 	DECLARE_WAITQUEUE(wait, current);
255 	int suspended = 0;
256 	unsigned long cmd_addr;
257 	struct cfi_private *cfi = map->fldrv_priv;
258 
259 	adr += chip->start;
260 
261 	/* Ensure cmd read/writes are aligned. */
262 	cmd_addr = adr & ~(map_bankwidth(map)-1);
263 
264 	/* Let's determine this according to the interleave only once */
265 	status_OK = CMD(0x80);
266 
267 	timeo = jiffies + HZ;
268  retry:
269 	mutex_lock(&chip->mutex);
270 
271 	/* Check that the chip's ready to talk to us.
272 	 * If it's in FL_ERASING state, suspend it and make it talk now.
273 	 */
274 	switch (chip->state) {
275 	case FL_ERASING:
276 		if (!(((struct cfi_pri_intelext *)cfi->cmdset_priv)->FeatureSupport & 2))
277 			goto sleep; /* We don't support erase suspend */
278 
279 		map_write (map, CMD(0xb0), cmd_addr);
280 		/* If the flash has finished erasing, then 'erase suspend'
281 		 * appears to make some (28F320) flash devices switch to
282 		 * 'read' mode.  Make sure that we switch to 'read status'
283 		 * mode so we get the right data. --rmk
284 		 */
285 		map_write(map, CMD(0x70), cmd_addr);
286 		chip->oldstate = FL_ERASING;
287 		chip->state = FL_ERASE_SUSPENDING;
288 		//		printk("Erase suspending at 0x%lx\n", cmd_addr);
289 		for (;;) {
290 			status = map_read(map, cmd_addr);
291 			if (map_word_andequal(map, status, status_OK, status_OK))
292 				break;
293 
294 			if (time_after(jiffies, timeo)) {
295 				/* Urgh */
296 				map_write(map, CMD(0xd0), cmd_addr);
297 				/* make sure we're in 'read status' mode */
298 				map_write(map, CMD(0x70), cmd_addr);
299 				chip->state = FL_ERASING;
300 				wake_up(&chip->wq);
301 				mutex_unlock(&chip->mutex);
302 				printk(KERN_ERR "Chip not ready after erase "
303 				       "suspended: status = 0x%lx\n", status.x[0]);
304 				return -EIO;
305 			}
306 
307 			mutex_unlock(&chip->mutex);
308 			cfi_udelay(1);
309 			mutex_lock(&chip->mutex);
310 		}
311 
312 		suspended = 1;
313 		map_write(map, CMD(0xff), cmd_addr);
314 		chip->state = FL_READY;
315 		break;
316 
317 #if 0
318 	case FL_WRITING:
319 		/* Not quite yet */
320 #endif
321 
322 	case FL_READY:
323 		break;
324 
325 	case FL_CFI_QUERY:
326 	case FL_JEDEC_QUERY:
327 		map_write(map, CMD(0x70), cmd_addr);
328 		chip->state = FL_STATUS;
329 
330 	case FL_STATUS:
331 		status = map_read(map, cmd_addr);
332 		if (map_word_andequal(map, status, status_OK, status_OK)) {
333 			map_write(map, CMD(0xff), cmd_addr);
334 			chip->state = FL_READY;
335 			break;
336 		}
337 
338 		/* Urgh. Chip not yet ready to talk to us. */
339 		if (time_after(jiffies, timeo)) {
340 			mutex_unlock(&chip->mutex);
341 			printk(KERN_ERR "waiting for chip to be ready timed out in read. WSM status = %lx\n", status.x[0]);
342 			return -EIO;
343 		}
344 
345 		/* Latency issues. Drop the lock, wait a while and retry */
346 		mutex_unlock(&chip->mutex);
347 		cfi_udelay(1);
348 		goto retry;
349 
350 	default:
351 	sleep:
352 		/* Stick ourselves on a wait queue to be woken when
353 		   someone changes the status */
354 		set_current_state(TASK_UNINTERRUPTIBLE);
355 		add_wait_queue(&chip->wq, &wait);
356 		mutex_unlock(&chip->mutex);
357 		schedule();
358 		remove_wait_queue(&chip->wq, &wait);
359 		timeo = jiffies + HZ;
360 		goto retry;
361 	}
362 
363 	map_copy_from(map, buf, adr, len);
364 
365 	if (suspended) {
366 		chip->state = chip->oldstate;
367 		/* What if one interleaved chip has finished and the
368 		   other hasn't? The old code would leave the finished
369 		   one in READY mode. That's bad, and caused -EROFS
370 		   errors to be returned from do_erase_oneblock because
371 		   that's the only bit it checked for at the time.
372 		   As the state machine appears to explicitly allow
373 		   sending the 0x70 (Read Status) command to an erasing
374 		   chip and expecting it to be ignored, that's what we
375 		   do. */
376 		map_write(map, CMD(0xd0), cmd_addr);
377 		map_write(map, CMD(0x70), cmd_addr);
378 	}
379 
380 	wake_up(&chip->wq);
381 	mutex_unlock(&chip->mutex);
382 	return 0;
383 }
384 
cfi_staa_read(struct mtd_info * mtd,loff_t from,size_t len,size_t * retlen,u_char * buf)385 static int cfi_staa_read (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf)
386 {
387 	struct map_info *map = mtd->priv;
388 	struct cfi_private *cfi = map->fldrv_priv;
389 	unsigned long ofs;
390 	int chipnum;
391 	int ret = 0;
392 
393 	/* ofs: offset within the first chip that the first read should start */
394 	chipnum = (from >> cfi->chipshift);
395 	ofs = from - (chipnum <<  cfi->chipshift);
396 
397 	*retlen = 0;
398 
399 	while (len) {
400 		unsigned long thislen;
401 
402 		if (chipnum >= cfi->numchips)
403 			break;
404 
405 		if ((len + ofs -1) >> cfi->chipshift)
406 			thislen = (1<<cfi->chipshift) - ofs;
407 		else
408 			thislen = len;
409 
410 		ret = do_read_onechip(map, &cfi->chips[chipnum], ofs, thislen, buf);
411 		if (ret)
412 			break;
413 
414 		*retlen += thislen;
415 		len -= thislen;
416 		buf += thislen;
417 
418 		ofs = 0;
419 		chipnum++;
420 	}
421 	return ret;
422 }
423 
do_write_buffer(struct map_info * map,struct flchip * chip,unsigned long adr,const u_char * buf,int len)424 static inline int do_write_buffer(struct map_info *map, struct flchip *chip,
425 				  unsigned long adr, const u_char *buf, int len)
426 {
427 	struct cfi_private *cfi = map->fldrv_priv;
428 	map_word status, status_OK;
429 	unsigned long cmd_adr, timeo;
430 	DECLARE_WAITQUEUE(wait, current);
431 	int wbufsize, z;
432 
433         /* M58LW064A requires bus alignment for buffer wriets -- saw */
434         if (adr & (map_bankwidth(map)-1))
435             return -EINVAL;
436 
437         wbufsize = cfi_interleave(cfi) << cfi->cfiq->MaxBufWriteSize;
438         adr += chip->start;
439 	cmd_adr = adr & ~(wbufsize-1);
440 
441 	/* Let's determine this according to the interleave only once */
442         status_OK = CMD(0x80);
443 
444 	timeo = jiffies + HZ;
445  retry:
446 
447 #ifdef DEBUG_CFI_FEATURES
448        printk("%s: chip->state[%d]\n", __func__, chip->state);
449 #endif
450 	mutex_lock(&chip->mutex);
451 
452 	/* Check that the chip's ready to talk to us.
453 	 * Later, we can actually think about interrupting it
454 	 * if it's in FL_ERASING state.
455 	 * Not just yet, though.
456 	 */
457 	switch (chip->state) {
458 	case FL_READY:
459 		break;
460 
461 	case FL_CFI_QUERY:
462 	case FL_JEDEC_QUERY:
463 		map_write(map, CMD(0x70), cmd_adr);
464                 chip->state = FL_STATUS;
465 #ifdef DEBUG_CFI_FEATURES
466 	printk("%s: 1 status[%x]\n", __func__, map_read(map, cmd_adr));
467 #endif
468 
469 	case FL_STATUS:
470 		status = map_read(map, cmd_adr);
471 		if (map_word_andequal(map, status, status_OK, status_OK))
472 			break;
473 		/* Urgh. Chip not yet ready to talk to us. */
474 		if (time_after(jiffies, timeo)) {
475 			mutex_unlock(&chip->mutex);
476                         printk(KERN_ERR "waiting for chip to be ready timed out in buffer write Xstatus = %lx, status = %lx\n",
477                                status.x[0], map_read(map, cmd_adr).x[0]);
478 			return -EIO;
479 		}
480 
481 		/* Latency issues. Drop the lock, wait a while and retry */
482 		mutex_unlock(&chip->mutex);
483 		cfi_udelay(1);
484 		goto retry;
485 
486 	default:
487 		/* Stick ourselves on a wait queue to be woken when
488 		   someone changes the status */
489 		set_current_state(TASK_UNINTERRUPTIBLE);
490 		add_wait_queue(&chip->wq, &wait);
491 		mutex_unlock(&chip->mutex);
492 		schedule();
493 		remove_wait_queue(&chip->wq, &wait);
494 		timeo = jiffies + HZ;
495 		goto retry;
496 	}
497 
498 	ENABLE_VPP(map);
499 	map_write(map, CMD(0xe8), cmd_adr);
500 	chip->state = FL_WRITING_TO_BUFFER;
501 
502 	z = 0;
503 	for (;;) {
504 		status = map_read(map, cmd_adr);
505 		if (map_word_andequal(map, status, status_OK, status_OK))
506 			break;
507 
508 		mutex_unlock(&chip->mutex);
509 		cfi_udelay(1);
510 		mutex_lock(&chip->mutex);
511 
512 		if (++z > 100) {
513 			/* Argh. Not ready for write to buffer */
514 			DISABLE_VPP(map);
515                         map_write(map, CMD(0x70), cmd_adr);
516 			chip->state = FL_STATUS;
517 			mutex_unlock(&chip->mutex);
518 			printk(KERN_ERR "Chip not ready for buffer write. Xstatus = %lx\n", status.x[0]);
519 			return -EIO;
520 		}
521 	}
522 
523 	/* Write length of data to come */
524 	map_write(map, CMD(len/map_bankwidth(map)-1), cmd_adr );
525 
526 	/* Write data */
527 	for (z = 0; z < len;
528 	     z += map_bankwidth(map), buf += map_bankwidth(map)) {
529 		map_word d;
530 		d = map_word_load(map, buf);
531 		map_write(map, d, adr+z);
532 	}
533 	/* GO GO GO */
534 	map_write(map, CMD(0xd0), cmd_adr);
535 	chip->state = FL_WRITING;
536 
537 	mutex_unlock(&chip->mutex);
538 	cfi_udelay(chip->buffer_write_time);
539 	mutex_lock(&chip->mutex);
540 
541 	timeo = jiffies + (HZ/2);
542 	z = 0;
543 	for (;;) {
544 		if (chip->state != FL_WRITING) {
545 			/* Someone's suspended the write. Sleep */
546 			set_current_state(TASK_UNINTERRUPTIBLE);
547 			add_wait_queue(&chip->wq, &wait);
548 			mutex_unlock(&chip->mutex);
549 			schedule();
550 			remove_wait_queue(&chip->wq, &wait);
551 			timeo = jiffies + (HZ / 2); /* FIXME */
552 			mutex_lock(&chip->mutex);
553 			continue;
554 		}
555 
556 		status = map_read(map, cmd_adr);
557 		if (map_word_andequal(map, status, status_OK, status_OK))
558 			break;
559 
560 		/* OK Still waiting */
561 		if (time_after(jiffies, timeo)) {
562                         /* clear status */
563                         map_write(map, CMD(0x50), cmd_adr);
564                         /* put back into read status register mode */
565                         map_write(map, CMD(0x70), adr);
566 			chip->state = FL_STATUS;
567 			DISABLE_VPP(map);
568 			mutex_unlock(&chip->mutex);
569 			printk(KERN_ERR "waiting for chip to be ready timed out in bufwrite\n");
570 			return -EIO;
571 		}
572 
573 		/* Latency issues. Drop the lock, wait a while and retry */
574 		mutex_unlock(&chip->mutex);
575 		cfi_udelay(1);
576 		z++;
577 		mutex_lock(&chip->mutex);
578 	}
579 	if (!z) {
580 		chip->buffer_write_time--;
581 		if (!chip->buffer_write_time)
582 			chip->buffer_write_time++;
583 	}
584 	if (z > 1)
585 		chip->buffer_write_time++;
586 
587 	/* Done and happy. */
588 	DISABLE_VPP(map);
589 	chip->state = FL_STATUS;
590 
591         /* check for errors: 'lock bit', 'VPP', 'dead cell'/'unerased cell' or 'incorrect cmd' -- saw */
592         if (map_word_bitsset(map, status, CMD(0x3a))) {
593 #ifdef DEBUG_CFI_FEATURES
594 		printk("%s: 2 status[%lx]\n", __func__, status.x[0]);
595 #endif
596 		/* clear status */
597 		map_write(map, CMD(0x50), cmd_adr);
598 		/* put back into read status register mode */
599 		map_write(map, CMD(0x70), adr);
600 		wake_up(&chip->wq);
601 		mutex_unlock(&chip->mutex);
602 		return map_word_bitsset(map, status, CMD(0x02)) ? -EROFS : -EIO;
603 	}
604 	wake_up(&chip->wq);
605 	mutex_unlock(&chip->mutex);
606 
607         return 0;
608 }
609 
cfi_staa_write_buffers(struct mtd_info * mtd,loff_t to,size_t len,size_t * retlen,const u_char * buf)610 static int cfi_staa_write_buffers (struct mtd_info *mtd, loff_t to,
611 				       size_t len, size_t *retlen, const u_char *buf)
612 {
613 	struct map_info *map = mtd->priv;
614 	struct cfi_private *cfi = map->fldrv_priv;
615 	int wbufsize = cfi_interleave(cfi) << cfi->cfiq->MaxBufWriteSize;
616 	int ret = 0;
617 	int chipnum;
618 	unsigned long ofs;
619 
620 	*retlen = 0;
621 	if (!len)
622 		return 0;
623 
624 	chipnum = to >> cfi->chipshift;
625 	ofs = to  - (chipnum << cfi->chipshift);
626 
627 #ifdef DEBUG_CFI_FEATURES
628 	printk("%s: map_bankwidth(map)[%x]\n", __func__, map_bankwidth(map));
629 	printk("%s: chipnum[%x] wbufsize[%x]\n", __func__, chipnum, wbufsize);
630 	printk("%s: ofs[%x] len[%x]\n", __func__, ofs, len);
631 #endif
632 
633         /* Write buffer is worth it only if more than one word to write... */
634         while (len > 0) {
635 		/* We must not cross write block boundaries */
636 		int size = wbufsize - (ofs & (wbufsize-1));
637 
638                 if (size > len)
639                     size = len;
640 
641                 ret = do_write_buffer(map, &cfi->chips[chipnum],
642 				      ofs, buf, size);
643 		if (ret)
644 			return ret;
645 
646 		ofs += size;
647 		buf += size;
648 		(*retlen) += size;
649 		len -= size;
650 
651 		if (ofs >> cfi->chipshift) {
652 			chipnum ++;
653 			ofs = 0;
654 			if (chipnum == cfi->numchips)
655 				return 0;
656 		}
657 	}
658 
659 	return 0;
660 }
661 
662 /*
663  * Writev for ECC-Flashes is a little more complicated. We need to maintain
664  * a small buffer for this.
665  * XXX: If the buffer size is not a multiple of 2, this will break
666  */
667 #define ECCBUF_SIZE (mtd->writesize)
668 #define ECCBUF_DIV(x) ((x) & ~(ECCBUF_SIZE - 1))
669 #define ECCBUF_MOD(x) ((x) &  (ECCBUF_SIZE - 1))
670 static int
cfi_staa_writev(struct mtd_info * mtd,const struct kvec * vecs,unsigned long count,loff_t to,size_t * retlen)671 cfi_staa_writev(struct mtd_info *mtd, const struct kvec *vecs,
672 		unsigned long count, loff_t to, size_t *retlen)
673 {
674 	unsigned long i;
675 	size_t	 totlen = 0, thislen;
676 	int	 ret = 0;
677 	size_t	 buflen = 0;
678 	static char *buffer;
679 
680 	if (!ECCBUF_SIZE) {
681 		/* We should fall back to a general writev implementation.
682 		 * Until that is written, just break.
683 		 */
684 		return -EIO;
685 	}
686 	buffer = kmalloc(ECCBUF_SIZE, GFP_KERNEL);
687 	if (!buffer)
688 		return -ENOMEM;
689 
690 	for (i=0; i<count; i++) {
691 		size_t elem_len = vecs[i].iov_len;
692 		void *elem_base = vecs[i].iov_base;
693 		if (!elem_len) /* FIXME: Might be unnecessary. Check that */
694 			continue;
695 		if (buflen) { /* cut off head */
696 			if (buflen + elem_len < ECCBUF_SIZE) { /* just accumulate */
697 				memcpy(buffer+buflen, elem_base, elem_len);
698 				buflen += elem_len;
699 				continue;
700 			}
701 			memcpy(buffer+buflen, elem_base, ECCBUF_SIZE-buflen);
702 			ret = mtd_write(mtd, to, ECCBUF_SIZE, &thislen,
703 					buffer);
704 			totlen += thislen;
705 			if (ret || thislen != ECCBUF_SIZE)
706 				goto write_error;
707 			elem_len -= thislen-buflen;
708 			elem_base += thislen-buflen;
709 			to += ECCBUF_SIZE;
710 		}
711 		if (ECCBUF_DIV(elem_len)) { /* write clean aligned data */
712 			ret = mtd_write(mtd, to, ECCBUF_DIV(elem_len),
713 					&thislen, elem_base);
714 			totlen += thislen;
715 			if (ret || thislen != ECCBUF_DIV(elem_len))
716 				goto write_error;
717 			to += thislen;
718 		}
719 		buflen = ECCBUF_MOD(elem_len); /* cut off tail */
720 		if (buflen) {
721 			memset(buffer, 0xff, ECCBUF_SIZE);
722 			memcpy(buffer, elem_base + thislen, buflen);
723 		}
724 	}
725 	if (buflen) { /* flush last page, even if not full */
726 		/* This is sometimes intended behaviour, really */
727 		ret = mtd_write(mtd, to, buflen, &thislen, buffer);
728 		totlen += thislen;
729 		if (ret || thislen != ECCBUF_SIZE)
730 			goto write_error;
731 	}
732 write_error:
733 	if (retlen)
734 		*retlen = totlen;
735 	kfree(buffer);
736 	return ret;
737 }
738 
739 
do_erase_oneblock(struct map_info * map,struct flchip * chip,unsigned long adr)740 static inline int do_erase_oneblock(struct map_info *map, struct flchip *chip, unsigned long adr)
741 {
742 	struct cfi_private *cfi = map->fldrv_priv;
743 	map_word status, status_OK;
744 	unsigned long timeo;
745 	int retries = 3;
746 	DECLARE_WAITQUEUE(wait, current);
747 	int ret = 0;
748 
749 	adr += chip->start;
750 
751 	/* Let's determine this according to the interleave only once */
752 	status_OK = CMD(0x80);
753 
754 	timeo = jiffies + HZ;
755 retry:
756 	mutex_lock(&chip->mutex);
757 
758 	/* Check that the chip's ready to talk to us. */
759 	switch (chip->state) {
760 	case FL_CFI_QUERY:
761 	case FL_JEDEC_QUERY:
762 	case FL_READY:
763 		map_write(map, CMD(0x70), adr);
764 		chip->state = FL_STATUS;
765 
766 	case FL_STATUS:
767 		status = map_read(map, adr);
768 		if (map_word_andequal(map, status, status_OK, status_OK))
769 			break;
770 
771 		/* Urgh. Chip not yet ready to talk to us. */
772 		if (time_after(jiffies, timeo)) {
773 			mutex_unlock(&chip->mutex);
774 			printk(KERN_ERR "waiting for chip to be ready timed out in erase\n");
775 			return -EIO;
776 		}
777 
778 		/* Latency issues. Drop the lock, wait a while and retry */
779 		mutex_unlock(&chip->mutex);
780 		cfi_udelay(1);
781 		goto retry;
782 
783 	default:
784 		/* Stick ourselves on a wait queue to be woken when
785 		   someone changes the status */
786 		set_current_state(TASK_UNINTERRUPTIBLE);
787 		add_wait_queue(&chip->wq, &wait);
788 		mutex_unlock(&chip->mutex);
789 		schedule();
790 		remove_wait_queue(&chip->wq, &wait);
791 		timeo = jiffies + HZ;
792 		goto retry;
793 	}
794 
795 	ENABLE_VPP(map);
796 	/* Clear the status register first */
797 	map_write(map, CMD(0x50), adr);
798 
799 	/* Now erase */
800 	map_write(map, CMD(0x20), adr);
801 	map_write(map, CMD(0xD0), adr);
802 	chip->state = FL_ERASING;
803 
804 	mutex_unlock(&chip->mutex);
805 	msleep(1000);
806 	mutex_lock(&chip->mutex);
807 
808 	/* FIXME. Use a timer to check this, and return immediately. */
809 	/* Once the state machine's known to be working I'll do that */
810 
811 	timeo = jiffies + (HZ*20);
812 	for (;;) {
813 		if (chip->state != FL_ERASING) {
814 			/* Someone's suspended the erase. Sleep */
815 			set_current_state(TASK_UNINTERRUPTIBLE);
816 			add_wait_queue(&chip->wq, &wait);
817 			mutex_unlock(&chip->mutex);
818 			schedule();
819 			remove_wait_queue(&chip->wq, &wait);
820 			timeo = jiffies + (HZ*20); /* FIXME */
821 			mutex_lock(&chip->mutex);
822 			continue;
823 		}
824 
825 		status = map_read(map, adr);
826 		if (map_word_andequal(map, status, status_OK, status_OK))
827 			break;
828 
829 		/* OK Still waiting */
830 		if (time_after(jiffies, timeo)) {
831 			map_write(map, CMD(0x70), adr);
832 			chip->state = FL_STATUS;
833 			printk(KERN_ERR "waiting for erase to complete timed out. Xstatus = %lx, status = %lx.\n", status.x[0], map_read(map, adr).x[0]);
834 			DISABLE_VPP(map);
835 			mutex_unlock(&chip->mutex);
836 			return -EIO;
837 		}
838 
839 		/* Latency issues. Drop the lock, wait a while and retry */
840 		mutex_unlock(&chip->mutex);
841 		cfi_udelay(1);
842 		mutex_lock(&chip->mutex);
843 	}
844 
845 	DISABLE_VPP(map);
846 	ret = 0;
847 
848 	/* We've broken this before. It doesn't hurt to be safe */
849 	map_write(map, CMD(0x70), adr);
850 	chip->state = FL_STATUS;
851 	status = map_read(map, adr);
852 
853 	/* check for lock bit */
854 	if (map_word_bitsset(map, status, CMD(0x3a))) {
855 		unsigned char chipstatus = status.x[0];
856 		if (!map_word_equal(map, status, CMD(chipstatus))) {
857 			int i, w;
858 			for (w=0; w<map_words(map); w++) {
859 				for (i = 0; i<cfi_interleave(cfi); i++) {
860 					chipstatus |= status.x[w] >> (cfi->device_type * 8);
861 				}
862 			}
863 			printk(KERN_WARNING "Status is not identical for all chips: 0x%lx. Merging to give 0x%02x\n",
864 			       status.x[0], chipstatus);
865 		}
866 		/* Reset the error bits */
867 		map_write(map, CMD(0x50), adr);
868 		map_write(map, CMD(0x70), adr);
869 
870 		if ((chipstatus & 0x30) == 0x30) {
871 			printk(KERN_NOTICE "Chip reports improper command sequence: status 0x%x\n", chipstatus);
872 			ret = -EIO;
873 		} else if (chipstatus & 0x02) {
874 			/* Protection bit set */
875 			ret = -EROFS;
876 		} else if (chipstatus & 0x8) {
877 			/* Voltage */
878 			printk(KERN_WARNING "Chip reports voltage low on erase: status 0x%x\n", chipstatus);
879 			ret = -EIO;
880 		} else if (chipstatus & 0x20) {
881 			if (retries--) {
882 				printk(KERN_DEBUG "Chip erase failed at 0x%08lx: status 0x%x. Retrying...\n", adr, chipstatus);
883 				timeo = jiffies + HZ;
884 				chip->state = FL_STATUS;
885 				mutex_unlock(&chip->mutex);
886 				goto retry;
887 			}
888 			printk(KERN_DEBUG "Chip erase failed at 0x%08lx: status 0x%x\n", adr, chipstatus);
889 			ret = -EIO;
890 		}
891 	}
892 
893 	wake_up(&chip->wq);
894 	mutex_unlock(&chip->mutex);
895 	return ret;
896 }
897 
cfi_staa_erase_varsize(struct mtd_info * mtd,struct erase_info * instr)898 static int cfi_staa_erase_varsize(struct mtd_info *mtd,
899 				  struct erase_info *instr)
900 {	struct map_info *map = mtd->priv;
901 	struct cfi_private *cfi = map->fldrv_priv;
902 	unsigned long adr, len;
903 	int chipnum, ret = 0;
904 	int i, first;
905 	struct mtd_erase_region_info *regions = mtd->eraseregions;
906 
907 	if (instr->addr > mtd->size)
908 		return -EINVAL;
909 
910 	if ((instr->len + instr->addr) > mtd->size)
911 		return -EINVAL;
912 
913 	/* Check that both start and end of the requested erase are
914 	 * aligned with the erasesize at the appropriate addresses.
915 	 */
916 
917 	i = 0;
918 
919 	/* Skip all erase regions which are ended before the start of
920 	   the requested erase. Actually, to save on the calculations,
921 	   we skip to the first erase region which starts after the
922 	   start of the requested erase, and then go back one.
923 	*/
924 
925 	while (i < mtd->numeraseregions && instr->addr >= regions[i].offset)
926 	       i++;
927 	i--;
928 
929 	/* OK, now i is pointing at the erase region in which this
930 	   erase request starts. Check the start of the requested
931 	   erase range is aligned with the erase size which is in
932 	   effect here.
933 	*/
934 
935 	if (instr->addr & (regions[i].erasesize-1))
936 		return -EINVAL;
937 
938 	/* Remember the erase region we start on */
939 	first = i;
940 
941 	/* Next, check that the end of the requested erase is aligned
942 	 * with the erase region at that address.
943 	 */
944 
945 	while (i<mtd->numeraseregions && (instr->addr + instr->len) >= regions[i].offset)
946 		i++;
947 
948 	/* As before, drop back one to point at the region in which
949 	   the address actually falls
950 	*/
951 	i--;
952 
953 	if ((instr->addr + instr->len) & (regions[i].erasesize-1))
954 		return -EINVAL;
955 
956 	chipnum = instr->addr >> cfi->chipshift;
957 	adr = instr->addr - (chipnum << cfi->chipshift);
958 	len = instr->len;
959 
960 	i=first;
961 
962 	while(len) {
963 		ret = do_erase_oneblock(map, &cfi->chips[chipnum], adr);
964 
965 		if (ret)
966 			return ret;
967 
968 		adr += regions[i].erasesize;
969 		len -= regions[i].erasesize;
970 
971 		if (adr % (1<< cfi->chipshift) == (((unsigned long)regions[i].offset + (regions[i].erasesize * regions[i].numblocks)) %( 1<< cfi->chipshift)))
972 			i++;
973 
974 		if (adr >> cfi->chipshift) {
975 			adr = 0;
976 			chipnum++;
977 
978 			if (chipnum >= cfi->numchips)
979 			break;
980 		}
981 	}
982 
983 	instr->state = MTD_ERASE_DONE;
984 	mtd_erase_callback(instr);
985 
986 	return 0;
987 }
988 
cfi_staa_sync(struct mtd_info * mtd)989 static void cfi_staa_sync (struct mtd_info *mtd)
990 {
991 	struct map_info *map = mtd->priv;
992 	struct cfi_private *cfi = map->fldrv_priv;
993 	int i;
994 	struct flchip *chip;
995 	int ret = 0;
996 	DECLARE_WAITQUEUE(wait, current);
997 
998 	for (i=0; !ret && i<cfi->numchips; i++) {
999 		chip = &cfi->chips[i];
1000 
1001 	retry:
1002 		mutex_lock(&chip->mutex);
1003 
1004 		switch(chip->state) {
1005 		case FL_READY:
1006 		case FL_STATUS:
1007 		case FL_CFI_QUERY:
1008 		case FL_JEDEC_QUERY:
1009 			chip->oldstate = chip->state;
1010 			chip->state = FL_SYNCING;
1011 			/* No need to wake_up() on this state change -
1012 			 * as the whole point is that nobody can do anything
1013 			 * with the chip now anyway.
1014 			 */
1015 		case FL_SYNCING:
1016 			mutex_unlock(&chip->mutex);
1017 			break;
1018 
1019 		default:
1020 			/* Not an idle state */
1021 			set_current_state(TASK_UNINTERRUPTIBLE);
1022 			add_wait_queue(&chip->wq, &wait);
1023 
1024 			mutex_unlock(&chip->mutex);
1025 			schedule();
1026 		        remove_wait_queue(&chip->wq, &wait);
1027 
1028 			goto retry;
1029 		}
1030 	}
1031 
1032 	/* Unlock the chips again */
1033 
1034 	for (i--; i >=0; i--) {
1035 		chip = &cfi->chips[i];
1036 
1037 		mutex_lock(&chip->mutex);
1038 
1039 		if (chip->state == FL_SYNCING) {
1040 			chip->state = chip->oldstate;
1041 			wake_up(&chip->wq);
1042 		}
1043 		mutex_unlock(&chip->mutex);
1044 	}
1045 }
1046 
do_lock_oneblock(struct map_info * map,struct flchip * chip,unsigned long adr)1047 static inline int do_lock_oneblock(struct map_info *map, struct flchip *chip, unsigned long adr)
1048 {
1049 	struct cfi_private *cfi = map->fldrv_priv;
1050 	map_word status, status_OK;
1051 	unsigned long timeo = jiffies + HZ;
1052 	DECLARE_WAITQUEUE(wait, current);
1053 
1054 	adr += chip->start;
1055 
1056 	/* Let's determine this according to the interleave only once */
1057 	status_OK = CMD(0x80);
1058 
1059 	timeo = jiffies + HZ;
1060 retry:
1061 	mutex_lock(&chip->mutex);
1062 
1063 	/* Check that the chip's ready to talk to us. */
1064 	switch (chip->state) {
1065 	case FL_CFI_QUERY:
1066 	case FL_JEDEC_QUERY:
1067 	case FL_READY:
1068 		map_write(map, CMD(0x70), adr);
1069 		chip->state = FL_STATUS;
1070 
1071 	case FL_STATUS:
1072 		status = map_read(map, adr);
1073 		if (map_word_andequal(map, status, status_OK, status_OK))
1074 			break;
1075 
1076 		/* Urgh. Chip not yet ready to talk to us. */
1077 		if (time_after(jiffies, timeo)) {
1078 			mutex_unlock(&chip->mutex);
1079 			printk(KERN_ERR "waiting for chip to be ready timed out in lock\n");
1080 			return -EIO;
1081 		}
1082 
1083 		/* Latency issues. Drop the lock, wait a while and retry */
1084 		mutex_unlock(&chip->mutex);
1085 		cfi_udelay(1);
1086 		goto retry;
1087 
1088 	default:
1089 		/* Stick ourselves on a wait queue to be woken when
1090 		   someone changes the status */
1091 		set_current_state(TASK_UNINTERRUPTIBLE);
1092 		add_wait_queue(&chip->wq, &wait);
1093 		mutex_unlock(&chip->mutex);
1094 		schedule();
1095 		remove_wait_queue(&chip->wq, &wait);
1096 		timeo = jiffies + HZ;
1097 		goto retry;
1098 	}
1099 
1100 	ENABLE_VPP(map);
1101 	map_write(map, CMD(0x60), adr);
1102 	map_write(map, CMD(0x01), adr);
1103 	chip->state = FL_LOCKING;
1104 
1105 	mutex_unlock(&chip->mutex);
1106 	msleep(1000);
1107 	mutex_lock(&chip->mutex);
1108 
1109 	/* FIXME. Use a timer to check this, and return immediately. */
1110 	/* Once the state machine's known to be working I'll do that */
1111 
1112 	timeo = jiffies + (HZ*2);
1113 	for (;;) {
1114 
1115 		status = map_read(map, adr);
1116 		if (map_word_andequal(map, status, status_OK, status_OK))
1117 			break;
1118 
1119 		/* OK Still waiting */
1120 		if (time_after(jiffies, timeo)) {
1121 			map_write(map, CMD(0x70), adr);
1122 			chip->state = FL_STATUS;
1123 			printk(KERN_ERR "waiting for lock to complete timed out. Xstatus = %lx, status = %lx.\n", status.x[0], map_read(map, adr).x[0]);
1124 			DISABLE_VPP(map);
1125 			mutex_unlock(&chip->mutex);
1126 			return -EIO;
1127 		}
1128 
1129 		/* Latency issues. Drop the lock, wait a while and retry */
1130 		mutex_unlock(&chip->mutex);
1131 		cfi_udelay(1);
1132 		mutex_lock(&chip->mutex);
1133 	}
1134 
1135 	/* Done and happy. */
1136 	chip->state = FL_STATUS;
1137 	DISABLE_VPP(map);
1138 	wake_up(&chip->wq);
1139 	mutex_unlock(&chip->mutex);
1140 	return 0;
1141 }
cfi_staa_lock(struct mtd_info * mtd,loff_t ofs,uint64_t len)1142 static int cfi_staa_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
1143 {
1144 	struct map_info *map = mtd->priv;
1145 	struct cfi_private *cfi = map->fldrv_priv;
1146 	unsigned long adr;
1147 	int chipnum, ret = 0;
1148 #ifdef DEBUG_LOCK_BITS
1149 	int ofs_factor = cfi->interleave * cfi->device_type;
1150 #endif
1151 
1152 	if (ofs & (mtd->erasesize - 1))
1153 		return -EINVAL;
1154 
1155 	if (len & (mtd->erasesize -1))
1156 		return -EINVAL;
1157 
1158 	if ((len + ofs) > mtd->size)
1159 		return -EINVAL;
1160 
1161 	chipnum = ofs >> cfi->chipshift;
1162 	adr = ofs - (chipnum << cfi->chipshift);
1163 
1164 	while(len) {
1165 
1166 #ifdef DEBUG_LOCK_BITS
1167 		cfi_send_gen_cmd(0x90, 0x55, 0, map, cfi, cfi->device_type, NULL);
1168 		printk("before lock: block status register is %x\n",cfi_read_query(map, adr+(2*ofs_factor)));
1169 		cfi_send_gen_cmd(0xff, 0x55, 0, map, cfi, cfi->device_type, NULL);
1170 #endif
1171 
1172 		ret = do_lock_oneblock(map, &cfi->chips[chipnum], adr);
1173 
1174 #ifdef DEBUG_LOCK_BITS
1175 		cfi_send_gen_cmd(0x90, 0x55, 0, map, cfi, cfi->device_type, NULL);
1176 		printk("after lock: block status register is %x\n",cfi_read_query(map, adr+(2*ofs_factor)));
1177 		cfi_send_gen_cmd(0xff, 0x55, 0, map, cfi, cfi->device_type, NULL);
1178 #endif
1179 
1180 		if (ret)
1181 			return ret;
1182 
1183 		adr += mtd->erasesize;
1184 		len -= mtd->erasesize;
1185 
1186 		if (adr >> cfi->chipshift) {
1187 			adr = 0;
1188 			chipnum++;
1189 
1190 			if (chipnum >= cfi->numchips)
1191 			break;
1192 		}
1193 	}
1194 	return 0;
1195 }
do_unlock_oneblock(struct map_info * map,struct flchip * chip,unsigned long adr)1196 static inline int do_unlock_oneblock(struct map_info *map, struct flchip *chip, unsigned long adr)
1197 {
1198 	struct cfi_private *cfi = map->fldrv_priv;
1199 	map_word status, status_OK;
1200 	unsigned long timeo = jiffies + HZ;
1201 	DECLARE_WAITQUEUE(wait, current);
1202 
1203 	adr += chip->start;
1204 
1205 	/* Let's determine this according to the interleave only once */
1206 	status_OK = CMD(0x80);
1207 
1208 	timeo = jiffies + HZ;
1209 retry:
1210 	mutex_lock(&chip->mutex);
1211 
1212 	/* Check that the chip's ready to talk to us. */
1213 	switch (chip->state) {
1214 	case FL_CFI_QUERY:
1215 	case FL_JEDEC_QUERY:
1216 	case FL_READY:
1217 		map_write(map, CMD(0x70), adr);
1218 		chip->state = FL_STATUS;
1219 
1220 	case FL_STATUS:
1221 		status = map_read(map, adr);
1222 		if (map_word_andequal(map, status, status_OK, status_OK))
1223 			break;
1224 
1225 		/* Urgh. Chip not yet ready to talk to us. */
1226 		if (time_after(jiffies, timeo)) {
1227 			mutex_unlock(&chip->mutex);
1228 			printk(KERN_ERR "waiting for chip to be ready timed out in unlock\n");
1229 			return -EIO;
1230 		}
1231 
1232 		/* Latency issues. Drop the lock, wait a while and retry */
1233 		mutex_unlock(&chip->mutex);
1234 		cfi_udelay(1);
1235 		goto retry;
1236 
1237 	default:
1238 		/* Stick ourselves on a wait queue to be woken when
1239 		   someone changes the status */
1240 		set_current_state(TASK_UNINTERRUPTIBLE);
1241 		add_wait_queue(&chip->wq, &wait);
1242 		mutex_unlock(&chip->mutex);
1243 		schedule();
1244 		remove_wait_queue(&chip->wq, &wait);
1245 		timeo = jiffies + HZ;
1246 		goto retry;
1247 	}
1248 
1249 	ENABLE_VPP(map);
1250 	map_write(map, CMD(0x60), adr);
1251 	map_write(map, CMD(0xD0), adr);
1252 	chip->state = FL_UNLOCKING;
1253 
1254 	mutex_unlock(&chip->mutex);
1255 	msleep(1000);
1256 	mutex_lock(&chip->mutex);
1257 
1258 	/* FIXME. Use a timer to check this, and return immediately. */
1259 	/* Once the state machine's known to be working I'll do that */
1260 
1261 	timeo = jiffies + (HZ*2);
1262 	for (;;) {
1263 
1264 		status = map_read(map, adr);
1265 		if (map_word_andequal(map, status, status_OK, status_OK))
1266 			break;
1267 
1268 		/* OK Still waiting */
1269 		if (time_after(jiffies, timeo)) {
1270 			map_write(map, CMD(0x70), adr);
1271 			chip->state = FL_STATUS;
1272 			printk(KERN_ERR "waiting for unlock to complete timed out. Xstatus = %lx, status = %lx.\n", status.x[0], map_read(map, adr).x[0]);
1273 			DISABLE_VPP(map);
1274 			mutex_unlock(&chip->mutex);
1275 			return -EIO;
1276 		}
1277 
1278 		/* Latency issues. Drop the unlock, wait a while and retry */
1279 		mutex_unlock(&chip->mutex);
1280 		cfi_udelay(1);
1281 		mutex_lock(&chip->mutex);
1282 	}
1283 
1284 	/* Done and happy. */
1285 	chip->state = FL_STATUS;
1286 	DISABLE_VPP(map);
1287 	wake_up(&chip->wq);
1288 	mutex_unlock(&chip->mutex);
1289 	return 0;
1290 }
cfi_staa_unlock(struct mtd_info * mtd,loff_t ofs,uint64_t len)1291 static int cfi_staa_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
1292 {
1293 	struct map_info *map = mtd->priv;
1294 	struct cfi_private *cfi = map->fldrv_priv;
1295 	unsigned long adr;
1296 	int chipnum, ret = 0;
1297 #ifdef DEBUG_LOCK_BITS
1298 	int ofs_factor = cfi->interleave * cfi->device_type;
1299 #endif
1300 
1301 	chipnum = ofs >> cfi->chipshift;
1302 	adr = ofs - (chipnum << cfi->chipshift);
1303 
1304 #ifdef DEBUG_LOCK_BITS
1305 	{
1306 		unsigned long temp_adr = adr;
1307 		unsigned long temp_len = len;
1308 
1309 		cfi_send_gen_cmd(0x90, 0x55, 0, map, cfi, cfi->device_type, NULL);
1310                 while (temp_len) {
1311 			printk("before unlock %x: block status register is %x\n",temp_adr,cfi_read_query(map, temp_adr+(2*ofs_factor)));
1312 			temp_adr += mtd->erasesize;
1313 			temp_len -= mtd->erasesize;
1314 		}
1315 		cfi_send_gen_cmd(0xff, 0x55, 0, map, cfi, cfi->device_type, NULL);
1316 	}
1317 #endif
1318 
1319 	ret = do_unlock_oneblock(map, &cfi->chips[chipnum], adr);
1320 
1321 #ifdef DEBUG_LOCK_BITS
1322 	cfi_send_gen_cmd(0x90, 0x55, 0, map, cfi, cfi->device_type, NULL);
1323 	printk("after unlock: block status register is %x\n",cfi_read_query(map, adr+(2*ofs_factor)));
1324 	cfi_send_gen_cmd(0xff, 0x55, 0, map, cfi, cfi->device_type, NULL);
1325 #endif
1326 
1327 	return ret;
1328 }
1329 
cfi_staa_suspend(struct mtd_info * mtd)1330 static int cfi_staa_suspend(struct mtd_info *mtd)
1331 {
1332 	struct map_info *map = mtd->priv;
1333 	struct cfi_private *cfi = map->fldrv_priv;
1334 	int i;
1335 	struct flchip *chip;
1336 	int ret = 0;
1337 
1338 	for (i=0; !ret && i<cfi->numchips; i++) {
1339 		chip = &cfi->chips[i];
1340 
1341 		mutex_lock(&chip->mutex);
1342 
1343 		switch(chip->state) {
1344 		case FL_READY:
1345 		case FL_STATUS:
1346 		case FL_CFI_QUERY:
1347 		case FL_JEDEC_QUERY:
1348 			chip->oldstate = chip->state;
1349 			chip->state = FL_PM_SUSPENDED;
1350 			/* No need to wake_up() on this state change -
1351 			 * as the whole point is that nobody can do anything
1352 			 * with the chip now anyway.
1353 			 */
1354 		case FL_PM_SUSPENDED:
1355 			break;
1356 
1357 		default:
1358 			ret = -EAGAIN;
1359 			break;
1360 		}
1361 		mutex_unlock(&chip->mutex);
1362 	}
1363 
1364 	/* Unlock the chips again */
1365 
1366 	if (ret) {
1367 		for (i--; i >=0; i--) {
1368 			chip = &cfi->chips[i];
1369 
1370 			mutex_lock(&chip->mutex);
1371 
1372 			if (chip->state == FL_PM_SUSPENDED) {
1373 				/* No need to force it into a known state here,
1374 				   because we're returning failure, and it didn't
1375 				   get power cycled */
1376 				chip->state = chip->oldstate;
1377 				wake_up(&chip->wq);
1378 			}
1379 			mutex_unlock(&chip->mutex);
1380 		}
1381 	}
1382 
1383 	return ret;
1384 }
1385 
cfi_staa_resume(struct mtd_info * mtd)1386 static void cfi_staa_resume(struct mtd_info *mtd)
1387 {
1388 	struct map_info *map = mtd->priv;
1389 	struct cfi_private *cfi = map->fldrv_priv;
1390 	int i;
1391 	struct flchip *chip;
1392 
1393 	for (i=0; i<cfi->numchips; i++) {
1394 
1395 		chip = &cfi->chips[i];
1396 
1397 		mutex_lock(&chip->mutex);
1398 
1399 		/* Go to known state. Chip may have been power cycled */
1400 		if (chip->state == FL_PM_SUSPENDED) {
1401 			map_write(map, CMD(0xFF), 0);
1402 			chip->state = FL_READY;
1403 			wake_up(&chip->wq);
1404 		}
1405 
1406 		mutex_unlock(&chip->mutex);
1407 	}
1408 }
1409 
cfi_staa_destroy(struct mtd_info * mtd)1410 static void cfi_staa_destroy(struct mtd_info *mtd)
1411 {
1412 	struct map_info *map = mtd->priv;
1413 	struct cfi_private *cfi = map->fldrv_priv;
1414 	kfree(cfi->cmdset_priv);
1415 	kfree(cfi);
1416 }
1417 
1418 MODULE_LICENSE("GPL");
1419