Branch data Line data Source code
1 : : /*
2 : : * PS/2 mouse driver
3 : : *
4 : : * Copyright (c) 1999-2002 Vojtech Pavlik
5 : : * Copyright (c) 2003-2004 Dmitry Torokhov
6 : : */
7 : :
8 : : /*
9 : : * This program is free software; you can redistribute it and/or modify it
10 : : * under the terms of the GNU General Public License version 2 as published by
11 : : * the Free Software Foundation.
12 : : */
13 : :
14 : : #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
15 : : #define psmouse_fmt(fmt) fmt
16 : :
17 : : #include <linux/delay.h>
18 : : #include <linux/module.h>
19 : : #include <linux/slab.h>
20 : : #include <linux/interrupt.h>
21 : : #include <linux/input.h>
22 : : #include <linux/serio.h>
23 : : #include <linux/init.h>
24 : : #include <linux/libps2.h>
25 : : #include <linux/mutex.h>
26 : :
27 : : #include "psmouse.h"
28 : : #include "synaptics.h"
29 : : #include "logips2pp.h"
30 : : #include "alps.h"
31 : : #include "hgpk.h"
32 : : #include "lifebook.h"
33 : : #include "trackpoint.h"
34 : : #include "touchkit_ps2.h"
35 : : #include "elantech.h"
36 : : #include "sentelic.h"
37 : : #include "cypress_ps2.h"
38 : :
39 : : #define DRIVER_DESC "PS/2 mouse driver"
40 : :
41 : : MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
42 : : MODULE_DESCRIPTION(DRIVER_DESC);
43 : : MODULE_LICENSE("GPL");
44 : :
45 : : static unsigned int psmouse_max_proto = PSMOUSE_AUTO;
46 : : static int psmouse_set_maxproto(const char *val, const struct kernel_param *);
47 : : static int psmouse_get_maxproto(char *buffer, const struct kernel_param *kp);
48 : : static struct kernel_param_ops param_ops_proto_abbrev = {
49 : : .set = psmouse_set_maxproto,
50 : : .get = psmouse_get_maxproto,
51 : : };
52 : : #define param_check_proto_abbrev(name, p) __param_check(name, p, unsigned int)
53 : : module_param_named(proto, psmouse_max_proto, proto_abbrev, 0644);
54 : : MODULE_PARM_DESC(proto, "Highest protocol extension to probe (bare, imps, exps, any). Useful for KVM switches.");
55 : :
56 : : static unsigned int psmouse_resolution = 200;
57 : : module_param_named(resolution, psmouse_resolution, uint, 0644);
58 : : MODULE_PARM_DESC(resolution, "Resolution, in dpi.");
59 : :
60 : : static unsigned int psmouse_rate = 100;
61 : : module_param_named(rate, psmouse_rate, uint, 0644);
62 : : MODULE_PARM_DESC(rate, "Report rate, in reports per second.");
63 : :
64 : : static bool psmouse_smartscroll = 1;
65 : : module_param_named(smartscroll, psmouse_smartscroll, bool, 0644);
66 : : MODULE_PARM_DESC(smartscroll, "Logitech Smartscroll autorepeat, 1 = enabled (default), 0 = disabled.");
67 : :
68 : : static unsigned int psmouse_resetafter = 5;
69 : : module_param_named(resetafter, psmouse_resetafter, uint, 0644);
70 : : MODULE_PARM_DESC(resetafter, "Reset device after so many bad packets (0 = never).");
71 : :
72 : : static unsigned int psmouse_resync_time;
73 : : module_param_named(resync_time, psmouse_resync_time, uint, 0644);
74 : : MODULE_PARM_DESC(resync_time, "How long can mouse stay idle before forcing resync (in seconds, 0 = never).");
75 : :
76 : : PSMOUSE_DEFINE_ATTR(protocol, S_IWUSR | S_IRUGO,
77 : : NULL,
78 : : psmouse_attr_show_protocol, psmouse_attr_set_protocol);
79 : : PSMOUSE_DEFINE_ATTR(rate, S_IWUSR | S_IRUGO,
80 : : (void *) offsetof(struct psmouse, rate),
81 : : psmouse_show_int_attr, psmouse_attr_set_rate);
82 : : PSMOUSE_DEFINE_ATTR(resolution, S_IWUSR | S_IRUGO,
83 : : (void *) offsetof(struct psmouse, resolution),
84 : : psmouse_show_int_attr, psmouse_attr_set_resolution);
85 : : PSMOUSE_DEFINE_ATTR(resetafter, S_IWUSR | S_IRUGO,
86 : : (void *) offsetof(struct psmouse, resetafter),
87 : : psmouse_show_int_attr, psmouse_set_int_attr);
88 : : PSMOUSE_DEFINE_ATTR(resync_time, S_IWUSR | S_IRUGO,
89 : : (void *) offsetof(struct psmouse, resync_time),
90 : : psmouse_show_int_attr, psmouse_set_int_attr);
91 : :
92 : : static struct attribute *psmouse_attributes[] = {
93 : : &psmouse_attr_protocol.dattr.attr,
94 : : &psmouse_attr_rate.dattr.attr,
95 : : &psmouse_attr_resolution.dattr.attr,
96 : : &psmouse_attr_resetafter.dattr.attr,
97 : : &psmouse_attr_resync_time.dattr.attr,
98 : : NULL
99 : : };
100 : :
101 : : static struct attribute_group psmouse_attribute_group = {
102 : : .attrs = psmouse_attributes,
103 : : };
104 : :
105 : : /*
106 : : * psmouse_mutex protects all operations changing state of mouse
107 : : * (connecting, disconnecting, changing rate or resolution via
108 : : * sysfs). We could use a per-device semaphore but since there
109 : : * rarely more than one PS/2 mouse connected and since semaphore
110 : : * is taken in "slow" paths it is not worth it.
111 : : */
112 : : static DEFINE_MUTEX(psmouse_mutex);
113 : :
114 : : static struct workqueue_struct *kpsmoused_wq;
115 : :
116 : : struct psmouse_protocol {
117 : : enum psmouse_type type;
118 : : bool maxproto;
119 : : bool ignore_parity; /* Protocol should ignore parity errors from KBC */
120 : : const char *name;
121 : : const char *alias;
122 : : int (*detect)(struct psmouse *, bool);
123 : : int (*init)(struct psmouse *);
124 : : };
125 : :
126 : : /*
127 : : * psmouse_process_byte() analyzes the PS/2 data stream and reports
128 : : * relevant events to the input module once full packet has arrived.
129 : : */
130 : :
131 : 0 : psmouse_ret_t psmouse_process_byte(struct psmouse *psmouse)
132 : : {
133 : 0 : struct input_dev *dev = psmouse->dev;
134 : : unsigned char *packet = psmouse->packet;
135 : :
136 [ # # ]: 0 : if (psmouse->pktcnt < psmouse->pktsize)
137 : : return PSMOUSE_GOOD_DATA;
138 : :
139 : : /*
140 : : * Full packet accumulated, process it
141 : : */
142 : :
143 : : /*
144 : : * Scroll wheel on IntelliMice, scroll buttons on NetMice
145 : : */
146 : :
147 [ # # ]: 0 : if (psmouse->type == PSMOUSE_IMPS || psmouse->type == PSMOUSE_GENPS)
148 : 0 : input_report_rel(dev, REL_WHEEL, -(signed char) packet[3]);
149 : :
150 : : /*
151 : : * Scroll wheel and buttons on IntelliMouse Explorer
152 : : */
153 : :
154 [ # # ]: 0 : if (psmouse->type == PSMOUSE_IMEX) {
155 [ # # # # ]: 0 : switch (packet[3] & 0xC0) {
156 : : case 0x80: /* vertical scroll on IntelliMouse Explorer 4.0 */
157 : 0 : input_report_rel(dev, REL_WHEEL, (int) (packet[3] & 32) - (int) (packet[3] & 31));
158 : : break;
159 : : case 0x40: /* horizontal scroll on IntelliMouse Explorer 4.0 */
160 : 0 : input_report_rel(dev, REL_HWHEEL, (int) (packet[3] & 32) - (int) (packet[3] & 31));
161 : : break;
162 : : case 0x00:
163 : : case 0xC0:
164 : 0 : input_report_rel(dev, REL_WHEEL, (int) (packet[3] & 8) - (int) (packet[3] & 7));
165 : 0 : input_report_key(dev, BTN_SIDE, (packet[3] >> 4) & 1);
166 : 0 : input_report_key(dev, BTN_EXTRA, (packet[3] >> 5) & 1);
167 : : break;
168 : : }
169 : : }
170 : :
171 : : /*
172 : : * Extra buttons on Genius NewNet 3D
173 : : */
174 : :
175 [ # # ]: 0 : if (psmouse->type == PSMOUSE_GENPS) {
176 : 0 : input_report_key(dev, BTN_SIDE, (packet[0] >> 6) & 1);
177 : 0 : input_report_key(dev, BTN_EXTRA, (packet[0] >> 7) & 1);
178 : : }
179 : :
180 : : /*
181 : : * Extra button on ThinkingMouse
182 : : */
183 [ # # ]: 0 : if (psmouse->type == PSMOUSE_THINKPS) {
184 : 0 : input_report_key(dev, BTN_EXTRA, (packet[0] >> 3) & 1);
185 : : /* Without this bit of weirdness moving up gives wildly high Y changes. */
186 : 0 : packet[1] |= (packet[0] & 0x40) << 1;
187 : : }
188 : :
189 : : /*
190 : : * Cortron PS2 Trackball reports SIDE button on the 4th bit of the first
191 : : * byte.
192 : : */
193 [ # # ]: 0 : if (psmouse->type == PSMOUSE_CORTRON) {
194 : 0 : input_report_key(dev, BTN_SIDE, (packet[0] >> 3) & 1);
195 : 0 : packet[0] |= 0x08;
196 : : }
197 : :
198 : : /*
199 : : * Generic PS/2 Mouse
200 : : */
201 : :
202 : 0 : input_report_key(dev, BTN_LEFT, packet[0] & 1);
203 : 0 : input_report_key(dev, BTN_MIDDLE, (packet[0] >> 2) & 1);
204 : 0 : input_report_key(dev, BTN_RIGHT, (packet[0] >> 1) & 1);
205 : :
206 [ # # ]: 0 : input_report_rel(dev, REL_X, packet[1] ? (int) packet[1] - (int) ((packet[0] << 4) & 0x100) : 0);
207 [ # # ]: 0 : input_report_rel(dev, REL_Y, packet[2] ? (int) ((packet[0] << 3) & 0x100) - (int) packet[2] : 0);
208 : :
209 : : input_sync(dev);
210 : :
211 : 0 : return PSMOUSE_FULL_PACKET;
212 : : }
213 : :
214 : 0 : void psmouse_queue_work(struct psmouse *psmouse, struct delayed_work *work,
215 : : unsigned long delay)
216 : : {
217 : 0 : queue_delayed_work(kpsmoused_wq, work, delay);
218 : 0 : }
219 : :
220 : : /*
221 : : * __psmouse_set_state() sets new psmouse state and resets all flags.
222 : : */
223 : :
224 : : static inline void __psmouse_set_state(struct psmouse *psmouse, enum psmouse_state new_state)
225 : : {
226 : 0 : psmouse->state = new_state;
227 : 0 : psmouse->pktcnt = psmouse->out_of_sync_cnt = 0;
228 : 0 : psmouse->ps2dev.flags = 0;
229 : 0 : psmouse->last = jiffies;
230 : : }
231 : :
232 : :
233 : : /*
234 : : * psmouse_set_state() sets new psmouse state and resets all flags and
235 : : * counters while holding serio lock so fighting with interrupt handler
236 : : * is not a concern.
237 : : */
238 : :
239 : 0 : void psmouse_set_state(struct psmouse *psmouse, enum psmouse_state new_state)
240 : : {
241 : 0 : serio_pause_rx(psmouse->ps2dev.serio);
242 : : __psmouse_set_state(psmouse, new_state);
243 : 0 : serio_continue_rx(psmouse->ps2dev.serio);
244 : 0 : }
245 : :
246 : : /*
247 : : * psmouse_handle_byte() processes one byte of the input data stream
248 : : * by calling corresponding protocol handler.
249 : : */
250 : :
251 : 0 : static int psmouse_handle_byte(struct psmouse *psmouse)
252 : : {
253 : 0 : psmouse_ret_t rc = psmouse->protocol_handler(psmouse);
254 : :
255 [ # # # ]: 0 : switch (rc) {
256 : : case PSMOUSE_BAD_DATA:
257 [ # # ]: 0 : if (psmouse->state == PSMOUSE_ACTIVATED) {
258 : 0 : psmouse_warn(psmouse,
259 : : "%s at %s lost sync at byte %d\n",
260 : : psmouse->name, psmouse->phys,
261 : : psmouse->pktcnt);
262 [ # # ]: 0 : if (++psmouse->out_of_sync_cnt == psmouse->resetafter) {
263 : : __psmouse_set_state(psmouse, PSMOUSE_IGNORE);
264 : 0 : psmouse_notice(psmouse,
265 : : "issuing reconnect request\n");
266 : 0 : serio_reconnect(psmouse->ps2dev.serio);
267 : 0 : return -1;
268 : : }
269 : : }
270 : 0 : psmouse->pktcnt = 0;
271 : 0 : break;
272 : :
273 : : case PSMOUSE_FULL_PACKET:
274 : 0 : psmouse->pktcnt = 0;
275 [ # # ]: 0 : if (psmouse->out_of_sync_cnt) {
276 : 0 : psmouse->out_of_sync_cnt = 0;
277 : 0 : psmouse_notice(psmouse,
278 : : "%s at %s - driver resynced.\n",
279 : : psmouse->name, psmouse->phys);
280 : : }
281 : : break;
282 : :
283 : : case PSMOUSE_GOOD_DATA:
284 : : break;
285 : : }
286 : : return 0;
287 : : }
288 : :
289 : : /*
290 : : * psmouse_interrupt() handles incoming characters, either passing them
291 : : * for normal processing or gathering them as command response.
292 : : */
293 : :
294 : 0 : static irqreturn_t psmouse_interrupt(struct serio *serio,
295 : : unsigned char data, unsigned int flags)
296 : : {
297 : : struct psmouse *psmouse = serio_get_drvdata(serio);
298 : :
299 [ # # ]: 0 : if (psmouse->state == PSMOUSE_IGNORE)
300 : : goto out;
301 : :
302 [ # # ][ # # ]: 0 : if (unlikely((flags & SERIO_TIMEOUT) ||
[ # # ][ # # ]
303 : : ((flags & SERIO_PARITY) && !psmouse->ignore_parity))) {
304 : :
305 [ # # ]: 0 : if (psmouse->state == PSMOUSE_ACTIVATED)
306 [ # # ][ # # ]: 0 : psmouse_warn(psmouse,
307 : : "bad data from KBC -%s%s\n",
308 : : flags & SERIO_TIMEOUT ? " timeout" : "",
309 : : flags & SERIO_PARITY ? " bad parity" : "");
310 : 0 : ps2_cmd_aborted(&psmouse->ps2dev);
311 : 0 : goto out;
312 : : }
313 : :
314 [ # # ]: 0 : if (unlikely(psmouse->ps2dev.flags & PS2_FLAG_ACK))
315 [ # # ]: 0 : if (ps2_handle_ack(&psmouse->ps2dev, data))
316 : : goto out;
317 : :
318 [ # # ]: 0 : if (unlikely(psmouse->ps2dev.flags & PS2_FLAG_CMD))
319 [ # # ]: 0 : if (ps2_handle_response(&psmouse->ps2dev, data))
320 : : goto out;
321 : :
322 [ # # ]: 0 : if (psmouse->state <= PSMOUSE_RESYNCING)
323 : : goto out;
324 : :
325 [ # # ][ # # ]: 0 : if (psmouse->state == PSMOUSE_ACTIVATED &&
326 [ # # ]: 0 : psmouse->pktcnt && time_after(jiffies, psmouse->last + HZ/2)) {
327 : 0 : psmouse_info(psmouse, "%s at %s lost synchronization, throwing %d bytes away.\n",
328 : : psmouse->name, psmouse->phys, psmouse->pktcnt);
329 : 0 : psmouse->badbyte = psmouse->packet[0];
330 : : __psmouse_set_state(psmouse, PSMOUSE_RESYNCING);
331 : 0 : psmouse_queue_work(psmouse, &psmouse->resync_work, 0);
332 : : goto out;
333 : : }
334 : :
335 : 0 : psmouse->packet[psmouse->pktcnt++] = data;
336 : : /*
337 : : * Check if this is a new device announcement (0xAA 0x00)
338 : : */
339 [ # # ][ # # ]: 0 : if (unlikely(psmouse->packet[0] == PSMOUSE_RET_BAT && psmouse->pktcnt <= 2)) {
340 [ # # ]: 0 : if (psmouse->pktcnt == 1) {
341 : 0 : psmouse->last = jiffies;
342 : 0 : goto out;
343 : : }
344 : :
345 [ # # ][ # # ]: 0 : if (psmouse->packet[1] == PSMOUSE_RET_ID ||
346 [ # # ]: 0 : (psmouse->type == PSMOUSE_HGPK &&
347 : : psmouse->packet[1] == PSMOUSE_RET_BAT)) {
348 : : __psmouse_set_state(psmouse, PSMOUSE_IGNORE);
349 : 0 : serio_reconnect(serio);
350 : 0 : goto out;
351 : : }
352 : : /*
353 : : * Not a new device, try processing first byte normally
354 : : */
355 : 0 : psmouse->pktcnt = 1;
356 [ # # ]: 0 : if (psmouse_handle_byte(psmouse))
357 : : goto out;
358 : :
359 : 0 : psmouse->packet[psmouse->pktcnt++] = data;
360 : : }
361 : :
362 : : /*
363 : : * See if we need to force resync because mouse was idle for too long
364 : : */
365 [ # # ][ # # ]: 0 : if (psmouse->state == PSMOUSE_ACTIVATED &&
366 [ # # ]: 0 : psmouse->pktcnt == 1 && psmouse->resync_time &&
367 [ # # ]: 0 : time_after(jiffies, psmouse->last + psmouse->resync_time * HZ)) {
368 : 0 : psmouse->badbyte = psmouse->packet[0];
369 : : __psmouse_set_state(psmouse, PSMOUSE_RESYNCING);
370 : 0 : psmouse_queue_work(psmouse, &psmouse->resync_work, 0);
371 : : goto out;
372 : : }
373 : :
374 : 0 : psmouse->last = jiffies;
375 : 0 : psmouse_handle_byte(psmouse);
376 : :
377 : : out:
378 : 0 : return IRQ_HANDLED;
379 : : }
380 : :
381 : :
382 : : /*
383 : : * psmouse_sliced_command() sends an extended PS/2 command to the mouse
384 : : * using sliced syntax, understood by advanced devices, such as Logitech
385 : : * or Synaptics touchpads. The command is encoded as:
386 : : * 0xE6 0xE8 rr 0xE8 ss 0xE8 tt 0xE8 uu where (rr*64)+(ss*16)+(tt*4)+uu
387 : : * is the command.
388 : : */
389 : 0 : int psmouse_sliced_command(struct psmouse *psmouse, unsigned char command)
390 : : {
391 : : int i;
392 : :
393 [ # # ]: 0 : if (ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETSCALE11))
394 : : return -1;
395 : :
396 [ # # ]: 0 : for (i = 6; i >= 0; i -= 2) {
397 : 0 : unsigned char d = (command >> i) & 3;
398 [ # # ]: 0 : if (ps2_command(&psmouse->ps2dev, &d, PSMOUSE_CMD_SETRES))
399 : 0 : return -1;
400 : : }
401 : :
402 : : return 0;
403 : : }
404 : :
405 : :
406 : : /*
407 : : * psmouse_reset() resets the mouse into power-on state.
408 : : */
409 : 0 : int psmouse_reset(struct psmouse *psmouse)
410 : : {
411 : : unsigned char param[2];
412 : :
413 [ # # ]: 0 : if (ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_RESET_BAT))
414 : : return -1;
415 : :
416 [ # # ][ # # ]: 0 : if (param[0] != PSMOUSE_RET_BAT && param[1] != PSMOUSE_RET_ID)
417 : : return -1;
418 : :
419 : 0 : return 0;
420 : : }
421 : :
422 : : /*
423 : : * Here we set the mouse resolution.
424 : : */
425 : :
426 : 0 : void psmouse_set_resolution(struct psmouse *psmouse, unsigned int resolution)
427 : : {
428 : : static const unsigned char params[] = { 0, 1, 2, 2, 3 };
429 : : unsigned char p;
430 : :
431 [ # # ]: 0 : if (resolution == 0 || resolution > 200)
432 : : resolution = 200;
433 : :
434 : 0 : p = params[resolution / 50];
435 : 0 : ps2_command(&psmouse->ps2dev, &p, PSMOUSE_CMD_SETRES);
436 : 0 : psmouse->resolution = 25 << p;
437 : 0 : }
438 : :
439 : : /*
440 : : * Here we set the mouse report rate.
441 : : */
442 : :
443 : 0 : static void psmouse_set_rate(struct psmouse *psmouse, unsigned int rate)
444 : : {
445 : : static const unsigned char rates[] = { 200, 100, 80, 60, 40, 20, 10, 0 };
446 : : unsigned char r;
447 : : int i = 0;
448 : :
449 [ # # ]: 0 : while (rates[i] > rate) i++;
450 : 0 : r = rates[i];
451 : 0 : ps2_command(&psmouse->ps2dev, &r, PSMOUSE_CMD_SETRATE);
452 : 0 : psmouse->rate = r;
453 : 0 : }
454 : :
455 : : /*
456 : : * psmouse_poll() - default poll handler. Everyone except for ALPS uses it.
457 : : */
458 : :
459 : 0 : static int psmouse_poll(struct psmouse *psmouse)
460 : : {
461 : 0 : return ps2_command(&psmouse->ps2dev, psmouse->packet,
462 : 0 : PSMOUSE_CMD_POLL | (psmouse->pktsize << 8));
463 : : }
464 : :
465 : :
466 : : /*
467 : : * Genius NetMouse magic init.
468 : : */
469 : 0 : static int genius_detect(struct psmouse *psmouse, bool set_properties)
470 : : {
471 : 0 : struct ps2dev *ps2dev = &psmouse->ps2dev;
472 : : unsigned char param[4];
473 : :
474 : 0 : param[0] = 3;
475 : 0 : ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
476 : 0 : ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11);
477 : 0 : ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11);
478 : 0 : ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11);
479 : 0 : ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO);
480 : :
481 [ # # ][ # # ]: 0 : if (param[0] != 0x00 || param[1] != 0x33 || param[2] != 0x55)
[ # # ]
482 : : return -1;
483 : :
484 [ # # ]: 0 : if (set_properties) {
485 : 0 : __set_bit(BTN_MIDDLE, psmouse->dev->keybit);
486 : 0 : __set_bit(BTN_EXTRA, psmouse->dev->keybit);
487 : 0 : __set_bit(BTN_SIDE, psmouse->dev->keybit);
488 : 0 : __set_bit(REL_WHEEL, psmouse->dev->relbit);
489 : :
490 : 0 : psmouse->vendor = "Genius";
491 : 0 : psmouse->name = "Mouse";
492 : 0 : psmouse->pktsize = 4;
493 : : }
494 : :
495 : : return 0;
496 : : }
497 : :
498 : : /*
499 : : * IntelliMouse magic init.
500 : : */
501 : 0 : static int intellimouse_detect(struct psmouse *psmouse, bool set_properties)
502 : : {
503 : 0 : struct ps2dev *ps2dev = &psmouse->ps2dev;
504 : : unsigned char param[2];
505 : :
506 : 0 : param[0] = 200;
507 : 0 : ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
508 : 0 : param[0] = 100;
509 : 0 : ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
510 : 0 : param[0] = 80;
511 : 0 : ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
512 : 0 : ps2_command(ps2dev, param, PSMOUSE_CMD_GETID);
513 : :
514 [ # # ]: 0 : if (param[0] != 3)
515 : : return -1;
516 : :
517 [ # # ]: 0 : if (set_properties) {
518 : 0 : __set_bit(BTN_MIDDLE, psmouse->dev->keybit);
519 : 0 : __set_bit(REL_WHEEL, psmouse->dev->relbit);
520 : :
521 [ # # ]: 0 : if (!psmouse->vendor)
522 : 0 : psmouse->vendor = "Generic";
523 [ # # ]: 0 : if (!psmouse->name)
524 : 0 : psmouse->name = "Wheel Mouse";
525 : 0 : psmouse->pktsize = 4;
526 : : }
527 : :
528 : : return 0;
529 : : }
530 : :
531 : : /*
532 : : * Try IntelliMouse/Explorer magic init.
533 : : */
534 : 0 : static int im_explorer_detect(struct psmouse *psmouse, bool set_properties)
535 : : {
536 : 0 : struct ps2dev *ps2dev = &psmouse->ps2dev;
537 : : unsigned char param[2];
538 : :
539 : 0 : intellimouse_detect(psmouse, 0);
540 : :
541 : 0 : param[0] = 200;
542 : 0 : ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
543 : 0 : param[0] = 200;
544 : 0 : ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
545 : 0 : param[0] = 80;
546 : 0 : ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
547 : 0 : ps2_command(ps2dev, param, PSMOUSE_CMD_GETID);
548 : :
549 [ # # ]: 0 : if (param[0] != 4)
550 : : return -1;
551 : :
552 : : /* Magic to enable horizontal scrolling on IntelliMouse 4.0 */
553 : 0 : param[0] = 200;
554 : 0 : ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
555 : 0 : param[0] = 80;
556 : 0 : ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
557 : 0 : param[0] = 40;
558 : 0 : ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
559 : :
560 [ # # ]: 0 : if (set_properties) {
561 : 0 : __set_bit(BTN_MIDDLE, psmouse->dev->keybit);
562 : 0 : __set_bit(REL_WHEEL, psmouse->dev->relbit);
563 : 0 : __set_bit(REL_HWHEEL, psmouse->dev->relbit);
564 : 0 : __set_bit(BTN_SIDE, psmouse->dev->keybit);
565 : 0 : __set_bit(BTN_EXTRA, psmouse->dev->keybit);
566 : :
567 [ # # ]: 0 : if (!psmouse->vendor)
568 : 0 : psmouse->vendor = "Generic";
569 [ # # ]: 0 : if (!psmouse->name)
570 : 0 : psmouse->name = "Explorer Mouse";
571 : 0 : psmouse->pktsize = 4;
572 : : }
573 : :
574 : : return 0;
575 : : }
576 : :
577 : : /*
578 : : * Kensington ThinkingMouse / ExpertMouse magic init.
579 : : */
580 : 0 : static int thinking_detect(struct psmouse *psmouse, bool set_properties)
581 : : {
582 : 0 : struct ps2dev *ps2dev = &psmouse->ps2dev;
583 : : unsigned char param[2];
584 : : static const unsigned char seq[] = { 20, 60, 40, 20, 20, 60, 40, 20, 20 };
585 : : int i;
586 : :
587 : 0 : param[0] = 10;
588 : 0 : ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
589 : 0 : param[0] = 0;
590 : 0 : ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
591 [ # # ]: 0 : for (i = 0; i < ARRAY_SIZE(seq); i++) {
592 : 0 : param[0] = seq[i];
593 : 0 : ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
594 : : }
595 : 0 : ps2_command(ps2dev, param, PSMOUSE_CMD_GETID);
596 : :
597 [ # # ]: 0 : if (param[0] != 2)
598 : : return -1;
599 : :
600 [ # # ]: 0 : if (set_properties) {
601 : 0 : __set_bit(BTN_MIDDLE, psmouse->dev->keybit);
602 : 0 : __set_bit(BTN_EXTRA, psmouse->dev->keybit);
603 : :
604 : 0 : psmouse->vendor = "Kensington";
605 : 0 : psmouse->name = "ThinkingMouse";
606 : : }
607 : :
608 : : return 0;
609 : : }
610 : :
611 : : /*
612 : : * Bare PS/2 protocol "detection". Always succeeds.
613 : : */
614 : 0 : static int ps2bare_detect(struct psmouse *psmouse, bool set_properties)
615 : : {
616 [ # # ]: 0 : if (set_properties) {
617 [ # # ]: 0 : if (!psmouse->vendor)
618 : 0 : psmouse->vendor = "Generic";
619 [ # # ]: 0 : if (!psmouse->name)
620 : 0 : psmouse->name = "Mouse";
621 : :
622 : : /*
623 : : * We have no way of figuring true number of buttons so let's
624 : : * assume that the device has 3.
625 : : */
626 : 0 : __set_bit(BTN_MIDDLE, psmouse->dev->keybit);
627 : : }
628 : :
629 : 0 : return 0;
630 : : }
631 : :
632 : : /*
633 : : * Cortron PS/2 protocol detection. There's no special way to detect it, so it
634 : : * must be forced by sysfs protocol writing.
635 : : */
636 : 0 : static int cortron_detect(struct psmouse *psmouse, bool set_properties)
637 : : {
638 [ # # ]: 0 : if (set_properties) {
639 : 0 : psmouse->vendor = "Cortron";
640 : 0 : psmouse->name = "PS/2 Trackball";
641 : :
642 : 0 : __set_bit(BTN_MIDDLE, psmouse->dev->keybit);
643 : 0 : __set_bit(BTN_SIDE, psmouse->dev->keybit);
644 : : }
645 : :
646 : 0 : return 0;
647 : : }
648 : :
649 : : /*
650 : : * Apply default settings to the psmouse structure. Most of them will
651 : : * be overridden by individual protocol initialization routines.
652 : : */
653 : :
654 : 0 : static void psmouse_apply_defaults(struct psmouse *psmouse)
655 : : {
656 : 0 : struct input_dev *input_dev = psmouse->dev;
657 : :
658 : 0 : memset(input_dev->evbit, 0, sizeof(input_dev->evbit));
659 : 0 : memset(input_dev->keybit, 0, sizeof(input_dev->keybit));
660 : 0 : memset(input_dev->relbit, 0, sizeof(input_dev->relbit));
661 : 0 : memset(input_dev->absbit, 0, sizeof(input_dev->absbit));
662 : 0 : memset(input_dev->mscbit, 0, sizeof(input_dev->mscbit));
663 : :
664 : : __set_bit(EV_KEY, input_dev->evbit);
665 : : __set_bit(EV_REL, input_dev->evbit);
666 : :
667 : : __set_bit(BTN_LEFT, input_dev->keybit);
668 : : __set_bit(BTN_RIGHT, input_dev->keybit);
669 : :
670 : : __set_bit(REL_X, input_dev->relbit);
671 : : __set_bit(REL_Y, input_dev->relbit);
672 : :
673 : 0 : psmouse->set_rate = psmouse_set_rate;
674 : 0 : psmouse->set_resolution = psmouse_set_resolution;
675 : 0 : psmouse->poll = psmouse_poll;
676 : 0 : psmouse->protocol_handler = psmouse_process_byte;
677 : 0 : psmouse->pktsize = 3;
678 : 0 : psmouse->reconnect = NULL;
679 : 0 : psmouse->disconnect = NULL;
680 : 0 : psmouse->cleanup = NULL;
681 : 0 : psmouse->pt_activate = NULL;
682 : 0 : psmouse->pt_deactivate = NULL;
683 : 0 : }
684 : :
685 : : /*
686 : : * Apply default settings to the psmouse structure and call specified
687 : : * protocol detection or initialization routine.
688 : : */
689 : 0 : static int psmouse_do_detect(int (*detect)(struct psmouse *psmouse,
690 : : bool set_properties),
691 : : struct psmouse *psmouse, bool set_properties)
692 : : {
693 [ # # ][ # # ]: 0 : if (set_properties)
[ # # # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
694 : 0 : psmouse_apply_defaults(psmouse);
695 : :
696 : 0 : return detect(psmouse, set_properties);
697 : : }
698 : :
699 : : /*
700 : : * psmouse_extensions() probes for any extensions to the basic PS/2 protocol
701 : : * the mouse may have.
702 : : */
703 : :
704 : 0 : static int psmouse_extensions(struct psmouse *psmouse,
705 : : unsigned int max_proto, bool set_properties)
706 : : {
707 : : bool synaptics_hardware = false;
708 : :
709 : : /*
710 : : * We always check for lifebook because it does not disturb mouse
711 : : * (it only checks DMI information).
712 : : */
713 [ # # ]: 0 : if (psmouse_do_detect(lifebook_detect, psmouse, set_properties) == 0) {
714 [ # # ]: 0 : if (max_proto > PSMOUSE_IMEX) {
715 [ # # ]: 0 : if (!set_properties || lifebook_init(psmouse) == 0)
716 : : return PSMOUSE_LIFEBOOK;
717 : : }
718 : : }
719 : :
720 : : /*
721 : : * Try Kensington ThinkingMouse (we try first, because synaptics probe
722 : : * upsets the thinkingmouse).
723 : : */
724 : :
725 [ # # # # ]: 0 : if (max_proto > PSMOUSE_IMEX &&
726 : : psmouse_do_detect(thinking_detect, psmouse, set_properties) == 0) {
727 : : return PSMOUSE_THINKPS;
728 : : }
729 : :
730 : : /*
731 : : * Try Synaptics TouchPad. Note that probing is done even if Synaptics protocol
732 : : * support is disabled in config - we need to know if it is synaptics so we
733 : : * can reset it properly after probing for intellimouse.
734 : : */
735 [ # # # # ]: 0 : if (max_proto > PSMOUSE_PS2 &&
736 : : psmouse_do_detect(synaptics_detect, psmouse, set_properties) == 0) {
737 : : synaptics_hardware = true;
738 : :
739 [ # # ]: 0 : if (max_proto > PSMOUSE_IMEX) {
740 : : /*
741 : : * Try activating protocol, but check if support is enabled first, since
742 : : * we try detecting Synaptics even when protocol is disabled.
743 : : */
744 [ # # ][ # # ]: 0 : if (synaptics_supported() &&
745 [ # # ]: 0 : (!set_properties || synaptics_init(psmouse) == 0)) {
746 : : return PSMOUSE_SYNAPTICS;
747 : : }
748 : :
749 : : /*
750 : : * Some Synaptics touchpads can emulate extended protocols (like IMPS/2).
751 : : * Unfortunately Logitech/Genius probes confuse some firmware versions so
752 : : * we'll have to skip them.
753 : : */
754 : : max_proto = PSMOUSE_IMEX;
755 : : }
756 : : /*
757 : : * Make sure that touchpad is in relative mode, gestures (taps) are enabled
758 : : */
759 : 0 : synaptics_reset(psmouse);
760 : : }
761 : :
762 : : /*
763 : : * Try Cypress Trackpad.
764 : : * Must try it before Finger Sensing Pad because Finger Sensing Pad probe
765 : : * upsets some modules of Cypress Trackpads.
766 : : */
767 [ # # # # ]: 0 : if (max_proto > PSMOUSE_IMEX &&
768 : 0 : cypress_detect(psmouse, set_properties) == 0) {
769 [ # # ]: 0 : if (cypress_supported()) {
770 [ # # ]: 0 : if (cypress_init(psmouse) == 0)
771 : : return PSMOUSE_CYPRESS;
772 : :
773 : : /*
774 : : * Finger Sensing Pad probe upsets some modules of
775 : : * Cypress Trackpad, must avoid Finger Sensing Pad
776 : : * probe if Cypress Trackpad device detected.
777 : : */
778 : 0 : return PSMOUSE_PS2;
779 : : }
780 : :
781 : : max_proto = PSMOUSE_IMEX;
782 : : }
783 : :
784 : : /*
785 : : * Try ALPS TouchPad
786 : : */
787 [ # # ]: 0 : if (max_proto > PSMOUSE_IMEX) {
788 : 0 : ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_RESET_DIS);
789 [ # # ]: 0 : if (psmouse_do_detect(alps_detect,
790 : : psmouse, set_properties) == 0) {
791 [ # # ][ # # ]: 0 : if (!set_properties || alps_init(psmouse) == 0)
792 : : return PSMOUSE_ALPS;
793 : : /*
794 : : * Init failed, try basic relative protocols
795 : : */
796 : : max_proto = PSMOUSE_IMEX;
797 : : }
798 : : }
799 : :
800 : : /*
801 : : * Try OLPC HGPK touchpad.
802 : : */
803 [ # # # # ]: 0 : if (max_proto > PSMOUSE_IMEX &&
804 : : psmouse_do_detect(hgpk_detect, psmouse, set_properties) == 0) {
805 [ # # ]: 0 : if (!set_properties || hgpk_init(psmouse) == 0)
806 : : return PSMOUSE_HGPK;
807 : : /*
808 : : * Init failed, try basic relative protocols
809 : : */
810 : : max_proto = PSMOUSE_IMEX;
811 : : }
812 : :
813 : : /*
814 : : * Try Elantech touchpad.
815 : : */
816 [ # # # # ]: 0 : if (max_proto > PSMOUSE_IMEX &&
817 : : psmouse_do_detect(elantech_detect, psmouse, set_properties) == 0) {
818 [ # # ]: 0 : if (!set_properties || elantech_init(psmouse) == 0)
819 : : return PSMOUSE_ELANTECH;
820 : : /*
821 : : * Init failed, try basic relative protocols
822 : : */
823 : : max_proto = PSMOUSE_IMEX;
824 : : }
825 : :
826 [ # # ]: 0 : if (max_proto > PSMOUSE_IMEX) {
827 [ # # ]: 0 : if (psmouse_do_detect(genius_detect,
828 : : psmouse, set_properties) == 0)
829 : : return PSMOUSE_GENPS;
830 : :
831 [ # # ]: 0 : if (psmouse_do_detect(ps2pp_init,
832 : : psmouse, set_properties) == 0)
833 : : return PSMOUSE_PS2PP;
834 : :
835 [ # # ]: 0 : if (psmouse_do_detect(trackpoint_detect,
836 : : psmouse, set_properties) == 0)
837 : : return PSMOUSE_TRACKPOINT;
838 : :
839 [ # # ]: 0 : if (psmouse_do_detect(touchkit_ps2_detect,
840 : : psmouse, set_properties) == 0)
841 : : return PSMOUSE_TOUCHKIT_PS2;
842 : : }
843 : :
844 : : /*
845 : : * Try Finger Sensing Pad. We do it here because its probe upsets
846 : : * Trackpoint devices (causing TP_READ_ID command to time out).
847 : : */
848 [ # # ]: 0 : if (max_proto > PSMOUSE_IMEX) {
849 [ # # ]: 0 : if (psmouse_do_detect(fsp_detect,
850 : : psmouse, set_properties) == 0) {
851 [ # # ]: 0 : if (!set_properties || fsp_init(psmouse) == 0)
852 : : return PSMOUSE_FSP;
853 : : /*
854 : : * Init failed, try basic relative protocols
855 : : */
856 : : max_proto = PSMOUSE_IMEX;
857 : : }
858 : : }
859 : :
860 : : /*
861 : : * Reset to defaults in case the device got confused by extended
862 : : * protocol probes. Note that we follow up with full reset because
863 : : * some mice put themselves to sleep when they see PSMOUSE_RESET_DIS.
864 : : */
865 : 0 : ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_RESET_DIS);
866 : 0 : psmouse_reset(psmouse);
867 : :
868 [ # # # # ]: 0 : if (max_proto >= PSMOUSE_IMEX &&
869 : : psmouse_do_detect(im_explorer_detect,
870 : : psmouse, set_properties) == 0) {
871 : : return PSMOUSE_IMEX;
872 : : }
873 : :
874 [ # # # # ]: 0 : if (max_proto >= PSMOUSE_IMPS &&
875 : : psmouse_do_detect(intellimouse_detect,
876 : : psmouse, set_properties) == 0) {
877 : : return PSMOUSE_IMPS;
878 : : }
879 : :
880 : : /*
881 : : * Okay, all failed, we have a standard mouse here. The number of the buttons
882 : : * is still a question, though. We assume 3.
883 : : */
884 : 0 : psmouse_do_detect(ps2bare_detect, psmouse, set_properties);
885 : :
886 [ # # ]: 0 : if (synaptics_hardware) {
887 : : /*
888 : : * We detected Synaptics hardware but it did not respond to IMPS/2 probes.
889 : : * We need to reset the touchpad because if there is a track point on the
890 : : * pass through port it could get disabled while probing for protocol
891 : : * extensions.
892 : : */
893 : 0 : psmouse_reset(psmouse);
894 : : }
895 : :
896 : : return PSMOUSE_PS2;
897 : : }
898 : :
899 : : static const struct psmouse_protocol psmouse_protocols[] = {
900 : : {
901 : : .type = PSMOUSE_PS2,
902 : : .name = "PS/2",
903 : : .alias = "bare",
904 : : .maxproto = true,
905 : : .ignore_parity = true,
906 : : .detect = ps2bare_detect,
907 : : },
908 : : #ifdef CONFIG_MOUSE_PS2_LOGIPS2PP
909 : : {
910 : : .type = PSMOUSE_PS2PP,
911 : : .name = "PS2++",
912 : : .alias = "logitech",
913 : : .detect = ps2pp_init,
914 : : },
915 : : #endif
916 : : {
917 : : .type = PSMOUSE_THINKPS,
918 : : .name = "ThinkPS/2",
919 : : .alias = "thinkps",
920 : : .detect = thinking_detect,
921 : : },
922 : : #ifdef CONFIG_MOUSE_PS2_CYPRESS
923 : : {
924 : : .type = PSMOUSE_CYPRESS,
925 : : .name = "CyPS/2",
926 : : .alias = "cypress",
927 : : .detect = cypress_detect,
928 : : .init = cypress_init,
929 : : },
930 : : #endif
931 : : {
932 : : .type = PSMOUSE_GENPS,
933 : : .name = "GenPS/2",
934 : : .alias = "genius",
935 : : .detect = genius_detect,
936 : : },
937 : : {
938 : : .type = PSMOUSE_IMPS,
939 : : .name = "ImPS/2",
940 : : .alias = "imps",
941 : : .maxproto = true,
942 : : .ignore_parity = true,
943 : : .detect = intellimouse_detect,
944 : : },
945 : : {
946 : : .type = PSMOUSE_IMEX,
947 : : .name = "ImExPS/2",
948 : : .alias = "exps",
949 : : .maxproto = true,
950 : : .ignore_parity = true,
951 : : .detect = im_explorer_detect,
952 : : },
953 : : #ifdef CONFIG_MOUSE_PS2_SYNAPTICS
954 : : {
955 : : .type = PSMOUSE_SYNAPTICS,
956 : : .name = "SynPS/2",
957 : : .alias = "synaptics",
958 : : .detect = synaptics_detect,
959 : : .init = synaptics_init,
960 : : },
961 : : {
962 : : .type = PSMOUSE_SYNAPTICS_RELATIVE,
963 : : .name = "SynRelPS/2",
964 : : .alias = "synaptics-relative",
965 : : .detect = synaptics_detect,
966 : : .init = synaptics_init_relative,
967 : : },
968 : : #endif
969 : : #ifdef CONFIG_MOUSE_PS2_ALPS
970 : : {
971 : : .type = PSMOUSE_ALPS,
972 : : .name = "AlpsPS/2",
973 : : .alias = "alps",
974 : : .detect = alps_detect,
975 : : .init = alps_init,
976 : : },
977 : : #endif
978 : : #ifdef CONFIG_MOUSE_PS2_LIFEBOOK
979 : : {
980 : : .type = PSMOUSE_LIFEBOOK,
981 : : .name = "LBPS/2",
982 : : .alias = "lifebook",
983 : : .init = lifebook_init,
984 : : },
985 : : #endif
986 : : #ifdef CONFIG_MOUSE_PS2_TRACKPOINT
987 : : {
988 : : .type = PSMOUSE_TRACKPOINT,
989 : : .name = "TPPS/2",
990 : : .alias = "trackpoint",
991 : : .detect = trackpoint_detect,
992 : : },
993 : : #endif
994 : : #ifdef CONFIG_MOUSE_PS2_TOUCHKIT
995 : : {
996 : : .type = PSMOUSE_TOUCHKIT_PS2,
997 : : .name = "touchkitPS/2",
998 : : .alias = "touchkit",
999 : : .detect = touchkit_ps2_detect,
1000 : : },
1001 : : #endif
1002 : : #ifdef CONFIG_MOUSE_PS2_OLPC
1003 : : {
1004 : : .type = PSMOUSE_HGPK,
1005 : : .name = "OLPC HGPK",
1006 : : .alias = "hgpk",
1007 : : .detect = hgpk_detect,
1008 : : },
1009 : : #endif
1010 : : #ifdef CONFIG_MOUSE_PS2_ELANTECH
1011 : : {
1012 : : .type = PSMOUSE_ELANTECH,
1013 : : .name = "ETPS/2",
1014 : : .alias = "elantech",
1015 : : .detect = elantech_detect,
1016 : : .init = elantech_init,
1017 : : },
1018 : : #endif
1019 : : #ifdef CONFIG_MOUSE_PS2_SENTELIC
1020 : : {
1021 : : .type = PSMOUSE_FSP,
1022 : : .name = "FSPPS/2",
1023 : : .alias = "fsp",
1024 : : .detect = fsp_detect,
1025 : : .init = fsp_init,
1026 : : },
1027 : : #endif
1028 : : {
1029 : : .type = PSMOUSE_CORTRON,
1030 : : .name = "CortronPS/2",
1031 : : .alias = "cortps",
1032 : : .detect = cortron_detect,
1033 : : },
1034 : : {
1035 : : .type = PSMOUSE_AUTO,
1036 : : .name = "auto",
1037 : : .alias = "any",
1038 : : .maxproto = true,
1039 : : },
1040 : : };
1041 : :
1042 : 0 : static const struct psmouse_protocol *psmouse_protocol_by_type(enum psmouse_type type)
1043 : : {
1044 : : int i;
1045 : :
1046 [ # # ]: 0 : for (i = 0; i < ARRAY_SIZE(psmouse_protocols); i++)
1047 [ # # ]: 0 : if (psmouse_protocols[i].type == type)
1048 : 0 : return &psmouse_protocols[i];
1049 : :
1050 : 0 : WARN_ON(1);
1051 : 0 : return &psmouse_protocols[0];
1052 : : }
1053 : :
1054 : 0 : static const struct psmouse_protocol *psmouse_protocol_by_name(const char *name, size_t len)
1055 : : {
1056 : : const struct psmouse_protocol *p;
1057 : : int i;
1058 : :
1059 [ # # ]: 0 : for (i = 0; i < ARRAY_SIZE(psmouse_protocols); i++) {
1060 : 0 : p = &psmouse_protocols[i];
1061 : :
1062 [ # # ][ # # ]: 0 : if ((strlen(p->name) == len && !strncmp(p->name, name, len)) ||
[ # # ]
1063 [ # # ]: 0 : (strlen(p->alias) == len && !strncmp(p->alias, name, len)))
1064 : : return &psmouse_protocols[i];
1065 : : }
1066 : :
1067 : : return NULL;
1068 : : }
1069 : :
1070 : :
1071 : : /*
1072 : : * psmouse_probe() probes for a PS/2 mouse.
1073 : : */
1074 : :
1075 : 0 : static int psmouse_probe(struct psmouse *psmouse)
1076 : : {
1077 : 0 : struct ps2dev *ps2dev = &psmouse->ps2dev;
1078 : : unsigned char param[2];
1079 : :
1080 : : /*
1081 : : * First, we check if it's a mouse. It should send 0x00 or 0x03
1082 : : * in case of an IntelliMouse in 4-byte mode or 0x04 for IM Explorer.
1083 : : * Sunrex K8561 IR Keyboard/Mouse reports 0xff on second and subsequent
1084 : : * ID queries, probably due to a firmware bug.
1085 : : */
1086 : :
1087 : 0 : param[0] = 0xa5;
1088 [ # # ]: 0 : if (ps2_command(ps2dev, param, PSMOUSE_CMD_GETID))
1089 : : return -1;
1090 : :
1091 [ # # ][ # # ]: 0 : if (param[0] != 0x00 && param[0] != 0x03 &&
1092 [ # # ]: 0 : param[0] != 0x04 && param[0] != 0xff)
1093 : : return -1;
1094 : :
1095 : : /*
1096 : : * Then we reset and disable the mouse so that it doesn't generate events.
1097 : : */
1098 : :
1099 [ # # ]: 0 : if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_RESET_DIS))
1100 : 0 : psmouse_warn(psmouse, "Failed to reset mouse on %s\n",
1101 : : ps2dev->serio->phys);
1102 : :
1103 : : return 0;
1104 : : }
1105 : :
1106 : : /*
1107 : : * psmouse_initialize() initializes the mouse to a sane state.
1108 : : */
1109 : :
1110 : 0 : static void psmouse_initialize(struct psmouse *psmouse)
1111 : : {
1112 : : /*
1113 : : * We set the mouse report rate, resolution and scaling.
1114 : : */
1115 : :
1116 [ # # ]: 0 : if (psmouse_max_proto != PSMOUSE_PS2) {
1117 : 0 : psmouse->set_rate(psmouse, psmouse->rate);
1118 : 0 : psmouse->set_resolution(psmouse, psmouse->resolution);
1119 : 0 : ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETSCALE11);
1120 : : }
1121 : 0 : }
1122 : :
1123 : : /*
1124 : : * psmouse_activate() enables the mouse so that we get motion reports from it.
1125 : : */
1126 : :
1127 : 0 : int psmouse_activate(struct psmouse *psmouse)
1128 : : {
1129 [ # # ]: 0 : if (ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_ENABLE)) {
1130 : 0 : psmouse_warn(psmouse, "Failed to enable mouse on %s\n",
1131 : : psmouse->ps2dev.serio->phys);
1132 : 0 : return -1;
1133 : : }
1134 : :
1135 : 0 : psmouse_set_state(psmouse, PSMOUSE_ACTIVATED);
1136 : 0 : return 0;
1137 : : }
1138 : :
1139 : : /*
1140 : : * psmouse_deactivate() puts the mouse into poll mode so that we don't get motion
1141 : : * reports from it unless we explicitly request it.
1142 : : */
1143 : :
1144 : 0 : int psmouse_deactivate(struct psmouse *psmouse)
1145 : : {
1146 [ # # ]: 0 : if (ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_DISABLE)) {
1147 : 0 : psmouse_warn(psmouse, "Failed to deactivate mouse on %s\n",
1148 : : psmouse->ps2dev.serio->phys);
1149 : 0 : return -1;
1150 : : }
1151 : :
1152 : 0 : psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
1153 : 0 : return 0;
1154 : : }
1155 : :
1156 : :
1157 : : /*
1158 : : * psmouse_resync() attempts to re-validate current protocol.
1159 : : */
1160 : :
1161 : 0 : static void psmouse_resync(struct work_struct *work)
1162 : : {
1163 : 0 : struct psmouse *parent = NULL, *psmouse =
1164 : : container_of(work, struct psmouse, resync_work.work);
1165 : 0 : struct serio *serio = psmouse->ps2dev.serio;
1166 : : psmouse_ret_t rc = PSMOUSE_GOOD_DATA;
1167 : : bool failed = false, enabled = false;
1168 : : int i;
1169 : :
1170 : 0 : mutex_lock(&psmouse_mutex);
1171 : :
1172 [ # # ]: 0 : if (psmouse->state != PSMOUSE_RESYNCING)
1173 : : goto out;
1174 : :
1175 [ # # ][ # # ]: 0 : if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
1176 : : parent = serio_get_drvdata(serio->parent);
1177 : 0 : psmouse_deactivate(parent);
1178 : : }
1179 : :
1180 : : /*
1181 : : * Some mice don't ACK commands sent while they are in the middle of
1182 : : * transmitting motion packet. To avoid delay we use ps2_sendbyte()
1183 : : * instead of ps2_command() which would wait for 200ms for an ACK
1184 : : * that may never come.
1185 : : * As an additional quirk ALPS touchpads may not only forget to ACK
1186 : : * disable command but will stop reporting taps, so if we see that
1187 : : * mouse at least once ACKs disable we will do full reconnect if ACK
1188 : : * is missing.
1189 : : */
1190 : 0 : psmouse->num_resyncs++;
1191 : :
1192 [ # # ]: 0 : if (ps2_sendbyte(&psmouse->ps2dev, PSMOUSE_CMD_DISABLE, 20)) {
1193 [ # # ][ # # ]: 0 : if (psmouse->num_resyncs < 3 || psmouse->acks_disable_command)
1194 : : failed = true;
1195 : : } else
1196 : 0 : psmouse->acks_disable_command = true;
1197 : :
1198 : : /*
1199 : : * Poll the mouse. If it was reset the packet will be shorter than
1200 : : * psmouse->pktsize and ps2_command will fail. We do not expect and
1201 : : * do not handle scenario when mouse "upgrades" its protocol while
1202 : : * disconnected since it would require additional delay. If we ever
1203 : : * see a mouse that does it we'll adjust the code.
1204 : : */
1205 [ # # ]: 0 : if (!failed) {
1206 [ # # ]: 0 : if (psmouse->poll(psmouse))
1207 : : failed = true;
1208 : : else {
1209 : 0 : psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
1210 [ # # ]: 0 : for (i = 0; i < psmouse->pktsize; i++) {
1211 : 0 : psmouse->pktcnt++;
1212 : 0 : rc = psmouse->protocol_handler(psmouse);
1213 [ # # ]: 0 : if (rc != PSMOUSE_GOOD_DATA)
1214 : : break;
1215 : : }
1216 [ # # ]: 0 : if (rc != PSMOUSE_FULL_PACKET)
1217 : : failed = true;
1218 : 0 : psmouse_set_state(psmouse, PSMOUSE_RESYNCING);
1219 : : }
1220 : : }
1221 : : /*
1222 : : * Now try to enable mouse. We try to do that even if poll failed and also
1223 : : * repeat our attempts 5 times, otherwise we may be left out with disabled
1224 : : * mouse.
1225 : : */
1226 [ # # ]: 0 : for (i = 0; i < 5; i++) {
1227 [ # # ]: 0 : if (!ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_ENABLE)) {
1228 : : enabled = true;
1229 : : break;
1230 : : }
1231 : 0 : msleep(200);
1232 : : }
1233 : :
1234 [ # # ]: 0 : if (!enabled) {
1235 : 0 : psmouse_warn(psmouse, "failed to re-enable mouse on %s\n",
1236 : : psmouse->ps2dev.serio->phys);
1237 : : failed = true;
1238 : : }
1239 : :
1240 [ # # ]: 0 : if (failed) {
1241 : 0 : psmouse_set_state(psmouse, PSMOUSE_IGNORE);
1242 : 0 : psmouse_info(psmouse,
1243 : : "resync failed, issuing reconnect request\n");
1244 : 0 : serio_reconnect(serio);
1245 : : } else
1246 : 0 : psmouse_set_state(psmouse, PSMOUSE_ACTIVATED);
1247 : :
1248 [ # # ]: 0 : if (parent)
1249 : 0 : psmouse_activate(parent);
1250 : : out:
1251 : 0 : mutex_unlock(&psmouse_mutex);
1252 : 0 : }
1253 : :
1254 : : /*
1255 : : * psmouse_cleanup() resets the mouse into power-on state.
1256 : : */
1257 : :
1258 : 0 : static void psmouse_cleanup(struct serio *serio)
1259 : : {
1260 : : struct psmouse *psmouse = serio_get_drvdata(serio);
1261 : : struct psmouse *parent = NULL;
1262 : :
1263 : 0 : mutex_lock(&psmouse_mutex);
1264 : :
1265 [ # # ][ # # ]: 0 : if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
1266 : : parent = serio_get_drvdata(serio->parent);
1267 : 0 : psmouse_deactivate(parent);
1268 : : }
1269 : :
1270 : 0 : psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
1271 : :
1272 : : /*
1273 : : * Disable stream mode so cleanup routine can proceed undisturbed.
1274 : : */
1275 [ # # ]: 0 : if (ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_DISABLE))
1276 : 0 : psmouse_warn(psmouse, "Failed to disable mouse on %s\n",
1277 : : psmouse->ps2dev.serio->phys);
1278 : :
1279 [ # # ]: 0 : if (psmouse->cleanup)
1280 : 0 : psmouse->cleanup(psmouse);
1281 : :
1282 : : /*
1283 : : * Reset the mouse to defaults (bare PS/2 protocol).
1284 : : */
1285 : 0 : ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_RESET_DIS);
1286 : :
1287 : : /*
1288 : : * Some boxes, such as HP nx7400, get terribly confused if mouse
1289 : : * is not fully enabled before suspending/shutting down.
1290 : : */
1291 : 0 : ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_ENABLE);
1292 : :
1293 [ # # ]: 0 : if (parent) {
1294 [ # # ]: 0 : if (parent->pt_deactivate)
1295 : 0 : parent->pt_deactivate(parent);
1296 : :
1297 : 0 : psmouse_activate(parent);
1298 : : }
1299 : :
1300 : 0 : mutex_unlock(&psmouse_mutex);
1301 : 0 : }
1302 : :
1303 : : /*
1304 : : * psmouse_disconnect() closes and frees.
1305 : : */
1306 : :
1307 : 0 : static void psmouse_disconnect(struct serio *serio)
1308 : : {
1309 : : struct psmouse *psmouse, *parent = NULL;
1310 : :
1311 : : psmouse = serio_get_drvdata(serio);
1312 : :
1313 : 0 : sysfs_remove_group(&serio->dev.kobj, &psmouse_attribute_group);
1314 : :
1315 : 0 : mutex_lock(&psmouse_mutex);
1316 : :
1317 : 0 : psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
1318 : :
1319 : : /* make sure we don't have a resync in progress */
1320 : 0 : mutex_unlock(&psmouse_mutex);
1321 : 0 : flush_workqueue(kpsmoused_wq);
1322 : 0 : mutex_lock(&psmouse_mutex);
1323 : :
1324 [ # # ][ # # ]: 0 : if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
1325 : : parent = serio_get_drvdata(serio->parent);
1326 : 0 : psmouse_deactivate(parent);
1327 : : }
1328 : :
1329 [ # # ]: 0 : if (psmouse->disconnect)
1330 : 0 : psmouse->disconnect(psmouse);
1331 : :
1332 [ # # ][ # # ]: 0 : if (parent && parent->pt_deactivate)
1333 : 0 : parent->pt_deactivate(parent);
1334 : :
1335 : 0 : psmouse_set_state(psmouse, PSMOUSE_IGNORE);
1336 : :
1337 : 0 : serio_close(serio);
1338 : : serio_set_drvdata(serio, NULL);
1339 : 0 : input_unregister_device(psmouse->dev);
1340 : 0 : kfree(psmouse);
1341 : :
1342 [ # # ]: 0 : if (parent)
1343 : 0 : psmouse_activate(parent);
1344 : :
1345 : 0 : mutex_unlock(&psmouse_mutex);
1346 : 0 : }
1347 : :
1348 : 0 : static int psmouse_switch_protocol(struct psmouse *psmouse,
1349 : : const struct psmouse_protocol *proto)
1350 : : {
1351 : : const struct psmouse_protocol *selected_proto;
1352 : 0 : struct input_dev *input_dev = psmouse->dev;
1353 : :
1354 : 0 : input_dev->dev.parent = &psmouse->ps2dev.serio->dev;
1355 : :
1356 [ # # ][ # # ]: 0 : if (proto && (proto->detect || proto->init)) {
[ # # ]
1357 : 0 : psmouse_apply_defaults(psmouse);
1358 : :
1359 [ # # ][ # # ]: 0 : if (proto->detect && proto->detect(psmouse, true) < 0)
1360 : : return -1;
1361 : :
1362 [ # # ][ # # ]: 0 : if (proto->init && proto->init(psmouse) < 0)
1363 : : return -1;
1364 : :
1365 : 0 : psmouse->type = proto->type;
1366 : 0 : selected_proto = proto;
1367 : : } else {
1368 : 0 : psmouse->type = psmouse_extensions(psmouse,
1369 : : psmouse_max_proto, true);
1370 : 0 : selected_proto = psmouse_protocol_by_type(psmouse->type);
1371 : : }
1372 : :
1373 : 0 : psmouse->ignore_parity = selected_proto->ignore_parity;
1374 : :
1375 : : /*
1376 : : * If mouse's packet size is 3 there is no point in polling the
1377 : : * device in hopes to detect protocol reset - we won't get less
1378 : : * than 3 bytes response anyhow.
1379 : : */
1380 [ # # ]: 0 : if (psmouse->pktsize == 3)
1381 : 0 : psmouse->resync_time = 0;
1382 : :
1383 : : /*
1384 : : * Some smart KVMs fake response to POLL command returning just
1385 : : * 3 bytes and messing up our resync logic, so if initial poll
1386 : : * fails we won't try polling the device anymore. Hopefully
1387 : : * such KVM will maintain initially selected protocol.
1388 : : */
1389 [ # # ][ # # ]: 0 : if (psmouse->resync_time && psmouse->poll(psmouse))
1390 : 0 : psmouse->resync_time = 0;
1391 : :
1392 : 0 : snprintf(psmouse->devname, sizeof(psmouse->devname), "%s %s %s",
1393 : : selected_proto->name, psmouse->vendor, psmouse->name);
1394 : :
1395 : 0 : input_dev->name = psmouse->devname;
1396 : 0 : input_dev->phys = psmouse->phys;
1397 : 0 : input_dev->id.bustype = BUS_I8042;
1398 : 0 : input_dev->id.vendor = 0x0002;
1399 : 0 : input_dev->id.product = psmouse->type;
1400 : 0 : input_dev->id.version = psmouse->model;
1401 : :
1402 : 0 : return 0;
1403 : : }
1404 : :
1405 : : /*
1406 : : * psmouse_connect() is a callback from the serio module when
1407 : : * an unhandled serio port is found.
1408 : : */
1409 : 0 : static int psmouse_connect(struct serio *serio, struct serio_driver *drv)
1410 : : {
1411 : : struct psmouse *psmouse, *parent = NULL;
1412 : : struct input_dev *input_dev;
1413 : : int retval = 0, error = -ENOMEM;
1414 : :
1415 : 0 : mutex_lock(&psmouse_mutex);
1416 : :
1417 : : /*
1418 : : * If this is a pass-through port deactivate parent so the device
1419 : : * connected to this port can be successfully identified
1420 : : */
1421 [ # # ][ # # ]: 0 : if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
1422 : : parent = serio_get_drvdata(serio->parent);
1423 : 0 : psmouse_deactivate(parent);
1424 : : }
1425 : :
1426 : : psmouse = kzalloc(sizeof(struct psmouse), GFP_KERNEL);
1427 : 0 : input_dev = input_allocate_device();
1428 [ # # ]: 0 : if (!psmouse || !input_dev)
1429 : : goto err_free;
1430 : :
1431 : 0 : ps2_init(&psmouse->ps2dev, serio);
1432 : 0 : INIT_DELAYED_WORK(&psmouse->resync_work, psmouse_resync);
1433 : 0 : psmouse->dev = input_dev;
1434 : 0 : snprintf(psmouse->phys, sizeof(psmouse->phys), "%s/input0", serio->phys);
1435 : :
1436 : 0 : psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
1437 : :
1438 : : serio_set_drvdata(serio, psmouse);
1439 : :
1440 : 0 : error = serio_open(serio, drv);
1441 [ # # ]: 0 : if (error)
1442 : : goto err_clear_drvdata;
1443 : :
1444 [ # # ]: 0 : if (psmouse_probe(psmouse) < 0) {
1445 : : error = -ENODEV;
1446 : : goto err_close_serio;
1447 : : }
1448 : :
1449 : 0 : psmouse->rate = psmouse_rate;
1450 : 0 : psmouse->resolution = psmouse_resolution;
1451 : 0 : psmouse->resetafter = psmouse_resetafter;
1452 [ # # ]: 0 : psmouse->resync_time = parent ? 0 : psmouse_resync_time;
1453 : 0 : psmouse->smartscroll = psmouse_smartscroll;
1454 : :
1455 : 0 : psmouse_switch_protocol(psmouse, NULL);
1456 : :
1457 : 0 : psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
1458 : 0 : psmouse_initialize(psmouse);
1459 : :
1460 : 0 : error = input_register_device(psmouse->dev);
1461 [ # # ]: 0 : if (error)
1462 : : goto err_protocol_disconnect;
1463 : :
1464 [ # # ][ # # ]: 0 : if (parent && parent->pt_activate)
1465 : 0 : parent->pt_activate(parent);
1466 : :
1467 : 0 : error = sysfs_create_group(&serio->dev.kobj, &psmouse_attribute_group);
1468 [ # # ]: 0 : if (error)
1469 : : goto err_pt_deactivate;
1470 : :
1471 : 0 : psmouse_activate(psmouse);
1472 : :
1473 : : out:
1474 : : /* If this is a pass-through port the parent needs to be re-activated */
1475 [ # # ]: 0 : if (parent)
1476 : 0 : psmouse_activate(parent);
1477 : :
1478 : 0 : mutex_unlock(&psmouse_mutex);
1479 : 0 : return retval;
1480 : :
1481 : : err_pt_deactivate:
1482 [ # # ][ # # ]: 0 : if (parent && parent->pt_deactivate)
1483 : 0 : parent->pt_deactivate(parent);
1484 : 0 : input_unregister_device(psmouse->dev);
1485 : : input_dev = NULL; /* so we don't try to free it below */
1486 : : err_protocol_disconnect:
1487 [ # # ]: 0 : if (psmouse->disconnect)
1488 : 0 : psmouse->disconnect(psmouse);
1489 : 0 : psmouse_set_state(psmouse, PSMOUSE_IGNORE);
1490 : : err_close_serio:
1491 : 0 : serio_close(serio);
1492 : : err_clear_drvdata:
1493 : : serio_set_drvdata(serio, NULL);
1494 : : err_free:
1495 : 0 : input_free_device(input_dev);
1496 : 0 : kfree(psmouse);
1497 : :
1498 : : retval = error;
1499 : 0 : goto out;
1500 : : }
1501 : :
1502 : :
1503 : 0 : static int psmouse_reconnect(struct serio *serio)
1504 : : {
1505 : : struct psmouse *psmouse = serio_get_drvdata(serio);
1506 : : struct psmouse *parent = NULL;
1507 : 0 : struct serio_driver *drv = serio->drv;
1508 : : unsigned char type;
1509 : : int rc = -1;
1510 : :
1511 [ # # ]: 0 : if (!drv || !psmouse) {
1512 : : psmouse_dbg(psmouse,
1513 : : "reconnect request, but serio is disconnected, ignoring...\n");
1514 : : return -1;
1515 : : }
1516 : :
1517 : 0 : mutex_lock(&psmouse_mutex);
1518 : :
1519 [ # # ][ # # ]: 0 : if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
1520 : : parent = serio_get_drvdata(serio->parent);
1521 : 0 : psmouse_deactivate(parent);
1522 : : }
1523 : :
1524 : 0 : psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
1525 : :
1526 [ # # ]: 0 : if (psmouse->reconnect) {
1527 [ # # ]: 0 : if (psmouse->reconnect(psmouse))
1528 : : goto out;
1529 : : } else {
1530 : 0 : psmouse_reset(psmouse);
1531 : :
1532 [ # # ]: 0 : if (psmouse_probe(psmouse) < 0)
1533 : : goto out;
1534 : :
1535 : 0 : type = psmouse_extensions(psmouse, psmouse_max_proto, false);
1536 [ # # ]: 0 : if (psmouse->type != type)
1537 : : goto out;
1538 : : }
1539 : :
1540 : : /*
1541 : : * OK, the device type (and capabilities) match the old one,
1542 : : * we can continue using it, complete initialization
1543 : : */
1544 : 0 : psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
1545 : :
1546 : 0 : psmouse_initialize(psmouse);
1547 : :
1548 [ # # ][ # # ]: 0 : if (parent && parent->pt_activate)
1549 : 0 : parent->pt_activate(parent);
1550 : :
1551 : 0 : psmouse_activate(psmouse);
1552 : : rc = 0;
1553 : :
1554 : : out:
1555 : : /* If this is a pass-through port the parent waits to be activated */
1556 [ # # ]: 0 : if (parent)
1557 : 0 : psmouse_activate(parent);
1558 : :
1559 : 0 : mutex_unlock(&psmouse_mutex);
1560 : 0 : return rc;
1561 : : }
1562 : :
1563 : : static struct serio_device_id psmouse_serio_ids[] = {
1564 : : {
1565 : : .type = SERIO_8042,
1566 : : .proto = SERIO_ANY,
1567 : : .id = SERIO_ANY,
1568 : : .extra = SERIO_ANY,
1569 : : },
1570 : : {
1571 : : .type = SERIO_PS_PSTHRU,
1572 : : .proto = SERIO_ANY,
1573 : : .id = SERIO_ANY,
1574 : : .extra = SERIO_ANY,
1575 : : },
1576 : : { 0 }
1577 : : };
1578 : :
1579 : : MODULE_DEVICE_TABLE(serio, psmouse_serio_ids);
1580 : :
1581 : : static struct serio_driver psmouse_drv = {
1582 : : .driver = {
1583 : : .name = "psmouse",
1584 : : },
1585 : : .description = DRIVER_DESC,
1586 : : .id_table = psmouse_serio_ids,
1587 : : .interrupt = psmouse_interrupt,
1588 : : .connect = psmouse_connect,
1589 : : .reconnect = psmouse_reconnect,
1590 : : .disconnect = psmouse_disconnect,
1591 : : .cleanup = psmouse_cleanup,
1592 : : };
1593 : :
1594 : 0 : ssize_t psmouse_attr_show_helper(struct device *dev, struct device_attribute *devattr,
1595 : : char *buf)
1596 : : {
1597 : : struct serio *serio = to_serio_port(dev);
1598 : : struct psmouse_attribute *attr = to_psmouse_attr(devattr);
1599 : : struct psmouse *psmouse;
1600 : :
1601 : : psmouse = serio_get_drvdata(serio);
1602 : :
1603 : 0 : return attr->show(psmouse, attr->data, buf);
1604 : : }
1605 : :
1606 : 0 : ssize_t psmouse_attr_set_helper(struct device *dev, struct device_attribute *devattr,
1607 : : const char *buf, size_t count)
1608 : : {
1609 : : struct serio *serio = to_serio_port(dev);
1610 : : struct psmouse_attribute *attr = to_psmouse_attr(devattr);
1611 : : struct psmouse *psmouse, *parent = NULL;
1612 : : int retval;
1613 : :
1614 : 0 : retval = mutex_lock_interruptible(&psmouse_mutex);
1615 [ # # ]: 0 : if (retval)
1616 : : goto out;
1617 : :
1618 : : psmouse = serio_get_drvdata(serio);
1619 : :
1620 [ # # ]: 0 : if (attr->protect) {
1621 [ # # ]: 0 : if (psmouse->state == PSMOUSE_IGNORE) {
1622 : : retval = -ENODEV;
1623 : : goto out_unlock;
1624 : : }
1625 : :
1626 [ # # ][ # # ]: 0 : if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
1627 : : parent = serio_get_drvdata(serio->parent);
1628 : 0 : psmouse_deactivate(parent);
1629 : : }
1630 : :
1631 : 0 : psmouse_deactivate(psmouse);
1632 : : }
1633 : :
1634 : 0 : retval = attr->set(psmouse, attr->data, buf, count);
1635 : :
1636 [ # # ]: 0 : if (attr->protect) {
1637 [ # # ]: 0 : if (retval != -ENODEV)
1638 : 0 : psmouse_activate(psmouse);
1639 : :
1640 [ # # ]: 0 : if (parent)
1641 : 0 : psmouse_activate(parent);
1642 : : }
1643 : :
1644 : : out_unlock:
1645 : 0 : mutex_unlock(&psmouse_mutex);
1646 : : out:
1647 : 0 : return retval;
1648 : : }
1649 : :
1650 : 0 : static ssize_t psmouse_show_int_attr(struct psmouse *psmouse, void *offset, char *buf)
1651 : : {
1652 : 0 : unsigned int *field = (unsigned int *)((char *)psmouse + (size_t)offset);
1653 : :
1654 : 0 : return sprintf(buf, "%u\n", *field);
1655 : : }
1656 : :
1657 : 0 : static ssize_t psmouse_set_int_attr(struct psmouse *psmouse, void *offset, const char *buf, size_t count)
1658 : : {
1659 : 0 : unsigned int *field = (unsigned int *)((char *)psmouse + (size_t)offset);
1660 : : unsigned int value;
1661 : : int err;
1662 : :
1663 : 0 : err = kstrtouint(buf, 10, &value);
1664 [ # # ]: 0 : if (err)
1665 : : return err;
1666 : :
1667 : 0 : *field = value;
1668 : :
1669 : 0 : return count;
1670 : : }
1671 : :
1672 : 0 : static ssize_t psmouse_attr_show_protocol(struct psmouse *psmouse, void *data, char *buf)
1673 : : {
1674 : 0 : return sprintf(buf, "%s\n", psmouse_protocol_by_type(psmouse->type)->name);
1675 : : }
1676 : :
1677 : 0 : static ssize_t psmouse_attr_set_protocol(struct psmouse *psmouse, void *data, const char *buf, size_t count)
1678 : : {
1679 : 0 : struct serio *serio = psmouse->ps2dev.serio;
1680 : : struct psmouse *parent = NULL;
1681 : : struct input_dev *old_dev, *new_dev;
1682 : : const struct psmouse_protocol *proto, *old_proto;
1683 : : int error;
1684 : : int retry = 0;
1685 : :
1686 : 0 : proto = psmouse_protocol_by_name(buf, count);
1687 [ # # ]: 0 : if (!proto)
1688 : : return -EINVAL;
1689 : :
1690 [ # # ]: 0 : if (psmouse->type == proto->type)
1691 : 0 : return count;
1692 : :
1693 : 0 : new_dev = input_allocate_device();
1694 [ # # ]: 0 : if (!new_dev)
1695 : : return -ENOMEM;
1696 : :
1697 [ # # ]: 0 : while (!list_empty(&serio->children)) {
1698 [ # # ]: 0 : if (++retry > 3) {
1699 : 0 : psmouse_warn(psmouse,
1700 : : "failed to destroy children ports, protocol change aborted.\n");
1701 : 0 : input_free_device(new_dev);
1702 : 0 : return -EIO;
1703 : : }
1704 : :
1705 : 0 : mutex_unlock(&psmouse_mutex);
1706 : 0 : serio_unregister_child_port(serio);
1707 : 0 : mutex_lock(&psmouse_mutex);
1708 : :
1709 [ # # ]: 0 : if (serio->drv != &psmouse_drv) {
1710 : 0 : input_free_device(new_dev);
1711 : 0 : return -ENODEV;
1712 : : }
1713 : :
1714 [ # # ]: 0 : if (psmouse->type == proto->type) {
1715 : 0 : input_free_device(new_dev);
1716 : 0 : return count; /* switched by other thread */
1717 : : }
1718 : : }
1719 : :
1720 [ # # ][ # # ]: 0 : if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
1721 : : parent = serio_get_drvdata(serio->parent);
1722 [ # # ]: 0 : if (parent->pt_deactivate)
1723 : 0 : parent->pt_deactivate(parent);
1724 : : }
1725 : :
1726 : 0 : old_dev = psmouse->dev;
1727 : 0 : old_proto = psmouse_protocol_by_type(psmouse->type);
1728 : :
1729 [ # # ]: 0 : if (psmouse->disconnect)
1730 : 0 : psmouse->disconnect(psmouse);
1731 : :
1732 : 0 : psmouse_set_state(psmouse, PSMOUSE_IGNORE);
1733 : :
1734 : 0 : psmouse->dev = new_dev;
1735 : 0 : psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
1736 : :
1737 [ # # ]: 0 : if (psmouse_switch_protocol(psmouse, proto) < 0) {
1738 : 0 : psmouse_reset(psmouse);
1739 : : /* default to PSMOUSE_PS2 */
1740 : 0 : psmouse_switch_protocol(psmouse, &psmouse_protocols[0]);
1741 : : }
1742 : :
1743 : 0 : psmouse_initialize(psmouse);
1744 : 0 : psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
1745 : :
1746 : 0 : error = input_register_device(psmouse->dev);
1747 [ # # ]: 0 : if (error) {
1748 [ # # ]: 0 : if (psmouse->disconnect)
1749 : 0 : psmouse->disconnect(psmouse);
1750 : :
1751 : 0 : psmouse_set_state(psmouse, PSMOUSE_IGNORE);
1752 : 0 : input_free_device(new_dev);
1753 : 0 : psmouse->dev = old_dev;
1754 : 0 : psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
1755 : 0 : psmouse_switch_protocol(psmouse, old_proto);
1756 : 0 : psmouse_initialize(psmouse);
1757 : 0 : psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
1758 : :
1759 : 0 : return error;
1760 : : }
1761 : :
1762 : 0 : input_unregister_device(old_dev);
1763 : :
1764 [ # # ][ # # ]: 0 : if (parent && parent->pt_activate)
1765 : 0 : parent->pt_activate(parent);
1766 : :
1767 : 0 : return count;
1768 : : }
1769 : :
1770 : 0 : static ssize_t psmouse_attr_set_rate(struct psmouse *psmouse, void *data, const char *buf, size_t count)
1771 : : {
1772 : : unsigned int value;
1773 : : int err;
1774 : :
1775 : 0 : err = kstrtouint(buf, 10, &value);
1776 [ # # ]: 0 : if (err)
1777 : : return err;
1778 : :
1779 : 0 : psmouse->set_rate(psmouse, value);
1780 : 0 : return count;
1781 : : }
1782 : :
1783 : 0 : static ssize_t psmouse_attr_set_resolution(struct psmouse *psmouse, void *data, const char *buf, size_t count)
1784 : : {
1785 : : unsigned int value;
1786 : : int err;
1787 : :
1788 : 0 : err = kstrtouint(buf, 10, &value);
1789 [ # # ]: 0 : if (err)
1790 : : return err;
1791 : :
1792 : 0 : psmouse->set_resolution(psmouse, value);
1793 : 0 : return count;
1794 : : }
1795 : :
1796 : :
1797 : 0 : static int psmouse_set_maxproto(const char *val, const struct kernel_param *kp)
1798 : : {
1799 : : const struct psmouse_protocol *proto;
1800 : :
1801 [ # # ]: 0 : if (!val)
1802 : : return -EINVAL;
1803 : :
1804 : 0 : proto = psmouse_protocol_by_name(val, strlen(val));
1805 : :
1806 [ # # ][ # # ]: 0 : if (!proto || !proto->maxproto)
1807 : : return -EINVAL;
1808 : :
1809 : 0 : *((unsigned int *)kp->arg) = proto->type;
1810 : :
1811 : 0 : return 0;
1812 : : }
1813 : :
1814 : 0 : static int psmouse_get_maxproto(char *buffer, const struct kernel_param *kp)
1815 : : {
1816 : 0 : int type = *((unsigned int *)kp->arg);
1817 : :
1818 : 0 : return sprintf(buffer, "%s", psmouse_protocol_by_type(type)->name);
1819 : : }
1820 : :
1821 : 0 : static int __init psmouse_init(void)
1822 : : {
1823 : : int err;
1824 : :
1825 : : lifebook_module_init();
1826 : 0 : synaptics_module_init();
1827 : : hgpk_module_init();
1828 : :
1829 : 0 : kpsmoused_wq = create_singlethread_workqueue("kpsmoused");
1830 [ # # ]: 0 : if (!kpsmoused_wq) {
1831 : 0 : pr_err("failed to create kpsmoused workqueue\n");
1832 : 0 : return -ENOMEM;
1833 : : }
1834 : :
1835 : 0 : err = serio_register_driver(&psmouse_drv);
1836 [ # # ]: 0 : if (err)
1837 : 0 : destroy_workqueue(kpsmoused_wq);
1838 : :
1839 : 0 : return err;
1840 : : }
1841 : :
1842 : 0 : static void __exit psmouse_exit(void)
1843 : : {
1844 : 0 : serio_unregister_driver(&psmouse_drv);
1845 : 0 : destroy_workqueue(kpsmoused_wq);
1846 : 0 : }
1847 : :
1848 : : module_init(psmouse_init);
1849 : : module_exit(psmouse_exit);
|
