Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 2b6a321d authored by Andrew Duggan's avatar Andrew Duggan Committed by Dmitry Torokhov
Browse files

Input: synaptics-rmi4 - add support for Synaptics RMI4 devices 



Synaptics uses the Register Mapped Interface (RMI) protocol as a
communications interface for their devices. This driver adds the core
functionality needed to interface with RMI4 devices.

RMI devices can be connected to the host via several transport protocols
and can supports a wide variety of functionality defined by RMI functions.
Support for transport protocols and RMI functions are implemented in
individual drivers. The RMI4 core driver uses a bus architecture to
facilitate the various combinations of transport and function drivers
needed by a particular device.

Signed-off-by: default avatarAndrew Duggan <aduggan@synaptics.com>
Signed-off-by: default avatarChristopher Heiny <cheiny@synaptics.com>
Tested-by: default avatarBenjamin Tissoires <benjamin.tissoires@redhat.com>
Tested-by: default avatarLinus Walleij <linus.walleij@linaro.org>
Tested-by: default avatarBjorn Andersson <bjorn.andersson@linaro.org>
Signed-off-by: default avatarDmitry Torokhov <dmitry.torokhov@gmail.com>
parent afd2ff9b

drivers/input/Kconfig

+2 −0
Original line number Diff line number Diff line
@@ -201,6 +201,8 @@ source "drivers/input/touchscreen/Kconfig" 


source "drivers/input/misc/Kconfig"



source "drivers/input/rmi4/Kconfig"



endif



menu "Hardware I/O ports"

drivers/input/Makefile

+2 −0
Original line number Diff line number Diff line
@@ -26,3 +26,5 @@ obj-$(CONFIG_INPUT_TOUCHSCREEN) += touchscreen/ 
obj-$(CONFIG_INPUT_MISC)	+= misc/



obj-$(CONFIG_INPUT_APMPOWER)	+= apm-power.o



obj-$(CONFIG_RMI4_CORE)		+= rmi4/

drivers/input/rmi4/Kconfig

0 → 100644
+10 −0
Original line number Diff line number Diff line 
#

# RMI4 configuration

#

config RMI4_CORE

	tristate "Synaptics RMI4 bus support"

	help

	  Say Y here if you want to support the Synaptics RMI4 bus.  This is

	  required for all RMI4 device support.



	  If unsure, say Y.

drivers/input/rmi4/Makefile

0 → 100644
+2 −0
Original line number Diff line number Diff line 
obj-$(CONFIG_RMI4_CORE) += rmi_core.o

rmi_core-y := rmi_bus.o rmi_driver.o rmi_f01.o

drivers/input/rmi4/rmi_bus.c

0 → 100644
+375 −0
Original line number Diff line number Diff line 
/*

 * Copyright (c) 2011-2016 Synaptics Incorporated

 * Copyright (c) 2011 Unixphere

 *

 * 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

 * the Free Software Foundation.

 */



#include <linux/kernel.h>

#include <linux/device.h>

#include <linux/kconfig.h>

#include <linux/list.h>

#include <linux/pm.h>

#include <linux/rmi.h>

#include <linux/slab.h>

#include <linux/types.h>

#include <linux/of.h>

#include "rmi_bus.h"

#include "rmi_driver.h"



static int debug_flags;

module_param(debug_flags, int, 0644);

MODULE_PARM_DESC(debug_flags, "control debugging information");



void rmi_dbg(int flags, struct device *dev, const char *fmt, ...)

{

	struct va_format vaf;

	va_list args;



	if (flags & debug_flags) {

		va_start(args, fmt);



		vaf.fmt = fmt;

		vaf.va = &args;



		dev_printk(KERN_DEBUG, dev, "%pV", &vaf);



		va_end(args);

	}

}

EXPORT_SYMBOL_GPL(rmi_dbg);



/*

 * RMI Physical devices

 *

 * Physical RMI device consists of several functions serving particular

 * purpose. For example F11 is a 2D touch sensor while F01 is a generic

 * function present in every RMI device.

 */



static void rmi_release_device(struct device *dev)

{

	struct rmi_device *rmi_dev = to_rmi_device(dev);



	kfree(rmi_dev);

}



static struct device_type rmi_device_type = {

	.name		= "rmi4_sensor",

