Changes in / [bbc7d83e:ec293a8] in mainline
- Location:
- uspace
- Files:
-
- 5 deleted
- 11 edited
Legend:
- Unmodified
- Added
- Removed
-
uspace/drv/usbhid/descdump.h
rbbc7d83e rec293a8 37 37 #define USBHID_DESCDUMP_H_ 38 38 39 #include "hid.h"39 #include <usb/classes/hid.h> 40 40 41 41 void dump_standard_configuration_descriptor( -
uspace/drv/usbhid/descparser.h
rbbc7d83e rec293a8 37 37 #define USBHID_DESCPARSER_H_ 38 38 39 #include "hid.h"39 #include <usb/classes/hid.h> 40 40 41 41 int usbkbd_parse_descriptors(const uint8_t *data, size_t size, -
uspace/drv/usbhid/main.c
rbbc7d83e rec293a8 43 43 #include <io/console.h> 44 44 #include <errno.h> 45 #include <str_error.h>46 45 #include <fibril.h> 47 46 #include <usb/classes/hid.h> … … 50 49 #include <usb/descriptor.h> 51 50 #include <io/console.h> 52 #include "hid.h"53 51 #include "descparser.h" 54 52 #include "descdump.h" … … 381 379 if (rc < 0) { 382 380 printf("Problem setting phone to HC.\n"); 383 goto error_leave; 381 free(kbd_dev); 382 return NULL; 384 383 } 385 384 … … 387 386 if (rc < 0) { 388 387 printf("Problem getting address of the device.\n"); 389 goto error_leave; 388 free(kbd_dev); 389 return NULL; 390 390 } 391 391 … … 397 397 // } 398 398 399 // default endpoint 400 kbd_dev->poll_endpoint = GUESSED_POLL_ENDPOINT; 401 399 402 /* 400 403 * will need all descriptors: … … 407 410 usbkbd_process_descriptors(kbd_dev); 408 411 409 410 411 /*412 * Initialize the backing connection to the host controller.413 */414 rc = usb_device_connection_initialize(&kbd_dev->wire, dev);415 if (rc != EOK) {416 printf("Problem initializing connection to device: %s.\n",417 str_error(rc));418 goto error_leave;419 }420 421 /*422 * Initialize device pipes.423 */424 rc = usb_endpoint_pipe_initialize(&kbd_dev->poll_pipe, &kbd_dev->wire,425 GUESSED_POLL_ENDPOINT, USB_TRANSFER_INTERRUPT, USB_DIRECTION_IN);426 if (rc != EOK) {427 printf("Failed to initialize interrupt in pipe: %s.\n",428 str_error(rc));429 goto error_leave;430 }431 432 433 412 return kbd_dev; 434 435 error_leave:436 free(kbd_dev);437 return NULL;438 413 } 439 414 … … 460 435 static void usbkbd_poll_keyboard(usb_hid_dev_kbd_t *kbd_dev) 461 436 { 462 int rc, sess_rc; 437 int rc; 438 usb_handle_t handle; 463 439 uint8_t buffer[BUFFER_SIZE]; 464 440 size_t actual_size; 441 //usb_endpoint_t poll_endpoint = 1; 442 443 // usb_address_t my_address = usb_drv_get_my_address(dev->parent_phone, 444 // dev); 445 // if (my_address < 0) { 446 // return; 447 // } 448 449 usb_target_t poll_target = { 450 .address = kbd_dev->address, 451 .endpoint = kbd_dev->poll_endpoint 452 }; 465 453 466 454 printf("Polling keyboard...\n"); … … 468 456 while (true) { 469 457 async_usleep(1000 * 1000 * 2); 470 471 sess_rc = usb_endpoint_pipe_start_session(&kbd_dev->poll_pipe);472 if (sess_rc != EOK) { 473 printf("Failed to start a session: %s.\n",474 str_error(sess_rc));458 rc = usb_drv_async_interrupt_in(kbd_dev->device->parent_phone, 459 poll_target, buffer, BUFFER_SIZE, &actual_size, &handle); 460 461 if (rc != EOK) { 462 printf("Error in usb_drv_async_interrupt_in(): %d\n", rc); 475 463 continue; 476 464 } 477 465 478 rc = usb_endpoint_pipe_read(&kbd_dev->poll_pipe, buffer, 479 BUFFER_SIZE, &actual_size); 480 sess_rc = usb_endpoint_pipe_end_session(&kbd_dev->poll_pipe); 481 466 rc = usb_drv_async_wait_for(handle); 482 467 if (rc != EOK) { 483 printf("Error polling the keyboard: %s.\n", 484 str_error(rc)); 485 continue; 486 } 487 488 if (sess_rc != EOK) { 489 printf("Error closing session: %s.\n", 490 str_error(sess_rc)); 468 printf("Error in usb_drv_async_wait_for(): %d\n", rc); 491 469 continue; 492 470 } -
uspace/drv/vhc/connhost.c
rbbc7d83e rec293a8 42 42 #include "hc.h" 43 43 44 45 44 typedef struct { 46 45 usb_direction_t direction; … … 48 47 usbhc_iface_transfer_in_callback_t in_callback; 49 48 device_t *dev; 50 size_t reported_size;51 49 void *arg; 52 50 } transfer_info_t; 53 51 54 typedef struct {55 usb_direction_t direction;56 usb_target_t target;57 usbhc_iface_transfer_out_callback_t out_callback;58 usbhc_iface_transfer_in_callback_t in_callback;59 device_t *dev;60 void *arg;61 void *data_buffer;62 size_t data_buffer_size;63 } control_transfer_info_t;64 65 52 static void universal_callback(void *buffer, size_t size, 66 53 usb_transaction_outcome_t outcome, void *arg) 67 54 { 68 55 transfer_info_t *transfer = (transfer_info_t *) arg; 69 70 if (transfer->reported_size != (size_t) -1) {71 size = transfer->reported_size;72 }73 56 74 57 switch (transfer->direction) { … … 101 84 transfer->arg = arg; 102 85 transfer->dev = dev; 103 transfer->reported_size = (size_t) -1;104 105 return transfer;106 }107 108 static void control_abort_prematurely(control_transfer_info_t *transfer,109 size_t size, usb_transaction_outcome_t outcome)110 {111 switch (transfer->direction) {112 case USB_DIRECTION_IN:113 transfer->in_callback(transfer->dev,114 outcome, size,115 transfer->arg);116 break;117 case USB_DIRECTION_OUT:118 transfer->out_callback(transfer->dev,119 outcome,120 transfer->arg);121 break;122 default:123 assert(false && "unreachable");124 break;125 }126 }127 128 static void control_callback_two(void *buffer, size_t size,129 usb_transaction_outcome_t outcome, void *arg)130 {131 control_transfer_info_t *ctrl_transfer = (control_transfer_info_t *) arg;132 133 if (outcome != USB_OUTCOME_OK) {134 control_abort_prematurely(ctrl_transfer, outcome, size);135 free(ctrl_transfer);136 return;137 }138 139 transfer_info_t *transfer = create_transfer_info(ctrl_transfer->dev,140 ctrl_transfer->direction, ctrl_transfer->arg);141 transfer->out_callback = ctrl_transfer->out_callback;142 transfer->in_callback = ctrl_transfer->in_callback;143 transfer->reported_size = size;144 145 switch (ctrl_transfer->direction) {146 case USB_DIRECTION_IN:147 hc_add_transaction_to_device(false, ctrl_transfer->target,148 USB_TRANSFER_CONTROL,149 NULL, 0,150 universal_callback, transfer);151 break;152 case USB_DIRECTION_OUT:153 hc_add_transaction_from_device(ctrl_transfer->target,154 USB_TRANSFER_CONTROL,155 NULL, 0,156 universal_callback, transfer);157 break;158 default:159 assert(false && "unreachable");160 break;161 }162 163 free(ctrl_transfer);164 }165 166 static void control_callback_one(void *buffer, size_t size,167 usb_transaction_outcome_t outcome, void *arg)168 {169 control_transfer_info_t *transfer = (control_transfer_info_t *) arg;170 171 if (outcome != USB_OUTCOME_OK) {172 control_abort_prematurely(transfer, outcome, size);173 free(transfer);174 return;175 }176 177 switch (transfer->direction) {178 case USB_DIRECTION_IN:179 hc_add_transaction_from_device(transfer->target,180 USB_TRANSFER_CONTROL,181 transfer->data_buffer, transfer->data_buffer_size,182 control_callback_two, transfer);183 break;184 case USB_DIRECTION_OUT:185 hc_add_transaction_to_device(false, transfer->target,186 USB_TRANSFER_CONTROL,187 transfer->data_buffer, transfer->data_buffer_size,188 control_callback_two, transfer);189 break;190 default:191 assert(false && "unreachable");192 break;193 }194 }195 196 static control_transfer_info_t *create_control_transfer_info(device_t *dev,197 usb_direction_t direction, usb_target_t target,198 void *data_buffer, size_t data_buffer_size,199 void *arg)200 {201 control_transfer_info_t *transfer202 = malloc(sizeof(control_transfer_info_t));203 204 transfer->direction = direction;205 transfer->target = target;206 transfer->in_callback = NULL;207 transfer->out_callback = NULL;208 transfer->arg = arg;209 transfer->dev = dev;210 transfer->data_buffer = data_buffer;211 transfer->data_buffer_size = data_buffer_size;212 86 213 87 return transfer; … … 319 193 } 320 194 321 static int control_write(device_t *dev, usb_target_t target,322 void *setup_packet, size_t setup_packet_size,323 void *data, size_t data_size,324 usbhc_iface_transfer_out_callback_t callback, void *arg)325 {326 control_transfer_info_t *transfer327 = create_control_transfer_info(dev, USB_DIRECTION_OUT, target,328 data, data_size, arg);329 transfer->out_callback = callback;330 331 hc_add_transaction_to_device(true, target, USB_TRANSFER_CONTROL,332 setup_packet, setup_packet_size,333 control_callback_one, transfer);334 335 return EOK;336 }337 338 195 static int control_read_setup(device_t *dev, usb_target_t target, 339 196 void *data, size_t size, … … 360 217 NULL, 0, 361 218 callback, arg); 362 }363 364 static int control_read(device_t *dev, usb_target_t target,365 void *setup_packet, size_t setup_packet_size,366 void *data, size_t data_size,367 usbhc_iface_transfer_in_callback_t callback, void *arg)368 {369 control_transfer_info_t *transfer370 = create_control_transfer_info(dev, USB_DIRECTION_IN, target,371 data, data_size, arg);372 transfer->in_callback = callback;373 374 hc_add_transaction_to_device(true, target, USB_TRANSFER_CONTROL,375 setup_packet, setup_packet_size,376 control_callback_one, transfer);377 378 return EOK;379 219 } 380 220 … … 450 290 .control_write_status = control_write_status, 451 291 452 .control_write = control_write,453 454 292 .control_read_setup = control_read_setup, 455 293 .control_read_data = control_read_data, 456 .control_read_status = control_read_status, 457 458 .control_read = control_read 294 .control_read_status = control_read_status 459 295 }; 460 296 -
uspace/lib/drv/generic/remote_usbhc.c
rbbc7d83e rec293a8 1 1 /* 2 * Copyright (c) 2010 -2011Vojtech Horky2 * Copyright (c) 2010 Vojtech Horky 3 3 * All rights reserved. 4 4 * … … 52 52 static void remote_usbhc_control_read_data(device_t *, void *, ipc_callid_t, ipc_call_t *); 53 53 static void remote_usbhc_control_read_status(device_t *, void *, ipc_callid_t, ipc_call_t *); 54 static void remote_usbhc_control_write(device_t *, void *, ipc_callid_t, ipc_call_t *);55 static void remote_usbhc_control_read(device_t *, void *, ipc_callid_t, ipc_call_t *);56 54 static void remote_usbhc_reserve_default_address(device_t *, void *, ipc_callid_t, ipc_call_t *); 57 55 static void remote_usbhc_release_default_address(device_t *, void *, ipc_callid_t, ipc_call_t *); … … 83 81 remote_usbhc_control_read_setup, 84 82 remote_usbhc_control_read_data, 85 remote_usbhc_control_read_status, 86 87 remote_usbhc_control_write, 88 remote_usbhc_control_read 83 remote_usbhc_control_read_status 89 84 }; 90 85 … … 100 95 ipc_callid_t caller; 101 96 void *buffer; 102 void *setup_packet;103 97 size_t size; 104 98 } async_transaction_t; … … 303 297 trans->caller = callid; 304 298 trans->buffer = buffer; 305 trans->setup_packet = NULL;306 299 trans->size = len; 307 300 … … 343 336 trans->caller = callid; 344 337 trans->buffer = malloc(len); 345 trans->setup_packet = NULL;346 338 trans->size = len; 347 339 … … 399 391 trans->caller = callid; 400 392 trans->buffer = NULL; 401 trans->setup_packet = NULL;402 393 trans->size = 0; 403 394 … … 505 496 } 506 497 507 void remote_usbhc_control_write(device_t *device, void *iface,508 ipc_callid_t callid, ipc_call_t *call)509 {510 usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;511 assert(usb_iface != NULL);512 513 if (!usb_iface->control_write) {514 ipc_answer_0(callid, ENOTSUP);515 return;516 }517 518 usb_target_t target = {519 .address = DEV_IPC_GET_ARG1(*call),520 .endpoint = DEV_IPC_GET_ARG2(*call)521 };522 523 int rc;524 525 void *setup_packet = NULL;526 void *data_buffer = NULL;527 size_t setup_packet_len = 0;528 size_t data_buffer_len = 0;529 530 rc = async_data_write_accept(&setup_packet, false,531 1, USB_MAX_PAYLOAD_SIZE, 0, &setup_packet_len);532 if (rc != EOK) {533 ipc_answer_0(callid, rc);534 return;535 }536 rc = async_data_write_accept(&data_buffer, false,537 1, USB_MAX_PAYLOAD_SIZE, 0, &data_buffer_len);538 if (rc != EOK) {539 free(setup_packet);540 ipc_answer_0(callid, rc);541 return;542 }543 544 async_transaction_t *trans = malloc(sizeof(async_transaction_t));545 trans->caller = callid;546 trans->setup_packet = setup_packet;547 trans->buffer = data_buffer;548 trans->size = data_buffer_len;549 550 rc = usb_iface->control_write(device, target,551 setup_packet, setup_packet_len,552 data_buffer, data_buffer_len,553 callback_out, trans);554 555 if (rc != EOK) {556 ipc_answer_0(callid, rc);557 free(setup_packet);558 free(data_buffer);559 free(trans);560 }561 }562 563 564 void remote_usbhc_control_read(device_t *device, void *iface,565 ipc_callid_t callid, ipc_call_t *call)566 {567 usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;568 assert(usb_iface != NULL);569 570 if (!usb_iface->control_read) {571 ipc_answer_0(callid, ENOTSUP);572 return;573 }574 575 size_t data_len = DEV_IPC_GET_ARG3(*call);576 usb_target_t target = {577 .address = DEV_IPC_GET_ARG1(*call),578 .endpoint = DEV_IPC_GET_ARG2(*call)579 };580 581 int rc;582 583 void *setup_packet = NULL;584 size_t setup_packet_len = 0;585 586 rc = async_data_write_accept(&setup_packet, false,587 1, USB_MAX_PAYLOAD_SIZE, 0, &setup_packet_len);588 if (rc != EOK) {589 ipc_answer_0(callid, rc);590 return;591 }592 593 async_transaction_t *trans = malloc(sizeof(async_transaction_t));594 trans->caller = callid;595 trans->setup_packet = setup_packet;596 trans->buffer = malloc(data_len);597 trans->size = data_len;598 599 rc = usb_iface->control_read(device, target,600 setup_packet, setup_packet_len,601 trans->buffer, trans->size,602 callback_in, trans);603 604 if (rc != EOK) {605 ipc_answer_0(callid, rc);606 free(setup_packet);607 free(trans->buffer);608 free(trans);609 }610 }611 612 498 613 499 -
uspace/lib/drv/include/usbhc_iface.h
rbbc7d83e rec293a8 201 201 IPC_M_USBHC_CONTROL_READ_STATUS, 202 202 203 /** Issue control WRITE transfer.204 * See explanation at usb_iface_funcs_t (OUT transaction) for205 * call parameters.206 * This call is immediately followed by two IPC data writes207 * from the caller (setup packet and actual data).208 */209 IPC_M_USBHC_CONTROL_WRITE,210 211 /** Issue control WRITE transfer.212 * See explanation at usb_iface_funcs_t (IN transaction) for213 * call parameters.214 * This call is immediately followed by IPC data read from the caller215 * (setup packet).216 * Actual data are retrieved through IPC_M_USBHC_GET_BUFFER.217 */218 IPC_M_USBHC_CONTROL_READ,219 203 220 204 /* IPC_M_USB_ */ … … 265 249 int (*control_read_status)(device_t *, usb_target_t, 266 250 usbhc_iface_transfer_out_callback_t, void *); 267 268 int (*control_write)(device_t *, usb_target_t,269 void *, size_t, void *, size_t,270 usbhc_iface_transfer_out_callback_t, void *);271 272 int (*control_read)(device_t *, usb_target_t,273 void *, size_t, void *, size_t,274 usbhc_iface_transfer_in_callback_t, void *);275 251 } usbhc_iface_t; 276 252 -
uspace/lib/usb/Makefile
rbbc7d83e rec293a8 43 43 src/hidparser.c \ 44 44 src/localdrv.c \ 45 src/pipes.c \46 45 src/recognise.c \ 47 46 src/remotedrv.c \ 48 src/request.c \49 47 src/usb.c \ 50 48 src/usbdrvreq.c \ -
uspace/lib/usb/include/usb/classes/hid.h
rbbc7d83e rec293a8 37 37 38 38 #include <usb/usb.h> 39 #include <driver.h> 39 40 #include <usb/classes/hidparser.h> 40 41 #include <usb/descriptor.h> … … 100 101 } __attribute__ ((packed)) usb_standard_hid_descriptor_t; 101 102 103 /** 104 * 105 */ 106 typedef struct { 107 usb_standard_interface_descriptor_t iface_desc; 108 usb_standard_endpoint_descriptor_t *endpoints; 109 usb_standard_hid_descriptor_t hid_desc; 110 uint8_t *report_desc; 111 //usb_standard_hid_class_descriptor_info_t *class_desc_info; 112 //uint8_t **class_descs; 113 } usb_hid_iface_t; 114 115 /** 116 * 117 */ 118 typedef struct { 119 usb_standard_configuration_descriptor_t config_descriptor; 120 usb_hid_iface_t *interfaces; 121 } usb_hid_configuration_t; 122 123 /** 124 * @brief USB/HID keyboard device type. 125 * 126 * Quite dummy right now. 127 */ 128 typedef struct { 129 device_t *device; 130 usb_hid_configuration_t *conf; 131 usb_address_t address; 132 usb_endpoint_t poll_endpoint; 133 usb_hid_report_parser_t *parser; 134 } usb_hid_dev_kbd_t; 135 136 // TODO: more configurations! 102 137 103 138 #endif -
uspace/lib/usb/include/usb/usb.h
rbbc7d83e rec293a8 52 52 typedef enum { 53 53 USB_DIRECTION_IN, 54 USB_DIRECTION_OUT, 55 USB_DIRECTION_BOTH 54 USB_DIRECTION_OUT 56 55 } usb_direction_t; 57 56 -
uspace/lib/usb/include/usb/usbdrv.h
rbbc7d83e rec293a8 70 70 usb_handle_t *); 71 71 72 int usb_drv_async_control_write(int, usb_target_t,73 void *, size_t, void *, size_t, usb_handle_t *);74 75 72 int usb_drv_psync_control_write_setup(int, usb_target_t, void *, size_t); 76 73 int usb_drv_psync_control_write_data(int, usb_target_t, void *, size_t); … … 80 77 void *, size_t, void *, size_t); 81 78 79 82 80 int usb_drv_async_control_read_setup(int, usb_target_t, 83 81 void *, size_t, usb_handle_t *); … … 86 84 int usb_drv_async_control_read_status(int, usb_target_t, 87 85 usb_handle_t *); 88 89 int usb_drv_async_control_read(int, usb_target_t,90 void *, size_t, void *, size_t, size_t *, usb_handle_t *);91 86 92 87 int usb_drv_psync_control_read_setup(int, usb_target_t, void *, size_t); -
uspace/lib/usb/src/usbdrv.c
rbbc7d83e rec293a8 495 495 } 496 496 497 /** Issue whole control write transfer. */498 int usb_drv_async_control_write(int phone, usb_target_t target,499 void *setup_packet, size_t setup_packet_size,500 void *buffer, size_t buffer_size,501 usb_handle_t *handle)502 {503 // FIXME - check input parameters instead of asserting them504 assert(phone > 0);505 assert(setup_packet != NULL);506 assert(setup_packet_size > 0);507 assert(buffer != NULL);508 assert(buffer_size > 0);509 assert(handle != NULL);510 511 transfer_info_t *transfer512 = (transfer_info_t *) malloc(sizeof(transfer_info_t));513 if (transfer == NULL) {514 return ENOMEM;515 }516 517 transfer->size_transferred = NULL;518 transfer->buffer = NULL;519 transfer->size = 0;520 transfer->phone = phone;521 522 int rc;523 524 transfer->request = async_send_3(phone,525 DEV_IFACE_ID(USBHC_DEV_IFACE),526 IPC_M_USBHC_CONTROL_WRITE,527 target.address, target.endpoint,528 &transfer->reply);529 530 rc = async_data_write_start(phone, setup_packet, setup_packet_size);531 if (rc != EOK) {532 async_wait_for(transfer->request, NULL);533 return rc;534 }535 536 rc = async_data_write_start(phone, buffer, buffer_size);537 if (rc != EOK) {538 async_wait_for(transfer->request, NULL);539 return rc;540 }541 542 *handle = (usb_handle_t) transfer;543 544 return EOK;545 }546 547 497 /** Start control read transfer. */ 548 498 int usb_drv_async_control_read_setup(int phone, usb_target_t target, … … 580 530 } 581 531 582 /** Issue whole control read transfer. */583 int usb_drv_async_control_read(int phone, usb_target_t target,584 void *setup_packet, size_t setup_packet_size,585 void *buffer, size_t buffer_size, size_t *actual_size,586 usb_handle_t *handle)587 {588 // FIXME - check input parameters instead of asserting them589 assert(phone > 0);590 assert(setup_packet != NULL);591 assert(setup_packet_size > 0);592 assert(buffer != NULL);593 assert(buffer_size > 0);594 assert(handle != NULL);595 596 transfer_info_t *transfer597 = (transfer_info_t *) malloc(sizeof(transfer_info_t));598 if (transfer == NULL) {599 return ENOMEM;600 }601 602 transfer->size_transferred = actual_size;603 transfer->buffer = buffer;604 transfer->size = buffer_size;605 transfer->phone = phone;606 607 int rc;608 609 transfer->request = async_send_4(phone,610 DEV_IFACE_ID(USBHC_DEV_IFACE),611 IPC_M_USBHC_CONTROL_READ,612 target.address, target.endpoint,613 buffer_size,614 &transfer->reply);615 616 rc = async_data_write_start(phone, setup_packet, setup_packet_size);617 if (rc != EOK) {618 async_wait_for(transfer->request, NULL);619 return rc;620 }621 622 *handle = (usb_handle_t) transfer;623 624 return EOK;625 }626 627 532 /** 628 533 * @}
Note:
See TracChangeset
for help on using the changeset viewer.