projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Input: gpio_keys - add support for interrupt only keys
[deliverable/linux.git] / drivers / input / mouse / sentelic.c
CommitLineData
fc69f4a6
TL		 1/*-
2 * Finger Sensing Pad PS/2 mouse driver.
3 *
4 * Copyright (C) 2005-2007 Asia Vital Components Co., Ltd.
6ccbcf2c 5 * Copyright (C) 2005-2011 Tai-hwa Liang, Sentelic Corporation.
fc69f4a6
TL		 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>
fc69f4a6
TL		 23#include <linux/input.h>
24#include <linux/ctype.h>
25#include <linux/libps2.h>
26#include <linux/serio.h>
27#include <linux/jiffies.h>
5a0e3ad6 28#include <linux/slab.h>
fc69f4a6
TL		 29
30#include "psmouse.h"
31#include "sentelic.h"
32
33/*
34 * Timeout for FSP PS/2 command only (in milliseconds).
35 */
36#define FSP_CMD_TIMEOUT 200
37#define FSP_CMD_TIMEOUT2 30
38
39/** Driver version. */
40static const char fsp_drv_ver[] = "1.0.0-K";
41
42/*
43 * Make sure that the value being sent to FSP will not conflict with
44 * possible sample rate values.
45 */
46static unsigned char fsp_test_swap_cmd(unsigned char reg_val)
47{
48 switch (reg_val) {
49 case 10: case 20: case 40: case 60: case 80: case 100: case 200:
50 /*
51 * The requested value being sent to FSP matched to possible
52 * sample rates, swap the given value such that the hardware
53 * wouldn't get confused.
54 */
55 return (reg_val >> 4) | (reg_val << 4);
56 default:
57 return reg_val; /* swap isn't necessary */
58 }
59}
60
61/*
62 * Make sure that the value being sent to FSP will not conflict with certain
63 * commands.
64 */
65static unsigned char fsp_test_invert_cmd(unsigned char reg_val)
66{
67 switch (reg_val) {
68 case 0xe9: case 0xee: case 0xf2: case 0xff:
69 /*
70 * The requested value being sent to FSP matched to certain
71 * commands, inverse the given value such that the hardware
72 * wouldn't get confused.
73 */
74 return ~reg_val;
75 default:
76 return reg_val; /* inversion isn't necessary */
77 }
78}
79
80static int fsp_reg_read(struct psmouse *psmouse, int reg_addr, int *reg_val)
81{
82 struct ps2dev *ps2dev = &psmouse->ps2dev;
83 unsigned char param[3];
84 unsigned char addr;
85 int rc = -1;
86
87 /*
88 * We need to shut off the device and switch it into command
89 * mode so we don't confuse our protocol handler. We don't need
90 * to do that for writes because sysfs set helper does this for
91 * us.
92 */
c35c0e7d 93 psmouse_deactivate(psmouse);
181d683d
DT		 94
95 ps2_begin_command(ps2dev);
fc69f4a6
TL		 96
97 if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
98 goto out;
99
100 /* should return 0xfe(request for resending) */
101 ps2_sendbyte(ps2dev, 0x66, FSP_CMD_TIMEOUT2);
102 /* should return 0xfc(failed) */
103 ps2_sendbyte(ps2dev, 0x88, FSP_CMD_TIMEOUT2);
104
105 if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
106 goto out;
107
108 if ((addr = fsp_test_invert_cmd(reg_addr)) != reg_addr) {
109 ps2_sendbyte(ps2dev, 0x68, FSP_CMD_TIMEOUT2);
110 } else if ((addr = fsp_test_swap_cmd(reg_addr)) != reg_addr) {
111 /* swapping is required */
112 ps2_sendbyte(ps2dev, 0xcc, FSP_CMD_TIMEOUT2);
113 /* expect 0xfe */
114 } else {
115 /* swapping isn't necessary */
116 ps2_sendbyte(ps2dev, 0x66, FSP_CMD_TIMEOUT2);
117 /* expect 0xfe */
118 }
119 /* should return 0xfc(failed) */
120 ps2_sendbyte(ps2dev, addr, FSP_CMD_TIMEOUT);
121
122 if (__ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO) < 0)
123 goto out;
124
125 *reg_val = param[2];
126 rc = 0;
127
128 out:
181d683d 129 ps2_end_command(ps2dev);
c35c0e7d 130 psmouse_activate(psmouse);
fc69f4a6
TL		 131 dev_dbg(&ps2dev->serio->dev, "READ REG: 0x%02x is 0x%02x (rc = %d)\n",
132 reg_addr, *reg_val, rc);
133 return rc;
134}
135
136static int fsp_reg_write(struct psmouse *psmouse, int reg_addr, int reg_val)
137{
138 struct ps2dev *ps2dev = &psmouse->ps2dev;
139 unsigned char v;
140 int rc = -1;
141
181d683d 142 ps2_begin_command(ps2dev);
fc69f4a6
TL		 143
144 if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
145 goto out;
146
147 if ((v = fsp_test_invert_cmd(reg_addr)) != reg_addr) {
148 /* inversion is required */
149 ps2_sendbyte(ps2dev, 0x74, FSP_CMD_TIMEOUT2);
150 } else {
151 if ((v = fsp_test_swap_cmd(reg_addr)) != reg_addr) {
152 /* swapping is required */
153 ps2_sendbyte(ps2dev, 0x77, FSP_CMD_TIMEOUT2);
154 } else {
155 /* swapping isn't necessary */
156 ps2_sendbyte(ps2dev, 0x55, FSP_CMD_TIMEOUT2);
157 }
158 }
159 /* write the register address in correct order */
160 ps2_sendbyte(ps2dev, v, FSP_CMD_TIMEOUT2);
161
162 if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
d9bae67a 163 goto out;
fc69f4a6
TL		 164
165 if ((v = fsp_test_invert_cmd(reg_val)) != reg_val) {
166 /* inversion is required */
167 ps2_sendbyte(ps2dev, 0x47, FSP_CMD_TIMEOUT2);
168 } else if ((v = fsp_test_swap_cmd(reg_val)) != reg_val) {
169 /* swapping is required */
170 ps2_sendbyte(ps2dev, 0x44, FSP_CMD_TIMEOUT2);
171 } else {
172 /* swapping isn't necessary */
173 ps2_sendbyte(ps2dev, 0x33, FSP_CMD_TIMEOUT2);
174 }
175
176 /* write the register value in correct order */
177 ps2_sendbyte(ps2dev, v, FSP_CMD_TIMEOUT2);
178 rc = 0;
179
180 out:
181d683d 181 ps2_end_command(ps2dev);
fc69f4a6
TL		 182 dev_dbg(&ps2dev->serio->dev, "WRITE REG: 0x%02x to 0x%02x (rc = %d)\n",
183 reg_addr, reg_val, rc);
184 return rc;
185}
186
187/* Enable register clock gating for writing certain registers */
188static int fsp_reg_write_enable(struct psmouse *psmouse, bool enable)
189{
190 int v, nv;
191
192 if (fsp_reg_read(psmouse, FSP_REG_SYSCTL1, &v) == -1)
193 return -1;
194
195 if (enable)
196 nv = v | FSP_BIT_EN_REG_CLK;
197 else
198 nv = v & ~FSP_BIT_EN_REG_CLK;
199
200 /* only write if necessary */
201 if (nv != v)
202 if (fsp_reg_write(psmouse, FSP_REG_SYSCTL1, nv) == -1)
203 return -1;
204
205 return 0;
206}
207
208static int fsp_page_reg_read(struct psmouse *psmouse, int *reg_val)
209{
210 struct ps2dev *ps2dev = &psmouse->ps2dev;
211 unsigned char param[3];
212 int rc = -1;
213
c35c0e7d 214 psmouse_deactivate(psmouse);
181d683d
DT		 215
216 ps2_begin_command(ps2dev);
fc69f4a6
TL		 217
218 if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
219 goto out;
220
221 ps2_sendbyte(ps2dev, 0x66, FSP_CMD_TIMEOUT2);
222 ps2_sendbyte(ps2dev, 0x88, FSP_CMD_TIMEOUT2);
223
224 if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
225 goto out;
226
227 ps2_sendbyte(ps2dev, 0x83, FSP_CMD_TIMEOUT2);
228 ps2_sendbyte(ps2dev, 0x88, FSP_CMD_TIMEOUT2);
229
230 /* get the returned result */
231 if (__ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO))
232 goto out;
233
234 *reg_val = param[2];
235 rc = 0;
236
237 out:
181d683d 238 ps2_end_command(ps2dev);
c35c0e7d 239 psmouse_activate(psmouse);
fc69f4a6
TL		 240 dev_dbg(&ps2dev->serio->dev, "READ PAGE REG: 0x%02x (rc = %d)\n",
241 *reg_val, rc);
242 return rc;
243}
244
245static int fsp_page_reg_write(struct psmouse *psmouse, int reg_val)
246{
247 struct ps2dev *ps2dev = &psmouse->ps2dev;
248 unsigned char v;
249 int rc = -1;
250
181d683d 251 ps2_begin_command(ps2dev);
fc69f4a6
TL		 252
253 if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
254 goto out;
255
256 ps2_sendbyte(ps2dev, 0x38, FSP_CMD_TIMEOUT2);
257 ps2_sendbyte(ps2dev, 0x88, FSP_CMD_TIMEOUT2);
258
259 if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
d9bae67a 260 goto out;
fc69f4a6
TL		 261
262 if ((v = fsp_test_invert_cmd(reg_val)) != reg_val) {
263 ps2_sendbyte(ps2dev, 0x47, FSP_CMD_TIMEOUT2);
264 } else if ((v = fsp_test_swap_cmd(reg_val)) != reg_val) {
265 /* swapping is required */
266 ps2_sendbyte(ps2dev, 0x44, FSP_CMD_TIMEOUT2);
267 } else {
268 /* swapping isn't necessary */
269 ps2_sendbyte(ps2dev, 0x33, FSP_CMD_TIMEOUT2);
270 }
271
272 ps2_sendbyte(ps2dev, v, FSP_CMD_TIMEOUT2);
273 rc = 0;
274
275 out:
181d683d 276 ps2_end_command(ps2dev);
fc69f4a6
TL		 277 dev_dbg(&ps2dev->serio->dev, "WRITE PAGE REG: to 0x%02x (rc = %d)\n",
278 reg_val, rc);
279 return rc;
280}
281
282static int fsp_get_version(struct psmouse *psmouse, int *version)
283{
284 if (fsp_reg_read(psmouse, FSP_REG_VERSION, version))
285 return -EIO;
286
287 return 0;
288}
289
290static int fsp_get_revision(struct psmouse *psmouse, int *rev)
291{
292 if (fsp_reg_read(psmouse, FSP_REG_REVISION, rev))
293 return -EIO;
294
295 return 0;
296}
297
298static int fsp_get_buttons(struct psmouse *psmouse, int *btn)
299{
300 static const int buttons[] = {
301 0x16, /* Left/Middle/Right/Forward/Backward & Scroll Up/Down */
302 0x06, /* Left/Middle/Right & Scroll Up/Down/Right/Left */
303 0x04, /* Left/Middle/Right & Scroll Up/Down */
304 0x02, /* Left/Middle/Right */
305 };
306 int val;
307
6ccbcf2c 308 if (fsp_reg_read(psmouse, FSP_REG_TMOD_STATUS, &val) == -1)
fc69f4a6
TL		 309 return -EIO;
310
311 *btn = buttons[(val & 0x30) >> 4];
312 return 0;
313}
314
315/* Enable on-pad command tag output */
316static int fsp_opc_tag_enable(struct psmouse *psmouse, bool enable)
317{
318 int v, nv;
319 int res = 0;
320
321 if (fsp_reg_read(psmouse, FSP_REG_OPC_QDOWN, &v) == -1) {
322 dev_err(&psmouse->ps2dev.serio->dev, "Unable get OPC state.\n");
323 return -EIO;
324 }
325
326 if (enable)
327 nv = v | FSP_BIT_EN_OPC_TAG;
328 else
329 nv = v & ~FSP_BIT_EN_OPC_TAG;
330
331 /* only write if necessary */
332 if (nv != v) {
333 fsp_reg_write_enable(psmouse, true);
334 res = fsp_reg_write(psmouse, FSP_REG_OPC_QDOWN, nv);
335 fsp_reg_write_enable(psmouse, false);
336 }
337
338 if (res != 0) {
339 dev_err(&psmouse->ps2dev.serio->dev,
340 "Unable to enable OPC tag.\n");
341 res = -EIO;
342 }
343
344 return res;
345}
346
347static int fsp_onpad_vscr(struct psmouse *psmouse, bool enable)
348{
349 struct fsp_data *pad = psmouse->private;
350 int val;
351
352 if (fsp_reg_read(psmouse, FSP_REG_ONPAD_CTL, &val))
353 return -EIO;
354
355 pad->vscroll = enable;
356
357 if (enable)
358 val |= (FSP_BIT_FIX_VSCR | FSP_BIT_ONPAD_ENABLE);
359 else
360 val &= ~FSP_BIT_FIX_VSCR;
361
362 if (fsp_reg_write(psmouse, FSP_REG_ONPAD_CTL, val))
363 return -EIO;
364
365 return 0;
366}
367
368static int fsp_onpad_hscr(struct psmouse *psmouse, bool enable)
369{
370 struct fsp_data *pad = psmouse->private;
371 int val, v2;
372
373 if (fsp_reg_read(psmouse, FSP_REG_ONPAD_CTL, &val))
374 return -EIO;
375
376 if (fsp_reg_read(psmouse, FSP_REG_SYSCTL5, &v2))
377 return -EIO;
378
379 pad->hscroll = enable;
380
381 if (enable) {
382 val |= (FSP_BIT_FIX_HSCR | FSP_BIT_ONPAD_ENABLE);
383 v2 |= FSP_BIT_EN_MSID6;
384 } else {
385 val &= ~FSP_BIT_FIX_HSCR;
386 v2 &= ~(FSP_BIT_EN_MSID6 | FSP_BIT_EN_MSID7 | FSP_BIT_EN_MSID8);
387 }
388
389 if (fsp_reg_write(psmouse, FSP_REG_ONPAD_CTL, val))
390 return -EIO;
391
392 /* reconfigure horizontal scrolling packet output */
393 if (fsp_reg_write(psmouse, FSP_REG_SYSCTL5, v2))
394 return -EIO;
395
396 return 0;
397}
398
399/*
400 * Write device specific initial parameters.
401 *
402 * ex: 0xab 0xcd - write oxcd into register 0xab
403 */
404static ssize_t fsp_attr_set_setreg(struct psmouse *psmouse, void *data,
405 const char *buf, size_t count)
406{
76496e7a 407 int reg, val;
fc69f4a6
TL		 408 char *rest;
409 ssize_t retval;
410
411 reg = simple_strtoul(buf, &rest, 16);
412 if (rest == buf || *rest != ' ' || reg > 0xff)
413 return -EINVAL;
414
76496e7a
JD		 415 retval = kstrtoint(rest + 1, 16, &val);
416 if (retval)
417 return retval;
418
419 if (val > 0xff)
fc69f4a6
TL		 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
432PSMOUSE_DEFINE_WO_ATTR(setreg, S_IWUSR, NULL, fsp_attr_set_setreg);
433
434static 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 */
447static 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;
76496e7a
JD		 451 int reg, val, err;
452
453 err = kstrtoint(buf, 16, &reg);
454 if (err)
455 return err;
fc69f4a6 456
76496e7a 457 if (reg > 0xff)
fc69f4a6
TL		 458 return -EINVAL;
459
460 if (fsp_reg_read(psmouse, reg, &val))
461 return -EIO;
462
463 pad->last_reg = reg;
464 pad->last_val = val;
465
466 return count;
467}
468
469PSMOUSE_DEFINE_ATTR(getreg, S_IWUSR | S_IRUGO, NULL,
470 fsp_attr_show_getreg, fsp_attr_set_getreg);
471
472static ssize_t fsp_attr_show_pagereg(struct psmouse *psmouse,
473 void *data, char *buf)
474{
475 int val = 0;
476
477 if (fsp_page_reg_read(psmouse, &val))
478 return -EIO;
479
480 return sprintf(buf, "%02x\n", val);
481}
482
483static ssize_t fsp_attr_set_pagereg(struct psmouse *psmouse, void *data,
484 const char *buf, size_t count)
485{
76496e7a 486 int val, err;
fc69f4a6 487
76496e7a
JD		 488 err = kstrtoint(buf, 16, &val);
489 if (err)
490 return err;
491
492 if (val > 0xff)
fc69f4a6
TL		 493 return -EINVAL;
494
495 if (fsp_page_reg_write(psmouse, val))
496 return -EIO;
497
498 return count;
499}
500
501PSMOUSE_DEFINE_ATTR(page, S_IWUSR | S_IRUGO, NULL,
502 fsp_attr_show_pagereg, fsp_attr_set_pagereg);
503
504static ssize_t fsp_attr_show_vscroll(struct psmouse *psmouse,
505 void *data, char *buf)
506{
507 struct fsp_data *pad = psmouse->private;
508
509 return sprintf(buf, "%d\n", pad->vscroll);
510}
511
512static ssize_t fsp_attr_set_vscroll(struct psmouse *psmouse, void *data,
513 const char *buf, size_t count)
514{
76496e7a
JD		 515 unsigned int val;
516 int err;
517
518 err = kstrtouint(buf, 10, &val);
519 if (err)
520 return err;
fc69f4a6 521
76496e7a 522 if (val > 1)
fc69f4a6
TL		 523 return -EINVAL;
524
525 fsp_onpad_vscr(psmouse, val);
526
527 return count;
528}
529
530PSMOUSE_DEFINE_ATTR(vscroll, S_IWUSR | S_IRUGO, NULL,
531 fsp_attr_show_vscroll, fsp_attr_set_vscroll);
532
533static ssize_t fsp_attr_show_hscroll(struct psmouse *psmouse,
534 void *data, char *buf)
535{
536 struct fsp_data *pad = psmouse->private;
537
538 return sprintf(buf, "%d\n", pad->hscroll);
539}
540
541static ssize_t fsp_attr_set_hscroll(struct psmouse *psmouse, void *data,
542 const char *buf, size_t count)
543{
76496e7a
JD		 544 unsigned int val;
545 int err;
546
547 err = kstrtouint(buf, 10, &val);
548 if (err)
549 return err;
fc69f4a6 550
76496e7a 551 if (val > 1)
fc69f4a6
TL		 552 return -EINVAL;
553
554 fsp_onpad_hscr(psmouse, val);
555
556 return count;
557}
558
559PSMOUSE_DEFINE_ATTR(hscroll, S_IWUSR | S_IRUGO, NULL,
560 fsp_attr_show_hscroll, fsp_attr_set_hscroll);
561
562static ssize_t fsp_attr_show_flags(struct psmouse *psmouse,
563 void *data, char *buf)
564{
565 struct fsp_data *pad = psmouse->private;
566
567 return sprintf(buf, "%c\n",
568 pad->flags & FSPDRV_FLAG_EN_OPC ? 'C' : 'c');
569}
570
571static ssize_t fsp_attr_set_flags(struct psmouse *psmouse, void *data,
572 const char *buf, size_t count)
573{
574 struct fsp_data *pad = psmouse->private;
575 size_t i;
576
577 for (i = 0; i < count; i++) {
578 switch (buf[i]) {
579 case 'C':
580 pad->flags |= FSPDRV_FLAG_EN_OPC;
581 break;
582 case 'c':
583 pad->flags &= ~FSPDRV_FLAG_EN_OPC;
584 break;
585 default:
586 return -EINVAL;
587 }
588 }
589 return count;
590}
591
592PSMOUSE_DEFINE_ATTR(flags, S_IWUSR | S_IRUGO, NULL,
593 fsp_attr_show_flags, fsp_attr_set_flags);
594
595static ssize_t fsp_attr_show_ver(struct psmouse *psmouse,
596 void *data, char *buf)
597{
598 return sprintf(buf, "Sentelic FSP kernel module %s\n", fsp_drv_ver);
599}
600
601PSMOUSE_DEFINE_RO_ATTR(ver, S_IRUGO, NULL, fsp_attr_show_ver);
602
603static struct attribute *fsp_attributes[] = {
604 &psmouse_attr_setreg.dattr.attr,
605 &psmouse_attr_getreg.dattr.attr,
606 &psmouse_attr_page.dattr.attr,
607 &psmouse_attr_vscroll.dattr.attr,
608 &psmouse_attr_hscroll.dattr.attr,
609 &psmouse_attr_flags.dattr.attr,
610 &psmouse_attr_ver.dattr.attr,
611 NULL
612};
613
614static struct attribute_group fsp_attribute_group = {
615 .attrs = fsp_attributes,
616};
617
618#ifdef FSP_DEBUG
619static void fsp_packet_debug(unsigned char packet[])
620{
621 static unsigned int ps2_packet_cnt;
622 static unsigned int ps2_last_second;
623 unsigned int jiffies_msec;
624
625 ps2_packet_cnt++;
626 jiffies_msec = jiffies_to_msecs(jiffies);
b5d21704
DT		 627 psmouse_dbg(psmouse,
628 "%08dms PS/2 packets: %02x, %02x, %02x, %02x\n",
629 jiffies_msec, packet[0], packet[1], packet[2], packet[3]);
fc69f4a6
TL		 630
631 if (jiffies_msec - ps2_last_second > 1000) {
b5d21704 632 psmouse_dbg(psmouse, "PS/2 packets/sec = %d\n", ps2_packet_cnt);
fc69f4a6
TL		 633 ps2_packet_cnt = 0;
634 ps2_last_second = jiffies_msec;
635 }
636}
637#else
638static void fsp_packet_debug(unsigned char packet[])
639{
640}
641#endif
642
643static psmouse_ret_t fsp_process_byte(struct psmouse *psmouse)
644{
645 struct input_dev *dev = psmouse->dev;
646 struct fsp_data *ad = psmouse->private;
647 unsigned char *packet = psmouse->packet;
648 unsigned char button_status = 0, lscroll = 0, rscroll = 0;
649 int rel_x, rel_y;
650
651 if (psmouse->pktcnt < 4)
652 return PSMOUSE_GOOD_DATA;
653
654 /*
655 * Full packet accumulated, process it
656 */
657
658 switch (psmouse->packet[0] >> FSP_PKT_TYPE_SHIFT) {
659 case FSP_PKT_TYPE_ABS:
660 dev_warn(&psmouse->ps2dev.serio->dev,
661 "Unexpected absolute mode packet, ignored.\n");
662 break;
663
664 case FSP_PKT_TYPE_NORMAL_OPC:
665 /* on-pad click, filter it if necessary */
666 if ((ad->flags & FSPDRV_FLAG_EN_OPC) != FSPDRV_FLAG_EN_OPC)
667 packet[0] &= ~BIT(0);
668 /* fall through */
669
670 case FSP_PKT_TYPE_NORMAL:
671 /* normal packet */
672 /* special packet data translation from on-pad packets */
673 if (packet[3] != 0) {
674 if (packet[3] & BIT(0))
675 button_status |= 0x01; /* wheel down */
676 if (packet[3] & BIT(1))
677 button_status |= 0x0f; /* wheel up */
678 if (packet[3] & BIT(2))
c332e9fc 679 button_status |= BIT(4);/* horizontal left */
fc69f4a6 680 if (packet[3] & BIT(3))
c332e9fc 681 button_status |= BIT(5);/* horizontal right */
fc69f4a6
TL		 682 /* push back to packet queue */
683 if (button_status != 0)
684 packet[3] = button_status;
685 rscroll = (packet[3] >> 4) & 1;
686 lscroll = (packet[3] >> 5) & 1;
687 }
688 /*
689 * Processing wheel up/down and extra button events
690 */
691 input_report_rel(dev, REL_WHEEL,
692 (int)(packet[3] & 8) - (int)(packet[3] & 7));
693 input_report_rel(dev, REL_HWHEEL, lscroll - rscroll);
694 input_report_key(dev, BTN_BACK, lscroll);
695 input_report_key(dev, BTN_FORWARD, rscroll);
696
697 /*
698 * Standard PS/2 Mouse
699 */
700 input_report_key(dev, BTN_LEFT, packet[0] & 1);
701 input_report_key(dev, BTN_MIDDLE, (packet[0] >> 2) & 1);
702 input_report_key(dev, BTN_RIGHT, (packet[0] >> 1) & 1);
703
704 rel_x = packet[1] ? (int)packet[1] - (int)((packet[0] << 4) & 0x100) : 0;
705 rel_y = packet[2] ? (int)((packet[0] << 3) & 0x100) - (int)packet[2] : 0;
706
707 input_report_rel(dev, REL_X, rel_x);
708 input_report_rel(dev, REL_Y, rel_y);
709 break;
710 }
711
712 input_sync(dev);
713
714 fsp_packet_debug(packet);
715
716 return PSMOUSE_FULL_PACKET;
717}
718
719static int fsp_activate_protocol(struct psmouse *psmouse)
720{
721 struct fsp_data *pad = psmouse->private;
722 struct ps2dev *ps2dev = &psmouse->ps2dev;
723 unsigned char param[2];
724 int val;
725
726 /*
727 * Standard procedure to enter FSP Intellimouse mode
728 * (scrolling wheel, 4th and 5th buttons)
729 */
730 param[0] = 200;
731 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
732 param[0] = 200;
733 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
734 param[0] = 80;
735 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
736
737 ps2_command(ps2dev, param, PSMOUSE_CMD_GETID);
738 if (param[0] != 0x04) {
739 dev_err(&psmouse->ps2dev.serio->dev,
740 "Unable to enable 4 bytes packet format.\n");
741 return -EIO;
742 }
743
744 if (fsp_reg_read(psmouse, FSP_REG_SYSCTL5, &val)) {
745 dev_err(&psmouse->ps2dev.serio->dev,
746 "Unable to read SYSCTL5 register.\n");
747 return -EIO;
748 }
749
750 val &= ~(FSP_BIT_EN_MSID7 | FSP_BIT_EN_MSID8 | FSP_BIT_EN_AUTO_MSID8);
751 /* Ensure we are not in absolute mode */
752 val &= ~FSP_BIT_EN_PKT_G0;
753 if (pad->buttons == 0x06) {
754 /* Left/Middle/Right & Scroll Up/Down/Right/Left */
755 val |= FSP_BIT_EN_MSID6;
756 }
757
758 if (fsp_reg_write(psmouse, FSP_REG_SYSCTL5, val)) {
759 dev_err(&psmouse->ps2dev.serio->dev,
760 "Unable to set up required mode bits.\n");
761 return -EIO;
762 }
763
764 /*
765 * Enable OPC tags such that driver can tell the difference between
766 * on-pad and real button click
767 */
768 if (fsp_opc_tag_enable(psmouse, true))
769 dev_warn(&psmouse->ps2dev.serio->dev,
770 "Failed to enable OPC tag mode.\n");
771
772 /* Enable on-pad vertical and horizontal scrolling */
773 fsp_onpad_vscr(psmouse, true);
774 fsp_onpad_hscr(psmouse, true);
775
776 return 0;
777}
778
b7802c5c 779int fsp_detect(struct psmouse *psmouse, bool set_properties)
fc69f4a6
TL		 780{
781 int id;
782
783 if (fsp_reg_read(psmouse, FSP_REG_DEVICE_ID, &id))
784 return -EIO;
785
786 if (id != 0x01)
787 return -ENODEV;
788
789 if (set_properties) {
790 psmouse->vendor = "Sentelic";
791 psmouse->name = "FingerSensingPad";
792 }
793
794 return 0;
795}
796
797static void fsp_reset(struct psmouse *psmouse)
798{
799 fsp_opc_tag_enable(psmouse, false);
800 fsp_onpad_vscr(psmouse, false);
801 fsp_onpad_hscr(psmouse, false);
802}
803
804static void fsp_disconnect(struct psmouse *psmouse)
805{
806 sysfs_remove_group(&psmouse->ps2dev.serio->dev.kobj,
807 &fsp_attribute_group);
808
809 fsp_reset(psmouse);
810 kfree(psmouse->private);
811}
812
813static int fsp_reconnect(struct psmouse *psmouse)
814{
815 int version;
816
817 if (fsp_detect(psmouse, 0))
818 return -ENODEV;
819
820 if (fsp_get_version(psmouse, &version))
821 return -ENODEV;
822
823 if (fsp_activate_protocol(psmouse))
824 return -EIO;
825
826 return 0;
827}
828
829int fsp_init(struct psmouse *psmouse)
830{
831 struct fsp_data *priv;
832 int ver, rev, buttons;
833 int error;
834
835 if (fsp_get_version(psmouse, &ver) ||
836 fsp_get_revision(psmouse, &rev) ||
837 fsp_get_buttons(psmouse, &buttons)) {
838 return -ENODEV;
839 }
840
b5d21704
DT		 841 psmouse_info(psmouse,
842 "Finger Sensing Pad, hw: %d.%d.%d, sw: %s, buttons: %d\n",
843 ver >> 4, ver & 0x0F, rev, fsp_drv_ver, buttons & 7);
fc69f4a6
TL		 844
845 psmouse->private = priv = kzalloc(sizeof(struct fsp_data), GFP_KERNEL);
846 if (!priv)
847 return -ENOMEM;
848
849 priv->ver = ver;
850 priv->rev = rev;
851 priv->buttons = buttons;
852
853 /* enable on-pad click by default */
854 priv->flags |= FSPDRV_FLAG_EN_OPC;
855
856 /* Set up various supported input event bits */
315eb996 857 __set_bit(BTN_MIDDLE, psmouse->dev->keybit);
fc69f4a6
TL		 858 __set_bit(BTN_BACK, psmouse->dev->keybit);
859 __set_bit(BTN_FORWARD, psmouse->dev->keybit);
860 __set_bit(REL_WHEEL, psmouse->dev->relbit);
861 __set_bit(REL_HWHEEL, psmouse->dev->relbit);
862
863 psmouse->protocol_handler = fsp_process_byte;
864 psmouse->disconnect = fsp_disconnect;
865 psmouse->reconnect = fsp_reconnect;
866 psmouse->cleanup = fsp_reset;
867 psmouse->pktsize = 4;
868
869 /* set default packet output based on number of buttons we found */
870 error = fsp_activate_protocol(psmouse);
871 if (error)
872 goto err_out;
873
874 error = sysfs_create_group(&psmouse->ps2dev.serio->dev.kobj,
875 &fsp_attribute_group);
876 if (error) {
877 dev_err(&psmouse->ps2dev.serio->dev,
878 "Failed to create sysfs attributes (%d)", error);
879 goto err_out;
880 }
881
882 return 0;
883
884 err_out:
885 kfree(psmouse->private);
886 psmouse->private = NULL;
887 return error;
888}
Linux kernel - Deliverables
This page took 0.199306 seconds and 5 git commands to generate.