1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2011 Jonathan Cameron 4 * 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 comments 9 * and explanatory notes than any 'real' driver would have. 10 * Anyone starting out writing an IIO driver should first make sure they 11 * understand all of this driver except those bits specifically marked 12 * 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 26 static 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 mapping 32 * @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 */ 36 struct iio_dummy_accel_calibscale { 37 int val; 38 int val2; 39 int regval; /* what would be written to hardware */ 40 }; 41 42 static 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_EVENTS 49 50 /* 51 * simple event - triggered when value rises above 52 * a threshold 53 */ 54 static 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 detected 62 */ 63 static 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 confidence 71 * value rises above a threshold value 72 */ 73 static 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 confidence 81 * value falls under a threshold value 82 */ 83 static 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 #endif 89 90 /* 91 * iio_dummy_channels - Description of available channels 92 * 93 * This array of structures tells the IIO core about what the device 94 * actually provides for a given channel. 95 */ 96 static 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_raw 107 * Raw (unscaled no bias removal etc) measurement 108 * from the device. 109 */ 110 BIT(IIO_CHAN_INFO_RAW) | 111 /* 112 * in_voltage0_offset 113 * Offset for userspace to apply prior to scale 114 * when converting to standard units (microvolts) 115 */ 116 BIT(IIO_CHAN_INFO_OFFSET) | 117 /* 118 * in_voltage0_scale 119 * Multipler for userspace to apply post offset 120 * when converting to standard units (microvolts) 121 */ 122 BIT(IIO_CHAN_INFO_SCALE), 123 /* 124 * sampling_frequency 125 * The frequency in Hz at which the channels are sampled 126 */ 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_EVENTS 137 .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 channel 147 * for the positive part, channel2 for the negative. 148 */ 149 .indexed = 1, 150 .channel = 1, 151 .channel2 = 2, 152 /* 153 * in_voltage1-voltage2_raw 154 * Raw (unscaled no bias removal etc) measurement 155 * from the device. 156 */ 157 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), 158 /* 159 * in_voltage-voltage_scale 160 * Shared version of scale - shared by differential 161 * input channels of type IIO_VOLTAGE. 162 */ 163 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), 164 /* 165 * sampling_frequency 166 * The frequency in Hz at which the channels are sampled 167 */ 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 channel 196 * in_accel_z_raw 197 */ 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. Applied 206 * by the hardware or driver prior to userspace 207 * seeing the readings. Typically part of hardware 208 * 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 in 223 * 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_EVENTS 242 .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_EVENTS 253 .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_EVENTS 264 .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 instance 273 * @chan: the channel whose data is to be read 274 * @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 */ 279 static 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 int ret = -EINVAL; 287 288 mutex_lock(&st->lock); 289 switch (mask) { 290 case IIO_CHAN_INFO_RAW: /* magic value - channel value read */ 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 ret = IIO_VAL_INT; 297 } else if (chan->differential) { 298 if (chan->channel == 1) 299 *val = st->differential_adc_val[0]; 300 else 301 *val = st->differential_adc_val[1]; 302 ret = IIO_VAL_INT; 303 } else { 304 *val = st->single_ended_adc_val; 305 ret = IIO_VAL_INT; 306 } 307 break; 308 case IIO_ACCEL: 309 *val = st->accel_val; 310 ret = IIO_VAL_INT; 311 break; 312 default: 313 break; 314 } 315 break; 316 case IIO_CHAN_INFO_PROCESSED: 317 switch (chan->type) { 318 case IIO_STEPS: 319 *val = st->steps; 320 ret = IIO_VAL_INT; 321 break; 322 case IIO_ACTIVITY: 323 switch (chan->channel2) { 324 case IIO_MOD_RUNNING: 325 *val = st->activity_running; 326 ret = IIO_VAL_INT; 327 break; 328 case IIO_MOD_WALKING: 329 *val = st->activity_walking; 330 ret = IIO_VAL_INT; 331 break; 332 default: 333 break; 334 } 335 break; 336 default: 337 break; 338 } 339 break; 340 case IIO_CHAN_INFO_OFFSET: 341 /* only single ended adc -> 7 */ 342 *val = 7; 343 ret = IIO_VAL_INT; 344 break; 345 case IIO_CHAN_INFO_SCALE: 346 switch (chan->type) { 347 case IIO_VOLTAGE: 348 switch (chan->differential) { 349 case 0: 350 /* only single ended adc -> 0.001333 */ 351 *val = 0; 352 *val2 = 1333; 353 ret = IIO_VAL_INT_PLUS_MICRO; 354 break; 355 case 1: 356 /* all differential adc -> 0.000001344 */ 357 *val = 0; 358 *val2 = 1344; 359 ret = IIO_VAL_INT_PLUS_NANO; 360 } 361 break; 362 default: 363 break; 364 } 365 break; 366 case IIO_CHAN_INFO_CALIBBIAS: 367 /* only the acceleration axis - read from cache */ 368 *val = st->accel_calibbias; 369 ret = IIO_VAL_INT; 370 break; 371 case IIO_CHAN_INFO_CALIBSCALE: 372 *val = st->accel_calibscale->val; 373 *val2 = st->accel_calibscale->val2; 374 ret = IIO_VAL_INT_PLUS_MICRO; 375 break; 376 case IIO_CHAN_INFO_SAMP_FREQ: 377 *val = 3; 378 *val2 = 33; 379 ret = IIO_VAL_INT_PLUS_NANO; 380 break; 381 case IIO_CHAN_INFO_ENABLE: 382 switch (chan->type) { 383 case IIO_STEPS: 384 *val = st->steps_enabled; 385 ret = IIO_VAL_INT; 386 break; 387 default: 388 break; 389 } 390 break; 391 case IIO_CHAN_INFO_CALIBHEIGHT: 392 switch (chan->type) { 393 case IIO_STEPS: 394 *val = st->height; 395 ret = IIO_VAL_INT; 396 break; 397 default: 398 break; 399 } 400 break; 401 402 default: 403 break; 404 } 405 mutex_unlock(&st->lock); 406 return ret; 407 } 408 409 /** 410 * iio_dummy_write_raw() - data write function. 411 * @indio_dev: the struct iio_dev associated with this device instance 412 * @chan: the channel whose data is to be written 413 * @val: first element of value to set (typically INT) 414 * @val2: second element of value to set (typically MICRO) 415 * @mask: what we actually want to write as per the info_mask_* 416 * in iio_chan_spec. 417 * 418 * Note that all raw writes are assumed IIO_VAL_INT and info mask elements 419 * are assumed to be IIO_INT_PLUS_MICRO unless the callback write_raw_get_fmt 420 * in struct iio_info is provided by the driver. 421 */ 422 static int iio_dummy_write_raw(struct iio_dev *indio_dev, 423 struct iio_chan_spec const *chan, 424 int val, 425 int val2, 426 long mask) 427 { 428 int i; 429 int ret = 0; 430 struct iio_dummy_state *st = iio_priv(indio_dev); 431 432 switch (mask) { 433 case IIO_CHAN_INFO_RAW: 434 switch (chan->type) { 435 case IIO_VOLTAGE: 436 if (chan->output == 0) 437 return -EINVAL; 438 439 /* Locking not required as writing single value */ 440 mutex_lock(&st->lock); 441 st->dac_val = val; 442 mutex_unlock(&st->lock); 443 return 0; 444 default: 445 return -EINVAL; 446 } 447 case IIO_CHAN_INFO_PROCESSED: 448 switch (chan->type) { 449 case IIO_STEPS: 450 mutex_lock(&st->lock); 451 st->steps = val; 452 mutex_unlock(&st->lock); 453 return 0; 454 case IIO_ACTIVITY: 455 if (val < 0) 456 val = 0; 457 if (val > 100) 458 val = 100; 459 switch (chan->channel2) { 460 case IIO_MOD_RUNNING: 461 st->activity_running = val; 462 return 0; 463 case IIO_MOD_WALKING: 464 st->activity_walking = val; 465 return 0; 466 default: 467 return -EINVAL; 468 } 469 break; 470 default: 471 return -EINVAL; 472 } 473 case IIO_CHAN_INFO_CALIBSCALE: 474 mutex_lock(&st->lock); 475 /* Compare against table - hard matching here */ 476 for (i = 0; i < ARRAY_SIZE(dummy_scales); i++) 477 if (val == dummy_scales[i].val && 478 val2 == dummy_scales[i].val2) 479 break; 480 if (i == ARRAY_SIZE(dummy_scales)) 481 ret = -EINVAL; 482 else 483 st->accel_calibscale = &dummy_scales[i]; 484 mutex_unlock(&st->lock); 485 return ret; 486 case IIO_CHAN_INFO_CALIBBIAS: 487 mutex_lock(&st->lock); 488 st->accel_calibbias = val; 489 mutex_unlock(&st->lock); 490 return 0; 491 case IIO_CHAN_INFO_ENABLE: 492 switch (chan->type) { 493 case IIO_STEPS: 494 mutex_lock(&st->lock); 495 st->steps_enabled = val; 496 mutex_unlock(&st->lock); 497 return 0; 498 default: 499 return -EINVAL; 500 } 501 case IIO_CHAN_INFO_CALIBHEIGHT: 502 switch (chan->type) { 503 case IIO_STEPS: 504 st->height = val; 505 return 0; 506 default: 507 return -EINVAL; 508 } 509 510 default: 511 return -EINVAL; 512 } 513 } 514 515 /* 516 * Device type specific information. 517 */ 518 static const struct iio_info iio_dummy_info = { 519 .read_raw = &iio_dummy_read_raw, 520 .write_raw = &iio_dummy_write_raw, 521 #ifdef CONFIG_IIO_SIMPLE_DUMMY_EVENTS 522 .read_event_config = &iio_simple_dummy_read_event_config, 523 .write_event_config = &iio_simple_dummy_write_event_config, 524 .read_event_value = &iio_simple_dummy_read_event_value, 525 .write_event_value = &iio_simple_dummy_write_event_value, 526 #endif /* CONFIG_IIO_SIMPLE_DUMMY_EVENTS */ 527 }; 528 529 /** 530 * iio_dummy_init_device() - device instance specific init 531 * @indio_dev: the iio device structure 532 * 533 * Most drivers have one of these to set up default values, 534 * reset the device to known state etc. 535 */ 536 static int iio_dummy_init_device(struct iio_dev *indio_dev) 537 { 538 struct iio_dummy_state *st = iio_priv(indio_dev); 539 540 st->dac_val = 0; 541 st->single_ended_adc_val = 73; 542 st->differential_adc_val[0] = 33; 543 st->differential_adc_val[1] = -34; 544 st->accel_val = 34; 545 st->accel_calibbias = -7; 546 st->accel_calibscale = &dummy_scales[0]; 547 st->steps = 47; 548 st->activity_running = 98; 549 st->activity_walking = 4; 550 551 return 0; 552 } 553 554 /** 555 * iio_dummy_probe() - device instance probe 556 * @name: name of this instance. 557 * 558 * Arguments are bus type specific. 559 * I2C: iio_dummy_probe(struct i2c_client *client, 560 * const struct i2c_device_id *id) 561 * SPI: iio_dummy_probe(struct spi_device *spi) 562 */ 563 static struct iio_sw_device *iio_dummy_probe(const char *name) 564 { 565 int ret; 566 struct iio_dev *indio_dev; 567 struct iio_dummy_state *st; 568 struct iio_sw_device *swd; 569 struct device *parent = NULL; 570 571 /* 572 * With hardware: Set the parent device. 573 * parent = &spi->dev; 574 * parent = &client->dev; 575 */ 576 577 swd = kzalloc(sizeof(*swd), GFP_KERNEL); 578 if (!swd) 579 return ERR_PTR(-ENOMEM); 580 581 /* 582 * Allocate an IIO device. 583 * 584 * This structure contains all generic state 585 * information about the device instance. 586 * It also has a region (accessed by iio_priv() 587 * for chip specific state information. 588 */ 589 indio_dev = iio_device_alloc(parent, sizeof(*st)); 590 if (!indio_dev) { 591 ret = -ENOMEM; 592 goto error_free_swd; 593 } 594 595 st = iio_priv(indio_dev); 596 mutex_init(&st->lock); 597 598 iio_dummy_init_device(indio_dev); 599 600 /* 601 * Make the iio_dev struct available to remove function. 602 * Bus equivalents 603 * i2c_set_clientdata(client, indio_dev); 604 * spi_set_drvdata(spi, indio_dev); 605 */ 606 swd->device = indio_dev; 607 608 /* 609 * Set the device name. 610 * 611 * This is typically a part number and obtained from the module 612 * id table. 613 * e.g. for i2c and spi: 614 * indio_dev->name = id->name; 615 * indio_dev->name = spi_get_device_id(spi)->name; 616 */ 617 indio_dev->name = kstrdup(name, GFP_KERNEL); 618 if (!indio_dev->name) { 619 ret = -ENOMEM; 620 goto error_free_device; 621 } 622 623 /* Provide description of available channels */ 624 indio_dev->channels = iio_dummy_channels; 625 indio_dev->num_channels = ARRAY_SIZE(iio_dummy_channels); 626 627 /* 628 * Provide device type specific interface functions and 629 * constant data. 630 */ 631 indio_dev->info = &iio_dummy_info; 632 633 /* Specify that device provides sysfs type interfaces */ 634 indio_dev->modes = INDIO_DIRECT_MODE; 635 636 ret = iio_simple_dummy_events_register(indio_dev); 637 if (ret < 0) 638 goto error_free_name; 639 640 ret = iio_simple_dummy_configure_buffer(indio_dev); 641 if (ret < 0) 642 goto error_unregister_events; 643 644 ret = iio_device_register(indio_dev); 645 if (ret < 0) 646 goto error_unconfigure_buffer; 647 648 iio_swd_group_init_type_name(swd, name, &iio_dummy_type); 649 650 return swd; 651 error_unconfigure_buffer: 652 iio_simple_dummy_unconfigure_buffer(indio_dev); 653 error_unregister_events: 654 iio_simple_dummy_events_unregister(indio_dev); 655 error_free_name: 656 kfree(indio_dev->name); 657 error_free_device: 658 iio_device_free(indio_dev); 659 error_free_swd: 660 kfree(swd); 661 return ERR_PTR(ret); 662 } 663 664 /** 665 * iio_dummy_remove() - device instance removal function 666 * @swd: pointer to software IIO device abstraction 667 * 668 * Parameters follow those of iio_dummy_probe for buses. 669 */ 670 static int iio_dummy_remove(struct iio_sw_device *swd) 671 { 672 /* 673 * Get a pointer to the device instance iio_dev structure 674 * from the bus subsystem. E.g. 675 * struct iio_dev *indio_dev = i2c_get_clientdata(client); 676 * struct iio_dev *indio_dev = spi_get_drvdata(spi); 677 */ 678 struct iio_dev *indio_dev = swd->device; 679 680 /* Unregister the device */ 681 iio_device_unregister(indio_dev); 682 683 /* Device specific code to power down etc */ 684 685 /* Buffered capture related cleanup */ 686 iio_simple_dummy_unconfigure_buffer(indio_dev); 687 688 iio_simple_dummy_events_unregister(indio_dev); 689 690 /* Free all structures */ 691 kfree(indio_dev->name); 692 iio_device_free(indio_dev); 693 694 return 0; 695 } 696 697 /* 698 * module_iio_sw_device_driver() - device driver registration 699 * 700 * Varies depending on bus type of the device. As there is no device 701 * here, call probe directly. For information on device registration 702 * i2c: 703 * Documentation/i2c/writing-clients.rst 704 * spi: 705 * Documentation/spi/spi-summary.rst 706 */ 707 static const struct iio_sw_device_ops iio_dummy_device_ops = { 708 .probe = iio_dummy_probe, 709 .remove = iio_dummy_remove, 710 }; 711 712 static struct iio_sw_device_type iio_dummy_device = { 713 .name = "dummy", 714 .owner = THIS_MODULE, 715 .ops = &iio_dummy_device_ops, 716 }; 717 718 module_iio_sw_device_driver(iio_dummy_device); 719 720 MODULE_AUTHOR("Jonathan Cameron <jic23@kernel.org>"); 721 MODULE_DESCRIPTION("IIO dummy driver"); 722 MODULE_LICENSE("GPL v2"); 723