blob: 3f5649f190824408a25c495bdfd4da88b8febe9a [file] [log] [blame]
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -07001/*-
2 * Finger Sensing Pad PS/2 mouse driver.
3 *
4 * Copyright (C) 2005-2007 Asia Vital Components Co., Ltd.
Tai-hwa Lianga4c85072012-03-25 17:16:36 -07005 * Copyright (C) 2005-2012 Tai-hwa Liang, Sentelic Corporation.
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -07006 *
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>
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -070023#include <linux/input.h>
Tai-hwa Lianga4c85072012-03-25 17:16:36 -070024#include <linux/input/mt.h>
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -070025#include <linux/ctype.h>
26#include <linux/libps2.h>
27#include <linux/serio.h>
28#include <linux/jiffies.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090029#include <linux/slab.h>
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -070030
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
Oskari Saarenmaa727f9b42012-03-25 17:17:27 -070040#define GET_ABS_X(packet) ((packet[1] << 2) | ((packet[3] >> 2) & 0x03))
41#define GET_ABS_Y(packet) ((packet[2] << 2) | (packet[3] & 0x03))
42
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -070043/** Driver version. */
Tai-hwa Liangd3132c52012-05-07 08:45:58 -070044static const char fsp_drv_ver[] = "1.1.0-K";
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -070045
46/*
47 * Make sure that the value being sent to FSP will not conflict with
48 * possible sample rate values.
49 */
50static unsigned char fsp_test_swap_cmd(unsigned char reg_val)
51{
52 switch (reg_val) {
53 case 10: case 20: case 40: case 60: case 80: case 100: case 200:
54 /*
55 * The requested value being sent to FSP matched to possible
56 * sample rates, swap the given value such that the hardware
57 * wouldn't get confused.
58 */
59 return (reg_val >> 4) | (reg_val << 4);
60 default:
61 return reg_val; /* swap isn't necessary */
62 }
63}
64
65/*
66 * Make sure that the value being sent to FSP will not conflict with certain
67 * commands.
68 */
69static unsigned char fsp_test_invert_cmd(unsigned char reg_val)
70{
71 switch (reg_val) {
72 case 0xe9: case 0xee: case 0xf2: case 0xff:
73 /*
74 * The requested value being sent to FSP matched to certain
75 * commands, inverse the given value such that the hardware
76 * wouldn't get confused.
77 */
78 return ~reg_val;
79 default:
80 return reg_val; /* inversion isn't necessary */
81 }
82}
83
84static int fsp_reg_read(struct psmouse *psmouse, int reg_addr, int *reg_val)
85{
86 struct ps2dev *ps2dev = &psmouse->ps2dev;
87 unsigned char param[3];
88 unsigned char addr;
89 int rc = -1;
90
91 /*
92 * We need to shut off the device and switch it into command
93 * mode so we don't confuse our protocol handler. We don't need
94 * to do that for writes because sysfs set helper does this for
95 * us.
96 */
Paul Foxc35c0e72012-02-24 00:51:37 -080097 psmouse_deactivate(psmouse);
Dmitry Torokhov181d6832009-09-16 01:06:43 -070098
99 ps2_begin_command(ps2dev);
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700100
101 if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
102 goto out;
103
104 /* should return 0xfe(request for resending) */
105 ps2_sendbyte(ps2dev, 0x66, FSP_CMD_TIMEOUT2);
106 /* should return 0xfc(failed) */
107 ps2_sendbyte(ps2dev, 0x88, FSP_CMD_TIMEOUT2);
108
109 if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
110 goto out;
111
112 if ((addr = fsp_test_invert_cmd(reg_addr)) != reg_addr) {
113 ps2_sendbyte(ps2dev, 0x68, FSP_CMD_TIMEOUT2);
114 } else if ((addr = fsp_test_swap_cmd(reg_addr)) != reg_addr) {
115 /* swapping is required */
116 ps2_sendbyte(ps2dev, 0xcc, FSP_CMD_TIMEOUT2);
117 /* expect 0xfe */
118 } else {
119 /* swapping isn't necessary */
120 ps2_sendbyte(ps2dev, 0x66, FSP_CMD_TIMEOUT2);
121 /* expect 0xfe */
122 }
123 /* should return 0xfc(failed) */
124 ps2_sendbyte(ps2dev, addr, FSP_CMD_TIMEOUT);
125
126 if (__ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO) < 0)
127 goto out;
128
129 *reg_val = param[2];
130 rc = 0;
131
132 out:
Dmitry Torokhov181d6832009-09-16 01:06:43 -0700133 ps2_end_command(ps2dev);
Paul Foxc35c0e72012-02-24 00:51:37 -0800134 psmouse_activate(psmouse);
Tai-hwa Liang3ac17802012-03-25 17:15:03 -0700135 psmouse_dbg(psmouse,
136 "READ REG: 0x%02x is 0x%02x (rc = %d)\n",
137 reg_addr, *reg_val, rc);
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700138 return rc;
139}
140
141static int fsp_reg_write(struct psmouse *psmouse, int reg_addr, int reg_val)
142{
143 struct ps2dev *ps2dev = &psmouse->ps2dev;
144 unsigned char v;
145 int rc = -1;
146
Dmitry Torokhov181d6832009-09-16 01:06:43 -0700147 ps2_begin_command(ps2dev);
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700148
149 if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
150 goto out;
151
152 if ((v = fsp_test_invert_cmd(reg_addr)) != reg_addr) {
153 /* inversion is required */
154 ps2_sendbyte(ps2dev, 0x74, FSP_CMD_TIMEOUT2);
155 } else {
156 if ((v = fsp_test_swap_cmd(reg_addr)) != reg_addr) {
157 /* swapping is required */
158 ps2_sendbyte(ps2dev, 0x77, FSP_CMD_TIMEOUT2);
159 } else {
160 /* swapping isn't necessary */
161 ps2_sendbyte(ps2dev, 0x55, FSP_CMD_TIMEOUT2);
162 }
163 }
164 /* write the register address in correct order */
165 ps2_sendbyte(ps2dev, v, FSP_CMD_TIMEOUT2);
166
167 if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
Tai-hwa Liangd9bae672011-12-23 01:14:31 -0800168 goto out;
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700169
170 if ((v = fsp_test_invert_cmd(reg_val)) != reg_val) {
171 /* inversion is required */
172 ps2_sendbyte(ps2dev, 0x47, FSP_CMD_TIMEOUT2);
173 } else if ((v = fsp_test_swap_cmd(reg_val)) != reg_val) {
174 /* swapping is required */
175 ps2_sendbyte(ps2dev, 0x44, FSP_CMD_TIMEOUT2);
176 } else {
177 /* swapping isn't necessary */
178 ps2_sendbyte(ps2dev, 0x33, FSP_CMD_TIMEOUT2);
179 }
180
181 /* write the register value in correct order */
182 ps2_sendbyte(ps2dev, v, FSP_CMD_TIMEOUT2);
183 rc = 0;
184
185 out:
Dmitry Torokhov181d6832009-09-16 01:06:43 -0700186 ps2_end_command(ps2dev);
Tai-hwa Liang3ac17802012-03-25 17:15:03 -0700187 psmouse_dbg(psmouse,
188 "WRITE REG: 0x%02x to 0x%02x (rc = %d)\n",
189 reg_addr, reg_val, rc);
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700190 return rc;
191}
192
193/* Enable register clock gating for writing certain registers */
194static int fsp_reg_write_enable(struct psmouse *psmouse, bool enable)
195{
196 int v, nv;
197
198 if (fsp_reg_read(psmouse, FSP_REG_SYSCTL1, &v) == -1)
199 return -1;
200
201 if (enable)
202 nv = v | FSP_BIT_EN_REG_CLK;
203 else
204 nv = v & ~FSP_BIT_EN_REG_CLK;
205
206 /* only write if necessary */
207 if (nv != v)
208 if (fsp_reg_write(psmouse, FSP_REG_SYSCTL1, nv) == -1)
209 return -1;
210
211 return 0;
212}
213
214static int fsp_page_reg_read(struct psmouse *psmouse, int *reg_val)
215{
216 struct ps2dev *ps2dev = &psmouse->ps2dev;
217 unsigned char param[3];
218 int rc = -1;
219
Paul Foxc35c0e72012-02-24 00:51:37 -0800220 psmouse_deactivate(psmouse);
Dmitry Torokhov181d6832009-09-16 01:06:43 -0700221
222 ps2_begin_command(ps2dev);
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700223
224 if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
225 goto out;
226
227 ps2_sendbyte(ps2dev, 0x66, FSP_CMD_TIMEOUT2);
228 ps2_sendbyte(ps2dev, 0x88, FSP_CMD_TIMEOUT2);
229
230 if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
231 goto out;
232
233 ps2_sendbyte(ps2dev, 0x83, FSP_CMD_TIMEOUT2);
234 ps2_sendbyte(ps2dev, 0x88, FSP_CMD_TIMEOUT2);
235
236 /* get the returned result */
237 if (__ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO))
238 goto out;
239
240 *reg_val = param[2];
241 rc = 0;
242
243 out:
Dmitry Torokhov181d6832009-09-16 01:06:43 -0700244 ps2_end_command(ps2dev);
Paul Foxc35c0e72012-02-24 00:51:37 -0800245 psmouse_activate(psmouse);
Tai-hwa Liang3ac17802012-03-25 17:15:03 -0700246 psmouse_dbg(psmouse,
247 "READ PAGE REG: 0x%02x (rc = %d)\n",
248 *reg_val, rc);
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700249 return rc;
250}
251
252static int fsp_page_reg_write(struct psmouse *psmouse, int reg_val)
253{
254 struct ps2dev *ps2dev = &psmouse->ps2dev;
255 unsigned char v;
256 int rc = -1;
257
Dmitry Torokhov181d6832009-09-16 01:06:43 -0700258 ps2_begin_command(ps2dev);
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700259
260 if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
261 goto out;
262
263 ps2_sendbyte(ps2dev, 0x38, FSP_CMD_TIMEOUT2);
264 ps2_sendbyte(ps2dev, 0x88, FSP_CMD_TIMEOUT2);
265
266 if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
Tai-hwa Liangd9bae672011-12-23 01:14:31 -0800267 goto out;
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700268
269 if ((v = fsp_test_invert_cmd(reg_val)) != reg_val) {
270 ps2_sendbyte(ps2dev, 0x47, FSP_CMD_TIMEOUT2);
271 } else if ((v = fsp_test_swap_cmd(reg_val)) != reg_val) {
272 /* swapping is required */
273 ps2_sendbyte(ps2dev, 0x44, FSP_CMD_TIMEOUT2);
274 } else {
275 /* swapping isn't necessary */
276 ps2_sendbyte(ps2dev, 0x33, FSP_CMD_TIMEOUT2);
277 }
278
279 ps2_sendbyte(ps2dev, v, FSP_CMD_TIMEOUT2);
280 rc = 0;
281
282 out:
Dmitry Torokhov181d6832009-09-16 01:06:43 -0700283 ps2_end_command(ps2dev);
Tai-hwa Liang3ac17802012-03-25 17:15:03 -0700284 psmouse_dbg(psmouse,
285 "WRITE PAGE REG: to 0x%02x (rc = %d)\n",
286 reg_val, rc);
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700287 return rc;
288}
289
290static int fsp_get_version(struct psmouse *psmouse, int *version)
291{
292 if (fsp_reg_read(psmouse, FSP_REG_VERSION, version))
293 return -EIO;
294
295 return 0;
296}
297
298static int fsp_get_revision(struct psmouse *psmouse, int *rev)
299{
300 if (fsp_reg_read(psmouse, FSP_REG_REVISION, rev))
301 return -EIO;
302
303 return 0;
304}
305
Tai-hwa Liangd3132c52012-05-07 08:45:58 -0700306static int fsp_get_sn(struct psmouse *psmouse, int *sn)
307{
308 int v0, v1, v2;
309 int rc = -EIO;
310
311 /* production number since Cx is available at: 0x0b40 ~ 0x0b42 */
312 if (fsp_page_reg_write(psmouse, FSP_PAGE_0B))
313 goto out;
314 if (fsp_reg_read(psmouse, FSP_REG_SN0, &v0))
315 goto out;
316 if (fsp_reg_read(psmouse, FSP_REG_SN1, &v1))
317 goto out;
318 if (fsp_reg_read(psmouse, FSP_REG_SN2, &v2))
319 goto out;
320 *sn = (v0 << 16) | (v1 << 8) | v2;
321 rc = 0;
322out:
323 fsp_page_reg_write(psmouse, FSP_PAGE_DEFAULT);
324 return rc;
325}
326
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700327static int fsp_get_buttons(struct psmouse *psmouse, int *btn)
328{
329 static const int buttons[] = {
330 0x16, /* Left/Middle/Right/Forward/Backward & Scroll Up/Down */
331 0x06, /* Left/Middle/Right & Scroll Up/Down/Right/Left */
332 0x04, /* Left/Middle/Right & Scroll Up/Down */
333 0x02, /* Left/Middle/Right */
334 };
335 int val;
336
Tai-hwa Liang6ccbcf22011-12-29 09:47:36 -0800337 if (fsp_reg_read(psmouse, FSP_REG_TMOD_STATUS, &val) == -1)
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700338 return -EIO;
339
340 *btn = buttons[(val & 0x30) >> 4];
341 return 0;
342}
343
344/* Enable on-pad command tag output */
345static int fsp_opc_tag_enable(struct psmouse *psmouse, bool enable)
346{
347 int v, nv;
348 int res = 0;
349
350 if (fsp_reg_read(psmouse, FSP_REG_OPC_QDOWN, &v) == -1) {
Tai-hwa Liang3ac17802012-03-25 17:15:03 -0700351 psmouse_err(psmouse, "Unable get OPC state.\n");
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700352 return -EIO;
353 }
354
355 if (enable)
356 nv = v | FSP_BIT_EN_OPC_TAG;
357 else
358 nv = v & ~FSP_BIT_EN_OPC_TAG;
359
360 /* only write if necessary */
361 if (nv != v) {
362 fsp_reg_write_enable(psmouse, true);
363 res = fsp_reg_write(psmouse, FSP_REG_OPC_QDOWN, nv);
364 fsp_reg_write_enable(psmouse, false);
365 }
366
367 if (res != 0) {
Tai-hwa Liang3ac17802012-03-25 17:15:03 -0700368 psmouse_err(psmouse, "Unable to enable OPC tag.\n");
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700369 res = -EIO;
370 }
371
372 return res;
373}
374
375static int fsp_onpad_vscr(struct psmouse *psmouse, bool enable)
376{
377 struct fsp_data *pad = psmouse->private;
378 int val;
379
380 if (fsp_reg_read(psmouse, FSP_REG_ONPAD_CTL, &val))
381 return -EIO;
382
383 pad->vscroll = enable;
384
385 if (enable)
386 val |= (FSP_BIT_FIX_VSCR | FSP_BIT_ONPAD_ENABLE);
387 else
388 val &= ~FSP_BIT_FIX_VSCR;
389
390 if (fsp_reg_write(psmouse, FSP_REG_ONPAD_CTL, val))
391 return -EIO;
392
393 return 0;
394}
395
396static int fsp_onpad_hscr(struct psmouse *psmouse, bool enable)
397{
398 struct fsp_data *pad = psmouse->private;
399 int val, v2;
400
401 if (fsp_reg_read(psmouse, FSP_REG_ONPAD_CTL, &val))
402 return -EIO;
403
404 if (fsp_reg_read(psmouse, FSP_REG_SYSCTL5, &v2))
405 return -EIO;
406
407 pad->hscroll = enable;
408
409 if (enable) {
410 val |= (FSP_BIT_FIX_HSCR | FSP_BIT_ONPAD_ENABLE);
411 v2 |= FSP_BIT_EN_MSID6;
412 } else {
413 val &= ~FSP_BIT_FIX_HSCR;
414 v2 &= ~(FSP_BIT_EN_MSID6 | FSP_BIT_EN_MSID7 | FSP_BIT_EN_MSID8);
415 }
416
417 if (fsp_reg_write(psmouse, FSP_REG_ONPAD_CTL, val))
418 return -EIO;
419
420 /* reconfigure horizontal scrolling packet output */
421 if (fsp_reg_write(psmouse, FSP_REG_SYSCTL5, v2))
422 return -EIO;
423
424 return 0;
425}
426
427/*
428 * Write device specific initial parameters.
429 *
430 * ex: 0xab 0xcd - write oxcd into register 0xab
431 */
432static ssize_t fsp_attr_set_setreg(struct psmouse *psmouse, void *data,
433 const char *buf, size_t count)
434{
JJ Ding76496e72011-11-09 10:20:14 -0800435 int reg, val;
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700436 char *rest;
437 ssize_t retval;
438
439 reg = simple_strtoul(buf, &rest, 16);
440 if (rest == buf || *rest != ' ' || reg > 0xff)
441 return -EINVAL;
442
JJ Ding76496e72011-11-09 10:20:14 -0800443 retval = kstrtoint(rest + 1, 16, &val);
444 if (retval)
445 return retval;
446
447 if (val > 0xff)
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700448 return -EINVAL;
449
450 if (fsp_reg_write_enable(psmouse, true))
451 return -EIO;
452
453 retval = fsp_reg_write(psmouse, reg, val) < 0 ? -EIO : count;
454
455 fsp_reg_write_enable(psmouse, false);
456
457 return count;
458}
459
460PSMOUSE_DEFINE_WO_ATTR(setreg, S_IWUSR, NULL, fsp_attr_set_setreg);
461
462static ssize_t fsp_attr_show_getreg(struct psmouse *psmouse,
463 void *data, char *buf)
464{
465 struct fsp_data *pad = psmouse->private;
466
467 return sprintf(buf, "%02x%02x\n", pad->last_reg, pad->last_val);
468}
469
470/*
471 * Read a register from device.
472 *
473 * ex: 0xab -- read content from register 0xab
474 */
475static ssize_t fsp_attr_set_getreg(struct psmouse *psmouse, void *data,
476 const char *buf, size_t count)
477{
478 struct fsp_data *pad = psmouse->private;
JJ Ding76496e72011-11-09 10:20:14 -0800479 int reg, val, err;
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700480
JJ Ding76496e72011-11-09 10:20:14 -0800481 err = kstrtoint(buf, 16, &reg);
482 if (err)
483 return err;
484
485 if (reg > 0xff)
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700486 return -EINVAL;
487
488 if (fsp_reg_read(psmouse, reg, &val))
489 return -EIO;
490
491 pad->last_reg = reg;
492 pad->last_val = val;
493
494 return count;
495}
496
497PSMOUSE_DEFINE_ATTR(getreg, S_IWUSR | S_IRUGO, NULL,
498 fsp_attr_show_getreg, fsp_attr_set_getreg);
499
500static ssize_t fsp_attr_show_pagereg(struct psmouse *psmouse,
501 void *data, char *buf)
502{
503 int val = 0;
504
505 if (fsp_page_reg_read(psmouse, &val))
506 return -EIO;
507
508 return sprintf(buf, "%02x\n", val);
509}
510
511static ssize_t fsp_attr_set_pagereg(struct psmouse *psmouse, void *data,
512 const char *buf, size_t count)
513{
JJ Ding76496e72011-11-09 10:20:14 -0800514 int val, err;
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700515
JJ Ding76496e72011-11-09 10:20:14 -0800516 err = kstrtoint(buf, 16, &val);
517 if (err)
518 return err;
519
520 if (val > 0xff)
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700521 return -EINVAL;
522
523 if (fsp_page_reg_write(psmouse, val))
524 return -EIO;
525
526 return count;
527}
528
529PSMOUSE_DEFINE_ATTR(page, S_IWUSR | S_IRUGO, NULL,
530 fsp_attr_show_pagereg, fsp_attr_set_pagereg);
531
532static ssize_t fsp_attr_show_vscroll(struct psmouse *psmouse,
533 void *data, char *buf)
534{
535 struct fsp_data *pad = psmouse->private;
536
537 return sprintf(buf, "%d\n", pad->vscroll);
538}
539
540static ssize_t fsp_attr_set_vscroll(struct psmouse *psmouse, void *data,
541 const char *buf, size_t count)
542{
JJ Ding76496e72011-11-09 10:20:14 -0800543 unsigned int val;
544 int err;
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700545
JJ Ding76496e72011-11-09 10:20:14 -0800546 err = kstrtouint(buf, 10, &val);
547 if (err)
548 return err;
549
550 if (val > 1)
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700551 return -EINVAL;
552
553 fsp_onpad_vscr(psmouse, val);
554
555 return count;
556}
557
558PSMOUSE_DEFINE_ATTR(vscroll, S_IWUSR | S_IRUGO, NULL,
559 fsp_attr_show_vscroll, fsp_attr_set_vscroll);
560
561static ssize_t fsp_attr_show_hscroll(struct psmouse *psmouse,
562 void *data, char *buf)
563{
564 struct fsp_data *pad = psmouse->private;
565
566 return sprintf(buf, "%d\n", pad->hscroll);
567}
568
569static ssize_t fsp_attr_set_hscroll(struct psmouse *psmouse, void *data,
570 const char *buf, size_t count)
571{
JJ Ding76496e72011-11-09 10:20:14 -0800572 unsigned int val;
573 int err;
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700574
JJ Ding76496e72011-11-09 10:20:14 -0800575 err = kstrtouint(buf, 10, &val);
576 if (err)
577 return err;
578
579 if (val > 1)
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700580 return -EINVAL;
581
582 fsp_onpad_hscr(psmouse, val);
583
584 return count;
585}
586
587PSMOUSE_DEFINE_ATTR(hscroll, S_IWUSR | S_IRUGO, NULL,
588 fsp_attr_show_hscroll, fsp_attr_set_hscroll);
589
590static ssize_t fsp_attr_show_flags(struct psmouse *psmouse,
591 void *data, char *buf)
592{
593 struct fsp_data *pad = psmouse->private;
594
595 return sprintf(buf, "%c\n",
596 pad->flags & FSPDRV_FLAG_EN_OPC ? 'C' : 'c');
597}
598
599static ssize_t fsp_attr_set_flags(struct psmouse *psmouse, void *data,
600 const char *buf, size_t count)
601{
602 struct fsp_data *pad = psmouse->private;
603 size_t i;
604
605 for (i = 0; i < count; i++) {
606 switch (buf[i]) {
607 case 'C':
608 pad->flags |= FSPDRV_FLAG_EN_OPC;
609 break;
610 case 'c':
611 pad->flags &= ~FSPDRV_FLAG_EN_OPC;
612 break;
613 default:
614 return -EINVAL;
615 }
616 }
617 return count;
618}
619
620PSMOUSE_DEFINE_ATTR(flags, S_IWUSR | S_IRUGO, NULL,
621 fsp_attr_show_flags, fsp_attr_set_flags);
622
623static ssize_t fsp_attr_show_ver(struct psmouse *psmouse,
624 void *data, char *buf)
625{
626 return sprintf(buf, "Sentelic FSP kernel module %s\n", fsp_drv_ver);
627}
628
629PSMOUSE_DEFINE_RO_ATTR(ver, S_IRUGO, NULL, fsp_attr_show_ver);
630
631static struct attribute *fsp_attributes[] = {
632 &psmouse_attr_setreg.dattr.attr,
633 &psmouse_attr_getreg.dattr.attr,
634 &psmouse_attr_page.dattr.attr,
635 &psmouse_attr_vscroll.dattr.attr,
636 &psmouse_attr_hscroll.dattr.attr,
637 &psmouse_attr_flags.dattr.attr,
638 &psmouse_attr_ver.dattr.attr,
639 NULL
640};
641
642static struct attribute_group fsp_attribute_group = {
643 .attrs = fsp_attributes,
644};
645
Oskari Saarenmaa727f9b42012-03-25 17:17:27 -0700646#ifdef FSP_DEBUG
647static void fsp_packet_debug(struct psmouse *psmouse, unsigned char packet[])
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700648{
649 static unsigned int ps2_packet_cnt;
650 static unsigned int ps2_last_second;
651 unsigned int jiffies_msec;
Oskari Saarenmaa727f9b42012-03-25 17:17:27 -0700652 const char *packet_type = "UNKNOWN";
653 unsigned short abs_x = 0, abs_y = 0;
654
655 /* Interpret & dump the packet data. */
656 switch (packet[0] >> FSP_PKT_TYPE_SHIFT) {
657 case FSP_PKT_TYPE_ABS:
658 packet_type = "Absolute";
659 abs_x = GET_ABS_X(packet);
660 abs_y = GET_ABS_Y(packet);
661 break;
662 case FSP_PKT_TYPE_NORMAL:
663 packet_type = "Normal";
664 break;
665 case FSP_PKT_TYPE_NOTIFY:
666 packet_type = "Notify";
667 break;
668 case FSP_PKT_TYPE_NORMAL_OPC:
669 packet_type = "Normal-OPC";
670 break;
671 }
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700672
673 ps2_packet_cnt++;
674 jiffies_msec = jiffies_to_msecs(jiffies);
Dmitry Torokhovb5d21702011-10-10 18:27:03 -0700675 psmouse_dbg(psmouse,
Oskari Saarenmaa727f9b42012-03-25 17:17:27 -0700676 "%08dms %s packets: %02x, %02x, %02x, %02x; "
677 "abs_x: %d, abs_y: %d\n",
678 jiffies_msec, packet_type,
679 packet[0], packet[1], packet[2], packet[3], abs_x, abs_y);
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700680
681 if (jiffies_msec - ps2_last_second > 1000) {
Dmitry Torokhovb5d21702011-10-10 18:27:03 -0700682 psmouse_dbg(psmouse, "PS/2 packets/sec = %d\n", ps2_packet_cnt);
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700683 ps2_packet_cnt = 0;
684 ps2_last_second = jiffies_msec;
685 }
686}
687#else
Oskari Saarenmaa727f9b42012-03-25 17:17:27 -0700688static void fsp_packet_debug(struct psmouse *psmouse, unsigned char packet[])
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700689{
690}
691#endif
692
Tai-hwa Lianga4c85072012-03-25 17:16:36 -0700693static void fsp_set_slot(struct input_dev *dev, int slot, bool active,
694 unsigned int x, unsigned int y)
695{
696 input_mt_slot(dev, slot);
697 input_mt_report_slot_state(dev, MT_TOOL_FINGER, active);
698 if (active) {
699 input_report_abs(dev, ABS_MT_POSITION_X, x);
700 input_report_abs(dev, ABS_MT_POSITION_Y, y);
701 }
702}
703
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700704static psmouse_ret_t fsp_process_byte(struct psmouse *psmouse)
705{
706 struct input_dev *dev = psmouse->dev;
707 struct fsp_data *ad = psmouse->private;
708 unsigned char *packet = psmouse->packet;
709 unsigned char button_status = 0, lscroll = 0, rscroll = 0;
Tai-hwa Lianga4c85072012-03-25 17:16:36 -0700710 unsigned short abs_x, abs_y, fgrs = 0;
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700711 int rel_x, rel_y;
712
713 if (psmouse->pktcnt < 4)
714 return PSMOUSE_GOOD_DATA;
715
716 /*
717 * Full packet accumulated, process it
718 */
719
Oskari Saarenmaa727f9b42012-03-25 17:17:27 -0700720 fsp_packet_debug(psmouse, packet);
721
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700722 switch (psmouse->packet[0] >> FSP_PKT_TYPE_SHIFT) {
723 case FSP_PKT_TYPE_ABS:
Oskari Saarenmaa727f9b42012-03-25 17:17:27 -0700724 abs_x = GET_ABS_X(packet);
725 abs_y = GET_ABS_Y(packet);
Tai-hwa Lianga4c85072012-03-25 17:16:36 -0700726
727 if (packet[0] & FSP_PB0_MFMC) {
728 /*
729 * MFMC packet: assume that there are two fingers on
730 * pad
731 */
732 fgrs = 2;
733
734 /* MFMC packet */
735 if (packet[0] & FSP_PB0_MFMC_FGR2) {
736 /* 2nd finger */
737 if (ad->last_mt_fgr == 2) {
738 /*
739 * workaround for buggy firmware
740 * which doesn't clear MFMC bit if
741 * the 1st finger is up
742 */
743 fgrs = 1;
744 fsp_set_slot(dev, 0, false, 0, 0);
745 }
746 ad->last_mt_fgr = 2;
747
748 fsp_set_slot(dev, 1, fgrs == 2, abs_x, abs_y);
749 } else {
750 /* 1st finger */
751 if (ad->last_mt_fgr == 1) {
752 /*
753 * workaround for buggy firmware
754 * which doesn't clear MFMC bit if
755 * the 2nd finger is up
756 */
757 fgrs = 1;
758 fsp_set_slot(dev, 1, false, 0, 0);
759 }
760 ad->last_mt_fgr = 1;
761 fsp_set_slot(dev, 0, fgrs != 0, abs_x, abs_y);
762 }
763 } else {
764 /* SFAC packet */
Oskari Saarenmaad626dad2012-04-03 09:46:32 -0700765 if ((packet[0] & (FSP_PB0_LBTN|FSP_PB0_PHY_BTN)) ==
766 FSP_PB0_LBTN) {
767 /* On-pad click in SFAC mode should be handled
768 * by userspace. On-pad clicks in MFMC mode
769 * are real clickpad clicks, and not ignored.
770 */
771 packet[0] &= ~FSP_PB0_LBTN;
772 }
Tai-hwa Lianga4c85072012-03-25 17:16:36 -0700773
774 /* no multi-finger information */
775 ad->last_mt_fgr = 0;
776
777 if (abs_x != 0 && abs_y != 0)
778 fgrs = 1;
779
780 fsp_set_slot(dev, 0, fgrs > 0, abs_x, abs_y);
781 fsp_set_slot(dev, 1, false, 0, 0);
782 }
783 if (fgrs > 0) {
784 input_report_abs(dev, ABS_X, abs_x);
785 input_report_abs(dev, ABS_Y, abs_y);
786 }
787 input_report_key(dev, BTN_LEFT, packet[0] & 0x01);
788 input_report_key(dev, BTN_RIGHT, packet[0] & 0x02);
789 input_report_key(dev, BTN_TOUCH, fgrs);
790 input_report_key(dev, BTN_TOOL_FINGER, fgrs == 1);
791 input_report_key(dev, BTN_TOOL_DOUBLETAP, fgrs == 2);
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700792 break;
793
794 case FSP_PKT_TYPE_NORMAL_OPC:
795 /* on-pad click, filter it if necessary */
796 if ((ad->flags & FSPDRV_FLAG_EN_OPC) != FSPDRV_FLAG_EN_OPC)
Tai-hwa Liang7b85f732012-03-25 17:17:00 -0700797 packet[0] &= ~FSP_PB0_LBTN;
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700798 /* fall through */
799
800 case FSP_PKT_TYPE_NORMAL:
801 /* normal packet */
802 /* special packet data translation from on-pad packets */
803 if (packet[3] != 0) {
804 if (packet[3] & BIT(0))
805 button_status |= 0x01; /* wheel down */
806 if (packet[3] & BIT(1))
807 button_status |= 0x0f; /* wheel up */
808 if (packet[3] & BIT(2))
Tai-hwa Liangc332e9f2010-01-13 00:25:35 -0800809 button_status |= BIT(4);/* horizontal left */
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700810 if (packet[3] & BIT(3))
Tai-hwa Liangc332e9f2010-01-13 00:25:35 -0800811 button_status |= BIT(5);/* horizontal right */
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700812 /* push back to packet queue */
813 if (button_status != 0)
814 packet[3] = button_status;
815 rscroll = (packet[3] >> 4) & 1;
816 lscroll = (packet[3] >> 5) & 1;
817 }
818 /*
819 * Processing wheel up/down and extra button events
820 */
821 input_report_rel(dev, REL_WHEEL,
822 (int)(packet[3] & 8) - (int)(packet[3] & 7));
823 input_report_rel(dev, REL_HWHEEL, lscroll - rscroll);
824 input_report_key(dev, BTN_BACK, lscroll);
825 input_report_key(dev, BTN_FORWARD, rscroll);
826
827 /*
828 * Standard PS/2 Mouse
829 */
830 input_report_key(dev, BTN_LEFT, packet[0] & 1);
831 input_report_key(dev, BTN_MIDDLE, (packet[0] >> 2) & 1);
832 input_report_key(dev, BTN_RIGHT, (packet[0] >> 1) & 1);
833
834 rel_x = packet[1] ? (int)packet[1] - (int)((packet[0] << 4) & 0x100) : 0;
835 rel_y = packet[2] ? (int)((packet[0] << 3) & 0x100) - (int)packet[2] : 0;
836
837 input_report_rel(dev, REL_X, rel_x);
838 input_report_rel(dev, REL_Y, rel_y);
839 break;
840 }
841
842 input_sync(dev);
843
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700844 return PSMOUSE_FULL_PACKET;
845}
846
847static int fsp_activate_protocol(struct psmouse *psmouse)
848{
849 struct fsp_data *pad = psmouse->private;
850 struct ps2dev *ps2dev = &psmouse->ps2dev;
851 unsigned char param[2];
852 int val;
853
854 /*
855 * Standard procedure to enter FSP Intellimouse mode
856 * (scrolling wheel, 4th and 5th buttons)
857 */
858 param[0] = 200;
859 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
860 param[0] = 200;
861 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
862 param[0] = 80;
863 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
864
865 ps2_command(ps2dev, param, PSMOUSE_CMD_GETID);
866 if (param[0] != 0x04) {
Tai-hwa Liang3ac17802012-03-25 17:15:03 -0700867 psmouse_err(psmouse,
868 "Unable to enable 4 bytes packet format.\n");
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700869 return -EIO;
870 }
871
Tai-hwa Liang3ac17802012-03-25 17:15:03 -0700872 if (pad->ver < FSP_VER_STL3888_C0) {
873 /* Preparing relative coordinates output for older hardware */
874 if (fsp_reg_read(psmouse, FSP_REG_SYSCTL5, &val)) {
875 psmouse_err(psmouse,
876 "Unable to read SYSCTL5 register.\n");
877 return -EIO;
878 }
879
880 if (fsp_get_buttons(psmouse, &pad->buttons)) {
881 psmouse_err(psmouse,
882 "Unable to retrieve number of buttons.\n");
883 return -EIO;
884 }
885
886 val &= ~(FSP_BIT_EN_MSID7 | FSP_BIT_EN_MSID8 | FSP_BIT_EN_AUTO_MSID8);
887 /* Ensure we are not in absolute mode */
888 val &= ~FSP_BIT_EN_PKT_G0;
889 if (pad->buttons == 0x06) {
890 /* Left/Middle/Right & Scroll Up/Down/Right/Left */
891 val |= FSP_BIT_EN_MSID6;
892 }
893
894 if (fsp_reg_write(psmouse, FSP_REG_SYSCTL5, val)) {
895 psmouse_err(psmouse,
896 "Unable to set up required mode bits.\n");
897 return -EIO;
898 }
899
900 /*
901 * Enable OPC tags such that driver can tell the difference
902 * between on-pad and real button click
903 */
904 if (fsp_opc_tag_enable(psmouse, true))
905 psmouse_warn(psmouse,
906 "Failed to enable OPC tag mode.\n");
907 /* enable on-pad click by default */
908 pad->flags |= FSPDRV_FLAG_EN_OPC;
909
910 /* Enable on-pad vertical and horizontal scrolling */
911 fsp_onpad_vscr(psmouse, true);
912 fsp_onpad_hscr(psmouse, true);
Tai-hwa Lianga4c85072012-03-25 17:16:36 -0700913 } else {
914 /* Enable absolute coordinates output for Cx/Dx hardware */
915 if (fsp_reg_write(psmouse, FSP_REG_SWC1,
916 FSP_BIT_SWC1_EN_ABS_1F |
917 FSP_BIT_SWC1_EN_ABS_2F |
918 FSP_BIT_SWC1_EN_FUP_OUT |
919 FSP_BIT_SWC1_EN_ABS_CON)) {
920 psmouse_err(psmouse,
921 "Unable to enable absolute coordinates output.\n");
922 return -EIO;
923 }
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700924 }
925
Tai-hwa Liang3ac17802012-03-25 17:15:03 -0700926 return 0;
927}
928
929static int fsp_set_input_params(struct psmouse *psmouse)
930{
931 struct input_dev *dev = psmouse->dev;
932 struct fsp_data *pad = psmouse->private;
933
934 if (pad->ver < FSP_VER_STL3888_C0) {
935 __set_bit(BTN_MIDDLE, dev->keybit);
936 __set_bit(BTN_BACK, dev->keybit);
937 __set_bit(BTN_FORWARD, dev->keybit);
938 __set_bit(REL_WHEEL, dev->relbit);
939 __set_bit(REL_HWHEEL, dev->relbit);
Tai-hwa Lianga4c85072012-03-25 17:16:36 -0700940 } else {
941 /*
942 * Hardware prior to Cx performs much better in relative mode;
943 * hence, only enable absolute coordinates output as well as
944 * multi-touch output for the newer hardware.
945 *
946 * Maximum coordinates can be computed as:
947 *
948 * number of scanlines * 64 - 57
949 *
950 * where number of X/Y scanline lines are 16/12.
951 */
952 int abs_x = 967, abs_y = 711;
953
954 __set_bit(EV_ABS, dev->evbit);
955 __clear_bit(EV_REL, dev->evbit);
956 __set_bit(BTN_TOUCH, dev->keybit);
957 __set_bit(BTN_TOOL_FINGER, dev->keybit);
958 __set_bit(BTN_TOOL_DOUBLETAP, dev->keybit);
959 __set_bit(INPUT_PROP_SEMI_MT, dev->propbit);
960
961 input_set_abs_params(dev, ABS_X, 0, abs_x, 0, 0);
962 input_set_abs_params(dev, ABS_Y, 0, abs_y, 0, 0);
963 input_mt_init_slots(dev, 2);
964 input_set_abs_params(dev, ABS_MT_POSITION_X, 0, abs_x, 0, 0);
965 input_set_abs_params(dev, ABS_MT_POSITION_Y, 0, abs_y, 0, 0);
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700966 }
967
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700968 return 0;
969}
970
Dmitry Torokhovb7802c52009-09-09 19:13:20 -0700971int fsp_detect(struct psmouse *psmouse, bool set_properties)
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -0700972{
973 int id;
974
975 if (fsp_reg_read(psmouse, FSP_REG_DEVICE_ID, &id))
976 return -EIO;
977
978 if (id != 0x01)
979 return -ENODEV;
980
981 if (set_properties) {
982 psmouse->vendor = "Sentelic";
983 psmouse->name = "FingerSensingPad";
984 }
985
986 return 0;
987}
988
989static void fsp_reset(struct psmouse *psmouse)
990{
991 fsp_opc_tag_enable(psmouse, false);
992 fsp_onpad_vscr(psmouse, false);
993 fsp_onpad_hscr(psmouse, false);
994}
995
996static void fsp_disconnect(struct psmouse *psmouse)
997{
998 sysfs_remove_group(&psmouse->ps2dev.serio->dev.kobj,
999 &fsp_attribute_group);
1000
1001 fsp_reset(psmouse);
1002 kfree(psmouse->private);
1003}
1004
1005static int fsp_reconnect(struct psmouse *psmouse)
1006{
1007 int version;
1008
1009 if (fsp_detect(psmouse, 0))
1010 return -ENODEV;
1011
1012 if (fsp_get_version(psmouse, &version))
1013 return -ENODEV;
1014
1015 if (fsp_activate_protocol(psmouse))
1016 return -EIO;
1017
1018 return 0;
1019}
1020
1021int fsp_init(struct psmouse *psmouse)
1022{
1023 struct fsp_data *priv;
Tai-hwa Liangd3132c52012-05-07 08:45:58 -07001024 int ver, rev, sn = 0;
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -07001025 int error;
1026
1027 if (fsp_get_version(psmouse, &ver) ||
Tai-hwa Liang3ac17802012-03-25 17:15:03 -07001028 fsp_get_revision(psmouse, &rev)) {
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -07001029 return -ENODEV;
1030 }
Tai-hwa Liangd3132c52012-05-07 08:45:58 -07001031 if (ver >= FSP_VER_STL3888_C0) {
1032 /* firmware information is only available since C0 */
1033 fsp_get_sn(psmouse, &sn);
1034 }
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -07001035
Tai-hwa Liangd3132c52012-05-07 08:45:58 -07001036 psmouse_info(psmouse,
1037 "Finger Sensing Pad, hw: %d.%d.%d, sn: %x, sw: %s\n",
1038 ver >> 4, ver & 0x0F, rev, sn, fsp_drv_ver);
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -07001039
1040 psmouse->private = priv = kzalloc(sizeof(struct fsp_data), GFP_KERNEL);
1041 if (!priv)
1042 return -ENOMEM;
1043
1044 priv->ver = ver;
1045 priv->rev = rev;
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -07001046
1047 psmouse->protocol_handler = fsp_process_byte;
1048 psmouse->disconnect = fsp_disconnect;
1049 psmouse->reconnect = fsp_reconnect;
1050 psmouse->cleanup = fsp_reset;
1051 psmouse->pktsize = 4;
1052
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -07001053 error = fsp_activate_protocol(psmouse);
1054 if (error)
1055 goto err_out;
1056
Tai-hwa Liang3ac17802012-03-25 17:15:03 -07001057 /* Set up various supported input event bits */
1058 error = fsp_set_input_params(psmouse);
1059 if (error)
1060 goto err_out;
1061
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -07001062 error = sysfs_create_group(&psmouse->ps2dev.serio->dev.kobj,
1063 &fsp_attribute_group);
1064 if (error) {
Tai-hwa Liang3ac17802012-03-25 17:15:03 -07001065 psmouse_err(psmouse,
1066 "Failed to create sysfs attributes (%d)", error);
Tai-hwa Liangfc69f4a2009-05-10 18:15:39 -07001067 goto err_out;
1068 }
1069
1070 return 0;
1071
1072 err_out:
1073 kfree(psmouse->private);
1074 psmouse->private = NULL;
1075 return error;
1076}