}
 
 /* Function to initialize the processing for usage id */
-static int __devinit hid_accel_3d_probe(struct platform_device *pdev)
+static int hid_accel_3d_probe(struct platform_device *pdev)
 {
        int ret = 0;
        static const char *name = "accel_3d";
 }
 
 /* Function to deinitialize the processing for usage id */
-static int __devinit hid_accel_3d_remove(struct platform_device *pdev)
+static int hid_accel_3d_remove(struct platform_device *pdev)
 {
        struct hid_sensor_hub_device *hsdev = pdev->dev.platform_data;
        struct iio_dev *indio_dev = platform_get_drvdata(pdev);
 
        },
 };
 
-static void __devinit ad7266_init_channels(struct iio_dev *indio_dev)
+static void ad7266_init_channels(struct iio_dev *indio_dev)
 {
        struct ad7266_state *st = iio_priv(indio_dev);
        bool is_differential, is_signed;
        "AD0", "AD1", "AD2",
 };
 
-static int __devinit ad7266_probe(struct spi_device *spi)
+static int ad7266_probe(struct spi_device *spi)
 {
        struct ad7266_platform_data *pdata = spi->dev.platform_data;
        struct iio_dev *indio_dev;
        return ret;
 }
 
-static int __devexit ad7266_remove(struct spi_device *spi)
+static int ad7266_remove(struct spi_device *spi)
 {
        struct iio_dev *indio_dev = spi_get_drvdata(spi);
        struct ad7266_state *st = iio_priv(indio_dev);
                .owner  = THIS_MODULE,
        },
        .probe          = ad7266_probe,
-       .remove         = __devexit_p(ad7266_remove),
+       .remove         = ad7266_remove,
        .id_table       = ad7266_id,
 };
 module_spi_driver(ad7266_driver);
 
        .driver_module = THIS_MODULE,
 };
 
-static int __devinit ad7298_probe(struct spi_device *spi)
+static int ad7298_probe(struct spi_device *spi)
 {
        struct ad7298_platform_data *pdata = spi->dev.platform_data;
        struct ad7298_state *st;
        return ret;
 }
 
-static int __devexit ad7298_remove(struct spi_device *spi)
+static int ad7298_remove(struct spi_device *spi)
 {
        struct iio_dev *indio_dev = spi_get_drvdata(spi);
        struct ad7298_state *st = iio_priv(indio_dev);
                .owner  = THIS_MODULE,
        },
        .probe          = ad7298_probe,
-       .remove         = __devexit_p(ad7298_remove),
+       .remove         = ad7298_remove,
        .id_table       = ad7298_id,
 };
 module_spi_driver(ad7298_driver);
 
        .read_raw = &ad7476_read_raw,
 };
 
-static int __devinit ad7476_probe(struct spi_device *spi)
+static int ad7476_probe(struct spi_device *spi)
 {
        struct ad7476_state *st;
        struct iio_dev *indio_dev;
        return ret;
 }
 
-static int __devexit ad7476_remove(struct spi_device *spi)
+static int ad7476_remove(struct spi_device *spi)
 {
        struct iio_dev *indio_dev = spi_get_drvdata(spi);
        struct ad7476_state *st = iio_priv(indio_dev);
                .owner  = THIS_MODULE,
        },
        .probe          = ad7476_probe,
-       .remove         = __devexit_p(ad7476_remove),
+       .remove         = ad7476_remove,
        .id_table       = ad7476_id,
 };
 module_spi_driver(ad7476_driver);
 
        .driver_module = THIS_MODULE,
 };
 
-static int __devinit ad7791_setup(struct ad7791_state *st,
-       struct ad7791_platform_data *pdata)
+static int ad7791_setup(struct ad7791_state *st,
+                       struct ad7791_platform_data *pdata)
 {
        /* Set to poweron-reset default values */
        st->mode = AD7791_MODE_BUFFER;
                st->mode);
 }
 
-static int __devinit ad7791_probe(struct spi_device *spi)
+static int ad7791_probe(struct spi_device *spi)
 {
        struct ad7791_platform_data *pdata = spi->dev.platform_data;
        struct iio_dev *indio_dev;
        return ret;
 }
 
-static int __devexit ad7791_remove(struct spi_device *spi)
+static int ad7791_remove(struct spi_device *spi)
 {
        struct iio_dev *indio_dev = spi_get_drvdata(spi);
        struct ad7791_state *st = iio_priv(indio_dev);
                .owner  = THIS_MODULE,
        },
        .probe          = ad7791_probe,
