Subversion Repositories HelenOS

Rev

Rev 4240 | Rev 4329 | Go to most recent revision | Only display areas with differences | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 4240 Rev 4285
1
/*
1
/*
2
 * Copyright (c) 2006 Josef Cejka
2
 * Copyright (c) 2006 Josef Cejka
3
 * All rights reserved.
3
 * All rights reserved.
4
 *
4
 *
5
 * Redistribution and use in source and binary forms, with or without
5
 * Redistribution and use in source and binary forms, with or without
6
 * modification, are permitted provided that the following conditions
6
 * modification, are permitted provided that the following conditions
7
 * are met:
7
 * are met:
8
 *
8
 *
9
 * - Redistributions of source code must retain the above copyright
9
 * - Redistributions of source code must retain the above copyright
10
 *   notice, this list of conditions and the following disclaimer.
10
 *   notice, this list of conditions and the following disclaimer.
11
 * - Redistributions in binary form must reproduce the above copyright
11
 * - Redistributions in binary form must reproduce the above copyright
12
 *   notice, this list of conditions and the following disclaimer in the
12
 *   notice, this list of conditions and the following disclaimer in the
13
 *   documentation and/or other materials provided with the distribution.
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
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.
15
 *   derived from this software without specific prior written permission.
16
 *
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
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
18
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
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
23
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
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
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.
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
 */
27
 */
28
 
28
 
29
/**
29
/**
30
 * @addtogroup kbdgen generic
30
 * @addtogroup kbdgen generic
31
 * @brief   HelenOS generic uspace keyboard handler.
31
 * @brief   HelenOS generic uspace keyboard handler.
32
 * @ingroup  kbd
32
 * @ingroup  kbd
33
 * @{
33
 * @{
34
 */
34
 */
35
/** @file
35
/** @file
36
 */
36
 */
37
 
37
 
38
#include <ipc/ipc.h>
38
#include <ipc/ipc.h>
39
#include <ipc/services.h>
39
#include <ipc/services.h>
40
#include <sysinfo.h>
40
#include <sysinfo.h>
41
#include <stdio.h>
41
#include <stdio.h>
42
#include <unistd.h>
42
#include <unistd.h>
43
#include <stdlib.h>
43
#include <stdlib.h>
44
#include <stdio.h>
44
#include <stdio.h>
45
#include <ipc/ns.h>
45
#include <ipc/ns.h>
46
#include <async.h>
46
#include <async.h>
47
#include <errno.h>
47
#include <errno.h>
48
#include <libadt/fifo.h>
48
#include <libadt/fifo.h>
49
#include <kbd/kbd.h>
49
#include <kbd/kbd.h>
50
#include <kbd/keycode.h>
50
#include <kbd/keycode.h>
51
 
51
 
52
#include <kbd.h>
52
#include <kbd.h>
53
#include <key_buffer.h>
53
#include <key_buffer.h>
54
#include <kbd_port.h>
54
#include <kbd_port.h>
55
#include <kbd_ctl.h>
55
#include <kbd_ctl.h>
56
#include <layout.h>
56
#include <layout.h>
57
 
57
 
58
#define NAME "kbd"
58
#define NAME "kbd"
59
 
59
 
60
int cons_connected = 0;
60
int cons_connected = 0;
61
int phone2cons = -1;
61
int phone2cons = -1;
62
keybuffer_t keybuffer;
62
keybuffer_t keybuffer;
63
 
63
 
64
/** Currently active modifiers. */
64
/** Currently active modifiers. */
65
static unsigned mods = KM_NUM_LOCK;
65
static unsigned mods = KM_NUM_LOCK;
66
 
66
 
67
/** Currently pressed lock keys. We track these to tackle autorepeat. */
67
/** Currently pressed lock keys. We track these to tackle autorepeat. */
68
static unsigned lock_keys;
68
static unsigned lock_keys;
69
 
69
 
70
int cir_service = 0;
70
int cir_service = 0;
71
int cir_phone = -1;
71
int cir_phone = -1;
72
 
