/*
 *  Native support for the Aiptek 8000U
 *
 *  Copyright (c) 2001 Chris Atenasio		<chris@crud.net>
 *
 *  based on wacom.c by
 *     Vojtech Pavlik      <vojtech@suse.cz>
 *     Andreas Bach Aaen   <abach@stofanet.dk>
 *     Clifford Wolf       <clifford@clifford.at>
 *     Sam Mosel           <sam.mosel@computer.org>
 *     James E. Blair      <corvus@gnu.org>
 *     Daniel Egger        <egger@suse.de>
 *
 *
 *  Many thanks to Oliver Kuechemann for his support.
 *
 *  ChangeLog:
 *      v0.1 - Initial release
 *      v0.2 - Hack to get around fake event 28's.
 *      v0.3 - Make URB dynamic (Bryan W. Headley, Jun-8-2002)
 *             (kernel 2.5.x variant, June-14-2002)
 */

/*
 * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

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

/*
 * Version Information
 */
#define DRIVER_VERSION "v0.3"
#define DRIVER_AUTHOR "Chris Atenasio <chris@crud.net>"
#define DRIVER_DESC "USB Aiptek 6000U/8000U tablet driver (Linux 2.5.x)"

MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL");

/*
 * Aiptek status packet:
 *
 *        bit7  bit6  bit5  bit4  bit3  bit2  bit1  bit0
 * byte0   0     0     0     0     0     0     1     0
 * byte1  X7    X6    X5    X4    X3    X2    X1    X0
 * byte2  X15   X14   X13   X12   X11   X10   X9    X8
 * byte3  Y7    Y6    Y5    Y4    Y3    Y2    Y1    Y0
 * byte4  Y15   Y14   Y13   Y12   Y11   Y10   Y9    Y8
 * byte5   *     *     *    BS2   BS1   Tip   DV    IR
 * byte6  P7    P6    P5    P4    P3    P2    P1    P0
 * byte7  P15   P14   P13   P12   P11   P10   P9    P8
 *
 * IR: In Range = Proximity on
 * DV = Data Valid
 *
 * 
 * Command Summary:
 *
 * Command/Data    Description     Return Bytes    Return Value
 * 0x10/0x00       SwitchToMouse       0
 * 0x10/0x01       SwitchToTablet      0
 * 0x18/0x04       Resolution500LPI    0
 * 0x17/0x00       FilterOn            0
 * 0x12/0xFF       AutoGainOn          0
 * 0x01/0x00       GetXExtension       2           MaxX
 * 0x01/0x01       GetYExtension       2           MaxY
 * 0x02/0x00       GetModelCode        2           ModelCode = LOBYTE
 * 0x03/0x00       GetODMCode          2           ODMCode
 * 0x08/0x00       GetPressureLevels   2           =512
 * 0x04/0x00       GetFirmwareVersion  2           Firmware Version
 *
 *
 * To initialize the tablet:
 *
 * (1) Send command Resolution500LPI
 * (2) Option Commands (GetXExtension, GetYExtension)
 * (3) Send command SwitchToTablet
 */

#define USB_VENDOR_ID_AIPTEK   0x08ca

struct aiptek_features {
	char *name;
	int pktlen;
	int x_max;
	int y_max;
	int pressure_min;
	int pressure_max;
	usb_complete_t irq;
	unsigned long evbit;
	unsigned long absbit;
	unsigned long relbit;
	unsigned long btnbit;
	unsigned long digibit;
};

struct aiptek {
	struct input_dev dev;
	struct usb_device *usbdev;
	struct urb *irq;
	struct aiptek_features *features;
	int tool;
	int open;

	signed char *data;
	dma_addr_t data_dma;
};