-       .remove         = __devexit_p(ad7791_remove),
+       .remove         = ad7791_remove,
        .id_table       = ad7791_spi_ids,
 };
 module_spi_driver(ad7791_driver);
 
        .driver_module = THIS_MODULE,
 };
 
-static int __devinit ad7887_probe(struct spi_device *spi)
+static int ad7887_probe(struct spi_device *spi)
 {
        struct ad7887_platform_data *pdata = spi->dev.platform_data;
        struct ad7887_state *st;
        return ret;
 }
 
-static int __devexit ad7887_remove(struct spi_device *spi)
+static int ad7887_remove(struct spi_device *spi)
 {
        struct iio_dev *indio_dev = spi_get_drvdata(spi);
        struct ad7887_state *st = iio_priv(indio_dev);
                .owner  = THIS_MODULE,
        },
        .probe          = ad7887_probe,
-       .remove         = __devexit_p(ad7887_remove),
+       .remove         = ad7887_remove,
        .id_table       = ad7887_id,
 };
 module_spi_driver(ad7887_driver);
 
        .read_raw = &at91_adc_read_raw,
 };
 
-static int __devinit at91_adc_probe(struct platform_device *pdev)
+static int at91_adc_probe(struct platform_device *pdev)
 {
        unsigned int prsc, mstrclk, ticks, adc_clk;
        int ret;
        return ret;
 }
 
-static int __devexit at91_adc_remove(struct platform_device *pdev)
+static int at91_adc_remove(struct platform_device *pdev)
 {
        struct iio_dev *idev = platform_get_drvdata(pdev);
        struct at91_adc_state *st = iio_priv(idev);
 
 static struct platform_driver at91_adc_driver = {
        .probe = at91_adc_probe,
-       .remove = __devexit_p(at91_adc_remove),
+       .remove = at91_adc_remove,
        .driver = {
                   .name = "at91_adc",
                   .of_match_table = of_match_ptr(at91_adc_dt_ids),
 
        iio_map_array_unregister(indio_dev, adc->map);
 }
 
-static int __devinit lp8788_adc_probe(struct platform_device *pdev)
+static int lp8788_adc_probe(struct platform_device *pdev)
 {
        struct lp8788 *lp = dev_get_drvdata(pdev->dev.parent);
        struct iio_dev *indio_dev;
        return ret;
 }
 
-static int __devexit lp8788_adc_remove(struct platform_device *pdev)
+static int lp8788_adc_remove(struct platform_device *pdev)
 {
        struct iio_dev *indio_dev = platform_get_drvdata(pdev);
        struct lp8788_adc *adc = iio_priv(indio_dev);
 
 static struct platform_driver lp8788_adc_driver = {
        .probe = lp8788_adc_probe,
-       .remove = __devexit_p(lp8788_adc_remove),
+       .remove = lp8788_adc_remove,
        .driver = {
                .name = LP8788_DEV_ADC,
                .owner = THIS_MODULE,
 
        return max1363_set_scan_mode(st);
 }
 
-static int __devinit max1363_alloc_scan_masks(struct iio_dev *indio_dev)
+static int max1363_alloc_scan_masks(struct iio_dev *indio_dev)
 {
        struct max1363_state *st = iio_priv(indio_dev);
        unsigned long *masks;
        iio_kfifo_free(indio_dev->buffer);
 }
 
-static int __devinit max1363_probe(struct i2c_client *client,
-                                  const struct i2c_device_id *id)
+static int max1363_probe(struct i2c_client *client,
+                        const struct i2c_device_id *id)
 {
        int ret;
        struct max1363_state *st;
        return ret;
 }
 
-static int __devexit max1363_remove(struct i2c_client *client)
+static int max1363_remove(struct i2c_client *client)
 {
        struct iio_dev *indio_dev = i2c_get_clientdata(client);
        struct max1363_state *st = iio_priv(indio_dev);
                .name = "max1363",
        },
        .probe = max1363_probe,
-       .remove = __devexit_p(max1363_remove),
+       .remove = max1363_remove,
        .id_table = max1363_id,
 };
 module_i2c_driver(max1363_driver);
 
        .read_raw = &tiadc_read_raw,
 };
 
-static int __devinit tiadc_probe(struct platform_device *pdev)
+static int tiadc_probe(struct platform_device *pdev)
 {
        struct iio_dev          *indio_dev;
        struct tiadc_device     *adc_dev;
        return err;
 }
 
-static int __devexit tiadc_remove(struct platform_device *pdev)
+static int tiadc_remove(struct platform_device *pdev)
 {
        struct iio_dev *indio_dev = platform_get_drvdata(pdev);
 
                .pm     = TIADC_PM_OPS,
        },
        .probe  = tiadc_probe,
-       .remove = __devexit_p(tiadc_remove),
+       .remove = tiadc_remove,
 };
 
 module_platform_driver(tiadc_driver);
 
        .driver_module = THIS_MODULE,
 };
 
