Changeset f8e8738 in mainline for uspace/lib

Timestamp:

2011-04-07T20:22:40Z (15 years ago)

Author:

Lubos Slovak <lubos.slovak@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

fee6381

Parents:

61257f4 (diff), a82889e (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:

Changes from development

Location:

uspace/lib

Files:

• c/Makefile (modified) (1 diff)
• c/arch/abs32le/_link.ld.in (modified) (1 diff)
• c/arch/amd64/_link.ld.in (modified) (1 diff)
• c/arch/arm32/_link.ld.in (modified) (1 diff)
• c/arch/ia32/_link.ld.in (modified) (1 diff)
• c/arch/ia64/_link.ld.in (modified) (2 diffs)
• c/arch/mips32/_link.ld.in (modified) (1 diff)
• c/arch/ppc32/_link.ld.in (modified) (1 diff)
• c/arch/sparc64/_link.ld.in (modified) (1 diff)
• c/generic/adt/hash_table.c (modified) (1 diff)
• c/generic/devman.c (modified) (3 diffs)
• c/generic/io/log.c (added)
• c/generic/net/packet.c (modified) (1 diff)
• c/generic/net/socket_client.c (modified) (1 diff)
• c/generic/vfs/vfs.c (modified) (1 diff)
• c/include/adt/generic_char_map.h (modified) (6 diffs)
• c/include/adt/generic_field.h (modified) (4 diffs)
• c/include/adt/hash_table.h (modified) (2 diffs)
• c/include/adt/int_map.h (modified) (10 diffs)
• c/include/devman.h (modified) (1 diff)
• c/include/io/log.h (moved) (moved from kernel/arch/amd64/include/memstr.h ) (2 diffs)
• c/include/ipc/devman.h (modified) (1 diff)
• drv/Makefile (modified) (1 diff)
• drv/generic/driver.c (modified) (1 diff)
• drv/generic/log.c (added)
• drv/include/ddf/log.h (moved) (moved from kernel/arch/ia32/include/memstr.h ) (2 diffs)
• net/tl/socket_core.c (modified) (3 diffs)
• net/tl/tl_common.c (modified) (1 diff)
• usb/Makefile (modified) (1 diff)
• usb/include/usb/devdrv.h (modified) (5 diffs)
• usb/include/usb/host/batch.h (modified) (3 diffs)
• usb/include/usb/host/device_keeper.h (modified) (4 diffs)
• usb/include/usb/host/endpoint.h (added)
• usb/include/usb/host/usb_endpoint_manager.h (added)
• usb/include/usb/pipes.h (modified) (1 diff)
• usb/src/devdrv.c (modified) (11 diffs)
• usb/src/host/batch.c (modified) (2 diffs)
• usb/src/host/device_keeper.c (modified) (11 diffs)
• usb/src/host/endpoint.c (added)
• usb/src/host/usb_endpoint_manager.c (added)
• usb/src/hub.c (modified) (6 diffs)
• usb/src/pipesinit.c (modified) (3 diffs)
• usb/src/request.c (modified) (1 diff)

uspace/lib/c/Makefile

@@ -77 +77 @@
         generic/io/io.c \
         generic/io/printf.c \
+        generic/io/log.c \
         generic/io/klog.c \
         generic/io/snprintf.c \

uspace/lib/c/arch/abs32le/_link.ld.in

@@ -11 +11 @@
         
         .text : {
-                *(.text);
-                *(.rodata*);
+                *(.text .text.*);
+                *(.rodata .rodata.*);
         } :text
         

uspace/lib/c/arch/amd64/_link.ld.in

@@ -16 +16 @@
         
         .text : {
-                *(.text);
-                *(.rodata*);
+                *(.text .text.*);
+                *(.rodata .rodata.*);
         } :text
         

uspace/lib/c/arch/arm32/_link.ld.in

@@ -15 +15 @@
         
         .text : {
-                *(.text);
-                *(.rodata*);
+                *(.text .text.*);
+                *(.rodata .rodata.*);
         } :text
         

uspace/lib/c/arch/ia32/_link.ld.in

@@ -16 +16 @@
         
         .text : {
-                *(.text);
-                *(.rodata*);
+                *(.text .text.*);
+                *(.rodata .rodata.*);
         } :text
         

uspace/lib/c/arch/ia64/_link.ld.in

@@ -15 +15 @@
         
         .text : {
-                *(.text);
-                *(.rodata*);
+                *(.text .text.*);
+                *(.rodata .rodata.*);
         } :text
         
@@ -23 +23 @@
         .got : {
                 _gp = .;
-                *(.got*);
+                *(.got .got.*);
         } :data
         

uspace/lib/c/arch/mips32/_link.ld.in

@@ -15 +15 @@
         
         .text : {
-                *(.text);
-                *(.rodata*);
+                *(.text .text.*);
+                *(.rodata .rodata.*);
         } :text
         

uspace/lib/c/arch/ppc32/_link.ld.in

@@ -15 +15 @@
         
         .text : {
-                *(.text);
-                *(.rodata*);
+                *(.text .text.*);
+                *(.rodata .rodata.*);
         } :text
         

uspace/lib/c/arch/sparc64/_link.ld.in

@@ -15 +15 @@
         
         .text : {
-                *(.text);
-                *(.rodata*);
+                *(.text .text.*);
+                *(.rodata .rodata.*);
         } :text
         

uspace/lib/c/generic/adt/hash_table.c

@@ -54 +54 @@
  *
  */
-int hash_table_create(hash_table_t *h, hash_count_t m, hash_count_t max_keys,
+bool hash_table_create(hash_table_t *h, hash_count_t m, hash_count_t max_keys,
     hash_table_operations_t *op)
 {

uspace/lib/c/generic/devman.c

@@ -147 +147 @@
                 ret = devman_send_match_id(phone, match_id);
                 if (ret != EOK) {
-                        printf("Driver failed to send match id, error %d\n",
-                            ret);
                         return ret;
                 }
@@ -195 +193 @@
         }
         
-        devman_send_match_ids(phone, match_ids);
-        
-        async_wait_for(req, &retval);
-        
-        async_serialize_end();
-        
+        int match_ids_rc = devman_send_match_ids(phone, match_ids);
+        
+        async_wait_for(req, &retval);
+        
+        async_serialize_end();
+        
+        /* Prefer the answer to DEVMAN_ADD_FUNCTION in case of errors. */
+        if ((match_ids_rc != EOK) && (retval == EOK)) {
+                retval = match_ids_rc;
+        }
+
         if (retval == EOK)
                 fun_handle = (int) IPC_GET_ARG1(answer);
@@ -326 +329 @@
 }
 
+int devman_device_get_handle_by_class(const char *classname,
+    const char *devname, devman_handle_t *handle, unsigned int flags)
+{
+        int phone = devman_get_phone(DEVMAN_CLIENT, flags);
+
+        if (phone < 0)
+                return phone;
+
+        async_serialize_start();
+
+        ipc_call_t answer;
+        aid_t req = async_send_1(phone, DEVMAN_DEVICE_GET_HANDLE_BY_CLASS,
+            flags, &answer);
+
+        sysarg_t retval = async_data_write_start(phone, classname,
+            str_size(classname));
+        if (retval != EOK) {
+                async_wait_for(req, NULL);
+                async_serialize_end();
+                return retval;
+        }
+        retval = async_data_write_start(phone, devname,
+            str_size(devname));
+        if (retval != EOK) {
+                async_wait_for(req, NULL);
+                async_serialize_end();
+                return retval;
+        }
+
+        async_wait_for(req, &retval);
+
+        async_serialize_end();
+
+        if (retval != EOK) {
+                if (handle != NULL)
+                        *handle = (devman_handle_t) -1;
+                return retval;
+        }
+
+        if (handle != NULL)
+                *handle = (devman_handle_t) IPC_GET_ARG1(answer);
+
+        return retval;
+}
+
 
 /** @}

uspace/lib/c/generic/net/packet.c

@@ -190 +190 @@
                 }
         }
-        gpm_destroy(&pm_globals.packet_map);
+        gpm_destroy(&pm_globals.packet_map, free);
         /* leave locked */
 }

