sys/powerpc/powernv/opal_flash.c

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