[deliverable/linux.git] / drivers / input / tablet / pegasus_notetaker.c

/*
 * Pegasus Mobile Notetaker Pen input tablet driver
 *
 * Copyright (c) 2016 Martin Kepplinger <martink@posteo.de>
 */

/*
 * request packet (control endpoint):
 * |-------------------------------------|
 * | Report ID | Nr of bytes | command   |
 * | (1 byte)  | (1 byte)    | (n bytes) |
 * |-------------------------------------|
 * | 0x02      | n           |           |
 * |-------------------------------------|
 *
 * data packet after set xy mode command, 0x80 0xb5 0x02 0x01
 * and pen is in range:
 *
 * byte	byte name		value (bits)
 * --------------------------------------------
 * 0	status			0 1 0 0 0 0 X X
 * 1	color			0 0 0 0 H 0 S T
 * 2	X low
 * 3	X high
 * 4	Y low
 * 5	Y high
 *
 * X X	battery state:
 *	no state reported	0x00
 *	battery low		0x01
 *	battery good		0x02
 *
 * H	Hovering
 * S	Switch 1 (pen button)
 * T	Tip
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/input.h>
#include <linux/usb/input.h>
#include <linux/slab.h>

/* USB HID defines */
#define USB_REQ_GET_REPORT		0x01
#define USB_REQ_SET_REPORT		0x09

#define USB_VENDOR_ID_PEGASUSTECH	0x0e20
#define USB_DEVICE_ID_PEGASUS_NOTETAKER_EN100	0x0101

/* device specific defines */
#define NOTETAKER_REPORT_ID		0x02
#define NOTETAKER_SET_CMD		0x80
#define NOTETAKER_SET_MODE		0xb5

#define NOTETAKER_LED_MOUSE		0x02
#define PEN_MODE_XY			0x01

#define SPECIAL_COMMAND			0x80
#define BUTTON_PRESSED			0xb5
#define COMMAND_VERSION			0xa9

/* in xy data packet */
#define BATTERY_NO_REPORT		0x40
#define BATTERY_LOW			0x41
#define BATTERY_GOOD			0x42
#define PEN_BUTTON_PRESSED		BIT(1)
#define PEN_TIP				BIT(0)

struct pegasus {
	unsigned char *data;
	u8 data_len;
	dma_addr_t data_dma;
	struct input_dev *dev;
	struct usb_device *usbdev;
	struct usb_interface *intf;
	struct urb *irq;
	char name[128];
	char phys[64];
	struct work_struct init;
};

static int pegasus_control_msg(struct pegasus *pegasus, u8 *data, int len)
{
	const int sizeof_buf = len + 2;
	int result;
	int error;
	u8 *cmd_buf;

	cmd_buf = kmalloc(sizeof_buf, GFP_KERNEL);
	if (!cmd_buf)
		return -ENOMEM;

	cmd_buf[0] = NOTETAKER_REPORT_ID;
	cmd_buf[1] = len;
	memcpy(cmd_buf + 2, data, len);

	result = usb_control_msg(pegasus->usbdev,
				 usb_sndctrlpipe(pegasus->usbdev, 0),
				 USB_REQ_SET_REPORT,
				 USB_TYPE_VENDOR | USB_DIR_OUT,
				 0, 0, cmd_buf, sizeof_buf,
				 USB_CTRL_SET_TIMEOUT);

	kfree(cmd_buf);

	if (unlikely(result != sizeof_buf)) {
		error = result < 0 ? result : -EIO;
		dev_err(&pegasus->usbdev->dev, "control msg error: %d\n",
			error);
		return error;
	}

	return 0;
}

static int pegasus_set_mode(struct pegasus *pegasus, u8 mode, u8 led)
{
	u8 cmd[] = { NOTETAKER_SET_CMD, NOTETAKER_SET_MODE, led, mode };

	return pegasus_control_msg(pegasus, cmd, sizeof(cmd));
}

