opal_flash.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    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/lock.h>
   36 #include <sys/module.h>
   37 #include <sys/mutex.h>
   38 #include <sys/proc.h>
   39 #include <geom/geom_disk.h>
   40 
   41 #include <vm/vm.h>
   42 #include <vm/pmap.h>
   43 
   44 #include <dev/ofw/ofw_bus.h>
   45 #include <dev/ofw/ofw_bus_subr.h>
   46 #include <dev/ofw/openfirm.h>
   47 #include "opal.h"
   48 
   49 /*
   50  * OPAL System flash driver, using OPAL firmware calls to access the device.
   51  *
   52  * This just presents the base block interface.  The fdt_slicer can be used on
   53  * top to present the partitions listed in the fdt.
   54  *
   55  * There are three OPAL methods used: OPAL_FLASH_READ, OPAL_FLASH_WRITE, and
   56  * OPAL_FLASH_ERASE.  At the firmware layer, READ and WRITE can be on arbitrary
   57  * boundaries, but ERASE is only at flash-block-size block alignments and sizes.
   58  * To account for this, the following restrictions are in place:
   59  *
   60  * - Reads are on a 512-byte block boundary and size
   61  * - Writes and Erases are aligned and sized on flash-block-size bytes.
   62  *
   63  * In order to support the fdt_slicer we present a type attribute of
   64  * NAND::device.
   65  */
   66 struct opalflash_softc {
   67         device_t                 sc_dev;
   68         struct mtx               sc_mtx;
   69         struct disk             *sc_disk;
   70         struct proc             *sc_p;
   71         struct bio_queue_head    sc_bio_queue;
   72         int                      sc_opal_id;
   73         bool                     sc_erase; /* Erase is needed before write. */
   74 };
   75 
   76 #define OPALFLASH_LOCK(sc)              mtx_lock(&(sc)->sc_mtx)
   77 #define OPALFLASH_UNLOCK(sc)            mtx_unlock(&(sc)->sc_mtx)
   78 #define OPALFLASH_LOCK_INIT(sc) \
   79         mtx_init(&(sc)->sc_mtx, device_get_nameunit((sc)->sc_dev), \
   80             "opalflash", MTX_DEF)
   81 
   82 #define FLASH_BLOCKSIZE                 512
   83 
   84 static int      opalflash_probe(device_t);
   85 static int      opalflash_attach(device_t);
   86 
   87 static device_method_t  opalflash_methods[] = {
   88         /* Device interface */
   89         DEVMETHOD(device_probe,         opalflash_probe),
   90         DEVMETHOD(device_attach,        opalflash_attach),
   91 
   92         DEVMETHOD_END
   93 };
   94 
   95 static driver_t opalflash_driver = {
   96         "opalflash",
   97         opalflash_methods,
   98         sizeof(struct opalflash_softc)
   99 };
  100 
  101 DRIVER_MODULE(opalflash, opal, opalflash_driver, 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         rv = 0;
  179         while (count > 0) {
  180                 size = MIN(count, PAGE_SIZE);
  181                 size = MIN(size, PAGE_SIZE - ((u_long)data & PAGE_MASK));
  182                 rv = opal_call(OPAL_FLASH_READ, sc->sc_opal_id, off,
  183                     vtophys(data), size, token);
  184                 if (rv == OPAL_ASYNC_COMPLETION) {
  185                         rv = opal_wait_completion(&msg, sizeof(msg), token);
  186                         if (rv == OPAL_SUCCESS)
  187                                 rv = msg.params[1];
  188                 }
  189                 if (rv != OPAL_SUCCESS)
  190                         break;
  191                 count -= size;
  192                 off += size;
  193                 data += size;
  194         }
  195         opal_free_async_token(token);
  196         if (rv == OPAL_SUCCESS)
  197                 rv = 0;
  198         else
  199                 rv = EIO;
  200 
  201         return (rv);
  202 }
  203 
  204 static int
  205 opalflash_erase(struct opalflash_softc *sc, off_t off, off_t count)
  206 {
  207         struct opal_msg msg;
  208         int rv, token;
  209 
  210         /* Ensure we write aligned to a full block size. */
  211         if (off % sc->sc_disk->d_stripesize != 0 ||
  212             count % sc->sc_disk->d_stripesize != 0)
  213                 return (EIO);
  214 
  215         token = opal_alloc_async_token();
  216 
  217         rv = opal_call(OPAL_FLASH_ERASE, sc->sc_opal_id, off, count, token);
  218         if (rv == OPAL_ASYNC_COMPLETION) {
  219                 rv = opal_wait_completion(&msg, sizeof(msg), token);
  220                 if (rv == OPAL_SUCCESS)
  221                         rv = msg.params[1];
  222         }
  223         opal_free_async_token(token);
  224 
  225         if (rv == OPAL_SUCCESS)
  226                 rv = 0;
  227         else
  228                 rv = EIO;
  229 
  230         return (rv);
  231 }
  232 
  233 static int
  234 opalflash_write(struct opalflash_softc *sc, off_t off,
  235     caddr_t data, off_t count)
  236 {
  237         struct opal_msg msg;
  238         int rv, size, token;
  239 
  240         /* Ensure we write aligned to a full block size. */
  241         if (off % sc->sc_disk->d_sectorsize != 0 ||
  242             count % sc->sc_disk->d_sectorsize != 0)
  243                 return (EIO);
  244 
  245         if (sc->sc_erase) {
  246             /* Erase the full block first, then write in page chunks. */
  247             rv = opalflash_erase(sc, off, count);
  248             if (rv != 0)
  249                     return (rv);
  250         }
  251 
  252         token = opal_alloc_async_token();
  253 
  254         /*
  255          * Write one page at a time.  It's not guaranteed that the buffer is
  256          * physically contiguous.
  257          */
  258         while (count > 0) {
  259                 size = MIN(count, PAGE_SIZE);
  260                 size = MIN(size, PAGE_SIZE - ((u_long)data & PAGE_MASK));
  261                 rv = opal_call(OPAL_FLASH_WRITE, sc->sc_opal_id, off,
  262                     vtophys(data), size, token);
  263                 if (rv == OPAL_ASYNC_COMPLETION) {
  264                         rv = opal_wait_completion(&msg, sizeof(msg), token);
  265                         if (rv == OPAL_SUCCESS)
  266                                 rv = msg.params[1];
  267                 }
  268                 if (rv != OPAL_SUCCESS)
  269                         break;
  270                 count -= size;
  271                 off += size;
  272                 data += size;
  273         }
  274         opal_free_async_token(token);
  275 
  276         if (rv == OPAL_SUCCESS)
  277                 rv = 0;
  278         else
  279                 rv = EIO;
  280 
  281         return (rv);
  282 }
  283 
  284 /* Main flash handling task. */
  285 static void
  286 opalflash_task(void *arg)
  287 {
  288         struct opalflash_softc *sc;
  289         struct bio *bp;
  290 
  291         sc = arg;
  292 
  293         for (;;) {
  294                 OPALFLASH_LOCK(sc);
  295                 do {
  296                         bp = bioq_first(&sc->sc_bio_queue);
  297                         if (bp == NULL)
  298                                 msleep(sc, &sc->sc_mtx, PRIBIO, "opalflash", 0);
  299                 } while (bp == NULL);
  300                 bioq_remove(&sc->sc_bio_queue, bp);
  301                 OPALFLASH_UNLOCK(sc);
  302 
  303                 switch (bp->bio_cmd) {
  304                 case BIO_DELETE:
  305                         bp->bio_error = opalflash_erase(sc, bp->bio_offset,
  306                             bp->bio_bcount);
  307                         break;
  308                 case BIO_READ:
  309                         bp->bio_error = opalflash_read(sc, bp->bio_offset,
  310                             bp->bio_data, bp->bio_bcount);
  311                         break;
  312                 case BIO_WRITE:
  313                         bp->bio_error = opalflash_write(sc, bp->bio_offset,
  314                             bp->bio_data, bp->bio_bcount);
  315                         break;
  316                 default:
  317                         bp->bio_error = EINVAL;
  318                 }
  319                 biodone(bp);
  320         }
  321 }
  322 
  323 /* Device driver interfaces. */
  324 
  325 static int
  326 opalflash_probe(device_t dev)
  327 {
  328         if (!ofw_bus_is_compatible(dev, "ibm,opal-flash"))
  329                 return (ENXIO);
  330 
  331         device_set_desc(dev, "OPAL System Flash");
  332 
  333         return (BUS_PROBE_GENERIC);
  334 }
  335 
  336 static int
  337 opalflash_attach(device_t dev)
  338 {
  339         struct opalflash_softc *sc;
  340         phandle_t node;
  341         cell_t flash_blocksize, opal_id;
  342         uint32_t regs[2];
  343 
  344         sc = device_get_softc(dev);
  345         sc->sc_dev = dev;
  346 
  347         node = ofw_bus_get_node(dev);
  348         OF_getencprop(node, "ibm,opal-id", &opal_id, sizeof(opal_id));
  349         sc->sc_opal_id = opal_id;
  350 
  351         if (OF_getencprop(node, "ibm,flash-block-size",
  352             &flash_blocksize, sizeof(flash_blocksize)) < 0) {
  353                 device_printf(dev, "Cannot determine flash block size.\n");
  354                 return (ENXIO);
  355         }
  356 
  357         if (!OF_hasprop(node, "no-erase"))
  358                 sc->sc_erase = true;
  359 
  360         OPALFLASH_LOCK_INIT(sc);
  361 
  362         if (OF_getencprop(node, "reg", regs, sizeof(regs)) < 0) {
  363                 device_printf(dev, "Unable to get flash size.\n");
  364                 return (ENXIO);
  365         }
  366 
  367         sc->sc_disk = disk_alloc();
  368         sc->sc_disk->d_name = "opalflash";
  369         sc->sc_disk->d_open = opalflash_open;
  370         sc->sc_disk->d_close = opalflash_close;
  371         sc->sc_disk->d_strategy = opalflash_strategy;
  372         sc->sc_disk->d_ioctl = opalflash_ioctl;
  373         sc->sc_disk->d_getattr = opalflash_getattr;
  374         sc->sc_disk->d_drv1 = sc;
  375         sc->sc_disk->d_maxsize = DFLTPHYS;
  376         sc->sc_disk->d_mediasize = regs[1];
  377         sc->sc_disk->d_unit = device_get_unit(sc->sc_dev);
  378         sc->sc_disk->d_sectorsize = FLASH_BLOCKSIZE;
  379             sc->sc_disk->d_stripesize = flash_blocksize;
  380         sc->sc_disk->d_dump = NULL;
  381 
  382         disk_create(sc->sc_disk, DISK_VERSION);
  383         bioq_init(&sc->sc_bio_queue);
  384 
  385         kproc_create(&opalflash_task, sc, &sc->sc_p, 0, 0, "task: OPAL Flash");
  386 
  387         return (0);
  388 }
Cache object: c5d913a21a0896ebfa0dd83b703f7207
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/powerpc/powernv/opal_flash.c

FreeBSD/Linux Kernel Cross Reference
sys/powerpc/powernv/opal_flash.c