72
 
73
#define NUM_LAYOUTS 3
73
#define NUM_LAYOUTS 3
74
 
74
 
75
static layout_op_t *layout[NUM_LAYOUTS] = {
75
static layout_op_t *layout[NUM_LAYOUTS] = {
76
    &us_qwerty_op,
76
    &us_qwerty_op,
77
    &us_dvorak_op,
77
    &us_dvorak_op,
78
    &cz_op
78
    &cz_op
79
};
79
};
80
 
80
 
81
static int active_layout = 0;
81
static int active_layout = 0;
82
 
82
 
83
void kbd_push_scancode(int scancode)
83
void kbd_push_scancode(int scancode)
84
{
84
{
85
/*  printf("scancode: 0x%x\n", scancode);*/
85
/*  printf("scancode: 0x%x\n", scancode);*/
86
    kbd_ctl_parse_scancode(scancode);
86
    kbd_ctl_parse_scancode(scancode);
87
}
87
}
88
 
88
 
89
void kbd_push_ev(int type, unsigned int key)
89
void kbd_push_ev(int type, unsigned int key)
90
{
90
{
91
    kbd_event_t ev;
91
    kbd_event_t ev;
92
    unsigned mod_mask;
92
    unsigned mod_mask;
93
 
93
 
94
    switch (key) {
94
    switch (key) {
95
    case KC_LCTRL: mod_mask = KM_LCTRL; break;
95
    case KC_LCTRL: mod_mask = KM_LCTRL; break;
96
    case KC_RCTRL: mod_mask = KM_RCTRL; break;
96
    case KC_RCTRL: mod_mask = KM_RCTRL; break;
97
    case KC_LSHIFT: mod_mask = KM_LSHIFT; break;
97
    case KC_LSHIFT: mod_mask = KM_LSHIFT; break;
98
    case KC_RSHIFT: mod_mask = KM_RSHIFT; break;
98
    case KC_RSHIFT: mod_mask = KM_RSHIFT; break;
99
    case KC_LALT: mod_mask = KM_LALT; break;
99
    case KC_LALT: mod_mask = KM_LALT; break;
100
    case KC_RALT: mod_mask = KM_RALT; break;
100
    case KC_RALT: mod_mask = KM_RALT; break;
101
    default: mod_mask = 0; break;
101
    default: mod_mask = 0; break;
102
    }
102
    }
103
 
103
 
104
    if (mod_mask != 0) {
104
    if (mod_mask != 0) {
105
        if (type == KE_PRESS)
105
        if (type == KE_PRESS)
106
            mods = mods | mod_mask;
106
            mods = mods | mod_mask;
107
        else
107
        else
108
            mods = mods & ~mod_mask;
108
            mods = mods & ~mod_mask;
109
    }
109
    }
110
 
110
 
111
    switch (key) {
111
    switch (key) {
112
    case KC_CAPS_LOCK: mod_mask = KM_CAPS_LOCK; break;
112
    case KC_CAPS_LOCK: mod_mask = KM_CAPS_LOCK; break;
113
    case KC_NUM_LOCK: mod_mask = KM_NUM_LOCK; break;
113
    case KC_NUM_LOCK: mod_mask = KM_NUM_LOCK; break;
114
    case KC_SCROLL_LOCK: mod_mask = KM_SCROLL_LOCK; break;
114
    case KC_SCROLL_LOCK: mod_mask = KM_SCROLL_LOCK; break;
115
    default: mod_mask = 0; break;
115
    default: mod_mask = 0; break;
116
    }
116
    }
117
 
117
 
118
    if (mod_mask != 0) {
118
    if (mod_mask != 0) {
119
        if (type == KE_PRESS) {
119
        if (type == KE_PRESS) {
120
            /*
120
            /*
121
             * Only change lock state on transition from released
121
             * Only change lock state on transition from released
122
             * to pressed. This prevents autorepeat from messing
122
             * to pressed. This prevents autorepeat from messing
123
             * up the lock state.
123
             * up the lock state.
124
             */
124
             */
125
            mods = mods ^ (mod_mask & ~lock_keys);
125
            mods = mods ^ (mod_mask & ~lock_keys);
126
            lock_keys = lock_keys | mod_mask;
126
            lock_keys = lock_keys | mod_mask;
127
        } else {
127
        } else {
128
            lock_keys = lock_keys & ~mod_mask;
128
            lock_keys = lock_keys & ~mod_mask;
129
        }
129
        }
130
    }
130
    }
131
/*
131
/*
132
    printf("type: %d\n", type);
132
    printf("type: %d\n", type);
133
    printf("mods: 0x%x\n", mods);
133
    printf("mods: 0x%x\n", mods);
134
    printf("keycode: %u\n", key);
134
    printf("keycode: %u\n", key);
135
*/
135
*/
136
    if (type == KE_PRESS && (mods & KM_LCTRL) &&
136
    if (type == KE_PRESS && (mods & KM_LCTRL) &&
137
        key == KC_F1) {
137
        key == KC_F1) {
138
        active_layout = 0;
138
        active_layout = 0;
-
 
139
        layout[active_layout]->reset();
139
        return;
140
        return;
140
    }
141
    }
141
 
142
 
142
    if (type == KE_PRESS && (mods & KM_LCTRL) &&
143
    if (type == KE_PRESS && (mods & KM_LCTRL) &&
143
        key == KC_F2) {
144
        key == KC_F2) {
144
        active_layout = 1;
145
        active_layout = 1;
-
 
146
        layout[active_layout]->reset();
145
        return;
147
        return;
146
    }
148
    }
147
 
149
 
148
    if (type == KE_PRESS && (mods & KM_LCTRL) &&
150
    if (type == KE_PRESS && (mods & KM_LCTRL) &&
149
        key == KC_F3) {
151
        key == KC_F3) {
150
        active_layout = 2;
152
        active_layout = 2;
-
 
153
        layout[active_layout]->reset();
151
        return;
154
        return;
152
    }
155
    }
153
 
156
 
154
    ev.type = type;
157
    ev.type = type;
155
    ev.key = key;
158
    ev.key = key;
156
    ev.mods = mods;
159
    ev.mods = mods;
157
 
160
 
158
    ev.c = layout[active_layout]->parse_ev(&ev);
161
    ev.c = layout[active_layout]->parse_ev(&ev);
159
 
162
 
160
    async_msg_4(phone2cons, KBD_EVENT, ev.type, ev.key, ev.mods, ev.c);
163
    async_msg_4(phone2cons, KBD_EVENT, ev.type, ev.key, ev.mods, ev.c);
161
}
164
}
162
 
