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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
sa1111_keyb.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：27k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

sa1111_keyb.c：源码内容
  1. /*
  2.  * SA1111 PS/2 keyboard/mouse driver
  3.  *
  4.  * 2000 by VASARA RESEARCH INC.
  5.  *
  6.  * Changelog:
  7.  *     Jun.xx,2000:    Kunihiko IMAI <imai@vasara.co.jp>
  8.  *                     Port to 2.4.0test1-ac19-rmk1-np1
  9.  *     Apr.17,2000:    Takafumi Kawana <kawana@pro.or.jp>
  10.  *                     Internal Release for XP860
  11.  *
  12.  *
  13.  * This driver is based on linux/drivers/char/pc_keyb.c
  14.  * Original declaration follows:
  16.  *
  17.  * linux/drivers/char/pc_keyb.c
  18.  *
  19.  * Separation of the PC low-level part by Geert Uytterhoeven, May 1997
  20.  * See keyboard.c for the whole history.
  21.  *
  22.  * Major cleanup by Martin Mares, May 1997
  23.  *
  24.  * Combined the keyboard and PS/2 mouse handling into one file,
  25.  * because they share the same hardware.
  26.  * Johan Myreen <jem@iki.fi> 1998-10-08.
  27.  *
  28.  * Code fixes to handle mouse ACKs properly.
  29.  * C. Scott Ananian <cananian@alumni.princeton.edu> 1999-01-29.
  30.  *
  31.  */
  32. #include <linux/config.h>
  33. #include <linux/spinlock.h>
  34. #include <linux/sched.h>
  35. #include <linux/interrupt.h>
  36. #include <linux/tty.h>
  37. #include <linux/mm.h>
  38. #include <linux/signal.h>
  39. #include <linux/init.h>
  40. #include <linux/kbd_ll.h>
  41. #include <linux/delay.h>
  42. #include <linux/random.h>
  43. #include <linux/poll.h>
  44. #include <linux/miscdevice.h>
  45. #include <linux/slab.h>
  46. #include <linux/kbd_kern.h>
  47. #include <linux/ioport.h>
  49. #include <asm/hardware.h>
  50. #include <asm/bitops.h>
  51. #include <asm/uaccess.h>
  52. #include <asm/irq.h>
  53. #include <asm/system.h>
  55. #include <asm/io.h>
  57. /* Some configuration switches are present in the include file... */
  59. #include <linux/pc_keyb.h>
  60. #include <asm/keyboard.h>
  61. #include <asm/hardware/sa1111.h>
  63. #define KBD_STAT_RXB    (1<<4)
  64. #define KBD_STAT_RXF    (1<<5)
  65. #define KBD_STAT_TXB    (1<<6)
  66. #define KBD_STAT_TXE    (1<<7)
  67. #define KBD_STAT_STP    (1<<8)
  69. #define MSE_STAT_RXB    (1<<4)
  70. #define MSE_STAT_RXF    (1<<5)
  71. #define MSE_STAT_TXB    (1<<6)
  72. #define MSE_STAT_TXE    (1<<7)
  73. #define MSE_STAT_STP    (1<<8)
  75. /* Simple translation table for the SysRq keys */
  77. #ifdef CONFIG_MAGIC_SYSRQ
  78. unsigned char sa1111_sysrq_xlate[128] = "00331234567890-=177t" /* 0x00 - 0x0f */
  79.     "qwertyuiop[]r00as" /* 0x10 - 0x1f */
  80.     "dfghjkl;'`00\zxcv" /* 0x20 - 0x2f */
  81.     "bnm,./00*00 00201202203204205" /* 0x30 - 0x3f */
  82.     "2062072102112120000789-456+1" /* 0x40 - 0x4f */
  83.     "230177000021321400000000000000000000" /* 0x50 - 0x5f */
  84.     "r00/"; /* 0x60 - 0x6f */
  85. #endif
  87. // static void kbd_write_command_w(int data);
  88. static void kbd_write_output_w(int data);
  90. spinlock_t kbd_controller_lock = SPIN_LOCK_UNLOCKED;
  91. static void handle_kbd_event(void);
  93. /* used only by send_data - set by keyboard_interrupt */
  94. static volatile unsigned char reply_expected = 0;
  95. static volatile unsigned char acknowledge = 0;
  96. static volatile unsigned char resend = 0;
  99. #if defined CONFIG_PSMOUSE
  100. /*
  101.  *     PS/2 Auxiliary Device
  102.  */
  104. static int __init psaux_init(void);
  106. static struct aux_queue *queue; /* Mouse data buffer. */
  107. static int aux_count = 0;
  108. /* used when we send commands to the mouse that expect an ACK. */
  109. static unsigned char mouse_reply_expected = 0;
  111. #define AUX_INTS_OFF (KBD_MODE_KCC | KBD_MODE_DISABLE_MOUSE | KBD_MODE_SYS | KBD_MODE_KBD_INT)
  112. #define AUX_INTS_ON  (KBD_MODE_KCC | KBD_MODE_SYS | KBD_MODE_MOUSE_INT | KBD_MODE_KBD_INT)
  114. #define MAX_RETRIES    60 /* some aux operations take long time */
  115. #endif /* CONFIG_PSMOUSE */
  117. /*
  118.  * Wait for keyboard controller input buffer to drain.
  119.  *
  120.  * Don't use 'jiffies' so that we don't depend on
  121.  * interrupts..
  122.  *
  123.  * Quote from PS/2 System Reference Manual:
  124.  *
  125.  * "Address hex 0060 and address hex 0064 should be written only when
  126.  * the input-buffer-full bit and output-buffer-full bit in the
  127.  * Controller Status register are set 0."
  128.  */
  130. static void kb_wait(void)
  131. {
  132. unsigned long timeout = KBC_TIMEOUT;
  134. do {
  135. /*
  136.  * "handle_kbd_event()" will handle any incoming events
  137.  * while we wait - keypresses or mouse movement.
  138.  */
  139. handle_kbd_event();
  140. if (KBDSTAT & KBD_STAT_TXE)
  141. return;
  142. mdelay(1);
  143. timeout--;
  144. }
  145. while (timeout);
  146. #ifdef KBD_REPORT_TIMEOUTS
  147. printk(KERN_WARNING "Keyboard timed out[1]n");
  148. #endif
  149. }
  151. /*
  152.  * Translation of escaped scancodes to keycodes.
  153.  * This is now user-settable.
  154.  * The keycodes 1-88,96-111,119 are fairly standard, and
  155.  * should probably not be changed - changing might confuse X.
  156.  * X also interprets scancode 0x5d (KEY_Begin).
  157.  *
  158.  * For 1-88 keycode equals scancode.
  159.  */
  161. #define E0_KPENTER 96
  162. #define E0_RCTRL   97
  163. #define E0_KPSLASH 98
  164. #define E0_PRSCR   99
  165. #define E0_RALT    100
  166. #define E0_BREAK   101 /* (control-pause) */
  167. #define E0_HOME    102
  168. #define E0_UP      103
  169. #define E0_PGUP    104
  170. #define E0_LEFT    105
  171. #define E0_RIGHT   106
  172. #define E0_END     107
  173. #define E0_DOWN    108
  174. #define E0_PGDN    109
  175. #define E0_INS     110
  176. #define E0_DEL     111
  178. /* for USB 106 keyboard */
  179. #define E0_YEN         124
  180. #define E0_BACKSLASH   89
  183. #define E1_PAUSE   119
  185. /*
  186.  * The keycodes below are randomly located in 89-95,112-118,120-127.
  187.  * They could be thrown away (and all occurrences below replaced by 0),
  188.  * but that would force many users to use the `setkeycodes' utility, where
  189.  * they needed not before. It does not matter that there are duplicates, as
  190.  * long as no duplication occurs for any single keyboard.
  191.  */
  192. #define SC_LIM 89
  194. #define FOCUS_PF1 85 /* actual code! */
  195. #define FOCUS_PF2 89
  196. #define FOCUS_PF3 90
  197. #define FOCUS_PF4 91
  198. #define FOCUS_PF5 92
  199. #define FOCUS_PF6 93
  200. #define FOCUS_PF7 94
  201. #define FOCUS_PF8 95
  202. #define FOCUS_PF9 120
  203. #define FOCUS_PF10 121
  204. #define FOCUS_PF11 122
  205. #define FOCUS_PF12 123
  207. #define JAP_86     124
  208. /* tfj@olivia.ping.dk:
  209.  * The four keys are located over the numeric keypad, and are
  210.  * labelled A1-A4. It's an rc930 keyboard, from
  211.  * Regnecentralen/RC International, Now ICL.
  212.  * Scancodes: 59, 5a, 5b, 5c.
  213.  */
  214. #define RGN1 124
  215. #define RGN2 125
  216. #define RGN3 126
  217. #define RGN4 127
  219. static unsigned char high_keys[128 - SC_LIM] = {
  220. RGN1, RGN2, RGN3, RGN4, 0, 0, 0, /* 0x59-0x5f */
  221. 0, 0, 0, 0, 0, 0, 0, 0, /* 0x60-0x67 */
  222. 0, 0, 0, 0, 0, FOCUS_PF11, 0, FOCUS_PF12, /* 0x68-0x6f */
  223. 0, 0, 0, FOCUS_PF2, FOCUS_PF9, 0, 0, FOCUS_PF3, /* 0x70-0x77 */
  224. FOCUS_PF4, FOCUS_PF5, FOCUS_PF6, FOCUS_PF7, /* 0x78-0x7b */
  225. FOCUS_PF8, JAP_86, FOCUS_PF10, 0 /* 0x7c-0x7f */
  226. };
  228. /* BTC */
  229. #define E0_MACRO   112
  230. /* LK450 */
  231. #define E0_F13     113
  232. #define E0_F14     114
  233. #define E0_HELP    115
  234. #define E0_DO      116
  235. #define E0_F17     117
  236. #define E0_KPMINPLUS 118
  237. /*
  238.  * My OmniKey generates e0 4c for  the "OMNI" key and the
  239.  * right alt key does nada. [kkoller@nyx10.cs.du.edu]
  240.  */
  241. #define E0_OK  124
  242. /*
  243.  * New microsoft keyboard is rumoured to have
  244.  * e0 5b (left window button), e0 5c (right window button),
  245.  * e0 5d (menu button). [or: LBANNER, RBANNER, RMENU]
  246.  * [or: Windows_L, Windows_R, TaskMan]
  247.  */
  248. #define E0_MSLW        125
  249. #define E0_MSRW        126
  250. #define E0_MSTM        127
  252. static unsigned char e0_keys[128] = {
  253. 0, 0, 0, 0, 0, 0, 0, 0, /* 0x00-0x07 */
  254. 0, 0, 0, 0, 0, 0, 0, 0, /* 0x08-0x0f */
  255. 0, 0, 0, 0, 0, 0, 0, 0, /* 0x10-0x17 */
  256. 0, 0, 0, 0, E0_KPENTER, E0_RCTRL, 0, 0, /* 0x18-0x1f */
  257. 0, 0, 0, 0, 0, 0, 0, 0, /* 0x20-0x27 */
  258. 0, 0, 0, 0, 0, 0, 0, 0, /* 0x28-0x2f */
  259. 0, 0, 0, 0, 0, E0_KPSLASH, 0, E0_PRSCR, /* 0x30-0x37 */
  260. E0_RALT, 0, 0, 0, 0, E0_F13, E0_F14, E0_HELP, /* 0x38-0x3f */
  261. E0_DO, E0_F17, 0, 0, 0, 0, E0_BREAK, E0_HOME, /* 0x40-0x47 */
  262. E0_UP, E0_PGUP, 0, E0_LEFT, E0_OK, E0_RIGHT, E0_KPMINPLUS, E0_END, /* 0x48-0x4f */
  263. E0_DOWN, E0_PGDN, E0_INS, E0_DEL, 0, 0, 0, 0, /* 0x50-0x57 */
  264. 0, 0, 0, E0_MSLW, E0_MSRW, E0_MSTM, 0, 0, /* 0x58-0x5f */
  265. 0, 0, 0, 0, 0, 0, 0, 0, /* 0x60-0x67 */
  266. 0, 0, 0, 0, 0, 0, 0, E0_MACRO, /* 0x68-0x6f */
  267. //0, 0, 0, 0, 0, 0, 0, 0,                          /* 0x70-0x77 */
  268. 0, 0, 0, 0, 0, E0_BACKSLASH, 0, 0, /* 0x70-0x77 */
  269. 0, 0, 0, E0_YEN, 0, 0, 0, 0 /* 0x78-0x7f */
  270. };
  272. int sa1111_setkeycode(unsigned int scancode, unsigned int keycode)
  273. {
  274. if (scancode < SC_LIM || scancode > 255 || keycode > 127)
  275. return -EINVAL;
  276. if (scancode < 128)
  277. high_keys[scancode - SC_LIM] = keycode;
  278. else
  279. e0_keys[scancode - 128] = keycode;
  280. return 0;
  281. }
  283. int sa1111_getkeycode(unsigned int scancode)
  284. {
  285. return
  286.     (scancode < SC_LIM || scancode > 255) ? -EINVAL :
  287.     (scancode <
  288.      128) ? high_keys[scancode - SC_LIM] : e0_keys[scancode - 128];
  289. }
  291. static int do_acknowledge(unsigned char scancode)
  292. {
  293. if (reply_expected) {
  294. /* Unfortunately, we must recognise these codes only if we know they
  295.  * are known to be valid (i.e., after sending a command), because there
  296.  * are some brain-damaged keyboards (yes, FOCUS 9000 again) which have
  297.  * keys with such codes :(
  298.  */
  299. if (scancode == KBD_REPLY_ACK) {
  300. acknowledge = 1;
  301. reply_expected = 0;
  302. return 0;
  303. } else if (scancode == KBD_REPLY_RESEND) {
  304. resend = 1;
  305. reply_expected = 0;
  306. return 0;
  307. }
  308. /* Should not happen... */
  309. #if 0
  310. printk(KERN_DEBUG "keyboard reply expected - got %02xn",
  311.        scancode);
  312. #endif
  313. }
  314. return 1;
  315. }
  317. int
  318. sa1111_translate(unsigned char scancode, unsigned char *keycode,
  319.  char raw_mode)
  320. {
  321. static int prev_scancode = 0;
  323. /* special prefix scancodes.. */
  324. if (scancode == 0xe0 || scancode == 0xe1) {
  325. prev_scancode = scancode;
  326. return 0;
  327. }
  329. /* 0xFF is sent by a few keyboards, ignore it. 0x00 is error */
  330. if (scancode == 0x00 || scancode == 0xff) {
  331. prev_scancode = 0;
  332. return 0;
  333. }
  335. scancode &= 0x7f;
  337. if (prev_scancode) {
  338. /*
  339.  * usually it will be 0xe0, but a Pause key generates
  340.  * e1 1d 45 e1 9d c5 when pressed, and nothing when released
  341.  */
  342. if (prev_scancode != 0xe0) {
  343. if (prev_scancode == 0xe1 && scancode == 0x1d) {
  344. prev_scancode = 0x100;
  345. return 0;
  346. }
  347. else if (prev_scancode == 0x100
  348.  && scancode == 0x45) {
  349. *keycode = E1_PAUSE;
  350. prev_scancode = 0;
  351. } else {
  352. #ifdef KBD_REPORT_UNKN
  353. if (!raw_mode)
  354. printk(KERN_INFO
  355.        "keyboard: unknown e1 escape sequencen");
  356. #endif
  357. prev_scancode = 0;
  358. return 0;
  359. }
  360. } else {
  361. prev_scancode = 0;
  362. /*
  363.  *  The keyboard maintains its own internal caps lock and
  364.  *  num lock statuses. In caps lock mode E0 AA precedes make
  365.  *  code and E0 2A follows break code. In num lock mode,
  366.  *  E0 2A precedes make code and E0 AA follows break code.
  367.  *  We do our own book-keeping, so we will just ignore these.
  368.  */
  369. /*
  370.  *  For my keyboard there is no caps lock mode, but there are
  371.  *  both Shift-L and Shift-R modes. The former mode generates
  372.  *  E0 2A / E0 AA pairs, the latter E0 B6 / E0 36 pairs.
  373.  *  So, we should also ignore the latter. - aeb@cwi.nl
  374.  */
  375. if (scancode == 0x2a || scancode == 0x36)
  376. return 0;
  378. if (e0_keys[scancode])
  379. *keycode = e0_keys[scancode];
  380. else {
  381. #ifdef KBD_REPORT_UNKN
  382. if (!raw_mode)
  383. printk(KERN_INFO
  384.        "keyboard: unknown scancode e0 %02xn",
  385.        scancode);
  386. #endif
  387. return 0;
  388. }
  389. }
  390. } else if (scancode >= SC_LIM) {
  391. /* This happens with the FOCUS 9000 keyboard
  392.    Its keys PF1..PF12 are reported to generate
  393.    55 73 77 78 79 7a 7b 7c 74 7e 6d 6f
  394.    Moreover, unless repeated, they do not generate
  395.    key-down events, so we have to zero up_flag below */
  396. /* Also, Japanese 86/106 keyboards are reported to
  397.    generate 0x73 and 0x7d for  - and  | respectively. */
  398. /* Also, some Brazilian keyboard is reported to produce
  399.    0x73 and 0x7e for  ? and KP-dot, respectively. */
  401. *keycode = high_keys[scancode - SC_LIM];
  403. if (!*keycode) {
  404. if (!raw_mode) {
  405. #ifdef KBD_REPORT_UNKN
  406. printk(KERN_INFO
  407.        "keyboard: unrecognized scancode (%02x)"
  408.        " - ignoredn", scancode);
  409. #endif
  410. }
  411. return 0;
  412. }
  413. } else
  414. *keycode = scancode;
  415. return 1;
  416. }
  418. char sa1111_unexpected_up(unsigned char keycode)
  419. {
  420. /* unexpected, but this can happen: maybe this was a key release for a
  421.    FOCUS 9000 PF key; if we want to see it, we have to clear up_flag */
  422. if (keycode >= SC_LIM || keycode == 85)
  423. return 0;
  424. else
  425. return 0200;
  426. }
  428. static unsigned char kbd_exists = 1;
  430. static inline void handle_keyboard_event(unsigned char scancode)
  431. {
  432. #ifdef CONFIG_VT
  433. kbd_exists = 1;
  434. if (do_acknowledge(scancode))
  435. handle_scancode(scancode, !(scancode & 0x80));
  436. #endif
  437. tasklet_schedule(&keyboard_tasklet);
  438. }
  440. /*
  441.  * This reads the keyboard status port, and does the
  442.  * appropriate action.
  443.  *
  444.  * It requires that we hold the keyboard controller
  445.  * spinlock.
  446.  */
  447. static void handle_kbd_event(void)
  448. {
  449. unsigned int status = KBDSTAT;
  450. unsigned int work = 10000;
  451. unsigned char scancode;
  453. while (status & KBD_STAT_RXF) {
  454. while (status & KBD_STAT_RXF) {
  455. scancode = KBDDATA & 0xff;
  456. if (!(status & KBD_STAT_STP))
  457. handle_keyboard_event(scancode);
  458. if (!--work) {
  459. printk(KERN_ERR
  460.        "pc_keyb: keyboard controller jammed (0x%02X).n",
  461.        status);
  462. return;
  463. }
  464. status = KBDSTAT;
  465. }
  466. work = 10000;
  467. }
  469. if (status & KBD_STAT_STP)
  470. KBDSTAT = KBD_STAT_STP;
  471. }
  473. static void keyboard_interrupt(int irq, void *dev_id, struct pt_regs *regs)
  474. {
  475. unsigned long flags;
  477. #ifdef CONFIG_VT
  478. kbd_pt_regs = regs;
  479. #endif
  480. spin_lock_irqsave(&kbd_controller_lock, flags);
  481. handle_kbd_event();
  482. spin_unlock_irqrestore(&kbd_controller_lock, flags);
  483. }
  485. /*
  486.  * send_data sends a character to the keyboard and waits
  487.  * for an acknowledge, possibly retrying if asked to. Returns
  488.  * the success status.
  489.  *
  490.  * Don't use 'jiffies', so that we don't depend on interrupts
  491.  */
  492. static int send_data(unsigned char data)
  493. {
  494. int retries = 3;
  496. do {
  497. unsigned long timeout = KBD_TIMEOUT;
  499. acknowledge = 0; /* Set by interrupt routine on receipt of ACK. */
  500. resend = 0;
  501. reply_expected = 1;
  502. kbd_write_output_w(data);
  503. for (;;) {
  504. if (acknowledge)
  505. return 1;
  506. if (resend)
  507. break;
  508. mdelay(1);
  509. if (!--timeout) {
  510. #ifdef KBD_REPORT_TIMEOUTS
  511. printk(KERN_WARNING
  512.        "keyboard: Timeout - AT keyboard not present?n");
  513. #endif
  514. return 0;
  515. }
  516. }
  517. }
  518. while (retries-- > 0);
  519. #ifdef KBD_REPORT_TIMEOUTS
  520. printk(KERN_WARNING
  521.        "keyboard: Too many NACKs -- noisy kbd cable?n");
  522. #endif
  523. return 0;
  524. }
  526. void sa1111_leds(unsigned char leds)
  527. {
  528. if (kbd_exists
  529.     && (!send_data(KBD_CMD_SET_LEDS) || !send_data(leds))) {
  530. send_data(KBD_CMD_ENABLE); /* re-enable kbd if any errors */
  531. kbd_exists = 0;
  532. }
  533. }
  535. #define KBD_NO_DATA    (-1) /* No data */
  536. #define KBD_BAD_DATA   (-2) /* Parity or other error */
  538. static int __init kbd_read_data(void)
  539. {
  540. int retval = KBD_NO_DATA;
  541. unsigned int status;
  543. status = KBDSTAT;
  544. if (status & KBD_STAT_RXF) {
  545. unsigned char data = KBDDATA;
  547. retval = data;
  548. if (status & KBD_STAT_STP)
  549. retval = KBD_BAD_DATA;
  550. }
  551. return retval;
  552. }
  554. static void __init kbd_clear_input(void)
  555. {
  556. int maxread = 100; /* Random number */
  558. do {
  559. if (kbd_read_data() == KBD_NO_DATA)
  560. break;
  561. }
  562. while (--maxread);
  563. }
  565. static int __init kbd_wait_for_input(void)
  566. {
  567. long timeout = KBD_INIT_TIMEOUT;
  569. do {
  570. int retval = kbd_read_data();
  571. if (retval >= 0)
  572. return retval;
  573. mdelay(1);
  574. }
  575. while (--timeout);
  576. return -1;
  577. }
  579. #if 0
  580. static void kbd_write_command_w(int data)
  581. {
  582. unsigned long flags;
  584. spin_lock_irqsave(&kbd_controller_lock, flags);
  585. kb_wait();
  586. kbd_write_command(data);
  587. spin_unlock_irqrestore(&kbd_controller_lock, flags);
  588. }
  589. #endif
  591. static void kbd_write_output_w(int data)
  592. {
  593. unsigned long flags;
  595. spin_lock_irqsave(&kbd_controller_lock, flags);
  596. kb_wait();
  597. KBDDATA = data & 0xff;
  598. spin_unlock_irqrestore(&kbd_controller_lock, flags);
  599. }
  601. /*
  602.  * Test the keyboard interface.  We basically check to make sure that
  603.  * we can drive each line to the keyboard independently of each other.
  604.  */
  605. static int kbdif_test(void)
  606. {
  607. int ret = 0;
  609. KBDCR = KBDCR_ENA | KBDCR_FKC;
  610. udelay(2);
  611. if ((KBDSTAT & (KBDSTAT_KBC | KBDSTAT_KBD)) != KBDSTAT_KBD) {
  612. printk("Keyboard interface test failed[1]: %02xn",
  613.        KBDSTAT);
  614. ret = -ENODEV;
  615. }
  617. KBDCR = KBDCR_ENA;
  618. udelay(2);
  619. if ((KBDSTAT & (KBDSTAT_KBC | KBDSTAT_KBD)) != (KBDSTAT_KBC | KBDSTAT_KBD)) {
  620. printk("Keyboard interface test failed[2]: %02xn",
  621.        KBDSTAT);
  622. ret = -ENODEV;
  623. }
  625. KBDCR = KBDCR_ENA | KBDCR_FKD;
  626. udelay(2);
  627. if ((KBDSTAT & (KBDSTAT_KBC | KBDSTAT_KBD)) != KBDSTAT_KBC) {
  628. printk("Keyboard interface test failed[3]: %02xn",
  629.        KBDSTAT);
  630. ret = -ENODEV;
  631. }
  633. return ret;
  634. }
  636. static char *__init initialize_kbd(void)
  637. {
  638. int status;
  640. /*
  641.  * Test the keyboard interface.
  642.  */
  643. kbdif_test();
  645. /*
  646.  * Ok, drop the force low bits, and wait a while,
  647.  * and clear the stop bit error flag.
  648.  */
  649. KBDCR = KBDCR_ENA;
  650. udelay(4);
  651. KBDSTAT = KBD_STAT_STP;
  653. /*
  654.  * Ok, we're now ready to talk to the keyboard.  Reset
  655.  * it, just to make sure we're starting in a sane state.
  656.  *
  657.  * Set up to try again if the keyboard asks for RESEND.
  658.  */
  659. do {
  660. KBDDATA = KBD_CMD_RESET;
  661. status = kbd_wait_for_input();
  662. if (status == KBD_REPLY_ACK)
  663. break;
  664. if (status != KBD_REPLY_RESEND)
  665. return "Keyboard reset failed, no ACK";
  666. } while (1);
  668. if (kbd_wait_for_input() != KBD_REPLY_POR)
  669. return "Keyboard reset failed, no POR";
  671. /*
  672.  * Set keyboard controller mode. During this, the keyboard should be
  673.  * in the disabled state.
  674.  *
  675.  * Set up to try again if the keyboard asks for RESEND.
  676.  */
  677. do {
  678. kbd_write_output_w(KBD_CMD_DISABLE);
  679. status = kbd_wait_for_input();
  680. if (status == KBD_REPLY_ACK)
  681. break;
  682. if (status != KBD_REPLY_RESEND)
  683. return "Disable keyboard: no ACK";
  684. } while (1);
  686. #if 0 /*@@@ */
  687. kbd_write_command_w(KBD_CCMD_WRITE_MODE);
  688. kbd_write_output_w(KBD_MODE_KBD_INT
  689.    | KBD_MODE_SYS | KBD_MODE_DISABLE_MOUSE |
  690.    KBD_MODE_KCC);
  692. /* ibm powerpc portables need this to use scan-code set 1 -- Cort */
  693. kbd_write_command_w(KBD_CCMD_READ_MODE);
  694. if (!(kbd_wait_for_input() & KBD_MODE_KCC)) {
  695. /*
  696.  * If the controller does not support conversion,
  697.  * Set the keyboard to scan-code set 1.
  698.  */
  699. kbd_write_output_w(0xF0);
  700. kbd_wait_for_input();
  701. kbd_write_output_w(0x01);
  702. kbd_wait_for_input();
  703. }
  704. #else
  705. kbd_write_output_w(0xf0);
  706. kbd_wait_for_input();
  707. kbd_write_output_w(0x01);
  708. kbd_wait_for_input();
  709. #endif
  712. kbd_write_output_w(KBD_CMD_ENABLE);
  713. if (kbd_wait_for_input() != KBD_REPLY_ACK)
  714. return "Enable keyboard: no ACK";
  716. /*
  717.  * Finally, set the typematic rate to maximum.
  718.  */
  719. kbd_write_output_w(KBD_CMD_SET_RATE);
  720. if (kbd_wait_for_input() != KBD_REPLY_ACK)
  721. return "Set rate: no ACK";
  722. kbd_write_output_w(0x00);
  723. if (kbd_wait_for_input() != KBD_REPLY_ACK)
  724. return "Set rate: no ACK";
  726. return NULL;
  727. }
  729. int __init sa1111_kbd_init_hw(void)
  730. {
  731. char *msg;
  732. int ret;
  734. if (!request_mem_region(_KBDCR, 512, "keyboard"))
  735. return -EBUSY;
  737. SKPCR |= SKPCR_PTCLKEN;
  738. KBDCLKDIV = 0;
  739. KBDPRECNT = 127;
  741. /* Flush any pending input. */
  742. kbd_clear_input();
  744. msg = initialize_kbd();
  745. if (msg)
  746. printk(KERN_WARNING "initialize_kbd: %sn", msg);
  748. #if defined CONFIG_PSMOUSE
  749. psaux_init();
  750. #endif
  752. k_setkeycode = sa1111_setkeycode;
  753. k_getkeycode = sa1111_getkeycode;
  754. k_translate = sa1111_translate;
  755. k_unexpected_up = sa1111_unexpected_up;
  756. k_leds = sa1111_leds;
  757. #ifdef CONFIG_MAGIC_SYSRQ
  758. k_sysrq_xlate = sa1111_sysrq_xlate;
  759. k_sysrq_key = 0x54;
  760. #endif
  762. /* Ok, finally allocate the IRQ, and off we go.. */
  763. ret = request_irq(IRQ_TPRXINT, keyboard_interrupt, 0, "keyboard", NULL);
  764. if (ret)
  765. release_mem_region(_KBDCR, 512);
  767. return ret;
  768. }
  770. #if defined CONFIG_PSMOUSE
  772. static inline void handle_mouse_event(unsigned char scancode)
  773. {
  774. if (mouse_reply_expected) {
  775. if (scancode == AUX_ACK) {
  776. mouse_reply_expected--;
  777. return;
  778. }
  779. mouse_reply_expected = 0;
  780. }
  782. add_mouse_randomness(scancode);
  783. if (aux_count) {
  784. int head = queue->head;
  786. queue->buf[head] = scancode;
  787. head = (head + 1) & (AUX_BUF_SIZE - 1);
  788. if (head != queue->tail) {
  789. queue->head = head;
  790. if (queue->fasync)
  791. kill_fasync(&queue->fasync, SIGIO,
  792.     POLL_IN);
  793. wake_up_interruptible(&queue->proc_list);
  794. }
  795. }
  796. }
  798. static void handle_mse_event(void)
  799. {
  800. unsigned int msests = MSESTAT;
  801. unsigned int work = 10000;
  802. unsigned char scancode;
  804. while (msests & MSE_STAT_RXF) {
  805. while (msests & MSE_STAT_RXF) {
  806. scancode = MSEDATA & 0xff;
  807. if (!(msests & MSE_STAT_STP))
  808. handle_mouse_event(scancode);
  809. if (!--work) {
  810. printk(KERN_ERR
  811.        "pc_keyb: mouse controller jammed (0x%02X).n",
  812.        msests);
  813. return;
  814.  /*XXX*/}
  815. msests = MSESTAT;
  816. }
  817. work = 10000;
  818. }
  819. }
  821. static void ms_wait(void)
  822. {
  823. unsigned long timeout = KBC_TIMEOUT;
  825. do {
  826. /*
  827.  * "handle_kbd_event()" will handle any incoming events
  828.  * while we wait - keypresses or mouse movement.
  829.  */
  830. handle_mse_event();
  831. if (MSESTAT & MSE_STAT_TXE)
  832. return;
  833. mdelay(1);
  834. timeout--;
  835. }
  836. while (timeout);
  837. #ifdef KBD_REPORT_TIMEOUTS
  838. printk(KERN_WARNING "Mouse timed out[1]n");
  839. #endif
  840. }
  842. static void mouse_interrupt(int irq, void *dev_id, struct pt_regs *regs)
  843. {
  844. unsigned long flags;
  846. spin_lock_irqsave(&kbd_controller_lock, flags);
  847. handle_mse_event();
  848. spin_unlock_irqrestore(&kbd_controller_lock, flags);
  849. }
  851. /*
  852.  * Check if this is a dual port controller.
  853.  */
  854. static int __init detect_auxiliary_port(void)
  855. {
  856. unsigned long flags;
  857. int loops = 10;
  858. int retval = 0;
  860. /* Check if the BIOS detected a device on the auxiliary port. */
  861. if (aux_device_present == 0xaa)
  862. return 1;
  864. spin_lock_irqsave(&kbd_controller_lock, flags);
  866. /* Put the value 0x5A in the output buffer using the "Write
  867.  * Auxiliary Device Output Buffer" command (0xD3). Poll the
  868.  * Status Register for a while to see if the value really
  869.  * turns up in the Data Register. If the KBD_STAT_MOUSE_OBF
  870.  * bit is also set to 1 in the Status Register, we assume this
  871.  * controller has an Auxiliary Port (a.k.a. Mouse Port).
  872.  */
  873. // kb_wait();
  874. // kbd_write_command(KBD_CCMD_WRITE_AUX_OBUF);
  876. SKPCR |= SKPCR_PMCLKEN;
  878. MSECLKDIV = 0;
  879. MSEPRECNT = 127;
  880. MSECR = MSECR_ENA;
  881. mdelay(50);
  882. MSEDATA = 0xf4;
  883. mdelay(50);
  885. do {
  886. unsigned int msests = MSESTAT;
  888. if (msests & MSE_STAT_RXF) {
  889. do {
  890. msests = MSEDATA; /* dummy read */
  891. mdelay(50);
  892. msests = MSESTAT;
  893. }
  894. while (msests & MSE_STAT_RXF);
  895. printk(KERN_INFO "Detected PS/2 Mouse Port.n");
  896. retval = 1;
  897. break;
  898. }
  899. mdelay(1);
  900. }
  901. while (--loops);
  902. spin_unlock_irqrestore(&kbd_controller_lock, flags);
  904. return retval;
  905. }
  907. /*
  908.  * Send a byte to the mouse.
  909.  */
  910. static void aux_write_dev(int val)
  911. {
  912. unsigned long flags;
  914. spin_lock_irqsave(&kbd_controller_lock, flags);
  915. // kb_wait();
  916. // kbd_write_command(KBD_CCMD_WRITE_MOUSE);
  917. ms_wait();
  918. MSEDATA = val;
  919. spin_unlock_irqrestore(&kbd_controller_lock, flags);
  920. }
  922. /*
  923.  * Send a byte to the mouse & handle returned ack
  924.  */
  925. static void aux_write_ack(int val)
  926. {
  927. unsigned long flags;
  929. spin_lock_irqsave(&kbd_controller_lock, flags);
  930. // kb_wait();
  931. // kbd_write_command(KBD_CCMD_WRITE_MOUSE);
  932. ms_wait();
  933. MSEDATA = val;
  934. /* we expect an ACK in response. */
  935. mouse_reply_expected++;
  936. ms_wait();
  937. spin_unlock_irqrestore(&kbd_controller_lock, flags);
  938. }
  940. static unsigned char get_from_queue(void)
  941. {
  942. unsigned char result;
  943. unsigned long flags;
  945. spin_lock_irqsave(&kbd_controller_lock, flags);
  946. result = queue->buf[queue->tail];
  947. queue->tail = (queue->tail + 1) & (AUX_BUF_SIZE - 1);
  948. spin_unlock_irqrestore(&kbd_controller_lock, flags);
  949. return result;
  950. }
  953. static inline int queue_empty(void)
  954. {
  955. return queue->head == queue->tail;
  956. }
  958. static int fasync_aux(int fd, struct file *filp, int on)
  959. {
  960. int retval;
  962. retval = fasync_helper(fd, filp, on, &queue->fasync);
  963. if (retval < 0)
  964. return retval;
  965. return 0;
  966. }
  969. /*
  970.  * Random magic cookie for the aux device
  971.  */
  972. #define AUX_DEV ((void *)queue)
  974. static int release_aux(struct inode *inode, struct file *file)
  975. {
  976. fasync_aux(-1, file, 0);
  977. if (--aux_count)
  978. return 0;
  979. // kbd_write_cmd(AUX_INTS_OFF);                     /* Disable controller ints */
  980. // kbd_write_command_w(KBD_CCMD_MOUSE_DISABLE);
  981. aux_write_ack(AUX_DISABLE_DEV); /* Disable aux device */
  982. MSECR &= ~MSECR_ENA;
  983. free_irq(IRQ_MSRXINT, AUX_DEV);
  984. return 0;
  985. }
  987. /*
  988.  * Install interrupt handler.
  989.  * Enable auxiliary device.
  990.  */
  992. static int open_aux(struct inode *inode, struct file *file)
  993. {
  994. if (aux_count++) {
  995. return 0;
  996. }
  997. queue->head = queue->tail = 0; /* Flush input queue */
  998. /* Don't enable the mouse controller until we've registered IRQ handler */
  999. if (request_irq(IRQ_MSRXINT, mouse_interrupt, SA_SHIRQ, "PS/2 Mouse", AUX_DEV)) {
  1000. aux_count--;
  1001. return -EBUSY;
  1002. }
  1003. MSECLKDIV = 0;
  1004. MSEPRECNT = 127;
  1005. MSECR &= ~MSECR_ENA;
  1006. mdelay(50);
  1007. MSECR = MSECR_ENA;
  1008. mdelay(50);
  1009. MSEDATA = 0xf4;
  1010. mdelay(50);
  1011. if (MSESTAT & 0x0100) {
  1012. MSESTAT = 0x0100; /* clear IRQ status */
  1013. }
  1014. /*  kbd_write_command_w(KBD_CCMD_MOUSE_ENABLE); *//* Enable the
  1015.    auxiliary port on
  1016.    controller. */
  1017. aux_write_ack(AUX_ENABLE_DEV); /* Enable aux device */
  1018. // kbd_write_cmd(AUX_INTS_ON); /* Enable controller ints */
  1020. // send_data(KBD_CMD_ENABLE);   /* try to workaround toshiba4030cdt problem */
  1022. return 0;
  1023. }
  1025. /*
  1026.  * Put bytes from input queue to buffer.
  1027.  */
  1029. static ssize_t
  1030. read_aux(struct file *file, char *buffer, size_t count, loff_t * ppos)
  1031. {
  1032. DECLARE_WAITQUEUE(wait, current);
  1033. ssize_t i = count;
  1034. unsigned char c;
  1036. if (queue_empty()) {
  1037. if (file->f_flags & O_NONBLOCK)
  1038. return -EAGAIN;
  1039. add_wait_queue(&queue->proc_list, &wait);
  1040.       repeat:
  1041. set_current_state(TASK_INTERRUPTIBLE);
  1042. if (queue_empty() && !signal_pending(current)) {
  1043. schedule();
  1044. goto repeat;
  1045. }
  1046. current->state = TASK_RUNNING;
  1047. remove_wait_queue(&queue->proc_list, &wait);
  1048. }
  1049. while (i > 0 && !queue_empty()) {
  1050. c = get_from_queue();
  1051. put_user(c, buffer++);
  1052. i--;
  1053. }
  1054. if (count - i) {
  1055. file->f_dentry->d_inode->i_atime = CURRENT_TIME;
  1056. return count - i;
  1057. }
  1058. if (signal_pending(current))
  1059. return -ERESTARTSYS;
  1060. return 0;
  1061. }
  1063. /*
  1064.  * Write to the aux device.
  1065.  */
  1067. static ssize_t
  1068. write_aux(struct file *file, const char *buffer, size_t count,
  1069.   loff_t * ppos)
  1070. {
  1071. ssize_t retval = 0;
  1073. if (count) {
  1074. ssize_t written = 0;
  1076. if (count > 32)
  1077. count = 32; /* Limit to 32 bytes. */
  1078. do {
  1079. char c;
  1080. get_user(c, buffer++);
  1081. aux_write_dev(c);
  1082. written++;
  1083. }
  1084. while (--count);
  1085. retval = -EIO;
  1086. if (written) {
  1087. retval = written;
  1088. file->f_dentry->d_inode->i_mtime = CURRENT_TIME;
  1089. }
  1090. }
  1092. return retval;
  1093. }
  1095. static unsigned int aux_poll(struct file *file, poll_table * wait)
  1096. {
  1097. poll_wait(file, &queue->proc_list, wait);
  1098. if (!queue_empty())
  1099. return POLLIN | POLLRDNORM;
  1100. return 0;
  1101. }
  1103. struct file_operations psaux_fops = {
  1104. read: read_aux,
  1105. write: write_aux,
  1106. poll: aux_poll,
  1107. open: open_aux,
  1108. release: release_aux,
  1109. fasync: fasync_aux,
  1110. };
  1112. /*
  1113.  * Initialize driver.
  1114.  */
  1115. static struct miscdevice psaux_mouse = {
  1116. PSMOUSE_MINOR, "psaux", &psaux_fops
  1117. };
  1120. static int __init psaux_init(void)
  1121. {
  1122. int ret;
  1124. if (!request_mem_region(_MSECR, 512, "psaux"))
  1125. return -EBUSY;
  1127. if (!detect_auxiliary_port()) {
  1128. ret = -EIO;
  1129. goto out;
  1130. }
  1132. misc_register(&psaux_mouse);
  1133. queue = (struct aux_queue *) kmalloc(sizeof(*queue), GFP_KERNEL);
  1134. memset(queue, 0, sizeof(*queue));
  1135. queue->head = queue->tail = 0;
  1136. init_waitqueue_head(&queue->proc_list);
  1138. #ifdef CONFIG_PSMOUSE
  1139. aux_write_ack(AUX_SET_SAMPLE);
  1140. aux_write_ack(100); /* 100 samples/sec */
  1141. aux_write_ack(AUX_SET_RES);
  1142. aux_write_ack(3); /* 8 counts per mm */
  1143. aux_write_ack(AUX_SET_SCALE21); /* 2:1 scaling */
  1144. #endif
  1145. ret = 0;
  1147.  out:
  1148.   if (ret)
  1149.   release_mem_region(_MSECR, 512);
  1150. return ret;
  1151. }
  1153. #endif /* CONFIG_PSMOUSE */