2 * Copyright (C) 2015 Justin Hibbits
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 /* RouterBoard 600/800 NAND controller driver. */
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
32 #include <sys/param.h>
33 #include <sys/systm.h>
35 #include <sys/kernel.h>
36 #include <sys/module.h>
37 #include <sys/malloc.h>
40 #include <machine/bus.h>
42 #include <dev/ofw/ofw_bus.h>
43 #include <dev/ofw/ofw_bus_subr.h>
45 #include <dev/nand/nand.h>
46 #include <dev/nand/nandbus.h>
48 #include <powerpc/mpc85xx/mpc85xx.h>
53 #define RB_NAND_DATA (0x00)
55 struct rb_nand_softc {
56 struct nand_softc nand_dev;
57 struct resource *sc_mem;
66 static int rb_nand_attach(device_t);
67 static int rb_nand_probe(device_t);
68 static int rb_nand_send_command(device_t, uint8_t);
69 static int rb_nand_send_address(device_t, uint8_t);
70 static uint8_t rb_nand_read_byte(device_t);
71 static void rb_nand_read_buf(device_t, void *, uint32_t);
72 static void rb_nand_write_buf(device_t, void *, uint32_t);
73 static int rb_nand_select_cs(device_t, uint8_t);
74 static int rb_nand_read_rnb(device_t);
76 static device_method_t rb_nand_methods[] = {
77 DEVMETHOD(device_probe, rb_nand_probe),
78 DEVMETHOD(device_attach, rb_nand_attach),
80 DEVMETHOD(nfc_send_command, rb_nand_send_command),
81 DEVMETHOD(nfc_send_address, rb_nand_send_address),
82 DEVMETHOD(nfc_read_byte, rb_nand_read_byte),
83 DEVMETHOD(nfc_read_buf, rb_nand_read_buf),
84 DEVMETHOD(nfc_write_buf, rb_nand_write_buf),
85 DEVMETHOD(nfc_select_cs, rb_nand_select_cs),
86 DEVMETHOD(nfc_read_rnb, rb_nand_read_rnb),
91 static driver_t rb_nand_driver = {
94 sizeof(struct rb_nand_softc),
97 static devclass_t rb_nand_devclass;
98 DRIVER_MODULE(rb_nand, ofwbus, rb_nand_driver, rb_nand_devclass, 0, 0);
101 static const struct nand_ecc_data rb_ecc = {
103 .eccmode = NAND_ECC_SOFT,
105 .eccpositions = { 8, 9, 10, 13, 14, 15 },
110 rb_nand_probe(device_t dev)
112 const char *device_type;
114 device_type = ofw_bus_get_type(dev);
116 if (!device_type || strcmp(device_type, "rb,nand"))
119 device_set_desc(dev, "RouterBoard 333/600/800 NAND controller");
120 return (BUS_PROBE_DEFAULT);
124 rb_nand_attach(device_t dev)
126 struct rb_nand_softc *sc;
128 uint32_t ale[2],cle[2],nce[2],rdy[2];
132 sc = device_get_softc(dev);
133 node = ofw_bus_get_node(dev);
135 if (OF_getprop(node, "ale", ale, sizeof(ale)) <= 0) {
138 if (OF_getprop(node, "cle", cle, sizeof(cle)) <= 0) {
141 if (OF_getprop(node, "nce", nce, sizeof(nce)) <= 0) {
144 if (OF_getprop(node, "rdy", rdy, sizeof(rdy)) <= 0) {
148 if (ale[0] != cle[0] || ale[0] != nce[0] || ale[0] != rdy[0]) {
149 device_printf(dev, "GPIO handles for signals must match.\n");
152 sc->sc_ale_pin = ale[1];
153 sc->sc_cle_pin = cle[1];
154 sc->sc_nce_pin = nce[1];
155 sc->sc_rdy_pin = rdy[1];
157 sc->sc_gpio = OF_device_from_xref(ale[0]);
158 if (sc->sc_gpio == NULL) {
159 device_printf(dev, "No GPIO resource found!\n");
163 sc->sc_mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &sc->rid,
165 if (sc->sc_mem == NULL) {
166 device_printf(dev, "could not allocate resources!\n");
170 start = rman_get_start(sc->sc_mem);
171 size = rman_get_size(sc->sc_mem);
172 if (law_enable(OCP85XX_TGTIF_LBC, start, size) != 0) {
173 bus_release_resource(dev, SYS_RES_MEMORY, sc->rid, sc->sc_mem);
174 device_printf(dev, "could not allocate local address window.\n");
178 nand_init(&sc->nand_dev, dev, NAND_ECC_SOFT, 0, 0, NULL, NULL);
180 err = nandbus_create(dev);
186 rb_nand_send_command(device_t dev, uint8_t command)
188 struct rb_nand_softc *sc;
190 nand_debug(NDBG_DRV,"rb_nand: send command %x", command);
192 sc = device_get_softc(dev);
193 GPIO_PIN_SET(sc->sc_gpio, sc->sc_cle_pin, 1);
194 GPIO_PIN_SET(sc->sc_gpio, sc->sc_ale_pin, 0);
195 GPIO_PIN_SET(sc->sc_gpio, sc->sc_nce_pin, 0);
196 bus_write_1(sc->sc_mem, RB_NAND_DATA, command);
197 GPIO_PIN_SET(sc->sc_gpio, sc->sc_cle_pin, 0);
202 rb_nand_send_address(device_t dev, uint8_t addr)
204 struct rb_nand_softc *sc;
206 nand_debug(NDBG_DRV,"rb_nand: send address %x", addr);
208 sc = device_get_softc(dev);
209 GPIO_PIN_SET(sc->sc_gpio, sc->sc_cle_pin, 0);
210 GPIO_PIN_SET(sc->sc_gpio, sc->sc_ale_pin, 1);
211 GPIO_PIN_SET(sc->sc_gpio, sc->sc_nce_pin, 0);
212 bus_write_1(sc->sc_mem, RB_NAND_DATA, addr);
213 GPIO_PIN_SET(sc->sc_gpio, sc->sc_ale_pin, 0);
218 rb_nand_read_byte(device_t dev)
220 struct rb_nand_softc *sc;
223 sc = device_get_softc(dev);
224 data = bus_read_1(sc->sc_mem, RB_NAND_DATA);
226 nand_debug(NDBG_DRV,"rb_nand: read %x", data);
232 rb_nand_read_buf(device_t dev, void* buf, uint32_t len)
234 struct rb_nand_softc *sc;
236 sc = device_get_softc(dev);
238 bus_read_region_1(sc->sc_mem, RB_NAND_DATA, buf, len);
242 rb_nand_write_buf(device_t dev, void* buf, uint32_t len)
244 struct rb_nand_softc *sc;
246 uint8_t *b = (uint8_t*)buf;
248 sc = device_get_softc(dev);
250 for (i = 0; i < len; i++) {
253 printf("%s", i == 0 ? "rb_nand:\n" : "\n");
258 bus_write_1(sc->sc_mem, RB_NAND_DATA, b[i]);
263 rb_nand_select_cs(device_t dev, uint8_t cs)
273 rb_nand_read_rnb(device_t dev)
275 struct rb_nand_softc *sc;
278 sc = device_get_softc(dev);
279 GPIO_PIN_GET(sc->sc_gpio, sc->sc_rdy_pin, &rdy_bit);
281 return (rdy_bit); /* ready */