1/*
   2 * Apple USB Touchpad (for post-February 2005 PowerBooks and MacBooks) driver
   3 *
   4 * Copyright (C) 2001-2004 Greg Kroah-Hartman (greg@kroah.com)
   5 * Copyright (C) 2005-2008 Johannes Berg (johannes@sipsolutions.net)
   6 * Copyright (C) 2005-2008 Stelian Pop (stelian@popies.net)
   7 * Copyright (C) 2005      Frank Arnold (frank@scirocco-5v-turbo.de)
   8 * Copyright (C) 2005      Peter Osterlund (petero2@telia.com)
   9 * Copyright (C) 2005      Michael Hanselmann (linux-kernel@hansmi.ch)
  10 * Copyright (C) 2006      Nicolas Boichat (nicolas@boichat.ch)
  11 * Copyright (C) 2007-2008 Sven Anders (anders@anduras.de)
  12 *
  13 * Thanks to Alex Harper <basilisk@foobox.net> for his inputs.
  14 *
  15 * This program is free software; you can redistribute it and/or modify
  16 * it under the terms of the GNU General Public License as published by
  17 * the Free Software Foundation; either version 2 of the License, or
  18 * (at your option) any later version.
  19 *
  20 * This program is distributed in the hope that it will be useful,
  21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23 * GNU General Public License for more details.
  24 *
  25 * You should have received a copy of the GNU General Public License
  26 * along with this program; if not, write to the Free Software
  27 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  28 *
  29 */
  30
  31#include <linux/kernel.h>
  32#include <linux/errno.h>
  33#include <linux/slab.h>
  34#include <linux/module.h>
  35#include <linux/usb/input.h>
  36
  37/*
  38 * Note: We try to keep the touchpad aspect ratio while still doing only
  39 * simple arithmetics:
  40 *	0 <= x <= (xsensors - 1) * xfact
  41 *	0 <= y <= (ysensors - 1) * yfact
  42 */
  43struct atp_info {
  44	int xsensors;				/* number of X sensors */
  45	int xsensors_17;			/* 17" models have more sensors */
  46	int ysensors;				/* number of Y sensors */
  47	int xfact;				/* X multiplication factor */
  48	int yfact;				/* Y multiplication factor */
  49	int datalen;				/* size of USB transfers */
  50	void (*callback)(struct urb *);		/* callback function */
  51	int fuzz;				/* fuzz touchpad generates */
  52};
  53
  54static void atp_complete_geyser_1_2(struct urb *urb);
  55static void atp_complete_geyser_3_4(struct urb *urb);
  56
  57static const struct atp_info fountain_info = {
  58	.xsensors	= 16,
  59	.xsensors_17	= 26,
  60	.ysensors	= 16,
  61	.xfact		= 64,
  62	.yfact		= 43,
  63	.datalen	= 81,
  64	.callback	= atp_complete_geyser_1_2,
  65	.fuzz		= 16,
  66};
  67
  68static const struct atp_info geyser1_info = {
  69	.xsensors	= 16,
  70	.xsensors_17	= 26,
  71	.ysensors	= 16,
  72	.xfact		= 64,
  73	.yfact		= 43,
  74	.datalen	= 81,
  75	.callback	= atp_complete_geyser_1_2,
  76	.fuzz		= 16,
  77};
  78
  79static const struct atp_info geyser2_info = {
  80	.xsensors	= 15,
  81	.xsensors_17	= 20,
  82	.ysensors	= 9,
  83	.xfact		= 64,
  84	.yfact		= 43,
  85	.datalen	= 64,
  86	.callback	= atp_complete_geyser_1_2,
  87	.fuzz		= 0,
  88};
  89
  90static const struct atp_info geyser3_info = {
  91	.xsensors	= 20,
  92	.ysensors	= 10,
  93	.xfact		= 64,
  94	.yfact		= 64,
  95	.datalen	= 64,
  96	.callback	= atp_complete_geyser_3_4,
  97	.fuzz		= 0,
  98};
  99
 100static const struct atp_info geyser4_info = {
 101	.xsensors	= 20,
 102	.ysensors	= 10,
 103	.xfact		= 64,
 104	.yfact		= 64,
 105	.datalen	= 64,
 106	.callback	= atp_complete_geyser_3_4,
 107	.fuzz		= 0,
 108};
 109
 110#define ATP_DEVICE(prod, info)					\
 111{								\
 112	.match_flags = USB_DEVICE_ID_MATCH_DEVICE |		\
 113		       USB_DEVICE_ID_MATCH_INT_CLASS |		\
 114		       USB_DEVICE_ID_MATCH_INT_PROTOCOL,	\
 115	.idVendor = 0x05ac, /* Apple */				\
 116	.idProduct = (prod),					\
 117	.bInterfaceClass = 0x03,				\
 118	.bInterfaceProtocol = 0x02,				\
 119	.driver_info = (unsigned long) &info,			\
 120}
 121
 122/*
 123 * Table of devices (Product IDs) that work with this driver.
 124 * (The names come from Info.plist in AppleUSBTrackpad.kext,
 125 *  According to Info.plist Geyser IV is the same as Geyser III.)
 126 */
 127
 128static struct usb_device_id atp_table[] = {
 129	/* PowerBooks Feb 2005, iBooks G4 */
 130	ATP_DEVICE(0x020e, fountain_info),	/* FOUNTAIN ANSI */
 131	ATP_DEVICE(0x020f, fountain_info),	/* FOUNTAIN ISO */
 132	ATP_DEVICE(0x030a, fountain_info),	/* FOUNTAIN TP ONLY */
 133	ATP_DEVICE(0x030b, geyser1_info),	/* GEYSER 1 TP ONLY */
 134
 135	/* PowerBooks Oct 2005 */
 136	ATP_DEVICE(0x0214, geyser2_info),	/* GEYSER 2 ANSI */
 137	ATP_DEVICE(0x0215, geyser2_info),	/* GEYSER 2 ISO */
 138	ATP_DEVICE(0x0216, geyser2_info),	/* GEYSER 2 JIS */
 139
 140	/* Core Duo MacBook & MacBook Pro */
 141	ATP_DEVICE(0x0217, geyser3_info),	/* GEYSER 3 ANSI */
 142	ATP_DEVICE(0x0218, geyser3_info),	/* GEYSER 3 ISO */
 143	ATP_DEVICE(0x0219, geyser3_info),	/* GEYSER 3 JIS */
 144
 145	/* Core2 Duo MacBook & MacBook Pro */
 146	ATP_DEVICE(0x021a, geyser4_info),	/* GEYSER 4 ANSI */
 147	ATP_DEVICE(0x021b, geyser4_info),	/* GEYSER 4 ISO */
 148	ATP_DEVICE(0x021c, geyser4_info),	/* GEYSER 4 JIS */
 149
 150	/* Core2 Duo MacBook3,1 */
 151	ATP_DEVICE(0x0229, geyser4_info),	/* GEYSER 4 HF ANSI */
 152	ATP_DEVICE(0x022a, geyser4_info),	/* GEYSER 4 HF ISO */
 153	ATP_DEVICE(0x022b, geyser4_info),	/* GEYSER 4 HF JIS */
 154
 155	/* Terminating entry */
 156	{ }
 157};
 158MODULE_DEVICE_TABLE(usb, atp_table);
 159
 160/* maximum number of sensors */
 161#define ATP_XSENSORS	26
 162#define ATP_YSENSORS	16
 163
 164/*
 165 * The largest possible bank of sensors with additional buffer of 4 extra values
 166 * on either side, for an array of smoothed sensor values.
 167 */
 168#define ATP_SMOOTHSIZE	34
 169
 170/* maximum pressure this driver will report */
 171#define ATP_PRESSURE	300
 172
 173/*
 174 * Threshold for the touchpad sensors. Any change less than ATP_THRESHOLD is
 175 * ignored.
 176 */
 177#define ATP_THRESHOLD	5
 178
 179/*
 180 * How far we'll bitshift our sensor values before averaging them. Mitigates
 181 * rounding errors.
 182 */
 183#define ATP_SCALE	12
 184
 185/* Geyser initialization constants */
 186#define ATP_GEYSER_MODE_READ_REQUEST_ID		1
 187#define ATP_GEYSER_MODE_WRITE_REQUEST_ID	9
 188#define ATP_GEYSER_MODE_REQUEST_VALUE		0x300
 189#define ATP_GEYSER_MODE_REQUEST_INDEX		0
 190#define ATP_GEYSER_MODE_VENDOR_VALUE		0x04
 191
 192/**
 193 * enum atp_status_bits - status bit meanings
 194 *
 195 * These constants represent the meaning of the status bits.
 196 * (only Geyser 3/4)
 197 *
 198 * @ATP_STATUS_BUTTON: The button was pressed
 199 * @ATP_STATUS_BASE_UPDATE: Update of the base values (untouched pad)
 200 * @ATP_STATUS_FROM_RESET: Reset previously performed
 201 */
 202enum atp_status_bits {
 203	ATP_STATUS_BUTTON	= BIT(0),
 204	ATP_STATUS_BASE_UPDATE	= BIT(2),
 205	ATP_STATUS_FROM_RESET	= BIT(4),
 206};
 207
 208/* Structure to hold all of our device specific stuff */
 209struct atp {
 210	char			phys[64];
 211	struct usb_device	*udev;		/* usb device */
 212	struct usb_interface	*intf;		/* usb interface */
 213	struct urb		*urb;		/* usb request block */
 214	u8			*data;		/* transferred data */
 215	struct input_dev	*input;		/* input dev */
 216	const struct atp_info	*info;		/* touchpad model */
 217	bool			open;
 218	bool			valid;		/* are the samples valid? */
 219	bool			size_detect_done;
 220	bool			overflow_warned;
 221	int			fingers_old;	/* last reported finger count */
 222	int			x_old;		/* last reported x/y, */
 223	int			y_old;		/* used for smoothing */
 224	signed char		xy_cur[ATP_XSENSORS + ATP_YSENSORS];
 225	signed char		xy_old[ATP_XSENSORS + ATP_YSENSORS];
 226	int			xy_acc[ATP_XSENSORS + ATP_YSENSORS];
 227	int			smooth[ATP_SMOOTHSIZE];
 228	int			smooth_tmp[ATP_SMOOTHSIZE];
 229	int			idlecount;	/* number of empty packets */
 230	struct work_struct	work;
 231};
 232
 233#define dbg_dump(msg, tab) \
 234	if (debug > 1) {						\
 235		int __i;						\
 236		printk(KERN_DEBUG "appletouch: %s", msg);		\
 237		for (__i = 0; __i < ATP_XSENSORS + ATP_YSENSORS; __i++)	\
 238			printk(" %02x", tab[__i]);			\
 239		printk("\n");						\
 240	}
 241
 242#define dprintk(format, a...)						\
 243	do {								\
 244		if (debug)						\
 245			printk(KERN_DEBUG format, ##a);			\
 246	} while (0)
 247
 248MODULE_AUTHOR("Johannes Berg");
 249MODULE_AUTHOR("Stelian Pop");
 250MODULE_AUTHOR("Frank Arnold");
 251MODULE_AUTHOR("Michael Hanselmann");
 252MODULE_AUTHOR("Sven Anders");
 253MODULE_DESCRIPTION("Apple PowerBook and MacBook USB touchpad driver");
 254MODULE_LICENSE("GPL");
 255
 256/*
 257 * Make the threshold a module parameter
 258 */
 259static int threshold = ATP_THRESHOLD;
 260module_param(threshold, int, 0644);
 261MODULE_PARM_DESC(threshold, "Discard any change in data from a sensor"
 262			    " (the trackpad has many of these sensors)"
 263			    " less than this value.");
 264
 265static int debug;
 266module_param(debug, int, 0644);
 267MODULE_PARM_DESC(debug, "Activate debugging output");
 268
 269/*
 270 * By default newer Geyser devices send standard USB HID mouse
 271 * packets (Report ID 2). This code changes device mode, so it
 272 * sends raw sensor reports (Report ID 5).
 273 */
 274static int atp_geyser_init(struct atp *dev)
 275{
 276	struct usb_device *udev = dev->udev;
 277	char *data;
 278	int size;
 279	int i;
 280	int ret;
 281
 282	data = kmalloc(8, GFP_KERNEL);
 283	if (!data) {
 284		dev_err(&dev->intf->dev, "Out of memory\n");
 285		return -ENOMEM;
 286	}
 287
 288	size = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
 289			ATP_GEYSER_MODE_READ_REQUEST_ID,
 290			USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
 291			ATP_GEYSER_MODE_REQUEST_VALUE,
 292			ATP_GEYSER_MODE_REQUEST_INDEX, data, 8, 5000);
 293
 294	if (size != 8) {
 295		dprintk("atp_geyser_init: read error\n");
 296		for (i = 0; i < 8; i++)
 297			dprintk("appletouch[%d]: %d\n", i, data[i]);
 298
 299		dev_err(&dev->intf->dev, "Failed to read mode from device.\n");
 300		ret = -EIO;
 301		goto out_free;
 302	}
 303
 304	/* Apply the mode switch */
 305	data[0] = ATP_GEYSER_MODE_VENDOR_VALUE;
 306
 307	size = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
 308			ATP_GEYSER_MODE_WRITE_REQUEST_ID,
 309			USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
 310			ATP_GEYSER_MODE_REQUEST_VALUE,
 311			ATP_GEYSER_MODE_REQUEST_INDEX, data, 8, 5000);
 312
 313	if (size != 8) {
 314		dprintk("atp_geyser_init: write error\n");
 315		for (i = 0; i < 8; i++)
 316			dprintk("appletouch[%d]: %d\n", i, data[i]);
 317
 318		dev_err(&dev->intf->dev, "Failed to request geyser raw mode\n");
 319		ret = -EIO;
 320		goto out_free;
 321	}
 322	ret = 0;
 323out_free:
 324	kfree(data);
 325	return ret;
 326}
 327
 328/*
 329 * Reinitialise the device. This usually stops stream of empty packets
 330 * coming from it.
 331 */
 332static void atp_reinit(struct work_struct *work)
 333{
 334	struct atp *dev = container_of(work, struct atp, work);
 335	int retval;
 336
 337	dprintk("appletouch: putting appletouch to sleep (reinit)\n");
 338	atp_geyser_init(dev);
 339
 340	retval = usb_submit_urb(dev->urb, GFP_ATOMIC);
 341	if (retval)
 342		dev_err(&dev->intf->dev,
 343			"atp_reinit: usb_submit_urb failed with error %d\n",
 344			retval);
 345}
 346
 347static int atp_calculate_abs(struct atp *dev, int offset, int nb_sensors,
 348			     int fact, int *z, int *fingers)
 349{
 350	int i, pass;
 351
 352	/*
 353	 * Use offset to point xy_sensors at the first value in dev->xy_acc
 354	 * for whichever dimension we're looking at this particular go-round.
 355	 */
 356	int *xy_sensors = dev->xy_acc + offset;
 357
 358	/* values to calculate mean */
 359	int pcum = 0, psum = 0;
 360	int is_increasing = 0;
 361
 362	*fingers = 0;
 363
 364	for (i = 0; i < nb_sensors; i++) {
 365		if (xy_sensors[i] < threshold) {
 366			if (is_increasing)
 367				is_increasing = 0;
 368
 369		/*
 370		 * Makes the finger detection more versatile.  For example,
 371		 * two fingers with no gap will be detected.  Also, my
 372		 * tests show it less likely to have intermittent loss
 373		 * of multiple finger readings while moving around (scrolling).
 374		 *
 375		 * Changes the multiple finger detection to counting humps on
 376		 * sensors (transitions from nonincreasing to increasing)
 377		 * instead of counting transitions from low sensors (no
 378		 * finger reading) to high sensors (finger above
 379		 * sensor)
 380		 *
 381		 * - Jason Parekh <jasonparekh@gmail.com>
 382		 */
 383
 384		} else if (i < 1 ||
 385		    (!is_increasing && xy_sensors[i - 1] < xy_sensors[i])) {
 386			(*fingers)++;
 387			is_increasing = 1;
 388		} else if (i > 0 && (xy_sensors[i - 1] - xy_sensors[i] > threshold)) {
 389			is_increasing = 0;
 390		}
 391	}
 392
 393	if (*fingers < 1)     /* No need to continue if no fingers are found. */
 394		return 0;
 395
 396	/*
 397	 * Use a smoothed version of sensor data for movement calculations, to
 398	 * combat noise without needing to rely so heavily on a threshold.
 399	 * This improves tracking.
 400	 *
 401	 * The smoothed array is bigger than the original so that the smoothing
 402	 * doesn't result in edge values being truncated.
 403	 */
 404
 405	memset(dev->smooth, 0, 4 * sizeof(dev->smooth[0]));
 406	/* Pull base values, scaled up to help avoid truncation errors. */
 407	for (i = 0; i < nb_sensors; i++)
 408		dev->smooth[i + 4] = xy_sensors[i] << ATP_SCALE;
 409	memset(&dev->smooth[nb_sensors + 4], 0, 4 * sizeof(dev->smooth[0]));
 410
 411	for (pass = 0; pass < 4; pass++) {
 412		/* Handle edge. */
 413		dev->smooth_tmp[0] = (dev->smooth[0] + dev->smooth[1]) / 2;
 414
 415		/* Average values with neighbors. */
 416		for (i = 1; i < nb_sensors + 7; i++)
 417			dev->smooth_tmp[i] = (dev->smooth[i - 1] +
 418					      dev->smooth[i] * 2 +
 419					      dev->smooth[i + 1]) / 4;
 420
 421		/* Handle other edge. */
 422		dev->smooth_tmp[i] = (dev->smooth[i - 1] + dev->smooth[i]) / 2;
 423
 424		memcpy(dev->smooth, dev->smooth_tmp, sizeof(dev->smooth));
 425	}
 426
 427	for (i = 0; i < nb_sensors + 8; i++) {
 428		/*
 429		 * Skip values if they're small enough to be truncated to 0
 430		 * by scale. Mostly noise.
 431		 */
 432		if ((dev->smooth[i] >> ATP_SCALE) > 0) {
 433			pcum += dev->smooth[i] * i;
 434			psum += dev->smooth[i];
 435		}
 436	}
 437
 438	if (psum > 0) {
 439		*z = psum >> ATP_SCALE;        /* Scale down pressure output. */
 440		return pcum * fact / psum;
 441	}
 442
 443	return 0;
 444}
 445
 446static inline void atp_report_fingers(struct input_dev *input, int fingers)
 447{
 448	input_report_key(input, BTN_TOOL_FINGER, fingers == 1);
 449	input_report_key(input, BTN_TOOL_DOUBLETAP, fingers == 2);
 450	input_report_key(input, BTN_TOOL_TRIPLETAP, fingers > 2);
 451}
 452
 453/* Check URB status and for correct length of data package */
 454
 455#define ATP_URB_STATUS_SUCCESS		0
 456#define ATP_URB_STATUS_ERROR		1
 457#define ATP_URB_STATUS_ERROR_FATAL	2
 458
 459static int atp_status_check(struct urb *urb)
 460{
 461	struct atp *dev = urb->context;
 462	struct usb_interface *intf = dev->intf;
 463
 464	switch (urb->status) {
 465	case 0:
 466		/* success */
 467		break;
 468	case -EOVERFLOW:
 469		if (!dev->overflow_warned) {
 470			dev_warn(&intf->dev,
 471				"appletouch: OVERFLOW with data length %d, actual length is %d\n",
 472				dev->info->datalen, dev->urb->actual_length);
 473			dev->overflow_warned = true;
 474		}
 475	case -ECONNRESET:
 476	case -ENOENT:
 477	case -ESHUTDOWN:
 478		/* This urb is terminated, clean up */
 479		dev_dbg(&intf->dev,
 480			"atp_complete: urb shutting down with status: %d\n",
 481			urb->status);
 482		return ATP_URB_STATUS_ERROR_FATAL;
 483
 484	default:
 485		dev_dbg(&intf->dev,
 486			"atp_complete: nonzero urb status received: %d\n",
 487			urb->status);
 488		return ATP_URB_STATUS_ERROR;
 489	}
 490
 491	/* drop incomplete datasets */
 492	if (dev->urb->actual_length != dev->info->datalen) {
 493		dprintk("appletouch: incomplete data package"
 494			" (first byte: %d, length: %d).\n",
 495			dev->data[0], dev->urb->actual_length);
 496		return ATP_URB_STATUS_ERROR;
 497	}
 498
 499	return ATP_URB_STATUS_SUCCESS;
 500}
 501
 502static void atp_detect_size(struct atp *dev)
 503{
 504	int i;
 505
 506	/* 17" Powerbooks have extra X sensors */
 507	for (i = dev->info->xsensors; i < ATP_XSENSORS; i++) {
 508		if (dev->xy_cur[i]) {
 509
 510			dev_info(&dev->intf->dev,
 511				"appletouch: 17\" model detected.\n");
 512
 513			input_set_abs_params(dev->input, ABS_X, 0,
 514					     (dev->info->xsensors_17 - 1) *
 515							dev->info->xfact - 1,
 516					     dev->info->fuzz, 0);
 517			break;
 518		}
 519	}
 520}
 521
 522/*
 523 * USB interrupt callback functions
 524 */
 525
 526/* Interrupt function for older touchpads: FOUNTAIN/GEYSER1/GEYSER2 */
 527
 528static void atp_complete_geyser_1_2(struct urb *urb)
 529{
 530	int x, y, x_z, y_z, x_f, y_f;
 531	int retval, i, j;
 532	int key, fingers;
 533	struct atp *dev = urb->context;
 534	int status = atp_status_check(urb);
 535
 536	if (status == ATP_URB_STATUS_ERROR_FATAL)
 537		return;
 538	else if (status == ATP_URB_STATUS_ERROR)
 539		goto exit;
 540
 541	/* reorder the sensors values */
 542	if (dev->info == &geyser2_info) {
 543		memset(dev->xy_cur, 0, sizeof(dev->xy_cur));
 544
 545		/*
 546		 * The values are laid out like this:
 547		 * Y1, Y2, -, Y3, Y4, -, ..., X1, X2, -, X3, X4, -, ...
 548		 * '-' is an unused value.
 549		 */
 550
 551		/* read X values */
 552		for (i = 0, j = 19; i < 20; i += 2, j += 3) {
 553			dev->xy_cur[i] = dev->data[j];
 554			dev->xy_cur[i + 1] = dev->data[j + 1];
 555		}
 556
 557		/* read Y values */
 558		for (i = 0, j = 1; i < 9; i += 2, j += 3) {
 559			dev->xy_cur[ATP_XSENSORS + i] = dev->data[j];
 560			dev->xy_cur[ATP_XSENSORS + i + 1] = dev->data[j + 1];
 561		}
 562	} else {
 563		for (i = 0; i < 8; i++) {
 564			/* X values */
 565			dev->xy_cur[i +  0] = dev->data[5 * i +  2];
 566			dev->xy_cur[i +  8] = dev->data[5 * i +  4];
 567			dev->xy_cur[i + 16] = dev->data[5 * i + 42];
 568			if (i < 2)
 569				dev->xy_cur[i + 24] = dev->data[5 * i + 44];
 570
 571			/* Y values */
 572			dev->xy_cur[ATP_XSENSORS + i] = dev->data[5 * i +  1];
 573			dev->xy_cur[ATP_XSENSORS + i + 8] = dev->data[5 * i + 3];
 574		}
 575	}
 576
 577	dbg_dump("sample", dev->xy_cur);
 578
 579	if (!dev->valid) {
 580		/* first sample */
 581		dev->valid = true;
 582		dev->x_old = dev->y_old = -1;
 583
 584		/* Store first sample */
 585		memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
 586
 587		/* Perform size detection, if not done already */
 588		if (unlikely(!dev->size_detect_done)) {
 589			atp_detect_size(dev);
 590			dev->size_detect_done = 1;
 591			goto exit;
 592		}
 593	}
 594
 595	for (i = 0; i < ATP_XSENSORS + ATP_YSENSORS; i++) {
 596		/* accumulate the change */
 597		signed char change = dev->xy_old[i] - dev->xy_cur[i];
 598		dev->xy_acc[i] -= change;
 599
 600		/* prevent down drifting */
 601		if (dev->xy_acc[i] < 0)
 602			dev->xy_acc[i] = 0;
 603	}
 604
 605	memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
 606
 607	dbg_dump("accumulator", dev->xy_acc);
 608
 609	x = atp_calculate_abs(dev, 0, ATP_XSENSORS,
 610			      dev->info->xfact, &x_z, &x_f);
 611	y = atp_calculate_abs(dev, ATP_XSENSORS, ATP_YSENSORS,
 612			      dev->info->yfact, &y_z, &y_f);
 613	key = dev->data[dev->info->datalen - 1] & ATP_STATUS_BUTTON;
 614
 615	fingers = max(x_f, y_f);
 616
 617	if (x && y && fingers == dev->fingers_old) {
 618		if (dev->x_old != -1) {
 619			x = (dev->x_old * 7 + x) >> 3;
 620			y = (dev->y_old * 7 + y) >> 3;
 621			dev->x_old = x;
 622			dev->y_old = y;
 623
 624			if (debug > 1)
 625				printk(KERN_DEBUG "appletouch: "
 626					"X: %3d Y: %3d Xz: %3d Yz: %3d\n",
 627					x, y, x_z, y_z);
 628
 629			input_report_key(dev->input, BTN_TOUCH, 1);
 630			input_report_abs(dev->input, ABS_X, x);
 631			input_report_abs(dev->input, ABS_Y, y);
 632			input_report_abs(dev->input, ABS_PRESSURE,
 633					 min(ATP_PRESSURE, x_z + y_z));
 634			atp_report_fingers(dev->input, fingers);
 635		}
 636		dev->x_old = x;
 637		dev->y_old = y;
 638
 639	} else if (!x && !y) {
 640
 641		dev->x_old = dev->y_old = -1;
 642		dev->fingers_old = 0;
 643		input_report_key(dev->input, BTN_TOUCH, 0);
 644		input_report_abs(dev->input, ABS_PRESSURE, 0);
 645		atp_report_fingers(dev->input, 0);
 646
 647		/* reset the accumulator on release */
 648		memset(dev->xy_acc, 0, sizeof(dev->xy_acc));
 649	}
 650
 651	if (fingers != dev->fingers_old)
 652		dev->x_old = dev->y_old = -1;
 653	dev->fingers_old = fingers;
 654
 655	input_report_key(dev->input, BTN_LEFT, key);
 656	input_sync(dev->input);
 657
 658 exit:
 659	retval = usb_submit_urb(dev->urb, GFP_ATOMIC);
 660	if (retval)
 661		dev_err(&dev->intf->dev,
 662			"atp_complete: usb_submit_urb failed with result %d\n",
 663			retval);
 664}
 665
 666/* Interrupt function for older touchpads: GEYSER3/GEYSER4 */
 667
 668static void atp_complete_geyser_3_4(struct urb *urb)
 669{
 670	int x, y, x_z, y_z, x_f, y_f;
 671	int retval, i, j;
 672	int key, fingers;
 673	struct atp *dev = urb->context;
 674	int status = atp_status_check(urb);
 675
 676	if (status == ATP_URB_STATUS_ERROR_FATAL)
 677		return;
 678	else if (status == ATP_URB_STATUS_ERROR)
 679		goto exit;
 680
 681	/* Reorder the sensors values:
 682	 *
 683	 * The values are laid out like this:
 684	 * -, Y1, Y2, -, Y3, Y4, -, ..., -, X1, X2, -, X3, X4, ...
 685	 * '-' is an unused value.
 686	 */
 687
 688	/* read X values */
 689	for (i = 0, j = 19; i < 20; i += 2, j += 3) {
 690		dev->xy_cur[i] = dev->data[j + 1];
 691		dev->xy_cur[i + 1] = dev->data[j + 2];
 692	}
 693	/* read Y values */
 694	for (i = 0, j = 1; i < 9; i += 2, j += 3) {
 695		dev->xy_cur[ATP_XSENSORS + i] = dev->data[j + 1];
 696		dev->xy_cur[ATP_XSENSORS + i + 1] = dev->data[j + 2];
 697	}
 698
 699	dbg_dump("sample", dev->xy_cur);
 700
 701	/* Just update the base values (i.e. touchpad in untouched state) */
 702	if (dev->data[dev->info->datalen - 1] & ATP_STATUS_BASE_UPDATE) {
 703
 704		dprintk("appletouch: updated base values\n");
 705
 706		memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
 707		goto exit;
 708	}
 709
 710	for (i = 0; i < ATP_XSENSORS + ATP_YSENSORS; i++) {
 711		/* calculate the change */
 712		dev->xy_acc[i] = dev->xy_cur[i] - dev->xy_old[i];
 713
 714		/* this is a round-robin value, so couple with that */
 715		if (dev->xy_acc[i] > 127)
 716			dev->xy_acc[i] -= 256;
 717
 718		if (dev->xy_acc[i] < -127)
 719			dev->xy_acc[i] += 256;
 720
 721		/* prevent down drifting */
 722		if (dev->xy_acc[i] < 0)
 723			dev->xy_acc[i] = 0;
 724	}
 725
 726	dbg_dump("accumulator", dev->xy_acc);
 727
 728	x = atp_calculate_abs(dev, 0, ATP_XSENSORS,
 729			      dev->info->xfact, &x_z, &x_f);
 730	y = atp_calculate_abs(dev, ATP_XSENSORS, ATP_YSENSORS,
 731			      dev->info->yfact, &y_z, &y_f);
 732
 733	key = dev->data[dev->info->datalen - 1] & ATP_STATUS_BUTTON;
 734
 735	fingers = max(x_f, y_f);
 736
 737	if (x && y && fingers == dev->fingers_old) {
 738		if (dev->x_old != -1) {
 739			x = (dev->x_old * 7 + x) >> 3;
 740			y = (dev->y_old * 7 + y) >> 3;
 741			dev->x_old = x;
 742			dev->y_old = y;
 743
 744			if (debug > 1)
 745				printk(KERN_DEBUG "appletouch: X: %3d Y: %3d "
 746				       "Xz: %3d Yz: %3d\n",
 747				       x, y, x_z, y_z);
 748
 749			input_report_key(dev->input, BTN_TOUCH, 1);
 750			input_report_abs(dev->input, ABS_X, x);
 751			input_report_abs(dev->input, ABS_Y, y);
 752			input_report_abs(dev->input, ABS_PRESSURE,
 753					 min(ATP_PRESSURE, x_z + y_z));
 754			atp_report_fingers(dev->input, fingers);
 755		}
 756		dev->x_old = x;
 757		dev->y_old = y;
 758
 759	} else if (!x && !y) {
 760
 761		dev->x_old = dev->y_old = -1;
 762		dev->fingers_old = 0;
 763		input_report_key(dev->input, BTN_TOUCH, 0);
 764		input_report_abs(dev->input, ABS_PRESSURE, 0);
 765		atp_report_fingers(dev->input, 0);
 766
 767		/* reset the accumulator on release */
 768		memset(dev->xy_acc, 0, sizeof(dev->xy_acc));
 769	}
 770
 771	if (fingers != dev->fingers_old)
 772		dev->x_old = dev->y_old = -1;
 773	dev->fingers_old = fingers;
 774
 775	input_report_key(dev->input, BTN_LEFT, key);
 776	input_sync(dev->input);
 777
 778	/*
 779	 * Geysers 3/4 will continue to send packets continually after
 780	 * the first touch unless reinitialised. Do so if it's been
 781	 * idle for a while in order to avoid waking the kernel up
 782	 * several hundred times a second.
 783	 */
 784
 785	/*
 786	 * Button must not be pressed when entering suspend,
 787	 * otherwise we will never release the button.
 788	 */
 789	if (!x && !y && !key) {
 790		dev->idlecount++;
 791		if (dev->idlecount == 10) {
 792			dev->x_old = dev->y_old = -1;
 793			dev->idlecount = 0;
 794			schedule_work(&dev->work);
 795			/* Don't resubmit urb here, wait for reinit */
 796			return;
 797		}
 798	} else
 799		dev->idlecount = 0;
 800
 801 exit:
 802	retval = usb_submit_urb(dev->urb, GFP_ATOMIC);
 803	if (retval)
 804		dev_err(&dev->intf->dev,
 805			"atp_complete: usb_submit_urb failed with result %d\n",
 806			retval);
 807}
 808
 809static int atp_open(struct input_dev *input)
 810{
 811	struct atp *dev = input_get_drvdata(input);
 812
 813	if (usb_submit_urb(dev->urb, GFP_ATOMIC))
 814		return -EIO;
 815
 816	dev->open = 1;
 817	return 0;
 818}
 819
 820static void atp_close(struct input_dev *input)
 821{
 822	struct atp *dev = input_get_drvdata(input);
 823
 824	usb_kill_urb(dev->urb);
 825	cancel_work_sync(&dev->work);
 826	dev->open = 0;
 827}
 828
 829static int atp_handle_geyser(struct atp *dev)
 830{
 831	if (dev->info != &fountain_info) {
 832		/* switch to raw sensor mode */
 833		if (atp_geyser_init(dev))
 834			return -EIO;
 835
 836		dev_info(&dev->intf->dev, "Geyser mode initialized.\n");
 837	}
 838
 839	return 0;
 840}
 841
 842static int atp_probe(struct usb_interface *iface,
 843		     const struct usb_device_id *id)
 844{
 845	struct atp *dev;
 846	struct input_dev *input_dev;
 847	struct usb_device *udev = interface_to_usbdev(iface);
 848	struct usb_host_interface *iface_desc;
 849	struct usb_endpoint_descriptor *endpoint;
 850	int int_in_endpointAddr = 0;
 851	int i, error = -ENOMEM;
 852	const struct atp_info *info = (const struct atp_info *)id->driver_info;
 853
 854	/* set up the endpoint information */
 855	/* use only the first interrupt-in endpoint */
 856	iface_desc = iface->cur_altsetting;
 857	for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) {
 858		endpoint = &iface_desc->endpoint[i].desc;
 859		if (!int_in_endpointAddr && usb_endpoint_is_int_in(endpoint)) {
 860			/* we found an interrupt in endpoint */
 861			int_in_endpointAddr = endpoint->bEndpointAddress;
 862			break;
 863		}
 864	}
 865	if (!int_in_endpointAddr) {
 866		dev_err(&iface->dev, "Could not find int-in endpoint\n");
 867		return -EIO;
 868	}
 869
 870	/* allocate memory for our device state and initialize it */
 871	dev = kzalloc(sizeof(struct atp), GFP_KERNEL);
 872	input_dev = input_allocate_device();
 873	if (!dev || !input_dev) {
 874		dev_err(&iface->dev, "Out of memory\n");
 875		goto err_free_devs;
 876	}
 877
 878	dev->udev = udev;
 879	dev->intf = iface;
 880	dev->input = input_dev;
 881	dev->info = info;
 882	dev->overflow_warned = false;
 883
 884	dev->urb = usb_alloc_urb(0, GFP_KERNEL);
 885	if (!dev->urb)
 886		goto err_free_devs;
 887
 888	dev->data = usb_alloc_coherent(dev->udev, dev->info->datalen, GFP_KERNEL,
 889				       &dev->urb->transfer_dma);
 890	if (!dev->data)
 891		goto err_free_urb;
 892
 893	usb_fill_int_urb(dev->urb, udev,
 894			 usb_rcvintpipe(udev, int_in_endpointAddr),
 895			 dev->data, dev->info->datalen,
 896			 dev->info->callback, dev, 1);
 897
 898	error = atp_handle_geyser(dev);
 899	if (error)
 900		goto err_free_buffer;
 901
 902	usb_make_path(udev, dev->phys, sizeof(dev->phys));
 903	strlcat(dev->phys, "/input0", sizeof(dev->phys));
 904
 905	input_dev->name = "appletouch";
 906	input_dev->phys = dev->phys;
 907	usb_to_input_id(dev->udev, &input_dev->id);
 908	input_dev->dev.parent = &iface->dev;
 909
 910	input_set_drvdata(input_dev, dev);
 911
 912	input_dev->open = atp_open;
 913	input_dev->close = atp_close;
 914
 915	set_bit(EV_ABS, input_dev->evbit);
 916
 917	input_set_abs_params(input_dev, ABS_X, 0,
 918			     (dev->info->xsensors - 1) * dev->info->xfact - 1,
 919			     dev->info->fuzz, 0);
 920	input_set_abs_params(input_dev, ABS_Y, 0,
 921			     (dev->info->ysensors - 1) * dev->info->yfact - 1,
 922			     dev->info->fuzz, 0);
 923	input_set_abs_params(input_dev, ABS_PRESSURE, 0, ATP_PRESSURE, 0, 0);
 924
 925	set_bit(EV_KEY, input_dev->evbit);
 926	set_bit(BTN_TOUCH, input_dev->keybit);
 927	set_bit(BTN_TOOL_FINGER, input_dev->keybit);
 928	set_bit(BTN_TOOL_DOUBLETAP, input_dev->keybit);
 929	set_bit(BTN_TOOL_TRIPLETAP, input_dev->keybit);
 930	set_bit(BTN_LEFT, input_dev->keybit);
 931
 932	error = input_register_device(dev->input);
 933	if (error)
 934		goto err_free_buffer;
 935
 936	/* save our data pointer in this interface device */
 937	usb_set_intfdata(iface, dev);
 938
 939	INIT_WORK(&dev->work, atp_reinit);
 940
 941	return 0;
 942
 943 err_free_buffer:
 944	usb_free_coherent(dev->udev, dev->info->datalen,
 945			  dev->data, dev->urb->transfer_dma);
 946 err_free_urb:
 947	usb_free_urb(dev->urb);
 948 err_free_devs:
 949	usb_set_intfdata(iface, NULL);
 950	kfree(dev);
 951	input_free_device(input_dev);
 952	return error;
 953}
 954
 955static void atp_disconnect(struct usb_interface *iface)
 956{
 957	struct atp *dev = usb_get_intfdata(iface);
 958
 959	usb_set_intfdata(iface, NULL);
 960	if (dev) {
 961		usb_kill_urb(dev->urb);
 962		input_unregister_device(dev->input);
 963		usb_free_coherent(dev->udev, dev->info->datalen,
 964				  dev->data, dev->urb->transfer_dma);
 965		usb_free_urb(dev->urb);
 966		kfree(dev);
 967	}
 968	dev_info(&iface->dev, "input: appletouch disconnected\n");
 969}
 970
 971static int atp_recover(struct atp *dev)
 972{
 973	int error;
 974
 975	error = atp_handle_geyser(dev);
 976	if (error)
 977		return error;
 978
 979	if (dev->open && usb_submit_urb(dev->urb, GFP_ATOMIC))
 980		return -EIO;
 981
 982	return 0;
 983}
 984
 985static int atp_suspend(struct usb_interface *iface, pm_message_t message)
 986{
 987	struct atp *dev = usb_get_intfdata(iface);
 988
 989	usb_kill_urb(dev->urb);
 990	return 0;
 991}
 992
 993static int atp_resume(struct usb_interface *iface)
 994{
 995	struct atp *dev = usb_get_intfdata(iface);
 996
 997	if (dev->open && usb_submit_urb(dev->urb, GFP_ATOMIC))
 998		return -EIO;
 999
1000	return 0;
1001}
1002
1003static int atp_reset_resume(struct usb_interface *iface)
1004{
1005	struct atp *dev = usb_get_intfdata(iface);
1006
1007	return atp_recover(dev);
1008}
1009
1010static struct usb_driver atp_driver = {
1011	.name		= "appletouch",
1012	.probe		= atp_probe,
1013	.disconnect	= atp_disconnect,
1014	.suspend	= atp_suspend,
1015	.resume		= atp_resume,
1016	.reset_resume	= atp_reset_resume,
1017	.id_table	= atp_table,
1018};
1019
1020module_usb_driver(atp_driver);