Lines Matching +full:quad +full:- +full:channel
1 // SPDX-License-Identifier: GPL-2.0
3 * Counter driver for the ACCES 104-QUAD-8
6 * This driver supports the ACCES 104-QUAD-8 and ACCES 104-QUAD-4.
27 MODULE_PARM_DESC(base, "ACCES 104-QUAD-8 base addresses");
32 * struct quad8_iio - IIO device private data structure
102 const int base_offset = priv->base + 2 * chan->channel; in quad8_read_raw()
107 if (chan->type == IIO_INDEX) { in quad8_read_raw()
108 *val = !!(inb(priv->base + QUAD8_REG_INDEX_INPUT_LEVELS) in quad8_read_raw()
109 & BIT(chan->channel)); in quad8_read_raw()
115 mutex_lock(&priv->lock); in quad8_read_raw()
124 mutex_unlock(&priv->lock); in quad8_read_raw()
128 *val = priv->ab_enable[chan->channel]; in quad8_read_raw()
132 *val2 = priv->quadrature_scale[chan->channel]; in quad8_read_raw()
136 return -EINVAL; in quad8_read_raw()
143 const int base_offset = priv->base + 2 * chan->channel; in quad8_write_raw()
149 if (chan->type == IIO_INDEX) in quad8_write_raw()
150 return -EINVAL; in quad8_write_raw()
152 /* Only 24-bit values are supported */ in quad8_write_raw()
154 return -EINVAL; in quad8_write_raw()
156 mutex_lock(&priv->lock); in quad8_write_raw()
172 val = priv->preset[chan->channel]; in quad8_write_raw()
181 mutex_unlock(&priv->lock); in quad8_write_raw()
187 return -EINVAL; in quad8_write_raw()
189 mutex_lock(&priv->lock); in quad8_write_raw()
191 priv->ab_enable[chan->channel] = val; in quad8_write_raw()
193 ior_cfg = val | priv->preset_enable[chan->channel] << 1; in quad8_write_raw()
198 mutex_unlock(&priv->lock); in quad8_write_raw()
202 mutex_lock(&priv->lock); in quad8_write_raw()
205 if (!priv->quadrature_mode[chan->channel] && in quad8_write_raw()
207 mutex_unlock(&priv->lock); in quad8_write_raw()
208 return -EINVAL; in quad8_write_raw()
213 priv->quadrature_scale[chan->channel] = 0; in quad8_write_raw()
217 priv->quadrature_scale[chan->channel] = 1; in quad8_write_raw()
220 priv->quadrature_scale[chan->channel] = 2; in quad8_write_raw()
223 mutex_unlock(&priv->lock); in quad8_write_raw()
224 return -EINVAL; in quad8_write_raw()
227 mutex_unlock(&priv->lock); in quad8_write_raw()
228 return -EINVAL; in quad8_write_raw()
231 mutex_unlock(&priv->lock); in quad8_write_raw()
235 return -EINVAL; in quad8_write_raw()
248 return snprintf(buf, PAGE_SIZE, "%u\n", priv->preset[chan->channel]); in quad8_read_preset()
255 const int base_offset = priv->base + 2 * chan->channel; in quad8_write_preset()
264 /* Only 24-bit values are supported */ in quad8_write_preset()
266 return -EINVAL; in quad8_write_preset()
268 mutex_lock(&priv->lock); in quad8_write_preset()
270 priv->preset[chan->channel] = preset; in quad8_write_preset()
279 mutex_unlock(&priv->lock); in quad8_write_preset()
290 !priv->preset_enable[chan->channel]); in quad8_read_set_to_preset_on_index()
298 const int base_offset = priv->base + 2 * chan->channel + 1; in quad8_write_set_to_preset_on_index()
310 mutex_lock(&priv->lock); in quad8_write_set_to_preset_on_index()
312 priv->preset_enable[chan->channel] = preset_enable; in quad8_write_set_to_preset_on_index()
314 ior_cfg = priv->ab_enable[chan->channel] | in quad8_write_set_to_preset_on_index()
320 mutex_unlock(&priv->lock); in quad8_write_set_to_preset_on_index()
334 const int base_offset = priv->base + 2 * chan->channel + 1; in quad8_get_noise_error()
354 const int base_offset = priv->base + 2 * chan->channel + 1; in quad8_get_count_direction()
368 "non-recycle",
369 "modulo-n"
377 const int base_offset = priv->base + 2 * chan->channel + 1; in quad8_set_count_mode()
379 mutex_lock(&priv->lock); in quad8_set_count_mode()
381 priv->count_mode[chan->channel] = cnt_mode; in quad8_set_count_mode()
384 if (priv->quadrature_mode[chan->channel]) in quad8_set_count_mode()
385 mode_cfg |= (priv->quadrature_scale[chan->channel] + 1) << 3; in quad8_set_count_mode()
390 mutex_unlock(&priv->lock); in quad8_set_count_mode()
400 return priv->count_mode[chan->channel]; in quad8_get_count_mode()
411 "non-synchronous",
419 const int base_offset = priv->base + 2 * chan->channel + 1; in quad8_set_synchronous_mode()
422 mutex_lock(&priv->lock); in quad8_set_synchronous_mode()
424 idr_cfg |= priv->index_polarity[chan->channel] << 1; in quad8_set_synchronous_mode()
426 /* Index function must be non-synchronous in non-quadrature mode */ in quad8_set_synchronous_mode()
427 if (synchronous_mode && !priv->quadrature_mode[chan->channel]) { in quad8_set_synchronous_mode()
428 mutex_unlock(&priv->lock); in quad8_set_synchronous_mode()
429 return -EINVAL; in quad8_set_synchronous_mode()
432 priv->synchronous_mode[chan->channel] = synchronous_mode; in quad8_set_synchronous_mode()
437 mutex_unlock(&priv->lock); in quad8_set_synchronous_mode()
447 return priv->synchronous_mode[chan->channel]; in quad8_get_synchronous_mode()
458 "non-quadrature",
466 const int base_offset = priv->base + 2 * chan->channel + 1; in quad8_set_quadrature_mode()
469 mutex_lock(&priv->lock); in quad8_set_quadrature_mode()
471 mode_cfg = priv->count_mode[chan->channel] << 1; in quad8_set_quadrature_mode()
474 mode_cfg |= (priv->quadrature_scale[chan->channel] + 1) << 3; in quad8_set_quadrature_mode()
477 priv->quadrature_scale[chan->channel] = 0; in quad8_set_quadrature_mode()
479 /* Synchronous function not supported in non-quadrature mode */ in quad8_set_quadrature_mode()
480 if (priv->synchronous_mode[chan->channel]) in quad8_set_quadrature_mode()
484 priv->quadrature_mode[chan->channel] = quadrature_mode; in quad8_set_quadrature_mode()
489 mutex_unlock(&priv->lock); in quad8_set_quadrature_mode()
499 return priv->quadrature_mode[chan->channel]; in quad8_get_quadrature_mode()
518 const int base_offset = priv->base + 2 * chan->channel + 1; in quad8_set_index_polarity()
521 mutex_lock(&priv->lock); in quad8_set_index_polarity()
523 idr_cfg |= priv->synchronous_mode[chan->channel]; in quad8_set_index_polarity()
525 priv->index_polarity[chan->channel] = index_polarity; in quad8_set_index_polarity()
530 mutex_unlock(&priv->lock); in quad8_set_index_polarity()
540 return priv->index_polarity[chan->channel]; in quad8_get_index_polarity()
585 .channel = (_chan), \
594 .channel = (_chan), \
614 const struct quad8_iio *const priv = counter->priv; in quad8_signal_read()
618 if (signal->id < 16) in quad8_signal_read()
619 return -EINVAL; in quad8_signal_read()
621 state = inb(priv->base + QUAD8_REG_INDEX_INPUT_LEVELS) in quad8_signal_read()
622 & BIT(signal->id - 16); in quad8_signal_read()
632 struct quad8_iio *const priv = counter->priv; in quad8_count_read()
633 const int base_offset = priv->base + 2 * count->id; in quad8_count_read()
638 mutex_lock(&priv->lock); in quad8_count_read()
647 mutex_unlock(&priv->lock); in quad8_count_read()
655 struct quad8_iio *const priv = counter->priv; in quad8_count_write()
656 const int base_offset = priv->base + 2 * count->id; in quad8_count_write()
659 /* Only 24-bit values are supported */ in quad8_count_write()
661 return -EINVAL; in quad8_count_write()
663 mutex_lock(&priv->lock); in quad8_count_write()
679 val = priv->preset[count->id]; in quad8_count_write()
688 mutex_unlock(&priv->lock); in quad8_count_write()
710 struct quad8_iio *const priv = counter->priv; in quad8_function_get()
711 const int id = count->id; in quad8_function_get()
713 mutex_lock(&priv->lock); in quad8_function_get()
715 if (priv->quadrature_mode[id]) in quad8_function_get()
716 switch (priv->quadrature_scale[id]) { in quad8_function_get()
730 mutex_unlock(&priv->lock); in quad8_function_get()
738 struct quad8_iio *const priv = counter->priv; in quad8_function_set()
739 const int id = count->id; in quad8_function_set()
740 unsigned int *const quadrature_mode = priv->quadrature_mode + id; in quad8_function_set()
741 unsigned int *const scale = priv->quadrature_scale + id; in quad8_function_set()
742 unsigned int *const synchronous_mode = priv->synchronous_mode + id; in quad8_function_set()
743 const int base_offset = priv->base + 2 * id + 1; in quad8_function_set()
747 mutex_lock(&priv->lock); in quad8_function_set()
749 mode_cfg = priv->count_mode[id] << 1; in quad8_function_set()
750 idr_cfg = priv->index_polarity[id] << 1; in quad8_function_set()
758 /* Synchronous function not supported in non-quadrature mode */ in quad8_function_set()
786 mutex_unlock(&priv->lock); in quad8_function_set()
794 const struct quad8_iio *const priv = counter->priv; in quad8_direction_get()
796 const unsigned int flag_addr = priv->base + 2 * count->id + 1; in quad8_direction_get()
828 struct quad8_iio *const priv = counter->priv; in quad8_action_get()
831 const size_t signal_a_id = count->synapses[0].signal->id; in quad8_action_get()
835 if (synapse->signal->id >= 16) { in quad8_action_get()
836 if (priv->preset_enable[count->id]) in quad8_action_get()
854 if (synapse->signal->id == signal_a_id) in quad8_action_get()
858 if (synapse->signal->id == signal_a_id) { in quad8_action_get()
868 if (synapse->signal->id == signal_a_id) in quad8_action_get()
891 const struct quad8_iio *const priv = counter->priv; in quad8_index_polarity_get()
892 const size_t channel_id = signal->id - 16; in quad8_index_polarity_get()
894 *index_polarity = priv->index_polarity[channel_id]; in quad8_index_polarity_get()
902 struct quad8_iio *const priv = counter->priv; in quad8_index_polarity_set()
903 const size_t channel_id = signal->id - 16; in quad8_index_polarity_set()
904 const int base_offset = priv->base + 2 * channel_id + 1; in quad8_index_polarity_set()
907 mutex_lock(&priv->lock); in quad8_index_polarity_set()
909 idr_cfg |= priv->synchronous_mode[channel_id]; in quad8_index_polarity_set()
911 priv->index_polarity[channel_id] = index_polarity; in quad8_index_polarity_set()
916 mutex_unlock(&priv->lock); in quad8_index_polarity_set()
931 const struct quad8_iio *const priv = counter->priv; in quad8_synchronous_mode_get()
932 const size_t channel_id = signal->id - 16; in quad8_synchronous_mode_get()
934 *synchronous_mode = priv->synchronous_mode[channel_id]; in quad8_synchronous_mode_get()
942 struct quad8_iio *const priv = counter->priv; in quad8_synchronous_mode_set()
943 const size_t channel_id = signal->id - 16; in quad8_synchronous_mode_set()
944 const int base_offset = priv->base + 2 * channel_id + 1; in quad8_synchronous_mode_set()
947 mutex_lock(&priv->lock); in quad8_synchronous_mode_set()
949 idr_cfg |= priv->index_polarity[channel_id] << 1; in quad8_synchronous_mode_set()
951 /* Index function must be non-synchronous in non-quadrature mode */ in quad8_synchronous_mode_set()
952 if (synchronous_mode && !priv->quadrature_mode[channel_id]) { in quad8_synchronous_mode_set()
953 mutex_unlock(&priv->lock); in quad8_synchronous_mode_set()
954 return -EINVAL; in quad8_synchronous_mode_set()
957 priv->synchronous_mode[channel_id] = synchronous_mode; in quad8_synchronous_mode_set()
962 mutex_unlock(&priv->lock); in quad8_synchronous_mode_set()
984 const struct quad8_iio *const priv = counter->priv; in quad8_count_mode_get()
986 /* Map 104-QUAD-8 count mode to Generic Counter count mode */ in quad8_count_mode_get()
987 switch (priv->count_mode[count->id]) { in quad8_count_mode_get()
1008 struct quad8_iio *const priv = counter->priv; in quad8_count_mode_set()
1010 const int base_offset = priv->base + 2 * count->id + 1; in quad8_count_mode_set()
1012 /* Map Generic Counter count mode to 104-QUAD-8 count mode */ in quad8_count_mode_set()
1028 mutex_lock(&priv->lock); in quad8_count_mode_set()
1030 priv->count_mode[count->id] = cnt_mode; in quad8_count_mode_set()
1036 if (priv->quadrature_mode[count->id]) in quad8_count_mode_set()
1037 mode_cfg |= (priv->quadrature_scale[count->id] + 1) << 3; in quad8_count_mode_set()
1042 mutex_unlock(&priv->lock); in quad8_count_mode_set()
1067 const struct quad8_iio *const priv = counter->priv; in quad8_count_enable_read()
1069 return sprintf(buf, "%u\n", priv->ab_enable[count->id]); in quad8_count_enable_read()
1075 struct quad8_iio *const priv = counter->priv; in quad8_count_enable_write()
1076 const int base_offset = priv->base + 2 * count->id; in quad8_count_enable_write()
1085 mutex_lock(&priv->lock); in quad8_count_enable_write()
1087 priv->ab_enable[count->id] = ab_enable; in quad8_count_enable_write()
1089 ior_cfg = ab_enable | priv->preset_enable[count->id] << 1; in quad8_count_enable_write()
1094 mutex_unlock(&priv->lock); in quad8_count_enable_write()
1102 const struct quad8_iio *const priv = counter->priv; in quad8_error_noise_get()
1103 const int base_offset = priv->base + 2 * count->id + 1; in quad8_error_noise_get()
1119 const struct quad8_iio *const priv = counter->priv; in quad8_count_preset_read()
1121 return sprintf(buf, "%u\n", priv->preset[count->id]); in quad8_count_preset_read()
1127 const unsigned int base_offset = quad8iio->base + 2 * id; in quad8_preset_register_set()
1130 quad8iio->preset[id] = preset; in quad8_preset_register_set()
1143 struct quad8_iio *const priv = counter->priv; in quad8_count_preset_write()
1151 /* Only 24-bit values are supported */ in quad8_count_preset_write()
1153 return -EINVAL; in quad8_count_preset_write()
1155 mutex_lock(&priv->lock); in quad8_count_preset_write()
1157 quad8_preset_register_set(priv, count->id, preset); in quad8_count_preset_write()
1159 mutex_unlock(&priv->lock); in quad8_count_preset_write()
1167 struct quad8_iio *const priv = counter->priv; in quad8_count_ceiling_read()
1169 mutex_lock(&priv->lock); in quad8_count_ceiling_read()
1171 /* Range Limit and Modulo-N count modes use preset value as ceiling */ in quad8_count_ceiling_read()
1172 switch (priv->count_mode[count->id]) { in quad8_count_ceiling_read()
1175 mutex_unlock(&priv->lock); in quad8_count_ceiling_read()
1176 return sprintf(buf, "%u\n", priv->preset[count->id]); in quad8_count_ceiling_read()
1179 mutex_unlock(&priv->lock); in quad8_count_ceiling_read()
1188 struct quad8_iio *const priv = counter->priv; in quad8_count_ceiling_write()
1196 /* Only 24-bit values are supported */ in quad8_count_ceiling_write()
1198 return -EINVAL; in quad8_count_ceiling_write()
1200 mutex_lock(&priv->lock); in quad8_count_ceiling_write()
1202 /* Range Limit and Modulo-N count modes use preset value as ceiling */ in quad8_count_ceiling_write()
1203 switch (priv->count_mode[count->id]) { in quad8_count_ceiling_write()
1206 quad8_preset_register_set(priv, count->id, ceiling); in quad8_count_ceiling_write()
1207 mutex_unlock(&priv->lock); in quad8_count_ceiling_write()
1211 mutex_unlock(&priv->lock); in quad8_count_ceiling_write()
1213 return -EINVAL; in quad8_count_ceiling_write()
1219 const struct quad8_iio *const priv = counter->priv; in quad8_count_preset_enable_read()
1221 return sprintf(buf, "%u\n", !priv->preset_enable[count->id]); in quad8_count_preset_enable_read()
1227 struct quad8_iio *const priv = counter->priv; in quad8_count_preset_enable_write()
1228 const int base_offset = priv->base + 2 * count->id + 1; in quad8_count_preset_enable_write()
1240 mutex_lock(&priv->lock); in quad8_count_preset_enable_write()
1242 priv->preset_enable[count->id] = preset_enable; in quad8_count_preset_enable_write()
1244 ior_cfg = priv->ab_enable[count->id] | (unsigned int)preset_enable << 1; in quad8_count_preset_enable_write()
1249 mutex_unlock(&priv->lock); in quad8_count_preset_enable_write()
1258 struct quad8_iio *const priv = counter->priv; in quad8_signal_cable_fault_read()
1259 const size_t channel_id = signal->id / 2; in quad8_signal_cable_fault_read()
1264 mutex_lock(&priv->lock); in quad8_signal_cable_fault_read()
1266 disabled = !(priv->cable_fault_enable & BIT(channel_id)); in quad8_signal_cable_fault_read()
1269 mutex_unlock(&priv->lock); in quad8_signal_cable_fault_read()
1270 return -EINVAL; in quad8_signal_cable_fault_read()
1274 status = inb(priv->base + QUAD8_DIFF_ENCODER_CABLE_STATUS); in quad8_signal_cable_fault_read()
1276 mutex_unlock(&priv->lock); in quad8_signal_cable_fault_read()
1278 /* Mask respective channel and invert logic */ in quad8_signal_cable_fault_read()
1288 const struct quad8_iio *const priv = counter->priv; in quad8_signal_cable_fault_enable_read()
1289 const size_t channel_id = signal->id / 2; in quad8_signal_cable_fault_enable_read()
1290 const unsigned int enb = !!(priv->cable_fault_enable & BIT(channel_id)); in quad8_signal_cable_fault_enable_read()
1299 struct quad8_iio *const priv = counter->priv; in quad8_signal_cable_fault_enable_write()
1300 const size_t channel_id = signal->id / 2; in quad8_signal_cable_fault_enable_write()
1309 mutex_lock(&priv->lock); in quad8_signal_cable_fault_enable_write()
1312 priv->cable_fault_enable |= BIT(channel_id); in quad8_signal_cable_fault_enable_write()
1314 priv->cable_fault_enable &= ~BIT(channel_id); in quad8_signal_cable_fault_enable_write()
1317 cable_fault_enable = ~priv->cable_fault_enable; in quad8_signal_cable_fault_enable_write()
1319 outb(cable_fault_enable, priv->base + QUAD8_DIFF_ENCODER_CABLE_STATUS); in quad8_signal_cable_fault_enable_write()
1321 mutex_unlock(&priv->lock); in quad8_signal_cable_fault_enable_write()
1329 const struct quad8_iio *const priv = counter->priv; in quad8_signal_fck_prescaler_read()
1330 const size_t channel_id = signal->id / 2; in quad8_signal_fck_prescaler_read()
1332 return sprintf(buf, "%u\n", priv->fck_prescaler[channel_id]); in quad8_signal_fck_prescaler_read()
1339 struct quad8_iio *const priv = counter->priv; in quad8_signal_fck_prescaler_write()
1340 const size_t channel_id = signal->id / 2; in quad8_signal_fck_prescaler_write()
1341 const int base_offset = priv->base + 2 * channel_id; in quad8_signal_fck_prescaler_write()
1349 mutex_lock(&priv->lock); in quad8_signal_fck_prescaler_write()
1351 priv->fck_prescaler[channel_id] = prescaler; in quad8_signal_fck_prescaler_write()
1361 mutex_unlock(&priv->lock); in quad8_signal_fck_prescaler_write()
1405 QUAD8_QUAD_SIGNAL(0, "Channel 1 Quadrature A"),
1406 QUAD8_QUAD_SIGNAL(1, "Channel 1 Quadrature B"),
1407 QUAD8_QUAD_SIGNAL(2, "Channel 2 Quadrature A"),
1408 QUAD8_QUAD_SIGNAL(3, "Channel 2 Quadrature B"),
1409 QUAD8_QUAD_SIGNAL(4, "Channel 3 Quadrature A"),
1410 QUAD8_QUAD_SIGNAL(5, "Channel 3 Quadrature B"),
1411 QUAD8_QUAD_SIGNAL(6, "Channel 4 Quadrature A"),
1412 QUAD8_QUAD_SIGNAL(7, "Channel 4 Quadrature B"),
1413 QUAD8_QUAD_SIGNAL(8, "Channel 5 Quadrature A"),
1414 QUAD8_QUAD_SIGNAL(9, "Channel 5 Quadrature B"),
1415 QUAD8_QUAD_SIGNAL(10, "Channel 6 Quadrature A"),
1416 QUAD8_QUAD_SIGNAL(11, "Channel 6 Quadrature B"),
1417 QUAD8_QUAD_SIGNAL(12, "Channel 7 Quadrature A"),
1418 QUAD8_QUAD_SIGNAL(13, "Channel 7 Quadrature B"),
1419 QUAD8_QUAD_SIGNAL(14, "Channel 8 Quadrature A"),
1420 QUAD8_QUAD_SIGNAL(15, "Channel 8 Quadrature B"),
1421 QUAD8_INDEX_SIGNAL(16, "Channel 1 Index"),
1422 QUAD8_INDEX_SIGNAL(17, "Channel 2 Index"),
1423 QUAD8_INDEX_SIGNAL(18, "Channel 3 Index"),
1424 QUAD8_INDEX_SIGNAL(19, "Channel 4 Index"),
1425 QUAD8_INDEX_SIGNAL(20, "Channel 5 Index"),
1426 QUAD8_INDEX_SIGNAL(21, "Channel 6 Index"),
1427 QUAD8_INDEX_SIGNAL(22, "Channel 7 Index"),
1428 QUAD8_INDEX_SIGNAL(23, "Channel 8 Index")
1503 QUAD8_COUNT(0, "Channel 1 Count"),
1504 QUAD8_COUNT(1, "Channel 2 Count"),
1505 QUAD8_COUNT(2, "Channel 3 Count"),
1506 QUAD8_COUNT(3, "Channel 4 Count"),
1507 QUAD8_COUNT(4, "Channel 5 Count"),
1508 QUAD8_COUNT(5, "Channel 6 Count"),
1509 QUAD8_COUNT(6, "Channel 7 Count"),
1510 QUAD8_COUNT(7, "Channel 8 Count")
1522 dev_err(dev, "Unable to lock port addresses (0x%X-0x%X)\n", in quad8_probe()
1524 return -EBUSY; in quad8_probe()
1530 return -ENOMEM; in quad8_probe()
1533 indio_dev->info = &quad8_info; in quad8_probe()
1534 indio_dev->modes = INDIO_DIRECT_MODE; in quad8_probe()
1535 indio_dev->num_channels = ARRAY_SIZE(quad8_channels); in quad8_probe()
1536 indio_dev->channels = quad8_channels; in quad8_probe()
1537 indio_dev->name = dev_name(dev); in quad8_probe()
1541 quad8iio->counter.name = dev_name(dev); in quad8_probe()
1542 quad8iio->counter.parent = dev; in quad8_probe()
1543 quad8iio->counter.ops = &quad8_ops; in quad8_probe()
1544 quad8iio->counter.counts = quad8_counts; in quad8_probe()
1545 quad8iio->counter.num_counts = ARRAY_SIZE(quad8_counts); in quad8_probe()
1546 quad8iio->counter.signals = quad8_signals; in quad8_probe()
1547 quad8iio->counter.num_signals = ARRAY_SIZE(quad8_signals); in quad8_probe()
1548 quad8iio->counter.priv = quad8iio; in quad8_probe()
1549 quad8iio->base = base[id]; in quad8_probe()
1552 mutex_init(&quad8iio->lock); in quad8_probe()
1574 /* Binary encoding; Normal count; non-quadrature mode */ in quad8_probe()
1592 return devm_counter_register(dev, &quad8iio->counter); in quad8_probe()
1598 .name = "104-quad-8"
1605 MODULE_DESCRIPTION("ACCES 104-QUAD-8 IIO driver");