Changeset 55e388a1 in mainline for uspace/lib


Ignore:
Timestamp:
2011-03-24T14:57:53Z (15 years ago)
Author:
Matej Klonfar <maklf@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
b53d3b7
Parents:
361e61b (diff), e18e0d6 (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:

Check of initialization of report parser structure

Location:
uspace/lib/usb
Files:
20 edited

Legend:

Unmodified
Added
Removed

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

    r361e61b r55e388a1  
    7979} usb_log_level_t;
    8080
     81/** Default log level. */
     82#define USB_LOG_LEVEL_DEFAULT USB_LOG_LEVEL_DEBUG
     83
    8184
    8285void usb_log_enable(usb_log_level_t, const char *);

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

    r361e61b r55e388a1  
    3838#include <usb/pipes.h>
    3939
     40/** Descriptors for USB device. */
     41typedef struct {
     42        /** Standard device descriptor. */
     43        usb_standard_device_descriptor_t device;
     44        /** Full configuration descriptor of current configuration. */
     45        uint8_t *configuration;
     46        size_t configuration_size;
     47} usb_device_descriptors_t;
     48
    4049/** USB device structure. */
    4150typedef struct {
    4251        /** The default control pipe. */
    43         usb_endpoint_pipe_t ctrl_pipe;
     52        usb_pipe_t ctrl_pipe;
    4453        /** Other endpoint pipes.
    4554         * This is an array of other endpoint pipes in the same order as
    … …  
    5261         */
    5362        int interface_no;
     63
     64        /** Some useful descriptors. */
     65        usb_device_descriptors_t descriptors;
     66
    5467        /** Generic DDF device backing this one. */
    5568        ddf_dev_t *ddf_dev;

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

    r361e61b r55e388a1  
    2626 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2727 */
    28 /** @addtogroup drvusbuhcihc
     28/** @addtogroup libusb
    2929 * @{
    3030 */
    3131/** @file
    32  * @brief UHCI driver USB transaction structure
     32 * USB transfer transaction structures.
    3333 */
    3434#ifndef LIBUSB_HOST_BATCH_H
    … …  
    4040#include <usb/usb.h>
    4141
    42 typedef struct batch
    43 {
     42typedef struct usb_transfer_batch usb_transfer_batch_t;
     43struct usb_transfer_batch {
    4444        link_t link;
    4545        usb_target_t target;
    … …  
    5656        size_t max_packet_size;
    5757        size_t transfered_size;
    58         void (*next_step)(struct batch*);
     58        void (*next_step)(usb_transfer_batch_t *);
    5959        int error;
    6060        ddf_fun_t *fun;
    6161        void *arg;
    6262        void *private_data;
    63 } batch_t;
     63};
    6464
    65 void batch_init(
    66     batch_t *instance,
     65void usb_transfer_batch_init(
     66    usb_transfer_batch_t *instance,
    6767    usb_target_t target,
    6868    usb_transfer_type_t transfer_type,
    … …  
    8181);
    8282
    83 static inline batch_t *batch_from_link(link_t *link_ptr)
     83static inline usb_transfer_batch_t *usb_transfer_batch_from_link(link_t *l)
    8484{
    85         assert(link_ptr);
    86         return list_get_instance(link_ptr, batch_t, link);
     85        assert(l);
     86        return list_get_instance(l, usb_transfer_batch_t, link);
    8787}
    8888
    89 void batch_call_in(batch_t *instance);
    90 void batch_call_out(batch_t *instance);
    91 void batch_finish(batch_t *instance, int error);
     89void usb_transfer_batch_call_in(usb_transfer_batch_t *instance);
     90void usb_transfer_batch_call_out(usb_transfer_batch_t *instance);
     91void usb_transfer_batch_finish(usb_transfer_batch_t *instance, int error);
     92
    9293#endif
    9394/**

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

    r361e61b r55e388a1  
    3131 */
    3232/** @file
    33  * @brief UHCI driver
     33 * Device keeper structure and functions.
     34 *
     35 * Typical USB host controller needs to keep track of various settings for
     36 * each device that is connected to it.
     37 * State of toggle bit, device speed etc. etc.
     38 * This structure shall simplify the management.
    3439 */
    3540#ifndef LIBUSB_HOST_DEVICE_KEEPER_H
    … …  
    3944#include <usb/usb.h>
    4045
     46/** Number of USB address for array dimensions. */
    4147#define USB_ADDRESS_COUNT (USB11_ADDRESS_MAX + 1)
    4248
     49/** Information about attached USB device. */
    4350struct usb_device_info {
    4451        usb_speed_t speed;
    … …  
    4855};
    4956
    50 typedef struct device_keeper {
     57/** Host controller device keeper.
     58 * You shall not access members directly but only using functions below.
     59 */
     60typedef struct {
    5161        struct usb_device_info devices[USB_ADDRESS_COUNT];
    5262        fibril_mutex_t guard;
    5363        fibril_condvar_t default_address_occupied;
    5464        usb_address_t last_address;
    55 } device_keeper_t;
     65} usb_device_keeper_t;
    5666
    57 void device_keeper_init(device_keeper_t *instance);
     67void usb_device_keeper_init(usb_device_keeper_t *instance);
    5868
    59 void device_keeper_reserve_default(
    60     device_keeper_t *instance, usb_speed_t speed);
     69void usb_device_keeper_reserve_default_address(usb_device_keeper_t *instance,
     70    usb_speed_t speed);
    6171
    62 void device_keeper_release_default(device_keeper_t *instance);
     72void usb_device_keeper_release_default_address(usb_device_keeper_t *instance);
    6373
    64 void device_keeper_reset_if_need(
    65     device_keeper_t *instance, usb_target_t target,
    66     const unsigned char *setup_data);
     74void usb_device_keeper_reset_if_need(usb_device_keeper_t *instance,
     75    usb_target_t target,
     76    const uint8_t *setup_data);
    6777
    68 int device_keeper_get_toggle(
    69     device_keeper_t *instance, usb_target_t target, usb_direction_t direction);
     78int usb_device_keeper_get_toggle(usb_device_keeper_t *instance,
     79    usb_target_t target, usb_direction_t direction);
    7080
    71 int device_keeper_set_toggle(device_keeper_t *instance,
     81int usb_device_keeper_set_toggle(usb_device_keeper_t *instance,
    7282    usb_target_t target, usb_direction_t direction, bool toggle);
    7383
    74 usb_address_t device_keeper_request(
    75     device_keeper_t *instance, usb_speed_t speed);
     84usb_address_t device_keeper_get_free_address(usb_device_keeper_t *instance,
     85    usb_speed_t speed);
    7686
    77 void device_keeper_bind(
    78     device_keeper_t *instance, usb_address_t address, devman_handle_t handle);
     87void usb_device_keeper_bind(usb_device_keeper_t *instance,
     88    usb_address_t address, devman_handle_t handle);
    7989
    80 void device_keeper_release(device_keeper_t *instance, usb_address_t address);
     90void usb_device_keeper_release(usb_device_keeper_t *instance,
     91    usb_address_t address);
    8192
    82 usb_address_t device_keeper_find(
    83     device_keeper_t *instance, devman_handle_t handle);
     93usb_address_t usb_device_keeper_find(usb_device_keeper_t *instance,
     94    devman_handle_t handle);
    8495
    85 usb_speed_t device_keeper_speed(
    86     device_keeper_t *instance, usb_address_t address);
     96usb_speed_t usb_device_keeper_get_speed(usb_device_keeper_t *instance,
     97    usb_address_t address);
     98
    8799#endif
    88100/**

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

    r361e61b r55e388a1  
    8080         */
    8181        int hc_phone;
    82 } usb_endpoint_pipe_t;
     82} usb_pipe_t;
    8383
    8484
    … …  
    102102typedef struct {
    103103        /** Endpoint pipe. */
    104         usb_endpoint_pipe_t *pipe;
     104        usb_pipe_t *pipe;
    105105        /** Endpoint description. */
    106106        const usb_endpoint_description_t *description;
    … …  
    125125usb_address_t usb_device_get_assigned_address(devman_handle_t);
    126126
    127 int usb_endpoint_pipe_initialize(usb_endpoint_pipe_t *,
    128     usb_device_connection_t *,
     127int usb_pipe_initialize(usb_pipe_t *, usb_device_connection_t *,
    129128    usb_endpoint_t, usb_transfer_type_t, size_t, usb_direction_t);
    130 int usb_endpoint_pipe_initialize_default_control(usb_endpoint_pipe_t *,
     129int usb_pipe_initialize_default_control(usb_pipe_t *,
    131130    usb_device_connection_t *);
    132 int usb_endpoint_pipe_probe_default_control(usb_endpoint_pipe_t *);
    133 int usb_endpoint_pipe_initialize_from_configuration(usb_endpoint_mapping_t *,
     131int usb_pipe_probe_default_control(usb_pipe_t *);
     132int usb_pipe_initialize_from_configuration(usb_endpoint_mapping_t *,
    134133    size_t, uint8_t *, size_t, usb_device_connection_t *);
    135 int usb_endpoint_pipe_register(usb_endpoint_pipe_t *, unsigned int,
    136     usb_hc_connection_t *);
    137 int usb_endpoint_pipe_unregister(usb_endpoint_pipe_t *, usb_hc_connection_t *);
     134int usb_pipe_register(usb_pipe_t *, unsigned int, usb_hc_connection_t *);
     135int usb_pipe_unregister(usb_pipe_t *, usb_hc_connection_t *);
    138136
    139 int usb_endpoint_pipe_start_session(usb_endpoint_pipe_t *);
    140 int usb_endpoint_pipe_end_session(usb_endpoint_pipe_t *);
    141 bool usb_endpoint_pipe_is_session_started(usb_endpoint_pipe_t *);
     137int usb_pipe_start_session(usb_pipe_t *);
     138int usb_pipe_end_session(usb_pipe_t *);
     139bool usb_pipe_is_session_started(usb_pipe_t *);
    142140
    143 int usb_endpoint_pipe_read(usb_endpoint_pipe_t *, void *, size_t, size_t *);
    144 int usb_endpoint_pipe_write(usb_endpoint_pipe_t *, void *, size_t);
     141int usb_pipe_read(usb_pipe_t *, void *, size_t, size_t *);
     142int usb_pipe_write(usb_pipe_t *, void *, size_t);
    145143
    146 int usb_endpoint_pipe_control_read(usb_endpoint_pipe_t *, void *, size_t,
     144int usb_pipe_control_read(usb_pipe_t *, void *, size_t,
    147145    void *, size_t, size_t *);
    148 int usb_endpoint_pipe_control_write(usb_endpoint_pipe_t *, void *, size_t,
     146int usb_pipe_control_write(usb_pipe_t *, void *, size_t,
    149147    void *, size_t);
    150148

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

    r361e61b r55e388a1  
    4848    const usb_standard_interface_descriptor_t *, match_id_list_t *);
    4949
    50 int usb_device_create_match_ids(usb_endpoint_pipe_t *, match_id_list_t *);
     50int usb_device_create_match_ids(usb_pipe_t *, match_id_list_t *);
    5151
    5252int usb_device_register_child_in_devman(usb_address_t, devman_handle_t,

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

    r361e61b r55e388a1  
    8686} __attribute__ ((packed)) usb_device_request_setup_packet_t;
    8787
    88 int usb_control_request_set(usb_endpoint_pipe_t *,
     88int usb_control_request_set(usb_pipe_t *,
    8989    usb_request_type_t, usb_request_recipient_t, uint8_t,
    9090    uint16_t, uint16_t, void *, size_t);
    9191
    92 int usb_control_request_get(usb_endpoint_pipe_t *,
     92int usb_control_request_get(usb_pipe_t *,
    9393    usb_request_type_t, usb_request_recipient_t, uint8_t,
    9494    uint16_t, uint16_t, void *, size_t, size_t *);
    9595
    96 int usb_request_get_status(usb_endpoint_pipe_t *, usb_request_recipient_t,
     96int usb_request_get_status(usb_pipe_t *, usb_request_recipient_t,
    9797    uint16_t, uint16_t *);
    98 int usb_request_clear_feature(usb_endpoint_pipe_t *, usb_request_type_t,
     98int usb_request_clear_feature(usb_pipe_t *, usb_request_type_t,
    9999    usb_request_recipient_t, uint16_t, uint16_t);
    100 int usb_request_set_feature(usb_endpoint_pipe_t *, usb_request_type_t,
     100int usb_request_set_feature(usb_pipe_t *, usb_request_type_t,
    101101    usb_request_recipient_t, uint16_t, uint16_t);
    102 int usb_request_set_address(usb_endpoint_pipe_t *, usb_address_t);
    103 int usb_request_get_descriptor(usb_endpoint_pipe_t *, usb_request_type_t,
     102int usb_request_set_address(usb_pipe_t *, usb_address_t);
     103int usb_request_get_descriptor(usb_pipe_t *, usb_request_type_t,
    104104    usb_request_recipient_t, uint8_t, uint8_t, uint16_t, void *, size_t,
    105105    size_t *);
    106 int usb_request_get_descriptor_alloc(usb_endpoint_pipe_t *, usb_request_type_t,
     106int usb_request_get_descriptor_alloc(usb_pipe_t *, usb_request_type_t,
    107107    usb_request_recipient_t, uint8_t, uint8_t, uint16_t, void **, size_t *);
    108 int usb_request_get_device_descriptor(usb_endpoint_pipe_t *,
     108int usb_request_get_device_descriptor(usb_pipe_t *,
    109109    usb_standard_device_descriptor_t *);
    110 int usb_request_get_bare_configuration_descriptor(usb_endpoint_pipe_t *, int,
     110int usb_request_get_bare_configuration_descriptor(usb_pipe_t *, int,
    111111    usb_standard_configuration_descriptor_t *);
    112 int usb_request_get_full_configuration_descriptor(usb_endpoint_pipe_t *, int,
     112int usb_request_get_full_configuration_descriptor(usb_pipe_t *, int,
    113113    void *, size_t, size_t *);
    114 int usb_request_get_full_configuration_descriptor_alloc(usb_endpoint_pipe_t *,
     114int usb_request_get_full_configuration_descriptor_alloc(usb_pipe_t *,
    115115    int, void **, size_t *);
    116 int usb_request_set_descriptor(usb_endpoint_pipe_t *, usb_request_type_t,
     116int usb_request_set_descriptor(usb_pipe_t *, usb_request_type_t,
    117117    usb_request_recipient_t, uint8_t, uint8_t, uint16_t, void *, size_t);
    118 int usb_request_get_configuration(usb_endpoint_pipe_t *, uint8_t *);
    119 int usb_request_set_configuration(usb_endpoint_pipe_t *, uint8_t);
    120 int usb_request_get_interface(usb_endpoint_pipe_t *, uint8_t, uint8_t *);
    121 int usb_request_set_interface(usb_endpoint_pipe_t *, uint8_t, uint8_t);
     118int usb_request_get_configuration(usb_pipe_t *, uint8_t *);
     119int usb_request_set_configuration(usb_pipe_t *, uint8_t);
     120int usb_request_get_interface(usb_pipe_t *, uint8_t, uint8_t *);
     121int usb_request_set_interface(usb_pipe_t *, uint8_t, uint8_t);
    122122
    123 int usb_request_get_supported_languages(usb_endpoint_pipe_t *,
     123int usb_request_get_supported_languages(usb_pipe_t *,
    124124    l18_win_locales_t **, size_t *);
    125 int usb_request_get_string(usb_endpoint_pipe_t *, size_t, l18_win_locales_t,
     125int usb_request_get_string(usb_pipe_t *, size_t, l18_win_locales_t,
    126126    char **);
    127127

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

    r361e61b r55e388a1  
    6161
    6262const char * usb_str_transfer_type(usb_transfer_type_t t);
     63const char * usb_str_transfer_type_short(usb_transfer_type_t t);
    6364
    6465/** USB data transfer direction. */
    … …  
    7879        USB_SPEED_HIGH
    7980} usb_speed_t;
     81
     82const char *usb_str_speed(usb_speed_t);
     83
    8084
    8185/** USB request type target. */

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

    r361e61b r55e388a1  
    126126
    127127        for (i = 0; i < pipe_count; i++) {
    128                 dev->pipes[i].pipe = malloc(sizeof(usb_endpoint_pipe_t));
     128                dev->pipes[i].pipe = malloc(sizeof(usb_pipe_t));
    129129                if (dev->pipes[i].pipe == NULL) {
    130130                        usb_log_oom(dev->ddf_dev);
    … …  
    137137        }
    138138
    139         void *config_descriptor;
    140         size_t config_descriptor_size;
    141         rc = usb_request_get_full_configuration_descriptor_alloc(
    142             &dev->ctrl_pipe, 0, &config_descriptor, &config_descriptor_size);
    143         if (rc != EOK) {
    144                 usb_log_error("Failed retrieving configuration of `%s': %s.\n",
    145                     dev->ddf_dev->name, str_error(rc));
    146                 goto rollback;
    147         }
    148 
    149         rc = usb_endpoint_pipe_initialize_from_configuration(dev->pipes,
    150            pipe_count, config_descriptor, config_descriptor_size, &dev->wire);
     139        rc = usb_pipe_initialize_from_configuration(dev->pipes, pipe_count,
     140            dev->descriptors.configuration, dev->descriptors.configuration_size,
     141            &dev->wire);
    151142        if (rc != EOK) {
    152143                usb_log_error("Failed initializing USB endpoints: %s.\n",
    … …  
    172163        for (i = 0; i < pipe_count; i++) {
    173164                if (dev->pipes[i].present) {
    174                         rc = usb_endpoint_pipe_register(dev->pipes[i].pipe,
     165                        rc = usb_pipe_register(dev->pipes[i].pipe,
    175166                            dev->pipes[i].descriptor->poll_interval,
    176167                            &hc_conn);
    … …  
    219210        }
    220211
    221         rc = usb_endpoint_pipe_initialize_default_control(&dev->ctrl_pipe,
     212        rc = usb_pipe_initialize_default_control(&dev->ctrl_pipe,
    222213            &dev->wire);
    223214        if (rc != EOK) {
    … …  
    228219        }
    229220
    230         rc = usb_endpoint_pipe_probe_default_control(&dev->ctrl_pipe);
     221        rc = usb_pipe_probe_default_control(&dev->ctrl_pipe);
    231222        if (rc != EOK) {
    232223                usb_log_error(
    … …  
    237228
    238229        /*
    239          * Initialization of other pipes requires open session on
    240          * default control pipe.
     230         * For further actions, we need open session on default control pipe.
    241231         */
    242         rc = usb_endpoint_pipe_start_session(&dev->ctrl_pipe);
     232        rc = usb_pipe_start_session(&dev->ctrl_pipe);
    243233        if (rc != EOK) {
    244234                usb_log_error("Failed to start an IPC session: %s.\n",
    245235                    str_error(rc));
     236                return rc;
     237        }
     238
     239        /* Get the device descriptor. */
     240        rc = usb_request_get_device_descriptor(&dev->ctrl_pipe,
     241            &dev->descriptors.device);
     242        if (rc != EOK) {
     243                usb_log_error("Failed to retrieve device descriptor: %s.\n",
     244                    str_error(rc));
     245                return rc;
     246        }
     247
     248        /* Get the full configuration descriptor. */
     249        rc = usb_request_get_full_configuration_descriptor_alloc(
     250            &dev->ctrl_pipe, 0, (void **) &dev->descriptors.configuration,
     251            &dev->descriptors.configuration_size);
     252        if (rc != EOK) {
     253                usb_log_error("Failed retrieving configuration descriptor: %s.\n",
     254                    dev->ddf_dev->name, str_error(rc));
    246255                return rc;
    247256        }
    … …  
    252261
    253262        /* No checking here. */
    254         usb_endpoint_pipe_end_session(&dev->ctrl_pipe);
     263        usb_pipe_end_session(&dev->ctrl_pipe);
     264
     265        /* Rollback actions. */
     266        if (rc != EOK) {
     267                if (dev->descriptors.configuration != NULL) {
     268                        free(dev->descriptors.configuration);
     269                }
     270        }
    255271
    256272        return rc;
    … …  
    283299        dev->ddf_dev->driver_data = dev;
    284300        dev->driver_data = NULL;
     301        dev->descriptors.configuration = NULL;
    285302
    286303        rc = initialize_pipes(dev);

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

    r361e61b r55e388a1  
    6464        assert(polling_data);
    6565
    66         usb_endpoint_pipe_t *pipe
     66        usb_pipe_t *pipe
    6767            = polling_data->dev->pipes[polling_data->pipe_index].pipe;
    6868
    … …  
    7171                int rc;
    7272
    73                 rc = usb_endpoint_pipe_start_session(pipe);
     73                rc = usb_pipe_start_session(pipe);
    7474                if (rc != EOK) {
    7575                        failed_attempts++;
    … …  
    7878
    7979                size_t actual_size;
    80                 rc = usb_endpoint_pipe_read(pipe, polling_data->buffer,
     80                rc = usb_pipe_read(pipe, polling_data->buffer,
    8181                    polling_data->request_size, &actual_size);
    8282
    8383                /* Quit the session regardless of errors. */
    84                 usb_endpoint_pipe_end_session(pipe);
     84                usb_pipe_end_session(pipe);
    8585
    8686                if (rc != EOK) {

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

    r361e61b r55e388a1  
    8484{
    8585   if(parser == NULL) {
    86         return -1;
     86        return EINVAL;
    8787   }
    8888
    … …  
    115115        size_t offset_output=0;
    116116        size_t offset_feature=0;
     117
     118        if(usb_hid_parser_init(parser) != EOK) {
     119                return EINVAL;
     120        }
    117121       
    118122
    … …  
    128132
    129133                        if((i+USB_HID_ITEM_SIZE(data[i]))>= size){
    130                                 return -1; // TODO ERROR CODE
     134                                return EINVAL; // TODO ERROR CODE
    131135                        }
    132136                       
    … …  
    530534void usb_hid_descriptor_print(usb_hid_report_parser_t *parser)
    531535{
     536        if(parser == NULL) {
     537                return;
     538        }
     539       
    532540        usb_log_debug("INPUT:\n");
    533541        usb_hid_descriptor_print_list(&parser->input);
    … …  
    615623        size_t j=0;
    616624
     625        if(parser == NULL) {
     626                return EINVAL;
     627        }
     628
     629       
    617630        // get the size of result keycodes array
    618631        usb_hid_report_path_t path;
    … …  
    737750int usb_hid_report_input_length(const usb_hid_report_parser_t *parser,
    738751        const usb_hid_report_path_t *path)
    739 {
     752{       
    740753        int ret = 0;
    741754        link_t *item;
    742755        usb_hid_report_item_t *report_item;
    743756
     757        if(parser == NULL) {
     758                return EINVAL;
     759        }
     760       
    744761        item = (&parser->input)->next;
    745762        while(&parser->input != item) {

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

    r361e61b r55e388a1  
    3030 */
    3131/** @file
    32  * @brief OHCI driver USB transaction structure
     32 * USB transfer transaction structures (implementation).
    3333 */
    3434#include <errno.h>
    … …  
    3939#include <usb/host/batch.h>
    4040
    41 void batch_init(
    42     batch_t *instance,
     41void usb_transfer_batch_init(
     42    usb_transfer_batch_t *instance,
    4343    usb_target_t target,
    4444    usb_transfer_type_t transfer_type,
    … …  
    8585 *
    8686 */
    87 void batch_finish(batch_t *instance, int error)
     87void usb_transfer_batch_finish(usb_transfer_batch_t *instance, int error)
    8888{
    8989        assert(instance);
    … …  
    9898 * parameters.
    9999 */
    100 void batch_call_in(batch_t *instance)
     100void usb_transfer_batch_call_in(usb_transfer_batch_t *instance)
    101101{
    102102        assert(instance);
    … …  
    107107            instance->buffer_size);
    108108
    109         int err = instance->error;
    110         usb_log_debug("Batch(%p) callback IN(type:%d): %s(%d), %zu.\n",
    111             instance, instance->transfer_type, str_error(err), err,
    112             instance->transfered_size);
     109        usb_log_debug("Batch %p done (T%d.%d, %s %s in, %zuB): %s (%d).\n",
     110            instance,
     111            instance->target.address, instance->target.endpoint,
     112            usb_str_speed(instance->speed),
     113            usb_str_transfer_type_short(instance->transfer_type),
     114            instance->transfered_size,
     115            str_error(instance->error), instance->error);
    113116
    114         instance->callback_in(
    115             instance->fun, err, instance->transfered_size, instance->arg);
     117        instance->callback_in(instance->fun, instance->error,
     118            instance->transfered_size, instance->arg);
    116119}
    117120/*----------------------------------------------------------------------------*/
    … …  
    120123 * @param[in] instance Batch structure to use.
    121124 */
    122 void batch_call_out(batch_t *instance)
     125void usb_transfer_batch_call_out(usb_transfer_batch_t *instance)
    123126{
    124127        assert(instance);
    125128        assert(instance->callback_out);
    126129
    127         int err = instance->error;
    128         usb_log_debug("Batch(%p) callback OUT(type:%d): %s(%d).\n",
    129             instance, instance->transfer_type, str_error(err), err);
     130        usb_log_debug("Batch %p done (T%d.%d, %s %s out): %s (%d).\n",
     131            instance,
     132            instance->target.address, instance->target.endpoint,
     133            usb_str_speed(instance->speed),
     134            usb_str_transfer_type_short(instance->transfer_type),
     135            str_error(instance->error), instance->error);
     136
    130137        instance->callback_out(instance->fun,
    131             err, instance->arg);
     138            instance->error, instance->arg);
    132139}
    133140/**

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

    r361e61b r55e388a1  
    3131 */
    3232/** @file
    33  * @brief UHCI driver
     33 * Device keeper structure and functions (implementation).
    3434 */
    3535#include <assert.h>
    … …  
    4545 * Set all values to false/0.
    4646 */
    47 void device_keeper_init(device_keeper_t *instance)
     47void usb_device_keeper_init(usb_device_keeper_t *instance)
    4848{
    4949        assert(instance);
    … …  
    6565 * @param[in] speed Speed of the device requesting default address.
    6666 */
    67 void device_keeper_reserve_default(device_keeper_t *instance, usb_speed_t speed)
     67void usb_device_keeper_reserve_default_address(usb_device_keeper_t *instance,
     68    usb_speed_t speed)
    6869{
    6970        assert(instance);
    … …  
    8384 * @param[in] speed Speed of the device requesting default address.
    8485 */
    85 void device_keeper_release_default(device_keeper_t *instance)
     86void usb_device_keeper_release_default_address(usb_device_keeper_t *instance)
    8687{
    8788        assert(instance);
    … …  
    100101 * Really ugly one.
    101102 */
    102 void device_keeper_reset_if_need(
    103     device_keeper_t *instance, usb_target_t target, const unsigned char *data)
     103void usb_device_keeper_reset_if_need(usb_device_keeper_t *instance,
     104    usb_target_t target, const uint8_t *data)
    104105{
    105106        assert(instance);
    … …  
    144145 * @return Error code
    145146 */
    146 int device_keeper_get_toggle(
    147     device_keeper_t *instance, usb_target_t target, usb_direction_t direction)
     147int usb_device_keeper_get_toggle(usb_device_keeper_t *instance,
     148    usb_target_t target, usb_direction_t direction)
    148149{
    149150        assert(instance);
    … …  
    173174 * @return Error code.
    174175 */
    175 int device_keeper_set_toggle(device_keeper_t *instance,
     176int usb_device_keeper_set_toggle(usb_device_keeper_t *instance,
    176177    usb_target_t target, usb_direction_t direction, bool toggle)
    177178{
    … …  
    207208 * @return Free address, or error code.
    208209 */
    209 usb_address_t device_keeper_request(
    210     device_keeper_t *instance, usb_speed_t speed)
    211 {
    212         assert(instance);
    213         fibril_mutex_lock(&instance->guard);
    214 
    215         usb_address_t new_address = instance->last_address + 1;
    216         while (instance->devices[new_address].occupied) {
     210usb_address_t device_keeper_get_free_address(usb_device_keeper_t *instance,
     211    usb_speed_t speed)
     212{
     213        assert(instance);
     214        fibril_mutex_lock(&instance->guard);
     215
     216        usb_address_t new_address = instance->last_address;
     217        do {
     218                ++new_address;
     219                if (new_address > USB11_ADDRESS_MAX)
     220                        new_address = 1;
    217221                if (new_address == instance->last_address) {
    218222                        fibril_mutex_unlock(&instance->guard);
    219223                        return ENOSPC;
    220224                }
    221                 if (new_address == USB11_ADDRESS_MAX)
    222                         new_address = 1;
    223                 ++new_address;
    224         }
     225        } while (instance->devices[new_address].occupied);
    225226
    226227        assert(new_address != USB_ADDRESS_DEFAULT);
    … …  
    241242 * @param[in] handle Devman handle of the device.
    242243 */
    243 void device_keeper_bind(
    244     device_keeper_t *instance, usb_address_t address, devman_handle_t handle)
     244void usb_device_keeper_bind(usb_device_keeper_t *instance,
     245    usb_address_t address, devman_handle_t handle)
    245246{
    246247        assert(instance);
    … …  
    258259 * @param[in] address Device address
    259260 */
    260 void device_keeper_release(device_keeper_t *instance, usb_address_t address)
     261void usb_device_keeper_release(usb_device_keeper_t *instance,
     262    usb_address_t address)
    261263{
    262264        assert(instance);
    … …  
    276278 * @return USB Address, or error code.
    277279 */
    278 usb_address_t device_keeper_find(
    279     device_keeper_t *instance, devman_handle_t handle)
     280usb_address_t usb_device_keeper_find(usb_device_keeper_t *instance,
     281    devman_handle_t handle)
    280282{
    281283        assert(instance);
    … …  
    299301 * @return USB speed.
    300302 */
    301 usb_speed_t device_keeper_speed(
    302     device_keeper_t *instance, usb_address_t address)
     303usb_speed_t usb_device_keeper_get_speed(usb_device_keeper_t *instance,
     304    usb_address_t address)
    303305{
    304306        assert(instance);
    … …  
    307309        return instance->devices[address].speed;
    308310}
     311
    309312/**
    310313 * @}

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

    r361e61b r55e388a1  
    228228        }
    229229
    230         usb_endpoint_pipe_t ctrl_pipe;
    231         rc = usb_endpoint_pipe_initialize_default_control(&ctrl_pipe,
     230        usb_pipe_t ctrl_pipe;
     231        rc = usb_pipe_initialize_default_control(&ctrl_pipe,
    232232            &dev_conn);
    233233        if (rc != EOK) {
    … …  
    235235                goto leave_release_default_address;
    236236        }
    237         rc = usb_endpoint_pipe_probe_default_control(&ctrl_pipe);
     237        rc = usb_pipe_probe_default_control(&ctrl_pipe);
    238238        if (rc != EOK) {
    239239                rc = ENOTCONN;
    … …  
    241241        }
    242242
    243         rc = usb_endpoint_pipe_start_session(&ctrl_pipe);
     243        rc = usb_pipe_start_session(&ctrl_pipe);
    244244        if (rc != EOK) {
    245245                rc = ENOTCONN;
    … …  
    253253        }
    254254
    255         usb_endpoint_pipe_end_session(&ctrl_pipe);
     255        usb_pipe_end_session(&ctrl_pipe);
    256256
    257257        /*
    … …  
    306306
    307307leave_stop_session:
    308         usb_endpoint_pipe_end_session(&ctrl_pipe);
     308        usb_pipe_end_session(&ctrl_pipe);
    309309
    310310leave_release_default_address:

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

    r361e61b r55e388a1  
    233233 * A session is something inside what any communication occurs.
    234234 * It is expected that sessions would be started right before the transfer
    235  * and ended - see usb_endpoint_pipe_end_session() - after the last
     235 * and ended - see usb_pipe_end_session() - after the last
    236236 * transfer.
    237237 * The reason for this is that session actually opens some communication
    … …  
    244244 * @return Error code.
    245245 */
    246 int usb_endpoint_pipe_start_session(usb_endpoint_pipe_t *pipe)
     246int usb_pipe_start_session(usb_pipe_t *pipe)
    247247{
    248248        assert(pipe);
    249249
    250         if (usb_endpoint_pipe_is_session_started(pipe)) {
     250        if (usb_pipe_is_session_started(pipe)) {
    251251                return EBUSY;
    252252        }
    … …  
    265265/** Ends a session on the endpoint pipe.
    266266 *
    267  * @see usb_endpoint_pipe_start_session
     267 * @see usb_pipe_start_session
    268268 *
    269269 * @param pipe Endpoint pipe to end the session on.
    270270 * @return Error code.
    271271 */
    272 int usb_endpoint_pipe_end_session(usb_endpoint_pipe_t *pipe)
     272int usb_pipe_end_session(usb_pipe_t *pipe)
    273273{
    274274        assert(pipe);
    275275
    276         if (!usb_endpoint_pipe_is_session_started(pipe)) {
     276        if (!usb_pipe_is_session_started(pipe)) {
    277277                return ENOENT;
    278278        }
    … …  
    296296 * @return Whether @p pipe has opened a session.
    297297 */
    298 bool usb_endpoint_pipe_is_session_started(usb_endpoint_pipe_t *pipe)
     298bool usb_pipe_is_session_started(usb_pipe_t *pipe)
    299299{
    300300        return (pipe->hc_phone >= 0);

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

    r361e61b r55e388a1  
    193193        }
    194194
    195         int rc = usb_endpoint_pipe_initialize(ep_mapping->pipe, wire,
     195        int rc = usb_pipe_initialize(ep_mapping->pipe, wire,
    196196            ep_no, description.transfer_type, endpoint->max_packet_size,
    197197            description.direction);
    … …  
    276276 * @return Error code.
    277277 */
    278 int usb_endpoint_pipe_initialize_from_configuration(
     278int usb_pipe_initialize_from_configuration(
    279279    usb_endpoint_mapping_t *mapping, size_t mapping_count,
    280280    uint8_t *configuration_descriptor, size_t configuration_descriptor_size,
    … …  
    342342 * @return Error code.
    343343 */
    344 int usb_endpoint_pipe_initialize(usb_endpoint_pipe_t *pipe,
     344int usb_pipe_initialize(usb_pipe_t *pipe,
    345345    usb_device_connection_t *connection, usb_endpoint_t endpoint_no,
    346346    usb_transfer_type_t transfer_type, size_t max_packet_size,
    … …  
    367367 * @return Error code.
    368368 */
    369 int usb_endpoint_pipe_initialize_default_control(usb_endpoint_pipe_t *pipe,
     369int usb_pipe_initialize_default_control(usb_pipe_t *pipe,
    370370    usb_device_connection_t *connection)
    371371{
    … …  
    373373        assert(connection);
    374374
    375         int rc = usb_endpoint_pipe_initialize(pipe, connection,
     375        int rc = usb_pipe_initialize(pipe, connection,
    376376            0, USB_TRANSFER_CONTROL, CTRL_PIPE_MIN_PACKET_SIZE,
    377377            USB_DIRECTION_BOTH);
    … …  
    390390 * @return Error code.
    391391 */
    392 int usb_endpoint_pipe_probe_default_control(usb_endpoint_pipe_t *pipe)
     392int usb_pipe_probe_default_control(usb_pipe_t *pipe)
    393393{
    394394        assert(pipe);
    … …  
    408408
    409409        TRY_LOOP(failed_attempts) {
    410                 rc = usb_endpoint_pipe_start_session(pipe);
     410                rc = usb_pipe_start_session(pipe);
    411411                if (rc == EOK) {
    412412                        break;
    … …  
    433433                }
    434434        }
    435         usb_endpoint_pipe_end_session(pipe);
     435        usb_pipe_end_session(pipe);
    436436        if (rc != EOK) {
    437437                return rc;
    … …  
    451451 * @return Error code.
    452452 */
    453 int usb_endpoint_pipe_register(usb_endpoint_pipe_t *pipe,
     453int usb_pipe_register(usb_pipe_t *pipe,
    454454    unsigned int interval,
    455455    usb_hc_connection_t *hc_connection)
    … …  
    479479 * @return Error code.
    480480 */
    481 int usb_endpoint_pipe_unregister(usb_endpoint_pipe_t *pipe,
     481int usb_pipe_unregister(usb_pipe_t *pipe,
    482482    usb_hc_connection_t *hc_connection)
    483483{

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

    r361e61b r55e388a1  
    5858 * @return Error code.
    5959 */
    60 static int usb_endpoint_pipe_read_no_checks(usb_endpoint_pipe_t *pipe,
     60static int usb_pipe_read_no_checks(usb_pipe_t *pipe,
    6161    void *buffer, size_t size, size_t *size_transfered)
    6262{
    … …  
    140140 * @return Error code.
    141141 */
    142 int usb_endpoint_pipe_read(usb_endpoint_pipe_t *pipe,
     142int usb_pipe_read(usb_pipe_t *pipe,
    143143    void *buffer, size_t size, size_t *size_transfered)
    144144{
    … …  
    153153        }
    154154
    155         if (!usb_endpoint_pipe_is_session_started(pipe)) {
     155        if (!usb_pipe_is_session_started(pipe)) {
    156156                return EBADF;
    157157        }
    … …  
    168168        int rc;
    169169
    170         rc = usb_endpoint_pipe_read_no_checks(pipe, buffer, size, &act_size);
     170        rc = usb_pipe_read_no_checks(pipe, buffer, size, &act_size);
    171171        if (rc != EOK) {
    172172                return rc;
    … …  
    190190 * @return Error code.
    191191 */
    192 static int usb_endpoint_pipe_write_no_check(usb_endpoint_pipe_t *pipe,
     192static int usb_pipe_write_no_check(usb_pipe_t *pipe,
    193193    void *buffer, size_t size)
    194194{
    … …  
    247247 * @return Error code.
    248248 */
    249 int usb_endpoint_pipe_write(usb_endpoint_pipe_t *pipe,
     249int usb_pipe_write(usb_pipe_t *pipe,
    250250    void *buffer, size_t size)
    251251{
    … …  
    260260        }
    261261
    262         if (!usb_endpoint_pipe_is_session_started(pipe)) {
     262        if (!usb_pipe_is_session_started(pipe)) {
    263263                return EBADF;
    264264        }
    … …  
    272272        }
    273273
    274         int rc = usb_endpoint_pipe_write_no_check(pipe, buffer, size);
     274        int rc = usb_pipe_write_no_check(pipe, buffer, size);
    275275
    276276        return rc;
    … …  
    289289 * @return Error code.
    290290 */
    291 static int usb_endpoint_pipe_control_read_no_check(usb_endpoint_pipe_t *pipe,
     291static int usb_pipe_control_read_no_check(usb_pipe_t *pipe,
    292292    void *setup_buffer, size_t setup_buffer_size,
    293293    void *data_buffer, size_t data_buffer_size, size_t *data_transfered_size)
    … …  
    365365 * @return Error code.
    366366 */
    367 int usb_endpoint_pipe_control_read(usb_endpoint_pipe_t *pipe,
     367int usb_pipe_control_read(usb_pipe_t *pipe,
    368368    void *setup_buffer, size_t setup_buffer_size,
    369369    void *data_buffer, size_t data_buffer_size, size_t *data_transfered_size)
    … …  
    379379        }
    380380
    381         if (!usb_endpoint_pipe_is_session_started(pipe)) {
     381        if (!usb_pipe_is_session_started(pipe)) {
    382382                return EBADF;
    383383        }
    … …  
    389389
    390390        size_t act_size = 0;
    391         int rc = usb_endpoint_pipe_control_read_no_check(pipe,
     391        int rc = usb_pipe_control_read_no_check(pipe,
    392392            setup_buffer, setup_buffer_size,
    393393            data_buffer, data_buffer_size, &act_size);
    … …  
    414414 * @return Error code.
    415415 */
    416 static int usb_endpoint_pipe_control_write_no_check(usb_endpoint_pipe_t *pipe,
     416static int usb_pipe_control_write_no_check(usb_pipe_t *pipe,
    417417    void *setup_buffer, size_t setup_buffer_size,
    418418    void *data_buffer, size_t data_buffer_size)
    … …  
    473473 * @return Error code.
    474474 */
    475 int usb_endpoint_pipe_control_write(usb_endpoint_pipe_t *pipe,
     475int usb_pipe_control_write(usb_pipe_t *pipe,
    476476    void *setup_buffer, size_t setup_buffer_size,
    477477    void *data_buffer, size_t data_buffer_size)
    … …  
    491491        }
    492492
    493         if (!usb_endpoint_pipe_is_session_started(pipe)) {
     493        if (!usb_pipe_is_session_started(pipe)) {
    494494                return EBADF;
    495495        }
    … …  
    500500        }
    501501
    502         int rc = usb_endpoint_pipe_control_write_no_check(pipe,
     502        int rc = usb_pipe_control_write_no_check(pipe,
    503503            setup_buffer, setup_buffer_size, data_buffer, data_buffer_size);
    504504

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

    r361e61b r55e388a1  
    311311 * @return Error code.
    312312 */
    313 int usb_device_create_match_ids(usb_endpoint_pipe_t *ctrl_pipe,
     313int usb_device_create_match_ids(usb_pipe_t *ctrl_pipe,
    314314    match_id_list_t *matches)
    315315{
    … …  
    363363        int rc;
    364364        usb_device_connection_t dev_connection;
    365         usb_endpoint_pipe_t ctrl_pipe;
     365        usb_pipe_t ctrl_pipe;
    366366
    367367        rc = usb_device_connection_initialize(&dev_connection, hc_handle, address);
    … …  
    370370        }
    371371
    372         rc = usb_endpoint_pipe_initialize_default_control(&ctrl_pipe,
     372        rc = usb_pipe_initialize_default_control(&ctrl_pipe,
    373373            &dev_connection);
    374374        if (rc != EOK) {
    375375                goto failure;
    376376        }
    377         rc = usb_endpoint_pipe_probe_default_control(&ctrl_pipe);
     377        rc = usb_pipe_probe_default_control(&ctrl_pipe);
    378378        if (rc != EOK) {
    379379                goto failure;
    … …  
    404404        child->driver_data = dev_data;
    405405
    406         rc = usb_endpoint_pipe_start_session(&ctrl_pipe);
     406        rc = usb_pipe_start_session(&ctrl_pipe);
    407407        if (rc != EOK) {
    408408                goto failure;
    … …  
    414414        }
    415415
    416         rc = usb_endpoint_pipe_end_session(&ctrl_pipe);
     416        rc = usb_pipe_end_session(&ctrl_pipe);
    417417        if (rc != EOK) {
    418418                goto failure;

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

    r361e61b r55e388a1  
    4242/** Generic wrapper for SET requests using standard control request format.
    4343 *
    44  * @see usb_endpoint_pipe_control_write
     44 * @see usb_pipe_control_write
    4545 *
    4646 * @param pipe Pipe used for the communication.
    … …  
    6060 * @retval ERANGE Data buffer too large.
    6161 */
    62 int usb_control_request_set(usb_endpoint_pipe_t *pipe,
     62int usb_control_request_set(usb_pipe_t *pipe,
    6363    usb_request_type_t request_type, usb_request_recipient_t recipient,
    6464    uint8_t request,
    … …  
    9090        setup_packet.length = (uint16_t) data_size;
    9191
    92         int rc = usb_endpoint_pipe_control_write(pipe,
     92        int rc = usb_pipe_control_write(pipe,
    9393            &setup_packet, sizeof(setup_packet),
    9494            data, data_size);
    … …  
    9999 /** Generic wrapper for GET requests using standard control request format.
    100100  *
    101   * @see usb_endpoint_pipe_control_read
     101  * @see usb_pipe_control_read
    102102  *
    103103  * @param pipe Pipe used for the communication.
    … …  
    120120  * @retval ERANGE Data buffer too large.
    121121  */
    122 int usb_control_request_get(usb_endpoint_pipe_t *pipe,
     122int usb_control_request_get(usb_pipe_t *pipe,
    123123    usb_request_type_t request_type, usb_request_recipient_t recipient,
    124124    uint8_t request,
    … …  
    150150        setup_packet.length = (uint16_t) data_size;
    151151
    152         int rc = usb_endpoint_pipe_control_read(pipe,
     152        int rc = usb_pipe_control_read(pipe,
    153153            &setup_packet, sizeof(setup_packet),
    154154            data, data_size, actual_data_size);
    … …  
    165165 * @return Error code.
    166166 */
    167 int usb_request_get_status(usb_endpoint_pipe_t *pipe,
     167int usb_request_get_status(usb_pipe_t *pipe,
    168168    usb_request_recipient_t recipient, uint16_t index,
    169169    uint16_t *status)
    … …  
    203203 * @return Error code.
    204204 */
    205 int usb_request_clear_feature(usb_endpoint_pipe_t *pipe,
     205int usb_request_clear_feature(usb_pipe_t *pipe,
    206206    usb_request_type_t request_type, usb_request_recipient_t recipient,
    207207    uint16_t feature_selector, uint16_t index)
    … …  
    231231 * @return Error code.
    232232 */
    233 int usb_request_set_feature(usb_endpoint_pipe_t *pipe,
     233int usb_request_set_feature(usb_pipe_t *pipe,
    234234    usb_request_type_t request_type, usb_request_recipient_t recipient,
    235235    uint16_t feature_selector, uint16_t index)
    … …  
    258258 * @return Error code.
    259259 */
    260 int usb_request_set_address(usb_endpoint_pipe_t *pipe,
     260int usb_request_set_address(usb_pipe_t *pipe,
    261261    usb_address_t new_address)
    262262{
    … …  
    297297 * @return Error code.
    298298 */
    299 int usb_request_get_descriptor(usb_endpoint_pipe_t *pipe,
     299int usb_request_get_descriptor(usb_pipe_t *pipe,
    300300    usb_request_type_t request_type, usb_request_recipient_t recipient,
    301301    uint8_t descriptor_type, uint8_t descriptor_index,
    … …  
    331331 * @return
    332332 */
    333 int usb_request_get_descriptor_alloc(usb_endpoint_pipe_t * pipe,
     333int usb_request_get_descriptor_alloc(usb_pipe_t * pipe,
    334334    usb_request_type_t request_type, usb_request_recipient_t recipient,
    335335    uint8_t descriptor_type, uint8_t descriptor_index,
    … …  
    400400 * @return Error code.
    401401 */
    402 int usb_request_get_device_descriptor(usb_endpoint_pipe_t *pipe,
     402int usb_request_get_device_descriptor(usb_pipe_t *pipe,
    403403    usb_standard_device_descriptor_t *descriptor)
    404404{
    … …  
    442442 * @return Error code.
    443443 */
    444 int usb_request_get_bare_configuration_descriptor(usb_endpoint_pipe_t *pipe,
     444int usb_request_get_bare_configuration_descriptor(usb_pipe_t *pipe,
    445445    int index, usb_standard_configuration_descriptor_t *descriptor)
    446446{
    … …  
    488488 * @return Error code.
    489489 */
    490 int usb_request_get_full_configuration_descriptor(usb_endpoint_pipe_t *pipe,
     490int usb_request_get_full_configuration_descriptor(usb_pipe_t *pipe,
    491491    int index, void *descriptor, size_t descriptor_size, size_t *actual_size)
    492492{
    … …  
    514514 */
    515515int usb_request_get_full_configuration_descriptor_alloc(
    516     usb_endpoint_pipe_t *pipe, int index,
     516    usb_pipe_t *pipe, int index,
    517517    void **descriptor_ptr, size_t *descriptor_size)
    518518{
    … …  
    578578 * @return Error code.
    579579 */
    580 int usb_request_set_descriptor(usb_endpoint_pipe_t *pipe,
     580int usb_request_set_descriptor(usb_pipe_t *pipe,
    581581    usb_request_type_t request_type, usb_request_recipient_t recipient,
    582582    uint8_t descriptor_type, uint8_t descriptor_index,
    … …  
    607607 * @return Error code.
    608608 */
    609 int usb_request_get_configuration(usb_endpoint_pipe_t *pipe,
     609int usb_request_get_configuration(usb_pipe_t *pipe,
    610610    uint8_t *configuration_value)
    611611{
    … …  
    639639 * @return Error code.
    640640 */
    641 int usb_request_set_configuration(usb_endpoint_pipe_t *pipe,
     641int usb_request_set_configuration(usb_pipe_t *pipe,
    642642    uint8_t configuration_value)
    643643{
    … …  
    658658 * @return Error code.
    659659 */
    660 int usb_request_get_interface(usb_endpoint_pipe_t *pipe,
     660int usb_request_get_interface(usb_pipe_t *pipe,
    661661    uint8_t interface_index, uint8_t *alternate_setting)
    662662{
    … …  
    691691 * @return Error code.
    692692 */
    693 int usb_request_set_interface(usb_endpoint_pipe_t *pipe,
     693int usb_request_set_interface(usb_pipe_t *pipe,
    694694    uint8_t interface_index, uint8_t alternate_setting)
    695695{
    … …  
    710710 * @return Error code.
    711711 */
    712 int usb_request_get_supported_languages(usb_endpoint_pipe_t *pipe,
     712int usb_request_get_supported_languages(usb_pipe_t *pipe,
    713713    l18_win_locales_t **languages_ptr, size_t *languages_count)
    714714{
    … …  
    782782 * @return Error code.
    783783 */
    784 int usb_request_get_string(usb_endpoint_pipe_t *pipe,
     784int usb_request_get_string(usb_pipe_t *pipe,
    785785    size_t index, l18_win_locales_t lang, char **string_ptr)
    786786{

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

    r361e61b r55e388a1  
    3636#include <errno.h>
    3737
     38#define ARR_SIZE(arr) (sizeof(arr)/sizeof(arr[0]))
     39
     40static const char *str_speed[] = {
     41        "low",
     42        "full",
     43        "high"
     44};
     45
     46static const char *str_transfer_type[] = {
     47        "control",
     48        "isochronous",
     49        "bulk",
     50        "interrupt"
     51};
     52
     53static const char *str_transfer_type_short[] = {
     54        "ctrl",
     55        "iso",
     56        "bulk",
     57        "intr"
     58};
    3859
    3960/** String representation for USB transfer type.
    … …  
    4263 * @return Transfer type as a string (in English).
    4364 */
    44 const char * usb_str_transfer_type(usb_transfer_type_t t)
     65const char *usb_str_transfer_type(usb_transfer_type_t t)
    4566{
    46         switch (t) {
    47                 case USB_TRANSFER_ISOCHRONOUS:
    48                         return "isochronous";
    49                 case USB_TRANSFER_INTERRUPT:
    50                         return "interrupt";
    51                 case USB_TRANSFER_CONTROL:
    52                         return "control";
    53                 case USB_TRANSFER_BULK:
    54                         return "bulk";
    55                 default:
    56                         return "unknown";
     67        if (t >= ARR_SIZE(str_transfer_type)) {
     68                return "invalid";
    5769        }
     70        return str_transfer_type[t];
     71}
     72
     73/** String representation for USB transfer type (short version).
     74 *
     75 * @param t Transfer type.
     76 * @return Transfer type as a short string for debugging messages.
     77 */
     78const char *usb_str_transfer_type_short(usb_transfer_type_t t)
     79{
     80        if (t >= ARR_SIZE(str_transfer_type_short)) {
     81                return "invl";
     82        }
     83        return str_transfer_type_short[t];
     84}
     85
     86/** String representation of USB speed.
     87 *
     88 * @param s The speed.
     89 * @return USB speed as a string (in English).
     90 */
     91const char *usb_str_speed(usb_speed_t s)
     92{
     93        if (s >= ARR_SIZE(str_speed)) {
     94                return "invalid";
     95        }
     96        return str_speed[s];
    5897}
    5998
Note: See TracChangeset for help on using the changeset viewer.