-static int __devinit vprbrd_adc_probe(struct platform_device *pdev)
+static int vprbrd_adc_probe(struct platform_device *pdev)
 {
        struct vprbrd *vb = dev_get_drvdata(pdev->dev.parent);
        struct vprbrd_adc *adc;
        return ret;
 }
 
-static int __devexit vprbrd_adc_remove(struct platform_device *pdev)
+static int vprbrd_adc_remove(struct platform_device *pdev)
 {
        struct iio_dev *indio_dev = platform_get_drvdata(pdev);
 
                .owner  = THIS_MODULE,
        },
        .probe          = vprbrd_adc_probe,
-       .remove         = __devexit_p(vprbrd_adc_remove),
+       .remove         = vprbrd_adc_remove,
 };
 
 module_platform_driver(vprbrd_adc_driver);
 
        AD8366_CHAN(1),
 };
 
-static int __devinit ad8366_probe(struct spi_device *spi)
+static int ad8366_probe(struct spi_device *spi)
 {
        struct iio_dev *indio_dev;
        struct ad8366_state *st;
        return ret;
 }
 
-static int __devexit ad8366_remove(struct spi_device *spi)
+static int ad8366_remove(struct spi_device *spi)
 {
        struct iio_dev *indio_dev = spi_get_drvdata(spi);
        struct ad8366_state *st = iio_priv(indio_dev);
                .owner  = THIS_MODULE,
        },
        .probe          = ad8366_probe,
-       .remove         = __devexit_p(ad8366_remove),
+       .remove         = ad8366_remove,
        .id_table       = ad8366_id,
 };
 
 
        return st->chip_info->shared_vref ? "vref" : ad5064_vref_names[vref];
 }
 
-static int __devinit ad5064_probe(struct device *dev, enum ad5064_type type,
-       const char *name, ad5064_write_func write)
+static int ad5064_probe(struct device *dev, enum ad5064_type type,
+                       const char *name, ad5064_write_func write)
 {
        struct iio_dev *indio_dev;
        struct ad5064_state *st;
        return ret;
 }
 
-static int __devexit ad5064_remove(struct device *dev)
+static int ad5064_remove(struct device *dev)
 {
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
        struct ad5064_state *st = iio_priv(indio_dev);
        return spi_write(spi, &st->data.spi, sizeof(st->data.spi));
 }
 
-static int __devinit ad5064_spi_probe(struct spi_device *spi)
+static int ad5064_spi_probe(struct spi_device *spi)
 {
        const struct spi_device_id *id = spi_get_device_id(spi);
 
                                ad5064_spi_write);
 }
 
-static int __devexit ad5064_spi_remove(struct spi_device *spi)
+static int ad5064_spi_remove(struct spi_device *spi)
 {
        return ad5064_remove(&spi->dev);
 }
                   .owner = THIS_MODULE,
        },
        .probe = ad5064_spi_probe,
-       .remove = __devexit_p(ad5064_spi_remove),
+       .remove = ad5064_spi_remove,
        .id_table = ad5064_spi_ids,
 };
 
        return i2c_master_send(i2c, st->data.i2c, 3);
 }
 
-static int __devinit ad5064_i2c_probe(struct i2c_client *i2c,
+static int ad5064_i2c_probe(struct i2c_client *i2c,
        const struct i2c_device_id *id)
 {
        return ad5064_probe(&i2c->dev, id->driver_data, id->name,
                                                ad5064_i2c_write);
 }
 
-static int __devexit ad5064_i2c_remove(struct i2c_client *i2c)
+static int ad5064_i2c_remove(struct i2c_client *i2c)
 {
        return ad5064_remove(&i2c->dev);
 }
                   .owner = THIS_MODULE,
        },
        .probe = ad5064_i2c_probe,
-       .remove = __devexit_p(ad5064_i2c_remove),
+       .remove = ad5064_i2c_remove,
        .id_table = ad5064_i2c_ids,
 };
 
 
         "vref0", "vref1", "vref2"
 };
 
-static int __devinit ad5360_alloc_channels(struct iio_dev *indio_dev)
+static int ad5360_alloc_channels(struct iio_dev *indio_dev)
 {
        struct ad5360_state *st = iio_priv(indio_dev);
        struct iio_chan_spec *channels;
        return 0;
 }
 