165
 
163
static void console_connection(ipc_callid_t iid, ipc_call_t *icall)
166
static void console_connection(ipc_callid_t iid, ipc_call_t *icall)
164
{
167
{
165
    ipc_callid_t callid;
168
    ipc_callid_t callid;
166
    ipc_call_t call;
169
    ipc_call_t call;
167
    int retval;
170
    int retval;
168
 
171
 
169
    if (cons_connected) {
172
    if (cons_connected) {
170
        ipc_answer_0(iid, ELIMIT);
173
        ipc_answer_0(iid, ELIMIT);
171
        return;
174
        return;
172
    }
175
    }
173
    cons_connected = 1;
176
    cons_connected = 1;
174
    ipc_answer_0(iid, EOK);
177
    ipc_answer_0(iid, EOK);
175
 
178
 
176
    while (1) {
179
    while (1) {
177
        callid = async_get_call(&call);
180
        callid = async_get_call(&call);
178
        switch (IPC_GET_METHOD(call)) {
181
        switch (IPC_GET_METHOD(call)) {
179
        case IPC_M_PHONE_HUNGUP:
182
        case IPC_M_PHONE_HUNGUP:
180
            cons_connected = 0;
183
            cons_connected = 0;
181
            ipc_hangup(phone2cons);
184
            ipc_hangup(phone2cons);
182
            phone2cons = -1;
185
            phone2cons = -1;
183
            ipc_answer_0(callid, EOK);
186
            ipc_answer_0(callid, EOK);
184
            return;
187
            return;
185
        case IPC_M_CONNECT_TO_ME:
188
        case IPC_M_CONNECT_TO_ME:
186
            if (phone2cons != -1) {
189
            if (phone2cons != -1) {
187
                retval = ELIMIT;
190
                retval = ELIMIT;
188
                break;
191
                break;
189
            }
192
            }
190
            phone2cons = IPC_GET_ARG5(call);
193
            phone2cons = IPC_GET_ARG5(call);
191
            retval = 0;
194
            retval = 0;
192
            break;
195
            break;
193
        default:
196
        default:
194
            retval = EINVAL;
197
            retval = EINVAL;
195
        }
198
        }
196
        ipc_answer_0(callid, retval);
199
        ipc_answer_0(callid, retval);
197
    }  
200
    }  
198
}
201
}
199
 
