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