2 * Copyright (C) 2009-2012 Semihalf
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 /* Generic NAND driver */
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
32 #include <sys/param.h>
33 #include <sys/systm.h>
37 #include <sys/endian.h>
38 #include <sys/kernel.h>
39 #include <sys/module.h>
42 #include <sys/mutex.h>
44 #include <sys/malloc.h>
46 #include <dev/nand/nand.h>
47 #include <dev/nand/nandbus.h>
50 #include "nandbus_if.h"
53 static int onfi_nand_probe(device_t dev);
54 static int large_nand_probe(device_t dev);
55 static int small_nand_probe(device_t dev);
56 static int generic_nand_attach(device_t dev);
57 static int generic_nand_detach(device_t dev);
59 static int generic_erase_block(device_t, uint32_t);
60 static int generic_erase_block_intlv(device_t, uint32_t);
61 static int generic_read_page (device_t, uint32_t, void *, uint32_t, uint32_t);
62 static int generic_read_oob(device_t, uint32_t, void *, uint32_t, uint32_t);
63 static int generic_program_page(device_t, uint32_t, void *, uint32_t, uint32_t);
64 static int generic_program_page_intlv(device_t, uint32_t, void *, uint32_t,
66 static int generic_program_oob(device_t, uint32_t, void *, uint32_t, uint32_t);
67 static int generic_is_blk_bad(device_t, uint32_t, uint8_t *);
68 static int generic_get_ecc(device_t, void *, void *, int *);
69 static int generic_correct_ecc(device_t, void *, void *, void *);
71 static int small_read_page(device_t, uint32_t, void *, uint32_t, uint32_t);
72 static int small_read_oob(device_t, uint32_t, void *, uint32_t, uint32_t);
73 static int small_program_page(device_t, uint32_t, void *, uint32_t, uint32_t);
74 static int small_program_oob(device_t, uint32_t, void *, uint32_t, uint32_t);
76 static int onfi_is_blk_bad(device_t, uint32_t, uint8_t *);
77 static int onfi_read_parameter(struct nand_chip *, struct onfi_chip_params *);
79 static int nand_send_address(device_t, int32_t, int32_t, int8_t);
81 static device_method_t onand_methods[] = {
82 /* Device interface */
83 DEVMETHOD(device_probe, onfi_nand_probe),
84 DEVMETHOD(device_attach, generic_nand_attach),
85 DEVMETHOD(device_detach, generic_nand_detach),
87 DEVMETHOD(nand_read_page, generic_read_page),
88 DEVMETHOD(nand_program_page, generic_program_page),
89 DEVMETHOD(nand_program_page_intlv, generic_program_page_intlv),
90 DEVMETHOD(nand_read_oob, generic_read_oob),
91 DEVMETHOD(nand_program_oob, generic_program_oob),
92 DEVMETHOD(nand_erase_block, generic_erase_block),
93 DEVMETHOD(nand_erase_block_intlv, generic_erase_block_intlv),
95 DEVMETHOD(nand_is_blk_bad, onfi_is_blk_bad),
96 DEVMETHOD(nand_get_ecc, generic_get_ecc),
97 DEVMETHOD(nand_correct_ecc, generic_correct_ecc),
101 static device_method_t lnand_methods[] = {
102 /* Device interface */
103 DEVMETHOD(device_probe, large_nand_probe),
104 DEVMETHOD(device_attach, generic_nand_attach),
105 DEVMETHOD(device_detach, generic_nand_detach),
107 DEVMETHOD(nand_read_page, generic_read_page),
108 DEVMETHOD(nand_program_page, generic_program_page),
109 DEVMETHOD(nand_read_oob, generic_read_oob),
110 DEVMETHOD(nand_program_oob, generic_program_oob),
111 DEVMETHOD(nand_erase_block, generic_erase_block),
113 DEVMETHOD(nand_is_blk_bad, generic_is_blk_bad),
114 DEVMETHOD(nand_get_ecc, generic_get_ecc),
115 DEVMETHOD(nand_correct_ecc, generic_correct_ecc),
119 static device_method_t snand_methods[] = {
120 /* Device interface */
121 DEVMETHOD(device_probe, small_nand_probe),
122 DEVMETHOD(device_attach, generic_nand_attach),
123 DEVMETHOD(device_detach, generic_nand_detach),
125 DEVMETHOD(nand_read_page, small_read_page),
126 DEVMETHOD(nand_program_page, small_program_page),
127 DEVMETHOD(nand_read_oob, small_read_oob),
128 DEVMETHOD(nand_program_oob, small_program_oob),
129 DEVMETHOD(nand_erase_block, generic_erase_block),
131 DEVMETHOD(nand_is_blk_bad, generic_is_blk_bad),
132 DEVMETHOD(nand_get_ecc, generic_get_ecc),
133 DEVMETHOD(nand_correct_ecc, generic_correct_ecc),
137 devclass_t onand_devclass;
138 devclass_t lnand_devclass;
139 devclass_t snand_devclass;
141 driver_t onand_driver = {
144 sizeof(struct nand_chip)
147 driver_t lnand_driver = {
150 sizeof(struct nand_chip)
153 driver_t snand_driver = {
156 sizeof(struct nand_chip)
159 DRIVER_MODULE(onand, nandbus, onand_driver, onand_devclass, 0, 0);
160 DRIVER_MODULE(lnand, nandbus, lnand_driver, lnand_devclass, 0, 0);
161 DRIVER_MODULE(snand, nandbus, snand_driver, snand_devclass, 0, 0);
164 onfi_nand_probe(device_t dev)
166 struct nandbus_ivar *ivar;
168 ivar = device_get_ivars(dev);
169 if (ivar && ivar->is_onfi) {
170 device_set_desc(dev, "ONFI compliant NAND");
171 return (BUS_PROBE_DEFAULT);
178 large_nand_probe(device_t dev)
180 struct nandbus_ivar *ivar;
182 ivar = device_get_ivars(dev);
183 if (ivar && !ivar->is_onfi && ivar->params->page_size >= 512) {
184 device_set_desc(dev, ivar->params->name);
185 return (BUS_PROBE_DEFAULT);
192 small_nand_probe(device_t dev)
194 struct nandbus_ivar *ivar;
196 ivar = device_get_ivars(dev);
197 if (ivar && !ivar->is_onfi && ivar->params->page_size == 512) {
198 device_set_desc(dev, ivar->params->name);
199 return (BUS_PROBE_DEFAULT);
206 generic_nand_attach(device_t dev)
208 struct nand_chip *chip;
209 struct nandbus_ivar *ivar;
210 struct onfi_chip_params *onfi_chip_params;
211 device_t nandbus, nfc;
214 chip = device_get_softc(dev);
217 ivar = device_get_ivars(dev);
218 chip->id.man_id = ivar->man_id;
219 chip->id.dev_id = ivar->dev_id;
220 chip->num = ivar->cs;
222 /* TODO remove when HW ECC supported */
223 nandbus = device_get_parent(dev);
224 nfc = device_get_parent(nandbus);
226 chip->nand = device_get_softc(nfc);
229 onfi_chip_params = malloc(sizeof(struct onfi_chip_params),
230 M_NAND, M_WAITOK | M_ZERO);
232 if (onfi_read_parameter(chip, onfi_chip_params)) {
233 nand_debug(NDBG_GEN,"Could not read parameter page!\n");
234 free(onfi_chip_params, M_NAND);
238 nand_onfi_set_params(chip, onfi_chip_params);
239 /* Set proper column and row cycles */
240 ivar->cols = (onfi_chip_params->address_cycles >> 4) & 0xf;
241 ivar->rows = onfi_chip_params->address_cycles & 0xf;
242 free(onfi_chip_params, M_NAND);
245 nand_set_params(chip, ivar->params);
248 err = nand_init_stat(chip);
250 generic_nand_detach(dev);
254 err = nand_init_bbt(chip);
256 generic_nand_detach(dev);
260 err = nand_make_dev(chip);
262 generic_nand_detach(dev);
266 err = create_geom_disk(chip);
268 generic_nand_detach(dev);
276 generic_nand_detach(device_t dev)
278 struct nand_chip *chip;
280 chip = device_get_softc(dev);
282 nand_destroy_bbt(chip);
283 destroy_geom_disk(chip);
284 nand_destroy_dev(chip);
285 nand_destroy_stat(chip);
291 can_write(device_t nandbus)
295 if (NANDBUS_WAIT_READY(nandbus, &status))
298 if (!(status & NAND_STATUS_WP)) {
299 nand_debug(NDBG_GEN,"Chip is write-protected");
307 check_fail(device_t nandbus)
311 NANDBUS_WAIT_READY(nandbus, &status);
312 if (status & NAND_STATUS_FAIL) {
313 nand_debug(NDBG_GEN,"Status failed %x", status);
321 onfi_crc(const void *buf, size_t buflen)
325 const uint8_t *bufptr;
329 for (j = 0; j < buflen; j++) {
330 crc ^= *bufptr++ << 8;
331 for (i = 0; i < 8; i++)
333 crc = (crc << 1) ^ 0x8005;
341 onfi_read_parameter(struct nand_chip *chip, struct onfi_chip_params *chip_params)
344 struct onfi_params params;
345 int found, sigcount, trycopy;
347 nand_debug(NDBG_GEN,"read parameter");
349 nandbus = device_get_parent(chip->dev);
351 NANDBUS_SELECT_CS(nandbus, chip->num);
353 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_READ_PARAMETER))
356 if (nand_send_address(chip->dev, -1, -1, PAGE_PARAMETER_DEF))
359 if (NANDBUS_START_COMMAND(nandbus))
363 * XXX Bogus DELAY, we really need a nandbus_wait_ready() here, but it's
364 * not accessible from here (static to nandbus).
369 * The ONFI spec mandates a minimum of three copies of the parameter
370 * data, so loop up to 3 times trying to find good data. Each copy is
371 * validated by a signature of "ONFI" and a crc. There is a very strange
372 * rule that the signature is valid if any 2 of the 4 bytes are correct.
374 for (found= 0, trycopy = 0; !found && trycopy < 3; trycopy++) {
375 NANDBUS_READ_BUFFER(nandbus, ¶ms, sizeof(struct onfi_params));
376 sigcount = params.signature[0] == 'O';
377 sigcount += params.signature[1] == 'N';
378 sigcount += params.signature[2] == 'F';
379 sigcount += params.signature[3] == 'I';
382 if (onfi_crc(¶ms, 254) != params.crc)
389 chip_params->luns = params.luns;
390 chip_params->blocks_per_lun = le32dec(¶ms.blocks_per_lun);
391 chip_params->pages_per_block = le32dec(¶ms.pages_per_block);
392 chip_params->bytes_per_page = le32dec(¶ms.bytes_per_page);
393 chip_params->spare_bytes_per_page = le16dec(¶ms.spare_bytes_per_page);
394 chip_params->t_bers = le16dec(¶ms.t_bers);
395 chip_params->t_prog = le16dec(¶ms.t_prog);
396 chip_params->t_r = le16dec(¶ms.t_r);
397 chip_params->t_ccs = le16dec(¶ms.t_ccs);
398 chip_params->features = le16dec(¶ms.features);
399 chip_params->address_cycles = params.address_cycles;
405 send_read_page(device_t nand, uint8_t start_command, uint8_t end_command,
406 uint32_t row, uint32_t column)
408 device_t nandbus = device_get_parent(nand);
410 if (NANDBUS_SEND_COMMAND(nandbus, start_command))
413 if (nand_send_address(nand, row, column, -1))
416 if (NANDBUS_SEND_COMMAND(nandbus, end_command))
419 if (NANDBUS_START_COMMAND(nandbus))
426 generic_read_page(device_t nand, uint32_t page, void *buf, uint32_t len,
429 struct nand_chip *chip;
430 struct page_stat *pg_stat;
434 nand_debug(NDBG_GEN,"%p raw read page %x[%x] at %x", nand, page, len, offset);
435 chip = device_get_softc(nand);
436 nandbus = device_get_parent(nand);
438 if (nand_check_page_boundary(chip, page))
441 page_to_row(&chip->chip_geom, page, &row);
443 if (send_read_page(nand, NAND_CMD_READ, NAND_CMD_READ_END, row,
449 NANDBUS_READ_BUFFER(nandbus, buf, len);
451 if (check_fail(nandbus))
454 pg_stat = &(chip->pg_stat[page]);
455 pg_stat->page_raw_read++;
461 generic_read_oob(device_t nand, uint32_t page, void* buf, uint32_t len,
464 struct nand_chip *chip;
468 nand_debug(NDBG_GEN,"%p raw read oob %x[%x] at %x", nand, page, len, offset);
469 chip = device_get_softc(nand);
470 nandbus = device_get_parent(nand);
472 if (nand_check_page_boundary(chip, page)) {
473 nand_debug(NDBG_GEN,"page boundary check failed: %08x\n", page);
477 page_to_row(&chip->chip_geom, page, &row);
479 offset += chip->chip_geom.page_size;
481 if (send_read_page(nand, NAND_CMD_READ, NAND_CMD_READ_END, row,
487 NANDBUS_READ_BUFFER(nandbus, buf, len);
489 if (check_fail(nandbus))
496 send_start_program_page(device_t nand, uint32_t row, uint32_t column)
498 device_t nandbus = device_get_parent(nand);
500 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_PROG))
503 if (nand_send_address(nand, row, column, -1))
510 send_end_program_page(device_t nandbus, uint8_t end_command)
513 if (NANDBUS_SEND_COMMAND(nandbus, end_command))
516 if (NANDBUS_START_COMMAND(nandbus))
523 generic_program_page(device_t nand, uint32_t page, void *buf, uint32_t len,
526 struct nand_chip *chip;
527 struct page_stat *pg_stat;
531 nand_debug(NDBG_GEN,"%p raw prog page %x[%x] at %x", nand, page, len,
533 chip = device_get_softc(nand);
534 nandbus = device_get_parent(nand);
536 if (nand_check_page_boundary(chip, page))
539 page_to_row(&chip->chip_geom, page, &row);
541 if (!can_write(nandbus))
544 if (send_start_program_page(nand, row, offset))
547 NANDBUS_WRITE_BUFFER(nandbus, buf, len);
549 if (send_end_program_page(nandbus, NAND_CMD_PROG_END))
554 if (check_fail(nandbus))
557 pg_stat = &(chip->pg_stat[page]);
558 pg_stat->page_raw_written++;
564 generic_program_page_intlv(device_t nand, uint32_t page, void *buf,
565 uint32_t len, uint32_t offset)
567 struct nand_chip *chip;
568 struct page_stat *pg_stat;
572 nand_debug(NDBG_GEN,"%p raw prog page %x[%x] at %x", nand, page, len, offset);
573 chip = device_get_softc(nand);
574 nandbus = device_get_parent(nand);
576 if (nand_check_page_boundary(chip, page))
579 page_to_row(&chip->chip_geom, page, &row);
581 if (!can_write(nandbus))
584 if (send_start_program_page(nand, row, offset))
587 NANDBUS_WRITE_BUFFER(nandbus, buf, len);
589 if (send_end_program_page(nandbus, NAND_CMD_PROG_INTLV))
594 if (check_fail(nandbus))
597 pg_stat = &(chip->pg_stat[page]);
598 pg_stat->page_raw_written++;
604 generic_program_oob(device_t nand, uint32_t page, void* buf, uint32_t len,
607 struct nand_chip *chip;
611 nand_debug(NDBG_GEN,"%p raw prog oob %x[%x] at %x", nand, page, len,
613 chip = device_get_softc(nand);
614 nandbus = device_get_parent(nand);
616 if (nand_check_page_boundary(chip, page))
619 page_to_row(&chip->chip_geom, page, &row);
620 offset += chip->chip_geom.page_size;
622 if (!can_write(nandbus))
625 if (send_start_program_page(nand, row, offset))
628 NANDBUS_WRITE_BUFFER(nandbus, buf, len);
630 if (send_end_program_page(nandbus, NAND_CMD_PROG_END))
635 if (check_fail(nandbus))
642 send_erase_block(device_t nand, uint32_t row, uint8_t second_command)
644 device_t nandbus = device_get_parent(nand);
646 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_ERASE))
649 if (nand_send_address(nand, row, -1, -1))
652 if (NANDBUS_SEND_COMMAND(nandbus, second_command))
655 if (NANDBUS_START_COMMAND(nandbus))
662 generic_erase_block(device_t nand, uint32_t block)
664 struct block_stat *blk_stat;
665 struct nand_chip *chip;
669 nand_debug(NDBG_GEN,"%p erase block %x", nand, block);
670 nandbus = device_get_parent(nand);
671 chip = device_get_softc(nand);
673 if (block >= (chip->chip_geom.blks_per_lun * chip->chip_geom.luns))
676 row = (block << chip->chip_geom.blk_shift) &
677 chip->chip_geom.blk_mask;
679 nand_debug(NDBG_GEN,"%p erase block row %x", nand, row);
681 if (!can_write(nandbus))
684 send_erase_block(nand, row, NAND_CMD_ERASE_END);
688 if (check_fail(nandbus))
691 blk_stat = &(chip->blk_stat[block]);
692 blk_stat->block_erased++;
698 generic_erase_block_intlv(device_t nand, uint32_t block)
700 struct block_stat *blk_stat;
701 struct nand_chip *chip;
705 nand_debug(NDBG_GEN,"%p erase block %x", nand, block);
706 nandbus = device_get_parent(nand);
707 chip = device_get_softc(nand);
709 if (block >= (chip->chip_geom.blks_per_lun * chip->chip_geom.luns))
712 row = (block << chip->chip_geom.blk_shift) &
713 chip->chip_geom.blk_mask;
715 if (!can_write(nandbus))
718 send_erase_block(nand, row, NAND_CMD_ERASE_INTLV);
722 if (check_fail(nandbus))
725 blk_stat = &(chip->blk_stat[block]);
726 blk_stat->block_erased++;
733 onfi_is_blk_bad(device_t device, uint32_t block_number, uint8_t *bad)
735 struct nand_chip *chip;
736 int page_number, i, j, err;
739 chip = device_get_softc(device);
741 oob = malloc(chip->chip_geom.oob_size, M_NAND, M_WAITOK);
743 page_number = block_number * chip->chip_geom.pgs_per_blk;
745 /* Check OOB of first and last page */
746 for (i = 0; i < 2; i++, page_number+= chip->chip_geom.pgs_per_blk - 1) {
747 err = generic_read_oob(device, page_number, oob,
748 chip->chip_geom.oob_size, 0);
750 device_printf(device, "%s: cannot allocate oob\n",
756 for (j = 0; j < chip->chip_geom.oob_size; j++) {
771 send_small_read_page(device_t nand, uint8_t start_command,
772 uint32_t row, uint32_t column)
774 device_t nandbus = device_get_parent(nand);
776 if (NANDBUS_SEND_COMMAND(nandbus, start_command))
779 if (nand_send_address(nand, row, column, -1))
782 if (NANDBUS_START_COMMAND(nandbus))
790 small_read_page(device_t nand, uint32_t page, void *buf, uint32_t len,
793 struct nand_chip *chip;
794 struct page_stat *pg_stat;
798 nand_debug(NDBG_GEN,"%p small read page %x[%x] at %x", nand, page, len, offset);
799 chip = device_get_softc(nand);
800 nandbus = device_get_parent(nand);
802 if (nand_check_page_boundary(chip, page))
805 page_to_row(&chip->chip_geom, page, &row);
808 if (send_small_read_page(nand, NAND_CMD_SMALLA, row, offset))
812 if (send_small_read_page(nandbus, NAND_CMD_SMALLB, row, offset))
818 NANDBUS_READ_BUFFER(nandbus, buf, len);
820 if (check_fail(nandbus))
823 pg_stat = &(chip->pg_stat[page]);
824 pg_stat->page_raw_read++;
830 small_read_oob(device_t nand, uint32_t page, void *buf, uint32_t len,
833 struct nand_chip *chip;
834 struct page_stat *pg_stat;
838 nand_debug(NDBG_GEN,"%p small read oob %x[%x] at %x", nand, page, len, offset);
839 chip = device_get_softc(nand);
840 nandbus = device_get_parent(nand);
842 if (nand_check_page_boundary(chip, page))
845 page_to_row(&chip->chip_geom, page, &row);
847 if (send_small_read_page(nand, NAND_CMD_SMALLOOB, row, 0))
852 NANDBUS_READ_BUFFER(nandbus, buf, len);
854 if (check_fail(nandbus))
857 pg_stat = &(chip->pg_stat[page]);
858 pg_stat->page_raw_read++;
864 small_program_page(device_t nand, uint32_t page, void* buf, uint32_t len,
867 struct nand_chip *chip;
871 nand_debug(NDBG_GEN,"%p small prog page %x[%x] at %x", nand, page, len, offset);
872 chip = device_get_softc(nand);
873 nandbus = device_get_parent(nand);
875 if (nand_check_page_boundary(chip, page))
878 page_to_row(&chip->chip_geom, page, &row);
880 if (!can_write(nandbus))
884 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_SMALLA))
887 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_SMALLB))
891 if (send_start_program_page(nand, row, offset))
894 NANDBUS_WRITE_BUFFER(nandbus, buf, len);
896 if (send_end_program_page(nandbus, NAND_CMD_PROG_END))
901 if (check_fail(nandbus))
908 small_program_oob(device_t nand, uint32_t page, void* buf, uint32_t len,
911 struct nand_chip *chip;
915 nand_debug(NDBG_GEN,"%p small prog oob %x[%x] at %x", nand, page, len, offset);
916 chip = device_get_softc(nand);
917 nandbus = device_get_parent(nand);
919 if (nand_check_page_boundary(chip, page))
922 page_to_row(&chip->chip_geom, page, &row);
924 if (!can_write(nandbus))
927 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_SMALLOOB))
930 if (send_start_program_page(nand, row, offset))
933 NANDBUS_WRITE_BUFFER(nandbus, buf, len);
935 if (send_end_program_page(nandbus, NAND_CMD_PROG_END))
940 if (check_fail(nandbus))
947 nand_send_address(device_t nand, int32_t row, int32_t col, int8_t id)
949 struct nandbus_ivar *ivar;
955 nandbus = device_get_parent(nand);
956 ivar = device_get_ivars(nand);
959 nand_debug(NDBG_GEN,"send_address: send id %02x", id);
960 err = NANDBUS_SEND_ADDRESS(nandbus, id);
963 if (!err && col != -1) {
964 for (i = 0; i < ivar->cols; i++, col >>= 8) {
965 addr = (uint8_t)(col & 0xff);
966 nand_debug(NDBG_GEN,"send_address: send address column "
968 err = NANDBUS_SEND_ADDRESS(nandbus, addr);
974 if (!err && row != -1) {
975 for (i = 0; i < ivar->rows; i++, row >>= 8) {
976 addr = (uint8_t)(row & 0xff);
977 nand_debug(NDBG_GEN,"send_address: send address row "
979 err = NANDBUS_SEND_ADDRESS(nandbus, addr);
989 generic_is_blk_bad(device_t dev, uint32_t block, uint8_t *bad)
991 struct nand_chip *chip;
992 int page_number, err, i;
995 chip = device_get_softc(dev);
997 oob = malloc(chip->chip_geom.oob_size, M_NAND, M_WAITOK);
999 page_number = block * chip->chip_geom.pgs_per_blk;
1002 /* Check OOB of first and second page */
1003 for (i = 0; i < 2; i++) {
1004 err = NAND_READ_OOB(dev, page_number + i, oob,
1005 chip->chip_geom.oob_size, 0);
1007 device_printf(dev, "%s: cannot allocate OOB\n",
1026 generic_get_ecc(device_t dev, void *buf, void *ecc, int *needwrite)
1028 struct nand_chip *chip = device_get_softc(dev);
1029 struct chip_geom *cg = &chip->chip_geom;
1031 return (NANDBUS_GET_ECC(device_get_parent(dev), buf, cg->page_size,
1036 generic_correct_ecc(device_t dev, void *buf, void *readecc, void *calcecc)
1038 struct nand_chip *chip = device_get_softc(dev);
1039 struct chip_geom *cg = &chip->chip_geom;
1041 return (NANDBUS_CORRECT_ECC(device_get_parent(dev), buf,
1042 cg->page_size, readecc, calcecc));
1048 nand_chng_read_col(device_t nand, uint32_t col, void *buf, size_t len)
1050 struct nand_chip *chip;
1053 chip = device_get_softc(nand);
1054 nandbus = device_get_parent(nand);
1056 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_CHNG_READ_COL))
1059 if (NANDBUS_SEND_ADDRESS(nandbus, -1, col, -1))
1062 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_CHNG_READ_COL_END))
1065 if (NANDBUS_START_COMMAND(nandbus))
1068 if (buf != NULL && len > 0)
1069 NANDBUS_READ_BUFFER(nandbus, buf, len);
1075 nand_chng_write_col(device_t dev, uint32_t col, void *buf,
1078 struct nand_chip *chip;
1081 chip = device_get_softc(dev);
1082 nandbus = device_get_parent(dev);
1084 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_CHNG_WRITE_COL))
1087 if (NANDBUS_SEND_ADDRESS(nandbus, -1, col, -1))
1090 if (buf != NULL && len > 0)
1091 NANDBUS_WRITE_BUFFER(nandbus, buf, len);
1093 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_CHNG_READ_COL_END))
1096 if (NANDBUS_START_COMMAND(nandbus))
1103 nand_copyback_read(device_t dev, uint32_t page, uint32_t col,
1104 void *buf, size_t len)
1106 struct nand_chip *chip;
1107 struct page_stat *pg_stat;
1111 nand_debug(NDBG_GEN," raw read page %x[%x] at %x", page, col, len);
1112 chip = device_get_softc(dev);
1113 nandbus = device_get_parent(dev);
1115 if (nand_check_page_boundary(chip, page))
1118 page_to_row(&chip->chip_geom, page, &row);
1120 if (send_read_page(nand, NAND_CMD_READ, NAND_CMD_READ_CPBK, row, 0))
1124 if (check_fail(nandbus))
1127 if (buf != NULL && len > 0)
1128 NANDBUS_READ_BUFFER(nandbus, buf, len);
1130 pg_stat = &(chip->pg_stat[page]);
1131 pg_stat->page_raw_read++;
1137 nand_copyback_prog(device_t dev, uint32_t page, uint32_t col,
1138 void *buf, size_t len)
1140 struct nand_chip *chip;
1141 struct page_stat *pg_stat;
1145 nand_debug(NDBG_GEN,"copyback prog page %x[%x]", page, len);
1146 chip = device_get_softc(dev);
1147 nandbus = device_get_parent(dev);
1149 if (nand_check_page_boundary(chip, page))
1152 page_to_row(&chip->chip_geom, page, &row);
1154 if (!can_write(nandbus))
1157 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_CHNG_WRITE_COL))
1160 if (NANDBUS_SEND_ADDRESS(nandbus, row, col, -1))
1163 if (buf != NULL && len > 0)
1164 NANDBUS_WRITE_BUFFER(nandbus, buf, len);
1166 if (send_end_program_page(nandbus, NAND_CMD_PROG_END))
1169 DELAY(chip->t_prog);
1171 if (check_fail(nandbus))
1174 pg_stat = &(chip->pg_stat[page]);
1175 pg_stat->page_raw_written++;
1181 nand_copyback_prog_intlv(device_t dev, uint32_t page)
1183 struct nand_chip *chip;
1184 struct page_stat *pg_stat;
1188 nand_debug(NDBG_GEN,"cache prog page %x", page);
1189 chip = device_get_softc(dev);
1190 nandbus = device_get_parent(dev);
1192 if (nand_check_page_boundary(chip, page))
1195 page_to_row(&chip->chip_geom, page, &row);
1197 if (!can_write(nandbus))
1200 if (send_start_program_page(nand, row, 0))
1203 if (send_end_program_page(nandbus, NAND_CMD_PROG_INTLV))
1206 DELAY(chip->t_prog);
1208 if (check_fail(nandbus))
1211 pg_stat = &(chip->pg_stat[page]);
1212 pg_stat->page_raw_written++;
1218 nand_prog_cache(device_t dev, uint32_t page, uint32_t col,
1219 void *buf, size_t len, uint8_t end)
1221 struct nand_chip *chip;
1222 struct page_stat *pg_stat;
1227 nand_debug(NDBG_GEN,"cache prog page %x[%x]", page, len);
1228 chip = device_get_softc(dev);
1229 nandbus = device_get_parent(dev);
1231 if (nand_check_page_boundary(chip, page))
1234 page_to_row(&chip->chip_geom, page, &row);
1236 if (!can_write(nandbus))
1239 if (send_start_program_page(dev, row, 0))
1242 NANDBUS_WRITE_BUFFER(nandbus, buf, len);
1245 command = NAND_CMD_PROG_END;
1247 command = NAND_CMD_PROG_CACHE;
1249 if (send_end_program_page(nandbus, command))
1252 DELAY(chip->t_prog);
1254 if (check_fail(nandbus))
1257 pg_stat = &(chip->pg_stat[page]);
1258 pg_stat->page_raw_written++;
1264 nand_read_cache(device_t dev, uint32_t page, uint32_t col,
1265 void *buf, size_t len, uint8_t end)
1267 struct nand_chip *chip;
1268 struct page_stat *pg_stat;
1273 nand_debug(NDBG_GEN,"cache read page %x[%x] ", page, len);
1274 chip = device_get_softc(dev);
1275 nandbus = device_get_parent(dev);
1277 if (nand_check_page_boundary(chip, page))
1280 page_to_row(&chip->chip_geom, page, &row);
1283 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_READ))
1286 if (NANDBUS_SEND_ADDRESS(nandbus, row, col, -1))
1291 command = NAND_CMD_READ_CACHE_END;
1293 command = NAND_CMD_READ_CACHE;
1295 if (NANDBUS_SEND_COMMAND(nandbus, command))
1298 if (NANDBUS_START_COMMAND(nandbus))
1302 if (check_fail(nandbus))
1305 if (buf != NULL && len > 0)
1306 NANDBUS_READ_BUFFER(nandbus, buf, len);
1308 pg_stat = &(chip->pg_stat[page]);
1309 pg_stat->page_raw_read++;
1315 nand_get_feature(device_t dev, uint8_t feat, void *buf)
1317 struct nand_chip *chip;
1320 nand_debug(NDBG_GEN,"nand get feature");
1322 chip = device_get_softc(dev);
1323 nandbus = device_get_parent(dev);
1325 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_GET_FEATURE))
1328 if (NANDBUS_SEND_ADDRESS(nandbus, -1, -1, feat))
1331 if (NANDBUS_START_COMMAND(nandbus))
1335 NANDBUS_READ_BUFFER(nandbus, buf, 4);
1341 nand_set_feature(device_t dev, uint8_t feat, void *buf)
1343 struct nand_chip *chip;
1346 nand_debug(NDBG_GEN,"nand set feature");
1348 chip = device_get_softc(dev);
1349 nandbus = device_get_parent(dev);
1351 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_SET_FEATURE))
1354 if (NANDBUS_SEND_ADDRESS(nandbus, -1, -1, feat))
1357 NANDBUS_WRITE_BUFFER(nandbus, buf, 4);
1359 if (NANDBUS_START_COMMAND(nandbus))