	.release	= rmi_release_device,

};



bool rmi_is_physical_device(struct device *dev)

{

	return dev->type == &rmi_device_type;

}



/**

 * rmi_register_transport_device - register a transport device connection

 * on the RMI bus.  Transport drivers provide communication from the devices

 * on a bus (such as SPI, I2C, and so on) to the RMI4 sensor.

 *

 * @xport: the transport device to register

 */

int rmi_register_transport_device(struct rmi_transport_dev *xport)

{

	static atomic_t transport_device_count = ATOMIC_INIT(0);

	struct rmi_device *rmi_dev;

	int error;



	rmi_dev = kzalloc(sizeof(struct rmi_device), GFP_KERNEL);

	if (!rmi_dev)

		return -ENOMEM;



	device_initialize(&rmi_dev->dev);



	rmi_dev->xport = xport;

	rmi_dev->number = atomic_inc_return(&transport_device_count) - 1;



	dev_set_name(&rmi_dev->dev, "rmi4-%02d", rmi_dev->number);



	rmi_dev->dev.bus = &rmi_bus_type;

	rmi_dev->dev.type = &rmi_device_type;



	xport->rmi_dev = rmi_dev;



	error = device_add(&rmi_dev->dev);

	if (error)

		goto err_put_device;



	rmi_dbg(RMI_DEBUG_CORE, xport->dev,

		"%s: Registered %s as %s.\n", __func__,

		dev_name(rmi_dev->xport->dev), dev_name(&rmi_dev->dev));



	return 0;



err_put_device:

	put_device(&rmi_dev->dev);

	return error;

}

EXPORT_SYMBOL_GPL(rmi_register_transport_device);



/**

 * rmi_unregister_transport_device - unregister a transport device connection

 * @xport: the transport driver to unregister

 *

 */

void rmi_unregister_transport_device(struct rmi_transport_dev *xport)

{

	struct rmi_device *rmi_dev = xport->rmi_dev;



	device_del(&rmi_dev->dev);

	put_device(&rmi_dev->dev);

}

EXPORT_SYMBOL(rmi_unregister_transport_device);





/* Function specific stuff */



static void rmi_release_function(struct device *dev)

{

	struct rmi_function *fn = to_rmi_function(dev);



	kfree(fn);

}



static struct device_type rmi_function_type = {

	.name		= "rmi4_function",

	.release	= rmi_release_function,

};



bool rmi_is_function_device(struct device *dev)

{

	return dev->type == &rmi_function_type;

}



static int rmi_function_match(struct device *dev, struct device_driver *drv)

{

	struct rmi_function_handler *handler = to_rmi_function_handler(drv);

	struct rmi_function *fn = to_rmi_function(dev);



	return fn->fd.function_number == handler->func;

}



static int rmi_function_probe(struct device *dev)

{

	struct rmi_function *fn = to_rmi_function(dev);

	struct rmi_function_handler *handler =

					to_rmi_function_handler(dev->driver);

	int error;



	if (handler->probe) {

		error = handler->probe(fn);

		return error;

	}



	return 0;

}



static int rmi_function_remove(struct device *dev)

{

	struct rmi_function *fn = to_rmi_function(dev);

	struct rmi_function_handler *handler =

					to_rmi_function_handler(dev->driver);



	if (handler->remove)

		handler->remove(fn);



	return 0;

}



int rmi_register_function(struct rmi_function *fn)

{

	struct rmi_device *rmi_dev = fn->rmi_dev;

	int error;



	device_initialize(&fn->dev);



	dev_set_name(&fn->dev, "%s.fn%02x",

		     dev_name(&rmi_dev->dev), fn->fd.function_number);



	fn->dev.parent = &rmi_dev->dev;

	fn->dev.type = &rmi_function_type;

	fn->dev.bus = &rmi_bus_type;



	error = device_add(&fn->dev);

	if (error) {

		dev_err(&rmi_dev->dev,

			"Failed device_register function device %s\n",

			dev_name(&fn->dev));

		goto err_put_device;

	}



	rmi_dbg(RMI_DEBUG_CORE, &rmi_dev->dev, "Registered F%02X.\n",

			fn->fd.function_number);



	return 0;



err_put_device:

	put_device(&fn->dev);

	return error;

}



void rmi_unregister_function(struct rmi_function *fn)

