disable some mediatekl custom warnings
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / mtd / ftl.c
1 /* This version ported to the Linux-MTD system by dwmw2@infradead.org
2 *
3 * Fixes: Arnaldo Carvalho de Melo <acme@conectiva.com.br>
4 * - fixes some leaks on failure in build_maps and ftl_notify_add, cleanups
5 *
6 * Based on:
7 */
8 /*======================================================================
9
10 A Flash Translation Layer memory card driver
11
12 This driver implements a disk-like block device driver with an
13 apparent block size of 512 bytes for flash memory cards.
14
15 ftl_cs.c 1.62 2000/02/01 00:59:04
16
17 The contents of this file are subject to the Mozilla Public
18 License Version 1.1 (the "License"); you may not use this file
19 except in compliance with the License. You may obtain a copy of
20 the License at http://www.mozilla.org/MPL/
21
22 Software distributed under the License is distributed on an "AS
23 IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
24 implied. See the License for the specific language governing
25 rights and limitations under the License.
26
27 The initial developer of the original code is David A. Hinds
28 <dahinds@users.sourceforge.net>. Portions created by David A. Hinds
29 are Copyright © 1999 David A. Hinds. All Rights Reserved.
30
31 Alternatively, the contents of this file may be used under the
32 terms of the GNU General Public License version 2 (the "GPL"), in
33 which case the provisions of the GPL are applicable instead of the
34 above. If you wish to allow the use of your version of this file
35 only under the terms of the GPL and not to allow others to use
36 your version of this file under the MPL, indicate your decision
37 by deleting the provisions above and replace them with the notice
38 and other provisions required by the GPL. If you do not delete
39 the provisions above, a recipient may use your version of this
40 file under either the MPL or the GPL.
41
42 LEGAL NOTE: The FTL format is patented by M-Systems. They have
43 granted a license for its use with PCMCIA devices:
44
45 "M-Systems grants a royalty-free, non-exclusive license under
46 any presently existing M-Systems intellectual property rights
47 necessary for the design and development of FTL-compatible
48 drivers, file systems and utilities using the data formats with
49 PCMCIA PC Cards as described in the PCMCIA Flash Translation
50 Layer (FTL) Specification."
51
52 Use of the FTL format for non-PCMCIA applications may be an
53 infringement of these patents. For additional information,
54 contact M-Systems directly. M-Systems since acquired by Sandisk.
55
56 ======================================================================*/
57 #include <linux/mtd/blktrans.h>
58 #include <linux/module.h>
59 #include <linux/mtd/mtd.h>
60 /*#define PSYCHO_DEBUG */
61
62 #include <linux/kernel.h>
63 #include <linux/ptrace.h>
64 #include <linux/slab.h>
65 #include <linux/string.h>
66 #include <linux/timer.h>
67 #include <linux/major.h>
68 #include <linux/fs.h>
69 #include <linux/init.h>
70 #include <linux/hdreg.h>
71 #include <linux/vmalloc.h>
72 #include <linux/blkpg.h>
73 #include <asm/uaccess.h>
74
75 #include <linux/mtd/ftl.h>
76
77 /*====================================================================*/
78
79 /* Parameters that can be set with 'insmod' */
80 static int shuffle_freq = 50;
81 module_param(shuffle_freq, int, 0);
82
83 /*====================================================================*/
84
85 /* Major device # for FTL device */
86 #ifndef FTL_MAJOR
87 #define FTL_MAJOR 44
88 #endif
89
90
91 /*====================================================================*/
92
93 /* Maximum number of separate memory devices we'll allow */
94 #define MAX_DEV 4
95
96 /* Maximum number of regions per device */
97 #define MAX_REGION 4
98
99 /* Maximum number of partitions in an FTL region */
100 #define PART_BITS 4
101
102 /* Maximum number of outstanding erase requests per socket */
103 #define MAX_ERASE 8
104
105 /* Sector size -- shouldn't need to change */
106 #define SECTOR_SIZE 512
107
108
109 /* Each memory region corresponds to a minor device */
110 typedef struct partition_t {
111 struct mtd_blktrans_dev mbd;
112 uint32_t state;
113 uint32_t *VirtualBlockMap;
114 uint32_t *VirtualPageMap;
115 uint32_t FreeTotal;
116 struct eun_info_t {
117 uint32_t Offset;
118 uint32_t EraseCount;
119 uint32_t Free;
120 uint32_t Deleted;
121 } *EUNInfo;
122 struct xfer_info_t {
123 uint32_t Offset;
124 uint32_t EraseCount;
125 uint16_t state;
126 } *XferInfo;
127 uint16_t bam_index;
128 uint32_t *bam_cache;
129 uint16_t DataUnits;
130 uint32_t BlocksPerUnit;
131 erase_unit_header_t header;
132 } partition_t;
133
134 /* Partition state flags */
135 #define FTL_FORMATTED 0x01
136
137 /* Transfer unit states */
138 #define XFER_UNKNOWN 0x00
139 #define XFER_ERASING 0x01
140 #define XFER_ERASED 0x02
141 #define XFER_PREPARED 0x03
142 #define XFER_FAILED 0x04
143
144 /*====================================================================*/
145
146
147 static void ftl_erase_callback(struct erase_info *done);
148
149
150 /*======================================================================
151
152 Scan_header() checks to see if a memory region contains an FTL
153 partition. build_maps() reads all the erase unit headers, builds
154 the erase unit map, and then builds the virtual page map.
155
156 ======================================================================*/
157
158 static int scan_header(partition_t *part)
159 {
160 erase_unit_header_t header;
161 loff_t offset, max_offset;
162 size_t ret;
163 int err;
164 part->header.FormattedSize = 0;
165 max_offset = (0x100000<part->mbd.mtd->size)?0x100000:part->mbd.mtd->size;
166 /* Search first megabyte for a valid FTL header */
167 for (offset = 0;
168 (offset + sizeof(header)) < max_offset;
169 offset += part->mbd.mtd->erasesize ? : 0x2000) {
170
171 err = mtd_read(part->mbd.mtd, offset, sizeof(header), &ret,
172 (unsigned char *)&header);
173
174 if (err)
175 return err;
176
177 if (strcmp(header.DataOrgTuple+3, "FTL100") == 0) break;
178 }
179
180 if (offset == max_offset) {
181 printk(KERN_NOTICE "ftl_cs: FTL header not found.\n");
182 return -ENOENT;
183 }
184 if (header.BlockSize != 9 ||
185 (header.EraseUnitSize < 10) || (header.EraseUnitSize > 31) ||
186 (header.NumTransferUnits >= le16_to_cpu(header.NumEraseUnits))) {
187 printk(KERN_NOTICE "ftl_cs: FTL header corrupt!\n");
188 return -1;
189 }
190 if ((1 << header.EraseUnitSize) != part->mbd.mtd->erasesize) {
191 printk(KERN_NOTICE "ftl: FTL EraseUnitSize %x != MTD erasesize %x\n",
192 1 << header.EraseUnitSize,part->mbd.mtd->erasesize);
193 return -1;
194 }
195 part->header = header;
196 return 0;
197 }
198
199 static int build_maps(partition_t *part)
200 {
201 erase_unit_header_t header;
202 uint16_t xvalid, xtrans, i;
203 unsigned blocks, j;
204 int hdr_ok, ret = -1;
205 ssize_t retval;
206 loff_t offset;
207
208 /* Set up erase unit maps */
209 part->DataUnits = le16_to_cpu(part->header.NumEraseUnits) -
210 part->header.NumTransferUnits;
211 part->EUNInfo = kmalloc(part->DataUnits * sizeof(struct eun_info_t),
212 GFP_KERNEL);
213 if (!part->EUNInfo)
214 goto out;
215 for (i = 0; i < part->DataUnits; i++)
216 part->EUNInfo[i].Offset = 0xffffffff;
217 part->XferInfo =
218 kmalloc(part->header.NumTransferUnits * sizeof(struct xfer_info_t),
219 GFP_KERNEL);
220 if (!part->XferInfo)
221 goto out_EUNInfo;
222
223 xvalid = xtrans = 0;
224 for (i = 0; i < le16_to_cpu(part->header.NumEraseUnits); i++) {
225 offset = ((i + le16_to_cpu(part->header.FirstPhysicalEUN))
226 << part->header.EraseUnitSize);
227 ret = mtd_read(part->mbd.mtd, offset, sizeof(header), &retval,
228 (unsigned char *)&header);
229
230 if (ret)
231 goto out_XferInfo;
232
233 ret = -1;
234 /* Is this a transfer partition? */
235 hdr_ok = (strcmp(header.DataOrgTuple+3, "FTL100") == 0);
236 if (hdr_ok && (le16_to_cpu(header.LogicalEUN) < part->DataUnits) &&
237 (part->EUNInfo[le16_to_cpu(header.LogicalEUN)].Offset == 0xffffffff)) {
238 part->EUNInfo[le16_to_cpu(header.LogicalEUN)].Offset = offset;
239 part->EUNInfo[le16_to_cpu(header.LogicalEUN)].EraseCount =
240 le32_to_cpu(header.EraseCount);
241 xvalid++;
242 } else {
243 if (xtrans == part->header.NumTransferUnits) {
244 printk(KERN_NOTICE "ftl_cs: format error: too many "
245 "transfer units!\n");
246 goto out_XferInfo;
247 }
248 if (hdr_ok && (le16_to_cpu(header.LogicalEUN) == 0xffff)) {
249 part->XferInfo[xtrans].state = XFER_PREPARED;
250 part->XferInfo[xtrans].EraseCount = le32_to_cpu(header.EraseCount);
251 } else {
252 part->XferInfo[xtrans].state = XFER_UNKNOWN;
253 /* Pick anything reasonable for the erase count */
254 part->XferInfo[xtrans].EraseCount =
255 le32_to_cpu(part->header.EraseCount);
256 }
257 part->XferInfo[xtrans].Offset = offset;
258 xtrans++;
259 }
260 }
261 /* Check for format trouble */
262 header = part->header;
263 if ((xtrans != header.NumTransferUnits) ||
264 (xvalid+xtrans != le16_to_cpu(header.NumEraseUnits))) {
265 printk(KERN_NOTICE "ftl_cs: format error: erase units "
266 "don't add up!\n");
267 goto out_XferInfo;
268 }
269
270 /* Set up virtual page map */
271 blocks = le32_to_cpu(header.FormattedSize) >> header.BlockSize;
272 part->VirtualBlockMap = vmalloc(blocks * sizeof(uint32_t));
273 if (!part->VirtualBlockMap)
274 goto out_XferInfo;
275
276 memset(part->VirtualBlockMap, 0xff, blocks * sizeof(uint32_t));
277 part->BlocksPerUnit = (1 << header.EraseUnitSize) >> header.BlockSize;
278
279 part->bam_cache = kmalloc(part->BlocksPerUnit * sizeof(uint32_t),
280 GFP_KERNEL);
281 if (!part->bam_cache)
282 goto out_VirtualBlockMap;
283
284 part->bam_index = 0xffff;
285 part->FreeTotal = 0;
286
287 for (i = 0; i < part->DataUnits; i++) {
288 part->EUNInfo[i].Free = 0;
289 part->EUNInfo[i].Deleted = 0;
290 offset = part->EUNInfo[i].Offset + le32_to_cpu(header.BAMOffset);
291
292 ret = mtd_read(part->mbd.mtd, offset,
293 part->BlocksPerUnit * sizeof(uint32_t), &retval,
294 (unsigned char *)part->bam_cache);
295
296 if (ret)
297 goto out_bam_cache;
298
299 for (j = 0; j < part->BlocksPerUnit; j++) {
300 if (BLOCK_FREE(le32_to_cpu(part->bam_cache[j]))) {
301 part->EUNInfo[i].Free++;
302 part->FreeTotal++;
303 } else if ((BLOCK_TYPE(le32_to_cpu(part->bam_cache[j])) == BLOCK_DATA) &&
304 (BLOCK_NUMBER(le32_to_cpu(part->bam_cache[j])) < blocks))
305 part->VirtualBlockMap[BLOCK_NUMBER(le32_to_cpu(part->bam_cache[j]))] =
306 (i << header.EraseUnitSize) + (j << header.BlockSize);
307 else if (BLOCK_DELETED(le32_to_cpu(part->bam_cache[j])))
308 part->EUNInfo[i].Deleted++;
309 }
310 }
311
312 ret = 0;
313 goto out;
314
315 out_bam_cache:
316 kfree(part->bam_cache);
317 out_VirtualBlockMap:
318 vfree(part->VirtualBlockMap);
319 out_XferInfo:
320 kfree(part->XferInfo);
321 out_EUNInfo:
322 kfree(part->EUNInfo);
323 out:
324 return ret;
325 } /* build_maps */
326
327 /*======================================================================
328
329 Erase_xfer() schedules an asynchronous erase operation for a
330 transfer unit.
331
332 ======================================================================*/
333
334 static int erase_xfer(partition_t *part,
335 uint16_t xfernum)
336 {
337 int ret;
338 struct xfer_info_t *xfer;
339 struct erase_info *erase;
340
341 xfer = &part->XferInfo[xfernum];
342 pr_debug("ftl_cs: erasing xfer unit at 0x%x\n", xfer->Offset);
343 xfer->state = XFER_ERASING;
344
345 /* Is there a free erase slot? Always in MTD. */
346
347
348 erase=kmalloc(sizeof(struct erase_info), GFP_KERNEL);
349 if (!erase)
350 return -ENOMEM;
351
352 erase->mtd = part->mbd.mtd;
353 erase->callback = ftl_erase_callback;
354 erase->addr = xfer->Offset;
355 erase->len = 1 << part->header.EraseUnitSize;
356 erase->priv = (u_long)part;
357
358 ret = mtd_erase(part->mbd.mtd, erase);
359
360 if (!ret)
361 xfer->EraseCount++;
362 else
363 kfree(erase);
364
365 return ret;
366 } /* erase_xfer */
367
368 /*======================================================================
369
370 Prepare_xfer() takes a freshly erased transfer unit and gives
371 it an appropriate header.
372
373 ======================================================================*/
374
375 static void ftl_erase_callback(struct erase_info *erase)
376 {
377 partition_t *part;
378 struct xfer_info_t *xfer;
379 int i;
380
381 /* Look up the transfer unit */
382 part = (partition_t *)(erase->priv);
383
384 for (i = 0; i < part->header.NumTransferUnits; i++)
385 if (part->XferInfo[i].Offset == erase->addr) break;
386
387 if (i == part->header.NumTransferUnits) {
388 printk(KERN_NOTICE "ftl_cs: internal error: "
389 "erase lookup failed!\n");
390 return;
391 }
392
393 xfer = &part->XferInfo[i];
394 if (erase->state == MTD_ERASE_DONE)
395 xfer->state = XFER_ERASED;
396 else {
397 xfer->state = XFER_FAILED;
398 printk(KERN_NOTICE "ftl_cs: erase failed: state = %d\n",
399 erase->state);
400 }
401
402 kfree(erase);
403
404 } /* ftl_erase_callback */
405
406 static int prepare_xfer(partition_t *part, int i)
407 {
408 erase_unit_header_t header;
409 struct xfer_info_t *xfer;
410 int nbam, ret;
411 uint32_t ctl;
412 ssize_t retlen;
413 loff_t offset;
414
415 xfer = &part->XferInfo[i];
416 xfer->state = XFER_FAILED;
417
418 pr_debug("ftl_cs: preparing xfer unit at 0x%x\n", xfer->Offset);
419
420 /* Write the transfer unit header */
421 header = part->header;
422 header.LogicalEUN = cpu_to_le16(0xffff);
423 header.EraseCount = cpu_to_le32(xfer->EraseCount);
424
425 ret = mtd_write(part->mbd.mtd, xfer->Offset, sizeof(header), &retlen,
426 (u_char *)&header);
427
428 if (ret) {
429 return ret;
430 }
431
432 /* Write the BAM stub */
433 nbam = (part->BlocksPerUnit * sizeof(uint32_t) +
434 le32_to_cpu(part->header.BAMOffset) + SECTOR_SIZE - 1) / SECTOR_SIZE;
435
436 offset = xfer->Offset + le32_to_cpu(part->header.BAMOffset);
437 ctl = cpu_to_le32(BLOCK_CONTROL);
438
439 for (i = 0; i < nbam; i++, offset += sizeof(uint32_t)) {
440
441 ret = mtd_write(part->mbd.mtd, offset, sizeof(uint32_t), &retlen,
442 (u_char *)&ctl);
443
444 if (ret)
445 return ret;
446 }
447 xfer->state = XFER_PREPARED;
448 return 0;
449
450 } /* prepare_xfer */
451
452 /*======================================================================
453
454 Copy_erase_unit() takes a full erase block and a transfer unit,
455 copies everything to the transfer unit, then swaps the block
456 pointers.
457
458 All data blocks are copied to the corresponding blocks in the
459 target unit, so the virtual block map does not need to be
460 updated.
461
462 ======================================================================*/
463
464 static int copy_erase_unit(partition_t *part, uint16_t srcunit,
465 uint16_t xferunit)
466 {
467 u_char buf[SECTOR_SIZE];
468 struct eun_info_t *eun;
469 struct xfer_info_t *xfer;
470 uint32_t src, dest, free, i;
471 uint16_t unit;
472 int ret;
473 ssize_t retlen;
474 loff_t offset;
475 uint16_t srcunitswap = cpu_to_le16(srcunit);
476
477 eun = &part->EUNInfo[srcunit];
478 xfer = &part->XferInfo[xferunit];
479 pr_debug("ftl_cs: copying block 0x%x to 0x%x\n",
480 eun->Offset, xfer->Offset);
481
482
483 /* Read current BAM */
484 if (part->bam_index != srcunit) {
485
486 offset = eun->Offset + le32_to_cpu(part->header.BAMOffset);
487
488 ret = mtd_read(part->mbd.mtd, offset,
489 part->BlocksPerUnit * sizeof(uint32_t), &retlen,
490 (u_char *)(part->bam_cache));
491
492 /* mark the cache bad, in case we get an error later */
493 part->bam_index = 0xffff;
494
495 if (ret) {
496 printk( KERN_WARNING "ftl: Failed to read BAM cache in copy_erase_unit()!\n");
497 return ret;
498 }
499 }
500
501 /* Write the LogicalEUN for the transfer unit */
502 xfer->state = XFER_UNKNOWN;
503 offset = xfer->Offset + 20; /* Bad! */
504 unit = cpu_to_le16(0x7fff);
505
506 ret = mtd_write(part->mbd.mtd, offset, sizeof(uint16_t), &retlen,
507 (u_char *)&unit);
508
509 if (ret) {
510 printk( KERN_WARNING "ftl: Failed to write back to BAM cache in copy_erase_unit()!\n");
511 return ret;
512 }
513
514 /* Copy all data blocks from source unit to transfer unit */
515 src = eun->Offset; dest = xfer->Offset;
516
517 free = 0;
518 ret = 0;
519 for (i = 0; i < part->BlocksPerUnit; i++) {
520 switch (BLOCK_TYPE(le32_to_cpu(part->bam_cache[i]))) {
521 case BLOCK_CONTROL:
522 /* This gets updated later */
523 break;
524 case BLOCK_DATA:
525 case BLOCK_REPLACEMENT:
526 ret = mtd_read(part->mbd.mtd, src, SECTOR_SIZE, &retlen,
527 (u_char *)buf);
528 if (ret) {
529 printk(KERN_WARNING "ftl: Error reading old xfer unit in copy_erase_unit\n");
530 return ret;
531 }
532
533
534 ret = mtd_write(part->mbd.mtd, dest, SECTOR_SIZE, &retlen,
535 (u_char *)buf);
536 if (ret) {
537 printk(KERN_WARNING "ftl: Error writing new xfer unit in copy_erase_unit\n");
538 return ret;
539 }
540
541 break;
542 default:
543 /* All other blocks must be free */
544 part->bam_cache[i] = cpu_to_le32(0xffffffff);
545 free++;
546 break;
547 }
548 src += SECTOR_SIZE;
549 dest += SECTOR_SIZE;
550 }
551
552 /* Write the BAM to the transfer unit */
553 ret = mtd_write(part->mbd.mtd,
554 xfer->Offset + le32_to_cpu(part->header.BAMOffset),
555 part->BlocksPerUnit * sizeof(int32_t),
556 &retlen,
557 (u_char *)part->bam_cache);
558 if (ret) {
559 printk( KERN_WARNING "ftl: Error writing BAM in copy_erase_unit\n");
560 return ret;
561 }
562
563
564 /* All clear? Then update the LogicalEUN again */
565 ret = mtd_write(part->mbd.mtd, xfer->Offset + 20, sizeof(uint16_t),
566 &retlen, (u_char *)&srcunitswap);
567
568 if (ret) {
569 printk(KERN_WARNING "ftl: Error writing new LogicalEUN in copy_erase_unit\n");
570 return ret;
571 }
572
573
574 /* Update the maps and usage stats*/
575 i = xfer->EraseCount;
576 xfer->EraseCount = eun->EraseCount;
577 eun->EraseCount = i;
578 i = xfer->Offset;
579 xfer->Offset = eun->Offset;
580 eun->Offset = i;
581 part->FreeTotal -= eun->Free;
582 part->FreeTotal += free;
583 eun->Free = free;
584 eun->Deleted = 0;
585
586 /* Now, the cache should be valid for the new block */
587 part->bam_index = srcunit;
588
589 return 0;
590 } /* copy_erase_unit */
591
592 /*======================================================================
593
594 reclaim_block() picks a full erase unit and a transfer unit and
595 then calls copy_erase_unit() to copy one to the other. Then, it
596 schedules an erase on the expired block.
597
598 What's a good way to decide which transfer unit and which erase
599 unit to use? Beats me. My way is to always pick the transfer
600 unit with the fewest erases, and usually pick the data unit with
601 the most deleted blocks. But with a small probability, pick the
602 oldest data unit instead. This means that we generally postpone
603 the next reclamation as long as possible, but shuffle static
604 stuff around a bit for wear leveling.
605
606 ======================================================================*/
607
608 static int reclaim_block(partition_t *part)
609 {
610 uint16_t i, eun, xfer;
611 uint32_t best;
612 int queued, ret;
613
614 pr_debug("ftl_cs: reclaiming space...\n");
615 pr_debug("NumTransferUnits == %x\n", part->header.NumTransferUnits);
616 /* Pick the least erased transfer unit */
617 best = 0xffffffff; xfer = 0xffff;
618 do {
619 queued = 0;
620 for (i = 0; i < part->header.NumTransferUnits; i++) {
621 int n=0;
622 if (part->XferInfo[i].state == XFER_UNKNOWN) {
623 pr_debug("XferInfo[%d].state == XFER_UNKNOWN\n",i);
624 n=1;
625 erase_xfer(part, i);
626 }
627 if (part->XferInfo[i].state == XFER_ERASING) {
628 pr_debug("XferInfo[%d].state == XFER_ERASING\n",i);
629 n=1;
630 queued = 1;
631 }
632 else if (part->XferInfo[i].state == XFER_ERASED) {
633 pr_debug("XferInfo[%d].state == XFER_ERASED\n",i);
634 n=1;
635 prepare_xfer(part, i);
636 }
637 if (part->XferInfo[i].state == XFER_PREPARED) {
638 pr_debug("XferInfo[%d].state == XFER_PREPARED\n",i);
639 n=1;
640 if (part->XferInfo[i].EraseCount <= best) {
641 best = part->XferInfo[i].EraseCount;
642 xfer = i;
643 }
644 }
645 if (!n)
646 pr_debug("XferInfo[%d].state == %x\n",i, part->XferInfo[i].state);
647
648 }
649 if (xfer == 0xffff) {
650 if (queued) {
651 pr_debug("ftl_cs: waiting for transfer "
652 "unit to be prepared...\n");
653 mtd_sync(part->mbd.mtd);
654 } else {
655 static int ne = 0;
656 if (++ne < 5)
657 printk(KERN_NOTICE "ftl_cs: reclaim failed: no "
658 "suitable transfer units!\n");
659 else
660 pr_debug("ftl_cs: reclaim failed: no "
661 "suitable transfer units!\n");
662
663 return -EIO;
664 }
665 }
666 } while (xfer == 0xffff);
667
668 eun = 0;
669 if ((jiffies % shuffle_freq) == 0) {
670 pr_debug("ftl_cs: recycling freshest block...\n");
671 best = 0xffffffff;
672 for (i = 0; i < part->DataUnits; i++)
673 if (part->EUNInfo[i].EraseCount <= best) {
674 best = part->EUNInfo[i].EraseCount;
675 eun = i;
676 }
677 } else {
678 best = 0;
679 for (i = 0; i < part->DataUnits; i++)
680 if (part->EUNInfo[i].Deleted >= best) {
681 best = part->EUNInfo[i].Deleted;
682 eun = i;
683 }
684 if (best == 0) {
685 static int ne = 0;
686 if (++ne < 5)
687 printk(KERN_NOTICE "ftl_cs: reclaim failed: "
688 "no free blocks!\n");
689 else
690 pr_debug("ftl_cs: reclaim failed: "
691 "no free blocks!\n");
692
693 return -EIO;
694 }
695 }
696 ret = copy_erase_unit(part, eun, xfer);
697 if (!ret)
698 erase_xfer(part, xfer);
699 else
700 printk(KERN_NOTICE "ftl_cs: copy_erase_unit failed!\n");
701 return ret;
702 } /* reclaim_block */
703
704 /*======================================================================
705
706 Find_free() searches for a free block. If necessary, it updates
707 the BAM cache for the erase unit containing the free block. It
708 returns the block index -- the erase unit is just the currently
709 cached unit. If there are no free blocks, it returns 0 -- this
710 is never a valid data block because it contains the header.
711
712 ======================================================================*/
713
714 #ifdef PSYCHO_DEBUG
715 static void dump_lists(partition_t *part)
716 {
717 int i;
718 printk(KERN_DEBUG "ftl_cs: Free total = %d\n", part->FreeTotal);
719 for (i = 0; i < part->DataUnits; i++)
720 printk(KERN_DEBUG "ftl_cs: unit %d: %d phys, %d free, "
721 "%d deleted\n", i,
722 part->EUNInfo[i].Offset >> part->header.EraseUnitSize,
723 part->EUNInfo[i].Free, part->EUNInfo[i].Deleted);
724 }
725 #endif
726
727 static uint32_t find_free(partition_t *part)
728 {
729 uint16_t stop, eun;
730 uint32_t blk;
731 size_t retlen;
732 int ret;
733
734 /* Find an erase unit with some free space */
735 stop = (part->bam_index == 0xffff) ? 0 : part->bam_index;
736 eun = stop;
737 do {
738 if (part->EUNInfo[eun].Free != 0) break;
739 /* Wrap around at end of table */
740 if (++eun == part->DataUnits) eun = 0;
741 } while (eun != stop);
742
743 if (part->EUNInfo[eun].Free == 0)
744 return 0;
745
746 /* Is this unit's BAM cached? */
747 if (eun != part->bam_index) {
748 /* Invalidate cache */
749 part->bam_index = 0xffff;
750
751 ret = mtd_read(part->mbd.mtd,
752 part->EUNInfo[eun].Offset + le32_to_cpu(part->header.BAMOffset),
753 part->BlocksPerUnit * sizeof(uint32_t),
754 &retlen,
755 (u_char *)(part->bam_cache));
756
757 if (ret) {
758 printk(KERN_WARNING"ftl: Error reading BAM in find_free\n");
759 return 0;
760 }
761 part->bam_index = eun;
762 }
763
764 /* Find a free block */
765 for (blk = 0; blk < part->BlocksPerUnit; blk++)
766 if (BLOCK_FREE(le32_to_cpu(part->bam_cache[blk]))) break;
767 if (blk == part->BlocksPerUnit) {
768 #ifdef PSYCHO_DEBUG
769 static int ne = 0;
770 if (++ne == 1)
771 dump_lists(part);
772 #endif
773 printk(KERN_NOTICE "ftl_cs: bad free list!\n");
774 return 0;
775 }
776 pr_debug("ftl_cs: found free block at %d in %d\n", blk, eun);
777 return blk;
778
779 } /* find_free */
780
781
782 /*======================================================================
783
784 Read a series of sectors from an FTL partition.
785
786 ======================================================================*/
787
788 static int ftl_read(partition_t *part, caddr_t buffer,
789 u_long sector, u_long nblocks)
790 {
791 uint32_t log_addr, bsize;
792 u_long i;
793 int ret;
794 size_t offset, retlen;
795
796 pr_debug("ftl_cs: ftl_read(0x%p, 0x%lx, %ld)\n",
797 part, sector, nblocks);
798 if (!(part->state & FTL_FORMATTED)) {
799 printk(KERN_NOTICE "ftl_cs: bad partition\n");
800 return -EIO;
801 }
802 bsize = 1 << part->header.EraseUnitSize;
803
804 for (i = 0; i < nblocks; i++) {
805 if (((sector+i) * SECTOR_SIZE) >= le32_to_cpu(part->header.FormattedSize)) {
806 printk(KERN_NOTICE "ftl_cs: bad read offset\n");
807 return -EIO;
808 }
809 log_addr = part->VirtualBlockMap[sector+i];
810 if (log_addr == 0xffffffff)
811 memset(buffer, 0, SECTOR_SIZE);
812 else {
813 offset = (part->EUNInfo[log_addr / bsize].Offset
814 + (log_addr % bsize));
815 ret = mtd_read(part->mbd.mtd, offset, SECTOR_SIZE, &retlen,
816 (u_char *)buffer);
817
818 if (ret) {
819 printk(KERN_WARNING "Error reading MTD device in ftl_read()\n");
820 return ret;
821 }
822 }
823 buffer += SECTOR_SIZE;
824 }
825 return 0;
826 } /* ftl_read */
827
828 /*======================================================================
829
830 Write a series of sectors to an FTL partition
831
832 ======================================================================*/
833
834 static int set_bam_entry(partition_t *part, uint32_t log_addr,
835 uint32_t virt_addr)
836 {
837 uint32_t bsize, blk, le_virt_addr;
838 #ifdef PSYCHO_DEBUG
839 uint32_t old_addr;
840 #endif
841 uint16_t eun;
842 int ret;
843 size_t retlen, offset;
844
845 pr_debug("ftl_cs: set_bam_entry(0x%p, 0x%x, 0x%x)\n",
846 part, log_addr, virt_addr);
847 bsize = 1 << part->header.EraseUnitSize;
848 eun = log_addr / bsize;
849 blk = (log_addr % bsize) / SECTOR_SIZE;
850 offset = (part->EUNInfo[eun].Offset + blk * sizeof(uint32_t) +
851 le32_to_cpu(part->header.BAMOffset));
852
853 #ifdef PSYCHO_DEBUG
854 ret = mtd_read(part->mbd.mtd, offset, sizeof(uint32_t), &retlen,
855 (u_char *)&old_addr);
856 if (ret) {
857 printk(KERN_WARNING"ftl: Error reading old_addr in set_bam_entry: %d\n",ret);
858 return ret;
859 }
860 old_addr = le32_to_cpu(old_addr);
861
862 if (((virt_addr == 0xfffffffe) && !BLOCK_FREE(old_addr)) ||
863 ((virt_addr == 0) && (BLOCK_TYPE(old_addr) != BLOCK_DATA)) ||
864 (!BLOCK_DELETED(virt_addr) && (old_addr != 0xfffffffe))) {
865 static int ne = 0;
866 if (++ne < 5) {
867 printk(KERN_NOTICE "ftl_cs: set_bam_entry() inconsistency!\n");
868 printk(KERN_NOTICE "ftl_cs: log_addr = 0x%x, old = 0x%x"
869 ", new = 0x%x\n", log_addr, old_addr, virt_addr);
870 }
871 return -EIO;
872 }
873 #endif
874 le_virt_addr = cpu_to_le32(virt_addr);
875 if (part->bam_index == eun) {
876 #ifdef PSYCHO_DEBUG
877 if (le32_to_cpu(part->bam_cache[blk]) != old_addr) {
878 static int ne = 0;
879 if (++ne < 5) {
880 printk(KERN_NOTICE "ftl_cs: set_bam_entry() "
881 "inconsistency!\n");
882 printk(KERN_NOTICE "ftl_cs: log_addr = 0x%x, cache"
883 " = 0x%x\n",
884 le32_to_cpu(part->bam_cache[blk]), old_addr);
885 }
886 return -EIO;
887 }
888 #endif
889 part->bam_cache[blk] = le_virt_addr;
890 }
891 ret = mtd_write(part->mbd.mtd, offset, sizeof(uint32_t), &retlen,
892 (u_char *)&le_virt_addr);
893
894 if (ret) {
895 printk(KERN_NOTICE "ftl_cs: set_bam_entry() failed!\n");
896 printk(KERN_NOTICE "ftl_cs: log_addr = 0x%x, new = 0x%x\n",
897 log_addr, virt_addr);
898 }
899 return ret;
900 } /* set_bam_entry */
901
902 static int ftl_write(partition_t *part, caddr_t buffer,
903 u_long sector, u_long nblocks)
904 {
905 uint32_t bsize, log_addr, virt_addr, old_addr, blk;
906 u_long i;
907 int ret;
908 size_t retlen, offset;
909
910 pr_debug("ftl_cs: ftl_write(0x%p, %ld, %ld)\n",
911 part, sector, nblocks);
912 if (!(part->state & FTL_FORMATTED)) {
913 printk(KERN_NOTICE "ftl_cs: bad partition\n");
914 return -EIO;
915 }
916 /* See if we need to reclaim space, before we start */
917 while (part->FreeTotal < nblocks) {
918 ret = reclaim_block(part);
919 if (ret)
920 return ret;
921 }
922
923 bsize = 1 << part->header.EraseUnitSize;
924
925 virt_addr = sector * SECTOR_SIZE | BLOCK_DATA;
926 for (i = 0; i < nblocks; i++) {
927 if (virt_addr >= le32_to_cpu(part->header.FormattedSize)) {
928 printk(KERN_NOTICE "ftl_cs: bad write offset\n");
929 return -EIO;
930 }
931
932 /* Grab a free block */
933 blk = find_free(part);
934 if (blk == 0) {
935 static int ne = 0;
936 if (++ne < 5)
937 printk(KERN_NOTICE "ftl_cs: internal error: "
938 "no free blocks!\n");
939 return -ENOSPC;
940 }
941
942 /* Tag the BAM entry, and write the new block */
943 log_addr = part->bam_index * bsize + blk * SECTOR_SIZE;
944 part->EUNInfo[part->bam_index].Free--;
945 part->FreeTotal--;
946 if (set_bam_entry(part, log_addr, 0xfffffffe))
947 return -EIO;
948 part->EUNInfo[part->bam_index].Deleted++;
949 offset = (part->EUNInfo[part->bam_index].Offset +
950 blk * SECTOR_SIZE);
951 ret = mtd_write(part->mbd.mtd, offset, SECTOR_SIZE, &retlen, buffer);
952
953 if (ret) {
954 printk(KERN_NOTICE "ftl_cs: block write failed!\n");
955 printk(KERN_NOTICE "ftl_cs: log_addr = 0x%x, virt_addr"
956 " = 0x%x, Offset = 0x%zx\n", log_addr, virt_addr,
957 offset);
958 return -EIO;
959 }
960
961 /* Only delete the old entry when the new entry is ready */
962 old_addr = part->VirtualBlockMap[sector+i];
963 if (old_addr != 0xffffffff) {
964 part->VirtualBlockMap[sector+i] = 0xffffffff;
965 part->EUNInfo[old_addr/bsize].Deleted++;
966 if (set_bam_entry(part, old_addr, 0))
967 return -EIO;
968 }
969
970 /* Finally, set up the new pointers */
971 if (set_bam_entry(part, log_addr, virt_addr))
972 return -EIO;
973 part->VirtualBlockMap[sector+i] = log_addr;
974 part->EUNInfo[part->bam_index].Deleted--;
975
976 buffer += SECTOR_SIZE;
977 virt_addr += SECTOR_SIZE;
978 }
979 return 0;
980 } /* ftl_write */
981
982 static int ftl_getgeo(struct mtd_blktrans_dev *dev, struct hd_geometry *geo)
983 {
984 partition_t *part = (void *)dev;
985 u_long sect;
986
987 /* Sort of arbitrary: round size down to 4KiB boundary */
988 sect = le32_to_cpu(part->header.FormattedSize)/SECTOR_SIZE;
989
990 geo->heads = 1;
991 geo->sectors = 8;
992 geo->cylinders = sect >> 3;
993
994 return 0;
995 }
996
997 static int ftl_readsect(struct mtd_blktrans_dev *dev,
998 unsigned long block, char *buf)
999 {
1000 return ftl_read((void *)dev, buf, block, 1);
1001 }
1002
1003 static int ftl_writesect(struct mtd_blktrans_dev *dev,
1004 unsigned long block, char *buf)
1005 {
1006 return ftl_write((void *)dev, buf, block, 1);
1007 }
1008
1009 static int ftl_discardsect(struct mtd_blktrans_dev *dev,
1010 unsigned long sector, unsigned nr_sects)
1011 {
1012 partition_t *part = (void *)dev;
1013 uint32_t bsize = 1 << part->header.EraseUnitSize;
1014
1015 pr_debug("FTL erase sector %ld for %d sectors\n",
1016 sector, nr_sects);
1017
1018 while (nr_sects) {
1019 uint32_t old_addr = part->VirtualBlockMap[sector];
1020 if (old_addr != 0xffffffff) {
1021 part->VirtualBlockMap[sector] = 0xffffffff;
1022 part->EUNInfo[old_addr/bsize].Deleted++;
1023 if (set_bam_entry(part, old_addr, 0))
1024 return -EIO;
1025 }
1026 nr_sects--;
1027 sector++;
1028 }
1029
1030 return 0;
1031 }
1032 /*====================================================================*/
1033
1034 static void ftl_freepart(partition_t *part)
1035 {
1036 vfree(part->VirtualBlockMap);
1037 part->VirtualBlockMap = NULL;
1038 kfree(part->VirtualPageMap);
1039 part->VirtualPageMap = NULL;
1040 kfree(part->EUNInfo);
1041 part->EUNInfo = NULL;
1042 kfree(part->XferInfo);
1043 part->XferInfo = NULL;
1044 kfree(part->bam_cache);
1045 part->bam_cache = NULL;
1046 } /* ftl_freepart */
1047
1048 static void ftl_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd)
1049 {
1050 partition_t *partition;
1051
1052 partition = kzalloc(sizeof(partition_t), GFP_KERNEL);
1053
1054 if (!partition) {
1055 printk(KERN_WARNING "No memory to scan for FTL on %s\n",
1056 mtd->name);
1057 return;
1058 }
1059
1060 partition->mbd.mtd = mtd;
1061
1062 if ((scan_header(partition) == 0) &&
1063 (build_maps(partition) == 0)) {
1064
1065 partition->state = FTL_FORMATTED;
1066 #ifdef PCMCIA_DEBUG
1067 printk(KERN_INFO "ftl_cs: opening %d KiB FTL partition\n",
1068 le32_to_cpu(partition->header.FormattedSize) >> 10);
1069 #endif
1070 partition->mbd.size = le32_to_cpu(partition->header.FormattedSize) >> 9;
1071
1072 partition->mbd.tr = tr;
1073 partition->mbd.devnum = -1;
1074 if (!add_mtd_blktrans_dev((void *)partition))
1075 return;
1076 }
1077
1078 ftl_freepart(partition);
1079 kfree(partition);
1080 }
1081
1082 static void ftl_remove_dev(struct mtd_blktrans_dev *dev)
1083 {
1084 del_mtd_blktrans_dev(dev);
1085 ftl_freepart((partition_t *)dev);
1086 }
1087
1088 static struct mtd_blktrans_ops ftl_tr = {
1089 .name = "ftl",
1090 .major = FTL_MAJOR,
1091 .part_bits = PART_BITS,
1092 .blksize = SECTOR_SIZE,
1093 .readsect = ftl_readsect,
1094 .writesect = ftl_writesect,
1095 .discard = ftl_discardsect,
1096 .getgeo = ftl_getgeo,
1097 .add_mtd = ftl_add_mtd,
1098 .remove_dev = ftl_remove_dev,
1099 .owner = THIS_MODULE,
1100 };
1101
1102 static int __init init_ftl(void)
1103 {
1104 return register_mtd_blktrans(&ftl_tr);
1105 }
1106
1107 static void __exit cleanup_ftl(void)
1108 {
1109 deregister_mtd_blktrans(&ftl_tr);
1110 }
1111
1112 module_init(init_ftl);
1113 module_exit(cleanup_ftl);
1114
1115
1116 MODULE_LICENSE("Dual MPL/GPL");
1117 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
1118 MODULE_DESCRIPTION("Support code for Flash Translation Layer, used on PCMCIA devices");