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