st->dready_trig = devm_iio_trigger_alloc(dev,
                                                         "%s-dev%d",
                                                         indio_dev->name,
-                                                        indio_dev->id);
+                                                        iio_device_id(indio_dev));
                if (st->dready_trig == NULL)
                        return -ENOMEM;
 
                st->peak_datardy_trig = devm_iio_trigger_alloc(dev,
                                                               "%s-dev%d-peak",
                                                               indio_dev->name,
-                                                              indio_dev->id);
+                                                              iio_device_id(indio_dev));
                if (!st->peak_datardy_trig)
                        return -ENOMEM;
 
 
 
        if (client->irq > 0) {
                data->trig = iio_trigger_alloc(dev, "%s-dev%d", indio_dev->name,
-                       indio_dev->id);
+                                              iio_device_id(indio_dev));
                if (!data->trig) {
                        ret = -ENOMEM;
                        goto err_chip_disable;
 
                struct bmc150_accel_trigger *t = &data->triggers[i];
 
                t->indio_trig = devm_iio_trigger_alloc(dev,
-                                       bmc150_accel_triggers[i].name,
+                                                      bmc150_accel_triggers[i].name,
                                                       indio_dev->name,
-                                                      indio_dev->id);
+                                                      iio_device_id(indio_dev));
                if (!t->indio_trig) {
                        ret = -ENOMEM;
                        break;
 
                data->dready_trig = devm_iio_trigger_alloc(&client->dev,
                                                           "%s-dev%d",
                                                           indio_dev->name,
-                                                          indio_dev->id);
+                                                          iio_device_id(indio_dev));
                if (!data->dready_trig) {
                        ret = -ENOMEM;
                        goto err_poweroff;
                data->motion_trig = devm_iio_trigger_alloc(&client->dev,
                                                          "%s-any-motion-dev%d",
                                                          indio_dev->name,
-                                                         indio_dev->id);
+                                                         iio_device_id(indio_dev));
                if (!data->motion_trig) {
                        ret = -ENOMEM;
                        goto err_poweroff;
 
 
        trig = devm_iio_trigger_alloc(&data->client->dev, "%s-dev%d",
                                      indio_dev->name,
-                                     indio_dev->id);
+                                     iio_device_id(indio_dev));
        if (!trig)
                return -ENOMEM;
 
 
                data->dready_trig = devm_iio_trigger_alloc(&client->dev,
                                                           "%s-dev%d",
                                                           indio_dev->name,
-                                                          indio_dev->id);
+                                                          iio_device_id(indio_dev));
                if (!data->dready_trig)
                        return -ENOMEM;
 
 
                data->dready_trig = devm_iio_trigger_alloc(&client->dev,
                                                           "%s-dev%d",
                                                           indio_dev->name,
-                                                          indio_dev->id);
+                                                          iio_device_id(indio_dev));
                if (!data->dready_trig) {
                        ret = -ENOMEM;
                        goto err_power_off;
 
                data->dready_trig = devm_iio_trigger_alloc(&client->dev,
                                                           "%s-dev%d",
                                                           indio_dev->name,
-                                                          indio_dev->id);
+                                                          iio_device_id(indio_dev));
                if (!data->dready_trig) {
                        ret = -ENOMEM;
                        goto err_power_off;
 
        }
 
        st->trig = devm_iio_trigger_alloc(dev, "%s-dev%d",
-                                         indio_dev->name, indio_dev->id);
+                                         indio_dev->name,
+                                         iio_device_id(indio_dev));
        if (!st->trig)
                return -ENOMEM;
 
 
 
        if (spi->irq > 0) {
                ad7766->trig = devm_iio_trigger_alloc(&spi->dev, "%s-dev%d",
-                       indio_dev->name, indio_dev->id);
+                                                     indio_dev->name,
+                                                     iio_device_id(indio_dev));
                if (!ad7766->trig)
                        return -ENOMEM;
 
 
        }
 
        st->trig = devm_iio_trigger_alloc(&spi->dev, "%s-dev%d",
-                                         indio_dev->name, indio_dev->id);
+                                         indio_dev->name,
+                                         iio_device_id(indio_dev));
        if (!st->trig)
                return -ENOMEM;
 
 
 
        sigma_delta->trig = iio_trigger_alloc(&sigma_delta->spi->dev,
                                              "%s-dev%d", indio_dev->name,
-                                             indio_dev->id);
+                                             iio_device_id(indio_dev));
        if (sigma_delta->trig == NULL) {
                ret = -ENOMEM;
                goto error_ret;
 
        int ret;
 
        trig = devm_iio_trigger_alloc(&indio->dev, "%s-dev%d-%s", indio->name,
-                                     indio->id, trigger_name);
+                               iio_device_id(indio), trigger_name);
        if (!trig)
                return NULL;
 
 
                char *name = kasprintf(GFP_KERNEL,
                                "%s-dev%d-%s",
                                idev->name,
-                               idev->id,
+                               iio_device_id(idev),
                                triggers[i].name);
                if (!name)
                        return -ENOMEM;
        int ret;
 
        trig = iio_trigger_alloc(idev->dev.parent, "%s-dev%d-%s", idev->name,
-                                idev->id, trigger->name);
+                                iio_device_id(idev), trigger->name);
        if (trig == NULL)
                return NULL;
 
 
        indio_dev->setup_ops = &dln2_adc_buffer_setup_ops;
 
        dln2->trig = devm_iio_trigger_alloc(dev, "%s-dev%d",
-                                           indio_dev->name, indio_dev->id);
+                                           indio_dev->name,
+                                           iio_device_id(indio_dev));
        if (!dln2->trig) {
                dev_err(dev, "failed to allocate trigger\n");
                return -ENOMEM;
 
                chip->allow_async_readout);
 
        task = kthread_create(ina2xx_capture_thread, (void *)indio_dev,
-                             "%s:%d-%uus", indio_dev->name, indio_dev->id,
+                             "%s:%d-%uus", indio_dev->name,
+                             iio_device_id(indio_dev),
                              sampling_us);
        if (IS_ERR(task))
                return PTR_ERR(task);
 
        struct mxs_lradc_adc *adc = iio_priv(iio);
 
        trig = devm_iio_trigger_alloc(&iio->dev, "%s-dev%i", iio->name,
-                                     iio->id);
+                                     iio_device_id(iio));
        if (!trig)
                return -ENOMEM;
 
 
        }
 
        st->trig = devm_iio_trigger_alloc(&spi->dev, "%s-dev%d",
-               indio_dev->name, indio_dev->id);
+               indio_dev->name, iio_device_id(indio_dev));
        if (!st->trig) {
                dev_err(&spi->dev, "failed to allocate IIO trigger\n");
                return -ENOMEM;
 
        int ret;
 
        trig = devm_iio_trigger_alloc(dev, "%s%d-%s", indio_dev->name,
-                                     indio_dev->id, name);
+                                     iio_device_id(indio_dev), name);
        if (trig == NULL)
                return ERR_PTR(-ENOMEM);
 
 
                                                 indio_dev,
                                                 "%s_consumer%d",
                                                 indio_dev->name,
