arch/m68k/atari/atakeyb.c

   1 /*
   2  * linux/atari/atakeyb.c
   3  *
   4  * Atari Keyboard driver for 680x0 Linux
   5  *
   6  * This file is subject to the terms and conditions of the GNU General Public
   7  * License.  See the file COPYING in the main directory of this archive
   8  * for more details.
   9  */
  10
  11 /*
  12  * Atari support by Robert de Vries
  13  * enhanced by Bjoern Brauel and Roman Hodek
  14  */
  15
  16 #include <linux/config.h>
  17 #include <linux/sched.h>
  18 #include <linux/kernel.h>
  19 #include <linux/interrupt.h>
  20 #include <linux/errno.h>
  21 #include <linux/keyboard.h>
  22 #include <linux/delay.h>
  23 #include <linux/timer.h>
  24 #include <linux/kd.h>
  25 #include <linux/random.h>
  26 #include <linux/init.h>
  27 #include <linux/kbd_ll.h>
  28 #include <linux/kbd_kern.h>
  29
  30 #include <asm/atariints.h>
  31 #include <asm/atarihw.h>
  32 #include <asm/atarikb.h>
  33 #include <asm/atari_joystick.h>
  34 #include <asm/irq.h>
  35
  36 static void atakeyb_rep( unsigned long ignore );
  37 extern unsigned int keymap_count;
  38
  39 /* Hook for MIDI serial driver */
  40 void (*atari_MIDI_interrupt_hook) (void);
  41 /* Hook for mouse driver */
  42 void (*atari_mouse_interrupt_hook) (char *);
  43
  44 /* variables for IKBD self test: */
  45
  46 /* state: 0: off; >0: in progress; >1: 0xf1 received */
  47 static volatile int ikbd_self_test;
  48 /* timestamp when last received a char */
  49 static volatile unsigned long self_test_last_rcv;
  50 /* bitmap of keys reported as broken */
  51 static unsigned long broken_keys[128/(sizeof(unsigned long)*8)] = { 0, };
  52
  53 #define BREAK_MASK      (0x80)
  54
  55 /*
  56  * ++roman: The following changes were applied manually:
  57  *
  58  *  - The Alt (= Meta) key works in combination with Shift and
  59  *    Control, e.g. Alt+Shift+a sends Meta-A (0xc1), Alt+Control+A sends
  60  *    Meta-Ctrl-A (0x81) ...
  61  *
  62  *  - The parentheses on the keypad send '(' and ')' with all
  63  *    modifiers (as would do e.g. keypad '+'), but they cannot be used as
  64  *    application keys (i.e. sending Esc O c).
  65  *
  66  *  - HELP and UNDO are mapped to be F21 and F24, resp, that send the
  67  *    codes "\E[M" and "\E[P". (This is better than the old mapping to
  68  *    F11 and F12, because these codes are on Shift+F1/2 anyway.) This
  69  *    way, applications that allow their own keyboard mappings
  70  *    (e.g. tcsh, X Windows) can be configured to use them in the way
  71  *    the label suggests (providing help or undoing).
  72  *
  73  *  - Console switching is done with Alt+Fx (consoles 1..10) and
  74  *    Shift+Alt+Fx (consoles 11..20).
  75  *
  76  *  - The misc. special function implemented in the kernel are mapped
  77  *    to the following key combinations:
  78  *
  79  *      ClrHome          -> Home/Find
  80  *      Shift + ClrHome  -> End/Select
  81  *      Shift + Up       -> Page Up
  82  *      Shift + Down     -> Page Down
  83  *      Alt + Help       -> show system status
  84  *      Shift + Help     -> show memory info
  85  *      Ctrl + Help      -> show registers
  86  *      Ctrl + Alt + Del -> Reboot
  87  *      Alt + Undo       -> switch to last console
  88  *      Shift + Undo     -> send interrupt
  89  *      Alt + Insert     -> stop/start output (same as ^S/^Q)
  90  *      Alt + Up         -> Scroll back console (if implemented)
  91  *      Alt + Down       -> Scroll forward console (if implemented)
  92  *      Alt + CapsLock   -> NumLock
  93  *
  94  * ++Andreas:
  95  *
  96  *  - Help mapped to K_HELP
  97  *  - Undo mapped to K_UNDO (= K_F246)
  98  *  - Keypad Left/Right Parenthesis mapped to new K_PPAREN[LR]
  99  */
 100
 101 static u_short ataplain_map[NR_KEYS] __initdata = {
 102         0xf200, 0xf01b, 0xf031, 0xf032, 0xf033, 0xf034, 0xf035, 0xf036,
 103         0xf037, 0xf038, 0xf039, 0xf030, 0xf02d, 0xf03d, 0xf008, 0xf009,
 104         0xfb71, 0xfb77, 0xfb65, 0xfb72, 0xfb74, 0xfb79, 0xfb75, 0xfb69,
 105         0xfb6f, 0xfb70, 0xf05b, 0xf05d, 0xf201, 0xf702, 0xfb61, 0xfb73,
 106         0xfb64, 0xfb66, 0xfb67, 0xfb68, 0xfb6a, 0xfb6b, 0xfb6c, 0xf03b,
 107         0xf027, 0xf060, 0xf700, 0xf05c, 0xfb7a, 0xfb78, 0xfb63, 0xfb76,
 108         0xfb62, 0xfb6e, 0xfb6d, 0xf02c, 0xf02e, 0xf02f, 0xf700, 0xf200,
 109         0xf703, 0xf020, 0xf207, 0xf100, 0xf101, 0xf102, 0xf103, 0xf104,
 110         0xf105, 0xf106, 0xf107, 0xf108, 0xf109, 0xf200, 0xf200, 0xf114,
 111         0xf603, 0xf200, 0xf30b, 0xf601, 0xf200, 0xf602, 0xf30a, 0xf200,
 112         0xf600, 0xf200, 0xf115, 0xf07f, 0xf200, 0xf200, 0xf200, 0xf200,
 113         0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
 114         0xf200, 0xf1ff, 0xf11b, 0xf312, 0xf313, 0xf30d, 0xf30c, 0xf307,
 115         0xf308, 0xf309, 0xf304, 0xf305, 0xf306, 0xf301, 0xf302, 0xf303,
 116         0xf300, 0xf310, 0xf30e, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
 117         0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200
 118 };
 119
 120 static u_short atashift_map[NR_KEYS] __initdata = {
 121         0xf200, 0xf01b, 0xf021, 0xf040, 0xf023, 0xf024, 0xf025, 0xf05e,
 122         0xf026, 0xf02a, 0xf028, 0xf029, 0xf05f, 0xf02b, 0xf008, 0xf009,
 123         0xfb51, 0xfb57, 0xfb45, 0xfb52, 0xfb54, 0xfb59, 0xfb55, 0xfb49,
 124         0xfb4f, 0xfb50, 0xf07b, 0xf07d, 0xf201, 0xf702, 0xfb41, 0xfb53,
 125         0xfb44, 0xfb46, 0xfb47, 0xfb48, 0xfb4a, 0xfb4b, 0xfb4c, 0xf03a,
 126         0xf022, 0xf07e, 0xf700, 0xf07c, 0xfb5a, 0xfb58, 0xfb43, 0xfb56,
 127         0xfb42, 0xfb4e, 0xfb4d, 0xf03c, 0xf03e, 0xf03f, 0xf700, 0xf200,
 128         0xf703, 0xf020, 0xf207, 0xf10a, 0xf10b, 0xf10c, 0xf10d, 0xf10e,
 129         0xf10f, 0xf110, 0xf111, 0xf112, 0xf113, 0xf200, 0xf200, 0xf117,
 130         0xf118, 0xf200, 0xf30b, 0xf601, 0xf200, 0xf602, 0xf30a, 0xf200,
 131         0xf119, 0xf200, 0xf115, 0xf07f, 0xf200, 0xf200, 0xf200, 0xf200,
 132         0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
 133         0xf200, 0xf205, 0xf203, 0xf312, 0xf313, 0xf30d, 0xf30c, 0xf307,
 134         0xf308, 0xf309, 0xf304, 0xf305, 0xf306, 0xf301, 0xf302, 0xf303,
 135         0xf300, 0xf310, 0xf30e, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
 136         0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200
 137 };
 138
 139 static u_short atactrl_map[NR_KEYS] __initdata = {
 140         0xf200, 0xf200, 0xf200, 0xf000, 0xf01b, 0xf01c, 0xf01d, 0xf01e,
 141         0xf01f, 0xf07f, 0xf200, 0xf200, 0xf01f, 0xf200, 0xf008, 0xf200,
 142         0xf011, 0xf017, 0xf005, 0xf012, 0xf014, 0xf019, 0xf015, 0xf009,
 143         0xf00f, 0xf010, 0xf01b, 0xf01d, 0xf201, 0xf702, 0xf001, 0xf013,
 144         0xf004, 0xf006, 0xf007, 0xf008, 0xf00a, 0xf00b, 0xf00c, 0xf200,
 145         0xf007, 0xf000, 0xf700, 0xf01c, 0xf01a, 0xf018, 0xf003, 0xf016,
 146         0xf002, 0xf00e, 0xf00d, 0xf200, 0xf200, 0xf07f, 0xf700, 0xf200,
 147         0xf703, 0xf000, 0xf207, 0xf100, 0xf101, 0xf102, 0xf103, 0xf104,
 148         0xf105, 0xf106, 0xf107, 0xf108, 0xf109, 0xf200, 0xf200, 0xf114,
 149         0xf603, 0xf200, 0xf30b, 0xf601, 0xf200, 0xf602, 0xf30a, 0xf200,
 150         0xf600, 0xf200, 0xf115, 0xf07f, 0xf200, 0xf200, 0xf200, 0xf200,
 151         0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
 152         0xf200, 0xf1ff, 0xf202, 0xf312, 0xf313, 0xf30d, 0xf30c, 0xf307,
 153         0xf308, 0xf309, 0xf304, 0xf305, 0xf306, 0xf301, 0xf302, 0xf303,
 154         0xf300, 0xf310, 0xf30e, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
 155         0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200
 156 };
 157
 158 static u_short atashift_ctrl_map[NR_KEYS] __initdata = {
 159         0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
 160         0xf200, 0xf200, 0xf200, 0xf200, 0xf01f, 0xf200, 0xf008, 0xf200,
 161         0xf011, 0xf017, 0xf005, 0xf012, 0xf014, 0xf019, 0xf015, 0xf009,
 162         0xf00f, 0xf010, 0xf200, 0xf200, 0xf201, 0xf702, 0xf001, 0xf013,
 163         0xf004, 0xf006, 0xf007, 0xf008, 0xf00a, 0xf00b, 0xf00c, 0xf200,
 164         0xf200, 0xf200, 0xf700, 0xf200, 0xf01a, 0xf018, 0xf003, 0xf016,
 165         0xf002, 0xf00e, 0xf00d, 0xf200, 0xf200, 0xf07f, 0xf700, 0xf200,
 166         0xf703, 0xf200, 0xf207, 0xf100, 0xf101, 0xf102, 0xf103, 0xf104,
 167         0xf105, 0xf106, 0xf107, 0xf108, 0xf109, 0xf200, 0xf200, 0xf117,
 168         0xf603, 0xf200, 0xf30b, 0xf601, 0xf200, 0xf602, 0xf30a, 0xf200,
 169         0xf600, 0xf200, 0xf115, 0xf07f, 0xf200, 0xf200, 0xf200, 0xf200,
 170         0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
 171         0xf200, 0xf1ff, 0xf11b, 0xf312, 0xf313, 0xf30d, 0xf30c, 0xf307,
 172         0xf308, 0xf309, 0xf304, 0xf305, 0xf306, 0xf301, 0xf302, 0xf303,
 173         0xf300, 0xf310, 0xf30e, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
 174         0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200
 175 };
 176
 177 static u_short ataalt_map[NR_KEYS] __initdata = {
 178         0xf200, 0xf81b, 0xf831, 0xf832, 0xf833, 0xf834, 0xf835, 0xf836,
 179         0xf837, 0xf838, 0xf839, 0xf830, 0xf82d, 0xf83d, 0xf808, 0xf809,
 180         0xf871, 0xf877, 0xf865, 0xf872, 0xf874, 0xf879, 0xf875, 0xf869,
 181         0xf86f, 0xf870, 0xf85b, 0xf85d, 0xf80d, 0xf702, 0xf861, 0xf873,
 182         0xf864, 0xf866, 0xf867, 0xf868, 0xf86a, 0xf86b, 0xf86c, 0xf83b,
 183         0xf827, 0xf860, 0xf700, 0xf85c, 0xf87a, 0xf878, 0xf863, 0xf876,
 184         0xf862, 0xf86e, 0xf86d, 0xf82c, 0xf82e, 0xf82f, 0xf700, 0xf200,
 185         0xf703, 0xf820, 0xf208, 0xf500, 0xf501, 0xf502, 0xf503, 0xf504,
 186         0xf505, 0xf506, 0xf507, 0xf508, 0xf509, 0xf200, 0xf200, 0xf114,
 187         0xf20b, 0xf200, 0xf30b, 0xf601, 0xf200, 0xf602, 0xf30a, 0xf200,
 188         0xf20a, 0xf200, 0xf209, 0xf87f, 0xf200, 0xf200, 0xf200, 0xf200,
 189         0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
 190         0xf200, 0xf206, 0xf204, 0xf312, 0xf313, 0xf30d, 0xf30c, 0xf907,
 191         0xf908, 0xf909, 0xf904, 0xf905, 0xf906, 0xf901, 0xf902, 0xf903,
 192         0xf900, 0xf310, 0xf30e, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
 193         0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200
 194 };
 195
 196 static u_short atashift_alt_map[NR_KEYS] __initdata = {
 197         0xf200, 0xf81b, 0xf821, 0xf840, 0xf823, 0xf824, 0xf825, 0xf85e,
 198         0xf826, 0xf82a, 0xf828, 0xf829, 0xf85f, 0xf82b, 0xf808, 0xf809,
 199         0xf851, 0xf857, 0xf845, 0xf852, 0xf854, 0xf859, 0xf855, 0xf849,
 200         0xf84f, 0xf850, 0xf87b, 0xf87d, 0xf201, 0xf702, 0xf841, 0xf853,
 201         0xf844, 0xf846, 0xf847, 0xf848, 0xf84a, 0xf84b, 0xf84c, 0xf83a,
 202         0xf822, 0xf87e, 0xf700, 0xf87c, 0xf85a, 0xf858, 0xf843, 0xf856,
 203         0xf842, 0xf84e, 0xf84d, 0xf83c, 0xf83e, 0xf83f, 0xf700, 0xf200,
 204         0xf703, 0xf820, 0xf207, 0xf50a, 0xf50b, 0xf50c, 0xf50d, 0xf50e,
 205         0xf50f, 0xf510, 0xf511, 0xf512, 0xf513, 0xf200, 0xf200, 0xf117,
 206         0xf118, 0xf200, 0xf30b, 0xf601, 0xf200, 0xf602, 0xf30a, 0xf200,
 207         0xf119, 0xf200, 0xf115, 0xf87f, 0xf200, 0xf200, 0xf200, 0xf200,
 208         0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
 209         0xf200, 0xf1ff, 0xf11b, 0xf312, 0xf313, 0xf30d, 0xf30c, 0xf307,
 210         0xf308, 0xf309, 0xf304, 0xf305, 0xf306, 0xf301, 0xf302, 0xf303,
 211         0xf300, 0xf310, 0xf30e, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
 212         0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200
 213 };
 214
 215 static u_short atactrl_alt_map[NR_KEYS] __initdata = {
 216         0xf200, 0xf200, 0xf200, 0xf800, 0xf81b, 0xf81c, 0xf81d, 0xf81e,
 217         0xf81f, 0xf87f, 0xf200, 0xf200, 0xf81f, 0xf200, 0xf808, 0xf200,
 218         0xf811, 0xf817, 0xf805, 0xf812, 0xf814, 0xf819, 0xf815, 0xf809,
 219         0xf80f, 0xf810, 0xf81b, 0xf81d, 0xf201, 0xf702, 0xf801, 0xf813,
 220         0xf804, 0xf806, 0xf807, 0xf808, 0xf80a, 0xf80b, 0xf80c, 0xf200,
 221         0xf807, 0xf800, 0xf700, 0xf81c, 0xf81a, 0xf818, 0xf803, 0xf816,
 222         0xf802, 0xf80e, 0xf80d, 0xf200, 0xf200, 0xf87f, 0xf700, 0xf200,
 223         0xf703, 0xf800, 0xf207, 0xf100, 0xf101, 0xf102, 0xf103, 0xf104,
 224         0xf105, 0xf106, 0xf107, 0xf108, 0xf109, 0xf200, 0xf200, 0xf114,
 225         0xf603, 0xf200, 0xf30b, 0xf601, 0xf200, 0xf602, 0xf30a, 0xf200,
 226         0xf600, 0xf200, 0xf115, 0xf87f, 0xf200, 0xf200, 0xf200, 0xf200,
 227         0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
 228         0xf200, 0xf1ff, 0xf202, 0xf312, 0xf313, 0xf30d, 0xf30c, 0xf307,
 229         0xf308, 0xf309, 0xf304, 0xf305, 0xf306, 0xf301, 0xf302, 0xf303,
 230         0xf300, 0xf310, 0xf30e, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
 231         0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200
 232 };
 233
 234 static u_short atashift_ctrl_alt_map[NR_KEYS] = {
 235         0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
 236         0xf200, 0xf200, 0xf200, 0xf200, 0xf81f, 0xf200, 0xf808, 0xf200,
 237         0xf811, 0xf817, 0xf805, 0xf812, 0xf814, 0xf819, 0xf815, 0xf809,
 238         0xf80f, 0xf810, 0xf200, 0xf200, 0xf201, 0xf702, 0xf801, 0xf813,
 239         0xf804, 0xf806, 0xf807, 0xf808, 0xf80a, 0xf80b, 0xf80c, 0xf200,
 240         0xf200, 0xf200, 0xf700, 0xf200, 0xf81a, 0xf818, 0xf803, 0xf816,
 241         0xf802, 0xf80e, 0xf80d, 0xf200, 0xf200, 0xf87f, 0xf700, 0xf200,
 242         0xf703, 0xf200, 0xf207, 0xf100, 0xf101, 0xf102, 0xf103, 0xf104,
 243         0xf105, 0xf106, 0xf107, 0xf108, 0xf109, 0xf200, 0xf200, 0xf117,
 244         0xf603, 0xf200, 0xf30b, 0xf601, 0xf200, 0xf602, 0xf30a, 0xf200,
 245         0xf600, 0xf200, 0xf115, 0xf87f, 0xf200, 0xf200, 0xf200, 0xf200,
 246         0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
 247         0xf200, 0xf1ff, 0xf11b, 0xf312, 0xf313, 0xf30d, 0xf30c, 0xf307,
 248         0xf308, 0xf309, 0xf304, 0xf305, 0xf306, 0xf301, 0xf302, 0xf303,
 249         0xf300, 0xf310, 0xf30e, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200,
 250         0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200
 251 };
 252
 253 typedef enum kb_state_t
 254 {
 255     KEYBOARD, AMOUSE, RMOUSE, JOYSTICK, CLOCK, RESYNC
 256 } KB_STATE_T;
 257
 258 #define IS_SYNC_CODE(sc)        ((sc) >= 0x04 && (sc) <= 0xfb)
 259
 260 typedef struct keyboard_state
 261 {
 262     unsigned char  buf[6];
 263     int            len;
 264     KB_STATE_T     state;
 265 } KEYBOARD_STATE;
 266
 267 KEYBOARD_STATE kb_state;
 268
 269 #define DEFAULT_KEYB_REP_DELAY  (HZ/4)
 270 #define DEFAULT_KEYB_REP_RATE   (HZ/25)
 271
 272 /* These could be settable by some ioctl() in future... */
 273 static unsigned int key_repeat_delay = DEFAULT_KEYB_REP_DELAY;
 274 static unsigned int key_repeat_rate  = DEFAULT_KEYB_REP_RATE;
 275
 276 static unsigned char rep_scancode;
 277 static struct timer_list atakeyb_rep_timer = { function: atakeyb_rep };
 278
 279 static void atakeyb_rep( unsigned long ignore )
 280
 281 {
 282         kbd_pt_regs = NULL;
 283
 284         /* Disable keyboard for the time we call handle_scancode(), else a race
 285          * in the keyboard tty queue may happen */
 286         atari_disable_irq( IRQ_MFP_ACIA );
 287         del_timer( &atakeyb_rep_timer );
 288
 289         /* A keyboard int may have come in before we disabled the irq, so
 290          * double-check whether rep_scancode is still != 0 */
 291         if (rep_scancode) {
 292                 init_timer(&atakeyb_rep_timer);
 293                 atakeyb_rep_timer.expires = jiffies + key_repeat_rate;
 294                 add_timer( &atakeyb_rep_timer );
 295
 296                 handle_scancode(rep_scancode, 1);
 297         }
 298
 299         atari_enable_irq( IRQ_MFP_ACIA );
 300 }
 301
 302
 303 /* ++roman: If a keyboard overrun happened, we can't tell in general how much
 304  * bytes have been lost and in which state of the packet structure we are now.
 305  * This usually causes keyboards bytes to be interpreted as mouse movements
 306  * and vice versa, which is very annoying. It seems better to throw away some
 307  * bytes (that are usually mouse bytes) than to misinterpret them. Therefor I
 308  * introduced the RESYNC state for IKBD data. In this state, the bytes up to
 309  * one that really looks like a key event (0x04..0xf2) or the start of a mouse
 310  * packet (0xf8..0xfb) are thrown away, but at most 2 bytes. This at least
 311  * speeds up the resynchronization of the event structure, even if maybe a
 312  * mouse movement is lost. However, nothing is perfect. For bytes 0x01..0x03,
 313  * it's really hard to decide whether they're mouse or keyboard bytes. Since
 314  * overruns usually occur when moving the Atari mouse rapidly, they're seen as
 315  * mouse bytes here. If this is wrong, only a make code of the keyboard gets
 316  * lost, which isn't too bad. Loosing a break code would be disastrous,
 317  * because then the keyboard repeat strikes...
 318  */
 319
 320 static void keyboard_interrupt(int irq, void *dummy, struct pt_regs *fp)
 321 {
 322   u_char acia_stat;
 323   int scancode;
 324   int break_flag;
 325
 326   /* save frame for register dump */
 327   kbd_pt_regs = fp;
 328
 329  repeat:
 330   if (acia.mid_ctrl & ACIA_IRQ)
 331         if (atari_MIDI_interrupt_hook)
 332                 atari_MIDI_interrupt_hook();
 333   acia_stat = acia.key_ctrl;
 334   /* check out if the interrupt came from this ACIA */
 335   if (!((acia_stat | acia.mid_ctrl) & ACIA_IRQ))
 336         return;
 337
 338     if (acia_stat & ACIA_OVRN)
 339     {
 340         /* a very fast typist or a slow system, give a warning */
 341         /* ...happens often if interrupts were disabled for too long */
 342         printk( KERN_DEBUG "Keyboard overrun\n" );
 343         scancode = acia.key_data;
 344         /* Turn off autorepeating in case a break code has been lost */
 345         del_timer( &atakeyb_rep_timer );
 346         rep_scancode = 0;
 347         if (ikbd_self_test)
 348             /* During self test, don't do resyncing, just process the code */
 349             goto interpret_scancode;
 350         else if (IS_SYNC_CODE(scancode)) {
 351             /* This code seem already to be the start of a new packet or a
 352              * single scancode */
 353             kb_state.state = KEYBOARD;
 354             goto interpret_scancode;
 355         }
 356         else {
 357             /* Go to RESYNC state and skip this byte */
 358             kb_state.state = RESYNC;
 359             kb_state.len = 1; /* skip max. 1 another byte */
 360             goto repeat;
 361         }
 362     }
 363
 364     if (acia_stat & ACIA_RDRF)  /* received a character */
 365     {
 366         scancode = acia.key_data;       /* get it or reset the ACIA, I'll get it! */
 367         tasklet_schedule(&keyboard_tasklet);
 368       interpret_scancode:
 369         switch (kb_state.state)
 370         {
 371           case KEYBOARD:
 372             switch (scancode)
 373             {
 374               case 0xF7:
 375                 kb_state.state = AMOUSE;
 376                 kb_state.len = 0;
 377                 break;
 378
 379               case 0xF8:
 380               case 0xF9:
 381               case 0xFA:
 382               case 0xFB:
 383                 kb_state.state = RMOUSE;
 384                 kb_state.len = 1;
 385                 kb_state.buf[0] = scancode;
 386                 break;
 387
 388               case 0xFC:
 389                 kb_state.state = CLOCK;
 390                 kb_state.len = 0;
 391                 break;
 392
 393               case 0xFE:
 394               case 0xFF:
 395                 kb_state.state = JOYSTICK;
 396                 kb_state.len = 1;
 397                 kb_state.buf[0] = scancode;
 398                 break;
 399
 400               case 0xF1:
 401                 /* during self-test, note that 0xf1 received */
 402                 if (ikbd_self_test) {
 403                     ++ikbd_self_test;
 404                     self_test_last_rcv = jiffies;
 405                     break;
 406                 }
 407                 /* FALL THROUGH */
 408
 409               default:
 410                 break_flag = scancode & BREAK_MASK;
 411                 scancode &= ~BREAK_MASK;
 412
 413                 if (ikbd_self_test) {
 414                     /* Scancodes sent during the self-test stand for broken
 415                      * keys (keys being down). The code *should* be a break
 416                      * code, but nevertheless some AT keyboard interfaces send
 417                      * make codes instead. Therefore, simply ignore
 418                      * break_flag...
 419                      * */
 420                     int keyval = plain_map[scancode], keytyp;
 421
 422                     set_bit( scancode, broken_keys );
 423                     self_test_last_rcv = jiffies;
 424                     keyval = plain_map[scancode];
 425                     keytyp = KTYP(keyval) - 0xf0;
 426                     keyval = KVAL(keyval);
 427
 428                     printk( KERN_WARNING "Key with scancode %d ", scancode );
 429                     if (keytyp == KT_LATIN || keytyp == KT_LETTER) {
 430                         if (keyval < ' ')
 431                             printk( "('^%c') ", keyval + '@' );
 432                         else
 433                             printk( "('%c') ", keyval );
 434                     }
 435                     printk( "is broken -- will be ignored.\n" );
 436                     break;
 437                 }
 438                 else if (test_bit( scancode, broken_keys ))
 439                     break;
 440
 441                 if (break_flag) {
 442                     del_timer( &atakeyb_rep_timer );
 443                     rep_scancode = 0;
 444                 }
 445                 else {
 446                     del_timer( &atakeyb_rep_timer );
 447                     rep_scancode = scancode;
 448                     atakeyb_rep_timer.expires = jiffies + key_repeat_delay;
 449                     add_timer( &atakeyb_rep_timer );
 450                 }
 451
 452                 handle_scancode(scancode, !break_flag);
 453                 break;
 454             }
 455             break;
 456
 457           case AMOUSE:
 458             kb_state.buf[kb_state.len++] = scancode;
 459             if (kb_state.len == 5)
 460             {
 461                 kb_state.state = KEYBOARD;
 462                 /* not yet used */
 463                 /* wake up someone waiting for this */
 464             }
 465             break;
 466
 467           case RMOUSE:
 468             kb_state.buf[kb_state.len++] = scancode;
 469             if (kb_state.len == 3)
 470             {
 471                 kb_state.state = KEYBOARD;
 472                 if (atari_mouse_interrupt_hook)
 473                         atari_mouse_interrupt_hook(kb_state.buf);
 474             }
 475             break;
 476
 477           case JOYSTICK:
 478             kb_state.buf[1] = scancode;
 479             kb_state.state = KEYBOARD;
 480             atari_joystick_interrupt(kb_state.buf);
 481             break;
 482
 483           case CLOCK:
 484             kb_state.buf[kb_state.len++] = scancode;
 485             if (kb_state.len == 6)
 486             {
 487                 kb_state.state = KEYBOARD;
 488                 /* wake up someone waiting for this.
 489                    But will this ever be used, as Linux keeps its own time.
 490                    Perhaps for synchronization purposes? */
 491                 /* wake_up_interruptible(&clock_wait); */
 492             }
 493             break;
 494
 495           case RESYNC:
 496             if (kb_state.len <= 0 || IS_SYNC_CODE(scancode)) {
 497                 kb_state.state = KEYBOARD;
 498                 goto interpret_scancode;
 499             }
 500             kb_state.len--;
 501             break;
 502         }
 503     }
 504
 505 #if 0
 506     if (acia_stat & ACIA_CTS)
 507         /* cannot happen */;
 508 #endif
 509
 510     if (acia_stat & (ACIA_FE | ACIA_PE))
 511     {
 512         printk("Error in keyboard communication\n");
 513     }
 514
 515     /* handle_scancode() can take a lot of time, so check again if
 516          * some character arrived
 517          */
 518     goto repeat;
 519 }
 520
 521 /*
 522  * I write to the keyboard without using interrupts, I poll instead.
 523  * This takes for the maximum length string allowed (7) at 7812.5 baud
 524  * 8 data 1 start 1 stop bit: 9.0 ms
 525  * If this takes too long for normal operation, interrupt driven writing
 526  * is the solution. (I made a feeble attempt in that direction but I
 527  * kept it simple for now.)
 528  */
 529 void ikbd_write(const char *str, int len)
 530 {
 531     u_char acia_stat;
 532
 533     if ((len < 1) || (len > 7))
 534         panic("ikbd: maximum string length exceeded");
 535     while (len)
 536     {
 537         acia_stat = acia.key_ctrl;
 538         if (acia_stat & ACIA_TDRE)
 539         {
 540             acia.key_data = *str++;
 541             len--;
 542         }
 543     }
 544 }
 545
 546 /* Reset (without touching the clock) */
 547 void ikbd_reset(void)
 548 {
 549     static const char cmd[2] = { 0x80, 0x01 };
 550
 551     ikbd_write(cmd, 2);
 552
 553     /* if all's well code 0xF1 is returned, else the break codes of
 554        all keys making contact */
 555 }
 556
 557 /* Set mouse button action */
 558 void ikbd_mouse_button_action(int mode)
 559 {
 560     char cmd[2] = { 0x07, mode };
 561
 562     ikbd_write(cmd, 2);
 563 }
 564
 565 /* Set relative mouse position reporting */
 566 void ikbd_mouse_rel_pos(void)
 567 {
 568     static const char cmd[1] = { 0x08 };
 569
 570     ikbd_write(cmd, 1);
 571 }
 572
 573 /* Set absolute mouse position reporting */
 574 void ikbd_mouse_abs_pos(int xmax, int ymax)
 575 {
 576     char cmd[5] = { 0x09, xmax>>8, xmax&0xFF, ymax>>8, ymax&0xFF };
 577
 578     ikbd_write(cmd, 5);
 579 }
 580
 581 /* Set mouse keycode mode */
 582 void ikbd_mouse_kbd_mode(int dx, int dy)
 583 {
 584     char cmd[3] = { 0x0A, dx, dy };
 585
 586     ikbd_write(cmd, 3);
 587 }
 588
 589 /* Set mouse threshold */
 590 void ikbd_mouse_thresh(int x, int y)
 591 {
 592     char cmd[3] = { 0x0B, x, y };
 593
 594     ikbd_write(cmd, 3);
 595 }
 596
 597 /* Set mouse scale */
 598 void ikbd_mouse_scale(int x, int y)
 599 {
 600     char cmd[3] = { 0x0C, x, y };
 601
 602     ikbd_write(cmd, 3);
 603 }
 604
 605 /* Interrogate mouse position */
 606 void ikbd_mouse_pos_get(int *x, int *y)
 607 {
 608     static const char cmd[1] = { 0x0D };
 609
 610     ikbd_write(cmd, 1);
 611
 612     /* wait for returning bytes */
 613 }
 614
 615 /* Load mouse position */
 616 void ikbd_mouse_pos_set(int x, int y)
 617 {
 618     char cmd[6] = { 0x0E, 0x00, x>>8, x&0xFF, y>>8, y&0xFF };
 619
 620     ikbd_write(cmd, 6);
 621 }
 622
 623 /* Set Y=0 at bottom */
 624 void ikbd_mouse_y0_bot(void)
 625 {
 626     static const char cmd[1] = { 0x0F };
 627
 628     ikbd_write(cmd, 1);
 629 }
 630
 631 /* Set Y=0 at top */
 632 void ikbd_mouse_y0_top(void)
 633 {
 634     static const char cmd[1] = { 0x10 };
 635
 636     ikbd_write(cmd, 1);
 637 }
 638
 639 /* Resume */
 640 void ikbd_resume(void)
 641 {
 642     static const char cmd[1] = { 0x11 };
 643
 644     ikbd_write(cmd, 1);
 645 }
 646
 647 /* Disable mouse */
 648 void ikbd_mouse_disable(void)
 649 {
 650     static const char cmd[1] = { 0x12 };
 651
 652     ikbd_write(cmd, 1);
 653 }
 654
 655 /* Pause output */
 656 void ikbd_pause(void)
 657 {
 658     static const char cmd[1] = { 0x13 };
 659
 660     ikbd_write(cmd, 1);
 661 }
 662
 663 /* Set joystick event reporting */
 664 void ikbd_joystick_event_on(void)
 665 {
 666     static const char cmd[1] = { 0x14 };
 667
 668     ikbd_write(cmd, 1);
 669 }
 670
 671 /* Set joystick interrogation mode */
 672 void ikbd_joystick_event_off(void)
 673 {
 674     static const char cmd[1] = { 0x15 };
 675
 676     ikbd_write(cmd, 1);
 677 }
 678
 679 /* Joystick interrogation */
 680 void ikbd_joystick_get_state(void)
 681 {
 682     static const char cmd[1] = { 0x16 };
 683
 684     ikbd_write(cmd, 1);
 685 }
 686
 687 #if 0
 688 /* This disables all other ikbd activities !!!! */
 689 /* Set joystick monitoring */
 690 void ikbd_joystick_monitor(int rate)
 691 {
 692     static const char cmd[2] = { 0x17, rate };
 693
 694     ikbd_write(cmd, 2);
 695
 696     kb_state.state = JOYSTICK_MONITOR;
 697 }
 698 #endif
 699
 700 /* some joystick routines not in yet (0x18-0x19) */
 701
 702 /* Disable joysticks */
 703 void ikbd_joystick_disable(void)
 704 {
 705     static const char cmd[1] = { 0x1A };
 706
 707     ikbd_write(cmd, 1);
 708 }
 709
 710 /* Time-of-day clock set */
 711 void ikbd_clock_set(int year, int month, int day, int hour, int minute, int second)
 712 {
 713     char cmd[7] = { 0x1B, year, month, day, hour, minute, second };
 714
 715     ikbd_write(cmd, 7);
 716 }
 717
 718 /* Interrogate time-of-day clock */
 719 void ikbd_clock_get(int *year, int *month, int *day, int *hour, int *minute, int second)
 720 {
 721     static const char cmd[1] = { 0x1C };
 722
 723     ikbd_write(cmd, 1);
 724 }
 725
 726 /* Memory load */
 727 void ikbd_mem_write(int address, int size, char *data)
 728 {
 729     panic("Attempt to write data into keyboard memory");
 730 }
 731
 732 /* Memory read */
 733 void ikbd_mem_read(int address, char data[6])
 734 {
 735     char cmd[3] = { 0x21, address>>8, address&0xFF };
 736
 737     ikbd_write(cmd, 3);
 738
 739     /* receive data and put it in data */
 740 }
 741
 742 /* Controller execute */
 743 void ikbd_exec(int address)
 744 {
 745     char cmd[3] = { 0x22, address>>8, address&0xFF };
 746
 747     ikbd_write(cmd, 3);
 748 }
 749
 750 /* Status inquiries (0x87-0x9A) not yet implemented */
 751
 752 /* Set the state of the caps lock led. */
 753 void atari_kbd_leds (unsigned int leds)
 754 {
 755     char cmd[6] = {32, 0, 4, 1, 254 + ((leds & 4) != 0), 0};
 756     ikbd_write(cmd, 6);
 757 }
 758
 759 /*
 760  * The original code sometimes left the interrupt line of
 761  * the ACIAs low forever. I hope, it is fixed now.
 762  *
 763  * Martin Rogge, 20 Aug 1995
 764  */
 765
 766 int __init atari_keyb_init(void)
 767 {
 768     /* setup key map */
 769     memcpy(key_maps[0], ataplain_map, sizeof(plain_map));
 770     memcpy(key_maps[1], atashift_map, sizeof(plain_map));
 771     memcpy(key_maps[4], atactrl_map, sizeof(plain_map));
 772     memcpy(key_maps[5], atashift_ctrl_map, sizeof(plain_map));
 773     memcpy(key_maps[8], ataalt_map, sizeof(plain_map));
 774     /* Atari doesn't have an altgr_map, so we can reuse its memory for
 775        atashift_alt_map */
 776     memcpy(key_maps[2], atashift_alt_map, sizeof(plain_map));
 777     key_maps[9]  = key_maps[2];
 778     key_maps[2]  = 0; /* ataaltgr_map */
 779     memcpy(key_maps[12], atactrl_alt_map, sizeof(plain_map));
 780     key_maps[13] = atashift_ctrl_alt_map;
 781     keymap_count = 8;
 782
 783     /* say that we don't have an AltGr key */
 784     keyboard_type = KB_84;
 785
 786     kb_state.state = KEYBOARD;
 787     kb_state.len = 0;
 788
 789     request_irq(IRQ_MFP_ACIA, keyboard_interrupt, IRQ_TYPE_SLOW,
 790                 "keyboard/mouse/MIDI", keyboard_interrupt);
 791
 792     atari_turnoff_irq(IRQ_MFP_ACIA);
 793     do {
 794         /* reset IKBD ACIA */
 795         acia.key_ctrl = ACIA_RESET |
 796                         (atari_switches & ATARI_SWITCH_IKBD) ? ACIA_RHTID : 0;
 797         (void)acia.key_ctrl;
 798         (void)acia.key_data;
 799
 800         /* reset MIDI ACIA */
 801         acia.mid_ctrl = ACIA_RESET |
 802                         (atari_switches & ATARI_SWITCH_MIDI) ? ACIA_RHTID : 0;
 803         (void)acia.mid_ctrl;
 804         (void)acia.mid_data;
 805
 806         /* divide 500kHz by 64 gives 7812.5 baud */
 807         /* 8 data no parity 1 start 1 stop bit */
 808         /* receive interrupt enabled */
 809         /* RTS low (except if switch selected), transmit interrupt disabled */
 810         acia.key_ctrl = (ACIA_DIV64|ACIA_D8N1S|ACIA_RIE) |
 811                         ((atari_switches & ATARI_SWITCH_IKBD) ?
 812                          ACIA_RHTID : ACIA_RLTID);
 813
 814         acia.mid_ctrl = ACIA_DIV16 | ACIA_D8N1S |
 815                         (atari_switches & ATARI_SWITCH_MIDI) ? ACIA_RHTID : 0;
 816     }
 817     /* make sure the interrupt line is up */
 818     while ((mfp.par_dt_reg & 0x10) == 0);
 819
 820     /* enable ACIA Interrupts */
 821     mfp.active_edge &= ~0x10;
 822     atari_turnon_irq(IRQ_MFP_ACIA);
 823
 824     ikbd_self_test = 1;
 825     ikbd_reset();
 826     /* wait for a period of inactivity (here: 0.25s), then assume the IKBD's
 827      * self-test is finished */
 828     self_test_last_rcv = jiffies;
 829     while (time_before(jiffies, self_test_last_rcv + HZ/4))
 830         barrier();
 831     /* if not incremented: no 0xf1 received */
 832     if (ikbd_self_test == 1)
 833         printk( KERN_ERR "WARNING: keyboard self test failed!\n" );
 834     ikbd_self_test = 0;
 835
 836     ikbd_mouse_disable();
 837     ikbd_joystick_disable();
 838
 839     atari_joystick_init();
 840
 841     return 0;
 842 }
 843
 844
 845 int atari_kbdrate( struct kbd_repeat *k )
 846
 847 {
 848         if (k->delay > 0) {
 849                 /* convert from msec to jiffies */
 850                 key_repeat_delay = (k->delay * HZ + 500) / 1000;
 851                 if (key_repeat_delay < 1)
 852                         key_repeat_delay = 1;
 853         }
 854         if (k->rate > 0) {
 855                 key_repeat_rate = (k->rate * HZ + 500) / 1000;
 856                 if (key_repeat_rate < 1)
 857                         key_repeat_rate = 1;
 858         }
 859
 860         k->delay = key_repeat_delay * 1000 / HZ;
 861         k->rate  = key_repeat_rate  * 1000 / HZ;
 862
 863         return( 0 );
 864 }
 865
 866 int atari_kbd_translate(unsigned char keycode, unsigned char *keycodep, char raw_mode)
 867 {
 868 #ifdef CONFIG_MAGIC_SYSRQ
 869         /* ALT+HELP pressed? */
 870         if ((keycode == 98) && ((shift_state & 0xff) == 8))
 871                 *keycodep = 0xff;
 872         else
 873 #endif
 874                 *keycodep = keycode;
 875         return 1;
 876 }
 877