Changeset 92574f4 in mainline for uspace/drv/vhc/connhost.c


Ignore:
Timestamp:
2011-02-24T12:03:27Z (13 years ago)
Author:
Lubos Slovak <lubos.slovak@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
e7b7ebd5
Parents:
4837092 (diff), a80849c (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merged development (changes in DDF, etc.).

Conflicts in uspace/drv/usbkbd/main.c

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/vhc/connhost.c

    r4837092 r92574f4  
    3636#include <errno.h>
    3737#include <usb/usb.h>
    38 #include <usb/hcd.h>
     38#include <usb/addrkeep.h>
     39#include <usb/ddfiface.h>
    3940
    4041#include "vhcd.h"
    … …  
    4748        usbhc_iface_transfer_out_callback_t out_callback;
    4849        usbhc_iface_transfer_in_callback_t in_callback;
    49         device_t *dev;
     50        ddf_fun_t *fun;
    5051        size_t reported_size;
    5152        void *arg;
    … …  
    5758        usbhc_iface_transfer_out_callback_t out_callback;
    5859        usbhc_iface_transfer_in_callback_t in_callback;
    59         device_t *dev;
     60        ddf_fun_t *fun;
    6061        void *arg;
    6162        void *data_buffer;
    … …  
    6465
    6566static void universal_callback(void *buffer, size_t size,
    66     usb_transaction_outcome_t outcome, void *arg)
     67    int outcome, void *arg)
    6768{
    6869        transfer_info_t *transfer = (transfer_info_t *) arg;
    … …  
    7475        switch (transfer->direction) {
    7576                case USB_DIRECTION_IN:
    76                         transfer->in_callback(transfer->dev,
     77                        transfer->in_callback(transfer->fun,
    7778                            outcome, size,
    7879                            transfer->arg);
    7980                        break;
    8081                case USB_DIRECTION_OUT:
    81                         transfer->out_callback(transfer->dev,
     82                        transfer->out_callback(transfer->fun,
    8283                            outcome,
    8384                            transfer->arg);
    … …  
    9192}
    9293
    93 static transfer_info_t *create_transfer_info(device_t *dev,
     94static transfer_info_t *create_transfer_info(ddf_fun_t *fun,
    9495    usb_direction_t direction, void *arg)
    9596{
    … …  
    100101        transfer->out_callback = NULL;
    101102        transfer->arg = arg;
    102         transfer->dev = dev;
     103        transfer->fun = fun;
    103104        transfer->reported_size = (size_t) -1;
    104105
    … …  
    107108
    108109static void control_abort_prematurely(control_transfer_info_t *transfer,
    109     size_t size, usb_transaction_outcome_t outcome)
     110    size_t size, int outcome)
    110111{
    111112        switch (transfer->direction) {
    112113                case USB_DIRECTION_IN:
    113                         transfer->in_callback(transfer->dev,
     114                        transfer->in_callback(transfer->fun,
    114115                            outcome, size,
    115116                            transfer->arg);
    116117                        break;
    117118                case USB_DIRECTION_OUT:
    118                         transfer->out_callback(transfer->dev,
     119                        transfer->out_callback(transfer->fun,
    119120                            outcome,
    120121                            transfer->arg);
    … …  
    127128
    128129static void control_callback_two(void *buffer, size_t size,
    129     usb_transaction_outcome_t outcome, void *arg)
     130    int outcome, void *arg)
    130131{
    131132        control_transfer_info_t *ctrl_transfer = (control_transfer_info_t *) arg;
    132133
    133         if (outcome != USB_OUTCOME_OK) {
     134        if (outcome != EOK) {
    134135                control_abort_prematurely(ctrl_transfer, outcome, size);
    135136                free(ctrl_transfer);
    … …  
    137138        }
    138139
    139         transfer_info_t *transfer  = create_transfer_info(ctrl_transfer->dev,
     140        transfer_info_t *transfer  = create_transfer_info(ctrl_transfer->fun,
    140141            ctrl_transfer->direction, ctrl_transfer->arg);
    141142        transfer->out_callback = ctrl_transfer->out_callback;
    … …  
    165166
    166167static void control_callback_one(void *buffer, size_t size,
    167     usb_transaction_outcome_t outcome, void *arg)
     168    int outcome, void *arg)
    168169{
    169170        control_transfer_info_t *transfer = (control_transfer_info_t *) arg;
    170171
    171         if (outcome != USB_OUTCOME_OK) {
     172        if (outcome != EOK) {
    172173                control_abort_prematurely(transfer, outcome, size);
    173174                free(transfer);
    … …  
    194195}
    195196
    196 static control_transfer_info_t *create_control_transfer_info(device_t *dev,
     197static control_transfer_info_t *create_control_transfer_info(ddf_fun_t *fun,
    197198    usb_direction_t direction, usb_target_t target,
    198199    void *data_buffer, size_t data_buffer_size,
    … …  
    207208        transfer->out_callback = NULL;
    208209        transfer->arg = arg;
    209         transfer->dev = dev;
     210        transfer->fun = fun;
    210211        transfer->data_buffer = data_buffer;
    211212        transfer->data_buffer_size = data_buffer_size;
    … …  
    214215}
    215216
    216 static int enqueue_transfer_out(device_t *dev,
     217static int enqueue_transfer_out(ddf_fun_t *fun,
    217218    usb_target_t target, usb_transfer_type_t transfer_type,
    218219    void *buffer, size_t size,
    … …  
    225226
    226227        transfer_info_t *transfer
    227             = create_transfer_info(dev, USB_DIRECTION_OUT, arg);
     228            = create_transfer_info(fun, USB_DIRECTION_OUT, arg);
    228229        transfer->out_callback = callback;
    229230
    … …  
    234235}
    235236
    236 static int enqueue_transfer_setup(device_t *dev,
    237     usb_target_t target, usb_transfer_type_t transfer_type,
    238     void *buffer, size_t size,
    239     usbhc_iface_transfer_out_callback_t callback, void *arg)
    240 {
    241         usb_log_debug2("Transfer SETUP [%d.%d (%s); %zu].\n",
    242             target.address, target.endpoint,
    243             usb_str_transfer_type(transfer_type),
    244             size);
    245 
    246         transfer_info_t *transfer
    247             = create_transfer_info(dev, USB_DIRECTION_OUT, arg);
    248         transfer->out_callback = callback;
    249 
    250         hc_add_transaction_to_device(true, target, transfer_type, buffer, size,
    251             universal_callback, transfer);
    252 
    253         return EOK;
    254 }
    255 
    256 static int enqueue_transfer_in(device_t *dev,
     237static int enqueue_transfer_in(ddf_fun_t *fun,
    257238    usb_target_t target, usb_transfer_type_t transfer_type,
    258239    void *buffer, size_t size,
    … …  
    265246
    266247        transfer_info_t *transfer
    267             = create_transfer_info(dev, USB_DIRECTION_IN, arg);
     248            = create_transfer_info(fun, USB_DIRECTION_IN, arg);
    268249        transfer->in_callback = callback;
    269250
    … …  
    275256
    276257
    277 static int interrupt_out(device_t *dev, usb_target_t target,
     258static int interrupt_out(ddf_fun_t *fun, usb_target_t target,
     259    size_t max_packet_size,
    278260    void *data, size_t size,
    279261    usbhc_iface_transfer_out_callback_t callback, void *arg)
    280262{
    281         return enqueue_transfer_out(dev, target, USB_TRANSFER_INTERRUPT,
     263        return enqueue_transfer_out(fun, target, USB_TRANSFER_INTERRUPT,
    282264            data, size,
    283265            callback, arg);
    284266}
    285267
    286 static int interrupt_in(device_t *dev, usb_target_t target,
     268static int interrupt_in(ddf_fun_t *fun, usb_target_t target,
     269    size_t max_packet_size,
    287270    void *data, size_t size,
    288271    usbhc_iface_transfer_in_callback_t callback, void *arg)
    289272{
    290         return enqueue_transfer_in(dev, target, USB_TRANSFER_INTERRUPT,
     273        return enqueue_transfer_in(fun, target, USB_TRANSFER_INTERRUPT,
    291274            data, size,
    292275            callback, arg);
    293276}
    294277
    295 static int control_write_setup(device_t *dev, usb_target_t target,
    296     void *data, size_t size,
    297     usbhc_iface_transfer_out_callback_t callback, void *arg)
    298 {
    299         return enqueue_transfer_setup(dev, target, USB_TRANSFER_CONTROL,
    300             data, size,
    301             callback, arg);
    302 }
    303 
    304 static int control_write_data(device_t *dev, usb_target_t target,
    305     void *data, size_t size,
    306     usbhc_iface_transfer_out_callback_t callback, void *arg)
    307 {
    308         return enqueue_transfer_out(dev, target, USB_TRANSFER_CONTROL,
    309             data, size,
    310             callback, arg);
    311 }
    312 
    313 static int control_write_status(device_t *dev, usb_target_t target,
    314     usbhc_iface_transfer_in_callback_t callback, void *arg)
    315 {
    316         return enqueue_transfer_in(dev, target, USB_TRANSFER_CONTROL,
    317             NULL, 0,
    318             callback, arg);
    319 }
    320 
    321 static int control_write(device_t *dev, usb_target_t target,
     278static int control_write(ddf_fun_t *fun, usb_target_t target,
     279    size_t max_packet_size,
    322280    void *setup_packet, size_t setup_packet_size,
    323281    void *data, size_t data_size,
    … …  
    325283{
    326284        control_transfer_info_t *transfer
    327             = create_control_transfer_info(dev, USB_DIRECTION_OUT, target,
     285            = create_control_transfer_info(fun, USB_DIRECTION_OUT, target,
    328286            data, data_size, arg);
    329287        transfer->out_callback = callback;
    … …  
    336294}
    337295
    338 static int control_read_setup(device_t *dev, usb_target_t target,
    339     void *data, size_t size,
    340     usbhc_iface_transfer_out_callback_t callback, void *arg)
    341 {
    342         return enqueue_transfer_setup(dev, target, USB_TRANSFER_CONTROL,
    343             data, size,
    344             callback, arg);
    345 }
    346 
    347 static int control_read_data(device_t *dev, usb_target_t target,
    348     void *data, size_t size,
    349     usbhc_iface_transfer_in_callback_t callback, void *arg)
    350 {
    351         return enqueue_transfer_in(dev, target, USB_TRANSFER_CONTROL,
    352             data, size,
    353             callback, arg);
    354 }
    355 
    356 static int control_read_status(device_t *dev, usb_target_t target,
    357     usbhc_iface_transfer_out_callback_t callback, void *arg)
    358 {
    359         return enqueue_transfer_out(dev, target, USB_TRANSFER_CONTROL,
    360             NULL, 0,
    361             callback, arg);
    362 }
    363 
    364 static int control_read(device_t *dev, usb_target_t target,
     296static int control_read(ddf_fun_t *fun, usb_target_t target,
     297    size_t max_packet_size,
    365298    void *setup_packet, size_t setup_packet_size,
    366299    void *data, size_t data_size,
    … …  
    368301{
    369302        control_transfer_info_t *transfer
    370             = create_control_transfer_info(dev, USB_DIRECTION_IN, target,
     303            = create_control_transfer_info(fun, USB_DIRECTION_IN, target,
    371304            data, data_size, arg);
    372305        transfer->in_callback = callback;
    … …  
    381314static usb_address_keeping_t addresses;
    382315
    383 
    384 static int reserve_default_address(device_t *dev)
     316static int tell_address(ddf_fun_t *fun, devman_handle_t handle,
     317    usb_address_t *address)
     318{
     319        usb_log_debug("tell_address(fun \"%s\", handle %zu)\n",
     320            fun->name, (size_t) fun->handle);
     321        usb_address_t addr = usb_address_keeping_find(&addresses, handle);
     322        if (addr < 0) {
     323                return addr;
     324        }
     325
     326        *address = addr;
     327        return EOK;
     328}
     329
     330static int reserve_default_address(ddf_fun_t *fun, usb_speed_t ignored)
    385331{
    386332        usb_address_keeping_reserve_default(&addresses);
    … …  
    388334}
    389335
    390 static int release_default_address(device_t *dev)
     336static int release_default_address(ddf_fun_t *fun)
    391337{
    392338        usb_address_keeping_release_default(&addresses);
    … …  
    394340}
    395341
    396 static int request_address(device_t *dev, usb_address_t *address)
     342static int request_address(ddf_fun_t *fun, usb_speed_t ignored,
     343    usb_address_t *address)
    397344{
    398345        usb_address_t addr = usb_address_keeping_request(&addresses);
    … …  
    405352}
    406353
    407 static int release_address(device_t *dev, usb_address_t address)
     354static int release_address(ddf_fun_t *fun, usb_address_t address)
    408355{
    409356        return usb_address_keeping_release(&addresses, address);
    410357}
    411358
    412 static int bind_address(device_t *dev, usb_address_t address,
     359static int bind_address(ddf_fun_t *fun, usb_address_t address,
    413360    devman_handle_t handle)
    414361{
    … …  
    417364}
    418365
    419 static int tell_address(device_t *dev, devman_handle_t handle,
     366static int usb_iface_get_hc_handle_rh_impl(ddf_fun_t *root_hub_fun,
     367    devman_handle_t *handle)
     368{
     369        ddf_fun_t *hc_fun = root_hub_fun->driver_data;
     370        assert(hc_fun != NULL);
     371
     372        *handle = hc_fun->handle;
     373
     374        usb_log_debug("usb_iface_get_hc_handle_rh_impl returns %zu\n", *handle);
     375
     376        return EOK;
     377}
     378
     379static int tell_address_rh(ddf_fun_t *root_hub_fun, devman_handle_t handle,
    420380    usb_address_t *address)
    421381{
    422         usb_address_t addr = usb_address_keeping_find(&addresses, handle);
    423         if (addr < 0) {
    424                 return addr;
    425         }
    426 
    427         *address = addr;
    428         return EOK;
     382        ddf_fun_t *hc_fun = root_hub_fun->driver_data;
     383        assert(hc_fun != NULL);
     384
     385        return tell_address(hc_fun, root_hub_fun->handle, address);
    429386}
    430387
    … …  
    435392
    436393usbhc_iface_t vhc_iface = {
    437         .tell_address = tell_address,
    438 
    439394        .reserve_default_address = reserve_default_address,
    440395        .release_default_address = release_default_address,
    … …  
    446401        .interrupt_in = interrupt_in,
    447402
    448         .control_write_setup = control_write_setup,
    449         .control_write_data = control_write_data,
    450         .control_write_status = control_write_status,
    451 
    452403        .control_write = control_write,
    453 
    454         .control_read_setup = control_read_setup,
    455         .control_read_data = control_read_data,
    456         .control_read_status = control_read_status,
    457 
    458404        .control_read = control_read
    459405};
     406
     407usb_iface_t vhc_usb_iface = {
     408        .get_hc_handle = usb_iface_get_hc_handle_hc_impl,
     409        .get_address = tell_address
     410};
     411
     412usb_iface_t rh_usb_iface = {
     413        .get_hc_handle = usb_iface_get_hc_handle_rh_impl,
     414        .get_address = tell_address_rh
     415};
     416
    460417
    461418/**
Note: See TracChangeset for help on using the changeset viewer.