-                                                indio_dev->id);
+                                                iio_device_id(indio_dev));
        if (indio_dev->pollfunc == NULL) {
                ret = -ENOMEM;
                goto error_kfifo_free;
 
        indio_dev->modes = INDIO_BUFFER_SOFTWARE | INDIO_DIRECT_MODE;
 
        trig = devm_iio_trigger_alloc(&client->dev, "%s-dev%d",
-                                     indio_dev->name, indio_dev->id);
+                                     indio_dev->name, iio_device_id(indio_dev));
 
        if (!trig)
                return -ENOMEM;
 
                data->drdy_trig = devm_iio_trigger_alloc(&client->dev,
                                                         "%s-dev%d",
                                                         indio_dev->name,
-                                                        indio_dev->id);
+                                                        iio_device_id(indio_dev));
                if (!data->drdy_trig) {
                        ret = -ENOMEM;
                        goto err_poweroff;
 
        struct iio_trigger *trig;
        int ret;
 
-       trig = devm_iio_trigger_alloc(dev, "%s-dev%d", indio_dev->name, indio_dev->id);
+       trig = devm_iio_trigger_alloc(dev, "%s-dev%d", indio_dev->name,
+                                     iio_device_id(indio_dev));
        if (!trig) {
                dev_err(dev, "failed to allocate trigger\n");
                return -ENOMEM;
 
        }
 
        trig = iio_trigger_alloc(indio_dev->dev.parent,
-                                "%s-dev%d", name, indio_dev->id);
+                                "%s-dev%d", name, iio_device_id(indio_dev));
        if (trig == NULL) {
                dev_err(&indio_dev->dev, "Trigger Allocate Failed\n");
                ret = -ENOMEM;
 
 
        st->dready_trig = devm_iio_trigger_alloc(&st->spi->dev, "%s-dev%d",
                                                 indio_dev->name,
-                                                indio_dev->id);
+                                                iio_device_id(indio_dev));
        if (!st->dready_trig)
                return -ENOMEM;
 
 
                data->dready_trig = devm_iio_trigger_alloc(dev,
                                                           "%s-dev%d",
                                                           indio_dev->name,
-                                                          indio_dev->id);
+                                                          iio_device_id(indio_dev));
                if (!data->dready_trig)
                        return -ENOMEM;
 
                data->motion_trig = devm_iio_trigger_alloc(dev,
                                                          "%s-any-motion-dev%d",
                                                          indio_dev->name,
-                                                         indio_dev->id);
+                                                         iio_device_id(indio_dev));
                if (!data->motion_trig)
                        return -ENOMEM;
 
 
 
        data->dready_trig = devm_iio_trigger_alloc(dev, "%s-dev%d",
                                                   indio_dev->name,
-                                                  indio_dev->id);
+                                                  iio_device_id(indio_dev));
        if (!data->dready_trig)
                return -ENOMEM;
 
 
        struct itg3200 *st = iio_priv(indio_dev);
 
        st->trig = iio_trigger_alloc(&st->i2c->dev, "%s-dev%d", indio_dev->name,
-                                    indio_dev->id);
+                                    iio_device_id(indio_dev));
        if (!st->trig)
                return -ENOMEM;
 
 
        mpu3050->trig = devm_iio_trigger_alloc(&indio_dev->dev,
                                               "%s-dev%d",
                                               indio_dev->name,
-                                              indio_dev->id);
+                                              iio_device_id(indio_dev));
        if (!mpu3050->trig)
                return -ENOMEM;
 
 
                afe->trig = devm_iio_trigger_alloc(afe->dev,
                                                   "%s-dev%d",
                                                   indio_dev->name,
-                                                  indio_dev->id);
+                                                  iio_device_id(indio_dev));
                if (!afe->trig) {
                        dev_err(afe->dev, "Unable to allocate IIO trigger\n");
                        ret = -ENOMEM;
 
                afe->trig = devm_iio_trigger_alloc(afe->dev,
                                                   "%s-dev%d",
                                                   indio_dev->name,
-                                                  indio_dev->id);
+                                                  iio_device_id(indio_dev));
                if (!afe->trig) {
                        dev_err(afe->dev, "Unable to allocate IIO trigger\n");
                        ret = -ENOMEM;
 
        int ret;
 
        adis->trig = devm_iio_trigger_alloc(&adis->spi->dev, "%s-dev%d",
-                                           indio_dev->name, indio_dev->id);
+                                           indio_dev->name,
+                                           iio_device_id(indio_dev));
        if (!adis->trig)
                return -ENOMEM;
 
 
        int ret;
 
        data->trig = devm_iio_trigger_alloc(&indio_dev->dev, "%s-dev%d",
-                                           indio_dev->name, indio_dev->id);
+                                           indio_dev->name,
+                                           iio_device_id(indio_dev));
 
        if (data->trig == NULL)
                return -ENOMEM;
 
        st->trig = devm_iio_trigger_alloc(&indio_dev->dev,
                                          "%s-dev%d",
                                          indio_dev->name,
-                                         indio_dev->id);
+                                         iio_device_id(indio_dev));
        if (!st->trig)
                return -ENOMEM;
 
 
                                      "%s-%s-dev%d",
                                      indio_dev->name,
                                      tag,
