Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * PS/2 mouse driver
0004  *
0005  * Copyright (c) 1999-2002 Vojtech Pavlik
0006  * Copyright (c) 2003-2004 Dmitry Torokhov
0007  */
0008 
0009 
0010 #define pr_fmt(fmt)     KBUILD_MODNAME ": " fmt
0011 #define psmouse_fmt(fmt)    fmt
0012 
0013 #include <linux/bitops.h>
0014 #include <linux/delay.h>
0015 #include <linux/module.h>
0016 #include <linux/slab.h>
0017 #include <linux/interrupt.h>
0018 #include <linux/input.h>
0019 #include <linux/serio.h>
0020 #include <linux/init.h>
0021 #include <linux/libps2.h>
0022 #include <linux/mutex.h>
0023 #include <linux/types.h>
0024 
0025 #include "psmouse.h"
0026 #include "synaptics.h"
0027 #include "logips2pp.h"
0028 #include "alps.h"
0029 #include "hgpk.h"
0030 #include "lifebook.h"
0031 #include "trackpoint.h"
0032 #include "touchkit_ps2.h"
0033 #include "elantech.h"
0034 #include "sentelic.h"
0035 #include "cypress_ps2.h"
0036 #include "focaltech.h"
0037 #include "vmmouse.h"
0038 #include "byd.h"
0039 
0040 #define DRIVER_DESC "PS/2 mouse driver"
0041 
0042 MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
0043 MODULE_DESCRIPTION(DRIVER_DESC);
0044 MODULE_LICENSE("GPL");
0045 
0046 static unsigned int psmouse_max_proto = PSMOUSE_AUTO;
0047 static int psmouse_set_maxproto(const char *val, const struct kernel_param *);
0048 static int psmouse_get_maxproto(char *buffer, const struct kernel_param *kp);
0049 static const struct kernel_param_ops param_ops_proto_abbrev = {
0050     .set = psmouse_set_maxproto,
0051     .get = psmouse_get_maxproto,
0052 };
0053 #define param_check_proto_abbrev(name, p)   __param_check(name, p, unsigned int)
0054 module_param_named(proto, psmouse_max_proto, proto_abbrev, 0644);
0055 MODULE_PARM_DESC(proto, "Highest protocol extension to probe (bare, imps, exps, any). Useful for KVM switches.");
0056 
0057 static unsigned int psmouse_resolution = 200;
0058 module_param_named(resolution, psmouse_resolution, uint, 0644);
0059 MODULE_PARM_DESC(resolution, "Resolution, in dpi.");
0060 
0061 static unsigned int psmouse_rate = 100;
0062 module_param_named(rate, psmouse_rate, uint, 0644);
0063 MODULE_PARM_DESC(rate, "Report rate, in reports per second.");
0064 
0065 static bool psmouse_smartscroll = true;
0066 module_param_named(smartscroll, psmouse_smartscroll, bool, 0644);
0067 MODULE_PARM_DESC(smartscroll, "Logitech Smartscroll autorepeat, 1 = enabled (default), 0 = disabled.");
0068 
0069 static bool psmouse_a4tech_2wheels;
0070 module_param_named(a4tech_workaround, psmouse_a4tech_2wheels, bool, 0644);
0071 MODULE_PARM_DESC(a4tech_workaround, "A4Tech second scroll wheel workaround, 1 = enabled, 0 = disabled (default).");
0072 
0073 static unsigned int psmouse_resetafter = 5;
0074 module_param_named(resetafter, psmouse_resetafter, uint, 0644);
0075 MODULE_PARM_DESC(resetafter, "Reset device after so many bad packets (0 = never).");
0076 
0077 static unsigned int psmouse_resync_time;
0078 module_param_named(resync_time, psmouse_resync_time, uint, 0644);
0079 MODULE_PARM_DESC(resync_time, "How long can mouse stay idle before forcing resync (in seconds, 0 = never).");
0080 
0081 PSMOUSE_DEFINE_ATTR(protocol, S_IWUSR | S_IRUGO,
0082             NULL,
0083             psmouse_attr_show_protocol, psmouse_attr_set_protocol);
0084 PSMOUSE_DEFINE_ATTR(rate, S_IWUSR | S_IRUGO,
0085             (void *) offsetof(struct psmouse, rate),
0086             psmouse_show_int_attr, psmouse_attr_set_rate);
0087 PSMOUSE_DEFINE_ATTR(resolution, S_IWUSR | S_IRUGO,
0088             (void *) offsetof(struct psmouse, resolution),
0089             psmouse_show_int_attr, psmouse_attr_set_resolution);
0090 PSMOUSE_DEFINE_ATTR(resetafter, S_IWUSR | S_IRUGO,
0091             (void *) offsetof(struct psmouse, resetafter),
0092             psmouse_show_int_attr, psmouse_set_int_attr);
0093 PSMOUSE_DEFINE_ATTR(resync_time, S_IWUSR | S_IRUGO,
0094             (void *) offsetof(struct psmouse, resync_time),
0095             psmouse_show_int_attr, psmouse_set_int_attr);
0096 
0097 static struct attribute *psmouse_attributes[] = {
0098     &psmouse_attr_protocol.dattr.attr,
0099     &psmouse_attr_rate.dattr.attr,
0100     &psmouse_attr_resolution.dattr.attr,
0101     &psmouse_attr_resetafter.dattr.attr,
0102     &psmouse_attr_resync_time.dattr.attr,
0103     NULL
0104 };
0105 
0106 static const struct attribute_group psmouse_attribute_group = {
0107     .attrs  = psmouse_attributes,
0108 };
0109 
0110 /*
0111  * psmouse_mutex protects all operations changing state of mouse
0112  * (connecting, disconnecting, changing rate or resolution via
0113  * sysfs). We could use a per-device semaphore but since there
0114  * rarely more than one PS/2 mouse connected and since semaphore
0115  * is taken in "slow" paths it is not worth it.
0116  */
0117 static DEFINE_MUTEX(psmouse_mutex);
0118 
0119 static struct workqueue_struct *kpsmoused_wq;
0120 
0121 void psmouse_report_standard_buttons(struct input_dev *dev, u8 buttons)
0122 {
0123     input_report_key(dev, BTN_LEFT,   buttons & BIT(0));
0124     input_report_key(dev, BTN_MIDDLE, buttons & BIT(2));
0125     input_report_key(dev, BTN_RIGHT,  buttons & BIT(1));
0126 }
0127 
0128 void psmouse_report_standard_motion(struct input_dev *dev, u8 *packet)
0129 {
0130     int x, y;
0131 
0132     x = packet[1] ? packet[1] - ((packet[0] << 4) & 0x100) : 0;
0133     y = packet[2] ? packet[2] - ((packet[0] << 3) & 0x100) : 0;
0134 
0135     input_report_rel(dev, REL_X, x);
0136     input_report_rel(dev, REL_Y, -y);
0137 }
0138 
0139 void psmouse_report_standard_packet(struct input_dev *dev, u8 *packet)
0140 {
0141     psmouse_report_standard_buttons(dev, packet[0]);
0142     psmouse_report_standard_motion(dev, packet);
0143 }
0144 
0145 /*
0146  * psmouse_process_byte() analyzes the PS/2 data stream and reports
0147  * relevant events to the input module once full packet has arrived.
0148  */
0149 psmouse_ret_t psmouse_process_byte(struct psmouse *psmouse)
0150 {
0151     struct input_dev *dev = psmouse->dev;
0152     u8 *packet = psmouse->packet;
0153     int wheel;
0154 
0155     if (psmouse->pktcnt < psmouse->pktsize)
0156         return PSMOUSE_GOOD_DATA;
0157 
0158     /* Full packet accumulated, process it */
0159 
0160     switch (psmouse->protocol->type) {
0161     case PSMOUSE_IMPS:
0162         /* IntelliMouse has scroll wheel */
0163         input_report_rel(dev, REL_WHEEL, -(s8) packet[3]);
0164         break;
0165 
0166     case PSMOUSE_IMEX:
0167         /* Scroll wheel and buttons on IntelliMouse Explorer */
0168         switch (packet[3] & 0xC0) {
0169         case 0x80: /* vertical scroll on IntelliMouse Explorer 4.0 */
0170             input_report_rel(dev, REL_WHEEL,
0171                      -sign_extend32(packet[3], 5));
0172             break;
0173         case 0x40: /* horizontal scroll on IntelliMouse Explorer 4.0 */
0174             input_report_rel(dev, REL_HWHEEL,
0175                      -sign_extend32(packet[3], 5));
0176             break;
0177         case 0x00:
0178         case 0xC0:
0179             wheel = sign_extend32(packet[3], 3);
0180 
0181             /*
0182              * Some A4Tech mice have two scroll wheels, with first
0183              * one reporting +/-1 in the lower nibble, and second
0184              * one reporting +/-2.
0185              */
0186             if (psmouse_a4tech_2wheels && abs(wheel) > 1)
0187                 input_report_rel(dev, REL_HWHEEL, wheel / 2);
0188             else
0189                 input_report_rel(dev, REL_WHEEL, -wheel);
0190 
0191             input_report_key(dev, BTN_SIDE,  packet[3] & BIT(4));
0192             input_report_key(dev, BTN_EXTRA, packet[3] & BIT(5));
0193             break;
0194         }
0195         break;
0196 
0197     case PSMOUSE_GENPS:
0198         /* Report scroll buttons on NetMice */
0199         input_report_rel(dev, REL_WHEEL, -(s8) packet[3]);
0200 
0201         /* Extra buttons on Genius NewNet 3D */
0202         input_report_key(dev, BTN_SIDE,  packet[0] & BIT(6));
0203         input_report_key(dev, BTN_EXTRA, packet[0] & BIT(7));
0204         break;
0205 
0206     case PSMOUSE_THINKPS:
0207         /* Extra button on ThinkingMouse */
0208         input_report_key(dev, BTN_EXTRA, packet[0] & BIT(3));
0209 
0210         /*
0211          * Without this bit of weirdness moving up gives wildly
0212          * high Y changes.
0213          */
0214         packet[1] |= (packet[0] & 0x40) << 1;
0215         break;
0216 
0217     case PSMOUSE_CORTRON:
0218         /*
0219          * Cortron PS2 Trackball reports SIDE button in the
0220          * 4th bit of the first byte.
0221          */
0222         input_report_key(dev, BTN_SIDE, packet[0] & BIT(3));
0223         packet[0] |= BIT(3);
0224         break;
0225 
0226     default:
0227         break;
0228     }
0229 
0230     /* Generic PS/2 Mouse */
0231     packet[0] |= psmouse->extra_buttons;
0232     psmouse_report_standard_packet(dev, packet);
0233 
0234     input_sync(dev);
0235 
0236     return PSMOUSE_FULL_PACKET;
0237 }
0238 
0239 void psmouse_queue_work(struct psmouse *psmouse, struct delayed_work *work,
0240         unsigned long delay)
0241 {
0242     queue_delayed_work(kpsmoused_wq, work, delay);
0243 }
0244 
0245 /*
0246  * __psmouse_set_state() sets new psmouse state and resets all flags.
0247  */
0248 static inline void __psmouse_set_state(struct psmouse *psmouse, enum psmouse_state new_state)
0249 {
0250     psmouse->state = new_state;
0251     psmouse->pktcnt = psmouse->out_of_sync_cnt = 0;
0252     psmouse->ps2dev.flags = 0;
0253     psmouse->last = jiffies;
0254 }
0255 
0256 /*
0257  * psmouse_set_state() sets new psmouse state and resets all flags and
0258  * counters while holding serio lock so fighting with interrupt handler
0259  * is not a concern.
0260  */
0261 void psmouse_set_state(struct psmouse *psmouse, enum psmouse_state new_state)
0262 {
0263     serio_pause_rx(psmouse->ps2dev.serio);
0264     __psmouse_set_state(psmouse, new_state);
0265     serio_continue_rx(psmouse->ps2dev.serio);
0266 }
0267 
0268 /*
0269  * psmouse_handle_byte() processes one byte of the input data stream
0270  * by calling corresponding protocol handler.
0271  */
0272 static int psmouse_handle_byte(struct psmouse *psmouse)
0273 {
0274     psmouse_ret_t rc = psmouse->protocol_handler(psmouse);
0275 
0276     switch (rc) {
0277     case PSMOUSE_BAD_DATA:
0278         if (psmouse->state == PSMOUSE_ACTIVATED) {
0279             psmouse_warn(psmouse,
0280                      "%s at %s lost sync at byte %d\n",
0281                      psmouse->name, psmouse->phys,
0282                      psmouse->pktcnt);
0283             if (++psmouse->out_of_sync_cnt == psmouse->resetafter) {
0284                 __psmouse_set_state(psmouse, PSMOUSE_IGNORE);
0285                 psmouse_notice(psmouse,
0286                         "issuing reconnect request\n");
0287                 serio_reconnect(psmouse->ps2dev.serio);
0288                 return -EIO;
0289             }
0290         }
0291         psmouse->pktcnt = 0;
0292         break;
0293 
0294     case PSMOUSE_FULL_PACKET:
0295         psmouse->pktcnt = 0;
0296         if (psmouse->out_of_sync_cnt) {
0297             psmouse->out_of_sync_cnt = 0;
0298             psmouse_notice(psmouse,
0299                     "%s at %s - driver resynced.\n",
0300                     psmouse->name, psmouse->phys);
0301         }
0302         break;
0303 
0304     case PSMOUSE_GOOD_DATA:
0305         break;
0306     }
0307     return 0;
0308 }
0309 
0310 static void psmouse_handle_oob_data(struct psmouse *psmouse, u8 data)
0311 {
0312     switch (psmouse->oob_data_type) {
0313     case PSMOUSE_OOB_NONE:
0314         psmouse->oob_data_type = data;
0315         break;
0316 
0317     case PSMOUSE_OOB_EXTRA_BTNS:
0318         psmouse_report_standard_buttons(psmouse->dev, data);
0319         input_sync(psmouse->dev);
0320 
0321         psmouse->extra_buttons = data;
0322         psmouse->oob_data_type = PSMOUSE_OOB_NONE;
0323         break;
0324 
0325     default:
0326         psmouse_warn(psmouse,
0327                  "unknown OOB_DATA type: 0x%02x\n",
0328                  psmouse->oob_data_type);
0329         psmouse->oob_data_type = PSMOUSE_OOB_NONE;
0330         break;
0331     }
0332 }
0333 
0334 /*
0335  * psmouse_interrupt() handles incoming characters, either passing them
0336  * for normal processing or gathering them as command response.
0337  */
0338 static irqreturn_t psmouse_interrupt(struct serio *serio,
0339                      u8 data, unsigned int flags)
0340 {
0341     struct psmouse *psmouse = serio_get_drvdata(serio);
0342 
0343     if (psmouse->state == PSMOUSE_IGNORE)
0344         goto out;
0345 
0346     if (unlikely((flags & SERIO_TIMEOUT) ||
0347              ((flags & SERIO_PARITY) &&
0348               !psmouse->protocol->ignore_parity))) {
0349 
0350         if (psmouse->state == PSMOUSE_ACTIVATED)
0351             psmouse_warn(psmouse,
0352                      "bad data from KBC -%s%s\n",
0353                      flags & SERIO_TIMEOUT ? " timeout" : "",
0354                      flags & SERIO_PARITY ? " bad parity" : "");
0355         ps2_cmd_aborted(&psmouse->ps2dev);
0356         goto out;
0357     }
0358 
0359     if (flags & SERIO_OOB_DATA) {
0360         psmouse_handle_oob_data(psmouse, data);
0361         goto out;
0362     }
0363 
0364     if (unlikely(psmouse->ps2dev.flags & PS2_FLAG_ACK))
0365         if  (ps2_handle_ack(&psmouse->ps2dev, data))
0366             goto out;
0367 
0368     if (unlikely(psmouse->ps2dev.flags & PS2_FLAG_CMD))
0369         if  (ps2_handle_response(&psmouse->ps2dev, data))
0370             goto out;
0371 
0372     pm_wakeup_event(&serio->dev, 0);
0373 
0374     if (psmouse->state <= PSMOUSE_RESYNCING)
0375         goto out;
0376 
0377     if (psmouse->state == PSMOUSE_ACTIVATED &&
0378         psmouse->pktcnt && time_after(jiffies, psmouse->last + HZ/2)) {
0379         psmouse_info(psmouse, "%s at %s lost synchronization, throwing %d bytes away.\n",
0380                  psmouse->name, psmouse->phys, psmouse->pktcnt);
0381         psmouse->badbyte = psmouse->packet[0];
0382         __psmouse_set_state(psmouse, PSMOUSE_RESYNCING);
0383         psmouse_queue_work(psmouse, &psmouse->resync_work, 0);
0384         goto out;
0385     }
0386 
0387     psmouse->packet[psmouse->pktcnt++] = data;
0388 
0389     /* Check if this is a new device announcement (0xAA 0x00) */
0390     if (unlikely(psmouse->packet[0] == PSMOUSE_RET_BAT && psmouse->pktcnt <= 2)) {
0391         if (psmouse->pktcnt == 1) {
0392             psmouse->last = jiffies;
0393             goto out;
0394         }
0395 
0396         if (psmouse->packet[1] == PSMOUSE_RET_ID ||
0397             (psmouse->protocol->type == PSMOUSE_HGPK &&
0398              psmouse->packet[1] == PSMOUSE_RET_BAT)) {
0399             __psmouse_set_state(psmouse, PSMOUSE_IGNORE);
0400             serio_reconnect(serio);
0401             goto out;
0402         }
0403 
0404         /* Not a new device, try processing first byte normally */
0405         psmouse->pktcnt = 1;
0406         if (psmouse_handle_byte(psmouse))
0407             goto out;
0408 
0409         psmouse->packet[psmouse->pktcnt++] = data;
0410     }
0411 
0412     /*
0413      * See if we need to force resync because mouse was idle for
0414      * too long.
0415      */
0416     if (psmouse->state == PSMOUSE_ACTIVATED &&
0417         psmouse->pktcnt == 1 && psmouse->resync_time &&
0418         time_after(jiffies, psmouse->last + psmouse->resync_time * HZ)) {
0419         psmouse->badbyte = psmouse->packet[0];
0420         __psmouse_set_state(psmouse, PSMOUSE_RESYNCING);
0421         psmouse_queue_work(psmouse, &psmouse->resync_work, 0);
0422         goto out;
0423     }
0424 
0425     psmouse->last = jiffies;
0426     psmouse_handle_byte(psmouse);
0427 
0428  out:
0429     return IRQ_HANDLED;
0430 }
0431 
0432 /*
0433  * psmouse_reset() resets the mouse into power-on state.
0434  */
0435 int psmouse_reset(struct psmouse *psmouse)
0436 {
0437     u8 param[2];
0438     int error;
0439 
0440     error = ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_RESET_BAT);
0441     if (error)
0442         return error;
0443 
0444     if (param[0] != PSMOUSE_RET_BAT && param[1] != PSMOUSE_RET_ID)
0445         return -EIO;
0446 
0447     return 0;
0448 }
0449 
0450 /*
0451  * Here we set the mouse resolution.
0452  */
0453 void psmouse_set_resolution(struct psmouse *psmouse, unsigned int resolution)
0454 {
0455     static const u8 params[] = { 0, 1, 2, 2, 3 };
0456     u8 p;
0457 
0458     if (resolution == 0 || resolution > 200)
0459         resolution = 200;
0460 
0461     p = params[resolution / 50];
0462     ps2_command(&psmouse->ps2dev, &p, PSMOUSE_CMD_SETRES);
0463     psmouse->resolution = 25 << p;
0464 }
0465 
0466 /*
0467  * Here we set the mouse report rate.
0468  */
0469 static void psmouse_set_rate(struct psmouse *psmouse, unsigned int rate)
0470 {
0471     static const u8 rates[] = { 200, 100, 80, 60, 40, 20, 10, 0 };
0472     u8 r;
0473     int i = 0;
0474 
0475     while (rates[i] > rate)
0476         i++;
0477     r = rates[i];
0478     ps2_command(&psmouse->ps2dev, &r, PSMOUSE_CMD_SETRATE);
0479     psmouse->rate = r;
0480 }
0481 
0482 /*
0483  * Here we set the mouse scaling.
0484  */
0485 static void psmouse_set_scale(struct psmouse *psmouse, enum psmouse_scale scale)
0486 {
0487     ps2_command(&psmouse->ps2dev, NULL,
0488             scale == PSMOUSE_SCALE21 ? PSMOUSE_CMD_SETSCALE21 :
0489                            PSMOUSE_CMD_SETSCALE11);
0490 }
0491 
0492 /*
0493  * psmouse_poll() - default poll handler. Everyone except for ALPS uses it.
0494  */
0495 static int psmouse_poll(struct psmouse *psmouse)
0496 {
0497     return ps2_command(&psmouse->ps2dev, psmouse->packet,
0498                PSMOUSE_CMD_POLL | (psmouse->pktsize << 8));
0499 }
0500 
0501 static bool psmouse_check_pnp_id(const char *id, const char * const ids[])
0502 {
0503     int i;
0504 
0505     for (i = 0; ids[i]; i++)
0506         if (!strcasecmp(id, ids[i]))
0507             return true;
0508 
0509     return false;
0510 }
0511 
0512 /*
0513  * psmouse_matches_pnp_id - check if psmouse matches one of the passed in ids.
0514  */
0515 bool psmouse_matches_pnp_id(struct psmouse *psmouse, const char * const ids[])
0516 {
0517     struct serio *serio = psmouse->ps2dev.serio;
0518     char *p, *fw_id_copy, *save_ptr;
0519     bool found = false;
0520 
0521     if (strncmp(serio->firmware_id, "PNP: ", 5))
0522         return false;
0523 
0524     fw_id_copy = kstrndup(&serio->firmware_id[5],
0525                   sizeof(serio->firmware_id) - 5,
0526                   GFP_KERNEL);
0527     if (!fw_id_copy)
0528         return false;
0529 
0530     save_ptr = fw_id_copy;
0531     while ((p = strsep(&fw_id_copy, " ")) != NULL) {
0532         if (psmouse_check_pnp_id(p, ids)) {
0533             found = true;
0534             break;
0535         }
0536     }
0537 
0538     kfree(save_ptr);
0539     return found;
0540 }
0541 
0542 /*
0543  * Genius NetMouse magic init.
0544  */
0545 static int genius_detect(struct psmouse *psmouse, bool set_properties)
0546 {
0547     struct ps2dev *ps2dev = &psmouse->ps2dev;
0548     u8 param[4];
0549 
0550     param[0] = 3;
0551     ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
0552     ps2_command(ps2dev,  NULL, PSMOUSE_CMD_SETSCALE11);
0553     ps2_command(ps2dev,  NULL, PSMOUSE_CMD_SETSCALE11);
0554     ps2_command(ps2dev,  NULL, PSMOUSE_CMD_SETSCALE11);
0555     ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO);
0556 
0557     if (param[0] != 0x00 || param[1] != 0x33 || param[2] != 0x55)
0558         return -ENODEV;
0559 
0560     if (set_properties) {
0561         __set_bit(BTN_MIDDLE, psmouse->dev->keybit);
0562         __set_bit(BTN_EXTRA, psmouse->dev->keybit);
0563         __set_bit(BTN_SIDE, psmouse->dev->keybit);
0564         __set_bit(REL_WHEEL, psmouse->dev->relbit);
0565 
0566         psmouse->vendor = "Genius";
0567         psmouse->name = "Mouse";
0568         psmouse->pktsize = 4;
0569     }
0570 
0571     return 0;
0572 }
0573 
0574 /*
0575  * IntelliMouse magic init.
0576  */
0577 static int intellimouse_detect(struct psmouse *psmouse, bool set_properties)
0578 {
0579     struct ps2dev *ps2dev = &psmouse->ps2dev;
0580     u8 param[2];
0581 
0582     param[0] = 200;
0583     ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
0584     param[0] = 100;
0585     ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
0586     param[0] =  80;
0587     ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
0588     ps2_command(ps2dev, param, PSMOUSE_CMD_GETID);
0589 
0590     if (param[0] != 3)
0591         return -ENODEV;
0592 
0593     if (set_properties) {
0594         __set_bit(BTN_MIDDLE, psmouse->dev->keybit);
0595         __set_bit(REL_WHEEL, psmouse->dev->relbit);
0596 
0597         if (!psmouse->vendor)
0598             psmouse->vendor = "Generic";
0599         if (!psmouse->name)
0600             psmouse->name = "Wheel Mouse";
0601         psmouse->pktsize = 4;
0602     }
0603 
0604     return 0;
0605 }
0606 
0607 /*
0608  * Try IntelliMouse/Explorer magic init.
0609  */
0610 static int im_explorer_detect(struct psmouse *psmouse, bool set_properties)
0611 {
0612     struct ps2dev *ps2dev = &psmouse->ps2dev;
0613     u8 param[2];
0614 
0615     intellimouse_detect(psmouse, 0);
0616 
0617     param[0] = 200;
0618     ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
0619     param[0] = 200;
0620     ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
0621     param[0] =  80;
0622     ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
0623     ps2_command(ps2dev, param, PSMOUSE_CMD_GETID);
0624 
0625     if (param[0] != 4)
0626         return -ENODEV;
0627 
0628     /* Magic to enable horizontal scrolling on IntelliMouse 4.0 */
0629     param[0] = 200;
0630     ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
0631     param[0] =  80;
0632     ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
0633     param[0] =  40;
0634     ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
0635 
0636     if (set_properties) {
0637         __set_bit(BTN_MIDDLE, psmouse->dev->keybit);
0638         __set_bit(REL_WHEEL, psmouse->dev->relbit);
0639         __set_bit(REL_HWHEEL, psmouse->dev->relbit);
0640         __set_bit(BTN_SIDE, psmouse->dev->keybit);
0641         __set_bit(BTN_EXTRA, psmouse->dev->keybit);
0642 
0643         if (!psmouse->vendor)
0644             psmouse->vendor = "Generic";
0645         if (!psmouse->name)
0646             psmouse->name = "Explorer Mouse";
0647         psmouse->pktsize = 4;
0648     }
0649 
0650     return 0;
0651 }
0652 
0653 /*
0654  * Kensington ThinkingMouse / ExpertMouse magic init.
0655  */
0656 static int thinking_detect(struct psmouse *psmouse, bool set_properties)
0657 {
0658     struct ps2dev *ps2dev = &psmouse->ps2dev;
0659     u8 param[2];
0660     static const u8 seq[] = { 20, 60, 40, 20, 20, 60, 40, 20, 20 };
0661     int i;
0662 
0663     param[0] = 10;
0664     ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
0665     param[0] = 0;
0666     ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
0667     for (i = 0; i < ARRAY_SIZE(seq); i++) {
0668         param[0] = seq[i];
0669         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
0670     }
0671     ps2_command(ps2dev, param, PSMOUSE_CMD_GETID);
0672 
0673     if (param[0] != 2)
0674         return -ENODEV;
0675 
0676     if (set_properties) {
0677         __set_bit(BTN_MIDDLE, psmouse->dev->keybit);
0678         __set_bit(BTN_EXTRA, psmouse->dev->keybit);
0679 
0680         psmouse->vendor = "Kensington";
0681         psmouse->name = "ThinkingMouse";
0682     }
0683 
0684     return 0;
0685 }
0686 
0687 /*
0688  * Bare PS/2 protocol "detection". Always succeeds.
0689  */
0690 static int ps2bare_detect(struct psmouse *psmouse, bool set_properties)
0691 {
0692     if (set_properties) {
0693         if (!psmouse->vendor)
0694             psmouse->vendor = "Generic";
0695         if (!psmouse->name)
0696             psmouse->name = "Mouse";
0697 
0698         /*
0699          * We have no way of figuring true number of buttons so let's
0700          * assume that the device has 3.
0701          */
0702         input_set_capability(psmouse->dev, EV_KEY, BTN_MIDDLE);
0703     }
0704 
0705     return 0;
0706 }
0707 
0708 /*
0709  * Cortron PS/2 protocol detection. There's no special way to detect it, so it
0710  * must be forced by sysfs protocol writing.
0711  */
0712 static int cortron_detect(struct psmouse *psmouse, bool set_properties)
0713 {
0714     if (set_properties) {
0715         psmouse->vendor = "Cortron";
0716         psmouse->name = "PS/2 Trackball";
0717 
0718         __set_bit(BTN_MIDDLE, psmouse->dev->keybit);
0719         __set_bit(BTN_SIDE, psmouse->dev->keybit);
0720     }
0721 
0722     return 0;
0723 }
0724 
0725 static const struct psmouse_protocol psmouse_protocols[] = {
0726     {
0727         .type       = PSMOUSE_PS2,
0728         .name       = "PS/2",
0729         .alias      = "bare",
0730         .maxproto   = true,
0731         .ignore_parity  = true,
0732         .detect     = ps2bare_detect,
0733         .try_passthru   = true,
0734     },
0735 #ifdef CONFIG_MOUSE_PS2_LOGIPS2PP
0736     {
0737         .type       = PSMOUSE_PS2PP,
0738         .name       = "PS2++",
0739         .alias      = "logitech",
0740         .detect     = ps2pp_detect,
0741     },
0742 #endif
0743     {
0744         .type       = PSMOUSE_THINKPS,
0745         .name       = "ThinkPS/2",
0746         .alias      = "thinkps",
0747         .detect     = thinking_detect,
0748     },
0749 #ifdef CONFIG_MOUSE_PS2_CYPRESS
0750     {
0751         .type       = PSMOUSE_CYPRESS,
0752         .name       = "CyPS/2",
0753         .alias      = "cypress",
0754         .detect     = cypress_detect,
0755         .init       = cypress_init,
0756     },
0757 #endif
0758     {
0759         .type       = PSMOUSE_GENPS,
0760         .name       = "GenPS/2",
0761         .alias      = "genius",
0762         .detect     = genius_detect,
0763     },
0764     {
0765         .type       = PSMOUSE_IMPS,
0766         .name       = "ImPS/2",
0767         .alias      = "imps",
0768         .maxproto   = true,
0769         .ignore_parity  = true,
0770         .detect     = intellimouse_detect,
0771         .try_passthru   = true,
0772     },
0773     {
0774         .type       = PSMOUSE_IMEX,
0775         .name       = "ImExPS/2",
0776         .alias      = "exps",
0777         .maxproto   = true,
0778         .ignore_parity  = true,
0779         .detect     = im_explorer_detect,
0780         .try_passthru   = true,
0781     },
0782 #ifdef CONFIG_MOUSE_PS2_SYNAPTICS
0783     {
0784         .type       = PSMOUSE_SYNAPTICS,
0785         .name       = "SynPS/2",
0786         .alias      = "synaptics",
0787         .detect     = synaptics_detect,
0788         .init       = synaptics_init_absolute,
0789     },
0790     {
0791         .type       = PSMOUSE_SYNAPTICS_RELATIVE,
0792         .name       = "SynRelPS/2",
0793         .alias      = "synaptics-relative",
0794         .detect     = synaptics_detect,
0795         .init       = synaptics_init_relative,
0796     },
0797 #endif
0798 #ifdef CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS
0799     {
0800         .type       = PSMOUSE_SYNAPTICS_SMBUS,
0801         .name       = "SynSMBus",
0802         .alias      = "synaptics-smbus",
0803         .detect     = synaptics_detect,
0804         .init       = synaptics_init_smbus,
0805         .smbus_companion = true,
0806     },
0807 #endif
0808 #ifdef CONFIG_MOUSE_PS2_ALPS
0809     {
0810         .type       = PSMOUSE_ALPS,
0811         .name       = "AlpsPS/2",
0812         .alias      = "alps",
0813         .detect     = alps_detect,
0814         .init       = alps_init,
0815     },
0816 #endif
0817 #ifdef CONFIG_MOUSE_PS2_LIFEBOOK
0818     {
0819         .type       = PSMOUSE_LIFEBOOK,
0820         .name       = "LBPS/2",
0821         .alias      = "lifebook",
0822         .detect     = lifebook_detect,
0823         .init       = lifebook_init,
0824     },
0825 #endif
0826 #ifdef CONFIG_MOUSE_PS2_TRACKPOINT
0827     {
0828         .type       = PSMOUSE_TRACKPOINT,
0829         .name       = "TPPS/2",
0830         .alias      = "trackpoint",
0831         .detect     = trackpoint_detect,
0832         .try_passthru   = true,
0833     },
0834 #endif
0835 #ifdef CONFIG_MOUSE_PS2_TOUCHKIT
0836     {
0837         .type       = PSMOUSE_TOUCHKIT_PS2,
0838         .name       = "touchkitPS/2",
0839         .alias      = "touchkit",
0840         .detect     = touchkit_ps2_detect,
0841     },
0842 #endif
0843 #ifdef CONFIG_MOUSE_PS2_OLPC
0844     {
0845         .type       = PSMOUSE_HGPK,
0846         .name       = "OLPC HGPK",
0847         .alias      = "hgpk",
0848         .detect     = hgpk_detect,
0849     },
0850 #endif
0851 #ifdef CONFIG_MOUSE_PS2_ELANTECH
0852     {
0853         .type       = PSMOUSE_ELANTECH,
0854         .name       = "ETPS/2",
0855         .alias      = "elantech",
0856         .detect     = elantech_detect,
0857         .init       = elantech_init_ps2,
0858     },
0859 #endif
0860 #ifdef CONFIG_MOUSE_PS2_ELANTECH_SMBUS
0861     {
0862         .type       = PSMOUSE_ELANTECH_SMBUS,
0863         .name       = "ETSMBus",
0864         .alias      = "elantech-smbus",
0865         .detect     = elantech_detect,
0866         .init       = elantech_init_smbus,
0867         .smbus_companion = true,
0868     },
0869 #endif
0870 #ifdef CONFIG_MOUSE_PS2_SENTELIC
0871     {
0872         .type       = PSMOUSE_FSP,
0873         .name       = "FSPPS/2",
0874         .alias      = "fsp",
0875         .detect     = fsp_detect,
0876         .init       = fsp_init,
0877     },
0878 #endif
0879     {
0880         .type       = PSMOUSE_CORTRON,
0881         .name       = "CortronPS/2",
0882         .alias      = "cortps",
0883         .detect     = cortron_detect,
0884     },
0885 #ifdef CONFIG_MOUSE_PS2_FOCALTECH
0886     {
0887         .type       = PSMOUSE_FOCALTECH,
0888         .name       = "FocalTechPS/2",
0889         .alias      = "focaltech",
0890         .detect     = focaltech_detect,
0891         .init       = focaltech_init,
0892     },
0893 #endif
0894 #ifdef CONFIG_MOUSE_PS2_VMMOUSE
0895     {
0896         .type       = PSMOUSE_VMMOUSE,
0897         .name       = VMMOUSE_PSNAME,
0898         .alias      = "vmmouse",
0899         .detect     = vmmouse_detect,
0900         .init       = vmmouse_init,
0901     },
0902 #endif
0903 #ifdef CONFIG_MOUSE_PS2_BYD
0904     {
0905         .type       = PSMOUSE_BYD,
0906         .name       = "BYDPS/2",
0907         .alias      = "byd",
0908         .detect     = byd_detect,
0909         .init       = byd_init,
0910     },
0911 #endif
0912     {
0913         .type       = PSMOUSE_AUTO,
0914         .name       = "auto",
0915         .alias      = "any",
0916         .maxproto   = true,
0917     },
0918 };
0919 
0920 static const struct psmouse_protocol *__psmouse_protocol_by_type(enum psmouse_type type)
0921 {
0922     int i;
0923 
0924     for (i = 0; i < ARRAY_SIZE(psmouse_protocols); i++)
0925         if (psmouse_protocols[i].type == type)
0926             return &psmouse_protocols[i];
0927 
0928     return NULL;
0929 }
0930 
0931 static const struct psmouse_protocol *psmouse_protocol_by_type(enum psmouse_type type)
0932 {
0933     const struct psmouse_protocol *proto;
0934 
0935     proto = __psmouse_protocol_by_type(type);
0936     if (proto)
0937         return proto;
0938 
0939     WARN_ON(1);
0940     return &psmouse_protocols[0];
0941 }
0942 
0943 static const struct psmouse_protocol *psmouse_protocol_by_name(const char *name, size_t len)
0944 {
0945     const struct psmouse_protocol *p;
0946     int i;
0947 
0948     for (i = 0; i < ARRAY_SIZE(psmouse_protocols); i++) {
0949         p = &psmouse_protocols[i];
0950 
0951         if ((strlen(p->name) == len && !strncmp(p->name, name, len)) ||
0952             (strlen(p->alias) == len && !strncmp(p->alias, name, len)))
0953             return &psmouse_protocols[i];
0954     }
0955 
0956     return NULL;
0957 }
0958 
0959 /*
0960  * Apply default settings to the psmouse structure. Most of them will
0961  * be overridden by individual protocol initialization routines.
0962  */
0963 static void psmouse_apply_defaults(struct psmouse *psmouse)
0964 {
0965     struct input_dev *input_dev = psmouse->dev;
0966 
0967     bitmap_zero(input_dev->evbit, EV_CNT);
0968     bitmap_zero(input_dev->keybit, KEY_CNT);
0969     bitmap_zero(input_dev->relbit, REL_CNT);
0970     bitmap_zero(input_dev->absbit, ABS_CNT);
0971     bitmap_zero(input_dev->mscbit, MSC_CNT);
0972 
0973     input_set_capability(input_dev, EV_KEY, BTN_LEFT);
0974     input_set_capability(input_dev, EV_KEY, BTN_RIGHT);
0975 
0976     input_set_capability(input_dev, EV_REL, REL_X);
0977     input_set_capability(input_dev, EV_REL, REL_Y);
0978 
0979     __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
0980 
0981     psmouse->protocol = &psmouse_protocols[0];
0982 
0983     psmouse->set_rate = psmouse_set_rate;
0984     psmouse->set_resolution = psmouse_set_resolution;
0985     psmouse->set_scale = psmouse_set_scale;
0986     psmouse->poll = psmouse_poll;
0987     psmouse->protocol_handler = psmouse_process_byte;
0988     psmouse->pktsize = 3;
0989     psmouse->reconnect = NULL;
0990     psmouse->fast_reconnect = NULL;
0991     psmouse->disconnect = NULL;
0992     psmouse->cleanup = NULL;
0993     psmouse->pt_activate = NULL;
0994     psmouse->pt_deactivate = NULL;
0995 }
0996 
0997 static bool psmouse_do_detect(int (*detect)(struct psmouse *, bool),
0998                   struct psmouse *psmouse, bool allow_passthrough,
0999                   bool set_properties)
1000 {
1001     if (psmouse->ps2dev.serio->id.type == SERIO_PS_PSTHRU &&
1002         !allow_passthrough) {
1003         return false;
1004     }
1005 
1006     if (set_properties)
1007         psmouse_apply_defaults(psmouse);
1008 
1009     return detect(psmouse, set_properties) == 0;
1010 }
1011 
1012 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     proto = __psmouse_protocol_by_type(type);
1020     if (!proto)
1021         return false;
1022 
1023     if (!psmouse_do_detect(proto->detect, psmouse, proto->try_passthru,
1024                    set_properties))
1025         return false;
1026 
1027     if (set_properties && proto->init && init_allowed) {
1028         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             if (*max_proto > PSMOUSE_IMEX)
1034                 *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 static int psmouse_extensions(struct psmouse *psmouse,
1048                   unsigned int max_proto, bool set_properties)
1049 {
1050     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     if (psmouse_do_detect(focaltech_detect,
1058                   psmouse, false, set_properties)) {
1059         if (max_proto > PSMOUSE_IMEX &&
1060             IS_ENABLED(CONFIG_MOUSE_PS2_FOCALTECH) &&
1061             (!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         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     if (psmouse_try_protocol(psmouse, PSMOUSE_LIFEBOOK, &max_proto,
1080                  set_properties, max_proto > PSMOUSE_IMEX))
1081         return PSMOUSE_LIFEBOOK;
1082 
1083     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     if (max_proto > PSMOUSE_IMEX &&
1092         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     if (max_proto > PSMOUSE_PS2 &&
1104         psmouse_do_detect(synaptics_detect,
1105                   psmouse, false, set_properties)) {
1106         synaptics_hardware = true;
1107 
1108         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                 if (!set_properties)
1117                     return PSMOUSE_SYNAPTICS;
1118 
1119                 ret = synaptics_init(psmouse);
1120                 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             max_proto = PSMOUSE_IMEX;
1131         }
1132 
1133         /*
1134          * Make sure that touchpad is in relative mode, gestures
1135          * (taps) are enabled.
1136          */
1137         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     if (max_proto > PSMOUSE_IMEX &&
1146         psmouse_try_protocol(psmouse, PSMOUSE_CYPRESS, &max_proto,
1147                  set_properties, true)) {
1148         return PSMOUSE_CYPRESS;
1149     }
1150 
1151     /* Try ALPS TouchPad */
1152     if (max_proto > PSMOUSE_IMEX) {
1153         ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_RESET_DIS);
1154         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     if (max_proto > PSMOUSE_IMEX &&
1161         psmouse_try_protocol(psmouse, PSMOUSE_HGPK, &max_proto,
1162                  set_properties, true)) {
1163         return PSMOUSE_HGPK;
1164     }
1165 
1166     /* Try Elantech touchpad */
1167     if (max_proto > PSMOUSE_IMEX &&
1168         psmouse_try_protocol(psmouse, PSMOUSE_ELANTECH,
1169                  &max_proto, set_properties, false)) {
1170         if (!set_properties)
1171             return PSMOUSE_ELANTECH;
1172 
1173         ret = elantech_init(psmouse);
1174         if (ret >= 0)
1175             return ret;
1176     }
1177 
1178     if (max_proto > PSMOUSE_IMEX) {
1179         if (psmouse_try_protocol(psmouse, PSMOUSE_GENPS,
1180                      &max_proto, set_properties, true))
1181             return PSMOUSE_GENPS;
1182 
1183         if (psmouse_try_protocol(psmouse, PSMOUSE_PS2PP,
1184                      &max_proto, set_properties, true))
1185             return PSMOUSE_PS2PP;
1186 
1187         if (psmouse_try_protocol(psmouse, PSMOUSE_TRACKPOINT,
1188                      &max_proto, set_properties, true))
1189             return PSMOUSE_TRACKPOINT;
1190 
1191         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     if (max_proto > PSMOUSE_IMEX &&
1201         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     ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_RESET_DIS);
1212     psmouse_reset(psmouse);
1213 
1214     if (max_proto >= PSMOUSE_IMEX &&
1215         psmouse_try_protocol(psmouse, PSMOUSE_IMEX,
1216                  &max_proto, set_properties, true)) {
1217         return PSMOUSE_IMEX;
1218     }
1219 
1220     if (max_proto >= PSMOUSE_IMPS &&
1221         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     psmouse_try_protocol(psmouse, PSMOUSE_PS2,
1231                  &max_proto, set_properties, true);
1232 
1233     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         psmouse_reset(psmouse);
1241     }
1242 
1243     return PSMOUSE_PS2;
1244 }
1245 
1246 /*
1247  * psmouse_probe() probes for a PS/2 mouse.
1248  */
1249 static int psmouse_probe(struct psmouse *psmouse)
1250 {
1251     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     param[0] = 0xa5;
1262     error = ps2_command(ps2dev, param, PSMOUSE_CMD_GETID);
1263     if (error)
1264         return error;
1265 
1266     if (param[0] != 0x00 && param[0] != 0x03 &&
1267         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     error = ps2_command(ps2dev, NULL, PSMOUSE_CMD_RESET_DIS);
1275     if (error)
1276         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 static void psmouse_initialize(struct psmouse *psmouse)
1286 {
1287     /*
1288      * We set the mouse report rate, resolution and scaling.
1289      */
1290     if (psmouse_max_proto != PSMOUSE_PS2) {
1291         psmouse->set_rate(psmouse, psmouse->rate);
1292         psmouse->set_resolution(psmouse, psmouse->resolution);
1293         psmouse->set_scale(psmouse, PSMOUSE_SCALE11);
1294     }
1295 }
1296 
1297 /*
1298  * psmouse_activate() enables the mouse so that we get motion reports from it.
1299  */
1300 int psmouse_activate(struct psmouse *psmouse)
1301 {
1302     if (ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_ENABLE)) {
1303         psmouse_warn(psmouse, "Failed to enable mouse on %s\n",
1304                  psmouse->ps2dev.serio->phys);
1305         return -1;
1306     }
1307 
1308     psmouse_set_state(psmouse, PSMOUSE_ACTIVATED);
1309     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 int psmouse_deactivate(struct psmouse *psmouse)
1317 {
1318     int error;
1319 
1320     error = ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_DISABLE);
1321     if (error) {
1322         psmouse_warn(psmouse, "Failed to deactivate mouse on %s: %d\n",
1323                  psmouse->ps2dev.serio->phys, error);
1324         return error;
1325     }
1326 
1327     psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
1328     return 0;
1329 }
1330 
1331 /*
1332  * psmouse_resync() attempts to re-validate current protocol.
1333  */
1334 static void psmouse_resync(struct work_struct *work)
1335 {
1336     struct psmouse *parent = NULL, *psmouse =
1337         container_of(work, struct psmouse, resync_work.work);
1338     struct serio *serio = psmouse->ps2dev.serio;
1339     psmouse_ret_t rc = PSMOUSE_GOOD_DATA;
1340     bool failed = false, enabled = false;
1341     int i;
1342 
1343     mutex_lock(&psmouse_mutex);
1344 
1345     if (psmouse->state != PSMOUSE_RESYNCING)
1346         goto out;
1347 
1348     if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
1349         parent = serio_get_drvdata(serio->parent);
1350         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     psmouse->num_resyncs++;
1364 
1365     if (ps2_sendbyte(&psmouse->ps2dev, PSMOUSE_CMD_DISABLE, 20)) {
1366         if (psmouse->num_resyncs < 3 || psmouse->acks_disable_command)
1367             failed = true;
1368     } else
1369         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     if (!failed) {
1379         if (psmouse->poll(psmouse))
1380             failed = true;
1381         else {
1382             psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
1383             for (i = 0; i < psmouse->pktsize; i++) {
1384                 psmouse->pktcnt++;
1385                 rc = psmouse->protocol_handler(psmouse);
1386                 if (rc != PSMOUSE_GOOD_DATA)
1387                     break;
1388             }
1389             if (rc != PSMOUSE_FULL_PACKET)
1390                 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     for (i = 0; i < 5; i++) {
1401         if (!ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_ENABLE)) {
1402             enabled = true;
1403             break;
1404         }
1405         msleep(200);
1406     }
1407 
1408     if (!enabled) {
1409         psmouse_warn(psmouse, "failed to re-enable mouse on %s\n",
1410                  psmouse->ps2dev.serio->phys);
1411         failed = true;
1412     }
1413 
1414     if (failed) {
1415         psmouse_set_state(psmouse, PSMOUSE_IGNORE);
1416         psmouse_info(psmouse,
1417                  "resync failed, issuing reconnect request\n");
1418         serio_reconnect(serio);
1419     } else
1420         psmouse_set_state(psmouse, PSMOUSE_ACTIVATED);
1421 
1422     if (parent)
1423         psmouse_activate(parent);
1424  out:
1425     mutex_unlock(&psmouse_mutex);
1426 }
1427 
1428 /*
1429  * psmouse_cleanup() resets the mouse into power-on state.
1430  */
1431 static void psmouse_cleanup(struct serio *serio)
1432 {
1433     struct psmouse *psmouse = serio_get_drvdata(serio);
1434     struct psmouse *parent = NULL;
1435 
1436     mutex_lock(&psmouse_mutex);
1437 
1438     if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
1439         parent = serio_get_drvdata(serio->parent);
1440         psmouse_deactivate(parent);
1441     }
1442 
1443     psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
1444 
1445     /*
1446      * Disable stream mode so cleanup routine can proceed undisturbed.
1447      */
1448     if (ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_DISABLE))
1449         psmouse_warn(psmouse, "Failed to disable mouse on %s\n",
1450                  psmouse->ps2dev.serio->phys);
1451 
1452     if (psmouse->cleanup)
1453         psmouse->cleanup(psmouse);
1454 
1455     /*
1456      * Reset the mouse to defaults (bare PS/2 protocol).
1457      */
1458     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     ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_ENABLE);
1465 
1466     if (parent) {
1467         if (parent->pt_deactivate)
1468             parent->pt_deactivate(parent);
1469 
1470         psmouse_activate(parent);
1471     }
1472 
1473     mutex_unlock(&psmouse_mutex);
1474 }
1475 
1476 /*
1477  * psmouse_disconnect() closes and frees.
1478  */
1479 static void psmouse_disconnect(struct serio *serio)
1480 {
1481     struct psmouse *psmouse = serio_get_drvdata(serio);
1482     struct psmouse *parent = NULL;
1483 
1484     sysfs_remove_group(&serio->dev.kobj, &psmouse_attribute_group);
1485 
1486     mutex_lock(&psmouse_mutex);
1487 
1488     psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
1489 
1490     /* make sure we don't have a resync in progress */
1491     mutex_unlock(&psmouse_mutex);
1492     flush_workqueue(kpsmoused_wq);
1493     mutex_lock(&psmouse_mutex);
1494 
1495     if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
1496         parent = serio_get_drvdata(serio->parent);
1497         psmouse_deactivate(parent);
1498     }
1499 
1500     if (psmouse->disconnect)
1501         psmouse->disconnect(psmouse);
1502 
1503     if (parent && parent->pt_deactivate)
1504         parent->pt_deactivate(parent);
1505 
1506     psmouse_set_state(psmouse, PSMOUSE_IGNORE);
1507 
1508     serio_close(serio);
1509     serio_set_drvdata(serio, NULL);
1510 
1511     if (psmouse->dev)
1512         input_unregister_device(psmouse->dev);
1513 
1514     kfree(psmouse);
1515 
1516     if (parent)
1517         psmouse_activate(parent);
1518 
1519     mutex_unlock(&psmouse_mutex);
1520 }
1521 
1522 static int psmouse_switch_protocol(struct psmouse *psmouse,
1523                    const struct psmouse_protocol *proto)
1524 {
1525     const struct psmouse_protocol *selected_proto;
1526     struct input_dev *input_dev = psmouse->dev;
1527     enum psmouse_type type;
1528 
1529     input_dev->dev.parent = &psmouse->ps2dev.serio->dev;
1530 
1531     if (proto && (proto->detect || proto->init)) {
1532         psmouse_apply_defaults(psmouse);
1533 
1534         if (proto->detect && proto->detect(psmouse, true) < 0)
1535             return -1;
1536 
1537         if (proto->init && proto->init(psmouse) < 0)
1538             return -1;
1539 
1540         selected_proto = proto;
1541     } else {
1542         type = psmouse_extensions(psmouse, psmouse_max_proto, true);
1543         selected_proto = psmouse_protocol_by_type(type);
1544     }
1545 
1546     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     if (psmouse->pktsize == 3)
1554         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     if (psmouse->resync_time && psmouse->poll(psmouse))
1563         psmouse->resync_time = 0;
1564 
1565     snprintf(psmouse->devname, sizeof(psmouse->devname), "%s %s %s",
1566          selected_proto->name, psmouse->vendor, psmouse->name);
1567 
1568     input_dev->name = psmouse->devname;
1569     input_dev->phys = psmouse->phys;
1570     input_dev->id.bustype = BUS_I8042;
1571     input_dev->id.vendor = 0x0002;
1572     input_dev->id.product = psmouse->protocol->type;
1573     input_dev->id.version = psmouse->model;
1574 
1575     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 static int psmouse_connect(struct serio *serio, struct serio_driver *drv)
1583 {
1584     struct psmouse *psmouse, *parent = NULL;
1585     struct input_dev *input_dev;
1586     int retval = 0, error = -ENOMEM;
1587 
1588     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     if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
1595         parent = serio_get_drvdata(serio->parent);
1596         psmouse_deactivate(parent);
1597     }
1598 
1599     psmouse = kzalloc(sizeof(struct psmouse), GFP_KERNEL);
1600     input_dev = input_allocate_device();
1601     if (!psmouse || !input_dev)
1602         goto err_free;
1603 
1604     ps2_init(&psmouse->ps2dev, serio);
1605     INIT_DELAYED_WORK(&psmouse->resync_work, psmouse_resync);
1606     psmouse->dev = input_dev;
1607     snprintf(psmouse->phys, sizeof(psmouse->phys), "%s/input0", serio->phys);
1608 
1609     psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
1610 
1611     serio_set_drvdata(serio, psmouse);
1612 
1613     error = serio_open(serio, drv);
1614     if (error)
1615         goto err_clear_drvdata;
1616 
1617     /* give PT device some time to settle down before probing */
1618     if (serio->id.type == SERIO_PS_PSTHRU)
1619         usleep_range(10000, 15000);
1620 
1621     if (psmouse_probe(psmouse) < 0) {
1622         error = -ENODEV;
1623         goto err_close_serio;
1624     }
1625 
1626     psmouse->rate = psmouse_rate;
1627     psmouse->resolution = psmouse_resolution;
1628     psmouse->resetafter = psmouse_resetafter;
1629     psmouse->resync_time = parent ? 0 : psmouse_resync_time;
1630     psmouse->smartscroll = psmouse_smartscroll;
1631 
1632     psmouse_switch_protocol(psmouse, NULL);
1633 
1634     if (!psmouse->protocol->smbus_companion) {
1635         psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
1636         psmouse_initialize(psmouse);
1637 
1638         error = input_register_device(input_dev);
1639         if (error)
1640             goto err_protocol_disconnect;
1641     } else {
1642         /* Smbus companion will be reporting events, not us. */
1643         input_free_device(input_dev);
1644         psmouse->dev = input_dev = NULL;
1645     }
1646 
1647     if (parent && parent->pt_activate)
1648         parent->pt_activate(parent);
1649 
1650     error = sysfs_create_group(&serio->dev.kobj, &psmouse_attribute_group);
1651     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     if (!psmouse->protocol->smbus_companion)
1659         psmouse_activate(psmouse);
1660 
1661  out:
1662     /* If this is a pass-through port the parent needs to be re-activated */
1663     if (parent)
1664         psmouse_activate(parent);
1665 
1666     mutex_unlock(&psmouse_mutex);
1667     return retval;
1668 
1669  err_pt_deactivate:
1670     if (parent && parent->pt_deactivate)
1671         parent->pt_deactivate(parent);
1672     if (input_dev) {
1673         input_unregister_device(input_dev);
1674         input_dev = NULL; /* so we don't try to free it below */
1675     }
1676  err_protocol_disconnect:
1677     if (psmouse->disconnect)
1678         psmouse->disconnect(psmouse);
1679     psmouse_set_state(psmouse, PSMOUSE_IGNORE);
1680  err_close_serio:
1681     serio_close(serio);
1682  err_clear_drvdata:
1683     serio_set_drvdata(serio, NULL);
1684  err_free:
1685     input_free_device(input_dev);
1686     kfree(psmouse);
1687 
1688     retval = error;
1689     goto out;
1690 }
1691 
1692 static int __psmouse_reconnect(struct serio *serio, bool fast_reconnect)
1693 {
1694     struct psmouse *psmouse = serio_get_drvdata(serio);
1695     struct psmouse *parent = NULL;
1696     int (*reconnect_handler)(struct psmouse *);
1697     enum psmouse_type type;
1698     int rc = -1;
1699 
1700     mutex_lock(&psmouse_mutex);
1701 
1702     if (fast_reconnect) {
1703         reconnect_handler = psmouse->fast_reconnect;
1704         if (!reconnect_handler) {
1705             rc = -ENOENT;
1706             goto out_unlock;
1707         }
1708     } else {
1709         reconnect_handler = psmouse->reconnect;
1710     }
1711 
1712     if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
1713         parent = serio_get_drvdata(serio->parent);
1714         psmouse_deactivate(parent);
1715     }
1716 
1717     psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
1718 
1719     if (reconnect_handler) {
1720         if (reconnect_handler(psmouse))
1721             goto out;
1722     } else {
1723         psmouse_reset(psmouse);
1724 
1725         if (psmouse_probe(psmouse) < 0)
1726             goto out;
1727 
1728         type = psmouse_extensions(psmouse, psmouse_max_proto, false);
1729         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     if (!psmouse->protocol->smbus_companion) {
1738         psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
1739         psmouse_initialize(psmouse);
1740     }
1741 
1742     if (parent && parent->pt_activate)
1743         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     if (!psmouse->protocol->smbus_companion)
1750         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     if (parent)
1757         psmouse_activate(parent);
1758 
1759 out_unlock:
1760     mutex_unlock(&psmouse_mutex);
1761     return rc;
1762 }
1763 
1764 static int psmouse_reconnect(struct serio *serio)
1765 {
1766     return __psmouse_reconnect(serio, false);
1767 }
1768 
1769 static int psmouse_fast_reconnect(struct serio *serio)
1770 {
1771     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 ssize_t psmouse_attr_show_helper(struct device *dev, struct device_attribute *devattr,
1807                  char *buf)
1808 {
1809     struct serio *serio = to_serio_port(dev);
1810     struct psmouse_attribute *attr = to_psmouse_attr(devattr);
1811     struct psmouse *psmouse = serio_get_drvdata(serio);
1812 
1813     if (psmouse->protocol->smbus_companion &&
1814             devattr != &psmouse_attr_protocol.dattr)
1815         return -ENOENT;
1816 
1817     return attr->show(psmouse, attr->data, buf);
1818 }
1819 
1820 ssize_t psmouse_attr_set_helper(struct device *dev, struct device_attribute *devattr,
1821                 const char *buf, size_t count)
1822 {
1823     struct serio *serio = to_serio_port(dev);
1824     struct psmouse_attribute *attr = to_psmouse_attr(devattr);
1825     struct psmouse *psmouse, *parent = NULL;
1826     int retval;
1827 
1828     retval = mutex_lock_interruptible(&psmouse_mutex);
1829     if (retval)
1830         goto out;
1831 
1832     psmouse = serio_get_drvdata(serio);
1833 
1834     if (psmouse->protocol->smbus_companion &&
1835             devattr != &psmouse_attr_protocol.dattr) {
1836         retval = -ENOENT;
1837         goto out_unlock;
1838     }
1839 
1840     if (attr->protect) {
1841         if (psmouse->state == PSMOUSE_IGNORE) {
1842             retval = -ENODEV;
1843             goto out_unlock;
1844         }
1845 
1846         if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
1847             parent = serio_get_drvdata(serio->parent);
1848             psmouse_deactivate(parent);
1849         }
1850 
1851         if (!psmouse->protocol->smbus_companion)
1852             psmouse_deactivate(psmouse);
1853     }
1854 
1855     retval = attr->set(psmouse, attr->data, buf, count);
1856 
1857     if (attr->protect) {
1858         if (retval != -ENODEV && !psmouse->protocol->smbus_companion)
1859             psmouse_activate(psmouse);
1860 
1861         if (parent)
1862             psmouse_activate(parent);
1863     }
1864 
1865  out_unlock:
1866     mutex_unlock(&psmouse_mutex);
1867  out:
1868     return retval;
1869 }
1870 
1871 static ssize_t psmouse_show_int_attr(struct psmouse *psmouse, void *offset, char *buf)
1872 {
1873     unsigned int *field = (unsigned int *)((char *)psmouse + (size_t)offset);
1874 
1875     return sprintf(buf, "%u\n", *field);
1876 }
1877 
1878 static ssize_t psmouse_set_int_attr(struct psmouse *psmouse, void *offset, const char *buf, size_t count)
1879 {
1880     unsigned int *field = (unsigned int *)((char *)psmouse + (size_t)offset);
1881     unsigned int value;
1882     int err;
1883 
1884     err = kstrtouint(buf, 10, &value);
1885     if (err)
1886         return err;
1887 
1888     *field = value;
1889 
1890     return count;
1891 }
1892 
1893 static ssize_t psmouse_attr_show_protocol(struct psmouse *psmouse, void *data, char *buf)
1894 {
1895     return sprintf(buf, "%s\n", psmouse->protocol->name);
1896 }
1897 
1898 static ssize_t psmouse_attr_set_protocol(struct psmouse *psmouse, void *data, const char *buf, size_t count)
1899 {
1900     struct serio *serio = psmouse->ps2dev.serio;
1901     struct psmouse *parent = NULL;
1902     struct input_dev *old_dev, *new_dev;
1903     const struct psmouse_protocol *proto, *old_proto;
1904     int error;
1905     int retry = 0;
1906 
1907     proto = psmouse_protocol_by_name(buf, count);
1908     if (!proto)
1909         return -EINVAL;
1910 
1911     if (psmouse->protocol == proto)
1912         return count;
1913 
1914     new_dev = input_allocate_device();
1915     if (!new_dev)
1916         return -ENOMEM;
1917 
1918     while (!list_empty(&serio->children)) {
1919         if (++retry > 3) {
1920             psmouse_warn(psmouse,
1921                      "failed to destroy children ports, protocol change aborted.\n");
1922             input_free_device(new_dev);
1923             return -EIO;
1924         }
1925 
1926         mutex_unlock(&psmouse_mutex);
1927         serio_unregister_child_port(serio);
1928         mutex_lock(&psmouse_mutex);
1929 
1930         if (serio->drv != &psmouse_drv) {
1931             input_free_device(new_dev);
1932             return -ENODEV;
1933         }
1934 
1935         if (psmouse->protocol == proto) {
1936             input_free_device(new_dev);
1937             return count; /* switched by other thread */
1938         }
1939     }
1940 
1941     if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
1942         parent = serio_get_drvdata(serio->parent);
1943         if (parent->pt_deactivate)
1944             parent->pt_deactivate(parent);
1945     }
1946 
1947     old_dev = psmouse->dev;
1948     old_proto = psmouse->protocol;
1949 
1950     if (psmouse->disconnect)
1951         psmouse->disconnect(psmouse);
1952 
1953     psmouse_set_state(psmouse, PSMOUSE_IGNORE);
1954 
1955     psmouse->dev = new_dev;
1956     psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
1957 
1958     if (psmouse_switch_protocol(psmouse, proto) < 0) {
1959         psmouse_reset(psmouse);
1960         /* default to PSMOUSE_PS2 */
1961         psmouse_switch_protocol(psmouse, &psmouse_protocols[0]);
1962     }
1963 
1964     psmouse_initialize(psmouse);
1965     psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
1966 
1967     if (psmouse->protocol->smbus_companion) {
1968         input_free_device(psmouse->dev);
1969         psmouse->dev = NULL;
1970     } else {
1971         error = input_register_device(psmouse->dev);
1972         if (error) {
1973             if (psmouse->disconnect)
1974                 psmouse->disconnect(psmouse);
1975 
1976             psmouse_set_state(psmouse, PSMOUSE_IGNORE);
1977             input_free_device(new_dev);
1978             psmouse->dev = old_dev;
1979             psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
1980             psmouse_switch_protocol(psmouse, old_proto);
1981             psmouse_initialize(psmouse);
1982             psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
1983 
1984             return error;
1985         }
1986     }
1987 
1988     if (old_dev)
1989         input_unregister_device(old_dev);
1990 
1991     if (parent && parent->pt_activate)
1992         parent->pt_activate(parent);
1993 
1994     return count;
1995 }
1996 
1997 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     err = kstrtouint(buf, 10, &value);
2003     if (err)
2004         return err;
2005 
2006     psmouse->set_rate(psmouse, value);
2007     return count;
2008 }
2009 
2010 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     err = kstrtouint(buf, 10, &value);
2016     if (err)
2017         return err;
2018 
2019     psmouse->set_resolution(psmouse, value);
2020     return count;
2021 }
2022 
2023 
2024 static int psmouse_set_maxproto(const char *val, const struct kernel_param *kp)
2025 {
2026     const struct psmouse_protocol *proto;
2027 
2028     if (!val)
2029         return -EINVAL;
2030 
2031     proto = psmouse_protocol_by_name(val, strlen(val));
2032 
2033     if (!proto || !proto->maxproto)
2034         return -EINVAL;
2035 
2036     *((unsigned int *)kp->arg) = proto->type;
2037 
2038     return 0;
2039 }
2040 
2041 static int psmouse_get_maxproto(char *buffer, const struct kernel_param *kp)
2042 {
2043     int type = *((unsigned int *)kp->arg);
2044 
2045     return sprintf(buffer, "%s\n", psmouse_protocol_by_type(type)->name);
2046 }
2047 
2048 static int __init psmouse_init(void)
2049 {
2050     int err;
2051 
2052     lifebook_module_init();
2053     synaptics_module_init();
2054     hgpk_module_init();
2055 
2056     err = psmouse_smbus_module_init();
2057     if (err)
2058         return err;
2059 
2060     kpsmoused_wq = alloc_ordered_workqueue("kpsmoused", 0);
2061     if (!kpsmoused_wq) {
2062         pr_err("failed to create kpsmoused workqueue\n");
2063         err = -ENOMEM;
2064         goto err_smbus_exit;
2065     }
2066 
2067     err = serio_register_driver(&psmouse_drv);
2068     if (err)
2069         goto err_destroy_wq;
2070 
2071     return 0;
2072 
2073 err_destroy_wq:
2074     destroy_workqueue(kpsmoused_wq);
2075 err_smbus_exit:
2076     psmouse_smbus_module_exit();
2077     return err;
2078 }
2079 
2080 static void __exit psmouse_exit(void)
2081 {
2082     serio_unregister_driver(&psmouse_drv);
2083     destroy_workqueue(kpsmoused_wq);
2084     psmouse_smbus_module_exit();
2085 }
2086 
2087 module_init(psmouse_init);
2088 module_exit(psmouse_exit);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!