comedidev.h revision b8f4ac237e382accd4b30c75043939f7ed9e79a6
1/* 2 include/linux/comedidev.h 3 header file for kernel-only structures, variables, and constants 4 5 COMEDI - Linux Control and Measurement Device Interface 6 Copyright (C) 1997-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 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 21 22*/ 23 24#ifndef _COMEDIDEV_H 25#define _COMEDIDEV_H 26 27#include <linux/kernel.h> 28#include <linux/module.h> 29#include <linux/kdev_t.h> 30#include <linux/slab.h> 31#include <linux/delay.h> 32#include <linux/errno.h> 33#include <linux/spinlock.h> 34#include <linux/mutex.h> 35#include <linux/wait.h> 36#include <linux/mm.h> 37#include <linux/init.h> 38#include <linux/vmalloc.h> 39#include <linux/dma-mapping.h> 40#include <linux/uaccess.h> 41#include <linux/io.h> 42#include <linux/timer.h> 43 44#include "comedi.h" 45 46#define DPRINTK(format, args...) do { \ 47 if (comedi_debug) \ 48 pr_debug("comedi: " format, ## args); \ 49} while (0) 50 51#define COMEDI_VERSION(a, b, c) (((a) << 16) + ((b) << 8) + (c)) 52#define COMEDI_VERSION_CODE COMEDI_VERSION(COMEDI_MAJORVERSION, \ 53 COMEDI_MINORVERSION, COMEDI_MICROVERSION) 54#define COMEDI_RELEASE VERSION 55 56#define COMEDI_NUM_MINORS 0x100 57#define COMEDI_NUM_BOARD_MINORS 0x30 58#define COMEDI_FIRST_SUBDEVICE_MINOR COMEDI_NUM_BOARD_MINORS 59 60struct comedi_subdevice { 61 struct comedi_device *device; 62 int index; 63 int type; 64 int n_chan; 65 int subdev_flags; 66 int len_chanlist; /* maximum length of channel/gain list */ 67 68 void *private; 69 70 struct comedi_async *async; 71 72 void *lock; 73 void *busy; 74 unsigned runflags; 75 spinlock_t spin_lock; 76 77 unsigned int io_bits; 78 79 unsigned int maxdata; /* if maxdata==0, use list */ 80 const unsigned int *maxdata_list; /* list is channel specific */ 81 82 unsigned int flags; 83 const unsigned int *flaglist; 84 85 unsigned int settling_time_0; 86 87 const struct comedi_lrange *range_table; 88 const struct comedi_lrange *const *range_table_list; 89 90 unsigned int *chanlist; /* driver-owned chanlist (not used) */ 91 92 int (*insn_read) (struct comedi_device *, struct comedi_subdevice *, 93 struct comedi_insn *, unsigned int *); 94 int (*insn_write) (struct comedi_device *, struct comedi_subdevice *, 95 struct comedi_insn *, unsigned int *); 96 int (*insn_bits) (struct comedi_device *, struct comedi_subdevice *, 97 struct comedi_insn *, unsigned int *); 98 int (*insn_config) (struct comedi_device *, struct comedi_subdevice *, 99 struct comedi_insn *, unsigned int *); 100 101 int (*do_cmd) (struct comedi_device *, struct comedi_subdevice *); 102 int (*do_cmdtest) (struct comedi_device *, struct comedi_subdevice *, 103 struct comedi_cmd *); 104 int (*poll) (struct comedi_device *, struct comedi_subdevice *); 105 int (*cancel) (struct comedi_device *, struct comedi_subdevice *); 106 /* int (*do_lock)(struct comedi_device *, struct comedi_subdevice *); */ 107 /* int (*do_unlock)(struct comedi_device *, \ 108 struct comedi_subdevice *); */ 109 110 /* called when the buffer changes */ 111 int (*buf_change) (struct comedi_device *dev, 112 struct comedi_subdevice *s, unsigned long new_size); 113 114 void (*munge) (struct comedi_device *dev, struct comedi_subdevice *s, 115 void *data, unsigned int num_bytes, 116 unsigned int start_chan_index); 117 enum dma_data_direction async_dma_dir; 118 119 unsigned int state; 120 121 struct device *class_dev; 122 int minor; 123}; 124 125struct comedi_buf_page { 126 void *virt_addr; 127 dma_addr_t dma_addr; 128}; 129 130struct comedi_async { 131 struct comedi_subdevice *subdevice; 132 133 void *prealloc_buf; /* pre-allocated buffer */ 134 unsigned int prealloc_bufsz; /* buffer size, in bytes */ 135 /* virtual and dma address of each page */ 136 struct comedi_buf_page *buf_page_list; 137 unsigned n_buf_pages; /* num elements in buf_page_list */ 138 139 unsigned int max_bufsize; /* maximum buffer size, bytes */ 140 /* current number of mmaps of prealloc_buf */ 141 unsigned int mmap_count; 142 143 /* byte count for writer (write completed) */ 144 unsigned int buf_write_count; 145 /* byte count for writer (allocated for writing) */ 146 unsigned int buf_write_alloc_count; 147 /* byte count for reader (read completed) */ 148 unsigned int buf_read_count; 149 /* byte count for reader (allocated for reading) */ 150 unsigned int buf_read_alloc_count; 151 152 unsigned int buf_write_ptr; /* buffer marker for writer */ 153 unsigned int buf_read_ptr; /* buffer marker for reader */ 154 155 unsigned int cur_chan; /* useless channel marker for interrupt */ 156 /* number of bytes that have been received for current scan */ 157 unsigned int scan_progress; 158 /* keeps track of where we are in chanlist as for munging */ 159 unsigned int munge_chan; 160 /* number of bytes that have been munged */ 161 unsigned int munge_count; 162 /* buffer marker for munging */ 163 unsigned int munge_ptr; 164 165 unsigned int events; /* events that have occurred */ 166 167 struct comedi_cmd cmd; 168 169 wait_queue_head_t wait_head; 170 171 /* callback stuff */ 172 unsigned int cb_mask; 173 int (*cb_func) (unsigned int flags, void *); 174 void *cb_arg; 175 176 int (*inttrig) (struct comedi_device *dev, struct comedi_subdevice *s, 177 unsigned int x); 178}; 179 180struct comedi_driver { 181 struct comedi_driver *next; 182 183 const char *driver_name; 184 struct module *module; 185 int (*attach) (struct comedi_device *, struct comedi_devconfig *); 186 void (*detach) (struct comedi_device *); 187 int (*auto_attach) (struct comedi_device *, unsigned long); 188 189 /* number of elements in board_name and board_id arrays */ 190 unsigned int num_names; 191 const char *const *board_name; 192 /* offset in bytes from one board name pointer to the next */ 193 int offset; 194}; 195 196struct comedi_device { 197 int use_count; 198 struct comedi_driver *driver; 199 void *private; 200 201 struct device *class_dev; 202 int minor; 203 /* hw_dev is passed to dma_alloc_coherent when allocating async buffers 204 * for subdevices that have async_dma_dir set to something other than 205 * DMA_NONE */ 206 struct device *hw_dev; 207 208 const char *board_name; 209 const void *board_ptr; 210 int attached; 211 spinlock_t spinlock; 212 struct mutex mutex; 213 int in_request_module; 214 215 int n_subdevices; 216 struct comedi_subdevice *subdevices; 217 218 /* dumb */ 219 unsigned long iobase; 220 unsigned int irq; 221 222 struct comedi_subdevice *read_subdev; 223 struct comedi_subdevice *write_subdev; 224 225 struct fasync_struct *async_queue; 226 227 int (*open) (struct comedi_device *dev); 228 void (*close) (struct comedi_device *dev); 229}; 230 231static inline const void *comedi_board(const struct comedi_device *dev) 232{ 233 return dev->board_ptr; 234} 235 236#ifdef CONFIG_COMEDI_DEBUG 237extern int comedi_debug; 238#else 239static const int comedi_debug; 240#endif 241 242/* 243 * function prototypes 244 */ 245 246void comedi_event(struct comedi_device *dev, struct comedi_subdevice *s); 247void comedi_error(const struct comedi_device *dev, const char *s); 248 249/* we can expand the number of bits used to encode devices/subdevices into 250 the minor number soon, after more distros support > 8 bit minor numbers 251 (like after Debian Etch gets released) */ 252enum comedi_minor_bits { 253 COMEDI_DEVICE_MINOR_MASK = 0xf, 254 COMEDI_SUBDEVICE_MINOR_MASK = 0xf0 255}; 256static const unsigned COMEDI_SUBDEVICE_MINOR_SHIFT = 4; 257static const unsigned COMEDI_SUBDEVICE_MINOR_OFFSET = 1; 258 259struct comedi_device *comedi_dev_from_minor(unsigned minor); 260 261void init_polling(void); 262void cleanup_polling(void); 263void start_polling(struct comedi_device *); 264void stop_polling(struct comedi_device *); 265 266/* subdevice runflags */ 267enum subdevice_runflags { 268 SRF_USER = 0x00000001, 269 SRF_RT = 0x00000002, 270 /* indicates an COMEDI_CB_ERROR event has occurred since the last 271 * command was started */ 272 SRF_ERROR = 0x00000004, 273 SRF_RUNNING = 0x08000000 274}; 275 276bool comedi_is_subdevice_running(struct comedi_subdevice *s); 277 278int comedi_check_chanlist(struct comedi_subdevice *s, 279 int n, 280 unsigned int *chanlist); 281 282/* range stuff */ 283 284#define RANGE(a, b) {(a)*1e6, (b)*1e6, 0} 285#define RANGE_ext(a, b) {(a)*1e6, (b)*1e6, RF_EXTERNAL} 286#define RANGE_mA(a, b) {(a)*1e6, (b)*1e6, UNIT_mA} 287#define RANGE_unitless(a, b) {(a)*1e6, (b)*1e6, 0} 288#define BIP_RANGE(a) {-(a)*1e6, (a)*1e6, 0} 289#define UNI_RANGE(a) {0, (a)*1e6, 0} 290 291extern const struct comedi_lrange range_bipolar10; 292extern const struct comedi_lrange range_bipolar5; 293extern const struct comedi_lrange range_bipolar2_5; 294extern const struct comedi_lrange range_unipolar10; 295extern const struct comedi_lrange range_unipolar5; 296extern const struct comedi_lrange range_unknown; 297 298#define range_digital range_unipolar5 299 300#if __GNUC__ >= 3 301#define GCC_ZERO_LENGTH_ARRAY 302#else 303#define GCC_ZERO_LENGTH_ARRAY 0 304#endif 305 306struct comedi_lrange { 307 int length; 308 struct comedi_krange range[GCC_ZERO_LENGTH_ARRAY]; 309}; 310 311/* some silly little inline functions */ 312 313static inline unsigned int bytes_per_sample(const struct comedi_subdevice *subd) 314{ 315 if (subd->subdev_flags & SDF_LSAMPL) 316 return sizeof(unsigned int); 317 else 318 return sizeof(short); 319} 320 321/* 322 * Must set dev->hw_dev if you wish to dma directly into comedi's buffer. 323 * Also useful for retrieving a previously configured hardware device of 324 * known bus type. Set automatically for auto-configured devices. 325 * Automatically set to NULL when detaching hardware device. 326 */ 327int comedi_set_hw_dev(struct comedi_device *dev, struct device *hw_dev); 328 329unsigned int comedi_buf_write_alloc(struct comedi_async *, unsigned int); 330unsigned int comedi_buf_write_free(struct comedi_async *, unsigned int); 331 332unsigned int comedi_buf_read_n_available(struct comedi_async *); 333unsigned int comedi_buf_read_alloc(struct comedi_async *, unsigned int); 334unsigned int comedi_buf_read_free(struct comedi_async *, unsigned int); 335 336int comedi_buf_put(struct comedi_async *, short); 337int comedi_buf_get(struct comedi_async *, short *); 338 339void comedi_buf_memcpy_to(struct comedi_async *async, unsigned int offset, 340 const void *source, unsigned int num_bytes); 341void comedi_buf_memcpy_from(struct comedi_async *async, unsigned int offset, 342 void *destination, unsigned int num_bytes); 343 344/* drivers.c - general comedi driver functions */ 345 346int comedi_alloc_subdevices(struct comedi_device *, int); 347 348int comedi_auto_config(struct device *, struct comedi_driver *, 349 unsigned long context); 350void comedi_auto_unconfig(struct device *); 351 352int comedi_driver_register(struct comedi_driver *); 353int comedi_driver_unregister(struct comedi_driver *); 354 355/** 356 * module_comedi_driver() - Helper macro for registering a comedi driver 357 * @__comedi_driver: comedi_driver struct 358 * 359 * Helper macro for comedi drivers which do not do anything special in module 360 * init/exit. This eliminates a lot of boilerplate. Each module may only use 361 * this macro once, and calling it replaces module_init() and module_exit(). 362 */ 363#define module_comedi_driver(__comedi_driver) \ 364 module_driver(__comedi_driver, comedi_driver_register, \ 365 comedi_driver_unregister) 366 367#ifdef CONFIG_COMEDI_PCI_DRIVERS 368 369/* comedi_pci.c - comedi PCI driver specific functions */ 370 371/* 372 * PCI Vendor IDs not in <linux/pci_ids.h> 373 */ 374#define PCI_VENDOR_ID_KOLTER 0x1001 375#define PCI_VENDOR_ID_ICP 0x104c 376#define PCI_VENDOR_ID_AMCC 0x10e8 377#define PCI_VENDOR_ID_DT 0x1116 378#define PCI_VENDOR_ID_IOTECH 0x1616 379#define PCI_VENDOR_ID_CONTEC 0x1221 380#define PCI_VENDOR_ID_RTD 0x1435 381 382struct pci_dev; 383struct pci_driver; 384 385struct pci_dev *comedi_to_pci_dev(struct comedi_device *); 386 387int comedi_pci_enable(struct pci_dev *, const char *); 388void comedi_pci_disable(struct pci_dev *); 389 390int comedi_pci_auto_config(struct pci_dev *, struct comedi_driver *, 391 unsigned long context); 392void comedi_pci_auto_unconfig(struct pci_dev *); 393 394int comedi_pci_driver_register(struct comedi_driver *, struct pci_driver *); 395void comedi_pci_driver_unregister(struct comedi_driver *, struct pci_driver *); 396 397/** 398 * module_comedi_pci_driver() - Helper macro for registering a comedi PCI driver 399 * @__comedi_driver: comedi_driver struct 400 * @__pci_driver: pci_driver struct 401 * 402 * Helper macro for comedi PCI drivers which do not do anything special 403 * in module init/exit. This eliminates a lot of boilerplate. Each 404 * module may only use this macro once, and calling it replaces 405 * module_init() and module_exit() 406 */ 407#define module_comedi_pci_driver(__comedi_driver, __pci_driver) \ 408 module_driver(__comedi_driver, comedi_pci_driver_register, \ 409 comedi_pci_driver_unregister, &(__pci_driver)) 410 411#else 412 413/* 414 * Some of the comedi mixed ISA/PCI drivers call the PCI specific 415 * functions. Provide some dummy functions if CONFIG_COMEDI_PCI_DRIVERS 416 * is not enabled. 417 */ 418 419static inline struct pci_dev *comedi_to_pci_dev(struct comedi_device *dev) 420{ 421 return NULL; 422} 423 424static inline int comedi_pci_enable(struct pci_dev *dev, const char *name) 425{ 426 return -ENOSYS; 427} 428 429static inline void comedi_pci_disable(struct pci_dev *dev) 430{ 431} 432 433#endif /* CONFIG_COMEDI_PCI_DRIVERS */ 434 435#ifdef CONFIG_COMEDI_PCMCIA_DRIVERS 436 437/* comedi_pcmcia.c - comedi PCMCIA driver specific functions */ 438 439struct pcmcia_driver; 440struct pcmcia_device; 441 442struct pcmcia_device *comedi_to_pcmcia_dev(struct comedi_device *); 443 444int comedi_pcmcia_enable(struct comedi_device *, 445 int (*conf_check)(struct pcmcia_device *, void *)); 446void comedi_pcmcia_disable(struct comedi_device *); 447 448int comedi_pcmcia_auto_config(struct pcmcia_device *, struct comedi_driver *); 449void comedi_pcmcia_auto_unconfig(struct pcmcia_device *); 450 451int comedi_pcmcia_driver_register(struct comedi_driver *, 452 struct pcmcia_driver *); 453void comedi_pcmcia_driver_unregister(struct comedi_driver *, 454 struct pcmcia_driver *); 455 456/** 457 * module_comedi_pcmcia_driver() - Helper macro for registering a comedi PCMCIA driver 458 * @__comedi_driver: comedi_driver struct 459 * @__pcmcia_driver: pcmcia_driver struct 460 * 461 * Helper macro for comedi PCMCIA drivers which do not do anything special 462 * in module init/exit. This eliminates a lot of boilerplate. Each 463 * module may only use this macro once, and calling it replaces 464 * module_init() and module_exit() 465 */ 466#define module_comedi_pcmcia_driver(__comedi_driver, __pcmcia_driver) \ 467 module_driver(__comedi_driver, comedi_pcmcia_driver_register, \ 468 comedi_pcmcia_driver_unregister, &(__pcmcia_driver)) 469 470#endif /* CONFIG_COMEDI_PCMCIA_DRIVERS */ 471 472#ifdef CONFIG_COMEDI_USB_DRIVERS 473 474/* comedi_usb.c - comedi USB driver specific functions */ 475 476struct usb_driver; 477struct usb_interface; 478 479struct usb_interface *comedi_to_usb_interface(struct comedi_device *); 480 481int comedi_usb_auto_config(struct usb_interface *, struct comedi_driver *, 482 unsigned long context); 483void comedi_usb_auto_unconfig(struct usb_interface *); 484 485int comedi_usb_driver_register(struct comedi_driver *, struct usb_driver *); 486void comedi_usb_driver_unregister(struct comedi_driver *, struct usb_driver *); 487 488/** 489 * module_comedi_usb_driver() - Helper macro for registering a comedi USB driver 490 * @__comedi_driver: comedi_driver struct 491 * @__usb_driver: usb_driver struct 492 * 493 * Helper macro for comedi USB drivers which do not do anything special 494 * in module init/exit. This eliminates a lot of boilerplate. Each 495 * module may only use this macro once, and calling it replaces 496 * module_init() and module_exit() 497 */ 498#define module_comedi_usb_driver(__comedi_driver, __usb_driver) \ 499 module_driver(__comedi_driver, comedi_usb_driver_register, \ 500 comedi_usb_driver_unregister, &(__usb_driver)) 501 502#endif /* CONFIG_COMEDI_USB_DRIVERS */ 503 504#endif /* _COMEDIDEV_H */ 505