Index: uspace/lib/block/libblock.c =================================================================== --- uspace/lib/block/libblock.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/block/libblock.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -2,4 +2,5 @@ * Copyright (c) 2008 Jakub Jermar * Copyright (c) 2008 Martin Decky + * Copyright (c) 2011 Martin Sucha * All rights reserved. * @@ -61,13 +62,13 @@ static LIST_INITIALIZE(dcl_head); -#define CACHE_BUCKETS_LOG2 10 -#define CACHE_BUCKETS (1 << CACHE_BUCKETS_LOG2) +#define CACHE_BUCKETS_LOG2 10 +#define CACHE_BUCKETS (1 << CACHE_BUCKETS_LOG2) typedef struct { fibril_mutex_t lock; - size_t lblock_size; /**< Logical block size. */ - unsigned blocks_cluster; /**< Physical blocks per block_t */ - unsigned block_count; /**< Total number of blocks. */ - unsigned blocks_cached; /**< Number of cached blocks. */ + size_t lblock_size; /**< Logical block size. */ + unsigned blocks_cluster; /**< Physical blocks per block_t */ + unsigned block_count; /**< Total number of blocks. */ + unsigned blocks_cached; /**< Number of cached blocks. */ hash_table_t block_hash; link_t free_head; @@ -78,5 +79,5 @@ link_t link; devmap_handle_t devmap_handle; - int dev_phone; + async_sess_t *sess; fibril_mutex_t comm_area_lock; void *comm_area; @@ -84,19 +85,20 @@ void *bb_buf; aoff64_t bb_addr; - size_t pblock_size; /**< Physical block size. */ + size_t pblock_size; /**< Physical block size. */ cache_t *cache; } devcon_t; -static int read_blocks(devcon_t *devcon, aoff64_t ba, size_t cnt); -static int write_blocks(devcon_t *devcon, aoff64_t ba, size_t cnt); -static int get_block_size(int dev_phone, size_t *bsize); -static int get_num_blocks(int dev_phone, aoff64_t *nblocks); -static aoff64_t ba_ltop(devcon_t *devcon, aoff64_t lba); +static int read_blocks(devcon_t *, aoff64_t, size_t); +static int write_blocks(devcon_t *, aoff64_t, size_t); +static int get_block_size(async_sess_t *, size_t *); +static int get_num_blocks(async_sess_t *, aoff64_t *); +static aoff64_t ba_ltop(devcon_t *, aoff64_t); static devcon_t *devcon_search(devmap_handle_t devmap_handle) { link_t *cur; - + fibril_mutex_lock(&dcl_lock); + for (cur = dcl_head.next; cur != &dcl_head; cur = cur->next) { devcon_t *devcon = list_get_instance(cur, devcon_t, link); @@ -106,17 +108,18 @@ } } + fibril_mutex_unlock(&dcl_lock); return NULL; } -static int devcon_add(devmap_handle_t devmap_handle, int dev_phone, size_t bsize, - void *comm_area, size_t comm_size) +static int devcon_add(devmap_handle_t devmap_handle, async_sess_t *sess, + size_t bsize, void *comm_area, size_t comm_size) { link_t *cur; devcon_t *devcon; - + if (comm_size < bsize) return EINVAL; - + devcon = malloc(sizeof(devcon_t)); if (!devcon) @@ -125,5 +128,5 @@ link_initialize(&devcon->link); devcon->devmap_handle = devmap_handle; - devcon->dev_phone = dev_phone; + devcon->sess = sess; fibril_mutex_initialize(&devcon->comm_area_lock); devcon->comm_area = comm_area; @@ -133,5 +136,5 @@ devcon->pblock_size = bsize; devcon->cache = NULL; - + fibril_mutex_lock(&dcl_lock); for (cur = dcl_head.next; cur != &dcl_head; cur = cur->next) { @@ -155,44 +158,46 @@ } -int block_init(devmap_handle_t devmap_handle, size_t comm_size) -{ - int rc; - int dev_phone; - void *comm_area; - size_t bsize; - - comm_area = mmap(NULL, comm_size, PROTO_READ | PROTO_WRITE, +int block_init(exch_mgmt_t mgmt, devmap_handle_t devmap_handle, + size_t comm_size) +{ + void *comm_area = mmap(NULL, comm_size, PROTO_READ | PROTO_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, 0, 0); - if (!comm_area) { + if (!comm_area) return ENOMEM; - } - - dev_phone = devmap_device_connect(devmap_handle, IPC_FLAG_BLOCKING); - if (dev_phone < 0) { + + async_sess_t *sess = devmap_device_connect(mgmt, devmap_handle, + IPC_FLAG_BLOCKING); + if (!sess) { munmap(comm_area, comm_size); - return dev_phone; - } - - rc = async_share_out_start(dev_phone, comm_area, + return ENOENT; + } + + async_exch_t *exch = async_exchange_begin(sess); + int rc = async_share_out_start(exch, comm_area, AS_AREA_READ | AS_AREA_WRITE); - if (rc != EOK) { - munmap(comm_area, comm_size); - async_hangup(dev_phone); - return rc; - } - - if (get_block_size(dev_phone, &bsize) != EOK) { - munmap(comm_area, comm_size); - async_hangup(dev_phone); - return rc; - } - - rc = devcon_add(devmap_handle, dev_phone, bsize, comm_area, comm_size); + async_exchange_end(exch); + if (rc != EOK) { munmap(comm_area, comm_size); - async_hangup(dev_phone); + async_hangup(sess); return rc; } - + + size_t bsize; + rc = get_block_size(sess, &bsize); + + if (rc != EOK) { + munmap(comm_area, comm_size); + async_hangup(sess); + return rc; + } + + rc = devcon_add(devmap_handle, sess, bsize, comm_area, comm_size); + if (rc != EOK) { + munmap(comm_area, comm_size); + async_hangup(sess); + return rc; + } + return EOK; } @@ -205,14 +210,14 @@ if (devcon->cache) (void) block_cache_fini(devmap_handle); - + devcon_remove(devcon); - + if (devcon->bb_buf) free(devcon->bb_buf); - + munmap(devcon->comm_area, devcon->comm_size); - async_hangup(devcon->dev_phone); - - free(devcon); + async_hangup(devcon->sess); + + free(devcon); } @@ -807,5 +812,5 @@ assert(devcon); - return get_block_size(devcon->dev_phone, bsize); + return get_block_size(devcon->sess, bsize); } @@ -819,10 +824,60 @@ int block_get_nblocks(devmap_handle_t devmap_handle, aoff64_t *nblocks) { - devcon_t *devcon; - - devcon = devcon_search(devmap_handle); - assert(devcon); - - return get_num_blocks(devcon->dev_phone, nblocks); + devcon_t *devcon = devcon_search(devmap_handle); + assert(devcon); + + return get_num_blocks(devcon->sess, nblocks); +} + +/** Read bytes directly from the device (bypass cache) + * + * @param devmap_handle Device handle of the block device. + * @param abs_offset Absolute offset in bytes where to start reading + * @param bytes Number of bytes to read + * @param data Buffer that receives the data + * + * @return EOK on success or negative error code on failure. + */ +int block_read_bytes_direct(devmap_handle_t devmap_handle, aoff64_t abs_offset, + size_t bytes, void *data) +{ + int rc; + size_t phys_block_size; + size_t buf_size; + void *buffer; + aoff64_t first_block; + aoff64_t last_block; + size_t blocks; + size_t offset; + + rc = block_get_bsize(devmap_handle, &phys_block_size); + if (rc != EOK) { + return rc; + } + + /* calculate data position and required space */ + first_block = abs_offset / phys_block_size; + offset = abs_offset % phys_block_size; + last_block = (abs_offset + bytes - 1) / phys_block_size; + blocks = last_block - first_block + 1; + buf_size = blocks * phys_block_size; + + /* read the data into memory */ + buffer = malloc(buf_size); + if (buffer == NULL) { + return ENOMEM; + } + + rc = block_read_direct(devmap_handle, first_block, blocks, buffer); + if (rc != EOK) { + free(buffer); + return rc; + } + + /* copy the data from the buffer */ + memcpy(data, buffer + offset, bytes); + free(buffer); + + return EOK; } @@ -838,9 +893,11 @@ static int read_blocks(devcon_t *devcon, aoff64_t ba, size_t cnt) { - int rc; - - assert(devcon); - rc = async_req_3_0(devcon->dev_phone, BD_READ_BLOCKS, LOWER32(ba), + assert(devcon); + + async_exch_t *exch = async_exchange_begin(devcon->sess); + int rc = async_req_3_0(exch, BD_READ_BLOCKS, LOWER32(ba), UPPER32(ba), cnt); + async_exchange_end(exch); + if (rc != EOK) { printf("Error %d reading %zu blocks starting at block %" PRIuOFF64 @@ -851,4 +908,5 @@ #endif } + return rc; } @@ -865,9 +923,11 @@ static int write_blocks(devcon_t *devcon, aoff64_t ba, size_t cnt) { - int rc; - - assert(devcon); - rc = async_req_3_0(devcon->dev_phone, BD_WRITE_BLOCKS, LOWER32(ba), + assert(devcon); + + async_exch_t *exch = async_exchange_begin(devcon->sess); + int rc = async_req_3_0(exch, BD_WRITE_BLOCKS, LOWER32(ba), UPPER32(ba), cnt); + async_exchange_end(exch); + if (rc != EOK) { printf("Error %d writing %zu blocks starting at block %" PRIuOFF64 @@ -877,31 +937,36 @@ #endif } + return rc; } /** Get block size used by the device. */ -static int get_block_size(int dev_phone, size_t *bsize) +static int get_block_size(async_sess_t *sess, size_t *bsize) { sysarg_t bs; - int rc; - - rc = async_req_0_1(dev_phone, BD_GET_BLOCK_SIZE, &bs); + + async_exch_t *exch = async_exchange_begin(sess); + int rc = async_req_0_1(exch, BD_GET_BLOCK_SIZE, &bs); + async_exchange_end(exch); + if (rc == EOK) *bsize = (size_t) bs; - + return rc; } /** Get total number of blocks on block device. */ -static int get_num_blocks(int dev_phone, aoff64_t *nblocks) -{ - sysarg_t nb_l, nb_h; - int rc; - - rc = async_req_0_2(dev_phone, BD_GET_NUM_BLOCKS, &nb_l, &nb_h); - if (rc == EOK) { +static int get_num_blocks(async_sess_t *sess, aoff64_t *nblocks) +{ + sysarg_t nb_l; + sysarg_t nb_h; + + async_exch_t *exch = async_exchange_begin(sess); + int rc = async_req_0_2(exch, BD_GET_NUM_BLOCKS, &nb_l, &nb_h); + async_exchange_end(exch); + + if (rc == EOK) *nblocks = (aoff64_t) MERGE_LOUP32(nb_l, nb_h); - } - + return rc; } Index: uspace/lib/block/libblock.h =================================================================== --- uspace/lib/block/libblock.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/block/libblock.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -2,4 +2,5 @@ * Copyright (c) 2008 Jakub Jermar * Copyright (c) 2008 Martin Decky + * Copyright (c) 2011 Martin Sucha * All rights reserved. * @@ -39,4 +40,5 @@ #include +#include #include "../../srv/vfs/vfs.h" #include @@ -95,5 +97,5 @@ }; -extern int block_init(devmap_handle_t, size_t); +extern int block_init(exch_mgmt_t, devmap_handle_t, size_t); extern void block_fini(devmap_handle_t); @@ -113,4 +115,5 @@ extern int block_get_nblocks(devmap_handle_t, aoff64_t *); extern int block_read_direct(devmap_handle_t, aoff64_t, size_t, void *); +extern int block_read_bytes_direct(devmap_handle_t, aoff64_t, size_t, void *); extern int block_write_direct(devmap_handle_t, aoff64_t, size_t, const void *); Index: uspace/lib/c/Makefile =================================================================== --- uspace/lib/c/Makefile (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/Makefile (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -68,5 +68,7 @@ generic/clipboard.c \ generic/devmap.c \ + generic/devmap_obsolete.c \ generic/devman.c \ + generic/devman_obsolete.c \ generic/device/hw_res.c \ generic/device/char_dev.c \ @@ -76,4 +78,5 @@ generic/str.c \ generic/str_error.c \ + generic/l18n/langs.c \ generic/fibril.c \ generic/fibril_synch.c \ @@ -95,10 +98,11 @@ generic/io/console.c \ generic/io/screenbuffer.c \ - generic/ipc/ns.c \ generic/malloc.c \ generic/sysinfo.c \ generic/ipc.c \ + generic/ns.c \ + generic/ns_obsolete.c \ generic/async.c \ - generic/async_sess.c \ + generic/async_obsolete.c \ generic/loader.c \ generic/getopt.c \ @@ -128,5 +132,5 @@ generic/assert.c -ifeq ($(CONFIG_RTLD), y) +ifeq ($(CONFIG_RTLD),y) GENERIC_SOURCES += \ generic/dlfcn.c \ Index: uspace/lib/c/arch/abs32le/include/ddi.h =================================================================== --- uspace/lib/c/arch/abs32le/include/ddi.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/arch/abs32le/include/ddi.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -33,4 +33,7 @@ #define LIBC_abs32le_DDI_H_ +#include +#include + static inline void pio_write_8(ioport8_t *port, uint8_t v) { Index: uspace/lib/c/arch/abs32le/include/types.h =================================================================== --- uspace/lib/c/arch/abs32le/include/types.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/arch/abs32le/include/types.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -51,4 +51,5 @@ typedef uint32_t size_t; +typedef int32_t intptr_t; typedef uint32_t uintptr_t; typedef uint32_t atomic_count_t; Index: uspace/lib/c/arch/amd64/include/types.h =================================================================== --- uspace/lib/c/arch/amd64/include/types.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/arch/amd64/include/types.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -51,4 +51,5 @@ typedef uint64_t size_t; +typedef int64_t intptr_t; typedef uint64_t uintptr_t; typedef uint64_t atomic_count_t; Index: uspace/lib/c/arch/arm32/include/types.h =================================================================== --- uspace/lib/c/arch/arm32/include/types.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/arch/arm32/include/types.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -52,4 +52,5 @@ typedef uint32_t size_t; +typedef int32_t intptr_t; typedef uint32_t uintptr_t; typedef uint32_t atomic_count_t; Index: uspace/lib/c/arch/ia32/include/types.h =================================================================== --- uspace/lib/c/arch/ia32/include/types.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/arch/ia32/include/types.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -51,4 +51,5 @@ typedef uint32_t size_t; +typedef int32_t intptr_t; typedef uint32_t uintptr_t; typedef uint32_t atomic_count_t; Index: uspace/lib/c/arch/ia64/include/types.h =================================================================== --- uspace/lib/c/arch/ia64/include/types.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/arch/ia64/include/types.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -61,4 +61,5 @@ typedef uint64_t size_t; +typedef int64_t intptr_t; typedef uint64_t uintptr_t; typedef uint64_t atomic_count_t; Index: uspace/lib/c/arch/mips32/include/types.h =================================================================== --- uspace/lib/c/arch/mips32/include/types.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/arch/mips32/include/types.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -52,4 +52,5 @@ typedef uint32_t size_t; +typedef int32_t intptr_t; typedef uint32_t uintptr_t; typedef uint32_t atomic_count_t; Index: uspace/lib/c/arch/ppc32/include/types.h =================================================================== --- uspace/lib/c/arch/ppc32/include/types.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/arch/ppc32/include/types.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -51,4 +51,5 @@ typedef uint32_t size_t; +typedef int32_t intptr_t; typedef uint32_t uintptr_t; typedef uint32_t atomic_count_t; Index: uspace/lib/c/arch/sparc64/include/types.h =================================================================== --- uspace/lib/c/arch/sparc64/include/types.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/arch/sparc64/include/types.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -51,4 +51,5 @@ typedef uint64_t size_t; +typedef int64_t intptr_t; typedef uint64_t uintptr_t; typedef uint64_t atomic_count_t; Index: uspace/lib/c/generic/adt/hash_table.c =================================================================== --- uspace/lib/c/generic/adt/hash_table.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/generic/adt/hash_table.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -54,5 +54,5 @@ * */ -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) { Index: uspace/lib/c/generic/adt/measured_strings.c =================================================================== --- uspace/lib/c/generic/adt/measured_strings.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/generic/adt/measured_strings.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -42,4 +42,5 @@ #include #include +#include /** Creates a new measured string bundled with a copy of the given string @@ -326,5 +327,5 @@ return ENOMEM; - rc = async_data_read_start(phone, lengths, + rc = async_obsolete_data_read_start(phone, lengths, sizeof(size_t) * (count + 1)); if (rc != EOK) { @@ -351,5 +352,5 @@ (*strings)[index].length = lengths[index]; if (lengths[index] > 0) { - rc = async_data_read_start(phone, next, lengths[index]); + rc = async_obsolete_data_read_start(phone, next, lengths[index]); if (rc != EOK) { free(lengths); @@ -399,5 +400,5 @@ return ENOMEM; - rc = async_data_write_start(phone, lengths, + rc = async_obsolete_data_write_start(phone, lengths, sizeof(size_t) * (count + 1)); if (rc != EOK) { @@ -410,5 +411,5 @@ for (index = 0; index < count; index++) { if (strings[index].length > 0) { - rc = async_data_write_start(phone, strings[index].value, + rc = async_obsolete_data_write_start(phone, strings[index].value, strings[index].length); if (rc != EOK) Index: uspace/lib/c/generic/as.c =================================================================== --- uspace/lib/c/generic/as.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/generic/as.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -35,4 +35,5 @@ #include #include +#include #include #include @@ -114,4 +115,30 @@ } +/** Find mapping to physical address. + * + * @param address Virtual address in question (virtual). + * @param[out] frame Frame address (physical). + * @return Error code. + * @retval EOK No error, @p frame holds the translation. + * @retval ENOENT Mapping not found. + */ +int as_get_physical_mapping(void *address, uintptr_t *frame) +{ + uintptr_t tmp_frame; + uintptr_t virt = (uintptr_t) address; + + int rc = (int) __SYSCALL2(SYS_PAGE_FIND_MAPPING, + (sysarg_t) virt, (sysarg_t) &tmp_frame); + if (rc != EOK) { + return rc; + } + + if (frame != NULL) { + *frame = tmp_frame; + } + + return EOK; +} + /** @} */ Index: uspace/lib/c/generic/async.c =================================================================== --- uspace/lib/c/generic/async.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/generic/async.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -40,6 +40,7 @@ * programming. * - * You should be able to write very simple multithreaded programs, the async - * framework will automatically take care of most synchronization problems. + * You should be able to write very simple multithreaded programs. The async + * framework will automatically take care of most of the synchronization + * problems. * * Example of use (pseudo C): @@ -53,7 +54,14 @@ * int fibril1(void *arg) * { - * conn = async_connect_me_to(); - * c1 = async_send(conn); - * c2 = async_send(conn); + * conn = async_connect_me_to(...); + * + * exch = async_exchange_begin(conn); + * c1 = async_send(exch); + * async_exchange_end(exch); + * + * exch = async_exchange_begin(conn); + * c2 = async_send(exch); + * async_exchange_end(exch); + * * async_wait_for(c1); * async_wait_for(c2); @@ -94,5 +102,4 @@ #include #include -#include #include #include @@ -102,8 +109,13 @@ #include #include +#include +#include #include -#include #include "private/async.h" +#define CLIENT_HASH_TABLE_BUCKETS 32 +#define CONN_HASH_TABLE_BUCKETS 32 + +/** Async framework global futex */ atomic_t async_futex = FUTEX_INITIALIZER; @@ -111,33 +123,25 @@ atomic_t threads_in_ipc_wait = { 0 }; -typedef struct { - awaiter_t wdata; - - /** If reply was received. */ - bool done; - - /** Pointer to where the answer data is stored. */ - ipc_call_t *dataptr; - - sysarg_t retval; -} amsg_t; - -/** - * Structures of this type are used to group information about - * a call and about a message queue link. - */ +/** Naming service session */ +async_sess_t *session_ns; + +/** Call data */ typedef struct { link_t link; + ipc_callid_t callid; ipc_call_t call; } msg_t; +/* Client connection data */ typedef struct { + link_t link; + sysarg_t in_task_hash; - link_t link; - int refcnt; + atomic_t refcnt; void *data; } client_t; +/* Server connection data */ typedef struct { awaiter_t wdata; @@ -148,4 +152,5 @@ /** Incoming client task hash. */ sysarg_t in_task_hash; + /** Incoming phone hash. */ sysarg_t in_phone_hash; @@ -170,5 +175,5 @@ /** Identifier of the incoming connection handled by the current fibril. */ -static fibril_local connection_t *FIBRIL_connection; +static fibril_local connection_t *fibril_connection; static void *default_client_data_constructor(void) @@ -196,8 +201,8 @@ } -void *async_client_data_get(void) -{ - assert(FIBRIL_connection); - return FIBRIL_connection->client->data; +void *async_get_client_data(void) +{ + assert(fibril_connection); + return fibril_connection->client->data; } @@ -215,9 +220,4 @@ } -/** - * Pointer to a fibril function that will be used to handle connections. - */ -static async_client_conn_t client_connection = default_client_connection; - /** Default fibril function that gets called to handle interrupt notifications. * @@ -232,9 +232,41 @@ } -/** - * Pointer to a fibril function that will be used to handle interrupt - * notifications. - */ +static async_client_conn_t client_connection = default_client_connection; static async_client_conn_t interrupt_received = default_interrupt_received; + +/** Setter for client_connection function pointer. + * + * @param conn Function that will implement a new connection fibril. + * + */ +void async_set_client_connection(async_client_conn_t conn) +{ + client_connection = conn; +} + +/** Setter for interrupt_received function pointer. + * + * @param intr Function that will implement a new interrupt + * notification fibril. + */ +void async_set_interrupt_received(async_client_conn_t intr) +{ + interrupt_received = intr; +} + +/** Mutex protecting inactive_exch_list and avail_phone_cv. + * + */ +static FIBRIL_MUTEX_INITIALIZE(async_sess_mutex); + +/** List of all currently inactive exchanges. + * + */ +static LIST_INITIALIZE(inactive_exch_list); + +/** Condition variable to wait for a phone to become available. + * + */ +static FIBRIL_CONDVAR_INITIALIZE(avail_phone_cv); static hash_table_t client_hash_table; @@ -242,10 +274,8 @@ static LIST_INITIALIZE(timeout_list); -#define CLIENT_HASH_TABLE_BUCKETS 32 -#define CONN_HASH_TABLE_BUCKETS 32 - static hash_index_t client_hash(unsigned long key[]) { assert(key); + return (((key[0]) >> 4) % CLIENT_HASH_TABLE_BUCKETS); } @@ -253,4 +283,7 @@ static int client_compare(unsigned long key[], hash_count_t keys, link_t *item) { + assert(key); + assert(item); + client_t *client = hash_table_get_instance(item, client_t, link); return (key[0] == client->in_task_hash); @@ -278,4 +311,5 @@ { assert(key); + return (((key[0]) >> 4) % CONN_HASH_TABLE_BUCKETS); } @@ -292,4 +326,7 @@ static int conn_compare(unsigned long key[], hash_count_t keys, link_t *item) { + assert(key); + assert(item); + connection_t *conn = hash_table_get_instance(item, connection_t, link); return (key[0] == conn->in_phone_hash); @@ -314,4 +351,6 @@ void async_insert_timeout(awaiter_t *wd) { + assert(wd); + wd->to_event.occurred = false; wd->to_event.inlist = true; @@ -346,4 +385,6 @@ static bool route_call(ipc_callid_t callid, ipc_call_t *call) { + assert(call); + futex_down(&async_futex); @@ -400,4 +441,6 @@ static int notification_fibril(void *arg) { + assert(arg); + msg_t *msg = (msg_t *) arg; interrupt_received(msg->callid, &msg->call); @@ -420,4 +463,6 @@ static bool process_notification(ipc_callid_t callid, ipc_call_t *call) { + assert(call); + futex_down(&async_futex); @@ -458,13 +503,14 @@ ipc_callid_t async_get_call_timeout(ipc_call_t *call, suseconds_t usecs) { - assert(FIBRIL_connection); + assert(call); + assert(fibril_connection); /* Why doing this? - * GCC 4.1.0 coughs on FIBRIL_connection-> dereference. + * GCC 4.1.0 coughs on fibril_connection-> dereference. * GCC 4.1.1 happilly puts the rdhwr instruction in delay slot. * I would never expect to find so many errors in * a compiler. */ - connection_t *conn = FIBRIL_connection; + connection_t *conn = fibril_connection; futex_down(&async_futex); @@ -541,8 +587,10 @@ static int connection_fibril(void *arg) { + assert(arg); + /* * Setup fibril-local connection pointer. */ - FIBRIL_connection = (connection_t *) arg; + fibril_connection = (connection_t *) arg; futex_down(&async_futex); @@ -554,5 +602,5 @@ */ - unsigned long key = FIBRIL_connection->in_task_hash; + unsigned long key = fibril_connection->in_task_hash; link_t *lnk = hash_table_find(&client_hash_table, &key); @@ -561,20 +609,17 @@ if (lnk) { client = hash_table_get_instance(lnk, client_t, link); - client->refcnt++; + atomic_inc(&client->refcnt); } else { client = malloc(sizeof(client_t)); if (!client) { - ipc_answer_0(FIBRIL_connection->callid, ENOMEM); + ipc_answer_0(fibril_connection->callid, ENOMEM); futex_up(&async_futex); return 0; } - client->in_task_hash = FIBRIL_connection->in_task_hash; - - async_serialize_start(); + client->in_task_hash = fibril_connection->in_task_hash; client->data = async_client_data_create(); - async_serialize_end(); - - client->refcnt = 1; + + atomic_set(&client->refcnt, 1); hash_table_insert(&client_hash_table, &key, &client->link); } @@ -582,11 +627,11 @@ futex_up(&async_futex); - FIBRIL_connection->client = client; + fibril_connection->client = client; /* * Call the connection handler function. */ - FIBRIL_connection->cfibril(FIBRIL_connection->callid, - &FIBRIL_connection->call); + fibril_connection->cfibril(fibril_connection->callid, + &fibril_connection->call); /* @@ -597,5 +642,5 @@ futex_down(&async_futex); - if (--client->refcnt == 0) { + if (atomic_predec(&client->refcnt) == 0) { hash_table_remove(&client_hash_table, &key, 1); destroy = true; @@ -616,5 +661,5 @@ */ futex_down(&async_futex); - key = FIBRIL_connection->in_phone_hash; + key = fibril_connection->in_phone_hash; hash_table_remove(&conn_hash_table, &key, 1); futex_up(&async_futex); @@ -623,7 +668,7 @@ * Answer all remaining messages with EHANGUP. */ - while (!list_empty(&FIBRIL_connection->msg_queue)) { + while (!list_empty(&fibril_connection->msg_queue)) { msg_t *msg = - list_get_instance(FIBRIL_connection->msg_queue.next, msg_t, + list_get_instance(fibril_connection->msg_queue.next, msg_t, link); @@ -637,8 +682,8 @@ * i.e. IPC_M_PHONE_HUNGUP. */ - if (FIBRIL_connection->close_callid) - ipc_answer_0(FIBRIL_connection->close_callid, EOK); - - free(FIBRIL_connection); + if (fibril_connection->close_callid) + ipc_answer_0(fibril_connection->close_callid, EOK); + + free(fibril_connection); return 0; } @@ -646,5 +691,5 @@ /** Create a new fibril for a new connection. * - * Create new fibril for connection, fill in connection structures and inserts + * Create new fibril for connection, fill in connection structures and insert * it into the hash table, so that later we can easily do routing of messages to * particular fibrils. @@ -665,5 +710,5 @@ fid_t async_new_connection(sysarg_t in_task_hash, sysarg_t in_phone_hash, ipc_callid_t callid, ipc_call_t *call, - void (*cfibril)(ipc_callid_t, ipc_call_t *)) + async_client_conn_t cfibril) { connection_t *conn = malloc(sizeof(*conn)); @@ -721,4 +766,6 @@ static void handle_call(ipc_callid_t callid, ipc_call_t *call) { + assert(call); + /* Unrouted call - take some default action */ if ((callid & IPC_CALLID_NOTIFICATION)) { @@ -878,11 +925,25 @@ void __async_init(void) { - if (!hash_table_create(&client_hash_table, CLIENT_HASH_TABLE_BUCKETS, 1, - &client_hash_table_ops)) + if (!hash_table_create(&client_hash_table, CLIENT_HASH_TABLE_BUCKETS, + 1, &client_hash_table_ops)) abort(); - if (!hash_table_create(&conn_hash_table, CONN_HASH_TABLE_BUCKETS, 1, - &conn_hash_table_ops)) + if (!hash_table_create(&conn_hash_table, CONN_HASH_TABLE_BUCKETS, + 1, &conn_hash_table_ops)) abort(); + + session_ns = (async_sess_t *) malloc(sizeof(async_sess_t)); + if (session_ns == NULL) + abort(); + + session_ns->mgmt = EXCHANGE_ATOMIC; + session_ns->phone = PHONE_NS; + session_ns->arg1 = 0; + session_ns->arg2 = 0; + session_ns->arg3 = 0; + + list_initialize(&session_ns->exch_list); + fibril_mutex_initialize(&session_ns->mutex); + atomic_set(&session_ns->refcnt, 0); } @@ -899,6 +960,8 @@ * */ -static void reply_received(void *arg, int retval, ipc_call_t *data) -{ +void reply_received(void *arg, int retval, ipc_call_t *data) +{ + assert(arg); + futex_down(&async_futex); @@ -930,6 +993,6 @@ * completion. * - * @param phoneid Handle of the phone that will be used for the send. - * @param method Service-defined method. + * @param exch Exchange for sending the message. + * @param imethod Service-defined interface and method. * @param arg1 Service-defined payload argument. * @param arg2 Service-defined payload argument. @@ -942,10 +1005,12 @@ * */ -aid_t async_send_fast(int phoneid, sysarg_t method, sysarg_t arg1, +aid_t async_send_fast(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, ipc_call_t *dataptr) { + if (exch == NULL) + return 0; + amsg_t *msg = malloc(sizeof(amsg_t)); - - if (!msg) + if (msg == NULL) return 0; @@ -961,5 +1026,5 @@ msg->wdata.active = true; - ipc_call_async_4(phoneid, method, arg1, arg2, arg3, arg4, msg, + ipc_call_async_4(exch->phone, imethod, arg1, arg2, arg3, arg4, msg, reply_received, true); @@ -972,6 +1037,6 @@ * completion. * - * @param phoneid Handle of the phone that will be used for the send. - * @param method Service-defined method. + * @param exch Exchange for sending the message. + * @param imethod Service-defined interface and method. * @param arg1 Service-defined payload argument. * @param arg2 Service-defined payload argument. @@ -985,11 +1050,14 @@ * */ -aid_t async_send_slow(int phoneid, sysarg_t method, sysarg_t arg1, +aid_t async_send_slow(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, ipc_call_t *dataptr) { + if (exch == NULL) + return 0; + amsg_t *msg = malloc(sizeof(amsg_t)); - if (!msg) + if (msg == NULL) return 0; @@ -1005,6 +1073,6 @@ msg->wdata.active = true; - ipc_call_async_5(phoneid, method, arg1, arg2, arg3, arg4, arg5, msg, - reply_received, true); + ipc_call_async_5(exch->phone, imethod, arg1, arg2, arg3, arg4, arg5, + msg, reply_received, true); return (aid_t) msg; @@ -1020,4 +1088,6 @@ void async_wait_for(aid_t amsgid, sysarg_t *retval) { + assert(amsgid); + amsg_t *msg = (amsg_t *) amsgid; @@ -1056,4 +1126,6 @@ int async_wait_timeout(aid_t amsgid, sysarg_t *retval, suseconds_t timeout) { + assert(amsgid); + amsg_t *msg = (amsg_t *) amsgid; @@ -1124,24 +1196,4 @@ } -/** Setter for client_connection function pointer. - * - * @param conn Function that will implement a new connection fibril. - * - */ -void async_set_client_connection(async_client_conn_t conn) -{ - client_connection = conn; -} - -/** Setter for interrupt_received function pointer. - * - * @param intr Function that will implement a new interrupt - * notification fibril. - */ -void async_set_interrupt_received(async_client_conn_t intr) -{ - interrupt_received = intr; -} - /** Pseudo-synchronous message sending - fast version. * @@ -1151,6 +1203,6 @@ * transferring more arguments, see the slower async_req_slow(). * - * @param phoneid Hash of the phone through which to make the call. - * @param method Method of the call. + * @param exch Exchange for sending the message. + * @param imethod Interface and method of the call. * @param arg1 Service-defined payload argument. * @param arg2 Service-defined payload argument. @@ -1166,14 +1218,17 @@ * */ -sysarg_t async_req_fast(int phoneid, sysarg_t method, sysarg_t arg1, +sysarg_t async_req_fast(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3, sysarg_t *r4, sysarg_t *r5) { + if (exch == NULL) + return ENOENT; + ipc_call_t result; - aid_t eid = async_send_4(phoneid, method, arg1, arg2, arg3, arg4, + aid_t aid = async_send_4(exch, imethod, arg1, arg2, arg3, arg4, &result); sysarg_t rc; - async_wait_for(eid, &rc); + async_wait_for(aid, &rc); if (r1) @@ -1199,6 +1254,6 @@ * Send message asynchronously and return only after the reply arrives. * - * @param phoneid Hash of the phone through which to make the call. - * @param method Method of the call. + * @param exch Exchange for sending the message. + * @param imethod Interface and method of the call. * @param arg1 Service-defined payload argument. * @param arg2 Service-defined payload argument. @@ -1215,14 +1270,17 @@ * */ -sysarg_t async_req_slow(int phoneid, sysarg_t method, sysarg_t arg1, +sysarg_t async_req_slow(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3, sysarg_t *r4, sysarg_t *r5) { + if (exch == NULL) + return ENOENT; + ipc_call_t result; - aid_t eid = async_send_5(phoneid, method, arg1, arg2, arg3, arg4, arg5, + aid_t aid = async_send_5(exch, imethod, arg1, arg2, arg3, arg4, arg5, &result); sysarg_t rc; - async_wait_for(eid, &rc); + async_wait_for(aid, &rc); if (r1) @@ -1244,37 +1302,46 @@ } -void async_msg_0(int phone, sysarg_t imethod) -{ - ipc_call_async_0(phone, imethod, NULL, NULL, true); -} - -void async_msg_1(int phone, sysarg_t imethod, sysarg_t arg1) -{ - ipc_call_async_1(phone, imethod, arg1, NULL, NULL, true); -} - -void async_msg_2(int phone, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2) -{ - ipc_call_async_2(phone, imethod, arg1, arg2, NULL, NULL, true); -} - -void async_msg_3(int phone, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, - sysarg_t arg3) -{ - ipc_call_async_3(phone, imethod, arg1, arg2, arg3, NULL, NULL, true); -} - -void async_msg_4(int phone, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, - sysarg_t arg3, sysarg_t arg4) -{ - ipc_call_async_4(phone, imethod, arg1, arg2, arg3, arg4, NULL, NULL, - true); -} - -void async_msg_5(int phone, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, - sysarg_t arg3, sysarg_t arg4, sysarg_t arg5) -{ - ipc_call_async_5(phone, imethod, arg1, arg2, arg3, arg4, arg5, NULL, - NULL, true); +void async_msg_0(async_exch_t *exch, sysarg_t imethod) +{ + if (exch != NULL) + ipc_call_async_0(exch->phone, imethod, NULL, NULL, true); +} + +void async_msg_1(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1) +{ + if (exch != NULL) + ipc_call_async_1(exch->phone, imethod, arg1, NULL, NULL, true); +} + +void async_msg_2(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, + sysarg_t arg2) +{ + if (exch != NULL) + ipc_call_async_2(exch->phone, imethod, arg1, arg2, NULL, NULL, + true); +} + +void async_msg_3(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, + sysarg_t arg2, sysarg_t arg3) +{ + if (exch != NULL) + ipc_call_async_3(exch->phone, imethod, arg1, arg2, arg3, NULL, + NULL, true); +} + +void async_msg_4(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, + sysarg_t arg2, sysarg_t arg3, sysarg_t arg4) +{ + if (exch != NULL) + ipc_call_async_4(exch->phone, imethod, arg1, arg2, arg3, arg4, + NULL, NULL, true); +} + +void async_msg_5(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, + sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5) +{ + if (exch != NULL) + ipc_call_async_5(exch->phone, imethod, arg1, arg2, arg3, arg4, + arg5, NULL, NULL, true); } @@ -1313,16 +1380,22 @@ } -int async_forward_fast(ipc_callid_t callid, int phoneid, sysarg_t imethod, - sysarg_t arg1, sysarg_t arg2, unsigned int mode) -{ - return ipc_forward_fast(callid, phoneid, imethod, arg1, arg2, mode); -} - -int async_forward_slow(ipc_callid_t callid, int phoneid, sysarg_t imethod, - sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, - unsigned int mode) -{ - return ipc_forward_slow(callid, phoneid, imethod, arg1, arg2, arg3, arg4, - arg5, mode); +int async_forward_fast(ipc_callid_t callid, async_exch_t *exch, + sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, unsigned int mode) +{ + if (exch == NULL) + return ENOENT; + + return ipc_forward_fast(callid, exch->phone, imethod, arg1, arg2, mode); +} + +int async_forward_slow(ipc_callid_t callid, async_exch_t *exch, + sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, + sysarg_t arg4, sysarg_t arg5, unsigned int mode) +{ + if (exch == NULL) + return ENOENT; + + return ipc_forward_slow(callid, exch->phone, imethod, arg1, arg2, arg3, + arg4, arg5, mode); } @@ -1331,5 +1404,5 @@ * Ask through phone for a new connection to some service. * - * @param phone Phone handle used for contacting the other side. + * @param exch Exchange for sending the message. * @param arg1 User defined argument. * @param arg2 User defined argument. @@ -1337,13 +1410,16 @@ * @param client_receiver Connection handing routine. * - * @return New phone handle on success or a negative error code. - * - */ -int async_connect_to_me(int phone, sysarg_t arg1, sysarg_t arg2, + * @return Zero on success or a negative error code. + * + */ +int async_connect_to_me(async_exch_t *exch, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, async_client_conn_t client_receiver) { + if (exch == NULL) + return ENOENT; + sysarg_t task_hash; sysarg_t phone_hash; - int rc = async_req_3_5(phone, IPC_M_CONNECT_TO_ME, arg1, arg2, arg3, + int rc = async_req_3_5(exch, IPC_M_CONNECT_TO_ME, arg1, arg2, arg3, NULL, NULL, NULL, &task_hash, &phone_hash); if (rc != EOK) @@ -1357,27 +1433,159 @@ } -/** Wrapper for making IPC_M_CONNECT_ME_TO calls using the async framework. - * - * Ask through phone for a new connection to some service. - * - * @param phone Phone handle used for contacting the other side. - * @param arg1 User defined argument. - * @param arg2 User defined argument. - * @param arg3 User defined argument. - * - * @return New phone handle on success or a negative error code. - * - */ -int async_connect_me_to(int phone, sysarg_t arg1, sysarg_t arg2, - sysarg_t arg3) -{ - sysarg_t newphid; - int rc = async_req_3_5(phone, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3, - NULL, NULL, NULL, NULL, &newphid); +/** Wrapper for making IPC_M_CONNECT_ME calls using the async framework. + * + * Ask through for a cloned connection to some service. + * + * @param mgmt Exchange management style. + * @param exch Exchange for sending the message. + * + * @return New session on success or NULL on error. + * + */ +async_sess_t *async_connect_me(exch_mgmt_t mgmt, async_exch_t *exch) +{ + if (exch == NULL) { + errno = ENOENT; + return NULL; + } + + async_sess_t *sess = (async_sess_t *) malloc(sizeof(async_sess_t)); + if (sess == NULL) { + errno = ENOMEM; + return NULL; + } + + ipc_call_t result; + + amsg_t *msg = malloc(sizeof(amsg_t)); + if (msg == NULL) { + free(sess); + errno = ENOMEM; + return NULL; + } + + msg->done = false; + msg->dataptr = &result; + + msg->wdata.to_event.inlist = false; + + /* + * We may sleep in the next method, + * but it will use its own means + */ + msg->wdata.active = true; + + ipc_call_async_0(exch->phone, IPC_M_CONNECT_ME, msg, + reply_received, true); + + sysarg_t rc; + async_wait_for((aid_t) msg, &rc); + + if (rc != EOK) { + errno = rc; + free(sess); + return NULL; + } + + int phone = (int) IPC_GET_ARG5(result); + + if (phone < 0) { + errno = phone; + free(sess); + return NULL; + } + + sess->mgmt = mgmt; + sess->phone = phone; + sess->arg1 = 0; + sess->arg2 = 0; + sess->arg3 = 0; + + list_initialize(&sess->exch_list); + fibril_mutex_initialize(&sess->mutex); + atomic_set(&sess->refcnt, 0); + + return sess; +} + +static int async_connect_me_to_internal(int phone, sysarg_t arg1, sysarg_t arg2, + sysarg_t arg3, sysarg_t arg4) +{ + ipc_call_t result; + + amsg_t *msg = malloc(sizeof(amsg_t)); + if (msg == NULL) + return ENOENT; + + msg->done = false; + msg->dataptr = &result; + + msg->wdata.to_event.inlist = false; + + /* + * We may sleep in the next method, + * but it will use its own means + */ + msg->wdata.active = true; + + ipc_call_async_4(phone, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3, arg4, + msg, reply_received, true); + + sysarg_t rc; + async_wait_for((aid_t) msg, &rc); if (rc != EOK) return rc; - return newphid; + return (int) IPC_GET_ARG5(result); +} + +/** Wrapper for making IPC_M_CONNECT_ME_TO calls using the async framework. + * + * Ask through for a new connection to some service. + * + * @param mgmt Exchange management style. + * @param exch Exchange for sending the message. + * @param arg1 User defined argument. + * @param arg2 User defined argument. + * @param arg3 User defined argument. + * + * @return New session on success or NULL on error. + * + */ +async_sess_t *async_connect_me_to(exch_mgmt_t mgmt, async_exch_t *exch, + sysarg_t arg1, sysarg_t arg2, sysarg_t arg3) +{ + if (exch == NULL) { + errno = ENOENT; + return NULL; + } + + async_sess_t *sess = (async_sess_t *) malloc(sizeof(async_sess_t)); + if (sess == NULL) { + errno = ENOMEM; + return NULL; + } + + int phone = async_connect_me_to_internal(exch->phone, arg1, arg2, arg3, + 0); + + if (phone < 0) { + errno = phone; + free(sess); + return NULL; + } + + sess->mgmt = mgmt; + sess->phone = phone; + sess->arg1 = arg1; + sess->arg2 = arg2; + sess->arg3 = arg3; + + list_initialize(&sess->exch_list); + fibril_mutex_initialize(&sess->mutex); + atomic_set(&sess->refcnt, 0); + + return sess; } @@ -1387,23 +1595,47 @@ * success. * - * @param phoneid Phone handle used for contacting the other side. - * @param arg1 User defined argument. - * @param arg2 User defined argument. - * @param arg3 User defined argument. - * - * @return New phone handle on success or a negative error code. - * - */ -int async_connect_me_to_blocking(int phoneid, sysarg_t arg1, sysarg_t arg2, - sysarg_t arg3) -{ - sysarg_t newphid; - int rc = async_req_4_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3, - IPC_FLAG_BLOCKING, NULL, NULL, NULL, NULL, &newphid); - - if (rc != EOK) - return rc; - - return newphid; + * @param mgmt Exchange management style. + * @param exch Exchange for sending the message. + * @param arg1 User defined argument. + * @param arg2 User defined argument. + * @param arg3 User defined argument. + * + * @return New session on success or NULL on error. + * + */ +async_sess_t *async_connect_me_to_blocking(exch_mgmt_t mgmt, async_exch_t *exch, + sysarg_t arg1, sysarg_t arg2, sysarg_t arg3) +{ + if (exch == NULL) { + errno = ENOENT; + return NULL; + } + + async_sess_t *sess = (async_sess_t *) malloc(sizeof(async_sess_t)); + if (sess == NULL) { + errno = ENOMEM; + return NULL; + } + + int phone = async_connect_me_to_internal(exch->phone, arg1, arg2, arg3, + IPC_FLAG_BLOCKING); + + if (phone < 0) { + errno = phone; + free(sess); + return NULL; + } + + sess->mgmt = mgmt; + sess->phone = phone; + sess->arg1 = arg1; + sess->arg2 = arg2; + sess->arg3 = arg3; + + list_initialize(&sess->exch_list); + fibril_mutex_initialize(&sess->mutex); + atomic_set(&sess->refcnt, 0); + + return sess; } @@ -1411,19 +1643,56 @@ * */ -int async_connect_kbox(task_id_t id) -{ - return ipc_connect_kbox(id); +async_sess_t *async_connect_kbox(task_id_t id) +{ + async_sess_t *sess = (async_sess_t *) malloc(sizeof(async_sess_t)); + if (sess == NULL) { + errno = ENOMEM; + return NULL; + } + + int phone = ipc_connect_kbox(id); + if (phone < 0) { + errno = phone; + free(sess); + return NULL; + } + + sess->mgmt = EXCHANGE_ATOMIC; + sess->phone = phone; + sess->arg1 = 0; + sess->arg2 = 0; + sess->arg3 = 0; + + list_initialize(&sess->exch_list); + fibril_mutex_initialize(&sess->mutex); + atomic_set(&sess->refcnt, 0); + + return sess; +} + +static int async_hangup_internal(int phone) +{ + return ipc_hangup(phone); } /** Wrapper for ipc_hangup. * - * @param phone Phone handle to hung up. + * @param sess Session to hung up. * * @return Zero on success or a negative error code. * */ -int async_hangup(int phone) -{ - return ipc_hangup(phone); +int async_hangup(async_sess_t *sess) +{ + assert(sess); + + if (atomic_get(&sess->refcnt) > 0) + return EBUSY; + + int rc = async_hangup_internal(sess->phone); + if (rc == EOK) + free(sess); + + return rc; } @@ -1434,20 +1703,140 @@ } +/** Start new exchange in a session. + * + * @param session Session. + * + * @return New exchange or NULL on error. + * + */ +async_exch_t *async_exchange_begin(async_sess_t *sess) +{ + if (sess == NULL) + return NULL; + + async_exch_t *exch; + + fibril_mutex_lock(&async_sess_mutex); + + if (!list_empty(&sess->exch_list)) { + /* + * There are inactive exchanges in the session. + */ + exch = (async_exch_t *) + list_get_instance(sess->exch_list.next, async_exch_t, sess_link); + list_remove(&exch->sess_link); + list_remove(&exch->global_link); + } else { + /* + * There are no available exchanges in the session. + */ + + if ((sess->mgmt == EXCHANGE_ATOMIC) || + (sess->mgmt == EXCHANGE_SERIALIZE)) { + exch = (async_exch_t *) malloc(sizeof(async_exch_t)); + if (exch != NULL) { + list_initialize(&exch->sess_link); + list_initialize(&exch->global_link); + exch->sess = sess; + exch->phone = sess->phone; + } + } else { /* EXCHANGE_PARALLEL */ + /* + * Make a one-time attempt to connect a new data phone. + */ + + int phone; + +retry: + phone = async_connect_me_to_internal(sess->phone, sess->arg1, + sess->arg2, sess->arg3, 0); + if (phone >= 0) { + exch = (async_exch_t *) malloc(sizeof(async_exch_t)); + if (exch != NULL) { + list_initialize(&exch->sess_link); + list_initialize(&exch->global_link); + exch->sess = sess; + exch->phone = phone; + } else + async_hangup_internal(phone); + } else if (!list_empty(&inactive_exch_list)) { + /* + * We did not manage to connect a new phone. But we + * can try to close some of the currently inactive + * connections in other sessions and try again. + */ + exch = (async_exch_t *) + list_get_instance(inactive_exch_list.next, async_exch_t, + global_link); + list_remove(&exch->sess_link); + list_remove(&exch->global_link); + async_hangup_internal(exch->phone); + free(exch); + goto retry; + } else { + /* + * Wait for a phone to become available. + */ + fibril_condvar_wait(&avail_phone_cv, &async_sess_mutex); + goto retry; + } + } + } + + fibril_mutex_unlock(&async_sess_mutex); + + if (exch != NULL) { + atomic_inc(&sess->refcnt); + + if (sess->mgmt == EXCHANGE_SERIALIZE) + fibril_mutex_lock(&sess->mutex); + } + + return exch; +} + +/** Finish an exchange. + * + * @param exch Exchange to finish. + * + */ +void async_exchange_end(async_exch_t *exch) +{ + if (exch == NULL) + return; + + async_sess_t *sess = exch->sess; + + if (sess->mgmt == EXCHANGE_SERIALIZE) + fibril_mutex_unlock(&sess->mutex); + + fibril_mutex_lock(&async_sess_mutex); + + list_append(&exch->sess_link, &sess->exch_list); + list_append(&exch->global_link, &inactive_exch_list); + fibril_condvar_signal(&avail_phone_cv); + + fibril_mutex_unlock(&async_sess_mutex); +} + /** Wrapper for IPC_M_SHARE_IN calls using the async framework. * - * @param phoneid Phone that will be used to contact the receiving side. - * @param dst Destination address space area base. - * @param size Size of the destination address space area. - * @param arg User defined argument. - * @param flags Storage for the received flags. Can be NULL. + * @param exch Exchange for sending the message. + * @param dst Destination address space area base. + * @param size Size of the destination address space area. + * @param arg User defined argument. + * @param flags Storage for the received flags. Can be NULL. * * @return Zero on success or a negative error code from errno.h. * */ -int async_share_in_start(int phoneid, void *dst, size_t size, sysarg_t arg, - unsigned int *flags) -{ +int async_share_in_start(async_exch_t *exch, void *dst, size_t size, + sysarg_t arg, unsigned int *flags) +{ + if (exch == NULL) + return ENOENT; + sysarg_t tmp_flags; - int res = async_req_3_2(phoneid, IPC_M_SHARE_IN, (sysarg_t) dst, + int res = async_req_3_2(exch, IPC_M_SHARE_IN, (sysarg_t) dst, (sysarg_t) size, arg, NULL, &tmp_flags); @@ -1507,14 +1896,17 @@ /** Wrapper for IPC_M_SHARE_OUT calls using the async framework. * - * @param phoneid Phone that will be used to contact the receiving side. - * @param src Source address space area base address. - * @param flags Flags to be used for sharing. Bits can be only cleared. + * @param exch Exchange for sending the message. + * @param src Source address space area base address. + * @param flags Flags to be used for sharing. Bits can be only cleared. * * @return Zero on success or a negative error code from errno.h. * */ -int async_share_out_start(int phoneid, void *src, unsigned int flags) -{ - return async_req_3_0(phoneid, IPC_M_SHARE_OUT, (sysarg_t) src, 0, +int async_share_out_start(async_exch_t *exch, void *src, unsigned int flags) +{ + if (exch == NULL) + return ENOENT; + + return async_req_3_0(exch, IPC_M_SHARE_OUT, (sysarg_t) src, 0, (sysarg_t) flags); } @@ -1569,19 +1961,37 @@ } +/** Start IPC_M_DATA_READ using the async framework. + * + * @param exch Exchange for sending the message. + * @param dst Address of the beginning of the destination buffer. + * @param size Size of the destination buffer (in bytes). + * @param dataptr Storage of call data (arg 2 holds actual data size). + * + * @return Hash of the sent message or 0 on error. + * + */ +aid_t async_data_read(async_exch_t *exch, void *dst, size_t size, + ipc_call_t *dataptr) +{ + return async_send_2(exch, IPC_M_DATA_READ, (sysarg_t) dst, + (sysarg_t) size, dataptr); +} + /** Wrapper for IPC_M_DATA_READ calls using the async framework. * - * @param phoneid Phone that will be used to contact the receiving side. - * @param dst Address of the beginning of the destination buffer. - * @param size Size of the destination buffer. - * @param flags Flags to control the data transfer. + * @param exch Exchange for sending the message. + * @param dst Address of the beginning of the destination buffer. + * @param size Size of the destination buffer. * * @return Zero on success or a negative error code from errno.h. * */ -int -async_data_read_start_generic(int phoneid, void *dst, size_t size, int flags) -{ - return async_req_3_0(phoneid, IPC_M_DATA_READ, (sysarg_t) dst, - (sysarg_t) size, (sysarg_t) flags); +int async_data_read_start(async_exch_t *exch, void *dst, size_t size) +{ + if (exch == NULL) + return ENOENT; + + return async_req_2_0(exch, IPC_M_DATA_READ, (sysarg_t) dst, + (sysarg_t) size); } @@ -1638,7 +2048,11 @@ * */ -int async_data_read_forward_fast(int phoneid, sysarg_t method, sysarg_t arg1, - sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, ipc_call_t *dataptr) -{ +int async_data_read_forward_fast(async_exch_t *exch, sysarg_t imethod, + sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, + ipc_call_t *dataptr) +{ + if (exch == NULL) + return ENOENT; + ipc_callid_t callid; if (!async_data_read_receive(&callid, NULL)) { @@ -1647,5 +2061,5 @@ } - aid_t msg = async_send_fast(phoneid, method, arg1, arg2, arg3, arg4, + aid_t msg = async_send_fast(exch, imethod, arg1, arg2, arg3, arg4, dataptr); if (msg == 0) { @@ -1654,5 +2068,5 @@ } - int retval = ipc_forward_fast(callid, phoneid, 0, 0, 0, + int retval = ipc_forward_fast(callid, exch->phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME); if (retval != EOK) { @@ -1670,18 +2084,18 @@ /** Wrapper for IPC_M_DATA_WRITE calls using the async framework. * - * @param phoneid Phone that will be used to contact the receiving side. - * @param src Address of the beginning of the source buffer. - * @param size Size of the source buffer. - * @param flags Flags to control the data transfer. + * @param exch Exchange for sending the message. + * @param src Address of the beginning of the source buffer. + * @param size Size of the source buffer. * * @return Zero on success or a negative error code from errno.h. * */ -int -async_data_write_start_generic(int phoneid, const void *src, size_t size, - int flags) -{ - return async_req_3_0(phoneid, IPC_M_DATA_WRITE, (sysarg_t) src, - (sysarg_t) size, (sysarg_t) flags); +int async_data_write_start(async_exch_t *exch, const void *src, size_t size) +{ + if (exch == NULL) + return ENOENT; + + return async_req_2_0(exch, IPC_M_DATA_WRITE, (sysarg_t) src, + (sysarg_t) size); } @@ -1759,4 +2173,6 @@ size_t *received) { + assert(data); + ipc_callid_t callid; size_t size; @@ -1826,7 +2242,11 @@ * */ -int async_data_write_forward_fast(int phoneid, sysarg_t method, sysarg_t arg1, - sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, ipc_call_t *dataptr) -{ +int async_data_write_forward_fast(async_exch_t *exch, sysarg_t imethod, + sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, + ipc_call_t *dataptr) +{ + if (exch == NULL) + return ENOENT; + ipc_callid_t callid; if (!async_data_write_receive(&callid, NULL)) { @@ -1835,5 +2255,5 @@ } - aid_t msg = async_send_fast(phoneid, method, arg1, arg2, arg3, arg4, + aid_t msg = async_send_fast(exch, imethod, arg1, arg2, arg3, arg4, dataptr); if (msg == 0) { @@ -1842,5 +2262,5 @@ } - int retval = ipc_forward_fast(callid, phoneid, 0, 0, 0, + int retval = ipc_forward_fast(callid, exch->phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME); if (retval != EOK) { @@ -1856,4 +2276,105 @@ } +/** Wrapper for sending an exchange over different exchange for cloning + * + * @param exch Exchange to be used for sending. + * @param clone_exch Exchange to be cloned. + * + */ +int async_exchange_clone(async_exch_t *exch, async_exch_t *clone_exch) +{ + return async_req_1_0(exch, IPC_M_CONNECTION_CLONE, clone_exch->phone); +} + +/** Wrapper for receiving the IPC_M_CONNECTION_CLONE calls. + * + * If the current call is IPC_M_CONNECTION_CLONE then a new + * async session is created for the accepted phone. + * + * @param mgmt Exchange management style. + * + * @return New async session or NULL on failure. + * + */ +async_sess_t *async_clone_receive(exch_mgmt_t mgmt) +{ + /* Accept the phone */ + ipc_call_t call; + ipc_callid_t callid = async_get_call(&call); + int phone = (int) IPC_GET_ARG1(call); + + if ((IPC_GET_IMETHOD(call) != IPC_M_CONNECTION_CLONE) || + (phone < 0)) { + async_answer_0(callid, EINVAL); + return NULL; + } + + async_sess_t *sess = (async_sess_t *) malloc(sizeof(async_sess_t)); + if (sess == NULL) { + async_answer_0(callid, ENOMEM); + return NULL; + } + + sess->mgmt = mgmt; + sess->phone = phone; + sess->arg1 = 0; + sess->arg2 = 0; + sess->arg3 = 0; + + list_initialize(&sess->exch_list); + fibril_mutex_initialize(&sess->mutex); + atomic_set(&sess->refcnt, 0); + + /* Acknowledge the cloned phone */ + async_answer_0(callid, EOK); + + return sess; +} + +/** Wrapper for receiving the IPC_M_CONNECT_TO_ME calls. + * + * If the current call is IPC_M_CONNECT_TO_ME then a new + * async session is created for the accepted phone. + * + * @param mgmt Exchange management style. + * + * @return New async session or NULL on failure. + * + */ +async_sess_t *async_callback_receive(exch_mgmt_t mgmt) +{ + /* Accept the phone */ + ipc_call_t call; + ipc_callid_t callid = async_get_call(&call); + int phone = (int) IPC_GET_ARG5(call); + + if ((IPC_GET_IMETHOD(call) != IPC_M_CONNECT_TO_ME) || + (phone < 0)) { + async_answer_0(callid, EINVAL); + return NULL; + } + + async_sess_t *sess = (async_sess_t *) malloc(sizeof(async_sess_t)); + if (sess == NULL) { + async_answer_0(callid, ENOMEM); + return NULL; + } + + sess->mgmt = mgmt; + sess->phone = phone; + sess->arg1 = 0; + sess->arg2 = 0; + sess->arg3 = 0; + + list_initialize(&sess->exch_list); + fibril_mutex_initialize(&sess->mutex); + atomic_set(&sess->refcnt, 0); + + /* Acknowledge the connected phone */ + async_answer_0(callid, EOK); + + return sess; +} + /** @} */ Index: uspace/lib/c/generic/async_obsolete.c =================================================================== --- uspace/lib/c/generic/async_obsolete.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/c/generic/async_obsolete.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,460 @@ +/* + * Copyright (c) 2006 Ondrej Palkovsky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libc + * @{ + */ +/** @file + */ + +#define LIBC_ASYNC_C_ +#define LIBC_ASYNC_OBSOLETE_C_ +#include +#include +#include +#undef LIBC_ASYNC_C_ +#undef LIBC_ASYNC_OBSOLETE_C_ + +#include +#include +#include +#include "private/async.h" + +/** Send message and return id of the sent message. + * + * The return value can be used as input for async_wait() to wait for + * completion. + * + * @param phoneid Handle of the phone that will be used for the send. + * @param method Service-defined method. + * @param arg1 Service-defined payload argument. + * @param arg2 Service-defined payload argument. + * @param arg3 Service-defined payload argument. + * @param arg4 Service-defined payload argument. + * @param dataptr If non-NULL, storage where the reply data will be + * stored. + * + * @return Hash of the sent message or 0 on error. + * + */ +aid_t async_obsolete_send_fast(int phoneid, sysarg_t method, sysarg_t arg1, + sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, ipc_call_t *dataptr) +{ + amsg_t *msg = malloc(sizeof(amsg_t)); + + if (!msg) + return 0; + + msg->done = false; + msg->dataptr = dataptr; + + msg->wdata.to_event.inlist = false; + + /* + * We may sleep in the next method, + * but it will use its own means + */ + msg->wdata.active = true; + + ipc_call_async_4(phoneid, method, arg1, arg2, arg3, arg4, msg, + reply_received, true); + + return (aid_t) msg; +} + +/** Pseudo-synchronous message sending - fast version. + * + * Send message asynchronously and return only after the reply arrives. + * + * This function can only transfer 4 register payload arguments. For + * transferring more arguments, see the slower async_req_slow(). + * + * @param phoneid Hash of the phone through which to make the call. + * @param method Method of the call. + * @param arg1 Service-defined payload argument. + * @param arg2 Service-defined payload argument. + * @param arg3 Service-defined payload argument. + * @param arg4 Service-defined payload argument. + * @param r1 If non-NULL, storage for the 1st reply argument. + * @param r2 If non-NULL, storage for the 2nd reply argument. + * @param r3 If non-NULL, storage for the 3rd reply argument. + * @param r4 If non-NULL, storage for the 4th reply argument. + * @param r5 If non-NULL, storage for the 5th reply argument. + * + * @return Return code of the reply or a negative error code. + * + */ +sysarg_t async_obsolete_req_fast(int phoneid, sysarg_t method, sysarg_t arg1, + sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t *r1, sysarg_t *r2, + sysarg_t *r3, sysarg_t *r4, sysarg_t *r5) +{ + ipc_call_t result; + aid_t eid = async_obsolete_send_4(phoneid, method, arg1, arg2, arg3, arg4, + &result); + + sysarg_t rc; + async_wait_for(eid, &rc); + + if (r1) + *r1 = IPC_GET_ARG1(result); + + if (r2) + *r2 = IPC_GET_ARG2(result); + + if (r3) + *r3 = IPC_GET_ARG3(result); + + if (r4) + *r4 = IPC_GET_ARG4(result); + + if (r5) + *r5 = IPC_GET_ARG5(result); + + return rc; +} + +/** Wrapper for IPC_M_SHARE_OUT calls using the async framework. + * + * @param phoneid Phone that will be used to contact the receiving side. + * @param src Source address space area base address. + * @param flags Flags to be used for sharing. Bits can be only cleared. + * + * @return Zero on success or a negative error code from errno.h. + * + */ +int async_obsolete_share_out_start(int phoneid, void *src, unsigned int flags) +{ + return async_obsolete_req_3_0(phoneid, IPC_M_SHARE_OUT, (sysarg_t) src, 0, + (sysarg_t) flags); +} + +/** Wrapper for ipc_hangup. + * + * @param phone Phone handle to hung up. + * + * @return Zero on success or a negative error code. + * + */ +int async_obsolete_hangup(int phone) +{ + return ipc_hangup(phone); +} + +void async_obsolete_serialize_start(void) +{ + fibril_inc_sercount(); +} + +void async_obsolete_serialize_end(void) +{ + fibril_dec_sercount(); +} + +/** Wrapper for IPC_M_DATA_WRITE calls using the async framework. + * + * @param phoneid Phone that will be used to contact the receiving side. + * @param src Address of the beginning of the source buffer. + * @param size Size of the source buffer. + * @param flags Flags to control the data transfer. + * + * @return Zero on success or a negative error code from errno.h. + * + */ +int async_obsolete_data_write_start_generic(int phoneid, const void *src, size_t size, + int flags) +{ + return async_obsolete_req_3_0(phoneid, IPC_M_DATA_WRITE, (sysarg_t) src, + (sysarg_t) size, (sysarg_t) flags); +} + +/** Start IPC_M_DATA_READ using the async framework. + * + * @param phoneid Phone that will be used to contact the receiving side. + * @param dst Address of the beginning of the destination buffer. + * @param size Size of the destination buffer (in bytes). + * @param dataptr Storage of call data (arg 2 holds actual data size). + * + * @return Hash of the sent message or 0 on error. + * + */ +aid_t async_obsolete_data_read(int phone, void *dst, size_t size, + ipc_call_t *dataptr) +{ + return async_obsolete_send_2(phone, IPC_M_DATA_READ, (sysarg_t) dst, + (sysarg_t) size, dataptr); +} + +/** Wrapper for IPC_M_DATA_READ calls using the async framework. + * + * @param phoneid Phone that will be used to contact the receiving side. + * @param dst Address of the beginning of the destination buffer. + * @param size Size of the destination buffer. + * @param flags Flags to control the data transfer. + * + * @return Zero on success or a negative error code from errno.h. + * + */ +int async_obsolete_data_read_start_generic(int phoneid, void *dst, size_t size, int flags) +{ + return async_obsolete_req_3_0(phoneid, IPC_M_DATA_READ, (sysarg_t) dst, + (sysarg_t) size, (sysarg_t) flags); +} + +/** Wrapper for making IPC_M_CONNECT_TO_ME calls using the async framework. + * + * Ask through phone for a new connection to some service. + * + * @param phone Phone handle used for contacting the other side. + * @param arg1 User defined argument. + * @param arg2 User defined argument. + * @param arg3 User defined argument. + * @param client_receiver Connection handing routine. + * + * @return New phone handle on success or a negative error code. + * + */ +int async_obsolete_connect_to_me(int phone, sysarg_t arg1, sysarg_t arg2, + sysarg_t arg3, async_client_conn_t client_receiver) +{ + sysarg_t task_hash; + sysarg_t phone_hash; + int rc = async_obsolete_req_3_5(phone, IPC_M_CONNECT_TO_ME, arg1, arg2, arg3, + NULL, NULL, NULL, &task_hash, &phone_hash); + if (rc != EOK) + return rc; + + if (client_receiver != NULL) + async_new_connection(task_hash, phone_hash, 0, NULL, + client_receiver); + + return EOK; +} + +/** Wrapper for making IPC_M_CONNECT_ME_TO calls using the async framework. + * + * Ask through phone for a new connection to some service. + * + * @param phone Phone handle used for contacting the other side. + * @param arg1 User defined argument. + * @param arg2 User defined argument. + * @param arg3 User defined argument. + * + * @return New phone handle on success or a negative error code. + * + */ +int async_obsolete_connect_me_to(int phone, sysarg_t arg1, sysarg_t arg2, + sysarg_t arg3) +{ + sysarg_t newphid; + int rc = async_obsolete_req_3_5(phone, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3, + NULL, NULL, NULL, NULL, &newphid); + + if (rc != EOK) + return rc; + + return newphid; +} + +/** Wrapper for making IPC_M_CONNECT_ME_TO calls using the async framework. + * + * Ask through phone for a new connection to some service and block until + * success. + * + * @param phoneid Phone handle used for contacting the other side. + * @param arg1 User defined argument. + * @param arg2 User defined argument. + * @param arg3 User defined argument. + * + * @return New phone handle on success or a negative error code. + * + */ +int async_obsolete_connect_me_to_blocking(int phoneid, sysarg_t arg1, sysarg_t arg2, + sysarg_t arg3) +{ + sysarg_t newphid; + int rc = async_obsolete_req_4_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3, + IPC_FLAG_BLOCKING, NULL, NULL, NULL, NULL, &newphid); + + if (rc != EOK) + return rc; + + return newphid; +} + +/** Send message and return id of the sent message + * + * The return value can be used as input for async_wait() to wait for + * completion. + * + * @param phoneid Handle of the phone that will be used for the send. + * @param method Service-defined method. + * @param arg1 Service-defined payload argument. + * @param arg2 Service-defined payload argument. + * @param arg3 Service-defined payload argument. + * @param arg4 Service-defined payload argument. + * @param arg5 Service-defined payload argument. + * @param dataptr If non-NULL, storage where the reply data will be + * stored. + * + * @return Hash of the sent message or 0 on error. + * + */ +aid_t async_obsolete_send_slow(int phoneid, sysarg_t method, sysarg_t arg1, + sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, + ipc_call_t *dataptr) +{ + amsg_t *msg = malloc(sizeof(amsg_t)); + + if (!msg) + return 0; + + msg->done = false; + msg->dataptr = dataptr; + + msg->wdata.to_event.inlist = false; + + /* + * We may sleep in the next method, + * but it will use its own means + */ + msg->wdata.active = true; + + ipc_call_async_5(phoneid, method, arg1, arg2, arg3, arg4, arg5, msg, + reply_received, true); + + return (aid_t) msg; +} + +void async_obsolete_msg_0(int phone, sysarg_t imethod) +{ + ipc_call_async_0(phone, imethod, NULL, NULL, true); +} + +void async_obsolete_msg_1(int phone, sysarg_t imethod, sysarg_t arg1) +{ + ipc_call_async_1(phone, imethod, arg1, NULL, NULL, true); +} + +void async_obsolete_msg_2(int phone, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2) +{ + ipc_call_async_2(phone, imethod, arg1, arg2, NULL, NULL, true); +} + +void async_obsolete_msg_3(int phone, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, + sysarg_t arg3) +{ + ipc_call_async_3(phone, imethod, arg1, arg2, arg3, NULL, NULL, true); +} + +void async_obsolete_msg_4(int phone, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, + sysarg_t arg3, sysarg_t arg4) +{ + ipc_call_async_4(phone, imethod, arg1, arg2, arg3, arg4, NULL, NULL, + true); +} + +void async_obsolete_msg_5(int phone, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, + sysarg_t arg3, sysarg_t arg4, sysarg_t arg5) +{ + ipc_call_async_5(phone, imethod, arg1, arg2, arg3, arg4, arg5, NULL, + NULL, true); +} + +/** Wrapper for IPC_M_SHARE_IN calls using the async framework. + * + * @param phoneid Phone that will be used to contact the receiving side. + * @param dst Destination address space area base. + * @param size Size of the destination address space area. + * @param arg User defined argument. + * @param flags Storage for the received flags. Can be NULL. + * + * @return Zero on success or a negative error code from errno.h. + * + */ +int async_obsolete_share_in_start(int phoneid, void *dst, size_t size, sysarg_t arg, + unsigned int *flags) +{ + sysarg_t tmp_flags; + int res = async_obsolete_req_3_2(phoneid, IPC_M_SHARE_IN, (sysarg_t) dst, + (sysarg_t) size, arg, NULL, &tmp_flags); + + if (flags) + *flags = (unsigned int) tmp_flags; + + return res; +} + +int async_obsolete_forward_fast(ipc_callid_t callid, int phoneid, sysarg_t imethod, + sysarg_t arg1, sysarg_t arg2, unsigned int mode) +{ + return ipc_forward_fast(callid, phoneid, imethod, arg1, arg2, mode); +} + +int async_obsolete_forward_slow(ipc_callid_t callid, int phoneid, sysarg_t imethod, + sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, + unsigned int mode) +{ + return ipc_forward_slow(callid, phoneid, imethod, arg1, arg2, arg3, arg4, + arg5, mode); +} + +/** Wrapper for forwarding any data that is about to be received + * + */ +int async_obsolete_data_write_forward_fast(int phoneid, sysarg_t method, sysarg_t arg1, + sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, ipc_call_t *dataptr) +{ + ipc_callid_t callid; + if (!async_data_write_receive(&callid, NULL)) { + ipc_answer_0(callid, EINVAL); + return EINVAL; + } + + aid_t msg = async_obsolete_send_fast(phoneid, method, arg1, arg2, arg3, arg4, + dataptr); + if (msg == 0) { + ipc_answer_0(callid, EINVAL); + return EINVAL; + } + + int retval = ipc_forward_fast(callid, phoneid, 0, 0, 0, + IPC_FF_ROUTE_FROM_ME); + if (retval != EOK) { + async_wait_for(msg, NULL); + ipc_answer_0(callid, retval); + return retval; + } + + sysarg_t rc; + async_wait_for(msg, &rc); + + return (int) rc; +} + +/** @} + */ Index: uspace/lib/c/generic/async_sess.c =================================================================== --- uspace/lib/c/generic/async_sess.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ (revision ) @@ -1,309 +1,0 @@ -/* - * Copyright (c) 2010 Jakub Jermar - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup libc - * @{ - */ -/** @file - */ - -/** - * This file implements simple session support for the async framework. - * - * By the term 'session', we mean a logical data path between a client and a - * server over which the client can perform multiple concurrent exchanges. - * Each exchange consists of one or more requests (IPC calls) which can - * be potentially blocking. - * - * Clients and servers are naturally connected using IPC phones, thus an IPC - * phone represents a session between a client and a server. In one - * session, there can be many outstanding exchanges. In the current - * implementation each concurrent exchanges takes place over a different - * connection (there can be at most one active exchage per connection). - * - * Sessions make it useful for a client or client API to support concurrent - * requests, independent of the actual implementation. Sessions provide - * an abstract interface to concurrent IPC communication. This is especially - * useful for client API stubs that aim to be reentrant (i.e. that allow - * themselves to be called from different fibrils and threads concurrently). - * - * There are several possible implementations of sessions. This implementation - * uses additional phones to represent sessions. Using phones both for the - * session and also for its exchages/connections has several advantages: - * - * - to make a series of exchanges over a session, the client can continue to - * use the existing async framework APIs - * - the server supports sessions by the virtue of spawning a new connection - * fibril, just as it does for every new connection even without sessions - * - the implementation is pretty straightforward; a very naive implementation - * would be to make each exchage using a fresh phone (that is what we - * have done in the past); a slightly better approach would be to cache - * connections so that they can be reused by a later exchange within - * the same session (that is what this implementation does) - * - * The main disadvantages of using phones to represent sessions are: - * - * - if there are too many exchanges (even cached ones), the task may hit its - * limit on the maximum number of connected phones, which could prevent the - * task from making new IPC connections to other tasks - * - if there are too many IPC connections already, it may be impossible to - * create an exchange by connecting a new phone thanks to the task's limit on - * the maximum number of connected phones - * - * These problems can be alleviated by increasing the limit on the maximum - * number of connected phones to some reasonable value and by limiting the number - * of cached connections to some fraction of this limit. - * - * The cache itself has a mechanism to close some number of unused phones if a - * new phone cannot be connected, but the outer world currently does not have a - * way to ask the phone cache to shrink. - * - * To minimize the confusion stemming from the fact that we use phones for two - * things (the session itself and also one for each data connection), this file - * makes the distinction by using the term 'session phone' for the former and - * 'data phone' for the latter. Under the hood, all phones remain equal, - * of course. - * - * There is a small inefficiency in that the cache repeatedly allocates and - * deallocates the conn_node_t structures when in fact it could keep the - * allocated structures around and reuse them later. But such a solution would - * be effectively implementing a poor man's slab allocator while it would be - * better to have the slab allocator ported to uspace so that everyone could - * benefit from it. - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include "private/async_sess.h" - -/** An inactive open connection. */ -typedef struct { - link_t sess_link; /**< Link for the session list of inactive connections. */ - link_t global_link; /**< Link for the global list of inactive connections. */ - int data_phone; /**< Connected data phone. */ -} conn_node_t; - -/** - * Mutex protecting the inactive_conn_head list, the session list and the - * avail_phone condition variable. - */ -static fibril_mutex_t async_sess_mutex; - -/** - * List of all currently inactive connections. - */ -static LIST_INITIALIZE(inactive_conn_head); - -/** - * List of all open sessions. - */ -static LIST_INITIALIZE(session_list_head); - -/** - * Condition variable used to wait for a phone to become available. - */ -static FIBRIL_CONDVAR_INITIALIZE(avail_phone_cv); - -/** Initialize the async_sess subsystem. - * - * Needs to be called prior to any other interface in this file. - * - */ -void __async_sess_init(void) -{ - fibril_mutex_initialize(&async_sess_mutex); - list_initialize(&inactive_conn_head); - list_initialize(&session_list_head); -} - -/** Create a session. - * - * Session is a logical datapath from a client task to a server task. - * One session can accomodate multiple concurrent exchanges. Here - * @a phone is a phone connected to the desired server task. - * - * This function always succeeds. - * - * @param sess Session structure provided by caller, will be filled in. - * @param phone Phone connected to the desired server task. - * @param arg1 Value to pass as first argument upon creating a new - * connection. Typical use is to identify a resource within - * the server that the caller wants to access (port ID, - * interface ID, device ID, etc.). - */ -void async_session_create(async_sess_t *sess, int phone, sysarg_t arg1) -{ - sess->sess_phone = phone; - sess->connect_arg1 = arg1; - list_initialize(&sess->conn_head); - - /* Add to list of sessions. */ - fibril_mutex_lock(&async_sess_mutex); - list_append(&sess->sess_link, &session_list_head); - fibril_mutex_unlock(&async_sess_mutex); -} - -/** Destroy a session. - * - * Dismantle session structure @a sess and release any resources (connections) - * held by the session. - * - * @param sess Session to destroy. - */ -void async_session_destroy(async_sess_t *sess) -{ - conn_node_t *conn; - - /* Remove from list of sessions. */ - fibril_mutex_lock(&async_sess_mutex); - list_remove(&sess->sess_link); - fibril_mutex_unlock(&async_sess_mutex); - - /* We did not connect the phone so we do not hang it up either. */ - sess->sess_phone = -1; - - /* Tear down all data connections. */ - while (!list_empty(&sess->conn_head)) { - conn = list_get_instance(sess->conn_head.next, conn_node_t, - sess_link); - - list_remove(&conn->sess_link); - list_remove(&conn->global_link); - - async_hangup(conn->data_phone); - free(conn); - } - - fibril_condvar_broadcast(&avail_phone_cv); -} - -static void conn_node_initialize(conn_node_t *conn) -{ - link_initialize(&conn->sess_link); - link_initialize(&conn->global_link); - conn->data_phone = -1; -} - -/** Start new exchange in a session. - * - * @param sess_phone Session. - * @return Phone representing the new exchange or a negative error - * code. - */ -int async_exchange_begin(async_sess_t *sess) -{ - conn_node_t *conn; - int data_phone; - - fibril_mutex_lock(&async_sess_mutex); - - if (!list_empty(&sess->conn_head)) { - /* - * There are inactive connections in the session. - */ - conn = list_get_instance(sess->conn_head.next, conn_node_t, - sess_link); - list_remove(&conn->sess_link); - list_remove(&conn->global_link); - - data_phone = conn->data_phone; - free(conn); - } else { - /* - * There are no available connections in the session. - * Make a one-time attempt to connect a new data phone. - */ -retry: - data_phone = async_connect_me_to(sess->sess_phone, - sess->connect_arg1, 0, 0); - if (data_phone >= 0) { - /* success, do nothing */ - } else if (!list_empty(&inactive_conn_head)) { - /* - * We did not manage to connect a new phone. But we can - * try to close some of the currently inactive - * connections in other sessions and try again. - */ - conn = list_get_instance(inactive_conn_head.next, - conn_node_t, global_link); - list_remove(&conn->global_link); - list_remove(&conn->sess_link); - data_phone = conn->data_phone; - free(conn); - async_hangup(data_phone); - goto retry; - } else { - /* - * Wait for a phone to become available. - */ - fibril_condvar_wait(&avail_phone_cv, &async_sess_mutex); - goto retry; - } - } - - fibril_mutex_unlock(&async_sess_mutex); - return data_phone; -} - -/** Finish an exchange. - * - * @param sess Session. - * @param data_phone Phone representing the exchange within the session. - */ -void async_exchange_end(async_sess_t *sess, int data_phone) -{ - conn_node_t *conn; - - fibril_mutex_lock(&async_sess_mutex); - fibril_condvar_signal(&avail_phone_cv); - conn = (conn_node_t *) malloc(sizeof(conn_node_t)); - if (!conn) { - /* - * Being unable to remember the connected data phone here - * means that we simply hang up. - */ - async_hangup(data_phone); - fibril_mutex_unlock(&async_sess_mutex); - return; - } - - conn_node_initialize(conn); - conn->data_phone = data_phone; - list_append(&conn->sess_link, &sess->conn_head); - list_append(&conn->global_link, &inactive_conn_head); - fibril_mutex_unlock(&async_sess_mutex); -} - -/** @} - */ Index: uspace/lib/c/generic/clipboard.c =================================================================== --- uspace/lib/c/generic/clipboard.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/generic/clipboard.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -39,7 +39,8 @@ #include -#include +#include #include #include +#include #include #include @@ -47,13 +48,33 @@ #include -static int clip_phone = -1; - -/** Connect to clipboard server - * - */ -static void clip_connect(void) -{ - while (clip_phone < 0) - clip_phone = service_connect_blocking(SERVICE_CLIPBOARD, 0, 0); +static FIBRIL_MUTEX_INITIALIZE(clip_mutex); +static async_sess_t *clip_sess = NULL; + +/** Start an async exchange on the clipboard session. + * + * @return New exchange. + * + */ +static async_exch_t *clip_exchange_begin(void) +{ + fibril_mutex_lock(&clip_mutex); + + while (clip_sess == NULL) + clip_sess = service_connect_blocking(EXCHANGE_SERIALIZE, + SERVICE_CLIPBOARD, 0, 0); + + fibril_mutex_unlock(&clip_mutex); + + return async_exchange_begin(clip_sess); +} + +/** Finish an async exchange on the clipboard session. + * + * @param exch Exchange to be finished. + * + */ +static void clip_exchange_end(async_exch_t *exch) +{ + async_exchange_end(exch); } @@ -73,22 +94,20 @@ if (size == 0) { - async_serialize_start(); - clip_connect(); - - sysarg_t rc = async_req_1_0(clip_phone, CLIPBOARD_PUT_DATA, CLIPBOARD_TAG_NONE); - - async_serialize_end(); + async_exch_t *exch = clip_exchange_begin(); + sysarg_t rc = async_req_1_0(exch, CLIPBOARD_PUT_DATA, + CLIPBOARD_TAG_NONE); + clip_exchange_end(exch); return (int) rc; } else { - async_serialize_start(); - clip_connect(); - - aid_t req = async_send_1(clip_phone, CLIPBOARD_PUT_DATA, CLIPBOARD_TAG_DATA, NULL); - sysarg_t rc = async_data_write_start(clip_phone, (void *) str, size); + async_exch_t *exch = clip_exchange_begin(); + aid_t req = async_send_1(exch, CLIPBOARD_PUT_DATA, CLIPBOARD_TAG_DATA, + NULL); + sysarg_t rc = async_data_write_start(exch, (void *) str, size); + clip_exchange_end(exch); + if (rc != EOK) { sysarg_t rc_orig; async_wait_for(req, &rc_orig); - async_serialize_end(); if (rc_orig == EOK) return (int) rc; @@ -98,5 +117,4 @@ async_wait_for(req, &rc); - async_serialize_end(); return (int) rc; @@ -117,12 +135,11 @@ /* Loop until clipboard read succesful */ while (true) { - async_serialize_start(); - clip_connect(); + async_exch_t *exch = clip_exchange_begin(); sysarg_t size; sysarg_t tag; - sysarg_t rc = async_req_0_2(clip_phone, CLIPBOARD_CONTENT, &size, &tag); - - async_serialize_end(); + sysarg_t rc = async_req_0_2(exch, CLIPBOARD_CONTENT, &size, &tag); + + clip_exchange_end(exch); if (rc != EOK) @@ -145,8 +162,9 @@ return ENOMEM; - async_serialize_start(); - - aid_t req = async_send_1(clip_phone, CLIPBOARD_GET_DATA, tag, NULL); - rc = async_data_read_start(clip_phone, (void *) sbuf, size); + exch = clip_exchange_begin(); + aid_t req = async_send_1(exch, CLIPBOARD_GET_DATA, tag, NULL); + rc = async_data_read_start(exch, (void *) sbuf, size); + clip_exchange_end(exch); + if ((int) rc == EOVERFLOW) { /* @@ -154,5 +172,4 @@ * the last call of CLIPBOARD_CONTENT */ - async_serialize_end(); break; } @@ -161,5 +178,4 @@ sysarg_t rc_orig; async_wait_for(req, &rc_orig); - async_serialize_end(); if (rc_orig == EOK) return (int) rc; @@ -169,5 +185,4 @@ async_wait_for(req, &rc); - async_serialize_end(); if (rc == EOK) { Index: uspace/lib/c/generic/device/char_dev.c =================================================================== --- uspace/lib/c/generic/device/char_dev.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/generic/device/char_dev.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -45,35 +45,37 @@ * using its character interface. * - * @param dev_phone Phone to the device. - * @param buf Buffer for the data read from or written to the device. - * @param size Maximum size of data (in bytes) to be read or written. - * @param read Read from the device if true, write to it otherwise. + * @param sess Session to the device. + * @param buf Buffer for the data read from or written to the device. + * @param size Maximum size of data (in bytes) to be read or written. + * @param read Read from the device if true, write to it otherwise. * - * @return Non-negative number of bytes actually read from or - * written to the device on success, negative error number - * otherwise. + * @return Non-negative number of bytes actually read from or + * written to the device on success, negative error number + * otherwise. + * */ -static ssize_t char_dev_rw(int dev_phone, void *buf, size_t size, bool read) +static ssize_t char_dev_rw(async_sess_t *sess, void *buf, size_t size, bool read) { - async_serialize_start(); - ipc_call_t answer; aid_t req; int ret; + async_exch_t *exch = async_exchange_begin(sess); + if (read) { - req = async_send_1(dev_phone, DEV_IFACE_ID(CHAR_DEV_IFACE), + req = async_send_1(exch, DEV_IFACE_ID(CHAR_DEV_IFACE), CHAR_DEV_READ, &answer); - ret = async_data_read_start(dev_phone, buf, size); + ret = async_data_read_start(exch, buf, size); } else { - req = async_send_1(dev_phone, DEV_IFACE_ID(CHAR_DEV_IFACE), + req = async_send_1(exch, DEV_IFACE_ID(CHAR_DEV_IFACE), CHAR_DEV_WRITE, &answer); - ret = async_data_write_start(dev_phone, buf, size); + ret = async_data_write_start(exch, buf, size); } + + async_exchange_end(exch); sysarg_t rc; if (ret != EOK) { async_wait_for(req, &rc); - async_serialize_end(); if (rc == EOK) return (ssize_t) ret; @@ -83,5 +85,4 @@ async_wait_for(req, &rc); - async_serialize_end(); ret = (int) rc; @@ -94,29 +95,31 @@ /** Read from character device. * - * @param dev_phone Phone to the device. - * @param buf Output buffer for the data read from the device. - * @param size Maximum size (in bytes) of the data to be read. + * @param sess Session to the device. + * @param buf Output buffer for the data read from the device. + * @param size Maximum size (in bytes) of the data to be read. * - * @return Non-negative number of bytes actually read from the - * device on success, negative error number otherwise. + * @return Non-negative number of bytes actually read from the + * device on success, negative error number otherwise. + * */ -ssize_t char_dev_read(int dev_phone, void *buf, size_t size) +ssize_t char_dev_read(async_sess_t *sess, void *buf, size_t size) { - return char_dev_rw(dev_phone, buf, size, true); + return char_dev_rw(sess, buf, size, true); } /** Write to character device. * - * @param dev_phone Phone to the device. - * @param buf Input buffer containg the data to be written to the - * device. - * @param size Maximum size (in bytes) of the data to be written. + * @param sess Session to the device. + * @param buf Input buffer containg the data to be written to the + * device. + * @param size Maximum size (in bytes) of the data to be written. * - * @return Non-negative number of bytes actually written to the - * device on success, negative error number otherwise. + * @return Non-negative number of bytes actually written to the + * device on success, negative error number otherwise. + * */ -ssize_t char_dev_write(int dev_phone, void *buf, size_t size) +ssize_t char_dev_write(async_sess_t *sess, void *buf, size_t size) { - return char_dev_rw(dev_phone, buf, size, false); + return char_dev_rw(sess, buf, size, false); } Index: uspace/lib/c/generic/device/hw_res.c =================================================================== --- uspace/lib/c/generic/device/hw_res.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/generic/device/hw_res.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -38,36 +38,48 @@ #include -int hw_res_get_resource_list(int dev_phone, hw_resource_list_t *hw_resources) +int hw_res_get_resource_list(async_sess_t *sess, + hw_resource_list_t *hw_resources) { sysarg_t count = 0; - - int rc = async_req_1_1(dev_phone, DEV_IFACE_ID(HW_RES_DEV_IFACE), + + async_exch_t *exch = async_exchange_begin(sess); + int rc = async_req_1_1(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE), HW_RES_GET_RESOURCE_LIST, &count); - - hw_resources->count = count; - if (rc != EOK) + + if (rc != EOK) { + async_exchange_end(exch); return rc; + } size_t size = count * sizeof(hw_resource_t); - hw_resources->resources = (hw_resource_t *)malloc(size); - if (!hw_resources->resources) + hw_resource_t *resources = (hw_resource_t *) malloc(size); + if (resources == NULL) { + // FIXME: This is protocol violation + async_exchange_end(exch); return ENOMEM; + } - rc = async_data_read_start(dev_phone, hw_resources->resources, size); + rc = async_data_read_start(exch, resources, size); + async_exchange_end(exch); + if (rc != EOK) { - free(hw_resources->resources); - hw_resources->resources = NULL; + free(resources); return rc; } + + hw_resources->resources = resources; + hw_resources->count = count; return EOK; } -bool hw_res_enable_interrupt(int dev_phone) +bool hw_res_enable_interrupt(async_sess_t *sess) { - int rc = async_req_1_0(dev_phone, DEV_IFACE_ID(HW_RES_DEV_IFACE), + async_exch_t *exch = async_exchange_begin(sess); + int rc = async_req_1_0(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE), HW_RES_ENABLE_INTERRUPT); - - return rc == EOK; + async_exchange_end(exch); + + return (rc == EOK); } Index: uspace/lib/c/generic/devman.c =================================================================== --- uspace/lib/c/generic/devman.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/generic/devman.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -36,59 +36,141 @@ #include -#include #include +#include #include #include +#include #include -#include #include #include #include -#include - -static int devman_phone_driver = -1; -static int devman_phone_client = -1; - -static FIBRIL_MUTEX_INITIALIZE(devman_phone_mutex); - -int devman_get_phone(devman_interface_t iface, unsigned int flags) + +static FIBRIL_MUTEX_INITIALIZE(devman_driver_block_mutex); +static FIBRIL_MUTEX_INITIALIZE(devman_client_block_mutex); + +static FIBRIL_MUTEX_INITIALIZE(devman_driver_mutex); +static FIBRIL_MUTEX_INITIALIZE(devman_client_mutex); + +static async_sess_t *devman_driver_block_sess = NULL; +static async_sess_t *devman_client_block_sess = NULL; + +static async_sess_t *devman_driver_sess = NULL; +static async_sess_t *devman_client_sess = NULL; + +static void clone_session(fibril_mutex_t *mtx, async_sess_t *src, + async_sess_t **dst) +{ + fibril_mutex_lock(mtx); + + if ((*dst == NULL) && (src != NULL)) + *dst = src; + + fibril_mutex_unlock(mtx); +} + +/** Start an async exchange on the devman session (blocking). + * + * @param iface Device manager interface to choose + * + * @return New exchange. + * + */ +async_exch_t *devman_exchange_begin_blocking(devman_interface_t iface) { switch (iface) { case DEVMAN_DRIVER: - fibril_mutex_lock(&devman_phone_mutex); - if (devman_phone_driver >= 0) { - fibril_mutex_unlock(&devman_phone_mutex); - return devman_phone_driver; + fibril_mutex_lock(&devman_driver_block_mutex); + + while (devman_driver_block_sess == NULL) { + clone_session(&devman_driver_mutex, devman_driver_sess, + &devman_driver_block_sess); + + if (devman_driver_block_sess == NULL) + devman_driver_block_sess = + service_connect_blocking(EXCHANGE_SERIALIZE, + SERVICE_DEVMAN, DEVMAN_DRIVER, 0); } - if (flags & IPC_FLAG_BLOCKING) - devman_phone_driver = async_connect_me_to_blocking( - PHONE_NS, SERVICE_DEVMAN, DEVMAN_DRIVER, 0); - else - devman_phone_driver = async_connect_me_to(PHONE_NS, - SERVICE_DEVMAN, DEVMAN_DRIVER, 0); - - fibril_mutex_unlock(&devman_phone_mutex); - return devman_phone_driver; + fibril_mutex_unlock(&devman_driver_block_mutex); + + clone_session(&devman_driver_mutex, devman_driver_block_sess, + &devman_driver_sess); + + return async_exchange_begin(devman_driver_block_sess); case DEVMAN_CLIENT: - fibril_mutex_lock(&devman_phone_mutex); - if (devman_phone_client >= 0) { - fibril_mutex_unlock(&devman_phone_mutex); - return devman_phone_client; + fibril_mutex_lock(&devman_client_block_mutex); + + while (devman_client_block_sess == NULL) { + clone_session(&devman_client_mutex, devman_client_sess, + &devman_client_block_sess); + + if (devman_client_block_sess == NULL) + devman_client_block_sess = + service_connect_blocking(EXCHANGE_SERIALIZE, + SERVICE_DEVMAN, DEVMAN_CLIENT, 0); } - if (flags & IPC_FLAG_BLOCKING) { - devman_phone_client = async_connect_me_to_blocking( - PHONE_NS, SERVICE_DEVMAN, DEVMAN_CLIENT, 0); - } else { - devman_phone_client = async_connect_me_to(PHONE_NS, - SERVICE_DEVMAN, DEVMAN_CLIENT, 0); - } - - fibril_mutex_unlock(&devman_phone_mutex); - return devman_phone_client; + fibril_mutex_unlock(&devman_client_block_mutex); + + clone_session(&devman_client_mutex, devman_client_block_sess, + &devman_client_sess); + + return async_exchange_begin(devman_client_block_sess); default: - return -1; - } + return NULL; + } +} + +/** Start an async exchange on the devman session. + * + * @param iface Device manager interface to choose + * + * @return New exchange. + * + */ +async_exch_t *devman_exchange_begin(devman_interface_t iface) +{ + switch (iface) { + case DEVMAN_DRIVER: + fibril_mutex_lock(&devman_driver_mutex); + + if (devman_driver_sess == NULL) + devman_driver_sess = + service_connect(EXCHANGE_SERIALIZE, SERVICE_DEVMAN, + DEVMAN_DRIVER, 0); + + fibril_mutex_unlock(&devman_driver_mutex); + + if (devman_driver_sess == NULL) + return NULL; + + return async_exchange_begin(devman_driver_sess); + case DEVMAN_CLIENT: + fibril_mutex_lock(&devman_client_mutex); + + if (devman_client_sess == NULL) + devman_client_sess = + service_connect(EXCHANGE_SERIALIZE, SERVICE_DEVMAN, + DEVMAN_CLIENT, 0); + + fibril_mutex_unlock(&devman_client_mutex); + + if (devman_client_sess == NULL) + return NULL; + + return async_exchange_begin(devman_client_sess); + default: + return NULL; + } +} + +/** Finish an async exchange on the devman session. + * + * @param exch Exchange to be finished. + * + */ +void devman_exchange_end(async_exch_t *exch) +{ + async_exchange_end(exch); } @@ -96,120 +178,98 @@ int devman_driver_register(const char *name, async_client_conn_t conn) { - int phone = devman_get_phone(DEVMAN_DRIVER, IPC_FLAG_BLOCKING); - - if (phone < 0) - return phone; - - async_serialize_start(); - - ipc_call_t answer; - aid_t req = async_send_2(phone, DEVMAN_DRIVER_REGISTER, 0, 0, &answer); - - sysarg_t retval = async_data_write_start(phone, name, str_size(name)); - if (retval != EOK) { - async_wait_for(req, NULL); - async_serialize_end(); - return -1; + async_exch_t *exch = devman_exchange_begin_blocking(DEVMAN_DRIVER); + + ipc_call_t answer; + aid_t req = async_send_2(exch, DEVMAN_DRIVER_REGISTER, 0, 0, &answer); + sysarg_t retval = async_data_write_start(exch, name, str_size(name)); + + devman_exchange_end(exch); + + if (retval != EOK) { + async_wait_for(req, NULL); + return retval; } async_set_client_connection(conn); - async_connect_to_me(phone, 0, 0, 0, NULL); + exch = devman_exchange_begin(DEVMAN_DRIVER); + async_connect_to_me(exch, 0, 0, 0, NULL); + devman_exchange_end(exch); + async_wait_for(req, &retval); - - async_serialize_end(); - return retval; } -static int devman_send_match_id(int phone, match_id_t *match_id) -{ - ipc_call_t answer; - - aid_t req = async_send_1(phone, DEVMAN_ADD_MATCH_ID, match_id->score, - &answer); - int retval = async_data_write_start(phone, match_id->id, - str_size(match_id->id)); - - async_wait_for(req, NULL); - return retval; -} - - -static int devman_send_match_ids(int phone, match_id_list_t *match_ids) -{ +/** Add function to a device. + * + * Request devman to add a new function to the specified device owned by + * this driver task. + * + * @param name Name of the new function + * @param ftype Function type, fun_inner or fun_exposed + * @param match_ids Match IDs (should be empty for fun_exposed) + * @param devh Devman handle of the device + * @param funh Place to store handle of the new function + * + * @return EOK on success or negative error code. + * + */ +int devman_add_function(const char *name, fun_type_t ftype, + match_id_list_t *match_ids, devman_handle_t devh, devman_handle_t *funh) +{ + int match_count = list_count(&match_ids->ids); + async_exch_t *exch = devman_exchange_begin_blocking(DEVMAN_DRIVER); + + ipc_call_t answer; + aid_t req = async_send_3(exch, DEVMAN_ADD_FUNCTION, (sysarg_t) ftype, + devh, match_count, &answer); + sysarg_t retval = async_data_write_start(exch, name, str_size(name)); + if (retval != EOK) { + devman_exchange_end(exch); + async_wait_for(req, NULL); + return retval; + } + + async_wait_for(req, &retval); + if (retval != EOK) { + devman_exchange_end(exch); + + if (funh != NULL) + *funh = -1; + + return retval; + } + + if (funh != NULL) + *funh = (int) IPC_GET_ARG1(answer); + link_t *link = match_ids->ids.next; match_id_t *match_id = NULL; - int ret = EOK; - + while (link != &match_ids->ids) { - match_id = list_get_instance(link, match_id_t, link); - ret = devman_send_match_id(phone, match_id); - if (ret != EOK) { - return ret; + match_id = list_get_instance(link, match_id_t, link); + + ipc_call_t answer; + aid_t req = async_send_1(exch, DEVMAN_ADD_MATCH_ID, + match_id->score, &answer); + retval = async_data_write_start(exch, match_id->id, + str_size(match_id->id)); + if (retval != EOK) { + devman_exchange_end(exch); + async_wait_for(req, NULL); + return retval; } - + + async_wait_for(req, &retval); + if (retval != EOK) { + devman_exchange_end(exch); + return retval; + } + link = link->next; } - - return ret; -} - -/** Add function to a device. - * - * Request devman to add a new function to the specified device owned by - * this driver task. - * - * @param name Name of the new function - * @param ftype Function type, fun_inner or fun_exposed - * @param match_ids Match IDs (should be empty for fun_exposed) - * @param devh Devman handle of the device - * @param funh Place to store handle of the new function - * - * @return EOK on success or negative error code. - */ -int devman_add_function(const char *name, fun_type_t ftype, - match_id_list_t *match_ids, devman_handle_t devh, devman_handle_t *funh) -{ - int phone = devman_get_phone(DEVMAN_DRIVER, IPC_FLAG_BLOCKING); - int fun_handle; - - if (phone < 0) - return phone; - - async_serialize_start(); - - int match_count = list_count(&match_ids->ids); - ipc_call_t answer; - - aid_t req = async_send_3(phone, DEVMAN_ADD_FUNCTION, (sysarg_t) ftype, - devh, match_count, &answer); - - sysarg_t retval = async_data_write_start(phone, name, str_size(name)); - if (retval != EOK) { - async_wait_for(req, NULL); - async_serialize_end(); - return retval; - } - - 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); - else - fun_handle = -1; - - *funh = fun_handle; - - return retval; + + devman_exchange_end(exch); + return EOK; } @@ -217,76 +277,51 @@ const char *class_name) { - int phone = devman_get_phone(DEVMAN_DRIVER, IPC_FLAG_BLOCKING); - - if (phone < 0) - return phone; - - async_serialize_start(); - ipc_call_t answer; - aid_t req = async_send_1(phone, DEVMAN_ADD_DEVICE_TO_CLASS, + async_exch_t *exch = devman_exchange_begin_blocking(DEVMAN_DRIVER); + + ipc_call_t answer; + aid_t req = async_send_1(exch, DEVMAN_ADD_DEVICE_TO_CLASS, devman_handle, &answer); - - sysarg_t retval = async_data_write_start(phone, class_name, + sysarg_t retval = async_data_write_start(exch, class_name, str_size(class_name)); - if (retval != EOK) { - async_wait_for(req, NULL); - async_serialize_end(); + + devman_exchange_end(exch); + + if (retval != EOK) { + async_wait_for(req, NULL); return retval; } async_wait_for(req, &retval); - async_serialize_end(); - return retval; } -void devman_hangup_phone(devman_interface_t iface) -{ - switch (iface) { - case DEVMAN_DRIVER: - if (devman_phone_driver >= 0) { - async_hangup(devman_phone_driver); - devman_phone_driver = -1; - } - break; - case DEVMAN_CLIENT: - if (devman_phone_client >= 0) { - async_hangup(devman_phone_client); - devman_phone_client = -1; - } - break; - default: - break; - } -} - -int devman_device_connect(devman_handle_t handle, unsigned int flags) -{ - int phone; - - if (flags & IPC_FLAG_BLOCKING) { - phone = async_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAN, - DEVMAN_CONNECT_TO_DEVICE, handle); - } else { - phone = async_connect_me_to(PHONE_NS, SERVICE_DEVMAN, - DEVMAN_CONNECT_TO_DEVICE, handle); - } - - return phone; -} - -int devman_parent_device_connect(devman_handle_t handle, unsigned int flags) -{ - int phone; - - if (flags & IPC_FLAG_BLOCKING) { - phone = async_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAN, - DEVMAN_CONNECT_TO_PARENTS_DEVICE, handle); - } else { - phone = async_connect_me_to(PHONE_NS, SERVICE_DEVMAN, - DEVMAN_CONNECT_TO_PARENTS_DEVICE, handle); - } - - return phone; +async_sess_t *devman_device_connect(exch_mgmt_t mgmt, devman_handle_t handle, + unsigned int flags) +{ + async_sess_t *sess; + + if (flags & IPC_FLAG_BLOCKING) + sess = service_connect_blocking(mgmt, SERVICE_DEVMAN, + DEVMAN_CONNECT_TO_DEVICE, handle); + else + sess = service_connect(mgmt, SERVICE_DEVMAN, + DEVMAN_CONNECT_TO_DEVICE, handle); + + return sess; +} + +async_sess_t *devman_parent_device_connect(exch_mgmt_t mgmt, + devman_handle_t handle, unsigned int flags) +{ + async_sess_t *sess; + + if (flags & IPC_FLAG_BLOCKING) + sess = service_connect_blocking(mgmt, SERVICE_DEVMAN, + DEVMAN_CONNECT_TO_PARENTS_DEVICE, handle); + else + sess = service_connect(mgmt, SERVICE_DEVMAN, + DEVMAN_CONNECT_TO_PARENTS_DEVICE, handle); + + return sess; } @@ -294,30 +329,33 @@ 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_2(phone, DEVMAN_DEVICE_GET_HANDLE, flags, 0, + async_exch_t *exch; + + if (flags & IPC_FLAG_BLOCKING) + exch = devman_exchange_begin_blocking(DEVMAN_CLIENT); + else { + exch = devman_exchange_begin(DEVMAN_CLIENT); + if (exch == NULL) + return errno; + } + + ipc_call_t answer; + aid_t req = async_send_2(exch, DEVMAN_DEVICE_GET_HANDLE, flags, 0, &answer); - - sysarg_t retval = async_data_write_start(phone, pathname, + sysarg_t retval = async_data_write_start(exch, pathname, str_size(pathname)); - if (retval != EOK) { - async_wait_for(req, NULL); - async_serialize_end(); + + devman_exchange_end(exch); + + if (retval != EOK) { + async_wait_for(req, NULL); return retval; } async_wait_for(req, &retval); - - async_serialize_end(); if (retval != EOK) { if (handle != NULL) *handle = (devman_handle_t) -1; + return retval; } @@ -332,46 +370,99 @@ 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, + async_exch_t *exch; + + if (flags & IPC_FLAG_BLOCKING) + exch = devman_exchange_begin_blocking(DEVMAN_CLIENT); + else { + exch = devman_exchange_begin(DEVMAN_CLIENT); + if (exch == NULL) + return errno; + } + + ipc_call_t answer; + aid_t req = async_send_1(exch, DEVMAN_DEVICE_GET_HANDLE_BY_CLASS, flags, &answer); - - sysarg_t retval = async_data_write_start(phone, classname, + sysarg_t retval = async_data_write_start(exch, classname, str_size(classname)); - if (retval != EOK) { - async_wait_for(req, NULL); - async_serialize_end(); - return retval; - } - retval = async_data_write_start(phone, devname, + + if (retval != EOK) { + devman_exchange_end(exch); + async_wait_for(req, NULL); + return retval; + } + + retval = async_data_write_start(exch, devname, str_size(devname)); - if (retval != EOK) { - async_wait_for(req, NULL); - async_serialize_end(); - return retval; - } - + + devman_exchange_end(exch); + + if (retval != EOK) { + async_wait_for(req, NULL); + return retval; + } + async_wait_for(req, &retval); - - async_serialize_end(); - + if (retval != EOK) { if (handle != NULL) *handle = (devman_handle_t) -1; - return retval; - } - + + return retval; + } + if (handle != NULL) *handle = (devman_handle_t) IPC_GET_ARG1(answer); - + return retval; } +int devman_get_device_path(devman_handle_t handle, char *path, size_t path_size) +{ + async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT); + if (exch == NULL) + return errno; + + ipc_call_t answer; + aid_t req = async_send_1(exch, DEVMAN_DEVICE_GET_DEVICE_PATH, + handle, &answer); + + ipc_call_t data_request_call; + aid_t data_request = async_data_read(exch, path, path_size, + &data_request_call); + + devman_exchange_end(exch); + + if (data_request == 0) { + async_wait_for(req, NULL); + return ENOMEM; + } + + sysarg_t data_request_rc; + async_wait_for(data_request, &data_request_rc); + + sysarg_t opening_request_rc; + async_wait_for(req, &opening_request_rc); + + if (data_request_rc != EOK) { + /* Prefer the return code of the opening request. */ + if (opening_request_rc != EOK) + return (int) opening_request_rc; + else + return (int) data_request_rc; + } + + if (opening_request_rc != EOK) + return (int) opening_request_rc; + + /* To be on the safe-side. */ + path[path_size - 1] = 0; + size_t transferred_size = IPC_GET_ARG2(data_request_call); + if (transferred_size >= path_size) + return ELIMIT; + + /* Terminate the string (trailing 0 not send over IPC). */ + path[transferred_size] = 0; + return EOK; +} /** @} Index: uspace/lib/c/generic/devman_obsolete.c =================================================================== --- uspace/lib/c/generic/devman_obsolete.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/c/generic/devman_obsolete.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,149 @@ +/* + * Copyright (c) 2007 Josef Cejka + * Copyright (c) 2009 Jiri Svoboda + * Copyright (c) 2010 Lenka Trochtova + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libc + * @{ + */ +/** @file + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static int devman_phone_driver = -1; +static int devman_phone_client = -1; + +static FIBRIL_MUTEX_INITIALIZE(devman_phone_mutex); + +int devman_obsolete_get_phone(devman_interface_t iface, unsigned int flags) +{ + switch (iface) { + case DEVMAN_DRIVER: + fibril_mutex_lock(&devman_phone_mutex); + if (devman_phone_driver >= 0) { + fibril_mutex_unlock(&devman_phone_mutex); + return devman_phone_driver; + } + + if (flags & IPC_FLAG_BLOCKING) + devman_phone_driver = service_obsolete_connect_blocking( + SERVICE_DEVMAN, DEVMAN_DRIVER, 0); + else + devman_phone_driver = service_obsolete_connect(SERVICE_DEVMAN, + DEVMAN_DRIVER, 0); + + fibril_mutex_unlock(&devman_phone_mutex); + return devman_phone_driver; + case DEVMAN_CLIENT: + fibril_mutex_lock(&devman_phone_mutex); + if (devman_phone_client >= 0) { + fibril_mutex_unlock(&devman_phone_mutex); + return devman_phone_client; + } + + if (flags & IPC_FLAG_BLOCKING) { + devman_phone_client = service_obsolete_connect_blocking( + SERVICE_DEVMAN, DEVMAN_CLIENT, 0); + } else { + devman_phone_client = service_obsolete_connect(SERVICE_DEVMAN, + DEVMAN_CLIENT, 0); + } + + fibril_mutex_unlock(&devman_phone_mutex); + return devman_phone_client; + default: + return -1; + } +} + +void devman_obsolete_hangup_phone(devman_interface_t iface) +{ + switch (iface) { + case DEVMAN_DRIVER: + if (devman_phone_driver >= 0) { + async_obsolete_hangup(devman_phone_driver); + devman_phone_driver = -1; + } + break; + case DEVMAN_CLIENT: + if (devman_phone_client >= 0) { + async_obsolete_hangup(devman_phone_client); + devman_phone_client = -1; + } + break; + default: + break; + } +} + +int devman_obsolete_device_connect(devman_handle_t handle, unsigned int flags) +{ + int phone; + + if (flags & IPC_FLAG_BLOCKING) { + phone = service_obsolete_connect_blocking(SERVICE_DEVMAN, + DEVMAN_CONNECT_TO_DEVICE, handle); + } else { + phone = service_obsolete_connect(SERVICE_DEVMAN, + DEVMAN_CONNECT_TO_DEVICE, handle); + } + + return phone; +} + +int devman_obsolete_parent_device_connect(devman_handle_t handle, unsigned int flags) +{ + int phone; + + if (flags & IPC_FLAG_BLOCKING) { + phone = service_obsolete_connect_blocking(SERVICE_DEVMAN, + DEVMAN_CONNECT_TO_PARENTS_DEVICE, handle); + } else { + phone = service_obsolete_connect(SERVICE_DEVMAN, + DEVMAN_CONNECT_TO_PARENTS_DEVICE, handle); + } + + return phone; +} + +/** @} + */ Index: uspace/lib/c/generic/devmap.c =================================================================== --- uspace/lib/c/generic/devmap.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/generic/devmap.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -30,7 +30,8 @@ #include #include -#include +#include #include #include +#include #include #include @@ -38,58 +39,131 @@ #include -static int devmap_phone_driver = -1; -static int devmap_phone_client = -1; - -/** Get phone to device mapper task. */ -int devmap_get_phone(devmap_interface_t iface, unsigned int flags) +static FIBRIL_MUTEX_INITIALIZE(devmap_driver_block_mutex); +static FIBRIL_MUTEX_INITIALIZE(devmap_client_block_mutex); + +static FIBRIL_MUTEX_INITIALIZE(devmap_driver_mutex); +static FIBRIL_MUTEX_INITIALIZE(devmap_client_mutex); + +static async_sess_t *devmap_driver_block_sess = NULL; +static async_sess_t *devmap_client_block_sess = NULL; + +static async_sess_t *devmap_driver_sess = NULL; +static async_sess_t *devmap_client_sess = NULL; + +static void clone_session(fibril_mutex_t *mtx, async_sess_t *src, + async_sess_t **dst) +{ + fibril_mutex_lock(mtx); + + if ((*dst == NULL) && (src != NULL)) + *dst = src; + + fibril_mutex_unlock(mtx); +} + +/** Start an async exchange on the devmap session (blocking). + * + * @param iface Device mapper interface to choose + * + * @return New exchange. + * + */ +async_exch_t *devmap_exchange_begin_blocking(devmap_interface_t iface) { switch (iface) { case DEVMAP_DRIVER: - if (devmap_phone_driver >= 0) - return devmap_phone_driver; - - if (flags & IPC_FLAG_BLOCKING) - devmap_phone_driver = service_connect_blocking(SERVICE_DEVMAP, - DEVMAP_DRIVER, 0); - else - devmap_phone_driver = service_connect(SERVICE_DEVMAP, - DEVMAP_DRIVER, 0); - - return devmap_phone_driver; + fibril_mutex_lock(&devmap_driver_block_mutex); + + while (devmap_driver_block_sess == NULL) { + clone_session(&devmap_driver_mutex, devmap_driver_sess, + &devmap_driver_block_sess); + + if (devmap_driver_block_sess == NULL) + devmap_driver_block_sess = + service_connect_blocking(EXCHANGE_SERIALIZE, + SERVICE_DEVMAP, DEVMAP_DRIVER, 0); + } + + fibril_mutex_unlock(&devmap_driver_block_mutex); + + clone_session(&devmap_driver_mutex, devmap_driver_block_sess, + &devmap_driver_sess); + + return async_exchange_begin(devmap_driver_block_sess); case DEVMAP_CLIENT: - if (devmap_phone_client >= 0) - return devmap_phone_client; - - if (flags & IPC_FLAG_BLOCKING) - devmap_phone_client = service_connect_blocking(SERVICE_DEVMAP, - DEVMAP_CLIENT, 0); - else - devmap_phone_client = service_connect(SERVICE_DEVMAP, - DEVMAP_CLIENT, 0); - - return devmap_phone_client; + fibril_mutex_lock(&devmap_client_block_mutex); + + while (devmap_client_block_sess == NULL) { + clone_session(&devmap_client_mutex, devmap_client_sess, + &devmap_client_block_sess); + + if (devmap_client_block_sess == NULL) + devmap_client_block_sess = + service_connect_blocking(EXCHANGE_SERIALIZE, + SERVICE_DEVMAP, DEVMAP_CLIENT, 0); + } + + fibril_mutex_unlock(&devmap_client_block_mutex); + + clone_session(&devmap_client_mutex, devmap_client_block_sess, + &devmap_client_sess); + + return async_exchange_begin(devmap_client_block_sess); default: - return -1; - } -} - -void devmap_hangup_phone(devmap_interface_t iface) + return NULL; + } +} + +/** Start an async exchange on the devmap session. + * + * @param iface Device mapper interface to choose + * + * @return New exchange. + * + */ +async_exch_t *devmap_exchange_begin(devmap_interface_t iface) { switch (iface) { case DEVMAP_DRIVER: - if (devmap_phone_driver >= 0) { - async_hangup(devmap_phone_driver); - devmap_phone_driver = -1; - } - break; + fibril_mutex_lock(&devmap_driver_mutex); + + if (devmap_driver_sess == NULL) + devmap_driver_sess = + service_connect(EXCHANGE_SERIALIZE, SERVICE_DEVMAP, + DEVMAP_DRIVER, 0); + + fibril_mutex_unlock(&devmap_driver_mutex); + + if (devmap_driver_sess == NULL) + return NULL; + + return async_exchange_begin(devmap_driver_sess); case DEVMAP_CLIENT: - if (devmap_phone_client >= 0) { - async_hangup(devmap_phone_client); - devmap_phone_client = -1; - } - break; + fibril_mutex_lock(&devmap_client_mutex); + + if (devmap_client_sess == NULL) + devmap_client_sess = + service_connect(EXCHANGE_SERIALIZE, SERVICE_DEVMAP, + DEVMAP_CLIENT, 0); + + fibril_mutex_unlock(&devmap_client_mutex); + + if (devmap_client_sess == NULL) + return NULL; + + return async_exchange_begin(devmap_client_sess); default: - break; - } + return NULL; + } +} + +/** Finish an async exchange on the devmap session. + * + * @param exch Exchange to be finished. + * + */ +void devmap_exchange_end(async_exch_t *exch) +{ + async_exchange_end(exch); } @@ -97,28 +171,24 @@ int devmap_driver_register(const char *name, async_client_conn_t conn) { - int phone = devmap_get_phone(DEVMAP_DRIVER, IPC_FLAG_BLOCKING); - - if (phone < 0) - return phone; - - async_serialize_start(); + async_exch_t *exch = devmap_exchange_begin_blocking(DEVMAP_DRIVER); ipc_call_t answer; - aid_t req = async_send_2(phone, DEVMAP_DRIVER_REGISTER, 0, 0, &answer); - - sysarg_t retval = async_data_write_start(phone, name, str_size(name)); + aid_t req = async_send_2(exch, DEVMAP_DRIVER_REGISTER, 0, 0, &answer); + sysarg_t retval = async_data_write_start(exch, name, str_size(name)); + + devmap_exchange_end(exch); + if (retval != EOK) { async_wait_for(req, NULL); - async_serialize_end(); - return -1; + return retval; } async_set_client_connection(conn); - async_connect_to_me(phone, 0, 0, 0, NULL); + exch = devmap_exchange_begin(DEVMAP_DRIVER); + async_connect_to_me(exch, 0, 0, 0, NULL); + devmap_exchange_end(exch); + async_wait_for(req, &retval); - - async_serialize_end(); - return retval; } @@ -129,10 +199,11 @@ * If not 0, the first argument is the interface and the second argument * is the devmap handle of the device. + * * When the interface is zero (default), the first argument is directly * the handle (to ensure backward compatibility). * - * @param fqdn Fully qualified device name. - * @param[out] handle Handle to the created instance of device. - * @param interface Interface when forwarding. + * @param fqdn Fully qualified device name. + * @param[out] handle Handle to the created instance of device. + * @param interface Interface when forwarding. * */ @@ -140,29 +211,24 @@ devmap_handle_t *handle, sysarg_t interface) { - int phone = devmap_get_phone(DEVMAP_DRIVER, IPC_FLAG_BLOCKING); - - if (phone < 0) - return phone; - - async_serialize_start(); + async_exch_t *exch = devmap_exchange_begin_blocking(DEVMAP_DRIVER); ipc_call_t answer; - aid_t req = async_send_2(phone, DEVMAP_DEVICE_REGISTER, interface, 0, + aid_t req = async_send_2(exch, DEVMAP_DEVICE_REGISTER, interface, 0, &answer); - - sysarg_t retval = async_data_write_start(phone, fqdn, str_size(fqdn)); + sysarg_t retval = async_data_write_start(exch, fqdn, str_size(fqdn)); + + devmap_exchange_end(exch); + 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 = -1; + return retval; } @@ -176,6 +242,6 @@ /** Register new device. * - * @param fqdn Fully qualified device name. - * @param handle Output: Handle to the created instance of device. + * @param fqdn Fully qualified device name. + * @param handle Output: Handle to the created instance of device. * */ @@ -185,32 +251,35 @@ } - -int devmap_device_get_handle(const char *fqdn, devmap_handle_t *handle, unsigned int flags) -{ - int phone = devmap_get_phone(DEVMAP_CLIENT, flags); - - if (phone < 0) - return phone; - - async_serialize_start(); +int devmap_device_get_handle(const char *fqdn, devmap_handle_t *handle, + unsigned int flags) +{ + async_exch_t *exch; + + if (flags & IPC_FLAG_BLOCKING) + exch = devmap_exchange_begin_blocking(DEVMAP_CLIENT); + else { + exch = devmap_exchange_begin(DEVMAP_CLIENT); + if (exch == NULL) + return errno; + } ipc_call_t answer; - aid_t req = async_send_2(phone, DEVMAP_DEVICE_GET_HANDLE, flags, 0, + aid_t req = async_send_2(exch, DEVMAP_DEVICE_GET_HANDLE, flags, 0, &answer); - - sysarg_t retval = async_data_write_start(phone, fqdn, str_size(fqdn)); + sysarg_t retval = async_data_write_start(exch, fqdn, str_size(fqdn)); + + devmap_exchange_end(exch); + 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 = (devmap_handle_t) -1; + return retval; } @@ -222,31 +291,35 @@ } -int devmap_namespace_get_handle(const char *name, devmap_handle_t *handle, unsigned int flags) -{ - int phone = devmap_get_phone(DEVMAP_CLIENT, flags); - - if (phone < 0) - return phone; - - async_serialize_start(); +int devmap_namespace_get_handle(const char *name, devmap_handle_t *handle, + unsigned int flags) +{ + async_exch_t *exch; + + if (flags & IPC_FLAG_BLOCKING) + exch = devmap_exchange_begin_blocking(DEVMAP_CLIENT); + else { + exch = devmap_exchange_begin(DEVMAP_CLIENT); + if (exch == NULL) + return errno; + } ipc_call_t answer; - aid_t req = async_send_2(phone, DEVMAP_NAMESPACE_GET_HANDLE, flags, 0, + aid_t req = async_send_2(exch, DEVMAP_NAMESPACE_GET_HANDLE, flags, 0, &answer); - - sysarg_t retval = async_data_write_start(phone, name, str_size(name)); + sysarg_t retval = async_data_write_start(exch, name, str_size(name)); + + devmap_exchange_end(exch); + 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 = (devmap_handle_t) -1; + return retval; } @@ -260,11 +333,11 @@ devmap_handle_type_t devmap_handle_probe(devmap_handle_t handle) { - int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING); - - if (phone < 0) - return phone; + async_exch_t *exch = devmap_exchange_begin_blocking(DEVMAP_CLIENT); sysarg_t type; - int retval = async_req_1_1(phone, DEVMAP_HANDLE_PROBE, handle, &type); + int retval = async_req_1_1(exch, DEVMAP_HANDLE_PROBE, handle, &type); + + devmap_exchange_end(exch); + if (retval != EOK) return DEV_HANDLE_NONE; @@ -273,28 +346,28 @@ } -int devmap_device_connect(devmap_handle_t handle, unsigned int flags) -{ - int phone; - - if (flags & IPC_FLAG_BLOCKING) { - phone = async_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAP, +async_sess_t *devmap_device_connect(exch_mgmt_t mgmt, devmap_handle_t handle, + unsigned int flags) +{ + async_sess_t *sess; + + if (flags & IPC_FLAG_BLOCKING) + sess = service_connect_blocking(mgmt, SERVICE_DEVMAP, DEVMAP_CONNECT_TO_DEVICE, handle); - } else { - phone = async_connect_me_to(PHONE_NS, SERVICE_DEVMAP, + else + sess = service_connect(mgmt, SERVICE_DEVMAP, DEVMAP_CONNECT_TO_DEVICE, handle); - } - - return phone; + + return sess; } int devmap_null_create(void) { - int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING); - - if (phone < 0) - return -1; + async_exch_t *exch = devmap_exchange_begin_blocking(DEVMAP_CLIENT); sysarg_t null_id; - int retval = async_req_0_1(phone, DEVMAP_NULL_CREATE, &null_id); + int retval = async_req_0_1(exch, DEVMAP_NULL_CREATE, &null_id); + + devmap_exchange_end(exch); + if (retval != EOK) return -1; @@ -305,16 +378,13 @@ void devmap_null_destroy(int null_id) { - int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING); - - if (phone < 0) - return; - - async_req_1_0(phone, DEVMAP_NULL_DESTROY, (sysarg_t) null_id); -} - -static size_t devmap_count_namespaces_internal(int phone) + async_exch_t *exch = devmap_exchange_begin_blocking(DEVMAP_CLIENT); + async_req_1_0(exch, DEVMAP_NULL_DESTROY, (sysarg_t) null_id); + devmap_exchange_end(exch); +} + +static size_t devmap_count_namespaces_internal(async_exch_t *exch) { sysarg_t count; - int retval = async_req_0_1(phone, DEVMAP_GET_NAMESPACE_COUNT, &count); + int retval = async_req_0_1(exch, DEVMAP_GET_NAMESPACE_COUNT, &count); if (retval != EOK) return 0; @@ -323,8 +393,10 @@ } -static size_t devmap_count_devices_internal(int phone, devmap_handle_t ns_handle) +static size_t devmap_count_devices_internal(async_exch_t *exch, + devmap_handle_t ns_handle) { sysarg_t count; - int retval = async_req_1_1(phone, DEVMAP_GET_DEVICE_COUNT, ns_handle, &count); + int retval = async_req_1_1(exch, DEVMAP_GET_DEVICE_COUNT, ns_handle, + &count); if (retval != EOK) return 0; @@ -335,32 +407,28 @@ size_t devmap_count_namespaces(void) { - int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING); - - if (phone < 0) - return 0; - - return devmap_count_namespaces_internal(phone); + async_exch_t *exch = devmap_exchange_begin_blocking(DEVMAP_CLIENT); + size_t size = devmap_count_namespaces_internal(exch); + devmap_exchange_end(exch); + + return size; } size_t devmap_count_devices(devmap_handle_t ns_handle) { - int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING); - - if (phone < 0) - return 0; - - return devmap_count_devices_internal(phone, ns_handle); + async_exch_t *exch = devmap_exchange_begin_blocking(DEVMAP_CLIENT); + size_t size = devmap_count_devices_internal(exch, ns_handle); + devmap_exchange_end(exch); + + return size; } size_t devmap_get_namespaces(dev_desc_t **data) { - int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING); - - if (phone < 0) - return 0; - /* Loop until namespaces read succesful */ while (true) { - size_t count = devmap_count_namespaces_internal(phone); + async_exch_t *exch = devmap_exchange_begin_blocking(DEVMAP_CLIENT); + size_t count = devmap_count_namespaces_internal(exch); + devmap_exchange_end(exch); + if (count == 0) return 0; @@ -370,10 +438,12 @@ return 0; - async_serialize_start(); + exch = devmap_exchange_begin(DEVMAP_CLIENT); ipc_call_t answer; - aid_t req = async_send_0(phone, DEVMAP_GET_NAMESPACES, &answer); - - int rc = async_data_read_start(phone, devs, count * sizeof(dev_desc_t)); + aid_t req = async_send_0(exch, DEVMAP_GET_NAMESPACES, &answer); + int rc = async_data_read_start(exch, devs, count * sizeof(dev_desc_t)); + + devmap_exchange_end(exch); + if (rc == EOVERFLOW) { /* @@ -381,5 +451,4 @@ * the last call of DEVMAP_DEVICE_GET_NAMESPACE_COUNT */ - async_serialize_end(); free(devs); continue; @@ -388,5 +457,4 @@ if (rc != EOK) { async_wait_for(req, NULL); - async_serialize_end(); free(devs); return 0; @@ -395,5 +463,4 @@ sysarg_t retval; async_wait_for(req, &retval); - async_serialize_end(); if (retval != EOK) @@ -407,12 +474,10 @@ size_t devmap_get_devices(devmap_handle_t ns_handle, dev_desc_t **data) { - int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING); - - if (phone < 0) - return 0; - - /* Loop until namespaces read succesful */ + /* Loop until devices read succesful */ while (true) { - size_t count = devmap_count_devices_internal(phone, ns_handle); + async_exch_t *exch = devmap_exchange_begin_blocking(DEVMAP_CLIENT); + size_t count = devmap_count_devices_internal(exch, ns_handle); + devmap_exchange_end(exch); + if (count == 0) return 0; @@ -422,10 +487,12 @@ return 0; - async_serialize_start(); + exch = devmap_exchange_begin(DEVMAP_CLIENT); ipc_call_t answer; - aid_t req = async_send_1(phone, DEVMAP_GET_DEVICES, ns_handle, &answer); - - int rc = async_data_read_start(phone, devs, count * sizeof(dev_desc_t)); + aid_t req = async_send_1(exch, DEVMAP_GET_DEVICES, ns_handle, &answer); + int rc = async_data_read_start(exch, devs, count * sizeof(dev_desc_t)); + + devmap_exchange_end(exch); + if (rc == EOVERFLOW) { /* @@ -433,5 +500,4 @@ * the last call of DEVMAP_DEVICE_GET_DEVICE_COUNT */ - async_serialize_end(); free(devs); continue; @@ -440,5 +506,4 @@ if (rc != EOK) { async_wait_for(req, NULL); - async_serialize_end(); free(devs); return 0; @@ -447,5 +512,4 @@ sysarg_t retval; async_wait_for(req, &retval); - async_serialize_end(); if (retval != EOK) Index: uspace/lib/c/generic/devmap_obsolete.c =================================================================== --- uspace/lib/c/generic/devmap_obsolete.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/c/generic/devmap_obsolete.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,114 @@ +/* + * Copyright (c) 2007 Josef Cejka + * Copyright (c) 2009 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static int devmap_phone_driver = -1; +static int devmap_phone_client = -1; + +/** Get phone to device mapper task. */ +int devmap_obsolete_get_phone(devmap_interface_t iface, unsigned int flags) +{ + switch (iface) { + case DEVMAP_DRIVER: + if (devmap_phone_driver >= 0) + return devmap_phone_driver; + + if (flags & IPC_FLAG_BLOCKING) + devmap_phone_driver = service_obsolete_connect_blocking(SERVICE_DEVMAP, + DEVMAP_DRIVER, 0); + else + devmap_phone_driver = service_obsolete_connect(SERVICE_DEVMAP, + DEVMAP_DRIVER, 0); + + return devmap_phone_driver; + case DEVMAP_CLIENT: + if (devmap_phone_client >= 0) + return devmap_phone_client; + + if (flags & IPC_FLAG_BLOCKING) + devmap_phone_client = service_obsolete_connect_blocking(SERVICE_DEVMAP, + DEVMAP_CLIENT, 0); + else + devmap_phone_client = service_obsolete_connect(SERVICE_DEVMAP, + DEVMAP_CLIENT, 0); + + return devmap_phone_client; + default: + return -1; + } +} + +void devmap_obsolete_hangup_phone(devmap_interface_t iface) +{ + switch (iface) { + case DEVMAP_DRIVER: + if (devmap_phone_driver >= 0) { + async_obsolete_hangup(devmap_phone_driver); + devmap_phone_driver = -1; + } + break; + case DEVMAP_CLIENT: + if (devmap_phone_client >= 0) { + async_obsolete_hangup(devmap_phone_client); + devmap_phone_client = -1; + } + break; + default: + break; + } +} + +int devmap_obsolete_device_connect(devmap_handle_t handle, unsigned int flags) +{ + int phone; + + if (flags & IPC_FLAG_BLOCKING) { + phone = service_obsolete_connect_blocking(SERVICE_DEVMAP, + DEVMAP_CONNECT_TO_DEVICE, handle); + } else { + phone = service_obsolete_connect(SERVICE_DEVMAP, + DEVMAP_CONNECT_TO_DEVICE, handle); + } + + return phone; +} + +/** @} + */ Index: uspace/lib/c/generic/io/console.c =================================================================== --- uspace/lib/c/generic/io/console.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/generic/io/console.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -37,73 +37,204 @@ #include #include +#include +#include +#include +#include #include #include -void console_clear(int phone) -{ - async_msg_0(phone, CONSOLE_CLEAR); -} - -int console_get_size(int phone, sysarg_t *cols, sysarg_t *rows) -{ - return async_req_0_2(phone, CONSOLE_GET_SIZE, cols, rows); -} - -void console_set_style(int phone, uint8_t style) -{ - async_msg_1(phone, CONSOLE_SET_STYLE, style); -} - -void console_set_color(int phone, uint8_t fg_color, uint8_t bg_color, +console_ctrl_t *console_init(FILE *ifile, FILE *ofile) +{ + console_ctrl_t *ctrl = malloc(sizeof(console_ctrl_t)); + if (!ctrl) + return NULL; + + ctrl->input_sess = fsession(EXCHANGE_SERIALIZE, ifile); + if (!ctrl->input_sess) { + free(ctrl); + return NULL; + } + + ctrl->output_sess = fsession(EXCHANGE_SERIALIZE, ofile); + if (!ctrl->output_sess) { + free(ctrl); + return NULL; + } + + ctrl->input = ifile; + ctrl->output = ofile; + ctrl->input_aid = 0; + + return ctrl; +} + +void console_done(console_ctrl_t *ctrl) +{ + free(ctrl); +} + +bool console_kcon(void) +{ +#if 0 + return __SYSCALL0(SYS_DEBUG_ACTIVATE_CONSOLE); +#endif + + return false; +} + +void console_flush(console_ctrl_t *ctrl) +{ + fflush(ctrl->output); +} + +void console_clear(console_ctrl_t *ctrl) +{ + async_exch_t *exch = async_exchange_begin(ctrl->output_sess); + async_msg_0(exch, CONSOLE_CLEAR); + async_exchange_end(exch); +} + +int console_get_size(console_ctrl_t *ctrl, sysarg_t *cols, sysarg_t *rows) +{ + async_exch_t *exch = async_exchange_begin(ctrl->output_sess); + int rc = async_req_0_2(exch, CONSOLE_GET_SIZE, cols, rows); + async_exchange_end(exch); + + return rc; +} + +void console_set_style(console_ctrl_t *ctrl, uint8_t style) +{ + async_exch_t *exch = async_exchange_begin(ctrl->output_sess); + async_msg_1(exch, CONSOLE_SET_STYLE, style); + async_exchange_end(exch); +} + +void console_set_color(console_ctrl_t *ctrl, uint8_t fg_color, uint8_t bg_color, uint8_t flags) { - async_msg_3(phone, CONSOLE_SET_COLOR, fg_color, bg_color, flags); -} - -void console_set_rgb_color(int phone, uint32_t fg_color, uint32_t bg_color) -{ - async_msg_2(phone, CONSOLE_SET_RGB_COLOR, fg_color, bg_color); -} - -void console_cursor_visibility(int phone, bool show) -{ - async_msg_1(phone, CONSOLE_CURSOR_VISIBILITY, (show != false)); -} - -int console_get_color_cap(int phone, sysarg_t *ccap) -{ - return async_req_0_1(phone, CONSOLE_GET_COLOR_CAP, ccap); -} - -void console_kcon_enable(int phone) -{ - async_msg_0(phone, CONSOLE_KCON_ENABLE); -} - -int console_get_pos(int phone, sysarg_t *col, sysarg_t *row) -{ - return async_req_0_2(phone, CONSOLE_GET_POS, col, row); -} - -void console_set_pos(int phone, sysarg_t col, sysarg_t row) -{ - async_msg_2(phone, CONSOLE_GOTO, col, row); -} - -bool console_get_event(int phone, console_event_t *event) -{ - sysarg_t type; - sysarg_t key; - sysarg_t mods; - sysarg_t c; - - int rc = async_req_0_4(phone, CONSOLE_GET_EVENT, &type, &key, &mods, &c); - if (rc < 0) + async_exch_t *exch = async_exchange_begin(ctrl->output_sess); + async_msg_3(exch, CONSOLE_SET_COLOR, fg_color, bg_color, flags); + async_exchange_end(exch); +} + +void console_set_rgb_color(console_ctrl_t *ctrl, uint32_t fg_color, + uint32_t bg_color) +{ + async_exch_t *exch = async_exchange_begin(ctrl->output_sess); + async_msg_2(exch, CONSOLE_SET_RGB_COLOR, fg_color, bg_color); + async_exchange_end(exch); +} + +void console_cursor_visibility(console_ctrl_t *ctrl, bool show) +{ + async_exch_t *exch = async_exchange_begin(ctrl->output_sess); + async_msg_1(exch, CONSOLE_CURSOR_VISIBILITY, (show != false)); + async_exchange_end(exch); +} + +int console_get_color_cap(console_ctrl_t *ctrl, sysarg_t *ccap) +{ + async_exch_t *exch = async_exchange_begin(ctrl->output_sess); + int rc = async_req_0_1(exch, CONSOLE_GET_COLOR_CAP, ccap); + async_exchange_end(exch); + + return rc; +} + +int console_get_pos(console_ctrl_t *ctrl, sysarg_t *col, sysarg_t *row) +{ + async_exch_t *exch = async_exchange_begin(ctrl->output_sess); + int rc = async_req_0_2(exch, CONSOLE_GET_POS, col, row); + async_exchange_end(exch); + + return rc; +} + +void console_set_pos(console_ctrl_t *ctrl, sysarg_t col, sysarg_t row) +{ + async_exch_t *exch = async_exchange_begin(ctrl->output_sess); + async_msg_2(exch, CONSOLE_GOTO, col, row); + async_exchange_end(exch); +} + +bool console_get_kbd_event(console_ctrl_t *ctrl, kbd_event_t *event) +{ + if (ctrl->input_aid == 0) { + sysarg_t type; + sysarg_t key; + sysarg_t mods; + sysarg_t c; + + async_exch_t *exch = async_exchange_begin(ctrl->input_sess); + int rc = async_req_0_4(exch, CONSOLE_GET_EVENT, &type, &key, &mods, &c); + async_exchange_end(exch); + + if (rc != EOK) { + errno = rc; + return false; + } + + event->type = type; + event->key = key; + event->mods = mods; + event->c = c; + } else { + sysarg_t retval; + async_wait_for(ctrl->input_aid, &retval); + + ctrl->input_aid = 0; + + if (retval != EOK) { + errno = (int) retval; + return false; + } + + event->type = IPC_GET_ARG1(ctrl->input_call); + event->key = IPC_GET_ARG2(ctrl->input_call); + event->mods = IPC_GET_ARG3(ctrl->input_call); + event->c = IPC_GET_ARG4(ctrl->input_call); + } + + return true; +} + +bool console_get_kbd_event_timeout(console_ctrl_t *ctrl, kbd_event_t *event, + suseconds_t *timeout) +{ + struct timeval t0; + gettimeofday(&t0, NULL); + + if (ctrl->input_aid == 0) { + async_exch_t *exch = async_exchange_begin(ctrl->input_sess); + ctrl->input_aid = async_send_0(exch, CONSOLE_GET_EVENT, + &ctrl->input_call); + async_exchange_end(exch); + } + + sysarg_t retval; + int rc = async_wait_timeout(ctrl->input_aid, &retval, *timeout); + if (rc != EOK) { + *timeout = 0; + errno = rc; return false; - - event->type = type; - event->key = key; - event->mods = mods; - event->c = c; + } + + ctrl->input_aid = 0; + + if (retval != EOK) { + errno = (int) retval; + return false; + } + + event->type = IPC_GET_ARG1(ctrl->input_call); + event->key = IPC_GET_ARG2(ctrl->input_call); + event->mods = IPC_GET_ARG3(ctrl->input_call); + event->c = IPC_GET_ARG4(ctrl->input_call); + + /* Update timeout */ + struct timeval t1; + gettimeofday(&t1, NULL); + *timeout -= tv_sub(&t1, &t0); return true; Index: uspace/lib/c/generic/io/io.c =================================================================== --- uspace/lib/c/generic/io/io.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/generic/io/io.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -44,7 +44,9 @@ #include #include +#include #include #include #include "../private/io.h" +#include "../private/stdio.h" static void _ffillbuf(FILE *stream); @@ -56,5 +58,5 @@ .eof = true, .klog = false, - .phone = -1, + .sess = NULL, .btype = _IONBF, .buf = NULL, @@ -70,5 +72,5 @@ .eof = false, .klog = true, - .phone = -1, + .sess = NULL, .btype = _IOLBF, .buf = NULL, @@ -84,5 +86,5 @@ .eof = false, .klog = true, - .phone = -1, + .sess = NULL, .btype = _IONBF, .buf = NULL, @@ -255,5 +257,5 @@ stream->eof = false; stream->klog = false; - stream->phone = -1; + stream->sess = NULL; stream->need_sync = false; _setvbuf(stream); @@ -277,5 +279,5 @@ stream->eof = false; stream->klog = false; - stream->phone = -1; + stream->sess = NULL; stream->need_sync = false; _setvbuf(stream); @@ -309,5 +311,5 @@ stream->eof = false; stream->klog = false; - stream->phone = -1; + stream->sess = NULL; stream->need_sync = false; _setvbuf(stream); @@ -324,6 +326,6 @@ fflush(stream); - if (stream->phone >= 0) - async_hangup(stream->phone); + if (stream->sess != NULL) + async_hangup(stream->sess); if (stream->fd >= 0) @@ -732,5 +734,5 @@ } - if (stream->fd >= 0 && stream->need_sync) { + if ((stream->fd >= 0) && (stream->need_sync)) { /** * Better than syncing always, but probably still not the @@ -770,14 +772,14 @@ } -int fphone(FILE *stream) +async_sess_t *fsession(exch_mgmt_t mgmt, FILE *stream) { if (stream->fd >= 0) { - if (stream->phone < 0) - stream->phone = fd_phone(stream->fd); - - return stream->phone; - } - - return -1; + if (stream->sess == NULL) + stream->sess = fd_session(mgmt, stream->fd); + + return stream->sess; + } + + return NULL; } Index: uspace/lib/c/generic/ipc.c =================================================================== --- uspace/lib/c/generic/ipc.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/generic/ipc.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -632,4 +632,22 @@ } +/** Request cloned connection. + * + * @param phoneid Phone handle used for contacting the other side. + * + * @return Cloned phone handle on success or a negative error code. + * + */ +int ipc_connect_me(int phoneid) +{ + sysarg_t newphid; + int res = ipc_call_sync_0_5(phoneid, IPC_M_CONNECT_ME, NULL, NULL, + NULL, NULL, &newphid); + if (res) + return res; + + return newphid; +} + /** Request new connection. * Index: uspace/lib/c/generic/ipc/ns.c =================================================================== --- uspace/lib/c/generic/ipc/ns.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ (revision ) @@ -1,54 +1,0 @@ -/* - * Copyright (c) 2011 Martin Decky - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup libc - * @{ - */ -/** @file - */ - -#include -#include - -int service_register(sysarg_t service) -{ - return async_connect_to_me(PHONE_NS, service, 0, 0, NULL); -} - -int service_connect(sysarg_t service, sysarg_t arg2, sysarg_t arg3) -{ - return async_connect_me_to(PHONE_NS, service, arg2, arg3); -} - -int service_connect_blocking(sysarg_t service, sysarg_t arg2, sysarg_t arg3) -{ - return async_connect_me_to_blocking(PHONE_NS, service, arg2, arg3); -} - -/** @} - */ Index: uspace/lib/c/generic/l18n/langs.c =================================================================== --- uspace/lib/c/generic/l18n/langs.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/c/generic/l18n/langs.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libc + * @{ + */ +/** @file + * Language and locale ids. + */ + +#include +#include +#include + +#define UNKNOWN_LOCALE_LEN 64 + +static fibril_local char unknown_locale[UNKNOWN_LOCALE_LEN]; + +/** Get string representation of a given locale. + * + * @param locale The locale. + * @return Name of the locale. + */ +const char *str_l18_win_locale(l18_win_locales_t locale) +{ + /* + * Static array with names might be better but it would be + * way too big. + */ + switch (locale) { + case L18N_WIN_LOCALE_AFRIKAANS: + return "Afrikaans"; + case L18N_WIN_LOCALE_CZECH: + return "Czech"; + case L18N_WIN_LOCALE_ENGLISH_UNITED_STATES: + return "English (US)"; + case L18N_WIN_LOCALE_SLOVAK: + return "Slovak"; + case L18N_WIN_LOCALE_SPANISH_TRADITIONAL: + return "Spanish (traditional)"; + case L18N_WIN_LOCALE_ZULU: + return "Zulu"; + } + + snprintf(unknown_locale, UNKNOWN_LOCALE_LEN, "Unknown locale 0x%04d", + (int) locale); + return unknown_locale; +} + +/** @} + */ Index: uspace/lib/c/generic/libc.c =================================================================== --- uspace/lib/c/generic/libc.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/generic/libc.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -49,5 +49,4 @@ #include "private/libc.h" #include "private/async.h" -#include "private/async_sess.h" #include "private/malloc.h" #include "private/io.h" @@ -64,5 +63,4 @@ __malloc_init(); __async_init(); - __async_sess_init(); fibril_t *fibril = fibril_setup(); Index: uspace/lib/c/generic/loader.c =================================================================== --- uspace/lib/c/generic/loader.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/generic/loader.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -35,5 +35,5 @@ #include #include -#include +#include #include #include @@ -44,4 +44,5 @@ #include #include +#include "private/loader.h" /** Connect to a new program loader. @@ -63,13 +64,16 @@ loader_t *loader_connect(void) { - int phone_id = service_connect_blocking(SERVICE_LOAD, 0, 0); - if (phone_id < 0) - return NULL; - loader_t *ldr = malloc(sizeof(loader_t)); if (ldr == NULL) return NULL; - ldr->phone_id = phone_id; + async_sess_t *sess = + service_connect_blocking(EXCHANGE_SERIALIZE, SERVICE_LOAD, 0, 0); + if (sess == NULL) { + free(ldr); + return NULL; + } + + ldr->sess = sess; return ldr; } @@ -88,15 +92,19 @@ { /* Get task ID. */ - ipc_call_t answer; - aid_t req = async_send_0(ldr->phone_id, LOADER_GET_TASKID, &answer); - int rc = async_data_read_start(ldr->phone_id, task_id, sizeof(task_id_t)); - if (rc != EOK) { - async_wait_for(req, NULL); - return rc; - } - - sysarg_t retval; - async_wait_for(req, &retval); - return (int) retval; + async_exch_t *exch = async_exchange_begin(ldr->sess); + + ipc_call_t answer; + aid_t req = async_send_0(exch, LOADER_GET_TASKID, &answer); + sysarg_t rc = async_data_read_start(exch, task_id, sizeof(task_id_t)); + + async_exchange_end(exch); + + if (rc != EOK) { + async_wait_for(req, NULL); + return (int) rc; + } + + async_wait_for(req, &rc); + return (int) rc; } @@ -112,26 +120,29 @@ int loader_set_cwd(loader_t *ldr) { - char *cwd; - size_t len; - - cwd = (char *) malloc(MAX_PATH_LEN + 1); + char *cwd = (char *) malloc(MAX_PATH_LEN + 1); if (!cwd) return ENOMEM; + if (!getcwd(cwd, MAX_PATH_LEN + 1)) - str_cpy(cwd, MAX_PATH_LEN + 1, "/"); - len = str_length(cwd); - - ipc_call_t answer; - aid_t req = async_send_0(ldr->phone_id, LOADER_SET_CWD, &answer); - int rc = async_data_write_start(ldr->phone_id, cwd, len); + str_cpy(cwd, MAX_PATH_LEN + 1, "/"); + + size_t len = str_length(cwd); + + async_exch_t *exch = async_exchange_begin(ldr->sess); + + ipc_call_t answer; + aid_t req = async_send_0(exch, LOADER_SET_CWD, &answer); + sysarg_t rc = async_data_write_start(exch, cwd, len); + + async_exchange_end(exch); free(cwd); - if (rc != EOK) { - async_wait_for(req, NULL); - return rc; - } - - sysarg_t retval; - async_wait_for(req, &retval); - return (int) retval; + + if (rc != EOK) { + async_wait_for(req, NULL); + return (int) rc; + } + + async_wait_for(req, &rc); + return (int) rc; } @@ -153,21 +164,23 @@ char *pa = absolutize(path, &pa_len); if (!pa) - return 0; + return ENOMEM; /* Send program pathname */ - ipc_call_t answer; - aid_t req = async_send_0(ldr->phone_id, LOADER_SET_PATHNAME, &answer); - int rc = async_data_write_start(ldr->phone_id, (void *) pa, pa_len); - if (rc != EOK) { - free(pa); - async_wait_for(req, NULL); - return rc; - } - + async_exch_t *exch = async_exchange_begin(ldr->sess); + + ipc_call_t answer; + aid_t req = async_send_0(exch, LOADER_SET_PATHNAME, &answer); + sysarg_t rc = async_data_write_start(exch, (void *) pa, pa_len); + + async_exchange_end(exch); free(pa); - sysarg_t retval; - async_wait_for(req, &retval); - return (int) retval; + if (rc != EOK) { + async_wait_for(req, NULL); + return (int) rc; + } + + async_wait_for(req, &rc); + return (int) rc; } @@ -212,20 +225,21 @@ /* Send serialized arguments to the loader */ - ipc_call_t answer; - aid_t req = async_send_0(ldr->phone_id, LOADER_SET_ARGS, &answer); - sysarg_t rc = async_data_write_start(ldr->phone_id, (void *) arg_buf, buffer_size); - if (rc != EOK) { - async_wait_for(req, NULL); - return rc; - } - - async_wait_for(req, &rc); - if (rc != EOK) - return rc; - - /* Free temporary buffer */ + async_exch_t *exch = async_exchange_begin(ldr->sess); + + ipc_call_t answer; + aid_t req = async_send_0(exch, LOADER_SET_ARGS, &answer); + sysarg_t rc = async_data_write_start(exch, (void *) arg_buf, + buffer_size); + + async_exchange_end(exch); free(arg_buf); - return EOK; + if (rc != EOK) { + async_wait_for(req, NULL); + return (int) rc; + } + + async_wait_for(req, &rc); + return (int) rc; } @@ -266,21 +280,21 @@ /* Send serialized files to the loader */ - ipc_call_t answer; - aid_t req = async_send_0(ldr->phone_id, LOADER_SET_FILES, &answer); - sysarg_t rc = async_data_write_start(ldr->phone_id, (void *) files_buf, + async_exch_t *exch = async_exchange_begin(ldr->sess); + + ipc_call_t answer; + aid_t req = async_send_0(exch, LOADER_SET_FILES, &answer); + sysarg_t rc = async_data_write_start(exch, (void *) files_buf, count * sizeof(fdi_node_t)); - if (rc != EOK) { - async_wait_for(req, NULL); - return rc; - } - - async_wait_for(req, &rc); - if (rc != EOK) - return rc; - - /* Free temporary buffer */ + + async_exchange_end(exch); free(files_buf); - return EOK; + if (rc != EOK) { + async_wait_for(req, NULL); + return (int) rc; + } + + async_wait_for(req, &rc); + return (int) rc; } @@ -297,5 +311,9 @@ int loader_load_program(loader_t *ldr) { - return (int) async_req_0_0(ldr->phone_id, LOADER_LOAD); + async_exch_t *exch = async_exchange_begin(ldr->sess); + int rc = async_req_0_0(exch, LOADER_LOAD); + async_exchange_end(exch); + + return rc; } @@ -306,6 +324,6 @@ * the task and its thread is stopped. * - * After using this function, no further operations must be performed - * on the loader structure. It should be de-allocated using free(). + * After using this function, no further operations can be performed + * on the loader structure and it is deallocated. * * @param ldr Loader connection structure. @@ -316,10 +334,14 @@ int loader_run(loader_t *ldr) { - int rc = async_req_0_0(ldr->phone_id, LOADER_RUN); + async_exch_t *exch = async_exchange_begin(ldr->sess); + int rc = async_req_0_0(exch, LOADER_RUN); + async_exchange_end(exch); + if (rc != EOK) return rc; - async_hangup(ldr->phone_id); - ldr->phone_id = 0; + async_hangup(ldr->sess); + free(ldr); + return EOK; } @@ -327,7 +349,7 @@ /** Cancel the loader session. * - * Tells the loader not to load any program and terminate. - * After using this function, no further operations must be performed - * on the loader structure. It should be de-allocated using free(). + * Tell the loader not to load any program and terminate. + * After using this function, no further operations can be performed + * on the loader structure and it is deallocated. * * @param ldr Loader connection structure. @@ -338,6 +360,6 @@ void loader_abort(loader_t *ldr) { - async_hangup(ldr->phone_id); - ldr->phone_id = 0; + async_hangup(ldr->sess); + free(ldr); } Index: uspace/lib/c/generic/net/icmp_api.c =================================================================== --- uspace/lib/c/generic/net/icmp_api.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/generic/net/icmp_api.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -42,4 +42,5 @@ #include #include +#include #include #include @@ -83,9 +84,9 @@ return EINVAL; - message_id = async_send_5(icmp_phone, NET_ICMP_ECHO, size, timeout, ttl, + message_id = async_obsolete_send_5(icmp_phone, NET_ICMP_ECHO, size, timeout, ttl, tos, (sysarg_t) dont_fragment, NULL); /* Send the address */ - async_data_write_start(icmp_phone, addr, (size_t) addrlen); + async_obsolete_data_write_start(icmp_phone, addr, (size_t) addrlen); async_wait_for(message_id, &result); Index: uspace/lib/c/generic/net/modules.c =================================================================== --- uspace/lib/c/generic/net/modules.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/generic/net/modules.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -40,4 +40,5 @@ #include +#include #include #include @@ -45,7 +46,9 @@ #include #include +#include +#include /** The time between connect requests in microseconds. */ -#define MODULE_WAIT_TIME (10 * 1000) +#define MODULE_WAIT_TIME (10 * 1000) /** Answer a call. @@ -138,7 +141,7 @@ if (phone >= 0) { /* Request the bidirectional connection */ - int rc = async_connect_to_me(phone, arg1, arg2, arg3, client_receiver); + int rc = async_obsolete_connect_to_me(phone, arg1, arg2, arg3, client_receiver); if (rc != EOK) { - async_hangup(phone); + async_obsolete_hangup(phone); return rc; } @@ -172,8 +175,8 @@ /* If no timeout is set */ if (timeout <= 0) - return async_connect_me_to_blocking(PHONE_NS, need, 0, 0); - + return service_obsolete_connect_blocking(need, 0, 0); + while (true) { - phone = async_connect_me_to(PHONE_NS, need, 0, 0); + phone = service_obsolete_connect(need, 0, 0); if ((phone >= 0) || (phone != ENOENT)) return phone; Index: uspace/lib/c/generic/net/socket_client.c =================================================================== --- uspace/lib/c/generic/net/socket_client.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/generic/net/socket_client.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -39,4 +39,5 @@ #include #include +#include #include #include @@ -472,5 +473,5 @@ } - rc = (int) async_req_3_3(phone, NET_SOCKET, socket_id, 0, service, NULL, + rc = (int) async_obsolete_req_3_3(phone, NET_SOCKET, socket_id, 0, service, NULL, &fragment_size, &header_size); if (rc != EOK) { @@ -493,5 +494,5 @@ dyn_fifo_destroy(&socket->accepted); free(socket); - async_msg_3(phone, NET_SOCKET_CLOSE, (sysarg_t) socket_id, 0, + async_obsolete_msg_3(phone, NET_SOCKET_CLOSE, (sysarg_t) socket_id, 0, service); return rc; @@ -538,8 +539,8 @@ /* Request the message */ - message_id = async_send_3(socket->phone, message, + message_id = async_obsolete_send_3(socket->phone, message, (sysarg_t) socket->socket_id, arg2, socket->service, NULL); /* Send the address */ - async_data_write_start(socket->phone, data, datalength); + async_obsolete_data_write_start(socket->phone, data, datalength); fibril_rwlock_read_unlock(&socket_globals.lock); @@ -598,5 +599,5 @@ /* Request listen backlog change */ - result = (int) async_req_3_0(socket->phone, NET_SOCKET_LISTEN, + result = (int) async_obsolete_req_3_0(socket->phone, NET_SOCKET_LISTEN, (sysarg_t) socket->socket_id, (sysarg_t) backlog, socket->service); @@ -681,10 +682,10 @@ /* Request accept */ - message_id = async_send_5(socket->phone, NET_SOCKET_ACCEPT, + message_id = async_obsolete_send_5(socket->phone, NET_SOCKET_ACCEPT, (sysarg_t) socket->socket_id, 0, socket->service, 0, new_socket->socket_id, &answer); /* Read address */ - async_data_read_start(socket->phone, cliaddr, *addrlen); + async_obsolete_data_read_start(socket->phone, cliaddr, *addrlen); fibril_rwlock_write_unlock(&socket_globals.lock); async_wait_for(message_id, &ipc_result); @@ -780,5 +781,5 @@ /* Request close */ - rc = (int) async_req_3_0(socket->phone, NET_SOCKET_CLOSE, + rc = (int) async_obsolete_req_3_0(socket->phone, NET_SOCKET_CLOSE, (sysarg_t) socket->socket_id, 0, socket->service); if (rc != EOK) { @@ -853,5 +854,5 @@ /* Request send */ - message_id = async_send_5(socket->phone, message, + message_id = async_obsolete_send_5(socket->phone, message, (sysarg_t) socket->socket_id, (fragments == 1 ? datalength : socket->data_fragment_size), @@ -860,11 +861,11 @@ /* Send the address if given */ if (!toaddr || - (async_data_write_start(socket->phone, toaddr, addrlen) == EOK)) { + (async_obsolete_data_write_start(socket->phone, toaddr, addrlen) == EOK)) { if (fragments == 1) { /* Send all if only one fragment */ - async_data_write_start(socket->phone, data, datalength); + async_obsolete_data_write_start(socket->phone, data, datalength); } else { /* Send the first fragment */ - async_data_write_start(socket->phone, data, + async_obsolete_data_write_start(socket->phone, data, socket->data_fragment_size - socket->header_size); data = ((const uint8_t *) data) + @@ -873,5 +874,5 @@ /* Send the middle fragments */ while (--fragments > 1) { - async_data_write_start(socket->phone, data, + async_obsolete_data_write_start(socket->phone, data, socket->data_fragment_size); data = ((const uint8_t *) data) + @@ -880,5 +881,5 @@ /* Send the last fragment */ - async_data_write_start(socket->phone, data, + async_obsolete_data_write_start(socket->phone, data, (datalength + socket->header_size) % socket->data_fragment_size); @@ -1038,5 +1039,5 @@ /* Request packet data */ - message_id = async_send_4(socket->phone, message, + message_id = async_obsolete_send_4(socket->phone, message, (sysarg_t) socket->socket_id, 0, socket->service, (sysarg_t) flags, &answer); @@ -1044,8 +1045,8 @@ /* Read the address if desired */ if(!fromaddr || - (async_data_read_start(socket->phone, fromaddr, + (async_obsolete_data_read_start(socket->phone, fromaddr, *addrlen) == EOK)) { /* Read the fragment lengths */ - if (async_data_read_start(socket->phone, lengths, + if (async_obsolete_data_read_start(socket->phone, lengths, sizeof(int) * (fragments + 1)) == EOK) { if (lengths[fragments] <= datalength) { @@ -1054,5 +1055,5 @@ for (index = 0; index < fragments; ++index) { - async_data_read_start( + async_obsolete_data_read_start( socket->phone, data, lengths[index]); @@ -1067,5 +1068,5 @@ } else { /* fragments == 1 */ /* Request packet data */ - message_id = async_send_4(socket->phone, message, + message_id = async_obsolete_send_4(socket->phone, message, (sysarg_t) socket->socket_id, 0, socket->service, (sysarg_t) flags, &answer); @@ -1073,8 +1074,8 @@ /* Read the address if desired */ if (!fromaddr || - (async_data_read_start(socket->phone, fromaddr, + (async_obsolete_data_read_start(socket->phone, fromaddr, *addrlen) == EOK)) { /* Read all if only one fragment */ - async_data_read_start(socket->phone, data, datalength); + async_obsolete_data_read_start(socket->phone, data, datalength); } } @@ -1190,13 +1191,13 @@ /* Request option value */ - message_id = async_send_3(socket->phone, NET_SOCKET_GETSOCKOPT, + message_id = async_obsolete_send_3(socket->phone, NET_SOCKET_GETSOCKOPT, (sysarg_t) socket->socket_id, (sysarg_t) optname, socket->service, NULL); /* Read the length */ - if (async_data_read_start(socket->phone, optlen, + if (async_obsolete_data_read_start(socket->phone, optlen, sizeof(*optlen)) == EOK) { /* Read the value */ - async_data_read_start(socket->phone, value, *optlen); + async_obsolete_data_read_start(socket->phone, value, *optlen); } Index: uspace/lib/c/generic/ns.c =================================================================== --- uspace/lib/c/generic/ns.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/c/generic/ns.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,91 @@ +/* + * Copyright (c) 2011 Martin Decky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libc + * @{ + */ +/** @file + */ + +#include +#include +#include +#include +#include "private/ns.h" + +int service_register(sysarg_t service) +{ + async_exch_t *exch = async_exchange_begin(session_ns); + int rc = async_connect_to_me(exch, service, 0, 0, NULL); + async_exchange_end(exch); + + return rc; +} + +async_sess_t *service_connect(exch_mgmt_t mgmt, sysarg_t service, sysarg_t arg2, + sysarg_t arg3) +{ + async_exch_t *exch = async_exchange_begin(session_ns); + async_sess_t *sess = + async_connect_me_to(mgmt, exch, service, arg2, arg3); + async_exchange_end(exch); + + return sess; +} + +async_sess_t *service_connect_blocking(exch_mgmt_t mgmt, sysarg_t service, + sysarg_t arg2, sysarg_t arg3) +{ + async_exch_t *exch = async_exchange_begin(session_ns); + async_sess_t *sess = + async_connect_me_to_blocking(mgmt, exch, service, arg2, arg3); + async_exchange_end(exch); + + return sess; +} + +int ns_ping(void) +{ + async_exch_t *exch = async_exchange_begin(session_ns); + int rc = async_req_0_0(exch, NS_PING); + async_exchange_end(exch); + + return rc; +} + +int ns_intro(task_id_t id) +{ + async_exch_t *exch = async_exchange_begin(session_ns); + int rc = async_req_2_0(exch, NS_ID_INTRO, LOWER32(id), UPPER32(id)); + async_exchange_end(exch); + + return rc; +} + +/** @} + */ Index: uspace/lib/c/generic/ns_obsolete.c =================================================================== --- uspace/lib/c/generic/ns_obsolete.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/c/generic/ns_obsolete.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2011 Martin Decky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libc + * @{ + */ +/** @file + */ + +#include +#include +#include +#include + +int service_obsolete_connect(sysarg_t service, sysarg_t arg2, sysarg_t arg3) +{ + return async_obsolete_connect_me_to(PHONE_NS, service, arg2, arg3); +} + +int service_obsolete_connect_blocking(sysarg_t service, sysarg_t arg2, sysarg_t arg3) +{ + return async_obsolete_connect_me_to_blocking(PHONE_NS, service, arg2, arg3); +} + +/** @} + */ Index: uspace/lib/c/generic/private/async.h =================================================================== --- uspace/lib/c/generic/private/async.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/generic/private/async.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -79,6 +79,20 @@ } awaiter_t; +/** Message data */ +typedef struct { + awaiter_t wdata; + + /** If reply was received. */ + bool done; + + /** Pointer to where the answer data is stored. */ + ipc_call_t *dataptr; + + sysarg_t retval; +} amsg_t; + extern void __async_init(void); extern void async_insert_timeout(awaiter_t *); +extern void reply_received(void *, int, ipc_call_t *); #endif Index: uspace/lib/c/generic/private/async_sess.h =================================================================== --- uspace/lib/c/generic/private/async_sess.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ (revision ) @@ -1,43 +1,0 @@ -/* - * Copyright (c) 2011 Martin Decky - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup libc - * @{ - */ -/** @file - */ - -#ifndef LIBC_PRIVATE_ASYNC_SESS_H_ -#define LIBC_PRIVATE_ASYNC_SESS_H_ - -extern void __async_sess_init(void); - -#endif - -/** @} - */ Index: uspace/lib/c/generic/private/loader.h =================================================================== --- uspace/lib/c/generic/private/loader.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/c/generic/private/loader.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2011 Martin Decky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libc + * @{ + */ +/** @file + */ + +#ifndef LIBC_PRIVATE_LOADER_H_ +#define LIBC_PRIVATE_LOADER_H_ + +#include + +/** Abstraction of a loader connection */ +struct loader { + /** Session to the loader. */ + async_sess_t *sess; +}; + +#endif + +/** @} + */ Index: uspace/lib/c/generic/private/ns.h =================================================================== --- uspace/lib/c/generic/private/ns.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/c/generic/private/ns.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2011 Martin Decky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libc + * @{ + */ +/** @file + */ + +#ifndef LIBC_PRIVATE_NS_H_ +#define LIBC_PRIVATE_NS_H_ + +#include + +extern async_sess_t *session_ns; + +#endif + +/** @} + */ Index: uspace/lib/c/generic/private/stdio.h =================================================================== --- uspace/lib/c/generic/private/stdio.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/c/generic/private/stdio.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,89 @@ +/* + * Copyright (c) 2011 Martin Decky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libc + * @{ + */ +/** @file + */ + +#ifndef LIBC_PRIVATE_STDIO_H_ +#define LIBC_PRIVATE_STDIO_H_ + +#include +#include +#include + +struct _IO_FILE { + /** Linked list pointer. */ + link_t link; + + /** Underlying file descriptor. */ + int fd; + + /** Error indicator. */ + int error; + + /** End-of-file indicator. */ + int eof; + + /** Klog indicator */ + int klog; + + /** Session to the file provider */ + async_sess_t *sess; + + /** + * Non-zero if the stream needs sync on fflush(). XXX change + * console semantics so that sync is not needed. + */ + int need_sync; + + /** Buffering type */ + enum _buffer_type btype; + + /** Buffer */ + uint8_t *buf; + + /** Buffer size */ + size_t buf_size; + + /** Buffer state */ + enum _buffer_state buf_state; + + /** Buffer I/O pointer */ + uint8_t *buf_head; + + /** Points to end of occupied space when in read mode. */ + uint8_t *buf_tail; +}; + +#endif + +/** @} + */ Index: uspace/lib/c/generic/str_error.c =================================================================== --- uspace/lib/c/generic/str_error.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/generic/str_error.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -33,4 +33,5 @@ */ +#include #include #include @@ -63,10 +64,25 @@ static fibril_local char noerr[NOERR_LEN]; -const char *str_error(const int errno) +const char *str_error(const int e) { - if ((errno <= 0) && (errno >= MIN_ERRNO)) - return err_desc[-errno]; + if ((e <= 0) && (e >= MIN_ERRNO)) + return err_desc[-e]; - snprintf(noerr, NOERR_LEN, "Unkown error code %d", errno); + /* Ad hoc descriptions of error codes interesting for USB. */ + // FIXME: integrate these as first-class error values + switch (e) { + case EBADCHECKSUM: + return "Bad checksum"; + case ESTALL: + return "Operation stalled"; + case EAGAIN: + return "Resource temporarily unavailable"; + case EEMPTY: + return "Resource is empty"; + default: + break; + } + + snprintf(noerr, NOERR_LEN, "Unkown error code %d", e); return noerr; } Index: uspace/lib/c/generic/task.c =================================================================== --- uspace/lib/c/generic/task.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/generic/task.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -35,7 +35,4 @@ #include -#include -#include -#include #include #include @@ -43,5 +40,10 @@ #include #include +#include #include +#include +#include +#include +#include "private/ns.h" task_id_t task_get_id(void) @@ -68,4 +70,6 @@ int task_set_name(const char *name) { + assert(name); + return __SYSCALL2(SYS_TASK_SET_NAME, (sysarg_t) name, str_size(name)); } @@ -88,23 +92,21 @@ * loader API. Arguments are passed as a null-terminated array of strings. * - * @param id If not NULL, the ID of the task is stored here on success. - * @param path Pathname of the binary to execute. - * @param argv Command-line arguments. - * - * @return Zero on success or negative error code. + * @param id If not NULL, the ID of the task is stored here on success. + * @param path Pathname of the binary to execute. + * @param argv Command-line arguments. + * + * @return Zero on success or negative error code. + * */ int task_spawnv(task_id_t *id, const char *path, const char *const args[]) { - loader_t *ldr; - task_id_t task_id; - int rc; - /* Connect to a program loader. */ - ldr = loader_connect(); + loader_t *ldr = loader_connect(); if (ldr == NULL) return EREFUSED; /* Get task ID. */ - rc = loader_get_task_id(ldr, &task_id); + task_id_t task_id; + int rc = loader_get_task_id(ldr, &task_id); if (rc != EOK) goto error; @@ -163,6 +165,4 @@ /* Success */ - free(ldr); - if (id != NULL) *id = task_id; @@ -173,5 +173,4 @@ /* Error exit */ loader_abort(ldr); - free(ldr); return rc; } @@ -182,19 +181,20 @@ * loader API. Arguments are passed as a null-terminated list of arguments. * - * @param id If not NULL, the ID of the task is stored here on success. - * @param path Pathname of the binary to execute. - * @param ... Command-line arguments. - * - * @return Zero on success or negative error code. + * @param id If not NULL, the ID of the task is stored here on success. + * @param path Pathname of the binary to execute. + * @param ... Command-line arguments. + * + * @return Zero on success or negative error code. + * */ int task_spawnl(task_id_t *task_id, const char *path, ...) { + /* Count the number of arguments. */ + va_list ap; - int rc, cnt; const char *arg; const char **arglist; - - /* Count the number of arguments. */ - cnt = 0; + int cnt = 0; + va_start(ap, path); do { @@ -203,10 +203,10 @@ } while (arg != NULL); va_end(ap); - + /* Allocate argument list. */ arglist = malloc(cnt * sizeof(const char *)); if (arglist == NULL) return ENOMEM; - + /* Fill in arguments. */ cnt = 0; @@ -217,8 +217,8 @@ } while (arg != NULL); va_end(ap); - + /* Spawn task. */ - rc = task_spawnv(task_id, path, arglist); - + int rc = task_spawnv(task_id, path, arglist); + /* Free argument list. */ free(arglist); @@ -228,12 +228,16 @@ int task_wait(task_id_t id, task_exit_t *texit, int *retval) { + assert(texit); + assert(retval); + + async_exch_t *exch = async_exchange_begin(session_ns); sysarg_t te, rv; - int rc; - - rc = (int) async_req_2_2(PHONE_NS, NS_TASK_WAIT, LOWER32(id), + int rc = (int) async_req_2_2(exch, NS_TASK_WAIT, LOWER32(id), UPPER32(id), &te, &rv); + async_exchange_end(exch); + *texit = te; *retval = rv; - + return rc; } @@ -241,5 +245,9 @@ int task_retval(int val) { - return (int) async_req_1_0(PHONE_NS, NS_RETVAL, val); + async_exch_t *exch = async_exchange_begin(session_ns); + int rc = (int) async_req_1_0(exch, NS_RETVAL, val); + async_exchange_end(exch); + + return rc; } Index: uspace/lib/c/generic/time.c =================================================================== --- uspace/lib/c/generic/time.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/generic/time.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -207,4 +207,10 @@ } +void udelay(useconds_t time) +{ + (void) __SYSCALL1(SYS_THREAD_UDELAY, (sysarg_t) time); +} + + /** Wait unconditionally for specified number of seconds * Index: uspace/lib/c/generic/udebug.c =================================================================== --- uspace/lib/c/generic/udebug.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/generic/udebug.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -35,102 +35,108 @@ #include #include +#include #include -int udebug_begin(int phoneid) +int udebug_begin(async_sess_t *sess) { - return async_req_1_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_BEGIN); + async_exch_t *exch = async_exchange_begin(sess); + return async_req_1_0(exch, IPC_M_DEBUG, UDEBUG_M_BEGIN); } -int udebug_end(int phoneid) +int udebug_end(async_sess_t *sess) { - return async_req_1_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_END); + async_exch_t *exch = async_exchange_begin(sess); + return async_req_1_0(exch, IPC_M_DEBUG, UDEBUG_M_END); } -int udebug_set_evmask(int phoneid, udebug_evmask_t mask) +int udebug_set_evmask(async_sess_t *sess, udebug_evmask_t mask) { - return async_req_2_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_SET_EVMASK, - mask); + async_exch_t *exch = async_exchange_begin(sess); + return async_req_2_0(exch, IPC_M_DEBUG, UDEBUG_M_SET_EVMASK, mask); } -int udebug_thread_read(int phoneid, void *buffer, size_t n, - size_t *copied, size_t *needed) +int udebug_thread_read(async_sess_t *sess, void *buffer, size_t n, + size_t *copied, size_t *needed) { sysarg_t a_copied, a_needed; - int rc; - - rc = async_req_3_3(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_THREAD_READ, - (sysarg_t)buffer, n, NULL, &a_copied, &a_needed); - - *copied = (size_t)a_copied; - *needed = (size_t)a_needed; - + + async_exch_t *exch = async_exchange_begin(sess); + int rc = async_req_3_3(exch, IPC_M_DEBUG, UDEBUG_M_THREAD_READ, + (sysarg_t) buffer, n, NULL, &a_copied, &a_needed); + + *copied = (size_t) a_copied; + *needed = (size_t) a_needed; + return rc; } -int udebug_name_read(int phoneid, void *buffer, size_t n, - size_t *copied, size_t *needed) +int udebug_name_read(async_sess_t *sess, void *buffer, size_t n, + size_t *copied, size_t *needed) { sysarg_t a_copied, a_needed; - int rc; - - rc = async_req_3_3(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_NAME_READ, - (sysarg_t)buffer, n, NULL, &a_copied, &a_needed); - - *copied = (size_t)a_copied; - *needed = (size_t)a_needed; - + + async_exch_t *exch = async_exchange_begin(sess); + int rc = async_req_3_3(exch, IPC_M_DEBUG, UDEBUG_M_NAME_READ, + (sysarg_t) buffer, n, NULL, &a_copied, &a_needed); + + *copied = (size_t) a_copied; + *needed = (size_t) a_needed; + return rc; } -int udebug_areas_read(int phoneid, void *buffer, size_t n, - size_t *copied, size_t *needed) +int udebug_areas_read(async_sess_t *sess, void *buffer, size_t n, + size_t *copied, size_t *needed) { sysarg_t a_copied, a_needed; - int rc; - - rc = async_req_3_3(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_AREAS_READ, - (sysarg_t)buffer, n, NULL, &a_copied, &a_needed); - - *copied = (size_t)a_copied; - *needed = (size_t)a_needed; - + + async_exch_t *exch = async_exchange_begin(sess); + int rc = async_req_3_3(exch, IPC_M_DEBUG, UDEBUG_M_AREAS_READ, + (sysarg_t) buffer, n, NULL, &a_copied, &a_needed); + + *copied = (size_t) a_copied; + *needed = (size_t) a_needed; + return rc; } -int udebug_mem_read(int phoneid, void *buffer, uintptr_t addr, size_t n) +int udebug_mem_read(async_sess_t *sess, void *buffer, uintptr_t addr, size_t n) { - return async_req_4_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_MEM_READ, - (sysarg_t)buffer, addr, n); + async_exch_t *exch = async_exchange_begin(sess); + return async_req_4_0(exch, IPC_M_DEBUG, UDEBUG_M_MEM_READ, + (sysarg_t) buffer, addr, n); } -int udebug_args_read(int phoneid, thash_t tid, sysarg_t *buffer) +int udebug_args_read(async_sess_t *sess, thash_t tid, sysarg_t *buffer) { - return async_req_3_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_ARGS_READ, - tid, (sysarg_t)buffer); + async_exch_t *exch = async_exchange_begin(sess); + return async_req_3_0(exch, IPC_M_DEBUG, UDEBUG_M_ARGS_READ, + tid, (sysarg_t) buffer); } -int udebug_regs_read(int phoneid, thash_t tid, void *buffer) +int udebug_regs_read(async_sess_t *sess, thash_t tid, void *buffer) { - return async_req_3_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_REGS_READ, - tid, (sysarg_t)buffer); + async_exch_t *exch = async_exchange_begin(sess); + return async_req_3_0(exch, IPC_M_DEBUG, UDEBUG_M_REGS_READ, + tid, (sysarg_t) buffer); } -int udebug_go(int phoneid, thash_t tid, udebug_event_t *ev_type, +int udebug_go(async_sess_t *sess, thash_t tid, udebug_event_t *ev_type, sysarg_t *val0, sysarg_t *val1) { sysarg_t a_ev_type; - int rc; - - rc = async_req_2_3(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_GO, + + async_exch_t *exch = async_exchange_begin(sess); + int rc = async_req_2_3(exch, IPC_M_DEBUG, UDEBUG_M_GO, tid, &a_ev_type, val0, val1); - + *ev_type = a_ev_type; return rc; } -int udebug_stop(int phoneid, thash_t tid) +int udebug_stop(async_sess_t *sess, thash_t tid) { - return async_req_2_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_STOP, - tid); + async_exch_t *exch = async_exchange_begin(sess); + return async_req_2_0(exch, IPC_M_DEBUG, UDEBUG_M_STOP, tid); } Index: uspace/lib/c/generic/vfs/vfs.c =================================================================== --- uspace/lib/c/generic/vfs/vfs.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/generic/vfs/vfs.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -33,6 +33,7 @@ */ +#include #include -#include +#include #include #include @@ -44,5 +45,5 @@ #include #include -#include +#include #include #include @@ -54,8 +55,6 @@ #include -static async_sess_t vfs_session; - -static FIBRIL_MUTEX_INITIALIZE(vfs_phone_mutex); -static int vfs_phone = -1; +static FIBRIL_MUTEX_INITIALIZE(vfs_mutex); +static async_sess_t *vfs_sess = NULL; static FIBRIL_MUTEX_INITIALIZE(cwd_mutex); @@ -65,9 +64,36 @@ static size_t cwd_size = 0; +/** Start an async exchange on the VFS session. + * + * @return New exchange. + * + */ +static async_exch_t *vfs_exchange_begin(void) +{ + fibril_mutex_lock(&vfs_mutex); + + while (vfs_sess == NULL) + vfs_sess = service_connect_blocking(EXCHANGE_PARALLEL, SERVICE_VFS, + 0, 0); + + fibril_mutex_unlock(&vfs_mutex); + + return async_exchange_begin(vfs_sess); +} + +/** Finish an async exchange on the VFS session. + * + * @param exch Exchange to be finished. + * + */ +static void vfs_exchange_end(async_exch_t *exch) +{ + async_exchange_end(exch); +} + char *absolutize(const char *path, size_t *retlen) { char *ncwd_path; char *ncwd_path_nc; - size_t total_size; fibril_mutex_lock(&cwd_mutex); @@ -78,16 +104,14 @@ return NULL; } - total_size = cwd_size + 1 + size + 1; - ncwd_path_nc = malloc(total_size); + ncwd_path_nc = malloc(cwd_size + 1 + size + 1); if (!ncwd_path_nc) { fibril_mutex_unlock(&cwd_mutex); return NULL; } - str_cpy(ncwd_path_nc, total_size, cwd_path); + str_cpy(ncwd_path_nc, cwd_size + 1 + size + 1, cwd_path); ncwd_path_nc[cwd_size] = '/'; ncwd_path_nc[cwd_size + 1] = '\0'; } else { - total_size = size + 1; - ncwd_path_nc = malloc(total_size); + ncwd_path_nc = malloc(size + 1); if (!ncwd_path_nc) { fibril_mutex_unlock(&cwd_mutex); @@ -96,5 +120,5 @@ ncwd_path_nc[0] = '\0'; } - str_append(ncwd_path_nc, total_size, path); + str_append(ncwd_path_nc, cwd_size + 1 + size + 1, path); ncwd_path = canonify(ncwd_path_nc, retlen); if (!ncwd_path) { @@ -118,36 +142,4 @@ } -/** Connect to VFS service and create session. */ -static void vfs_connect(void) -{ - while (vfs_phone < 0) - vfs_phone = service_connect_blocking(SERVICE_VFS, 0, 0); - - async_session_create(&vfs_session, vfs_phone, 0); -} - -/** Start an async exchange on the VFS session. - * - * @return New phone to be used during the exchange. - */ -static int vfs_exchange_begin(void) -{ - fibril_mutex_lock(&vfs_phone_mutex); - if (vfs_phone < 0) - vfs_connect(); - fibril_mutex_unlock(&vfs_phone_mutex); - - return async_exchange_begin(&vfs_session); -} - -/** End an async exchange on the VFS session. - * - * @param phone Phone used during the exchange. - */ -static void vfs_exchange_end(int phone) -{ - async_exchange_end(&vfs_session, phone); -} - int mount(const char *fs_name, const char *mp, const char *fqdn, const char *opts, unsigned int flags) @@ -186,11 +178,11 @@ } - int vfs_phone = vfs_exchange_begin(); + async_exch_t *exch = vfs_exchange_begin(); sysarg_t rc_orig; - aid_t req = async_send_2(vfs_phone, VFS_IN_MOUNT, devmap_handle, flags, NULL); - sysarg_t rc = async_data_write_start(vfs_phone, (void *) mpa, mpa_size); - if (rc != EOK) { - vfs_exchange_end(vfs_phone); + aid_t req = async_send_2(exch, VFS_IN_MOUNT, devmap_handle, flags, NULL); + sysarg_t rc = async_data_write_start(exch, (void *) mpa, mpa_size); + if (rc != EOK) { + vfs_exchange_end(exch); free(mpa); async_wait_for(req, &rc_orig); @@ -205,7 +197,7 @@ } - rc = async_data_write_start(vfs_phone, (void *) opts, str_size(opts)); - if (rc != EOK) { - vfs_exchange_end(vfs_phone); + rc = async_data_write_start(exch, (void *) opts, str_size(opts)); + if (rc != EOK) { + vfs_exchange_end(exch); free(mpa); async_wait_for(req, &rc_orig); @@ -220,7 +212,7 @@ } - rc = async_data_write_start(vfs_phone, (void *) fs_name, str_size(fs_name)); - if (rc != EOK) { - vfs_exchange_end(vfs_phone); + rc = async_data_write_start(exch, (void *) fs_name, str_size(fs_name)); + if (rc != EOK) { + vfs_exchange_end(exch); free(mpa); async_wait_for(req, &rc_orig); @@ -236,7 +228,7 @@ /* Ask VFS whether it likes fs_name. */ - rc = async_req_0_0(vfs_phone, IPC_M_PING); - if (rc != EOK) { - vfs_exchange_end(vfs_phone); + rc = async_req_0_0(exch, VFS_IN_PING); + if (rc != EOK) { + vfs_exchange_end(exch); free(mpa); async_wait_for(req, &rc_orig); @@ -251,5 +243,5 @@ } - vfs_exchange_end(vfs_phone); + vfs_exchange_end(exch); free(mpa); async_wait_for(req, &rc); @@ -273,10 +265,10 @@ return ENOMEM; - int vfs_phone = vfs_exchange_begin(); - - req = async_send_0(vfs_phone, VFS_IN_UNMOUNT, NULL); - rc = async_data_write_start(vfs_phone, (void *) mpa, mpa_size); - if (rc != EOK) { - vfs_exchange_end(vfs_phone); + async_exch_t *exch = vfs_exchange_begin(); + + req = async_send_0(exch, VFS_IN_UNMOUNT, NULL); + rc = async_data_write_start(exch, (void *) mpa, mpa_size); + if (rc != EOK) { + vfs_exchange_end(exch); free(mpa); async_wait_for(req, &rc_orig); @@ -288,5 +280,5 @@ - vfs_exchange_end(vfs_phone); + vfs_exchange_end(exch); free(mpa); async_wait_for(req, &rc); @@ -297,12 +289,12 @@ static int open_internal(const char *abs, size_t abs_size, int lflag, int oflag) { - int vfs_phone = vfs_exchange_begin(); + async_exch_t *exch = vfs_exchange_begin(); ipc_call_t answer; - aid_t req = async_send_3(vfs_phone, VFS_IN_OPEN, lflag, oflag, 0, &answer); - sysarg_t rc = async_data_write_start(vfs_phone, abs, abs_size); - - if (rc != EOK) { - vfs_exchange_end(vfs_phone); + aid_t req = async_send_3(exch, VFS_IN_OPEN, lflag, oflag, 0, &answer); + sysarg_t rc = async_data_write_start(exch, abs, abs_size); + + if (rc != EOK) { + vfs_exchange_end(exch); sysarg_t rc_orig; @@ -315,5 +307,5 @@ } - vfs_exchange_end(vfs_phone); + vfs_exchange_end(exch); async_wait_for(req, &rc); @@ -339,11 +331,11 @@ int open_node(fdi_node_t *node, int oflag) { - int vfs_phone = vfs_exchange_begin(); + async_exch_t *exch = vfs_exchange_begin(); ipc_call_t answer; - aid_t req = async_send_4(vfs_phone, VFS_IN_OPEN_NODE, node->fs_handle, + aid_t req = async_send_4(exch, VFS_IN_OPEN_NODE, node->fs_handle, node->devmap_handle, node->index, oflag, &answer); - vfs_exchange_end(vfs_phone); + vfs_exchange_end(exch); sysarg_t rc; @@ -360,11 +352,9 @@ sysarg_t rc; - int vfs_phone = vfs_exchange_begin(); - - rc = async_req_1_0(vfs_phone, VFS_IN_CLOSE, fildes); - - vfs_exchange_end(vfs_phone); - - return (int)rc; + async_exch_t *exch = vfs_exchange_begin(); + rc = async_req_1_0(exch, VFS_IN_CLOSE, fildes); + vfs_exchange_end(exch); + + return (int) rc; } @@ -374,12 +364,11 @@ ipc_call_t answer; aid_t req; - - int vfs_phone = vfs_exchange_begin(); - - req = async_send_1(vfs_phone, VFS_IN_READ, fildes, &answer); - rc = async_data_read_start_generic(vfs_phone, (void *) buf, nbyte, - IPC_XF_RESTRICT); - if (rc != EOK) { - vfs_exchange_end(vfs_phone); + + async_exch_t *exch = vfs_exchange_begin(); + + req = async_send_1(exch, VFS_IN_READ, fildes, &answer); + rc = async_data_read_start(exch, (void *)buf, nbyte); + if (rc != EOK) { + vfs_exchange_end(exch); sysarg_t rc_orig; @@ -391,5 +380,5 @@ return (ssize_t) rc_orig; } - vfs_exchange_end(vfs_phone); + vfs_exchange_end(exch); async_wait_for(req, &rc); if (rc == EOK) @@ -404,12 +393,11 @@ ipc_call_t answer; aid_t req; - - int vfs_phone = vfs_exchange_begin(); - - req = async_send_1(vfs_phone, VFS_IN_WRITE, fildes, &answer); - rc = async_data_write_start_generic(vfs_phone, (void *) buf, nbyte, - IPC_XF_RESTRICT); - if (rc != EOK) { - vfs_exchange_end(vfs_phone); + + async_exch_t *exch = vfs_exchange_begin(); + + req = async_send_1(exch, VFS_IN_WRITE, fildes, &answer); + rc = async_data_write_start(exch, (void *)buf, nbyte); + if (rc != EOK) { + vfs_exchange_end(exch); sysarg_t rc_orig; @@ -421,5 +409,5 @@ return (ssize_t) rc_orig; } - vfs_exchange_end(vfs_phone); + vfs_exchange_end(exch); async_wait_for(req, &rc); if (rc == EOK) @@ -431,9 +419,7 @@ int fsync(int fildes) { - int vfs_phone = vfs_exchange_begin(); - - sysarg_t rc = async_req_1_0(vfs_phone, VFS_IN_SYNC, fildes); - - vfs_exchange_end(vfs_phone); + async_exch_t *exch = vfs_exchange_begin(); + sysarg_t rc = async_req_1_0(exch, VFS_IN_SYNC, fildes); + vfs_exchange_end(exch); return (int) rc; @@ -442,13 +428,13 @@ off64_t lseek(int fildes, off64_t offset, int whence) { - int vfs_phone = vfs_exchange_begin(); + async_exch_t *exch = vfs_exchange_begin(); sysarg_t newoff_lo; sysarg_t newoff_hi; - sysarg_t rc = async_req_4_2(vfs_phone, VFS_IN_SEEK, fildes, + sysarg_t rc = async_req_4_2(exch, VFS_IN_SEEK, fildes, LOWER32(offset), UPPER32(offset), whence, &newoff_lo, &newoff_hi); - vfs_exchange_end(vfs_phone); + vfs_exchange_end(exch); if (rc != EOK) @@ -462,9 +448,8 @@ sysarg_t rc; - int vfs_phone = vfs_exchange_begin(); - - rc = async_req_3_0(vfs_phone, VFS_IN_TRUNCATE, fildes, + async_exch_t *exch = vfs_exchange_begin(); + rc = async_req_3_0(exch, VFS_IN_TRUNCATE, fildes, LOWER32(length), UPPER32(length)); - vfs_exchange_end(vfs_phone); + vfs_exchange_end(exch); return (int) rc; @@ -475,11 +460,11 @@ sysarg_t rc; aid_t req; - - int vfs_phone = vfs_exchange_begin(); - - req = async_send_1(vfs_phone, VFS_IN_FSTAT, fildes, NULL); - rc = async_data_read_start(vfs_phone, (void *) stat, sizeof(struct stat)); - if (rc != EOK) { - vfs_exchange_end(vfs_phone); + + async_exch_t *exch = vfs_exchange_begin(); + + req = async_send_1(exch, VFS_IN_FSTAT, fildes, NULL); + rc = async_data_read_start(exch, (void *) stat, sizeof(struct stat)); + if (rc != EOK) { + vfs_exchange_end(exch); sysarg_t rc_orig; @@ -491,5 +476,5 @@ return (ssize_t) rc_orig; } - vfs_exchange_end(vfs_phone); + vfs_exchange_end(exch); async_wait_for(req, &rc); @@ -508,10 +493,10 @@ return ENOMEM; - int vfs_phone = vfs_exchange_begin(); - - req = async_send_0(vfs_phone, VFS_IN_STAT, NULL); - rc = async_data_write_start(vfs_phone, pa, pa_size); - if (rc != EOK) { - vfs_exchange_end(vfs_phone); + async_exch_t *exch = vfs_exchange_begin(); + + req = async_send_0(exch, VFS_IN_STAT, NULL); + rc = async_data_write_start(exch, pa, pa_size); + if (rc != EOK) { + vfs_exchange_end(exch); free(pa); async_wait_for(req, &rc_orig); @@ -521,7 +506,7 @@ return (int) rc_orig; } - rc = async_data_read_start(vfs_phone, stat, sizeof(struct stat)); - if (rc != EOK) { - vfs_exchange_end(vfs_phone); + rc = async_data_read_start(exch, stat, sizeof(struct stat)); + if (rc != EOK) { + vfs_exchange_end(exch); free(pa); async_wait_for(req, &rc_orig); @@ -531,5 +516,5 @@ return (int) rc_orig; } - vfs_exchange_end(vfs_phone); + vfs_exchange_end(exch); free(pa); async_wait_for(req, &rc); @@ -592,10 +577,10 @@ return ENOMEM; - int vfs_phone = vfs_exchange_begin(); - - req = async_send_1(vfs_phone, VFS_IN_MKDIR, mode, NULL); - rc = async_data_write_start(vfs_phone, pa, pa_size); - if (rc != EOK) { - vfs_exchange_end(vfs_phone); + async_exch_t *exch = vfs_exchange_begin(); + + req = async_send_1(exch, VFS_IN_MKDIR, mode, NULL); + rc = async_data_write_start(exch, pa, pa_size); + if (rc != EOK) { + vfs_exchange_end(exch); free(pa); @@ -608,5 +593,5 @@ return (int) rc_orig; } - vfs_exchange_end(vfs_phone); + vfs_exchange_end(exch); free(pa); async_wait_for(req, &rc); @@ -623,11 +608,11 @@ if (!pa) return ENOMEM; - - int vfs_phone = vfs_exchange_begin(); - - req = async_send_0(vfs_phone, VFS_IN_UNLINK, NULL); - rc = async_data_write_start(vfs_phone, pa, pa_size); - if (rc != EOK) { - vfs_exchange_end(vfs_phone); + + async_exch_t *exch = vfs_exchange_begin(); + + req = async_send_0(exch, VFS_IN_UNLINK, NULL); + rc = async_data_write_start(exch, pa, pa_size); + if (rc != EOK) { + vfs_exchange_end(exch); free(pa); @@ -640,5 +625,5 @@ return (int) rc_orig; } - vfs_exchange_end(vfs_phone); + vfs_exchange_end(exch); free(pa); async_wait_for(req, &rc); @@ -673,11 +658,11 @@ return ENOMEM; } - - int vfs_phone = vfs_exchange_begin(); - - req = async_send_0(vfs_phone, VFS_IN_RENAME, NULL); - rc = async_data_write_start(vfs_phone, olda, olda_size); - if (rc != EOK) { - vfs_exchange_end(vfs_phone); + + async_exch_t *exch = vfs_exchange_begin(); + + req = async_send_0(exch, VFS_IN_RENAME, NULL); + rc = async_data_write_start(exch, olda, olda_size); + if (rc != EOK) { + vfs_exchange_end(exch); free(olda); free(newa); @@ -688,7 +673,7 @@ return (int) rc_orig; } - rc = async_data_write_start(vfs_phone, newa, newa_size); - if (rc != EOK) { - vfs_exchange_end(vfs_phone); + rc = async_data_write_start(exch, newa, newa_size); + if (rc != EOK) { + vfs_exchange_end(exch); free(olda); free(newa); @@ -699,5 +684,5 @@ return (int) rc_orig; } - vfs_exchange_end(vfs_phone); + vfs_exchange_end(exch); free(olda); free(newa); @@ -755,16 +740,19 @@ } -int fd_phone(int fildes) +async_sess_t *fd_session(exch_mgmt_t mgmt, int fildes) { struct stat stat; - int rc = fstat(fildes, &stat); - if (rc != 0) - return rc; - - if (!stat.device) - return -1; - - return devmap_device_connect(stat.device, 0); + if (rc != 0) { + errno = rc; + return NULL; + } + + if (!stat.device) { + errno = ENOENT; + return NULL; + } + + return devmap_device_connect(mgmt, stat.device, 0); } @@ -772,7 +760,5 @@ { struct stat stat; - int rc; - - rc = fstat(fildes, &stat); + int rc = fstat(fildes, &stat); if (rc == EOK) { @@ -787,10 +773,10 @@ int dup2(int oldfd, int newfd) { - int vfs_phone = vfs_exchange_begin(); + async_exch_t *exch = vfs_exchange_begin(); sysarg_t ret; - sysarg_t rc = async_req_2_1(vfs_phone, VFS_IN_DUP, oldfd, newfd, &ret); - - vfs_exchange_end(vfs_phone); + sysarg_t rc = async_req_2_1(exch, VFS_IN_DUP, oldfd, newfd, &ret); + + vfs_exchange_end(exch); if (rc == EOK) Index: uspace/lib/c/include/adt/hash_table.h =================================================================== --- uspace/lib/c/include/adt/hash_table.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/include/adt/hash_table.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -38,4 +38,5 @@ #include #include +#include typedef unsigned long hash_count_t; @@ -83,5 +84,5 @@ 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 *); Index: uspace/lib/c/include/as.h =================================================================== --- uspace/lib/c/include/as.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/include/as.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -60,4 +60,5 @@ extern void *set_maxheapsize(size_t); extern void *as_get_mappable_page(size_t); +extern int as_get_physical_mapping(void *, uintptr_t *); #endif Index: uspace/lib/c/include/async.h =================================================================== --- uspace/lib/c/include/async.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/include/async.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -41,6 +41,6 @@ #include -#include #include +#include #include #include @@ -55,4 +55,76 @@ typedef void (*async_client_conn_t)(ipc_callid_t, ipc_call_t *); +/** Exchange management style + * + */ +typedef enum { + /** No explicit exchange management + * + * Suitable for protocols which use a single + * IPC message per exchange only. + * + */ + EXCHANGE_ATOMIC = 0, + + /** Exchange management via phone cloning + * + * Suitable for servers which support client + * data tracking by task hashes and do not + * mind cloned phones. + * + */ + EXCHANGE_PARALLEL, + + /** Exchange management via mutual exclusion + * + * Suitable for any kind of client/server communication, + * but can limit parallelism. + * + */ + EXCHANGE_SERIALIZE +} exch_mgmt_t; + +/** Session data */ +typedef struct { + /** List of inactive exchanges */ + link_t exch_list; + + /** Exchange management style */ + exch_mgmt_t mgmt; + + /** Session identification */ + int phone; + + /** First clone connection argument */ + sysarg_t arg1; + + /** Second clone connection argument */ + sysarg_t arg2; + + /** Third clone connection argument */ + sysarg_t arg3; + + /** Exchange mutex */ + fibril_mutex_t mutex; + + /** Number of opened exchanges */ + atomic_t refcnt; +} async_sess_t; + +/** Exchange data */ +typedef struct { + /** Link into list of inactive exchanges */ + link_t sess_link; + + /** Link into global list of inactive exchanges */ + link_t global_link; + + /** Session pointer */ + async_sess_t *sess; + + /** Exchange identification */ + int phone; +} async_exch_t; + extern atomic_t threads_in_ipc_wait; @@ -68,32 +140,32 @@ * User-friendly wrappers for async_send_fast() and async_send_slow(). The * macros are in the form async_send_m(), where m denotes the number of payload - * arguments. Each macros chooses between the fast and the slow version based + * arguments. Each macros chooses between the fast and the slow version based * on m. */ -#define async_send_0(phoneid, method, dataptr) \ - async_send_fast((phoneid), (method), 0, 0, 0, 0, (dataptr)) -#define async_send_1(phoneid, method, arg1, dataptr) \ - async_send_fast((phoneid), (method), (arg1), 0, 0, 0, (dataptr)) -#define async_send_2(phoneid, method, arg1, arg2, dataptr) \ - async_send_fast((phoneid), (method), (arg1), (arg2), 0, 0, (dataptr)) -#define async_send_3(phoneid, method, arg1, arg2, arg3, dataptr) \ - async_send_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, (dataptr)) -#define async_send_4(phoneid, method, arg1, arg2, arg3, arg4, dataptr) \ - async_send_fast((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \ - (dataptr)) -#define async_send_5(phoneid, method, arg1, arg2, arg3, arg4, arg5, dataptr) \ - async_send_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \ - (arg5), (dataptr)) - -extern aid_t async_send_fast(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t, - sysarg_t, ipc_call_t *); -extern aid_t async_send_slow(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t, +#define async_send_0(exch, method, dataptr) \ + async_send_fast(exch, method, 0, 0, 0, 0, dataptr) +#define async_send_1(exch, method, arg1, dataptr) \ + async_send_fast(exch, method, arg1, 0, 0, 0, dataptr) +#define async_send_2(exch, method, arg1, arg2, dataptr) \ + async_send_fast(exch, method, arg1, arg2, 0, 0, dataptr) +#define async_send_3(exch, method, arg1, arg2, arg3, dataptr) \ + async_send_fast(exch, method, arg1, arg2, arg3, 0, dataptr) +#define async_send_4(exch, method, arg1, arg2, arg3, arg4, dataptr) \ + async_send_fast(exch, method, arg1, arg2, arg3, arg4, dataptr) +#define async_send_5(exch, method, arg1, arg2, arg3, arg4, arg5, dataptr) \ + async_send_slow(exch, method, arg1, arg2, arg3, arg4, arg5, dataptr) + +extern aid_t async_send_fast(async_exch_t *, sysarg_t, sysarg_t, sysarg_t, sysarg_t, sysarg_t, ipc_call_t *); +extern aid_t async_send_slow(async_exch_t *, sysarg_t, sysarg_t, sysarg_t, + sysarg_t, sysarg_t, sysarg_t, ipc_call_t *); + extern void async_wait_for(aid_t, sysarg_t *); extern int async_wait_timeout(aid_t, sysarg_t *, suseconds_t); extern fid_t async_new_connection(sysarg_t, sysarg_t, ipc_callid_t, - ipc_call_t *, void (*)(ipc_callid_t, ipc_call_t *)); + ipc_call_t *, async_client_conn_t); + extern void async_usleep(suseconds_t); extern void async_create_manager(void); @@ -102,6 +174,5 @@ extern void async_set_client_data_constructor(async_client_data_ctor_t); extern void async_set_client_data_destructor(async_client_data_dtor_t); - -extern void *async_client_data_get(void); +extern void *async_get_client_data(void); extern void async_set_client_connection(async_client_conn_t); @@ -112,11 +183,12 @@ */ -extern void async_msg_0(int, sysarg_t); -extern void async_msg_1(int, sysarg_t, sysarg_t); -extern void async_msg_2(int, sysarg_t, sysarg_t, sysarg_t); -extern void async_msg_3(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t); -extern void async_msg_4(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t, sysarg_t); -extern void async_msg_5(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t, sysarg_t, +extern void async_msg_0(async_exch_t *, sysarg_t); +extern void async_msg_1(async_exch_t *, sysarg_t, sysarg_t); +extern void async_msg_2(async_exch_t *, sysarg_t, sysarg_t, sysarg_t); +extern void async_msg_3(async_exch_t *, sysarg_t, sysarg_t, sysarg_t, sysarg_t); +extern void async_msg_4(async_exch_t *, sysarg_t, sysarg_t, sysarg_t, sysarg_t, sysarg_t); +extern void async_msg_5(async_exch_t *, sysarg_t, sysarg_t, sysarg_t, sysarg_t, + sysarg_t, sysarg_t); /* @@ -138,8 +210,8 @@ */ -extern int async_forward_fast(ipc_callid_t, int, sysarg_t, sysarg_t, sysarg_t, - unsigned int); -extern int async_forward_slow(ipc_callid_t, int, sysarg_t, sysarg_t, sysarg_t, - sysarg_t, sysarg_t, sysarg_t, unsigned int); +extern int async_forward_fast(ipc_callid_t, async_exch_t *, sysarg_t, sysarg_t, + sysarg_t, unsigned int); +extern int async_forward_slow(ipc_callid_t, async_exch_t *, sysarg_t, sysarg_t, + sysarg_t, sysarg_t, sysarg_t, sysarg_t, unsigned int); /* @@ -150,161 +222,160 @@ */ -#define async_req_0_0(phoneid, method) \ - async_req_fast((phoneid), (method), 0, 0, 0, 0, NULL, NULL, NULL, NULL, \ - NULL) -#define async_req_0_1(phoneid, method, r1) \ - async_req_fast((phoneid), (method), 0, 0, 0, 0, (r1), NULL, NULL, NULL, \ - NULL) -#define async_req_0_2(phoneid, method, r1, r2) \ - async_req_fast((phoneid), (method), 0, 0, 0, 0, (r1), (r2), NULL, NULL, \ - NULL) -#define async_req_0_3(phoneid, method, r1, r2, r3) \ - async_req_fast((phoneid), (method), 0, 0, 0, 0, (r1), (r2), (r3), NULL, \ - NULL) -#define async_req_0_4(phoneid, method, r1, r2, r3, r4) \ - async_req_fast((phoneid), (method), 0, 0, 0, 0, (r1), (r2), (r3), (r4), \ - NULL) -#define async_req_0_5(phoneid, method, r1, r2, r3, r4, r5) \ - async_req_fast((phoneid), (method), 0, 0, 0, 0, (r1), (r2), (r3), (r4), \ - (r5)) -#define async_req_1_0(phoneid, method, arg1) \ - async_req_fast((phoneid), (method), (arg1), 0, 0, 0, NULL, NULL, NULL, \ - NULL, NULL) -#define async_req_1_1(phoneid, method, arg1, rc1) \ - async_req_fast((phoneid), (method), (arg1), 0, 0, 0, (rc1), NULL, NULL, \ - NULL, NULL) -#define async_req_1_2(phoneid, method, arg1, rc1, rc2) \ - async_req_fast((phoneid), (method), (arg1), 0, 0, 0, (rc1), (rc2), NULL, \ - NULL, NULL) -#define async_req_1_3(phoneid, method, arg1, rc1, rc2, rc3) \ - async_req_fast((phoneid), (method), (arg1), 0, 0, 0, (rc1), (rc2), (rc3), \ - NULL, NULL) -#define async_req_1_4(phoneid, method, arg1, rc1, rc2, rc3, rc4) \ - async_req_fast((phoneid), (method), (arg1), 0, 0, 0, (rc1), (rc2), (rc3), \ - (rc4), NULL) -#define async_req_1_5(phoneid, method, arg1, rc1, rc2, rc3, rc4, rc5) \ - async_req_fast((phoneid), (method), (arg1), 0, 0, 0, (rc1), (rc2), (rc3), \ - (rc4), (rc5)) -#define async_req_2_0(phoneid, method, arg1, arg2) \ - async_req_fast((phoneid), (method), (arg1), (arg2), 0, 0, NULL, NULL, \ +#define async_req_0_0(exch, method) \ + async_req_fast(exch, method, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL) +#define async_req_0_1(exch, method, r1) \ + async_req_fast(exch, method, 0, 0, 0, 0, r1, NULL, NULL, NULL, NULL) +#define async_req_0_2(exch, method, r1, r2) \ + async_req_fast(exch, method, 0, 0, 0, 0, r1, r2, NULL, NULL, NULL) +#define async_req_0_3(exch, method, r1, r2, r3) \ + async_req_fast(exch, method, 0, 0, 0, 0, r1, r2, r3, NULL, NULL) +#define async_req_0_4(exch, method, r1, r2, r3, r4) \ + async_req_fast(exch, method, 0, 0, 0, 0, r1, r2, r3, r4, NULL) +#define async_req_0_5(exch, method, r1, r2, r3, r4, r5) \ + async_req_fast(exch, method, 0, 0, 0, 0, r1, r2, r3, r4, r5) + +#define async_req_1_0(exch, method, arg1) \ + async_req_fast(exch, method, arg1, 0, 0, 0, NULL, NULL, NULL, NULL, \ + NULL) +#define async_req_1_1(exch, method, arg1, rc1) \ + async_req_fast(exch, method, arg1, 0, 0, 0, rc1, NULL, NULL, NULL, \ + NULL) +#define async_req_1_2(exch, method, arg1, rc1, rc2) \ + async_req_fast(exch, method, arg1, 0, 0, 0, rc1, rc2, NULL, NULL, \ + NULL) +#define async_req_1_3(exch, method, arg1, rc1, rc2, rc3) \ + async_req_fast(exch, method, arg1, 0, 0, 0, rc1, rc2, rc3, NULL, \ + NULL) +#define async_req_1_4(exch, method, arg1, rc1, rc2, rc3, rc4) \ + async_req_fast(exch, method, arg1, 0, 0, 0, rc1, rc2, rc3, rc4, \ + NULL) +#define async_req_1_5(exch, method, arg1, rc1, rc2, rc3, rc4, rc5) \ + async_req_fast(exch, method, arg1, 0, 0, 0, rc1, rc2, rc3, rc4, \ + rc5) + +#define async_req_2_0(exch, method, arg1, arg2) \ + async_req_fast(exch, method, arg1, arg2, 0, 0, NULL, NULL, NULL, \ + NULL, NULL) +#define async_req_2_1(exch, method, arg1, arg2, rc1) \ + async_req_fast(exch, method, arg1, arg2, 0, 0, rc1, NULL, NULL, \ + NULL, NULL) +#define async_req_2_2(exch, method, arg1, arg2, rc1, rc2) \ + async_req_fast(exch, method, arg1, arg2, 0, 0, rc1, rc2, NULL, NULL, \ + NULL) +#define async_req_2_3(exch, method, arg1, arg2, rc1, rc2, rc3) \ + async_req_fast(exch, method, arg1, arg2, 0, 0, rc1, rc2, rc3, NULL, \ + NULL) +#define async_req_2_4(exch, method, arg1, arg2, rc1, rc2, rc3, rc4) \ + async_req_fast(exch, method, arg1, arg2, 0, 0, rc1, rc2, rc3, rc4, \ + NULL) +#define async_req_2_5(exch, method, arg1, arg2, rc1, rc2, rc3, rc4, rc5) \ + async_req_fast(exch, method, arg1, arg2, 0, 0, rc1, rc2, rc3, rc4, \ + rc5) + +#define async_req_3_0(exch, method, arg1, arg2, arg3) \ + async_req_fast(exch, method, arg1, arg2, arg3, 0, NULL, NULL, NULL, \ + NULL, NULL) +#define async_req_3_1(exch, method, arg1, arg2, arg3, rc1) \ + async_req_fast(exch, method, arg1, arg2, arg3, 0, rc1, NULL, NULL, \ + NULL, NULL) +#define async_req_3_2(exch, method, arg1, arg2, arg3, rc1, rc2) \ + async_req_fast(exch, method, arg1, arg2, arg3, 0, rc1, rc2, NULL, \ + NULL, NULL) +#define async_req_3_3(exch, method, arg1, arg2, arg3, rc1, rc2, rc3) \ + async_req_fast(exch, method, arg1, arg2, arg3, 0, rc1, rc2, rc3, \ + NULL, NULL) +#define async_req_3_4(exch, method, arg1, arg2, arg3, rc1, rc2, rc3, rc4) \ + async_req_fast(exch, method, arg1, arg2, arg3, 0, rc1, rc2, rc3, \ + rc4, NULL) +#define async_req_3_5(exch, method, arg1, arg2, arg3, rc1, rc2, rc3, rc4, \ + rc5) \ + async_req_fast(exch, method, arg1, arg2, arg3, 0, rc1, rc2, rc3, \ + rc4, rc5) + +#define async_req_4_0(exch, method, arg1, arg2, arg3, arg4) \ + async_req_fast(exch, method, arg1, arg2, arg3, arg4, NULL, NULL, \ NULL, NULL, NULL) -#define async_req_2_1(phoneid, method, arg1, arg2, rc1) \ - async_req_fast((phoneid), (method), (arg1), (arg2), 0, 0, (rc1), NULL, \ +#define async_req_4_1(exch, method, arg1, arg2, arg3, arg4, rc1) \ + async_req_fast(exch, method, arg1, arg2, arg3, arg4, rc1, NULL, \ NULL, NULL, NULL) -#define async_req_2_2(phoneid, method, arg1, arg2, rc1, rc2) \ - async_req_fast((phoneid), (method), (arg1), (arg2), 0, 0, (rc1), (rc2), \ +#define async_req_4_2(exch, method, arg1, arg2, arg3, arg4, rc1, rc2) \ + async_req_fast(exch, method, arg1, arg2, arg3, arg4, rc1, rc2, NULL, \ + NULL, NULL) +#define async_req_4_3(exch, method, arg1, arg2, arg3, arg4, rc1, rc2, rc3) \ + async_req_fast(exch, method, arg1, arg2, arg3, arg4, rc1, rc2, rc3, \ + NULL, NULL) +#define async_req_4_4(exch, method, arg1, arg2, arg3, arg4, rc1, rc2, rc3, \ + rc4) \ + async_req_fast(exch, method, arg1, arg2, arg3, arg4, rc1, rc2, rc3, \ + rc4, NULL) +#define async_req_4_5(exch, method, arg1, arg2, arg3, arg4, rc1, rc2, rc3, \ + rc4, rc5) \ + async_req_fast(exch, method, arg1, arg2, arg3, arg4, rc1, rc2, rc3, \ + rc4, rc5) + +#define async_req_5_0(exch, method, arg1, arg2, arg3, arg4, arg5) \ + async_req_slow(exch, method, arg1, arg2, arg3, arg4, arg5, NULL, \ + NULL, NULL, NULL, NULL) +#define async_req_5_1(exch, method, arg1, arg2, arg3, arg4, arg5, rc1) \ + async_req_slow(exch, method, arg1, arg2, arg3, arg4, arg5, rc1, \ + NULL, NULL, NULL, NULL) +#define async_req_5_2(exch, method, arg1, arg2, arg3, arg4, arg5, rc1, rc2) \ + async_req_slow(exch, method, arg1, arg2, arg3, arg4, arg5, rc1, rc2, \ NULL, NULL, NULL) -#define async_req_2_3(phoneid, method, arg1, arg2, rc1, rc2, rc3) \ - async_req_fast((phoneid), (method), (arg1), (arg2), 0, 0, (rc1), (rc2), \ - (rc3), NULL, NULL) -#define async_req_2_4(phoneid, method, arg1, arg2, rc1, rc2, rc3, rc4) \ - async_req_fast((phoneid), (method), (arg1), (arg2), 0, 0, (rc1), (rc2), \ - (rc3), (rc4), NULL) -#define async_req_2_5(phoneid, method, arg1, arg2, rc1, rc2, rc3, rc4, rc5) \ - async_req_fast((phoneid), (method), (arg1), (arg2), 0, 0, (rc1), (rc2), \ - (rc3), (rc4), (rc5)) -#define async_req_3_0(phoneid, method, arg1, arg2, arg3) \ - async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, NULL, NULL, \ - NULL, NULL, NULL) -#define async_req_3_1(phoneid, method, arg1, arg2, arg3, rc1) \ - async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, (rc1), \ - NULL, NULL, NULL, NULL) -#define async_req_3_2(phoneid, method, arg1, arg2, arg3, rc1, rc2) \ - async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, (rc1), \ - (rc2), NULL, NULL, NULL) -#define async_req_3_3(phoneid, method, arg1, arg2, arg3, rc1, rc2, rc3) \ - async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, (rc1), \ - (rc2), (rc3), NULL, NULL) -#define async_req_3_4(phoneid, method, arg1, arg2, arg3, rc1, rc2, rc3, rc4) \ - async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, (rc1), \ - (rc2), (rc3), (rc4), NULL) -#define async_req_3_5(phoneid, method, arg1, arg2, arg3, rc1, rc2, rc3, rc4, \ - rc5) \ - async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, (rc1), \ - (rc2), (rc3), (rc4), (rc5)) -#define async_req_4_0(phoneid, method, arg1, arg2, arg3, arg4) \ - async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), (arg4), NULL, \ - NULL, NULL, NULL, NULL) -#define async_req_4_1(phoneid, method, arg1, arg2, arg3, arg4, rc1) \ - async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), (arg4), (rc1), \ - NULL, NULL, NULL, NULL) -#define async_req_4_2(phoneid, method, arg1, arg2, arg3, arg4, rc1, rc2) \ - async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), (arg4), (rc1), \ - (rc2), NULL, NULL, NULL) -#define async_req_4_3(phoneid, method, arg1, arg2, arg3, arg4, rc1, rc2, rc3) \ - async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), (arg4), (rc1), \ - (rc2), (rc3), NULL, NULL) -#define async_req_4_4(phoneid, method, arg1, arg2, arg3, arg4, rc1, rc2, rc3, \ - rc4) \ - async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \ - (rc1), (rc2), (rc3), (rc4), NULL) -#define async_req_4_5(phoneid, method, arg1, arg2, arg3, arg4, rc1, rc2, rc3, \ - rc4, rc5) \ - async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \ - (rc1), (rc2), (rc3), (rc4), (rc5)) -#define async_req_5_0(phoneid, method, arg1, arg2, arg3, arg4, arg5) \ - async_req_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \ - (arg5), NULL, NULL, NULL, NULL, NULL) -#define async_req_5_1(phoneid, method, arg1, arg2, arg3, arg4, arg5, rc1) \ - async_req_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \ - (arg5), (rc1), NULL, NULL, NULL, NULL) -#define async_req_5_2(phoneid, method, arg1, arg2, arg3, arg4, arg5, rc1, rc2) \ - async_req_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \ - (arg5), (rc1), (rc2), NULL, NULL, NULL) -#define async_req_5_3(phoneid, method, arg1, arg2, arg3, arg4, arg5, rc1, rc2, \ +#define async_req_5_3(exch, method, arg1, arg2, arg3, arg4, arg5, rc1, rc2, \ rc3) \ - async_req_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \ - (arg5), (rc1), (rc2), (rc3), NULL, NULL) -#define async_req_5_4(phoneid, method, arg1, arg2, arg3, arg4, arg5, rc1, rc2, \ + async_req_slow(exch, method, arg1, arg2, arg3, arg4, arg5, rc1, rc2, \ + rc3, NULL, NULL) +#define async_req_5_4(exch, method, arg1, arg2, arg3, arg4, arg5, rc1, rc2, \ rc3, rc4) \ - async_req_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \ - (arg5), (rc1), (rc2), (rc3), (rc4), NULL) -#define async_req_5_5(phoneid, method, arg1, arg2, arg3, arg4, arg5, rc1, rc2, \ + async_req_slow(exch, method, arg1, arg2, arg3, arg4, arg5, rc1, rc2, \ + rc3, rc4, NULL) +#define async_req_5_5(exch, method, arg1, arg2, arg3, arg4, arg5, rc1, rc2, \ rc3, rc4, rc5) \ - async_req_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \ - (arg5), (rc1), (rc2), (rc3), (rc4), (rc5)) - -extern sysarg_t async_req_fast(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t, - sysarg_t, sysarg_t *, sysarg_t *, sysarg_t *, sysarg_t *, sysarg_t *); -extern sysarg_t async_req_slow(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t, + async_req_slow(exch, method, arg1, arg2, arg3, arg4, arg5, rc1, rc2, \ + rc3, rc4, rc5) + +extern sysarg_t async_req_fast(async_exch_t *, sysarg_t, sysarg_t, sysarg_t, sysarg_t, sysarg_t, sysarg_t *, sysarg_t *, sysarg_t *, sysarg_t *, sysarg_t *); - -static inline void async_serialize_start(void) -{ - fibril_inc_sercount(); -} - -static inline void async_serialize_end(void) -{ - fibril_dec_sercount(); -} - -extern int async_connect_to_me(int, sysarg_t, sysarg_t, sysarg_t, +extern sysarg_t async_req_slow(async_exch_t *, sysarg_t, sysarg_t, sysarg_t, + sysarg_t, sysarg_t, sysarg_t, sysarg_t *, sysarg_t *, sysarg_t *, + sysarg_t *, sysarg_t *); + +extern async_sess_t *async_connect_me(exch_mgmt_t, async_exch_t *); +extern async_sess_t *async_connect_me_to(exch_mgmt_t, async_exch_t *, sysarg_t, + sysarg_t, sysarg_t); +extern async_sess_t *async_connect_me_to_blocking(exch_mgmt_t, async_exch_t *, + sysarg_t, sysarg_t, sysarg_t); +extern async_sess_t *async_connect_kbox(task_id_t); + +extern int async_connect_to_me(async_exch_t *, sysarg_t, sysarg_t, sysarg_t, async_client_conn_t); -extern int async_connect_me_to(int, sysarg_t, sysarg_t, sysarg_t); -extern int async_connect_me_to_blocking(int, sysarg_t, sysarg_t, sysarg_t); -extern int async_connect_kbox(task_id_t); -extern int async_hangup(int); + +extern int async_hangup(async_sess_t *); extern void async_poke(void); +extern async_exch_t *async_exchange_begin(async_sess_t *); +extern void async_exchange_end(async_exch_t *); + /* * User-friendly wrappers for async_share_in_start(). */ -#define async_share_in_start_0_0(phoneid, dst, size) \ - async_share_in_start((phoneid), (dst), (size), 0, NULL) -#define async_share_in_start_0_1(phoneid, dst, size, flags) \ - async_share_in_start((phoneid), (dst), (size), 0, (flags)) -#define async_share_in_start_1_0(phoneid, dst, size, arg) \ - async_share_in_start((phoneid), (dst), (size), (arg), NULL) -#define async_share_in_start_1_1(phoneid, dst, size, arg, flags) \ - async_share_in_start((phoneid), (dst), (size), (arg), (flags)) - -extern int async_share_in_start(int, void *, size_t, sysarg_t, unsigned int *); +#define async_share_in_start_0_0(exch, dst, size) \ + async_share_in_start(exch, dst, size, 0, NULL) +#define async_share_in_start_0_1(exch, dst, size, flags) \ + async_share_in_start(exch, dst, size, 0, flags) +#define async_share_in_start_1_0(exch, dst, size, arg) \ + async_share_in_start(exch, dst, size, arg, NULL) +#define async_share_in_start_1_1(exch, dst, size, arg, flags) \ + async_share_in_start(exch, dst, size, arg, flags) + +extern int async_share_in_start(async_exch_t *, void *, size_t, sysarg_t, + unsigned int *); extern bool async_share_in_receive(ipc_callid_t *, size_t *); extern int async_share_in_finalize(ipc_callid_t, void *, unsigned int); -extern int async_share_out_start(int, void *, unsigned int); +extern int async_share_out_start(async_exch_t *, void *, unsigned int); extern bool async_share_out_receive(ipc_callid_t *, size_t *, unsigned int *); extern int async_share_out_finalize(ipc_callid_t, void *); @@ -314,39 +385,37 @@ */ -#define async_data_read_forward_0_0(phoneid, method, answer) \ - async_data_read_forward_fast((phoneid), (method), 0, 0, 0, 0, NULL) -#define async_data_read_forward_0_1(phoneid, method, answer) \ - async_data_read_forward_fast((phoneid), (method), 0, 0, 0, 0, (answer)) -#define async_data_read_forward_1_0(phoneid, method, arg1, answer) \ - async_data_read_forward_fast((phoneid), (method), (arg1), 0, 0, 0, NULL) -#define async_data_read_forward_1_1(phoneid, method, arg1, answer) \ - async_data_read_forward_fast((phoneid), (method), (arg1), 0, 0, 0, (answer)) -#define async_data_read_forward_2_0(phoneid, method, arg1, arg2, answer) \ - async_data_read_forward_fast((phoneid), (method), (arg1), (arg2), 0, 0, NULL) -#define async_data_read_forward_2_1(phoneid, method, arg1, arg2, answer) \ - async_data_read_forward_fast((phoneid), (method), (arg1), (arg2), 0, 0, \ - (answer)) -#define async_data_read_forward_3_0(phoneid, method, arg1, arg2, arg3, answer) \ - async_data_read_forward_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, \ - NULL) -#define async_data_read_forward_3_1(phoneid, method, arg1, arg2, arg3, answer) \ - async_data_read_forward_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, \ - (answer)) -#define async_data_read_forward_4_0(phoneid, method, arg1, arg2, arg3, arg4, answer) \ - async_data_read_forward_fast((phoneid), (method), (arg1), (arg2), (arg3), \ - (arg4), NULL) -#define async_data_read_forward_4_1(phoneid, method, arg1, arg2, arg3, arg4, answer) \ - async_data_read_forward_fast((phoneid), (method), (arg1), (arg2), (arg3), \ - (arg4), (answer)) - -#define async_data_read_start(p, buf, len) \ - async_data_read_start_generic((p), (buf), (len), IPC_XF_NONE) - -extern int async_data_read_start_generic(int, void *, size_t, int); +#define async_data_read_forward_0_0(exch, method, answer) \ + async_data_read_forward_fast(exch, method, 0, 0, 0, 0, NULL) +#define async_data_read_forward_0_1(exch, method, answer) \ + async_data_read_forward_fast(exch, method, 0, 0, 0, 0, answer) +#define async_data_read_forward_1_0(exch, method, arg1, answer) \ + async_data_read_forward_fast(exch, method, arg1, 0, 0, 0, NULL) +#define async_data_read_forward_1_1(exch, method, arg1, answer) \ + async_data_read_forward_fast(exch, method, arg1, 0, 0, 0, answer) +#define async_data_read_forward_2_0(exch, method, arg1, arg2, answer) \ + async_data_read_forward_fast(exch, method, arg1, arg2, 0, 0, NULL) +#define async_data_read_forward_2_1(exch, method, arg1, arg2, answer) \ + async_data_read_forward_fast(exch, method, arg1, arg2, 0, 0, answer) +#define async_data_read_forward_3_0(exch, method, arg1, arg2, arg3, answer) \ + async_data_read_forward_fast(exch, method, arg1, arg2, arg3, 0, NULL) +#define async_data_read_forward_3_1(exch, method, arg1, arg2, arg3, answer) \ + async_data_read_forward_fast(exch, method, arg1, arg2, arg3, 0, \ + answer) +#define async_data_read_forward_4_0(exch, method, arg1, arg2, arg3, arg4, \ + answer) \ + async_data_read_forward_fast(exch, method, arg1, arg2, arg3, arg4, \ + NULL) +#define async_data_read_forward_4_1(exch, method, arg1, arg2, arg3, arg4, \ + answer) \ + async_data_read_forward_fast(exch, method, arg1, arg2, arg3, arg4, \ + answer) + +extern aid_t async_data_read(async_exch_t *, void *, size_t, ipc_call_t *); +extern int async_data_read_start(async_exch_t *, void *, size_t); extern bool async_data_read_receive(ipc_callid_t *, size_t *); extern int async_data_read_finalize(ipc_callid_t, const void *, size_t); -extern int async_data_read_forward_fast(int, sysarg_t, sysarg_t, sysarg_t, - sysarg_t, sysarg_t, ipc_call_t *); +extern int async_data_read_forward_fast(async_exch_t *, sysarg_t, sysarg_t, + sysarg_t, sysarg_t, sysarg_t, ipc_call_t *); /* @@ -354,36 +423,32 @@ */ -#define async_data_write_forward_0_0(phoneid, method, answer) \ - async_data_write_forward_fast((phoneid), (method), 0, 0, 0, 0, NULL) -#define async_data_write_forward_0_1(phoneid, method, answer) \ - async_data_write_forward_fast((phoneid), (method), 0, 0, 0, 0, (answer)) -#define async_data_write_forward_1_0(phoneid, method, arg1, answer) \ - async_data_write_forward_fast((phoneid), (method), (arg1), 0, 0, 0, NULL) -#define async_data_write_forward_1_1(phoneid, method, arg1, answer) \ - async_data_write_forward_fast((phoneid), (method), (arg1), 0, 0, 0, \ - (answer)) -#define async_data_write_forward_2_0(phoneid, method, arg1, arg2, answer) \ - async_data_write_forward_fast((phoneid), (method), (arg1), (arg2), 0, 0, \ - NULL) -#define async_data_write_forward_2_1(phoneid, method, arg1, arg2, answer) \ - async_data_write_forward_fast((phoneid), (method), (arg1), (arg2), 0, 0, \ - (answer)) -#define async_data_write_forward_3_0(phoneid, method, arg1, arg2, arg3, answer) \ - async_data_write_forward_fast((phoneid), (method), (arg1), (arg2), (arg3), \ - 0, NULL) -#define async_data_write_forward_3_1(phoneid, method, arg1, arg2, arg3, answer) \ - async_data_write_forward_fast((phoneid), (method), (arg1), (arg2), (arg3), \ - 0, (answer)) -#define async_data_write_forward_4_0(phoneid, method, arg1, arg2, arg3, arg4, answer) \ - async_data_write_forward_fast((phoneid), (method), (arg1), (arg2), (arg3), \ - (arg4), NULL) -#define async_data_write_forward_4_1(phoneid, method, arg1, arg2, arg3, arg4, answer) \ - async_data_write_forward_fast((phoneid), (method), (arg1), (arg2), (arg3), \ - (arg4), (answer)) - -#define async_data_write_start(p, buf, len) \ - async_data_write_start_generic((p), (buf), (len), IPC_XF_NONE) - -extern int async_data_write_start_generic(int, const void *, size_t, int); +#define async_data_write_forward_0_0(exch, method, answer) \ + async_data_write_forward_fast(exch, method, 0, 0, 0, 0, NULL) +#define async_data_write_forward_0_1(exch, method, answer) \ + async_data_write_forward_fast(exch, method, 0, 0, 0, 0, answer) +#define async_data_write_forward_1_0(exch, method, arg1, answer) \ + async_data_write_forward_fast(exch, method, arg1, 0, 0, 0, NULL) +#define async_data_write_forward_1_1(exch, method, arg1, answer) \ + async_data_write_forward_fast(exch, method, arg1, 0, 0, 0, answer) +#define async_data_write_forward_2_0(exch, method, arg1, arg2, answer) \ + async_data_write_forward_fast(exch, method, arg1, arg2, 0, 0, NULL) +#define async_data_write_forward_2_1(exch, method, arg1, arg2, answer) \ + async_data_write_forward_fast(exch, method, arg1, arg2, 0, 0, answer) +#define async_data_write_forward_3_0(exch, method, arg1, arg2, arg3, answer) \ + async_data_write_forward_fast(exch, method, arg1, arg2, arg3, 0, \ + NULL) +#define async_data_write_forward_3_1(exch, method, arg1, arg2, arg3, answer) \ + async_data_write_forward_fast(exch, method, arg1, arg2, arg3, 0, \ + answer) +#define async_data_write_forward_4_0(exch, method, arg1, arg2, arg3, arg4, \ + answer) \ + async_data_write_forward_fast(exch, method, arg1, arg2, arg3, arg4, \ + NULL) +#define async_data_write_forward_4_1(exch, method, arg1, arg2, arg3, arg4, \ + answer) \ + async_data_write_forward_fast(exch, method, arg1, arg2, arg3, arg4, \ + answer) + +extern int async_data_write_start(async_exch_t *, const void *, size_t); extern bool async_data_write_receive(ipc_callid_t *, size_t *); extern int async_data_write_finalize(ipc_callid_t, void *, size_t); @@ -393,6 +458,10 @@ extern void async_data_write_void(sysarg_t); -extern int async_data_write_forward_fast(int, sysarg_t, sysarg_t, sysarg_t, - sysarg_t, sysarg_t, ipc_call_t *); +extern int async_data_write_forward_fast(async_exch_t *, sysarg_t, sysarg_t, + sysarg_t, sysarg_t, sysarg_t, ipc_call_t *); + +extern int async_exchange_clone(async_exch_t *, async_exch_t *); +extern async_sess_t *async_clone_receive(exch_mgmt_t); +extern async_sess_t *async_callback_receive(exch_mgmt_t); #endif Index: uspace/lib/c/include/async_obsolete.h =================================================================== --- uspace/lib/c/include/async_obsolete.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/c/include/async_obsolete.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,267 @@ +/* + * Copyright (c) 2006 Ondrej Palkovsky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libc + * @{ + */ +/** @file + */ + +#if ((defined(LIBC_IPC_H_)) && (!defined(LIBC_ASYNC_OBSOLETE_C_))) + #error Do not intermix low-level IPC interface and async framework +#endif + +#ifndef LIBC_ASYNC_OBSOLETE_H_ +#define LIBC_ASYNC_OBSOLETE_H_ + +extern void async_obsolete_serialize_start(void); +extern void async_obsolete_serialize_end(void); + +#define async_obsolete_send_0(phoneid, method, dataptr) \ + async_obsolete_send_fast((phoneid), (method), 0, 0, 0, 0, (dataptr)) +#define async_obsolete_send_1(phoneid, method, arg1, dataptr) \ + async_obsolete_send_fast((phoneid), (method), (arg1), 0, 0, 0, (dataptr)) +#define async_obsolete_send_2(phoneid, method, arg1, arg2, dataptr) \ + async_obsolete_send_fast((phoneid), (method), (arg1), (arg2), 0, 0, (dataptr)) +#define async_obsolete_send_3(phoneid, method, arg1, arg2, arg3, dataptr) \ + async_obsolete_send_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, (dataptr)) +#define async_obsolete_send_4(phoneid, method, arg1, arg2, arg3, arg4, dataptr) \ + async_obsolete_send_fast((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \ + (dataptr)) +#define async_obsolete_send_5(phoneid, method, arg1, arg2, arg3, arg4, arg5, dataptr) \ + async_obsolete_send_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \ + (arg5), (dataptr)) + +extern aid_t async_obsolete_send_fast(int phoneid, sysarg_t method, sysarg_t arg1, + sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, ipc_call_t *dataptr); +extern aid_t async_obsolete_send_slow(int phoneid, sysarg_t method, sysarg_t arg1, + sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, + ipc_call_t *dataptr); + +#define async_obsolete_req_0_0(phoneid, method) \ + async_obsolete_req_fast((phoneid), (method), 0, 0, 0, 0, NULL, NULL, NULL, NULL, \ + NULL) +#define async_obsolete_req_0_1(phoneid, method, r1) \ + async_obsolete_req_fast((phoneid), (method), 0, 0, 0, 0, (r1), NULL, NULL, NULL, \ + NULL) +#define async_obsolete_req_0_2(phoneid, method, r1, r2) \ + async_obsolete_req_fast((phoneid), (method), 0, 0, 0, 0, (r1), (r2), NULL, NULL, \ + NULL) +#define async_obsolete_req_0_3(phoneid, method, r1, r2, r3) \ + async_obsolete_req_fast((phoneid), (method), 0, 0, 0, 0, (r1), (r2), (r3), NULL, \ + NULL) +#define async_obsolete_req_0_4(phoneid, method, r1, r2, r3, r4) \ + async_obsolete_req_fast((phoneid), (method), 0, 0, 0, 0, (r1), (r2), (r3), (r4), \ + NULL) +#define async_obsolete_req_0_5(phoneid, method, r1, r2, r3, r4, r5) \ + async_obsolete_req_fast((phoneid), (method), 0, 0, 0, 0, (r1), (r2), (r3), (r4), \ + (r5)) +#define async_obsolete_req_1_0(phoneid, method, arg1) \ + async_obsolete_req_fast((phoneid), (method), (arg1), 0, 0, 0, NULL, NULL, NULL, \ + NULL, NULL) +#define async_obsolete_req_1_1(phoneid, method, arg1, rc1) \ + async_obsolete_req_fast((phoneid), (method), (arg1), 0, 0, 0, (rc1), NULL, NULL, \ + NULL, NULL) +#define async_obsolete_req_1_2(phoneid, method, arg1, rc1, rc2) \ + async_obsolete_req_fast((phoneid), (method), (arg1), 0, 0, 0, (rc1), (rc2), NULL, \ + NULL, NULL) +#define async_obsolete_req_1_3(phoneid, method, arg1, rc1, rc2, rc3) \ + async_obsolete_req_fast((phoneid), (method), (arg1), 0, 0, 0, (rc1), (rc2), (rc3), \ + NULL, NULL) +#define async_obsolete_req_1_4(phoneid, method, arg1, rc1, rc2, rc3, rc4) \ + async_obsolete_req_fast((phoneid), (method), (arg1), 0, 0, 0, (rc1), (rc2), (rc3), \ + (rc4), NULL) +#define async_obsolete_req_1_5(phoneid, method, arg1, rc1, rc2, rc3, rc4, rc5) \ + async_obsolete_req_fast((phoneid), (method), (arg1), 0, 0, 0, (rc1), (rc2), (rc3), \ + (rc4), (rc5)) +#define async_obsolete_req_2_0(phoneid, method, arg1, arg2) \ + async_obsolete_req_fast((phoneid), (method), (arg1), (arg2), 0, 0, NULL, NULL, \ + NULL, NULL, NULL) +#define async_obsolete_req_2_1(phoneid, method, arg1, arg2, rc1) \ + async_obsolete_req_fast((phoneid), (method), (arg1), (arg2), 0, 0, (rc1), NULL, \ + NULL, NULL, NULL) +#define async_obsolete_req_2_2(phoneid, method, arg1, arg2, rc1, rc2) \ + async_obsolete_req_fast((phoneid), (method), (arg1), (arg2), 0, 0, (rc1), (rc2), \ + NULL, NULL, NULL) +#define async_obsolete_req_2_3(phoneid, method, arg1, arg2, rc1, rc2, rc3) \ + async_obsolete_req_fast((phoneid), (method), (arg1), (arg2), 0, 0, (rc1), (rc2), \ + (rc3), NULL, NULL) +#define async_obsolete_req_2_4(phoneid, method, arg1, arg2, rc1, rc2, rc3, rc4) \ + async_obsolete_req_fast((phoneid), (method), (arg1), (arg2), 0, 0, (rc1), (rc2), \ + (rc3), (rc4), NULL) +#define async_obsolete_req_2_5(phoneid, method, arg1, arg2, rc1, rc2, rc3, rc4, rc5) \ + async_obsolete_req_fast((phoneid), (method), (arg1), (arg2), 0, 0, (rc1), (rc2), \ + (rc3), (rc4), (rc5)) +#define async_obsolete_req_3_0(phoneid, method, arg1, arg2, arg3) \ + async_obsolete_req_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, NULL, NULL, \ + NULL, NULL, NULL) +#define async_obsolete_req_3_1(phoneid, method, arg1, arg2, arg3, rc1) \ + async_obsolete_req_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, (rc1), \ + NULL, NULL, NULL, NULL) +#define async_obsolete_req_3_2(phoneid, method, arg1, arg2, arg3, rc1, rc2) \ + async_obsolete_req_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, (rc1), \ + (rc2), NULL, NULL, NULL) +#define async_obsolete_req_3_3(phoneid, method, arg1, arg2, arg3, rc1, rc2, rc3) \ + async_obsolete_req_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, (rc1), \ + (rc2), (rc3), NULL, NULL) +#define async_obsolete_req_3_4(phoneid, method, arg1, arg2, arg3, rc1, rc2, rc3, rc4) \ + async_obsolete_req_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, (rc1), \ + (rc2), (rc3), (rc4), NULL) +#define async_obsolete_req_3_5(phoneid, method, arg1, arg2, arg3, rc1, rc2, rc3, rc4, \ + rc5) \ + async_obsolete_req_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, (rc1), \ + (rc2), (rc3), (rc4), (rc5)) +#define async_obsolete_req_4_0(phoneid, method, arg1, arg2, arg3, arg4) \ + async_obsolete_req_fast((phoneid), (method), (arg1), (arg2), (arg3), (arg4), NULL, \ + NULL, NULL, NULL, NULL) +#define async_obsolete_req_4_1(phoneid, method, arg1, arg2, arg3, arg4, rc1) \ + async_obsolete_req_fast((phoneid), (method), (arg1), (arg2), (arg3), (arg4), (rc1), \ + NULL, NULL, NULL, NULL) +#define async_obsolete_req_4_2(phoneid, method, arg1, arg2, arg3, arg4, rc1, rc2) \ + async_obsolete_req_fast((phoneid), (method), (arg1), (arg2), (arg3), (arg4), (rc1), \ + (rc2), NULL, NULL, NULL) +#define async_obsolete_req_4_3(phoneid, method, arg1, arg2, arg3, arg4, rc1, rc2, rc3) \ + async_obsolete_req_fast((phoneid), (method), (arg1), (arg2), (arg3), (arg4), (rc1), \ + (rc2), (rc3), NULL, NULL) +#define async_obsolete_req_4_4(phoneid, method, arg1, arg2, arg3, arg4, rc1, rc2, rc3, \ + rc4) \ + async_obsolete_req_fast((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \ + (rc1), (rc2), (rc3), (rc4), NULL) +#define async_obsolete_req_4_5(phoneid, method, arg1, arg2, arg3, arg4, rc1, rc2, rc3, \ + rc4, rc5) \ + async_obsolete_req_fast((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \ + (rc1), (rc2), (rc3), (rc4), (rc5)) +#define async_obsolete_req_5_0(phoneid, method, arg1, arg2, arg3, arg4, arg5) \ + async_obsolete_req_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \ + (arg5), NULL, NULL, NULL, NULL, NULL) +#define async_obsolete_req_5_1(phoneid, method, arg1, arg2, arg3, arg4, arg5, rc1) \ + async_obsolete_req_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \ + (arg5), (rc1), NULL, NULL, NULL, NULL) +#define async_obsolete_req_5_2(phoneid, method, arg1, arg2, arg3, arg4, arg5, rc1, rc2) \ + async_obsolete_req_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \ + (arg5), (rc1), (rc2), NULL, NULL, NULL) +#define async_obsolete_req_5_3(phoneid, method, arg1, arg2, arg3, arg4, arg5, rc1, rc2, \ + rc3) \ + async_obsolete_req_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \ + (arg5), (rc1), (rc2), (rc3), NULL, NULL) +#define async_obsolete_req_5_4(phoneid, method, arg1, arg2, arg3, arg4, arg5, rc1, rc2, \ + rc3, rc4) \ + async_obsolete_req_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \ + (arg5), (rc1), (rc2), (rc3), (rc4), NULL) +#define async_obsolete_req_5_5(phoneid, method, arg1, arg2, arg3, arg4, arg5, rc1, rc2, \ + rc3, rc4, rc5) \ + async_obsolete_req_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \ + (arg5), (rc1), (rc2), (rc3), (rc4), (rc5)) + +extern sysarg_t async_obsolete_req_fast(int phoneid, sysarg_t method, sysarg_t arg1, + sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t *r1, sysarg_t *r2, + sysarg_t *r3, sysarg_t *r4, sysarg_t *r5); +extern sysarg_t async_obsolete_req_slow(int phoneid, sysarg_t method, sysarg_t arg1, + sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, sysarg_t *r1, + sysarg_t *r2, sysarg_t *r3, sysarg_t *r4, sysarg_t *r5); + +extern void async_obsolete_msg_0(int, sysarg_t); +extern void async_obsolete_msg_1(int, sysarg_t, sysarg_t); +extern void async_obsolete_msg_2(int, sysarg_t, sysarg_t, sysarg_t); +extern void async_obsolete_msg_3(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t); +extern void async_obsolete_msg_4(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t, sysarg_t); +extern void async_obsolete_msg_5(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t, sysarg_t, + sysarg_t); + +extern int async_obsolete_forward_slow(ipc_callid_t, int, sysarg_t, sysarg_t, sysarg_t, + sysarg_t, sysarg_t, sysarg_t, unsigned int); + +extern int async_obsolete_connect_to_me(int, sysarg_t, sysarg_t, sysarg_t, + async_client_conn_t); +extern int async_obsolete_connect_me_to(int, sysarg_t, sysarg_t, sysarg_t); +extern int async_obsolete_connect_me_to_blocking(int, sysarg_t, sysarg_t, sysarg_t); +extern int async_obsolete_hangup(int); + +#define async_obsolete_share_in_start_0_0(phoneid, dst, size) \ + async_obsolete_share_in_start((phoneid), (dst), (size), 0, NULL) +#define async_obsolete_share_in_start_0_1(phoneid, dst, size, flags) \ + async_obsolete_share_in_start((phoneid), (dst), (size), 0, (flags)) +#define async_obsolete_share_in_start_1_0(phoneid, dst, size, arg) \ + async_obsolete_share_in_start((phoneid), (dst), (size), (arg), NULL) +#define async_obsolete_share_in_start_1_1(phoneid, dst, size, arg, flags) \ + async_obsolete_share_in_start((phoneid), (dst), (size), (arg), (flags)) + +extern int async_obsolete_share_in_start(int, void *, size_t, sysarg_t, + unsigned int *); +extern int async_obsolete_share_out_start(int, void *, unsigned int); + +#define async_obsolete_data_write_start(p, buf, len) \ + async_obsolete_data_write_start_generic((p), (buf), (len), IPC_XF_NONE) + +#define async_obsolete_data_read_start(p, buf, len) \ + async_obsolete_data_read_start_generic((p), (buf), (len), IPC_XF_NONE) + +#define async_obsolete_data_write_forward_0_0(phoneid, method, answer) \ + async_obsolete_data_write_forward_fast((phoneid), (method), 0, 0, 0, 0, NULL) +#define async_obsolete_data_write_forward_0_1(phoneid, method, answer) \ + async_obsolete_data_write_forward_fast((phoneid), (method), 0, 0, 0, 0, (answer)) +#define async_obsolete_data_write_forward_1_0(phoneid, method, arg1, answer) \ + async_obsolete_data_write_forward_fast((phoneid), (method), (arg1), 0, 0, 0, NULL) +#define async_obsolete_data_write_forward_1_1(phoneid, method, arg1, answer) \ + async_obsolete_data_write_forward_fast((phoneid), (method), (arg1), 0, 0, 0, \ + (answer)) +#define async_obsolete_data_write_forward_2_0(phoneid, method, arg1, arg2, answer) \ + async_obsolete_data_write_forward_fast((phoneid), (method), (arg1), (arg2), 0, 0, \ + NULL) +#define async_obsolete_data_write_forward_2_1(phoneid, method, arg1, arg2, answer) \ + async_obsolete_data_write_forward_fast((phoneid), (method), (arg1), (arg2), 0, 0, \ + (answer)) +#define async_obsolete_data_write_forward_3_0(phoneid, method, arg1, arg2, arg3, answer) \ + async_obsolete_data_write_forward_fast((phoneid), (method), (arg1), (arg2), (arg3), \ + 0, NULL) +#define async_obsolete_data_write_forward_3_1(phoneid, method, arg1, arg2, arg3, answer) \ + async_obsolete_data_write_forward_fast((phoneid), (method), (arg1), (arg2), (arg3), \ + 0, (answer)) +#define async_obsolete_data_write_forward_4_0(phoneid, method, arg1, arg2, arg3, arg4, answer) \ + async_obsolete_data_write_forward_fast((phoneid), (method), (arg1), (arg2), (arg3), \ + (arg4), NULL) +#define async_obsolete_data_write_forward_4_1(phoneid, method, arg1, arg2, arg3, arg4, answer) \ + async_obsolete_data_write_forward_fast((phoneid), (method), (arg1), (arg2), (arg3), \ + (arg4), (answer)) + +extern aid_t async_obsolete_data_read(int, void *, size_t, ipc_call_t *); +extern int async_obsolete_data_read_start_generic(int, void *, size_t, int); + +extern int async_obsolete_data_write_start_generic(int, const void *, size_t, int); +extern void async_obsolete_data_write_void(const int); + +extern int async_obsolete_forward_fast(ipc_callid_t, int, sysarg_t, sysarg_t, + sysarg_t, unsigned int); + +extern int async_obsolete_data_write_forward_fast(int, sysarg_t, sysarg_t, sysarg_t, + sysarg_t, sysarg_t, ipc_call_t *); + +#endif + +/** @} + */ Index: uspace/lib/c/include/async_sess.h =================================================================== --- uspace/lib/c/include/async_sess.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ (revision ) @@ -1,55 +1,0 @@ -/* - * Copyright (c) 2010 Jakub Jermar - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup libc - * @{ - */ -/** @file - */ - -#ifndef LIBC_ASYNC_SESS_H_ -#define LIBC_ASYNC_SESS_H_ - -#include - -typedef struct { - int sess_phone; /**< Phone for cloning off the connections. */ - sysarg_t connect_arg1; /**< Argument for CONNECT_ME_TO. */ - link_t conn_head; /**< List of open data connections. */ - link_t sess_link; /**< Link in global list of open sessions. */ -} async_sess_t; - -extern void async_session_create(async_sess_t *, int, sysarg_t); -extern void async_session_destroy(async_sess_t *); -extern int async_exchange_begin(async_sess_t *); -extern void async_exchange_end(async_sess_t *, int); - -#endif - -/** @} - */ Index: uspace/lib/c/include/device/char_dev.h =================================================================== --- uspace/lib/c/include/device/char_dev.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/include/device/char_dev.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -36,4 +36,6 @@ #define LIBC_DEVICE_CHAR_DEV_H_ +#include + typedef enum { CHAR_DEV_READ = 0, @@ -41,6 +43,6 @@ } char_dev_method_t; -ssize_t char_dev_read(int dev_phone, void *buf, size_t len); -ssize_t char_dev_write(int dev_phone, void *buf, size_t len); +extern ssize_t char_dev_read(async_sess_t *, void *, size_t); +extern ssize_t char_dev_write(async_sess_t *, void *, size_t); #endif Index: uspace/lib/c/include/device/hw_res.h =================================================================== --- uspace/lib/c/include/device/hw_res.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/include/device/hw_res.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -26,5 +26,5 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ - + /** @addtogroup libc * @{ @@ -32,9 +32,10 @@ /** @file */ - + #ifndef LIBC_DEVICE_HW_RES_H_ #define LIBC_DEVICE_HW_RES_H_ #include +#include #include @@ -48,5 +49,5 @@ typedef enum { INTERRUPT, - IO_RANGE, + IO_RANGE, MEM_RANGE } hw_res_type_t; @@ -66,5 +67,5 @@ size_t size; } mem_range; - + struct { uint64_t address; @@ -72,5 +73,5 @@ size_t size; } io_range; - + struct { int irq; @@ -88,13 +89,12 @@ if (hw_res->resources != NULL) { free(hw_res->resources); - hw_res->resources = NULL; } - + hw_res->count = 0; } -extern int hw_res_get_resource_list(int, hw_resource_list_t *); -extern bool hw_res_enable_interrupt(int); +extern int hw_res_get_resource_list(async_sess_t *, hw_resource_list_t *); +extern bool hw_res_enable_interrupt(async_sess_t *); #endif Index: uspace/lib/c/include/devman.h =================================================================== --- uspace/lib/c/include/devman.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/include/devman.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -41,6 +41,7 @@ #include -extern int devman_get_phone(devman_interface_t, unsigned int); -extern void devman_hangup_phone(devman_interface_t); +extern async_exch_t *devman_exchange_begin_blocking(devman_interface_t); +extern async_exch_t *devman_exchange_begin(devman_interface_t); +extern void devman_exchange_end(async_exch_t *); extern int devman_driver_register(const char *, async_client_conn_t); @@ -48,6 +49,8 @@ devman_handle_t, devman_handle_t *); -extern int devman_device_connect(devman_handle_t, unsigned int); -extern int devman_parent_device_connect(devman_handle_t, unsigned int); +extern async_sess_t *devman_device_connect(exch_mgmt_t, devman_handle_t, + unsigned int); +extern async_sess_t *devman_parent_device_connect(exch_mgmt_t, devman_handle_t, + unsigned int); extern int devman_device_get_handle(const char *, devman_handle_t *, @@ -55,4 +58,5 @@ extern int devman_device_get_handle_by_class(const char *, const char *, devman_handle_t *, unsigned int); +extern int devman_get_device_path(devman_handle_t, char *, size_t); extern int devman_add_device_to_class(devman_handle_t, const char *); Index: uspace/lib/c/include/devman_obsolete.h =================================================================== --- uspace/lib/c/include/devman_obsolete.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/c/include/devman_obsolete.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2009 Jiri Svoboda + * Copyright (c) 2010 Lenka Trochtova + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libc + * @{ + */ +/** @file + */ + +#ifndef LIBC_DEVMAN_OBSOLETE_H_ +#define LIBC_DEVMAN_OBSOLETE_H_ + +#include +#include +#include + +extern int devman_obsolete_get_phone(devman_interface_t, unsigned int); +extern void devman_obsolete_hangup_phone(devman_interface_t); + +extern int devman_obsolete_device_connect(devman_handle_t, unsigned int); +extern int devman_obsolete_parent_device_connect(devman_handle_t, unsigned int); + +#endif + +/** @} + */ Index: uspace/lib/c/include/devmap.h =================================================================== --- uspace/lib/c/include/devmap.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/include/devmap.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -40,16 +40,21 @@ #include -extern int devmap_get_phone(devmap_interface_t, unsigned int); -extern void devmap_hangup_phone(devmap_interface_t iface); +extern async_exch_t *devmap_exchange_begin_blocking(devmap_interface_t); +extern async_exch_t *devmap_exchange_begin(devmap_interface_t); +extern void devmap_exchange_end(async_exch_t *); extern int devmap_driver_register(const char *, async_client_conn_t); extern int devmap_device_register(const char *, devmap_handle_t *); -extern int devmap_device_register_with_iface(const char *, devmap_handle_t *, sysarg_t); +extern int devmap_device_register_with_iface(const char *, devmap_handle_t *, + sysarg_t); -extern int devmap_device_get_handle(const char *, devmap_handle_t *, unsigned int); -extern int devmap_namespace_get_handle(const char *, devmap_handle_t *, unsigned int); +extern int devmap_device_get_handle(const char *, devmap_handle_t *, + unsigned int); +extern int devmap_namespace_get_handle(const char *, devmap_handle_t *, + unsigned int); extern devmap_handle_type_t devmap_handle_probe(devmap_handle_t); -extern int devmap_device_connect(devmap_handle_t, unsigned int); +extern async_sess_t *devmap_device_connect(exch_mgmt_t, devmap_handle_t, + unsigned int); extern int devmap_null_create(void); Index: uspace/lib/c/include/devmap_obsolete.h =================================================================== --- uspace/lib/c/include/devmap_obsolete.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/c/include/devmap_obsolete.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2009 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libc + * @{ + */ +/** @file + */ + +#ifndef LIBC_DEVMAP_OBSOLETE_H_ +#define LIBC_DEVMAP_OBSOLETE_H_ + +#include +#include +#include + +extern int devmap_obsolete_get_phone(devmap_interface_t, unsigned int); +extern void devmap_obsolete_hangup_phone(devmap_interface_t iface); + +extern int devmap_obsolete_device_connect(devmap_handle_t, unsigned int); + +#endif + +/** @} + */ Index: uspace/lib/c/include/errno.h =================================================================== --- uspace/lib/c/include/errno.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/include/errno.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -56,4 +56,16 @@ #define EMLINK (-266) +/** Bad checksum. */ +#define EBADCHECKSUM (-300) + +/** USB: stalled operation. */ +#define ESTALL (-301) + +/** Empty resource (no data). */ +#define EEMPTY (-302) + +/** Negative acknowledgment. */ +#define ENAK (-303) + /** An API function is called while another blocking function is in progress. */ #define EINPROGRESS (-10036) Index: uspace/lib/c/include/io/console.h =================================================================== --- uspace/lib/c/include/io/console.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/include/io/console.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -36,10 +36,8 @@ #define LIBC_IO_CONSOLE_H_ +#include +#include #include - -typedef enum { - KEY_PRESS, - KEY_RELEASE -} console_ev_type_t; +#include typedef enum { @@ -50,8 +48,34 @@ } console_caps_t; +/** Console control structure. */ +typedef struct { + /** Console input file */ + FILE *input; + + /** Console output file */ + FILE *output; + + /** Console input session */ + async_sess_t *input_sess; + + /** Console output session */ + async_sess_t *output_sess; + + /** Input request call with timeout */ + ipc_call_t input_call; + + /** Input response with timeout */ + aid_t input_aid; +} console_ctrl_t; + +typedef enum { + KEY_PRESS, + KEY_RELEASE +} kbd_event_type_t; + /** Console event structure. */ typedef struct { /** Press or release event. */ - console_ev_type_t type; + kbd_event_type_t type; /** Keycode of the key that was pressed or released. */ @@ -63,22 +87,26 @@ /** The character that was generated or '\0' for none. */ wchar_t c; -} console_event_t; +} kbd_event_t; -extern void console_clear(int phone); +extern console_ctrl_t *console_init(FILE *, FILE *); +extern void console_done(console_ctrl_t *); +extern bool console_kcon(void); -extern int console_get_size(int phone, sysarg_t *cols, sysarg_t *rows); -extern int console_get_pos(int phone, sysarg_t *col, sysarg_t *row); -extern void console_set_pos(int phone, sysarg_t col, sysarg_t row); +extern void console_flush(console_ctrl_t *); +extern void console_clear(console_ctrl_t *); -extern void console_set_style(int phone, uint8_t style); -extern void console_set_color(int phone, uint8_t fg_color, uint8_t bg_color, - uint8_t flags); -extern void console_set_rgb_color(int phone, uint32_t fg_color, uint32_t bg_color); +extern int console_get_size(console_ctrl_t *, sysarg_t *, sysarg_t *); +extern int console_get_pos(console_ctrl_t *, sysarg_t *, sysarg_t *); +extern void console_set_pos(console_ctrl_t *, sysarg_t, sysarg_t); -extern void console_cursor_visibility(int phone, bool show); -extern int console_get_color_cap(int phone, sysarg_t *ccap); -extern void console_kcon_enable(int phone); +extern void console_set_style(console_ctrl_t *, uint8_t); +extern void console_set_color(console_ctrl_t *, uint8_t, uint8_t, uint8_t); +extern void console_set_rgb_color(console_ctrl_t *, uint32_t, uint32_t); -extern bool console_get_event(int phone, console_event_t *event); +extern void console_cursor_visibility(console_ctrl_t *, bool); +extern int console_get_color_cap(console_ctrl_t *, sysarg_t *); +extern bool console_get_kbd_event(console_ctrl_t *, kbd_event_t *); +extern bool console_get_kbd_event_timeout(console_ctrl_t *, kbd_event_t *, + suseconds_t *); #endif Index: uspace/lib/c/include/ipc/dev_iface.h =================================================================== --- uspace/lib/c/include/ipc/dev_iface.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/include/ipc/dev_iface.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -37,4 +37,15 @@ HW_RES_DEV_IFACE = 0, CHAR_DEV_IFACE, + + /** Interface provided by any PCI device. */ + PCI_DEV_IFACE, + + /** Interface provided by any USB device. */ + USB_DEV_IFACE, + /** Interface provided by USB host controller. */ + USBHC_DEV_IFACE, + /** Interface provided by USB HID devices. */ + USBHID_DEV_IFACE, + DEV_IFACE_MAX } dev_inferface_idx_t; @@ -48,4 +59,14 @@ DEV_IFACE_ID(DEV_FIRST_CUSTOM_METHOD_IDX) +/* + * The first argument is actually method (as the "real" method is used + * for indexing into interfaces. + */ + +#define DEV_IPC_GET_ARG1(call) IPC_GET_ARG2((call)) +#define DEV_IPC_GET_ARG2(call) IPC_GET_ARG3((call)) +#define DEV_IPC_GET_ARG3(call) IPC_GET_ARG4((call)) +#define DEV_IPC_GET_ARG4(call) IPC_GET_ARG5((call)) + #endif Index: uspace/lib/c/include/ipc/devman.h =================================================================== --- uspace/lib/c/include/ipc/devman.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/include/ipc/devman.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -149,5 +149,6 @@ typedef enum { DEVMAN_DEVICE_GET_HANDLE = IPC_FIRST_USER_METHOD, - DEVMAN_DEVICE_GET_HANDLE_BY_CLASS + DEVMAN_DEVICE_GET_HANDLE_BY_CLASS, + DEVMAN_DEVICE_GET_DEVICE_PATH } client_to_devman_t; Index: uspace/lib/c/include/ipc/devmap.h =================================================================== --- uspace/lib/c/include/ipc/devmap.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/include/ipc/devmap.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -31,6 +31,6 @@ */ -#ifndef DEVMAP_DEVMAP_H_ -#define DEVMAP_DEVMAP_H_ +#ifndef LIBC_IPC_DEVMAP_H_ +#define LIBC_IPC_DEVMAP_H_ #include Index: uspace/lib/c/include/ipc/ipc.h =================================================================== --- uspace/lib/c/include/ipc/ipc.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/include/ipc/ipc.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -42,4 +42,5 @@ #include #include +#include #include #include @@ -255,4 +256,5 @@ extern int ipc_connect_to_me(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t *, sysarg_t *); +extern int ipc_connect_me(int); extern int ipc_connect_me_to(int, sysarg_t, sysarg_t, sysarg_t); extern int ipc_connect_me_to_blocking(int, sysarg_t, sysarg_t, sysarg_t); Index: uspace/lib/c/include/ipc/kbd.h =================================================================== --- uspace/lib/c/include/ipc/kbd.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/include/ipc/kbd.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -39,7 +39,8 @@ #include +#include typedef enum { - KBD_YIELD = IPC_FIRST_USER_METHOD, + KBD_YIELD = DEV_FIRST_CUSTOM_METHOD, KBD_RECLAIM } kbd_request_t; Index: uspace/lib/c/include/ipc/ns.h =================================================================== --- uspace/lib/c/include/ipc/ns.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/include/ipc/ns.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -33,8 +33,7 @@ */ -#ifndef LIBC_NS_H_ -#define LIBC_NS_H_ +#ifndef LIBC_IPC_NS_H_ +#define LIBC_IPC_NS_H_ -#include #include @@ -46,8 +45,4 @@ } ns_request_t; -extern int service_register(sysarg_t); -extern int service_connect(sysarg_t, sysarg_t, sysarg_t); -extern int service_connect_blocking(sysarg_t, sysarg_t, sysarg_t); - #endif Index: uspace/lib/c/include/ipc/serial_ctl.h =================================================================== --- uspace/lib/c/include/ipc/serial_ctl.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/include/ipc/serial_ctl.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -32,11 +32,13 @@ #include -/** ipc methods for getting/setting serial communication properties - * 1st ipc arg: baud rate - * 2nd ipc arg: parity - * 3rd ipc arg: number of bits in one word - * 4th ipc arg: number of stop bits +/** IPC methods for getting/setting serial communication properties + * + * 1st IPC arg: baud rate + * 2nd IPC arg: parity + * 3rd IPC arg: number of bits in one word + * 4th IPC arg: number of stop bits + * */ -typedef enum { +typedef enum { SERIAL_GET_COM_PROPS = DEV_FIRST_CUSTOM_METHOD, SERIAL_SET_COM_PROPS @@ -48,5 +50,5 @@ SERIAL_EVEN_PARITY = 3, SERIAL_MARK_PARITY = 5, - SERIAL_SPACE_PARITY = 7 + SERIAL_SPACE_PARITY = 7 } serial_parity_t; Index: uspace/lib/c/include/ipc/vfs.h =================================================================== --- uspace/lib/c/include/ipc/vfs.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/include/ipc/vfs.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -69,4 +69,5 @@ VFS_IN_FSTAT, VFS_IN_CLOSE, + VFS_IN_PING, VFS_IN_MOUNT, VFS_IN_UNMOUNT, Index: uspace/lib/c/include/l18n/langs.h =================================================================== --- uspace/lib/c/include/l18n/langs.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/c/include/l18n/langs.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,64 @@ +/* + * Copyright (c) 2005 Jakub Jermar + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libc + * @{ + */ +/** @file + * Language and locale ids. + */ + +#ifndef LIBC_L18N_LANGS_H_ +#define LIBC_L18N_LANGS_H_ + +/** Windows locale IDs. + * Codes taken from + * Developing International Software For Windows 95 and Windows NT + * by Nadine Kano (Microsoft Press). + * FIXME: add missing codes. + */ +typedef enum { + L18N_WIN_LOCALE_AFRIKAANS = 0x0436, + /* ... */ + L18N_WIN_LOCALE_CZECH = 0x0405, + /* ... */ + L18N_WIN_LOCALE_ENGLISH_UNITED_STATES = 0x0409, + /* ... */ + L18N_WIN_LOCALE_SLOVAK = 0x041B, + /* ... */ + L18N_WIN_LOCALE_SPANISH_TRADITIONAL = 0x040A, + /* ... */ + L18N_WIN_LOCALE_ZULU = 0x0435 +} l18_win_locales_t; + +const char *str_l18_win_locale(l18_win_locales_t); + +#endif + +/** @} + */ Index: uspace/lib/c/include/loader/loader.h =================================================================== --- uspace/lib/c/include/loader/loader.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/include/loader/loader.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -40,9 +40,7 @@ #include -/** Abstraction of a loader connection */ -typedef struct { - /** ID of the phone connected to the loader. */ - int phone_id; -} loader_t; +/** Forward declararion */ +struct loader; +typedef struct loader loader_t; extern int loader_spawn(const char *); Index: uspace/lib/c/include/ns.h =================================================================== --- uspace/lib/c/include/ns.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/c/include/ns.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2006 Ondrej Palkovsky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libc + * @{ + */ +/** @file + */ + +#ifndef LIBC_NS_H_ +#define LIBC_NS_H_ + +#include +#include +#include + +extern int service_register(sysarg_t); +extern async_sess_t *service_connect(exch_mgmt_t, sysarg_t, sysarg_t, sysarg_t); +extern async_sess_t *service_connect_blocking(exch_mgmt_t, sysarg_t, sysarg_t, + sysarg_t); + +extern int ns_ping(void); +extern int ns_intro(task_id_t); + +#endif + +/** @} + */ Index: uspace/lib/c/include/ns_obsolete.h =================================================================== --- uspace/lib/c/include/ns_obsolete.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/c/include/ns_obsolete.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2006 Ondrej Palkovsky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libc + * @{ + */ +/** @file + */ + +#ifndef LIBC_NS_OBSOLETE_H_ +#define LIBC_NS_OBSOLETE_H_ + +#include +#include + +extern int service_obsolete_connect(sysarg_t, sysarg_t, sysarg_t); +extern int service_obsolete_connect_blocking(sysarg_t, sysarg_t, + sysarg_t); + +#endif + +/** @} + */ Index: uspace/lib/c/include/stdio.h =================================================================== --- uspace/lib/c/include/stdio.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/include/stdio.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -97,47 +97,7 @@ }; -typedef struct { - /** Linked list pointer. */ - link_t link; - - /** Underlying file descriptor. */ - int fd; - - /** Error indicator. */ - int error; - - /** End-of-file indicator. */ - int eof; - - /** Klog indicator */ - int klog; - - /** Phone to the file provider */ - int phone; - - /** - * Non-zero if the stream needs sync on fflush(). XXX change - * console semantics so that sync is not needed. - */ - int need_sync; - - /** Buffering type */ - enum _buffer_type btype; - - /** Buffer */ - uint8_t *buf; - - /** Buffer size */ - size_t buf_size; - - /** Buffer state */ - enum _buffer_state buf_state; - - /** Buffer I/O pointer */ - uint8_t *buf_head; - - /** Points to end of occupied space when in read mode. */ - uint8_t *buf_tail; -} FILE; +/** Forward declaration */ +struct _IO_FILE; +typedef struct _IO_FILE FILE; extern FILE *stdin; Index: uspace/lib/c/include/sys/time.h =================================================================== --- uspace/lib/c/include/sys/time.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/include/sys/time.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -62,4 +62,6 @@ extern int gettimeofday(struct timeval *tv, struct timezone *tz); +extern void udelay(useconds_t); + #endif Index: uspace/lib/c/include/udebug.h =================================================================== --- uspace/lib/c/include/udebug.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/include/udebug.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -38,18 +38,23 @@ #include #include +#include typedef sysarg_t thash_t; -int udebug_begin(int); -int udebug_end(int); -int udebug_set_evmask(int, udebug_evmask_t); -int udebug_thread_read(int, void *, size_t , size_t *, size_t *); -int udebug_name_read(int, void *, size_t, size_t *, size_t *); -int udebug_areas_read(int, void *, size_t, size_t *, size_t *); -int udebug_mem_read(int, void *, uintptr_t, size_t); -int udebug_args_read(int, thash_t, sysarg_t *); -int udebug_regs_read(int, thash_t, void *); -int udebug_go(int, thash_t, udebug_event_t *, sysarg_t *, sysarg_t *); -int udebug_stop(int, thash_t); +extern int udebug_begin(async_sess_t *); +extern int udebug_end(async_sess_t *); +extern int udebug_set_evmask(async_sess_t *, udebug_evmask_t); +extern int udebug_thread_read(async_sess_t *, void *, size_t , size_t *, + size_t *); +extern int udebug_name_read(async_sess_t *, void *, size_t, size_t *, + size_t *); +extern int udebug_areas_read(async_sess_t *, void *, size_t, size_t *, + size_t *); +extern int udebug_mem_read(async_sess_t *, void *, uintptr_t, size_t); +extern int udebug_args_read(async_sess_t *, thash_t, sysarg_t *); +extern int udebug_regs_read(async_sess_t *, thash_t, void *); +extern int udebug_go(async_sess_t *, thash_t, udebug_event_t *, sysarg_t *, + sysarg_t *); +extern int udebug_stop(async_sess_t *, thash_t); #endif Index: uspace/lib/c/include/vfs/vfs.h =================================================================== --- uspace/lib/c/include/vfs/vfs.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/c/include/vfs/vfs.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -41,7 +41,9 @@ #include -/** - * This type is a libc version of the VFS triplet. - * It uniquely identifies a file system node within a file system instance. +/** Libc version of the VFS triplet. + * + * Unique identification of a file system node + * within a file system instance. + * */ typedef struct { @@ -58,9 +60,7 @@ extern int open_node(fdi_node_t *, int); -extern int fd_phone(int); extern int fd_node(int, fdi_node_t *); extern FILE *fopen_node(fdi_node_t *, const char *); -extern int fphone(FILE *); extern int fnode(FILE *, fdi_node_t *); Index: uspace/lib/c/include/vfs/vfs_sess.h =================================================================== --- uspace/lib/c/include/vfs/vfs_sess.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/c/include/vfs/vfs_sess.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2007 Jakub Jermar + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libc + * @{ + */ +/** @file + */ + +#ifndef LIBC_VFS_SESS_H_ +#define LIBC_VFS_SESS_H_ + +#include +#include + +extern async_sess_t *fd_session(exch_mgmt_t, int); +extern async_sess_t *fsession(exch_mgmt_t, FILE *); + +#endif + +/** @} + */ Index: uspace/lib/clui/tinput.c =================================================================== --- uspace/lib/clui/tinput.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/clui/tinput.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -54,8 +54,8 @@ static void tinput_sel_all(tinput_t *); static void tinput_sel_delete(tinput_t *); -static void tinput_key_ctrl(tinput_t *, console_event_t *); -static void tinput_key_shift(tinput_t *, console_event_t *); -static void tinput_key_ctrl_shift(tinput_t *, console_event_t *); -static void tinput_key_unmod(tinput_t *, console_event_t *); +static void tinput_key_ctrl(tinput_t *, kbd_event_t *); +static void tinput_key_shift(tinput_t *, kbd_event_t *); +static void tinput_key_ctrl_shift(tinput_t *, kbd_event_t *); +static void tinput_key_unmod(tinput_t *, kbd_event_t *); static void tinput_pre_seek(tinput_t *, bool); static void tinput_post_seek(tinput_t *, bool); @@ -88,7 +88,7 @@ tinput_sel_get_bounds(ti, &sa, &sb); - console_set_pos(fphone(stdout), (ti->col0 + start) % ti->con_cols, + console_set_pos(ti->console, (ti->col0 + start) % ti->con_cols, ti->row0 + (ti->col0 + start) / ti->con_cols); - console_set_style(fphone(stdout), STYLE_NORMAL); + console_set_style(ti->console, STYLE_NORMAL); size_t p = start; @@ -101,6 +101,7 @@ if (p < sb) { - fflush(stdout); - console_set_style(fphone(stdout), STYLE_SELECTED); + console_flush(ti->console); + console_set_style(ti->console, STYLE_SELECTED); + memcpy(dbuf, ti->buffer + p, (sb - p) * sizeof(wchar_t)); @@ -110,6 +111,6 @@ } - fflush(stdout); - console_set_style(fphone(stdout), STYLE_NORMAL); + console_flush(ti->console); + console_set_style(ti->console, STYLE_NORMAL); if (p < ti->nc) { @@ -123,5 +124,5 @@ putchar(' '); - fflush(stdout); + console_flush(ti->console); } @@ -133,5 +134,5 @@ static void tinput_position_caret(tinput_t *ti) { - console_set_pos(fphone(stdout), (ti->col0 + ti->pos) % ti->con_cols, + console_set_pos(ti->console, (ti->col0 + ti->pos) % ti->con_cols, ti->row0 + (ti->col0 + ti->pos) / ti->con_cols); } @@ -516,4 +517,5 @@ static void tinput_init(tinput_t *ti) { + ti->console = console_init(stdin, stdout); ti->hnum = 0; ti->hpos = 0; @@ -533,9 +535,9 @@ int tinput_read(tinput_t *ti, char **dstr) { - fflush(stdout); - if (console_get_size(fphone(stdin), &ti->con_cols, &ti->con_rows) != EOK) + console_flush(ti->console); + if (console_get_size(ti->console, &ti->con_cols, &ti->con_rows) != EOK) return EIO; - if (console_get_pos(fphone(stdin), &ti->col0, &ti->row0) != EOK) + if (console_get_pos(ti->console, &ti->col0, &ti->row0) != EOK) return EIO; @@ -548,8 +550,8 @@ while (!ti->done) { - fflush(stdout); - - console_event_t ev; - if (!console_get_event(fphone(stdin), &ev)) + console_flush(ti->console); + + kbd_event_t ev; + if (!console_get_kbd_event(ti->console, &ev)) return EIO; @@ -596,5 +598,5 @@ } -static void tinput_key_ctrl(tinput_t *ti, console_event_t *ev) +static void tinput_key_ctrl(tinput_t *ti, kbd_event_t *ev) { switch (ev->key) { @@ -635,5 +637,5 @@ } -static void tinput_key_ctrl_shift(tinput_t *ti, console_event_t *ev) +static void tinput_key_ctrl_shift(tinput_t *ti, kbd_event_t *ev) { switch (ev->key) { @@ -655,5 +657,5 @@ } -static void tinput_key_shift(tinput_t *ti, console_event_t *ev) +static void tinput_key_shift(tinput_t *ti, kbd_event_t *ev) { switch (ev->key) { @@ -681,5 +683,5 @@ } -static void tinput_key_unmod(tinput_t *ti, console_event_t *ev) +static void tinput_key_unmod(tinput_t *ti, kbd_event_t *ev) { switch (ev->key) { Index: uspace/lib/clui/tinput.h =================================================================== --- uspace/lib/clui/tinput.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/clui/tinput.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -37,4 +37,9 @@ #define LIBCLUI_TINPUT_H_ +#include +#include +#include +#include + #define HISTORY_LEN 10 #define INPUT_MAX_SIZE 1024 @@ -45,4 +50,7 @@ */ typedef struct { + /** Console */ + console_ctrl_t *console; + /** Buffer holding text currently being edited */ wchar_t buffer[INPUT_MAX_SIZE + 1]; Index: uspace/lib/drv/Makefile =================================================================== --- uspace/lib/drv/Makefile (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/drv/Makefile (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -29,5 +29,5 @@ USPACE_PREFIX = ../.. -EXTRA_CFLAGS = -Iinclude +EXTRA_CFLAGS = -Iinclude -I$(LIBUSB_PREFIX)/include LIBRARY = libdrv @@ -37,5 +37,9 @@ generic/log.c \ generic/remote_hw_res.c \ - generic/remote_char_dev.c + generic/remote_char_dev.c \ + generic/remote_usb.c \ + generic/remote_pci.c \ + generic/remote_usbhc.c \ + generic/remote_usbhid.c include $(USPACE_PREFIX)/Makefile.common Index: uspace/lib/drv/generic/dev_iface.c =================================================================== --- uspace/lib/drv/generic/dev_iface.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/drv/generic/dev_iface.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -41,9 +41,19 @@ #include "remote_hw_res.h" #include "remote_char_dev.h" +#include "remote_usb.h" +#include "remote_usbhc.h" +#include "remote_usbhid.h" +#include "remote_pci.h" + +#include static iface_dipatch_table_t remote_ifaces = { .ifaces = { &remote_hw_res_iface, - &remote_char_dev_iface + &remote_char_dev_iface, + &remote_pci_iface, + &remote_usb_iface, + &remote_usbhc_iface, + &remote_usbhid_iface } }; Index: uspace/lib/drv/generic/driver.c =================================================================== --- uspace/lib/drv/generic/driver.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/drv/generic/driver.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -285,13 +285,12 @@ async_answer_0(iid, EOK); - bool cont = true; - while (cont) { + while (true) { ipc_call_t call; ipc_callid_t callid = async_get_call(&call); + if (!IPC_GET_IMETHOD(call)) + break; + switch (IPC_GET_IMETHOD(call)) { - case IPC_M_PHONE_HUNGUP: - cont = false; - continue; case DRIVER_ADD_DEVICE: driver_add_device(callid, &call); @@ -303,9 +302,9 @@ } -/** - * Generic client connection handler both for applications and drivers. - * - * @param drv True for driver client, false for other clients - * (applications, services etc.). +/** Generic client connection handler both for applications and drivers. + * + * @param drv True for driver client, false for other clients + * (applications, services, etc.). + * */ static void driver_connection_gen(ipc_callid_t iid, ipc_call_t *icall, bool drv) @@ -317,5 +316,5 @@ devman_handle_t handle = IPC_GET_ARG2(*icall); ddf_fun_t *fun = driver_get_function(&functions, handle); - + if (fun == NULL) { printf("%s: driver_connection_gen error - no function with handle" @@ -325,5 +324,4 @@ } - /* * TODO - if the client is not a driver, check whether it is allowed to @@ -340,13 +338,11 @@ return; - while (1) { + while (true) { ipc_callid_t callid; ipc_call_t call; callid = async_get_call(&call); sysarg_t method = IPC_GET_IMETHOD(call); - int iface_idx; - - switch (method) { - case IPC_M_PHONE_HUNGUP: + + if (!method) { /* Close device function */ if (fun->ops != NULL && fun->ops->close != NULL) @@ -354,69 +350,68 @@ async_answer_0(callid, EOK); return; - default: - /* convert ipc interface id to interface index */ - - iface_idx = DEV_IFACE_IDX(method); - - if (!is_valid_iface_idx(iface_idx)) { - remote_handler_t *default_handler = - function_get_default_handler(fun); - if (default_handler != NULL) { - (*default_handler)(fun, callid, &call); - break; - } - - /* - * Function has no such interface and - * default handler is not provided. - */ - printf("%s: driver_connection_gen error - " - "invalid interface id %d.", - driver->name, iface_idx); - async_answer_0(callid, ENOTSUP); - break; - } - - /* calling one of the function's interfaces */ - - /* Get the interface ops structure. */ - void *ops = function_get_ops(fun, iface_idx); - if (ops == NULL) { - printf("%s: driver_connection_gen error - ", - driver->name); - printf("Function with handle %" PRIun " has no interface " - "with id %d.\n", handle, iface_idx); - async_answer_0(callid, ENOTSUP); + } + + /* Convert ipc interface id to interface index */ + + int iface_idx = DEV_IFACE_IDX(method); + + if (!is_valid_iface_idx(iface_idx)) { + remote_handler_t *default_handler = + function_get_default_handler(fun); + if (default_handler != NULL) { + (*default_handler)(fun, callid, &call); break; } /* - * Get the corresponding interface for remote request - * handling ("remote interface"). + * Function has no such interface and + * default handler is not provided. */ - remote_iface_t *rem_iface = get_remote_iface(iface_idx); - assert(rem_iface != NULL); - - /* get the method of the remote interface */ - sysarg_t iface_method_idx = IPC_GET_ARG1(call); - remote_iface_func_ptr_t iface_method_ptr = - get_remote_method(rem_iface, iface_method_idx); - if (iface_method_ptr == NULL) { - /* The interface has not such method */ - printf("%s: driver_connection_gen error - " - "invalid interface method.", driver->name); - async_answer_0(callid, ENOTSUP); - break; - } - - /* - * Call the remote interface's method, which will - * receive parameters from the remote client and it will - * pass it to the corresponding local interface method - * associated with the function by its driver. - */ - (*iface_method_ptr)(fun, ops, callid, &call); + printf("%s: driver_connection_gen error - " + "invalid interface id %d.", + driver->name, iface_idx); + async_answer_0(callid, ENOTSUP); break; } + + /* Calling one of the function's interfaces */ + + /* Get the interface ops structure. */ + void *ops = function_get_ops(fun, iface_idx); + if (ops == NULL) { + printf("%s: driver_connection_gen error - ", driver->name); + printf("Function with handle %" PRIun " has no interface " + "with id %d.\n", handle, iface_idx); + async_answer_0(callid, ENOTSUP); + break; + } + + /* + * Get the corresponding interface for remote request + * handling ("remote interface"). + */ + remote_iface_t *rem_iface = get_remote_iface(iface_idx); + assert(rem_iface != NULL); + + /* get the method of the remote interface */ + sysarg_t iface_method_idx = IPC_GET_ARG1(call); + remote_iface_func_ptr_t iface_method_ptr = + get_remote_method(rem_iface, iface_method_idx); + if (iface_method_ptr == NULL) { + /* The interface has not such method */ + printf("%s: driver_connection_gen error - " + "invalid interface method.", driver->name); + async_answer_0(callid, ENOTSUP); + break; + } + + /* + * Call the remote interface's method, which will + * receive parameters from the remote client and it will + * pass it to the corresponding local interface method + * associated with the function by its driver. + */ + (*iface_method_ptr)(fun, ops, callid, &call); + break; } } Index: uspace/lib/drv/generic/remote_pci.c =================================================================== --- uspace/lib/drv/generic/remote_pci.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/drv/generic/remote_pci.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,179 @@ +/* + * Copyright (c) 2011 Jan Vesely + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libdrv + * @{ + */ +/** @file + */ +#include +#include +#include + +#include "pci_dev_iface.h" +#include "ddf/driver.h" + +static void remote_config_space_read_8(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_config_space_read_16(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_config_space_read_32(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); + +static void remote_config_space_write_8(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_config_space_write_16(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_config_space_write_32(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); + +/** Remote USB interface operations. */ +static remote_iface_func_ptr_t remote_pci_iface_ops [] = { + remote_config_space_read_8, + remote_config_space_read_16, + remote_config_space_read_32, + + remote_config_space_write_8, + remote_config_space_write_16, + remote_config_space_write_32 +}; + +/** Remote USB interface structure. + */ +remote_iface_t remote_pci_iface = { + .method_count = sizeof(remote_pci_iface_ops) / + sizeof(remote_pci_iface_ops[0]), + .methods = remote_pci_iface_ops +}; + +void remote_config_space_read_8(ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call) +{ + assert(iface); + pci_dev_iface_t *pci_iface = (pci_dev_iface_t *)iface; + if (pci_iface->config_space_read_8 == NULL) { + async_answer_0(callid, ENOTSUP); + return; + } + uint32_t address = DEV_IPC_GET_ARG1(*call); + uint8_t value; + int ret = pci_iface->config_space_read_8(fun, address, &value); + if (ret != EOK) { + async_answer_0(callid, ret); + } else { + async_answer_1(callid, EOK, value); + } +} + +void remote_config_space_read_16(ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call) +{ + assert(iface); + pci_dev_iface_t *pci_iface = (pci_dev_iface_t *)iface; + if (pci_iface->config_space_read_16 == NULL) { + async_answer_0(callid, ENOTSUP); + return; + } + uint32_t address = DEV_IPC_GET_ARG1(*call); + uint16_t value; + int ret = pci_iface->config_space_read_16(fun, address, &value); + if (ret != EOK) { + async_answer_0(callid, ret); + } else { + async_answer_1(callid, EOK, value); + } +} +void remote_config_space_read_32(ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call) +{ + assert(iface); + pci_dev_iface_t *pci_iface = (pci_dev_iface_t *)iface; + if (pci_iface->config_space_read_32 == NULL) { + async_answer_0(callid, ENOTSUP); + return; + } + uint32_t address = DEV_IPC_GET_ARG1(*call); + uint32_t value; + int ret = pci_iface->config_space_read_32(fun, address, &value); + if (ret != EOK) { + async_answer_0(callid, ret); + } else { + async_answer_1(callid, EOK, value); + } +} + +void remote_config_space_write_8(ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call) +{ + assert(iface); + pci_dev_iface_t *pci_iface = (pci_dev_iface_t *)iface; + if (pci_iface->config_space_write_8 == NULL) { + async_answer_0(callid, ENOTSUP); + return; + } + uint32_t address = DEV_IPC_GET_ARG1(*call); + uint8_t value = DEV_IPC_GET_ARG2(*call); + int ret = pci_iface->config_space_write_8(fun, address, value); + if (ret != EOK) { + async_answer_0(callid, ret); + } else { + async_answer_0(callid, EOK); + } +} + +void remote_config_space_write_16(ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call) +{ + assert(iface); + pci_dev_iface_t *pci_iface = (pci_dev_iface_t *)iface; + if (pci_iface->config_space_write_16 == NULL) { + async_answer_0(callid, ENOTSUP); + return; + } + uint32_t address = DEV_IPC_GET_ARG1(*call); + uint16_t value = DEV_IPC_GET_ARG2(*call); + int ret = pci_iface->config_space_write_16(fun, address, value); + if (ret != EOK) { + async_answer_0(callid, ret); + } else { + async_answer_0(callid, EOK); + } +} + +void remote_config_space_write_32(ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call) +{ + assert(iface); + pci_dev_iface_t *pci_iface = (pci_dev_iface_t *)iface; + if (pci_iface->config_space_write_32 == NULL) { + async_answer_0(callid, ENOTSUP); + return; + } + uint32_t address = DEV_IPC_GET_ARG1(*call); + uint32_t value = DEV_IPC_GET_ARG2(*call); + int ret = pci_iface->config_space_write_32(fun, address, value); + if (ret != EOK) { + async_answer_0(callid, ret); + } else { + async_answer_0(callid, EOK); + } +} + + +/** + * @} + */ + Index: uspace/lib/drv/generic/remote_usb.c =================================================================== --- uspace/lib/drv/generic/remote_usb.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/drv/generic/remote_usb.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,128 @@ +/* + * Copyright (c) 2010 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libdrv + * @{ + */ +/** @file + */ + +#include +#include + +#include "usb_iface.h" +#include "ddf/driver.h" + + +static void remote_usb_get_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_usb_get_interface(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_usb_get_hc_handle(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); +//static void remote_usb(device_t *, void *, ipc_callid_t, ipc_call_t *); + +/** Remote USB interface operations. */ +static remote_iface_func_ptr_t remote_usb_iface_ops [] = { + remote_usb_get_address, + remote_usb_get_interface, + remote_usb_get_hc_handle +}; + +/** Remote USB interface structure. + */ +remote_iface_t remote_usb_iface = { + .method_count = sizeof(remote_usb_iface_ops) / + sizeof(remote_usb_iface_ops[0]), + .methods = remote_usb_iface_ops +}; + + +void remote_usb_get_address(ddf_fun_t *fun, void *iface, + ipc_callid_t callid, ipc_call_t *call) +{ + usb_iface_t *usb_iface = (usb_iface_t *) iface; + + if (usb_iface->get_address == NULL) { + async_answer_0(callid, ENOTSUP); + return; + } + + devman_handle_t handle = DEV_IPC_GET_ARG1(*call); + + usb_address_t address; + int rc = usb_iface->get_address(fun, handle, &address); + if (rc != EOK) { + async_answer_0(callid, rc); + } else { + async_answer_1(callid, EOK, address); + } +} + +void remote_usb_get_interface(ddf_fun_t *fun, void *iface, + ipc_callid_t callid, ipc_call_t *call) +{ + usb_iface_t *usb_iface = (usb_iface_t *) iface; + + if (usb_iface->get_interface == NULL) { + async_answer_0(callid, ENOTSUP); + return; + } + + devman_handle_t handle = DEV_IPC_GET_ARG1(*call); + + int iface_no; + int rc = usb_iface->get_interface(fun, handle, &iface_no); + if (rc != EOK) { + async_answer_0(callid, rc); + } else { + async_answer_1(callid, EOK, iface_no); + } +} + +void remote_usb_get_hc_handle(ddf_fun_t *fun, void *iface, + ipc_callid_t callid, ipc_call_t *call) +{ + usb_iface_t *usb_iface = (usb_iface_t *) iface; + + if (usb_iface->get_hc_handle == NULL) { + async_answer_0(callid, ENOTSUP); + return; + } + + devman_handle_t handle; + int rc = usb_iface->get_hc_handle(fun, &handle); + if (rc != EOK) { + async_answer_0(callid, rc); + } + + async_answer_1(callid, EOK, (sysarg_t) handle); +} + + + +/** + * @} + */ Index: uspace/lib/drv/generic/remote_usbhc.c =================================================================== --- uspace/lib/drv/generic/remote_usbhc.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/drv/generic/remote_usbhc.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,583 @@ +/* + * Copyright (c) 2010-2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libdrv + * @{ + */ +/** @file + */ + +#include +#include +#include + +#include "usbhc_iface.h" +#include "ddf/driver.h" + +#define USB_MAX_PAYLOAD_SIZE 1020 +#define HACK_MAX_PACKET_SIZE 8 +#define HACK_MAX_PACKET_SIZE_INTERRUPT_IN 4 + +static void remote_usbhc_interrupt_out(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_usbhc_interrupt_in(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_usbhc_bulk_out(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_usbhc_bulk_in(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_usbhc_control_write(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_usbhc_control_read(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_usbhc_request_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_usbhc_bind_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_usbhc_find_by_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_usbhc_release_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_usbhc_register_endpoint(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_usbhc_unregister_endpoint(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); +//static void remote_usbhc(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); + +/** Remote USB host controller interface operations. */ +static remote_iface_func_ptr_t remote_usbhc_iface_ops [] = { + remote_usbhc_request_address, + remote_usbhc_bind_address, + remote_usbhc_find_by_address, + remote_usbhc_release_address, + + remote_usbhc_interrupt_out, + remote_usbhc_interrupt_in, + + remote_usbhc_bulk_out, + remote_usbhc_bulk_in, + + remote_usbhc_control_write, + remote_usbhc_control_read, + + remote_usbhc_register_endpoint, + remote_usbhc_unregister_endpoint +}; + +/** Remote USB host controller interface structure. + */ +remote_iface_t remote_usbhc_iface = { + .method_count = sizeof(remote_usbhc_iface_ops) / + sizeof(remote_usbhc_iface_ops[0]), + .methods = remote_usbhc_iface_ops +}; + +typedef struct { + ipc_callid_t caller; + ipc_callid_t data_caller; + void *buffer; + void *setup_packet; + size_t size; +} async_transaction_t; + +static void async_transaction_destroy(async_transaction_t *trans) +{ + if (trans == NULL) { + return; + } + + if (trans->setup_packet != NULL) { + free(trans->setup_packet); + } + if (trans->buffer != NULL) { + free(trans->buffer); + } + + free(trans); +} + +static async_transaction_t *async_transaction_create(ipc_callid_t caller) +{ + async_transaction_t *trans = malloc(sizeof(async_transaction_t)); + if (trans == NULL) { + return NULL; + } + + trans->caller = caller; + trans->data_caller = 0; + trans->buffer = NULL; + trans->setup_packet = NULL; + trans->size = 0; + + return trans; +} + +void remote_usbhc_request_address(ddf_fun_t *fun, void *iface, + ipc_callid_t callid, ipc_call_t *call) +{ + usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; + + if (!usb_iface->request_address) { + async_answer_0(callid, ENOTSUP); + return; + } + + usb_speed_t speed = DEV_IPC_GET_ARG1(*call); + + usb_address_t address; + int rc = usb_iface->request_address(fun, speed, &address); + if (rc != EOK) { + async_answer_0(callid, rc); + } else { + async_answer_1(callid, EOK, (sysarg_t) address); + } +} + +void remote_usbhc_bind_address(ddf_fun_t *fun, void *iface, + ipc_callid_t callid, ipc_call_t *call) +{ + usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; + + if (!usb_iface->bind_address) { + async_answer_0(callid, ENOTSUP); + return; + } + + usb_address_t address = (usb_address_t) DEV_IPC_GET_ARG1(*call); + devman_handle_t handle = (devman_handle_t) DEV_IPC_GET_ARG2(*call); + + int rc = usb_iface->bind_address(fun, address, handle); + + async_answer_0(callid, rc); +} + +void remote_usbhc_find_by_address(ddf_fun_t *fun, void *iface, + ipc_callid_t callid, ipc_call_t *call) +{ + usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; + + if (!usb_iface->find_by_address) { + async_answer_0(callid, ENOTSUP); + return; + } + + usb_address_t address = (usb_address_t) DEV_IPC_GET_ARG1(*call); + devman_handle_t handle; + int rc = usb_iface->find_by_address(fun, address, &handle); + + if (rc == EOK) { + async_answer_1(callid, EOK, handle); + } else { + async_answer_0(callid, rc); + } +} + +void remote_usbhc_release_address(ddf_fun_t *fun, void *iface, + ipc_callid_t callid, ipc_call_t *call) +{ + usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; + + if (!usb_iface->release_address) { + async_answer_0(callid, ENOTSUP); + return; + } + + usb_address_t address = (usb_address_t) DEV_IPC_GET_ARG1(*call); + + int rc = usb_iface->release_address(fun, address); + + async_answer_0(callid, rc); +} + + +static void callback_out(ddf_fun_t *fun, + int outcome, void *arg) +{ + async_transaction_t *trans = (async_transaction_t *)arg; + + async_answer_0(trans->caller, outcome); + + async_transaction_destroy(trans); +} + +static void callback_in(ddf_fun_t *fun, + int outcome, size_t actual_size, void *arg) +{ + async_transaction_t *trans = (async_transaction_t *)arg; + + if (outcome != EOK) { + async_answer_0(trans->caller, outcome); + if (trans->data_caller) { + async_answer_0(trans->data_caller, EINTR); + } + async_transaction_destroy(trans); + return; + } + + trans->size = actual_size; + + if (trans->data_caller) { + async_data_read_finalize(trans->data_caller, + trans->buffer, actual_size); + } + + async_answer_0(trans->caller, EOK); + + async_transaction_destroy(trans); +} + +/** Process an outgoing transfer (both OUT and SETUP). + * + * @param device Target device. + * @param callid Initiating caller. + * @param call Initiating call. + * @param transfer_func Transfer function (might be NULL). + */ +static void remote_usbhc_out_transfer(ddf_fun_t *fun, + ipc_callid_t callid, ipc_call_t *call, + usbhc_iface_transfer_out_t transfer_func) +{ + if (!transfer_func) { + async_answer_0(callid, ENOTSUP); + return; + } + + usb_target_t target = { + .address = DEV_IPC_GET_ARG1(*call), + .endpoint = DEV_IPC_GET_ARG2(*call) + }; + + size_t len = 0; + void *buffer = NULL; + + int rc = async_data_write_accept(&buffer, false, + 1, USB_MAX_PAYLOAD_SIZE, + 0, &len); + + if (rc != EOK) { + async_answer_0(callid, rc); + return; + } + + async_transaction_t *trans = async_transaction_create(callid); + if (trans == NULL) { + if (buffer != NULL) { + free(buffer); + } + async_answer_0(callid, ENOMEM); + return; + } + + trans->buffer = buffer; + trans->size = len; + + rc = transfer_func(fun, target, + buffer, len, + callback_out, trans); + + if (rc != EOK) { + async_answer_0(callid, rc); + async_transaction_destroy(trans); + } +} + +/** Process an incoming transfer. + * + * @param device Target device. + * @param callid Initiating caller. + * @param call Initiating call. + * @param transfer_func Transfer function (might be NULL). + */ +static void remote_usbhc_in_transfer(ddf_fun_t *fun, + ipc_callid_t callid, ipc_call_t *call, + usbhc_iface_transfer_in_t transfer_func) +{ + if (!transfer_func) { + async_answer_0(callid, ENOTSUP); + return; + } + + usb_target_t target = { + .address = DEV_IPC_GET_ARG1(*call), + .endpoint = DEV_IPC_GET_ARG2(*call) + }; + + size_t len; + ipc_callid_t data_callid; + if (!async_data_read_receive(&data_callid, &len)) { + async_answer_0(callid, EPARTY); + return; + } + + async_transaction_t *trans = async_transaction_create(callid); + if (trans == NULL) { + async_answer_0(data_callid, ENOMEM); + async_answer_0(callid, ENOMEM); + return; + } + trans->data_caller = data_callid; + trans->buffer = malloc(len); + trans->size = len; + + int rc = transfer_func(fun, target, + trans->buffer, len, + callback_in, trans); + + if (rc != EOK) { + async_answer_0(data_callid, rc); + async_answer_0(callid, rc); + async_transaction_destroy(trans); + } +} + +void remote_usbhc_interrupt_out(ddf_fun_t *fun, void *iface, + ipc_callid_t callid, ipc_call_t *call) +{ + usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; + assert(usb_iface != NULL); + + return remote_usbhc_out_transfer(fun, callid, call, + usb_iface->interrupt_out); +} + +void remote_usbhc_interrupt_in(ddf_fun_t *fun, void *iface, + ipc_callid_t callid, ipc_call_t *call) +{ + usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; + assert(usb_iface != NULL); + + return remote_usbhc_in_transfer(fun, callid, call, + usb_iface->interrupt_in); +} + +void remote_usbhc_bulk_out(ddf_fun_t *fun, void *iface, + ipc_callid_t callid, ipc_call_t *call) +{ + usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; + assert(usb_iface != NULL); + + return remote_usbhc_out_transfer(fun, callid, call, + usb_iface->bulk_out); +} + +void remote_usbhc_bulk_in(ddf_fun_t *fun, void *iface, + ipc_callid_t callid, ipc_call_t *call) +{ + usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; + assert(usb_iface != NULL); + + return remote_usbhc_in_transfer(fun, callid, call, + usb_iface->bulk_in); +} + +void remote_usbhc_control_write(ddf_fun_t *fun, void *iface, +ipc_callid_t callid, ipc_call_t *call) +{ + usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; + assert(usb_iface != NULL); + + if (!usb_iface->control_write) { + async_answer_0(callid, ENOTSUP); + return; + } + + usb_target_t target = { + .address = DEV_IPC_GET_ARG1(*call), + .endpoint = DEV_IPC_GET_ARG2(*call) + }; + size_t data_buffer_len = DEV_IPC_GET_ARG3(*call); + + int rc; + + void *setup_packet = NULL; + void *data_buffer = NULL; + size_t setup_packet_len = 0; + + rc = async_data_write_accept(&setup_packet, false, + 1, USB_MAX_PAYLOAD_SIZE, 0, &setup_packet_len); + if (rc != EOK) { + async_answer_0(callid, rc); + return; + } + + if (data_buffer_len > 0) { + rc = async_data_write_accept(&data_buffer, false, + 1, USB_MAX_PAYLOAD_SIZE, 0, &data_buffer_len); + if (rc != EOK) { + async_answer_0(callid, rc); + free(setup_packet); + return; + } + } + + async_transaction_t *trans = async_transaction_create(callid); + if (trans == NULL) { + async_answer_0(callid, ENOMEM); + free(setup_packet); + free(data_buffer); + return; + } + trans->setup_packet = setup_packet; + trans->buffer = data_buffer; + trans->size = data_buffer_len; + + rc = usb_iface->control_write(fun, target, + setup_packet, setup_packet_len, + data_buffer, data_buffer_len, + callback_out, trans); + + if (rc != EOK) { + async_answer_0(callid, rc); + async_transaction_destroy(trans); + } +} + + +void remote_usbhc_control_read(ddf_fun_t *fun, void *iface, +ipc_callid_t callid, ipc_call_t *call) +{ + usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; + assert(usb_iface != NULL); + + if (!usb_iface->control_read) { + async_answer_0(callid, ENOTSUP); + return; + } + + usb_target_t target = { + .address = DEV_IPC_GET_ARG1(*call), + .endpoint = DEV_IPC_GET_ARG2(*call) + }; + + int rc; + + void *setup_packet = NULL; + size_t setup_packet_len = 0; + size_t data_len = 0; + + rc = async_data_write_accept(&setup_packet, false, + 1, USB_MAX_PAYLOAD_SIZE, 0, &setup_packet_len); + if (rc != EOK) { + async_answer_0(callid, rc); + return; + } + + ipc_callid_t data_callid; + if (!async_data_read_receive(&data_callid, &data_len)) { + async_answer_0(callid, EPARTY); + free(setup_packet); + return; + } + + async_transaction_t *trans = async_transaction_create(callid); + if (trans == NULL) { + async_answer_0(data_callid, ENOMEM); + async_answer_0(callid, ENOMEM); + free(setup_packet); + return; + } + trans->data_caller = data_callid; + trans->setup_packet = setup_packet; + trans->size = data_len; + trans->buffer = malloc(data_len); + if (trans->buffer == NULL) { + async_answer_0(data_callid, ENOMEM); + async_answer_0(callid, ENOMEM); + async_transaction_destroy(trans); + return; + } + + rc = usb_iface->control_read(fun, target, + setup_packet, setup_packet_len, + trans->buffer, trans->size, + callback_in, trans); + + if (rc != EOK) { + async_answer_0(data_callid, rc); + async_answer_0(callid, rc); + async_transaction_destroy(trans); + } +} + + +void remote_usbhc_register_endpoint(ddf_fun_t *fun, void *iface, + ipc_callid_t callid, ipc_call_t *call) +{ + usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; + + if (!usb_iface->register_endpoint) { + async_answer_0(callid, ENOTSUP); + return; + } + +#define _INIT_FROM_HIGH_DATA2(type, var, arg_no) \ + type var = (type) DEV_IPC_GET_ARG##arg_no(*call) / (1 << 16) +#define _INIT_FROM_LOW_DATA2(type, var, arg_no) \ + type var = (type) DEV_IPC_GET_ARG##arg_no(*call) % (1 << 16) +#define _INIT_FROM_HIGH_DATA3(type, var, arg_no) \ + type var = (type) DEV_IPC_GET_ARG##arg_no(*call) / (1 << 16) +#define _INIT_FROM_MIDDLE_DATA3(type, var, arg_no) \ + type var = (type) (DEV_IPC_GET_ARG##arg_no(*call) / (1 << 8)) % (1 << 8) +#define _INIT_FROM_LOW_DATA3(type, var, arg_no) \ + type var = (type) DEV_IPC_GET_ARG##arg_no(*call) % (1 << 8) + + _INIT_FROM_HIGH_DATA2(usb_address_t, address, 1); + _INIT_FROM_LOW_DATA2(usb_endpoint_t, endpoint, 1); + + _INIT_FROM_HIGH_DATA3(usb_speed_t, speed, 2); + _INIT_FROM_MIDDLE_DATA3(usb_transfer_type_t, transfer_type, 2); + _INIT_FROM_LOW_DATA3(usb_direction_t, direction, 2); + + _INIT_FROM_HIGH_DATA2(size_t, max_packet_size, 3); + _INIT_FROM_LOW_DATA2(unsigned int, interval, 3); + +#undef _INIT_FROM_HIGH_DATA2 +#undef _INIT_FROM_LOW_DATA2 +#undef _INIT_FROM_HIGH_DATA3 +#undef _INIT_FROM_MIDDLE_DATA3 +#undef _INIT_FROM_LOW_DATA3 + + int rc = usb_iface->register_endpoint(fun, address, speed, endpoint, + transfer_type, direction, max_packet_size, interval); + + async_answer_0(callid, rc); +} + + +void remote_usbhc_unregister_endpoint(ddf_fun_t *fun, void *iface, + ipc_callid_t callid, ipc_call_t *call) +{ + usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; + + if (!usb_iface->unregister_endpoint) { + async_answer_0(callid, ENOTSUP); + return; + } + + usb_address_t address = (usb_address_t) DEV_IPC_GET_ARG1(*call); + usb_endpoint_t endpoint = (usb_endpoint_t) DEV_IPC_GET_ARG2(*call); + usb_direction_t direction = (usb_direction_t) DEV_IPC_GET_ARG3(*call); + + int rc = usb_iface->unregister_endpoint(fun, + address, endpoint, direction); + + async_answer_0(callid, rc); +} + + +/** + * @} + */ Index: uspace/lib/drv/generic/remote_usbhid.c =================================================================== --- uspace/lib/drv/generic/remote_usbhid.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/drv/generic/remote_usbhid.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,220 @@ +/* + * Copyright (c) 2010-2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libdrv + * @{ + */ +/** @file + */ + +#include +#include +#include +#include + +#include "usbhid_iface.h" +#include "ddf/driver.h" + +static void remote_usbhid_get_event_length(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_usbhid_get_event(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_usbhid_get_report_descriptor_length(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_usbhid_get_report_descriptor(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); +// static void remote_usbhid_(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); + +/** Remote USB HID interface operations. */ +static remote_iface_func_ptr_t remote_usbhid_iface_ops [] = { + remote_usbhid_get_event_length, + remote_usbhid_get_event, + remote_usbhid_get_report_descriptor_length, + remote_usbhid_get_report_descriptor +}; + +/** Remote USB HID interface structure. + */ +remote_iface_t remote_usbhid_iface = { + .method_count = sizeof(remote_usbhid_iface_ops) / + sizeof(remote_usbhid_iface_ops[0]), + .methods = remote_usbhid_iface_ops +}; + +//usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; + + +void remote_usbhid_get_event_length(ddf_fun_t *fun, void *iface, + ipc_callid_t callid, ipc_call_t *call) +{ + printf("remote_usbhid_get_event_length()\n"); + + usbhid_iface_t *hid_iface = (usbhid_iface_t *) iface; + + if (!hid_iface->get_event_length) { + printf("Get event length not set!\n"); + async_answer_0(callid, ENOTSUP); + return; + } + + size_t len = hid_iface->get_event_length(fun); +// if (len == 0) { +// len = EEMPTY; +// } + async_answer_1(callid, EOK, len); + +// if (len < 0) { +// async_answer_0(callid, len); +// } else { +// async_answer_1(callid, EOK, len); +// } +} + +void remote_usbhid_get_event(ddf_fun_t *fun, void *iface, + ipc_callid_t callid, ipc_call_t *call) +{ + usbhid_iface_t *hid_iface = (usbhid_iface_t *) iface; + + if (!hid_iface->get_event) { + async_answer_0(callid, ENOTSUP); + return; + } + + unsigned int flags = DEV_IPC_GET_ARG1(*call); + + size_t len; + ipc_callid_t data_callid; + if (!async_data_read_receive(&data_callid, &len)) { + async_answer_0(callid, EPARTY); + return; + } +// /* Check that length is even number. Truncate otherwise. */ +// if ((len % 2) == 1) { +// len--; +// } + if (len == 0) { + async_answer_0(data_callid, EINVAL); + async_answer_0(callid, EINVAL); + return; + } + + int rc; + + uint8_t *data = malloc(len); + if (data == NULL) { + async_answer_0(data_callid, ENOMEM); + async_answer_0(callid, ENOMEM); + return; + } + + size_t act_length; + int event_nr; + rc = hid_iface->get_event(fun, data, len, &act_length, &event_nr, flags); + if (rc != EOK) { + free(data); + async_answer_0(data_callid, rc); + async_answer_0(callid, rc); + return; + } + if (act_length >= len) { + /* This shall not happen. */ + // FIXME: how about an assert here? + act_length = len; + } + + async_data_read_finalize(data_callid, data, act_length); + + free(data); + + async_answer_1(callid, EOK, event_nr); +} + +void remote_usbhid_get_report_descriptor_length(ddf_fun_t *fun, void *iface, + ipc_callid_t callid, ipc_call_t *call) +{ + usbhid_iface_t *hid_iface = (usbhid_iface_t *) iface; + + if (!hid_iface->get_report_descriptor_length) { + async_answer_0(callid, ENOTSUP); + return; + } + + size_t len = hid_iface->get_report_descriptor_length(fun); + async_answer_1(callid, EOK, (sysarg_t) len); +} + +void remote_usbhid_get_report_descriptor(ddf_fun_t *fun, void *iface, + ipc_callid_t callid, ipc_call_t *call) +{ + usbhid_iface_t *hid_iface = (usbhid_iface_t *) iface; + + if (!hid_iface->get_report_descriptor) { + async_answer_0(callid, ENOTSUP); + return; + } + + size_t len; + ipc_callid_t data_callid; + if (!async_data_read_receive(&data_callid, &len)) { + async_answer_0(callid, EINVAL); + return; + } + + if (len == 0) { + async_answer_0(data_callid, EINVAL); + async_answer_0(callid, EINVAL); + return; + } + + uint8_t *descriptor = malloc(len); + if (descriptor == NULL) { + async_answer_0(data_callid, ENOMEM); + async_answer_0(callid, ENOMEM); + return; + } + + size_t act_len = 0; + int rc = hid_iface->get_report_descriptor(fun, descriptor, len, + &act_len); + if (act_len > len) { + rc = ELIMIT; + } + if (rc != EOK) { + free(descriptor); + async_answer_0(data_callid, rc); + async_answer_0(callid, rc); + return; + } + + async_data_read_finalize(data_callid, descriptor, act_len); + async_answer_0(callid, EOK); + + free(descriptor); +} + + + +/** + * @} + */ Index: uspace/lib/drv/include/ddf/driver.h =================================================================== --- uspace/lib/drv/include/ddf/driver.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/drv/include/ddf/driver.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -37,7 +37,7 @@ #define DDF_DRIVER_H_ +#include #include #include - #include "../dev_iface.h" @@ -83,8 +83,8 @@ /** - * Phone to the parent device driver (if it is different from this + * Session to the parent device driver (if it is different from this * driver) */ - int parent_phone; + async_sess_t *parent_sess; /** Device name */ Index: uspace/lib/drv/include/pci_dev_iface.h =================================================================== --- uspace/lib/drv/include/pci_dev_iface.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/drv/include/pci_dev_iface.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2011 Jan Vesely + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libdrv + * @addtogroup usb + * @{ + */ +/** @file + * @brief PCI device interface definition. + */ + +#ifndef LIBDRV_PCI_DEV_IFACE_H_ +#define LIBDRV_PCI_DEV_IFACE_H_ + +#include "ddf/driver.h" + +typedef enum { + IPC_M_CONFIG_SPACE_READ_8, + IPC_M_CONFIG_SPACE_READ_16, + IPC_M_CONFIG_SPACE_READ_32, + + IPC_M_CONFIG_SPACE_WRITE_8, + IPC_M_CONFIG_SPACE_WRITE_16, + IPC_M_CONFIG_SPACE_WRITE_32 +} pci_dev_iface_funcs_t; + +/** PCI device communication interface. */ +typedef struct { + int (*config_space_read_8)(ddf_fun_t *, uint32_t address, uint8_t *data); + int (*config_space_read_16)(ddf_fun_t *, uint32_t address, uint16_t *data); + int (*config_space_read_32)(ddf_fun_t *, uint32_t address, uint32_t *data); + + int (*config_space_write_8)(ddf_fun_t *, uint32_t address, uint8_t data); + int (*config_space_write_16)(ddf_fun_t *, uint32_t address, uint16_t data); + int (*config_space_write_32)(ddf_fun_t *, uint32_t address, uint32_t data); +} pci_dev_iface_t; + + +#endif +/** + * @} + */ + Index: uspace/lib/drv/include/remote_pci.h =================================================================== --- uspace/lib/drv/include/remote_pci.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/drv/include/remote_pci.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2011 Jan Vesely + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libdrv + * @{ + */ +/** @file + */ + +#ifndef LIBDRV_REMOTE_PCI_H_ +#define LIBDRV_REMOTE_PCI_H_ + +extern remote_iface_t remote_pci_iface; + +#endif + +/** + * @} + */ + Index: uspace/lib/drv/include/remote_usb.h =================================================================== --- uspace/lib/drv/include/remote_usb.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/drv/include/remote_usb.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2010 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libdrv + * @{ + */ +/** @file + */ + +#ifndef LIBDRV_REMOTE_USB_H_ +#define LIBDRV_REMOTE_USB_H_ + +extern remote_iface_t remote_usb_iface; + +#endif + +/** + * @} + */ Index: uspace/lib/drv/include/remote_usbhc.h =================================================================== --- uspace/lib/drv/include/remote_usbhc.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/drv/include/remote_usbhc.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2010 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libdrv + * @{ + */ +/** @file + */ + +#ifndef LIBDRV_REMOTE_USBHC_H_ +#define LIBDRV_REMOTE_USBHC_H_ + +extern remote_iface_t remote_usbhc_iface; + +#endif + +/** + * @} + */ Index: uspace/lib/drv/include/remote_usbhid.h =================================================================== --- uspace/lib/drv/include/remote_usbhid.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/drv/include/remote_usbhid.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libdrv + * @{ + */ +/** @file + */ + +#ifndef LIBDRV_REMOTE_USBHID_H_ +#define LIBDRV_REMOTE_USBHID_H_ + +extern remote_iface_t remote_usbhid_iface; + +#endif + +/** + * @} + */ Index: uspace/lib/drv/include/usb_iface.h =================================================================== --- uspace/lib/drv/include/usb_iface.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/drv/include/usb_iface.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,101 @@ +/* + * Copyright (c) 2010 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libdrv + * @addtogroup usb + * @{ + */ +/** @file + * @brief USB interface definition. + */ + +#ifndef LIBDRV_USB_IFACE_H_ +#define LIBDRV_USB_IFACE_H_ + +#include "ddf/driver.h" +#include +typedef enum { + /** Tell USB address assigned to device. + * Parameters: + * - devman handle id + * Answer: + * - EINVAL - unknown handle or handle not managed by this driver + * - ENOTSUP - operation not supported (shall not happen) + * - arbitrary error code if returned by remote implementation + * - EOK - handle found, first parameter contains the USB address + * + * The handle must be the one used for binding USB address with + * it (IPC_M_USBHC_BIND_ADDRESS), otherwise the host controller + * (that this request would eventually reach) would not be able + * to find it. + * The problem is that this handle is actually assigned to the + * function inside driver of the parent device (usually hub driver). + * To bypass this problem, the initial caller specify handle as + * zero and the first parent assigns the actual value. + * See usb_iface_get_address_hub_child_impl() implementation + * that could be assigned to device ops of a child device of in a + * hub driver. + * For example, the USB multi interface device driver (MID) + * passes this initial zero without any modification because the + * handle must be resolved by its parent. + */ + IPC_M_USB_GET_ADDRESS, + + /** Tell interface number given device can use. + * Parameters + * - devman handle id of the device + * Answer: + * - ENOTSUP - operation not supported (can also mean any interface) + * - EOK - operation okay, first parameter contains interface number + */ + IPC_M_USB_GET_INTERFACE, + + /** Tell devman handle of device host controller. + * Parameters: + * - none + * Answer: + * - EOK - request processed without errors + * - ENOTSUP - this indicates invalid USB driver + * Parameters of the answer: + * - devman handle of HC caller is physically connected to + */ + IPC_M_USB_GET_HOST_CONTROLLER_HANDLE +} usb_iface_funcs_t; + +/** USB device communication interface. */ +typedef struct { + int (*get_address)(ddf_fun_t *, devman_handle_t, usb_address_t *); + int (*get_interface)(ddf_fun_t *, devman_handle_t, int *); + int (*get_hc_handle)(ddf_fun_t *, devman_handle_t *); +} usb_iface_t; + + +#endif +/** + * @} + */ Index: uspace/lib/drv/include/usbhc_iface.h =================================================================== --- uspace/lib/drv/include/usbhc_iface.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/drv/include/usbhc_iface.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,244 @@ +/* + * Copyright (c) 2010 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libdrv + * @addtogroup usb + * @{ + */ +/** @file + * @brief USB host controller interface definition. + */ + +#ifndef LIBDRV_USBHC_IFACE_H_ +#define LIBDRV_USBHC_IFACE_H_ + +#include "ddf/driver.h" +#include +#include + + +/** IPC methods for communication with HC through DDF interface. + * + * Notes for async methods: + * + * Methods for sending data to device (OUT transactions) + * - e.g. IPC_M_USBHC_INTERRUPT_OUT - + * always use the same semantics: + * - first, IPC call with given method is made + * - argument #1 is target address + * - argument #2 is target endpoint + * - argument #3 is max packet size of the endpoint + * - this call is immediately followed by IPC data write (from caller) + * - the initial call (and the whole transaction) is answer after the + * transaction is scheduled by the HC and acknowledged by the device + * or immediately after error is detected + * - the answer carries only the error code + * + * Methods for retrieving data from device (IN transactions) + * - e.g. IPC_M_USBHC_INTERRUPT_IN - + * also use the same semantics: + * - first, IPC call with given method is made + * - argument #1 is target address + * - argument #2 is target endpoint + * - this call is immediately followed by IPC data read (async version) + * - the call is not answered until the device returns some data (or until + * error occurs) + * + * Some special methods (NO-DATA transactions) do not send any data. These + * might behave as both OUT or IN transactions because communication parts + * where actual buffers are exchanged are omitted. + ** + * For all these methods, wrap functions exists. Important rule: functions + * for IN transactions have (as parameters) buffers where retrieved data + * will be stored. These buffers must be already allocated and shall not be + * touch until the transaction is completed + * (e.g. not before calling usb_wait_for() with appropriate handle). + * OUT transactions buffers can be freed immediately after call is dispatched + * (i.e. after return from wrapping function). + * + */ +typedef enum { + /** Asks for address assignment by host controller. + * Answer: + * - ELIMIT - host controller run out of address + * - EOK - address assigned + * Answer arguments: + * - assigned address + * + * The address must be released by via IPC_M_USBHC_RELEASE_ADDRESS. + */ + IPC_M_USBHC_REQUEST_ADDRESS, + + /** Bind USB address with devman handle. + * Parameters: + * - USB address + * - devman handle + * Answer: + * - EOK - address binded + * - ENOENT - address is not in use + */ + IPC_M_USBHC_BIND_ADDRESS, + + /** Get handle binded with given USB address. + * Parameters + * - USB address + * Answer: + * - EOK - address binded, first parameter is the devman handle + * - ENOENT - address is not in use at the moment + */ + IPC_M_USBHC_GET_HANDLE_BY_ADDRESS, + + /** Release address in use. + * Arguments: + * - address to be released + * Answer: + * - ENOENT - address not in use + * - EPERM - trying to release default USB address + */ + IPC_M_USBHC_RELEASE_ADDRESS, + + + /** Send interrupt data to device. + * See explanation at usb_iface_funcs_t (OUT transaction). + */ + IPC_M_USBHC_INTERRUPT_OUT, + + /** Get interrupt data from device. + * See explanation at usb_iface_funcs_t (IN transaction). + */ + IPC_M_USBHC_INTERRUPT_IN, + + /** Send bulk data to device. + * See explanation at usb_iface_funcs_t (OUT transaction). + */ + IPC_M_USBHC_BULK_OUT, + + /** Get bulk data from device. + * See explanation at usb_iface_funcs_t (IN transaction). + */ + IPC_M_USBHC_BULK_IN, + + /** Issue control WRITE transfer. + * See explanation at usb_iface_funcs_t (OUT transaction) for + * call parameters. + * This call is immediately followed by two IPC data writes + * from the caller (setup packet and actual data). + */ + IPC_M_USBHC_CONTROL_WRITE, + + /** Issue control READ transfer. + * See explanation at usb_iface_funcs_t (IN transaction) for + * call parameters. + * This call is immediately followed by IPC data write from the caller + * (setup packet) and IPC data read (buffer that was read). + */ + IPC_M_USBHC_CONTROL_READ, + + /** Register endpoint attributes at host controller. + * This is used to reserve portion of USB bandwidth. + * When speed is invalid, speed of the device is used. + * Parameters: + * - USB address + endpoint number + * - packed as ADDR << 16 + EP + * - speed + transfer type + direction + * - packed as ( SPEED << 8 + TYPE ) << 8 + DIR + * - maximum packet size + interval (in milliseconds) + * - packed as MPS << 16 + INT + * Answer: + * - EOK - reservation successful + * - ELIMIT - not enough bandwidth to satisfy the request + */ + IPC_M_USBHC_REGISTER_ENDPOINT, + + /** Revert endpoint registration. + * Parameters: + * - USB address + * - endpoint number + * - data direction + * Answer: + * - EOK - endpoint unregistered + * - ENOENT - unknown endpoint + */ + IPC_M_USBHC_UNREGISTER_ENDPOINT +} usbhc_iface_funcs_t; + +/** Callback for outgoing transfer. */ +typedef void (*usbhc_iface_transfer_out_callback_t)(ddf_fun_t *, + int, void *); + +/** Callback for incoming transfer. */ +typedef void (*usbhc_iface_transfer_in_callback_t)(ddf_fun_t *, + int, size_t, void *); + + +/** Out transfer processing function prototype. */ +typedef int (*usbhc_iface_transfer_out_t)(ddf_fun_t *, usb_target_t, + void *, size_t, + usbhc_iface_transfer_out_callback_t, void *); + +/** Setup transfer processing function prototype. @deprecated */ +typedef usbhc_iface_transfer_out_t usbhc_iface_transfer_setup_t; + +/** In transfer processing function prototype. */ +typedef int (*usbhc_iface_transfer_in_t)(ddf_fun_t *, usb_target_t, + void *, size_t, + usbhc_iface_transfer_in_callback_t, void *); + +/** USB host controller communication interface. */ +typedef struct { + int (*request_address)(ddf_fun_t *, usb_speed_t, usb_address_t *); + int (*bind_address)(ddf_fun_t *, usb_address_t, devman_handle_t); + int (*find_by_address)(ddf_fun_t *, usb_address_t, devman_handle_t *); + int (*release_address)(ddf_fun_t *, usb_address_t); + + int (*register_endpoint)(ddf_fun_t *, + usb_address_t, usb_speed_t, usb_endpoint_t, + usb_transfer_type_t, usb_direction_t, size_t, unsigned int); + int (*unregister_endpoint)(ddf_fun_t *, usb_address_t, usb_endpoint_t, + usb_direction_t); + + usbhc_iface_transfer_out_t interrupt_out; + usbhc_iface_transfer_in_t interrupt_in; + + usbhc_iface_transfer_out_t bulk_out; + usbhc_iface_transfer_in_t bulk_in; + + int (*control_write)(ddf_fun_t *, usb_target_t, + void *, size_t, void *, size_t, + usbhc_iface_transfer_out_callback_t, void *); + + int (*control_read)(ddf_fun_t *, usb_target_t, + void *, size_t, void *, size_t, + usbhc_iface_transfer_in_callback_t, void *); +} usbhc_iface_t; + + +#endif +/** + * @} + */ Index: uspace/lib/drv/include/usbhid_iface.h =================================================================== --- uspace/lib/drv/include/usbhid_iface.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/drv/include/usbhid_iface.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,136 @@ +/* + * Copyright (c) 2010 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libdrv + * @{ + */ +/** @file + * USB HID interface definition. + */ + +#ifndef LIBDRV_USBHID_IFACE_H_ +#define LIBDRV_USBHID_IFACE_H_ + +#include "ddf/driver.h" +#include + +/** IPC methods for USB HID device interface. */ +typedef enum { + /** Get number of events reported in single burst. + * Parameters: none + * Answer: + * - Size of one report in bytes. + */ + IPC_M_USBHID_GET_EVENT_LENGTH, + /** Get single event from the HID device. + * The word single refers to set of individual events that were + * available at particular point in time. + * Parameters: + * - flags + * The call is followed by data read expecting two concatenated + * arrays. + * Answer: + * - EOK - events returned + * - EAGAIN - no event ready (only in non-blocking mode) + * + * It is okay if the client requests less data. Extra data must + * be truncated by the driver. + * + * @todo Change this comment. + */ + IPC_M_USBHID_GET_EVENT, + + /** Get the size of the report descriptor from the HID device. + * + * Parameters: + * - none + * Answer: + * - EOK - method is implemented (expected always) + * Parameters of the answer: + * - Size of the report in bytes. + */ + IPC_M_USBHID_GET_REPORT_DESCRIPTOR_LENGTH, + + /** Get the report descriptor from the HID device. + * + * Parameters: + * - none + * The call is followed by data read expecting the descriptor itself. + * Answer: + * - EOK - report descriptor returned. + */ + IPC_M_USBHID_GET_REPORT_DESCRIPTOR +} usbhid_iface_funcs_t; + +/** USB HID interface flag - return immediately if no data are available. */ +#define USBHID_IFACE_FLAG_NON_BLOCKING (1 << 0) + +/** USB HID device communication interface. */ +typedef struct { + /** Get size of the event in bytes. + * + * @param[in] fun DDF function answering the request. + * @return Size of the event in bytes. + */ + size_t (*get_event_length)(ddf_fun_t *fun); + + /** Get single event from the HID device. + * + * @param[in] fun DDF function answering the request. + * @param[out] buffer Buffer with raw data from the device. + * @param[out] act_size Actual number of returned events. + * @param[in] flags Flags (see USBHID_IFACE_FLAG_*). + * @return Error code. + */ + int (*get_event)(ddf_fun_t *fun, uint8_t *buffer, size_t size, + size_t *act_size, int *event_nr, unsigned int flags); + + /** Get size of the report descriptor in bytes. + * + * @param[in] fun DDF function answering the request. + * @return Size of the report descriptor in bytes. + */ + size_t (*get_report_descriptor_length)(ddf_fun_t *fun); + + /** Get the report descriptor from the HID device. + * + * @param[in] fun DDF function answering the request. + * @param[out] desc Buffer with the report descriptor. + * @param[in] size Size of the allocated @p desc buffer. + * @param[out] act_size Actual size of the report descriptor returned. + * @return Error code. + */ + int (*get_report_descriptor)(ddf_fun_t *fun, uint8_t *desc, + size_t size, size_t *act_size); +} usbhid_iface_t; + + +#endif +/** + * @} + */ Index: uspace/lib/ext2/Makefile =================================================================== --- uspace/lib/ext2/Makefile (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/ext2/Makefile (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,43 @@ +# +# Copyright (c) 2005 Martin Decky +# Copyright (c) 2007 Jakub Jermar +# Copyright (c) 2010 Martin Sucha +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# - Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# - Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# - The name of the author may not be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +USPACE_PREFIX = ../.. +LIBRARY = libext2 +EXTRA_CFLAGS = -I$(LIBBLOCK_PREFIX) +LIBS = $(LIBBLOCK_PREFIX)/libblock.a + +SOURCES = \ + libext2_filesystem.c \ + libext2_superblock.c \ + libext2_block_group.c \ + libext2_inode.c \ + libext2_directory.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/lib/ext2/libext2.h =================================================================== --- uspace/lib/ext2/libext2.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/ext2/libext2.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2011 Martin Sucha + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext2 + * @{ + */ +/** + * @file + */ + +#ifndef LIBEXT2_LIBEXT2_H_ +#define LIBEXT2_LIBEXT2_H_ + +#include "libext2_superblock.h" +#include "libext2_block_group.h" +#include "libext2_inode.h" +#include "libext2_filesystem.h" +#include "libext2_directory.h" + +#endif + +/** @} + */ Index: uspace/lib/ext2/libext2_block_group.c =================================================================== --- uspace/lib/ext2/libext2_block_group.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/ext2/libext2_block_group.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,114 @@ +/* + * Copyright (c) 2011 Martin Sucha + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext2 + * @{ + */ +/** + * @file + */ + +#include "libext2.h" +#include "libext2_block_group.h" +#include + +/** + * Get block ID corresponding to the block bitmap of this block group + * + * @param bg pointer to block group descriptor + */ +uint32_t ext2_block_group_get_block_bitmap_block(ext2_block_group_t *bg) +{ + return uint32_t_le2host(bg->block_bitmap_block); +} + +/** + * Get block ID corresponding to the inode bitmap of this block group + * + * @param bg pointer to block group descriptor + */ +uint32_t ext2_block_group_get_inode_bitmap_block(ext2_block_group_t *bg) +{ + return uint32_t_le2host(bg->inode_bitmap_block); +} + +/** + * Get block ID of first block in inode table + * + * @param bg pointer to block group descriptor + */ +uint32_t ext2_block_group_get_inode_table_first_block(ext2_block_group_t *bg) +{ + return uint32_t_le2host(bg->inode_table_first_block); +} + +/** + * Get amount of free blocks in this block group + * + * @param bg pointer to block group descriptor + */ +uint16_t ext2_block_group_get_free_block_count(ext2_block_group_t *bg) +{ + return uint16_t_le2host(bg->free_block_count); +} + +/** + * Set amount of free blocks in this block group + * + * @param bg pointer to block group descriptor + * @param val new value + */ +void ext2_block_group_set_free_block_count(ext2_block_group_t *bg, + uint16_t val) +{ + bg->free_block_count = host2uint16_t_le(val); +} + +/** + * Get amount of free inodes in this block group + * + * @param bg pointer to block group descriptor + */ +uint16_t ext2_block_group_get_free_inode_count(ext2_block_group_t *bg) +{ + return uint16_t_le2host(bg->free_inode_count); +} + +/** + * Get amount of inodes allocated for directories + * + * @param bg pointer to block group descriptor + */ +uint16_t ext2_block_group_get_directory_inode_count(ext2_block_group_t *bg) +{ + return uint16_t_le2host(bg->directory_inode_count); +} + + +/** @} + */ Index: uspace/lib/ext2/libext2_block_group.h =================================================================== --- uspace/lib/ext2/libext2_block_group.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/ext2/libext2_block_group.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,69 @@ +/* + * Copyright (c) 2011 Martin Sucha + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext2 + * @{ + */ +/** + * @file + */ + +#ifndef LIBEXT2_LIBEXT2_BLOCK_GROUP_H_ +#define LIBEXT2_LIBEXT2_BLOCK_GROUP_H_ + +#include + +typedef struct ext2_block_group { + uint32_t block_bitmap_block; // Block ID for block bitmap + uint32_t inode_bitmap_block; // Block ID for inode bitmap + uint32_t inode_table_first_block; // Block ID of first block of inode table + uint16_t free_block_count; // Count of free blocks + uint16_t free_inode_count; // Count of free inodes + uint16_t directory_inode_count; // Number of inodes allocated to directories +} ext2_block_group_t; + +typedef struct ext2_block_group_ref { + block_t *block; // Reference to a block containing this block group descr + ext2_block_group_t *block_group; +} ext2_block_group_ref_t; + +#define EXT2_BLOCK_GROUP_DESCRIPTOR_SIZE 32 + +extern uint32_t ext2_block_group_get_block_bitmap_block(ext2_block_group_t *); +extern uint32_t ext2_block_group_get_inode_bitmap_block(ext2_block_group_t *); +extern uint32_t ext2_block_group_get_inode_table_first_block(ext2_block_group_t *); +extern uint16_t ext2_block_group_get_free_block_count(ext2_block_group_t *); +extern uint16_t ext2_block_group_get_free_inode_count(ext2_block_group_t *); +extern uint16_t ext2_block_group_get_directory_inode_count(ext2_block_group_t *); + +extern void ext2_block_group_set_free_block_count(ext2_block_group_t *, uint16_t); + +#endif + +/** @} + */ Index: uspace/lib/ext2/libext2_directory.c =================================================================== --- uspace/lib/ext2/libext2_directory.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/ext2/libext2_directory.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,245 @@ +/* + * Copyright (c) 2011 Martin Sucha + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext2 + * @{ + */ +/** + * @file + */ + +#include "libext2.h" +#include "libext2_directory.h" +#include +#include +#include + +static int ext2_directory_iterator_set(ext2_directory_iterator_t *it, + uint32_t block_size); + +/** + * Get inode number for the directory entry + * + * @param de pointer to linked list directory entry + */ +uint32_t ext2_directory_entry_ll_get_inode(ext2_directory_entry_ll_t *de) +{ + return uint32_t_le2host(de->inode); +} + +/** + * Get length of the directory entry + * + * @param de pointer to linked list directory entry + */ +uint16_t ext2_directory_entry_ll_get_entry_length( + ext2_directory_entry_ll_t *de) +{ + return uint16_t_le2host(de->entry_length); +} + +/** + * Get length of the name stored in the directory entry + * + * @param de pointer to linked list directory entry + */ +uint16_t ext2_directory_entry_ll_get_name_length( + ext2_superblock_t *sb, ext2_directory_entry_ll_t *de) +{ + if (ext2_superblock_get_rev_major(sb) == 0 && + ext2_superblock_get_rev_minor(sb) < 5) { + return ((uint16_t)de->name_length_high) << 8 | + ((uint16_t)de->name_length); + } + return de->name_length; +} + +/** + * Initialize a directory iterator + * + * @param it pointer to iterator to initialize + * @param fs pointer to filesystem structure + * @param inode pointer to inode reference structure + * @return EOK on success or negative error code on failure + */ +int ext2_directory_iterator_init(ext2_directory_iterator_t *it, + ext2_filesystem_t *fs, ext2_inode_ref_t *inode_ref) +{ + int rc; + uint32_t block_id; + uint32_t block_size; + + it->inode_ref = inode_ref; + it->fs = fs; + + /* Get the first data block, so we can get the first entry */ + rc = ext2_filesystem_get_inode_data_block_index(fs, inode_ref->inode, 0, + &block_id); + if (rc != EOK) { + return rc; + } + + rc = block_get(&it->current_block, fs->device, block_id, 0); + if (rc != EOK) { + return rc; + } + + block_size = ext2_superblock_get_block_size(fs->superblock); + + it->current_offset = 0; + return ext2_directory_iterator_set(it, block_size); +} + +/** + * Advance the directory iterator to the next entry + * + * @param it pointer to iterator to initialize + * @return EOK on success or negative error code on failure + */ +int ext2_directory_iterator_next(ext2_directory_iterator_t *it) +{ + int rc; + uint16_t skip; + uint64_t size; + aoff64_t current_block_idx; + aoff64_t next_block_idx; + uint32_t next_block_phys_idx; + uint32_t block_size; + + assert(it->current != NULL); + + skip = ext2_directory_entry_ll_get_entry_length(it->current); + size = ext2_inode_get_size(it->fs->superblock, it->inode_ref->inode); + + /* Are we at the end? */ + if (it->current_offset + skip >= size) { + rc = block_put(it->current_block); + it->current_block = NULL; + it->current = NULL; + if (rc != EOK) { + return rc; + } + + it->current_offset += skip; + return EOK; + } + + block_size = ext2_superblock_get_block_size(it->fs->superblock); + current_block_idx = it->current_offset / block_size; + next_block_idx = (it->current_offset + skip) / block_size; + + /* If we are moving accross block boundary, + * we need to get another block + */ + if (current_block_idx != next_block_idx) { + rc = block_put(it->current_block); + it->current_block = NULL; + it->current = NULL; + if (rc != EOK) { + return rc; + } + + rc = ext2_filesystem_get_inode_data_block_index(it->fs, + it->inode_ref->inode, next_block_idx, &next_block_phys_idx); + if (rc != EOK) { + return rc; + } + + rc = block_get(&it->current_block, it->fs->device, next_block_phys_idx, + BLOCK_FLAGS_NONE); + if (rc != EOK) { + it->current_block = NULL; + return rc; + } + } + + it->current_offset += skip; + return ext2_directory_iterator_set(it, block_size); +} + +static int ext2_directory_iterator_set(ext2_directory_iterator_t *it, + uint32_t block_size) +{ + uint32_t offset_in_block = it->current_offset % block_size; + + it->current = NULL; + + /* Ensure proper alignment */ + if ((offset_in_block % 4) != 0) { + return EIO; + } + + /* Ensure that the core of the entry does not overflow the block */ + if (offset_in_block > block_size - 8) { + return EIO; + } + + ext2_directory_entry_ll_t *entry = it->current_block->data + offset_in_block; + + /* Ensure that the whole entry does not overflow the block */ + uint16_t length = ext2_directory_entry_ll_get_entry_length(entry); + if (offset_in_block + length > block_size) { + return EIO; + } + + /* Ensure the name length is not too large */ + if (ext2_directory_entry_ll_get_name_length(it->fs->superblock, + entry) > length-8) { + return EIO; + } + + it->current = entry; + return EOK; +} + +/** + * Release all resources asociated with the directory iterator + * + * @param it pointer to iterator to initialize + * @return EOK on success or negative error code on failure + */ +int ext2_directory_iterator_fini(ext2_directory_iterator_t *it) +{ + int rc; + + it->fs = NULL; + it->inode_ref = NULL; + it->current = NULL; + + if (it->current_block) { + rc = block_put(it->current_block); + if (rc != EOK) { + return rc; + } + } + + return EOK; +} + +/** @} + */ Index: uspace/lib/ext2/libext2_directory.h =================================================================== --- uspace/lib/ext2/libext2_directory.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/ext2/libext2_directory.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2011 Martin Sucha + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext2 + * @{ + */ +/** + * @file + */ + +#ifndef LIBEXT2_LIBEXT2_DIRECTORY_H_ +#define LIBEXT2_LIBEXT2_DIRECTORY_H_ + +#include +#include "libext2_filesystem.h" +#include "libext2_inode.h" + +/** + * Linked list directory entry structure + */ +typedef struct ext2_directory_entry_ll { + uint32_t inode; // Inode for the entry + uint16_t entry_length; // Distance to the next directory entry + uint8_t name_length; // Lower 8 bits of name length + union { + uint8_t name_length_high; // Higher 8 bits of name length + uint8_t inode_type; // Type of referenced inode (in rev >= 0.5) + } __attribute__ ((packed)); + uint8_t name; // First byte of name, if present +} __attribute__ ((packed)) ext2_directory_entry_ll_t; + +typedef struct ext2_directory_iterator { + ext2_filesystem_t *fs; + ext2_inode_ref_t *inode_ref; + block_t *current_block; + aoff64_t current_offset; + ext2_directory_entry_ll_t *current; +} ext2_directory_iterator_t; + + +extern uint32_t ext2_directory_entry_ll_get_inode(ext2_directory_entry_ll_t *); +extern uint16_t ext2_directory_entry_ll_get_entry_length( + ext2_directory_entry_ll_t *); +extern uint16_t ext2_directory_entry_ll_get_name_length( + ext2_superblock_t *, ext2_directory_entry_ll_t *); + +extern int ext2_directory_iterator_init(ext2_directory_iterator_t *, + ext2_filesystem_t *, ext2_inode_ref_t *); +extern int ext2_directory_iterator_next(ext2_directory_iterator_t *); +extern int ext2_directory_iterator_fini(ext2_directory_iterator_t *); + +#endif + +/** @} + */ Index: uspace/lib/ext2/libext2_filesystem.c =================================================================== --- uspace/lib/ext2/libext2_filesystem.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/ext2/libext2_filesystem.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,526 @@ +/* + * Copyright (c) 2011 Martin Sucha + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext2 + * @{ + */ +/** + * @file + */ + +#include "libext2_filesystem.h" +#include "libext2_superblock.h" +#include "libext2_block_group.h" +#include "libext2_inode.h" +#include +#include +#include +#include +#include + +/** + * Initialize an instance of filesystem on the device. + * This function reads superblock from the device and + * initializes libblock cache with appropriate logical block size. + * + * @param fs Pointer to ext2_filesystem_t to initialize + * @param devmap_handle Device handle of the block device + * + * @return EOK on success or negative error code on failure + */ +int ext2_filesystem_init(ext2_filesystem_t *fs, devmap_handle_t devmap_handle) +{ + int rc; + ext2_superblock_t *temp_superblock; + size_t block_size; + + fs->device = devmap_handle; + + rc = block_init(EXCHANGE_SERIALIZE, fs->device, 2048); + if (rc != EOK) { + return rc; + } + + rc = ext2_superblock_read_direct(fs->device, &temp_superblock); + if (rc != EOK) { + block_fini(fs->device); + return rc; + } + + block_size = ext2_superblock_get_block_size(temp_superblock); + + if (block_size > EXT2_MAX_BLOCK_SIZE) { + block_fini(fs->device); + return ENOTSUP; + } + + rc = block_cache_init(devmap_handle, block_size, 0, CACHE_MODE_WT); + if (rc != EOK) { + block_fini(fs->device); + return rc; + } + + fs->superblock = temp_superblock; + + return EOK; +} + +/** + * Check filesystem for sanity + * + * @param fs Pointer to ext2_filesystem_t to check + * @return EOK on success or negative error code on failure + */ +int ext2_filesystem_check_sanity(ext2_filesystem_t *fs) +{ + int rc; + + rc = ext2_superblock_check_sanity(fs->superblock); + if (rc != EOK) { + return rc; + } + + return EOK; +} + +/** + * Check feature flags + * + * @param fs Pointer to ext2_filesystem_t to check + * @param read_only bool to set to true if the fs needs to be read-only + * @return EOK on success or negative error code on failure + */ +int ext2_filesystem_check_flags(ext2_filesystem_t *fs, bool *o_read_only) +{ + /* feature flags are present in rev 1 and later */ + if (ext2_superblock_get_rev_major(fs->superblock) == 0) { + *o_read_only = false; + return EOK; + } + + uint32_t incompatible; + uint32_t read_only; + + incompatible = ext2_superblock_get_features_incompatible(fs->superblock); + read_only = ext2_superblock_get_features_read_only(fs->superblock); + + /* check whether we support all features + * first unset any supported feature flags + * and see whether any unspported feature remains */ + incompatible &= ~EXT2_SUPPORTED_INCOMPATIBLE_FEATURES; + read_only &= ~EXT2_SUPPORTED_READ_ONLY_FEATURES; + + if (incompatible > 0) { + *o_read_only = true; + return ENOTSUP; + } + + if (read_only > 0) { + *o_read_only = true; + } + + return EOK; +} + +/** + * Get a reference to block descriptor + * + * @param fs Pointer to filesystem information + * @param bgid Index of block group to find + * @param ref Pointer where to store pointer to block group reference + * + * @return EOK on success or negative error code on failure + */ +int ext2_filesystem_get_block_group_ref(ext2_filesystem_t *fs, uint32_t bgid, + ext2_block_group_ref_t **ref) +{ + int rc; + aoff64_t block_id; + uint32_t descriptors_per_block; + size_t offset; + ext2_block_group_ref_t *newref; + + newref = malloc(sizeof(ext2_block_group_ref_t)); + if (newref == NULL) { + return ENOMEM; + } + + descriptors_per_block = ext2_superblock_get_block_size(fs->superblock) + / EXT2_BLOCK_GROUP_DESCRIPTOR_SIZE; + + /* Block group descriptor table starts at the next block after superblock */ + block_id = ext2_superblock_get_first_block(fs->superblock) + 1; + + /* Find the block containing the descriptor we are looking for */ + block_id += bgid / descriptors_per_block; + offset = (bgid % descriptors_per_block) * EXT2_BLOCK_GROUP_DESCRIPTOR_SIZE; + + rc = block_get(&newref->block, fs->device, block_id, 0); + if (rc != EOK) { + free(newref); + return rc; + } + + newref->block_group = newref->block->data + offset; + + *ref = newref; + + return EOK; +} + +/** + * Free a reference to block group + * + * @param ref Pointer to block group reference to free + * + * @return EOK on success or negative error code on failure + */ +int ext2_filesystem_put_block_group_ref(ext2_block_group_ref_t *ref) +{ + int rc; + + rc = block_put(ref->block); + free(ref); + + return rc; +} + +/** + * Get a reference to inode + * + * @param fs Pointer to filesystem information + * @param index The index number of the inode + * @param ref Pointer where to store pointer to inode reference + * + * @return EOK on success or negative error code on failure + */ +int ext2_filesystem_get_inode_ref(ext2_filesystem_t *fs, uint32_t index, + ext2_inode_ref_t **ref) +{ + int rc; + aoff64_t block_id; + uint32_t block_group; + uint32_t offset_in_group; + uint32_t byte_offset_in_group; + size_t offset_in_block; + uint32_t inodes_per_group; + uint32_t inode_table_start; + uint16_t inode_size; + uint32_t block_size; + ext2_block_group_ref_t *bg_ref; + ext2_inode_ref_t *newref; + + newref = malloc(sizeof(ext2_inode_ref_t)); + if (newref == NULL) { + return ENOMEM; + } + + inodes_per_group = ext2_superblock_get_inodes_per_group(fs->superblock); + + /* inode numbers are 1-based, but it is simpler to work with 0-based + * when computing indices + */ + index -= 1; + block_group = index / inodes_per_group; + offset_in_group = index % inodes_per_group; + + rc = ext2_filesystem_get_block_group_ref(fs, block_group, &bg_ref); + if (rc != EOK) { + free(newref); + return rc; + } + + inode_table_start = ext2_block_group_get_inode_table_first_block( + bg_ref->block_group); + + inode_size = ext2_superblock_get_inode_size(fs->superblock); + block_size = ext2_superblock_get_block_size(fs->superblock); + + byte_offset_in_group = offset_in_group * inode_size; + + block_id = inode_table_start + (byte_offset_in_group / block_size); + offset_in_block = byte_offset_in_group % block_size; + + rc = block_get(&newref->block, fs->device, block_id, 0); + if (rc != EOK) { + free(newref); + return rc; + } + + newref->inode = newref->block->data + offset_in_block; + /* we decremented index above, but need to store the original value + * in the reference + */ + newref->index = index+1; + + *ref = newref; + + return EOK; +} + +/** + * Free a reference to inode + * + * @param ref Pointer to inode reference to free + * + * @return EOK on success or negative error code on failure + */ +int ext2_filesystem_put_inode_ref(ext2_inode_ref_t *ref) +{ + int rc; + + rc = block_put(ref->block); + free(ref); + + return rc; +} + +/** + * Find a filesystem block number where iblock-th data block + * of the given inode is located. + * + * @param fblock the number of filesystem block, or 0 if no such block is allocated yet + * + * @return EOK on success or negative error code on failure + */ +int ext2_filesystem_get_inode_data_block_index(ext2_filesystem_t *fs, ext2_inode_t* inode, + aoff64_t iblock, uint32_t* fblock) +{ + int rc; + aoff64_t limits[4]; + uint32_t block_ids_per_block; + aoff64_t blocks_per_level[4]; + uint32_t offset_in_block; + uint32_t current_block; + aoff64_t block_offset_in_level; + int i; + int level; + block_t *block; + + /* Handle simple case when we are dealing with direct reference */ + if (iblock < EXT2_INODE_DIRECT_BLOCKS) { + current_block = ext2_inode_get_direct_block(inode, (uint32_t)iblock); + *fblock = current_block; + return EOK; + } + + /* Compute limits for indirect block levels + * TODO: compute this once when loading filesystem and store in ext2_filesystem_t + */ + block_ids_per_block = ext2_superblock_get_block_size(fs->superblock) / sizeof(uint32_t); + limits[0] = EXT2_INODE_DIRECT_BLOCKS; + blocks_per_level[0] = 1; + for (i = 1; i < 4; i++) { + blocks_per_level[i] = blocks_per_level[i-1] * + block_ids_per_block; + limits[i] = limits[i-1] + blocks_per_level[i]; + } + + /* Determine the indirection level needed to get the desired block */ + level = -1; + for (i = 1; i < 4; i++) { + if (iblock < limits[i]) { + level = i; + break; + } + } + + if (level == -1) { + return EIO; + } + + /* Compute offsets for the topmost level */ + block_offset_in_level = iblock - limits[level-1]; + current_block = ext2_inode_get_indirect_block(inode, level-1); + offset_in_block = block_offset_in_level / blocks_per_level[level-1]; + + /* Navigate through other levels, until we find the block number + * or find null reference meaning we are dealing with sparse file + */ + while (level > 0) { + rc = block_get(&block, fs->device, current_block, 0); + if (rc != EOK) { + return rc; + } + + assert(offset_in_block < block_ids_per_block); + current_block = uint32_t_le2host(((uint32_t*)block->data)[offset_in_block]); + + rc = block_put(block); + if (rc != EOK) { + return rc; + } + + if (current_block == 0) { + /* This is a sparse file */ + *fblock = 0; + return EOK; + } + + level -= 1; + + /* If we are on the last level, break here as + * there is no next level to visit + */ + if (level == 0) { + break; + } + + /* Visit the next level */ + block_offset_in_level %= blocks_per_level[level]; + offset_in_block = block_offset_in_level / blocks_per_level[level-1]; + } + + *fblock = current_block; + + return EOK; +} + +/** + * Allocate a given number of blocks and store their ids in blocks + * + * @todo TODO: This function is not finished and really has never been + * used (and tested) yet + * + * @param fs pointer to filesystem + * @param blocks array of count uint32_t values where store block ids + * @param count number of blocks to allocate and elements in blocks array + * @param preferred_bg preferred block group number + * + * @return EOK on success or negative error code on failure + */ +int ext2_filesystem_allocate_blocks(ext2_filesystem_t *fs, uint32_t *blocks, + size_t count, uint32_t preferred_bg) +{ + uint32_t bg_count = ext2_superblock_get_block_group_count(fs->superblock); + uint32_t bpg = ext2_superblock_get_blocks_per_group(fs->superblock); + uint32_t block_size = ext2_superblock_get_block_size(fs->superblock); + uint32_t block_group = preferred_bg; + uint32_t free_blocks_sb; + uint32_t block_groups_left; + size_t idx; + ext2_block_group_ref_t *bg; + int rc; + uint32_t bb_block; + block_t *block; + size_t bb_idx; + size_t bb_bit; + + free_blocks_sb = ext2_superblock_get_free_block_count(fs->superblock); + + if (count > free_blocks_sb) { + return EIO; + } + + block_groups_left = bg_count; + + idx = 0; + + /* Read the block group descriptor */ + rc = ext2_filesystem_get_block_group_ref(fs, block_group, &bg); + if (rc != EOK) { + goto failed; + } + + while (idx < count && block_groups_left > 0) { + uint16_t fb = ext2_block_group_get_free_block_count(bg->block_group); + if (fb == 0) { + block_group = (block_group + 1) % bg_count; + block_groups_left -= 1; + + rc = ext2_filesystem_put_block_group_ref(bg); + if (rc != EOK) { + goto failed; + } + + rc = ext2_filesystem_get_block_group_ref(fs, block_group, &bg); + if (rc != EOK) { + goto failed; + } + continue; + } + + /* We found a block group with free block, let's look at the block bitmap */ + bb_block = ext2_block_group_get_block_bitmap_block(bg->block_group); + + rc = block_get(&block, fs->device, bb_block, BLOCK_FLAGS_NONE); + if (rc != EOK) { + goto failed; + } + + /* Use all blocks from this block group */ + for (bb_idx = 0; bb_idx < block_size && idx < count; bb_idx++) { + uint8_t *data = (uint8_t *) block->data; + if (data[bb_idx] == 0xff) { + continue; + } + /* find an empty bit */ + uint8_t mask; + for (mask = 1, bb_bit = 0; + bb_bit < 8 && idx < count; + bb_bit++, mask = mask << 1) { + if ((data[bb_idx] & mask) == 0) { + // free block found + blocks[idx] = block_group * bpg + bb_idx*8 + bb_bit; + data[bb_idx] |= mask; + idx += 1; + fb -= 1; + ext2_block_group_set_free_block_count(bg->block_group, fb); + } + } + } + } + + rc = ext2_filesystem_put_block_group_ref(bg); + if (rc != EOK) { + goto failed; + } + + // TODO update superblock + + return EOK; +failed: + // TODO deallocate already allocated blocks, if possible + + return rc; +} + +/** + * Finalize an instance of filesystem + * + * @param fs Pointer to ext2_filesystem_t to finalize + */ +void ext2_filesystem_fini(ext2_filesystem_t *fs) +{ + free(fs->superblock); + block_fini(fs->device); +} + + +/** @} + */ Index: uspace/lib/ext2/libext2_filesystem.h =================================================================== --- uspace/lib/ext2/libext2_filesystem.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/ext2/libext2_filesystem.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,78 @@ +/* + * Copyright (c) 2011 Martin Sucha + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext2 + * @{ + */ +/** + * @file + */ + +#ifndef LIBEXT2_LIBEXT2_FILESYSTEM_H_ +#define LIBEXT2_LIBEXT2_FILESYSTEM_H_ + +#include +#include "libext2_superblock.h" +#include "libext2_block_group.h" +#include "libext2_inode.h" + +typedef struct ext2_filesystem { + devmap_handle_t device; + ext2_superblock_t * superblock; +} ext2_filesystem_t; + +// allow maximum this block size +#define EXT2_MAX_BLOCK_SIZE 8096 +#define EXT2_REV0_FIRST_INODE 11 +#define EXT2_REV0_INODE_SIZE 128 + +#define EXT2_FEATURE_RO_SPARSE_SUPERBLOCK 1 +#define EXT2_FEATURE_RO_LARGE_FILE 2 +#define EXT2_FEATURE_I_TYPE_IN_DIR 2 + +#define EXT2_SUPPORTED_INCOMPATIBLE_FEATURES EXT2_FEATURE_I_TYPE_IN_DIR +#define EXT2_SUPPORTED_READ_ONLY_FEATURES 0 + +extern int ext2_filesystem_init(ext2_filesystem_t *, devmap_handle_t); +extern int ext2_filesystem_check_sanity(ext2_filesystem_t *); +extern int ext2_filesystem_check_flags(ext2_filesystem_t *, bool *); +extern int ext2_filesystem_get_block_group_ref(ext2_filesystem_t *, uint32_t, + ext2_block_group_ref_t **); +extern int ext2_filesystem_put_block_group_ref(ext2_block_group_ref_t *); +extern int ext2_filesystem_get_inode_ref(ext2_filesystem_t *, uint32_t, + ext2_inode_ref_t **); +extern int ext2_filesystem_put_inode_ref(ext2_inode_ref_t *); +extern int ext2_filesystem_get_inode_data_block_index(ext2_filesystem_t *, ext2_inode_t*, + aoff64_t, uint32_t*); +extern int ext2_filesystem_allocate_blocks(ext2_filesystem_t *, uint32_t *, size_t, uint32_t); +extern void ext2_filesystem_fini(ext2_filesystem_t *); + +#endif + +/** @} + */ Index: uspace/lib/ext2/libext2_inode.c =================================================================== --- uspace/lib/ext2/libext2_inode.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/ext2/libext2_inode.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,192 @@ +/* + * Copyright (c) 2011 Martin Sucha + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext2 + * @{ + */ +/** + * @file + */ + +#include "libext2.h" +#include "libext2_inode.h" +#include "libext2_superblock.h" +#include +#include + +/** + * Get mode stored in the inode + * + * @param inode pointer to inode + */ +uint32_t ext2_inode_get_mode(ext2_superblock_t *sb, ext2_inode_t *inode) +{ + if (ext2_superblock_get_os(sb) == EXT2_SUPERBLOCK_OS_HURD) { + return ((uint32_t)uint16_t_le2host(inode->mode_high)) << 16 | + ((uint32_t)uint16_t_le2host(inode->mode)); + } + return uint16_t_le2host(inode->mode); +} + +/** + * Check whether inode is of given type + * + * @param sb pointer to superblock structure + * @param inode pointer to inode + * @param type EXT2_INODE_MODE_TYPE_* constant to check + */ +bool ext2_inode_is_type(ext2_superblock_t *sb, ext2_inode_t *inode, uint32_t type) +{ + uint32_t mode = ext2_inode_get_mode(sb, inode); + return (mode & EXT2_INODE_MODE_TYPE_MASK) == type; +} + +/** + * Get uid this inode is belonging to + * + * @param inode pointer to inode + */ +uint32_t ext2_inode_get_user_id(ext2_superblock_t *sb, ext2_inode_t *inode) +{ + uint32_t os = ext2_superblock_get_os(sb); + if (os == EXT2_SUPERBLOCK_OS_LINUX || os == EXT2_SUPERBLOCK_OS_HURD) { + return ((uint32_t)uint16_t_le2host(inode->user_id_high)) << 16 | + ((uint32_t)uint16_t_le2host(inode->user_id)); + } + return uint16_t_le2host(inode->user_id); +} + +/** + * Get size of file + * + * For regular files in revision 1 and later, the high 32 bits of + * file size are stored in inode->size_high and are 0 otherwise + * + * @param inode pointer to inode + */ +uint64_t ext2_inode_get_size(ext2_superblock_t *sb, ext2_inode_t *inode) +{ + uint32_t major_rev = ext2_superblock_get_rev_major(sb); + + if (major_rev > 0 && ext2_inode_is_type(sb, inode, EXT2_INODE_MODE_FILE)) { + return ((uint64_t)uint32_t_le2host(inode->size_high)) << 32 | + ((uint64_t)uint32_t_le2host(inode->size)); + } + return uint32_t_le2host(inode->size); +} + +/** + * Get gid this inode belongs to + * + * For Linux and Hurd, the high 16 bits are stored in OS dependent part + * of inode structure + * + * @param inode pointer to inode + */ +uint32_t ext2_inode_get_group_id(ext2_superblock_t *sb, ext2_inode_t *inode) +{ + uint32_t os = ext2_superblock_get_os(sb); + if (os == EXT2_SUPERBLOCK_OS_LINUX || os == EXT2_SUPERBLOCK_OS_HURD) { + return ((uint32_t)uint16_t_le2host(inode->group_id_high)) << 16 | + ((uint32_t)uint16_t_le2host(inode->group_id)); + } + return uint16_t_le2host(inode->group_id); +} + +/** + * Get usage count (i.e. hard link count) + * A value of 1 is common, while 0 means that the inode should be freed + * + * @param inode pointer to inode + */ +uint16_t ext2_inode_get_usage_count(ext2_inode_t *inode) +{ + return uint16_t_le2host(inode->usage_count); +} + +/** + * Get number of 512-byte data blocks allocated for contents of the file + * represented by this inode. + * This should be multiple of block size unless fragments are used. + * + * @param inode pointer to inode + */ +uint32_t ext2_inode_get_reserved_512_blocks(ext2_inode_t *inode) +{ + return uint32_t_le2host(inode->reserved_512_blocks); +} + +/** + * Get number of blocks allocated for contents of the file + * represented by this inode. + * + * @param inode pointer to inode + */ +uint32_t ext2_inode_get_reserved_blocks(ext2_superblock_t *sb, + ext2_inode_t *inode) +{ + return ext2_inode_get_reserved_512_blocks(inode) / + (ext2_superblock_get_block_size(sb) / 512); +} + +/** + * Get inode flags + * + * @param inode pointer to inode + */ +uint32_t ext2_inode_get_flags(ext2_inode_t *inode) { + return uint32_t_le2host(inode->flags); +} + +/** + * Get direct block ID + * + * @param inode pointer to inode + * @param idx Index to block. Valid values are 0 <= idx < 12 + */ +uint32_t ext2_inode_get_direct_block(ext2_inode_t *inode, uint8_t idx) +{ + assert(idx < EXT2_INODE_DIRECT_BLOCKS); + return uint32_t_le2host(inode->direct_blocks[idx]); +} + +/** + * Get indirect block ID + * + * @param inode pointer to inode + * @param idx Indirection level. Valid values are 0 <= idx < 3, where 0 is + * singly-indirect block and 2 is triply-indirect-block + */ +uint32_t ext2_inode_get_indirect_block(ext2_inode_t *inode, uint8_t idx) +{ + assert(idx < 3); + return uint32_t_le2host(inode->indirect_blocks[idx]); +} + +/** @} + */ Index: uspace/lib/ext2/libext2_inode.h =================================================================== --- uspace/lib/ext2/libext2_inode.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/ext2/libext2_inode.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,103 @@ +/* + * Copyright (c) 2011 Martin Sucha + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext2 + * @{ + */ +/** + * @file + */ + +#ifndef LIBEXT2_LIBEXT2_INODE_H_ +#define LIBEXT2_LIBEXT2_INODE_H_ + +#include +#include "libext2_superblock.h" + +typedef struct ext2_inode { + uint16_t mode; + uint16_t user_id; + uint32_t size; + uint8_t unused[16]; + uint16_t group_id; + uint16_t usage_count; // Hard link count, when 0 the inode is to be freed + uint32_t reserved_512_blocks; // Size of this inode in 512-byte blocks + uint32_t flags; + uint8_t unused2[4]; + uint32_t direct_blocks[12]; // Direct block ids stored in this inode + uint32_t indirect_blocks[3]; + uint32_t version; + uint32_t file_acl; + union { + uint32_t dir_acl; + uint32_t size_high; // For regular files in version >= 1 + } __attribute__ ((packed)); + uint8_t unused3[6]; + uint16_t mode_high; // Hurd only + uint16_t user_id_high; // Linux/Hurd only + uint16_t group_id_high; // Linux/Hurd only +} __attribute__ ((packed)) ext2_inode_t; + +#define EXT2_INODE_MODE_FIFO 0x1000 +#define EXT2_INODE_MODE_CHARDEV 0x2000 +#define EXT2_INODE_MODE_DIRECTORY 0x4000 +#define EXT2_INODE_MODE_BLOCKDEV 0x6000 +#define EXT2_INODE_MODE_FILE 0x8000 +#define EXT2_INODE_MODE_SOFTLINK 0xA000 +#define EXT2_INODE_MODE_SOCKET 0xC000 +#define EXT2_INODE_MODE_ACCESS_MASK 0x0FFF +#define EXT2_INODE_MODE_TYPE_MASK 0xF000 +#define EXT2_INODE_DIRECT_BLOCKS 12 + +#define EXT2_INODE_ROOT_INDEX 2 + +typedef struct ext2_inode_ref { + block_t *block; // Reference to a block containing this inode + ext2_inode_t *inode; + uint32_t index; // Index number of this inode +} ext2_inode_ref_t; + +extern uint32_t ext2_inode_get_mode(ext2_superblock_t *, ext2_inode_t *); +extern bool ext2_inode_is_type(ext2_superblock_t *, ext2_inode_t *, uint32_t); +extern uint32_t ext2_inode_get_user_id(ext2_superblock_t *, ext2_inode_t *); +extern uint64_t ext2_inode_get_size(ext2_superblock_t *, ext2_inode_t *); +extern uint32_t ext2_inode_get_group_id(ext2_superblock_t *, ext2_inode_t *); +extern uint16_t ext2_inode_get_usage_count(ext2_inode_t *); +extern uint32_t ext2_inode_get_reserved_512_blocks(ext2_inode_t *); +extern uint32_t ext2_inode_get_reserved_blocks(ext2_superblock_t *, + ext2_inode_t *); +extern uint32_t ext2_inode_get_flags(ext2_inode_t *); +extern uint32_t ext2_inode_get_direct_block(ext2_inode_t *, uint8_t); +extern uint32_t ext2_inode_get_indirect_block(ext2_inode_t *, uint8_t level); + + + +#endif + +/** @} + */ Index: uspace/lib/ext2/libext2_superblock.c =================================================================== --- uspace/lib/ext2/libext2_superblock.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/ext2/libext2_superblock.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,409 @@ +/* + * Copyright (c) 2011 Martin Sucha + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext2 + * @{ + */ +/** + * @file + */ + +#include "libext2.h" +#include +#include +#include +#include + +/** + * Return a magic number from ext2 superblock, this should be equal to + * EXT_SUPERBLOCK_MAGIC for valid ext2 superblock + * + * @param sb pointer to superblock + */ +uint16_t ext2_superblock_get_magic(ext2_superblock_t *sb) +{ + return uint16_t_le2host(sb->magic); +} + +/** + * Get the position of first ext2 data block (i.e. the block number + * containing main superblock) + * + * @param sb pointer to superblock + */ +uint32_t ext2_superblock_get_first_block(ext2_superblock_t *sb) +{ + return uint32_t_le2host(sb->first_block); +} + +/** + * Get the number of bits to shift a value of 1024 to the left necessary + * to get the size of a block + * + * @param sb pointer to superblock + */ +uint32_t ext2_superblock_get_block_size_log2(ext2_superblock_t *sb) +{ + return uint32_t_le2host(sb->block_size_log2); +} + +/** + * Get the size of a block, in bytes + * + * @param sb pointer to superblock + */ +uint32_t ext2_superblock_get_block_size(ext2_superblock_t *sb) +{ + return 1024 << ext2_superblock_get_block_size_log2(sb); +} + +/** + * Get the number of bits to shift a value of 1024 to the left necessary + * to get the size of a fragment (note that this is a signed integer and + * if negative, the value should be shifted to the right instead) + * + * @param sb pointer to superblock + */ +int32_t ext2_superblock_get_fragment_size_log2(ext2_superblock_t *sb) +{ + return uint32_t_le2host(sb->fragment_size_log2); +} + +/** + * Get the size of a fragment, in bytes + * + * @param sb pointer to superblock + */ +uint32_t ext2_superblock_get_fragment_size(ext2_superblock_t *sb) +{ + int32_t log = ext2_superblock_get_fragment_size_log2(sb); + if (log >= 0) { + return 1024 << log; + } + else { + return 1024 >> -log; + } +} + +/** + * Get number of blocks per block group + * + * @param sb pointer to superblock + */ +uint32_t ext2_superblock_get_blocks_per_group(ext2_superblock_t *sb) +{ + return uint32_t_le2host(sb->blocks_per_group); +} + +/** + * Get number of fragments per block group + * + * @param sb pointer to superblock + */ +uint32_t ext2_superblock_get_fragments_per_group(ext2_superblock_t *sb) +{ + return uint32_t_le2host(sb->fragments_per_group); +} + +/** + * Get filesystem state + * + * @param sb pointer to superblock + */ +uint16_t ext2_superblock_get_state(ext2_superblock_t *sb) +{ + return uint16_t_le2host(sb->state); +} + +/** + * Get minor revision number + * + * @param sb pointer to superblock + */ +uint16_t ext2_superblock_get_rev_minor(ext2_superblock_t *sb) +{ + return uint16_t_le2host(sb->rev_minor); +} + +/** + * Get major revision number + * + * @param sb pointer to superblock + */ +uint32_t ext2_superblock_get_rev_major(ext2_superblock_t *sb) +{ + return uint32_t_le2host(sb->rev_major); +} + +/** + * Get index of first regular inode + * + * @param sb pointer to superblock + */ +uint32_t ext2_superblock_get_first_inode(ext2_superblock_t *sb) +{ + if (ext2_superblock_get_rev_major(sb) == 0) { + return EXT2_REV0_FIRST_INODE; + } + return uint32_t_le2host(sb->first_inode); +} + +/** + * Get size of inode + * + * @param sb pointer to superblock + */ +uint16_t ext2_superblock_get_inode_size(ext2_superblock_t *sb) +{ + if (ext2_superblock_get_rev_major(sb) == 0) { + return EXT2_REV0_INODE_SIZE; + } + return uint16_t_le2host(sb->inode_size); +} + +/** + * Get total inode count + * + * @param sb pointer to superblock + */ +uint32_t ext2_superblock_get_total_inode_count(ext2_superblock_t *sb) +{ + return uint32_t_le2host(sb->total_inode_count); +} + +/** + * Get total block count + * + * @param sb pointer to superblock + */ +uint32_t ext2_superblock_get_total_block_count(ext2_superblock_t *sb) +{ + return uint32_t_le2host(sb->total_block_count); +} + +/** + * Get amount of blocks reserved for the superuser + * + * @param sb pointer to superblock + */ +uint32_t ext2_superblock_get_reserved_block_count(ext2_superblock_t *sb) +{ + return uint32_t_le2host(sb->reserved_block_count); +} + +/** + * Get amount of free blocks + * + * @param sb pointer to superblock + */ +uint32_t ext2_superblock_get_free_block_count(ext2_superblock_t *sb) +{ + return uint32_t_le2host(sb->free_block_count); +} + +/** + * Get amount of free inodes + * + * @param sb pointer to superblock + */ +uint32_t ext2_superblock_get_free_inode_count(ext2_superblock_t *sb) +{ + return uint32_t_le2host(sb->free_inode_count); +} + +/** + * Get id of operating system that created the filesystem + * + * @param sb pointer to superblock + */ +uint32_t ext2_superblock_get_os(ext2_superblock_t *sb) +{ + return uint32_t_le2host(sb->os); +} + +/** + * Get count of inodes per block group + * + * @param sb pointer to superblock + */ +uint32_t ext2_superblock_get_inodes_per_group(ext2_superblock_t *sb) +{ + return uint32_t_le2host(sb->inodes_per_group); +} + +/** + * Get compatible features flags + * + * @param sb pointer to superblock + */ +uint32_t ext2_superblock_get_features_compatible(ext2_superblock_t *sb) +{ + return uint32_t_le2host(sb->features_compatible); +} + +/** + * Get incompatible features flags + * + * @param sb pointer to superblock + */ +uint32_t ext2_superblock_get_features_incompatible(ext2_superblock_t *sb) +{ + return uint32_t_le2host(sb->features_incompatible); +} + +/** + * Get read-only compatible features flags + * + * @param sb pointer to superblock + */ +uint32_t ext2_superblock_get_features_read_only(ext2_superblock_t *sb) +{ + return uint32_t_le2host(sb->features_read_only); +} + +/** + * Compute count of block groups present in the filesystem + * + * Note: This function works only for correct filesystem, + * i.e. it assumes that total block count > 0 and + * blocks per group > 0 + * + * Example: + * If there are 3 blocks per group, the result should be as follows: + * Total blocks Result + * 1 1 + * 2 1 + * 3 1 + * 4 2 + * + * + * @param sb pointer to superblock + */ +uint32_t ext2_superblock_get_block_group_count(ext2_superblock_t *sb) +{ + /* We add one to the result because e.g. 2/3 = 0, while to store + * 2 blocks in 3-block group we need one (1) block group + * + * We subtract one first because of special case that to store e.g. + * 3 blocks in a 3-block group we need only one group + * (and 3/3 yields one - this is one more that we want as we + * already add one at the end) + */ + return ((ext2_superblock_get_total_block_count(sb)-1) / + ext2_superblock_get_blocks_per_group(sb))+1; +} + +/** Read a superblock directly from device (i.e. no libblock cache) + * + * @param devmap_handle Device handle of the block device. + * @param superblock Pointer where to store pointer to new superblock + * + * @return EOK on success or negative error code on failure. + */ +int ext2_superblock_read_direct(devmap_handle_t devmap_handle, + ext2_superblock_t **superblock) +{ + void *data; + int rc; + + data = malloc(EXT2_SUPERBLOCK_SIZE); + if (data == NULL) { + return ENOMEM; + } + + rc = block_read_bytes_direct(devmap_handle, EXT2_SUPERBLOCK_OFFSET, + EXT2_SUPERBLOCK_SIZE, data); + if (rc != EOK) { + free(data); + return rc; + } + + (*superblock) = data; + return EOK; +} + +/** Check a superblock for sanity + * + * @param sb Pointer to superblock + * + * @return EOK on success or negative error code on failure. + */ +int ext2_superblock_check_sanity(ext2_superblock_t *sb) +{ + if (ext2_superblock_get_magic(sb) != EXT2_SUPERBLOCK_MAGIC) { + return ENOTSUP; + } + + if (ext2_superblock_get_rev_major(sb) > 1) { + return ENOTSUP; + } + + if (ext2_superblock_get_total_inode_count(sb) == 0) { + return ENOTSUP; + } + + if (ext2_superblock_get_total_block_count(sb) == 0) { + return ENOTSUP; + } + + if (ext2_superblock_get_blocks_per_group(sb) == 0) { + return ENOTSUP; + } + + if (ext2_superblock_get_fragments_per_group(sb) == 0) { + return ENOTSUP; + } + + /* We don't support fragments smaller than block */ + if (ext2_superblock_get_block_size(sb) != + ext2_superblock_get_fragment_size(sb)) { + return ENOTSUP; + } + if (ext2_superblock_get_blocks_per_group(sb) != + ext2_superblock_get_fragments_per_group(sb)) { + return ENOTSUP; + } + + if (ext2_superblock_get_inodes_per_group(sb) == 0) { + return ENOTSUP; + } + + if (ext2_superblock_get_inode_size(sb) < 128) { + return ENOTSUP; + } + + if (ext2_superblock_get_first_inode(sb) < 11) { + return ENOTSUP; + } + + return EOK; +} + + +/** @} + */ Index: uspace/lib/ext2/libext2_superblock.h =================================================================== --- uspace/lib/ext2/libext2_superblock.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/ext2/libext2_superblock.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,118 @@ +/* + * Copyright (c) 2011 Martin Sucha + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext2 + * @{ + */ +/** + * @file + */ + +#ifndef LIBEXT2_LIBEXT2_SUPERBLOCK_H_ +#define LIBEXT2_LIBEXT2_SUPERBLOCK_H_ + +#include + +typedef struct ext2_superblock { + uint32_t total_inode_count; // Total number of inodes + uint32_t total_block_count; // Total number of blocks + uint32_t reserved_block_count; // Total number of reserved blocks + uint32_t free_block_count; // Total number of free blocks + uint32_t free_inode_count; // Total number of free inodes + uint32_t first_block; // Block containing the superblock (either 0 or 1) + uint32_t block_size_log2; // log_2(block_size) + int32_t fragment_size_log2; // log_2(fragment size) + uint32_t blocks_per_group; // Number of blocks in one block group + uint32_t fragments_per_group; // Number of fragments per block group + uint32_t inodes_per_group; // Number of inodes per block group + uint8_t unused2[12]; + uint16_t magic; // Magic value + uint16_t state; // State (mounted/unmounted) + uint16_t error_behavior; // What to do when errors are encountered + uint16_t rev_minor; // Minor revision level + uint8_t unused3[8]; + uint32_t os; // OS that created the filesystem + uint32_t rev_major; // Major revision level + uint8_t unused4[4]; + + // Following is for ext2 revision 1 only + uint32_t first_inode; + uint16_t inode_size; + uint16_t unused5; + uint32_t features_compatible; + uint32_t features_incompatible; + uint32_t features_read_only; + uint8_t uuid[16]; // UUID TODO: Create a library for UUIDs + uint8_t volume_name[16]; + +// TODO: add __attribute__((aligned(...)) for better performance? +// (it is necessary to ensure the superblock is correctly aligned then +// though) +} __attribute__ ((packed)) ext2_superblock_t; + +#define EXT2_SUPERBLOCK_MAGIC 0xEF53 +#define EXT2_SUPERBLOCK_SIZE 1024 +#define EXT2_SUPERBLOCK_OFFSET 1024 +#define EXT2_SUPERBLOCK_LAST_BYTE (EXT2_SUPERBLOCK_OFFSET + \ + EXT2_SUPERBLOCK_SIZE -1) +#define EXT2_SUPERBLOCK_OS_LINUX 0 +#define EXT2_SUPERBLOCK_OS_HURD 1 + + +extern uint16_t ext2_superblock_get_magic(ext2_superblock_t *); +extern uint32_t ext2_superblock_get_first_block(ext2_superblock_t *); +extern uint32_t ext2_superblock_get_block_size_log2(ext2_superblock_t *); +extern uint32_t ext2_superblock_get_block_size(ext2_superblock_t *); +extern int32_t ext2_superblock_get_fragment_size_log2(ext2_superblock_t *); +extern uint32_t ext2_superblock_get_fragment_size(ext2_superblock_t *); +extern uint32_t ext2_superblock_get_blocks_per_group(ext2_superblock_t *); +extern uint32_t ext2_superblock_get_fragments_per_group(ext2_superblock_t *); +extern uint16_t ext2_superblock_get_state(ext2_superblock_t *); +extern uint16_t ext2_superblock_get_rev_minor(ext2_superblock_t *); +extern uint32_t ext2_superblock_get_rev_major(ext2_superblock_t *); +extern uint32_t ext2_superblock_get_os(ext2_superblock_t *); +extern uint32_t ext2_superblock_get_first_inode(ext2_superblock_t *); +extern uint16_t ext2_superblock_get_inode_size(ext2_superblock_t *); +extern uint32_t ext2_superblock_get_total_inode_count(ext2_superblock_t *); +extern uint32_t ext2_superblock_get_total_block_count(ext2_superblock_t *); +extern uint32_t ext2_superblock_get_reserved_block_count(ext2_superblock_t *); +extern uint32_t ext2_superblock_get_free_block_count(ext2_superblock_t *); +extern uint32_t ext2_superblock_get_free_inode_count(ext2_superblock_t *); +extern uint32_t ext2_superblock_get_block_group_count(ext2_superblock_t *); +extern uint32_t ext2_superblock_get_inodes_per_group(ext2_superblock_t *); +extern uint32_t ext2_superblock_get_features_compatible(ext2_superblock_t *); +extern uint32_t ext2_superblock_get_features_incompatible(ext2_superblock_t *); +extern uint32_t ext2_superblock_get_features_read_only(ext2_superblock_t *); + +extern int ext2_superblock_read_direct(devmap_handle_t, ext2_superblock_t **); +extern int ext2_superblock_check_sanity(ext2_superblock_t *); + +#endif + +/** @} + */ Index: uspace/lib/fs/libfs.c =================================================================== --- uspace/lib/fs/libfs.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/fs/libfs.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -67,16 +67,16 @@ * code. * - * @param vfs_phone Open phone for communication with VFS. - * @param reg File system registration structure. It will be - * initialized by this function. - * @param info VFS info structure supplied by the file system - * implementation. - * @param conn Connection fibril for handling all calls originating in - * VFS. + * @param sess Session for communication with VFS. + * @param reg File system registration structure. It will be + * initialized by this function. + * @param info VFS info structure supplied by the file system + * implementation. + * @param conn Connection fibril for handling all calls originating in + * VFS. * * @return EOK on success or a non-zero error code on errror. * */ -int fs_register(int vfs_phone, fs_reg_t *reg, vfs_info_t *info, +int fs_register(async_sess_t *sess, fs_reg_t *reg, vfs_info_t *info, async_client_conn_t conn) { @@ -86,12 +86,17 @@ * out-of-order, when it knows that the operation succeeded or failed. */ + + async_exch_t *exch = async_exchange_begin(sess); + ipc_call_t answer; - aid_t req = async_send_0(vfs_phone, VFS_IN_REGISTER, &answer); + aid_t req = async_send_0(exch, VFS_IN_REGISTER, &answer); /* * Send our VFS info structure to VFS. */ - int rc = async_data_write_start(vfs_phone, info, sizeof(*info)); + int rc = async_data_write_start(exch, info, sizeof(*info)); + if (rc != EOK) { + async_exchange_end(exch); async_wait_for(req, NULL); return rc; @@ -101,5 +106,5 @@ * Ask VFS for callback connection. */ - async_connect_to_me(vfs_phone, 0, 0, 0, conn); + async_connect_to_me(exch, 0, 0, 0, conn); /* @@ -108,4 +113,5 @@ reg->plb_ro = as_get_mappable_page(PLB_SIZE); if (!reg->plb_ro) { + async_exchange_end(exch); async_wait_for(req, NULL); return ENOMEM; @@ -115,5 +121,8 @@ * Request sharing the Path Lookup Buffer with VFS. */ - rc = async_share_in_start_0_0(vfs_phone, reg->plb_ro, PLB_SIZE); + rc = async_share_in_start_0_0(exch, reg->plb_ro, PLB_SIZE); + + async_exchange_end(exch); + if (rc) { async_wait_for(req, NULL); @@ -148,27 +157,15 @@ fs_handle_t mr_fs_handle = (fs_handle_t) IPC_GET_ARG3(*request); devmap_handle_t mr_devmap_handle = (devmap_handle_t) IPC_GET_ARG4(*request); - int res; - sysarg_t rc; - - ipc_call_t call; - ipc_callid_t callid; - - /* Accept the phone */ - callid = async_get_call(&call); - int mountee_phone = (int) IPC_GET_ARG1(call); - if ((IPC_GET_IMETHOD(call) != IPC_M_CONNECTION_CLONE) || - (mountee_phone < 0)) { - async_answer_0(callid, EINVAL); + + async_sess_t *mountee_sess = async_clone_receive(EXCHANGE_PARALLEL); + if (mountee_sess == NULL) { async_answer_0(rid, EINVAL); return; } - /* Acknowledge the mountee_phone */ - async_answer_0(callid, EOK); - fs_node_t *fn; - res = ops->node_get(&fn, mp_devmap_handle, mp_fs_index); + int res = ops->node_get(&fn, mp_devmap_handle, mp_fs_index); if ((res != EOK) || (!fn)) { - async_hangup(mountee_phone); + async_hangup(mountee_sess); async_data_write_void(combine_rc(res, ENOENT)); async_answer_0(rid, combine_rc(res, ENOENT)); @@ -177,5 +174,5 @@ if (fn->mp_data.mp_active) { - async_hangup(mountee_phone); + async_hangup(mountee_sess); (void) ops->node_put(fn); async_data_write_void(EBUSY); @@ -184,16 +181,20 @@ } - rc = async_req_0_0(mountee_phone, IPC_M_CONNECT_ME); - if (rc != EOK) { - async_hangup(mountee_phone); + async_exch_t *exch = async_exchange_begin(mountee_sess); + async_sess_t *sess = async_connect_me(EXCHANGE_PARALLEL, exch); + + if (!sess) { + async_exchange_end(exch); + async_hangup(mountee_sess); (void) ops->node_put(fn); - async_data_write_void(rc); - async_answer_0(rid, rc); + async_data_write_void(errno); + async_answer_0(rid, errno); return; } ipc_call_t answer; - rc = async_data_write_forward_1_1(mountee_phone, VFS_OUT_MOUNTED, + int rc = async_data_write_forward_1_1(exch, VFS_OUT_MOUNTED, mr_devmap_handle, &answer); + async_exchange_end(exch); if (rc == EOK) { @@ -201,5 +202,5 @@ fn->mp_data.fs_handle = mr_fs_handle; fn->mp_data.devmap_handle = mr_devmap_handle; - fn->mp_data.phone = mountee_phone; + fn->mp_data.sess = mountee_sess; } @@ -236,6 +237,7 @@ * Tell the mounted file system to unmount. */ - res = async_req_1_0(fn->mp_data.phone, VFS_OUT_UNMOUNTED, - fn->mp_data.devmap_handle); + async_exch_t *exch = async_exchange_begin(fn->mp_data.sess); + res = async_req_1_0(exch, VFS_OUT_UNMOUNTED, fn->mp_data.devmap_handle); + async_exchange_end(exch); /* @@ -243,9 +245,10 @@ */ if (res == EOK) { - async_hangup(fn->mp_data.phone); + async_hangup(fn->mp_data.sess); fn->mp_data.mp_active = false; fn->mp_data.fs_handle = 0; fn->mp_data.devmap_handle = 0; - fn->mp_data.phone = 0; + fn->mp_data.sess = NULL; + /* Drop the reference created in libfs_mount(). */ (void) ops->node_put(fn); @@ -293,7 +296,9 @@ if (cur->mp_data.mp_active) { - async_forward_slow(rid, cur->mp_data.phone, VFS_OUT_LOOKUP, - next, last, cur->mp_data.devmap_handle, lflag, index, - IPC_FF_ROUTE_FROM_ME); + async_exch_t *exch = async_exchange_begin(cur->mp_data.sess); + async_forward_slow(rid, exch, VFS_OUT_LOOKUP, next, last, + cur->mp_data.devmap_handle, lflag, index, IPC_FF_ROUTE_FROM_ME); + async_exchange_end(exch); + (void) ops->node_put(cur); return; @@ -351,7 +356,10 @@ next--; - async_forward_slow(rid, tmp->mp_data.phone, - VFS_OUT_LOOKUP, next, last, tmp->mp_data.devmap_handle, - lflag, index, IPC_FF_ROUTE_FROM_ME); + async_exch_t *exch = async_exchange_begin(tmp->mp_data.sess); + async_forward_slow(rid, exch, VFS_OUT_LOOKUP, next, last, + tmp->mp_data.devmap_handle, lflag, index, + IPC_FF_ROUTE_FROM_ME); + async_exchange_end(exch); + (void) ops->node_put(cur); (void) ops->node_put(tmp); Index: uspace/lib/fs/libfs.h =================================================================== --- uspace/lib/fs/libfs.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/fs/libfs.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -44,5 +44,5 @@ typedef struct { bool mp_active; - int phone; + async_sess_t *sess; fs_handle_t fs_handle; devmap_handle_t devmap_handle; @@ -88,5 +88,6 @@ } fs_reg_t; -extern int fs_register(int, fs_reg_t *, vfs_info_t *, async_client_conn_t); +extern int fs_register(async_sess_t *, fs_reg_t *, vfs_info_t *, + async_client_conn_t); extern void fs_node_initialize(fs_node_t *); Index: uspace/lib/net/generic/generic.c =================================================================== --- uspace/lib/net/generic/generic.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/net/generic/generic.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -37,4 +37,5 @@ #include #include +#include #include #include @@ -56,5 +57,5 @@ int state, services_t target) { - async_msg_3(phone, (sysarg_t) message, (sysarg_t) device_id, + async_obsolete_msg_3(phone, (sysarg_t) message, (sysarg_t) device_id, (sysarg_t) state, target); @@ -78,5 +79,5 @@ int arg2, services_t service) { - return (int) async_req_3_0(phone, (sysarg_t) message, + return (int) async_obsolete_req_3_0(phone, (sysarg_t) message, (sysarg_t) device_id, (sysarg_t) arg2, (sysarg_t) service); } @@ -107,5 +108,5 @@ /* Request the address */ - message_id = async_send_1(phone, (sysarg_t) message, + message_id = async_obsolete_send_1(phone, (sysarg_t) message, (sysarg_t) device_id, NULL); string = measured_strings_return(phone, address, data, 1); @@ -145,5 +146,5 @@ sysarg_t suffix; - sysarg_t result = async_req_1_4(phone, (sysarg_t) message, + sysarg_t result = async_obsolete_req_1_4(phone, (sysarg_t) message, (sysarg_t) device_id, &addr_len, &prefix, &content, &suffix); @@ -172,8 +173,8 @@ { if (error) { - async_msg_4(phone, (sysarg_t) message, (sysarg_t) device_id, + async_obsolete_msg_4(phone, (sysarg_t) message, (sysarg_t) device_id, (sysarg_t) packet_id, (sysarg_t) target, (sysarg_t) error); } else { - async_msg_3(phone, (sysarg_t) message, (sysarg_t) device_id, + async_obsolete_msg_3(phone, (sysarg_t) message, (sysarg_t) device_id, (sysarg_t) packet_id, (sysarg_t) target); } @@ -198,8 +199,8 @@ { if (error) { - async_msg_4(phone, (sysarg_t) message, (sysarg_t) device_id, + async_obsolete_msg_4(phone, (sysarg_t) message, (sysarg_t) device_id, (sysarg_t) packet_id, (sysarg_t) sender, (sysarg_t) error); } else { - async_msg_3(phone, (sysarg_t) message, (sysarg_t) device_id, + async_obsolete_msg_3(phone, (sysarg_t) message, (sysarg_t) device_id, (sysarg_t) packet_id, (sysarg_t) sender); } @@ -243,5 +244,5 @@ /* Request the translation */ - message_id = async_send_3(phone, (sysarg_t) message, + message_id = async_obsolete_send_3(phone, (sysarg_t) message, (sysarg_t) device_id, (sysarg_t) count, (sysarg_t) service, NULL); measured_strings_send(phone, configuration, count); Index: uspace/lib/net/generic/packet_remote.c =================================================================== --- uspace/lib/net/generic/packet_remote.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/net/generic/packet_remote.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -37,4 +37,5 @@ #include +#include #include #include @@ -59,5 +60,5 @@ * @return EOK on success. * @return Other error codes as defined for the pm_add() function. - * @return Other error codes as defined for the async_share_in_start() function. + * @return Other error codes as defined for the async_obsolete_share_in_start() function. * */ @@ -69,8 +70,8 @@ int rc; - message = async_send_1(phone, NET_PACKET_GET, packet_id, &answer); + message = async_obsolete_send_1(phone, NET_PACKET_GET, packet_id, &answer); *packet = (packet_t *) as_get_mappable_page(size); - rc = async_share_in_start_0_0(phone, *packet, size); + rc = async_obsolete_share_in_start_0_0(phone, *packet, size); if (rc != EOK) { munmap(*packet, size); @@ -117,5 +118,5 @@ sysarg_t size; - rc = async_req_1_1(phone, NET_PACKET_GET_SIZE, packet_id, + rc = async_obsolete_req_1_1(phone, NET_PACKET_GET_SIZE, packet_id, &size); if (rc != EOK) @@ -154,5 +155,5 @@ int rc; - rc = async_req_4_2(phone, NET_PACKET_CREATE_4, max_content, addr_len, + rc = async_obsolete_req_4_2(phone, NET_PACKET_CREATE_4, max_content, addr_len, max_prefix, max_suffix, &packet_id, &size); if (rc != EOK) @@ -185,5 +186,5 @@ int rc; - rc = async_req_1_2(phone, NET_PACKET_CREATE_1, content, &packet_id, + rc = async_obsolete_req_1_2(phone, NET_PACKET_CREATE_1, content, &packet_id, &size); if (rc != EOK) @@ -212,5 +213,5 @@ void pq_release_remote(int phone, packet_id_t packet_id) { - async_msg_1(phone, NET_PACKET_RELEASE, packet_id); + async_obsolete_msg_1(phone, NET_PACKET_RELEASE, packet_id); } Index: uspace/lib/net/il/arp_remote.c =================================================================== --- uspace/lib/net/il/arp_remote.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/net/il/arp_remote.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -40,4 +40,5 @@ #include +#include #include #include @@ -68,5 +69,5 @@ int arp_clean_cache_req(int arp_phone) { - return (int) async_req_0_0(arp_phone, NET_ARP_CLEAN_CACHE); + return (int) async_obsolete_req_0_0(arp_phone, NET_ARP_CLEAN_CACHE); } @@ -87,5 +88,5 @@ sysarg_t result; - message_id = async_send_2(arp_phone, NET_ARP_CLEAR_ADDRESS, + message_id = async_obsolete_send_2(arp_phone, NET_ARP_CLEAR_ADDRESS, (sysarg_t) device_id, protocol, NULL); measured_strings_send(arp_phone, address, 1); @@ -104,5 +105,5 @@ int arp_clear_device_req(int arp_phone, device_id_t device_id) { - return (int) async_req_1_0(arp_phone, NET_ARP_CLEAR_DEVICE, + return (int) async_obsolete_req_1_0(arp_phone, NET_ARP_CLEAR_DEVICE, (sysarg_t) device_id); } @@ -137,5 +138,5 @@ sysarg_t result; - message_id = async_send_3(arp_phone, NET_ARP_DEVICE, + message_id = async_obsolete_send_3(arp_phone, NET_ARP_DEVICE, (sysarg_t) device_id, protocol, netif, NULL); measured_strings_send(arp_phone, address, 1); Index: uspace/lib/net/il/il_skel.c =================================================================== --- uspace/lib/net/il/il_skel.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/net/il/il_skel.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -42,4 +42,7 @@ #include +// FIXME: remove this header +#include + /** Default thread for new connections. * @@ -75,6 +78,5 @@ * result. */ - if ((IPC_GET_IMETHOD(call) == IPC_M_PHONE_HUNGUP) || - (res == EHANGUP)) + if ((!IPC_GET_IMETHOD(call)) || (res == EHANGUP)) return; Index: uspace/lib/net/il/ip_client.c =================================================================== --- uspace/lib/net/il/ip_client.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/net/il/ip_client.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -181,6 +181,6 @@ /* Set the header */ header = (ip_header_t *) data; - header->header_length = IP_COMPUTE_HEADER_LENGTH(sizeof(ip_header_t) + - ipopt_length); + SET_IP_HEADER_LENGTH(header, + (IP_COMPUTE_HEADER_LENGTH(sizeof(ip_header_t) + ipopt_length))); header->ttl = (ttl ? ttl : IPDEFTTL); header->tos = tos; @@ -188,5 +188,5 @@ if (dont_fragment) - header->flags = IPFLAG_DONT_FRAGMENT; + SET_IP_HEADER_FLAGS(header, IPFLAG_DONT_FRAGMENT); return EOK; @@ -227,5 +227,5 @@ *tos = header->tos; if (dont_fragment) - *dont_fragment = header->flags & IPFLAG_DONT_FRAGMENT; + *dont_fragment = GET_IP_HEADER_FLAGS(header) & IPFLAG_DONT_FRAGMENT; if (ipopt_length) { *ipopt_length = IP_HEADER_LENGTH(header) - sizeof(ip_header_t); Index: uspace/lib/net/il/ip_remote.c =================================================================== --- uspace/lib/net/il/ip_remote.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/net/il/ip_remote.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -44,5 +44,5 @@ #include #include - +#include #include #include @@ -66,5 +66,5 @@ in_addr_t address, in_addr_t netmask, in_addr_t gateway) { - return (int) async_req_4_0(ip_phone, NET_IP_ADD_ROUTE, + return (int) async_obsolete_req_4_0(ip_phone, NET_IP_ADD_ROUTE, (sysarg_t) device_id, (sysarg_t) gateway.s_addr, (sysarg_t) address.s_addr, (sysarg_t) netmask.s_addr); @@ -150,13 +150,13 @@ ipc_call_t answer; - aid_t message_id = async_send_1(ip_phone, NET_IP_GET_ROUTE, + aid_t message_id = async_obsolete_send_1(ip_phone, NET_IP_GET_ROUTE, (sysarg_t) protocol, &answer); - if ((async_data_write_start(ip_phone, destination, addrlen) == EOK) && - (async_data_read_start(ip_phone, headerlen, + if ((async_obsolete_data_write_start(ip_phone, destination, addrlen) == EOK) && + (async_obsolete_data_read_start(ip_phone, headerlen, sizeof(*headerlen)) == EOK) && (*headerlen > 0)) { *header = malloc(*headerlen); if (*header) { - if (async_data_read_start(ip_phone, *header, + if (async_obsolete_data_read_start(ip_phone, *header, *headerlen) != EOK) free(*header); @@ -243,5 +243,5 @@ in_addr_t gateway) { - return (int) async_req_2_0(ip_phone, NET_IP_SET_GATEWAY, + return (int) async_obsolete_req_2_0(ip_phone, NET_IP_SET_GATEWAY, (sysarg_t) device_id, (sysarg_t) gateway.s_addr); } Index: uspace/lib/net/include/ip_header.h =================================================================== --- uspace/lib/net/include/ip_header.h (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/net/include/ip_header.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -64,5 +64,5 @@ */ #define IP_FRAGMENT_OFFSET(header) \ - ((((header)->fragment_offset_high << 8) + \ + (((GET_IP_HEADER_FRAGMENT_OFFSET_HIGH(header) << 8) + \ (header)->fragment_offset_low) * 8U) @@ -83,5 +83,5 @@ */ #define IP_HEADER_LENGTH(header) \ - ((header)->header_length * 4U) + (GET_IP_HEADER_LENGTH(header) * 4U) /** Returns the actual IP packet total length. @@ -143,11 +143,17 @@ */ struct ip_header { -#ifdef ARCH_IS_BIG_ENDIAN - uint8_t version : 4; - uint8_t header_length : 4; -#else - uint8_t header_length : 4; - uint8_t version : 4; -#endif + uint8_t vhl; /* version, header_length */ + +#define GET_IP_HEADER_VERSION(header) \ + (((header)->vhl & 0xf0) >> 4) +#define SET_IP_HEADER_VERSION(header, version) \ + ((header)->vhl = \ + ((version & 0x0f) << 4) | ((header)->vhl & 0x0f)) + +#define GET_IP_HEADER_LENGTH(header) \ + ((header)->vhl & 0x0f) +#define SET_IP_HEADER_LENGTH(header, length) \ + ((header)->vhl = \ + (length & 0x0f) | ((header)->vhl & 0xf0)) uint8_t tos; @@ -155,11 +161,17 @@ uint16_t identification; -#ifdef ARCH_IS_BIG_ENDIAN - uint8_t flags : 3; - uint8_t fragment_offset_high : 5; -#else - uint8_t fragment_offset_high : 5; - uint8_t flags : 3; -#endif + uint8_t ffoh; /* flags, fragment_offset_high */ + +#define GET_IP_HEADER_FLAGS(header) \ + (((header)->ffoh & 0xe0) >> 5) +#define SET_IP_HEADER_FLAGS(header, flags) \ + ((header)->ffoh = \ + ((flags & 0x07) << 5) | ((header)->ffoh & 0x1f)) + +#define GET_IP_HEADER_FRAGMENT_OFFSET_HIGH(header) \ + ((header)->ffoh & 0x1f) +#define SET_IP_HEADER_FRAGMENT_OFFSET_HIGH(header, fragment_offset_high) \ + ((header)->ffoh = \ + (fragment_offset_high & 0x1f) | ((header)->ffoh & 0xe0)) uint8_t fragment_offset_low; @@ -181,11 +193,18 @@ uint8_t pointer; -#ifdef ARCH_IS_BIG_ENDIAN - uint8_t overflow : 4; - uint8_t flags : 4; -#else - uint8_t flags : 4; - uint8_t overflow : 4; -#endif + uint8_t of; /* overflow, flags */ + +#define GET_IP_OPTION_OVERFLOW(option) \ + (((option)->of & 0xf0) >> 4) +#define SET_IP_OPTION_OVERFLOW(option, overflow) \ + ((option)->of = \ + ((overflow & 0x0f) << 4) | ((option)->of & 0x0f)) + +#define GET_IP_OPTION_FLAGS(option) \ + ((option)->of & 0x0f) +#define SET_IP_OPTION_FLAGS(option, flags) \ + ((option)->of = \ + (flags & 0x0f) | ((option)->of & 0xf0)) + } __attribute__ ((packed)); Index: uspace/lib/net/netif/netif_remote.c =================================================================== --- uspace/lib/net/netif/netif_remote.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/net/netif/netif_remote.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -38,5 +38,5 @@ #include #include - +#include #include #include @@ -82,5 +82,5 @@ int netif_probe_req(int netif_phone, device_id_t device_id, int irq, void *io) { - return async_req_3_0(netif_phone, NET_NETIF_PROBE, device_id, irq, + return async_obsolete_req_3_0(netif_phone, NET_NETIF_PROBE, device_id, irq, (sysarg_t) io); } @@ -119,5 +119,5 @@ int netif_start_req(int netif_phone, device_id_t device_id) { - return async_req_1_0(netif_phone, NET_NETIF_START, device_id); + return async_obsolete_req_1_0(netif_phone, NET_NETIF_START, device_id); } @@ -136,5 +136,5 @@ int netif_stop_req(int netif_phone, device_id_t device_id) { - return async_req_1_0(netif_phone, NET_NETIF_STOP, device_id); + return async_obsolete_req_1_0(netif_phone, NET_NETIF_STOP, device_id); } @@ -154,7 +154,7 @@ return EBADMEM; - aid_t message_id = async_send_1(netif_phone, NET_NETIF_STATS, + aid_t message_id = async_obsolete_send_1(netif_phone, NET_NETIF_STATS, (sysarg_t) device_id, NULL); - async_data_read_start(netif_phone, stats, sizeof(*stats)); + async_obsolete_data_read_start(netif_phone, stats, sizeof(*stats)); sysarg_t result; Index: uspace/lib/net/netif/netif_skel.c =================================================================== --- uspace/lib/net/netif/netif_skel.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/net/netif/netif_skel.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -54,4 +54,7 @@ #include +// FIXME: remove this header +#include + DEVICE_MAP_IMPLEMENT(netif_device_map, netif_device_t); @@ -288,8 +291,8 @@ *count = 0; + if (!IPC_GET_IMETHOD(*call)) + return EOK; + switch (IPC_GET_IMETHOD(*call)) { - case IPC_M_PHONE_HUNGUP: - return EOK; - case NET_NETIF_PROBE: return netif_probe_req_local(0, IPC_GET_DEVICE(*call), @@ -385,6 +388,5 @@ /* End if said to either by the message or the processing result */ - if ((IPC_GET_IMETHOD(call) == IPC_M_PHONE_HUNGUP) || - (res == EHANGUP)) + if ((!IPC_GET_IMETHOD(call)) || (res == EHANGUP)) return; Index: uspace/lib/net/nil/nil_skel.c =================================================================== --- uspace/lib/net/nil/nil_skel.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/net/nil/nil_skel.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -42,4 +42,7 @@ #include +// FIXME: remove this header +#include + /** Default thread for new connections. * @@ -75,6 +78,5 @@ * result. */ - if ((IPC_GET_IMETHOD(call) == IPC_M_PHONE_HUNGUP) || - (res == EHANGUP)) + if ((!IPC_GET_IMETHOD(call)) || (res == EHANGUP)) return; Index: uspace/lib/net/tl/icmp_remote.c =================================================================== --- uspace/lib/net/tl/icmp_remote.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/net/tl/icmp_remote.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -41,4 +41,5 @@ #include +#include #include #include @@ -64,5 +65,5 @@ icmp_param_t mtu, packet_t *packet) { - async_msg_3(icmp_phone, NET_ICMP_DEST_UNREACH, (sysarg_t) code, + async_obsolete_msg_3(icmp_phone, NET_ICMP_DEST_UNREACH, (sysarg_t) code, (sysarg_t) packet_get_id(packet), (sysarg_t) mtu); return EOK; @@ -83,5 +84,5 @@ int icmp_source_quench_msg(int icmp_phone, packet_t *packet) { - async_msg_2(icmp_phone, NET_ICMP_SOURCE_QUENCH, 0, + async_obsolete_msg_2(icmp_phone, NET_ICMP_SOURCE_QUENCH, 0, (sysarg_t) packet_get_id(packet)); return EOK; @@ -103,5 +104,5 @@ int icmp_time_exceeded_msg(int icmp_phone, icmp_code_t code, packet_t *packet) { - async_msg_2(icmp_phone, NET_ICMP_TIME_EXCEEDED, (sysarg_t) code, + async_obsolete_msg_2(icmp_phone, NET_ICMP_TIME_EXCEEDED, (sysarg_t) code, (sysarg_t) packet_get_id(packet)); return EOK; @@ -125,5 +126,5 @@ icmp_param_t pointer, packet_t *packet) { - async_msg_3(icmp_phone, NET_ICMP_PARAMETERPROB, (sysarg_t) code, + async_obsolete_msg_3(icmp_phone, NET_ICMP_PARAMETERPROB, (sysarg_t) code, (sysarg_t) packet_get_id(packet), (sysarg_t) pointer); return EOK; Index: uspace/lib/net/tl/tl_skel.c =================================================================== --- uspace/lib/net/tl/tl_skel.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/net/tl/tl_skel.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -42,4 +42,7 @@ #include +// FIXME: remove this header +#include + /** Default thread for new connections. * @@ -77,6 +80,5 @@ * result. */ - if ((IPC_GET_IMETHOD(call) == IPC_M_PHONE_HUNGUP) || - (res == EHANGUP)) + if ((!IPC_GET_IMETHOD(call)) || (res == EHANGUP)) return; Index: uspace/lib/packet/generic/packet_server.c =================================================================== --- uspace/lib/packet/generic/packet_server.c (revision 9536e6ec91688bf386cf5f5e8f86fd2fb06546e2) +++ uspace/lib/packet/generic/packet_server.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -324,8 +324,9 @@ *answer_count = 0; + + if (!IPC_GET_IMETHOD(*call)) + return EOK; + switch (IPC_GET_IMETHOD(*call)) { - case IPC_M_PHONE_HUNGUP: - return EOK; - case NET_PACKET_CREATE_1: packet = packet_get_local(DEFAULT_ADDR_LEN, DEFAULT_PREFIX, Index: uspace/lib/usb/Makefile =================================================================== --- uspace/lib/usb/Makefile (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usb/Makefile (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,44 @@ +# +# Copyright (c) 2010 Vojtech Horky +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# - Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# - Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# - The name of the author may not be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +USPACE_PREFIX = ../.. +LIBRARY = libusb +EXTRA_CFLAGS += \ + -I$(LIBDRV_PREFIX)/include \ + -Iinclude + +SOURCES = \ + src/class.c \ + src/ddfiface.c \ + src/debug.c \ + src/dump.c \ + src/hc.c \ + src/resolve.c \ + src/usb.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/lib/usb/include/usb/classes/classes.h =================================================================== --- uspace/lib/usb/include/usb/classes/classes.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usb/include/usb/classes/classes.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,67 @@ +/* + * Copyright (c) 2010 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusb + * @{ + */ +/** @file + * USB device classes (generic constants and functions). + */ +#ifndef LIBUSB_CLASSES_H_ +#define LIBUSB_CLASSES_H_ + +/** USB device class. */ +typedef enum { + USB_CLASS_USE_INTERFACE = 0x00, + USB_CLASS_AUDIO = 0x01, + USB_CLASS_COMMUNICATIONS_CDC_CONTROL = 0x02, + USB_CLASS_HID = 0x03, + USB_CLASS_PHYSICAL = 0x05, + USB_CLASS_IMAGE = 0x06, + USB_CLASS_PRINTER = 0x07, + USB_CLASS_MASS_STORAGE = 0x08, + USB_CLASS_HUB = 0x09, + USB_CLASS_CDC_DATA = 0x0A, + USB_CLASS_SMART_CARD = 0x0B, + USB_CLASS_CONTENT_SECURITY = 0x0D, + USB_CLASS_VIDEO = 0x0E, + USB_CLASS_PERSONAL_HEALTHCARE = 0x0F, + USB_CLASS_DIAGNOSTIC = 0xDC, + USB_CLASS_WIRELESS_CONTROLLER = 0xE0, + USB_CLASS_MISCELLANEOUS = 0xEF, + USB_CLASS_APPLICATION_SPECIFIC = 0xFE, + USB_CLASS_VENDOR_SPECIFIC = 0xFF, + /* USB_CLASS_ = 0x, */ +} usb_class_t; + +const char *usb_str_class(usb_class_t); + +#endif +/** + * @} + */ Index: uspace/lib/usb/include/usb/classes/hub.h =================================================================== --- uspace/lib/usb/include/usb/classes/hub.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usb/include/usb/classes/hub.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,225 @@ +/* + * Copyright (c) 2010 Matus Dekanek + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusb + * @{ + */ +/** @file + * @brief USB hub related structures. + */ +#ifndef LIBUSB_CLASS_HUB_H_ +#define LIBUSB_CLASS_HUB_H_ + +#include + +/** Hub class feature selector. + * @warning The constants are not unique (feature selectors are used + * for hub and port). + */ +typedef enum { + USB_HUB_FEATURE_HUB_LOCAL_POWER = 0, + USB_HUB_FEATURE_HUB_OVER_CURRENT = 1, + USB_HUB_FEATURE_C_HUB_LOCAL_POWER = 0, + USB_HUB_FEATURE_C_HUB_OVER_CURRENT = 1, + USB_HUB_FEATURE_PORT_CONNECTION = 0, + USB_HUB_FEATURE_PORT_ENABLE = 1, + USB_HUB_FEATURE_PORT_SUSPEND = 2, + USB_HUB_FEATURE_PORT_OVER_CURRENT = 3, + USB_HUB_FEATURE_PORT_RESET = 4, + USB_HUB_FEATURE_PORT_POWER = 8, + USB_HUB_FEATURE_PORT_LOW_SPEED = 9, + USB_HUB_FEATURE_C_PORT_CONNECTION = 16, + USB_HUB_FEATURE_C_PORT_ENABLE = 17, + USB_HUB_FEATURE_C_PORT_SUSPEND = 18, + USB_HUB_FEATURE_C_PORT_OVER_CURRENT = 19, + USB_HUB_FEATURE_C_PORT_RESET = 20, + /* USB_HUB_FEATURE_ = , */ +} usb_hub_class_feature_t; + + +/** Header of standard hub descriptor without the "variadic" part. */ +typedef struct { + /** Descriptor length. */ + uint8_t length; + /** Descriptor type (0x29). */ + uint8_t descriptor_type; + /** Number of downstream ports. */ + uint8_t port_count; + /** Characteristics bitmask. */ + uint16_t characteristics; + /** Time from power-on to stabilization of current on the port. */ + uint8_t power_good_time; + /** Maximum current requirements in mA. */ + uint8_t max_current; +} __attribute__ ((packed)) usb_hub_descriptor_header_t; + +/** + * @brief usb hub descriptor + * + * For more information see Universal Serial Bus Specification Revision 1.1 chapter 11.16.2 + */ +typedef struct usb_hub_descriptor_type { + /** Number of bytes in this descriptor, including this byte */ + //uint8_t bDescLength; + + /** Descriptor Type, value: 29H for hub descriptor */ + //uint8_t bDescriptorType; + + /** Number of downstream ports that this hub supports */ + uint8_t ports_count; + + /** + D1...D0: Logical Power Switching Mode + 00: Ganged power switching (all ports power at + once) + 01: Individual port power switching + 1X: Reserved. Used only on 1.0 compliant hubs + that implement no power switching. + D2: Identifies a Compound Device + 0: Hub is not part of a compound device + 1: Hub is part of a compound device + D4...D3: Over-current Protection Mode + 00: Global Over-current Protection. The hub + reports over-current as a summation of all + ports current draw, without a breakdown of + individual port over-current status. + 01: Individual Port Over-current Protection. The + hub reports over-current on a per-port basis. + Each port has an over-current indicator. + 1X: No Over-current Protection. This option is + allowed only for bus-powered hubs that do not + implement over-current protection. + D15...D5: + Reserved + */ + uint16_t hub_characteristics; + + /** + Time (in 2ms intervals) from the time the power-on + sequence begins on a port until power is good on that + port. The USB System Software uses this value to + determine how long to wait before accessing a + powered-on port. + */ + uint8_t pwr_on_2_good_time; + + /** + Maximum current requirements of the Hub Controller + electronics in mA. + */ + uint8_t current_requirement; + + /** + Indicates if a port has a removable device attached. + This field is reported on byte-granularity. Within a + byte, if no port exists for a given location, the field + representing the port characteristics returns 0. + Bit value definition: + 0B - Device is removable + 1B - Device is non-removable + This is a bitmap corresponding to the individual ports + on the hub: + Bit 0: Reserved for future use + Bit 1: Port 1 + Bit 2: Port 2 + .... + Bit n: Port n (implementation-dependent, up to a + maximum of 255 ports). + */ + uint8_t devices_removable[32]; + + /** + This field exists for reasons of compatibility with + software written for 1.0 compliant devices. All bits in + this field should be set to 1B. This field has one bit for + each port on the hub with additional pad bits, if + necessary, to make the number of bits in the field an + integer multiple of 8. + */ + //uint8_t * port_pwr_ctrl_mask; +} usb_hub_descriptor_t; + + + +/** @brief usb hub specific request types. + * + * For more information see Universal Serial Bus Specification Revision 1.1 chapter 11.16.2 + */ +typedef enum { + /** This request resets a value reported in the hub status. */ + USB_HUB_REQ_TYPE_CLEAR_HUB_FEATURE = 0x20, + /** This request resets a value reported in the port status. */ + USB_HUB_REQ_TYPE_CLEAR_PORT_FEATURE = 0x23, + /** This is an optional per-port diagnostic request that returns the bus state value, as sampled at the last EOF2 point. */ + USB_HUB_REQ_TYPE_GET_STATE = 0xA3, + /** This request returns the hub descriptor. */ + USB_HUB_REQ_TYPE_GET_DESCRIPTOR = 0xA0, + /** This request returns the current hub status and the states that have changed since the previous acknowledgment. */ + USB_HUB_REQ_TYPE_GET_HUB_STATUS = 0xA0, + /** This request returns the current port status and the current value of the port status change bits. */ + USB_HUB_REQ_TYPE_GET_PORT_STATUS = 0xA3, + /** This request overwrites the hub descriptor. */ + USB_HUB_REQ_TYPE_SET_DESCRIPTOR = 0x20, + /** This request sets a value reported in the hub status. */ + USB_HUB_REQ_TYPE_SET_HUB_FEATURE = 0x20, + /** This request sets a value reported in the port status. */ + USB_HUB_REQ_TYPE_SET_PORT_FEATURE = 0x23 +} usb_hub_bm_request_type_t; + +/** @brief hub class request codes*/ +/// \TODO these are duplicit to standart descriptors +typedef enum { + /** */ + USB_HUB_REQUEST_GET_STATUS = 0, + /** */ + USB_HUB_REQUEST_CLEAR_FEATURE = 1, + /** */ + USB_HUB_REQUEST_GET_STATE = 2, + /** */ + USB_HUB_REQUEST_SET_FEATURE = 3, + /** */ + USB_HUB_REQUEST_GET_DESCRIPTOR = 6, + /** */ + USB_HUB_REQUEST_SET_DESCRIPTOR = 7 +} usb_hub_request_t; + +/** + * Maximum size of usb hub descriptor in bytes + */ +extern size_t USB_HUB_MAX_DESCRIPTOR_SIZE; + + + + + + + +#endif +/** + * @} + */ Index: uspace/lib/usb/include/usb/classes/massstor.h =================================================================== --- uspace/lib/usb/include/usb/classes/massstor.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usb/include/usb/classes/massstor.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusb + * @{ + */ +/** @file + * USB mass storage related functions and constants. + */ +#ifndef LIBUSB_CLASS_MASSSTOR_H_ +#define LIBUSB_CLASS_MASSSTOR_H_ + +#include + +/** USB mass storage subclasses. */ +typedef enum { + USB_MASSSTOR_SUBCLASS_RBC = 0x01, + /** Also known as MMC-5. */ + USB_MASSSTOR_SUBCLASS_ATAPI = 0x02, + USB_MASSSTOR_SUBCLASS_UFI = 0x04, + USB_MASSSTOR_SUBCLASS_SCSI = 0x06, + USB_MASSSTOR_SUBCLASS_LSDFS = 0x07, + USB_MASSSTOR_SUBCLASS_IEEE1667 = 0x08, + USB_MASSSTOR_SUBCLASS_VENDOR = 0xFF +} usb_massstor_subclass_t; + +/** USB mass storage interface protocols. */ +typedef enum { + /** CBI transport with command completion interrupt. */ + USB_MASSSTOR_PROTOCOL_CBI_CC = 0x00, + /** CBI transport with no command completion interrupt. */ + USB_MASSSTOR_PROTOCOL_CBI = 0x01, + /** Bulk only transport. */ + USB_MASSSTOR_PROTOCOL_BBB = 0x50, + /** USB attached SCSI. */ + USB_MASSSTOR_PROTOCOL_UAS = 0x62, + USB_MASSSTOR_PROTOCOL_VENDOR = 0xFF +} usb_massstor_protocol_t; + +#endif +/** + * @} + */ Index: uspace/lib/usb/include/usb/ddfiface.h =================================================================== --- uspace/lib/usb/include/usb/ddfiface.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usb/include/usb/ddfiface.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusb + * @{ + */ +/** @file + * Implementations of DDF interfaces functions. + */ +#ifndef LIBUSB_DDFIFACE_H_ +#define LIBUSB_DDFIFACE_H_ + +#include +#include + +int usb_iface_get_hc_handle_hub_impl(ddf_fun_t *, devman_handle_t *); +int usb_iface_get_address_hub_impl(ddf_fun_t *, devman_handle_t, + usb_address_t *); +extern usb_iface_t usb_iface_hub_impl; + +int usb_iface_get_hc_handle_hub_child_impl(ddf_fun_t *, devman_handle_t *); +int usb_iface_get_address_hub_child_impl(ddf_fun_t *, devman_handle_t, + usb_address_t *); +extern usb_iface_t usb_iface_hub_child_impl; + +int usb_iface_get_hc_handle_hc_impl(ddf_fun_t *, devman_handle_t *); + + +#endif +/** + * @} + */ Index: uspace/lib/usb/include/usb/debug.h =================================================================== --- uspace/lib/usb/include/usb/debug.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usb/include/usb/debug.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,125 @@ +/* + * Copyright (c) 2010-2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusb + * @{ + */ +/** @file + * Debugging related functions. + */ +#ifndef LIBUSB_DEBUG_H_ +#define LIBUSB_DEBUG_H_ +#include +#include +#include +#include + +void usb_dump_standard_descriptor(FILE *, const char *, const char *, + const uint8_t *, size_t); + +/** Logging level. */ +typedef enum { + /** Fatal, unrecoverable, error. + * Such error prevents the driver from working at all. + */ + USB_LOG_LEVEL_FATAL, + + /** Serious but recoverable error + * Shall be used for errors fatal for single device but not for + * driver itself. + */ + USB_LOG_LEVEL_ERROR, + + /** Warning. + * Problems from which the driver is able to recover gracefully. + */ + USB_LOG_LEVEL_WARNING, + + /** Information message. + * This should be the last level that is printed by default to + * the screen. + * Typical usage is to inform that new device was found and what + * are its capabilities. + * Do not use for repetitive actions (such as device polling). + */ + USB_LOG_LEVEL_INFO, + + /** Debugging message. */ + USB_LOG_LEVEL_DEBUG, + + /** More detailed debugging message. */ + USB_LOG_LEVEL_DEBUG2, + + /** Terminating constant for logging levels. */ + USB_LOG_LEVEL_MAX +} usb_log_level_t; + +/** Default log level. */ +#ifdef CONFIG_USB_RELEASE_BUILD +# define USB_LOG_LEVEL_DEFAULT USB_LOG_LEVEL_INFO +#else +# define USB_LOG_LEVEL_DEFAULT USB_LOG_LEVEL_DEBUG +#endif + +void usb_log_enable(usb_log_level_t, const char *); + +void usb_log_printf(usb_log_level_t, const char *, ...) + PRINTF_ATTRIBUTE(2, 3); + +/** Log fatal error. */ +#define usb_log_fatal(format, ...) \ + usb_log_printf(USB_LOG_LEVEL_FATAL, format, ##__VA_ARGS__) + +/** Log normal (recoverable) error. */ +#define usb_log_error(format, ...) \ + usb_log_printf(USB_LOG_LEVEL_ERROR, format, ##__VA_ARGS__) + +/** Log warning. */ +#define usb_log_warning(format, ...) \ + usb_log_printf(USB_LOG_LEVEL_WARNING, format, ##__VA_ARGS__) + +/** Log informational message. */ +#define usb_log_info(format, ...) \ + usb_log_printf(USB_LOG_LEVEL_INFO, format, ##__VA_ARGS__) + +/** Log debugging message. */ +#define usb_log_debug(format, ...) \ + usb_log_printf(USB_LOG_LEVEL_DEBUG, format, ##__VA_ARGS__) + +/** Log verbose debugging message. */ +#define usb_log_debug2(format, ...) \ + usb_log_printf(USB_LOG_LEVEL_DEBUG2, format, ##__VA_ARGS__) + +const char *usb_debug_str_buffer(const uint8_t *, size_t, size_t); + + +#endif +/** + * @} + */ + Index: uspace/lib/usb/include/usb/descriptor.h =================================================================== --- uspace/lib/usb/include/usb/descriptor.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usb/include/usb/descriptor.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,214 @@ +/* + * Copyright (c) 2010 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusb + * @{ + */ +/** @file + * Standard USB descriptors. + */ +#ifndef LIBUSB_DESCRIPTOR_H_ +#define LIBUSB_DESCRIPTOR_H_ + +#include + +/** Descriptor type. */ +typedef enum { + USB_DESCTYPE_DEVICE = 1, + USB_DESCTYPE_CONFIGURATION = 2, + USB_DESCTYPE_STRING = 3, + USB_DESCTYPE_INTERFACE = 4, + USB_DESCTYPE_ENDPOINT = 5, + USB_DESCTYPE_HID = 0x21, + USB_DESCTYPE_HID_REPORT = 0x22, + USB_DESCTYPE_HID_PHYSICAL = 0x23, + USB_DESCTYPE_HUB = 0x29, + /* USB_DESCTYPE_ = */ +} usb_descriptor_type_t; + +/** Standard USB device descriptor. + */ +typedef struct { + /** Size of this descriptor in bytes. */ + uint8_t length; + /** Descriptor type (USB_DESCTYPE_DEVICE). */ + uint8_t descriptor_type; + /** USB specification release number. + * The number shall be coded as binary-coded decimal (BCD). + */ + uint16_t usb_spec_version; + /** Device class. */ + uint8_t device_class; + /** Device sub-class. */ + uint8_t device_subclass; + /** Device protocol. */ + uint8_t device_protocol; + /** Maximum packet size for endpoint zero. + * Valid values are only 8, 16, 32, 64). + */ + uint8_t max_packet_size; + /** Vendor ID. */ + uint16_t vendor_id; + /** Product ID. */ + uint16_t product_id; + /** Device release number (in BCD). */ + uint16_t device_version; + /** Manufacturer descriptor index. */ + uint8_t str_manufacturer; + /** Product descriptor index. */ + uint8_t str_product; + /** Device serial number descriptor index. */ + uint8_t str_serial_number; + /** Number of possible configurations. */ + uint8_t configuration_count; +} __attribute__ ((packed)) usb_standard_device_descriptor_t; + +/** Standard USB configuration descriptor. + */ +typedef struct { + /** Size of this descriptor in bytes. */ + uint8_t length; + /** Descriptor type (USB_DESCTYPE_CONFIGURATION). */ + uint8_t descriptor_type; + /** Total length of all data of this configuration. + * This includes the combined length of all descriptors + * (configuration, interface, endpoint, class-specific and + * vendor-specific) valid for this configuration. + */ + uint16_t total_length; + /** Number of possible interfaces under this configuration. */ + uint8_t interface_count; + /** Configuration value used when setting this configuration. */ + uint8_t configuration_number; + /** String descriptor describing this configuration. */ + uint8_t str_configuration; + /** Attribute bitmap. */ + uint8_t attributes; + /** Maximum power consumption from the USB under this configuration. + * Expressed in 2mA unit (e.g. 50 ~ 100mA). + */ + uint8_t max_power; +} __attribute__ ((packed)) usb_standard_configuration_descriptor_t; + +/** Standard USB interface descriptor. + */ +typedef struct { + /** Size of this descriptor in bytes. */ + uint8_t length; + /** Descriptor type (USB_DESCTYPE_INTERFACE). */ + uint8_t descriptor_type; + /** Number of interface. + * Zero-based index into array of interfaces for current configuration. + */ + uint8_t interface_number; + /** Alternate setting for value in interface_number. */ + uint8_t alternate_setting; + /** Number of endpoints used by this interface. + * This number must exclude usage of endpoint zero + * (default control pipe). + */ + uint8_t endpoint_count; + /** Class code. */ + uint8_t interface_class; + /** Subclass code. */ + uint8_t interface_subclass; + /** Protocol code. */ + uint8_t interface_protocol; + /** String descriptor describing this interface. */ + uint8_t str_interface; +} __attribute__ ((packed)) usb_standard_interface_descriptor_t; + +/** Standard USB endpoint descriptor. + */ +typedef struct { + /** Size of this descriptor in bytes. */ + uint8_t length; + /** Descriptor type (USB_DESCTYPE_ENDPOINT). */ + uint8_t descriptor_type; + /** Endpoint address together with data flow direction. */ + uint8_t endpoint_address; + /** Endpoint attributes. + * Includes transfer type (usb_transfer_type_t). + */ + uint8_t attributes; + /** Maximum packet size. */ + uint16_t max_packet_size; + /** Polling interval in milliseconds. + * Ignored for bulk and control endpoints. + * Isochronous endpoints must use value 1. + * Interrupt endpoints any value from 1 to 255. + */ + uint8_t poll_interval; +} __attribute__ ((packed)) usb_standard_endpoint_descriptor_t; + +/** Part of standard USB HID descriptor specifying one class descriptor. + * + * (See HID Specification, p.22) + */ +typedef struct { + /** Type of class-specific descriptor (Report or Physical). */ + uint8_t type; + /** Length of class-specific descriptor in bytes. */ + uint16_t length; +} __attribute__ ((packed)) usb_standard_hid_class_descriptor_info_t; + +/** Standard USB HID descriptor. + * + * (See HID Specification, p.22) + * + * It is actually only the "header" of the descriptor, it does not contain + * the last two mandatory fields (type and length of the first class-specific + * descriptor). + */ +typedef struct { + /** Total size of this descriptor in bytes. + * + * This includes all class-specific descriptor info - type + length + * for each descriptor. + */ + uint8_t length; + /** Descriptor type (USB_DESCTYPE_HID). */ + uint8_t descriptor_type; + /** HID Class Specification release. */ + uint16_t spec_release; + /** Country code of localized hardware. */ + uint8_t country_code; + /** Total number of class-specific (i.e. Report and Physical) + * descriptors. + * + * @note There is always only one Report descriptor. + */ + uint8_t class_desc_count; + /** First mandatory class descriptor (Report) info. */ + usb_standard_hid_class_descriptor_info_t report_desc_info; +} __attribute__ ((packed)) usb_standard_hid_descriptor_t; + +#endif +/** + * @} + */ Index: uspace/lib/usb/include/usb/hc.h =================================================================== --- uspace/lib/usb/include/usb/hc.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usb/include/usb/hc.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusb + * @{ + */ +/** @file + * General communication with host controller driver. + */ +#ifndef LIBUSB_HC_H_ +#define LIBUSB_HC_H_ + +#include +#include +#include +#include +#include +#include + +/** Connection to the host controller driver. */ +typedef struct { + /** Devman handle of the host controller. */ + devman_handle_t hc_handle; + /** Session to the host controller. */ + async_sess_t *hc_sess; +} usb_hc_connection_t; + +int usb_hc_connection_initialize_from_device(usb_hc_connection_t *, + ddf_dev_t *); +int usb_hc_connection_initialize(usb_hc_connection_t *, devman_handle_t); + +int usb_hc_connection_open(usb_hc_connection_t *); +bool usb_hc_connection_is_opened(const usb_hc_connection_t *); +int usb_hc_connection_close(usb_hc_connection_t *); +int usb_hc_get_handle_by_address(usb_hc_connection_t *, usb_address_t, + devman_handle_t *); + +int usb_hc_get_address_by_handle(devman_handle_t); + +int usb_hc_find(devman_handle_t, devman_handle_t *); + +int usb_resolve_device_handle(const char *, devman_handle_t *, usb_address_t *, + devman_handle_t *); + +int usb_ddf_get_hc_handle_by_class(size_t, devman_handle_t *); + + +#endif +/** + * @} + */ Index: uspace/lib/usb/include/usb/usb.h =================================================================== --- uspace/lib/usb/include/usb/usb.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usb/include/usb/usb.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,180 @@ +/* + * Copyright (c) 2010 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusb + * @{ + */ +/** @file + * Common USB types and functions. + */ +#ifndef LIBUSB_USB_H_ +#define LIBUSB_USB_H_ + +#include +#include + +/** Convert 16bit value from native (host) endianness to USB endianness. */ +#define uint16_host2usb(n) host2uint16_t_le((n)) + +/** Convert 32bit value from native (host) endianness to USB endianness. */ +#define uint32_host2usb(n) host2uint32_t_le((n)) + +/** Convert 16bit value from USB endianness into native (host) one. */ +#define uint16_usb2host(n) uint16_t_le2host((n)) + +/** Convert 32bit value from USB endianness into native (host) one. */ +#define uint32_usb2host(n) uint32_t_le2host((n)) + + +/** USB transfer type. */ +typedef enum { + USB_TRANSFER_CONTROL = 0, + USB_TRANSFER_ISOCHRONOUS = 1, + USB_TRANSFER_BULK = 2, + USB_TRANSFER_INTERRUPT = 3 +} usb_transfer_type_t; + +const char * usb_str_transfer_type(usb_transfer_type_t t); +const char * usb_str_transfer_type_short(usb_transfer_type_t t); + +/** USB data transfer direction. */ +typedef enum { + USB_DIRECTION_IN, + USB_DIRECTION_OUT, + USB_DIRECTION_BOTH +} usb_direction_t; + +/** USB speeds. */ +typedef enum { + /** USB 1.1 low speed (1.5Mbits/s). */ + USB_SPEED_LOW, + /** USB 1.1 full speed (12Mbits/s). */ + USB_SPEED_FULL, + /** USB 2.0 high speed (480Mbits/s). */ + USB_SPEED_HIGH, + /** Psuedo-speed serving as a boundary. */ + USB_SPEED_MAX +} usb_speed_t; + +const char *usb_str_speed(usb_speed_t); + + +/** USB request type target. */ +typedef enum { + USB_REQUEST_TYPE_STANDARD = 0, + USB_REQUEST_TYPE_CLASS = 1, + USB_REQUEST_TYPE_VENDOR = 2 +} usb_request_type_t; + +/** USB request recipient. */ +typedef enum { + USB_REQUEST_RECIPIENT_DEVICE = 0, + USB_REQUEST_RECIPIENT_INTERFACE = 1, + USB_REQUEST_RECIPIENT_ENDPOINT = 2, + USB_REQUEST_RECIPIENT_OTHER = 3 +} usb_request_recipient_t; + +/** USB address type. + * Negative values could be used to indicate error. + */ +typedef int usb_address_t; + +/** Default USB address. */ +#define USB_ADDRESS_DEFAULT 0 +/** Maximum address number in USB 1.1. */ +#define USB11_ADDRESS_MAX 128 + +/** USB endpoint number type. + * Negative values could be used to indicate error. + */ +typedef int usb_endpoint_t; + +/** Maximum endpoint number in USB 1.1. + */ +#define USB11_ENDPOINT_MAX 16 + + +/** USB complete address type. + * Pair address + endpoint is identification of transaction recipient. + */ +typedef struct { + usb_address_t address; + usb_endpoint_t endpoint; +} usb_target_t; + +/** Compare USB targets (addresses and endpoints). + * + * @param a First target. + * @param b Second target. + * @return Whether @p a and @p b points to the same pipe on the same device. + */ +static inline int usb_target_same(usb_target_t a, usb_target_t b) +{ + return (a.address == b.address) + && (a.endpoint == b.endpoint); +} + +/** General handle type. + * Used by various USB functions as opaque handle. + */ +typedef sysarg_t usb_handle_t; + +/** USB packet identifier. */ +typedef enum { +#define _MAKE_PID_NIBBLE(tag, type) \ + ((uint8_t)(((tag) << 2) | (type))) +#define _MAKE_PID(tag, type) \ + ( \ + _MAKE_PID_NIBBLE(tag, type) \ + | ((~_MAKE_PID_NIBBLE(tag, type)) << 4) \ + ) + USB_PID_OUT = _MAKE_PID(0, 1), + USB_PID_IN = _MAKE_PID(2, 1), + USB_PID_SOF = _MAKE_PID(1, 1), + USB_PID_SETUP = _MAKE_PID(3, 1), + + USB_PID_DATA0 = _MAKE_PID(0 ,3), + USB_PID_DATA1 = _MAKE_PID(2 ,3), + + USB_PID_ACK = _MAKE_PID(0 ,2), + USB_PID_NAK = _MAKE_PID(2 ,2), + USB_PID_STALL = _MAKE_PID(3 ,2), + + USB_PID_PRE = _MAKE_PID(3 ,0), + /* USB_PID_ = _MAKE_PID( ,), */ +#undef _MAKE_PID +#undef _MAKE_PID_NIBBLE +} usb_packet_id; + +/** Class name for USB host controllers. */ +#define USB_HC_DDF_CLASS_NAME "usbhc" + +#endif +/** + * @} + */ Index: uspace/lib/usb/src/class.c =================================================================== --- uspace/lib/usb/src/class.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usb/src/class.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,92 @@ +/* + * Copyright (c) 2010 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusb + * @{ + */ +/** @file + * @brief Class related functions. + */ +#include +#include + +/** Tell string representation of USB class. + * + * @param cls Class code. + * @return String representation. + */ +const char *usb_str_class(usb_class_t cls) +{ + switch (cls) { + case USB_CLASS_USE_INTERFACE: + return "use-interface"; + case USB_CLASS_AUDIO: + return "audio"; + case USB_CLASS_COMMUNICATIONS_CDC_CONTROL: + return "communications"; + case USB_CLASS_HID: + return "HID"; + case USB_CLASS_PHYSICAL: + return "physical"; + case USB_CLASS_IMAGE: + return "image"; + case USB_CLASS_PRINTER: + return "printer"; + case USB_CLASS_MASS_STORAGE: + return "mass-storage"; + case USB_CLASS_HUB: + return "hub"; + case USB_CLASS_CDC_DATA: + return "CDC"; + case USB_CLASS_SMART_CARD: + return "smart-card"; + case USB_CLASS_CONTENT_SECURITY: + return "security"; + case USB_CLASS_VIDEO: + return "video"; + case USB_CLASS_PERSONAL_HEALTHCARE: + return "healthcare"; + case USB_CLASS_DIAGNOSTIC: + return "diagnostic"; + case USB_CLASS_WIRELESS_CONTROLLER: + return "wireless"; + case USB_CLASS_MISCELLANEOUS: + return "misc"; + case USB_CLASS_APPLICATION_SPECIFIC: + return "application"; + case USB_CLASS_VENDOR_SPECIFIC: + return "vendor"; + default: + return "unknown"; + } +} + + +/** + * @} + */ Index: uspace/lib/usb/src/ddfiface.c =================================================================== --- uspace/lib/usb/src/ddfiface.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usb/src/ddfiface.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,175 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusb + * @{ + */ +/** @file + * Implementations of DDF interfaces functions (actual implementation). + */ +#include +#include +#include +#include +#include +#include +#include +#include + +/** DDF interface for USB device, implementation for typical hub. */ +usb_iface_t usb_iface_hub_impl = { + .get_hc_handle = usb_iface_get_hc_handle_hub_impl, + .get_address = usb_iface_get_address_hub_impl +}; + +/** DDF interface for USB device, implementation for child of a typical hub. */ +usb_iface_t usb_iface_hub_child_impl = { + .get_hc_handle = usb_iface_get_hc_handle_hub_child_impl, + .get_address = usb_iface_get_address_hub_child_impl +}; + + +/** Get host controller handle, interface implementation for hub driver. + * + * @param[in] fun Device function the operation is running on. + * @param[out] handle Storage for the host controller handle. + * @return Error code. + */ +int usb_iface_get_hc_handle_hub_impl(ddf_fun_t *fun, devman_handle_t *handle) +{ + assert(fun); + return usb_hc_find(fun->handle, handle); +} + +/** Get host controller handle, interface implementation for child of + * a hub driver. + * + * @param[in] fun Device function the operation is running on. + * @param[out] handle Storage for the host controller handle. + * @return Error code. + */ +int usb_iface_get_hc_handle_hub_child_impl(ddf_fun_t *fun, + devman_handle_t *handle) +{ + assert(fun != NULL); + + async_sess_t *parent_sess = + devman_parent_device_connect(EXCHANGE_SERIALIZE, fun->handle, + IPC_FLAG_BLOCKING); + if (!parent_sess) + return ENOMEM; + + async_exch_t *exch = async_exchange_begin(parent_sess); + + sysarg_t hc_handle; + int rc = async_req_1_1(exch, DEV_IFACE_ID(USB_DEV_IFACE), + IPC_M_USB_GET_HOST_CONTROLLER_HANDLE, &hc_handle); + + async_exchange_end(exch); + async_hangup(parent_sess); + + if (rc != EOK) + return rc; + + *handle = hc_handle; + return EOK; +} + +/** Get host controller handle, interface implementation for HC driver. + * + * @param[in] fun Device function the operation is running on. + * @param[out] handle Storage for the host controller handle. + * @return Always EOK. + */ +int usb_iface_get_hc_handle_hc_impl(ddf_fun_t *fun, devman_handle_t *handle) +{ + assert(fun); + + if (handle != NULL) { + *handle = fun->handle; + } + + return EOK; +} + +/** Get USB device address, interface implementation for hub driver. + * + * @param[in] fun Device function the operation is running on. + * @param[in] handle Devman handle of USB device we want address of. + * @param[out] address Storage for USB address of device with handle @p handle. + * @return Error code. + */ +int usb_iface_get_address_hub_impl(ddf_fun_t *fun, devman_handle_t handle, + usb_address_t *address) +{ + assert(fun); + + async_sess_t *parent_sess = + devman_parent_device_connect(EXCHANGE_SERIALIZE, fun->handle, + IPC_FLAG_BLOCKING); + if (!parent_sess) + return ENOMEM; + + async_exch_t *exch = async_exchange_begin(parent_sess); + + sysarg_t addr; + int rc = async_req_2_1(exch, DEV_IFACE_ID(USB_DEV_IFACE), + IPC_M_USB_GET_ADDRESS, handle, &addr); + + async_exchange_end(exch); + async_hangup(parent_sess); + + if (rc != EOK) + return rc; + + if (address != NULL) + *address = (usb_address_t) addr; + + return EOK; +} + +/** Get USB device address, interface implementation for child of + * a hub driver. + * + * @param[in] fun Device function the operation is running on. + * @param[in] handle Devman handle of USB device we want address of. + * @param[out] address Storage for USB address of device with handle @p handle. + * @return Error code. + */ +int usb_iface_get_address_hub_child_impl(ddf_fun_t *fun, + devman_handle_t handle, usb_address_t *address) +{ + if (handle == 0) { + handle = fun->handle; + } + return usb_iface_get_address_hub_impl(fun, handle, address); +} + +/** + * @} + */ Index: uspace/lib/usb/src/debug.c =================================================================== --- uspace/lib/usb/src/debug.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usb/src/debug.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,268 @@ +/* + * Copyright (c) 2010-2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusb + * @{ + */ +/** @file + * Debugging and logging support. + */ +#include +#include +#include +#include +#include +#include + +/** Level of logging messages. */ +static usb_log_level_t log_level = USB_LOG_LEVEL_WARNING; + +/** Prefix for logging messages. */ +static const char *log_prefix = "usb"; + +/** Serialization mutex for logging functions. */ +static FIBRIL_MUTEX_INITIALIZE(log_serializer); + +/** File where to store the log. */ +static FILE *log_stream = NULL; + + +/** Enable logging. + * + * @param level Maximal enabled level (including this one). + * @param message_prefix Prefix for each printed message. + */ +void usb_log_enable(usb_log_level_t level, const char *message_prefix) +{ + log_prefix = message_prefix; + log_level = level; + if (log_stream == NULL) { + char *fname; + int rc = asprintf(&fname, "/log/%s", message_prefix); + if (rc > 0) { + log_stream = fopen(fname, "w"); + free(fname); + } + } +} + +/** Get log level name prefix. + * + * @param level Log level. + * @return String prefix for the message. + */ +static const char *log_level_name(usb_log_level_t level) +{ + switch (level) { + case USB_LOG_LEVEL_FATAL: + return " FATAL"; + case USB_LOG_LEVEL_ERROR: + return " ERROR"; + case USB_LOG_LEVEL_WARNING: + return " WARN"; + case USB_LOG_LEVEL_INFO: + return " info"; + default: + return ""; + } +} + +/** Print logging message. + * + * @param level Verbosity level of the message. + * @param format Formatting directive. + */ +void usb_log_printf(usb_log_level_t level, const char *format, ...) +{ + FILE *screen_stream = NULL; + switch (level) { + case USB_LOG_LEVEL_FATAL: + case USB_LOG_LEVEL_ERROR: + screen_stream = stderr; + break; + default: + screen_stream = stdout; + break; + } + assert(screen_stream != NULL); + + va_list args; + + /* + * Serialize access to log files. + * Print to screen only messages with higher level than the one + * specified during logging initialization. + * Print also to file, to it print one more (lower) level as well. + */ + fibril_mutex_lock(&log_serializer); + + const char *level_name = log_level_name(level); + + if ((log_stream != NULL) && (level <= log_level + 1)) { + va_start(args, format); + + fprintf(log_stream, "[%s]%s: ", log_prefix, level_name); + vfprintf(log_stream, format, args); + fflush(log_stream); + + va_end(args); + } + + if (level <= log_level) { + va_start(args, format); + + fprintf(screen_stream, "[%s]%s: ", log_prefix, level_name); + vfprintf(screen_stream, format, args); + fflush(screen_stream); + + va_end(args); + } + + fibril_mutex_unlock(&log_serializer); +} + + +#define REMAINDER_STR_FMT " (%zu)..." +/* string + terminator + number width (enough for 4GB)*/ +#define REMAINDER_STR_LEN (5 + 1 + 10) + +/** How many bytes to group together. */ +#define BUFFER_DUMP_GROUP_SIZE 4 + +/** Size of the string for buffer dumps. */ +#define BUFFER_DUMP_LEN 240 /* Ought to be enough for everybody ;-). */ + +/** Fibril local storage for the dumped buffer. */ +static fibril_local char buffer_dump[2][BUFFER_DUMP_LEN]; +/** Fibril local storage for buffer switching. */ +static fibril_local int buffer_dump_index = 0; + +/** Dump buffer into string. + * + * The function dumps given buffer into hexadecimal format and stores it + * in a static fibril local string. + * That means that you do not have to deallocate the string (actually, you + * can not do that) and you do not have to guard it against concurrent + * calls to it. + * The only limitation is that each second call rewrites the buffer again + * (internally, two buffer are used in cyclic manner). + * Thus, it is necessary to copy the buffer elsewhere (that includes printing + * to screen or writing to file). + * Since this function is expected to be used for debugging prints only, + * that is not a big limitation. + * + * @warning You cannot use this function more than twice in the same printf + * (see detailed explanation). + * + * @param buffer Buffer to be printed (can be NULL). + * @param size Size of the buffer in bytes (can be zero). + * @param dumped_size How many bytes to actually dump (zero means all). + * @return Dumped buffer as a static (but fibril local) string. + */ +const char *usb_debug_str_buffer(const uint8_t *buffer, size_t size, + size_t dumped_size) +{ + /* + * Remove previous string. + */ + bzero(buffer_dump[buffer_dump_index], BUFFER_DUMP_LEN); + + if (buffer == NULL) { + return "(null)"; + } + if (size == 0) { + return "(empty)"; + } + if ((dumped_size == 0) || (dumped_size > size)) { + dumped_size = size; + } + + /* How many bytes are available in the output buffer. */ + size_t buffer_remaining_size = BUFFER_DUMP_LEN - 1 - REMAINDER_STR_LEN; + char *it = buffer_dump[buffer_dump_index]; + + size_t index = 0; + + while (index < size) { + /* Determine space before the number. */ + const char *space_before; + if (index == 0) { + space_before = ""; + } else if ((index % BUFFER_DUMP_GROUP_SIZE) == 0) { + space_before = " "; + } else { + space_before = " "; + } + + /* + * Add the byte as a hexadecimal number plus the space. + * We do it into temporary buffer to ensure that always + * the whole byte is printed. + */ + int val = buffer[index]; + char current_byte[16]; + int printed = snprintf(current_byte, 16, + "%s%02x", space_before, val); + if (printed < 0) { + break; + } + + if ((size_t) printed > buffer_remaining_size) { + break; + } + + /* We can safely add 1, because space for end 0 is reserved. */ + str_append(it, buffer_remaining_size + 1, current_byte); + + buffer_remaining_size -= printed; + /* Point at the terminator 0. */ + it += printed; + index++; + + if (index >= dumped_size) { + break; + } + } + + /* Add how many bytes were not printed. */ + if (index < size) { + snprintf(it, REMAINDER_STR_LEN, + REMAINDER_STR_FMT, size - index); + } + + /* Next time, use the other buffer. */ + buffer_dump_index = 1 - buffer_dump_index; + + /* Need to take the old one due to previous line. */ + return buffer_dump[1 - buffer_dump_index]; +} + + +/** + * @} + */ Index: uspace/lib/usb/src/dump.c =================================================================== --- uspace/lib/usb/src/dump.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usb/src/dump.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,291 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusb + * @{ + */ +/** @file + * Descriptor dumping. + */ +#include +#include +#include +#include +#include +#include +#include +#include + +/** Mapping between descriptor id and dumping function. */ +typedef struct { + /** Descriptor id. */ + int id; + /** Dumping function. */ + void (*dump)(FILE *, const char *, const char *, + const uint8_t *, size_t); +} descriptor_dump_t; + +static void usb_dump_descriptor_device(FILE *, const char *, const char *, + const uint8_t *, size_t); +static void usb_dump_descriptor_configuration(FILE *, const char *, const char *, + const uint8_t *, size_t); +static void usb_dump_descriptor_interface(FILE *, const char *, const char *, + const uint8_t *, size_t); +static void usb_dump_descriptor_string(FILE *, const char *, const char *, + const uint8_t *, size_t); +static void usb_dump_descriptor_endpoint(FILE *, const char *, const char *, + const uint8_t *, size_t); +static void usb_dump_descriptor_hid(FILE *, const char *, const char *, + const uint8_t *, size_t); +static void usb_dump_descriptor_hub(FILE *, const char *, const char *, + const uint8_t *, size_t); +static void usb_dump_descriptor_generic(FILE *, const char *, const char *, + const uint8_t *, size_t); + +/** Descriptor dumpers mapping. */ +static descriptor_dump_t descriptor_dumpers[] = { + { USB_DESCTYPE_DEVICE, usb_dump_descriptor_device }, + { USB_DESCTYPE_CONFIGURATION, usb_dump_descriptor_configuration }, + { USB_DESCTYPE_STRING, usb_dump_descriptor_string }, + { USB_DESCTYPE_INTERFACE, usb_dump_descriptor_interface }, + { USB_DESCTYPE_ENDPOINT, usb_dump_descriptor_endpoint }, + { USB_DESCTYPE_HID, usb_dump_descriptor_hid }, + { USB_DESCTYPE_HUB, usb_dump_descriptor_hub }, + { -1, usb_dump_descriptor_generic }, + { -1, NULL } +}; + +/** Dumps standard USB descriptor. + * The @p line_suffix must contain the newline \\n character. + * When @p line_suffix or @p line_prefix is NULL, they are substitued with + * default values + * ( - for prefix and line termination for suffix). + * + * @param output Output file stream to dump descriptor to. + * @param line_prefix Prefix for each line of output. + * @param line_suffix Suffix of each line of output. + * @param descriptor Actual descriptor. + * @param descriptor_length Descriptor size. + */ +void usb_dump_standard_descriptor(FILE *output, + const char *line_prefix, const char *line_suffix, + const uint8_t *descriptor, size_t descriptor_length) +{ + if (descriptor_length < 2) { + return; + } + int type = descriptor[1]; + + descriptor_dump_t *dumper = descriptor_dumpers; + while (dumper->dump != NULL) { + if ((dumper->id == type) || (dumper->id < 0)) { + dumper->dump(output, line_prefix, line_suffix, + descriptor, descriptor_length); + return; + } + dumper++; + } +} + +/** Prints single line of USB descriptor dump. + * @warning This macro abuses heavily the naming conventions used + * by all dumping functions (i.e. names for output file stream (@c output) and + * line prefix and suffix (@c line_prefix and @c line_suffix respectively))- + * + * @param fmt Formatting string. + */ +#define PRINTLINE(fmt, ...) \ + fprintf(output, "%s" fmt "%s", \ + line_prefix ? line_prefix : " - ", \ + __VA_ARGS__, \ + line_suffix ? line_suffix : "\n") + +#define BCD_INT(a) (((unsigned int)(a)) / 256) +#define BCD_FRAC(a) (((unsigned int)(a)) % 256) + +#define BCD_FMT "%x.%x" +#define BCD_ARGS(a) BCD_INT((a)), BCD_FRAC((a)) + +static void usb_dump_descriptor_device(FILE *output, + const char *line_prefix, const char *line_suffix, + const uint8_t *descriptor, size_t descriptor_length) +{ + usb_standard_device_descriptor_t *d + = (usb_standard_device_descriptor_t *) descriptor; + if (descriptor_length < sizeof(*d)) { + return; + } + + PRINTLINE("bLength = %d", d->length); + PRINTLINE("bDescriptorType = 0x%02x", d->descriptor_type); + PRINTLINE("bcdUSB = %d (" BCD_FMT ")", d->usb_spec_version, + BCD_ARGS(d->usb_spec_version)); + PRINTLINE("bDeviceClass = 0x%02x", d->device_class); + PRINTLINE("bDeviceSubClass = 0x%02x", d->device_subclass); + PRINTLINE("bDeviceProtocol = 0x%02x", d->device_protocol); + PRINTLINE("bMaxPacketSize0 = %d", d->max_packet_size); + PRINTLINE("idVendor = 0x%04x", d->vendor_id); + PRINTLINE("idProduct = 0x%04x", d->product_id); + PRINTLINE("bcdDevice = %d", d->device_version); + PRINTLINE("iManufacturer = %d", d->str_manufacturer); + PRINTLINE("iProduct = %d", d->str_product); + PRINTLINE("iSerialNumber = %d", d->str_serial_number); + PRINTLINE("bNumConfigurations = %d", d->configuration_count); +} + +static void usb_dump_descriptor_configuration(FILE *output, + const char *line_prefix, const char *line_suffix, + const uint8_t *descriptor, size_t descriptor_length) +{ + usb_standard_configuration_descriptor_t *d + = (usb_standard_configuration_descriptor_t *) descriptor; + if (descriptor_length < sizeof(*d)) { + return; + } + + bool self_powered = d->attributes & 64; + bool remote_wakeup = d->attributes & 32; + + PRINTLINE("bLength = %d", d->length); + PRINTLINE("bDescriptorType = 0x%02x", d->descriptor_type); + PRINTLINE("wTotalLength = %d", d->total_length); + PRINTLINE("bNumInterfaces = %d", d->interface_count); + PRINTLINE("bConfigurationValue = %d", d->configuration_number); + PRINTLINE("iConfiguration = %d", d->str_configuration); + PRINTLINE("bmAttributes = %d [%s%s%s]", d->attributes, + self_powered ? "self-powered" : "", + (self_powered & remote_wakeup) ? ", " : "", + remote_wakeup ? "remote-wakeup" : ""); + PRINTLINE("MaxPower = %d (%dmA)", d->max_power, + 2 * d->max_power); +} + +static void usb_dump_descriptor_interface(FILE *output, + const char *line_prefix, const char *line_suffix, + const uint8_t *descriptor, size_t descriptor_length) +{ + usb_standard_interface_descriptor_t *d + = (usb_standard_interface_descriptor_t *) descriptor; + if (descriptor_length < sizeof(*d)) { + return; + } + + PRINTLINE("bLength = %d", d->length); + PRINTLINE("bDescriptorType = 0x%02x", d->descriptor_type); + PRINTLINE("bInterfaceNumber = %d", d->interface_number); + PRINTLINE("bAlternateSetting = %d", d->alternate_setting); + PRINTLINE("bNumEndpoints = %d", d->endpoint_count); + PRINTLINE("bInterfaceClass = %s", d->interface_class == 0 + ? "reserved (0)" : usb_str_class(d->interface_class)); + PRINTLINE("bInterfaceSubClass = %d", d->interface_subclass); + PRINTLINE("bInterfaceProtocol = %d", d->interface_protocol); + PRINTLINE("iInterface = %d", d->str_interface); +} + +static void usb_dump_descriptor_string(FILE *output, + const char *line_prefix, const char *line_suffix, + const uint8_t *descriptor, size_t descriptor_length) +{ +} + +static void usb_dump_descriptor_endpoint(FILE *output, + const char *line_prefix, const char *line_suffix, + const uint8_t *descriptor, size_t descriptor_length) +{ + usb_standard_endpoint_descriptor_t *d + = (usb_standard_endpoint_descriptor_t *) descriptor; + if (descriptor_length < sizeof(*d)) { + return; + } + + int endpoint = d->endpoint_address & 15; + usb_direction_t direction = d->endpoint_address & 128 + ? USB_DIRECTION_IN : USB_DIRECTION_OUT; + usb_transfer_type_t transfer_type = d->attributes & 3; + + PRINTLINE("bLength = %d", d->length); + PRINTLINE("bDescriptorType = 0x%02X", d->descriptor_type); + PRINTLINE("bEndpointAddress = 0x%02X [%d, %s]", + d->endpoint_address, endpoint, + direction == USB_DIRECTION_IN ? "in" : "out"); + PRINTLINE("bmAttributes = %d [%s]", d->attributes, + usb_str_transfer_type(transfer_type)); + PRINTLINE("wMaxPacketSize = %d", d->max_packet_size); + PRINTLINE("bInterval = %dms", d->poll_interval); +} + +static void usb_dump_descriptor_hid(FILE *output, + const char *line_prefix, const char *line_suffix, + const uint8_t *descriptor, size_t descriptor_length) +{ + usb_standard_hid_descriptor_t *d + = (usb_standard_hid_descriptor_t *) descriptor; + if (descriptor_length < sizeof(*d)) { + return; + } + + PRINTLINE("bLength = %d", d->length); + PRINTLINE("bDescriptorType = 0x%02x", d->descriptor_type); + PRINTLINE("bcdHID = %d (" BCD_FMT ")", d->spec_release, + BCD_ARGS(d->spec_release)); + PRINTLINE("bCountryCode = %d", d->country_code); + PRINTLINE("bNumDescriptors = %d", d->class_desc_count); + PRINTLINE("bDescriptorType = %d", d->report_desc_info.type); + PRINTLINE("wDescriptorLength = %d", d->report_desc_info.length); + + /* Print info about report descriptors. */ + size_t i; + size_t count = (descriptor_length - sizeof(*d)) + / sizeof(usb_standard_hid_class_descriptor_info_t); + usb_standard_hid_class_descriptor_info_t *d2 + = (usb_standard_hid_class_descriptor_info_t *) + (descriptor + sizeof(*d)); + for (i = 0; i < count; i++, d2++) { + PRINTLINE("bDescriptorType = %d", d2->type); + PRINTLINE("wDescriptorLength = %d", d2->length); + } +} + +static void usb_dump_descriptor_hub(FILE *output, + const char *line_prefix, const char *line_suffix, + const uint8_t *descriptor, size_t descriptor_length) +{ + /* TODO */ +} + +static void usb_dump_descriptor_generic(FILE *output, + const char *line_prefix, const char *line_suffix, + const uint8_t *descriptor, size_t descriptor_length) +{ + /* TODO */ +} + + +/** + * @} + */ Index: uspace/lib/usb/src/hc.c =================================================================== --- uspace/lib/usb/src/hc.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usb/src/hc.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,268 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusb + * @{ + */ +/** @file + * General communication with host controller driver (implementation). + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/** Initialize connection to USB host controller. + * + * @param connection Connection to be initialized. + * @param device Device connecting to the host controller. + * @return Error code. + */ +int usb_hc_connection_initialize_from_device(usb_hc_connection_t *connection, + ddf_dev_t *device) +{ + assert(connection); + + if (device == NULL) { + return EBADMEM; + } + + devman_handle_t hc_handle; + int rc = usb_hc_find(device->handle, &hc_handle); + if (rc != EOK) { + return rc; + } + + rc = usb_hc_connection_initialize(connection, hc_handle); + + return rc; +} + +/** Manually initialize connection to USB host controller. + * + * @param connection Connection to be initialized. + * @param hc_handle Devman handle of the host controller. + * @return Error code. + */ +int usb_hc_connection_initialize(usb_hc_connection_t *connection, + devman_handle_t hc_handle) +{ + assert(connection); + + connection->hc_handle = hc_handle; + connection->hc_sess = NULL; + + return EOK; +} + +/** Open connection to host controller. + * + * @param connection Connection to the host controller. + * @return Error code. + */ +int usb_hc_connection_open(usb_hc_connection_t *connection) +{ + assert(connection); + + if (usb_hc_connection_is_opened(connection)) + return EBUSY; + + async_sess_t *sess = devman_device_connect(EXCHANGE_SERIALIZE, + connection->hc_handle, 0); + if (!sess) + return ENOMEM; + + connection->hc_sess = sess; + return EOK; +} + +/** Tells whether connection to host controller is opened. + * + * @param connection Connection to the host controller. + * @return Whether connection is opened. + */ +bool usb_hc_connection_is_opened(const usb_hc_connection_t *connection) +{ + assert(connection); + return (connection->hc_sess != NULL); +} + +/** Close connection to the host controller. + * + * @param connection Connection to the host controller. + * @return Error code. + */ +int usb_hc_connection_close(usb_hc_connection_t *connection) +{ + assert(connection); + + if (!usb_hc_connection_is_opened(connection)) { + return ENOENT; + } + + int rc = async_hangup(connection->hc_sess); + if (rc != EOK) { + return rc; + } + + connection->hc_sess = NULL; + + return EOK; +} + +/** Get handle of USB device with given address. + * + * @param[in] connection Opened connection to host controller. + * @param[in] address Address of device in question. + * @param[out] handle Where to write the device handle. + * @return Error code. + */ +int usb_hc_get_handle_by_address(usb_hc_connection_t *connection, + usb_address_t address, devman_handle_t *handle) +{ + if (!usb_hc_connection_is_opened(connection)) + return ENOENT; + + async_exch_t *exch = async_exchange_begin(connection->hc_sess); + + sysarg_t tmp; + int rc = async_req_2_1(exch, DEV_IFACE_ID(USBHC_DEV_IFACE), + IPC_M_USBHC_GET_HANDLE_BY_ADDRESS, + address, &tmp); + + async_exchange_end(exch); + + if ((rc == EOK) && (handle != NULL)) + *handle = tmp; + + return rc; +} + +/** Tell USB address assigned to device with given handle. + * + * @param dev_handle Devman handle of the USB device in question. + * @return USB address or negative error code. + */ +usb_address_t usb_hc_get_address_by_handle(devman_handle_t dev_handle) +{ + async_sess_t *parent_sess = + devman_parent_device_connect(EXCHANGE_SERIALIZE, dev_handle, + IPC_FLAG_BLOCKING); + if (!parent_sess) + return ENOMEM; + + async_exch_t *exch = async_exchange_begin(parent_sess); + + sysarg_t address; + int rc = async_req_2_1(exch, DEV_IFACE_ID(USB_DEV_IFACE), + IPC_M_USB_GET_ADDRESS, + dev_handle, &address); + + async_exchange_end(exch); + async_hangup(parent_sess); + + if (rc != EOK) + return rc; + + return (usb_address_t) address; +} + + +/** Get host controller handle by its class index. + * + * @param class_index Class index for the host controller. + * @param hc_handle Where to store the HC handle + * (can be NULL for existence test only). + * @return Error code. + */ +int usb_ddf_get_hc_handle_by_class(size_t class_index, + devman_handle_t *hc_handle) +{ + char *class_index_str; + devman_handle_t hc_handle_tmp; + int rc; + + rc = asprintf(&class_index_str, "%zu", class_index); + if (rc < 0) { + return ENOMEM; + } + rc = devman_device_get_handle_by_class("usbhc", class_index_str, + &hc_handle_tmp, 0); + free(class_index_str); + if (rc != EOK) { + return rc; + } + + if (hc_handle != NULL) { + *hc_handle = hc_handle_tmp; + } + + return EOK; +} + +/** Find host controller handle that is ancestor of given device. + * + * @param[in] device_handle Device devman handle. + * @param[out] hc_handle Where to store handle of host controller + * controlling device with @p device_handle handle. + * @return Error code. + */ +int usb_hc_find(devman_handle_t device_handle, devman_handle_t *hc_handle) +{ + async_sess_t *parent_sess = + devman_parent_device_connect(EXCHANGE_SERIALIZE, device_handle, + IPC_FLAG_BLOCKING); + if (!parent_sess) + return ENOMEM; + + async_exch_t *exch = async_exchange_begin(parent_sess); + + devman_handle_t h; + int rc = async_req_1_1(exch, DEV_IFACE_ID(USB_DEV_IFACE), + IPC_M_USB_GET_HOST_CONTROLLER_HANDLE, &h); + + async_exchange_end(exch); + async_hangup(parent_sess); + + if (rc != EOK) + return rc; + + if (hc_handle != NULL) + *hc_handle = h; + + return EOK; +} + +/** + * @} + */ Index: uspace/lib/usb/src/resolve.c =================================================================== --- uspace/lib/usb/src/resolve.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usb/src/resolve.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,244 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusb + * @{ + */ +/** @file + * + */ +#include +#include +#include +#include +#include +#include + +#define MAX_DEVICE_PATH 1024 + +static bool try_parse_bus_and_address(const char *path, + char **func_start, + devman_handle_t *out_hc_handle, usb_address_t *out_device_address) +{ + size_t class_index; + size_t address; + int rc; + char *ptr; + + rc = str_size_t(path, &ptr, 10, false, &class_index); + if (rc != EOK) { + return false; + } + if ((*ptr == ':') || (*ptr == '.')) { + ptr++; + } else { + return false; + } + rc = str_size_t(ptr, func_start, 10, false, &address); + if (rc != EOK) { + return false; + } + rc = usb_ddf_get_hc_handle_by_class(class_index, out_hc_handle); + if (rc != EOK) { + return false; + } + if (out_device_address != NULL) { + *out_device_address = (usb_address_t) address; + } + return true; +} + +static int get_device_handle_by_address(devman_handle_t hc_handle, int addr, + devman_handle_t *dev_handle) +{ + int rc; + usb_hc_connection_t conn; + + usb_hc_connection_initialize(&conn, hc_handle); + rc = usb_hc_connection_open(&conn); + if (rc != EOK) { + return rc; + } + + rc = usb_hc_get_handle_by_address(&conn, addr, dev_handle); + + usb_hc_connection_close(&conn); + + return rc; +} + +/** Resolve handle and address of USB device from its path. + * + * This is a wrapper working on best effort principle. + * If the resolving fails, if will not give much details about what + * is wrong. + * Typically, error from this function would be reported to the user + * as "bad device specification" or "device does not exist". + * + * The path can be specified in following format: + * - devman path (e.g. /hw/pci0/.../usb01_a5 + * - bus number and device address (e.g. 5.1) + * - bus number, device address and device function (e.g. 2.1/HID0/keyboard) + * + * @param[in] dev_path Path to the device. + * @param[out] out_hc_handle Where to store handle of a parent host controller. + * @param[out] out_dev_addr Where to store device (USB) address. + * @param[out] out_dev_handle Where to store device handle. + * @return Error code. + */ +int usb_resolve_device_handle(const char *dev_path, devman_handle_t *out_hc_handle, + usb_address_t *out_dev_addr, devman_handle_t *out_dev_handle) +{ + if (dev_path == NULL) { + return EBADMEM; + } + + bool found_hc = false; + bool found_addr = false; + devman_handle_t hc_handle, dev_handle; + usb_address_t dev_addr = -1; + int rc; + bool is_bus_addr; + char *func_start = NULL; + char *path = NULL; + + /* First try the BUS.ADDR format. */ + is_bus_addr = try_parse_bus_and_address(dev_path, &func_start, + &hc_handle, &dev_addr); + if (is_bus_addr) { + found_hc = true; + found_addr = true; + /* + * Now get the handle of the device. We will need that + * in both cases. If there is only BUS.ADDR, it will + * be the handle to be returned to the caller, otherwise + * we will need it to resolve the path to which the + * suffix would be appended. + */ + /* If there is nothing behind the BUS.ADDR, we will + * get the device handle from the host controller. + * Otherwise, we will + */ + rc = get_device_handle_by_address(hc_handle, dev_addr, + &dev_handle); + if (rc != EOK) { + return rc; + } + if (str_length(func_start) > 0) { + char tmp_path[MAX_DEVICE_PATH ]; + rc = devman_get_device_path(dev_handle, + tmp_path, MAX_DEVICE_PATH); + if (rc != EOK) { + return rc; + } + rc = asprintf(&path, "%s%s", tmp_path, func_start); + if (rc < 0) { + return ENOMEM; + } + } else { + /* Everything is resolved. Get out of here. */ + goto copy_out; + } + } else { + path = str_dup(dev_path); + if (path == NULL) { + return ENOMEM; + } + } + + /* First try to get the device handle. */ + rc = devman_device_get_handle(path, &dev_handle, 0); + if (rc != EOK) { + free(path); + /* Invalid path altogether. */ + return rc; + } + + /* Remove suffixes and hope that we will encounter device node. */ + while (str_length(path) > 0) { + /* Get device handle first. */ + devman_handle_t tmp_handle; + rc = devman_device_get_handle(path, &tmp_handle, 0); + if (rc != EOK) { + free(path); + return rc; + } + + /* Try to find its host controller. */ + if (!found_hc) { + rc = usb_hc_find(tmp_handle, &hc_handle); + if (rc == EOK) { + found_hc = true; + } + } + + /* Try to get its address. */ + if (!found_addr) { + dev_addr = usb_hc_get_address_by_handle(tmp_handle); + if (dev_addr >= 0) { + found_addr = true; + } + } + + /* Speed-up. */ + if (found_hc && found_addr) { + break; + } + + /* Remove the last suffix. */ + char *slash_pos = str_rchr(path, '/'); + if (slash_pos != NULL) { + *slash_pos = 0; + } + } + + free(path); + + if (!found_addr || !found_hc) { + return ENOENT; + } + +copy_out: + if (out_dev_addr != NULL) { + *out_dev_addr = dev_addr; + } + if (out_hc_handle != NULL) { + *out_hc_handle = hc_handle; + } + if (out_dev_handle != NULL) { + *out_dev_handle = dev_handle; + } + + return EOK; +} + + +/** + * @} + */ + Index: uspace/lib/usb/src/usb.c =================================================================== --- uspace/lib/usb/src/usb.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usb/src/usb.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,101 @@ +/* + * Copyright (c) 2010 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusb + * @{ + */ +/** @file + * Common USB functions. + */ +#include +#include + +#define ARR_SIZE(arr) (sizeof(arr)/sizeof(arr[0])) + +static const char *str_speed[] = { + "low", + "full", + "high" +}; + +static const char *str_transfer_type[] = { + "control", + "isochronous", + "bulk", + "interrupt" +}; + +static const char *str_transfer_type_short[] = { + "ctrl", + "iso", + "bulk", + "intr" +}; + +/** String representation for USB transfer type. + * + * @param t Transfer type. + * @return Transfer type as a string (in English). + */ +const char *usb_str_transfer_type(usb_transfer_type_t t) +{ + if (t >= ARR_SIZE(str_transfer_type)) { + return "invalid"; + } + return str_transfer_type[t]; +} + +/** String representation for USB transfer type (short version). + * + * @param t Transfer type. + * @return Transfer type as a short string for debugging messages. + */ +const char *usb_str_transfer_type_short(usb_transfer_type_t t) +{ + if (t >= ARR_SIZE(str_transfer_type_short)) { + return "invl"; + } + return str_transfer_type_short[t]; +} + +/** String representation of USB speed. + * + * @param s The speed. + * @return USB speed as a string (in English). + */ +const char *usb_str_speed(usb_speed_t s) +{ + if (s >= ARR_SIZE(str_speed)) { + return "invalid"; + } + return str_speed[s]; +} + +/** + * @} + */ Index: uspace/lib/usbdev/Makefile =================================================================== --- uspace/lib/usbdev/Makefile (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbdev/Makefile (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,50 @@ +# +# Copyright (c) 2011 Vojtech Horky +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# - Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# - Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# - The name of the author may not be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +USPACE_PREFIX = ../.. +LIBRARY = libusbdev +EXTRA_CFLAGS += \ + -I$(LIBUSB_PREFIX)/include \ + -I$(LIBDRV_PREFIX)/include \ + -Iinclude + +SOURCES = \ + src/altiface.c \ + src/devdrv.c \ + src/devpoll.c \ + src/dp.c \ + src/hub.c \ + src/pipepriv.c \ + src/pipepriv.h \ + src/pipes.c \ + src/pipesinit.c \ + src/pipesio.c \ + src/recognise.c \ + src/request.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/lib/usbdev/include/usb/dev/dp.h =================================================================== --- uspace/lib/usbdev/include/usb/dev/dp.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbdev/include/usb/dev/dp.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,85 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbdev + * @{ + */ +/** @file + * USB descriptor parser. + */ +#ifndef LIBUSBDEV_DP_H_ +#define LIBUSBDEV_DP_H_ + +#include +#include +#include + +/** USB descriptors nesting. + * The nesting describes the logical tree USB descriptors form + * (e.g. that endpoint descriptor belongs to interface or that + * interface belongs to configuration). + * + * See usb_descriptor_type_t for descriptor constants. + */ +typedef struct { + /** Child descriptor id. */ + int child; + /** Parent descriptor id. */ + int parent; +} usb_dp_descriptor_nesting_t; + +extern usb_dp_descriptor_nesting_t usb_dp_standard_descriptor_nesting[]; + +/** Descriptor parser structure. */ +typedef struct { + /** Used descriptor nesting. */ + usb_dp_descriptor_nesting_t *nesting; +} usb_dp_parser_t; + +/** Descriptor parser data. */ +typedef struct { + /** Data to be parsed. */ + uint8_t *data; + /** Size of input data in bytes. */ + size_t size; + /** Custom argument. */ + void *arg; +} usb_dp_parser_data_t; + +uint8_t *usb_dp_get_nested_descriptor(usb_dp_parser_t *, + usb_dp_parser_data_t *, uint8_t *); +uint8_t *usb_dp_get_sibling_descriptor(usb_dp_parser_t *, + usb_dp_parser_data_t *, uint8_t *, uint8_t *); + +void usb_dp_walk_simple(uint8_t *, size_t, usb_dp_descriptor_nesting_t *, + void (*)(uint8_t *, size_t, void *), void *); + +#endif +/** + * @} + */ Index: uspace/lib/usbdev/include/usb/dev/driver.h =================================================================== --- uspace/lib/usbdev/include/usb/dev/driver.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbdev/include/usb/dev/driver.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,179 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbdev + * @{ + */ +/** @file + * USB device driver framework. + */ +#ifndef LIBUSBDEV_DRIVER_H_ +#define LIBUSBDEV_DRIVER_H_ + +#include + +/** Descriptors for USB device. */ +typedef struct { + /** Standard device descriptor. */ + usb_standard_device_descriptor_t device; + /** Full configuration descriptor of current configuration. */ + uint8_t *configuration; + size_t configuration_size; +} 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 { + /** The default control pipe. */ + usb_pipe_t ctrl_pipe; + /** Other endpoint pipes. + * This is an array of other endpoint pipes in the same order as + * in usb_driver_t. + */ + usb_endpoint_mapping_t *pipes; + /** Number of other endpoint pipes. */ + size_t pipes_count; + /** Current interface. + * Usually, drivers operate on single interface only. + * This item contains the value of the interface or -1 for any. + */ + 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. */ + usb_device_descriptors_t descriptors; + + /** Generic DDF device backing this one. */ + ddf_dev_t *ddf_dev; + /** Custom driver data. + * Do not use the entry in generic device, that is already used + * by the framework. + */ + void *driver_data; + + /** Connection backing the pipes. + * Typically, you will not need to use this attribute at all. + */ + usb_device_connection_t wire; +} usb_device_t; + +/** USB driver ops. */ +typedef struct { + /** Callback when new device is about to be controlled by the driver. */ + int (*add_device)(usb_device_t *); +} usb_driver_ops_t; + +/** USB driver structure. */ +typedef struct { + /** Driver name. + * This name is copied to the generic driver name and must be exactly + * the same as the directory name where the driver executable resides. + */ + const char *name; + /** 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. + * + * 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; + /** Driver ops. */ + usb_driver_ops_t *ops; +} usb_driver_t; + +int usb_driver_main(usb_driver_t *); + +int usb_device_select_interface(usb_device_t *, uint8_t, + usb_endpoint_description_t **); + +int usb_device_retrieve_descriptors(usb_pipe_t *, usb_device_descriptors_t *); +int usb_device_create_pipes(ddf_dev_t *, usb_device_connection_t *, + usb_endpoint_description_t **, uint8_t *, size_t, int, int, + usb_endpoint_mapping_t **, size_t *); +int usb_device_destroy_pipes(ddf_dev_t *, usb_endpoint_mapping_t *, size_t); +int usb_device_create(ddf_dev_t *, usb_endpoint_description_t **, usb_device_t **, const char **); +void usb_device_destroy(usb_device_t *); + +size_t usb_interface_count_alternates(uint8_t *, size_t, uint8_t); +int usb_alternate_interfaces_create(uint8_t *, size_t, int, + usb_alternate_interfaces_t **); + +#endif +/** + * @} + */ Index: uspace/lib/usbdev/include/usb/dev/hub.h =================================================================== --- uspace/lib/usbdev/include/usb/dev/hub.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbdev/include/usb/dev/hub.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,69 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbdev + * @{ + */ +/** @file + * Functions needed by hub drivers. + * + * For class specific requests, see usb/classes/hub.h. + */ +#ifndef LIBUSBDEV_HUB_H_ +#define LIBUSBDEV_HUB_H_ + +#include +#include + +int usb_hc_new_device_wrapper(ddf_dev_t *, usb_hc_connection_t *, usb_speed_t, + int (*)(int, void *), int, void *, + usb_address_t *, devman_handle_t *, + ddf_dev_ops_t *, void *, ddf_fun_t **); + +/** Info about device attached to host controller. + * + * This structure exists only to keep the same signature of + * usb_hc_register_device() when more properties of the device + * would have to be passed to the host controller. + */ +typedef struct { + /** Device address. */ + usb_address_t address; + /** Devman handle of the device. */ + devman_handle_t handle; +} usb_hc_attached_device_t; + +usb_address_t usb_hc_request_address(usb_hc_connection_t *, usb_speed_t); +int usb_hc_register_device(usb_hc_connection_t *, + const usb_hc_attached_device_t *); +int usb_hc_unregister_device(usb_hc_connection_t *, usb_address_t); + +#endif +/** + * @} + */ Index: uspace/lib/usbdev/include/usb/dev/pipes.h =================================================================== --- uspace/lib/usbdev/include/usb/dev/pipes.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbdev/include/usb/dev/pipes.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,193 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbdev + * @{ + */ +/** @file + * USB pipes representation. + */ +#ifndef LIBUSBDEV_PIPES_H_ +#define LIBUSBDEV_PIPES_H_ + +#include +#include +#include +#include +#include +#include +#include +#include + +/** Abstraction of a physical connection to the device. + * This type is an abstraction of the USB wire that connects the host and + * the function (device). + */ +typedef struct { + /** Handle of the host controller device is connected to. */ + devman_handle_t hc_handle; + /** Address of the device. */ + usb_address_t address; +} usb_device_connection_t; + +/** Abstraction of a logical connection to USB device endpoint. + * It encapsulates endpoint attributes (transfer type etc.) as well + * as information about currently running sessions. + * This endpoint must be bound with existing usb_device_connection_t + * (i.e. the wire to send data over). + * + * Locking order: if you want to lock both mutexes + * (@c guard and @c hc_sess_mutex), lock @c guard first. + * It is not necessary to lock @c guard if you want to lock @c hc_sess_mutex + * only. + */ +typedef struct { + /** Guard of the whole pipe. */ + fibril_mutex_t guard; + + /** The connection used for sending the data. */ + usb_device_connection_t *wire; + + /** Endpoint number. */ + usb_endpoint_t endpoint_no; + + /** Endpoint transfer type. */ + usb_transfer_type_t transfer_type; + + /** Endpoint direction. */ + usb_direction_t direction; + + /** Maximum packet size for the endpoint. */ + size_t max_packet_size; + + /** Session to the host controller. + * NULL when no session is active. + * It is an error to access this member without @c hc_sess_mutex + * being locked. + * If call over the phone is to be made, it must be preceeded by + * call to pipe_add_ref() [internal libusb function]. + */ + async_sess_t *hc_sess; + + /** Guard for serialization of requests over the session. */ + fibril_mutex_t hc_sess_mutex; + + /** Number of active transfers over the pipe. */ + int refcount; + /** Number of failed attempts to open the HC phone. + * When user requests usb_pipe_start_long_transfer() and the operation + * fails, there is no way to report this to the user. + * That the soft reference counter is increased to record the attempt. + * When the user then request e.g. usb_pipe_read(), it will try to + * add reference as well. + * If that fails, it is reported to the user. If it is okay, the + * real reference counter is incremented. + * The problem might arise when ending the long transfer (since + * the number of references would be only 1, but logically it shall be + * two). + * Decrementing the soft counter first shall solve this. + */ + int refcount_soft; + + /** Whether to automatically reset halt on the endpoint. + * Valid only for control endpoint zero. + */ + bool auto_reset_halt; +} usb_pipe_t; + + +/** Description of endpoint characteristics. */ +typedef struct { + /** Transfer type (e.g. control or interrupt). */ + usb_transfer_type_t transfer_type; + /** Transfer direction (to or from a device). */ + usb_direction_t direction; + /** Interface class this endpoint belongs to (-1 for any). */ + int interface_class; + /** Interface subclass this endpoint belongs to (-1 for any). */ + int interface_subclass; + /** Interface protocol this endpoint belongs to (-1 for any). */ + int interface_protocol; + /** Extra endpoint flags. */ + unsigned int flags; +} usb_endpoint_description_t; + +/** Mapping of endpoint pipes and endpoint descriptions. */ +typedef struct { + /** Endpoint pipe. */ + usb_pipe_t *pipe; + /** Endpoint description. */ + const usb_endpoint_description_t *description; + /** 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; + /** Interface descriptor the endpoint belongs to. */ + usb_standard_interface_descriptor_t *interface; + /** Whether the endpoint was actually found. */ + bool present; +} usb_endpoint_mapping_t; + +int usb_device_connection_initialize_on_default_address( + usb_device_connection_t *, usb_hc_connection_t *); +int usb_device_connection_initialize_from_device(usb_device_connection_t *, + ddf_dev_t *); +int usb_device_connection_initialize(usb_device_connection_t *, + devman_handle_t, usb_address_t); + +int usb_device_get_assigned_interface(ddf_dev_t *); + +int usb_pipe_initialize(usb_pipe_t *, usb_device_connection_t *, + usb_endpoint_t, usb_transfer_type_t, size_t, usb_direction_t); +int usb_pipe_initialize_default_control(usb_pipe_t *, + usb_device_connection_t *); +int usb_pipe_probe_default_control(usb_pipe_t *); +int usb_pipe_initialize_from_configuration(usb_endpoint_mapping_t *, + size_t, uint8_t *, size_t, usb_device_connection_t *); +int usb_pipe_register_with_speed(usb_pipe_t *, usb_speed_t, + unsigned int, usb_hc_connection_t *); +int usb_pipe_register(usb_pipe_t *, unsigned int, usb_hc_connection_t *); +int usb_pipe_unregister(usb_pipe_t *, usb_hc_connection_t *); + +void usb_pipe_start_long_transfer(usb_pipe_t *); +void usb_pipe_end_long_transfer(usb_pipe_t *); + +int usb_pipe_read(usb_pipe_t *, void *, size_t, size_t *); +int usb_pipe_write(usb_pipe_t *, void *, size_t); + +int usb_pipe_control_read(usb_pipe_t *, void *, size_t, + void *, size_t, size_t *); +int usb_pipe_control_write(usb_pipe_t *, void *, size_t, + void *, size_t); + +#endif +/** + * @} + */ Index: uspace/lib/usbdev/include/usb/dev/poll.h =================================================================== --- uspace/lib/usbdev/include/usb/dev/poll.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbdev/include/usb/dev/poll.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,99 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbdev + * @{ + */ +/** @file + * USB device polling functions. + */ +#ifndef LIBUSBDEV_POLL_H_ +#define LIBUSBDEV_POLL_H_ + +#include +#include + +typedef struct { + /** Level of debugging messages from auto polling. + * 0 - nothing + * 1 - inform about errors and polling start/end + * 2 - also dump every retrieved buffer + */ + int debug; + /** Maximum number of consecutive errors before polling termination. */ + size_t max_failures; + /** Delay between poll requests in milliseconds. + * Set to negative value to use value from endpoint descriptor. + */ + int delay; + /** Whether to automatically try to clear the HALT feature after + * the endpoint stalls. + */ + bool auto_clear_halt; + /** Callback when data arrives. + * + * @param dev Device that was polled. + * @param data Data buffer (in USB endianness). + * @param data_size Size of the @p data buffer in bytes. + * @param arg Custom argument. + * @return Whether to continue in polling. + */ + bool (*on_data)(usb_device_t *dev, uint8_t *data, size_t data_size, + void *arg); + /** Callback when polling is terminated. + * + * @param dev Device where the polling was terminated. + * @param due_to_errors Whether polling stopped due to several failures. + * @param arg Custom argument. + */ + void (*on_polling_end)(usb_device_t *dev, bool due_to_errors, + void *arg); + /** Callback when error occurs. + * + * @param dev Device where error occurred. + * @param err_code Error code (as returned from usb_pipe_read). + * @param arg Custom argument. + * @return Whether to continue in polling. + */ + bool (*on_error)(usb_device_t *dev, int err_code, void *arg); +} usb_device_auto_polling_t; + +int usb_device_auto_polling(usb_device_t *, size_t, usb_device_auto_polling_t *, + size_t, void *); + +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, + usb_polling_callback_t, size_t, usb_polling_terminted_callback_t, void *); + +#endif +/** + * @} + */ Index: uspace/lib/usbdev/include/usb/dev/recognise.h =================================================================== --- uspace/lib/usbdev/include/usb/dev/recognise.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbdev/include/usb/dev/recognise.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbdev + * @{ + */ +/** @file + * USB device recognition. + */ +#ifndef LIBUSBDEV_RECOGNISE_H_ +#define LIBUSBDEV_RECOGNISE_H_ + +#include +#include +#include +#include + +int usb_device_create_match_ids_from_device_descriptor( + const usb_standard_device_descriptor_t *, match_id_list_t *); + +int usb_device_create_match_ids_from_interface( + const usb_standard_device_descriptor_t *, + const usb_standard_interface_descriptor_t *, match_id_list_t *); + +int usb_device_create_match_ids(usb_pipe_t *, match_id_list_t *); + +int usb_device_register_child_in_devman(usb_address_t, devman_handle_t, + ddf_dev_t *, devman_handle_t *, ddf_dev_ops_t *, void *, ddf_fun_t **); + +#endif +/** + * @} + */ Index: uspace/lib/usbdev/include/usb/dev/request.h =================================================================== --- uspace/lib/usbdev/include/usb/dev/request.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbdev/include/usb/dev/request.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,150 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbdev + * @{ + */ +/** @file + * Standard USB requests. + */ +#ifndef LIBUSBDEV_REQUEST_H_ +#define LIBUSBDEV_REQUEST_H_ + +#include +#include +#include +#include +#include + +/** USB device status - device is self powered (opposed to bus powered). */ +#define USB_DEVICE_STATUS_SELF_POWERED ((uint16_t)(1 << 0)) + +/** USB device status - remote wake-up signaling is enabled. */ +#define USB_DEVICE_STATUS_REMOTE_WAKEUP ((uint16_t)(1 << 1)) + +/** USB endpoint status - endpoint is halted (stalled). */ +#define USB_ENDPOINT_STATUS_HALTED ((uint16_t)(1 << 0)) + +/** USB feature selector - endpoint halt (stall). */ +#define USB_FEATURE_SELECTOR_ENDPOINT_HALT (0) + +/** USB feature selector - device remote wake-up. */ +#define USB_FEATURE_SELECTOR_REMOTE_WAKEUP (1) + +/** Standard device request. */ +typedef enum { + USB_DEVREQ_GET_STATUS = 0, + USB_DEVREQ_CLEAR_FEATURE = 1, + USB_DEVREQ_SET_FEATURE = 3, + USB_DEVREQ_SET_ADDRESS = 5, + USB_DEVREQ_GET_DESCRIPTOR = 6, + USB_DEVREQ_SET_DESCRIPTOR = 7, + USB_DEVREQ_GET_CONFIGURATION = 8, + USB_DEVREQ_SET_CONFIGURATION = 9, + USB_DEVREQ_GET_INTERFACE = 10, + USB_DEVREQ_SET_INTERFACE = 11, + USB_DEVREQ_SYNCH_FRAME = 12, + USB_DEVREQ_LAST_STD +} usb_stddevreq_t; + +/** Device request setup packet. + * The setup packet describes the request. + */ +typedef struct { + /** Request type. + * The type combines transfer direction, request type and + * intended recipient. + */ + uint8_t request_type; + /** Request identification. */ + uint8_t request; + /** Main parameter to the request. */ + union { + uint16_t value; + /* FIXME: add #ifdefs according to host endianness */ + struct { + uint8_t value_low; + uint8_t value_high; + }; + }; + /** Auxiliary parameter to the request. + * Typically, it is offset to something. + */ + uint16_t index; + /** Length of extra data. */ + uint16_t length; +} __attribute__ ((packed)) usb_device_request_setup_packet_t; + +int usb_control_request_set(usb_pipe_t *, + usb_request_type_t, usb_request_recipient_t, uint8_t, + uint16_t, uint16_t, void *, size_t); + +int usb_control_request_get(usb_pipe_t *, + usb_request_type_t, usb_request_recipient_t, uint8_t, + uint16_t, uint16_t, void *, size_t, size_t *); + +int usb_request_get_status(usb_pipe_t *, usb_request_recipient_t, + uint16_t, uint16_t *); +int usb_request_clear_feature(usb_pipe_t *, usb_request_type_t, + usb_request_recipient_t, uint16_t, uint16_t); +int usb_request_set_feature(usb_pipe_t *, usb_request_type_t, + usb_request_recipient_t, uint16_t, uint16_t); +int usb_request_set_address(usb_pipe_t *, usb_address_t); +int usb_request_get_descriptor(usb_pipe_t *, usb_request_type_t, + usb_request_recipient_t, uint8_t, uint8_t, uint16_t, void *, size_t, + size_t *); +int usb_request_get_descriptor_alloc(usb_pipe_t *, usb_request_type_t, + usb_request_recipient_t, uint8_t, uint8_t, uint16_t, void **, size_t *); +int usb_request_get_device_descriptor(usb_pipe_t *, + usb_standard_device_descriptor_t *); +int usb_request_get_bare_configuration_descriptor(usb_pipe_t *, int, + usb_standard_configuration_descriptor_t *); +int usb_request_get_full_configuration_descriptor(usb_pipe_t *, int, + void *, size_t, size_t *); +int usb_request_get_full_configuration_descriptor_alloc(usb_pipe_t *, + int, void **, size_t *); +int usb_request_set_descriptor(usb_pipe_t *, usb_request_type_t, + usb_request_recipient_t, uint8_t, uint8_t, uint16_t, void *, size_t); +int usb_request_get_configuration(usb_pipe_t *, uint8_t *); +int usb_request_set_configuration(usb_pipe_t *, uint8_t); +int usb_request_get_interface(usb_pipe_t *, uint8_t, uint8_t *); +int usb_request_set_interface(usb_pipe_t *, uint8_t, uint8_t); + +int usb_request_get_supported_languages(usb_pipe_t *, + l18_win_locales_t **, size_t *); +int usb_request_get_string(usb_pipe_t *, size_t, l18_win_locales_t, + char **); + +int usb_request_clear_endpoint_halt(usb_pipe_t *, uint16_t); +int usb_pipe_clear_halt(usb_pipe_t *, usb_pipe_t *); +int usb_request_get_endpoint_status(usb_pipe_t *, usb_pipe_t *, uint16_t *); + +#endif +/** + * @} + */ Index: uspace/lib/usbdev/src/altiface.c =================================================================== --- uspace/lib/usbdev/src/altiface.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbdev/src/altiface.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,181 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbdev + * @{ + */ +/** @file + * Handling alternate interface settings. + */ +#include +#include +#include +#include +#include +#include +#include + +/** 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. + */ +size_t usb_interface_count_alternates(uint8_t *config_descr, + size_t config_descr_size, uint8_t interface_no) +{ + assert(config_descr != NULL); + assert(config_descr_size > 0); + + 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; +} + +/** Create alternate interface representation structure. + * + * @param[in] config_descr Configuration descriptor. + * @param[in] config_descr_size Size of configuration descriptor. + * @param[in] interface_number Interface number. + * @param[out] alternates_ptr Where to store pointer to allocated structure. + * @return Error code. + */ +int usb_alternate_interfaces_create(uint8_t *config_descr, + size_t config_descr_size, int interface_number, + usb_alternate_interfaces_t **alternates_ptr) +{ + assert(alternates_ptr != NULL); + assert(config_descr != NULL); + assert(config_descr_size > 0); + + if (interface_number < 0) { + alternates_ptr = NULL; + return EOK; + } + + usb_alternate_interfaces_t *alternates + = malloc(sizeof(usb_alternate_interfaces_t)); + + if (alternates == NULL) { + return ENOMEM; + } + + alternates->alternative_count + = usb_interface_count_alternates(config_descr, config_descr_size, + interface_number); + + 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 = config_descr, + .size = config_descr_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 != interface_number)) { + 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++; + } + + *alternates_ptr = alternates; + + return EOK; +} + + +/** + * @} + */ Index: uspace/lib/usbdev/src/devdrv.c =================================================================== --- uspace/lib/usbdev/src/devdrv.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbdev/src/devdrv.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,563 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbdev + * @{ + */ +/** @file + * USB device driver framework. + */ +#include +#include +#include +#include +#include +#include +#include + +static int generic_add_device(ddf_dev_t *); + +static driver_ops_t generic_driver_ops = { + .add_device = generic_add_device +}; +static driver_t generic_driver = { + .driver_ops = &generic_driver_ops +}; + +static usb_driver_t *driver = NULL; + + +/** Main routine of USB device driver. + * + * Under normal conditions, this function never returns. + * + * @param drv USB device driver structure. + * @return Task exit status. + */ +int usb_driver_main(usb_driver_t *drv) +{ + assert(drv != NULL); + + /* Prepare the generic driver. */ + generic_driver.name = drv->name; + + driver = drv; + + return ddf_driver_main(&generic_driver); +} + +/** Count number of pipes the driver expects. + * + * @param drv USB driver. + * @return Number of pipes (excluding default control pipe). + */ +static size_t count_other_pipes(usb_endpoint_description_t **endpoints) +{ + size_t count = 0; + if (endpoints == NULL) { + return 0; + } + + while (endpoints[count] != NULL) { + count++; + } + + return count; +} + +/** Initialize endpoint pipes, excluding default control one. + * + * @param drv The device driver. + * @param dev Device to be initialized. + * @return Error code. + */ +static int initialize_other_pipes(usb_endpoint_description_t **endpoints, + usb_device_t *dev, int alternate_setting) +{ + if (endpoints == NULL) { + dev->pipes = NULL; + dev->pipes_count = 0; + return EOK; + } + + usb_endpoint_mapping_t *pipes; + size_t pipes_count; + + int rc = usb_device_create_pipes(dev->ddf_dev, &dev->wire, endpoints, + dev->descriptors.configuration, dev->descriptors.configuration_size, + dev->interface_no, alternate_setting, + &pipes, &pipes_count); + + if (rc != EOK) { + return rc; + } + + dev->pipes = pipes; + dev->pipes_count = pipes_count; + + return EOK; +} + +/** Callback when new device is supposed to be controlled by this driver. + * + * This callback is a wrapper for USB specific version of @c add_device. + * + * @param gen_dev Device structure as prepared by DDF. + * @return Error code. + */ +int generic_add_device(ddf_dev_t *gen_dev) +{ + assert(driver); + assert(driver->ops); + assert(driver->ops->add_device); + + int rc; + + usb_device_t *dev = NULL; + const char *err_msg = NULL; + rc = usb_device_create(gen_dev, driver->endpoints, &dev, &err_msg); + if (rc != EOK) { + usb_log_error("USB device `%s' creation failed (%s): %s.\n", + gen_dev->name, err_msg, str_error(rc)); + return rc; + } + + 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) +{ + int rc = usb_device_destroy_pipes(dev->ddf_dev, + dev->pipes, dev->pipes_count); + if (rc != EOK) { + return rc; + } + + 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(). + * + * @warning This is a wrapper function that does several operations that + * can fail and that cannot be rollbacked easily. That means that a failure + * during the SET_INTERFACE request would result in having a device with + * no pipes at all (except the default control one). That is because the old + * pipes needs to be unregistered at HC first and the new ones could not + * be created. + * + * @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; + + /* 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, (int) alternate_setting); + + return rc; +} + +/** Retrieve basic descriptors from the device. + * + * @param[in] ctrl_pipe Control endpoint pipe. + * @param[out] descriptors Where to store the descriptors. + * @return Error code. + */ +int usb_device_retrieve_descriptors(usb_pipe_t *ctrl_pipe, + usb_device_descriptors_t *descriptors) +{ + assert(descriptors != NULL); + + descriptors->configuration = NULL; + + int rc; + + /* It is worth to start a long transfer. */ + usb_pipe_start_long_transfer(ctrl_pipe); + + /* Get the device descriptor. */ + rc = usb_request_get_device_descriptor(ctrl_pipe, &descriptors->device); + if (rc != EOK) { + goto leave; + } + + /* Get the full configuration descriptor. */ + rc = usb_request_get_full_configuration_descriptor_alloc( + ctrl_pipe, 0, (void **) &descriptors->configuration, + &descriptors->configuration_size); + +leave: + usb_pipe_end_long_transfer(ctrl_pipe); + + return rc; +} + +/** Create pipes for a device. + * + * This is more or less a wrapper that does following actions: + * - allocate and initialize pipes + * - map endpoints to the pipes based on the descriptions + * - registers endpoints with the host controller + * + * @param[in] dev Generic DDF device backing the USB one. + * @param[in] wire Initialized backing connection to the host controller. + * @param[in] endpoints Endpoints description, NULL terminated. + * @param[in] config_descr Configuration descriptor of active configuration. + * @param[in] config_descr_size Size of @p config_descr in bytes. + * @param[in] interface_no Interface to map from. + * @param[in] interface_setting Interface setting (default is usually 0). + * @param[out] pipes_ptr Where to store array of created pipes + * (not NULL terminated). + * @param[out] pipes_count_ptr Where to store number of pipes + * (set to if you wish to ignore the count). + * @return Error code. + */ +int usb_device_create_pipes(ddf_dev_t *dev, usb_device_connection_t *wire, + usb_endpoint_description_t **endpoints, + uint8_t *config_descr, size_t config_descr_size, + int interface_no, int interface_setting, + usb_endpoint_mapping_t **pipes_ptr, size_t *pipes_count_ptr) +{ + assert(dev != NULL); + assert(wire != NULL); + assert(endpoints != NULL); + assert(config_descr != NULL); + assert(config_descr_size > 0); + assert(pipes_ptr != NULL); + + size_t i; + int rc; + + size_t pipe_count = count_other_pipes(endpoints); + if (pipe_count == 0) { + *pipes_ptr = NULL; + return EOK; + } + + usb_endpoint_mapping_t *pipes + = malloc(sizeof(usb_endpoint_mapping_t) * pipe_count); + if (pipes == NULL) { + return ENOMEM; + } + + /* Initialize to NULL to allow smooth rollback. */ + for (i = 0; i < pipe_count; i++) { + pipes[i].pipe = NULL; + } + + /* Now allocate and fully initialize. */ + for (i = 0; i < pipe_count; i++) { + pipes[i].pipe = malloc(sizeof(usb_pipe_t)); + if (pipes[i].pipe == NULL) { + rc = ENOMEM; + goto rollback_free_only; + } + pipes[i].description = endpoints[i]; + pipes[i].interface_no = interface_no; + pipes[i].interface_setting = interface_setting; + } + + /* Find the mapping from configuration descriptor. */ + rc = usb_pipe_initialize_from_configuration(pipes, pipe_count, + config_descr, config_descr_size, wire); + if (rc != EOK) { + goto rollback_free_only; + } + + /* Register the endpoints with HC. */ + usb_hc_connection_t hc_conn; + rc = usb_hc_connection_initialize_from_device(&hc_conn, dev); + if (rc != EOK) { + goto rollback_free_only; + } + + rc = usb_hc_connection_open(&hc_conn); + if (rc != EOK) { + goto rollback_free_only; + } + + for (i = 0; i < pipe_count; i++) { + if (pipes[i].present) { + rc = usb_pipe_register(pipes[i].pipe, + pipes[i].descriptor->poll_interval, &hc_conn); + if (rc != EOK) { + goto rollback_unregister_endpoints; + } + } + } + + usb_hc_connection_close(&hc_conn); + + *pipes_ptr = pipes; + if (pipes_count_ptr != NULL) { + *pipes_count_ptr = pipe_count; + } + + return EOK; + + /* + * Jump here if something went wrong after endpoints have + * been registered. + * This is also the target when the registration of + * endpoints fails. + */ +rollback_unregister_endpoints: + for (i = 0; i < pipe_count; i++) { + if (pipes[i].present) { + usb_pipe_unregister(pipes[i].pipe, &hc_conn); + } + } + + usb_hc_connection_close(&hc_conn); + + /* + * Jump here if something went wrong before some actual communication + * with HC. Then the only thing that needs to be done is to free + * allocated memory. + */ +rollback_free_only: + for (i = 0; i < pipe_count; i++) { + if (pipes[i].pipe != NULL) { + free(pipes[i].pipe); + } + } + free(pipes); + + return rc; +} + +/** Destroy pipes previously created by usb_device_create_pipes. + * + * @param[in] dev Generic DDF device backing the USB one. + * @param[in] pipes Endpoint mapping to be destroyed. + * @param[in] pipes_count Number of endpoints. + */ +int usb_device_destroy_pipes(ddf_dev_t *dev, + usb_endpoint_mapping_t *pipes, size_t pipes_count) +{ + assert(dev != NULL); + assert(((pipes != NULL) && (pipes_count > 0)) + || ((pipes == NULL) && (pipes_count == 0))); + + if (pipes_count == 0) { + return EOK; + } + + int rc; + + /* Prepare connection to HC to allow endpoint unregistering. */ + usb_hc_connection_t hc_conn; + rc = usb_hc_connection_initialize_from_device(&hc_conn, dev); + if (rc != EOK) { + return rc; + } + rc = usb_hc_connection_open(&hc_conn); + if (rc != EOK) { + return rc; + } + + /* Destroy the pipes. */ + size_t i; + for (i = 0; i < pipes_count; i++) { + usb_pipe_unregister(pipes[i].pipe, &hc_conn); + free(pipes[i].pipe); + } + + usb_hc_connection_close(&hc_conn); + + free(pipes); + + return EOK; +} + +/** Initialize control pipe in a device. + * + * @param dev USB device in question. + * @param errmsg Where to store error context. + * @return + */ +static int init_wire_and_ctrl_pipe(usb_device_t *dev, const char **errmsg) +{ + int rc; + + rc = usb_device_connection_initialize_from_device(&dev->wire, + dev->ddf_dev); + if (rc != EOK) { + *errmsg = "device connection initialization"; + return rc; + } + + rc = usb_pipe_initialize_default_control(&dev->ctrl_pipe, + &dev->wire); + if (rc != EOK) { + *errmsg = "default control pipe initialization"; + return rc; + } + + return EOK; +} + + +/** Create new instance of USB device. + * + * @param[in] ddf_dev Generic DDF device backing the USB one. + * @param[in] endpoints NULL terminated array of endpoints (NULL for none). + * @param[out] dev_ptr Where to store pointer to the new device. + * @param[out] errstr_ptr Where to store description of context + * (in case error occurs). + * @return Error code. + */ +int usb_device_create(ddf_dev_t *ddf_dev, + usb_endpoint_description_t **endpoints, + usb_device_t **dev_ptr, const char **errstr_ptr) +{ + assert(dev_ptr != NULL); + assert(ddf_dev != NULL); + + int rc; + + usb_device_t *dev = malloc(sizeof(usb_device_t)); + if (dev == NULL) { + *errstr_ptr = "structure allocation"; + return ENOMEM; + } + + // FIXME: proper deallocation in case of errors + + dev->ddf_dev = ddf_dev; + dev->driver_data = NULL; + dev->descriptors.configuration = NULL; + dev->alternate_interfaces = NULL; + + dev->pipes_count = 0; + dev->pipes = NULL; + + /* Initialize backing wire and control pipe. */ + rc = init_wire_and_ctrl_pipe(dev, errstr_ptr); + if (rc != EOK) { + return rc; + } + + /* Get our interface. */ + dev->interface_no = usb_device_get_assigned_interface(dev->ddf_dev); + + /* Retrieve standard descriptors. */ + rc = usb_device_retrieve_descriptors(&dev->ctrl_pipe, + &dev->descriptors); + if (rc != EOK) { + *errstr_ptr = "descriptor retrieval"; + return rc; + } + + /* Create alternate interfaces. */ + rc = usb_alternate_interfaces_create(dev->descriptors.configuration, + dev->descriptors.configuration_size, dev->interface_no, + &dev->alternate_interfaces); + if (rc != EOK) { + /* We will try to silently ignore this. */ + dev->alternate_interfaces = NULL; + } + + rc = initialize_other_pipes(endpoints, dev, 0); + if (rc != EOK) { + *errstr_ptr = "pipes initialization"; + return rc; + } + + *errstr_ptr = NULL; + *dev_ptr = dev; + + return EOK; +} + +/** Destroy instance of a USB device. + * + * @param dev Device to be destroyed. + */ +void usb_device_destroy(usb_device_t *dev) +{ + if (dev == NULL) { + return; + } + + /* Ignore errors and hope for the best. */ + usb_device_destroy_pipes(dev->ddf_dev, dev->pipes, dev->pipes_count); + if (dev->descriptors.configuration != NULL) { + free(dev->descriptors.configuration); + } + + if (dev->alternate_interfaces != NULL) { + if (dev->alternate_interfaces->alternatives != NULL) { + free(dev->alternate_interfaces->alternatives); + } + free(dev->alternate_interfaces); + } + + free(dev); +} + +/** + * @} + */ Index: uspace/lib/usbdev/src/devpoll.c =================================================================== --- uspace/lib/usbdev/src/devpoll.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbdev/src/devpoll.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,317 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbdev + * @{ + */ +/** @file + * USB device driver framework - automatic interrupt polling. + */ +#include +#include +#include +#include +#include +#include +#include + +/** Maximum number of failed consecutive requests before announcing failure. */ +#define MAX_FAILED_ATTEMPTS 3 + +/** Data needed for polling. */ +typedef struct { + int debug; + size_t max_failures; + useconds_t delay; + bool auto_clear_halt; + bool (*on_data)(usb_device_t *, uint8_t *, size_t, void *); + void (*on_polling_end)(usb_device_t *, bool, void *); + bool (*on_error)(usb_device_t *, int, void *); + + usb_device_t *dev; + size_t pipe_index; + size_t request_size; + uint8_t *buffer; + void *custom_arg; +} polling_data_t; + + +/** Polling fibril. + * + * @param arg Pointer to polling_data_t. + * @return Always EOK. + */ +static int polling_fibril(void *arg) +{ + polling_data_t *polling_data = (polling_data_t *) arg; + assert(polling_data); + + usb_pipe_t *pipe + = polling_data->dev->pipes[polling_data->pipe_index].pipe; + + if (polling_data->debug > 0) { + usb_endpoint_mapping_t *mapping + = &polling_data->dev->pipes[polling_data->pipe_index]; + usb_log_debug("Poll%p: started polling of `%s' - " \ + "interface %d (%s,%d,%d), %zuB/%zu.\n", + polling_data, + polling_data->dev->ddf_dev->name, + (int) mapping->interface->interface_number, + usb_str_class(mapping->interface->interface_class), + (int) mapping->interface->interface_subclass, + (int) mapping->interface->interface_protocol, + polling_data->request_size, pipe->max_packet_size); + } + + size_t failed_attempts = 0; + while (failed_attempts <= polling_data->max_failures) { + int rc; + + size_t actual_size; + rc = usb_pipe_read(pipe, polling_data->buffer, + polling_data->request_size, &actual_size); + + if (polling_data->debug > 1) { + if (rc == EOK) { + usb_log_debug( + "Poll%p: received: '%s' (%zuB).\n", + polling_data, + usb_debug_str_buffer(polling_data->buffer, + actual_size, 16), + actual_size); + } else { + usb_log_debug( + "Poll%p: polling failed: %s.\n", + polling_data, str_error(rc)); + } + } + + /* If the pipe stalled, we can try to reset the stall. */ + if ((rc == ESTALL) && (polling_data->auto_clear_halt)) { + /* + * We ignore error here as this is usually a futile + * attempt anyway. + */ + usb_request_clear_endpoint_halt( + &polling_data->dev->ctrl_pipe, + pipe->endpoint_no); + } + + if (rc != EOK) { + if (polling_data->on_error != NULL) { + bool cont = polling_data->on_error( + polling_data->dev, rc, + polling_data->custom_arg); + if (!cont) { + failed_attempts + = polling_data->max_failures; + } + } + failed_attempts++; + continue; + } + + /* We have the data, execute the callback now. */ + bool carry_on = polling_data->on_data(polling_data->dev, + polling_data->buffer, actual_size, + polling_data->custom_arg); + + if (!carry_on) { + failed_attempts = 0; + break; + } + + /* Reset as something might be only a temporary problem. */ + failed_attempts = 0; + + /* Take a rest before next request. */ + async_usleep(polling_data->delay); + } + + if (polling_data->on_polling_end != NULL) { + polling_data->on_polling_end(polling_data->dev, + failed_attempts > 0, polling_data->custom_arg); + } + + if (polling_data->debug > 0) { + if (failed_attempts > 0) { + usb_log_error( + "Polling of device `%s' terminated: %s.\n", + polling_data->dev->ddf_dev->name, + "recurring failures"); + } else { + usb_log_debug( + "Polling of device `%s' terminated by user.\n", + polling_data->dev->ddf_dev->name + ); + } + } + + /* Free the allocated memory. */ + free(polling_data->buffer); + free(polling_data); + + return EOK; +} + +/** Start automatic device polling over interrupt in pipe. + * + * @warning It is up to the callback to produce delays between individual + * requests. + * + * @warning There is no guarantee when the request to the device + * will be sent for the first time (it is possible that this + * first request would be executed prior to return from this function). + * + * @param dev Device to be periodically polled. + * @param pipe_index Index of the endpoint pipe used for polling. + * @param callback Callback when data are available. + * @param request_size How many bytes to ask for in each request. + * @param terminated_callback Callback when polling is terminated. + * @param arg Custom argument (passed as is to the callbacks). + * @return Error code. + * @retval EOK New fibril polling the device was already started. + */ +int usb_device_auto_poll(usb_device_t *dev, size_t pipe_index, + usb_polling_callback_t callback, size_t request_size, + usb_polling_terminted_callback_t terminated_callback, void *arg) +{ + if ((dev == NULL) || (callback == NULL)) { + return EBADMEM; + } + if (request_size == 0) { + return EINVAL; + } + if ((dev->pipes[pipe_index].pipe->transfer_type != USB_TRANSFER_INTERRUPT) + || (dev->pipes[pipe_index].pipe->direction != USB_DIRECTION_IN)) { + return EINVAL; + } + + usb_device_auto_polling_t *auto_polling + = malloc(sizeof(usb_device_auto_polling_t)); + if (auto_polling == NULL) { + return ENOMEM; + } + + auto_polling->debug = 1; + auto_polling->auto_clear_halt = true; + auto_polling->delay = 0; + auto_polling->max_failures = MAX_FAILED_ATTEMPTS; + auto_polling->on_data = callback; + auto_polling->on_polling_end = terminated_callback; + auto_polling->on_error = NULL; + + int rc = usb_device_auto_polling(dev, pipe_index, auto_polling, + request_size, arg); + + free(auto_polling); + + return rc; +} + +/** Start automatic device polling over interrupt in pipe. + * + * The polling settings is copied thus it is okay to destroy the structure + * after this function returns. + * + * @warning There is no guarantee when the request to the device + * will be sent for the first time (it is possible that this + * first request would be executed prior to return from this function). + * + * @param dev Device to be periodically polled. + * @param pipe_index Index of the endpoint pipe used for polling. + * @param polling Polling settings. + * @param request_size How many bytes to ask for in each request. + * @param arg Custom argument (passed as is to the callbacks). + * @return Error code. + * @retval EOK New fibril polling the device was already started. + */ +int usb_device_auto_polling(usb_device_t *dev, size_t pipe_index, + usb_device_auto_polling_t *polling, + size_t request_size, void *arg) +{ + if (dev == NULL) { + return EBADMEM; + } + if (pipe_index >= dev->pipes_count) { + return EINVAL; + } + if ((dev->pipes[pipe_index].pipe->transfer_type != USB_TRANSFER_INTERRUPT) + || (dev->pipes[pipe_index].pipe->direction != USB_DIRECTION_IN)) { + return EINVAL; + } + if ((polling == NULL) || (polling->on_data == NULL)) { + return EBADMEM; + } + + polling_data_t *polling_data = malloc(sizeof(polling_data_t)); + if (polling_data == NULL) { + return ENOMEM; + } + + /* Fill-in the data. */ + polling_data->buffer = malloc(sizeof(request_size)); + if (polling_data->buffer == NULL) { + free(polling_data); + return ENOMEM; + } + polling_data->request_size = request_size; + polling_data->dev = dev; + polling_data->pipe_index = pipe_index; + polling_data->custom_arg = arg; + + polling_data->debug = polling->debug; + polling_data->max_failures = polling->max_failures; + if (polling->delay >= 0) { + polling_data->delay = (useconds_t) polling->delay; + } else { + polling_data->delay = (useconds_t) dev->pipes[pipe_index] + .descriptor->poll_interval; + } + polling_data->auto_clear_halt = polling->auto_clear_halt; + + polling_data->on_data = polling->on_data; + polling_data->on_polling_end = polling->on_polling_end; + polling_data->on_error = polling->on_error; + + fid_t fibril = fibril_create(polling_fibril, polling_data); + if (fibril == 0) { + free(polling_data->buffer); + free(polling_data); + return ENOMEM; + } + fibril_add_ready(fibril); + + /* Fibril launched. That fibril will free the allocated data. */ + + return EOK; +} + +/** + * @} + */ Index: uspace/lib/usbdev/src/dp.c =================================================================== --- uspace/lib/usbdev/src/dp.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbdev/src/dp.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,326 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbdev + * @{ + */ +/** + * @file + * USB descriptor parser (implementation). + * + * The descriptor parser is a generic parser for structure, where individual + * items are stored in single buffer and each item begins with length followed + * by type. These types are organized into tree hierarchy. + * + * The parser is able of only two actions: find first child and find next + * sibling. + */ +#include +#include +#include +#include +#include +#include +#include + +#define NESTING(parentname, childname) \ + { \ + .child = USB_DESCTYPE_##childname, \ + .parent = USB_DESCTYPE_##parentname, \ + } +#define LAST_NESTING { -1, -1 } + +/** Nesting of standard USB descriptors. */ +usb_dp_descriptor_nesting_t usb_dp_standard_descriptor_nesting[] = { + NESTING(CONFIGURATION, INTERFACE), + NESTING(INTERFACE, ENDPOINT), + NESTING(INTERFACE, HUB), + NESTING(INTERFACE, HID), + NESTING(HID, HID_REPORT), + LAST_NESTING +}; + +#undef NESTING +#undef LAST_NESTING + +/** Tells whether pointer points inside descriptor data. + * + * @param data Parser data. + * @param ptr Pointer to be verified. + * @return Whether @p ptr points inside data->data field. + */ +static bool is_valid_descriptor_pointer(usb_dp_parser_data_t *data, + uint8_t *ptr) +{ + if (ptr == NULL) { + return false; + } + + if (ptr < data->data) { + return false; + } + + if ((size_t)(ptr - data->data) >= data->size) { + return false; + } + + return true; +} + +/** Get next descriptor regardless of the nesting. + * + * @param data Parser data. + * @param current Pointer to current descriptor. + * @return Pointer to start of next descriptor. + * @retval NULL Invalid input or no next descriptor. + */ +static uint8_t *get_next_descriptor(usb_dp_parser_data_t *data, + uint8_t *current) +{ + assert(is_valid_descriptor_pointer(data, current)); + + uint8_t current_length = *current; + uint8_t *next = current + current_length; + + if (!is_valid_descriptor_pointer(data, next)) { + return NULL; + } + + return next; +} + +/** Get descriptor type. + * + * @see usb_descriptor_type_t + * + * @param data Parser data. + * @param start Pointer to start of the descriptor. + * @return Descriptor type. + * @retval -1 Invalid input. + */ +static int get_descriptor_type(usb_dp_parser_data_t *data, uint8_t *start) +{ + if (start == NULL) { + return -1; + } + + start++; + if (!is_valid_descriptor_pointer(data, start)) { + return -1; + } else { + return (int) (*start); + } +} + +/** Tells whether descriptors could be nested. + * + * @param parser Parser. + * @param child Child descriptor type. + * @param parent Parent descriptor type. + * @return Whether @p child could be child of @p parent. + */ +static bool is_nested_descriptor_type(usb_dp_parser_t *parser, + int child, int parent) +{ + usb_dp_descriptor_nesting_t *nesting = parser->nesting; + while ((nesting->child > 0) && (nesting->parent > 0)) { + if ((nesting->child == child) && (nesting->parent == parent)) { + return true; + } + nesting++; + } + return false; +} + +/** Tells whether descriptors could be nested. + * + * @param parser Parser. + * @param data Parser data. + * @param child Pointer to child descriptor. + * @param parent Pointer to parent descriptor. + * @return Whether @p child could be child of @p parent. + */ +static bool is_nested_descriptor(usb_dp_parser_t *parser, + usb_dp_parser_data_t *data, uint8_t *child, uint8_t *parent) +{ + return is_nested_descriptor_type(parser, + get_descriptor_type(data, child), + get_descriptor_type(data, parent)); +} + +/** Find first nested descriptor of given parent. + * + * @param parser Parser. + * @param data Parser data. + * @param parent Pointer to the beginning of parent descriptor. + * @return Pointer to the beginning of the first nested (child) descriptor. + * @retval NULL No child descriptor found. + * @retval NULL Invalid input. + */ +uint8_t *usb_dp_get_nested_descriptor(usb_dp_parser_t *parser, + usb_dp_parser_data_t *data, uint8_t *parent) +{ + if (!is_valid_descriptor_pointer(data, parent)) { + return NULL; + } + + uint8_t *next = get_next_descriptor(data, parent); + if (next == NULL) { + return NULL; + } + + if (is_nested_descriptor(parser, data, next, parent)) { + return next; + } else { + return NULL; + } +} + +/** Skip all nested descriptors. + * + * @param parser Parser. + * @param data Parser data. + * @param parent Pointer to the beginning of parent descriptor. + * @return Pointer to first non-child descriptor. + * @retval NULL No next descriptor. + * @retval NULL Invalid input. + */ +static uint8_t *skip_nested_descriptors(usb_dp_parser_t *parser, + usb_dp_parser_data_t *data, uint8_t *parent) +{ + uint8_t *child = usb_dp_get_nested_descriptor(parser, data, parent); + if (child == NULL) { + return get_next_descriptor(data, parent); + } + uint8_t *next_child = skip_nested_descriptors(parser, data, child); + while (is_nested_descriptor(parser, data, next_child, parent)) { + next_child = skip_nested_descriptors(parser, data, next_child); + } + + return next_child; +} + +/** Get sibling descriptor. + * + * @param parser Parser. + * @param data Parser data. + * @param parent Pointer to common parent descriptor. + * @param sibling Left sibling. + * @return Pointer to first right sibling of @p sibling. + * @retval NULL No sibling exist. + * @retval NULL Invalid input. + */ +uint8_t *usb_dp_get_sibling_descriptor(usb_dp_parser_t *parser, + usb_dp_parser_data_t *data, uint8_t *parent, uint8_t *sibling) +{ + if (!is_valid_descriptor_pointer(data, parent) + || !is_valid_descriptor_pointer(data, sibling)) { + return NULL; + } + + uint8_t *possible_sibling = skip_nested_descriptors(parser, data, sibling); + if (possible_sibling == NULL) { + return NULL; + } + + int parent_type = get_descriptor_type(data, parent); + int possible_sibling_type = get_descriptor_type(data, possible_sibling); + if (is_nested_descriptor_type(parser, possible_sibling_type, parent_type)) { + return possible_sibling; + } else { + return NULL; + } +} + +/** Browser of the descriptor tree. + * + * @see usb_dp_walk_simple + * + * @param parser Descriptor parser. + * @param data Data for descriptor parser. + * @param root Pointer to current root of the tree. + * @param depth Current nesting depth. + * @param callback Callback for each found descriptor. + * @param arg Custom (user) argument. + */ +static void usb_dp_browse_simple_internal(usb_dp_parser_t *parser, + usb_dp_parser_data_t *data, uint8_t *root, size_t depth, + void (*callback)(uint8_t *, size_t, void *), void *arg) +{ + if (root == NULL) { + return; + } + callback(root, depth, arg); + uint8_t *child = usb_dp_get_nested_descriptor(parser, data, root); + do { + usb_dp_browse_simple_internal(parser, data, child, depth + 1, + callback, arg); + child = usb_dp_get_sibling_descriptor(parser, data, + root, child); + } while (child != NULL); +} + +/** Browse flatten descriptor tree. + * + * The callback is called with following arguments: pointer to the start + * of the descriptor (somewhere inside @p descriptors), depth of the nesting + * (starting from 0 for the first descriptor) and the custom argument. + * Note that the size of the descriptor is not passed because it can + * be read from the first byte of the descriptor. + * + * @param descriptors Descriptor data. + * @param descriptors_size Size of descriptor data (in bytes). + * @param descriptor_nesting Possible descriptor nesting. + * @param callback Callback for each found descriptor. + * @param arg Custom (user) argument. + */ +void usb_dp_walk_simple(uint8_t *descriptors, size_t descriptors_size, + usb_dp_descriptor_nesting_t *descriptor_nesting, + void (*callback)(uint8_t *, size_t, void *), void *arg) +{ + if ((descriptors == NULL) || (descriptors_size == 0) + || (descriptor_nesting == NULL) || (callback == NULL)) { + return; + } + + usb_dp_parser_data_t data = { + .data = descriptors, + .size = descriptors_size, + .arg = NULL + }; + + usb_dp_parser_t parser = { + .nesting = descriptor_nesting + }; + + usb_dp_browse_simple_internal(&parser, &data, descriptors, + 0, callback, arg); +} + +/** @} + */ Index: uspace/lib/usbdev/src/hub.c =================================================================== --- uspace/lib/usbdev/src/hub.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbdev/src/hub.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,377 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbdev + * @{ + */ +/** @file + * Functions needed by hub drivers. + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/** How much time to wait between attempts to register endpoint 0:0. + * The value is based on typical value for port reset + some overhead. + */ +#define ENDPOINT_0_0_REGISTER_ATTEMPT_DELAY_USEC (1000 * (10 + 2)) + +/** Check that HC connection is alright. + * + * @param conn Connection to be checked. + */ +#define CHECK_CONNECTION(conn) \ + do { \ + assert((conn)); \ + if (!usb_hc_connection_is_opened((conn))) { \ + return ENOENT; \ + } \ + } while (false) + +/** Ask host controller for free address assignment. + * + * @param connection Opened connection to host controller. + * @param speed Speed of the new device (device that will be assigned + * the returned address). + * @return Assigned USB address or negative error code. + */ +usb_address_t usb_hc_request_address(usb_hc_connection_t *connection, + usb_speed_t speed) +{ + CHECK_CONNECTION(connection); + + async_exch_t *exch = async_exchange_begin(connection->hc_sess); + + sysarg_t address; + int rc = async_req_2_1(exch, DEV_IFACE_ID(USBHC_DEV_IFACE), + IPC_M_USBHC_REQUEST_ADDRESS, speed, + &address); + + async_exchange_end(exch); + + if (rc != EOK) + return (usb_address_t) rc; + + return (usb_address_t) address; +} + +/** Inform host controller about new device. + * + * @param connection Opened connection to host controller. + * @param attached_device Information about the new device. + * @return Error code. + */ +int usb_hc_register_device(usb_hc_connection_t * connection, + const usb_hc_attached_device_t *attached_device) +{ + CHECK_CONNECTION(connection); + + if (attached_device == NULL) + return EBADMEM; + + async_exch_t *exch = async_exchange_begin(connection->hc_sess); + int rc = async_req_3_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE), + IPC_M_USBHC_BIND_ADDRESS, + attached_device->address, attached_device->handle); + async_exchange_end(exch); + + return rc; +} + +/** Inform host controller about device removal. + * + * @param connection Opened connection to host controller. + * @param address Address of the device that is being removed. + * @return Error code. + */ +int usb_hc_unregister_device(usb_hc_connection_t *connection, + usb_address_t address) +{ + CHECK_CONNECTION(connection); + + async_exch_t *exch = async_exchange_begin(connection->hc_sess); + int rc = async_req_2_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE), + IPC_M_USBHC_RELEASE_ADDRESS, address); + async_exchange_end(exch); + + return rc; +} + + +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); +} + + +/** Wrapper for registering attached device to the hub. + * + * The @p enable_port function is expected to enable signaling on given + * port. + * The two arguments to it can have arbitrary meaning + * (the @p port_no is only a suggestion) + * and are not touched at all by this function + * (they are passed as is to the @p enable_port function). + * + * If the @p enable_port fails (i.e. does not return EOK), the device + * addition is canceled. + * The return value is then returned (it is good idea to use different + * error codes than those listed as return codes by this function itself). + * + * The @p connection representing connection with host controller does not + * need to be started. + * This function duplicates the connection to allow simultaneous calls of + * this function (i.e. from different fibrils). + * + * @param[in] parent Parent device (i.e. the hub device). + * @param[in] connection Connection to host controller. + * @param[in] dev_speed New device speed. + * @param[in] enable_port Function for enabling signaling through the port the + * device is attached to. + * @param[in] port_no Port number (passed through to @p enable_port). + * @param[in] arg Any data argument to @p enable_port. + * @param[out] assigned_address USB address of the device. + * @param[out] assigned_handle Devman handle of the new device. + * @param[in] dev_ops Child device ops. + * @param[in] new_dev_data Arbitrary pointer to be stored in the child + * as @c driver_data. + * @param[out] new_fun Storage where pointer to allocated child function + * will be written. + * @return Error code. + * @retval ENOENT Connection to HC not opened. + * @retval EADDRNOTAVAIL Failed retrieving free address from host controller. + * @retval EBUSY Failed reserving default USB address. + * @retval ENOTCONN Problem connecting to the host controller via USB pipe. + * @retval ESTALL Problem communication with device (either SET_ADDRESS + * request or requests for descriptors when creating match ids). + */ +int usb_hc_new_device_wrapper(ddf_dev_t *parent, usb_hc_connection_t *connection, + usb_speed_t dev_speed, + int (*enable_port)(int port_no, void *arg), int port_no, void *arg, + usb_address_t *assigned_address, devman_handle_t *assigned_handle, + ddf_dev_ops_t *dev_ops, void *new_dev_data, ddf_fun_t **new_fun) +{ + assert(connection != NULL); + // FIXME: this is awful, we are accessing directly the structure. + usb_hc_connection_t hc_conn = { + .hc_handle = connection->hc_handle, + .hc_sess = NULL + }; + + int rc; + struct timeval start_time; + + rc = gettimeofday(&start_time, NULL); + if (rc != EOK) { + return rc; + } + + rc = usb_hc_connection_open(&hc_conn); + if (rc != EOK) { + return rc; + } + + + /* + * Request new address. + */ + usb_address_t dev_addr = usb_hc_request_address(&hc_conn, dev_speed); + if (dev_addr < 0) { + usb_hc_connection_close(&hc_conn); + return EADDRNOTAVAIL; + } + + /* + * We will not register control pipe on default address. + * The registration might fail. That means that someone else already + * registered that endpoint. We will simply wait and try again. + * (Someone else already wants to add a new device.) + */ + usb_device_connection_t dev_conn; + rc = usb_device_connection_initialize_on_default_address(&dev_conn, + &hc_conn); + if (rc != EOK) { + rc = ENOTCONN; + goto leave_release_free_address; + } + + usb_pipe_t ctrl_pipe; + rc = usb_pipe_initialize_default_control(&ctrl_pipe, + &dev_conn); + if (rc != EOK) { + rc = ENOTCONN; + goto leave_release_free_address; + } + + do { + rc = usb_pipe_register_with_speed(&ctrl_pipe, dev_speed, 0, + &hc_conn); + if (rc != EOK) { + /* Do not overheat the CPU ;-). */ + async_usleep(ENDPOINT_0_0_REGISTER_ATTEMPT_DELAY_USEC); + } + } while (rc != EOK); + struct timeval end_time; + + rc = gettimeofday(&end_time, NULL); + if (rc != EOK) { + goto leave_release_default_address; + } + + /* According to the USB spec part 9.1.2 host allows 100ms time for + * the insertion process to complete. According to 7.1.7.1 this is the + * time between attach detected and port reset. However, the setup done + * above might use much of this time so we should only wait to fill + * up the 100ms quota*/ + suseconds_t elapsed = tv_sub(&end_time, &start_time); + if (elapsed < 100000) { + async_usleep(100000 - elapsed); + } + + /* + * Endpoint is registered. We can enable the port and change + * device address. + */ + rc = enable_port(port_no, arg); + if (rc != EOK) { + goto leave_release_default_address; + } + /* USB spec 7.1.7.1: The USB System Software guarantees a minimum of + * 10ms for reset recovery. Device response to any bus transactions + * addressed to the default device address during the reset recovery + * time is undefined. + */ + async_usleep(10000); + + rc = usb_pipe_probe_default_control(&ctrl_pipe); + if (rc != EOK) { + rc = ESTALL; + goto leave_release_default_address; + } + + rc = usb_request_set_address(&ctrl_pipe, dev_addr); + if (rc != EOK) { + rc = ESTALL; + goto leave_release_default_address; + } + + /* + * Address changed. We can release the original endpoint, thus + * allowing other to access the default address. + */ + unregister_control_endpoint_on_default_address(&hc_conn); + + /* + * Time to register the new endpoint. + */ + rc = usb_pipe_register(&ctrl_pipe, 0, &hc_conn); + if (rc != EOK) { + goto leave_release_free_address; + } + + /* + * It is time to register the device with devman. + */ + /* FIXME: create device_register that will get opened ctrl pipe. */ + devman_handle_t child_handle; + rc = usb_device_register_child_in_devman(dev_addr, dev_conn.hc_handle, + parent, &child_handle, + dev_ops, new_dev_data, new_fun); + if (rc != EOK) { + rc = ESTALL; + goto leave_release_free_address; + } + + /* + * And now inform the host controller about the handle. + */ + usb_hc_attached_device_t new_device = { + .address = dev_addr, + .handle = child_handle + }; + rc = usb_hc_register_device(&hc_conn, &new_device); + if (rc != EOK) { + rc = EDESTADDRREQ; + goto leave_release_free_address; + } + + usb_hc_connection_close(&hc_conn); + + /* + * And we are done. + */ + if (assigned_address != NULL) { + *assigned_address = dev_addr; + } + if (assigned_handle != NULL) { + *assigned_handle = child_handle; + } + + return EOK; + + + + /* + * Error handling (like nested exceptions) starts here. + * Completely ignoring errors here. + */ +leave_release_default_address: + usb_pipe_unregister(&ctrl_pipe, &hc_conn); + +leave_release_free_address: + usb_hc_unregister_device(&hc_conn, dev_addr); + + usb_hc_connection_close(&hc_conn); + + return rc; +} + +/** + * @} + */ Index: uspace/lib/usbdev/src/pipepriv.c =================================================================== --- uspace/lib/usbdev/src/pipepriv.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbdev/src/pipepriv.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,147 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbdev + * @{ + */ +/** @file + * Library internal functions on USB pipes (implementation). + */ +#include "pipepriv.h" +#include +#include +#include + +/** Ensure exclusive access to the IPC phone of given pipe. + * + * @param pipe Pipe to be exclusively accessed. + */ +void pipe_start_transaction(usb_pipe_t *pipe) +{ + fibril_mutex_lock(&pipe->hc_sess_mutex); +} + +/** Terminate exclusive access to the IPC phone of given pipe. + * + * @param pipe Pipe to be released from exclusive usage. + */ +void pipe_end_transaction(usb_pipe_t *pipe) +{ + fibril_mutex_unlock(&pipe->hc_sess_mutex); +} + +/** Ensure exclusive access to the pipe as a whole. + * + * @param pipe Pipe to be exclusively accessed. + */ +void pipe_acquire(usb_pipe_t *pipe) +{ + fibril_mutex_lock(&pipe->guard); +} + +/** Terminate exclusive access to the pipe as a whole. + * + * @param pipe Pipe to be released from exclusive usage. + */ +void pipe_release(usb_pipe_t *pipe) +{ + fibril_mutex_unlock(&pipe->guard); +} + +/** Add reference of active transfers over the pipe. + * + * @param pipe The USB pipe. + * @param hide_failure Whether to hide failure when adding reference + * (use soft refcount). + * @return Error code. + * @retval EOK Currently always. + */ +int pipe_add_ref(usb_pipe_t *pipe, bool hide_failure) +{ + pipe_acquire(pipe); + + if (pipe->refcount == 0) { + /* Need to open the phone by ourselves. */ + async_sess_t *sess = + devman_device_connect(EXCHANGE_SERIALIZE, pipe->wire->hc_handle, 0); + if (!sess) { + if (hide_failure) { + pipe->refcount_soft++; + pipe_release(pipe); + return EOK; + } + + pipe_release(pipe); + return ENOMEM; + } + + /* + * No locking is needed, refcount is zero and whole pipe + * mutex is locked. + */ + + pipe->hc_sess = sess; + } + + pipe->refcount++; + pipe_release(pipe); + + return EOK; +} + +/** Drop active transfer reference on the pipe. + * + * @param pipe The USB pipe. + */ +void pipe_drop_ref(usb_pipe_t *pipe) +{ + pipe_acquire(pipe); + + if (pipe->refcount_soft > 0) { + pipe->refcount_soft--; + pipe_release(pipe); + return; + } + + assert(pipe->refcount > 0); + + pipe->refcount--; + + if (pipe->refcount == 0) { + /* We were the last users, let's hang-up. */ + async_hangup(pipe->hc_sess); + pipe->hc_sess = NULL; + } + + pipe_release(pipe); +} + + +/** + * @} + */ Index: uspace/lib/usbdev/src/pipepriv.h =================================================================== --- uspace/lib/usbdev/src/pipepriv.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbdev/src/pipepriv.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbdev + * @{ + */ +/** @file + * Library internal functions on USB pipes. + */ +#ifndef LIBUSBDEV_PIPEPRIV_H_ +#define LIBUSBDEV_PIPEPRIV_H_ + +#include +#include + +void pipe_acquire(usb_pipe_t *); +void pipe_release(usb_pipe_t *); + +void pipe_start_transaction(usb_pipe_t *); +void pipe_end_transaction(usb_pipe_t *); + +int pipe_add_ref(usb_pipe_t *, bool); +void pipe_drop_ref(usb_pipe_t *); + + +#endif +/** + * @} + */ Index: uspace/lib/usbdev/src/pipes.c =================================================================== --- uspace/lib/usbdev/src/pipes.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbdev/src/pipes.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,234 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbdev + * @{ + */ +/** @file + * USB endpoint pipes miscellaneous functions. + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "pipepriv.h" + +#define IPC_AGAIN_DELAY (1000 * 2) /* 2ms */ + +/** Tell USB address assigned to given device. + * + * @param sess Session to parent device. + * @param dev Device in question. + * @return USB address or error code. + */ +static usb_address_t get_my_address(async_sess_t *sess, ddf_dev_t *dev) +{ + async_exch_t *exch = async_exchange_begin(sess); + + /* + * We are sending special value as a handle - zero - to get + * handle of the parent function (that handle was used + * when registering our device @p dev. + */ + sysarg_t address; + int rc = async_req_2_1(exch, DEV_IFACE_ID(USB_DEV_IFACE), + IPC_M_USB_GET_ADDRESS, 0, &address); + + async_exchange_end(exch); + + if (rc != EOK) + return rc; + + return (usb_address_t) address; +} + +/** Tell USB interface assigned to given device. + * + * @param device Device in question. + * @return Interface number (negative code means any). + */ +int usb_device_get_assigned_interface(ddf_dev_t *device) +{ + async_sess_t *parent_sess = + devman_parent_device_connect(EXCHANGE_SERIALIZE, device->handle, + IPC_FLAG_BLOCKING); + if (!parent_sess) + return -1; + + async_exch_t *exch = async_exchange_begin(parent_sess); + + sysarg_t iface_no; + int rc = async_req_2_1(exch, DEV_IFACE_ID(USB_DEV_IFACE), + IPC_M_USB_GET_INTERFACE, device->handle, &iface_no); + + async_exchange_end(exch); + async_hangup(parent_sess); + + if (rc != EOK) + return -1; + + return (int) iface_no; +} + +/** Initialize connection to USB device. + * + * @param connection Connection structure to be initialized. + * @param dev Generic device backing the USB device. + * @return Error code. + */ +int usb_device_connection_initialize_from_device( + usb_device_connection_t *connection, ddf_dev_t *dev) +{ + assert(connection); + assert(dev); + + int rc; + devman_handle_t hc_handle; + usb_address_t my_address; + + rc = usb_hc_find(dev->handle, &hc_handle); + if (rc != EOK) + return rc; + + async_sess_t *parent_sess = + devman_parent_device_connect(EXCHANGE_SERIALIZE, dev->handle, + IPC_FLAG_BLOCKING); + if (!parent_sess) + return ENOMEM; + + /* + * Asking for "my" address may require several attempts. + * That is because following scenario may happen: + * - parent driver (i.e. driver of parent device) announces new device + * and devman launches current driver + * - parent driver is preempted and thus does not send address-handle + * binding to HC driver + * - this driver gets here and wants the binding + * - the HC does not know the binding yet and thus it answers ENOENT + * So, we need to wait for the HC to learn the binding. + */ + + do { + my_address = get_my_address(parent_sess, dev); + + if (my_address == ENOENT) { + /* Be nice, let other fibrils run and try again. */ + async_usleep(IPC_AGAIN_DELAY); + } else if (my_address < 0) { + /* Some other problem, no sense trying again. */ + rc = my_address; + goto leave; + } + + } while (my_address < 0); + + rc = usb_device_connection_initialize(connection, + hc_handle, my_address); + +leave: + async_hangup(parent_sess); + return rc; +} + +/** Initialize connection to USB device. + * + * @param connection Connection structure to be initialized. + * @param host_controller_handle Devman handle of host controller device is + * connected to. + * @param device_address Device USB address. + * @return Error code. + */ +int usb_device_connection_initialize(usb_device_connection_t *connection, + devman_handle_t host_controller_handle, usb_address_t device_address) +{ + assert(connection); + + if ((device_address < 0) || (device_address >= USB11_ADDRESS_MAX)) { + return EINVAL; + } + + connection->hc_handle = host_controller_handle; + connection->address = device_address; + + return EOK; +} + +/** Initialize connection to USB device on default address. + * + * @param dev_connection Device connection structure to be initialized. + * @param hc_connection Initialized connection to host controller. + * @return Error code. + */ +int usb_device_connection_initialize_on_default_address( + usb_device_connection_t *dev_connection, + usb_hc_connection_t *hc_connection) +{ + assert(dev_connection); + + if (hc_connection == NULL) { + return EBADMEM; + } + + return usb_device_connection_initialize(dev_connection, + hc_connection->hc_handle, (usb_address_t) 0); +} + +/** Prepare pipe for a long transfer. + * + * By a long transfer is mean transfer consisting of several + * requests to the HC. + * Calling such function is optional and it has positive effect of + * improved performance because IPC session is initiated only once. + * + * @param pipe Pipe over which the transfer will happen. + * @return Error code. + */ +void usb_pipe_start_long_transfer(usb_pipe_t *pipe) +{ + (void) pipe_add_ref(pipe, true); +} + +/** Terminate a long transfer on a pipe. + * + * @see usb_pipe_start_long_transfer + * + * @param pipe Pipe where to end the long transfer. + */ +void usb_pipe_end_long_transfer(usb_pipe_t *pipe) +{ + pipe_drop_ref(pipe); +} + +/** + * @} + */ Index: uspace/lib/usbdev/src/pipesinit.c =================================================================== --- uspace/lib/usbdev/src/pipesinit.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbdev/src/pipesinit.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,531 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbdev + * @{ + */ +/** @file + * Initialization of endpoint pipes. + * + */ +#include +#include +#include +#include +#include +#include +#include + +#define CTRL_PIPE_MIN_PACKET_SIZE 8 +#define DEV_DESCR_MAX_PACKET_SIZE_OFFSET 7 + + +#define NESTING(parentname, childname) \ + { \ + .child = USB_DESCTYPE_##childname, \ + .parent = USB_DESCTYPE_##parentname, \ + } +#define LAST_NESTING { -1, -1 } + +/** Nesting pairs of standard descriptors. */ +static usb_dp_descriptor_nesting_t descriptor_nesting[] = { + NESTING(CONFIGURATION, INTERFACE), + NESTING(INTERFACE, ENDPOINT), + NESTING(INTERFACE, HUB), + NESTING(INTERFACE, HID), + NESTING(HID, HID_REPORT), + LAST_NESTING +}; + +/** Tells whether given descriptor is of endpoint type. + * + * @param descriptor Descriptor in question. + * @return Whether the given descriptor is endpoint descriptor. + */ +static inline bool is_endpoint_descriptor(uint8_t *descriptor) +{ + return descriptor[1] == USB_DESCTYPE_ENDPOINT; +} + +/** Tells whether found endpoint corresponds to endpoint described by user. + * + * @param wanted Endpoint description as entered by driver author. + * @param found Endpoint description obtained from endpoint descriptor. + * @return Whether the @p found descriptor fits the @p wanted descriptor. + */ +static bool endpoint_fits_description(const usb_endpoint_description_t *wanted, + usb_endpoint_description_t *found) +{ +#define _SAME(fieldname) ((wanted->fieldname) == (found->fieldname)) + + if (!_SAME(direction)) { + return false; + } + + if (!_SAME(transfer_type)) { + return false; + } + + if ((wanted->interface_class >= 0) && !_SAME(interface_class)) { + return false; + } + + if ((wanted->interface_subclass >= 0) && !_SAME(interface_subclass)) { + return false; + } + + if ((wanted->interface_protocol >= 0) && !_SAME(interface_protocol)) { + return false; + } + +#undef _SAME + + return true; +} + +/** Find endpoint mapping for a found endpoint. + * + * @param mapping Endpoint mapping list. + * @param mapping_count Number of endpoint mappings in @p mapping. + * @param found_endpoint Description of found endpoint. + * @param interface_number Number of currently processed interface. + * @return Endpoint mapping corresponding to @p found_endpoint. + * @retval NULL No corresponding endpoint found. + */ +static usb_endpoint_mapping_t *find_endpoint_mapping( + usb_endpoint_mapping_t *mapping, size_t mapping_count, + usb_endpoint_description_t *found_endpoint, + int interface_number, int interface_setting) +{ + while (mapping_count > 0) { + bool interface_number_fits = (mapping->interface_no < 0) + || (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 + && interface_setting_fits + && endpoint_descriptions_fits) { + return mapping; + } + + mapping++; + mapping_count--; + } + return NULL; +} + +/** Process endpoint descriptor. + * + * @param mapping Endpoint mapping list. + * @param mapping_count Number of endpoint mappings in @p mapping. + * @param interface Interface descriptor under which belongs the @p endpoint. + * @param endpoint Endpoint descriptor. + * @param wire Connection backing the endpoint pipes. + * @return Error code. + */ +static int process_endpoint( + usb_endpoint_mapping_t *mapping, size_t mapping_count, + usb_standard_interface_descriptor_t *interface, + usb_standard_endpoint_descriptor_t *endpoint, + usb_device_connection_t *wire) +{ + usb_endpoint_description_t description; + + /* + * Get endpoint characteristics. + */ + + /* Actual endpoint number is in bits 0..3 */ + usb_endpoint_t ep_no = endpoint->endpoint_address & 0x0F; + + /* Endpoint direction is set by bit 7 */ + description.direction = (endpoint->endpoint_address & 128) + ? USB_DIRECTION_IN : USB_DIRECTION_OUT; + /* Transfer type is in bits 0..2 and the enum values corresponds 1:1 */ + description.transfer_type = endpoint->attributes & 3; + + /* + * Get interface characteristics. + */ + description.interface_class = interface->interface_class; + description.interface_subclass = interface->interface_subclass; + description.interface_protocol = interface->interface_protocol; + + /* + * Find the most fitting mapping and initialize the pipe. + */ + usb_endpoint_mapping_t *ep_mapping = find_endpoint_mapping(mapping, + mapping_count, &description, + interface->interface_number, interface->alternate_setting); + if (ep_mapping == NULL) { + return ENOENT; + } + + if (ep_mapping->pipe == NULL) { + return EBADMEM; + } + if (ep_mapping->present) { + return EEXISTS; + } + + int rc = usb_pipe_initialize(ep_mapping->pipe, wire, + ep_no, description.transfer_type, endpoint->max_packet_size, + description.direction); + if (rc != EOK) { + return rc; + } + + ep_mapping->present = true; + ep_mapping->descriptor = endpoint; + ep_mapping->interface = interface; + + return EOK; +} + +/** Process whole USB interface. + * + * @param mapping Endpoint mapping list. + * @param mapping_count Number of endpoint mappings in @p mapping. + * @param parser Descriptor parser. + * @param parser_data Descriptor parser data. + * @param interface_descriptor Interface descriptor. + * @return Error code. + */ +static int process_interface( + usb_endpoint_mapping_t *mapping, size_t mapping_count, + usb_dp_parser_t *parser, usb_dp_parser_data_t *parser_data, + uint8_t *interface_descriptor) +{ + uint8_t *descriptor = usb_dp_get_nested_descriptor(parser, + parser_data, interface_descriptor); + + if (descriptor == NULL) { + return ENOENT; + } + + do { + if (is_endpoint_descriptor(descriptor)) { + (void) process_endpoint(mapping, mapping_count, + (usb_standard_interface_descriptor_t *) + interface_descriptor, + (usb_standard_endpoint_descriptor_t *) + descriptor, + (usb_device_connection_t *) parser_data->arg); + } + + descriptor = usb_dp_get_sibling_descriptor(parser, parser_data, + interface_descriptor, descriptor); + } while (descriptor != NULL); + + return EOK; +} + +/** Initialize endpoint pipes from configuration descriptor. + * + * The mapping array is expected to conform to following rules: + * - @c pipe must point to already allocated structure with uninitialized pipe + * - @c description must point to prepared endpoint description + * - @c descriptor does not need to be initialized (will be overwritten) + * - @c interface does not need to be initialized (will be overwritten) + * - @c present does not need to be initialized (will be overwritten) + * + * After processing the configuration descriptor, the mapping is updated + * in the following fashion: + * - @c present will be set to @c true when the endpoint was found in the + * configuration + * - @c descriptor will point inside the configuration descriptor to endpoint + * corresponding to given description (or NULL for not found descriptor) + * - @c interface will point inside the configuration descriptor to interface + * descriptor the endpoint @c descriptor belongs to (or NULL for not found + * descriptor) + * - @c pipe will be initialized when found, otherwise left untouched + * - @c description will be untouched under all circumstances + * + * @param mapping Endpoint mapping list. + * @param mapping_count Number of endpoint mappings in @p mapping. + * @param configuration_descriptor Full configuration descriptor (is expected + * to be in USB endianness: i.e. as-is after being retrieved from + * the device). + * @param configuration_descriptor_size Size of @p configuration_descriptor + * in bytes. + * @param connection Connection backing the endpoint pipes. + * @return Error code. + */ +int usb_pipe_initialize_from_configuration( + usb_endpoint_mapping_t *mapping, size_t mapping_count, + uint8_t *configuration_descriptor, size_t configuration_descriptor_size, + usb_device_connection_t *connection) +{ + assert(connection); + + if (configuration_descriptor == NULL) { + return EBADMEM; + } + if (configuration_descriptor_size + < sizeof(usb_standard_configuration_descriptor_t)) { + return ERANGE; + } + + /* + * Go through the mapping and set all endpoints to not present. + */ + size_t i; + for (i = 0; i < mapping_count; i++) { + mapping[i].present = false; + mapping[i].descriptor = NULL; + mapping[i].interface = NULL; + } + + /* + * Prepare the descriptor parser. + */ + usb_dp_parser_t dp_parser = { + .nesting = descriptor_nesting + }; + usb_dp_parser_data_t dp_data = { + .data = configuration_descriptor, + .size = configuration_descriptor_size, + .arg = connection + }; + + /* + * Iterate through all interfaces. + */ + uint8_t *interface = usb_dp_get_nested_descriptor(&dp_parser, + &dp_data, configuration_descriptor); + if (interface == NULL) { + return ENOENT; + } + do { + (void) process_interface(mapping, mapping_count, + &dp_parser, &dp_data, + interface); + interface = usb_dp_get_sibling_descriptor(&dp_parser, &dp_data, + configuration_descriptor, interface); + } while (interface != NULL); + + return EOK; +} + +/** Initialize USB endpoint pipe. + * + * @param pipe Endpoint pipe to be initialized. + * @param connection Connection to the USB device backing this pipe (the wire). + * @param endpoint_no Endpoint number (in USB 1.1 in range 0 to 15). + * @param transfer_type Transfer type (e.g. interrupt or bulk). + * @param max_packet_size Maximum packet size in bytes. + * @param direction Endpoint direction (in/out). + * @return Error code. + */ +int usb_pipe_initialize(usb_pipe_t *pipe, + usb_device_connection_t *connection, usb_endpoint_t endpoint_no, + usb_transfer_type_t transfer_type, size_t max_packet_size, + usb_direction_t direction) +{ + assert(pipe); + assert(connection); + + fibril_mutex_initialize(&pipe->guard); + pipe->wire = connection; + pipe->hc_sess = NULL; + fibril_mutex_initialize(&pipe->hc_sess_mutex); + pipe->endpoint_no = endpoint_no; + pipe->transfer_type = transfer_type; + pipe->max_packet_size = max_packet_size; + pipe->direction = direction; + pipe->refcount = 0; + pipe->refcount_soft = 0; + pipe->auto_reset_halt = false; + + return EOK; +} + + +/** Initialize USB endpoint pipe as the default zero control pipe. + * + * @param pipe Endpoint pipe to be initialized. + * @param connection Connection to the USB device backing this pipe (the wire). + * @return Error code. + */ +int usb_pipe_initialize_default_control(usb_pipe_t *pipe, + usb_device_connection_t *connection) +{ + assert(pipe); + assert(connection); + + int rc = usb_pipe_initialize(pipe, connection, + 0, USB_TRANSFER_CONTROL, CTRL_PIPE_MIN_PACKET_SIZE, + USB_DIRECTION_BOTH); + + pipe->auto_reset_halt = true; + + return rc; +} + +/** Probe default control pipe for max packet size. + * + * The function tries to get the correct value of max packet size several + * time before giving up. + * + * The session on the pipe shall not be started. + * + * @param pipe Default control pipe. + * @return Error code. + */ +int usb_pipe_probe_default_control(usb_pipe_t *pipe) +{ + assert(pipe); + assert(DEV_DESCR_MAX_PACKET_SIZE_OFFSET < CTRL_PIPE_MIN_PACKET_SIZE); + + if ((pipe->direction != USB_DIRECTION_BOTH) || + (pipe->transfer_type != USB_TRANSFER_CONTROL) || + (pipe->endpoint_no != 0)) { + return EINVAL; + } + +#define TRY_LOOP(attempt_var) \ + for (attempt_var = 0; attempt_var < 3; attempt_var++) + + size_t failed_attempts; + int rc; + + usb_pipe_start_long_transfer(pipe); + + uint8_t dev_descr_start[CTRL_PIPE_MIN_PACKET_SIZE]; + size_t transferred_size; + TRY_LOOP(failed_attempts) { + rc = usb_request_get_descriptor(pipe, USB_REQUEST_TYPE_STANDARD, + USB_REQUEST_RECIPIENT_DEVICE, USB_DESCTYPE_DEVICE, + 0, 0, dev_descr_start, CTRL_PIPE_MIN_PACKET_SIZE, + &transferred_size); + if (rc == EOK) { + if (transferred_size != CTRL_PIPE_MIN_PACKET_SIZE) { + rc = ELIMIT; + continue; + } + break; + } + } + usb_pipe_end_long_transfer(pipe); + if (rc != EOK) { + return rc; + } + + pipe->max_packet_size + = dev_descr_start[DEV_DESCR_MAX_PACKET_SIZE_OFFSET]; + + return EOK; +} + +/** Register endpoint with the host controller. + * + * @param pipe Pipe to be registered. + * @param interval Polling interval. + * @param hc_connection Connection to the host controller (must be opened). + * @return Error code. + */ +int usb_pipe_register(usb_pipe_t *pipe, + unsigned int interval, + usb_hc_connection_t *hc_connection) +{ + return usb_pipe_register_with_speed(pipe, USB_SPEED_MAX + 1, + interval, hc_connection); +} + +/** Register endpoint with a speed at the host controller. + * + * You will rarely need to use this function because it is needed only + * if the registered endpoint is of address 0 and there is no other way + * to tell speed of the device at address 0. + * + * @param pipe Pipe to be registered. + * @param speed Speed of the device + * (invalid speed means use previously specified one). + * @param interval Polling interval. + * @param hc_connection Connection to the host controller (must be opened). + * @return Error code. + */ +int usb_pipe_register_with_speed(usb_pipe_t *pipe, usb_speed_t speed, + unsigned int interval, + usb_hc_connection_t *hc_connection) +{ + assert(pipe); + assert(hc_connection); + + if (!usb_hc_connection_is_opened(hc_connection)) + return EBADF; + +#define _PACK2(high, low) (((high) << 16) + (low)) +#define _PACK3(high, middle, low) (((((high) << 8) + (middle)) << 8) + (low)) + + async_exch_t *exch = async_exchange_begin(hc_connection->hc_sess); + int rc = async_req_4_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE), + IPC_M_USBHC_REGISTER_ENDPOINT, + _PACK2(pipe->wire->address, pipe->endpoint_no), + _PACK3(speed, pipe->transfer_type, pipe->direction), + _PACK2(pipe->max_packet_size, interval)); + async_exchange_end(exch); + +#undef _PACK2 +#undef _PACK3 + + return rc; +} + +/** Revert endpoint registration with the host controller. + * + * @param pipe Pipe to be unregistered. + * @param hc_connection Connection to the host controller (must be opened). + * @return Error code. + */ +int usb_pipe_unregister(usb_pipe_t *pipe, + usb_hc_connection_t *hc_connection) +{ + assert(pipe); + assert(hc_connection); + + if (!usb_hc_connection_is_opened(hc_connection)) + return EBADF; + + async_exch_t *exch = async_exchange_begin(hc_connection->hc_sess); + int rc = async_req_4_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE), + IPC_M_USBHC_UNREGISTER_ENDPOINT, + pipe->wire->address, pipe->endpoint_no, pipe->direction); + async_exchange_end(exch); + + return rc; +} + +/** + * @} + */ Index: uspace/lib/usbdev/src/pipesio.c =================================================================== --- uspace/lib/usbdev/src/pipesio.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbdev/src/pipesio.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,610 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbdev + * @{ + */ +/** @file + * Input and output functions (reads and writes) on endpoint pipes. + * + * Note on synchronousness of the operations: there is ABSOLUTELY NO + * guarantee that a call to particular function will not trigger a fibril + * switch. + * + * Note about the implementation: the transfer requests are always divided + * into two functions. + * The outer one does checking of input parameters (e.g. that session was + * already started, buffers are not NULL etc), while the inner one + * (with _no_checks suffix) does the actual IPC (it checks for IPC errors, + * obviously). + */ + +#include +#include +#include +#include +#include +#include +#include +#include "pipepriv.h" + +/** Request an in transfer, no checking of input parameters. + * + * @param[in] pipe Pipe used for the transfer. + * @param[out] buffer Buffer where to store the data. + * @param[in] size Size of the buffer (in bytes). + * @param[out] size_transfered Number of bytes that were actually transfered. + * @return Error code. + */ +static int usb_pipe_read_no_checks(usb_pipe_t *pipe, + void *buffer, size_t size, size_t *size_transfered) +{ + /* + * Get corresponding IPC method. + * In future, replace with static array of mappings + * transfer type -> method. + */ + usbhc_iface_funcs_t ipc_method; + switch (pipe->transfer_type) { + case USB_TRANSFER_INTERRUPT: + ipc_method = IPC_M_USBHC_INTERRUPT_IN; + break; + case USB_TRANSFER_BULK: + ipc_method = IPC_M_USBHC_BULK_IN; + break; + default: + return ENOTSUP; + } + + /* Ensure serialization over the phone. */ + pipe_start_transaction(pipe); + async_exch_t *exch = async_exchange_begin(pipe->hc_sess); + + /* + * Make call identifying target USB device and type of transfer. + */ + aid_t opening_request = async_send_3(exch, DEV_IFACE_ID(USBHC_DEV_IFACE), + ipc_method, pipe->wire->address, pipe->endpoint_no, NULL); + + if (opening_request == 0) { + async_exchange_end(exch); + pipe_end_transaction(pipe); + return ENOMEM; + } + + /* + * Retrieve the data. + */ + ipc_call_t data_request_call; + aid_t data_request = async_data_read(exch, buffer, size, + &data_request_call); + + /* + * Since now on, someone else might access the backing phone + * without breaking the transfer IPC protocol. + */ + async_exchange_end(exch); + pipe_end_transaction(pipe); + + if (data_request == 0) { + /* + * FIXME: + * How to let the other side know that we want to abort? + */ + async_wait_for(opening_request, NULL); + return ENOMEM; + } + + /* + * Wait for the answer. + */ + sysarg_t data_request_rc; + sysarg_t opening_request_rc; + async_wait_for(data_request, &data_request_rc); + async_wait_for(opening_request, &opening_request_rc); + + if (data_request_rc != EOK) { + /* Prefer the return code of the opening request. */ + if (opening_request_rc != EOK) { + return (int) opening_request_rc; + } else { + return (int) data_request_rc; + } + } + if (opening_request_rc != EOK) { + return (int) opening_request_rc; + } + + *size_transfered = IPC_GET_ARG2(data_request_call); + + return EOK; +} + + +/** Request a read (in) transfer on an endpoint pipe. + * + * @param[in] pipe Pipe used for the transfer. + * @param[out] buffer Buffer where to store the data. + * @param[in] size Size of the buffer (in bytes). + * @param[out] size_transfered Number of bytes that were actually transfered. + * @return Error code. + */ +int usb_pipe_read(usb_pipe_t *pipe, + void *buffer, size_t size, size_t *size_transfered) +{ + assert(pipe); + + if (buffer == NULL) { + return EINVAL; + } + + if (size == 0) { + return EINVAL; + } + + if (pipe->direction != USB_DIRECTION_IN) { + return EBADF; + } + + if (pipe->transfer_type == USB_TRANSFER_CONTROL) { + return EBADF; + } + + int rc; + rc = pipe_add_ref(pipe, false); + if (rc != EOK) { + return rc; + } + + + size_t act_size = 0; + + rc = usb_pipe_read_no_checks(pipe, buffer, size, &act_size); + + pipe_drop_ref(pipe); + + if (rc != EOK) { + return rc; + } + + if (size_transfered != NULL) { + *size_transfered = act_size; + } + + return EOK; +} + + + + +/** Request an out transfer, no checking of input parameters. + * + * @param[in] pipe Pipe used for the transfer. + * @param[in] buffer Buffer with data to transfer. + * @param[in] size Size of the buffer (in bytes). + * @return Error code. + */ +static int usb_pipe_write_no_check(usb_pipe_t *pipe, + void *buffer, size_t size) +{ + /* + * Get corresponding IPC method. + * In future, replace with static array of mappings + * transfer type -> method. + */ + usbhc_iface_funcs_t ipc_method; + switch (pipe->transfer_type) { + case USB_TRANSFER_INTERRUPT: + ipc_method = IPC_M_USBHC_INTERRUPT_OUT; + break; + case USB_TRANSFER_BULK: + ipc_method = IPC_M_USBHC_BULK_OUT; + break; + default: + return ENOTSUP; + } + + /* Ensure serialization over the phone. */ + pipe_start_transaction(pipe); + async_exch_t *exch = async_exchange_begin(pipe->hc_sess); + + /* + * Make call identifying target USB device and type of transfer. + */ + aid_t opening_request = async_send_3(exch, DEV_IFACE_ID(USBHC_DEV_IFACE), + ipc_method, pipe->wire->address, pipe->endpoint_no, NULL); + + if (opening_request == 0) { + async_exchange_end(exch); + pipe_end_transaction(pipe); + return ENOMEM; + } + + /* + * Send the data. + */ + int rc = async_data_write_start(exch, buffer, size); + + /* + * Since now on, someone else might access the backing phone + * without breaking the transfer IPC protocol. + */ + async_exchange_end(exch); + pipe_end_transaction(pipe); + + if (rc != EOK) { + async_wait_for(opening_request, NULL); + return rc; + } + + /* + * Wait for the answer. + */ + sysarg_t opening_request_rc; + async_wait_for(opening_request, &opening_request_rc); + + return (int) opening_request_rc; +} + +/** Request a write (out) transfer on an endpoint pipe. + * + * @param[in] pipe Pipe used for the transfer. + * @param[in] buffer Buffer with data to transfer. + * @param[in] size Size of the buffer (in bytes). + * @return Error code. + */ +int usb_pipe_write(usb_pipe_t *pipe, + void *buffer, size_t size) +{ + assert(pipe); + + if (buffer == NULL) { + return EINVAL; + } + + if (size == 0) { + return EINVAL; + } + + if (pipe->direction != USB_DIRECTION_OUT) { + return EBADF; + } + + if (pipe->transfer_type == USB_TRANSFER_CONTROL) { + return EBADF; + } + + int rc; + + rc = pipe_add_ref(pipe, false); + if (rc != EOK) { + return rc; + } + + rc = usb_pipe_write_no_check(pipe, buffer, size); + + pipe_drop_ref(pipe); + + return rc; +} + +/** Try to clear endpoint halt of default control pipe. + * + * @param pipe Pipe for control endpoint zero. + */ +static void clear_self_endpoint_halt(usb_pipe_t *pipe) +{ + assert(pipe != NULL); + + if (!pipe->auto_reset_halt || (pipe->endpoint_no != 0)) { + return; + } + + + /* Prevent indefinite recursion. */ + pipe->auto_reset_halt = false; + usb_request_clear_endpoint_halt(pipe, 0); + pipe->auto_reset_halt = true; +} + + +/** Request a control read transfer, no checking of input parameters. + * + * @param[in] pipe Pipe used for the transfer. + * @param[in] setup_buffer Buffer with the setup packet. + * @param[in] setup_buffer_size Size of the setup packet (in bytes). + * @param[out] data_buffer Buffer for incoming data. + * @param[in] data_buffer_size Size of the buffer for incoming data (in bytes). + * @param[out] data_transfered_size Number of bytes that were actually + * transfered during the DATA stage. + * @return Error code. + */ +static int usb_pipe_control_read_no_check(usb_pipe_t *pipe, + void *setup_buffer, size_t setup_buffer_size, + void *data_buffer, size_t data_buffer_size, size_t *data_transfered_size) +{ + /* Ensure serialization over the phone. */ + pipe_start_transaction(pipe); + + /* + * Make call identifying target USB device and control transfer type. + */ + async_exch_t *exch = async_exchange_begin(pipe->hc_sess); + aid_t opening_request = async_send_3(exch, DEV_IFACE_ID(USBHC_DEV_IFACE), + IPC_M_USBHC_CONTROL_READ, pipe->wire->address, pipe->endpoint_no, + NULL); + + if (opening_request == 0) { + async_exchange_end(exch); + return ENOMEM; + } + + /* + * Send the setup packet. + */ + int rc = async_data_write_start(exch, setup_buffer, setup_buffer_size); + if (rc != EOK) { + async_exchange_end(exch); + pipe_end_transaction(pipe); + async_wait_for(opening_request, NULL); + return rc; + } + + /* + * Retrieve the data. + */ + ipc_call_t data_request_call; + aid_t data_request = async_data_read(exch, data_buffer, + data_buffer_size, &data_request_call); + + /* + * Since now on, someone else might access the backing phone + * without breaking the transfer IPC protocol. + */ + async_exchange_end(exch); + pipe_end_transaction(pipe); + + if (data_request == 0) { + async_wait_for(opening_request, NULL); + return ENOMEM; + } + + /* + * Wait for the answer. + */ + sysarg_t data_request_rc; + sysarg_t opening_request_rc; + async_wait_for(data_request, &data_request_rc); + async_wait_for(opening_request, &opening_request_rc); + + if (data_request_rc != EOK) { + /* Prefer the return code of the opening request. */ + if (opening_request_rc != EOK) { + return (int) opening_request_rc; + } else { + return (int) data_request_rc; + } + } + if (opening_request_rc != EOK) { + return (int) opening_request_rc; + } + + *data_transfered_size = IPC_GET_ARG2(data_request_call); + + return EOK; +} + +/** Request a control read transfer on an endpoint pipe. + * + * This function encapsulates all three stages of a control transfer. + * + * @param[in] pipe Pipe used for the transfer. + * @param[in] setup_buffer Buffer with the setup packet. + * @param[in] setup_buffer_size Size of the setup packet (in bytes). + * @param[out] data_buffer Buffer for incoming data. + * @param[in] data_buffer_size Size of the buffer for incoming data (in bytes). + * @param[out] data_transfered_size Number of bytes that were actually + * transfered during the DATA stage. + * @return Error code. + */ +int usb_pipe_control_read(usb_pipe_t *pipe, + void *setup_buffer, size_t setup_buffer_size, + void *data_buffer, size_t data_buffer_size, size_t *data_transfered_size) +{ + assert(pipe); + + if ((setup_buffer == NULL) || (setup_buffer_size == 0)) { + return EINVAL; + } + + if ((data_buffer == NULL) || (data_buffer_size == 0)) { + return EINVAL; + } + + if ((pipe->direction != USB_DIRECTION_BOTH) + || (pipe->transfer_type != USB_TRANSFER_CONTROL)) { + return EBADF; + } + + int rc; + + rc = pipe_add_ref(pipe, false); + if (rc != EOK) { + return rc; + } + + size_t act_size = 0; + rc = usb_pipe_control_read_no_check(pipe, + setup_buffer, setup_buffer_size, + data_buffer, data_buffer_size, &act_size); + + if (rc == ESTALL) { + clear_self_endpoint_halt(pipe); + } + + pipe_drop_ref(pipe); + + if (rc != EOK) { + return rc; + } + + if (data_transfered_size != NULL) { + *data_transfered_size = act_size; + } + + return EOK; +} + + +/** Request a control write transfer, no checking of input parameters. + * + * @param[in] pipe Pipe used for the transfer. + * @param[in] setup_buffer Buffer with the setup packet. + * @param[in] setup_buffer_size Size of the setup packet (in bytes). + * @param[in] data_buffer Buffer with data to be sent. + * @param[in] data_buffer_size Size of the buffer with outgoing data (in bytes). + * @return Error code. + */ +static int usb_pipe_control_write_no_check(usb_pipe_t *pipe, + void *setup_buffer, size_t setup_buffer_size, + void *data_buffer, size_t data_buffer_size) +{ + /* Ensure serialization over the phone. */ + pipe_start_transaction(pipe); + + /* + * Make call identifying target USB device and control transfer type. + */ + async_exch_t *exch = async_exchange_begin(pipe->hc_sess); + aid_t opening_request = async_send_4(exch, DEV_IFACE_ID(USBHC_DEV_IFACE), + IPC_M_USBHC_CONTROL_WRITE, pipe->wire->address, pipe->endpoint_no, + data_buffer_size, NULL); + + if (opening_request == 0) { + async_exchange_end(exch); + pipe_end_transaction(pipe); + return ENOMEM; + } + + /* + * Send the setup packet. + */ + int rc = async_data_write_start(exch, setup_buffer, setup_buffer_size); + if (rc != EOK) { + async_exchange_end(exch); + pipe_end_transaction(pipe); + async_wait_for(opening_request, NULL); + return rc; + } + + /* + * Send the data (if any). + */ + if (data_buffer_size > 0) { + rc = async_data_write_start(exch, data_buffer, data_buffer_size); + + /* All data sent, pipe can be released. */ + async_exchange_end(exch); + pipe_end_transaction(pipe); + + if (rc != EOK) { + async_wait_for(opening_request, NULL); + return rc; + } + } else { + /* No data to send, we can release the pipe for others. */ + async_exchange_end(exch); + pipe_end_transaction(pipe); + } + + /* + * Wait for the answer. + */ + sysarg_t opening_request_rc; + async_wait_for(opening_request, &opening_request_rc); + + return (int) opening_request_rc; +} + +/** Request a control write transfer on an endpoint pipe. + * + * This function encapsulates all three stages of a control transfer. + * + * @param[in] pipe Pipe used for the transfer. + * @param[in] setup_buffer Buffer with the setup packet. + * @param[in] setup_buffer_size Size of the setup packet (in bytes). + * @param[in] data_buffer Buffer with data to be sent. + * @param[in] data_buffer_size Size of the buffer with outgoing data (in bytes). + * @return Error code. + */ +int usb_pipe_control_write(usb_pipe_t *pipe, + void *setup_buffer, size_t setup_buffer_size, + void *data_buffer, size_t data_buffer_size) +{ + assert(pipe); + + if ((setup_buffer == NULL) || (setup_buffer_size == 0)) { + return EINVAL; + } + + if ((data_buffer == NULL) && (data_buffer_size > 0)) { + return EINVAL; + } + + if ((data_buffer != NULL) && (data_buffer_size == 0)) { + return EINVAL; + } + + if ((pipe->direction != USB_DIRECTION_BOTH) + || (pipe->transfer_type != USB_TRANSFER_CONTROL)) { + return EBADF; + } + + int rc; + + rc = pipe_add_ref(pipe, false); + if (rc != EOK) { + return rc; + } + + rc = usb_pipe_control_write_no_check(pipe, + setup_buffer, setup_buffer_size, data_buffer, data_buffer_size); + + if (rc == ESTALL) { + clear_self_endpoint_halt(pipe); + } + + pipe_drop_ref(pipe); + + return rc; +} + + +/** + * @} + */ Index: uspace/lib/usbdev/src/recognise.c =================================================================== --- uspace/lib/usbdev/src/recognise.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbdev/src/recognise.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,442 @@ +/* + * Copyright (c) 2010 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbdev + * @{ + */ +/** @file + * Functions for recognition of attached devices. + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/** Index to append after device name for uniqueness. */ +static size_t device_name_index = 0; +/** Mutex guard for device_name_index. */ +static FIBRIL_MUTEX_INITIALIZE(device_name_index_mutex); + +/** DDF operations of child devices. */ +ddf_dev_ops_t child_ops = { + .interfaces[USB_DEV_IFACE] = &usb_iface_hub_child_impl +}; + +/** Get integer part from BCD coded number. */ +#define BCD_INT(a) (((unsigned int)(a)) / 256) +/** Get fraction part from BCD coded number (as an integer, no less). */ +#define BCD_FRAC(a) (((unsigned int)(a)) % 256) + +/** Format for BCD coded number to be used in printf. */ +#define BCD_FMT "%x.%x" +/** Arguments to printf for BCD coded number. */ +#define BCD_ARGS(a) BCD_INT((a)), BCD_FRAC((a)) + +/* FIXME: make this dynamic */ +#define MATCH_STRING_MAX 256 + +/** Add formatted match id. + * + * @param matches List of match ids where to add to. + * @param score Score of the match. + * @param format Printf-like format + * @return Error code. + */ +static int usb_add_match_id(match_id_list_t *matches, int score, + const char *format, ...) +{ + char *match_str = NULL; + match_id_t *match_id = NULL; + int rc; + + match_str = malloc(MATCH_STRING_MAX + 1); + if (match_str == NULL) { + rc = ENOMEM; + goto failure; + } + + /* + * FIXME: replace with dynamic allocation of exact size + */ + va_list args; + va_start(args, format ); + vsnprintf(match_str, MATCH_STRING_MAX, format, args); + match_str[MATCH_STRING_MAX] = 0; + va_end(args); + + match_id = create_match_id(); + if (match_id == NULL) { + rc = ENOMEM; + goto failure; + } + + match_id->id = match_str; + match_id->score = score; + add_match_id(matches, match_id); + + return EOK; + +failure: + if (match_str != NULL) { + free(match_str); + } + if (match_id != NULL) { + match_id->id = NULL; + delete_match_id(match_id); + } + + return rc; +} + +/** Add match id to list or return with error code. + * + * @param match_ids List of match ids. + * @param score Match id score. + * @param format Format of the matching string + * @param ... Arguments for the format. + */ +#define ADD_MATCHID_OR_RETURN(match_ids, score, format, ...) \ + do { \ + int __rc = usb_add_match_id((match_ids), (score), \ + format, ##__VA_ARGS__); \ + if (__rc != EOK) { \ + return __rc; \ + } \ + } while (0) + +/** Create device match ids based on its interface. + * + * @param[in] desc_device Device descriptor. + * @param[in] desc_interface Interface descriptor. + * @param[out] matches Initialized list of match ids. + * @return Error code (the two mentioned are not the only ones). + * @retval EINVAL Invalid input parameters (expects non NULL pointers). + * @retval ENOENT Device class is not "use interface". + */ +int usb_device_create_match_ids_from_interface( + const usb_standard_device_descriptor_t *desc_device, + const usb_standard_interface_descriptor_t *desc_interface, + match_id_list_t *matches) +{ + if (desc_interface == NULL) { + return EINVAL; + } + if (matches == NULL) { + return EINVAL; + } + + if (desc_interface->interface_class == USB_CLASS_USE_INTERFACE) { + return ENOENT; + } + + const char *classname = usb_str_class(desc_interface->interface_class); + assert(classname != NULL); + +#define IFACE_PROTOCOL_FMT "interface&class=%s&subclass=0x%02x&protocol=0x%02x" +#define IFACE_PROTOCOL_ARGS classname, desc_interface->interface_subclass, \ + desc_interface->interface_protocol + +#define IFACE_SUBCLASS_FMT "interface&class=%s&subclass=0x%02x" +#define IFACE_SUBCLASS_ARGS classname, desc_interface->interface_subclass + +#define IFACE_CLASS_FMT "interface&class=%s" +#define IFACE_CLASS_ARGS classname + +#define VENDOR_RELEASE_FMT "vendor=0x%04x&product=0x%04x&release=" BCD_FMT +#define VENDOR_RELEASE_ARGS desc_device->vendor_id, desc_device->product_id, \ + BCD_ARGS(desc_device->device_version) + +#define VENDOR_PRODUCT_FMT "vendor=0x%04x&product=0x%04x" +#define VENDOR_PRODUCT_ARGS desc_device->vendor_id, desc_device->product_id + +#define VENDOR_ONLY_FMT "vendor=0x%04x" +#define VENDOR_ONLY_ARGS desc_device->vendor_id + + /* + * If the vendor is specified, create match ids with vendor with + * higher score. + * Then the same ones without the vendor part. + */ + if ((desc_device != NULL) && (desc_device->vendor_id != 0)) { + /* First, interface matches with device release number. */ + ADD_MATCHID_OR_RETURN(matches, 250, + "usb&" VENDOR_RELEASE_FMT "&" IFACE_PROTOCOL_FMT, + VENDOR_RELEASE_ARGS, IFACE_PROTOCOL_ARGS); + ADD_MATCHID_OR_RETURN(matches, 240, + "usb&" VENDOR_RELEASE_FMT "&" IFACE_SUBCLASS_FMT, + VENDOR_RELEASE_ARGS, IFACE_SUBCLASS_ARGS); + ADD_MATCHID_OR_RETURN(matches, 230, + "usb&" VENDOR_RELEASE_FMT "&" IFACE_CLASS_FMT, + VENDOR_RELEASE_ARGS, IFACE_CLASS_ARGS); + + /* Next, interface matches without release number. */ + ADD_MATCHID_OR_RETURN(matches, 220, + "usb&" VENDOR_PRODUCT_FMT "&" IFACE_PROTOCOL_FMT, + VENDOR_PRODUCT_ARGS, IFACE_PROTOCOL_ARGS); + ADD_MATCHID_OR_RETURN(matches, 210, + "usb&" VENDOR_PRODUCT_FMT "&" IFACE_SUBCLASS_FMT, + VENDOR_PRODUCT_ARGS, IFACE_SUBCLASS_ARGS); + ADD_MATCHID_OR_RETURN(matches, 200, + "usb&" VENDOR_PRODUCT_FMT "&" IFACE_CLASS_FMT, + VENDOR_PRODUCT_ARGS, IFACE_CLASS_ARGS); + + /* Finally, interface matches with only vendor. */ + ADD_MATCHID_OR_RETURN(matches, 190, + "usb&" VENDOR_ONLY_FMT "&" IFACE_PROTOCOL_FMT, + VENDOR_ONLY_ARGS, IFACE_PROTOCOL_ARGS); + ADD_MATCHID_OR_RETURN(matches, 180, + "usb&" VENDOR_ONLY_FMT "&" IFACE_SUBCLASS_FMT, + VENDOR_ONLY_ARGS, IFACE_SUBCLASS_ARGS); + ADD_MATCHID_OR_RETURN(matches, 170, + "usb&" VENDOR_ONLY_FMT "&" IFACE_CLASS_FMT, + VENDOR_ONLY_ARGS, IFACE_CLASS_ARGS); + } + + /* Now, the same but without any vendor specification. */ + ADD_MATCHID_OR_RETURN(matches, 160, + "usb&" IFACE_PROTOCOL_FMT, + IFACE_PROTOCOL_ARGS); + ADD_MATCHID_OR_RETURN(matches, 150, + "usb&" IFACE_SUBCLASS_FMT, + IFACE_SUBCLASS_ARGS); + ADD_MATCHID_OR_RETURN(matches, 140, + "usb&" IFACE_CLASS_FMT, + IFACE_CLASS_ARGS); + +#undef IFACE_PROTOCOL_FMT +#undef IFACE_PROTOCOL_ARGS +#undef IFACE_SUBCLASS_FMT +#undef IFACE_SUBCLASS_ARGS +#undef IFACE_CLASS_FMT +#undef IFACE_CLASS_ARGS +#undef VENDOR_RELEASE_FMT +#undef VENDOR_RELEASE_ARGS +#undef VENDOR_PRODUCT_FMT +#undef VENDOR_PRODUCT_ARGS +#undef VENDOR_ONLY_FMT +#undef VENDOR_ONLY_ARGS + + /* As a last resort, try fallback driver. */ + ADD_MATCHID_OR_RETURN(matches, 10, "usb&interface&fallback"); + + return EOK; +} + +/** Create DDF match ids from USB device descriptor. + * + * @param matches List of match ids to extend. + * @param device_descriptor Device descriptor returned by given device. + * @return Error code. + */ +int usb_device_create_match_ids_from_device_descriptor( + const usb_standard_device_descriptor_t *device_descriptor, + match_id_list_t *matches) +{ + /* + * Unless the vendor id is 0, the pair idVendor-idProduct + * quite uniquely describes the device. + */ + if (device_descriptor->vendor_id != 0) { + /* First, with release number. */ + ADD_MATCHID_OR_RETURN(matches, 100, + "usb&vendor=0x%04x&product=0x%04x&release=" BCD_FMT, + (int) device_descriptor->vendor_id, + (int) device_descriptor->product_id, + BCD_ARGS(device_descriptor->device_version)); + + /* Next, without release number. */ + ADD_MATCHID_OR_RETURN(matches, 90, + "usb&vendor=0x%04x&product=0x%04x", + (int) device_descriptor->vendor_id, + (int) device_descriptor->product_id); + } + + /* + * If the device class points to interface we skip adding + * class directly but we add a multi interface device. + */ + if (device_descriptor->device_class != USB_CLASS_USE_INTERFACE) { + ADD_MATCHID_OR_RETURN(matches, 50, "usb&class=%s", + usb_str_class(device_descriptor->device_class)); + } else { + ADD_MATCHID_OR_RETURN(matches, 50, "usb&mid"); + } + + /* As a last resort, try fallback driver. */ + ADD_MATCHID_OR_RETURN(matches, 10, "usb&fallback"); + + return EOK; +} + + +/** Create match ids describing attached device. + * + * @warning The list of match ids @p matches may change even when + * function exits with error. + * + * @param ctrl_pipe Control pipe to given device (session must be already + * started). + * @param matches Initialized list of match ids. + * @return Error code. + */ +int usb_device_create_match_ids(usb_pipe_t *ctrl_pipe, + match_id_list_t *matches) +{ + int rc; + /* + * Retrieve device descriptor and add matches from it. + */ + usb_standard_device_descriptor_t device_descriptor; + + rc = usb_request_get_device_descriptor(ctrl_pipe, &device_descriptor); + if (rc != EOK) { + return rc; + } + + rc = usb_device_create_match_ids_from_device_descriptor( + &device_descriptor, matches); + if (rc != EOK) { + return rc; + } + + return EOK; +} + +/** Probe for device kind and register it in devman. + * + * @param[in] address Address of the (unknown) attached device. + * @param[in] hc_handle Handle of the host controller. + * @param[in] parent Parent device. + * @param[out] child_handle Handle of the child device. + * @param[in] dev_ops Child device ops. + * @param[in] dev_data Arbitrary pointer to be stored in the child + * as @c driver_data. + * @param[out] child_fun Storage where pointer to allocated child function + * will be written. + * @return Error code. + */ +int usb_device_register_child_in_devman(usb_address_t address, + devman_handle_t hc_handle, + ddf_dev_t *parent, devman_handle_t *child_handle, + ddf_dev_ops_t *dev_ops, void *dev_data, ddf_fun_t **child_fun) +{ + size_t this_device_name_index; + + fibril_mutex_lock(&device_name_index_mutex); + this_device_name_index = device_name_index; + device_name_index++; + fibril_mutex_unlock(&device_name_index_mutex); + + ddf_fun_t *child = NULL; + char *child_name = NULL; + int rc; + usb_device_connection_t dev_connection; + usb_pipe_t ctrl_pipe; + + rc = usb_device_connection_initialize(&dev_connection, hc_handle, address); + if (rc != EOK) { + goto failure; + } + + rc = usb_pipe_initialize_default_control(&ctrl_pipe, + &dev_connection); + if (rc != EOK) { + goto failure; + } + rc = usb_pipe_probe_default_control(&ctrl_pipe); + if (rc != EOK) { + goto failure; + } + + /* + * TODO: Once the device driver framework support persistent + * naming etc., something more descriptive could be created. + */ + rc = asprintf(&child_name, "usb%02zu_a%d", + this_device_name_index, address); + if (rc < 0) { + goto failure; + } + + child = ddf_fun_create(parent, fun_inner, child_name); + if (child == NULL) { + rc = ENOMEM; + goto failure; + } + + if (dev_ops != NULL) { + child->ops = dev_ops; + } else { + child->ops = &child_ops; + } + + child->driver_data = dev_data; + + rc = usb_device_create_match_ids(&ctrl_pipe, &child->match_ids); + if (rc != EOK) { + goto failure; + } + + rc = ddf_fun_bind(child); + if (rc != EOK) { + goto failure; + } + + if (child_handle != NULL) { + *child_handle = child->handle; + } + + if (child_fun != NULL) { + *child_fun = child; + } + + return EOK; + +failure: + if (child != NULL) { + child->name = NULL; + /* This takes care of match_id deallocation as well. */ + ddf_fun_destroy(child); + } + if (child_name != NULL) { + free(child_name); + } + + return rc; +} + + +/** + * @} + */ Index: uspace/lib/usbdev/src/request.c =================================================================== --- uspace/lib/usbdev/src/request.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbdev/src/request.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,930 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbdev + * @{ + */ +/** @file + * Standard USB requests (implementation). + */ +#include +#include +#include +#include + +#define MAX_DATA_LENGTH ((size_t)(0xFFFF)) + +/** Generic wrapper for SET requests using standard control request format. + * + * @see usb_pipe_control_write + * + * @param pipe Pipe used for the communication. + * @param request_type Request type (standard/class/vendor). + * @param recipient Request recipient (e.g. device or endpoint). + * @param request Actual request (e.g. GET_DESCRIPTOR). + * @param value Value of @c wValue field of setup packet + * (must be in USB endianness). + * @param index Value of @c wIndex field of setup packet + * (must be in USB endianness). + * @param data Data to be sent during DATA stage + * (expected to be in USB endianness). + * @param data_size Size of the @p data buffer (in native endianness). + * @return Error code. + * @retval EBADMEM @p pipe is NULL. + * @retval EBADMEM @p data is NULL and @p data_size is not zero. + * @retval ERANGE Data buffer too large. + */ +int usb_control_request_set(usb_pipe_t *pipe, + usb_request_type_t request_type, usb_request_recipient_t recipient, + uint8_t request, + uint16_t value, uint16_t index, + void *data, size_t data_size) +{ + if (pipe == NULL) { + return EBADMEM; + } + + if (data_size > MAX_DATA_LENGTH) { + return ERANGE; + } + + if ((data_size > 0) && (data == NULL)) { + return EBADMEM; + } + + /* + * TODO: check that @p request_type and @p recipient are + * within ranges. + */ + + usb_device_request_setup_packet_t setup_packet; + setup_packet.request_type = (request_type << 5) | recipient; + setup_packet.request = request; + setup_packet.value = value; + setup_packet.index = index; + setup_packet.length = (uint16_t) data_size; + + int rc = usb_pipe_control_write(pipe, + &setup_packet, sizeof(setup_packet), + data, data_size); + + return rc; +} + + /** Generic wrapper for GET requests using standard control request format. + * + * @see usb_pipe_control_read + * + * @param pipe Pipe used for the communication. + * @param request_type Request type (standard/class/vendor). + * @param recipient Request recipient (e.g. device or endpoint). + * @param request Actual request (e.g. GET_DESCRIPTOR). + * @param value Value of @c wValue field of setup packet + * (must be in USB endianness). + * @param index Value of @c wIndex field of setup packet + * (must be in USB endianness). + * @param data Buffer where to store data accepted during the DATA stage. + * (they will come in USB endianness). + * @param data_size Size of the @p data buffer + * (in native endianness). + * @param actual_data_size Actual size of transfered data + * (in native endianness). + * @return Error code. + * @retval EBADMEM @p pipe is NULL. + * @retval EBADMEM @p data is NULL and @p data_size is not zero. + * @retval ERANGE Data buffer too large. + */ +int usb_control_request_get(usb_pipe_t *pipe, + usb_request_type_t request_type, usb_request_recipient_t recipient, + uint8_t request, + uint16_t value, uint16_t index, + void *data, size_t data_size, size_t *actual_data_size) +{ + if (pipe == NULL) { + return EBADMEM; + } + + if (data_size > MAX_DATA_LENGTH) { + return ERANGE; + } + + if ((data_size > 0) && (data == NULL)) { + return EBADMEM; + } + + /* + * TODO: check that @p request_type and @p recipient are + * within ranges. + */ + + usb_device_request_setup_packet_t setup_packet; + setup_packet.request_type = 128 | (request_type << 5) | recipient; + setup_packet.request = request; + setup_packet.value = value; + setup_packet.index = index; + setup_packet.length = (uint16_t) data_size; + + int rc = usb_pipe_control_read(pipe, + &setup_packet, sizeof(setup_packet), + data, data_size, actual_data_size); + + return rc; +} + +/** Retrieve status of a USB device. + * + * @param[in] pipe Control endpoint pipe (session must be already started). + * @param[in] index Recipient index (in native endianness). + * @param[in] recipient Recipient of the GET_STATUS request. + * @param[out] status Recipient status (in native endianness). + * @return Error code. + */ +int usb_request_get_status(usb_pipe_t *pipe, + usb_request_recipient_t recipient, uint16_t index, + uint16_t *status) +{ + if ((recipient == USB_REQUEST_RECIPIENT_DEVICE) && (index != 0)) { + return EINVAL; + } + + if (status == NULL) { + return EBADMEM; + } + + uint16_t status_usb_endianess; + size_t data_transfered_size; + int rc = usb_control_request_get(pipe, USB_REQUEST_TYPE_STANDARD, + recipient, USB_DEVREQ_GET_STATUS, 0, uint16_host2usb(index), + &status_usb_endianess, 2, &data_transfered_size); + if (rc != EOK) { + return rc; + } + if (data_transfered_size != 2) { + return ELIMIT; + } + + *status = uint16_usb2host(status_usb_endianess); + + return EOK; +} + +/** Clear or disable specific device feature. + * + * @param[in] pipe Control endpoint pipe (session must be already started). + * @param[in] request_type Request type (standard/class/vendor). + * @param[in] recipient Recipient of the CLEAR_FEATURE request. + * @param[in] feature_selector Feature selector (in native endianness). + * @param[in] index Recipient index (in native endianness). + * @return Error code. + */ +int usb_request_clear_feature(usb_pipe_t *pipe, + usb_request_type_t request_type, usb_request_recipient_t recipient, + uint16_t feature_selector, uint16_t index) +{ + if (request_type == USB_REQUEST_TYPE_STANDARD) { + if ((recipient == USB_REQUEST_RECIPIENT_DEVICE) + && (index != 0)) { + return EINVAL; + } + } + + int rc = usb_control_request_set(pipe, request_type, recipient, + USB_DEVREQ_CLEAR_FEATURE, + uint16_host2usb(feature_selector), uint16_host2usb(index), + NULL, 0); + + return rc; +} + +/** Set or enable specific device feature. + * + * @param[in] pipe Control endpoint pipe (session must be already started). + * @param[in] request_type Request type (standard/class/vendor). + * @param[in] recipient Recipient of the SET_FEATURE request. + * @param[in] feature_selector Feature selector (in native endianness). + * @param[in] index Recipient index (in native endianness). + * @return Error code. + */ +int usb_request_set_feature(usb_pipe_t *pipe, + usb_request_type_t request_type, usb_request_recipient_t recipient, + uint16_t feature_selector, uint16_t index) +{ + if (request_type == USB_REQUEST_TYPE_STANDARD) { + if ((recipient == USB_REQUEST_RECIPIENT_DEVICE) + && (index != 0)) { + return EINVAL; + } + } + + int rc = usb_control_request_set(pipe, request_type, recipient, + USB_DEVREQ_SET_FEATURE, + uint16_host2usb(feature_selector), uint16_host2usb(index), + NULL, 0); + + return rc; +} + +/** Change address of connected device. + * This function automatically updates the backing connection to point to + * the new address. + * + * @param pipe Control endpoint pipe (session must be already started). + * @param new_address New USB address to be set (in native endianness). + * @return Error code. + */ +int usb_request_set_address(usb_pipe_t *pipe, + usb_address_t new_address) +{ + if ((new_address < 0) || (new_address >= USB11_ADDRESS_MAX)) { + return EINVAL; + } + + uint16_t addr = uint16_host2usb((uint16_t)new_address); + + int rc = usb_control_request_set(pipe, + USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE, + USB_DEVREQ_SET_ADDRESS, + addr, 0, + NULL, 0); + + if (rc != EOK) { + return rc; + } + + assert(pipe->wire != NULL); + /* TODO: prevent other from accessing wire now. */ + pipe->wire->address = new_address; + + return EOK; +} + +/** Retrieve USB descriptor of a USB device. + * + * @param[in] pipe Control endpoint pipe (session must be already started). + * @param[in] request_type Request type (standard/class/vendor). + * @param[in] recipient Request recipient (device/interface/endpoint). + * @param[in] descriptor_type Descriptor type (device/configuration/HID/...). + * @param[in] descriptor_index Descriptor index. + * @param[in] language Language index. + * @param[out] buffer Buffer where to store the retrieved descriptor. + * @param[in] size Size of the @p buffer. + * @param[out] actual_size Number of bytes actually transferred. + * @return Error code. + */ +int usb_request_get_descriptor(usb_pipe_t *pipe, + usb_request_type_t request_type, usb_request_recipient_t recipient, + uint8_t descriptor_type, uint8_t descriptor_index, + uint16_t language, + void *buffer, size_t size, size_t *actual_size) +{ + if (buffer == NULL) { + return EBADMEM; + } + if (size == 0) { + return EINVAL; + } + + uint16_t wValue = descriptor_index | (descriptor_type << 8); + + return usb_control_request_get(pipe, + request_type, recipient, + USB_DEVREQ_GET_DESCRIPTOR, + wValue, language, + buffer, size, actual_size); +} + +/** Retrieve USB descriptor, allocate space for it. + * + * @param[in] pipe Control endpoint pipe (session must be already started). + * @param[in] request_type Request type (standard/class/vendor). + * @param[in] recipient Request recipient (device/interface/endpoint). + * @param[in] descriptor_type Descriptor type (device/configuration/HID/...). + * @param[in] descriptor_index Descriptor index. + * @param[in] language Language index. + * @param[out] buffer_ptr Where to store pointer to allocated buffer. + * @param[out] buffer_size Where to store the size of the descriptor. + * @return + */ +int usb_request_get_descriptor_alloc(usb_pipe_t * pipe, + usb_request_type_t request_type, usb_request_recipient_t recipient, + uint8_t descriptor_type, uint8_t descriptor_index, + uint16_t language, + void **buffer_ptr, size_t *buffer_size) +{ + if (buffer_ptr == NULL) { + return EBADMEM; + } + + int rc; + + /* + * Get only first byte to retrieve descriptor length. + */ + uint8_t tmp_buffer[1]; + size_t bytes_transfered; + rc = usb_request_get_descriptor(pipe, request_type, recipient, + descriptor_type, descriptor_index, language, + &tmp_buffer, 1, &bytes_transfered); + if (rc != EOK) { + return rc; + } + if (bytes_transfered != 1) { + /* FIXME: some better error code? */ + return ESTALL; + } + + size_t size = tmp_buffer[0]; + if (size == 0) { + /* FIXME: some better error code? */ + return ESTALL; + } + + /* + * Allocate buffer and get the descriptor again. + */ + void *buffer = malloc(size); + if (buffer == NULL) { + return ENOMEM; + } + + rc = usb_request_get_descriptor(pipe, request_type, recipient, + descriptor_type, descriptor_index, language, + buffer, size, &bytes_transfered); + if (rc != EOK) { + free(buffer); + return rc; + } + if (bytes_transfered != size) { + free(buffer); + /* FIXME: some better error code? */ + return ESTALL; + } + + *buffer_ptr = buffer; + if (buffer_size != NULL) { + *buffer_size = size; + } + + return EOK; +} + +/** Retrieve standard device descriptor of a USB device. + * + * @param[in] pipe Control endpoint pipe (session must be already started). + * @param[out] descriptor Storage for the device descriptor. + * @return Error code. + */ +int usb_request_get_device_descriptor(usb_pipe_t *pipe, + usb_standard_device_descriptor_t *descriptor) +{ + if (descriptor == NULL) { + return EBADMEM; + } + + size_t actually_transferred = 0; + usb_standard_device_descriptor_t descriptor_tmp; + int rc = usb_request_get_descriptor(pipe, + USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE, + USB_DESCTYPE_DEVICE, 0, 0, + &descriptor_tmp, sizeof(descriptor_tmp), + &actually_transferred); + + if (rc != EOK) { + return rc; + } + + /* Verify that all data has been transferred. */ + if (actually_transferred < sizeof(descriptor_tmp)) { + return ELIMIT; + } + + /* Everything is okay, copy the descriptor. */ + memcpy(descriptor, &descriptor_tmp, + sizeof(descriptor_tmp)); + + return EOK; +} + +/** Retrieve configuration descriptor of a USB device. + * + * The function does not retrieve additional data binded with configuration + * descriptor (such as its interface and endpoint descriptors) - use + * usb_request_get_full_configuration_descriptor() instead. + * + * @param[in] pipe Control endpoint pipe (session must be already started). + * @param[in] index Descriptor index. + * @param[out] descriptor Storage for the device descriptor. + * @return Error code. + */ +int usb_request_get_bare_configuration_descriptor(usb_pipe_t *pipe, + int index, usb_standard_configuration_descriptor_t *descriptor) +{ + if (descriptor == NULL) { + return EBADMEM; + } + + if ((index < 0) || (index > 0xFF)) { + return ERANGE; + } + + size_t actually_transferred = 0; + usb_standard_configuration_descriptor_t descriptor_tmp; + int rc = usb_request_get_descriptor(pipe, + USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE, + USB_DESCTYPE_CONFIGURATION, index, 0, + &descriptor_tmp, sizeof(descriptor_tmp), + &actually_transferred); + if (rc != EOK) { + return rc; + } + + /* Verify that all data has been transferred. */ + if (actually_transferred < sizeof(descriptor_tmp)) { + return ELIMIT; + } + + /* Everything is okay, copy the descriptor. */ + memcpy(descriptor, &descriptor_tmp, + sizeof(descriptor_tmp)); + + return EOK; +} + +/** Retrieve full configuration descriptor of a USB device. + * + * @warning The @p buffer might be touched (i.e. its contents changed) + * even when error occurs. + * + * @param[in] pipe Control endpoint pipe (session must be already started). + * @param[in] index Descriptor index. + * @param[out] descriptor Storage for the device descriptor. + * @param[in] descriptor_size Size of @p descriptor buffer. + * @param[out] actual_size Number of bytes actually transferred. + * @return Error code. + */ +int usb_request_get_full_configuration_descriptor(usb_pipe_t *pipe, + int index, void *descriptor, size_t descriptor_size, size_t *actual_size) +{ + if ((index < 0) || (index > 0xFF)) { + return ERANGE; + } + + return usb_request_get_descriptor(pipe, + USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE, + USB_DESCTYPE_CONFIGURATION, index, 0, + descriptor, descriptor_size, actual_size); +} + +/** Retrieve full configuration descriptor, allocate space for it. + * + * The function takes care that full configuration descriptor is returned + * (i.e. the function will fail when less data then descriptor.totalLength + * is returned). + * + * @param[in] pipe Control endpoint pipe (session must be already started). + * @param[in] index Configuration index. + * @param[out] descriptor_ptr Where to store pointer to allocated buffer. + * @param[out] descriptor_size Where to store the size of the descriptor. + * @return Error code. + */ +int usb_request_get_full_configuration_descriptor_alloc( + usb_pipe_t *pipe, int index, + void **descriptor_ptr, size_t *descriptor_size) +{ + int rc; + + if (descriptor_ptr == NULL) { + return EBADMEM; + } + + usb_standard_configuration_descriptor_t bare_config; + rc = usb_request_get_bare_configuration_descriptor(pipe, index, + &bare_config); + if (rc != EOK) { + return rc; + } + if (bare_config.descriptor_type != USB_DESCTYPE_CONFIGURATION) { + return ENOENT; + } + if (bare_config.total_length < sizeof(bare_config)) { + return ELIMIT; + } + + void *buffer = malloc(bare_config.total_length); + if (buffer == NULL) { + return ENOMEM; + } + + size_t transferred = 0; + rc = usb_request_get_full_configuration_descriptor(pipe, index, + buffer, bare_config.total_length, &transferred); + if (rc != EOK) { + free(buffer); + return rc; + } + + if (transferred != bare_config.total_length) { + free(buffer); + return ELIMIT; + } + + /* Everything looks okay, copy the pointers. */ + + *descriptor_ptr = buffer; + + if (descriptor_size != NULL) { + *descriptor_size = bare_config.total_length; + } + + return EOK; +} + +/** Update existing or add new USB descriptor to a USB device. + * + * @param[in] pipe Control endpoint pipe (session must be already started). + * @param[in] request_type Request type (standard/class/vendor). + * @param[in] recipient Request recipient (device/interface/endpoint). + * @param[in] descriptor_type Descriptor type (device/configuration/HID/...). + * @param[in] descriptor_index Descriptor index. + * @param[in] language Language index (in native endianness). + * @param[in] buffer Buffer with the new descriptor (in USB endianness). + * @param[in] size Size of the @p buffer in bytes (in native endianness). + * @return Error code. + */ +int usb_request_set_descriptor(usb_pipe_t *pipe, + usb_request_type_t request_type, usb_request_recipient_t recipient, + uint8_t descriptor_type, uint8_t descriptor_index, + uint16_t language, + void *buffer, size_t size) +{ + if (buffer == NULL) { + return EBADMEM; + } + if (size == 0) { + return EINVAL; + } + + /* FIXME: proper endianness. */ + uint16_t wValue = descriptor_index | (descriptor_type << 8); + + return usb_control_request_set(pipe, + request_type, recipient, + USB_DEVREQ_SET_DESCRIPTOR, + wValue, language, + buffer, size); +} + +/** Get current configuration value of USB device. + * + * @param[in] pipe Control endpoint pipe (session must be already started). + * @param[out] configuration_value Current configuration value. + * @return Error code. + */ +int usb_request_get_configuration(usb_pipe_t *pipe, + uint8_t *configuration_value) +{ + uint8_t value; + size_t actual_size; + + int rc = usb_control_request_get(pipe, + USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE, + USB_DEVREQ_GET_CONFIGURATION, + 0, 0, + &value, 1, &actual_size); + + if (rc != EOK) { + return rc; + } + if (actual_size != 1) { + return ELIMIT; + } + + if (configuration_value != NULL) { + *configuration_value = value; + } + + return EOK; +} + +/** Set configuration of USB device. + * + * @param pipe Control endpoint pipe (session must be already started). + * @param configuration_value New configuration value. + * @return Error code. + */ +int usb_request_set_configuration(usb_pipe_t *pipe, + uint8_t configuration_value) +{ + uint16_t config_value + = uint16_host2usb((uint16_t) configuration_value); + + return usb_control_request_set(pipe, + USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE, + USB_DEVREQ_SET_CONFIGURATION, config_value, 0, + NULL, 0); +} + +/** Get selected alternate setting for USB interface. + * + * @param[in] pipe Control endpoint pipe (session must be already started). + * @param[in] interface_index Interface index. + * @param[out] alternate_setting Alternate setting for the interface. + * @return Error code. + */ +int usb_request_get_interface(usb_pipe_t *pipe, + uint8_t interface_index, uint8_t *alternate_setting) +{ + uint8_t value; + size_t actual_size; + + int rc = usb_control_request_get(pipe, + USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_INTERFACE, + USB_DEVREQ_GET_INTERFACE, + 0, uint16_host2usb((uint16_t) interface_index), + &value, 1, &actual_size); + + if (rc != EOK) { + return rc; + } + if (actual_size != 1) { + return ELIMIT; + } + + if (alternate_setting != NULL) { + *alternate_setting = value; + } + + return EOK; +} + +/** Select alternate setting for USB interface. + * + * @param[in] pipe Control endpoint pipe (session must be already started). + * @param[in] interface_index Interface index. + * @param[in] alternate_setting Alternate setting to select. + * @return Error code. + */ +int usb_request_set_interface(usb_pipe_t *pipe, + uint8_t interface_index, uint8_t alternate_setting) +{ + return usb_control_request_set(pipe, + USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_INTERFACE, + USB_DEVREQ_SET_INTERFACE, + uint16_host2usb((uint16_t) alternate_setting), + uint16_host2usb((uint16_t) interface_index), + NULL, 0); +} + +/** Get list of supported languages by USB device. + * + * @param[in] pipe Control endpoint pipe (session must be already started). + * @param[out] languages_ptr Where to store pointer to allocated array of + * supported languages. + * @param[out] languages_count Number of supported languages. + * @return Error code. + */ +int usb_request_get_supported_languages(usb_pipe_t *pipe, + l18_win_locales_t **languages_ptr, size_t *languages_count) +{ + int rc; + + if (languages_ptr == NULL) { + return EBADMEM; + } + if (languages_count == NULL) { + return EBADMEM; + } + + uint8_t *string_descriptor = NULL; + size_t string_descriptor_size = 0; + rc = usb_request_get_descriptor_alloc(pipe, + USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE, + USB_DESCTYPE_STRING, 0, 0, + (void **) &string_descriptor, &string_descriptor_size); + if (rc != EOK) { + return rc; + } + if (string_descriptor_size <= 2) { + free(string_descriptor); + return EEMPTY; + } + /* Subtract first 2 bytes (length and descriptor type). */ + string_descriptor_size -= 2; + + /* Odd number of bytes - descriptor is broken? */ + if ((string_descriptor_size % 2) != 0) { + /* FIXME: shall we return with error or silently ignore? */ + free(string_descriptor); + return ESTALL; + } + + size_t langs_count = string_descriptor_size / 2; + l18_win_locales_t *langs + = malloc(sizeof(l18_win_locales_t) * langs_count); + if (langs == NULL) { + free(string_descriptor); + return ENOMEM; + } + + size_t i; + for (i = 0; i < langs_count; i++) { + /* Language code from the descriptor is in USB endianness. */ + /* FIXME: is this really correct? */ + uint16_t lang_code = (string_descriptor[2 + 2 * i + 1] << 8) + + string_descriptor[2 + 2 * i]; + langs[i] = uint16_usb2host(lang_code); + } + + free(string_descriptor); + + *languages_ptr = langs; + *languages_count =langs_count; + + return EOK; +} + +/** Get string (descriptor) from USB device. + * + * The string is returned in native encoding of the operating system. + * For HelenOS, that is UTF-8. + * + * @param[in] pipe Control endpoint pipe (session must be already started). + * @param[in] index String index (in native endianness), + * first index has number 1 (index from descriptors can be used directly). + * @param[in] lang String language (in native endianness). + * @param[out] string_ptr Where to store allocated string in native encoding. + * @return Error code. + */ +int usb_request_get_string(usb_pipe_t *pipe, + size_t index, l18_win_locales_t lang, char **string_ptr) +{ + if (string_ptr == NULL) { + return EBADMEM; + } + /* + * Index is actually one byte value and zero index is used + * to retrieve list of supported languages. + */ + if ((index < 1) || (index > 0xFF)) { + return ERANGE; + } + /* Language is actually two byte value. */ + if (lang > 0xFFFF) { + return ERANGE; + } + + int rc; + + /* Prepare dynamically allocated variables. */ + uint8_t *string = NULL; + wchar_t *string_chars = NULL; + + /* Get the actual descriptor. */ + size_t string_size; + rc = usb_request_get_descriptor_alloc(pipe, + USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE, + USB_DESCTYPE_STRING, index, uint16_host2usb(lang), + (void **) &string, &string_size); + if (rc != EOK) { + goto leave; + } + + if (string_size <= 2) { + rc = EEMPTY; + goto leave; + } + /* Subtract first 2 bytes (length and descriptor type). */ + string_size -= 2; + + /* Odd number of bytes - descriptor is broken? */ + if ((string_size % 2) != 0) { + /* FIXME: shall we return with error or silently ignore? */ + rc = ESTALL; + goto leave; + } + + size_t string_char_count = string_size / 2; + string_chars = malloc(sizeof(wchar_t) * (string_char_count + 1)); + if (string_chars == NULL) { + rc = ENOMEM; + goto leave; + } + + /* + * Build a wide string. + * And do not forget to set NULL terminator (string descriptors + * do not have them). + */ + size_t i; + for (i = 0; i < string_char_count; i++) { + uint16_t uni_char = (string[2 + 2 * i + 1] << 8) + + string[2 + 2 * i]; + string_chars[i] = uni_char; + } + string_chars[string_char_count] = 0; + + + /* Convert to normal string. */ + char *str = wstr_to_astr(string_chars); + if (str == NULL) { + rc = ENOMEM; + goto leave; + } + + *string_ptr = str; + rc = EOK; + +leave: + if (string != NULL) { + free(string); + } + if (string_chars != NULL) { + free(string_chars); + } + + return rc; +} + +/** Clear halt bit of an endpoint pipe (after pipe stall). + * + * @param pipe Control pipe. + * @param ep_index Endpoint index (in native endianness). + * @return Error code. + */ +int usb_request_clear_endpoint_halt(usb_pipe_t *pipe, uint16_t ep_index) +{ + return usb_request_clear_feature(pipe, + USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_ENDPOINT, + uint16_host2usb(USB_FEATURE_SELECTOR_ENDPOINT_HALT), + uint16_host2usb(ep_index)); +} + +/** Clear halt bit of an endpoint pipe (after pipe stall). + * + * @param ctrl_pipe Control pipe. + * @param target_pipe Which pipe is halted and shall be cleared. + * @return Error code. + */ +int usb_pipe_clear_halt(usb_pipe_t *ctrl_pipe, usb_pipe_t *target_pipe) +{ + if ((ctrl_pipe == NULL) || (target_pipe == NULL)) { + return EINVAL; + } + return usb_request_clear_endpoint_halt(ctrl_pipe, + target_pipe->endpoint_no); +} + +/** Get endpoint status. + * + * @param[in] ctrl_pipe Control pipe. + * @param[in] pipe Of which pipe the status shall be received. + * @param[out] status Where to store pipe status (in native endianness). + * @return Error code. + */ +int usb_request_get_endpoint_status(usb_pipe_t *ctrl_pipe, usb_pipe_t *pipe, + uint16_t *status) +{ + uint16_t status_tmp; + uint16_t pipe_index = (uint16_t) pipe->endpoint_no; + int rc = usb_request_get_status(ctrl_pipe, + USB_REQUEST_RECIPIENT_ENDPOINT, uint16_host2usb(pipe_index), + &status_tmp); + if (rc != EOK) { + return rc; + } + + if (status != NULL) { + *status = uint16_usb2host(status_tmp); + } + + return EOK; +} + +/** + * @} + */ Index: uspace/lib/usbhid/Makefile =================================================================== --- uspace/lib/usbhid/Makefile (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbhid/Makefile (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,46 @@ +# +# Copyright (c) 2011 Vojtech Horky +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# - Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# - Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# - The name of the author may not be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +USPACE_PREFIX = ../.. +LIBRARY = libusbhid +EXTRA_CFLAGS += \ + -I$(LIBUSB_PREFIX)/include \ + -I$(LIBUSBDEV_PREFIX)/include \ + -I$(LIBDRV_PREFIX)/include \ + -Iinclude + +SOURCES = \ + src/hiddescriptor.c \ + src/hidiface.c \ + src/hidparser.c \ + src/hidpath.c \ + src/hidreport.c \ + src/consumer.c \ + src/hidreq.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/lib/usbhid/include/usb/hid/hid.h =================================================================== --- uspace/lib/usbhid/include/usb/hid/hid.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbhid/include/usb/hid/hid.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,75 @@ +/* + * Copyright (c) 2010 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbhid + * @{ + */ +/** @file + * @brief USB HID device related types. + */ +#ifndef LIBUSBHID_HID_H_ +#define LIBUSBHID_HID_H_ + +#include +#include +#include + +/** USB/HID device requests. */ +typedef enum { + USB_HIDREQ_GET_REPORT = 1, + USB_HIDREQ_GET_IDLE = 2, + USB_HIDREQ_GET_PROTOCOL = 3, + /* Values 4 to 8 are reserved. */ + USB_HIDREQ_SET_REPORT = 9, + USB_HIDREQ_SET_IDLE = 10, + USB_HIDREQ_SET_PROTOCOL = 11 +} usb_hid_request_t; + +typedef enum { + USB_HID_PROTOCOL_BOOT = 0, + USB_HID_PROTOCOL_REPORT = 1 +} usb_hid_protocol_t; + +/** USB/HID subclass constants. */ +typedef enum { + USB_HID_SUBCLASS_NONE = 0, + USB_HID_SUBCLASS_BOOT = 1 +} usb_hid_subclass_t; + +/** USB/HID interface protocols. */ +typedef enum { + USB_HID_PROTOCOL_NONE = 0, + USB_HID_PROTOCOL_KEYBOARD = 1, + USB_HID_PROTOCOL_MOUSE = 2 +} usb_hid_iface_protocol_t; + + +#endif +/** + * @} + */ Index: uspace/lib/usbhid/include/usb/hid/hid_report_items.h =================================================================== --- uspace/lib/usbhid/include/usb/hid/hid_report_items.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbhid/include/usb/hid/hid_report_items.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,354 @@ +/* + * Copyright (c) 2011 Matej Klonfar + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusb + * @{ + */ +/** @file + * @brief USB HID Report descriptor item tags. + */ +#ifndef LIBUSB_HID_REPORT_ITEMS_H_ +#define LIBUSB_HID_REPORT_ITEMS_H_ + +#include + +/*---------------------------------------------------------------------------*/ +/* + * Item prefix + */ + +/** Returns size of item data in bytes */ +#define USB_HID_ITEM_SIZE(data) ((uint8_t)(data & 0x3)) + +/** Returns item tag */ +#define USB_HID_ITEM_TAG(data) ((uint8_t)((data & 0xF0) >> 4)) + +/** Returns class of item tag */ +#define USB_HID_ITEM_TAG_CLASS(data) ((uint8_t)((data & 0xC) >> 2)) + +/** Returns if the item is the short item or long item. Long items are not + * supported. */ +#define USB_HID_ITEM_IS_LONG(data) (data == 0xFE) + +/*---------------------------------------------------------------------------*/ +/* + * Extended usage macros + */ + +/** Recognizes if the given usage is extended (contains also usage page). */ +#define USB_HID_IS_EXTENDED_USAGE(usage) ((usage & 0xFFFF0000) != 0) + +/** Cuts usage page of the extended usage. */ +#define USB_HID_EXTENDED_USAGE_PAGE(usage) ((usage & 0xFFFF0000) >> 16) + +/** Cuts usage of the extended usage */ +#define USB_HID_EXTENDED_USAGE(usage) (usage & 0xFFFF) + +/*---------------------------------------------------------------------------*/ +/* + * Input/Output/Feature Item flags + */ +/** + * Indicates whether the item is data (0) or a constant (1) value. Data + * indicates the item is defining report fields that contain modifiable device + * data. Constant indicates the item is a static read-only field in a report + * and cannot be modified (written) by the host. + */ +#define USB_HID_ITEM_FLAG_CONSTANT(flags) ((flags & 0x1) == 0x1) + +/** + * Indicates whether the item creates variable (1) or array (0) data fields in + * reports. + */ +#define USB_HID_ITEM_FLAG_VARIABLE(flags) ((flags & 0x2) == 0x2) + +/** + * Indicates whether the data is absolute (0) (based on a fixed origin) or + * relative (1) (indicating the change in value from the last report). Mouse + * devices usually provide relative data, while tablets usually provide + * absolute data. + */ +#define USB_HID_ITEM_FLAG_RELATIVE(flags) ((flags & 0x4) == 0x4) + +/** Indicates whether the data “rolls over” when reaching either the extreme + * high or low value. For example, a dial that can spin freely 360 degrees + * might output values from 0 to 10. If Wrap is indicated, the next value + * reported after passing the 10 position in the increasing direction would be + * 0. + */ +#define USB_HID_ITEM_FLAG_WRAP(flags) ((flags & 0x8) == 0x8) + +/** + * Indicates whether the raw data from the device has been processed in some + * way, and no longer represents a linear relationship between what is + * measured and the data that is reported. + */ +#define USB_HID_ITEM_FLAG_LINEAR(flags) ((flags & 0x10) == 0x10) + +/** + * Indicates whether the control has a preferred state to which it will return + * when the user is not physically interacting with the control. Push buttons + * (as opposed to toggle buttons) and self- centering joysticks are examples. + */ +#define USB_HID_ITEM_FLAG_PREFERRED(flags) ((flags & 0x20) == 0x20) + +/** + * Indicates whether the control has a state in which it is not sending + * meaningful data. One possible use of the null state is for controls that + * require the user to physically interact with the control in order for it to + * report useful data. + */ +#define USB_HID_ITEM_FLAG_POSITION(flags) ((flags & 0x40) == 0x40) + +/** + * Indicates whether the Feature or Output control's value should be changed + * by the host or not. Volatile output can change with or without host + * interaction. To avoid synchronization problems, volatile controls should be + * relative whenever possible. + */ +#define USB_HID_ITEM_FLAG_VOLATILE(flags) ((flags & 0x80) == 0x80) + +/** + * Indicates that the control emits a fixed-size stream of bytes. The contents + * of the data field are determined by the application. The contents of the + * buffer are not interpreted as a single numeric quantity. Report data + * defined by a Buffered Bytes item must be aligned on an 8-bit boundary. + */ +#define USB_HID_ITEM_FLAG_BUFFERED(flags) ((flags & 0x100) == 0x100) + +/*---------------------------------------------------------------------------*/ + +/* MAIN ITEMS */ + +/** + * Main items are used to either define or group certain types of data fields + * within a Report descriptor. + */ +#define USB_HID_TAG_CLASS_MAIN 0x0 + +/** + * An Input item describes information about the data provided by one or more + * physical controls. An application can use this information to interpret the + * data provided by the device. All data fields defined in a single item share + * an identical data format. + */ +#define USB_HID_REPORT_TAG_INPUT 0x8 + +/** + * The Output item is used to define an output data field in a report. This + * item is similar to an Input item except it describes data sent to the + * device—for example, LED states. + */ +#define USB_HID_REPORT_TAG_OUTPUT 0x9 + +/** + * Feature items describe device configuration information that can be sent to + * the device. + */ +#define USB_HID_REPORT_TAG_FEATURE 0xB + +/** + * A Collection item identifies a relationship between two or more data + * (Input, Output, or Feature.) + */ +#define USB_HID_REPORT_TAG_COLLECTION 0xA + +/** + * While the Collection item opens a collection of data, the End Collection + * item closes a collection. + */ +#define USB_HID_REPORT_TAG_END_COLLECTION 0xC + +/*---------------------------------------------------------------------------*/ + +/* GLOBAL ITEMS */ + +/** + * Global items describe rather than define data from a control. + */ +#define USB_HID_TAG_CLASS_GLOBAL 0x1 + +/** + * Unsigned integer specifying the current Usage Page. Since a usage are 32 + * bit values, Usage Page items can be used to conserve space in a report + * descriptor by setting the high order 16 bits of a subsequent usages. Any + * usage that follows which is defines 16 bits or less is interpreted as a + * Usage ID and concatenated with the Usage Page to form a 32 bit Usage. + */ +#define USB_HID_REPORT_TAG_USAGE_PAGE 0x0 + +/** + * Extent value in logical units. This is the minimum value that a variable + * or array item will report. For example, a mouse reporting x position values + * from 0 to 128 would have a Logical Minimum of 0 and a Logical Maximum of + * 128. + */ +#define USB_HID_REPORT_TAG_LOGICAL_MINIMUM 0x1 + +/** + * Extent value in logical units. This is the maximum value that a variable + * or array item will report. + */ +#define USB_HID_REPORT_TAG_LOGICAL_MAXIMUM 0x2 + +/** + * Minimum value for the physical extent of a variable item. This represents + * the Logical Minimum with units applied to it. + */ +#define USB_HID_REPORT_TAG_PHYSICAL_MINIMUM 0x3 + +/** + * Maximum value for the physical extent of a variable item. + */ +#define USB_HID_REPORT_TAG_PHYSICAL_MAXIMUM 0x4 + +/** + * Value of the unit exponent in base 10. See the table later in this section + * for more information. + */ +#define USB_HID_REPORT_TAG_UNIT_EXPONENT 0x5 + +/** + * Unit values. + */ +#define USB_HID_REPORT_TAG_UNIT 0x6 + +/** + * Unsigned integer specifying the size of the report fields in bits. This + * allows the parser to build an item map for the report handler to use. + */ +#define USB_HID_REPORT_TAG_REPORT_SIZE 0x7 + +/** + * Unsigned value that specifies the Report ID. If a Report ID tag is used + * anywhere in Report descriptor, all data reports for the device are preceded + * by a single byte ID field. All items succeeding the first Report ID tag but + * preceding a second Report ID tag are included in a report prefixed by a + * 1-byte ID. All items succeeding the second but preceding a third Report ID + * tag are included in a second report prefixed by a second ID, and so on. + */ +#define USB_HID_REPORT_TAG_REPORT_ID 0x8 + +/** + * Unsigned integer specifying the number of data fields for the item; + * determines how many fields are included in the report for this particular + * item (and consequently how many bits are added to the report). + */ +#define USB_HID_REPORT_TAG_REPORT_COUNT 0x9 + +/** + * Places a copy of the global item state table on the stack. + */ +#define USB_HID_REPORT_TAG_PUSH 0xA + +/** + * Replaces the item state table with the top structure from the stack. + */ +#define USB_HID_REPORT_TAG_POP 0xB + +/*---------------------------------------------------------------------------*/ + +/* LOCAL ITEMS */ + +/** + * Local item tags define characteristics of controls. These items do not + * carry over to the next Main item. If a Main item defines more than one + * control, it may be preceded by several similar Local item tags. For + * example, an Input item may have several Usage tags associated with it, one + * for each control. + */ +#define USB_HID_TAG_CLASS_LOCAL 0x2 + +/** + * Usage index for an item usage; represents a suggested usage for the item or + * collection. In the case where an item represents multiple controls, a Usage + * tag may suggest a usage for every variable or element in an array. + */ +#define USB_HID_REPORT_TAG_USAGE 0x0 + +/** + * Defines the starting usage associated with an array or bitmap. + */ +#define USB_HID_REPORT_TAG_USAGE_MINIMUM 0x1 + +/** + * Defines the ending usage associated with an array or bitmap. + */ +#define USB_HID_REPORT_TAG_USAGE_MAXIMUM 0x2 + +/** + * Determines the body part used for a control. Index points to a designator + * in the Physical descriptor. + */ +#define USB_HID_REPORT_TAG_DESIGNATOR_INDEX 0x3 + +/** + * Defines the index of the starting designator associated with an array or + * bitmap. + */ +#define USB_HID_REPORT_TAG_DESIGNATOR_MINIMUM 0x4 + +/** + * Defines the index of the ending designator associated with an array or + * bitmap. + */ +#define USB_HID_REPORT_TAG_DESIGNATOR_MAXIMUM 0x5 + +/** + * String index for a String descriptor; allows a string to be associated with + * a particular item or control. + */ +#define USB_HID_REPORT_TAG_STRING_INDEX 0x7 + +/** + * Specifies the first string index when assigning a group of sequential + * strings to controls in an array or bitmap. + */ +#define USB_HID_REPORT_TAG_STRING_MINIMUM 0x8 + +/** + * Specifies the last string index when assigning a group of sequential + * strings to controls in an array or bitmap. + */ +#define USB_HID_REPORT_TAG_STRING_MAXIMUM 0x9 + +/** + * Defines the beginning or end of a set of local items (1 = open set, 0 = + * close set). + * + * Usages other than the first (most preferred) usage defined are not + * accessible by system software. + */ +#define USB_HID_REPORT_TAG_DELIMITER 0xA + +/*---------------------------------------------------------------------------*/ + +#endif +/** + * @} + */ Index: uspace/lib/usbhid/include/usb/hid/hiddescriptor.h =================================================================== --- uspace/lib/usbhid/include/usb/hid/hiddescriptor.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbhid/include/usb/hid/hiddescriptor.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,94 @@ +/* + * Copyright (c) 2011 Matej Klonfar + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusb + * @{ + */ +/** @file + * USB HID report descriptor and report data parser + */ +#ifndef LIBUSB_HIDDESCRIPTOR_H_ +#define LIBUSB_HIDDESCRIPTOR_H_ + +#include +#include +#include +#include +#include + +int usb_hid_parse_report_descriptor(usb_hid_report_t *report, + const uint8_t *data, size_t size); + +void usb_hid_free_report(usb_hid_report_t *report); + +void usb_hid_descriptor_print(usb_hid_report_t *report); + +int usb_hid_report_init(usb_hid_report_t *report); + +int usb_hid_report_append_fields(usb_hid_report_t *report, + usb_hid_report_item_t *report_item); + +usb_hid_report_description_t * usb_hid_report_find_description( + const usb_hid_report_t *report, uint8_t report_id, + usb_hid_report_type_t type); + +int usb_hid_report_parse_tag(uint8_t tag, uint8_t class, const uint8_t *data, + size_t item_size, usb_hid_report_item_t *report_item, + usb_hid_report_path_t *usage_path); + +int usb_hid_report_parse_main_tag(uint8_t tag, const uint8_t *data, + size_t item_size, usb_hid_report_item_t *report_item, + usb_hid_report_path_t *usage_path); + +int usb_hid_report_parse_global_tag(uint8_t tag, const uint8_t *data, + size_t item_size, usb_hid_report_item_t *report_item, + usb_hid_report_path_t *usage_path); + +int usb_hid_report_parse_local_tag(uint8_t tag, const uint8_t *data, + size_t item_size, usb_hid_report_item_t *report_item, + usb_hid_report_path_t *usage_path); + +void usb_hid_descriptor_print_list(link_t *head); + +void usb_hid_report_reset_local_items(usb_hid_report_item_t *report_item); + +void usb_hid_free_report_list(link_t *head); + +usb_hid_report_item_t *usb_hid_report_item_clone( + const usb_hid_report_item_t *item); + +uint32_t usb_hid_report_tag_data_uint32(const uint8_t *data, size_t size); + +usb_hid_report_path_t *usb_hid_report_path_try_insert(usb_hid_report_t*report, + usb_hid_report_path_t *cmp_path); + + +#endif +/** + * @} + */ Index: uspace/lib/usbhid/include/usb/hid/hidparser.h =================================================================== --- uspace/lib/usbhid/include/usb/hid/hidparser.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbhid/include/usb/hid/hidparser.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2011 Matej Klonfar + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbhid + * @{ + */ +/** @file + * USB HID report descriptor and report data parser + */ +#ifndef LIBUSBHID_HIDPARSER_H_ +#define LIBUSBHID_HIDPARSER_H_ + +#include +#include +#include +#include +#include +#include + + +/* + * Input report parser functions + */ +int usb_hid_parse_report(const usb_hid_report_t *report, const uint8_t *data, + size_t size, uint8_t *report_id); + +/* + * Output report parser functions + */ +uint8_t *usb_hid_report_output(usb_hid_report_t *report, size_t *size, + uint8_t report_id); + +void usb_hid_report_output_free(uint8_t *output); + +size_t usb_hid_report_size(usb_hid_report_t *report, uint8_t report_id, + usb_hid_report_type_t type); + +size_t usb_hid_report_byte_size(usb_hid_report_t *report, uint8_t report_id, + usb_hid_report_type_t type); + + +int usb_hid_report_output_translate(usb_hid_report_t *report, + uint8_t report_id, uint8_t *buffer, size_t size); + + +/* + * Report descriptor structure observing functions + */ +usb_hid_report_field_t *usb_hid_report_get_sibling(usb_hid_report_t *report, + usb_hid_report_field_t *field, usb_hid_report_path_t *path, + int flags, usb_hid_report_type_t type); + +uint8_t usb_hid_get_next_report_id(usb_hid_report_t *report, + uint8_t report_id, usb_hid_report_type_t type); + +#endif +/** + * @} + */ Index: uspace/lib/usbhid/include/usb/hid/hidpath.h =================================================================== --- uspace/lib/usbhid/include/usb/hid/hidpath.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbhid/include/usb/hid/hidpath.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,144 @@ +/* + * Copyright (c) 2011 Matej Klonfar + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusb + * @{ + */ +/** @file + * USB HID report descriptor and report data parser + */ +#ifndef LIBUSB_HIDPATH_H_ +#define LIBUSB_HIDPATH_H_ + +#include +#include +#include + + +/*---------------------------------------------------------------------------*/ +/* + * Flags of usage paths comparison modes. + * + */ +/** Wanted usage path must be exactly the same as the searched one. This + * option cannot be combined with the others. + */ +#define USB_HID_PATH_COMPARE_STRICT 0 + +/** + * Wanted usage path must be the suffix in the searched one. + */ +#define USB_HID_PATH_COMPARE_END 1 + +/** + * Only usage page are compared along the usage path. This option can be + * combined with others. + */ +#define USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY 2 + +/** + * Searched usage page must be prefix of the other one. + */ +#define USB_HID_PATH_COMPARE_BEGIN 4 + +/** + * Searched couple of usage page and usage can be anywhere in usage path. + * This option is deprecated. + */ +#define USB_HID_PATH_COMPARE_ANYWHERE 8 + +/*----------------------------------------------------------------------------*/ +/** + * Item of usage path structure. Last item of linked list describes one item + * in report, the others describe superior Collection tags. Usage and Usage + * page of report item can be changed due to data in report. + */ +typedef struct { + /** Usage page of report item. Zero when usage page can be changed. */ + uint32_t usage_page; + /** Usage of report item. Zero when usage can be changed. */ + uint32_t usage; + + /** Attribute of Collection tag in report descriptor*/ + uint8_t flags; + + /** Linked list structure*/ + link_t link; +} usb_hid_report_usage_path_t; + + +/*---------------------------------------------------------------------------*/ +/** + * USB HID usage path structure. + * */ +typedef struct { + /** Length of usage path */ + int depth; + + /** Report id. Zero is reserved and means that report id is not used. + * */ + uint8_t report_id; + + /** Linked list structure. */ + link_t link; /* list */ + + /** Head of the list of usage path items. */ + link_t head; + +} usb_hid_report_path_t; + +/*---------------------------------------------------------------------------*/ +usb_hid_report_path_t *usb_hid_report_path(void); + +void usb_hid_report_path_free(usb_hid_report_path_t *path); + +int usb_hid_report_path_set_report_id(usb_hid_report_path_t *usage_path, + uint8_t report_id); + +int usb_hid_report_path_append_item(usb_hid_report_path_t *usage_path, + int32_t usage_page, int32_t usage); + +void usb_hid_report_remove_last_item(usb_hid_report_path_t *usage_path); + +void usb_hid_report_null_last_item(usb_hid_report_path_t *usage_path); + +void usb_hid_report_set_last_item(usb_hid_report_path_t *usage_path, + int32_t tag, int32_t data); + +int usb_hid_report_compare_usage_path(usb_hid_report_path_t *report_path, + usb_hid_report_path_t *path, int flags); + +usb_hid_report_path_t *usb_hid_report_path_clone( + usb_hid_report_path_t *usage_path); + +void usb_hid_print_usage_path(usb_hid_report_path_t *path); + +#endif +/** + * @} + */ Index: uspace/lib/usbhid/include/usb/hid/hidreport.h =================================================================== --- uspace/lib/usbhid/include/usb/hid/hidreport.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbhid/include/usb/hid/hidreport.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,67 @@ +/* + * Copyright (c) 2011 Lubos Slovak + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbhid + * @{ + */ +/** @file + * USB HID report parser initialization from descriptors. + */ + +#ifndef LIBUSBHID_HIDREPORT_H_ +#define LIBUSBHID_HIDREPORT_H_ + +#include +#include + +/** + * Retrieves the Report descriptor from the USB device and initializes the + * report parser. + * + * \param[in] dev USB device representing a HID device. + * \param[in/out] parser HID Report parser. + * \param[out] report_desc Place to save report descriptor into. + * \param[out] report_size + * + * \retval EOK if successful. + * \retval EINVAL if one of the parameters is not given (is NULL). + * \retval ENOENT if there are some descriptors missing. + * \retval ENOMEM if an error with allocation occured. + * \retval EINVAL if the Report descriptor's size does not match the size + * from the interface descriptor. + * \return Other value inherited from function usb_pipe_start_session(), + * usb_pipe_end_session() or usb_request_get_descriptor(). + */ +int usb_hid_process_report_descriptor(usb_device_t *dev, + usb_hid_report_t *report, uint8_t **report_desc, size_t *report_size); + +#endif /* LIBUSB_HIDREPORT_H_ */ + +/** + * @} + */ Index: uspace/lib/usbhid/include/usb/hid/hidtypes.h =================================================================== --- uspace/lib/usbhid/include/usb/hid/hidtypes.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbhid/include/usb/hid/hidtypes.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,322 @@ +/* + * Copyright (c) 2011 Matej Klonfar + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusb + * @{ + */ +/** @file + * Basic data structures for USB HID Report descriptor and report parser. + */ +#ifndef LIBUSB_HIDTYPES_H_ +#define LIBUSB_HIDTYPES_H_ + +#include +#include + +/*---------------------------------------------------------------------------*/ + +/** + * Maximum amount of specified usages for one report item + */ +#define USB_HID_MAX_USAGES 0xffff + +/** + * Converts integer from unsigned two's complement format format to signed + * one. + * + * @param x Number to convert + * @param size Length of the unsigned number in bites + * @return signed int + */ +#define USB_HID_UINT32_TO_INT32(x, size) \ + ((((x) & (1 << ((size) - 1))) != 0) ? \ + -(~((x) - 1) & ((1 << size) - 1)) : (x)) + +/** + * Convert integer from signed format to unsigned. If number is negative the + * two's complement format is used. + * + * @param x Number to convert + * @param size Length of result number in bites + * @return unsigned int + */ +#define USB_HID_INT32_TO_UINT32(x, size) \ + (((x) < 0 ) ? ((1 << (size)) + (x)) : (x)) + +/*---------------------------------------------------------------------------*/ + +/** + * Enum of report types + */ +typedef enum { + /** Input report. Data are sent from device to system */ + USB_HID_REPORT_TYPE_INPUT = 1, + + /** Output report. Data are sent from system to device */ + USB_HID_REPORT_TYPE_OUTPUT = 2, + + /** Feature report. Describes device configuration information that + * can be sent to the device */ + USB_HID_REPORT_TYPE_FEATURE = 3 +} usb_hid_report_type_t; + +/*---------------------------------------------------------------------------*/ + +/** + * Description of all reports described in one report descriptor. + */ +typedef struct { + /** Count of available reports. */ + int report_count; + + /** Head of linked list of description of reports. */ + link_t reports; + + /** Head of linked list of all used usage/collection paths. */ + link_t collection_paths; + + /** Length of list of usage paths. */ + int collection_paths_count; + + /** Flag whether report ids are used. */ + int use_report_ids; + + /** Report id of last parsed report. */ + uint8_t last_report_id; + +} usb_hid_report_t; +/*---------------------------------------------------------------------------*/ + +/** + * Description of one concrete report + */ +typedef struct { + /** Report id. Zero when no report id is used. */ + uint8_t report_id; + + /** Type of report */ + usb_hid_report_type_t type; + + /** Bit length of the report */ + size_t bit_length; + + /** Number of items in report */ + size_t item_length; + + /** Linked list of report items in report */ + link_t report_items; + + /** Linked list of descriptions. */ + link_t link; +} usb_hid_report_description_t; +/*---------------------------------------------------------------------------*/ + +/** + * Description of one field/item in report + */ +typedef struct { + /** Bit offset of the field */ + int offset; + + /** Bit size of the field */ + size_t size; + + /** Usage page. Zero when usage page can be changed. */ + uint16_t usage_page; + + /** Usage. Zero when usage can be changed. */ + uint16_t usage; + + /** Item's attributes */ + uint8_t item_flags; + + /** Usage/Collection path of the field. */ + usb_hid_report_path_t *collection_path; + + /** + * The lowest valid logical value (value with the device operates) + */ + int32_t logical_minimum; + + /** + * The greatest valid logical value + */ + int32_t logical_maximum; + + /** + * The lowest valid physical value (value with the system operates) + */ + int32_t physical_minimum; + + /** The greatest valid physical value */ + int32_t physical_maximum; + + /** The lowest valid usage index */ + int32_t usage_minimum; + + /** The greatest valid usage index */ + int32_t usage_maximum; + + /** Unit of the value */ + uint32_t unit; + + /** Unit exponent */ + uint32_t unit_exponent; + + /** Array of possible usages */ + uint32_t *usages; + + /** Size of the array of usages */ + size_t usages_count; + + /** Parsed value */ + int32_t value; + + /** List to another report items */ + link_t link; +} usb_hid_report_field_t; + +/*---------------------------------------------------------------------------*/ + +/** + * State table for report descriptor parsing + */ +typedef struct { + /** report id */ + int32_t id; + + /** Extended usage page */ + uint16_t extended_usage_page; + + /** Array of usages specified for this item */ + uint32_t usages[USB_HID_MAX_USAGES]; + + /** Length of usages array */ + int usages_count; + + /** Usage page*/ + uint32_t usage_page; + + /** Minimum valid usage index */ + int32_t usage_minimum; + + /** Maximum valid usage index */ + int32_t usage_maximum; + + /** Minimum valid logical value */ + int32_t logical_minimum; + + /** Maximum valid logical value */ + int32_t logical_maximum; + + /** Length of the items in bits*/ + int32_t size; + + /** COunt of items*/ + int32_t count; + + /** Bit offset of the item in report */ + size_t offset; + + /** Unit exponent */ + int32_t unit_exponent; + /** Unit of the value */ + int32_t unit; + + /** String index */ + uint32_t string_index; + + /** Minimum valid string index */ + uint32_t string_minimum; + + /** Maximum valid string index */ + uint32_t string_maximum; + + /** The designator index */ + uint32_t designator_index; + + /** Minimum valid designator value*/ + uint32_t designator_minimum; + + /** Maximum valid designator value*/ + uint32_t designator_maximum; + + /** Minimal valid physical value*/ + int32_t physical_minimum; + + /** Maximal valid physical value */ + int32_t physical_maximum; + + /** Items attributes*/ + uint8_t item_flags; + + /** Report type */ + usb_hid_report_type_t type; + + /** current collection path*/ + usb_hid_report_path_t *usage_path; + + /** Unused*/ + link_t link; + + int in_delimiter; +} usb_hid_report_item_t; +/*---------------------------------------------------------------------------*/ +/** + * Enum of the keyboard modifiers + */ +typedef enum { + USB_HID_MOD_LCTRL = 0x01, + USB_HID_MOD_LSHIFT = 0x02, + USB_HID_MOD_LALT = 0x04, + USB_HID_MOD_LGUI = 0x08, + USB_HID_MOD_RCTRL = 0x10, + USB_HID_MOD_RSHIFT = 0x20, + USB_HID_MOD_RALT = 0x40, + USB_HID_MOD_RGUI = 0x80, + USB_HID_MOD_COUNT = 8 +} usb_hid_modifiers_t; + +static const usb_hid_modifiers_t + usb_hid_modifiers_consts[USB_HID_MOD_COUNT] = { + USB_HID_MOD_LCTRL, + USB_HID_MOD_LSHIFT, + USB_HID_MOD_LALT, + USB_HID_MOD_LGUI, + USB_HID_MOD_RCTRL, + USB_HID_MOD_RSHIFT, + USB_HID_MOD_RALT, + USB_HID_MOD_RGUI +}; +/*---------------------------------------------------------------------------*/ + + +#endif +/** + * @} + */ Index: uspace/lib/usbhid/include/usb/hid/iface.h =================================================================== --- uspace/lib/usbhid/include/usb/hid/iface.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbhid/include/usb/hid/iface.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbhid + * @{ + */ +/** @file + * Client functions for accessing USB HID interface. + */ +#ifndef LIBUSBHID_CLASSES_HID_IFACE_H_ +#define LIBUSBHID_CLASSES_HID_IFACE_H_ + +#include +#include + +extern int usbhid_dev_get_event_length(async_sess_t *, size_t *); +extern int usbhid_dev_get_event(async_sess_t *, uint8_t *, size_t, size_t *, + int *, unsigned int); +extern int usbhid_dev_get_report_descriptor_length(async_sess_t *, size_t *); +extern int usbhid_dev_get_report_descriptor(async_sess_t *, uint8_t *, size_t, + size_t *); + +#endif +/** + * @} + */ Index: uspace/lib/usbhid/include/usb/hid/request.h =================================================================== --- uspace/lib/usbhid/include/usb/hid/request.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbhid/include/usb/hid/request.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,69 @@ +/* + * Copyright (c) 2011 Lubos Slovak + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbhid + * @{ + */ +/** @file + * HID class-specific requests. + */ + +#ifndef USB_KBD_HIDREQ_H_ +#define USB_KBD_HIDREQ_H_ + +#include + +#include +#include + +/*----------------------------------------------------------------------------*/ + +int usbhid_req_set_report(usb_pipe_t *ctrl_pipe, int iface_no, + usb_hid_report_type_t type, uint8_t *buffer, size_t buf_size); + +int usbhid_req_set_protocol(usb_pipe_t *ctrl_pipe, int iface_no, + usb_hid_protocol_t protocol); + +int usbhid_req_set_idle(usb_pipe_t *ctrl_pipe, int iface_no, uint8_t duration); + +int usbhid_req_get_report(usb_pipe_t *ctrl_pipe, int iface_no, + usb_hid_report_type_t type, uint8_t *buffer, size_t buf_size, + size_t *actual_size); + +int usbhid_req_get_protocol(usb_pipe_t *ctrl_pipe, int iface_no, + usb_hid_protocol_t *protocol); + +int usbhid_req_get_idle(usb_pipe_t *ctrl_pipe, int iface_no, uint8_t *duration); + +/*----------------------------------------------------------------------------*/ + +#endif /* USB_KBD_HIDREQ_H_ */ + +/** + * @} + */ Index: uspace/lib/usbhid/include/usb/hid/usages/consumer.h =================================================================== --- uspace/lib/usbhid/include/usb/hid/usages/consumer.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbhid/include/usb/hid/usages/consumer.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2011 Lubos Slovak + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbhid + * @{ + */ +/** @file + * USB multimedia key usage to string mapping. + */ + +#ifndef LIBUSBHID_CONSUMER_H_ +#define LIBUSBHID_CONSUMER_H_ + +const char *usbhid_multimedia_usage_to_str(int usage); + +#endif /* LIBUSBHID_CONSUMER_H_ */ + +/** + * @} + */ Index: uspace/lib/usbhid/include/usb/hid/usages/core.h =================================================================== --- uspace/lib/usbhid/include/usb/hid/usages/core.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbhid/include/usb/hid/usages/core.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2010 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbhid + * @{ + */ +/** @file + * @brief USB HID Usage Tables. + */ +#ifndef LIBUSBHID_HIDUT_H_ +#define LIBUSBHID_HIDUT_H_ + +/** USB/HID Usage Pages. */ +typedef enum { + USB_HIDUT_PAGE_GENERIC_DESKTOP = 1, + USB_HIDUT_PAGE_SIMULATION = 2, + USB_HIDUT_PAGE_VR = 3, + USB_HIDUT_PAGE_SPORT = 4, + USB_HIDUT_PAGE_GAME = 5, + USB_HIDUT_PAGE_GENERIC_DEVICE = 6, + USB_HIDUT_PAGE_KEYBOARD = 7, + USB_HIDUT_PAGE_LED = 8, + USB_HIDUT_PAGE_BUTTON = 9, + USB_HIDUT_PAGE_ORDINAL = 0x0a, + USB_HIDUT_PAGE_TELEPHONY_DEVICE = 0x0b, + USB_HIDUT_PAGE_CONSUMER = 0x0c +} usb_hidut_usage_page_t; + +/** Usages for Generic Desktop Page. */ +typedef enum { + USB_HIDUT_USAGE_GENERIC_DESKTOP_POINTER = 1, + USB_HIDUT_USAGE_GENERIC_DESKTOP_MOUSE = 2, + USB_HIDUT_USAGE_GENERIC_DESKTOP_JOYSTICK = 4, + USB_HIDUT_USAGE_GENERIC_DESKTOP_GAMEPAD = 5, + USB_HIDUT_USAGE_GENERIC_DESKTOP_KEYBOARD = 6, + USB_HIDUT_USAGE_GENERIC_DESKTOP_KEYPAD = 7, + USB_HIDUT_USAGE_GENERIC_DESKTOP_X = 0x30, + USB_HIDUT_USAGE_GENERIC_DESKTOP_Y = 0x31, + USB_HIDUT_USAGE_GENERIC_DESKTOP_WHEEL = 0x38 + /* USB_HIDUT_USAGE_GENERIC_DESKTOP_ = , */ + +} usb_hidut_usage_generic_desktop_t; + +typedef enum { + USB_HIDUT_USAGE_CONSUMER_CONSUMER_CONTROL = 1 +} usb_hidut_usage_consumer_t; + + +#endif +/** + * @} + */ Index: uspace/lib/usbhid/include/usb/hid/usages/kbdgen.h =================================================================== --- uspace/lib/usbhid/include/usb/hid/usages/kbdgen.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbhid/include/usb/hid/usages/kbdgen.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,175 @@ +/* + * Copyright (c) 2010 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbhid + * @{ + */ +/** @file + * @brief USB HID key codes. + * @details + * This is not a typical header as by default it is equal to empty file. + * However, by cleverly defining the USB_HIDUT_KBD_KEY you can use it + * to generate conversion tables etc. + * + * For example, this creates enum for known keys: + * @code +#define USB_HIDUT_KBD_KEY(name, usage_id, l, lc, l1, l2) \ + USB_KBD_KEY_##name = usage_id, +typedef enum { + #include +} usb_key_code_t; + @endcode + * + * Maybe, it might be better that you would place such enums into separate + * files and create them as separate step before compiling to allow tools + * such as Doxygen get the definitions right. + * + * @warning This file does not include guard to prevent multiple inclusions + * into a single file. + */ + + +#ifndef USB_HIDUT_KBD_KEY +/** Declare keyboard key. + * @param name Key name (identifier). + * @param usage_id Key code (see Keyboard/Keypad Page (0x07) in HUT1.12. + * @param letter Corresponding character (0 if not applicable). + * @param letter_caps Corresponding character with Caps on. + * @param letter_mod1 Corresponding character with modifier #1 on. + * @param letter_mod2 Corresponding character with modifier #2 on. + */ +#define USB_HIDUT_KBD_KEY(name, usage_id, letter, letter_caps, letter_mod1, letter_mod2) + +#endif + +#define __NONPRINT(name, usage_id) \ + USB_HIDUT_KBD_KEY(name, usage_id, 0, 0, 0, 0) + +/* US alphabet letters */ +USB_HIDUT_KBD_KEY(A, 0x04, 'a', 'A', 0, 0) +USB_HIDUT_KBD_KEY(B, 0x05, 'b', 'B', 0, 0) +USB_HIDUT_KBD_KEY(C, 0x06, 'c', 'C', 0, 0) +USB_HIDUT_KBD_KEY(D, 0x07, 'd', 'D', 0, 0) +USB_HIDUT_KBD_KEY(E, 0x08, 'e', 'E', 0, 0) +USB_HIDUT_KBD_KEY(F, 0x09, 'f', 'F', 0, 0) +USB_HIDUT_KBD_KEY(G, 0x0A, 'g', 'G', 0, 0) +USB_HIDUT_KBD_KEY(H, 0x0B, 'h', 'H', 0, 0) +USB_HIDUT_KBD_KEY(I, 0x0C, 'i', 'I', 0, 0) +USB_HIDUT_KBD_KEY(J, 0x0D, 'j', 'J', 0, 0) +USB_HIDUT_KBD_KEY(K, 0x0E, 'k', 'K', 0, 0) +USB_HIDUT_KBD_KEY(L, 0x0F, 'l', 'L', 0, 0) +USB_HIDUT_KBD_KEY(M, 0x10, 'm', 'M', 0, 0) +USB_HIDUT_KBD_KEY(N, 0x11, 'n', 'N', 0, 0) +USB_HIDUT_KBD_KEY(O, 0x12, 'o', 'O', 0, 0) +USB_HIDUT_KBD_KEY(P, 0x13, 'p', 'P', 0, 0) +USB_HIDUT_KBD_KEY(Q, 0x14, 'q', 'Q', 0, 0) +USB_HIDUT_KBD_KEY(R, 0x15, 'r', 'R', 0, 0) +USB_HIDUT_KBD_KEY(S, 0x16, 's', 'S', 0, 0) +USB_HIDUT_KBD_KEY(T, 0x17, 't', 'T', 0, 0) +USB_HIDUT_KBD_KEY(U, 0x18, 'u', 'U', 0, 0) +USB_HIDUT_KBD_KEY(V, 0x19, 'v', 'V', 0, 0) +USB_HIDUT_KBD_KEY(W, 0x1A, 'w', 'W', 0, 0) +USB_HIDUT_KBD_KEY(X, 0x1B, 'x', 'X', 0, 0) +USB_HIDUT_KBD_KEY(Y, 0x1C, 'y', 'Y', 0, 0) +USB_HIDUT_KBD_KEY(Z, 0x1D, 'z', 'Z', 0, 0) + +/* Keyboard digits */ +USB_HIDUT_KBD_KEY(1, 0x1E, '1', '!', 0, 0) +USB_HIDUT_KBD_KEY(2, 0x1F, '2', '@', 0, 0) +USB_HIDUT_KBD_KEY(3, 0x20, '3', '#', 0, 0) +USB_HIDUT_KBD_KEY(4, 0x21, '4', '$', 0, 0) +USB_HIDUT_KBD_KEY(5, 0x22, '5', '%', 0, 0) +USB_HIDUT_KBD_KEY(6, 0x23, '6', '^', 0, 0) +USB_HIDUT_KBD_KEY(7, 0x24, '7', '&', 0, 0) +USB_HIDUT_KBD_KEY(8, 0x25, '8', '*', 0, 0) +USB_HIDUT_KBD_KEY(9, 0x26, '9', '(', 0, 0) +USB_HIDUT_KBD_KEY(0, 0x27, '0', ')', 0, 0) + +/* More-or-less typewriter command keys */ +USB_HIDUT_KBD_KEY(ENTER, 0x28, '\n', 0, 0, 0) +USB_HIDUT_KBD_KEY(ESCAPE, 0x29, 0, 0, 0, 0) +USB_HIDUT_KBD_KEY(BACKSPACE, 0x2A, '\b', 0, 0, 0) +USB_HIDUT_KBD_KEY(TAB, 0x2B, '\t', 0, 0, 0) +USB_HIDUT_KBD_KEY(SPACE, 0x2C, ' ', 0, 0, 0) + +/* Special (printable) characters */ +USB_HIDUT_KBD_KEY(DASH, 0x2D, '-', '_', 0, 0) +USB_HIDUT_KBD_KEY(EQUALS, 0x2E, '=', '+', 0, 0) +USB_HIDUT_KBD_KEY(LEFT_BRACKET, 0x2F, '[', '{', 0, 0) +USB_HIDUT_KBD_KEY(RIGHT_BRACKET, 0x30, ']', '}', 0, 0) +USB_HIDUT_KBD_KEY(BACKSLASH, 0x31, '\\', '|', 0, 0) +USB_HIDUT_KBD_KEY(HASH, 0x32, '#', '~', 0, 0) +USB_HIDUT_KBD_KEY(SEMICOLON, 0x33, ';', ':', 0, 0) +USB_HIDUT_KBD_KEY(APOSTROPHE, 0x34, '\'', '"', 0, 0) +USB_HIDUT_KBD_KEY(GRAVE_ACCENT, 0x35, '`', '~', 0, 0) +USB_HIDUT_KBD_KEY(COMMA, 0x36, ',', '<', 0, 0) +USB_HIDUT_KBD_KEY(PERIOD, 0x37, '.', '>', 0, 0) +USB_HIDUT_KBD_KEY(SLASH, 0x38, '/', '?', 0, 0) + +USB_HIDUT_KBD_KEY(CAPS_LOCK, 0x39, 0, 0, 0, 0) + +/* Function keys */ +__NONPRINT( F1, 0x3A) +__NONPRINT( F2, 0x3B) +__NONPRINT( F3, 0x3C) +__NONPRINT( F4, 0x3D) +__NONPRINT( F5, 0x3E) +__NONPRINT( F6, 0x3F) +__NONPRINT( F7, 0x40) +__NONPRINT( F8, 0x41) +__NONPRINT( F9, 0x42) +__NONPRINT(F10, 0x43) +__NONPRINT(F11, 0x44) +__NONPRINT(F12, 0x45) + +/* Cursor movement keys & co. */ +__NONPRINT(PRINT_SCREEN, 0x46) +__NONPRINT(SCROLL_LOCK, 0x47) +__NONPRINT(PAUSE, 0x48) +__NONPRINT(INSERT, 0x49) +__NONPRINT(HOME, 0x4A) +__NONPRINT(PAGE_UP, 0x4B) +__NONPRINT(DELETE, 0x4C) +__NONPRINT(END, 0x4D) +__NONPRINT(PAGE_DOWN, 0x4E) +__NONPRINT(RIGHT_ARROW, 0x4F) +__NONPRINT(LEFT_ARROW, 0x50) +__NONPRINT(DOWN_ARROW, 0x51) +__NONPRINT(UP_ARROW, 0x52) + + + + +/* USB_HIDUT_KBD_KEY(, 0x, '', '', 0, 0) */ + +#undef __NONPRINT + +/** + * @} + */ + Index: uspace/lib/usbhid/include/usb/hid/usages/led.h =================================================================== --- uspace/lib/usbhid/include/usb/hid/usages/led.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbhid/include/usb/hid/usages/led.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,122 @@ +/* + * Copyright (c) 2010 Lubos Slovak + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbhid + * @{ + */ +/** @file + * @brief USB HID Usage Tables - LED page. + */ +#ifndef LIBUSBHID_UTLED_H_ +#define LIBUSBHID_UTLED_H_ + +typedef enum { + USB_HID_LED_UNDEFINED = 0, + USB_HID_LED_NUM_LOCK, + USB_HID_LED_CAPS_LOCK, + USB_HID_LED_SCROLL_LOCK, + USB_HID_LED_COMPOSE, + USB_HID_LED_KANA, + USB_HID_LED_POWER, + USB_HID_LED_SHIFT, + USB_HID_LED_DND, + USB_HID_LED_MUTE, + USB_HID_LED_TONE_ENABLE, + USB_HID_LED_HIGH_CUT_FILTER, + USB_HID_LED_LOW_CUT_FILTER, + USB_HID_LED_EQ_ENABLE, + USB_HID_LED_SOUND_FIELD_ON, + USB_HID_LED_SURROUND_ON, + USB_HID_LED_REPEAT, + USB_HID_LED_STEREO, + USB_HID_LED_SAMPLING_RATE_DETECT, + USB_HID_LED_SPINNING, + USB_HID_LED_CAV, + USB_HID_LED_CLV, + USB_HID_LED_RECORDING_FORMAT_DETECT, + USB_HID_LED_OFF_HOOK, + USB_HID_LED_RING, + USB_HID_LED_MESSAGE_WAITING, + USB_HID_LED_DATA_MODE, + USB_HID_LED_BATTERY_OPERATION, + USB_HID_LED_BATTERY_OK, + USB_HID_LED_BATTERY_LOW, + USB_HID_LED_SPEAKER, + USB_HID_LED_HEAD_SET, + USB_HID_LED_HOLD, + USB_HID_LED_MICRO, + USB_HID_LED_COVERAGE, + USB_HID_LED_NIGHT_MODE, + USB_HID_LED_SEND_CALLS, + USB_HID_LED_CALL_PICKUP, + USB_HID_LED_CONFERENCE, + USB_HID_LED_STAND_BY, + USB_HID_LED_CAMERA_ON, + USB_HID_LED_CAMERA_OFF, + USB_HID_LED_ON_LINE, + USB_HID_LED_OFF_LINE, + USB_HID_LED_BUSY, + USB_HID_LED_READY, + USB_HID_LED_PAPER_OUT, + USB_HID_LED_PAPER_JAM, + USB_HID_LED_REMOTE, + USB_HID_LED_FORWARD, + USB_HID_LED_REVERSE, + USB_HID_LED_STOP, + USB_HID_LED_REWIND, + USB_HID_LED_FAST_FORWARD, + USB_HID_LED_PLAY, + USB_HID_LED_PAUSE, + USB_HID_LED_RECORD, + USB_HID_LED_ERROR, + USB_HID_LED_USAGE_SELECTED_IND, + USB_HID_LED_USAGE_IN_USE_IND, + USB_HID_LED_USAGE_MULTI_MODE_IND, + USB_HID_LED_IND_ON, + USB_HID_LED_IND_FLASH, + USB_HID_LED_IND_SLOW_BLINK, + USB_HID_LED_IND_FAST_BLINK, + USB_HID_LED_IND_OFF, + USB_HID_LED_FLASH_ON_TIME, + USB_HID_LED_SLOW_BLINK_ON_TIME, + USB_HID_LED_SLOW_BLINK_OFF_TIME, + USB_HID_LED_FAST_BLINK_ON_TIME, + USB_HID_LED_FAST_BLINK_OFF_TIME, + USB_HID_LED_USAGE_IND_COLOR, + USB_HID_LED_IND_RED, + USB_HID_LED_IND_GREEN, + USB_HID_LED_IND_AMBER, + USB_HID_LED_GENERIC_IND, + USB_HID_LED_SYSTEM_SUSPEND, + USB_HID_LED_EXTERNAL_POWER +} usb_hid_usage_led_t; + +#endif /* LIBUSB_UTLED_H_ */ +/** + * @} + */ Index: uspace/lib/usbhid/src/consumer.c =================================================================== --- uspace/lib/usbhid/src/consumer.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbhid/src/consumer.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,732 @@ +/* + * Copyright (c) 2011 Lubos Slovak + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbhid + * @{ + */ +/** @file + * UUSB multimedia key usage, to string mapping. + */ + +#include +#include +#include + +static const char *usbhid_consumer_usage_str[0x29d] = { + [0x01] = "Consumer Control", + [0x02] = "Numeric Key Pad", + [0x03] = "Programmable Buttons", + [0x04] = "Microphone", + [0x05] = "Headphone", + [0x06] = "Graphic Equalizer", + [0x07] = "Reserved", + [0x08] = "Reserved", + [0x09] = "Reserved", + [0x0a] = "Reserved", + [0x0b] = "Reserved", + [0x0c] = "Reserved", + [0x0d] = "Reserved", + [0x0e] = "Reserved", + [0x0f] = "Reserved", + [0x10] = "Reserved", + [0x11] = "Reserved", + [0x12] = "Reserved", + [0x13] = "Reserved", + [0x14] = "Reserved", + [0x15] = "Reserved", + [0x16] = "Reserved", + [0x17] = "Reserved", + [0x18] = "Reserved", + [0x19] = "Reserved", + [0x1a] = "Reserved", + [0x1b] = "Reserved", + [0x1c] = "Reserved", + [0x1d] = "Reserved", + [0x1e] = "Reserved", + [0x1f] = "Reserved", + [0x20] = "+10", + [0x21] = "+100", + [0x22] = "AM/PM", + [0x23] = "Reserved", + [0x24] = "Reserved", + [0x25] = "Reserved", + [0x26] = "Reserved", + [0x27] = "Reserved", + [0x28] = "Reserved", + [0x29] = "Reserved", + [0x2a] = "Reserved", + [0x2b] = "Reserved", + [0x2c] = "Reserved", + [0x2d] = "Reserved", + [0x2e] = "Reserved", + [0x2f] = "Reserved", + [0x30] = "Reserved", + [0x31] = "Reserved", + [0x32] = "Reserved", + [0x33] = "Reserved", + [0x34] = "Reserved", + [0x35] = "Reserved", + [0x36] = "Reserved", + [0x37] = "Reserved", + [0x38] = "Reserved", + [0x39] = "Reserved", + [0x3a] = "Reserved", + [0x3b] = "Reserved", + [0x3c] = "Reserved", + [0x3d] = "Reserved", + [0x3e] = "Reserved", + [0x3f] = "Reserved", + [0x40] = "Menu", + [0x41] = "Menu Pick", + [0x42] = "Menu Up", + [0x43] = "Menu Down", + [0x44] = "Menu Left", + [0x45] = "Menu Right", + [0x46] = "Menu Escape", + [0x47] = "Menu Value Increase", + [0x48] = "Menu Value Decrease", + [0x49] = "Reserved", + [0x4a] = "Reserved", + [0x4b] = "Reserved", + [0x4c] = "Reserved", + [0x4d] = "Reserved", + [0x4e] = "Reserved", + [0x4f] = "Reserved", + [0x50] = "Reserved", + [0x51] = "Reserved", + [0x52] = "Reserved", + [0x53] = "Reserved", + [0x54] = "Reserved", + [0x55] = "Reserved", + [0x56] = "Reserved", + [0x57] = "Reserved", + [0x58] = "Reserved", + [0x59] = "Reserved", + [0x5a] = "Reserved", + [0x5b] = "Reserved", + [0x5c] = "Reserved", + [0x5d] = "Reserved", + [0x5e] = "Reserved", + [0x5f] = "Reserved", + [0x60] = "Data On Screen", + [0x61] = "Closed Caption", + [0x62] = "Closed Caption Select", + [0x63] = "VCR/TV", + [0x64] = "Broadcast Mode", + [0x65] = "Snapshot", + [0x66] = "Still", + [0x67] = "Reserved", + [0x68] = "Reserved", + [0x69] = "Reserved", + [0x6a] = "Reserved", + [0x6b] = "Reserved", + [0x6c] = "Reserved", + [0x6d] = "Reserved", + [0x6e] = "Reserved", + [0x6f] = "Reserved", + [0x70] = "Reserved", + [0x71] = "Reserved", + [0x72] = "Reserved", + [0x73] = "Reserved", + [0x74] = "Reserved", + [0x75] = "Reserved", + [0x76] = "Reserved", + [0x77] = "Reserved", + [0x78] = "Reserved", + [0x79] = "Reserved", + [0x7a] = "Reserved", + [0x7b] = "Reserved", + [0x7c] = "Reserved", + [0x7d] = "Reserved", + [0x7e] = "Reserved", + [0x7f] = "Reserved", + [0x80] = "Selection", + [0x81] = "Assign Selection", + [0x82] = "Mode Step", + [0x83] = "Recall Last", + [0x84] = "Enter Channel", + [0x85] = "Order Movie", + [0x86] = "Channel", + [0x87] = "Media Selection", + [0x88] = "Media Select Computer", + [0x89] = "Media Select TV", + [0x8a] = "Media Select WWW", + [0x8b] = "Media Select DVD", + [0x8c] = "Media Select Telephone", + [0x8d] = "Media Select Program Guide", + [0x8e] = "Media Select Video Phone", + [0x8f] = "Media Select Games", + [0x90] = "Media Select Messages", + [0x91] = "Media Select CD", + [0x92] = "Media Select VCR", + [0x93] = "Media Select Tuner", + [0x94] = "Quit", + [0x95] = "Help", + [0x96] = "Media Select Tape", + [0x97] = "Media Select Cable", + [0x98] = "Media Select Satellite", + [0x99] = "Media Select Security", + [0x9a] = "Media Select Home", + [0x9b] = "Media Select Call", + [0x9c] = "Channel Increment", + [0x9d] = "Channel Decrement", + [0x9e] = "Media Select SAP", + [0x9f] = "Reserved", + [0xa0] = "VCR Plus", + [0xa1] = "Once", + [0xa2] = "Daily", + [0xa3] = "Weekly", + [0xa4] = "Monthly", + [0xa5] = "Reserved", + [0xa6] = "Reserved", + [0xa7] = "Reserved", + [0xa8] = "Reserved", + [0xa9] = "Reserved", + [0xaa] = "Reserved", + [0xab] = "Reserved", + [0xac] = "Reserved", + [0xad] = "Reserved", + [0xae] = "Reserved", + [0xaf] = "Reserved", + [0xb0] = "Play", + [0xb1] = "Pause", + [0xb2] = "Record", + [0xb3] = "Fast Forward", + [0xb4] = "Rewind", + [0xb5] = "Scan Next Track", + [0xb6] = "Scan Previous Trac", + [0xb7] = "Stop", + [0xb8] = "Eject", + [0xb9] = "Random Play", + [0xba] = "Select Disc", + [0xbb] = "Enter Disc", + [0xbc] = "Repeat", + [0xbd] = "Tracking", + [0xbe] = "Track Normal", + [0xbf] = "Slow Tracking", + [0xc0] = "Frame Forward", + [0xc1] = "Frame Back", + [0xc2] = "Mark", + [0xc3] = "Clear Mark", + [0xc4] = "Repeat From Mark", + [0xc5] = "Return to Mark", + [0xc6] = "Search Mark Forward", + [0xc7] = "Search Mark Backwards", + [0xc8] = "Counter Reset", + [0xc9] = "Show Counter", + [0xca] = "Tracking Increment", + [0xcb] = "Tracking Decrement", + [0xcc] = "Stop/Eject", + [0xcd] = "Play/Pause", + [0xce] = "Play/Skip", + [0xcf] = "Reserved", + [0xd0] = "Reserved", + [0xd1] = "Reserved", + [0xd2] = "Reserved", + [0xd3] = "Reserved", + [0xd4] = "Reserved", + [0xd5] = "Reserved", + [0xd6] = "Reserved", + [0xd7] = "Reserved", + [0xd8] = "Reserved", + [0xd9] = "Reserved", + [0xda] = "Reserved", + [0xdb] = "Reserved", + [0xdc] = "Reserved", + [0xdd] = "Reserved", + [0xde] = "Reserved", + [0xdf] = "Reserved", + [0xe0] = "Volume", + [0xe1] = "Balance", + [0xe2] = "Mute", + [0xe3] = "Bass", + [0xe4] = "Treble", + [0xe5] = "Bass Boost", + [0xe6] = "Surround Mode", + [0xe7] = "Loudness", + [0xe8] = "MPX", + [0xe9] = "Volume Increment", + [0xea] = "Volume Decrement", + [0xeb] = "Reserved", + [0xec] = "Reserved", + [0xed] = "Reserved", + [0xee] = "Reserved", + [0xef] = "Reserved", + [0xf0] = "Speed Select", + [0xf1] = "Playback Speed", + [0xf2] = "Standard Play", + [0xf3] = "Long Play", + [0xf4] = "Extended Play", + [0xf5] = "Slow", + [0xf6] = "Reserved", + [0xf7] = "Reserved", + [0xf8] = "Reserved", + [0xf9] = "Reserved", + [0xfa] = "Reserved", + [0xfb] = "Reserved", + [0xfc] = "Reserved", + [0xfd] = "Reserved", + [0xfe] = "Reserved", + [0xff] = "Reserved", + [0x100] = "Fan Enable", + [0x101] = "Fan Speed", + [0x102] = "Light Enable", + [0x103] = "Light Illumination Level", + [0x104] = "Climate Control Enable", + [0x105] = "Room Temperature", + [0x106] = "Security Enable", + [0x107] = "Fire Alarm", + [0x108] = "Police Alarm", + [0x109] = "Proximity", + [0x10a] = "Motion", + [0x10b] = "Duress Alarm", + [0x10c] = "Holdup Alarm", + [0x10d] = "Medical Alarm", + [0x10e] = "Reserved", + [0x10f] = "Reserved", + [0x110] = "Reserved", + [0x111] = "Reserved", + [0x112] = "Reserved", + [0x113] = "Reserved", + [0x114] = "Reserved", + [0x115] = "Reserved", + [0x116] = "Reserved", + [0x117] = "Reserved", + [0x118] = "Reserved", + [0x119] = "Reserved", + [0x11a] = "Reserved", + [0x11b] = "Reserved", + [0x11c] = "Reserved", + [0x11d] = "Reserved", + [0x11e] = "Reserved", + [0x11f] = "Reserved", + [0x120] = "Reserved", + [0x121] = "Reserved", + [0x122] = "Reserved", + [0x123] = "Reserved", + [0x124] = "Reserved", + [0x125] = "Reserved", + [0x126] = "Reserved", + [0x127] = "Reserved", + [0x128] = "Reserved", + [0x129] = "Reserved", + [0x12a] = "Reserved", + [0x12b] = "Reserved", + [0x12c] = "Reserved", + [0x12d] = "Reserved", + [0x12e] = "Reserved", + [0x12f] = "Reserved", + [0x130] = "Reserved", + [0x131] = "Reserved", + [0x132] = "Reserved", + [0x133] = "Reserved", + [0x134] = "Reserved", + [0x135] = "Reserved", + [0x136] = "Reserved", + [0x137] = "Reserved", + [0x138] = "Reserved", + [0x139] = "Reserved", + [0x13a] = "Reserved", + [0x13b] = "Reserved", + [0x13c] = "Reserved", + [0x13d] = "Reserved", + [0x13e] = "Reserved", + [0x13f] = "Reserved", + [0x140] = "Reserved", + [0x141] = "Reserved", + [0x142] = "Reserved", + [0x143] = "Reserved", + [0x144] = "Reserved", + [0x145] = "Reserved", + [0x146] = "Reserved", + [0x147] = "Reserved", + [0x148] = "Reserved", + [0x149] = "Reserved", + [0x14a] = "Reserved", + [0x14b] = "Reserved", + [0x14c] = "Reserved", + [0x14d] = "Reserved", + [0x14e] = "Reserved", + [0x14f] = "Reserved", + [0x150] = "Balance Right", + [0x151] = "Balance Left", + [0x152] = "Bass Increment", + [0x153] = "Bass Decrement", + [0x154] = "Treble Increment", + [0x155] = "Treble Decrement", + [0x156] = "Reserved", + [0x157] = "Reserved", + [0x158] = "Reserved", + [0x159] = "Reserved", + [0x15a] = "Reserved", + [0x15b] = "Reserved", + [0x15c] = "Reserved", + [0x15d] = "Reserved", + [0x15e] = "Reserved", + [0x15f] = "Reserved", + [0x160] = "Speaker System", + [0x161] = "Channel Left", + [0x162] = "Channel Right", + [0x163] = "Channel Center", + [0x164] = "Channel Front", + [0x165] = "Channel Center Front", + [0x166] = "Channel Side", + [0x167] = "Channel Surround", + [0x168] = "Channel Low Frequency Enhancement", + [0x169] = "Channel Top", + [0x16a] = "Channel Unknown", + [0x16b] = "Reserved", + [0x16c] = "Reserved", + [0x16d] = "Reserved", + [0x16e] = "Reserved", + [0x16f] = "Reserved", + [0x170] = "Sub-channel", + [0x171] = "Sub-channel Increment", + [0x172] = "Sub-channel Decrement", + [0x173] = "Alternate Audio Increment", + [0x174] = "Alternate Audio Decrement", + [0x175] = "Reserved", + [0x176] = "Reserved", + [0x177] = "Reserved", + [0x178] = "Reserved", + [0x179] = "Reserved", + [0x17a] = "Reserved", + [0x17b] = "Reserved", + [0x17c] = "Reserved", + [0x17d] = "Reserved", + [0x17e] = "Reserved", + [0x17f] = "Reserved", + [0x180] = "Application Launch Buttons", + [0x181] = "AL Launch Buttion Configuration Tool", + [0x182] = "AL Programmable Button Configuration", + [0x183] = "AL Consumer Control Configuration", + [0x184] = "AL Word Processor", + [0x185] = "AL Text Editor", + [0x186] = "AL Spreadsheet", + [0x187] = "AL Graphics Editor", + [0x188] = "AL Presentation App", + [0x189] = "AL Database App", + [0x18a] = "AL Email Reader", + [0x18b] = "AL Newsreader", + [0x18c] = "AL Voicemail", + [0x18d] = "AL Contacts/Address Book", + [0x18e] = "AL Calendar/Schedule", + [0x18f] = "AL Task/Project Manager", + [0x190] = "AL Log/Journal/Timecard", + [0x191] = "AL Checkbook/Finance", + [0x192] = "AL Calculator", + [0x193] = "AL A/V Capture/Playback", + [0x194] = "AL Local Machine Browser", + [0x195] = "AL LAN/WAN Browser", + [0x196] = "AL Internet Browser", + [0x197] = "AL Remote Networking/ISP Connect", + [0x198] = "AL Network Conference", + [0x199] = "AL Network Chat", + [0x19a] = "AL Telephony/Dialer", + [0x19b] = "AL Logon", + [0x19c] = "AL Logoff", + [0x19d] = "AL Logon/Logoff", + [0x19e] = "AL Terminal Lock/Screensaver", + [0x19f] = "AL Control Panel", + [0x1a0] = "AL Command Line Processor/Run", + [0x1a1] = "AL Process/Task Manager", + [0x1a2] = "AL Select Task/Application", + [0x1a3] = "AL Next Task/Application", + [0x1a4] = "AL Previous Task/Application", + [0x1a5] = "AL Preemptive Halt Task/Application", + [0x1a6] = "AL Integrated Help Center", + [0x1a7] = "AL Documents", + [0x1a8] = "AL Thesaurus", + [0x1a9] = "AL Dictionary", + [0x1aa] = "AL Desktop", + [0x1ab] = "AL Spell Check", + [0x1ac] = "AL Grammar Check", + [0x1ad] = "AL Wireless Status", + [0x1ae] = "AL Keyboard Layout", + [0x1af] = "AL Virus Protection", + [0x1b0] = "AL Encryption", + [0x1b1] = "AL Screen Saver", + [0x1b2] = "AL Alarms", + [0x1b3] = "AL Clock", + [0x1b4] = "AL File Browser", + [0x1b5] = "AL Power Status", + [0x1b6] = "AL Image Browser", + [0x1b7] = "AL Audio Browser", + [0x1b8] = "AL Movie Browser", + [0x1b9] = "AL Digital Rights Manager", + [0x1ba] = "AL Digital Wallet", + [0x1bb] = "Reserved", + [0x1bc] = "AL Instant Messaging", + [0x1bd] = "AL OEM Features Tips/Tutorial Browser", + [0x1be] = "AL OEM Help", + [0x1bf] = "AL Online Community", + [0x1c0] = "AL Entertainment Content Browser", + [0x1c1] = "AL Online Shopping Browser", + [0x1c2] = "AL SmartCard Information/Help", + [0x1c3] = "AL Market Monitor/Finance Browser", + [0x1c4] = "AL Customized Corporate News Browser", + [0x1c5] = "AL Online Activity Browser", + [0x1c6] = "AL Research/Search Browser", + [0x1c7] = "AL Audio Player", + [0x1c8] = "Reserved", + [0x1c9] = "Reserved", + [0x1ca] = "Reserved", + [0x1cb] = "Reserved", + [0x1cc] = "Reserved", + [0x1cd] = "Reserved", + [0x1ce] = "Reserved", + [0x1cf] = "Reserved", + [0x1d0] = "Reserved", + [0x1d1] = "Reserved", + [0x1d2] = "Reserved", + [0x1d3] = "Reserved", + [0x1d4] = "Reserved", + [0x1d5] = "Reserved", + [0x1d6] = "Reserved", + [0x1d7] = "Reserved", + [0x1d8] = "Reserved", + [0x1d9] = "Reserved", + [0x1da] = "Reserved", + [0x1db] = "Reserved", + [0x1dc] = "Reserved", + [0x1dd] = "Reserved", + [0x1de] = "Reserved", + [0x1df] = "Reserved", + [0x1e0] = "Reserved", + [0x1e1] = "Reserved", + [0x1e2] = "Reserved", + [0x1e3] = "Reserved", + [0x1e4] = "Reserved", + [0x1e5] = "Reserved", + [0x1e6] = "Reserved", + [0x1e7] = "Reserved", + [0x1e8] = "Reserved", + [0x1e9] = "Reserved", + [0x1ea] = "Reserved", + [0x1eb] = "Reserved", + [0x1ec] = "Reserved", + [0x1ed] = "Reserved", + [0x1ee] = "Reserved", + [0x1ef] = "Reserved", + [0x1f0] = "Reserved", + [0x1f1] = "Reserved", + [0x1f2] = "Reserved", + [0x1f3] = "Reserved", + [0x1f4] = "Reserved", + [0x1f5] = "Reserved", + [0x1f6] = "Reserved", + [0x1f7] = "Reserved", + [0x1f8] = "Reserved", + [0x1f9] = "Reserved", + [0x1fa] = "Reserved", + [0x1fb] = "Reserved", + [0x1fc] = "Reserved", + [0x1fd] = "Reserved", + [0x1fe] = "Reserved", + [0x1ff] = "Reserved", + [0x200] = "Generic GUI Application Controls", + [0x201] = "AC New", + [0x202] = "AC Open", + [0x203] = "AC Close", + [0x204] = "AC Exit", + [0x205] = "AC Maximize", + [0x206] = "AC Minimize", + [0x207] = "AC Save", + [0x208] = "AC Print", + [0x209] = "AC Properties", + [0x20a] = "", + [0x20b] = "", + [0x20c] = "", + [0x20d] = "", + [0x20e] = "", + [0x20f] = "", + [0x210] = "", + [0x211] = "", + [0x212] = "", + [0x213] = "", + [0x214] = "", + [0x215] = "", + [0x216] = "", + [0x217] = "", + [0x218] = "", + [0x219] = "", + [0x21a] = "AC Undo", + [0x21b] = "AC Copy", + [0x21c] = "AC Cut", + [0x21d] = "AC Paste", + [0x21e] = "AC Select All", + [0x21f] = "AC Find", + [0x220] = "AC Find and Replace", + [0x221] = "AC Search", + [0x222] = "AC Go To", + [0x223] = "AC Home", + [0x224] = "AC Back", + [0x225] = "AC Forward", + [0x226] = "AC Stop", + [0x227] = "AC Refresh", + [0x228] = "AC Previous Link", + [0x229] = "AC Next Link", + [0x22a] = "AC Bookmarks", + [0x22b] = "AC History", + [0x22c] = "AC Subscriptions", + [0x22d] = "AC Zoom In", + [0x22e] = "AC Zoom Out", + [0x22f] = "AC Zoom", + [0x230] = "AC Full Screen View", + [0x231] = "AC Normal View", + [0x232] = "AC View Toggle", + [0x233] = "AC Scroll Up", + [0x234] = "AC Scroll Down", + [0x235] = "AC Scroll", + [0x236] = "AC Pan Left", + [0x237] = "AC Pan Right", + [0x238] = "AC Pan", + [0x239] = "AC New Window", + [0x23a] = "AC Tile Horizontally", + [0x23b] = "AC Tile Vertically", + [0x23c] = "AC Format", + [0x23d] = "AC Edit", + [0x23e] = "AC Bold", + [0x23f] = "AC Italics", + [0x240] = "AC Undeline", + [0x241] = "AC Strikethrough", + [0x242] = "AC Subscript", + [0x243] = "AC Superscript", + [0x244] = "AC All Caps", + [0x245] = "AC Rotate", + [0x246] = "AC Resize", + [0x247] = "AC Flip Horizontal", + [0x248] = "AC Flip Vertical", + [0x249] = "AC Mirror Horizontal", + [0x24a] = "AC Mirror Vertical", + [0x24b] = "AC Font Select", + [0x24c] = "AC Font Color", + [0x24d] = "AC Font Size", + [0x24e] = "AC Justify Left", + [0x24f] = "AC Justify Center H", + [0x250] = "AC Justify Right", + [0x251] = "AC Justify Block H", + [0x252] = "AC Justify Top", + [0x253] = "AC Justify Center V", + [0x254] = "AC Justify Bottom", + [0x255] = "AC Justify Block V", + [0x256] = "AC Indent Decrease", + [0x257] = "AC Indent Increase", + [0x258] = "AC Numbered List", + [0x259] = "AC Restart Numbering", + [0x25a] = "AC Bulleted List", + [0x25b] = "AC Promote", + [0x25c] = "AC Demote", + [0x25d] = "AC Yes", + [0x25e] = "AC No", + [0x25f] = "AC Cancel", + [0x260] = "AC Catalog", + [0x261] = "AC Buy/Checkout", + [0x262] = "AC Add to Cart", + [0x263] = "AC Expand", + [0x264] = "AC Expand All", + [0x265] = "AC Collapse", + [0x266] = "AC Collapse All", + [0x267] = "AC Print Preview", + [0x268] = "AC Paste Special", + [0x269] = "AC Insert Mode", + [0x26a] = "AC Delete", + [0x26b] = "AC Lock", + [0x26c] = "AC Unlock", + [0x26d] = "AC Protect", + [0x26e] = "AC Unprotect", + [0x26f] = "AC Attach Comment", + [0x270] = "AC Delete Comment", + [0x271] = "AC View Comment", + [0x272] = "AC Select Word", + [0x273] = "AC Select Sentence", + [0x274] = "AC Select Paragraph", + [0x275] = "AC Select Column", + [0x276] = "AC Select Row", + [0x277] = "AC Select Table", + [0x278] = "AC Select Object", + [0x279] = "AC Redo/Repeat", + [0x27a] = "AC Sort", + [0x27b] = "AC Sort Ascending", + [0x27c] = "AC Sort Descending", + [0x27d] = "AC Filter", + [0x27e] = "AC Set Clock", + [0x27f] = "AC View Clock", + [0x280] = "AC Select Time Zone", + [0x281] = "AC Edit Time Zones", + [0x282] = "AC Set Alarm", + [0x283] = "AC Clear Alarm", + [0x284] = "AC Snooze Alarm", + [0x285] = "AC Reset Alarm", + [0x286] = "AC Synchronize", + [0x287] = "AC Send/Receive", + [0x288] = "AC Send To", + [0x289] = "AC Reply", + [0x28a] = "AC Reply All", + [0x28b] = "AC Forward Msg", + [0x28c] = "AC Send", + [0x28d] = "AC Attach File", + [0x28e] = "AC Upload", + [0x28f] = "AC Download (Save Target As)", + [0x290] = "AC Set Borders", + [0x291] = "AC Insert Row", + [0x292] = "AC Insert Column", + [0x293] = "AC Insert File", + [0x294] = "AC Insert Picture", + [0x295] = "AC Insert Object", + [0x296] = "AC Insert Symbol", + [0x297] = "AC Save and Close", + [0x298] = "AC Rename", + [0x299] = "AC Merge", + [0x29a] = "AC Split", + [0x29b] = "AC Distrubute Horizontally", + [0x29c] = "AC Distrubute Vertically" +}; + +/** + * Translates USB HID Usages from the Consumer Page into their string + * representation. + * + * @param usage USB HID Consumer Page Usage number. + * + * @retval HelenOS key code corresponding to the given USB Consumer Page Usage. + */ +const char *usbhid_multimedia_usage_to_str(int usage) +{ + size_t map_length = sizeof(usbhid_consumer_usage_str) / sizeof(char *); + + if ((usage < 0) || ((size_t)usage >= map_length)) + return "Unknown usage"; + + /*! @todo What if the usage is not in the table? */ + return usbhid_consumer_usage_str[usage]; +} + +/** + * @} + */ Index: uspace/lib/usbhid/src/hiddescriptor.c =================================================================== --- uspace/lib/usbhid/src/hiddescriptor.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbhid/src/hiddescriptor.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,1068 @@ +/* + * Copyright (c) 2011 Matej Klonfar + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbhid + * @{ + */ +/** @file + * HID report descriptor and report data parser implementation. + */ +#include +#include +#include +#include +#include +#include +#include + +/*---------------------------------------------------------------------------*/ +/* + * Constants defining current parsing mode for correct parsing of the set of + * local tags (usage) enclosed in delimter tags. + */ +/** + * Second delimiter tag was read. The set of local items (usage) ended. + */ +#define OUTSIDE_DELIMITER_SET 0 + +/** + * First delimiter tag was read. The set of local items (usage) started. + */ +#define START_DELIMITER_SET 1 + +/** + * Parser is in the set of local items. + */ +#define INSIDE_DELIMITER_SET 2 + +/*---------------------------------------------------------------------------*/ + +/** The new report item flag. Used to determine when the item is completly + * configured and should be added to the report structure + */ +#define USB_HID_NEW_REPORT_ITEM 1 + +/** No special action after the report descriptor tag is processed should be + * done + */ +#define USB_HID_NO_ACTION 2 + +#define USB_HID_RESET_OFFSET 3 + +/** Unknown tag was founded in report descriptor data*/ +#define USB_HID_UNKNOWN_TAG -99 + +/*---------------------------------------------------------------------------*/ +/** + * Checks if given collection path is already present in report structure and + * inserts it if not. + * + * @param report Report structure + * @param cmp_path The collection path + * @return Pointer to the result collection path in report structure. + * @retval NULL If some error occurs + */ +usb_hid_report_path_t *usb_hid_report_path_try_insert( + usb_hid_report_t *report, usb_hid_report_path_t *cmp_path) { + + link_t *path_it = report->collection_paths.prev->next; + usb_hid_report_path_t *path = NULL; + + if((report == NULL) || (cmp_path == NULL)) { + return NULL; + } + + while(path_it != &report->collection_paths) { + path = list_get_instance(path_it, usb_hid_report_path_t, + link); + + if(usb_hid_report_compare_usage_path(path, cmp_path, + USB_HID_PATH_COMPARE_STRICT) == EOK){ + break; + } + path_it = path_it->next; + } + if(path_it == &report->collection_paths) { + path = usb_hid_report_path_clone(cmp_path); + if(path == NULL) { + return NULL; + } + list_append(&path->link, &report->collection_paths); + report->collection_paths_count++; + + return path; + } + else { + return list_get_instance(path_it, usb_hid_report_path_t, + link); + } +} + +/*---------------------------------------------------------------------------*/ +/** + * Initialize the report descriptor parser structure + * + * @param parser Report descriptor parser structure + * @return Error code + * @retval EINVAL If no report structure was given + * @retval EOK If report structure was successfully initialized + */ +int usb_hid_report_init(usb_hid_report_t *report) +{ + if(report == NULL) { + return EINVAL; + } + + memset(report, 0, sizeof(usb_hid_report_t)); + list_initialize(&report->reports); + list_initialize(&report->collection_paths); + + report->use_report_ids = 0; + return EOK; +} + +/*---------------------------------------------------------------------------*/ + +/** + * + * + * @param report Report structure in which the new report items should be + * stored + * @param report_item Current report descriptor's parsing state table + * @return Error code + * @retval EOK If all fields were successfully append to report + * @retval EINVAL If invalid parameters (NULL) was given + * @retval ENOMEM If there is no memmory to store new report description + * + */ +int usb_hid_report_append_fields(usb_hid_report_t *report, + usb_hid_report_item_t *report_item) { + + usb_hid_report_field_t *field; + int i; + + uint32_t *usages; + int usages_used=0; + + if((report == NULL) || (report_item == NULL)) { + return EINVAL; + } + + if(report_item->usages_count > 0){ + usages = malloc(sizeof(int32_t) * report_item->usages_count); + memcpy(usages, report_item->usages, sizeof(int32_t) * + report_item->usages_count); + } + else { + usages = NULL; + } + + usb_hid_report_path_t *path = report_item->usage_path; + for(i=0; icount; i++){ + + field = malloc(sizeof(usb_hid_report_field_t)); + if(field == NULL) { + return ENOMEM; + } + + memset(field, 0, sizeof(usb_hid_report_field_t)); + list_initialize(&field->link); + + /* fill the attributes */ + field->logical_minimum = report_item->logical_minimum; + field->logical_maximum = report_item->logical_maximum; + field->physical_minimum = report_item->physical_minimum; + field->physical_maximum = report_item->physical_maximum; + + if(USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) == 0){ + /* + Store usage array. The Correct Usage Page and Usage is + depending on data in report and will be filled later + */ + field->usage = 0; + field->usage_page = 0; //report_item->usage_page; + + field->usages_count = report_item->usages_count; + field->usages = usages; + usages_used = 1; + } + else { + + /* Fill the correct Usage and Usage Page */ + int32_t usage; + if(i < report_item->usages_count) { + usage = report_item->usages[i]; + } + else { + usage = report_item->usages[ + report_item->usages_count- 1]; + } + + if(USB_HID_IS_EXTENDED_USAGE(usage)){ + field->usage = USB_HID_EXTENDED_USAGE(usage); + field->usage_page = + USB_HID_EXTENDED_USAGE_PAGE(usage); + } + else { + // should not occur + field->usage = usage; + field->usage_page = report_item->usage_page; + } + } + + usb_hid_report_set_last_item(path, USB_HID_TAG_CLASS_GLOBAL, + field->usage_page); + usb_hid_report_set_last_item(path, USB_HID_TAG_CLASS_LOCAL, + field->usage); + + field->collection_path = + usb_hid_report_path_try_insert(report, path); + + field->size = report_item->size; + + if(report_item->type == USB_HID_REPORT_TYPE_INPUT) { + int offset = report_item->offset + report_item->size * i; + int field_offset = (offset/8)*8 + (offset/8 + 1) * 8 - + offset - report_item->size; + if(field_offset < 0) { + field->offset = 0; + } + else { + field->offset = field_offset; + } + } + else { + field->offset = report_item->offset + (i * report_item->size); + } + + + if(report->use_report_ids != 0) { + field->offset += 8; + report->use_report_ids = 1; + } + + field->item_flags = report_item->item_flags; + + /* find the right report list*/ + usb_hid_report_description_t *report_des; + report_des = usb_hid_report_find_description(report, + report_item->id, report_item->type); + + if(report_des == NULL){ + report_des = malloc( + sizeof(usb_hid_report_description_t)); + if(report_des == NULL) { + return ENOMEM; + } + + memset(report_des, 0, + sizeof(usb_hid_report_description_t)); + + report_des->type = report_item->type; + report_des->report_id = report_item->id; + if(report_des->report_id != 0) { + /* set up the bit length by report_id field */ + report_des->bit_length = 8; + } + + list_initialize (&report_des->link); + list_initialize (&report_des->report_items); + + list_append(&report_des->link, &report->reports); + report->report_count++; + } + + /* append this field to the end of founded report list */ + list_append (&field->link, &report_des->report_items); + + /* update the sizes */ + report_des->bit_length += field->size; + report_des->item_length++; + + } + + // free only when not used!!! + if(usages && usages_used == 0) { + free(usages); + } + + return EOK; +} +/*---------------------------------------------------------------------------*/ +/** + * Finds description of report with given report_id and of given type in + * opaque report structure. + * + * @param report Opaque structure containing the parsed report descriptor + * @param report_id ReportId of report we are searching + * @param type Type of report we are searching + * @return Pointer to the particular report description + * @retval NULL If no description is founded + */ +usb_hid_report_description_t * usb_hid_report_find_description( + const usb_hid_report_t *report, uint8_t report_id, + usb_hid_report_type_t type) { + + if(report == NULL) { + return NULL; + } + + link_t *report_it = report->reports.next; + usb_hid_report_description_t *report_des = NULL; + + while(report_it != &report->reports) { + report_des = list_get_instance(report_it, + usb_hid_report_description_t, link); + + // if report id not set, return the first of the type + if(((report_des->report_id == report_id) || (report_id == 0)) && + (report_des->type == type)) { + return report_des; + } + + report_it = report_it->next; + } + + return NULL; +} +/*---------------------------------------------------------------------------*/ + +/** Parse HID report descriptor. + * + * @param parser Opaque HID report parser structure. + * @param data Data describing the report. + * @return Error code. + * @retval ENOMEM If no more memmory is available + * @retval EINVAL If invalid data are founded + * @retval EOK If report descriptor is successfully parsed + */ +int usb_hid_parse_report_descriptor(usb_hid_report_t *report, + const uint8_t *data, size_t size) +{ + size_t i=0; + uint8_t tag=0; + uint8_t item_size=0; + int class=0; + int ret; + usb_hid_report_item_t *report_item=0; + usb_hid_report_item_t *new_report_item; + usb_hid_report_path_t *usage_path; + + size_t offset_input=0; + size_t offset_output=0; + size_t offset_feature=0; + + link_t stack; + list_initialize(&stack); + + /* parser structure initialization*/ + if(usb_hid_report_init(report) != EOK) { + return EINVAL; + } + + /*report item initialization*/ + if(!(report_item=malloc(sizeof(usb_hid_report_item_t)))){ + return ENOMEM; + } + memset(report_item, 0, sizeof(usb_hid_report_item_t)); + list_initialize(&(report_item->link)); + + /* usage path context initialization */ + if(!(usage_path=usb_hid_report_path())){ + return ENOMEM; + } + usb_hid_report_path_append_item(usage_path, 0, 0); + + while(i= size){ + return EINVAL; + } + + tag = USB_HID_ITEM_TAG(data[i]); + item_size = USB_HID_ITEM_SIZE(data[i]); + class = USB_HID_ITEM_TAG_CLASS(data[i]); + + ret = usb_hid_report_parse_tag(tag,class,data+i+1, + item_size,report_item, usage_path); + + switch(ret){ + case USB_HID_NEW_REPORT_ITEM: + /* store report item to report and create the + * new one store current collection path + */ + report_item->usage_path = usage_path; + + usb_hid_report_path_set_report_id( + report_item->usage_path, report_item->id); + + if(report_item->id != 0){ + report->use_report_ids = 1; + } + + switch(tag) { + case USB_HID_REPORT_TAG_INPUT: + report_item->type = + USB_HID_REPORT_TYPE_INPUT; + + report_item->offset = offset_input; + offset_input += report_item->count * + report_item->size; + break; + + case USB_HID_REPORT_TAG_OUTPUT: + report_item->type = + USB_HID_REPORT_TYPE_OUTPUT; + + report_item->offset = offset_output; + offset_output += report_item->count * + report_item->size; + break; + + case USB_HID_REPORT_TAG_FEATURE: + report_item->type = + USB_HID_REPORT_TYPE_FEATURE; + + report_item->offset = offset_feature; + offset_feature += report_item->count * + report_item->size; + break; + + default: + usb_log_debug2( + "\tjump over - tag %X\n", tag); + break; + } + + /* + * append new fields to the report structure + */ + usb_hid_report_append_fields(report, + report_item); + + /* reset local items */ + usb_hid_report_reset_local_items (report_item); + break; + + case USB_HID_RESET_OFFSET: + offset_input = 0; + offset_output = 0; + offset_feature = 0; + usb_hid_report_path_set_report_id (usage_path, + report_item->id); + break; + + case USB_HID_REPORT_TAG_PUSH: + // push current state to stack + new_report_item = usb_hid_report_item_clone( + report_item); + + usb_hid_report_path_t *tmp_path = + usb_hid_report_path_clone(usage_path); + + new_report_item->usage_path = tmp_path; + + list_prepend (&new_report_item->link, &stack); + break; + case USB_HID_REPORT_TAG_POP: + // restore current state from stack + if(list_empty (&stack)) { + return EINVAL; + } + free(report_item); + + report_item = list_get_instance(stack.next, + usb_hid_report_item_t, link); + + usb_hid_report_usage_path_t *tmp_usage_path; + tmp_usage_path = list_get_instance( + report_item->usage_path->link.prev, + usb_hid_report_usage_path_t, link); + + usb_hid_report_set_last_item(usage_path, + USB_HID_TAG_CLASS_GLOBAL, tmp_usage_path->usage_page); + + usb_hid_report_set_last_item(usage_path, + USB_HID_TAG_CLASS_LOCAL, tmp_usage_path->usage); + + usb_hid_report_path_free(report_item->usage_path); + list_initialize(&report_item->usage_path->link); + list_remove (stack.next); + + break; + + default: + // nothing special to do + break; + } + + /* jump over the processed block */ + i += 1 + USB_HID_ITEM_SIZE(data[i]); + } + else{ + // TBD + i += 3 + USB_HID_ITEM_SIZE(data[i+1]); + } + + + } + + return EOK; +} + +/*---------------------------------------------------------------------------*/ + +/** + * Parse one tag of the report descriptor + * + * @param Tag to parse + * @param Report descriptor buffer + * @param Size of data belongs to this tag + * @param Current report item structe + * @return Code of action to be done next + */ +int usb_hid_report_parse_tag(uint8_t tag, uint8_t class, const uint8_t *data, + size_t item_size, usb_hid_report_item_t *report_item, + usb_hid_report_path_t *usage_path) { + + int ret; + + switch(class){ + case USB_HID_TAG_CLASS_MAIN: + + if((ret=usb_hid_report_parse_main_tag(tag, data, item_size, + report_item, usage_path)) == EOK) { + + return USB_HID_NEW_REPORT_ITEM; + } + else { + return ret; + } + break; + + case USB_HID_TAG_CLASS_GLOBAL: + return usb_hid_report_parse_global_tag(tag, data, item_size, + report_item, usage_path); + break; + + case USB_HID_TAG_CLASS_LOCAL: + return usb_hid_report_parse_local_tag(tag, data, item_size, + report_item, usage_path); + break; + + default: + return USB_HID_NO_ACTION; + } +} + +/** + * Parse main tags of report descriptor + * + * @param Tag identifier + * @param Data buffer + * @param Length of data buffer + * @param Current state table + * @return Error code + */ + +int usb_hid_report_parse_main_tag(uint8_t tag, const uint8_t *data, + size_t item_size, usb_hid_report_item_t *report_item, + usb_hid_report_path_t *usage_path) +{ + usb_hid_report_usage_path_t *path_item; + + switch(tag) + { + case USB_HID_REPORT_TAG_INPUT: + case USB_HID_REPORT_TAG_OUTPUT: + case USB_HID_REPORT_TAG_FEATURE: + report_item->item_flags = *data; + return EOK; + break; + + case USB_HID_REPORT_TAG_COLLECTION: + + /* store collection atributes */ + path_item = list_get_instance(usage_path->head.prev, + usb_hid_report_usage_path_t, link); + path_item->flags = *data; + + /* set last item */ + usb_hid_report_set_last_item(usage_path, + USB_HID_TAG_CLASS_GLOBAL, + USB_HID_EXTENDED_USAGE_PAGE(report_item->usages[ + report_item->usages_count-1])); + + usb_hid_report_set_last_item(usage_path, + USB_HID_TAG_CLASS_LOCAL, + USB_HID_EXTENDED_USAGE(report_item->usages[ + report_item->usages_count-1])); + + /* append the new one which will be set by common usage/usage + * page */ + usb_hid_report_path_append_item(usage_path, + report_item->usage_page, + report_item->usages[report_item->usages_count-1]); + + usb_hid_report_reset_local_items (report_item); + return USB_HID_NO_ACTION; + break; + + case USB_HID_REPORT_TAG_END_COLLECTION: + usb_hid_report_remove_last_item(usage_path); + return USB_HID_NO_ACTION; + break; + + default: + return USB_HID_NO_ACTION; + } + + return EOK; +} + +/** + * Parse global tags of report descriptor + * + * @param Tag identifier + * @param Data buffer + * @param Length of data buffer + * @param Current state table + * @return Error code + */ +int usb_hid_report_parse_global_tag(uint8_t tag, const uint8_t *data, + size_t item_size, usb_hid_report_item_t *report_item, + usb_hid_report_path_t *usage_path) { + + switch(tag) + { + case USB_HID_REPORT_TAG_USAGE_PAGE: + report_item->usage_page = + usb_hid_report_tag_data_uint32(data, item_size); + break; + + case USB_HID_REPORT_TAG_LOGICAL_MINIMUM: + report_item->logical_minimum = USB_HID_UINT32_TO_INT32( + usb_hid_report_tag_data_uint32(data,item_size), + item_size * 8); + break; + + case USB_HID_REPORT_TAG_LOGICAL_MAXIMUM: + report_item->logical_maximum = USB_HID_UINT32_TO_INT32( + usb_hid_report_tag_data_uint32(data,item_size), + item_size * 8); + break; + + case USB_HID_REPORT_TAG_PHYSICAL_MINIMUM: + report_item->physical_minimum = USB_HID_UINT32_TO_INT32( + usb_hid_report_tag_data_uint32(data,item_size), + item_size * 8); + break; + + case USB_HID_REPORT_TAG_PHYSICAL_MAXIMUM: + report_item->physical_maximum = USB_HID_UINT32_TO_INT32( + usb_hid_report_tag_data_uint32(data,item_size), + item_size * 8); + break; + + case USB_HID_REPORT_TAG_UNIT_EXPONENT: + report_item->unit_exponent = usb_hid_report_tag_data_uint32( + data,item_size); + break; + + case USB_HID_REPORT_TAG_UNIT: + report_item->unit = usb_hid_report_tag_data_uint32( + data,item_size); + break; + + case USB_HID_REPORT_TAG_REPORT_SIZE: + report_item->size = usb_hid_report_tag_data_uint32( + data,item_size); + break; + + case USB_HID_REPORT_TAG_REPORT_COUNT: + report_item->count = usb_hid_report_tag_data_uint32( + data,item_size); + break; + + case USB_HID_REPORT_TAG_REPORT_ID: + report_item->id = usb_hid_report_tag_data_uint32(data, + item_size); + return USB_HID_RESET_OFFSET; + break; + + case USB_HID_REPORT_TAG_PUSH: + case USB_HID_REPORT_TAG_POP: + /* + * stack operations are done in top level parsing + * function + */ + return tag; + break; + + default: + return USB_HID_NO_ACTION; + } + + return EOK; +} + +/** + * Parse local tags of report descriptor + * + * @param Tag identifier + * @param Data buffer + * @param Length of data buffer + * @param Current state table + * @return Error code + */ +int usb_hid_report_parse_local_tag(uint8_t tag, const uint8_t *data, + size_t item_size, usb_hid_report_item_t *report_item, + usb_hid_report_path_t *usage_path) +{ + int32_t extended_usage; + + switch(tag) { + case USB_HID_REPORT_TAG_USAGE: + switch(report_item->in_delimiter) { + case INSIDE_DELIMITER_SET: + /* nothing to do + * we catch only the first one + */ + break; + + case START_DELIMITER_SET: + report_item->in_delimiter = INSIDE_DELIMITER_SET; + case OUTSIDE_DELIMITER_SET: + extended_usage = ((report_item->usage_page) << 16); + extended_usage += usb_hid_report_tag_data_uint32( + data,item_size); + + report_item->usages[report_item->usages_count] = + extended_usage; + + report_item->usages_count++; + break; + } + break; + + case USB_HID_REPORT_TAG_USAGE_MINIMUM: + if (item_size == 3) { + // usage extended usages + report_item->extended_usage_page = + USB_HID_EXTENDED_USAGE_PAGE( + usb_hid_report_tag_data_uint32(data,item_size)); + + + report_item->usage_minimum = + USB_HID_EXTENDED_USAGE( + usb_hid_report_tag_data_uint32(data,item_size)); + } + else { + report_item->usage_minimum = + usb_hid_report_tag_data_uint32(data,item_size); + } + break; + + case USB_HID_REPORT_TAG_USAGE_MAXIMUM: + if (item_size == 3) { + if(report_item->extended_usage_page != + USB_HID_EXTENDED_USAGE_PAGE( + usb_hid_report_tag_data_uint32(data,item_size))) { + + return EINVAL; + } + + // usage extended usages + report_item->extended_usage_page = + USB_HID_EXTENDED_USAGE_PAGE( + usb_hid_report_tag_data_uint32(data,item_size)); + + report_item->usage_maximum = + USB_HID_EXTENDED_USAGE( + usb_hid_report_tag_data_uint32(data,item_size)); + } + else { + report_item->usage_maximum = + usb_hid_report_tag_data_uint32(data,item_size); + } + + // vlozit zaznamy do pole usages + int32_t i; + for(i = report_item->usage_minimum; + i <= report_item->usage_maximum; i++) { + + if(report_item->extended_usage_page) { + report_item->usages[report_item->usages_count++] = + (report_item->extended_usage_page << 16) + i; + } + else { + report_item->usages[report_item->usages_count++] = + (report_item->usage_page << 16) + i; + } + } + report_item->extended_usage_page = 0; + + break; + + case USB_HID_REPORT_TAG_DESIGNATOR_INDEX: + report_item->designator_index = + usb_hid_report_tag_data_uint32(data,item_size); + break; + + case USB_HID_REPORT_TAG_DESIGNATOR_MINIMUM: + report_item->designator_minimum = + usb_hid_report_tag_data_uint32(data,item_size); + break; + + case USB_HID_REPORT_TAG_DESIGNATOR_MAXIMUM: + report_item->designator_maximum = + usb_hid_report_tag_data_uint32(data,item_size); + break; + + case USB_HID_REPORT_TAG_STRING_INDEX: + report_item->string_index = + usb_hid_report_tag_data_uint32(data,item_size); + break; + + case USB_HID_REPORT_TAG_STRING_MINIMUM: + report_item->string_minimum = + usb_hid_report_tag_data_uint32(data,item_size); + break; + + case USB_HID_REPORT_TAG_STRING_MAXIMUM: + report_item->string_maximum = + usb_hid_report_tag_data_uint32(data,item_size); + break; + + case USB_HID_REPORT_TAG_DELIMITER: + report_item->in_delimiter = + usb_hid_report_tag_data_uint32(data,item_size); + break; + + default: + return USB_HID_NO_ACTION; + } + + return EOK; +} +/*---------------------------------------------------------------------------*/ + +/** + * Converts raw data to uint32 (thats the maximum length of short item data) + * + * @param Data buffer + * @param Size of buffer + * @return Converted int32 number + */ +uint32_t usb_hid_report_tag_data_uint32(const uint8_t *data, size_t size) +{ + unsigned int i; + uint32_t result; + + result = 0; + for(i=0; inext; item != head; item = item->next) { + + report_item = list_get_instance(item, usb_hid_report_field_t, + link); + + usb_log_debug("\t\tOFFSET: %X\n", report_item->offset); + usb_log_debug("\t\tSIZE: %zu\n", report_item->size); + usb_log_debug("\t\tLOGMIN: %d\n", + report_item->logical_minimum); + usb_log_debug("\t\tLOGMAX: %d\n", + report_item->logical_maximum); + usb_log_debug("\t\tPHYMIN: %d\n", + report_item->physical_minimum); + usb_log_debug("\t\tPHYMAX: %d\n", + report_item->physical_maximum); + usb_log_debug("\t\ttUSAGEMIN: %X\n", + report_item->usage_minimum); + usb_log_debug("\t\tUSAGEMAX: %X\n", + report_item->usage_maximum); + usb_log_debug("\t\tUSAGES COUNT: %zu\n", + report_item->usages_count); + + usb_log_debug("\t\tVALUE: %X\n", report_item->value); + usb_log_debug("\t\ttUSAGE: %X\n", report_item->usage); + usb_log_debug("\t\tUSAGE PAGE: %X\n", report_item->usage_page); + + usb_hid_print_usage_path(report_item->collection_path); + + usb_log_debug("\n"); + + } + +} +/*---------------------------------------------------------------------------*/ + +/** + * Prints content of given report descriptor in human readable format. + * + * @param parser Parsed descriptor to print + * @return void + */ +void usb_hid_descriptor_print(usb_hid_report_t *report) +{ + if(report == NULL) { + return; + } + + link_t *report_it = report->reports.next; + usb_hid_report_description_t *report_des; + + while(report_it != &report->reports) { + report_des = list_get_instance(report_it, + usb_hid_report_description_t, link); + usb_log_debug("Report ID: %d\n", report_des->report_id); + usb_log_debug("\tType: %d\n", report_des->type); + usb_log_debug("\tLength: %zu\n", report_des->bit_length); + usb_log_debug("\tB Size: %zu\n", + usb_hid_report_byte_size(report, + report_des->report_id, + report_des->type)); + usb_log_debug("\tItems: %zu\n", report_des->item_length); + + usb_hid_descriptor_print_list(&report_des->report_items); + + report_it = report_it->next; + } +} +/*---------------------------------------------------------------------------*/ + +/** + * Releases whole linked list of report items + * + * @param head Head of list of report descriptor items (usb_hid_report_item_t) + * @return void + */ +void usb_hid_free_report_list(link_t *head) +{ + return; + + usb_hid_report_item_t *report_item; + link_t *next; + + if(head == NULL || list_empty(head)) { + return; + } + + next = head->next; + while(next != head) { + + report_item = list_get_instance(next, usb_hid_report_item_t, link); + + while(!list_empty(&report_item->usage_path->link)) { + usb_hid_report_remove_last_item(report_item->usage_path); + } + + + next = next->next; + + free(report_item); + } + + return; + +} +/*---------------------------------------------------------------------------*/ + +/** Frees the HID report descriptor parser structure + * + * @param parser Opaque HID report parser structure + * @return void + */ +void usb_hid_free_report(usb_hid_report_t *report) +{ + if(report == NULL){ + return; + } + + // free collection paths + usb_hid_report_path_t *path; + while(!list_empty(&report->collection_paths)) { + path = list_get_instance(report->collection_paths.next, + usb_hid_report_path_t, link); + + usb_hid_report_path_free(path); + } + + // free report items + usb_hid_report_description_t *report_des; + usb_hid_report_field_t *field; + while(!list_empty(&report->reports)) { + report_des = list_get_instance(report->reports.next, + usb_hid_report_description_t, link); + + list_remove(&report_des->link); + + while(!list_empty(&report_des->report_items)) { + field = list_get_instance( + report_des->report_items.next, + usb_hid_report_field_t, link); + + list_remove(&field->link); + + free(field); + } + + free(report_des); + } + + return; +} +/*---------------------------------------------------------------------------*/ + +/** + * @} + */ Index: uspace/lib/usbhid/src/hidiface.c =================================================================== --- uspace/lib/usbhid/src/hidiface.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbhid/src/hidiface.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,238 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbhid + * @{ + */ +/** @file + * Client functions for accessing USB HID interface (implementation). + */ +#include +#include +#include +#include +#include +#include +#include + +/** Ask for event array length. + * + * @param dev_sess Session to DDF device providing USB HID interface. + * + * @return Number of usages returned or negative error code. + * + */ +int usbhid_dev_get_event_length(async_sess_t *dev_sess, size_t *size) +{ + if (!dev_sess) + return EINVAL; + + async_exch_t *exch = async_exchange_begin(dev_sess); + + sysarg_t len; + int rc = async_req_1_1(exch, DEV_IFACE_ID(USBHID_DEV_IFACE), + IPC_M_USBHID_GET_EVENT_LENGTH, &len); + + async_exchange_end(exch); + + if (rc == EOK) { + if (size != NULL) + *size = (size_t) len; + } + + return rc; +} + +/** Request for next event from HID device. + * + * @param[in] dev_sess Session to DDF device providing USB HID interface. + * @param[out] usage_pages Where to store usage pages. + * @param[out] usages Where to store usages (actual data). + * @param[in] usage_count Length of @p usage_pages and @p usages buffer + * (in items, not bytes). + * @param[out] actual_usage_count Number of usages actually returned by the + * device driver. + * @param[in] flags Flags (see USBHID_IFACE_FLAG_*). + * + * @return Error code. + * + */ +int usbhid_dev_get_event(async_sess_t *dev_sess, uint8_t *buf, + size_t size, size_t *actual_size, int *event_nr, unsigned int flags) +{ + if (!dev_sess) + return EINVAL; + + if ((buf == NULL)) + return ENOMEM; + + if (size == 0) + return EINVAL; + + size_t buffer_size = size; + uint8_t *buffer = malloc(buffer_size); + if (buffer == NULL) + return ENOMEM; + + async_exch_t *exch = async_exchange_begin(dev_sess); + + ipc_call_t opening_request_call; + aid_t opening_request = async_send_2(exch, + DEV_IFACE_ID(USBHID_DEV_IFACE), IPC_M_USBHID_GET_EVENT, + flags, &opening_request_call); + + if (opening_request == 0) { + async_exchange_end(exch); + free(buffer); + return ENOMEM; + } + + ipc_call_t data_request_call; + aid_t data_request = async_data_read(exch, buffer, buffer_size, + &data_request_call); + + async_exchange_end(exch); + + if (data_request == 0) { + async_wait_for(opening_request, NULL); + free(buffer); + return ENOMEM; + } + + sysarg_t data_request_rc; + sysarg_t opening_request_rc; + async_wait_for(data_request, &data_request_rc); + async_wait_for(opening_request, &opening_request_rc); + + if (data_request_rc != EOK) { + /* Prefer return code of the opening request. */ + if (opening_request_rc != EOK) + return (int) opening_request_rc; + else + return (int) data_request_rc; + } + + if (opening_request_rc != EOK) + return (int) opening_request_rc; + + size_t act_size = IPC_GET_ARG2(data_request_call); + + /* Copy the individual items. */ + memcpy(buf, buffer, act_size); + + if (actual_size != NULL) + *actual_size = act_size; + + if (event_nr != NULL) + *event_nr = IPC_GET_ARG1(opening_request_call); + + return EOK; +} + +int usbhid_dev_get_report_descriptor_length(async_sess_t *dev_sess, + size_t *size) +{ + if (!dev_sess) + return EINVAL; + + async_exch_t *exch = async_exchange_begin(dev_sess); + + sysarg_t arg_size; + int rc = async_req_1_1(exch, DEV_IFACE_ID(USBHID_DEV_IFACE), + IPC_M_USBHID_GET_REPORT_DESCRIPTOR_LENGTH, &arg_size); + + async_exchange_end(exch); + + if (rc == EOK) { + if (size != NULL) + *size = (size_t) arg_size; + } + + return rc; +} + +int usbhid_dev_get_report_descriptor(async_sess_t *dev_sess, uint8_t *buf, + size_t size, size_t *actual_size) +{ + if (!dev_sess) + return EINVAL; + + if ((buf == NULL)) + return ENOMEM; + + if (size == 0) + return EINVAL; + + async_exch_t *exch = async_exchange_begin(dev_sess); + + aid_t opening_request = async_send_1(exch, + DEV_IFACE_ID(USBHID_DEV_IFACE), IPC_M_USBHID_GET_REPORT_DESCRIPTOR, + NULL); + if (opening_request == 0) { + async_exchange_end(exch); + return ENOMEM; + } + + ipc_call_t data_request_call; + aid_t data_request = async_data_read(exch, buf, size, + &data_request_call); + + async_exchange_end(exch); + + if (data_request == 0) { + async_wait_for(opening_request, NULL); + return ENOMEM; + } + + sysarg_t data_request_rc; + sysarg_t opening_request_rc; + async_wait_for(data_request, &data_request_rc); + async_wait_for(opening_request, &opening_request_rc); + + if (data_request_rc != EOK) { + /* Prefer return code of the opening request. */ + if (opening_request_rc != EOK) + return (int) opening_request_rc; + else + return (int) data_request_rc; + } + + if (opening_request_rc != EOK) + return (int) opening_request_rc; + + size_t act_size = IPC_GET_ARG2(data_request_call); + + if (actual_size != NULL) + *actual_size = act_size; + + return EOK; +} + +/** + * @} + */ Index: uspace/lib/usbhid/src/hidparser.c =================================================================== --- uspace/lib/usbhid/src/hidparser.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbhid/src/hidparser.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,666 @@ +/* + * Copyright (c) 2011 Matej Klonfar + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbhid + * @{ + */ +/** @file + * USB HID report data parser implementation. + */ +#include +#include +#include +#include +#include +#include +#include + +/*---------------------------------------------------------------------------*/ +/* + * Data translation private functions + */ +uint32_t usb_hid_report_tag_data_uint32(const uint8_t *data, size_t size); + +int usb_hid_translate_data(usb_hid_report_field_t *item, const uint8_t *data); + +uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item, + int32_t value); + +int usb_pow(int a, int b); + +/*---------------------------------------------------------------------------*/ + +// TODO: tohle ma bejt asi jinde +int usb_pow(int a, int b) +{ + switch(b) { + case 0: + return 1; + break; + case 1: + return a; + break; + default: + return a * usb_pow(a, b-1); + break; + } +} +/*---------------------------------------------------------------------------*/ + +/** Returns size of report of specified report id and type in items + * + * @param parser Opaque report parser structure + * @param report_id + * @param type + * @return Number of items in specified report + */ +size_t usb_hid_report_size(usb_hid_report_t *report, uint8_t report_id, + usb_hid_report_type_t type) +{ + usb_hid_report_description_t *report_des; + + if(report == NULL) { + return 0; + } + + report_des = usb_hid_report_find_description (report, report_id, type); + if(report_des == NULL){ + return 0; + } + else { + return report_des->item_length; + } +} + +/** Returns size of report of specified report id and type in bytes + * + * @param parser Opaque report parser structure + * @param report_id + * @param type + * @return Number of items in specified report + */ +size_t usb_hid_report_byte_size(usb_hid_report_t *report, uint8_t report_id, + usb_hid_report_type_t type) +{ + usb_hid_report_description_t *report_des; + + if(report == NULL) { + return 0; + } + + report_des = usb_hid_report_find_description (report, report_id, type); + if(report_des == NULL){ + return 0; + } + else { + return ((report_des->bit_length + 7) / 8) ; + } +} +/*---------------------------------------------------------------------------*/ + +/** Parse and act upon a HID report. + * + * @see usb_hid_parse_report_descriptor + * + * @param parser Opaque HID report parser structure. + * @param data Data for the report. + * @return Error code. + */ +int usb_hid_parse_report(const usb_hid_report_t *report, const uint8_t *data, + size_t size, uint8_t *report_id) +{ + link_t *list_item; + usb_hid_report_field_t *item; + + usb_hid_report_description_t *report_des; + usb_hid_report_type_t type = USB_HID_REPORT_TYPE_INPUT; + + if(report == NULL) { + return EINVAL; + } + + if(report->use_report_ids != 0) { + *report_id = data[0]; + } + else { + *report_id = 0; + } + + + report_des = usb_hid_report_find_description(report, *report_id, + type); + + if(report_des == NULL) { + return EINVAL; + } + + /* read data */ + list_item = report_des->report_items.next; + while(list_item != &(report_des->report_items)) { + + item = list_get_instance(list_item, usb_hid_report_field_t, + link); + + if(USB_HID_ITEM_FLAG_CONSTANT(item->item_flags) == 0) { + + if(USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0){ + + // array + item->value = + usb_hid_translate_data(item, data); + + item->usage = USB_HID_EXTENDED_USAGE( + item->usages[ + item->value - item->physical_minimum]); + + item->usage_page = + USB_HID_EXTENDED_USAGE_PAGE( + item->usages[ + item->value - item->physical_minimum]); + + usb_hid_report_set_last_item ( + item->collection_path, + USB_HID_TAG_CLASS_GLOBAL, + item->usage_page); + + usb_hid_report_set_last_item ( + item->collection_path, + USB_HID_TAG_CLASS_LOCAL, item->usage); + + } + else { + // variable item + item->value = usb_hid_translate_data(item, + data); + } + } + list_item = list_item->next; + } + + return EOK; + +} + +/*---------------------------------------------------------------------------*/ +/** + * Translate data from the report as specified in report descriptor item + * + * @param item Report descriptor item with definition of translation + * @param data Data to translate + * @return Translated data + */ +int usb_hid_translate_data(usb_hid_report_field_t *item, const uint8_t *data) +{ + int resolution; + int offset; + int part_size; + + int32_t value=0; + int32_t mask=0; + const uint8_t *foo=0; + + // now only shot tags are allowed + if(item->size > 32) { + return 0; + } + + if((item->physical_minimum == 0) && (item->physical_maximum == 0)){ + item->physical_minimum = item->logical_minimum; + item->physical_maximum = item->logical_maximum; + } + + + if(item->physical_maximum == item->physical_minimum){ + resolution = 1; + } + else { + resolution = (item->logical_maximum - item->logical_minimum) / + ((item->physical_maximum - item->physical_minimum) * + (usb_pow(10,(item->unit_exponent)))); + } + + offset = item->offset; + // FIXME + if((size_t)(offset/8) != (size_t)((offset+item->size-1)/8)) { + + part_size = 0; + + size_t i=0; + for(i=(size_t)(offset/8); i<=(size_t)(offset+item->size-1)/8; i++){ + if(i == (size_t)(offset/8)) { + // the higher one + part_size = 8 - (offset % 8); + foo = data + i; + mask = ((1 << (item->size-part_size))-1); + value = (*foo & mask); + } + else if(i == ((offset+item->size-1)/8)){ + // the lower one + foo = data + i; + mask = ((1 << (item->size - part_size)) - 1) + << (8 - (item->size - part_size)); + + value = (((*foo & mask) >> (8 - + (item->size - part_size))) << part_size ) + + value; + } + else { + value = (*(data + 1) << (part_size + 8)) + value; + part_size += 8; + } + } + } + else { + foo = data+(offset/8); + mask = ((1 << item->size)-1) << (8-((offset%8)+item->size)); + value = (*foo & mask) >> (8-((offset%8)+item->size)); + } + + if((item->logical_minimum < 0) || (item->logical_maximum < 0)){ + value = USB_HID_UINT32_TO_INT32(value, item->size); + } + + return (int)(((value - item->logical_minimum) / resolution) + + item->physical_minimum); + +} + +/*---------------------------------------------------------------------------*/ +/* OUTPUT API */ + +/** + * Allocates output report buffer for output report + * + * @param parser Report parsed structure + * @param size Size of returned buffer + * @param report_id Report id of created output report + * @return Returns allocated output buffer for specified output + */ +uint8_t *usb_hid_report_output(usb_hid_report_t *report, size_t *size, + uint8_t report_id) +{ + if(report == NULL) { + *size = 0; + return NULL; + } + + link_t *report_it = report->reports.next; + usb_hid_report_description_t *report_des = NULL; + while(report_it != &report->reports) { + report_des = list_get_instance(report_it, + usb_hid_report_description_t, link); + + if((report_des->report_id == report_id) && + (report_des->type == USB_HID_REPORT_TYPE_OUTPUT)){ + break; + } + + report_it = report_it->next; + } + + if(report_des == NULL){ + *size = 0; + return NULL; + } + else { + *size = (report_des->bit_length + (8 - 1))/8; + uint8_t *ret = malloc((*size) * sizeof(uint8_t)); + memset(ret, 0, (*size) * sizeof(uint8_t)); + return ret; + } +} + + +/** Frees output report buffer + * + * @param output Output report buffer + * @return void + */ +void usb_hid_report_output_free(uint8_t *output) + +{ + if(output != NULL) { + free (output); + } +} + +/** Makes the output report buffer for data given in the report structure + * + * @param parser Opaque report parser structure + * @param path Usage path specifing which parts of output will be set + * @param flags Usage path structure comparison flags + * @param buffer Output buffer + * @param size Size of output buffer + * @return Error code + */ +int usb_hid_report_output_translate(usb_hid_report_t *report, + uint8_t report_id, uint8_t *buffer, size_t size) +{ + link_t *item; + int32_t value=0; + int offset; + int length; + int32_t tmp_value; + + if(report == NULL) { + return EINVAL; + } + + if(report->use_report_ids != 0) { + buffer[0] = report_id; + } + + usb_hid_report_description_t *report_des; + report_des = usb_hid_report_find_description (report, report_id, + USB_HID_REPORT_TYPE_OUTPUT); + + if(report_des == NULL){ + return EINVAL; + } + + usb_hid_report_field_t *report_item; + item = report_des->report_items.next; + while(item != &report_des->report_items) { + report_item = list_get_instance(item, usb_hid_report_field_t, link); + + value = usb_hid_translate_data_reverse(report_item, + report_item->value); + + offset = report_des->bit_length - report_item->offset - 1; + length = report_item->size; + + usb_log_debug("\ttranslated value: %x\n", value); + + if((offset/8) == ((offset+length-1)/8)) { + // je to v jednom bytu + if(((size_t)(offset/8) >= size) || + ((size_t)(offset+length-1)/8) >= size) { + break; // TODO ErrorCode + } + size_t shift = 8 - offset%8 - length; + value = value << shift; + value = value & (((1 << length)-1) << shift); + + uint8_t mask = 0; + mask = 0xff - (((1 << length) - 1) << shift); + buffer[offset/8] = (buffer[offset/8] & mask) | value; + } + else { + int i = 0; + uint8_t mask = 0; + for(i = (offset/8); i <= ((offset+length-1)/8); i++) { + if(i == (offset/8)) { + tmp_value = value; + tmp_value = tmp_value & + ((1 << (8-(offset%8)))-1); + + tmp_value = tmp_value << (offset%8); + + mask = ~(((1 << (8-(offset%8)))-1) << + (offset%8)); + + buffer[i] = (buffer[i] & mask) | + tmp_value; + } + else if (i == ((offset + length -1)/8)) { + + value = value >> (length - + ((offset + length) % 8)); + + value = value & ((1 << (length - + ((offset + length) % 8))) - 1); + + mask = (1 << (length - + ((offset + length) % 8))) - 1; + + buffer[i] = (buffer[i] & mask) | value; + } + else { + buffer[i] = value & (0xFF << i); + } + } + } + + // reset value + report_item->value = 0; + + item = item->next; + } + + return EOK; +} + +/*---------------------------------------------------------------------------*/ +/** + * Translate given data for putting them into the outoput report + * @param item Report item structure + * @param value Value to translate + * @return ranslated value + */ +uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item, + int value) +{ + int ret=0; + int resolution; + + if(USB_HID_ITEM_FLAG_CONSTANT(item->item_flags)) { + ret = item->logical_minimum; + } + + if((item->physical_minimum == 0) && (item->physical_maximum == 0)){ + item->physical_minimum = item->logical_minimum; + item->physical_maximum = item->logical_maximum; + } + + // variable item + if(item->physical_maximum == item->physical_minimum){ + resolution = 1; + } + else { + resolution = (item->logical_maximum - item->logical_minimum) / + ((item->physical_maximum - item->physical_minimum) * + (usb_pow(10,(item->unit_exponent)))); + } + + ret = ((value - item->physical_minimum) * resolution) + + item->logical_minimum; + + usb_log_debug("\tvalue(%x), resolution(%x), phymin(%x) logmin(%x), \ + ret(%x)\n", value, resolution, item->physical_minimum, + item->logical_minimum, ret); + + if((item->logical_minimum < 0) || (item->logical_maximum < 0)){ + return USB_HID_INT32_TO_UINT32(ret, item->size); + } + return (int32_t)0 + ret; +} + +/*---------------------------------------------------------------------------*/ +/** + * Clones given state table + * + * @param item State table to clone + * @return Pointer to the cloned item + */ +usb_hid_report_item_t *usb_hid_report_item_clone( + const usb_hid_report_item_t *item) +{ + usb_hid_report_item_t *new_report_item; + + if(!(new_report_item = malloc(sizeof(usb_hid_report_item_t)))) { + return NULL; + } + memcpy(new_report_item,item, sizeof(usb_hid_report_item_t)); + link_initialize(&(new_report_item->link)); + + return new_report_item; +} + +/*---------------------------------------------------------------------------*/ +/** + * Function for sequence walking through the report. Returns next field in the + * report or the first one when no field is given. + * + * @param report Searched report structure + * @param field Current field. If NULL is given, the first one in the report + * is returned. Otherwise the next one i nthe list is returned. + * @param path Usage path specifying which fields wa are interested in. + * @param flags Flags defining mode of usage paths comparison + * @param type Type of report we search. + * @retval NULL if no field is founded + * @retval Pointer to the founded report structure when founded + */ +usb_hid_report_field_t *usb_hid_report_get_sibling(usb_hid_report_t *report, + usb_hid_report_field_t *field, usb_hid_report_path_t *path, int flags, + usb_hid_report_type_t type) +{ + usb_hid_report_description_t *report_des = + usb_hid_report_find_description(report, path->report_id, type); + + link_t *field_it; + + if(report_des == NULL){ + return NULL; + } + + if(field == NULL){ + field_it = report_des->report_items.next; + } + else { + field_it = field->link.next; + } + + while(field_it != &report_des->report_items) { + field = list_get_instance(field_it, usb_hid_report_field_t, + link); + + if(USB_HID_ITEM_FLAG_CONSTANT(field->item_flags) == 0) { + usb_hid_report_path_append_item ( + field->collection_path, field->usage_page, + field->usage); + + if(usb_hid_report_compare_usage_path( + field->collection_path, path, flags) == EOK){ + + usb_hid_report_remove_last_item( + field->collection_path); + + return field; + } + usb_hid_report_remove_last_item ( + field->collection_path); + } + field_it = field_it->next; + } + + return NULL; +} + +/*---------------------------------------------------------------------------*/ +/** + * Returns next report_id of report of specified type. If zero is given than + * first report_id of specified type is returned (0 is not legal value for + * repotr_id) + * + * @param report_id Current report_id, 0 if there is no current report_id + * @param type Type of searched report + * @param report Report structure inwhich we search + * @retval 0 if report structure is null or there is no specified report + * @retval report_id otherwise + */ +uint8_t usb_hid_get_next_report_id(usb_hid_report_t *report, + uint8_t report_id, usb_hid_report_type_t type) +{ + if(report == NULL){ + return 0; + } + + usb_hid_report_description_t *report_des; + link_t *report_it; + + if(report_id > 0) { + report_des = usb_hid_report_find_description(report, report_id, + type); + if(report_des == NULL) { + return 0; + } + else { + report_it = report_des->link.next; + } + } + else { + report_it = report->reports.next; + } + + while(report_it != &report->reports) { + report_des = list_get_instance(report_it, + usb_hid_report_description_t, link); + + if(report_des->type == type){ + return report_des->report_id; + } + + report_it = report_it->next; + } + + return 0; +} + +/*---------------------------------------------------------------------------*/ +/** + * Reset all local items in given state table + * + * @param report_item State table containing current state of report + * descriptor parsing + * + * @return void + */ +void usb_hid_report_reset_local_items(usb_hid_report_item_t *report_item) +{ + if(report_item == NULL) { + return; + } + + report_item->usages_count = 0; + memset(report_item->usages, 0, USB_HID_MAX_USAGES); + + report_item->extended_usage_page = 0; + report_item->usage_minimum = 0; + report_item->usage_maximum = 0; + report_item->designator_index = 0; + report_item->designator_minimum = 0; + report_item->designator_maximum = 0; + report_item->string_index = 0; + report_item->string_minimum = 0; + report_item->string_maximum = 0; + + return; +} +/** + * @} + */ Index: uspace/lib/usbhid/src/hidpath.c =================================================================== --- uspace/lib/usbhid/src/hidpath.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbhid/src/hidpath.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,468 @@ +/* + * Copyright (c) 2011 Matej Klonfar + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbhid + * @{ + */ +/** @file + * HID report descriptor and report data parser implementation. + */ +#include +#include +#include +#include +#include +#include +#include + +/*---------------------------------------------------------------------------*/ +/** + * Compares two usages if they are same or not or one of the usages is not + * set. + * + * @param usage1 + * @param usage2 + * @return boolean + */ +#define USB_HID_SAME_USAGE(usage1, usage2) \ + ((usage1 == usage2) || (usage1 == 0) || (usage2 == 0)) + +/** + * Compares two usage pages if they are same or not or one of them is not set. + * + * @param page1 + * @param page2 + * @return boolean + */ +#define USB_HID_SAME_USAGE_PAGE(page1, page2) \ + ((page1 == page2) || (page1 == 0) || (page2 == 0)) + +/*---------------------------------------------------------------------------*/ +/** + * Appends one item (couple of usage_path and usage) into the usage path + * structure + * + * @param usage_path Usage path structure + * @param usage_page Usage page constant + * @param usage Usage constant + * @return Error code + */ +int usb_hid_report_path_append_item(usb_hid_report_path_t *usage_path, + int32_t usage_page, int32_t usage) +{ + usb_hid_report_usage_path_t *item; + + if(!(item=malloc(sizeof(usb_hid_report_usage_path_t)))) { + return ENOMEM; + } + list_initialize(&item->link); + + item->usage = usage; + item->usage_page = usage_page; + item->flags = 0; + + list_append (&item->link, &usage_path->head); + usage_path->depth++; + return EOK; +} + +/*---------------------------------------------------------------------------*/ +/** + * Removes last item from the usage path structure + * @param usage_path + * @return void + */ +void usb_hid_report_remove_last_item(usb_hid_report_path_t *usage_path) +{ + usb_hid_report_usage_path_t *item; + + if(!list_empty(&usage_path->head)){ + item = list_get_instance(usage_path->head.prev, + usb_hid_report_usage_path_t, link); + list_remove(usage_path->head.prev); + usage_path->depth--; + free(item); + } +} + +/*---------------------------------------------------------------------------*/ +/** + * Nulls last item of the usage path structure. + * + * @param usage_path + * @return void + */ +void usb_hid_report_null_last_item(usb_hid_report_path_t *usage_path) +{ + usb_hid_report_usage_path_t *item; + + if(!list_empty(&usage_path->head)){ + item = list_get_instance(usage_path->head.prev, + usb_hid_report_usage_path_t, link); + + memset(item, 0, sizeof(usb_hid_report_usage_path_t)); + } +} + +/*---------------------------------------------------------------------------*/ +/** + * Modifies last item of usage path structure by given usage page or usage + * + * @param usage_path Opaque usage path structure + * @param tag Class of currently processed tag (Usage page tag falls into Global + * class but Usage tag into the Local) + * @param data Value of the processed tag + * @return void + */ +void usb_hid_report_set_last_item(usb_hid_report_path_t *usage_path, + int32_t tag, int32_t data) +{ + usb_hid_report_usage_path_t *item; + + if(!list_empty(&usage_path->head)){ + item = list_get_instance(usage_path->head.prev, + usb_hid_report_usage_path_t, link); + + switch(tag) { + case USB_HID_TAG_CLASS_GLOBAL: + item->usage_page = data; + break; + case USB_HID_TAG_CLASS_LOCAL: + item->usage = data; + break; + } + } + +} + +/*---------------------------------------------------------------------------*/ +/** + * + * + * + * + */ +void usb_hid_print_usage_path(usb_hid_report_path_t *path) +{ + usb_log_debug("USAGE_PATH FOR RId(%d):\n", path->report_id); + usb_log_debug("\tLENGTH: %d\n", path->depth); + + link_t *item = path->head.next; + usb_hid_report_usage_path_t *path_item; + while(item != &path->head) { + + path_item = list_get_instance(item, usb_hid_report_usage_path_t, + link); + + usb_log_debug("\tUSAGE_PAGE: %X\n", path_item->usage_page); + usb_log_debug("\tUSAGE: %X\n", path_item->usage); + usb_log_debug("\tFLAGS: %d\n", path_item->flags); + + item = item->next; + } +} + +/*---------------------------------------------------------------------------*/ +/** + * Compares two usage paths structures + * + * + * @param report_path usage path structure to compare with @path + * @param path usage patrh structure to compare + * @param flags Flags determining the mode of comparison + * @return EOK if both paths are identical, non zero number otherwise + */ +int usb_hid_report_compare_usage_path(usb_hid_report_path_t *report_path, + usb_hid_report_path_t *path, + int flags) +{ + usb_hid_report_usage_path_t *report_item; + usb_hid_report_usage_path_t *path_item; + + link_t *report_link; + link_t *path_link; + + int only_page; + + if(report_path->report_id != path->report_id) { + if(path->report_id != 0) { + return 1; + } + } + + // Empty path match all others + if(path->depth == 0){ + return EOK; + } + + + if((only_page = flags & USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY) != 0){ + flags -= USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY; + } + + switch(flags){ + /* path is somewhere in report_path */ + case USB_HID_PATH_COMPARE_ANYWHERE: + if(path->depth != 1){ + return 1; + } + + report_link = report_path->head.next; + path_link = path->head.next; + path_item = list_get_instance(path_link, + usb_hid_report_usage_path_t, link); + + while(report_link != &report_path->head) { + report_item = list_get_instance(report_link, + usb_hid_report_usage_path_t, link); + + if(USB_HID_SAME_USAGE_PAGE(report_item->usage_page, + path_item->usage_page)){ + + if(only_page == 0){ + if(USB_HID_SAME_USAGE( + report_item->usage, + path_item->usage)) { + + return EOK; + } + } + else { + return EOK; + } + } + + report_link = report_link->next; + } + + return 1; + break; + + /* the paths must be identical */ + case USB_HID_PATH_COMPARE_STRICT: + if(report_path->depth != path->depth){ + return 1; + } + + /* path is prefix of the report_path */ + case USB_HID_PATH_COMPARE_BEGIN: + + report_link = report_path->head.next; + path_link = path->head.next; + + while((report_link != &report_path->head) && + (path_link != &path->head)) { + + report_item = list_get_instance(report_link, + usb_hid_report_usage_path_t, link); + + path_item = list_get_instance(path_link, + usb_hid_report_usage_path_t, link); + + if(!USB_HID_SAME_USAGE_PAGE(report_item->usage_page, + path_item->usage_page) || ((only_page == 0) && + !USB_HID_SAME_USAGE(report_item->usage, + path_item->usage))) { + + return 1; + } + else { + report_link = report_link->next; + path_link = path_link->next; + } + + } + + if((((flags & USB_HID_PATH_COMPARE_BEGIN) != 0) && + (path_link == &path->head)) || + ((report_link == &report_path->head) && + (path_link == &path->head))) { + + return EOK; + } + else { + return 1; + } + break; + + /* path is suffix of report_path */ + case USB_HID_PATH_COMPARE_END: + + report_link = report_path->head.prev; + path_link = path->head.prev; + + if(list_empty(&path->head)){ + return EOK; + } + + while((report_link != &report_path->head) && + (path_link != &path->head)) { + + report_item = list_get_instance(report_link, + usb_hid_report_usage_path_t, link); + + path_item = list_get_instance(path_link, + usb_hid_report_usage_path_t, link); + + if(!USB_HID_SAME_USAGE_PAGE(report_item->usage_page, + path_item->usage_page) || ((only_page == 0) && + !USB_HID_SAME_USAGE(report_item->usage, + path_item->usage))) { + + return 1; + } else { + report_link = report_link->prev; + path_link = path_link->prev; + } + + } + + if(path_link == &path->head) { + return EOK; + } + else { + return 1; + } + + break; + + default: + return EINVAL; + } +} + +/*---------------------------------------------------------------------------*/ +/** + * Allocates and initializes new usage path structure. + * + * @return Initialized usage path structure + */ +usb_hid_report_path_t *usb_hid_report_path(void) +{ + usb_hid_report_path_t *path; + path = malloc(sizeof(usb_hid_report_path_t)); + if(path == NULL){ + return NULL; + } + else { + path->depth = 0; + path->report_id = 0; + list_initialize(&path->link); + list_initialize(&path->head); + return path; + } +} + +/*---------------------------------------------------------------------------*/ +/** + * Releases given usage path structure. + * + * @param path usage path structure to release + * @return void + */ +void usb_hid_report_path_free(usb_hid_report_path_t *path) +{ + while(!list_empty(&path->head)){ + usb_hid_report_remove_last_item(path); + } + + list_remove(&path->link); + free(path); +} + +/*---------------------------------------------------------------------------*/ +/** + * Clone content of given usage path to the new one + * + * @param usage_path Usage path structure to clone + * @return New copy of given usage path structure + */ +usb_hid_report_path_t *usb_hid_report_path_clone( + usb_hid_report_path_t *usage_path) +{ + link_t *path_link; + usb_hid_report_usage_path_t *path_item; + usb_hid_report_usage_path_t *new_path_item; + usb_hid_report_path_t *new_usage_path = usb_hid_report_path (); + + if(new_usage_path == NULL){ + return NULL; + } + + new_usage_path->report_id = usage_path->report_id; + + if(list_empty(&usage_path->head)){ + return new_usage_path; + } + + path_link = usage_path->head.next; + while(path_link != &usage_path->head) { + path_item = list_get_instance(path_link, + usb_hid_report_usage_path_t, link); + + new_path_item = malloc(sizeof(usb_hid_report_usage_path_t)); + if(new_path_item == NULL) { + return NULL; + } + + list_initialize (&new_path_item->link); + new_path_item->usage_page = path_item->usage_page; + new_path_item->usage = path_item->usage; + new_path_item->flags = path_item->flags; + + list_append(&new_path_item->link, &new_usage_path->head); + new_usage_path->depth++; + + path_link = path_link->next; + } + + return new_usage_path; +} + +/*---------------------------------------------------------------------------*/ +/** + * Sets report id in usage path structure + * + * @param path Usage path structure + * @param report_id Report id to set + * @return Error code + */ +int usb_hid_report_path_set_report_id(usb_hid_report_path_t *path, + uint8_t report_id) +{ + if(path == NULL){ + return EINVAL; + } + + path->report_id = report_id; + return EOK; +} + +/** + * @} + */ Index: uspace/lib/usbhid/src/hidreport.c =================================================================== --- uspace/lib/usbhid/src/hidreport.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbhid/src/hidreport.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,207 @@ +/* + * Copyright (c) 2011 Lubos Slovak + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbhid + * @{ + */ +/** + * @file + * USB HID keyboard device structure and API. + */ + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +static int usb_hid_get_report_descriptor(usb_device_t *dev, + uint8_t **report_desc, size_t *size) +{ + assert(report_desc != NULL); + assert(size != NULL); + + usb_dp_parser_t parser = { + .nesting = usb_dp_standard_descriptor_nesting + }; + + usb_dp_parser_data_t parser_data = { + .data = dev->descriptors.configuration, + .size = dev->descriptors.configuration_size, + .arg = NULL + }; + + /* + * First nested descriptor of the configuration descriptor. + */ + uint8_t *d = + usb_dp_get_nested_descriptor(&parser, &parser_data, + dev->descriptors.configuration); + + /* + * Find the interface descriptor corresponding to our interface number. + */ + int i = 0; + while (d != NULL && i < dev->interface_no) { + d = usb_dp_get_sibling_descriptor(&parser, &parser_data, + dev->descriptors.configuration, d); + ++i; + } + + if (d == NULL) { + usb_log_error("The %d. interface descriptor not found!\n", + dev->interface_no); + return ENOENT; + } + + /* + * First nested descriptor of the interface descriptor. + */ + uint8_t *iface_desc = d; + d = usb_dp_get_nested_descriptor(&parser, &parser_data, iface_desc); + + /* + * Search through siblings until the HID descriptor is found. + */ + while (d != NULL && *(d + 1) != USB_DESCTYPE_HID) { + d = usb_dp_get_sibling_descriptor(&parser, &parser_data, + iface_desc, d); + } + + if (d == NULL) { + usb_log_fatal("No HID descriptor found!\n"); + return ENOENT; + } + + if (*d != sizeof(usb_standard_hid_descriptor_t)) { + usb_log_error("HID descriptor has wrong size (%u, expected %zu" + ")\n", *d, sizeof(usb_standard_hid_descriptor_t)); + return EINVAL; + } + + usb_standard_hid_descriptor_t *hid_desc = + (usb_standard_hid_descriptor_t *)d; + + uint16_t length = hid_desc->report_desc_info.length; + size_t actual_size = 0; + + /* + * Allocate space for the report descriptor. + */ + *report_desc = (uint8_t *)malloc(length); + if (*report_desc == NULL) { + usb_log_error("Failed to allocate space for Report descriptor." + "\n"); + return ENOMEM; + } + + usb_log_debug("Getting Report descriptor, expected size: %u\n", length); + + /* + * Get the descriptor from the device. + */ + int rc = usb_request_get_descriptor(&dev->ctrl_pipe, + USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_INTERFACE, + USB_DESCTYPE_HID_REPORT, 0, dev->interface_no, + *report_desc, length, &actual_size); + + if (rc != EOK) { + free(*report_desc); + *report_desc = NULL; + return rc; + } + + if (actual_size != length) { + free(*report_desc); + *report_desc = NULL; + usb_log_error("Report descriptor has wrong size (%zu, expected " + "%u)\n", actual_size, length); + return EINVAL; + } + + *size = length; + + usb_log_debug("Done.\n"); + + return EOK; +} + +/*----------------------------------------------------------------------------*/ + +int usb_hid_process_report_descriptor(usb_device_t *dev, + usb_hid_report_t *report, uint8_t **report_desc, size_t *report_size) +{ + if (dev == NULL || report == NULL) { + usb_log_error("Failed to process Report descriptor: wrong " + "parameters given.\n"); + return EINVAL; + } + +// uint8_t *report_desc = NULL; +// size_t report_size; + + int rc = usb_hid_get_report_descriptor(dev, report_desc, report_size); + + if (rc != EOK) { + usb_log_error("Problem with getting Report descriptor: %s.\n", + str_error(rc)); + if (*report_desc != NULL) { + free(*report_desc); + *report_desc = NULL; + } + return rc; + } + + assert(*report_desc != NULL); + + rc = usb_hid_parse_report_descriptor(report, *report_desc, *report_size); + if (rc != EOK) { + usb_log_error("Problem parsing Report descriptor: %s.\n", + str_error(rc)); + free(*report_desc); + *report_desc = NULL; + return rc; + } + + usb_hid_descriptor_print(report); + + return EOK; +} + +/** + * @} + */ Index: uspace/lib/usbhid/src/hidreq.c =================================================================== --- uspace/lib/usbhid/src/hidreq.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbhid/src/hidreq.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,379 @@ +/* + * Copyright (c) 2011 Lubos Slovak + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup drvusbhid + * @{ + */ +/** @file + * HID class-specific requests. + */ + +#include +#include +#include + +#include +#include +#include +#include + +#include + +/*----------------------------------------------------------------------------*/ +/** + * Send Set Report request to the HID device. + * + * @param hid_dev HID device to send the request to. + * @param type Type of the report. + * @param buffer Report data. + * @param buf_size Report data size (in bytes). + * + * @retval EOK if successful. + * @retval EINVAL if no HID device is given. + * @return Other value inherited from function usb_control_request_set(). + */ +int usbhid_req_set_report(usb_pipe_t *ctrl_pipe, int iface_no, + usb_hid_report_type_t type, uint8_t *buffer, size_t buf_size) +{ + if (ctrl_pipe == NULL) { + usb_log_warning("usbhid_req_set_report(): no pipe given.\n"); + return EINVAL; + } + + if (iface_no < 0) { + usb_log_warning("usbhid_req_set_report(): no interface given." + "\n"); + return EINVAL; + } + + /* + * No need for checking other parameters, as they are checked in + * the called function (usb_control_request_set()). + */ + + int rc; + + uint16_t value = 0; + value |= (type << 8); + + usb_log_debug("Sending Set_Report request to the device.\n"); + + rc = usb_control_request_set(ctrl_pipe, + USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, + USB_HIDREQ_SET_REPORT, value, iface_no, buffer, buf_size); + + if (rc != EOK) { + usb_log_warning("Error sending output report to the keyboard: " + "%s.\n", str_error(rc)); + return rc; + } + + return EOK; +} + +/*----------------------------------------------------------------------------*/ +/** + * Send Set Protocol request to the HID device. + * + * @param hid_dev HID device to send the request to. + * @param protocol Protocol to set. + * + * @retval EOK if successful. + * @retval EINVAL if no HID device is given. + * @return Other value inherited from function usb_control_request_set(). + */ +int usbhid_req_set_protocol(usb_pipe_t *ctrl_pipe, int iface_no, + usb_hid_protocol_t protocol) +{ + if (ctrl_pipe == NULL) { + usb_log_warning("usbhid_req_set_report(): no pipe given.\n"); + return EINVAL; + } + + if (iface_no < 0) { + usb_log_warning("usbhid_req_set_report(): no interface given." + "\n"); + return EINVAL; + } + + /* + * No need for checking other parameters, as they are checked in + * the called function (usb_control_request_set()). + */ + + int rc; + + usb_log_debug("Sending Set_Protocol request to the device (" + "protocol: %d, iface: %d).\n", protocol, iface_no); + + rc = usb_control_request_set(ctrl_pipe, + USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, + USB_HIDREQ_SET_PROTOCOL, protocol, iface_no, NULL, 0); + + if (rc != EOK) { + usb_log_warning("Error sending output report to the keyboard: " + "%s.\n", str_error(rc)); + return rc; + } + + return EOK; +} + +/*----------------------------------------------------------------------------*/ +/** + * Send Set Idle request to the HID device. + * + * @param hid_dev HID device to send the request to. + * @param duration Duration value (is multiplicated by 4 by the device to + * get real duration in miliseconds). + * + * @retval EOK if successful. + * @retval EINVAL if no HID device is given. + * @return Other value inherited from function usb_control_request_set(). + */ +int usbhid_req_set_idle(usb_pipe_t *ctrl_pipe, int iface_no, uint8_t duration) +{ + if (ctrl_pipe == NULL) { + usb_log_warning("usbhid_req_set_report(): no pipe given.\n"); + return EINVAL; + } + + if (iface_no < 0) { + usb_log_warning("usbhid_req_set_report(): no interface given." + "\n"); + return EINVAL; + } + + /* + * No need for checking other parameters, as they are checked in + * the called function (usb_control_request_set()). + */ + + int rc; + + usb_log_debug("Sending Set_Idle request to the device (" + "duration: %u, iface: %d).\n", duration, iface_no); + + uint16_t value = duration << 8; + + rc = usb_control_request_set(ctrl_pipe, + USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, + USB_HIDREQ_SET_IDLE, value, iface_no, NULL, 0); + + if (rc != EOK) { + usb_log_warning("Error sending output report to the keyboard: " + "%s.\n", str_error(rc)); + return rc; + } + + return EOK; +} + +/*----------------------------------------------------------------------------*/ +/** + * Send Get Report request to the HID device. + * + * @param[in] hid_dev HID device to send the request to. + * @param[in] type Type of the report. + * @param[in][out] buffer Buffer for the report data. + * @param[in] buf_size Size of the buffer (in bytes). + * @param[out] actual_size Actual size of report received from the device + * (in bytes). + * + * @retval EOK if successful. + * @retval EINVAL if no HID device is given. + * @return Other value inherited from function usb_control_request_set(). + */ +int usbhid_req_get_report(usb_pipe_t *ctrl_pipe, int iface_no, + usb_hid_report_type_t type, uint8_t *buffer, size_t buf_size, + size_t *actual_size) +{ + if (ctrl_pipe == NULL) { + usb_log_warning("usbhid_req_set_report(): no pipe given.\n"); + return EINVAL; + } + + if (iface_no < 0) { + usb_log_warning("usbhid_req_set_report(): no interface given." + "\n"); + return EINVAL; + } + + /* + * No need for checking other parameters, as they are checked in + * the called function (usb_control_request_set()). + */ + + int rc; + + uint16_t value = 0; + value |= (type << 8); + + usb_log_debug("Sending Get_Report request to the device.\n"); + + rc = usb_control_request_get(ctrl_pipe, + USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, + USB_HIDREQ_GET_REPORT, value, iface_no, buffer, buf_size, + actual_size); + + if (rc != EOK) { + usb_log_warning("Error sending output report to the keyboard: " + "%s.\n", str_error(rc)); + return rc; + } + + return EOK; +} + +/*----------------------------------------------------------------------------*/ +/** + * Send Get Protocol request to the HID device. + * + * @param[in] hid_dev HID device to send the request to. + * @param[out] protocol Current protocol of the device. + * + * @retval EOK if successful. + * @retval EINVAL if no HID device is given. + * @return Other value inherited from function usb_control_request_set(). + */ +int usbhid_req_get_protocol(usb_pipe_t *ctrl_pipe, int iface_no, + usb_hid_protocol_t *protocol) +{ + if (ctrl_pipe == NULL) { + usb_log_warning("usbhid_req_set_report(): no pipe given.\n"); + return EINVAL; + } + + if (iface_no < 0) { + usb_log_warning("usbhid_req_set_report(): no interface given." + "\n"); + return EINVAL; + } + + /* + * No need for checking other parameters, as they are checked in + * the called function (usb_control_request_set()). + */ + + int rc; + + usb_log_debug("Sending Get_Protocol request to the device (" + "iface: %d).\n", iface_no); + + uint8_t buffer[1]; + size_t actual_size = 0; + + rc = usb_control_request_get(ctrl_pipe, + USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, + USB_HIDREQ_GET_PROTOCOL, 0, iface_no, buffer, 1, &actual_size); + + if (rc != EOK) { + usb_log_warning("Error sending output report to the keyboard: " + "%s.\n", str_error(rc)); + return rc; + } + + if (actual_size != 1) { + usb_log_warning("Wrong data size: %zu, expected: 1.\n", + actual_size); + return ELIMIT; + } + + *protocol = buffer[0]; + + return EOK; +} + +/*----------------------------------------------------------------------------*/ +/** + * Send Get Idle request to the HID device. + * + * @param[in] hid_dev HID device to send the request to. + * @param[out] duration Duration value (multiplicate by 4 to get real duration + * in miliseconds). + * + * @retval EOK if successful. + * @retval EINVAL if no HID device is given. + * @return Other value inherited from one of functions + * usb_pipe_start_session(), usb_pipe_end_session(), + * usb_control_request_set(). + */ +int usbhid_req_get_idle(usb_pipe_t *ctrl_pipe, int iface_no, uint8_t *duration) +{ + if (ctrl_pipe == NULL) { + usb_log_warning("usbhid_req_set_report(): no pipe given.\n"); + return EINVAL; + } + + if (iface_no < 0) { + usb_log_warning("usbhid_req_set_report(): no interface given." + "\n"); + return EINVAL; + } + + /* + * No need for checking other parameters, as they are checked in + * the called function (usb_control_request_set()). + */ + + int rc; + + usb_log_debug("Sending Get_Idle request to the device (" + "iface: %d).\n", iface_no); + + uint16_t value = 0; + uint8_t buffer[1]; + size_t actual_size = 0; + + rc = usb_control_request_get(ctrl_pipe, + USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE, + USB_HIDREQ_GET_IDLE, value, iface_no, buffer, 1, + &actual_size); + + if (rc != EOK) { + usb_log_warning("Error sending output report to the keyboard: " + "%s.\n", str_error(rc)); + return rc; + } + + if (actual_size != 1) { + usb_log_warning("Wrong data size: %zu, expected: 1.\n", + actual_size); + return ELIMIT; + } + + *duration = buffer[0]; + + return EOK; +} + +/*----------------------------------------------------------------------------*/ + +/** + * @} + */ Index: uspace/lib/usbhost/Makefile =================================================================== --- uspace/lib/usbhost/Makefile (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbhost/Makefile (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,42 @@ +# +# Copyright (c) 2011 Vojtech Horky +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# - Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# - Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# - The name of the author may not be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +USPACE_PREFIX = ../.. +LIBRARY = libusbhost +EXTRA_CFLAGS += \ + -I$(LIBUSB_PREFIX)/include \ + -I$(LIBDRV_PREFIX)/include \ + -Iinclude + +SOURCES = \ + src/batch.c \ + src/device_keeper.c \ + src/endpoint.c \ + src/usb_endpoint_manager.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/lib/usbhost/include/usb/host/batch.h =================================================================== --- uspace/lib/usbhost/include/usb/host/batch.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbhost/include/usb/host/batch.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,101 @@ +/* + * Copyright (c) 2011 Jan Vesely + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/** @addtogroup libusbhost + * @{ + */ +/** @file + * USB transfer transaction structures. + */ +#ifndef LIBUSBHOST_HOST_BATCH_H +#define LIBUSBHOST_HOST_BATCH_H + +#include + +#include +#include +#include + +typedef struct usb_transfer_batch usb_transfer_batch_t; +struct usb_transfer_batch { + endpoint_t *ep; + link_t link; + usbhc_iface_transfer_in_callback_t callback_in; + usbhc_iface_transfer_out_callback_t callback_out; + void *arg; + char *buffer; + char *data_buffer; + size_t buffer_size; + char *setup_buffer; + size_t setup_size; + size_t transfered_size; + void (*next_step)(usb_transfer_batch_t *); + int error; + ddf_fun_t *fun; + void *private_data; + void (*private_data_dtor)(void *p_data); +}; + +void usb_transfer_batch_init( + usb_transfer_batch_t *instance, + endpoint_t *ep, + char *buffer, + char *data_buffer, + size_t buffer_size, + char *setup_buffer, + size_t setup_size, + usbhc_iface_transfer_in_callback_t func_in, + usbhc_iface_transfer_out_callback_t func_out, + void *arg, + ddf_fun_t *fun, + void *private_data, + void (*private_data_dtor)(void *p_data) +); + +void usb_transfer_batch_call_in_and_dispose(usb_transfer_batch_t *instance); +void usb_transfer_batch_call_out_and_dispose(usb_transfer_batch_t *instance); +void usb_transfer_batch_finish(usb_transfer_batch_t *instance); +void usb_transfer_batch_dispose(usb_transfer_batch_t *instance); + +static inline void usb_transfer_batch_finish_error( + usb_transfer_batch_t *instance, int error) +{ + assert(instance); + instance->error = error; + usb_transfer_batch_finish(instance); +} + +static inline usb_transfer_batch_t *usb_transfer_batch_from_link(link_t *l) +{ + assert(l); + return list_get_instance(l, usb_transfer_batch_t, link); +} + +#endif +/** + * @} + */ Index: uspace/lib/usbhost/include/usb/host/device_keeper.h =================================================================== --- uspace/lib/usbhost/include/usb/host/device_keeper.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbhost/include/usb/host/device_keeper.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,90 @@ +/* + * Copyright (c) 2011 Jan Vesely + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbhost + * @{ + */ +/** @file + * Device keeper structure and functions. + * + * Typical USB host controller needs to keep track of various settings for + * each device that is connected to it. + * State of toggle bit, device speed etc. etc. + * This structure shall simplify the management. + */ +#ifndef LIBUSBHOST_HOST_DEVICE_KEEPER_H +#define LIBUSBHOST_HOST_DEVICE_KEEPER_H + +#include +#include +#include +#include +#include + +/** Number of USB address for array dimensions. */ +#define USB_ADDRESS_COUNT (USB11_ADDRESS_MAX + 1) + +/** Information about attached USB device. */ +struct usb_device_info { + usb_speed_t speed; + bool occupied; + devman_handle_t handle; +}; + +/** Host controller device keeper. + * You shall not access members directly but only using functions below. + */ +typedef struct { + struct usb_device_info devices[USB_ADDRESS_COUNT]; + fibril_mutex_t guard; + usb_address_t last_address; +} usb_device_keeper_t; + +void usb_device_keeper_init(usb_device_keeper_t *instance); + +usb_address_t device_keeper_get_free_address(usb_device_keeper_t *instance, + usb_speed_t speed); + +void usb_device_keeper_bind(usb_device_keeper_t *instance, + usb_address_t address, devman_handle_t handle); + +void usb_device_keeper_release(usb_device_keeper_t *instance, + usb_address_t address); + +usb_address_t usb_device_keeper_find(usb_device_keeper_t *instance, + devman_handle_t handle); + +bool usb_device_keeper_find_by_address(usb_device_keeper_t *instance, + usb_address_t address, devman_handle_t *handle); + +usb_speed_t usb_device_keeper_get_speed(usb_device_keeper_t *instance, + usb_address_t address); +#endif +/** + * @} + */ Index: uspace/lib/usbhost/include/usb/host/endpoint.h =================================================================== --- uspace/lib/usbhost/include/usb/host/endpoint.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbhost/include/usb/host/endpoint.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,86 @@ +/* + * Copyright (c) 2011 Jan Vesely + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbhost + * @{ + */ +/** @file + * + */ +#ifndef LIBUSBHOST_HOST_ENDPOINT_H +#define LIBUSBHOST_HOST_ENDPOINT_H + +#include +#include +#include +#include + +#include + +typedef struct endpoint { + usb_address_t address; + usb_endpoint_t endpoint; + usb_direction_t direction; + usb_transfer_type_t transfer_type; + usb_speed_t speed; + size_t max_packet_size; + unsigned toggle:1; + fibril_mutex_t guard; + fibril_condvar_t avail; + volatile bool active; + struct { + void *data; + int (*toggle_get)(void *); + void (*toggle_set)(void *, int); + } hc_data; +} endpoint_t; + +int endpoint_init(endpoint_t *instance, usb_address_t address, + usb_endpoint_t endpoint, usb_direction_t direction, + usb_transfer_type_t type, usb_speed_t speed, size_t max_packet_size); + +void endpoint_destroy(endpoint_t *instance); + +void endpoint_set_hc_data(endpoint_t *instance, + void *data, int (*toggle_get)(void *), void (*toggle_set)(void *, int)); + +void endpoint_clear_hc_data(endpoint_t *instance); + +void endpoint_use(endpoint_t *instance); + +void endpoint_release(endpoint_t *instance); + +int endpoint_toggle_get(endpoint_t *instance); + +void endpoint_toggle_set(endpoint_t *instance, int toggle); + +void endpoint_toggle_reset_filtered(endpoint_t *instance, usb_target_t target); +#endif +/** + * @} + */ Index: uspace/lib/usbhost/include/usb/host/usb_endpoint_manager.h =================================================================== --- uspace/lib/usbhost/include/usb/host/usb_endpoint_manager.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbhost/include/usb/host/usb_endpoint_manager.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,106 @@ +/* + * Copyright (c) 2011 Jan Vesely + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/** @addtogroup libusbhost + * @{ + */ +/** @file + * Device keeper structure and functions. + * + * Typical USB host controller needs to keep track of various settings for + * each device that is connected to it. + * State of toggle bit, device speed etc. etc. + * This structure shall simplify the management. + */ +#ifndef LIBUSBHOST_HOST_USB_ENDPOINT_MANAGER_H +#define LIBUSBHOST_HOST_YSB_ENDPOINT_MANAGER_H + +#include +#include +#include +#include +#include + +#define BANDWIDTH_TOTAL_USB11 12000000 +#define BANDWIDTH_AVAILABLE_USB11 ((BANDWIDTH_TOTAL_USB11 / 10) * 9) + +typedef struct usb_endpoint_manager { + hash_table_t ep_table; + fibril_mutex_t guard; + fibril_condvar_t change; + size_t free_bw; +} usb_endpoint_manager_t; + +size_t bandwidth_count_usb11(usb_speed_t speed, usb_transfer_type_t type, + size_t size, size_t max_packet_size); + +int usb_endpoint_manager_init(usb_endpoint_manager_t *instance, + size_t available_bandwidth); + +void usb_endpoint_manager_destroy(usb_endpoint_manager_t *instance); + +int usb_endpoint_manager_register_ep(usb_endpoint_manager_t *instance, + endpoint_t *ep, size_t data_size); + +int usb_endpoint_manager_unregister_ep(usb_endpoint_manager_t *instance, + usb_address_t address, usb_endpoint_t ep, usb_direction_t direction); + +endpoint_t * usb_endpoint_manager_get_ep(usb_endpoint_manager_t *instance, + usb_address_t address, usb_endpoint_t ep, usb_direction_t direction, + size_t *bw); + +void usb_endpoint_manager_reset_if_need( + usb_endpoint_manager_t *instance, usb_target_t target, const uint8_t *data); + +static inline int usb_endpoint_manager_add_ep(usb_endpoint_manager_t *instance, + usb_address_t address, usb_endpoint_t endpoint, usb_direction_t direction, + usb_transfer_type_t type, usb_speed_t speed, size_t max_packet_size, + size_t data_size) +{ + endpoint_t *ep = malloc(sizeof(endpoint_t)); + if (ep == NULL) + return ENOMEM; + + int ret = endpoint_init(ep, address, endpoint, direction, type, speed, + max_packet_size); + if (ret != EOK) { + free(ep); + return ret; + } + + ret = usb_endpoint_manager_register_ep(instance, ep, data_size); + if (ret != EOK) { + endpoint_destroy(ep); + return ret; + } + return EOK; +} +#endif +/** + * @} + */ + Index: uspace/lib/usbhost/src/batch.c =================================================================== --- uspace/lib/usbhost/src/batch.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbhost/src/batch.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,176 @@ +/* + * Copyright (c) 2011 Jan Vesely + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/** @addtogroup libusbhost + * @{ + */ +/** @file + * USB transfer transaction structures (implementation). + */ +#include +#include + +#include +#include +#include + +void usb_transfer_batch_call_in(usb_transfer_batch_t *instance); +void usb_transfer_batch_call_out(usb_transfer_batch_t *instance); + +void usb_transfer_batch_init( + usb_transfer_batch_t *instance, + endpoint_t *ep, + char *buffer, + char *data_buffer, + size_t buffer_size, + char *setup_buffer, + size_t setup_size, + usbhc_iface_transfer_in_callback_t func_in, + usbhc_iface_transfer_out_callback_t func_out, + void *arg, + ddf_fun_t *fun, + void *private_data, + void (*private_data_dtor)(void *p_data) + ) +{ + assert(instance); + link_initialize(&instance->link); + instance->ep = ep; + instance->callback_in = func_in; + instance->callback_out = func_out; + instance->arg = arg; + instance->buffer = buffer; + instance->data_buffer = data_buffer; + instance->buffer_size = buffer_size; + instance->setup_buffer = setup_buffer; + instance->setup_size = setup_size; + instance->fun = fun; + instance->private_data = private_data; + instance->private_data_dtor = private_data_dtor; + instance->transfered_size = 0; + instance->next_step = NULL; + instance->error = EOK; + endpoint_use(instance->ep); +} +/*----------------------------------------------------------------------------*/ +/** Helper function, calls callback and correctly destroys batch structure. + * + * @param[in] instance Batch structure to use. + */ +void usb_transfer_batch_call_in_and_dispose(usb_transfer_batch_t *instance) +{ + assert(instance); + usb_transfer_batch_call_in(instance); + usb_transfer_batch_dispose(instance); +} +/*----------------------------------------------------------------------------*/ +/** Helper function calls callback and correctly destroys batch structure. + * + * @param[in] instance Batch structure to use. + */ +void usb_transfer_batch_call_out_and_dispose(usb_transfer_batch_t *instance) +{ + assert(instance); + usb_transfer_batch_call_out(instance); + usb_transfer_batch_dispose(instance); +} +/*----------------------------------------------------------------------------*/ +/** Mark batch as finished and continue with next step. + * + * @param[in] instance Batch structure to use. + * + */ +void usb_transfer_batch_finish(usb_transfer_batch_t *instance) +{ + assert(instance); + assert(instance->ep); + endpoint_release(instance->ep); + instance->next_step(instance); +} +/*----------------------------------------------------------------------------*/ +/** Prepare data, get error status and call callback in. + * + * @param[in] instance Batch structure to use. + * Copies data from transport buffer, and calls callback with appropriate + * parameters. + */ +void usb_transfer_batch_call_in(usb_transfer_batch_t *instance) +{ + assert(instance); + assert(instance->callback_in); + assert(instance->ep); + + /* We are data in, we need data */ + memcpy(instance->buffer, instance->data_buffer, instance->buffer_size); + + usb_log_debug("Batch(%p) done (T%d.%d, %s %s in, %zuB): %s (%d).\n", + instance, instance->ep->address, instance->ep->endpoint, + usb_str_speed(instance->ep->speed), + usb_str_transfer_type_short(instance->ep->transfer_type), + instance->transfered_size, str_error(instance->error), + instance->error); + + instance->callback_in(instance->fun, instance->error, + instance->transfered_size, instance->arg); +} +/*----------------------------------------------------------------------------*/ +/** Get error status and call callback out. + * + * @param[in] instance Batch structure to use. + */ +void usb_transfer_batch_call_out(usb_transfer_batch_t *instance) +{ + assert(instance); + assert(instance->callback_out); + + usb_log_debug("Batch(%p) done (T%d.%d, %s %s out): %s (%d).\n", + instance, instance->ep->address, instance->ep->endpoint, + usb_str_speed(instance->ep->speed), + usb_str_transfer_type_short(instance->ep->transfer_type), + str_error(instance->error), instance->error); + + instance->callback_out(instance->fun, + instance->error, instance->arg); +} +/*----------------------------------------------------------------------------*/ +/** Correctly dispose all used data structures. + * + * @param[in] instance Batch structure to use. + */ +void usb_transfer_batch_dispose(usb_transfer_batch_t *instance) +{ + assert(instance); + usb_log_debug("Batch(%p) disposing.\n", instance); + if (instance->private_data) { + assert(instance->private_data_dtor); + instance->private_data_dtor(instance->private_data); + } + free(instance); +} +/** + * @} + */ Index: uspace/lib/usbhost/src/device_keeper.c =================================================================== --- uspace/lib/usbhost/src/device_keeper.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbhost/src/device_keeper.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,208 @@ +/* + * Copyright (c) 2011 Jan Vesely + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbhost + * @{ + */ +/** @file + * Device keeper structure and functions (implementation). + */ +#include +#include +#include +#include + +/*----------------------------------------------------------------------------*/ +/** Initialize device keeper structure. + * + * @param[in] instance Memory place to initialize. + * + * Set all values to false/0. + */ +void usb_device_keeper_init(usb_device_keeper_t *instance) +{ + assert(instance); + unsigned i = 0; + for (; i < USB_ADDRESS_COUNT; ++i) { + instance->devices[i].occupied = false; + instance->devices[i].handle = 0; + instance->devices[i].speed = USB_SPEED_MAX; + } + // TODO: is this hack enough? + // (it is needed to allow smooth registration at default address) + instance->devices[0].occupied = true; + instance->last_address = 0; + fibril_mutex_initialize(&instance->guard); +} +/*----------------------------------------------------------------------------*/ +/** Get a free USB address + * + * @param[in] instance Device keeper structure to use. + * @param[in] speed Speed of the device requiring address. + * @return Free address, or error code. + */ +usb_address_t device_keeper_get_free_address( + usb_device_keeper_t *instance, usb_speed_t speed) +{ + assert(instance); + fibril_mutex_lock(&instance->guard); + + usb_address_t new_address = instance->last_address; + do { + ++new_address; + if (new_address > USB11_ADDRESS_MAX) + new_address = 1; + if (new_address == instance->last_address) { + fibril_mutex_unlock(&instance->guard); + return ENOSPC; + } + } while (instance->devices[new_address].occupied); + + assert(new_address != USB_ADDRESS_DEFAULT); + assert(instance->devices[new_address].occupied == false); + + instance->devices[new_address].occupied = true; + instance->devices[new_address].speed = speed; + instance->last_address = new_address; + + fibril_mutex_unlock(&instance->guard); + return new_address; +} +/*----------------------------------------------------------------------------*/ +/** Bind USB address to devman handle. + * + * @param[in] instance Device keeper structure to use. + * @param[in] address Device address + * @param[in] handle Devman handle of the device. + */ +void usb_device_keeper_bind(usb_device_keeper_t *instance, + usb_address_t address, devman_handle_t handle) +{ + assert(instance); + fibril_mutex_lock(&instance->guard); + + assert(address > 0); + assert(address <= USB11_ADDRESS_MAX); + assert(instance->devices[address].occupied); + + instance->devices[address].handle = handle; + fibril_mutex_unlock(&instance->guard); +} +/*----------------------------------------------------------------------------*/ +/** Release used USB address. + * + * @param[in] instance Device keeper structure to use. + * @param[in] address Device address + */ +void usb_device_keeper_release( + usb_device_keeper_t *instance, usb_address_t address) +{ + assert(instance); + assert(address > 0); + assert(address <= USB11_ADDRESS_MAX); + + fibril_mutex_lock(&instance->guard); + assert(instance->devices[address].occupied); + + instance->devices[address].occupied = false; + fibril_mutex_unlock(&instance->guard); +} +/*----------------------------------------------------------------------------*/ +/** Find USB address associated with the device + * + * @param[in] instance Device keeper structure to use. + * @param[in] handle Devman handle of the device seeking its address. + * @return USB Address, or error code. + */ +usb_address_t usb_device_keeper_find( + usb_device_keeper_t *instance, devman_handle_t handle) +{ + assert(instance); + fibril_mutex_lock(&instance->guard); + usb_address_t address = 1; + while (address <= USB11_ADDRESS_MAX) { + if (instance->devices[address].handle == handle) { + assert(instance->devices[address].occupied); + fibril_mutex_unlock(&instance->guard); + return address; + } + ++address; + } + fibril_mutex_unlock(&instance->guard); + return ENOENT; +} + +/** Find devman handle assigned to USB address. + * Intentionally refuse to find handle of default address. + * + * @param[in] instance Device keeper structure to use. + * @param[in] address Address the caller wants to find. + * @param[out] handle Where to store found handle. + * @return Whether such address is currently occupied. + */ +bool usb_device_keeper_find_by_address(usb_device_keeper_t *instance, + usb_address_t address, devman_handle_t *handle) +{ + assert(instance); + fibril_mutex_lock(&instance->guard); + if ((address <= 0) || (address >= USB_ADDRESS_COUNT)) { + fibril_mutex_unlock(&instance->guard); + return false; + } + if (!instance->devices[address].occupied) { + fibril_mutex_unlock(&instance->guard); + return false; + } + + if (handle != NULL) { + *handle = instance->devices[address].handle; + } + + fibril_mutex_unlock(&instance->guard); + return true; +} + +/*----------------------------------------------------------------------------*/ +/** Get speed associated with the address + * + * @param[in] instance Device keeper structure to use. + * @param[in] address Address of the device. + * @return USB speed. + */ +usb_speed_t usb_device_keeper_get_speed( + usb_device_keeper_t *instance, usb_address_t address) +{ + assert(instance); + assert(address >= 0); + assert(address <= USB11_ADDRESS_MAX); + + return instance->devices[address].speed; +} +/** + * @} + */ Index: uspace/lib/usbhost/src/endpoint.c =================================================================== --- uspace/lib/usbhost/src/endpoint.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbhost/src/endpoint.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,130 @@ +/* + * Copyright (c) 2011 Jan Vesely + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup drvusbuhcihc + * @{ + */ +/** @file + * @brief UHCI host controller driver structure + */ + +#include +#include +#include +#include + +int endpoint_init(endpoint_t *instance, usb_address_t address, + usb_endpoint_t endpoint, usb_direction_t direction, + usb_transfer_type_t type, usb_speed_t speed, size_t max_packet_size) +{ + assert(instance); + instance->address = address; + instance->endpoint = endpoint; + instance->direction = direction; + instance->transfer_type = type; + instance->speed = speed; + instance->max_packet_size = max_packet_size; + instance->toggle = 0; + instance->active = false; + fibril_mutex_initialize(&instance->guard); + fibril_condvar_initialize(&instance->avail); + endpoint_clear_hc_data(instance); + return EOK; +} +/*----------------------------------------------------------------------------*/ +void endpoint_destroy(endpoint_t *instance) +{ + assert(instance); + assert(!instance->active); + free(instance); +} +/*----------------------------------------------------------------------------*/ +void endpoint_set_hc_data(endpoint_t *instance, + void *data, int (*toggle_get)(void *), void (*toggle_set)(void *, int)) +{ + assert(instance); + instance->hc_data.data = data; + instance->hc_data.toggle_get = toggle_get; + instance->hc_data.toggle_set = toggle_set; +} +/*----------------------------------------------------------------------------*/ +void endpoint_clear_hc_data(endpoint_t *instance) +{ + assert(instance); + instance->hc_data.data = NULL; + instance->hc_data.toggle_get = NULL; + instance->hc_data.toggle_set = NULL; +} +/*----------------------------------------------------------------------------*/ +void endpoint_use(endpoint_t *instance) +{ + assert(instance); + fibril_mutex_lock(&instance->guard); + while (instance->active) + fibril_condvar_wait(&instance->avail, &instance->guard); + instance->active = true; + fibril_mutex_unlock(&instance->guard); +} +/*----------------------------------------------------------------------------*/ +void endpoint_release(endpoint_t *instance) +{ + assert(instance); + fibril_mutex_lock(&instance->guard); + instance->active = false; + fibril_mutex_unlock(&instance->guard); + fibril_condvar_signal(&instance->avail); +} +/*----------------------------------------------------------------------------*/ +int endpoint_toggle_get(endpoint_t *instance) +{ + assert(instance); + if (instance->hc_data.toggle_get) + instance->toggle = + instance->hc_data.toggle_get(instance->hc_data.data); + return (int)instance->toggle; +} +/*----------------------------------------------------------------------------*/ +void endpoint_toggle_set(endpoint_t *instance, int toggle) +{ + assert(instance); + assert(toggle == 0 || toggle == 1); + if (instance->hc_data.toggle_set) + instance->hc_data.toggle_set(instance->hc_data.data, toggle); + instance->toggle = toggle; +} +/*----------------------------------------------------------------------------*/ +void endpoint_toggle_reset_filtered(endpoint_t *instance, usb_target_t target) +{ + assert(instance); + if (instance->address == target.address && + (instance->endpoint == target.endpoint || target.endpoint == 0)) + endpoint_toggle_set(instance, 0); +} +/** + * @} + */ Index: uspace/lib/usbhost/src/usb_endpoint_manager.c =================================================================== --- uspace/lib/usbhost/src/usb_endpoint_manager.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbhost/src/usb_endpoint_manager.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,291 @@ +/* + * Copyright (c) 2011 Jan Vesely + * All rights eps. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include + +#include +#include + +#define BUCKET_COUNT 7 + +#define MAX_KEYS (3) +typedef struct { + link_t link; + size_t bw; + endpoint_t *ep; +} node_t; +/*----------------------------------------------------------------------------*/ +static hash_index_t node_hash(unsigned long key[]) +{ + hash_index_t hash = 0; + unsigned i = 0; + for (;i < MAX_KEYS; ++i) { + hash ^= key[i]; + } + hash %= BUCKET_COUNT; + return hash; +} +/*----------------------------------------------------------------------------*/ +static int node_compare(unsigned long key[], hash_count_t keys, link_t *item) +{ + assert(item); + node_t *node = hash_table_get_instance(item, node_t, link); + assert(node); + assert(node->ep); + bool match = true; + switch (keys) { + case 3: + match = match && (key[2] == node->ep->direction); + case 2: + match = match && (key[1] == (unsigned long)node->ep->endpoint); + case 1: + match = match && (key[0] == (unsigned long)node->ep->address); + break; + default: + match = false; + } + return match; +} +/*----------------------------------------------------------------------------*/ +static void node_remove(link_t *item) +{ + assert(item); + node_t *node = hash_table_get_instance(item, node_t, link); + endpoint_destroy(node->ep); + free(node); +} +/*----------------------------------------------------------------------------*/ +static void node_toggle_reset_filtered(link_t *item, void *arg) +{ + assert(item); + node_t *node = hash_table_get_instance(item, node_t, link); + usb_target_t *target = arg; + endpoint_toggle_reset_filtered(node->ep, *target); +} +/*----------------------------------------------------------------------------*/ +static hash_table_operations_t op = { + .hash = node_hash, + .compare = node_compare, + .remove_callback = node_remove, +}; +/*----------------------------------------------------------------------------*/ +size_t bandwidth_count_usb11(usb_speed_t speed, usb_transfer_type_t type, + size_t size, size_t max_packet_size) +{ + /* We care about bandwidth only for interrupt and isochronous. */ + if ((type != USB_TRANSFER_INTERRUPT) + && (type != USB_TRANSFER_ISOCHRONOUS)) { + return 0; + } + + const unsigned packet_count = + (size + max_packet_size - 1) / max_packet_size; + /* TODO: It may be that ISO and INT transfers use only one data packet + * per transaction, but I did not find text in UB spec that confirms + * this */ + /* NOTE: All data packets will be considered to be max_packet_size */ + switch (speed) + { + case USB_SPEED_LOW: + assert(type == USB_TRANSFER_INTERRUPT); + /* Protocol overhead 13B + * (3 SYNC bytes, 3 PID bytes, 2 Endpoint + CRC bytes, 2 + * CRC bytes, and a 3-byte interpacket delay) + * see USB spec page 45-46. */ + /* Speed penalty 8: low speed is 8-times slower*/ + return packet_count * (13 + max_packet_size) * 8; + case USB_SPEED_FULL: + /* Interrupt transfer overhead see above + * or page 45 of USB spec */ + if (type == USB_TRANSFER_INTERRUPT) + return packet_count * (13 + max_packet_size); + + assert(type == USB_TRANSFER_ISOCHRONOUS); + /* Protocol overhead 9B + * (2 SYNC bytes, 2 PID bytes, 2 Endpoint + CRC bytes, 2 CRC + * bytes, and a 1-byte interpacket delay) + * see USB spec page 42 */ + return packet_count * (9 + max_packet_size); + default: + return 0; + } +} +/*----------------------------------------------------------------------------*/ +int usb_endpoint_manager_init(usb_endpoint_manager_t *instance, + size_t available_bandwidth) +{ + assert(instance); + fibril_mutex_initialize(&instance->guard); + fibril_condvar_initialize(&instance->change); + instance->free_bw = available_bandwidth; + bool ht = + hash_table_create(&instance->ep_table, BUCKET_COUNT, MAX_KEYS, &op); + return ht ? EOK : ENOMEM; +} +/*----------------------------------------------------------------------------*/ +void usb_endpoint_manager_destroy(usb_endpoint_manager_t *instance) +{ + hash_table_destroy(&instance->ep_table); +} +/*----------------------------------------------------------------------------*/ +int usb_endpoint_manager_register_ep(usb_endpoint_manager_t *instance, + endpoint_t *ep, size_t data_size) +{ + assert(ep); + size_t bw = bandwidth_count_usb11(ep->speed, ep->transfer_type, + data_size, ep->max_packet_size); + assert(instance); + + unsigned long key[MAX_KEYS] = + {ep->address, ep->endpoint, ep->direction}; + fibril_mutex_lock(&instance->guard); + + link_t *item = + hash_table_find(&instance->ep_table, key); + if (item != NULL) { + fibril_mutex_unlock(&instance->guard); + return EEXISTS; + } + + if (bw > instance->free_bw) { + fibril_mutex_unlock(&instance->guard); + return ENOSPC; + } + + node_t *node = malloc(sizeof(node_t)); + if (node == NULL) { + fibril_mutex_unlock(&instance->guard); + return ENOMEM; + } + + node->bw = bw; + node->ep = ep; + link_initialize(&node->link); + + hash_table_insert(&instance->ep_table, key, &node->link); + instance->free_bw -= bw; + fibril_mutex_unlock(&instance->guard); + fibril_condvar_broadcast(&instance->change); + return EOK; +} +/*----------------------------------------------------------------------------*/ +int usb_endpoint_manager_unregister_ep(usb_endpoint_manager_t *instance, + usb_address_t address, usb_endpoint_t endpoint, usb_direction_t direction) +{ + assert(instance); + unsigned long key[MAX_KEYS] = {address, endpoint, direction}; + + fibril_mutex_lock(&instance->guard); + link_t *item = hash_table_find(&instance->ep_table, key); + if (item == NULL) { + fibril_mutex_unlock(&instance->guard); + return EINVAL; + } + + node_t *node = hash_table_get_instance(item, node_t, link); + if (node->ep->active) + return EBUSY; + + instance->free_bw += node->bw; + hash_table_remove(&instance->ep_table, key, MAX_KEYS); + + fibril_mutex_unlock(&instance->guard); + fibril_condvar_broadcast(&instance->change); + return EOK; +} +/*----------------------------------------------------------------------------*/ +endpoint_t * usb_endpoint_manager_get_ep(usb_endpoint_manager_t *instance, + usb_address_t address, usb_endpoint_t endpoint, usb_direction_t direction, + size_t *bw) +{ + assert(instance); + unsigned long key[MAX_KEYS] = {address, endpoint, direction}; + + fibril_mutex_lock(&instance->guard); + link_t *item = hash_table_find(&instance->ep_table, key); + if (item == NULL) { + fibril_mutex_unlock(&instance->guard); + return NULL; + } + node_t *node = hash_table_get_instance(item, node_t, link); + if (bw) + *bw = node->bw; + + fibril_mutex_unlock(&instance->guard); + return node->ep; +} +/*----------------------------------------------------------------------------*/ +/** Check setup packet data for signs of toggle reset. + * + * @param[in] instance Device keeper structure to use. + * @param[in] target Device to receive setup packet. + * @param[in] data Setup packet data. + * + * Really ugly one. + */ +void usb_endpoint_manager_reset_if_need( + usb_endpoint_manager_t *instance, usb_target_t target, const uint8_t *data) +{ + assert(instance); + if (target.endpoint > 15 || target.endpoint < 0 + || target.address >= USB11_ADDRESS_MAX || target.address < 0) { + usb_log_error("Invalid data when checking for toggle reset.\n"); + return; + } + + switch (data[1]) + { + case 0x01: /*clear feature*/ + /* recipient is endpoint, value is zero (ENDPOINT_STALL) */ + if (((data[0] & 0xf) == 1) && ((data[2] | data[3]) == 0)) { + /* endpoint number is < 16, thus first byte is enough */ + usb_target_t reset_target = + { .address = target.address, data[4] }; + fibril_mutex_lock(&instance->guard); + hash_table_apply(&instance->ep_table, + node_toggle_reset_filtered, &reset_target); + fibril_mutex_unlock(&instance->guard); + } + break; + + case 0x9: /* set configuration */ + case 0x11: /* set interface */ + /* target must be device */ + if ((data[0] & 0xf) == 0) { + usb_target_t reset_target = + { .address = target.address, 0 }; + fibril_mutex_lock(&instance->guard); + hash_table_apply(&instance->ep_table, + node_toggle_reset_filtered, &reset_target); + fibril_mutex_unlock(&instance->guard); + } + break; + } +} Index: uspace/lib/usbvirt/Makefile =================================================================== --- uspace/lib/usbvirt/Makefile (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbvirt/Makefile (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,46 @@ +# +# Copyright (c) 2011 Vojtech Horky +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# - Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# - Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# - The name of the author may not be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +USPACE_PREFIX = ../.. +LIBRARY = libusbvirt + +EXTRA_CFLAGS = \ + -I$(LIBDRV_PREFIX)/include \ + -I$(LIBUSB_PREFIX)/include \ + -I$(LIBUSBDEV_PREFIX)/include \ + -Iinclude + +SOURCES = \ + src/ctrltransfer.c \ + src/device.c \ + src/ipc_dev.c \ + src/ipc_hc.c \ + src/stdreq.c \ + src/transfer.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/lib/usbvirt/include/usbvirt/device.h =================================================================== --- uspace/lib/usbvirt/include/usbvirt/device.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbvirt/include/usbvirt/device.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,221 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbvirt + * @{ + */ +/** @file + * Virtual USB device. + */ + +#ifndef LIBUSBVIRT_DEVICE_H_ +#define LIBUSBVIRT_DEVICE_H_ + +#include +#include +#include + +/** Maximum number of endpoints supported by virtual USB. */ +#define USBVIRT_ENDPOINT_MAX 16 + +typedef struct usbvirt_device usbvirt_device_t; + +/** Callback for data to device (OUT transaction). + * + * @param dev Virtual device to which the transaction belongs. + * @param endpoint Target endpoint number. + * @param transfer_type Transfer type. + * @param buffer Data buffer. + * @param buffer_size Size of the buffer in bytes. + * @return Error code. + */ +typedef int (*usbvirt_on_data_to_device_t)(usbvirt_device_t *dev, + usb_endpoint_t endpoint, usb_transfer_type_t transfer_type, + void *buffer, size_t buffer_size); + +/** Callback for data from device (IN transaction). + * + * @param dev Virtual device to which the transaction belongs. + * @param endpoint Target endpoint number. + * @param transfer_type Transfer type. + * @param buffer Data buffer to write answer to. + * @param buffer_size Size of the buffer in bytes. + * @param act_buffer_size Write here how many bytes were actually written. + * @return Error code. + */ +typedef int (*usbvirt_on_data_from_device_t)(usbvirt_device_t *dev, + usb_endpoint_t endpoint, usb_transfer_type_t transfer_type, + void *buffer, size_t buffer_size, size_t *act_buffer_size); + +/** Callback for control transfer on endpoint zero. + * + * Notice that size of the data buffer is expected to be read from the + * setup packet. + * + * @param dev Virtual device to which the transaction belongs. + * @param setup_packet Standard setup packet. + * @param data Data (might be NULL). + * @param act_data_size Size of returned data in bytes. + * @return Error code. + */ +typedef int (*usbvirt_on_control_t)(usbvirt_device_t *dev, + const usb_device_request_setup_packet_t *setup_packet, + uint8_t *data, size_t *act_data_size); + +/** Callback for control request on a virtual USB device. + * + * See usbvirt_control_reply_helper() for simple way of answering + * control read requests. + */ +typedef struct { + /** Request direction (in or out). */ + usb_direction_t req_direction; + /** Request recipient (device, interface or endpoint). */ + usb_request_recipient_t req_recipient; + /** Request type (standard, class or vendor). */ + usb_request_type_t req_type; + /** Actual request code. */ + uint8_t request; + /** Request handler name for debugging purposes. */ + const char *name; + /** Callback to be executed on matching request. */ + usbvirt_on_control_t callback; +} usbvirt_control_request_handler_t; + +/** Extra configuration data for GET_CONFIGURATION request. */ +typedef struct { + /** Actual data. */ + uint8_t *data; + /** Data length. */ + size_t length; +} usbvirt_device_configuration_extras_t; + +/** Single device configuration. */ +typedef struct { + /** Standard configuration descriptor. */ + usb_standard_configuration_descriptor_t *descriptor; + /** Array of extra data. */ + usbvirt_device_configuration_extras_t *extra; + /** Length of @c extra array. */ + size_t extra_count; +} usbvirt_device_configuration_t; + +/** Standard USB descriptors for virtual device. */ +typedef struct { + /** Standard device descriptor. + * There is always only one such descriptor for the device. + */ + usb_standard_device_descriptor_t *device; + + /** Configurations. */ + usbvirt_device_configuration_t *configuration; + /** Number of configurations. */ + size_t configuration_count; +} usbvirt_descriptors_t; + +/** Possible states of virtual USB device. + * Notice that these are not 1:1 mappings to those in USB specification. + */ +typedef enum { + /** Default state, device listens at default address. */ + USBVIRT_STATE_DEFAULT, + /** Device has non-default address assigned. */ + USBVIRT_STATE_ADDRESS, + /** Device is configured. */ + USBVIRT_STATE_CONFIGURED +} usbvirt_device_state_t; + +/** Ops structure for virtual USB device. */ +typedef struct { + /** Callbacks for data to device. + * Index zero is ignored. + */ + usbvirt_on_data_to_device_t data_out[USBVIRT_ENDPOINT_MAX]; + /** Callbacks for data from device. + * Index zero is ignored. + */ + usbvirt_on_data_from_device_t data_in[USBVIRT_ENDPOINT_MAX]; + /** Array of control handlers. + * Last handler is expected to have the @c callback field set to NULL + */ + usbvirt_control_request_handler_t *control; + /** Callback when device changes state. + * + * The value of @c state attribute of @p dev device is not + * defined during call of this function. + * + * @param dev The virtual USB device. + * @param old_state Old device state. + * @param new_state New device state. + */ + void (*state_changed)(usbvirt_device_t *dev, + usbvirt_device_state_t old_state, usbvirt_device_state_t new_state); +} usbvirt_device_ops_t; + +/** Virtual USB device. */ +struct usbvirt_device { + /** Name for debugging purposes. */ + const char *name; + /** Custom device data. */ + void *device_data; + /** Device ops. */ + usbvirt_device_ops_t *ops; + /** Device descriptors. */ + usbvirt_descriptors_t *descriptors; + /** Current device address. + * You shall treat this field as read only in your code. + */ + usb_address_t address; + /** Current device state. + * You shall treat this field as read only in your code. + */ + usbvirt_device_state_t state; + /** Session to the host controller. + * You shall treat this field as read only in your code. + */ + async_sess_t *vhc_sess; +}; + +int usbvirt_device_plug(usbvirt_device_t *, const char *); +void usbvirt_device_unplug(usbvirt_device_t *); + +void usbvirt_control_reply_helper(const usb_device_request_setup_packet_t *, + uint8_t *, size_t *, void *, size_t); + +int usbvirt_control_write(usbvirt_device_t *, void *, size_t, void *, size_t); +int usbvirt_control_read(usbvirt_device_t *, void *, size_t, void *, size_t, size_t *); +int usbvirt_data_out(usbvirt_device_t *, usb_transfer_type_t, usb_endpoint_t, + void *, size_t); +int usbvirt_data_in(usbvirt_device_t *, usb_transfer_type_t, usb_endpoint_t, + void *, size_t, size_t *); + +#endif + +/** + * @} + */ Index: uspace/lib/usbvirt/include/usbvirt/ipc.h =================================================================== --- uspace/lib/usbvirt/include/usbvirt/ipc.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbvirt/include/usbvirt/ipc.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,73 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbvirt + * @{ + */ +/** @file + * IPC wrappers for virtual USB. + */ + +#ifndef LIBUSBVIRT_IPC_H_ +#define LIBUSBVIRT_IPC_H_ + +#include +#include +#include +#include +#include + +/** IPC methods communication between host controller and virtual device. */ +typedef enum { + IPC_M_USBVIRT_GET_NAME = IPC_FIRST_USER_METHOD + 80, + IPC_M_USBVIRT_CONTROL_READ, + IPC_M_USBVIRT_CONTROL_WRITE, + IPC_M_USBVIRT_INTERRUPT_IN, + IPC_M_USBVIRT_INTERRUPT_OUT, + IPC_M_USBVIRT_BULK_IN, + IPC_M_USBVIRT_BULK_OUT +} usbvirt_hc_to_device_method_t; + +extern int usbvirt_ipc_send_control_read(async_sess_t *, void *, size_t, + void *, size_t, size_t *); +extern int usbvirt_ipc_send_control_write(async_sess_t *, void *, size_t, + void *, size_t); +extern int usbvirt_ipc_send_data_in(async_sess_t *, usb_endpoint_t, + usb_transfer_type_t, void *, size_t, size_t *); +extern int usbvirt_ipc_send_data_out(async_sess_t *, usb_endpoint_t, + usb_transfer_type_t, void *, size_t); + +extern bool usbvirt_is_usbvirt_method(sysarg_t); +extern bool usbvirt_ipc_handle_call(usbvirt_device_t *, ipc_callid_t, + ipc_call_t *); + +#endif + +/** + * @} + */ Index: uspace/lib/usbvirt/src/ctrltransfer.c =================================================================== --- uspace/lib/usbvirt/src/ctrltransfer.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbvirt/src/ctrltransfer.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,102 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbvirt + * @{ + */ +/** @file + * Control transfer handling. + */ +#include "private.h" +#include +#include +#include +#include + +/** Find and execute control transfer handler for virtual USB device. + * + * @param dev Target virtual device. + * @param control_handlers Array of control request handlers. + * @param setup Setup packet. + * @param data Extra data. + * @param data_sent_size Size of extra data in bytes. + * @return Error code. + * @retval EFORWARD No suitable handler found. + */ +int process_control_transfer(usbvirt_device_t *dev, + usbvirt_control_request_handler_t *control_handlers, + usb_device_request_setup_packet_t *setup, + uint8_t *data, size_t *data_sent_size) +{ + assert(dev); + assert(setup); + + if (control_handlers == NULL) { + return EFORWARD; + } + + usb_direction_t direction = setup->request_type & 128 ? + USB_DIRECTION_IN : USB_DIRECTION_OUT; + usb_request_recipient_t req_recipient = setup->request_type & 31; + usb_request_type_t req_type = (setup->request_type >> 5) & 3; + + usbvirt_control_request_handler_t *handler = control_handlers; + while (handler->callback != NULL) { + if (handler->req_direction != direction) { + goto next; + } + if (handler->req_recipient != req_recipient) { + goto next; + } + if (handler->req_type != req_type) { + goto next; + } + if (handler->request != setup->request) { + goto next; + } + + usb_log_debug("Control transfer: %s(%s)\n", handler->name, + usb_debug_str_buffer((uint8_t*) setup, sizeof(*setup), 0)); + int rc = handler->callback(dev, setup, data, data_sent_size); + if (rc == EFORWARD) { + goto next; + } + + return rc; + +next: + handler++; + } + + return EFORWARD; +} + + +/** + * @} + */ Index: uspace/lib/usbvirt/src/device.c =================================================================== --- uspace/lib/usbvirt/src/device.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbvirt/src/device.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,121 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbvirt + * @{ + */ +/** @file + * Virtual USB device main routines. + */ +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +/** Current device. */ +static usbvirt_device_t *DEV = NULL; + +/** Main IPC call handling from virtual host controller. + * + * @param iid Caller identification. + * @param icall Initial incoming call. + */ +static void callback_connection(ipc_callid_t iid, ipc_call_t *icall) +{ + assert(DEV != NULL); + + async_answer_0(iid, EOK); + + while (true) { + ipc_callid_t callid; + ipc_call_t call; + + callid = async_get_call(&call); + bool processed = usbvirt_ipc_handle_call(DEV, callid, &call); + if (!processed) { + if (!IPC_GET_IMETHOD(call)) { + async_answer_0(callid, EOK); + return; + } else + async_answer_0(callid, EINVAL); + } + } +} + +/** Connect the device to the virtual host controller. + * + * @param dev The virtual device to be (virtually) plugged in. + * @param vhc_path Devman path to the virtual host controller. + * @return Error code. + */ +int usbvirt_device_plug(usbvirt_device_t *dev, const char *vhc_path) +{ + if (DEV != NULL) + return ELIMIT; + + devman_handle_t handle; + int rc = devman_device_get_handle(vhc_path, &handle, 0); + if (rc != EOK) + return rc; + + async_sess_t *hcd_sess = + devman_device_connect(EXCHANGE_SERIALIZE, handle, 0); + if (!hcd_sess) + return ENOMEM; + + DEV = dev; + dev->vhc_sess = hcd_sess; + + async_exch_t *exch = async_exchange_begin(hcd_sess); + rc = async_connect_to_me(exch, 0, 0, 0, callback_connection); + async_exchange_end(exch); + + if (rc != EOK) + DEV = NULL; + + return rc; +} + +/** Disconnect the device from virtual host controller. + * + * @param dev Device to be disconnected. + */ +void usbvirt_device_unplug(usbvirt_device_t *dev) +{ + async_hangup(dev->vhc_sess); +} + +/** + * @} + */ Index: uspace/lib/usbvirt/src/ipc_dev.c =================================================================== --- uspace/lib/usbvirt/src/ipc_dev.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbvirt/src/ipc_dev.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,297 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbvirt + * @{ + */ +/** @file + * IPC wrappers, device side. + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/** Handle VHC request for device name. + * + * @param dev Target virtual device. + * @param iid Caller id. + * @param icall The call with the request. + */ +static void ipc_get_name(usbvirt_device_t *dev, + ipc_callid_t iid, ipc_call_t *icall) +{ + if (dev->name == NULL) { + async_answer_0(iid, ENOENT); + } + + size_t size = str_size(dev->name); + + ipc_callid_t callid; + size_t accepted_size; + if (!async_data_read_receive(&callid, &accepted_size)) { + async_answer_0(iid, EINVAL); + return; + } + + if (accepted_size > size) { + accepted_size = size; + } + async_data_read_finalize(callid, dev->name, accepted_size); + + async_answer_1(iid, EOK, accepted_size); +} + +/** Handle VHC request for control read from the device. + * + * @param dev Target virtual device. + * @param iid Caller id. + * @param icall The call with the request. + */ +static void ipc_control_read(usbvirt_device_t *dev, + ipc_callid_t iid, ipc_call_t *icall) +{ + int rc; + + void *setup_packet = NULL; + size_t setup_packet_len = 0; + size_t data_len = 0; + + rc = async_data_write_accept(&setup_packet, false, + 1, 1024, 0, &setup_packet_len); + if (rc != EOK) { + async_answer_0(iid, rc); + return; + } + + ipc_callid_t data_callid; + if (!async_data_read_receive(&data_callid, &data_len)) { + async_answer_0(iid, EPARTY); + free(setup_packet); + return; + } + + void *buffer = malloc(data_len); + if (buffer == NULL) { + async_answer_0(iid, ENOMEM); + free(setup_packet); + return; + } + + size_t actual_len; + rc = usbvirt_control_read(dev, setup_packet, setup_packet_len, + buffer, data_len, &actual_len); + + if (rc != EOK) { + async_answer_0(data_callid, rc); + async_answer_0(iid, rc); + free(setup_packet); + free(buffer); + return; + } + + async_data_read_finalize(data_callid, buffer, actual_len); + async_answer_0(iid, EOK); + + free(setup_packet); + free(buffer); +} + +/** Handle VHC request for control write to the device. + * + * @param dev Target virtual device. + * @param iid Caller id. + * @param icall The call with the request. + */ +static void ipc_control_write(usbvirt_device_t *dev, + ipc_callid_t iid, ipc_call_t *icall) +{ + size_t data_buffer_len = IPC_GET_ARG1(*icall); + int rc; + + void *setup_packet = NULL; + void *data_buffer = NULL; + size_t setup_packet_len = 0; + + rc = async_data_write_accept(&setup_packet, false, + 1, 0, 0, &setup_packet_len); + if (rc != EOK) { + async_answer_0(iid, rc); + return; + } + + if (data_buffer_len > 0) { + rc = async_data_write_accept(&data_buffer, false, + 1, 0, 0, &data_buffer_len); + if (rc != EOK) { + async_answer_0(iid, rc); + free(setup_packet); + return; + } + } + + rc = usbvirt_control_write(dev, setup_packet, setup_packet_len, + data_buffer, data_buffer_len); + + async_answer_0(iid, rc); + + free(setup_packet); + if (data_buffer != NULL) { + free(data_buffer); + } +} + +/** Handle VHC request for data read from the device (in transfer). + * + * @param dev Target virtual device. + * @param iid Caller id. + * @param icall The call with the request. + */ +static void ipc_data_in(usbvirt_device_t *dev, + usb_transfer_type_t transfer_type, + ipc_callid_t iid, ipc_call_t *icall) +{ + usb_endpoint_t endpoint = IPC_GET_ARG1(*icall); + + int rc; + + size_t data_len = 0; + ipc_callid_t data_callid; + if (!async_data_read_receive(&data_callid, &data_len)) { + async_answer_0(iid, EPARTY); + return; + } + + void *buffer = malloc(data_len); + if (buffer == NULL) { + async_answer_0(iid, ENOMEM); + return; + } + + size_t actual_len; + rc = usbvirt_data_in(dev, transfer_type, endpoint, + buffer, data_len, &actual_len); + + if (rc != EOK) { + async_answer_0(data_callid, rc); + async_answer_0(iid, rc); + free(buffer); + return; + } + + async_data_read_finalize(data_callid, buffer, actual_len); + async_answer_0(iid, EOK); + + free(buffer); +} + +/** Handle VHC request for data write to the device (out transfer). + * + * @param dev Target virtual device. + * @param iid Caller id. + * @param icall The call with the request. + */ +static void ipc_data_out(usbvirt_device_t *dev, + usb_transfer_type_t transfer_type, + ipc_callid_t iid, ipc_call_t *icall) +{ + usb_endpoint_t endpoint = IPC_GET_ARG1(*icall); + + void *data_buffer = NULL; + size_t data_buffer_size = 0; + + int rc = async_data_write_accept(&data_buffer, false, + 1, 0, 0, &data_buffer_size); + if (rc != EOK) { + async_answer_0(iid, rc); + return; + } + + rc = usbvirt_data_out(dev, transfer_type, endpoint, + data_buffer, data_buffer_size); + + async_answer_0(iid, rc); + + free(data_buffer); +} + +/** Handle incoming IPC call for virtual USB device. + * + * @param dev Target USB device. + * @param callid Caller id. + * @param call Incoming call. + * @return Whether the call was handled. + */ +bool usbvirt_ipc_handle_call(usbvirt_device_t *dev, + ipc_callid_t callid, ipc_call_t *call) +{ + switch (IPC_GET_IMETHOD(*call)) { + case IPC_M_USBVIRT_GET_NAME: + ipc_get_name(dev, callid, call); + break; + + case IPC_M_USBVIRT_CONTROL_READ: + ipc_control_read(dev, callid, call); + break; + + case IPC_M_USBVIRT_CONTROL_WRITE: + ipc_control_write(dev, callid, call); + break; + + case IPC_M_USBVIRT_INTERRUPT_IN: + ipc_data_in(dev, USB_TRANSFER_INTERRUPT, callid, call); + break; + + case IPC_M_USBVIRT_BULK_IN: + ipc_data_in(dev, USB_TRANSFER_BULK, callid, call); + break; + + case IPC_M_USBVIRT_INTERRUPT_OUT: + ipc_data_out(dev, USB_TRANSFER_INTERRUPT, callid, call); + break; + + case IPC_M_USBVIRT_BULK_OUT: + ipc_data_out(dev, USB_TRANSFER_BULK, callid, call); + break; + + + default: + return false; + } + + return true; +} + +/** + * @} + */ Index: uspace/lib/usbvirt/src/ipc_hc.c =================================================================== --- uspace/lib/usbvirt/src/ipc_hc.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbvirt/src/ipc_hc.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,316 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbvirt + * @{ + */ +/** @file + * IPC wrappers, host controller side. + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/** Send control read transfer to virtual USB device. + * + * @param sess Session to the virtual device. + * @param ep Target endpoint number. + * @param setup_buffer Setup buffer. + * @param setup_buffer_size Setup buffer size in bytes. + * @param data_buffer Data buffer (DATA stage of control transfer). + * @param data_buffer_size Size of data buffer in bytes. + * @param data_transfered_size Number of actually transferred bytes. + * + * @return Error code. + * + */ +int usbvirt_ipc_send_control_read(async_sess_t *sess, void *setup_buffer, + size_t setup_buffer_size, void *data_buffer, size_t data_buffer_size, + size_t *data_transfered_size) +{ + if (!sess) + return EINVAL; + + if ((setup_buffer == NULL) || (setup_buffer_size == 0)) + return EINVAL; + + if ((data_buffer == NULL) || (data_buffer_size == 0)) + return EINVAL; + + async_exch_t *exch = async_exchange_begin(sess); + + aid_t opening_request = async_send_0(exch, IPC_M_USBVIRT_CONTROL_READ, + NULL); + if (opening_request == 0) { + async_exchange_end(exch); + return ENOMEM; + } + + int rc = async_data_write_start(exch, setup_buffer, setup_buffer_size); + if (rc != EOK) { + async_exchange_end(exch); + async_wait_for(opening_request, NULL); + return rc; + } + + ipc_call_t data_request_call; + aid_t data_request = async_data_read(exch, data_buffer, data_buffer_size, + &data_request_call); + + async_exchange_end(exch); + + if (data_request == 0) { + async_wait_for(opening_request, NULL); + return ENOMEM; + } + + sysarg_t data_request_rc; + sysarg_t opening_request_rc; + async_wait_for(data_request, &data_request_rc); + async_wait_for(opening_request, &opening_request_rc); + + if (data_request_rc != EOK) { + /* Prefer the return code of the opening request. */ + if (opening_request_rc != EOK) + return (int) opening_request_rc; + else + return (int) data_request_rc; + } + + if (opening_request_rc != EOK) + return (int) opening_request_rc; + + if (data_transfered_size != NULL) + *data_transfered_size = IPC_GET_ARG2(data_request_call); + + return EOK; +} + +/** Send control write transfer to virtual USB device. + * + * @param sess Session to the virtual device. + * @param ep Target endpoint number. + * @param setup_buffer Setup buffer. + * @param setup_buffer_size Setup buffer size in bytes. + * @param data_buffer Data buffer (DATA stage of control transfer). + * @param data_buffer_size Size of data buffer in bytes. + * + * @return Error code. + * + */ +int usbvirt_ipc_send_control_write(async_sess_t *sess, void *setup_buffer, + size_t setup_buffer_size, void *data_buffer, size_t data_buffer_size) +{ + if (!sess) + return EINVAL; + + if ((setup_buffer == NULL) || (setup_buffer_size == 0)) + return EINVAL; + + if ((data_buffer_size > 0) && (data_buffer == NULL)) + return EINVAL; + + async_exch_t *exch = async_exchange_begin(sess); + + aid_t opening_request = async_send_1(exch, IPC_M_USBVIRT_CONTROL_WRITE, + data_buffer_size, NULL); + if (opening_request == 0) { + async_exchange_end(exch); + return ENOMEM; + } + + int rc = async_data_write_start(exch, setup_buffer, setup_buffer_size); + if (rc != EOK) { + async_exchange_end(exch); + async_wait_for(opening_request, NULL); + return rc; + } + + if (data_buffer_size > 0) { + rc = async_data_write_start(exch, data_buffer, data_buffer_size); + if (rc != EOK) { + async_exchange_end(exch); + async_wait_for(opening_request, NULL); + return rc; + } + } + + async_exchange_end(exch); + + sysarg_t opening_request_rc; + async_wait_for(opening_request, &opening_request_rc); + + return (int) opening_request_rc; +} + +/** Request data transfer from virtual USB device. + * + * @param sess Session to the virtual device. + * @param ep Target endpoint number. + * @param tr_type Transfer type (interrupt or bulk). + * @param data Data buffer. + * @param data_size Size of the data buffer in bytes. + * @param act_size Number of actually returned bytes. + * + * @return Error code. + * + */ +int usbvirt_ipc_send_data_in(async_sess_t *sess, usb_endpoint_t ep, + usb_transfer_type_t tr_type, void *data, size_t data_size, size_t *act_size) +{ + if (!sess) + return EINVAL; + + usbvirt_hc_to_device_method_t method; + + switch (tr_type) { + case USB_TRANSFER_INTERRUPT: + method = IPC_M_USBVIRT_INTERRUPT_IN; + break; + case USB_TRANSFER_BULK: + method = IPC_M_USBVIRT_BULK_IN; + break; + default: + return EINVAL; + } + + if ((ep <= 0) || (ep >= USBVIRT_ENDPOINT_MAX)) + return EINVAL; + + if ((data == NULL) || (data_size == 0)) + return EINVAL; + + async_exch_t *exch = async_exchange_begin(sess); + + aid_t opening_request = async_send_2(exch, method, ep, tr_type, NULL); + if (opening_request == 0) { + async_exchange_end(exch); + return ENOMEM; + } + + ipc_call_t data_request_call; + aid_t data_request = async_data_read(exch, data, data_size, + &data_request_call); + + async_exchange_end(exch); + + if (data_request == 0) { + async_wait_for(opening_request, NULL); + return ENOMEM; + } + + sysarg_t data_request_rc; + sysarg_t opening_request_rc; + async_wait_for(data_request, &data_request_rc); + async_wait_for(opening_request, &opening_request_rc); + + if (data_request_rc != EOK) { + /* Prefer the return code of the opening request. */ + if (opening_request_rc != EOK) + return (int) opening_request_rc; + else + return (int) data_request_rc; + } + + if (opening_request_rc != EOK) + return (int) opening_request_rc; + + if (act_size != NULL) + *act_size = IPC_GET_ARG2(data_request_call); + + return EOK; +} + +/** Send data to virtual USB device. + * + * @param sess Session to the virtual device. + * @param ep Target endpoint number. + * @param tr_type Transfer type (interrupt or bulk). + * @param data Data buffer. + * @param data_size Size of the data buffer in bytes. + * + * @return Error code. + * + */ +int usbvirt_ipc_send_data_out(async_sess_t *sess, usb_endpoint_t ep, + usb_transfer_type_t tr_type, void *data, size_t data_size) +{ + if (!sess) + return EINVAL; + + usbvirt_hc_to_device_method_t method; + + switch (tr_type) { + case USB_TRANSFER_INTERRUPT: + method = IPC_M_USBVIRT_INTERRUPT_OUT; + break; + case USB_TRANSFER_BULK: + method = IPC_M_USBVIRT_BULK_OUT; + break; + default: + return EINVAL; + } + + if ((ep <= 0) || (ep >= USBVIRT_ENDPOINT_MAX)) + return EINVAL; + + if ((data == NULL) || (data_size == 0)) + return EINVAL; + + async_exch_t *exch = async_exchange_begin(sess); + + aid_t opening_request = async_send_1(exch, method, ep, NULL); + if (opening_request == 0) { + async_exchange_end(exch); + return ENOMEM; + } + + int rc = async_data_write_start(exch, data, data_size); + + async_exchange_end(exch); + + if (rc != EOK) { + async_wait_for(opening_request, NULL); + return rc; + } + + sysarg_t opening_request_rc; + async_wait_for(opening_request, &opening_request_rc); + + return (int) opening_request_rc; +} + +/** + * @} + */ Index: uspace/lib/usbvirt/src/private.h =================================================================== --- uspace/lib/usbvirt/src/private.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbvirt/src/private.h (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbvirt + * @{ + */ +/** @file + * Private definitions. + */ +#ifndef USBVIRT_PRIVATE_H_ +#define USBVIRT_PRIVATE_H_ + +#include + +int process_control_transfer(usbvirt_device_t *, + usbvirt_control_request_handler_t *, + usb_device_request_setup_packet_t *, + uint8_t *, size_t *); + +extern usbvirt_control_request_handler_t library_handlers[]; + +#endif +/** + * @} + */ Index: uspace/lib/usbvirt/src/stdreq.c =================================================================== --- uspace/lib/usbvirt/src/stdreq.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbvirt/src/stdreq.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,223 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbvirt + * @{ + */ +/** @file + * Standard control request handlers. + */ +#include "private.h" +#include +#include +#include + +/** Helper for replying to control read transfer from virtual USB device. + * + * This function takes care of copying data to answer buffer taking care + * of buffer sizes properly. + * + * @param setup_packet The setup packet. + * @param data Data buffer to write to. + * @param act_size Where to write actual size of returned data. + * @param actual_data Data to be returned. + * @param actual_data_size Size of answer data (@p actual_data) in bytes. + */ +void usbvirt_control_reply_helper(const usb_device_request_setup_packet_t *setup_packet, + uint8_t *data, size_t *act_size, + void *actual_data, size_t actual_data_size) +{ + size_t expected_size = setup_packet->length; + if (expected_size < actual_data_size) { + actual_data_size = expected_size; + } + + memcpy(data, actual_data, actual_data_size); + + if (act_size != NULL) { + *act_size = actual_data_size; + } +} + +/** GET_DESCRIPTOR handler. */ +static int req_get_descriptor(usbvirt_device_t *device, + const usb_device_request_setup_packet_t *setup_packet, uint8_t *data, size_t *act_size) +{ + uint8_t type = setup_packet->value_high; + uint8_t index = setup_packet->value_low; + + /* + * Standard device descriptor. + */ + if ((type == USB_DESCTYPE_DEVICE) && (index == 0)) { + if (device->descriptors && device->descriptors->device) { + usbvirt_control_reply_helper(setup_packet, data, act_size, + device->descriptors->device, + device->descriptors->device->length); + return EOK; + } else { + return EFORWARD; + } + } + + /* + * Configuration descriptor together with interface, endpoint and + * class-specific descriptors. + */ + if (type == USB_DESCTYPE_CONFIGURATION) { + if (!device->descriptors) { + return EFORWARD; + } + if (index >= device->descriptors->configuration_count) { + return EFORWARD; + } + /* Copy the data. */ + usbvirt_device_configuration_t *config = &device->descriptors + ->configuration[index]; + uint8_t *all_data = malloc(config->descriptor->total_length); + if (all_data == NULL) { + return ENOMEM; + } + + uint8_t *ptr = all_data; + memcpy(ptr, config->descriptor, config->descriptor->length); + ptr += config->descriptor->length; + size_t i; + for (i = 0; i < config->extra_count; i++) { + usbvirt_device_configuration_extras_t *extra + = &config->extra[i]; + memcpy(ptr, extra->data, extra->length); + ptr += extra->length; + } + + usbvirt_control_reply_helper(setup_packet, data, act_size, + all_data, config->descriptor->total_length); + + free(all_data); + + return EOK; + } + + return EFORWARD; +} + +static int req_set_address(usbvirt_device_t *device, + const usb_device_request_setup_packet_t *setup_packet, uint8_t *data, size_t *act_size) +{ + uint16_t new_address = setup_packet->value; + uint16_t zero1 = setup_packet->index; + uint16_t zero2 = setup_packet->length; + + if ((zero1 != 0) || (zero2 != 0)) { + return EINVAL; + } + + if (new_address > 127) { + return EINVAL; + } + + device->address = new_address; + + return EOK; +} + +static int req_set_configuration(usbvirt_device_t *device, + const usb_device_request_setup_packet_t *setup_packet, uint8_t *data, size_t *act_size) +{ + uint16_t configuration_value = setup_packet->value; + uint16_t zero1 = setup_packet->index; + uint16_t zero2 = setup_packet->length; + + if ((zero1 != 0) || (zero2 != 0)) { + return EINVAL; + } + + /* + * Configuration value is 1 byte information. + */ + if (configuration_value > 255) { + return EINVAL; + } + + /* + * Do nothing when in default state. According to specification, + * this is not specified. + */ + if (device->state == USBVIRT_STATE_DEFAULT) { + return EOK; + } + + usbvirt_device_state_t new_state; + if (configuration_value == 0) { + new_state = USBVIRT_STATE_ADDRESS; + } else { + // FIXME: check that this configuration exists + new_state = USBVIRT_STATE_CONFIGURED; + } + + if (device->ops && device->ops->state_changed) { + device->ops->state_changed(device, device->state, new_state); + } + device->state = new_state; + + return EOK; +} + +/** Standard request handlers. */ +usbvirt_control_request_handler_t library_handlers[] = { + { + .req_direction = USB_DIRECTION_OUT, + .req_recipient = USB_REQUEST_RECIPIENT_DEVICE, + .req_type = USB_REQUEST_TYPE_STANDARD, + .request = USB_DEVREQ_SET_ADDRESS, + .name = "SetAddress", + .callback = req_set_address + }, + { + .req_direction = USB_DIRECTION_IN, + .req_recipient = USB_REQUEST_RECIPIENT_DEVICE, + .req_type = USB_REQUEST_TYPE_STANDARD, + .request = USB_DEVREQ_GET_DESCRIPTOR, + .name = "GetDescriptor", + .callback = req_get_descriptor + }, + { + .req_direction = USB_DIRECTION_OUT, + .req_recipient = USB_REQUEST_RECIPIENT_DEVICE, + .req_type = USB_REQUEST_TYPE_STANDARD, + .request = USB_DEVREQ_SET_CONFIGURATION, + .name = "SetConfiguration", + .callback = req_set_configuration + }, + + { .callback = NULL } +}; + +/** + * @} + */ Index: uspace/lib/usbvirt/src/transfer.c =================================================================== --- uspace/lib/usbvirt/src/transfer.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) +++ uspace/lib/usbvirt/src/transfer.c (revision f2a45d9dfce1c48cd7ca84792b0eedb9b0920ac8) @@ -0,0 +1,190 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbvirt + * @{ + */ +/** @file + * Transfer handling. + */ +#include +#include +#include +#include +#include "private.h" + +/** Process a control transfer to the virtual USB device. + * + * @param dev Target device. + * @param setup Setup packet data. + * @param setup_size Size of setup packet. + * @param data Extra data (DATA stage). + * @param data_size Size of extra data in bytes. + * @param data_size_sent Number of actually send bytes during the transfer + * (only used for READ transfers). + * @return Error code. + */ +static int usbvirt_control_transfer(usbvirt_device_t *dev, + void *setup, size_t setup_size, + void *data, size_t data_size, size_t *data_size_sent) +{ + assert(dev); + assert(dev->ops); + + if (setup_size != sizeof(usb_device_request_setup_packet_t)) { + return ESTALL; + } + usb_device_request_setup_packet_t *setup_packet = setup; + if (data_size != setup_packet->length) { + return ESTALL; + } + + int rc; + + /* Run user handler first. */ + rc = process_control_transfer(dev, dev->ops->control, + setup_packet, data, data_size_sent); + if (rc != EFORWARD) { + return rc; + } + + /* Run the library handlers afterwards. */ + rc = process_control_transfer(dev, library_handlers, + setup_packet, data, data_size_sent); + + if (rc == EFORWARD) { + usb_log_warning("Control transfer {%s (%s)} not handled.\n", + usb_debug_str_buffer(setup, setup_size, 10), + setup_packet->request_type & 0x80 + ? "IN" : usb_debug_str_buffer(data, data_size, 10)); + rc = EBADCHECKSUM; + } + + return rc; +} + +/** Issue a control write transfer to virtual USB device. + * + * @see usbvirt_control_transfer + * + * @param dev Target virtual device. + * @param setup Setup data. + * @param setup_size Size of setup packet. + * @param data Extra data (DATA stage). + * @param data_size Size of extra data buffer in bytes. + * @return Error code. + */ +int usbvirt_control_write(usbvirt_device_t *dev, void *setup, size_t setup_size, + void *data, size_t data_size) +{ + return usbvirt_control_transfer(dev, setup, setup_size, + data, data_size, NULL); +} + +/** Issue a control read transfer to virtual USB device. + * + * @see usbvirt_control_transfer + * + * @param dev Target virtual device. + * @param setup Setup data. + * @param setup_size Size of setup packet. + * @param data Extra data (DATA stage). + * @param data_size Size of extra data buffer in bytes. + * @param data_size_sent Number of actually send bytes during the transfer. + * @return Error code. + */ +int usbvirt_control_read(usbvirt_device_t *dev, void *setup, size_t setup_size, + void *data, size_t data_size, size_t *data_size_sent) +{ + return usbvirt_control_transfer(dev, setup, setup_size, + data, data_size, data_size_sent); +} + +/** Send data to virtual USB device. + * + * @param dev Target virtual device. + * @param transf_type Transfer type (interrupt, bulk). + * @param endpoint Endpoint number. + * @param data Data sent from the driver to the device. + * @param data_size Size of the @p data buffer in bytes. + * @return Error code. + */ +int usbvirt_data_out(usbvirt_device_t *dev, usb_transfer_type_t transf_type, + usb_endpoint_t endpoint, void *data, size_t data_size) +{ + if ((endpoint <= 0) || (endpoint >= USBVIRT_ENDPOINT_MAX)) { + return ERANGE; + } + if ((dev->ops == NULL) || (dev->ops->data_out[endpoint] == NULL)) { + return ENOTSUP; + } + + int rc = dev->ops->data_out[endpoint](dev, endpoint, transf_type, + data, data_size); + + return rc; +} + +/** Request data from virtual USB device. + * + * @param dev Target virtual device. + * @param transf_type Transfer type (interrupt, bulk). + * @param endpoint Endpoint number. + * @param data Where to stored data the device returns to the driver. + * @param data_size Size of the @p data buffer in bytes. + * @param data_size_sent Number of actually written bytes. + * @return Error code. + */ +int usbvirt_data_in(usbvirt_device_t *dev, usb_transfer_type_t transf_type, + usb_endpoint_t endpoint, void *data, size_t data_size, size_t *data_size_sent) +{ + if ((endpoint <= 0) || (endpoint >= USBVIRT_ENDPOINT_MAX)) { + return ERANGE; + } + if ((dev->ops == NULL) || (dev->ops->data_in[endpoint] == NULL)) { + return ENOTSUP; + } + + size_t data_size_sent_tmp; + int rc = dev->ops->data_in[endpoint](dev, endpoint, transf_type, + data, data_size, &data_size_sent_tmp); + + if (rc != EOK) { + return rc; + } + + if (data_size_sent != NULL) { + *data_size_sent = data_size_sent_tmp; + } + + return EOK; +} + +/** + * @} + */