The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/altera/avgen/altera_avgen.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  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
    3  *
    4  * Copyright (c) 2012-2013, 2016 Robert N. M. Watson
    5  * All rights reserved.
    6  *
    7  * This software was developed by SRI International and the University of
    8  * Cambridge Computer Laboratory under DARPA/AFRL contract (FA8750-10-C-0237)
    9  * ("CTSRD"), as part of the DARPA CRASH research 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 AND CONTRIBUTORS ``AS IS'' AND
   21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   30  * SUCH DAMAGE.
   31  */
   32 
   33 #include <sys/cdefs.h>
   34 __FBSDID("$FreeBSD: releng/12.0/sys/dev/altera/avgen/altera_avgen.c 326255 2017-11-27 14:52:40Z pfg $");
   35 
   36 #include <sys/param.h>
   37 #include <sys/bio.h>
   38 #include <sys/bus.h>
   39 #include <sys/condvar.h>
   40 #include <sys/conf.h>
   41 #include <sys/kernel.h>
   42 #include <sys/lock.h>
   43 #include <sys/malloc.h>
   44 #include <sys/module.h>
   45 #include <sys/mutex.h>
   46 #include <sys/rman.h>
   47 #include <sys/stat.h>
   48 #include <sys/systm.h>
   49 #include <sys/uio.h>
   50 
   51 #include <geom/geom_disk.h>
   52 
   53 #include <machine/bus.h>
   54 #include <machine/resource.h>
   55 
   56 #include <vm/vm.h>
   57 
   58 #include <dev/altera/avgen/altera_avgen.h>
   59 
   60 /*
   61  * Generic device driver for allowing read(), write(), and mmap() on
   62  * memory-mapped, Avalon-attached devices.  There is no actual dependence on
   63  * Avalon, so conceivably this should just be soc_dev or similar, since many
   64  * system-on-chip bus environments would work fine with the same code.
   65  */
   66 
   67 devclass_t altera_avgen_devclass;
   68 
   69 static d_mmap_t altera_avgen_mmap;
   70 static d_read_t altera_avgen_read;
   71 static d_write_t altera_avgen_write;
   72 
   73 #define ALTERA_AVGEN_DEVNAME            "altera_avgen"
   74 #define ALTERA_AVGEN_DEVNAME_FMT        (ALTERA_AVGEN_DEVNAME "%d")
   75 
   76 static struct cdevsw avg_cdevsw = {
   77         .d_version =    D_VERSION,
   78         .d_mmap =       altera_avgen_mmap,
   79         .d_read =       altera_avgen_read,
   80         .d_write =      altera_avgen_write,
   81         .d_name =       ALTERA_AVGEN_DEVNAME,
   82 };
   83 
   84 #define ALTERA_AVGEN_SECTORSIZE 512     /* Not configurable at this time. */
   85 
   86 static int
   87 altera_avgen_read(struct cdev *dev, struct uio *uio, int flag)
   88 {
   89         struct altera_avgen_softc *sc;
   90         u_long offset, size;
   91 #ifdef NOTYET
   92         uint64_t v8;
   93 #endif
   94         uint32_t v4;
   95         uint16_t v2;
   96         uint8_t v1;
   97         u_int width;
   98         int error;
   99 
  100         sc = dev->si_drv1;
  101         if ((sc->avg_flags & ALTERA_AVALON_FLAG_READ) == 0)
  102                 return (EACCES);
  103         width = sc->avg_width;
  104         if (uio->uio_offset < 0 || uio->uio_offset % width != 0 ||
  105             uio->uio_resid % width != 0)
  106                 return (ENODEV);
  107         size = rman_get_size(sc->avg_res);
  108         if ((uio->uio_offset + uio->uio_resid < 0) ||
  109             (uio->uio_offset + uio->uio_resid > size))
  110                 return (ENODEV);
  111         while (uio->uio_resid > 0) {
  112                 offset = uio->uio_offset;
  113                 if (offset + width > size)
  114                         return (ENODEV);
  115                 switch (width) {
  116                 case 1:
  117                         v1 = bus_read_1(sc->avg_res, offset);
  118                         error = uiomove(&v1, sizeof(v1), uio);
  119                         break;
  120                         
  121                 case 2:
  122                         v2 = bus_read_2(sc->avg_res, offset);
  123                         error = uiomove(&v2, sizeof(v2), uio);
  124                         break;
  125                         
  126                 case 4:
  127                         v4 = bus_read_4(sc->avg_res, offset);
  128                         error = uiomove(&v4, sizeof(v4), uio);
  129                         break;
  130                         
  131 #ifdef NOTYET
  132                 case 8:
  133                         v8 = bus_read_8(sc->avg_res, offset);
  134                         error = uiomove(&v8, sizeof(v8), uio);
  135                         break;
  136                         
  137 #endif
  138 
  139                 default:
  140                         panic("%s: unexpected widthment %u", __func__, width);
  141                 }
  142                 if (error)
  143                         return (error);
  144         }
  145         return (0);
  146 }
  147 
  148 static int
  149 altera_avgen_write(struct cdev *dev, struct uio *uio, int flag)
  150 {
  151         struct altera_avgen_softc *sc;
  152         u_long offset, size;
  153 #ifdef NOTYET
  154         uint64_t v8;
  155 #endif
  156         uint32_t v4;
  157         uint16_t v2;
  158         uint8_t v1;
  159         u_int width;
  160         int error;
  161 
  162         sc = dev->si_drv1;
  163         if ((sc->avg_flags & ALTERA_AVALON_FLAG_WRITE) == 0)
  164                 return (EACCES);
  165         width = sc->avg_width;
  166         if (uio->uio_offset < 0 || uio->uio_offset % width != 0 ||
  167             uio->uio_resid % width != 0)
  168                 return (ENODEV);
  169         size = rman_get_size(sc->avg_res);
  170         while (uio->uio_resid > 0) {
  171                 offset = uio->uio_offset;
  172                 if (offset + width > size)
  173                         return (ENODEV);
  174                 switch (width) {
  175                 case 1:
  176                         error = uiomove(&v1, sizeof(v1), uio);
  177                         if (error)
  178                                 return (error);
  179                         bus_write_1(sc->avg_res, offset, v1);
  180                         break;
  181 
  182                 case 2:
  183                         error = uiomove(&v2, sizeof(v2), uio);
  184                         if (error)
  185                                 return (error);
  186                         bus_write_2(sc->avg_res, offset, v2);
  187                         break;
  188 
  189                 case 4:
  190                         error = uiomove(&v4, sizeof(v4), uio);
  191                         if (error)
  192                                 return (error);
  193                         bus_write_4(sc->avg_res, offset, v4);
  194                         break;
  195 
  196 #ifdef NOTYET
  197                 case 8:
  198                         error = uiomove(&v8, sizeof(v8), uio);
  199                         if (error)
  200                                 return (error);
  201                         bus_write_8(sc->avg_res, offset, v8);
  202                         break;
  203 #endif
  204 
  205                 default:
  206                         panic("%s: unexpected width %u", __func__, width);
  207                 }
  208         }
  209         return (0);
  210 }
  211 
  212 static int
  213 altera_avgen_mmap(struct cdev *dev, vm_ooffset_t offset, vm_paddr_t *paddr,
  214     int nprot, vm_memattr_t *memattr)
  215 {
  216         struct altera_avgen_softc *sc;
  217 
  218         sc = dev->si_drv1;
  219         if (nprot & VM_PROT_READ) {
  220                 if ((sc->avg_flags & ALTERA_AVALON_FLAG_MMAP_READ) == 0)
  221                         return (EACCES);
  222         }
  223         if (nprot & VM_PROT_WRITE) {
  224                 if ((sc->avg_flags & ALTERA_AVALON_FLAG_MMAP_WRITE) == 0)
  225                         return (EACCES);
  226         }
  227         if (nprot & VM_PROT_EXECUTE) {
  228                 if ((sc->avg_flags & ALTERA_AVALON_FLAG_MMAP_EXEC) == 0)
  229                         return (EACCES);
  230         }
  231         if (trunc_page(offset) == offset &&
  232             rman_get_size(sc->avg_res) >= offset + PAGE_SIZE) {
  233                 *paddr = rman_get_start(sc->avg_res) + offset;
  234                 *memattr = VM_MEMATTR_UNCACHEABLE;
  235         } else
  236                 return (ENODEV);
  237         return (0);
  238 }
  239 
  240 /*
  241  * NB: We serialise block reads and writes in case the OS is generating
  242  * concurrent I/O against the same block, in which case we want one I/O (or
  243  * another) to win.  This is not sufficient to provide atomicity for the
  244  * sector in the presence of a fail stop -- however, we're just writing this
  245  * to non-persistent DRAM .. right?
  246  */
  247 static void
  248 altera_avgen_disk_strategy(struct bio *bp)
  249 {
  250         struct altera_avgen_softc *sc;
  251         void *data;
  252         long bcount;
  253         daddr_t pblkno;
  254 
  255         sc = bp->bio_disk->d_drv1;
  256         data = bp->bio_data;
  257         bcount = bp->bio_bcount;
  258         pblkno = bp->bio_pblkno;
  259 
  260         /*
  261          * Serialize block reads / writes.
  262          */
  263         mtx_lock(&sc->avg_disk_mtx);
  264         switch (bp->bio_cmd) {
  265         case BIO_READ:
  266                 if (!(sc->avg_flags & ALTERA_AVALON_FLAG_GEOM_READ)) {
  267                         biofinish(bp, NULL, EIO);
  268                         break;
  269                 }
  270                 switch (sc->avg_width) {
  271                 case 1:
  272                         bus_read_region_1(sc->avg_res,
  273                             bp->bio_pblkno * ALTERA_AVGEN_SECTORSIZE,
  274                             (uint8_t *)data, bcount);
  275                         break;
  276 
  277                 case 2:
  278                         bus_read_region_2(sc->avg_res,
  279                             bp->bio_pblkno * ALTERA_AVGEN_SECTORSIZE,
  280                             (uint16_t *)data, bcount / 2);
  281                         break;
  282 
  283                 case 4:
  284                         bus_read_region_4(sc->avg_res,
  285                             bp->bio_pblkno * ALTERA_AVGEN_SECTORSIZE,
  286                             (uint32_t *)data, bcount / 4);
  287                         break;
  288 
  289                 default:
  290                         panic("%s: unexpected width %u", __func__,
  291                             sc->avg_width);
  292                 }
  293                 break;
  294 
  295         case BIO_WRITE:
  296                 if (!(sc->avg_flags & ALTERA_AVALON_FLAG_GEOM_WRITE)) {
  297                         biofinish(bp, NULL, EROFS);
  298                         break;
  299                 }
  300                 switch (sc->avg_width) {
  301                 case 1:
  302                         bus_write_region_1(sc->avg_res,
  303                             bp->bio_pblkno * ALTERA_AVGEN_SECTORSIZE,
  304                             (uint8_t *)data, bcount);
  305                         break;
  306 
  307                 case 2:
  308                         bus_write_region_2(sc->avg_res,
  309                             bp->bio_pblkno * ALTERA_AVGEN_SECTORSIZE,
  310                             (uint16_t *)data, bcount / 2);
  311                         break;
  312 
  313                 case 4:
  314                         bus_write_region_4(sc->avg_res,
  315                             bp->bio_pblkno * ALTERA_AVGEN_SECTORSIZE,
  316                             (uint32_t *)data, bcount / 4);
  317                         break;
  318 
  319                 default:
  320                         panic("%s: unexpected width %u", __func__,
  321                             sc->avg_width);
  322                 }
  323                 break;
  324 
  325         default:
  326                 panic("%s: unsupported I/O operation %d", __func__,
  327                     bp->bio_cmd);
  328         }
  329         mtx_unlock(&sc->avg_disk_mtx);
  330         biofinish(bp, NULL, 0);
  331 }
  332 
  333 static int
  334 altera_avgen_process_options(struct altera_avgen_softc *sc,
  335     const char *str_fileio, const char *str_geomio, const char *str_mmapio,
  336     const char *str_devname, int devunit)
  337 {
  338         const char *cp;
  339         device_t dev = sc->avg_dev;
  340 
  341         /*
  342          * Check for valid combinations of options.
  343          */
  344         if (str_fileio == NULL && str_geomio == NULL && str_mmapio == NULL) {
  345                 device_printf(dev,
  346                     "at least one of %s, %s, or %s must be specified\n",
  347                     ALTERA_AVALON_STR_FILEIO, ALTERA_AVALON_STR_GEOMIO,
  348                     ALTERA_AVALON_STR_MMAPIO);
  349                 return (ENXIO);
  350         }
  351 
  352         /*
  353          * Validity check: a device can either be a GEOM device (in which case
  354          * we use GEOM to register the device node), or a special device --
  355          * but not both as that causes a collision in /dev.
  356          */
  357         if (str_geomio != NULL && (str_fileio != NULL || str_mmapio != NULL)) {
  358                 device_printf(dev,
  359                     "at most one of %s and (%s or %s) may be specified\n",
  360                     ALTERA_AVALON_STR_GEOMIO, ALTERA_AVALON_STR_FILEIO,
  361                     ALTERA_AVALON_STR_MMAPIO);
  362                 return (ENXIO);
  363         }
  364 
  365         /*
  366          * Ensure that a unit is specified if a name is also specified.
  367          */
  368         if (str_devname == NULL && devunit != -1) {
  369                 device_printf(dev, "%s requires %s be specified\n",
  370                     ALTERA_AVALON_STR_DEVUNIT, ALTERA_AVALON_STR_DEVNAME);
  371                 return (ENXIO);
  372         }
  373 
  374         /*
  375          * Extract, digest, and save values.
  376          */
  377         switch (sc->avg_width) {
  378         case 1:
  379         case 2:
  380         case 4:
  381 #ifdef NOTYET
  382         case 8:
  383 #endif
  384                 break;
  385 
  386         default:
  387                 device_printf(dev, "%s unsupported value %u\n",
  388                     ALTERA_AVALON_STR_WIDTH, sc->avg_width);
  389                 return (ENXIO);
  390         }
  391         sc->avg_flags = 0;
  392         if (str_fileio != NULL) {
  393                 for (cp = str_fileio; *cp != '\0'; cp++) {
  394                         switch (*cp) {
  395                         case ALTERA_AVALON_CHAR_READ:
  396                                 sc->avg_flags |= ALTERA_AVALON_FLAG_READ;
  397                                 break;
  398 
  399                         case ALTERA_AVALON_CHAR_WRITE:
  400                                 sc->avg_flags |= ALTERA_AVALON_FLAG_WRITE;
  401                                 break;
  402 
  403                         default:
  404                                 device_printf(dev,
  405                                     "invalid %s character %c\n", 
  406                                     ALTERA_AVALON_STR_FILEIO, *cp);
  407                                 return (ENXIO);
  408                         }
  409                 }
  410         }
  411         if (str_geomio != NULL) {
  412                 for (cp = str_geomio; *cp != '\0'; cp++){
  413                         switch (*cp) {
  414                         case ALTERA_AVALON_CHAR_READ:
  415                                 sc->avg_flags |= ALTERA_AVALON_FLAG_GEOM_READ;
  416                                 break;
  417 
  418                         case ALTERA_AVALON_CHAR_WRITE:
  419                                 sc->avg_flags |= ALTERA_AVALON_FLAG_GEOM_WRITE;
  420                                 break;
  421 
  422                         default:
  423                                 device_printf(dev,
  424                                     "invalid %s character %c\n",
  425                                     ALTERA_AVALON_STR_GEOMIO, *cp);
  426                                 return (ENXIO);
  427                         }
  428                 }
  429         }
  430         if (str_mmapio != NULL) {
  431                 for (cp = str_mmapio; *cp != '\0'; cp++) {
  432                         switch (*cp) {
  433                         case ALTERA_AVALON_CHAR_READ:
  434                                 sc->avg_flags |= ALTERA_AVALON_FLAG_MMAP_READ;
  435                                 break;
  436 
  437                         case ALTERA_AVALON_CHAR_WRITE:
  438                                 sc->avg_flags |=
  439                                     ALTERA_AVALON_FLAG_MMAP_WRITE;
  440                                 break;
  441 
  442                         case ALTERA_AVALON_CHAR_EXEC:
  443                                 sc->avg_flags |= ALTERA_AVALON_FLAG_MMAP_EXEC;
  444                                 break;
  445 
  446                         default:
  447                                 device_printf(dev,
  448                                     "invalid %s character %c\n",
  449                                     ALTERA_AVALON_STR_MMAPIO, *cp);
  450                                 return (ENXIO);
  451                         }
  452                 }
  453         }
  454         return (0);
  455 }
  456 
  457 int
  458 altera_avgen_attach(struct altera_avgen_softc *sc, const char *str_fileio,
  459     const char *str_geomio, const char *str_mmapio, const char *str_devname,
  460     int devunit)
  461 {
  462         device_t dev = sc->avg_dev;
  463         int error;
  464 
  465         error = altera_avgen_process_options(sc, str_fileio, str_geomio,
  466             str_mmapio, str_devname, devunit);
  467         if (error)
  468                 return (error);
  469 
  470         if (rman_get_size(sc->avg_res) >= PAGE_SIZE || str_mmapio != NULL) {
  471                 if (rman_get_size(sc->avg_res) % PAGE_SIZE != 0) {
  472                         device_printf(dev,
  473                             "memory region not even multiple of page size\n");
  474                         return (ENXIO);
  475                 }
  476                 if (rman_get_start(sc->avg_res) % PAGE_SIZE != 0) {
  477                         device_printf(dev, "memory region not page-aligned\n");
  478                         return (ENXIO);
  479                 }
  480         }
  481 
  482         /*
  483          * If a GEOM permission is requested, then create the device via GEOM.
  484          * Otherwise, create a special device.  We checked during options
  485          * processing that both weren't requested a once.
  486          */
  487         if (str_devname != NULL) {
  488                 sc->avg_name = strdup(str_devname, M_TEMP);
  489                 devunit = sc->avg_unit;
  490         } else
  491                 sc->avg_name = strdup(ALTERA_AVGEN_DEVNAME, M_TEMP);
  492         if (sc->avg_flags & (ALTERA_AVALON_FLAG_GEOM_READ |
  493             ALTERA_AVALON_FLAG_GEOM_WRITE)) {
  494                 mtx_init(&sc->avg_disk_mtx, "altera_avgen_disk", NULL,
  495                     MTX_DEF);
  496                 sc->avg_disk = disk_alloc();
  497                 sc->avg_disk->d_drv1 = sc;
  498                 sc->avg_disk->d_strategy = altera_avgen_disk_strategy;
  499                 if (devunit == -1)
  500                         devunit = 0;
  501                 sc->avg_disk->d_name = sc->avg_name;
  502                 sc->avg_disk->d_unit = devunit;
  503 
  504                 /*
  505                  * NB: As avg_res is a multiple of PAGE_SIZE, it is also a
  506                  * multiple of ALTERA_AVGEN_SECTORSIZE.
  507                  */
  508                 sc->avg_disk->d_sectorsize = ALTERA_AVGEN_SECTORSIZE;
  509                 sc->avg_disk->d_mediasize = rman_get_size(sc->avg_res);
  510                 sc->avg_disk->d_maxsize = ALTERA_AVGEN_SECTORSIZE;
  511                 disk_create(sc->avg_disk, DISK_VERSION);
  512         } else {
  513                 /* Device node allocation. */
  514                 if (str_devname == NULL) {
  515                         str_devname = ALTERA_AVGEN_DEVNAME_FMT;
  516                         devunit = sc->avg_unit;
  517                 }
  518                 if (devunit != -1)
  519                         sc->avg_cdev = make_dev(&avg_cdevsw, sc->avg_unit,
  520                             UID_ROOT, GID_WHEEL, S_IRUSR | S_IWUSR, "%s%d",
  521                             str_devname, devunit);
  522                 else
  523                         sc->avg_cdev = make_dev(&avg_cdevsw, sc->avg_unit,
  524                             UID_ROOT, GID_WHEEL, S_IRUSR | S_IWUSR,
  525                             "%s", str_devname);
  526                 if (sc->avg_cdev == NULL) {
  527                         device_printf(sc->avg_dev, "%s: make_dev failed\n",
  528                             __func__);
  529                         return (ENXIO);
  530                 }
  531 
  532                 /* XXXRW: Slight race between make_dev(9) and here. */
  533                 sc->avg_cdev->si_drv1 = sc;
  534         }
  535         return (0);
  536 }
  537 
  538 void
  539 altera_avgen_detach(struct altera_avgen_softc *sc)
  540 {
  541 
  542         KASSERT((sc->avg_disk != NULL) || (sc->avg_cdev != NULL),
  543             ("%s: neither GEOM nor special device", __func__));
  544 
  545         if (sc->avg_disk != NULL) {
  546                 disk_gone(sc->avg_disk);
  547                 disk_destroy(sc->avg_disk);
  548                 free(sc->avg_name, M_TEMP);
  549                 mtx_destroy(&sc->avg_disk_mtx);
  550         } else {
  551                 destroy_dev(sc->avg_cdev);
  552         }
  553 }

Cache object: 06b159b3b15237241f0af62cb54b21e2


[ 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.