[mirror_ubuntu-bionic-kernel.git] / drivers / input / rmi4 / rmi_bus.c

/*
 * 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;
}

#ifdef CONFIG_OF
static void rmi_function_of_probe(struct rmi_function *fn)
{
	char of_name[9];
	struct device_node *node = fn->rmi_dev->xport->dev->of_node;

	snprintf(of_name, sizeof(of_name), "rmi4-f%02x",
		fn->fd.function_number);
	fn->dev.of_node = of_get_child_by_name(node, of_name);
}
#else
static inline void rmi_function_of_probe(struct rmi_function *fn)
{}
#endif

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;

	rmi_function_of_probe(fn);

	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);
	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,
#ifdef CONFIG_RMI4_F11
	&rmi_f11_handler,
#endif
#ifdef CONFIG_RMI4_F12
	&rmi_f12_handler,
#endif
#ifdef CONFIG_RMI4_F30
	&rmi_f30_handler,
#endif
};

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;
}

int rmi_of_property_read_u32(struct device *dev, u32 *result,
				const char *prop, bool optional)
{
	int retval;
	u32 val = 0;

	retval = of_property_read_u32(dev->of_node, prop, &val);
	if (retval && (!optional && retval == -EINVAL)) {
		dev_err(dev, "Failed to get %s value: %d\n",
			prop, retval);
		return retval;
	}
	*result = val;

	return 0;
}
EXPORT_SYMBOL_GPL(rmi_of_property_read_u32);

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);
Commit	Line	Data
2b6a321d AD	1	/*
	2	* Copyright (c) 2011-2016 Synaptics Incorporated
	3	* Copyright (c) 2011 Unixphere
	4	*
	5	* This program is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 as published by
	7	* the Free Software Foundation.
	8	*/
	9
	10	#include <linux/kernel.h>
	11	#include <linux/device.h>
	12	#include <linux/kconfig.h>
	13	#include <linux/list.h>
	14	#include <linux/pm.h>
	15	#include <linux/rmi.h>
	16	#include <linux/slab.h>
	17	#include <linux/types.h>
	18	#include <linux/of.h>
	19	#include "rmi_bus.h"
	20	#include "rmi_driver.h"
	21
	22	static int debug_flags;
	23	module_param(debug_flags, int, 0644);
	24	MODULE_PARM_DESC(debug_flags, "control debugging information");
	25
	26	void rmi_dbg(int flags, struct device dev, const char fmt, ...)
	27	{
	28	struct va_format vaf;
	29	va_list args;
	30
	31	if (flags & debug_flags) {
	32	va_start(args, fmt);
	33
	34	vaf.fmt = fmt;
	35	vaf.va = &args;
	36
	37	dev_printk(KERN_DEBUG, dev, "%pV", &vaf);
	38
	39	va_end(args);
	40	}
	41	}
	42	EXPORT_SYMBOL_GPL(rmi_dbg);
	43
	44	/*
	45	* RMI Physical devices
	46	*
	47	* Physical RMI device consists of several functions serving particular
	48	* purpose. For example F11 is a 2D touch sensor while F01 is a generic
	49	* function present in every RMI device.
	50	*/
	51
	52	static void rmi_release_device(struct device *dev)
	53	{
	54	struct rmi_device *rmi_dev = to_rmi_device(dev);
	55
	56	kfree(rmi_dev);
	57	}
	58
	59	static struct device_type rmi_device_type = {
	60	.name = "rmi4_sensor",
	61	.release = rmi_release_device,
	62	};
	63
	64	bool rmi_is_physical_device(struct device *dev)
