9e964950a560ed92d9f37599d6138fd9c1a360b6
[firefly-linux-kernel-4.4.55.git] / drivers / staging / comedi / drivers / skel.c
1 /*
2     comedi/drivers/skel.c
3     Skeleton code for a Comedi driver
4
5     COMEDI - Linux Control and Measurement Device Interface
6     Copyright (C) 2000 David A. Schleef <ds@schleef.org>
7
8     This program is free software; you can redistribute it and/or modify
9     it under the terms of the GNU General Public License as published by
10     the Free Software Foundation; either version 2 of the License, or
11     (at your option) any later version.
12
13     This program is distributed in the hope that it will be useful,
14     but WITHOUT ANY WARRANTY; without even the implied warranty of
15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16     GNU General Public License for more details.
17 */
18 /*
19 Driver: skel
20 Description: Skeleton driver, an example for driver writers
21 Devices:
22 Author: ds
23 Updated: Mon, 18 Mar 2002 15:34:01 -0800
24 Status: works
25
26 This driver is a documented example on how Comedi drivers are
27 written.
28
29 Configuration Options:
30   none
31 */
32
33 /*
34  * The previous block comment is used to automatically generate
35  * documentation in Comedi and Comedilib.  The fields:
36  *
37  *  Driver: the name of the driver
38  *  Description: a short phrase describing the driver.  Don't list boards.
39  *  Devices: a full list of the boards that attempt to be supported by
40  *    the driver.  Format is "(manufacturer) board name [comedi name]",
41  *    where comedi_name is the name that is used to configure the board.
42  *    See the comment near board_name: in the struct comedi_driver structure
43  *    below.  If (manufacturer) or [comedi name] is missing, the previous
44  *    value is used.
45  *  Author: you
46  *  Updated: date when the _documentation_ was last updated.  Use 'date -R'
47  *    to get a value for this.
48  *  Status: a one-word description of the status.  Valid values are:
49  *    works - driver works correctly on most boards supported, and
50  *      passes comedi_test.
51  *    unknown - unknown.  Usually put there by ds.
52  *    experimental - may not work in any particular release.  Author
53  *      probably wants assistance testing it.
54  *    bitrotten - driver has not been update in a long time, probably
55  *      doesn't work, and probably is missing support for significant
56  *      Comedi interface features.
57  *    untested - author probably wrote it "blind", and is believed to
58  *      work, but no confirmation.
59  *
60  * These headers should be followed by a blank line, and any comments
61  * you wish to say about the driver.  The comment area is the place
62  * to put any known bugs, limitations, unsupported features, supported
63  * command triggers, whether or not commands are supported on particular
64  * subdevices, etc.
65  *
66  * Somewhere in the comment should be information about configuration
67  * options that are used with comedi_config.
68  */
69
70 #include <linux/module.h>
71 #include <linux/pci.h>
72
73 #include "../comedidev.h"
74
75 #include "comedi_fc.h"
76
77 /* Imaginary registers for the imaginary board */
78
79 #define SKEL_SIZE 0
80
81 #define SKEL_START_AI_CONV      0
82 #define SKEL_AI_READ            0
83
84 /*
85  * Board descriptions for two imaginary boards.  Describing the
86  * boards in this way is optional, and completely driver-dependent.
87  * Some drivers use arrays such as this, other do not.
88  */
89 enum skel_boardid {
90         BOARD_SKEL100,
91         BOARD_SKEL200,
92 };
93
94 struct skel_board {
95         const char *name;
96         int ai_chans;
97         int ai_bits;
98         int have_dio;
99 };
100
101 static const struct skel_board skel_boards[] = {
102         [BOARD_SKEL100] = {
103                 .name           = "skel-100",
104                 .ai_chans       = 16,
105                 .ai_bits        = 12,
106                 .have_dio       = 1,
107         },
108         [BOARD_SKEL200] = {
109                 .name           = "skel-200",
110                 .ai_chans       = 8,
111                 .ai_bits        = 16,
112         },
113 };
114
115 /* this structure is for data unique to this hardware driver.  If
116    several hardware drivers keep similar information in this structure,
117    feel free to suggest moving the variable to the struct comedi_device struct.
118  */
119 struct skel_private {
120
121         int data;
122
123         /* Used for AO readback */
124         unsigned int ao_readback[2];
125 };
126
127 /* This function doesn't require a particular form, this is just
128  * what happens to be used in some of the drivers.  It should
129  * convert ns nanoseconds to a counter value suitable for programming
130  * the device.  Also, it should adjust ns so that it cooresponds to
131  * the actual time that the device will use. */
132 static int skel_ns_to_timer(unsigned int *ns, int round)
133 {
134         /* trivial timer */
135         /* if your timing is done through two cascaded timers, the
136          * i8253_cascade_ns_to_timer() function in 8253.h can be
137          * very helpful.  There are also i8254_load() and i8254_mm_load()
138          * which can be used to load values into the ubiquitous 8254 counters
139          */
140
141         return *ns;
142 }
143
144 /*
145  * "instructions" read/write data in "one-shot" or "software-triggered"
146  * mode.
147  */
148 static int skel_ai_rinsn(struct comedi_device *dev, struct comedi_subdevice *s,
149                          struct comedi_insn *insn, unsigned int *data)
150 {
151         const struct skel_board *thisboard = comedi_board(dev);
152         int n, i;
153         unsigned int d;
154         unsigned int status;
155
156         /* a typical programming sequence */
157
158         /* write channel to multiplexer */
159         /* outw(chan,dev->iobase + SKEL_MUX); */
160
161         /* don't wait for mux to settle */
162
163         /* convert n samples */
164         for (n = 0; n < insn->n; n++) {
165                 /* trigger conversion */
166                 /* outw(0,dev->iobase + SKEL_CONVERT); */
167
168 #define TIMEOUT 100
169                 /* wait for conversion to end */
170                 for (i = 0; i < TIMEOUT; i++) {
171                         status = 1;
172                         /* status = inb(dev->iobase + SKEL_STATUS); */
173                         if (status)
174                                 break;
175                 }
176                 if (i == TIMEOUT) {
177                         dev_warn(dev->class_dev, "ai timeout\n");
178                         return -ETIMEDOUT;
179                 }
180
181                 /* read data */
182                 /* d = inw(dev->iobase + SKEL_AI_DATA); */
183                 d = 0;
184
185                 /* mangle the data as necessary */
186                 d ^= 1 << (thisboard->ai_bits - 1);
187
188                 data[n] = d;
189         }
190
191         /* return the number of samples read/written */
192         return n;
193 }
194
195 /*
196  * cmdtest tests a particular command to see if it is valid.
197  * Using the cmdtest ioctl, a user can create a valid cmd
198  * and then have it executes by the cmd ioctl.
199  *
200  * cmdtest returns 1,2,3,4 or 0, depending on which tests
201  * the command passes.
202  */
203 static int skel_ai_cmdtest(struct comedi_device *dev,
204                            struct comedi_subdevice *s,
205                            struct comedi_cmd *cmd)
206 {
207         int err = 0;
208         int tmp;
209
210         /* Step 1 : check if triggers are trivially valid */
211
212         err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
213         err |= cfc_check_trigger_src(&cmd->scan_begin_src,
214                                         TRIG_TIMER | TRIG_EXT);
215         err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_TIMER | TRIG_EXT);
216         err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
217         err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
218
219         if (err)
220                 return 1;
221
222         /* Step 2a : make sure trigger sources are unique */
223
224         err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
225         err |= cfc_check_trigger_is_unique(cmd->convert_src);
226         err |= cfc_check_trigger_is_unique(cmd->stop_src);
227
228         /* Step 2b : and mutually compatible */
229
230         if (err)
231                 return 2;
232
233         /* Step 3: check if arguments are trivially valid */
234
235         err |= cfc_check_trigger_arg_is(&cmd->start_arg, 0);
236
237 #define MAX_SPEED       10000   /* in nanoseconds */
238 #define MIN_SPEED       1000000000      /* in nanoseconds */
239
240         if (cmd->scan_begin_src == TRIG_TIMER) {
241                 err |= cfc_check_trigger_arg_min(&cmd->scan_begin_arg,
242                                                  MAX_SPEED);
243                 err |= cfc_check_trigger_arg_max(&cmd->scan_begin_arg,
244                                                  MIN_SPEED);
245         } else {
246                 /* external trigger */
247                 /* should be level/edge, hi/lo specification here */
248                 /* should specify multiple external triggers */
249                 err |= cfc_check_trigger_arg_max(&cmd->scan_begin_arg, 9);
250         }
251
252         if (cmd->convert_src == TRIG_TIMER) {
253                 err |= cfc_check_trigger_arg_min(&cmd->convert_arg, MAX_SPEED);
254                 err |= cfc_check_trigger_arg_max(&cmd->convert_arg, MIN_SPEED);
255         } else {
256                 /* external trigger */
257                 /* see above */
258                 err |= cfc_check_trigger_arg_max(&cmd->scan_begin_arg, 9);
259         }
260
261         err |= cfc_check_trigger_arg_is(&cmd->scan_end_arg, cmd->chanlist_len);
262
263         if (cmd->stop_src == TRIG_COUNT)
264                 err |= cfc_check_trigger_arg_max(&cmd->stop_arg, 0x00ffffff);
265         else    /* TRIG_NONE */
266                 err |= cfc_check_trigger_arg_is(&cmd->stop_arg, 0);
267
268         if (err)
269                 return 3;
270
271         /* step 4: fix up any arguments */
272
273         if (cmd->scan_begin_src == TRIG_TIMER) {
274                 tmp = cmd->scan_begin_arg;
275                 skel_ns_to_timer(&cmd->scan_begin_arg,
276                                  cmd->flags & TRIG_ROUND_MASK);
277                 if (tmp != cmd->scan_begin_arg)
278                         err++;
279         }
280         if (cmd->convert_src == TRIG_TIMER) {
281                 tmp = cmd->convert_arg;
282                 skel_ns_to_timer(&cmd->convert_arg,
283                                  cmd->flags & TRIG_ROUND_MASK);
284                 if (tmp != cmd->convert_arg)
285                         err++;
286                 if (cmd->scan_begin_src == TRIG_TIMER &&
287                     cmd->scan_begin_arg <
288                     cmd->convert_arg * cmd->scan_end_arg) {
289                         cmd->scan_begin_arg =
290                             cmd->convert_arg * cmd->scan_end_arg;
291                         err++;
292                 }
293         }
294
295         if (err)
296                 return 4;
297
298         return 0;
299 }
300
301 static int skel_ao_winsn(struct comedi_device *dev, struct comedi_subdevice *s,
302                          struct comedi_insn *insn, unsigned int *data)
303 {
304         struct skel_private *devpriv = dev->private;
305         int i;
306         int chan = CR_CHAN(insn->chanspec);
307
308         /* Writing a list of values to an AO channel is probably not
309          * very useful, but that's how the interface is defined. */
310         for (i = 0; i < insn->n; i++) {
311                 /* a typical programming sequence */
312                 /* outw(data[i],dev->iobase + SKEL_DA0 + chan); */
313                 devpriv->ao_readback[chan] = data[i];
314         }
315
316         /* return the number of samples read/written */
317         return i;
318 }
319
320 /* AO subdevices should have a read insn as well as a write insn.
321  * Usually this means copying a value stored in devpriv. */
322 static int skel_ao_rinsn(struct comedi_device *dev, struct comedi_subdevice *s,
323                          struct comedi_insn *insn, unsigned int *data)
324 {
325         struct skel_private *devpriv = dev->private;
326         int i;
327         int chan = CR_CHAN(insn->chanspec);
328
329         for (i = 0; i < insn->n; i++)
330                 data[i] = devpriv->ao_readback[chan];
331
332         return i;
333 }
334
335 /* DIO devices are slightly special.  Although it is possible to
336  * implement the insn_read/insn_write interface, it is much more
337  * useful to applications if you implement the insn_bits interface.
338  * This allows packed reading/writing of the DIO channels.  The
339  * comedi core can convert between insn_bits and insn_read/write */
340 static int skel_dio_insn_bits(struct comedi_device *dev,
341                               struct comedi_subdevice *s,
342                               struct comedi_insn *insn, unsigned int *data)
343 {
344         /* The insn data is a mask in data[0] and the new data
345          * in data[1], each channel cooresponding to a bit. */
346         if (data[0]) {
347                 s->state &= ~data[0];
348                 s->state |= data[0] & data[1];
349                 /* Write out the new digital output lines */
350                 /* outw(s->state,dev->iobase + SKEL_DIO); */
351         }
352
353         /* on return, data[1] contains the value of the digital
354          * input and output lines. */
355         /* data[1]=inw(dev->iobase + SKEL_DIO); */
356         /* or we could just return the software copy of the output values if
357          * it was a purely digital output subdevice */
358         /* data[1]=s->state; */
359
360         return insn->n;
361 }
362
363 static int skel_dio_insn_config(struct comedi_device *dev,
364                                 struct comedi_subdevice *s,
365                                 struct comedi_insn *insn,
366                                 unsigned int *data)
367 {
368         int ret;
369
370         /*
371          * The input or output configuration of each digital line is
372          * configured by special insn_config instructions.
373          *
374          * chanspec contains the channel to be changed
375          * data[0] contains the instruction to perform on the channel
376          *
377          * Normally the core provided comedi_dio_insn_config() function
378          * can be used to handle the boilerplpate.
379          */
380         ret = comedi_dio_insn_config(dev, s, insn, data, 0);
381         if (ret)
382                 return ret;
383
384         /* Update the hardware to the new configuration */
385         /* outw(s->io_bits, dev->iobase + SKEL_DIO_CONFIG); */
386
387         return insn->n;
388 }
389
390 /*
391  * Handle common part of skel_attach() and skel_auto_attach().
392  */
393 static int skel_common_attach(struct comedi_device *dev)
394 {
395         const struct skel_board *thisboard = comedi_board(dev);
396         struct comedi_subdevice *s;
397         int ret;
398
399         ret = comedi_alloc_subdevices(dev, 3);
400         if (ret)
401                 return ret;
402
403         s = &dev->subdevices[0];
404         /* dev->read_subdev=s; */
405         /* analog input subdevice */
406         s->type = COMEDI_SUBD_AI;
407         /* we support single-ended (ground) and differential */
408         s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_DIFF;
409         s->n_chan = thisboard->ai_chans;
410         s->maxdata = (1 << thisboard->ai_bits) - 1;
411         s->range_table = &range_bipolar10;
412         s->len_chanlist = 16;   /* This is the maximum chanlist length that
413                                    the board can handle */
414         s->insn_read = skel_ai_rinsn;
415 /*
416 *       s->subdev_flags |= SDF_CMD_READ;
417 *       s->do_cmd = skel_ai_cmd;
418 */
419         s->do_cmdtest = skel_ai_cmdtest;
420
421         s = &dev->subdevices[1];
422         /* analog output subdevice */
423         s->type = COMEDI_SUBD_AO;
424         s->subdev_flags = SDF_WRITABLE;
425         s->n_chan = 1;
426         s->maxdata = 0xffff;
427         s->range_table = &range_bipolar5;
428         s->insn_write = skel_ao_winsn;
429         s->insn_read = skel_ao_rinsn;
430
431         s = &dev->subdevices[2];
432         /* digital i/o subdevice */
433         if (thisboard->have_dio) {
434                 s->type = COMEDI_SUBD_DIO;
435                 s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
436                 s->n_chan = 16;
437                 s->maxdata = 1;
438                 s->range_table = &range_digital;
439                 s->insn_bits = skel_dio_insn_bits;
440                 s->insn_config = skel_dio_insn_config;
441         } else {
442                 s->type = COMEDI_SUBD_UNUSED;
443         }
444
445         dev_info(dev->class_dev, "skel: attached\n");
446
447         return 0;
448 }
449
450 /*
451  * _attach is called by the Comedi core to configure the driver
452  * for a particular board in response to the COMEDI_DEVCONFIG ioctl for
453  * a matching board or driver name.  If you specified a board_name array
454  * in the driver structure, dev->board_ptr contains that address.
455  *
456  * Drivers that handle only PCI or USB devices do not usually support
457  * manual attachment of those devices via the COMEDI_DEVCONFIG ioctl, so
458  * those drivers do not have an _attach function; they just have an
459  * _auto_attach function instead.  (See skel_auto_attach() for an example
460  * of such a function.)
461  */
462 static int skel_attach(struct comedi_device *dev, struct comedi_devconfig *it)
463 {
464         const struct skel_board *thisboard;
465         struct skel_private *devpriv;
466
467 /*
468  * If you can probe the device to determine what device in a series
469  * it is, this is the place to do it.  Otherwise, dev->board_ptr
470  * should already be initialized.
471  */
472         /* dev->board_ptr = skel_probe(dev, it); */
473
474         thisboard = comedi_board(dev);
475
476         /*
477          * The dev->board_name is initialized by the comedi core before
478          * calling the (*attach) function. It can be optionally set by
479          * the driver if additional probing has been done.
480          */
481         /* dev->board_name = thisboard->name; */
482
483         /* Allocate the private data */
484         devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
485         if (!devpriv)
486                 return -ENOMEM;
487
488 /*
489  * Supported boards are usually either auto-attached via the
490  * Comedi driver's _auto_attach routine, or manually attached via the
491  * Comedi driver's _attach routine.  In most cases, attempts to
492  * manual attach boards that are usually auto-attached should be
493  * rejected by this function.
494  */
495 /*
496  *      if (thisboard->bustype == pci_bustype) {
497  *              dev_err(dev->class_dev,
498  *                      "Manual attachment of PCI board '%s' not supported\n",
499  *                      thisboard->name);
500  *      }
501  */
502
503 /*
504  * For ISA boards, get the i/o base address from it->options[],
505  * request the i/o region and set dev->iobase * from it->options[].
506  * If using interrupts, get the IRQ number from it->options[].
507  */
508
509         /*
510          * Call a common function to handle the remaining things to do for
511          * attaching ISA or PCI boards.  (Extra parameters could be added
512          * to pass additional information such as IRQ number.)
513          */
514         return skel_common_attach(dev);
515 }
516
517 /*
518  * _auto_attach is called via comedi_pci_auto_config() (or
519  * comedi_usb_auto_config(), etc.) to handle devices that can be attached
520  * to the Comedi core automatically without the COMEDI_DEVCONFIG ioctl.
521  *
522  * The context parameter is driver dependent.
523  */
524 static int skel_auto_attach(struct comedi_device *dev,
525                             unsigned long context)
526 {
527         struct pci_dev *pcidev = comedi_to_pci_dev(dev);
528         const struct skel_board *thisboard = NULL;
529         struct skel_private *devpriv;
530         int ret;
531
532         /* Hack to allow unused code to be optimized out. */
533         if (!IS_ENABLED(CONFIG_COMEDI_PCI_DRIVERS))
534                 return -EINVAL;
535
536         /*
537          * In this example, the _auto_attach is for a PCI device.
538          *
539          * The 'context' passed to this function is the id->driver_data
540          * associated with the PCI device found in the id_table during
541          * the modprobe. This 'context' is the index of the entry in
542          * skel_boards[i] that contains the boardinfo for the PCI device.
543          */
544         if (context < ARRAY_SIZE(skel_boards))
545                 thisboard = &skel_boards[context];
546         if (!thisboard)
547                 return -ENODEV;
548
549         /*
550          * Point the struct comedi_device to the matching board info
551          * and set the board name.
552          */
553         dev->board_ptr = thisboard;
554         dev->board_name = thisboard->name;
555
556         /* Allocate the private data */
557         devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
558         if (!devpriv)
559                 return -ENOMEM;
560
561         /* Enable the PCI device. */
562         ret = comedi_pci_enable(dev);
563         if (ret)
564                 return ret;
565
566         /*
567          * Record the fact that the PCI device is enabled so that it can
568          * be disabled during _detach().
569          *
570          * For this example driver, we assume PCI BAR 0 is the main I/O
571          * region for the board registers and use dev->iobase to hold the
572          * I/O base address and to indicate that the PCI device has been
573          * enabled.
574          *
575          * (For boards with memory-mapped registers, dev->iobase is not
576          * usually needed for register access, so can just be set to 1
577          * to indicate that the PCI device has been enabled.)
578          */
579         dev->iobase = pci_resource_start(pcidev, 0);
580
581         /*
582          * Call a common function to handle the remaining things to do for
583          * attaching ISA or PCI boards.  (Extra parameters could be added
584          * to pass additional information such as IRQ number.)
585          */
586         return skel_common_attach(dev);
587 }
588
589 /*
590  * _detach is called to deconfigure a device.  It should deallocate
591  * resources.
592  * This function is also called when _attach() fails, so it should be
593  * careful not to release resources that were not necessarily
594  * allocated by _attach().  dev->private and dev->subdevices are
595  * deallocated automatically by the core.
596  */
597 static void skel_detach(struct comedi_device *dev)
598 {
599         const struct skel_board *thisboard = comedi_board(dev);
600         struct skel_private *devpriv = dev->private;
601
602         if (!thisboard || !devpriv)
603                 return;
604
605 /*
606  * Do common stuff such as freeing IRQ, unmapping remapped memory
607  * regions, etc., being careful to check that the stuff is valid given
608  * that _detach() is called even when _attach() or _auto_attach() return
609  * an error.
610  */
611
612         if (IS_ENABLED(CONFIG_COMEDI_PCI_DRIVERS) /* &&
613             thisboard->bustype == pci_bustype */) {
614                 /*
615                  * PCI board
616                  *
617                  * If PCI device enabled by _auto_attach() (or _attach()),
618                  * disable it here.
619                  */
620                 comedi_pci_disable(dev);
621         } else {
622                 /*
623                  * ISA board
624                  *
625                  * Release the first I/O region requested during the
626                  * _attach(). This is safe to call even if the request
627                  * failed. If any additional I/O regions are requested
628                  * they need to be released by the driver.
629                  */
630                 comedi_legacy_detach(dev);
631         }
632 }
633
634 /*
635  * The struct comedi_driver structure tells the Comedi core module
636  * which functions to call to configure/deconfigure (attach/detach)
637  * the board, and also about the kernel module that contains
638  * the device code.
639  */
640 static struct comedi_driver skel_driver = {
641         .driver_name = "dummy",
642         .module = THIS_MODULE,
643         .attach = skel_attach,
644         .auto_attach = skel_auto_attach,
645         .detach = skel_detach,
646 /* It is not necessary to implement the following members if you are
647  * writing a driver for a ISA PnP or PCI card */
648         /* Most drivers will support multiple types of boards by
649          * having an array of board structures.  These were defined
650          * in skel_boards[] above.  Note that the element 'name'
651          * was first in the structure -- Comedi uses this fact to
652          * extract the name of the board without knowing any details
653          * about the structure except for its length.
654          * When a device is attached (by comedi_config), the name
655          * of the device is given to Comedi, and Comedi tries to
656          * match it by going through the list of board names.  If
657          * there is a match, the address of the pointer is put
658          * into dev->board_ptr and driver->attach() is called.
659          *
660          * Note that these are not necessary if you can determine
661          * the type of board in software.  ISA PnP, PCI, and PCMCIA
662          * devices are such boards.
663          */
664         .board_name = &skel_boards[0].name,
665         .offset = sizeof(struct skel_board),
666         .num_names = ARRAY_SIZE(skel_boards),
667 };
668
669 #ifdef CONFIG_COMEDI_PCI_DRIVERS
670
671 static int skel_pci_probe(struct pci_dev *dev,
672                           const struct pci_device_id *id)
673 {
674         return comedi_pci_auto_config(dev, &skel_driver, id->driver_data);
675 }
676
677 /*
678  * Please add your PCI vendor ID to comedidev.h, and it will
679  * be forwarded upstream.
680  */
681 #define PCI_VENDOR_ID_SKEL      0xdafe
682
683 /*
684  * This is used by modprobe to translate PCI IDs to drivers.
685  * Should only be used for PCI and ISA-PnP devices
686  */
687 static DEFINE_PCI_DEVICE_TABLE(skel_pci_table) = {
688         { PCI_VDEVICE(SKEL, 0x0100), BOARD_SKEL100 },
689         { PCI_VDEVICE(SKEL, 0x0200), BOARD_SKEL200 },
690         { 0 }
691 };
692 MODULE_DEVICE_TABLE(pci, skel_pci_table);
693
694 static struct pci_driver skel_pci_driver = {
695         .name           = "dummy",
696         .id_table       = skel_pci_table,
697         .probe          = skel_pci_probe,
698         .remove         = comedi_pci_auto_unconfig,
699 };
700 module_comedi_pci_driver(skel_driver, skel_pci_driver);
701 #else
702 module_comedi_driver(skel_driver);
703 #endif
704
705 MODULE_AUTHOR("Comedi http://www.comedi.org");
706 MODULE_DESCRIPTION("Comedi low-level driver");
707 MODULE_LICENSE("GPL");