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