uspace/lib/c/generic/net/socket_client.c

@@ -749 +749 @@
         dyn_fifo_destroy(&socket->received);
         dyn_fifo_destroy(&socket->accepted);
-        sockets_exclude(socket_get_sockets(), socket->socket_id);
+        sockets_exclude(socket_get_sockets(), socket->socket_id, free);
 }
 

uspace/lib/c/generic/vfs/vfs.c

@@ -756 +756 @@
 {
         struct stat stat;
-        int rc;
-
-        rc = fstat(fildes, &stat);
-
+        
+        int rc = fstat(fildes, &stat);
+        if (rc != 0)
+                return rc;
+        
         if (!stat.device)
                 return -1;

uspace/lib/c/include/adt/generic_char_map.h

@@ -47 +47 @@
 #define GENERIC_CHAR_MAP_MAGIC_VALUE    0x12345622
 
+/** Generic destructor function pointer. */
+#define DTOR_T(identifier) \
+        void (*identifier)(const void *)
+
 /** Character string to generic type map declaration.
  *  @param[in] name     Name of the map.
@@ -64 +68 @@
         int name##_add(name##_t *, const uint8_t *, const size_t, type *); \
         int name##_count(name##_t *); \
-        void name##_destroy(name##_t *); \
-        void name##_exclude(name##_t *, const uint8_t *, const size_t); \
+        void name##_destroy(name##_t *, DTOR_T()); \
+        void name##_exclude(name##_t *, const uint8_t *, const size_t, DTOR_T()); \
         type *name##_find(name##_t *, const uint8_t *, const size_t); \
         int name##_initialize(name##_t *); \
@@ -84 +88 @@
              type *value) \
         { \
-                int rc; \
                 int index; \
                 if (!name##_is_valid(map)) \
@@ -91 +94 @@
                 if (index < 0) \
                         return index; \
-                rc = char_map_add(&map->names, name, length, index); \
-                if (rc != EOK) { \
-                        name##_items_exclude_index(&map->values, index); \
-                        return rc; \
-                } \
-                return EOK; \
+                return char_map_add(&map->names, name, length, index); \
         } \
         \
@@ -105 +103 @@
         } \
         \
-        void name##_destroy(name##_t *map) \
+        void name##_destroy(name##_t *map, DTOR_T(dtor)) \
         { \
                 if (name##_is_valid(map)) { \
                         char_map_destroy(&map->names); \
-                        name##_items_destroy(&map->values); \
+                        name##_items_destroy(&map->values, dtor); \
                 } \
         } \
         \
         void name##_exclude(name##_t *map, const uint8_t *name, \
-            const size_t length) \
+            const size_t length, DTOR_T(dtor)) \
         { \
                 if (name##_is_valid(map)) { \
@@ -121 +119 @@
                         if (index != CHAR_MAP_NULL) \
                                 name##_items_exclude_index(&map->values, \
-                                     index); \
+                                     index, dtor); \
                 } \
         } \

uspace/lib/c/include/adt/generic_field.h

@@ -46 +46 @@
 #define GENERIC_FIELD_MAGIC_VALUE               0x55667788
 
+/** Generic destructor function pointer. */
+#define DTOR_T(identifier) \
+        void (*identifier)(const void *)
+
 /** Generic type field declaration.
  *
@@ -63 +67 @@
         int name##_add(name##_t *, type *); \
         int name##_count(name##_t *); \
-        void name##_destroy(name##_t *); \
-        void name##_exclude_index(name##_t *, int); \
+        void name##_destroy(name##_t *, DTOR_T()); \
+        void name##_exclude_index(name##_t *, int, DTOR_T()); \
         type **name##_get_field(name##_t *); \
         type *name##_get_index(name##_t *, int); \
@@ -103 +107 @@
         } \
         \
-        void name##_destroy(name##_t *field) \
+        void name##_destroy(name##_t *field, DTOR_T(dtor)) \
         { \
                 if (name##_is_valid(field)) { \
                         int index; \
                         field->magic = 0; \
-                        for (index = 0; index < field->next; index++) { \
-                                if (field->items[index]) \
-                                        free(field->items[index]); \
+                        if (dtor) { \
+                                for (index = 0; index < field->next; index++) { \
+                                        if (field->items[index]) \
+                                                dtor(field->items[index]); \
+                                } \
                         } \
                         free(field->items); \
@@ -116 +122 @@
         } \
          \
-        void name##_exclude_index(name##_t *field, int index) \
+        void name##_exclude_index(name##_t *field, int index, DTOR_T(dtor)) \
         { \
                 if (name##_is_valid(field) && (index >= 0) && \
                     (index < field->next) && (field->items[index])) { \
-                        free(field->items[index]); \
+                        if (dtor) \
+                                dtor(field->items[index]); \
                         field->items[index] = NULL; \
                 } \

uspace/lib/c/include/adt/hash_table.h

@@ -38 +38 @@
 #include <adt/list.h>
 #include <unistd.h>
+#include <bool.h>
 
 typedef unsigned long hash_count_t;
@@ -83 +84 @@
     list_get_instance((item), type, member)
 
-extern int hash_table_create(hash_table_t *, hash_count_t, hash_count_t,
+extern bool hash_table_create(hash_table_t *, hash_count_t, hash_count_t,
     hash_table_operations_t *);
 extern void hash_table_insert(hash_table_t *, unsigned long [], link_t *);

uspace/lib/c/include/adt/int_map.h

@@ -49 +49 @@
 #define INT_MAP_ITEM_MAGIC_VALUE        0x55667788
 
+/** Generic destructor function pointer. */
+#define DTOR_T(identifier) \
+        void (*identifier)(const void *)
+
 /** Integer to generic type map declaration.
  *
@@ -72 +76 @@
         \
         int name##_add(name##_t *, int, type *); \
-        void name##_clear(name##_t *); \
+        void name##_clear(name##_t *, DTOR_T()); \
         int name##_count(name##_t *); \
-        void name##_destroy(name##_t *); \
-        void name##_exclude(name##_t *, int); \
-        void name##_exclude_index(name##_t *, int); \
+        void name##_destroy(name##_t *, DTOR_T()); \
+        void name##_exclude(name##_t *, int, DTOR_T()); \
+        void name##_exclude_index(name##_t *, int, DTOR_T()); \
         type *name##_find(name##_t *, int); \
         int name##_update(name##_t *, int, int); \
@@ -82 +86 @@
         int name##_initialize(name##_t *); \
         int name##_is_valid(name##_t *); \
-        void name##_item_destroy(name##_item_t *); \
+        void name##_item_destroy(name##_item_t *, DTOR_T()); \
         int name##_item_is_valid(name##_item_t *);
 
@@ -115 +119 @@
         } \
         \
-        void name##_clear(name##_t *map) \
+        void name##_clear(name##_t *map, DTOR_T(dtor)) \
         { \
                 if (name##_is_valid(map)) { \
@@ -122 +126 @@
                                 if (name##_item_is_valid(&map->items[index])) { \
                                         name##_item_destroy( \
-                                            &map->items[index]); \
+                                            &map->items[index], dtor); \
                                 } \
                         } \
@@ -135 +139 @@
         } \
         \
-        void name##_destroy(name##_t *map) \
+        void name##_destroy(name##_t *map, DTOR_T(dtor)) \
         { \
                 if (name##_is_valid(map)) { \
@@ -143 +147 @@
                                 if (name##_item_is_valid(&map->items[index])) { \
                                         name##_item_destroy( \
-                                            &map->items[index]); \
+                                            &map->items[index], dtor); \
                                 } \
                         } \
@@ -150 +154 @@
         } \
         \
-        void name##_exclude(name##_t *map, int key) \
+        void name##_exclude(name##_t *map, int key, DTOR_T(dtor)) \
         { \
                 if (name##_is_valid(map)) { \
@@ -158 +162 @@
                                     (map->items[index].key == key)) { \
                                         name##_item_destroy( \
-                                            &map->items[index]); \
-                                } \
-                        } \
-                } \
-        } \
-        \
-        void name##_exclude_index(name##_t *map, int index) \
+                                            &map->items[index], dtor); \
+                                } \
+                        } \
+                } \
+        } \
+        \
+        void name##_exclude_index(name##_t *map, int index, DTOR_T(dtor)) \
         { \
                 if (name##_is_valid(map) && (index >= 0) && \
                     (index < map->next) && \
                     name##_item_is_valid(&map->items[index])) { \
-                        name##_item_destroy(&map->items[index]); \
+                        name##_item_destroy(&map->items[index], dtor); \
                 } \
         } \
@@ -236 +240 @@
         } \
         \
-        void name##_item_destroy(name##_item_t *item) \
+        void name##_item_destroy(name##_item_t *item, DTOR_T(dtor)) \
         { \
                 if (name##_item_is_valid(item)) { \
                         item->magic = 0; \
                         if (item->value) { \
-                                free(item->value); \
+                                if (dtor) \
+                                        dtor(item->value); \
                                 item->value = NULL; \
                         } \

uspace/lib/c/include/devman.h

@@ -53 +53 @@
 extern int devman_device_get_handle(const char *, devman_handle_t *,
     unsigned int);
+extern int devman_device_get_handle_by_class(const char *, const char *,
+    devman_handle_t *, unsigned int);
 
 extern int devman_add_device_to_class(devman_handle_t, const char *);

uspace/lib/c/include/io/log.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2005 Sergey Bondari
+ * Copyright (c) 2011 Vojtech Horky
+ * Copyright (c) 2011 Jiri Svoboda
  * All rights reserved.
  *
@@ -27 +28 @@
  */
 
-/** @addtogroup amd64
+/** @addtogroup libc
  * @{
  */
-/** @file
- */
 
-#ifndef KERN_amd64_MEMSTR_H_
-#define KERN_amd64_MEMSTR_H_
+#ifndef LIBC_IO_LOG_H_
+#define LIBC_IO_LOG_H_
 
-#define memcpy(dst, src, cnt)  __builtin_memcpy((dst), (src), (cnt))
+#include <stdarg.h>
 
-extern void memsetw(void *, size_t, uint16_t);
-extern void memsetb(void *, size_t, uint8_t);
+typedef enum {
+        LVL_FATAL,
+        LVL_ERROR,
+        LVL_WARN,
+        LVL_NOTE,
+        LVL_DEBUG,
+        LVL_DEBUG2,
+
+        /** For checking range of values */
+        LVL_LIMIT
+} log_level_t;
+
+extern int log_init(const char *, log_level_t);
+extern void log_msg(log_level_t, const char *, ...);
+extern void log_msgv(log_level_t, const char *, va_list);
 
 #endif

uspace/lib/c/include/ipc/devman.h

@@ -148 +148 @@
 
 typedef enum {
-        DEVMAN_DEVICE_GET_HANDLE = IPC_FIRST_USER_METHOD
+        DEVMAN_DEVICE_GET_HANDLE = IPC_FIRST_USER_METHOD,
+        DEVMAN_DEVICE_GET_HANDLE_BY_CLASS
 } client_to_devman_t;
 

uspace/lib/drv/Makefile

@@ -36 +36 @@
         generic/dev_iface.c \
         generic/remote_char_dev.c \
+        generic/log.c \
         generic/remote_hw_res.c \
         generic/remote_usb.c \

uspace/lib/drv/generic/driver.c

@@ -273 +273 @@
         
         res = driver->driver_ops->add_device(dev);
-        if (res == EOK) {
-                printf("%s: new device with handle=%" PRIun " was added.\n",
-                    driver->name, dev_handle);
-        } else {
-                printf("%s: failed to add a new device with handle = %" PRIun ".\n",
-                    driver->name, dev_handle);
+        if (res != EOK)
                 delete_device(dev);
-        }
         
         async_answer_0(iid, res);

uspace/lib/drv/include/ddf/log.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2005 Sergey Bondari
+ * Copyright (c) 2011 Jiri Svoboda
  * All rights reserved.
  *
@@ -27 +27 @@
  */
 
-/** @addtogroup ia32
+/** @addtogroup libdrv
  * @{
  */
-/** @file
- */
 
-#ifndef KERN_ia32_MEMSTR_H_
-#define KERN_ia32_MEMSTR_H_
+#ifndef DDF_LOG_H_
+#define DDF_LOG_H_
 
-#define memcpy(dst, src, cnt)  __builtin_memcpy((dst), (src), (cnt))
+#include <io/log.h>
 
-extern void memsetw(void *, size_t, uint16_t);
-extern void memsetb(void *, size_t, uint8_t);
+extern int ddf_log_init(const char *, log_level_t);
+extern void ddf_msg(log_level_t, const char *, ...);
 
 #endif

uspace/lib/net/tl/socket_core.c

@@ -107 +107 @@
                 socket_release(socket);
 
-        socket_cores_exclude(local_sockets, socket->socket_id);
+        socket_cores_exclude(local_sockets, socket->socket_id, free);
 }
 
