cfi_disk.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) 2009 Sam Leffler, Errno Consulting
    3  * Copyright (c) 2012-2013, SRI International
    4  * All rights reserved.
    5  *
    6  * Portions of this software were developed by SRI International and the
    7  * University of Cambridge Computer Laboratory under DARPA/AFRL contract
    8  * (FA8750-10-C-0237) ("CTSRD"), as part of the DARPA CRASH research
    9  * programme.
   10  *
   11  * Redistribution and use in source and binary forms, with or without
   12  * modification, are permitted provided that the following conditions
   13  * are met:
   14  * 1. Redistributions of source code must retain the above copyright
   15  *    notice, this list of conditions and the following disclaimer.
   16  * 2. Redistributions in binary form must reproduce the above copyright
   17  *    notice, this list of conditions and the following disclaimer in the
   18  *    documentation and/or other materials provided with the distribution.
   19  *
   20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   21  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   22  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   23  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   24  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   25  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   29  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   30  */
   31 
   32 #include <sys/cdefs.h>
   33 __FBSDID("$FreeBSD: releng/10.3/sys/dev/cfi/cfi_disk.c 255207 2013-09-04 17:19:21Z brooks $");
   34 
   35 #include <sys/param.h>
   36 #include <sys/systm.h>
   37 #include <sys/bio.h>
   38 #include <sys/bus.h>
   39 #include <sys/conf.h>
   40 #include <sys/kernel.h>
   41 #include <sys/malloc.h>   
   42 #include <sys/lock.h>
   43 #include <sys/mutex.h>
   44 #include <sys/module.h>
   45 #include <sys/rman.h>
   46 #include <sys/sysctl.h>
   47 #include <sys/taskqueue.h>
   48 
   49 #include <machine/bus.h>
   50 
   51 #include <dev/cfi/cfi_var.h>
   52 
   53 #include <geom/geom.h>
   54 #include <geom/geom_disk.h>
   55 
   56 struct cfi_disk_softc {
   57         struct cfi_softc *parent;
   58         struct disk     *disk;
   59         int             flags;
   60 #define CFI_DISK_OPEN   0x0001
   61         struct bio_queue_head bioq;     /* bio queue */
   62         struct mtx      qlock;          /* bioq lock */
   63         struct taskqueue *tq;           /* private task queue for i/o request */
   64         struct task     iotask;         /* i/o processing */
   65 };
   66 
   67 #define CFI_DISK_SECSIZE        512
   68 #define CFI_DISK_MAXIOSIZE      65536
   69 
   70 static int cfi_disk_detach(device_t);
   71 static int cfi_disk_open(struct disk *);
   72 static int cfi_disk_close(struct disk *);
   73 static void cfi_io_proc(void *, int);
   74 static int cfi_disk_getattr(struct bio *);
   75 static void cfi_disk_strategy(struct bio *);
   76 static int cfi_disk_ioctl(struct disk *, u_long, void *, int, struct thread *);
   77 
   78 static int
   79 cfi_disk_probe(device_t dev)
   80 {
   81         return 0;
   82 }
   83 
   84 static int
   85 cfi_disk_attach(device_t dev)
   86 {
   87         struct cfi_disk_softc *sc = device_get_softc(dev);
   88 
   89         sc->parent = device_get_softc(device_get_parent(dev));
   90         /* validate interface width; assumed by other code */
   91         if (sc->parent->sc_width != 1 &&
   92             sc->parent->sc_width != 2 &&
   93             sc->parent->sc_width != 4)
   94                 return EINVAL;
   95 
   96         sc->disk = disk_alloc();
   97         if (sc->disk == NULL)
   98                 return ENOMEM;
   99         sc->disk->d_name = "cfid";
  100         sc->disk->d_unit = device_get_unit(dev);
  101         sc->disk->d_open = cfi_disk_open;
  102         sc->disk->d_close = cfi_disk_close;
  103         sc->disk->d_strategy = cfi_disk_strategy;
  104         sc->disk->d_ioctl = cfi_disk_ioctl;
  105         sc->disk->d_dump = NULL;                /* NB: no dumps */
  106         sc->disk->d_getattr = cfi_disk_getattr;
  107         sc->disk->d_sectorsize = CFI_DISK_SECSIZE;
  108         sc->disk->d_mediasize = sc->parent->sc_size;
  109         sc->disk->d_maxsize = CFI_DISK_MAXIOSIZE;
  110         /* NB: use stripesize to hold the erase/region size */
  111         if (sc->parent->sc_regions) {
  112                 /*
  113                  * Multiple regions, use the last one.  This is a
  114                  * total hack as it's (presently) used only by
  115                  * geom_redboot to locate the FIS directory which
  116                  * lies at the start of the last erase region.
  117                  */
  118                 sc->disk->d_stripesize =
  119                     sc->parent->sc_region[sc->parent->sc_regions-1].r_blksz;
  120         } else
  121                 sc->disk->d_stripesize = sc->disk->d_mediasize;
  122         sc->disk->d_drv1 = sc;
  123         disk_create(sc->disk, DISK_VERSION);
  124 
  125         mtx_init(&sc->qlock, "CFID I/O lock", NULL, MTX_DEF);
  126         bioq_init(&sc->bioq);
  127 
  128         sc->tq = taskqueue_create("cfid_taskq", M_NOWAIT,
  129                 taskqueue_thread_enqueue, &sc->tq);
  130         taskqueue_start_threads(&sc->tq, 1, PI_DISK, "cfid taskq");
  131 
  132         TASK_INIT(&sc->iotask, 0, cfi_io_proc, sc);
  133 
  134         return 0;
  135 }
  136 
  137 static int
  138 cfi_disk_detach(device_t dev)
  139 {
  140         struct cfi_disk_softc *sc = device_get_softc(dev);
  141 
  142         if (sc->flags & CFI_DISK_OPEN)
  143                 return EBUSY;
  144         taskqueue_free(sc->tq);
  145         /* XXX drain bioq */
  146         disk_destroy(sc->disk);
  147         mtx_destroy(&sc->qlock);
  148         return 0;
  149 }
  150 
  151 static int
  152 cfi_disk_open(struct disk *dp)
  153 {
  154         struct cfi_disk_softc *sc = dp->d_drv1;
  155 
  156         /* XXX no interlock with /dev/cfi */
  157         sc->flags |= CFI_DISK_OPEN;
  158         return 0;
  159 }
  160 
  161 static int
  162 cfi_disk_close(struct disk *dp)
  163 {
  164         struct cfi_disk_softc *sc = dp->d_drv1;
  165 
  166         sc->flags &= ~CFI_DISK_OPEN;
  167         return 0;
  168 }
  169 
  170 static void
  171 cfi_disk_read(struct cfi_softc *sc, struct bio *bp)
  172 {
  173         long resid;
  174 
  175         KASSERT(sc->sc_width == 1 || sc->sc_width == 2 || sc->sc_width == 4,
  176             ("sc_width %d", sc->sc_width));
  177 
  178         if (sc->sc_writing) {
  179                 bp->bio_error = cfi_block_finish(sc);
  180                 if (bp->bio_error) {
  181                         bp->bio_flags |= BIO_ERROR;
  182                         goto done;
  183                 }
  184         }
  185         if (bp->bio_offset > sc->sc_size) {
  186                 bp->bio_flags |= BIO_ERROR;
  187                 bp->bio_error = EIO;
  188                 goto done;
  189         }
  190         resid = bp->bio_bcount;
  191         if (sc->sc_width == 1) {
  192                 uint8_t *dp = (uint8_t *)bp->bio_data;
  193                 while (resid > 0 && bp->bio_offset < sc->sc_size) {
  194                         *dp++ = cfi_read_raw(sc, bp->bio_offset);
  195                         bp->bio_offset += 1, resid -= 1;
  196                 }
  197         } else if (sc->sc_width == 2) {
  198                 uint16_t *dp = (uint16_t *)bp->bio_data;
  199                 while (resid > 0 && bp->bio_offset < sc->sc_size) {
  200                         *dp++ = cfi_read_raw(sc, bp->bio_offset);
  201                         bp->bio_offset += 2, resid -= 2;
  202                 }
  203         } else {
  204                 uint32_t *dp = (uint32_t *)bp->bio_data;
  205                 while (resid > 0 && bp->bio_offset < sc->sc_size) {
  206                         *dp++ = cfi_read_raw(sc, bp->bio_offset);
  207                         bp->bio_offset += 4, resid -= 4;
  208                 }
  209         }
  210         bp->bio_resid = resid;
  211 done:
  212         biodone(bp);
  213 }
  214 
  215 static void
  216 cfi_disk_write(struct cfi_softc *sc, struct bio *bp)
  217 {
  218         long resid;
  219         u_int top;
  220 
  221         KASSERT(sc->sc_width == 1 || sc->sc_width == 2 || sc->sc_width == 4,
  222             ("sc_width %d", sc->sc_width));
  223 
  224         if (bp->bio_offset > sc->sc_size) {
  225                 bp->bio_flags |= BIO_ERROR;
  226                 bp->bio_error = EIO;
  227                 goto done;
  228         }
  229         resid = bp->bio_bcount;
  230         while (resid > 0) {
  231                 /*
  232                  * Finish the current block if we're about to write
  233                  * to a different block.
  234                  */
  235                 if (sc->sc_writing) {
  236                         top = sc->sc_wrofs + sc->sc_wrbufsz;
  237                         if (bp->bio_offset < sc->sc_wrofs ||
  238                             bp->bio_offset >= top)
  239                                 cfi_block_finish(sc);
  240                 }
  241 
  242                 /* Start writing to a (new) block if applicable. */
  243                 if (!sc->sc_writing) {
  244                         bp->bio_error = cfi_block_start(sc, bp->bio_offset);
  245                         if (bp->bio_error) {
  246                                 bp->bio_flags |= BIO_ERROR;
  247                                 goto done;
  248                         }
  249                 }
  250 
  251                 top = sc->sc_wrofs + sc->sc_wrbufsz;
  252                 bcopy(bp->bio_data,
  253                     sc->sc_wrbuf + bp->bio_offset - sc->sc_wrofs,
  254                     MIN(top - bp->bio_offset, resid));
  255                 resid -= MIN(top - bp->bio_offset, resid);
  256         }
  257         bp->bio_resid = resid;
  258 done:
  259         biodone(bp);
  260 }
  261 
  262 static void
  263 cfi_io_proc(void *arg, int pending)
  264 {
  265         struct cfi_disk_softc *sc = arg;
  266         struct cfi_softc *cfi = sc->parent;
  267         struct bio *bp;
  268 
  269         for (;;) {
  270                 mtx_lock(&sc->qlock);
  271                 bp = bioq_takefirst(&sc->bioq);
  272                 mtx_unlock(&sc->qlock);
  273                 if (bp == NULL)
  274                         break;
  275 
  276                 switch (bp->bio_cmd) {
  277                 case BIO_READ:
  278                         cfi_disk_read(cfi, bp);
  279                         break;
  280                 case BIO_WRITE:
  281                         cfi_disk_write(cfi, bp);
  282                         break;
  283                 }
  284         }
  285 }
  286 
  287 static int
  288 cfi_disk_getattr(struct bio *bp)
  289 {
  290         struct cfi_disk_softc *dsc;
  291         struct cfi_softc *sc;
  292         device_t dev;
  293 
  294         if (bp->bio_disk == NULL || bp->bio_disk->d_drv1 == NULL)
  295                 return (ENXIO);
  296 
  297         dsc = bp->bio_disk->d_drv1;
  298         sc = dsc->parent;
  299         dev = sc->sc_dev;
  300 
  301         if (strcmp(bp->bio_attribute, "CFI::device") == 0) {
  302                 if (bp->bio_length != sizeof(dev))
  303                         return (EFAULT);
  304                 bcopy(&dev, bp->bio_data, sizeof(dev));
  305         } else
  306                 return (-1);
  307         return (0);
  308 }
  309 
  310 
  311 static void
  312 cfi_disk_strategy(struct bio *bp)
  313 {
  314         struct cfi_disk_softc *sc = bp->bio_disk->d_drv1;
  315 
  316         if (sc == NULL)
  317                 goto invalid;
  318         if (bp->bio_bcount == 0) {
  319                 bp->bio_resid = bp->bio_bcount;
  320                 biodone(bp);
  321                 return;
  322         }
  323         switch (bp->bio_cmd) {
  324         case BIO_READ:
  325         case BIO_WRITE:
  326                 mtx_lock(&sc->qlock);
  327                 /* no value in sorting requests? */
  328                 bioq_insert_tail(&sc->bioq, bp);
  329                 mtx_unlock(&sc->qlock);
  330                 taskqueue_enqueue(sc->tq, &sc->iotask);
  331                 return;
  332         }
  333         /* fall thru... */
  334 invalid:
  335         bp->bio_flags |= BIO_ERROR;
  336         bp->bio_error = EINVAL;
  337         biodone(bp);
  338 }
  339 
  340 static int
  341 cfi_disk_ioctl(struct disk *dp, u_long cmd, void *data, int fflag,
  342         struct thread *td)
  343 {
  344         return EINVAL;
  345 }
  346 
  347 static device_method_t cfi_disk_methods[] = {
  348         DEVMETHOD(device_probe,         cfi_disk_probe),
  349         DEVMETHOD(device_attach,        cfi_disk_attach),
  350         DEVMETHOD(device_detach,        cfi_disk_detach),
  351 
  352         { 0, 0 }
  353 };
  354 static driver_t cfi_disk_driver = {
  355         "cfid",
  356         cfi_disk_methods,
  357         sizeof(struct cfi_disk_softc),
  358 };
  359 DRIVER_MODULE(cfid, cfi, cfi_disk_driver, cfi_diskclass, 0, NULL);
Cache object: 6d245e46ee28dd7478c59ce7216d3609
[ 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/dev/cfi/cfi_disk.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/cfi/cfi_disk.c
