开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
adbhid.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：26k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

adbhid.c：源码内容
  1. /*
  2.  * drivers/input/adbhid.c
  3.  *
  4.  * ADB HID driver for Power Macintosh computers.
  5.  *
  6.  * Adapted from drivers/macintosh/mac_keyb.c by Franz Sirl
  7.  * (see that file for its authors and contributors).
  8.  *
  9.  * Copyright (C) 2000 Franz Sirl.
  10.  *
  11.  * Adapted to ADB changes and support for more devices by
  12.  * Benjamin Herrenschmidt. Adapted from code in MkLinux
  13.  * and reworked.
  14.  * 
  15.  * Supported devices:
  16.  *
  17.  * - Standard 1 button mouse
  18.  * - All standard Apple Extended protocol (handler ID 4)
  19.  * - mouseman and trackman mice & trackballs 
  20.  * - PowerBook Trackpad (default setup: enable tapping)
  21.  * - MicroSpeed mouse & trackball (needs testing)
  22.  * - CH Products Trackball Pro (needs testing)
  23.  * - Contour Design (Contour Mouse)
  24.  * - Hunter digital (NoHandsMouse)
  25.  * - Kensignton TurboMouse 5 (needs testing)
  26.  * - Mouse Systems A3 mice and trackballs <aidan@kublai.com>
  27.  * - MacAlly 2-buttons mouse (needs testing) <pochini@denise.shiny.it>
  28.  *
  29.  * To do:
  30.  *
  31.  * Improve Kensington support.
  32.  */
  34. #include <linux/config.h>
  35. #include <linux/module.h>
  36. #include <linux/slab.h>
  37. #include <linux/init.h>
  38. #include <linux/notifier.h>
  39. #include <linux/input.h>
  40. #include <linux/kbd_ll.h>
  42. #include <linux/adb.h>
  43. #include <linux/cuda.h>
  44. #include <linux/pmu.h>
  45. #ifdef CONFIG_PMAC_BACKLIGHT
  46. #include <asm/backlight.h>
  47. #endif
  49. MODULE_AUTHOR("Franz Sirl <Franz.Sirl-kernel@lauterbach.com>");
  51. #define KEYB_KEYREG 0 /* register # for key up/down data */
  52. #define KEYB_LEDREG 2 /* register # for leds on ADB keyboard */
  53. #define MOUSE_DATAREG 0 /* reg# for movement/button codes from mouse */
  55. static int adb_message_handler(struct notifier_block *, unsigned long, void *);
  56. static struct notifier_block adbhid_adb_notifier = {
  57. notifier_call: adb_message_handler,
  58. };
  60. unsigned char adb_to_linux_keycodes[128] = {
  61.  30, 31, 32, 33, 35, 34, 44, 45, 46, 47, 86, 48, 16, 17, 18, 19,
  62.  21, 20,  2,  3,  4,  5,  7,  6, 13, 10,  8, 12,  9, 11, 27, 24,
  63.  22, 26, 23, 25, 28, 38, 36, 40, 37, 39, 43, 51, 53, 49, 50, 52,
  64.  15, 57, 41, 14, 96,  1, 29,125, 42, 58, 56,105,106,108,103,  0,
  65.   0, 83,  0, 55,  0, 78,  0, 69,  0,  0,  0, 98, 96,  0, 74,  0,
  66.   0,117, 82, 79, 80, 81, 75, 76, 77, 71,  0, 72, 73,183,181,124,
  67.  63, 64, 65, 61, 66, 67,191, 87,190, 99,  0, 70,  0, 68,101, 88,
  68.   0,119,110,102,104,111, 62,107, 60,109, 59, 54,100, 97,116,116
  69. };
  71. struct adbhid {
  72. struct input_dev input;
  73. int id;
  74. int default_id;
  75. int original_handler_id;
  76. int current_handler_id;
  77. int mouse_kind;
  78. unsigned char *keycode;
  79. char name[64];
  80. };
  82. static struct adbhid *adbhid[16] = { 0 };
  84. static void adbhid_probe(void);
  86. static void adbhid_input_keycode(int, int, int);
  87. static void leds_done(struct adb_request *);
  89. static void init_trackpad(int id);
  90. static void init_trackball(int id);
  91. static void init_turbomouse(int id);
  92. static void init_microspeed(int id);
  93. static void init_ms_a3(int id);
  95. static struct adb_ids keyboard_ids;
  96. static struct adb_ids mouse_ids;
  97. static struct adb_ids buttons_ids;
  99. #ifdef CONFIG_PMAC_BACKLIGHT
  100. /* Exported to via-pmu.c */
  101. int disable_kernel_backlight = 0;
  102. #endif /* CONFIG_PMAC_BACKLIGHT */
  104. /* Kind of keyboard, see Apple technote 1152  */
  105. #define ADB_KEYBOARD_UNKNOWN 0
  106. #define ADB_KEYBOARD_ANSI 0x0100
  107. #define ADB_KEYBOARD_ISO 0x0200
  108. #define ADB_KEYBOARD_JIS 0x0300
  110. /* Kind of mouse  */
  111. #define ADBMOUSE_STANDARD_100 0 /* Standard 100cpi mouse (handler 1) */
  112. #define ADBMOUSE_STANDARD_200 1 /* Standard 200cpi mouse (handler 2) */
  113. #define ADBMOUSE_EXTENDED 2 /* Apple Extended mouse (handler 4) */
  114. #define ADBMOUSE_TRACKBALL 3 /* TrackBall (handler 4) */
  115. #define ADBMOUSE_TRACKPAD       4 /* Apple's PowerBook trackpad (handler 4) */
  116. #define ADBMOUSE_TURBOMOUSE5    5 /* Turbomouse 5 (previously req. mousehack) */
  117. #define ADBMOUSE_MICROSPEED 6 /* Microspeed mouse (&trackball ?), MacPoint */
  118. #define ADBMOUSE_TRACKBALLPRO 7 /* Trackball Pro (special buttons) */
  119. #define ADBMOUSE_MS_A3 8 /* Mouse systems A3 trackball (handler 3) */
  120. #define ADBMOUSE_MACALLY2 9 /* MacAlly 2-button mouse */
  122. static void
  123. adbhid_keyboard_input(unsigned char *data, int nb, struct pt_regs *regs, int apoll)
  124. {
  125. int id = (data[0] >> 4) & 0x0f;
  127. if (!adbhid[id]) {
  128. printk(KERN_ERR "ADB HID on ID %d not yet registered, packet %#02x, %#02x, %#02x, %#02xn",
  129.        id, data[0], data[1], data[2], data[3]);
  130. return;
  131. }
  133. /* first check this is from register 0 */
  134. if (nb != 3 || (data[0] & 3) != KEYB_KEYREG)
  135. return; /* ignore it */
  136. kbd_pt_regs = regs;
  137. adbhid_input_keycode(id, data[1], 0);
  138. if (!(data[2] == 0xff || (data[2] == 0x7f && data[1] == 0x7f)))
  139. adbhid_input_keycode(id, data[2], 0);
  140. }
  142. static void
  143. adbhid_input_keycode(int id, int keycode, int repeat)
  144. {
  145. int up_flag;
  147. up_flag = (keycode & 0x80);
  148. keycode &= 0x7f;
  150. switch (keycode) {
  151. case 0x39: /* Generate down/up events for CapsLock everytime. */
  152. input_report_key(&adbhid[id]->input, KEY_CAPSLOCK, 1);
  153. input_report_key(&adbhid[id]->input, KEY_CAPSLOCK, 0);
  154. return;
  155. case 0x3f: /* ignore Powerbook Fn key */
  156. return;
  157. }
  159. if (adbhid[id]->keycode[keycode])
  160. input_report_key(&adbhid[id]->input,
  161.  adbhid[id]->keycode[keycode], !up_flag);
  162. else
  163. printk(KERN_INFO "Unhandled ADB key (scancode %#02x) %s.n", keycode,
  164.        up_flag ? "released" : "pressed");
  165. }
  167. static void
  168. adbhid_mouse_input(unsigned char *data, int nb, struct pt_regs *regs, int autopoll)
  169. {
  170. int id = (data[0] >> 4) & 0x0f;
  172. if (!adbhid[id]) {
  173. printk(KERN_ERR "ADB HID on ID %d not yet registeredn", id);
  174. return;
  175. }
  177.   /*
  178.     Handler 1 -- 100cpi original Apple mouse protocol.
  179.     Handler 2 -- 200cpi original Apple mouse protocol.
  181.     For Apple's standard one-button mouse protocol the data array will
  182.     contain the following values:
  184.                 BITS    COMMENTS
  185.     data[0] = dddd 1100 ADB command: Talk, register 0, for device dddd.
  186.     data[1] = bxxx xxxx First button and x-axis motion.
  187.     data[2] = byyy yyyy Second button and y-axis motion.
  189.     Handler 4 -- Apple Extended mouse protocol.
  191.     For Apple's 3-button mouse protocol the data array will contain the
  192.     following values:
  194. BITS    COMMENTS
  195.     data[0] = dddd 1100 ADB command: Talk, register 0, for device dddd.
  196.     data[1] = bxxx xxxx Left button and x-axis motion.
  197.     data[2] = byyy yyyy Second button and y-axis motion.
  198.     data[3] = byyy bxxx Third button and fourth button.  Y is additional
  199.       high bits of y-axis motion.  XY is additional
  200.       high bits of x-axis motion.
  202.     MacAlly 2-button mouse protocol.
  204.     For MacAlly 2-button mouse protocol the data array will contain the
  205.     following values:
  207. BITS    COMMENTS
  208.     data[0] = dddd 1100 ADB command: Talk, register 0, for device dddd.
  209.     data[1] = bxxx xxxx Left button and x-axis motion.
  210.     data[2] = byyy yyyy Right button and y-axis motion.
  211.     data[3] = ???? ???? unknown
  212.     data[4] = ???? ???? unknown
  214.   */
  216. /* If it's a trackpad, we alias the second button to the first.
  217.    NOTE: Apple sends an ADB flush command to the trackpad when
  218.          the first (the real) button is released. We could do
  219.  this here using async flush requests.
  220. */
  221. switch (adbhid[id]->mouse_kind)
  222. {
  223.     case ADBMOUSE_TRACKPAD:
  224. data[1] = (data[1] & 0x7f) | ((data[1] & data[2]) & 0x80);
  225. data[2] = data[2] | 0x80;
  226. break;
  227.     case ADBMOUSE_MICROSPEED:
  228. data[1] = (data[1] & 0x7f) | ((data[3] & 0x01) << 7);
  229. data[2] = (data[2] & 0x7f) | ((data[3] & 0x02) << 6);
  230. data[3] = (data[3] & 0x77) | ((data[3] & 0x04) << 5)
  231. | (data[3] & 0x08);
  232. break;
  233.     case ADBMOUSE_TRACKBALLPRO:
  234. data[1] = (data[1] & 0x7f) | (((data[3] & 0x04) << 5)
  235. & ((data[3] & 0x08) << 4));
  236. data[2] = (data[2] & 0x7f) | ((data[3] & 0x01) << 7);
  237. data[3] = (data[3] & 0x77) | ((data[3] & 0x02) << 6);
  238. break;
  239.     case ADBMOUSE_MS_A3:
  240. data[1] = (data[1] & 0x7f) | ((data[3] & 0x01) << 7);
  241. data[2] = (data[2] & 0x7f) | ((data[3] & 0x02) << 6);
  242. data[3] = ((data[3] & 0x04) << 5);
  243. break;
  244.             case ADBMOUSE_MACALLY2:
  245. data[3] = (data[2] & 0x80) ? 0x80 : 0x00;
  246. data[2] |= 0x80;  /* Right button is mapped as button 3 */
  247. nb=4;
  248.                 break;
  249. }
  251. input_report_key(&adbhid[id]->input, BTN_LEFT,   !((data[1] >> 7) & 1));
  252. input_report_key(&adbhid[id]->input, BTN_MIDDLE, !((data[2] >> 7) & 1));
  254. if (nb >= 4)
  255. input_report_key(&adbhid[id]->input, BTN_RIGHT,  !((data[3] >> 7) & 1));
  257. input_report_rel(&adbhid[id]->input, REL_X,
  258.  ((data[2]&0x7f) < 64 ? (data[2]&0x7f) : (data[2]&0x7f)-128 ));
  259. input_report_rel(&adbhid[id]->input, REL_Y,
  260.  ((data[1]&0x7f) < 64 ? (data[1]&0x7f) : (data[1]&0x7f)-128 ));
  261. }
  263. static void
  264. adbhid_buttons_input(unsigned char *data, int nb, struct pt_regs *regs, int autopoll)
  265. {
  266. int id = (data[0] >> 4) & 0x0f;
  268. if (!adbhid[id]) {
  269. printk(KERN_ERR "ADB HID on ID %d not yet registeredn", id);
  270. return;
  271. }
  273. switch (adbhid[id]->original_handler_id) {
  274. default:
  275. case 0x02: /* Adjustable keyboard button device */
  276. printk(KERN_INFO "Unhandled ADB_MISC event %02x, %02x, %02x, %02xn",
  277.        data[0], data[1], data[2], data[3]);
  278. break;
  279. case 0x1f: /* Powerbook button device */
  280.   {
  281.    int down = (data[1] == (data[1] & 0xf));
  282. #ifdef CONFIG_PMAC_BACKLIGHT
  283. int backlight = get_backlight_level();
  284. #endif
  285. /*
  286.  * XXX: Where is the contrast control for the passive?
  287.  *  -- Cort
  288.  */
  290. switch (data[1] & 0x0f) {
  291. case 0x8: /* mute */
  292. input_report_key(&adbhid[id]->input, KEY_MUTE, down);
  293. break;
  295. case 0x7: /* volume decrease */
  296. input_report_key(&adbhid[id]->input, KEY_VOLUMEDOWN, down);
  297. break;
  299. case 0x6: /* volume increase */
  300. input_report_key(&adbhid[id]->input, KEY_VOLUMEUP, down);
  301.   break;
  303. case 0xb: /* eject */
  304. input_report_key(&adbhid[id]->input, KEY_EJECTCD, down);
  305. break;
  306. case 0xa: /* brightness decrease */
  307. #ifdef CONFIG_PMAC_BACKLIGHT
  308. if (!disable_kernel_backlight) {
  309. if (!down || backlight < 0)
  310. break;
  311. if (backlight > BACKLIGHT_OFF)
  312. set_backlight_level(backlight-1);
  313. else
  314. set_backlight_level(BACKLIGHT_OFF);
  315. break;
  316. }
  317. #endif /* CONFIG_PMAC_BACKLIGHT */
  318. input_report_key(&adbhid[id]->input, KEY_BRIGHTNESSDOWN, down);
  319. break;
  320. case 0x9: /* brightness increase */
  321. #ifdef CONFIG_PMAC_BACKLIGHT
  322. if (!disable_kernel_backlight) {
  323. if (!down || backlight < 0)
  324. break;
  325. if (backlight < BACKLIGHT_MAX)
  326. set_backlight_level(backlight+1);
  327. else 
  328. set_backlight_level(BACKLIGHT_MAX);
  329. break;
  330. }
  331. #endif /* CONFIG_PMAC_BACKLIGHT */
  332. input_report_key(&adbhid[id]->input, KEY_BRIGHTNESSUP, down);
  333. break;
  334. }
  335.   }
  336.   break;
  337. }
  338. }
  340. static struct adb_request led_request;
  341. static int leds_pending[16];
  342. static int pending_devs[16];
  343. static int pending_led_start=0;
  344. static int pending_led_end=0;
  346. static void real_leds(unsigned char leds, int device)
  347. {
  348.     if (led_request.complete) {
  349. adb_request(&led_request, leds_done, 0, 3,
  350.     ADB_WRITEREG(device, KEYB_LEDREG), 0xff,
  351.     ~leds);
  352.     } else {
  353. if (!(leds_pending[device] & 0x100)) {
  354.     pending_devs[pending_led_end] = device;
  355.     pending_led_end++;
  356.     pending_led_end = (pending_led_end < 16) ? pending_led_end : 0;
  357. }
  358. leds_pending[device] = leds | 0x100;
  359.     }
  360. }
  362. /*
  363.  * Event callback from the input module. Events that change the state of
  364.  * the hardware are processed here.
  365.  */
  366. static int adbhid_kbd_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
  367. {
  368. struct adbhid *adbhid = dev->private;
  369. unsigned char leds;
  371. switch (type) {
  372. case EV_LED:
  373.   leds = (test_bit(LED_SCROLLL, dev->led) ? 4 : 0)
  374.        | (test_bit(LED_NUML,    dev->led) ? 1 : 0)
  375.        | (test_bit(LED_CAPSL,   dev->led) ? 2 : 0);
  376.   real_leds(leds, adbhid->id);
  377.   return 0;
  378. }
  380. return -1;
  381. }
  383. static void leds_done(struct adb_request *req)
  384. {
  385.     int leds,device;
  387.     if (pending_led_start != pending_led_end) {
  388. device = pending_devs[pending_led_start];
  389. leds = leds_pending[device] & 0xff;
  390. leds_pending[device] = 0;
  391. pending_led_start++;
  392. pending_led_start = (pending_led_start < 16) ? pending_led_start : 0;
  393. real_leds(leds,device);
  394.     }
  396. }
  398. static int
  399. adb_message_handler(struct notifier_block *this, unsigned long code, void *x)
  400. {
  401. unsigned long flags;
  403. switch (code) {
  404. case ADB_MSG_PRE_RESET:
  405. case ADB_MSG_POWERDOWN:
  406.      /* Stop the repeat timer. Autopoll is already off at this point */
  407. save_flags(flags);
  408. cli();
  409. {
  410. int i;
  411. for (i = 1; i < 16; i++) {
  412. if (adbhid[i])
  413. del_timer(&adbhid[i]->input.timer);
  414. }
  415. }
  416. restore_flags(flags);
  418. /* Stop pending led requests */
  419. while(!led_request.complete)
  420. adb_poll();
  421. break;
  423. case ADB_MSG_POST_RESET:
  424. adbhid_probe();
  425. break;
  426. }
  427. return NOTIFY_DONE;
  428. }
  430. static void
  431. adbhid_input_register(int id, int default_id, int original_handler_id,
  432.       int current_handler_id, int mouse_kind)
  433. {
  434. int i;
  436. if (adbhid[id]) {
  437. printk(KERN_ERR "Trying to reregister ADB HID on ID %dn", id);
  438. return;
  439. }
  441. if (!(adbhid[id] = kmalloc(sizeof(struct adbhid), GFP_KERNEL)))
  442. return;
  444. memset(adbhid[id], 0, sizeof(struct adbhid));
  446. adbhid[id]->id = default_id;
  447. adbhid[id]->original_handler_id = original_handler_id;
  448. adbhid[id]->current_handler_id = current_handler_id;
  449. adbhid[id]->mouse_kind = mouse_kind;
  450. adbhid[id]->input.private = adbhid[id];
  451. adbhid[id]->input.name = adbhid[id]->name;
  452. adbhid[id]->input.idbus = BUS_ADB;
  453. adbhid[id]->input.idvendor = 0x0001;
  454. adbhid[id]->input.idproduct = (id << 12) | (default_id << 8) | original_handler_id;
  455. adbhid[id]->input.idversion = 0x0100;
  457. switch (default_id) {
  458. case ADB_KEYBOARD:
  459. if (!(adbhid[id]->keycode = kmalloc(sizeof(adb_to_linux_keycodes), GFP_KERNEL))) {
  460. kfree(adbhid[id]);
  461. return;
  462. }
  464. sprintf(adbhid[id]->name, "ADB keyboard on ID %d:%d.%02x",
  465. id, default_id, original_handler_id);
  467. memcpy(adbhid[id]->keycode, adb_to_linux_keycodes, sizeof(adb_to_linux_keycodes));
  469. printk(KERN_INFO "Detected ADB keyboard, type ");
  470. switch (original_handler_id) {
  471. default:
  472. printk("<unknown>.n");
  473. adbhid[id]->input.idversion = ADB_KEYBOARD_UNKNOWN;
  474. break;
  476. case 0x01: case 0x02: case 0x03: case 0x06: case 0x08:
  477. case 0x0C: case 0x10: case 0x18: case 0x1B: case 0x1C:
  478. case 0xC0: case 0xC3: case 0xC6:
  479. printk("ANSI.n");
  480. adbhid[id]->input.idversion = ADB_KEYBOARD_ANSI;
  481. break;
  483. case 0x04: case 0x05: case 0x07: case 0x09: case 0x0D:
  484. case 0x11: case 0x14: case 0x19: case 0x1D: case 0xC1:
  485. case 0xC4: case 0xC7:
  486. printk("ISO, swapping keys.n");
  487. adbhid[id]->input.idversion = ADB_KEYBOARD_ISO;
  488. i = adbhid[id]->keycode[10];
  489. adbhid[id]->keycode[10] = adbhid[id]->keycode[50];
  490. adbhid[id]->keycode[50] = i;
  491. break;
  493. case 0x12: case 0x15: case 0x16: case 0x17: case 0x1A:
  494. case 0x1E: case 0xC2: case 0xC5: case 0xC8: case 0xC9:
  495. printk("JIS.n");
  496. adbhid[id]->input.idversion = ADB_KEYBOARD_JIS;
  497. break;
  498. }
  500. for (i = 0; i < 128; i++)
  501. if (adbhid[id]->keycode[i])
  502. set_bit(adbhid[id]->keycode[i], adbhid[id]->input.keybit);
  504. adbhid[id]->input.evbit[0] = BIT(EV_KEY) | BIT(EV_LED) | BIT(EV_REP);
  505. adbhid[id]->input.ledbit[0] = BIT(LED_SCROLLL) | BIT(LED_CAPSL) | BIT(LED_NUML);
  506. adbhid[id]->input.event = adbhid_kbd_event;
  507. adbhid[id]->input.keycodemax = 127;
  508. adbhid[id]->input.keycodesize = 1;
  509. break;
  511. case ADB_MOUSE:
  512. sprintf(adbhid[id]->name, "ADB mouse on ID %d:%d.%02x",
  513. id, default_id, original_handler_id);
  515. adbhid[id]->input.evbit[0] = BIT(EV_KEY) | BIT(EV_REL);
  516. adbhid[id]->input.keybit[LONG(BTN_MOUSE)] = BIT(BTN_LEFT) | BIT(BTN_MIDDLE) | BIT(BTN_RIGHT);
  517. adbhid[id]->input.relbit[0] = BIT(REL_X) | BIT(REL_Y);
  518. break;
  520. case ADB_MISC:
  521. switch (original_handler_id) {
  522. case 0x02: /* Adjustable keyboard button device */
  523. sprintf(adbhid[id]->name, "ADB adjustable keyboard buttons on ID %d:%d.%02x",
  524. id, default_id, original_handler_id);
  525. break;
  526. case 0x1f: /* Powerbook button device */
  527. sprintf(adbhid[id]->name, "ADB Powerbook buttons on ID %d:%d.%02x",
  528. id, default_id, original_handler_id);
  529. adbhid[id]->input.evbit[0] = BIT(EV_KEY) | BIT(EV_REP);
  530. set_bit(KEY_MUTE, adbhid[id]->input.keybit);
  531. set_bit(KEY_VOLUMEUP, adbhid[id]->input.keybit);
  532. set_bit(KEY_VOLUMEDOWN, adbhid[id]->input.keybit);
  533. set_bit(KEY_BRIGHTNESSUP, adbhid[id]->input.keybit);
  534. set_bit(KEY_BRIGHTNESSDOWN, adbhid[id]->input.keybit);
  535. set_bit(KEY_EJECTCD, adbhid[id]->input.keybit);
  536. break;
  537. }
  538. if (adbhid[id]->name[0])
  539. break;
  540. /* else fall through */
  542. default:
  543. printk(KERN_INFO "Trying to register unknown ADB device to input layer.n");
  544. kfree(adbhid[id]);
  545. return;
  546. }
  548. adbhid[id]->input.keycode = adbhid[id]->keycode;
  550. input_register_device(&adbhid[id]->input);
  552. printk(KERN_INFO "input%d: ADB HID on ID %d:%d.%02xn",
  553.        adbhid[id]->input.number, id, default_id, original_handler_id);
  555. if (default_id == ADB_KEYBOARD) {
  556. /* HACK WARNING!! This should go away as soon there is an utility
  557.  * to control that for event devices.
  558.  */
  559. adbhid[id]->input.rep[REP_DELAY] = HZ/2;   /* input layer default: HZ/4 */
  560. adbhid[id]->input.rep[REP_PERIOD] = HZ/15; /* input layer default: HZ/33 */
  561. }
  562. }
  564. static void adbhid_input_unregister(int id)
  565. {
  566. input_unregister_device(&adbhid[id]->input);
  567. if (adbhid[id]->keycode)
  568. kfree(adbhid[id]->keycode);
  569. kfree(adbhid[id]);
  570. adbhid[id] = 0;
  571. }
  574. static u16
  575. adbhid_input_reregister(int id, int default_id, int org_handler_id,
  576. int cur_handler_id, int mk)
  577. {
  578. if (adbhid[id]) {
  579. if (adbhid[id]->input.idproduct !=
  580.     ((id << 12)|(default_id << 8)|org_handler_id)) {
  581. adbhid_input_unregister(id);
  582. adbhid_input_register(id, default_id, org_handler_id,
  583. cur_handler_id, mk);
  584. }
  585. } else
  586. adbhid_input_register(id, default_id, org_handler_id,
  587. cur_handler_id, mk);
  588. return 1<<id;
  589. }
  591. static void
  592. adbhid_input_devcleanup(u16 exist)
  593. {
  594. int i;
  595. for(i=1; i<16; i++)
  596.     if (adbhid[i] && !(exist&(1<<i)))
  597. adbhid_input_unregister(i);
  598. }
  599.  
  600. static void
  601. adbhid_probe(void)
  602. {
  603. struct adb_request req;
  604. int i, default_id, org_handler_id, cur_handler_id;
  605. u16 reg = 0;
  607. adb_register(ADB_MOUSE, 0, &mouse_ids, adbhid_mouse_input);
  608. adb_register(ADB_KEYBOARD, 0, &keyboard_ids, adbhid_keyboard_input);
  609. adb_register(ADB_MISC, 0, &buttons_ids, adbhid_buttons_input);
  611. for (i = 0; i < keyboard_ids.nids; i++) {
  612. int id = keyboard_ids.id[i];
  614. adb_get_infos(id, &default_id, &org_handler_id);
  616. /* turn off all leds */
  617. adb_request(&req, NULL, ADBREQ_SYNC, 3,
  618.     ADB_WRITEREG(id, KEYB_LEDREG), 0xff, 0xff);
  620. /* Enable full feature set of the keyboard
  621.    ->get it to send separate codes for left and right shift,
  622.    control, option keys */
  623. #if 0 /* handler 5 doesn't send separate codes for R modifiers */
  624. if (adb_try_handler_change(id, 5))
  625. printk("ADB keyboard at %d, handler set to 5n", id);
  626. else
  627. #endif
  628. if (adb_try_handler_change(id, 3))
  629. printk("ADB keyboard at %d, handler set to 3n", id);
  630. else
  631. printk("ADB keyboard at %d, handler 1n", id);
  633. adb_get_infos(id, &default_id, &cur_handler_id);
  634. reg |= adbhid_input_reregister(id, default_id, org_handler_id, cur_handler_id, 0);
  635. }
  637. for (i = 0; i < buttons_ids.nids; i++) {
  638. int id = buttons_ids.id[i];
  640. adb_get_infos(id, &default_id, &org_handler_id);
  641. reg |= adbhid_input_reregister(id, default_id, org_handler_id, org_handler_id, 0);
  642. }
  644. /* Try to switch all mice to handler 4, or 2 for three-button
  645.    mode and full resolution. */
  646. for (i = 0; i < mouse_ids.nids; i++) {
  647. int id = mouse_ids.id[i];
  648. int mouse_kind;
  650. adb_get_infos(id, &default_id, &org_handler_id);
  652. if (adb_try_handler_change(id, 4)) {
  653. printk("ADB mouse at %d, handler set to 4", id);
  654. mouse_kind = ADBMOUSE_EXTENDED;
  655. }
  656. else if (adb_try_handler_change(id, 0x2F)) {
  657. printk("ADB mouse at %d, handler set to 0x2F", id);
  658. mouse_kind = ADBMOUSE_MICROSPEED;
  659. }
  660. else if (adb_try_handler_change(id, 0x42)) {
  661. printk("ADB mouse at %d, handler set to 0x42", id);
  662. mouse_kind = ADBMOUSE_TRACKBALLPRO;
  663. }
  664. else if (adb_try_handler_change(id, 0x66)) {
  665. printk("ADB mouse at %d, handler set to 0x66", id);
  666. mouse_kind = ADBMOUSE_MICROSPEED;
  667. }
  668. else if (adb_try_handler_change(id, 0x5F)) {
  669. printk("ADB mouse at %d, handler set to 0x5F", id);
  670. mouse_kind = ADBMOUSE_MICROSPEED;
  671. }
  672. else if (adb_try_handler_change(id, 3)) {
  673. printk("ADB mouse at %d, handler set to 3", id);
  674. mouse_kind = ADBMOUSE_MS_A3;
  675. }
  676. else if (adb_try_handler_change(id, 2)) {
  677. printk("ADB mouse at %d, handler set to 2", id);
  678. mouse_kind = ADBMOUSE_STANDARD_200;
  679. }
  680. else {
  681. printk("ADB mouse at %d, handler 1", id);
  682. mouse_kind = ADBMOUSE_STANDARD_100;
  683. }
  685. if ((mouse_kind == ADBMOUSE_TRACKBALLPRO)
  686.     || (mouse_kind == ADBMOUSE_MICROSPEED)) {
  687. init_microspeed(id);
  688. } else if (mouse_kind == ADBMOUSE_MS_A3) {
  689. init_ms_a3(id);
  690. } else if (mouse_kind ==  ADBMOUSE_EXTENDED) {
  691. /*
  692.  * Register 1 is usually used for device
  693.  * identification.  Here, we try to identify
  694.  * a known device and call the appropriate
  695.  * init function.
  696.  */
  697. adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
  698.     ADB_READREG(id, 1));
  700. if ((req.reply_len) &&
  701.     (req.reply[1] == 0x9a) && ((req.reply[2] == 0x21)
  702.      || (req.reply[2] == 0x20))) {
  703. mouse_kind = ADBMOUSE_TRACKBALL;
  704. init_trackball(id);
  705. }
  706. else if ((req.reply_len >= 4) &&
  707.     (req.reply[1] == 0x74) && (req.reply[2] == 0x70) &&
  708.     (req.reply[3] == 0x61) && (req.reply[4] == 0x64)) {
  709. mouse_kind = ADBMOUSE_TRACKPAD;
  710. init_trackpad(id);
  711. }
  712. else if ((req.reply_len >= 4) &&
  713.     (req.reply[1] == 0x4b) && (req.reply[2] == 0x4d) &&
  714.     (req.reply[3] == 0x4c) && (req.reply[4] == 0x31)) {
  715. mouse_kind = ADBMOUSE_TURBOMOUSE5;
  716. init_turbomouse(id);
  717. }
  718. else if ((req.reply_len == 9) &&
  719.     (req.reply[1] == 0x4b) && (req.reply[2] == 0x4f) &&
  720.     (req.reply[3] == 0x49) && (req.reply[4] == 0x54)) {
  721. if (adb_try_handler_change(id, 0x42)) {
  722. printk("nADB MacAlly 2-button mouse at %d, handler set to 0x42", id);
  723. mouse_kind = ADBMOUSE_MACALLY2;
  724. }
  725. }
  726. }
  727. printk("n");
  729. adb_get_infos(id, &default_id, &cur_handler_id);
  730. reg |= adbhid_input_reregister(id, default_id, org_handler_id,
  731.       cur_handler_id, mouse_kind);
  732.         }
  733. adbhid_input_devcleanup(reg);
  734. }
  736. static void 
  737. init_trackpad(int id)
  738. {
  739. struct adb_request req;
  740. unsigned char r1_buffer[8];
  742. printk(" (trackpad)");
  744. adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
  745. ADB_READREG(id,1));
  746. if (req.reply_len < 8)
  747.     printk("bad length for reg. 1n");
  748. else
  749. {
  750.     memcpy(r1_buffer, &req.reply[1], 8);
  752.     adb_request(&req, NULL, ADBREQ_SYNC, 9,
  753.         ADB_WRITEREG(id,1),
  754.             r1_buffer[0],
  755.             r1_buffer[1],
  756.             r1_buffer[2],
  757.             r1_buffer[3],
  758.             r1_buffer[4],
  759.             r1_buffer[5],
  760.             0x0d,
  761.             r1_buffer[7]);
  763.             adb_request(&req, NULL, ADBREQ_SYNC, 9,
  764.         ADB_WRITEREG(id,2),
  765.          0x99,
  766.          0x94,
  767.          0x19,
  768.          0xff,
  769.          0xb2,
  770.          0x8a,
  771.          0x1b,
  772.          0x50);
  774.     adb_request(&req, NULL, ADBREQ_SYNC, 9,
  775.         ADB_WRITEREG(id,1),
  776.             r1_buffer[0],
  777.             r1_buffer[1],
  778.             r1_buffer[2],
  779.             r1_buffer[3],
  780.             r1_buffer[4],
  781.             r1_buffer[5],
  782.             0x03, /*r1_buffer[6],*/
  783.             r1_buffer[7]);
  785.     /* Without this flush, the trackpad may be locked up */     
  786.     adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(id));
  787.         }
  788. }
  790. static void 
  791. init_trackball(int id)
  792. {
  793. struct adb_request req;
  795. printk(" (trackman/mouseman)");
  797. adb_request(&req, NULL, ADBREQ_SYNC, 3,
  798. ADB_WRITEREG(id,1), 00,0x81);
  800. adb_request(&req, NULL, ADBREQ_SYNC, 3,
  801. ADB_WRITEREG(id,1), 01,0x81);
  803. adb_request(&req, NULL, ADBREQ_SYNC, 3,
  804. ADB_WRITEREG(id,1), 02,0x81);
  806. adb_request(&req, NULL, ADBREQ_SYNC, 3,
  807. ADB_WRITEREG(id,1), 03,0x38);
  809. adb_request(&req, NULL, ADBREQ_SYNC, 3,
  810. ADB_WRITEREG(id,1), 00,0x81);
  812. adb_request(&req, NULL, ADBREQ_SYNC, 3,
  813. ADB_WRITEREG(id,1), 01,0x81);
  815. adb_request(&req, NULL, ADBREQ_SYNC, 3,
  816. ADB_WRITEREG(id,1), 02,0x81);
  818. adb_request(&req, NULL, ADBREQ_SYNC, 3,
  819. ADB_WRITEREG(id,1), 03,0x38);
  820. }
  822. static void
  823. init_turbomouse(int id)
  824. {
  825. struct adb_request req;
  827.         printk(" (TurboMouse 5)");
  829. adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(id));
  831. adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(3));
  833. adb_request(&req, NULL, ADBREQ_SYNC, 9,
  834. ADB_WRITEREG(3,2),
  835.     0xe7,
  836.     0x8c,
  837.     0,
  838.     0,
  839.     0,
  840.     0xff,
  841.     0xff,
  842.     0x94);
  844. adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(3));
  846. adb_request(&req, NULL, ADBREQ_SYNC, 9,
  847. ADB_WRITEREG(3,2),
  848.     0xa5,
  849.     0x14,
  850.     0,
  851.     0,
  852.     0x69,
  853.     0xff,
  854.     0xff,
  855.     0x27);
  856. }
  858. static void
  859. init_microspeed(int id)
  860. {
  861. struct adb_request req;
  863.         printk(" (Microspeed/MacPoint or compatible)");
  865. adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(id));
  867. /* This will initialize mice using the Microspeed, MacPoint and
  868.    other compatible firmware. Bit 12 enables extended protocol.
  869.    
  870.    Register 1 Listen (4 Bytes)
  871.             0 -  3     Button is mouse (set also for double clicking!!!)
  872.             4 -  7     Button is locking (affects change speed also)
  873.             8 - 11     Button changes speed
  874.            12          1 = Extended mouse mode, 0 = normal mouse mode
  875.            13 - 15     unused 0
  876.            16 - 23     normal speed
  877.            24 - 31     changed speed
  879.        Register 1 talk holds version and product identification information.
  880.        Register 1 Talk (4 Bytes):
  881.             0 -  7     Product code
  882.             8 - 23     undefined, reserved
  883.            24 - 31     Version number
  884.         
  885.        Speed 0 is max. 1 to 255 set speed in increments of 1/256 of max.
  886.  */
  887. adb_request(&req, NULL, ADBREQ_SYNC, 5,
  888. ADB_WRITEREG(id,1),
  889.     0x20, /* alt speed = 0x20 (rather slow) */
  890.     0x00, /* norm speed = 0x00 (fastest) */
  891.     0x10, /* extended protocol, no speed change */
  892.     0x07); /* all buttons enabled as mouse buttons, no locking */
  895. adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(id));
  896. }
  898. static void
  899. init_ms_a3(int id)
  900. {
  901. struct adb_request req;
  903. printk(" (Mouse Systems A3 Mouse, or compatible)");
  904. adb_request(&req, NULL, ADBREQ_SYNC, 3,
  905. ADB_WRITEREG(id, 0x2),
  906.     0x00,
  907.     0x07);
  908.  
  909.   adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(id));
  910. }
  912. static int __init adbhid_init(void)
  913. {
  914. #ifndef CONFIG_MAC
  915. if ( (_machine != _MACH_chrp) && (_machine != _MACH_Pmac) )
  916.     return 0;
  917. #endif
  919. led_request.complete = 1;
  921. adbhid_probe();
  923. notifier_chain_register(&adb_client_list, &adbhid_adb_notifier);
  925. return 0;
  926. }
  928. static void __exit adbhid_exit(void)
  929. {
  930. }
  931.  
  932. module_init(adbhid_init);
  933. module_exit(adbhid_exit);