static void pegasus_parse_packet(struct pegasus *pegasus)
{
	unsigned char *data = pegasus->data;
	struct input_dev *dev = pegasus->dev;
	u16 x, y;

	switch (data[0]) {
	case SPECIAL_COMMAND:
		/* device button pressed */
		if (data[1] == BUTTON_PRESSED)
			schedule_work(&pegasus->init);

		break;

	/* xy data */
	case BATTERY_LOW:
		dev_warn_once(&dev->dev, "Pen battery low\n");
		/* fall through */

	case BATTERY_NO_REPORT:
	case BATTERY_GOOD:
		x = le16_to_cpup((__le16 *)&data[2]);
		y = le16_to_cpup((__le16 *)&data[4]);

		/* pen-up event */
		if (x == 0 && y == 0)
			break;

		input_report_key(dev, BTN_TOUCH, data[1] & PEN_TIP);
		input_report_key(dev, BTN_RIGHT, data[1] & PEN_BUTTON_PRESSED);
		input_report_key(dev, BTN_TOOL_PEN, 1);
		input_report_abs(dev, ABS_X, (s16)x);
		input_report_abs(dev, ABS_Y, y);

		input_sync(dev);
		break;

	default:
		dev_warn_once(&pegasus->usbdev->dev,
			      "unknown answer from device\n");
	}
}

static void pegasus_irq(struct urb *urb)
{
	struct pegasus *pegasus = urb->context;
	struct usb_device *dev = pegasus->usbdev;
	int retval;

	switch (urb->status) {
	case 0:
		pegasus_parse_packet(pegasus);
		usb_mark_last_busy(pegasus->usbdev);
		break;

	case -ECONNRESET:
	case -ENOENT:
	case -ESHUTDOWN:
		dev_err(&dev->dev, "%s - urb shutting down with status: %d",
			__func__, urb->status);
		return;

	default:
		dev_err(&dev->dev, "%s - nonzero urb status received: %d",
			__func__, urb->status);
		break;
	}

	retval = usb_submit_urb(urb, GFP_ATOMIC);
	if (retval)
		dev_err(&dev->dev, "%s - usb_submit_urb failed with result %d",
			__func__, retval);
}

static void pegasus_init(struct work_struct *work)
{
	struct pegasus *pegasus = container_of(work, struct pegasus, init);
	int error;

	error = pegasus_set_mode(pegasus, PEN_MODE_XY, NOTETAKER_LED_MOUSE);
	if (error)
		dev_err(&pegasus->usbdev->dev, "pegasus_set_mode error: %d\n",
			error);
}

static int pegasus_open(struct input_dev *dev)
{
	struct pegasus *pegasus = input_get_drvdata(dev);
	int error;

	error = usb_autopm_get_interface(pegasus->intf);
	if (error)
		return error;

	pegasus->irq->dev = pegasus->usbdev;
	if (usb_submit_urb(pegasus->irq, GFP_KERNEL)) {
		error = -EIO;
		goto err_autopm_put;
	}

	error = pegasus_set_mode(pegasus, PEN_MODE_XY, NOTETAKER_LED_MOUSE);
	if (error)
		goto err_kill_urb;

	return 0;

err_kill_urb:
	usb_kill_urb(pegasus->irq);
	cancel_work_sync(&pegasus->init);
err_autopm_put:
	usb_autopm_put_interface(pegasus->intf);
	return error;
}

static void pegasus_close(struct input_dev *dev)
{
	struct pegasus *pegasus = input_get_drvdata(dev);

	usb_kill_urb(pegasus->irq);
	cancel_work_sync(&pegasus->init);
	usb_autopm_put_interface(pegasus->intf);
}

