2 * Handles the M-Systems DiskOnChip G3 chip
4 * Copyright (C) 2011 Robert Jarzmik
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
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>
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>
36 #include <linux/debugfs.h>
37 #include <linux/seq_file.h>
39 #define CREATE_TRACE_POINTS
43 * This driver handles the DiskOnChip G3 flash memory.
45 * As no specification is available from M-Systems/Sandisk, this drivers lacks
46 * several functions available on the chip, as :
49 * The bus data width (8bits versus 16bits) is not handled (if_cfg flag), and
50 * the driver assumes a 16bits data bus.
52 * DocG3 relies on 2 ECC algorithms, which are handled in hardware :
53 * - a 1 byte Hamming code stored in the OOB for each page
54 * - a 7 bytes BCH code stored in the OOB for each page
56 * - BCH is in GF(2^14)
57 * - BCH is over data of 520 bytes (512 page + 7 page_info bytes
59 * - BCH can correct up to 4 bits (t = 4)
60 * - BCH syndroms are calculated in hardware, and checked in hardware as well
64 static unsigned int reliable_mode
;
65 module_param(reliable_mode
, uint
, 0);
66 MODULE_PARM_DESC(reliable_mode
, "Set the docg3 mode (0=normal MLC, 1=fast, "
67 "2=reliable) : MLC normal operations are in normal mode");
70 * struct docg3_oobinfo - DiskOnChip G3 OOB layout
71 * @eccbytes: 8 bytes are used (1 for Hamming ECC, 7 for BCH ECC)
72 * @eccpos: ecc positions (byte 7 is Hamming ECC, byte 8-14 are BCH ECC)
73 * @oobfree: free pageinfo bytes (byte 0 until byte 6, byte 15
74 * @oobavail: 8 available bytes remaining after ECC toll
76 static struct nand_ecclayout docg3_oobinfo
= {
78 .eccpos
= {7, 8, 9, 10, 11, 12, 13, 14},
79 .oobfree
= {{0, 7}, {15, 1} },
84 * struct docg3_bch - BCH engine
86 static struct bch_control
*docg3_bch
;
88 static inline u8
doc_readb(struct docg3
*docg3
, u16 reg
)
90 u8 val
= readb(docg3
->base
+ reg
);
92 trace_docg3_io(0, 8, reg
, (int)val
);
96 static inline u16
doc_readw(struct docg3
*docg3
, u16 reg
)
98 u16 val
= readw(docg3
->base
+ reg
);
100 trace_docg3_io(0, 16, reg
, (int)val
);
104 static inline void doc_writeb(struct docg3
*docg3
, u8 val
, u16 reg
)
106 writeb(val
, docg3
->base
+ reg
);
107 trace_docg3_io(1, 8, reg
, val
);
110 static inline void doc_writew(struct docg3
*docg3
, u16 val
, u16 reg
)
112 writew(val
, docg3
->base
+ reg
);
113 trace_docg3_io(1, 16, reg
, val
);
116 static inline void doc_flash_command(struct docg3
*docg3
, u8 cmd
)
118 doc_writeb(docg3
, cmd
, DOC_FLASHCOMMAND
);
121 static inline void doc_flash_sequence(struct docg3
*docg3
, u8 seq
)
123 doc_writeb(docg3
, seq
, DOC_FLASHSEQUENCE
);
126 static inline void doc_flash_address(struct docg3
*docg3
, u8 addr
)
128 doc_writeb(docg3
, addr
, DOC_FLASHADDRESS
);
131 static char const *part_probes
[] = { "cmdlinepart", "saftlpart", NULL
};
133 static int doc_register_readb(struct docg3
*docg3
, int reg
)
137 doc_writew(docg3
, reg
, DOC_READADDRESS
);
138 val
= doc_readb(docg3
, reg
);
139 doc_vdbg("Read register %04x : %02x\n", reg
, val
);
143 static int doc_register_readw(struct docg3
*docg3
, int reg
)
147 doc_writew(docg3
, reg
, DOC_READADDRESS
);
148 val
= doc_readw(docg3
, reg
);
149 doc_vdbg("Read register %04x : %04x\n", reg
, val
);
154 * doc_delay - delay docg3 operations
156 * @nbNOPs: the number of NOPs to issue
158 * As no specification is available, the right timings between chip commands are
159 * unknown. The only available piece of information are the observed nops on a
160 * working docg3 chip.
161 * Therefore, doc_delay relies on a busy loop of NOPs, instead of scheduler
162 * friendlier msleep() functions or blocking mdelay().
164 static void doc_delay(struct docg3
*docg3
, int nbNOPs
)
168 doc_vdbg("NOP x %d\n", nbNOPs
);
169 for (i
= 0; i
< nbNOPs
; i
++)
170 doc_writeb(docg3
, 0, DOC_NOP
);
173 static int is_prot_seq_error(struct docg3
*docg3
)
177 ctrl
= doc_register_readb(docg3
, DOC_FLASHCONTROL
);
178 return ctrl
& (DOC_CTRL_PROTECTION_ERROR
| DOC_CTRL_SEQUENCE_ERROR
);
181 static int doc_is_ready(struct docg3
*docg3
)
185 ctrl
= doc_register_readb(docg3
, DOC_FLASHCONTROL
);
186 return ctrl
& DOC_CTRL_FLASHREADY
;
189 static int doc_wait_ready(struct docg3
*docg3
)
191 int maxWaitCycles
= 100;
196 } while (!doc_is_ready(docg3
) && maxWaitCycles
--);
198 if (maxWaitCycles
> 0)
204 static int doc_reset_seq(struct docg3
*docg3
)
208 doc_writeb(docg3
, 0x10, DOC_FLASHCONTROL
);
209 doc_flash_sequence(docg3
, DOC_SEQ_RESET
);
210 doc_flash_command(docg3
, DOC_CMD_RESET
);
212 ret
= doc_wait_ready(docg3
);
214 doc_dbg("doc_reset_seq() -> isReady=%s\n", ret
? "false" : "true");
219 * doc_read_data_area - Read data from data area
221 * @buf: the buffer to fill in (might be NULL is dummy reads)
222 * @len: the length to read
223 * @first: first time read, DOC_READADDRESS should be set
225 * Reads bytes from flash data. Handles the single byte / even bytes reads.
227 static void doc_read_data_area(struct docg3
*docg3
, void *buf
, int len
,
234 doc_dbg("doc_read_data_area(buf=%p, len=%d)\n", buf
, len
);
239 doc_writew(docg3
, DOC_IOSPACE_DATA
, DOC_READADDRESS
);
241 for (i
= 0; i
< len4
; i
+= 2) {
242 data16
= doc_readw(docg3
, DOC_IOSPACE_DATA
);
250 doc_writew(docg3
, DOC_IOSPACE_DATA
| DOC_READADDR_ONE_BYTE
,
254 for (i
= 0; i
< cdr
; i
++) {
255 data8
= doc_readb(docg3
, DOC_IOSPACE_DATA
);
265 * doc_write_data_area - Write data into data area
267 * @buf: the buffer to get input bytes from
268 * @len: the length to write
270 * Writes bytes into flash data. Handles the single byte / even bytes writes.
272 static void doc_write_data_area(struct docg3
*docg3
, const void *buf
, int len
)
278 doc_dbg("doc_write_data_area(buf=%p, len=%d)\n", buf
, len
);
282 doc_writew(docg3
, DOC_IOSPACE_DATA
, DOC_READADDRESS
);
284 for (i
= 0; i
< len4
; i
+= 2) {
285 doc_writew(docg3
, *src16
, DOC_IOSPACE_DATA
);
290 for (i
= 0; i
< cdr
; i
++) {
291 doc_writew(docg3
, DOC_IOSPACE_DATA
| DOC_READADDR_ONE_BYTE
,
293 doc_writeb(docg3
, *src8
, DOC_IOSPACE_DATA
);
299 * doc_set_data_mode - Sets the flash to normal or reliable data mode
302 * The reliable data mode is a bit slower than the fast mode, but less errors
303 * occur. Entering the reliable mode cannot be done without entering the fast
306 * In reliable mode, pages 2*n and 2*n+1 are clones. Writing to page 0 of blocks
307 * (4,5) make the hardware write also to page 1 of blocks blocks(4,5). Reading
308 * from page 0 of blocks (4,5) or from page 1 of blocks (4,5) gives the same
309 * result, which is a logical and between bytes from page 0 and page 1 (which is
310 * consistent with the fact that writing to a page is _clearing_ bits of that
313 static void doc_set_reliable_mode(struct docg3
*docg3
)
315 static char *strmode
[] = { "normal", "fast", "reliable", "invalid" };
317 doc_dbg("doc_set_reliable_mode(%s)\n", strmode
[docg3
->reliable
]);
318 switch (docg3
->reliable
) {
322 doc_flash_sequence(docg3
, DOC_SEQ_SET_FASTMODE
);
323 doc_flash_command(docg3
, DOC_CMD_FAST_MODE
);
326 doc_flash_sequence(docg3
, DOC_SEQ_SET_RELIABLEMODE
);
327 doc_flash_command(docg3
, DOC_CMD_FAST_MODE
);
328 doc_flash_command(docg3
, DOC_CMD_RELIABLE_MODE
);
331 doc_err("doc_set_reliable_mode(): invalid mode\n");
338 * doc_set_asic_mode - Set the ASIC mode
342 * The ASIC can work in 3 modes :
343 * - RESET: all registers are zeroed
344 * - NORMAL: receives and handles commands
345 * - POWERDOWN: minimal poweruse, flash parts shut off
347 static void doc_set_asic_mode(struct docg3
*docg3
, u8 mode
)
351 for (i
= 0; i
< 12; i
++)
352 doc_readb(docg3
, DOC_IOSPACE_IPL
);
354 mode
|= DOC_ASICMODE_MDWREN
;
355 doc_dbg("doc_set_asic_mode(%02x)\n", mode
);
356 doc_writeb(docg3
, mode
, DOC_ASICMODE
);
357 doc_writeb(docg3
, ~mode
, DOC_ASICMODECONFIRM
);
362 * doc_set_device_id - Sets the devices id for cascaded G3 chips
364 * @id: the chip to select (amongst 0, 1, 2, 3)
366 * There can be 4 cascaded G3 chips. This function selects the one which will
367 * should be the active one.
369 static void doc_set_device_id(struct docg3
*docg3
, int id
)
373 doc_dbg("doc_set_device_id(%d)\n", id
);
374 doc_writeb(docg3
, id
, DOC_DEVICESELECT
);
375 ctrl
= doc_register_readb(docg3
, DOC_FLASHCONTROL
);
377 ctrl
&= ~DOC_CTRL_VIOLATION
;
379 doc_writeb(docg3
, ctrl
, DOC_FLASHCONTROL
);
383 * doc_set_extra_page_mode - Change flash page layout
386 * Normally, the flash page is split into the data (512 bytes) and the out of
387 * band data (16 bytes). For each, 4 more bytes can be accessed, where the wear
388 * leveling counters are stored. To access this last area of 4 bytes, a special
389 * mode must be input to the flash ASIC.
391 * Returns 0 if no error occured, -EIO else.
393 static int doc_set_extra_page_mode(struct docg3
*docg3
)
397 doc_dbg("doc_set_extra_page_mode()\n");
398 doc_flash_sequence(docg3
, DOC_SEQ_PAGE_SIZE_532
);
399 doc_flash_command(docg3
, DOC_CMD_PAGE_SIZE_532
);
402 fctrl
= doc_register_readb(docg3
, DOC_FLASHCONTROL
);
403 if (fctrl
& (DOC_CTRL_PROTECTION_ERROR
| DOC_CTRL_SEQUENCE_ERROR
))
410 * doc_setup_addr_sector - Setup blocks/page/ofs address for one plane
412 * @sector: the sector
414 static void doc_setup_addr_sector(struct docg3
*docg3
, int sector
)
417 doc_flash_address(docg3
, sector
& 0xff);
418 doc_flash_address(docg3
, (sector
>> 8) & 0xff);
419 doc_flash_address(docg3
, (sector
>> 16) & 0xff);
424 * doc_setup_writeaddr_sector - Setup blocks/page/ofs address for one plane
426 * @sector: the sector
427 * @ofs: the offset in the page, between 0 and (512 + 16 + 512)
429 static void doc_setup_writeaddr_sector(struct docg3
*docg3
, int sector
, int ofs
)
433 doc_flash_address(docg3
, ofs
& 0xff);
434 doc_flash_address(docg3
, sector
& 0xff);
435 doc_flash_address(docg3
, (sector
>> 8) & 0xff);
436 doc_flash_address(docg3
, (sector
>> 16) & 0xff);
441 * doc_seek - Set both flash planes to the specified block, page for reading
443 * @block0: the first plane block index
444 * @block1: the second plane block index
445 * @page: the page index within the block
446 * @wear: if true, read will occur on the 4 extra bytes of the wear area
447 * @ofs: offset in page to read
449 * Programs the flash even and odd planes to the specific block and page.
450 * Alternatively, programs the flash to the wear area of the specified page.
452 static int doc_read_seek(struct docg3
*docg3
, int block0
, int block1
, int page
,
457 doc_dbg("doc_seek(blocks=(%d,%d), page=%d, ofs=%d, wear=%d)\n",
458 block0
, block1
, page
, ofs
, wear
);
460 if (!wear
&& (ofs
< 2 * DOC_LAYOUT_PAGE_SIZE
)) {
461 doc_flash_sequence(docg3
, DOC_SEQ_SET_PLANE1
);
462 doc_flash_command(docg3
, DOC_CMD_READ_PLANE1
);
465 doc_flash_sequence(docg3
, DOC_SEQ_SET_PLANE2
);
466 doc_flash_command(docg3
, DOC_CMD_READ_PLANE2
);
470 doc_set_reliable_mode(docg3
);
472 ret
= doc_set_extra_page_mode(docg3
);
476 doc_flash_sequence(docg3
, DOC_SEQ_READ
);
477 sector
= (block0
<< DOC_ADDR_BLOCK_SHIFT
) + (page
& DOC_ADDR_PAGE_MASK
);
478 doc_flash_command(docg3
, DOC_CMD_PROG_BLOCK_ADDR
);
479 doc_setup_addr_sector(docg3
, sector
);
481 sector
= (block1
<< DOC_ADDR_BLOCK_SHIFT
) + (page
& DOC_ADDR_PAGE_MASK
);
482 doc_flash_command(docg3
, DOC_CMD_PROG_BLOCK_ADDR
);
483 doc_setup_addr_sector(docg3
, sector
);
491 * doc_write_seek - Set both flash planes to the specified block, page for writing
493 * @block0: the first plane block index
494 * @block1: the second plane block index
495 * @page: the page index within the block
496 * @ofs: offset in page to write
498 * Programs the flash even and odd planes to the specific block and page.
499 * Alternatively, programs the flash to the wear area of the specified page.
501 static int doc_write_seek(struct docg3
*docg3
, int block0
, int block1
, int page
,
506 doc_dbg("doc_write_seek(blocks=(%d,%d), page=%d, ofs=%d)\n",
507 block0
, block1
, page
, ofs
);
509 doc_set_reliable_mode(docg3
);
511 if (ofs
< 2 * DOC_LAYOUT_PAGE_SIZE
) {
512 doc_flash_sequence(docg3
, DOC_SEQ_SET_PLANE1
);
513 doc_flash_command(docg3
, DOC_CMD_READ_PLANE1
);
516 doc_flash_sequence(docg3
, DOC_SEQ_SET_PLANE2
);
517 doc_flash_command(docg3
, DOC_CMD_READ_PLANE2
);
521 doc_flash_sequence(docg3
, DOC_SEQ_PAGE_SETUP
);
522 doc_flash_command(docg3
, DOC_CMD_PROG_CYCLE1
);
524 sector
= (block0
<< DOC_ADDR_BLOCK_SHIFT
) + (page
& DOC_ADDR_PAGE_MASK
);
525 doc_setup_writeaddr_sector(docg3
, sector
, ofs
);
527 doc_flash_command(docg3
, DOC_CMD_PROG_CYCLE3
);
529 ret
= doc_wait_ready(docg3
);
533 doc_flash_command(docg3
, DOC_CMD_PROG_CYCLE1
);
534 sector
= (block1
<< DOC_ADDR_BLOCK_SHIFT
) + (page
& DOC_ADDR_PAGE_MASK
);
535 doc_setup_writeaddr_sector(docg3
, sector
, ofs
);
544 * doc_read_page_ecc_init - Initialize hardware ECC engine
546 * @len: the number of bytes covered by the ECC (BCH covered)
548 * The function does initialize the hardware ECC engine to compute the Hamming
549 * ECC (on 1 byte) and the BCH hardware ECC (on 7 bytes).
551 * Return 0 if succeeded, -EIO on error
553 static int doc_read_page_ecc_init(struct docg3
*docg3
, int len
)
555 doc_writew(docg3
, DOC_ECCCONF0_READ_MODE
556 | DOC_ECCCONF0_BCH_ENABLE
| DOC_ECCCONF0_HAMMING_ENABLE
557 | (len
& DOC_ECCCONF0_DATA_BYTES_MASK
),
560 doc_register_readb(docg3
, DOC_FLASHCONTROL
);
561 return doc_wait_ready(docg3
);
565 * doc_write_page_ecc_init - Initialize hardware BCH ECC engine
567 * @len: the number of bytes covered by the ECC (BCH covered)
569 * The function does initialize the hardware ECC engine to compute the Hamming
570 * ECC (on 1 byte) and the BCH hardware ECC (on 7 bytes).
572 * Return 0 if succeeded, -EIO on error
574 static int doc_write_page_ecc_init(struct docg3
*docg3
, int len
)
576 doc_writew(docg3
, DOC_ECCCONF0_WRITE_MODE
577 | DOC_ECCCONF0_BCH_ENABLE
| DOC_ECCCONF0_HAMMING_ENABLE
578 | (len
& DOC_ECCCONF0_DATA_BYTES_MASK
),
581 doc_register_readb(docg3
, DOC_FLASHCONTROL
);
582 return doc_wait_ready(docg3
);
586 * doc_ecc_disable - Disable Hamming and BCH ECC hardware calculator
589 * Disables the hardware ECC generator and checker, for unchecked reads (as when
590 * reading OOB only or write status byte).
592 static void doc_ecc_disable(struct docg3
*docg3
)
594 doc_writew(docg3
, DOC_ECCCONF0_READ_MODE
, DOC_ECCCONF0
);
599 * doc_hamming_ecc_init - Initialize hardware Hamming ECC engine
601 * @nb_bytes: the number of bytes covered by the ECC (Hamming covered)
603 * This function programs the ECC hardware to compute the hamming code on the
604 * last provided N bytes to the hardware generator.
606 static void doc_hamming_ecc_init(struct docg3
*docg3
, int nb_bytes
)
610 ecc_conf1
= doc_register_readb(docg3
, DOC_ECCCONF1
);
611 ecc_conf1
&= ~DOC_ECCCONF1_HAMMING_BITS_MASK
;
612 ecc_conf1
|= (nb_bytes
& DOC_ECCCONF1_HAMMING_BITS_MASK
);
613 doc_writeb(docg3
, ecc_conf1
, DOC_ECCCONF1
);
617 * doc_ecc_bch_fix_data - Fix if need be read data from flash
619 * @buf: the buffer of read data (512 + 7 + 1 bytes)
620 * @hwecc: the hardware calculated ECC.
621 * It's in fact recv_ecc ^ calc_ecc, where recv_ecc was read from OOB
622 * area data, and calc_ecc the ECC calculated by the hardware generator.
624 * Checks if the received data matches the ECC, and if an error is detected,
625 * tries to fix the bit flips (at most 4) in the buffer buf. As the docg3
626 * understands the (data, ecc, syndroms) in an inverted order in comparison to
627 * the BCH library, the function reverses the order of bits (ie. bit7 and bit0,
628 * bit6 and bit 1, ...) for all ECC data.
630 * The hardware ecc unit produces oob_ecc ^ calc_ecc. The kernel's bch
631 * algorithm is used to decode this. However the hw operates on page
632 * data in a bit order that is the reverse of that of the bch alg,
633 * requiring that the bits be reversed on the result. Thanks to Ivan
634 * Djelic for his analysis.
636 * Returns number of fixed bits (0, 1, 2, 3, 4) or -EBADMSG if too many bit
637 * errors were detected and cannot be fixed.
639 static int doc_ecc_bch_fix_data(struct docg3
*docg3
, void *buf
, u8
*hwecc
)
641 u8 ecc
[DOC_ECC_BCH_SIZE
];
642 int errorpos
[DOC_ECC_BCH_T
], i
, numerrs
;
644 for (i
= 0; i
< DOC_ECC_BCH_SIZE
; i
++)
645 ecc
[i
] = bitrev8(hwecc
[i
]);
646 numerrs
= decode_bch(docg3_bch
, NULL
, DOC_ECC_BCH_COVERED_BYTES
,
647 NULL
, ecc
, NULL
, errorpos
);
648 BUG_ON(numerrs
== -EINVAL
);
652 for (i
= 0; i
< numerrs
; i
++)
653 errorpos
[i
] = (errorpos
[i
] & ~7) | (7 - (errorpos
[i
] & 7));
654 for (i
= 0; i
< numerrs
; i
++)
655 if (errorpos
[i
] < DOC_ECC_BCH_COVERED_BYTES
*8)
656 /* error is located in data, correct it */
657 change_bit(errorpos
[i
], buf
);
659 doc_dbg("doc_ecc_bch_fix_data: flipped %d bits\n", numerrs
);
665 * doc_read_page_prepare - Prepares reading data from a flash page
667 * @block0: the first plane block index on flash memory
668 * @block1: the second plane block index on flash memory
669 * @page: the page index in the block
670 * @offset: the offset in the page (must be a multiple of 4)
672 * Prepares the page to be read in the flash memory :
673 * - tell ASIC to map the flash pages
674 * - tell ASIC to be in read mode
676 * After a call to this method, a call to doc_read_page_finish is mandatory,
677 * to end the read cycle of the flash.
679 * Read data from a flash page. The length to be read must be between 0 and
680 * (page_size + oob_size + wear_size), ie. 532, and a multiple of 4 (because
681 * the extra bytes reading is not implemented).
683 * As pages are grouped by 2 (in 2 planes), reading from a page must be done
685 * - one read of 512 bytes at offset 0
686 * - one read of 512 bytes at offset 512 + 16
688 * Returns 0 if successful, -EIO if a read error occured.
690 static int doc_read_page_prepare(struct docg3
*docg3
, int block0
, int block1
,
691 int page
, int offset
)
693 int wear_area
= 0, ret
= 0;
695 doc_dbg("doc_read_page_prepare(blocks=(%d,%d), page=%d, ofsInPage=%d)\n",
696 block0
, block1
, page
, offset
);
697 if (offset
>= DOC_LAYOUT_WEAR_OFFSET
)
699 if (!wear_area
&& offset
> (DOC_LAYOUT_PAGE_OOB_SIZE
* 2))
702 doc_set_device_id(docg3
, docg3
->device_id
);
703 ret
= doc_reset_seq(docg3
);
707 /* Program the flash address block and page */
708 ret
= doc_read_seek(docg3
, block0
, block1
, page
, wear_area
, offset
);
712 doc_flash_command(docg3
, DOC_CMD_READ_ALL_PLANES
);
714 doc_wait_ready(docg3
);
716 doc_flash_command(docg3
, DOC_CMD_SET_ADDR_READ
);
718 if (offset
>= DOC_LAYOUT_PAGE_SIZE
* 2)
719 offset
-= 2 * DOC_LAYOUT_PAGE_SIZE
;
720 doc_flash_address(docg3
, offset
>> 2);
722 doc_wait_ready(docg3
);
724 doc_flash_command(docg3
, DOC_CMD_READ_FLASH
);
728 doc_writeb(docg3
, 0, DOC_DATAEND
);
734 * doc_read_page_getbytes - Reads bytes from a prepared page
736 * @len: the number of bytes to be read (must be a multiple of 4)
737 * @buf: the buffer to be filled in (or NULL is forget bytes)
738 * @first: 1 if first time read, DOC_READADDRESS should be set
741 static int doc_read_page_getbytes(struct docg3
*docg3
, int len
, u_char
*buf
,
744 doc_read_data_area(docg3
, buf
, len
, first
);
750 * doc_write_page_putbytes - Writes bytes into a prepared page
752 * @len: the number of bytes to be written
753 * @buf: the buffer of input bytes
756 static void doc_write_page_putbytes(struct docg3
*docg3
, int len
,
759 doc_write_data_area(docg3
, buf
, len
);
764 * doc_get_bch_hw_ecc - Get hardware calculated BCH ECC
766 * @hwecc: the array of 7 integers where the hardware ecc will be stored
768 static void doc_get_bch_hw_ecc(struct docg3
*docg3
, u8
*hwecc
)
772 for (i
= 0; i
< DOC_ECC_BCH_SIZE
; i
++)
773 hwecc
[i
] = doc_register_readb(docg3
, DOC_BCH_HW_ECC(i
));
777 * doc_page_finish - Ends reading/writing of a flash page
780 static void doc_page_finish(struct docg3
*docg3
)
782 doc_writeb(docg3
, 0, DOC_DATAEND
);
787 * doc_read_page_finish - Ends reading of a flash page
790 * As a side effect, resets the chip selector to 0. This ensures that after each
791 * read operation, the floor 0 is selected. Therefore, if the systems halts, the
792 * reboot will boot on floor 0, where the IPL is.
794 static void doc_read_page_finish(struct docg3
*docg3
)
796 doc_page_finish(docg3
);
797 doc_set_device_id(docg3
, 0);
801 * calc_block_sector - Calculate blocks, pages and ofs.
803 * @from: offset in flash
804 * @block0: first plane block index calculated
805 * @block1: second plane block index calculated
806 * @page: page calculated
807 * @ofs: offset in page
808 * @reliable: 0 if docg3 in normal mode, 1 if docg3 in fast mode, 2 if docg3 in
811 * The calculation is based on the reliable/normal mode. In normal mode, the 64
812 * pages of a block are available. In reliable mode, as pages 2*n and 2*n+1 are
813 * clones, only 32 pages per block are available.
815 static void calc_block_sector(loff_t from
, int *block0
, int *block1
, int *page
,
816 int *ofs
, int reliable
)
818 uint sector
, pages_biblock
;
820 pages_biblock
= DOC_LAYOUT_PAGES_PER_BLOCK
* DOC_LAYOUT_NBPLANES
;
821 if (reliable
== 1 || reliable
== 2)
824 sector
= from
/ DOC_LAYOUT_PAGE_SIZE
;
825 *block0
= sector
/ pages_biblock
* DOC_LAYOUT_NBPLANES
;
826 *block1
= *block0
+ 1;
827 *page
= sector
% pages_biblock
;
828 *page
/= DOC_LAYOUT_NBPLANES
;
829 if (reliable
== 1 || reliable
== 2)
832 *ofs
= DOC_LAYOUT_PAGE_OOB_SIZE
;
838 * doc_read_oob - Read out of band bytes from flash
840 * @from: the offset from first block and first page, in bytes, aligned on page
842 * @ops: the mtd oob structure
844 * Reads flash memory OOB area of pages.
846 * Returns 0 if read successfull, of -EIO, -EINVAL if an error occured
848 static int doc_read_oob(struct mtd_info
*mtd
, loff_t from
,
849 struct mtd_oob_ops
*ops
)
851 struct docg3
*docg3
= mtd
->priv
;
852 int block0
, block1
, page
, ret
, skip
, ofs
= 0;
853 u8
*oobbuf
= ops
->oobbuf
;
854 u8
*buf
= ops
->datbuf
;
855 size_t len
, ooblen
, nbdata
, nboob
;
856 u8 hwecc
[DOC_ECC_BCH_SIZE
], eccconf1
;
863 ooblen
= ops
->ooblen
;
867 if (oobbuf
&& ops
->mode
== MTD_OPS_PLACE_OOB
)
868 oobbuf
+= ops
->ooboffs
;
870 doc_dbg("doc_read_oob(from=%lld, mode=%d, data=(%p:%zu), oob=(%p:%zu))\n",
871 from
, ops
->mode
, buf
, len
, oobbuf
, ooblen
);
872 if (ooblen
% DOC_LAYOUT_OOB_SIZE
)
876 calc_block_sector(from
+ len
, &block0
, &block1
, &page
, &ofs
,
878 if (block1
> docg3
->max_block
)
884 skip
= from
% DOC_LAYOUT_PAGE_SIZE
;
885 while (!ret
&& (len
> 0 || ooblen
> 0)) {
886 calc_block_sector(from
- skip
, &block0
, &block1
, &page
, &ofs
,
888 nbdata
= min_t(size_t, len
, DOC_LAYOUT_PAGE_SIZE
- skip
);
889 nboob
= min_t(size_t, ooblen
, (size_t)DOC_LAYOUT_OOB_SIZE
);
890 ret
= doc_read_page_prepare(docg3
, block0
, block1
, page
, ofs
);
893 ret
= doc_read_page_ecc_init(docg3
, DOC_ECC_BCH_TOTAL_BYTES
);
896 ret
= doc_read_page_getbytes(docg3
, skip
, NULL
, 1);
899 ret
= doc_read_page_getbytes(docg3
, nbdata
, buf
, 0);
902 doc_read_page_getbytes(docg3
,
903 DOC_LAYOUT_PAGE_SIZE
- nbdata
- skip
,
905 ret
= doc_read_page_getbytes(docg3
, nboob
, oobbuf
, 0);
908 doc_read_page_getbytes(docg3
, DOC_LAYOUT_OOB_SIZE
- nboob
,
911 doc_get_bch_hw_ecc(docg3
, hwecc
);
912 eccconf1
= doc_register_readb(docg3
, DOC_ECCCONF1
);
914 if (nboob
>= DOC_LAYOUT_OOB_SIZE
) {
915 doc_dbg("OOB - INFO: %02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
916 oobbuf
[0], oobbuf
[1], oobbuf
[2], oobbuf
[3],
917 oobbuf
[4], oobbuf
[5], oobbuf
[6]);
918 doc_dbg("OOB - HAMMING: %02x\n", oobbuf
[7]);
919 doc_dbg("OOB - BCH_ECC: %02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
920 oobbuf
[8], oobbuf
[9], oobbuf
[10], oobbuf
[11],
921 oobbuf
[12], oobbuf
[13], oobbuf
[14]);
922 doc_dbg("OOB - UNUSED: %02x\n", oobbuf
[15]);
924 doc_dbg("ECC checks: ECCConf1=%x\n", eccconf1
);
925 doc_dbg("ECC HW_ECC: %02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
926 hwecc
[0], hwecc
[1], hwecc
[2], hwecc
[3], hwecc
[4],
930 if (is_prot_seq_error(docg3
))
933 if ((block0
>= DOC_LAYOUT_BLOCK_FIRST_DATA
) &&
934 (eccconf1
& DOC_ECCCONF1_BCH_SYNDROM_ERR
) &&
935 (eccconf1
& DOC_ECCCONF1_PAGE_IS_WRITTEN
) &&
936 (ops
->mode
!= MTD_OPS_RAW
) &&
937 (nbdata
== DOC_LAYOUT_PAGE_SIZE
)) {
938 ret
= doc_ecc_bch_fix_data(docg3
, buf
, hwecc
);
940 mtd
->ecc_stats
.failed
++;
944 mtd
->ecc_stats
.corrected
+= ret
;
949 doc_read_page_finish(docg3
);
950 ops
->retlen
+= nbdata
;
951 ops
->oobretlen
+= nboob
;
956 from
+= DOC_LAYOUT_PAGE_SIZE
;
962 doc_read_page_finish(docg3
);
968 * doc_read - Read bytes from flash
970 * @from: the offset from first block and first page, in bytes, aligned on page
972 * @len: the number of bytes to read (must be a multiple of 4)
973 * @retlen: the number of bytes actually read
974 * @buf: the filled in buffer
976 * Reads flash memory pages. This function does not read the OOB chunk, but only
979 * Returns 0 if read successfull, of -EIO, -EINVAL if an error occured
981 static int doc_read(struct mtd_info
*mtd
, loff_t from
, size_t len
,
982 size_t *retlen
, u_char
*buf
)
984 struct mtd_oob_ops ops
;
987 memset(&ops
, 0, sizeof(ops
));
990 ops
.mode
= MTD_OPS_AUTO_OOB
;
992 ret
= doc_read_oob(mtd
, from
, &ops
);
993 *retlen
= ops
.retlen
;
997 static int doc_reload_bbt(struct docg3
*docg3
)
999 int block
= DOC_LAYOUT_BLOCK_BBT
;
1000 int ret
= 0, nbpages
, page
;
1001 u_char
*buf
= docg3
->bbt
;
1003 nbpages
= DIV_ROUND_UP(docg3
->max_block
+ 1, 8 * DOC_LAYOUT_PAGE_SIZE
);
1004 for (page
= 0; !ret
&& (page
< nbpages
); page
++) {
1005 ret
= doc_read_page_prepare(docg3
, block
, block
+ 1,
1006 page
+ DOC_LAYOUT_PAGE_BBT
, 0);
1008 ret
= doc_read_page_ecc_init(docg3
,
1009 DOC_LAYOUT_PAGE_SIZE
);
1011 doc_read_page_getbytes(docg3
, DOC_LAYOUT_PAGE_SIZE
,
1013 buf
+= DOC_LAYOUT_PAGE_SIZE
;
1015 doc_read_page_finish(docg3
);
1020 * doc_block_isbad - Checks whether a block is good or not
1022 * @from: the offset to find the correct block
1024 * Returns 1 if block is bad, 0 if block is good
1026 static int doc_block_isbad(struct mtd_info
*mtd
, loff_t from
)
1028 struct docg3
*docg3
= mtd
->priv
;
1029 int block0
, block1
, page
, ofs
, is_good
;
1031 calc_block_sector(from
, &block0
, &block1
, &page
, &ofs
,
1033 doc_dbg("doc_block_isbad(from=%lld) => block=(%d,%d), page=%d, ofs=%d\n",
1034 from
, block0
, block1
, page
, ofs
);
1036 if (block0
< DOC_LAYOUT_BLOCK_FIRST_DATA
)
1038 if (block1
> docg3
->max_block
)
1041 is_good
= docg3
->bbt
[block0
>> 3] & (1 << (block0
& 0x7));
1047 * doc_get_erase_count - Get block erase count
1048 * @docg3: the device
1049 * @from: the offset in which the block is.
1051 * Get the number of times a block was erased. The number is the maximum of
1052 * erase times between first and second plane (which should be equal normally).
1054 * Returns The number of erases, or -EINVAL or -EIO on error.
1056 static int doc_get_erase_count(struct docg3
*docg3
, loff_t from
)
1058 u8 buf
[DOC_LAYOUT_WEAR_SIZE
];
1059 int ret
, plane1_erase_count
, plane2_erase_count
;
1060 int block0
, block1
, page
, ofs
;
1062 doc_dbg("doc_get_erase_count(from=%lld, buf=%p)\n", from
, buf
);
1063 if (from
% DOC_LAYOUT_PAGE_SIZE
)
1065 calc_block_sector(from
, &block0
, &block1
, &page
, &ofs
, docg3
->reliable
);
1066 if (block1
> docg3
->max_block
)
1069 ret
= doc_reset_seq(docg3
);
1071 ret
= doc_read_page_prepare(docg3
, block0
, block1
, page
,
1072 ofs
+ DOC_LAYOUT_WEAR_OFFSET
);
1074 ret
= doc_read_page_getbytes(docg3
, DOC_LAYOUT_WEAR_SIZE
,
1076 doc_read_page_finish(docg3
);
1078 if (ret
|| (buf
[0] != DOC_ERASE_MARK
) || (buf
[2] != DOC_ERASE_MARK
))
1080 plane1_erase_count
= (u8
)(~buf
[1]) | ((u8
)(~buf
[4]) << 8)
1081 | ((u8
)(~buf
[5]) << 16);
1082 plane2_erase_count
= (u8
)(~buf
[3]) | ((u8
)(~buf
[6]) << 8)
1083 | ((u8
)(~buf
[7]) << 16);
1085 return max(plane1_erase_count
, plane2_erase_count
);
1090 * doc_get_op_status - get erase/write operation status
1091 * @docg3: the device
1093 * Queries the status from the chip, and returns it
1095 * Returns the status (bits DOC_PLANES_STATUS_*)
1097 static int doc_get_op_status(struct docg3
*docg3
)
1101 doc_flash_sequence(docg3
, DOC_SEQ_PLANES_STATUS
);
1102 doc_flash_command(docg3
, DOC_CMD_PLANES_STATUS
);
1103 doc_delay(docg3
, 5);
1105 doc_ecc_disable(docg3
);
1106 doc_read_data_area(docg3
, &status
, 1, 1);
1111 * doc_write_erase_wait_status - wait for write or erase completion
1112 * @docg3: the device
1114 * Wait for the chip to be ready again after erase or write operation, and check
1115 * erase/write status.
1117 * Returns 0 if erase successfull, -EIO if erase/write issue, -ETIMEOUT if
1120 static int doc_write_erase_wait_status(struct docg3
*docg3
)
1122 int status
, ret
= 0;
1124 if (!doc_is_ready(docg3
))
1125 usleep_range(3000, 3000);
1126 if (!doc_is_ready(docg3
)) {
1127 doc_dbg("Timeout reached and the chip is still not ready\n");
1132 status
= doc_get_op_status(docg3
);
1133 if (status
& DOC_PLANES_STATUS_FAIL
) {
1134 doc_dbg("Erase/Write failed on (a) plane(s), status = %x\n",
1140 doc_page_finish(docg3
);
1145 * doc_erase_block - Erase a couple of blocks
1146 * @docg3: the device
1147 * @block0: the first block to erase (leftmost plane)
1148 * @block1: the second block to erase (rightmost plane)
1150 * Erase both blocks, and return operation status
1152 * Returns 0 if erase successful, -EIO if erase issue, -ETIMEOUT if chip not
1153 * ready for too long
1155 static int doc_erase_block(struct docg3
*docg3
, int block0
, int block1
)
1159 doc_dbg("doc_erase_block(blocks=(%d,%d))\n", block0
, block1
);
1160 ret
= doc_reset_seq(docg3
);
1164 doc_set_reliable_mode(docg3
);
1165 doc_flash_sequence(docg3
, DOC_SEQ_ERASE
);
1167 sector
= block0
<< DOC_ADDR_BLOCK_SHIFT
;
1168 doc_flash_command(docg3
, DOC_CMD_PROG_BLOCK_ADDR
);
1169 doc_setup_addr_sector(docg3
, sector
);
1170 sector
= block1
<< DOC_ADDR_BLOCK_SHIFT
;
1171 doc_flash_command(docg3
, DOC_CMD_PROG_BLOCK_ADDR
);
1172 doc_setup_addr_sector(docg3
, sector
);
1173 doc_delay(docg3
, 1);
1175 doc_flash_command(docg3
, DOC_CMD_ERASECYCLE2
);
1176 doc_delay(docg3
, 2);
1178 if (is_prot_seq_error(docg3
)) {
1179 doc_err("Erase blocks %d,%d error\n", block0
, block1
);
1183 return doc_write_erase_wait_status(docg3
);
1187 * doc_erase - Erase a portion of the chip
1189 * @info: the erase info
1191 * Erase a bunch of contiguous blocks, by pairs, as a "mtd" page of 1024 is
1192 * split into 2 pages of 512 bytes on 2 contiguous blocks.
1194 * Returns 0 if erase successful, -EINVAL if adressing error, -EIO if erase
1197 static int doc_erase(struct mtd_info
*mtd
, struct erase_info
*info
)
1199 struct docg3
*docg3
= mtd
->priv
;
1201 int block0
, block1
, page
, ret
, ofs
= 0;
1203 doc_dbg("doc_erase(from=%lld, len=%lld\n", info
->addr
, info
->len
);
1204 doc_set_device_id(docg3
, docg3
->device_id
);
1206 info
->state
= MTD_ERASE_PENDING
;
1207 calc_block_sector(info
->addr
+ info
->len
, &block0
, &block1
, &page
,
1208 &ofs
, docg3
->reliable
);
1210 if (block1
> docg3
->max_block
|| page
|| ofs
)
1214 calc_block_sector(info
->addr
, &block0
, &block1
, &page
, &ofs
,
1216 doc_set_reliable_mode(docg3
);
1217 for (len
= info
->len
; !ret
&& len
> 0; len
-= mtd
->erasesize
) {
1218 info
->state
= MTD_ERASING
;
1219 ret
= doc_erase_block(docg3
, block0
, block1
);
1227 info
->state
= MTD_ERASE_DONE
;
1231 info
->state
= MTD_ERASE_FAILED
;
1236 * doc_write_page - Write a single page to the chip
1237 * @docg3: the device
1238 * @to: the offset from first block and first page, in bytes, aligned on page
1240 * @buf: buffer to get bytes from
1241 * @oob: buffer to get out of band bytes from (can be NULL if no OOB should be
1243 * @autoecc: if 0, all 16 bytes from OOB are taken, regardless of HW Hamming or
1244 * BCH computations. If 1, only bytes 0-7 and byte 15 are taken,
1245 * remaining ones are filled with hardware Hamming and BCH
1246 * computations. Its value is not meaningfull is oob == NULL.
1248 * Write one full page (ie. 1 page split on two planes), of 512 bytes, with the
1249 * OOB data. The OOB ECC is automatically computed by the hardware Hamming and
1250 * BCH generator if autoecc is not null.
1252 * Returns 0 if write successful, -EIO if write error, -EAGAIN if timeout
1254 static int doc_write_page(struct docg3
*docg3
, loff_t to
, const u_char
*buf
,
1255 const u_char
*oob
, int autoecc
)
1257 int block0
, block1
, page
, ret
, ofs
= 0;
1258 u8 hwecc
[DOC_ECC_BCH_SIZE
], hamming
;
1260 doc_dbg("doc_write_page(to=%lld)\n", to
);
1261 calc_block_sector(to
, &block0
, &block1
, &page
, &ofs
, docg3
->reliable
);
1263 doc_set_device_id(docg3
, docg3
->device_id
);
1264 ret
= doc_reset_seq(docg3
);
1268 /* Program the flash address block and page */
1269 ret
= doc_write_seek(docg3
, block0
, block1
, page
, ofs
);
1273 doc_write_page_ecc_init(docg3
, DOC_ECC_BCH_TOTAL_BYTES
);
1274 doc_delay(docg3
, 2);
1275 doc_write_page_putbytes(docg3
, DOC_LAYOUT_PAGE_SIZE
, buf
);
1277 if (oob
&& autoecc
) {
1278 doc_write_page_putbytes(docg3
, DOC_LAYOUT_OOB_PAGEINFO_SZ
, oob
);
1279 doc_delay(docg3
, 2);
1280 oob
+= DOC_LAYOUT_OOB_UNUSED_OFS
;
1282 hamming
= doc_register_readb(docg3
, DOC_HAMMINGPARITY
);
1283 doc_delay(docg3
, 2);
1284 doc_write_page_putbytes(docg3
, DOC_LAYOUT_OOB_HAMMING_SZ
,
1286 doc_delay(docg3
, 2);
1288 doc_get_bch_hw_ecc(docg3
, hwecc
);
1289 doc_write_page_putbytes(docg3
, DOC_LAYOUT_OOB_BCH_SZ
, hwecc
);
1290 doc_delay(docg3
, 2);
1292 doc_write_page_putbytes(docg3
, DOC_LAYOUT_OOB_UNUSED_SZ
, oob
);
1294 if (oob
&& !autoecc
)
1295 doc_write_page_putbytes(docg3
, DOC_LAYOUT_OOB_SIZE
, oob
);
1297 doc_delay(docg3
, 2);
1298 doc_page_finish(docg3
);
1299 doc_delay(docg3
, 2);
1300 doc_flash_command(docg3
, DOC_CMD_PROG_CYCLE2
);
1301 doc_delay(docg3
, 2);
1304 * The wait status will perform another doc_page_finish() call, but that
1305 * seems to please the docg3, so leave it.
1307 ret
= doc_write_erase_wait_status(docg3
);
1310 doc_read_page_finish(docg3
);
1315 * doc_guess_autoecc - Guess autoecc mode from mbd_oob_ops
1316 * @ops: the oob operations
1318 * Returns 0 or 1 if success, -EINVAL if invalid oob mode
1320 static int doc_guess_autoecc(struct mtd_oob_ops
*ops
)
1324 switch (ops
->mode
) {
1325 case MTD_OPS_PLACE_OOB
:
1326 case MTD_OPS_AUTO_OOB
:
1339 * doc_fill_autooob - Fill a 16 bytes OOB from 8 non-ECC bytes
1340 * @dst: the target 16 bytes OOB buffer
1341 * @oobsrc: the source 8 bytes non-ECC OOB buffer
1344 static void doc_fill_autooob(u8
*dst
, u8
*oobsrc
)
1346 memcpy(dst
, oobsrc
, DOC_LAYOUT_OOB_PAGEINFO_SZ
);
1347 dst
[DOC_LAYOUT_OOB_UNUSED_OFS
] = oobsrc
[DOC_LAYOUT_OOB_PAGEINFO_SZ
];
1351 * doc_backup_oob - Backup OOB into docg3 structure
1352 * @docg3: the device
1353 * @to: the page offset in the chip
1354 * @ops: the OOB size and buffer
1356 * As the docg3 should write a page with its OOB in one pass, and some userland
1357 * applications do write_oob() to setup the OOB and then write(), store the OOB
1358 * into a temporary storage. This is very dangerous, as 2 concurrent
1359 * applications could store an OOB, and then write their pages (which will
1360 * result into one having its OOB corrupted).
1362 * The only reliable way would be for userland to call doc_write_oob() with both
1363 * the page data _and_ the OOB area.
1365 * Returns 0 if success, -EINVAL if ops content invalid
1367 static int doc_backup_oob(struct docg3
*docg3
, loff_t to
,
1368 struct mtd_oob_ops
*ops
)
1370 int ooblen
= ops
->ooblen
, autoecc
;
1372 if (ooblen
!= DOC_LAYOUT_OOB_SIZE
)
1374 autoecc
= doc_guess_autoecc(ops
);
1378 docg3
->oob_write_ofs
= to
;
1379 docg3
->oob_autoecc
= autoecc
;
1380 if (ops
->mode
== MTD_OPS_AUTO_OOB
) {
1381 doc_fill_autooob(docg3
->oob_write_buf
, ops
->oobbuf
);
1384 memcpy(docg3
->oob_write_buf
, ops
->oobbuf
, DOC_LAYOUT_OOB_SIZE
);
1385 ops
->oobretlen
= DOC_LAYOUT_OOB_SIZE
;
1391 * doc_write_oob - Write out of band bytes to flash
1393 * @ofs: the offset from first block and first page, in bytes, aligned on page
1395 * @ops: the mtd oob structure
1397 * Either write OOB data into a temporary buffer, for the subsequent write
1398 * page. The provided OOB should be 16 bytes long. If a data buffer is provided
1399 * as well, issue the page write.
1400 * Or provide data without OOB, and then a all zeroed OOB will be used (ECC will
1401 * still be filled in if asked for).
1403 * Returns 0 is successfull, EINVAL if length is not 14 bytes
1405 static int doc_write_oob(struct mtd_info
*mtd
, loff_t ofs
,
1406 struct mtd_oob_ops
*ops
)
1408 struct docg3
*docg3
= mtd
->priv
;
1409 int block0
, block1
, page
, ret
, pofs
= 0, autoecc
, oobdelta
;
1410 u8
*oobbuf
= ops
->oobbuf
;
1411 u8
*buf
= ops
->datbuf
;
1413 u8 oob
[DOC_LAYOUT_OOB_SIZE
];
1420 ooblen
= ops
->ooblen
;
1424 if (oobbuf
&& ops
->mode
== MTD_OPS_PLACE_OOB
)
1425 oobbuf
+= ops
->ooboffs
;
1427 doc_dbg("doc_write_oob(from=%lld, mode=%d, data=(%p:%zu), oob=(%p:%zu))\n",
1428 ofs
, ops
->mode
, buf
, len
, oobbuf
, ooblen
);
1429 switch (ops
->mode
) {
1430 case MTD_OPS_PLACE_OOB
:
1432 oobdelta
= mtd
->oobsize
;
1434 case MTD_OPS_AUTO_OOB
:
1435 oobdelta
= mtd
->ecclayout
->oobavail
;
1440 if ((len
% DOC_LAYOUT_PAGE_SIZE
) || (ooblen
% oobdelta
) ||
1441 (ofs
% DOC_LAYOUT_PAGE_SIZE
))
1443 if (len
&& ooblen
&&
1444 (len
/ DOC_LAYOUT_PAGE_SIZE
) != (ooblen
/ oobdelta
))
1448 calc_block_sector(ofs
+ len
, &block0
, &block1
, &page
, &pofs
,
1450 if (block1
> docg3
->max_block
)
1456 if (len
== 0 && ooblen
== 0)
1458 if (len
== 0 && ooblen
> 0)
1459 return doc_backup_oob(docg3
, ofs
, ops
);
1461 autoecc
= doc_guess_autoecc(ops
);
1465 while (!ret
&& len
> 0) {
1466 memset(oob
, 0, sizeof(oob
));
1467 if (ofs
== docg3
->oob_write_ofs
)
1468 memcpy(oob
, docg3
->oob_write_buf
, DOC_LAYOUT_OOB_SIZE
);
1469 else if (ooblen
> 0 && ops
->mode
== MTD_OPS_AUTO_OOB
)
1470 doc_fill_autooob(oob
, oobbuf
);
1471 else if (ooblen
> 0)
1472 memcpy(oob
, oobbuf
, DOC_LAYOUT_OOB_SIZE
);
1473 ret
= doc_write_page(docg3
, ofs
, buf
, oob
, autoecc
);
1475 ofs
+= DOC_LAYOUT_PAGE_SIZE
;
1476 len
-= DOC_LAYOUT_PAGE_SIZE
;
1477 buf
+= DOC_LAYOUT_PAGE_SIZE
;
1481 ops
->oobretlen
+= oobdelta
;
1483 ops
->retlen
+= DOC_LAYOUT_PAGE_SIZE
;
1486 doc_set_device_id(docg3
, 0);
1491 * doc_write - Write a buffer to the chip
1493 * @to: the offset from first block and first page, in bytes, aligned on page
1495 * @len: the number of bytes to write (must be a full page size, ie. 512)
1496 * @retlen: the number of bytes actually written (0 or 512)
1497 * @buf: the buffer to get bytes from
1499 * Writes data to the chip.
1501 * Returns 0 if write successful, -EIO if write error
1503 static int doc_write(struct mtd_info
*mtd
, loff_t to
, size_t len
,
1504 size_t *retlen
, const u_char
*buf
)
1506 struct docg3
*docg3
= mtd
->priv
;
1508 struct mtd_oob_ops ops
;
1510 doc_dbg("doc_write(to=%lld, len=%zu)\n", to
, len
);
1511 ops
.datbuf
= (char *)buf
;
1513 ops
.mode
= MTD_OPS_PLACE_OOB
;
1518 ret
= doc_write_oob(mtd
, to
, &ops
);
1519 *retlen
= ops
.retlen
;
1523 static struct docg3
*sysfs_dev2docg3(struct device
*dev
,
1524 struct device_attribute
*attr
)
1527 struct platform_device
*pdev
= to_platform_device(dev
);
1528 struct mtd_info
**docg3_floors
= platform_get_drvdata(pdev
);
1530 floor
= attr
->attr
.name
[1] - '0';
1531 if (floor
< 0 || floor
>= DOC_MAX_NBFLOORS
)
1534 return docg3_floors
[floor
]->priv
;
1537 static ssize_t
dps0_is_key_locked(struct device
*dev
,
1538 struct device_attribute
*attr
, char *buf
)
1540 struct docg3
*docg3
= sysfs_dev2docg3(dev
, attr
);
1543 doc_set_device_id(docg3
, docg3
->device_id
);
1544 dps0
= doc_register_readb(docg3
, DOC_DPS0_STATUS
);
1545 doc_set_device_id(docg3
, 0);
1547 return sprintf(buf
, "%d\n", !(dps0
& DOC_DPS_KEY_OK
));
1550 static ssize_t
dps1_is_key_locked(struct device
*dev
,
1551 struct device_attribute
*attr
, char *buf
)
1553 struct docg3
*docg3
= sysfs_dev2docg3(dev
, attr
);
1556 doc_set_device_id(docg3
, docg3
->device_id
);
1557 dps1
= doc_register_readb(docg3
, DOC_DPS1_STATUS
);
1558 doc_set_device_id(docg3
, 0);
1560 return sprintf(buf
, "%d\n", !(dps1
& DOC_DPS_KEY_OK
));
1563 static ssize_t
dps0_insert_key(struct device
*dev
,
1564 struct device_attribute
*attr
,
1565 const char *buf
, size_t count
)
1567 struct docg3
*docg3
= sysfs_dev2docg3(dev
, attr
);
1570 if (count
!= DOC_LAYOUT_DPS_KEY_LENGTH
)
1573 doc_set_device_id(docg3
, docg3
->device_id
);
1574 for (i
= 0; i
< DOC_LAYOUT_DPS_KEY_LENGTH
; i
++)
1575 doc_writeb(docg3
, buf
[i
], DOC_DPS0_KEY
);
1576 doc_set_device_id(docg3
, 0);
1580 static ssize_t
dps1_insert_key(struct device
*dev
,
1581 struct device_attribute
*attr
,
1582 const char *buf
, size_t count
)
1584 struct docg3
*docg3
= sysfs_dev2docg3(dev
, attr
);
1587 if (count
!= DOC_LAYOUT_DPS_KEY_LENGTH
)
1590 doc_set_device_id(docg3
, docg3
->device_id
);
1591 for (i
= 0; i
< DOC_LAYOUT_DPS_KEY_LENGTH
; i
++)
1592 doc_writeb(docg3
, buf
[i
], DOC_DPS1_KEY
);
1593 doc_set_device_id(docg3
, 0);
1597 #define FLOOR_SYSFS(id) { \
1598 __ATTR(f##id##_dps0_is_keylocked, S_IRUGO, dps0_is_key_locked, NULL), \
1599 __ATTR(f##id##_dps1_is_keylocked, S_IRUGO, dps1_is_key_locked, NULL), \
1600 __ATTR(f##id##_dps0_protection_key, S_IWUGO, NULL, dps0_insert_key), \
1601 __ATTR(f##id##_dps1_protection_key, S_IWUGO, NULL, dps1_insert_key), \
1604 static struct device_attribute doc_sys_attrs
[DOC_MAX_NBFLOORS
][4] = {
1605 FLOOR_SYSFS(0), FLOOR_SYSFS(1), FLOOR_SYSFS(2), FLOOR_SYSFS(3)
1608 static int doc_register_sysfs(struct platform_device
*pdev
,
1609 struct mtd_info
**floors
)
1611 int ret
= 0, floor
, i
= 0;
1612 struct device
*dev
= &pdev
->dev
;
1614 for (floor
= 0; !ret
&& floor
< DOC_MAX_NBFLOORS
&& floors
[floor
];
1616 for (i
= 0; !ret
&& i
< 4; i
++)
1617 ret
= device_create_file(dev
, &doc_sys_attrs
[floor
][i
]);
1622 device_remove_file(dev
, &doc_sys_attrs
[floor
][i
]);
1624 } while (--floor
>= 0);
1628 static void doc_unregister_sysfs(struct platform_device
*pdev
,
1629 struct mtd_info
**floors
)
1631 struct device
*dev
= &pdev
->dev
;
1634 for (floor
= 0; floor
< DOC_MAX_NBFLOORS
&& floors
[floor
];
1636 for (i
= 0; i
< 4; i
++)
1637 device_remove_file(dev
, &doc_sys_attrs
[floor
][i
]);
1641 * Debug sysfs entries
1643 static int dbg_flashctrl_show(struct seq_file
*s
, void *p
)
1645 struct docg3
*docg3
= (struct docg3
*)s
->private;
1648 u8 fctrl
= doc_register_readb(docg3
, DOC_FLASHCONTROL
);
1650 pos
+= seq_printf(s
,
1651 "FlashControl : 0x%02x (%s,CE# %s,%s,%s,flash %s)\n",
1653 fctrl
& DOC_CTRL_VIOLATION
? "protocol violation" : "-",
1654 fctrl
& DOC_CTRL_CE
? "active" : "inactive",
1655 fctrl
& DOC_CTRL_PROTECTION_ERROR
? "protection error" : "-",
1656 fctrl
& DOC_CTRL_SEQUENCE_ERROR
? "sequence error" : "-",
1657 fctrl
& DOC_CTRL_FLASHREADY
? "ready" : "not ready");
1660 DEBUGFS_RO_ATTR(flashcontrol
, dbg_flashctrl_show
);
1662 static int dbg_asicmode_show(struct seq_file
*s
, void *p
)
1664 struct docg3
*docg3
= (struct docg3
*)s
->private;
1667 int pctrl
= doc_register_readb(docg3
, DOC_ASICMODE
);
1668 int mode
= pctrl
& 0x03;
1670 pos
+= seq_printf(s
,
1671 "%04x : RAM_WE=%d,RSTIN_RESET=%d,BDETCT_RESET=%d,WRITE_ENABLE=%d,POWERDOWN=%d,MODE=%d%d (",
1673 pctrl
& DOC_ASICMODE_RAM_WE
? 1 : 0,
1674 pctrl
& DOC_ASICMODE_RSTIN_RESET
? 1 : 0,
1675 pctrl
& DOC_ASICMODE_BDETCT_RESET
? 1 : 0,
1676 pctrl
& DOC_ASICMODE_MDWREN
? 1 : 0,
1677 pctrl
& DOC_ASICMODE_POWERDOWN
? 1 : 0,
1678 mode
>> 1, mode
& 0x1);
1681 case DOC_ASICMODE_RESET
:
1682 pos
+= seq_printf(s
, "reset");
1684 case DOC_ASICMODE_NORMAL
:
1685 pos
+= seq_printf(s
, "normal");
1687 case DOC_ASICMODE_POWERDOWN
:
1688 pos
+= seq_printf(s
, "powerdown");
1691 pos
+= seq_printf(s
, ")\n");
1694 DEBUGFS_RO_ATTR(asic_mode
, dbg_asicmode_show
);
1696 static int dbg_device_id_show(struct seq_file
*s
, void *p
)
1698 struct docg3
*docg3
= (struct docg3
*)s
->private;
1700 int id
= doc_register_readb(docg3
, DOC_DEVICESELECT
);
1702 pos
+= seq_printf(s
, "DeviceId = %d\n", id
);
1705 DEBUGFS_RO_ATTR(device_id
, dbg_device_id_show
);
1707 static int dbg_protection_show(struct seq_file
*s
, void *p
)
1709 struct docg3
*docg3
= (struct docg3
*)s
->private;
1711 int protect
, dps0
, dps0_low
, dps0_high
, dps1
, dps1_low
, dps1_high
;
1713 protect
= doc_register_readb(docg3
, DOC_PROTECTION
);
1714 dps0
= doc_register_readb(docg3
, DOC_DPS0_STATUS
);
1715 dps0_low
= doc_register_readw(docg3
, DOC_DPS0_ADDRLOW
);
1716 dps0_high
= doc_register_readw(docg3
, DOC_DPS0_ADDRHIGH
);
1717 dps1
= doc_register_readb(docg3
, DOC_DPS1_STATUS
);
1718 dps1_low
= doc_register_readw(docg3
, DOC_DPS1_ADDRLOW
);
1719 dps1_high
= doc_register_readw(docg3
, DOC_DPS1_ADDRHIGH
);
1721 pos
+= seq_printf(s
, "Protection = 0x%02x (",
1723 if (protect
& DOC_PROTECT_FOUNDRY_OTP_LOCK
)
1724 pos
+= seq_printf(s
, "FOUNDRY_OTP_LOCK,");
1725 if (protect
& DOC_PROTECT_CUSTOMER_OTP_LOCK
)
1726 pos
+= seq_printf(s
, "CUSTOMER_OTP_LOCK,");
1727 if (protect
& DOC_PROTECT_LOCK_INPUT
)
1728 pos
+= seq_printf(s
, "LOCK_INPUT,");
1729 if (protect
& DOC_PROTECT_STICKY_LOCK
)
1730 pos
+= seq_printf(s
, "STICKY_LOCK,");
1731 if (protect
& DOC_PROTECT_PROTECTION_ENABLED
)
1732 pos
+= seq_printf(s
, "PROTECTION ON,");
1733 if (protect
& DOC_PROTECT_IPL_DOWNLOAD_LOCK
)
1734 pos
+= seq_printf(s
, "IPL_DOWNLOAD_LOCK,");
1735 if (protect
& DOC_PROTECT_PROTECTION_ERROR
)
1736 pos
+= seq_printf(s
, "PROTECT_ERR,");
1738 pos
+= seq_printf(s
, "NO_PROTECT_ERR");
1739 pos
+= seq_printf(s
, ")\n");
1741 pos
+= seq_printf(s
, "DPS0 = 0x%02x : "
1742 "Protected area [0x%x - 0x%x] : OTP=%d, READ=%d, "
1743 "WRITE=%d, HW_LOCK=%d, KEY_OK=%d\n",
1744 dps0
, dps0_low
, dps0_high
,
1745 !!(dps0
& DOC_DPS_OTP_PROTECTED
),
1746 !!(dps0
& DOC_DPS_READ_PROTECTED
),
1747 !!(dps0
& DOC_DPS_WRITE_PROTECTED
),
1748 !!(dps0
& DOC_DPS_HW_LOCK_ENABLED
),
1749 !!(dps0
& DOC_DPS_KEY_OK
));
1750 pos
+= seq_printf(s
, "DPS1 = 0x%02x : "
1751 "Protected area [0x%x - 0x%x] : OTP=%d, READ=%d, "
1752 "WRITE=%d, HW_LOCK=%d, KEY_OK=%d\n",
1753 dps1
, dps1_low
, dps1_high
,
1754 !!(dps1
& DOC_DPS_OTP_PROTECTED
),
1755 !!(dps1
& DOC_DPS_READ_PROTECTED
),
1756 !!(dps1
& DOC_DPS_WRITE_PROTECTED
),
1757 !!(dps1
& DOC_DPS_HW_LOCK_ENABLED
),
1758 !!(dps1
& DOC_DPS_KEY_OK
));
1761 DEBUGFS_RO_ATTR(protection
, dbg_protection_show
);
1763 static int __init
doc_dbg_register(struct docg3
*docg3
)
1765 struct dentry
*root
, *entry
;
1767 root
= debugfs_create_dir("docg3", NULL
);
1771 entry
= debugfs_create_file("flashcontrol", S_IRUSR
, root
, docg3
,
1772 &flashcontrol_fops
);
1774 entry
= debugfs_create_file("asic_mode", S_IRUSR
, root
,
1775 docg3
, &asic_mode_fops
);
1777 entry
= debugfs_create_file("device_id", S_IRUSR
, root
,
1778 docg3
, &device_id_fops
);
1780 entry
= debugfs_create_file("protection", S_IRUSR
, root
,
1781 docg3
, &protection_fops
);
1783 docg3
->debugfs_root
= root
;
1786 debugfs_remove_recursive(root
);
1791 static void __exit
doc_dbg_unregister(struct docg3
*docg3
)
1793 debugfs_remove_recursive(docg3
->debugfs_root
);
1797 * doc_set_driver_info - Fill the mtd_info structure and docg3 structure
1798 * @chip_id: The chip ID of the supported chip
1799 * @mtd: The structure to fill
1801 static void __init
doc_set_driver_info(int chip_id
, struct mtd_info
*mtd
)
1803 struct docg3
*docg3
= mtd
->priv
;
1806 cfg
= doc_register_readb(docg3
, DOC_CONFIGURATION
);
1807 docg3
->if_cfg
= (cfg
& DOC_CONF_IF_CFG
? 1 : 0);
1808 docg3
->reliable
= reliable_mode
;
1812 mtd
->name
= kasprintf(GFP_KERNEL
, "docg3.%d",
1814 docg3
->max_block
= 2047;
1817 mtd
->type
= MTD_NANDFLASH
;
1818 mtd
->flags
= MTD_CAP_NANDFLASH
;
1819 mtd
->size
= (docg3
->max_block
+ 1) * DOC_LAYOUT_BLOCK_SIZE
;
1820 if (docg3
->reliable
== 2)
1822 mtd
->erasesize
= DOC_LAYOUT_BLOCK_SIZE
* DOC_LAYOUT_NBPLANES
;
1823 if (docg3
->reliable
== 2)
1824 mtd
->erasesize
/= 2;
1825 mtd
->writebufsize
= mtd
->writesize
= DOC_LAYOUT_PAGE_SIZE
;
1826 mtd
->oobsize
= DOC_LAYOUT_OOB_SIZE
;
1827 mtd
->owner
= THIS_MODULE
;
1828 mtd
->_erase
= doc_erase
;
1829 mtd
->_read
= doc_read
;
1830 mtd
->_write
= doc_write
;
1831 mtd
->_read_oob
= doc_read_oob
;
1832 mtd
->_write_oob
= doc_write_oob
;
1833 mtd
->_block_isbad
= doc_block_isbad
;
1834 mtd
->ecclayout
= &docg3_oobinfo
;
1835 mtd
->ecc_strength
= DOC_ECC_BCH_T
;
1839 * doc_probe_device - Check if a device is available
1840 * @base: the io space where the device is probed
1841 * @floor: the floor of the probed device
1844 * Checks whether a device at the specified IO range, and floor is available.
1846 * Returns a mtd_info struct if there is a device, ENODEV if none found, ENOMEM
1847 * if a memory allocation failed. If floor 0 is checked, a reset of the ASIC is
1850 static struct mtd_info
*doc_probe_device(void __iomem
*base
, int floor
,
1853 int ret
, bbt_nbpages
;
1854 u16 chip_id
, chip_id_inv
;
1855 struct docg3
*docg3
;
1856 struct mtd_info
*mtd
;
1859 docg3
= kzalloc(sizeof(struct docg3
), GFP_KERNEL
);
1862 mtd
= kzalloc(sizeof(struct mtd_info
), GFP_KERNEL
);
1866 bbt_nbpages
= DIV_ROUND_UP(docg3
->max_block
+ 1,
1867 8 * DOC_LAYOUT_PAGE_SIZE
);
1868 docg3
->bbt
= kzalloc(bbt_nbpages
* DOC_LAYOUT_PAGE_SIZE
, GFP_KERNEL
);
1873 docg3
->device_id
= floor
;
1875 doc_set_device_id(docg3
, docg3
->device_id
);
1877 doc_set_asic_mode(docg3
, DOC_ASICMODE_RESET
);
1878 doc_set_asic_mode(docg3
, DOC_ASICMODE_NORMAL
);
1880 chip_id
= doc_register_readw(docg3
, DOC_CHIPID
);
1881 chip_id_inv
= doc_register_readw(docg3
, DOC_CHIPID_INV
);
1884 if (chip_id
!= (u16
)(~chip_id_inv
)) {
1890 doc_info("Found a G3 DiskOnChip at addr %p, floor %d\n",
1894 doc_err("Chip id %04x is not a DiskOnChip G3 chip\n", chip_id
);
1898 doc_set_driver_info(chip_id
, mtd
);
1900 doc_hamming_ecc_init(docg3
, DOC_LAYOUT_OOB_PAGEINFO_SZ
);
1901 doc_reload_bbt(docg3
);
1909 return ERR_PTR(ret
);
1913 * doc_release_device - Release a docg3 floor
1916 static void doc_release_device(struct mtd_info
*mtd
)
1918 struct docg3
*docg3
= mtd
->priv
;
1920 mtd_device_unregister(mtd
);
1928 * docg3_resume - Awakens docg3 floor
1929 * @pdev: platfrom device
1931 * Returns 0 (always successfull)
1933 static int docg3_resume(struct platform_device
*pdev
)
1936 struct mtd_info
**docg3_floors
, *mtd
;
1937 struct docg3
*docg3
;
1939 docg3_floors
= platform_get_drvdata(pdev
);
1940 mtd
= docg3_floors
[0];
1943 doc_dbg("docg3_resume()\n");
1944 for (i
= 0; i
< 12; i
++)
1945 doc_readb(docg3
, DOC_IOSPACE_IPL
);
1950 * docg3_suspend - Put in low power mode the docg3 floor
1951 * @pdev: platform device
1952 * @state: power state
1954 * Shuts off most of docg3 circuitery to lower power consumption.
1956 * Returns 0 if suspend succeeded, -EIO if chip refused suspend
1958 static int docg3_suspend(struct platform_device
*pdev
, pm_message_t state
)
1961 struct mtd_info
**docg3_floors
, *mtd
;
1962 struct docg3
*docg3
;
1965 docg3_floors
= platform_get_drvdata(pdev
);
1966 for (floor
= 0; floor
< DOC_MAX_NBFLOORS
; floor
++) {
1967 mtd
= docg3_floors
[floor
];
1972 doc_writeb(docg3
, floor
, DOC_DEVICESELECT
);
1973 ctrl
= doc_register_readb(docg3
, DOC_FLASHCONTROL
);
1974 ctrl
&= ~DOC_CTRL_VIOLATION
& ~DOC_CTRL_CE
;
1975 doc_writeb(docg3
, ctrl
, DOC_FLASHCONTROL
);
1977 for (i
= 0; i
< 10; i
++) {
1978 usleep_range(3000, 4000);
1979 pwr_down
= doc_register_readb(docg3
, DOC_POWERMODE
);
1980 if (pwr_down
& DOC_POWERDOWN_READY
)
1983 if (pwr_down
& DOC_POWERDOWN_READY
) {
1984 doc_dbg("docg3_suspend(): floor %d powerdown ok\n",
1987 doc_err("docg3_suspend(): floor %d powerdown failed\n",
1993 mtd
= docg3_floors
[0];
1995 doc_set_asic_mode(docg3
, DOC_ASICMODE_POWERDOWN
);
2000 * doc_probe - Probe the IO space for a DiskOnChip G3 chip
2001 * @pdev: platform device
2003 * Probes for a G3 chip at the specified IO space in the platform data
2004 * ressources. The floor 0 must be available.
2006 * Returns 0 on success, -ENOMEM, -ENXIO on error
2008 static int __init
docg3_probe(struct platform_device
*pdev
)
2010 struct device
*dev
= &pdev
->dev
;
2011 struct mtd_info
*mtd
;
2012 struct resource
*ress
;
2014 int ret
, floor
, found
= 0;
2015 struct mtd_info
**docg3_floors
;
2018 ress
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
2020 dev_err(dev
, "No I/O memory resource defined\n");
2023 base
= ioremap(ress
->start
, DOC_IOSPACE_SIZE
);
2026 docg3_floors
= kzalloc(sizeof(*docg3_floors
) * DOC_MAX_NBFLOORS
,
2030 docg3_bch
= init_bch(DOC_ECC_BCH_M
, DOC_ECC_BCH_T
,
2031 DOC_ECC_BCH_PRIMPOLY
);
2035 for (floor
= 0; floor
< DOC_MAX_NBFLOORS
; floor
++) {
2036 mtd
= doc_probe_device(base
, floor
, dev
);
2047 docg3_floors
[floor
] = mtd
;
2048 ret
= mtd_device_parse_register(mtd
, part_probes
, NULL
, NULL
,
2055 ret
= doc_register_sysfs(pdev
, docg3_floors
);
2061 platform_set_drvdata(pdev
, docg3_floors
);
2062 doc_dbg_register(docg3_floors
[0]->priv
);
2067 dev_info(dev
, "No supported DiskOnChip found\n");
2069 free_bch(docg3_bch
);
2070 for (floor
= 0; floor
< DOC_MAX_NBFLOORS
; floor
++)
2071 if (docg3_floors
[floor
])
2072 doc_release_device(docg3_floors
[floor
]);
2074 kfree(docg3_floors
);
2082 * docg3_release - Release the driver
2083 * @pdev: the platform device
2087 static int __exit
docg3_release(struct platform_device
*pdev
)
2089 struct mtd_info
**docg3_floors
= platform_get_drvdata(pdev
);
2090 struct docg3
*docg3
= docg3_floors
[0]->priv
;
2091 void __iomem
*base
= docg3
->base
;
2094 doc_unregister_sysfs(pdev
, docg3_floors
);
2095 doc_dbg_unregister(docg3
);
2096 for (floor
= 0; floor
< DOC_MAX_NBFLOORS
; floor
++)
2097 if (docg3_floors
[floor
])
2098 doc_release_device(docg3_floors
[floor
]);
2100 kfree(docg3_floors
);
2101 free_bch(docg3_bch
);
2106 static struct platform_driver g3_driver
= {
2109 .owner
= THIS_MODULE
,
2111 .suspend
= docg3_suspend
,
2112 .resume
= docg3_resume
,
2113 .remove
= __exit_p(docg3_release
),
2116 static int __init
docg3_init(void)
2118 return platform_driver_probe(&g3_driver
, docg3_probe
);
2120 module_init(docg3_init
);
2123 static void __exit
docg3_exit(void)
2125 platform_driver_unregister(&g3_driver
);
2127 module_exit(docg3_exit
);
2129 MODULE_LICENSE("GPL");
2130 MODULE_AUTHOR("Robert Jarzmik <robert.jarzmik@free.fr>");
2131 MODULE_DESCRIPTION("MTD driver for DiskOnChip G3");