{

	device_del(&fn->dev);



	if (fn->dev.of_node)

		of_node_put(fn->dev.of_node);



	put_device(&fn->dev);

}



/**

 * rmi_register_function_handler - register a handler for an RMI function

 * @handler: RMI handler that should be registered.

 * @module: pointer to module that implements the handler

 * @mod_name: name of the module implementing the handler

 *

 * This function performs additional setup of RMI function handler and

 * registers it with the RMI core so that it can be bound to

 * RMI function devices.

 */

int __rmi_register_function_handler(struct rmi_function_handler *handler,

				     struct module *owner,

				     const char *mod_name)

{

	struct device_driver *driver = &handler->driver;

	int error;



	driver->bus = &rmi_bus_type;

	driver->owner = owner;

	driver->mod_name = mod_name;

	driver->probe = rmi_function_probe;

	driver->remove = rmi_function_remove;



	error = driver_register(&handler->driver);

	if (error) {

		pr_err("driver_register() failed for %s, error: %d\n",

			handler->driver.name, error);

		return error;

	}



	return 0;

}

EXPORT_SYMBOL_GPL(__rmi_register_function_handler);



/**

 * rmi_unregister_function_handler - unregister given RMI function handler

 * @handler: RMI handler that should be unregistered.

 *

 * This function unregisters given function handler from RMI core which

 * causes it to be unbound from the function devices.

 */

void rmi_unregister_function_handler(struct rmi_function_handler *handler)

{

	driver_unregister(&handler->driver);

}

EXPORT_SYMBOL_GPL(rmi_unregister_function_handler);



/* Bus specific stuff */



static int rmi_bus_match(struct device *dev, struct device_driver *drv)

{

	bool physical = rmi_is_physical_device(dev);



	/* First see if types are not compatible */

	if (physical != rmi_is_physical_driver(drv))

		return 0;



	return physical || rmi_function_match(dev, drv);

}



struct bus_type rmi_bus_type = {

	.match		= rmi_bus_match,

	.name		= "rmi4",

};



static struct rmi_function_handler *fn_handlers[] = {

	&rmi_f01_handler,

};



static void __rmi_unregister_function_handlers(int start_idx)

{

	int i;



	for (i = start_idx; i >= 0; i--)

		rmi_unregister_function_handler(fn_handlers[i]);

}



static void rmi_unregister_function_handlers(void)

{

	__rmi_unregister_function_handlers(ARRAY_SIZE(fn_handlers) - 1);

}



static int rmi_register_function_handlers(void)

{

	int ret;

	int i;



	for (i = 0; i < ARRAY_SIZE(fn_handlers); i++)	{

		ret = rmi_register_function_handler(fn_handlers[i]);

		if (ret) {

			pr_err("%s: error registering the RMI F%02x handler: %d\n",

				__func__, fn_handlers[i]->func, ret);

			goto err_unregister_function_handlers;

		}

	}



	return 0;



err_unregister_function_handlers:

	__rmi_unregister_function_handlers(i - 1);

	return ret;

}



static int __init rmi_bus_init(void)

{

	int error;



	error = bus_register(&rmi_bus_type);

	if (error) {

		pr_err("%s: error registering the RMI bus: %d\n",

			__func__, error);

		return error;

	}



	error = rmi_register_function_handlers();

	if (error)

		goto err_unregister_bus;



	error = rmi_register_physical_driver();

	if (error) {

		pr_err("%s: error registering the RMI physical driver: %d\n",

			__func__, error);

		goto err_unregister_bus;

	}



	return 0;



err_unregister_bus:

	bus_unregister(&rmi_bus_type);

	return error;

}

module_init(rmi_bus_init);



static void __exit rmi_bus_exit(void)

{

	/*

	 * We should only ever get here if all drivers are unloaded, so

	 * all we have to do at this point is unregister ourselves.

	 */



	rmi_unregister_physical_driver();

	rmi_unregister_function_handlers();

	bus_unregister(&rmi_bus_type);

}

module_exit(rmi_bus_exit);



MODULE_AUTHOR("Christopher Heiny <cheiny@synaptics.com");

MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com");

MODULE_DESCRIPTION("RMI bus");

MODULE_LICENSE("GPL");

MODULE_VERSION(RMI_DRIVER_VERSION);