Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/uhci-hcd/iface.c

    rc61338a r1fb1339  
    3333 */
    3434#include <ddf/driver.h>
     35#include <remote_usbhc.h>
     36
     37#include <usb/debug.h>
     38
    3539#include <errno.h>
    3640
    37 #include <usb/debug.h>
    38 
    3941#include "iface.h"
    40 #include "hc.h"
     42#include "uhci_hc.h"
    4143
    4244/** Reserve default address interface function
    … …  
    4648 * @return Error code.
    4749 */
     50/*----------------------------------------------------------------------------*/
    4851static int reserve_default_address(ddf_fun_t *fun, usb_speed_t speed)
    4952{
    5053        assert(fun);
    51         hc_t *hc = fun_to_hc(fun);
     54        uhci_hc_t *hc = fun_to_uhci_hc(fun);
    5255        assert(hc);
    5356        usb_log_debug("Default address request with speed %d.\n", speed);
    54         usb_device_keeper_reserve_default_address(&hc->manager, speed);
     57        device_keeper_reserve_default(&hc->device_manager, speed);
    5558        return EOK;
    5659}
    … …  
    6467{
    6568        assert(fun);
    66         hc_t *hc = fun_to_hc(fun);
     69        uhci_hc_t *hc = fun_to_uhci_hc(fun);
    6770        assert(hc);
    6871        usb_log_debug("Default address release.\n");
    69         usb_device_keeper_release_default_address(&hc->manager);
     72        device_keeper_release_default(&hc->device_manager);
    7073        return EOK;
    7174}
    … …  
    7881 * @return Error code.
    7982 */
    80 static int request_address(
    81     ddf_fun_t *fun, usb_speed_t speed, usb_address_t *address)
    82 {
    83         assert(fun);
    84         hc_t *hc = fun_to_hc(fun);
     83static int request_address(ddf_fun_t *fun, usb_speed_t speed,
     84    usb_address_t *address)
     85{
     86        assert(fun);
     87        uhci_hc_t *hc = fun_to_uhci_hc(fun);
    8588        assert(hc);
    8689        assert(address);
    8790
    8891        usb_log_debug("Address request with speed %d.\n", speed);
    89         *address = device_keeper_get_free_address(&hc->manager, speed);
     92        *address = device_keeper_request(&hc->device_manager, speed);
    9093        usb_log_debug("Address request with result: %d.\n", *address);
    9194        if (*address <= 0)
    92                 return *address;
     95          return *address;
    9396        return EOK;
    9497}
    … …  
    105108{
    106109        assert(fun);
    107         hc_t *hc = fun_to_hc(fun);
     110        uhci_hc_t *hc = fun_to_uhci_hc(fun);
    108111        assert(hc);
    109112        usb_log_debug("Address bind %d-%d.\n", address, handle);
    110         usb_device_keeper_bind(&hc->manager, address, handle);
     113        device_keeper_bind(&hc->device_manager, address, handle);
    111114        return EOK;
    112115}
    … …  
    121124{
    122125        assert(fun);
    123         hc_t *hc = fun_to_hc(fun);
     126        uhci_hc_t *hc = fun_to_uhci_hc(fun);
    124127        assert(hc);
    125128        usb_log_debug("Address release %d.\n", address);
    126         usb_device_keeper_release(&hc->manager, address);
     129        device_keeper_release(&hc->device_manager, address);
    127130        return EOK;
    128131}
    … …  
    139142 * @return Error code.
    140143 */
    141 static int interrupt_out(
    142     ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
    143     size_t size, usbhc_iface_transfer_out_callback_t callback, void *arg)
    144 {
    145         assert(fun);
    146         hc_t *hc = fun_to_hc(fun);
    147         assert(hc);
    148         usb_speed_t speed =
    149             usb_device_keeper_get_speed(&hc->manager, target.address);
     144static int interrupt_out(ddf_fun_t *fun, usb_target_t target,
     145    size_t max_packet_size, void *data, size_t size,
     146    usbhc_iface_transfer_out_callback_t callback, void *arg)
     147{
     148        assert(fun);
     149        uhci_hc_t *hc = fun_to_uhci_hc(fun);
     150        assert(hc);
     151        usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
    150152
    151153        usb_log_debug("Interrupt OUT %d:%d %zu(%zu).\n",
    152154            target.address, target.endpoint, size, max_packet_size);
    153155
    154         usb_transfer_batch_t *batch =
    155             batch_get(fun, target, USB_TRANSFER_INTERRUPT, max_packet_size,
    156                 speed, data, size, NULL, 0, NULL, callback, arg, &hc->manager);
     156        batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
     157            max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg,
     158            &hc->device_manager);
    157159        if (!batch)
    158160                return ENOMEM;
    159161        batch_interrupt_out(batch);
    160         const int ret = hc_schedule(hc, batch);
    161         if (ret != EOK) {
    162                 batch_dispose(batch);
    163         }
    164         return ret;
     162        const int ret = uhci_hc_schedule(hc, batch);
     163        if (ret != EOK) {
     164                batch_dispose(batch);
     165                return ret;
     166        }
     167        return EOK;
    165168}
    166169/*----------------------------------------------------------------------------*/
    … …  
    176179 * @return Error code.
    177180 */
    178 static int interrupt_in(
    179     ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
    180     size_t size, usbhc_iface_transfer_in_callback_t callback, void *arg)
    181 {
    182         assert(fun);
    183         hc_t *hc = fun_to_hc(fun);
    184         assert(hc);
    185         usb_speed_t speed =
    186             usb_device_keeper_get_speed(&hc->manager, target.address);
     181static int interrupt_in(ddf_fun_t *fun, usb_target_t target,
     182    size_t max_packet_size, void *data, size_t size,
     183    usbhc_iface_transfer_in_callback_t callback, void *arg)
     184{
     185        assert(fun);
     186        uhci_hc_t *hc = fun_to_uhci_hc(fun);
     187        assert(hc);
     188        usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
    187189        usb_log_debug("Interrupt IN %d:%d %zu(%zu).\n",
    188190            target.address, target.endpoint, size, max_packet_size);
    189191
    190         usb_transfer_batch_t *batch =
    191             batch_get(fun, target, USB_TRANSFER_INTERRUPT, max_packet_size,
    192                 speed, data, size, NULL, 0, callback, NULL, arg, &hc->manager);
     192        batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
     193            max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg,
     194                        &hc->device_manager);
    193195        if (!batch)
    194196                return ENOMEM;
    195197        batch_interrupt_in(batch);
    196         const int ret = hc_schedule(hc, batch);
    197         if (ret != EOK) {
    198                 batch_dispose(batch);
    199         }
    200         return ret;
     198        const int ret = uhci_hc_schedule(hc, batch);
     199        if (ret != EOK) {
     200                batch_dispose(batch);
     201                return ret;
     202        }
     203        return EOK;
    201204}
    202205/*----------------------------------------------------------------------------*/
    … …  
    212215 * @return Error code.
    213216 */
    214 static int bulk_out(
    215     ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
    216     size_t size, usbhc_iface_transfer_out_callback_t callback, void *arg)
    217 {
    218         assert(fun);
    219         hc_t *hc = fun_to_hc(fun);
    220         assert(hc);
    221         usb_speed_t speed =
    222             usb_device_keeper_get_speed(&hc->manager, target.address);
     217static int bulk_out(ddf_fun_t *fun, usb_target_t target,
     218    size_t max_packet_size, void *data, size_t size,
     219    usbhc_iface_transfer_out_callback_t callback, void *arg)
     220{
     221        assert(fun);
     222        uhci_hc_t *hc = fun_to_uhci_hc(fun);
     223        assert(hc);
     224        usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
    223225
    224226        usb_log_debug("Bulk OUT %d:%d %zu(%zu).\n",
    225227            target.address, target.endpoint, size, max_packet_size);
    226228
    227         usb_transfer_batch_t *batch =
    228             batch_get(fun, target, USB_TRANSFER_BULK, max_packet_size, speed,
    229                 data, size, NULL, 0, NULL, callback, arg, &hc->manager);
     229        batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK,
     230            max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg,
     231            &hc->device_manager);
    230232        if (!batch)
    231233                return ENOMEM;
    232234        batch_bulk_out(batch);
    233         const int ret = hc_schedule(hc, batch);
    234         if (ret != EOK) {
    235                 batch_dispose(batch);
    236         }
    237         return ret;
     235        const int ret = uhci_hc_schedule(hc, batch);
     236        if (ret != EOK) {
     237                batch_dispose(batch);
     238                return ret;
     239        }
     240        return EOK;
    238241}
    239242/*----------------------------------------------------------------------------*/
    … …  
    249252 * @return Error code.
    250253 */
    251 static int bulk_in(
    252     ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
    253     size_t size, usbhc_iface_transfer_in_callback_t callback, void *arg)
    254 {
    255         assert(fun);
    256         hc_t *hc = fun_to_hc(fun);
    257         assert(hc);
    258         usb_speed_t speed =
    259             usb_device_keeper_get_speed(&hc->manager, target.address);
     254static int bulk_in(ddf_fun_t *fun, usb_target_t target,
     255    size_t max_packet_size, void *data, size_t size,
     256    usbhc_iface_transfer_in_callback_t callback, void *arg)
     257{
     258        assert(fun);
     259        uhci_hc_t *hc = fun_to_uhci_hc(fun);
     260        assert(hc);
     261        usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
    260262        usb_log_debug("Bulk IN %d:%d %zu(%zu).\n",
    261263            target.address, target.endpoint, size, max_packet_size);
    262264
    263         usb_transfer_batch_t *batch =
    264             batch_get(fun, target, USB_TRANSFER_BULK, max_packet_size, speed,
    265                 data, size, NULL, 0, callback, NULL, arg, &hc->manager);
     265        batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK,
     266            max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg,
     267            &hc->device_manager);
    266268        if (!batch)
    267269                return ENOMEM;
    268270        batch_bulk_in(batch);
    269         const int ret = hc_schedule(hc, batch);
    270         if (ret != EOK) {
    271                 batch_dispose(batch);
    272         }
    273         return ret;
     271        const int ret = uhci_hc_schedule(hc, batch);
     272        if (ret != EOK) {
     273                batch_dispose(batch);
     274                return ret;
     275        }
     276        return EOK;
    274277}
    275278/*----------------------------------------------------------------------------*/
    … …  
    279282 * @param[in] target USB device to write to.
    280283 * @param[in] max_packet_size maximum size of data packet the device accepts.
    281  * @param[in] setup_data Data to send with SETUP transfer.
    282  * @param[in] setup_size Size of data to send with SETUP transfer (always 8B).
     284 * @param[in] setup_data Data to send with SETUP packet.
     285 * @param[in] setup_size Size of data to send with SETUP packet (should be 8B).
    283286 * @param[in] data Source of data.
    284287 * @param[in] size Size of data source.
    … …  
    287290 * @return Error code.
    288291 */
    289 static int control_write(
    290     ddf_fun_t *fun, usb_target_t target, size_t max_packet_size,
     292static int control_write(ddf_fun_t *fun, usb_target_t target,
     293    size_t max_packet_size,
    291294    void *setup_data, size_t setup_size, void *data, size_t size,
    292295    usbhc_iface_transfer_out_callback_t callback, void *arg)
    293296{
    294297        assert(fun);
    295         hc_t *hc = fun_to_hc(fun);
    296         assert(hc);
    297         usb_speed_t speed =
    298             usb_device_keeper_get_speed(&hc->manager, target.address);
     298        uhci_hc_t *hc = fun_to_uhci_hc(fun);
     299        assert(hc);
     300        usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
    299301        usb_log_debug("Control WRITE (%d) %d:%d %zu(%zu).\n",
    300302            speed, target.address, target.endpoint, size, max_packet_size);
    … …  
    303305                return EINVAL;
    304306
    305         usb_transfer_batch_t *batch =
    306             batch_get(fun, target, USB_TRANSFER_CONTROL, max_packet_size, speed,
    307                 data, size, setup_data, setup_size, NULL, callback, arg,
    308                 &hc->manager);
    309         if (!batch)
    310                 return ENOMEM;
    311         usb_device_keeper_reset_if_need(&hc->manager, target, setup_data);
     307        batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
     308            max_packet_size, speed, data, size, setup_data, setup_size,
     309            NULL, callback, arg, &hc->device_manager);
     310        if (!batch)
     311                return ENOMEM;
     312        device_keeper_reset_if_need(&hc->device_manager, target, setup_data);
    312313        batch_control_write(batch);
    313         const int ret = hc_schedule(hc, batch);
    314         if (ret != EOK) {
    315                 batch_dispose(batch);
    316         }
    317         return ret;
     314        const int ret = uhci_hc_schedule(hc, batch);
     315        if (ret != EOK) {
     316                batch_dispose(batch);
     317                return ret;
     318        }
     319        return EOK;
    318320}
    319321/*----------------------------------------------------------------------------*/
    … …  
    331333 * @return Error code.
    332334 */
    333 static int control_read(
    334     ddf_fun_t *fun, usb_target_t target, size_t max_packet_size,
     335static int control_read(ddf_fun_t *fun, usb_target_t target,
     336    size_t max_packet_size,
    335337    void *setup_data, size_t setup_size, void *data, size_t size,
    336338    usbhc_iface_transfer_in_callback_t callback, void *arg)
    337339{
    338340        assert(fun);
    339         hc_t *hc = fun_to_hc(fun);
    340         assert(hc);
    341         usb_speed_t speed =
    342             usb_device_keeper_get_speed(&hc->manager, target.address);
     341        uhci_hc_t *hc = fun_to_uhci_hc(fun);
     342        assert(hc);
     343        usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
    343344
    344345        usb_log_debug("Control READ(%d) %d:%d %zu(%zu).\n",
    345346            speed, target.address, target.endpoint, size, max_packet_size);
    346         usb_transfer_batch_t *batch =
    347             batch_get(fun, target, USB_TRANSFER_CONTROL, max_packet_size, speed,
    348                 data, size, setup_data, setup_size, callback, NULL, arg,
    349                 &hc->manager);
     347        batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
     348            max_packet_size, speed, data, size, setup_data, setup_size, callback,
     349            NULL, arg, &hc->device_manager);
    350350        if (!batch)
    351351                return ENOMEM;
    352352        batch_control_read(batch);
    353         const int ret = hc_schedule(hc, batch);
    354         if (ret != EOK) {
    355                 batch_dispose(batch);
    356         }
    357         return ret;
    358 }
    359 /*----------------------------------------------------------------------------*/
    360 usbhc_iface_t hc_iface = {
     353        const int ret = uhci_hc_schedule(hc, batch);
     354        if (ret != EOK) {
     355                batch_dispose(batch);
     356                return ret;
     357        }
     358        return EOK;
     359}
     360/*----------------------------------------------------------------------------*/
     361usbhc_iface_t uhci_hc_iface = {
    361362        .reserve_default_address = reserve_default_address,
    362363        .release_default_address = release_default_address,
    … …  
    368369        .interrupt_in = interrupt_in,
    369370
     371        .bulk_in = bulk_in,
    370372        .bulk_out = bulk_out,
    371         .bulk_in = bulk_in,
    372 
     373
     374        .control_read = control_read,
    373375        .control_write = control_write,
    374         .control_read = control_read,
    375376};
    376377/**
Note: See TracChangeset for help on using the changeset viewer.