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