source: mainline/kernel/genarch/src/kbd/key.c@ cea12e9

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since cea12e9 was 28ecadb, checked in by Jakub Jermar <jakub@…>, 19 years ago

Convert sparc64 to detect keyboard and determine
its physical address by walking the memory representation
of the OpenFirmware device tree.

Add bus-specific functions that know how to apply the
"ranges" property to one component of the "reg" property.
Buses supported so far include FHC, EBUS and PCI.
  • Property mode set to 100644
File size: 6.3 KB
Line 
1/*
2 * Copyright (C) 2006 Jakub Jermar
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/** @addtogroup genarch
30 * @{
31 */
32/**
33 * @file
34 * @brief Key processing.
35 */
36
37#include <genarch/kbd/key.h>
38#include <genarch/kbd/scanc.h>
39#ifdef CONFIG_I8042
40#include <genarch/kbd/scanc_pc.h>
41#endif
42#if (defined(CONFIG_Z8530) || defined(CONFIG_NS16550))
43#include <genarch/kbd/scanc_sun.h>
44#endif
45#include <synch/spinlock.h>
46#include <console/chardev.h>
47#include <typedefs.h>
48#include <macros.h>
49
50#define PRESSED_SHIFT (1<<0)
51#define PRESSED_CAPSLOCK (1<<1)
52#define LOCKED_CAPSLOCK (1<<0)
53
54#define ACTIVE_READ_BUFF_SIZE 16 /* Must be power of 2 */
55
56chardev_t kbrd;
57
58static uint8_t active_read_buff[ACTIVE_READ_BUFF_SIZE];
59
60SPINLOCK_INITIALIZE(keylock); /**< keylock protects keyflags and lockflags. */
61static volatile int keyflags; /**< Tracking of multiple keypresses. */
62static volatile int lockflags; /**< Tracking of multiple keys lockings. */
63
64/** Process release of key.
65 *
66 * @param sc Scancode of the key being released.
67 */
68void key_released(uint8_t sc)
69{
70 spinlock_lock(&keylock);
71 switch (sc) {
72 case SC_LSHIFT:
73 case SC_RSHIFT:
74 keyflags &= ~PRESSED_SHIFT;
75 break;
76 case SC_CAPSLOCK:
77 keyflags &= ~PRESSED_CAPSLOCK;
78 if (lockflags & LOCKED_CAPSLOCK)
79 lockflags &= ~LOCKED_CAPSLOCK;
80 else
81 lockflags |= LOCKED_CAPSLOCK;
82 break;
83 default:
84 break;
85 }
86 spinlock_unlock(&keylock);
87}
88
89/** Process keypress.
90 *
91 * @param sc Scancode of the key being pressed.
92 */
93void key_pressed(uint8_t sc)
94{
95 char *map = sc_primary_map;
96 char ascii = sc_primary_map[sc];
97 bool shift, capslock;
98 bool letter = false;
99
100 spinlock_lock(&keylock);
101 switch (sc) {
102 case SC_LSHIFT:
103 case SC_RSHIFT:
104 keyflags |= PRESSED_SHIFT;
105 break;
106 case SC_CAPSLOCK:
107 keyflags |= PRESSED_CAPSLOCK;
108 break;
109 case SC_SPEC_ESCAPE:
110 break;
111 case SC_LEFTARR:
112 chardev_push_character(&kbrd, 0x1b);
113 chardev_push_character(&kbrd, 0x5b);
114 chardev_push_character(&kbrd, 0x44);
115 break;
116 case SC_RIGHTARR:
117 chardev_push_character(&kbrd, 0x1b);
118 chardev_push_character(&kbrd, 0x5b);
119 chardev_push_character(&kbrd, 0x43);
120 break;
121 case SC_UPARR:
122 chardev_push_character(&kbrd, 0x1b);
123 chardev_push_character(&kbrd, 0x5b);
124 chardev_push_character(&kbrd, 0x41);
125 break;
126 case SC_DOWNARR:
127 chardev_push_character(&kbrd, 0x1b);
128 chardev_push_character(&kbrd, 0x5b);
129 chardev_push_character(&kbrd, 0x42);
130 break;
131 case SC_HOME:
132 chardev_push_character(&kbrd, 0x1b);
133 chardev_push_character(&kbrd, 0x4f);
134 chardev_push_character(&kbrd, 0x48);
135 break;
136 case SC_END:
137 chardev_push_character(&kbrd, 0x1b);
138 chardev_push_character(&kbrd, 0x4f);
139 chardev_push_character(&kbrd, 0x46);
140 break;
141 case SC_DELETE:
142 chardev_push_character(&kbrd, 0x1b);
143 chardev_push_character(&kbrd, 0x5b);
144 chardev_push_character(&kbrd, 0x33);
145 chardev_push_character(&kbrd, 0x7e);
146 break;
147 default:
148 letter = is_lower(ascii);
149 capslock = (keyflags & PRESSED_CAPSLOCK) || (lockflags & LOCKED_CAPSLOCK);
150 shift = keyflags & PRESSED_SHIFT;
151 if (letter && capslock)
152 shift = !shift;
153 if (shift)
154 map = sc_secondary_map;
155 chardev_push_character(&kbrd, map[sc]);
156 break;
157 }
158 spinlock_unlock(&keylock);
159}
160
161uint8_t active_read_buff_read(void)
162{
163 static int i=0;
164 i &= (ACTIVE_READ_BUFF_SIZE-1);
165 if(!active_read_buff[i]) {
166 return 0;
167 }
168 return active_read_buff[i++];
169}
170
171void active_read_buff_write(uint8_t ch)
172{
173 static int i=0;
174 active_read_buff[i] = ch;
175 i++;
176 i &= (ACTIVE_READ_BUFF_SIZE-1);
177 active_read_buff[i]=0;
178}
179
180
181void active_read_key_pressed(uint8_t sc)
182{
183 char *map = sc_primary_map;
184 char ascii = sc_primary_map[sc];
185 bool shift, capslock;
186 bool letter = false;
187
188 /*spinlock_lock(&keylock);*/
189 switch (sc) {
190 case SC_LSHIFT:
191 case SC_RSHIFT:
192 keyflags |= PRESSED_SHIFT;
193 break;
194 case SC_CAPSLOCK:
195 keyflags |= PRESSED_CAPSLOCK;
196 break;
197 case SC_SPEC_ESCAPE:
198 break;
199 case SC_LEFTARR:
200 active_read_buff_write(0x1b);
201 active_read_buff_write(0x5b);
202 active_read_buff_write(0x44);
203 break;
204 case SC_RIGHTARR:
205 active_read_buff_write(0x1b);
206 active_read_buff_write(0x5b);
207 active_read_buff_write(0x43);
208 break;
209 case SC_UPARR:
210 active_read_buff_write(0x1b);
211 active_read_buff_write(0x5b);
212 active_read_buff_write(0x41);
213 break;
214 case SC_DOWNARR:
215 active_read_buff_write(0x1b);
216 active_read_buff_write(0x5b);
217 active_read_buff_write(0x42);
218 break;
219 case SC_HOME:
220 active_read_buff_write(0x1b);
221 active_read_buff_write(0x4f);
222 active_read_buff_write(0x48);
223 break;
224 case SC_END:
225 active_read_buff_write(0x1b);
226 active_read_buff_write(0x4f);
227 active_read_buff_write(0x46);
228 break;
229 case SC_DELETE:
230 active_read_buff_write(0x1b);
231 active_read_buff_write(0x5b);
232 active_read_buff_write(0x33);
233 active_read_buff_write(0x7e);
234 break;
235 default:
236 letter = is_lower(ascii);
237 capslock = (keyflags & PRESSED_CAPSLOCK) || (lockflags & LOCKED_CAPSLOCK);
238 shift = keyflags & PRESSED_SHIFT;
239 if (letter && capslock)
240 shift = !shift;
241 if (shift)
242 map = sc_secondary_map;
243 active_read_buff_write(map[sc]);
244 break;
245 }
246 /*spinlock_unlock(&keylock);*/
247
248}
249
250/** @}
251 */
Note: See TracBrowser for help on using the repository browser.