2 * Cypress Trackpad PS/2 mouse driver
4 * Copyright (c) 2012 Cypress Semiconductor Corporation.
7 * Dudley Du <dudl@cypress.com>
9 * Additional contributors include:
10 * Kamal Mostafa <kamal@canonical.com>
11 * Kyle Fazzari <git@status.e4ward.com>
13 * This program is free software; you can redistribute it and/or modify it
14 * under the terms of the GNU General Public License version 2 as published by
15 * the Free Software Foundation.
18 #include <linux/init.h>
19 #include <linux/module.h>
20 #include <linux/kernel.h>
21 #include <linux/slab.h>
22 #include <linux/serio.h>
23 #include <linux/libps2.h>
24 #include <linux/input.h>
25 #include <linux/input/mt.h>
26 #include <linux/sched.h>
27 #include <linux/wait.h>
29 #include "cypress_ps2.h"
31 #undef CYTP_DEBUG_VERBOSE /* define this and DEBUG for more verbose dump */
33 static void cypress_set_packet_size(struct psmouse
*psmouse
, unsigned int n
)
35 struct cytp_data
*cytp
= psmouse
->private;
39 static const unsigned char cytp_rate
[] = {10, 20, 40, 60, 100, 200};
40 static const unsigned char cytp_resolution
[] = {0x00, 0x01, 0x02, 0x03};
42 static int cypress_ps2_sendbyte(struct psmouse
*psmouse
, int value
)
44 struct ps2dev
*ps2dev
= &psmouse
->ps2dev
;
46 if (ps2_sendbyte(ps2dev
, value
& 0xff, CYTP_CMD_TIMEOUT
) < 0) {
48 "sending command 0x%02x failed, resp 0x%02x\n",
49 value
& 0xff, ps2dev
->nak
);
50 if (ps2dev
->nak
== CYTP_PS2_RETRY
)
51 return CYTP_PS2_RETRY
;
53 return CYTP_PS2_ERROR
;
56 #ifdef CYTP_DEBUG_VERBOSE
57 psmouse_dbg(psmouse
, "sending command 0x%02x succeeded, resp 0xfa\n",
64 static int cypress_ps2_ext_cmd(struct psmouse
*psmouse
, unsigned short cmd
,
67 struct ps2dev
*ps2dev
= &psmouse
->ps2dev
;
68 int tries
= CYTP_PS2_CMD_TRIES
;
71 ps2_begin_command(ps2dev
);
75 * Send extension command byte (0xE8 or 0xF3).
76 * If sending the command fails, send recovery command
77 * to make the device return to the ready state.
79 rc
= cypress_ps2_sendbyte(psmouse
, cmd
& 0xff);
80 if (rc
== CYTP_PS2_RETRY
) {
81 rc
= cypress_ps2_sendbyte(psmouse
, 0x00);
82 if (rc
== CYTP_PS2_RETRY
)
83 rc
= cypress_ps2_sendbyte(psmouse
, 0x0a);
85 if (rc
== CYTP_PS2_ERROR
)
88 rc
= cypress_ps2_sendbyte(psmouse
, data
);
89 if (rc
== CYTP_PS2_RETRY
)
90 rc
= cypress_ps2_sendbyte(psmouse
, data
);
91 if (rc
== CYTP_PS2_ERROR
)
95 } while (--tries
> 0);
97 ps2_end_command(ps2dev
);
102 static int cypress_ps2_read_cmd_status(struct psmouse
*psmouse
,
104 unsigned char *param
)
107 struct ps2dev
*ps2dev
= &psmouse
->ps2dev
;
108 enum psmouse_state old_state
;
111 ps2_begin_command(&psmouse
->ps2dev
);
113 old_state
= psmouse
->state
;
114 psmouse
->state
= PSMOUSE_CMD_MODE
;
117 pktsize
= (cmd
== CYTP_CMD_READ_TP_METRICS
) ? 8 : 3;
118 memset(param
, 0, pktsize
);
120 rc
= cypress_ps2_sendbyte(psmouse
, 0xe9);
124 wait_event_timeout(ps2dev
->wait
,
125 (psmouse
->pktcnt
>= pktsize
),
126 msecs_to_jiffies(CYTP_CMD_TIMEOUT
));
128 memcpy(param
, psmouse
->packet
, pktsize
);
130 psmouse_dbg(psmouse
, "Command 0x%02x response data (0x): %*ph\n",
131 cmd
, pktsize
, param
);
134 psmouse
->state
= old_state
;
137 ps2_end_command(&psmouse
->ps2dev
);
142 static bool cypress_verify_cmd_state(struct psmouse
*psmouse
,
143 unsigned char cmd
, unsigned char *param
)
145 bool rate_match
= false;
146 bool resolution_match
= false;
149 /* callers will do further checking. */
150 if (cmd
== CYTP_CMD_READ_CYPRESS_ID
||
151 cmd
== CYTP_CMD_STANDARD_MODE
||
152 cmd
== CYTP_CMD_READ_TP_METRICS
)
155 if ((~param
[0] & DFLT_RESP_BITS_VALID
) == DFLT_RESP_BITS_VALID
&&
156 (param
[0] & DFLT_RESP_BIT_MODE
) == DFLT_RESP_STREAM_MODE
) {
157 for (i
= 0; i
< sizeof(cytp_resolution
); i
++)
158 if (cytp_resolution
[i
] == param
[1])
159 resolution_match
= true;
161 for (i
= 0; i
< sizeof(cytp_rate
); i
++)
162 if (cytp_rate
[i
] == param
[2])
165 if (resolution_match
&& rate_match
)
169 psmouse_dbg(psmouse
, "verify cmd state failed.\n");
173 static int cypress_send_ext_cmd(struct psmouse
*psmouse
, unsigned char cmd
,
174 unsigned char *param
)
176 int tries
= CYTP_PS2_CMD_TRIES
;
179 psmouse_dbg(psmouse
, "send extension cmd 0x%02x, [%d %d %d %d]\n",
180 cmd
, DECODE_CMD_AA(cmd
), DECODE_CMD_BB(cmd
),
181 DECODE_CMD_CC(cmd
), DECODE_CMD_DD(cmd
));
184 cypress_ps2_ext_cmd(psmouse
,
185 PSMOUSE_CMD_SETRES
, DECODE_CMD_DD(cmd
));
186 cypress_ps2_ext_cmd(psmouse
,
187 PSMOUSE_CMD_SETRES
, DECODE_CMD_CC(cmd
));
188 cypress_ps2_ext_cmd(psmouse
,
189 PSMOUSE_CMD_SETRES
, DECODE_CMD_BB(cmd
));
190 cypress_ps2_ext_cmd(psmouse
,
191 PSMOUSE_CMD_SETRES
, DECODE_CMD_AA(cmd
));
193 rc
= cypress_ps2_read_cmd_status(psmouse
, cmd
, param
);
197 if (cypress_verify_cmd_state(psmouse
, cmd
, param
))
200 } while (--tries
> 0);
205 int cypress_detect(struct psmouse
*psmouse
, bool set_properties
)
207 unsigned char param
[3];
209 if (cypress_send_ext_cmd(psmouse
, CYTP_CMD_READ_CYPRESS_ID
, param
))
212 /* Check for Cypress Trackpad signature bytes: 0x33 0xCC */
213 if (param
[0] != 0x33 || param
[1] != 0xCC)
216 if (set_properties
) {
217 psmouse
->vendor
= "Cypress";
218 psmouse
->name
= "Trackpad";
224 static int cypress_read_fw_version(struct psmouse
*psmouse
)
226 struct cytp_data
*cytp
= psmouse
->private;
227 unsigned char param
[3];
229 if (cypress_send_ext_cmd(psmouse
, CYTP_CMD_READ_CYPRESS_ID
, param
))
232 /* Check for Cypress Trackpad signature bytes: 0x33 0xCC */
233 if (param
[0] != 0x33 || param
[1] != 0xCC)
236 cytp
->fw_version
= param
[2] & FW_VERSION_MASX
;
237 cytp
->tp_metrics_supported
= (param
[2] & TP_METRICS_MASK
) ? 1 : 0;
240 * Trackpad fw_version 11 (in Dell XPS12) yields a bogus response to
241 * CYTP_CMD_READ_TP_METRICS so do not try to use it. LP: #1103594.
243 if (cytp
->fw_version
>= 11)
244 cytp
->tp_metrics_supported
= 0;
246 psmouse_dbg(psmouse
, "cytp->fw_version = %d\n", cytp
->fw_version
);
247 psmouse_dbg(psmouse
, "cytp->tp_metrics_supported = %d\n",
248 cytp
->tp_metrics_supported
);
253 static int cypress_read_tp_metrics(struct psmouse
*psmouse
)
255 struct cytp_data
*cytp
= psmouse
->private;
256 unsigned char param
[8];
258 /* set default values for tp metrics. */
259 cytp
->tp_width
= CYTP_DEFAULT_WIDTH
;
260 cytp
->tp_high
= CYTP_DEFAULT_HIGH
;
261 cytp
->tp_max_abs_x
= CYTP_ABS_MAX_X
;
262 cytp
->tp_max_abs_y
= CYTP_ABS_MAX_Y
;
263 cytp
->tp_min_pressure
= CYTP_MIN_PRESSURE
;
264 cytp
->tp_max_pressure
= CYTP_MAX_PRESSURE
;
265 cytp
->tp_res_x
= cytp
->tp_max_abs_x
/ cytp
->tp_width
;
266 cytp
->tp_res_y
= cytp
->tp_max_abs_y
/ cytp
->tp_high
;
268 if (!cytp
->tp_metrics_supported
)
271 memset(param
, 0, sizeof(param
));
272 if (cypress_send_ext_cmd(psmouse
, CYTP_CMD_READ_TP_METRICS
, param
) == 0) {
273 /* Update trackpad parameters. */
274 cytp
->tp_max_abs_x
= (param
[1] << 8) | param
[0];
275 cytp
->tp_max_abs_y
= (param
[3] << 8) | param
[2];
276 cytp
->tp_min_pressure
= param
[4];
277 cytp
->tp_max_pressure
= param
[5];
280 if (!cytp
->tp_max_pressure
||
281 cytp
->tp_max_pressure
< cytp
->tp_min_pressure
||
282 !cytp
->tp_width
|| !cytp
->tp_high
||
283 !cytp
->tp_max_abs_x
||
284 cytp
->tp_max_abs_x
< cytp
->tp_width
||
285 !cytp
->tp_max_abs_y
||
286 cytp
->tp_max_abs_y
< cytp
->tp_high
)
289 cytp
->tp_res_x
= cytp
->tp_max_abs_x
/ cytp
->tp_width
;
290 cytp
->tp_res_y
= cytp
->tp_max_abs_y
/ cytp
->tp_high
;
292 #ifdef CYTP_DEBUG_VERBOSE
293 psmouse_dbg(psmouse
, "Dump trackpad hardware configuration as below:\n");
294 psmouse_dbg(psmouse
, "cytp->tp_width = %d\n", cytp
->tp_width
);
295 psmouse_dbg(psmouse
, "cytp->tp_high = %d\n", cytp
->tp_high
);
296 psmouse_dbg(psmouse
, "cytp->tp_max_abs_x = %d\n", cytp
->tp_max_abs_x
);
297 psmouse_dbg(psmouse
, "cytp->tp_max_abs_y = %d\n", cytp
->tp_max_abs_y
);
298 psmouse_dbg(psmouse
, "cytp->tp_min_pressure = %d\n", cytp
->tp_min_pressure
);
299 psmouse_dbg(psmouse
, "cytp->tp_max_pressure = %d\n", cytp
->tp_max_pressure
);
300 psmouse_dbg(psmouse
, "cytp->tp_res_x = %d\n", cytp
->tp_res_x
);
301 psmouse_dbg(psmouse
, "cytp->tp_res_y = %d\n", cytp
->tp_res_y
);
303 psmouse_dbg(psmouse
, "tp_type_APA = %d\n",
304 (param
[6] & TP_METRICS_BIT_APA
) ? 1 : 0);
305 psmouse_dbg(psmouse
, "tp_type_MTG = %d\n",
306 (param
[6] & TP_METRICS_BIT_MTG
) ? 1 : 0);
307 psmouse_dbg(psmouse
, "tp_palm = %d\n",
308 (param
[6] & TP_METRICS_BIT_PALM
) ? 1 : 0);
309 psmouse_dbg(psmouse
, "tp_stubborn = %d\n",
310 (param
[6] & TP_METRICS_BIT_STUBBORN
) ? 1 : 0);
311 psmouse_dbg(psmouse
, "tp_1f_jitter = %d\n",
312 (param
[6] & TP_METRICS_BIT_1F_JITTER
) >> 2);
313 psmouse_dbg(psmouse
, "tp_2f_jitter = %d\n",
314 (param
[6] & TP_METRICS_BIT_2F_JITTER
) >> 4);
315 psmouse_dbg(psmouse
, "tp_1f_spike = %d\n",
316 param
[7] & TP_METRICS_BIT_1F_SPIKE
);
317 psmouse_dbg(psmouse
, "tp_2f_spike = %d\n",
318 (param
[7] & TP_METRICS_BIT_2F_SPIKE
) >> 2);
319 psmouse_dbg(psmouse
, "tp_abs_packet_format_set = %d\n",
320 (param
[7] & TP_METRICS_BIT_ABS_PKT_FORMAT_SET
) >> 4);
326 static int cypress_query_hardware(struct psmouse
*psmouse
)
330 ret
= cypress_read_fw_version(psmouse
);
334 ret
= cypress_read_tp_metrics(psmouse
);
341 static int cypress_set_absolute_mode(struct psmouse
*psmouse
)
343 struct cytp_data
*cytp
= psmouse
->private;
344 unsigned char param
[3];
346 if (cypress_send_ext_cmd(psmouse
, CYTP_CMD_ABS_WITH_PRESSURE_MODE
, param
) < 0)
349 cytp
->mode
= (cytp
->mode
& ~CYTP_BIT_ABS_REL_MASK
)
350 | CYTP_BIT_ABS_PRESSURE
;
351 cypress_set_packet_size(psmouse
, 5);
357 * Reset trackpad device.
358 * This is also the default mode when trackpad powered on.
360 static void cypress_reset(struct psmouse
*psmouse
)
362 struct cytp_data
*cytp
= psmouse
->private;
366 psmouse_reset(psmouse
);
369 static int cypress_set_input_params(struct input_dev
*input
,
370 struct cytp_data
*cytp
)
374 if (!cytp
->tp_res_x
|| !cytp
->tp_res_y
)
377 __set_bit(EV_ABS
, input
->evbit
);
378 input_set_abs_params(input
, ABS_X
, 0, cytp
->tp_max_abs_x
, 0, 0);
379 input_set_abs_params(input
, ABS_Y
, 0, cytp
->tp_max_abs_y
, 0, 0);
380 input_set_abs_params(input
, ABS_PRESSURE
,
381 cytp
->tp_min_pressure
, cytp
->tp_max_pressure
, 0, 0);
382 input_set_abs_params(input
, ABS_TOOL_WIDTH
, 0, 255, 0, 0);
384 /* finger position */
385 input_set_abs_params(input
, ABS_MT_POSITION_X
, 0, cytp
->tp_max_abs_x
, 0, 0);
386 input_set_abs_params(input
, ABS_MT_POSITION_Y
, 0, cytp
->tp_max_abs_y
, 0, 0);
387 input_set_abs_params(input
, ABS_MT_PRESSURE
, 0, 255, 0, 0);
389 ret
= input_mt_init_slots(input
, CYTP_MAX_MT_SLOTS
,
390 INPUT_MT_DROP_UNUSED
|INPUT_MT_TRACK
);
394 __set_bit(INPUT_PROP_SEMI_MT
, input
->propbit
);
396 input_abs_set_res(input
, ABS_X
, cytp
->tp_res_x
);
397 input_abs_set_res(input
, ABS_Y
, cytp
->tp_res_y
);
399 input_abs_set_res(input
, ABS_MT_POSITION_X
, cytp
->tp_res_x
);
400 input_abs_set_res(input
, ABS_MT_POSITION_Y
, cytp
->tp_res_y
);
402 __set_bit(BTN_TOUCH
, input
->keybit
);
403 __set_bit(BTN_TOOL_FINGER
, input
->keybit
);
404 __set_bit(BTN_TOOL_DOUBLETAP
, input
->keybit
);
405 __set_bit(BTN_TOOL_TRIPLETAP
, input
->keybit
);
406 __set_bit(BTN_TOOL_QUADTAP
, input
->keybit
);
407 __set_bit(BTN_TOOL_QUINTTAP
, input
->keybit
);
409 __clear_bit(EV_REL
, input
->evbit
);
410 __clear_bit(REL_X
, input
->relbit
);
411 __clear_bit(REL_Y
, input
->relbit
);
413 __set_bit(INPUT_PROP_BUTTONPAD
, input
->propbit
);
414 __set_bit(EV_KEY
, input
->evbit
);
415 __set_bit(BTN_LEFT
, input
->keybit
);
416 __set_bit(BTN_RIGHT
, input
->keybit
);
417 __set_bit(BTN_MIDDLE
, input
->keybit
);
419 input_set_drvdata(input
, cytp
);
424 static int cypress_get_finger_count(unsigned char header_byte
)
426 unsigned char bits6_7
;
429 bits6_7
= header_byte
>> 6;
430 finger_count
= bits6_7
& 0x03;
432 if (finger_count
== 1)
435 if (header_byte
& ABS_HSCROLL_BIT
) {
436 /* HSCROLL gets added on to 0 finger count. */
437 switch (finger_count
) {
441 /* Invalid contact (e.g. palm). Ignore it. */
450 static int cypress_parse_packet(struct psmouse
*psmouse
,
451 struct cytp_data
*cytp
, struct cytp_report_data
*report_data
)
453 unsigned char *packet
= psmouse
->packet
;
454 unsigned char header_byte
= packet
[0];
456 memset(report_data
, 0, sizeof(struct cytp_report_data
));
458 report_data
->contact_cnt
= cypress_get_finger_count(header_byte
);
459 report_data
->tap
= (header_byte
& ABS_MULTIFINGER_TAP
) ? 1 : 0;
461 if (report_data
->contact_cnt
== 1) {
462 report_data
->contacts
[0].x
=
463 ((packet
[1] & 0x70) << 4) | packet
[2];
464 report_data
->contacts
[0].y
=
465 ((packet
[1] & 0x07) << 8) | packet
[3];
466 if (cytp
->mode
& CYTP_BIT_ABS_PRESSURE
)
467 report_data
->contacts
[0].z
= packet
[4];
469 } else if (report_data
->contact_cnt
>= 2) {
470 report_data
->contacts
[0].x
=
471 ((packet
[1] & 0x70) << 4) | packet
[2];
472 report_data
->contacts
[0].y
=
473 ((packet
[1] & 0x07) << 8) | packet
[3];
474 if (cytp
->mode
& CYTP_BIT_ABS_PRESSURE
)
475 report_data
->contacts
[0].z
= packet
[4];
477 report_data
->contacts
[1].x
=
478 ((packet
[5] & 0xf0) << 4) | packet
[6];
479 report_data
->contacts
[1].y
=
480 ((packet
[5] & 0x0f) << 8) | packet
[7];
481 if (cytp
->mode
& CYTP_BIT_ABS_PRESSURE
)
482 report_data
->contacts
[1].z
= report_data
->contacts
[0].z
;
485 report_data
->left
= (header_byte
& BTN_LEFT_BIT
) ? 1 : 0;
486 report_data
->right
= (header_byte
& BTN_RIGHT_BIT
) ? 1 : 0;
489 * This is only true if one of the mouse buttons were tapped. Make
490 * sure it doesn't turn into a click. The regular tap-to-click
491 * functionality will handle that on its own. If we don't do this,
492 * disabling tap-to-click won't affect the mouse button zones.
494 if (report_data
->tap
)
495 report_data
->left
= 0;
497 #ifdef CYTP_DEBUG_VERBOSE
500 int n
= report_data
->contact_cnt
;
501 psmouse_dbg(psmouse
, "Dump parsed report data as below:\n");
502 psmouse_dbg(psmouse
, "contact_cnt = %d\n",
503 report_data
->contact_cnt
);
504 if (n
> CYTP_MAX_MT_SLOTS
)
505 n
= CYTP_MAX_MT_SLOTS
;
506 for (i
= 0; i
< n
; i
++)
507 psmouse_dbg(psmouse
, "contacts[%d] = {%d, %d, %d}\n", i
,
508 report_data
->contacts
[i
].x
,
509 report_data
->contacts
[i
].y
,
510 report_data
->contacts
[i
].z
);
511 psmouse_dbg(psmouse
, "left = %d\n", report_data
->left
);
512 psmouse_dbg(psmouse
, "right = %d\n", report_data
->right
);
513 psmouse_dbg(psmouse
, "middle = %d\n", report_data
->middle
);
520 static void cypress_process_packet(struct psmouse
*psmouse
, bool zero_pkt
)
523 struct input_dev
*input
= psmouse
->dev
;
524 struct cytp_data
*cytp
= psmouse
->private;
525 struct cytp_report_data report_data
;
526 struct cytp_contact
*contact
;
527 struct input_mt_pos pos
[CYTP_MAX_MT_SLOTS
];
528 int slots
[CYTP_MAX_MT_SLOTS
];
531 cypress_parse_packet(psmouse
, cytp
, &report_data
);
533 n
= report_data
.contact_cnt
;
534 if (n
> CYTP_MAX_MT_SLOTS
)
535 n
= CYTP_MAX_MT_SLOTS
;
537 for (i
= 0; i
< n
; i
++) {
538 contact
= &report_data
.contacts
[i
];
539 pos
[i
].x
= contact
->x
;
540 pos
[i
].y
= contact
->y
;
543 input_mt_assign_slots(input
, slots
, pos
, n
);
545 for (i
= 0; i
< n
; i
++) {
546 contact
= &report_data
.contacts
[i
];
547 input_mt_slot(input
, slots
[i
]);
548 input_mt_report_slot_state(input
, MT_TOOL_FINGER
, true);
549 input_report_abs(input
, ABS_MT_POSITION_X
, contact
->x
);
550 input_report_abs(input
, ABS_MT_POSITION_Y
, contact
->y
);
551 input_report_abs(input
, ABS_MT_PRESSURE
, contact
->z
);
554 input_mt_sync_frame(input
);
556 input_mt_report_finger_count(input
, report_data
.contact_cnt
);
558 input_report_key(input
, BTN_LEFT
, report_data
.left
);
559 input_report_key(input
, BTN_RIGHT
, report_data
.right
);
560 input_report_key(input
, BTN_MIDDLE
, report_data
.middle
);
565 static psmouse_ret_t
cypress_validate_byte(struct psmouse
*psmouse
)
568 int index
= psmouse
->pktcnt
- 1;
569 unsigned char *packet
= psmouse
->packet
;
570 struct cytp_data
*cytp
= psmouse
->private;
572 if (index
< 0 || index
> cytp
->pkt_size
)
573 return PSMOUSE_BAD_DATA
;
575 if (index
== 0 && (packet
[0] & 0xfc) == 0) {
576 /* call packet process for reporting finger leave. */
577 cypress_process_packet(psmouse
, 1);
578 return PSMOUSE_FULL_PACKET
;
582 * Perform validation (and adjust packet size) based only on the
583 * first byte; allow all further bytes through.
586 return PSMOUSE_GOOD_DATA
;
589 * If absolute/relative mode bit has not been set yet, just pass
592 if ((cytp
->mode
& CYTP_BIT_ABS_REL_MASK
) == 0)
593 return PSMOUSE_GOOD_DATA
;
595 if ((packet
[0] & 0x08) == 0x08)
596 return PSMOUSE_BAD_DATA
;
598 contact_cnt
= cypress_get_finger_count(packet
[0]);
599 if (cytp
->mode
& CYTP_BIT_ABS_NO_PRESSURE
)
600 cypress_set_packet_size(psmouse
, contact_cnt
== 2 ? 7 : 4);
602 cypress_set_packet_size(psmouse
, contact_cnt
== 2 ? 8 : 5);
604 return PSMOUSE_GOOD_DATA
;
607 static psmouse_ret_t
cypress_protocol_handler(struct psmouse
*psmouse
)
609 struct cytp_data
*cytp
= psmouse
->private;
611 if (psmouse
->pktcnt
>= cytp
->pkt_size
) {
612 cypress_process_packet(psmouse
, 0);
613 return PSMOUSE_FULL_PACKET
;
616 return cypress_validate_byte(psmouse
);
619 static void cypress_set_rate(struct psmouse
*psmouse
, unsigned int rate
)
621 struct cytp_data
*cytp
= psmouse
->private;
625 cytp
->mode
|= CYTP_BIT_HIGH_RATE
;
628 cytp
->mode
&= ~CYTP_BIT_HIGH_RATE
;
631 ps2_command(&psmouse
->ps2dev
, (unsigned char *)&psmouse
->rate
,
632 PSMOUSE_CMD_SETRATE
);
635 static void cypress_disconnect(struct psmouse
*psmouse
)
637 cypress_reset(psmouse
);
638 kfree(psmouse
->private);
639 psmouse
->private = NULL
;
642 static int cypress_reconnect(struct psmouse
*psmouse
)
644 int tries
= CYTP_PS2_CMD_TRIES
;
648 cypress_reset(psmouse
);
649 rc
= cypress_detect(psmouse
, false);
650 } while (rc
&& (--tries
> 0));
653 psmouse_err(psmouse
, "Reconnect: unable to detect trackpad.\n");
657 if (cypress_set_absolute_mode(psmouse
)) {
658 psmouse_err(psmouse
, "Reconnect: Unable to initialize Cypress absolute mode.\n");
665 int cypress_init(struct psmouse
*psmouse
)
667 struct cytp_data
*cytp
;
669 cytp
= kzalloc(sizeof(struct cytp_data
), GFP_KERNEL
);
673 psmouse
->private = cytp
;
674 psmouse
->pktsize
= 8;
676 cypress_reset(psmouse
);
678 if (cypress_query_hardware(psmouse
)) {
679 psmouse_err(psmouse
, "Unable to query Trackpad hardware.\n");
683 if (cypress_set_absolute_mode(psmouse
)) {
684 psmouse_err(psmouse
, "init: Unable to initialize Cypress absolute mode.\n");
688 if (cypress_set_input_params(psmouse
->dev
, cytp
) < 0) {
689 psmouse_err(psmouse
, "init: Unable to set input params.\n");
694 psmouse
->protocol_handler
= cypress_protocol_handler
;
695 psmouse
->set_rate
= cypress_set_rate
;
696 psmouse
->disconnect
= cypress_disconnect
;
697 psmouse
->reconnect
= cypress_reconnect
;
698 psmouse
->cleanup
= cypress_reset
;
699 psmouse
->resync_time
= 0;
705 * Reset Cypress Trackpad as a standard mouse. Then
706 * let psmouse driver commmunicating with it as default PS2 mouse.
708 cypress_reset(psmouse
);
710 psmouse
->private = NULL
;
716 bool cypress_supported(void)