Changes in uspace/drv/usbhid/main.c [c2fa801:0f21c0c] in mainline
- File:
-
- 1 edited
-
uspace/drv/usbhid/main.c (modified) (28 diffs)
Legend:
- Unmodified
- Added
- Removed
-
uspace/drv/usbhid/main.c
rc2fa801 r0f21c0c 36 36 */ 37 37 38 #include <d df/driver.h>38 #include <driver.h> 39 39 #include <ipc/driver.h> 40 40 #include <ipc/kbd.h> … … 51 51 #include <usb/descriptor.h> 52 52 #include <io/console.h> 53 #include <stdint.h>54 #include <usb/dp.h>55 53 #include "hid.h" 54 #include "descparser.h" 55 #include "descdump.h" 56 56 #include "conv.h" 57 57 #include "layout.h" 58 58 59 59 #define BUFFER_SIZE 8 60 #define BUFFER_OUT_SIZE 161 60 #define NAME "usbhid" 62 61 63 //#define GUESSED_POLL_ENDPOINT 1 64 #define BOOTP_REPORT_SIZE 6 65 66 static unsigned DEFAULT_ACTIVE_MODS = KM_NUM_LOCK; 62 #define GUESSED_POLL_ENDPOINT 1 67 63 68 64 /** Keyboard polling endpoint description for boot protocol class. */ … … 76 72 }; 77 73 78 static void default_connection_handler(d df_fun_t *, ipc_callid_t, ipc_call_t *);79 static d df_dev_ops_t keyboard_ops = {74 static void default_connection_handler(device_t *, ipc_callid_t, ipc_call_t *); 75 static device_ops_t keyboard_ops = { 80 76 .default_handler = default_connection_handler 81 77 }; … … 89 85 * @param icall Call data. 90 86 */ 91 void default_connection_handler(d df_fun_t *fun,87 void default_connection_handler(device_t *dev, 92 88 ipc_callid_t icallid, ipc_call_t *icall) 93 89 { … … 124 120 125 121 static void dump_buffer(const char *msg, const uint8_t *buffer, size_t length) 126 { uint8_t buffer[BUFFER_SIZE];122 { 127 123 printf("%s\n", msg); 128 124 … … 141 137 */ 142 138 143 /** Currently active modifiers (locks is probably better word).139 /** Currently active modifiers. 144 140 * 145 141 * TODO: put to device? 146 142 */ 147 //static unsigned mods = KM_NUM_LOCK;143 static unsigned mods = KM_NUM_LOCK; 148 144 149 145 /** Currently pressed lock keys. We track these to tackle autorepeat. … … 151 147 * TODO: put to device? 152 148 */ 153 //static unsigned lock_keys;149 static unsigned lock_keys; 154 150 155 151 #define NUM_LAYOUTS 3 … … 163 159 static int active_layout = 0; 164 160 165 static void usbkbd_req_set_report(usb_hid_dev_kbd_t *kbd_dev, uint16_t iface, 166 usb_hid_report_type_t type, uint8_t *buffer, size_t buf_size) 167 { 168 int rc, sess_rc; 169 170 sess_rc = usb_endpoint_pipe_start_session(&kbd_dev->ctrl_pipe); 171 if (sess_rc != EOK) { 172 usb_log_warning("Failed to start a session: %s.\n", 173 str_error(sess_rc)); 174 return; 175 } 176 177 usb_log_debug("Sending Set_Report request to the device.\n"); 178 179 rc = usb_control_request_set(&kbd_dev->ctrl_pipe, 180 USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 181 USB_HIDREQ_SET_REPORT, type, iface, buffer, buf_size); 182 183 sess_rc = usb_endpoint_pipe_end_session(&kbd_dev->ctrl_pipe); 184 185 if (rc != EOK) { 186 usb_log_warning("Error sending output report to the keyboard: " 187 "%s.\n", str_error(rc)); 188 return; 189 } 190 191 if (sess_rc != EOK) { 192 usb_log_warning("Error closing session: %s.\n", 193 str_error(sess_rc)); 194 return; 195 } 196 } 197 198 static void usbkbd_req_set_protocol(usb_hid_dev_kbd_t *kbd_dev, 199 usb_hid_protocol_t protocol) 200 { 201 int rc, sess_rc; 202 203 sess_rc = usb_endpoint_pipe_start_session(&kbd_dev->ctrl_pipe); 204 if (sess_rc != EOK) { 205 usb_log_warning("Failed to start a session: %s.\n", 206 str_error(sess_rc)); 207 return; 208 } 209 210 usb_log_debug("Sending Set_Protocol request to the device (" 211 "protocol: %d, iface: %d).\n", protocol, kbd_dev->iface); 212 213 rc = usb_control_request_set(&kbd_dev->ctrl_pipe, 214 USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, 215 USB_HIDREQ_SET_PROTOCOL, protocol, kbd_dev->iface, NULL, 0); 216 217 sess_rc = usb_endpoint_pipe_end_session(&kbd_dev->ctrl_pipe); 218 219 if (rc != EOK) { 220 usb_log_warning("Error sending output report to the keyboard: " 221 "%s.\n", str_error(rc)); 222 return; 223 } 224 225 if (sess_rc != EOK) { 226 usb_log_warning("Error closing session: %s.\n", 227 str_error(sess_rc)); 228 return; 229 } 230 } 231 232 static void usbkbd_set_led(usb_hid_dev_kbd_t *kbd_dev) 233 { 234 uint8_t buffer[BUFFER_OUT_SIZE]; 235 int rc= 0, i; 236 237 memset(buffer, 0, BUFFER_OUT_SIZE); 238 uint8_t leds = 0; 239 240 if (kbd_dev->mods & KM_NUM_LOCK) { 241 leds |= USB_HID_LED_NUM_LOCK; 242 } 243 244 if (kbd_dev->mods & KM_CAPS_LOCK) { 245 leds |= USB_HID_LED_CAPS_LOCK; 246 } 247 248 if (kbd_dev->mods & KM_SCROLL_LOCK) { 249 leds |= USB_HID_LED_SCROLL_LOCK; 250 } 251 252 // TODO: COMPOSE and KANA 253 254 usb_log_debug("Creating output report.\n"); 255 usb_log_debug("Leds: 0x%x\n", leds); 256 if ((rc = usb_hid_boot_keyboard_output_report( 257 leds, buffer, BUFFER_OUT_SIZE)) != EOK) { 258 usb_log_warning("Error composing output report to the keyboard:" 259 "%s.\n", str_error(rc)); 260 return; 261 } 262 263 usb_log_debug("Output report buffer: "); 264 for (i = 0; i < BUFFER_OUT_SIZE; ++i) { 265 usb_log_debug("0x%x ", buffer[i]); 266 } 267 usb_log_debug("\n"); 268 269 uint16_t value = 0; 270 value |= (USB_HID_REPORT_TYPE_OUTPUT << 8); 271 272 usbkbd_req_set_report(kbd_dev, kbd_dev->iface, value, buffer, 273 BUFFER_OUT_SIZE); 274 } 275 276 static void kbd_push_ev(int type, unsigned int key, usb_hid_dev_kbd_t *kbd_dev) 161 static void kbd_push_ev(int type, unsigned int key) 277 162 { 278 163 console_event_t ev; … … 292 177 if (mod_mask != 0) { 293 178 if (type == KEY_PRESS) 294 kbd_dev->mods = kbd_dev->mods | mod_mask;179 mods = mods | mod_mask; 295 180 else 296 kbd_dev->mods = kbd_dev->mods & ~mod_mask;181 mods = mods & ~mod_mask; 297 182 } 298 183 299 184 switch (key) { 300 case KC_CAPS_LOCK: mod_mask = KM_CAPS_LOCK; usb_log_debug2("\n\nPushing CAPS LOCK! (mask: %u)\n\n", mod_mask);break;301 case KC_NUM_LOCK: mod_mask = KM_NUM_LOCK; usb_log_debug2("\n\nPushing NUM LOCK! (mask: %u)\n\n", mod_mask);break;302 case KC_SCROLL_LOCK: mod_mask = KM_SCROLL_LOCK; usb_log_debug2("\n\nPushing SCROLL LOCK! (mask: %u)\n\n", mod_mask);break;185 case KC_CAPS_LOCK: mod_mask = KM_CAPS_LOCK; break; 186 case KC_NUM_LOCK: mod_mask = KM_NUM_LOCK; break; 187 case KC_SCROLL_LOCK: mod_mask = KM_SCROLL_LOCK; break; 303 188 default: mod_mask = 0; break; 304 189 } 305 190 306 191 if (mod_mask != 0) { 307 usb_log_debug2("\n\nChanging mods and lock keys\n");308 usb_log_debug2("\nmods before: 0x%x\n", kbd_dev->mods);309 usb_log_debug2("\nLock keys before:0x%x\n\n", kbd_dev->lock_keys);310 311 192 if (type == KEY_PRESS) { 312 usb_log_debug2("\nKey pressed.\n");313 193 /* 314 194 * Only change lock state on transition from released … … 316 196 * up the lock state. 317 197 */ 318 kbd_dev->mods = 319 kbd_dev->mods ^ (mod_mask & ~kbd_dev->lock_keys); 320 kbd_dev->lock_keys = kbd_dev->lock_keys | mod_mask; 198 mods = mods ^ (mod_mask & ~lock_keys); 199 lock_keys = lock_keys | mod_mask; 321 200 322 201 /* Update keyboard lock indicator lights. */ 323 usbkbd_set_led(kbd_dev); 202 // TODO 203 //kbd_ctl_set_ind(mods); 324 204 } else { 325 usb_log_debug2("\nKey released.\n"); 326 kbd_dev->lock_keys = kbd_dev->lock_keys & ~mod_mask; 327 } 328 } 329 330 usb_log_debug2("\n\nmods after: 0x%x\n", kbd_dev->mods); 331 usb_log_debug2("\nLock keys after: 0x%x\n\n", kbd_dev->lock_keys); 332 333 if (type == KEY_PRESS && (kbd_dev->mods & KM_LCTRL) && key == KC_F1) { 205 lock_keys = lock_keys & ~mod_mask; 206 } 207 } 208 /* 209 printf("type: %d\n", type); 210 printf("mods: 0x%x\n", mods); 211 printf("keycode: %u\n", key); 212 */ 213 214 if (type == KEY_PRESS && (mods & KM_LCTRL) && 215 key == KC_F1) { 334 216 active_layout = 0; 335 217 layout[active_layout]->reset(); … … 337 219 } 338 220 339 if (type == KEY_PRESS && (kbd_dev->mods & KM_LCTRL) && key == KC_F2) { 221 if (type == KEY_PRESS && (mods & KM_LCTRL) && 222 key == KC_F2) { 340 223 active_layout = 1; 341 224 layout[active_layout]->reset(); … … 343 226 } 344 227 345 if (type == KEY_PRESS && (kbd_dev->mods & KM_LCTRL) && key == KC_F3) { 228 if (type == KEY_PRESS && (mods & KM_LCTRL) && 229 key == KC_F3) { 346 230 active_layout = 2; 347 231 layout[active_layout]->reset(); … … 351 235 ev.type = type; 352 236 ev.key = key; 353 ev.mods = kbd_dev->mods; 354 355 if (ev.mods & KM_NUM_LOCK) { 356 usb_log_debug("\n\nNum Lock turned on.\n\n"); 357 } 237 ev.mods = mods; 358 238 359 239 ev.c = layout[active_layout]->parse_ev(&ev); 360 240 361 usb_log_debug2("Sending key %d to the console\n", ev.key);241 printf("Sending key %d to the console\n", ev.key); 362 242 assert(console_callback_phone != -1); 363 async_msg_4(console_callback_phone, KBD_EVENT, ev.type, ev.key, 364 ev.mods, ev.c); 243 async_msg_4(console_callback_phone, KBD_EVENT, ev.type, ev.key, ev.mods, ev.c); 365 244 } 366 245 /* … … 370 249 /* 371 250 * TODO: 372 * 1) key press / key release - how does the keyboard notify about 373 * release? 251 * 1) key press / key release - how does the keyboard notify about release? 374 252 * 2) layouts (use the already defined), not important now 375 253 * 3) 376 254 */ 377 255 378 static const keycode_t usb_hid_modifiers_keycodes[USB_HID_MOD_COUNT] = {379 KC_LCTRL, /* USB_HID_MOD_LCTRL */380 KC_LSHIFT, /* USB_HID_MOD_LSHIFT */381 KC_LALT, /* USB_HID_MOD_LALT */382 0, /* USB_HID_MOD_LGUI */383 KC_RCTRL, /* USB_HID_MOD_RCTRL */384 KC_RSHIFT, /* USB_HID_MOD_RSHIFT */385 KC_RALT, /* USB_HID_MOD_RALT */386 0, /* USB_HID_MOD_RGUI */387 };388 389 static void usbkbd_check_modifier_changes(usb_hid_dev_kbd_t *kbd_dev,390 uint8_t modifiers)391 {392 /*393 * TODO: why the USB keyboard has NUM_, SCROLL_ and CAPS_LOCK394 * both as modifiers and as keys with their own scancodes???395 *396 * modifiers should be sent as normal keys to usbkbd_parse_scancode()!!397 * so maybe it would be better if I received it from report parser in398 * that way399 */400 401 int i;402 for (i = 0; i < USB_HID_MOD_COUNT; ++i) {403 if ((modifiers & usb_hid_modifiers_consts[i]) &&404 !(kbd_dev->modifiers & usb_hid_modifiers_consts[i])) {405 // modifier pressed406 if (usb_hid_modifiers_keycodes[i] != 0) {407 kbd_push_ev(KEY_PRESS,408 usb_hid_modifiers_keycodes[i], kbd_dev);409 }410 } else if (!(modifiers & usb_hid_modifiers_consts[i]) &&411 (kbd_dev->modifiers & usb_hid_modifiers_consts[i])) {412 // modifier released413 if (usb_hid_modifiers_keycodes[i] != 0) {414 kbd_push_ev(KEY_RELEASE,415 usb_hid_modifiers_keycodes[i], kbd_dev);416 }417 } // no change418 }419 420 kbd_dev->modifiers = modifiers;421 }422 423 static void usbkbd_check_key_changes(usb_hid_dev_kbd_t *kbd_dev,424 const uint8_t *key_codes)425 {426 // TODO: phantom state!!427 428 unsigned int key;429 unsigned int i, j;430 431 // TODO: quite dummy right now, think of better implementation432 433 // key releases434 for (j = 0; j < kbd_dev->keycode_count; ++j) {435 // try to find the old key in the new key list436 i = 0;437 while (i < kbd_dev->keycode_count438 && key_codes[i] != kbd_dev->keycodes[j]) {439 ++i;440 }441 442 if (i == kbd_dev->keycode_count) {443 // not found, i.e. the key was released444 key = usbkbd_parse_scancode(kbd_dev->keycodes[j]);445 kbd_push_ev(KEY_RELEASE, key, kbd_dev);446 usb_log_debug2("\nKey released: %d\n", key);447 } else {448 // found, nothing happens449 }450 }451 452 // key presses453 for (i = 0; i < kbd_dev->keycode_count; ++i) {454 // try to find the new key in the old key list455 j = 0;456 while (j < kbd_dev->keycode_count457 && kbd_dev->keycodes[j] != key_codes[i]) {458 ++j;459 }460 461 if (j == kbd_dev->keycode_count) {462 // not found, i.e. new key pressed463 key = usbkbd_parse_scancode(key_codes[i]);464 usb_log_debug2("\nKey pressed: %d (keycode: %d)\n", key,465 key_codes[i]);466 kbd_push_ev(KEY_PRESS, key, kbd_dev);467 } else {468 // found, nothing happens469 }470 }471 472 memcpy(kbd_dev->keycodes, key_codes, kbd_dev->keycode_count);473 474 usb_log_debug2("\nNew stored keycodes: ");475 for (i = 0; i < kbd_dev->keycode_count; ++i) {476 usb_log_debug2("%d ", kbd_dev->keycodes[i]);477 }478 }479 480 256 /* 481 257 * Callbacks for parser … … 484 260 uint8_t modifiers, void *arg) 485 261 { 486 if (arg == NULL) { 487 usb_log_warning("Missing argument in callback " 488 "usbkbd_process_keycodes().\n"); 489 return; 490 } 491 492 usb_log_debug2("Got keys from parser: "); 262 printf("Got keys: "); 493 263 unsigned i; 494 264 for (i = 0; i < count; ++i) { 495 usb_log_debug2("%d ", key_codes[i]); 496 } 497 usb_log_debug2("\n"); 498 499 usb_hid_dev_kbd_t *kbd_dev = (usb_hid_dev_kbd_t *)arg; 500 501 if (count != kbd_dev->keycode_count) { 502 usb_log_warning("Number of received keycodes (%d) differs from" 503 " expected number (%d).\n", count, kbd_dev->keycode_count); 504 return; 505 } 506 507 usbkbd_check_modifier_changes(kbd_dev, modifiers); 508 usbkbd_check_key_changes(kbd_dev, key_codes); 265 printf("%d ", key_codes[i]); 266 } 267 printf("\n"); 268 269 for (i = 0; i < count; ++i) { 270 // TODO: Key press / release 271 272 // TODO: NOT WORKING 273 unsigned int key = usbkbd_parse_scancode(key_codes[i]); 274 275 if (key == 0) { 276 continue; 277 } 278 kbd_push_ev(KEY_PRESS, key); 279 } 280 printf("\n"); 509 281 } 510 282 … … 512 284 * Kbd functions 513 285 */ 514 //static int usbkbd_get_report_descriptor(usb_hid_dev_kbd_t *kbd_dev) 515 //{ 516 // // iterate over all configurations and interfaces 517 // // TODO: more configurations!! 518 // unsigned i; 519 // for (i = 0; i < kbd_dev->conf->config_descriptor.interface_count; ++i) { 520 // // TODO: endianness 521 // uint16_t length = kbd_dev->conf->interfaces[i].hid_desc. 522 // report_desc_info.length; 523 // size_t actual_size = 0; 524 525 // // allocate space for the report descriptor 526 // kbd_dev->conf->interfaces[i].report_desc = 527 // (uint8_t *)malloc(length); 286 static int usbkbd_get_report_descriptor(usb_hid_dev_kbd_t *kbd_dev) 287 { 288 // iterate over all configurations and interfaces 289 // TODO: more configurations!! 290 unsigned i; 291 for (i = 0; i < kbd_dev->conf->config_descriptor.interface_count; ++i) { 292 // TODO: endianness 293 uint16_t length = 294 kbd_dev->conf->interfaces[i].hid_desc.report_desc_info.length; 295 size_t actual_size = 0; 296 297 // allocate space for the report descriptor 298 kbd_dev->conf->interfaces[i].report_desc = (uint8_t *)malloc(length); 528 299 529 // // get the descriptor from the device 530 // int rc = usb_request_get_descriptor(&kbd_dev->ctrl_pipe, 531 // USB_REQUEST_TYPE_CLASS, USB_DESCTYPE_HID_REPORT, 532 // i, 0, 533 // kbd_dev->conf->interfaces[i].report_desc, length, 534 // &actual_size); 535 536 // if (rc != EOK) { 537 // return rc; 538 // } 539 540 // assert(actual_size == length); 541 542 // //dump_hid_class_descriptor(0, USB_DESCTYPE_HID_REPORT, 543 // // kbd_dev->conf->interfaces[i].report_desc, length); 544 // } 545 546 // return EOK; 547 //} 548 549 static int usbkbd_get_report_descriptor(usb_hid_dev_kbd_t *kbd_dev, 550 uint8_t *config_desc, size_t config_desc_size, uint8_t *iface_desc) 551 { 552 assert(kbd_dev != NULL); 553 assert(config_desc != NULL); 554 assert(config_desc_size != 0); 555 assert(iface_desc != NULL); 556 557 usb_dp_parser_t parser = { 558 .nesting = usb_dp_standard_descriptor_nesting 559 }; 560 561 usb_dp_parser_data_t parser_data = { 562 .data = config_desc, 563 .size = config_desc_size, 564 .arg = NULL 565 }; 566 567 /* 568 * First nested descriptor of interface descriptor. 569 */ 570 uint8_t *d = 571 usb_dp_get_nested_descriptor(&parser, &parser_data, iface_desc); 572 573 /* 574 * Search through siblings until the HID descriptor is found. 575 */ 576 while (d != NULL && *(d + 1) != USB_DESCTYPE_HID) { 577 d = usb_dp_get_sibling_descriptor(&parser, &parser_data, 578 iface_desc, d); 579 } 580 581 if (d == NULL) { 582 usb_log_fatal("No HID descriptor found!\n"); 583 return ENOENT; 584 } 585 586 if (*d != sizeof(usb_standard_hid_descriptor_t)) { 587 usb_log_fatal("HID descriptor hass wrong size (%u, expected %u" 588 ")\n", *d, sizeof(usb_standard_hid_descriptor_t)); 589 return EINVAL; 590 } 591 592 usb_standard_hid_descriptor_t *hid_desc = 593 (usb_standard_hid_descriptor_t *)d; 594 595 uint16_t length = hid_desc->report_desc_info.length; 596 size_t actual_size = 0; 597 598 /* 599 * Allocate space for the report descriptor. 600 */ 601 kbd_dev->report_desc = (uint8_t *)malloc(length); 602 if (kbd_dev->report_desc == NULL) { 603 usb_log_fatal("Failed to allocate space for Report descriptor." 604 "\n"); 605 return ENOMEM; 606 } 607 608 usb_log_debug("Getting Report descriptor, expected size: %u\n", length); 609 610 /* 611 * Get the descriptor from the device. 612 */ 613 int rc = usb_request_get_descriptor(&kbd_dev->ctrl_pipe, 614 USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_INTERFACE, 615 USB_DESCTYPE_HID_REPORT, 0, 616 kbd_dev->iface, kbd_dev->report_desc, length, &actual_size); 617 618 if (rc != EOK) { 619 return rc; 620 } 621 622 if (actual_size != length) { 623 free(kbd_dev->report_desc); 624 kbd_dev->report_desc = NULL; 625 usb_log_fatal("Report descriptor has wrong size (%u, expected " 626 "%u)\n", actual_size, length); 627 return EINVAL; 628 } 629 630 usb_log_debug("Done.\n"); 631 300 // get the descriptor from the device 301 int rc = usb_request_get_descriptor(&kbd_dev->ctrl_pipe, 302 USB_REQUEST_TYPE_CLASS, USB_DESCTYPE_HID_REPORT, 303 i, 0, 304 kbd_dev->conf->interfaces[i].report_desc, length, 305 &actual_size); 306 307 if (rc != EOK) { 308 return rc; 309 } 310 311 assert(actual_size == length); 312 313 //dump_hid_class_descriptor(0, USB_DESCTYPE_HID_REPORT, 314 // kbd_dev->conf->interfaces[i].report_desc, length); 315 } 316 632 317 return EOK; 633 318 } 634 635 319 static int usbkbd_process_descriptors(usb_hid_dev_kbd_t *kbd_dev) 636 320 { … … 680 364 descriptors, config_desc.total_length, 681 365 &kbd_dev->wire); 682 683 366 if (rc != EOK) { 684 367 usb_log_error("Failed to initialize poll pipe: %s.\n", 685 368 str_error(rc)); 686 free(descriptors);687 369 return rc; 688 370 } 689 690 371 if (!endpoint_mapping[0].present) { 691 372 usb_log_warning("Not accepting device, " \ 692 373 "not boot-protocol keyboard.\n"); 374 return EREFUSED; 375 } 376 377 378 379 380 kbd_dev->conf = (usb_hid_configuration_t *)calloc(1, 381 sizeof(usb_hid_configuration_t)); 382 if (kbd_dev->conf == NULL) { 693 383 free(descriptors); 694 return EREFUSED; 695 } 696 697 usb_log_debug("Accepted device. Saving interface, and getting Report" 698 " descriptor.\n"); 699 700 /* 701 * Save assigned interface number. 702 */ 703 if (endpoint_mapping[0].interface_no < 0) { 704 usb_log_error("Bad interface number.\n"); 705 free(descriptors); 706 return EINVAL; 707 } 708 709 kbd_dev->iface = endpoint_mapping[0].interface_no; 710 711 assert(endpoint_mapping[0].interface != NULL); 712 713 rc = usbkbd_get_report_descriptor(kbd_dev, descriptors, transferred, 714 (uint8_t *)endpoint_mapping[0].interface); 715 384 return ENOMEM; 385 } 386 387 /*rc = usbkbd_parse_descriptors(descriptors, transferred, kbd_dev->conf); 716 388 free(descriptors); 717 718 if (rc != EOK) { 719 usb_log_warning("Problem with parsing REPORT descriptor.\n"); 389 if (rc != EOK) { 390 printf("Problem with parsing standard descriptors.\n"); 720 391 return rc; 721 392 } 722 723 usb_log_debug("Done parsing descriptors.\n"); 724 393 394 // get and report descriptors*/ 395 rc = usbkbd_get_report_descriptor(kbd_dev); 396 if (rc != EOK) { 397 printf("Problem with parsing HID REPORT descriptor.\n"); 398 return rc; 399 } 400 401 //usbkbd_print_config(kbd_dev->conf); 402 403 /* 404 * TODO: 405 * 1) select one configuration (lets say the first) 406 * 2) how many interfaces?? how to select one?? 407 * ("The default setting for an interface is always alternate setting zero.") 408 * 3) find endpoint which is IN and INTERRUPT (parse), save its number 409 * as the endpoint for polling 410 */ 411 725 412 return EOK; 726 413 } 727 414 728 static usb_hid_dev_kbd_t *usbkbd_init_device(d df_dev_t *dev)415 static usb_hid_dev_kbd_t *usbkbd_init_device(device_t *dev) 729 416 { 730 417 int rc; … … 734 421 735 422 if (kbd_dev == NULL) { 736 usb_log_fatal("No memory!\n");423 fprintf(stderr, NAME ": No memory!\n"); 737 424 return NULL; 738 425 } … … 762 449 763 450 /* 764 * Get descriptors, parse descriptors and save endpoints. 765 */ 451 * will need all descriptors: 452 * 1) choose one configuration from configuration descriptors 453 * (set it to the device) 454 * 2) set endpoints from endpoint descriptors 455 */ 456 457 // TODO: get descriptors, parse descriptors and save endpoints 766 458 usb_endpoint_pipe_start_session(&kbd_dev->ctrl_pipe); 767 459 //usb_request_set_configuration(&kbd_dev->ctrl_pipe, 1); 768 460 rc = usbkbd_process_descriptors(kbd_dev); 769 770 461 usb_endpoint_pipe_end_session(&kbd_dev->ctrl_pipe); 771 462 if (rc != EOK) { 772 463 goto error_leave; 773 464 } 774 775 // save the size of the report (boot protocol report by default) 776 kbd_dev->keycode_count = BOOTP_REPORT_SIZE; 777 kbd_dev->keycodes = (uint8_t *)calloc( 778 kbd_dev->keycode_count, sizeof(uint8_t)); 779 780 if (kbd_dev->keycodes == NULL) { 781 usb_log_fatal("No memory!\n"); 782 goto error_leave; 783 } 784 785 kbd_dev->modifiers = 0; 786 kbd_dev->mods = DEFAULT_ACTIVE_MODS; 787 kbd_dev->lock_keys = 0; 788 789 // set boot protocol 790 usbkbd_req_set_protocol(kbd_dev, USB_HID_PROTOCOL_BOOT); 791 792 // set LEDs according to internal setup (NUM LOCK enabled) 793 usbkbd_set_led(kbd_dev); 794 465 795 466 return kbd_dev; 796 467 … … 805 476 usb_hid_report_in_callbacks_t *callbacks = 806 477 (usb_hid_report_in_callbacks_t *)malloc( 807 478 sizeof(usb_hid_report_in_callbacks_t)); 808 479 callbacks->keyboard = usbkbd_process_keycodes; 809 480 810 481 //usb_hid_parse_report(kbd_dev->parser, buffer, actual_size, callbacks, 811 482 // NULL); 812 /*usb_log_debug2("Calling usb_hid_boot_keyboard_input_report() with size"813 " %zu\n", actual_size);*/483 printf("Calling usb_hid_boot_keyboard_input_report() with size %zu\n", 484 actual_size); 814 485 //dump_buffer("bufffer: ", buffer, actual_size); 815 int rc = usb_hid_boot_keyboard_input_report(buffer, actual_size, 816 callbacks, kbd_dev); 817 818 if (rc != EOK) { 819 usb_log_warning("Error in usb_hid_boot_keyboard_input_report():" 820 "%s\n", str_error(rc)); 486 int rc = usb_hid_boot_keyboard_input_report(buffer, actual_size, callbacks, 487 NULL); 488 if (rc != EOK) { 489 printf("Error in usb_hid_boot_keyboard_input_report(): %d\n", rc); 821 490 } 822 491 } … … 828 497 size_t actual_size; 829 498 830 usb_log_info("Polling keyboard...\n");499 printf("Polling keyboard...\n"); 831 500 832 501 while (true) { … … 835 504 sess_rc = usb_endpoint_pipe_start_session(&kbd_dev->poll_pipe); 836 505 if (sess_rc != EOK) { 837 usb_log_warning("Failed to start a session: %s.\n",506 printf("Failed to start a session: %s.\n", 838 507 str_error(sess_rc)); 839 508 continue; … … 845 514 846 515 if (rc != EOK) { 847 usb_log_warning("Error polling the keyboard: %s.\n",516 printf("Error polling the keyboard: %s.\n", 848 517 str_error(rc)); 849 518 continue; … … 851 520 852 521 if (sess_rc != EOK) { 853 usb_log_warning("Error closing session: %s.\n",522 printf("Error closing session: %s.\n", 854 523 str_error(sess_rc)); 855 524 continue; … … 861 530 */ 862 531 if (actual_size == 0) { 863 usb_log_debug("Keyboard returned NAK\n");532 printf("Keyboard returned NAK\n"); 864 533 continue; 865 534 } … … 868 537 * TODO: Process pressed keys. 869 538 */ 870 usb_log_debug("Calling usbkbd_process_interrupt_in()\n");539 printf("Calling usbkbd_process_interrupt_in()\n"); 871 540 usbkbd_process_interrupt_in(kbd_dev, buffer, actual_size); 872 541 } … … 878 547 static int usbkbd_fibril_device(void *arg) 879 548 { 549 printf("!!! USB device fibril\n"); 550 880 551 if (arg == NULL) { 881 usb_log_error("No device!\n");552 printf("No device!\n"); 882 553 return -1; 883 554 } 884 885 usb_hid_dev_kbd_t *kbd_dev = (usb_hid_dev_kbd_t *)arg; 886 887 usbkbd_poll_keyboard(kbd_dev); 888 889 return EOK; 890 } 891 892 static int usbkbd_add_device(ddf_dev_t *dev) 893 { 894 /* 895 * Create default function. 896 */ 897 // FIXME - check for errors 898 ddf_fun_t *kbd_fun = ddf_fun_create(dev, fun_exposed, "keyboard"); 899 assert(kbd_fun != NULL); 900 kbd_fun->ops = &keyboard_ops; 901 902 int rc = ddf_fun_bind(kbd_fun); 903 assert(rc == EOK); 904 rc = ddf_fun_add_to_class(kbd_fun, "keyboard"); 905 assert(rc == EOK); 906 907 /* 908 * Initialize device (get and process descriptors, get address, etc.) 909 */ 555 556 device_t *dev = (device_t *)arg; 557 558 // initialize device (get and process descriptors, get address, etc.) 910 559 usb_hid_dev_kbd_t *kbd_dev = usbkbd_init_device(dev); 911 560 if (kbd_dev == NULL) { 912 usb_log_error("Error while initializing device.\n");561 printf("Error while initializing device.\n"); 913 562 return -1; 914 563 } 915 564 916 usb_log_info("Device initialized.\n"); 917 565 usbkbd_poll_keyboard(kbd_dev); 566 567 return EOK; 568 } 569 570 static int usbkbd_add_device(device_t *dev) 571 { 572 /* For now, fail immediately. */ 573 //return ENOTSUP; 574 575 /* 576 * When everything is okay, connect to "our" HC. 577 * 578 * Not supported yet, skip.. 579 */ 580 // int phone = usb_drv_hc_connect_auto(dev, 0); 581 // if (phone < 0) { 582 // /* 583 // * Connecting to HC failed, roll-back and announce 584 // * failure. 585 // */ 586 // return phone; 587 // } 588 589 // dev->parent_phone = phone; 590 918 591 /* 919 592 * Create new fibril for handling this keyboard 920 593 */ 921 fid_t fid = fibril_create(usbkbd_fibril_device, kbd_dev);594 fid_t fid = fibril_create(usbkbd_fibril_device, dev); 922 595 if (fid == 0) { 923 usb_log_error("Failed to start fibril for HID device\n");596 printf("%s: failed to start fibril for HID device\n", NAME); 924 597 return ENOMEM; 925 598 } 926 599 fibril_add_ready(fid); 927 600 928 //dev->ops = &keyboard_ops; 929 (void)keyboard_ops; 930 931 //add_device_to_class(dev, "keyboard"); 601 dev->ops = &keyboard_ops; 602 603 add_device_to_class(dev, "keyboard"); 932 604 933 605 /* … … 948 620 int main(int argc, char *argv[]) 949 621 { 950 usb_log_enable(USB_LOG_LEVEL_INFO, NAME);951 return d df_driver_main(&kbd_driver);622 usb_log_enable(USB_LOG_LEVEL_INFO, "usbhid"); 623 return driver_main(&kbd_driver); 952 624 } 953 625
Note:
See TracChangeset
for help on using the changeset viewer.