static int pegasus_probe(struct usb_interface *intf,
			 const struct usb_device_id *id)
{
	struct usb_device *dev = interface_to_usbdev(intf);
	struct usb_endpoint_descriptor *endpoint;
	struct pegasus *pegasus;
	struct input_dev *input_dev;
	int error;
	int pipe;

	/* We control interface 0 */
	if (intf->cur_altsetting->desc.bInterfaceNumber >= 1)
		return -ENODEV;

	/* Sanity check that the device has an endpoint */
	if (intf->altsetting[0].desc.bNumEndpoints < 1) {
		dev_err(&intf->dev, "Invalid number of endpoints\n");
		return -EINVAL;
	}

	endpoint = &intf->cur_altsetting->endpoint[0].desc;

	pegasus = kzalloc(sizeof(*pegasus), GFP_KERNEL);
	input_dev = input_allocate_device();
	if (!pegasus || !input_dev) {
		error = -ENOMEM;
		goto err_free_mem;
	}

	pegasus->usbdev = dev;
	pegasus->dev = input_dev;
	pegasus->intf = intf;

	pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);
	pegasus->data_len = usb_maxpacket(dev, pipe, usb_pipeout(pipe));

	pegasus->data = usb_alloc_coherent(dev, pegasus->data_len, GFP_KERNEL,
					   &pegasus->data_dma);
	if (!pegasus->data) {
		error = -ENOMEM;
		goto err_free_mem;
	}

	pegasus->irq = usb_alloc_urb(0, GFP_KERNEL);
	if (!pegasus->irq) {
		error = -ENOMEM;
		goto err_free_dma;
	}

	usb_fill_int_urb(pegasus->irq, dev, pipe,
			 pegasus->data, pegasus->data_len,
			 pegasus_irq, pegasus, endpoint->bInterval);

	pegasus->irq->transfer_dma = pegasus->data_dma;
	pegasus->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;

	if (dev->manufacturer)
		strlcpy(pegasus->name, dev->manufacturer,
			sizeof(pegasus->name));

	if (dev->product) {
		if (dev->manufacturer)
			strlcat(pegasus->name, " ", sizeof(pegasus->name));
		strlcat(pegasus->name, dev->product, sizeof(pegasus->name));
	}

	if (!strlen(pegasus->name))
		snprintf(pegasus->name, sizeof(pegasus->name),
			 "USB Pegasus Device %04x:%04x",
			 le16_to_cpu(dev->descriptor.idVendor),
			 le16_to_cpu(dev->descriptor.idProduct));

	usb_make_path(dev, pegasus->phys, sizeof(pegasus->phys));
	strlcat(pegasus->phys, "/input0", sizeof(pegasus->phys));

	INIT_WORK(&pegasus->init, pegasus_init);

	usb_set_intfdata(intf, pegasus);

	input_dev->name = pegasus->name;
	input_dev->phys = pegasus->phys;
	usb_to_input_id(dev, &input_dev->id);
	input_dev->dev.parent = &intf->dev;

	input_set_drvdata(input_dev, pegasus);

	input_dev->open = pegasus_open;
	input_dev->close = pegasus_close;

	__set_bit(EV_ABS, input_dev->evbit);
	__set_bit(EV_KEY, input_dev->evbit);

	__set_bit(ABS_X, input_dev->absbit);
	__set_bit(ABS_Y, input_dev->absbit);

	__set_bit(BTN_TOUCH, input_dev->keybit);
	__set_bit(BTN_RIGHT, input_dev->keybit);
	__set_bit(BTN_TOOL_PEN, input_dev->keybit);

	__set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
	__set_bit(INPUT_PROP_POINTER, input_dev->propbit);

	input_set_abs_params(input_dev, ABS_X, -1500, 1500, 8, 0);
	input_set_abs_params(input_dev, ABS_Y, 1600, 3000, 8, 0);

	error = input_register_device(pegasus->dev);
	if (error)
		goto err_free_urb;

	return 0;

err_free_urb:
	usb_free_urb(pegasus->irq);
err_free_dma:
	usb_free_coherent(dev, pegasus->data_len,
			  pegasus->data, pegasus->data_dma);
err_free_mem:
	input_free_device(input_dev);
	kfree(pegasus);
	usb_set_intfdata(intf, NULL);

	return error;
}

static void pegasus_disconnect(struct usb_interface *intf)
{
	struct pegasus *pegasus = usb_get_intfdata(intf);

	input_unregister_device(pegasus->dev);

	usb_free_urb(pegasus->irq);
	usb_free_coherent(interface_to_usbdev(intf),
			  pegasus->data_len, pegasus->data,
			  pegasus->data_dma);

	kfree(pegasus);
	usb_set_intfdata(intf, NULL);
}

