Changeset 2e85b3c in mainline


Ignore:
Timestamp:
2011-02-16T18:22:43Z (13 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f4c87aa9
Parents:
600733e (diff), ec59693 (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:

Development branch

Location:
uspace
Files:
5 added
6 deleted
30 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/tester/adt/usbaddrkeep.c

    r600733e r2e85b3c  
    2929#include <stdio.h>
    3030#include <stdlib.h>
    31 #include <usb/hcd.h>
     31#include <usb/addrkeep.h>
    3232#include <errno.h>
    3333#include "../tester.h"

  • uspace/app/virtusbkbd/kbdconfig.c

    r600733e r2e85b3c  
    6161        .endpoint_count = 1,
    6262        .interface_class = USB_CLASS_HID,
    63         .interface_subclass = 0,
     63        .interface_subclass = USB_HID_SUBCLASS_BOOT,
    6464        .interface_protocol = USB_HID_PROTOCOL_KEYBOARD,
    6565        .str_interface = 0

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

    r600733e r2e85b3c  
    103103/*----------------------------------------------------------------------------*/
    104104static int interrupt_out(device_t *dev, usb_target_t target,
    105     void *data, size_t size,
    106     usbhc_iface_transfer_out_callback_t callback, void *arg)
    107 {
    108         size_t max_packet_size = 8;
     105    size_t max_packet_size,
     106    void *data, size_t size,
     107    usbhc_iface_transfer_out_callback_t callback, void *arg)
     108{
    109109        dev_speed_t speed = FULL_SPEED;
    110110
    … …  
    118118/*----------------------------------------------------------------------------*/
    119119static int interrupt_in(device_t *dev, usb_target_t target,
    120     void *data, size_t size,
    121     usbhc_iface_transfer_in_callback_t callback, void *arg)
    122 {
    123         size_t max_packet_size = 4;
     120    size_t max_packet_size,
     121    void *data, size_t size,
     122    usbhc_iface_transfer_in_callback_t callback, void *arg)
     123{
    124124        dev_speed_t speed = FULL_SPEED;
    125125
    … …  
    133133/*----------------------------------------------------------------------------*/
    134134static int control_write(device_t *dev, usb_target_t target,
     135    size_t max_packet_size,
    135136    void *setup_data, size_t setup_size, void *data, size_t size,
    136137    usbhc_iface_transfer_out_callback_t callback, void *arg)
    137138{
    138         size_t max_packet_size = 8;
    139139        dev_speed_t speed = FULL_SPEED;
    140140
    … …  
    149149/*----------------------------------------------------------------------------*/
    150150static int control_read(device_t *dev, usb_target_t target,
     151    size_t max_packet_size,
    151152    void *setup_data, size_t setup_size, void *data, size_t size,
    152153    usbhc_iface_transfer_in_callback_t callback, void *arg)
    153154{
    154         size_t max_packet_size = 8;
    155155        dev_speed_t speed = FULL_SPEED;
    156156
    … …  
    165165/*----------------------------------------------------------------------------*/
    166166static int control_write_setup(device_t *dev, usb_target_t target,
    167     void *data, size_t size,
    168     usbhc_iface_transfer_out_callback_t callback, void *arg)
     167    size_t max_packet_size,
     168    void *data, size_t size,
     169    usbhc_iface_transfer_out_callback_t callback, void *arg)
     170{
     171        dev_speed_t speed = FULL_SPEED;
     172
     173        usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
     174        batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
     175            max_packet_size, speed, NULL, 0, data, size, NULL, callback, arg);
     176        if (!batch)
     177                return ENOMEM;
     178        batch_control_setup_old(batch);
     179        return EOK;
     180}
     181/*----------------------------------------------------------------------------*/
     182static int control_write_data(device_t *dev, usb_target_t target,
     183    size_t max_packet_size,
     184    void *data, size_t size,
     185    usbhc_iface_transfer_out_callback_t callback, void *arg)
     186{
     187        dev_speed_t speed = FULL_SPEED;
     188
     189        usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
     190        batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
     191            max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg);
     192        if (!batch)
     193                return ENOMEM;
     194        batch_control_write_data_old(batch);
     195        return EOK;
     196}
     197/*----------------------------------------------------------------------------*/
     198static int control_write_status(device_t *dev, usb_target_t target,
     199    usbhc_iface_transfer_in_callback_t callback, void *arg)
    169200{
    170201        size_t max_packet_size = 8;
    … …  
    173204        usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
    174205        batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
     206            max_packet_size, speed, NULL, 0, NULL, 0, callback, NULL, arg);
     207        if (!batch)
     208                return ENOMEM;
     209        batch_control_write_status_old(batch);
     210        return EOK;
     211}
     212/*----------------------------------------------------------------------------*/
     213static int control_read_setup(device_t *dev, usb_target_t target,
     214    size_t max_packet_size,
     215    void *data, size_t size,
     216    usbhc_iface_transfer_out_callback_t callback, void *arg)
     217{
     218        dev_speed_t speed = FULL_SPEED;
     219
     220        usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
     221        batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
    175222            max_packet_size, speed, NULL, 0, data, size, NULL, callback, arg);
    176223        if (!batch)
    … …  
    180227}
    181228/*----------------------------------------------------------------------------*/
    182 static int control_write_data(device_t *dev, usb_target_t target,
    183     void *data, size_t size,
    184     usbhc_iface_transfer_out_callback_t callback, void *arg)
    185 {
    186         size_t max_packet_size = 8;
    187         dev_speed_t speed = FULL_SPEED;
    188 
    189         usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
    190         batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
    191             max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg);
    192         if (!batch)
    193                 return ENOMEM;
    194         batch_control_write_data_old(batch);
    195         return EOK;
    196 }
    197 /*----------------------------------------------------------------------------*/
    198 static int control_write_status(device_t *dev, usb_target_t target,
    199     usbhc_iface_transfer_in_callback_t callback, void *arg)
    200 {
    201         size_t max_packet_size = 8;
    202         dev_speed_t speed = FULL_SPEED;
    203 
    204         usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
    205         batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
    206             max_packet_size, speed, NULL, 0, NULL, 0, callback, NULL, arg);
    207         if (!batch)
    208                 return ENOMEM;
    209         batch_control_write_status_old(batch);
    210         return EOK;
    211 }
    212 /*----------------------------------------------------------------------------*/
    213 static int control_read_setup(device_t *dev, usb_target_t target,
    214     void *data, size_t size,
    215     usbhc_iface_transfer_out_callback_t callback, void *arg)
    216 {
    217         size_t max_packet_size = 8;
    218         dev_speed_t speed = FULL_SPEED;
    219 
    220         usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
    221         batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
    222             max_packet_size, speed, NULL, 0, data, size, NULL, callback, arg);
    223         if (!batch)
    224                 return ENOMEM;
    225         batch_control_setup_old(batch);
    226         return EOK;
    227 }
    228 /*----------------------------------------------------------------------------*/
    229229static int control_read_data(device_t *dev, usb_target_t target,
    230     void *data, size_t size,
    231     usbhc_iface_transfer_in_callback_t callback, void *arg)
    232 {
    233         size_t max_packet_size = 8;
     230    size_t max_packet_size,
     231    void *data, size_t size,
     232    usbhc_iface_transfer_in_callback_t callback, void *arg)
     233{
    234234        dev_speed_t speed = FULL_SPEED;
    235235

  • uspace/drv/uhci-rhd/port.c

    r600733e r2e85b3c  
    3636
    3737#include <usb/usb.h>    /* usb_address_t */
    38 #include <usb/usbdrv.h> /* usb_drv_*     */
     38#include <usb/usbdevice.h>
     39#include <usb/hub.h>
     40#include <usb/request.h>
    3941#include <usb/debug.h>
    4042#include <usb/recognise.h>
    … …  
    5860        port->attached_device = 0;
    5961        port->rh = rh;
    60         port->hc_phone = parent_phone;
     62        int rc = usb_hc_connection_initialize_from_device(
     63            &port->hc_connection, rh);
     64        if (rc != EOK) {
     65                usb_log_error("Failed to initialize connection to HC.");
     66                return rc;
     67        }
    6168
    6269        port->checker = fibril_create(uhci_port_check, port);
    … …  
    98105
    99106                if (port_status & STATUS_CONNECTED_CHANGED) {
     107                        int rc = usb_hc_connection_open(
     108                            &port_instance->hc_connection);
     109                        if (rc != EOK) {
     110                                usb_log_error("Failed to connect to HC.");
     111                                goto next;
     112                        }
     113
    100114                        if (port_status & STATUS_CONNECTED) {
    101115                                /* new device */
    … …  
    104118                                uhci_port_remove_device(port_instance);
    105119                        }
     120
     121                        rc = usb_hc_connection_close(
     122                            &port_instance->hc_connection);
     123                        if (rc != EOK) {
     124                                usb_log_error("Failed to disconnect from HC.");
     125                                goto next;
     126                        }
    106127                }
     128        next:
    107129                async_usleep(port_instance->wait_period_usec);
    108130        }
    … …  
    113135{
    114136        assert(port);
    115         assert(port->hc_phone);
     137        assert(usb_hc_connection_is_opened(&port->hc_connection));
    116138
    117139        usb_log_info("Adding new device on port %d.\n", port->number);
    118140
    119141        /* get address of the future device */
    120         const usb_address_t usb_address = usb_drv_request_address(port->hc_phone);
     142        const usb_address_t usb_address = usb_hc_request_address(&port->hc_connection);
    121143
    122144        if (usb_address <= 0) {
    … …  
    128150
    129151        /* get default address */
    130         int ret = usb_drv_reserve_default_address(port->hc_phone);
     152        int ret = usb_hc_reserve_default_address(&port->hc_connection);
    131153        if (ret != EOK) {
    132154                usb_log_error("Failed to reserve default address on port %d.\n",
    133155                    port->number);
    134                 int ret2 =
    135                   usb_drv_release_address(port->hc_phone, usb_address);
     156                int ret2 = usb_hc_unregister_device(&port->hc_connection,
     157                    usb_address);
    136158                if (ret2 != EOK) {
    137159                        usb_log_fatal("Failed to return requested address on port %d.\n",
    … …  
    174196        }
    175197
    176         /* assign address to device */
    177         ret = usb_drv_req_set_address(port->hc_phone, 0, usb_address);
     198        /*
     199         * Initialize connection to the device.
     200         */
     201        /* FIXME: check for errors. */
     202        usb_device_connection_t new_dev_connection;
     203        usb_endpoint_pipe_t new_dev_ctrl_pipe;
     204        usb_device_connection_initialize_on_default_address(
     205            &new_dev_connection, &port->hc_connection);
     206        usb_endpoint_pipe_initialize_default_control(&new_dev_ctrl_pipe,
     207            &new_dev_connection);
     208
     209        /*
     210         * Assign new address to the device. This function updates
     211         * the backing connection to still point to the same device.
     212         */
     213        /* FIXME: check for errors. */
     214        usb_endpoint_pipe_start_session(&new_dev_ctrl_pipe);
     215        ret = usb_request_set_address(&new_dev_ctrl_pipe, usb_address);
     216        usb_endpoint_pipe_end_session(&new_dev_ctrl_pipe);
    178217
    179218        if (ret != EOK) { /* address assigning went wrong */
    180219                usb_log_error("Failed(%d) to assign address to the device.\n", ret);
    181220                uhci_port_set_enabled(port, false);
    182                 int release = usb_drv_release_default_address(port->hc_phone);
     221                int release = usb_hc_release_default_address(&port->hc_connection);
    183222                if (release != EOK) {
    184223                        usb_log_error("Failed to release default address on port %d.\n",
    … …  
    194233
    195234        /* release default address */
    196         ret = usb_drv_release_default_address(port->hc_phone);
     235        ret = usb_hc_release_default_address(&port->hc_connection);
    197236        if (ret != EOK) {
    198237                usb_log_error("Failed to release default address on port %d.\n",
    … …  
    206245        assert(port->attached_device == 0);
    207246
    208         devman_handle_t hc_handle;
    209         ret = usb_drv_find_hc(port->rh, &hc_handle);
    210         if (ret != EOK) {
    211                 usb_log_error("Failed to get handle of host controller: %s.\n",
    212                     str_error(ret));
    213                 uhci_port_set_enabled(port, false);
    214                 return ENOMEM;
    215         }
    216 
    217         ret = usb_device_register_child_in_devman(usb_address, hc_handle,
    218             port->rh, &port->attached_device);
     247        ret = usb_device_register_child_in_devman(new_dev_connection.address,
     248            new_dev_connection.hc_handle, port->rh, &port->attached_device);
     249
    219250        if (ret != EOK) { /* something went wrong */
    220251                usb_log_error("Failed(%d) in usb_drv_register_child.\n", ret);
    … …  
    225256                port->number, usb_address, port->attached_device);
    226257
    227         ret =
    228           usb_drv_bind_address(port->hc_phone, usb_address, port->attached_device);
     258        /*
     259         * Register the device in the host controller.
     260         */
     261        usb_hc_attached_device_t new_device = {
     262                .address = new_dev_connection.address,
     263                .handle = port->attached_device
     264        };
     265
     266        ret = usb_hc_register_device(&port->hc_connection, &new_device);
    229267        // TODO: proper error check here
    230268        assert(ret == EOK);

  • uspace/drv/uhci-rhd/port.h

    r600733e r2e85b3c  
    3838#include <driver.h> /* device_t */
    3939#include <stdint.h>
     40#include <usb/usbdevice.h>
    4041
    4142#include "port_status.h"
    … …  
    4647        unsigned number;
    4748        unsigned wait_period_usec;
    48         int hc_phone;
     49        usb_hc_connection_t hc_connection;
    4950        device_t *rh;
    5051        devman_handle_t attached_device;

  • uspace/drv/usbhub/usbhub.c

    r600733e r2e85b3c  
    8484        }*/
    8585
    86         result->usb_device = usb_new(usb_hcd_attached_device_info_t);
    87         result->usb_device->address = addr;
     86        result->address = addr;
    8887
    8988        // get hub descriptor
    … …  
    155154        int opResult;
    156155        usb_target_t target;
    157         target.address = hub_info->usb_device->address;
     156        target.address = hub_info->address;
    158157        target.endpoint = 0;
    159158
    … …  
    216215        dprintf(USB_LOG_LEVEL_INFO, "hub dev added");
    217216        dprintf(USB_LOG_LEVEL_DEBUG, "\taddress %d, has %d ports ",
    218                         hub_info->usb_device->address,
     217                        hub_info->address,
    219218                        hub_info->port_count);
    220219        dprintf(USB_LOG_LEVEL_DEBUG, "\tused configuration %d",config_descriptor.configuration_number);
    … …  
    465464
    466465                usb_target_t target;
    467                 target.address = hub_info->usb_device->address;
     466                target.address = hub_info->address;
    468467                target.endpoint = 1;/// \TODO get from endpoint descriptor
    469468                dprintf(USB_LOG_LEVEL_INFO, "checking changes for hub at addr %d",
    … …  
    507506                        if (interrupt) {
    508507                                usb_hub_process_interrupt(
    509                                         hub_info, hc, port, hub_info->usb_device->address);
     508                                        hub_info, hc, port, hub_info->address);
    510509                        }
    511510                }

  • uspace/drv/usbhub/usbhub.h

    r600733e r2e85b3c  
    3636#define DRV_USBHUB_USBHUB_H
    3737
     38#include <ipc/devman.h>
     39#include <usb/usb.h>
     40#include <driver.h>
     41
    3842#define NAME "usbhub"
    39 
    40 #include "usb/hcdhubd.h"
    4143
    4244/** basic information about device attached to hub */
    … …  
    5254        /** attached device handles */
    5355        usb_hub_attached_device_t * attached_devs;
    54         /** General usb device info. */
    55         usb_hcd_attached_device_info_t * usb_device;
     56        /** USB address of the hub. */
     57        usb_address_t address;
    5658        /** General device info*/
    5759        device_t * device;
    58 
    5960} usb_hub_info_t;
    6061

  • uspace/drv/vhc/conn.h

    r600733e r2e85b3c  
    3737
    3838#include <usb/usb.h>
    39 #include <usb/hcdhubd.h>
    4039#include <usbhc_iface.h>
    4140#include "vhcd.h"
    … …  
    4443void connection_handler_host(sysarg_t);
    4544
    46 usb_hcd_transfer_ops_t vhc_transfer_ops;
    4745usbhc_iface_t vhc_iface;
    4846

  • uspace/drv/vhc/connhost.c

    r600733e r2e85b3c  
    3636#include <errno.h>
    3737#include <usb/usb.h>
    38 #include <usb/hcd.h>
     38#include <usb/addrkeep.h>
    3939
    4040#include "vhcd.h"
    … …  
    6464
    6565static void universal_callback(void *buffer, size_t size,
    66     usb_transaction_outcome_t outcome, void *arg)
     66    int outcome, void *arg)
    6767{
    6868        transfer_info_t *transfer = (transfer_info_t *) arg;
    … …  
    107107
    108108static void control_abort_prematurely(control_transfer_info_t *transfer,
    109     size_t size, usb_transaction_outcome_t outcome)
     109    size_t size, int outcome)
    110110{
    111111        switch (transfer->direction) {
    … …  
    127127
    128128static void control_callback_two(void *buffer, size_t size,
    129     usb_transaction_outcome_t outcome, void *arg)
     129    int outcome, void *arg)
    130130{
    131131        control_transfer_info_t *ctrl_transfer = (control_transfer_info_t *) arg;
    132132
    133         if (outcome != USB_OUTCOME_OK) {
     133        if (outcome != EOK) {
    134134                control_abort_prematurely(ctrl_transfer, outcome, size);
    135135                free(ctrl_transfer);
    … …  
    165165
    166166static void control_callback_one(void *buffer, size_t size,
    167     usb_transaction_outcome_t outcome, void *arg)
     167    int outcome, void *arg)
    168168{
    169169        control_transfer_info_t *transfer = (control_transfer_info_t *) arg;
    170170
    171         if (outcome != USB_OUTCOME_OK) {
     171        if (outcome != EOK) {
    172172                control_abort_prematurely(transfer, outcome, size);
    173173                free(transfer);
    … …  
    276276
    277277static int interrupt_out(device_t *dev, usb_target_t target,
     278    size_t max_packet_size,
    278279    void *data, size_t size,
    279280    usbhc_iface_transfer_out_callback_t callback, void *arg)
    … …  
    285286
    286287static int interrupt_in(device_t *dev, usb_target_t target,
     288    size_t max_packet_size,
    287289    void *data, size_t size,
    288290    usbhc_iface_transfer_in_callback_t callback, void *arg)
    … …  
    294296
    295297static int control_write_setup(device_t *dev, usb_target_t target,
     298    size_t max_packet_size,
    296299    void *data, size_t size,
    297300    usbhc_iface_transfer_out_callback_t callback, void *arg)
    … …  
    303306
    304307static int control_write_data(device_t *dev, usb_target_t target,
     308    size_t max_packet_size,
    305309    void *data, size_t size,
    306310    usbhc_iface_transfer_out_callback_t callback, void *arg)
    … …  
    320324
    321325static int control_write(device_t *dev, usb_target_t target,
     326    size_t max_packet_size,
    322327    void *setup_packet, size_t setup_packet_size,
    323328    void *data, size_t data_size,
    … …  
    337342
    338343static int control_read_setup(device_t *dev, usb_target_t target,
     344    size_t max_packet_size,
    339345    void *data, size_t size,
    340346    usbhc_iface_transfer_out_callback_t callback, void *arg)
    … …  
    346352
    347353static int control_read_data(device_t *dev, usb_target_t target,
     354    size_t max_packet_size,
    348355    void *data, size_t size,
    349356    usbhc_iface_transfer_in_callback_t callback, void *arg)
    … …  
    363370
    364371static int control_read(device_t *dev, usb_target_t target,
     372    size_t max_packet_size,
    365373    void *setup_packet, size_t setup_packet_size,
    366374    void *data, size_t data_size,

  • uspace/drv/vhc/devices.c

    r600733e r2e85b3c  
    112112 * @param transaction Transaction to be sent over the bus.
    113113 */
    114 usb_transaction_outcome_t virtdev_send_to_all(transaction_t *transaction)
     114int virtdev_send_to_all(transaction_t *transaction)
    115115{
    116116        /* For easier debugging. */
    … …  
    126126                        assert(false && "unreachable branch in switch()");
    127127        }
    128         usb_transaction_outcome_t outcome = USB_OUTCOME_BABBLE;
     128        int outcome = EBADCHECKSUM;
    129129
    130130        link_t *pos;
    … …  
    185185                 */
    186186                if (rc == EOK) {
    187                         outcome = USB_OUTCOME_OK;
     187                        outcome = EOK;
    188188                }
    189189        }
    … …  
    221221                                break;
    222222                }
    223                 outcome = USB_OUTCOME_OK;
     223                outcome = EOK;
    224224        }
    225225       

  • uspace/drv/vhc/devices.h

    r600733e r2e85b3c  
    5454virtdev_connection_t *virtdev_find(sysarg_t);
    5555void virtdev_destroy_device(virtdev_connection_t *);
    56 usb_transaction_outcome_t virtdev_send_to_all(transaction_t *);
     56int virtdev_send_to_all(transaction_t *);
    5757
    5858#endif

  • uspace/drv/vhc/hc.c

    r600733e r2e85b3c  
    8989 */
    9090static void process_transaction_with_outcome(transaction_t * transaction,
    91     usb_transaction_outcome_t outcome)
     91    int outcome)
    9292{
    9393        usb_log_debug2("Transaction " TRANSACTION_FORMAT " done: %s.\n",
    9494            TRANSACTION_PRINTF(*transaction),
    95             usb_str_transaction_outcome(outcome));
     95            str_error(outcome));
    9696       
    9797        transaction->callback(transaction->buffer, transaction->actual_len,
    … …  
    127127                    TRANSACTION_PRINTF(*transaction), ports);
    128128
    129                 usb_transaction_outcome_t outcome;
     129                int outcome;
    130130                outcome = virtdev_send_to_all(transaction);
    131131               

  • uspace/drv/vhc/hc.h

    r600733e r2e85b3c  
    4747 */
    4848typedef void (*hc_transaction_done_callback_t)(void *buffer, size_t size,
    49     usb_transaction_outcome_t outcome, void *arg);
     49    int outcome, void *arg);
    5050
    5151/** Pending transaction details. */

  • uspace/lib/c/generic/str_error.c

    r600733e r2e85b3c  
    3333 */
    3434
     35#include <errno.h>
    3536#include <str_error.h>
    3637#include <stdio.h>
    … …  
    6364static fibril_local char noerr[NOERR_LEN];
    6465
    65 const char *str_error(const int errno)
     66const char *str_error(const int e)
    6667{
    67         if ((errno <= 0) && (errno >= MIN_ERRNO))
    68                 return err_desc[-errno];
     68        if ((e <= 0) && (e >= MIN_ERRNO))
     69                return err_desc[-e];
    6970       
    70         snprintf(noerr, NOERR_LEN, "Unkown error code %d", errno);
     71        /* Ad hoc descriptions of error codes interesting for USB. */
     72        switch (e) {
     73                case EBADCHECKSUM:
     74                        return "Bad checksum";
     75                case EAGAIN:
     76                        return "Resource temporarily unavailable";
     77                default:
     78                        break;
     79        }
     80
     81        snprintf(noerr, NOERR_LEN, "Unkown error code %d", e);
    7182        return noerr;
    7283}

  • uspace/lib/c/include/errno.h

    r600733e r2e85b3c  
    5656#define EMLINK        (-266)
    5757
     58/** Bad checksum. */
     59#define EBADCHECKSUM  (-300)
     60
    5861/** An API function is called while another blocking function is in progress. */
    5962#define EINPROGRESS  (-10036)

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

    r600733e r2e85b3c  
    4040
    4141#define USB_MAX_PAYLOAD_SIZE 1020
     42#define HACK_MAX_PACKET_SIZE 8
     43#define HACK_MAX_PACKET_SIZE_INTERRUPT_IN 4
    4244
    4345static void remote_usbhc_get_address(device_t *, void *, ipc_callid_t, ipc_call_t *);
    … …  
    240242
    241243static void callback_out(device_t *device,
    242     usb_transaction_outcome_t outcome, void *arg)
     244    int outcome, void *arg)
    243245{
    244246        async_transaction_t *trans = (async_transaction_t *)arg;
    … …  
    250252
    251253static void callback_in(device_t *device,
    252     usb_transaction_outcome_t outcome, size_t actual_size, void *arg)
     254    int outcome, size_t actual_size, void *arg)
    253255{
    254256        async_transaction_t *trans = (async_transaction_t *)arg;
    255257
    256         if (outcome != USB_OUTCOME_OK) {
     258        if (outcome != EOK) {
    257259                async_answer_0(trans->caller, outcome);
    258260                if (trans->data_caller) {
    … …  
    270272        }
    271273
    272         async_answer_0(trans->caller, USB_OUTCOME_OK);
     274        async_answer_0(trans->caller, EOK);
    273275
    274276        async_transaction_destroy(trans);
    … …  
    322324        trans->size = len;
    323325
    324         int rc = transfer_func(device, target, buffer, len,
     326        int rc = transfer_func(device, target, HACK_MAX_PACKET_SIZE,
     327            buffer, len,
    325328            callback_out, trans);
    326329
    … …  
    368371        trans->size = len;
    369372
    370         int rc = transfer_func(device, target, trans->buffer, len,
     373        int rc = transfer_func(device, target, HACK_MAX_PACKET_SIZE_INTERRUPT_IN,
     374            trans->buffer, len,
    371375            callback_in, trans);
    372376
    … …  
    540544                .endpoint = DEV_IPC_GET_ARG2(*call)
    541545        };
     546        size_t data_buffer_len = DEV_IPC_GET_ARG3(*call);
    542547
    543548        int rc;
    … …  
    546551        void *data_buffer = NULL;
    547552        size_t setup_packet_len = 0;
    548         size_t data_buffer_len = 0;
    549553
    550554        rc = async_data_write_accept(&setup_packet, false,
    … …  
    554558                return;
    555559        }
    556         rc = async_data_write_accept(&data_buffer, false,
    557             1, USB_MAX_PAYLOAD_SIZE, 0, &data_buffer_len);
    558         if (rc != EOK) {
    559                 async_answer_0(callid, rc);
    560                 free(setup_packet);
    561                 return;
     560
     561        if (data_buffer_len > 0) {
     562                rc = async_data_write_accept(&data_buffer, false,
     563                    1, USB_MAX_PAYLOAD_SIZE, 0, &data_buffer_len);
     564                if (rc != EOK) {
     565                        async_answer_0(callid, rc);
     566                        free(setup_packet);
     567                        return;
     568                }
    562569        }
    563570
    … …  
    573580        trans->size = data_buffer_len;
    574581
    575         rc = usb_iface->control_write(device, target,
     582        rc = usb_iface->control_write(device, target, HACK_MAX_PACKET_SIZE,
    576583            setup_packet, setup_packet_len,
    577584            data_buffer, data_buffer_len,
    … …  
    596603        }
    597604
    598         size_t data_len = DEV_IPC_GET_ARG3(*call);
    599605        usb_target_t target = {
    600606                .address = DEV_IPC_GET_ARG1(*call),
    … …  
    606612        void *setup_packet = NULL;
    607613        size_t setup_packet_len = 0;
     614        size_t data_len = 0;
    608615
    609616        rc = async_data_write_accept(&setup_packet, false,
    … …  
    637644        }
    638645
    639         rc = usb_iface->control_read(device, target,
     646        rc = usb_iface->control_read(device, target, HACK_MAX_PACKET_SIZE,
    640647            setup_packet, setup_packet_len,
    641648            trans->buffer, trans->size,

  • uspace/lib/drv/include/usbhc_iface.h

    r600733e r2e85b3c  
    207207/** Callback for outgoing transfer. */
    208208typedef void (*usbhc_iface_transfer_out_callback_t)(device_t *,
    209     usb_transaction_outcome_t, void *);
     209    int, void *);
    210210
    211211/** Callback for incoming transfer. */
    212212typedef void (*usbhc_iface_transfer_in_callback_t)(device_t *,
    213     usb_transaction_outcome_t, size_t, void *);
     213    int, size_t, void *);
    214214
    215215
    216216/** Out transfer processing function prototype. */
    217 typedef int (*usbhc_iface_transfer_out_t)(device_t *, usb_target_t,
     217typedef int (*usbhc_iface_transfer_out_t)(device_t *, usb_target_t, size_t,
    218218    void *, size_t,
    219219    usbhc_iface_transfer_out_callback_t, void *);
    220220
    221 /** Setup transfer processing function prototype. */
     221/** Setup transfer processing function prototype. @deprecated */
    222222typedef usbhc_iface_transfer_out_t usbhc_iface_transfer_setup_t;
    223223
    224224/** In transfer processing function prototype. */
    225 typedef int (*usbhc_iface_transfer_in_t)(device_t *, usb_target_t,
     225typedef int (*usbhc_iface_transfer_in_t)(device_t *, usb_target_t, size_t,
    226226    void *, size_t,
    227227    usbhc_iface_transfer_in_callback_t, void *);
    … …  
    251251
    252252        int (*control_write)(device_t *, usb_target_t,
     253            size_t,
    253254            void *, size_t, void *, size_t,
    254255            usbhc_iface_transfer_out_callback_t, void *);
    255256
    256257        int (*control_read)(device_t *, usb_target_t,
     258            size_t,
    257259            void *, size_t, void *, size_t,
    258260            usbhc_iface_transfer_in_callback_t, void *);

  • uspace/lib/usb/Makefile

    r600733e r2e85b3c  
    3939        src/drvpsync.c \
    4040        src/dump.c \
    41         src/hcdhubd.c \
    42         src/hcdrv.c \
    4341        src/hidparser.c \
    44         src/localdrv.c \
     42        src/hub.c \
    4543        src/pipes.c \
    4644        src/pipesinit.c \
     45        src/pipesio.c \
    4746        src/recognise.c \
    48         src/remotedrv.c \
    4947        src/request.c \
    5048        src/usb.c \
     49        src/usbdevice.c \
    5150        src/usbdrvreq.c \
    5251        src/usbdrv.c \

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

    • Property mode changed from 120000 to 100644
    r600733e r2e85b3c  
    1 hcd.h
     1/*
     2 * Copyright (c) 2010 Vojtech Horky
     3 * All rights reserved.
     4 *
     5 * Redistribution and use in source and binary forms, with or without
     6 * modification, are permitted provided that the following conditions
     7 * are met:
     8 *
     9 * - Redistributions of source code must retain the above copyright
     10 *   notice, this list of conditions and the following disclaimer.
     11 * - Redistributions in binary form must reproduce the above copyright
     12 *   notice, this list of conditions and the following disclaimer in the
     13 *   documentation and/or other materials provided with the distribution.
     14 * - The name of the author may not be used to endorse or promote products
     15 *   derived from this software without specific prior written permission.
     16 *
     17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     27 */
     28
     29/** @addtogroup libusb
     30 * @{
     31 */
     32/** @file
     33 * USB address keeping for host controller drivers.
     34 */
     35#ifndef LIBUSB_ADDRKEEP_H_
     36#define LIBUSB_ADDRKEEP_H_
     37
     38#include <usb/usb.h>
     39#include <fibril_synch.h>
     40#include <devman.h>
     41
     42/** Info about used address. */
     43typedef struct {
     44        /** Linked list member. */
     45        link_t link;
     46        /** Address. */
     47        usb_address_t address;
     48        /** Corresponding devman handle. */
     49        devman_handle_t devman_handle;
     50} usb_address_keeping_used_t;
     51
     52/** Structure for keeping track of free and used USB addresses. */
     53typedef struct {
     54        /** Head of list of used addresses. */
     55        link_t used_addresses;
     56        /** Upper bound for USB addresses. */
     57        usb_address_t max_address;
     58        /** Mutex protecting used address. */
     59        fibril_mutex_t used_addresses_guard;
     60        /** Condition variable for used addresses. */
     61        fibril_condvar_t used_addresses_condvar;
     62
     63        /** Condition variable mutex for default address. */
     64        fibril_mutex_t default_condvar_guard;
     65        /** Condition variable for default address. */
     66        fibril_condvar_t default_condvar;
     67        /** Whether is default address available. */
     68        bool default_available;
     69} usb_address_keeping_t;
     70
     71void usb_address_keeping_init(usb_address_keeping_t *, usb_address_t);
     72
     73void usb_address_keeping_reserve_default(usb_address_keeping_t *);
     74void usb_address_keeping_release_default(usb_address_keeping_t *);
     75
     76usb_address_t usb_address_keeping_request(usb_address_keeping_t *);
     77int usb_address_keeping_release(usb_address_keeping_t *, usb_address_t);
     78void usb_address_keeping_devman_bind(usb_address_keeping_t *, usb_address_t,
     79    devman_handle_t);
     80usb_address_t usb_address_keeping_find(usb_address_keeping_t *,
     81    devman_handle_t);
     82
     83#endif
     84/**
     85 * @}
     86 */

  • uspace/lib/usb/include/usb/classes/hub.h

    r600733e r2e85b3c  
    3737
    3838#include <sys/types.h>
    39 #include <usb/hcdhubd.h>
    40 
    4139
    4240/** Hub class feature selector.
    … …  
    8078    /**
    8179            D1...D0: Logical Power Switching Mode
    82             00: Ganged power switching (all ports’ power at
     80            00: Ganged power switching (all ports power at
    8381            once)
    8482            01: Individual port power switching
    … …  
    9189            00: Global Over-current Protection. The hub
    9290            reports over-current as a summation of all
    93             ports’ current draw, without a breakdown of
     91            ports current draw, without a breakdown of
    9492            individual port over-current status.
    9593            01: Individual Port Over-current Protection. The

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

    r600733e r2e85b3c  
    3131 */
    3232/** @file
    33  * Communication between device drivers and host controller driver.
     33 * USB pipes representation.
    3434 */
    3535#ifndef LIBUSB_PIPES_H_
    … …  
    3838#include <sys/types.h>
    3939#include <usb/usb.h>
     40#include <usb/usbdevice.h>
    4041#include <usb/descriptor.h>
    4142#include <ipc/devman.h>
    … …  
    114115} usb_endpoint_mapping_t;
    115116
     117int usb_device_connection_initialize_on_default_address(
     118    usb_device_connection_t *, usb_hc_connection_t *);
    116119int usb_device_connection_initialize_from_device(usb_device_connection_t *,
    117120    device_t *);
    … …  
    139142    void *, size_t);
    140143
    141 
    142 
    143 int usb_endpoint_pipe_async_read(usb_endpoint_pipe_t *, void *, size_t,
    144     size_t *, usb_handle_t *);
    145 int usb_endpoint_pipe_async_write(usb_endpoint_pipe_t *, void *, size_t,
    146     usb_handle_t *);
    147 
    148 int usb_endpoint_pipe_async_control_read(usb_endpoint_pipe_t *, void *, size_t,
    149     void *, size_t, size_t *, usb_handle_t *);
    150 int usb_endpoint_pipe_async_control_write(usb_endpoint_pipe_t *, void *, size_t,
    151     void *, size_t, usb_handle_t *);
    152 
    153 int usb_endpoint_pipe_wait_for(usb_endpoint_pipe_t *, usb_handle_t);
    154 
    155144#endif
    156145/**

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

    r600733e r2e85b3c  
    3939#include <usb/usb.h>
    4040#include <usb/pipes.h>
     41#include <ipc/devman.h>
    4142
    4243int usb_device_create_match_ids(usb_endpoint_pipe_t *, match_id_list_t *);

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

    r600733e r2e85b3c  
    8383} usb_request_recipient_t;
    8484
    85 /** USB transaction outcome. */
    86 typedef enum {
    87         USB_OUTCOME_OK,
    88         USB_OUTCOME_CRCERROR,
    89         USB_OUTCOME_BABBLE
    90 } usb_transaction_outcome_t;
    91 
    92 const char * usb_str_transaction_outcome(usb_transaction_outcome_t o);
    93 
    9485/** USB address type.
    9586 * Negative values could be used to indicate error.

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

    r600733e r2e85b3c  
    3333 * @brief Address keeping.
    3434 */
    35 #include <usb/hcd.h>
     35#include <usb/addrkeep.h>
    3636#include <errno.h>
    3737#include <assert.h>

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

    r600733e r2e85b3c  
    147147        PRINTLINE("bDeviceProtocol = 0x%02x", d->device_protocol);
    148148        PRINTLINE("bMaxPacketSize0 = %d", d->max_packet_size);
    149         PRINTLINE("idVendor = %d", d->vendor_id);
    150         PRINTLINE("idProduct = %d", d->product_id);
     149        PRINTLINE("idVendor = 0x%04x", d->vendor_id);
     150        PRINTLINE("idProduct = 0x%04x", d->product_id);
    151151        PRINTLINE("bcdDevice = %d", d->device_version);
    152152        PRINTLINE("iManufacturer = %d", d->str_manufacturer);

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

    r600733e r2e85b3c  
    3131 */
    3232/** @file
    33  * Communication between device drivers and host controller driver.
    34  *
    35  * Note on synchronousness of the operations: there is ABSOLUTELY NO
    36  * guarantee that a call to particular function will not trigger a fibril
    37  * switch.
    38  * The initialization functions may actually involve contacting some other
    39  * task, starting/ending a session might involve asynchronous IPC and since
    40  * the transfer functions uses IPC, asynchronous nature of them is obvious.
    41  * The pseudo synchronous versions for the transfers internally call the
    42  * asynchronous ones and so fibril switch is possible in them as well.
     33 * USB endpoint pipes miscellaneous functions.
    4334 */
    4435#include <usb/usb.h>
    … …  
    4738#include <assert.h>
    4839#include <usb/usbdrv.h>
    49 
    50 #define _PREPARE_TARGET(varname, pipe) \
    51         usb_target_t varname = { \
    52                 .address = (pipe)->wire->address, \
    53                 .endpoint = (pipe)->endpoint_no \
    54         }
    5540
    5641/** Initialize connection to USB device.
    … …  
    117102}
    118103
    119 /** Initialize USB endpoint pipe.
     104/** Initialize connection to USB device on default address.
    120105 *
    121  * @param pipe Endpoint pipe to be initialized.
    122  * @param connection Connection to the USB device backing this pipe (the wire).
    123  * @param endpoint_no Endpoint number (in USB 1.1 in range 0 to 15).
    124  * @param transfer_type Transfer type (e.g. interrupt or bulk).
    125  * @param max_packet_size Maximum packet size in bytes.
    126  * @param direction Endpoint direction (in/out).
     106 * @param dev_connection Device connection structure to be initialized.
     107 * @param hc_connection Initialized connection to host controller.
    127108 * @return Error code.
    128109 */
    129 int usb_endpoint_pipe_initialize(usb_endpoint_pipe_t *pipe,
    130     usb_device_connection_t *connection, usb_endpoint_t endpoint_no,
    131     usb_transfer_type_t transfer_type, size_t max_packet_size,
    132     usb_direction_t direction)
     110int usb_device_connection_initialize_on_default_address(
     111    usb_device_connection_t *dev_connection,
     112    usb_hc_connection_t *hc_connection)
    133113{
    134         assert(pipe);
    135         assert(connection);
     114        assert(dev_connection);
    136115
    137         pipe->wire = connection;
    138         pipe->hc_phone = -1;
    139         pipe->endpoint_no = endpoint_no;
    140         pipe->transfer_type = transfer_type;
    141         pipe->max_packet_size = max_packet_size;
    142         pipe->direction = direction;
     116        if (hc_connection == NULL) {
     117                return EBADMEM;
     118        }
    143119
    144         return EOK;
    145 }
    146 
    147 
    148 /** Initialize USB endpoint pipe as the default zero control pipe.
    149  *
    150  * @param pipe Endpoint pipe to be initialized.
    151  * @param connection Connection to the USB device backing this pipe (the wire).
    152  * @return Error code.
    153  */
    154 int usb_endpoint_pipe_initialize_default_control(usb_endpoint_pipe_t *pipe,
    155     usb_device_connection_t *connection)
    156 {
    157         assert(pipe);
    158         assert(connection);
    159 
    160         int rc = usb_endpoint_pipe_initialize(pipe, connection,
    161             0, USB_TRANSFER_CONTROL, 8, USB_DIRECTION_BOTH);
    162 
    163         return rc;
     120        return usb_device_connection_initialize(dev_connection,
     121            hc_connection->hc_handle, (usb_address_t) 0);
    164122}
    165123
    … …  
    224182}
    225183
    226 
    227 /** Request a read (in) transfer on an endpoint pipe.
    228  *
    229  * @param[in] pipe Pipe used for the transfer.
    230  * @param[out] buffer Buffer where to store the data.
    231  * @param[in] size Size of the buffer (in bytes).
    232  * @param[out] size_transfered Number of bytes that were actually transfered.
    233  * @return Error code.
    234  */
    235 int usb_endpoint_pipe_read(usb_endpoint_pipe_t *pipe,
    236     void *buffer, size_t size, size_t *size_transfered)
    237 {
    238         assert(pipe);
    239 
    240         int rc;
    241         usb_handle_t handle;
    242 
    243         rc = usb_endpoint_pipe_async_read(pipe, buffer, size, size_transfered,
    244             &handle);
    245         if (rc != EOK) {
    246                 return rc;
    247         }
    248 
    249         rc = usb_endpoint_pipe_wait_for(pipe, handle);
    250         return rc;
    251 }
    252 
    253 /** Request a write (out) transfer on an endpoint pipe.
    254  *
    255  * @param[in] pipe Pipe used for the transfer.
    256  * @param[in] buffer Buffer with data to transfer.
    257  * @param[in] size Size of the buffer (in bytes).
    258  * @return Error code.
    259  */
    260 int usb_endpoint_pipe_write(usb_endpoint_pipe_t *pipe,
    261     void *buffer, size_t size)
    262 {
    263         assert(pipe);
    264 
    265         int rc;
    266         usb_handle_t handle;
    267 
    268         rc = usb_endpoint_pipe_async_write(pipe, buffer, size, &handle);
    269         if (rc != EOK) {
    270                 return rc;
    271         }
    272 
    273         rc = usb_endpoint_pipe_wait_for(pipe, handle);
    274         return rc;
    275 }
    276 
    277 
    278 /** Request a control read transfer on an endpoint pipe.
    279  *
    280  * This function encapsulates all three stages of a control transfer.
    281  *
    282  * @param[in] pipe Pipe used for the transfer.
    283  * @param[in] setup_buffer Buffer with the setup packet.
    284  * @param[in] setup_buffer_size Size of the setup packet (in bytes).
    285  * @param[out] data_buffer Buffer for incoming data.
    286  * @param[in] data_buffer_size Size of the buffer for incoming data (in bytes).
    287  * @param[out] data_transfered_size Number of bytes that were actually
    288  *                                  transfered during the DATA stage.
    289  * @return Error code.
    290  */
    291 int usb_endpoint_pipe_control_read(usb_endpoint_pipe_t *pipe,
    292     void *setup_buffer, size_t setup_buffer_size,
    293     void *data_buffer, size_t data_buffer_size, size_t *data_transfered_size)
    294 {
    295         assert(pipe);
    296 
    297         int rc;
    298         usb_handle_t handle;
    299 
    300         rc = usb_endpoint_pipe_async_control_read(pipe,
    301             setup_buffer, setup_buffer_size,
    302             data_buffer, data_buffer_size, data_transfered_size,
    303             &handle);
    304         if (rc != EOK) {
    305                 return rc;
    306         }
    307 
    308         rc = usb_endpoint_pipe_wait_for(pipe, handle);
    309         return rc;
    310 }
    311 
    312 
    313 /** Request a control write transfer on an endpoint pipe.
    314  *
    315  * This function encapsulates all three stages of a control transfer.
    316  *
    317  * @param[in] pipe Pipe used for the transfer.
    318  * @param[in] setup_buffer Buffer with the setup packet.
    319  * @param[in] setup_buffer_size Size of the setup packet (in bytes).
    320  * @param[in] data_buffer Buffer with data to be sent.
    321  * @param[in] data_buffer_size Size of the buffer with outgoing data (in bytes).
    322  * @return Error code.
    323  */
    324 int usb_endpoint_pipe_control_write(usb_endpoint_pipe_t *pipe,
    325     void *setup_buffer, size_t setup_buffer_size,
    326     void *data_buffer, size_t data_buffer_size)
    327 {
    328         assert(pipe);
    329 
    330         int rc;
    331         usb_handle_t handle;
    332 
    333         rc = usb_endpoint_pipe_async_control_write(pipe,
    334             setup_buffer, setup_buffer_size,
    335             data_buffer, data_buffer_size,
    336             &handle);
    337         if (rc != EOK) {
    338                 return rc;
    339         }
    340 
    341         rc = usb_endpoint_pipe_wait_for(pipe, handle);
    342         return rc;
    343 }
    344 
    345 
    346 /** Request a read (in) transfer on an endpoint pipe (asynchronous version).
    347  *
    348  * @param[in] pipe Pipe used for the transfer.
    349  * @param[out] buffer Buffer where to store the data.
    350  * @param[in] size Size of the buffer (in bytes).
    351  * @param[out] size_transfered Number of bytes that were actually transfered.
    352  * @param[out] handle Handle of the transfer.
    353  * @return Error code.
    354  */
    355 int usb_endpoint_pipe_async_read(usb_endpoint_pipe_t *pipe,
    356     void *buffer, size_t size, size_t *size_transfered,
    357     usb_handle_t *handle)
    358 {
    359         assert(pipe);
    360 
    361         if (pipe->hc_phone < 0) {
    362                 return EBADF;
    363         }
    364 
    365         if (pipe->direction != USB_DIRECTION_IN) {
    366                 return EBADF;
    367         }
    368 
    369         int rc;
    370         _PREPARE_TARGET(target, pipe);
    371 
    372         switch (pipe->transfer_type) {
    373                 case USB_TRANSFER_INTERRUPT:
    374                         rc = usb_drv_async_interrupt_in(pipe->hc_phone, target,
    375                             buffer, size, size_transfered, handle);
    376                         break;
    377                 case USB_TRANSFER_CONTROL:
    378                         rc = EBADF;
    379                         break;
    380                 default:
    381                         rc = ENOTSUP;
    382                         break;
    383         }
    384 
    385         return rc;
    386 }
    387 
    388 
    389 /** Request a write (out) transfer on an endpoint pipe (asynchronous version).
    390  *
    391  * @param[in] pipe Pipe used for the transfer.
    392  * @param[in] buffer Buffer with data to transfer.
    393  * @param[in] size Size of the buffer (in bytes).
    394  * @param[out] handle Handle of the transfer.
    395  * @return Error code.
    396  */
    397 int usb_endpoint_pipe_async_write(usb_endpoint_pipe_t *pipe,
    398     void *buffer, size_t size,
    399     usb_handle_t *handle)
    400 {
    401         assert(pipe);
    402 
    403         if (pipe->hc_phone < 0) {
    404                 return EBADF;
    405         }
    406 
    407         if (pipe->direction != USB_DIRECTION_OUT) {
    408                 return EBADF;
    409         }
    410 
    411         int rc;
    412         _PREPARE_TARGET(target, pipe);
    413 
    414         switch (pipe->transfer_type) {
    415                 case USB_TRANSFER_INTERRUPT:
    416                         rc = usb_drv_async_interrupt_out(pipe->hc_phone, target,
    417                             buffer, size, handle);
    418                         break;
    419                 case USB_TRANSFER_CONTROL:
    420                         rc = EBADF;
    421                         break;
    422                 default:
    423                         rc = ENOTSUP;
    424                         break;
    425         }
    426 
    427         return rc;
    428 }
    429 
    430 
    431 /** Request a control read transfer on an endpoint pipe (asynchronous version).
    432  *
    433  * This function encapsulates all three stages of a control transfer.
    434  *
    435  * @param[in] pipe Pipe used for the transfer.
    436  * @param[in] setup_buffer Buffer with the setup packet.
    437  * @param[in] setup_buffer_size Size of the setup packet (in bytes).
    438  * @param[out] data_buffer Buffer for incoming data.
    439  * @param[in] data_buffer_size Size of the buffer for incoming data (in bytes).
    440  * @param[out] data_transfered_size Number of bytes that were actually
    441  *                                  transfered during the DATA stage.
    442  * @param[out] handle Handle of the transfer.
    443  * @return Error code.
    444  */
    445 int usb_endpoint_pipe_async_control_read(usb_endpoint_pipe_t *pipe,
    446     void *setup_buffer, size_t setup_buffer_size,
    447     void *data_buffer, size_t data_buffer_size, size_t *data_transfered_size,
    448     usb_handle_t *handle)
    449 {
    450         assert(pipe);
    451 
    452         if (pipe->hc_phone < 0) {
    453                 return EBADF;
    454         }
    455 
    456         if ((pipe->direction != USB_DIRECTION_BOTH)
    457             || (pipe->transfer_type != USB_TRANSFER_CONTROL)) {
    458                 return EBADF;
    459         }
    460 
    461         int rc;
    462         _PREPARE_TARGET(target, pipe);
    463 
    464         rc = usb_drv_async_control_read(pipe->hc_phone, target,
    465             setup_buffer, setup_buffer_size,
    466             data_buffer, data_buffer_size, data_transfered_size,
    467             handle);
    468 
    469         return rc;
    470 }
    471 
    472 
    473 /** Request a control write transfer on an endpoint pipe (asynchronous version).
    474  *
    475  * This function encapsulates all three stages of a control transfer.
    476  *
    477  * @param[in] pipe Pipe used for the transfer.
    478  * @param[in] setup_buffer Buffer with the setup packet.
    479  * @param[in] setup_buffer_size Size of the setup packet (in bytes).
    480  * @param[in] data_buffer Buffer with data to be sent.
    481  * @param[in] data_buffer_size Size of the buffer with outgoing data (in bytes).
    482  * @param[out] handle Handle of the transfer.
    483  * @return Error code.
    484  */
    485 int usb_endpoint_pipe_async_control_write(usb_endpoint_pipe_t *pipe,
    486     void *setup_buffer, size_t setup_buffer_size,
    487     void *data_buffer, size_t data_buffer_size,
    488     usb_handle_t *handle)
    489 {
    490         assert(pipe);
    491 
    492         if (pipe->hc_phone < 0) {
    493                 return EBADF;
    494         }
    495 
    496         if ((pipe->direction != USB_DIRECTION_BOTH)
    497             || (pipe->transfer_type != USB_TRANSFER_CONTROL)) {
    498                 return EBADF;
    499         }
    500 
    501         int rc;
    502         _PREPARE_TARGET(target, pipe);
    503 
    504         rc = usb_drv_async_control_write(pipe->hc_phone, target,
    505             setup_buffer, setup_buffer_size,
    506             data_buffer, data_buffer_size,
    507             handle);
    508 
    509         return rc;
    510 }
    511 
    512 /** Wait for transfer completion.
    513  *
    514  * The function blocks the caller fibril until the transfer associated
    515  * with given @p handle is completed.
    516  *
    517  * @param[in] pipe Pipe the transfer executed on.
    518  * @param[in] handle Transfer handle.
    519  * @return Error code.
    520  */
    521 int usb_endpoint_pipe_wait_for(usb_endpoint_pipe_t *pipe, usb_handle_t handle)
    522 {
    523         return usb_drv_async_wait_for(handle);
    524 }
    525 
    526 
    527184/**
    528185 * @}

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

    r600733e r2e85b3c  
    320320}
    321321
     322/** Initialize USB endpoint pipe.
     323 *
     324 * @param pipe Endpoint pipe to be initialized.
     325 * @param connection Connection to the USB device backing this pipe (the wire).
     326 * @param endpoint_no Endpoint number (in USB 1.1 in range 0 to 15).
     327 * @param transfer_type Transfer type (e.g. interrupt or bulk).
     328 * @param max_packet_size Maximum packet size in bytes.
     329 * @param direction Endpoint direction (in/out).
     330 * @return Error code.
     331 */
     332int usb_endpoint_pipe_initialize(usb_endpoint_pipe_t *pipe,
     333    usb_device_connection_t *connection, usb_endpoint_t endpoint_no,
     334    usb_transfer_type_t transfer_type, size_t max_packet_size,
     335    usb_direction_t direction)
     336{
     337        assert(pipe);
     338        assert(connection);
     339
     340        pipe->wire = connection;
     341        pipe->hc_phone = -1;
     342        pipe->endpoint_no = endpoint_no;
     343        pipe->transfer_type = transfer_type;
     344        pipe->max_packet_size = max_packet_size;
     345        pipe->direction = direction;
     346
     347        return EOK;
     348}
     349
     350
     351/** Initialize USB endpoint pipe as the default zero control pipe.
     352 *
     353 * @param pipe Endpoint pipe to be initialized.
     354 * @param connection Connection to the USB device backing this pipe (the wire).
     355 * @return Error code.
     356 */
     357int usb_endpoint_pipe_initialize_default_control(usb_endpoint_pipe_t *pipe,
     358    usb_device_connection_t *connection)
     359{
     360        assert(pipe);
     361        assert(connection);
     362
     363        int rc = usb_endpoint_pipe_initialize(pipe, connection,
     364            0, USB_TRANSFER_CONTROL, 8, USB_DIRECTION_BOTH);
     365
     366        return rc;
     367}
     368
    322369/**
    323370 * @}

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

    r600733e r2e85b3c  
    5454}
    5555
    56 /** String representation of USB transaction outcome. */
    57 const char * usb_str_transaction_outcome(usb_transaction_outcome_t o)
    58 {
    59         switch (o) {
    60                 case USB_OUTCOME_OK:
    61                         return "ok";
    62                 case USB_OUTCOME_CRCERROR:
    63                         return "CRC error";
    64                 case USB_OUTCOME_BABBLE:
    65                         return "babble";
    66                 default:
    67                         return "unknown";
    68         }
    69 }
    70 
    71 
    7256/**
    7357 * @}

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

    r600733e r2e85b3c  
    464464        assert(setup_packet != NULL);
    465465        assert(setup_packet_size > 0);
    466         assert(buffer != NULL);
    467         assert(buffer_size > 0);
     466        assert(((buffer != NULL) && (buffer_size > 0))
     467            || ((buffer == NULL) && (buffer_size == 0)));
    468468        assert(handle != NULL);
    469469
    … …  
    494494        }
    495495
    496         rc = async_data_write_start(phone, buffer, buffer_size);
    497         if (rc != EOK) {
    498                 async_wait_for(transfer->request, NULL);
    499                 return rc;
     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                }
    500502        }
    501503

  • uspace/lib/usbvirt/Makefile

    r600733e r2e85b3c  
    3030LIBRARY = libusbvirt
    3131
    32 LIBS = $(LIBUSB_PREFIX)/libusb.a
    3332EXTRA_CFLAGS = -I$(LIBUSB_PREFIX)/include -Iinclude
    3433
Note: See TracChangeset for help on using the changeset viewer.