65	{
66	return dev->type == &rmi_device_type;
67	}
68
69	/**
70	* rmi_register_transport_device - register a transport device connection
71	* on the RMI bus. Transport drivers provide communication from the devices
72	* on a bus (such as SPI, I2C, and so on) to the RMI4 sensor.
73	*
74	* @xport: the transport device to register
75	*/
76	int rmi_register_transport_device(struct rmi_transport_dev *xport)
77	{
78	static atomic_t transport_device_count = ATOMIC_INIT(0);
79	struct rmi_device *rmi_dev;
80	int error;
81
82	rmi_dev = kzalloc(sizeof(struct rmi_device), GFP_KERNEL);
83	if (!rmi_dev)
84	return -ENOMEM;
85
86	device_initialize(&rmi_dev->dev);
87
88	rmi_dev->xport = xport;
89	rmi_dev->number = atomic_inc_return(&transport_device_count) - 1;
90
91	dev_set_name(&rmi_dev->dev, "rmi4-%02d", rmi_dev->number);
92
93	rmi_dev->dev.bus = &rmi_bus_type;
94	rmi_dev->dev.type = &rmi_device_type;
95
96	xport->rmi_dev = rmi_dev;
97
98	error = device_add(&rmi_dev->dev);
99	if (error)
100	goto err_put_device;
101
102	rmi_dbg(RMI_DEBUG_CORE, xport->dev,
103	"%s: Registered %s as %s.\n", __func__,
104	dev_name(rmi_dev->xport->dev), dev_name(&rmi_dev->dev));
105
106	return 0;
107
108	err_put_device:
109	put_device(&rmi_dev->dev);
110	return error;
111	}
112	EXPORT_SYMBOL_GPL(rmi_register_transport_device);
113
114	/**
115	* rmi_unregister_transport_device - unregister a transport device connection
116	* @xport: the transport driver to unregister
117	*
118	*/
119	void rmi_unregister_transport_device(struct rmi_transport_dev *xport)
120	{
121	struct rmi_device *rmi_dev = xport->rmi_dev;
122
123	device_del(&rmi_dev->dev);
124	put_device(&rmi_dev->dev);
125	}
126	EXPORT_SYMBOL(rmi_unregister_transport_device);
127
128
129	/* Function specific stuff */
130
131	static void rmi_release_function(struct device *dev)
132	{
133	struct rmi_function *fn = to_rmi_function(dev);
134
135	kfree(fn);
136	}
137
138	static struct device_type rmi_function_type = {
139	.name = "rmi4_function",
140	.release = rmi_release_function,
141	};
142
143	bool rmi_is_function_device(struct device *dev)
144	{
145	return dev->type == &rmi_function_type;
146	}
147
148	static int rmi_function_match(struct device dev, struct device_driver drv)
149	{
150	struct rmi_function_handler *handler = to_rmi_function_handler(drv);
151	struct rmi_function *fn = to_rmi_function(dev);
152
153	return fn->fd.function_number == handler->func;
154	}
155
d8a8b3ed AD	156	#ifdef CONFIG_OF
	157	static void rmi_function_of_probe(struct rmi_function *fn)
	158	{
	159	char of_name[9];
9624516d	160	struct device_node *node = fn->rmi_dev->xport->dev->of_node;
d8a8b3ed AD	161
	162	snprintf(of_name, sizeof(of_name), "rmi4-f%02x",
	163	fn->fd.function_number);
9624516d	164	fn->dev.of_node = of_get_child_by_name(node, of_name);
d8a8b3ed AD	165	}
	166	#else
	167	static inline void rmi_function_of_probe(struct rmi_function *fn)
	168	{}
	169	#endif
	170