@@ -230 +230 @@
 
 fail:
-        socket_port_map_destroy(&socket_port->map);
+        socket_port_map_destroy(&socket_port->map, free);
         free(socket_port);
         return rc;
@@ -649 +649 @@
                         if (socket_port->count <= 0) {
                                 // destroy the map
-                                socket_port_map_destroy(&socket_port->map);
+                                socket_port_map_destroy(&socket_port->map, free);
                                 // release the port
                                 socket_ports_exclude(global_sockets,
-                                    socket->port);
+                                    socket->port, free);
                         } else {
                                 // remove
                                 socket_port_map_exclude(&socket_port->map,
-                                    socket->key, socket->key_length);
+                                    socket->key, socket->key_length, free);
                         }
                 }

uspace/lib/net/tl/tl_common.c

@@ -182 +182 @@
                         else
                                 packet_dimensions_exclude(packet_dimensions,
-                                    DEVICE_INVALID_ID);
+                                    DEVICE_INVALID_ID, free);
                 }
         }

uspace/lib/usb/Makefile

@@ -53 +53 @@
         src/hidreport.c \
         src/host/device_keeper.c \
-        src/host/batch.c
+        src/host/batch.c \
+        src/host/endpoint.c \
+        src/host/usb_endpoint_manager.c
 
 include $(USPACE_PREFIX)/Makefile.common

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

