1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * comedi_bond.c
4 * A Comedi driver to 'bond' or merge multiple drivers and devices as one.
5 *
6 * COMEDI - Linux Control and Measurement Device Interface
7 * Copyright (C) 2000 David A. Schleef <ds@schleef.org>
8 * Copyright (C) 2005 Calin A. Culianu <calin@ajvar.org>
9 */
10
11 /*
12 * Driver: comedi_bond
13 * Description: A driver to 'bond' (merge) multiple subdevices from multiple
14 * devices together as one.
15 * Devices:
16 * Author: ds
17 * Updated: Mon, 10 Oct 00:18:25 -0500
18 * Status: works
19 *
20 * This driver allows you to 'bond' (merge) multiple comedi subdevices
21 * (coming from possibly difference boards and/or drivers) together. For
22 * example, if you had a board with 2 different DIO subdevices, and
23 * another with 1 DIO subdevice, you could 'bond' them with this driver
24 * so that they look like one big fat DIO subdevice. This makes writing
25 * applications slightly easier as you don't have to worry about managing
26 * different subdevices in the application -- you just worry about
27 * indexing one linear array of channel id's.
28 *
29 * Right now only DIO subdevices are supported as that's the personal itch
30 * I am scratching with this driver. If you want to add support for AI and AO
31 * subdevs, go right on ahead and do so!
32 *
33 * Commands aren't supported -- although it would be cool if they were.
34 *
35 * Configuration Options:
36 * List of comedi-minors to bond. All subdevices of the same type
37 * within each minor will be concatenated together in the order given here.
38 */
39
40 #include <linux/module.h>
41 #include <linux/string.h>
42 #include <linux/slab.h>
43 #include "../comedi.h"
44 #include "../comedilib.h"
45 #include "../comedidev.h"
46
47 struct bonded_device {
48 struct comedi_device *dev;
49 unsigned int minor;
50 unsigned int subdev;
51 unsigned int nchans;
52 };
53
54 struct comedi_bond_private {
55 char name[256];
56 struct bonded_device **devs;
57 unsigned int ndevs;
58 unsigned int nchans;
59 };
60
61 static int bonding_dio_insn_bits(struct comedi_device *dev,
62 struct comedi_subdevice *s,
63 struct comedi_insn *insn, unsigned int *data)
64 {
65 struct comedi_bond_private *devpriv = dev->private;
66 unsigned int n_left, n_done, base_chan;
67 unsigned int write_mask, data_bits;
68 struct bonded_device **devs;
69
70 write_mask = data[0];
71 data_bits = data[1];
72 base_chan = CR_CHAN(insn->chanspec);
73 /* do a maximum of 32 channels, starting from base_chan. */
74 n_left = devpriv->nchans - base_chan;
75 if (n_left > 32)
76 n_left = 32;
77
78 n_done = 0;
79 devs = devpriv->devs;
80 do {
81 struct bonded_device *bdev = *devs++;
82
83 if (base_chan < bdev->nchans) {
84 /* base channel falls within bonded device */
85 unsigned int b_chans, b_mask, b_write_mask, b_data_bits;
86 int ret;
87
88 /*
89 * Get num channels to do for bonded device and set
90 * up mask and data bits for bonded device.
91 */
92 b_chans = bdev->nchans - base_chan;
93 if (b_chans > n_left)
94 b_chans = n_left;
95 b_mask = (b_chans < 32) ? ((1 << b_chans) - 1)
96 : 0xffffffff;
97 b_write_mask = (write_mask >> n_done) & b_mask;
98 b_data_bits = (data_bits >> n_done) & b_mask;
99 /* Read/Write the new digital lines. */
100 ret = comedi_dio_bitfield2(bdev->dev, bdev->subdev,
101 b_write_mask, &b_data_bits,
102 base_chan);
103 if (ret < 0)
104 return ret;
105 /* Place read bits into data[1]. */
106 data[1] &= ~(b_mask << n_done);
107 data[1] |= (b_data_bits & b_mask) << n_done;
108 /*
109 * Set up for following bonded device (if still have
110 * channels to read/write).
111 */
112 base_chan = 0;
113 n_done += b_chans;
114 n_left -= b_chans;
115 } else {
116 /* Skip bonded devices before base channel. */
117 base_chan -= bdev->nchans;
118 }
119 } while (n_left);
120
121 return insn->n;
122 }
123
124 static int bonding_dio_insn_config(struct comedi_device *dev,
125 struct comedi_subdevice *s,
126 struct comedi_insn *insn, unsigned int *data)
127 {
128 struct comedi_bond_private *devpriv = dev->private;
129 unsigned int chan = CR_CHAN(insn->chanspec);
130 int ret;
131 struct bonded_device *bdev;
132 struct bonded_device **devs;
133
134 /*
135 * Locate bonded subdevice and adjust channel.
136 */
137 devs = devpriv->devs;
138 for (bdev = *devs++; chan >= bdev->nchans; bdev = *devs++)
139 chan -= bdev->nchans;
140
141 /*
142 * The input or output configuration of each digital line is
143 * configured by a special insn_config instruction. chanspec
144 * contains the channel to be changed, and data[0] contains the
145 * configuration instruction INSN_CONFIG_DIO_OUTPUT,
146 * INSN_CONFIG_DIO_INPUT or INSN_CONFIG_DIO_QUERY.
147 *
148 * Note that INSN_CONFIG_DIO_OUTPUT == COMEDI_OUTPUT,
149 * and INSN_CONFIG_DIO_INPUT == COMEDI_INPUT. This is deliberate ;)
150 */
151 switch (data[0]) {
152 case INSN_CONFIG_DIO_OUTPUT:
153 case INSN_CONFIG_DIO_INPUT:
154 ret = comedi_dio_config(bdev->dev, bdev->subdev, chan, data[0]);
155 break;
156 case INSN_CONFIG_DIO_QUERY:
157 ret = comedi_dio_get_config(bdev->dev, bdev->subdev, chan,
158 &data[1]);
159 break;
160 default:
161 ret = -EINVAL;
162 break;
163 }
164 if (ret >= 0)
165 ret = insn->n;
166 return ret;
167 }
168
169 static int do_dev_config(struct comedi_device *dev, struct comedi_devconfig *it)
170 {
171 struct comedi_bond_private *devpriv = dev->private;
172 DECLARE_BITMAP(devs_opened, COMEDI_NUM_BOARD_MINORS);
173 int i;
174
175 memset(&devs_opened, 0, sizeof(devs_opened));
176 devpriv->name[0] = 0;
177 /*
178 * Loop through all comedi devices specified on the command-line,
179 * building our device list.
180 */
181 for (i = 0; i < COMEDI_NDEVCONFOPTS && (!i || it->options[i]); ++i) {
182 char file[sizeof("/dev/comediXXXXXX")];
183 int minor = it->options[i];
184 struct comedi_device *d;
185 int sdev = -1, nchans;
186 struct bonded_device *bdev;
187 struct bonded_device **devs;
188
189 if (minor < 0 || minor >= COMEDI_NUM_BOARD_MINORS) {
190 dev_err(dev->class_dev,
191 "Minor %d is invalid!\n", minor);
192 return -EINVAL;
193 }
194 if (minor == dev->minor) {
195 dev_err(dev->class_dev,
196 "Cannot bond this driver to itself!\n");
197 return -EINVAL;
198 }
199 if (test_and_set_bit(minor, devs_opened)) {
200 dev_err(dev->class_dev,
201 "Minor %d specified more than once!\n", minor);
202 return -EINVAL;
203 }
204
205 snprintf(file, sizeof(file), "/dev/comedi%d", minor);
206 file[sizeof(file) - 1] = 0;
207
208 d = comedi_open(file);
209
210 if (!d) {
211 dev_err(dev->class_dev,
212 "Minor %u could not be opened\n", minor);
213 return -ENODEV;
214 }
215
216 /* Do DIO, as that's all we support now.. */
217 while ((sdev = comedi_find_subdevice_by_type(d, COMEDI_SUBD_DIO,
218 sdev + 1)) > -1) {
219 nchans = comedi_get_n_channels(d, sdev);
220 if (nchans <= 0) {
221 dev_err(dev->class_dev,
222 "comedi_get_n_channels() returned %d on minor %u subdev %d!\n",
223 nchans, minor, sdev);
224 return -EINVAL;
225 }
226 bdev = kmalloc(sizeof(*bdev), GFP_KERNEL);
227 if (!bdev)
228 return -ENOMEM;
229
230 bdev->dev = d;
231 bdev->minor = minor;
232 bdev->subdev = sdev;
233 bdev->nchans = nchans;
234 devpriv->nchans += nchans;
235
236 /*
237 * Now put bdev pointer at end of devpriv->devs array
238 * list..
239 */
240
241 /* ergh.. ugly.. we need to realloc :( */
242 devs = krealloc(devpriv->devs,
243 (devpriv->ndevs + 1) * sizeof(*devs),
244 GFP_KERNEL);
245 if (!devs) {
246 dev_err(dev->class_dev,
247 "Could not allocate memory. Out of memory?\n");
248 kfree(bdev);
249 return -ENOMEM;
250 }
251 devpriv->devs = devs;
252 devpriv->devs[devpriv->ndevs++] = bdev;
253 {
254 /* Append dev:subdev to devpriv->name */
255 char buf[20];
256
257 snprintf(buf, sizeof(buf), "%u:%u ",
258 bdev->minor, bdev->subdev);
259 strlcat(devpriv->name, buf,
260 sizeof(devpriv->name));
261 }
262 }
263 }
264
265 if (!devpriv->nchans) {
266 dev_err(dev->class_dev, "No channels found!\n");
267 return -EINVAL;
268 }
269
270 return 0;
271 }
272
273 static int bonding_attach(struct comedi_device *dev,
274 struct comedi_devconfig *it)
275 {
276 struct comedi_bond_private *devpriv;
277 struct comedi_subdevice *s;
278 int ret;
279
280 devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
281 if (!devpriv)
282 return -ENOMEM;
283
284 /*
285 * Setup our bonding from config params.. sets up our private struct..
286 */
287 ret = do_dev_config(dev, it);
288 if (ret)
289 return ret;
290
291 dev->board_name = devpriv->name;
292
293 ret = comedi_alloc_subdevices(dev, 1);
294 if (ret)
295 return ret;
296
297 s = &dev->subdevices[0];
298 s->type = COMEDI_SUBD_DIO;
299 s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
300 s->n_chan = devpriv->nchans;
301 s->maxdata = 1;
302 s->range_table = &range_digital;
303 s->insn_bits = bonding_dio_insn_bits;
304 s->insn_config = bonding_dio_insn_config;
305
306 dev_info(dev->class_dev,
307 "%s: %s attached, %u channels from %u devices\n",
308 dev->driver->driver_name, dev->board_name,
309 devpriv->nchans, devpriv->ndevs);
310
311 return 0;
312 }
313
314 static void bonding_detach(struct comedi_device *dev)
315 {
316 struct comedi_bond_private *devpriv = dev->private;
317
318 if (devpriv && devpriv->devs) {
319 DECLARE_BITMAP(devs_closed, COMEDI_NUM_BOARD_MINORS);
320
321 memset(&devs_closed, 0, sizeof(devs_closed));
322 while (devpriv->ndevs--) {
323 struct bonded_device *bdev;
324
325 bdev = devpriv->devs[devpriv->ndevs];
326 if (!bdev)
327 continue;
328 if (!test_and_set_bit(bdev->minor, devs_closed))
329 comedi_close(bdev->dev);
330 kfree(bdev);
331 }
332 kfree(devpriv->devs);
333 devpriv->devs = NULL;
334 }
335 }
336
337 static struct comedi_driver bonding_driver = {
338 .driver_name = "comedi_bond",
339 .module = THIS_MODULE,
340 .attach = bonding_attach,
341 .detach = bonding_detach,
342 };
343 module_comedi_driver(bonding_driver);
344
345 MODULE_AUTHOR("Calin A. Culianu");
346 MODULE_DESCRIPTION("comedi_bond: A driver for COMEDI to bond multiple COMEDI devices together as one.");
347 MODULE_LICENSE("GPL");