202
 
200
 
203
 
201
int main(int argc, char **argv)
204
int main(int argc, char **argv)
202
{
205
{
203
    printf(NAME ": HelenOS Keyboard service\n");
206
    printf(NAME ": HelenOS Keyboard service\n");
204
   
207
   
205
    ipcarg_t phonead;
208
    ipcarg_t phonead;
206
   
209
   
207
    if (sysinfo_value("kbd.cir.fhc") == 1)
210
    if (sysinfo_value("kbd.cir.fhc") == 1)
208
        cir_service = SERVICE_FHC;
211
        cir_service = SERVICE_FHC;
209
    else if (sysinfo_value("kbd.cir.obio") == 1)
212
    else if (sysinfo_value("kbd.cir.obio") == 1)
210
        cir_service = SERVICE_OBIO;
213
        cir_service = SERVICE_OBIO;
211
   
214
   
212
    if (cir_service) {
215
    if (cir_service) {
213
        while (cir_phone < 0) {
216
        while (cir_phone < 0) {
214
            cir_phone = ipc_connect_me_to_blocking(PHONE_NS, cir_service,
217
            cir_phone = ipc_connect_me_to_blocking(PHONE_NS, cir_service,
215
                0, 0);
218
                0, 0);
216
        }
219
        }
217
    }
220
    }
218
   
221
   
219
    /* Initialize port driver. */
222
    /* Initialize port driver. */
220
    if (kbd_port_init() != 0)
223
    if (kbd_port_init() != 0)
221
        return -1;
224
        return -1;
222
 
225
 
223
    /* Initialize controller driver. */
226
    /* Initialize controller driver. */
224
    if (kbd_ctl_init() != 0)
227
    if (kbd_ctl_init() != 0)
225
        return -1;
228
        return -1;
226
   
229
 
-
 
230
    /* Initialize (reset) layout. */
-
 
231
    layout[active_layout]->reset();
-
 
232
   
227
    /* Initialize key buffer */
233
    /* Initialize key buffer */
228
    keybuffer_init(&keybuffer);
234
    keybuffer_init(&keybuffer);
229
   
235
   
230
    async_set_client_connection(console_connection);
236
    async_set_client_connection(console_connection);
231
 
237
 
232
    /* Register service at nameserver. */
238
    /* Register service at nameserver. */
233
    if (ipc_connect_to_me(PHONE_NS, SERVICE_KEYBOARD, 0, 0, &phonead) != 0)
239
    if (ipc_connect_to_me(PHONE_NS, SERVICE_KEYBOARD, 0, 0, &phonead) != 0)
234
        return -1;
240
        return -1;
235
   
241
   
236
    printf(NAME ": Accepting connections\n");
242
    printf(NAME ": Accepting connections\n");
237
    async_manager();
243
    async_manager();
238
 
244
 
239
    /* Not reached. */
245
    /* Not reached. */
240
    return 0;
246
    return 0;
241
}
247
}
242
 
248
 
243
/**
249
/**
244
 * @}
250
 * @}
245
 */
251
 */
246
 
252