-static int __devinit ad5360_probe(struct spi_device *spi)
+static int ad5360_probe(struct spi_device *spi)
 {
        enum ad5360_type type = spi_get_device_id(spi)->driver_data;
        struct iio_dev *indio_dev;
        return ret;
 }
 
-static int __devexit ad5360_remove(struct spi_device *spi)
+static int ad5360_remove(struct spi_device *spi)
 {
        struct iio_dev *indio_dev = spi_get_drvdata(spi);
        struct ad5360_state *st = iio_priv(indio_dev);
                   .owner = THIS_MODULE,
        },
        .probe = ad5360_probe,
-       .remove = __devexit_p(ad5360_remove),
+       .remove = ad5360_remove,
        .id_table = ad5360_ids,
 };
 module_spi_driver(ad5360_driver);
 
        },
 };
 
-static int __devinit ad5380_alloc_channels(struct iio_dev *indio_dev)
+static int ad5380_alloc_channels(struct iio_dev *indio_dev)
 {
        struct ad5380_state *st = iio_priv(indio_dev);
        struct iio_chan_spec *channels;
        return 0;
 }
 
-static int __devinit ad5380_probe(struct device *dev, struct regmap *regmap,
-       enum ad5380_type type, const char *name)
+static int ad5380_probe(struct device *dev, struct regmap *regmap,
+                       enum ad5380_type type, const char *name)
 {
        struct iio_dev *indio_dev;
        struct ad5380_state *st;
        return ret;
 }
 
-static int __devexit ad5380_remove(struct device *dev)
+static int ad5380_remove(struct device *dev)
 {
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
        struct ad5380_state *st = iio_priv(indio_dev);
 
 #if IS_ENABLED(CONFIG_SPI_MASTER)
 
-static int __devinit ad5380_spi_probe(struct spi_device *spi)
+static int ad5380_spi_probe(struct spi_device *spi)
 {
        const struct spi_device_id *id = spi_get_device_id(spi);
        struct regmap *regmap;
        return ad5380_probe(&spi->dev, regmap, id->driver_data, id->name);
 }
 
-static int __devexit ad5380_spi_remove(struct spi_device *spi)
+static int ad5380_spi_remove(struct spi_device *spi)
 {
        return ad5380_remove(&spi->dev);
 }
                   .owner = THIS_MODULE,
        },
        .probe = ad5380_spi_probe,
-       .remove = __devexit_p(ad5380_spi_remove),
+       .remove = ad5380_spi_remove,
        .id_table = ad5380_spi_ids,
 };
 
 
 #if IS_ENABLED(CONFIG_I2C)
 
-static int __devinit ad5380_i2c_probe(struct i2c_client *i2c,
-       const struct i2c_device_id *id)
+static int ad5380_i2c_probe(struct i2c_client *i2c,
+                           const struct i2c_device_id *id)
 {
        struct regmap *regmap;
 
        return ad5380_probe(&i2c->dev, regmap, id->driver_data, id->name);
 }
 
-static int __devexit ad5380_i2c_remove(struct i2c_client *i2c)
+static int ad5380_i2c_remove(struct i2c_client *i2c)
 {
        return ad5380_remove(&i2c->dev);
 }
                   .owner = THIS_MODULE,
        },
        .probe = ad5380_i2c_probe,
-       .remove = __devexit_p(ad5380_i2c_remove),
+       .remove = ad5380_i2c_remove,
        .id_table = ad5380_i2c_ids,
 };
 
 
        .driver_module =        THIS_MODULE,
 };
 
-static int __devinit ad5421_probe(struct spi_device *spi)
+static int ad5421_probe(struct spi_device *spi)
 {
        struct ad5421_platform_data *pdata = dev_get_platdata(&spi->dev);
        struct iio_dev *indio_dev;
        return ret;
 }
 
-static int __devexit ad5421_remove(struct spi_device *spi)
+static int ad5421_remove(struct spi_device *spi)
 {
        struct iio_dev *indio_dev = spi_get_drvdata(spi);
 
                   .owner = THIS_MODULE,
        },
        .probe = ad5421_probe,
-       .remove = __devexit_p(ad5421_remove),
+       .remove = ad5421_remove,
 };
 module_spi_driver(ad5421_driver);
 
 
        .driver_module = THIS_MODULE,
 };
 
-static int __devinit ad5446_probe(struct device *dev, const char *name,
-       const struct ad5446_chip_info *chip_info)
+static int ad5446_probe(struct device *dev, const char *name,
+                       const struct ad5446_chip_info *chip_info)
 {
        struct ad5446_state *st;
        struct iio_dev *indio_dev;
 };
 MODULE_DEVICE_TABLE(spi, ad5446_spi_ids);
 
