input synaptics-rmi4: Remove sysfs & debugfs stuff

Commit Message

Christopher Heiny Dec. 3, 2013, 12:52 a.m. UTC

This patch implements changes to the synaptics-rmi4 branch of
Dmitry's input tree.  The base for the patchset is Dmitry's commit
4a695a01fba9bf467b3b52e124ccee6cef73b323 from 2013-01-31.

Removed all of the sysfs and most of the debugfs support from the driver core
and function drivers.  The code is still horribly broken (as previously
advertised) but should now be easier to work with.  A few lines are reformatted
for line-length issues.

Signed-off-by: Christopher Heiny <[e-mail]>
Cc: Dmitry Torokhov <[e-mail]>
Cc: Jean Delvare <[e-mail]>
Cc: Linus Walleij <[e-mail]>
Cc: Joerie de Gram <[e-mail]>
Cc: Benjamin Tissoires <[e-mail]>

---
 drivers/input/rmi4/rmi_bus.h    |  11 -
 drivers/input/rmi4/rmi_driver.c | 175 +--------
 drivers/input/rmi4/rmi_f01.c    | 787 +---------------------------------------
 drivers/input/rmi4/rmi_f11.c    | 183 ----------
 drivers/input/rmi4/rmi_i2c.c    |   6 +-
 5 files changed, 9 insertions(+), 1153 deletions(-)

--
To unsubscribe from this list: send the line "unsubscribe linux-input" in
the body of a message to [e-mail]
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Comments

Dmitry Torokhov Dec. 5, 2013, 9:01 p.m. UTC | #1

On Mon, Dec 02, 2013 at 04:52:20PM -0800, Christopher Heiny wrote:
> This patch implements changes to the synaptics-rmi4 branch of
> Dmitry's input tree.  The base for the patchset is Dmitry's commit
> 4a695a01fba9bf467b3b52e124ccee6cef73b323 from 2013-01-31.
> 
> Removed all of the sysfs and most of the debugfs support from the driver core
> and function drivers.  The code is still horribly broken (as previously
> advertised) but should now be easier to work with.  A few lines are reformatted
> for line-length issues.
> 
> Signed-off-by: Christopher Heiny <[e-mail]>

Applied, thank you.

