struct st_sensor_data *adata = iio_priv(indio_dev);
        struct st_sensors_platform_data *pdata =
                (struct st_sensors_platform_data *)adata->dev->platform_data;
-       int irq = adata->get_irq_data_ready(indio_dev);
        struct iio_chan_spec *channels;
        size_t channels_size;
        int err;
        if (err < 0)
                goto st_accel_power_off;
 
-       if (irq > 0) {
+       if (adata->irq > 0) {
                err = st_sensors_allocate_trigger(indio_dev,
                                                 ST_ACCEL_TRIGGER_OPS);
                if (err < 0)
        return 0;
 
 st_accel_device_register_error:
-       if (irq > 0)
+       if (adata->irq > 0)
                st_sensors_deallocate_trigger(indio_dev);
 st_accel_probe_trigger_error:
        st_accel_deallocate_ring(indio_dev);
        st_sensors_power_disable(indio_dev);
 
        iio_device_unregister(indio_dev);
-       if (adata->get_irq_data_ready(indio_dev) > 0)
+       if (adata->irq > 0)
                st_sensors_deallocate_trigger(indio_dev);
 
        st_accel_deallocate_ring(indio_dev);
 
 
 #define ST_SENSORS_I2C_MULTIREAD       0x80
 
-static unsigned int st_sensors_i2c_get_irq(struct iio_dev *indio_dev)
-{
-       struct st_sensor_data *sdata = iio_priv(indio_dev);
-
-       return to_i2c_client(sdata->dev)->irq;
-}
-
 static const struct regmap_config st_sensors_i2c_regmap_config = {
        .reg_bits = 8,
        .val_bits = 8,
        indio_dev->name = client->name;
 
        sdata->dev = &client->dev;
-       sdata->get_irq_data_ready = st_sensors_i2c_get_irq;
+       sdata->irq = client->irq;
 
        return 0;
 }
 
 
 #define ST_SENSORS_SPI_MULTIREAD       0xc0
 
-static unsigned int st_sensors_spi_get_irq(struct iio_dev *indio_dev)
-{
-       struct st_sensor_data *sdata = iio_priv(indio_dev);
-
-       return to_spi_device(sdata->dev)->irq;
-}
-
 static const struct regmap_config st_sensors_spi_regmap_config = {
        .reg_bits = 8,
        .val_bits = 8,
        indio_dev->name = spi->modalias;
 
        sdata->dev = &spi->dev;
-       sdata->get_irq_data_ready = st_sensors_spi_get_irq;
+       sdata->irq = spi->irq;
 
        return 0;
 }
 
 int st_sensors_allocate_trigger(struct iio_dev *indio_dev,
                                const struct iio_trigger_ops *trigger_ops)
 {
-       int err, irq;
        struct st_sensor_data *sdata = iio_priv(indio_dev);
        unsigned long irq_trig;
+       int err;
 
        sdata->trig = iio_trigger_alloc("%s-trigger", indio_dev->name);
        if (sdata->trig == NULL) {
        sdata->trig->ops = trigger_ops;
        sdata->trig->dev.parent = sdata->dev;
 
-       irq = sdata->get_irq_data_ready(indio_dev);
-       irq_trig = irqd_get_trigger_type(irq_get_irq_data(irq));
+       irq_trig = irqd_get_trigger_type(irq_get_irq_data(sdata->irq));
        /*
         * If the IRQ is triggered on falling edge, we need to mark the
         * interrupt as active low, if the hardware supports this.
            sdata->sensor_settings->drdy_irq.stat_drdy.addr)
                irq_trig |= IRQF_SHARED;
 
-       err = request_threaded_irq(sdata->get_irq_data_ready(indio_dev),
-                       st_sensors_irq_handler,
-                       st_sensors_irq_thread,
-                       irq_trig,
-                       sdata->trig->name,
-                       sdata->trig);
+       err = request_threaded_irq(sdata->irq,
+                                  st_sensors_irq_handler,
+                                  st_sensors_irq_thread,
+                                  irq_trig,
+                                  sdata->trig->name,
+                                  sdata->trig);
        if (err) {
                dev_err(&indio_dev->dev, "failed to request trigger IRQ.\n");
                goto iio_trigger_free;
        return 0;
 
 iio_trigger_register_error:
-       free_irq(sdata->get_irq_data_ready(indio_dev), sdata->trig);
+       free_irq(sdata->irq, sdata->trig);
 iio_trigger_free:
        iio_trigger_free(sdata->trig);
        return err;
        struct st_sensor_data *sdata = iio_priv(indio_dev);
 
        iio_trigger_unregister(sdata->trig);
-       free_irq(sdata->get_irq_data_ready(indio_dev), sdata->trig);
+       free_irq(sdata->irq, sdata->trig);
        iio_trigger_free(sdata->trig);
 }
 EXPORT_SYMBOL(st_sensors_deallocate_trigger);
 
 int st_gyro_common_probe(struct iio_dev *indio_dev)
 {
        struct st_sensor_data *gdata = iio_priv(indio_dev);
-       int irq = gdata->get_irq_data_ready(indio_dev);
        int err;
 
        indio_dev->modes = INDIO_DIRECT_MODE;
        if (err < 0)
                goto st_gyro_power_off;
 
-       if (irq > 0) {
+       if (gdata->irq > 0) {
                err = st_sensors_allocate_trigger(indio_dev,
                                                  ST_GYRO_TRIGGER_OPS);
                if (err < 0)
        return 0;
 
 st_gyro_device_register_error:
-       if (irq > 0)
+       if (gdata->irq > 0)
                st_sensors_deallocate_trigger(indio_dev);
 st_gyro_probe_trigger_error:
        st_gyro_deallocate_ring(indio_dev);
        st_sensors_power_disable(indio_dev);
 
        iio_device_unregister(indio_dev);
-       if (gdata->get_irq_data_ready(indio_dev) > 0)
+       if (gdata->irq > 0)
                st_sensors_deallocate_trigger(indio_dev);
 
        st_gyro_deallocate_ring(indio_dev);
 
 int st_magn_common_probe(struct iio_dev *indio_dev)
 {
        struct st_sensor_data *mdata = iio_priv(indio_dev);
-       int irq = mdata->get_irq_data_ready(indio_dev);
        int err;
 
        indio_dev->modes = INDIO_DIRECT_MODE;
        if (err < 0)
                goto st_magn_power_off;
 
-       if (irq > 0) {
+       if (mdata->irq > 0) {
                err = st_sensors_allocate_trigger(indio_dev,
                                                ST_MAGN_TRIGGER_OPS);
                if (err < 0)
        return 0;
 
 st_magn_device_register_error:
-       if (irq > 0)
+       if (mdata->irq > 0)
                st_sensors_deallocate_trigger(indio_dev);
 st_magn_probe_trigger_error:
        st_magn_deallocate_ring(indio_dev);
        st_sensors_power_disable(indio_dev);
 
        iio_device_unregister(indio_dev);
-       if (mdata->get_irq_data_ready(indio_dev) > 0)
+       if (mdata->irq > 0)
                st_sensors_deallocate_trigger(indio_dev);
 
        st_magn_deallocate_ring(indio_dev);
 
        struct st_sensor_data *press_data = iio_priv(indio_dev);
        struct st_sensors_platform_data *pdata =
                (struct st_sensors_platform_data *)press_data->dev->platform_data;
-       int irq = press_data->get_irq_data_ready(indio_dev);
        int err;
 
        indio_dev->modes = INDIO_DIRECT_MODE;
        if (err < 0)
                goto st_press_power_off;
 
-       if (irq > 0) {
+       if (press_data->irq > 0) {
                err = st_sensors_allocate_trigger(indio_dev,
                                                  ST_PRESS_TRIGGER_OPS);
                if (err < 0)
        return err;
 
 st_press_device_register_error:
-       if (irq > 0)
+       if (press_data->irq > 0)
                st_sensors_deallocate_trigger(indio_dev);
 st_press_probe_trigger_error:
        st_press_deallocate_ring(indio_dev);
        st_sensors_power_disable(indio_dev);
 
        iio_device_unregister(indio_dev);
-       if (press_data->get_irq_data_ready(indio_dev) > 0)
+       if (press_data->irq > 0)
                st_sensors_deallocate_trigger(indio_dev);
 
        st_press_deallocate_ring(indio_dev);
 
  * num_data_channels: Number of data channels used in buffer.
  * @drdy_int_pin: Redirect DRDY on pin 1 (1) or pin 2 (2).
  * @int_pin_open_drain: Set the interrupt/DRDY to open drain.
- * @get_irq_data_ready: Function to get the IRQ used for data ready signal.
+ * @irq: the IRQ number.
  * @edge_irq: the IRQ triggers on edges and need special handling.
  * @hw_irq_trigger: if we're using the hardware interrupt on the sensor.
  * @hw_timestamp: Latest timestamp from the interrupt handler, when in use.
 
        u8 drdy_int_pin;
        bool int_pin_open_drain;
-
-       unsigned int (*get_irq_data_ready) (struct iio_dev *indio_dev);
+       int irq;
 
        bool edge_irq;
        bool hw_irq_trigger;