-static int __devinit ad5446_spi_probe(struct spi_device *spi)
+static int ad5446_spi_probe(struct spi_device *spi)
 {
        const struct spi_device_id *id = spi_get_device_id(spi);
 
                &ad5446_spi_chip_info[id->driver_data]);
 }
 
-static int __devexit ad5446_spi_remove(struct spi_device *spi)
+static int ad5446_spi_remove(struct spi_device *spi)
 {
        return ad5446_remove(&spi->dev);
 }
                .owner  = THIS_MODULE,
        },
        .probe          = ad5446_spi_probe,
-       .remove         = __devexit_p(ad5446_spi_remove),
+       .remove         = ad5446_spi_remove,
        .id_table       = ad5446_spi_ids,
 };
 
        },
 };
 
-static int __devinit ad5446_i2c_probe(struct i2c_client *i2c,
-       const struct i2c_device_id *id)
+static int ad5446_i2c_probe(struct i2c_client *i2c,
+                           const struct i2c_device_id *id)
 {
        return ad5446_probe(&i2c->dev, id->name,
                &ad5446_i2c_chip_info[id->driver_data]);
 }
 
-static int __devexit ad5446_i2c_remove(struct i2c_client *i2c)
+static int ad5446_i2c_remove(struct i2c_client *i2c)
 {
        return ad5446_remove(&i2c->dev);
 }
                   .owner = THIS_MODULE,
        },
        .probe = ad5446_i2c_probe,
-       .remove = __devexit_p(ad5446_i2c_remove),
+       .remove = ad5446_i2c_remove,
        .id_table = ad5446_i2c_ids,
 };
 
 
                return "VREFB";
 }
 
-static int __devinit ad5449_spi_probe(struct spi_device *spi)
+static int ad5449_spi_probe(struct spi_device *spi)
 {
        struct ad5449_platform_data *pdata = spi->dev.platform_data;
        const struct spi_device_id *id = spi_get_device_id(spi);
        return ret;
 }
 
-static int __devexit ad5449_spi_remove(struct spi_device *spi)
+static int ad5449_spi_remove(struct spi_device *spi)
 {
        struct iio_dev *indio_dev = spi_get_drvdata(spi);
        struct ad5449 *st = iio_priv(indio_dev);
                .owner = THIS_MODULE,
        },
        .probe = ad5449_spi_probe,
-       .remove = __devexit_p(ad5449_spi_remove),
+       .remove = ad5449_spi_remove,
        .id_table = ad5449_spi_ids,
 };
 module_spi_driver(ad5449_spi_driver);
 
        AD5504_CHANNEL(3),
 };
 
-static int __devinit ad5504_probe(struct spi_device *spi)
+static int ad5504_probe(struct spi_device *spi)
 {
        struct ad5504_platform_data *pdata = spi->dev.platform_data;
        struct iio_dev *indio_dev;
        return ret;
 }
 
-static int __devexit ad5504_remove(struct spi_device *spi)
+static int ad5504_remove(struct spi_device *spi)
 {
        struct iio_dev *indio_dev = spi_get_drvdata(spi);
        struct ad5504_state *st = iio_priv(indio_dev);
                   .owner = THIS_MODULE,
                   },
        .probe = ad5504_probe,
-       .remove = __devexit_p(ad5504_remove),
+       .remove = ad5504_remove,
        .id_table = ad5504_id,
 };
 module_spi_driver(ad5504_driver);
 
        },
 };
 
-static int __devinit ad5624r_probe(struct spi_device *spi)
+static int ad5624r_probe(struct spi_device *spi)
 {
        struct ad5624r_state *st;
        struct iio_dev *indio_dev;
        return ret;
 }
 
-static int __devexit ad5624r_remove(struct spi_device *spi)
+static int ad5624r_remove(struct spi_device *spi)
 {
        struct iio_dev *indio_dev = spi_get_drvdata(spi);
        struct ad5624r_state *st = iio_priv(indio_dev);
                   .owner = THIS_MODULE,
                   },
        .probe = ad5624r_probe,
-       .remove = __devexit_p(ad5624r_remove),
+       .remove = ad5624r_remove,
        .id_table = ad5624r_id,
 };
 module_spi_driver(ad5624r_driver);
 
 };
 
 
-static int __devinit ad5686_probe(struct spi_device *spi)
+static int ad5686_probe(struct spi_device *spi)
 {
        struct ad5686_state *st;
        struct iio_dev *indio_dev;
        return ret;
 }
 
