1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#define _GNU_SOURCE
25
26#define __NO_VERSION__
27#include "comedi_fops.h"
28#include <linux/device.h>
29#include <linux/module.h>
30#include <linux/pci.h>
31#include <linux/usb.h>
32#include <linux/errno.h>
33#include <linux/kernel.h>
34#include <linux/sched.h>
35#include <linux/fcntl.h>
36#include <linux/delay.h>
37#include <linux/ioport.h>
38#include <linux/mm.h>
39#include <linux/slab.h>
40#include "comedidev.h"
41#include "wrapper.h"
42#include <linux/highmem.h>
43#include <linux/vmalloc.h>
44#include <linux/cdev.h>
45#include <linux/dma-mapping.h>
46
47#include <asm/io.h>
48#include <asm/system.h>
49
50static int postconfig(struct comedi_device *dev);
51static int insn_rw_emulate_bits(struct comedi_device *dev,
52 struct comedi_subdevice *s,
53 struct comedi_insn *insn, unsigned int *data);
54static void *comedi_recognize(struct comedi_driver *driv, const char *name);
55static void comedi_report_boards(struct comedi_driver *driv);
56static int poll_invalid(struct comedi_device *dev, struct comedi_subdevice *s);
57int comedi_buf_alloc(struct comedi_device *dev, struct comedi_subdevice *s,
58 unsigned long new_size);
59
60struct comedi_driver *comedi_drivers;
61
62int comedi_modprobe(int minor)
63{
64 return -EINVAL;
65}
66
67static void cleanup_device(struct comedi_device *dev)
68{
69 int i;
70 struct comedi_subdevice *s;
71
72 if (dev->subdevices) {
73 for (i = 0; i < dev->n_subdevices; i++) {
74 s = dev->subdevices + i;
75 comedi_free_subdevice_minor(s);
76 if (s->async) {
77 comedi_buf_alloc(dev, s, 0);
78 kfree(s->async);
79 }
80 }
81 kfree(dev->subdevices);
82 dev->subdevices = NULL;
83 dev->n_subdevices = 0;
84 }
85 kfree(dev->private);
86 dev->private = NULL;
87 dev->driver = 0;
88 dev->board_name = NULL;
89 dev->board_ptr = NULL;
90 dev->iobase = 0;
91 dev->irq = 0;
92 dev->read_subdev = NULL;
93 dev->write_subdev = NULL;
94 dev->open = NULL;
95 dev->close = NULL;
96 comedi_set_hw_dev(dev, NULL);
97}
98
99static void __comedi_device_detach(struct comedi_device *dev)
100{
101 dev->attached = 0;
102 if (dev->driver) {
103 dev->driver->detach(dev);
104 } else {
105 printk("BUG: dev->driver=NULL in comedi_device_detach()\n");
106 }
107 cleanup_device(dev);
108}
109
110void comedi_device_detach(struct comedi_device *dev)
111{
112 if (!dev->attached)
113 return;
114 __comedi_device_detach(dev);
115}
116
117int comedi_device_attach(struct comedi_device *dev, struct comedi_devconfig *it)
118{
119 struct comedi_driver *driv;
120 int ret;
121
122 if (dev->attached)
123 return -EBUSY;
124
125 for (driv = comedi_drivers; driv; driv = driv->next) {
126 if (!try_module_get(driv->module)) {
127 printk
128 ("comedi: failed to increment module count, skipping\n");
129 continue;
130 }
131 if (driv->num_names) {
132 dev->board_ptr = comedi_recognize(driv, it->board_name);
133 if (dev->board_ptr == NULL) {
134 module_put(driv->module);
135 continue;
136 }
137 } else {
138 if (strcmp(driv->driver_name, it->board_name)) {
139 module_put(driv->module);
140 continue;
141 }
142 }
143
144 dev->driver = driv;
145 ret = driv->attach(dev, it);
146 if (ret < 0) {
147 module_put(dev->driver->module);
148 __comedi_device_detach(dev);
149 return ret;
150 }
151 goto attached;
152 }
153
154
155
156 for (driv = comedi_drivers; driv; driv = driv->next) {
157 if (!try_module_get(driv->module)) {
158 printk("comedi: failed to increment module count\n");
159 continue;
160 }
161 comedi_report_boards(driv);
162 module_put(driv->module);
163 }
164 return -EIO;
165
166attached:
167
168 ret = postconfig(dev);
169 module_put(dev->driver->module);
170 if (ret < 0) {
171 __comedi_device_detach(dev);
172 return ret;
173 }
174
175 if (!dev->board_name) {
176 printk("BUG: dev->board_name=<%p>\n", dev->board_name);
177 dev->board_name = "BUG";
178 }
179 smp_wmb();
180 dev->attached = 1;
181
182 return 0;
183}
184
185int comedi_driver_register(struct comedi_driver *driver)
186{
187 driver->next = comedi_drivers;
188 comedi_drivers = driver;
189
190 return 0;
191}
192
193int comedi_driver_unregister(struct comedi_driver *driver)
194{
195 struct comedi_driver *prev;
196 int i;
197
198
199 for (i = 0; i < COMEDI_NUM_BOARD_MINORS; i++) {
200 struct comedi_device_file_info *dev_file_info =
201 comedi_get_device_file_info(i);
202 struct comedi_device *dev;
203
204 if (dev_file_info == NULL)
205 continue;
206 dev = dev_file_info->device;
207
208 mutex_lock(&dev->mutex);
209 if (dev->attached && dev->driver == driver) {
210 if (dev->use_count)
211 printk
212 ("BUG! detaching device with use_count=%d\n",
213 dev->use_count);
214 comedi_device_detach(dev);
215 }
216 mutex_unlock(&dev->mutex);
217 }
218
219 if (comedi_drivers == driver) {
220 comedi_drivers = driver->next;
221 return 0;
222 }
223
224 for (prev = comedi_drivers; prev->next; prev = prev->next) {
225 if (prev->next == driver) {
226 prev->next = driver->next;
227 return 0;
228 }
229 }
230 return -EINVAL;
231}
232
233static int postconfig(struct comedi_device *dev)
234{
235 int i;
236 struct comedi_subdevice *s;
237 struct comedi_async *async = NULL;
238 int ret;
239
240 for (i = 0; i < dev->n_subdevices; i++) {
241 s = dev->subdevices + i;
242
243 if (s->type == COMEDI_SUBD_UNUSED)
244 continue;
245
246 if (s->len_chanlist == 0)
247 s->len_chanlist = 1;
248
249 if (s->do_cmd) {
250 BUG_ON((s->subdev_flags & (SDF_CMD_READ |
251 SDF_CMD_WRITE)) == 0);
252 BUG_ON(!s->do_cmdtest);
253
254 async =
255 kzalloc(sizeof(struct comedi_async), GFP_KERNEL);
256 if (async == NULL) {
257 printk("failed to allocate async struct\n");
258 return -ENOMEM;
259 }
260 init_waitqueue_head(&async->wait_head);
261 async->subdevice = s;
262 s->async = async;
263
264#define DEFAULT_BUF_MAXSIZE (64*1024)
265#define DEFAULT_BUF_SIZE (64*1024)
266
267 async->max_bufsize = DEFAULT_BUF_MAXSIZE;
268
269 async->prealloc_buf = NULL;
270 async->prealloc_bufsz = 0;
271 if (comedi_buf_alloc(dev, s, DEFAULT_BUF_SIZE) < 0) {
272 printk("Buffer allocation failed\n");
273 return -ENOMEM;
274 }
275 if (s->buf_change) {
276 ret = s->buf_change(dev, s, DEFAULT_BUF_SIZE);
277 if (ret < 0)
278 return ret;
279 }
280 comedi_alloc_subdevice_minor(dev, s);
281 }
282
283 if (!s->range_table && !s->range_table_list)
284 s->range_table = &range_unknown;
285
286 if (!s->insn_read && s->insn_bits)
287 s->insn_read = insn_rw_emulate_bits;
288 if (!s->insn_write && s->insn_bits)
289 s->insn_write = insn_rw_emulate_bits;
290
291 if (!s->insn_read)
292 s->insn_read = insn_inval;
293 if (!s->insn_write)
294 s->insn_write = insn_inval;
295 if (!s->insn_bits)
296 s->insn_bits = insn_inval;
297 if (!s->insn_config)
298 s->insn_config = insn_inval;
299
300 if (!s->poll)
301 s->poll = poll_invalid;
302 }
303
304 return 0;
305}
306
307
308void *comedi_recognize(struct comedi_driver *driv, const char *name)
309{
310 unsigned i;
311 const char *const *name_ptr = driv->board_name;
312 for (i = 0; i < driv->num_names; i++) {
313 if (strcmp(*name_ptr, name) == 0)
314 return (void *)name_ptr;
315 name_ptr =
316 (const char *const *)((const char *)name_ptr +
317 driv->offset);
318 }
319
320 return NULL;
321}
322
323void comedi_report_boards(struct comedi_driver *driv)
324{
325 unsigned int i;
326 const char *const *name_ptr;
327
328 printk("comedi: valid board names for %s driver are:\n",
329 driv->driver_name);
330
331 name_ptr = driv->board_name;
332 for (i = 0; i < driv->num_names; i++) {
333 printk(" %s\n", *name_ptr);
334 name_ptr = (const char **)((char *)name_ptr + driv->offset);
335 }
336
337 if (driv->num_names == 0)
338 printk(" %s\n", driv->driver_name);
339}
340
341static int poll_invalid(struct comedi_device *dev, struct comedi_subdevice *s)
342{
343 return -EINVAL;
344}
345
346int insn_inval(struct comedi_device *dev, struct comedi_subdevice *s,
347 struct comedi_insn *insn, unsigned int *data)
348{
349 return -EINVAL;
350}
351
352static int insn_rw_emulate_bits(struct comedi_device *dev,
353 struct comedi_subdevice *s,
354 struct comedi_insn *insn, unsigned int *data)
355{
356 struct comedi_insn new_insn;
357 int ret;
358 static const unsigned channels_per_bitfield = 32;
359
360 unsigned chan = CR_CHAN(insn->chanspec);
361 const unsigned base_bitfield_channel =
362 (chan < channels_per_bitfield) ? 0 : chan;
363 unsigned int new_data[2];
364 memset(new_data, 0, sizeof(new_data));
365 memset(&new_insn, 0, sizeof(new_insn));
366 new_insn.insn = INSN_BITS;
367 new_insn.chanspec = base_bitfield_channel;
368 new_insn.n = 2;
369 new_insn.data = new_data;
370 new_insn.subdev = insn->subdev;
371
372 if (insn->insn == INSN_WRITE) {
373 if (!(s->subdev_flags & SDF_WRITABLE))
374 return -EINVAL;
375 new_data[0] = 1 << (chan - base_bitfield_channel);
376 new_data[1] = data[0] ? (1 << (chan - base_bitfield_channel)) : 0;
377 }
378
379 ret = s->insn_bits(dev, s, &new_insn, new_data);
380 if (ret < 0)
381 return ret;
382
383 if (insn->insn == INSN_READ) {
384 data[0] = (new_data[1] >> (chan - base_bitfield_channel)) & 1;
385 }
386
387 return 1;
388}
389
390static inline unsigned long uvirt_to_kva(pgd_t * pgd, unsigned long adr)
391{
392 unsigned long ret = 0UL;
393 pmd_t *pmd;
394 pte_t *ptep, pte;
395 pud_t *pud;
396
397 if (!pgd_none(*pgd)) {
398 pud = pud_offset(pgd, adr);
399 pmd = pmd_offset(pud, adr);
400 if (!pmd_none(*pmd)) {
401 ptep = pte_offset_kernel(pmd, adr);
402 pte = *ptep;
403 if (pte_present(pte)) {
404 ret = (unsigned long)
405 page_address(pte_page(pte));
406 ret |= (adr & (PAGE_SIZE - 1));
407 }
408 }
409 }
410 return ret;
411}
412
413static inline unsigned long kvirt_to_kva(unsigned long adr)
414{
415 unsigned long va, kva;
416
417 va = adr;
418 kva = uvirt_to_kva(pgd_offset_k(va), va);
419
420 return kva;
421}
422
423int comedi_buf_alloc(struct comedi_device *dev, struct comedi_subdevice *s,
424 unsigned long new_size)
425{
426 struct comedi_async *async = s->async;
427
428
429 new_size = (new_size + PAGE_SIZE - 1) & PAGE_MASK;
430
431
432 if (async->prealloc_buf && async->prealloc_bufsz == new_size) {
433 return 0;
434 }
435
436 if (async->prealloc_buf) {
437 vunmap(async->prealloc_buf);
438 async->prealloc_buf = NULL;
439 async->prealloc_bufsz = 0;
440 }
441 if (async->buf_page_list) {
442 unsigned i;
443 for (i = 0; i < async->n_buf_pages; ++i) {
444 if (async->buf_page_list[i].virt_addr) {
445 mem_map_unreserve(virt_to_page
446 (async->buf_page_list[i].
447 virt_addr));
448 if (s->async_dma_dir != DMA_NONE) {
449 dma_free_coherent(dev->hw_dev,
450 PAGE_SIZE,
451 async->
452 buf_page_list
453 [i].virt_addr,
454 async->
455 buf_page_list
456 [i].dma_addr);
457 } else {
458 free_page((unsigned long)
459 async->buf_page_list[i].
460 virt_addr);
461 }
462 }
463 }
464 vfree(async->buf_page_list);
465 async->buf_page_list = NULL;
466 async->n_buf_pages = 0;
467 }
468
469 if (new_size) {
470 unsigned i = 0;
471 unsigned n_pages = new_size >> PAGE_SHIFT;
472 struct page **pages = NULL;
473
474 async->buf_page_list =
475 vmalloc(sizeof(struct comedi_buf_page) * n_pages);
476 if (async->buf_page_list) {
477 memset(async->buf_page_list, 0,
478 sizeof(struct comedi_buf_page) * n_pages);
479 pages = vmalloc(sizeof(struct page *) * n_pages);
480 }
481 if (pages) {
482 for (i = 0; i < n_pages; i++) {
483 if (s->async_dma_dir != DMA_NONE) {
484 async->buf_page_list[i].virt_addr =
485 dma_alloc_coherent(dev->hw_dev,
486 PAGE_SIZE,
487 &async->
488 buf_page_list
489 [i].dma_addr,
490 GFP_KERNEL |
491 __GFP_COMP);
492 } else {
493 async->buf_page_list[i].virt_addr =
494 (void *)
495 get_zeroed_page(GFP_KERNEL);
496 }
497 if (async->buf_page_list[i].virt_addr == NULL) {
498 break;
499 }
500 mem_map_reserve(virt_to_page
501 (async->buf_page_list[i].
502 virt_addr));
503 pages[i] =
504 virt_to_page(async->
505 buf_page_list[i].virt_addr);
506 }
507 }
508 if (i == n_pages) {
509 async->prealloc_buf =
510 vmap(pages, n_pages, VM_MAP, PAGE_KERNEL_NOCACHE);
511 }
512 vfree(pages);
513
514 if (async->prealloc_buf == NULL) {
515
516 if (async->buf_page_list) {
517 for (i = 0; i < n_pages; i++) {
518 if (async->buf_page_list[i].virt_addr ==
519 NULL) {
520 break;
521 }
522 mem_map_unreserve(virt_to_page
523 (async->buf_page_list
524 [i].virt_addr));
525 if (s->async_dma_dir != DMA_NONE) {
526 dma_free_coherent(dev->hw_dev,
527 PAGE_SIZE,
528 async->
529 buf_page_list
530 [i].virt_addr,
531 async->
532 buf_page_list
533 [i].dma_addr);
534 } else {
535 free_page((unsigned long)
536 async->buf_page_list
537 [i].virt_addr);
538 }
539 }
540 vfree(async->buf_page_list);
541 async->buf_page_list = NULL;
542 }
543 return -ENOMEM;
544 }
545 async->n_buf_pages = n_pages;
546 }
547 async->prealloc_bufsz = new_size;
548
549 return 0;
550}
551
552
553
554unsigned int comedi_buf_munge(struct comedi_async *async,
555 unsigned int num_bytes)
556{
557 struct comedi_subdevice *s = async->subdevice;
558 unsigned int count = 0;
559 const unsigned num_sample_bytes = bytes_per_sample(s);
560
561 if (s->munge == NULL || (async->cmd.flags & CMDF_RAWDATA)) {
562 async->munge_count += num_bytes;
563 BUG_ON((int)(async->munge_count - async->buf_write_count) > 0);
564 return num_bytes;
565 }
566
567 num_bytes -= num_bytes % num_sample_bytes;
568 while (count < num_bytes) {
569 int block_size;
570
571 block_size = num_bytes - count;
572 if (block_size < 0) {
573 printk("%s: %s: bug! block_size is negative\n",
574 __FILE__, __func__);
575 break;
576 }
577 if ((int)(async->munge_ptr + block_size -
578 async->prealloc_bufsz) > 0)
579 block_size = async->prealloc_bufsz - async->munge_ptr;
580
581 s->munge(s->device, s, async->prealloc_buf + async->munge_ptr,
582 block_size, async->munge_chan);
583
584 smp_wmb();
585
586 async->munge_chan += block_size / num_sample_bytes;
587 async->munge_chan %= async->cmd.chanlist_len;
588 async->munge_count += block_size;
589 async->munge_ptr += block_size;
590 async->munge_ptr %= async->prealloc_bufsz;
591 count += block_size;
592 }
593 BUG_ON((int)(async->munge_count - async->buf_write_count) > 0);
594 return count;
595}
596
597unsigned int comedi_buf_write_n_available(struct comedi_async *async)
598{
599 unsigned int free_end;
600 unsigned int nbytes;
601
602 if (async == NULL)
603 return 0;
604
605 free_end = async->buf_read_count + async->prealloc_bufsz;
606 nbytes = free_end - async->buf_write_alloc_count;
607 nbytes -= nbytes % bytes_per_sample(async->subdevice);
608
609
610
611
612 smp_mb();
613 return nbytes;
614}
615
616
617unsigned int comedi_buf_write_alloc(struct comedi_async *async,
618 unsigned int nbytes)
619{
620 unsigned int free_end = async->buf_read_count + async->prealloc_bufsz;
621
622 if ((int)(async->buf_write_alloc_count + nbytes - free_end) > 0) {
623 nbytes = free_end - async->buf_write_alloc_count;
624 }
625 async->buf_write_alloc_count += nbytes;
626
627
628 smp_mb();
629 return nbytes;
630}
631
632
633unsigned int comedi_buf_write_alloc_strict(struct comedi_async *async,
634 unsigned int nbytes)
635{
636 unsigned int free_end = async->buf_read_count + async->prealloc_bufsz;
637
638 if ((int)(async->buf_write_alloc_count + nbytes - free_end) > 0) {
639 nbytes = 0;
640 }
641 async->buf_write_alloc_count += nbytes;
642
643
644 smp_mb();
645 return nbytes;
646}
647
648
649unsigned comedi_buf_write_free(struct comedi_async *async, unsigned int nbytes)
650{
651 if ((int)(async->buf_write_count + nbytes -
652 async->buf_write_alloc_count) > 0) {
653 printk
654 ("comedi: attempted to write-free more bytes than have been write-allocated.\n");
655 nbytes = async->buf_write_alloc_count - async->buf_write_count;
656 }
657 async->buf_write_count += nbytes;
658 async->buf_write_ptr += nbytes;
659 comedi_buf_munge(async, async->buf_write_count - async->munge_count);
660 if (async->buf_write_ptr >= async->prealloc_bufsz) {
661 async->buf_write_ptr %= async->prealloc_bufsz;
662 }
663 return nbytes;
664}
665
666
667unsigned comedi_buf_read_alloc(struct comedi_async *async, unsigned nbytes)
668{
669 if ((int)(async->buf_read_alloc_count + nbytes - async->munge_count) >
670 0) {
671 nbytes = async->munge_count - async->buf_read_alloc_count;
672 }
673 async->buf_read_alloc_count += nbytes;
674
675
676 smp_rmb();
677 return nbytes;
678}
679
680
681unsigned comedi_buf_read_free(struct comedi_async *async, unsigned int nbytes)
682{
683
684 smp_mb();
685 if ((int)(async->buf_read_count + nbytes -
686 async->buf_read_alloc_count) > 0) {
687 printk
688 ("comedi: attempted to read-free more bytes than have been read-allocated.\n");
689 nbytes = async->buf_read_alloc_count - async->buf_read_count;
690 }
691 async->buf_read_count += nbytes;
692 async->buf_read_ptr += nbytes;
693 async->buf_read_ptr %= async->prealloc_bufsz;
694 return nbytes;
695}
696
697void comedi_buf_memcpy_to(struct comedi_async *async, unsigned int offset,
698 const void *data, unsigned int num_bytes)
699{
700 unsigned int write_ptr = async->buf_write_ptr + offset;
701
702 if (write_ptr >= async->prealloc_bufsz)
703 write_ptr %= async->prealloc_bufsz;
704
705 while (num_bytes) {
706 unsigned int block_size;
707
708 if (write_ptr + num_bytes > async->prealloc_bufsz)
709 block_size = async->prealloc_bufsz - write_ptr;
710 else
711 block_size = num_bytes;
712
713 memcpy(async->prealloc_buf + write_ptr, data, block_size);
714
715 data += block_size;
716 num_bytes -= block_size;
717
718 write_ptr = 0;
719 }
720}
721
722void comedi_buf_memcpy_from(struct comedi_async *async, unsigned int offset,
723 void *dest, unsigned int nbytes)
724{
725 void *src;
726 unsigned int read_ptr = async->buf_read_ptr + offset;
727
728 if (read_ptr >= async->prealloc_bufsz)
729 read_ptr %= async->prealloc_bufsz;
730
731 while (nbytes) {
732 unsigned int block_size;
733
734 src = async->prealloc_buf + read_ptr;
735
736 if (nbytes >= async->prealloc_bufsz - read_ptr)
737 block_size = async->prealloc_bufsz - read_ptr;
738 else
739 block_size = nbytes;
740
741 memcpy(dest, src, block_size);
742 nbytes -= block_size;
743 dest += block_size;
744 read_ptr = 0;
745 }
746}
747
748unsigned int comedi_buf_read_n_available(struct comedi_async *async)
749{
750 unsigned num_bytes;
751
752 if (async == NULL)
753 return 0;
754 num_bytes = async->munge_count - async->buf_read_count;
755
756
757
758
759 smp_rmb();
760 return num_bytes;
761}
762
763int comedi_buf_get(struct comedi_async *async, short *x)
764{
765 unsigned int n = comedi_buf_read_n_available(async);
766
767 if (n < sizeof(short))
768 return 0;
769 comedi_buf_read_alloc(async, sizeof(short));
770 *x = *(short *)(async->prealloc_buf + async->buf_read_ptr);
771 comedi_buf_read_free(async, sizeof(short));
772 return 1;
773}
774
775int comedi_buf_put(struct comedi_async *async, short x)
776{
777 unsigned int n = comedi_buf_write_alloc_strict(async, sizeof(short));
778
779 if (n < sizeof(short)) {
780 async->events |= COMEDI_CB_ERROR;
781 return 0;
782 }
783 *(short *)(async->prealloc_buf + async->buf_write_ptr) = x;
784 comedi_buf_write_free(async, sizeof(short));
785 return 1;
786}
787
788void comedi_reset_async_buf(struct comedi_async *async)
789{
790 async->buf_write_alloc_count = 0;
791 async->buf_write_count = 0;
792 async->buf_read_alloc_count = 0;
793 async->buf_read_count = 0;
794
795 async->buf_write_ptr = 0;
796 async->buf_read_ptr = 0;
797
798 async->cur_chan = 0;
799 async->scan_progress = 0;
800 async->munge_chan = 0;
801 async->munge_count = 0;
802 async->munge_ptr = 0;
803
804 async->events = 0;
805}
806
807int comedi_auto_config(struct device *hardware_device, const char *board_name,
808 const int *options, unsigned num_options)
809{
810 struct comedi_devconfig it;
811 int minor;
812 struct comedi_device_file_info *dev_file_info;
813 int retval;
814 unsigned *private_data = NULL;
815
816 if (!comedi_autoconfig) {
817 dev_set_drvdata(hardware_device, NULL);
818 return 0;
819 }
820
821 minor = comedi_alloc_board_minor(hardware_device);
822 if (minor < 0)
823 return minor;
824
825 private_data = kmalloc(sizeof(unsigned), GFP_KERNEL);
826 if (private_data == NULL) {
827 retval = -ENOMEM;
828 goto cleanup;
829 }
830 *private_data = minor;
831 dev_set_drvdata(hardware_device, private_data);
832
833 dev_file_info = comedi_get_device_file_info(minor);
834
835 memset(&it, 0, sizeof(it));
836 strncpy(it.board_name, board_name, COMEDI_NAMELEN);
837 it.board_name[COMEDI_NAMELEN - 1] = '\0';
838 BUG_ON(num_options > COMEDI_NDEVCONFOPTS);
839 memcpy(it.options, options, num_options * sizeof(int));
840
841 mutex_lock(&dev_file_info->device->mutex);
842 retval = comedi_device_attach(dev_file_info->device, &it);
843 mutex_unlock(&dev_file_info->device->mutex);
844
845cleanup:
846 if (retval < 0) {
847 kfree(private_data);
848 comedi_free_board_minor(minor);
849 }
850 return retval;
851}
852
853void comedi_auto_unconfig(struct device *hardware_device)
854{
855 unsigned *minor = (unsigned *)dev_get_drvdata(hardware_device);
856 if (minor == NULL)
857 return;
858
859 BUG_ON(*minor >= COMEDI_NUM_BOARD_MINORS);
860
861 comedi_free_board_minor(*minor);
862 dev_set_drvdata(hardware_device, NULL);
863 kfree(minor);
864}
865
866int comedi_pci_auto_config(struct pci_dev *pcidev, const char *board_name)
867{
868 int options[2];
869
870
871 options[0] = pcidev->bus->number;
872
873 options[1] = PCI_SLOT(pcidev->devfn);
874
875 return comedi_auto_config(&pcidev->dev, board_name,
876 options, ARRAY_SIZE(options));
877}
878
879void comedi_pci_auto_unconfig(struct pci_dev *pcidev)
880{
881 comedi_auto_unconfig(&pcidev->dev);
882}
883
884int comedi_usb_auto_config(struct usb_device *usbdev, const char *board_name)
885{
886 BUG_ON(usbdev == NULL);
887 return comedi_auto_config(&usbdev->dev, board_name, NULL, 0);
888}
889
890void comedi_usb_auto_unconfig(struct usb_device *usbdev)
891{
892 BUG_ON(usbdev == NULL);
893 comedi_auto_unconfig(&usbdev->dev);
894}
895
