PageRenderTime 55ms CodeModel.GetById 16ms app.highlight 33ms RepoModel.GetById 1ms app.codeStats 0ms

/drivers/input/mouse/synaptics.c

https://bitbucket.org/evzijst/gittest
C | 700 lines | 500 code | 116 blank | 84 comment | 109 complexity | d5d499576292ff7eeb66ee9099144715 MD5 | raw file
  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/input.h>
 28#include <linux/serio.h>
 29#include <linux/libps2.h>
 30#include "psmouse.h"
 31#include "synaptics.h"
 32
 33/*
 34 * The x/y limits are taken from the Synaptics TouchPad interfacing Guide,
 35 * section 2.3.2, which says that they should be valid regardless of the
 36 * actual size of the sensor.
 37 */
 38#define XMIN_NOMINAL 1472
 39#define XMAX_NOMINAL 5472
 40#define YMIN_NOMINAL 1408
 41#define YMAX_NOMINAL 4448
 42
 43/*****************************************************************************
 44 *	Synaptics communications functions
 45 ****************************************************************************/
 46
 47/*
 48 * Send a command to the synpatics touchpad by special commands
 49 */
 50static int synaptics_send_cmd(struct psmouse *psmouse, unsigned char c, unsigned char *param)
 51{
 52	if (psmouse_sliced_command(psmouse, c))
 53		return -1;
 54	if (ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_GETINFO))
 55		return -1;
 56	return 0;
 57}
 58
 59/*
 60 * Set the synaptics touchpad mode byte by special commands
 61 */
 62static int synaptics_mode_cmd(struct psmouse *psmouse, unsigned char mode)
 63{
 64	unsigned char param[1];
 65
 66	if (psmouse_sliced_command(psmouse, mode))
 67		return -1;
 68	param[0] = SYN_PS_SET_MODE2;
 69	if (ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_SETRATE))
 70		return -1;
 71	return 0;
 72}
 73
 74/*
 75 * Read the model-id bytes from the touchpad
 76 * see also SYN_MODEL_* macros
 77 */
 78static int synaptics_model_id(struct psmouse *psmouse)
 79{
 80	struct synaptics_data *priv = psmouse->private;
 81	unsigned char mi[3];
 82
 83	if (synaptics_send_cmd(psmouse, SYN_QUE_MODEL, mi))
 84		return -1;
 85	priv->model_id = (mi[0]<<16) | (mi[1]<<8) | mi[2];
 86	return 0;
 87}
 88
 89/*
 90 * Read the capability-bits from the touchpad
 91 * see also the SYN_CAP_* macros
 92 */
 93static int synaptics_capability(struct psmouse *psmouse)
 94{
 95	struct synaptics_data *priv = psmouse->private;
 96	unsigned char cap[3];
 97
 98	if (synaptics_send_cmd(psmouse, SYN_QUE_CAPABILITIES, cap))
 99		return -1;
100	priv->capabilities = (cap[0] << 16) | (cap[1] << 8) | cap[2];
101	priv->ext_cap = 0;
102	if (!SYN_CAP_VALID(priv->capabilities))
103		return -1;
104
105	/*
106	 * Unless capExtended is set the rest of the flags should be ignored
107	 */
108	if (!SYN_CAP_EXTENDED(priv->capabilities))
109		priv->capabilities = 0;
110
111	if (SYN_EXT_CAP_REQUESTS(priv->capabilities) >= 1) {
112		if (synaptics_send_cmd(psmouse, SYN_QUE_EXT_CAPAB, cap)) {
113			printk(KERN_ERR "Synaptics claims to have extended capabilities,"
114			       " but I'm not able to read them.");
115		} else {
116			priv->ext_cap = (cap[0] << 16) | (cap[1] << 8) | cap[2];
117
118			/*
119			 * if nExtBtn is greater than 8 it should be considered
120			 * invalid and treated as 0
121			 */
122			if (SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap) > 8)
123				priv->ext_cap &= 0xff0fff;
124		}
125	}
126	return 0;
127}
128
129/*
130 * Identify Touchpad
131 * See also the SYN_ID_* macros
132 */
133static int synaptics_identify(struct psmouse *psmouse)
134{
135	struct synaptics_data *priv = psmouse->private;
136	unsigned char id[3];
137
138	if (synaptics_send_cmd(psmouse, SYN_QUE_IDENTIFY, id))
139		return -1;
140	priv->identity = (id[0]<<16) | (id[1]<<8) | id[2];
141	if (SYN_ID_IS_SYNAPTICS(priv->identity))
142		return 0;
143	return -1;
144}
145
146static void print_ident(struct synaptics_data *priv)
147{
148	printk(KERN_INFO "Synaptics Touchpad, model: %ld\n", SYN_ID_MODEL(priv->identity));
149	printk(KERN_INFO " Firmware: %ld.%ld\n", SYN_ID_MAJOR(priv->identity),
150	       SYN_ID_MINOR(priv->identity));
151	if (SYN_MODEL_ROT180(priv->model_id))
152		printk(KERN_INFO " 180 degree mounted touchpad\n");
153	if (SYN_MODEL_PORTRAIT(priv->model_id))
154		printk(KERN_INFO " portrait touchpad\n");
155	printk(KERN_INFO " Sensor: %ld\n", SYN_MODEL_SENSOR(priv->model_id));
156	if (SYN_MODEL_NEWABS(priv->model_id))
157		printk(KERN_INFO " new absolute packet format\n");
158	if (SYN_MODEL_PEN(priv->model_id))
159		printk(KERN_INFO " pen detection\n");
160
161	if (SYN_CAP_EXTENDED(priv->capabilities)) {
162		printk(KERN_INFO " Touchpad has extended capability bits\n");
163		if (SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap))
164			printk(KERN_INFO " -> %d multi-buttons, i.e. besides standard buttons\n",
165			       (int)(SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap)));
166		if (SYN_CAP_MIDDLE_BUTTON(priv->capabilities))
167			printk(KERN_INFO " -> middle button\n");
168		if (SYN_CAP_FOUR_BUTTON(priv->capabilities))
169			printk(KERN_INFO " -> four buttons\n");
170		if (SYN_CAP_MULTIFINGER(priv->capabilities))
171			printk(KERN_INFO " -> multifinger detection\n");
172		if (SYN_CAP_PALMDETECT(priv->capabilities))
173			printk(KERN_INFO " -> palm detection\n");
174		if (SYN_CAP_PASS_THROUGH(priv->capabilities))
175			printk(KERN_INFO " -> pass-through port\n");
176	}
177}
178
179static int synaptics_query_hardware(struct psmouse *psmouse)
180{
181	int retries = 0;
182
183	while ((retries++ < 3) && psmouse_reset(psmouse))
184		printk(KERN_ERR "synaptics reset failed\n");
185
186	if (synaptics_identify(psmouse))
187		return -1;
188	if (synaptics_model_id(psmouse))
189		return -1;
190	if (synaptics_capability(psmouse))
191		return -1;
192
193	return 0;
194}
195
196static int synaptics_set_absolute_mode(struct psmouse *psmouse)
197{
198	struct synaptics_data *priv = psmouse->private;
199
200	priv->mode = SYN_BIT_ABSOLUTE_MODE;
201	if (SYN_ID_MAJOR(priv->identity) >= 4)
202		priv->mode |= SYN_BIT_DISABLE_GESTURE;
203	if (SYN_CAP_EXTENDED(priv->capabilities))
204		priv->mode |= SYN_BIT_W_MODE;
205
206	if (synaptics_mode_cmd(psmouse, priv->mode))
207		return -1;
208
209	return 0;
210}
211
212static void synaptics_set_rate(struct psmouse *psmouse, unsigned int rate)
213{
214	struct synaptics_data *priv = psmouse->private;
215
216	if (rate >= 80) {
217		priv->mode |= SYN_BIT_HIGH_RATE;
218		psmouse->rate = 80;
219	} else {
220		priv->mode &= ~SYN_BIT_HIGH_RATE;
221		psmouse->rate = 40;
222	}
223
224	synaptics_mode_cmd(psmouse, priv->mode);
225}
226
227/*****************************************************************************
228 *	Synaptics pass-through PS/2 port support
229 ****************************************************************************/
230static int synaptics_pt_write(struct serio *serio, unsigned char c)
231{
232	struct psmouse *parent = serio_get_drvdata(serio->parent);
233	char rate_param = SYN_PS_CLIENT_CMD; /* indicates that we want pass-through port */
234
235	if (psmouse_sliced_command(parent, c))
236		return -1;
237	if (ps2_command(&parent->ps2dev, &rate_param, PSMOUSE_CMD_SETRATE))
238		return -1;
239	return 0;
240}
241
242static inline int synaptics_is_pt_packet(unsigned char *buf)
243{
244	return (buf[0] & 0xFC) == 0x84 && (buf[3] & 0xCC) == 0xC4;
245}
246
247static void synaptics_pass_pt_packet(struct serio *ptport, unsigned char *packet)
248{
249	struct psmouse *child = serio_get_drvdata(ptport);
250
251	if (child && child->state == PSMOUSE_ACTIVATED) {
252		serio_interrupt(ptport, packet[1], 0, NULL);
253		serio_interrupt(ptport, packet[4], 0, NULL);
254		serio_interrupt(ptport, packet[5], 0, NULL);
255		if (child->type >= PSMOUSE_GENPS)
256			serio_interrupt(ptport, packet[2], 0, NULL);
257	} else
258		serio_interrupt(ptport, packet[1], 0, NULL);
259}
260
261static void synaptics_pt_activate(struct psmouse *psmouse)
262{
263	struct serio *ptport = psmouse->ps2dev.serio->child;
264	struct psmouse *child = serio_get_drvdata(ptport);
265	struct synaptics_data *priv = psmouse->private;
266
267	/* adjust the touchpad to child's choice of protocol */
268	if (child) {
269		if (child->type >= PSMOUSE_GENPS)
270			priv->mode |= SYN_BIT_FOUR_BYTE_CLIENT;
271		else
272			priv->mode &= ~SYN_BIT_FOUR_BYTE_CLIENT;
273
274		if (synaptics_mode_cmd(psmouse, priv->mode))
275			printk(KERN_INFO "synaptics: failed to switch guest protocol\n");
276	}
277}
278
279static void synaptics_pt_create(struct psmouse *psmouse)
280{
281	struct serio *serio;
282
283	serio = kmalloc(sizeof(struct serio), GFP_KERNEL);
284	if (!serio) {
285		printk(KERN_ERR "synaptics: not enough memory to allocate pass-through port\n");
286		return;
287	}
288
289	memset(serio, 0, sizeof(struct serio));
290
291	serio->id.type = SERIO_PS_PSTHRU;
292	strlcpy(serio->name, "Synaptics pass-through", sizeof(serio->name));
293	strlcpy(serio->phys, "synaptics-pt/serio0", sizeof(serio->name));
294	serio->write = synaptics_pt_write;
295	serio->parent = psmouse->ps2dev.serio;
296
297	psmouse->pt_activate = synaptics_pt_activate;
298
299	printk(KERN_INFO "serio: %s port at %s\n", serio->name, psmouse->phys);
300	serio_register_port(serio);
301}
302
303/*****************************************************************************
304 *	Functions to interpret the absolute mode packets
305 ****************************************************************************/
306
307static void synaptics_parse_hw_state(unsigned char buf[], struct synaptics_data *priv, struct synaptics_hw_state *hw)
308{
309	memset(hw, 0, sizeof(struct synaptics_hw_state));
310
311	if (SYN_MODEL_NEWABS(priv->model_id)) {
312		hw->x = (((buf[3] & 0x10) << 8) |
313			 ((buf[1] & 0x0f) << 8) |
314			 buf[4]);
315		hw->y = (((buf[3] & 0x20) << 7) |
316			 ((buf[1] & 0xf0) << 4) |
317			 buf[5]);
318
319		hw->z = buf[2];
320		hw->w = (((buf[0] & 0x30) >> 2) |
321			 ((buf[0] & 0x04) >> 1) |
322			 ((buf[3] & 0x04) >> 2));
323
324		hw->left  = (buf[0] & 0x01) ? 1 : 0;
325		hw->right = (buf[0] & 0x02) ? 1 : 0;
326
327		if (SYN_CAP_MIDDLE_BUTTON(priv->capabilities)) {
328			hw->middle = ((buf[0] ^ buf[3]) & 0x01) ? 1 : 0;
329			if (hw->w == 2)
330				hw->scroll = (signed char)(buf[1]);
331		}
332
333		if (SYN_CAP_FOUR_BUTTON(priv->capabilities)) {
334			hw->up   = ((buf[0] ^ buf[3]) & 0x01) ? 1 : 0;
335			hw->down = ((buf[0] ^ buf[3]) & 0x02) ? 1 : 0;
336		}
337
338		if (SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap) &&
339		    ((buf[0] ^ buf[3]) & 0x02)) {
340			switch (SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap) & ~0x01) {
341			default:
342				/*
343				 * if nExtBtn is greater than 8 it should be
344				 * considered invalid and treated as 0
345				 */
346				break;
347			case 8:
348				hw->ext_buttons |= ((buf[5] & 0x08)) ? 0x80 : 0;
349				hw->ext_buttons |= ((buf[4] & 0x08)) ? 0x40 : 0;
350			case 6:
351				hw->ext_buttons |= ((buf[5] & 0x04)) ? 0x20 : 0;
352				hw->ext_buttons |= ((buf[4] & 0x04)) ? 0x10 : 0;
353			case 4:
354				hw->ext_buttons |= ((buf[5] & 0x02)) ? 0x08 : 0;
355				hw->ext_buttons |= ((buf[4] & 0x02)) ? 0x04 : 0;
356			case 2:
357				hw->ext_buttons |= ((buf[5] & 0x01)) ? 0x02 : 0;
358				hw->ext_buttons |= ((buf[4] & 0x01)) ? 0x01 : 0;
359			}
360		}
361	} else {
362		hw->x = (((buf[1] & 0x1f) << 8) | buf[2]);
363		hw->y = (((buf[4] & 0x1f) << 8) | buf[5]);
364
365		hw->z = (((buf[0] & 0x30) << 2) | (buf[3] & 0x3F));
366		hw->w = (((buf[1] & 0x80) >> 4) | ((buf[0] & 0x04) >> 1));
367
368		hw->left  = (buf[0] & 0x01) ? 1 : 0;
369		hw->right = (buf[0] & 0x02) ? 1 : 0;
370	}
371}
372
373/*
374 *  called for each full received packet from the touchpad
375 */
376static void synaptics_process_packet(struct psmouse *psmouse)
377{
378	struct input_dev *dev = &psmouse->dev;
379	struct synaptics_data *priv = psmouse->private;
380	struct synaptics_hw_state hw;
381	int num_fingers;
382	int finger_width;
383	int i;
384
385	synaptics_parse_hw_state(psmouse->packet, priv, &hw);
386
387	if (hw.scroll) {
388		priv->scroll += hw.scroll;
389
390		while (priv->scroll >= 4) {
391			input_report_key(dev, BTN_BACK, !hw.down);
392			input_sync(dev);
393			input_report_key(dev, BTN_BACK, hw.down);
394			input_sync(dev);
395			priv->scroll -= 4;
396		}
397		while (priv->scroll <= -4) {
398			input_report_key(dev, BTN_FORWARD, !hw.up);
399			input_sync(dev);
400			input_report_key(dev, BTN_FORWARD, hw.up);
401			input_sync(dev);
402			priv->scroll += 4;
403		}
404		return;
405	}
406
407	if (hw.z > 0) {
408		num_fingers = 1;
409		finger_width = 5;
410		if (SYN_CAP_EXTENDED(priv->capabilities)) {
411			switch (hw.w) {
412			case 0 ... 1:
413				if (SYN_CAP_MULTIFINGER(priv->capabilities))
414					num_fingers = hw.w + 2;
415				break;
416			case 2:
417				if (SYN_MODEL_PEN(priv->model_id))
418					;   /* Nothing, treat a pen as a single finger */
419				break;
420			case 4 ... 15:
421				if (SYN_CAP_PALMDETECT(priv->capabilities))
422					finger_width = hw.w;
423				break;
424			}
425		}
426	} else {
427		num_fingers = 0;
428		finger_width = 0;
429	}
430
431	/* Post events
432	 * BTN_TOUCH has to be first as mousedev relies on it when doing
433	 * absolute -> relative conversion
434	 */
435	if (hw.z > 30) input_report_key(dev, BTN_TOUCH, 1);
436	if (hw.z < 25) input_report_key(dev, BTN_TOUCH, 0);
437
438	if (hw.z > 0) {
439		input_report_abs(dev, ABS_X, hw.x);
440		input_report_abs(dev, ABS_Y, YMAX_NOMINAL + YMIN_NOMINAL - hw.y);
441	}
442	input_report_abs(dev, ABS_PRESSURE, hw.z);
443
444	input_report_abs(dev, ABS_TOOL_WIDTH, finger_width);
445	input_report_key(dev, BTN_TOOL_FINGER, num_fingers == 1);
446	input_report_key(dev, BTN_TOOL_DOUBLETAP, num_fingers == 2);
447	input_report_key(dev, BTN_TOOL_TRIPLETAP, num_fingers == 3);
448
449	input_report_key(dev, BTN_LEFT, hw.left);
450	input_report_key(dev, BTN_RIGHT, hw.right);
451
452	if (SYN_CAP_MIDDLE_BUTTON(priv->capabilities))
453		input_report_key(dev, BTN_MIDDLE, hw.middle);
454
455	if (SYN_CAP_FOUR_BUTTON(priv->capabilities)) {
456		input_report_key(dev, BTN_FORWARD, hw.up);
457		input_report_key(dev, BTN_BACK, hw.down);
458	}
459
460	for (i = 0; i < SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap); i++)
461		input_report_key(dev, BTN_0 + i, hw.ext_buttons & (1 << i));
462
463	input_sync(dev);
464}
465
466static int synaptics_validate_byte(unsigned char packet[], int idx, unsigned char pkt_type)
467{
468	static unsigned char newabs_mask[]	= { 0xC8, 0x00, 0x00, 0xC8, 0x00 };
469	static unsigned char newabs_rel_mask[]	= { 0xC0, 0x00, 0x00, 0xC0, 0x00 };
470	static unsigned char newabs_rslt[]	= { 0x80, 0x00, 0x00, 0xC0, 0x00 };
471	static unsigned char oldabs_mask[]	= { 0xC0, 0x60, 0x00, 0xC0, 0x60 };
472	static unsigned char oldabs_rslt[]	= { 0xC0, 0x00, 0x00, 0x80, 0x00 };
473
474	if (idx < 0 || idx > 4)
475		return 0;
476
477	switch (pkt_type) {
478		case SYN_NEWABS:
479		case SYN_NEWABS_RELAXED:
480			return (packet[idx] & newabs_rel_mask[idx]) == newabs_rslt[idx];
481
482		case SYN_NEWABS_STRICT:
483			return (packet[idx] & newabs_mask[idx]) == newabs_rslt[idx];
484
485		case SYN_OLDABS:
486			return (packet[idx] & oldabs_mask[idx]) == oldabs_rslt[idx];
487
488		default:
489			printk(KERN_ERR "synaptics: unknown packet type %d\n", pkt_type);
490			return 0;
491	}
492}
493
494static unsigned char synaptics_detect_pkt_type(struct psmouse *psmouse)
495{
496	int i;
497
498	for (i = 0; i < 5; i++)
499		if (!synaptics_validate_byte(psmouse->packet, i, SYN_NEWABS_STRICT)) {
500			printk(KERN_INFO "synaptics: using relaxed packet validation\n");
501			return SYN_NEWABS_RELAXED;
502		}
503
504	return SYN_NEWABS_STRICT;
505}
506
507static psmouse_ret_t synaptics_process_byte(struct psmouse *psmouse, struct pt_regs *regs)
508{
509	struct input_dev *dev = &psmouse->dev;
510	struct synaptics_data *priv = psmouse->private;
511
512	input_regs(dev, regs);
513
514	if (psmouse->pktcnt >= 6) { /* Full packet received */
515		if (unlikely(priv->pkt_type == SYN_NEWABS))
516			priv->pkt_type = synaptics_detect_pkt_type(psmouse);
517
518		if (SYN_CAP_PASS_THROUGH(priv->capabilities) && synaptics_is_pt_packet(psmouse->packet)) {
519			if (psmouse->ps2dev.serio->child)
520				synaptics_pass_pt_packet(psmouse->ps2dev.serio->child, psmouse->packet);
521		} else
522			synaptics_process_packet(psmouse);
523
524		return PSMOUSE_FULL_PACKET;
525	}
526
527	return synaptics_validate_byte(psmouse->packet, psmouse->pktcnt - 1, priv->pkt_type) ?
528		PSMOUSE_GOOD_DATA : PSMOUSE_BAD_DATA;
529}
530
531/*****************************************************************************
532 *	Driver initialization/cleanup functions
533 ****************************************************************************/
534static void set_input_params(struct input_dev *dev, struct synaptics_data *priv)
535{
536	int i;
537
538	set_bit(EV_ABS, dev->evbit);
539	input_set_abs_params(dev, ABS_X, XMIN_NOMINAL, XMAX_NOMINAL, 0, 0);
540	input_set_abs_params(dev, ABS_Y, YMIN_NOMINAL, YMAX_NOMINAL, 0, 0);
541	input_set_abs_params(dev, ABS_PRESSURE, 0, 255, 0, 0);
542	set_bit(ABS_TOOL_WIDTH, dev->absbit);
543
544	set_bit(EV_KEY, dev->evbit);
545	set_bit(BTN_TOUCH, dev->keybit);
546	set_bit(BTN_TOOL_FINGER, dev->keybit);
547	set_bit(BTN_TOOL_DOUBLETAP, dev->keybit);
548	set_bit(BTN_TOOL_TRIPLETAP, dev->keybit);
549
550	set_bit(BTN_LEFT, dev->keybit);
551	set_bit(BTN_RIGHT, dev->keybit);
552
553	if (SYN_CAP_MIDDLE_BUTTON(priv->capabilities))
554		set_bit(BTN_MIDDLE, dev->keybit);
555
556	if (SYN_CAP_FOUR_BUTTON(priv->capabilities) ||
557	    SYN_CAP_MIDDLE_BUTTON(priv->capabilities)) {
558		set_bit(BTN_FORWARD, dev->keybit);
559		set_bit(BTN_BACK, dev->keybit);
560	}
561
562	for (i = 0; i < SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap); i++)
563		set_bit(BTN_0 + i, dev->keybit);
564
565	clear_bit(EV_REL, dev->evbit);
566	clear_bit(REL_X, dev->relbit);
567	clear_bit(REL_Y, dev->relbit);
568}
569
570void synaptics_reset(struct psmouse *psmouse)
571{
572	/* reset touchpad back to relative mode, gestures enabled */
573	synaptics_mode_cmd(psmouse, 0);
574}
575
576static void synaptics_disconnect(struct psmouse *psmouse)
577{
578	synaptics_reset(psmouse);
579	kfree(psmouse->private);
580	psmouse->private = NULL;
581}
582
583static int synaptics_reconnect(struct psmouse *psmouse)
584{
585	struct synaptics_data *priv = psmouse->private;
586	struct synaptics_data old_priv = *priv;
587
588	if (synaptics_detect(psmouse, 0))
589		return -1;
590
591	if (synaptics_query_hardware(psmouse)) {
592		printk(KERN_ERR "Unable to query Synaptics hardware.\n");
593		return -1;
594	}
595
596	if (old_priv.identity != priv->identity ||
597	    old_priv.model_id != priv->model_id ||
598	    old_priv.capabilities != priv->capabilities ||
599	    old_priv.ext_cap != priv->ext_cap)
600		return -1;
601
602	if (synaptics_set_absolute_mode(psmouse)) {
603		printk(KERN_ERR "Unable to initialize Synaptics hardware.\n");
604		return -1;
605	}
606
607	return 0;
608}
609
610int synaptics_detect(struct psmouse *psmouse, int set_properties)
611{
612	struct ps2dev *ps2dev = &psmouse->ps2dev;
613	unsigned char param[4];
614
615	param[0] = 0;
616
617	ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
618	ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
619	ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
620	ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
621	ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO);
622
623	if (param[1] != 0x47)
624		return -1;
625
626	if (set_properties) {
627		psmouse->vendor = "Synaptics";
628		psmouse->name = "TouchPad";
629	}
630
631	return 0;
632}
633
634#if defined(__i386__)
635#include <linux/dmi.h>
636static struct dmi_system_id toshiba_dmi_table[] = {
637	{
638		.ident = "Toshiba Satellite",
639		.matches = {
640			DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
641			DMI_MATCH(DMI_PRODUCT_NAME , "Satellite"),
642		},
643	},
644	{ }
645};
646#endif
647
648int synaptics_init(struct psmouse *psmouse)
649{
650	struct synaptics_data *priv;
651
652	psmouse->private = priv = kmalloc(sizeof(struct synaptics_data), GFP_KERNEL);
653	if (!priv)
654		return -1;
655	memset(priv, 0, sizeof(struct synaptics_data));
656
657	if (synaptics_query_hardware(psmouse)) {
658		printk(KERN_ERR "Unable to query Synaptics hardware.\n");
659		goto init_fail;
660	}
661
662	if (synaptics_set_absolute_mode(psmouse)) {
663		printk(KERN_ERR "Unable to initialize Synaptics hardware.\n");
664		goto init_fail;
665	}
666
667	priv->pkt_type = SYN_MODEL_NEWABS(priv->model_id) ? SYN_NEWABS : SYN_OLDABS;
668
669	print_ident(priv);
670	set_input_params(&psmouse->dev, priv);
671
672	psmouse->protocol_handler = synaptics_process_byte;
673	psmouse->set_rate = synaptics_set_rate;
674	psmouse->disconnect = synaptics_disconnect;
675	psmouse->reconnect = synaptics_reconnect;
676	psmouse->pktsize = 6;
677
678	if (SYN_CAP_PASS_THROUGH(priv->capabilities))
679		synaptics_pt_create(psmouse);
680
681#if defined(__i386__)
682	/*
683	 * Toshiba's KBC seems to have trouble handling data from
684	 * Synaptics as full rate, switch to lower rate which is roughly
685	 * thye same as rate of standard PS/2 mouse.
686	 */
687	if (psmouse->rate >= 80 && dmi_check_system(toshiba_dmi_table)) {
688		printk(KERN_INFO "synaptics: Toshiba Satellite detected, limiting rate to 40pps.\n");
689		psmouse->rate = 40;
690	}
691#endif
692
693	return 0;
694
695 init_fail:
696	kfree(priv);
697	return -1;
698}
699
700