2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
4 * Copyright (C) 2009-2012 Semihalf
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 /* Generic NAND driver */
31 #include <sys/cdefs.h>
32 __FBSDID("$FreeBSD$");
34 #include <sys/param.h>
35 #include <sys/systm.h>
39 #include <sys/endian.h>
40 #include <sys/kernel.h>
41 #include <sys/module.h>
44 #include <sys/mutex.h>
46 #include <sys/malloc.h>
48 #include <dev/nand/nand.h>
49 #include <dev/nand/nandbus.h>
52 #include "nandbus_if.h"
55 static int onfi_nand_probe(device_t dev);
56 static int large_nand_probe(device_t dev);
57 static int small_nand_probe(device_t dev);
58 static int generic_nand_attach(device_t dev);
59 static int generic_nand_detach(device_t dev);
61 static int generic_erase_block(device_t, uint32_t);
62 static int generic_erase_block_intlv(device_t, uint32_t);
63 static int generic_read_page (device_t, uint32_t, void *, uint32_t, uint32_t);
64 static int generic_read_oob(device_t, uint32_t, void *, uint32_t, uint32_t);
65 static int generic_program_page(device_t, uint32_t, void *, uint32_t, uint32_t);
66 static int generic_program_page_intlv(device_t, uint32_t, void *, uint32_t,
68 static int generic_program_oob(device_t, uint32_t, void *, uint32_t, uint32_t);
69 static int generic_is_blk_bad(device_t, uint32_t, uint8_t *);
70 static int generic_get_ecc(device_t, void *, void *, int *);
71 static int generic_correct_ecc(device_t, void *, void *, void *);
73 static int small_read_page(device_t, uint32_t, void *, uint32_t, uint32_t);
74 static int small_read_oob(device_t, uint32_t, void *, uint32_t, uint32_t);
75 static int small_program_page(device_t, uint32_t, void *, uint32_t, uint32_t);
76 static int small_program_oob(device_t, uint32_t, void *, uint32_t, uint32_t);
78 static int onfi_is_blk_bad(device_t, uint32_t, uint8_t *);
79 static int onfi_read_parameter(struct nand_chip *, struct onfi_chip_params *);
81 static int nand_send_address(device_t, int32_t, int32_t, int8_t);
83 static device_method_t onand_methods[] = {
84 /* Device interface */
85 DEVMETHOD(device_probe, onfi_nand_probe),
86 DEVMETHOD(device_attach, generic_nand_attach),
87 DEVMETHOD(device_detach, generic_nand_detach),
89 DEVMETHOD(nand_read_page, generic_read_page),
90 DEVMETHOD(nand_program_page, generic_program_page),
91 DEVMETHOD(nand_program_page_intlv, generic_program_page_intlv),
92 DEVMETHOD(nand_read_oob, generic_read_oob),
93 DEVMETHOD(nand_program_oob, generic_program_oob),
94 DEVMETHOD(nand_erase_block, generic_erase_block),
95 DEVMETHOD(nand_erase_block_intlv, generic_erase_block_intlv),
97 DEVMETHOD(nand_is_blk_bad, onfi_is_blk_bad),
98 DEVMETHOD(nand_get_ecc, generic_get_ecc),
99 DEVMETHOD(nand_correct_ecc, generic_correct_ecc),
103 static device_method_t lnand_methods[] = {
104 /* Device interface */
105 DEVMETHOD(device_probe, large_nand_probe),
106 DEVMETHOD(device_attach, generic_nand_attach),
107 DEVMETHOD(device_detach, generic_nand_detach),
109 DEVMETHOD(nand_read_page, generic_read_page),
110 DEVMETHOD(nand_program_page, generic_program_page),
111 DEVMETHOD(nand_read_oob, generic_read_oob),
112 DEVMETHOD(nand_program_oob, generic_program_oob),
113 DEVMETHOD(nand_erase_block, generic_erase_block),
115 DEVMETHOD(nand_is_blk_bad, generic_is_blk_bad),
116 DEVMETHOD(nand_get_ecc, generic_get_ecc),
117 DEVMETHOD(nand_correct_ecc, generic_correct_ecc),
121 static device_method_t snand_methods[] = {
122 /* Device interface */
123 DEVMETHOD(device_probe, small_nand_probe),
124 DEVMETHOD(device_attach, generic_nand_attach),
125 DEVMETHOD(device_detach, generic_nand_detach),
127 DEVMETHOD(nand_read_page, small_read_page),
128 DEVMETHOD(nand_program_page, small_program_page),
129 DEVMETHOD(nand_read_oob, small_read_oob),
130 DEVMETHOD(nand_program_oob, small_program_oob),
131 DEVMETHOD(nand_erase_block, generic_erase_block),
133 DEVMETHOD(nand_is_blk_bad, generic_is_blk_bad),
134 DEVMETHOD(nand_get_ecc, generic_get_ecc),
135 DEVMETHOD(nand_correct_ecc, generic_correct_ecc),
139 devclass_t onand_devclass;
140 devclass_t lnand_devclass;
141 devclass_t snand_devclass;
143 driver_t onand_driver = {
146 sizeof(struct nand_chip)
149 driver_t lnand_driver = {
152 sizeof(struct nand_chip)
155 driver_t snand_driver = {
158 sizeof(struct nand_chip)
161 DRIVER_MODULE(onand, nandbus, onand_driver, onand_devclass, 0, 0);
162 DRIVER_MODULE(lnand, nandbus, lnand_driver, lnand_devclass, 0, 0);
163 DRIVER_MODULE(snand, nandbus, snand_driver, snand_devclass, 0, 0);
166 onfi_nand_probe(device_t dev)
168 struct nandbus_ivar *ivar;
170 ivar = device_get_ivars(dev);
171 if (ivar && ivar->is_onfi) {
172 device_set_desc(dev, "ONFI compliant NAND");
173 return (BUS_PROBE_DEFAULT);
180 large_nand_probe(device_t dev)
182 struct nandbus_ivar *ivar;
184 ivar = device_get_ivars(dev);
185 if (ivar && !ivar->is_onfi && ivar->params->page_size >= 512) {
186 device_set_desc(dev, ivar->params->name);
187 return (BUS_PROBE_DEFAULT);
194 small_nand_probe(device_t dev)
196 struct nandbus_ivar *ivar;
198 ivar = device_get_ivars(dev);
199 if (ivar && !ivar->is_onfi && ivar->params->page_size == 512) {
200 device_set_desc(dev, ivar->params->name);
201 return (BUS_PROBE_DEFAULT);
208 generic_nand_attach(device_t dev)
210 struct nand_chip *chip;
211 struct nandbus_ivar *ivar;
212 struct onfi_chip_params *onfi_chip_params;
213 device_t nandbus, nfc;
216 chip = device_get_softc(dev);
219 ivar = device_get_ivars(dev);
220 chip->id.man_id = ivar->man_id;
221 chip->id.dev_id = ivar->dev_id;
222 chip->num = ivar->cs;
224 /* TODO remove when HW ECC supported */
225 nandbus = device_get_parent(dev);
226 nfc = device_get_parent(nandbus);
228 chip->nand = device_get_softc(nfc);
231 onfi_chip_params = malloc(sizeof(struct onfi_chip_params),
232 M_NAND, M_WAITOK | M_ZERO);
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 page_number = block_number * chip->chip_geom.pgs_per_blk;
747 /* Check OOB of first and last page */
748 for (i = 0; i < 2; i++, page_number+= chip->chip_geom.pgs_per_blk - 1) {
749 err = generic_read_oob(device, page_number, oob,
750 chip->chip_geom.oob_size, 0);
752 device_printf(device, "%s: cannot allocate oob\n",
758 for (j = 0; j < chip->chip_geom.oob_size; j++) {
773 send_small_read_page(device_t nand, uint8_t start_command,
774 uint32_t row, uint32_t column)
776 device_t nandbus = device_get_parent(nand);
778 if (NANDBUS_SEND_COMMAND(nandbus, start_command))
781 if (nand_send_address(nand, row, column, -1))
784 if (NANDBUS_START_COMMAND(nandbus))
792 small_read_page(device_t nand, uint32_t page, void *buf, uint32_t len,
795 struct nand_chip *chip;
796 struct page_stat *pg_stat;
800 nand_debug(NDBG_GEN,"%p small read page %x[%x] at %x", nand, page, len, offset);
801 chip = device_get_softc(nand);
802 nandbus = device_get_parent(nand);
804 if (nand_check_page_boundary(chip, page))
807 page_to_row(&chip->chip_geom, page, &row);
810 if (send_small_read_page(nand, NAND_CMD_SMALLA, row, offset))
814 if (send_small_read_page(nandbus, NAND_CMD_SMALLB, row, offset))
820 NANDBUS_READ_BUFFER(nandbus, buf, len);
822 if (check_fail(nandbus))
825 pg_stat = &(chip->pg_stat[page]);
826 pg_stat->page_raw_read++;
832 small_read_oob(device_t nand, uint32_t page, void *buf, uint32_t len,
835 struct nand_chip *chip;
836 struct page_stat *pg_stat;
840 nand_debug(NDBG_GEN,"%p small read oob %x[%x] at %x", nand, page, len, offset);
841 chip = device_get_softc(nand);
842 nandbus = device_get_parent(nand);
844 if (nand_check_page_boundary(chip, page))
847 page_to_row(&chip->chip_geom, page, &row);
849 if (send_small_read_page(nand, NAND_CMD_SMALLOOB, row, 0))
854 NANDBUS_READ_BUFFER(nandbus, buf, len);
856 if (check_fail(nandbus))
859 pg_stat = &(chip->pg_stat[page]);
860 pg_stat->page_raw_read++;
866 small_program_page(device_t nand, uint32_t page, void* buf, uint32_t len,
869 struct nand_chip *chip;
873 nand_debug(NDBG_GEN,"%p small prog page %x[%x] at %x", nand, page, len, offset);
874 chip = device_get_softc(nand);
875 nandbus = device_get_parent(nand);
877 if (nand_check_page_boundary(chip, page))
880 page_to_row(&chip->chip_geom, page, &row);
882 if (!can_write(nandbus))
886 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_SMALLA))
889 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_SMALLB))
893 if (send_start_program_page(nand, row, offset))
896 NANDBUS_WRITE_BUFFER(nandbus, buf, len);
898 if (send_end_program_page(nandbus, NAND_CMD_PROG_END))
903 if (check_fail(nandbus))
910 small_program_oob(device_t nand, uint32_t page, void* buf, uint32_t len,
913 struct nand_chip *chip;
917 nand_debug(NDBG_GEN,"%p small prog oob %x[%x] at %x", nand, page, len, offset);
918 chip = device_get_softc(nand);
919 nandbus = device_get_parent(nand);
921 if (nand_check_page_boundary(chip, page))
924 page_to_row(&chip->chip_geom, page, &row);
926 if (!can_write(nandbus))
929 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_SMALLOOB))
932 if (send_start_program_page(nand, row, offset))
935 NANDBUS_WRITE_BUFFER(nandbus, buf, len);
937 if (send_end_program_page(nandbus, NAND_CMD_PROG_END))
942 if (check_fail(nandbus))
949 nand_send_address(device_t nand, int32_t row, int32_t col, int8_t id)
951 struct nandbus_ivar *ivar;
957 nandbus = device_get_parent(nand);
958 ivar = device_get_ivars(nand);
961 nand_debug(NDBG_GEN,"send_address: send id %02x", id);
962 err = NANDBUS_SEND_ADDRESS(nandbus, id);
965 if (!err && col != -1) {
966 for (i = 0; i < ivar->cols; i++, col >>= 8) {
967 addr = (uint8_t)(col & 0xff);
968 nand_debug(NDBG_GEN,"send_address: send address column "
970 err = NANDBUS_SEND_ADDRESS(nandbus, addr);
976 if (!err && row != -1) {
977 for (i = 0; i < ivar->rows; i++, row >>= 8) {
978 addr = (uint8_t)(row & 0xff);
979 nand_debug(NDBG_GEN,"send_address: send address row "
981 err = NANDBUS_SEND_ADDRESS(nandbus, addr);
991 generic_is_blk_bad(device_t dev, uint32_t block, uint8_t *bad)
993 struct nand_chip *chip;
994 int page_number, err, i;
997 chip = device_get_softc(dev);
999 oob = malloc(chip->chip_geom.oob_size, M_NAND, M_WAITOK);
1001 page_number = block * chip->chip_geom.pgs_per_blk;
1004 /* Check OOB of first and second page */
1005 for (i = 0; i < 2; i++) {
1006 err = NAND_READ_OOB(dev, page_number + i, oob,
1007 chip->chip_geom.oob_size, 0);
1009 device_printf(dev, "%s: cannot allocate OOB\n",
1028 generic_get_ecc(device_t dev, void *buf, void *ecc, int *needwrite)
1030 struct nand_chip *chip = device_get_softc(dev);
1031 struct chip_geom *cg = &chip->chip_geom;
1033 return (NANDBUS_GET_ECC(device_get_parent(dev), buf, cg->page_size,
1038 generic_correct_ecc(device_t dev, void *buf, void *readecc, void *calcecc)
1040 struct nand_chip *chip = device_get_softc(dev);
1041 struct chip_geom *cg = &chip->chip_geom;
1043 return (NANDBUS_CORRECT_ECC(device_get_parent(dev), buf,
1044 cg->page_size, readecc, calcecc));
1050 nand_chng_read_col(device_t nand, uint32_t col, void *buf, size_t len)
1052 struct nand_chip *chip;
1055 chip = device_get_softc(nand);
1056 nandbus = device_get_parent(nand);
1058 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_CHNG_READ_COL))
1061 if (NANDBUS_SEND_ADDRESS(nandbus, -1, col, -1))
1064 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_CHNG_READ_COL_END))
1067 if (NANDBUS_START_COMMAND(nandbus))
1070 if (buf != NULL && len > 0)
1071 NANDBUS_READ_BUFFER(nandbus, buf, len);
1077 nand_chng_write_col(device_t dev, uint32_t col, void *buf,
1080 struct nand_chip *chip;
1083 chip = device_get_softc(dev);
1084 nandbus = device_get_parent(dev);
1086 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_CHNG_WRITE_COL))
1089 if (NANDBUS_SEND_ADDRESS(nandbus, -1, col, -1))
1092 if (buf != NULL && len > 0)
1093 NANDBUS_WRITE_BUFFER(nandbus, buf, len);
1095 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_CHNG_READ_COL_END))
1098 if (NANDBUS_START_COMMAND(nandbus))
1105 nand_copyback_read(device_t dev, uint32_t page, uint32_t col,
1106 void *buf, size_t len)
1108 struct nand_chip *chip;
1109 struct page_stat *pg_stat;
1113 nand_debug(NDBG_GEN," raw read page %x[%x] at %x", page, col, len);
1114 chip = device_get_softc(dev);
1115 nandbus = device_get_parent(dev);
1117 if (nand_check_page_boundary(chip, page))
1120 page_to_row(&chip->chip_geom, page, &row);
1122 if (send_read_page(nand, NAND_CMD_READ, NAND_CMD_READ_CPBK, row, 0))
1126 if (check_fail(nandbus))
1129 if (buf != NULL && len > 0)
1130 NANDBUS_READ_BUFFER(nandbus, buf, len);
1132 pg_stat = &(chip->pg_stat[page]);
1133 pg_stat->page_raw_read++;
1139 nand_copyback_prog(device_t dev, uint32_t page, uint32_t col,
1140 void *buf, size_t len)
1142 struct nand_chip *chip;
1143 struct page_stat *pg_stat;
1147 nand_debug(NDBG_GEN,"copyback prog page %x[%x]", page, len);
1148 chip = device_get_softc(dev);
1149 nandbus = device_get_parent(dev);
1151 if (nand_check_page_boundary(chip, page))
1154 page_to_row(&chip->chip_geom, page, &row);
1156 if (!can_write(nandbus))
1159 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_CHNG_WRITE_COL))
1162 if (NANDBUS_SEND_ADDRESS(nandbus, row, col, -1))
1165 if (buf != NULL && len > 0)
1166 NANDBUS_WRITE_BUFFER(nandbus, buf, len);
1168 if (send_end_program_page(nandbus, NAND_CMD_PROG_END))
1171 DELAY(chip->t_prog);
1173 if (check_fail(nandbus))
1176 pg_stat = &(chip->pg_stat[page]);
1177 pg_stat->page_raw_written++;
1183 nand_copyback_prog_intlv(device_t dev, uint32_t page)
1185 struct nand_chip *chip;
1186 struct page_stat *pg_stat;
1190 nand_debug(NDBG_GEN,"cache prog page %x", page);
1191 chip = device_get_softc(dev);
1192 nandbus = device_get_parent(dev);
1194 if (nand_check_page_boundary(chip, page))
1197 page_to_row(&chip->chip_geom, page, &row);
1199 if (!can_write(nandbus))
1202 if (send_start_program_page(nand, row, 0))
1205 if (send_end_program_page(nandbus, NAND_CMD_PROG_INTLV))
1208 DELAY(chip->t_prog);
1210 if (check_fail(nandbus))
1213 pg_stat = &(chip->pg_stat[page]);
1214 pg_stat->page_raw_written++;
1220 nand_prog_cache(device_t dev, uint32_t page, uint32_t col,
1221 void *buf, size_t len, uint8_t end)
1223 struct nand_chip *chip;
1224 struct page_stat *pg_stat;
1229 nand_debug(NDBG_GEN,"cache prog page %x[%x]", page, len);
1230 chip = device_get_softc(dev);
1231 nandbus = device_get_parent(dev);
1233 if (nand_check_page_boundary(chip, page))
1236 page_to_row(&chip->chip_geom, page, &row);
1238 if (!can_write(nandbus))
1241 if (send_start_program_page(dev, row, 0))
1244 NANDBUS_WRITE_BUFFER(nandbus, buf, len);
1247 command = NAND_CMD_PROG_END;
1249 command = NAND_CMD_PROG_CACHE;
1251 if (send_end_program_page(nandbus, command))
1254 DELAY(chip->t_prog);
1256 if (check_fail(nandbus))
1259 pg_stat = &(chip->pg_stat[page]);
1260 pg_stat->page_raw_written++;
1266 nand_read_cache(device_t dev, uint32_t page, uint32_t col,
1267 void *buf, size_t len, uint8_t end)
1269 struct nand_chip *chip;
1270 struct page_stat *pg_stat;
1275 nand_debug(NDBG_GEN,"cache read page %x[%x] ", page, len);
1276 chip = device_get_softc(dev);
1277 nandbus = device_get_parent(dev);
1279 if (nand_check_page_boundary(chip, page))
1282 page_to_row(&chip->chip_geom, page, &row);
1285 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_READ))
1288 if (NANDBUS_SEND_ADDRESS(nandbus, row, col, -1))
1293 command = NAND_CMD_READ_CACHE_END;
1295 command = NAND_CMD_READ_CACHE;
1297 if (NANDBUS_SEND_COMMAND(nandbus, command))
1300 if (NANDBUS_START_COMMAND(nandbus))
1304 if (check_fail(nandbus))
1307 if (buf != NULL && len > 0)
1308 NANDBUS_READ_BUFFER(nandbus, buf, len);
1310 pg_stat = &(chip->pg_stat[page]);
1311 pg_stat->page_raw_read++;
1317 nand_get_feature(device_t dev, uint8_t feat, void *buf)
1319 struct nand_chip *chip;
1322 nand_debug(NDBG_GEN,"nand get feature");
1324 chip = device_get_softc(dev);
1325 nandbus = device_get_parent(dev);
1327 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_GET_FEATURE))
1330 if (NANDBUS_SEND_ADDRESS(nandbus, -1, -1, feat))
1333 if (NANDBUS_START_COMMAND(nandbus))
1337 NANDBUS_READ_BUFFER(nandbus, buf, 4);
1343 nand_set_feature(device_t dev, uint8_t feat, void *buf)
1345 struct nand_chip *chip;
1348 nand_debug(NDBG_GEN,"nand set feature");
1350 chip = device_get_softc(dev);
1351 nandbus = device_get_parent(dev);
1353 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_SET_FEATURE))
1356 if (NANDBUS_SEND_ADDRESS(nandbus, -1, -1, feat))
1359 NANDBUS_WRITE_BUFFER(nandbus, buf, 4);
1361 if (NANDBUS_START_COMMAND(nandbus))