@@ -47 +47 @@
 } usb_device_descriptors_t;
 
+/** Wrapper for data related to alternate interface setting.
+ * The pointers will typically point inside configuration descriptor and
+ * thus you shall not deallocate them.
+ */
+typedef struct {
+        /** Interface descriptor. */
+        usb_standard_interface_descriptor_t *interface;
+        /** Pointer to start of descriptor tree bound with this interface. */
+        uint8_t *nested_descriptors;
+        /** Size of data pointed by nested_descriptors in bytes. */
+        size_t nested_descriptors_size;
+} usb_alternate_interface_descriptors_t;
+
+/** Alternate interface settings. */
+typedef struct {
+        /** Array of alternate interfaces descriptions. */
+        usb_alternate_interface_descriptors_t *alternatives;
+        /** Size of @c alternatives array. */
+        size_t alternative_count;
+        /** Index of currently selected one. */
+        size_t current;
+} usb_alternate_interfaces_t;
+
 /** USB device structure. */
 typedef struct {
@@ -56 +79 @@
          */
         usb_endpoint_mapping_t *pipes;
+        /** Number of other endpoint pipes. */
+        size_t pipes_count;
         /** Current interface.
          * Usually, drivers operate on single interface only.
@@ -61 +86 @@
          */
         int interface_no;
+
+        /** Alternative interfaces.
+         * Set to NULL when the driver controls whole device
+         * (i.e. more (or any) interfaces).
+         */
+        usb_alternate_interfaces_t *alternate_interfaces;
 
         /** Some useful descriptors. */
@@ -92 +123 @@
          */
         const char *name;
-        /** Expected endpoints description, excluding default control endpoint.
+        /** Expected endpoints description.
+         * This description shall exclude default control endpoint (pipe zero)
+         * and must be NULL terminated.
+         * When only control endpoint is expected, you may set NULL directly
+         * without creating one item array containing NULL.
          *
-         * It MUST be of size expected_enpoints_count(excluding default ctrl) + 1
-         * where the last record MUST BE NULL, otherwise catastrophic things may
-         * happen.
+         * When the driver expect single interrupt in endpoint,
+         * the initialization may look like this:
+\code
+static usb_endpoint_description_t poll_endpoint_description = {
+        .transfer_type = USB_TRANSFER_INTERRUPT,
+        .direction = USB_DIRECTION_IN,
+        .interface_class = USB_CLASS_HUB,
+        .interface_subclass = 0,
+        .interface_protocol = 0,
+        .flags = 0
+};
+
+static usb_endpoint_description_t *hub_endpoints[] = {
+        &poll_endpoint_description,
+        NULL
+};
+
+static usb_driver_t hub_driver = {
+        .endpoints = hub_endpoints,
+        ...
+};
+\endcode
          */
         usb_endpoint_description_t **endpoints;
@@ -105 +159 @@
 int usb_driver_main(usb_driver_t *);
 
+int usb_device_select_interface(usb_device_t *, uint8_t,
+    usb_endpoint_description_t **);
+
 typedef bool (*usb_polling_callback_t)(usb_device_t *,
     uint8_t *, size_t, void *);
 typedef void (*usb_polling_terminted_callback_t)(usb_device_t *, bool, void *);
-
 
 int usb_device_auto_poll(usb_device_t *, size_t,

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

@@ -39 +39 @@
 #include <usbhc_iface.h>
 #include <usb/usb.h>
+#include <usb/host/endpoint.h>
 
 typedef struct usb_transfer_batch usb_transfer_batch_t;
@@ -60 +61 @@
         ddf_fun_t *fun;
         void *arg;
+        endpoint_t *ep;
         void *private_data;
 };
@@ -78 +80 @@
     void *arg,
     ddf_fun_t *fun,
+                endpoint_t *ep,
     void *private_data
 );

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

