(minor) Modules/UDI - Improved error message for multiple UDI_DL_BUF
[tpg/acess2.git] / KernelLand / Modules / Input / Keyboard / main.c
1 /*
2  * Acess2 Kernel - Keyboard Driver
3  * - By John Hodge (thePowersGang)
4  *
5  * main.c
6  * - Keyboard driver core
7  *
8  * TODO: Make the key transation code more general (for non-US layouts)
9  * TODO: Support multiple virtual keyboards
10  */
11 #define DEBUG   0
12 #define VERSION VER2(1,0)
13 #include <acess.h>
14 #include <modules.h>
15 #include <fs_devfs.h>
16 #include <Input/Keyboard/include/keyboard.h>
17 #include "keymap_int.h"
18 #include "layout_kbdus.h"
19 #include <hal_proc.h>
20
21 #define USE_KERNEL_MAGIC        1
22
23 // === IMPORTS ===
24 #if USE_KERNEL_MAGIC
25 extern void     Threads_ToggleTrace(int TID);
26 extern void     Threads_Dump(void);
27 extern void     Heap_Stats(void);
28 #endif
29
30 // === PROTOTYPES ===
31  int    Keyboard_Install(char **Arguments);
32  int    Keyboard_Cleanup(void);
33 // - Internal
34 tKeymap *Keyboard_LoadMap(const char *Name);
35 void    Keyboard_FreeMap(tKeymap *Keymap);
36 // - "User" side (Actually VT)
37  int    Keyboard_IOCtl(tVFS_Node *Node, int ID, void *Data);
38 // - Device Side
39 tKeyboard *Keyboard_CreateInstance(int MaxSym, const char *Name);
40 void    Keyboard_RemoveInstance(tKeyboard *Instance);
41 void    Keyboard_HandleKey(tKeyboard *Source, Uint32 HIDKeySym);
42
43 // === GLOBALS ===
44 MODULE_DEFINE(0, VERSION, Keyboard, Keyboard_Install, Keyboard_Cleanup, NULL);
45 tVFS_NodeType   gKB_NodeType = {
46         .IOCtl = Keyboard_IOCtl
47 };
48 tDevFS_Driver   gKB_DevInfo = {
49         NULL, "Keyboard",
50         { .Type = &gKB_NodeType }
51 };
52 #if USE_KERNEL_MAGIC
53  int    giKB_MagicAddress = 0;
54  int    giKB_MagicAddressPos = 0;
55 #endif
56
57 // === CODE ===
58 /**
59  * \brief Initialise the keyboard driver
60  */
61 int Keyboard_Install(char **Arguments)
62 {
63         /// - Register with DevFS
64         DevFS_AddDevice( &gKB_DevInfo );
65         return 0;
66 }
67
68 /**
69  * \brief Pre-unload cleanup function
70  */
71 int Keyboard_Cleanup(void)
72 {
73         // TODO: Do I need this?
74         return 0;
75 }
76
77 // --- Map Management ---
78 /**
79  * \brief Load an arbitary keyboard map
80  * \param Name  Keymap name (e.g. "en-us")
81  * \return Keymap pointer
82  */
83 tKeymap *Keyboard_int_LoadMap(const char *Name)
84 {
85         Log_Warning("Keyboard", "TOD: Impliment Keyboard_int_LoadMap");
86         return NULL;
87 }
88
89 /**
90  * \brief Unload a keyboard map
91  * \param Keymap        Keymap to unload/free
92  */
93 void Keyboard_int_FreeMap(tKeymap *Keymap)
94 {
95 }
96
97 // --- VFS Interface ---
98 static const char *csaIOCTL_NAMES[] = {DRV_IOCTLNAMES, DRV_KEYBAORD_IOCTLNAMES, NULL};
99 /**
100  * \brief Keyboard IOCtl
101  */
102 int Keyboard_IOCtl(tVFS_Node *Node, int Id, void *Data)
103 {
104         switch(Id)
105         {
106         BASE_IOCTLS(DRV_TYPE_KEYBOARD, "Keyboard", 0x100, csaIOCTL_NAMES);
107         
108         case KB_IOCTL_SETCALLBACK:
109                 if( Threads_GetUID() != 0 )     return -1;
110                 if( MM_IsUser( (tVAddr)Data ) ) return -1;
111                 if( Node->ImplInt )     return 0;       // Can only be set once
112                 Node->ImplInt = (Uint)Data;
113                 return 1;
114         }
115         return -1;
116 }
117
118 // --- Device Interface ---
119 /*
120  * Create a new keyboard device instance
121  * TODO: Allow linking to other VFS nodes
122  * See Input/Keyboard/include/keyboard.h
123  */
124 tKeyboard *Keyboard_CreateInstance(int MaxSym, const char *Name)
125 {
126         tKeyboard       *ret;
127          int    sym_bitmap_size = (MaxSym + 7)/8;
128          int    string_size = strlen(Name) + 1;
129
130         ret = malloc( sizeof(tKeyboard) + sym_bitmap_size + string_size );
131         if( !ret ) {
132                 return NULL;
133         }
134         // Clear
135         memset(ret, 0, sizeof(tKeyboard) + sym_bitmap_size );
136         // Set name
137         ret->Name = (char*)ret + sizeof(tKeyboard) + sym_bitmap_size;
138         memcpy(ret->Name, Name, string_size);
139         // Set node and default keymap
140         ret->Node = &gKB_DevInfo.RootNode;
141         ret->Keymap = &gKeymap_KBDUS;
142
143         return ret;
144 }
145
146 /*
147  * Destroy a keyboard instance
148  * - See Input/Keyboard/include/keyboard.h
149  */
150 void Keyboard_RemoveInstance(tKeyboard *Instance)
151 {
152         // TODO: Implement
153         Log_Error("Keyboard", "TODO: Implement Keyboard_RemoveInstance");
154 }
155
156 /*
157  * Handle a key press/release event
158  * - See Input/Keyboard/include/keyboard.h
159  */
160 void Keyboard_HandleKey(tKeyboard *Source, Uint32 HIDKeySym)
161 {
162          int    bPressed;
163         Uint32  trans;
164         Uint32  flag;
165         Uint8   layer;
166         
167         if( !Source ) {
168                 Log_Error("Keyboard", "Passed NULL handle");
169                 return ;
170         }
171         if( !Source->Node ) {
172                 Log_Error("Keyboard", "Passed handle with NULL node");
173                 return ;
174         }
175         
176         bPressed = !(HIDKeySym & (1 << 31));
177         HIDKeySym &= 0x7FFFFFFF;
178
179         // - Determine the action (Press, Release or Refire)
180         {
181                 Uint8   mask = 1 << (HIDKeySym&7);
182                  int    ofs = HIDKeySym / 8;
183                  int    oldstate = !!(Source->KeyStates[ofs] & mask);
184                 
185                 // Get the state of all other devices attached
186                  int    otherstate = 0;
187                 for( tKeyboard *kb = Source->Node->ImplPtr; kb; kb = kb->Next )
188                 {
189                         if( kb == Source )      continue ;
190                         if( kb->MaxKeysym <= HIDKeySym )        continue ;
191                         otherstate = otherstate || (kb->KeyStates[ofs] & mask);
192                 }
193                 
194                 // Update key state
195                 if( bPressed )
196                         Source->KeyStates[ ofs ] |= mask;
197                 else
198                         Source->KeyStates[ ofs ] &= ~mask;
199                 
200                 // Get the final flag
201                 if( bPressed )
202                 {
203                         if( !oldstate && !otherstate )
204                                 flag = KEY_ACTION_PRESS; // Down
205                         else
206                                 flag = KEY_ACTION_REFIRE; // Refire
207                 }
208                 else
209                 {
210                         if( !otherstate )
211                                 flag = KEY_ACTION_RELEASE; // Up
212                         else
213                                 flag = -1; // Do nothing
214                 }
215         }
216
217         // Translate \a State into layer
218         // TODO: Support non-trivial layouts
219         layer = !!(Source->State & 3);
220         
221         // Do translation
222         if( flag == KEY_ACTION_RELEASE )
223                 trans = 0;
224         else {  
225                 
226                 // Translate the keysym into a character
227                 if( layer >= Source->Keymap->nLayers )
228                         trans = 0;
229                 else if( HIDKeySym >= Source->Keymap->Layers[layer]->nSyms )
230                         trans = 0;
231                 else
232                         trans = Source->Keymap->Layers[layer]->Sym[HIDKeySym];
233                 // - No translation in \a layer, fall back to layer=0
234                 if(!trans && HIDKeySym < Source->Keymap->Layers[0]->nSyms)
235                         trans = Source->Keymap->Layers[0]->Sym[HIDKeySym];
236         }
237
238         // Call callback (only if the action is valid)
239         if( flag != -1 )
240         {
241                 tKeybardCallback Callback = (void*)Source->Node->ImplInt;
242                 Callback( HIDKeySym | KEY_ACTION_RAWSYM );
243                 Callback( flag | trans );
244         }
245
246         // TODO: Translate this into agnostic code
247         switch( HIDKeySym )
248         {
249         case KEYSYM_LEFTSHIFT:
250                 if(bPressed) Source->State |= 1;
251                 else Source->State &= ~1;
252                 break;
253         case KEYSYM_RIGHTSHIFT:
254                 if(bPressed) Source->State |= 2;
255                 else Source->State &= ~2;
256                 break;
257         }
258
259         // --- Check for Kernel Magic Combos
260         #if USE_KERNEL_MAGIC
261         if(bPressed
262         && Source->KeyStates[KEYSYM_LEFTCTRL/8] & (1 << (KEYSYM_LEFTCTRL&7))
263         && Source->KeyStates[KEYSYM_LEFTALT/8]  & (1 << (KEYSYM_LEFTALT &7)) )
264         {
265                  int    val;
266                 switch(trans)
267                 {
268                 case '0': val = 0;  goto _av;   case '1': val = 1;  goto _av;
269                 case '2': val = 2;  goto _av;   case '3': val = 3;  goto _av;
270                 case '4': val = 4;  goto _av;   case '5': val = 5;  goto _av;
271                 case '6': val = 6;  goto _av;   case '7': val = 7;  goto _av;
272                 case '8': val = 8;  goto _av;   case '9': val = 9;  goto _av;
273                 case 'a': val = 10; goto _av;   case 'b': val = 11; goto _av;
274                 case 'c': val = 12; goto _av;   case 'd': val = 13; goto _av;
275                 case 'e': val = 14; goto _av;   case 'f': val = 15; goto _av;
276                 _av:
277                         if(giKB_MagicAddressPos == BITS/4)      break;
278                         giKB_MagicAddress |= (Uint)val << giKB_MagicAddressPos;
279                         giKB_MagicAddressPos ++;
280                         break;
281                 
282                 // Instruction Tracing
283                 case 't':
284                         Log("Toggle instruction tracing on %i\n", giKB_MagicAddress);
285                         Threads_ToggleTrace( giKB_MagicAddress );
286                         giKB_MagicAddress = 0;  giKB_MagicAddressPos = 0;
287                         return;
288                 
289                 // Thread List Dump
290                 case 'p':       Threads_Dump(); return;
291                 // Heap Statistics
292                 case 'h':       Heap_Stats();   return;
293                 // PMem Statistics
294                 case 'm':       MM_DumpStatistics();    return;
295                 // Dump Structure
296                 case 's':       return;
297                 }
298         }
299         #endif
300
301         #if defined(ARCHDIR_is_x86) || defined(ARCHDIR_is_x86_64)
302         if(bPressed
303         && Source->KeyStates[KEYSYM_LEFTCTRL/8] & (1 << (KEYSYM_LEFTCTRL&7))
304         && Source->KeyStates[KEYSYM_LEFTALT/8]  & (1 << (KEYSYM_LEFTALT &7)) )
305         {
306                 if( HIDKeySym == KEYSYM_DELETE )
307                 {
308                         // Trigger triple fault
309                         __asm__ __volatile__ ("lgdt (%esp) ; int $0x0");
310                         for(;;);
311                 }
312         }
313         #endif
314
315 }
316

UCC git Repository :: git.ucc.asn.au