1 /*- 2 * Copyright (c) 2006 M. Warner Losh. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 1. Redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer. 9 * 2. Redistributions in binary form must reproduce the above copyright 10 * notice, this list of conditions and the following disclaimer in the 11 * documentation and/or other materials provided with the distribution. 12 * 13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 14 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 15 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 16 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 17 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 18 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 19 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 20 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 21 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 22 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 23 */ 24 25 #include <sys/cdefs.h> 26 __FBSDID("$FreeBSD$"); 27 28 #include <sys/param.h> 29 #include <sys/systm.h> 30 #include <sys/bio.h> 31 #include <sys/bus.h> 32 #include <sys/conf.h> 33 #include <sys/gpio.h> 34 #include <sys/kernel.h> 35 #include <sys/kthread.h> 36 #include <sys/lock.h> 37 #include <sys/mbuf.h> 38 #include <sys/malloc.h> 39 #include <sys/module.h> 40 #include <sys/mutex.h> 41 #include <geom/geom_disk.h> 42 43 #include <dev/spibus/spi.h> 44 #include "spibus_if.h" 45 46 struct at45d_softc 47 { 48 struct intr_config_hook config_intrhook; 49 device_t dev; 50 struct mtx sc_mtx; 51 struct disk *disk; 52 struct proc *p; 53 struct bio_queue_head bio_queue; 54 }; 55 56 #define AT45D_LOCK(_sc) mtx_lock(&(_sc)->sc_mtx) 57 #define AT45D_UNLOCK(_sc) mtx_unlock(&(_sc)->sc_mtx) 58 #define AT45D_LOCK_INIT(_sc) \ 59 mtx_init(&_sc->sc_mtx, device_get_nameunit(_sc->dev), \ 60 "at45d", MTX_DEF) 61 #define AT45D_LOCK_DESTROY(_sc) mtx_destroy(&_sc->sc_mtx); 62 #define AT45D_ASSERT_LOCKED(_sc) mtx_assert(&_sc->sc_mtx, MA_OWNED); 63 #define AT45D_ASSERT_UNLOCKED(_sc) mtx_assert(&_sc->sc_mtx, MA_NOTOWNED); 64 65 static void at45d_delayed_attach(void *xsc); 66 67 /* disk routines */ 68 static int at45d_open(struct disk *dp); 69 static int at45d_close(struct disk *dp); 70 static void at45d_strategy(struct bio *bp); 71 static void at45d_task(void *arg); 72 73 #define CONTINUOUS_ARRAY_READ 0xE8 74 #define CONTINUOUS_ARRAY_READ_HF 0x0B 75 #define CONTINUOUS_ARRAY_READ_LF 0x03 76 #define STATUS_REGISTER_READ 0xD7 77 #define PROGRAM_THROUGH_BUFFER 0x82 78 #define MANUFACTURER_ID 0x9F 79 80 static uint8_t 81 at45d_get_status(device_t dev) 82 { 83 uint8_t txBuf[8], rxBuf[8]; 84 struct spi_command cmd; 85 int err; 86 87 memset(&cmd, 0, sizeof(cmd)); 88 memset(txBuf, 0, sizeof(txBuf)); 89 memset(rxBuf, 0, sizeof(rxBuf)); 90 91 txBuf[0] = STATUS_REGISTER_READ; 92 cmd.tx_cmd = txBuf; 93 cmd.rx_cmd = rxBuf; 94 cmd.rx_cmd_sz = 2; 95 cmd.tx_cmd_sz = 2; 96 err = SPIBUS_TRANSFER(device_get_parent(dev), dev, &cmd); 97 return (rxBuf[1]); 98 } 99 100 static void 101 at45d_wait_for_device_ready(device_t dev) 102 { 103 while (!(at45d_get_status(dev) & 0x80)) 104 continue; 105 } 106 107 static int 108 at45d_get_mfg_info(device_t dev, uint8_t *resp) 109 { 110 uint8_t txBuf[8], rxBuf[8]; 111 struct spi_command cmd; 112 int err; 113 114 memset(&cmd, 0, sizeof(cmd)); 115 memset(txBuf, 0, sizeof(txBuf)); 116 memset(rxBuf, 0, sizeof(rxBuf)); 117 118 txBuf[0] = MANUFACTURER_ID; 119 cmd.tx_cmd = &txBuf; 120 cmd.rx_cmd = &rxBuf; 121 cmd.tx_cmd_sz = 5; 122 cmd.rx_cmd_sz = 5; 123 err = SPIBUS_TRANSFER(device_get_parent(dev), dev, &cmd); 124 if (err) 125 return (err); 126 memcpy(resp, rxBuf + 1, 4); 127 // XXX We really should 'decode' the reply into some kind of 128 // XXX structure. To be generic (and not just for atmel parts) 129 // XXX we'd have to loop until we got a full reply. 130 return (0); 131 } 132 133 static int 134 at45d_probe(device_t dev) 135 { 136 device_set_desc(dev, "AT45 Flash Family"); 137 return (0); 138 } 139 140 static int 141 at45d_attach(device_t dev) 142 { 143 struct at45d_softc *sc; 144 145 sc = device_get_softc(dev); 146 sc->dev = dev; 147 AT45D_LOCK_INIT(sc); 148 149 /* We'll see what kind of flash we have later... */ 150 sc->config_intrhook.ich_func = at45d_delayed_attach; 151 sc->config_intrhook.ich_arg = sc; 152 if (config_intrhook_establish(&sc->config_intrhook) != 0) 153 device_printf(dev, "config_intrhook_establish failed\n"); 154 return (0); 155 } 156 157 static int 158 at45d_detach(device_t dev) 159 { 160 return EIO; 161 } 162 163 static void 164 at45d_delayed_attach(void *xsc) 165 { 166 struct at45d_softc *sc = xsc; 167 uint8_t buf[4]; 168 169 at45d_get_mfg_info(sc->dev, buf); 170 at45d_wait_for_device_ready(sc->dev); 171 172 sc->disk = disk_alloc(); 173 sc->disk->d_open = at45d_open; 174 sc->disk->d_close = at45d_close; 175 sc->disk->d_strategy = at45d_strategy; 176 sc->disk->d_name = "flash/spi"; 177 sc->disk->d_drv1 = sc; 178 sc->disk->d_maxsize = DFLTPHYS; 179 sc->disk->d_sectorsize = 1056; /* XXX */ 180 sc->disk->d_mediasize = 8192 * 1056; /* XXX */ 181 sc->disk->d_unit = device_get_unit(sc->dev); 182 disk_create(sc->disk, DISK_VERSION); 183 bioq_init(&sc->bio_queue); 184 kproc_create(&at45d_task, sc, &sc->p, 0, 0, "task: at45d flash"); 185 186 config_intrhook_disestablish(&sc->config_intrhook); 187 } 188 189 static int 190 at45d_open(struct disk *dp) 191 { 192 return 0; 193 } 194 195 static int 196 at45d_close(struct disk *dp) 197 { 198 return 0; 199 } 200 201 static void 202 at45d_strategy(struct bio *bp) 203 { 204 struct at45d_softc *sc; 205 206 sc = (struct at45d_softc *)bp->bio_disk->d_drv1; 207 AT45D_LOCK(sc); 208 bioq_disksort(&sc->bio_queue, bp); 209 wakeup(sc); 210 AT45D_UNLOCK(sc); 211 } 212 213 static void 214 at45d_task(void *arg) 215 { 216 struct at45d_softc *sc = (struct at45d_softc*)arg; 217 struct bio *bp; 218 uint8_t txBuf[8], rxBuf[8]; 219 struct spi_command cmd; 220 int sz; 221 daddr_t block, end; 222 device_t dev, pdev; 223 int err; 224 225 for (;;) { 226 dev = sc->dev; 227 pdev = device_get_parent(dev); 228 AT45D_LOCK(sc); 229 do { 230 bp = bioq_first(&sc->bio_queue); 231 if (bp == NULL) 232 msleep(sc, &sc->sc_mtx, PRIBIO, "jobqueue", 0); 233 } while (bp == NULL); 234 bioq_remove(&sc->bio_queue, bp); 235 AT45D_UNLOCK(sc); 236 sz = sc->disk->d_sectorsize; 237 end = bp->bio_pblkno + (bp->bio_bcount / sz); 238 for (block = bp->bio_pblkno; block < end; block++) { 239 char *vaddr = bp->bio_data + (block - bp->bio_pblkno) * sz; 240 if (bp->bio_cmd == BIO_READ) { 241 txBuf[0] = CONTINUOUS_ARRAY_READ_HF; 242 cmd.tx_cmd_sz = 5; 243 cmd.rx_cmd_sz = 5; 244 } else { 245 txBuf[0] = PROGRAM_THROUGH_BUFFER; 246 cmd.tx_cmd_sz = 4; 247 cmd.rx_cmd_sz = 4; 248 } 249 // XXX only works on certain devices... Fixme 250 txBuf[1] = ((block >> 5) & 0xFF); 251 txBuf[2] = ((block << 3) & 0xF8); 252 txBuf[3] = 0; 253 txBuf[4] = 0; 254 cmd.tx_cmd = txBuf; 255 cmd.rx_cmd = rxBuf; 256 cmd.tx_data = vaddr; 257 cmd.tx_data_sz = sz; 258 cmd.rx_data = vaddr; 259 cmd.rx_data_sz = sz; 260 err = SPIBUS_TRANSFER(pdev, dev, &cmd); 261 // XXX err check? 262 } 263 biodone(bp); 264 } 265 } 266 267 static devclass_t at45d_devclass; 268 269 static device_method_t at45d_methods[] = { 270 /* Device interface */ 271 DEVMETHOD(device_probe, at45d_probe), 272 DEVMETHOD(device_attach, at45d_attach), 273 DEVMETHOD(device_detach, at45d_detach), 274 275 { 0, 0 } 276 }; 277 278 static driver_t at45d_driver = { 279 "at45d", 280 at45d_methods, 281 sizeof(struct at45d_softc), 282 }; 283 284 DRIVER_MODULE(at45d, spibus, at45d_driver, at45d_devclass, 0, 0); 285