@@ -40 +40 @@
 #ifndef LIBUSB_HOST_DEVICE_KEEPER_H
 #define LIBUSB_HOST_DEVICE_KEEPER_H
+
+#include <adt/list.h>
 #include <devman.h>
 #include <fibril_synch.h>
 #include <usb/usb.h>
+#include <usb/host/endpoint.h>
 
 /** Number of USB address for array dimensions. */
@@ -51 +54 @@
         usb_speed_t speed;
         bool occupied;
-        bool control_used;
-        uint16_t toggle_status[2];
+        link_t endpoints;
+        uint16_t control_used;
         devman_handle_t handle;
 };
@@ -68 +71 @@
 void usb_device_keeper_init(usb_device_keeper_t *instance);
 
-void usb_device_keeper_reserve_default_address(usb_device_keeper_t *instance,
-    usb_speed_t speed);
+void usb_device_keeper_add_ep(
+    usb_device_keeper_t *instance, usb_address_t address, endpoint_t *ep);
+
+void usb_device_keeper_reserve_default_address(
+    usb_device_keeper_t *instance, usb_speed_t speed);
 
 void usb_device_keeper_release_default_address(usb_device_keeper_t *instance);
 
 void usb_device_keeper_reset_if_need(usb_device_keeper_t *instance,
-    usb_target_t target,
-    const uint8_t *setup_data);
-
-int usb_device_keeper_get_toggle(usb_device_keeper_t *instance,
-    usb_target_t target, usb_direction_t direction);
-
-int usb_device_keeper_set_toggle(usb_device_keeper_t *instance,
-    usb_target_t target, usb_direction_t direction, bool toggle);
+    usb_target_t target, const uint8_t *setup_data);
 
 usb_address_t device_keeper_get_free_address(usb_device_keeper_t *instance,
@@ -99 +98 @@
 
 void usb_device_keeper_use_control(usb_device_keeper_t *instance,
-    usb_address_t address);
+    usb_target_t target);
 
 void usb_device_keeper_release_control(usb_device_keeper_t *instance,
-    usb_address_t address);
+    usb_target_t target);
 
 #endif

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

@@ -107 +107 @@
         /** Interface number the endpoint must belong to (-1 for any). */
         int interface_no;
+        /** Alternate interface setting to choose. */
+        int interface_setting;
         /** Found descriptor fitting the description. */
         usb_standard_endpoint_descriptor_t *descriptor;

uspace/lib/usb/src/devdrv.c

@@ -36 +36 @@
 #include <usb/request.h>
 #include <usb/debug.h>
+#include <usb/dp.h>
 #include <errno.h>
 #include <str_error.h>
@@ -86 +87 @@
  * @return Number of pipes (excluding default control pipe).
  */
