xref: /openbmc/linux/drivers/input/mouse/synaptics.c (revision 83ba9ea8a04b72dfee2515428c15e7414ba4fc61)
1 /*
2  * Synaptics TouchPad PS/2 mouse driver
3  *
4  *   2003 Dmitry Torokhov <dtor@mail.ru>
5  *     Added support for pass-through port. Special thanks to Peter Berg Larsen
6  *     for explaining various Synaptics quirks.
7  *
8  *   2003 Peter Osterlund <petero2@telia.com>
9  *     Ported to 2.5 input device infrastructure.
10  *
11  *   Copyright (C) 2001 Stefan Gmeiner <riddlebox@freesurf.ch>
12  *     start merging tpconfig and gpm code to a xfree-input module
13  *     adding some changes and extensions (ex. 3rd and 4th button)
14  *
15  *   Copyright (c) 1997 C. Scott Ananian <cananian@alumni.priceton.edu>
16  *   Copyright (c) 1998-2000 Bruce Kalk <kall@compass.com>
17  *     code for the special synaptics commands (from the tpconfig-source)
18  *
19  * This program is free software; you can redistribute it and/or modify it
20  * under the terms of the GNU General Public License version 2 as published by
21  * the Free Software Foundation.
22  *
23  * Trademarks are the property of their respective owners.
24  */
25 
26 #include <linux/module.h>
27 #include <linux/dmi.h>
28 #include <linux/input.h>
29 #include <linux/serio.h>
30 #include <linux/libps2.h>
31 #include <linux/slab.h>
32 #include "psmouse.h"
33 #include "synaptics.h"
34 
35 /*
36  * The x/y limits are taken from the Synaptics TouchPad interfacing Guide,
37  * section 2.3.2, which says that they should be valid regardless of the
38  * actual size of the sensor.
39  * Note that newer firmware allows querying device for maximum useable
40  * coordinates.
41  */
42 #define XMIN_NOMINAL 1472
43 #define XMAX_NOMINAL 5472
44 #define YMIN_NOMINAL 1408
45 #define YMAX_NOMINAL 4448
46 
47 
48 /*****************************************************************************
49  *	Stuff we need even when we do not want native Synaptics support
50  ****************************************************************************/
51 
52 /*
53  * Set the synaptics touchpad mode byte by special commands
54  */
55 static int synaptics_mode_cmd(struct psmouse *psmouse, unsigned char mode)
56 {
57 	unsigned char param[1];
58 
59 	if (psmouse_sliced_command(psmouse, mode))
60 		return -1;
61 	param[0] = SYN_PS_SET_MODE2;
62 	if (ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_SETRATE))
63 		return -1;
64 	return 0;
65 }
66 
67 int synaptics_detect(struct psmouse *psmouse, bool set_properties)
68 {
69 	struct ps2dev *ps2dev = &psmouse->ps2dev;
70 	unsigned char param[4];
71 
72 	param[0] = 0;
73 
74 	ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
75 	ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
76 	ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
77 	ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
78 	ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO);
79 
80 	if (param[1] != 0x47)
81 		return -ENODEV;
82 
83 	if (set_properties) {
84 		psmouse->vendor = "Synaptics";
85 		psmouse->name = "TouchPad";
86 	}
87 
88 	return 0;
89 }
90 
91 void synaptics_reset(struct psmouse *psmouse)
92 {
93 	/* reset touchpad back to relative mode, gestures enabled */
94 	synaptics_mode_cmd(psmouse, 0);
95 }
96 
97 #ifdef CONFIG_MOUSE_PS2_SYNAPTICS
98 
99 /*****************************************************************************
100  *	Synaptics communications functions
101  ****************************************************************************/
102 
103 /*
104  * Send a command to the synpatics touchpad by special commands
105  */
106 static int synaptics_send_cmd(struct psmouse *psmouse, unsigned char c, unsigned char *param)
107 {
108 	if (psmouse_sliced_command(psmouse, c))
109 		return -1;
110 	if (ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_GETINFO))
111 		return -1;
112 	return 0;
113 }
114 
115 /*
116  * Read the model-id bytes from the touchpad
117  * see also SYN_MODEL_* macros
118  */
119 static int synaptics_model_id(struct psmouse *psmouse)
120 {
121 	struct synaptics_data *priv = psmouse->private;
122 	unsigned char mi[3];
123 
124 	if (synaptics_send_cmd(psmouse, SYN_QUE_MODEL, mi))
125 		return -1;
126 	priv->model_id = (mi[0]<<16) | (mi[1]<<8) | mi[2];
127 	return 0;
128 }
129 
130 /*
131  * Read the capability-bits from the touchpad
132  * see also the SYN_CAP_* macros
133  */
134 static int synaptics_capability(struct psmouse *psmouse)
135 {
136 	struct synaptics_data *priv = psmouse->private;
137 	unsigned char cap[3];
138 
139 	if (synaptics_send_cmd(psmouse, SYN_QUE_CAPABILITIES, cap))
140 		return -1;
141 	priv->capabilities = (cap[0] << 16) | (cap[1] << 8) | cap[2];
142 	priv->ext_cap = priv->ext_cap_0c = 0;
143 
144 	if (!SYN_CAP_VALID(priv->capabilities))
145 		return -1;
146 
147 	/*
148 	 * Unless capExtended is set the rest of the flags should be ignored
149 	 */
150 	if (!SYN_CAP_EXTENDED(priv->capabilities))
151 		priv->capabilities = 0;
152 
153 	if (SYN_EXT_CAP_REQUESTS(priv->capabilities) >= 1) {
154 		if (synaptics_send_cmd(psmouse, SYN_QUE_EXT_CAPAB, cap)) {
155 			printk(KERN_ERR "Synaptics claims to have extended capabilities,"
156 			       " but I'm not able to read them.\n");
157 		} else {
158 			priv->ext_cap = (cap[0] << 16) | (cap[1] << 8) | cap[2];
159 
160 			/*
161 			 * if nExtBtn is greater than 8 it should be considered
162 			 * invalid and treated as 0
163 			 */
164 			if (SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap) > 8)
165 				priv->ext_cap &= 0xff0fff;
166 		}
167 	}
168 
169 	if (SYN_EXT_CAP_REQUESTS(priv->capabilities) >= 4) {
170 		if (synaptics_send_cmd(psmouse, SYN_QUE_EXT_CAPAB_0C, cap)) {
171 			printk(KERN_ERR "Synaptics claims to have extended capability 0x0c,"
172 			       " but I'm not able to read it.\n");
173 		} else {
174 			priv->ext_cap_0c = (cap[0] << 16) | (cap[1] << 8) | cap[2];
175 		}
176 	}
177 
178 	return 0;
179 }
180 
181 /*
182  * Identify Touchpad
183  * See also the SYN_ID_* macros
184  */
185 static int synaptics_identify(struct psmouse *psmouse)
186 {
187 	struct synaptics_data *priv = psmouse->private;
188 	unsigned char id[3];
189 
190 	if (synaptics_send_cmd(psmouse, SYN_QUE_IDENTIFY, id))
191 		return -1;
192 	priv->identity = (id[0]<<16) | (id[1]<<8) | id[2];
193 	if (SYN_ID_IS_SYNAPTICS(priv->identity))
194 		return 0;
195 	return -1;
196 }
197 
198 /*
199  * Read touchpad resolution and maximum reported coordinates
200  * Resolution is left zero if touchpad does not support the query
201  */
202 static int synaptics_resolution(struct psmouse *psmouse)
203 {
204 	struct synaptics_data *priv = psmouse->private;
205 	unsigned char res[3];
206 	unsigned char max[3];
207 
208 	if (SYN_ID_MAJOR(priv->identity) < 4)
209 
210 	if (synaptics_send_cmd(psmouse, SYN_QUE_RESOLUTION, res) == 0) {
211 		if (res[0] != 0 && (res[1] & 0x80) && res[2] != 0) {
212 			priv->x_res = res[0]; /* x resolution in units/mm */
213 			priv->y_res = res[2]; /* y resolution in units/mm */
214 		}
215 	}
216 
217 	if (SYN_EXT_CAP_REQUESTS(priv->capabilities) >= 5 &&
218 	    SYN_CAP_MAX_DIMENSIONS(priv->ext_cap_0c)) {
219 		if (synaptics_send_cmd(psmouse, SYN_QUE_EXT_DIMENSIONS, max)) {
220 			printk(KERN_ERR "Synaptics claims to have dimensions query,"
221 			       " but I'm not able to read it.\n");
222 		} else {
223 			priv->x_max = (max[0] << 5) | ((max[1] & 0x0f) << 1);
224 			priv->y_max = (max[2] << 5) | ((max[1] & 0xf0) >> 3);
225 		}
226 	}
227 
228 	return 0;
229 }
230 
231 static int synaptics_query_hardware(struct psmouse *psmouse)
232 {
233 	if (synaptics_identify(psmouse))
234 		return -1;
235 	if (synaptics_model_id(psmouse))
236 		return -1;
237 	if (synaptics_capability(psmouse))
238 		return -1;
239 	if (synaptics_resolution(psmouse))
240 		return -1;
241 
242 	return 0;
243 }
244 
245 static int synaptics_set_absolute_mode(struct psmouse *psmouse)
246 {
247 	struct synaptics_data *priv = psmouse->private;
248 
249 	priv->mode = SYN_BIT_ABSOLUTE_MODE;
250 	if (SYN_ID_MAJOR(priv->identity) >= 4)
251 		priv->mode |= SYN_BIT_DISABLE_GESTURE;
252 	if (SYN_CAP_EXTENDED(priv->capabilities))
253 		priv->mode |= SYN_BIT_W_MODE;
254 
255 	if (synaptics_mode_cmd(psmouse, priv->mode))
256 		return -1;
257 
258 	return 0;
259 }
260 
261 static void synaptics_set_rate(struct psmouse *psmouse, unsigned int rate)
262 {
263 	struct synaptics_data *priv = psmouse->private;
264 
265 	if (rate >= 80) {
266 		priv->mode |= SYN_BIT_HIGH_RATE;
267 		psmouse->rate = 80;
268 	} else {
269 		priv->mode &= ~SYN_BIT_HIGH_RATE;
270 		psmouse->rate = 40;
271 	}
272 
273 	synaptics_mode_cmd(psmouse, priv->mode);
274 }
275 
276 /*****************************************************************************
277  *	Synaptics pass-through PS/2 port support
278  ****************************************************************************/
279 static int synaptics_pt_write(struct serio *serio, unsigned char c)
280 {
281 	struct psmouse *parent = serio_get_drvdata(serio->parent);
282 	char rate_param = SYN_PS_CLIENT_CMD; /* indicates that we want pass-through port */
283 
284 	if (psmouse_sliced_command(parent, c))
285 		return -1;
286 	if (ps2_command(&parent->ps2dev, &rate_param, PSMOUSE_CMD_SETRATE))
287 		return -1;
288 	return 0;
289 }
290 
291 static inline int synaptics_is_pt_packet(unsigned char *buf)
292 {
293 	return (buf[0] & 0xFC) == 0x84 && (buf[3] & 0xCC) == 0xC4;
294 }
295 
296 static void synaptics_pass_pt_packet(struct serio *ptport, unsigned char *packet)
297 {
298 	struct psmouse *child = serio_get_drvdata(ptport);
299 
300 	if (child && child->state == PSMOUSE_ACTIVATED) {
301 		serio_interrupt(ptport, packet[1], 0);
302 		serio_interrupt(ptport, packet[4], 0);
303 		serio_interrupt(ptport, packet[5], 0);
304 		if (child->pktsize == 4)
305 			serio_interrupt(ptport, packet[2], 0);
306 	} else
307 		serio_interrupt(ptport, packet[1], 0);
308 }
309 
310 static void synaptics_pt_activate(struct psmouse *psmouse)
311 {
312 	struct serio *ptport = psmouse->ps2dev.serio->child;
313 	struct psmouse *child = serio_get_drvdata(ptport);
314 	struct synaptics_data *priv = psmouse->private;
315 
316 	/* adjust the touchpad to child's choice of protocol */
317 	if (child) {
318 		if (child->pktsize == 4)
319 			priv->mode |= SYN_BIT_FOUR_BYTE_CLIENT;
320 		else
321 			priv->mode &= ~SYN_BIT_FOUR_BYTE_CLIENT;
322 
323 		if (synaptics_mode_cmd(psmouse, priv->mode))
324 			printk(KERN_INFO "synaptics: failed to switch guest protocol\n");
325 	}
326 }
327 
328 static void synaptics_pt_create(struct psmouse *psmouse)
329 {
330 	struct serio *serio;
331 
332 	serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
333 	if (!serio) {
334 		printk(KERN_ERR "synaptics: not enough memory to allocate pass-through port\n");
335 		return;
336 	}
337 
338 	serio->id.type = SERIO_PS_PSTHRU;
339 	strlcpy(serio->name, "Synaptics pass-through", sizeof(serio->name));
340 	strlcpy(serio->phys, "synaptics-pt/serio0", sizeof(serio->name));
341 	serio->write = synaptics_pt_write;
342 	serio->parent = psmouse->ps2dev.serio;
343 
344 	psmouse->pt_activate = synaptics_pt_activate;
345 
346 	printk(KERN_INFO "serio: %s port at %s\n", serio->name, psmouse->phys);
347 	serio_register_port(serio);
348 }
349 
350 /*****************************************************************************
351  *	Functions to interpret the absolute mode packets
352  ****************************************************************************/
353 
354 static void synaptics_parse_hw_state(unsigned char buf[], struct synaptics_data *priv, struct synaptics_hw_state *hw)
355 {
356 	memset(hw, 0, sizeof(struct synaptics_hw_state));
357 
358 	if (SYN_MODEL_NEWABS(priv->model_id)) {
359 		hw->x = (((buf[3] & 0x10) << 8) |
360 			 ((buf[1] & 0x0f) << 8) |
361 			 buf[4]);
362 		hw->y = (((buf[3] & 0x20) << 7) |
363 			 ((buf[1] & 0xf0) << 4) |
364 			 buf[5]);
365 
366 		hw->z = buf[2];
367 		hw->w = (((buf[0] & 0x30) >> 2) |
368 			 ((buf[0] & 0x04) >> 1) |
369 			 ((buf[3] & 0x04) >> 2));
370 
371 		hw->left  = (buf[0] & 0x01) ? 1 : 0;
372 		hw->right = (buf[0] & 0x02) ? 1 : 0;
373 
374 		if (SYN_CAP_CLICKPAD(priv->ext_cap_0c)) {
375 			/*
376 			 * Clickpad's button is transmitted as middle button,
377 			 * however, since it is primary button, we will report
378 			 * it as BTN_LEFT.
379 			 */
380 			hw->left = ((buf[0] ^ buf[3]) & 0x01) ? 1 : 0;
381 
382 		} else if (SYN_CAP_MIDDLE_BUTTON(priv->capabilities)) {
383 			hw->middle = ((buf[0] ^ buf[3]) & 0x01) ? 1 : 0;
384 			if (hw->w == 2)
385 				hw->scroll = (signed char)(buf[1]);
386 		}
387 
388 		if (SYN_CAP_FOUR_BUTTON(priv->capabilities)) {
389 			hw->up   = ((buf[0] ^ buf[3]) & 0x01) ? 1 : 0;
390 			hw->down = ((buf[0] ^ buf[3]) & 0x02) ? 1 : 0;
391 		}
392 
393 		if (SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap) &&
394 		    ((buf[0] ^ buf[3]) & 0x02)) {
395 			switch (SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap) & ~0x01) {
396 			default:
397 				/*
398 				 * if nExtBtn is greater than 8 it should be
399 				 * considered invalid and treated as 0
400 				 */
401 				break;
402 			case 8:
403 				hw->ext_buttons |= ((buf[5] & 0x08)) ? 0x80 : 0;
404 				hw->ext_buttons |= ((buf[4] & 0x08)) ? 0x40 : 0;
405 			case 6:
406 				hw->ext_buttons |= ((buf[5] & 0x04)) ? 0x20 : 0;
407 				hw->ext_buttons |= ((buf[4] & 0x04)) ? 0x10 : 0;
408 			case 4:
409 				hw->ext_buttons |= ((buf[5] & 0x02)) ? 0x08 : 0;
410 				hw->ext_buttons |= ((buf[4] & 0x02)) ? 0x04 : 0;
411 			case 2:
412 				hw->ext_buttons |= ((buf[5] & 0x01)) ? 0x02 : 0;
413 				hw->ext_buttons |= ((buf[4] & 0x01)) ? 0x01 : 0;
414 			}
415 		}
416 	} else {
417 		hw->x = (((buf[1] & 0x1f) << 8) | buf[2]);
418 		hw->y = (((buf[4] & 0x1f) << 8) | buf[5]);
419 
420 		hw->z = (((buf[0] & 0x30) << 2) | (buf[3] & 0x3F));
421 		hw->w = (((buf[1] & 0x80) >> 4) | ((buf[0] & 0x04) >> 1));
422 
423 		hw->left  = (buf[0] & 0x01) ? 1 : 0;
424 		hw->right = (buf[0] & 0x02) ? 1 : 0;
425 	}
426 }
427 
428 /*
429  *  called for each full received packet from the touchpad
430  */
431 static void synaptics_process_packet(struct psmouse *psmouse)
432 {
433 	struct input_dev *dev = psmouse->dev;
434 	struct synaptics_data *priv = psmouse->private;
435 	struct synaptics_hw_state hw;
436 	int num_fingers;
437 	int finger_width;
438 	int i;
439 
440 	synaptics_parse_hw_state(psmouse->packet, priv, &hw);
441 
442 	if (hw.scroll) {
443 		priv->scroll += hw.scroll;
444 
445 		while (priv->scroll >= 4) {
446 			input_report_key(dev, BTN_BACK, !hw.down);
447 			input_sync(dev);
448 			input_report_key(dev, BTN_BACK, hw.down);
449 			input_sync(dev);
450 			priv->scroll -= 4;
451 		}
452 		while (priv->scroll <= -4) {
453 			input_report_key(dev, BTN_FORWARD, !hw.up);
454 			input_sync(dev);
455 			input_report_key(dev, BTN_FORWARD, hw.up);
456 			input_sync(dev);
457 			priv->scroll += 4;
458 		}
459 		return;
460 	}
461 
462 	if (hw.z > 0) {
463 		num_fingers = 1;
464 		finger_width = 5;
465 		if (SYN_CAP_EXTENDED(priv->capabilities)) {
466 			switch (hw.w) {
467 			case 0 ... 1:
468 				if (SYN_CAP_MULTIFINGER(priv->capabilities))
469 					num_fingers = hw.w + 2;
470 				break;
471 			case 2:
472 				if (SYN_MODEL_PEN(priv->model_id))
473 					;   /* Nothing, treat a pen as a single finger */
474 				break;
475 			case 4 ... 15:
476 				if (SYN_CAP_PALMDETECT(priv->capabilities))
477 					finger_width = hw.w;
478 				break;
479 			}
480 		}
481 	} else {
482 		num_fingers = 0;
483 		finger_width = 0;
484 	}
485 
486 	/* Post events
487 	 * BTN_TOUCH has to be first as mousedev relies on it when doing
488 	 * absolute -> relative conversion
489 	 */
490 	if (hw.z > 30) input_report_key(dev, BTN_TOUCH, 1);
491 	if (hw.z < 25) input_report_key(dev, BTN_TOUCH, 0);
492 
493 	if (hw.z > 0) {
494 		input_report_abs(dev, ABS_X, hw.x);
495 		input_report_abs(dev, ABS_Y, YMAX_NOMINAL + YMIN_NOMINAL - hw.y);
496 	}
497 	input_report_abs(dev, ABS_PRESSURE, hw.z);
498 
499 	input_report_abs(dev, ABS_TOOL_WIDTH, finger_width);
500 	input_report_key(dev, BTN_TOOL_FINGER, num_fingers == 1);
501 	input_report_key(dev, BTN_LEFT, hw.left);
502 	input_report_key(dev, BTN_RIGHT, hw.right);
503 
504 	if (SYN_CAP_MULTIFINGER(priv->capabilities)) {
505 		input_report_key(dev, BTN_TOOL_DOUBLETAP, num_fingers == 2);
506 		input_report_key(dev, BTN_TOOL_TRIPLETAP, num_fingers == 3);
507 	}
508 
509 	if (SYN_CAP_MIDDLE_BUTTON(priv->capabilities))
510 		input_report_key(dev, BTN_MIDDLE, hw.middle);
511 
512 	if (SYN_CAP_FOUR_BUTTON(priv->capabilities)) {
513 		input_report_key(dev, BTN_FORWARD, hw.up);
514 		input_report_key(dev, BTN_BACK, hw.down);
515 	}
516 
517 	for (i = 0; i < SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap); i++)
518 		input_report_key(dev, BTN_0 + i, hw.ext_buttons & (1 << i));
519 
520 	input_sync(dev);
521 }
522 
523 static int synaptics_validate_byte(unsigned char packet[], int idx, unsigned char pkt_type)
524 {
525 	static const unsigned char newabs_mask[]	= { 0xC8, 0x00, 0x00, 0xC8, 0x00 };
526 	static const unsigned char newabs_rel_mask[]	= { 0xC0, 0x00, 0x00, 0xC0, 0x00 };
527 	static const unsigned char newabs_rslt[]	= { 0x80, 0x00, 0x00, 0xC0, 0x00 };
528 	static const unsigned char oldabs_mask[]	= { 0xC0, 0x60, 0x00, 0xC0, 0x60 };
529 	static const unsigned char oldabs_rslt[]	= { 0xC0, 0x00, 0x00, 0x80, 0x00 };
530 
531 	if (idx < 0 || idx > 4)
532 		return 0;
533 
534 	switch (pkt_type) {
535 		case SYN_NEWABS:
536 		case SYN_NEWABS_RELAXED:
537 			return (packet[idx] & newabs_rel_mask[idx]) == newabs_rslt[idx];
538 
539 		case SYN_NEWABS_STRICT:
540 			return (packet[idx] & newabs_mask[idx]) == newabs_rslt[idx];
541 
542 		case SYN_OLDABS:
543 			return (packet[idx] & oldabs_mask[idx]) == oldabs_rslt[idx];
544 
545 		default:
546 			printk(KERN_ERR "synaptics: unknown packet type %d\n", pkt_type);
547 			return 0;
548 	}
549 }
550 
551 static unsigned char synaptics_detect_pkt_type(struct psmouse *psmouse)
552 {
553 	int i;
554 
555 	for (i = 0; i < 5; i++)
556 		if (!synaptics_validate_byte(psmouse->packet, i, SYN_NEWABS_STRICT)) {
557 			printk(KERN_INFO "synaptics: using relaxed packet validation\n");
558 			return SYN_NEWABS_RELAXED;
559 		}
560 
561 	return SYN_NEWABS_STRICT;
562 }
563 
564 static psmouse_ret_t synaptics_process_byte(struct psmouse *psmouse)
565 {
566 	struct synaptics_data *priv = psmouse->private;
567 
568 	if (psmouse->pktcnt >= 6) { /* Full packet received */
569 		if (unlikely(priv->pkt_type == SYN_NEWABS))
570 			priv->pkt_type = synaptics_detect_pkt_type(psmouse);
571 
572 		if (SYN_CAP_PASS_THROUGH(priv->capabilities) && synaptics_is_pt_packet(psmouse->packet)) {
573 			if (psmouse->ps2dev.serio->child)
574 				synaptics_pass_pt_packet(psmouse->ps2dev.serio->child, psmouse->packet);
575 		} else
576 			synaptics_process_packet(psmouse);
577 
578 		return PSMOUSE_FULL_PACKET;
579 	}
580 
581 	return synaptics_validate_byte(psmouse->packet, psmouse->pktcnt - 1, priv->pkt_type) ?
582 		PSMOUSE_GOOD_DATA : PSMOUSE_BAD_DATA;
583 }
584 
585 /*****************************************************************************
586  *	Driver initialization/cleanup functions
587  ****************************************************************************/
588 static void set_input_params(struct input_dev *dev, struct synaptics_data *priv)
589 {
590 	int i;
591 
592 	__set_bit(EV_ABS, dev->evbit);
593 	input_set_abs_params(dev, ABS_X,
594 			     XMIN_NOMINAL, priv->x_max ?: XMAX_NOMINAL, 0, 0);
595 	input_set_abs_params(dev, ABS_Y,
596 			     YMIN_NOMINAL, priv->y_max ?: YMAX_NOMINAL, 0, 0);
597 	input_set_abs_params(dev, ABS_PRESSURE, 0, 255, 0, 0);
598 	__set_bit(ABS_TOOL_WIDTH, dev->absbit);
599 
600 	__set_bit(EV_KEY, dev->evbit);
601 	__set_bit(BTN_TOUCH, dev->keybit);
602 	__set_bit(BTN_TOOL_FINGER, dev->keybit);
603 	__set_bit(BTN_LEFT, dev->keybit);
604 	__set_bit(BTN_RIGHT, dev->keybit);
605 
606 	if (SYN_CAP_MULTIFINGER(priv->capabilities)) {
607 		__set_bit(BTN_TOOL_DOUBLETAP, dev->keybit);
608 		__set_bit(BTN_TOOL_TRIPLETAP, dev->keybit);
609 	}
610 
611 	if (SYN_CAP_MIDDLE_BUTTON(priv->capabilities))
612 		__set_bit(BTN_MIDDLE, dev->keybit);
613 
614 	if (SYN_CAP_FOUR_BUTTON(priv->capabilities) ||
615 	    SYN_CAP_MIDDLE_BUTTON(priv->capabilities)) {
616 		__set_bit(BTN_FORWARD, dev->keybit);
617 		__set_bit(BTN_BACK, dev->keybit);
618 	}
619 
620 	for (i = 0; i < SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap); i++)
621 		__set_bit(BTN_0 + i, dev->keybit);
622 
623 	__clear_bit(EV_REL, dev->evbit);
624 	__clear_bit(REL_X, dev->relbit);
625 	__clear_bit(REL_Y, dev->relbit);
626 
627 	dev->absres[ABS_X] = priv->x_res;
628 	dev->absres[ABS_Y] = priv->y_res;
629 
630 	if (SYN_CAP_CLICKPAD(priv->ext_cap_0c)) {
631 		/* Clickpads report only left button */
632 		__clear_bit(BTN_RIGHT, dev->keybit);
633 		__clear_bit(BTN_MIDDLE, dev->keybit);
634 	}
635 }
636 
637 static void synaptics_disconnect(struct psmouse *psmouse)
638 {
639 	synaptics_reset(psmouse);
640 	kfree(psmouse->private);
641 	psmouse->private = NULL;
642 }
643 
644 static int synaptics_reconnect(struct psmouse *psmouse)
645 {
646 	struct synaptics_data *priv = psmouse->private;
647 	struct synaptics_data old_priv = *priv;
648 
649 	psmouse_reset(psmouse);
650 
651 	if (synaptics_detect(psmouse, 0))
652 		return -1;
653 
654 	if (synaptics_query_hardware(psmouse)) {
655 		printk(KERN_ERR "Unable to query Synaptics hardware.\n");
656 		return -1;
657 	}
658 
659 	if (old_priv.identity != priv->identity ||
660 	    old_priv.model_id != priv->model_id ||
661 	    old_priv.capabilities != priv->capabilities ||
662 	    old_priv.ext_cap != priv->ext_cap)
663 		return -1;
664 
665 	if (synaptics_set_absolute_mode(psmouse)) {
666 		printk(KERN_ERR "Unable to initialize Synaptics hardware.\n");
667 		return -1;
668 	}
669 
670 	return 0;
671 }
672 
673 static bool impaired_toshiba_kbc;
674 
675 static const struct dmi_system_id __initconst toshiba_dmi_table[] = {
676 #if defined(CONFIG_DMI) && defined(CONFIG_X86)
677 	{
678 		/* Toshiba Satellite */
679 		.matches = {
680 			DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
681 			DMI_MATCH(DMI_PRODUCT_NAME, "Satellite"),
682 		},
683 	},
684 	{
685 		/* Toshiba Dynabook */
686 		.matches = {
687 			DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
688 			DMI_MATCH(DMI_PRODUCT_NAME, "dynabook"),
689 		},
690 	},
691 	{
692 		/* Toshiba Portege M300 */
693 		.matches = {
694 			DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
695 			DMI_MATCH(DMI_PRODUCT_NAME, "PORTEGE M300"),
696 		},
697 
698 	},
699 	{
700 		/* Toshiba Portege M300 */
701 		.matches = {
702 			DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
703 			DMI_MATCH(DMI_PRODUCT_NAME, "Portable PC"),
704 			DMI_MATCH(DMI_PRODUCT_VERSION, "Version 1.0"),
705 		},
706 
707 	},
708 	{ }
709 #endif
710 };
711 
712 void __init synaptics_module_init(void)
713 {
714 	impaired_toshiba_kbc = dmi_check_system(toshiba_dmi_table);
715 }
716 
717 int synaptics_init(struct psmouse *psmouse)
718 {
719 	struct synaptics_data *priv;
720 
721 	psmouse->private = priv = kzalloc(sizeof(struct synaptics_data), GFP_KERNEL);
722 	if (!priv)
723 		return -1;
724 
725 	psmouse_reset(psmouse);
726 
727 	if (synaptics_query_hardware(psmouse)) {
728 		printk(KERN_ERR "Unable to query Synaptics hardware.\n");
729 		goto init_fail;
730 	}
731 
732 	if (synaptics_set_absolute_mode(psmouse)) {
733 		printk(KERN_ERR "Unable to initialize Synaptics hardware.\n");
734 		goto init_fail;
735 	}
736 
737 	priv->pkt_type = SYN_MODEL_NEWABS(priv->model_id) ? SYN_NEWABS : SYN_OLDABS;
738 
739 	printk(KERN_INFO "Synaptics Touchpad, model: %ld, fw: %ld.%ld, id: %#lx, caps: %#lx/%#lx/%#lx\n",
740 		SYN_ID_MODEL(priv->identity),
741 		SYN_ID_MAJOR(priv->identity), SYN_ID_MINOR(priv->identity),
742 		priv->model_id, priv->capabilities, priv->ext_cap, priv->ext_cap_0c);
743 
744 	set_input_params(psmouse->dev, priv);
745 
746 	/*
747 	 * Encode touchpad model so that it can be used to set
748 	 * input device->id.version and be visible to userspace.
749 	 * Because version is __u16 we have to drop something.
750 	 * Hardware info bits seem to be good candidates as they
751 	 * are documented to be for Synaptics corp. internal use.
752 	 */
753 	psmouse->model = ((priv->model_id & 0x00ff0000) >> 8) |
754 			  (priv->model_id & 0x000000ff);
755 
756 	psmouse->protocol_handler = synaptics_process_byte;
757 	psmouse->set_rate = synaptics_set_rate;
758 	psmouse->disconnect = synaptics_disconnect;
759 	psmouse->reconnect = synaptics_reconnect;
760 	psmouse->cleanup = synaptics_reset;
761 	psmouse->pktsize = 6;
762 	/* Synaptics can usually stay in sync without extra help */
763 	psmouse->resync_time = 0;
764 
765 	if (SYN_CAP_PASS_THROUGH(priv->capabilities))
766 		synaptics_pt_create(psmouse);
767 
768 	/*
769 	 * Toshiba's KBC seems to have trouble handling data from
770 	 * Synaptics as full rate, switch to lower rate which is roughly
771 	 * thye same as rate of standard PS/2 mouse.
772 	 */
773 	if (psmouse->rate >= 80 && impaired_toshiba_kbc) {
774 		printk(KERN_INFO "synaptics: Toshiba %s detected, limiting rate to 40pps.\n",
775 			dmi_get_system_info(DMI_PRODUCT_NAME));
776 		psmouse->rate = 40;
777 	}
778 
779 	return 0;
780 
781  init_fail:
782 	kfree(priv);
783 	return -1;
784 }
785 
786 bool synaptics_supported(void)
787 {
788 	return true;
789 }
790 
791 #else /* CONFIG_MOUSE_PS2_SYNAPTICS */
792 
793 void __init synaptics_module_init(void)
794 {
795 }
796 
797 int synaptics_init(struct psmouse *psmouse)
798 {
799 	return -ENOSYS;
800 }
801 
802 bool synaptics_supported(void)
803 {
804 	return false;
805 }
806 
807 #endif /* CONFIG_MOUSE_PS2_SYNAPTICS */
808 
809