static void
aiptek_irq(struct urb *urb, struct pt_regs *regs)
{
	struct aiptek *aiptek = urb->context;
	unsigned char *data = aiptek->data;
	struct input_dev *dev = &aiptek->dev;
	int x;
	int y;
	int pressure;
	int proximity;
	int retval;

	switch (urb->status) {
	case 0:
		/* success */
		break;
	case -ECONNRESET:
	case -ENOENT:
	case -ESHUTDOWN:
		/* this urb is terminated, clean up */
		dbg("%s - urb shutting down with status: %d", __FUNCTION__, urb->status);
		return;
	default:
		dbg("%s - nonzero urb status received: %d", __FUNCTION__, urb->status);
		goto exit;
	}

	if ((data[0] & 2) == 0) {
		dbg("received unknown report #%d", data[0]);
	}

	proximity = data[5] & 0x01;
	input_report_key(dev, BTN_TOOL_PEN, proximity);

	x = ((__u32) data[1]) | ((__u32) data[2] << 8);
	y = ((__u32) data[3]) | ((__u32) data[4] << 8);
	pressure = ((__u32) data[6]) | ((__u32) data[7] << 8);
	pressure -= aiptek->features->pressure_min;

	if (pressure < 0) {
		pressure = 0;
	}

	if (proximity) {
		input_report_abs(dev, ABS_X, x);
		input_report_abs(dev, ABS_Y, y);
		input_report_abs(dev, ABS_PRESSURE, pressure);
		input_report_key(dev, BTN_TOUCH, data[5] & 0x04);
		input_report_key(dev, BTN_STYLUS, data[5] & 0x08);
		input_report_key(dev, BTN_STYLUS2, data[5] & 0x10);
	}

	input_sync(dev);

exit:
	retval = usb_submit_urb (urb, GFP_ATOMIC);
	if (retval)
		err ("%s - usb_submit_urb failed with result %d",
		     __FUNCTION__, retval);
}

struct aiptek_features aiptek_features[] = {
	{"Aiptek 6000U/8000U",
	 8, 3000, 2250, 26, 511, aiptek_irq, 0, 0, 0, 0},
	{NULL, 0}
};

struct usb_device_id aiptek_ids[] = {
	{USB_DEVICE(USB_VENDOR_ID_AIPTEK, 0x20), .driver_info = 0},
	{}
};

MODULE_DEVICE_TABLE(usb, aiptek_ids);

static int
aiptek_open(struct input_dev *dev)
{
	struct aiptek *aiptek = dev->private;

	if (aiptek->open++)
		return 0;

	aiptek->irq->dev = aiptek->usbdev;
	if (usb_submit_urb(aiptek->irq, GFP_KERNEL))
		return -EIO;

	return 0;
}

static void
aiptek_close(struct input_dev *dev)
{
	struct aiptek *aiptek = dev->private;

	if (!--aiptek->open)
		usb_unlink_urb(aiptek->irq);
}

/* 
 * FIXME, either remove this call, or talk the maintainer into 
 * adding usb_set_report back into the core.
 */
#if 0
static void
aiptek_command(struct usb_device *dev, unsigned int ifnum,
	       unsigned char command, unsigned char data)
{
	__u8 buf[3];

	buf[0] = 4;
	buf[1] = command;
	buf[2] = data;

	if (usb_set_report(dev, ifnum, 3, 2, buf, 3) != 3) {
		dbg("aiptek_command: 0x%x 0x%x\n", command, data);
	}
}
#endif

static int 
aiptek_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 aiptek *aiptek;

	if (!(aiptek = kmalloc(sizeof (struct aiptek), GFP_KERNEL)))
		return -ENOMEM;

	memset(aiptek, 0, sizeof (struct aiptek));

	aiptek->data = usb_buffer_alloc(dev, 10, SLAB_ATOMIC, &aiptek->data_dma);
	if (!aiptek->data) {
		kfree(aiptek);
		return -ENOMEM;
	}

	aiptek->irq = usb_alloc_urb(0, GFP_KERNEL);
	if (!aiptek->irq) {
		usb_buffer_free(dev, 10, aiptek->data, aiptek->data_dma);
		kfree(aiptek);
		return -ENOMEM;
	}

	// Resolution500LPI
//	aiptek_command(dev, ifnum, 0x18, 0x04);

	// SwitchToTablet
