mtd: nand: Pass the CS line to ->setup_data_interface()
[karo-tx-linux.git] / drivers / mtd / nand / nand_base.c
1 /*
2  *  Overview:
3  *   This is the generic MTD driver for NAND flash devices. It should be
4  *   capable of working with almost all NAND chips currently available.
5  *
6  *      Additional technical information is available on
7  *      http://www.linux-mtd.infradead.org/doc/nand.html
8  *
9  *  Copyright (C) 2000 Steven J. Hill (sjhill@realitydiluted.com)
10  *                2002-2006 Thomas Gleixner (tglx@linutronix.de)
11  *
12  *  Credits:
13  *      David Woodhouse for adding multichip support
14  *
15  *      Aleph One Ltd. and Toby Churchill Ltd. for supporting the
16  *      rework for 2K page size chips
17  *
18  *  TODO:
19  *      Enable cached programming for 2k page size chips
20  *      Check, if mtd->ecctype should be set to MTD_ECC_HW
21  *      if we have HW ECC support.
22  *      BBT table is not serialized, has to be fixed
23  *
24  * This program is free software; you can redistribute it and/or modify
25  * it under the terms of the GNU General Public License version 2 as
26  * published by the Free Software Foundation.
27  *
28  */
29
30 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
31
32 #include <linux/module.h>
33 #include <linux/delay.h>
34 #include <linux/errno.h>
35 #include <linux/err.h>
36 #include <linux/sched.h>
37 #include <linux/slab.h>
38 #include <linux/mm.h>
39 #include <linux/nmi.h>
40 #include <linux/types.h>
41 #include <linux/mtd/mtd.h>
42 #include <linux/mtd/nand.h>
43 #include <linux/mtd/nand_ecc.h>
44 #include <linux/mtd/nand_bch.h>
45 #include <linux/interrupt.h>
46 #include <linux/bitops.h>
47 #include <linux/io.h>
48 #include <linux/mtd/partitions.h>
49 #include <linux/of.h>
50
51 static int nand_get_device(struct mtd_info *mtd, int new_state);
52
53 static int nand_do_write_oob(struct mtd_info *mtd, loff_t to,
54                              struct mtd_oob_ops *ops);
55
56 /* Define default oob placement schemes for large and small page devices */
57 static int nand_ooblayout_ecc_sp(struct mtd_info *mtd, int section,
58                                  struct mtd_oob_region *oobregion)
59 {
60         struct nand_chip *chip = mtd_to_nand(mtd);
61         struct nand_ecc_ctrl *ecc = &chip->ecc;
62
63         if (section > 1)
64                 return -ERANGE;
65
66         if (!section) {
67                 oobregion->offset = 0;
68                 oobregion->length = 4;
69         } else {
70                 oobregion->offset = 6;
71                 oobregion->length = ecc->total - 4;
72         }
73
74         return 0;
75 }
76
77 static int nand_ooblayout_free_sp(struct mtd_info *mtd, int section,
78                                   struct mtd_oob_region *oobregion)
79 {
80         if (section > 1)
81                 return -ERANGE;
82
83         if (mtd->oobsize == 16) {
84                 if (section)
85                         return -ERANGE;
86
87                 oobregion->length = 8;
88                 oobregion->offset = 8;
89         } else {
90                 oobregion->length = 2;
91                 if (!section)
92                         oobregion->offset = 3;
93                 else
94                         oobregion->offset = 6;
95         }
96
97         return 0;
98 }
99
100 const struct mtd_ooblayout_ops nand_ooblayout_sp_ops = {
101         .ecc = nand_ooblayout_ecc_sp,
102         .free = nand_ooblayout_free_sp,
103 };
104 EXPORT_SYMBOL_GPL(nand_ooblayout_sp_ops);
105
106 static int nand_ooblayout_ecc_lp(struct mtd_info *mtd, int section,
107                                  struct mtd_oob_region *oobregion)
108 {
109         struct nand_chip *chip = mtd_to_nand(mtd);
110         struct nand_ecc_ctrl *ecc = &chip->ecc;
111
112         if (section)
113                 return -ERANGE;
114
115         oobregion->length = ecc->total;
116         oobregion->offset = mtd->oobsize - oobregion->length;
117
118         return 0;
119 }
120
121 static int nand_ooblayout_free_lp(struct mtd_info *mtd, int section,
122                                   struct mtd_oob_region *oobregion)
123 {
124         struct nand_chip *chip = mtd_to_nand(mtd);
125         struct nand_ecc_ctrl *ecc = &chip->ecc;
126
127         if (section)
128                 return -ERANGE;
129
130         oobregion->length = mtd->oobsize - ecc->total - 2;
131         oobregion->offset = 2;
132
133         return 0;
134 }
135
136 const struct mtd_ooblayout_ops nand_ooblayout_lp_ops = {
137         .ecc = nand_ooblayout_ecc_lp,
138         .free = nand_ooblayout_free_lp,
139 };
140 EXPORT_SYMBOL_GPL(nand_ooblayout_lp_ops);
141
142 /*
143  * Support the old "large page" layout used for 1-bit Hamming ECC where ECC
144  * are placed at a fixed offset.
145  */
146 static int nand_ooblayout_ecc_lp_hamming(struct mtd_info *mtd, int section,
147                                          struct mtd_oob_region *oobregion)
148 {
149         struct nand_chip *chip = mtd_to_nand(mtd);
150         struct nand_ecc_ctrl *ecc = &chip->ecc;
151
152         if (section)
153                 return -ERANGE;
154
155         switch (mtd->oobsize) {
156         case 64:
157                 oobregion->offset = 40;
158                 break;
159         case 128:
160                 oobregion->offset = 80;
161                 break;
162         default:
163                 return -EINVAL;
164         }
165
166         oobregion->length = ecc->total;
167         if (oobregion->offset + oobregion->length > mtd->oobsize)
168                 return -ERANGE;
169
170         return 0;
171 }
172
173 static int nand_ooblayout_free_lp_hamming(struct mtd_info *mtd, int section,
174                                           struct mtd_oob_region *oobregion)
175 {
176         struct nand_chip *chip = mtd_to_nand(mtd);
177         struct nand_ecc_ctrl *ecc = &chip->ecc;
178         int ecc_offset = 0;
179
180         if (section < 0 || section > 1)
181                 return -ERANGE;
182
183         switch (mtd->oobsize) {
184         case 64:
185                 ecc_offset = 40;
186                 break;
187         case 128:
188                 ecc_offset = 80;
189                 break;
190         default:
191                 return -EINVAL;
192         }
193
194         if (section == 0) {
195                 oobregion->offset = 2;
196                 oobregion->length = ecc_offset - 2;
197         } else {
198                 oobregion->offset = ecc_offset + ecc->total;
199                 oobregion->length = mtd->oobsize - oobregion->offset;
200         }
201
202         return 0;
203 }
204
205 const struct mtd_ooblayout_ops nand_ooblayout_lp_hamming_ops = {
206         .ecc = nand_ooblayout_ecc_lp_hamming,
207         .free = nand_ooblayout_free_lp_hamming,
208 };
209
210 static int check_offs_len(struct mtd_info *mtd,
211                                         loff_t ofs, uint64_t len)
212 {
213         struct nand_chip *chip = mtd_to_nand(mtd);
214         int ret = 0;
215
216         /* Start address must align on block boundary */
217         if (ofs & ((1ULL << chip->phys_erase_shift) - 1)) {
218                 pr_debug("%s: unaligned address\n", __func__);
219                 ret = -EINVAL;
220         }
221
222         /* Length must align on block boundary */
223         if (len & ((1ULL << chip->phys_erase_shift) - 1)) {
224                 pr_debug("%s: length not block aligned\n", __func__);
225                 ret = -EINVAL;
226         }
227
228         return ret;
229 }
230
231 /**
232  * nand_release_device - [GENERIC] release chip
233  * @mtd: MTD device structure
234  *
235  * Release chip lock and wake up anyone waiting on the device.
236  */
237 static void nand_release_device(struct mtd_info *mtd)
238 {
239         struct nand_chip *chip = mtd_to_nand(mtd);
240
241         /* Release the controller and the chip */
242         spin_lock(&chip->controller->lock);
243         chip->controller->active = NULL;
244         chip->state = FL_READY;
245         wake_up(&chip->controller->wq);
246         spin_unlock(&chip->controller->lock);
247 }
248
249 /**
250  * nand_read_byte - [DEFAULT] read one byte from the chip
251  * @mtd: MTD device structure
252  *
253  * Default read function for 8bit buswidth
254  */
255 static uint8_t nand_read_byte(struct mtd_info *mtd)
256 {
257         struct nand_chip *chip = mtd_to_nand(mtd);
258         return readb(chip->IO_ADDR_R);
259 }
260
261 /**
262  * nand_read_byte16 - [DEFAULT] read one byte endianness aware from the chip
263  * @mtd: MTD device structure
264  *
265  * Default read function for 16bit buswidth with endianness conversion.
266  *
267  */
268 static uint8_t nand_read_byte16(struct mtd_info *mtd)
269 {
270         struct nand_chip *chip = mtd_to_nand(mtd);
271         return (uint8_t) cpu_to_le16(readw(chip->IO_ADDR_R));
272 }
273
274 /**
275  * nand_read_word - [DEFAULT] read one word from the chip
276  * @mtd: MTD device structure
277  *
278  * Default read function for 16bit buswidth without endianness conversion.
279  */
280 static u16 nand_read_word(struct mtd_info *mtd)
281 {
282         struct nand_chip *chip = mtd_to_nand(mtd);
283         return readw(chip->IO_ADDR_R);
284 }
285
286 /**
287  * nand_select_chip - [DEFAULT] control CE line
288  * @mtd: MTD device structure
289  * @chipnr: chipnumber to select, -1 for deselect
290  *
291  * Default select function for 1 chip devices.
292  */
293 static void nand_select_chip(struct mtd_info *mtd, int chipnr)
294 {
295         struct nand_chip *chip = mtd_to_nand(mtd);
296
297         switch (chipnr) {
298         case -1:
299                 chip->cmd_ctrl(mtd, NAND_CMD_NONE, 0 | NAND_CTRL_CHANGE);
300                 break;
301         case 0:
302                 break;
303
304         default:
305                 BUG();
306         }
307 }
308
309 /**
310  * nand_write_byte - [DEFAULT] write single byte to chip
311  * @mtd: MTD device structure
312  * @byte: value to write
313  *
314  * Default function to write a byte to I/O[7:0]
315  */
316 static void nand_write_byte(struct mtd_info *mtd, uint8_t byte)
317 {
318         struct nand_chip *chip = mtd_to_nand(mtd);
319
320         chip->write_buf(mtd, &byte, 1);
321 }
322
323 /**
324  * nand_write_byte16 - [DEFAULT] write single byte to a chip with width 16
325  * @mtd: MTD device structure
326  * @byte: value to write
327  *
328  * Default function to write a byte to I/O[7:0] on a 16-bit wide chip.
329  */
330 static void nand_write_byte16(struct mtd_info *mtd, uint8_t byte)
331 {
332         struct nand_chip *chip = mtd_to_nand(mtd);
333         uint16_t word = byte;
334
335         /*
336          * It's not entirely clear what should happen to I/O[15:8] when writing
337          * a byte. The ONFi spec (Revision 3.1; 2012-09-19, Section 2.16) reads:
338          *
339          *    When the host supports a 16-bit bus width, only data is
340          *    transferred at the 16-bit width. All address and command line
341          *    transfers shall use only the lower 8-bits of the data bus. During
342          *    command transfers, the host may place any value on the upper
343          *    8-bits of the data bus. During address transfers, the host shall
344          *    set the upper 8-bits of the data bus to 00h.
345          *
346          * One user of the write_byte callback is nand_onfi_set_features. The
347          * four parameters are specified to be written to I/O[7:0], but this is
348          * neither an address nor a command transfer. Let's assume a 0 on the
349          * upper I/O lines is OK.
350          */
351         chip->write_buf(mtd, (uint8_t *)&word, 2);
352 }
353
354 /**
355  * nand_write_buf - [DEFAULT] write buffer to chip
356  * @mtd: MTD device structure
357  * @buf: data buffer
358  * @len: number of bytes to write
359  *
360  * Default write function for 8bit buswidth.
361  */
362 static void nand_write_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
363 {
364         struct nand_chip *chip = mtd_to_nand(mtd);
365
366         iowrite8_rep(chip->IO_ADDR_W, buf, len);
367 }
368
369 /**
370  * nand_read_buf - [DEFAULT] read chip data into buffer
371  * @mtd: MTD device structure
372  * @buf: buffer to store date
373  * @len: number of bytes to read
374  *
375  * Default read function for 8bit buswidth.
376  */
377 static void nand_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
378 {
379         struct nand_chip *chip = mtd_to_nand(mtd);
380
381         ioread8_rep(chip->IO_ADDR_R, buf, len);
382 }
383
384 /**
385  * nand_write_buf16 - [DEFAULT] write buffer to chip
386  * @mtd: MTD device structure
387  * @buf: data buffer
388  * @len: number of bytes to write
389  *
390  * Default write function for 16bit buswidth.
391  */
392 static void nand_write_buf16(struct mtd_info *mtd, const uint8_t *buf, int len)
393 {
394         struct nand_chip *chip = mtd_to_nand(mtd);
395         u16 *p = (u16 *) buf;
396
397         iowrite16_rep(chip->IO_ADDR_W, p, len >> 1);
398 }
399
400 /**
401  * nand_read_buf16 - [DEFAULT] read chip data into buffer
402  * @mtd: MTD device structure
403  * @buf: buffer to store date
404  * @len: number of bytes to read
405  *
406  * Default read function for 16bit buswidth.
407  */
408 static void nand_read_buf16(struct mtd_info *mtd, uint8_t *buf, int len)
409 {
410         struct nand_chip *chip = mtd_to_nand(mtd);
411         u16 *p = (u16 *) buf;
412
413         ioread16_rep(chip->IO_ADDR_R, p, len >> 1);
414 }
415
416 /**
417  * nand_block_bad - [DEFAULT] Read bad block marker from the chip
418  * @mtd: MTD device structure
419  * @ofs: offset from device start
420  *
421  * Check, if the block is bad.
422  */
423 static int nand_block_bad(struct mtd_info *mtd, loff_t ofs)
424 {
425         int page, page_end, res;
426         struct nand_chip *chip = mtd_to_nand(mtd);
427         u8 bad;
428
429         if (chip->bbt_options & NAND_BBT_SCANLASTPAGE)
430                 ofs += mtd->erasesize - mtd->writesize;
431
432         page = (int)(ofs >> chip->page_shift) & chip->pagemask;
433         page_end = page + (chip->bbt_options & NAND_BBT_SCAN2NDPAGE ? 2 : 1);
434
435         for (; page < page_end; page++) {
436                 res = chip->ecc.read_oob(mtd, chip, page);
437                 if (res)
438                         return res;
439
440                 bad = chip->oob_poi[chip->badblockpos];
441
442                 if (likely(chip->badblockbits == 8))
443                         res = bad != 0xFF;
444                 else
445                         res = hweight8(bad) < chip->badblockbits;
446                 if (res)
447                         return res;
448         }
449
450         return 0;
451 }
452
453 /**
454  * nand_default_block_markbad - [DEFAULT] mark a block bad via bad block marker
455  * @mtd: MTD device structure
456  * @ofs: offset from device start
457  *
458  * This is the default implementation, which can be overridden by a hardware
459  * specific driver. It provides the details for writing a bad block marker to a
460  * block.
461  */
462 static int nand_default_block_markbad(struct mtd_info *mtd, loff_t ofs)
463 {
464         struct nand_chip *chip = mtd_to_nand(mtd);
465         struct mtd_oob_ops ops;
466         uint8_t buf[2] = { 0, 0 };
467         int ret = 0, res, i = 0;
468
469         memset(&ops, 0, sizeof(ops));
470         ops.oobbuf = buf;
471         ops.ooboffs = chip->badblockpos;
472         if (chip->options & NAND_BUSWIDTH_16) {
473                 ops.ooboffs &= ~0x01;
474                 ops.len = ops.ooblen = 2;
475         } else {
476                 ops.len = ops.ooblen = 1;
477         }
478         ops.mode = MTD_OPS_PLACE_OOB;
479
480         /* Write to first/last page(s) if necessary */
481         if (chip->bbt_options & NAND_BBT_SCANLASTPAGE)
482                 ofs += mtd->erasesize - mtd->writesize;
483         do {
484                 res = nand_do_write_oob(mtd, ofs, &ops);
485                 if (!ret)
486                         ret = res;
487
488                 i++;
489                 ofs += mtd->writesize;
490         } while ((chip->bbt_options & NAND_BBT_SCAN2NDPAGE) && i < 2);
491
492         return ret;
493 }
494
495 /**
496  * nand_block_markbad_lowlevel - mark a block bad
497  * @mtd: MTD device structure
498  * @ofs: offset from device start
499  *
500  * This function performs the generic NAND bad block marking steps (i.e., bad
501  * block table(s) and/or marker(s)). We only allow the hardware driver to
502  * specify how to write bad block markers to OOB (chip->block_markbad).
503  *
504  * We try operations in the following order:
505  *  (1) erase the affected block, to allow OOB marker to be written cleanly
506  *  (2) write bad block marker to OOB area of affected block (unless flag
507  *      NAND_BBT_NO_OOB_BBM is present)
508  *  (3) update the BBT
509  * Note that we retain the first error encountered in (2) or (3), finish the
510  * procedures, and dump the error in the end.
511 */
512 static int nand_block_markbad_lowlevel(struct mtd_info *mtd, loff_t ofs)
513 {
514         struct nand_chip *chip = mtd_to_nand(mtd);
515         int res, ret = 0;
516
517         if (!(chip->bbt_options & NAND_BBT_NO_OOB_BBM)) {
518                 struct erase_info einfo;
519
520                 /* Attempt erase before marking OOB */
521                 memset(&einfo, 0, sizeof(einfo));
522                 einfo.mtd = mtd;
523                 einfo.addr = ofs;
524                 einfo.len = 1ULL << chip->phys_erase_shift;
525                 nand_erase_nand(mtd, &einfo, 0);
526
527                 /* Write bad block marker to OOB */
528                 nand_get_device(mtd, FL_WRITING);
529                 ret = chip->block_markbad(mtd, ofs);
530                 nand_release_device(mtd);
531         }
532
533         /* Mark block bad in BBT */
534         if (chip->bbt) {
535                 res = nand_markbad_bbt(mtd, ofs);
536                 if (!ret)
537                         ret = res;
538         }
539
540         if (!ret)
541                 mtd->ecc_stats.badblocks++;
542
543         return ret;
544 }
545
546 /**
547  * nand_check_wp - [GENERIC] check if the chip is write protected
548  * @mtd: MTD device structure
549  *
550  * Check, if the device is write protected. The function expects, that the
551  * device is already selected.
552  */
553 static int nand_check_wp(struct mtd_info *mtd)
554 {
555         struct nand_chip *chip = mtd_to_nand(mtd);
556
557         /* Broken xD cards report WP despite being writable */
558         if (chip->options & NAND_BROKEN_XD)
559                 return 0;
560
561         /* Check the WP bit */
562         chip->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
563         return (chip->read_byte(mtd) & NAND_STATUS_WP) ? 0 : 1;
564 }
565
566 /**
567  * nand_block_isreserved - [GENERIC] Check if a block is marked reserved.
568  * @mtd: MTD device structure
569  * @ofs: offset from device start
570  *
571  * Check if the block is marked as reserved.
572  */
573 static int nand_block_isreserved(struct mtd_info *mtd, loff_t ofs)
574 {
575         struct nand_chip *chip = mtd_to_nand(mtd);
576
577         if (!chip->bbt)
578                 return 0;
579         /* Return info from the table */
580         return nand_isreserved_bbt(mtd, ofs);
581 }
582
583 /**
584  * nand_block_checkbad - [GENERIC] Check if a block is marked bad
585  * @mtd: MTD device structure
586  * @ofs: offset from device start
587  * @allowbbt: 1, if its allowed to access the bbt area
588  *
589  * Check, if the block is bad. Either by reading the bad block table or
590  * calling of the scan function.
591  */
592 static int nand_block_checkbad(struct mtd_info *mtd, loff_t ofs, int allowbbt)
593 {
594         struct nand_chip *chip = mtd_to_nand(mtd);
595
596         if (!chip->bbt)
597                 return chip->block_bad(mtd, ofs);
598
599         /* Return info from the table */
600         return nand_isbad_bbt(mtd, ofs, allowbbt);
601 }
602
603 /**
604  * panic_nand_wait_ready - [GENERIC] Wait for the ready pin after commands.
605  * @mtd: MTD device structure
606  * @timeo: Timeout
607  *
608  * Helper function for nand_wait_ready used when needing to wait in interrupt
609  * context.
610  */
611 static void panic_nand_wait_ready(struct mtd_info *mtd, unsigned long timeo)
612 {
613         struct nand_chip *chip = mtd_to_nand(mtd);
614         int i;
615
616         /* Wait for the device to get ready */
617         for (i = 0; i < timeo; i++) {
618                 if (chip->dev_ready(mtd))
619                         break;
620                 touch_softlockup_watchdog();
621                 mdelay(1);
622         }
623 }
624
625 /**
626  * nand_wait_ready - [GENERIC] Wait for the ready pin after commands.
627  * @mtd: MTD device structure
628  *
629  * Wait for the ready pin after a command, and warn if a timeout occurs.
630  */
631 void nand_wait_ready(struct mtd_info *mtd)
632 {
633         struct nand_chip *chip = mtd_to_nand(mtd);
634         unsigned long timeo = 400;
635
636         if (in_interrupt() || oops_in_progress)
637                 return panic_nand_wait_ready(mtd, timeo);
638
639         /* Wait until command is processed or timeout occurs */
640         timeo = jiffies + msecs_to_jiffies(timeo);
641         do {
642                 if (chip->dev_ready(mtd))
643                         return;
644                 cond_resched();
645         } while (time_before(jiffies, timeo));
646
647         if (!chip->dev_ready(mtd))
648                 pr_warn_ratelimited("timeout while waiting for chip to become ready\n");
649 }
650 EXPORT_SYMBOL_GPL(nand_wait_ready);
651
652 /**
653  * nand_wait_status_ready - [GENERIC] Wait for the ready status after commands.
654  * @mtd: MTD device structure
655  * @timeo: Timeout in ms
656  *
657  * Wait for status ready (i.e. command done) or timeout.
658  */
659 static void nand_wait_status_ready(struct mtd_info *mtd, unsigned long timeo)
660 {
661         register struct nand_chip *chip = mtd_to_nand(mtd);
662
663         timeo = jiffies + msecs_to_jiffies(timeo);
664         do {
665                 if ((chip->read_byte(mtd) & NAND_STATUS_READY))
666                         break;
667                 touch_softlockup_watchdog();
668         } while (time_before(jiffies, timeo));
669 };
670
671 /**
672  * nand_command - [DEFAULT] Send command to NAND device
673  * @mtd: MTD device structure
674  * @command: the command to be sent
675  * @column: the column address for this command, -1 if none
676  * @page_addr: the page address for this command, -1 if none
677  *
678  * Send command to NAND device. This function is used for small page devices
679  * (512 Bytes per page).
680  */
681 static void nand_command(struct mtd_info *mtd, unsigned int command,
682                          int column, int page_addr)
683 {
684         register struct nand_chip *chip = mtd_to_nand(mtd);
685         int ctrl = NAND_CTRL_CLE | NAND_CTRL_CHANGE;
686
687         /* Write out the command to the device */
688         if (command == NAND_CMD_SEQIN) {
689                 int readcmd;
690
691                 if (column >= mtd->writesize) {
692                         /* OOB area */
693                         column -= mtd->writesize;
694                         readcmd = NAND_CMD_READOOB;
695                 } else if (column < 256) {
696                         /* First 256 bytes --> READ0 */
697                         readcmd = NAND_CMD_READ0;
698                 } else {
699                         column -= 256;
700                         readcmd = NAND_CMD_READ1;
701                 }
702                 chip->cmd_ctrl(mtd, readcmd, ctrl);
703                 ctrl &= ~NAND_CTRL_CHANGE;
704         }
705         chip->cmd_ctrl(mtd, command, ctrl);
706
707         /* Address cycle, when necessary */
708         ctrl = NAND_CTRL_ALE | NAND_CTRL_CHANGE;
709         /* Serially input address */
710         if (column != -1) {
711                 /* Adjust columns for 16 bit buswidth */
712                 if (chip->options & NAND_BUSWIDTH_16 &&
713                                 !nand_opcode_8bits(command))
714                         column >>= 1;
715                 chip->cmd_ctrl(mtd, column, ctrl);
716                 ctrl &= ~NAND_CTRL_CHANGE;
717         }
718         if (page_addr != -1) {
719                 chip->cmd_ctrl(mtd, page_addr, ctrl);
720                 ctrl &= ~NAND_CTRL_CHANGE;
721                 chip->cmd_ctrl(mtd, page_addr >> 8, ctrl);
722                 /* One more address cycle for devices > 32MiB */
723                 if (chip->chipsize > (32 << 20))
724                         chip->cmd_ctrl(mtd, page_addr >> 16, ctrl);
725         }
726         chip->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE);
727
728         /*
729          * Program and erase have their own busy handlers status and sequential
730          * in needs no delay
731          */
732         switch (command) {
733
734         case NAND_CMD_PAGEPROG:
735         case NAND_CMD_ERASE1:
736         case NAND_CMD_ERASE2:
737         case NAND_CMD_SEQIN:
738         case NAND_CMD_STATUS:
739         case NAND_CMD_READID:
740         case NAND_CMD_SET_FEATURES:
741                 return;
742
743         case NAND_CMD_RESET:
744                 if (chip->dev_ready)
745                         break;
746                 udelay(chip->chip_delay);
747                 chip->cmd_ctrl(mtd, NAND_CMD_STATUS,
748                                NAND_CTRL_CLE | NAND_CTRL_CHANGE);
749                 chip->cmd_ctrl(mtd,
750                                NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE);
751                 /* EZ-NAND can take upto 250ms as per ONFi v4.0 */
752                 nand_wait_status_ready(mtd, 250);
753                 return;
754
755                 /* This applies to read commands */
756         default:
757                 /*
758                  * If we don't have access to the busy pin, we apply the given
759                  * command delay
760                  */
761                 if (!chip->dev_ready) {
762                         udelay(chip->chip_delay);
763                         return;
764                 }
765         }
766         /*
767          * Apply this short delay always to ensure that we do wait tWB in
768          * any case on any machine.
769          */
770         ndelay(100);
771
772         nand_wait_ready(mtd);
773 }
774
775 static void nand_ccs_delay(struct nand_chip *chip)
776 {
777         /*
778          * The controller already takes care of waiting for tCCS when the RNDIN
779          * or RNDOUT command is sent, return directly.
780          */
781         if (!(chip->options & NAND_WAIT_TCCS))
782                 return;
783
784         /*
785          * Wait tCCS_min if it is correctly defined, otherwise wait 500ns
786          * (which should be safe for all NANDs).
787          */
788         if (chip->data_interface && chip->data_interface->timings.sdr.tCCS_min)
789                 ndelay(chip->data_interface->timings.sdr.tCCS_min / 1000);
790         else
791                 ndelay(500);
792 }
793
794 /**
795  * nand_command_lp - [DEFAULT] Send command to NAND large page device
796  * @mtd: MTD device structure
797  * @command: the command to be sent
798  * @column: the column address for this command, -1 if none
799  * @page_addr: the page address for this command, -1 if none
800  *
801  * Send command to NAND device. This is the version for the new large page
802  * devices. We don't have the separate regions as we have in the small page
803  * devices. We must emulate NAND_CMD_READOOB to keep the code compatible.
804  */
805 static void nand_command_lp(struct mtd_info *mtd, unsigned int command,
806                             int column, int page_addr)
807 {
808         register struct nand_chip *chip = mtd_to_nand(mtd);
809
810         /* Emulate NAND_CMD_READOOB */
811         if (command == NAND_CMD_READOOB) {
812                 column += mtd->writesize;
813                 command = NAND_CMD_READ0;
814         }
815
816         /* Command latch cycle */
817         chip->cmd_ctrl(mtd, command, NAND_NCE | NAND_CLE | NAND_CTRL_CHANGE);
818
819         if (column != -1 || page_addr != -1) {
820                 int ctrl = NAND_CTRL_CHANGE | NAND_NCE | NAND_ALE;
821
822                 /* Serially input address */
823                 if (column != -1) {
824                         /* Adjust columns for 16 bit buswidth */
825                         if (chip->options & NAND_BUSWIDTH_16 &&
826                                         !nand_opcode_8bits(command))
827                                 column >>= 1;
828                         chip->cmd_ctrl(mtd, column, ctrl);
829                         ctrl &= ~NAND_CTRL_CHANGE;
830
831                         /* Only output a single addr cycle for 8bits opcodes. */
832                         if (!nand_opcode_8bits(command))
833                                 chip->cmd_ctrl(mtd, column >> 8, ctrl);
834                 }
835                 if (page_addr != -1) {
836                         chip->cmd_ctrl(mtd, page_addr, ctrl);
837                         chip->cmd_ctrl(mtd, page_addr >> 8,
838                                        NAND_NCE | NAND_ALE);
839                         /* One more address cycle for devices > 128MiB */
840                         if (chip->chipsize > (128 << 20))
841                                 chip->cmd_ctrl(mtd, page_addr >> 16,
842                                                NAND_NCE | NAND_ALE);
843                 }
844         }
845         chip->cmd_ctrl(mtd, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE);
846
847         /*
848          * Program and erase have their own busy handlers status, sequential
849          * in and status need no delay.
850          */
851         switch (command) {
852
853         case NAND_CMD_CACHEDPROG:
854         case NAND_CMD_PAGEPROG:
855         case NAND_CMD_ERASE1:
856         case NAND_CMD_ERASE2:
857         case NAND_CMD_SEQIN:
858         case NAND_CMD_STATUS:
859         case NAND_CMD_READID:
860         case NAND_CMD_SET_FEATURES:
861                 return;
862
863         case NAND_CMD_RNDIN:
864                 nand_ccs_delay(chip);
865                 return;
866
867         case NAND_CMD_RESET:
868                 if (chip->dev_ready)
869                         break;
870                 udelay(chip->chip_delay);
871                 chip->cmd_ctrl(mtd, NAND_CMD_STATUS,
872                                NAND_NCE | NAND_CLE | NAND_CTRL_CHANGE);
873                 chip->cmd_ctrl(mtd, NAND_CMD_NONE,
874                                NAND_NCE | NAND_CTRL_CHANGE);
875                 /* EZ-NAND can take upto 250ms as per ONFi v4.0 */
876                 nand_wait_status_ready(mtd, 250);
877                 return;
878
879         case NAND_CMD_RNDOUT:
880                 /* No ready / busy check necessary */
881                 chip->cmd_ctrl(mtd, NAND_CMD_RNDOUTSTART,
882                                NAND_NCE | NAND_CLE | NAND_CTRL_CHANGE);
883                 chip->cmd_ctrl(mtd, NAND_CMD_NONE,
884                                NAND_NCE | NAND_CTRL_CHANGE);
885
886                 nand_ccs_delay(chip);
887                 return;
888
889         case NAND_CMD_READ0:
890                 chip->cmd_ctrl(mtd, NAND_CMD_READSTART,
891                                NAND_NCE | NAND_CLE | NAND_CTRL_CHANGE);
892                 chip->cmd_ctrl(mtd, NAND_CMD_NONE,
893                                NAND_NCE | NAND_CTRL_CHANGE);
894
895                 /* This applies to read commands */
896         default:
897                 /*
898                  * If we don't have access to the busy pin, we apply the given
899                  * command delay.
900                  */
901                 if (!chip->dev_ready) {
902                         udelay(chip->chip_delay);
903                         return;
904                 }
905         }
906
907         /*
908          * Apply this short delay always to ensure that we do wait tWB in
909          * any case on any machine.
910          */
911         ndelay(100);
912
913         nand_wait_ready(mtd);
914 }
915
916 /**
917  * panic_nand_get_device - [GENERIC] Get chip for selected access
918  * @chip: the nand chip descriptor
919  * @mtd: MTD device structure
920  * @new_state: the state which is requested
921  *
922  * Used when in panic, no locks are taken.
923  */
924 static void panic_nand_get_device(struct nand_chip *chip,
925                       struct mtd_info *mtd, int new_state)
926 {
927         /* Hardware controller shared among independent devices */
928         chip->controller->active = chip;
929         chip->state = new_state;
930 }
931
932 /**
933  * nand_get_device - [GENERIC] Get chip for selected access
934  * @mtd: MTD device structure
935  * @new_state: the state which is requested
936  *
937  * Get the device and lock it for exclusive access
938  */
939 static int
940 nand_get_device(struct mtd_info *mtd, int new_state)
941 {
942         struct nand_chip *chip = mtd_to_nand(mtd);
943         spinlock_t *lock = &chip->controller->lock;
944         wait_queue_head_t *wq = &chip->controller->wq;
945         DECLARE_WAITQUEUE(wait, current);
946 retry:
947         spin_lock(lock);
948
949         /* Hardware controller shared among independent devices */
950         if (!chip->controller->active)
951                 chip->controller->active = chip;
952
953         if (chip->controller->active == chip && chip->state == FL_READY) {
954                 chip->state = new_state;
955                 spin_unlock(lock);
956                 return 0;
957         }
958         if (new_state == FL_PM_SUSPENDED) {
959                 if (chip->controller->active->state == FL_PM_SUSPENDED) {
960                         chip->state = FL_PM_SUSPENDED;
961                         spin_unlock(lock);
962                         return 0;
963                 }
964         }
965         set_current_state(TASK_UNINTERRUPTIBLE);
966         add_wait_queue(wq, &wait);
967         spin_unlock(lock);
968         schedule();
969         remove_wait_queue(wq, &wait);
970         goto retry;
971 }
972
973 /**
974  * panic_nand_wait - [GENERIC] wait until the command is done
975  * @mtd: MTD device structure
976  * @chip: NAND chip structure
977  * @timeo: timeout
978  *
979  * Wait for command done. This is a helper function for nand_wait used when
980  * we are in interrupt context. May happen when in panic and trying to write
981  * an oops through mtdoops.
982  */
983 static void panic_nand_wait(struct mtd_info *mtd, struct nand_chip *chip,
984                             unsigned long timeo)
985 {
986         int i;
987         for (i = 0; i < timeo; i++) {
988                 if (chip->dev_ready) {
989                         if (chip->dev_ready(mtd))
990                                 break;
991                 } else {
992                         if (chip->read_byte(mtd) & NAND_STATUS_READY)
993                                 break;
994                 }
995                 mdelay(1);
996         }
997 }
998
999 /**
1000  * nand_wait - [DEFAULT] wait until the command is done
1001  * @mtd: MTD device structure
1002  * @chip: NAND chip structure
1003  *
1004  * Wait for command done. This applies to erase and program only.
1005  */
1006 static int nand_wait(struct mtd_info *mtd, struct nand_chip *chip)
1007 {
1008
1009         int status;
1010         unsigned long timeo = 400;
1011
1012         /*
1013          * Apply this short delay always to ensure that we do wait tWB in any
1014          * case on any machine.
1015          */
1016         ndelay(100);
1017
1018         chip->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
1019
1020         if (in_interrupt() || oops_in_progress)
1021                 panic_nand_wait(mtd, chip, timeo);
1022         else {
1023                 timeo = jiffies + msecs_to_jiffies(timeo);
1024                 do {
1025                         if (chip->dev_ready) {
1026                                 if (chip->dev_ready(mtd))
1027                                         break;
1028                         } else {
1029                                 if (chip->read_byte(mtd) & NAND_STATUS_READY)
1030                                         break;
1031                         }
1032                         cond_resched();
1033                 } while (time_before(jiffies, timeo));
1034         }
1035
1036         status = (int)chip->read_byte(mtd);
1037         /* This can happen if in case of timeout or buggy dev_ready */
1038         WARN_ON(!(status & NAND_STATUS_READY));
1039         return status;
1040 }
1041
1042 /**
1043  * nand_reset_data_interface - Reset data interface and timings
1044  * @chip: The NAND chip
1045  * @chipnr: Internal die id
1046  *
1047  * Reset the Data interface and timings to ONFI mode 0.
1048  *
1049  * Returns 0 for success or negative error code otherwise.
1050  */
1051 static int nand_reset_data_interface(struct nand_chip *chip, int chipnr)
1052 {
1053         struct mtd_info *mtd = nand_to_mtd(chip);
1054         const struct nand_data_interface *conf;
1055         int ret;
1056
1057         if (!chip->setup_data_interface)
1058                 return 0;
1059
1060         /*
1061          * The ONFI specification says:
1062          * "
1063          * To transition from NV-DDR or NV-DDR2 to the SDR data
1064          * interface, the host shall use the Reset (FFh) command
1065          * using SDR timing mode 0. A device in any timing mode is
1066          * required to recognize Reset (FFh) command issued in SDR
1067          * timing mode 0.
1068          * "
1069          *
1070          * Configure the data interface in SDR mode and set the
1071          * timings to timing mode 0.
1072          */
1073
1074         conf = nand_get_default_data_interface();
1075         ret = chip->setup_data_interface(mtd, chipnr, conf);
1076         if (ret)
1077                 pr_err("Failed to configure data interface to SDR timing mode 0\n");
1078
1079         return ret;
1080 }
1081
1082 /**
1083  * nand_setup_data_interface - Setup the best data interface and timings
1084  * @chip: The NAND chip
1085  * @chipnr: Internal die id
1086  *
1087  * Find and configure the best data interface and NAND timings supported by
1088  * the chip and the driver.
1089  * First tries to retrieve supported timing modes from ONFI information,
1090  * and if the NAND chip does not support ONFI, relies on the
1091  * ->onfi_timing_mode_default specified in the nand_ids table.
1092  *
1093  * Returns 0 for success or negative error code otherwise.
1094  */
1095 static int nand_setup_data_interface(struct nand_chip *chip, int chipnr)
1096 {
1097         struct mtd_info *mtd = nand_to_mtd(chip);
1098         int ret;
1099
1100         if (!chip->setup_data_interface || !chip->data_interface)
1101                 return 0;
1102
1103         /*
1104          * Ensure the timing mode has been changed on the chip side
1105          * before changing timings on the controller side.
1106          */
1107         if (chip->onfi_version) {
1108                 u8 tmode_param[ONFI_SUBFEATURE_PARAM_LEN] = {
1109                         chip->onfi_timing_mode_default,
1110                 };
1111
1112                 ret = chip->onfi_set_features(mtd, chip,
1113                                 ONFI_FEATURE_ADDR_TIMING_MODE,
1114                                 tmode_param);
1115                 if (ret)
1116                         goto err;
1117         }
1118
1119         ret = chip->setup_data_interface(mtd, chipnr, chip->data_interface);
1120 err:
1121         return ret;
1122 }
1123
1124 /**
1125  * nand_init_data_interface - find the best data interface and timings
1126  * @chip: The NAND chip
1127  *
1128  * Find the best data interface and NAND timings supported by the chip
1129  * and the driver.
1130  * First tries to retrieve supported timing modes from ONFI information,
1131  * and if the NAND chip does not support ONFI, relies on the
1132  * ->onfi_timing_mode_default specified in the nand_ids table. After this
1133  * function nand_chip->data_interface is initialized with the best timing mode
1134  * available.
1135  *
1136  * Returns 0 for success or negative error code otherwise.
1137  */
1138 static int nand_init_data_interface(struct nand_chip *chip)
1139 {
1140         struct mtd_info *mtd = nand_to_mtd(chip);
1141         int modes, mode, ret;
1142
1143         if (!chip->setup_data_interface)
1144                 return 0;
1145
1146         /*
1147          * First try to identify the best timings from ONFI parameters and
1148          * if the NAND does not support ONFI, fallback to the default ONFI
1149          * timing mode.
1150          */
1151         modes = onfi_get_async_timing_mode(chip);
1152         if (modes == ONFI_TIMING_MODE_UNKNOWN) {
1153                 if (!chip->onfi_timing_mode_default)
1154                         return 0;
1155
1156                 modes = GENMASK(chip->onfi_timing_mode_default, 0);
1157         }
1158
1159         chip->data_interface = kzalloc(sizeof(*chip->data_interface),
1160                                        GFP_KERNEL);
1161         if (!chip->data_interface)
1162                 return -ENOMEM;
1163
1164         for (mode = fls(modes) - 1; mode >= 0; mode--) {
1165                 ret = onfi_init_data_interface(chip, chip->data_interface,
1166                                                NAND_SDR_IFACE, mode);
1167                 if (ret)
1168                         continue;
1169
1170                 /* Pass -1 to only */
1171                 ret = chip->setup_data_interface(mtd,
1172                                                  NAND_DATA_IFACE_CHECK_ONLY,
1173                                                  chip->data_interface);
1174                 if (!ret) {
1175                         chip->onfi_timing_mode_default = mode;
1176                         break;
1177                 }
1178         }
1179
1180         return 0;
1181 }
1182
1183 static void nand_release_data_interface(struct nand_chip *chip)
1184 {
1185         kfree(chip->data_interface);
1186 }
1187
1188 /**
1189  * nand_reset - Reset and initialize a NAND device
1190  * @chip: The NAND chip
1191  * @chipnr: Internal die id
1192  *
1193  * Returns 0 for success or negative error code otherwise
1194  */
1195 int nand_reset(struct nand_chip *chip, int chipnr)
1196 {
1197         struct mtd_info *mtd = nand_to_mtd(chip);
1198         int ret;
1199
1200         ret = nand_reset_data_interface(chip, chipnr);
1201         if (ret)
1202                 return ret;
1203
1204         /*
1205          * The CS line has to be released before we can apply the new NAND
1206          * interface settings, hence this weird ->select_chip() dance.
1207          */
1208         chip->select_chip(mtd, chipnr);
1209         chip->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
1210         chip->select_chip(mtd, -1);
1211
1212         chip->select_chip(mtd, chipnr);
1213         ret = nand_setup_data_interface(chip, chipnr);
1214         chip->select_chip(mtd, -1);
1215         if (ret)
1216                 return ret;
1217
1218         return 0;
1219 }
1220
1221 /**
1222  * __nand_unlock - [REPLACEABLE] unlocks specified locked blocks
1223  * @mtd: mtd info
1224  * @ofs: offset to start unlock from
1225  * @len: length to unlock
1226  * @invert: when = 0, unlock the range of blocks within the lower and
1227  *                    upper boundary address
1228  *          when = 1, unlock the range of blocks outside the boundaries
1229  *                    of the lower and upper boundary address
1230  *
1231  * Returs unlock status.
1232  */
1233 static int __nand_unlock(struct mtd_info *mtd, loff_t ofs,
1234                                         uint64_t len, int invert)
1235 {
1236         int ret = 0;
1237         int status, page;
1238         struct nand_chip *chip = mtd_to_nand(mtd);
1239
1240         /* Submit address of first page to unlock */
1241         page = ofs >> chip->page_shift;
1242         chip->cmdfunc(mtd, NAND_CMD_UNLOCK1, -1, page & chip->pagemask);
1243
1244         /* Submit address of last page to unlock */
1245         page = (ofs + len) >> chip->page_shift;
1246         chip->cmdfunc(mtd, NAND_CMD_UNLOCK2, -1,
1247                                 (page | invert) & chip->pagemask);
1248
1249         /* Call wait ready function */
1250         status = chip->waitfunc(mtd, chip);
1251         /* See if device thinks it succeeded */
1252         if (status & NAND_STATUS_FAIL) {
1253                 pr_debug("%s: error status = 0x%08x\n",
1254                                         __func__, status);
1255                 ret = -EIO;
1256         }
1257
1258         return ret;
1259 }
1260
1261 /**
1262  * nand_unlock - [REPLACEABLE] unlocks specified locked blocks
1263  * @mtd: mtd info
1264  * @ofs: offset to start unlock from
1265  * @len: length to unlock
1266  *
1267  * Returns unlock status.
1268  */
1269 int nand_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
1270 {
1271         int ret = 0;
1272         int chipnr;
1273         struct nand_chip *chip = mtd_to_nand(mtd);
1274
1275         pr_debug("%s: start = 0x%012llx, len = %llu\n",
1276                         __func__, (unsigned long long)ofs, len);
1277
1278         if (check_offs_len(mtd, ofs, len))
1279                 return -EINVAL;
1280
1281         /* Align to last block address if size addresses end of the device */
1282         if (ofs + len == mtd->size)
1283                 len -= mtd->erasesize;
1284
1285         nand_get_device(mtd, FL_UNLOCKING);
1286
1287         /* Shift to get chip number */
1288         chipnr = ofs >> chip->chip_shift;
1289
1290         /*
1291          * Reset the chip.
1292          * If we want to check the WP through READ STATUS and check the bit 7
1293          * we must reset the chip
1294          * some operation can also clear the bit 7 of status register
1295          * eg. erase/program a locked block
1296          */
1297         nand_reset(chip, chipnr);
1298
1299         chip->select_chip(mtd, chipnr);
1300
1301         /* Check, if it is write protected */
1302         if (nand_check_wp(mtd)) {
1303                 pr_debug("%s: device is write protected!\n",
1304                                         __func__);
1305                 ret = -EIO;
1306                 goto out;
1307         }
1308
1309         ret = __nand_unlock(mtd, ofs, len, 0);
1310
1311 out:
1312         chip->select_chip(mtd, -1);
1313         nand_release_device(mtd);
1314
1315         return ret;
1316 }
1317 EXPORT_SYMBOL(nand_unlock);
1318
1319 /**
1320  * nand_lock - [REPLACEABLE] locks all blocks present in the device
1321  * @mtd: mtd info
1322  * @ofs: offset to start unlock from
1323  * @len: length to unlock
1324  *
1325  * This feature is not supported in many NAND parts. 'Micron' NAND parts do
1326  * have this feature, but it allows only to lock all blocks, not for specified
1327  * range for block. Implementing 'lock' feature by making use of 'unlock', for
1328  * now.
1329  *
1330  * Returns lock status.
1331  */
1332 int nand_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
1333 {
1334         int ret = 0;
1335         int chipnr, status, page;
1336         struct nand_chip *chip = mtd_to_nand(mtd);
1337
1338         pr_debug("%s: start = 0x%012llx, len = %llu\n",
1339                         __func__, (unsigned long long)ofs, len);
1340
1341         if (check_offs_len(mtd, ofs, len))
1342                 return -EINVAL;
1343
1344         nand_get_device(mtd, FL_LOCKING);
1345
1346         /* Shift to get chip number */
1347         chipnr = ofs >> chip->chip_shift;
1348
1349         /*
1350          * Reset the chip.
1351          * If we want to check the WP through READ STATUS and check the bit 7
1352          * we must reset the chip
1353          * some operation can also clear the bit 7 of status register
1354          * eg. erase/program a locked block
1355          */
1356         nand_reset(chip, chipnr);
1357
1358         chip->select_chip(mtd, chipnr);
1359
1360         /* Check, if it is write protected */
1361         if (nand_check_wp(mtd)) {
1362                 pr_debug("%s: device is write protected!\n",
1363                                         __func__);
1364                 status = MTD_ERASE_FAILED;
1365                 ret = -EIO;
1366                 goto out;
1367         }
1368
1369         /* Submit address of first page to lock */
1370         page = ofs >> chip->page_shift;
1371         chip->cmdfunc(mtd, NAND_CMD_LOCK, -1, page & chip->pagemask);
1372
1373         /* Call wait ready function */
1374         status = chip->waitfunc(mtd, chip);
1375         /* See if device thinks it succeeded */
1376         if (status & NAND_STATUS_FAIL) {
1377                 pr_debug("%s: error status = 0x%08x\n",
1378                                         __func__, status);
1379                 ret = -EIO;
1380                 goto out;
1381         }
1382
1383         ret = __nand_unlock(mtd, ofs, len, 0x1);
1384
1385 out:
1386         chip->select_chip(mtd, -1);
1387         nand_release_device(mtd);
1388
1389         return ret;
1390 }
1391 EXPORT_SYMBOL(nand_lock);
1392
1393 /**
1394  * nand_check_erased_buf - check if a buffer contains (almost) only 0xff data
1395  * @buf: buffer to test
1396  * @len: buffer length
1397  * @bitflips_threshold: maximum number of bitflips
1398  *
1399  * Check if a buffer contains only 0xff, which means the underlying region
1400  * has been erased and is ready to be programmed.
1401  * The bitflips_threshold specify the maximum number of bitflips before
1402  * considering the region is not erased.
1403  * Note: The logic of this function has been extracted from the memweight
1404  * implementation, except that nand_check_erased_buf function exit before
1405  * testing the whole buffer if the number of bitflips exceed the
1406  * bitflips_threshold value.
1407  *
1408  * Returns a positive number of bitflips less than or equal to
1409  * bitflips_threshold, or -ERROR_CODE for bitflips in excess of the
1410  * threshold.
1411  */
1412 static int nand_check_erased_buf(void *buf, int len, int bitflips_threshold)
1413 {
1414         const unsigned char *bitmap = buf;
1415         int bitflips = 0;
1416         int weight;
1417
1418         for (; len && ((uintptr_t)bitmap) % sizeof(long);
1419              len--, bitmap++) {
1420                 weight = hweight8(*bitmap);
1421                 bitflips += BITS_PER_BYTE - weight;
1422                 if (unlikely(bitflips > bitflips_threshold))
1423                         return -EBADMSG;
1424         }
1425
1426         for (; len >= sizeof(long);
1427              len -= sizeof(long), bitmap += sizeof(long)) {
1428                 unsigned long d = *((unsigned long *)bitmap);
1429                 if (d == ~0UL)
1430                         continue;
1431                 weight = hweight_long(d);
1432                 bitflips += BITS_PER_LONG - weight;
1433                 if (unlikely(bitflips > bitflips_threshold))
1434                         return -EBADMSG;
1435         }
1436
1437         for (; len > 0; len--, bitmap++) {
1438                 weight = hweight8(*bitmap);
1439                 bitflips += BITS_PER_BYTE - weight;
1440                 if (unlikely(bitflips > bitflips_threshold))
1441                         return -EBADMSG;
1442         }
1443
1444         return bitflips;
1445 }
1446
1447 /**
1448  * nand_check_erased_ecc_chunk - check if an ECC chunk contains (almost) only
1449  *                               0xff data
1450  * @data: data buffer to test
1451  * @datalen: data length
1452  * @ecc: ECC buffer
1453  * @ecclen: ECC length
1454  * @extraoob: extra OOB buffer
1455  * @extraooblen: extra OOB length
1456  * @bitflips_threshold: maximum number of bitflips
1457  *
1458  * Check if a data buffer and its associated ECC and OOB data contains only
1459  * 0xff pattern, which means the underlying region has been erased and is
1460  * ready to be programmed.
1461  * The bitflips_threshold specify the maximum number of bitflips before
1462  * considering the region as not erased.
1463  *
1464  * Note:
1465  * 1/ ECC algorithms are working on pre-defined block sizes which are usually
1466  *    different from the NAND page size. When fixing bitflips, ECC engines will
1467  *    report the number of errors per chunk, and the NAND core infrastructure
1468  *    expect you to return the maximum number of bitflips for the whole page.
1469  *    This is why you should always use this function on a single chunk and
1470  *    not on the whole page. After checking each chunk you should update your
1471  *    max_bitflips value accordingly.
1472  * 2/ When checking for bitflips in erased pages you should not only check
1473  *    the payload data but also their associated ECC data, because a user might
1474  *    have programmed almost all bits to 1 but a few. In this case, we
1475  *    shouldn't consider the chunk as erased, and checking ECC bytes prevent
1476  *    this case.
1477  * 3/ The extraoob argument is optional, and should be used if some of your OOB
1478  *    data are protected by the ECC engine.
1479  *    It could also be used if you support subpages and want to attach some
1480  *    extra OOB data to an ECC chunk.
1481  *
1482  * Returns a positive number of bitflips less than or equal to
1483  * bitflips_threshold, or -ERROR_CODE for bitflips in excess of the
1484  * threshold. In case of success, the passed buffers are filled with 0xff.
1485  */
1486 int nand_check_erased_ecc_chunk(void *data, int datalen,
1487                                 void *ecc, int ecclen,
1488                                 void *extraoob, int extraooblen,
1489                                 int bitflips_threshold)
1490 {
1491         int data_bitflips = 0, ecc_bitflips = 0, extraoob_bitflips = 0;
1492
1493         data_bitflips = nand_check_erased_buf(data, datalen,
1494                                               bitflips_threshold);
1495         if (data_bitflips < 0)
1496                 return data_bitflips;
1497
1498         bitflips_threshold -= data_bitflips;
1499
1500         ecc_bitflips = nand_check_erased_buf(ecc, ecclen, bitflips_threshold);
1501         if (ecc_bitflips < 0)
1502                 return ecc_bitflips;
1503
1504         bitflips_threshold -= ecc_bitflips;
1505
1506         extraoob_bitflips = nand_check_erased_buf(extraoob, extraooblen,
1507                                                   bitflips_threshold);
1508         if (extraoob_bitflips < 0)
1509                 return extraoob_bitflips;
1510
1511         if (data_bitflips)
1512                 memset(data, 0xff, datalen);
1513
1514         if (ecc_bitflips)
1515                 memset(ecc, 0xff, ecclen);
1516
1517         if (extraoob_bitflips)
1518                 memset(extraoob, 0xff, extraooblen);
1519
1520         return data_bitflips + ecc_bitflips + extraoob_bitflips;
1521 }
1522 EXPORT_SYMBOL(nand_check_erased_ecc_chunk);
1523
1524 /**
1525  * nand_read_page_raw - [INTERN] read raw page data without ecc
1526  * @mtd: mtd info structure
1527  * @chip: nand chip info structure
1528  * @buf: buffer to store read data
1529  * @oob_required: caller requires OOB data read to chip->oob_poi
1530  * @page: page number to read
1531  *
1532  * Not for syndrome calculating ECC controllers, which use a special oob layout.
1533  */
1534 int nand_read_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
1535                        uint8_t *buf, int oob_required, int page)
1536 {
1537         chip->read_buf(mtd, buf, mtd->writesize);
1538         if (oob_required)
1539                 chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
1540         return 0;
1541 }
1542 EXPORT_SYMBOL(nand_read_page_raw);
1543
1544 /**
1545  * nand_read_page_raw_syndrome - [INTERN] read raw page data without ecc
1546  * @mtd: mtd info structure
1547  * @chip: nand chip info structure
1548  * @buf: buffer to store read data
1549  * @oob_required: caller requires OOB data read to chip->oob_poi
1550  * @page: page number to read
1551  *
1552  * We need a special oob layout and handling even when OOB isn't used.
1553  */
1554 static int nand_read_page_raw_syndrome(struct mtd_info *mtd,
1555                                        struct nand_chip *chip, uint8_t *buf,
1556                                        int oob_required, int page)
1557 {
1558         int eccsize = chip->ecc.size;
1559         int eccbytes = chip->ecc.bytes;
1560         uint8_t *oob = chip->oob_poi;
1561         int steps, size;
1562
1563         for (steps = chip->ecc.steps; steps > 0; steps--) {
1564                 chip->read_buf(mtd, buf, eccsize);
1565                 buf += eccsize;
1566
1567                 if (chip->ecc.prepad) {
1568                         chip->read_buf(mtd, oob, chip->ecc.prepad);
1569                         oob += chip->ecc.prepad;
1570                 }
1571
1572                 chip->read_buf(mtd, oob, eccbytes);
1573                 oob += eccbytes;
1574
1575                 if (chip->ecc.postpad) {
1576                         chip->read_buf(mtd, oob, chip->ecc.postpad);
1577                         oob += chip->ecc.postpad;
1578                 }
1579         }
1580
1581         size = mtd->oobsize - (oob - chip->oob_poi);
1582         if (size)
1583                 chip->read_buf(mtd, oob, size);
1584
1585         return 0;
1586 }
1587
1588 /**
1589  * nand_read_page_swecc - [REPLACEABLE] software ECC based page read function
1590  * @mtd: mtd info structure
1591  * @chip: nand chip info structure
1592  * @buf: buffer to store read data
1593  * @oob_required: caller requires OOB data read to chip->oob_poi
1594  * @page: page number to read
1595  */
1596 static int nand_read_page_swecc(struct mtd_info *mtd, struct nand_chip *chip,
1597                                 uint8_t *buf, int oob_required, int page)
1598 {
1599         int i, eccsize = chip->ecc.size, ret;
1600         int eccbytes = chip->ecc.bytes;
1601         int eccsteps = chip->ecc.steps;
1602         uint8_t *p = buf;
1603         uint8_t *ecc_calc = chip->buffers->ecccalc;
1604         uint8_t *ecc_code = chip->buffers->ecccode;
1605         unsigned int max_bitflips = 0;
1606
1607         chip->ecc.read_page_raw(mtd, chip, buf, 1, page);
1608
1609         for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize)
1610                 chip->ecc.calculate(mtd, p, &ecc_calc[i]);
1611
1612         ret = mtd_ooblayout_get_eccbytes(mtd, ecc_code, chip->oob_poi, 0,
1613                                          chip->ecc.total);
1614         if (ret)
1615                 return ret;
1616
1617         eccsteps = chip->ecc.steps;
1618         p = buf;
1619
1620         for (i = 0 ; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
1621                 int stat;
1622
1623                 stat = chip->ecc.correct(mtd, p, &ecc_code[i], &ecc_calc[i]);
1624                 if (stat < 0) {
1625                         mtd->ecc_stats.failed++;
1626                 } else {
1627                         mtd->ecc_stats.corrected += stat;
1628                         max_bitflips = max_t(unsigned int, max_bitflips, stat);
1629                 }
1630         }
1631         return max_bitflips;
1632 }
1633
1634 /**
1635  * nand_read_subpage - [REPLACEABLE] ECC based sub-page read function
1636  * @mtd: mtd info structure
1637  * @chip: nand chip info structure
1638  * @data_offs: offset of requested data within the page
1639  * @readlen: data length
1640  * @bufpoi: buffer to store read data
1641  * @page: page number to read
1642  */
1643 static int nand_read_subpage(struct mtd_info *mtd, struct nand_chip *chip,
1644                         uint32_t data_offs, uint32_t readlen, uint8_t *bufpoi,
1645                         int page)
1646 {
1647         int start_step, end_step, num_steps, ret;
1648         uint8_t *p;
1649         int data_col_addr, i, gaps = 0;
1650         int datafrag_len, eccfrag_len, aligned_len, aligned_pos;
1651         int busw = (chip->options & NAND_BUSWIDTH_16) ? 2 : 1;
1652         int index, section = 0;
1653         unsigned int max_bitflips = 0;
1654         struct mtd_oob_region oobregion = { };
1655
1656         /* Column address within the page aligned to ECC size (256bytes) */
1657         start_step = data_offs / chip->ecc.size;
1658         end_step = (data_offs + readlen - 1) / chip->ecc.size;
1659         num_steps = end_step - start_step + 1;
1660         index = start_step * chip->ecc.bytes;
1661
1662         /* Data size aligned to ECC ecc.size */
1663         datafrag_len = num_steps * chip->ecc.size;
1664         eccfrag_len = num_steps * chip->ecc.bytes;
1665
1666         data_col_addr = start_step * chip->ecc.size;
1667         /* If we read not a page aligned data */
1668         if (data_col_addr != 0)
1669                 chip->cmdfunc(mtd, NAND_CMD_RNDOUT, data_col_addr, -1);
1670
1671         p = bufpoi + data_col_addr;
1672         chip->read_buf(mtd, p, datafrag_len);
1673
1674         /* Calculate ECC */
1675         for (i = 0; i < eccfrag_len ; i += chip->ecc.bytes, p += chip->ecc.size)
1676                 chip->ecc.calculate(mtd, p, &chip->buffers->ecccalc[i]);
1677
1678         /*
1679          * The performance is faster if we position offsets according to
1680          * ecc.pos. Let's make sure that there are no gaps in ECC positions.
1681          */
1682         ret = mtd_ooblayout_find_eccregion(mtd, index, &section, &oobregion);
1683         if (ret)
1684                 return ret;
1685
1686         if (oobregion.length < eccfrag_len)
1687                 gaps = 1;
1688
1689         if (gaps) {
1690                 chip->cmdfunc(mtd, NAND_CMD_RNDOUT, mtd->writesize, -1);
1691                 chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
1692         } else {
1693                 /*
1694                  * Send the command to read the particular ECC bytes take care
1695                  * about buswidth alignment in read_buf.
1696                  */
1697                 aligned_pos = oobregion.offset & ~(busw - 1);
1698                 aligned_len = eccfrag_len;
1699                 if (oobregion.offset & (busw - 1))
1700                         aligned_len++;
1701                 if ((oobregion.offset + (num_steps * chip->ecc.bytes)) &
1702                     (busw - 1))
1703                         aligned_len++;
1704
1705                 chip->cmdfunc(mtd, NAND_CMD_RNDOUT,
1706                               mtd->writesize + aligned_pos, -1);
1707                 chip->read_buf(mtd, &chip->oob_poi[aligned_pos], aligned_len);
1708         }
1709
1710         ret = mtd_ooblayout_get_eccbytes(mtd, chip->buffers->ecccode,
1711                                          chip->oob_poi, index, eccfrag_len);
1712         if (ret)
1713                 return ret;
1714
1715         p = bufpoi + data_col_addr;
1716         for (i = 0; i < eccfrag_len ; i += chip->ecc.bytes, p += chip->ecc.size) {
1717                 int stat;
1718
1719                 stat = chip->ecc.correct(mtd, p,
1720                         &chip->buffers->ecccode[i], &chip->buffers->ecccalc[i]);
1721                 if (stat == -EBADMSG &&
1722                     (chip->ecc.options & NAND_ECC_GENERIC_ERASED_CHECK)) {
1723                         /* check for empty pages with bitflips */
1724                         stat = nand_check_erased_ecc_chunk(p, chip->ecc.size,
1725                                                 &chip->buffers->ecccode[i],
1726                                                 chip->ecc.bytes,
1727                                                 NULL, 0,
1728                                                 chip->ecc.strength);
1729                 }
1730
1731                 if (stat < 0) {
1732                         mtd->ecc_stats.failed++;
1733                 } else {
1734                         mtd->ecc_stats.corrected += stat;
1735                         max_bitflips = max_t(unsigned int, max_bitflips, stat);
1736                 }
1737         }
1738         return max_bitflips;
1739 }
1740
1741 /**
1742  * nand_read_page_hwecc - [REPLACEABLE] hardware ECC based page read function
1743  * @mtd: mtd info structure
1744  * @chip: nand chip info structure
1745  * @buf: buffer to store read data
1746  * @oob_required: caller requires OOB data read to chip->oob_poi
1747  * @page: page number to read
1748  *
1749  * Not for syndrome calculating ECC controllers which need a special oob layout.
1750  */
1751 static int nand_read_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip,
1752                                 uint8_t *buf, int oob_required, int page)
1753 {
1754         int i, eccsize = chip->ecc.size, ret;
1755         int eccbytes = chip->ecc.bytes;
1756         int eccsteps = chip->ecc.steps;
1757         uint8_t *p = buf;
1758         uint8_t *ecc_calc = chip->buffers->ecccalc;
1759         uint8_t *ecc_code = chip->buffers->ecccode;
1760         unsigned int max_bitflips = 0;
1761
1762         for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
1763                 chip->ecc.hwctl(mtd, NAND_ECC_READ);
1764                 chip->read_buf(mtd, p, eccsize);
1765                 chip->ecc.calculate(mtd, p, &ecc_calc[i]);
1766         }
1767         chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
1768
1769         ret = mtd_ooblayout_get_eccbytes(mtd, ecc_code, chip->oob_poi, 0,
1770                                          chip->ecc.total);
1771         if (ret)
1772                 return ret;
1773
1774         eccsteps = chip->ecc.steps;
1775         p = buf;
1776
1777         for (i = 0 ; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
1778                 int stat;
1779
1780                 stat = chip->ecc.correct(mtd, p, &ecc_code[i], &ecc_calc[i]);
1781                 if (stat == -EBADMSG &&
1782                     (chip->ecc.options & NAND_ECC_GENERIC_ERASED_CHECK)) {
1783                         /* check for empty pages with bitflips */
1784                         stat = nand_check_erased_ecc_chunk(p, eccsize,
1785                                                 &ecc_code[i], eccbytes,
1786                                                 NULL, 0,
1787                                                 chip->ecc.strength);
1788                 }
1789
1790                 if (stat < 0) {
1791                         mtd->ecc_stats.failed++;
1792                 } else {
1793                         mtd->ecc_stats.corrected += stat;
1794                         max_bitflips = max_t(unsigned int, max_bitflips, stat);
1795                 }
1796         }
1797         return max_bitflips;
1798 }
1799
1800 /**
1801  * nand_read_page_hwecc_oob_first - [REPLACEABLE] hw ecc, read oob first
1802  * @mtd: mtd info structure
1803  * @chip: nand chip info structure
1804  * @buf: buffer to store read data
1805  * @oob_required: caller requires OOB data read to chip->oob_poi
1806  * @page: page number to read
1807  *
1808  * Hardware ECC for large page chips, require OOB to be read first. For this
1809  * ECC mode, the write_page method is re-used from ECC_HW. These methods
1810  * read/write ECC from the OOB area, unlike the ECC_HW_SYNDROME support with
1811  * multiple ECC steps, follows the "infix ECC" scheme and reads/writes ECC from
1812  * the data area, by overwriting the NAND manufacturer bad block markings.
1813  */
1814 static int nand_read_page_hwecc_oob_first(struct mtd_info *mtd,
1815         struct nand_chip *chip, uint8_t *buf, int oob_required, int page)
1816 {
1817         int i, eccsize = chip->ecc.size, ret;
1818         int eccbytes = chip->ecc.bytes;
1819         int eccsteps = chip->ecc.steps;
1820         uint8_t *p = buf;
1821         uint8_t *ecc_code = chip->buffers->ecccode;
1822         uint8_t *ecc_calc = chip->buffers->ecccalc;
1823         unsigned int max_bitflips = 0;
1824
1825         /* Read the OOB area first */
1826         chip->cmdfunc(mtd, NAND_CMD_READOOB, 0, page);
1827         chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
1828         chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
1829
1830         ret = mtd_ooblayout_get_eccbytes(mtd, ecc_code, chip->oob_poi, 0,
1831                                          chip->ecc.total);
1832         if (ret)
1833                 return ret;
1834
1835         for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
1836                 int stat;
1837
1838                 chip->ecc.hwctl(mtd, NAND_ECC_READ);
1839                 chip->read_buf(mtd, p, eccsize);
1840                 chip->ecc.calculate(mtd, p, &ecc_calc[i]);
1841
1842                 stat = chip->ecc.correct(mtd, p, &ecc_code[i], NULL);
1843                 if (stat == -EBADMSG &&
1844                     (chip->ecc.options & NAND_ECC_GENERIC_ERASED_CHECK)) {
1845                         /* check for empty pages with bitflips */
1846                         stat = nand_check_erased_ecc_chunk(p, eccsize,
1847                                                 &ecc_code[i], eccbytes,
1848                                                 NULL, 0,
1849                                                 chip->ecc.strength);
1850                 }
1851
1852                 if (stat < 0) {
1853                         mtd->ecc_stats.failed++;
1854                 } else {
1855                         mtd->ecc_stats.corrected += stat;
1856                         max_bitflips = max_t(unsigned int, max_bitflips, stat);
1857                 }
1858         }
1859         return max_bitflips;
1860 }
1861
1862 /**
1863  * nand_read_page_syndrome - [REPLACEABLE] hardware ECC syndrome based page read
1864  * @mtd: mtd info structure
1865  * @chip: nand chip info structure
1866  * @buf: buffer to store read data
1867  * @oob_required: caller requires OOB data read to chip->oob_poi
1868  * @page: page number to read
1869  *
1870  * The hw generator calculates the error syndrome automatically. Therefore we
1871  * need a special oob layout and handling.
1872  */
1873 static int nand_read_page_syndrome(struct mtd_info *mtd, struct nand_chip *chip,
1874                                    uint8_t *buf, int oob_required, int page)
1875 {
1876         int i, eccsize = chip->ecc.size;
1877         int eccbytes = chip->ecc.bytes;
1878         int eccsteps = chip->ecc.steps;
1879         int eccpadbytes = eccbytes + chip->ecc.prepad + chip->ecc.postpad;
1880         uint8_t *p = buf;
1881         uint8_t *oob = chip->oob_poi;
1882         unsigned int max_bitflips = 0;
1883
1884         for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
1885                 int stat;
1886
1887                 chip->ecc.hwctl(mtd, NAND_ECC_READ);
1888                 chip->read_buf(mtd, p, eccsize);
1889
1890                 if (chip->ecc.prepad) {
1891                         chip->read_buf(mtd, oob, chip->ecc.prepad);
1892                         oob += chip->ecc.prepad;
1893                 }
1894
1895                 chip->ecc.hwctl(mtd, NAND_ECC_READSYN);
1896                 chip->read_buf(mtd, oob, eccbytes);
1897                 stat = chip->ecc.correct(mtd, p, oob, NULL);
1898
1899                 oob += eccbytes;
1900
1901                 if (chip->ecc.postpad) {
1902                         chip->read_buf(mtd, oob, chip->ecc.postpad);
1903                         oob += chip->ecc.postpad;
1904                 }
1905
1906                 if (stat == -EBADMSG &&
1907                     (chip->ecc.options & NAND_ECC_GENERIC_ERASED_CHECK)) {
1908                         /* check for empty pages with bitflips */
1909                         stat = nand_check_erased_ecc_chunk(p, chip->ecc.size,
1910                                                            oob - eccpadbytes,
1911                                                            eccpadbytes,
1912                                                            NULL, 0,
1913                                                            chip->ecc.strength);
1914                 }
1915
1916                 if (stat < 0) {
1917                         mtd->ecc_stats.failed++;
1918                 } else {
1919                         mtd->ecc_stats.corrected += stat;
1920                         max_bitflips = max_t(unsigned int, max_bitflips, stat);
1921                 }
1922         }
1923
1924         /* Calculate remaining oob bytes */
1925         i = mtd->oobsize - (oob - chip->oob_poi);
1926         if (i)
1927                 chip->read_buf(mtd, oob, i);
1928
1929         return max_bitflips;
1930 }
1931
1932 /**
1933  * nand_transfer_oob - [INTERN] Transfer oob to client buffer
1934  * @mtd: mtd info structure
1935  * @oob: oob destination address
1936  * @ops: oob ops structure
1937  * @len: size of oob to transfer
1938  */
1939 static uint8_t *nand_transfer_oob(struct mtd_info *mtd, uint8_t *oob,
1940                                   struct mtd_oob_ops *ops, size_t len)
1941 {
1942         struct nand_chip *chip = mtd_to_nand(mtd);
1943         int ret;
1944
1945         switch (ops->mode) {
1946
1947         case MTD_OPS_PLACE_OOB:
1948         case MTD_OPS_RAW:
1949                 memcpy(oob, chip->oob_poi + ops->ooboffs, len);
1950                 return oob + len;
1951
1952         case MTD_OPS_AUTO_OOB:
1953                 ret = mtd_ooblayout_get_databytes(mtd, oob, chip->oob_poi,
1954                                                   ops->ooboffs, len);
1955                 BUG_ON(ret);
1956                 return oob + len;
1957
1958         default:
1959                 BUG();
1960         }
1961         return NULL;
1962 }
1963
1964 /**
1965  * nand_setup_read_retry - [INTERN] Set the READ RETRY mode
1966  * @mtd: MTD device structure
1967  * @retry_mode: the retry mode to use
1968  *
1969  * Some vendors supply a special command to shift the Vt threshold, to be used
1970  * when there are too many bitflips in a page (i.e., ECC error). After setting
1971  * a new threshold, the host should retry reading the page.
1972  */
1973 static int nand_setup_read_retry(struct mtd_info *mtd, int retry_mode)
1974 {
1975         struct nand_chip *chip = mtd_to_nand(mtd);
1976
1977         pr_debug("setting READ RETRY mode %d\n", retry_mode);
1978
1979         if (retry_mode >= chip->read_retries)
1980                 return -EINVAL;
1981
1982         if (!chip->setup_read_retry)
1983                 return -EOPNOTSUPP;
1984
1985         return chip->setup_read_retry(mtd, retry_mode);
1986 }
1987
1988 /**
1989  * nand_do_read_ops - [INTERN] Read data with ECC
1990  * @mtd: MTD device structure
1991  * @from: offset to read from
1992  * @ops: oob ops structure
1993  *
1994  * Internal function. Called with chip held.
1995  */
1996 static int nand_do_read_ops(struct mtd_info *mtd, loff_t from,
1997                             struct mtd_oob_ops *ops)
1998 {
1999         int chipnr, page, realpage, col, bytes, aligned, oob_required;
2000         struct nand_chip *chip = mtd_to_nand(mtd);
2001         int ret = 0;
2002         uint32_t readlen = ops->len;
2003         uint32_t oobreadlen = ops->ooblen;
2004         uint32_t max_oobsize = mtd_oobavail(mtd, ops);
2005
2006         uint8_t *bufpoi, *oob, *buf;
2007         int use_bufpoi;
2008         unsigned int max_bitflips = 0;
2009         int retry_mode = 0;
2010         bool ecc_fail = false;
2011
2012         chipnr = (int)(from >> chip->chip_shift);
2013         chip->select_chip(mtd, chipnr);
2014
2015         realpage = (int)(from >> chip->page_shift);
2016         page = realpage & chip->pagemask;
2017
2018         col = (int)(from & (mtd->writesize - 1));
2019
2020         buf = ops->datbuf;
2021         oob = ops->oobbuf;
2022         oob_required = oob ? 1 : 0;
2023
2024         while (1) {
2025                 unsigned int ecc_failures = mtd->ecc_stats.failed;
2026
2027                 bytes = min(mtd->writesize - col, readlen);
2028                 aligned = (bytes == mtd->writesize);
2029
2030                 if (!aligned)
2031                         use_bufpoi = 1;
2032                 else if (chip->options & NAND_USE_BOUNCE_BUFFER)
2033                         use_bufpoi = !virt_addr_valid(buf) ||
2034                                      !IS_ALIGNED((unsigned long)buf,
2035                                                  chip->buf_align);
2036                 else
2037                         use_bufpoi = 0;
2038
2039                 /* Is the current page in the buffer? */
2040                 if (realpage != chip->pagebuf || oob) {
2041                         bufpoi = use_bufpoi ? chip->buffers->databuf : buf;
2042
2043                         if (use_bufpoi && aligned)
2044                                 pr_debug("%s: using read bounce buffer for buf@%p\n",
2045                                                  __func__, buf);
2046
2047 read_retry:
2048                         if (nand_standard_page_accessors(&chip->ecc))
2049                                 chip->cmdfunc(mtd, NAND_CMD_READ0, 0x00, page);
2050
2051                         /*
2052                          * Now read the page into the buffer.  Absent an error,
2053                          * the read methods return max bitflips per ecc step.
2054                          */
2055                         if (unlikely(ops->mode == MTD_OPS_RAW))
2056                                 ret = chip->ecc.read_page_raw(mtd, chip, bufpoi,
2057                                                               oob_required,
2058                                                               page);
2059                         else if (!aligned && NAND_HAS_SUBPAGE_READ(chip) &&
2060                                  !oob)
2061                                 ret = chip->ecc.read_subpage(mtd, chip,
2062                                                         col, bytes, bufpoi,
2063                                                         page);
2064                         else
2065                                 ret = chip->ecc.read_page(mtd, chip, bufpoi,
2066                                                           oob_required, page);
2067                         if (ret < 0) {
2068                                 if (use_bufpoi)
2069                                         /* Invalidate page cache */
2070                                         chip->pagebuf = -1;
2071                                 break;
2072                         }
2073
2074                         /* Transfer not aligned data */
2075                         if (use_bufpoi) {
2076                                 if (!NAND_HAS_SUBPAGE_READ(chip) && !oob &&
2077                                     !(mtd->ecc_stats.failed - ecc_failures) &&
2078                                     (ops->mode != MTD_OPS_RAW)) {
2079                                         chip->pagebuf = realpage;
2080                                         chip->pagebuf_bitflips = ret;
2081                                 } else {
2082                                         /* Invalidate page cache */
2083                                         chip->pagebuf = -1;
2084                                 }
2085                                 memcpy(buf, chip->buffers->databuf + col, bytes);
2086                         }
2087
2088                         if (unlikely(oob)) {
2089                                 int toread = min(oobreadlen, max_oobsize);
2090
2091                                 if (toread) {
2092                                         oob = nand_transfer_oob(mtd,
2093                                                 oob, ops, toread);
2094                                         oobreadlen -= toread;
2095                                 }
2096                         }
2097
2098                         if (chip->options & NAND_NEED_READRDY) {
2099                                 /* Apply delay or wait for ready/busy pin */
2100                                 if (!chip->dev_ready)
2101                                         udelay(chip->chip_delay);
2102                                 else
2103                                         nand_wait_ready(mtd);
2104                         }
2105
2106                         if (mtd->ecc_stats.failed - ecc_failures) {
2107                                 if (retry_mode + 1 < chip->read_retries) {
2108                                         retry_mode++;
2109                                         ret = nand_setup_read_retry(mtd,
2110                                                         retry_mode);
2111                                         if (ret < 0)
2112                                                 break;
2113
2114                                         /* Reset failures; retry */
2115                                         mtd->ecc_stats.failed = ecc_failures;
2116                                         goto read_retry;
2117                                 } else {
2118                                         /* No more retry modes; real failure */
2119                                         ecc_fail = true;
2120                                 }
2121                         }
2122
2123                         buf += bytes;
2124                         max_bitflips = max_t(unsigned int, max_bitflips, ret);
2125                 } else {
2126                         memcpy(buf, chip->buffers->databuf + col, bytes);
2127                         buf += bytes;
2128                         max_bitflips = max_t(unsigned int, max_bitflips,
2129                                              chip->pagebuf_bitflips);
2130                 }
2131
2132                 readlen -= bytes;
2133
2134                 /* Reset to retry mode 0 */
2135                 if (retry_mode) {
2136                         ret = nand_setup_read_retry(mtd, 0);
2137                         if (ret < 0)
2138                                 break;
2139                         retry_mode = 0;
2140                 }
2141
2142                 if (!readlen)
2143                         break;
2144
2145                 /* For subsequent reads align to page boundary */
2146                 col = 0;
2147                 /* Increment page address */
2148                 realpage++;
2149
2150                 page = realpage & chip->pagemask;
2151                 /* Check, if we cross a chip boundary */
2152                 if (!page) {
2153                         chipnr++;
2154                         chip->select_chip(mtd, -1);
2155                         chip->select_chip(mtd, chipnr);
2156                 }
2157         }
2158         chip->select_chip(mtd, -1);
2159
2160         ops->retlen = ops->len - (size_t) readlen;
2161         if (oob)
2162                 ops->oobretlen = ops->ooblen - oobreadlen;
2163
2164         if (ret < 0)
2165                 return ret;
2166
2167         if (ecc_fail)
2168                 return -EBADMSG;
2169
2170         return max_bitflips;
2171 }
2172
2173 /**
2174  * nand_read - [MTD Interface] MTD compatibility function for nand_do_read_ecc
2175  * @mtd: MTD device structure
2176  * @from: offset to read from
2177  * @len: number of bytes to read
2178  * @retlen: pointer to variable to store the number of read bytes
2179  * @buf: the databuffer to put data
2180  *
2181  * Get hold of the chip and call nand_do_read.
2182  */
2183 static int nand_read(struct mtd_info *mtd, loff_t from, size_t len,
2184                      size_t *retlen, uint8_t *buf)
2185 {
2186         struct mtd_oob_ops ops;
2187         int ret;
2188
2189         nand_get_device(mtd, FL_READING);
2190         memset(&ops, 0, sizeof(ops));
2191         ops.len = len;
2192         ops.datbuf = buf;
2193         ops.mode = MTD_OPS_PLACE_OOB;
2194         ret = nand_do_read_ops(mtd, from, &ops);
2195         *retlen = ops.retlen;
2196         nand_release_device(mtd);
2197         return ret;
2198 }
2199
2200 /**
2201  * nand_read_oob_std - [REPLACEABLE] the most common OOB data read function
2202  * @mtd: mtd info structure
2203  * @chip: nand chip info structure
2204  * @page: page number to read
2205  */
2206 int nand_read_oob_std(struct mtd_info *mtd, struct nand_chip *chip, int page)
2207 {
2208         chip->cmdfunc(mtd, NAND_CMD_READOOB, 0, page);
2209         chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
2210         return 0;
2211 }
2212 EXPORT_SYMBOL(nand_read_oob_std);
2213
2214 /**
2215  * nand_read_oob_syndrome - [REPLACEABLE] OOB data read function for HW ECC
2216  *                          with syndromes
2217  * @mtd: mtd info structure
2218  * @chip: nand chip info structure
2219  * @page: page number to read
2220  */
2221 int nand_read_oob_syndrome(struct mtd_info *mtd, struct nand_chip *chip,
2222                            int page)
2223 {
2224         int length = mtd->oobsize;
2225         int chunk = chip->ecc.bytes + chip->ecc.prepad + chip->ecc.postpad;
2226         int eccsize = chip->ecc.size;
2227         uint8_t *bufpoi = chip->oob_poi;
2228         int i, toread, sndrnd = 0, pos;
2229
2230         chip->cmdfunc(mtd, NAND_CMD_READ0, chip->ecc.size, page);
2231         for (i = 0; i < chip->ecc.steps; i++) {
2232                 if (sndrnd) {
2233                         pos = eccsize + i * (eccsize + chunk);
2234                         if (mtd->writesize > 512)
2235                                 chip->cmdfunc(mtd, NAND_CMD_RNDOUT, pos, -1);
2236                         else
2237                                 chip->cmdfunc(mtd, NAND_CMD_READ0, pos, page);
2238                 } else
2239                         sndrnd = 1;
2240                 toread = min_t(int, length, chunk);
2241                 chip->read_buf(mtd, bufpoi, toread);
2242                 bufpoi += toread;
2243                 length -= toread;
2244         }
2245         if (length > 0)
2246                 chip->read_buf(mtd, bufpoi, length);
2247
2248         return 0;
2249 }
2250 EXPORT_SYMBOL(nand_read_oob_syndrome);
2251
2252 /**
2253  * nand_write_oob_std - [REPLACEABLE] the most common OOB data write function
2254  * @mtd: mtd info structure
2255  * @chip: nand chip info structure
2256  * @page: page number to write
2257  */
2258 int nand_write_oob_std(struct mtd_info *mtd, struct nand_chip *chip, int page)
2259 {
2260         int status = 0;
2261         const uint8_t *buf = chip->oob_poi;
2262         int length = mtd->oobsize;
2263
2264         chip->cmdfunc(mtd, NAND_CMD_SEQIN, mtd->writesize, page);
2265         chip->write_buf(mtd, buf, length);
2266         /* Send command to program the OOB data */
2267         chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
2268
2269         status = chip->waitfunc(mtd, chip);
2270
2271         return status & NAND_STATUS_FAIL ? -EIO : 0;
2272 }
2273 EXPORT_SYMBOL(nand_write_oob_std);
2274
2275 /**
2276  * nand_write_oob_syndrome - [REPLACEABLE] OOB data write function for HW ECC
2277  *                           with syndrome - only for large page flash
2278  * @mtd: mtd info structure
2279  * @chip: nand chip info structure
2280  * @page: page number to write
2281  */
2282 int nand_write_oob_syndrome(struct mtd_info *mtd, struct nand_chip *chip,
2283                             int page)
2284 {
2285         int chunk = chip->ecc.bytes + chip->ecc.prepad + chip->ecc.postpad;
2286         int eccsize = chip->ecc.size, length = mtd->oobsize;
2287         int i, len, pos, status = 0, sndcmd = 0, steps = chip->ecc.steps;
2288         const uint8_t *bufpoi = chip->oob_poi;
2289
2290         /*
2291          * data-ecc-data-ecc ... ecc-oob
2292          * or
2293          * data-pad-ecc-pad-data-pad .... ecc-pad-oob
2294          */
2295         if (!chip->ecc.prepad && !chip->ecc.postpad) {
2296                 pos = steps * (eccsize + chunk);
2297                 steps = 0;
2298         } else
2299                 pos = eccsize;
2300
2301         chip->cmdfunc(mtd, NAND_CMD_SEQIN, pos, page);
2302         for (i = 0; i < steps; i++) {
2303                 if (sndcmd) {
2304                         if (mtd->writesize <= 512) {
2305                                 uint32_t fill = 0xFFFFFFFF;
2306
2307                                 len = eccsize;
2308                                 while (len > 0) {
2309                                         int num = min_t(int, len, 4);
2310                                         chip->write_buf(mtd, (uint8_t *)&fill,
2311                                                         num);
2312                                         len -= num;
2313                                 }
2314                         } else {
2315                                 pos = eccsize + i * (eccsize + chunk);
2316                                 chip->cmdfunc(mtd, NAND_CMD_RNDIN, pos, -1);
2317                         }
2318                 } else
2319                         sndcmd = 1;
2320                 len = min_t(int, length, chunk);
2321                 chip->write_buf(mtd, bufpoi, len);
2322                 bufpoi += len;
2323                 length -= len;
2324         }
2325         if (length > 0)
2326                 chip->write_buf(mtd, bufpoi, length);
2327
2328         chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
2329         status = chip->waitfunc(mtd, chip);
2330
2331         return status & NAND_STATUS_FAIL ? -EIO : 0;
2332 }
2333 EXPORT_SYMBOL(nand_write_oob_syndrome);
2334
2335 /**
2336  * nand_do_read_oob - [INTERN] NAND read out-of-band
2337  * @mtd: MTD device structure
2338  * @from: offset to read from
2339  * @ops: oob operations description structure
2340  *
2341  * NAND read out-of-band data from the spare area.
2342  */
2343 static int nand_do_read_oob(struct mtd_info *mtd, loff_t from,
2344                             struct mtd_oob_ops *ops)
2345 {
2346         int page, realpage, chipnr;
2347         struct nand_chip *chip = mtd_to_nand(mtd);
2348         struct mtd_ecc_stats stats;
2349         int readlen = ops->ooblen;
2350         int len;
2351         uint8_t *buf = ops->oobbuf;
2352         int ret = 0;
2353
2354         pr_debug("%s: from = 0x%08Lx, len = %i\n",
2355                         __func__, (unsigned long long)from, readlen);
2356
2357         stats = mtd->ecc_stats;
2358
2359         len = mtd_oobavail(mtd, ops);
2360
2361         if (unlikely(ops->ooboffs >= len)) {
2362                 pr_debug("%s: attempt to start read outside oob\n",
2363                                 __func__);
2364                 return -EINVAL;
2365         }
2366
2367         /* Do not allow reads past end of device */
2368         if (unlikely(from >= mtd->size ||
2369                      ops->ooboffs + readlen > ((mtd->size >> chip->page_shift) -
2370                                         (from >> chip->page_shift)) * len)) {
2371                 pr_debug("%s: attempt to read beyond end of device\n",
2372                                 __func__);
2373                 return -EINVAL;
2374         }
2375
2376         chipnr = (int)(from >> chip->chip_shift);
2377         chip->select_chip(mtd, chipnr);
2378
2379         /* Shift to get page */
2380         realpage = (int)(from >> chip->page_shift);
2381         page = realpage & chip->pagemask;
2382
2383         while (1) {
2384                 if (ops->mode == MTD_OPS_RAW)
2385                         ret = chip->ecc.read_oob_raw(mtd, chip, page);
2386                 else
2387                         ret = chip->ecc.read_oob(mtd, chip, page);
2388
2389                 if (ret < 0)
2390                         break;
2391
2392                 len = min(len, readlen);
2393                 buf = nand_transfer_oob(mtd, buf, ops, len);
2394
2395                 if (chip->options & NAND_NEED_READRDY) {
2396                         /* Apply delay or wait for ready/busy pin */
2397                         if (!chip->dev_ready)
2398                                 udelay(chip->chip_delay);
2399                         else
2400                                 nand_wait_ready(mtd);
2401                 }
2402
2403                 readlen -= len;
2404                 if (!readlen)
2405                         break;
2406
2407                 /* Increment page address */
2408                 realpage++;
2409
2410                 page = realpage & chip->pagemask;
2411                 /* Check, if we cross a chip boundary */
2412                 if (!page) {
2413                         chipnr++;
2414                         chip->select_chip(mtd, -1);
2415                         chip->select_chip(mtd, chipnr);
2416                 }
2417         }
2418         chip->select_chip(mtd, -1);
2419
2420         ops->oobretlen = ops->ooblen - readlen;
2421
2422         if (ret < 0)
2423                 return ret;
2424
2425         if (mtd->ecc_stats.failed - stats.failed)
2426                 return -EBADMSG;
2427
2428         return  mtd->ecc_stats.corrected - stats.corrected ? -EUCLEAN : 0;
2429 }
2430
2431 /**
2432  * nand_read_oob - [MTD Interface] NAND read data and/or out-of-band
2433  * @mtd: MTD device structure
2434  * @from: offset to read from
2435  * @ops: oob operation description structure
2436  *
2437  * NAND read data and/or out-of-band data.
2438  */
2439 static int nand_read_oob(struct mtd_info *mtd, loff_t from,
2440                          struct mtd_oob_ops *ops)
2441 {
2442         int ret;
2443
2444         ops->retlen = 0;
2445
2446         /* Do not allow reads past end of device */
2447         if (ops->datbuf && (from + ops->len) > mtd->size) {
2448                 pr_debug("%s: attempt to read beyond end of device\n",
2449                                 __func__);
2450                 return -EINVAL;
2451         }
2452
2453         if (ops->mode != MTD_OPS_PLACE_OOB &&
2454             ops->mode != MTD_OPS_AUTO_OOB &&
2455             ops->mode != MTD_OPS_RAW)
2456                 return -ENOTSUPP;
2457
2458         nand_get_device(mtd, FL_READING);
2459
2460         if (!ops->datbuf)
2461                 ret = nand_do_read_oob(mtd, from, ops);
2462         else
2463                 ret = nand_do_read_ops(mtd, from, ops);
2464
2465         nand_release_device(mtd);
2466         return ret;
2467 }
2468
2469
2470 /**
2471  * nand_write_page_raw - [INTERN] raw page write function
2472  * @mtd: mtd info structure
2473  * @chip: nand chip info structure
2474  * @buf: data buffer
2475  * @oob_required: must write chip->oob_poi to OOB
2476  * @page: page number to write
2477  *
2478  * Not for syndrome calculating ECC controllers, which use a special oob layout.
2479  */
2480 int nand_write_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
2481                         const uint8_t *buf, int oob_required, int page)
2482 {
2483         chip->write_buf(mtd, buf, mtd->writesize);
2484         if (oob_required)
2485                 chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
2486
2487         return 0;
2488 }
2489 EXPORT_SYMBOL(nand_write_page_raw);
2490
2491 /**
2492  * nand_write_page_raw_syndrome - [INTERN] raw page write function
2493  * @mtd: mtd info structure
2494  * @chip: nand chip info structure
2495  * @buf: data buffer
2496  * @oob_required: must write chip->oob_poi to OOB
2497  * @page: page number to write
2498  *
2499  * We need a special oob layout and handling even when ECC isn't checked.
2500  */
2501 static int nand_write_page_raw_syndrome(struct mtd_info *mtd,
2502                                         struct nand_chip *chip,
2503                                         const uint8_t *buf, int oob_required,
2504                                         int page)
2505 {
2506         int eccsize = chip->ecc.size;
2507         int eccbytes = chip->ecc.bytes;
2508         uint8_t *oob = chip->oob_poi;
2509         int steps, size;
2510
2511         for (steps = chip->ecc.steps; steps > 0; steps--) {
2512                 chip->write_buf(mtd, buf, eccsize);
2513                 buf += eccsize;
2514
2515                 if (chip->ecc.prepad) {
2516                         chip->write_buf(mtd, oob, chip->ecc.prepad);
2517                         oob += chip->ecc.prepad;
2518                 }
2519
2520                 chip->write_buf(mtd, oob, eccbytes);
2521                 oob += eccbytes;
2522
2523                 if (chip->ecc.postpad) {
2524                         chip->write_buf(mtd, oob, chip->ecc.postpad);
2525                         oob += chip->ecc.postpad;
2526                 }
2527         }
2528
2529         size = mtd->oobsize - (oob - chip->oob_poi);
2530         if (size)
2531                 chip->write_buf(mtd, oob, size);
2532
2533         return 0;
2534 }
2535 /**
2536  * nand_write_page_swecc - [REPLACEABLE] software ECC based page write function
2537  * @mtd: mtd info structure
2538  * @chip: nand chip info structure
2539  * @buf: data buffer
2540  * @oob_required: must write chip->oob_poi to OOB
2541  * @page: page number to write
2542  */
2543 static int nand_write_page_swecc(struct mtd_info *mtd, struct nand_chip *chip,
2544                                  const uint8_t *buf, int oob_required,
2545                                  int page)
2546 {
2547         int i, eccsize = chip->ecc.size, ret;
2548         int eccbytes = chip->ecc.bytes;
2549         int eccsteps = chip->ecc.steps;
2550         uint8_t *ecc_calc = chip->buffers->ecccalc;
2551         const uint8_t *p = buf;
2552
2553         /* Software ECC calculation */
2554         for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize)
2555                 chip->ecc.calculate(mtd, p, &ecc_calc[i]);
2556
2557         ret = mtd_ooblayout_set_eccbytes(mtd, ecc_calc, chip->oob_poi, 0,
2558                                          chip->ecc.total);
2559         if (ret)
2560                 return ret;
2561
2562         return chip->ecc.write_page_raw(mtd, chip, buf, 1, page);
2563 }
2564
2565 /**
2566  * nand_write_page_hwecc - [REPLACEABLE] hardware ECC based page write function
2567  * @mtd: mtd info structure
2568  * @chip: nand chip info structure
2569  * @buf: data buffer
2570  * @oob_required: must write chip->oob_poi to OOB
2571  * @page: page number to write
2572  */
2573 static int nand_write_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip,
2574                                   const uint8_t *buf, int oob_required,
2575                                   int page)
2576 {
2577         int i, eccsize = chip->ecc.size, ret;
2578         int eccbytes = chip->ecc.bytes;
2579         int eccsteps = chip->ecc.steps;
2580         uint8_t *ecc_calc = chip->buffers->ecccalc;
2581         const uint8_t *p = buf;
2582
2583         for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
2584                 chip->ecc.hwctl(mtd, NAND_ECC_WRITE);
2585                 chip->write_buf(mtd, p, eccsize);
2586                 chip->ecc.calculate(mtd, p, &ecc_calc[i]);
2587         }
2588
2589         ret = mtd_ooblayout_set_eccbytes(mtd, ecc_calc, chip->oob_poi, 0,
2590                                          chip->ecc.total);
2591         if (ret)
2592                 return ret;
2593
2594         chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
2595
2596         return 0;
2597 }
2598
2599
2600 /**
2601  * nand_write_subpage_hwecc - [REPLACEABLE] hardware ECC based subpage write
2602  * @mtd:        mtd info structure
2603  * @chip:       nand chip info structure
2604  * @offset:     column address of subpage within the page
2605  * @data_len:   data length
2606  * @buf:        data buffer
2607  * @oob_required: must write chip->oob_poi to OOB
2608  * @page: page number to write
2609  */
2610 static int nand_write_subpage_hwecc(struct mtd_info *mtd,
2611                                 struct nand_chip *chip, uint32_t offset,
2612                                 uint32_t data_len, const uint8_t *buf,
2613                                 int oob_required, int page)
2614 {
2615         uint8_t *oob_buf  = chip->oob_poi;
2616         uint8_t *ecc_calc = chip->buffers->ecccalc;
2617         int ecc_size      = chip->ecc.size;
2618         int ecc_bytes     = chip->ecc.bytes;
2619         int ecc_steps     = chip->ecc.steps;
2620         uint32_t start_step = offset / ecc_size;
2621         uint32_t end_step   = (offset + data_len - 1) / ecc_size;
2622         int oob_bytes       = mtd->oobsize / ecc_steps;
2623         int step, ret;
2624
2625         for (step = 0; step < ecc_steps; step++) {
2626                 /* configure controller for WRITE access */
2627                 chip->ecc.hwctl(mtd, NAND_ECC_WRITE);
2628
2629                 /* write data (untouched subpages already masked by 0xFF) */
2630                 chip->write_buf(mtd, buf, ecc_size);
2631
2632                 /* mask ECC of un-touched subpages by padding 0xFF */
2633                 if ((step < start_step) || (step > end_step))
2634                         memset(ecc_calc, 0xff, ecc_bytes);
2635                 else
2636                         chip->ecc.calculate(mtd, buf, ecc_calc);
2637
2638                 /* mask OOB of un-touched subpages by padding 0xFF */
2639                 /* if oob_required, preserve OOB metadata of written subpage */
2640                 if (!oob_required || (step < start_step) || (step > end_step))
2641                         memset(oob_buf, 0xff, oob_bytes);
2642
2643                 buf += ecc_size;
2644                 ecc_calc += ecc_bytes;
2645                 oob_buf  += oob_bytes;
2646         }
2647
2648         /* copy calculated ECC for whole page to chip->buffer->oob */
2649         /* this include masked-value(0xFF) for unwritten subpages */
2650         ecc_calc = chip->buffers->ecccalc;
2651         ret = mtd_ooblayout_set_eccbytes(mtd, ecc_calc, chip->oob_poi, 0,
2652                                          chip->ecc.total);
2653         if (ret)
2654                 return ret;
2655
2656         /* write OOB buffer to NAND device */
2657         chip->write_buf(mtd, chip->oob_poi, mtd->oobsize);
2658
2659         return 0;
2660 }
2661
2662
2663 /**
2664  * nand_write_page_syndrome - [REPLACEABLE] hardware ECC syndrome based page write
2665  * @mtd: mtd info structure
2666  * @chip: nand chip info structure
2667  * @buf: data buffer
2668  * @oob_required: must write chip->oob_poi to OOB
2669  * @page: page number to write
2670  *
2671  * The hw generator calculates the error syndrome automatically. Therefore we
2672  * need a special oob layout and handling.
2673  */
2674 static int nand_write_page_syndrome(struct mtd_info *mtd,
2675                                     struct nand_chip *chip,
2676                                     const uint8_t *buf, int oob_required,
2677                                     int page)
2678 {
2679         int i, eccsize = chip->ecc.size;
2680         int eccbytes = chip->ecc.bytes;
2681         int eccsteps = chip->ecc.steps;
2682         const uint8_t *p = buf;
2683         uint8_t *oob = chip->oob_poi;
2684
2685         for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
2686
2687                 chip->ecc.hwctl(mtd, NAND_ECC_WRITE);
2688                 chip->write_buf(mtd, p, eccsize);
2689
2690                 if (chip->ecc.prepad) {
2691                         chip->write_buf(mtd, oob, chip->ecc.prepad);
2692                         oob += chip->ecc.prepad;
2693                 }
2694
2695                 chip->ecc.calculate(mtd, p, oob);
2696                 chip->write_buf(mtd, oob, eccbytes);
2697                 oob += eccbytes;
2698
2699                 if (chip->ecc.postpad) {
2700                         chip->write_buf(mtd, oob, chip->ecc.postpad);
2701                         oob += chip->ecc.postpad;
2702                 }
2703         }
2704
2705         /* Calculate remaining oob bytes */
2706         i = mtd->oobsize - (oob - chip->oob_poi);
2707         if (i)
2708                 chip->write_buf(mtd, oob, i);
2709
2710         return 0;
2711 }
2712
2713 /**
2714  * nand_write_page - write one page
2715  * @mtd: MTD device structure
2716  * @chip: NAND chip descriptor
2717  * @offset: address offset within the page
2718  * @data_len: length of actual data to be written
2719  * @buf: the data to write
2720  * @oob_required: must write chip->oob_poi to OOB
2721  * @page: page number to write
2722  * @cached: cached programming
2723  * @raw: use _raw version of write_page
2724  */
2725 static int nand_write_page(struct mtd_info *mtd, struct nand_chip *chip,
2726                 uint32_t offset, int data_len, const uint8_t *buf,
2727                 int oob_required, int page, int cached, int raw)
2728 {
2729         int status, subpage;
2730
2731         if (!(chip->options & NAND_NO_SUBPAGE_WRITE) &&
2732                 chip->ecc.write_subpage)
2733                 subpage = offset || (data_len < mtd->writesize);
2734         else
2735                 subpage = 0;
2736
2737         if (nand_standard_page_accessors(&chip->ecc))
2738                 chip->cmdfunc(mtd, NAND_CMD_SEQIN, 0x00, page);
2739
2740         if (unlikely(raw))
2741                 status = chip->ecc.write_page_raw(mtd, chip, buf,
2742                                                   oob_required, page);
2743         else if (subpage)
2744                 status = chip->ecc.write_subpage(mtd, chip, offset, data_len,
2745                                                  buf, oob_required, page);
2746         else
2747                 status = chip->ecc.write_page(mtd, chip, buf, oob_required,
2748                                               page);
2749
2750         if (status < 0)
2751                 return status;
2752
2753         /*
2754          * Cached progamming disabled for now. Not sure if it's worth the
2755          * trouble. The speed gain is not very impressive. (2.3->2.6Mib/s).
2756          */
2757         cached = 0;
2758
2759         if (!cached || !NAND_HAS_CACHEPROG(chip)) {
2760
2761                 if (nand_standard_page_accessors(&chip->ecc))
2762                         chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
2763                 status = chip->waitfunc(mtd, chip);
2764                 /*
2765                  * See if operation failed and additional status checks are
2766                  * available.
2767                  */
2768                 if ((status & NAND_STATUS_FAIL) && (chip->errstat))
2769                         status = chip->errstat(mtd, chip, FL_WRITING, status,
2770                                                page);
2771
2772                 if (status & NAND_STATUS_FAIL)
2773                         return -EIO;
2774         } else {
2775                 chip->cmdfunc(mtd, NAND_CMD_CACHEDPROG, -1, -1);
2776                 status = chip->waitfunc(mtd, chip);
2777         }
2778
2779         return 0;
2780 }
2781
2782 /**
2783  * nand_fill_oob - [INTERN] Transfer client buffer to oob
2784  * @mtd: MTD device structure
2785  * @oob: oob data buffer
2786  * @len: oob data write length
2787  * @ops: oob ops structure
2788  */
2789 static uint8_t *nand_fill_oob(struct mtd_info *mtd, uint8_t *oob, size_t len,
2790                               struct mtd_oob_ops *ops)
2791 {
2792         struct nand_chip *chip = mtd_to_nand(mtd);
2793         int ret;
2794
2795         /*
2796          * Initialise to all 0xFF, to avoid the possibility of left over OOB
2797          * data from a previous OOB read.
2798          */
2799         memset(chip->oob_poi, 0xff, mtd->oobsize);
2800
2801         switch (ops->mode) {
2802
2803         case MTD_OPS_PLACE_OOB:
2804         case MTD_OPS_RAW:
2805                 memcpy(chip->oob_poi + ops->ooboffs, oob, len);
2806                 return oob + len;
2807
2808         case MTD_OPS_AUTO_OOB:
2809                 ret = mtd_ooblayout_set_databytes(mtd, oob, chip->oob_poi,
2810                                                   ops->ooboffs, len);
2811                 BUG_ON(ret);
2812                 return oob + len;
2813
2814         default:
2815                 BUG();
2816         }
2817         return NULL;
2818 }
2819
2820 #define NOTALIGNED(x)   ((x & (chip->subpagesize - 1)) != 0)
2821
2822 /**
2823  * nand_do_write_ops - [INTERN] NAND write with ECC
2824  * @mtd: MTD device structure
2825  * @to: offset to write to
2826  * @ops: oob operations description structure
2827  *
2828  * NAND write with ECC.
2829  */
2830 static int nand_do_write_ops(struct mtd_info *mtd, loff_t to,
2831                              struct mtd_oob_ops *ops)
2832 {
2833         int chipnr, realpage, page, blockmask, column;
2834         struct nand_chip *chip = mtd_to_nand(mtd);
2835         uint32_t writelen = ops->len;
2836
2837         uint32_t oobwritelen = ops->ooblen;
2838         uint32_t oobmaxlen = mtd_oobavail(mtd, ops);
2839
2840         uint8_t *oob = ops->oobbuf;
2841         uint8_t *buf = ops->datbuf;
2842         int ret;
2843         int oob_required = oob ? 1 : 0;
2844
2845         ops->retlen = 0;
2846         if (!writelen)
2847                 return 0;
2848
2849         /* Reject writes, which are not page aligned */
2850         if (NOTALIGNED(to) || NOTALIGNED(ops->len)) {
2851                 pr_notice("%s: attempt to write non page aligned data\n",
2852                            __func__);
2853                 return -EINVAL;
2854         }
2855
2856         column = to & (mtd->writesize - 1);
2857
2858         chipnr = (int)(to >> chip->chip_shift);
2859         chip->select_chip(mtd, chipnr);
2860
2861         /* Check, if it is write protected */
2862         if (nand_check_wp(mtd)) {
2863                 ret = -EIO;
2864                 goto err_out;
2865         }
2866
2867         realpage = (int)(to >> chip->page_shift);
2868         page = realpage & chip->pagemask;
2869         blockmask = (1 << (chip->phys_erase_shift - chip->page_shift)) - 1;
2870
2871         /* Invalidate the page cache, when we write to the cached page */
2872         if (to <= ((loff_t)chip->pagebuf << chip->page_shift) &&
2873             ((loff_t)chip->pagebuf << chip->page_shift) < (to + ops->len))
2874                 chip->pagebuf = -1;
2875
2876         /* Don't allow multipage oob writes with offset */
2877         if (oob && ops->ooboffs && (ops->ooboffs + ops->ooblen > oobmaxlen)) {
2878                 ret = -EINVAL;
2879                 goto err_out;
2880         }
2881
2882         while (1) {
2883                 int bytes = mtd->writesize;
2884                 int cached = writelen > bytes && page != blockmask;
2885                 uint8_t *wbuf = buf;
2886                 int use_bufpoi;
2887                 int part_pagewr = (column || writelen < mtd->writesize);
2888
2889                 if (part_pagewr)
2890                         use_bufpoi = 1;
2891                 else if (chip->options & NAND_USE_BOUNCE_BUFFER)
2892                         use_bufpoi = !virt_addr_valid(buf) ||
2893                                      !IS_ALIGNED((unsigned long)buf,
2894                                                  chip->buf_align);
2895                 else
2896                         use_bufpoi = 0;
2897
2898                 /* Partial page write?, or need to use bounce buffer */
2899                 if (use_bufpoi) {
2900                         pr_debug("%s: using write bounce buffer for buf@%p\n",
2901                                          __func__, buf);
2902                         cached = 0;
2903                         if (part_pagewr)
2904                                 bytes = min_t(int, bytes - column, writelen);
2905                         chip->pagebuf = -1;
2906                         memset(chip->buffers->databuf, 0xff, mtd->writesize);
2907                         memcpy(&chip->buffers->databuf[column], buf, bytes);
2908                         wbuf = chip->buffers->databuf;
2909                 }
2910
2911                 if (unlikely(oob)) {
2912                         size_t len = min(oobwritelen, oobmaxlen);
2913                         oob = nand_fill_oob(mtd, oob, len, ops);
2914                         oobwritelen -= len;
2915                 } else {
2916                         /* We still need to erase leftover OOB data */
2917                         memset(chip->oob_poi, 0xff, mtd->oobsize);
2918                 }
2919
2920                 ret = nand_write_page(mtd, chip, column, bytes, wbuf,
2921                                       oob_required, page, cached,
2922                                       (ops->mode == MTD_OPS_RAW));
2923                 if (ret)
2924                         break;
2925
2926                 writelen -= bytes;
2927                 if (!writelen)
2928                         break;
2929
2930                 column = 0;
2931                 buf += bytes;
2932                 realpage++;
2933
2934                 page = realpage & chip->pagemask;
2935                 /* Check, if we cross a chip boundary */
2936                 if (!page) {
2937                         chipnr++;
2938                         chip->select_chip(mtd, -1);
2939                         chip->select_chip(mtd, chipnr);
2940                 }
2941         }
2942
2943         ops->retlen = ops->len - writelen;
2944         if (unlikely(oob))
2945                 ops->oobretlen = ops->ooblen;
2946
2947 err_out:
2948         chip->select_chip(mtd, -1);
2949         return ret;
2950 }
2951
2952 /**
2953  * panic_nand_write - [MTD Interface] NAND write with ECC
2954  * @mtd: MTD device structure
2955  * @to: offset to write to
2956  * @len: number of bytes to write
2957  * @retlen: pointer to variable to store the number of written bytes
2958  * @buf: the data to write
2959  *
2960  * NAND write with ECC. Used when performing writes in interrupt context, this
2961  * may for example be called by mtdoops when writing an oops while in panic.
2962  */
2963 static int panic_nand_write(struct mtd_info *mtd, loff_t to, size_t len,
2964                             size_t *retlen, const uint8_t *buf)
2965 {
2966         struct nand_chip *chip = mtd_to_nand(mtd);
2967         struct mtd_oob_ops ops;
2968         int ret;
2969
2970         /* Wait for the device to get ready */
2971         panic_nand_wait(mtd, chip, 400);
2972
2973         /* Grab the device */
2974         panic_nand_get_device(chip, mtd, FL_WRITING);
2975
2976         memset(&ops, 0, sizeof(ops));
2977         ops.len = len;
2978         ops.datbuf = (uint8_t *)buf;
2979         ops.mode = MTD_OPS_PLACE_OOB;
2980
2981         ret = nand_do_write_ops(mtd, to, &ops);
2982
2983         *retlen = ops.retlen;
2984         return ret;
2985 }
2986
2987 /**
2988  * nand_write - [MTD Interface] NAND write with ECC
2989  * @mtd: MTD device structure
2990  * @to: offset to write to
2991  * @len: number of bytes to write
2992  * @retlen: pointer to variable to store the number of written bytes
2993  * @buf: the data to write
2994  *
2995  * NAND write with ECC.
2996  */
2997 static int nand_write(struct mtd_info *mtd, loff_t to, size_t len,
2998                           size_t *retlen, const uint8_t *buf)
2999 {
3000         struct mtd_oob_ops ops;
3001         int ret;
3002
3003         nand_get_device(mtd, FL_WRITING);
3004         memset(&ops, 0, sizeof(ops));
3005         ops.len = len;
3006         ops.datbuf = (uint8_t *)buf;
3007         ops.mode = MTD_OPS_PLACE_OOB;
3008         ret = nand_do_write_ops(mtd, to, &ops);
3009         *retlen = ops.retlen;
3010         nand_release_device(mtd);
3011         return ret;
3012 }
3013
3014 /**
3015  * nand_do_write_oob - [MTD Interface] NAND write out-of-band
3016  * @mtd: MTD device structure
3017  * @to: offset to write to
3018  * @ops: oob operation description structure
3019  *
3020  * NAND write out-of-band.
3021  */
3022 static int nand_do_write_oob(struct mtd_info *mtd, loff_t to,
3023                              struct mtd_oob_ops *ops)
3024 {
3025         int chipnr, page, status, len;
3026         struct nand_chip *chip = mtd_to_nand(mtd);
3027
3028         pr_debug("%s: to = 0x%08x, len = %i\n",
3029                          __func__, (unsigned int)to, (int)ops->ooblen);
3030
3031         len = mtd_oobavail(mtd, ops);
3032
3033         /* Do not allow write past end of page */
3034         if ((ops->ooboffs + ops->ooblen) > len) {
3035                 pr_debug("%s: attempt to write past end of page\n",
3036                                 __func__);
3037                 return -EINVAL;
3038         }
3039
3040         if (unlikely(ops->ooboffs >= len)) {
3041                 pr_debug("%s: attempt to start write outside oob\n",
3042                                 __func__);
3043                 return -EINVAL;
3044         }
3045
3046         /* Do not allow write past end of device */
3047         if (unlikely(to >= mtd->size ||
3048                      ops->ooboffs + ops->ooblen >
3049                         ((mtd->size >> chip->page_shift) -
3050                          (to >> chip->page_shift)) * len)) {
3051                 pr_debug("%s: attempt to write beyond end of device\n",
3052                                 __func__);
3053                 return -EINVAL;
3054         }
3055
3056         chipnr = (int)(to >> chip->chip_shift);
3057
3058         /*
3059          * Reset the chip. Some chips (like the Toshiba TC5832DC found in one
3060          * of my DiskOnChip 2000 test units) will clear the whole data page too
3061          * if we don't do this. I have no clue why, but I seem to have 'fixed'
3062          * it in the doc2000 driver in August 1999.  dwmw2.
3063          */
3064         nand_reset(chip, chipnr);
3065
3066         chip->select_chip(mtd, chipnr);
3067
3068         /* Shift to get page */
3069         page = (int)(to >> chip->page_shift);
3070
3071         /* Check, if it is write protected */
3072         if (nand_check_wp(mtd)) {
3073                 chip->select_chip(mtd, -1);
3074                 return -EROFS;
3075         }
3076
3077         /* Invalidate the page cache, if we write to the cached page */
3078         if (page == chip->pagebuf)
3079                 chip->pagebuf = -1;
3080
3081         nand_fill_oob(mtd, ops->oobbuf, ops->ooblen, ops);
3082
3083         if (ops->mode == MTD_OPS_RAW)
3084                 status = chip->ecc.write_oob_raw(mtd, chip, page & chip->pagemask);
3085         else
3086                 status = chip->ecc.write_oob(mtd, chip, page & chip->pagemask);
3087
3088         chip->select_chip(mtd, -1);
3089
3090         if (status)
3091                 return status;
3092
3093         ops->oobretlen = ops->ooblen;
3094
3095         return 0;
3096 }
3097
3098 /**
3099  * nand_write_oob - [MTD Interface] NAND write data and/or out-of-band
3100  * @mtd: MTD device structure
3101  * @to: offset to write to
3102  * @ops: oob operation description structure
3103  */
3104 static int nand_write_oob(struct mtd_info *mtd, loff_t to,
3105                           struct mtd_oob_ops *ops)
3106 {
3107         int ret = -ENOTSUPP;
3108
3109         ops->retlen = 0;
3110
3111         /* Do not allow writes past end of device */
3112         if (ops->datbuf && (to + ops->len) > mtd->size) {
3113                 pr_debug("%s: attempt to write beyond end of device\n",
3114                                 __func__);
3115                 return -EINVAL;
3116         }
3117
3118         nand_get_device(mtd, FL_WRITING);
3119
3120         switch (ops->mode) {
3121         case MTD_OPS_PLACE_OOB:
3122         case MTD_OPS_AUTO_OOB:
3123         case MTD_OPS_RAW:
3124                 break;
3125
3126         default:
3127                 goto out;
3128         }
3129
3130         if (!ops->datbuf)
3131                 ret = nand_do_write_oob(mtd, to, ops);
3132         else
3133                 ret = nand_do_write_ops(mtd, to, ops);
3134
3135 out:
3136         nand_release_device(mtd);
3137         return ret;
3138 }
3139
3140 /**
3141  * single_erase - [GENERIC] NAND standard block erase command function
3142  * @mtd: MTD device structure
3143  * @page: the page address of the block which will be erased
3144  *
3145  * Standard erase command for NAND chips. Returns NAND status.
3146  */
3147 static int single_erase(struct mtd_info *mtd, int page)
3148 {
3149         struct nand_chip *chip = mtd_to_nand(mtd);
3150         /* Send commands to erase a block */
3151         chip->cmdfunc(mtd, NAND_CMD_ERASE1, -1, page);
3152         chip->cmdfunc(mtd, NAND_CMD_ERASE2, -1, -1);
3153
3154         return chip->waitfunc(mtd, chip);
3155 }
3156
3157 /**
3158  * nand_erase - [MTD Interface] erase block(s)
3159  * @mtd: MTD device structure
3160  * @instr: erase instruction
3161  *
3162  * Erase one ore more blocks.
3163  */
3164 static int nand_erase(struct mtd_info *mtd, struct erase_info *instr)
3165 {
3166         return nand_erase_nand(mtd, instr, 0);
3167 }
3168
3169 /**
3170  * nand_erase_nand - [INTERN] erase block(s)
3171  * @mtd: MTD device structure
3172  * @instr: erase instruction
3173  * @allowbbt: allow erasing the bbt area
3174  *
3175  * Erase one ore more blocks.
3176  */
3177 int nand_erase_nand(struct mtd_info *mtd, struct erase_info *instr,
3178                     int allowbbt)
3179 {
3180         int page, status, pages_per_block, ret, chipnr;
3181         struct nand_chip *chip = mtd_to_nand(mtd);
3182         loff_t len;
3183
3184         pr_debug("%s: start = 0x%012llx, len = %llu\n",
3185                         __func__, (unsigned long long)instr->addr,
3186                         (unsigned long long)instr->len);
3187
3188         if (check_offs_len(mtd, instr->addr, instr->len))
3189                 return -EINVAL;
3190
3191         /* Grab the lock and see if the device is available */
3192         nand_get_device(mtd, FL_ERASING);
3193
3194         /* Shift to get first page */
3195         page = (int)(instr->addr >> chip->page_shift);
3196         chipnr = (int)(instr->addr >> chip->chip_shift);
3197
3198         /* Calculate pages in each block */
3199         pages_per_block = 1 << (chip->phys_erase_shift - chip->page_shift);
3200
3201         /* Select the NAND device */
3202         chip->select_chip(mtd, chipnr);
3203
3204         /* Check, if it is write protected */
3205         if (nand_check_wp(mtd)) {
3206                 pr_debug("%s: device is write protected!\n",
3207                                 __func__);
3208                 instr->state = MTD_ERASE_FAILED;
3209                 goto erase_exit;
3210         }
3211
3212         /* Loop through the pages */
3213         len = instr->len;
3214
3215         instr->state = MTD_ERASING;
3216
3217         while (len) {
3218                 /* Check if we have a bad block, we do not erase bad blocks! */
3219                 if (nand_block_checkbad(mtd, ((loff_t) page) <<
3220                                         chip->page_shift, allowbbt)) {
3221                         pr_warn("%s: attempt to erase a bad block at page 0x%08x\n",
3222                                     __func__, page);
3223                         instr->state = MTD_ERASE_FAILED;
3224                         goto erase_exit;
3225                 }
3226
3227                 /*
3228                  * Invalidate the page cache, if we erase the block which
3229                  * contains the current cached page.
3230                  */
3231                 if (page <= chip->pagebuf && chip->pagebuf <
3232                     (page + pages_per_block))
3233                         chip->pagebuf = -1;
3234
3235                 status = chip->erase(mtd, page & chip->pagemask);
3236
3237                 /*
3238                  * See if operation failed and additional status checks are
3239                  * available
3240                  */
3241                 if ((status & NAND_STATUS_FAIL) && (chip->errstat))
3242                         status = chip->errstat(mtd, chip, FL_ERASING,
3243                                                status, page);
3244
3245                 /* See if block erase succeeded */
3246                 if (status & NAND_STATUS_FAIL) {
3247                         pr_debug("%s: failed erase, page 0x%08x\n",
3248                                         __func__, page);
3249                         instr->state = MTD_ERASE_FAILED;
3250                         instr->fail_addr =
3251                                 ((loff_t)page << chip->page_shift);
3252                         goto erase_exit;
3253                 }
3254
3255                 /* Increment page address and decrement length */
3256                 len -= (1ULL << chip->phys_erase_shift);
3257                 page += pages_per_block;
3258
3259                 /* Check, if we cross a chip boundary */
3260                 if (len && !(page & chip->pagemask)) {
3261                         chipnr++;
3262                         chip->select_chip(mtd, -1);
3263                         chip->select_chip(mtd, chipnr);
3264                 }
3265         }
3266         instr->state = MTD_ERASE_DONE;
3267
3268 erase_exit:
3269
3270         ret = instr->state == MTD_ERASE_DONE ? 0 : -EIO;
3271
3272         /* Deselect and wake up anyone waiting on the device */
3273         chip->select_chip(mtd, -1);
3274         nand_release_device(mtd);
3275
3276         /* Do call back function */
3277         if (!ret)
3278                 mtd_erase_callback(instr);
3279
3280         /* Return more or less happy */
3281         return ret;
3282 }
3283
3284 /**
3285  * nand_sync - [MTD Interface] sync
3286  * @mtd: MTD device structure
3287  *
3288  * Sync is actually a wait for chip ready function.
3289  */
3290 static void nand_sync(struct mtd_info *mtd)
3291 {
3292         pr_debug("%s: called\n", __func__);
3293
3294         /* Grab the lock and see if the device is available */
3295         nand_get_device(mtd, FL_SYNCING);
3296         /* Release it and go back */
3297         nand_release_device(mtd);
3298 }
3299
3300 /**
3301  * nand_block_isbad - [MTD Interface] Check if block at offset is bad
3302  * @mtd: MTD device structure
3303  * @offs: offset relative to mtd start
3304  */
3305 static int nand_block_isbad(struct mtd_info *mtd, loff_t offs)
3306 {
3307         struct nand_chip *chip = mtd_to_nand(mtd);
3308         int chipnr = (int)(offs >> chip->chip_shift);
3309         int ret;
3310
3311         /* Select the NAND device */
3312         nand_get_device(mtd, FL_READING);
3313         chip->select_chip(mtd, chipnr);
3314
3315         ret = nand_block_checkbad(mtd, offs, 0);
3316
3317         chip->select_chip(mtd, -1);
3318         nand_release_device(mtd);
3319
3320         return ret;
3321 }
3322
3323 /**
3324  * nand_block_markbad - [MTD Interface] Mark block at the given offset as bad
3325  * @mtd: MTD device structure
3326  * @ofs: offset relative to mtd start
3327  */
3328 static int nand_block_markbad(struct mtd_info *mtd, loff_t ofs)
3329 {
3330         int ret;
3331
3332         ret = nand_block_isbad(mtd, ofs);
3333         if (ret) {
3334                 /* If it was bad already, return success and do nothing */
3335                 if (ret > 0)