1
2
3
4
5
6
7
8
9
10#include <linux/kernel.h>
11#include <linux/module.h>
12#include <linux/random.h>
13#include <linux/hdreg.h>
14#include <linux/kthread.h>
15#include <linux/freezer.h>
16#include <linux/sysfs.h>
17#include <linux/bitops.h>
18#include <linux/slab.h>
19#include <linux/mtd/nand_ecc.h>
20#include "nand/raw/sm_common.h"
21#include "sm_ftl.h"
22
23
24
25static struct workqueue_struct *cache_flush_workqueue;
26
27static int cache_timeout = 1000;
28module_param(cache_timeout, int, S_IRUGO);
29MODULE_PARM_DESC(cache_timeout,
30 "Timeout (in ms) for cache flush (1000 ms default");
31
32static int debug;
33module_param(debug, int, S_IRUGO | S_IWUSR);
34MODULE_PARM_DESC(debug, "Debug level (0-2)");
35
36
37
38struct sm_sysfs_attribute {
39 struct device_attribute dev_attr;
40 char *data;
41 int len;
42};
43
44static ssize_t sm_attr_show(struct device *dev, struct device_attribute *attr,
45 char *buf)
46{
47 struct sm_sysfs_attribute *sm_attr =
48 container_of(attr, struct sm_sysfs_attribute, dev_attr);
49
50 strncpy(buf, sm_attr->data, sm_attr->len);
51 return sm_attr->len;
52}
53
54
55#define NUM_ATTRIBUTES 1
56#define SM_CIS_VENDOR_OFFSET 0x59
57static struct attribute_group *sm_create_sysfs_attributes(struct sm_ftl *ftl)
58{
59 struct attribute_group *attr_group;
60 struct attribute **attributes;
61 struct sm_sysfs_attribute *vendor_attribute;
62 char *vendor;
63
64 vendor = kstrndup(ftl->cis_buffer + SM_CIS_VENDOR_OFFSET,
65 SM_SMALL_PAGE - SM_CIS_VENDOR_OFFSET, GFP_KERNEL);
66 if (!vendor)
67 goto error1;
68
69
70 vendor_attribute =
71 kzalloc(sizeof(struct sm_sysfs_attribute), GFP_KERNEL);
72 if (!vendor_attribute)
73 goto error2;
74
75 sysfs_attr_init(&vendor_attribute->dev_attr.attr);
76
77 vendor_attribute->data = vendor;
78 vendor_attribute->len = strlen(vendor);
79 vendor_attribute->dev_attr.attr.name = "vendor";
80 vendor_attribute->dev_attr.attr.mode = S_IRUGO;
81 vendor_attribute->dev_attr.show = sm_attr_show;
82
83
84
85 attributes = kzalloc(sizeof(struct attribute *) * (NUM_ATTRIBUTES + 1),
86 GFP_KERNEL);
87 if (!attributes)
88 goto error3;
89 attributes[0] = &vendor_attribute->dev_attr.attr;
90
91
92 attr_group = kzalloc(sizeof(struct attribute_group), GFP_KERNEL);
93 if (!attr_group)
94 goto error4;
95 attr_group->attrs = attributes;
96 return attr_group;
97error4:
98 kfree(attributes);
99error3:
100 kfree(vendor_attribute);
101error2:
102 kfree(vendor);
103error1:
104 return NULL;
105}
106
107static void sm_delete_sysfs_attributes(struct sm_ftl *ftl)
108{
109 struct attribute **attributes = ftl->disk_attributes->attrs;
110 int i;
111
112 for (i = 0; attributes[i] ; i++) {
113
114 struct device_attribute *dev_attr = container_of(attributes[i],
115 struct device_attribute, attr);
116
117 struct sm_sysfs_attribute *sm_attr =
118 container_of(dev_attr,
119 struct sm_sysfs_attribute, dev_attr);
120
121 kfree(sm_attr->data);
122 kfree(sm_attr);
123 }
124
125 kfree(ftl->disk_attributes->attrs);
126 kfree(ftl->disk_attributes);
127}
128
129
130
131
132static int sm_get_lba(uint8_t *lba)
133{
134
135 if ((lba[0] & 0xF8) != 0x10)
136 return -2;
137
138
139 if (hweight16(*(uint16_t *)lba) & 1)
140 return -2;
141
142 return (lba[1] >> 1) | ((lba[0] & 0x07) << 7);
143}
144
145
146
147
148
149
150
151static int sm_read_lba(struct sm_oob *oob)
152{
153 static const uint32_t erased_pattern[4] = {
154 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF };
155
156 uint16_t lba_test;
157 int lba;
158
159
160 if (!memcmp(oob, erased_pattern, SM_OOB_SIZE))
161 return -1;
162
163
164 lba_test = *(uint16_t *)oob->lba_copy1 ^ *(uint16_t*)oob->lba_copy2;
165 if (lba_test && !is_power_of_2(lba_test))
166 return -2;
167
168
169 lba = sm_get_lba(oob->lba_copy1);
170
171 if (lba == -2)
172 lba = sm_get_lba(oob->lba_copy2);
173
174 return lba;
175}
176
177static void sm_write_lba(struct sm_oob *oob, uint16_t lba)
178{
179 uint8_t tmp[2];
180
181 WARN_ON(lba >= 1000);
182
183 tmp[0] = 0x10 | ((lba >> 7) & 0x07);
184 tmp[1] = (lba << 1) & 0xFF;
185
186 if (hweight16(*(uint16_t *)tmp) & 0x01)
187 tmp[1] |= 1;
188
189 oob->lba_copy1[0] = oob->lba_copy2[0] = tmp[0];
190 oob->lba_copy1[1] = oob->lba_copy2[1] = tmp[1];
191}
192
193
194
195static loff_t sm_mkoffset(struct sm_ftl *ftl, int zone, int block, int boffset)
196{
197 WARN_ON(boffset & (SM_SECTOR_SIZE - 1));
198 WARN_ON(zone < 0 || zone >= ftl->zone_count);
199 WARN_ON(block >= ftl->zone_size);
200 WARN_ON(boffset >= ftl->block_size);
201
202 if (block == -1)
203 return -1;
204
205 return (zone * SM_MAX_ZONE_SIZE + block) * ftl->block_size + boffset;
206}
207
208
209static void sm_break_offset(struct sm_ftl *ftl, loff_t loffset,
210 int *zone, int *block, int *boffset)
211{
212 u64 offset = loffset;
213 *boffset = do_div(offset, ftl->block_size);
214 *block = do_div(offset, ftl->max_lba);
215 *zone = offset >= ftl->zone_count ? -1 : offset;
216}
217
218
219
220static int sm_correct_sector(uint8_t *buffer, struct sm_oob *oob)
221{
222 uint8_t ecc[3];
223
224 __nand_calculate_ecc(buffer, SM_SMALL_PAGE, ecc);
225 if (__nand_correct_data(buffer, ecc, oob->ecc1, SM_SMALL_PAGE) < 0)
226 return -EIO;
227
228 buffer += SM_SMALL_PAGE;
229
230 __nand_calculate_ecc(buffer, SM_SMALL_PAGE, ecc);
231 if (__nand_correct_data(buffer, ecc, oob->ecc2, SM_SMALL_PAGE) < 0)
232 return -EIO;
233 return 0;
234}
235
236
237static int sm_read_sector(struct sm_ftl *ftl,
238 int zone, int block, int boffset,
239 uint8_t *buffer, struct sm_oob *oob)
240{
241 struct mtd_info *mtd = ftl->trans->mtd;
242 struct mtd_oob_ops ops;
243 struct sm_oob tmp_oob;
244 int ret = -EIO;
245 int try = 0;
246
247
248 if (block == -1) {
249 memset(buffer, 0xFF, SM_SECTOR_SIZE);
250 return 0;
251 }
252
253
254 if (!oob)
255 oob = &tmp_oob;
256
257 ops.mode = ftl->smallpagenand ? MTD_OPS_RAW : MTD_OPS_PLACE_OOB;
258 ops.ooboffs = 0;
259 ops.ooblen = SM_OOB_SIZE;
260 ops.oobbuf = (void *)oob;
261 ops.len = SM_SECTOR_SIZE;
262 ops.datbuf = buffer;
263
264again:
265 if (try++) {
266
267
268 if (zone == 0 && block == ftl->cis_block && boffset ==
269 ftl->cis_boffset)
270 return ret;
271
272
273 if (try == 3 || sm_recheck_media(ftl))
274 return ret;
275 }
276
277
278
279 ret = mtd_read_oob(mtd, sm_mkoffset(ftl, zone, block, boffset), &ops);
280
281
282 if (ret != 0 && !mtd_is_bitflip_or_eccerr(ret)) {
283 dbg("read of block %d at zone %d, failed due to error (%d)",
284 block, zone, ret);
285 goto again;
286 }
287
288
289 if (oob->reserved != 0xFFFFFFFF && !is_power_of_2(~oob->reserved))
290 goto again;
291
292
293 WARN_ON(ops.oobretlen != SM_OOB_SIZE);
294 WARN_ON(buffer && ops.retlen != SM_SECTOR_SIZE);
295
296 if (!buffer)
297 return 0;
298
299
300 if (!sm_sector_valid(oob)) {
301 dbg("read of block %d at zone %d, failed because it is marked"
302 " as bad" , block, zone);
303 goto again;
304 }
305
306
307 if (mtd_is_eccerr(ret) ||
308 (ftl->smallpagenand && sm_correct_sector(buffer, oob))) {
309
310 dbg("read of block %d at zone %d, failed due to ECC error",
311 block, zone);
312 goto again;
313 }
314
315 return 0;
316}
317
318
319static int sm_write_sector(struct sm_ftl *ftl,
320 int zone, int block, int boffset,
321 uint8_t *buffer, struct sm_oob *oob)
322{
323 struct mtd_oob_ops ops;
324 struct mtd_info *mtd = ftl->trans->mtd;
325 int ret;
326
327 BUG_ON(ftl->readonly);
328
329 if (zone == 0 && (block == ftl->cis_block || block == 0)) {
330 dbg("attempted to write the CIS!");
331 return -EIO;
332 }
333
334 if (ftl->unstable)
335 return -EIO;
336
337 ops.mode = ftl->smallpagenand ? MTD_OPS_RAW : MTD_OPS_PLACE_OOB;
338 ops.len = SM_SECTOR_SIZE;
339 ops.datbuf = buffer;
340 ops.ooboffs = 0;
341 ops.ooblen = SM_OOB_SIZE;
342 ops.oobbuf = (void *)oob;
343
344 ret = mtd_write_oob(mtd, sm_mkoffset(ftl, zone, block, boffset), &ops);
345
346
347
348 if (ret) {
349 dbg("write to block %d at zone %d, failed with error %d",
350 block, zone, ret);
351
352 sm_recheck_media(ftl);
353 return ret;
354 }
355
356
357 WARN_ON(ops.oobretlen != SM_OOB_SIZE);
358 WARN_ON(buffer && ops.retlen != SM_SECTOR_SIZE);
359
360 return 0;
361}
362
363
364
365
366static int sm_write_block(struct sm_ftl *ftl, uint8_t *buf,
367 int zone, int block, int lba,
368 unsigned long invalid_bitmap)
369{
370 struct sm_oob oob;
371 int boffset;
372 int retry = 0;
373
374
375 memset(&oob, 0xFF, SM_OOB_SIZE);
376 sm_write_lba(&oob, lba);
377restart:
378 if (ftl->unstable)
379 return -EIO;
380
381 for (boffset = 0; boffset < ftl->block_size;
382 boffset += SM_SECTOR_SIZE) {
383
384 oob.data_status = 0xFF;
385
386 if (test_bit(boffset / SM_SECTOR_SIZE, &invalid_bitmap)) {
387
388 sm_printk("sector %d of block at LBA %d of zone %d"
389 " couldn't be read, marking it as invalid",
390 boffset / SM_SECTOR_SIZE, lba, zone);
391
392 oob.data_status = 0;
393 }
394
395 if (ftl->smallpagenand) {
396 __nand_calculate_ecc(buf + boffset,
397 SM_SMALL_PAGE, oob.ecc1);
398
399 __nand_calculate_ecc(buf + boffset + SM_SMALL_PAGE,
400 SM_SMALL_PAGE, oob.ecc2);
401 }
402 if (!sm_write_sector(ftl, zone, block, boffset,
403 buf + boffset, &oob))
404 continue;
405
406 if (!retry) {
407
408
409
410
411
412
413
414 if (sm_erase_block(ftl, zone, block, 0))
415 return -EIO;
416
417 retry = 1;
418 goto restart;
419 } else {
420 sm_mark_block_bad(ftl, zone, block);
421 return -EIO;
422 }
423 }
424 return 0;
425}
426
427
428
429static void sm_mark_block_bad(struct sm_ftl *ftl, int zone, int block)
430{
431 struct sm_oob oob;
432 int boffset;
433
434 memset(&oob, 0xFF, SM_OOB_SIZE);
435 oob.block_status = 0xF0;
436
437 if (ftl->unstable)
438 return;
439
440 if (sm_recheck_media(ftl))
441 return;
442
443 sm_printk("marking block %d of zone %d as bad", block, zone);
444
445
446
447
448 for (boffset = 0; boffset < ftl->block_size; boffset += SM_SECTOR_SIZE)
449 sm_write_sector(ftl, zone, block, boffset, NULL, &oob);
450}
451
452
453
454
455
456static int sm_erase_block(struct sm_ftl *ftl, int zone_num, uint16_t block,
457 int put_free)
458{
459 struct ftl_zone *zone = &ftl->zones[zone_num];
460 struct mtd_info *mtd = ftl->trans->mtd;
461 struct erase_info erase;
462
463 erase.addr = sm_mkoffset(ftl, zone_num, block, 0);
464 erase.len = ftl->block_size;
465
466 if (ftl->unstable)
467 return -EIO;
468
469 BUG_ON(ftl->readonly);
470
471 if (zone_num == 0 && (block == ftl->cis_block || block == 0)) {
472 sm_printk("attempted to erase the CIS!");
473 return -EIO;
474 }
475
476 if (mtd_erase(mtd, &erase)) {
477 sm_printk("erase of block %d in zone %d failed",
478 block, zone_num);
479 goto error;
480 }
481
482 if (put_free)
483 kfifo_in(&zone->free_sectors,
484 (const unsigned char *)&block, sizeof(block));
485
486 return 0;
487error:
488 sm_mark_block_bad(ftl, zone_num, block);
489 return -EIO;
490}
491
492
493static int sm_check_block(struct sm_ftl *ftl, int zone, int block)
494{
495 int boffset;
496 struct sm_oob oob;
497 int lbas[] = { -3, 0, 0, 0 };
498 int i = 0;
499 int test_lba;
500
501
502
503
504
505 for (boffset = 0; boffset < ftl->block_size;
506 boffset += SM_SECTOR_SIZE) {
507
508
509 if (sm_read_sector(ftl, zone, block, boffset, NULL, &oob))
510 return -2;
511
512 test_lba = sm_read_lba(&oob);
513
514 if (lbas[i] != test_lba)
515 lbas[++i] = test_lba;
516
517
518 if (i == 3)
519 return -EIO;
520 }
521
522
523 if (i == 2) {
524 sm_erase_block(ftl, zone, block, 1);
525 return 1;
526 }
527
528 return 0;
529}
530
531
532static const struct chs_entry chs_table[] = {
533 { 1, 125, 4, 4 },
534 { 2, 125, 4, 8 },
535 { 4, 250, 4, 8 },
536 { 8, 250, 4, 16 },
537 { 16, 500, 4, 16 },
538 { 32, 500, 8, 16 },
539 { 64, 500, 8, 32 },
540 { 128, 500, 16, 32 },
541 { 256, 1000, 16, 32 },
542 { 512, 1015, 32, 63 },
543 { 1024, 985, 33, 63 },
544 { 2048, 985, 33, 63 },
545 { 0 },
546};
547
548
549static const uint8_t cis_signature[] = {
550 0x01, 0x03, 0xD9, 0x01, 0xFF, 0x18, 0x02, 0xDF, 0x01, 0x20
551};
552
553
554static int sm_get_media_info(struct sm_ftl *ftl, struct mtd_info *mtd)
555{
556 int i;
557 int size_in_megs = mtd->size / (1024 * 1024);
558
559 ftl->readonly = mtd->type == MTD_ROM;
560
561
562 ftl->zone_count = 1;
563 ftl->smallpagenand = 0;
564
565 switch (size_in_megs) {
566 case 1:
567
568 ftl->zone_size = 256;
569 ftl->max_lba = 250;
570 ftl->block_size = 8 * SM_SECTOR_SIZE;
571 ftl->smallpagenand = 1;
572
573 break;
574 case 2:
575
576 if (mtd->writesize == SM_SMALL_PAGE) {
577 ftl->zone_size = 512;
578 ftl->max_lba = 500;
579 ftl->block_size = 8 * SM_SECTOR_SIZE;
580 ftl->smallpagenand = 1;
581
582 } else {
583
584 if (!ftl->readonly)
585 return -ENODEV;
586
587 ftl->zone_size = 256;
588 ftl->max_lba = 250;
589 ftl->block_size = 16 * SM_SECTOR_SIZE;
590 }
591 break;
592 case 4:
593
594 ftl->zone_size = 512;
595 ftl->max_lba = 500;
596 ftl->block_size = 16 * SM_SECTOR_SIZE;
597 break;
598 case 8:
599
600 ftl->zone_size = 1024;
601 ftl->max_lba = 1000;
602 ftl->block_size = 16 * SM_SECTOR_SIZE;
603 }
604
605
606
607 if (size_in_megs >= 16) {
608 ftl->zone_count = size_in_megs / 16;
609 ftl->zone_size = 1024;
610 ftl->max_lba = 1000;
611 ftl->block_size = 32 * SM_SECTOR_SIZE;
612 }
613
614
615 if (mtd->erasesize > ftl->block_size)
616 return -ENODEV;
617
618 if (mtd->writesize > SM_SECTOR_SIZE)
619 return -ENODEV;
620
621 if (ftl->smallpagenand && mtd->oobsize < SM_SMALL_OOB_SIZE)
622 return -ENODEV;
623
624 if (!ftl->smallpagenand && mtd->oobsize < SM_OOB_SIZE)
625 return -ENODEV;
626
627
628 if (!mtd_has_oob(mtd))
629 return -ENODEV;
630
631
632 for (i = 0 ; i < ARRAY_SIZE(chs_table) ; i++) {
633 if (chs_table[i].size == size_in_megs) {
634 ftl->cylinders = chs_table[i].cyl;
635 ftl->heads = chs_table[i].head;
636 ftl->sectors = chs_table[i].sec;
637 return 0;
638 }
639 }
640
641 sm_printk("media has unknown size : %dMiB", size_in_megs);
642 ftl->cylinders = 985;
643 ftl->heads = 33;
644 ftl->sectors = 63;
645 return 0;
646}
647
648
649static int sm_read_cis(struct sm_ftl *ftl)
650{
651 struct sm_oob oob;
652
653 if (sm_read_sector(ftl,
654 0, ftl->cis_block, ftl->cis_boffset, ftl->cis_buffer, &oob))
655 return -EIO;
656
657 if (!sm_sector_valid(&oob) || !sm_block_valid(&oob))
658 return -EIO;
659
660 if (!memcmp(ftl->cis_buffer + ftl->cis_page_offset,
661 cis_signature, sizeof(cis_signature))) {
662 return 0;
663 }
664
665 return -EIO;
666}
667
668
669static int sm_find_cis(struct sm_ftl *ftl)
670{
671 struct sm_oob oob;
672 int block, boffset;
673 int block_found = 0;
674 int cis_found = 0;
675
676
677 for (block = 0 ; block < ftl->zone_size - ftl->max_lba ; block++) {
678
679 if (sm_read_sector(ftl, 0, block, 0, NULL, &oob))
680 continue;
681
682 if (!sm_block_valid(&oob))
683 continue;
684 block_found = 1;
685 break;
686 }
687
688 if (!block_found)
689 return -EIO;
690
691
692 for (boffset = 0 ; boffset < ftl->block_size;
693 boffset += SM_SECTOR_SIZE) {
694
695 if (sm_read_sector(ftl, 0, block, boffset, NULL, &oob))
696 continue;
697
698 if (!sm_sector_valid(&oob))
699 continue;
700 break;
701 }
702
703 if (boffset == ftl->block_size)
704 return -EIO;
705
706 ftl->cis_block = block;
707 ftl->cis_boffset = boffset;
708 ftl->cis_page_offset = 0;
709
710 cis_found = !sm_read_cis(ftl);
711
712 if (!cis_found) {
713 ftl->cis_page_offset = SM_SMALL_PAGE;
714 cis_found = !sm_read_cis(ftl);
715 }
716
717 if (cis_found) {
718 dbg("CIS block found at offset %x",
719 block * ftl->block_size +
720 boffset + ftl->cis_page_offset);
721 return 0;
722 }
723 return -EIO;
724}
725
726
727static int sm_recheck_media(struct sm_ftl *ftl)
728{
729 if (sm_read_cis(ftl)) {
730
731 if (!ftl->unstable) {
732 sm_printk("media unstable, not allowing writes");
733 ftl->unstable = 1;
734 }
735 return -EIO;
736 }
737 return 0;
738}
739
740
741static int sm_init_zone(struct sm_ftl *ftl, int zone_num)
742{
743 struct ftl_zone *zone = &ftl->zones[zone_num];
744 struct sm_oob oob;
745 uint16_t block;
746 int lba;
747 int i = 0;
748 int len;
749
750 dbg("initializing zone %d", zone_num);
751
752
753 zone->lba_to_phys_table = kmalloc(ftl->max_lba * 2, GFP_KERNEL);
754
755 if (!zone->lba_to_phys_table)
756 return -ENOMEM;
757 memset(zone->lba_to_phys_table, -1, ftl->max_lba * 2);
758
759
760
761 if (kfifo_alloc(&zone->free_sectors, ftl->zone_size * 2, GFP_KERNEL)) {
762 kfree(zone->lba_to_phys_table);
763 return -ENOMEM;
764 }
765
766
767 for (block = 0 ; block < ftl->zone_size ; block++) {
768
769
770 if (zone_num == 0 && block <= ftl->cis_block)
771 continue;
772
773
774 if (sm_read_sector(ftl, zone_num, block, 0, NULL, &oob))
775 return -EIO;
776
777
778
779 if (sm_block_erased(&oob)) {
780 kfifo_in(&zone->free_sectors,
781 (unsigned char *)&block, 2);
782 continue;
783 }
784
785
786
787
788
789 if (!sm_block_valid(&oob)) {
790 dbg("PH %04d <-> <marked bad>", block);
791 continue;
792 }
793
794
795 lba = sm_read_lba(&oob);
796
797
798
799
800 if (lba == -2 || lba >= ftl->max_lba) {
801 dbg("PH %04d <-> LBA %04d(bad)", block, lba);
802 continue;
803 }
804
805
806
807
808 if (zone->lba_to_phys_table[lba] < 0) {
809 dbg_verbose("PH %04d <-> LBA %04d", block, lba);
810 zone->lba_to_phys_table[lba] = block;
811 continue;
812 }
813
814 sm_printk("collision"
815 " of LBA %d between blocks %d and %d in zone %d",
816 lba, zone->lba_to_phys_table[lba], block, zone_num);
817
818
819 if (sm_check_block(ftl, zone_num, block))
820 continue;
821
822
823 if (sm_check_block(ftl, zone_num,
824 zone->lba_to_phys_table[lba])) {
825 zone->lba_to_phys_table[lba] = block;
826 continue;
827 }
828
829
830
831
832
833 sm_printk("both blocks are valid, erasing the later");
834 sm_erase_block(ftl, zone_num, block, 1);
835 }
836
837 dbg("zone initialized");
838 zone->initialized = 1;
839
840
841
842 if (!kfifo_len(&zone->free_sectors)) {
843 sm_printk("no free blocks in zone %d", zone_num);
844 return 0;
845 }
846
847
848 get_random_bytes(&i, 2);
849 i %= (kfifo_len(&zone->free_sectors) / 2);
850
851 while (i--) {
852 len = kfifo_out(&zone->free_sectors,
853 (unsigned char *)&block, 2);
854 WARN_ON(len != 2);
855 kfifo_in(&zone->free_sectors, (const unsigned char *)&block, 2);
856 }
857 return 0;
858}
859
860
861static struct ftl_zone *sm_get_zone(struct sm_ftl *ftl, int zone_num)
862{
863 struct ftl_zone *zone;
864 int error;
865
866 BUG_ON(zone_num >= ftl->zone_count);
867 zone = &ftl->zones[zone_num];
868
869 if (!zone->initialized) {
870 error = sm_init_zone(ftl, zone_num);
871
872 if (error)
873 return ERR_PTR(error);
874 }
875 return zone;
876}
877
878
879
880
881
882static void sm_cache_init(struct sm_ftl *ftl)
883{
884 ftl->cache_data_invalid_bitmap = 0xFFFFFFFF;
885 ftl->cache_clean = 1;
886 ftl->cache_zone = -1;
887 ftl->cache_block = -1;
888
889}
890
891
892static void sm_cache_put(struct sm_ftl *ftl, char *buffer, int boffset)
893{
894 memcpy(ftl->cache_data + boffset, buffer, SM_SECTOR_SIZE);
895 clear_bit(boffset / SM_SECTOR_SIZE, &ftl->cache_data_invalid_bitmap);
896 ftl->cache_clean = 0;
897}
898
899
900static int sm_cache_get(struct sm_ftl *ftl, char *buffer, int boffset)
901{
902 if (test_bit(boffset / SM_SECTOR_SIZE,
903 &ftl->cache_data_invalid_bitmap))
904 return -1;
905
906 memcpy(buffer, ftl->cache_data + boffset, SM_SECTOR_SIZE);
907 return 0;
908}
909
910
911static int sm_cache_flush(struct sm_ftl *ftl)
912{
913 struct ftl_zone *zone;
914
915 int sector_num;
916 uint16_t write_sector;
917 int zone_num = ftl->cache_zone;
918 int block_num;
919
920 if (ftl->cache_clean)
921 return 0;
922
923 if (ftl->unstable)
924 return -EIO;
925
926 BUG_ON(zone_num < 0);
927 zone = &ftl->zones[zone_num];
928 block_num = zone->lba_to_phys_table[ftl->cache_block];
929
930
931
932 for_each_set_bit(sector_num, &ftl->cache_data_invalid_bitmap,
933 ftl->block_size / SM_SECTOR_SIZE) {
934
935 if (!sm_read_sector(ftl,
936 zone_num, block_num, sector_num * SM_SECTOR_SIZE,
937 ftl->cache_data + sector_num * SM_SECTOR_SIZE, NULL))
938 clear_bit(sector_num,
939 &ftl->cache_data_invalid_bitmap);
940 }
941restart:
942
943 if (ftl->unstable)
944 return -EIO;
945
946
947
948
949
950 if (kfifo_out(&zone->free_sectors,
951 (unsigned char *)&write_sector, 2) != 2) {
952 dbg("no free sectors for write!");
953 return -EIO;
954 }
955
956
957 if (sm_write_block(ftl, ftl->cache_data, zone_num, write_sector,
958 ftl->cache_block, ftl->cache_data_invalid_bitmap))
959 goto restart;
960
961
962 zone->lba_to_phys_table[ftl->cache_block] = write_sector;
963
964
965 if (block_num > 0)
966 sm_erase_block(ftl, zone_num, block_num, 1);
967
968 sm_cache_init(ftl);
969 return 0;
970}
971
972
973
974static void sm_cache_flush_timer(struct timer_list *t)
975{
976 struct sm_ftl *ftl = from_timer(ftl, t, timer);
977 queue_work(cache_flush_workqueue, &ftl->flush_work);
978}
979
980
981static void sm_cache_flush_work(struct work_struct *work)
982{
983 struct sm_ftl *ftl = container_of(work, struct sm_ftl, flush_work);
984 mutex_lock(&ftl->mutex);
985 sm_cache_flush(ftl);
986 mutex_unlock(&ftl->mutex);
987 return;
988}
989
990
991
992
993static int sm_read(struct mtd_blktrans_dev *dev,
994 unsigned long sect_no, char *buf)
995{
996 struct sm_ftl *ftl = dev->priv;
997 struct ftl_zone *zone;
998 int error = 0, in_cache = 0;
999 int zone_num, block, boffset;
1000
1001 sm_break_offset(ftl, sect_no << 9, &zone_num, &block, &boffset);
1002 mutex_lock(&ftl->mutex);
1003
1004
1005 zone = sm_get_zone(ftl, zone_num);
1006 if (IS_ERR(zone)) {
1007 error = PTR_ERR(zone);
1008 goto unlock;
1009 }
1010
1011
1012 if (ftl->cache_zone == zone_num && ftl->cache_block == block) {
1013 in_cache = 1;
1014 if (!sm_cache_get(ftl, buf, boffset))
1015 goto unlock;
1016 }
1017
1018
1019 block = zone->lba_to_phys_table[block];
1020
1021 if (block == -1) {
1022 memset(buf, 0xFF, SM_SECTOR_SIZE);
1023 goto unlock;
1024 }
1025
1026 if (sm_read_sector(ftl, zone_num, block, boffset, buf, NULL)) {
1027 error = -EIO;
1028 goto unlock;
1029 }
1030
1031 if (in_cache)
1032 sm_cache_put(ftl, buf, boffset);
1033unlock:
1034 mutex_unlock(&ftl->mutex);
1035 return error;
1036}
1037
1038
1039static int sm_write(struct mtd_blktrans_dev *dev,
1040 unsigned long sec_no, char *buf)
1041{
1042 struct sm_ftl *ftl = dev->priv;
1043 struct ftl_zone *zone;
1044 int error = 0, zone_num, block, boffset;
1045
1046 BUG_ON(ftl->readonly);
1047 sm_break_offset(ftl, sec_no << 9, &zone_num, &block, &boffset);
1048
1049
1050 del_timer(&ftl->timer);
1051 mutex_lock(&ftl->mutex);
1052
1053 zone = sm_get_zone(ftl, zone_num);
1054 if (IS_ERR(zone)) {
1055 error = PTR_ERR(zone);
1056 goto unlock;
1057 }
1058
1059
1060 if (ftl->cache_block != block || ftl->cache_zone != zone_num) {
1061
1062 error = sm_cache_flush(ftl);
1063 if (error)
1064 goto unlock;
1065
1066 ftl->cache_block = block;
1067 ftl->cache_zone = zone_num;
1068 }
1069
1070 sm_cache_put(ftl, buf, boffset);
1071unlock:
1072 mod_timer(&ftl->timer, jiffies + msecs_to_jiffies(cache_timeout));
1073 mutex_unlock(&ftl->mutex);
1074 return error;
1075}
1076
1077
1078static int sm_flush(struct mtd_blktrans_dev *dev)
1079{
1080 struct sm_ftl *ftl = dev->priv;
1081 int retval;
1082
1083 mutex_lock(&ftl->mutex);
1084 retval = sm_cache_flush(ftl);
1085 mutex_unlock(&ftl->mutex);
1086 return retval;
1087}
1088
1089
1090static void sm_release(struct mtd_blktrans_dev *dev)
1091{
1092 struct sm_ftl *ftl = dev->priv;
1093
1094 mutex_lock(&ftl->mutex);
1095 del_timer_sync(&ftl->timer);
1096 cancel_work_sync(&ftl->flush_work);
1097 sm_cache_flush(ftl);
1098 mutex_unlock(&ftl->mutex);
1099}
1100
1101
1102static int sm_getgeo(struct mtd_blktrans_dev *dev, struct hd_geometry *geo)
1103{
1104 struct sm_ftl *ftl = dev->priv;
1105 geo->heads = ftl->heads;
1106 geo->sectors = ftl->sectors;
1107 geo->cylinders = ftl->cylinders;
1108 return 0;
1109}
1110
1111
1112static void sm_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd)
1113{
1114 struct mtd_blktrans_dev *trans;
1115 struct sm_ftl *ftl;
1116
1117
1118 ftl = kzalloc(sizeof(struct sm_ftl), GFP_KERNEL);
1119 if (!ftl)
1120 goto error1;
1121
1122
1123 mutex_init(&ftl->mutex);
1124 timer_setup(&ftl->timer, sm_cache_flush_timer, 0);
1125 INIT_WORK(&ftl->flush_work, sm_cache_flush_work);
1126
1127
1128 if (sm_get_media_info(ftl, mtd)) {
1129 dbg("found unsupported mtd device, aborting");
1130 goto error2;
1131 }
1132
1133
1134
1135 ftl->cis_buffer = kzalloc(SM_SECTOR_SIZE, GFP_KERNEL);
1136 if (!ftl->cis_buffer)
1137 goto error2;
1138
1139
1140 ftl->zones = kzalloc(sizeof(struct ftl_zone) * ftl->zone_count,
1141 GFP_KERNEL);
1142 if (!ftl->zones)
1143 goto error3;
1144
1145
1146 ftl->cache_data = kzalloc(ftl->block_size, GFP_KERNEL);
1147
1148 if (!ftl->cache_data)
1149 goto error4;
1150
1151 sm_cache_init(ftl);
1152
1153
1154
1155 trans = kzalloc(sizeof(struct mtd_blktrans_dev), GFP_KERNEL);
1156 if (!trans)
1157 goto error5;
1158
1159 ftl->trans = trans;
1160 trans->priv = ftl;
1161
1162 trans->tr = tr;
1163 trans->mtd = mtd;
1164 trans->devnum = -1;
1165 trans->size = (ftl->block_size * ftl->max_lba * ftl->zone_count) >> 9;
1166 trans->readonly = ftl->readonly;
1167
1168 if (sm_find_cis(ftl)) {
1169 dbg("CIS not found on mtd device, aborting");
1170 goto error6;
1171 }
1172
1173 ftl->disk_attributes = sm_create_sysfs_attributes(ftl);
1174 if (!ftl->disk_attributes)
1175 goto error6;
1176 trans->disk_attributes = ftl->disk_attributes;
1177
1178 sm_printk("Found %d MiB xD/SmartMedia FTL on mtd%d",
1179 (int)(mtd->size / (1024 * 1024)), mtd->index);
1180
1181 dbg("FTL layout:");
1182 dbg("%d zone(s), each consists of %d blocks (+%d spares)",
1183 ftl->zone_count, ftl->max_lba,
1184 ftl->zone_size - ftl->max_lba);
1185 dbg("each block consists of %d bytes",
1186 ftl->block_size);
1187
1188
1189
1190 if (add_mtd_blktrans_dev(trans)) {
1191 dbg("error in mtdblktrans layer");
1192 goto error6;
1193 }
1194 return;
1195error6:
1196 kfree(trans);
1197error5:
1198 kfree(ftl->cache_data);
1199error4:
1200 kfree(ftl->zones);
1201error3:
1202 kfree(ftl->cis_buffer);
1203error2:
1204 kfree(ftl);
1205error1:
1206 return;
1207}
1208
1209
1210static void sm_remove_dev(struct mtd_blktrans_dev *dev)
1211{
1212 struct sm_ftl *ftl = dev->priv;
1213 int i;
1214
1215 del_mtd_blktrans_dev(dev);
1216 ftl->trans = NULL;
1217
1218 for (i = 0 ; i < ftl->zone_count; i++) {
1219
1220 if (!ftl->zones[i].initialized)
1221 continue;
1222
1223 kfree(ftl->zones[i].lba_to_phys_table);
1224 kfifo_free(&ftl->zones[i].free_sectors);
1225 }
1226
1227 sm_delete_sysfs_attributes(ftl);
1228 kfree(ftl->cis_buffer);
1229 kfree(ftl->zones);
1230 kfree(ftl->cache_data);
1231 kfree(ftl);
1232}
1233
1234static struct mtd_blktrans_ops sm_ftl_ops = {
1235 .name = "smblk",
1236 .major = 0,
1237 .part_bits = SM_FTL_PARTN_BITS,
1238 .blksize = SM_SECTOR_SIZE,
1239 .getgeo = sm_getgeo,
1240
1241 .add_mtd = sm_add_mtd,
1242 .remove_dev = sm_remove_dev,
1243
1244 .readsect = sm_read,
1245 .writesect = sm_write,
1246
1247 .flush = sm_flush,
1248 .release = sm_release,
1249
1250 .owner = THIS_MODULE,
1251};
1252
1253static __init int sm_module_init(void)
1254{
1255 int error = 0;
1256
1257 cache_flush_workqueue = create_freezable_workqueue("smflush");
1258 if (!cache_flush_workqueue)
1259 return -ENOMEM;
1260
1261 error = register_mtd_blktrans(&sm_ftl_ops);
1262 if (error)
1263 destroy_workqueue(cache_flush_workqueue);
1264 return error;
1265
1266}
1267
1268static void __exit sm_module_exit(void)
1269{
1270 destroy_workqueue(cache_flush_workqueue);
1271 deregister_mtd_blktrans(&sm_ftl_ops);
1272}
1273
1274module_init(sm_module_init);
1275module_exit(sm_module_exit);
1276
1277MODULE_LICENSE("GPL");
1278MODULE_AUTHOR("Maxim Levitsky <maximlevitsky@gmail.com>");
1279MODULE_DESCRIPTION("Smartmedia/xD mtd translation layer");
1280