> Cc: Dmitry Torokhov <[e-mail]>
> Cc: Jean Delvare <[e-mail]>
> Cc: Linus Walleij <[e-mail]>
> Cc: Joerie de Gram <[e-mail]>
> Cc: Benjamin Tissoires <[e-mail]>
> 
> ---
>  drivers/input/rmi4/rmi_bus.h    |  11 -
>  drivers/input/rmi4/rmi_driver.c | 175 +--------
>  drivers/input/rmi4/rmi_f01.c    | 787 +---------------------------------------
>  drivers/input/rmi4/rmi_f11.c    | 183 ----------
>  drivers/input/rmi4/rmi_i2c.c    |   6 +-
>  5 files changed, 9 insertions(+), 1153 deletions(-)
> 
> diff --git a/drivers/input/rmi4/rmi_bus.h b/drivers/input/rmi4/rmi_bus.h
> index 33e8f1b..e2a3dc6 100644
> --- a/drivers/input/rmi4/rmi_bus.h
> +++ b/drivers/input/rmi4/rmi_bus.h
> @@ -22,17 +22,6 @@
>  #include <linux/debugfs.h>
>  #include <linux/rmi.h>
>  
> -
> -/* Permissions for sysfs attributes.  Since the permissions policy will change
> - * on a global basis in the future, rather than edit all sysfs attrs everywhere
> - * in the driver (and risk screwing that up in the process), we use this handy
> - * set of #defines.  That way when we change the policy for sysfs permissions,
> - * we only need to change them here.
> - */
> -#define RMI_RO_ATTR S_IRUGO
> -#define RMI_RW_ATTR (S_IRUGO | S_IWUGO)
> -#define RMI_WO_ATTR S_IWUGO
> -
>  struct rmi_device;
>  
>  /**
> diff --git a/drivers/input/rmi4/rmi_driver.c b/drivers/input/rmi4/rmi_driver.c
> index 5cf7b33..132cd52 100644
> --- a/drivers/input/rmi4/rmi_driver.c
> +++ b/drivers/input/rmi4/rmi_driver.c
> @@ -4,9 +4,10 @@
>   *
>   * This driver provides the core support for a single RMI4-based device.
>   *
> - * The RMI4 specification can be found here:
> + * The RMI4 specification can be found here (URL split for line length):
>   *
> - * http://www.synaptics.com/sites/default/files/511-000136-01-Rev-E-RMI4%20Intrfacing%20Guide.pdf
> + * http://www.synaptics.com/sites/default/files/
> + *      511-000136-01-Rev-E-RMI4%20Intrfacing%20Guide.pdf
>   *
>   * This program is free software; you can redistribute it and/or modify it
>   * under the terms of the GNU General Public License version 2 as published by
> @@ -42,48 +43,6 @@
>  
>  #define IRQ_DEBUG(data) (IS_ENABLED(CONFIG_RMI4_DEBUG) && data->irq_debug)
>  
> -#ifdef	CONFIG_RMI4_DEBUG
> -static void rmi_driver_setup_debugfs(struct rmi_device *rmi_dev)
> -{
> -	struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev);
> -	struct rmi_phys_info *info = &rmi_dev->phys->info;
> -
> -	if (!rmi_dev->debugfs_root)
> -		return;
> -
> -	if (!debugfs_create_u32_array("transport_stats", RMI_RO_ATTR,
> -				      rmi_dev->debugfs_root,
> -				      (u32 *)&info->tx_count, 6))
> -		dev_warn(&rmi_dev->dev,
> -			 "Failed to create debugfs transport_stats\n");
> -
> -	if (!debugfs_create_bool("irq_debug", RMI_RW_ATTR,
> -				 rmi_dev->debugfs_root,
> -				 &data->irq_debug))
> -		dev_warn(&rmi_dev->dev, "Failed to create debugfs irq_debug\n");
> -
> -	if (!debugfs_create_u32("attn_count", RMI_RO_ATTR,
> -				rmi_dev->debugfs_root,
> -				&data->attn_count))
> -		dev_warn(&rmi_dev->dev,
> -			 "Failed to create debugfs attn_count\n");
> -}
> -
> -static void rmi_driver_teardown_debugfs(struct rmi_device *rmi_dev)
> -{
> -	debugfs_remove_recursive(rmi_dev->debugfs_root);
> -}
> -
> -#else
> -static inline void rmi_driver_setup_debugfs(struct rmi_device *rmi_dev)
> -{
> -}
> -
> -static inline rmi_driver_teardown_debugfs(struct rmi_device *rmi_dev)
> -{
> -}
> -#endif
> -
>  static irqreturn_t rmi_irq_thread(int irq, void *p)
>  {
>  	struct rmi_phys_device *phys = p;
> @@ -217,122 +176,6 @@ static int enable_sensor(struct rmi_device *rmi_dev)
>  	return retval;
>  }
>  
> -/* sysfs show and store fns for driver attributes */
> -
> -static ssize_t rmi_driver_bsr_show(struct device *dev,
> -				   struct device_attribute *attr, char *buf)
> -{
> -	struct rmi_device *rmi_dev;
> -	struct rmi_driver_data *data;
> -	rmi_dev = to_rmi_device(dev);
> -	data = dev_get_drvdata(&rmi_dev->dev);
> -
> -	return snprintf(buf, PAGE_SIZE, "%u\n", data->bsr);
> -}
> -
> -static ssize_t rmi_driver_bsr_store(struct device *dev,
> -				    struct device_attribute *attr,
> -				    const char *buf, size_t count)
> -{
> -	int retval;
> -	unsigned long val;
> -	struct rmi_device *rmi_dev;
> -	struct rmi_driver_data *data;
> -
> -	rmi_dev = to_rmi_device(dev);
> -	data = dev_get_drvdata(&rmi_dev->dev);
> -
> -	/* need to convert the string data to an actual value */
> -	retval = strict_strtoul(buf, 10, &val);
> -	if (retval < 0 || val > 255) {
> -		dev_err(dev, "Invalid value '%s' written to BSR.\n", buf);
> -		return -EINVAL;
> -	}
> -
> -	retval = rmi_write(rmi_dev, BSR_LOCATION, (u8)val);
> -	if (retval < 0) {
> -		dev_err(dev, "%s : failed to write bsr %lu to %#06x\n",
> -			__func__, val, BSR_LOCATION);
> -		return retval;
> -	}
> -
> -	data->bsr = val;
> -
> -	return count;
> -}
> -
> -static DEVICE_ATTR(bsr, RMI_RW_ATTR, rmi_driver_bsr_show, rmi_driver_bsr_store);
> -
> -static ssize_t rmi_driver_enabled_show(struct device *dev,
> -				       struct device_attribute *attr, char *buf)
> -{
> -	struct rmi_device *rmi_dev = to_rmi_device(dev);
> -	struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev);
> -
> -	return snprintf(buf, PAGE_SIZE, "%u\n", data->enabled);
> -}
> -
> -static ssize_t rmi_driver_enabled_store(struct device *dev,
> -					struct device_attribute *attr,
> -					const char *buf, size_t count)
> -{
> -	struct rmi_device *rmi_dev = to_rmi_device(dev);
> -	int retval;
> -	int new_value;
> -
> -	if (sysfs_streq(buf, "0"))
> -		new_value = false;
> -	else if (sysfs_streq(buf, "1"))
> -		new_value = true;
> -	else
> -		return -EINVAL;
> -
> -	if (new_value) {
> -		retval = enable_sensor(rmi_dev);
> -		if (retval) {
> -			dev_err(dev, "Failed to enable sensor, code=%d.\n",
> -				retval);
> -			return -EIO;
> -		}
> -	} else {
> -		disable_sensor(rmi_dev);
> -	}
> -
> -	return count;
> -}
> -
> -/** This sysfs attribute is deprecated, and will be removed in a future release.
> - */
> -static DEVICE_ATTR(enabled, RMI_RW_ATTR,
> -		   rmi_driver_enabled_show, rmi_driver_enabled_store);
> -
> -static umode_t rmi_driver_attr_visible(struct kobject *kobj,
> -				       struct attribute *attr, int n)
> -{
> -	struct device *dev = kobj_to_dev(kobj);
> -	struct rmi_device *rmi_dev = to_rmi_device(dev);
> -	struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev);
> -	umode_t mode = attr->mode;
> -
> -	if (attr == &dev_attr_bsr.attr) {
> -		if (!data->pdt_props.has_bsr)
> -			mode = 0;
> -	}
> -
> -	return mode;
> -}
> -
> -static struct attribute *rmi_driver_attrs[] = {
> -	&dev_attr_bsr.attr,
> -	&dev_attr_enabled.attr,
> -	NULL
> -};
> -
> -static struct attribute_group rmi_driver_attr_group = {
> -	.is_visible	= rmi_driver_attr_visible,
> -	.attrs		= rmi_driver_attrs,
> -};
> -
>  static void rmi_free_function_list(struct rmi_device *rmi_dev)
>  {
>  	struct rmi_function *fn, *tmp;
> @@ -718,7 +561,8 @@ static int reset_and_reflash(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);
> +	const struct rmi_device_platform_data *pdata =
> +			to_rmi_platform_data(rmi_dev);
>  
>  	dev_dbg(dev, "Initial reset.\n");
>  
> @@ -941,7 +785,6 @@ static int rmi_driver_remove(struct device *dev)
>  	struct rmi_device *rmi_dev = to_rmi_device(dev);
>  
>  	rmi_driver_teardown_debugfs(rmi_dev);
> -	sysfs_remove_group(&dev->kobj, &rmi_driver_attr_group);
>  
>  	disable_sensor(rmi_dev);
>  	rmi_free_function_list(rmi_dev);
> @@ -1079,14 +922,6 @@ static int rmi_driver_probe(struct device *dev)
>  		mutex_init(&data->suspend_mutex);
>  	}
>  
> -	retval = sysfs_create_group(&dev->kobj, &rmi_driver_attr_group);
> -	if (retval < 0) {
> -		dev_err(dev, "%s: Failed to create sysfs group\n", __func__);
> -		goto err_free_data;
> -	}
> -
> -	rmi_driver_setup_debugfs(rmi_dev);
> -
>  	if (pdata->attn_gpio) {
>  		data->irq = gpio_to_irq(pdata->attn_gpio);
>  		if (pdata->level_triggered) {
> diff --git a/drivers/input/rmi4/rmi_f01.c b/drivers/input/rmi4/rmi_f01.c
> index fe26869..840a8d0 100644
> --- a/drivers/input/rmi4/rmi_f01.c
> +++ b/drivers/input/rmi4/rmi_f01.c
> @@ -8,7 +8,6 @@
>   */
>  
>  #include <linux/kernel.h>
> -#include <linux/debugfs.h>
>  #include <linux/kconfig.h>
>  #include <linux/rmi.h>
>  #include <linux/slab.h>
> @@ -143,780 +142,6 @@ struct f01_data {
>  	bool suspended;
>  	bool old_nosleep;
>  #endif
> -
> -#ifdef CONFIG_RMI4_DEBUG
> -	struct dentry *debugfs_interrupt_enable;
> -#endif
> -};
> -
> -#ifdef CONFIG_RMI4_DEBUG
> -struct f01_debugfs_data {
> -	bool done;
> -	struct rmi_function *fn;
> -};
> -
> -static int f01_debug_open(struct inode *inodep, struct file *filp)
> -{
> -	struct f01_debugfs_data *data;
> -	struct rmi_function *fn = inodep->i_private;
> -
> -	data = kzalloc(sizeof(struct f01_debugfs_data), GFP_KERNEL);
> -	if (!data)
> -		return -ENOMEM;
> -
> -	data->fn = fn;
> -	filp->private_data = data;
> -	return 0;
> -}
> -
> -static int f01_debug_release(struct inode *inodep, struct file *filp)
> -{
> -	kfree(filp->private_data);
> -	return 0;
> -}
> -
> -static ssize_t interrupt_enable_read(struct file *filp, char __user *buffer,
> -				     size_t size, loff_t *offset) {
> -	int i;
> -	int len;
> -	int total_len = 0;
> -	char local_buf[size]; // FIXME!!!! XXX arbitrary size array on stack
> -	char *current_buf = local_buf;
> -	struct f01_debugfs_data *data = filp->private_data;
> -	struct f01_data *f01 = data->fn->data;
> -
> -	if (data->done)
> -		return 0;
> -
> -	data->done = 1;
> -
> -	/* loop through each irq value and copy its
> -	 * string representation into buf */
> -	for (i = 0; i < f01->irq_count; i++) {
> -		int irq_reg;
> -		int irq_shift;
> -		int interrupt_enable;
> -
> -		irq_reg = i / 8;
> -		irq_shift = i % 8;
> -		interrupt_enable =
> -		    ((f01->device_control.interrupt_enable[irq_reg]
> -			>> irq_shift) & 0x01);
> -
> -		/* get next irq value and write it to buf */
> -		len = snprintf(current_buf, size - total_len,
> -			"%u ", interrupt_enable);
> -		/* bump up ptr to next location in buf if the
> -		 * snprintf was valid.  Otherwise issue an error
> -		 * and return. */
> -		if (len > 0) {
> -			current_buf += len;
> -			total_len += len;
> -		} else {
> -			dev_err(&data->fn->dev, "Failed to build interrupt_enable buffer, code = %d.\n",
> -						len);
> -			return snprintf(local_buf, size, "unknown\n");
> -		}
> -	}
> -	len = snprintf(current_buf, size - total_len, "\n");
> -	if (len > 0)
> -		total_len += len;
> -	else
> -		dev_warn(&data->fn->dev, "%s: Failed to append carriage return.\n",
> -			 __func__);
> -
> -	if (copy_to_user(buffer, local_buf, total_len))
> -		return -EFAULT;
> -
> -	return total_len;
> -}
> -
> -static ssize_t interrupt_enable_write(struct file *filp,
> -		const char __user *buffer, size_t size, loff_t *offset) {
> -	int retval;
> -	char buf[size];
> -	char *local_buf = buf;
> -	int i;
> -	int irq_count = 0;
> -	int irq_reg = 0;
> -	struct f01_debugfs_data *data = filp->private_data;
> -	struct f01_data *f01 = data->fn->data;
> -
> -	retval = copy_from_user(buf, buffer, size);
> -	if (retval)
> -		return -EFAULT;
> -
> -	for (i = 0; i < f01->irq_count && *local_buf != 0;
> -	     i++, local_buf += 2) {
> -		int irq_shift;
> -		int interrupt_enable;
> -		int result;
> -
> -		irq_reg = i / 8;
> -		irq_shift = i % 8;
> -
> -		/* get next interrupt mapping value and store and bump up to
> -		 * point to next item in local_buf */
> -		result = sscanf(local_buf, "%u", &interrupt_enable);
> -		if ((result != 1) ||
> -			(interrupt_enable != 0 && interrupt_enable != 1)) {
> -			dev_err(&data->fn->dev, "Interrupt enable[%d] is not a valid value 0x%x.\n",
> -				i, interrupt_enable);
> -			return -EINVAL;
> -		}
> -		if (interrupt_enable == 0) {
> -			f01->device_control.interrupt_enable[irq_reg] &=
> -				(1 << irq_shift) ^ 0xFF;
> -		} else
> -			f01->device_control.interrupt_enable[irq_reg] |=
> -				(1 << irq_shift);
> -		irq_count++;
> -	}
> -
> -	/* Make sure the irq count matches */
> -	if (irq_count != f01->irq_count) {
> -		dev_err(&data->fn->dev, "Interrupt enable count of %d doesn't match device count of %d.\n",
> -			 irq_count, f01->irq_count);
> -		return -EINVAL;
> -	}
> -
> -	/* write back to the control register */
> -	retval = rmi_write_block(data->fn->rmi_dev, f01->interrupt_enable_addr,
> -			f01->device_control.interrupt_enable,
> -			f01->num_of_irq_regs);
> -	if (retval < 0) {
> -		dev_err(&data->fn->dev, "Could not write interrupt_enable mask to %#06x\n",
> -			f01->interrupt_enable_addr);
> -		return retval;
> -	}
> -
> -	return size;
> -}
> -
> -static const struct file_operations interrupt_enable_fops = {
> -	.owner = THIS_MODULE,
> -	.open = f01_debug_open,
> -	.release = f01_debug_release,
> -	.read = interrupt_enable_read,
> -	.write = interrupt_enable_write,
> -};
> -
> -static int setup_debugfs(struct rmi_function *fn)
> -{
> -	struct f01_data *data = fn->data;
> -
> -	if (!fn->debugfs_root)
> -		return -ENODEV;
> -
> -	data->debugfs_interrupt_enable = debugfs_create_file("interrupt_enable",
> -		RMI_RW_ATTR, fn->debugfs_root, fn, &interrupt_enable_fops);
> -	if (!data->debugfs_interrupt_enable)
> -		dev_warn(&fn->dev,
> -			 "Failed to create debugfs interrupt_enable.\n");
> -
> -	return 0;
> -}
> -
> -static void teardown_debugfs(struct f01_data *f01)
> -{
> -	if (f01->debugfs_interrupt_enable)
> -		debugfs_remove(f01->debugfs_interrupt_enable);
> -}
> -
> -#else
> -
> -static inline int setup_debugfs(struct rmi_function *fn)
> -{
> -	return 0;
> -}
> -
> -static inline void teardown_debugfs(struct f01_data *f01)
> -{
> -}
> -
> -#endif
> -
> -static ssize_t rmi_fn_01_productinfo_show(struct device *dev,
> -					  struct device_attribute *attr,
> -					  char *buf)
> -{
> -	struct rmi_function *fn = to_rmi_function(dev);
> -	struct f01_data *data = fn->data;
> -
> -	return snprintf(buf, PAGE_SIZE, "0x%04x\n",
> -			data->properties.productinfo);
> -}
> -
> -static ssize_t rmi_fn_01_productid_show(struct device *dev,
> -					struct device_attribute *attr,
> -					char *buf)
> -{
> -	struct rmi_function *fn = to_rmi_function(dev);
> -	struct f01_data *data = fn->data;
> -
> -	return snprintf(buf, PAGE_SIZE, "%s\n", data->properties.product_id);
> -}
> -
> -static ssize_t rmi_fn_01_manufacturer_show(struct device *dev,
> -					   struct device_attribute *attr,
> -					   char *buf)
> -{
> -	struct rmi_function *fn = to_rmi_function(dev);
> -	struct f01_data *data = fn->data;
> -
> -	return snprintf(buf, PAGE_SIZE, "0x%02x\n",
> -			data->properties.manufacturer_id);
> -}
> -
> -static ssize_t rmi_fn_01_datecode_show(struct device *dev,
> -				       struct device_attribute *attr,
> -				       char *buf)
> -{
> -	struct rmi_function *fn = to_rmi_function(dev);
> -	struct f01_data *data = fn->data;
> -
> -	return snprintf(buf, PAGE_SIZE, "%s\n", data->properties.dom);
> -}
> -
> -static ssize_t rmi_fn_01_reset_store(struct device *dev,
> -				     struct device_attribute *attr,
> -				     const char *buf, size_t count)
> -{
> -	struct rmi_function *fn = to_rmi_function(dev);
> -	unsigned int reset;
> -	int error;
> -
> -	if (sscanf(buf, "%u", &reset) != 1)
> -		return -EINVAL;
> -	if (reset < 0 || reset > 1)
> -		return -EINVAL;
> -
> -	/* Per spec, 0 has no effect, so we skip it entirely. */
> -	if (reset) {
> -		/* Command register always reads as 0, so just use a local. */
> -		u8 command = RMI_F01_CMD_DEVICE_RESET;
> -
> -		error = rmi_write_block(fn->rmi_dev, fn->fd.command_base_addr,
> -					 &command, sizeof(command));
> -		if (error < 0) {
> -			dev_err(dev, "Failed to issue reset command, code = %d.",
> -				error);
> -			return error;
> -		}
> -	}
> -
> -	return count;
> -}
> -
> -static ssize_t rmi_fn_01_sleepmode_show(struct device *dev,
> -					struct device_attribute *attr,
> -					char *buf)
> -{
> -	struct rmi_function *fn = to_rmi_function(dev);
> -	struct f01_data *data = fn->data;
> -	unsigned int value = data->device_control.ctrl0 &
> -					RMI_F01_CTRL0_SLEEP_MODE_MASK;
> -
> -	return snprintf(buf, PAGE_SIZE, "%d\n", value);
> -}
> -
> -static ssize_t rmi_fn_01_sleepmode_store(struct device *dev,
> -					 struct device_attribute *attr,
> -					 const char *buf, size_t count)
> -{
> -	struct rmi_function *fn = to_rmi_function(dev);
> -	struct f01_data *data = fn->data;
> -	unsigned long new_value;
> -	int retval;
> -
> -	retval = strict_strtoul(buf, 10, &new_value);
> -	if (retval < 0 || !RMI_IS_VALID_SLEEPMODE(new_value)) {
> -		dev_err(dev, "%s: Invalid sleep mode %s.", __func__, buf);
> -		return -EINVAL;
> -	}
> -
> -	retval = mutex_lock_interruptible(&data->control_mutex);
> -	if (retval)
> -		return retval;
> -
> -	dev_dbg(dev, "Setting sleep mode to %ld.", new_value);
> -
> -	data->device_control.ctrl0 &= ~RMI_F01_CTRL0_SLEEP_MODE_MASK;
> -	data->device_control.ctrl0 |= new_value;
> -
> -	retval = rmi_write_block(fn->rmi_dev, fn->fd.control_base_addr,
> -			&data->device_control.ctrl0,
> -			sizeof(data->device_control.ctrl0));
> -	if (retval >= 0)
> -		retval = count;
> -	else
> -		dev_err(dev, "Failed to write sleep mode, code %d.\n", retval);
> -
> -	mutex_unlock(&data->control_mutex);
> -	return retval;
> -}
> -
> -static ssize_t rmi_fn_01_nosleep_show(struct device *dev,
> -				      struct device_attribute *attr, char *buf)
> -{
> -	struct rmi_function *fn = to_rmi_function(dev);
> -	struct f01_data *data = fn->data;
> -	unsigned int value = !!(data->device_control.ctrl0 &
> -					RMI_F01_CRTL0_NOSLEEP_BIT);
> -
> -	return snprintf(buf, PAGE_SIZE, "%d\n", value);
> -}
> -
> -static ssize_t rmi_fn_01_nosleep_store(struct device *dev,
> -				       struct device_attribute *attr,
> -				       const char *buf, size_t count)
> -{
> -	struct rmi_function *fn = to_rmi_function(dev);
> -	struct f01_data *data = fn->data;
> -	unsigned long new_value;
> -	int retval;
> -
> -	retval = strict_strtoul(buf, 10, &new_value);
> -	if (retval < 0 || new_value > 1) {
> -		dev_err(dev, "%s: Invalid nosleep bit %s.", __func__, buf);
> -		return -EINVAL;
> -	}
> -
> -	retval = mutex_lock_interruptible(&data->control_mutex);
> -	if (retval)
> -		return retval;
> -
> -	if (new_value)
> -		data->device_control.ctrl0 |= RMI_F01_CRTL0_NOSLEEP_BIT;
> -	else
> -		data->device_control.ctrl0 &= ~RMI_F01_CRTL0_NOSLEEP_BIT;
> -
> -	retval = rmi_write_block(fn->rmi_dev, fn->fd.control_base_addr,
> -				 &data->device_control.ctrl0,
> -				 sizeof(data->device_control.ctrl0));
> -	if (retval >= 0)
> -		retval = count;
> -	else
> -		dev_err(dev, "Failed to write nosleep bit.\n");
> -
> -	mutex_unlock(&data->control_mutex);
> -	return retval;
> -}
> -
> -static ssize_t rmi_fn_01_chargerinput_show(struct device *dev,
> -				      struct device_attribute *attr, char *buf)
> -{
> -	struct rmi_function *fn = to_rmi_function(dev);
> -	struct f01_data *data = fn->data;
> -	unsigned int value = !!(data->device_control.ctrl0 &
> -					RMI_F01_CRTL0_CHARGER_BIT);
> -
> -	return snprintf(buf, PAGE_SIZE, "%d\n", value);
> -}
> -
> -static ssize_t rmi_fn_01_chargerinput_store(struct device *dev,
> -				       struct device_attribute *attr,
> -				       const char *buf, size_t count)
> -{
> -	struct rmi_function *fn = to_rmi_function(dev);
> -	struct f01_data *data = fn->data;
> -	unsigned long new_value;
> -	int retval;
> -
> -	retval = strict_strtoul(buf, 10, &new_value);
> -	if (retval < 0 || new_value > 1) {
> -		dev_err(dev, "%s: Invalid chargerinput bit %s.", __func__, buf);
> -		return -EINVAL;
> -	}
> -
> -	retval = mutex_lock_interruptible(&data->control_mutex);
> -	if (retval)
> -		return retval;
> -
> -	if (new_value)
> -		data->device_control.ctrl0 |= RMI_F01_CRTL0_CHARGER_BIT;
> -	else
> -		data->device_control.ctrl0 &= ~RMI_F01_CRTL0_CHARGER_BIT;
> -
> -	retval = rmi_write_block(fn->rmi_dev, fn->fd.control_base_addr,
> -				 &data->device_control.ctrl0,
> -				 sizeof(data->device_control.ctrl0));
> -	if (retval >= 0)
> -		retval = count;
> -	else
> -		dev_err(dev, "Failed to write chargerinput bit.\n");
> -
> -	mutex_unlock(&data->control_mutex);
> -	return retval;
> -}
> -
> -static ssize_t rmi_fn_01_reportrate_show(struct device *dev,
> -				      struct device_attribute *attr, char *buf)
> -{
> -	struct rmi_function *fn = to_rmi_function(dev);
> -	struct f01_data *data = fn->data;
> -	int value = !!(data->device_control.ctrl0 &
> -				RMI_F01_CRTL0_REPORTRATE_BIT);
> -
> -	return snprintf(buf, PAGE_SIZE, "%d\n", value);
> -}
> -
> -static ssize_t rmi_fn_01_reportrate_store(struct device *dev,
> -				       struct device_attribute *attr,
> -				       const char *buf, size_t count)
> -{
> -	struct rmi_function *fn = to_rmi_function(dev);
> -	struct f01_data *data = fn->data;
> -	unsigned long new_value;
> -	int retval;
> -
> -	retval = strict_strtoul(buf, 10, &new_value);
> -	if (retval < 0 || new_value > 1) {
> -		dev_err(dev, "%s: Invalid reportrate bit %s.", __func__, buf);
> -		return -EINVAL;
> -	}
> -
> -	retval = mutex_lock_interruptible(&data->control_mutex);
> -	if (retval)
> -		return retval;
> -
> -	if (new_value)
> -		data->device_control.ctrl0 |= RMI_F01_CRTL0_REPORTRATE_BIT;
> -	else
> -		data->device_control.ctrl0 &= ~RMI_F01_CRTL0_REPORTRATE_BIT;
> -
> -	retval = rmi_write_block(fn->rmi_dev, fn->fd.control_base_addr,
> -				 &data->device_control.ctrl0,
> -				 sizeof(data->device_control.ctrl0));
> -	if (retval >= 0)
> -		retval = count;
> -	else
> -		dev_err(dev, "Failed to write reportrate bit.\n");
> -
> -	mutex_unlock(&data->control_mutex);
> -	return retval;
> -}
> -
> -static ssize_t rmi_fn_01_interrupt_enable_show(struct device *dev,
> -				struct device_attribute *attr, char *buf)
> -{
> -	struct rmi_function *fn = to_rmi_function(dev);
> -	struct f01_data *data = fn->data;
> -	int i, len, total_len = 0;
> -	char *current_buf = buf;
> -
> -	/* loop through each irq value and copy its
> -	 * string representation into buf */
> -	for (i = 0; i < data->irq_count; i++) {
> -		int irq_reg;
> -		int irq_shift;
> -		int interrupt_enable;
> -
> -		irq_reg = i / 8;
> -		irq_shift = i % 8;
> -		interrupt_enable =
> -		    ((data->device_control.interrupt_enable[irq_reg]
> -			>> irq_shift) & 0x01);
> -
> -		/* get next irq value and write it to buf */
> -		len = snprintf(current_buf, PAGE_SIZE - total_len,
> -			"%u ", interrupt_enable);
> -		/* bump up ptr to next location in buf if the
> -		 * snprintf was valid.  Otherwise issue an error
> -		 * and return. */
> -		if (len > 0) {
> -			current_buf += len;
> -			total_len += len;
> -		} else {
> -			dev_err(dev, "Failed to build interrupt_enable buffer, code = %d.\n",
> -						len);
> -			return snprintf(buf, PAGE_SIZE, "unknown\n");
> -		}
> -	}
> -	len = snprintf(current_buf, PAGE_SIZE - total_len, "\n");
> -	if (len > 0)
> -		total_len += len;
> -	else
> -		dev_warn(dev, "%s: Failed to append carriage return.\n",
> -			 __func__);
> -	return total_len;
> -
> -}
> -
> -static ssize_t rmi_fn_01_doze_interval_show(struct device *dev,
> -				struct device_attribute *attr, char *buf)
> -{
> -	struct rmi_function *fn = to_rmi_function(dev);
> -	struct f01_data *data = fn->data;
> -
> -	return snprintf(buf, PAGE_SIZE, "%d\n",
> -			data->device_control.doze_interval);
> -
> -}
> -
> -static ssize_t rmi_fn_01_doze_interval_store(struct device *dev,
> -					  struct device_attribute *attr,
> -					  const char *buf, size_t count)
> -{
> -	struct rmi_function *fn = to_rmi_function(dev);
> -	struct f01_data *data = fn->data;
> -	unsigned long new_value;
> -	int retval;
> -	u16 ctrl_base_addr;
> -
> -	retval = strict_strtoul(buf, 10, &new_value);
> -	if (retval < 0 || new_value > 255) {
> -		dev_err(dev, "%s: Invalid doze interval %s.", __func__, buf);
> -		return -EINVAL;
> -	}
> -
> -	retval = mutex_lock_interruptible(&data->control_mutex);
> -	if (retval)
> -		return retval;
> -
> -	data->device_control.doze_interval = new_value;
> -	ctrl_base_addr = fn->fd.control_base_addr + sizeof(u8) +
> -			(sizeof(u8)*(data->num_of_irq_regs));
> -	dev_dbg(dev, "doze_interval store address %x, value %d",
> -		ctrl_base_addr, data->device_control.doze_interval);
> -
> -	retval = rmi_write_block(fn->rmi_dev, data->doze_interval_addr,
> -			&data->device_control.doze_interval,
> -			sizeof(u8));
> -	if (retval >= 0)
> -		retval = count;
> -	else
> -		dev_err(dev, "Failed to write doze interval.\n");
> -
> -	mutex_unlock(&data->control_mutex);
> -	return retval;
> -}
> -
> -static ssize_t rmi_fn_01_wakeup_threshold_show(struct device *dev,
> -					 struct device_attribute *attr,
> -					 char *buf)
> -{
> -	struct rmi_function *fn = to_rmi_function(dev);
> -	struct f01_data *data = fn->data;
> -
> -	return snprintf(buf, PAGE_SIZE, "%d\n",
> -			data->device_control.wakeup_threshold);
> -}
> -
> -static ssize_t rmi_fn_01_wakeup_threshold_store(struct device *dev,
> -					  struct device_attribute *attr,
> -					  const char *buf, size_t count)
> -{
> -	struct rmi_function *fn = to_rmi_function(dev);
> -	struct f01_data *data = fn->data;
> -	unsigned long new_value;
> -	int retval;
> -
> -	retval = strict_strtoul(buf, 10, &new_value);
> -	if (retval < 0 || new_value > 255) {
> -		dev_err(dev, "%s: Invalid wakeup threshold %s.", __func__, buf);
> -		return -EINVAL;
> -	}
> -
> -	retval = mutex_lock_interruptible(&data->control_mutex);
> -	if (retval)
> -		return retval;
> -
> -	data->device_control.doze_interval = new_value;
> -	retval = rmi_write_block(fn->rmi_dev, data->wakeup_threshold_addr,
> -			&data->device_control.wakeup_threshold,
> -			sizeof(u8));
> -	if (retval >= 0)
> -		retval = count;
> -	else
> -		dev_err(dev, "Failed to write wakeup threshold.\n");
> -
> -	mutex_unlock(&data->control_mutex);
> -	return retval;
> -}
> -
> -static ssize_t rmi_fn_01_doze_holdoff_show(struct device *dev,
> -					 struct device_attribute *attr,
> -					 char *buf)
> -{
> -	struct rmi_function *fn = to_rmi_function(dev);
> -	struct f01_data *data = fn->data;
> -
> -	return snprintf(buf, PAGE_SIZE, "%d\n",
> -			data->device_control.doze_holdoff);
> -
> -}
> -
> -static ssize_t rmi_fn_01_doze_holdoff_store(struct device *dev,
> -					  struct device_attribute *attr,
> -					  const char *buf, size_t count)
> -{
> -	struct rmi_function *fn = to_rmi_function(dev);
> -	struct f01_data *data = fn->data;
> -	unsigned long new_value;
> -	int retval;
> -
> -	retval = strict_strtoul(buf, 10, &new_value);
> -	if (retval < 0 || new_value > 255) {
> -		dev_err(dev, "%s: Invalid doze holdoff %s.", __func__, buf);
> -		return -EINVAL;
> -	}
> -
> -	retval = mutex_lock_interruptible(&data->control_mutex);
> -	if (retval)
> -		return retval;
> -
> -	data->device_control.doze_interval = new_value;
> -	retval = rmi_write_block(fn->rmi_dev, data->doze_holdoff_addr,
> -			&data->device_control.doze_holdoff,
> -			sizeof(u8));
> -	if (retval >= 0)
> -		retval = count;
> -	else
> -		dev_err(dev, "Failed to write doze holdoff.\n");
> -
> -	mutex_unlock(&data->control_mutex);
> -	return retval;
> -}
> -
> -static ssize_t rmi_fn_01_configured_show(struct device *dev,
> -				      struct device_attribute *attr, char *buf)
> -{
> -	struct rmi_function *fn = to_rmi_function(dev);
> -	struct f01_data *data = fn->data;
> -	unsigned int value = !!(data->device_control.ctrl0 &
> -					RMI_F01_CRTL0_CONFIGURED_BIT);
> -
> -	return snprintf(buf, PAGE_SIZE, "%d\n", value);
> -}
> -
> -static ssize_t rmi_fn_01_unconfigured_show(struct device *dev,
> -				      struct device_attribute *attr, char *buf)
> -{
> -	struct rmi_function *fn = to_rmi_function(dev);
> -	struct f01_data *data = fn->data;
> -
> -	return snprintf(buf, PAGE_SIZE, "%d\n",
> -			RMI_F01_STATUS_UNCONFIGURED(data->device_status));
> -}
> -
> -static ssize_t rmi_fn_01_flashprog_show(struct device *dev,
> -				      struct device_attribute *attr, char *buf)
> -{
> -	struct rmi_function *fn = to_rmi_function(dev);
> -	struct f01_data *data = fn->data;
> -
> -	return snprintf(buf, PAGE_SIZE, "%d\n",
> -			RMI_F01_STATUS_BOOTLOADER(data->device_status));
> -}
> -
> -static ssize_t rmi_fn_01_statuscode_show(struct device *dev,
> -				      struct device_attribute *attr, char *buf)
> -{
> -	struct rmi_function *fn = to_rmi_function(dev);
> -	struct f01_data *data = fn->data;
> -
> -	return snprintf(buf, PAGE_SIZE, "0x%02x\n",
> -			RMI_F01_STATUS_CODE(data->device_status));
> -}
> -
> -#define RMI_F01_ATTR(_name)			\
> -	DEVICE_ATTR(_name, RMI_RW_ATTR,		\
> -		    rmi_fn_01_##_name##_show,	\
> -		    rmi_fn_01_##_name##_store)
> -
> -#define RMI_F01_RO_ATTR(_name)			\
> -	DEVICE_ATTR(_name, RMI_RO_ATTR,		\
> -		    rmi_fn_01_##_name##_show,	\
> -		    NULL)
> -
> -#define RMI_F01_WO_ATTR(_name)			\
> -	DEVICE_ATTR(_name, RMI_RO_ATTR,		\
> -		    NULL,			\
> -		    rmi_fn_01_##_name##_store)
> -
> -
> -static RMI_F01_RO_ATTR(productinfo);
> -static RMI_F01_RO_ATTR(productid);
> -static RMI_F01_RO_ATTR(manufacturer);
> -static RMI_F01_RO_ATTR(datecode);
> -
> -/* Control register access */
> -static RMI_F01_ATTR(sleepmode);
> -static RMI_F01_ATTR(nosleep);
> -static RMI_F01_ATTR(chargerinput);
> -static RMI_F01_ATTR(reportrate);
> -
> -/*
> - * We don't want arbitrary callers changing the interrupt enable mask,
> - * so it's read only.
> - */
> -static RMI_F01_RO_ATTR(interrupt_enable);
> -static RMI_F01_ATTR(doze_interval);
> -static RMI_F01_ATTR(wakeup_threshold);
> -static RMI_F01_ATTR(doze_holdoff);
> -
> -/*
> - * We make 'configured' RO, since the driver uses that to look for
> - * resets.  We don't want someone faking us out by changing that
> - * bit.
> - */
> -static RMI_F01_RO_ATTR(configured);
> -
> -/* Command register access. */
> -static RMI_F01_WO_ATTR(reset);
> -
> -/* Status register access. */
> -static RMI_F01_RO_ATTR(unconfigured);
> -static RMI_F01_RO_ATTR(flashprog);
> -static RMI_F01_RO_ATTR(statuscode);
> -
> -static struct attribute *rmi_fn_01_attrs[] = {
> -	&dev_attr_productinfo.attr,
> -	&dev_attr_productid.attr,
> -	&dev_attr_manufacturer.attr,
> -	&dev_attr_datecode.attr,
> -	&dev_attr_sleepmode.attr,
> -	&dev_attr_nosleep.attr,
> -	&dev_attr_chargerinput.attr,
> -	&dev_attr_reportrate.attr,
> -	&dev_attr_interrupt_enable.attr,
> -	&dev_attr_doze_interval.attr,
> -	&dev_attr_wakeup_threshold.attr,
> -	&dev_attr_doze_holdoff.attr,
> -	&dev_attr_configured.attr,
> -	&dev_attr_reset.attr,
> -	&dev_attr_unconfigured.attr,
> -	&dev_attr_flashprog.attr,
> -	&dev_attr_statuscode.attr,
> -	NULL
> -};
> -
> -static umode_t rmi_fn_01_attr_visible(struct kobject *kobj,
> -				      struct attribute *attr, int n)
> -{
> -	struct device *dev = kobj_to_dev(kobj);
> -	struct rmi_function *fn = to_rmi_function(dev);
> -	struct f01_data *data = fn->data;
> -	umode_t mode = attr->mode;
> -
> -	if (attr == &dev_attr_doze_interval.attr) {
> -		if (!data->properties.has_lts)
> -			mode = 0;
> -	} else if (attr == &dev_attr_wakeup_threshold.attr) {
> -		if (!data->properties.has_adjustable_doze)
> -			mode = 0;
> -	} else if (attr == &dev_attr_doze_holdoff.attr) {
> -		if (!data->properties.has_adjustable_doze_holdoff)
> -			mode = 0;
> -	}
> -
> -	return mode;
> -}
> -
> -static struct attribute_group rmi_fn_01_attr_group = {
> -	.is_visible	= rmi_fn_01_attr_visible,
> -	.attrs		= rmi_fn_01_attrs,
>  };
>  
>  static int rmi_f01_alloc_memory(struct rmi_function *fn,
> @@ -1148,11 +373,6 @@ static int rmi_f01_initialize(struct rmi_function *fn)
>  		goto error_exit;
>  	}
>  
> -	error = setup_debugfs(fn);
> -	if (error)
> -		dev_warn(&fn->dev, "Failed to setup debugfs, error: %d.\n",
> -			 error);
> -
>  	return 0;
>  
>   error_exit:
> @@ -1228,17 +448,12 @@ static int rmi_f01_probe(struct rmi_function *fn)
>  	if (error)
>  		return error;
>  
> -	error = sysfs_create_group(&fn->dev.kobj, &rmi_fn_01_attr_group);
> -	if (error)
> -		return error;
> -
>  	return 0;
>  }
>  
>  static void rmi_f01_remove(struct rmi_function *fn)
>  {
> -	teardown_debugfs(fn->data);
> -	sysfs_remove_group(&fn->dev.kobj, &rmi_fn_01_attr_group);
> +	/* Placeholder for now. */
>  }
>  
>  #ifdef CONFIG_PM_SLEEP
> diff --git a/drivers/input/rmi4/rmi_f11.c b/drivers/input/rmi4/rmi_f11.c
> index 017c8ff..8984054 100644
> --- a/drivers/input/rmi4/rmi_f11.c
> +++ b/drivers/input/rmi4/rmi_f11.c
> @@ -10,7 +10,6 @@
>  #define FUNCTION_DATA f11_data
>  
>  #include <linux/kernel.h>
> -#include <linux/debugfs.h>
>  #include <linux/delay.h>
>  #include <linux/device.h>
>  #include <linux/input.h>
> @@ -822,177 +821,6 @@ enum finger_state_values {
>  	F11_RESERVED	= 0x03
>  };
>  
> -static ssize_t rmi_f11_rezero_store(struct device *dev,
> -				    struct device_attribute *attr,
> -				    const char *buf, size_t count)
> -{
> -	struct rmi_function *fn = to_rmi_function(dev);
> -	unsigned int rezero;
> -	int error;
> -
> -	error = kstrtouint(buf, 0, &rezero);
> -	if (error)
> -		return error;
> -
> -	if (rezero > 1)
> -		return -ERANGE;
> -
> -	/* Per spec, 0 has no effect, so we skip it entirely. */
> -	if (rezero) {
> -		/* Command register always reads as 0, so just use a local. */
> -		struct f11_2d_commands commands = {
> -			.rezero = true,
> -		};
> -
> -		error = rmi_write_block(fn->rmi_dev, fn->fd.command_base_addr,
> -					&commands, sizeof(commands));
> -		if (error < 0) {
> -			dev_err(dev,
> -				"%s: failed to issue rezero command, error = %d.",
> -				__func__, error);
> -			return error;
> -		}
> -	}
> -
> -	return count;
> -}
> -
> -static DEVICE_ATTR(rezero, RMI_WO_ATTR, NULL, rmi_f11_rezero_store);
> -
> -static struct attribute *rmi_f11_attrs[] = {
> -	&dev_attr_rezero.attr,
> -	NULL
> -};
> -
> -static struct attribute_group rmi_f11_attr_group = {
> -	.attrs = rmi_f11_attrs,
> -};
> -
> -#ifdef CONFIG_RMI4_DEBUG
> -static void rmi_f11_setup_sensor_debugfs(struct f11_2d_sensor *sensor)
> -{
> -	struct rmi_function *fn = sensor->fn;
> -	struct dentry *sensor_root;
> -	char dirname[sizeof("sensorNNN")];
> -
> -	if (!fn->debugfs_root)
> -		return;
> -
> -	snprintf(dirname, sizeof(dirname), "input%3u", sensor->sensor_index);
> -	sensor_root = debugfs_create_dir(dirname, fn->debugfs_root);
> -	if (!sensor_root) {
> -		dev_warn(&fn->dev,
> -			 "Failed to create debugfs directory %s for sensor %d\n",
> -			 dirname, sensor->sensor_index);
> -		return;
> -	}
> -
> -	if (!debugfs_create_bool("type_a", RMI_RW_ATTR, sensor_root,
> -				 &sensor->type_a))
> -		dev_warn(&fn->dev,
> -			 "Failed to create debugfs type_a for sensor %d.\n",
> -			 sensor->sensor_index);
> -
> -	if (!debugfs_create_u16("max_x", RMI_RW_ATTR, sensor_root,
> -				&sensor->max_x))
> -		dev_warn(&fn->dev,
> -			 "Failed to create debugfs max_x for sensor %d.\n",
> -			 sensor->sensor_index);
> -
> -	if (!debugfs_create_u16("max_xy", RMI_RW_ATTR, sensor_root,
> -				&sensor->max_y))
> -		dev_warn(&fn->dev,
> -			 "Failed to create debugfs max_y for sensor %d.\n",
> -			 sensor->sensor_index);
> -
> -	if (!debugfs_create_bool("flip_x", RMI_RW_ATTR, sensor_root,
> -				 &sensor->axis_align.flip_x))
> -		dev_warn(&fn->dev,
> -			 "Failed to create debugfs flip_x for sensor %d.\n",
> -			 sensor->sensor_index);
> -
> -	if (!debugfs_create_bool("flip_y", RMI_RW_ATTR, sensor_root,
> -				 &sensor->axis_align.flip_y))
> -		dev_warn(&fn->dev,
> -			 "Failed to create debugfs flip_y for sensor %d.\n",
> -			 sensor->sensor_index);
> -
> -	if (!debugfs_create_u16("clip_x_low", RMI_RW_ATTR, sensor_root,
> -				&sensor->axis_align.clip_x_low))
> -		dev_warn(&fn->dev,
> -			 "Failed to create debugfs clip_x_low for sensor %d.\n",
> -			 sensor->sensor_index);
> -
> -	if (!debugfs_create_u16("clip_x_high", RMI_RW_ATTR, sensor_root,
> -				&sensor->axis_align.clip_x_high))
> -		dev_warn(&fn->dev,
> -			 "Failed to create debugfs clip_x_high for sensor %d.\n",
> -			 sensor->sensor_index);
> -
> -	if (!debugfs_create_u16("clip_y_low", RMI_RW_ATTR, sensor_root,
> -				 &sensor->axis_align.clip_y_low))
> -		dev_warn(&fn->dev,
> -			 "Failed to create debugfs clip_y_low for sensor %d.\n",
> -			 sensor->sensor_index);
> -
> -	if (!debugfs_create_u16("clip_y_high", RMI_RW_ATTR, sensor_root,
> -				 &sensor->axis_align.clip_y_high))
> -		dev_warn(&fn->dev,
> -			 "Failed to create debugfs clip_y_high for sensor %d.\n",
> -			 sensor->sensor_index);
> -
> -	if (!debugfs_create_u8("delta_x_threshold", RMI_RW_ATTR, sensor_root,
> -				&sensor->axis_align.delta_x_threshold))
> -		dev_warn(&fn->dev,
> -			 "Failed to create debugfs delta_x_threshold for sensor %d.\n",
> -			 sensor->sensor_index);
> -
> -	if (!debugfs_create_u8("delta_y_threshold", RMI_RW_ATTR, sensor_root,
> -				&sensor->axis_align.delta_y_threshold))
> -		dev_warn(&fn->dev,
> -			 "Failed to create debugfs delta_y_threshold for sensor %d.\n",
> -			 sensor->sensor_index);
> -
> -	if (!debugfs_create_u16("offset_x", RMI_RW_ATTR, sensor_root,
> -				 &sensor->axis_align.offset_x))
> -		dev_warn(&fn->dev,
> -			 "Failed to create debugfs offset_x for sensor %d.\n",
> -			 sensor->sensor_index);
> -
> -	if (!debugfs_create_u16("offset_x", RMI_RW_ATTR, sensor_root,
> -				 &sensor->axis_align.offset_x))
> -		dev_warn(&fn->dev,
> -			 "Failed to create debugfs offset_y for sensor %d.\n",
> -			 sensor->sensor_index);
> -
> -	if (!debugfs_create_bool("swap", RMI_RW_ATTR, sensor_root,
> -				 &sensor->axis_align.swap_axes))
> -		dev_warn(&fn->dev,
> -			 "Failed to create debugfs swap for sensor %d.\n",
> -			 sensor->sensor_index);
> -}
> -
> -static void rmi_f11_setup_debugfs(struct rmi_function *fn)
> -{
> -	struct f11_data *f11 = fn->data;
> -
> -	if (fn->debugfs_root)
> -		if (!debugfs_create_u16("rezero_wait", RMI_RW_ATTR,
> -					fn->debugfs_root,
> -					&f11->rezero_wait_ms))
> -			dev_warn(&fn->dev,
> -				 "Failed to create debugfs rezero_wait.\n");
> -}
> -#else
> -static inline void rmi_f11_setup_sensor_debugfs(struct f11_2d_sensor *sensor)
> -{
> -}
> -static inline void rmi_f11_setup_debugfs(struct rmi_function *fn)
> -{
> -}
> -#endif
> -/* End adding debugfs */
> -
>  /** F11_INACCURATE state is overloaded to indicate pen present. */
>  #define F11_PEN F11_INACCURATE
>  
> @@ -1886,12 +1714,8 @@ static int rmi_f11_initialize(struct rmi_function *fn)
>  				dev_warn(&fn->dev, "Failed to write to delta_y_threshold %d. Code: %d.\n",
>  					i, rc);
>  		}
> -
> -		rmi_f11_setup_sensor_debugfs(sensor);
>  	}
>  
> -	rmi_f11_setup_debugfs(fn);
> -
>  	mutex_init(&f11->dev_controls_mutex);
>  	return 0;
>  }
> @@ -2112,18 +1936,11 @@ static int rmi_f11_probe(struct rmi_function *fn)
>  	if (error)
>  		return error;
>  
> -	error = sysfs_create_group(&fn->dev.kobj, &rmi_f11_attr_group);
> -	if (error)
> -		return error;
> -
>  	return 0;
>  }
>  
>  static void rmi_f11_remove(struct rmi_function *fn)
>  {
> -	debugfs_remove_recursive(fn->debugfs_root);
> -	sysfs_remove_group(&fn->dev.kobj, &rmi_f11_attr_group);
> -
>  	rmi_f11_free_devices(fn);
>  }
>  
> diff --git a/drivers/input/rmi4/rmi_i2c.c b/drivers/input/rmi4/rmi_i2c.c
> index f3bef04..62351c4 100644
> --- a/drivers/input/rmi4/rmi_i2c.c
> +++ b/drivers/input/rmi4/rmi_i2c.c
> @@ -8,7 +8,6 @@
>   */
>  
>  #include <linux/kernel.h>
> -#include <linux/debugfs.h>
>  #include <linux/delay.h>
>  #include <linux/i2c.h>
>  #include <linux/interrupt.h>
> @@ -61,8 +60,9 @@ static int setup_debugfs(struct rmi_device *rmi_dev, struct rmi_i2c_data *data)
>  	if (!rmi_dev->debugfs_root)
>  		return -ENODEV;
>  
> -	data->debugfs_comms = debugfs_create_bool("comms_debug", RMI_RW_ATTR,
> -			rmi_dev->debugfs_root, &data->comms_debug);
> +	data->debugfs_comms = debugfs_create_bool("comms_debug",
> +			(S_IRUGO | S_IWUGO), rmi_dev->debugfs_root,
> +			&data->comms_debug);
>  	if (!data->debugfs_comms || IS_ERR(data->debugfs_comms)) {
>  		dev_warn(&rmi_dev->dev,
>  			 "Failed to create debugfs comms_debug.\n");

Patch

diff --git a/drivers/input/rmi4/rmi_bus.h b/drivers/input/rmi4/rmi_bus.h
index 33e8f1b..e2a3dc6 100644
--- a/drivers/input/rmi4/rmi_bus.h
+++ b/drivers/input/rmi4/rmi_bus.h
@@ -22,17 +22,6 @@ 
 #include <linux/debugfs.h>
 #include <linux/rmi.h>
 
-
-/* Permissions for sysfs attributes.  Since the permissions policy will change
- * on a global basis in the future, rather than edit all sysfs attrs everywhere
- * in the driver (and risk screwing that up in the process), we use this handy
- * set of #defines.  That way when we change the policy for sysfs permissions,
- * we only need to change them here.
- */
-#define RMI_RO_ATTR S_IRUGO
-#define RMI_RW_ATTR (S_IRUGO | S_IWUGO)
-#define RMI_WO_ATTR S_IWUGO
-
 struct rmi_device;
 
 /**
diff --git a/drivers/input/rmi4/rmi_driver.c b/drivers/input/rmi4/rmi_driver.c
index 5cf7b33..132cd52 100644
--- a/drivers/input/rmi4/rmi_driver.c
+++ b/drivers/input/rmi4/rmi_driver.c
@@ -4,9 +4,10 @@ 
  *
  * This driver provides the core support for a single RMI4-based device.
  *
- * The RMI4 specification can be found here:
+ * The RMI4 specification can be found here (URL split for line length):
  *
- * http://www.synaptics.com/sites/default/files/511-000136-01-Rev-E-RMI4%20Intrfacing%20Guide.pdf
+ * http://www.synaptics.com/sites/default/files/
+ *      511-000136-01-Rev-E-RMI4%20Intrfacing%20Guide.pdf
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 as published by
@@ -42,48 +43,6 @@ 
 
 #define IRQ_DEBUG(data) (IS_ENABLED(CONFIG_RMI4_DEBUG) && data->irq_debug)
 
-#ifdef	CONFIG_RMI4_DEBUG
-static void rmi_driver_setup_debugfs(struct rmi_device *rmi_dev)
-{
-	struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev);
-	struct rmi_phys_info *info = &rmi_dev->phys->info;
-
-	if (!rmi_dev->debugfs_root)
-		return;
-
-	if (!debugfs_create_u32_array("transport_stats", RMI_RO_ATTR,
-				      rmi_dev->debugfs_root,
-				      (u32 *)&info->tx_count, 6))
-		dev_warn(&rmi_dev->dev,
-			 "Failed to create debugfs transport_stats\n");
-
-	if (!debugfs_create_bool("irq_debug", RMI_RW_ATTR,
-				 rmi_dev->debugfs_root,
-				 &data->irq_debug))
-		dev_warn(&rmi_dev->dev, "Failed to create debugfs irq_debug\n");
-
-	if (!debugfs_create_u32("attn_count", RMI_RO_ATTR,
-				rmi_dev->debugfs_root,
-				&data->attn_count))
-		dev_warn(&rmi_dev->dev,
-			 "Failed to create debugfs attn_count\n");
-}
-
-static void rmi_driver_teardown_debugfs(struct rmi_device *rmi_dev)
-{
-	debugfs_remove_recursive(rmi_dev->debugfs_root);
-}
-
-#else
-static inline void rmi_driver_setup_debugfs(struct rmi_device *rmi_dev)
-{
-}
-
-static inline rmi_driver_teardown_debugfs(struct rmi_device *rmi_dev)
-{
-}
-#endif
-
 static irqreturn_t rmi_irq_thread(int irq, void *p)
 {
 	struct rmi_phys_device *phys = p;
@@ -217,122 +176,6 @@  static int enable_sensor(struct rmi_device *rmi_dev)
 	return retval;
 }
 
-/* sysfs show and store fns for driver attributes */
-
-static ssize_t rmi_driver_bsr_show(struct device *dev,
-				   struct device_attribute *attr, char *buf)
-{
-	struct rmi_device *rmi_dev;
-	struct rmi_driver_data *data;
-	rmi_dev = to_rmi_device(dev);
-	data = dev_get_drvdata(&rmi_dev->dev);
-
-	return snprintf(buf, PAGE_SIZE, "%u\n", data->bsr);
-}
-
-static ssize_t rmi_driver_bsr_store(struct device *dev,
-				    struct device_attribute *attr,
-				    const char *buf, size_t count)
-{
-	int retval;
-	unsigned long val;
-	struct rmi_device *rmi_dev;
-	struct rmi_driver_data *data;
-
-	rmi_dev = to_rmi_device(dev);
-	data = dev_get_drvdata(&rmi_dev->dev);
-
-	/* need to convert the string data to an actual value */
-	retval = strict_strtoul(buf, 10, &val);
-	if (retval < 0 || val > 255) {
-		dev_err(dev, "Invalid value '%s' written to BSR.\n", buf);
-		return -EINVAL;
-	}
-
-	retval = rmi_write(rmi_dev, BSR_LOCATION, (u8)val);
-	if (retval < 0) {
-		dev_err(dev, "%s : failed to write bsr %lu to %#06x\n",
-			__func__, val, BSR_LOCATION);
-		return retval;
-	}
-
-	data->bsr = val;
-
-	return count;
-}
-
-static DEVICE_ATTR(bsr, RMI_RW_ATTR, rmi_driver_bsr_show, rmi_driver_bsr_store);
-
-static ssize_t rmi_driver_enabled_show(struct device *dev,
-				       struct device_attribute *attr, char *buf)
-{
-	struct rmi_device *rmi_dev = to_rmi_device(dev);
-	struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev);
-
-	return snprintf(buf, PAGE_SIZE, "%u\n", data->enabled);
-}
-
-static ssize_t rmi_driver_enabled_store(struct device *dev,
-					struct device_attribute *attr,
-					const char *buf, size_t count)
-{
-	struct rmi_device *rmi_dev = to_rmi_device(dev);
-	int retval;
-	int new_value;
-
-	if (sysfs_streq(buf, "0"))
-		new_value = false;
-	else if (sysfs_streq(buf, "1"))
-		new_value = true;
-	else
-		return -EINVAL;
-
-	if (new_value) {
-		retval = enable_sensor(rmi_dev);
-		if (retval) {
-			dev_err(dev, "Failed to enable sensor, code=%d.\n",
-				retval);
-			return -EIO;
-		}
-	} else {
-		disable_sensor(rmi_dev);
-	}
-
-	return count;
-}
-
-/** This sysfs attribute is deprecated, and will be removed in a future release.
- */
-static DEVICE_ATTR(enabled, RMI_RW_ATTR,
-		   rmi_driver_enabled_show, rmi_driver_enabled_store);
-
-static umode_t rmi_driver_attr_visible(struct kobject *kobj,
-				       struct attribute *attr, int n)
-{
-	struct device *dev = kobj_to_dev(kobj);
-	struct rmi_device *rmi_dev = to_rmi_device(dev);
-	struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev);
-	umode_t mode = attr->mode;
-
-	if (attr == &dev_attr_bsr.attr) {
-		if (!data->pdt_props.has_bsr)
-			mode = 0;
-	}
-
-	return mode;
-}
-
-static struct attribute *rmi_driver_attrs[] = {
-	&dev_attr_bsr.attr,
-	&dev_attr_enabled.attr,
-	NULL
-};
-
-static struct attribute_group rmi_driver_attr_group = {
-	.is_visible	= rmi_driver_attr_visible,
-	.attrs		= rmi_driver_attrs,
-};
-
 static void rmi_free_function_list(struct rmi_device *rmi_dev)
 {
 	struct rmi_function *fn, *tmp;
@@ -718,7 +561,8 @@  static int reset_and_reflash(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);
+	const struct rmi_device_platform_data *pdata =
+			to_rmi_platform_data(rmi_dev);
 
 	dev_dbg(dev, "Initial reset.\n");
 
@@ -941,7 +785,6 @@  static int rmi_driver_remove(struct device *dev)
 	struct rmi_device *rmi_dev = to_rmi_device(dev);
 
 	rmi_driver_teardown_debugfs(rmi_dev);
-	sysfs_remove_group(&dev->kobj, &rmi_driver_attr_group);
 
 	disable_sensor(rmi_dev);
 	rmi_free_function_list(rmi_dev);
@@ -1079,14 +922,6 @@  static int rmi_driver_probe(struct device *dev)
 		mutex_init(&data->suspend_mutex);
 	}
 
