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