1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22#include <linux/kernel.h>
23#include <linux/module.h>
24#include <linux/errno.h>
25#include <linux/of.h>
26#include <linux/platform_device.h>
27#include <linux/string.h>
28#include <linux/slab.h>
29#include <linux/io.h>
30#include <linux/delay.h>
31#include <linux/mtd/mtd.h>
32#include <linux/mtd/partitions.h>
33#include <linux/bitmap.h>
34#include <linux/bitrev.h>
35#include <linux/bch.h>
36
37#include <linux/debugfs.h>
38#include <linux/seq_file.h>
39
40#define CREATE_TRACE_POINTS
41#include "docg3.h"
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65static unsigned int reliable_mode;
66module_param(reliable_mode, uint, 0);
67MODULE_PARM_DESC(reliable_mode, "Set the docg3 mode (0=normal MLC, 1=fast, "
68 "2=reliable) : MLC normal operations are in normal mode");
69
70static int docg3_ooblayout_ecc(struct mtd_info *mtd, int section,
71 struct mtd_oob_region *oobregion)
72{
73 if (section)
74 return -ERANGE;
75
76
77 oobregion->offset = 7;
78 oobregion->length = 8;
79
80 return 0;
81}
82
83static int docg3_ooblayout_free(struct mtd_info *mtd, int section,
84 struct mtd_oob_region *oobregion)
85{
86 if (section > 1)
87 return -ERANGE;
88
89
90 if (!section) {
91 oobregion->offset = 0;
92 oobregion->length = 7;
93 } else {
94 oobregion->offset = 15;
95 oobregion->length = 1;
96 }
97
98 return 0;
99}
100
101static const struct mtd_ooblayout_ops nand_ooblayout_docg3_ops = {
102 .ecc = docg3_ooblayout_ecc,
103 .free = docg3_ooblayout_free,
104};
105
106static inline u8 doc_readb(struct docg3 *docg3, u16 reg)
107{
108 u8 val = readb(docg3->cascade->base + reg);
109
110 trace_docg3_io(0, 8, reg, (int)val);
111 return val;
112}
113
114static inline u16 doc_readw(struct docg3 *docg3, u16 reg)
115{
116 u16 val = readw(docg3->cascade->base + reg);
117
118 trace_docg3_io(0, 16, reg, (int)val);
119 return val;
120}
121
122static inline void doc_writeb(struct docg3 *docg3, u8 val, u16 reg)
123{
124 writeb(val, docg3->cascade->base + reg);
125 trace_docg3_io(1, 8, reg, val);
126}
127
128static inline void doc_writew(struct docg3 *docg3, u16 val, u16 reg)
129{
130 writew(val, docg3->cascade->base + reg);
131 trace_docg3_io(1, 16, reg, val);
132}
133
134static inline void doc_flash_command(struct docg3 *docg3, u8 cmd)
135{
136 doc_writeb(docg3, cmd, DOC_FLASHCOMMAND);
137}
138
139static inline void doc_flash_sequence(struct docg3 *docg3, u8 seq)
140{
141 doc_writeb(docg3, seq, DOC_FLASHSEQUENCE);
142}
143
144static inline void doc_flash_address(struct docg3 *docg3, u8 addr)
145{
146 doc_writeb(docg3, addr, DOC_FLASHADDRESS);
147}
148
149static char const * const part_probes[] = { "cmdlinepart", "saftlpart", NULL };
150
151static int doc_register_readb(struct docg3 *docg3, int reg)
152{
153 u8 val;
154
155 doc_writew(docg3, reg, DOC_READADDRESS);
156 val = doc_readb(docg3, reg);
157 doc_vdbg("Read register %04x : %02x\n", reg, val);
158 return val;
159}
160
161static int doc_register_readw(struct docg3 *docg3, int reg)
162{
163 u16 val;
164
165 doc_writew(docg3, reg, DOC_READADDRESS);
166 val = doc_readw(docg3, reg);
167 doc_vdbg("Read register %04x : %04x\n", reg, val);
168 return val;
169}
170
171
172
173
174
175
176
177
178
179
180
181
182static void doc_delay(struct docg3 *docg3, int nbNOPs)
183{
184 int i;
185
186 doc_vdbg("NOP x %d\n", nbNOPs);
187 for (i = 0; i < nbNOPs; i++)
188 doc_writeb(docg3, 0, DOC_NOP);
189}
190
191static int is_prot_seq_error(struct docg3 *docg3)
192{
193 int ctrl;
194
195 ctrl = doc_register_readb(docg3, DOC_FLASHCONTROL);
196 return ctrl & (DOC_CTRL_PROTECTION_ERROR | DOC_CTRL_SEQUENCE_ERROR);
197}
198
199static int doc_is_ready(struct docg3 *docg3)
200{
201 int ctrl;
202
203 ctrl = doc_register_readb(docg3, DOC_FLASHCONTROL);
204 return ctrl & DOC_CTRL_FLASHREADY;
205}
206
207static int doc_wait_ready(struct docg3 *docg3)
208{
209 int maxWaitCycles = 100;
210
211 do {
212 doc_delay(docg3, 4);
213 cpu_relax();
214 } while (!doc_is_ready(docg3) && maxWaitCycles--);
215 doc_delay(docg3, 2);
216 if (maxWaitCycles > 0)
217 return 0;
218 else
219 return -EIO;
220}
221
222static int doc_reset_seq(struct docg3 *docg3)
223{
224 int ret;
225
226 doc_writeb(docg3, 0x10, DOC_FLASHCONTROL);
227 doc_flash_sequence(docg3, DOC_SEQ_RESET);
228 doc_flash_command(docg3, DOC_CMD_RESET);
229 doc_delay(docg3, 2);
230 ret = doc_wait_ready(docg3);
231
232 doc_dbg("doc_reset_seq() -> isReady=%s\n", ret ? "false" : "true");
233 return ret;
234}
235
236
237
238
239
240
241
242
243
244
245static void doc_read_data_area(struct docg3 *docg3, void *buf, int len,
246 int first)
247{
248 int i, cdr, len4;
249 u16 data16, *dst16;
250 u8 data8, *dst8;
251
252 doc_dbg("doc_read_data_area(buf=%p, len=%d)\n", buf, len);
253 cdr = len & 0x1;
254 len4 = len - cdr;
255
256 if (first)
257 doc_writew(docg3, DOC_IOSPACE_DATA, DOC_READADDRESS);
258 dst16 = buf;
259 for (i = 0; i < len4; i += 2) {
260 data16 = doc_readw(docg3, DOC_IOSPACE_DATA);
261 if (dst16) {
262 *dst16 = data16;
263 dst16++;
264 }
265 }
266
267 if (cdr) {
268 doc_writew(docg3, DOC_IOSPACE_DATA | DOC_READADDR_ONE_BYTE,
269 DOC_READADDRESS);
270 doc_delay(docg3, 1);
271 dst8 = (u8 *)dst16;
272 for (i = 0; i < cdr; i++) {
273 data8 = doc_readb(docg3, DOC_IOSPACE_DATA);
274 if (dst8) {
275 *dst8 = data8;
276 dst8++;
277 }
278 }
279 }
280}
281
282
283
284
285
286
287
288
289
290static void doc_write_data_area(struct docg3 *docg3, const void *buf, int len)
291{
292 int i, cdr, len4;
293 u16 *src16;
294 u8 *src8;
295
296 doc_dbg("doc_write_data_area(buf=%p, len=%d)\n", buf, len);
297 cdr = len & 0x3;
298 len4 = len - cdr;
299
300 doc_writew(docg3, DOC_IOSPACE_DATA, DOC_READADDRESS);
301 src16 = (u16 *)buf;
302 for (i = 0; i < len4; i += 2) {
303 doc_writew(docg3, *src16, DOC_IOSPACE_DATA);
304 src16++;
305 }
306
307 src8 = (u8 *)src16;
308 for (i = 0; i < cdr; i++) {
309 doc_writew(docg3, DOC_IOSPACE_DATA | DOC_READADDR_ONE_BYTE,
310 DOC_READADDRESS);
311 doc_writeb(docg3, *src8, DOC_IOSPACE_DATA);
312 src8++;
313 }
314}
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331static void doc_set_reliable_mode(struct docg3 *docg3)
332{
333 static char *strmode[] = { "normal", "fast", "reliable", "invalid" };
334
335 doc_dbg("doc_set_reliable_mode(%s)\n", strmode[docg3->reliable]);
336 switch (docg3->reliable) {
337 case 0:
338 break;
339 case 1:
340 doc_flash_sequence(docg3, DOC_SEQ_SET_FASTMODE);
341 doc_flash_command(docg3, DOC_CMD_FAST_MODE);
342 break;
343 case 2:
344 doc_flash_sequence(docg3, DOC_SEQ_SET_RELIABLEMODE);
345 doc_flash_command(docg3, DOC_CMD_FAST_MODE);
346 doc_flash_command(docg3, DOC_CMD_RELIABLE_MODE);
347 break;
348 default:
349 doc_err("doc_set_reliable_mode(): invalid mode\n");
350 break;
351 }
352 doc_delay(docg3, 2);
353}
354
355
356
357
358
359
360
361
362
363
364
365static void doc_set_asic_mode(struct docg3 *docg3, u8 mode)
366{
367 int i;
368
369 for (i = 0; i < 12; i++)
370 doc_readb(docg3, DOC_IOSPACE_IPL);
371
372 mode |= DOC_ASICMODE_MDWREN;
373 doc_dbg("doc_set_asic_mode(%02x)\n", mode);
374 doc_writeb(docg3, mode, DOC_ASICMODE);
375 doc_writeb(docg3, ~mode, DOC_ASICMODECONFIRM);
376 doc_delay(docg3, 1);
377}
378
379
380
381
382
383
384
385
386
387static void doc_set_device_id(struct docg3 *docg3, int id)
388{
389 u8 ctrl;
390
391 doc_dbg("doc_set_device_id(%d)\n", id);
392 doc_writeb(docg3, id, DOC_DEVICESELECT);
393 ctrl = doc_register_readb(docg3, DOC_FLASHCONTROL);
394
395 ctrl &= ~DOC_CTRL_VIOLATION;
396 ctrl |= DOC_CTRL_CE;
397 doc_writeb(docg3, ctrl, DOC_FLASHCONTROL);
398}
399
400
401
402
403
404
405
406
407
408
409
410
411static int doc_set_extra_page_mode(struct docg3 *docg3)
412{
413 int fctrl;
414
415 doc_dbg("doc_set_extra_page_mode()\n");
416 doc_flash_sequence(docg3, DOC_SEQ_PAGE_SIZE_532);
417 doc_flash_command(docg3, DOC_CMD_PAGE_SIZE_532);
418 doc_delay(docg3, 2);
419
420 fctrl = doc_register_readb(docg3, DOC_FLASHCONTROL);
421 if (fctrl & (DOC_CTRL_PROTECTION_ERROR | DOC_CTRL_SEQUENCE_ERROR))
422 return -EIO;
423 else
424 return 0;
425}
426
427
428
429
430
431
432static void doc_setup_addr_sector(struct docg3 *docg3, int sector)
433{
434 doc_delay(docg3, 1);
435 doc_flash_address(docg3, sector & 0xff);
436 doc_flash_address(docg3, (sector >> 8) & 0xff);
437 doc_flash_address(docg3, (sector >> 16) & 0xff);
438 doc_delay(docg3, 1);
439}
440
441
442
443
444
445
446
447static void doc_setup_writeaddr_sector(struct docg3 *docg3, int sector, int ofs)
448{
449 ofs = ofs >> 2;
450 doc_delay(docg3, 1);
451 doc_flash_address(docg3, ofs & 0xff);
452 doc_flash_address(docg3, sector & 0xff);
453 doc_flash_address(docg3, (sector >> 8) & 0xff);
454 doc_flash_address(docg3, (sector >> 16) & 0xff);
455 doc_delay(docg3, 1);
456}
457
458
459
460
461
462
463
464
465
466
467
468
469
470static int doc_read_seek(struct docg3 *docg3, int block0, int block1, int page,
471 int wear, int ofs)
472{
473 int sector, ret = 0;
474
475 doc_dbg("doc_seek(blocks=(%d,%d), page=%d, ofs=%d, wear=%d)\n",
476 block0, block1, page, ofs, wear);
477
478 if (!wear && (ofs < 2 * DOC_LAYOUT_PAGE_SIZE)) {
479 doc_flash_sequence(docg3, DOC_SEQ_SET_PLANE1);
480 doc_flash_command(docg3, DOC_CMD_READ_PLANE1);
481 doc_delay(docg3, 2);
482 } else {
483 doc_flash_sequence(docg3, DOC_SEQ_SET_PLANE2);
484 doc_flash_command(docg3, DOC_CMD_READ_PLANE2);
485 doc_delay(docg3, 2);
486 }
487
488 doc_set_reliable_mode(docg3);
489 if (wear)
490 ret = doc_set_extra_page_mode(docg3);
491 if (ret)
492 goto out;
493
494 doc_flash_sequence(docg3, DOC_SEQ_READ);
495 sector = (block0 << DOC_ADDR_BLOCK_SHIFT) + (page & DOC_ADDR_PAGE_MASK);
496 doc_flash_command(docg3, DOC_CMD_PROG_BLOCK_ADDR);
497 doc_setup_addr_sector(docg3, sector);
498
499 sector = (block1 << DOC_ADDR_BLOCK_SHIFT) + (page & DOC_ADDR_PAGE_MASK);
500 doc_flash_command(docg3, DOC_CMD_PROG_BLOCK_ADDR);
501 doc_setup_addr_sector(docg3, sector);
502 doc_delay(docg3, 1);
503
504out:
505 return ret;
506}
507
508
509
510
511
512
513
514
515
516
517
518
519static int doc_write_seek(struct docg3 *docg3, int block0, int block1, int page,
520 int ofs)
521{
522 int ret = 0, sector;
523
524 doc_dbg("doc_write_seek(blocks=(%d,%d), page=%d, ofs=%d)\n",
525 block0, block1, page, ofs);
526
527 doc_set_reliable_mode(docg3);
528
529 if (ofs < 2 * DOC_LAYOUT_PAGE_SIZE) {
530 doc_flash_sequence(docg3, DOC_SEQ_SET_PLANE1);
531 doc_flash_command(docg3, DOC_CMD_READ_PLANE1);
532 doc_delay(docg3, 2);
533 } else {
534 doc_flash_sequence(docg3, DOC_SEQ_SET_PLANE2);
535 doc_flash_command(docg3, DOC_CMD_READ_PLANE2);
536 doc_delay(docg3, 2);
537 }
538
539 doc_flash_sequence(docg3, DOC_SEQ_PAGE_SETUP);
540 doc_flash_command(docg3, DOC_CMD_PROG_CYCLE1);
541
542 sector = (block0 << DOC_ADDR_BLOCK_SHIFT) + (page & DOC_ADDR_PAGE_MASK);
543 doc_setup_writeaddr_sector(docg3, sector, ofs);
544
545 doc_flash_command(docg3, DOC_CMD_PROG_CYCLE3);
546 doc_delay(docg3, 2);
547 ret = doc_wait_ready(docg3);
548 if (ret)
549 goto out;
550
551 doc_flash_command(docg3, DOC_CMD_PROG_CYCLE1);
552 sector = (block1 << DOC_ADDR_BLOCK_SHIFT) + (page & DOC_ADDR_PAGE_MASK);
553 doc_setup_writeaddr_sector(docg3, sector, ofs);
554 doc_delay(docg3, 1);
555
556out:
557 return ret;
558}
559
560
561
562
563
564
565
566
567
568
569
570
571static int doc_read_page_ecc_init(struct docg3 *docg3, int len)
572{
573 doc_writew(docg3, DOC_ECCCONF0_READ_MODE
574 | DOC_ECCCONF0_BCH_ENABLE | DOC_ECCCONF0_HAMMING_ENABLE
575 | (len & DOC_ECCCONF0_DATA_BYTES_MASK),
576 DOC_ECCCONF0);
577 doc_delay(docg3, 4);
578 doc_register_readb(docg3, DOC_FLASHCONTROL);
579 return doc_wait_ready(docg3);
580}
581
582
583
584
585
586
587
588
589
590
591
592static int doc_write_page_ecc_init(struct docg3 *docg3, int len)
593{
594 doc_writew(docg3, DOC_ECCCONF0_WRITE_MODE
595 | DOC_ECCCONF0_BCH_ENABLE | DOC_ECCCONF0_HAMMING_ENABLE
596 | (len & DOC_ECCCONF0_DATA_BYTES_MASK),
597 DOC_ECCCONF0);
598 doc_delay(docg3, 4);
599 doc_register_readb(docg3, DOC_FLASHCONTROL);
600 return doc_wait_ready(docg3);
601}
602
603
604
605
606
607
608
609
610static void doc_ecc_disable(struct docg3 *docg3)
611{
612 doc_writew(docg3, DOC_ECCCONF0_READ_MODE, DOC_ECCCONF0);
613 doc_delay(docg3, 4);
614}
615
616
617
618
619
620
621
622
623
624static void doc_hamming_ecc_init(struct docg3 *docg3, int nb_bytes)
625{
626 u8 ecc_conf1;
627
628 ecc_conf1 = doc_register_readb(docg3, DOC_ECCCONF1);
629 ecc_conf1 &= ~DOC_ECCCONF1_HAMMING_BITS_MASK;
630 ecc_conf1 |= (nb_bytes & DOC_ECCCONF1_HAMMING_BITS_MASK);
631 doc_writeb(docg3, ecc_conf1, DOC_ECCCONF1);
632}
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657static int doc_ecc_bch_fix_data(struct docg3 *docg3, void *buf, u8 *hwecc)
658{
659 u8 ecc[DOC_ECC_BCH_SIZE];
660 int errorpos[DOC_ECC_BCH_T], i, numerrs;
661
662 for (i = 0; i < DOC_ECC_BCH_SIZE; i++)
663 ecc[i] = bitrev8(hwecc[i]);
664 numerrs = decode_bch(docg3->cascade->bch, NULL,
665 DOC_ECC_BCH_COVERED_BYTES,
666 NULL, ecc, NULL, errorpos);
667 BUG_ON(numerrs == -EINVAL);
668 if (numerrs < 0)
669 goto out;
670
671 for (i = 0; i < numerrs; i++)
672 errorpos[i] = (errorpos[i] & ~7) | (7 - (errorpos[i] & 7));
673 for (i = 0; i < numerrs; i++)
674 if (errorpos[i] < DOC_ECC_BCH_COVERED_BYTES*8)
675
676 change_bit(errorpos[i], buf);
677out:
678 doc_dbg("doc_ecc_bch_fix_data: flipped %d bits\n", numerrs);
679 return numerrs;
680}
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709static int doc_read_page_prepare(struct docg3 *docg3, int block0, int block1,
710 int page, int offset)
711{
712 int wear_area = 0, ret = 0;
713
714 doc_dbg("doc_read_page_prepare(blocks=(%d,%d), page=%d, ofsInPage=%d)\n",
715 block0, block1, page, offset);
716 if (offset >= DOC_LAYOUT_WEAR_OFFSET)
717 wear_area = 1;
718 if (!wear_area && offset > (DOC_LAYOUT_PAGE_OOB_SIZE * 2))
719 return -EINVAL;
720
721 doc_set_device_id(docg3, docg3->device_id);
722 ret = doc_reset_seq(docg3);
723 if (ret)
724 goto err;
725
726
727 ret = doc_read_seek(docg3, block0, block1, page, wear_area, offset);
728 if (ret)
729 goto err;
730
731 doc_flash_command(docg3, DOC_CMD_READ_ALL_PLANES);
732 doc_delay(docg3, 2);
733 doc_wait_ready(docg3);
734
735 doc_flash_command(docg3, DOC_CMD_SET_ADDR_READ);
736 doc_delay(docg3, 1);
737 if (offset >= DOC_LAYOUT_PAGE_SIZE * 2)
738 offset -= 2 * DOC_LAYOUT_PAGE_SIZE;
739 doc_flash_address(docg3, offset >> 2);
740 doc_delay(docg3, 1);
741 doc_wait_ready(docg3);
742
743 doc_flash_command(docg3, DOC_CMD_READ_FLASH);
744
745 return 0;
746err:
747 doc_writeb(docg3, 0, DOC_DATAEND);
748 doc_delay(docg3, 2);
749 return -EIO;
750}
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767static int doc_read_page_getbytes(struct docg3 *docg3, int len, u_char *buf,
768 int first, int last_odd)
769{
770 if (last_odd && len > 0) {
771 doc_read_data_area(docg3, buf, 1, first);
772 doc_read_data_area(docg3, buf ? buf + 1 : buf, len - 1, 0);
773 } else {
774 doc_read_data_area(docg3, buf, len, first);
775 }
776 doc_delay(docg3, 2);
777 return len;
778}
779
780
781
782
783
784
785
786
787static void doc_write_page_putbytes(struct docg3 *docg3, int len,
788 const u_char *buf)
789{
790 doc_write_data_area(docg3, buf, len);
791 doc_delay(docg3, 2);
792}
793
794
795
796
797
798
799static void doc_get_bch_hw_ecc(struct docg3 *docg3, u8 *hwecc)
800{
801 int i;
802
803 for (i = 0; i < DOC_ECC_BCH_SIZE; i++)
804 hwecc[i] = doc_register_readb(docg3, DOC_BCH_HW_ECC(i));
805}
806
807
808
809
810
811static void doc_page_finish(struct docg3 *docg3)
812{
813 doc_writeb(docg3, 0, DOC_DATAEND);
814 doc_delay(docg3, 2);
815}
816
817
818
819
820
821
822
823
824
825static void doc_read_page_finish(struct docg3 *docg3)
826{
827 doc_page_finish(docg3);
828 doc_set_device_id(docg3, 0);
829}
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846static void calc_block_sector(loff_t from, int *block0, int *block1, int *page,
847 int *ofs, int reliable)
848{
849 uint sector, pages_biblock;
850
851 pages_biblock = DOC_LAYOUT_PAGES_PER_BLOCK * DOC_LAYOUT_NBPLANES;
852 if (reliable == 1 || reliable == 2)
853 pages_biblock /= 2;
854
855 sector = from / DOC_LAYOUT_PAGE_SIZE;
856 *block0 = sector / pages_biblock * DOC_LAYOUT_NBPLANES;
857 *block1 = *block0 + 1;
858 *page = sector % pages_biblock;
859 *page /= DOC_LAYOUT_NBPLANES;
860 if (reliable == 1 || reliable == 2)
861 *page *= 2;
862 if (sector % 2)
863 *ofs = DOC_LAYOUT_PAGE_OOB_SIZE;
864 else
865 *ofs = 0;
866}
867
868
869
870
871
872
873
874
875
876
877
878
879static int doc_read_oob(struct mtd_info *mtd, loff_t from,
880 struct mtd_oob_ops *ops)
881{
882 struct docg3 *docg3 = mtd->priv;
883 int block0, block1, page, ret, skip, ofs = 0;
884 u8 *oobbuf = ops->oobbuf;
885 u8 *buf = ops->datbuf;
886 size_t len, ooblen, nbdata, nboob;
887 u8 hwecc[DOC_ECC_BCH_SIZE], eccconf1;
888 int max_bitflips = 0;
889
890 if (buf)
891 len = ops->len;
892 else
893 len = 0;
894 if (oobbuf)
895 ooblen = ops->ooblen;
896 else
897 ooblen = 0;
898
899 if (oobbuf && ops->mode == MTD_OPS_PLACE_OOB)
900 oobbuf += ops->ooboffs;
901
902 doc_dbg("doc_read_oob(from=%lld, mode=%d, data=(%p:%zu), oob=(%p:%zu))\n",
903 from, ops->mode, buf, len, oobbuf, ooblen);
904 if (ooblen % DOC_LAYOUT_OOB_SIZE)
905 return -EINVAL;
906
907 ops->oobretlen = 0;
908 ops->retlen = 0;
909 ret = 0;
910 skip = from % DOC_LAYOUT_PAGE_SIZE;
911 mutex_lock(&docg3->cascade->lock);
912 while (ret >= 0 && (len > 0 || ooblen > 0)) {
913 calc_block_sector(from - skip, &block0, &block1, &page, &ofs,
914 docg3->reliable);
915 nbdata = min_t(size_t, len, DOC_LAYOUT_PAGE_SIZE - skip);
916 nboob = min_t(size_t, ooblen, (size_t)DOC_LAYOUT_OOB_SIZE);
917 ret = doc_read_page_prepare(docg3, block0, block1, page, ofs);
918 if (ret < 0)
919 goto out;
920 ret = doc_read_page_ecc_init(docg3, DOC_ECC_BCH_TOTAL_BYTES);
921 if (ret < 0)
922 goto err_in_read;
923 ret = doc_read_page_getbytes(docg3, skip, NULL, 1, 0);
924 if (ret < skip)
925 goto err_in_read;
926 ret = doc_read_page_getbytes(docg3, nbdata, buf, 0, skip % 2);
927 if (ret < nbdata)
928 goto err_in_read;
929 doc_read_page_getbytes(docg3,
930 DOC_LAYOUT_PAGE_SIZE - nbdata - skip,
931 NULL, 0, (skip + nbdata) % 2);
932 ret = doc_read_page_getbytes(docg3, nboob, oobbuf, 0, 0);
933 if (ret < nboob)
934 goto err_in_read;
935 doc_read_page_getbytes(docg3, DOC_LAYOUT_OOB_SIZE - nboob,
936 NULL, 0, nboob % 2);
937
938 doc_get_bch_hw_ecc(docg3, hwecc);
939 eccconf1 = doc_register_readb(docg3, DOC_ECCCONF1);
940
941 if (nboob >= DOC_LAYOUT_OOB_SIZE) {
942 doc_dbg("OOB - INFO: %*phC\n", 7, oobbuf);
943 doc_dbg("OOB - HAMMING: %02x\n", oobbuf[7]);
944 doc_dbg("OOB - BCH_ECC: %*phC\n", 7, oobbuf + 8);
945 doc_dbg("OOB - UNUSED: %02x\n", oobbuf[15]);
946 }
947 doc_dbg("ECC checks: ECCConf1=%x\n", eccconf1);
948 doc_dbg("ECC HW_ECC: %*phC\n", 7, hwecc);
949
950 ret = -EIO;
951 if (is_prot_seq_error(docg3))
952 goto err_in_read;
953 ret = 0;
954 if ((block0 >= DOC_LAYOUT_BLOCK_FIRST_DATA) &&
955 (eccconf1 & DOC_ECCCONF1_BCH_SYNDROM_ERR) &&
956 (eccconf1 & DOC_ECCCONF1_PAGE_IS_WRITTEN) &&
957 (ops->mode != MTD_OPS_RAW) &&
958 (nbdata == DOC_LAYOUT_PAGE_SIZE)) {
959 ret = doc_ecc_bch_fix_data(docg3, buf, hwecc);
960 if (ret < 0) {
961 mtd->ecc_stats.failed++;
962 ret = -EBADMSG;
963 }
964 if (ret > 0) {
965 mtd->ecc_stats.corrected += ret;
966 max_bitflips = max(max_bitflips, ret);
967 ret = max_bitflips;
968 }
969 }
970
971 doc_read_page_finish(docg3);
972 ops->retlen += nbdata;
973 ops->oobretlen += nboob;
974 buf += nbdata;
975 oobbuf += nboob;
976 len -= nbdata;
977 ooblen -= nboob;
978 from += DOC_LAYOUT_PAGE_SIZE;
979 skip = 0;
980 }
981
982out:
983 mutex_unlock(&docg3->cascade->lock);
984 return ret;
985err_in_read:
986 doc_read_page_finish(docg3);
987 goto out;
988}
989
990static int doc_reload_bbt(struct docg3 *docg3)
991{
992 int block = DOC_LAYOUT_BLOCK_BBT;
993 int ret = 0, nbpages, page;
994 u_char *buf = docg3->bbt;
995
996 nbpages = DIV_ROUND_UP(docg3->max_block + 1, 8 * DOC_LAYOUT_PAGE_SIZE);
997 for (page = 0; !ret && (page < nbpages); page++) {
998 ret = doc_read_page_prepare(docg3, block, block + 1,
999 page + DOC_LAYOUT_PAGE_BBT, 0);
1000 if (!ret)
1001 ret = doc_read_page_ecc_init(docg3,
1002 DOC_LAYOUT_PAGE_SIZE);
1003 if (!ret)
1004 doc_read_page_getbytes(docg3, DOC_LAYOUT_PAGE_SIZE,
1005 buf, 1, 0);
1006 buf += DOC_LAYOUT_PAGE_SIZE;
1007 }
1008 doc_read_page_finish(docg3);
1009 return ret;
1010}
1011
1012
1013
1014
1015
1016
1017
1018
1019static int doc_block_isbad(struct mtd_info *mtd, loff_t from)
1020{
1021 struct docg3 *docg3 = mtd->priv;
1022 int block0, block1, page, ofs, is_good;
1023
1024 calc_block_sector(from, &block0, &block1, &page, &ofs,
1025 docg3->reliable);
1026 doc_dbg("doc_block_isbad(from=%lld) => block=(%d,%d), page=%d, ofs=%d\n",
1027 from, block0, block1, page, ofs);
1028
1029 if (block0 < DOC_LAYOUT_BLOCK_FIRST_DATA)
1030 return 0;
1031 if (block1 > docg3->max_block)
1032 return -EINVAL;
1033
1034 is_good = docg3->bbt[block0 >> 3] & (1 << (block0 & 0x7));
1035 return !is_good;
1036}
1037
1038#if 0
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049static int doc_get_erase_count(struct docg3 *docg3, loff_t from)
1050{
1051 u8 buf[DOC_LAYOUT_WEAR_SIZE];
1052 int ret, plane1_erase_count, plane2_erase_count;
1053 int block0, block1, page, ofs;
1054
1055 doc_dbg("doc_get_erase_count(from=%lld, buf=%p)\n", from, buf);
1056 if (from % DOC_LAYOUT_PAGE_SIZE)
1057 return -EINVAL;
1058 calc_block_sector(from, &block0, &block1, &page, &ofs, docg3->reliable);
1059 if (block1 > docg3->max_block)
1060 return -EINVAL;
1061
1062 ret = doc_reset_seq(docg3);
1063 if (!ret)
1064 ret = doc_read_page_prepare(docg3, block0, block1, page,
1065 ofs + DOC_LAYOUT_WEAR_OFFSET, 0);
1066 if (!ret)
1067 ret = doc_read_page_getbytes(docg3, DOC_LAYOUT_WEAR_SIZE,
1068 buf, 1, 0);
1069 doc_read_page_finish(docg3);
1070
1071 if (ret || (buf[0] != DOC_ERASE_MARK) || (buf[2] != DOC_ERASE_MARK))
1072 return -EIO;
1073 plane1_erase_count = (u8)(~buf[1]) | ((u8)(~buf[4]) << 8)
1074 | ((u8)(~buf[5]) << 16);
1075 plane2_erase_count = (u8)(~buf[3]) | ((u8)(~buf[6]) << 8)
1076 | ((u8)(~buf[7]) << 16);
1077
1078 return max(plane1_erase_count, plane2_erase_count);
1079}
1080#endif
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090static int doc_get_op_status(struct docg3 *docg3)
1091{
1092 u8 status;
1093
1094 doc_flash_sequence(docg3, DOC_SEQ_PLANES_STATUS);
1095 doc_flash_command(docg3, DOC_CMD_PLANES_STATUS);
1096 doc_delay(docg3, 5);
1097
1098 doc_ecc_disable(docg3);
1099 doc_read_data_area(docg3, &status, 1, 1);
1100 return status;
1101}
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113static int doc_write_erase_wait_status(struct docg3 *docg3)
1114{
1115 int i, status, ret = 0;
1116
1117 for (i = 0; !doc_is_ready(docg3) && i < 5; i++)
1118 msleep(20);
1119 if (!doc_is_ready(docg3)) {
1120 doc_dbg("Timeout reached and the chip is still not ready\n");
1121 ret = -EAGAIN;
1122 goto out;
1123 }
1124
1125 status = doc_get_op_status(docg3);
1126 if (status & DOC_PLANES_STATUS_FAIL) {
1127 doc_dbg("Erase/Write failed on (a) plane(s), status = %x\n",
1128 status);
1129 ret = -EIO;
1130 }
1131
1132out:
1133 doc_page_finish(docg3);
1134 return ret;
1135}
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148static int doc_erase_block(struct docg3 *docg3, int block0, int block1)
1149{
1150 int ret, sector;
1151
1152 doc_dbg("doc_erase_block(blocks=(%d,%d))\n", block0, block1);
1153 ret = doc_reset_seq(docg3);
1154 if (ret)
1155 return -EIO;
1156
1157 doc_set_reliable_mode(docg3);
1158 doc_flash_sequence(docg3, DOC_SEQ_ERASE);
1159
1160 sector = block0 << DOC_ADDR_BLOCK_SHIFT;
1161 doc_flash_command(docg3, DOC_CMD_PROG_BLOCK_ADDR);
1162 doc_setup_addr_sector(docg3, sector);
1163 sector = block1 << DOC_ADDR_BLOCK_SHIFT;
1164 doc_flash_command(docg3, DOC_CMD_PROG_BLOCK_ADDR);
1165 doc_setup_addr_sector(docg3, sector);
1166 doc_delay(docg3, 1);
1167
1168 doc_flash_command(docg3, DOC_CMD_ERASECYCLE2);
1169 doc_delay(docg3, 2);
1170
1171 if (is_prot_seq_error(docg3)) {
1172 doc_err("Erase blocks %d,%d error\n", block0, block1);
1173 return -EIO;
1174 }
1175
1176 return doc_write_erase_wait_status(docg3);
1177}
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190static int doc_erase(struct mtd_info *mtd, struct erase_info *info)
1191{
1192 struct docg3 *docg3 = mtd->priv;
1193 uint64_t len;
1194 int block0, block1, page, ret, ofs = 0;
1195
1196 doc_dbg("doc_erase(from=%lld, len=%lld\n", info->addr, info->len);
1197
1198 info->state = MTD_ERASE_PENDING;
1199 calc_block_sector(info->addr + info->len, &block0, &block1, &page,
1200 &ofs, docg3->reliable);
1201 ret = -EINVAL;
1202 if (info->addr + info->len > mtd->size || page || ofs)
1203 goto reset_err;
1204
1205 ret = 0;
1206 calc_block_sector(info->addr, &block0, &block1, &page, &ofs,
1207 docg3->reliable);
1208 mutex_lock(&docg3->cascade->lock);
1209 doc_set_device_id(docg3, docg3->device_id);
1210 doc_set_reliable_mode(docg3);
1211 for (len = info->len; !ret && len > 0; len -= mtd->erasesize) {
1212 info->state = MTD_ERASING;
1213 ret = doc_erase_block(docg3, block0, block1);
1214 block0 += 2;
1215 block1 += 2;
1216 }
1217 mutex_unlock(&docg3->cascade->lock);
1218
1219 if (ret)
1220 goto reset_err;
1221
1222 info->state = MTD_ERASE_DONE;
1223 return 0;
1224
1225reset_err:
1226 info->state = MTD_ERASE_FAILED;
1227 return ret;
1228}
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249static int doc_write_page(struct docg3 *docg3, loff_t to, const u_char *buf,
1250 const u_char *oob, int autoecc)
1251{
1252 int block0, block1, page, ret, ofs = 0;
1253 u8 hwecc[DOC_ECC_BCH_SIZE], hamming;
1254
1255 doc_dbg("doc_write_page(to=%lld)\n", to);
1256 calc_block_sector(to, &block0, &block1, &page, &ofs, docg3->reliable);
1257
1258 doc_set_device_id(docg3, docg3->device_id);
1259 ret = doc_reset_seq(docg3);
1260 if (ret)
1261 goto err;
1262
1263
1264 ret = doc_write_seek(docg3, block0, block1, page, ofs);
1265 if (ret)
1266 goto err;
1267
1268 doc_write_page_ecc_init(docg3, DOC_ECC_BCH_TOTAL_BYTES);
1269 doc_delay(docg3, 2);
1270 doc_write_page_putbytes(docg3, DOC_LAYOUT_PAGE_SIZE, buf);
1271
1272 if (oob && autoecc) {
1273 doc_write_page_putbytes(docg3, DOC_LAYOUT_OOB_PAGEINFO_SZ, oob);
1274 doc_delay(docg3, 2);
1275 oob += DOC_LAYOUT_OOB_UNUSED_OFS;
1276
1277 hamming = doc_register_readb(docg3, DOC_HAMMINGPARITY);
1278 doc_delay(docg3, 2);
1279 doc_write_page_putbytes(docg3, DOC_LAYOUT_OOB_HAMMING_SZ,
1280 &hamming);
1281 doc_delay(docg3, 2);
1282
1283 doc_get_bch_hw_ecc(docg3, hwecc);
1284 doc_write_page_putbytes(docg3, DOC_LAYOUT_OOB_BCH_SZ, hwecc);
1285 doc_delay(docg3, 2);
1286
1287 doc_write_page_putbytes(docg3, DOC_LAYOUT_OOB_UNUSED_SZ, oob);
1288 }
1289 if (oob && !autoecc)
1290 doc_write_page_putbytes(docg3, DOC_LAYOUT_OOB_SIZE, oob);
1291
1292 doc_delay(docg3, 2);
1293 doc_page_finish(docg3);
1294 doc_delay(docg3, 2);
1295 doc_flash_command(docg3, DOC_CMD_PROG_CYCLE2);
1296 doc_delay(docg3, 2);
1297
1298
1299
1300
1301
1302 ret = doc_write_erase_wait_status(docg3);
1303 return ret;
1304err:
1305 doc_read_page_finish(docg3);
1306 return ret;
1307}
1308
1309
1310
1311
1312
1313
1314
1315static int doc_guess_autoecc(struct mtd_oob_ops *ops)
1316{
1317 int autoecc;
1318
1319 switch (ops->mode) {
1320 case MTD_OPS_PLACE_OOB:
1321 case MTD_OPS_AUTO_OOB:
1322 autoecc = 1;
1323 break;
1324 case MTD_OPS_RAW:
1325 autoecc = 0;
1326 break;
1327 default:
1328 autoecc = -EINVAL;
1329 }
1330 return autoecc;
1331}
1332
1333
1334
1335
1336
1337
1338
1339static void doc_fill_autooob(u8 *dst, u8 *oobsrc)
1340{
1341 memcpy(dst, oobsrc, DOC_LAYOUT_OOB_PAGEINFO_SZ);
1342 dst[DOC_LAYOUT_OOB_UNUSED_OFS] = oobsrc[DOC_LAYOUT_OOB_PAGEINFO_SZ];
1343}
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362static int doc_backup_oob(struct docg3 *docg3, loff_t to,
1363 struct mtd_oob_ops *ops)
1364{
1365 int ooblen = ops->ooblen, autoecc;
1366
1367 if (ooblen != DOC_LAYOUT_OOB_SIZE)
1368 return -EINVAL;
1369 autoecc = doc_guess_autoecc(ops);
1370 if (autoecc < 0)
1371 return autoecc;
1372
1373 docg3->oob_write_ofs = to;
1374 docg3->oob_autoecc = autoecc;
1375 if (ops->mode == MTD_OPS_AUTO_OOB) {
1376 doc_fill_autooob(docg3->oob_write_buf, ops->oobbuf);
1377 ops->oobretlen = 8;
1378 } else {
1379 memcpy(docg3->oob_write_buf, ops->oobbuf, DOC_LAYOUT_OOB_SIZE);
1380 ops->oobretlen = DOC_LAYOUT_OOB_SIZE;
1381 }
1382 return 0;
1383}
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400static int doc_write_oob(struct mtd_info *mtd, loff_t ofs,
1401 struct mtd_oob_ops *ops)
1402{
1403 struct docg3 *docg3 = mtd->priv;
1404 int ret, autoecc, oobdelta;
1405 u8 *oobbuf = ops->oobbuf;
1406 u8 *buf = ops->datbuf;
1407 size_t len, ooblen;
1408 u8 oob[DOC_LAYOUT_OOB_SIZE];
1409
1410 if (buf)
1411 len = ops->len;
1412 else
1413 len = 0;
1414 if (oobbuf)
1415 ooblen = ops->ooblen;
1416 else
1417 ooblen = 0;
1418
1419 if (oobbuf && ops->mode == MTD_OPS_PLACE_OOB)
1420 oobbuf += ops->ooboffs;
1421
1422 doc_dbg("doc_write_oob(from=%lld, mode=%d, data=(%p:%zu), oob=(%p:%zu))\n",
1423 ofs, ops->mode, buf, len, oobbuf, ooblen);
1424 switch (ops->mode) {
1425 case MTD_OPS_PLACE_OOB:
1426 case MTD_OPS_RAW:
1427 oobdelta = mtd->oobsize;
1428 break;
1429 case MTD_OPS_AUTO_OOB:
1430 oobdelta = mtd->oobavail;
1431 break;
1432 default:
1433 return -EINVAL;
1434 }
1435 if ((len % DOC_LAYOUT_PAGE_SIZE) || (ooblen % oobdelta) ||
1436 (ofs % DOC_LAYOUT_PAGE_SIZE))
1437 return -EINVAL;
1438 if (len && ooblen &&
1439 (len / DOC_LAYOUT_PAGE_SIZE) != (ooblen / oobdelta))
1440 return -EINVAL;
1441
1442 ops->oobretlen = 0;
1443 ops->retlen = 0;
1444 ret = 0;
1445 if (len == 0 && ooblen == 0)
1446 return -EINVAL;
1447 if (len == 0 && ooblen > 0)
1448 return doc_backup_oob(docg3, ofs, ops);
1449
1450 autoecc = doc_guess_autoecc(ops);
1451 if (autoecc < 0)
1452 return autoecc;
1453
1454 mutex_lock(&docg3->cascade->lock);
1455 while (!ret && len > 0) {
1456 memset(oob, 0, sizeof(oob));
1457 if (ofs == docg3->oob_write_ofs)
1458 memcpy(oob, docg3->oob_write_buf, DOC_LAYOUT_OOB_SIZE);
1459 else if (ooblen > 0 && ops->mode == MTD_OPS_AUTO_OOB)
1460 doc_fill_autooob(oob, oobbuf);
1461 else if (ooblen > 0)
1462 memcpy(oob, oobbuf, DOC_LAYOUT_OOB_SIZE);
1463 ret = doc_write_page(docg3, ofs, buf, oob, autoecc);
1464
1465 ofs += DOC_LAYOUT_PAGE_SIZE;
1466 len -= DOC_LAYOUT_PAGE_SIZE;
1467 buf += DOC_LAYOUT_PAGE_SIZE;
1468 if (ooblen) {
1469 oobbuf += oobdelta;
1470 ooblen -= oobdelta;
1471 ops->oobretlen += oobdelta;
1472 }
1473 ops->retlen += DOC_LAYOUT_PAGE_SIZE;
1474 }
1475
1476 doc_set_device_id(docg3, 0);
1477 mutex_unlock(&docg3->cascade->lock);
1478 return ret;
1479}
1480
1481static struct docg3 *sysfs_dev2docg3(struct device *dev,
1482 struct device_attribute *attr)
1483{
1484 int floor;
1485 struct platform_device *pdev = to_platform_device(dev);
1486 struct mtd_info **docg3_floors = platform_get_drvdata(pdev);
1487
1488 floor = attr->attr.name[1] - '0';
1489 if (floor < 0 || floor >= DOC_MAX_NBFLOORS)
1490 return NULL;
1491 else
1492 return docg3_floors[floor]->priv;
1493}
1494
1495static ssize_t dps0_is_key_locked(struct device *dev,
1496 struct device_attribute *attr, char *buf)
1497{
1498 struct docg3 *docg3 = sysfs_dev2docg3(dev, attr);
1499 int dps0;
1500
1501 mutex_lock(&docg3->cascade->lock);
1502 doc_set_device_id(docg3, docg3->device_id);
1503 dps0 = doc_register_readb(docg3, DOC_DPS0_STATUS);
1504 doc_set_device_id(docg3, 0);
1505 mutex_unlock(&docg3->cascade->lock);
1506
1507 return sprintf(buf, "%d\n", !(dps0 & DOC_DPS_KEY_OK));
1508}
1509
1510static ssize_t dps1_is_key_locked(struct device *dev,
1511 struct device_attribute *attr, char *buf)
1512{
1513 struct docg3 *docg3 = sysfs_dev2docg3(dev, attr);
1514 int dps1;
1515
1516 mutex_lock(&docg3->cascade->lock);
1517 doc_set_device_id(docg3, docg3->device_id);
1518 dps1 = doc_register_readb(docg3, DOC_DPS1_STATUS);
1519 doc_set_device_id(docg3, 0);
1520 mutex_unlock(&docg3->cascade->lock);
1521
1522 return sprintf(buf, "%d\n", !(dps1 & DOC_DPS_KEY_OK));
1523}
1524
1525static ssize_t dps0_insert_key(struct device *dev,
1526 struct device_attribute *attr,
1527 const char *buf, size_t count)
1528{
1529 struct docg3 *docg3 = sysfs_dev2docg3(dev, attr);
1530 int i;
1531
1532 if (count != DOC_LAYOUT_DPS_KEY_LENGTH)
1533 return -EINVAL;
1534
1535 mutex_lock(&docg3->cascade->lock);
1536 doc_set_device_id(docg3, docg3->device_id);
1537 for (i = 0; i < DOC_LAYOUT_DPS_KEY_LENGTH; i++)
1538 doc_writeb(docg3, buf[i], DOC_DPS0_KEY);
1539 doc_set_device_id(docg3, 0);
1540 mutex_unlock(&docg3->cascade->lock);
1541 return count;
1542}
1543
1544static ssize_t dps1_insert_key(struct device *dev,
1545 struct device_attribute *attr,
1546 const char *buf, size_t count)
1547{
1548 struct docg3 *docg3 = sysfs_dev2docg3(dev, attr);
1549 int i;
1550
1551 if (count != DOC_LAYOUT_DPS_KEY_LENGTH)
1552 return -EINVAL;
1553
1554 mutex_lock(&docg3->cascade->lock);
1555 doc_set_device_id(docg3, docg3->device_id);
1556 for (i = 0; i < DOC_LAYOUT_DPS_KEY_LENGTH; i++)
1557 doc_writeb(docg3, buf[i], DOC_DPS1_KEY);
1558 doc_set_device_id(docg3, 0);
1559 mutex_unlock(&docg3->cascade->lock);
1560 return count;
1561}
1562
1563#define FLOOR_SYSFS(id) { \
1564 __ATTR(f##id##_dps0_is_keylocked, S_IRUGO, dps0_is_key_locked, NULL), \
1565 __ATTR(f##id##_dps1_is_keylocked, S_IRUGO, dps1_is_key_locked, NULL), \
1566 __ATTR(f##id##_dps0_protection_key, S_IWUSR|S_IWGRP, NULL, dps0_insert_key), \
1567 __ATTR(f##id##_dps1_protection_key, S_IWUSR|S_IWGRP, NULL, dps1_insert_key), \
1568}
1569
1570static struct device_attribute doc_sys_attrs[DOC_MAX_NBFLOORS][4] = {
1571 FLOOR_SYSFS(0), FLOOR_SYSFS(1), FLOOR_SYSFS(2), FLOOR_SYSFS(3)
1572};
1573
1574static int doc_register_sysfs(struct platform_device *pdev,
1575 struct docg3_cascade *cascade)
1576{
1577 struct device *dev = &pdev->dev;
1578 int floor;
1579 int ret;
1580 int i;
1581
1582 for (floor = 0;
1583 floor < DOC_MAX_NBFLOORS && cascade->floors[floor];
1584 floor++) {
1585 for (i = 0; i < 4; i++) {
1586 ret = device_create_file(dev, &doc_sys_attrs[floor][i]);
1587 if (ret)
1588 goto remove_files;
1589 }
1590 }
1591
1592 return 0;
1593
1594remove_files:
1595 do {
1596 while (--i >= 0)
1597 device_remove_file(dev, &doc_sys_attrs[floor][i]);
1598 i = 4;
1599 } while (--floor >= 0);
1600
1601 return ret;
1602}
1603
1604static void doc_unregister_sysfs(struct platform_device *pdev,
1605 struct docg3_cascade *cascade)
1606{
1607 struct device *dev = &pdev->dev;
1608 int floor, i;
1609
1610 for (floor = 0; floor < DOC_MAX_NBFLOORS && cascade->floors[floor];
1611 floor++)
1612 for (i = 0; i < 4; i++)
1613 device_remove_file(dev, &doc_sys_attrs[floor][i]);
1614}
1615
1616
1617
1618
1619static int dbg_flashctrl_show(struct seq_file *s, void *p)
1620{
1621 struct docg3 *docg3 = (struct docg3 *)s->private;
1622
1623 u8 fctrl;
1624
1625 mutex_lock(&docg3->cascade->lock);
1626 fctrl = doc_register_readb(docg3, DOC_FLASHCONTROL);
1627 mutex_unlock(&docg3->cascade->lock);
1628
1629 seq_printf(s, "FlashControl : 0x%02x (%s,CE# %s,%s,%s,flash %s)\n",
1630 fctrl,
1631 fctrl & DOC_CTRL_VIOLATION ? "protocol violation" : "-",
1632 fctrl & DOC_CTRL_CE ? "active" : "inactive",
1633 fctrl & DOC_CTRL_PROTECTION_ERROR ? "protection error" : "-",
1634 fctrl & DOC_CTRL_SEQUENCE_ERROR ? "sequence error" : "-",
1635 fctrl & DOC_CTRL_FLASHREADY ? "ready" : "not ready");
1636
1637 return 0;
1638}
1639DEBUGFS_RO_ATTR(flashcontrol, dbg_flashctrl_show);
1640
1641static int dbg_asicmode_show(struct seq_file *s, void *p)
1642{
1643 struct docg3 *docg3 = (struct docg3 *)s->private;
1644
1645 int pctrl, mode;
1646
1647 mutex_lock(&docg3->cascade->lock);
1648 pctrl = doc_register_readb(docg3, DOC_ASICMODE);
1649 mode = pctrl & 0x03;
1650 mutex_unlock(&docg3->cascade->lock);
1651
1652 seq_printf(s,
1653 "%04x : RAM_WE=%d,RSTIN_RESET=%d,BDETCT_RESET=%d,WRITE_ENABLE=%d,POWERDOWN=%d,MODE=%d%d (",
1654 pctrl,
1655 pctrl & DOC_ASICMODE_RAM_WE ? 1 : 0,
1656 pctrl & DOC_ASICMODE_RSTIN_RESET ? 1 : 0,
1657 pctrl & DOC_ASICMODE_BDETCT_RESET ? 1 : 0,
1658 pctrl & DOC_ASICMODE_MDWREN ? 1 : 0,
1659 pctrl & DOC_ASICMODE_POWERDOWN ? 1 : 0,
1660 mode >> 1, mode & 0x1);
1661
1662 switch (mode) {
1663 case DOC_ASICMODE_RESET:
1664 seq_puts(s, "reset");
1665 break;
1666 case DOC_ASICMODE_NORMAL:
1667 seq_puts(s, "normal");
1668 break;
1669 case DOC_ASICMODE_POWERDOWN:
1670 seq_puts(s, "powerdown");
1671 break;
1672 }
1673 seq_puts(s, ")\n");
1674 return 0;
1675}
1676DEBUGFS_RO_ATTR(asic_mode, dbg_asicmode_show);
1677
1678static int dbg_device_id_show(struct seq_file *s, void *p)
1679{
1680 struct docg3 *docg3 = (struct docg3 *)s->private;
1681 int id;
1682
1683 mutex_lock(&docg3->cascade->lock);
1684 id = doc_register_readb(docg3, DOC_DEVICESELECT);
1685 mutex_unlock(&docg3->cascade->lock);
1686
1687 seq_printf(s, "DeviceId = %d\n", id);
1688 return 0;
1689}
1690DEBUGFS_RO_ATTR(device_id, dbg_device_id_show);
1691
1692static int dbg_protection_show(struct seq_file *s, void *p)
1693{
1694 struct docg3 *docg3 = (struct docg3 *)s->private;
1695 int protect, dps0, dps0_low, dps0_high, dps1, dps1_low, dps1_high;
1696
1697 mutex_lock(&docg3->cascade->lock);
1698 protect = doc_register_readb(docg3, DOC_PROTECTION);
1699 dps0 = doc_register_readb(docg3, DOC_DPS0_STATUS);
1700 dps0_low = doc_register_readw(docg3, DOC_DPS0_ADDRLOW);
1701 dps0_high = doc_register_readw(docg3, DOC_DPS0_ADDRHIGH);
1702 dps1 = doc_register_readb(docg3, DOC_DPS1_STATUS);
1703 dps1_low = doc_register_readw(docg3, DOC_DPS1_ADDRLOW);
1704 dps1_high = doc_register_readw(docg3, DOC_DPS1_ADDRHIGH);
1705 mutex_unlock(&docg3->cascade->lock);
1706
1707 seq_printf(s, "Protection = 0x%02x (", protect);
1708 if (protect & DOC_PROTECT_FOUNDRY_OTP_LOCK)
1709 seq_puts(s, "FOUNDRY_OTP_LOCK,");
1710 if (protect & DOC_PROTECT_CUSTOMER_OTP_LOCK)
1711 seq_puts(s, "CUSTOMER_OTP_LOCK,");
1712 if (protect & DOC_PROTECT_LOCK_INPUT)
1713 seq_puts(s, "LOCK_INPUT,");
1714 if (protect & DOC_PROTECT_STICKY_LOCK)
1715 seq_puts(s, "STICKY_LOCK,");
1716 if (protect & DOC_PROTECT_PROTECTION_ENABLED)
1717 seq_puts(s, "PROTECTION ON,");
1718 if (protect & DOC_PROTECT_IPL_DOWNLOAD_LOCK)
1719 seq_puts(s, "IPL_DOWNLOAD_LOCK,");
1720 if (protect & DOC_PROTECT_PROTECTION_ERROR)
1721 seq_puts(s, "PROTECT_ERR,");
1722 else
1723 seq_puts(s, "NO_PROTECT_ERR");
1724 seq_puts(s, ")\n");
1725
1726 seq_printf(s, "DPS0 = 0x%02x : Protected area [0x%x - 0x%x] : OTP=%d, READ=%d, WRITE=%d, HW_LOCK=%d, KEY_OK=%d\n",
1727 dps0, dps0_low, dps0_high,
1728 !!(dps0 & DOC_DPS_OTP_PROTECTED),
1729 !!(dps0 & DOC_DPS_READ_PROTECTED),
1730 !!(dps0 & DOC_DPS_WRITE_PROTECTED),
1731 !!(dps0 & DOC_DPS_HW_LOCK_ENABLED),
1732 !!(dps0 & DOC_DPS_KEY_OK));
1733 seq_printf(s, "DPS1 = 0x%02x : Protected area [0x%x - 0x%x] : OTP=%d, READ=%d, WRITE=%d, HW_LOCK=%d, KEY_OK=%d\n",
1734 dps1, dps1_low, dps1_high,
1735 !!(dps1 & DOC_DPS_OTP_PROTECTED),
1736 !!(dps1 & DOC_DPS_READ_PROTECTED),
1737 !!(dps1 & DOC_DPS_WRITE_PROTECTED),
1738 !!(dps1 & DOC_DPS_HW_LOCK_ENABLED),
1739 !!(dps1 & DOC_DPS_KEY_OK));
1740 return 0;
1741}
1742DEBUGFS_RO_ATTR(protection, dbg_protection_show);
1743
1744static void __init doc_dbg_register(struct mtd_info *floor)
1745{
1746 struct dentry *root = floor->dbg.dfs_dir;
1747 struct docg3 *docg3 = floor->priv;
1748
1749 if (IS_ERR_OR_NULL(root)) {
1750 if (IS_ENABLED(CONFIG_DEBUG_FS) &&
1751 !IS_ENABLED(CONFIG_MTD_PARTITIONED_MASTER))
1752 dev_warn(floor->dev.parent,
1753 "CONFIG_MTD_PARTITIONED_MASTER must be enabled to expose debugfs stuff\n");
1754 return;
1755 }
1756
1757 debugfs_create_file("docg3_flashcontrol", S_IRUSR, root, docg3,
1758 &flashcontrol_fops);
1759 debugfs_create_file("docg3_asic_mode", S_IRUSR, root, docg3,
1760 &asic_mode_fops);
1761 debugfs_create_file("docg3_device_id", S_IRUSR, root, docg3,
1762 &device_id_fops);
1763 debugfs_create_file("docg3_protection", S_IRUSR, root, docg3,
1764 &protection_fops);
1765}
1766
1767
1768
1769
1770
1771
1772static int __init doc_set_driver_info(int chip_id, struct mtd_info *mtd)
1773{
1774 struct docg3 *docg3 = mtd->priv;
1775 int cfg;
1776
1777 cfg = doc_register_readb(docg3, DOC_CONFIGURATION);
1778 docg3->if_cfg = (cfg & DOC_CONF_IF_CFG ? 1 : 0);
1779 docg3->reliable = reliable_mode;
1780
1781 switch (chip_id) {
1782 case DOC_CHIPID_G3:
1783 mtd->name = kasprintf(GFP_KERNEL, "docg3.%d",
1784 docg3->device_id);
1785 if (!mtd->name)
1786 return -ENOMEM;
1787 docg3->max_block = 2047;
1788 break;
1789 }
1790 mtd->type = MTD_NANDFLASH;
1791 mtd->flags = MTD_CAP_NANDFLASH;
1792 mtd->size = (docg3->max_block + 1) * DOC_LAYOUT_BLOCK_SIZE;
1793 if (docg3->reliable == 2)
1794 mtd->size /= 2;
1795 mtd->erasesize = DOC_LAYOUT_BLOCK_SIZE * DOC_LAYOUT_NBPLANES;
1796 if (docg3->reliable == 2)
1797 mtd->erasesize /= 2;
1798 mtd->writebufsize = mtd->writesize = DOC_LAYOUT_PAGE_SIZE;
1799 mtd->oobsize = DOC_LAYOUT_OOB_SIZE;
1800 mtd->_erase = doc_erase;
1801 mtd->_read_oob = doc_read_oob;
1802 mtd->_write_oob = doc_write_oob;
1803 mtd->_block_isbad = doc_block_isbad;
1804 mtd_set_ooblayout(mtd, &nand_ooblayout_docg3_ops);
1805 mtd->oobavail = 8;
1806 mtd->ecc_strength = DOC_ECC_BCH_T;
1807
1808 return 0;
1809}
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824static struct mtd_info * __init
1825doc_probe_device(struct docg3_cascade *cascade, int floor, struct device *dev)
1826{
1827 int ret, bbt_nbpages;
1828 u16 chip_id, chip_id_inv;
1829 struct docg3 *docg3;
1830 struct mtd_info *mtd;
1831
1832 ret = -ENOMEM;
1833 docg3 = kzalloc(sizeof(struct docg3), GFP_KERNEL);
1834 if (!docg3)
1835 goto nomem1;
1836 mtd = kzalloc(sizeof(struct mtd_info), GFP_KERNEL);
1837 if (!mtd)
1838 goto nomem2;
1839 mtd->priv = docg3;
1840 mtd->dev.parent = dev;
1841 bbt_nbpages = DIV_ROUND_UP(docg3->max_block + 1,
1842 8 * DOC_LAYOUT_PAGE_SIZE);
1843 docg3->bbt = kzalloc(bbt_nbpages * DOC_LAYOUT_PAGE_SIZE, GFP_KERNEL);
1844 if (!docg3->bbt)
1845 goto nomem3;
1846
1847 docg3->dev = dev;
1848 docg3->device_id = floor;
1849 docg3->cascade = cascade;
1850 doc_set_device_id(docg3, docg3->device_id);
1851 if (!floor)
1852 doc_set_asic_mode(docg3, DOC_ASICMODE_RESET);
1853 doc_set_asic_mode(docg3, DOC_ASICMODE_NORMAL);
1854
1855 chip_id = doc_register_readw(docg3, DOC_CHIPID);
1856 chip_id_inv = doc_register_readw(docg3, DOC_CHIPID_INV);
1857
1858 ret = 0;
1859 if (chip_id != (u16)(~chip_id_inv)) {
1860 goto nomem4;
1861 }
1862
1863 switch (chip_id) {
1864 case DOC_CHIPID_G3:
1865 doc_info("Found a G3 DiskOnChip at addr %p, floor %d\n",
1866 docg3->cascade->base, floor);
1867 break;
1868 default:
1869 doc_err("Chip id %04x is not a DiskOnChip G3 chip\n", chip_id);
1870 goto nomem4;
1871 }
1872
1873 ret = doc_set_driver_info(chip_id, mtd);
1874 if (ret)
1875 goto nomem4;
1876
1877 doc_hamming_ecc_init(docg3, DOC_LAYOUT_OOB_PAGEINFO_SZ);
1878 doc_reload_bbt(docg3);
1879 return mtd;
1880
1881nomem4:
1882 kfree(docg3->bbt);
1883nomem3:
1884 kfree(mtd);
1885nomem2:
1886 kfree(docg3);
1887nomem1:
1888 return ERR_PTR(ret);
1889}
1890
1891
1892
1893
1894
1895static void doc_release_device(struct mtd_info *mtd)
1896{
1897 struct docg3 *docg3 = mtd->priv;
1898
1899 mtd_device_unregister(mtd);
1900 kfree(docg3->bbt);
1901 kfree(docg3);
1902 kfree(mtd->name);
1903 kfree(mtd);
1904}
1905
1906
1907
1908
1909
1910
1911
1912static int docg3_resume(struct platform_device *pdev)
1913{
1914 int i;
1915 struct docg3_cascade *cascade;
1916 struct mtd_info **docg3_floors, *mtd;
1917 struct docg3 *docg3;
1918
1919 cascade = platform_get_drvdata(pdev);
1920 docg3_floors = cascade->floors;
1921 mtd = docg3_floors[0];
1922 docg3 = mtd->priv;
1923
1924 doc_dbg("docg3_resume()\n");
1925 for (i = 0; i < 12; i++)
1926 doc_readb(docg3, DOC_IOSPACE_IPL);
1927 return 0;
1928}
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939static int docg3_suspend(struct platform_device *pdev, pm_message_t state)
1940{
1941 int floor, i;
1942 struct docg3_cascade *cascade;
1943 struct mtd_info **docg3_floors, *mtd;
1944 struct docg3 *docg3;
1945 u8 ctrl, pwr_down;
1946
1947 cascade = platform_get_drvdata(pdev);
1948 docg3_floors = cascade->floors;
1949 for (floor = 0; floor < DOC_MAX_NBFLOORS; floor++) {
1950 mtd = docg3_floors[floor];
1951 if (!mtd)
1952 continue;
1953 docg3 = mtd->priv;
1954
1955 doc_writeb(docg3, floor, DOC_DEVICESELECT);
1956 ctrl = doc_register_readb(docg3, DOC_FLASHCONTROL);
1957 ctrl &= ~DOC_CTRL_VIOLATION & ~DOC_CTRL_CE;
1958 doc_writeb(docg3, ctrl, DOC_FLASHCONTROL);
1959
1960 for (i = 0; i < 10; i++) {
1961 usleep_range(3000, 4000);
1962 pwr_down = doc_register_readb(docg3, DOC_POWERMODE);
1963 if (pwr_down & DOC_POWERDOWN_READY)
1964 break;
1965 }
1966 if (pwr_down & DOC_POWERDOWN_READY) {
1967 doc_dbg("docg3_suspend(): floor %d powerdown ok\n",
1968 floor);
1969 } else {
1970 doc_err("docg3_suspend(): floor %d powerdown failed\n",
1971 floor);
1972 return -EIO;
1973 }
1974 }
1975
1976 mtd = docg3_floors[0];
1977 docg3 = mtd->priv;
1978 doc_set_asic_mode(docg3, DOC_ASICMODE_POWERDOWN);
1979 return 0;
1980}
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991static int __init docg3_probe(struct platform_device *pdev)
1992{
1993 struct device *dev = &pdev->dev;
1994 struct mtd_info *mtd;
1995 struct resource *ress;
1996 void __iomem *base;
1997 int ret, floor;
1998 struct docg3_cascade *cascade;
1999
2000 ret = -ENXIO;
2001 ress = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2002 if (!ress) {
2003 dev_err(dev, "No I/O memory resource defined\n");
2004 return ret;
2005 }
2006 base = devm_ioremap(dev, ress->start, DOC_IOSPACE_SIZE);
2007
2008 ret = -ENOMEM;
2009 cascade = devm_kzalloc(dev, sizeof(*cascade) * DOC_MAX_NBFLOORS,
2010 GFP_KERNEL);
2011 if (!cascade)
2012 return ret;
2013 cascade->base = base;
2014 mutex_init(&cascade->lock);
2015 cascade->bch = init_bch(DOC_ECC_BCH_M, DOC_ECC_BCH_T,
2016 DOC_ECC_BCH_PRIMPOLY);
2017 if (!cascade->bch)
2018 return ret;
2019
2020 for (floor = 0; floor < DOC_MAX_NBFLOORS; floor++) {
2021 mtd = doc_probe_device(cascade, floor, dev);
2022 if (IS_ERR(mtd)) {
2023 ret = PTR_ERR(mtd);
2024 goto err_probe;
2025 }
2026 if (!mtd) {
2027 if (floor == 0)
2028 goto notfound;
2029 else
2030 continue;
2031 }
2032 cascade->floors[floor] = mtd;
2033 ret = mtd_device_parse_register(mtd, part_probes, NULL, NULL,
2034 0);
2035 if (ret)
2036 goto err_probe;
2037
2038 doc_dbg_register(cascade->floors[floor]);
2039 }
2040
2041 ret = doc_register_sysfs(pdev, cascade);
2042 if (ret)
2043 goto err_probe;
2044
2045 platform_set_drvdata(pdev, cascade);
2046 return 0;
2047
2048notfound:
2049 ret = -ENODEV;
2050 dev_info(dev, "No supported DiskOnChip found\n");
2051err_probe:
2052 free_bch(cascade->bch);
2053 for (floor = 0; floor < DOC_MAX_NBFLOORS; floor++)
2054 if (cascade->floors[floor])
2055 doc_release_device(cascade->floors[floor]);
2056 return ret;
2057}
2058
2059
2060
2061
2062
2063
2064
2065static int docg3_release(struct platform_device *pdev)
2066{
2067 struct docg3_cascade *cascade = platform_get_drvdata(pdev);
2068 struct docg3 *docg3 = cascade->floors[0]->priv;
2069 int floor;
2070
2071 doc_unregister_sysfs(pdev, cascade);
2072 for (floor = 0; floor < DOC_MAX_NBFLOORS; floor++)
2073 if (cascade->floors[floor])
2074 doc_release_device(cascade->floors[floor]);
2075
2076 free_bch(docg3->cascade->bch);
2077 return 0;
2078}
2079
2080#ifdef CONFIG_OF
2081static const struct of_device_id docg3_dt_ids[] = {
2082 { .compatible = "m-systems,diskonchip-g3" },
2083 {}
2084};
2085MODULE_DEVICE_TABLE(of, docg3_dt_ids);
2086#endif
2087
2088static struct platform_driver g3_driver = {
2089 .driver = {
2090 .name = "docg3",
2091 .of_match_table = of_match_ptr(docg3_dt_ids),
2092 },
2093 .suspend = docg3_suspend,
2094 .resume = docg3_resume,
2095 .remove = docg3_release,
2096};
2097
2098module_platform_driver_probe(g3_driver, docg3_probe);
2099
2100MODULE_LICENSE("GPL");
2101MODULE_AUTHOR("Robert Jarzmik <robert.jarzmik@free.fr>");
2102MODULE_DESCRIPTION("MTD driver for DiskOnChip G3");
2103