-static size_t count_other_pipes(usb_driver_t *drv)
+static size_t count_other_pipes(usb_endpoint_description_t **endpoints)
 {
         size_t count = 0;
-        if (drv->endpoints == NULL) {
+        if (endpoints == NULL) {
                 return 0;
         }
 
-        while (drv->endpoints[count] != NULL) {
+        while (endpoints[count] != NULL) {
                 count++;
         }
@@ -106 +107 @@
  * @return Error code.
  */
-static int initialize_other_pipes(usb_driver_t *drv, usb_device_t *dev)
+static int initialize_other_pipes(usb_endpoint_description_t **endpoints,
+    usb_device_t *dev)
 {
         int rc;
-        dev->interface_no = usb_device_get_assigned_interface(dev->ddf_dev);
-
-        size_t pipe_count = count_other_pipes(drv);
+
+        size_t pipe_count = count_other_pipes(endpoints);
+        if (pipe_count == 0) {
+                return EOK;
+        }
+
         dev->pipes = malloc(sizeof(usb_endpoint_mapping_t) * pipe_count);
         if (dev->pipes == NULL) {
@@ -133 +138 @@
                 }
 
-                dev->pipes[i].description = drv->endpoints[i];
+                dev->pipes[i].description = endpoints[i];
                 dev->pipes[i].interface_no = dev->interface_no;
+                dev->pipes[i].interface_setting = 0;
         }
 
@@ -178 +184 @@
         usb_hc_connection_close(&hc_conn);
 
+        dev->pipes_count = pipe_count;
+
         return EOK;
 
@@ -227 +235 @@
         }
 
+        /* Get our interface. */
+        dev->interface_no = usb_device_get_assigned_interface(dev->ddf_dev);
+
         /*
          * For further actions, we need open session on default control pipe.
@@ -251 +262 @@
             &dev->descriptors.configuration_size);
         if (rc != EOK) {
-                usb_log_error("Failed retrieving configuration descriptor: %s.\n",
+                usb_log_error("Failed retrieving configuration descriptor: %s. %s\n",
                     dev->ddf_dev->name, str_error(rc));
                 return rc;
@@ -257 +268 @@
 
         if (driver->endpoints != NULL) {
-                rc = initialize_other_pipes(driver, dev);
+                rc = initialize_other_pipes(driver->endpoints, dev);
         }
 
@@ -271 +282 @@
 
         return rc;
+}
+
+/** Count number of alternate settings of a interface.
+ *
+ * @param config_descr Full configuration descriptor.
+ * @param config_descr_size Size of @p config_descr in bytes.
+ * @param interface_no Interface number.
+ * @return Number of alternate interfaces for @p interface_no interface.
+ */
+static size_t count_alternate_interfaces(uint8_t *config_descr,
+    size_t config_descr_size, int interface_no)
+{
+        assert(config_descr != NULL);
+        usb_dp_parser_t dp_parser = {
+                .nesting = usb_dp_standard_descriptor_nesting
+        };
+        usb_dp_parser_data_t dp_data = {
+                .data = config_descr,
+                .size = config_descr_size,
+                .arg = NULL
+        };
+
+        size_t alternate_count = 0;
+
+        uint8_t *iface_ptr = usb_dp_get_nested_descriptor(&dp_parser,
+            &dp_data, config_descr);
+        while (iface_ptr != NULL) {
+                usb_standard_interface_descriptor_t *iface
+                    = (usb_standard_interface_descriptor_t *) iface_ptr;
+                if (iface->descriptor_type == USB_DESCTYPE_INTERFACE) {
+                        if (iface->interface_number == interface_no) {
+                                alternate_count++;
+                        }
+                }
+                iface_ptr = usb_dp_get_sibling_descriptor(&dp_parser, &dp_data,
+                    config_descr, iface_ptr);
+        }
+
+        return alternate_count;
+}
+
+/** Initialize structures related to alternate interfaces.
+ *
+ * @param dev Device where alternate settings shall be initialized.
+ * @return Error code.
+ */
+static int initialize_alternate_interfaces(usb_device_t *dev)
+{
+        if (dev->interface_no < 0) {
+                dev->alternate_interfaces = NULL;
+                return EOK;
+        }
+
+        usb_alternate_interfaces_t *alternates
+            = malloc(sizeof(usb_alternate_interfaces_t));
+
+        if (alternates == NULL) {
+                return ENOMEM;
+        }
+
+        alternates->alternative_count
+            = count_alternate_interfaces(dev->descriptors.configuration,
+            dev->descriptors.configuration_size, dev->interface_no);
+
+        if (alternates->alternative_count == 0) {
+                free(alternates);
+                return ENOENT;
+        }
+
+        alternates->alternatives = malloc(alternates->alternative_count
+            * sizeof(usb_alternate_interface_descriptors_t));
+        if (alternates->alternatives == NULL) {
+                free(alternates);
+                return ENOMEM;
+        }
+
+        alternates->current = 0;
+
+        usb_dp_parser_t dp_parser = {
+                .nesting = usb_dp_standard_descriptor_nesting
+        };
+        usb_dp_parser_data_t dp_data = {
+                .data = dev->descriptors.configuration,
+                .size = dev->descriptors.configuration_size,
+                .arg = NULL
+        };
+
+        usb_alternate_interface_descriptors_t *cur_alt_iface
+            = &alternates->alternatives[0];
+
+        uint8_t *iface_ptr = usb_dp_get_nested_descriptor(&dp_parser,
+            &dp_data, dp_data.data);
+        while (iface_ptr != NULL) {
+                usb_standard_interface_descriptor_t *iface
+                    = (usb_standard_interface_descriptor_t *) iface_ptr;
+                if ((iface->descriptor_type != USB_DESCTYPE_INTERFACE)
+                    || (iface->interface_number != dev->interface_no)) {
+                        iface_ptr = usb_dp_get_sibling_descriptor(&dp_parser,
+                            &dp_data,
+                            dp_data.data, iface_ptr);
+                        continue;
+                }
+
+                cur_alt_iface->interface = iface;
+                cur_alt_iface->nested_descriptors = iface_ptr + sizeof(*iface);
+
+                /* Find next interface to count size of nested descriptors. */
+                iface_ptr = usb_dp_get_sibling_descriptor(&dp_parser, &dp_data,
+                    dp_data.data, iface_ptr);
+                if (iface_ptr == NULL) {
+                        uint8_t *next = dp_data.data + dp_data.size;
+                        cur_alt_iface->nested_descriptors_size
+                            = next - cur_alt_iface->nested_descriptors;
+                } else {
+                        cur_alt_iface->nested_descriptors_size
+                            = iface_ptr - cur_alt_iface->nested_descriptors;
+                }
+
+                cur_alt_iface++;
+        }
+
+        dev->alternate_interfaces = alternates;
+
+        return EOK;
 }
 
@@ -301 +436 @@
         dev->descriptors.configuration = NULL;
 
+        dev->pipes_count = 0;
+        dev->pipes = NULL;
+
         rc = initialize_pipes(dev);
         if (rc != EOK) {
@@ -307 +445 @@
         }
 
+        (void) initialize_alternate_interfaces(dev);
+
         return driver->ops->add_device(dev);
+}
+
+/** Destroy existing pipes of a USB device.
+ *
+ * @param dev Device where to destroy the pipes.
+ * @return Error code.
+ */
+static int destroy_current_pipes(usb_device_t *dev)
+{
+        size_t i;
+        int rc;
+
+        /* TODO: this shall be done under some device mutex. */
+
+        /* First check that no session is opened. */
+        for (i = 0; i < dev->pipes_count; i++) {
+                if (usb_pipe_is_session_started(dev->pipes[i].pipe)) {
+                        return EBUSY;
+                }
+        }
+
+        /* Prepare connection to HC. */
+        usb_hc_connection_t hc_conn;
+        rc = usb_hc_connection_initialize_from_device(&hc_conn, dev->ddf_dev);
+        if (rc != EOK) {
+                return rc;
+        }
+        rc = usb_hc_connection_open(&hc_conn);
+        if (rc != EOK) {
+                return rc;
+        }
+
+        /* Destroy the pipes. */
+        for (i = 0; i < dev->pipes_count; i++) {
+                usb_pipe_unregister(dev->pipes[i].pipe, &hc_conn);
+                free(dev->pipes[i].pipe);
+        }
+
+        usb_hc_connection_close(&hc_conn);
+
+        free(dev->pipes);
+        dev->pipes = NULL;
+        dev->pipes_count = 0;
+
+        return EOK;
+}
+
+/** Change interface setting of a device.
+ * This function selects new alternate setting of an interface by issuing
+ * proper USB command to the device and also creates new USB pipes
+ * under @c dev->pipes.
+ *
+ * @warning This function is intended for drivers working at interface level.
+ * For drivers controlling the whole device, you need to change interface
+ * manually using usb_request_set_interface() and creating new pipes
+ * with usb_pipe_initialize_from_configuration().
+ *
+ * @param dev USB device.
+ * @param alternate_setting Alternate setting to choose.
+ * @param endpoints New endpoint descriptions.
+ * @return Error code.
+ */
+int usb_device_select_interface(usb_device_t *dev, uint8_t alternate_setting,
+    usb_endpoint_description_t **endpoints)
+{
+        if (dev->interface_no < 0) {
+                return EINVAL;
+        }
+
+        int rc;
+
+        /* TODO: more transactional behavior. */
+
+        /* Destroy existing pipes. */
+        rc = destroy_current_pipes(dev);
+        if (rc != EOK) {
+                return rc;
+        }
+
+        /* Change the interface itself. */
+        rc = usb_request_set_interface(&dev->ctrl_pipe, dev->interface_no,
+            alternate_setting);
+        if (rc != EOK) {
+                return rc;
+        }
+
+        /* Create new pipes. */
+        rc = initialize_other_pipes(endpoints, dev);
+
+        return rc;
 }
 

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

@@ -54 +54 @@
     void *arg,
     ddf_fun_t *fun,
+                endpoint_t *ep,
     void *private_data
     )
