Index: uspace/lib/c/Makefile =================================================================== --- uspace/lib/c/Makefile (revision 0b4e7ca5837665462dd121f3429fdf63fd6d33d7) +++ uspace/lib/c/Makefile (revision 0cec844d322f50cced98388fe8d510b61d40b3ce) @@ -77,4 +77,5 @@ generic/io/io.c \ generic/io/printf.c \ + generic/io/log.c \ generic/io/klog.c \ generic/io/snprintf.c \ Index: uspace/lib/c/generic/adt/hash_table.c =================================================================== --- uspace/lib/c/generic/adt/hash_table.c (revision 0b4e7ca5837665462dd121f3429fdf63fd6d33d7) +++ uspace/lib/c/generic/adt/hash_table.c (revision 0cec844d322f50cced98388fe8d510b61d40b3ce) @@ -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/devman.c =================================================================== --- uspace/lib/c/generic/devman.c (revision 0b4e7ca5837665462dd121f3429fdf63fd6d33d7) +++ uspace/lib/c/generic/devman.c (revision 0cec844d322f50cced98388fe8d510b61d40b3ce) @@ -147,6 +147,4 @@ ret = devman_send_match_id(phone, match_id); if (ret != EOK) { - printf("Driver failed to send match id, error %d\n", - ret); return ret; } @@ -195,10 +193,15 @@ } - devman_send_match_ids(phone, match_ids); - - async_wait_for(req, &retval); - - async_serialize_end(); - + int match_ids_rc = devman_send_match_ids(phone, match_ids); + + async_wait_for(req, &retval); + + async_serialize_end(); + + /* Prefer the answer to DEVMAN_ADD_FUNCTION in case of errors. */ + if ((match_ids_rc != EOK) && (retval == EOK)) { + retval = match_ids_rc; + } + if (retval == EOK) fun_handle = (int) IPC_GET_ARG1(answer); @@ -326,4 +329,49 @@ } +int devman_device_get_handle_by_class(const char *classname, + const char *devname, devman_handle_t *handle, unsigned int flags) +{ + int phone = devman_get_phone(DEVMAN_CLIENT, flags); + + if (phone < 0) + return phone; + + async_serialize_start(); + + ipc_call_t answer; + aid_t req = async_send_1(phone, DEVMAN_DEVICE_GET_HANDLE_BY_CLASS, + flags, &answer); + + sysarg_t retval = async_data_write_start(phone, classname, + str_size(classname)); + if (retval != EOK) { + async_wait_for(req, NULL); + async_serialize_end(); + return retval; + } + retval = async_data_write_start(phone, devname, + str_size(devname)); + if (retval != EOK) { + async_wait_for(req, NULL); + async_serialize_end(); + return retval; + } + + async_wait_for(req, &retval); + + async_serialize_end(); + + if (retval != EOK) { + if (handle != NULL) + *handle = (devman_handle_t) -1; + return retval; + } + + if (handle != NULL) + *handle = (devman_handle_t) IPC_GET_ARG1(answer); + + return retval; +} + /** @} Index: uspace/lib/c/generic/io/log.c =================================================================== --- uspace/lib/c/generic/io/log.c (revision 0cec844d322f50cced98388fe8d510b61d40b3ce) +++ uspace/lib/c/generic/io/log.c (revision 0cec844d322f50cced98388fe8d510b61d40b3ce) @@ -0,0 +1,123 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * Copyright (c) 2011 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 + * @{ + */ + +#include +#include +#include +#include +#include +#include + +#include + +/** Serialization mutex for logging functions. */ +static FIBRIL_MUTEX_INITIALIZE(log_serializer); + +/** Current log level. */ +static log_level_t log_level; + +static FILE *log_stream; + +static const char *log_prog_name; + +/** Prefixes for individual logging levels. */ +static const char *log_level_names[] = { + [LVL_FATAL] = "Fatal error", + [LVL_ERROR] = "Error", + [LVL_WARN] = "Warning", + [LVL_NOTE] = "Note", + [LVL_DEBUG] = "Debug", + [LVL_DEBUG2] = "Debug2" +}; + +/** Initialize the logging system. + * + * @param prog_name Program name, will be printed as part of message + * @param level Minimum message level to print + */ +int log_init(const char *prog_name, log_level_t level) +{ + assert(level < LVL_LIMIT); + log_level = level; + + log_stream = stdout; + log_prog_name = str_dup(prog_name); + if (log_prog_name == NULL) + return ENOMEM; + + return EOK; +} + +/** Write an entry to the log. + * + * @param level Message verbosity level. Message is only printed + * if verbosity is less than or equal to current + * reporting level. + * @param fmt Format string (no traling newline). + */ +void log_msg(log_level_t level, const char *fmt, ...) +{ + va_list args; + + va_start(args, fmt); + log_msgv(level, fmt, args); + va_end(args); +} + +/** Write an entry to the log (va_list variant). + * + * @param level Message verbosity level. Message is only printed + * if verbosity is less than or equal to current + * reporting level. + * @param fmt Format string (no trailing newline) + */ +void log_msgv(log_level_t level, const char *fmt, va_list args) +{ + assert(level < LVL_LIMIT); + + /* Higher number means higher verbosity. */ + if (level <= log_level) { + fibril_mutex_lock(&log_serializer); + + fprintf(log_stream, "%s: %s: ", log_prog_name, + log_level_names[level]); + vfprintf(log_stream, fmt, args); + fputc('\n', log_stream); + fflush(log_stream); + + fibril_mutex_unlock(&log_serializer); + } +} + +/** @} + */ Index: uspace/lib/c/include/adt/hash_table.h =================================================================== --- uspace/lib/c/include/adt/hash_table.h (revision 0b4e7ca5837665462dd121f3429fdf63fd6d33d7) +++ uspace/lib/c/include/adt/hash_table.h (revision 0cec844d322f50cced98388fe8d510b61d40b3ce) @@ -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/devman.h =================================================================== --- uspace/lib/c/include/devman.h (revision 0b4e7ca5837665462dd121f3429fdf63fd6d33d7) +++ uspace/lib/c/include/devman.h (revision 0cec844d322f50cced98388fe8d510b61d40b3ce) @@ -53,4 +53,6 @@ extern int devman_device_get_handle(const char *, devman_handle_t *, unsigned int); +extern int devman_device_get_handle_by_class(const char *, const char *, + devman_handle_t *, unsigned int); extern int devman_add_device_to_class(devman_handle_t, const char *); Index: uspace/lib/c/include/io/log.h =================================================================== --- uspace/lib/c/include/io/log.h (revision 0cec844d322f50cced98388fe8d510b61d40b3ce) +++ uspace/lib/c/include/io/log.h (revision 0cec844d322f50cced98388fe8d510b61d40b3ce) @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2011 Vojtech Horky + * Copyright (c) 2011 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 + * @{ + */ + +#ifndef LIBC_IO_LOG_H_ +#define LIBC_IO_LOG_H_ + +#include + +typedef enum { + LVL_FATAL, + LVL_ERROR, + LVL_WARN, + LVL_NOTE, + LVL_DEBUG, + LVL_DEBUG2, + + /** For checking range of values */ + LVL_LIMIT +} log_level_t; + +extern int log_init(const char *, log_level_t); +extern void log_msg(log_level_t, const char *, ...); +extern void log_msgv(log_level_t, const char *, va_list); + +#endif + +/** @} + */ Index: uspace/lib/c/include/ipc/devman.h =================================================================== --- uspace/lib/c/include/ipc/devman.h (revision 0b4e7ca5837665462dd121f3429fdf63fd6d33d7) +++ uspace/lib/c/include/ipc/devman.h (revision 0cec844d322f50cced98388fe8d510b61d40b3ce) @@ -148,5 +148,6 @@ typedef enum { - DEVMAN_DEVICE_GET_HANDLE = IPC_FIRST_USER_METHOD + DEVMAN_DEVICE_GET_HANDLE = IPC_FIRST_USER_METHOD, + DEVMAN_DEVICE_GET_HANDLE_BY_CLASS } client_to_devman_t; Index: uspace/lib/drv/Makefile =================================================================== --- uspace/lib/drv/Makefile (revision 0b4e7ca5837665462dd121f3429fdf63fd6d33d7) +++ uspace/lib/drv/Makefile (revision 0cec844d322f50cced98388fe8d510b61d40b3ce) @@ -36,4 +36,5 @@ generic/dev_iface.c \ generic/remote_char_dev.c \ + generic/log.c \ generic/remote_hw_res.c \ generic/remote_usb.c \ Index: uspace/lib/drv/generic/driver.c =================================================================== --- uspace/lib/drv/generic/driver.c (revision 0b4e7ca5837665462dd121f3429fdf63fd6d33d7) +++ uspace/lib/drv/generic/driver.c (revision 0cec844d322f50cced98388fe8d510b61d40b3ce) @@ -273,12 +273,6 @@ res = driver->driver_ops->add_device(dev); - if (res == EOK) { - printf("%s: new device with handle=%" PRIun " was added.\n", - driver->name, dev_handle); - } else { - printf("%s: failed to add a new device with handle = %" PRIun ".\n", - driver->name, dev_handle); + if (res != EOK) delete_device(dev); - } async_answer_0(iid, res); Index: uspace/lib/drv/generic/log.c =================================================================== --- uspace/lib/drv/generic/log.c (revision 0cec844d322f50cced98388fe8d510b61d40b3ce) +++ uspace/lib/drv/generic/log.c (revision 0cec844d322f50cced98388fe8d510b61d40b3ce) @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2011 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 libdrv + * @{ + */ + +#include +#include + +#include + +/** Initialize the logging system. + * + * @param drv_name Driver name, will be printed as part of message + * @param level Minimum message level to print + */ +int ddf_log_init(const char *drv_name, log_level_t level) +{ + return log_init(drv_name, level); +} + +/** Log a driver message. + * + * @param level Message verbosity level. Message is only printed + * if verbosity is less than or equal to current + * reporting level. + * @param fmt Format string (no trailing newline) + */ +void ddf_msg(log_level_t level, const char *fmt, ...) +{ + va_list args; + + va_start(args, fmt); + log_msgv(level, fmt, args); + va_end(args); +} + +/** @} + */ Index: uspace/lib/drv/include/ddf/log.h =================================================================== --- uspace/lib/drv/include/ddf/log.h (revision 0cec844d322f50cced98388fe8d510b61d40b3ce) +++ uspace/lib/drv/include/ddf/log.h (revision 0cec844d322f50cced98388fe8d510b61d40b3ce) @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2011 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 libdrv + * @{ + */ + +#ifndef DDF_LOG_H_ +#define DDF_LOG_H_ + +#include + +extern int ddf_log_init(const char *, log_level_t); +extern void ddf_msg(log_level_t, const char *, ...); + +#endif + +/** @} + */ Index: uspace/lib/packet/include/net_byteorder.h =================================================================== --- uspace/lib/packet/include/net_byteorder.h (revision 0b4e7ca5837665462dd121f3429fdf63fd6d33d7) +++ (revision ) @@ -1,71 +1,0 @@ -/* - * Copyright (c) 2009 Lukas Mejdrech - * 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 net - * @{ - */ - -/** @file - * Host - network byte order manipulation functions. - */ - -#ifndef __NET_BYTEORDER_H__ -#define __NET_BYTEORDER_H__ - -#include -#include - - -/** Converts the given short number (16 bit) from the host byte order to the network byte order (big endian). - * @param[in] number The number in the host byte order to be converted. - * @returns The number in the network byte order. - */ -#define htons(number) host2uint16_t_be(number) - -/** Converts the given long number (32 bit) from the host byte order to the network byte order (big endian). - * @param[in] number The number in the host byte order to be converted. - * @returns The number in the network byte order. - */ -#define htonl(number) host2uint32_t_be(number) - -/** Converts the given short number (16 bit) from the network byte order (big endian) to the host byte order. - * @param[in] number The number in the network byte order to be converted. - * @returns The number in the host byte order. - */ -#define ntohs(number) uint16_t_be2host(number) - -/** Converts the given long number (32 bit) from the network byte order (big endian) to the host byte order. - * @param[in] number The number in the network byte order to be converted. - * @returns The number in the host byte order. - */ -#define ntohl(number) uint32_t_be2host(number) - -#endif - -/** @} - */ Index: uspace/lib/packet/include/net_err.h =================================================================== --- uspace/lib/packet/include/net_err.h (revision 0b4e7ca5837665462dd121f3429fdf63fd6d33d7) +++ (revision ) @@ -1,99 +1,0 @@ -/* - * Copyright (c) 2009 Lukas Mejdrech - * 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 net - * @{ - */ - -/** @file - * Common error processing codes and routines. - */ - -#ifndef __NET_ERR_H__ -#define __NET_ERR_H__ - -#include - -#ifdef CONFIG_DEBUG - #include - #include -#endif - -/** An actual stored error code. - * - */ -#define ERROR_CODE error_check_return_value - -/** An error processing routines declaration. - * - * This has to be declared in the block where the error processing - * is desired. - * - */ -#define ERROR_DECLARE int ERROR_CODE - -/** Store the value as an error code and checks if an error occurred. - * - * @param[in] value The value to be checked. May be a function call. - * @return False if the value indicates success (EOK). - * @return True otherwise. - * - */ -#ifdef CONFIG_DEBUG - -#define ERROR_OCCURRED(value) \ - (((ERROR_CODE = (value)) != EOK) \ - && ({ \ - fprintf(stderr, "libsocket error at %s:%d (%s)\n", \ - __FILE__, __LINE__, str_error(ERROR_CODE)); \ - 1; \ - })) - -#else - -#define ERROR_OCCURRED(value) ((ERROR_CODE = (value)) != EOK) - -#endif - -/** Error propagation - * - * Check if an error occurred and immediately exit the actual - * function returning the error code. - * - * @param[in] value The value to be checked. May be a function call. - * - */ - -#define ERROR_PROPAGATE(value) \ - if (ERROR_OCCURRED(value)) \ - return ERROR_CODE - -#endif - -/** @} - */ Index: uspace/lib/packet/include/socket_errno.h =================================================================== --- uspace/lib/packet/include/socket_errno.h (revision 0b4e7ca5837665462dd121f3429fdf63fd6d33d7) +++ (revision ) @@ -1,136 +1,0 @@ -/* - * Copyright (c) 2009 Lukas Mejdrech - * 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 net - * @{ - */ - -/** @file - * Socket error codes. - * Based on BSD. - */ - -#ifndef __NET_SOCKET_ERR_H__ -#define __NET_SOCKET_ERR_H__ - -#include - -/** @name Socket error codes definitions - */ -/*@{*/ - -////#define EINTR (-10004) -////#define EBADF (-10009) -//#define EACCES (-10013) -//#define EFAULT (-10014) -////#define EINVAL (-10022) -////#define EMFILE (-10024) -//#define EWOULDBLOCK (-10035) - -/** An API function is called while another blocking function is in progress. - */ -#define EINPROGRESS (-10036) - -//#define EALREADY (-10037) - -/** The socket identifier is not valid. - */ -#define ENOTSOCK (-10038) - -/** The destination address required. - */ -#define EDESTADDRREQ (-10039) - -//#define EMSGSIZE (-10040) -//#define EPROTOTYPE (-10041) -//#define ENOPROTOOPT (-10042) - -/** Protocol is not supported. - */ -#define EPROTONOSUPPORT (-10043) - -/** Socket type is not supported. - */ -#define ESOCKTNOSUPPORT (-10044) - -//#define EOPNOTSUPP (-10045) - -/** Protocol family is not supported. - */ -#define EPFNOSUPPORT (-10046) - -/** Address family is not supported. - */ -#define EAFNOSUPPORT (-10047) - -/** Address is already in use. - */ -#define EADDRINUSE (-10048) - -//#define EADDRNOTAVAIL (-10049) -/* May be reported at any time if the implementation detects an underlying failure. - */ -//#define ENETDOWN (-10050) -//#define ENETUNREACH (-10051) -//#define ENETRESET (-10052) -//#define ECONNABORTED (-10053) -//#define ECONNRESET (-10054) -//#define ENOBUFS (-10055) -//#define EISCONN (-10056) - -/** The socket is not connected or bound. - */ -#define ENOTCONN (-10057) - -//#define ESHUTDOWN (-10058) -//#define ETOOMANYREFS (-10059) -//#define ETIMEDOUT (-10060) -//#define ECONNREFUSED (-10061) -//#define ELOOP (-10062) -////#define ENAMETOOLONG (-10063) -//#define EHOSTDOWN (-10064) -//#define EHOSTUNREACH (-10065) -//#define HOST_NOT_FOUND (-11001) - -/** The requested operation was not performed. - * Try again later. - */ -#define TRY_AGAIN (-11002) - -//#define NO_RECOVERY (-11003) - -/** No data. - */ -#define NO_DATA (-11004) - -/*@}*/ - -#endif - -/** @} - */ Index: uspace/lib/usb/Makefile =================================================================== --- uspace/lib/usb/Makefile (revision 0b4e7ca5837665462dd121f3429fdf63fd6d33d7) +++ uspace/lib/usb/Makefile (revision 0cec844d322f50cced98388fe8d510b61d40b3ce) @@ -53,5 +53,6 @@ src/hidreport.c \ src/host/device_keeper.c \ - src/host/batch.c + src/host/batch.c \ + src/host/bandwidth.c include $(USPACE_PREFIX)/Makefile.common Index: uspace/lib/usb/include/usb/classes/hid/utled.h =================================================================== --- uspace/lib/usb/include/usb/classes/hid/utled.h (revision 0cec844d322f50cced98388fe8d510b61d40b3ce) +++ uspace/lib/usb/include/usb/classes/hid/utled.h (revision 0cec844d322f50cced98388fe8d510b61d40b3ce) @@ -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 libusb + * @{ + */ +/** @file + * @brief USB HID Usage Tables - LED page. + */ +#ifndef LIBUSB_UTLED_H_ +#define LIBUSB_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/usb/include/usb/classes/hidparser.h =================================================================== --- uspace/lib/usb/include/usb/classes/hidparser.h (revision 0b4e7ca5837665462dd121f3429fdf63fd6d33d7) +++ uspace/lib/usb/include/usb/classes/hidparser.h (revision 0cec844d322f50cced98388fe8d510b61d40b3ce) @@ -31,5 +31,5 @@ */ /** @file - * @brief USB HID parser. + * USB HID report descriptor and report data parser */ #ifndef LIBUSB_HIDPARSER_H_ @@ -74,13 +74,20 @@ #define USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY 4 +/** */ typedef struct { + /** */ int32_t usage_page; + /** */ int32_t usage; - + /** */ link_t link; } usb_hid_report_usage_path_t; +/** */ typedef struct { + /** */ int depth; + + /** */ link_t link; } usb_hid_report_path_t; @@ -90,32 +97,50 @@ */ typedef struct { + /** */ int32_t id; + /** */ int32_t usage_minimum; + /** */ int32_t usage_maximum; + /** */ int32_t logical_minimum; + /** */ int32_t logical_maximum; + /** */ int32_t size; + /** */ int32_t count; + /** */ size_t offset; + /** */ int32_t delimiter; - + /** */ int32_t unit_exponent; + /** */ int32_t unit; - /* - * some not yet used fields - */ + /** */ int32_t string_index; + /** */ int32_t string_minimum; + /** */ int32_t string_maximum; + /** */ int32_t designator_index; + /** */ int32_t designator_minimum; + /** */ int32_t designator_maximum; + /** */ int32_t physical_minimum; + /** */ int32_t physical_maximum; + /** */ uint8_t item_flags; + /** */ usb_hid_report_path_t *usage_path; + /** */ link_t link; } usb_hid_report_item_t; @@ -124,6 +149,9 @@ /** HID report parser structure. */ typedef struct { + /** */ link_t input; + /** */ link_t output; + /** */ link_t feature; } usb_hid_report_parser_t; @@ -154,12 +182,12 @@ } usb_hid_modifiers_t; -typedef enum { - USB_HID_LED_NUM_LOCK = 0x1, - USB_HID_LED_CAPS_LOCK = 0x2, - USB_HID_LED_SCROLL_LOCK = 0x4, - USB_HID_LED_COMPOSE = 0x8, - USB_HID_LED_KANA = 0x10, - USB_HID_LED_COUNT = 5 -} usb_hid_led_t; +//typedef enum { +// USB_HID_LED_NUM_LOCK = 0x1, +// USB_HID_LED_CAPS_LOCK = 0x2, +// USB_HID_LED_SCROLL_LOCK = 0x4, +// USB_HID_LED_COMPOSE = 0x8, +// USB_HID_LED_KANA = 0x10, +// USB_HID_LED_COUNT = 5 +//} usb_hid_led_t; static const usb_hid_modifiers_t @@ -190,16 +218,34 @@ /* - * modifiers definitions - */ - + * Descriptor parser functions + */ +/** */ +int usb_hid_parser_init(usb_hid_report_parser_t *parser); + +/** */ +int usb_hid_parse_report_descriptor(usb_hid_report_parser_t *parser, + const uint8_t *data, size_t size); + +/** */ +void usb_hid_free_report_parser(usb_hid_report_parser_t *parser); + +/** */ +void usb_hid_descriptor_print(usb_hid_report_parser_t *parser); + +/* + * Boot protocol functions + */ +/** */ int usb_hid_boot_keyboard_input_report(const uint8_t *data, size_t size, const usb_hid_report_in_callbacks_t *callbacks, void *arg); +/** */ int usb_hid_boot_keyboard_output_report(uint8_t leds, uint8_t *data, size_t size); -int usb_hid_parser_init(usb_hid_report_parser_t *parser); -int usb_hid_parse_report_descriptor(usb_hid_report_parser_t *parser, - const uint8_t *data, size_t size); - + +/* + * Input report parser functions + */ +/** */ int usb_hid_parse_report(const usb_hid_report_parser_t *parser, const uint8_t *data, size_t size, @@ -207,28 +253,56 @@ const usb_hid_report_in_callbacks_t *callbacks, void *arg); -int usb_hid_report_input_length(const usb_hid_report_parser_t *parser, +/** */ +size_t usb_hid_report_input_length(const usb_hid_report_parser_t *parser, usb_hid_report_path_t *path, int flags); -void usb_hid_free_report_parser(usb_hid_report_parser_t *parser); - -void usb_hid_descriptor_print(usb_hid_report_parser_t *parser); - -/* usage path functions */ + +/* + * usage path functions + */ +/** */ 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_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); -int usb_hid_report_path_clone(usb_hid_report_path_t *new_usage_path, usb_hid_report_path_t *usage_path); - - -// output -// - funkce co vrati cesty poli v output reportu -// - funkce co pro danou cestu nastavi data -// - finalize - + +/** */ +usb_hid_report_path_t *usb_hid_report_path_clone(usb_hid_report_path_t *usage_path); + + +/* + * Output report parser functions + */ +/** Allocates output report buffer*/ +uint8_t *usb_hid_report_output(usb_hid_report_parser_t *parser, size_t *size); + +/** Frees output report buffer*/ +void usb_hid_report_output_free(uint8_t *output); + +/** Returns size of output for given usage path */ +size_t usb_hid_report_output_size(usb_hid_report_parser_t *parser, + usb_hid_report_path_t *path, int flags); + +/** Updates the output report buffer by translated given data */ +int usb_hid_report_output_translate(usb_hid_report_parser_t *parser, + usb_hid_report_path_t *path, int flags, + uint8_t *buffer, size_t size, + int32_t *data, size_t data_size); #endif /** Index: uspace/lib/usb/include/usb/host/bandwidth.h =================================================================== --- uspace/lib/usb/include/usb/host/bandwidth.h (revision 0cec844d322f50cced98388fe8d510b61d40b3ce) +++ uspace/lib/usb/include/usb/host/bandwidth.h (revision 0cec844d322f50cced98388fe8d510b61d40b3ce) @@ -0,0 +1,81 @@ +/* + * 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 libusb + * @{ + */ +/** @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 LIBUSB_HOST_BANDWIDTH_H +#define LIBUSB_HOST_BANDWIDTH_H + +#include +#include +#include + +#define BANDWIDTH_TOTAL_USB11 12000000 +#define BANDWIDTH_AVAILABLE_USB11 ((BANDWIDTH_TOTAL_USB11 / 10) * 9) + +typedef struct bandwidth { + hash_table_t reserved; + fibril_mutex_t guard; + size_t free; + size_t (*usage_fnc)(usb_speed_t, usb_transfer_type_t, size_t, size_t); +} bandwidth_t; + +size_t bandwidth_count_usb11(usb_speed_t speed, usb_transfer_type_t type, + size_t size, size_t max_packet_size); + +int bandwidth_init(bandwidth_t *instance, size_t bandwidth, + size_t (*usage_fnc)(usb_speed_t, usb_transfer_type_t, size_t, size_t)); + +void bandwidth_destroy(bandwidth_t *instance); + +int bandwidth_reserve(bandwidth_t *instance, usb_address_t address, + usb_endpoint_t endpoint, usb_direction_t direction, usb_speed_t speed, + usb_transfer_type_t transfer_type, size_t max_packet_size, size_t size, + unsigned interval); + +int bandwidth_release(bandwidth_t *instance, usb_address_t address, + usb_endpoint_t endpoint, usb_direction_t direction); + +int bandwidth_use(bandwidth_t *instance, usb_address_t address, + usb_endpoint_t endpoint, usb_direction_t direction); + +int bandwidth_free(bandwidth_t *instance, usb_address_t address, + usb_endpoint_t endpoint, usb_direction_t direction); + +#endif +/** + * @} + */ Index: uspace/lib/usb/include/usb/host/device_keeper.h =================================================================== --- uspace/lib/usb/include/usb/host/device_keeper.h (revision 0b4e7ca5837665462dd121f3429fdf63fd6d33d7) +++ uspace/lib/usb/include/usb/host/device_keeper.h (revision 0cec844d322f50cced98388fe8d510b61d40b3ce) @@ -51,5 +51,5 @@ usb_speed_t speed; bool occupied; - bool control_used; + uint16_t control_used; uint16_t toggle_status[2]; devman_handle_t handle; @@ -99,8 +99,8 @@ void usb_device_keeper_use_control(usb_device_keeper_t *instance, - usb_address_t address); + usb_target_t target); void usb_device_keeper_release_control(usb_device_keeper_t *instance, - usb_address_t address); + usb_target_t target); #endif Index: uspace/lib/usb/src/devdrv.c =================================================================== --- uspace/lib/usb/src/devdrv.c (revision 0b4e7ca5837665462dd121f3429fdf63fd6d33d7) +++ uspace/lib/usb/src/devdrv.c (revision 0cec844d322f50cced98388fe8d510b61d40b3ce) @@ -262,5 +262,5 @@ &dev->descriptors.configuration_size); if (rc != EOK) { - usb_log_error("Failed retrieving configuration descriptor: %s.\n", + usb_log_error("Failed retrieving configuration descriptor: %s. %s\n", dev->ddf_dev->name, str_error(rc)); return rc; Index: uspace/lib/usb/src/hidparser.c =================================================================== --- uspace/lib/usb/src/hidparser.c (revision 0b4e7ca5837665462dd121f3429fdf63fd6d33d7) +++ uspace/lib/usb/src/hidparser.c (revision 0cec844d322f50cced98388fe8d510b61d40b3ce) @@ -31,5 +31,5 @@ */ /** @file - * @brief HID parser implementation. + * HID report descriptor and report data parser implementation. */ #include @@ -40,10 +40,16 @@ #include +/** */ #define USB_HID_NEW_REPORT_ITEM 1 + +/** */ #define USB_HID_NO_ACTION 2 + +/** */ #define USB_HID_UNKNOWN_TAG -99 -#define BAD_HACK_USAGE_PAGE 0x07 - +/* + * Private descriptor parser functions + */ 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); @@ -58,10 +64,15 @@ int usb_hid_report_reset_local_items(); void usb_hid_free_report_list(link_t *head); + +/* + * Data translation private functions + */ int32_t usb_hid_report_tag_data_int32(const uint8_t *data, size_t size); inline size_t usb_hid_count_item_offset(usb_hid_report_item_t * report_item, size_t offset); int usb_hid_translate_data(usb_hid_report_item_t *item, const uint8_t *data, size_t j); +int32_t usb_hid_translate_data_reverse(usb_hid_report_item_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) { @@ -80,13 +91,16 @@ /** - * + * Initialize the report descriptor parser structure + * + * @param parser Report descriptor parser structure + * @return Error code */ int usb_hid_parser_init(usb_hid_report_parser_t *parser) { - if(parser == NULL) { - return EINVAL; - } - - list_initialize(&(parser->input)); + if(parser == NULL) { + return EINVAL; + } + + list_initialize(&(parser->input)); list_initialize(&(parser->output)); list_initialize(&(parser->feature)); @@ -164,10 +178,7 @@ // store current usage path report_item->usage_path = usage_path; - - // new current usage path - tmp_usage_path = usb_hid_report_path(); - // copy old path to the new one - usb_hid_report_path_clone(tmp_usage_path, usage_path); + // clone path to the new one + tmp_usage_path = usb_hid_report_path_clone(usage_path); // swap @@ -304,4 +315,5 @@ /** + * Parse one tag of the report descriptor * * @param Tag to parse @@ -391,5 +403,4 @@ * @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) @@ -520,5 +531,5 @@ * Prints content of given list of report items. * - * @param List of report items + * @param List of report items (usb_hid_report_item_t) * @return void */ @@ -552,8 +563,5 @@ path = path->next; } - - -// usb_log_debug("\tUSAGE: %X\n", report_item->usage); -// usb_log_debug("\tUSAGE PAGE: %X\n", report_item->usage_page); + usb_log_debug("\tLOGMIN: %X\n", report_item->logical_minimum); usb_log_debug("\tLOGMAX: %X\n", report_item->logical_maximum); @@ -570,7 +578,7 @@ } /** - * Prints content of given descriptor in human readable format. - * - * @param Parsed descriptor to print + * Prints content of given report descriptor in human readable format. + * + * @param parser Parsed descriptor to print * @return void */ @@ -595,5 +603,6 @@ * 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) @@ -627,8 +636,8 @@ } -/** Free the HID report parser structure +/** Frees the HID report descriptor parser structure * * @param parser Opaque HID report parser structure - * @return Error code + * @return void */ void usb_hid_free_report_parser(usb_hid_report_parser_t *parser) @@ -660,9 +669,4 @@ const usb_hid_report_in_callbacks_t *callbacks, void *arg) { - /* - * - * only key codes (usage page 0x07) will be processed - * other usages will be ignored - */ link_t *list_item; usb_hid_report_item_t *item; @@ -676,7 +680,6 @@ return EINVAL; } - - - // get the size of result keycodes array + + /* get the size of result array */ key_count = usb_hid_report_input_length(parser, path, flags); @@ -685,5 +688,5 @@ } - // read data + /* read data */ list_item = parser->input.next; while(list_item != &(parser->input)) { @@ -719,5 +722,12 @@ } - +/** + * Translate data from the report as specified in report descriptor + * + * @param item Report descriptor item with definition of translation + * @param data Data to translate + * @param j Index of processed field in report descriptor item + * @return Translated data + */ int usb_hid_translate_data(usb_hid_report_item_t *item, const uint8_t *data, size_t j) { @@ -796,16 +806,24 @@ } -int usb_hid_report_input_length(const usb_hid_report_parser_t *parser, +/** + * + * + * @param parser + * @param path + * @param flags + * @return + */ +size_t usb_hid_report_input_length(const usb_hid_report_parser_t *parser, usb_hid_report_path_t *path, int flags) { - int ret = 0; + size_t ret = 0; link_t *item; usb_hid_report_item_t *report_item; if(parser == NULL) { - return EINVAL; - } - - item = (&parser->input)->next; + return 0; + } + + item = parser->input.next; while(&parser->input != item) { report_item = list_get_instance(item, usb_hid_report_item_t, link); @@ -824,4 +842,8 @@ /** * + * @param usage_path + * @param usage_page + * @param usage + * @return */ int usb_hid_report_path_append_item(usb_hid_report_path_t *usage_path, @@ -845,4 +867,6 @@ /** * + * @param usage_path + * @return */ void usb_hid_report_remove_last_item(usb_hid_report_path_t *usage_path) @@ -860,4 +884,6 @@ /** * + * @param usage_path + * @return */ void usb_hid_report_null_last_item(usb_hid_report_path_t *usage_path) @@ -873,4 +899,8 @@ /** * + * @param usage_path + * @param tag + * @param data + * @return */ void usb_hid_report_set_last_item(usb_hid_report_path_t *usage_path, int32_t tag, int32_t data) @@ -894,5 +924,10 @@ /** - * + * + * + * @param report_path + * @param path + * @param flags + * @return */ int usb_hid_report_compare_usage_path(usb_hid_report_path_t *report_path, @@ -949,5 +984,5 @@ break; - /* given path must be the end of the report one*/ + /* compare with only the end of path*/ case USB_HID_PATH_COMPARE_END: report_link = report_path->link.prev; @@ -992,4 +1027,5 @@ /** * + * @return */ usb_hid_report_path_t *usb_hid_report_path(void) @@ -1009,4 +1045,6 @@ /** * + * @param path + * @return void */ void usb_hid_report_path_free(usb_hid_report_path_t *path) @@ -1019,14 +1057,21 @@ /** - * - */ -int usb_hid_report_path_clone(usb_hid_report_path_t *new_usage_path, usb_hid_report_path_t *usage_path) + * Clone content of given usage path to the new one + * + * @param usage_path + * @return + */ +usb_hid_report_path_t *usb_hid_report_path_clone(usb_hid_report_path_t *usage_path) { usb_hid_report_usage_path_t *path_item; link_t *path_link; - + usb_hid_report_path_t *new_usage_path = usb_hid_report_path (); + + if(new_usage_path == NULL){ + return NULL; + } if(list_empty(&usage_path->link)){ - return EOK; + return new_usage_path; } @@ -1039,7 +1084,242 @@ } + return new_usage_path; +} + + +/*** OUTPUT API **/ + +/** Allocates output report buffer + * + * @param parser + * @param size + * @return + */ +uint8_t *usb_hid_report_output(usb_hid_report_parser_t *parser, size_t *size) +{ + if(parser == NULL) { + *size = 0; + return NULL; + } + + // read the last output report item + usb_hid_report_item_t *last; + link_t *link; + + link = parser->output.prev; + if(link != &parser->output) { + last = list_get_instance(link, usb_hid_report_item_t, link); + *size = (last->offset + (last->size * last->count)) / 8; + + uint8_t *buffer = malloc(sizeof(uint8_t) * (*size)); + memset(buffer, 0, sizeof(uint8_t) * (*size)); + usb_log_debug("output buffer: %s\n", usb_debug_str_buffer(buffer, *size, 0)); + + return buffer; + } + else { + *size = 0; + return NULL; + } +} + + +/** Frees output report buffer + * + * @param output Output report buffer + * @return + */ +void usb_hid_report_output_free(uint8_t *output) + +{ + if(output != NULL) { + free (output); + } +} + +/** Returns size of output for given usage path + * + * @param parser + * @param path + * @param flags + * @return + */ +size_t usb_hid_report_output_size(usb_hid_report_parser_t *parser, + usb_hid_report_path_t *path, int flags) +{ + size_t ret = 0; + link_t *item; + usb_hid_report_item_t *report_item; + + if(parser == NULL) { + return 0; + } + + item = parser->output.next; + while(&parser->output != item) { + report_item = list_get_instance(item, usb_hid_report_item_t, link); + if(!USB_HID_ITEM_FLAG_CONSTANT(report_item->item_flags) && + (usb_hid_report_compare_usage_path(report_item->usage_path, path, flags) == EOK)) { + ret += report_item->count; + } + + item = item->next; + } + + return ret; + +} + +/** Updates the output report buffer by translated given data + * + * @param parser + * @param path + * @param flags + * @param buffer + * @param size + * @param data + * @param data_size + * @return + */ +int usb_hid_report_output_translate(usb_hid_report_parser_t *parser, + usb_hid_report_path_t *path, int flags, + uint8_t *buffer, size_t size, + int32_t *data, size_t data_size) +{ + usb_hid_report_item_t *report_item; + link_t *item; + size_t idx=0; + int i=0; + int32_t value=0; + int offset; + int length; + int32_t tmp_value; + + if(parser == NULL) { + return EINVAL; + } + + usb_log_debug("OUTPUT BUFFER: %s\n", usb_debug_str_buffer(buffer,size, 0)); + usb_log_debug("OUTPUT DATA[0]: %d, DATA[1]: %d, DATA[2]: %d\n", data[0], data[1], data[2]); + + item = parser->output.next; + while(item != &parser->output) { + report_item = list_get_instance(item, usb_hid_report_item_t, link); + + for(i=0; icount; i++) { + + if(idx >= data_size) { + break; + } + + if((USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) == 0) || + ((report_item->usage_minimum == 0) && (report_item->usage_maximum == 0))) { + +// // variable item + value = usb_hid_translate_data_reverse(report_item, data[idx++]); + offset = report_item->offset + (i * report_item->size); + length = report_item->size; + } + else { + //bitmap + value += usb_hid_translate_data_reverse(report_item, data[idx++]); + offset = report_item->offset; + length = report_item->size * report_item->count; + } + + 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 = offset%8; + + 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 { + // je to ve dvou!! FIXME: melo by to umet delsi jak 2 + + // konec prvniho -- dolni x bitu + tmp_value = value; + tmp_value = tmp_value & ((1 << (8-(offset%8)))-1); + tmp_value = tmp_value << (offset%8); + + uint8_t mask = 0; + mask = ~(((1 << (8-(offset%8)))-1) << (offset%8)); + buffer[offset/8] = (buffer[offset/8] & mask) | tmp_value; + + // a ted druhej -- hornich length-x bitu + value = value >> (8 - (offset % 8)); + value = value & ((1 << (length - (8 - (offset % 8)))) - 1); + + mask = ((1 << (length - (8 - (offset % 8)))) - 1); + buffer[(offset+length-1)/8] = (buffer[(offset+length-1)/8] & mask) | value; + } + + } + + item = item->next; + } + + usb_log_debug("OUTPUT BUFFER: %s\n", usb_debug_str_buffer(buffer,size, 0)); + return EOK; } +/** + * + * @param item + * @param value + * @return + */ +int32_t usb_hid_translate_data_reverse(usb_hid_report_item_t *item, int value) +{ + int ret=0; + int resolution; + + if(USB_HID_ITEM_FLAG_CONSTANT(item->item_flags)) { + ret = item->logical_minimum; + } + + if((USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0)) { + + // variable item + 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)))); + } + + ret = ((value - item->physical_minimum) * resolution) + item->logical_minimum; + } + else { + // bitmapa + if(value == 0) { + ret = 0; + } + else { + size_t bitmap_idx = (value - item->usage_minimum); + ret = 1 << bitmap_idx; + } + } + + + return ret; +} + /** Index: uspace/lib/usb/src/host/bandwidth.c =================================================================== --- uspace/lib/usb/src/host/bandwidth.c (revision 0cec844d322f50cced98388fe8d510b61d40b3ce) +++ uspace/lib/usb/src/host/bandwidth.c (revision 0cec844d322f50cced98388fe8d510b61d40b3ce) @@ -0,0 +1,276 @@ +/* + * 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. + */ + +#include +#include +#include + +typedef struct { + usb_address_t address; + usb_endpoint_t endpoint; + usb_direction_t direction; +} __attribute__((aligned (sizeof(unsigned long)))) transfer_t; +/*----------------------------------------------------------------------------*/ +typedef struct { + transfer_t transfer; + link_t link; + bool used; + size_t required; +} transfer_status_t; +/*----------------------------------------------------------------------------*/ +#define BUCKET_COUNT 7 +#define MAX_KEYS (sizeof(transfer_t) / sizeof(unsigned long)) +/*----------------------------------------------------------------------------*/ +static hash_index_t transfer_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 transfer_compare( + unsigned long key[], hash_count_t keys, link_t *item) +{ + assert(item); + transfer_status_t *status = + hash_table_get_instance(item, transfer_status_t, link); + const size_t bytes = + keys < MAX_KEYS ? keys * sizeof(unsigned long) : sizeof(transfer_t); + return bcmp(key, &status->transfer, bytes); +} +/*----------------------------------------------------------------------------*/ +static void transfer_remove(link_t *item) +{ + assert(item); + transfer_status_t *status = + hash_table_get_instance(item, transfer_status_t, link); + assert(status); + free(status); +} +/*----------------------------------------------------------------------------*/ +hash_table_operations_t op = { + .hash = transfer_hash, + .compare = transfer_compare, + .remove_callback = transfer_remove, +}; +/*----------------------------------------------------------------------------*/ +size_t bandwidth_count_usb11(usb_speed_t speed, usb_transfer_type_t type, + size_t size, size_t max_packet_size) +{ + 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 bandwidth_init(bandwidth_t *instance, size_t bandwidth, + size_t (*usage_fnc)(usb_speed_t, usb_transfer_type_t, size_t, size_t)) +{ + assert(instance); + fibril_mutex_initialize(&instance->guard); + instance->free = bandwidth; + instance->usage_fnc = usage_fnc; + bool ht = + hash_table_create(&instance->reserved, BUCKET_COUNT, MAX_KEYS, &op); + return ht ? EOK : ENOMEM; +} +/*----------------------------------------------------------------------------*/ +void bandwidth_destroy(bandwidth_t *instance) +{ + hash_table_destroy(&instance->reserved); +} +/*----------------------------------------------------------------------------*/ +int bandwidth_reserve(bandwidth_t *instance, usb_address_t address, + usb_endpoint_t endpoint, usb_direction_t direction, usb_speed_t speed, + usb_transfer_type_t transfer_type, size_t max_packet_size, size_t size, + unsigned interval) +{ + if (transfer_type != USB_TRANSFER_ISOCHRONOUS && + transfer_type != USB_TRANSFER_INTERRUPT) { + return ENOTSUP; + } + + assert(instance); + assert(instance->usage_fnc); + + transfer_t trans = { + .address = address, + .endpoint = endpoint, + .direction = direction, + }; + fibril_mutex_lock(&instance->guard); + const size_t required = + instance->usage_fnc(speed, transfer_type, size, max_packet_size); + + if (required > instance->free) { + fibril_mutex_unlock(&instance->guard); + return ENOSPC; + } + + link_t *item = + hash_table_find(&instance->reserved, (unsigned long*)&trans); + if (item != NULL) { + fibril_mutex_unlock(&instance->guard); + return EEXISTS; + } + + transfer_status_t *status = malloc(sizeof(transfer_status_t)); + if (status == NULL) { + fibril_mutex_unlock(&instance->guard); + return ENOMEM; + } + + status->transfer = trans; + status->required = required; + status->used = false; + link_initialize(&status->link); + + hash_table_insert(&instance->reserved, + (unsigned long*)&status->transfer, &status->link); + instance->free -= required; + fibril_mutex_unlock(&instance->guard); + return EOK; + /* TODO: compute bandwidth used */ +} +/*----------------------------------------------------------------------------*/ +int bandwidth_release(bandwidth_t *instance, usb_address_t address, + usb_endpoint_t endpoint, usb_direction_t direction) +{ + assert(instance); + transfer_t trans = { + .address = address, + .endpoint = endpoint, + .direction = direction, + }; + fibril_mutex_lock(&instance->guard); + link_t *item = + hash_table_find(&instance->reserved, (unsigned long*)&trans); + if (item == NULL) { + fibril_mutex_unlock(&instance->guard); + return EINVAL; + } + + transfer_status_t *status = + hash_table_get_instance(item, transfer_status_t, link); + + instance->free += status->required; + + hash_table_remove(&instance->reserved, + (unsigned long*)&trans, MAX_KEYS); + + fibril_mutex_unlock(&instance->guard); + return EOK; + /* TODO: compute bandwidth freed */ +} +/*----------------------------------------------------------------------------*/ +int bandwidth_use(bandwidth_t *instance, usb_address_t address, + usb_endpoint_t endpoint, usb_direction_t direction) +{ + assert(instance); + transfer_t trans = { + .address = address, + .endpoint = endpoint, + .direction = direction, + }; + fibril_mutex_lock(&instance->guard); + link_t *item = + hash_table_find(&instance->reserved, (unsigned long*)&trans); + int ret = EOK; + if (item != NULL) { + transfer_status_t *status = + hash_table_get_instance(item, transfer_status_t, link); + assert(status); + if (status->used) { + ret = EINPROGRESS; + } + status->used = true; + } else { + ret = EINVAL; + } + fibril_mutex_unlock(&instance->guard); + return ret; +} +/*----------------------------------------------------------------------------*/ +int bandwidth_free(bandwidth_t *instance, usb_address_t address, + usb_endpoint_t endpoint, usb_direction_t direction) +{ + assert(instance); + transfer_t trans = { + .address = address, + .endpoint = endpoint, + .direction = direction, + }; + fibril_mutex_lock(&instance->guard); + link_t *item = + hash_table_find(&instance->reserved, (unsigned long*)&trans); + int ret = EOK; + if (item != NULL) { + transfer_status_t *status = + hash_table_get_instance(item, transfer_status_t, link); + assert(status); + if (!status->used) { + ret = ENOENT; + } + status->used = false; + } else { + ret = EINVAL; + } + fibril_mutex_unlock(&instance->guard); + return ret; +} Index: uspace/lib/usb/src/host/device_keeper.c =================================================================== --- uspace/lib/usb/src/host/device_keeper.c (revision 0b4e7ca5837665462dd121f3429fdf63fd6d33d7) +++ uspace/lib/usb/src/host/device_keeper.c (revision 0cec844d322f50cced98388fe8d510b61d40b3ce) @@ -54,5 +54,5 @@ for (; i < USB_ADDRESS_COUNT; ++i) { instance->devices[i].occupied = false; - instance->devices[i].control_used = false; + instance->devices[i].control_used = 0; instance->devices[i].handle = 0; instance->devices[i].toggle_status[0] = 0; @@ -311,21 +311,24 @@ /*----------------------------------------------------------------------------*/ void usb_device_keeper_use_control(usb_device_keeper_t *instance, - usb_address_t address) -{ - assert(instance); - fibril_mutex_lock(&instance->guard); - while (instance->devices[address].control_used) { + usb_target_t target) +{ + assert(instance); + const uint16_t ep = 1 << target.endpoint; + fibril_mutex_lock(&instance->guard); + while (instance->devices[target.address].control_used & ep) { fibril_condvar_wait(&instance->change, &instance->guard); } - instance->devices[address].control_used = true; + instance->devices[target.address].control_used |= ep; fibril_mutex_unlock(&instance->guard); } /*----------------------------------------------------------------------------*/ void usb_device_keeper_release_control(usb_device_keeper_t *instance, - usb_address_t address) -{ - assert(instance); - fibril_mutex_lock(&instance->guard); - instance->devices[address].control_used = false; + usb_target_t target) +{ + assert(instance); + const uint16_t ep = 1 << target.endpoint; + fibril_mutex_lock(&instance->guard); + assert((instance->devices[target.address].control_used & ep) != 0); + instance->devices[target.address].control_used &= ~ep; fibril_mutex_unlock(&instance->guard); fibril_condvar_signal(&instance->change); Index: uspace/lib/usb/src/request.c =================================================================== --- uspace/lib/usb/src/request.c (revision 0b4e7ca5837665462dd121f3429fdf63fd6d33d7) +++ uspace/lib/usb/src/request.c (revision 0cec844d322f50cced98388fe8d510b61d40b3ce) @@ -529,5 +529,4 @@ return rc; } - if (bare_config.descriptor_type != USB_DESCTYPE_CONFIGURATION) { return ENOENT;