2 comedi/drivers/comedi_bond.c
3 A Comedi driver to 'bond' or merge multiple drivers and devices as one.
5 COMEDI - Linux Control and Measurement Device Interface
6 Copyright (C) 2000 David A. Schleef <ds@schleef.org>
7 Copyright (C) 2005 Calin A. Culianu <calin@ajvar.org>
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 Description: A driver to 'bond' (merge) multiple subdevices from multiple
27 devices together as one.
30 Updated: Mon, 10 Oct 00:18:25 -0500
33 This driver allows you to 'bond' (merge) multiple comedi subdevices
34 (coming from possibly difference boards and/or drivers) together. For
35 example, if you had a board with 2 different DIO subdevices, and
36 another with 1 DIO subdevice, you could 'bond' them with this driver
37 so that they look like one big fat DIO subdevice. This makes writing
38 applications slightly easier as you don't have to worry about managing
39 different subdevices in the application -- you just worry about
40 indexing one linear array of channel id's.
42 Right now only DIO subdevices are supported as that's the personal itch
43 I am scratching with this driver. If you want to add support for AI and AO
44 subdevs, go right on ahead and do so!
46 Commands aren't supported -- although it would be cool if they were.
48 Configuration Options:
49 List of comedi-minors to bond. All subdevices of the same type
50 within each minor will be concatenated together in the order given here.
54 * The previous block comment is used to automatically generate
55 * documentation in Comedi and Comedilib. The fields:
57 * Driver: the name of the driver
58 * Description: a short phrase describing the driver. Don't list boards.
59 * Devices: a full list of the boards that attempt to be supported by
60 * the driver. Format is "(manufacturer) board name [comedi name]",
61 * where comedi_name is the name that is used to configure the board.
62 * See the comment near board_name: in the struct comedi_driver structure
63 * below. If (manufacturer) or [comedi name] is missing, the previous
66 * Updated: date when the _documentation_ was last updated. Use 'date -R'
67 * to get a value for this.
68 * Status: a one-word description of the status. Valid values are:
69 * works - driver works correctly on most boards supported, and
71 * unknown - unknown. Usually put there by ds.
72 * experimental - may not work in any particular release. Author
73 * probably wants assistance testing it.
74 * bitrotten - driver has not been update in a long time, probably
75 * doesn't work, and probably is missing support for significant
76 * Comedi interface features.
77 * untested - author probably wrote it "blind", and is believed to
78 * work, but no confirmation.
80 * These headers should be followed by a blank line, and any comments
81 * you wish to say about the driver. The comment area is the place
82 * to put any known bugs, limitations, unsupported features, supported
83 * command triggers, whether or not commands are supported on particular
86 * Somewhere in the comment should be information about configuration
87 * options that are used with comedi_config.
90 #include "../comedilib.h"
91 #include "../comedidev.h"
92 #include <linux/string.h>
94 /* The maxiumum number of channels per subdevice. */
97 #define MODULE_NAME "comedi_bond"
99 MODULE_LICENSE("GPL");
103 # define STR(x) STR1(x)
107 module_param(debug, int, 0644);
108 MODULE_PARM_DESC(debug, "If true, print extra cryptic debugging output useful"
109 "only to developers.");
111 #define LOG_MSG(x...) printk(KERN_INFO MODULE_NAME": "x)
112 #define DEBUG(x...) \
115 printk(KERN_DEBUG MODULE_NAME": DEBUG: "x); \
117 #define WARNING(x...) printk(KERN_WARNING MODULE_NAME ": WARNING: "x)
118 #define ERROR(x...) printk(KERN_ERR MODULE_NAME ": INTERNAL ERROR: "x)
119 MODULE_AUTHOR("Calin A. Culianu");
120 MODULE_DESCRIPTION(MODULE_NAME "A driver for COMEDI to bond multiple COMEDI "
121 "devices together as one. In the words of John Lennon: "
122 "'And the world will live as one...'");
125 * Board descriptions for two imaginary boards. Describing the
126 * boards in this way is optional, and completely driver-dependent.
127 * Some drivers use arrays such as this, other do not.
129 struct BondingBoard {
133 static const struct BondingBoard bondingBoards[] = {
140 * Useful for shorthand access to the particular board structure
142 #define thisboard ((const struct BondingBoard *)dev->board_ptr)
144 struct BondedDevice {
148 unsigned subdev_type;
150 unsigned chanid_offset; /* The offset into our unified linear
151 channel-id's of chanid 0 on this
155 /* this structure is for data unique to this hardware driver. If
156 several hardware drivers keep similar information in this structure,
157 feel free to suggest moving the variable to the struct comedi_device struct. */
159 # define MAX_BOARD_NAME 256
160 char name[MAX_BOARD_NAME];
161 struct BondedDevice **devs;
163 struct BondedDevice *chanIdDevMap[MAX_CHANS];
168 * most drivers define the following macro to make it easy to
169 * access the private structure.
171 #define devpriv ((struct Private *)dev->private)
174 * The struct comedi_driver structure tells the Comedi core module
175 * which functions to call to configure/deconfigure (attach/detach)
176 * the board, and also about the kernel module that contains
179 static int bonding_attach(struct comedi_device *dev,
180 struct comedi_devconfig *it);
181 static int bonding_detach(struct comedi_device *dev);
182 /** Build Private array of all devices.. */
183 static int doDevConfig(struct comedi_device *dev, struct comedi_devconfig *it);
184 static void doDevUnconfig(struct comedi_device *dev);
185 /* Ugly implementation of realloc that always copies memory around -- I'm lazy,
186 * what can I say? I like to do wasteful memcopies.. :) */
187 static void *Realloc(const void *ptr, size_t len, size_t old_len);
189 static struct comedi_driver driver_bonding = {
190 .driver_name = MODULE_NAME,
191 .module = THIS_MODULE,
192 .attach = bonding_attach,
193 .detach = bonding_detach,
194 /* It is not necessary to implement the following members if you are
195 * writing a driver for a ISA PnP or PCI card */
196 /* Most drivers will support multiple types of boards by
197 * having an array of board structures. These were defined
198 * in skel_boards[] above. Note that the element 'name'
199 * was first in the structure -- Comedi uses this fact to
200 * extract the name of the board without knowing any details
201 * about the structure except for its length.
202 * When a device is attached (by comedi_config), the name
203 * of the device is given to Comedi, and Comedi tries to
204 * match it by going through the list of board names. If
205 * there is a match, the address of the pointer is put
206 * into dev->board_ptr and driver->attach() is called.
208 * Note that these are not necessary if you can determine
209 * the type of board in software. ISA PnP, PCI, and PCMCIA
210 * devices are such boards.
212 .board_name = &bondingBoards[0].name,
213 .offset = sizeof(struct BondingBoard),
214 .num_names = ARRAY_SIZE(bondingBoards),
217 static int bonding_dio_insn_bits(struct comedi_device *dev,
218 struct comedi_subdevice *s,
219 struct comedi_insn *insn, unsigned int *data);
220 static int bonding_dio_insn_config(struct comedi_device *dev,
221 struct comedi_subdevice *s,
222 struct comedi_insn *insn,
226 * Attach is called by the Comedi core to configure the driver
227 * for a particular board. If you specified a board_name array
228 * in the driver structure, dev->board_ptr contains that
231 static int bonding_attach(struct comedi_device *dev,
232 struct comedi_devconfig *it)
234 struct comedi_subdevice *s;
236 LOG_MSG("comedi%d\n", dev->minor);
239 * Allocate the private structure area. alloc_private() is a
240 * convenient macro defined in comedidev.h.
242 if (alloc_private(dev, sizeof(struct Private)) < 0)
246 * Setup our bonding from config params.. sets up our Private struct..
248 if (!doDevConfig(dev, it))
252 * Initialize dev->board_name. Note that we can use the "thisboard"
253 * macro now, since we just initialized it in the last line.
255 dev->board_name = devpriv->name;
258 * Allocate the subdevice structures. alloc_subdevice() is a
259 * convenient macro defined in comedidev.h.
261 if (alloc_subdevices(dev, 1) < 0)
264 s = dev->subdevices + 0;
265 s->type = COMEDI_SUBD_DIO;
266 s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
267 s->n_chan = devpriv->nchans;
269 s->range_table = &range_digital;
270 s->insn_bits = bonding_dio_insn_bits;
271 s->insn_config = bonding_dio_insn_config;
273 LOG_MSG("attached with %u DIO channels coming from %u different "
274 "subdevices all bonded together. "
275 "John Lennon would be proud!\n",
276 devpriv->nchans, devpriv->ndevs);
282 * _detach is called to deconfigure a device. It should deallocate
284 * This function is also called when _attach() fails, so it should be
285 * careful not to release resources that were not necessarily
286 * allocated by _attach(). dev->private and dev->subdevices are
287 * deallocated automatically by the core.
289 static int bonding_detach(struct comedi_device *dev)
291 LOG_MSG("comedi%d: remove\n", dev->minor);
296 /* DIO devices are slightly special. Although it is possible to
297 * implement the insn_read/insn_write interface, it is much more
298 * useful to applications if you implement the insn_bits interface.
299 * This allows packed reading/writing of the DIO channels. The
300 * comedi core can convert between insn_bits and insn_read/write */
301 static int bonding_dio_insn_bits(struct comedi_device *dev,
302 struct comedi_subdevice *s,
303 struct comedi_insn *insn, unsigned int *data)
305 #define LSAMPL_BITS (sizeof(unsigned int)*8)
306 unsigned nchans = LSAMPL_BITS, num_done = 0, i;
310 if (devpriv->nchans < nchans)
311 nchans = devpriv->nchans;
313 /* The insn data is a mask in data[0] and the new data
314 * in data[1], each channel cooresponding to a bit. */
315 for (i = 0; num_done < nchans && i < devpriv->ndevs; ++i) {
316 struct BondedDevice *bdev = devpriv->devs[i];
317 /* Grab the channel mask and data of only the bits corresponding
318 to this subdevice.. need to shift them to zero position of
320 /* Bits corresponding to this subdev. */
321 unsigned int subdevMask = ((1 << bdev->nchans) - 1);
322 unsigned int writeMask, dataBits;
324 /* Argh, we have >= LSAMPL_BITS chans.. take all bits */
325 if (bdev->nchans >= LSAMPL_BITS)
326 subdevMask = (unsigned int)(-1);
328 writeMask = (data[0] >> num_done) & subdevMask;
329 dataBits = (data[1] >> num_done) & subdevMask;
331 /* Read/Write the new digital lines */
332 if (comedi_dio_bitfield(bdev->dev, bdev->subdev, writeMask,
336 /* Make room for the new bits in data[1], the return value */
337 data[1] &= ~(subdevMask << num_done);
338 /* Put the bits in the return value */
339 data[1] |= (dataBits & subdevMask) << num_done;
340 /* Save the new bits to the saved state.. */
343 num_done += bdev->nchans;
349 static int bonding_dio_insn_config(struct comedi_device *dev,
350 struct comedi_subdevice *s,
351 struct comedi_insn *insn, unsigned int *data)
353 int chan = CR_CHAN(insn->chanspec), ret, io_bits = s->io_bits;
355 struct BondedDevice *bdev;
357 if (chan < 0 || chan >= devpriv->nchans)
359 bdev = devpriv->chanIdDevMap[chan];
361 /* The input or output configuration of each digital line is
362 * configured by a special insn_config instruction. chanspec
363 * contains the channel to be changed, and data[0] contains the
364 * value COMEDI_INPUT or COMEDI_OUTPUT. */
366 case INSN_CONFIG_DIO_OUTPUT:
367 io = COMEDI_OUTPUT; /* is this really necessary? */
368 io_bits |= 1 << chan;
370 case INSN_CONFIG_DIO_INPUT:
371 io = COMEDI_INPUT; /* is this really necessary? */
372 io_bits &= ~(1 << chan);
374 case INSN_CONFIG_DIO_QUERY:
376 (io_bits & (1 << chan)) ? COMEDI_OUTPUT : COMEDI_INPUT;
383 /* 'real' channel id for this subdev.. */
384 chan -= bdev->chanid_offset;
385 ret = comedi_dio_config(bdev->dev, bdev->subdev, chan, io);
388 /* Finally, save the new io_bits values since we didn't get
390 s->io_bits = io_bits;
394 static void *Realloc(const void *oldmem, size_t newlen, size_t oldlen)
396 void *newmem = kmalloc(newlen, GFP_KERNEL);
398 if (newmem && oldmem)
399 memcpy(newmem, oldmem, min(oldlen, newlen));
404 static int doDevConfig(struct comedi_device *dev, struct comedi_devconfig *it)
407 void *devs_opened[COMEDI_NUM_BOARD_MINORS];
409 memset(devs_opened, 0, sizeof(devs_opened));
410 devpriv->name[0] = 0;;
411 /* Loop through all comedi devices specified on the command-line,
412 building our device list */
413 for (i = 0; i < COMEDI_NDEVCONFOPTS && (!i || it->options[i]); ++i) {
414 char file[] = "/dev/comediXXXXXX";
415 int minor = it->options[i];
417 int sdev = -1, nchans, tmp;
418 struct BondedDevice *bdev = NULL;
420 if (minor < 0 || minor > COMEDI_NUM_BOARD_MINORS) {
421 ERROR("Minor %d is invalid!\n", minor);
424 if (minor == dev->minor) {
425 ERROR("Cannot bond this driver to itself!\n");
428 if (devs_opened[minor]) {
429 ERROR("Minor %d specified more than once!\n", minor);
433 snprintf(file, sizeof(file), "/dev/comedi%u", minor);
434 file[sizeof(file) - 1] = 0;
436 d = devs_opened[minor] = comedi_open(file);
439 ERROR("Minor %u could not be opened\n", minor);
443 /* Do DIO, as that's all we support now.. */
444 while ((sdev = comedi_find_subdevice_by_type(d, COMEDI_SUBD_DIO,
446 nchans = comedi_get_n_channels(d, sdev);
448 ERROR("comedi_get_n_channels() returned %d "
449 "on minor %u subdev %d!\n",
450 nchans, minor, sdev);
453 bdev = kmalloc(sizeof(*bdev), GFP_KERNEL);
455 ERROR("Out of memory.\n");
461 bdev->subdev_type = COMEDI_SUBD_DIO;
462 bdev->nchans = nchans;
463 bdev->chanid_offset = devpriv->nchans;
465 /* map channel id's to BondedDevice * pointer.. */
467 devpriv->chanIdDevMap[devpriv->nchans++] = bdev;
469 /* Now put bdev pointer at end of devpriv->devs array
472 /* ergh.. ugly.. we need to realloc :( */
473 tmp = devpriv->ndevs * sizeof(bdev);
475 Realloc(devpriv->devs,
476 ++devpriv->ndevs * sizeof(bdev), tmp);
477 if (!devpriv->devs) {
478 ERROR("Could not allocate memory. "
483 devpriv->devs[devpriv->ndevs - 1] = bdev;
485 /** Append dev:subdev to devpriv->name */
488 MAX_BOARD_NAME - strlen(devpriv->name) - 1;
489 snprintf(buf, sizeof(buf), "%d:%d ", dev->minor,
491 buf[sizeof(buf) - 1] = 0;
492 strncat(devpriv->name, buf, left);
498 if (!devpriv->nchans) {
499 ERROR("No channels found!\n");
506 static void doDevUnconfig(struct comedi_device *dev)
508 unsigned long devs_closed = 0;
511 while (devpriv->ndevs-- && devpriv->devs) {
512 struct BondedDevice *bdev;
514 bdev = devpriv->devs[devpriv->ndevs];
517 if (!(devs_closed & (0x1 << bdev->minor))) {
518 comedi_close(bdev->dev);
519 devs_closed |= (0x1 << bdev->minor);
523 kfree(devpriv->devs);
524 devpriv->devs = NULL;
530 static int __init init(void)
532 return comedi_driver_register(&driver_bonding);
535 static void __exit cleanup(void)
537 comedi_driver_unregister(&driver_bonding);
541 module_exit(cleanup);