sys/dev/altera/avgen/altera_avgen.c

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