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