Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/drv/generic/remote_usbhc.c

    rec59693 rb36e5de2  
    4646static void remote_usbhc_interrupt_out(device_t *, void *, ipc_callid_t, ipc_call_t *);
    4747static void remote_usbhc_interrupt_in(device_t *, void *, ipc_callid_t, ipc_call_t *);
    48 static void remote_usbhc_control_write_setup(device_t *, void *, ipc_callid_t, ipc_call_t *);
    49 static void remote_usbhc_control_write_data(device_t *, void *, ipc_callid_t, ipc_call_t *);
    50 static void remote_usbhc_control_write_status(device_t *, void *, ipc_callid_t, ipc_call_t *);
    51 static void remote_usbhc_control_read_setup(device_t *, void *, ipc_callid_t, ipc_call_t *);
    52 static void remote_usbhc_control_read_data(device_t *, void *, ipc_callid_t, ipc_call_t *);
    53 static void remote_usbhc_control_read_status(device_t *, void *, ipc_callid_t, ipc_call_t *);
    5448static void remote_usbhc_control_write(device_t *, void *, ipc_callid_t, ipc_call_t *);
    5549static void remote_usbhc_control_read(device_t *, void *, ipc_callid_t, ipc_call_t *);
    … …  
    7569        remote_usbhc_interrupt_in,
    7670
    77         remote_usbhc_control_write_setup,
    78         remote_usbhc_control_write_data,
    79         remote_usbhc_control_write_status,
    80 
    81         remote_usbhc_control_read_setup,
    82         remote_usbhc_control_read_data,
    83         remote_usbhc_control_read_status,
    84 
    8571        remote_usbhc_control_write,
    8672        remote_usbhc_control_read
    … …  
    165151                return;
    166152        }
    167 
    168         int rc = usb_iface->reserve_default_address(device);
     153       
     154        usb_speed_t speed = DEV_IPC_GET_ARG1(*call);
     155       
     156        int rc = usb_iface->reserve_default_address(device, speed);
    169157
    170158        async_answer_0(callid, rc);
    … …  
    195183                return;
    196184        }
     185       
     186        usb_speed_t speed = DEV_IPC_GET_ARG1(*call);
    197187
    198188        usb_address_t address;
    199         int rc = usb_iface->request_address(device, &address);
     189        int rc = usb_iface->request_address(device, speed, &address);
    200190        if (rc != EOK) {
    201191                async_answer_0(callid, rc);
    … …  
    293283        }
    294284
    295         size_t expected_len = DEV_IPC_GET_ARG3(*call);
     285        size_t max_packet_size = DEV_IPC_GET_ARG3(*call);
    296286        usb_target_t target = {
    297287                .address = DEV_IPC_GET_ARG1(*call),
    … …  
    301291        size_t len = 0;
    302292        void *buffer = NULL;
    303         if (expected_len > 0) {
    304                 int rc = async_data_write_accept(&buffer, false,
    305                     1, USB_MAX_PAYLOAD_SIZE,
    306                     0, &len);
    307 
    308                 if (rc != EOK) {
    309                         async_answer_0(callid, rc);
    310                         return;
    311                 }
     293
     294        int rc = async_data_write_accept(&buffer, false,
     295            1, USB_MAX_PAYLOAD_SIZE,
     296            0, &len);
     297
     298        if (rc != EOK) {
     299                async_answer_0(callid, rc);
     300                return;
    312301        }
    313302
    … …  
    324313        trans->size = len;
    325314
    326         int rc = transfer_func(device, target, HACK_MAX_PACKET_SIZE,
     315        rc = transfer_func(device, target, max_packet_size,
    327316            buffer, len,
    328317            callback_out, trans);
    … …  
    350339        }
    351340
    352         size_t len = DEV_IPC_GET_ARG3(*call);
     341        size_t max_packet_size = DEV_IPC_GET_ARG3(*call);
    353342        usb_target_t target = {
    354343                .address = DEV_IPC_GET_ARG1(*call),
    … …  
    356345        };
    357346
     347        size_t len;
    358348        ipc_callid_t data_callid;
    359349        if (!async_data_read_receive(&data_callid, &len)) {
    … …  
    371361        trans->size = len;
    372362
    373         int rc = transfer_func(device, target, HACK_MAX_PACKET_SIZE_INTERRUPT_IN,
     363        int rc = transfer_func(device, target, max_packet_size,
    374364            trans->buffer, len,
    375365            callback_in, trans);
    … …  
    381371}
    382372
    383 /** Process status part of control transfer.
    384  *
    385  * @param device Target device.
    386  * @param callid Initiating caller.
    387  * @param call Initiating call.
    388  * @param direction Transfer direction (read ~ in, write ~ out).
    389  * @param transfer_in_func Transfer function for control read (might be NULL).
    390  * @param transfer_out_func Transfer function for control write (might be NULL).
    391  */
    392 static void remote_usbhc_status_transfer(device_t *device,
    393     ipc_callid_t callid, ipc_call_t *call,
    394     usb_direction_t direction,
    395     int (*transfer_in_func)(device_t *, usb_target_t,
    396         usbhc_iface_transfer_in_callback_t, void *),
    397     int (*transfer_out_func)(device_t *, usb_target_t,
    398         usbhc_iface_transfer_out_callback_t, void *))
    399 {
    400         switch (direction) {
    401                 case USB_DIRECTION_IN:
    402                         if (!transfer_in_func) {
    403                                 async_answer_0(callid, ENOTSUP);
    404                                 return;
    405                         }
    406                         break;
    407                 case USB_DIRECTION_OUT:
    408                         if (!transfer_out_func) {
    409                                 async_answer_0(callid, ENOTSUP);
    410                                 return;
    411                         }
    412                         break;
    413                 default:
    414                         assert(false && "unreachable code");
    415                         break;
    416         }
    417 
    418         usb_target_t target = {
    419                 .address = DEV_IPC_GET_ARG1(*call),
    420                 .endpoint = DEV_IPC_GET_ARG2(*call)
    421         };
    422 
    423         async_transaction_t *trans = async_transaction_create(callid);
    424         if (trans == NULL) {
    425                 async_answer_0(callid, ENOMEM);
    426                 return;
    427         }
    428 
    429         int rc;
    430         switch (direction) {
    431                 case USB_DIRECTION_IN:
    432                         rc = transfer_in_func(device, target,
    433                             callback_in, trans);
    434                         break;
    435                 case USB_DIRECTION_OUT:
    436                         rc = transfer_out_func(device, target,
    437                             callback_out, trans);
    438                         break;
    439                 default:
    440                         assert(false && "unreachable code");
    441                         break;
    442         }
    443 
    444         if (rc != EOK) {
    445                 async_answer_0(callid, rc);
    446                 async_transaction_destroy(trans);
    447         }
    448 }
    449 
    450 
    451373void remote_usbhc_interrupt_out(device_t *device, void *iface,
    452374    ipc_callid_t callid, ipc_call_t *call)
    … …  
    467389        return remote_usbhc_in_transfer(device, callid, call,
    468390            usb_iface->interrupt_in);
    469 }
    470 
    471 void remote_usbhc_control_write_setup(device_t *device, void *iface,
    472     ipc_callid_t callid, ipc_call_t *call)
    473 {
    474         usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
    475         assert(usb_iface != NULL);
    476 
    477         return remote_usbhc_out_transfer(device, callid, call,
    478             usb_iface->control_write_setup);
    479 }
    480 
    481 void remote_usbhc_control_write_data(device_t *device, void *iface,
    482     ipc_callid_t callid, ipc_call_t *call)
    483 {
    484         usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
    485         assert(usb_iface != NULL);
    486 
    487         return remote_usbhc_out_transfer(device, callid, call,
    488             usb_iface->control_write_data);
    489 }
    490 
    491 void remote_usbhc_control_write_status(device_t *device, void *iface,
    492     ipc_callid_t callid, ipc_call_t *call)
    493 {
    494         usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
    495         assert(usb_iface != NULL);
    496 
    497         return remote_usbhc_status_transfer(device, callid, call,
    498             USB_DIRECTION_IN, usb_iface->control_write_status, NULL);
    499 }
    500 
    501 void remote_usbhc_control_read_setup(device_t *device, void *iface,
    502     ipc_callid_t callid, ipc_call_t *call)
    503 {
    504         usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
    505         assert(usb_iface != NULL);
    506 
    507         return remote_usbhc_out_transfer(device, callid, call,
    508             usb_iface->control_read_setup);
    509 }
    510 
    511 void remote_usbhc_control_read_data(device_t *device, void *iface,
    512             ipc_callid_t callid, ipc_call_t *call)
    513 {
    514         usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
    515         assert(usb_iface != NULL);
    516 
    517         return remote_usbhc_in_transfer(device, callid, call,
    518             usb_iface->control_read_data);
    519 }
    520 
    521 void remote_usbhc_control_read_status(device_t *device, void *iface,
    522             ipc_callid_t callid, ipc_call_t *call)
    523 {
    524         usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
    525         assert(usb_iface != NULL);
    526 
    527         return remote_usbhc_status_transfer(device, callid, call,
    528             USB_DIRECTION_OUT, NULL, usb_iface->control_read_status);
    529391}
    530392
    … …  
    545407        };
    546408        size_t data_buffer_len = DEV_IPC_GET_ARG3(*call);
     409        size_t max_packet_size = DEV_IPC_GET_ARG4(*call);
    547410
    548411        int rc;
    … …  
    580443        trans->size = data_buffer_len;
    581444
    582         rc = usb_iface->control_write(device, target, HACK_MAX_PACKET_SIZE,
     445        rc = usb_iface->control_write(device, target, max_packet_size,
    583446            setup_packet, setup_packet_len,
    584447            data_buffer, data_buffer_len,
    … …  
    607470                .endpoint = DEV_IPC_GET_ARG2(*call)
    608471        };
     472        size_t max_packet_size = DEV_IPC_GET_ARG3(*call);
    609473
    610474        int rc;
    … …  
    644508        }
    645509
    646         rc = usb_iface->control_read(device, target, HACK_MAX_PACKET_SIZE,
     510        rc = usb_iface->control_read(device, target, max_packet_size,
    647511            setup_packet, setup_packet_len,
    648512            trans->buffer, trans->size,
Note: See TracChangeset for help on using the changeset viewer.