@@ -77 +78 @@
         instance->next_step = NULL;
         instance->error = EOK;
-
+        instance->ep = ep;
 }
 /*----------------------------------------------------------------------------*/

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

@@ -54 +54 @@
         for (; i < USB_ADDRESS_COUNT; ++i) {
                 instance->devices[i].occupied = false;
-                instance->devices[i].control_used = false;
+                instance->devices[i].control_used = 0;
                 instance->devices[i].handle = 0;
-                instance->devices[i].toggle_status[0] = 0;
-                instance->devices[i].toggle_status[1] = 0;
-        }
+                list_initialize(&instance->devices[i].endpoints);
+        }
+}
+/*----------------------------------------------------------------------------*/
+void usb_device_keeper_add_ep(
+    usb_device_keeper_t *instance, usb_address_t address, endpoint_t *ep)
+{
+        assert(instance);
+        fibril_mutex_lock(&instance->guard);
+        assert(instance->devices[address].occupied);
+        list_append(&ep->same_device_eps, &instance->devices[address].endpoints);
+        fibril_mutex_unlock(&instance->guard);
 }
 /*----------------------------------------------------------------------------*/
@@ -66 +75 @@
  * @param[in] speed Speed of the device requesting default address.
  */
-void usb_device_keeper_reserve_default_address(usb_device_keeper_t *instance,
-    usb_speed_t speed)
+void usb_device_keeper_reserve_default_address(
+    usb_device_keeper_t *instance, usb_speed_t speed)
 {
         assert(instance);
@@ -101 +110 @@
  * Really ugly one.
  */
-void usb_device_keeper_reset_if_need(usb_device_keeper_t *instance,
-    usb_target_t target, const uint8_t *data)
+void usb_device_keeper_reset_if_need(
+    usb_device_keeper_t *instance, usb_target_t target, const uint8_t *data)
 {
         assert(instance);
@@ -119 +128 @@
                 /* recipient is endpoint, value is zero (ENDPOINT_STALL) */
                 if (((data[0] & 0xf) == 1) && ((data[2] | data[3]) == 0)) {
+                        link_t *current =
+                            instance->devices[target.address].endpoints.next;
+                        while (current !=
+                           &instance->devices[target.address].endpoints)
+                        {
                         /* endpoint number is < 16, thus first byte is enough */
-                        instance->devices[target.address].toggle_status[0] &=
-                            ~(1 << data[4]);
-                        instance->devices[target.address].toggle_status[1] &=
-                            ~(1 << data[4]);
+                                endpoint_toggle_reset_filtered(
+                                    current, data[4]);
+                                current = current->next;
+                        }
                 }
         break;
@@ -131 +145 @@
                 /* target must be device */
                 if ((data[0] & 0xf) == 0) {
-                        instance->devices[target.address].toggle_status[0] = 0;
-                        instance->devices[target.address].toggle_status[1] = 0;
+                        link_t *current =
+                            instance->devices[target.address].endpoints.next;
+                        while (current !=
+                           &instance->devices[target.address].endpoints)
+                        {
+                                endpoint_toggle_reset(current);
+                                current = current->next;
+                        }
                 }
         break;
         }
         fibril_mutex_unlock(&instance->guard);
-}
-/*----------------------------------------------------------------------------*/
-/** Get current value of endpoint toggle.
- *
- * @param[in] instance Device keeper structure to use.
- * @param[in] target Device and endpoint used.
- * @return Error code
- */
-int usb_device_keeper_get_toggle(usb_device_keeper_t *instance,
-    usb_target_t target, usb_direction_t direction)
-{
-        assert(instance);
-        /* only control pipes are bi-directional and those do not need toggle */
-        if (direction == USB_DIRECTION_BOTH)
-                return ENOENT;
-        int ret;
-        fibril_mutex_lock(&instance->guard);
-        if (target.endpoint > 15 || target.endpoint < 0
-            || target.address >= USB_ADDRESS_COUNT || target.address < 0
-            || !instance->devices[target.address].occupied) {
-                usb_log_error("Invalid data when asking for toggle value.\n");
-                ret = EINVAL;
-        } else {
-                ret = (instance->devices[target.address].toggle_status[direction]
-                        >> target.endpoint) & 1;
-        }
-        fibril_mutex_unlock(&instance->guard);
-        return ret;
-}
-/*----------------------------------------------------------------------------*/
-/** Set current value of endpoint toggle.
- *
- * @param[in] instance Device keeper structure to use.
- * @param[in] target Device and endpoint used.
- * @param[in] toggle Toggle value.
- * @return Error code.
- */
-int usb_device_keeper_set_toggle(usb_device_keeper_t *instance,
-    usb_target_t target, usb_direction_t direction, bool toggle)
-{
-        assert(instance);
-        /* only control pipes are bi-directional and those do not need toggle */
-        if (direction == USB_DIRECTION_BOTH)
-                return ENOENT;
-        int ret;
-        fibril_mutex_lock(&instance->guard);
-        if (target.endpoint > 15 || target.endpoint < 0
-            || target.address >= USB_ADDRESS_COUNT || target.address < 0
-            || !instance->devices[target.address].occupied) {
-                usb_log_error("Invalid data when setting toggle value.\n");
-                ret = EINVAL;
-        } else {
-                if (toggle) {
-                        instance->devices[target.address].toggle_status[direction]
-                            |= (1 << target.endpoint);
-                } else {
-                        instance->devices[target.address].toggle_status[direction]
-                            &= ~(1 << target.endpoint);
-                }
-                ret = EOK;
-        }
-        fibril_mutex_unlock(&instance->guard);
-        return ret;
 }
 /*----------------------------------------------------------------------------*/
@@ -208 +165 @@
  * @return Free address, or error code.
  */
