[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / hid / hid-roccat-konepure.c

/*
 * Roccat KonePure driver for Linux
 *
 * Copyright (c) 2012 Stefan Achatz <erazor_de@users.sourceforge.net>
 */

/*
 * 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.
 */

/*
 * Roccat KonePure is a smaller version of KoneXTD with less buttons and lights.
 */

#include <linux/device.h>
#include <linux/input.h>
#include <linux/hid.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/hid-roccat.h>
#include "hid-ids.h"
#include "hid-roccat-common.h"
#include "hid-roccat-konepure.h"

static struct class *konepure_class;

static ssize_t konepure_sysfs_read(struct file *fp, struct kobject *kobj,
		char *buf, loff_t off, size_t count,
		size_t real_size, uint command)
{
	struct device *dev =
			container_of(kobj, struct device, kobj)->parent->parent;
	struct konepure_device *konepure = hid_get_drvdata(dev_get_drvdata(dev));
	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
	int retval;

	if (off >= real_size)
		return 0;

	if (off != 0 || count != real_size)
		return -EINVAL;

	mutex_lock(&konepure->konepure_lock);
	retval = roccat_common2_receive(usb_dev, command, buf, real_size);
	mutex_unlock(&konepure->konepure_lock);

	return retval ? retval : real_size;
}

static ssize_t konepure_sysfs_write(struct file *fp, struct kobject *kobj,
		void const *buf, loff_t off, size_t count,
		size_t real_size, uint command)
{
	struct device *dev =
			container_of(kobj, struct device, kobj)->parent->parent;
	struct konepure_device *konepure = hid_get_drvdata(dev_get_drvdata(dev));
	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
	int retval;

	if (off != 0 || count != real_size)
		return -EINVAL;

	mutex_lock(&konepure->konepure_lock);
	retval = roccat_common2_send_with_status(usb_dev, command,
			(void *)buf, real_size);
	mutex_unlock(&konepure->konepure_lock);

	return retval ? retval : real_size;
}

#define KONEPURE_SYSFS_W(thingy, THINGY) \
static ssize_t konepure_sysfs_write_ ## thingy(struct file *fp, \
		struct kobject *kobj, struct bin_attribute *attr, char *buf, \
		loff_t off, size_t count) \
{ \
	return konepure_sysfs_write(fp, kobj, buf, off, count, \
			KONEPURE_SIZE_ ## THINGY, KONEPURE_COMMAND_ ## THINGY); \
}

#define KONEPURE_SYSFS_R(thingy, THINGY) \
static ssize_t konepure_sysfs_read_ ## thingy(struct file *fp, \
		struct kobject *kobj, struct bin_attribute *attr, char *buf, \
		loff_t off, size_t count) \
{ \
	return konepure_sysfs_read(fp, kobj, buf, off, count, \
			KONEPURE_SIZE_ ## THINGY, KONEPURE_COMMAND_ ## THINGY); \
}

#define KONEPURE_SYSFS_RW(thingy, THINGY) \
KONEPURE_SYSFS_W(thingy, THINGY) \
KONEPURE_SYSFS_R(thingy, THINGY)

#define KONEPURE_BIN_ATTRIBUTE_RW(thingy, THINGY) \
{ \
	.attr = { .name = #thingy, .mode = 0660 }, \
	.size = KONEPURE_SIZE_ ## THINGY, \
	.read = konepure_sysfs_read_ ## thingy, \
	.write = konepure_sysfs_write_ ## thingy \
}

#define KONEPURE_BIN_ATTRIBUTE_R(thingy, THINGY) \
{ \
	.attr = { .name = #thingy, .mode = 0440 }, \
	.size = KONEPURE_SIZE_ ## THINGY, \
	.read = konepure_sysfs_read_ ## thingy, \
}

#define KONEPURE_BIN_ATTRIBUTE_W(thingy, THINGY) \
{ \
	.attr = { .name = #thingy, .mode = 0220 }, \
	.size = KONEPURE_SIZE_ ## THINGY, \
	.write = konepure_sysfs_write_ ## thingy \
}

KONEPURE_SYSFS_RW(actual_profile, ACTUAL_PROFILE)
KONEPURE_SYSFS_W(control, CONTROL)
KONEPURE_SYSFS_RW(info, INFO)
KONEPURE_SYSFS_W(talk, TALK)
KONEPURE_SYSFS_W(macro, MACRO)
KONEPURE_SYSFS_RW(sensor, SENSOR)
KONEPURE_SYSFS_RW(tcu, TCU)
KONEPURE_SYSFS_R(tcu_image, TCU_IMAGE)
KONEPURE_SYSFS_RW(profile_settings, PROFILE_SETTINGS)
KONEPURE_SYSFS_RW(profile_buttons, PROFILE_BUTTONS)

static struct bin_attribute konepure_bin_attributes[] = {
	KONEPURE_BIN_ATTRIBUTE_RW(actual_profile, ACTUAL_PROFILE),
	KONEPURE_BIN_ATTRIBUTE_W(control, CONTROL),
	KONEPURE_BIN_ATTRIBUTE_RW(info, INFO),
	KONEPURE_BIN_ATTRIBUTE_W(talk, TALK),
	KONEPURE_BIN_ATTRIBUTE_W(macro, MACRO),
	KONEPURE_BIN_ATTRIBUTE_RW(sensor, SENSOR),
	KONEPURE_BIN_ATTRIBUTE_RW(tcu, TCU),
	KONEPURE_BIN_ATTRIBUTE_R(tcu_image, TCU_IMAGE),
	KONEPURE_BIN_ATTRIBUTE_RW(profile_settings, PROFILE_SETTINGS),
	KONEPURE_BIN_ATTRIBUTE_RW(profile_buttons, PROFILE_BUTTONS),
	__ATTR_NULL
};

static int konepure_init_konepure_device_struct(struct usb_device *usb_dev,
		struct konepure_device *konepure)
{
	mutex_init(&konepure->konepure_lock);

	return 0;
}

static int konepure_init_specials(struct hid_device *hdev)
{
	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
	struct usb_device *usb_dev = interface_to_usbdev(intf);
	struct konepure_device *konepure;
	int retval;

	if (intf->cur_altsetting->desc.bInterfaceProtocol
			!= USB_INTERFACE_PROTOCOL_MOUSE) {
		hid_set_drvdata(hdev, NULL);
		return 0;
	}

	konepure = kzalloc(sizeof(*konepure), GFP_KERNEL);
	if (!konepure) {
		hid_err(hdev, "can't alloc device descriptor\n");
		return -ENOMEM;
	}
	hid_set_drvdata(hdev, konepure);

	retval = konepure_init_konepure_device_struct(usb_dev, konepure);
	if (retval) {
		hid_err(hdev, "couldn't init struct konepure_device\n");
		goto exit_free;
	}

	retval = roccat_connect(konepure_class, hdev,
			sizeof(struct konepure_mouse_report_button));
	if (retval < 0) {
		hid_err(hdev, "couldn't init char dev\n");
	} else {
		konepure->chrdev_minor = retval;
		konepure->roccat_claimed = 1;
	}

	return 0;
exit_free:
	kfree(konepure);
	return retval;
}

static void konepure_remove_specials(struct hid_device *hdev)
{
	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
	struct konepure_device *konepure;

	if (intf->cur_altsetting->desc.bInterfaceProtocol
			!= USB_INTERFACE_PROTOCOL_MOUSE)
		return;

	konepure = hid_get_drvdata(hdev);
	if (konepure->roccat_claimed)
		roccat_disconnect(konepure->chrdev_minor);
	kfree(konepure);
}

static int konepure_probe(struct hid_device *hdev,
		const struct hid_device_id *id)
{
	int retval;

	retval = hid_parse(hdev);
	if (retval) {
		hid_err(hdev, "parse failed\n");
		goto exit;
	}

	retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
	if (retval) {
		hid_err(hdev, "hw start failed\n");
		goto exit;
	}

	retval = konepure_init_specials(hdev);
	if (retval) {
		hid_err(hdev, "couldn't install mouse\n");
		goto exit_stop;
	}

	return 0;

exit_stop:
	hid_hw_stop(hdev);
exit:
	return retval;
}

static void konepure_remove(struct hid_device *hdev)
{
	konepure_remove_specials(hdev);
	hid_hw_stop(hdev);
}

static int konepure_raw_event(struct hid_device *hdev,
		struct hid_report *report, u8 *data, int size)
{
	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
	struct konepure_device *konepure = hid_get_drvdata(hdev);

	if (intf->cur_altsetting->desc.bInterfaceProtocol
			!= USB_INTERFACE_PROTOCOL_MOUSE)
		return 0;

	if (data[0] != KONEPURE_MOUSE_REPORT_NUMBER_BUTTON)
		return 0;

	if (konepure != NULL && konepure->roccat_claimed)
		roccat_report_event(konepure->chrdev_minor, data);

	return 0;
}

static const struct hid_device_id konepure_devices[] = {
	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONEPURE) },
	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONEPURE_OPTICAL) },
	{ }
};