static int pegasus_suspend(struct usb_interface *intf, pm_message_t message)
{
	struct pegasus *pegasus = usb_get_intfdata(intf);

	mutex_lock(&pegasus->dev->mutex);
	usb_kill_urb(pegasus->irq);
	cancel_work_sync(&pegasus->init);
	mutex_unlock(&pegasus->dev->mutex);

	return 0;
}

static int pegasus_resume(struct usb_interface *intf)
{
	struct pegasus *pegasus = usb_get_intfdata(intf);
	int retval = 0;

	mutex_lock(&pegasus->dev->mutex);
	if (pegasus->dev->users && usb_submit_urb(pegasus->irq, GFP_NOIO) < 0)
		retval = -EIO;
	mutex_unlock(&pegasus->dev->mutex);

	return retval;
}

static int pegasus_reset_resume(struct usb_interface *intf)
{
	struct pegasus *pegasus = usb_get_intfdata(intf);
	int retval = 0;

	mutex_lock(&pegasus->dev->mutex);
	if (pegasus->dev->users) {
		retval = pegasus_set_mode(pegasus, PEN_MODE_XY,
					  NOTETAKER_LED_MOUSE);
		if (!retval && usb_submit_urb(pegasus->irq, GFP_NOIO) < 0)
			retval = -EIO;
	}
	mutex_unlock(&pegasus->dev->mutex);

	return retval;
}

static const struct usb_device_id pegasus_ids[] = {
	{ USB_DEVICE(USB_VENDOR_ID_PEGASUSTECH,
		     USB_DEVICE_ID_PEGASUS_NOTETAKER_EN100) },
	{ }
};
MODULE_DEVICE_TABLE(usb, pegasus_ids);

static struct usb_driver pegasus_driver = {
	.name		= "pegasus_notetaker",
	.probe		= pegasus_probe,
	.disconnect	= pegasus_disconnect,
	.suspend	= pegasus_suspend,
	.resume		= pegasus_resume,
	.reset_resume	= pegasus_reset_resume,
	.id_table	= pegasus_ids,
	.supports_autosuspend = 1,
};

module_usb_driver(pegasus_driver);

