Changes in / [8cd1aa5e:31860b7] in mainline


Ignore:
Location:
uspace
Files:
1 deleted
10 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/root/root.c

    r8cd1aa5e r31860b7  
    7272static int add_platform_child(device_t *parent)
    7373{
     74        return EOK;
    7475        printf(NAME ": adding new child for platform device.\n");
    7576       

  • uspace/drv/uhci/main.c

    r8cd1aa5e r31860b7  
    7777        /*
    7878         * We need to announce the presence of our root hub.
    79          * Commented out until the problem which causes the whole task to
    80          * block is solved.
    8179         */
    82         //usb_hcd_add_root_hub(device);
     80        usb_hcd_add_root_hub(device);
    8381
    8482        return EOK;

  • uspace/drv/uhci/uhci.ma

    r8cd1aa5e r31860b7  
    1 10 pci/ven=8086&dev=7020
     10 pci/ven=8086&dev=7020
    2210 usb&hc=uhci
    3310 usb&hc=uhci&hub

  • uspace/drv/vhc/connhost.c

    r8cd1aa5e r31860b7  
    4141#include "hc.h"
    4242
    43 typedef struct {
    44         usb_direction_t direction;
    45         usb_hcd_transfer_callback_out_t out_callback;
    46         usb_hcd_transfer_callback_in_t in_callback;
    47         usb_hc_device_t *hc;
    48         void *arg;
    49 } transfer_info_t;
    50 
    51 static void universal_callback(void *buffer, size_t size,
    52     usb_transaction_outcome_t outcome, void *arg)
    53 {
    54         transfer_info_t *transfer = (transfer_info_t *) arg;
    55 
    56         switch (transfer->direction) {
    57                 case USB_DIRECTION_IN:
    58                         transfer->in_callback(transfer->hc,
    59                             size, outcome,
    60                             transfer->arg);
    61                         break;
    62                 case USB_DIRECTION_OUT:
    63                         transfer->out_callback(transfer->hc,
    64                             outcome,
    65                             transfer->arg);
    66                         break;
    67                 default:
    68                         assert(false && "unreachable");
    69                         break;
    70         }
    71 
    72         free(transfer);
    73 }
    74 
    75 static transfer_info_t *create_transfer_info(usb_hc_device_t *hc,
    76     usb_direction_t direction, void *arg)
    77 {
    78         transfer_info_t *transfer = malloc(sizeof(transfer_info_t));
    79 
    80         transfer->direction = direction;
    81         transfer->in_callback = NULL;
    82         transfer->out_callback = NULL;
    83         transfer->arg = arg;
    84         transfer->hc = hc;
    85 
    86         return transfer;
    87 }
    88 
    8943static int enqueue_transfer_out(usb_hc_device_t *hc,
    9044    usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint,
    … …  
    9650            usb_str_transfer_type(endpoint->transfer_type),
    9751            size);
    98 
    99         transfer_info_t *transfer
    100             = create_transfer_info(hc, USB_DIRECTION_OUT, arg);
    101         transfer->out_callback = callback;
    102 
    103         usb_target_t target = {
    104                 .address = dev->address,
    105                 .endpoint = endpoint->endpoint
    106         };
    107 
    108         hc_add_transaction_to_device(false, target, buffer, size,
    109             universal_callback, transfer);
    110 
    111         return EOK;
     52        return ENOTSUP;
    11253}
    11354
    … …  
    12162            usb_str_transfer_type(endpoint->transfer_type),
    12263            size);
    123 
    124         transfer_info_t *transfer
    125             = create_transfer_info(hc, USB_DIRECTION_OUT, arg);
    126         transfer->out_callback = callback;
    127 
    128         usb_target_t target = {
    129                 .address = dev->address,
    130                 .endpoint = endpoint->endpoint
    131         };
    132 
    133         hc_add_transaction_to_device(true, target, buffer, size,
    134             universal_callback, transfer);
    135 
    136         return EOK;
     64        return ENOTSUP;
    13765}
    13866
    … …  
    14674            usb_str_transfer_type(endpoint->transfer_type),
    14775            size);
    148 
    149         transfer_info_t *transfer
    150             = create_transfer_info(hc, USB_DIRECTION_IN, arg);
    151         transfer->in_callback = callback;
    152 
    153         usb_target_t target = {
    154                 .address = dev->address,
    155                 .endpoint = endpoint->endpoint
    156         };
    157 
    158         hc_add_transaction_from_device(target, buffer, size,
    159             universal_callback, transfer);
    160 
    161         return EOK;
     76        return ENOTSUP;
    16277}
    16378

  • uspace/drv/vhc/hc.c

    r8cd1aa5e r31860b7  
    131131               
    132132                process_transaction_with_outcome(transaction, outcome);
    133 
     133               
    134134                free(transaction);
    135135        }

  • uspace/drv/vhc/hc.h

    r8cd1aa5e r31860b7  
    7979    hc_transaction_done_callback_t callback, void * arg);
    8080
     81int hc_fillin_transaction_from_device(usb_target_t target,
     82    void * buffer, size_t len);
    8183
    8284#endif

  • uspace/drv/vhc/hcd.c

    r8cd1aa5e r31860b7  
    6969
    7070        /*
    71          * Initialize our hub and announce its presence.
     71         * Announce that we have some root hub present.
    7272         */
    73         hub_init();
    7473        usb_hcd_add_root_hub(dev);
    7574
    … …  
    8483};
    8584
    86 /** Fibril wrapper for HC transaction manager.
    87  *
    88  * @param arg Not used.
    89  * @return Nothing, return argument is unreachable.
    90  */
    91 static int hc_manager_fibril(void *arg)
    92 {
    93         hc_manager();
    94         return EOK;
    95 }
    96 
    9785int main(int argc, char * argv[])
    9886{       
    9987        printf("%s: virtual USB host controller driver.\n", NAME);
    10088
    101         debug_level = 10;
    102 
    103         fid_t fid = fibril_create(hc_manager_fibril, NULL);
    104         if (fid == 0) {
    105                 printf("%s: failed to start HC manager fibril\n", NAME);
    106                 return ENOMEM;
    107         }
    108         fibril_add_ready(fid);
    109 
    110         /*
    111          * Temporary workaround. Wait a little bit to be the last driver
    112          * in devman output.
    113          */
    114         sleep(4);
     89        debug_level = 5;
    11590
    11691        return usb_hcd_main(&vhc_driver);

  • uspace/lib/usb/Makefile

    r8cd1aa5e r31860b7  
    3434SOURCES = \
    3535        src/hcdhubd.c \
    36         src/localdrv.c \
    3736        src/usb.c \
    3837        src/usbdrv.c

  • uspace/lib/usb/include/usb/hcdhubd.h

    r8cd1aa5e r31860b7  
    159159    void *, size_t, size_t *, usb_handle_t *);
    160160
    161 int usb_hc_async_control_write_setup(usb_hc_device_t *, usb_target_t,
    162     void *, size_t, usb_handle_t *);
    163 int usb_hc_async_control_write_data(usb_hc_device_t *, usb_target_t,
    164     void *, size_t, usb_handle_t *);
    165 int usb_hc_async_control_write_status(usb_hc_device_t *, usb_target_t,
    166     usb_handle_t *);
    167 
    168 int usb_hc_async_control_read_setup(usb_hc_device_t *, usb_target_t,
    169     void *, size_t, usb_handle_t *);
    170 int usb_hc_async_control_read_data(usb_hc_device_t *, usb_target_t,
    171     void *, size_t, size_t *, usb_handle_t *);
    172 int usb_hc_async_control_read_status(usb_hc_device_t *, usb_target_t,
    173     usb_handle_t *);
    174 
    175161int usb_hc_async_wait_for(usb_handle_t);
    176162

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

    r8cd1aa5e r31860b7  
    3434 */
    3535#include <usb/hcdhubd.h>
    36 #include <usb/devreq.h>
    3736#include <usbhc_iface.h>
    3837#include <driver.h>
    … …  
    5655        .interfaces[USBHC_DEV_IFACE] = &usb_interface
    5756};
    58 
    59 static void set_hub_address(usb_hc_device_t *hc, usb_address_t address);
    6057
    6158/** Callback when new device is detected and must be handled by this driver.
    … …  
    10198                return EOK;
    10299        } else {
    103                 usb_hc_device_t *hc = list_get_instance(hc_list.next, usb_hc_device_t, link);
    104                 set_hub_address(hc, 5);
    105 
     100                printf("%s: hub added, hurrah!\n", hc_driver->name);
    106101                /*
    107102                 * We are some (probably deeply nested) hub.
    … …  
    109104                 * connected devices.
    110105                 */
    111 
    112106                return ENOTSUP;
    113107        }
    114 }
    115 
    116 /** Sample usage of usb_hc_async functions.
    117  * This function sets hub address using standard SET_ADDRESS request.
    118  *
    119  * @warning This function shall be removed once you are familiar with
    120  * the usb_hc_ API.
    121  *
    122  * @param hc Host controller the hub belongs to.
    123  * @param address New hub address.
    124  */
    125 static void set_hub_address(usb_hc_device_t *hc, usb_address_t address)
    126 {
    127         printf("%s: setting hub address to %d\n", hc->generic->name, address);
    128         usb_target_t target = {0, 0};
    129         usb_handle_t handle;
    130         int rc;
    131 
    132         usb_device_request_setup_packet_t setup_packet = {
    133                 .request_type = 0,
    134                 .request = USB_DEVREQ_SET_ADDRESS,
    135                 .index = 0,
    136                 .length = 0,
    137         };
    138         setup_packet.value = address;
    139 
    140         rc = usb_hc_async_control_write_setup(hc, target,
    141             &setup_packet, sizeof(setup_packet), &handle);
    142         if (rc != EOK) {
    143                 return;
    144         }
    145 
    146         rc = usb_hc_async_wait_for(handle);
    147         if (rc != EOK) {
    148                 return;
    149         }
    150 
    151         rc = usb_hc_async_control_write_status(hc, target, &handle);
    152         if (rc != EOK) {
    153                 return;
    154         }
    155 
    156         rc = usb_hc_async_wait_for(handle);
    157         if (rc != EOK) {
    158                 return;
    159         }
    160 
    161         printf("%s: hub address changed\n", hc->generic->name);
    162108}
    163109
    … …  
    266212
    267213        /*
     214         * For testing/debugging purposes only.
     215         * Try to send some data to default USB address.
     216         */
     217        usb_target_t target = {0, 0};
     218        usb_handle_t handle = 0;
     219        char *data = (char *) "Hello, World!";
     220
     221
     222        (void)usb_hc_async_interrupt_out(dev, target, data, str_length(data), &handle);
     223        (void)usb_hc_async_wait_for(handle);
     224
     225        /*
    268226         * Announce presence of child device.
    269227         */
    … …  
    314272}
    315273
     274/** Issue interrupt OUT transfer to HC driven by current task.
     275 *
     276 * @param hc Host controller to handle the transfer.
     277 * @param target Target device address.
     278 * @param buffer Data buffer.
     279 * @param size Buffer size.
     280 * @param handle Transfer handle.
     281 * @return Error code.
     282 */
     283int usb_hc_async_interrupt_out(usb_hc_device_t *hc, usb_target_t target,
     284    void *buffer, size_t size,
     285    usb_handle_t *handle)
     286{
     287        if ((hc->transfer_ops == NULL)
     288            || (hc->transfer_ops->transfer_out == NULL)) {
     289                return ENOTSUP;
     290        }
     291
     292        /*
     293         * For debugging purposes only.
     294         * We need to find appropriate device in list of managed device
     295         * and pass it to the transfer callback function.
     296         */
     297        usb_hcd_attached_device_info_t dev = {
     298                .address = target.address,
     299                .endpoint_count = 0,
     300                .endpoints = NULL,
     301        };
     302        usb_hc_endpoint_info_t endpoint = {
     303                .endpoint = target.endpoint,
     304                .transfer_type = USB_TRANSFER_INTERRUPT,
     305                .direction = USB_DIRECTION_OUT,
     306                .data_toggle = 0
     307        };
     308
     309        hc->transfer_ops->transfer_out(hc, &dev, &endpoint, buffer, size, NULL, NULL);
     310
     311        *handle = (usb_handle_t)NULL;
     312
     313        return EOK;
     314}
     315
     316
     317/** Issue interrupt IN transfer to HC driven by current task.
     318 *
     319 * @warning The @p buffer and @p actual_size parameters shall not be
     320 * touched until this transfer is waited for by usb_hc_async_wait_for().
     321 *
     322 * @param hc Host controller to handle the transfer.
     323 * @param target Target device address.
     324 * @param buffer Data buffer.
     325 * @param size Buffer size.
     326 * @param actual_size Size of actually transferred data.
     327 * @param handle Transfer handle.
     328 * @return Error code.
     329 */
     330int usb_hc_async_interrupt_in(usb_hc_device_t *hc, usb_target_t target,
     331    void *buffer, size_t size, size_t *actual_size,
     332    usb_handle_t *handle)
     333{
     334        /*
     335         * TODO: verify that given endpoint is of interrupt type and
     336         * call hc->transfer_ops->transfer_in()
     337         */
     338        return ENOTSUP;
     339}
     340
     341/** Wait for transfer to complete.
     342 *
     343 * @param handle Transfer handle.
     344 * @return Error code.
     345 */
     346int usb_hc_async_wait_for(usb_handle_t handle)
     347{
     348        return ENOTSUP;
     349}
     350
    316351/**
    317352 * @}
Note: See TracChangeset for help on using the changeset viewer.