Kernel

Kernel Git Source Tree

Root/drivers/mtd/inftlcore.c

1	/*
2	* inftlcore.c -- Linux driver for Inverse Flash Translation Layer (INFTL)
3	*
4	* Copyright © 2002, Greg Ungerer (gerg@snapgear.com)
5	*
6	* Based heavily on the nftlcore.c code which is:
7	* Copyright © 1999 Machine Vision Holdings, Inc.
8	* Copyright © 1999 David Woodhouse <dwmw2@infradead.org>
9	*
10	* This program is free software; you can redistribute it and/or modify
11	* it under the terms of the GNU General Public License as published by
12	* the Free Software Foundation; either version 2 of the License, or
13	* (at your option) any later version.
14	*
15	* This program is distributed in the hope that it will be useful,
16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18	* GNU General Public License for more details.
19	*
20	* You should have received a copy of the GNU General Public License
21	* along with this program; if not, write to the Free Software
22	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23	*/
24
25	#include <linux/kernel.h>
26	#include <linux/module.h>
27	#include <linux/delay.h>
28	#include <linux/slab.h>
29	#include <linux/sched.h>
30	#include <linux/init.h>
31	#include <linux/kmod.h>
32	#include <linux/hdreg.h>
33	#include <linux/mtd/mtd.h>
34	#include <linux/mtd/nftl.h>
35	#include <linux/mtd/inftl.h>
36	#include <linux/mtd/nand.h>
37	#include <asm/uaccess.h>
38	#include <asm/errno.h>
39	#include <asm/io.h>
40
41	/*
42	* Maximum number of loops while examining next block, to have a
43	* chance to detect consistency problems (they should never happen
44	* because of the checks done in the mounting.
45	*/
46	#define MAX_LOOPS 10000
47
48	static void inftl_add_mtd(struct mtd_blktrans_ops tr, struct mtd_info mtd)
49	{
50	struct INFTLrecord *inftl;
51	unsigned long temp;
52
53	if (mtd->type != MTD_NANDFLASH \|\| mtd->size > UINT_MAX)
54	return;
55	/* OK, this is moderately ugly. But probably safe. Alternatives? */
56	if (memcmp(mtd->name, "DiskOnChip", 10))
57	return;
58
59	if (!mtd->_block_isbad) {
60	printk(KERN_ERR
61	"INFTL no longer supports the old DiskOnChip drivers loaded via docprobe.\n"
62	"Please use the new diskonchip driver under the NAND subsystem.\n");
63	return;
64	}
65
66	pr_debug("INFTL: add_mtd for %s\n", mtd->name);
67
68	inftl = kzalloc(sizeof(*inftl), GFP_KERNEL);
69
70	if (!inftl)
71	return;
72
73	inftl->mbd.mtd = mtd;
74	inftl->mbd.devnum = -1;
75
76	inftl->mbd.tr = tr;
77
78	if (INFTL_mount(inftl) < 0) {
79	printk(KERN_WARNING "INFTL: could not mount device\n");
80	kfree(inftl);
81	return;
82	}
83
84	/* OK, it's a new one. Set up all the data structures. */
85
86	/* Calculate geometry */
87	inftl->cylinders = 1024;
88	inftl->heads = 16;
89
90	temp = inftl->cylinders * inftl->heads;
91	inftl->sectors = inftl->mbd.size / temp;
92	if (inftl->mbd.size % temp) {
93	inftl->sectors++;
94	temp = inftl->cylinders * inftl->sectors;
95	inftl->heads = inftl->mbd.size / temp;
96
97	if (inftl->mbd.size % temp) {
98	inftl->heads++;
99	temp = inftl->heads * inftl->sectors;
100	inftl->cylinders = inftl->mbd.size / temp;
101	}
102	}
103
104	if (inftl->mbd.size != inftl->heads * inftl->cylinders * inftl->sectors) {
105	/*
106	Oh no we don't have
107	mbd.size == heads * cylinders * sectors
108	*/
109	printk(KERN_WARNING "INFTL: cannot calculate a geometry to "
110	"match size of 0x%lx.\n", inftl->mbd.size);
111	printk(KERN_WARNING "INFTL: using C:%d H:%d S:%d "
112	"(== 0x%lx sects)\n",
113	inftl->cylinders, inftl->heads , inftl->sectors,
114	(long)inftl->cylinders * (long)inftl->heads *
115	(long)inftl->sectors );
116	}
117
118	if (add_mtd_blktrans_dev(&inftl->mbd)) {
119	kfree(inftl->PUtable);
120	kfree(inftl->VUtable);
121	kfree(inftl);
122	return;
123	}
124	#ifdef PSYCHO_DEBUG
125	printk(KERN_INFO "INFTL: Found new inftl%c\n", inftl->mbd.devnum + 'a');
126	#endif
127	return;
128	}
129
130	static void inftl_remove_dev(struct mtd_blktrans_dev *dev)
131	{
132	struct INFTLrecord inftl = (void )dev;
133
134	pr_debug("INFTL: remove_dev (i=%d)\n", dev->devnum);
135
136	del_mtd_blktrans_dev(dev);
137
138	kfree(inftl->PUtable);
139	kfree(inftl->VUtable);
140	}
141
142	/*
143	* Actual INFTL access routines.
144	*/
145
146	/*
147	* Read oob data from flash
148	*/
149	int inftl_read_oob(struct mtd_info *mtd, loff_t offs, size_t len,
150	size_t retlen, uint8_t buf)
151	{
152	struct mtd_oob_ops ops;
153	int res;
154
155	ops.mode = MTD_OPS_PLACE_OOB;
156	ops.ooboffs = offs & (mtd->writesize - 1);
157	ops.ooblen = len;
158	ops.oobbuf = buf;
159	ops.datbuf = NULL;
160
161	res = mtd_read_oob(mtd, offs & ~(mtd->writesize - 1), &ops);
162	*retlen = ops.oobretlen;
163	return res;
164	}
165
166	/*
167	* Write oob data to flash
168	*/
169	int inftl_write_oob(struct mtd_info *mtd, loff_t offs, size_t len,
170	size_t retlen, uint8_t buf)
171	{
172	struct mtd_oob_ops ops;
173	int res;
174
175	ops.mode = MTD_OPS_PLACE_OOB;
176	ops.ooboffs = offs & (mtd->writesize - 1);
177	ops.ooblen = len;
178	ops.oobbuf = buf;
179	ops.datbuf = NULL;
180
181	res = mtd_write_oob(mtd, offs & ~(mtd->writesize - 1), &ops);
182	*retlen = ops.oobretlen;
183	return res;
184	}
185
186	/*
187	* Write data and oob to flash
188	*/
189	static int inftl_write(struct mtd_info *mtd, loff_t offs, size_t len,
190	size_t retlen, uint8_t buf, uint8_t *oob)
191	{
192	struct mtd_oob_ops ops;
193	int res;
194
195	ops.mode = MTD_OPS_PLACE_OOB;
196	ops.ooboffs = offs;
197	ops.ooblen = mtd->oobsize;
198	ops.oobbuf = oob;
199	ops.datbuf = buf;
200	ops.len = len;
201
202	res = mtd_write_oob(mtd, offs & ~(mtd->writesize - 1), &ops);
203	*retlen = ops.retlen;
204	return res;
205	}
206
207	/*
208	* INFTL_findfreeblock: Find a free Erase Unit on the INFTL partition.
209	* This function is used when the give Virtual Unit Chain.
210	*/
211	static u16 INFTL_findfreeblock(struct INFTLrecord *inftl, int desperate)
212	{
213	u16 pot = inftl->LastFreeEUN;
214	int silly = inftl->nb_blocks;
215
216	pr_debug("INFTL: INFTL_findfreeblock(inftl=%p,desperate=%d)\n",
217	inftl, desperate);
218
219	/*
220	* Normally, we force a fold to happen before we run out of free
221	* blocks completely.
222	*/
223	if (!desperate && inftl->numfreeEUNs < 2) {
224	pr_debug("INFTL: there are too few free EUNs (%d)\n",
225	inftl->numfreeEUNs);
226	return BLOCK_NIL;
227	}
228
229	/* Scan for a free block */
230	do {
231	if (inftl->PUtable[pot] == BLOCK_FREE) {
232	inftl->LastFreeEUN = pot;
233	return pot;
234	}
235
236	if (++pot > inftl->lastEUN)
237	pot = 0;
238
239	if (!silly--) {
240	printk(KERN_WARNING "INFTL: no free blocks found! "
241	"EUN range = %d - %d\n", 0, inftl->LastFreeEUN);
242	return BLOCK_NIL;
243	}
244	} while (pot != inftl->LastFreeEUN);
245
246	return BLOCK_NIL;
247	}
248
249	static u16 INFTL_foldchain(struct INFTLrecord *inftl, unsigned thisVUC, unsigned pendingblock)
250	{
251	u16 BlockMap[MAX_SECTORS_PER_UNIT];
252	unsigned char BlockDeleted[MAX_SECTORS_PER_UNIT];
253	unsigned int thisEUN, prevEUN, status;
254	struct mtd_info *mtd = inftl->mbd.mtd;
255	int block, silly;
256	unsigned int targetEUN;
257	struct inftl_oob oob;
258	size_t retlen;
259
260	pr_debug("INFTL: INFTL_foldchain(inftl=%p,thisVUC=%d,pending=%d)\n",
261	inftl, thisVUC, pendingblock);
262
263	memset(BlockMap, 0xff, sizeof(BlockMap));
264	memset(BlockDeleted, 0, sizeof(BlockDeleted));
265
266	thisEUN = targetEUN = inftl->VUtable[thisVUC];
267
268	if (thisEUN == BLOCK_NIL) {
269	printk(KERN_WARNING "INFTL: trying to fold non-existent "
270	"Virtual Unit Chain %d!\n", thisVUC);
271	return BLOCK_NIL;
272	}
273
274	/*
275	* Scan to find the Erase Unit which holds the actual data for each
276	* 512-byte block within the Chain.
277	*/
278	silly = MAX_LOOPS;
279	while (thisEUN < inftl->nb_blocks) {
280	for (block = 0; block < inftl->EraseSize/SECTORSIZE; block ++) {
281	if ((BlockMap[block] != BLOCK_NIL) \|\|
282	BlockDeleted[block])
283	continue;
284
285	if (inftl_read_oob(mtd, (thisEUN * inftl->EraseSize)
286	+ (block * SECTORSIZE), 16, &retlen,
287	(char *)&oob) < 0)
288	status = SECTOR_IGNORE;
289	else
290	status = oob.b.Status \| oob.b.Status1;
291
292	switch(status) {
293	case SECTOR_FREE:
294	case SECTOR_IGNORE:
295	break;
296	case SECTOR_USED:
297	BlockMap[block] = thisEUN;
298	continue;
299	case SECTOR_DELETED:
300	BlockDeleted[block] = 1;
301	continue;
302	default:
303	printk(KERN_WARNING "INFTL: unknown status "
304	"for block %d in EUN %d: %x\n",
305	block, thisEUN, status);
306	break;
307	}
308	}
309
310	if (!silly--) {
311	printk(KERN_WARNING "INFTL: infinite loop in Virtual "
312	"Unit Chain 0x%x\n", thisVUC);
313	return BLOCK_NIL;
314	}
315
316	thisEUN = inftl->PUtable[thisEUN];
317	}
318
319	/*
320	* OK. We now know the location of every block in the Virtual Unit
321	* Chain, and the Erase Unit into which we are supposed to be copying.
322	* Go for it.
323	*/
324	pr_debug("INFTL: folding chain %d into unit %d\n", thisVUC, targetEUN);
325
326	for (block = 0; block < inftl->EraseSize/SECTORSIZE ; block++) {
327	unsigned char movebuf[SECTORSIZE];
328	int ret;
329
330	/*
331	* If it's in the target EUN already, or if it's pending write,
332	* do nothing.
333	*/
334	if (BlockMap[block] == targetEUN \|\| (pendingblock ==
335	(thisVUC * (inftl->EraseSize / SECTORSIZE) + block))) {
336	continue;
337	}
338
339	/*
340	* Copy only in non free block (free blocks can only
341	* happen in case of media errors or deleted blocks).
342	*/
343	if (BlockMap[block] == BLOCK_NIL)
344	continue;
345
346	ret = mtd_read(mtd,
347	(inftl->EraseSize * BlockMap[block]) + (block * SECTORSIZE),
348	SECTORSIZE,
349	&retlen,
350	movebuf);
351	if (ret < 0 && !mtd_is_bitflip(ret)) {
352	ret = mtd_read(mtd,
353	(inftl->EraseSize * BlockMap[block]) + (block * SECTORSIZE),
354	SECTORSIZE,
355	&retlen,
356	movebuf);
357	if (ret != -EIO)
358	pr_debug("INFTL: error went away on retry?\n");
359	}
360	memset(&oob, 0xff, sizeof(struct inftl_oob));
361	oob.b.Status = oob.b.Status1 = SECTOR_USED;
362
363	inftl_write(inftl->mbd.mtd, (inftl->EraseSize * targetEUN) +
364	(block * SECTORSIZE), SECTORSIZE, &retlen,
365	movebuf, (char *)&oob);
366	}
367
368	/*
369	* Newest unit in chain now contains data from _all_ older units.
370	* So go through and erase each unit in chain, oldest first. (This
371	* is important, by doing oldest first if we crash/reboot then it
372	* it is relatively simple to clean up the mess).
373	*/
374	pr_debug("INFTL: want to erase virtual chain %d\n", thisVUC);
375
376	for (;;) {
377	/* Find oldest unit in chain. */
378	thisEUN = inftl->VUtable[thisVUC];
379	prevEUN = BLOCK_NIL;
380	while (inftl->PUtable[thisEUN] != BLOCK_NIL) {
381	prevEUN = thisEUN;
382	thisEUN = inftl->PUtable[thisEUN];
383	}
384
385	/* Check if we are all done */
386	if (thisEUN == targetEUN)
387	break;
388
389	/* Unlink the last block from the chain. */
390	inftl->PUtable[prevEUN] = BLOCK_NIL;
391
392	/* Now try to erase it. */
393	if (INFTL_formatblock(inftl, thisEUN) < 0) {
394	/*
395	* Could not erase : mark block as reserved.
396	*/
397	inftl->PUtable[thisEUN] = BLOCK_RESERVED;
398	} else {
399	/* Correctly erased : mark it as free */
400	inftl->PUtable[thisEUN] = BLOCK_FREE;
401	inftl->numfreeEUNs++;
402	}
403	}
404
405	return targetEUN;
406	}
407
408	static u16 INFTL_makefreeblock(struct INFTLrecord *inftl, unsigned pendingblock)
409	{
410	/*
411	* This is the part that needs some cleverness applied.
412	* For now, I'm doing the minimum applicable to actually
413	* get the thing to work.
414	* Wear-levelling and other clever stuff needs to be implemented
415	* and we also need to do some assessment of the results when
416	* the system loses power half-way through the routine.
417	*/
418	u16 LongestChain = 0;
419	u16 ChainLength = 0, thislen;
420	u16 chain, EUN;
421
422	pr_debug("INFTL: INFTL_makefreeblock(inftl=%p,"
423	"pending=%d)\n", inftl, pendingblock);
424
425	for (chain = 0; chain < inftl->nb_blocks; chain++) {
426	EUN = inftl->VUtable[chain];
427	thislen = 0;
428
429	while (EUN <= inftl->lastEUN) {
430	thislen++;
431	EUN = inftl->PUtable[EUN];
432	if (thislen > 0xff00) {
433	printk(KERN_WARNING "INFTL: endless loop in "
434	"Virtual Chain %d: Unit %x\n",
435	chain, EUN);
436	/*
437	* Actually, don't return failure.
438	* Just ignore this chain and get on with it.
439	*/
440	thislen = 0;
441	break;
442	}
443	}
444
445	if (thislen > ChainLength) {
446	ChainLength = thislen;
447	LongestChain = chain;
448	}
449	}
450
451	if (ChainLength < 2) {
452	printk(KERN_WARNING "INFTL: no Virtual Unit Chains available "
453	"for folding. Failing request\n");
454	return BLOCK_NIL;
455	}
456
457	return INFTL_foldchain(inftl, LongestChain, pendingblock);
458	}
459
460	static int nrbits(unsigned int val, int bitcount)
461	{
462	int i, total = 0;
463
464	for (i = 0; (i < bitcount); i++)
465	total += (((0x1 << i) & val) ? 1 : 0);
466	return total;
467	}
468
469	/*
470	* INFTL_findwriteunit: Return the unit number into which we can write
471	* for this block. Make it available if it isn't already.
472	*/
473	static inline u16 INFTL_findwriteunit(struct INFTLrecord *inftl, unsigned block)
474	{
475	unsigned int thisVUC = block / (inftl->EraseSize / SECTORSIZE);
476	unsigned int thisEUN, writeEUN, prev_block, status;
477	unsigned long blockofs = (block * SECTORSIZE) & (inftl->EraseSize -1);
478	struct mtd_info *mtd = inftl->mbd.mtd;
479	struct inftl_oob oob;
480	struct inftl_bci bci;
481	unsigned char anac, nacs, parity;
482	size_t retlen;
483	int silly, silly2 = 3;
484
485	pr_debug("INFTL: INFTL_findwriteunit(inftl=%p,block=%d)\n",
486	inftl, block);
487
488	do {
489	/*
490	* Scan the media to find a unit in the VUC which has
491	* a free space for the block in question.
492	*/
493	writeEUN = BLOCK_NIL;
494	thisEUN = inftl->VUtable[thisVUC];
495	silly = MAX_LOOPS;
496
497	while (thisEUN <= inftl->lastEUN) {
498	inftl_read_oob(mtd, (thisEUN * inftl->EraseSize) +
499	blockofs, 8, &retlen, (char *)&bci);
500
501	status = bci.Status \| bci.Status1;
502	pr_debug("INFTL: status of block %d in EUN %d is %x\n",
503	block , writeEUN, status);
504
505	switch(status) {
506	case SECTOR_FREE:
507	writeEUN = thisEUN;
508	break;
509	case SECTOR_DELETED:
510	case SECTOR_USED:
511	/* Can't go any further */
512	goto hitused;
513	case SECTOR_IGNORE:
514	break;
515	default:
516	/*
517	* Invalid block. Don't use it any more.
518	* Must implement.
519	*/
520	break;
521	}
522
523	if (!silly--) {
524	printk(KERN_WARNING "INFTL: infinite loop in "
525	"Virtual Unit Chain 0x%x\n", thisVUC);
526	return BLOCK_NIL;
527	}
528
529	/* Skip to next block in chain */
530	thisEUN = inftl->PUtable[thisEUN];
531	}
532
533	hitused:
534	if (writeEUN != BLOCK_NIL)
535	return writeEUN;
536
537
538	/*
539	* OK. We didn't find one in the existing chain, or there
540	* is no existing chain. Allocate a new one.
541	*/
542	writeEUN = INFTL_findfreeblock(inftl, 0);
543
544	if (writeEUN == BLOCK_NIL) {
545	/*
546	* That didn't work - there were no free blocks just
547	* waiting to be picked up. We're going to have to fold
548	* a chain to make room.
549	*/
550	thisEUN = INFTL_makefreeblock(inftl, block);
551
552	/*
553	* Hopefully we free something, lets try again.
554	* This time we are desperate...
555	*/
556	pr_debug("INFTL: using desperate==1 to find free EUN "
557	"to accommodate write to VUC %d\n",
558	thisVUC);
559	writeEUN = INFTL_findfreeblock(inftl, 1);
560	if (writeEUN == BLOCK_NIL) {
561	/*
562	* Ouch. This should never happen - we should
563	* always be able to make some room somehow.
564	* If we get here, we've allocated more storage
565	* space than actual media, or our makefreeblock
566	* routine is missing something.
567	*/
568	printk(KERN_WARNING "INFTL: cannot make free "
569	"space.\n");
570	#ifdef DEBUG
571	INFTL_dumptables(inftl);
572	INFTL_dumpVUchains(inftl);
573	#endif
574	return BLOCK_NIL;
575	}
576	}
577
578	/*
579	* Insert new block into virtual chain. Firstly update the
580	* block headers in flash...
581	*/
582	anac = 0;
583	nacs = 0;
584	thisEUN = inftl->VUtable[thisVUC];
585	if (thisEUN != BLOCK_NIL) {
586	inftl_read_oob(mtd, thisEUN * inftl->EraseSize
587	+ 8, 8, &retlen, (char *)&oob.u);
588	anac = oob.u.a.ANAC + 1;
589	nacs = oob.u.a.NACs + 1;
590	}
591
592	prev_block = inftl->VUtable[thisVUC];
593	if (prev_block < inftl->nb_blocks)
594	prev_block -= inftl->firstEUN;
595
596	parity = (nrbits(thisVUC, 16) & 0x1) ? 0x1 : 0;
597	parity \|= (nrbits(prev_block, 16) & 0x1) ? 0x2 : 0;
598	parity \|= (nrbits(anac, 8) & 0x1) ? 0x4 : 0;
599	parity \|= (nrbits(nacs, 8) & 0x1) ? 0x8 : 0;
600
601	oob.u.a.virtualUnitNo = cpu_to_le16(thisVUC);
602	oob.u.a.prevUnitNo = cpu_to_le16(prev_block);
603	oob.u.a.ANAC = anac;
604	oob.u.a.NACs = nacs;
605	oob.u.a.parityPerField = parity;
606	oob.u.a.discarded = 0xaa;
607
608	inftl_write_oob(mtd, writeEUN * inftl->EraseSize + 8, 8,
609	&retlen, (char *)&oob.u);
610
611	/* Also back up header... */
612	oob.u.b.virtualUnitNo = cpu_to_le16(thisVUC);
613	oob.u.b.prevUnitNo = cpu_to_le16(prev_block);
614	oob.u.b.ANAC = anac;
615	oob.u.b.NACs = nacs;
616	oob.u.b.parityPerField = parity;
617	oob.u.b.discarded = 0xaa;
618
619	inftl_write_oob(mtd, writeEUN * inftl->EraseSize +
620	SECTORSIZE * 4 + 8, 8, &retlen, (char *)&oob.u);
621
622	inftl->PUtable[writeEUN] = inftl->VUtable[thisVUC];
623	inftl->VUtable[thisVUC] = writeEUN;
624
625	inftl->numfreeEUNs--;
626	return writeEUN;
627
628	} while (silly2--);
629
630	printk(KERN_WARNING "INFTL: error folding to make room for Virtual "
631	"Unit Chain 0x%x\n", thisVUC);
632	return BLOCK_NIL;
633	}
634
635	/*
636	* Given a Virtual Unit Chain, see if it can be deleted, and if so do it.
637	*/
638	static void INFTL_trydeletechain(struct INFTLrecord *inftl, unsigned thisVUC)
639	{
640	struct mtd_info *mtd = inftl->mbd.mtd;
641	unsigned char BlockUsed[MAX_SECTORS_PER_UNIT];
642	unsigned char BlockDeleted[MAX_SECTORS_PER_UNIT];
643	unsigned int thisEUN, status;
644	int block, silly;
645	struct inftl_bci bci;
646	size_t retlen;
647
648	pr_debug("INFTL: INFTL_trydeletechain(inftl=%p,"
649	"thisVUC=%d)\n", inftl, thisVUC);
650
651	memset(BlockUsed, 0, sizeof(BlockUsed));
652	memset(BlockDeleted, 0, sizeof(BlockDeleted));
653
654	thisEUN = inftl->VUtable[thisVUC];
655	if (thisEUN == BLOCK_NIL) {
656	printk(KERN_WARNING "INFTL: trying to delete non-existent "
657	"Virtual Unit Chain %d!\n", thisVUC);
658	return;
659	}
660
661	/*
662	* Scan through the Erase Units to determine whether any data is in
663	* each of the 512-byte blocks within the Chain.
664	*/
665	silly = MAX_LOOPS;
666	while (thisEUN < inftl->nb_blocks) {
667	for (block = 0; block < inftl->EraseSize/SECTORSIZE; block++) {
668	if (BlockUsed[block] \|\| BlockDeleted[block])
669	continue;
670
671	if (inftl_read_oob(mtd, (thisEUN * inftl->EraseSize)
672	+ (block * SECTORSIZE), 8 , &retlen,
673	(char *)&bci) < 0)
674	status = SECTOR_IGNORE;
675	else
676	status = bci.Status \| bci.Status1;
677
678	switch(status) {
679	case SECTOR_FREE:
680	case SECTOR_IGNORE:
681	break;
682	case SECTOR_USED:
683	BlockUsed[block] = 1;
684	continue;
685	case SECTOR_DELETED:
686	BlockDeleted[block] = 1;
687	continue;
688	default:
689	printk(KERN_WARNING "INFTL: unknown status "
690	"for block %d in EUN %d: 0x%x\n",
691	block, thisEUN, status);
692	}
693	}
694
695	if (!silly--) {
696	printk(KERN_WARNING "INFTL: infinite loop in Virtual "
697	"Unit Chain 0x%x\n", thisVUC);
698	return;
699	}
700
701	thisEUN = inftl->PUtable[thisEUN];
702	}
703
704	for (block = 0; block < inftl->EraseSize/SECTORSIZE; block++)
705	if (BlockUsed[block])
706	return;
707
708	/*
709	* For each block in the chain free it and make it available
710	* for future use. Erase from the oldest unit first.
711	*/
712	pr_debug("INFTL: deleting empty VUC %d\n", thisVUC);
713
714	for (;;) {
715	u16 *prevEUN = &inftl->VUtable[thisVUC];
716	thisEUN = *prevEUN;
717
718	/* If the chain is all gone already, we're done */
719	if (thisEUN == BLOCK_NIL) {
720	pr_debug("INFTL: Empty VUC %d for deletion was already absent\n", thisEUN);
721	return;
722	}
723
724	/* Find oldest unit in chain. */
725	while (inftl->PUtable[thisEUN] != BLOCK_NIL) {
726	BUG_ON(thisEUN >= inftl->nb_blocks);
727
728	prevEUN = &inftl->PUtable[thisEUN];
729	thisEUN = *prevEUN;
730	}
731
732	pr_debug("Deleting EUN %d from VUC %d\n",
733	thisEUN, thisVUC);
734
735	if (INFTL_formatblock(inftl, thisEUN) < 0) {
736	/*
737	* Could not erase : mark block as reserved.
738	*/
739	inftl->PUtable[thisEUN] = BLOCK_RESERVED;
740	} else {
741	/* Correctly erased : mark it as free */
742	inftl->PUtable[thisEUN] = BLOCK_FREE;
743	inftl->numfreeEUNs++;
744	}
745
746	/* Now sort out whatever was pointing to it... */
747	*prevEUN = BLOCK_NIL;
748
749	/* Ideally we'd actually be responsive to new
750	requests while we're doing this -- if there's
751	free space why should others be made to wait? */
752	cond_resched();
753	}
754
755	inftl->VUtable[thisVUC] = BLOCK_NIL;
756	}
757
758	static int INFTL_deleteblock(struct INFTLrecord *inftl, unsigned block)
759	{
760	unsigned int thisEUN = inftl->VUtable[block / (inftl->EraseSize / SECTORSIZE)];
761	unsigned long blockofs = (block * SECTORSIZE) & (inftl->EraseSize - 1);
762	struct mtd_info *mtd = inftl->mbd.mtd;
763	unsigned int status;
764	int silly = MAX_LOOPS;
765	size_t retlen;
766	struct inftl_bci bci;
767
768	pr_debug("INFTL: INFTL_deleteblock(inftl=%p,"
769	"block=%d)\n", inftl, block);
770
771	while (thisEUN < inftl->nb_blocks) {
772	if (inftl_read_oob(mtd, (thisEUN * inftl->EraseSize) +
773	blockofs, 8, &retlen, (char *)&bci) < 0)
774	status = SECTOR_IGNORE;
775	else
776	status = bci.Status \| bci.Status1;
777
778	switch (status) {
779	case SECTOR_FREE:
780	case SECTOR_IGNORE:
781	break;
782	case SECTOR_DELETED:
783	thisEUN = BLOCK_NIL;
784	goto foundit;
785	case SECTOR_USED:
786	goto foundit;
787	default:
788	printk(KERN_WARNING "INFTL: unknown status for "
789	"block %d in EUN %d: 0x%x\n",
790	block, thisEUN, status);
791	break;
792	}
793
794	if (!silly--) {
795	printk(KERN_WARNING "INFTL: infinite loop in Virtual "
796	"Unit Chain 0x%x\n",
797	block / (inftl->EraseSize / SECTORSIZE));
798	return 1;
799	}
800	thisEUN = inftl->PUtable[thisEUN];
801	}
802
803	foundit:
804	if (thisEUN != BLOCK_NIL) {
805	loff_t ptr = (thisEUN * inftl->EraseSize) + blockofs;
806
807	if (inftl_read_oob(mtd, ptr, 8, &retlen, (char *)&bci) < 0)
808	return -EIO;
809	bci.Status = bci.Status1 = SECTOR_DELETED;
810	if (inftl_write_oob(mtd, ptr, 8, &retlen, (char *)&bci) < 0)
811	return -EIO;
812	INFTL_trydeletechain(inftl, block / (inftl->EraseSize / SECTORSIZE));
813	}
814	return 0;
815	}
816
817	static int inftl_writeblock(struct mtd_blktrans_dev *mbd, unsigned long block,
818	char *buffer)
819	{
820	struct INFTLrecord inftl = (void )mbd;
821	unsigned int writeEUN;
822	unsigned long blockofs = (block * SECTORSIZE) & (inftl->EraseSize - 1);
823	size_t retlen;
824	struct inftl_oob oob;
825	char p, pend;
826
827	pr_debug("INFTL: inftl_writeblock(inftl=%p,block=%ld,"
828	"buffer=%p)\n", inftl, block, buffer);
829
830	/* Is block all zero? */
831	pend = buffer + SECTORSIZE;
832	for (p = buffer; p < pend && !*p; p++)
833	;
834
835	if (p < pend) {
836	writeEUN = INFTL_findwriteunit(inftl, block);
837
838	if (writeEUN == BLOCK_NIL) {
839	printk(KERN_WARNING "inftl_writeblock(): cannot find "
840	"block to write to\n");
841	/*
842	* If we _still_ haven't got a block to use,
843	* we're screwed.
844	*/
845	return 1;
846	}
847
848	memset(&oob, 0xff, sizeof(struct inftl_oob));
849	oob.b.Status = oob.b.Status1 = SECTOR_USED;
850
851	inftl_write(inftl->mbd.mtd, (writeEUN * inftl->EraseSize) +
852	blockofs, SECTORSIZE, &retlen, (char *)buffer,
853	(char *)&oob);
854	/*
855	* need to write SECTOR_USED flags since they are not written
856	* in mtd_writeecc
857	*/
858	} else {
859	INFTL_deleteblock(inftl, block);
860	}
861
862	return 0;
863	}
864
865	static int inftl_readblock(struct mtd_blktrans_dev *mbd, unsigned long block,
866	char *buffer)
867	{
868	struct INFTLrecord inftl = (void )mbd;
869	unsigned int thisEUN = inftl->VUtable[block / (inftl->EraseSize / SECTORSIZE)];
870	unsigned long blockofs = (block * SECTORSIZE) & (inftl->EraseSize - 1);
871	struct mtd_info *mtd = inftl->mbd.mtd;
872	unsigned int status;
873	int silly = MAX_LOOPS;
874	struct inftl_bci bci;
875	size_t retlen;
876
877	pr_debug("INFTL: inftl_readblock(inftl=%p,block=%ld,"
878	"buffer=%p)\n", inftl, block, buffer);
879
880	while (thisEUN < inftl->nb_blocks) {
881	if (inftl_read_oob(mtd, (thisEUN * inftl->EraseSize) +
882	blockofs, 8, &retlen, (char *)&bci) < 0)
883	status = SECTOR_IGNORE;
884	else
885	status = bci.Status \| bci.Status1;
886
887	switch (status) {
888	case SECTOR_DELETED:
889	thisEUN = BLOCK_NIL;
890	goto foundit;
891	case SECTOR_USED:
892	goto foundit;
893	case SECTOR_FREE:
894	case SECTOR_IGNORE:
895	break;
896	default:
897	printk(KERN_WARNING "INFTL: unknown status for "
898	"block %ld in EUN %d: 0x%04x\n",
899	block, thisEUN, status);
900	break;
901	}
902
903	if (!silly--) {
904	printk(KERN_WARNING "INFTL: infinite loop in "
905	"Virtual Unit Chain 0x%lx\n",
906	block / (inftl->EraseSize / SECTORSIZE));
907	return 1;
908	}
909
910	thisEUN = inftl->PUtable[thisEUN];
911	}
912
913	foundit:
914	if (thisEUN == BLOCK_NIL) {
915	/* The requested block is not on the media, return all 0x00 */
916	memset(buffer, 0, SECTORSIZE);
917	} else {
918	size_t retlen;
919	loff_t ptr = (thisEUN * inftl->EraseSize) + blockofs;
920	int ret = mtd_read(mtd, ptr, SECTORSIZE, &retlen, buffer);
921
922	/* Handle corrected bit flips gracefully */
923	if (ret < 0 && !mtd_is_bitflip(ret))
924	return -EIO;
925	}
926	return 0;
927	}
928
929	static int inftl_getgeo(struct mtd_blktrans_dev dev, struct hd_geometry geo)
930	{
931	struct INFTLrecord inftl = (void )dev;
932
933	geo->heads = inftl->heads;
934	geo->sectors = inftl->sectors;
935	geo->cylinders = inftl->cylinders;
936
937	return 0;
938	}
939
940	static struct mtd_blktrans_ops inftl_tr = {
941	.name = "inftl",
942	.major = INFTL_MAJOR,
943	.part_bits = INFTL_PARTN_BITS,
944	.blksize = 512,
945	.getgeo = inftl_getgeo,
946	.readsect = inftl_readblock,
947	.writesect = inftl_writeblock,
948	.add_mtd = inftl_add_mtd,
949	.remove_dev = inftl_remove_dev,
950	.owner = THIS_MODULE,
951	};
952
953	static int __init init_inftl(void)
954	{
955	return register_mtd_blktrans(&inftl_tr);
956	}
957
958	static void __exit cleanup_inftl(void)
959	{
960	deregister_mtd_blktrans(&inftl_tr);
961	}
962
963	module_init(init_inftl);
964	module_exit(cleanup_inftl);
965
966	MODULE_LICENSE("GPL");
967	MODULE_AUTHOR("Greg Ungerer <gerg@snapgear.com>, David Woodhouse <dwmw2@infradead.org>, Fabrice Bellard <fabrice.bellard@netgem.com> et al.");
968	MODULE_DESCRIPTION("Support code for Inverse Flash Translation Layer, used on M-Systems DiskOnChip 2000, Millennium and Millennium Plus");
969

Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9

Kernel

Kernel Git Source Tree

Root/drivers/mtd/inftlcore.c

interactive