diff --git a/Documentation/devicetree/bindings/input/rmi4.txt b/Documentation/devicetree/bindings/input/rmi4.txt
new file mode 100644
index 0000000..fff9db7
--- /dev/null
+++ b/Documentation/devicetree/bindings/input/rmi4.txt
@@ -0,0 +1,107 @@
+Synaptics RMI4-based input device binding
+
+PROPERTIES
+
+compatible:
+	Usage: required
+	Type: string, must be "syn,rmi_i2c"
+
+interrupts:
+	Usage: required
+	Type: <prop-encoded-array>
+	Desc: See devicetree/bindings/interrupt-controller/interrupts.txt;
+		Trigger sense required in mask
+
+syn,reset-delay:
+	Usage: optional (default: 100)
+	Type: u32, milliseconds
+	Desc: Delay after issuing a reset
+
+syn,power-no-sleep:
+	Usage: optional, mutually exclusive with syn,power-sleep
+		(default: chip-specific)
+	Type: boolean
+	Desc: Disable sleep mode
+
+syn,power-sleep:
+	Usage: optional, mutually exclusive with syn,power-no-sleep
+		(default: chip-specific)
+	Type: boolean
+	Desc: Enable sleep mode
+
+syn,power-wakeup-thresh:
+	Usage: optional (default: chip-specific)
+	Type: u32, chip-specific unit [0-255]
+	Desc: Capacitance threshold at which device should wake
+
+syn,power-doze-holdoff:
+	Usage: optional (default: chip-specific)
+	Type: u32, milliseconds [0-25500]
+	Desc: Idle delay before entering sleep mode
+
+syn,power-doze-interval:
+	Usage: optional (default: chip-specific)
+	Type: u32, milliseconds [0-2550]
+	Desc: Interval between checks for idle
+
+syn,2d-rezero-wait:
+	Usage: optional (default: no re-zeroing)
+	Type: u32, milliseconds [0-65535]
+	Desc: Delay after resume to re-zero sensor
+
+syn,2d-axis-swap:
+	Usage: optional (default: false)
+	Type: boolean
+	Desc: Swap X and Y axis
+
+syn,2d-flip-x:
+	Usage: optional (default: false)
+	Type: boolean
+	Desc: Invert X axis
+
+syn,2d-flip-y:
+	Usage: optional (default: false)
+	Type: boolean
+	Desc: Invert Y axis
+
+syn,2d-clip-range:
+	Usage: optional (default: clip disabled)
+	Type: u32 array (<top left bottom right>) [0-65535]
+	Usage: Clip values outside this range
+
+syn,2d-offset:
+	Usage: optional (default: offset disabled)
+	Type: u32 array (<X-offset Y-offset>) [0-65535]
+	Usage: Add offset values to reported events
+
+syn,2d-delta-thresh:
+	Usage: optional (default: chip-specific)
+	Type: u32 array (<X-delta Y-delta>) [0-255]
+	Usage: Minimum delta before event is reported
+
+syn,2d-sensor-type:
+	Usage: optional (default: chip-specific)
+	Type: string, "indirect" or "direct"
+	Usage: Set screen type for event reporting
+
+syn,2d-type-a:
+	Usage: optional (default: false)
+	Type: boolean
+	Usage: Sensor supports only Multifinger Type A protocol
+
+EXAMPLE
+
+i2c@0 {
+	compatible = "...";
+	#address-cells = <1>;
+	#size-cells = <0>;
+
+	synaptics_rmi4@2c {
+		compatible = "syn,rmi_i2c";
+		reg = <0x2c>;
+
+		interrupts = <61 IRQ_TYPE_EDGE_FALLING>;
+
+		syn,2d-clip-range = <0 0 1919 1079>;
+	};
+};
diff --git a/Documentation/devicetree/bindings/vendor-prefixes.txt b/Documentation/devicetree/bindings/vendor-prefixes.txt
index edbb8d8..3388986 100644
--- a/Documentation/devicetree/bindings/vendor-prefixes.txt
+++ b/Documentation/devicetree/bindings/vendor-prefixes.txt
@@ -72,6 +72,7 @@ snps 	Synopsys, Inc.
 st	STMicroelectronics
 ste	ST-Ericsson
 stericsson	ST-Ericsson