-static int __devexit ad5686_remove(struct spi_device *spi)
+static int ad5686_remove(struct spi_device *spi)
 {
        struct iio_dev *indio_dev = spi_get_drvdata(spi);
        struct ad5686_state *st = iio_priv(indio_dev);
                   .owner = THIS_MODULE,
                   },
        .probe = ad5686_probe,
-       .remove = __devexit_p(ad5686_remove),
+       .remove = ad5686_remove,
        .id_table = ad5686_id,
 };
 module_spi_driver(ad5686_driver);
 
        }
 }
 
-static int __devinit ad5755_setup_pdata(struct iio_dev *indio_dev,
-       const struct ad5755_platform_data *pdata)
+static int ad5755_setup_pdata(struct iio_dev *indio_dev,
+                             const struct ad5755_platform_data *pdata)
 {
        struct ad5755_state *st = iio_priv(indio_dev);
        unsigned int val;
        return 0;
 }
 
-static bool __devinit ad5755_is_voltage_mode(enum ad5755_mode mode)
+static bool ad5755_is_voltage_mode(enum ad5755_mode mode)
 {
        switch (mode) {
        case AD5755_MODE_VOLTAGE_0V_5V:
        }
 }
 
-static int __devinit ad5755_init_channels(struct iio_dev *indio_dev,
-       const struct ad5755_platform_data *pdata)
+static int ad5755_init_channels(struct iio_dev *indio_dev,
+                               const struct ad5755_platform_data *pdata)
 {
        struct ad5755_state *st = iio_priv(indio_dev);
        struct iio_chan_spec *channels = st->channels;
        },
 };
 
-static int __devinit ad5755_probe(struct spi_device *spi)
+static int ad5755_probe(struct spi_device *spi)
 {
        enum ad5755_type type = spi_get_device_id(spi)->driver_data;
        const struct ad5755_platform_data *pdata = dev_get_platdata(&spi->dev);
        return ret;
 }
 
-static int __devexit ad5755_remove(struct spi_device *spi)
+static int ad5755_remove(struct spi_device *spi)
 {
        struct iio_dev *indio_dev = spi_get_drvdata(spi);
 
                .owner = THIS_MODULE,
        },
        .probe = ad5755_probe,
-       .remove = __devexit_p(ad5755_remove),
+       .remove = ad5755_remove,
        .id_table = ad5755_id,
 };
 module_spi_driver(ad5755_driver);
 
        .driver_module = THIS_MODULE,
 };
 
-static int __devinit ad5764_probe(struct spi_device *spi)
+static int ad5764_probe(struct spi_device *spi)
 {
        enum ad5764_type type = spi_get_device_id(spi)->driver_data;
        struct iio_dev *indio_dev;
        return ret;
 }
 
-static int __devexit ad5764_remove(struct spi_device *spi)
+static int ad5764_remove(struct spi_device *spi)
 {
        struct iio_dev *indio_dev = spi_get_drvdata(spi);
        struct ad5764_state *st = iio_priv(indio_dev);
                .owner = THIS_MODULE,
        },
        .probe = ad5764_probe,
-       .remove = __devexit_p(ad5764_remove),
+       .remove = ad5764_remove,
        .id_table = ad5764_ids,
 };
 module_spi_driver(ad5764_driver);
 
        .driver_module = THIS_MODULE,
 };
 
-static int __devinit ad5791_probe(struct spi_device *spi)
+static int ad5791_probe(struct spi_device *spi)
 {
        struct ad5791_platform_data *pdata = spi->dev.platform_data;
        struct iio_dev *indio_dev;
        return ret;
 }
 
-static int __devexit ad5791_remove(struct spi_device *spi)
+static int ad5791_remove(struct spi_device *spi)
 {
        struct iio_dev *indio_dev = spi_get_drvdata(spi);
        struct ad5791_state *st = iio_priv(indio_dev);
                   .owner = THIS_MODULE,
                   },
        .probe = ad5791_probe,
-       .remove = __devexit_p(ad5791_remove),
+       .remove = ad5791_remove,
        .id_table = ad5791_id,
 };
 module_spi_driver(ad5791_driver);
 
        MAX517_CHANNEL(1)
 };
 