2b6a321d AD	171	static int rmi_function_probe(struct device *dev)
	172	{
	173	struct rmi_function *fn = to_rmi_function(dev);
	174	struct rmi_function_handler *handler =
	175	to_rmi_function_handler(dev->driver);
	176	int error;
	177
d8a8b3ed AD	178	rmi_function_of_probe(fn);
d8a8b3ed AD	179
2b6a321d AD	180	if (handler->probe) {
	181	error = handler->probe(fn);
	182	return error;
	183	}
	184
	185	return 0;
	186	}
	187
	188	static int rmi_function_remove(struct device *dev)
	189	{
	190	struct rmi_function *fn = to_rmi_function(dev);
	191	struct rmi_function_handler *handler =
	192	to_rmi_function_handler(dev->driver);
	193
	194	if (handler->remove)
	195	handler->remove(fn);
	196
	197	return 0;
	198	}
	199
	200	int rmi_register_function(struct rmi_function *fn)
	201	{
	202	struct rmi_device *rmi_dev = fn->rmi_dev;
	203	int error;
	204
	205	device_initialize(&fn->dev);
	206
	207	dev_set_name(&fn->dev, "%s.fn%02x",
	208	dev_name(&rmi_dev->dev), fn->fd.function_number);
	209
	210	fn->dev.parent = &rmi_dev->dev;
	211	fn->dev.type = &rmi_function_type;
	212	fn->dev.bus = &rmi_bus_type;
	213
	214	error = device_add(&fn->dev);
	215	if (error) {
	216	dev_err(&rmi_dev->dev,
	217	"Failed device_register function device %s\n",
	218	dev_name(&fn->dev));
	219	goto err_put_device;
	220	}
	221
	222	rmi_dbg(RMI_DEBUG_CORE, &rmi_dev->dev, "Registered F%02X.\n",
	223	fn->fd.function_number);
	224
	225	return 0;
	226
	227	err_put_device:
	228	put_device(&fn->dev);
	229	return error;
	230	}
	231
	232	void rmi_unregister_function(struct rmi_function *fn)
	233	{
	234	device_del(&fn->dev);
887ec0bf	235	of_node_put(fn->dev.of_node);
2b6a321d AD	236	put_device(&fn->dev);
	237	}
	238
	239	/**
	240	* rmi_register_function_handler - register a handler for an RMI function
	241	* @handler: RMI handler that should be registered.
	242	* @module: pointer to module that implements the handler
	243	* @mod_name: name of the module implementing the handler
	244	*
	245	* This function performs additional setup of RMI function handler and
	246	* registers it with the RMI core so that it can be bound to
	247	* RMI function devices.
	248	*/
	249	int __rmi_register_function_handler(struct rmi_function_handler *handler,
	250	struct module *owner,
	251	const char *mod_name)
	252	{
	253	struct device_driver *driver = &handler->driver;
	254	int error;
	255
	256	driver->bus = &rmi_bus_type;
	257	driver->owner = owner;
	258	driver->mod_name = mod_name;
	259	driver->probe = rmi_function_probe;
	260	driver->remove = rmi_function_remove;
	261
	262	error = driver_register(&handler->driver);
	263	if (error) {
	264	pr_err("driver_register() failed for %s, error: %d\n",
	265	handler->driver.name, error);
	266	return error;
	267	}
	268
	269	return 0;
	270	}
	271	EXPORT_SYMBOL_GPL(__rmi_register_function_handler);
	272
	273	/**
	274	* rmi_unregister_function_handler - unregister given RMI function handler
	275	* @handler: RMI handler that should be unregistered.
	276	*
	277	* This function unregisters given function handler from RMI core which
	278	* causes it to be unbound from the function devices.
	279	*/
	280	void rmi_unregister_function_handler(struct rmi_function_handler *handler)
	281	{
	282	driver_unregister(&handler->driver);
	283	}
	284	EXPORT_SYMBOL_GPL(rmi_unregister_function_handler);
	285
	286	/* Bus specific stuff */
	287
	288	static int rmi_bus_match(struct device dev, struct device_driver drv)
	289	{
	290	bool physical = rmi_is_physical_device(dev);
	291
	292	/* First see if types are not compatible */
	293	if (physical != rmi_is_physical_driver(drv))
	294	return 0;
	295
	296	return physical \|\| rmi_function_match(dev, drv);
	297	}
	298
	299	struct bus_type rmi_bus_type = {
300	.match = rmi_bus_match,
301	.name = "rmi4",
302	};
303
304	static struct rmi_function_handler *fn_handlers[] = {
305	&rmi_f01_handler,
ff8f8370 AD	306	#ifdef CONFIG_RMI4_F11
	307	&rmi_f11_handler,
	308	#endif
b43d2c1e AD	309	#ifdef CONFIG_RMI4_F12
	310	&rmi_f12_handler,
	311	#endif
562b42d3 AD	312	#ifdef CONFIG_RMI4_F30
	313	&rmi_f30_handler,
	314	#endif
2b6a321d AD	315	};
	316
	317	static void __rmi_unregister_function_handlers(int start_idx)
	318	{
	319	int i;
	320
	321	for (i = start_idx; i >= 0; i--)
	322	rmi_unregister_function_handler(fn_handlers[i]);
	323	}
	324
	325	static void rmi_unregister_function_handlers(void)
	326	{
	327	__rmi_unregister_function_handlers(ARRAY_SIZE(fn_handlers) - 1);
	328	}
	329
	330	static int rmi_register_function_handlers(void)
	331	{
	332	int ret;
	333	int i;
	334
	335	for (i = 0; i < ARRAY_SIZE(fn_handlers); i++) {
	336	ret = rmi_register_function_handler(fn_handlers[i]);
	337	if (ret) {
	338	pr_err("%s: error registering the RMI F%02x handler: %d\n",
	339	__func__, fn_handlers[i]->func, ret);
	340	goto err_unregister_function_handlers;
	341	}
	342	}
	343
	344	return 0;
	345
	346	err_unregister_function_handlers:
	347	__rmi_unregister_function_handlers(i - 1);
	348	return ret;
	349	}
	350
