sys/dev/adlink/adlink.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-3-Clause
   3  *
   4  * Copyright (c) 2003-2004 Poul-Henning Kamp
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. The names of the authors may not be used to endorse or promote
  16  *    products derived from this software without specific prior written
  17  *    permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  *
  31  * This is a device driver or the Adlink 9812 and 9810 ADC cards, mainly
  32  * intended to support Software Defined Radio reception of timesignals
  33  * in the VLF band.  See http://phk.freebsd.dk/loran-c
  34  *
  35  * The driver is configured with ioctls which define a ringbuffer with
  36  * a given number of chunks in it.  The a control structure and the
  37  * ringbuffer can then be mmap(2)'ed into userland and the application
  38  * can operate on the data directly.
  39  *
  40  * Tested with 10MHz external clock, divisor of 2 (ie: 5MHz sampling),
  41  * One channel active (ie: 2 bytes per sample = 10MB/sec) on a 660MHz
  42  * Celeron PC.
  43  *
  44  */
  45
  46 #ifdef _KERNEL
  47 #include <sys/cdefs.h>
  48 __FBSDID("$FreeBSD$");
  49
  50 #include <sys/param.h>
  51 #include <sys/systm.h>
  52 #include <sys/malloc.h>
  53 #include <sys/kernel.h>
  54 #include <sys/module.h>
  55 #include <sys/kthread.h>
  56 #include <sys/conf.h>
  57 #include <sys/bus.h>
  58 #include <machine/bus.h>
  59 #include <machine/resource.h>
  60 #include <sys/rman.h>
  61 #include <dev/pci/pcireg.h>
  62 #include <dev/pci/pcivar.h>
  63 #include <pci_if.h>
  64 #include <vm/vm.h>
  65 #include <vm/pmap.h>
  66
  67 #endif /* _KERNEL */
  68
  69 #include <sys/ioccom.h>
  70
  71 #define ADLINK_SETDIVISOR       _IOWR('A', 255, u_int)  /* divisor */
  72 #define ADLINK_SETCHUNKSIZE     _IOWR('A', 254, u_int)  /* bytes */
  73 #define ADLINK_SETRINGSIZE      _IOWR('A', 253, u_int)  /* bytes */
  74 #define ADLINK_START            _IOWR('A', 252, u_int)  /* dummy */
  75 #define ADLINK_STOP             _IOWR('A', 251, u_int)  /* dummy */
  76 #define ADLINK_RESET            _IOWR('A', 250, u_int)  /* dummy */
  77
  78 struct page0 {
  79         u_int                   version;
  80         int                     state;
  81 #         define STATE_RESET    -1
  82 #         define STATE_RUN      0
  83         u_int                   divisor;        /* int */
  84         u_int                   chunksize;      /* bytes */
  85         u_int                   ringsize;       /* chunks */
  86         u_int                   o_sample;       /*
  87                                                  * offset of ring generation
  88                                                  * array
  89                                                  */
  90         u_int                   o_ring;         /* offset of ring */
  91 };
  92
  93 #define PAGE0VERSION    20050219
  94
  95 #ifdef _KERNEL
  96
  97 struct pgstat {
  98         uint64_t                *sample;
  99         vm_paddr_t              phys;
 100         void                    *virt;
 101         struct pgstat           *next;
 102 };
 103
 104 struct softc {
 105         device_t                device;
 106         void                    *intrhand;
 107         struct resource         *res[3];
 108         struct cdev             *dev;
 109         off_t                   mapvir;
 110         int                     error;
 111         struct page0            *p0;
 112         u_int                   nchunks;
 113         struct pgstat           *chunks;
 114         struct pgstat           *next;
 115         uint64_t                sample;
 116 };
 117
 118 static d_ioctl_t adlink_ioctl;
 119 static d_mmap_t adlink_mmap;
 120 static int adlink_intr(void *arg);
 121
 122 static struct cdevsw adlink_cdevsw = {
 123         .d_version =    D_VERSION,
 124         .d_flags =      D_NEEDGIANT,
 125         .d_ioctl =      adlink_ioctl,
 126         .d_mmap =       adlink_mmap,
 127         .d_name =       "adlink",
 128 };
 129
 130 static int
 131 adlink_intr(void *arg)
 132 {
 133         struct softc *sc;
 134         struct pgstat *pg;
 135         uint32_t u;
 136
 137         sc = arg;
 138         u = bus_read_4(sc->res[0], 0x38);
 139         if (!(u & 0x00800000))
 140                 return (FILTER_STRAY);
 141         bus_write_4(sc->res[0], 0x38, u | 0x003f4000);
 142
 143         sc->sample += sc->p0->chunksize / 2;
 144         pg = sc->next;
 145         *(pg->sample) = sc->sample;
 146
 147         u = bus_read_4(sc->res[1], 0x18);
 148         if (u & 1)
 149                 sc->p0->state = EIO;
 150
 151         if (sc->p0->state != STATE_RUN) {
 152                 printf("adlink: stopping %d\n", sc->p0->state);
 153                 return (FILTER_STRAY);
 154         }
 155
 156         pg = pg->next;
 157         sc->next = pg;
 158         *(pg->sample) = 0;
 159         bus_write_4(sc->res[0], 0x24, pg->phys);
 160         bus_write_4(sc->res[0], 0x28, sc->p0->chunksize);
 161         wakeup(sc);
 162         return (FILTER_HANDLED);
 163 }
 164
 165 static int
 166 adlink_mmap(struct cdev *dev, vm_ooffset_t offset, vm_paddr_t *paddr,
 167     int nprot, vm_memattr_t *memattr)
 168 {
 169         struct softc *sc;
 170         vm_offset_t o;
 171         int i;
 172         struct pgstat *pg;
 173
 174         sc = dev->si_drv1;
 175         if (nprot != VM_PROT_READ)
 176                 return (-1);
 177         if (offset == 0) {
 178                 *paddr = vtophys(sc->p0);
 179                 return (0);
 180         }
 181         o = PAGE_SIZE;
 182         pg = sc->chunks;
 183         for (i = 0; i < sc->nchunks; i++, pg++) {
 184                 if (offset - o >= sc->p0->chunksize) {
 185                         o += sc->p0->chunksize;
 186                         continue;
 187                 }
 188                 *paddr = pg->phys + (offset - o);
 189                 return (0);
 190         }
 191         return (-1);
 192 }
 193
 194 static int
 195 adlink_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag, struct thread *td)
 196 {
 197         struct softc *sc;
 198         int i, error;
 199         u_int u;
 200         struct pgstat *pg;
 201         uint64_t *sample;
 202
 203         sc = dev->si_drv1;
 204         u = *(u_int*)data;
 205         error = 0;
 206         switch (cmd) {
 207         case ADLINK_SETDIVISOR:
 208                 if (sc->p0->state == STATE_RUN)
 209                         return (EBUSY);
 210                 if (u & 1)
 211                         return (EINVAL);
 212                 sc->p0->divisor = u;
 213                 break;
 214         case ADLINK_SETCHUNKSIZE:
 215                 if (sc->p0->state != STATE_RESET)
 216                         return (EBUSY);
 217                 if (u % PAGE_SIZE)
 218                         return (EINVAL);
 219                 if (sc->p0->ringsize != 0 && sc->p0->ringsize % u)
 220                         return (EINVAL);
 221                 sc->p0->chunksize = u;
 222                 break;
 223         case ADLINK_SETRINGSIZE:
 224                 if (sc->p0->state != STATE_RESET)
 225                         return (EBUSY);
 226                 if (u % PAGE_SIZE)
 227                         return (EINVAL);
 228                 if (sc->p0->chunksize != 0 && u % sc->p0->chunksize)
 229                         return (EINVAL);
 230                 sc->p0->ringsize = u;
 231                 break;
 232         case ADLINK_START:
 233                 if (sc->p0->state == STATE_RUN)
 234                         return (EBUSY);
 235                 if (sc->p0->state == STATE_RESET) {
 236
 237                         if (sc->p0->chunksize == 0)
 238                                 sc->p0->chunksize = 4 * PAGE_SIZE;
 239                         if (sc->p0->ringsize == 0)
 240                                 sc->p0->ringsize = 16 * sc->p0->chunksize;
 241                         if (sc->p0->divisor == 0)
 242                                 sc->p0->divisor = 4;
 243
 244                         sc->nchunks = sc->p0->ringsize / sc->p0->chunksize;
 245                         if (sc->nchunks * sizeof (*pg->sample) +
 246                             sizeof *sc->p0 > PAGE_SIZE)
 247                                 return (EINVAL);
 248                         sc->p0->o_ring = PAGE_SIZE;
 249                         sample = (uint64_t *)(sc->p0 + 1);
 250                         sc->p0->o_sample =
 251                             (uintptr_t)sample - (uintptr_t)(sc->p0);
 252                         pg = malloc(sizeof *pg * sc->nchunks,
 253                             M_DEVBUF, M_WAITOK | M_ZERO);
 254                         sc->chunks = pg;
 255                         for (i = 0; i < sc->nchunks; i++) {
 256                                 pg->sample = sample;
 257                                 *pg->sample = 0;
 258                                 sample++;
 259                                 pg->virt = contigmalloc(sc->p0->chunksize,
 260                                     M_DEVBUF, M_WAITOK,
 261                                     0ul, 0xfffffffful,
 262                                     PAGE_SIZE, 0);
 263                                 pg->phys = vtophys(pg->virt);
 264                                 if (i == sc->nchunks - 1)
 265                                         pg->next = sc->chunks;
 266                                 else
 267                                         pg->next = pg + 1;
 268                                 pg++;
 269                         }
 270                         sc->next = sc->chunks;
 271                 }
 272
 273                 /* Reset generation numbers */
 274                 pg = sc->chunks;
 275                 for (i = 0; i < sc->nchunks; i++) {
 276                         *pg->sample = 0;
 277                         pg++;
 278                 }
 279
 280                 /* Enable interrupts on write complete */
 281                 bus_write_4(sc->res[0], 0x38, 0x00004000);
 282
 283                 /* Sample CH0 only */
 284                 bus_write_4(sc->res[1], 0x00, 1);
 285
 286                 /* Divide clock by four */
 287                 bus_write_4(sc->res[1], 0x04, sc->p0->divisor);
 288
 289                 /* Software trigger mode: software */
 290                 bus_write_4(sc->res[1], 0x08, 0);
 291
 292                 /* Trigger level zero */
 293                 bus_write_4(sc->res[1], 0x0c, 0);
 294
 295                 /* Trigger source CH0 (not used) */
 296                 bus_write_4(sc->res[1], 0x10, 0);
 297
 298                 /* Fifo control/status: flush */
 299                 bus_write_4(sc->res[1], 0x18, 3);
 300
 301                 /* Clock source: external sine */
 302                 bus_write_4(sc->res[1], 0x20, 2);
 303
 304                 /* Chipmunks are go! */
 305                 sc->p0->state = STATE_RUN;
 306
 307                 /* Set up Write DMA */
 308                 pg = sc->next = sc->chunks;
 309                 *(pg->sample) = 0;
 310                 bus_write_4(sc->res[0], 0x24, pg->phys);
 311                 bus_write_4(sc->res[0], 0x28, sc->p0->chunksize);
 312                 u = bus_read_4(sc->res[0], 0x3c);
 313                 bus_write_4(sc->res[0], 0x3c, u | 0x00000600);
 314
 315                 /* Acquisition Enable Register: go! */
 316                 bus_write_4(sc->res[1], 0x1c, 1);
 317
 318                 break;
 319         case ADLINK_STOP:
 320                 if (sc->p0->state == STATE_RESET)
 321                         break;
 322                 sc->p0->state = EINTR;
 323                 while (*(sc->next->sample) == 0)
 324                         tsleep(sc, PUSER | PCATCH, "adstop", 1);
 325                 break;
 326 #ifdef notyet
 327         /*
 328          * I'm not sure we can actually do this.  How do we revoke
 329          * the mmap'ed pages from any process having them mmapped ?
 330          */
 331         case ADLINK_RESET:
 332                 if (sc->p0->state == STATE_RESET)
 333                         break;
 334                 sc->p0->state = EINTR;
 335                 while (*(sc->next->samp) == 0)
 336                         tsleep(sc, PUSER | PCATCH, "adreset", 1);
 337                 /* deallocate ring buffer */
 338                 break;
 339 #endif
 340         default:
 341                 error = ENOIOCTL;
 342                 break;
 343         }
 344         return (error);
 345 }
 346
 347 static devclass_t adlink_devclass;
 348
 349 struct pci_id
 350 {
 351         uint16_t        vendor;
 352         uint16_t        device;
 353         const char      *desc;
 354 } adlink_id[] = {
 355         { .vendor = 0x10e8, .device = 0x80da,
 356           .desc ="Adlink PCI-9812 4 ch 12 bit 20 msps" }
 357 };
 358
 359 static int
 360 adlink_probe(device_t self)
 361 {
 362         int i;
 363         uint16_t vendor, device;
 364
 365         vendor = pci_get_vendor(self);
 366         device = pci_get_device(self);
 367         for (i = 0; i < nitems(adlink_id); i++) {
 368                 if (adlink_id[i].vendor == vendor &&
 369                     adlink_id[i].device == device) {
 370                         device_set_desc(self, adlink_id[i].desc);
 371                         return (BUS_PROBE_DEFAULT);
 372                 }
 373         }
 374         return (ENXIO);
 375 }
 376
 377 static struct resource_spec adlink_res_spec[] = {
 378         { SYS_RES_IOPORT,       PCIR_BAR(0),    RF_ACTIVE},
 379         { SYS_RES_IOPORT,       PCIR_BAR(1),    RF_ACTIVE},
 380         { SYS_RES_IRQ,          0,              RF_ACTIVE | RF_SHAREABLE},
 381         { -1, 0, 0 }
 382 };
 383
 384 static int
 385 adlink_attach(device_t self)
 386 {
 387         struct softc *sc;
 388         int i, error;
 389
 390         sc = device_get_softc(self);
 391         bzero(sc, sizeof *sc);
 392         sc->device = self;
 393
 394         error = bus_alloc_resources(self, adlink_res_spec, sc->res);
 395         if (error)
 396                 return (error);
 397
 398         i = bus_setup_intr(self, sc->res[2], INTR_TYPE_MISC,
 399             adlink_intr, NULL, sc, &sc->intrhand);
 400         if (i) {
 401                 printf("adlink: Couldn't get FAST intr\n");
 402                 i = bus_setup_intr(self, sc->res[2],
 403                     INTR_MPSAFE | INTR_TYPE_MISC,
 404                     NULL, (driver_intr_t *)adlink_intr, sc, &sc->intrhand);
 405         }
 406
 407         if (i) {
 408                 bus_release_resources(self, adlink_res_spec, sc->res);
 409                 return (ENODEV);
 410         }
 411
 412         sc->p0 = malloc(PAGE_SIZE, M_DEVBUF, M_WAITOK | M_ZERO);
 413         sc->p0->version = PAGE0VERSION;
 414         sc->p0->state = STATE_RESET;
 415
 416         sc->dev = make_dev(&adlink_cdevsw, device_get_unit(self),
 417             UID_ROOT, GID_WHEEL, 0444, "adlink%d", device_get_unit(self));
 418         sc->dev->si_drv1 = sc;
 419
 420         return (0);
 421 }
 422
 423 static device_method_t adlink_methods[] = {
 424         /* Device interface */
 425         DEVMETHOD(device_probe,         adlink_probe),
 426         DEVMETHOD(device_attach,        adlink_attach),
 427         DEVMETHOD(device_suspend,       bus_generic_suspend),
 428         DEVMETHOD(device_resume,        bus_generic_resume),
 429         DEVMETHOD(device_shutdown,      bus_generic_shutdown),
 430
 431         DEVMETHOD_END
 432 };
 433
 434 static driver_t adlink_driver = {
 435         "adlink",
 436         adlink_methods,
 437         sizeof(struct softc)
 438 };
 439
 440 DRIVER_MODULE(adlink, pci, adlink_driver, adlink_devclass, 0, 0);
 441 MODULE_PNP_INFO("U16:vendor;U16:device;D:#", pci, adlink, adlink_id,
 442     nitems(adlink_id));
 443 #endif /* _KERNEL */