Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/usb/src/usbdrv.c

    rfe4dd14 r3937bda  
    4949        /** Storage for actual number of bytes transferred. */
    5050        size_t *size_transferred;
    51         /** Initial call replay data. */
     51        /** Initial call reply data. */
    5252        ipc_call_t reply;
    5353        /** Initial call identifier. */
    5454        aid_t request;
     55        /** Reply data for data read call. */
     56        ipc_call_t read_reply;
     57        /** Data read call identifier. */
     58        aid_t read_request;
    5559} transfer_info_t;
    5660
    … …  
    8084            IPC_M_USB_GET_HOST_CONTROLLER_HANDLE, &h);
    8185
    82         ipc_hangup(parent_phone);
     86        async_hangup(parent_phone);
    8387
    8488        if (rc != EOK) {
    … …  
    140144
    141145        if (rc != EOK) {
    142                 printf("usb_drv_get_my_address over %d failed: %s\n", phone, str_error(rc));
    143146                return rc;
    144147        }
    … …  
    250253        }
    251254
     255        transfer->read_request = 0;
    252256        transfer->size_transferred = NULL;
    253257        transfer->buffer = NULL;
    … …  
    315319        }
    316320
     321        transfer->read_request = 0;
    317322        transfer->size_transferred = actual_size;
    318323        transfer->buffer = buffer;
    … …  
    327332            &transfer->reply);
    328333
     334        if (buffer != NULL) {
     335                transfer->read_request = async_data_read(phone, buffer, size,
     336                    &transfer->read_reply);
     337        }
     338
    329339        *handle = (usb_handle_t) transfer;
    330340
    … …  
    332342}
    333343
    334 /** Read buffer from HCD.
    335  *
    336  * @param phone Opened phone to HCD.
    337  * @param hash Buffer hash (obtained after completing IN transaction).
    338  * @param buffer Buffer where to store data data.
    339  * @param size Buffer size.
    340  * @param actual_size Storage where actual number of bytes transferred will
    341  *      be stored.
    342  * @return Error status.
    343  */
    344 static int read_buffer_in(int phone, sysarg_t hash,
    345     void *buffer, size_t size, size_t *actual_size)
    346 {
    347         ipc_call_t answer_data;
    348         sysarg_t answer_rc;
    349         aid_t req;
    350         int rc;
    351 
    352         req = async_send_2(phone,
    353             DEV_IFACE_ID(USBHC_DEV_IFACE),
    354             IPC_M_USBHC_GET_BUFFER,
    355             hash,
    356             &answer_data);
    357 
    358         rc = async_data_read_start(phone, buffer, size);
    359         if (rc != EOK) {
    360                 async_wait_for(req, NULL);
    361                 return EINVAL;
    362         }
    363 
    364         async_wait_for(req, &answer_rc);
    365         rc = (int)answer_rc;
    366 
    367         if (rc != EOK) {
    368                 return rc;
    369         }
    370 
    371         *actual_size = IPC_GET_ARG1(answer_data);
    372 
    373         return EOK;
    374 }
    375344
    376345/** Blocks caller until given USB transaction is finished.
    … …  
    395364
    396365        sysarg_t answer_rc;
    397         async_wait_for(transfer->request, &answer_rc);
    398 
    399         if (answer_rc != EOK) {
    400                 rc = (int) answer_rc;
    401                 goto leave;
    402         }
    403366
    404367        /*
    … …  
    406369         */
    407370        if ((transfer->buffer != NULL) && (transfer->size > 0)) {
    408                 /*
    409                  * The buffer hash identifies the data on the server
    410                  * side.
    411                  * We will use it when actually reading-in the data.
    412                  */
    413                 sysarg_t buffer_hash = IPC_GET_ARG1(transfer->reply);
    414                 if (buffer_hash == 0) {
    415                         rc = ENOENT;
     371                async_wait_for(transfer->read_request, &answer_rc);
     372
     373                if (answer_rc != EOK) {
     374                        rc = (int) answer_rc;
    416375                        goto leave;
    417376                }
    418377
    419                 size_t actual_size;
    420                 rc = read_buffer_in(transfer->phone, buffer_hash,
    421                     transfer->buffer, transfer->size, &actual_size);
    422 
    423                 if (rc != EOK) {
    424                         goto leave;
     378                if (transfer->size_transferred != NULL) {
     379                        *(transfer->size_transferred)
     380                            = IPC_GET_ARG2(transfer->read_reply);
    425381                }
    426 
    427                 if (transfer->size_transferred) {
    428                         *(transfer->size_transferred) = actual_size;
    429                 }
     382        }
     383
     384        async_wait_for(transfer->request, &answer_rc);
     385
     386        if (answer_rc != EOK) {
     387                rc = (int) answer_rc;
     388                goto leave;
    430389        }
    431390
    … …  
    499458    void *setup_packet, size_t setup_packet_size,
    500459    void *buffer, size_t buffer_size,
     460    usb_handle_t *handle)
     461{
     462        // FIXME - check input parameters instead of asserting them
     463        assert(phone > 0);
     464        assert(setup_packet != NULL);
     465        assert(setup_packet_size > 0);
     466        assert(((buffer != NULL) && (buffer_size > 0))
     467            || ((buffer == NULL) && (buffer_size == 0)));
     468        assert(handle != NULL);
     469
     470        transfer_info_t *transfer
     471            = (transfer_info_t *) malloc(sizeof(transfer_info_t));
     472        if (transfer == NULL) {
     473                return ENOMEM;
     474        }
     475
     476        transfer->read_request = 0;
     477        transfer->size_transferred = NULL;
     478        transfer->buffer = NULL;
     479        transfer->size = 0;
     480        transfer->phone = phone;
     481
     482        int rc;
     483
     484        transfer->request = async_send_3(phone,
     485            DEV_IFACE_ID(USBHC_DEV_IFACE),
     486            IPC_M_USBHC_CONTROL_WRITE,
     487            target.address, target.endpoint,
     488            &transfer->reply);
     489
     490        rc = async_data_write_start(phone, setup_packet, setup_packet_size);
     491        if (rc != EOK) {
     492                async_wait_for(transfer->request, NULL);
     493                return rc;
     494        }
     495
     496        if (buffer_size > 0) {
     497                rc = async_data_write_start(phone, buffer, buffer_size);
     498                if (rc != EOK) {
     499                        async_wait_for(transfer->request, NULL);
     500                        return rc;
     501                }
     502        }
     503
     504        *handle = (usb_handle_t) transfer;
     505
     506        return EOK;
     507}
     508
     509/** Start control read transfer. */
     510int usb_drv_async_control_read_setup(int phone, usb_target_t target,
     511    void *buffer, size_t size,
     512    usb_handle_t *handle)
     513{
     514        return async_send_buffer(phone,
     515            IPC_M_USBHC_CONTROL_READ_SETUP,
     516            target,
     517            buffer, size,
     518            handle);
     519}
     520
     521/** Read data during control read transfer. */
     522int usb_drv_async_control_read_data(int phone, usb_target_t target,
     523    void *buffer, size_t size, size_t *actual_size,
     524    usb_handle_t *handle)
     525{
     526        return async_recv_buffer(phone,
     527            IPC_M_USBHC_CONTROL_READ_DATA,
     528            target,
     529            buffer, size, actual_size,
     530            handle);
     531}
     532
     533/** Finalize control read transfer. */
     534int usb_drv_async_control_read_status(int phone, usb_target_t target,
     535    usb_handle_t *handle)
     536{
     537        return async_send_buffer(phone,
     538            IPC_M_USBHC_CONTROL_READ_STATUS,
     539            target,
     540            NULL, 0,
     541            handle);
     542}
     543
     544/** Issue whole control read transfer. */
     545int usb_drv_async_control_read(int phone, usb_target_t target,
     546    void *setup_packet, size_t setup_packet_size,
     547    void *buffer, size_t buffer_size, size_t *actual_size,
    501548    usb_handle_t *handle)
    502549{
    … …  
    515562        }
    516563
    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 /** Start control read transfer. */
    548 int usb_drv_async_control_read_setup(int phone, usb_target_t target,
    549     void *buffer, size_t size,
    550     usb_handle_t *handle)
    551 {
    552         return async_send_buffer(phone,
    553             IPC_M_USBHC_CONTROL_READ_SETUP,
    554             target,
    555             buffer, size,
    556             handle);
    557 }
    558 
    559 /** Read data during control read transfer. */
    560 int usb_drv_async_control_read_data(int phone, usb_target_t target,
    561     void *buffer, size_t size, size_t *actual_size,
    562     usb_handle_t *handle)
    563 {
    564         return async_recv_buffer(phone,
    565             IPC_M_USBHC_CONTROL_READ_DATA,
    566             target,
    567             buffer, size, actual_size,
    568             handle);
    569 }
    570 
    571 /** Finalize control read transfer. */
    572 int usb_drv_async_control_read_status(int phone, usb_target_t target,
    573     usb_handle_t *handle)
    574 {
    575         return async_send_buffer(phone,
    576             IPC_M_USBHC_CONTROL_READ_STATUS,
    577             target,
    578             NULL, 0,
    579             handle);
    580 }
    581 
    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 them
    589         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 *transfer
    597             = (transfer_info_t *) malloc(sizeof(transfer_info_t));
    598         if (transfer == NULL) {
    599                 return ENOMEM;
    600         }
    601 
    602564        transfer->size_transferred = actual_size;
    603565        transfer->buffer = buffer;
    … …  
    620582        }
    621583
     584        transfer->read_request = async_data_read(phone, buffer, buffer_size,
     585            &transfer->read_reply);
     586
    622587        *handle = (usb_handle_t) transfer;
    623588
Note: See TracChangeset for help on using the changeset viewer.