#include <linux/iio/common/st_sensors_i2c.h>
 #include "st_accel.h"
 
-#ifdef CONFIG_OF
 static const struct of_device_id st_accel_of_match[] = {
        {
                /* An older compatible */
        {},
 };
 MODULE_DEVICE_TABLE(of, st_accel_of_match);
-#else
-#define st_accel_of_match NULL
-#endif
 
 #ifdef CONFIG_ACPI
 static const struct acpi_device_id st_accel_acpi_match[] = {
 static struct i2c_driver st_accel_driver = {
        .driver = {
                .name = "st-accel-i2c",
-               .of_match_table = of_match_ptr(st_accel_of_match),
+               .of_match_table = st_accel_of_match,
                .acpi_match_table = ACPI_PTR(st_accel_acpi_match),
        },
        .probe_new = st_accel_i2c_probe,
 
 #include <linux/iio/common/st_sensors_spi.h>
 #include "st_accel.h"
 
-#ifdef CONFIG_OF
 /*
  * For new single-chip sensors use <device_name> as compatible string.
  * For old single-chip devices keep <device_name>-accel to maintain
        {}
 };
 MODULE_DEVICE_TABLE(of, st_accel_of_match);
-#else
-#define st_accel_of_match      NULL
-#endif
 
 static int st_accel_spi_probe(struct spi_device *spi)
 {
 static struct spi_driver st_accel_driver = {
        .driver = {
                .name = "st-accel-spi",
-               .of_match_table = of_match_ptr(st_accel_of_match),
+               .of_match_table = st_accel_of_match,
        },
        .probe = st_accel_spi_probe,
        .remove = st_accel_spi_remove,
 
 #include <linux/iio/iio.h>
 #include <linux/property.h>
 #include <linux/regulator/consumer.h>
-#include <linux/of.h>
-#include <linux/of_device.h>
 #include <linux/regmap.h>
 #include <asm/unaligned.h>
 #include <linux/iio/common/st_sensors.h>
        return 0;
 }
 
-#ifdef CONFIG_OF
-static struct st_sensors_platform_data *st_sensors_of_probe(struct device *dev,
+static struct st_sensors_platform_data *st_sensors_dev_probe(struct device *dev,
                struct st_sensors_platform_data *defdata)
 {
        struct st_sensors_platform_data *pdata;
-       struct device_node *np = dev->of_node;
        u32 val;
 
-       if (!np)
+       if (!dev_fwnode(dev))
                return NULL;
 
        pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
-       if (!of_property_read_u32(np, "st,drdy-int-pin", &val) && (val <= 2))
+       if (!device_property_read_u32(dev, "st,drdy-int-pin", &val) && (val <= 2))
                pdata->drdy_int_pin = (u8) val;
        else
                pdata->drdy_int_pin = defdata ? defdata->drdy_int_pin : 0;
 
-       pdata->open_drain = of_property_read_bool(np, "drive-open-drain");
+       pdata->open_drain = device_property_read_bool(dev, "drive-open-drain");
 
        return pdata;
 }
-#else
-static struct st_sensors_platform_data *st_sensors_of_probe(struct device *dev,
-               struct st_sensors_platform_data *defdata)
-{
-       return NULL;
-}
-#endif
 
 /**
  * st_sensors_dev_name_probe() - device probe for ST sensor name
        int err = 0;
 
        /* If OF/DT pdata exists, it will take precedence of anything else */
-       of_pdata = st_sensors_of_probe(indio_dev->dev.parent, pdata);
+       of_pdata = st_sensors_dev_probe(indio_dev->dev.parent, pdata);
        if (of_pdata)
                pdata = of_pdata;
 
 
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/iio/iio.h>
+#include <linux/property.h>
 #include <linux/regmap.h>
 
 #include <linux/iio/common/st_sensors_spi.h>
  */
 static bool st_sensors_is_spi_3_wire(struct spi_device *spi)
 {
-       struct device_node *np = spi->dev.of_node;
        struct st_sensors_platform_data *pdata;
+       struct device *dev = &spi->dev;
 
-       pdata = (struct st_sensors_platform_data *)spi->dev.platform_data;
-       if ((np && of_property_read_bool(np, "spi-3wire")) ||
-           (pdata && pdata->spi_3wire)) {
+       if (device_property_read_bool(dev, "spi-3wire"))
+               return true;
+
+       pdata = (struct st_sensors_platform_data *)dev->platform_data;
+       if (pdata && pdata->spi_3wire)
                return true;
-       }
 
        return false;
 }
 
 #include <linux/iio/common/st_sensors_i2c.h>
 #include "st_gyro.h"
 
-#ifdef CONFIG_OF
 static const struct of_device_id st_gyro_of_match[] = {
        {
                .compatible = "st,l3g4200d-gyro",
        {},
 };
 MODULE_DEVICE_TABLE(of, st_gyro_of_match);
-#else
-#define st_gyro_of_match NULL
-#endif
 
 static int st_gyro_i2c_probe(struct i2c_client *client,
                             const struct i2c_device_id *id)
 static struct i2c_driver st_gyro_driver = {
        .driver = {
                .name = "st-gyro-i2c",
-               .of_match_table = of_match_ptr(st_gyro_of_match),
+               .of_match_table = st_gyro_of_match,
        },
        .probe = st_gyro_i2c_probe,
        .remove = st_gyro_i2c_remove,
 
 #include <linux/iio/common/st_sensors_spi.h>
 #include "st_gyro.h"
 
-#ifdef CONFIG_OF
 /*
  * For new single-chip sensors use <device_name> as compatible string.
  * For old single-chip devices keep <device_name>-gyro to maintain
        {},
 };
 MODULE_DEVICE_TABLE(of, st_gyro_of_match);
-#else
-#define st_gyro_of_match       NULL
-#endif
 
 static int st_gyro_spi_probe(struct spi_device *spi)
 {
 static struct spi_driver st_gyro_driver = {
        .driver = {
                .name = "st-gyro-spi",
-               .of_match_table = of_match_ptr(st_gyro_of_match),
+               .of_match_table = st_gyro_of_match,
        },
        .probe = st_gyro_spi_probe,
        .remove = st_gyro_spi_remove,
 
 #include <linux/iio/common/st_sensors_i2c.h>
 #include "st_magn.h"
 
-#ifdef CONFIG_OF
 static const struct of_device_id st_magn_of_match[] = {
        {
                .compatible = "st,lsm303dlh-magn",
        {},
 };
 MODULE_DEVICE_TABLE(of, st_magn_of_match);
-#else
-#define st_magn_of_match NULL
-#endif
 
 static int st_magn_i2c_probe(struct i2c_client *client,
                             const struct i2c_device_id *id)
 static struct i2c_driver st_magn_driver = {
        .driver = {
                .name = "st-magn-i2c",
-               .of_match_table = of_match_ptr(st_magn_of_match),
+               .of_match_table = st_magn_of_match,
        },
        .probe = st_magn_i2c_probe,
        .remove = st_magn_i2c_remove,
 
 #include <linux/iio/common/st_sensors_spi.h>
 #include "st_magn.h"
 
-#ifdef CONFIG_OF
 /*
  * For new single-chip sensors use <device_name> as compatible string.
  * For old single-chip devices keep <device_name>-magn to maintain
        {}
 };
 MODULE_DEVICE_TABLE(of, st_magn_of_match);
-#else
-#define st_magn_of_match       NULL
-#endif
 
 static int st_magn_spi_probe(struct spi_device *spi)
 {
 static struct spi_driver st_magn_driver = {
        .driver = {
                .name = "st-magn-spi",
-               .of_match_table = of_match_ptr(st_magn_of_match),
+               .of_match_table = st_magn_of_match,
        },
        .probe = st_magn_spi_probe,
        .remove = st_magn_spi_remove,
 
 #include <linux/iio/common/st_sensors_i2c.h>
 #include "st_pressure.h"
 
-#ifdef CONFIG_OF
 static const struct of_device_id st_press_of_match[] = {
        {
                .compatible = "st,lps001wp-press",
        {},
 };
 MODULE_DEVICE_TABLE(of, st_press_of_match);
-#else
-#define st_press_of_match NULL
-#endif
 
 #ifdef CONFIG_ACPI
 static const struct acpi_device_id st_press_acpi_match[] = {
 static struct i2c_driver st_press_driver = {
        .driver = {
                .name = "st-press-i2c",
-               .of_match_table = of_match_ptr(st_press_of_match),
+               .of_match_table = st_press_of_match,
                .acpi_match_table = ACPI_PTR(st_press_acpi_match),
        },
        .probe = st_press_i2c_probe,
 
 #include <linux/iio/common/st_sensors_spi.h>
 #include "st_pressure.h"
 
-#ifdef CONFIG_OF
 /*
  * For new single-chip sensors use <device_name> as compatible string.
  * For old single-chip devices keep <device_name>-press to maintain
        {},
 };
 MODULE_DEVICE_TABLE(of, st_press_of_match);
-#else
-#define st_press_of_match      NULL
-#endif
 
 static int st_press_spi_probe(struct spi_device *spi)
 {
 static struct spi_driver st_press_driver = {
        .driver = {
                .name = "st-press-spi",
-               .of_match_table = of_match_ptr(st_press_of_match),
+               .of_match_table = st_press_of_match,
        },
        .probe = st_press_spi_probe,
        .remove = st_press_spi_remove,