MODULE_DEVICE_TABLE(hid, konepure_devices);

static struct hid_driver konepure_driver = {
		.name = "konepure",
		.id_table = konepure_devices,
		.probe = konepure_probe,
		.remove = konepure_remove,
		.raw_event = konepure_raw_event
};

static int __init konepure_init(void)
{
	int retval;

	konepure_class = class_create(THIS_MODULE, "konepure");
	if (IS_ERR(konepure_class))
		return PTR_ERR(konepure_class);
	konepure_class->dev_bin_attrs = konepure_bin_attributes;

	retval = hid_register_driver(&konepure_driver);
	if (retval)
		class_destroy(konepure_class);
	return retval;
}

static void __exit konepure_exit(void)
{
	hid_unregister_driver(&konepure_driver);
	class_destroy(konepure_class);
}

module_init(konepure_init);
module_exit(konepure_exit);

MODULE_AUTHOR("Stefan Achatz");
MODULE_DESCRIPTION("USB Roccat KonePure/Optical driver");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
8936aa31 SA	1	/*
	2	* Roccat KonePure driver for Linux
	3	*
	4	* Copyright (c) 2012 Stefan Achatz <erazor_de@users.sourceforge.net>
	5	*/
	6
	7	/*
	8	* This program is free software; you can redistribute it and/or modify it
	9	* under the terms of the GNU General Public License as published by the Free
	10	* Software Foundation; either version 2 of the License, or (at your option)
	11	* any later version.
	12	*/
	13
	14	/*
	15	* Roccat KonePure is a smaller version of KoneXTD with less buttons and lights.
	16	*/
	17
	18	#include <linux/device.h>
	19	#include <linux/input.h>
	20	#include <linux/hid.h>
	21	#include <linux/module.h>
	22	#include <linux/slab.h>
	23	#include <linux/hid-roccat.h>
	24	#include "hid-ids.h"
	25	#include "hid-roccat-common.h"
	26	#include "hid-roccat-konepure.h"
	27
	28	static struct class *konepure_class;
	29
	30	static ssize_t konepure_sysfs_read(struct file fp, struct kobject kobj,
	31	char *buf, loff_t off, size_t count,
	32	size_t real_size, uint command)
	33	{
	34	struct device *dev =
	35	container_of(kobj, struct device, kobj)->parent->parent;
	36	struct konepure_device *konepure = hid_get_drvdata(dev_get_drvdata(dev));
	37	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
	38	int retval;
	39
	40	if (off >= real_size)
	41	return 0;
	42
	43	if (off != 0 \|\| count != real_size)
	44	return -EINVAL;
	45
	46	mutex_lock(&konepure->konepure_lock);
	47	retval = roccat_common2_receive(usb_dev, command, buf, real_size);
	48	mutex_unlock(&konepure->konepure_lock);
	49
	50	return retval ? retval : real_size;
	51	}
	52
	53	static ssize_t konepure_sysfs_write(struct file fp, struct kobject kobj,
	54	void const *buf, loff_t off, size_t count,
	55	size_t real_size, uint command)
	56	{
	57	struct device *dev =
	58	container_of(kobj, struct device, kobj)->parent->parent;
	59	struct konepure_device *konepure = hid_get_drvdata(dev_get_drvdata(dev));
	60	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
	61	int retval;
	62
	63	if (off != 0 \|\| count != real_size)
	64	return -EINVAL;
65
66	mutex_lock(&konepure->konepure_lock);
67	retval = roccat_common2_send_with_status(usb_dev, command,
68	(void *)buf, real_size);
69	mutex_unlock(&konepure->konepure_lock);
70
71	return retval ? retval : real_size;
72	}
73
74	#define KONEPURE_SYSFS_W(thingy, THINGY) \
75	static ssize_t konepure_sysfs_write_ ## thingy(struct file *fp, \
76	struct kobject kobj, struct bin_attribute attr, char *buf, \
77	loff_t off, size_t count) \
78	{ \
79	return konepure_sysfs_write(fp, kobj, buf, off, count, \
80	KONEPURE_SIZE_ ## THINGY, KONEPURE_COMMAND_ ## THINGY); \
81	}
82
83	#define KONEPURE_SYSFS_R(thingy, THINGY) \
84	static ssize_t konepure_sysfs_read_ ## thingy(struct file *fp, \
85	struct kobject kobj, struct bin_attribute attr, char *buf, \
86	loff_t off, size_t count) \
87	{ \
88	return konepure_sysfs_read(fp, kobj, buf, off, count, \
89	KONEPURE_SIZE_ ## THINGY, KONEPURE_COMMAND_ ## THINGY); \
90	}
91
92	#define KONEPURE_SYSFS_RW(thingy, THINGY) \
93	KONEPURE_SYSFS_W(thingy, THINGY) \
94	KONEPURE_SYSFS_R(thingy, THINGY)
95
96	#define KONEPURE_BIN_ATTRIBUTE_RW(thingy, THINGY) \
97	{ \
98	.attr = { .name = #thingy, .mode = 0660 }, \
99	.size = KONEPURE_SIZE_ ## THINGY, \
100	.read = konepure_sysfs_read_ ## thingy, \
101	.write = konepure_sysfs_write_ ## thingy \
102	}
103
104	#define KONEPURE_BIN_ATTRIBUTE_R(thingy, THINGY) \
105	{ \
106	.attr = { .name = #thingy, .mode = 0440 }, \
107	.size = KONEPURE_SIZE_ ## THINGY, \
108	.read = konepure_sysfs_read_ ## thingy, \
109	}
110
111	#define KONEPURE_BIN_ATTRIBUTE_W(thingy, THINGY) \
112	{ \
113	.attr = { .name = #thingy, .mode = 0220 }, \
114	.size = KONEPURE_SIZE_ ## THINGY, \
115	.write = konepure_sysfs_write_ ## thingy \
116	}
117
118	KONEPURE_SYSFS_RW(actual_profile, ACTUAL_PROFILE)
119	KONEPURE_SYSFS_W(control, CONTROL)
120	KONEPURE_SYSFS_RW(info, INFO)
121	KONEPURE_SYSFS_W(talk, TALK)
122	KONEPURE_SYSFS_W(macro, MACRO)
123	KONEPURE_SYSFS_RW(sensor, SENSOR)
124	KONEPURE_SYSFS_RW(tcu, TCU)
125	KONEPURE_SYSFS_R(tcu_image, TCU_IMAGE)
126	KONEPURE_SYSFS_RW(profile_settings, PROFILE_SETTINGS)
127	KONEPURE_SYSFS_RW(profile_buttons, PROFILE_BUTTONS)
128
129	static struct bin_attribute konepure_bin_attributes[] = {
130	KONEPURE_BIN_ATTRIBUTE_RW(actual_profile, ACTUAL_PROFILE),
131	KONEPURE_BIN_ATTRIBUTE_W(control, CONTROL),
132	KONEPURE_BIN_ATTRIBUTE_RW(info, INFO),
133	KONEPURE_BIN_ATTRIBUTE_W(talk, TALK),
134	KONEPURE_BIN_ATTRIBUTE_W(macro, MACRO),
135	KONEPURE_BIN_ATTRIBUTE_RW(sensor, SENSOR),
136	KONEPURE_BIN_ATTRIBUTE_RW(tcu, TCU),
137	KONEPURE_BIN_ATTRIBUTE_R(tcu_image, TCU_IMAGE),
138	KONEPURE_BIN_ATTRIBUTE_RW(profile_settings, PROFILE_SETTINGS),
139	KONEPURE_BIN_ATTRIBUTE_RW(profile_buttons, PROFILE_BUTTONS),
140	__ATTR_NULL
141	};
142
143	static int konepure_init_konepure_device_struct(struct usb_device *usb_dev,
144	struct konepure_device *konepure)
145	{
146	mutex_init(&konepure->konepure_lock);
147
148	return 0;
149	}
150
151	static int konepure_init_specials(struct hid_device *hdev)
152	{
153	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
154	struct usb_device *usb_dev = interface_to_usbdev(intf);
155	struct konepure_device *konepure;
156	int retval;
157
158	if (intf->cur_altsetting->desc.bInterfaceProtocol
159	!= USB_INTERFACE_PROTOCOL_MOUSE) {
160	hid_set_drvdata(hdev, NULL);
161	return 0;
162	}
163
164	konepure = kzalloc(sizeof(*konepure), GFP_KERNEL);
165	if (!konepure) {
166	hid_err(hdev, "can't alloc device descriptor\n");
167	return -ENOMEM;
168	}
169	hid_set_drvdata(hdev, konepure);
170
171	retval = konepure_init_konepure_device_struct(usb_dev, konepure);
172	if (retval) {
173	hid_err(hdev, "couldn't init struct konepure_device\n");
174	goto exit_free;
175	}
176
177	retval = roccat_connect(konepure_class, hdev,
178	sizeof(struct konepure_mouse_report_button));
179	if (retval < 0) {
180	hid_err(hdev, "couldn't init char dev\n");
181	} else {
182	konepure->chrdev_minor = retval;
183	konepure->roccat_claimed = 1;
184	}
185
186	return 0;
187	exit_free:
188	kfree(konepure);
189	return retval;
190	}
191
192	static void konepure_remove_specials(struct hid_device *hdev)
193	{
194	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
195	struct konepure_device *konepure;
196
197	if (intf->cur_altsetting->desc.bInterfaceProtocol
198	!= USB_INTERFACE_PROTOCOL_MOUSE)
199	return;
200
201	konepure = hid_get_drvdata(hdev);
202	if (konepure->roccat_claimed)
203	roccat_disconnect(konepure->chrdev_minor);
204	kfree(konepure);
205	}
206
207	static int konepure_probe(struct hid_device *hdev,
208	const struct hid_device_id *id)
209	{
210	int retval;
211
212	retval = hid_parse(hdev);
213	if (retval) {
214	hid_err(hdev, "parse failed\n");
215	goto exit;
216	}
217
218	retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
219	if (retval) {
220	hid_err(hdev, "hw start failed\n");
221	goto exit;
222	}
223
224	retval = konepure_init_specials(hdev);
225	if (retval) {
226	hid_err(hdev, "couldn't install mouse\n");
227	goto exit_stop;
228	}
229
230	return 0;
231
232	exit_stop:
233	hid_hw_stop(hdev);
234	exit:
235	return retval;
236	}
237
238	static void konepure_remove(struct hid_device *hdev)
239	{
240	konepure_remove_specials(hdev);
241	hid_hw_stop(hdev);
242	}
243
244	static int konepure_raw_event(struct hid_device *hdev,
245	struct hid_report report, u8 data, int size)
246	{
247	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
248	struct konepure_device *konepure = hid_get_drvdata(hdev);
249
250	if (intf->cur_altsetting->desc.bInterfaceProtocol
251	!= USB_INTERFACE_PROTOCOL_MOUSE)
252	return 0;
253
254	if (data[0] != KONEPURE_MOUSE_REPORT_NUMBER_BUTTON)
255	return 0;
256
257	if (konepure != NULL && konepure->roccat_claimed)
258	roccat_report_event(konepure->chrdev_minor, data);
259
260	return 0;
261	}
262
263	static const struct hid_device_id konepure_devices[] = {
264	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONEPURE) },
a873420a	265	{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONEPURE_OPTICAL) },
8936aa31 SA	266	{ }
	267	};
	268
	269	MODULE_DEVICE_TABLE(hid, konepure_devices);
	270
	271	static struct hid_driver konepure_driver = {
	272	.name = "konepure",
	273	.id_table = konepure_devices,
	274	.probe = konepure_probe,
	275	.remove = konepure_remove,
	276	.raw_event = konepure_raw_event
	277	};
	278
	279	static int __init konepure_init(void)
	280	{
	281	int retval;
	282
	283	konepure_class = class_create(THIS_MODULE, "konepure");
	284	if (IS_ERR(konepure_class))
	285	return PTR_ERR(konepure_class);
	286	konepure_class->dev_bin_attrs = konepure_bin_attributes;
	287
	288	retval = hid_register_driver(&konepure_driver);
	289	if (retval)
	290	class_destroy(konepure_class);
	291	return retval;
	292	}
	293
	294	static void __exit konepure_exit(void)
	295	{
	296	hid_unregister_driver(&konepure_driver);
	297	class_destroy(konepure_class);
	298	}
	299
	300	module_init(konepure_init);
	301	module_exit(konepure_exit);
	302
	303	MODULE_AUTHOR("Stefan Achatz");
a873420a	304	MODULE_DESCRIPTION("USB Roccat KonePure/Optical driver");
8936aa31	305	MODULE_LICENSE("GPL v2");