Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 700af62 in mainline


Ignore:
Timestamp:
2010-12-24T17:13:35Z (11 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master
Children:
a465a56
Parents:
77cea41
Message:

Hack for more keyboards in console

The console task periodically checks for new devices in /dev/class/keyboard.

Location:
uspace
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • uspace/drv/usbkbd/main.c

    r77cea41 r700af62  
    2929#include <driver.h>
    3030#include <ipc/driver.h>
     31#include <ipc/kbd.h>
     32#include <io/keycode.h>
     33#include <io/console.h>
    3134#include <errno.h>
    3235#include <fibril.h>
     
    4144#define GUESSED_POLL_ENDPOINT 1
    4245
     46static void default_connection_handler(device_t *, ipc_callid_t, ipc_call_t *);
     47static device_ops_t keyboard_ops = {
     48        .default_handler = default_connection_handler
     49};
     50
     51static int console_callback_phone = -1;
     52
     53/** Default handler for IPC methods not handled by DDF.
     54 *
     55 * @param dev Device handling the call.
     56 * @param icallid Call id.
     57 * @param icall Call data.
     58 */
     59void default_connection_handler(device_t *dev,
     60    ipc_callid_t icallid, ipc_call_t *icall)
     61{
     62        sysarg_t method = IPC_GET_IMETHOD(*icall);
     63
     64        if (method == IPC_M_CONNECT_TO_ME) {
     65                int callback = IPC_GET_ARG5(*icall);
     66
     67                if (console_callback_phone != -1) {
     68                        ipc_answer_0(icallid, ELIMIT);
     69                        return;
     70                }
     71
     72                console_callback_phone = callback;
     73                ipc_answer_0(icallid, EOK);
     74                return;
     75        }
     76
     77        ipc_answer_0(icallid, EINVAL);
     78}
     79
     80static void send_key(int key, int type, wchar_t c) {
     81        async_msg_4(console_callback_phone, KBD_EVENT, type, key,
     82            KM_NUM_LOCK, c);
     83}
     84
     85static void send_alnum(int key, wchar_t c) {
     86        printf(NAME ": sending key '%lc' to console\n", c);
     87        send_key(key, KEY_PRESS, c);
     88        send_key(key, KEY_RELEASE, c);
     89}
     90
    4391/*
    4492 * Callbacks for parser
     
    183231                sizeof(usb_hid_report_in_callbacks_t));
    184232        callbacks->keyboard = usbkbd_process_keycodes;
     233
     234        if (console_callback_phone != -1) {
     235                static size_t counter = 0;
     236                counter++;
     237                if (counter > 3) {
     238                        counter = 0;
     239                        send_alnum(KC_A, L'a');
     240                }
     241        }
    185242
    186243        usb_hid_parse_report(kbd_dev->parser, buffer, actual_size, callbacks,
     
    289346        fibril_add_ready(fid);
    290347
     348        dev->ops = &keyboard_ops;
     349
     350        add_device_to_class(dev, "keyboard");
     351
    291352        /*
    292353         * Hurrah, device is initialized.
  • uspace/lib/c/include/ipc/kbd.h

    r77cea41 r700af62  
    3939
    4040#include <ipc/ipc.h>
     41#include <ipc/dev_iface.h>
    4142
    4243typedef enum {
    43         KBD_YIELD = IPC_FIRST_USER_METHOD,
     44        KBD_YIELD = DEV_FIRST_CUSTOM_METHOD,
    4445        KBD_RECLAIM
    4546} kbd_request_t;
  • uspace/srv/hid/console/console.c

    r77cea41 r700af62  
    317317static void change_console(console_t *cons)
    318318{
    319         if (cons == active_console)
     319        if (cons == active_console) {
    320320                return;
     321        }
    321322       
    322323        fb_pending_flush();
     
    458459                        if (IPC_GET_ARG1(call) == 1) {
    459460                                int newcon = gcons_mouse_btn((bool) IPC_GET_ARG2(call));
    460                                 if (newcon != -1)
     461                                if (newcon != -1) {
    461462                                        change_console(&consoles[newcon]);
     463                                }
    462464                        }
    463465                        retval = 0;
     
    710712}
    711713
    712 static bool console_init(char *input)
    713 {
    714         /* Connect to input device */
    715         int input_fd = open(input, O_RDONLY);
    716         if (input_fd < 0) {
    717                 printf(NAME ": Failed opening %s\n", input);
    718                 return false;
    719         }
    720        
    721         kbd_phone = fd_phone(input_fd);
    722         if (kbd_phone < 0) {
     714static int connect_keyboard(char *path)
     715{
     716        int fd = open(path, O_RDONLY);
     717        if (fd < 0) {
     718                return fd;
     719        }
     720       
     721        int phone = fd_phone(fd);
     722        if (phone < 0) {
    723723                printf(NAME ": Failed to connect to input device\n");
    724                 return false;
     724                return phone;
    725725        }
    726726       
    727727        /* NB: The callback connection is slotted for removal */
    728728        sysarg_t phonehash;
    729         if (ipc_connect_to_me(kbd_phone, SERVICE_CONSOLE, 0, 0, &phonehash) != 0) {
     729        int rc = async_req_3_5(phone, IPC_M_CONNECT_TO_ME, SERVICE_CONSOLE,
     730            0, 0, NULL, NULL, NULL, NULL, &phonehash);
     731        if (rc != EOK) {
    730732                printf(NAME ": Failed to create callback from input device\n");
     733                return rc;
     734        }
     735       
     736        async_new_connection(phonehash, 0, NULL, keyboard_events);
     737
     738        printf(NAME ": we got a hit (new keyboard \"%s\").\n", path);
     739
     740        return phone;
     741}
     742
     743
     744static int check_new_keyboards(void *arg)
     745{
     746        char *class_name = (char *) arg;
     747
     748        int index = 1;
     749
     750        while (true) {
     751                async_usleep(1 * 500 * 1000);
     752                char *path;
     753                int rc = asprintf(&path, "/dev/class/%s\\%d", class_name, index);
     754                if (rc < 0) {
     755                        continue;
     756                }
     757                rc = 0;
     758                rc = connect_keyboard(path);
     759                if (rc > 0) {
     760                        /* We do not allow unplug. */
     761                        index++;
     762                }
     763
     764                free(path);
     765        }
     766
     767        return EOK;
     768}
     769
     770
     771/** Start a fibril monitoring hot-plugged keyboards.
     772 */
     773static void check_new_keyboards_in_background()
     774{
     775        fid_t fid = fibril_create(check_new_keyboards, (void *)"keyboard");
     776        if (!fid) {
     777                printf(NAME ": failed to create hot-plug-watch fibril.\n");
     778                return;
     779        }
     780        fibril_add_ready(fid);
     781}
     782
     783static bool console_init(char *input)
     784{
     785        /* Connect to input device */
     786        kbd_phone = connect_keyboard(input);
     787        if (kbd_phone < 0) {
    731788                return false;
    732789        }
    733        
    734         async_new_connection(phonehash, 0, NULL, keyboard_events);
    735        
     790
    736791        /* Connect to mouse device */
    737792        mouse_phone = -1;
     
    749804        }
    750805       
     806        sysarg_t phonehash;
    751807        if (ipc_connect_to_me(mouse_phone, SERVICE_CONSOLE, 0, 0, &phonehash) != 0) {
    752808                printf(NAME ": Failed to create callback from mouse device\n");
     
    841897        async_set_interrupt_received(interrupt_received);
    842898       
     899        /* Start fibril for checking on hot-plugged keyboards. */
     900        check_new_keyboards_in_background();
     901
    843902        return true;
    844903}
     
    860919        if (!console_init(argv[1]))
    861920                return -1;
    862        
     921
    863922        printf(NAME ": Accepting connections\n");
    864923        async_manager();
Note: See TracChangeset for help on using the changeset viewer.