drivers/input/touchscreen/rmi4/rmi_dev.c - kernel/tegra - Git at Google

 /*
  * Copyright (c) 2011 Synaptics Incorporated
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */

 #include <linux/fs.h>
 #include <linux/delay.h>
 #include <linux/uaccess.h>
 #include <linux/slab.h>
 #include <linux/input.h>
 #include <linux/interrupt.h>
 #include <linux/syscalls.h>

 #include <linux/rmi.h>
 #include "rmi_driver.h"

 #define CHAR_DEVICE_NAME "rmi"

 #define REG_ADDR_LIMIT 0xFFFF

 /*store dynamically allocated major number of char device*/
 static int rmi_char_dev_major_num;


 /* file operations for RMI char device */

 /*
  * rmi_char_dev_llseek: - use to setup register address
  *
  * @filp: file structure for seek
  * @off: offset
  *       if whence == SEEK_SET,
  *       high 16 bits: page address
  *       low 16 bits: register address
  *
  *       if whence == SEEK_CUR,
  *       offset from current position
  *
  *       if whence == SEEK_END,
  *       offset from END(0xFFFF)
  *
  * @whence: SEEK_SET , SEEK_CUR or SEEK_END
  */
 static loff_t rmi_char_dev_llseek(struct file *filp, loff_t off, int whence)
 {
 	loff_t newpos;
 	struct rmi_char_dev *my_char_dev = filp->private_data;

 	if (IS_ERR(my_char_dev)) {
 		pr_err("%s: pointer of char device is invalid", __func__);
 		return -EBADF;
 	}

 	mutex_lock(&(my_char_dev->mutex_file_op));

 	switch (whence) {
 	case SEEK_SET:
 		newpos = off;
 		break;

 	case SEEK_CUR:
 		newpos = filp->f_pos + off;
 		break;

 	case SEEK_END:
 		newpos = REG_ADDR_LIMIT + off;
 		break;

 	default:		/* can't happen */
 		newpos = -EINVAL;
 		goto clean_up;
 	}

 	if (newpos < 0 || newpos > REG_ADDR_LIMIT) {
 		dev_err(my_char_dev->phys->dev, "newpos 0x%04x is invalid.\n",
 			(unsigned int)newpos);
 		newpos = -EINVAL;
 		goto clean_up;
 	}

 	filp->f_pos = newpos;

 clean_up:
 	mutex_unlock(&(my_char_dev->mutex_file_op));
 	return newpos;
 }

 /*
  *  rmi_char_dev_read: - use to read data from RMI stream
  *
  *  @filp: file structure for read
  *  @buf: user-level buffer pointer
  *
  *  @count: number of byte read
  *  @f_pos: offset (starting register address)
  *
  *	@return number of bytes read into user buffer (buf) if succeeds
  *          negative number if error occurs.
  */
 static ssize_t rmi_char_dev_read(struct file *filp, char __user *buf,
 		size_t count, loff_t *f_pos)
 {
 	struct rmi_char_dev *my_char_dev = filp->private_data;
 	ssize_t ret_value  = 0;
 	unsigned char tmpbuf[count+1];
 	struct rmi_phys_device *phys;

 	/* limit offset to REG_ADDR_LIMIT-1 */
 	if (count > (REG_ADDR_LIMIT - *f_pos))
 		count = REG_ADDR_LIMIT - *f_pos;

 	if (count == 0)
 		return 0;

 	if (IS_ERR(my_char_dev)) {
 		pr_err("%s: pointer of char device is invalid", __func__);
 		ret_value = -EBADF;
 		return ret_value;
 	}

 	mutex_lock(&(my_char_dev->mutex_file_op));

 	phys = my_char_dev->phys;
 	/*
 	 * just let it go through , because we do not know the register is FIFO
 	 * register or not
 	 */

 	ret_value = phys->read_block(phys, *f_pos, tmpbuf, count);

 	if (ret_value < 0)
 		goto clean_up;
 	else
 		*f_pos += ret_value;

 	if (copy_to_user(buf, tmpbuf, count))
 		ret_value = -EFAULT;

 clean_up:

 	mutex_unlock(&(my_char_dev->mutex_file_op));

 	return ret_value;
 }

 /*
  * rmi_char_dev_write: - use to write data into RMI stream
  *
  * @filep : file structure for write
  * @buf: user-level buffer pointer contains data to be written
  * @count: number of byte be be written
  * @f_pos: offset (starting register address)
  *
  * @return number of bytes written from user buffer (buf) if succeeds
  *         negative number if error occurs.
  */
 static ssize_t rmi_char_dev_write(struct file *filp, const char __user *buf,
 		size_t count, loff_t *f_pos)
 {
 	struct rmi_char_dev *my_char_dev = filp->private_data;
 	ssize_t ret_value  = 0;
 	unsigned char tmpbuf[count+1];
 	struct rmi_phys_device *phys;

 	/* limit offset to REG_ADDR_LIMIT-1 */
 	if (count > (REG_ADDR_LIMIT - *f_pos))
 		count = REG_ADDR_LIMIT - *f_pos;

 	if (count == 0)
 		return 0;

 	if (IS_ERR(my_char_dev)) {
 		pr_err("%s: pointer of char device is invalid", __func__);
 		ret_value = -EBADF;
 		return ret_value;
 	}

 	if (copy_from_user(tmpbuf, buf, count)) {
 		ret_value = -EFAULT;
 		return ret_value;
 	}

 	mutex_lock(&(my_char_dev->mutex_file_op));

 	phys = my_char_dev->phys;
 	/*
 	 * just let it go through , because we do not know the register is FIFO
 	 * register or not
 	 */

 	ret_value = phys->write_block(phys, *f_pos, tmpbuf, count);

 	if (ret_value >= 0)
 		*f_pos += count;

 	mutex_unlock(&(my_char_dev->mutex_file_op));

 	return ret_value;
 }

 /*
  * rmi_char_dev_open: - get a new handle for from RMI stream
  * @inp : inode struture
  * @filp: file structure for read/write
  *
  * @return 0 if succeeds
  */
 static int rmi_char_dev_open(struct inode *inp, struct file *filp)
 {
 	/* store the device pointer to file structure */
 	struct rmi_char_dev *my_dev = container_of(inp->i_cdev,
 			struct rmi_char_dev, main_dev);
 	struct rmi_phys_device *phys = my_dev->phys;
 	int ret_value = 0;

 	filp->private_data = my_dev;

 	if (!phys)
 		return -EACCES;

 	mutex_lock(&(my_dev->mutex_file_op));
 	if (my_dev->ref_count < 1)
 		my_dev->ref_count++;
 	else
 		ret_value = -EACCES;

 	mutex_unlock(&(my_dev->mutex_file_op));

 	return ret_value;
 }

 /*
  *  rmi_char_dev_release: - release an existing handle
  *  @inp: inode structure
  *  @filp: file structure for read/write
  *
  *  @return 0 if succeeds
  */
 static int rmi_char_dev_release(struct inode *inp, struct file *filp)
 {
 	struct rmi_char_dev *my_dev = container_of(inp->i_cdev,
 			struct rmi_char_dev, main_dev);
 	struct rmi_phys_device *phys = my_dev->phys;

 	if (!phys)
 		return -EACCES;

 	mutex_lock(&(my_dev->mutex_file_op));

 	my_dev->ref_count--;
 	if (my_dev->ref_count < 0)
 		my_dev->ref_count = 0;

 	mutex_unlock(&(my_dev->mutex_file_op));

 	return 0;
 }

 static const struct file_operations rmi_char_dev_fops = {
 	.owner =    THIS_MODULE,
 	.llseek =   rmi_char_dev_llseek,
 	.read =     rmi_char_dev_read,
 	.write =    rmi_char_dev_write,
 	.open =     rmi_char_dev_open,
 	.release =  rmi_char_dev_release,
 };

 /*
  * rmi_char_dev_clean_up - release memory or unregister driver
  * @rmi_char_dev: rmi_char_dev structure
  *
  */
 static void rmi_char_dev_clean_up(struct rmi_char_dev *char_dev,
 			struct class *char_device_class)
 {
 	dev_t devno;

 	/* Get rid of our char dev entries */
 	if (char_dev) {
 		devno = char_dev->main_dev.dev;

 		cdev_del(&char_dev->main_dev);
 		kfree(char_dev);

 		if (char_device_class) {
 			device_destroy(char_device_class, devno);
 			class_unregister(char_device_class);
 			class_destroy(char_device_class);
 		}

 		/* cleanup_module is never called if registering failed */
 		unregister_chrdev_region(devno, 1);
 		pr_debug("%s: rmi_char_dev is removed\n", __func__);
 	}
 }

 /*
  * rmi_char_devnode - return device permission
  *
  * @dev: char device structure
  * @mode: file permission
  *
  */
 static char *rmi_char_devnode(struct device *dev, mode_t *mode)
 {
 	if (!mode)
 		return NULL;
 	/* rmi** */
 	/**mode = 0666*/
 	*mode = (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH);

 	return kasprintf(GFP_KERNEL, "rmi/%s", dev_name(dev));
 }

 /*
  * rmi_char_dev_register - register char device (called from up-level)
  *
  * @phy: a pointer to an rmi_phys_devices structure
  *
  * @return: zero if suceeds
  */
 int rmi_char_dev_register(struct rmi_phys_device *phys)
 {
 	struct rmi_char_dev *char_dev;
 	dev_t dev_no;
 	int err;
 	int result;
 	struct device *device_ptr;

 	if (rmi_char_dev_major_num) {
 		dev_no = MKDEV(rmi_char_dev_major_num, 0);
 		result = register_chrdev_region(dev_no, 1, CHAR_DEVICE_NAME);
 	} else {
 		result = alloc_chrdev_region(&dev_no, 0, 1, CHAR_DEVICE_NAME);
 		/* let kernel allocate a major for us */
 		rmi_char_dev_major_num = MAJOR(dev_no);
 		dev_info(phys->dev, "Major number of rmi_char_dev: %d\n",
 				 rmi_char_dev_major_num);
 	}
 	if (result < 0)
 		return result;

 	char_dev = kzalloc(sizeof(struct rmi_char_dev), GFP_KERNEL);
 	if (!char_dev) {
 		dev_err(phys->dev, "Failed to allocate rmi_char_dev.\n");
 		/* unregister the char device region */
 		__unregister_chrdev(rmi_char_dev_major_num, MINOR(dev_no), 1,
 				CHAR_DEVICE_NAME);
 		return -ENOMEM;
 	}

 	mutex_init(&char_dev->mutex_file_op);

 	phys->char_dev = char_dev;
 	char_dev->phys = phys;

 	cdev_init(&char_dev->main_dev, &rmi_char_dev_fops);

 	err = cdev_add(&char_dev->main_dev, dev_no, 1);
 	if (err) {
 		dev_err(phys->dev, "Error %d adding rmi_char_dev.\n", err);
 		rmi_char_dev_clean_up(phys->char_dev,
 				 phys->rmi_char_device_class);
 		return err;
 	}

 	/* create device node */
 	phys->rmi_char_device_class =
 		class_create(THIS_MODULE, CHAR_DEVICE_NAME);

 	if (IS_ERR(phys->rmi_char_device_class)) {
 		dev_err(phys->dev, "Failed to create /dev/%s.\n",
 			CHAR_DEVICE_NAME);
 		rmi_char_dev_clean_up(phys->char_dev,
 				 phys->rmi_char_device_class);
 		return -ENODEV;
 	}
 	/* setup permission */
 	phys->rmi_char_device_class->devnode = rmi_char_devnode;

 	/* class creation */
 	device_ptr = device_create(
 			phys->rmi_char_device_class,
 			NULL, dev_no, NULL,
 			CHAR_DEVICE_NAME"%d",
 			MINOR(dev_no));

 	if (IS_ERR(device_ptr)) {
 		dev_err(phys->dev, "Failed to create rmi device.\n");
 		rmi_char_dev_clean_up(phys->char_dev,
 				 phys->rmi_char_device_class);
 		return -ENODEV;
 	}

 	return 0;
 }
 EXPORT_SYMBOL(rmi_char_dev_register);

 /* rmi_char_dev_unregister - unregister char device (called from up-level)
  *
  * @phys: pointer to an rmi_phys_device structure
  */

 void rmi_char_dev_unregister(struct rmi_phys_device *phys)
 {
 	/* clean up */
 	if (phys)
 		rmi_char_dev_clean_up(phys->char_dev,
 				 phys->rmi_char_device_class);
 }
 EXPORT_SYMBOL(rmi_char_dev_unregister);

 MODULE_AUTHOR("Synaptics, Inc.");
 MODULE_DESCRIPTION("RMI4 Char Device");
 MODULE_LICENSE("GPL");
	/*
	* Copyright (c) 2011 Synaptics Incorporated
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 2 of the License, or
	* (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, write to the Free Software
	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	*/

	#include <linux/fs.h>
	#include <linux/delay.h>
	#include <linux/uaccess.h>
	#include <linux/slab.h>
	#include <linux/input.h>
	#include <linux/interrupt.h>
	#include <linux/syscalls.h>

	#include <linux/rmi.h>
	#include "rmi_driver.h"

	#define CHAR_DEVICE_NAME "rmi"

	#define REG_ADDR_LIMIT 0xFFFF

	/store dynamically allocated major number of char device/
	static int rmi_char_dev_major_num;


	/* file operations for RMI char device */

	/*
	* rmi_char_dev_llseek: - use to setup register address
	*
	* @filp: file structure for seek
	* @off: offset
	* if whence == SEEK_SET,
	* high 16 bits: page address
	* low 16 bits: register address
	*
	* if whence == SEEK_CUR,
	* offset from current position
	*
	* if whence == SEEK_END,
	* offset from END(0xFFFF)
	*
	* @whence: SEEK_SET , SEEK_CUR or SEEK_END
	*/
	static loff_t rmi_char_dev_llseek(struct file *filp, loff_t off, int whence)
	{
	loff_t newpos;
	struct rmi_char_dev *my_char_dev = filp->private_data;

	if (IS_ERR(my_char_dev)) {
	pr_err("%s: pointer of char device is invalid", __func__);
	return -EBADF;
	}

	mutex_lock(&(my_char_dev->mutex_file_op));

	switch (whence) {
	case SEEK_SET:
	newpos = off;
	break;

	case SEEK_CUR:
	newpos = filp->f_pos + off;
	break;

	case SEEK_END:
	newpos = REG_ADDR_LIMIT + off;
	break;

	default: /* can't happen */
	newpos = -EINVAL;
	goto clean_up;
	}

	if (newpos < 0 \|\| newpos > REG_ADDR_LIMIT) {
	dev_err(my_char_dev->phys->dev, "newpos 0x%04x is invalid.\n",
	(unsigned int)newpos);
	newpos = -EINVAL;
	goto clean_up;
	}

	filp->f_pos = newpos;

	clean_up:
	mutex_unlock(&(my_char_dev->mutex_file_op));
	return newpos;
	}

	/*
	* rmi_char_dev_read: - use to read data from RMI stream
	*
	* @filp: file structure for read
	* @buf: user-level buffer pointer
	*
	* @count: number of byte read
	* @f_pos: offset (starting register address)
	*
	* @return number of bytes read into user buffer (buf) if succeeds
	* negative number if error occurs.
	*/
	static ssize_t rmi_char_dev_read(struct file filp, char __user buf,
	size_t count, loff_t *f_pos)
	{
	struct rmi_char_dev *my_char_dev = filp->private_data;
	ssize_t ret_value = 0;
	unsigned char tmpbuf[count+1];
	struct rmi_phys_device *phys;

	/* limit offset to REG_ADDR_LIMIT-1 */
	if (count > (REG_ADDR_LIMIT - *f_pos))
	count = REG_ADDR_LIMIT - *f_pos;

	if (count == 0)
	return 0;

	if (IS_ERR(my_char_dev)) {
	pr_err("%s: pointer of char device is invalid", __func__);
	ret_value = -EBADF;
	return ret_value;
	}

	mutex_lock(&(my_char_dev->mutex_file_op));

	phys = my_char_dev->phys;
	/*
	* just let it go through , because we do not know the register is FIFO
	* register or not
	*/

	ret_value = phys->read_block(phys, *f_pos, tmpbuf, count);

	if (ret_value < 0)
	goto clean_up;
	else
	*f_pos += ret_value;

	if (copy_to_user(buf, tmpbuf, count))
	ret_value = -EFAULT;

	clean_up:

	mutex_unlock(&(my_char_dev->mutex_file_op));

	return ret_value;
	}

	/*
	* rmi_char_dev_write: - use to write data into RMI stream
	*
	* @filep : file structure for write
	* @buf: user-level buffer pointer contains data to be written
	* @count: number of byte be be written
	* @f_pos: offset (starting register address)
	*
	* @return number of bytes written from user buffer (buf) if succeeds
	* negative number if error occurs.
	*/
	static ssize_t rmi_char_dev_write(struct file filp, const char __user buf,
	size_t count, loff_t *f_pos)
	{
	struct rmi_char_dev *my_char_dev = filp->private_data;
	ssize_t ret_value = 0;
	unsigned char tmpbuf[count+1];
	struct rmi_phys_device *phys;

	/* limit offset to REG_ADDR_LIMIT-1 */
	if (count > (REG_ADDR_LIMIT - *f_pos))
	count = REG_ADDR_LIMIT - *f_pos;

	if (count == 0)
	return 0;

	if (IS_ERR(my_char_dev)) {
	pr_err("%s: pointer of char device is invalid", __func__);
	ret_value = -EBADF;
	return ret_value;
	}

	if (copy_from_user(tmpbuf, buf, count)) {
	ret_value = -EFAULT;
	return ret_value;
	}

	mutex_lock(&(my_char_dev->mutex_file_op));

	phys = my_char_dev->phys;
	/*
	* just let it go through , because we do not know the register is FIFO
	* register or not
	*/

	ret_value = phys->write_block(phys, *f_pos, tmpbuf, count);

	if (ret_value >= 0)
	*f_pos += count;

	mutex_unlock(&(my_char_dev->mutex_file_op));

	return ret_value;
	}

	/*
	* rmi_char_dev_open: - get a new handle for from RMI stream
	* @inp : inode struture
	* @filp: file structure for read/write
	*
	* @return 0 if succeeds
	*/
	static int rmi_char_dev_open(struct inode inp, struct file filp)
	{
	/* store the device pointer to file structure */
	struct rmi_char_dev *my_dev = container_of(inp->i_cdev,
	struct rmi_char_dev, main_dev);
	struct rmi_phys_device *phys = my_dev->phys;
	int ret_value = 0;

	filp->private_data = my_dev;

	if (!phys)
	return -EACCES;

	mutex_lock(&(my_dev->mutex_file_op));
	if (my_dev->ref_count < 1)
	my_dev->ref_count++;
	else
	ret_value = -EACCES;

	mutex_unlock(&(my_dev->mutex_file_op));

	return ret_value;
	}

	/*
	* rmi_char_dev_release: - release an existing handle
	* @inp: inode structure
	* @filp: file structure for read/write
	*
	* @return 0 if succeeds
	*/
	static int rmi_char_dev_release(struct inode inp, struct file filp)
	{
	struct rmi_char_dev *my_dev = container_of(inp->i_cdev,
	struct rmi_char_dev, main_dev);
	struct rmi_phys_device *phys = my_dev->phys;

	if (!phys)
	return -EACCES;

	mutex_lock(&(my_dev->mutex_file_op));

	my_dev->ref_count--;
	if (my_dev->ref_count < 0)
	my_dev->ref_count = 0;

	mutex_unlock(&(my_dev->mutex_file_op));

	return 0;
	}

	static const struct file_operations rmi_char_dev_fops = {
	.owner = THIS_MODULE,
	.llseek = rmi_char_dev_llseek,
	.read = rmi_char_dev_read,
	.write = rmi_char_dev_write,
	.open = rmi_char_dev_open,
	.release = rmi_char_dev_release,
	};

	/*
	* rmi_char_dev_clean_up - release memory or unregister driver
	* @rmi_char_dev: rmi_char_dev structure
	*
	*/
	static void rmi_char_dev_clean_up(struct rmi_char_dev *char_dev,
	struct class *char_device_class)
	{
	dev_t devno;

	/* Get rid of our char dev entries */
	if (char_dev) {
	devno = char_dev->main_dev.dev;

	cdev_del(&char_dev->main_dev);
	kfree(char_dev);

	if (char_device_class) {
	device_destroy(char_device_class, devno);
	class_unregister(char_device_class);
	class_destroy(char_device_class);
	}

	/* cleanup_module is never called if registering failed */
	unregister_chrdev_region(devno, 1);
	pr_debug("%s: rmi_char_dev is removed\n", __func__);
	}
	}

	/*
	* rmi_char_devnode - return device permission
	*
	* @dev: char device structure
	* @mode: file permission
	*
	*/
	static char rmi_char_devnode(struct device dev, mode_t *mode)
	{
	if (!mode)
	return NULL;
	/* rmi** */
	/*mode = 0666/
	*mode = (S_IRUSR\|S_IWUSR\|S_IRGRP\|S_IWGRP\|S_IROTH\|S_IWOTH);

	return kasprintf(GFP_KERNEL, "rmi/%s", dev_name(dev));
	}

	/*
	* rmi_char_dev_register - register char device (called from up-level)
	*
	* @phy: a pointer to an rmi_phys_devices structure
	*
	* @return: zero if suceeds
	*/
	int rmi_char_dev_register(struct rmi_phys_device *phys)
	{
	struct rmi_char_dev *char_dev;
	dev_t dev_no;
	int err;
	int result;
	struct device *device_ptr;

	if (rmi_char_dev_major_num) {
	dev_no = MKDEV(rmi_char_dev_major_num, 0);
	result = register_chrdev_region(dev_no, 1, CHAR_DEVICE_NAME);
	} else {
	result = alloc_chrdev_region(&dev_no, 0, 1, CHAR_DEVICE_NAME);
	/* let kernel allocate a major for us */
	rmi_char_dev_major_num = MAJOR(dev_no);
	dev_info(phys->dev, "Major number of rmi_char_dev: %d\n",
	rmi_char_dev_major_num);
	}
	if (result < 0)
	return result;

	char_dev = kzalloc(sizeof(struct rmi_char_dev), GFP_KERNEL);
	if (!char_dev) {
	dev_err(phys->dev, "Failed to allocate rmi_char_dev.\n");
	/* unregister the char device region */
	__unregister_chrdev(rmi_char_dev_major_num, MINOR(dev_no), 1,
	CHAR_DEVICE_NAME);
	return -ENOMEM;
	}

	mutex_init(&char_dev->mutex_file_op);

	phys->char_dev = char_dev;
	char_dev->phys = phys;

	cdev_init(&char_dev->main_dev, &rmi_char_dev_fops);

	err = cdev_add(&char_dev->main_dev, dev_no, 1);
	if (err) {
	dev_err(phys->dev, "Error %d adding rmi_char_dev.\n", err);
	rmi_char_dev_clean_up(phys->char_dev,
	phys->rmi_char_device_class);
	return err;
	}

	/* create device node */
	phys->rmi_char_device_class =
	class_create(THIS_MODULE, CHAR_DEVICE_NAME);

	if (IS_ERR(phys->rmi_char_device_class)) {
	dev_err(phys->dev, "Failed to create /dev/%s.\n",
	CHAR_DEVICE_NAME);
	rmi_char_dev_clean_up(phys->char_dev,
	phys->rmi_char_device_class);
	return -ENODEV;
	}
	/* setup permission */
	phys->rmi_char_device_class->devnode = rmi_char_devnode;

	/* class creation */
	device_ptr = device_create(
	phys->rmi_char_device_class,
	NULL, dev_no, NULL,
	CHAR_DEVICE_NAME"%d",
	MINOR(dev_no));

	if (IS_ERR(device_ptr)) {
	dev_err(phys->dev, "Failed to create rmi device.\n");
	rmi_char_dev_clean_up(phys->char_dev,
	phys->rmi_char_device_class);
	return -ENODEV;
	}

	return 0;
	}
	EXPORT_SYMBOL(rmi_char_dev_register);

	/* rmi_char_dev_unregister - unregister char device (called from up-level)
	*
	* @phys: pointer to an rmi_phys_device structure
	*/

	void rmi_char_dev_unregister(struct rmi_phys_device *phys)
	{
	/* clean up */
	if (phys)
	rmi_char_dev_clean_up(phys->char_dev,
	phys->rmi_char_device_class);
	}
	EXPORT_SYMBOL(rmi_char_dev_unregister);

	MODULE_AUTHOR("Synaptics, Inc.");
	MODULE_DESCRIPTION("RMI4 Char Device");
	MODULE_LICENSE("GPL");