drivers/input/mouse/sentelic.c

   1 /*-
   2  * Finger Sensing Pad PS/2 mouse driver.
   3  *
   4  * Copyright (C) 2005-2007 Asia Vital Components Co., Ltd.
   5  * Copyright (C) 2005-2012 Tai-hwa Liang, Sentelic Corporation.
   6  *
   7  *   This program is free software; you can redistribute it and/or
   8  *   modify it under the terms of the GNU General Public License
   9  *   as published by the Free Software Foundation; either version 2
  10  *   of the License, or (at your option) any later version.
  11  *
  12  *   This program is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *   GNU General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU General Public License
  18  *   along with this program; if not, write to the Free Software
  19  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 #include <linux/module.h>
  23 #include <linux/input.h>
  24 #include <linux/input/mt.h>
  25 #include <linux/ctype.h>
  26 #include <linux/libps2.h>
  27 #include <linux/serio.h>
  28 #include <linux/jiffies.h>
  29 #include <linux/slab.h>
  30
  31 #include "psmouse.h"
  32 #include "sentelic.h"
  33
  34 /*
  35  * Timeout for FSP PS/2 command only (in milliseconds).
  36  */
  37 #define FSP_CMD_TIMEOUT         200
  38 #define FSP_CMD_TIMEOUT2        30
  39
  40 /** Driver version. */
  41 static const char fsp_drv_ver[] = "1.0.0-K";
  42
  43 /*
  44  * Make sure that the value being sent to FSP will not conflict with
  45  * possible sample rate values.
  46  */
  47 static unsigned char fsp_test_swap_cmd(unsigned char reg_val)
  48 {
  49         switch (reg_val) {
  50         case 10: case 20: case 40: case 60: case 80: case 100: case 200:
  51                 /*
  52                  * The requested value being sent to FSP matched to possible
  53                  * sample rates, swap the given value such that the hardware
  54                  * wouldn't get confused.
  55                  */
  56                 return (reg_val >> 4) | (reg_val << 4);
  57         default:
  58                 return reg_val; /* swap isn't necessary */
  59         }
  60 }
  61
  62 /*
  63  * Make sure that the value being sent to FSP will not conflict with certain
  64  * commands.
  65  */
  66 static unsigned char fsp_test_invert_cmd(unsigned char reg_val)
  67 {
  68         switch (reg_val) {
  69         case 0xe9: case 0xee: case 0xf2: case 0xff:
  70                 /*
  71                  * The requested value being sent to FSP matched to certain
  72                  * commands, inverse the given value such that the hardware
  73                  * wouldn't get confused.
  74                  */
  75                 return ~reg_val;
  76         default:
  77                 return reg_val; /* inversion isn't necessary */
  78         }
  79 }
  80
  81 static int fsp_reg_read(struct psmouse *psmouse, int reg_addr, int *reg_val)
  82 {
  83         struct ps2dev *ps2dev = &psmouse->ps2dev;
  84         unsigned char param[3];
  85         unsigned char addr;
  86         int rc = -1;
  87
  88         /*
  89          * We need to shut off the device and switch it into command
  90          * mode so we don't confuse our protocol handler. We don't need
  91          * to do that for writes because sysfs set helper does this for
  92          * us.
  93          */
  94         psmouse_deactivate(psmouse);
  95
  96         ps2_begin_command(ps2dev);
  97
  98         if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
  99                 goto out;
 100
 101         /* should return 0xfe(request for resending) */
 102         ps2_sendbyte(ps2dev, 0x66, FSP_CMD_TIMEOUT2);
 103         /* should return 0xfc(failed) */
 104         ps2_sendbyte(ps2dev, 0x88, FSP_CMD_TIMEOUT2);
 105
 106         if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
 107                 goto out;
 108
 109         if ((addr = fsp_test_invert_cmd(reg_addr)) != reg_addr) {
 110                 ps2_sendbyte(ps2dev, 0x68, FSP_CMD_TIMEOUT2);
 111         } else if ((addr = fsp_test_swap_cmd(reg_addr)) != reg_addr) {
 112                 /* swapping is required */
 113                 ps2_sendbyte(ps2dev, 0xcc, FSP_CMD_TIMEOUT2);
 114                 /* expect 0xfe */
 115         } else {
 116                 /* swapping isn't necessary */
 117                 ps2_sendbyte(ps2dev, 0x66, FSP_CMD_TIMEOUT2);
 118                 /* expect 0xfe */
 119         }
 120         /* should return 0xfc(failed) */
 121         ps2_sendbyte(ps2dev, addr, FSP_CMD_TIMEOUT);
 122
 123         if (__ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO) < 0)
 124                 goto out;
 125
 126         *reg_val = param[2];
 127         rc = 0;
 128
 129  out:
 130         ps2_end_command(ps2dev);
 131         psmouse_activate(psmouse);
 132         psmouse_dbg(psmouse,
 133                     "READ REG: 0x%02x is 0x%02x (rc = %d)\n",
 134                     reg_addr, *reg_val, rc);
 135         return rc;
 136 }
 137
 138 static int fsp_reg_write(struct psmouse *psmouse, int reg_addr, int reg_val)
 139 {
 140         struct ps2dev *ps2dev = &psmouse->ps2dev;
 141         unsigned char v;
 142         int rc = -1;
 143
 144         ps2_begin_command(ps2dev);
 145
 146         if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
 147                 goto out;
 148
 149         if ((v = fsp_test_invert_cmd(reg_addr)) != reg_addr) {
 150                 /* inversion is required */
 151                 ps2_sendbyte(ps2dev, 0x74, FSP_CMD_TIMEOUT2);
 152         } else {
 153                 if ((v = fsp_test_swap_cmd(reg_addr)) != reg_addr) {
 154                         /* swapping is required */
 155                         ps2_sendbyte(ps2dev, 0x77, FSP_CMD_TIMEOUT2);
 156                 } else {
 157                         /* swapping isn't necessary */
 158                         ps2_sendbyte(ps2dev, 0x55, FSP_CMD_TIMEOUT2);
 159                 }
 160         }
 161         /* write the register address in correct order */
 162         ps2_sendbyte(ps2dev, v, FSP_CMD_TIMEOUT2);
 163
 164         if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
 165                 goto out;
 166
 167         if ((v = fsp_test_invert_cmd(reg_val)) != reg_val) {
 168                 /* inversion is required */
 169                 ps2_sendbyte(ps2dev, 0x47, FSP_CMD_TIMEOUT2);
 170         } else if ((v = fsp_test_swap_cmd(reg_val)) != reg_val) {
 171                 /* swapping is required */
 172                 ps2_sendbyte(ps2dev, 0x44, FSP_CMD_TIMEOUT2);
 173         } else {
 174                 /* swapping isn't necessary */
 175                 ps2_sendbyte(ps2dev, 0x33, FSP_CMD_TIMEOUT2);
 176         }
 177
 178         /* write the register value in correct order */
 179         ps2_sendbyte(ps2dev, v, FSP_CMD_TIMEOUT2);
 180         rc = 0;
 181
 182  out:
 183         ps2_end_command(ps2dev);
 184         psmouse_dbg(psmouse,
 185                     "WRITE REG: 0x%02x to 0x%02x (rc = %d)\n",
 186                     reg_addr, reg_val, rc);
 187         return rc;
 188 }
 189
 190 /* Enable register clock gating for writing certain registers */
 191 static int fsp_reg_write_enable(struct psmouse *psmouse, bool enable)
 192 {
 193         int v, nv;
 194
 195         if (fsp_reg_read(psmouse, FSP_REG_SYSCTL1, &v) == -1)
 196                 return -1;
 197
 198         if (enable)
 199                 nv = v | FSP_BIT_EN_REG_CLK;
 200         else
 201                 nv = v & ~FSP_BIT_EN_REG_CLK;
 202
 203         /* only write if necessary */
 204         if (nv != v)
 205                 if (fsp_reg_write(psmouse, FSP_REG_SYSCTL1, nv) == -1)
 206                         return -1;
 207
 208         return 0;
 209 }
 210
 211 static int fsp_page_reg_read(struct psmouse *psmouse, int *reg_val)
 212 {
 213         struct ps2dev *ps2dev = &psmouse->ps2dev;
 214         unsigned char param[3];
 215         int rc = -1;
 216
 217         psmouse_deactivate(psmouse);
 218
 219         ps2_begin_command(ps2dev);
 220
 221         if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
 222                 goto out;
 223
 224         ps2_sendbyte(ps2dev, 0x66, FSP_CMD_TIMEOUT2);
 225         ps2_sendbyte(ps2dev, 0x88, FSP_CMD_TIMEOUT2);
 226
 227         if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
 228                 goto out;
 229
 230         ps2_sendbyte(ps2dev, 0x83, FSP_CMD_TIMEOUT2);
 231         ps2_sendbyte(ps2dev, 0x88, FSP_CMD_TIMEOUT2);
 232
 233         /* get the returned result */
 234         if (__ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO))
 235                 goto out;
 236
 237         *reg_val = param[2];
 238         rc = 0;
 239
 240  out:
 241         ps2_end_command(ps2dev);
 242         psmouse_activate(psmouse);
 243         psmouse_dbg(psmouse,
 244                     "READ PAGE REG: 0x%02x (rc = %d)\n",
 245                     *reg_val, rc);
 246         return rc;
 247 }
 248
 249 static int fsp_page_reg_write(struct psmouse *psmouse, int reg_val)
 250 {
 251         struct ps2dev *ps2dev = &psmouse->ps2dev;
 252         unsigned char v;
 253         int rc = -1;
 254
 255         ps2_begin_command(ps2dev);
 256
 257         if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
 258                 goto out;
 259
 260         ps2_sendbyte(ps2dev, 0x38, FSP_CMD_TIMEOUT2);
 261         ps2_sendbyte(ps2dev, 0x88, FSP_CMD_TIMEOUT2);
 262
 263         if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
 264                 goto out;
 265
 266         if ((v = fsp_test_invert_cmd(reg_val)) != reg_val) {
 267                 ps2_sendbyte(ps2dev, 0x47, FSP_CMD_TIMEOUT2);
 268         } else if ((v = fsp_test_swap_cmd(reg_val)) != reg_val) {
 269                 /* swapping is required */
 270                 ps2_sendbyte(ps2dev, 0x44, FSP_CMD_TIMEOUT2);
 271         } else {
 272                 /* swapping isn't necessary */
 273                 ps2_sendbyte(ps2dev, 0x33, FSP_CMD_TIMEOUT2);
 274         }
 275
 276         ps2_sendbyte(ps2dev, v, FSP_CMD_TIMEOUT2);
 277         rc = 0;
 278
 279  out:
 280         ps2_end_command(ps2dev);
 281         psmouse_dbg(psmouse,
 282                     "WRITE PAGE REG: to 0x%02x (rc = %d)\n",
 283                     reg_val, rc);
 284         return rc;
 285 }
 286
 287 static int fsp_get_version(struct psmouse *psmouse, int *version)
 288 {
 289         if (fsp_reg_read(psmouse, FSP_REG_VERSION, version))
 290                 return -EIO;
 291
 292         return 0;
 293 }
 294
 295 static int fsp_get_revision(struct psmouse *psmouse, int *rev)
 296 {
 297         if (fsp_reg_read(psmouse, FSP_REG_REVISION, rev))
 298                 return -EIO;
 299
 300         return 0;
 301 }
 302
 303 static int fsp_get_buttons(struct psmouse *psmouse, int *btn)
 304 {
 305         static const int buttons[] = {
 306                 0x16, /* Left/Middle/Right/Forward/Backward & Scroll Up/Down */
 307                 0x06, /* Left/Middle/Right & Scroll Up/Down/Right/Left */
 308                 0x04, /* Left/Middle/Right & Scroll Up/Down */
 309                 0x02, /* Left/Middle/Right */
 310         };
 311         int val;
 312
 313         if (fsp_reg_read(psmouse, FSP_REG_TMOD_STATUS, &val) == -1)
 314                 return -EIO;
 315
 316         *btn = buttons[(val & 0x30) >> 4];
 317         return 0;
 318 }
 319
 320 /* Enable on-pad command tag output */
 321 static int fsp_opc_tag_enable(struct psmouse *psmouse, bool enable)
 322 {
 323         int v, nv;
 324         int res = 0;
 325
 326         if (fsp_reg_read(psmouse, FSP_REG_OPC_QDOWN, &v) == -1) {
 327                 psmouse_err(psmouse, "Unable get OPC state.\n");
 328                 return -EIO;
 329         }
 330
 331         if (enable)
 332                 nv = v | FSP_BIT_EN_OPC_TAG;
 333         else
 334                 nv = v & ~FSP_BIT_EN_OPC_TAG;
 335
 336         /* only write if necessary */
 337         if (nv != v) {
 338                 fsp_reg_write_enable(psmouse, true);
 339                 res = fsp_reg_write(psmouse, FSP_REG_OPC_QDOWN, nv);
 340                 fsp_reg_write_enable(psmouse, false);
 341         }
 342
 343         if (res != 0) {
 344                 psmouse_err(psmouse, "Unable to enable OPC tag.\n");
 345                 res = -EIO;
 346         }
 347
 348         return res;
 349 }
 350
 351 static int fsp_onpad_vscr(struct psmouse *psmouse, bool enable)
 352 {
 353         struct fsp_data *pad = psmouse->private;
 354         int val;
 355
 356         if (fsp_reg_read(psmouse, FSP_REG_ONPAD_CTL, &val))
 357                 return -EIO;
 358
 359         pad->vscroll = enable;
 360
 361         if (enable)
 362                 val |= (FSP_BIT_FIX_VSCR | FSP_BIT_ONPAD_ENABLE);
 363         else
 364                 val &= ~FSP_BIT_FIX_VSCR;
 365
 366         if (fsp_reg_write(psmouse, FSP_REG_ONPAD_CTL, val))
 367                 return -EIO;
 368
 369         return 0;
 370 }
 371
 372 static int fsp_onpad_hscr(struct psmouse *psmouse, bool enable)
 373 {
 374         struct fsp_data *pad = psmouse->private;
 375         int val, v2;
 376
 377         if (fsp_reg_read(psmouse, FSP_REG_ONPAD_CTL, &val))
 378                 return -EIO;
 379
 380         if (fsp_reg_read(psmouse, FSP_REG_SYSCTL5, &v2))
 381                 return -EIO;
 382
 383         pad->hscroll = enable;
 384
 385         if (enable) {
 386                 val |= (FSP_BIT_FIX_HSCR | FSP_BIT_ONPAD_ENABLE);
 387                 v2 |= FSP_BIT_EN_MSID6;
 388         } else {
 389                 val &= ~FSP_BIT_FIX_HSCR;
 390                 v2 &= ~(FSP_BIT_EN_MSID6 | FSP_BIT_EN_MSID7 | FSP_BIT_EN_MSID8);
 391         }
 392
 393         if (fsp_reg_write(psmouse, FSP_REG_ONPAD_CTL, val))
 394                 return -EIO;
 395
 396         /* reconfigure horizontal scrolling packet output */
 397         if (fsp_reg_write(psmouse, FSP_REG_SYSCTL5, v2))
 398                 return -EIO;
 399
 400         return 0;
 401 }
 402
 403 /*
 404  * Write device specific initial parameters.
 405  *
 406  * ex: 0xab 0xcd - write oxcd into register 0xab
 407  */
 408 static ssize_t fsp_attr_set_setreg(struct psmouse *psmouse, void *data,
 409                                    const char *buf, size_t count)
 410 {
 411         unsigned long reg, val;
 412         char *rest;
 413         ssize_t retval;
 414
 415         reg = simple_strtoul(buf, &rest, 16);
 416         if (rest == buf || *rest != ' ' || reg > 0xff)
 417                 return -EINVAL;
 418
 419         if (strict_strtoul(rest + 1, 16, &val) || val > 0xff)
 420                 return -EINVAL;
 421
 422         if (fsp_reg_write_enable(psmouse, true))
 423                 return -EIO;
 424
 425         retval = fsp_reg_write(psmouse, reg, val) < 0 ? -EIO : count;
 426
 427         fsp_reg_write_enable(psmouse, false);
 428
 429         return count;
 430 }
 431
 432 PSMOUSE_DEFINE_WO_ATTR(setreg, S_IWUSR, NULL, fsp_attr_set_setreg);
 433
 434 static ssize_t fsp_attr_show_getreg(struct psmouse *psmouse,
 435                                         void *data, char *buf)
 436 {
 437         struct fsp_data *pad = psmouse->private;
 438
 439         return sprintf(buf, "%02x%02x\n", pad->last_reg, pad->last_val);
 440 }
 441
 442 /*
 443  * Read a register from device.
 444  *
 445  * ex: 0xab -- read content from register 0xab
 446  */
 447 static ssize_t fsp_attr_set_getreg(struct psmouse *psmouse, void *data,
 448                                         const char *buf, size_t count)
 449 {
 450         struct fsp_data *pad = psmouse->private;
 451         unsigned long reg;
 452         int val;
 453
 454         if (strict_strtoul(buf, 16, &reg) || reg > 0xff)
 455                 return -EINVAL;
 456
 457         if (fsp_reg_read(psmouse, reg, &val))
 458                 return -EIO;
 459
 460         pad->last_reg = reg;
 461         pad->last_val = val;
 462
 463         return count;
 464 }
 465
 466 PSMOUSE_DEFINE_ATTR(getreg, S_IWUSR | S_IRUGO, NULL,
 467                         fsp_attr_show_getreg, fsp_attr_set_getreg);
 468
 469 static ssize_t fsp_attr_show_pagereg(struct psmouse *psmouse,
 470                                         void *data, char *buf)
 471 {
 472         int val = 0;
 473
 474         if (fsp_page_reg_read(psmouse, &val))
 475                 return -EIO;
 476
 477         return sprintf(buf, "%02x\n", val);
 478 }
 479
 480 static ssize_t fsp_attr_set_pagereg(struct psmouse *psmouse, void *data,
 481                                         const char *buf, size_t count)
 482 {
 483         unsigned long val;
 484
 485         if (strict_strtoul(buf, 16, &val) || val > 0xff)
 486                 return -EINVAL;
 487
 488         if (fsp_page_reg_write(psmouse, val))
 489                 return -EIO;
 490
 491         return count;
 492 }
 493
 494 PSMOUSE_DEFINE_ATTR(page, S_IWUSR | S_IRUGO, NULL,
 495                         fsp_attr_show_pagereg, fsp_attr_set_pagereg);
 496
 497 static ssize_t fsp_attr_show_vscroll(struct psmouse *psmouse,
 498                                         void *data, char *buf)
 499 {
 500         struct fsp_data *pad = psmouse->private;
 501
 502         return sprintf(buf, "%d\n", pad->vscroll);
 503 }
 504
 505 static ssize_t fsp_attr_set_vscroll(struct psmouse *psmouse, void *data,
 506                                         const char *buf, size_t count)
 507 {
 508         unsigned long val;
 509
 510         if (strict_strtoul(buf, 10, &val) || val > 1)
 511                 return -EINVAL;
 512
 513         fsp_onpad_vscr(psmouse, val);
 514
 515         return count;
 516 }
 517
 518 PSMOUSE_DEFINE_ATTR(vscroll, S_IWUSR | S_IRUGO, NULL,
 519                         fsp_attr_show_vscroll, fsp_attr_set_vscroll);
 520
 521 static ssize_t fsp_attr_show_hscroll(struct psmouse *psmouse,
 522                                         void *data, char *buf)
 523 {
 524         struct fsp_data *pad = psmouse->private;
 525
 526         return sprintf(buf, "%d\n", pad->hscroll);
 527 }
 528
 529 static ssize_t fsp_attr_set_hscroll(struct psmouse *psmouse, void *data,
 530                                         const char *buf, size_t count)
 531 {
 532         unsigned long val;
 533
 534         if (strict_strtoul(buf, 10, &val) || val > 1)
 535                 return -EINVAL;
 536
 537         fsp_onpad_hscr(psmouse, val);
 538
 539         return count;
 540 }
 541
 542 PSMOUSE_DEFINE_ATTR(hscroll, S_IWUSR | S_IRUGO, NULL,
 543                         fsp_attr_show_hscroll, fsp_attr_set_hscroll);
 544
 545 static ssize_t fsp_attr_show_flags(struct psmouse *psmouse,
 546                                         void *data, char *buf)
 547 {
 548         struct fsp_data *pad = psmouse->private;
 549
 550         return sprintf(buf, "%c\n",
 551                         pad->flags & FSPDRV_FLAG_EN_OPC ? 'C' : 'c');
 552 }
 553
 554 static ssize_t fsp_attr_set_flags(struct psmouse *psmouse, void *data,
 555                                         const char *buf, size_t count)
 556 {
 557         struct fsp_data *pad = psmouse->private;
 558         size_t i;
 559
 560         for (i = 0; i < count; i++) {
 561                 switch (buf[i]) {
 562                 case 'C':
 563                         pad->flags |= FSPDRV_FLAG_EN_OPC;
 564                         break;
 565                 case 'c':
 566                         pad->flags &= ~FSPDRV_FLAG_EN_OPC;
 567                         break;
 568                 default:
 569                         return -EINVAL;
 570                 }
 571         }
 572         return count;
 573 }
 574
 575 PSMOUSE_DEFINE_ATTR(flags, S_IWUSR | S_IRUGO, NULL,
 576                         fsp_attr_show_flags, fsp_attr_set_flags);
 577
 578 static ssize_t fsp_attr_show_ver(struct psmouse *psmouse,
 579                                         void *data, char *buf)
 580 {
 581         return sprintf(buf, "Sentelic FSP kernel module %s\n", fsp_drv_ver);
 582 }
 583
 584 PSMOUSE_DEFINE_RO_ATTR(ver, S_IRUGO, NULL, fsp_attr_show_ver);
 585
 586 static struct attribute *fsp_attributes[] = {
 587         &psmouse_attr_setreg.dattr.attr,
 588         &psmouse_attr_getreg.dattr.attr,
 589         &psmouse_attr_page.dattr.attr,
 590         &psmouse_attr_vscroll.dattr.attr,
 591         &psmouse_attr_hscroll.dattr.attr,
 592         &psmouse_attr_flags.dattr.attr,
 593         &psmouse_attr_ver.dattr.attr,
 594         NULL
 595 };
 596
 597 static struct attribute_group fsp_attribute_group = {
 598         .attrs = fsp_attributes,
 599 };
 600
 601 #ifdef FSP_DEBUG
 602 static void fsp_packet_debug(unsigned char packet[])
 603 {
 604         static unsigned int ps2_packet_cnt;
 605         static unsigned int ps2_last_second;
 606         unsigned int jiffies_msec;
 607
 608         ps2_packet_cnt++;
 609         jiffies_msec = jiffies_to_msecs(jiffies);
 610         psmouse_dbg(psmouse,
 611                     "%08dms PS/2 packets: %02x, %02x, %02x, %02x\n",
 612                     jiffies_msec, packet[0], packet[1], packet[2], packet[3]);
 613
 614         if (jiffies_msec - ps2_last_second > 1000) {
 615                 psmouse_dbg(psmouse, "PS/2 packets/sec = %d\n", ps2_packet_cnt);
 616                 ps2_packet_cnt = 0;
 617                 ps2_last_second = jiffies_msec;
 618         }
 619 }
 620 #else
 621 static void fsp_packet_debug(unsigned char packet[])
 622 {
 623 }
 624 #endif
 625
 626 static void fsp_set_slot(struct input_dev *dev, int slot, bool active,
 627                          unsigned int x, unsigned int y)
 628 {
 629         input_mt_slot(dev, slot);
 630         input_mt_report_slot_state(dev, MT_TOOL_FINGER, active);
 631         if (active) {
 632                 input_report_abs(dev, ABS_MT_POSITION_X, x);
 633                 input_report_abs(dev, ABS_MT_POSITION_Y, y);
 634         }
 635 }
 636
 637 static psmouse_ret_t fsp_process_byte(struct psmouse *psmouse)
 638 {
 639         struct input_dev *dev = psmouse->dev;
 640         struct fsp_data *ad = psmouse->private;
 641         unsigned char *packet = psmouse->packet;
 642         unsigned char button_status = 0, lscroll = 0, rscroll = 0;
 643         unsigned short abs_x, abs_y, fgrs = 0;
 644         int rel_x, rel_y;
 645
 646         if (psmouse->pktcnt < 4)
 647                 return PSMOUSE_GOOD_DATA;
 648
 649         /*
 650          * Full packet accumulated, process it
 651          */
 652
 653         switch (psmouse->packet[0] >> FSP_PKT_TYPE_SHIFT) {
 654         case FSP_PKT_TYPE_ABS:
 655                 abs_x = (packet[1] << 2) | ((packet[3] >> 2) & 0x03);
 656                 abs_y = (packet[2] << 2) | (packet[3] & 0x03);
 657
 658                 if (packet[0] & FSP_PB0_MFMC) {
 659                         /*
 660                          * MFMC packet: assume that there are two fingers on
 661                          * pad
 662                          */
 663                         fgrs = 2;
 664
 665                         /* MFMC packet */
 666                         if (packet[0] & FSP_PB0_MFMC_FGR2) {
 667                                 /* 2nd finger */
 668                                 if (ad->last_mt_fgr == 2) {
 669                                         /*
 670                                          * workaround for buggy firmware
 671                                          * which doesn't clear MFMC bit if
 672                                          * the 1st finger is up
 673                                          */
 674                                         fgrs = 1;
 675                                         fsp_set_slot(dev, 0, false, 0, 0);
 676                                 }
 677                                 ad->last_mt_fgr = 2;
 678
 679                                 fsp_set_slot(dev, 1, fgrs == 2, abs_x, abs_y);
 680                         } else {
 681                                 /* 1st finger */
 682                                 if (ad->last_mt_fgr == 1) {
 683                                         /*
 684                                          * workaround for buggy firmware
 685                                          * which doesn't clear MFMC bit if
 686                                          * the 2nd finger is up
 687                                          */
 688                                         fgrs = 1;
 689                                         fsp_set_slot(dev, 1, false, 0, 0);
 690                                 }
 691                                 ad->last_mt_fgr = 1;
 692                                 fsp_set_slot(dev, 0, fgrs != 0, abs_x, abs_y);
 693                         }
 694                 } else {
 695                         /* SFAC packet */
 696
 697                         /* no multi-finger information */
 698                         ad->last_mt_fgr = 0;
 699
 700                         if (abs_x != 0 && abs_y != 0)
 701                                 fgrs = 1;
 702
 703                         fsp_set_slot(dev, 0, fgrs > 0, abs_x, abs_y);
 704                         fsp_set_slot(dev, 1, false, 0, 0);
 705                 }
 706                 if (fgrs > 0) {
 707                         input_report_abs(dev, ABS_X, abs_x);
 708                         input_report_abs(dev, ABS_Y, abs_y);
 709                 }
 710                 input_report_key(dev, BTN_LEFT, packet[0] & 0x01);
 711                 input_report_key(dev, BTN_RIGHT, packet[0] & 0x02);
 712                 input_report_key(dev, BTN_TOUCH, fgrs);
 713                 input_report_key(dev, BTN_TOOL_FINGER, fgrs == 1);
 714                 input_report_key(dev, BTN_TOOL_DOUBLETAP, fgrs == 2);
 715                 break;
 716
 717         case FSP_PKT_TYPE_NORMAL_OPC:
 718                 /* on-pad click, filter it if necessary */
 719                 if ((ad->flags & FSPDRV_FLAG_EN_OPC) != FSPDRV_FLAG_EN_OPC)
 720                         packet[0] &= ~FSP_PB0_LBTN;
 721                 /* fall through */
 722
 723         case FSP_PKT_TYPE_NORMAL:
 724                 /* normal packet */
 725                 /* special packet data translation from on-pad packets */
 726                 if (packet[3] != 0) {
 727                         if (packet[3] & BIT(0))
 728                                 button_status |= 0x01;  /* wheel down */
 729                         if (packet[3] & BIT(1))
 730                                 button_status |= 0x0f;  /* wheel up */
 731                         if (packet[3] & BIT(2))
 732                                 button_status |= BIT(4);/* horizontal left */
 733                         if (packet[3] & BIT(3))
 734                                 button_status |= BIT(5);/* horizontal right */
 735                         /* push back to packet queue */
 736                         if (button_status != 0)
 737                                 packet[3] = button_status;
 738                         rscroll = (packet[3] >> 4) & 1;
 739                         lscroll = (packet[3] >> 5) & 1;
 740                 }
 741                 /*
 742                  * Processing wheel up/down and extra button events
 743                  */
 744                 input_report_rel(dev, REL_WHEEL,
 745                                  (int)(packet[3] & 8) - (int)(packet[3] & 7));
 746                 input_report_rel(dev, REL_HWHEEL, lscroll - rscroll);
 747                 input_report_key(dev, BTN_BACK, lscroll);
 748                 input_report_key(dev, BTN_FORWARD, rscroll);
 749
 750                 /*
 751                  * Standard PS/2 Mouse
 752                  */
 753                 input_report_key(dev, BTN_LEFT, packet[0] & 1);
 754                 input_report_key(dev, BTN_MIDDLE, (packet[0] >> 2) & 1);
 755                 input_report_key(dev, BTN_RIGHT, (packet[0] >> 1) & 1);
 756
 757                 rel_x = packet[1] ? (int)packet[1] - (int)((packet[0] << 4) & 0x100) : 0;
 758                 rel_y = packet[2] ? (int)((packet[0] << 3) & 0x100) - (int)packet[2] : 0;
 759
 760                 input_report_rel(dev, REL_X, rel_x);
 761                 input_report_rel(dev, REL_Y, rel_y);
 762                 break;
 763         }
 764
 765         input_sync(dev);
 766
 767         fsp_packet_debug(packet);
 768
 769         return PSMOUSE_FULL_PACKET;
 770 }
 771
 772 static int fsp_activate_protocol(struct psmouse *psmouse)
 773 {
 774         struct fsp_data *pad = psmouse->private;
 775         struct ps2dev *ps2dev = &psmouse->ps2dev;
 776         unsigned char param[2];
 777         int val;
 778
 779         /*
 780          * Standard procedure to enter FSP Intellimouse mode
 781          * (scrolling wheel, 4th and 5th buttons)
 782          */
 783         param[0] = 200;
 784         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
 785         param[0] = 200;
 786         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
 787         param[0] =  80;
 788         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
 789
 790         ps2_command(ps2dev, param, PSMOUSE_CMD_GETID);
 791         if (param[0] != 0x04) {
 792                 psmouse_err(psmouse,
 793                             "Unable to enable 4 bytes packet format.\n");
 794                 return -EIO;
 795         }
 796
 797         if (pad->ver < FSP_VER_STL3888_C0) {
 798                 /* Preparing relative coordinates output for older hardware */
 799                 if (fsp_reg_read(psmouse, FSP_REG_SYSCTL5, &val)) {
 800                         psmouse_err(psmouse,
 801                                     "Unable to read SYSCTL5 register.\n");
 802                         return -EIO;
 803                 }
 804
 805                 if (fsp_get_buttons(psmouse, &pad->buttons)) {
 806                         psmouse_err(psmouse,
 807                                     "Unable to retrieve number of buttons.\n");
 808                         return -EIO;
 809                 }
 810
 811                 val &= ~(FSP_BIT_EN_MSID7 | FSP_BIT_EN_MSID8 | FSP_BIT_EN_AUTO_MSID8);
 812                 /* Ensure we are not in absolute mode */
 813                 val &= ~FSP_BIT_EN_PKT_G0;
 814                 if (pad->buttons == 0x06) {
 815                         /* Left/Middle/Right & Scroll Up/Down/Right/Left */
 816                         val |= FSP_BIT_EN_MSID6;
 817                 }
 818
 819                 if (fsp_reg_write(psmouse, FSP_REG_SYSCTL5, val)) {
 820                         psmouse_err(psmouse,
 821                                     "Unable to set up required mode bits.\n");
 822                         return -EIO;
 823                 }
 824
 825                 /*
 826                  * Enable OPC tags such that driver can tell the difference
 827                  * between on-pad and real button click
 828                  */
 829                 if (fsp_opc_tag_enable(psmouse, true))
 830                         psmouse_warn(psmouse,
 831                                      "Failed to enable OPC tag mode.\n");
 832                 /* enable on-pad click by default */
 833                 pad->flags |= FSPDRV_FLAG_EN_OPC;
 834
 835                 /* Enable on-pad vertical and horizontal scrolling */
 836                 fsp_onpad_vscr(psmouse, true);
 837                 fsp_onpad_hscr(psmouse, true);
 838         } else {
 839                 /* Enable absolute coordinates output for Cx/Dx hardware */
 840                 if (fsp_reg_write(psmouse, FSP_REG_SWC1,
 841                                   FSP_BIT_SWC1_EN_ABS_1F |
 842                                   FSP_BIT_SWC1_EN_ABS_2F |
 843                                   FSP_BIT_SWC1_EN_FUP_OUT |
 844                                   FSP_BIT_SWC1_EN_ABS_CON)) {
 845                         psmouse_err(psmouse,
 846                                     "Unable to enable absolute coordinates output.\n");
 847                         return -EIO;
 848                 }
 849         }
 850
 851         return 0;
 852 }
 853
 854 static int fsp_set_input_params(struct psmouse *psmouse)
 855 {
 856         struct input_dev *dev = psmouse->dev;
 857         struct fsp_data *pad = psmouse->private;
 858
 859         if (pad->ver < FSP_VER_STL3888_C0) {
 860                 __set_bit(BTN_MIDDLE, dev->keybit);
 861                 __set_bit(BTN_BACK, dev->keybit);
 862                 __set_bit(BTN_FORWARD, dev->keybit);
 863                 __set_bit(REL_WHEEL, dev->relbit);
 864                 __set_bit(REL_HWHEEL, dev->relbit);
 865         } else {
 866                 /*
 867                  * Hardware prior to Cx performs much better in relative mode;
 868                  * hence, only enable absolute coordinates output as well as
 869                  * multi-touch output for the newer hardware.
 870                  *
 871                  * Maximum coordinates can be computed as:
 872                  *
 873                  *      number of scanlines * 64 - 57
 874                  *
 875                  * where number of X/Y scanline lines are 16/12.
 876                  */
 877                 int abs_x = 967, abs_y = 711;
 878
 879                 __set_bit(EV_ABS, dev->evbit);
 880                 __clear_bit(EV_REL, dev->evbit);
 881                 __set_bit(BTN_TOUCH, dev->keybit);
 882                 __set_bit(BTN_TOOL_FINGER, dev->keybit);
 883                 __set_bit(BTN_TOOL_DOUBLETAP, dev->keybit);
 884                 __set_bit(INPUT_PROP_SEMI_MT, dev->propbit);
 885
 886                 input_set_abs_params(dev, ABS_X, 0, abs_x, 0, 0);
 887                 input_set_abs_params(dev, ABS_Y, 0, abs_y, 0, 0);
 888                 input_mt_init_slots(dev, 2);
 889                 input_set_abs_params(dev, ABS_MT_POSITION_X, 0, abs_x, 0, 0);
 890                 input_set_abs_params(dev, ABS_MT_POSITION_Y, 0, abs_y, 0, 0);
 891         }
 892
 893         return 0;
 894 }
 895
 896 int fsp_detect(struct psmouse *psmouse, bool set_properties)
 897 {
 898         int id;
 899
 900         if (fsp_reg_read(psmouse, FSP_REG_DEVICE_ID, &id))
 901                 return -EIO;
 902
 903         if (id != 0x01)
 904                 return -ENODEV;
 905
 906         if (set_properties) {
 907                 psmouse->vendor = "Sentelic";
 908                 psmouse->name = "FingerSensingPad";
 909         }
 910
 911         return 0;
 912 }
 913
 914 static void fsp_reset(struct psmouse *psmouse)
 915 {
 916         fsp_opc_tag_enable(psmouse, false);
 917         fsp_onpad_vscr(psmouse, false);
 918         fsp_onpad_hscr(psmouse, false);
 919 }
 920
 921 static void fsp_disconnect(struct psmouse *psmouse)
 922 {
 923         sysfs_remove_group(&psmouse->ps2dev.serio->dev.kobj,
 924                            &fsp_attribute_group);
 925
 926         fsp_reset(psmouse);
 927         kfree(psmouse->private);
 928 }
 929
 930 static int fsp_reconnect(struct psmouse *psmouse)
 931 {
 932         int version;
 933
 934         if (fsp_detect(psmouse, 0))
 935                 return -ENODEV;
 936
 937         if (fsp_get_version(psmouse, &version))
 938                 return -ENODEV;
 939
 940         if (fsp_activate_protocol(psmouse))
 941                 return -EIO;
 942
 943         return 0;
 944 }
 945
 946 int fsp_init(struct psmouse *psmouse)
 947 {
 948         struct fsp_data *priv;
 949         int ver, rev;
 950         int error;
 951
 952         if (fsp_get_version(psmouse, &ver) ||
 953             fsp_get_revision(psmouse, &rev)) {
 954                 return -ENODEV;
 955         }
 956
 957         psmouse_info(psmouse, "Finger Sensing Pad, hw: %d.%d.%d, sw: %s\n",
 958                      ver >> 4, ver & 0x0F, rev, fsp_drv_ver);
 959
 960         psmouse->private = priv = kzalloc(sizeof(struct fsp_data), GFP_KERNEL);
 961         if (!priv)
 962                 return -ENOMEM;
 963
 964         priv->ver = ver;
 965         priv->rev = rev;
 966
 967         psmouse->protocol_handler = fsp_process_byte;
 968         psmouse->disconnect = fsp_disconnect;
 969         psmouse->reconnect = fsp_reconnect;
 970         psmouse->cleanup = fsp_reset;
 971         psmouse->pktsize = 4;
 972
 973         error = fsp_activate_protocol(psmouse);
 974         if (error)
 975                 goto err_out;
 976
 977         /* Set up various supported input event bits */
 978         error = fsp_set_input_params(psmouse);
 979         if (error)
 980                 goto err_out;
 981
 982         error = sysfs_create_group(&psmouse->ps2dev.serio->dev.kobj,
 983                                    &fsp_attribute_group);
 984         if (error) {
 985                 psmouse_err(psmouse,
 986                             "Failed to create sysfs attributes (%d)", error);
 987                 goto err_out;
 988         }
 989
 990         return 0;
 991
 992  err_out:
 993         kfree(psmouse->private);
 994         psmouse->private = NULL;
 995         return error;
 996 }