MODULE_AUTHOR("Martin Kepplinger <martink@posteo.de>");
MODULE_DESCRIPTION("Pegasus Mobile Notetaker Pen tablet driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
1afca2b6 MK	1	/*
	2	* Pegasus Mobile Notetaker Pen input tablet driver
	3	*
	4	* Copyright (c) 2016 Martin Kepplinger <martink@posteo.de>
	5	*/
	6
	7	/*
	8	* request packet (control endpoint):
	9	* \|-------------------------------------\|
	10	* \| Report ID \| Nr of bytes \| command \|
	11	* \| (1 byte) \| (1 byte) \| (n bytes) \|
	12	* \|-------------------------------------\|
	13	* \| 0x02 \| n \| \|
	14	* \|-------------------------------------\|
	15	*
	16	* data packet after set xy mode command, 0x80 0xb5 0x02 0x01
	17	* and pen is in range:
	18	*
	19	* byte byte name value (bits)
	20	* --------------------------------------------
	21	* 0 status 0 1 0 0 0 0 X X
	22	* 1 color 0 0 0 0 H 0 S T
	23	* 2 X low
	24	* 3 X high
	25	* 4 Y low
	26	* 5 Y high
	27	*
	28	* X X battery state:
	29	* no state reported 0x00
	30	* battery low 0x01
	31	* battery good 0x02
	32	*
	33	* H Hovering
	34	* S Switch 1 (pen button)
	35	* T Tip
	36	*/
	37
	38	#include <linux/kernel.h>
	39	#include <linux/module.h>
	40	#include <linux/input.h>
	41	#include <linux/usb/input.h>
	42	#include <linux/slab.h>
	43
	44	/* USB HID defines */
	45	#define USB_REQ_GET_REPORT 0x01
	46	#define USB_REQ_SET_REPORT 0x09
	47
	48	#define USB_VENDOR_ID_PEGASUSTECH 0x0e20
	49	#define USB_DEVICE_ID_PEGASUS_NOTETAKER_EN100 0x0101
	50
	51	/* device specific defines */
	52	#define NOTETAKER_REPORT_ID 0x02
	53	#define NOTETAKER_SET_CMD 0x80
	54	#define NOTETAKER_SET_MODE 0xb5
	55
	56	#define NOTETAKER_LED_MOUSE 0x02
	57	#define PEN_MODE_XY 0x01
	58
	59	#define SPECIAL_COMMAND 0x80
	60	#define BUTTON_PRESSED 0xb5
	61	#define COMMAND_VERSION 0xa9
	62
	63	/* in xy data packet */
	64	#define BATTERY_NO_REPORT 0x40
65	#define BATTERY_LOW 0x41
66	#define BATTERY_GOOD 0x42
67	#define PEN_BUTTON_PRESSED BIT(1)
68	#define PEN_TIP BIT(0)
69
70	struct pegasus {
71	unsigned char *data;
72	u8 data_len;
73	dma_addr_t data_dma;
74	struct input_dev *dev;
75	struct usb_device *usbdev;
76	struct usb_interface *intf;
77	struct urb *irq;
78	char name[128];
79	char phys[64];
80	struct work_struct init;
81	};
82
168c1398	83	static int pegasus_control_msg(struct pegasus pegasus, u8 data, int len)
1afca2b6 MK	84	{
	85	const int sizeof_buf = len + 2;
	86	int result;
168c1398	87	int error;
1afca2b6 MK	88	u8 *cmd_buf;
	89
	90	cmd_buf = kmalloc(sizeof_buf, GFP_KERNEL);
	91	if (!cmd_buf)
168c1398	92	return -ENOMEM;
1afca2b6 MK	93
	94	cmd_buf[0] = NOTETAKER_REPORT_ID;
	95	cmd_buf[1] = len;
	96	memcpy(cmd_buf + 2, data, len);
	97
	98	result = usb_control_msg(pegasus->usbdev,
	99	usb_sndctrlpipe(pegasus->usbdev, 0),
	100	USB_REQ_SET_REPORT,
	101	USB_TYPE_VENDOR \| USB_DIR_OUT,
	102	0, 0, cmd_buf, sizeof_buf,
	103	USB_CTRL_SET_TIMEOUT);
	104
1afca2b6	105	kfree(cmd_buf);
168c1398 MK	106
	107	if (unlikely(result != sizeof_buf)) {
	108	error = result < 0 ? result : -EIO;
	109	dev_err(&pegasus->usbdev->dev, "control msg error: %d\n",
	110	error);
	111	return error;
	112	}
	113
	114	return 0;
1afca2b6 MK	115	}
1afca2b6 MK	116
168c1398	117	static int pegasus_set_mode(struct pegasus *pegasus, u8 mode, u8 led)
1afca2b6 MK	118	{
	119	u8 cmd[] = { NOTETAKER_SET_CMD, NOTETAKER_SET_MODE, led, mode };
	120
168c1398	121	return pegasus_control_msg(pegasus, cmd, sizeof(cmd));
1afca2b6 MK	122	}
	123
	124	static void pegasus_parse_packet(struct pegasus *pegasus)
	125	{
	126	unsigned char *data = pegasus->data;
	127	struct input_dev *dev = pegasus->dev;
	128	u16 x, y;
	129
	130	switch (data[0]) {
	131	case SPECIAL_COMMAND:
	132	/* device button pressed */
	133	if (data[1] == BUTTON_PRESSED)
	134	schedule_work(&pegasus->init);
	135
	136	break;
	137
	138	/* xy data */
	139	case BATTERY_LOW:
	140	dev_warn_once(&dev->dev, "Pen battery low\n");
	141	/* fall through */
	142
	143	case BATTERY_NO_REPORT:
	144	case BATTERY_GOOD:
	145	x = le16_to_cpup((__le16 *)&data[2]);
	146	y = le16_to_cpup((__le16 *)&data[4]);
	147
	148	/* pen-up event */
	149	if (x == 0 && y == 0)
	150	break;
	151
	152	input_report_key(dev, BTN_TOUCH, data[1] & PEN_TIP);
	153	input_report_key(dev, BTN_RIGHT, data[1] & PEN_BUTTON_PRESSED);
	154	input_report_key(dev, BTN_TOOL_PEN, 1);
	155	input_report_abs(dev, ABS_X, (s16)x);
	156	input_report_abs(dev, ABS_Y, y);
	157
	158	input_sync(dev);
	159	break;
	160
	161	default:
	162	dev_warn_once(&pegasus->usbdev->dev,
	163	"unknown answer from device\n");
	164	}
	165	}
	166
	167	static void pegasus_irq(struct urb *urb)
	168	{
	169	struct pegasus *pegasus = urb->context;
	170	struct usb_device *dev = pegasus->usbdev;
	171	int retval;
	172
	173	switch (urb->status) {
	174	case 0:
	175	pegasus_parse_packet(pegasus);
	176	usb_mark_last_busy(pegasus->usbdev);
	177	break;
	178
	179	case -ECONNRESET:
	180	case -ENOENT:
	181	case -ESHUTDOWN:
	182	dev_err(&dev->dev, "%s - urb shutting down with status: %d",
	183	__func__, urb->status);
	184	return;
	185
186	default:
187	dev_err(&dev->dev, "%s - nonzero urb status received: %d",
188	__func__, urb->status);
189	break;
190	}
191
192	retval = usb_submit_urb(urb, GFP_ATOMIC);
193	if (retval)
194	dev_err(&dev->dev, "%s - usb_submit_urb failed with result %d",
195	__func__, retval);
196	}
197
198	static void pegasus_init(struct work_struct *work)
199	{
200	struct pegasus *pegasus = container_of(work, struct pegasus, init);
168c1398	201	int error;
1afca2b6	202
168c1398 MK	203	error = pegasus_set_mode(pegasus, PEN_MODE_XY, NOTETAKER_LED_MOUSE);
	204	if (error)
	205	dev_err(&pegasus->usbdev->dev, "pegasus_set_mode error: %d\n",
	206	error);
1afca2b6 MK	207	}
	208
	209	static int pegasus_open(struct input_dev *dev)
	210	{
	211	struct pegasus *pegasus = input_get_drvdata(dev);
9d3bef0b	212	int error;
1afca2b6	213
9d3bef0b MK	214	error = usb_autopm_get_interface(pegasus->intf);
	215	if (error)
	216	return error;
1afca2b6 MK	217
1afca2b6 MK	218	pegasus->irq->dev = pegasus->usbdev;
9d3bef0b MK	219	if (usb_submit_urb(pegasus->irq, GFP_KERNEL)) {
	220	error = -EIO;
	221	goto err_autopm_put;
	222	}
1afca2b6	223
9d3bef0b MK	224	error = pegasus_set_mode(pegasus, PEN_MODE_XY, NOTETAKER_LED_MOUSE);
	225	if (error)
	226	goto err_kill_urb;
1afca2b6	227
9d3bef0b	228	return 0;
1afca2b6	229
9d3bef0b MK	230	err_kill_urb:
	231	usb_kill_urb(pegasus->irq);
	232	cancel_work_sync(&pegasus->init);
	233	err_autopm_put:
	234	usb_autopm_put_interface(pegasus->intf);
	235	return error;
1afca2b6 MK	236	}
	237
	238	static void pegasus_close(struct input_dev *dev)
	239	{
	240	struct pegasus *pegasus = input_get_drvdata(dev);
1afca2b6	241
1afca2b6 MK	242	usb_kill_urb(pegasus->irq);
1afca2b6 MK	243	cancel_work_sync(&pegasus->init);
9d3bef0b	244	usb_autopm_put_interface(pegasus->intf);
1afca2b6 MK	245	}
	246
	247	static int pegasus_probe(struct usb_interface *intf,
	248	const struct usb_device_id *id)
	249	{
	250	struct usb_device *dev = interface_to_usbdev(intf);
	251	struct usb_endpoint_descriptor *endpoint;
	252	struct pegasus *pegasus;
	253	struct input_dev *input_dev;
	254	int error;
	255	int pipe;
	256
	257	/* We control interface 0 */
	258	if (intf->cur_altsetting->desc.bInterfaceNumber >= 1)
	259	return -ENODEV;
	260
	261	/* Sanity check that the device has an endpoint */
	262	if (intf->altsetting[0].desc.bNumEndpoints < 1) {
	263	dev_err(&intf->dev, "Invalid number of endpoints\n");
	264	return -EINVAL;
	265	}
	266
	267	endpoint = &intf->cur_altsetting->endpoint[0].desc;
	268
	269	pegasus = kzalloc(sizeof(*pegasus), GFP_KERNEL);
	270	input_dev = input_allocate_device();
	271	if (!pegasus \|\| !input_dev) {
	272	error = -ENOMEM;
	273	goto err_free_mem;
	274	}
	275
	276	pegasus->usbdev = dev;
	277	pegasus->dev = input_dev;
	278	pegasus->intf = intf;
	279
	280	pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);
	281	pegasus->data_len = usb_maxpacket(dev, pipe, usb_pipeout(pipe));
	282
	283	pegasus->data = usb_alloc_coherent(dev, pegasus->data_len, GFP_KERNEL,
	284	&pegasus->data_dma);
	285	if (!pegasus->data) {
	286	error = -ENOMEM;
	287	goto err_free_mem;
	288	}
	289
	290	pegasus->irq = usb_alloc_urb(0, GFP_KERNEL);
	291	if (!pegasus->irq) {
	292	error = -ENOMEM;
	293	goto err_free_dma;
	294	}
	295
	296	usb_fill_int_urb(pegasus->irq, dev, pipe,
	297	pegasus->data, pegasus->data_len,
	298	pegasus_irq, pegasus, endpoint->bInterval);
	299
	300	pegasus->irq->transfer_dma = pegasus->data_dma;
	301	pegasus->irq->transfer_flags \|= URB_NO_TRANSFER_DMA_MAP;
	302
	303	if (dev->manufacturer)
	304	strlcpy(pegasus->name, dev->manufacturer,
	305	sizeof(pegasus->name));
	306
	307	if (dev->product) {
	308	if (dev->manufacturer)
309	strlcat(pegasus->name, " ", sizeof(pegasus->name));
310	strlcat(pegasus->name, dev->product, sizeof(pegasus->name));
311	}
312
313	if (!strlen(pegasus->name))
314	snprintf(pegasus->name, sizeof(pegasus->name),
315	"USB Pegasus Device %04x:%04x",
316	le16_to_cpu(dev->descriptor.idVendor),
317	le16_to_cpu(dev->descriptor.idProduct));
318
319	usb_make_path(dev, pegasus->phys, sizeof(pegasus->phys));
320	strlcat(pegasus->phys, "/input0", sizeof(pegasus->phys));
321
322	INIT_WORK(&pegasus->init, pegasus_init);
323
324	usb_set_intfdata(intf, pegasus);
325
326	input_dev->name = pegasus->name;
327	input_dev->phys = pegasus->phys;
328	usb_to_input_id(dev, &input_dev->id);
329	input_dev->dev.parent = &intf->dev;
330
331	input_set_drvdata(input_dev, pegasus);
332
333	input_dev->open = pegasus_open;
334	input_dev->close = pegasus_close;
335
336	__set_bit(EV_ABS, input_dev->evbit);
337	__set_bit(EV_KEY, input_dev->evbit);
338
339	__set_bit(ABS_X, input_dev->absbit);
340	__set_bit(ABS_Y, input_dev->absbit);
341
342	__set_bit(BTN_TOUCH, input_dev->keybit);
343	__set_bit(BTN_RIGHT, input_dev->keybit);
344	__set_bit(BTN_TOOL_PEN, input_dev->keybit);
345
346	__set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
347	__set_bit(INPUT_PROP_POINTER, input_dev->propbit);
348
349	input_set_abs_params(input_dev, ABS_X, -1500, 1500, 8, 0);
350	input_set_abs_params(input_dev, ABS_Y, 1600, 3000, 8, 0);
351
352	error = input_register_device(pegasus->dev);
353	if (error)
354	goto err_free_urb;
355
356	return 0;
357
358	err_free_urb:
359	usb_free_urb(pegasus->irq);
360	err_free_dma:
361	usb_free_coherent(dev, pegasus->data_len,
362	pegasus->data, pegasus->data_dma);
363	err_free_mem:
364	input_free_device(input_dev);
365	kfree(pegasus);
366	usb_set_intfdata(intf, NULL);
367
368	return error;
369	}
370
371	static void pegasus_disconnect(struct usb_interface *intf)
372	{
373	struct pegasus *pegasus = usb_get_intfdata(intf);
374
375	input_unregister_device(pegasus->dev);
376
377	usb_free_urb(pegasus->irq);
378	usb_free_coherent(interface_to_usbdev(intf),
379	pegasus->data_len, pegasus->data,
380	pegasus->data_dma);
381
382	kfree(pegasus);
383	usb_set_intfdata(intf, NULL);
384	}
385
386	static int pegasus_suspend(struct usb_interface *intf, pm_message_t message)
387	{
388	struct pegasus *pegasus = usb_get_intfdata(intf);
389
390	mutex_lock(&pegasus->dev->mutex);
391	usb_kill_urb(pegasus->irq);
f32f5394	392	cancel_work_sync(&pegasus->init);
1afca2b6 MK	393	mutex_unlock(&pegasus->dev->mutex);
	394
	395	return 0;
	396	}
	397
	398	static int pegasus_resume(struct usb_interface *intf)
	399	{
	400	struct pegasus *pegasus = usb_get_intfdata(intf);
	401	int retval = 0;
	402
	403	mutex_lock(&pegasus->dev->mutex);
	404	if (pegasus->dev->users && usb_submit_urb(pegasus->irq, GFP_NOIO) < 0)
	405	retval = -EIO;
	406	mutex_unlock(&pegasus->dev->mutex);
	407
	408	return retval;
	409	}
	410
	411	static int pegasus_reset_resume(struct usb_interface *intf)
	412	{
c1d7b7c1 MK	413	struct pegasus *pegasus = usb_get_intfdata(intf);
	414	int retval = 0;
	415
	416	mutex_lock(&pegasus->dev->mutex);
	417	if (pegasus->dev->users) {
	418	retval = pegasus_set_mode(pegasus, PEN_MODE_XY,
	419	NOTETAKER_LED_MOUSE);
	420	if (!retval && usb_submit_urb(pegasus->irq, GFP_NOIO) < 0)
	421	retval = -EIO;
	422	}
	423	mutex_unlock(&pegasus->dev->mutex);
	424
	425	return retval;
1afca2b6 MK	426	}
	427
	428	static const struct usb_device_id pegasus_ids[] = {
	429	{ USB_DEVICE(USB_VENDOR_ID_PEGASUSTECH,
	430	USB_DEVICE_ID_PEGASUS_NOTETAKER_EN100) },
	431	{ }
	432	};
	433	MODULE_DEVICE_TABLE(usb, pegasus_ids);
	434
	435	static struct usb_driver pegasus_driver = {
	436	.name = "pegasus_notetaker",
	437	.probe = pegasus_probe,
	438	.disconnect = pegasus_disconnect,
	439	.suspend = pegasus_suspend,
	440	.resume = pegasus_resume,
	441	.reset_resume = pegasus_reset_resume,
	442	.id_table = pegasus_ids,
	443	.supports_autosuspend = 1,
	444	};
	445
	446	module_usb_driver(pegasus_driver);
	447
	448	MODULE_AUTHOR("Martin Kepplinger <martink@posteo.de>");
	449	MODULE_DESCRIPTION("Pegasus Mobile Notetaker Pen tablet driver");
	450	MODULE_LICENSE("GPL");