716 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * Copyright (c) 2011 Jonathan Cameron4 *5 * A reference industrial I/O driver to illustrate the functionality available.6 *7 * There are numerous real drivers to illustrate the finer points.8 * The purpose of this driver is to provide a driver with far more comments9 * and explanatory notes than any 'real' driver would have.10 * Anyone starting out writing an IIO driver should first make sure they11 * understand all of this driver except those bits specifically marked12 * as being present to allow us to 'fake' the presence of hardware.13 */14#include <linux/kernel.h>15#include <linux/slab.h>16#include <linux/module.h>17#include <linux/string.h>18 19#include <linux/iio/iio.h>20#include <linux/iio/sysfs.h>21#include <linux/iio/events.h>22#include <linux/iio/buffer.h>23#include <linux/iio/sw_device.h>24#include "iio_simple_dummy.h"25 26static const struct config_item_type iio_dummy_type = {27 .ct_owner = THIS_MODULE,28};29 30/**31 * struct iio_dummy_accel_calibscale - realworld to register mapping32 * @val: first value in read_raw - here integer part.33 * @val2: second value in read_raw etc - here micro part.34 * @regval: register value - magic device specific numbers.35 */36struct iio_dummy_accel_calibscale {37 int val;38 int val2;39 int regval; /* what would be written to hardware */40};41 42static const struct iio_dummy_accel_calibscale dummy_scales[] = {43 { 0, 100, 0x8 }, /* 0.000100 */44 { 0, 133, 0x7 }, /* 0.000133 */45 { 733, 13, 0x9 }, /* 733.000013 */46};47 48#ifdef CONFIG_IIO_SIMPLE_DUMMY_EVENTS49 50/*51 * simple event - triggered when value rises above52 * a threshold53 */54static const struct iio_event_spec iio_dummy_event = {55 .type = IIO_EV_TYPE_THRESH,56 .dir = IIO_EV_DIR_RISING,57 .mask_separate = BIT(IIO_EV_INFO_VALUE) | BIT(IIO_EV_INFO_ENABLE),58};59 60/*61 * simple step detect event - triggered when a step is detected62 */63static const struct iio_event_spec step_detect_event = {64 .type = IIO_EV_TYPE_CHANGE,65 .dir = IIO_EV_DIR_NONE,66 .mask_separate = BIT(IIO_EV_INFO_ENABLE),67};68 69/*70 * simple transition event - triggered when the reported running confidence71 * value rises above a threshold value72 */73static const struct iio_event_spec iio_running_event = {74 .type = IIO_EV_TYPE_THRESH,75 .dir = IIO_EV_DIR_RISING,76 .mask_separate = BIT(IIO_EV_INFO_VALUE) | BIT(IIO_EV_INFO_ENABLE),77};78 79/*80 * simple transition event - triggered when the reported walking confidence81 * value falls under a threshold value82 */83static const struct iio_event_spec iio_walking_event = {84 .type = IIO_EV_TYPE_THRESH,85 .dir = IIO_EV_DIR_FALLING,86 .mask_separate = BIT(IIO_EV_INFO_VALUE) | BIT(IIO_EV_INFO_ENABLE),87};88#endif89 90/*91 * iio_dummy_channels - Description of available channels92 *93 * This array of structures tells the IIO core about what the device94 * actually provides for a given channel.95 */96static const struct iio_chan_spec iio_dummy_channels[] = {97 /* indexed ADC channel in_voltage0_raw etc */98 {99 .type = IIO_VOLTAGE,100 /* Channel has a numeric index of 0 */101 .indexed = 1,102 .channel = 0,103 /* What other information is available? */104 .info_mask_separate =105 /*106 * in_voltage0_raw107 * Raw (unscaled no bias removal etc) measurement108 * from the device.109 */110 BIT(IIO_CHAN_INFO_RAW) |111 /*112 * in_voltage0_offset113 * Offset for userspace to apply prior to scale114 * when converting to standard units (microvolts)115 */116 BIT(IIO_CHAN_INFO_OFFSET) |117 /*118 * in_voltage0_scale119 * Multipler for userspace to apply post offset120 * when converting to standard units (microvolts)121 */122 BIT(IIO_CHAN_INFO_SCALE),123 /*124 * sampling_frequency125 * The frequency in Hz at which the channels are sampled126 */127 .info_mask_shared_by_dir = BIT(IIO_CHAN_INFO_SAMP_FREQ),128 /* The ordering of elements in the buffer via an enum */129 .scan_index = DUMMY_INDEX_VOLTAGE_0,130 .scan_type = { /* Description of storage in buffer */131 .sign = 'u', /* unsigned */132 .realbits = 13, /* 13 bits */133 .storagebits = 16, /* 16 bits used for storage */134 .shift = 0, /* zero shift */135 },136#ifdef CONFIG_IIO_SIMPLE_DUMMY_EVENTS137 .event_spec = &iio_dummy_event,138 .num_event_specs = 1,139#endif /* CONFIG_IIO_SIMPLE_DUMMY_EVENTS */140 },141 /* Differential ADC channel in_voltage1-voltage2_raw etc*/142 {143 .type = IIO_VOLTAGE,144 .differential = 1,145 /*146 * Indexing for differential channels uses channel147 * for the positive part, channel2 for the negative.148 */149 .indexed = 1,150 .channel = 1,151 .channel2 = 2,152 /*153 * in_voltage1-voltage2_raw154 * Raw (unscaled no bias removal etc) measurement155 * from the device.156 */157 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),158 /*159 * in_voltage-voltage_scale160 * Shared version of scale - shared by differential161 * input channels of type IIO_VOLTAGE.162 */163 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),164 /*165 * sampling_frequency166 * The frequency in Hz at which the channels are sampled167 */168 .scan_index = DUMMY_INDEX_DIFFVOLTAGE_1M2,169 .scan_type = { /* Description of storage in buffer */170 .sign = 's', /* signed */171 .realbits = 12, /* 12 bits */172 .storagebits = 16, /* 16 bits used for storage */173 .shift = 0, /* zero shift */174 },175 },176 /* Differential ADC channel in_voltage3-voltage4_raw etc*/177 {178 .type = IIO_VOLTAGE,179 .differential = 1,180 .indexed = 1,181 .channel = 3,182 .channel2 = 4,183 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),184 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),185 .info_mask_shared_by_dir = BIT(IIO_CHAN_INFO_SAMP_FREQ),186 .scan_index = DUMMY_INDEX_DIFFVOLTAGE_3M4,187 .scan_type = {188 .sign = 's',189 .realbits = 11,190 .storagebits = 16,191 .shift = 0,192 },193 },194 /*195 * 'modified' (i.e. axis specified) acceleration channel196 * in_accel_z_raw197 */198 {199 .type = IIO_ACCEL,200 .modified = 1,201 /* Channel 2 is use for modifiers */202 .channel2 = IIO_MOD_X,203 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |204 /*205 * Internal bias and gain correction values. Applied206 * by the hardware or driver prior to userspace207 * seeing the readings. Typically part of hardware208 * calibration.209 */210 BIT(IIO_CHAN_INFO_CALIBSCALE) |211 BIT(IIO_CHAN_INFO_CALIBBIAS),212 .info_mask_shared_by_dir = BIT(IIO_CHAN_INFO_SAMP_FREQ),213 .scan_index = DUMMY_INDEX_ACCELX,214 .scan_type = { /* Description of storage in buffer */215 .sign = 's', /* signed */216 .realbits = 16, /* 16 bits */217 .storagebits = 16, /* 16 bits used for storage */218 .shift = 0, /* zero shift */219 },220 },221 /*222 * Convenience macro for timestamps. 4 is the index in223 * the buffer.224 */225 IIO_CHAN_SOFT_TIMESTAMP(4),226 /* DAC channel out_voltage0_raw */227 {228 .type = IIO_VOLTAGE,229 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),230 .scan_index = -1, /* No buffer support */231 .output = 1,232 .indexed = 1,233 .channel = 0,234 },235 {236 .type = IIO_STEPS,237 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_ENABLE) |238 BIT(IIO_CHAN_INFO_CALIBHEIGHT),239 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),240 .scan_index = -1, /* No buffer support */241#ifdef CONFIG_IIO_SIMPLE_DUMMY_EVENTS242 .event_spec = &step_detect_event,243 .num_event_specs = 1,244#endif /* CONFIG_IIO_SIMPLE_DUMMY_EVENTS */245 },246 {247 .type = IIO_ACTIVITY,248 .modified = 1,249 .channel2 = IIO_MOD_RUNNING,250 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),251 .scan_index = -1, /* No buffer support */252#ifdef CONFIG_IIO_SIMPLE_DUMMY_EVENTS253 .event_spec = &iio_running_event,254 .num_event_specs = 1,255#endif /* CONFIG_IIO_SIMPLE_DUMMY_EVENTS */256 },257 {258 .type = IIO_ACTIVITY,259 .modified = 1,260 .channel2 = IIO_MOD_WALKING,261 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),262 .scan_index = -1, /* No buffer support */263#ifdef CONFIG_IIO_SIMPLE_DUMMY_EVENTS264 .event_spec = &iio_walking_event,265 .num_event_specs = 1,266#endif /* CONFIG_IIO_SIMPLE_DUMMY_EVENTS */267 },268};269 270/**271 * iio_dummy_read_raw() - data read function.272 * @indio_dev: the struct iio_dev associated with this device instance273 * @chan: the channel whose data is to be read274 * @val: first element of returned value (typically INT)275 * @val2: second element of returned value (typically MICRO)276 * @mask: what we actually want to read as per the info_mask_*277 * in iio_chan_spec.278 */279static int iio_dummy_read_raw(struct iio_dev *indio_dev,280 struct iio_chan_spec const *chan,281 int *val,282 int *val2,283 long mask)284{285 struct iio_dummy_state *st = iio_priv(indio_dev);286 287 switch (mask) {288 case IIO_CHAN_INFO_RAW: /* magic value - channel value read */289 iio_device_claim_direct_scoped(return -EBUSY, indio_dev) {290 guard(mutex)(&st->lock);291 switch (chan->type) {292 case IIO_VOLTAGE:293 if (chan->output) {294 /* Set integer part to cached value */295 *val = st->dac_val;296 return IIO_VAL_INT;297 } else if (chan->differential) {298 if (chan->channel == 1)299 *val = st->differential_adc_val[0];300 else301 *val = st->differential_adc_val[1];302 return IIO_VAL_INT;303 } else {304 *val = st->single_ended_adc_val;305 return IIO_VAL_INT;306 }307 308 case IIO_ACCEL:309 *val = st->accel_val;310 return IIO_VAL_INT;311 default:312 return -EINVAL;313 }314 }315 unreachable();316 case IIO_CHAN_INFO_PROCESSED:317 iio_device_claim_direct_scoped(return -EBUSY, indio_dev) {318 guard(mutex)(&st->lock);319 switch (chan->type) {320 case IIO_STEPS:321 *val = st->steps;322 return IIO_VAL_INT;323 case IIO_ACTIVITY:324 switch (chan->channel2) {325 case IIO_MOD_RUNNING:326 *val = st->activity_running;327 return IIO_VAL_INT;328 case IIO_MOD_WALKING:329 *val = st->activity_walking;330 return IIO_VAL_INT;331 default:332 return -EINVAL;333 }334 default:335 return -EINVAL;336 }337 }338 unreachable();339 case IIO_CHAN_INFO_OFFSET:340 /* only single ended adc -> 7 */341 *val = 7;342 return IIO_VAL_INT;343 case IIO_CHAN_INFO_SCALE:344 switch (chan->type) {345 case IIO_VOLTAGE:346 switch (chan->differential) {347 case 0:348 /* only single ended adc -> 0.001333 */349 *val = 0;350 *val2 = 1333;351 return IIO_VAL_INT_PLUS_MICRO;352 case 1:353 /* all differential adc -> 0.000001344 */354 *val = 0;355 *val2 = 1344;356 return IIO_VAL_INT_PLUS_NANO;357 default:358 return -EINVAL;359 }360 default:361 return -EINVAL;362 }363 case IIO_CHAN_INFO_CALIBBIAS: {364 guard(mutex)(&st->lock);365 /* only the acceleration axis - read from cache */366 *val = st->accel_calibbias;367 return IIO_VAL_INT;368 }369 case IIO_CHAN_INFO_CALIBSCALE: {370 guard(mutex)(&st->lock);371 *val = st->accel_calibscale->val;372 *val2 = st->accel_calibscale->val2;373 return IIO_VAL_INT_PLUS_MICRO;374 }375 case IIO_CHAN_INFO_SAMP_FREQ:376 *val = 3;377 *val2 = 33;378 return IIO_VAL_INT_PLUS_NANO;379 case IIO_CHAN_INFO_ENABLE: {380 guard(mutex)(&st->lock);381 switch (chan->type) {382 case IIO_STEPS:383 *val = st->steps_enabled;384 return IIO_VAL_INT;385 default:386 return -EINVAL;387 }388 }389 case IIO_CHAN_INFO_CALIBHEIGHT: {390 guard(mutex)(&st->lock);391 switch (chan->type) {392 case IIO_STEPS:393 *val = st->height;394 return IIO_VAL_INT;395 default:396 return -EINVAL;397 }398 }399 default:400 return -EINVAL;401 }402}403 404/**405 * iio_dummy_write_raw() - data write function.406 * @indio_dev: the struct iio_dev associated with this device instance407 * @chan: the channel whose data is to be written408 * @val: first element of value to set (typically INT)409 * @val2: second element of value to set (typically MICRO)410 * @mask: what we actually want to write as per the info_mask_*411 * in iio_chan_spec.412 *413 * Note that all raw writes are assumed IIO_VAL_INT and info mask elements414 * are assumed to be IIO_INT_PLUS_MICRO unless the callback write_raw_get_fmt415 * in struct iio_info is provided by the driver.416 */417static int iio_dummy_write_raw(struct iio_dev *indio_dev,418 struct iio_chan_spec const *chan,419 int val,420 int val2,421 long mask)422{423 int i;424 struct iio_dummy_state *st = iio_priv(indio_dev);425 426 switch (mask) {427 case IIO_CHAN_INFO_RAW:428 switch (chan->type) {429 case IIO_VOLTAGE:430 if (chan->output == 0)431 return -EINVAL;432 433 scoped_guard(mutex, &st->lock) {434 /* Locking not required as writing single value */435 st->dac_val = val;436 }437 return 0;438 default:439 return -EINVAL;440 }441 case IIO_CHAN_INFO_PROCESSED:442 switch (chan->type) {443 case IIO_STEPS:444 scoped_guard(mutex, &st->lock) {445 st->steps = val;446 }447 return 0;448 case IIO_ACTIVITY:449 if (val < 0)450 val = 0;451 if (val > 100)452 val = 100;453 switch (chan->channel2) {454 case IIO_MOD_RUNNING:455 st->activity_running = val;456 return 0;457 case IIO_MOD_WALKING:458 st->activity_walking = val;459 return 0;460 default:461 return -EINVAL;462 }463 break;464 default:465 return -EINVAL;466 }467 case IIO_CHAN_INFO_CALIBSCALE: {468 guard(mutex)(&st->lock);469 /* Compare against table - hard matching here */470 for (i = 0; i < ARRAY_SIZE(dummy_scales); i++)471 if (val == dummy_scales[i].val &&472 val2 == dummy_scales[i].val2)473 break;474 if (i == ARRAY_SIZE(dummy_scales))475 return -EINVAL;476 st->accel_calibscale = &dummy_scales[i];477 return 0;478 }479 case IIO_CHAN_INFO_CALIBBIAS:480 scoped_guard(mutex, &st->lock) {481 st->accel_calibbias = val;482 }483 return 0;484 case IIO_CHAN_INFO_ENABLE:485 switch (chan->type) {486 case IIO_STEPS:487 scoped_guard(mutex, &st->lock) {488 st->steps_enabled = val;489 }490 return 0;491 default:492 return -EINVAL;493 }494 case IIO_CHAN_INFO_CALIBHEIGHT:495 switch (chan->type) {496 case IIO_STEPS:497 st->height = val;498 return 0;499 default:500 return -EINVAL;501 }502 503 default:504 return -EINVAL;505 }506}507 508/*509 * Device type specific information.510 */511static const struct iio_info iio_dummy_info = {512 .read_raw = &iio_dummy_read_raw,513 .write_raw = &iio_dummy_write_raw,514#ifdef CONFIG_IIO_SIMPLE_DUMMY_EVENTS515 .read_event_config = &iio_simple_dummy_read_event_config,516 .write_event_config = &iio_simple_dummy_write_event_config,517 .read_event_value = &iio_simple_dummy_read_event_value,518 .write_event_value = &iio_simple_dummy_write_event_value,519#endif /* CONFIG_IIO_SIMPLE_DUMMY_EVENTS */520};521 522/**523 * iio_dummy_init_device() - device instance specific init524 * @indio_dev: the iio device structure525 *526 * Most drivers have one of these to set up default values,527 * reset the device to known state etc.528 */529static int iio_dummy_init_device(struct iio_dev *indio_dev)530{531 struct iio_dummy_state *st = iio_priv(indio_dev);532 533 st->dac_val = 0;534 st->single_ended_adc_val = 73;535 st->differential_adc_val[0] = 33;536 st->differential_adc_val[1] = -34;537 st->accel_val = 34;538 st->accel_calibbias = -7;539 st->accel_calibscale = &dummy_scales[0];540 st->steps = 47;541 st->activity_running = 98;542 st->activity_walking = 4;543 544 return 0;545}546 547/**548 * iio_dummy_probe() - device instance probe549 * @name: name of this instance.550 *551 * Arguments are bus type specific.552 * I2C: iio_dummy_probe(struct i2c_client *client,553 * const struct i2c_device_id *id)554 * SPI: iio_dummy_probe(struct spi_device *spi)555 */556static struct iio_sw_device *iio_dummy_probe(const char *name)557{558 int ret;559 struct iio_dev *indio_dev;560 struct iio_dummy_state *st;561 struct iio_sw_device *swd;562 struct device *parent = NULL;563 564 /*565 * With hardware: Set the parent device.566 * parent = &spi->dev;567 * parent = &client->dev;568 */569 570 swd = kzalloc(sizeof(*swd), GFP_KERNEL);571 if (!swd)572 return ERR_PTR(-ENOMEM);573 574 /*575 * Allocate an IIO device.576 *577 * This structure contains all generic state578 * information about the device instance.579 * It also has a region (accessed by iio_priv()580 * for chip specific state information.581 */582 indio_dev = iio_device_alloc(parent, sizeof(*st));583 if (!indio_dev) {584 ret = -ENOMEM;585 goto error_free_swd;586 }587 588 st = iio_priv(indio_dev);589 mutex_init(&st->lock);590 591 iio_dummy_init_device(indio_dev);592 593 /*594 * Make the iio_dev struct available to remove function.595 * Bus equivalents596 * i2c_set_clientdata(client, indio_dev);597 * spi_set_drvdata(spi, indio_dev);598 */599 swd->device = indio_dev;600 601 /*602 * Set the device name.603 *604 * This is typically a part number and obtained from the module605 * id table.606 * e.g. for i2c and spi:607 * indio_dev->name = id->name;608 * indio_dev->name = spi_get_device_id(spi)->name;609 */610 indio_dev->name = kstrdup(name, GFP_KERNEL);611 if (!indio_dev->name) {612 ret = -ENOMEM;613 goto error_free_device;614 }615 616 /* Provide description of available channels */617 indio_dev->channels = iio_dummy_channels;618 indio_dev->num_channels = ARRAY_SIZE(iio_dummy_channels);619 620 /*621 * Provide device type specific interface functions and622 * constant data.623 */624 indio_dev->info = &iio_dummy_info;625 626 /* Specify that device provides sysfs type interfaces */627 indio_dev->modes = INDIO_DIRECT_MODE;628 629 ret = iio_simple_dummy_events_register(indio_dev);630 if (ret < 0)631 goto error_free_name;632 633 ret = iio_simple_dummy_configure_buffer(indio_dev);634 if (ret < 0)635 goto error_unregister_events;636 637 ret = iio_device_register(indio_dev);638 if (ret < 0)639 goto error_unconfigure_buffer;640 641 iio_swd_group_init_type_name(swd, name, &iio_dummy_type);642 643 return swd;644error_unconfigure_buffer:645 iio_simple_dummy_unconfigure_buffer(indio_dev);646error_unregister_events:647 iio_simple_dummy_events_unregister(indio_dev);648error_free_name:649 kfree(indio_dev->name);650error_free_device:651 iio_device_free(indio_dev);652error_free_swd:653 kfree(swd);654 return ERR_PTR(ret);655}656 657/**658 * iio_dummy_remove() - device instance removal function659 * @swd: pointer to software IIO device abstraction660 *661 * Parameters follow those of iio_dummy_probe for buses.662 */663static int iio_dummy_remove(struct iio_sw_device *swd)664{665 /*666 * Get a pointer to the device instance iio_dev structure667 * from the bus subsystem. E.g.668 * struct iio_dev *indio_dev = i2c_get_clientdata(client);669 * struct iio_dev *indio_dev = spi_get_drvdata(spi);670 */671 struct iio_dev *indio_dev = swd->device;672 673 /* Unregister the device */674 iio_device_unregister(indio_dev);675 676 /* Device specific code to power down etc */677 678 /* Buffered capture related cleanup */679 iio_simple_dummy_unconfigure_buffer(indio_dev);680 681 iio_simple_dummy_events_unregister(indio_dev);682 683 /* Free all structures */684 kfree(indio_dev->name);685 iio_device_free(indio_dev);686 687 return 0;688}689 690/*691 * module_iio_sw_device_driver() - device driver registration692 *693 * Varies depending on bus type of the device. As there is no device694 * here, call probe directly. For information on device registration695 * i2c:696 * Documentation/i2c/writing-clients.rst697 * spi:698 * Documentation/spi/spi-summary.rst699 */700static const struct iio_sw_device_ops iio_dummy_device_ops = {701 .probe = iio_dummy_probe,702 .remove = iio_dummy_remove,703};704 705static struct iio_sw_device_type iio_dummy_device = {706 .name = "dummy",707 .owner = THIS_MODULE,708 .ops = &iio_dummy_device_ops,709};710 711module_iio_sw_device_driver(iio_dummy_device);712 713MODULE_AUTHOR("Jonathan Cameron <jic23@kernel.org>");714MODULE_DESCRIPTION("IIO dummy driver");715MODULE_LICENSE("GPL v2");716