-static int __devinit max517_probe(struct i2c_client *client,
+static int max517_probe(struct i2c_client *client,
                        const struct i2c_device_id *id)
 {
        struct max517_data *data;
        return err;
 }
 
-static int __devexit max517_remove(struct i2c_client *client)
+static int max517_remove(struct i2c_client *client)
 {
        iio_device_unregister(i2c_get_clientdata(client));
        iio_device_free(i2c_get_clientdata(client));
                .pm             = MAX517_PM_OPS,
        },
        .probe          = max517_probe,
-       .remove         =  __devexit_p(max517_remove),
+       .remove         = max517_remove,
        .id_table       = max517_id,
 };
 module_i2c_driver(max517_driver);
 
        .driver_module = THIS_MODULE,
 };
 
-static int __devinit mcp4725_probe(struct i2c_client *client,
-                       const struct i2c_device_id *id)
+static int mcp4725_probe(struct i2c_client *client,
+                        const struct i2c_device_id *id)
 {
        struct mcp4725_data *data;
        struct iio_dev *indio_dev;
        return err;
 }
 
-static int __devexit mcp4725_remove(struct i2c_client *client)
+static int mcp4725_remove(struct i2c_client *client)
 {
        struct iio_dev *indio_dev = i2c_get_clientdata(client);
 
                .pm     = MCP4725_PM_OPS,
        },
        .probe          = mcp4725_probe,
-       .remove         = __devexit_p(mcp4725_remove),
+       .remove         = mcp4725_remove,
        .id_table       = mcp4725_id,
 };
 module_i2c_driver(mcp4725_driver);
 
        return 0;
 }
 
-static int __devinit ad9523_probe(struct spi_device *spi)
+static int ad9523_probe(struct spi_device *spi)
 {
        struct ad9523_platform_data *pdata = spi->dev.platform_data;
        struct iio_dev *indio_dev;
        return ret;
 }
 
-static int __devexit ad9523_remove(struct spi_device *spi)
+static int ad9523_remove(struct spi_device *spi)
 {
        struct iio_dev *indio_dev = spi_get_drvdata(spi);
        struct ad9523_state *st = iio_priv(indio_dev);
                .owner  = THIS_MODULE,
        },
        .probe          = ad9523_probe,
-       .remove         = __devexit_p(ad9523_remove),
+       .remove         = ad9523_remove,
        .id_table       = ad9523_id,
 };
 module_spi_driver(ad9523_driver);
 
        .driver_module = THIS_MODULE,
 };
 
-static int __devinit adf4350_probe(struct spi_device *spi)
+static int adf4350_probe(struct spi_device *spi)
 {
        struct adf4350_platform_data *pdata = spi->dev.platform_data;
        struct iio_dev *indio_dev;
        return ret;
 }
 
-static int __devexit adf4350_remove(struct spi_device *spi)
+static int adf4350_remove(struct spi_device *spi)
 {
        struct iio_dev *indio_dev = spi_get_drvdata(spi);
        struct adf4350_state *st = iio_priv(indio_dev);
                .owner  = THIS_MODULE,
        },
        .probe          = adf4350_probe,
-       .remove         = __devexit_p(adf4350_remove),
+       .remove         = adf4350_remove,
        .id_table       = adf4350_id,
 };
 module_spi_driver(adf4350_driver);
 
 }
 
 /* Function to initialize the processing for usage id */
-static int __devinit hid_gyro_3d_probe(struct platform_device *pdev)
+static int hid_gyro_3d_probe(struct platform_device *pdev)
 {
        int ret = 0;
        static const char *name = "gyro_3d";
 }
 
 /* Function to deinitialize the processing for usage id */
-static int __devinit hid_gyro_3d_remove(struct platform_device *pdev)
+static int hid_gyro_3d_remove(struct platform_device *pdev)
 {
        struct hid_sensor_hub_device *hsdev = pdev->dev.platform_data;
        struct iio_dev *indio_dev = platform_get_drvdata(pdev);
 
        .driver_module = THIS_MODULE,
 };
 
-static int __devinit adjd_s311_probe(struct i2c_client *client,
-                       const struct i2c_device_id *id)
+static int adjd_s311_probe(struct i2c_client *client,
+                          const struct i2c_device_id *id)
 {
        struct adjd_s311_data *data;
        struct iio_dev *indio_dev;
        return err;
 }
 
-static int __devexit adjd_s311_remove(struct i2c_client *client)
+static int adjd_s311_remove(struct i2c_client *client)
 {
        struct iio_dev *indio_dev = i2c_get_clientdata(client);
        struct adjd_s311_data *data = iio_priv(indio_dev);
                .name   = ADJD_S311_DRV_NAME,
        },
        .probe          = adjd_s311_probe,
