drivers/input/mouse/synaptics.c

   1 /*
   2  * Synaptics TouchPad PS/2 mouse driver
   3  *
   4  *   2003 Dmitry Torokhov <dtor@mail.ru>
   5  *     Added support for pass-through port. Special thanks to Peter Berg Larsen
   6  *     for explaining various Synaptics quirks.
   7  *
   8  *   2003 Peter Osterlund <petero2@telia.com>
   9  *     Ported to 2.5 input device infrastructure.
  10  *
  11  *   Copyright (C) 2001 Stefan Gmeiner <riddlebox@freesurf.ch>
  12  *     start merging tpconfig and gpm code to a xfree-input module
  13  *     adding some changes and extensions (ex. 3rd and 4th button)
  14  *
  15  *   Copyright (c) 1997 C. Scott Ananian <cananian@alumni.priceton.edu>
  16  *   Copyright (c) 1998-2000 Bruce Kalk <kall@compass.com>
  17  *     code for the special synaptics commands (from the tpconfig-source)
  18  *
  19  * This program is free software; you can redistribute it and/or modify it
  20  * under the terms of the GNU General Public License version 2 as published by
  21  * the Free Software Foundation.
  22  *
  23  * Trademarks are the property of their respective owners.
  24  */
  25
  26 #include <linux/module.h>
  27 #include <linux/input.h>
  28 #include <linux/serio.h>
  29 #include "psmouse.h"
  30 #include "synaptics.h"
  31
  32 /*
  33  * The x/y limits are taken from the Synaptics TouchPad interfacing Guide,
  34  * section 2.3.2, which says that they should be valid regardless of the
  35  * actual size of the sensor.
  36  */
  37 #define XMIN_NOMINAL 1472
  38 #define XMAX_NOMINAL 5472
  39 #define YMIN_NOMINAL 1408
  40 #define YMAX_NOMINAL 4448
  41
  42 /*****************************************************************************
  43  *      Synaptics communications functions
  44  ****************************************************************************/
  45
  46 /*
  47  * Use the Synaptics extended ps/2 syntax to write a special command byte.
  48  * special command: 0xE8 rr 0xE8 ss 0xE8 tt 0xE8 uu where (rr*64)+(ss*16)+(tt*4)+uu
  49  *                  is the command. A 0xF3 or 0xE9 must follow (see synaptics_send_cmd
  50  *                  and synaptics_mode_cmd)
  51  */
  52 static int synaptics_special_cmd(struct psmouse *psmouse, unsigned char command)
  53 {
  54         int i;
  55
  56         if (psmouse_command(psmouse, NULL, PSMOUSE_CMD_SETSCALE11))
  57                 return -1;
  58
  59         for (i = 6; i >= 0; i -= 2) {
  60                 unsigned char d = (command >> i) & 3;
  61                 if (psmouse_command(psmouse, &d, PSMOUSE_CMD_SETRES))
  62                         return -1;
  63         }
  64
  65         return 0;
  66 }
  67
  68 /*
  69  * Send a command to the synpatics touchpad by special commands
  70  */
  71 static int synaptics_send_cmd(struct psmouse *psmouse, unsigned char c, unsigned char *param)
  72 {
  73         if (synaptics_special_cmd(psmouse, c))
  74                 return -1;
  75         if (psmouse_command(psmouse, param, PSMOUSE_CMD_GETINFO))
  76                 return -1;
  77         return 0;
  78 }
  79
  80 /*
  81  * Set the synaptics touchpad mode byte by special commands
  82  */
  83 static int synaptics_mode_cmd(struct psmouse *psmouse, unsigned char mode)
  84 {
  85         unsigned char param[1];
  86
  87         if (synaptics_special_cmd(psmouse, mode))
  88                 return -1;
  89         param[0] = SYN_PS_SET_MODE2;
  90         if (psmouse_command(psmouse, param, PSMOUSE_CMD_SETRATE))
  91                 return -1;
  92         return 0;
  93 }
  94
  95 /*
  96  * Read the model-id bytes from the touchpad
  97  * see also SYN_MODEL_* macros
  98  */
  99 static int synaptics_model_id(struct psmouse *psmouse)
 100 {
 101         struct synaptics_data *priv = psmouse->private;
 102         unsigned char mi[3];
 103
 104         if (synaptics_send_cmd(psmouse, SYN_QUE_MODEL, mi))
 105                 return -1;
 106         priv->model_id = (mi[0]<<16) | (mi[1]<<8) | mi[2];
 107         return 0;
 108 }
 109
 110 /*
 111  * Read the capability-bits from the touchpad
 112  * see also the SYN_CAP_* macros
 113  */
 114 static int synaptics_capability(struct psmouse *psmouse)
 115 {
 116         struct synaptics_data *priv = psmouse->private;
 117         unsigned char cap[3];
 118
 119         if (synaptics_send_cmd(psmouse, SYN_QUE_CAPABILITIES, cap))
 120                 return -1;
 121         priv->capabilities = (cap[0]<<16) | (cap[1]<<8) | cap[2];
 122         priv->ext_cap = 0;
 123         if (!SYN_CAP_VALID(priv->capabilities))
 124                 return -1;
 125
 126         if (SYN_EXT_CAP_REQUESTS(priv->capabilities)) {
 127                 if (synaptics_send_cmd(psmouse, SYN_QUE_EXT_CAPAB, cap)) {
 128                         printk(KERN_ERR "Synaptics claims to have extended capabilities,"
 129                                " but I'm not able to read them.");
 130                 } else
 131                         priv->ext_cap = (cap[0]<<16) | (cap[1]<<8) | cap[2];
 132         }
 133         return 0;
 134 }
 135
 136 /*
 137  * Identify Touchpad
 138  * See also the SYN_ID_* macros
 139  */
 140 static int synaptics_identify(struct psmouse *psmouse)
 141 {
 142         struct synaptics_data *priv = psmouse->private;
 143         unsigned char id[3];
 144
 145         if (synaptics_send_cmd(psmouse, SYN_QUE_IDENTIFY, id))
 146                 return -1;
 147         priv->identity = (id[0]<<16) | (id[1]<<8) | id[2];
 148         if (SYN_ID_IS_SYNAPTICS(priv->identity))
 149                 return 0;
 150         return -1;
 151 }
 152
 153 static void print_ident(struct synaptics_data *priv)
 154 {
 155         printk(KERN_INFO "Synaptics Touchpad, model: %ld\n", SYN_ID_MODEL(priv->identity));
 156         printk(KERN_INFO " Firmware: %ld.%ld\n", SYN_ID_MAJOR(priv->identity),
 157                SYN_ID_MINOR(priv->identity));
 158         if (SYN_MODEL_ROT180(priv->model_id))
 159                 printk(KERN_INFO " 180 degree mounted touchpad\n");
 160         if (SYN_MODEL_PORTRAIT(priv->model_id))
 161                 printk(KERN_INFO " portrait touchpad\n");
 162         printk(KERN_INFO " Sensor: %ld\n", SYN_MODEL_SENSOR(priv->model_id));
 163         if (SYN_MODEL_NEWABS(priv->model_id))
 164                 printk(KERN_INFO " new absolute packet format\n");
 165         if (SYN_MODEL_PEN(priv->model_id))
 166                 printk(KERN_INFO " pen detection\n");
 167
 168         if (SYN_CAP_EXTENDED(priv->capabilities)) {
 169                 printk(KERN_INFO " Touchpad has extended capability bits\n");
 170                 if (SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap) &&
 171                     SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap) <= 8)
 172                         printk(KERN_INFO " -> %d multi-buttons, i.e. besides standard buttons\n",
 173                                (int)(SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap)));
 174                 else if (SYN_CAP_FOUR_BUTTON(priv->capabilities))
 175                         printk(KERN_INFO " -> four buttons\n");
 176                 if (SYN_CAP_MULTIFINGER(priv->capabilities))
 177                         printk(KERN_INFO " -> multifinger detection\n");
 178                 if (SYN_CAP_PALMDETECT(priv->capabilities))
 179                         printk(KERN_INFO " -> palm detection\n");
 180                 if (SYN_CAP_PASS_THROUGH(priv->capabilities))
 181                         printk(KERN_INFO " -> pass-through port\n");
 182         }
 183 }
 184
 185 static int synaptics_query_hardware(struct psmouse *psmouse)
 186 {
 187         int retries = 0;
 188
 189         while ((retries++ < 3) && psmouse_reset(psmouse))
 190                 printk(KERN_ERR "synaptics reset failed\n");
 191
 192         if (synaptics_identify(psmouse))
 193                 return -1;
 194         if (synaptics_model_id(psmouse))
 195                 return -1;
 196         if (synaptics_capability(psmouse))
 197                 return -1;
 198
 199         return 0;
 200 }
 201
 202 static int synaptics_set_mode(struct psmouse *psmouse, int mode)
 203 {
 204         struct synaptics_data *priv = psmouse->private;
 205
 206         mode |= SYN_BIT_ABSOLUTE_MODE;
 207         if (psmouse_rate >= 80)
 208                 mode |= SYN_BIT_HIGH_RATE;
 209         if (SYN_ID_MAJOR(priv->identity) >= 4)
 210                 mode |= SYN_BIT_DISABLE_GESTURE;
 211         if (SYN_CAP_EXTENDED(priv->capabilities))
 212                 mode |= SYN_BIT_W_MODE;
 213         if (synaptics_mode_cmd(psmouse, mode))
 214                 return -1;
 215
 216         return 0;
 217 }
 218
 219 /*****************************************************************************
 220  *      Synaptics pass-through PS/2 port support
 221  ****************************************************************************/
 222 static int synaptics_pt_open(struct serio *port)
 223 {
 224         return 0;
 225 }
 226
 227 static void synaptics_pt_close(struct serio *port)
 228 {
 229 }
 230
 231 static int synaptics_pt_write(struct serio *port, unsigned char c)
 232 {
 233         struct psmouse *parent = port->driver;
 234         char rate_param = SYN_PS_CLIENT_CMD; /* indicates that we want pass-through port */
 235
 236         if (synaptics_special_cmd(parent, c))
 237                 return -1;
 238         if (psmouse_command(parent, &rate_param, PSMOUSE_CMD_SETRATE))
 239                 return -1;
 240         return 0;
 241 }
 242
 243 static inline int synaptics_is_pt_packet(unsigned char *buf)
 244 {
 245         return (buf[0] & 0xFC) == 0x84 && (buf[3] & 0xCC) == 0xC4;
 246 }
 247
 248 static void synaptics_pass_pt_packet(struct serio *ptport, unsigned char *packet)
 249 {
 250         struct psmouse *child = ptport->private;
 251
 252         if (child) {
 253                 if (child->state == PSMOUSE_ACTIVATED) {
 254                         serio_interrupt(ptport, packet[1], 0, NULL);
 255                         serio_interrupt(ptport, packet[4], 0, NULL);
 256                         serio_interrupt(ptport, packet[5], 0, NULL);
 257                         if (child->type >= PSMOUSE_GENPS)
 258                                 serio_interrupt(ptport, packet[2], 0, NULL);
 259                 } else if (child->state != PSMOUSE_IGNORE) {
 260                         serio_interrupt(ptport, packet[1], 0, NULL);
 261                 }
 262         }
 263 }
 264
 265 static void synaptics_pt_activate(struct psmouse *psmouse)
 266 {
 267         struct psmouse *child = psmouse->ptport->serio.private;
 268
 269         /* adjust the touchpad to child's choice of protocol */
 270         if (child && child->type >= PSMOUSE_GENPS) {
 271                 if (synaptics_set_mode(psmouse, SYN_BIT_FOUR_BYTE_CLIENT))
 272                         printk(KERN_INFO "synaptics: failed to enable 4-byte guest protocol\n");
 273         }
 274 }
 275
 276 static void synaptics_pt_create(struct psmouse *psmouse)
 277 {
 278         struct psmouse_ptport *port;
 279
 280         psmouse->ptport = port = kmalloc(sizeof(struct psmouse_ptport), GFP_KERNEL);
 281         if (!port) {
 282                 printk(KERN_ERR "synaptics: not enough memory to allocate pass-through port\n");
 283                 return;
 284         }
 285
 286         memset(port, 0, sizeof(struct psmouse_ptport));
 287
 288         port->serio.type = SERIO_PS_PSTHRU;
 289         port->serio.name = "Synaptics pass-through";
 290         port->serio.phys = "synaptics-pt/serio0";
 291         port->serio.write = synaptics_pt_write;
 292         port->serio.open = synaptics_pt_open;
 293         port->serio.close = synaptics_pt_close;
 294         port->serio.driver = psmouse;
 295
 296         port->activate = synaptics_pt_activate;
 297 }
 298
 299 /*****************************************************************************
 300  *      Driver initialization/cleanup functions
 301  ****************************************************************************/
 302
 303 static inline void set_abs_params(struct input_dev *dev, int axis, int min, int max, int fuzz, int flat)
 304 {
 305         dev->absmin[axis] = min;
 306         dev->absmax[axis] = max;
 307         dev->absfuzz[axis] = fuzz;
 308         dev->absflat[axis] = flat;
 309
 310         set_bit(axis, dev->absbit);
 311 }
 312
 313 static void set_input_params(struct input_dev *dev, struct synaptics_data *priv)
 314 {
 315         set_bit(EV_ABS, dev->evbit);
 316         set_abs_params(dev, ABS_X, XMIN_NOMINAL, XMAX_NOMINAL, 0, 0);
 317         set_abs_params(dev, ABS_Y, YMIN_NOMINAL, YMAX_NOMINAL, 0, 0);
 318         set_abs_params(dev, ABS_PRESSURE, 0, 255, 0, 0);
 319         set_bit(ABS_TOOL_WIDTH, dev->absbit);
 320
 321         set_bit(EV_KEY, dev->evbit);
 322         set_bit(BTN_TOUCH, dev->keybit);
 323         set_bit(BTN_TOOL_FINGER, dev->keybit);
 324         set_bit(BTN_TOOL_DOUBLETAP, dev->keybit);
 325         set_bit(BTN_TOOL_TRIPLETAP, dev->keybit);
 326
 327         set_bit(BTN_LEFT, dev->keybit);
 328         set_bit(BTN_RIGHT, dev->keybit);
 329         set_bit(BTN_FORWARD, dev->keybit);
 330         set_bit(BTN_BACK, dev->keybit);
 331         if (SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap)) {
 332                 switch (SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap) & ~0x01) {
 333                 default:
 334                         /*
 335                          * if nExtBtn is greater than 8 it should be considered
 336                          * invalid and treated as 0
 337                          */
 338                         break;
 339                 case 8:
 340                         set_bit(BTN_7, dev->keybit);
 341                         set_bit(BTN_6, dev->keybit);
 342                 case 6:
 343                         set_bit(BTN_5, dev->keybit);
 344                         set_bit(BTN_4, dev->keybit);
 345                 case 4:
 346                         set_bit(BTN_3, dev->keybit);
 347                         set_bit(BTN_2, dev->keybit);
 348                 case 2:
 349                         set_bit(BTN_1, dev->keybit);
 350                         set_bit(BTN_0, dev->keybit);
 351                         break;
 352                 }
 353         }
 354
 355         clear_bit(EV_REL, dev->evbit);
 356         clear_bit(REL_X, dev->relbit);
 357         clear_bit(REL_Y, dev->relbit);
 358 }
 359
 360 void synaptics_reset(struct psmouse *psmouse)
 361 {
 362         /* reset touchpad back to relative mode, gestures enabled */
 363         synaptics_mode_cmd(psmouse, 0);
 364 }
 365
 366 static void synaptics_disconnect(struct psmouse *psmouse)
 367 {
 368         synaptics_reset(psmouse);
 369         kfree(psmouse->private);
 370 }
 371
 372 static int synaptics_reconnect(struct psmouse *psmouse)
 373 {
 374         struct synaptics_data *priv = psmouse->private;
 375         struct synaptics_data old_priv = *priv;
 376
 377         if (!synaptics_detect(psmouse))
 378                 return -1;
 379
 380         if (synaptics_query_hardware(psmouse)) {
 381                 printk(KERN_ERR "Unable to query Synaptics hardware.\n");
 382                 return -1;
 383         }
 384
 385         if (old_priv.identity != priv->identity ||
 386             old_priv.model_id != priv->model_id ||
 387             old_priv.capabilities != priv->capabilities ||
 388             old_priv.ext_cap != priv->ext_cap)
 389                 return -1;
 390
 391         if (synaptics_set_mode(psmouse, 0)) {
 392                 printk(KERN_ERR "Unable to initialize Synaptics hardware.\n");
 393                 return -1;
 394         }
 395
 396         return 0;
 397 }
 398
 399 int synaptics_detect(struct psmouse *psmouse)
 400 {
 401         unsigned char param[4];
 402
 403         param[0] = 0;
 404
 405         psmouse_command(psmouse, param, PSMOUSE_CMD_SETRES);
 406         psmouse_command(psmouse, param, PSMOUSE_CMD_SETRES);
 407         psmouse_command(psmouse, param, PSMOUSE_CMD_SETRES);
 408         psmouse_command(psmouse, param, PSMOUSE_CMD_SETRES);
 409         psmouse_command(psmouse, param, PSMOUSE_CMD_GETINFO);
 410
 411         return param[1] == 0x47;
 412 }
 413
 414 int synaptics_init(struct psmouse *psmouse)
 415 {
 416         struct synaptics_data *priv;
 417
 418         psmouse->private = priv = kmalloc(sizeof(struct synaptics_data), GFP_KERNEL);
 419         if (!priv)
 420                 return -1;
 421         memset(priv, 0, sizeof(struct synaptics_data));
 422
 423         if (synaptics_query_hardware(psmouse)) {
 424                 printk(KERN_ERR "Unable to query Synaptics hardware.\n");
 425                 goto init_fail;
 426         }
 427
 428         if (synaptics_set_mode(psmouse, 0)) {
 429                 printk(KERN_ERR "Unable to initialize Synaptics hardware.\n");
 430                 goto init_fail;
 431         }
 432
 433         priv->pkt_type = SYN_MODEL_NEWABS(priv->model_id) ? SYN_NEWABS : SYN_OLDABS;
 434
 435         if (SYN_CAP_EXTENDED(priv->capabilities) && SYN_CAP_PASS_THROUGH(priv->capabilities))
 436                 synaptics_pt_create(psmouse);
 437
 438         print_ident(priv);
 439         set_input_params(&psmouse->dev, priv);
 440
 441         psmouse->disconnect = synaptics_disconnect;
 442         psmouse->reconnect = synaptics_reconnect;
 443
 444         return 0;
 445
 446  init_fail:
 447         kfree(priv);
 448         return -1;
 449 }
 450
 451 /*****************************************************************************
 452  *      Functions to interpret the absolute mode packets
 453  ****************************************************************************/
 454
 455 static void synaptics_parse_hw_state(unsigned char buf[], struct synaptics_data *priv, struct synaptics_hw_state *hw)
 456 {
 457         memset(hw, 0, sizeof(struct synaptics_hw_state));
 458
 459         if (SYN_MODEL_NEWABS(priv->model_id)) {
 460                 hw->x = (((buf[3] & 0x10) << 8) |
 461                          ((buf[1] & 0x0f) << 8) |
 462                          buf[4]);
 463                 hw->y = (((buf[3] & 0x20) << 7) |
 464                          ((buf[1] & 0xf0) << 4) |
 465                          buf[5]);
 466
 467                 hw->z = buf[2];
 468                 hw->w = (((buf[0] & 0x30) >> 2) |
 469                          ((buf[0] & 0x04) >> 1) |
 470                          ((buf[3] & 0x04) >> 2));
 471
 472                 hw->left  = (buf[0] & 0x01) ? 1 : 0;
 473                 hw->right = (buf[0] & 0x02) ? 1 : 0;
 474                 if (SYN_CAP_EXTENDED(priv->capabilities) &&
 475                     (SYN_CAP_FOUR_BUTTON(priv->capabilities))) {
 476                         hw->up = ((buf[3] & 0x01)) ? 1 : 0;
 477                         if (hw->left)
 478                                 hw->up = !hw->up;
 479                         hw->down = ((buf[3] & 0x02)) ? 1 : 0;
 480                         if (hw->right)
 481                                 hw->down = !hw->down;
 482                 }
 483                 if (SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap) &&
 484                     ((buf[3] & 2) ? !hw->right : hw->right)) {
 485                         switch (SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap) & ~0x01) {
 486                         default:
 487                                 /*
 488                                  * if nExtBtn is greater than 8 it should be
 489                                  * considered invalid and treated as 0
 490                                  */
 491                                 break;
 492                         case 8:
 493                                 hw->b7 = ((buf[5] & 0x08)) ? 1 : 0;
 494                                 hw->b6 = ((buf[4] & 0x08)) ? 1 : 0;
 495                         case 6:
 496                                 hw->b5 = ((buf[5] & 0x04)) ? 1 : 0;
 497                                 hw->b4 = ((buf[4] & 0x04)) ? 1 : 0;
 498                         case 4:
 499                                 hw->b3 = ((buf[5] & 0x02)) ? 1 : 0;
 500                                 hw->b2 = ((buf[4] & 0x02)) ? 1 : 0;
 501                         case 2:
 502                                 hw->b1 = ((buf[5] & 0x01)) ? 1 : 0;
 503                                 hw->b0 = ((buf[4] & 0x01)) ? 1 : 0;
 504                         }
 505                 }
 506         } else {
 507                 hw->x = (((buf[1] & 0x1f) << 8) | buf[2]);
 508                 hw->y = (((buf[4] & 0x1f) << 8) | buf[5]);
 509
 510                 hw->z = (((buf[0] & 0x30) << 2) | (buf[3] & 0x3F));
 511                 hw->w = (((buf[1] & 0x80) >> 4) | ((buf[0] & 0x04) >> 1));
 512
 513                 hw->left  = (buf[0] & 0x01) ? 1 : 0;
 514                 hw->right = (buf[0] & 0x02) ? 1 : 0;
 515         }
 516 }
 517
 518 /*
 519  *  called for each full received packet from the touchpad
 520  */
 521 static void synaptics_process_packet(struct psmouse *psmouse)
 522 {
 523         struct input_dev *dev = &psmouse->dev;
 524         struct synaptics_data *priv = psmouse->private;
 525         struct synaptics_hw_state hw;
 526         int num_fingers;
 527         int finger_width;
 528
 529         synaptics_parse_hw_state(psmouse->packet, priv, &hw);
 530
 531         if (hw.z > 0) {
 532                 num_fingers = 1;
 533                 finger_width = 5;
 534                 if (SYN_CAP_EXTENDED(priv->capabilities)) {
 535                         switch (hw.w) {
 536                         case 0 ... 1:
 537                                 if (SYN_CAP_MULTIFINGER(priv->capabilities))
 538                                         num_fingers = hw.w + 2;
 539                                 break;
 540                         case 2:
 541                                 if (SYN_MODEL_PEN(priv->model_id))
 542                                         ;   /* Nothing, treat a pen as a single finger */
 543                                 break;
 544                         case 4 ... 15:
 545                                 if (SYN_CAP_PALMDETECT(priv->capabilities))
 546                                         finger_width = hw.w;
 547                                 break;
 548                         }
 549                 }
 550         } else {
 551                 num_fingers = 0;
 552                 finger_width = 0;
 553         }
 554
 555         /* Post events
 556          * BTN_TOUCH has to be first as mousedev relies on it when doing
 557          * absolute -> relative conversion
 558          */
 559         if (hw.z > 30) input_report_key(dev, BTN_TOUCH, 1);
 560         if (hw.z < 25) input_report_key(dev, BTN_TOUCH, 0);
 561
 562         if (hw.z > 0) {
 563                 input_report_abs(dev, ABS_X, hw.x);
 564                 input_report_abs(dev, ABS_Y, YMAX_NOMINAL + YMIN_NOMINAL - hw.y);
 565         }
 566         input_report_abs(dev, ABS_PRESSURE, hw.z);
 567
 568         input_report_abs(dev, ABS_TOOL_WIDTH, finger_width);
 569         input_report_key(dev, BTN_TOOL_FINGER, num_fingers == 1);
 570         input_report_key(dev, BTN_TOOL_DOUBLETAP, num_fingers == 2);
 571         input_report_key(dev, BTN_TOOL_TRIPLETAP, num_fingers == 3);
 572
 573         input_report_key(dev, BTN_LEFT,    hw.left);
 574         input_report_key(dev, BTN_RIGHT,   hw.right);
 575         input_report_key(dev, BTN_FORWARD, hw.up);
 576         input_report_key(dev, BTN_BACK,    hw.down);
 577         if (SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap))
 578                 switch(SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap) & ~0x01) {
 579                 default:
 580                         /*
 581                          * if nExtBtn is greater than 8 it should be considered
 582                          * invalid and treated as 0
 583                          */
 584                         break;
 585                 case 8:
 586                         input_report_key(dev, BTN_7,       hw.b7);
 587                         input_report_key(dev, BTN_6,       hw.b6);
 588                 case 6:
 589                         input_report_key(dev, BTN_5,       hw.b5);
 590                         input_report_key(dev, BTN_4,       hw.b4);
 591                 case 4:
 592                         input_report_key(dev, BTN_3,       hw.b3);
 593                         input_report_key(dev, BTN_2,       hw.b2);
 594                 case 2:
 595                         input_report_key(dev, BTN_1,       hw.b1);
 596                         input_report_key(dev, BTN_0,       hw.b0);
 597                         break;
 598                 }
 599         input_sync(dev);
 600 }
 601
 602 static int synaptics_validate_byte(unsigned char packet[], int idx, unsigned char pkt_type)
 603 {
 604         static unsigned char newabs_mask[]      = { 0xC8, 0x00, 0x00, 0xC8, 0x00 };
 605         static unsigned char newabs_rel_mask[]  = { 0xC0, 0x00, 0x00, 0xC0, 0x00 };
 606         static unsigned char newabs_rslt[]      = { 0x80, 0x00, 0x00, 0xC0, 0x00 };
 607         static unsigned char oldabs_mask[]      = { 0xC0, 0x60, 0x00, 0xC0, 0x60 };
 608         static unsigned char oldabs_rslt[]      = { 0xC0, 0x00, 0x00, 0x80, 0x00 };
 609
 610         switch (pkt_type) {
 611                 case SYN_NEWABS:
 612                 case SYN_NEWABS_RELAXED:
 613                         return (packet[idx] & newabs_rel_mask[idx]) == newabs_rslt[idx];
 614
 615                 case SYN_NEWABS_STRICT:
 616                         return (packet[idx] & newabs_mask[idx]) == newabs_rslt[idx];
 617
 618                 case SYN_OLDABS:
 619                         return (packet[idx] & oldabs_mask[idx]) == oldabs_rslt[idx];
 620
 621                 default:
 622                         printk(KERN_ERR "synaptics: unknown packet type %d\n", pkt_type);
 623                         return 0;
 624         }
 625 }
 626
 627 static unsigned char synaptics_detect_pkt_type(struct psmouse *psmouse)
 628 {
 629         int i;
 630
 631         for (i = 0; i < 5; i++)
 632                 if (!synaptics_validate_byte(psmouse->packet, i, SYN_NEWABS_STRICT)) {
 633                         printk(KERN_INFO "synaptics: using relaxed packet validation\n");
 634                         return SYN_NEWABS_RELAXED;
 635                 }
 636
 637         return SYN_NEWABS_STRICT;
 638 }
 639
 640 void synaptics_process_byte(struct psmouse *psmouse, struct pt_regs *regs)
 641 {
 642         struct input_dev *dev = &psmouse->dev;
 643         struct synaptics_data *priv = psmouse->private;
 644
 645         input_regs(dev, regs);
 646
 647         if (psmouse->pktcnt >= 6) { /* Full packet received */
 648                 if (priv->out_of_sync) {
 649                         priv->out_of_sync = 0;
 650                         printk(KERN_NOTICE "Synaptics driver resynced.\n");
 651                 }
 652
 653                 if (unlikely(priv->pkt_type == SYN_NEWABS))
 654                         priv->pkt_type = synaptics_detect_pkt_type(psmouse);
 655
 656                 if (psmouse->ptport && psmouse->ptport->serio.dev && synaptics_is_pt_packet(psmouse->packet))
 657                         synaptics_pass_pt_packet(&psmouse->ptport->serio, psmouse->packet);
 658                 else
 659                         synaptics_process_packet(psmouse);
 660                 psmouse->pktcnt = 0;
 661
 662         } else if (psmouse->pktcnt &&
 663                    !synaptics_validate_byte(psmouse->packet, psmouse->pktcnt - 1, priv->pkt_type)) {
 664                 printk(KERN_WARNING "Synaptics driver lost sync at byte %d\n", psmouse->pktcnt);
 665                 psmouse->pktcnt = 0;
 666                 if (++priv->out_of_sync == psmouse_resetafter) {
 667                         psmouse->state = PSMOUSE_IGNORE;
 668                         printk(KERN_NOTICE "synaptics: issuing reconnect request\n");
 669                         serio_reconnect(psmouse->serio);
 670                 }
 671         }
 672 }