+syn	Synaptics, Inc.
 ti	Texas Instruments
 toshiba	Toshiba Corporation
 toumaz	Toumaz
diff --git a/drivers/input/rmi4/rmi_bus.c b/drivers/input/rmi4/rmi_bus.c
index a51e6b4..57de579 100644
--- a/drivers/input/rmi4/rmi_bus.c
+++ b/drivers/input/rmi4/rmi_bus.c
@@ -52,14 +52,11 @@ bool rmi_is_physical_device(struct device *dev)
 int rmi_register_transport_device(struct rmi_transport_dev *xport)
 {
 	static atomic_t transport_device_count = ATOMIC_INIT(0);
-	struct rmi_device_platform_data *pdata = xport->dev->platform_data;
 	struct rmi_device *rmi_dev;
 	int error;
 
-	if (!pdata) {
-		dev_err(xport->dev, "no platform data!\n");
-		return -EINVAL;
-	}
+	if (unlikely(!rmi_bus_type.p))
+		return -EPROBE_DEFER;
 
 	rmi_dev = kzalloc(sizeof(struct rmi_device), GFP_KERNEL);
 	if (!rmi_dev)
@@ -70,8 +67,10 @@ int rmi_register_transport_device(struct rmi_transport_dev *xport)
 
 	dev_set_name(&rmi_dev->dev, "sensor%02d", rmi_dev->number);
 
+	rmi_dev->dev.parent = xport->dev;
 	rmi_dev->dev.bus = &rmi_bus_type;
 	rmi_dev->dev.type = &rmi_device_type;
+	rmi_dev->dev.of_node = xport->dev->of_node;
 
 	xport->rmi_dev = rmi_dev;
 
@@ -206,6 +205,9 @@ int __rmi_register_function_handler(struct rmi_function_handler *handler,
 	struct device_driver *driver = &handler->driver;
 	int error;
 
+	if (WARN_ON(unlikely(!rmi_bus_type.p)))
+		return -EAGAIN;
+
 	driver->bus = &rmi_bus_type;
 	driver->owner = owner;
 	driver->mod_name = mod_name;
diff --git a/drivers/input/rmi4/rmi_bus.h b/drivers/input/rmi4/rmi_bus.h
index a21e4c4..51f9372 100644
--- a/drivers/input/rmi4/rmi_bus.h
+++ b/drivers/input/rmi4/rmi_bus.h
@@ -212,7 +212,8 @@ struct rmi_device {
 };
 
 #define to_rmi_device(d) container_of(d, struct rmi_device, dev)
-#define to_rmi_platform_data(d) ((d)->xport->dev->platform_data)
+#define to_rmi_xport_device(d) ((d)->xport->dev)
+#define to_rmi_platform_data(d) (dev_get_platdata(to_rmi_xport_device(d)))
 
 bool rmi_is_physical_device(struct device *dev);
 
diff --git a/drivers/input/rmi4/rmi_driver.c b/drivers/input/rmi4/rmi_driver.c
index 9ec7b93..92415ce 100644
--- a/drivers/input/rmi4/rmi_driver.c
+++ b/drivers/input/rmi4/rmi_driver.c
@@ -26,6 +26,8 @@
 #include <linux/rmi.h>
 #include <linux/slab.h>
 #include <linux/uaccess.h>
+#include <linux/of_irq.h>
+#include <linux/of.h>
 #include <uapi/linux/input.h>
 #include "rmi_bus.h"
 #include "rmi_driver.h"
@@ -498,7 +500,7 @@ static int create_function(struct rmi_device *rmi_dev,
  * We have to do this before actually building the PDT because the reflash
  * updates (if any) might cause various registers to move around.
  */
-static int rmi_initial_reset(struct rmi_device *rmi_dev)
+static int rmi_initial_reset(struct rmi_device *rmi_dev, u32 reset_delay)
 {
 	struct pdt_entry pdt_entry;
 	int page;
@@ -507,8 +509,6 @@ static int rmi_initial_reset(struct rmi_device *rmi_dev)
 	bool has_f01 = false;
 	int i;
 	int retval;
-	const struct rmi_device_platform_data *pdata =
-			to_rmi_platform_data(rmi_dev);
 
 	dev_dbg(dev, "Initial reset.\n");
 
@@ -538,7 +538,7 @@ static int rmi_initial_reset(struct rmi_device *rmi_dev)
 						retval);
 					return retval;
 				}
-				mdelay(pdata->reset_delay_ms);
+				mdelay(reset_delay);
 				done = true;
 				has_f01 = true;
 				break;
@@ -648,6 +648,8 @@ static int rmi_driver_probe(struct device *dev)
 	struct rmi_device_platform_data *pdata;
 	int retval = 0;
 	struct rmi_device *rmi_dev;
+	unsigned int irq;
+	u32 reset_delay;
 
 	dev_dbg(dev, "%s: Starting probe.\n", __func__);
 
@@ -661,6 +663,28 @@ static int rmi_driver_probe(struct device *dev)
 	rmi_dev->driver = rmi_driver;
 
 	pdata = to_rmi_platform_data(rmi_dev);
+	if (pdata == NULL) {
+#ifdef CONFIG_OF
+		const char *p;
+
+		p = "syn,reset-delay";
+		retval = of_property_read_u32(dev->of_node, p, &reset_delay);
+		if (retval && retval != -EINVAL) {
+			dev_err(dev, "Invalid '%s' property\n", p);
+			return -EINVAL;
+		}
+		if (retval == -EINVAL)
+			reset_delay = 0;
+
+		irq = irq_of_parse_and_map(dev->of_node, 0);
+#else
+		dev_err(dev, "No pdata\n");
+		return -EINVAL;
+#endif
+	} else {
+		reset_delay = pdata->reset_delay_ms;
+		irq = pdata->irq;
+	}
 
 	data = devm_kzalloc(dev, sizeof(struct rmi_driver_data), GFP_KERNEL);
 	if (!data) {
@@ -688,9 +712,9 @@ static int rmi_driver_probe(struct device *dev)
 	 * and leave the customer's device unusable.  So we warn them, and
 	 * continue processing.
 	 */
-	if (!pdata->reset_delay_ms)
-		pdata->reset_delay_ms = DEFAULT_RESET_DELAY_MS;
-	retval = rmi_initial_reset(rmi_dev);
+	if (!reset_delay)
+		reset_delay = DEFAULT_RESET_DELAY_MS;
+	retval = rmi_initial_reset(rmi_dev, reset_delay);
 	if (retval)
 		dev_warn(dev, "RMI initial reset failed! Continuing in spite of this.\n");
 
@@ -762,10 +786,10 @@ static int rmi_driver_probe(struct device *dev)
 		goto err_free_data;
 	}
 
-	data->irq = pdata->irq;
-	if (data->irq < 0) {
+	data->irq = irq;
+	if (data->irq < 0 || data->irq == NO_IRQ) {
 		dev_err(dev, "Failed to get attn IRQ.\n");
-		retval = data->irq;
+		retval = -EINVAL;
 		goto err_free_data;
 
 	}
diff --git a/drivers/input/rmi4/rmi_f01.c b/drivers/input/rmi4/rmi_f01.c
index 4cb9fcb..22b57f2 100644
--- a/drivers/input/rmi4/rmi_f01.c
+++ b/drivers/input/rmi4/rmi_f01.c
@@ -12,6 +12,7 @@
 #include <linux/rmi.h>
 #include <linux/slab.h>
 #include <linux/uaccess.h>
+#include <linux/of.h>
 #include "rmi_driver.h"
 
 #define RMI_PRODUCT_ID_LENGTH    10
@@ -169,15 +170,104 @@ static int rmi_f01_read_properties(struct rmi_device *rmi_dev,
 	return 0;
 }
 
+#ifdef CONFIG_OF
+static int rmi_f01_of_parse(struct device *dev,
+		struct rmi_f01_power_management *cdata)
+{
+	bool sleep, nosleep;
+	const char *p;
+	u32 val;
+	int rc;
+
+	if (dev->of_node == NULL)
+		return -EINVAL;
+
+	memset(cdata, 0, sizeof(*cdata));
+
+	sleep = of_property_read_bool(dev->of_node, "syn,power-sleep");
+	nosleep = of_property_read_bool(dev->of_node, "syn,power-nosleep");
+	if (sleep && nosleep) {
+		dev_err(dev, "'syn,power-sleep' and 'syn,power-nosleep' are mutually exclusive\n");
+		return -EINVAL;
+	}
+	if (sleep)
+		cdata->nosleep = RMI_F01_NOSLEEP_OFF;
+	else if (nosleep)
+		cdata->nosleep = RMI_F01_NOSLEEP_ON;
+
+	p = "syn,power-wakeup-thresh";
+	rc = of_property_read_u32(dev->of_node, p, &val);
+	if (rc && rc != -EINVAL) {
+		dev_err(dev, "Invalid '%s' property\n", p);
+		return rc;
+	}
+	if (rc != -EINVAL) {
+		if (val & ~0xff) {
+			dev_err(dev, "'%s' out of range [0-255]\n", p);
+			return -EINVAL;
+		}
+		cdata->wakeup_threshold = val;
+	}
+
+	p = "syn,power-doze-holdoff";
+	rc = of_property_read_u32(dev->of_node, p, &val);
+	if (rc && rc != -EINVAL) {
+		dev_err(dev, "Invalid '%s' property\n", p);
+		return rc;
+	}
+	if (rc != -EINVAL) {
+		if (val > 25500) {
+			dev_err(dev, "'%s' out of range [0-25500]ms\n", p);
+			return -EINVAL;
+		}
+		cdata->doze_holdoff = (val + 50) / 100;
+	}
+
+	p = "syn,power-doze-interval";
+	rc = of_property_read_u32(dev->of_node, p, &val);
+	if (rc && rc != -EINVAL) {
+		dev_err(dev, "Invalid '%s' property\n", p);
+		return rc;
+	}
+	if (rc != -EINVAL) {
+		if (val > 2550) {
+			dev_err(dev, "'%s' out of range [0-2550]ms\n", p);
+			return -EINVAL;
+		}
+		cdata->doze_interval = (val + 5) / 10;
+	}
+
+	return 0;
+}
+#else
+static int rmi_f01_of_parse(struct device *dev,
+		struct rmi_f01_power_management *cdata)
+{
+	return -EINVAL;
+}
+#endif
+
 static int rmi_f01_initialize(struct rmi_function *fn)
 {
 	u8 temp;
 	int error;
 	u16 ctrl_base_addr;
+	struct rmi_f01_power_management cdata;
 	struct rmi_device *rmi_dev = fn->rmi_dev;
+	struct device *dev = to_rmi_xport_device(rmi_dev);
 	struct rmi_driver_data *driver_data = dev_get_drvdata(&rmi_dev->dev);
 	struct f01_data *data = fn->data;
-	struct rmi_device_platform_data *pdata = to_rmi_platform_data(rmi_dev);
+	struct rmi_device_platform_data *pdata = dev_get_platdata(dev);
+
+	if (pdata != NULL) {
+		cdata = pdata->power_management;
+	} else {
+		error = rmi_f01_of_parse(dev, &cdata);
+		if (error) {
+			dev_err(dev, "Unable to parse DT data\n");
+			return error;
+		}
+	}
 
 	/*
 	 * Set the configured bit and (optionally) other important stuff
@@ -191,7 +281,7 @@ static int rmi_f01_initialize(struct rmi_function *fn)
 		dev_err(&fn->dev, "Failed to read F01 control.\n");
 		return error;
 	}
-	switch (pdata->power_management.nosleep) {
+	switch (cdata.nosleep) {
 	case RMI_F01_NOSLEEP_DEFAULT:
 		break;
 	case RMI_F01_NOSLEEP_OFF:
@@ -262,9 +352,9 @@ static int rmi_f01_initialize(struct rmi_function *fn)
 		data->doze_interval_addr = ctrl_base_addr;
 		ctrl_base_addr++;
 
-		if (pdata->power_management.doze_interval) {
+		if (cdata.doze_interval) {
 			data->device_control.doze_interval =
-				pdata->power_management.doze_interval;
+				cdata.doze_interval;
 			error = rmi_write(rmi_dev, data->doze_interval_addr,
 					data->device_control.doze_interval);
 			if (error < 0) {
@@ -283,9 +373,9 @@ static int rmi_f01_initialize(struct rmi_function *fn)
 		data->wakeup_threshold_addr = ctrl_base_addr;
 		ctrl_base_addr++;
 
-		if (pdata->power_management.wakeup_threshold) {
+		if (cdata.wakeup_threshold) {
 			data->device_control.wakeup_threshold =
-				pdata->power_management.wakeup_threshold;
+				cdata.wakeup_threshold;
 			error = rmi_write(rmi_dev, data->wakeup_threshold_addr,
 					data->device_control.wakeup_threshold);
 			if (error < 0) {
@@ -306,9 +396,8 @@ static int rmi_f01_initialize(struct rmi_function *fn)
 		data->doze_holdoff_addr = ctrl_base_addr;
 		ctrl_base_addr++;
 
-		if (pdata->power_management.doze_holdoff) {
-			data->device_control.doze_holdoff =
-				pdata->power_management.doze_holdoff;
+		if (cdata.doze_holdoff) {
+			data->device_control.doze_holdoff = cdata.doze_holdoff;
 			error = rmi_write(rmi_dev, data->doze_holdoff_addr,
 					data->device_control.doze_holdoff);
 			if (error < 0) {
diff --git a/drivers/input/rmi4/rmi_f11.c b/drivers/input/rmi4/rmi_f11.c
index b114f25..837b6e7 100644
--- a/drivers/input/rmi4/rmi_f11.c
+++ b/drivers/input/rmi4/rmi_f11.c
@@ -13,6 +13,7 @@
 #include <linux/input.h>
 #include <linux/input/mt.h>
 #include <linux/kconfig.h>
+#include <linux/of.h>
 #include <linux/rmi.h>
 #include <linux/slab.h>
 #include "rmi_driver.h"
@@ -794,9 +795,120 @@ static void f11_set_abs_params(struct rmi_function *fn)
 				     0, MT_TOOL_FINGER, 0, 0);
 }
 
+#ifdef CONFIG_OF
+static int rmi_f11_of_parse(struct device *dev,
+		struct rmi_f11_sensor_data *cdata)
+{
+	const char *type;
+	const char *p;
+	u32 a[4];
+	int rc;
+
+	if (dev->of_node == NULL)
+		return -EINVAL;
+
+	memset(cdata, 0, sizeof(*cdata));
+
+	p = "syn,2d-rezero-wait";
+	rc = of_property_read_u32(dev->of_node, p, &a[0]);
+	if (rc && rc != -EINVAL) {
+		dev_err(dev, "Invalid '%s' property\n", p);
+		return rc;
+	}
+	if (rc != -EINVAL) {
+		if (a[0] & ~0xffff) {
+			dev_err(dev, "'%s' value out of range [0-65535]\n", p);
+			return -EINVAL;
+		}
+		cdata->rezero_wait = a[0];
+	}
+
+	cdata->type_a = of_property_read_bool(dev->of_node, "syn,2d-type-a");
+	cdata->axis_align.swap_axes = of_property_read_bool(dev->of_node,
+			"syn,2d-axis-swap");
+	cdata->axis_align.flip_x = of_property_read_bool(dev->of_node,
+			"syn,2d-flip-x");
+	cdata->axis_align.flip_y = of_property_read_bool(dev->of_node,
+			"syn,2d-flip-y");
+
+	p = "syn-2d-clip-range";
+	rc = of_property_read_u32_array(dev->of_node, p, a, 4);
+	if (rc && rc != -EINVAL) {
+		dev_err(dev, "Invalid '%s' property\n", p);
+		return rc;
+	}
+	if (rc != -EINVAL) {
+		if ((a[0] | a[1] | a[2] | a[3]) & ~0xffff) {
+			dev_err(dev, "'%s' values out of range [0-65535]\n", p);
+			return -EINVAL;
+		}
+		cdata->axis_align.clip_x_low = a[0];
+		cdata->axis_align.clip_y_low = a[1];
+		cdata->axis_align.clip_x_high = a[2];
+		cdata->axis_align.clip_y_high = a[3];
+	}
+
+	p = "syn-2d-offset";
+	rc = of_property_read_u32_array(dev->of_node, p, a, 2);
+	if (rc && rc != -EINVAL) {
+		dev_err(dev, "Invalid '%s' property\n", p);
+		return rc;
+	}
+	if (rc != -EINVAL) {
+		if ((a[0] | a[1]) & ~0xffff) {
+			dev_err(dev, "'%s' values out of range [0-65535]\n", p);
+			return -EINVAL;
+		}
+		cdata->axis_align.offset_x = a[0];
+		cdata->axis_align.offset_y = a[1];
+	}
+
+	p = "syn,2d-delta-thresh";
+	rc = of_property_read_u32_array(dev->of_node, p, a, 2);
+	if (rc && rc != -EINVAL) {
+		dev_err(dev, "Invalid '%s' property\n", p);
+		return rc;
+	}
+	if (rc != -EINVAL) {
+		if ((a[0] | a[1]) & ~0xff) {
+			dev_err(dev, "'%s' values out of range [0-255]\n", p);
+			return -EINVAL;
+		}
+		cdata->axis_align.delta_x_threshold = a[0];
+		cdata->axis_align.delta_y_threshold = a[1];
+	}
+
+	p = "syn,2d-sensor-type";
+	rc = of_property_read_string(dev->of_node, p, &type);
+	if (rc && rc != -EINVAL) {
+		dev_err(dev, "Invalid '%s' property\n", p);
+		return rc;
+	}
+	if (rc != -EINVAL) {
+		if (!strcmp(type, "direct")) {
+			cdata->sensor_type = RMI_F11_SENSOR_DIRECT;
+		} else if (!strcmp(type, "indirect")) {
+			cdata->sensor_type = RMI_F11_SENSOR_INDIRECT;
+		} else {
+			dev_err(dev, "'%s' must be one of: \"indirect\", \"direct\"\n", p);
+			return -EINVAL;
+		}
+	}
+
+	return 0;
+}
+#else
+static int rmi_f11_of_parse(struct device *dev,
+		struct rmi_f11_sensor_data *cdata)
+{
+	return -EINVAL;
+}
+#endif
+
 static int rmi_f11_initialize(struct rmi_function *fn)
 {
 	struct rmi_device *rmi_dev = fn->rmi_dev;
+	struct device *dev = to_rmi_xport_device(rmi_dev);
 	struct f11_data *f11;
 	struct f11_2d_ctrl *ctrl;
 	u8 query_offset;
@@ -804,12 +916,23 @@ static int rmi_f11_initialize(struct rmi_function *fn)
 	u16 control_base_addr;
 	u16 max_x_pos, max_y_pos, temp;
 	int rc;
-	struct rmi_device_platform_data *pdata = to_rmi_platform_data(rmi_dev);
+	struct rmi_device_platform_data *pdata = dev_get_platdata(dev);
+	struct rmi_f11_sensor_data cdata;
 	struct f11_2d_sensor *sensor;
 	u8 buf;
 
 	dev_dbg(&fn->dev, "Initializing F11 values.\n");
 
+	if (pdata != NULL) {
+		cdata = pdata->f11_sensor_data;
+	} else {
+		rc = rmi_f11_of_parse(dev, &cdata);
+		if (rc) {
+			dev_err(dev, "Unable to parse DT data\n");
+			return rc;
+		}
+	}
+
 	/*
 	** init instance data, fill in values and create any sysfs files
 	*/
@@ -818,7 +941,7 @@ static int rmi_f11_initialize(struct rmi_function *fn)
 		return -ENOMEM;
 
 	fn->data = f11;
-	f11->rezero_wait_ms = pdata->f11_sensor_data.rezero_wait;
+	f11->rezero_wait_ms = cdata.rezero_wait;
 
 	query_base_addr = fn->fd.query_base_addr;
 	control_base_addr = fn->fd.control_base_addr;
@@ -851,9 +974,9 @@ static int rmi_f11_initialize(struct rmi_function *fn)
 		return rc;
 	}
 
-	sensor->axis_align = pdata->f11_sensor_data.axis_align;
-	sensor->type_a = pdata->f11_sensor_data.type_a;
-	sensor->sensor_type = pdata->f11_sensor_data.sensor_type;
+	sensor->axis_align = cdata.axis_align;
+	sensor->type_a = cdata.type_a;
+	sensor->sensor_type = cdata.sensor_type;
 
 	rc = rmi_read_block(rmi_dev,
 		control_base_addr + F11_CTRL_SENSOR_MAX_X_POS_OFFSET,
diff --git a/drivers/input/rmi4/rmi_i2c.c b/drivers/input/rmi4/rmi_i2c.c
index aebf974..377d4cc 100644
--- a/drivers/input/rmi4/rmi_i2c.c
+++ b/drivers/input/rmi4/rmi_i2c.c
@@ -186,16 +186,9 @@ static const struct rmi_transport_ops rmi_i2c_ops = {
 static int rmi_i2c_probe(struct i2c_client *client,
 			 const struct i2c_device_id *id)
 {
-	const struct rmi_device_platform_data *pdata =
-				dev_get_platdata(&client->dev);
 	struct rmi_i2c_xport *rmi_i2c;
 	int retval;
 
-	if (!pdata) {
-		dev_err(&client->dev, "no platform data\n");
-		return -EINVAL;
-	}
-
 	dev_dbg(&client->dev, "Probing %#02x.\n", client->addr);
 
 	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
@@ -258,10 +251,20 @@ static const struct i2c_device_id rmi_id[] = {
 };
 MODULE_DEVICE_TABLE(i2c, rmi_id);
 
+#ifdef CONFIG_OF
+static struct of_device_id rmi_match_table[] = {
+	{ .compatible = "syn,rmi_i2c", },
+	{ },
+};
+#else
+#define rmi_match_table NULL
+#endif
+
 static struct i2c_driver rmi_i2c_driver = {
 	.driver = {
 		.owner	= THIS_MODULE,
-		.name	= "rmi_i2c"
+		.name	= "rmi_i2c",
+		.of_match_table = rmi_match_table,
 	},
 	.id_table	= rmi_id,
 	.probe		= rmi_i2c_probe,