-                                     indio_dev->id);
+                                     iio_device_id(indio_dev));
        if (!trig)
                return ERR_PTR(-ENOMEM);
 
 
        [IIO_CHAN_INFO_THERMOCOUPLE_TYPE] = "thermocouple_type",
        [IIO_CHAN_INFO_CALIBAMBIENT] = "calibambient",
 };
+/**
+ * iio_device_id() - query the unique ID for the device
+ * @indio_dev:         Device structure whose ID is being queried
+ *
+ * The IIO device ID is a unique index used for example for the naming
+ * of the character device /dev/iio\:device[ID]
+ */
+int iio_device_id(struct iio_dev *indio_dev)
+{
+       struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
+
+       return iio_dev_opaque->id;
+}
+EXPORT_SYMBOL_GPL(iio_device_id);
 
 /**
  * iio_sysfs_match_string_with_gaps - matches given string in an array with gaps
 
        iio_device_detach_buffers(indio_dev);
 
-       ida_simple_remove(&iio_ida, indio_dev->id);
+       ida_simple_remove(&iio_ida, iio_dev_opaque->id);
        kfree(iio_dev_opaque);
 }
 
        mutex_init(&indio_dev->info_exist_lock);
        INIT_LIST_HEAD(&iio_dev_opaque->channel_attr_list);
 
-       indio_dev->id = ida_simple_get(&iio_ida, 0, 0, GFP_KERNEL);
-       if (indio_dev->id < 0) {
+       iio_dev_opaque->id = ida_simple_get(&iio_ida, 0, 0, GFP_KERNEL);
+       if (iio_dev_opaque->id < 0) {
                /* cannot use a dev_err as the name isn't available */
                pr_err("failed to get device id\n");
                kfree(iio_dev_opaque);
                return NULL;
        }
