Return to usb-hid.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / roms / seabios / src

Annotation of qemu/roms/seabios/src/usb-hid.c, revision 1.1

1.1     ! root        1: // Code for handling USB Human Interface Devices (HID).
        !             2: //
        !             3: // Copyright (C) 2009  Kevin O'Connor <[email protected]>
        !             4: //
        !             5: // This file may be distributed under the terms of the GNU LGPLv3 license.
        !             6: 
        !             7: #include "util.h" // dprintf
        !             8: #include "usb-hid.h" // usb_keyboard_setup
        !             9: #include "config.h" // CONFIG_*
        !            10: #include "usb.h" // usb_ctrlrequest
        !            11: #include "biosvar.h" // GET_GLOBAL
        !            12: 
        !            13: struct usb_pipe *keyboard_pipe VAR16VISIBLE;
        !            14: 
        !            15: 
        !            16: /****************************************************************
        !            17:  * Setup
        !            18:  ****************************************************************/
        !            19: 
        !            20: static int
        !            21: set_protocol(u32 endp, u16 val)
        !            22: {
        !            23:     struct usb_ctrlrequest req;
        !            24:     req.bRequestType = USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE;
        !            25:     req.bRequest = HID_REQ_SET_PROTOCOL;
        !            26:     req.wValue = val;
        !            27:     req.wIndex = 0;
        !            28:     req.wLength = 0;
        !            29:     return send_default_control(endp, &req, NULL);
        !            30: }
        !            31: 
        !            32: static int
        !            33: set_idle(u32 endp, u8 val)
        !            34: {
        !            35:     struct usb_ctrlrequest req;
        !            36:     req.bRequestType = USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE;
        !            37:     req.bRequest = HID_REQ_SET_IDLE;
        !            38:     req.wValue = val<<8;
        !            39:     req.wIndex = 0;
        !            40:     req.wLength = 0;
        !            41:     return send_default_control(endp, &req, NULL);
        !            42: }
        !            43: 
        !            44: int
        !            45: usb_keyboard_init(u32 endp, struct usb_interface_descriptor *iface, int imax)
        !            46: {
        !            47:     if (! CONFIG_USB_KEYBOARD)
        !            48:         return -1;
        !            49:     if (keyboard_pipe)
        !            50:         // XXX - this enables the first found keyboard (could be random)
        !            51:         return -1;
        !            52:     dprintf(2, "usb_keyboard_setup %x\n", endp);
        !            53: 
        !            54:     struct usb_endpoint_descriptor *epdesc = (void*)&iface[1];
        !            55:     for (;;) {
        !            56:         if ((void*)epdesc >= (void*)iface + imax
        !            57:             || epdesc->bDescriptorType == USB_DT_INTERFACE) {
        !            58:             dprintf(1, "No keyboard intr in?\n");
        !            59:             return -1;
        !            60:         }
        !            61:         if (epdesc->bDescriptorType == USB_DT_ENDPOINT
        !            62:             && (epdesc->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN
        !            63:             && ((epdesc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
        !            64:                 == USB_ENDPOINT_XFER_INT)
        !            65:             && epdesc->wMaxPacketSize == 8)
        !            66:             break;
        !            67:         epdesc = (void*)epdesc + epdesc->bLength;
        !            68:     }
        !            69:     u32 inendp = mkendp(endp2cntl(endp), endp2devaddr(endp)
        !            70:                         , epdesc->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK
        !            71:                         , endp2speed(endp), epdesc->wMaxPacketSize);
        !            72: 
        !            73:     // Enable "boot" protocol.
        !            74:     int ret = set_protocol(endp, 1);
        !            75:     if (ret)
        !            76:         return -1;
        !            77:     // Only send reports on a new key event.
        !            78:     ret = set_idle(endp, 0);
        !            79:     if (ret)
        !            80:         return -1;
        !            81: 
        !            82:     struct usb_pipe *pipe = alloc_intr_pipe(inendp, epdesc->bInterval);
        !            83:     if (!pipe)
        !            84:         return -1;
        !            85:     keyboard_pipe = pipe;
        !            86: 
        !            87:     return 0;
        !            88: }
        !            89: 
        !            90: void
        !            91: usb_keyboard_setup()
        !            92: {
        !            93:     if (! CONFIG_USB_KEYBOARD)
        !            94:         return;
        !            95:     keyboard_pipe = NULL;
        !            96: }
        !            97: 
        !            98: 
        !            99: /****************************************************************
        !           100:  * Keyboard events
        !           101:  ****************************************************************/
        !           102: 
        !           103: static u16 KeyToScanCode[] VAR16 = {
        !           104:     0x0000, 0x0000, 0x0000, 0x0000, 0x001e, 0x0030, 0x002e, 0x0020,
        !           105:     0x0012, 0x0021, 0x0022, 0x0023, 0x0017, 0x0024, 0x0025, 0x0026,
        !           106:     0x0032, 0x0031, 0x0018, 0x0019, 0x0010, 0x0013, 0x001f, 0x0014,
        !           107:     0x0016, 0x002f, 0x0011, 0x002d, 0x0015, 0x002c, 0x0002, 0x0003,
        !           108:     0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b,
        !           109:     0x001c, 0x0001, 0x000e, 0x000f, 0x0039, 0x000c, 0x000d, 0x001a,
        !           110:     0x001b, 0x002b, 0x0000, 0x0027, 0x0028, 0x0029, 0x0033, 0x0034,
        !           111:     0x0035, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f, 0x0040,
        !           112:     0x0041, 0x0042, 0x0043, 0x0044, 0x0057, 0x0058, 0xe037, 0x0046,
        !           113:     0xe11d, 0xe052, 0xe047, 0xe049, 0xe053, 0xe04f, 0xe051, 0xe04d,
        !           114:     0xe04b, 0xe050, 0xe048, 0x0045, 0xe035, 0x0037, 0x004a, 0x004e,
        !           115:     0xe01c, 0x004f, 0x0050, 0x0051, 0x004b, 0x004c, 0x004d, 0x0047,
        !           116:     0x0048, 0x0049, 0x0052, 0x0053
        !           117: };
        !           118: 
        !           119: static u16 ModifierToScanCode[] VAR16 = {
        !           120:     //lcntl, lshift, lalt, lgui, rcntl, rshift, ralt, rgui
        !           121:     0x001d, 0x002a, 0x0038, 0xe05b, 0xe01d, 0x0036, 0xe038, 0xe05c
        !           122: };
        !           123: 
        !           124: struct keyevent {
        !           125:     u8 modifiers;
        !           126:     u8 reserved;
        !           127:     u8 keys[6];
        !           128: };
        !           129: 
        !           130: static void
        !           131: prockeys(u16 keys)
        !           132: {
        !           133:     if (keys > 0xff) {
        !           134:         u8 key = keys>>8;
        !           135:         if (key == 0xe1) {
        !           136:             // Pause key
        !           137:             process_key(0xe1);
        !           138:             process_key(0x1d | (keys & 0x80));
        !           139:             process_key(0x45 | (keys & 0x80));
        !           140:             return;
        !           141:         }
        !           142:         process_key(key);
        !           143:     }
        !           144:     process_key(keys);
        !           145: }
        !           146: 
        !           147: static void
        !           148: handle_key(struct keyevent *data)
        !           149: {
        !           150:     dprintf(5, "Got key %x %x\n", data->modifiers, data->keys[0]);
        !           151:     // XXX
        !           152:     int i;
        !           153:     for (i=0; i<8; i++)
        !           154:         if (data->modifiers & (1<<i))
        !           155:             prockeys(GET_GLOBAL(ModifierToScanCode[i]));
        !           156:     for (i=0; i<ARRAY_SIZE(data->keys); i++) {
        !           157:         u8 key = data->keys[i];
        !           158:         if (key >= ARRAY_SIZE(KeyToScanCode))
        !           159:             continue;
        !           160:         key = GET_GLOBAL(KeyToScanCode[key]);
        !           161:         if (!key)
        !           162:             continue;
        !           163:         prockeys(key);
        !           164:     }
        !           165:     for (i=0; i<8; i++)
        !           166:         if (data->modifiers & (1<<i))
        !           167:             prockeys(GET_GLOBAL(ModifierToScanCode[i]) | 0x80);
        !           168: }
        !           169: 
        !           170: void
        !           171: usb_check_key()
        !           172: {
        !           173:     if (! CONFIG_USB_KEYBOARD)
        !           174:         return;
        !           175:     struct usb_pipe *pipe = GET_GLOBAL(keyboard_pipe);
        !           176:     if (!pipe)
        !           177:         return;
        !           178: 
        !           179:     for (;;) {
        !           180:         struct keyevent data;
        !           181:         int ret = usb_poll_intr(pipe, &data);
        !           182:         if (ret)
        !           183:             break;
        !           184:         handle_key(&data);
        !           185:     }
        !           186: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.