1/* 2 * OLPC HGPK (XO-1) touchpad PS/2 mouse driver 3 * 4 * Copyright (c) 2006-2008 One Laptop Per Child 5 * Authors: 6 * Zephaniah E. Hull 7 * Andres Salomon <dilinger@debian.org> 8 * 9 * This driver is partly based on the ALPS driver, which is: 10 * 11 * Copyright (c) 2003 Neil Brown <neilb@cse.unsw.edu.au> 12 * Copyright (c) 2003-2005 Peter Osterlund <petero2@telia.com> 13 * Copyright (c) 2004 Dmitry Torokhov <dtor@mail.ru> 14 * Copyright (c) 2005 Vojtech Pavlik <vojtech@suse.cz> 15 * 16 * This program is free software; you can redistribute it and/or modify 17 * it under the terms of the GNU General Public License version 2 as 18 * published by the Free Software Foundation. 19 */ 20 21/* 22 * The spec from ALPS is available from 23 * <http://wiki.laptop.org/go/Touch_Pad/Tablet>. It refers to this 24 * device as HGPK (Hybrid GS, PT, and Keymatrix). 25 * 26 * The earliest versions of the device had simultaneous reporting; that 27 * was removed. After that, the device used the Advanced Mode GS/PT streaming 28 * stuff. That turned out to be too buggy to support, so we've finally 29 * switched to Mouse Mode (which utilizes only the center 1/3 of the touchpad). 30 */ 31 32#define DEBUG 33#include <linux/slab.h> 34#include <linux/input.h> 35#include <linux/serio.h> 36#include <linux/libps2.h> 37#include <linux/delay.h> 38#include <asm/olpc.h> 39 40#include "psmouse.h" 41#include "hgpk.h" 42 43static bool tpdebug; 44module_param(tpdebug, bool, 0644); 45MODULE_PARM_DESC(tpdebug, "enable debugging, dumping packets to KERN_DEBUG."); 46 47static int recalib_delta = 100; 48module_param(recalib_delta, int, 0644); 49MODULE_PARM_DESC(recalib_delta, 50 "packets containing a delta this large will cause a recalibration."); 51 52static int jumpy_delay = 1000; 53module_param(jumpy_delay, int, 0644); 54MODULE_PARM_DESC(jumpy_delay, 55 "delay (ms) before recal after jumpiness detected"); 56 57static int spew_delay = 1000; 58module_param(spew_delay, int, 0644); 59MODULE_PARM_DESC(spew_delay, 60 "delay (ms) before recal after packet spew detected"); 61 62static int recal_guard_time = 2000; 63module_param(recal_guard_time, int, 0644); 64MODULE_PARM_DESC(recal_guard_time, 65 "interval (ms) during which recal will be restarted if packet received"); 66 67static int post_interrupt_delay = 1000; 68module_param(post_interrupt_delay, int, 0644); 69MODULE_PARM_DESC(post_interrupt_delay, 70 "delay (ms) before recal after recal interrupt detected"); 71 72/* 73 * When the touchpad gets ultra-sensitive, one can keep their finger 1/2" 74 * above the pad and still have it send packets. This causes a jump cursor 75 * when one places their finger on the pad. We can probably detect the 76 * jump as we see a large deltas (>= 100px). In mouse mode, I've been 77 * unable to even come close to 100px deltas during normal usage, so I think 78 * this threshold is safe. If a large delta occurs, trigger a recalibration. 79 */ 80static void hgpk_jumpy_hack(struct psmouse *psmouse, int x, int y) 81{ 82 struct hgpk_data *priv = psmouse->private; 83 84 if (abs(x) > recalib_delta || abs(y) > recalib_delta) { 85 hgpk_err(psmouse, ">%dpx jump detected (%d,%d)\n", 86 recalib_delta, x, y); 87 /* My car gets forty rods to the hogshead and that's the 88 * way I likes it! */ 89 psmouse_queue_work(psmouse, &priv->recalib_wq, 90 msecs_to_jiffies(jumpy_delay)); 91 } 92} 93 94/* 95 * We have no idea why this particular hardware bug occurs. The touchpad 96 * will randomly start spewing packets without anything touching the 97 * pad. This wouldn't necessarily be bad, but it's indicative of a 98 * severely miscalibrated pad; attempting to use the touchpad while it's 99 * spewing means the cursor will jump all over the place, and act "drunk". 100 * 101 * The packets that are spewed tend to all have deltas between -2 and 2, and 102 * the cursor will move around without really going very far. It will 103 * tend to end up in the same location; if we tally up the changes over 104 * 100 packets, we end up w/ a final delta of close to 0. This happens 105 * pretty regularly when the touchpad is spewing, and is pretty hard to 106 * manually trigger (at least for *my* fingers). So, it makes a perfect 107 * scheme for detecting spews. 108 */ 109static void hgpk_spewing_hack(struct psmouse *psmouse, 110 int l, int r, int x, int y) 111{ 112 struct hgpk_data *priv = psmouse->private; 113 114 /* ignore button press packets; many in a row could trigger 115 * a false-positive! */ 116 if (l || r) 117 return; 118 119 priv->x_tally += x; 120 priv->y_tally += y; 121 122 if (++priv->count > 100) { 123 if (abs(priv->x_tally) < 3 && abs(priv->y_tally) < 3) { 124 hgpk_dbg(psmouse, "packet spew detected (%d,%d)\n", 125 priv->x_tally, priv->y_tally); 126 psmouse_queue_work(psmouse, &priv->recalib_wq, 127 msecs_to_jiffies(spew_delay)); 128 } 129 /* reset every 100 packets */ 130 priv->count = 0; 131 priv->x_tally = 0; 132 priv->y_tally = 0; 133 } 134} 135 136/* 137 * HGPK Mouse Mode format (standard mouse format, sans middle button) 138 * 139 * byte 0: y-over x-over y-neg x-neg 1 0 swr swl 140 * byte 1: x7 x6 x5 x4 x3 x2 x1 x0 141 * byte 2: y7 y6 y5 y4 y3 y2 y1 y0 142 * 143 * swr/swl are the left/right buttons. 144 * x-neg/y-neg are the x and y delta negative bits 145 * x-over/y-over are the x and y overflow bits 146 */ 147static int hgpk_validate_byte(unsigned char *packet) 148{ 149 return (packet[0] & 0x0C) != 0x08; 150} 151 152static void hgpk_process_packet(struct psmouse *psmouse) 153{ 154 struct input_dev *dev = psmouse->dev; 155 unsigned char *packet = psmouse->packet; 156 int x, y, left, right; 157 158 left = packet[0] & 1; 159 right = (packet[0] >> 1) & 1; 160 161 x = packet[1] - ((packet[0] << 4) & 0x100); 162 y = ((packet[0] << 3) & 0x100) - packet[2]; 163 164 hgpk_jumpy_hack(psmouse, x, y); 165 hgpk_spewing_hack(psmouse, left, right, x, y); 166 167 if (tpdebug) 168 hgpk_dbg(psmouse, "l=%d r=%d x=%d y=%d\n", left, right, x, y); 169 170 input_report_key(dev, BTN_LEFT, left); 171 input_report_key(dev, BTN_RIGHT, right); 172 173 input_report_rel(dev, REL_X, x); 174 input_report_rel(dev, REL_Y, y); 175 176 input_sync(dev); 177} 178 179static psmouse_ret_t hgpk_process_byte(struct psmouse *psmouse) 180{ 181 struct hgpk_data *priv = psmouse->private; 182 183 if (hgpk_validate_byte(psmouse->packet)) { 184 hgpk_dbg(psmouse, "%s: (%d) %02x %02x %02x\n", 185 __func__, psmouse->pktcnt, psmouse->packet[0], 186 psmouse->packet[1], psmouse->packet[2]); 187 return PSMOUSE_BAD_DATA; 188 } 189 190 if (psmouse->pktcnt >= psmouse->pktsize) { 191 hgpk_process_packet(psmouse); 192 return PSMOUSE_FULL_PACKET; 193 } 194 195 if (priv->recalib_window) { 196 if (time_before(jiffies, priv->recalib_window)) { 197 /* 198 * ugh, got a packet inside our recalibration 199 * window, schedule another recalibration. 200 */ 201 hgpk_dbg(psmouse, 202 "packet inside calibration window, " 203 "queueing another recalibration\n"); 204 psmouse_queue_work(psmouse, &priv->recalib_wq, 205 msecs_to_jiffies(post_interrupt_delay)); 206 } 207 priv->recalib_window = 0; 208 } 209 210 return PSMOUSE_GOOD_DATA; 211} 212 213static int hgpk_force_recalibrate(struct psmouse *psmouse) 214{ 215 struct ps2dev *ps2dev = &psmouse->ps2dev; 216 struct hgpk_data *priv = psmouse->private; 217 218 /* C-series touchpads added the recalibrate command */ 219 if (psmouse->model < HGPK_MODEL_C) 220 return 0; 221 222 /* we don't want to race with the irq handler, nor with resyncs */ 223 psmouse_set_state(psmouse, PSMOUSE_INITIALIZING); 224 225 /* start by resetting the device */ 226 psmouse_reset(psmouse); 227 228 /* send the recalibrate request */ 229 if (ps2_command(ps2dev, NULL, 0xf5) || 230 ps2_command(ps2dev, NULL, 0xf5) || 231 ps2_command(ps2dev, NULL, 0xe6) || 232 ps2_command(ps2dev, NULL, 0xf5)) { 233 return -1; 234 } 235 236 /* according to ALPS, 150mS is required for recalibration */ 237 msleep(150); 238 239 240 if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_ENABLE)) 241 return -1; 242 243 psmouse_set_state(psmouse, PSMOUSE_ACTIVATED); 244 245 /* After we recalibrate, we shouldn't get any packets for 2s. If 246 * we do, it's likely that someone's finger was on the touchpad. 247 * If someone's finger *was* on the touchpad, it's probably 248 * miscalibrated. So, we should schedule another recalibration 249 */ 250 priv->recalib_window = jiffies + msecs_to_jiffies(recal_guard_time); 251 252 return 0; 253} 254 255/* 256 * This kills power to the touchpad; according to ALPS, current consumption 257 * goes down to 50uA after running this. To turn power back on, we drive 258 * MS-DAT low. 259 */ 260static int hgpk_toggle_power(struct psmouse *psmouse, int enable) 261{ 262 struct ps2dev *ps2dev = &psmouse->ps2dev; 263 int timeo; 264 265 /* Added on D-series touchpads */ 266 if (psmouse->model < HGPK_MODEL_D) 267 return 0; 268 269 if (enable) { 270 psmouse_set_state(psmouse, PSMOUSE_INITIALIZING); 271 272 /* 273 * Sending a byte will drive MS-DAT low; this will wake up 274 * the controller. Once we get an ACK back from it, it 275 * means we can continue with the touchpad re-init. ALPS 276 * tells us that 1s should be long enough, so set that as 277 * the upper bound. 278 */ 279 for (timeo = 20; timeo > 0; timeo--) { 280 if (!ps2_sendbyte(&psmouse->ps2dev, 281 PSMOUSE_CMD_DISABLE, 20)) 282 break; 283 msleep(50); 284 } 285 286 psmouse_reset(psmouse); 287 288 /* should be all set, enable the touchpad */ 289 ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_ENABLE); 290 psmouse_set_state(psmouse, PSMOUSE_ACTIVATED); 291 292 } else { 293 hgpk_dbg(psmouse, "Powering off touchpad.\n"); 294 psmouse_set_state(psmouse, PSMOUSE_IGNORE); 295 296 if (ps2_command(ps2dev, NULL, 0xec) || 297 ps2_command(ps2dev, NULL, 0xec) || 298 ps2_command(ps2dev, NULL, 0xea)) { 299 return -1; 300 } 301 302 /* probably won't see an ACK, the touchpad will be off */ 303 ps2_sendbyte(&psmouse->ps2dev, 0xec, 20); 304 } 305 306 return 0; 307} 308 309static int hgpk_poll(struct psmouse *psmouse) 310{ 311 /* We can't poll, so always return failure. */ 312 return -1; 313} 314 315static int hgpk_reconnect(struct psmouse *psmouse) 316{ 317 /* During suspend/resume the ps2 rails remain powered. We don't want 318 * to do a reset because it's flush data out of buffers; however, 319 * earlier prototypes (B1) had some brokenness that required a reset. */ 320 if (olpc_board_at_least(olpc_board(0xb2))) 321 if (psmouse->ps2dev.serio->dev.power.power_state.event != 322 PM_EVENT_ON) 323 return 0; 324 325 psmouse_reset(psmouse); 326 327 return 0; 328} 329 330static ssize_t hgpk_show_powered(struct psmouse *psmouse, void *data, char *buf) 331{ 332 struct hgpk_data *priv = psmouse->private; 333 334 return sprintf(buf, "%d\n", priv->powered); 335} 336 337static ssize_t hgpk_set_powered(struct psmouse *psmouse, void *data, 338 const char *buf, size_t count) 339{ 340 struct hgpk_data *priv = psmouse->private; 341 unsigned long value; 342 int err; 343 344 err = strict_strtoul(buf, 10, &value); 345 if (err || value > 1) 346 return -EINVAL; 347 348 if (value != priv->powered) { 349 /* 350 * hgpk_toggle_power will deal w/ state so 351 * we're not racing w/ irq 352 */ 353 err = hgpk_toggle_power(psmouse, value); 354 if (!err) 355 priv->powered = value; 356 } 357 358 return err ? err : count; 359} 360 361__PSMOUSE_DEFINE_ATTR(powered, S_IWUSR | S_IRUGO, NULL, 362 hgpk_show_powered, hgpk_set_powered, false); 363 364static ssize_t hgpk_trigger_recal_show(struct psmouse *psmouse, 365 void *data, char *buf) 366{ 367 return -EINVAL; 368} 369 370static ssize_t hgpk_trigger_recal(struct psmouse *psmouse, void *data, 371 const char *buf, size_t count) 372{ 373 struct hgpk_data *priv = psmouse->private; 374 unsigned long value; 375 int err; 376 377 err = strict_strtoul(buf, 10, &value); 378 if (err || value != 1) 379 return -EINVAL; 380 381 /* 382 * We queue work instead of doing recalibration right here 383 * to avoid adding locking to to hgpk_force_recalibrate() 384 * since workqueue provides serialization. 385 */ 386 psmouse_queue_work(psmouse, &priv->recalib_wq, 0); 387 return count; 388} 389 390__PSMOUSE_DEFINE_ATTR(recalibrate, S_IWUSR | S_IRUGO, NULL, 391 hgpk_trigger_recal_show, hgpk_trigger_recal, false); 392 393static void hgpk_disconnect(struct psmouse *psmouse) 394{ 395 struct hgpk_data *priv = psmouse->private; 396 397 device_remove_file(&psmouse->ps2dev.serio->dev, 398 &psmouse_attr_powered.dattr); 399 400 if (psmouse->model >= HGPK_MODEL_C) 401 device_remove_file(&psmouse->ps2dev.serio->dev, 402 &psmouse_attr_recalibrate.dattr); 403 404 psmouse_reset(psmouse); 405 kfree(priv); 406} 407 408static void hgpk_recalib_work(struct work_struct *work) 409{ 410 struct delayed_work *w = to_delayed_work(work); 411 struct hgpk_data *priv = container_of(w, struct hgpk_data, recalib_wq); 412 struct psmouse *psmouse = priv->psmouse; 413 414 hgpk_dbg(psmouse, "recalibrating touchpad..\n"); 415 416 if (hgpk_force_recalibrate(psmouse)) 417 hgpk_err(psmouse, "recalibration failed!\n"); 418} 419 420static int hgpk_register(struct psmouse *psmouse) 421{ 422 int err; 423 424 /* register handlers */ 425 psmouse->protocol_handler = hgpk_process_byte; 426 psmouse->poll = hgpk_poll; 427 psmouse->disconnect = hgpk_disconnect; 428 psmouse->reconnect = hgpk_reconnect; 429 psmouse->pktsize = 3; 430 431 /* Disable the idle resync. */ 432 psmouse->resync_time = 0; 433 /* Reset after a lot of bad bytes. */ 434 psmouse->resetafter = 1024; 435 436 err = device_create_file(&psmouse->ps2dev.serio->dev, 437 &psmouse_attr_powered.dattr); 438 if (err) { 439 hgpk_err(psmouse, "Failed creating 'powered' sysfs node\n"); 440 return err; 441 } 442 443 /* C-series touchpads added the recalibrate command */ 444 if (psmouse->model >= HGPK_MODEL_C) { 445 err = device_create_file(&psmouse->ps2dev.serio->dev, 446 &psmouse_attr_recalibrate.dattr); 447 if (err) { 448 hgpk_err(psmouse, 449 "Failed creating 'recalibrate' sysfs node\n"); 450 device_remove_file(&psmouse->ps2dev.serio->dev, 451 &psmouse_attr_powered.dattr); 452 return err; 453 } 454 } 455 456 return 0; 457} 458 459int hgpk_init(struct psmouse *psmouse) 460{ 461 struct hgpk_data *priv; 462 int err = -ENOMEM; 463 464 priv = kzalloc(sizeof(struct hgpk_data), GFP_KERNEL); 465 if (!priv) 466 goto alloc_fail; 467 468 psmouse->private = priv; 469 priv->psmouse = psmouse; 470 priv->powered = true; 471 INIT_DELAYED_WORK(&priv->recalib_wq, hgpk_recalib_work); 472 473 err = psmouse_reset(psmouse); 474 if (err) 475 goto init_fail; 476 477 err = hgpk_register(psmouse); 478 if (err) 479 goto init_fail; 480 481 return 0; 482 483init_fail: 484 kfree(priv); 485alloc_fail: 486 return err; 487} 488 489static enum hgpk_model_t hgpk_get_model(struct psmouse *psmouse) 490{ 491 struct ps2dev *ps2dev = &psmouse->ps2dev; 492 unsigned char param[3]; 493 494 /* E7, E7, E7, E9 gets us a 3 byte identifier */ 495 if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE21) || 496 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE21) || 497 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE21) || 498 ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO)) { 499 return -EIO; 500 } 501 502 hgpk_dbg(psmouse, "ID: %02x %02x %02x\n", param[0], param[1], param[2]); 503 504 /* HGPK signature: 0x67, 0x00, 0x<model> */ 505 if (param[0] != 0x67 || param[1] != 0x00) 506 return -ENODEV; 507 508 hgpk_info(psmouse, "OLPC touchpad revision 0x%x\n", param[2]); 509 510 return param[2]; 511} 512 513int hgpk_detect(struct psmouse *psmouse, bool set_properties) 514{ 515 int version; 516 517 version = hgpk_get_model(psmouse); 518 if (version < 0) 519 return version; 520 521 if (set_properties) { 522 psmouse->vendor = "ALPS"; 523 psmouse->name = "HGPK"; 524 psmouse->model = version; 525 } 526 527 return 0; 528} 529