-	retval = sysfs_create_group(&dev->kobj, &rmi_driver_attr_group);
-	if (retval < 0) {
-		dev_err(dev, "%s: Failed to create sysfs group\n", __func__);
-		goto err_free_data;
-	}
-
-	rmi_driver_setup_debugfs(rmi_dev);
-
 	if (pdata->attn_gpio) {
 		data->irq = gpio_to_irq(pdata->attn_gpio);
 		if (pdata->level_triggered) {
diff --git a/drivers/input/rmi4/rmi_f01.c b/drivers/input/rmi4/rmi_f01.c
index fe26869..840a8d0 100644
--- a/drivers/input/rmi4/rmi_f01.c
+++ b/drivers/input/rmi4/rmi_f01.c
@@ -8,7 +8,6 @@ 
  */
 
 #include <linux/kernel.h>
-#include <linux/debugfs.h>
 #include <linux/kconfig.h>
 #include <linux/rmi.h>
 #include <linux/slab.h>
@@ -143,780 +142,6 @@  struct f01_data {
 	bool suspended;
 	bool old_nosleep;
 #endif
-
-#ifdef CONFIG_RMI4_DEBUG
-	struct dentry *debugfs_interrupt_enable;
-#endif
-};
-
-#ifdef CONFIG_RMI4_DEBUG
-struct f01_debugfs_data {
-	bool done;
-	struct rmi_function *fn;
-};
-
-static int f01_debug_open(struct inode *inodep, struct file *filp)
-{
-	struct f01_debugfs_data *data;
-	struct rmi_function *fn = inodep->i_private;
-
-	data = kzalloc(sizeof(struct f01_debugfs_data), GFP_KERNEL);
-	if (!data)
-		return -ENOMEM;
-
-	data->fn = fn;
-	filp->private_data = data;
-	return 0;
-}
-
-static int f01_debug_release(struct inode *inodep, struct file *filp)
-{
-	kfree(filp->private_data);
-	return 0;
-}
-
-static ssize_t interrupt_enable_read(struct file *filp, char __user *buffer,
-				     size_t size, loff_t *offset) {
-	int i;
-	int len;
-	int total_len = 0;
-	char local_buf[size]; // FIXME!!!! XXX arbitrary size array on stack
-	char *current_buf = local_buf;
-	struct f01_debugfs_data *data = filp->private_data;
-	struct f01_data *f01 = data->fn->data;
-
-	if (data->done)
-		return 0;
-
-	data->done = 1;
-
-	/* loop through each irq value and copy its
-	 * string representation into buf */
-	for (i = 0; i < f01->irq_count; i++) {
-		int irq_reg;
-		int irq_shift;
-		int interrupt_enable;
-
-		irq_reg = i / 8;
-		irq_shift = i % 8;
-		interrupt_enable =
-		    ((f01->device_control.interrupt_enable[irq_reg]
-			>> irq_shift) & 0x01);
-
-		/* get next irq value and write it to buf */
-		len = snprintf(current_buf, size - total_len,
-			"%u ", interrupt_enable);
-		/* bump up ptr to next location in buf if the
-		 * snprintf was valid.  Otherwise issue an error
-		 * and return. */
-		if (len > 0) {
-			current_buf += len;
-			total_len += len;
-		} else {
-			dev_err(&data->fn->dev, "Failed to build interrupt_enable buffer, code = %d.\n",
-						len);
-			return snprintf(local_buf, size, "unknown\n");
-		}
-	}
-	len = snprintf(current_buf, size - total_len, "\n");
-	if (len > 0)
-		total_len += len;
-	else
-		dev_warn(&data->fn->dev, "%s: Failed to append carriage return.\n",
-			 __func__);
-
-	if (copy_to_user(buffer, local_buf, total_len))
-		return -EFAULT;
-
-	return total_len;
-}
-
-static ssize_t interrupt_enable_write(struct file *filp,
-		const char __user *buffer, size_t size, loff_t *offset) {
-	int retval;
-	char buf[size];
-	char *local_buf = buf;
-	int i;
-	int irq_count = 0;
-	int irq_reg = 0;
-	struct f01_debugfs_data *data = filp->private_data;
-	struct f01_data *f01 = data->fn->data;
-
-	retval = copy_from_user(buf, buffer, size);
-	if (retval)
-		return -EFAULT;
-
-	for (i = 0; i < f01->irq_count && *local_buf != 0;
-	     i++, local_buf += 2) {
-		int irq_shift;
-		int interrupt_enable;
-		int result;
-
-		irq_reg = i / 8;
-		irq_shift = i % 8;
-
-		/* get next interrupt mapping value and store and bump up to
-		 * point to next item in local_buf */
-		result = sscanf(local_buf, "%u", &interrupt_enable);
-		if ((result != 1) ||
-			(interrupt_enable != 0 && interrupt_enable != 1)) {
-			dev_err(&data->fn->dev, "Interrupt enable[%d] is not a valid value 0x%x.\n",
-				i, interrupt_enable);
-			return -EINVAL;
-		}
-		if (interrupt_enable == 0) {
-			f01->device_control.interrupt_enable[irq_reg] &=
-				(1 << irq_shift) ^ 0xFF;
-		} else
-			f01->device_control.interrupt_enable[irq_reg] |=
-				(1 << irq_shift);
-		irq_count++;
-	}
-
-	/* Make sure the irq count matches */
-	if (irq_count != f01->irq_count) {
-		dev_err(&data->fn->dev, "Interrupt enable count of %d doesn't match device count of %d.\n",
-			 irq_count, f01->irq_count);
-		return -EINVAL;
-	}
-
-	/* write back to the control register */
-	retval = rmi_write_block(data->fn->rmi_dev, f01->interrupt_enable_addr,
-			f01->device_control.interrupt_enable,
-			f01->num_of_irq_regs);
-	if (retval < 0) {
-		dev_err(&data->fn->dev, "Could not write interrupt_enable mask to %#06x\n",
-			f01->interrupt_enable_addr);
-		return retval;
-	}
-
-	return size;
-}
-
-static const struct file_operations interrupt_enable_fops = {
-	.owner = THIS_MODULE,
-	.open = f01_debug_open,
-	.release = f01_debug_release,
-	.read = interrupt_enable_read,
-	.write = interrupt_enable_write,
-};
-
-static int setup_debugfs(struct rmi_function *fn)
-{
-	struct f01_data *data = fn->data;
-
-	if (!fn->debugfs_root)
-		return -ENODEV;
-
-	data->debugfs_interrupt_enable = debugfs_create_file("interrupt_enable",
-		RMI_RW_ATTR, fn->debugfs_root, fn, &interrupt_enable_fops);
-	if (!data->debugfs_interrupt_enable)
-		dev_warn(&fn->dev,
-			 "Failed to create debugfs interrupt_enable.\n");
-
-	return 0;
-}
-
-static void teardown_debugfs(struct f01_data *f01)
-{
-	if (f01->debugfs_interrupt_enable)
-		debugfs_remove(f01->debugfs_interrupt_enable);
-}
-
-#else
-
-static inline int setup_debugfs(struct rmi_function *fn)
-{
-	return 0;
-}
-
-static inline void teardown_debugfs(struct f01_data *f01)
-{
-}
-
-#endif
-
-static ssize_t rmi_fn_01_productinfo_show(struct device *dev,
-					  struct device_attribute *attr,
-					  char *buf)
-{
-	struct rmi_function *fn = to_rmi_function(dev);
-	struct f01_data *data = fn->data;
-
-	return snprintf(buf, PAGE_SIZE, "0x%04x\n",
-			data->properties.productinfo);
-}
-
-static ssize_t rmi_fn_01_productid_show(struct device *dev,
-					struct device_attribute *attr,
-					char *buf)
-{
-	struct rmi_function *fn = to_rmi_function(dev);
-	struct f01_data *data = fn->data;
-
-	return snprintf(buf, PAGE_SIZE, "%s\n", data->properties.product_id);
-}
-
-static ssize_t rmi_fn_01_manufacturer_show(struct device *dev,
-					   struct device_attribute *attr,
-					   char *buf)
-{
-	struct rmi_function *fn = to_rmi_function(dev);
-	struct f01_data *data = fn->data;
-
-	return snprintf(buf, PAGE_SIZE, "0x%02x\n",
-			data->properties.manufacturer_id);
-}
-
-static ssize_t rmi_fn_01_datecode_show(struct device *dev,
-				       struct device_attribute *attr,
-				       char *buf)
-{
-	struct rmi_function *fn = to_rmi_function(dev);
-	struct f01_data *data = fn->data;
-
-	return snprintf(buf, PAGE_SIZE, "%s\n", data->properties.dom);
-}
-
-static ssize_t rmi_fn_01_reset_store(struct device *dev,
-				     struct device_attribute *attr,
-				     const char *buf, size_t count)
-{
-	struct rmi_function *fn = to_rmi_function(dev);
-	unsigned int reset;
-	int error;
-
-	if (sscanf(buf, "%u", &reset) != 1)
-		return -EINVAL;
-	if (reset < 0 || reset > 1)
-		return -EINVAL;
-
-	/* Per spec, 0 has no effect, so we skip it entirely. */
-	if (reset) {
-		/* Command register always reads as 0, so just use a local. */
-		u8 command = RMI_F01_CMD_DEVICE_RESET;
-
-		error = rmi_write_block(fn->rmi_dev, fn->fd.command_base_addr,
-					 &command, sizeof(command));
-		if (error < 0) {
-			dev_err(dev, "Failed to issue reset command, code = %d.",
-				error);
-			return error;
-		}
-	}
-
-	return count;
-}
-
-static ssize_t rmi_fn_01_sleepmode_show(struct device *dev,
-					struct device_attribute *attr,
-					char *buf)
-{
-	struct rmi_function *fn = to_rmi_function(dev);
-	struct f01_data *data = fn->data;
-	unsigned int value = data->device_control.ctrl0 &
-					RMI_F01_CTRL0_SLEEP_MODE_MASK;
-
-	return snprintf(buf, PAGE_SIZE, "%d\n", value);
-}
-
-static ssize_t rmi_fn_01_sleepmode_store(struct device *dev,
-					 struct device_attribute *attr,
-					 const char *buf, size_t count)
-{
-	struct rmi_function *fn = to_rmi_function(dev);
-	struct f01_data *data = fn->data;
-	unsigned long new_value;
-	int retval;
-
-	retval = strict_strtoul(buf, 10, &new_value);
-	if (retval < 0 || !RMI_IS_VALID_SLEEPMODE(new_value)) {
-		dev_err(dev, "%s: Invalid sleep mode %s.", __func__, buf);
-		return -EINVAL;
-	}
-
-	retval = mutex_lock_interruptible(&data->control_mutex);
-	if (retval)
-		return retval;
-
-	dev_dbg(dev, "Setting sleep mode to %ld.", new_value);
-
-	data->device_control.ctrl0 &= ~RMI_F01_CTRL0_SLEEP_MODE_MASK;
-	data->device_control.ctrl0 |= new_value;
-
-	retval = rmi_write_block(fn->rmi_dev, fn->fd.control_base_addr,
-			&data->device_control.ctrl0,
-			sizeof(data->device_control.ctrl0));
-	if (retval >= 0)
-		retval = count;
-	else
-		dev_err(dev, "Failed to write sleep mode, code %d.\n", retval);
-
-	mutex_unlock(&data->control_mutex);
-	return retval;
-}
-
-static ssize_t rmi_fn_01_nosleep_show(struct device *dev,
-				      struct device_attribute *attr, char *buf)
-{
-	struct rmi_function *fn = to_rmi_function(dev);
-	struct f01_data *data = fn->data;
-	unsigned int value = !!(data->device_control.ctrl0 &
-					RMI_F01_CRTL0_NOSLEEP_BIT);
-
-	return snprintf(buf, PAGE_SIZE, "%d\n", value);
-}
-
-static ssize_t rmi_fn_01_nosleep_store(struct device *dev,
-				       struct device_attribute *attr,
-				       const char *buf, size_t count)
-{
-	struct rmi_function *fn = to_rmi_function(dev);
-	struct f01_data *data = fn->data;
-	unsigned long new_value;
-	int retval;
-
-	retval = strict_strtoul(buf, 10, &new_value);
-	if (retval < 0 || new_value > 1) {
-		dev_err(dev, "%s: Invalid nosleep bit %s.", __func__, buf);
-		return -EINVAL;
-	}
-
-	retval = mutex_lock_interruptible(&data->control_mutex);
-	if (retval)
-		return retval;
-
-	if (new_value)
-		data->device_control.ctrl0 |= RMI_F01_CRTL0_NOSLEEP_BIT;
-	else
-		data->device_control.ctrl0 &= ~RMI_F01_CRTL0_NOSLEEP_BIT;
-
-	retval = rmi_write_block(fn->rmi_dev, fn->fd.control_base_addr,
-				 &data->device_control.ctrl0,
-				 sizeof(data->device_control.ctrl0));
-	if (retval >= 0)
-		retval = count;
-	else
-		dev_err(dev, "Failed to write nosleep bit.\n");
-
-	mutex_unlock(&data->control_mutex);
-	return retval;
-}
-
-static ssize_t rmi_fn_01_chargerinput_show(struct device *dev,
-				      struct device_attribute *attr, char *buf)
-{
-	struct rmi_function *fn = to_rmi_function(dev);
-	struct f01_data *data = fn->data;
-	unsigned int value = !!(data->device_control.ctrl0 &
-					RMI_F01_CRTL0_CHARGER_BIT);
-
-	return snprintf(buf, PAGE_SIZE, "%d\n", value);
-}
-
-static ssize_t rmi_fn_01_chargerinput_store(struct device *dev,
-				       struct device_attribute *attr,
-				       const char *buf, size_t count)
-{
-	struct rmi_function *fn = to_rmi_function(dev);
-	struct f01_data *data = fn->data;
-	unsigned long new_value;
-	int retval;
-
-	retval = strict_strtoul(buf, 10, &new_value);
-	if (retval < 0 || new_value > 1) {
-		dev_err(dev, "%s: Invalid chargerinput bit %s.", __func__, buf);
-		return -EINVAL;
-	}
-
-	retval = mutex_lock_interruptible(&data->control_mutex);
-	if (retval)
-		return retval;
-
-	if (new_value)
-		data->device_control.ctrl0 |= RMI_F01_CRTL0_CHARGER_BIT;
-	else
-		data->device_control.ctrl0 &= ~RMI_F01_CRTL0_CHARGER_BIT;
-
-	retval = rmi_write_block(fn->rmi_dev, fn->fd.control_base_addr,
-				 &data->device_control.ctrl0,
-				 sizeof(data->device_control.ctrl0));
-	if (retval >= 0)
-		retval = count;
-	else
-		dev_err(dev, "Failed to write chargerinput bit.\n");
-
-	mutex_unlock(&data->control_mutex);
-	return retval;
-}
-
-static ssize_t rmi_fn_01_reportrate_show(struct device *dev,
-				      struct device_attribute *attr, char *buf)
-{
-	struct rmi_function *fn = to_rmi_function(dev);
-	struct f01_data *data = fn->data;
-	int value = !!(data->device_control.ctrl0 &
-				RMI_F01_CRTL0_REPORTRATE_BIT);
-
-	return snprintf(buf, PAGE_SIZE, "%d\n", value);
-}
-
-static ssize_t rmi_fn_01_reportrate_store(struct device *dev,
-				       struct device_attribute *attr,
-				       const char *buf, size_t count)
-{
-	struct rmi_function *fn = to_rmi_function(dev);
-	struct f01_data *data = fn->data;
-	unsigned long new_value;
-	int retval;
-
-	retval = strict_strtoul(buf, 10, &new_value);
-	if (retval < 0 || new_value > 1) {
-		dev_err(dev, "%s: Invalid reportrate bit %s.", __func__, buf);
-		return -EINVAL;
-	}
-
-	retval = mutex_lock_interruptible(&data->control_mutex);
-	if (retval)
-		return retval;
-
-	if (new_value)
-		data->device_control.ctrl0 |= RMI_F01_CRTL0_REPORTRATE_BIT;
-	else
-		data->device_control.ctrl0 &= ~RMI_F01_CRTL0_REPORTRATE_BIT;
-
-	retval = rmi_write_block(fn->rmi_dev, fn->fd.control_base_addr,
-				 &data->device_control.ctrl0,
-				 sizeof(data->device_control.ctrl0));
-	if (retval >= 0)
-		retval = count;
-	else
-		dev_err(dev, "Failed to write reportrate bit.\n");
-
-	mutex_unlock(&data->control_mutex);
-	return retval;
-}
-
-static ssize_t rmi_fn_01_interrupt_enable_show(struct device *dev,
-				struct device_attribute *attr, char *buf)
-{
-	struct rmi_function *fn = to_rmi_function(dev);
-	struct f01_data *data = fn->data;
-	int i, len, total_len = 0;
-	char *current_buf = buf;
-
-	/* loop through each irq value and copy its
-	 * string representation into buf */
-	for (i = 0; i < data->irq_count; i++) {
-		int irq_reg;
-		int irq_shift;
-		int interrupt_enable;
-
-		irq_reg = i / 8;
-		irq_shift = i % 8;
-		interrupt_enable =
-		    ((data->device_control.interrupt_enable[irq_reg]
-			>> irq_shift) & 0x01);
-
-		/* get next irq value and write it to buf */
-		len = snprintf(current_buf, PAGE_SIZE - total_len,
-			"%u ", interrupt_enable);
-		/* bump up ptr to next location in buf if the
-		 * snprintf was valid.  Otherwise issue an error
-		 * and return. */
-		if (len > 0) {
-			current_buf += len;
-			total_len += len;
-		} else {
-			dev_err(dev, "Failed to build interrupt_enable buffer, code = %d.\n",
-						len);
-			return snprintf(buf, PAGE_SIZE, "unknown\n");
-		}
-	}
-	len = snprintf(current_buf, PAGE_SIZE - total_len, "\n");
-	if (len > 0)
-		total_len += len;
-	else
-		dev_warn(dev, "%s: Failed to append carriage return.\n",
-			 __func__);
-	return total_len;
-
-}
-
-static ssize_t rmi_fn_01_doze_interval_show(struct device *dev,
-				struct device_attribute *attr, char *buf)
-{
-	struct rmi_function *fn = to_rmi_function(dev);
-	struct f01_data *data = fn->data;
-
-	return snprintf(buf, PAGE_SIZE, "%d\n",
-			data->device_control.doze_interval);
-
-}
-
-static ssize_t rmi_fn_01_doze_interval_store(struct device *dev,
-					  struct device_attribute *attr,
-					  const char *buf, size_t count)
-{
-	struct rmi_function *fn = to_rmi_function(dev);
-	struct f01_data *data = fn->data;
-	unsigned long new_value;
-	int retval;
-	u16 ctrl_base_addr;
-
-	retval = strict_strtoul(buf, 10, &new_value);
-	if (retval < 0 || new_value > 255) {
-		dev_err(dev, "%s: Invalid doze interval %s.", __func__, buf);
-		return -EINVAL;
-	}
-
-	retval = mutex_lock_interruptible(&data->control_mutex);
-	if (retval)
-		return retval;
-
-	data->device_control.doze_interval = new_value;
-	ctrl_base_addr = fn->fd.control_base_addr + sizeof(u8) +
-			(sizeof(u8)*(data->num_of_irq_regs));
-	dev_dbg(dev, "doze_interval store address %x, value %d",
-		ctrl_base_addr, data->device_control.doze_interval);
-
-	retval = rmi_write_block(fn->rmi_dev, data->doze_interval_addr,
-			&data->device_control.doze_interval,
-			sizeof(u8));
-	if (retval >= 0)
-		retval = count;
-	else
-		dev_err(dev, "Failed to write doze interval.\n");
-
-	mutex_unlock(&data->control_mutex);
-	return retval;
-}
-
-static ssize_t rmi_fn_01_wakeup_threshold_show(struct device *dev,
-					 struct device_attribute *attr,
-					 char *buf)
-{
-	struct rmi_function *fn = to_rmi_function(dev);
-	struct f01_data *data = fn->data;
-
-	return snprintf(buf, PAGE_SIZE, "%d\n",
-			data->device_control.wakeup_threshold);
-}
-
-static ssize_t rmi_fn_01_wakeup_threshold_store(struct device *dev,
-					  struct device_attribute *attr,
-					  const char *buf, size_t count)
-{
-	struct rmi_function *fn = to_rmi_function(dev);
-	struct f01_data *data = fn->data;
-	unsigned long new_value;
-	int retval;
-
-	retval = strict_strtoul(buf, 10, &new_value);
-	if (retval < 0 || new_value > 255) {
-		dev_err(dev, "%s: Invalid wakeup threshold %s.", __func__, buf);
-		return -EINVAL;
-	}
-
-	retval = mutex_lock_interruptible(&data->control_mutex);
-	if (retval)
-		return retval;
-
-	data->device_control.doze_interval = new_value;
-	retval = rmi_write_block(fn->rmi_dev, data->wakeup_threshold_addr,
-			&data->device_control.wakeup_threshold,
-			sizeof(u8));
-	if (retval >= 0)
-		retval = count;
-	else
-		dev_err(dev, "Failed to write wakeup threshold.\n");
-
-	mutex_unlock(&data->control_mutex);
-	return retval;
-}
-
-static ssize_t rmi_fn_01_doze_holdoff_show(struct device *dev,
-					 struct device_attribute *attr,
-					 char *buf)
-{
-	struct rmi_function *fn = to_rmi_function(dev);
-	struct f01_data *data = fn->data;
-
-	return snprintf(buf, PAGE_SIZE, "%d\n",
-			data->device_control.doze_holdoff);
-
-}
-
-static ssize_t rmi_fn_01_doze_holdoff_store(struct device *dev,
-					  struct device_attribute *attr,
-					  const char *buf, size_t count)
-{
-	struct rmi_function *fn = to_rmi_function(dev);
-	struct f01_data *data = fn->data;
-	unsigned long new_value;
-	int retval;
-
-	retval = strict_strtoul(buf, 10, &new_value);
-	if (retval < 0 || new_value > 255) {
-		dev_err(dev, "%s: Invalid doze holdoff %s.", __func__, buf);
-		return -EINVAL;
-	}
-
-	retval = mutex_lock_interruptible(&data->control_mutex);
-	if (retval)
-		return retval;
-
-	data->device_control.doze_interval = new_value;
-	retval = rmi_write_block(fn->rmi_dev, data->doze_holdoff_addr,
-			&data->device_control.doze_holdoff,
-			sizeof(u8));
-	if (retval >= 0)
-		retval = count;
-	else
-		dev_err(dev, "Failed to write doze holdoff.\n");
-
-	mutex_unlock(&data->control_mutex);
-	return retval;
-}
-
-static ssize_t rmi_fn_01_configured_show(struct device *dev,
-				      struct device_attribute *attr, char *buf)
-{
-	struct rmi_function *fn = to_rmi_function(dev);
-	struct f01_data *data = fn->data;
-	unsigned int value = !!(data->device_control.ctrl0 &
-					RMI_F01_CRTL0_CONFIGURED_BIT);
-
-	return snprintf(buf, PAGE_SIZE, "%d\n", value);
-}
-
-static ssize_t rmi_fn_01_unconfigured_show(struct device *dev,
-				      struct device_attribute *attr, char *buf)
-{
-	struct rmi_function *fn = to_rmi_function(dev);
-	struct f01_data *data = fn->data;
-
-	return snprintf(buf, PAGE_SIZE, "%d\n",
-			RMI_F01_STATUS_UNCONFIGURED(data->device_status));
-}
-
-static ssize_t rmi_fn_01_flashprog_show(struct device *dev,
-				      struct device_attribute *attr, char *buf)
-{
-	struct rmi_function *fn = to_rmi_function(dev);
-	struct f01_data *data = fn->data;
-
-	return snprintf(buf, PAGE_SIZE, "%d\n",
-			RMI_F01_STATUS_BOOTLOADER(data->device_status));
-}
-
-static ssize_t rmi_fn_01_statuscode_show(struct device *dev,
-				      struct device_attribute *attr, char *buf)
-{
-	struct rmi_function *fn = to_rmi_function(dev);
-	struct f01_data *data = fn->data;
-
-	return snprintf(buf, PAGE_SIZE, "0x%02x\n",
-			RMI_F01_STATUS_CODE(data->device_status));
-}
-
-#define RMI_F01_ATTR(_name)			\
-	DEVICE_ATTR(_name, RMI_RW_ATTR,		\
-		    rmi_fn_01_##_name##_show,	\
-		    rmi_fn_01_##_name##_store)
-
-#define RMI_F01_RO_ATTR(_name)			\
-	DEVICE_ATTR(_name, RMI_RO_ATTR,		\
-		    rmi_fn_01_##_name##_show,	\
-		    NULL)
-
-#define RMI_F01_WO_ATTR(_name)			\
-	DEVICE_ATTR(_name, RMI_RO_ATTR,		\
-		    NULL,			\
-		    rmi_fn_01_##_name##_store)
-
-
-static RMI_F01_RO_ATTR(productinfo);
-static RMI_F01_RO_ATTR(productid);
-static RMI_F01_RO_ATTR(manufacturer);
-static RMI_F01_RO_ATTR(datecode);
-
-/* Control register access */
-static RMI_F01_ATTR(sleepmode);
-static RMI_F01_ATTR(nosleep);
-static RMI_F01_ATTR(chargerinput);
-static RMI_F01_ATTR(reportrate);
-
-/*
- * We don't want arbitrary callers changing the interrupt enable mask,
- * so it's read only.
- */
-static RMI_F01_RO_ATTR(interrupt_enable);
-static RMI_F01_ATTR(doze_interval);
-static RMI_F01_ATTR(wakeup_threshold);
-static RMI_F01_ATTR(doze_holdoff);
-
-/*
- * We make 'configured' RO, since the driver uses that to look for
- * resets.  We don't want someone faking us out by changing that
- * bit.
- */
-static RMI_F01_RO_ATTR(configured);
-
-/* Command register access. */
-static RMI_F01_WO_ATTR(reset);
-
-/* Status register access. */
-static RMI_F01_RO_ATTR(unconfigured);
-static RMI_F01_RO_ATTR(flashprog);
-static RMI_F01_RO_ATTR(statuscode);
-
-static struct attribute *rmi_fn_01_attrs[] = {
-	&dev_attr_productinfo.attr,
-	&dev_attr_productid.attr,
-	&dev_attr_manufacturer.attr,
-	&dev_attr_datecode.attr,
-	&dev_attr_sleepmode.attr,
-	&dev_attr_nosleep.attr,
-	&dev_attr_chargerinput.attr,
-	&dev_attr_reportrate.attr,
-	&dev_attr_interrupt_enable.attr,
-	&dev_attr_doze_interval.attr,
-	&dev_attr_wakeup_threshold.attr,
-	&dev_attr_doze_holdoff.attr,
-	&dev_attr_configured.attr,
-	&dev_attr_reset.attr,
-	&dev_attr_unconfigured.attr,
-	&dev_attr_flashprog.attr,
-	&dev_attr_statuscode.attr,
-	NULL
-};
-
-static umode_t rmi_fn_01_attr_visible(struct kobject *kobj,
-				      struct attribute *attr, int n)
-{
-	struct device *dev = kobj_to_dev(kobj);
-	struct rmi_function *fn = to_rmi_function(dev);
-	struct f01_data *data = fn->data;
-	umode_t mode = attr->mode;
-
-	if (attr == &dev_attr_doze_interval.attr) {
-		if (!data->properties.has_lts)
-			mode = 0;
-	} else if (attr == &dev_attr_wakeup_threshold.attr) {
-		if (!data->properties.has_adjustable_doze)
-			mode = 0;
-	} else if (attr == &dev_attr_doze_holdoff.attr) {
-		if (!data->properties.has_adjustable_doze_holdoff)
-			mode = 0;
-	}
-
-	return mode;
-}
-
-static struct attribute_group rmi_fn_01_attr_group = {
-	.is_visible	= rmi_fn_01_attr_visible,
-	.attrs		= rmi_fn_01_attrs,
 };
 
 static int rmi_f01_alloc_memory(struct rmi_function *fn,
@@ -1148,11 +373,6 @@  static int rmi_f01_initialize(struct rmi_function *fn)
 		goto error_exit;
 	}
 
-	error = setup_debugfs(fn);
-	if (error)
-		dev_warn(&fn->dev, "Failed to setup debugfs, error: %d.\n",
-			 error);
-
 	return 0;
 
  error_exit:
@@ -1228,17 +448,12 @@  static int rmi_f01_probe(struct rmi_function *fn)
 	if (error)
 		return error;
 
-	error = sysfs_create_group(&fn->dev.kobj, &rmi_fn_01_attr_group);
-	if (error)
-		return error;
-
 	return 0;
 }
 
 static void rmi_f01_remove(struct rmi_function *fn)
 {
-	teardown_debugfs(fn->data);
-	sysfs_remove_group(&fn->dev.kobj, &rmi_fn_01_attr_group);
+	/* Placeholder for now. */
 }
 
 #ifdef CONFIG_PM_SLEEP
diff --git a/drivers/input/rmi4/rmi_f11.c b/drivers/input/rmi4/rmi_f11.c
index 017c8ff..8984054 100644
--- a/drivers/input/rmi4/rmi_f11.c
+++ b/drivers/input/rmi4/rmi_f11.c
@@ -10,7 +10,6 @@ 
 #define FUNCTION_DATA f11_data
 
 #include <linux/kernel.h>
-#include <linux/debugfs.h>
 #include <linux/delay.h>
 #include <linux/device.h>
 #include <linux/input.h>
@@ -822,177 +821,6 @@  enum finger_state_values {
 	F11_RESERVED	= 0x03
 };
 
-static ssize_t rmi_f11_rezero_store(struct device *dev,
-				    struct device_attribute *attr,
-				    const char *buf, size_t count)
-{
-	struct rmi_function *fn = to_rmi_function(dev);
-	unsigned int rezero;
-	int error;
-
-	error = kstrtouint(buf, 0, &rezero);
-	if (error)
-		return error;
-
-	if (rezero > 1)
-		return -ERANGE;
-
-	/* Per spec, 0 has no effect, so we skip it entirely. */
-	if (rezero) {
-		/* Command register always reads as 0, so just use a local. */
-		struct f11_2d_commands commands = {
-			.rezero = true,
-		};
-
-		error = rmi_write_block(fn->rmi_dev, fn->fd.command_base_addr,
-					&commands, sizeof(commands));
-		if (error < 0) {
-			dev_err(dev,
-				"%s: failed to issue rezero command, error = %d.",
-				__func__, error);
-			return error;
-		}
-	}
-
-	return count;
-}
-
-static DEVICE_ATTR(rezero, RMI_WO_ATTR, NULL, rmi_f11_rezero_store);
-
-static struct attribute *rmi_f11_attrs[] = {
-	&dev_attr_rezero.attr,
-	NULL
-};
-
-static struct attribute_group rmi_f11_attr_group = {
-	.attrs = rmi_f11_attrs,
-};
-
-#ifdef CONFIG_RMI4_DEBUG
-static void rmi_f11_setup_sensor_debugfs(struct f11_2d_sensor *sensor)
-{
-	struct rmi_function *fn = sensor->fn;
-	struct dentry *sensor_root;
-	char dirname[sizeof("sensorNNN")];
-
-	if (!fn->debugfs_root)
-		return;
-
-	snprintf(dirname, sizeof(dirname), "input%3u", sensor->sensor_index);
-	sensor_root = debugfs_create_dir(dirname, fn->debugfs_root);
-	if (!sensor_root) {
-		dev_warn(&fn->dev,
-			 "Failed to create debugfs directory %s for sensor %d\n",
-			 dirname, sensor->sensor_index);
-		return;
-	}
-
-	if (!debugfs_create_bool("type_a", RMI_RW_ATTR, sensor_root,
-				 &sensor->type_a))
-		dev_warn(&fn->dev,
-			 "Failed to create debugfs type_a for sensor %d.\n",
-			 sensor->sensor_index);
-
-	if (!debugfs_create_u16("max_x", RMI_RW_ATTR, sensor_root,
-				&sensor->max_x))
-		dev_warn(&fn->dev,
-			 "Failed to create debugfs max_x for sensor %d.\n",
-			 sensor->sensor_index);
-
-	if (!debugfs_create_u16("max_xy", RMI_RW_ATTR, sensor_root,
-				&sensor->max_y))
-		dev_warn(&fn->dev,
-			 "Failed to create debugfs max_y for sensor %d.\n",
-			 sensor->sensor_index);
-
-	if (!debugfs_create_bool("flip_x", RMI_RW_ATTR, sensor_root,
-				 &sensor->axis_align.flip_x))
-		dev_warn(&fn->dev,
-			 "Failed to create debugfs flip_x for sensor %d.\n",
-			 sensor->sensor_index);
-
-	if (!debugfs_create_bool("flip_y", RMI_RW_ATTR, sensor_root,
-				 &sensor->axis_align.flip_y))
-		dev_warn(&fn->dev,
-			 "Failed to create debugfs flip_y for sensor %d.\n",
-			 sensor->sensor_index);
-
-	if (!debugfs_create_u16("clip_x_low", RMI_RW_ATTR, sensor_root,
-				&sensor->axis_align.clip_x_low))
-		dev_warn(&fn->dev,
-			 "Failed to create debugfs clip_x_low for sensor %d.\n",
-			 sensor->sensor_index);
-
-	if (!debugfs_create_u16("clip_x_high", RMI_RW_ATTR, sensor_root,
-				&sensor->axis_align.clip_x_high))
-		dev_warn(&fn->dev,
-			 "Failed to create debugfs clip_x_high for sensor %d.\n",
-			 sensor->sensor_index);
-
-	if (!debugfs_create_u16("clip_y_low", RMI_RW_ATTR, sensor_root,
-				 &sensor->axis_align.clip_y_low))
-		dev_warn(&fn->dev,
-			 "Failed to create debugfs clip_y_low for sensor %d.\n",
-			 sensor->sensor_index);
-
-	if (!debugfs_create_u16("clip_y_high", RMI_RW_ATTR, sensor_root,
-				 &sensor->axis_align.clip_y_high))
-		dev_warn(&fn->dev,
-			 "Failed to create debugfs clip_y_high for sensor %d.\n",
-			 sensor->sensor_index);
-
-	if (!debugfs_create_u8("delta_x_threshold", RMI_RW_ATTR, sensor_root,
-				&sensor->axis_align.delta_x_threshold))
-		dev_warn(&fn->dev,
-			 "Failed to create debugfs delta_x_threshold for sensor %d.\n",
-			 sensor->sensor_index);
-
-	if (!debugfs_create_u8("delta_y_threshold", RMI_RW_ATTR, sensor_root,
-				&sensor->axis_align.delta_y_threshold))
-		dev_warn(&fn->dev,
-			 "Failed to create debugfs delta_y_threshold for sensor %d.\n",
-			 sensor->sensor_index);
-
-	if (!debugfs_create_u16("offset_x", RMI_RW_ATTR, sensor_root,
-				 &sensor->axis_align.offset_x))
-		dev_warn(&fn->dev,
-			 "Failed to create debugfs offset_x for sensor %d.\n",
-			 sensor->sensor_index);
-
-	if (!debugfs_create_u16("offset_x", RMI_RW_ATTR, sensor_root,
-				 &sensor->axis_align.offset_x))
-		dev_warn(&fn->dev,
-			 "Failed to create debugfs offset_y for sensor %d.\n",
-			 sensor->sensor_index);
-
-	if (!debugfs_create_bool("swap", RMI_RW_ATTR, sensor_root,
-				 &sensor->axis_align.swap_axes))
-		dev_warn(&fn->dev,
-			 "Failed to create debugfs swap for sensor %d.\n",
-			 sensor->sensor_index);
-}
-
-static void rmi_f11_setup_debugfs(struct rmi_function *fn)
-{
-	struct f11_data *f11 = fn->data;
-
-	if (fn->debugfs_root)
-		if (!debugfs_create_u16("rezero_wait", RMI_RW_ATTR,
-					fn->debugfs_root,
-					&f11->rezero_wait_ms))
-			dev_warn(&fn->dev,
-				 "Failed to create debugfs rezero_wait.\n");
-}
-#else
-static inline void rmi_f11_setup_sensor_debugfs(struct f11_2d_sensor *sensor)
-{
-}
-static inline void rmi_f11_setup_debugfs(struct rmi_function *fn)
-{
-}
-#endif
-/* End adding debugfs */
-
 /** F11_INACCURATE state is overloaded to indicate pen present. */
 #define F11_PEN F11_INACCURATE
 
@@ -1886,12 +1714,8 @@  static int rmi_f11_initialize(struct rmi_function *fn)
 				dev_warn(&fn->dev, "Failed to write to delta_y_threshold %d. Code: %d.\n",
 					i, rc);
 		}
-
-		rmi_f11_setup_sensor_debugfs(sensor);
 	}
 
-	rmi_f11_setup_debugfs(fn);
-
 	mutex_init(&f11->dev_controls_mutex);
 	return 0;
 }
