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);
231 if (onfi_chip_params == NULL)
234 if (onfi_read_parameter(chip, onfi_chip_params)) {
235 nand_debug(NDBG_GEN,"Could not read parameter page!\n");
236 free(onfi_chip_params, M_NAND);
240 nand_onfi_set_params(chip, onfi_chip_params);
241 /* Set proper column and row cycles */
242 ivar->cols = (onfi_chip_params->address_cycles >> 4) & 0xf;
243 ivar->rows = onfi_chip_params->address_cycles & 0xf;
244 free(onfi_chip_params, M_NAND);
247 nand_set_params(chip, ivar->params);
250 err = nand_init_stat(chip);
252 generic_nand_detach(dev);
256 err = nand_init_bbt(chip);
258 generic_nand_detach(dev);
262 err = nand_make_dev(chip);
264 generic_nand_detach(dev);
268 err = create_geom_disk(chip);
270 generic_nand_detach(dev);
278 generic_nand_detach(device_t dev)
280 struct nand_chip *chip;
282 chip = device_get_softc(dev);
284 nand_destroy_bbt(chip);
285 destroy_geom_disk(chip);
286 nand_destroy_dev(chip);
287 nand_destroy_stat(chip);
293 can_write(device_t nandbus)
297 if (NANDBUS_WAIT_READY(nandbus, &status))
300 if (!(status & NAND_STATUS_WP)) {
301 nand_debug(NDBG_GEN,"Chip is write-protected");
309 check_fail(device_t nandbus)
313 NANDBUS_WAIT_READY(nandbus, &status);
314 if (status & NAND_STATUS_FAIL) {
315 nand_debug(NDBG_GEN,"Status failed %x", status);
323 onfi_crc(const void *buf, size_t buflen)
327 const uint8_t *bufptr;
331 for (j = 0; j < buflen; j++) {
332 crc ^= *bufptr++ << 8;
333 for (i = 0; i < 8; i++)
335 crc = (crc << 1) ^ 0x8005;
343 onfi_read_parameter(struct nand_chip *chip, struct onfi_chip_params *chip_params)
346 struct onfi_params params;
347 int found, sigcount, trycopy;
349 nand_debug(NDBG_GEN,"read parameter");
351 nandbus = device_get_parent(chip->dev);
353 NANDBUS_SELECT_CS(nandbus, chip->num);
355 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_READ_PARAMETER))
358 if (nand_send_address(chip->dev, -1, -1, PAGE_PARAMETER_DEF))
361 if (NANDBUS_START_COMMAND(nandbus))
365 * XXX Bogus DELAY, we really need a nandbus_wait_ready() here, but it's
366 * not accessible from here (static to nandbus).
371 * The ONFI spec mandates a minimum of three copies of the parameter
372 * data, so loop up to 3 times trying to find good data. Each copy is
373 * validated by a signature of "ONFI" and a crc. There is a very strange
374 * rule that the signature is valid if any 2 of the 4 bytes are correct.
376 for (found= 0, trycopy = 0; !found && trycopy < 3; trycopy++) {
377 NANDBUS_READ_BUFFER(nandbus, ¶ms, sizeof(struct onfi_params));
378 sigcount = params.signature[0] == 'O';
379 sigcount += params.signature[1] == 'N';
380 sigcount += params.signature[2] == 'F';
381 sigcount += params.signature[3] == 'I';
384 if (onfi_crc(¶ms, 254) != params.crc)
391 chip_params->luns = params.luns;
392 chip_params->blocks_per_lun = le32dec(¶ms.blocks_per_lun);
393 chip_params->pages_per_block = le32dec(¶ms.pages_per_block);
394 chip_params->bytes_per_page = le32dec(¶ms.bytes_per_page);
395 chip_params->spare_bytes_per_page = le16dec(¶ms.spare_bytes_per_page);
396 chip_params->t_bers = le16dec(¶ms.t_bers);
397 chip_params->t_prog = le16dec(¶ms.t_prog);
398 chip_params->t_r = le16dec(¶ms.t_r);
399 chip_params->t_ccs = le16dec(¶ms.t_ccs);
400 chip_params->features = le16dec(¶ms.features);
401 chip_params->address_cycles = params.address_cycles;
407 send_read_page(device_t nand, uint8_t start_command, uint8_t end_command,
408 uint32_t row, uint32_t column)
410 device_t nandbus = device_get_parent(nand);
412 if (NANDBUS_SEND_COMMAND(nandbus, start_command))
415 if (nand_send_address(nand, row, column, -1))
418 if (NANDBUS_SEND_COMMAND(nandbus, end_command))
421 if (NANDBUS_START_COMMAND(nandbus))
428 generic_read_page(device_t nand, uint32_t page, void *buf, uint32_t len,
431 struct nand_chip *chip;
432 struct page_stat *pg_stat;
436 nand_debug(NDBG_GEN,"%p raw read page %x[%x] at %x", nand, page, len, offset);
437 chip = device_get_softc(nand);
438 nandbus = device_get_parent(nand);
440 if (nand_check_page_boundary(chip, page))
443 page_to_row(&chip->chip_geom, page, &row);
445 if (send_read_page(nand, NAND_CMD_READ, NAND_CMD_READ_END, row,
451 NANDBUS_READ_BUFFER(nandbus, buf, len);
453 if (check_fail(nandbus))
456 pg_stat = &(chip->pg_stat[page]);
457 pg_stat->page_raw_read++;
463 generic_read_oob(device_t nand, uint32_t page, void* buf, uint32_t len,
466 struct nand_chip *chip;
470 nand_debug(NDBG_GEN,"%p raw read oob %x[%x] at %x", nand, page, len, offset);
471 chip = device_get_softc(nand);
472 nandbus = device_get_parent(nand);
474 if (nand_check_page_boundary(chip, page)) {
475 nand_debug(NDBG_GEN,"page boundary check failed: %08x\n", page);
479 page_to_row(&chip->chip_geom, page, &row);
481 offset += chip->chip_geom.page_size;
483 if (send_read_page(nand, NAND_CMD_READ, NAND_CMD_READ_END, row,
489 NANDBUS_READ_BUFFER(nandbus, buf, len);
491 if (check_fail(nandbus))
498 send_start_program_page(device_t nand, uint32_t row, uint32_t column)
500 device_t nandbus = device_get_parent(nand);
502 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_PROG))
505 if (nand_send_address(nand, row, column, -1))
512 send_end_program_page(device_t nandbus, uint8_t end_command)
515 if (NANDBUS_SEND_COMMAND(nandbus, end_command))
518 if (NANDBUS_START_COMMAND(nandbus))
525 generic_program_page(device_t nand, uint32_t page, void *buf, uint32_t len,
528 struct nand_chip *chip;
529 struct page_stat *pg_stat;
533 nand_debug(NDBG_GEN,"%p raw prog page %x[%x] at %x", nand, page, len,
535 chip = device_get_softc(nand);
536 nandbus = device_get_parent(nand);
538 if (nand_check_page_boundary(chip, page))
541 page_to_row(&chip->chip_geom, page, &row);
543 if (!can_write(nandbus))
546 if (send_start_program_page(nand, row, offset))
549 NANDBUS_WRITE_BUFFER(nandbus, buf, len);
551 if (send_end_program_page(nandbus, NAND_CMD_PROG_END))
556 if (check_fail(nandbus))
559 pg_stat = &(chip->pg_stat[page]);
560 pg_stat->page_raw_written++;
566 generic_program_page_intlv(device_t nand, uint32_t page, void *buf,
567 uint32_t len, uint32_t offset)
569 struct nand_chip *chip;
570 struct page_stat *pg_stat;
574 nand_debug(NDBG_GEN,"%p raw prog page %x[%x] at %x", nand, page, len, offset);
575 chip = device_get_softc(nand);
576 nandbus = device_get_parent(nand);
578 if (nand_check_page_boundary(chip, page))
581 page_to_row(&chip->chip_geom, page, &row);
583 if (!can_write(nandbus))
586 if (send_start_program_page(nand, row, offset))
589 NANDBUS_WRITE_BUFFER(nandbus, buf, len);
591 if (send_end_program_page(nandbus, NAND_CMD_PROG_INTLV))
596 if (check_fail(nandbus))
599 pg_stat = &(chip->pg_stat[page]);
600 pg_stat->page_raw_written++;
606 generic_program_oob(device_t nand, uint32_t page, void* buf, uint32_t len,
609 struct nand_chip *chip;
613 nand_debug(NDBG_GEN,"%p raw prog oob %x[%x] at %x", nand, page, len,
615 chip = device_get_softc(nand);
616 nandbus = device_get_parent(nand);
618 if (nand_check_page_boundary(chip, page))
621 page_to_row(&chip->chip_geom, page, &row);
622 offset += chip->chip_geom.page_size;
624 if (!can_write(nandbus))
627 if (send_start_program_page(nand, row, offset))
630 NANDBUS_WRITE_BUFFER(nandbus, buf, len);
632 if (send_end_program_page(nandbus, NAND_CMD_PROG_END))
637 if (check_fail(nandbus))
644 send_erase_block(device_t nand, uint32_t row, uint8_t second_command)
646 device_t nandbus = device_get_parent(nand);
648 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_ERASE))
651 if (nand_send_address(nand, row, -1, -1))
654 if (NANDBUS_SEND_COMMAND(nandbus, second_command))
657 if (NANDBUS_START_COMMAND(nandbus))
664 generic_erase_block(device_t nand, uint32_t block)
666 struct block_stat *blk_stat;
667 struct nand_chip *chip;
671 nand_debug(NDBG_GEN,"%p erase block %x", nand, block);
672 nandbus = device_get_parent(nand);
673 chip = device_get_softc(nand);
675 if (block >= (chip->chip_geom.blks_per_lun * chip->chip_geom.luns))
678 row = (block << chip->chip_geom.blk_shift) &
679 chip->chip_geom.blk_mask;
681 nand_debug(NDBG_GEN,"%p erase block row %x", nand, row);
683 if (!can_write(nandbus))
686 send_erase_block(nand, row, NAND_CMD_ERASE_END);
690 if (check_fail(nandbus))
693 blk_stat = &(chip->blk_stat[block]);
694 blk_stat->block_erased++;
700 generic_erase_block_intlv(device_t nand, uint32_t block)
702 struct block_stat *blk_stat;
703 struct nand_chip *chip;
707 nand_debug(NDBG_GEN,"%p erase block %x", nand, block);
708 nandbus = device_get_parent(nand);
709 chip = device_get_softc(nand);
711 if (block >= (chip->chip_geom.blks_per_lun * chip->chip_geom.luns))
714 row = (block << chip->chip_geom.blk_shift) &
715 chip->chip_geom.blk_mask;
717 if (!can_write(nandbus))
720 send_erase_block(nand, row, NAND_CMD_ERASE_INTLV);
724 if (check_fail(nandbus))
727 blk_stat = &(chip->blk_stat[block]);
728 blk_stat->block_erased++;
735 onfi_is_blk_bad(device_t device, uint32_t block_number, uint8_t *bad)
737 struct nand_chip *chip;
738 int page_number, i, j, err;
741 chip = device_get_softc(device);
743 oob = malloc(chip->chip_geom.oob_size, M_NAND, M_WAITOK);
745 device_printf(device, "%s: cannot allocate oob\n", __func__);
749 page_number = block_number * chip->chip_geom.pgs_per_blk;
751 /* Check OOB of first and last page */
752 for (i = 0; i < 2; i++, page_number+= chip->chip_geom.pgs_per_blk - 1) {
753 err = generic_read_oob(device, page_number, oob,
754 chip->chip_geom.oob_size, 0);
756 device_printf(device, "%s: cannot allocate oob\n",
762 for (j = 0; j < chip->chip_geom.oob_size; j++) {
777 send_small_read_page(device_t nand, uint8_t start_command,
778 uint32_t row, uint32_t column)
780 device_t nandbus = device_get_parent(nand);
782 if (NANDBUS_SEND_COMMAND(nandbus, start_command))
785 if (nand_send_address(nand, row, column, -1))
788 if (NANDBUS_START_COMMAND(nandbus))
796 small_read_page(device_t nand, uint32_t page, void *buf, uint32_t len,
799 struct nand_chip *chip;
800 struct page_stat *pg_stat;
804 nand_debug(NDBG_GEN,"%p small read page %x[%x] at %x", nand, page, len, offset);
805 chip = device_get_softc(nand);
806 nandbus = device_get_parent(nand);
808 if (nand_check_page_boundary(chip, page))
811 page_to_row(&chip->chip_geom, page, &row);
814 if (send_small_read_page(nand, NAND_CMD_SMALLA, row, offset))
818 if (send_small_read_page(nandbus, NAND_CMD_SMALLB, row, offset))
824 NANDBUS_READ_BUFFER(nandbus, buf, len);
826 if (check_fail(nandbus))
829 pg_stat = &(chip->pg_stat[page]);
830 pg_stat->page_raw_read++;
836 small_read_oob(device_t nand, uint32_t page, void *buf, uint32_t len,
839 struct nand_chip *chip;
840 struct page_stat *pg_stat;
844 nand_debug(NDBG_GEN,"%p small read oob %x[%x] at %x", nand, page, len, offset);
845 chip = device_get_softc(nand);
846 nandbus = device_get_parent(nand);
848 if (nand_check_page_boundary(chip, page))
851 page_to_row(&chip->chip_geom, page, &row);
853 if (send_small_read_page(nand, NAND_CMD_SMALLOOB, row, 0))
858 NANDBUS_READ_BUFFER(nandbus, buf, len);
860 if (check_fail(nandbus))
863 pg_stat = &(chip->pg_stat[page]);
864 pg_stat->page_raw_read++;
870 small_program_page(device_t nand, uint32_t page, void* buf, uint32_t len,
873 struct nand_chip *chip;
877 nand_debug(NDBG_GEN,"%p small prog page %x[%x] at %x", nand, page, len, offset);
878 chip = device_get_softc(nand);
879 nandbus = device_get_parent(nand);
881 if (nand_check_page_boundary(chip, page))
884 page_to_row(&chip->chip_geom, page, &row);
886 if (!can_write(nandbus))
890 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_SMALLA))
893 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_SMALLB))
897 if (send_start_program_page(nand, row, offset))
900 NANDBUS_WRITE_BUFFER(nandbus, buf, len);
902 if (send_end_program_page(nandbus, NAND_CMD_PROG_END))
907 if (check_fail(nandbus))
914 small_program_oob(device_t nand, uint32_t page, void* buf, uint32_t len,
917 struct nand_chip *chip;
921 nand_debug(NDBG_GEN,"%p small prog oob %x[%x] at %x", nand, page, len, offset);
922 chip = device_get_softc(nand);
923 nandbus = device_get_parent(nand);
925 if (nand_check_page_boundary(chip, page))
928 page_to_row(&chip->chip_geom, page, &row);
930 if (!can_write(nandbus))
933 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_SMALLOOB))
936 if (send_start_program_page(nand, row, offset))
939 NANDBUS_WRITE_BUFFER(nandbus, buf, len);
941 if (send_end_program_page(nandbus, NAND_CMD_PROG_END))
946 if (check_fail(nandbus))
953 nand_send_address(device_t nand, int32_t row, int32_t col, int8_t id)
955 struct nandbus_ivar *ivar;
961 nandbus = device_get_parent(nand);
962 ivar = device_get_ivars(nand);
965 nand_debug(NDBG_GEN,"send_address: send id %02x", id);
966 err = NANDBUS_SEND_ADDRESS(nandbus, id);
969 if (!err && col != -1) {
970 for (i = 0; i < ivar->cols; i++, col >>= 8) {
971 addr = (uint8_t)(col & 0xff);
972 nand_debug(NDBG_GEN,"send_address: send address column "
974 err = NANDBUS_SEND_ADDRESS(nandbus, addr);
980 if (!err && row != -1) {
981 for (i = 0; i < ivar->rows; i++, row >>= 8) {
982 addr = (uint8_t)(row & 0xff);
983 nand_debug(NDBG_GEN,"send_address: send address row "
985 err = NANDBUS_SEND_ADDRESS(nandbus, addr);
995 generic_is_blk_bad(device_t dev, uint32_t block, uint8_t *bad)
997 struct nand_chip *chip;
998 int page_number, err, i;
1001 chip = device_get_softc(dev);
1003 oob = malloc(chip->chip_geom.oob_size, M_NAND, M_WAITOK);
1005 device_printf(dev, "%s: cannot allocate OOB\n", __func__);
1009 page_number = block * chip->chip_geom.pgs_per_blk;
1012 /* Check OOB of first and second page */
1013 for (i = 0; i < 2; i++) {
1014 err = NAND_READ_OOB(dev, page_number + i, oob,
1015 chip->chip_geom.oob_size, 0);
1017 device_printf(dev, "%s: cannot allocate OOB\n",
1036 generic_get_ecc(device_t dev, void *buf, void *ecc, int *needwrite)
1038 struct nand_chip *chip = device_get_softc(dev);
1039 struct chip_geom *cg = &chip->chip_geom;
1041 return (NANDBUS_GET_ECC(device_get_parent(dev), buf, cg->page_size,
1046 generic_correct_ecc(device_t dev, void *buf, void *readecc, void *calcecc)
1048 struct nand_chip *chip = device_get_softc(dev);
1049 struct chip_geom *cg = &chip->chip_geom;
1051 return (NANDBUS_CORRECT_ECC(device_get_parent(dev), buf,
1052 cg->page_size, readecc, calcecc));
1058 nand_chng_read_col(device_t nand, uint32_t col, void *buf, size_t len)
1060 struct nand_chip *chip;
1063 chip = device_get_softc(nand);
1064 nandbus = device_get_parent(nand);
1066 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_CHNG_READ_COL))
1069 if (NANDBUS_SEND_ADDRESS(nandbus, -1, col, -1))
1072 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_CHNG_READ_COL_END))
1075 if (NANDBUS_START_COMMAND(nandbus))
1078 if (buf != NULL && len > 0)
1079 NANDBUS_READ_BUFFER(nandbus, buf, len);
1085 nand_chng_write_col(device_t dev, uint32_t col, void *buf,
1088 struct nand_chip *chip;
1091 chip = device_get_softc(dev);
1092 nandbus = device_get_parent(dev);
1094 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_CHNG_WRITE_COL))
1097 if (NANDBUS_SEND_ADDRESS(nandbus, -1, col, -1))
1100 if (buf != NULL && len > 0)
1101 NANDBUS_WRITE_BUFFER(nandbus, buf, len);
1103 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_CHNG_READ_COL_END))
1106 if (NANDBUS_START_COMMAND(nandbus))
1113 nand_copyback_read(device_t dev, uint32_t page, uint32_t col,
1114 void *buf, size_t len)
1116 struct nand_chip *chip;
1117 struct page_stat *pg_stat;
1121 nand_debug(NDBG_GEN," raw read page %x[%x] at %x", page, col, len);
1122 chip = device_get_softc(dev);
1123 nandbus = device_get_parent(dev);
1125 if (nand_check_page_boundary(chip, page))
1128 page_to_row(&chip->chip_geom, page, &row);
1130 if (send_read_page(nand, NAND_CMD_READ, NAND_CMD_READ_CPBK, row, 0))
1134 if (check_fail(nandbus))
1137 if (buf != NULL && len > 0)
1138 NANDBUS_READ_BUFFER(nandbus, buf, len);
1140 pg_stat = &(chip->pg_stat[page]);
1141 pg_stat->page_raw_read++;
1147 nand_copyback_prog(device_t dev, uint32_t page, uint32_t col,
1148 void *buf, size_t len)
1150 struct nand_chip *chip;
1151 struct page_stat *pg_stat;
1155 nand_debug(NDBG_GEN,"copyback prog page %x[%x]", page, len);
1156 chip = device_get_softc(dev);
1157 nandbus = device_get_parent(dev);
1159 if (nand_check_page_boundary(chip, page))
1162 page_to_row(&chip->chip_geom, page, &row);
1164 if (!can_write(nandbus))
1167 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_CHNG_WRITE_COL))
1170 if (NANDBUS_SEND_ADDRESS(nandbus, row, col, -1))
1173 if (buf != NULL && len > 0)
1174 NANDBUS_WRITE_BUFFER(nandbus, buf, len);
1176 if (send_end_program_page(nandbus, NAND_CMD_PROG_END))
1179 DELAY(chip->t_prog);
1181 if (check_fail(nandbus))
1184 pg_stat = &(chip->pg_stat[page]);
1185 pg_stat->page_raw_written++;
1191 nand_copyback_prog_intlv(device_t dev, uint32_t page)
1193 struct nand_chip *chip;
1194 struct page_stat *pg_stat;
1198 nand_debug(NDBG_GEN,"cache prog page %x", page);
1199 chip = device_get_softc(dev);
1200 nandbus = device_get_parent(dev);
1202 if (nand_check_page_boundary(chip, page))
1205 page_to_row(&chip->chip_geom, page, &row);
1207 if (!can_write(nandbus))
1210 if (send_start_program_page(nand, row, 0))
1213 if (send_end_program_page(nandbus, NAND_CMD_PROG_INTLV))
1216 DELAY(chip->t_prog);
1218 if (check_fail(nandbus))
1221 pg_stat = &(chip->pg_stat[page]);
1222 pg_stat->page_raw_written++;
1228 nand_prog_cache(device_t dev, uint32_t page, uint32_t col,
1229 void *buf, size_t len, uint8_t end)
1231 struct nand_chip *chip;
1232 struct page_stat *pg_stat;
1237 nand_debug(NDBG_GEN,"cache prog page %x[%x]", page, len);
1238 chip = device_get_softc(dev);
1239 nandbus = device_get_parent(dev);
1241 if (nand_check_page_boundary(chip, page))
1244 page_to_row(&chip->chip_geom, page, &row);
1246 if (!can_write(nandbus))
1249 if (send_start_program_page(dev, row, 0))
1252 NANDBUS_WRITE_BUFFER(nandbus, buf, len);
1255 command = NAND_CMD_PROG_END;
1257 command = NAND_CMD_PROG_CACHE;
1259 if (send_end_program_page(nandbus, command))
1262 DELAY(chip->t_prog);
1264 if (check_fail(nandbus))
1267 pg_stat = &(chip->pg_stat[page]);
1268 pg_stat->page_raw_written++;
1274 nand_read_cache(device_t dev, uint32_t page, uint32_t col,
1275 void *buf, size_t len, uint8_t end)
1277 struct nand_chip *chip;
1278 struct page_stat *pg_stat;
1283 nand_debug(NDBG_GEN,"cache read page %x[%x] ", page, len);
1284 chip = device_get_softc(dev);
1285 nandbus = device_get_parent(dev);
1287 if (nand_check_page_boundary(chip, page))
1290 page_to_row(&chip->chip_geom, page, &row);
1293 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_READ))
1296 if (NANDBUS_SEND_ADDRESS(nandbus, row, col, -1))
1301 command = NAND_CMD_READ_CACHE_END;
1303 command = NAND_CMD_READ_CACHE;
1305 if (NANDBUS_SEND_COMMAND(nandbus, command))
1308 if (NANDBUS_START_COMMAND(nandbus))
1312 if (check_fail(nandbus))
1315 if (buf != NULL && len > 0)
1316 NANDBUS_READ_BUFFER(nandbus, buf, len);
1318 pg_stat = &(chip->pg_stat[page]);
1319 pg_stat->page_raw_read++;
1325 nand_get_feature(device_t dev, uint8_t feat, void *buf)
1327 struct nand_chip *chip;
1330 nand_debug(NDBG_GEN,"nand get feature");
1332 chip = device_get_softc(dev);
1333 nandbus = device_get_parent(dev);
1335 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_GET_FEATURE))
1338 if (NANDBUS_SEND_ADDRESS(nandbus, -1, -1, feat))
1341 if (NANDBUS_START_COMMAND(nandbus))
1345 NANDBUS_READ_BUFFER(nandbus, buf, 4);
1351 nand_set_feature(device_t dev, uint8_t feat, void *buf)
1353 struct nand_chip *chip;
1356 nand_debug(NDBG_GEN,"nand set feature");
1358 chip = device_get_softc(dev);
1359 nandbus = device_get_parent(dev);
1361 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_SET_FEATURE))
1364 if (NANDBUS_SEND_ADDRESS(nandbus, -1, -1, feat))
1367 NANDBUS_WRITE_BUFFER(nandbus, buf, 4);
1369 if (NANDBUS_START_COMMAND(nandbus))