psmouse-base.c 39 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592
  1. /*
  2. * PS/2 mouse driver
  3. *
  4. * Copyright (c) 1999-2002 Vojtech Pavlik
  5. * Copyright (c) 2003-2004 Dmitry Torokhov
  6. */
  7. /*
  8. * This program is free software; you can redistribute it and/or modify it
  9. * under the terms of the GNU General Public License version 2 as published by
  10. * the Free Software Foundation.
  11. */
  12. #include <linux/delay.h>
  13. #include <linux/module.h>
  14. #include <linux/moduleparam.h>
  15. #include <linux/slab.h>
  16. #include <linux/interrupt.h>
  17. #include <linux/input.h>
  18. #include <linux/serio.h>
  19. #include <linux/init.h>
  20. #include <linux/libps2.h>
  21. #include <linux/mutex.h>
  22. #include "psmouse.h"
  23. #include "synaptics.h"
  24. #include "logips2pp.h"
  25. #include "alps.h"
  26. #include "lifebook.h"
  27. #include "trackpoint.h"
  28. #include "touchkit_ps2.h"
  29. #define DRIVER_DESC "PS/2 mouse driver"
  30. MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
  31. MODULE_DESCRIPTION(DRIVER_DESC);
  32. MODULE_LICENSE("GPL");
  33. static unsigned int psmouse_max_proto = PSMOUSE_AUTO;
  34. static int psmouse_set_maxproto(const char *val, struct kernel_param *kp);
  35. static int psmouse_get_maxproto(char *buffer, struct kernel_param *kp);
  36. #define param_check_proto_abbrev(name, p) __param_check(name, p, unsigned int)
  37. #define param_set_proto_abbrev psmouse_set_maxproto
  38. #define param_get_proto_abbrev psmouse_get_maxproto
  39. module_param_named(proto, psmouse_max_proto, proto_abbrev, 0644);
  40. MODULE_PARM_DESC(proto, "Highest protocol extension to probe (bare, imps, exps, any). Useful for KVM switches.");
  41. static unsigned int psmouse_resolution = 200;
  42. module_param_named(resolution, psmouse_resolution, uint, 0644);
  43. MODULE_PARM_DESC(resolution, "Resolution, in dpi.");
  44. static unsigned int psmouse_rate = 100;
  45. module_param_named(rate, psmouse_rate, uint, 0644);
  46. MODULE_PARM_DESC(rate, "Report rate, in reports per second.");
  47. static unsigned int psmouse_smartscroll = 1;
  48. module_param_named(smartscroll, psmouse_smartscroll, bool, 0644);
  49. MODULE_PARM_DESC(smartscroll, "Logitech Smartscroll autorepeat, 1 = enabled (default), 0 = disabled.");
  50. static unsigned int psmouse_resetafter = 5;
  51. module_param_named(resetafter, psmouse_resetafter, uint, 0644);
  52. MODULE_PARM_DESC(resetafter, "Reset device after so many bad packets (0 = never).");
  53. static unsigned int psmouse_resync_time;
  54. module_param_named(resync_time, psmouse_resync_time, uint, 0644);
  55. MODULE_PARM_DESC(resync_time, "How long can mouse stay idle before forcing resync (in seconds, 0 = never).");
  56. PSMOUSE_DEFINE_ATTR(protocol, S_IWUSR | S_IRUGO,
  57. NULL,
  58. psmouse_attr_show_protocol, psmouse_attr_set_protocol);
  59. PSMOUSE_DEFINE_ATTR(rate, S_IWUSR | S_IRUGO,
  60. (void *) offsetof(struct psmouse, rate),
  61. psmouse_show_int_attr, psmouse_attr_set_rate);
  62. PSMOUSE_DEFINE_ATTR(resolution, S_IWUSR | S_IRUGO,
  63. (void *) offsetof(struct psmouse, resolution),
  64. psmouse_show_int_attr, psmouse_attr_set_resolution);
  65. PSMOUSE_DEFINE_ATTR(resetafter, S_IWUSR | S_IRUGO,
  66. (void *) offsetof(struct psmouse, resetafter),
  67. psmouse_show_int_attr, psmouse_set_int_attr);
  68. PSMOUSE_DEFINE_ATTR(resync_time, S_IWUSR | S_IRUGO,
  69. (void *) offsetof(struct psmouse, resync_time),
  70. psmouse_show_int_attr, psmouse_set_int_attr);
  71. static struct attribute *psmouse_attributes[] = {
  72. &psmouse_attr_protocol.dattr.attr,
  73. &psmouse_attr_rate.dattr.attr,
  74. &psmouse_attr_resolution.dattr.attr,
  75. &psmouse_attr_resetafter.dattr.attr,
  76. &psmouse_attr_resync_time.dattr.attr,
  77. NULL
  78. };
  79. static struct attribute_group psmouse_attribute_group = {
  80. .attrs = psmouse_attributes,
  81. };
  82. /*
  83. * psmouse_mutex protects all operations changing state of mouse
  84. * (connecting, disconnecting, changing rate or resolution via
  85. * sysfs). We could use a per-device semaphore but since there
  86. * rarely more than one PS/2 mouse connected and since semaphore
  87. * is taken in "slow" paths it is not worth it.
  88. */
  89. static DEFINE_MUTEX(psmouse_mutex);
  90. static struct workqueue_struct *kpsmoused_wq;
  91. struct psmouse_protocol {
  92. enum psmouse_type type;
  93. const char *name;
  94. const char *alias;
  95. int maxproto;
  96. int (*detect)(struct psmouse *, int);
  97. int (*init)(struct psmouse *);
  98. };
  99. /*
  100. * psmouse_process_byte() analyzes the PS/2 data stream and reports
  101. * relevant events to the input module once full packet has arrived.
  102. */
  103. static psmouse_ret_t psmouse_process_byte(struct psmouse *psmouse)
  104. {
  105. struct input_dev *dev = psmouse->dev;
  106. unsigned char *packet = psmouse->packet;
  107. if (psmouse->pktcnt < psmouse->pktsize)
  108. return PSMOUSE_GOOD_DATA;
  109. /*
  110. * Full packet accumulated, process it
  111. */
  112. /*
  113. * Scroll wheel on IntelliMice, scroll buttons on NetMice
  114. */
  115. if (psmouse->type == PSMOUSE_IMPS || psmouse->type == PSMOUSE_GENPS)
  116. input_report_rel(dev, REL_WHEEL, -(signed char) packet[3]);
  117. /*
  118. * Scroll wheel and buttons on IntelliMouse Explorer
  119. */
  120. if (psmouse->type == PSMOUSE_IMEX) {
  121. switch (packet[3] & 0xC0) {
  122. case 0x80: /* vertical scroll on IntelliMouse Explorer 4.0 */
  123. input_report_rel(dev, REL_WHEEL, (int) (packet[3] & 32) - (int) (packet[3] & 31));
  124. break;
  125. case 0x40: /* horizontal scroll on IntelliMouse Explorer 4.0 */
  126. input_report_rel(dev, REL_HWHEEL, (int) (packet[3] & 32) - (int) (packet[3] & 31));
  127. break;
  128. case 0x00:
  129. case 0xC0:
  130. input_report_rel(dev, REL_WHEEL, (int) (packet[3] & 8) - (int) (packet[3] & 7));
  131. input_report_key(dev, BTN_SIDE, (packet[3] >> 4) & 1);
  132. input_report_key(dev, BTN_EXTRA, (packet[3] >> 5) & 1);
  133. break;
  134. }
  135. }
  136. /*
  137. * Extra buttons on Genius NewNet 3D
  138. */
  139. if (psmouse->type == PSMOUSE_GENPS) {
  140. input_report_key(dev, BTN_SIDE, (packet[0] >> 6) & 1);
  141. input_report_key(dev, BTN_EXTRA, (packet[0] >> 7) & 1);
  142. }
  143. /*
  144. * Extra button on ThinkingMouse
  145. */
  146. if (psmouse->type == PSMOUSE_THINKPS) {
  147. input_report_key(dev, BTN_EXTRA, (packet[0] >> 3) & 1);
  148. /* Without this bit of weirdness moving up gives wildly high Y changes. */
  149. packet[1] |= (packet[0] & 0x40) << 1;
  150. }
  151. /*
  152. * Generic PS/2 Mouse
  153. */
  154. input_report_key(dev, BTN_LEFT, packet[0] & 1);
  155. input_report_key(dev, BTN_MIDDLE, (packet[0] >> 2) & 1);
  156. input_report_key(dev, BTN_RIGHT, (packet[0] >> 1) & 1);
  157. input_report_rel(dev, REL_X, packet[1] ? (int) packet[1] - (int) ((packet[0] << 4) & 0x100) : 0);
  158. input_report_rel(dev, REL_Y, packet[2] ? (int) ((packet[0] << 3) & 0x100) - (int) packet[2] : 0);
  159. input_sync(dev);
  160. return PSMOUSE_FULL_PACKET;
  161. }
  162. /*
  163. * __psmouse_set_state() sets new psmouse state and resets all flags.
  164. */
  165. static inline void __psmouse_set_state(struct psmouse *psmouse, enum psmouse_state new_state)
  166. {
  167. psmouse->state = new_state;
  168. psmouse->pktcnt = psmouse->out_of_sync = 0;
  169. psmouse->ps2dev.flags = 0;
  170. psmouse->last = jiffies;
  171. }
  172. /*
  173. * psmouse_set_state() sets new psmouse state and resets all flags and
  174. * counters while holding serio lock so fighting with interrupt handler
  175. * is not a concern.
  176. */
  177. static void psmouse_set_state(struct psmouse *psmouse, enum psmouse_state new_state)
  178. {
  179. serio_pause_rx(psmouse->ps2dev.serio);
  180. __psmouse_set_state(psmouse, new_state);
  181. serio_continue_rx(psmouse->ps2dev.serio);
  182. }
  183. /*
  184. * psmouse_handle_byte() processes one byte of the input data stream
  185. * by calling corresponding protocol handler.
  186. */
  187. static int psmouse_handle_byte(struct psmouse *psmouse)
  188. {
  189. psmouse_ret_t rc = psmouse->protocol_handler(psmouse);
  190. switch (rc) {
  191. case PSMOUSE_BAD_DATA:
  192. if (psmouse->state == PSMOUSE_ACTIVATED) {
  193. printk(KERN_WARNING "psmouse.c: %s at %s lost sync at byte %d\n",
  194. psmouse->name, psmouse->phys, psmouse->pktcnt);
  195. if (++psmouse->out_of_sync == psmouse->resetafter) {
  196. __psmouse_set_state(psmouse, PSMOUSE_IGNORE);
  197. printk(KERN_NOTICE "psmouse.c: issuing reconnect request\n");
  198. serio_reconnect(psmouse->ps2dev.serio);
  199. return -1;
  200. }
  201. }
  202. psmouse->pktcnt = 0;
  203. break;
  204. case PSMOUSE_FULL_PACKET:
  205. psmouse->pktcnt = 0;
  206. if (psmouse->out_of_sync) {
  207. psmouse->out_of_sync = 0;
  208. printk(KERN_NOTICE "psmouse.c: %s at %s - driver resynched.\n",
  209. psmouse->name, psmouse->phys);
  210. }
  211. break;
  212. case PSMOUSE_GOOD_DATA:
  213. break;
  214. }
  215. return 0;
  216. }
  217. /*
  218. * psmouse_interrupt() handles incoming characters, either passing them
  219. * for normal processing or gathering them as command response.
  220. */
  221. static irqreturn_t psmouse_interrupt(struct serio *serio,
  222. unsigned char data, unsigned int flags)
  223. {
  224. struct psmouse *psmouse = serio_get_drvdata(serio);
  225. if (psmouse->state == PSMOUSE_IGNORE)
  226. goto out;
  227. if (flags & (SERIO_PARITY|SERIO_TIMEOUT)) {
  228. if (psmouse->state == PSMOUSE_ACTIVATED)
  229. printk(KERN_WARNING "psmouse.c: bad data from KBC -%s%s\n",
  230. flags & SERIO_TIMEOUT ? " timeout" : "",
  231. flags & SERIO_PARITY ? " bad parity" : "");
  232. ps2_cmd_aborted(&psmouse->ps2dev);
  233. goto out;
  234. }
  235. if (unlikely(psmouse->ps2dev.flags & PS2_FLAG_ACK))
  236. if (ps2_handle_ack(&psmouse->ps2dev, data))
  237. goto out;
  238. if (unlikely(psmouse->ps2dev.flags & PS2_FLAG_CMD))
  239. if (ps2_handle_response(&psmouse->ps2dev, data))
  240. goto out;
  241. if (psmouse->state <= PSMOUSE_RESYNCING)
  242. goto out;
  243. if (psmouse->state == PSMOUSE_ACTIVATED &&
  244. psmouse->pktcnt && time_after(jiffies, psmouse->last + HZ/2)) {
  245. printk(KERN_INFO "psmouse.c: %s at %s lost synchronization, throwing %d bytes away.\n",
  246. psmouse->name, psmouse->phys, psmouse->pktcnt);
  247. psmouse->badbyte = psmouse->packet[0];
  248. __psmouse_set_state(psmouse, PSMOUSE_RESYNCING);
  249. queue_work(kpsmoused_wq, &psmouse->resync_work);
  250. goto out;
  251. }
  252. psmouse->packet[psmouse->pktcnt++] = data;
  253. /*
  254. * Check if this is a new device announcement (0xAA 0x00)
  255. */
  256. if (unlikely(psmouse->packet[0] == PSMOUSE_RET_BAT && psmouse->pktcnt <= 2)) {
  257. if (psmouse->pktcnt == 1) {
  258. psmouse->last = jiffies;
  259. goto out;
  260. }
  261. if (psmouse->packet[1] == PSMOUSE_RET_ID) {
  262. __psmouse_set_state(psmouse, PSMOUSE_IGNORE);
  263. serio_reconnect(serio);
  264. goto out;
  265. }
  266. /*
  267. * Not a new device, try processing first byte normally
  268. */
  269. psmouse->pktcnt = 1;
  270. if (psmouse_handle_byte(psmouse))
  271. goto out;
  272. psmouse->packet[psmouse->pktcnt++] = data;
  273. }
  274. /*
  275. * See if we need to force resync because mouse was idle for too long
  276. */
  277. if (psmouse->state == PSMOUSE_ACTIVATED &&
  278. psmouse->pktcnt == 1 && psmouse->resync_time &&
  279. time_after(jiffies, psmouse->last + psmouse->resync_time * HZ)) {
  280. psmouse->badbyte = psmouse->packet[0];
  281. __psmouse_set_state(psmouse, PSMOUSE_RESYNCING);
  282. queue_work(kpsmoused_wq, &psmouse->resync_work);
  283. goto out;
  284. }
  285. psmouse->last = jiffies;
  286. psmouse_handle_byte(psmouse);
  287. out:
  288. return IRQ_HANDLED;
  289. }
  290. /*
  291. * psmouse_sliced_command() sends an extended PS/2 command to the mouse
  292. * using sliced syntax, understood by advanced devices, such as Logitech
  293. * or Synaptics touchpads. The command is encoded as:
  294. * 0xE6 0xE8 rr 0xE8 ss 0xE8 tt 0xE8 uu where (rr*64)+(ss*16)+(tt*4)+uu
  295. * is the command.
  296. */
  297. int psmouse_sliced_command(struct psmouse *psmouse, unsigned char command)
  298. {
  299. int i;
  300. if (ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETSCALE11))
  301. return -1;
  302. for (i = 6; i >= 0; i -= 2) {
  303. unsigned char d = (command >> i) & 3;
  304. if (ps2_command(&psmouse->ps2dev, &d, PSMOUSE_CMD_SETRES))
  305. return -1;
  306. }
  307. return 0;
  308. }
  309. /*
  310. * psmouse_reset() resets the mouse into power-on state.
  311. */
  312. int psmouse_reset(struct psmouse *psmouse)
  313. {
  314. unsigned char param[2];
  315. if (ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_RESET_BAT))
  316. return -1;
  317. if (param[0] != PSMOUSE_RET_BAT && param[1] != PSMOUSE_RET_ID)
  318. return -1;
  319. return 0;
  320. }
  321. /*
  322. * Genius NetMouse magic init.
  323. */
  324. static int genius_detect(struct psmouse *psmouse, int set_properties)
  325. {
  326. struct ps2dev *ps2dev = &psmouse->ps2dev;
  327. unsigned char param[4];
  328. param[0] = 3;
  329. ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
  330. ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11);
  331. ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11);
  332. ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11);
  333. ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO);
  334. if (param[0] != 0x00 || param[1] != 0x33 || param[2] != 0x55)
  335. return -1;
  336. if (set_properties) {
  337. set_bit(BTN_EXTRA, psmouse->dev->keybit);
  338. set_bit(BTN_SIDE, psmouse->dev->keybit);
  339. set_bit(REL_WHEEL, psmouse->dev->relbit);
  340. psmouse->vendor = "Genius";
  341. psmouse->name = "Mouse";
  342. psmouse->pktsize = 4;
  343. }
  344. return 0;
  345. }
  346. /*
  347. * IntelliMouse magic init.
  348. */
  349. static int intellimouse_detect(struct psmouse *psmouse, int set_properties)
  350. {
  351. struct ps2dev *ps2dev = &psmouse->ps2dev;
  352. unsigned char param[2];
  353. param[0] = 200;
  354. ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
  355. param[0] = 100;
  356. ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
  357. param[0] = 80;
  358. ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
  359. ps2_command(ps2dev, param, PSMOUSE_CMD_GETID);
  360. if (param[0] != 3)
  361. return -1;
  362. if (set_properties) {
  363. set_bit(BTN_MIDDLE, psmouse->dev->keybit);
  364. set_bit(REL_WHEEL, psmouse->dev->relbit);
  365. if (!psmouse->vendor) psmouse->vendor = "Generic";
  366. if (!psmouse->name) psmouse->name = "Wheel Mouse";
  367. psmouse->pktsize = 4;
  368. }
  369. return 0;
  370. }
  371. /*
  372. * Try IntelliMouse/Explorer magic init.
  373. */
  374. static int im_explorer_detect(struct psmouse *psmouse, int set_properties)
  375. {
  376. struct ps2dev *ps2dev = &psmouse->ps2dev;
  377. unsigned char param[2];
  378. intellimouse_detect(psmouse, 0);
  379. param[0] = 200;
  380. ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
  381. param[0] = 200;
  382. ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
  383. param[0] = 80;
  384. ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
  385. ps2_command(ps2dev, param, PSMOUSE_CMD_GETID);
  386. if (param[0] != 4)
  387. return -1;
  388. /* Magic to enable horizontal scrolling on IntelliMouse 4.0 */
  389. param[0] = 200;
  390. ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
  391. param[0] = 80;
  392. ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
  393. param[0] = 40;
  394. ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
  395. if (set_properties) {
  396. set_bit(BTN_MIDDLE, psmouse->dev->keybit);
  397. set_bit(REL_WHEEL, psmouse->dev->relbit);
  398. set_bit(REL_HWHEEL, psmouse->dev->relbit);
  399. set_bit(BTN_SIDE, psmouse->dev->keybit);
  400. set_bit(BTN_EXTRA, psmouse->dev->keybit);
  401. if (!psmouse->vendor) psmouse->vendor = "Generic";
  402. if (!psmouse->name) psmouse->name = "Explorer Mouse";
  403. psmouse->pktsize = 4;
  404. }
  405. return 0;
  406. }
  407. /*
  408. * Kensington ThinkingMouse / ExpertMouse magic init.
  409. */
  410. static int thinking_detect(struct psmouse *psmouse, int set_properties)
  411. {
  412. struct ps2dev *ps2dev = &psmouse->ps2dev;
  413. unsigned char param[2];
  414. static const unsigned char seq[] = { 20, 60, 40, 20, 20, 60, 40, 20, 20 };
  415. int i;
  416. param[0] = 10;
  417. ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
  418. param[0] = 0;
  419. ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
  420. for (i = 0; i < ARRAY_SIZE(seq); i++) {
  421. param[0] = seq[i];
  422. ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
  423. }
  424. ps2_command(ps2dev, param, PSMOUSE_CMD_GETID);
  425. if (param[0] != 2)
  426. return -1;
  427. if (set_properties) {
  428. set_bit(BTN_EXTRA, psmouse->dev->keybit);
  429. psmouse->vendor = "Kensington";
  430. psmouse->name = "ThinkingMouse";
  431. }
  432. return 0;
  433. }
  434. /*
  435. * Bare PS/2 protocol "detection". Always succeeds.
  436. */
  437. static int ps2bare_detect(struct psmouse *psmouse, int set_properties)
  438. {
  439. if (set_properties) {
  440. if (!psmouse->vendor) psmouse->vendor = "Generic";
  441. if (!psmouse->name) psmouse->name = "Mouse";
  442. }
  443. return 0;
  444. }
  445. /*
  446. * psmouse_extensions() probes for any extensions to the basic PS/2 protocol
  447. * the mouse may have.
  448. */
  449. static int psmouse_extensions(struct psmouse *psmouse,
  450. unsigned int max_proto, int set_properties)
  451. {
  452. int synaptics_hardware = 0;
  453. /*
  454. * We always check for lifebook because it does not disturb mouse
  455. * (it only checks DMI information).
  456. */
  457. if (lifebook_detect(psmouse, set_properties) == 0) {
  458. if (max_proto > PSMOUSE_IMEX) {
  459. if (!set_properties || lifebook_init(psmouse) == 0)
  460. return PSMOUSE_LIFEBOOK;
  461. }
  462. }
  463. /*
  464. * Try Kensington ThinkingMouse (we try first, because synaptics probe
  465. * upsets the thinkingmouse).
  466. */
  467. if (max_proto > PSMOUSE_IMEX && thinking_detect(psmouse, set_properties) == 0)
  468. return PSMOUSE_THINKPS;
  469. /*
  470. * Try Synaptics TouchPad. Note that probing is done even if Synaptics protocol
  471. * support is disabled in config - we need to know if it is synaptics so we
  472. * can reset it properly after probing for intellimouse.
  473. */
  474. if (max_proto > PSMOUSE_PS2 && synaptics_detect(psmouse, set_properties) == 0) {
  475. synaptics_hardware = 1;
  476. if (max_proto > PSMOUSE_IMEX) {
  477. if (!set_properties || synaptics_init(psmouse) == 0)
  478. return PSMOUSE_SYNAPTICS;
  479. /*
  480. * Some Synaptics touchpads can emulate extended protocols (like IMPS/2).
  481. * Unfortunately Logitech/Genius probes confuse some firmware versions so
  482. * we'll have to skip them.
  483. */
  484. max_proto = PSMOUSE_IMEX;
  485. }
  486. /*
  487. * Make sure that touchpad is in relative mode, gestures (taps) are enabled
  488. */
  489. synaptics_reset(psmouse);
  490. }
  491. /*
  492. * Try ALPS TouchPad
  493. */
  494. if (max_proto > PSMOUSE_IMEX) {
  495. ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_RESET_DIS);
  496. if (alps_detect(psmouse, set_properties) == 0) {
  497. if (!set_properties || alps_init(psmouse) == 0)
  498. return PSMOUSE_ALPS;
  499. /*
  500. * Init failed, try basic relative protocols
  501. */
  502. max_proto = PSMOUSE_IMEX;
  503. }
  504. }
  505. if (max_proto > PSMOUSE_IMEX) {
  506. if (genius_detect(psmouse, set_properties) == 0)
  507. return PSMOUSE_GENPS;
  508. if (ps2pp_init(psmouse, set_properties) == 0)
  509. return PSMOUSE_PS2PP;
  510. if (trackpoint_detect(psmouse, set_properties) == 0)
  511. return PSMOUSE_TRACKPOINT;
  512. if (touchkit_ps2_detect(psmouse, set_properties) == 0)
  513. return PSMOUSE_TOUCHKIT_PS2;
  514. }
  515. /*
  516. * Reset to defaults in case the device got confused by extended
  517. * protocol probes. Note that we do full reset becuase some mice
  518. * put themselves to sleep when see PSMOUSE_RESET_DIS.
  519. */
  520. psmouse_reset(psmouse);
  521. if (max_proto >= PSMOUSE_IMEX && im_explorer_detect(psmouse, set_properties) == 0)
  522. return PSMOUSE_IMEX;
  523. if (max_proto >= PSMOUSE_IMPS && intellimouse_detect(psmouse, set_properties) == 0)
  524. return PSMOUSE_IMPS;
  525. /*
  526. * Okay, all failed, we have a standard mouse here. The number of the buttons
  527. * is still a question, though. We assume 3.
  528. */
  529. ps2bare_detect(psmouse, set_properties);
  530. if (synaptics_hardware) {
  531. /*
  532. * We detected Synaptics hardware but it did not respond to IMPS/2 probes.
  533. * We need to reset the touchpad because if there is a track point on the
  534. * pass through port it could get disabled while probing for protocol
  535. * extensions.
  536. */
  537. psmouse_reset(psmouse);
  538. }
  539. return PSMOUSE_PS2;
  540. }
  541. static const struct psmouse_protocol psmouse_protocols[] = {
  542. {
  543. .type = PSMOUSE_PS2,
  544. .name = "PS/2",
  545. .alias = "bare",
  546. .maxproto = 1,
  547. .detect = ps2bare_detect,
  548. },
  549. #ifdef CONFIG_MOUSE_PS2_LOGIPS2PP
  550. {
  551. .type = PSMOUSE_PS2PP,
  552. .name = "PS2++",
  553. .alias = "logitech",
  554. .detect = ps2pp_init,
  555. },
  556. #endif
  557. {
  558. .type = PSMOUSE_THINKPS,
  559. .name = "ThinkPS/2",
  560. .alias = "thinkps",
  561. .detect = thinking_detect,
  562. },
  563. {
  564. .type = PSMOUSE_GENPS,
  565. .name = "GenPS/2",
  566. .alias = "genius",
  567. .detect = genius_detect,
  568. },
  569. {
  570. .type = PSMOUSE_IMPS,
  571. .name = "ImPS/2",
  572. .alias = "imps",
  573. .maxproto = 1,
  574. .detect = intellimouse_detect,
  575. },
  576. {
  577. .type = PSMOUSE_IMEX,
  578. .name = "ImExPS/2",
  579. .alias = "exps",
  580. .maxproto = 1,
  581. .detect = im_explorer_detect,
  582. },
  583. #ifdef CONFIG_MOUSE_PS2_SYNAPTICS
  584. {
  585. .type = PSMOUSE_SYNAPTICS,
  586. .name = "SynPS/2",
  587. .alias = "synaptics",
  588. .detect = synaptics_detect,
  589. .init = synaptics_init,
  590. },
  591. #endif
  592. #ifdef CONFIG_MOUSE_PS2_ALPS
  593. {
  594. .type = PSMOUSE_ALPS,
  595. .name = "AlpsPS/2",
  596. .alias = "alps",
  597. .detect = alps_detect,
  598. .init = alps_init,
  599. },
  600. #endif
  601. #ifdef CONFIG_MOUSE_PS2_LIFEBOOK
  602. {
  603. .type = PSMOUSE_LIFEBOOK,
  604. .name = "LBPS/2",
  605. .alias = "lifebook",
  606. .init = lifebook_init,
  607. },
  608. #endif
  609. #ifdef CONFIG_MOUSE_PS2_TRACKPOINT
  610. {
  611. .type = PSMOUSE_TRACKPOINT,
  612. .name = "TPPS/2",
  613. .alias = "trackpoint",
  614. .detect = trackpoint_detect,
  615. },
  616. #endif
  617. #ifdef CONFIG_MOUSE_PS2_TOUCHKIT
  618. {
  619. .type = PSMOUSE_TOUCHKIT_PS2,
  620. .name = "touchkitPS/2",
  621. .alias = "touchkit",
  622. .detect = touchkit_ps2_detect,
  623. },
  624. #endif
  625. {
  626. .type = PSMOUSE_AUTO,
  627. .name = "auto",
  628. .alias = "any",
  629. .maxproto = 1,
  630. },
  631. };
  632. static const struct psmouse_protocol *psmouse_protocol_by_type(enum psmouse_type type)
  633. {
  634. int i;
  635. for (i = 0; i < ARRAY_SIZE(psmouse_protocols); i++)
  636. if (psmouse_protocols[i].type == type)
  637. return &psmouse_protocols[i];
  638. WARN_ON(1);
  639. return &psmouse_protocols[0];
  640. }
  641. static const struct psmouse_protocol *psmouse_protocol_by_name(const char *name, size_t len)
  642. {
  643. const struct psmouse_protocol *p;
  644. int i;
  645. for (i = 0; i < ARRAY_SIZE(psmouse_protocols); i++) {
  646. p = &psmouse_protocols[i];
  647. if ((strlen(p->name) == len && !strncmp(p->name, name, len)) ||
  648. (strlen(p->alias) == len && !strncmp(p->alias, name, len)))
  649. return &psmouse_protocols[i];
  650. }
  651. return NULL;
  652. }
  653. /*
  654. * psmouse_probe() probes for a PS/2 mouse.
  655. */
  656. static int psmouse_probe(struct psmouse *psmouse)
  657. {
  658. struct ps2dev *ps2dev = &psmouse->ps2dev;
  659. unsigned char param[2];
  660. /*
  661. * First, we check if it's a mouse. It should send 0x00 or 0x03
  662. * in case of an IntelliMouse in 4-byte mode or 0x04 for IM Explorer.
  663. * Sunrex K8561 IR Keyboard/Mouse reports 0xff on second and subsequent
  664. * ID queries, probably due to a firmware bug.
  665. */
  666. param[0] = 0xa5;
  667. if (ps2_command(ps2dev, param, PSMOUSE_CMD_GETID))
  668. return -1;
  669. if (param[0] != 0x00 && param[0] != 0x03 &&
  670. param[0] != 0x04 && param[0] != 0xff)
  671. return -1;
  672. /*
  673. * Then we reset and disable the mouse so that it doesn't generate events.
  674. */
  675. if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_RESET_DIS))
  676. printk(KERN_WARNING "psmouse.c: Failed to reset mouse on %s\n", ps2dev->serio->phys);
  677. return 0;
  678. }
  679. /*
  680. * Here we set the mouse resolution.
  681. */
  682. void psmouse_set_resolution(struct psmouse *psmouse, unsigned int resolution)
  683. {
  684. static const unsigned char params[] = { 0, 1, 2, 2, 3 };
  685. unsigned char p;
  686. if (resolution == 0 || resolution > 200)
  687. resolution = 200;
  688. p = params[resolution / 50];
  689. ps2_command(&psmouse->ps2dev, &p, PSMOUSE_CMD_SETRES);
  690. psmouse->resolution = 25 << p;
  691. }
  692. /*
  693. * Here we set the mouse report rate.
  694. */
  695. static void psmouse_set_rate(struct psmouse *psmouse, unsigned int rate)
  696. {
  697. static const unsigned char rates[] = { 200, 100, 80, 60, 40, 20, 10, 0 };
  698. unsigned char r;
  699. int i = 0;
  700. while (rates[i] > rate) i++;
  701. r = rates[i];
  702. ps2_command(&psmouse->ps2dev, &r, PSMOUSE_CMD_SETRATE);
  703. psmouse->rate = r;
  704. }
  705. /*
  706. * psmouse_initialize() initializes the mouse to a sane state.
  707. */
  708. static void psmouse_initialize(struct psmouse *psmouse)
  709. {
  710. /*
  711. * We set the mouse report rate, resolution and scaling.
  712. */
  713. if (psmouse_max_proto != PSMOUSE_PS2) {
  714. psmouse->set_rate(psmouse, psmouse->rate);
  715. psmouse->set_resolution(psmouse, psmouse->resolution);
  716. ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETSCALE11);
  717. }
  718. }
  719. /*
  720. * psmouse_activate() enables the mouse so that we get motion reports from it.
  721. */
  722. static void psmouse_activate(struct psmouse *psmouse)
  723. {
  724. if (ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_ENABLE))
  725. printk(KERN_WARNING "psmouse.c: Failed to enable mouse on %s\n",
  726. psmouse->ps2dev.serio->phys);
  727. psmouse_set_state(psmouse, PSMOUSE_ACTIVATED);
  728. }
  729. /*
  730. * psmouse_deactivate() puts the mouse into poll mode so that we don't get motion
  731. * reports from it unless we explicitely request it.
  732. */
  733. static void psmouse_deactivate(struct psmouse *psmouse)
  734. {
  735. if (ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_DISABLE))
  736. printk(KERN_WARNING "psmouse.c: Failed to deactivate mouse on %s\n",
  737. psmouse->ps2dev.serio->phys);
  738. psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
  739. }
  740. /*
  741. * psmouse_poll() - default poll hanlder. Everyone except for ALPS uses it.
  742. */
  743. static int psmouse_poll(struct psmouse *psmouse)
  744. {
  745. return ps2_command(&psmouse->ps2dev, psmouse->packet,
  746. PSMOUSE_CMD_POLL | (psmouse->pktsize << 8));
  747. }
  748. /*
  749. * psmouse_resync() attempts to re-validate current protocol.
  750. */
  751. static void psmouse_resync(struct work_struct *work)
  752. {
  753. struct psmouse *parent = NULL, *psmouse =
  754. container_of(work, struct psmouse, resync_work);
  755. struct serio *serio = psmouse->ps2dev.serio;
  756. psmouse_ret_t rc = PSMOUSE_GOOD_DATA;
  757. int failed = 0, enabled = 0;
  758. int i;
  759. mutex_lock(&psmouse_mutex);
  760. if (psmouse->state != PSMOUSE_RESYNCING)
  761. goto out;
  762. if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
  763. parent = serio_get_drvdata(serio->parent);
  764. psmouse_deactivate(parent);
  765. }
  766. /*
  767. * Some mice don't ACK commands sent while they are in the middle of
  768. * transmitting motion packet. To avoid delay we use ps2_sendbyte()
  769. * instead of ps2_command() which would wait for 200ms for an ACK
  770. * that may never come.
  771. * As an additional quirk ALPS touchpads may not only forget to ACK
  772. * disable command but will stop reporting taps, so if we see that
  773. * mouse at least once ACKs disable we will do full reconnect if ACK
  774. * is missing.
  775. */
  776. psmouse->num_resyncs++;
  777. if (ps2_sendbyte(&psmouse->ps2dev, PSMOUSE_CMD_DISABLE, 20)) {
  778. if (psmouse->num_resyncs < 3 || psmouse->acks_disable_command)
  779. failed = 1;
  780. } else
  781. psmouse->acks_disable_command = 1;
  782. /*
  783. * Poll the mouse. If it was reset the packet will be shorter than
  784. * psmouse->pktsize and ps2_command will fail. We do not expect and
  785. * do not handle scenario when mouse "upgrades" its protocol while
  786. * disconnected since it would require additional delay. If we ever
  787. * see a mouse that does it we'll adjust the code.
  788. */
  789. if (!failed) {
  790. if (psmouse->poll(psmouse))
  791. failed = 1;
  792. else {
  793. psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
  794. for (i = 0; i < psmouse->pktsize; i++) {
  795. psmouse->pktcnt++;
  796. rc = psmouse->protocol_handler(psmouse);
  797. if (rc != PSMOUSE_GOOD_DATA)
  798. break;
  799. }
  800. if (rc != PSMOUSE_FULL_PACKET)
  801. failed = 1;
  802. psmouse_set_state(psmouse, PSMOUSE_RESYNCING);
  803. }
  804. }
  805. /*
  806. * Now try to enable mouse. We try to do that even if poll failed and also
  807. * repeat our attempts 5 times, otherwise we may be left out with disabled
  808. * mouse.
  809. */
  810. for (i = 0; i < 5; i++) {
  811. if (!ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_ENABLE)) {
  812. enabled = 1;
  813. break;
  814. }
  815. msleep(200);
  816. }
  817. if (!enabled) {
  818. printk(KERN_WARNING "psmouse.c: failed to re-enable mouse on %s\n",
  819. psmouse->ps2dev.serio->phys);
  820. failed = 1;
  821. }
  822. if (failed) {
  823. psmouse_set_state(psmouse, PSMOUSE_IGNORE);
  824. printk(KERN_INFO "psmouse.c: resync failed, issuing reconnect request\n");
  825. serio_reconnect(serio);
  826. } else
  827. psmouse_set_state(psmouse, PSMOUSE_ACTIVATED);
  828. if (parent)
  829. psmouse_activate(parent);
  830. out:
  831. mutex_unlock(&psmouse_mutex);
  832. }
  833. /*
  834. * psmouse_cleanup() resets the mouse into power-on state.
  835. */
  836. static void psmouse_cleanup(struct serio *serio)
  837. {
  838. struct psmouse *psmouse = serio_get_drvdata(serio);
  839. struct psmouse *parent = NULL;
  840. mutex_lock(&psmouse_mutex);
  841. if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
  842. parent = serio_get_drvdata(serio->parent);
  843. psmouse_deactivate(parent);
  844. }
  845. psmouse_deactivate(psmouse);
  846. if (psmouse->cleanup)
  847. psmouse->cleanup(psmouse);
  848. psmouse_reset(psmouse);
  849. /*
  850. * Some boxes, such as HP nx7400, get terribly confused if mouse
  851. * is not fully enabled before suspending/shutting down.
  852. */
  853. ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_ENABLE);
  854. if (parent) {
  855. if (parent->pt_deactivate)
  856. parent->pt_deactivate(parent);
  857. psmouse_activate(parent);
  858. }
  859. mutex_unlock(&psmouse_mutex);
  860. }
  861. /*
  862. * psmouse_disconnect() closes and frees.
  863. */
  864. static void psmouse_disconnect(struct serio *serio)
  865. {
  866. struct psmouse *psmouse, *parent = NULL;
  867. psmouse = serio_get_drvdata(serio);
  868. sysfs_remove_group(&serio->dev.kobj, &psmouse_attribute_group);
  869. mutex_lock(&psmouse_mutex);
  870. psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
  871. /* make sure we don't have a resync in progress */
  872. mutex_unlock(&psmouse_mutex);
  873. flush_workqueue(kpsmoused_wq);
  874. mutex_lock(&psmouse_mutex);
  875. if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
  876. parent = serio_get_drvdata(serio->parent);
  877. psmouse_deactivate(parent);
  878. }
  879. if (psmouse->disconnect)
  880. psmouse->disconnect(psmouse);
  881. if (parent && parent->pt_deactivate)
  882. parent->pt_deactivate(parent);
  883. psmouse_set_state(psmouse, PSMOUSE_IGNORE);
  884. serio_close(serio);
  885. serio_set_drvdata(serio, NULL);
  886. input_unregister_device(psmouse->dev);
  887. kfree(psmouse);
  888. if (parent)
  889. psmouse_activate(parent);
  890. mutex_unlock(&psmouse_mutex);
  891. }
  892. static int psmouse_switch_protocol(struct psmouse *psmouse, const struct psmouse_protocol *proto)
  893. {
  894. struct input_dev *input_dev = psmouse->dev;
  895. input_dev->dev.parent = &psmouse->ps2dev.serio->dev;
  896. input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_REL);
  897. input_dev->keybit[LONG(BTN_MOUSE)] = BIT(BTN_LEFT) | BIT(BTN_MIDDLE) | BIT(BTN_RIGHT);
  898. input_dev->relbit[0] = BIT(REL_X) | BIT(REL_Y);
  899. psmouse->set_rate = psmouse_set_rate;
  900. psmouse->set_resolution = psmouse_set_resolution;
  901. psmouse->poll = psmouse_poll;
  902. psmouse->protocol_handler = psmouse_process_byte;
  903. psmouse->pktsize = 3;
  904. if (proto && (proto->detect || proto->init)) {
  905. if (proto->detect && proto->detect(psmouse, 1) < 0)
  906. return -1;
  907. if (proto->init && proto->init(psmouse) < 0)
  908. return -1;
  909. psmouse->type = proto->type;
  910. }
  911. else
  912. psmouse->type = psmouse_extensions(psmouse, psmouse_max_proto, 1);
  913. /*
  914. * If mouse's packet size is 3 there is no point in polling the
  915. * device in hopes to detect protocol reset - we won't get less
  916. * than 3 bytes response anyhow.
  917. */
  918. if (psmouse->pktsize == 3)
  919. psmouse->resync_time = 0;
  920. /*
  921. * Some smart KVMs fake response to POLL command returning just
  922. * 3 bytes and messing up our resync logic, so if initial poll
  923. * fails we won't try polling the device anymore. Hopefully
  924. * such KVM will maintain initially selected protocol.
  925. */
  926. if (psmouse->resync_time && psmouse->poll(psmouse))
  927. psmouse->resync_time = 0;
  928. snprintf(psmouse->devname, sizeof(psmouse->devname), "%s %s %s",
  929. psmouse_protocol_by_type(psmouse->type)->name, psmouse->vendor, psmouse->name);
  930. input_dev->name = psmouse->devname;
  931. input_dev->phys = psmouse->phys;
  932. input_dev->id.bustype = BUS_I8042;
  933. input_dev->id.vendor = 0x0002;
  934. input_dev->id.product = psmouse->type;
  935. input_dev->id.version = psmouse->model;
  936. return 0;
  937. }
  938. /*
  939. * psmouse_connect() is a callback from the serio module when
  940. * an unhandled serio port is found.
  941. */
  942. static int psmouse_connect(struct serio *serio, struct serio_driver *drv)
  943. {
  944. struct psmouse *psmouse, *parent = NULL;
  945. struct input_dev *input_dev;
  946. int retval = 0, error = -ENOMEM;
  947. mutex_lock(&psmouse_mutex);
  948. /*
  949. * If this is a pass-through port deactivate parent so the device
  950. * connected to this port can be successfully identified
  951. */
  952. if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
  953. parent = serio_get_drvdata(serio->parent);
  954. psmouse_deactivate(parent);
  955. }
  956. psmouse = kzalloc(sizeof(struct psmouse), GFP_KERNEL);
  957. input_dev = input_allocate_device();
  958. if (!psmouse || !input_dev)
  959. goto err_free;
  960. ps2_init(&psmouse->ps2dev, serio);
  961. INIT_WORK(&psmouse->resync_work, psmouse_resync);
  962. psmouse->dev = input_dev;
  963. snprintf(psmouse->phys, sizeof(psmouse->phys), "%s/input0", serio->phys);
  964. psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
  965. serio_set_drvdata(serio, psmouse);
  966. error = serio_open(serio, drv);
  967. if (error)
  968. goto err_clear_drvdata;
  969. if (psmouse_probe(psmouse) < 0) {
  970. error = -ENODEV;
  971. goto err_close_serio;
  972. }
  973. psmouse->rate = psmouse_rate;
  974. psmouse->resolution = psmouse_resolution;
  975. psmouse->resetafter = psmouse_resetafter;
  976. psmouse->resync_time = parent ? 0 : psmouse_resync_time;
  977. psmouse->smartscroll = psmouse_smartscroll;
  978. psmouse_switch_protocol(psmouse, NULL);
  979. psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
  980. psmouse_initialize(psmouse);
  981. error = input_register_device(psmouse->dev);
  982. if (error)
  983. goto err_protocol_disconnect;
  984. if (parent && parent->pt_activate)
  985. parent->pt_activate(parent);
  986. error = sysfs_create_group(&serio->dev.kobj, &psmouse_attribute_group);
  987. if (error)
  988. goto err_pt_deactivate;
  989. psmouse_activate(psmouse);
  990. out:
  991. /* If this is a pass-through port the parent needs to be re-activated */
  992. if (parent)
  993. psmouse_activate(parent);
  994. mutex_unlock(&psmouse_mutex);
  995. return retval;
  996. err_pt_deactivate:
  997. if (parent && parent->pt_deactivate)
  998. parent->pt_deactivate(parent);
  999. err_protocol_disconnect:
  1000. if (psmouse->disconnect)
  1001. psmouse->disconnect(psmouse);
  1002. psmouse_set_state(psmouse, PSMOUSE_IGNORE);
  1003. err_close_serio:
  1004. serio_close(serio);
  1005. err_clear_drvdata:
  1006. serio_set_drvdata(serio, NULL);
  1007. err_free:
  1008. input_free_device(input_dev);
  1009. kfree(psmouse);
  1010. retval = error;
  1011. goto out;
  1012. }
  1013. static int psmouse_reconnect(struct serio *serio)
  1014. {
  1015. struct psmouse *psmouse = serio_get_drvdata(serio);
  1016. struct psmouse *parent = NULL;
  1017. struct serio_driver *drv = serio->drv;
  1018. int rc = -1;
  1019. if (!drv || !psmouse) {
  1020. printk(KERN_DEBUG "psmouse: reconnect request, but serio is disconnected, ignoring...\n");
  1021. return -1;
  1022. }
  1023. mutex_lock(&psmouse_mutex);
  1024. if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
  1025. parent = serio_get_drvdata(serio->parent);
  1026. psmouse_deactivate(parent);
  1027. }
  1028. psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
  1029. if (psmouse->reconnect) {
  1030. if (psmouse->reconnect(psmouse))
  1031. goto out;
  1032. } else if (psmouse_probe(psmouse) < 0 ||
  1033. psmouse->type != psmouse_extensions(psmouse, psmouse_max_proto, 0))
  1034. goto out;
  1035. /* ok, the device type (and capabilities) match the old one,
  1036. * we can continue using it, complete intialization
  1037. */
  1038. psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
  1039. psmouse_initialize(psmouse);
  1040. if (parent && parent->pt_activate)
  1041. parent->pt_activate(parent);
  1042. psmouse_activate(psmouse);
  1043. rc = 0;
  1044. out:
  1045. /* If this is a pass-through port the parent waits to be activated */
  1046. if (parent)
  1047. psmouse_activate(parent);
  1048. mutex_unlock(&psmouse_mutex);
  1049. return rc;
  1050. }
  1051. static struct serio_device_id psmouse_serio_ids[] = {
  1052. {
  1053. .type = SERIO_8042,
  1054. .proto = SERIO_ANY,
  1055. .id = SERIO_ANY,
  1056. .extra = SERIO_ANY,
  1057. },
  1058. {
  1059. .type = SERIO_PS_PSTHRU,
  1060. .proto = SERIO_ANY,
  1061. .id = SERIO_ANY,
  1062. .extra = SERIO_ANY,
  1063. },
  1064. { 0 }
  1065. };
  1066. MODULE_DEVICE_TABLE(serio, psmouse_serio_ids);
  1067. static struct serio_driver psmouse_drv = {
  1068. .driver = {
  1069. .name = "psmouse",
  1070. },
  1071. .description = DRIVER_DESC,
  1072. .id_table = psmouse_serio_ids,
  1073. .interrupt = psmouse_interrupt,
  1074. .connect = psmouse_connect,
  1075. .reconnect = psmouse_reconnect,
  1076. .disconnect = psmouse_disconnect,
  1077. .cleanup = psmouse_cleanup,
  1078. };
  1079. ssize_t psmouse_attr_show_helper(struct device *dev, struct device_attribute *devattr,
  1080. char *buf)
  1081. {
  1082. struct serio *serio = to_serio_port(dev);
  1083. struct psmouse_attribute *attr = to_psmouse_attr(devattr);
  1084. struct psmouse *psmouse;
  1085. int retval;
  1086. retval = serio_pin_driver(serio);
  1087. if (retval)
  1088. return retval;
  1089. if (serio->drv != &psmouse_drv) {
  1090. retval = -ENODEV;
  1091. goto out;
  1092. }
  1093. psmouse = serio_get_drvdata(serio);
  1094. retval = attr->show(psmouse, attr->data, buf);
  1095. out:
  1096. serio_unpin_driver(serio);
  1097. return retval;
  1098. }
  1099. ssize_t psmouse_attr_set_helper(struct device *dev, struct device_attribute *devattr,
  1100. const char *buf, size_t count)
  1101. {
  1102. struct serio *serio = to_serio_port(dev);
  1103. struct psmouse_attribute *attr = to_psmouse_attr(devattr);
  1104. struct psmouse *psmouse, *parent = NULL;
  1105. int retval;
  1106. retval = serio_pin_driver(serio);
  1107. if (retval)
  1108. return retval;
  1109. if (serio->drv != &psmouse_drv) {
  1110. retval = -ENODEV;
  1111. goto out_unpin;
  1112. }
  1113. retval = mutex_lock_interruptible(&psmouse_mutex);
  1114. if (retval)
  1115. goto out_unpin;
  1116. psmouse = serio_get_drvdata(serio);
  1117. if (psmouse->state == PSMOUSE_IGNORE) {
  1118. retval = -ENODEV;
  1119. goto out_unlock;
  1120. }
  1121. if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
  1122. parent = serio_get_drvdata(serio->parent);
  1123. psmouse_deactivate(parent);
  1124. }
  1125. psmouse_deactivate(psmouse);
  1126. retval = attr->set(psmouse, attr->data, buf, count);
  1127. if (retval != -ENODEV)
  1128. psmouse_activate(psmouse);
  1129. if (parent)
  1130. psmouse_activate(parent);
  1131. out_unlock:
  1132. mutex_unlock(&psmouse_mutex);
  1133. out_unpin:
  1134. serio_unpin_driver(serio);
  1135. return retval;
  1136. }
  1137. static ssize_t psmouse_show_int_attr(struct psmouse *psmouse, void *offset, char *buf)
  1138. {
  1139. unsigned int *field = (unsigned int *)((char *)psmouse + (size_t)offset);
  1140. return sprintf(buf, "%u\n", *field);
  1141. }
  1142. static ssize_t psmouse_set_int_attr(struct psmouse *psmouse, void *offset, const char *buf, size_t count)
  1143. {
  1144. unsigned int *field = (unsigned int *)((char *)psmouse + (size_t)offset);
  1145. unsigned long value;
  1146. char *rest;
  1147. value = simple_strtoul(buf, &rest, 10);
  1148. if (*rest)
  1149. return -EINVAL;
  1150. if ((unsigned int)value != value)
  1151. return -EINVAL;
  1152. *field = value;
  1153. return count;
  1154. }
  1155. static ssize_t psmouse_attr_show_protocol(struct psmouse *psmouse, void *data, char *buf)
  1156. {
  1157. return sprintf(buf, "%s\n", psmouse_protocol_by_type(psmouse->type)->name);
  1158. }
  1159. static ssize_t psmouse_attr_set_protocol(struct psmouse *psmouse, void *data, const char *buf, size_t count)
  1160. {
  1161. struct serio *serio = psmouse->ps2dev.serio;
  1162. struct psmouse *parent = NULL;
  1163. struct input_dev *old_dev, *new_dev;
  1164. const struct psmouse_protocol *proto, *old_proto;
  1165. int error;
  1166. int retry = 0;
  1167. proto = psmouse_protocol_by_name(buf, count);
  1168. if (!proto)
  1169. return -EINVAL;
  1170. if (psmouse->type == proto->type)
  1171. return count;
  1172. new_dev = input_allocate_device();
  1173. if (!new_dev)
  1174. return -ENOMEM;
  1175. while (serio->child) {
  1176. if (++retry > 3) {
  1177. printk(KERN_WARNING "psmouse: failed to destroy child port, protocol change aborted.\n");
  1178. input_free_device(new_dev);
  1179. return -EIO;
  1180. }
  1181. mutex_unlock(&psmouse_mutex);
  1182. serio_unpin_driver(serio);
  1183. serio_unregister_child_port(serio);
  1184. serio_pin_driver_uninterruptible(serio);
  1185. mutex_lock(&psmouse_mutex);
  1186. if (serio->drv != &psmouse_drv) {
  1187. input_free_device(new_dev);
  1188. return -ENODEV;
  1189. }
  1190. if (psmouse->type == proto->type) {
  1191. input_free_device(new_dev);
  1192. return count; /* switched by other thread */
  1193. }
  1194. }
  1195. if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
  1196. parent = serio_get_drvdata(serio->parent);
  1197. if (parent->pt_deactivate)
  1198. parent->pt_deactivate(parent);
  1199. }
  1200. old_dev = psmouse->dev;
  1201. old_proto = psmouse_protocol_by_type(psmouse->type);
  1202. if (psmouse->disconnect)
  1203. psmouse->disconnect(psmouse);
  1204. psmouse_set_state(psmouse, PSMOUSE_IGNORE);
  1205. psmouse->dev = new_dev;
  1206. psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
  1207. if (psmouse_switch_protocol(psmouse, proto) < 0) {
  1208. psmouse_reset(psmouse);
  1209. /* default to PSMOUSE_PS2 */
  1210. psmouse_switch_protocol(psmouse, &psmouse_protocols[0]);
  1211. }
  1212. psmouse_initialize(psmouse);
  1213. psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
  1214. error = input_register_device(psmouse->dev);
  1215. if (error) {
  1216. if (psmouse->disconnect)
  1217. psmouse->disconnect(psmouse);
  1218. psmouse_set_state(psmouse, PSMOUSE_IGNORE);
  1219. input_free_device(new_dev);
  1220. psmouse->dev = old_dev;
  1221. psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
  1222. psmouse_switch_protocol(psmouse, old_proto);
  1223. psmouse_initialize(psmouse);
  1224. psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
  1225. return error;
  1226. }
  1227. input_unregister_device(old_dev);
  1228. if (parent && parent->pt_activate)
  1229. parent->pt_activate(parent);
  1230. return count;
  1231. }
  1232. static ssize_t psmouse_attr_set_rate(struct psmouse *psmouse, void *data, const char *buf, size_t count)
  1233. {
  1234. unsigned long value;
  1235. char *rest;
  1236. value = simple_strtoul(buf, &rest, 10);
  1237. if (*rest)
  1238. return -EINVAL;
  1239. psmouse->set_rate(psmouse, value);
  1240. return count;
  1241. }
  1242. static ssize_t psmouse_attr_set_resolution(struct psmouse *psmouse, void *data, const char *buf, size_t count)
  1243. {
  1244. unsigned long value;
  1245. char *rest;
  1246. value = simple_strtoul(buf, &rest, 10);
  1247. if (*rest)
  1248. return -EINVAL;
  1249. psmouse->set_resolution(psmouse, value);
  1250. return count;
  1251. }
  1252. static int psmouse_set_maxproto(const char *val, struct kernel_param *kp)
  1253. {
  1254. const struct psmouse_protocol *proto;
  1255. if (!val)
  1256. return -EINVAL;
  1257. proto = psmouse_protocol_by_name(val, strlen(val));
  1258. if (!proto || !proto->maxproto)
  1259. return -EINVAL;
  1260. *((unsigned int *)kp->arg) = proto->type;
  1261. return 0;
  1262. }
  1263. static int psmouse_get_maxproto(char *buffer, struct kernel_param *kp)
  1264. {
  1265. int type = *((unsigned int *)kp->arg);
  1266. return sprintf(buffer, "%s\n", psmouse_protocol_by_type(type)->name);
  1267. }
  1268. static int __init psmouse_init(void)
  1269. {
  1270. int err;
  1271. kpsmoused_wq = create_singlethread_workqueue("kpsmoused");
  1272. if (!kpsmoused_wq) {
  1273. printk(KERN_ERR "psmouse: failed to create kpsmoused workqueue\n");
  1274. return -ENOMEM;
  1275. }
  1276. err = serio_register_driver(&psmouse_drv);
  1277. if (err)
  1278. destroy_workqueue(kpsmoused_wq);
  1279. return err;
  1280. }
  1281. static void __exit psmouse_exit(void)
  1282. {
  1283. serio_unregister_driver(&psmouse_drv);
  1284. destroy_workqueue(kpsmoused_wq);
  1285. }
  1286. module_init(psmouse_init);
  1287. module_exit(psmouse_exit);