//	aiptek_command(dev, ifnum, 0x10, 0x01);

	aiptek->features = aiptek_features + id->driver_info;

	aiptek->dev.evbit[0] |= BIT(EV_KEY) | BIT(EV_ABS) | BIT(EV_MSC) |
	    aiptek->features->evbit;

	aiptek->dev.absbit[0] |= BIT(ABS_X) | BIT(ABS_Y) | BIT(ABS_PRESSURE) |
	    BIT(ABS_MISC) | aiptek->features->absbit;

	aiptek->dev.relbit[0] |= aiptek->features->relbit;

	aiptek->dev.keybit[LONG(BTN_LEFT)] |= BIT(BTN_LEFT) | BIT(BTN_RIGHT) |
	    BIT(BTN_MIDDLE) | aiptek->features->btnbit;

	aiptek->dev.keybit[LONG(BTN_DIGI)] |= BIT(BTN_TOOL_PEN) |
	    BIT(BTN_TOOL_MOUSE) | BIT(BTN_TOUCH) |
	    BIT(BTN_STYLUS) | BIT(BTN_STYLUS2) | aiptek->features->digibit;

	aiptek->dev.mscbit[0] = BIT(MSC_SERIAL);

	aiptek->dev.absmax[ABS_X] = aiptek->features->x_max;
	aiptek->dev.absmax[ABS_Y] = aiptek->features->y_max;
	aiptek->dev.absmax[ABS_PRESSURE] = aiptek->features->pressure_max -
	    aiptek->features->pressure_min;

	aiptek->dev.absfuzz[ABS_X] = 0;
	aiptek->dev.absfuzz[ABS_Y] = 0;

	aiptek->dev.private = aiptek;
	aiptek->dev.open = aiptek_open;
	aiptek->dev.close = aiptek_close;

	aiptek->dev.name = aiptek->features->name;
	aiptek->dev.id.bustype = BUS_USB;
	aiptek->dev.id.vendor = dev->descriptor.idVendor;
	aiptek->dev.id.product = dev->descriptor.idProduct;
	aiptek->dev.id.version = dev->descriptor.bcdDevice;
	aiptek->usbdev = dev;

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

	if (aiptek->features->pktlen > 10)
		BUG();

	usb_fill_int_urb(aiptek->irq, dev,
			 usb_rcvintpipe(dev, endpoint->bEndpointAddress),
			 aiptek->data, aiptek->features->pktlen,
			 aiptek->features->irq, aiptek, endpoint->bInterval);
	aiptek->irq->transfer_dma = aiptek->data_dma;
	aiptek->irq->transfer_flags |= URB_NO_DMA_MAP;

	input_register_device(&aiptek->dev);

	printk(KERN_INFO "input: %s on usb%d:%d\n",
	       aiptek->features->name, dev->bus->busnum, dev->devnum);

	usb_set_intfdata(intf, aiptek);
	return 0;
}

static void
aiptek_disconnect(struct usb_interface *intf)
{
	struct aiptek *aiptek  = usb_get_intfdata (intf);

	usb_set_intfdata(intf, NULL);
	if (aiptek) {
		usb_unlink_urb(aiptek->irq);
		input_unregister_device(&aiptek->dev);
		usb_free_urb(aiptek->irq);
		usb_buffer_free(interface_to_usbdev(intf), 10, aiptek->data, aiptek->data_dma);
		kfree(aiptek);
	}
}

static struct usb_driver aiptek_driver = {
	.name =		"aiptek",
	.probe =	aiptek_probe,
	.disconnect =	aiptek_disconnect,
	.id_table =	aiptek_ids,
};

static int __init
aiptek_init(void)
{
	usb_register(&aiptek_driver);
	info(DRIVER_VERSION " " DRIVER_AUTHOR);
	info(DRIVER_DESC);
	return 0;
}

static void __exit
aiptek_exit(void)
{
	usb_deregister(&aiptek_driver);
}

module_init(aiptek_init);
module_exit(aiptek_exit);