-       .remove         = __devexit_p(adjd_s311_remove),
+       .remove         = adjd_s311_remove,
        .id_table       = adjd_s311_id,
 };
 module_i2c_driver(adjd_s311_driver);
 
 }
 
 /* Function to initialize the processing for usage id */
-static int __devinit hid_als_probe(struct platform_device *pdev)
+static int hid_als_probe(struct platform_device *pdev)
 {
        int ret = 0;
        static const char *name = "als";
 }
 
 /* Function to deinitialize the processing for usage id */
-static int __devinit hid_als_remove(struct platform_device *pdev)
+static int hid_als_remove(struct platform_device *pdev)
 {
        struct hid_sensor_hub_device *hsdev = pdev->dev.platform_data;
        struct iio_dev *indio_dev = platform_get_drvdata(pdev);
 
        .attrs = lm3533_als_attributes
 };
 
-static int __devinit lm3533_als_set_input_mode(struct lm3533_als *als,
-                                                               bool pwm_mode)
+static int lm3533_als_set_input_mode(struct lm3533_als *als, bool pwm_mode)
 {
        u8 mask = LM3533_ALS_INPUT_MODE_MASK;
        u8 val;
        return 0;
 }
 
-static int __devinit lm3533_als_set_resistor(struct lm3533_als *als, u8 val)
+static int lm3533_als_set_resistor(struct lm3533_als *als, u8 val)
 {
        int ret;
 
        return 0;
 }
 
-static int __devinit lm3533_als_setup(struct lm3533_als *als,
-                                       struct lm3533_als_platform_data *pdata)
+static int lm3533_als_setup(struct lm3533_als *als,
+                           struct lm3533_als_platform_data *pdata)
 {
        int ret;
 
        return 0;
 }
 
-static int __devinit lm3533_als_setup_irq(struct lm3533_als *als, void *dev)
+static int lm3533_als_setup_irq(struct lm3533_als *als, void *dev)
 {
        u8 mask = LM3533_ALS_INT_ENABLE_MASK;
        int ret;
        return 0;
 }
 
-static int __devinit lm3533_als_enable(struct lm3533_als *als)
+static int lm3533_als_enable(struct lm3533_als *als)
 {
        u8 mask = LM3533_ALS_ENABLE_MASK;
        int ret;
        .read_raw       = &lm3533_als_read_raw,
 };
 
-static int __devinit lm3533_als_probe(struct platform_device *pdev)
+static int lm3533_als_probe(struct platform_device *pdev)
 {
        struct lm3533 *lm3533;
        struct lm3533_als_platform_data *pdata;
        return ret;
 }
 
-static int __devexit lm3533_als_remove(struct platform_device *pdev)
+static int lm3533_als_remove(struct platform_device *pdev)
 {
        struct iio_dev *indio_dev = platform_get_drvdata(pdev);
        struct lm3533_als *als = iio_priv(indio_dev);
                .owner  = THIS_MODULE,
        },
        .probe          = lm3533_als_probe,
-       .remove         = __devexit_p(lm3533_als_remove),
+       .remove         = lm3533_als_remove,
 };
 module_platform_driver(lm3533_als_driver);
 
 
        .driver_module = THIS_MODULE,
 };
 
-static int __devinit vcnl4000_probe(struct i2c_client *client,
-                                       const struct i2c_device_id *id)
+static int vcnl4000_probe(struct i2c_client *client,
+                         const struct i2c_device_id *id)
 {
        struct vcnl4000_data *data;
        struct iio_dev *indio_dev;
        return ret;
 }
 
-static int __devexit vcnl4000_remove(struct i2c_client *client)
+static int vcnl4000_remove(struct i2c_client *client)
 {
        struct iio_dev *indio_dev = i2c_get_clientdata(client);
 
                .owner  = THIS_MODULE,
        },
        .probe  = vcnl4000_probe,
-       .remove = __devexit_p(vcnl4000_remove),
+       .remove = vcnl4000_remove,
        .id_table = vcnl4000_id,
 };
 
 
 }
 
 /* Function to initialize the processing for usage id */
-static int __devinit hid_magn_3d_probe(struct platform_device *pdev)
+static int hid_magn_3d_probe(struct platform_device *pdev)
 {
        int ret = 0;
        static char *name = "magn_3d";
 }
 
 /* Function to deinitialize the processing for usage id */
-static int __devinit hid_magn_3d_remove(struct platform_device *pdev)
+static int hid_magn_3d_remove(struct platform_device *pdev)
 {
        struct hid_sensor_hub_device *hsdev = pdev->dev.platform_data;
        struct iio_dev *indio_dev = platform_get_drvdata(pdev);