1 /*- 2 * Copyright (c) 2019 Justin Hibbits 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 AND CONTRIBUTORS ``AS IS'' AND 14 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 16 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 17 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 18 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 19 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 20 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 21 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 22 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 23 * SUCH DAMAGE. 24 */ 25 26 #include <sys/param.h> 27 #include <sys/systm.h> 28 #include <sys/bio.h> 29 #include <sys/bus.h> 30 #include <sys/kernel.h> 31 #include <sys/kthread.h> 32 #include <sys/lock.h> 33 #include <sys/module.h> 34 #include <sys/mutex.h> 35 #include <sys/proc.h> 36 #include <geom/geom_disk.h> 37 38 #include <vm/vm.h> 39 #include <vm/pmap.h> 40 41 #include <dev/ofw/ofw_bus.h> 42 #include <dev/ofw/ofw_bus_subr.h> 43 #include <dev/ofw/openfirm.h> 44 #include "opal.h" 45 46 /* 47 * OPAL System flash driver, using OPAL firmware calls to access the device. 48 * 49 * This just presents the base block interface. The fdt_slicer can be used on 50 * top to present the partitions listed in the fdt. 51 * 52 * There are three OPAL methods used: OPAL_FLASH_READ, OPAL_FLASH_WRITE, and 53 * OPAL_FLASH_ERASE. At the firmware layer, READ and WRITE can be on arbitrary 54 * boundaries, but ERASE is only at flash-block-size block alignments and sizes. 55 * To account for this, the following restrictions are in place: 56 * 57 * - Reads are on a 512-byte block boundary and size 58 * - Writes and Erases are aligned and sized on flash-block-size bytes. 59 * 60 * In order to support the fdt_slicer we present a type attribute of 61 * NAND::device. 62 */ 63 struct opalflash_softc { 64 device_t sc_dev; 65 struct mtx sc_mtx; 66 struct disk *sc_disk; 67 struct proc *sc_p; 68 struct bio_queue_head sc_bio_queue; 69 int sc_opal_id; 70 bool sc_erase; /* Erase is needed before write. */ 71 }; 72 73 #define OPALFLASH_LOCK(sc) mtx_lock(&(sc)->sc_mtx) 74 #define OPALFLASH_UNLOCK(sc) mtx_unlock(&(sc)->sc_mtx) 75 #define OPALFLASH_LOCK_INIT(sc) \ 76 mtx_init(&(sc)->sc_mtx, device_get_nameunit((sc)->sc_dev), \ 77 "opalflash", MTX_DEF) 78 79 #define FLASH_BLOCKSIZE 512 80 81 static int opalflash_probe(device_t); 82 static int opalflash_attach(device_t); 83 84 static device_method_t opalflash_methods[] = { 85 /* Device interface */ 86 DEVMETHOD(device_probe, opalflash_probe), 87 DEVMETHOD(device_attach, opalflash_attach), 88 89 DEVMETHOD_END 90 }; 91 92 static driver_t opalflash_driver = { 93 "opalflash", 94 opalflash_methods, 95 sizeof(struct opalflash_softc) 96 }; 97 98 DRIVER_MODULE(opalflash, opal, opalflash_driver, 0, 0); 99 100 /* GEOM Disk interfaces. */ 101 static int 102 opalflash_open(struct disk *dp) 103 { 104 105 return (0); 106 } 107 108 static int 109 opalflash_close(struct disk *dp) 110 { 111 112 return (0); 113 } 114 115 static int 116 opalflash_ioctl(struct disk *dp, u_long cmd, void *data, int fflag, 117 struct thread *td) 118 { 119 120 return (EINVAL); 121 } 122 123 /* Handle the one attribute we need to play nice with geom_flashmap. */ 124 static int 125 opalflash_getattr(struct bio *bp) 126 { 127 struct opalflash_softc *sc; 128 device_t dev; 129 130 if (bp->bio_disk == NULL || bp->bio_disk->d_drv1 == NULL) 131 return (ENXIO); 132 133 sc = bp->bio_disk->d_drv1; 134 dev = sc->sc_dev; 135 136 if (strcmp(bp->bio_attribute, "NAND::device") == 0) { 137 if (bp->bio_length != sizeof(dev)) 138 return (EFAULT); 139 bcopy(&dev, bp->bio_data, sizeof(dev)); 140 } else 141 return (-1); 142 return (0); 143 } 144 145 static void 146 opalflash_strategy(struct bio *bp) 147 { 148 struct opalflash_softc *sc; 149 150 sc = (struct opalflash_softc *)bp->bio_disk->d_drv1; 151 OPALFLASH_LOCK(sc); 152 bioq_disksort(&sc->sc_bio_queue, bp); 153 wakeup(sc); 154 OPALFLASH_UNLOCK(sc); 155 } 156 157 static int 158 opalflash_read(struct opalflash_softc *sc, off_t off, 159 caddr_t data, off_t count) 160 { 161 struct opal_msg msg; 162 int rv, size, token; 163 164 /* Ensure we write aligned to a full block size. */ 165 if (off % sc->sc_disk->d_sectorsize != 0 || 166 count % sc->sc_disk->d_sectorsize != 0) 167 return (EIO); 168 169 token = opal_alloc_async_token(); 170 171 /* 172 * Read one page at a time. It's not guaranteed that the buffer is 173 * physically contiguous. 174 */ 175 rv = 0; 176 while (count > 0) { 177 size = MIN(count, PAGE_SIZE); 178 size = MIN(size, PAGE_SIZE - ((u_long)data & PAGE_MASK)); 179 rv = opal_call(OPAL_FLASH_READ, sc->sc_opal_id, off, 180 vtophys(data), size, token); 181 if (rv == OPAL_ASYNC_COMPLETION) { 182 rv = opal_wait_completion(&msg, sizeof(msg), token); 183 if (rv == OPAL_SUCCESS) 184 rv = msg.params[1]; 185 } 186 if (rv != OPAL_SUCCESS) 187 break; 188 count -= size; 189 off += size; 190 data += size; 191 } 192 opal_free_async_token(token); 193 if (rv == OPAL_SUCCESS) 194 rv = 0; 195 else 196 rv = EIO; 197 198 return (rv); 199 } 200 201 static int 202 opalflash_erase(struct opalflash_softc *sc, off_t off, off_t count) 203 { 204 struct opal_msg msg; 205 int rv, token; 206 207 /* Ensure we write aligned to a full block size. */ 208 if (off % sc->sc_disk->d_stripesize != 0 || 209 count % sc->sc_disk->d_stripesize != 0) 210 return (EIO); 211 212 token = opal_alloc_async_token(); 213 214 rv = opal_call(OPAL_FLASH_ERASE, sc->sc_opal_id, off, count, token); 215 if (rv == OPAL_ASYNC_COMPLETION) { 216 rv = opal_wait_completion(&msg, sizeof(msg), token); 217 if (rv == OPAL_SUCCESS) 218 rv = msg.params[1]; 219 } 220 opal_free_async_token(token); 221 222 if (rv == OPAL_SUCCESS) 223 rv = 0; 224 else 225 rv = EIO; 226 227 return (rv); 228 } 229 230 static int 231 opalflash_write(struct opalflash_softc *sc, off_t off, 232 caddr_t data, off_t count) 233 { 234 struct opal_msg msg; 235 int rv, size, token; 236 237 /* Ensure we write aligned to a full block size. */ 238 if (off % sc->sc_disk->d_sectorsize != 0 || 239 count % sc->sc_disk->d_sectorsize != 0) 240 return (EIO); 241 242 if (sc->sc_erase) { 243 /* Erase the full block first, then write in page chunks. */ 244 rv = opalflash_erase(sc, off, count); 245 if (rv != 0) 246 return (rv); 247 } 248 249 token = opal_alloc_async_token(); 250 251 /* 252 * Write one page at a time. It's not guaranteed that the buffer is 253 * physically contiguous. 254 */ 255 while (count > 0) { 256 size = MIN(count, PAGE_SIZE); 257 size = MIN(size, PAGE_SIZE - ((u_long)data & PAGE_MASK)); 258 rv = opal_call(OPAL_FLASH_WRITE, sc->sc_opal_id, off, 259 vtophys(data), size, token); 260 if (rv == OPAL_ASYNC_COMPLETION) { 261 rv = opal_wait_completion(&msg, sizeof(msg), token); 262 if (rv == OPAL_SUCCESS) 263 rv = msg.params[1]; 264 } 265 if (rv != OPAL_SUCCESS) 266 break; 267 count -= size; 268 off += size; 269 data += size; 270 } 271 opal_free_async_token(token); 272 273 if (rv == OPAL_SUCCESS) 274 rv = 0; 275 else 276 rv = EIO; 277 278 return (rv); 279 } 280 281 /* Main flash handling task. */ 282 static void 283 opalflash_task(void *arg) 284 { 285 struct opalflash_softc *sc; 286 struct bio *bp; 287 288 sc = arg; 289 290 for (;;) { 291 OPALFLASH_LOCK(sc); 292 do { 293 bp = bioq_first(&sc->sc_bio_queue); 294 if (bp == NULL) 295 msleep(sc, &sc->sc_mtx, PRIBIO, "opalflash", 0); 296 } while (bp == NULL); 297 bioq_remove(&sc->sc_bio_queue, bp); 298 OPALFLASH_UNLOCK(sc); 299 300 switch (bp->bio_cmd) { 301 case BIO_DELETE: 302 bp->bio_error = opalflash_erase(sc, bp->bio_offset, 303 bp->bio_bcount); 304 break; 305 case BIO_READ: 306 bp->bio_error = opalflash_read(sc, bp->bio_offset, 307 bp->bio_data, bp->bio_bcount); 308 break; 309 case BIO_WRITE: 310 bp->bio_error = opalflash_write(sc, bp->bio_offset, 311 bp->bio_data, bp->bio_bcount); 312 break; 313 default: 314 bp->bio_error = EINVAL; 315 } 316 biodone(bp); 317 } 318 } 319 320 /* Device driver interfaces. */ 321 322 static int 323 opalflash_probe(device_t dev) 324 { 325 if (!ofw_bus_is_compatible(dev, "ibm,opal-flash")) 326 return (ENXIO); 327 328 device_set_desc(dev, "OPAL System Flash"); 329 330 return (BUS_PROBE_GENERIC); 331 } 332 333 static int 334 opalflash_attach(device_t dev) 335 { 336 struct opalflash_softc *sc; 337 phandle_t node; 338 cell_t flash_blocksize, opal_id; 339 uint32_t regs[2]; 340 341 sc = device_get_softc(dev); 342 sc->sc_dev = dev; 343 344 node = ofw_bus_get_node(dev); 345 OF_getencprop(node, "ibm,opal-id", &opal_id, sizeof(opal_id)); 346 sc->sc_opal_id = opal_id; 347 348 if (OF_getencprop(node, "ibm,flash-block-size", 349 &flash_blocksize, sizeof(flash_blocksize)) < 0) { 350 device_printf(dev, "Cannot determine flash block size.\n"); 351 return (ENXIO); 352 } 353 354 if (!OF_hasprop(node, "no-erase")) 355 sc->sc_erase = true; 356 357 OPALFLASH_LOCK_INIT(sc); 358 359 if (OF_getencprop(node, "reg", regs, sizeof(regs)) < 0) { 360 device_printf(dev, "Unable to get flash size.\n"); 361 return (ENXIO); 362 } 363 364 sc->sc_disk = disk_alloc(); 365 sc->sc_disk->d_name = "opalflash"; 366 sc->sc_disk->d_open = opalflash_open; 367 sc->sc_disk->d_close = opalflash_close; 368 sc->sc_disk->d_strategy = opalflash_strategy; 369 sc->sc_disk->d_ioctl = opalflash_ioctl; 370 sc->sc_disk->d_getattr = opalflash_getattr; 371 sc->sc_disk->d_drv1 = sc; 372 sc->sc_disk->d_maxsize = DFLTPHYS; 373 sc->sc_disk->d_mediasize = regs[1]; 374 sc->sc_disk->d_unit = device_get_unit(sc->sc_dev); 375 sc->sc_disk->d_sectorsize = FLASH_BLOCKSIZE; 376 sc->sc_disk->d_stripesize = flash_blocksize; 377 sc->sc_disk->d_dump = NULL; 378 379 disk_create(sc->sc_disk, DISK_VERSION); 380 bioq_init(&sc->sc_bio_queue); 381 382 kproc_create(&opalflash_task, sc, &sc->sc_p, 0, 0, "task: OPAL Flash"); 383 384 return (0); 385 } 386