d8a8b3ed AD	351	int rmi_of_property_read_u32(struct device dev, u32 result,
	352	const char *prop, bool optional)
	353	{
	354	int retval;
	355	u32 val = 0;
	356
	357	retval = of_property_read_u32(dev->of_node, prop, &val);
	358	if (retval && (!optional && retval == -EINVAL)) {
	359	dev_err(dev, "Failed to get %s value: %d\n",
	360	prop, retval);
	361	return retval;
	362	}
	363	*result = val;
	364
	365	return 0;
	366	}
	367	EXPORT_SYMBOL_GPL(rmi_of_property_read_u32);
	368
2b6a321d AD	369	static int __init rmi_bus_init(void)
	370	{
	371	int error;
	372
	373	error = bus_register(&rmi_bus_type);
	374	if (error) {
	375	pr_err("%s: error registering the RMI bus: %d\n",
	376	__func__, error);
	377	return error;
	378	}
	379
	380	error = rmi_register_function_handlers();
	381	if (error)
	382	goto err_unregister_bus;
	383
	384	error = rmi_register_physical_driver();
	385	if (error) {
	386	pr_err("%s: error registering the RMI physical driver: %d\n",
	387	__func__, error);
	388	goto err_unregister_bus;
	389	}
	390
	391	return 0;
	392
	393	err_unregister_bus:
	394	bus_unregister(&rmi_bus_type);
	395	return error;
	396	}
	397	module_init(rmi_bus_init);
	398
	399	static void __exit rmi_bus_exit(void)
	400	{
	401	/*
	402	* We should only ever get here if all drivers are unloaded, so
	403	* all we have to do at this point is unregister ourselves.
	404	*/
	405
	406	rmi_unregister_physical_driver();
	407	rmi_unregister_function_handlers();
	408	bus_unregister(&rmi_bus_type);
	409	}
	410	module_exit(rmi_bus_exit);
	411
	412	MODULE_AUTHOR("Christopher Heiny <cheiny@synaptics.com");
	413	MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com");
	414	MODULE_DESCRIPTION("RMI bus");
	415	MODULE_LICENSE("GPL");
	416	MODULE_VERSION(RMI_DRIVER_VERSION);