drivers/iio/dummy/iio_simple_dummy.c

   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 <[email protected]>");
 721 MODULE_DESCRIPTION("IIO dummy driver");
 722 MODULE_LICENSE("GPL v2");