-       dev_set_name(&indio_dev->dev, "iio:device%d", indio_dev->id);
+       dev_set_name(&indio_dev->dev, "iio:device%d", iio_dev_opaque->id);
        INIT_LIST_HEAD(&iio_dev_opaque->buffer_list);
        INIT_LIST_HEAD(&iio_dev_opaque->ioctl_handlers);
 
                cdev_init(&indio_dev->chrdev, &iio_event_fileops);
 
        if (iio_dev_opaque->attached_buffers_cnt || iio_dev_opaque->event_interface) {
-               indio_dev->dev.devt = MKDEV(MAJOR(iio_devt), indio_dev->id);
+               indio_dev->dev.devt = MKDEV(MAJOR(iio_devt), iio_dev_opaque->id);
                indio_dev->chrdev.owner = this_mod;
        }
 
 
                                                       indio_dev,
                                                       "%s_consumer%d",
                                                       indio_dev->name,
-                                                      indio_dev->id);
+                                                      iio_device_id(indio_dev));
        if (indio_dev->pollfunc_event == NULL)
                return -ENOMEM;
 
 
        indio_dev->channels = acpi_als_channels;
        indio_dev->num_channels = ARRAY_SIZE(acpi_als_channels);
 
-       als->trig = devm_iio_trigger_alloc(dev, "%s-dev%d", indio_dev->name, indio_dev->id);
+       als->trig = devm_iio_trigger_alloc(dev, "%s-dev%d", indio_dev->name,
+                                          iio_device_id(indio_dev));
        if (!als->trig)
                return -ENOMEM;
 
 
                /* Trigger0 producer setup */
                data->drdy_trigger0 = devm_iio_trigger_alloc(
                        indio_dev->dev.parent,
-                       "%s-dev%d", indio_dev->name, indio_dev->id);
+                       "%s-dev%d", indio_dev->name, iio_device_id(indio_dev));
                if (!data->drdy_trigger0) {
                        ret = -ENOMEM;
                        goto err_pm_disable;
 
        int ret;
 
        trig = devm_iio_trigger_alloc(&client->dev,
-                       "%s-dev%d", indio_dev->name, indio_dev->id);
+                       "%s-dev%d", indio_dev->name, iio_device_id(indio_dev));
        if (!trig)
                return -ENOMEM;
 
 
        struct iio_trigger *trigger;
 
        trigger = devm_iio_trigger_alloc(&client->dev, "%s-dev%d",
-                                        indio_dev->name, indio_dev->id);
+                                        indio_dev->name,
+                                        iio_device_id(indio_dev));
        if (!trigger)
                return -ENOMEM;
 
 
 
        data->drdy_trigger0 = devm_iio_trigger_alloc(
                        indio_dev->dev.parent,
-                       "%s-dev%d", indio_dev->name, indio_dev->id);
+                       "%s-dev%d", indio_dev->name, iio_device_id(indio_dev));
        if (!data->drdy_trigger0)
                return -ENOMEM;
 
 
                data->dready_trig = devm_iio_trigger_alloc(dev,
                                                           "%s-dev%d",
                                                           indio_dev->name,
-                                                          indio_dev->id);
+                                                          iio_device_id(indio_dev));
                if (!data->dready_trig) {
                        ret = -ENOMEM;
                        dev_err(dev, "iio trigger alloc failed\n");
 
 
                data->drdy_trig = devm_iio_trigger_alloc(dev, "%s-drdy%d",
                                                         indio_dev->name,
-                                                        indio_dev->id);
+                                                        iio_device_id(indio_dev));
                if (!data->drdy_trig)
                        return -ENOMEM;
 
 
        }
 
        data->trig = devm_iio_trigger_alloc(dev, "%s-mux%d",
-                                           indio_dev->name, indio_dev->id);
+                                           indio_dev->name,
+                                           iio_device_id(indio_dev));
        if (!data->trig) {
                dev_err(dev, "cannot allocate iio trigger.\n");
                return -ENOMEM;
 
                return 0;
 
        trigger = devm_iio_trigger_alloc(parent, "%s-dev%d",
-                                        indio_dev->name, indio_dev->id);
+                                        indio_dev->name,
+                                        iio_device_id(indio_dev));
        if (!trigger)
                return -ENOMEM;
 
 
        indio_dev->info = &as3935_info;
 
        trig = devm_iio_trigger_alloc(dev, "%s-dev%d",
-                                     indio_dev->name, indio_dev->id);
+                                     indio_dev->name,
+                                     iio_device_id(indio_dev));
 
        if (!trig)
                return -ENOMEM;
 
 
                data->trig = devm_iio_trigger_alloc(dev, "%s-dev%d",
                                                    indio_dev->name,
-                                                   indio_dev->id);
+                                                   iio_device_id(indio_dev));
                if (!data->trig)
                        return -ENOMEM;
 
 
                        return ret;
 
                data->trig = devm_iio_trigger_alloc(&client->dev,
-                               "%s-dev%d", indio_dev->name, indio_dev->id);
+                               "%s-dev%d", indio_dev->name, iio_device_id(indio_dev));
                if (!data->trig)
                        return -ENOMEM;
 
 
 /**
  * struct iio_dev_opaque - industrial I/O device opaque information
  * @indio_dev:                 public industrial I/O device information
+ * @id:                        used to identify device internally
  * @event_interface:           event chrdevs associated with interrupt lines
  * @attached_buffers:          array of buffers statically attached by the driver
  * @attached_buffers_cnt:      number of buffers in the array of statically attached buffers
  */
 struct iio_dev_opaque {
        struct iio_dev                  indio_dev;
+       int                             id;
        struct iio_event_interface      *event_interface;
        struct iio_buffer               **attached_buffers;
        unsigned int                    attached_buffers_cnt;
 
 
 /**
  * struct iio_dev - industrial I/O device
- * @id:                        [INTERN] used to identify device internally
  * @driver_module:     [INTERN] used to make it harder to undercut users
  * @modes:             [DRIVER] operating modes supported by device
  * @currentmode:       [DRIVER] current operating mode
  *                     **MUST** be accessed **ONLY** via iio_priv() helper
  */
 struct iio_dev {
-       int                             id;
        struct module                   *driver_module;
 
        int                             modes;
        void                            *priv;
 };
 
+int iio_device_id(struct iio_dev *indio_dev);
+
 const struct iio_chan_spec
 *iio_find_channel_from_si(struct iio_dev *indio_dev, int si);
 /**