Pileus Git - ~andy/linux/blob - drivers/staging/comedi/drivers/amplc_pc236.c

   1 /*
   2     comedi/drivers/amplc_pc236.c
   3     Driver for Amplicon PC36AT and PCI236 DIO boards.
   4
   5     Copyright (C) 2002 MEV Ltd. <http://www.mev.co.uk/>
   6
   7     COMEDI - Linux Control and Measurement Device Interface
   8     Copyright (C) 2000 David A. Schleef <ds@schleef.org>
   9
  10     This program is free software; you can redistribute it and/or modify
  11     it under the terms of the GNU General Public License as published by
  12     the Free Software Foundation; either version 2 of the License, or
  13     (at your option) any later version.
  14
  15     This program is distributed in the hope that it will be useful,
  16     but WITHOUT ANY WARRANTY; without even the implied warranty of
  17     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18     GNU General Public License for more details.
  19
  20     You should have received a copy of the GNU General Public License
  21     along with this program; if not, write to the Free Software
  22     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23
  24 */
  25 /*
  26 Driver: amplc_pc236
  27 Description: Amplicon PC36AT, PCI236
  28 Author: Ian Abbott <abbotti@mev.co.uk>
  29 Devices: [Amplicon] PC36AT (pc36at), PCI236 (pci236 or amplc_pc236)
  30 Updated: Wed, 01 Apr 2009 15:41:25 +0100
  31 Status: works
  32
  33 Configuration options - PC36AT:
  34   [0] - I/O port base address
  35   [1] - IRQ (optional)
  36
  37 Configuration options - PCI236:
  38   [0] - PCI bus of device (optional)
  39   [1] - PCI slot of device (optional)
  40   If bus/slot is not specified, the first available PCI device will be
  41   used.
  42
  43 The PC36AT ISA board and PCI236 PCI board have a single 8255 appearing
  44 as subdevice 0.
  45
  46 Subdevice 1 pretends to be a digital input device, but it always returns
  47 0 when read. However, if you run a command with scan_begin_src=TRIG_EXT,
  48 a rising edge on port C bit 3 acts as an external trigger, which can be
  49 used to wake up tasks.  This is like the comedi_parport device, but the
  50 only way to physically disable the interrupt on the PC36AT is to remove
  51 the IRQ jumper.  If no interrupt is connected, then subdevice 1 is
  52 unused.
  53 */
  54
  55 #include <linux/pci.h>
  56 #include <linux/interrupt.h>
  57
  58 #include "../comedidev.h"
  59
  60 #include "comedi_fc.h"
  61 #include "8255.h"
  62 #include "plx9052.h"
  63
  64 #define PC236_DRIVER_NAME       "amplc_pc236"
  65
  66 #define DO_ISA  IS_ENABLED(CONFIG_COMEDI_AMPLC_PC236_ISA)
  67 #define DO_PCI  IS_ENABLED(CONFIG_COMEDI_AMPLC_PC236_PCI)
  68
  69 /* PCI236 PCI configuration register information */
  70 #define PCI_DEVICE_ID_AMPLICON_PCI236 0x0009
  71 #define PCI_DEVICE_ID_INVALID 0xffff
  72
  73 /* PC36AT / PCI236 registers */
  74
  75 #define PC236_IO_SIZE           4
  76 #define PC236_LCR_IO_SIZE       128
  77
  78 /*
  79  * INTCSR values for PCI236.
  80  */
  81 /* Disable interrupt, also clear any interrupt there */
  82 #define PCI236_INTR_DISABLE (PLX9052_INTCSR_LI1ENAB_DISABLED \
  83         | PLX9052_INTCSR_LI1POL_HIGH \
  84         | PLX9052_INTCSR_LI2POL_HIGH \
  85         | PLX9052_INTCSR_PCIENAB_DISABLED \
  86         | PLX9052_INTCSR_LI1SEL_EDGE \
  87         | PLX9052_INTCSR_LI1CLRINT_ASSERTED)
  88 /* Enable interrupt, also clear any interrupt there. */
  89 #define PCI236_INTR_ENABLE (PLX9052_INTCSR_LI1ENAB_ENABLED \
  90         | PLX9052_INTCSR_LI1POL_HIGH \
  91         | PLX9052_INTCSR_LI2POL_HIGH \
  92         | PLX9052_INTCSR_PCIENAB_ENABLED \
  93         | PLX9052_INTCSR_LI1SEL_EDGE \
  94         | PLX9052_INTCSR_LI1CLRINT_ASSERTED)
  95
  96 /*
  97  * Board descriptions for Amplicon PC36AT and PCI236.
  98  */
  99
 100 enum pc236_bustype { isa_bustype, pci_bustype };
 101 enum pc236_model { pc36at_model, pci236_model, anypci_model };
 102
 103 struct pc236_board {
 104         const char *name;
 105         unsigned short devid;
 106         enum pc236_bustype bustype;
 107         enum pc236_model model;
 108 };
 109 static const struct pc236_board pc236_boards[] = {
 110 #if DO_ISA
 111         {
 112                 .name = "pc36at",
 113                 .bustype = isa_bustype,
 114                 .model = pc36at_model,
 115         },
 116 #endif
 117 #if DO_PCI
 118         {
 119                 .name = "pci236",
 120                 .devid = PCI_DEVICE_ID_AMPLICON_PCI236,
 121                 .bustype = pci_bustype,
 122                 .model = pci236_model,
 123         },
 124         {
 125                 .name = PC236_DRIVER_NAME,
 126                 .devid = PCI_DEVICE_ID_INVALID,
 127                 .bustype = pci_bustype,
 128                 .model = anypci_model,  /* wildcard */
 129         },
 130 #endif
 131 };
 132
 133 /* this structure is for data unique to this hardware driver.  If
 134    several hardware drivers keep similar information in this structure,
 135    feel free to suggest moving the variable to the struct comedi_device struct.
 136  */
 137 struct pc236_private {
 138         unsigned long lcr_iobase; /* PLX PCI9052 config registers in PCIBAR1 */
 139         int enable_irq;
 140 };
 141
 142 /* test if ISA supported and this is an ISA board */
 143 static inline bool is_isa_board(const struct pc236_board *board)
 144 {
 145         return DO_ISA && board->bustype == isa_bustype;
 146 }
 147
 148 /* test if PCI supported and this is a PCI board */
 149 static inline bool is_pci_board(const struct pc236_board *board)
 150 {
 151         return DO_PCI && board->bustype == pci_bustype;
 152 }
 153
 154 /*
 155  * This function looks for a board matching the supplied PCI device.
 156  */
 157 static const struct pc236_board *pc236_find_pci_board(struct pci_dev *pci_dev)
 158 {
 159         unsigned int i;
 160
 161         for (i = 0; i < ARRAY_SIZE(pc236_boards); i++)
 162                 if (is_pci_board(&pc236_boards[i]) &&
 163                     pci_dev->device == pc236_boards[i].devid)
 164                         return &pc236_boards[i];
 165         return NULL;
 166 }
 167
 168 /*
 169  * This function looks for a PCI device matching the requested board name,
 170  * bus and slot.
 171  */
 172 static struct pci_dev *pc236_find_pci_dev(struct comedi_device *dev,
 173                                           struct comedi_devconfig *it)
 174 {
 175         const struct pc236_board *thisboard = comedi_board(dev);
 176         struct pci_dev *pci_dev = NULL;
 177         int bus = it->options[0];
 178         int slot = it->options[1];
 179
 180         for_each_pci_dev(pci_dev) {
 181                 if (bus || slot) {
 182                         if (bus != pci_dev->bus->number ||
 183                             slot != PCI_SLOT(pci_dev->devfn))
 184                                 continue;
 185                 }
 186                 if (pci_dev->vendor != PCI_VENDOR_ID_AMPLICON)
 187                         continue;
 188
 189                 if (thisboard->model == anypci_model) {
 190                         /* Wildcard board matches any supported PCI board. */
 191                         const struct pc236_board *foundboard;
 192
 193                         foundboard = pc236_find_pci_board(pci_dev);
 194                         if (foundboard == NULL)
 195                                 continue;
 196                         /* Replace wildcard board_ptr. */
 197                         dev->board_ptr = foundboard;
 198                 } else {
 199                         /* Match specific model name. */
 200                         if (pci_dev->device != thisboard->devid)
 201                                 continue;
 202                 }
 203                 return pci_dev;
 204         }
 205         dev_err(dev->class_dev,
 206                 "No supported board found! (req. bus %d, slot %d)\n",
 207                 bus, slot);
 208         return NULL;
 209 }
 210
 211 /*
 212  * This function checks and requests an I/O region, reporting an error
 213  * if there is a conflict.
 214  */
 215 static int pc236_request_region(struct comedi_device *dev, unsigned long from,
 216                                 unsigned long extent)
 217 {
 218         if (!from || !request_region(from, extent, PC236_DRIVER_NAME)) {
 219                 dev_err(dev->class_dev, "I/O port conflict (%#lx,%lu)!\n",
 220                        from, extent);
 221                 return -EIO;
 222         }
 223         return 0;
 224 }
 225
 226 /*
 227  * This function is called to mark the interrupt as disabled (no command
 228  * configured on subdevice 1) and to physically disable the interrupt
 229  * (not possible on the PC36AT, except by removing the IRQ jumper!).
 230  */
 231 static void pc236_intr_disable(struct comedi_device *dev)
 232 {
 233         const struct pc236_board *thisboard = comedi_board(dev);
 234         struct pc236_private *devpriv = dev->private;
 235         unsigned long flags;
 236
 237         spin_lock_irqsave(&dev->spinlock, flags);
 238         devpriv->enable_irq = 0;
 239         if (is_pci_board(thisboard))
 240                 outl(PCI236_INTR_DISABLE, devpriv->lcr_iobase + PLX9052_INTCSR);
 241         spin_unlock_irqrestore(&dev->spinlock, flags);
 242 }
 243
 244 /*
 245  * This function is called to mark the interrupt as enabled (a command
 246  * configured on subdevice 1) and to physically enable the interrupt
 247  * (not possible on the PC36AT, except by (re)connecting the IRQ jumper!).
 248  */
 249 static void pc236_intr_enable(struct comedi_device *dev)
 250 {
 251         const struct pc236_board *thisboard = comedi_board(dev);
 252         struct pc236_private *devpriv = dev->private;
 253         unsigned long flags;
 254
 255         spin_lock_irqsave(&dev->spinlock, flags);
 256         devpriv->enable_irq = 1;
 257         if (is_pci_board(thisboard))
 258                 outl(PCI236_INTR_ENABLE, devpriv->lcr_iobase + PLX9052_INTCSR);
 259         spin_unlock_irqrestore(&dev->spinlock, flags);
 260 }
 261
 262 /*
 263  * This function is called when an interrupt occurs to check whether
 264  * the interrupt has been marked as enabled and was generated by the
 265  * board.  If so, the function prepares the hardware for the next
 266  * interrupt.
 267  * Returns 0 if the interrupt should be ignored.
 268  */
 269 static int pc236_intr_check(struct comedi_device *dev)
 270 {
 271         const struct pc236_board *thisboard = comedi_board(dev);
 272         struct pc236_private *devpriv = dev->private;
 273         int retval = 0;
 274         unsigned long flags;
 275
 276         spin_lock_irqsave(&dev->spinlock, flags);
 277         if (devpriv->enable_irq) {
 278                 retval = 1;
 279                 if (is_pci_board(thisboard)) {
 280                         if ((inl(devpriv->lcr_iobase + PLX9052_INTCSR)
 281                              & PLX9052_INTCSR_LI1STAT_MASK)
 282                             == PLX9052_INTCSR_LI1STAT_INACTIVE) {
 283                                 retval = 0;
 284                         } else {
 285                                 /* Clear interrupt and keep it enabled. */
 286                                 outl(PCI236_INTR_ENABLE,
 287                                      devpriv->lcr_iobase + PLX9052_INTCSR);
 288                         }
 289                 }
 290         }
 291         spin_unlock_irqrestore(&dev->spinlock, flags);
 292
 293         return retval;
 294 }
 295
 296 /*
 297  * Input from subdevice 1.
 298  * Copied from the comedi_parport driver.
 299  */
 300 static int pc236_intr_insn(struct comedi_device *dev,
 301                            struct comedi_subdevice *s, struct comedi_insn *insn,
 302                            unsigned int *data)
 303 {
 304         data[1] = 0;
 305         return insn->n;
 306 }
 307
 308 /*
 309  * Subdevice 1 command test.
 310  * Copied from the comedi_parport driver.
 311  */
 312 static int pc236_intr_cmdtest(struct comedi_device *dev,
 313                               struct comedi_subdevice *s,
 314                               struct comedi_cmd *cmd)
 315 {
 316         int err = 0;
 317
 318         /* Step 1 : check if triggers are trivially valid */
 319
 320         err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
 321         err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_EXT);
 322         err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_FOLLOW);
 323         err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
 324         err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_NONE);
 325
 326         if (err)
 327                 return 1;
 328
 329         /* Step 2a : make sure trigger sources are unique */
 330         /* Step 2b : and mutually compatible */
 331
 332         if (err)
 333                 return 2;
 334
 335         /* Step 3: check it arguments are trivially valid */
 336
 337         err |= cfc_check_trigger_arg_is(&cmd->start_arg, 0);
 338         err |= cfc_check_trigger_arg_is(&cmd->scan_begin_arg, 0);
 339         err |= cfc_check_trigger_arg_is(&cmd->convert_arg, 0);
 340         err |= cfc_check_trigger_arg_is(&cmd->scan_end_arg, 1);
 341         err |= cfc_check_trigger_arg_is(&cmd->stop_arg, 0);
 342
 343         if (err)
 344                 return 3;
 345
 346         /* step 4: ignored */
 347
 348         if (err)
 349                 return 4;
 350
 351         return 0;
 352 }
 353
 354 /*
 355  * Subdevice 1 command.
 356  */
 357 static int pc236_intr_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
 358 {
 359         pc236_intr_enable(dev);
 360
 361         return 0;
 362 }
 363
 364 /*
 365  * Subdevice 1 cancel command.
 366  */
 367 static int pc236_intr_cancel(struct comedi_device *dev,
 368                              struct comedi_subdevice *s)
 369 {
 370         pc236_intr_disable(dev);
 371
 372         return 0;
 373 }
 374
 375 /*
 376  * Interrupt service routine.
 377  * Based on the comedi_parport driver.
 378  */
 379 static irqreturn_t pc236_interrupt(int irq, void *d)
 380 {
 381         struct comedi_device *dev = d;
 382         struct comedi_subdevice *s = &dev->subdevices[1];
 383         int handled;
 384
 385         handled = pc236_intr_check(dev);
 386         if (dev->attached && handled) {
 387                 comedi_buf_put(s->async, 0);
 388                 s->async->events |= COMEDI_CB_BLOCK | COMEDI_CB_EOS;
 389                 comedi_event(dev, s);
 390         }
 391         return IRQ_RETVAL(handled);
 392 }
 393
 394 static void pc236_report_attach(struct comedi_device *dev, unsigned int irq)
 395 {
 396         const struct pc236_board *thisboard = comedi_board(dev);
 397         struct pci_dev *pcidev = comedi_to_pci_dev(dev);
 398         char tmpbuf[60];
 399         int tmplen;
 400
 401         if (is_isa_board(thisboard))
 402                 tmplen = scnprintf(tmpbuf, sizeof(tmpbuf),
 403                                    "(base %#lx) ", dev->iobase);
 404         else if (is_pci_board(thisboard))
 405                 tmplen = scnprintf(tmpbuf, sizeof(tmpbuf),
 406                                    "(pci %s) ", pci_name(pcidev));
 407         else
 408                 tmplen = 0;
 409         if (irq)
 410                 tmplen += scnprintf(&tmpbuf[tmplen], sizeof(tmpbuf) - tmplen,
 411                                     "(irq %u%s) ", irq,
 412                                     (dev->irq ? "" : " UNAVAILABLE"));
 413         else
 414                 tmplen += scnprintf(&tmpbuf[tmplen], sizeof(tmpbuf) - tmplen,
 415                                     "(no irq) ");
 416         dev_info(dev->class_dev, "%s %sattached\n",
 417                  dev->board_name, tmpbuf);
 418 }
 419
 420 static int pc236_common_attach(struct comedi_device *dev, unsigned long iobase,
 421                                unsigned int irq, unsigned long req_irq_flags)
 422 {
 423         const struct pc236_board *thisboard = comedi_board(dev);
 424         struct comedi_subdevice *s;
 425         int ret;
 426
 427         dev->board_name = thisboard->name;
 428         dev->iobase = iobase;
 429
 430         ret = comedi_alloc_subdevices(dev, 2);
 431         if (ret)
 432                 return ret;
 433
 434         s = &dev->subdevices[0];
 435         /* digital i/o subdevice (8255) */
 436         ret = subdev_8255_init(dev, s, NULL, iobase);
 437         if (ret < 0) {
 438                 dev_err(dev->class_dev, "error! out of memory!\n");
 439                 return ret;
 440         }
 441         s = &dev->subdevices[1];
 442         dev->read_subdev = s;
 443         s->type = COMEDI_SUBD_UNUSED;
 444         pc236_intr_disable(dev);
 445         if (irq) {
 446                 if (request_irq(irq, pc236_interrupt, req_irq_flags,
 447                                 PC236_DRIVER_NAME, dev) >= 0) {
 448                         dev->irq = irq;
 449                         s->type = COMEDI_SUBD_DI;
 450                         s->subdev_flags = SDF_READABLE | SDF_CMD_READ;
 451                         s->n_chan = 1;
 452                         s->maxdata = 1;
 453                         s->range_table = &range_digital;
 454                         s->insn_bits = pc236_intr_insn;
 455                         s->do_cmdtest = pc236_intr_cmdtest;
 456                         s->do_cmd = pc236_intr_cmd;
 457                         s->cancel = pc236_intr_cancel;
 458                 }
 459         }
 460         pc236_report_attach(dev, irq);
 461         return 1;
 462 }
 463
 464 static int pc236_pci_common_attach(struct comedi_device *dev,
 465                                    struct pci_dev *pci_dev)
 466 {
 467         struct pc236_private *devpriv = dev->private;
 468         unsigned long iobase;
 469         int ret;
 470
 471         comedi_set_hw_dev(dev, &pci_dev->dev);
 472
 473         ret = comedi_pci_enable(pci_dev, PC236_DRIVER_NAME);
 474         if (ret < 0) {
 475                 dev_err(dev->class_dev,
 476                         "error! cannot enable PCI device and request regions!\n");
 477                 return ret;
 478         }
 479         devpriv->lcr_iobase = pci_resource_start(pci_dev, 1);
 480         iobase = pci_resource_start(pci_dev, 2);
 481         return pc236_common_attach(dev, iobase, pci_dev->irq, IRQF_SHARED);
 482 }
 483
 484 /*
 485  * Attach is called by the Comedi core to configure the driver
 486  * for a particular board.  If you specified a board_name array
 487  * in the driver structure, dev->board_ptr contains that
 488  * address.
 489  */
 490 static int pc236_attach(struct comedi_device *dev, struct comedi_devconfig *it)
 491 {
 492         const struct pc236_board *thisboard = comedi_board(dev);
 493         struct pc236_private *devpriv;
 494         int ret;
 495
 496         dev_info(dev->class_dev, PC236_DRIVER_NAME ": attach\n");
 497
 498         devpriv = kzalloc(sizeof(*devpriv), GFP_KERNEL);
 499         if (!devpriv)
 500                 return -ENOMEM;
 501         dev->private = devpriv;
 502
 503         /* Process options according to bus type. */
 504         if (is_isa_board(thisboard)) {
 505                 unsigned long iobase = it->options[0];
 506                 unsigned int irq = it->options[1];
 507                 ret = pc236_request_region(dev, iobase, PC236_IO_SIZE);
 508                 if (ret < 0)
 509                         return ret;
 510                 return pc236_common_attach(dev, iobase, irq, 0);
 511         } else if (is_pci_board(thisboard)) {
 512                 struct pci_dev *pci_dev;
 513
 514                 pci_dev = pc236_find_pci_dev(dev, it);
 515                 if (!pci_dev)
 516                         return -EIO;
 517                 return pc236_pci_common_attach(dev, pci_dev);
 518         } else {
 519                 dev_err(dev->class_dev, PC236_DRIVER_NAME
 520                         ": BUG! cannot determine board type!\n");
 521                 return -EINVAL;
 522         }
 523 }
 524
 525 /*
 526  * The auto_attach hook is called at PCI probe time via
 527  * comedi_pci_auto_config().  dev->board_ptr is NULL on entry.
 528  * There should be a board entry matching the supplied PCI device.
 529  */
 530 static int pc236_auto_attach(struct comedi_device *dev,
 531                                        unsigned long context_unused)
 532 {
 533         struct pci_dev *pci_dev = comedi_to_pci_dev(dev);
 534         struct pc236_private *devpriv;
 535
 536         if (!DO_PCI)
 537                 return -EINVAL;
 538
 539         dev_info(dev->class_dev, PC236_DRIVER_NAME ": attach pci %s\n",
 540                  pci_name(pci_dev));
 541
 542         devpriv = kzalloc(sizeof(*devpriv), GFP_KERNEL);
 543         if (!devpriv)
 544                 return -ENOMEM;
 545         dev->private = devpriv;
 546
 547         dev->board_ptr = pc236_find_pci_board(pci_dev);
 548         if (dev->board_ptr == NULL) {
 549                 dev_err(dev->class_dev, "BUG! cannot determine board type!\n");
 550                 return -EINVAL;
 551         }
 552         /*
 553          * Need to 'get' the PCI device to match the 'put' in pc236_detach().
 554          * TODO: Remove the pci_dev_get() and matching pci_dev_put() once
 555          * support for manual attachment of PCI devices via pc236_attach()
 556          * has been removed.
 557          */
 558         pci_dev_get(pci_dev);
 559         return pc236_pci_common_attach(dev, pci_dev);
 560 }
 561
 562 static void pc236_detach(struct comedi_device *dev)
 563 {
 564         const struct pc236_board *thisboard = comedi_board(dev);
 565
 566         if (!thisboard)
 567                 return;
 568         if (dev->iobase)
 569                 pc236_intr_disable(dev);
 570         if (dev->irq)
 571                 free_irq(dev->irq, dev);
 572         if (dev->subdevices)
 573                 subdev_8255_cleanup(dev, &dev->subdevices[0]);
 574         if (is_isa_board(thisboard)) {
 575                 if (dev->iobase)
 576                         release_region(dev->iobase, PC236_IO_SIZE);
 577         } else if (is_pci_board(thisboard)) {
 578                 struct pci_dev *pcidev = comedi_to_pci_dev(dev);
 579                 if (pcidev) {
 580                         if (dev->iobase)
 581                                 comedi_pci_disable(pcidev);
 582                         pci_dev_put(pcidev);
 583                 }
 584         }
 585 }
 586
 587 /*
 588  * The struct comedi_driver structure tells the Comedi core module
 589  * which functions to call to configure/deconfigure (attach/detach)
 590  * the board, and also about the kernel module that contains
 591  * the device code.
 592  */
 593 static struct comedi_driver amplc_pc236_driver = {
 594         .driver_name = PC236_DRIVER_NAME,
 595         .module = THIS_MODULE,
 596         .attach = pc236_attach,
 597         .auto_attach = pc236_auto_attach,
 598         .detach = pc236_detach,
 599         .board_name = &pc236_boards[0].name,
 600         .offset = sizeof(struct pc236_board),
 601         .num_names = ARRAY_SIZE(pc236_boards),
 602 };
 603
 604 #if DO_PCI
 605 static DEFINE_PCI_DEVICE_TABLE(pc236_pci_table) = {
 606         { PCI_DEVICE(PCI_VENDOR_ID_AMPLICON, PCI_DEVICE_ID_AMPLICON_PCI236) },
 607         {0}
 608 };
 609
 610 MODULE_DEVICE_TABLE(pci, pc236_pci_table);
 611
 612 static int amplc_pc236_pci_probe(struct pci_dev *dev,
 613                                            const struct pci_device_id *ent)
 614 {
 615         return comedi_pci_auto_config(dev, &amplc_pc236_driver);
 616 }
 617
 618 static struct pci_driver amplc_pc236_pci_driver = {
 619         .name = PC236_DRIVER_NAME,
 620         .id_table = pc236_pci_table,
 621         .probe = &amplc_pc236_pci_probe,
 622         .remove         = comedi_pci_auto_unconfig,
 623 };
 624
 625 module_comedi_pci_driver(amplc_pc236_driver, amplc_pc236_pci_driver);
 626 #else
 627 module_comedi_driver(amplc_pc236_driver);
 628 #endif
 629
 630 MODULE_AUTHOR("Comedi http://www.comedi.org");
 631 MODULE_DESCRIPTION("Comedi low-level driver");
 632 MODULE_LICENSE("GPL");