drivers/iio/dummy/iio_simple_dummy.c

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