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/kernel.h>
38 #include <sys/module.h>
41 #include <sys/mutex.h>
43 #include <sys/malloc.h>
45 #include <dev/nand/nand.h>
46 #include <dev/nand/nandbus.h>
49 #include "nandbus_if.h"
52 static int onfi_nand_probe(device_t dev);
53 static int large_nand_probe(device_t dev);
54 static int small_nand_probe(device_t dev);
55 static int generic_nand_attach(device_t dev);
56 static int generic_nand_detach(device_t dev);
58 static int generic_erase_block(device_t, uint32_t);
59 static int generic_erase_block_intlv(device_t, uint32_t);
60 static int generic_read_page (device_t, uint32_t, void *, uint32_t, uint32_t);
61 static int generic_read_oob(device_t, uint32_t, void *, uint32_t, uint32_t);
62 static int generic_program_page(device_t, uint32_t, void *, uint32_t, uint32_t);
63 static int generic_program_page_intlv(device_t, uint32_t, void *, uint32_t,
65 static int generic_program_oob(device_t, uint32_t, void *, uint32_t, uint32_t);
66 static int generic_is_blk_bad(device_t, uint32_t, uint8_t *);
67 static int generic_get_ecc(device_t, void *, void *, int *);
68 static int generic_correct_ecc(device_t, void *, void *, void *);
70 static int small_read_page(device_t, uint32_t, void *, uint32_t, uint32_t);
71 static int small_read_oob(device_t, uint32_t, void *, uint32_t, uint32_t);
72 static int small_program_page(device_t, uint32_t, void *, uint32_t, uint32_t);
73 static int small_program_oob(device_t, uint32_t, void *, uint32_t, uint32_t);
75 static int onfi_is_blk_bad(device_t, uint32_t, uint8_t *);
76 static int onfi_read_parameter(struct nand_chip *, struct onfi_params *);
78 static int nand_send_address(device_t, int32_t, int32_t, int8_t);
80 static device_method_t onand_methods[] = {
81 /* Device interface */
82 DEVMETHOD(device_probe, onfi_nand_probe),
83 DEVMETHOD(device_attach, generic_nand_attach),
84 DEVMETHOD(device_detach, generic_nand_detach),
86 DEVMETHOD(nand_read_page, generic_read_page),
87 DEVMETHOD(nand_program_page, generic_program_page),
88 DEVMETHOD(nand_program_page_intlv, generic_program_page_intlv),
89 DEVMETHOD(nand_read_oob, generic_read_oob),
90 DEVMETHOD(nand_program_oob, generic_program_oob),
91 DEVMETHOD(nand_erase_block, generic_erase_block),
92 DEVMETHOD(nand_erase_block_intlv, generic_erase_block_intlv),
94 DEVMETHOD(nand_is_blk_bad, onfi_is_blk_bad),
95 DEVMETHOD(nand_get_ecc, generic_get_ecc),
96 DEVMETHOD(nand_correct_ecc, generic_correct_ecc),
100 static device_method_t lnand_methods[] = {
101 /* Device interface */
102 DEVMETHOD(device_probe, large_nand_probe),
103 DEVMETHOD(device_attach, generic_nand_attach),
104 DEVMETHOD(device_detach, generic_nand_detach),
106 DEVMETHOD(nand_read_page, generic_read_page),
107 DEVMETHOD(nand_program_page, generic_program_page),
108 DEVMETHOD(nand_read_oob, generic_read_oob),
109 DEVMETHOD(nand_program_oob, generic_program_oob),
110 DEVMETHOD(nand_erase_block, generic_erase_block),
112 DEVMETHOD(nand_is_blk_bad, generic_is_blk_bad),
113 DEVMETHOD(nand_get_ecc, generic_get_ecc),
114 DEVMETHOD(nand_correct_ecc, generic_correct_ecc),
118 static device_method_t snand_methods[] = {
119 /* Device interface */
120 DEVMETHOD(device_probe, small_nand_probe),
121 DEVMETHOD(device_attach, generic_nand_attach),
122 DEVMETHOD(device_detach, generic_nand_detach),
124 DEVMETHOD(nand_read_page, small_read_page),
125 DEVMETHOD(nand_program_page, small_program_page),
126 DEVMETHOD(nand_read_oob, small_read_oob),
127 DEVMETHOD(nand_program_oob, small_program_oob),
128 DEVMETHOD(nand_erase_block, generic_erase_block),
130 DEVMETHOD(nand_is_blk_bad, generic_is_blk_bad),
131 DEVMETHOD(nand_get_ecc, generic_get_ecc),
132 DEVMETHOD(nand_correct_ecc, generic_correct_ecc),
136 devclass_t onand_devclass;
137 devclass_t lnand_devclass;
138 devclass_t snand_devclass;
140 driver_t onand_driver = {
143 sizeof(struct nand_chip)
146 driver_t lnand_driver = {
149 sizeof(struct nand_chip)
152 driver_t snand_driver = {
155 sizeof(struct nand_chip)
158 DRIVER_MODULE(onand, nandbus, onand_driver, onand_devclass, 0, 0);
159 DRIVER_MODULE(lnand, nandbus, lnand_driver, lnand_devclass, 0, 0);
160 DRIVER_MODULE(snand, nandbus, snand_driver, snand_devclass, 0, 0);
163 onfi_nand_probe(device_t dev)
165 struct nandbus_ivar *ivar;
167 ivar = device_get_ivars(dev);
168 if (ivar && ivar->is_onfi) {
169 device_set_desc(dev, "ONFI compliant NAND");
170 return (BUS_PROBE_DEFAULT);
177 large_nand_probe(device_t dev)
179 struct nandbus_ivar *ivar;
181 ivar = device_get_ivars(dev);
182 if (ivar && !ivar->is_onfi && ivar->params->page_size >= 512) {
183 device_set_desc(dev, ivar->params->name);
184 return (BUS_PROBE_DEFAULT);
191 small_nand_probe(device_t dev)
193 struct nandbus_ivar *ivar;
195 ivar = device_get_ivars(dev);
196 if (ivar && !ivar->is_onfi && ivar->params->page_size == 512) {
197 device_set_desc(dev, ivar->params->name);
198 return (BUS_PROBE_DEFAULT);
205 generic_nand_attach(device_t dev)
207 struct nand_chip *chip;
208 struct nandbus_ivar *ivar;
209 struct onfi_params *onfi_params;
210 device_t nandbus, nfc;
213 chip = device_get_softc(dev);
216 ivar = device_get_ivars(dev);
217 chip->id.man_id = ivar->man_id;
218 chip->id.dev_id = ivar->dev_id;
219 chip->num = ivar->cs;
221 /* TODO remove when HW ECC supported */
222 nandbus = device_get_parent(dev);
223 nfc = device_get_parent(nandbus);
225 chip->nand = device_get_softc(nfc);
228 onfi_params = malloc(sizeof(struct onfi_params),
229 M_NAND, M_WAITOK | M_ZERO);
230 if (onfi_params == NULL)
233 if (onfi_read_parameter(chip, onfi_params)) {
234 nand_debug(NDBG_GEN,"Could not read parameter page!\n");
235 free(onfi_params, M_NAND);
239 nand_onfi_set_params(chip, onfi_params);
240 /* Set proper column and row cycles */
241 ivar->cols = (onfi_params->address_cycles >> 4) & 0xf;
242 ivar->rows = onfi_params->address_cycles & 0xf;
243 free(onfi_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_read_parameter(struct nand_chip *chip, struct onfi_params *params)
327 nand_debug(NDBG_GEN,"read parameter");
329 nandbus = device_get_parent(chip->dev);
331 NANDBUS_SELECT_CS(nandbus, chip->num);
333 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_READ_PARAMETER))
336 if (nand_send_address(chip->dev, -1, -1, PAGE_PARAMETER_DEF))
339 if (NANDBUS_START_COMMAND(nandbus))
342 NANDBUS_READ_BUFFER(nandbus, params, sizeof(struct onfi_params));
345 /* Check for signature */
347 /* Use redundant page if necessary */
353 send_read_page(device_t nand, uint8_t start_command, uint8_t end_command,
354 uint32_t row, uint32_t column)
356 device_t nandbus = device_get_parent(nand);
358 if (NANDBUS_SEND_COMMAND(nandbus, start_command))
361 if (nand_send_address(nand, row, column, -1))
364 if (NANDBUS_SEND_COMMAND(nandbus, end_command))
367 if (NANDBUS_START_COMMAND(nandbus))
374 generic_read_page(device_t nand, uint32_t page, void *buf, uint32_t len,
377 struct nand_chip *chip;
378 struct page_stat *pg_stat;
382 nand_debug(NDBG_GEN,"%p raw read page %x[%x] at %x", nand, page, len, offset);
383 chip = device_get_softc(nand);
384 nandbus = device_get_parent(nand);
386 if (nand_check_page_boundary(chip, page))
389 page_to_row(&chip->chip_geom, page, &row);
391 if (send_read_page(nand, NAND_CMD_READ, NAND_CMD_READ_END, row,
397 NANDBUS_READ_BUFFER(nandbus, buf, len);
399 if (check_fail(nandbus))
402 pg_stat = &(chip->pg_stat[page]);
403 pg_stat->page_raw_read++;
409 generic_read_oob(device_t nand, uint32_t page, void* buf, uint32_t len,
412 struct nand_chip *chip;
416 nand_debug(NDBG_GEN,"%p raw read oob %x[%x] at %x", nand, page, len, offset);
417 chip = device_get_softc(nand);
418 nandbus = device_get_parent(nand);
420 if (nand_check_page_boundary(chip, page)) {
421 nand_debug(NDBG_GEN,"page boundary check failed: %08x\n", page);
425 page_to_row(&chip->chip_geom, page, &row);
427 offset += chip->chip_geom.page_size;
429 if (send_read_page(nand, NAND_CMD_READ, NAND_CMD_READ_END, row,
435 NANDBUS_READ_BUFFER(nandbus, buf, len);
437 if (check_fail(nandbus))
444 send_start_program_page(device_t nand, uint32_t row, uint32_t column)
446 device_t nandbus = device_get_parent(nand);
448 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_PROG))
451 if (nand_send_address(nand, row, column, -1))
458 send_end_program_page(device_t nandbus, uint8_t end_command)
461 if (NANDBUS_SEND_COMMAND(nandbus, end_command))
464 if (NANDBUS_START_COMMAND(nandbus))
471 generic_program_page(device_t nand, uint32_t page, void *buf, uint32_t len,
474 struct nand_chip *chip;
475 struct page_stat *pg_stat;
479 nand_debug(NDBG_GEN,"%p raw prog page %x[%x] at %x", nand, page, len,
481 chip = device_get_softc(nand);
482 nandbus = device_get_parent(nand);
484 if (nand_check_page_boundary(chip, page))
487 page_to_row(&chip->chip_geom, page, &row);
489 if (!can_write(nandbus))
492 if (send_start_program_page(nand, row, offset))
495 NANDBUS_WRITE_BUFFER(nandbus, buf, len);
497 if (send_end_program_page(nandbus, NAND_CMD_PROG_END))
502 if (check_fail(nandbus))
505 pg_stat = &(chip->pg_stat[page]);
506 pg_stat->page_raw_written++;
512 generic_program_page_intlv(device_t nand, uint32_t page, void *buf,
513 uint32_t len, uint32_t offset)
515 struct nand_chip *chip;
516 struct page_stat *pg_stat;
520 nand_debug(NDBG_GEN,"%p raw prog page %x[%x] at %x", nand, page, len, offset);
521 chip = device_get_softc(nand);
522 nandbus = device_get_parent(nand);
524 if (nand_check_page_boundary(chip, page))
527 page_to_row(&chip->chip_geom, page, &row);
529 if (!can_write(nandbus))
532 if (send_start_program_page(nand, row, offset))
535 NANDBUS_WRITE_BUFFER(nandbus, buf, len);
537 if (send_end_program_page(nandbus, NAND_CMD_PROG_INTLV))
542 if (check_fail(nandbus))
545 pg_stat = &(chip->pg_stat[page]);
546 pg_stat->page_raw_written++;
552 generic_program_oob(device_t nand, uint32_t page, void* buf, uint32_t len,
555 struct nand_chip *chip;
559 nand_debug(NDBG_GEN,"%p raw prog oob %x[%x] at %x", nand, page, len,
561 chip = device_get_softc(nand);
562 nandbus = device_get_parent(nand);
564 if (nand_check_page_boundary(chip, page))
567 page_to_row(&chip->chip_geom, page, &row);
568 offset += chip->chip_geom.page_size;
570 if (!can_write(nandbus))
573 if (send_start_program_page(nand, row, offset))
576 NANDBUS_WRITE_BUFFER(nandbus, buf, len);
578 if (send_end_program_page(nandbus, NAND_CMD_PROG_END))
583 if (check_fail(nandbus))
590 send_erase_block(device_t nand, uint32_t row, uint8_t second_command)
592 device_t nandbus = device_get_parent(nand);
594 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_ERASE))
597 if (nand_send_address(nand, row, -1, -1))
600 if (NANDBUS_SEND_COMMAND(nandbus, second_command))
603 if (NANDBUS_START_COMMAND(nandbus))
610 generic_erase_block(device_t nand, uint32_t block)
612 struct block_stat *blk_stat;
613 struct nand_chip *chip;
617 nand_debug(NDBG_GEN,"%p erase block %x", nand, block);
618 nandbus = device_get_parent(nand);
619 chip = device_get_softc(nand);
621 if (block >= (chip->chip_geom.blks_per_lun * chip->chip_geom.luns))
624 row = (block << chip->chip_geom.blk_shift) &
625 chip->chip_geom.blk_mask;
627 nand_debug(NDBG_GEN,"%p erase block row %x", nand, row);
629 if (!can_write(nandbus))
632 send_erase_block(nand, row, NAND_CMD_ERASE_END);
636 if (check_fail(nandbus))
639 blk_stat = &(chip->blk_stat[block]);
640 blk_stat->block_erased++;
646 generic_erase_block_intlv(device_t nand, uint32_t block)
648 struct block_stat *blk_stat;
649 struct nand_chip *chip;
653 nand_debug(NDBG_GEN,"%p erase block %x", nand, block);
654 nandbus = device_get_parent(nand);
655 chip = device_get_softc(nand);
657 if (block >= (chip->chip_geom.blks_per_lun * chip->chip_geom.luns))
660 row = (block << chip->chip_geom.blk_shift) &
661 chip->chip_geom.blk_mask;
663 if (!can_write(nandbus))
666 send_erase_block(nand, row, NAND_CMD_ERASE_INTLV);
670 if (check_fail(nandbus))
673 blk_stat = &(chip->blk_stat[block]);
674 blk_stat->block_erased++;
681 onfi_is_blk_bad(device_t device, uint32_t block_number, uint8_t *bad)
683 struct nand_chip *chip;
684 int page_number, i, j, err;
687 chip = device_get_softc(device);
689 oob = malloc(chip->chip_geom.oob_size, M_NAND, M_WAITOK);
691 device_printf(device, "%s: cannot allocate oob\n", __func__);
695 page_number = block_number * chip->chip_geom.pgs_per_blk;
697 /* Check OOB of first and last page */
698 for (i = 0; i < 2; i++, page_number+= chip->chip_geom.pgs_per_blk - 1) {
699 err = generic_read_oob(device, page_number, oob,
700 chip->chip_geom.oob_size, 0);
702 device_printf(device, "%s: cannot allocate oob\n",
708 for (j = 0; j < chip->chip_geom.oob_size; j++) {
723 send_small_read_page(device_t nand, uint8_t start_command,
724 uint32_t row, uint32_t column)
726 device_t nandbus = device_get_parent(nand);
728 if (NANDBUS_SEND_COMMAND(nandbus, start_command))
731 if (nand_send_address(nand, row, column, -1))
734 if (NANDBUS_START_COMMAND(nandbus))
742 small_read_page(device_t nand, uint32_t page, void *buf, uint32_t len,
745 struct nand_chip *chip;
746 struct page_stat *pg_stat;
750 nand_debug(NDBG_GEN,"%p small read page %x[%x] at %x", nand, page, len, offset);
751 chip = device_get_softc(nand);
752 nandbus = device_get_parent(nand);
754 if (nand_check_page_boundary(chip, page))
757 page_to_row(&chip->chip_geom, page, &row);
760 if (send_small_read_page(nand, NAND_CMD_SMALLA, row, offset))
764 if (send_small_read_page(nandbus, NAND_CMD_SMALLB, row, offset))
770 NANDBUS_READ_BUFFER(nandbus, buf, len);
772 if (check_fail(nandbus))
775 pg_stat = &(chip->pg_stat[page]);
776 pg_stat->page_raw_read++;
782 small_read_oob(device_t nand, uint32_t page, void *buf, uint32_t len,
785 struct nand_chip *chip;
786 struct page_stat *pg_stat;
790 nand_debug(NDBG_GEN,"%p small read oob %x[%x] at %x", nand, page, len, offset);
791 chip = device_get_softc(nand);
792 nandbus = device_get_parent(nand);
794 if (nand_check_page_boundary(chip, page))
797 page_to_row(&chip->chip_geom, page, &row);
799 if (send_small_read_page(nand, NAND_CMD_SMALLOOB, row, 0))
804 NANDBUS_READ_BUFFER(nandbus, buf, len);
806 if (check_fail(nandbus))
809 pg_stat = &(chip->pg_stat[page]);
810 pg_stat->page_raw_read++;
816 small_program_page(device_t nand, uint32_t page, void* buf, uint32_t len,
819 struct nand_chip *chip;
823 nand_debug(NDBG_GEN,"%p small prog page %x[%x] at %x", nand, page, len, offset);
824 chip = device_get_softc(nand);
825 nandbus = device_get_parent(nand);
827 if (nand_check_page_boundary(chip, page))
830 page_to_row(&chip->chip_geom, page, &row);
832 if (!can_write(nandbus))
836 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_SMALLA))
839 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_SMALLB))
843 if (send_start_program_page(nand, row, offset))
846 NANDBUS_WRITE_BUFFER(nandbus, buf, len);
848 if (send_end_program_page(nandbus, NAND_CMD_PROG_END))
853 if (check_fail(nandbus))
860 small_program_oob(device_t nand, uint32_t page, void* buf, uint32_t len,
863 struct nand_chip *chip;
867 nand_debug(NDBG_GEN,"%p small prog oob %x[%x] at %x", nand, page, len, offset);
868 chip = device_get_softc(nand);
869 nandbus = device_get_parent(nand);
871 if (nand_check_page_boundary(chip, page))
874 page_to_row(&chip->chip_geom, page, &row);
876 if (!can_write(nandbus))
879 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_SMALLOOB))
882 if (send_start_program_page(nand, row, offset))
885 NANDBUS_WRITE_BUFFER(nandbus, buf, len);
887 if (send_end_program_page(nandbus, NAND_CMD_PROG_END))
892 if (check_fail(nandbus))
899 nand_send_address(device_t nand, int32_t row, int32_t col, int8_t id)
901 struct nandbus_ivar *ivar;
907 nandbus = device_get_parent(nand);
908 ivar = device_get_ivars(nand);
911 nand_debug(NDBG_GEN,"send_address: send id %02x", id);
912 err = NANDBUS_SEND_ADDRESS(nandbus, id);
915 if (!err && col != -1) {
916 for (i = 0; i < ivar->cols; i++, col >>= 8) {
917 addr = (uint8_t)(col & 0xff);
918 nand_debug(NDBG_GEN,"send_address: send address column "
920 err = NANDBUS_SEND_ADDRESS(nandbus, addr);
926 if (!err && row != -1) {
927 for (i = 0; i < ivar->rows; i++, row >>= 8) {
928 addr = (uint8_t)(row & 0xff);
929 nand_debug(NDBG_GEN,"send_address: send address row "
931 err = NANDBUS_SEND_ADDRESS(nandbus, addr);
941 generic_is_blk_bad(device_t dev, uint32_t block, uint8_t *bad)
943 struct nand_chip *chip;
944 int page_number, err, i;
947 chip = device_get_softc(dev);
949 oob = malloc(chip->chip_geom.oob_size, M_NAND, M_WAITOK);
951 device_printf(dev, "%s: cannot allocate OOB\n", __func__);
955 page_number = block * chip->chip_geom.pgs_per_blk;
958 /* Check OOB of first and second page */
959 for (i = 0; i < 2; i++) {
960 err = NAND_READ_OOB(dev, page_number + i, oob,
961 chip->chip_geom.oob_size, 0);
963 device_printf(dev, "%s: cannot allocate OOB\n",
982 generic_get_ecc(device_t dev, void *buf, void *ecc, int *needwrite)
984 struct nand_chip *chip = device_get_softc(dev);
985 struct chip_geom *cg = &chip->chip_geom;
987 return (NANDBUS_GET_ECC(device_get_parent(dev), buf, cg->page_size,
992 generic_correct_ecc(device_t dev, void *buf, void *readecc, void *calcecc)
994 struct nand_chip *chip = device_get_softc(dev);
995 struct chip_geom *cg = &chip->chip_geom;
997 return (NANDBUS_CORRECT_ECC(device_get_parent(dev), buf,
998 cg->page_size, readecc, calcecc));
1004 nand_chng_read_col(device_t nand, uint32_t col, void *buf, size_t len)
1006 struct nand_chip *chip;
1009 chip = device_get_softc(nand);
1010 nandbus = device_get_parent(nand);
1012 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_CHNG_READ_COL))
1015 if (NANDBUS_SEND_ADDRESS(nandbus, -1, col, -1))
1018 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_CHNG_READ_COL_END))
1021 if (NANDBUS_START_COMMAND(nandbus))
1024 if (buf != NULL && len > 0)
1025 NANDBUS_READ_BUFFER(nandbus, buf, len);
1031 nand_chng_write_col(device_t dev, uint32_t col, void *buf,
1034 struct nand_chip *chip;
1037 chip = device_get_softc(dev);
1038 nandbus = device_get_parent(dev);
1040 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_CHNG_WRITE_COL))
1043 if (NANDBUS_SEND_ADDRESS(nandbus, -1, col, -1))
1046 if (buf != NULL && len > 0)
1047 NANDBUS_WRITE_BUFFER(nandbus, buf, len);
1049 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_CHNG_READ_COL_END))
1052 if (NANDBUS_START_COMMAND(nandbus))
1059 nand_copyback_read(device_t dev, uint32_t page, uint32_t col,
1060 void *buf, size_t len)
1062 struct nand_chip *chip;
1063 struct page_stat *pg_stat;
1067 nand_debug(NDBG_GEN," raw read page %x[%x] at %x", page, col, len);
1068 chip = device_get_softc(dev);
1069 nandbus = device_get_parent(dev);
1071 if (nand_check_page_boundary(chip, page))
1074 page_to_row(&chip->chip_geom, page, &row);
1076 if (send_read_page(nand, NAND_CMD_READ, NAND_CMD_READ_CPBK, row, 0))
1080 if (check_fail(nandbus))
1083 if (buf != NULL && len > 0)
1084 NANDBUS_READ_BUFFER(nandbus, buf, len);
1086 pg_stat = &(chip->pg_stat[page]);
1087 pg_stat->page_raw_read++;
1093 nand_copyback_prog(device_t dev, uint32_t page, uint32_t col,
1094 void *buf, size_t len)
1096 struct nand_chip *chip;
1097 struct page_stat *pg_stat;
1101 nand_debug(NDBG_GEN,"copyback prog page %x[%x]", page, len);
1102 chip = device_get_softc(dev);
1103 nandbus = device_get_parent(dev);
1105 if (nand_check_page_boundary(chip, page))
1108 page_to_row(&chip->chip_geom, page, &row);
1110 if (!can_write(nandbus))
1113 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_CHNG_WRITE_COL))
1116 if (NANDBUS_SEND_ADDRESS(nandbus, row, col, -1))
1119 if (buf != NULL && len > 0)
1120 NANDBUS_WRITE_BUFFER(nandbus, buf, len);
1122 if (send_end_program_page(nandbus, NAND_CMD_PROG_END))
1125 DELAY(chip->t_prog);
1127 if (check_fail(nandbus))
1130 pg_stat = &(chip->pg_stat[page]);
1131 pg_stat->page_raw_written++;
1137 nand_copyback_prog_intlv(device_t dev, uint32_t page)
1139 struct nand_chip *chip;
1140 struct page_stat *pg_stat;
1144 nand_debug(NDBG_GEN,"cache prog page %x", page);
1145 chip = device_get_softc(dev);
1146 nandbus = device_get_parent(dev);
1148 if (nand_check_page_boundary(chip, page))
1151 page_to_row(&chip->chip_geom, page, &row);
1153 if (!can_write(nandbus))
1156 if (send_start_program_page(nand, row, 0))
1159 if (send_end_program_page(nandbus, NAND_CMD_PROG_INTLV))
1162 DELAY(chip->t_prog);
1164 if (check_fail(nandbus))
1167 pg_stat = &(chip->pg_stat[page]);
1168 pg_stat->page_raw_written++;
1174 nand_prog_cache(device_t dev, uint32_t page, uint32_t col,
1175 void *buf, size_t len, uint8_t end)
1177 struct nand_chip *chip;
1178 struct page_stat *pg_stat;
1183 nand_debug(NDBG_GEN,"cache prog page %x[%x]", page, len);
1184 chip = device_get_softc(dev);
1185 nandbus = device_get_parent(dev);
1187 if (nand_check_page_boundary(chip, page))
1190 page_to_row(&chip->chip_geom, page, &row);
1192 if (!can_write(nandbus))
1195 if (send_start_program_page(dev, row, 0))
1198 NANDBUS_WRITE_BUFFER(nandbus, buf, len);
1201 command = NAND_CMD_PROG_END;
1203 command = NAND_CMD_PROG_CACHE;
1205 if (send_end_program_page(nandbus, command))
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_read_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 read 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);
1239 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_READ))
1242 if (NANDBUS_SEND_ADDRESS(nandbus, row, col, -1))
1247 command = NAND_CMD_READ_CACHE_END;
1249 command = NAND_CMD_READ_CACHE;
1251 if (NANDBUS_SEND_COMMAND(nandbus, command))
1254 if (NANDBUS_START_COMMAND(nandbus))
1258 if (check_fail(nandbus))
1261 if (buf != NULL && len > 0)
1262 NANDBUS_READ_BUFFER(nandbus, buf, len);
1264 pg_stat = &(chip->pg_stat[page]);
1265 pg_stat->page_raw_read++;
1271 nand_get_feature(device_t dev, uint8_t feat, void *buf)
1273 struct nand_chip *chip;
1276 nand_debug(NDBG_GEN,"nand get feature");
1278 chip = device_get_softc(dev);
1279 nandbus = device_get_parent(dev);
1281 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_GET_FEATURE))
1284 if (NANDBUS_SEND_ADDRESS(nandbus, -1, -1, feat))
1287 if (NANDBUS_START_COMMAND(nandbus))
1291 NANDBUS_READ_BUFFER(nandbus, buf, 4);
1297 nand_set_feature(device_t dev, uint8_t feat, void *buf)
1299 struct nand_chip *chip;
1302 nand_debug(NDBG_GEN,"nand set feature");
1304 chip = device_get_softc(dev);
1305 nandbus = device_get_parent(dev);
1307 if (NANDBUS_SEND_COMMAND(nandbus, NAND_CMD_SET_FEATURE))
1310 if (NANDBUS_SEND_ADDRESS(nandbus, -1, -1, feat))
1313 NANDBUS_WRITE_BUFFER(nandbus, buf, 4);
1315 if (NANDBUS_START_COMMAND(nandbus))