Date: Fri, 1 Mar 2019 04:36:55 +0000 (UTC) From: Justin Hibbits <jhibbits@FreeBSD.org> To: src-committers@freebsd.org, svn-src-all@freebsd.org, svn-src-head@freebsd.org Subject: svn commit: r344687 - in head/sys: conf powerpc/powernv Message-ID: <201903010436.x214at8r033498@repo.freebsd.org>
next in thread | raw e-mail | index | archive | help
Author: jhibbits Date: Fri Mar 1 04:36:55 2019 New Revision: 344687 URL: https://svnweb.freebsd.org/changeset/base/344687 Log: powerpc/powernv: Add OPAL flash device driver Firmware needed by petitboot, for example, GPU firmware, can be installed to a partition in the flash filesystem. This driver exposes the full flash given by the device tree, letting the user manage firmware, etc, from FreeBSD. To use the partitions provided by the flash module, the fdt_slicer module is needed, but the module isn't needed for raw access, so there's no direct dependency link in here. MFC after: 2 weeks Added: head/sys/powerpc/powernv/opal_flash.c (contents, props changed) Modified: head/sys/conf/files.powerpc head/sys/powerpc/powernv/opal.h Modified: head/sys/conf/files.powerpc ============================================================================== --- head/sys/conf/files.powerpc Fri Mar 1 04:17:43 2019 (r344686) +++ head/sys/conf/files.powerpc Fri Mar 1 04:36:55 2019 (r344687) @@ -192,6 +192,7 @@ powerpc/powernv/opal.c optional powernv powerpc/powernv/opal_async.c optional powernv powerpc/powernv/opal_console.c optional powernv powerpc/powernv/opal_dev.c optional powernv +powerpc/powernv/opal_flash.c optional powernv powerpc/powernv/opal_i2c.c optional iicbus fdt powernv powerpc/powernv/opal_i2cm.c optional iicbus fdt powernv powerpc/powernv/opal_pci.c optional powernv pci Modified: head/sys/powerpc/powernv/opal.h ============================================================================== --- head/sys/powerpc/powernv/opal.h Fri Mar 1 04:17:43 2019 (r344686) +++ head/sys/powerpc/powernv/opal.h Fri Mar 1 04:36:55 2019 (r344687) @@ -76,6 +76,9 @@ int opal_call(uint64_t token, ...); #define OPAL_IPMI_SEND 107 #define OPAL_IPMI_RECV 108 #define OPAL_I2C_REQUEST 109 +#define OPAL_FLASH_READ 110 +#define OPAL_FLASH_WRITE 111 +#define OPAL_FLASH_ERASE 111 #define OPAL_INT_GET_XIRR 122 #define OPAL_INT_SET_CPPR 123 #define OPAL_INT_EOI 124 Added: head/sys/powerpc/powernv/opal_flash.c ============================================================================== --- /dev/null 00:00:00 1970 (empty, because file is newly added) +++ head/sys/powerpc/powernv/opal_flash.c Fri Mar 1 04:36:55 2019 (r344687) @@ -0,0 +1,372 @@ +/*- + * Copyright (c) 2019 Justin Hibbits + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include <sys/cdefs.h> +__FBSDID("$FreeBSD$"); + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/bio.h> +#include <sys/bus.h> +#include <sys/kernel.h> +#include <sys/kthread.h> +#include <sys/module.h> +#include <sys/mutex.h> +#include <sys/proc.h> +#include <geom/geom_disk.h> + +#include <vm/vm.h> +#include <vm/pmap.h> + +#include <dev/ofw/ofw_bus.h> +#include <dev/ofw/ofw_bus_subr.h> +#include <dev/ofw/openfirm.h> +#include "opal.h" + +/* + * OPAL System flash driver, using OPAL firmware calls to access the device. + * + * This just presents the base block interface. The fdt_slicer can be used on + * top to present the partitions listed in the fdt. + * + * There are three OPAL methods used: OPAL_FLASH_READ, OPAL_FLASH_WRITE, and + * OPAL_FLASH_ERASE. At the firmware layer, READ and WRITE can be on arbitrary + * boundaries, but ERASE is only at flash-block-size block alignments and sizes. + * To account for this, the following restrictions are in place: + * + * - Reads are on a 512-byte block boundary and size + * - Writes and Erases are aligned and sized on flash-block-size bytes. + * + * In order to support the fdt_slicer we present a type attribute of + * NAND::device. + */ +struct opalflash_softc { + device_t sc_dev; + struct mtx sc_mtx; + struct disk *sc_disk; + struct proc *sc_p; + struct bio_queue_head sc_bio_queue; + int sc_opal_id; +}; + +#define OPALFLASH_LOCK(sc) mtx_lock(&(sc)->sc_mtx) +#define OPALFLASH_UNLOCK(sc) mtx_unlock(&(sc)->sc_mtx) +#define OPALFLASH_LOCK_INIT(sc) \ + mtx_init(&(sc)->sc_mtx, device_get_nameunit((sc)->sc_dev), \ + "opalflash", MTX_DEF) + +#define FLASH_BLOCKSIZE 512 + +static int opalflash_probe(device_t); +static int opalflash_attach(device_t); + +static device_method_t opalflash_methods[] = { + /* Device interface */ + DEVMETHOD(device_probe, opalflash_probe), + DEVMETHOD(device_attach, opalflash_attach), + + DEVMETHOD_END +}; + +static driver_t opalflash_driver = { + "opalflash", + opalflash_methods, + sizeof(struct opalflash_softc) +}; + +static devclass_t opalflash_devclass; + +DRIVER_MODULE(opalflash, opal, opalflash_driver, opalflash_devclass, 0, 0); + +/* GEOM Disk interfaces. */ +static int +opalflash_open(struct disk *dp) +{ + + return (0); +} + +static int +opalflash_close(struct disk *dp) +{ + + return (0); +} + +static int +opalflash_ioctl(struct disk *dp, u_long cmd, void *data, int fflag, + struct thread *td) +{ + + return (EINVAL); +} + +/* Handle the one attribute we need to play nice with geom_flashmap. */ +static int +opalflash_getattr(struct bio *bp) +{ + struct opalflash_softc *sc; + device_t dev; + + if (bp->bio_disk == NULL || bp->bio_disk->d_drv1 == NULL) + return (ENXIO); + + sc = bp->bio_disk->d_drv1; + dev = sc->sc_dev; + + if (strcmp(bp->bio_attribute, "NAND::device") == 0) { + if (bp->bio_length != sizeof(dev)) + return (EFAULT); + bcopy(&dev, bp->bio_data, sizeof(dev)); + } else + return (-1); + return (0); +} + +static void +opalflash_strategy(struct bio *bp) +{ + struct opalflash_softc *sc; + + sc = (struct opalflash_softc *)bp->bio_disk->d_drv1; + OPALFLASH_LOCK(sc); + bioq_disksort(&sc->sc_bio_queue, bp); + wakeup(sc); + OPALFLASH_UNLOCK(sc); +} + +static int +opalflash_read(struct opalflash_softc *sc, off_t off, + caddr_t data, off_t count) +{ + struct opal_msg msg; + int rv, size, token; + + /* Ensure we write aligned to a full block size. */ + if (off % sc->sc_disk->d_sectorsize != 0 || + count % sc->sc_disk->d_sectorsize != 0) + return (EIO); + + token = opal_alloc_async_token(); + + /* + * Read one page at a time. It's not guaranteed that the buffer is + * physically contiguous. + */ + while (count > 0) { + size = MIN(count, PAGE_SIZE); + rv = opal_call(OPAL_FLASH_READ, sc->sc_opal_id, off, + vtophys(data), size, token); + if (rv == OPAL_ASYNC_COMPLETION) + rv = opal_wait_completion(&msg, sizeof(msg), token); + if (rv != OPAL_SUCCESS) + break; + count -= size; + off += size; + } + opal_free_async_token(token); + if (rv == OPAL_SUCCESS) + rv = 0; + else + rv = EIO; + + return (rv); +} + +static int +opalflash_erase(struct opalflash_softc *sc, off_t off, off_t count) +{ + struct opal_msg msg; + int rv, token; + + /* Ensure we write aligned to a full block size. */ + if (off % sc->sc_disk->d_stripesize != 0 || + count % sc->sc_disk->d_stripesize != 0) + return (EIO); + + token = opal_alloc_async_token(); + + rv = opal_call(OPAL_FLASH_ERASE, sc->sc_opal_id, off, count, token); + if (rv == OPAL_ASYNC_COMPLETION) + rv = opal_wait_completion(&msg, sizeof(msg), token); + opal_free_async_token(token); + + if (rv == OPAL_SUCCESS) + rv = 0; + else + rv = EIO; + + return (rv); +} + +static int +opalflash_write(struct opalflash_softc *sc, off_t off, + caddr_t data, off_t count) +{ + struct opal_msg msg; + int rv, size, token; + + /* Ensure we write aligned to a full block size. */ + if (off % sc->sc_disk->d_stripesize != 0 || + count % sc->sc_disk->d_stripesize != 0) + return (EIO); + + /* Erase the full block first, then write in page chunks. */ + rv = opalflash_erase(sc, off, count); + if (rv != 0) + return (rv); + + token = opal_alloc_async_token(); + + /* + * Write one page at a time. It's not guaranteed that the buffer is + * physically contiguous. + */ + while (count > 0) { + size = MIN(count, PAGE_SIZE); + rv = opal_call(OPAL_FLASH_WRITE, sc->sc_opal_id, off, + vtophys(data), size, token); + if (rv == OPAL_ASYNC_COMPLETION) + rv = opal_wait_completion(&msg, sizeof(msg), token); + if (rv != OPAL_SUCCESS) + break; + count -= size; + off += size; + } + opal_free_async_token(token); + + if (rv == OPAL_SUCCESS) + rv = 0; + else + rv = EIO; + + return (rv); +} + +/* Main flash handling task. */ +static void +opalflash_task(void *arg) +{ + struct opalflash_softc *sc; + struct bio *bp; + device_t dev; + + sc = arg; + + for (;;) { + dev = sc->sc_dev; + OPALFLASH_LOCK(sc); + do { + bp = bioq_first(&sc->sc_bio_queue); + if (bp == NULL) + msleep(sc, &sc->sc_mtx, PRIBIO, "opalflash", 0); + } while (bp == NULL); + bioq_remove(&sc->sc_bio_queue, bp); + OPALFLASH_UNLOCK(sc); + + switch (bp->bio_cmd) { + case BIO_DELETE: + bp->bio_error = opalflash_erase(sc, bp->bio_offset, + bp->bio_bcount); + break; + case BIO_READ: + bp->bio_error = opalflash_read(sc, bp->bio_offset, + bp->bio_data, bp->bio_bcount); + break; + case BIO_WRITE: + bp->bio_error = opalflash_write(sc, bp->bio_offset, + bp->bio_data, bp->bio_bcount); + break; + default: + bp->bio_error = EINVAL; + } + biodone(bp); + } +} + + +/* Device driver interfaces. */ + +static int +opalflash_probe(device_t dev) +{ + if (!ofw_bus_is_compatible(dev, "ibm,opal-flash")) + return (ENXIO); + + device_set_desc(dev, "OPAL System Flash"); + + return (BUS_PROBE_GENERIC); +} + +static int +opalflash_attach(device_t dev) +{ + struct opalflash_softc *sc; + phandle_t node; + cell_t flash_blocksize, opal_id; + uint32_t regs[2]; + + sc = device_get_softc(dev); + sc->sc_dev = dev; + + node = ofw_bus_get_node(dev); + OF_getencprop(node, "ibm,opal-id", &opal_id, sizeof(opal_id)); + sc->sc_opal_id = opal_id; + + if (OF_getencprop(node, "ibm,flash-block-size", + &flash_blocksize, sizeof(flash_blocksize)) < 0) { + device_printf(dev, "Cannot determine flash block size.\n"); + return (ENXIO); + } + + OPALFLASH_LOCK_INIT(sc); + + if (OF_getencprop(node, "reg", regs, sizeof(regs)) < 0) { + device_printf(dev, "Unable to get flash size.\n"); + return (ENXIO); + } + + sc->sc_disk = disk_alloc(); + sc->sc_disk->d_name = "opalflash"; + sc->sc_disk->d_open = opalflash_open; + sc->sc_disk->d_close = opalflash_close; + sc->sc_disk->d_strategy = opalflash_strategy; + sc->sc_disk->d_ioctl = opalflash_ioctl; + sc->sc_disk->d_getattr = opalflash_getattr; + sc->sc_disk->d_drv1 = sc; + sc->sc_disk->d_maxsize = DFLTPHYS; + sc->sc_disk->d_mediasize = regs[1]; + sc->sc_disk->d_unit = device_get_unit(sc->sc_dev); + sc->sc_disk->d_sectorsize = FLASH_BLOCKSIZE; + sc->sc_disk->d_stripesize = flash_blocksize; + sc->sc_disk->d_dump = NULL; + + disk_create(sc->sc_disk, DISK_VERSION); + bioq_init(&sc->sc_bio_queue); + + kproc_create(&opalflash_task, sc, &sc->sc_p, 0, 0, "task: OPAL Flash"); + + return (0); +}
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?201903010436.x214at8r033498>