-usb_address_t device_keeper_get_free_address(usb_device_keeper_t *instance,
-    usb_speed_t speed)
+usb_address_t device_keeper_get_free_address(
+    usb_device_keeper_t *instance, usb_speed_t speed)
 {
         assert(instance);
@@ -229 +186 @@
         instance->devices[new_address].occupied = true;
         instance->devices[new_address].speed = speed;
-        instance->devices[new_address].toggle_status[0] = 0;
-        instance->devices[new_address].toggle_status[1] = 0;
         instance->last_address = new_address;
         fibril_mutex_unlock(&instance->guard);
@@ -259 +214 @@
  * @param[in] address Device address
  */
-void usb_device_keeper_release(usb_device_keeper_t *instance,
-    usb_address_t address)
+void usb_device_keeper_release(
+    usb_device_keeper_t *instance, usb_address_t address)
 {
         assert(instance);
@@ -278 +233 @@
  * @return USB Address, or error code.
  */
-usb_address_t usb_device_keeper_find(usb_device_keeper_t *instance,
-    devman_handle_t handle)
+usb_address_t usb_device_keeper_find(
+    usb_device_keeper_t *instance, devman_handle_t handle)
 {
         assert(instance);
@@ -301 +256 @@
  * @return USB speed.
  */
-usb_speed_t usb_device_keeper_get_speed(usb_device_keeper_t *instance,
-    usb_address_t address)
+usb_speed_t usb_device_keeper_get_speed(
+    usb_device_keeper_t *instance, usb_address_t address)
 {
         assert(instance);
@@ -310 +265 @@
 }
 /*----------------------------------------------------------------------------*/
-void usb_device_keeper_use_control(usb_device_keeper_t *instance,
-    usb_address_t address)
-{
-        assert(instance);
-        fibril_mutex_lock(&instance->guard);
-        while (instance->devices[address].control_used) {
+void usb_device_keeper_use_control(
+    usb_device_keeper_t *instance, usb_target_t target)
+{
+        assert(instance);
+        const uint16_t ep = 1 << target.endpoint;
+        fibril_mutex_lock(&instance->guard);
+        while (instance->devices[target.address].control_used & ep) {
                 fibril_condvar_wait(&instance->change, &instance->guard);
         }
-        instance->devices[address].control_used = true;
-        fibril_mutex_unlock(&instance->guard);
-}
-/*----------------------------------------------------------------------------*/
-void usb_device_keeper_release_control(usb_device_keeper_t *instance,
-    usb_address_t address)
-{
-        assert(instance);
-        fibril_mutex_lock(&instance->guard);
-        instance->devices[address].control_used = false;
+        instance->devices[target.address].control_used |= ep;
+        fibril_mutex_unlock(&instance->guard);
+}
+/*----------------------------------------------------------------------------*/
+void usb_device_keeper_release_control(
+    usb_device_keeper_t *instance, usb_target_t target)
+{
+        assert(instance);
+        const uint16_t ep = 1 << target.endpoint;
+        fibril_mutex_lock(&instance->guard);
+        assert((instance->devices[target.address].control_used & ep) != 0);
+        instance->devices[target.address].control_used &= ~ep;
         fibril_mutex_unlock(&instance->guard);
         fibril_condvar_signal(&instance->change);

uspace/lib/usb/src/hub.c

@@ -142 +142 @@
             DEV_IFACE_ID(USBHC_DEV_IFACE),
             IPC_M_USBHC_RELEASE_ADDRESS, address);
+}
+
+static void unregister_control_endpoint_on_default_address(
+    usb_hc_connection_t *connection)
+{
+        usb_device_connection_t dev_conn;
+        int rc = usb_device_connection_initialize_on_default_address(&dev_conn,
+            connection);
+        if (rc != EOK) {
+                return;
+        }
+
+        usb_pipe_t ctrl_pipe;
+        rc = usb_pipe_initialize_default_control(&ctrl_pipe, &dev_conn);
+        if (rc != EOK) {
+                return;
+        }
+
+        usb_pipe_unregister(&ctrl_pipe, connection);
 }
 
@@ -235 +254 @@
                 goto leave_release_default_address;
         }
+
+        /* Before sending any traffic, we need to register this
+         * endpoint.
+         */
+        rc = usb_pipe_register(&ctrl_pipe, 0, connection);
+        if (rc != EOK) {
+                rc = EREFUSED;
+                goto leave_release_default_address;
+        }
         rc = usb_pipe_probe_default_control(&ctrl_pipe);
         if (rc != EOK) {
@@ -244 +272 @@
         if (rc != EOK) {
                 rc = ENOTCONN;
-                goto leave_release_default_address;
+                goto leave_unregister_endpoint;
         }
 
@@ -256 +284 @@
 
         /*
+         * Register the control endpoint for the new device.
+         */
+        rc = usb_pipe_register(&ctrl_pipe, 0, connection);
+        if (rc != EOK) {
+                rc = EREFUSED;
+                goto leave_unregister_endpoint;
+        }
+
+        /*
+         * Release the original endpoint.
+         */
+        unregister_control_endpoint_on_default_address(connection);
+
+        /*
          * Once the address is changed, we can return the default address.
          */
         usb_hc_release_default_address(connection);
+
 
         /*
@@ -273 +316 @@
         }
 
+
+
         /*
          * And now inform the host controller about the handle.
@@ -308 +353 @@
         usb_pipe_end_session(&ctrl_pipe);
 
+leave_unregister_endpoint:
+        usb_pipe_unregister(&ctrl_pipe, connection);
+
 leave_release_default_address:
         usb_hc_release_default_address(connection);

uspace/lib/usb/src/pipesinit.c

@@ -121 +121 @@
     usb_endpoint_mapping_t *mapping, size_t mapping_count,
     usb_endpoint_description_t *found_endpoint,
-    int interface_number)
+    int interface_number, int interface_setting)
 {
         while (mapping_count > 0) {
@@ -127 +127 @@
                     || (mapping->interface_no == interface_number);
 
+                bool interface_setting_fits = (mapping->interface_setting < 0)
+                    || (mapping->interface_setting == interface_setting);
+
                 bool endpoint_descriptions_fits = endpoint_fits_description(
                     mapping->description, found_endpoint);
 
-                if (interface_number_fits && endpoint_descriptions_fits) {
+                if (interface_number_fits
+                    && interface_setting_fits
+                    && endpoint_descriptions_fits) {
                         return mapping;
                 }
@@ -181 +186 @@
          */
         usb_endpoint_mapping_t *ep_mapping = find_endpoint_mapping(mapping,
-            mapping_count, &description, interface->interface_number);
+            mapping_count, &description,
+            interface->interface_number, interface->alternate_setting);
         if (ep_mapping == NULL) {
                 return ENOENT;

uspace/lib/usb/src/request.c

@@ -529 +529 @@
                 return rc;
         }
-
         if (bare_config.descriptor_type != USB_DESCTYPE_CONFIGURATION) {
                 return ENOENT;