@@ -2112,18 +1936,11 @@  static int rmi_f11_probe(struct rmi_function *fn)
 	if (error)
 		return error;
 
-	error = sysfs_create_group(&fn->dev.kobj, &rmi_f11_attr_group);
-	if (error)
-		return error;
-
 	return 0;
 }
 
 static void rmi_f11_remove(struct rmi_function *fn)
 {
-	debugfs_remove_recursive(fn->debugfs_root);
-	sysfs_remove_group(&fn->dev.kobj, &rmi_f11_attr_group);
-
 	rmi_f11_free_devices(fn);
 }
 
diff --git a/drivers/input/rmi4/rmi_i2c.c b/drivers/input/rmi4/rmi_i2c.c
index f3bef04..62351c4 100644
--- a/drivers/input/rmi4/rmi_i2c.c
+++ b/drivers/input/rmi4/rmi_i2c.c
@@ -8,7 +8,6 @@ 
  */
 
 #include <linux/kernel.h>
-#include <linux/debugfs.h>
 #include <linux/delay.h>
 #include <linux/i2c.h>
 #include <linux/interrupt.h>
@@ -61,8 +60,9 @@  static int setup_debugfs(struct rmi_device *rmi_dev, struct rmi_i2c_data *data)
 	if (!rmi_dev->debugfs_root)
 		return -ENODEV;
 
-	data->debugfs_comms = debugfs_create_bool("comms_debug", RMI_RW_ATTR,
-			rmi_dev->debugfs_root, &data->comms_debug);
+	data->debugfs_comms = debugfs_create_bool("comms_debug",
+			(S_IRUGO | S_IWUGO), rmi_dev->debugfs_root,
+			&data->comms_debug);
 	if (!data->debugfs_comms || IS_ERR(data->debugfs_comms)) {
 		dev_warn(&rmi_dev->dev,
 			 "Failed to create debugfs comms_debug.\n");