Index: uspace/lib/c/Makefile =================================================================== --- uspace/lib/c/Makefile (revision ebcb05a569ef3a706553a41bd6a44277cc63277f) +++ uspace/lib/c/Makefile (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -65,4 +65,5 @@ generic/str.c \ generic/str_error.c \ + generic/l18n/langs.c \ generic/fibril.c \ generic/fibril_synch.c \ Index: uspace/lib/c/generic/as.c =================================================================== --- uspace/lib/c/generic/as.c (revision ebcb05a569ef3a706553a41bd6a44277cc63277f) +++ uspace/lib/c/generic/as.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -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 ebcb05a569ef3a706553a41bd6a44277cc63277f) +++ uspace/lib/c/generic/async.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -1567,4 +1567,18 @@ } +/** 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_data_read(int phoneid, void *dst, size_t size, ipc_call_t *dataptr) +{ + return async_send_2(phoneid, IPC_M_DATA_READ, (sysarg_t) dst, + (sysarg_t) size, dataptr); +} + /** Wrapper for IPC_M_DATA_READ calls using the async framework. * Index: uspace/lib/c/generic/l18n/langs.c =================================================================== --- uspace/lib/c/generic/l18n/langs.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/c/generic/l18n/langs.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -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/malloc.c =================================================================== --- uspace/lib/c/generic/malloc.c (revision ebcb05a569ef3a706553a41bd6a44277cc63277f) +++ uspace/lib/c/generic/malloc.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -240,5 +240,5 @@ size_t asize = ALIGN_UP(size, PAGE_SIZE); - astart = as_area_create(astart, asize, AS_AREA_WRITE | AS_AREA_READ); + astart = as_area_create(astart, asize, AS_AREA_WRITE | AS_AREA_READ | AS_AREA_CACHEABLE); if (astart == (void *) -1) return false; Index: uspace/lib/c/generic/str_error.c =================================================================== --- uspace/lib/c/generic/str_error.c (revision ebcb05a569ef3a706553a41bd6a44277cc63277f) +++ uspace/lib/c/generic/str_error.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -33,4 +33,5 @@ */ +#include #include #include @@ -63,10 +64,24 @@ 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. */ + 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/include/as.h =================================================================== --- uspace/lib/c/include/as.h (revision ebcb05a569ef3a706553a41bd6a44277cc63277f) +++ uspace/lib/c/include/as.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -60,4 +60,5 @@ extern void *set_maxheapsize(size_t mhs); extern void * as_get_mappable_page(size_t sz); +extern int as_get_physical_mapping(void *address, uintptr_t *frame); #endif Index: uspace/lib/c/include/async.h =================================================================== --- uspace/lib/c/include/async.h (revision ebcb05a569ef3a706553a41bd6a44277cc63277f) +++ uspace/lib/c/include/async.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -340,4 +340,5 @@ (arg4), (answer)) +extern aid_t async_data_read(int, void *, size_t, ipc_call_t *); extern int async_data_read_start(int, void *, size_t); extern bool async_data_read_receive(ipc_callid_t *, size_t *); Index: uspace/lib/c/include/errno.h =================================================================== --- uspace/lib/c/include/errno.h (revision ebcb05a569ef3a706553a41bd6a44277cc63277f) +++ uspace/lib/c/include/errno.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -56,4 +56,13 @@ #define EMLINK (-266) +/** Bad checksum. */ +#define EBADCHECKSUM (-300) + +/** USB: stalled operation. */ +#define ESTALL (-301) + +/** Empty resource (no data). */ +#define EEMPTY (-302) + /** An API function is called while another blocking function is in progress. */ #define EINPROGRESS (-10036) Index: uspace/lib/c/include/ipc/dev_iface.h =================================================================== --- uspace/lib/c/include/ipc/dev_iface.h (revision ebcb05a569ef3a706553a41bd6a44277cc63277f) +++ uspace/lib/c/include/ipc/dev_iface.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -37,4 +37,13 @@ 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, + DEV_IFACE_MAX } dev_inferface_idx_t; @@ -48,4 +57,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/kbd.h =================================================================== --- uspace/lib/c/include/ipc/kbd.h (revision ebcb05a569ef3a706553a41bd6a44277cc63277f) +++ uspace/lib/c/include/ipc/kbd.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -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/l18n/langs.h =================================================================== --- uspace/lib/c/include/l18n/langs.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/c/include/l18n/langs.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -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/drv/Makefile =================================================================== --- uspace/lib/drv/Makefile (revision ebcb05a569ef3a706553a41bd6a44277cc63277f) +++ uspace/lib/drv/Makefile (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -29,5 +29,5 @@ USPACE_PREFIX = ../.. -EXTRA_CFLAGS = -Iinclude +EXTRA_CFLAGS = -Iinclude -I$(LIBUSB_PREFIX)/include LIBRARY = libdrv @@ -35,7 +35,10 @@ generic/driver.c \ generic/dev_iface.c \ + generic/remote_char_dev.c \ generic/log.c \ generic/remote_hw_res.c \ - generic/remote_char_dev.c + generic/remote_usb.c \ + generic/remote_pci.c \ + generic/remote_usbhc.c include $(USPACE_PREFIX)/Makefile.common Index: uspace/lib/drv/generic/dev_iface.c =================================================================== --- uspace/lib/drv/generic/dev_iface.c (revision ebcb05a569ef3a706553a41bd6a44277cc63277f) +++ uspace/lib/drv/generic/dev_iface.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -41,9 +41,15 @@ #include "remote_hw_res.h" #include "remote_char_dev.h" +#include "remote_usb.h" +#include "remote_usbhc.h" +#include "remote_pci.h" 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 } }; Index: uspace/lib/drv/generic/remote_pci.c =================================================================== --- uspace/lib/drv/generic/remote_pci.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/drv/generic/remote_pci.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -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 c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/drv/generic/remote_usb.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -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 c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/drv/generic/remote_usbhc.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,585 @@ +/* + * 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_reserve_default_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *); +static void remote_usbhc_release_default_address(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_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_reserve_default_address, + remote_usbhc_release_default_address, + + remote_usbhc_request_address, + remote_usbhc_bind_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_reserve_default_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->reserve_default_address) { + async_answer_0(callid, ENOTSUP); + return; + } + + usb_speed_t speed = DEV_IPC_GET_ARG1(*call); + + int rc = usb_iface->reserve_default_address(fun, speed); + + async_answer_0(callid, rc); +} + +void remote_usbhc_release_default_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_default_address) { + async_answer_0(callid, ENOTSUP); + return; + } + + int rc = usb_iface->release_default_address(fun); + + async_answer_0(callid, rc); +} + +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_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; + } + + size_t max_packet_size = DEV_IPC_GET_ARG3(*call); + 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, max_packet_size, + 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; + } + + size_t max_packet_size = DEV_IPC_GET_ARG3(*call); + 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(callid, ENOMEM); + return; + } + trans->data_caller = data_callid; + trans->buffer = malloc(len); + trans->size = len; + + int rc = transfer_func(fun, target, max_packet_size, + trans->buffer, len, + callback_in, trans); + + if (rc != EOK) { + 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); + size_t max_packet_size = DEV_IPC_GET_ARG4(*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, max_packet_size, + 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) + }; + size_t max_packet_size = DEV_IPC_GET_ARG3(*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(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(callid, ENOMEM); + async_transaction_destroy(trans); + return; + } + + rc = usb_iface->control_read(fun, target, max_packet_size, + setup_packet, setup_packet_len, + trans->buffer, trans->size, + callback_in, trans); + + if (rc != EOK) { + 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_DATA(type, var, arg_no) \ + type var = (type) DEV_IPC_GET_ARG##arg_no(*call) / 256 +#define INIT_FROM_LOW_DATA(type, var, arg_no) \ + type var = (type) DEV_IPC_GET_ARG##arg_no(*call) % 256 + + INIT_FROM_HIGH_DATA(usb_address_t, address, 1); + INIT_FROM_LOW_DATA(usb_endpoint_t, endpoint, 1); + INIT_FROM_HIGH_DATA(usb_transfer_type_t, transfer_type, 2); + INIT_FROM_LOW_DATA(usb_direction_t, direction, 2); + +#undef INIT_FROM_HIGH_DATA +#undef INIT_FROM_LOW_DATA + + size_t max_packet_size = (size_t) DEV_IPC_GET_ARG3(*call); + unsigned int interval = (unsigned int) DEV_IPC_GET_ARG4(*call); + + int rc = usb_iface->register_endpoint(fun, address, 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/include/pci_dev_iface.h =================================================================== --- uspace/lib/drv/include/pci_dev_iface.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/drv/include/pci_dev_iface.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -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 c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/drv/include/remote_pci.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -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_ + +remote_iface_t remote_pci_iface; + +#endif + +/** + * @} + */ + Index: uspace/lib/drv/include/remote_usb.h =================================================================== --- uspace/lib/drv/include/remote_usb.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/drv/include/remote_usb.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -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_ + +remote_iface_t remote_usb_iface; + +#endif + +/** + * @} + */ Index: uspace/lib/drv/include/remote_usbhc.h =================================================================== --- uspace/lib/drv/include/remote_usbhc.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/drv/include/remote_usbhc.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -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_ + +remote_iface_t remote_usbhc_iface; + +#endif + +/** + * @} + */ Index: uspace/lib/drv/include/usb_iface.h =================================================================== --- uspace/lib/drv/include/usb_iface.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/drv/include/usb_iface.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,86 @@ +/* + * 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 + */ + 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 c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/drv/include/usbhc_iface.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,250 @@ +/* + * 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 + * - argument #3 is max packet size of the 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 { + /** Reserve usage of default address. + * This call informs the host controller that the caller will be + * using default USB address. It is duty of the HC driver to ensure + * that only single entity will have it reserved. + * The address is returned via IPC_M_USBHC_RELEASE_DEFAULT_ADDRESS. + * The caller can start using the address after receiving EOK + * answer. + */ + IPC_M_USBHC_RESERVE_DEFAULT_ADDRESS, + + /** Release usage of default address. + * @see IPC_M_USBHC_RESERVE_DEFAULT_ADDRESS + */ + IPC_M_USBHC_RELEASE_DEFAULT_ADDRESS, + + /** 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, + + /** 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. + * Parameters: + * - USB address + endpoint number (ADDR * 256 + EP) + * - transfer type + direction (TYPE * 256 + DIR) + * - maximum packet size + * - interval (in milliseconds) + * 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, size_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, size_t, + void *, size_t, + usbhc_iface_transfer_in_callback_t, void *); + +/** USB host controller communication interface. */ +typedef struct { + int (*reserve_default_address)(ddf_fun_t *, usb_speed_t); + int (*release_default_address)(ddf_fun_t *); + 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 (*release_address)(ddf_fun_t *, usb_address_t); + + int (*register_endpoint)(ddf_fun_t *, usb_address_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, + size_t, + void *, size_t, void *, size_t, + usbhc_iface_transfer_out_callback_t, void *); + + int (*control_read)(ddf_fun_t *, usb_target_t, + size_t, + void *, size_t, void *, size_t, + usbhc_iface_transfer_in_callback_t, void *); +} usbhc_iface_t; + + +#endif +/** + * @} + */ Index: uspace/lib/usb/Makefile =================================================================== --- uspace/lib/usb/Makefile (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/Makefile (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,57 @@ +# +# 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 +LIBS = $(LIBDRV_PREFIX)/libdrv.a +EXTRA_CFLAGS += -I$(LIBDRV_PREFIX)/include -Iinclude + +SOURCES = \ + src/addrkeep.c \ + src/class.c \ + src/ddfiface.c \ + src/debug.c \ + src/devdrv.c \ + src/devpoll.c \ + src/dp.c \ + src/dump.c \ + src/hidparser.c \ + src/hub.c \ + src/pipes.c \ + src/pipesinit.c \ + src/pipesio.c \ + src/recognise.c \ + src/request.c \ + src/usb.c \ + src/usbdevice.c \ + src/hidreq.c \ + src/hidreport.c \ + src/host/device_keeper.c \ + src/host/batch.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/lib/usb/include/usb/addrkeep.h =================================================================== --- uspace/lib/usb/include/usb/addrkeep.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/include/usb/addrkeep.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,86 @@ +/* + * 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 address keeping for host controller drivers. + */ +#ifndef LIBUSB_ADDRKEEP_H_ +#define LIBUSB_ADDRKEEP_H_ + +#include +#include +#include + +/** Info about used address. */ +typedef struct { + /** Linked list member. */ + link_t link; + /** Address. */ + usb_address_t address; + /** Corresponding devman handle. */ + devman_handle_t devman_handle; +} usb_address_keeping_used_t; + +/** Structure for keeping track of free and used USB addresses. */ +typedef struct { + /** Head of list of used addresses. */ + link_t used_addresses; + /** Upper bound for USB addresses. */ + usb_address_t max_address; + /** Mutex protecting used address. */ + fibril_mutex_t used_addresses_guard; + /** Condition variable for used addresses. */ + fibril_condvar_t used_addresses_condvar; + + /** Condition variable mutex for default address. */ + fibril_mutex_t default_condvar_guard; + /** Condition variable for default address. */ + fibril_condvar_t default_condvar; + /** Whether is default address available. */ + bool default_available; +} usb_address_keeping_t; + +void usb_address_keeping_init(usb_address_keeping_t *, usb_address_t); + +void usb_address_keeping_reserve_default(usb_address_keeping_t *); +void usb_address_keeping_release_default(usb_address_keeping_t *); + +usb_address_t usb_address_keeping_request(usb_address_keeping_t *); +int usb_address_keeping_release(usb_address_keeping_t *, usb_address_t); +void usb_address_keeping_devman_bind(usb_address_keeping_t *, usb_address_t, + devman_handle_t); +usb_address_t usb_address_keeping_find(usb_address_keeping_t *, + devman_handle_t); + +#endif +/** + * @} + */ Index: uspace/lib/usb/include/usb/classes/classes.h =================================================================== --- uspace/lib/usb/include/usb/classes/classes.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/include/usb/classes/classes.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -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/hid.h =================================================================== --- uspace/lib/usb/include/usb/classes/hid.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/include/usb/classes/hid.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,123 @@ +/* + * 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 USB HID device related types. + */ +#ifndef LIBUSB_HID_H_ +#define LIBUSB_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_REPORT_TYPE_INPUT = 1, + USB_HID_REPORT_TYPE_OUTPUT = 2, + USB_HID_REPORT_TYPE_FEATURE = 3 +} usb_hid_report_type_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; + +/** 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/classes/hid/utled.h =================================================================== --- uspace/lib/usb/include/usb/classes/hid/utled.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/include/usb/classes/hid/utled.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -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/hid_report_items.h =================================================================== --- uspace/lib/usb/include/usb/classes/hid_report_items.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/include/usb/classes/hid_report_items.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,80 @@ +/* + * 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 USB HID parser. + */ +#ifndef LIBUSB_HID_REPORT_ITEMS_H_ +#define LIBUSB_HID_REPORT_ITEMS_H_ + +#include + +/* MAIN ITEMS */ +#define USB_HID_TAG_CLASS_MAIN 0x0 +#define USB_HID_REPORT_TAG_INPUT 0x8 +#define USB_HID_REPORT_TAG_OUTPUT 0x9 +#define USB_HID_REPORT_TAG_FEATURE 0xB +#define USB_HID_REPORT_TAG_COLLECTION 0xA +#define USB_HID_REPORT_TAG_END_COLLECTION 0xC + +/* GLOBAL ITEMS */ +#define USB_HID_TAG_CLASS_GLOBAL 0x1 +#define USB_HID_REPORT_TAG_USAGE_PAGE 0x0 +#define USB_HID_REPORT_TAG_LOGICAL_MINIMUM 0x1 +#define USB_HID_REPORT_TAG_LOGICAL_MAXIMUM 0x2 +#define USB_HID_REPORT_TAG_PHYSICAL_MINIMUM 0x3 +#define USB_HID_REPORT_TAG_PHYSICAL_MAXIMUM 0x4 +#define USB_HID_REPORT_TAG_UNIT_EXPONENT 0x5 +#define USB_HID_REPORT_TAG_UNIT 0x6 +#define USB_HID_REPORT_TAG_REPORT_SIZE 0x7 +#define USB_HID_REPORT_TAG_REPORT_ID 0x8 +#define USB_HID_REPORT_TAG_REPORT_COUNT 0x9 +#define USB_HID_REPORT_TAG_PUSH 0xA +#define USB_HID_REPORT_TAG_POP 0xB + + +/* LOCAL ITEMS */ +#define USB_HID_TAG_CLASS_LOCAL 0x2 +#define USB_HID_REPORT_TAG_USAGE 0x0 +#define USB_HID_REPORT_TAG_USAGE_MINIMUM 0x1 +#define USB_HID_REPORT_TAG_USAGE_MAXIMUM 0x2 +#define USB_HID_REPORT_TAG_DESIGNATOR_INDEX 0x3 +#define USB_HID_REPORT_TAG_DESIGNATOR_MINIMUM 0x4 +#define USB_HID_REPORT_TAG_DESIGNATOR_MAXIMUM 0x5 +#define USB_HID_REPORT_TAG_STRING_INDEX 0x7 +#define USB_HID_REPORT_TAG_STRING_MINIMUM 0x8 +#define USB_HID_REPORT_TAG_STRING_MAXIMUM 0x9 +#define USB_HID_REPORT_TAG_DELIMITER 0xA + +#endif +/** + * @} + */ Index: uspace/lib/usb/include/usb/classes/hidparser.h =================================================================== --- uspace/lib/usb/include/usb/classes/hidparser.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/include/usb/classes/hidparser.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,310 @@ +/* + * 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 HID report descriptor and report data parser + */ +#ifndef LIBUSB_HIDPARSER_H_ +#define LIBUSB_HIDPARSER_H_ + +#include +#include +#include + +/** + * Item prefix + */ +#define USB_HID_ITEM_SIZE(data) ((uint8_t)(data & 0x3)) +#define USB_HID_ITEM_TAG(data) ((uint8_t)((data & 0xF0) >> 4)) +#define USB_HID_ITEM_TAG_CLASS(data) ((uint8_t)((data & 0xC) >> 2)) +#define USB_HID_ITEM_IS_LONG(data) (data == 0xFE) + + +/** + * Input/Output/Feature Item flags + */ +/** Constant (1) / Variable (0) */ +#define USB_HID_ITEM_FLAG_CONSTANT(flags) ((flags & 0x1) == 0x1) +/** Variable (1) / Array (0) */ +#define USB_HID_ITEM_FLAG_VARIABLE(flags) ((flags & 0x2) == 0x2) +/** Absolute / Relative*/ +#define USB_HID_ITEM_FLAG_RELATIVE(flags) ((flags & 0x4) == 0x4) +/** Wrap / No Wrap */ +#define USB_HID_ITEM_FLAG_WRAP(flags) ((flags & 0x8) == 0x8) +#define USB_HID_ITEM_FLAG_LINEAR(flags) ((flags & 0x10) == 0x10) +#define USB_HID_ITEM_FLAG_PREFERRED(flags) ((flags & 0x20) == 0x20) +#define USB_HID_ITEM_FLAG_POSITION(flags) ((flags & 0x40) == 0x40) +#define USB_HID_ITEM_FLAG_VOLATILE(flags) ((flags & 0x80) == 0x80) +#define USB_HID_ITEM_FLAG_BUFFERED(flags) ((flags & 0x100) == 0x100) + + +/** + * Description of path of usage pages and usages in report descriptor + */ +#define USB_HID_PATH_COMPARE_STRICT 0 +#define USB_HID_PATH_COMPARE_END 1 +#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; + +/** + * Description of report items + */ +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; + + /** */ + 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; + + +/** HID report parser structure. */ +typedef struct { + /** */ + link_t input; + /** */ + link_t output; + /** */ + link_t feature; +} usb_hid_report_parser_t; + + +/** HID parser callbacks for IN items. */ +typedef struct { + /** Callback for keyboard. + * + * @param key_codes Array of pressed key (including modifiers). + * @param count Length of @p key_codes. + * @param arg Custom argument. + */ + void (*keyboard)(const uint8_t *key_codes, size_t count, const uint8_t modifiers, void *arg); +} usb_hid_report_in_callbacks_t; + + +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; + +//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 + 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 +}; + +//static const usb_hid_led_t usb_hid_led_consts[USB_HID_LED_COUNT] = { +// USB_HID_LED_NUM_LOCK, +// USB_HID_LED_CAPS_LOCK, +// USB_HID_LED_SCROLL_LOCK, +// USB_HID_LED_COMPOSE, +// USB_HID_LED_KANA +//}; + +//#define USB_HID_BOOT_KEYBOARD_NUM_LOCK 0x01 +//#define USB_HID_BOOT_KEYBOARD_CAPS_LOCK 0x02 +//#define USB_HID_BOOT_KEYBOARD_SCROLL_LOCK 0x04 +//#define USB_HID_BOOT_KEYBOARD_COMPOSE 0x08 +//#define USB_HID_BOOT_KEYBOARD_KANA 0x10 + +/* + * 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); + + +/* + * Input report parser functions + */ +/** */ +int usb_hid_parse_report(const usb_hid_report_parser_t *parser, + const uint8_t *data, size_t size, + usb_hid_report_path_t *path, int flags, + const usb_hid_report_in_callbacks_t *callbacks, void *arg); + +/** */ +size_t usb_hid_report_input_length(const usb_hid_report_parser_t *parser, + usb_hid_report_path_t *path, int flags); + + + +/* + * 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); + +/** */ +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/classes/hidreport.h =================================================================== --- uspace/lib/usb/include/usb/classes/hidreport.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/include/usb/classes/hidreport.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,65 @@ +/* + * 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 libusb + * @{ + */ +/** @file + * USB HID report parser initialization from descriptors. + */ + +#ifndef LIBUSB_HIDREPORT_H_ +#define LIBUSB_HIDREPORT_H_ + +#include +#include + +/** + * Retrieves the Report descriptor from the USB device and initializes the + * report parser. + * + * \param dev USB device representing a HID device. + * \param parser HID Report parser. + * + * \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_parser_t *parser); + +#endif /* LIBUSB_HIDREPORT_H_ */ + +/** + * @} + */ Index: uspace/lib/usb/include/usb/classes/hidreq.h =================================================================== --- uspace/lib/usb/include/usb/classes/hidreq.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/include/usb/classes/hidreq.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -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 libusb + * @{ + */ +/** @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/usb/include/usb/classes/hidut.h =================================================================== --- uspace/lib/usb/include/usb/classes/hidut.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/include/usb/classes/hidut.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,68 @@ +/* + * 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 USB HID Usage Tables. + */ +#ifndef LIBUSB_HIDUT_H_ +#define LIBUSB_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_ = , */ +} 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_ = , */ + +} usb_hidut_usage_generic_desktop_t; + + +#endif +/** + * @} + */ Index: uspace/lib/usb/include/usb/classes/hidutkbd.h =================================================================== --- uspace/lib/usb/include/usb/classes/hidutkbd.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/include/usb/classes/hidutkbd.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -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 libusb + * @{ + */ +/** @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/usb/include/usb/classes/hub.h =================================================================== --- uspace/lib/usb/include/usb/classes/hub.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/include/usb/classes/hub.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,222 @@ +/* + * 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_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; + + /** + 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/ddfiface.h =================================================================== --- uspace/lib/usb/include/usb/ddfiface.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/include/usb/ddfiface.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -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 libusb + * @{ + */ +/** @file + * Implementations of DDF interfaces functions. + */ +#ifndef LIBUSB_DDFIFACE_H_ +#define LIBUSB_DDFIFACE_H_ + +#include +#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 c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/include/usb/debug.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,120 @@ +/* + * 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 + +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. */ +#define USB_LOG_LEVEL_DEFAULT USB_LOG_LEVEL_DEBUG + + +void usb_log_enable(usb_log_level_t, const char *); + +void usb_log_printf(usb_log_level_t, const char *, ...); + +/** 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 c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/include/usb/descriptor.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,172 @@ +/* + * 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; + +#endif +/** + * @} + */ Index: uspace/lib/usb/include/usb/devdrv.h =================================================================== --- uspace/lib/usb/include/usb/devdrv.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/include/usb/devdrv.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,118 @@ +/* + * 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 device driver framework. + */ +#ifndef LIBUSB_DEVDRV_H_ +#define LIBUSB_DEVDRV_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; + +/** 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; + /** Current interface. + * Usually, drivers operate on single interface only. + * This item contains the value of the interface or -1 for any. + */ + int interface_no; + + /** 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, excluding default control endpoint. + * + * It MUST be of size expected_enpoints_count(excluding default ctrl) + 1 + * where the last record MUST BE NULL, otherwise catastrophic things may + * happen. + */ + usb_endpoint_description_t **endpoints; + /** Driver ops. */ + usb_driver_ops_t *ops; +} usb_driver_t; + +int usb_driver_main(usb_driver_t *); + +typedef bool (*usb_polling_callback_t)(usb_device_t *, + uint8_t *, size_t, void *); +typedef void (*usb_polling_terminted_callback_t)(usb_device_t *, bool, void *); + + +int usb_device_auto_poll(usb_device_t *, size_t, + usb_polling_callback_t, size_t, usb_polling_terminted_callback_t, void *); + +#endif +/** + * @} + */ Index: uspace/lib/usb/include/usb/dp.h =================================================================== --- uspace/lib/usb/include/usb/dp.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/include/usb/dp.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -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 libusb + * @{ + */ +/** @file + * USB descriptor parser. + */ +#ifndef LIBUSB_DP_H_ +#define LIBUSB_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/usb/include/usb/host/batch.h =================================================================== --- uspace/lib/usb/include/usb/host/batch.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/include/usb/host/batch.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,96 @@ +/* + * 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 + * USB transfer transaction structures. + */ +#ifndef LIBUSB_HOST_BATCH_H +#define LIBUSB_HOST_BATCH_H + +#include + +#include +#include + +typedef struct usb_transfer_batch usb_transfer_batch_t; +struct usb_transfer_batch { + link_t link; + usb_target_t target; + usb_transfer_type_t transfer_type; + usb_speed_t speed; + usb_direction_t direction; + usbhc_iface_transfer_in_callback_t callback_in; + usbhc_iface_transfer_out_callback_t callback_out; + char *buffer; + char *transport_buffer; + size_t buffer_size; + char *setup_buffer; + size_t setup_size; + size_t max_packet_size; + size_t transfered_size; + void (*next_step)(usb_transfer_batch_t *); + int error; + ddf_fun_t *fun; + void *arg; + void *private_data; +}; + +void usb_transfer_batch_init( + usb_transfer_batch_t *instance, + usb_target_t target, + usb_transfer_type_t transfer_type, + usb_speed_t speed, + size_t max_packet_size, + char *buffer, + char *transport_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 +); + +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); +} + +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_finish(usb_transfer_batch_t *instance, int error); + +#endif +/** + * @} + */ Index: uspace/lib/usb/include/usb/host/device_keeper.h =================================================================== --- uspace/lib/usb/include/usb/host/device_keeper.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/include/usb/host/device_keeper.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,109 @@ +/* + * 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_DEVICE_KEEPER_H +#define LIBUSB_HOST_DEVICE_KEEPER_H +#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; + bool control_used; + uint16_t toggle_status[2]; + 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; + fibril_condvar_t change; + usb_address_t last_address; +} usb_device_keeper_t; + +void usb_device_keeper_init(usb_device_keeper_t *instance); + +void usb_device_keeper_reserve_default_address(usb_device_keeper_t *instance, + usb_speed_t speed); + +void usb_device_keeper_release_default_address(usb_device_keeper_t *instance); + +void usb_device_keeper_reset_if_need(usb_device_keeper_t *instance, + usb_target_t target, + const uint8_t *setup_data); + +int usb_device_keeper_get_toggle(usb_device_keeper_t *instance, + usb_target_t target, usb_direction_t direction); + +int usb_device_keeper_set_toggle(usb_device_keeper_t *instance, + usb_target_t target, usb_direction_t direction, bool toggle); + +usb_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); + +usb_speed_t usb_device_keeper_get_speed(usb_device_keeper_t *instance, + usb_address_t address); + +void usb_device_keeper_use_control(usb_device_keeper_t *instance, + usb_address_t address); + +void usb_device_keeper_release_control(usb_device_keeper_t *instance, + usb_address_t address); + +#endif +/** + * @} + */ Index: uspace/lib/usb/include/usb/hub.h =================================================================== --- uspace/lib/usb/include/usb/hub.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/include/usb/hub.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,72 @@ +/* + * 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 + * Functions needed by hub drivers. + * + * For class specific requests, see usb/classes/hub.h. + */ +#ifndef LIBUSB_HUB_H_ +#define LIBUSB_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; + +int usb_hc_reserve_default_address(usb_hc_connection_t *, usb_speed_t); +int usb_hc_release_default_address(usb_hc_connection_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/usb/include/usb/pipes.h =================================================================== --- uspace/lib/usb/include/usb/pipes.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/include/usb/pipes.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,152 @@ +/* + * 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 pipes representation. + */ +#ifndef LIBUSB_PIPES_H_ +#define LIBUSB_PIPES_H_ + +#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). + */ +typedef struct { + /** 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; + + /** Phone to the host controller. + * Negative when no session is active. + */ + int hc_phone; +} 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; + /** 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 *); +usb_address_t usb_device_get_assigned_address(devman_handle_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(usb_pipe_t *, unsigned int, usb_hc_connection_t *); +int usb_pipe_unregister(usb_pipe_t *, usb_hc_connection_t *); + +int usb_pipe_start_session(usb_pipe_t *); +int usb_pipe_end_session(usb_pipe_t *); +bool usb_pipe_is_session_started(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/usb/include/usb/recognise.h =================================================================== --- uspace/lib/usb/include/usb/recognise.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/include/usb/recognise.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -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 libusb + * @{ + */ +/** @file + * USB device recognition. + */ +#ifndef LIBUSB_RECOGNISE_H_ +#define LIBUSB_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/usb/include/usb/request.h =================================================================== --- uspace/lib/usb/include/usb/request.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/include/usb/request.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,140 @@ +/* + * 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 + * Standard USB requests. + */ +#ifndef LIBUSB_REQUEST_H_ +#define LIBUSB_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)) + +/** 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 **); + +#endif +/** + * @} + */ Index: uspace/lib/usb/include/usb/usb.h =================================================================== --- uspace/lib/usb/include/usb/usb.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/include/usb/usb.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,174 @@ +/* + * 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 +} 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_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; + +#endif +/** + * @} + */ Index: uspace/lib/usb/include/usb/usbdevice.h =================================================================== --- uspace/lib/usb/include/usb/usbdevice.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/include/usb/usbdevice.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,67 @@ +/* + * 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 between device drivers and host controller driver. + */ +#ifndef LIBUSB_USBDEVICE_H_ +#define LIBUSB_USBDEVICE_H_ + +#include +#include +#include +#include +#include + +/** Connection to the host controller driver. */ +typedef struct { + /** Devman handle of the host controller. */ + devman_handle_t hc_handle; + /** Phone to the host controller. */ + int hc_phone; +} usb_hc_connection_t; + +int usb_hc_find(devman_handle_t, devman_handle_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 *); + + + +#endif +/** + * @} + */ Index: uspace/lib/usb/src/addrkeep.c =================================================================== --- uspace/lib/usb/src/addrkeep.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/src/addrkeep.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,347 @@ +/* + * 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 Address keeping. + */ +#include +#include +#include + +/** For loop over all used addresses in address keeping. + * + * @param link Iterator. + * @param addresses Addresses keeping structure to iterate. + */ +#define for_all_used_addresses(link, addresses) \ + for (link = (addresses)->used_addresses.next; \ + link != &(addresses)->used_addresses; \ + link = link->next) + +/** Get instance of usb_address_keeping_used_t. */ +#define used_address_get_instance(lnk) \ + list_get_instance(lnk, usb_address_keeping_used_t, link) + +/** Invalid value of devman handle. */ +#define INVALID_DEVMAN_HANDLE \ + ((devman_handle_t)-1) + +/** Creates structure for used USB address. + * + * @param address USB address. + * @return Initialized structure. + * @retval NULL Out of memory. + */ +static usb_address_keeping_used_t *usb_address_keeping_used_create( + usb_address_t address) +{ + usb_address_keeping_used_t *info + = malloc(sizeof(usb_address_keeping_used_t)); + if (info == NULL) { + return NULL; + } + + info->address = address; + info->devman_handle = INVALID_DEVMAN_HANDLE; + list_initialize(&info->link); + return info; +} + +/** Destroys structure for used USB address. + * + * @param info Structure to be destroyed. + */ +static void usb_address_keeping_used_destroy(usb_address_keeping_used_t *info) +{ + free(info); +} + +/** Find used USB address structure by USB address. + * + * It is expected that guard mutex is already locked. + * + * @param addresses Address keeping info. + * @param address Address to be found. + * @return Structure describing looked for address. + * @retval NULL Address not found. + */ +static usb_address_keeping_used_t *usb_address_keeping_used_find_no_lock( + usb_address_keeping_t *addresses, usb_address_t address) +{ + link_t *link; + for_all_used_addresses(link, addresses) { + usb_address_keeping_used_t *info + = used_address_get_instance(link); + + if (info->address == address) { + return info; + } + } + + return NULL; +} + +/** Initialize address keeping structure. + * + * @param addresses Address keeping info. + * @param max_address Maximum USB address (exclusive bound). + */ +void usb_address_keeping_init(usb_address_keeping_t *addresses, + usb_address_t max_address) +{ + /* + * Items related with used addresses. + */ + addresses->max_address = max_address; + list_initialize(&addresses->used_addresses); + fibril_mutex_initialize(&addresses->used_addresses_guard); + fibril_condvar_initialize(&addresses->used_addresses_condvar); + + /* + * Items related with default address. + */ + addresses->default_available = true; + fibril_condvar_initialize(&addresses->default_condvar); + fibril_mutex_initialize(&addresses->default_condvar_guard); +} + +/** Reserved default USB address. + * + * This function blocks until reserved address is available. + * + * @see usb_address_keeping_release_default + * + * @param addresses Address keeping info. + */ +void usb_address_keeping_reserve_default(usb_address_keeping_t *addresses) +{ + fibril_mutex_lock(&addresses->default_condvar_guard); + while (!addresses->default_available) { + fibril_condvar_wait(&addresses->default_condvar, + &addresses->default_condvar_guard); + } + addresses->default_available = false; + fibril_mutex_unlock(&addresses->default_condvar_guard); +} + +/** Releases default USB address. + * + * @see usb_address_keeping_reserve_default + * + * @param addresses Address keeping info. + */ +void usb_address_keeping_release_default(usb_address_keeping_t *addresses) +{ + fibril_mutex_lock(&addresses->default_condvar_guard); + addresses->default_available = true; + fibril_condvar_signal(&addresses->default_condvar); + fibril_mutex_unlock(&addresses->default_condvar_guard); +} + +/** Request free address assignment. + * + * This function does not block when there are not free addresses to be + * assigned. + * + * @param addresses Address keeping info. + * @return USB address that could be used or negative error code. + * @retval ELIMIT No more addresses to assign. + * @retval ENOMEM Out of memory. + */ +usb_address_t usb_address_keeping_request(usb_address_keeping_t *addresses) +{ + usb_address_t previous_address = 0; + usb_address_t free_address = 0; + + fibril_mutex_lock(&addresses->used_addresses_guard); + link_t *new_address_position; + if (list_empty(&addresses->used_addresses)) { + free_address = 1; + new_address_position = addresses->used_addresses.next; + } else { + usb_address_keeping_used_t *first + = used_address_get_instance(addresses->used_addresses.next); + previous_address = first->address; + + for_all_used_addresses(new_address_position, addresses) { + usb_address_keeping_used_t *info + = used_address_get_instance(new_address_position); + if (info->address > previous_address + 1) { + free_address = previous_address + 1; + break; + } + previous_address = info->address; + } + + if (free_address == 0) { + usb_address_keeping_used_t *last + = used_address_get_instance(addresses->used_addresses.next); + free_address = last->address + 1; + } + } + + if (free_address >= addresses->max_address) { + free_address = ELIMIT; + goto leave; + } + + usb_address_keeping_used_t *used + = usb_address_keeping_used_create(free_address); + if (used == NULL) { + free_address = ENOMEM; + goto leave; + } + + list_prepend(&used->link, new_address_position); + +leave: + fibril_mutex_unlock(&addresses->used_addresses_guard); + + return free_address; +} + +/** Release USB address. + * + * @param addresses Address keeping info. + * @param address Address to be released. + * @return Error code. + * @retval ENOENT Address is not in use. + */ +int usb_address_keeping_release(usb_address_keeping_t *addresses, + usb_address_t address) +{ + int rc = ENOENT; + + fibril_mutex_lock(&addresses->used_addresses_guard); + + usb_address_keeping_used_t *info + = usb_address_keeping_used_find_no_lock(addresses, address); + + if (info != NULL) { + rc = EOK; + list_remove(&info->link); + usb_address_keeping_used_destroy(info); + } + + fibril_mutex_unlock(&addresses->used_addresses_guard); + + return rc; +} + +/** Bind devman handle with USB address. + * + * When the @p address is invalid (e.g. no such entry), the request + * is silently ignored. + * + * @param addresses Address keeping info. + * @param address USB address. + * @param handle Devman handle. + */ +void usb_address_keeping_devman_bind(usb_address_keeping_t *addresses, + usb_address_t address, devman_handle_t handle) +{ + fibril_mutex_lock(&addresses->used_addresses_guard); + + usb_address_keeping_used_t *info + = usb_address_keeping_used_find_no_lock(addresses, address); + if (info == NULL) { + goto leave; + } + + assert(info->address == address); + info->devman_handle = handle; + + /* + * Inform that new handle was added. + */ + fibril_condvar_broadcast(&addresses->used_addresses_condvar); + +leave: + fibril_mutex_unlock(&addresses->used_addresses_guard); +} + +/** Find address by its devman handle. + * + * @param addresses Address keeping info. + * @param handle Devman handle. + * @return USB address or negative error code. + * @retval ENOENT No such address. + */ +static usb_address_t usb_address_keeping_find_no_lock( + usb_address_keeping_t *addresses, devman_handle_t handle) +{ + usb_address_t address = ENOENT; + + link_t *link; + for_all_used_addresses(link, addresses) { + usb_address_keeping_used_t *info + = used_address_get_instance(link); + + if (info->devman_handle == handle) { + address = info->address; + break; + } + } + + return address; +} + +/** Find USB address by its devman handle. + * + * This function blocks until corresponding address is found. + * + * @param addresses Address keeping info. + * @param handle Devman handle. + * @return USB address or negative error code. + */ +usb_address_t usb_address_keeping_find(usb_address_keeping_t *addresses, + devman_handle_t handle) +{ + usb_address_t address = ENOENT; + + fibril_mutex_lock(&addresses->used_addresses_guard); + while (true) { + address = usb_address_keeping_find_no_lock(addresses, handle); + if (address != ENOENT) { + break; + } + fibril_condvar_wait(&addresses->used_addresses_condvar, + &addresses->used_addresses_guard); + } + + fibril_mutex_unlock(&addresses->used_addresses_guard); + + return address; +} + +/** + * @} + */ Index: uspace/lib/usb/src/class.c =================================================================== --- uspace/lib/usb/src/class.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/src/class.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -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 c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/src/ddfiface.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,171 @@ +/* + * 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 + +/** 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); + + int parent_phone = devman_parent_device_connect(fun->handle, + IPC_FLAG_BLOCKING); + if (parent_phone < 0) { + return parent_phone; + } + + sysarg_t hc_handle; + int rc = async_req_1_1(parent_phone, DEV_IFACE_ID(USB_DEV_IFACE), + IPC_M_USB_GET_HOST_CONTROLLER_HANDLE, &hc_handle); + + async_hangup(parent_phone); + + 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); + int parent_phone = devman_parent_device_connect(fun->handle, + IPC_FLAG_BLOCKING); + if (parent_phone < 0) { + return parent_phone; + } + + sysarg_t addr; + int rc = async_req_2_1(parent_phone, DEV_IFACE_ID(USB_DEV_IFACE), + IPC_M_USB_GET_ADDRESS, handle, &addr); + + async_hangup(parent_phone); + + 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 c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/src/debug.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,261 @@ +/* + * 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. + * Always print to log file, to screen print only when the enabled + * log level is high enough. + */ + fibril_mutex_lock(&log_serializer); + + const char *level_name = log_level_name(level); + + if (log_stream != NULL) { + 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[BUFFER_DUMP_LEN]; + +/** 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 call rewrites the buffer again. + * 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 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 (that might also reveal double usage of + * this function). + */ + bzero(buffer_dump, 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; + + 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); + } + + return buffer_dump; +} + + +/** + * @} + */ Index: uspace/lib/usb/src/devdrv.c =================================================================== --- uspace/lib/usb/src/devdrv.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/src/devdrv.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,314 @@ +/* + * 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 device driver framework. + */ +#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); +} + +/** Log out of memory error on given device. + * + * @param dev Device causing the trouble. + */ +static void usb_log_oom(ddf_dev_t *dev) +{ + usb_log_error("Out of memory when adding device `%s'.\n", + dev->name); +} + +/** 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_driver_t *drv) +{ + size_t count = 0; + if (drv->endpoints == NULL) { + return 0; + } + + while (drv->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_driver_t *drv, usb_device_t *dev) +{ + int rc; + dev->interface_no = usb_device_get_assigned_interface(dev->ddf_dev); + + size_t pipe_count = count_other_pipes(drv); + dev->pipes = malloc(sizeof(usb_endpoint_mapping_t) * pipe_count); + if (dev->pipes == NULL) { + usb_log_oom(dev->ddf_dev); + return ENOMEM; + } + + size_t i; + + /* Initialize to NULL first for rollback purposes. */ + for (i = 0; i < pipe_count; i++) { + dev->pipes[i].pipe = NULL; + } + + for (i = 0; i < pipe_count; i++) { + dev->pipes[i].pipe = malloc(sizeof(usb_pipe_t)); + if (dev->pipes[i].pipe == NULL) { + usb_log_oom(dev->ddf_dev); + rc = ENOMEM; + goto rollback; + } + + dev->pipes[i].description = drv->endpoints[i]; + dev->pipes[i].interface_no = dev->interface_no; + } + + rc = usb_pipe_initialize_from_configuration(dev->pipes, pipe_count, + dev->descriptors.configuration, dev->descriptors.configuration_size, + &dev->wire); + if (rc != EOK) { + usb_log_error("Failed initializing USB endpoints: %s.\n", + str_error(rc)); + goto rollback; + } + + /* Register the endpoints. */ + usb_hc_connection_t hc_conn; + rc = usb_hc_connection_initialize_from_device(&hc_conn, dev->ddf_dev); + if (rc != EOK) { + usb_log_error( + "Failed initializing connection to host controller: %s.\n", + str_error(rc)); + goto rollback; + } + rc = usb_hc_connection_open(&hc_conn); + if (rc != EOK) { + usb_log_error("Failed to connect to host controller: %s.\n", + str_error(rc)); + goto rollback; + } + for (i = 0; i < pipe_count; i++) { + if (dev->pipes[i].present) { + rc = usb_pipe_register(dev->pipes[i].pipe, + dev->pipes[i].descriptor->poll_interval, + &hc_conn); + /* Ignore error when operation not supported by HC. */ + if ((rc != EOK) && (rc != ENOTSUP)) { + /* FIXME: what shall we do? */ + dev->pipes[i].present = false; + free(dev->pipes[i].pipe); + dev->pipes[i].pipe = NULL; + } + } + } + /* Ignoring errors here. */ + usb_hc_connection_close(&hc_conn); + + return EOK; + +rollback: + for (i = 0; i < pipe_count; i++) { + if (dev->pipes[i].pipe != NULL) { + free(dev->pipes[i].pipe); + } + } + free(dev->pipes); + + return rc; +} + +/** Initialize all endpoint pipes. + * + * @param drv The driver. + * @param dev The device to be initialized. + * @return Error code. + */ +static int initialize_pipes(usb_device_t *dev) +{ + int rc; + + rc = usb_device_connection_initialize_from_device(&dev->wire, + dev->ddf_dev); + if (rc != EOK) { + usb_log_error( + "Failed initializing connection on device `%s'. %s.\n", + dev->ddf_dev->name, str_error(rc)); + return rc; + } + + rc = usb_pipe_initialize_default_control(&dev->ctrl_pipe, + &dev->wire); + if (rc != EOK) { + usb_log_error("Failed to initialize default control pipe " \ + "on device `%s': %s.\n", + dev->ddf_dev->name, str_error(rc)); + return rc; + } + + rc = usb_pipe_probe_default_control(&dev->ctrl_pipe); + if (rc != EOK) { + usb_log_error( + "Probing default control pipe on device `%s' failed: %s.\n", + dev->ddf_dev->name, str_error(rc)); + return rc; + } + + /* + * For further actions, we need open session on default control pipe. + */ + rc = usb_pipe_start_session(&dev->ctrl_pipe); + if (rc != EOK) { + usb_log_error("Failed to start an IPC session: %s.\n", + str_error(rc)); + return rc; + } + + /* Get the device descriptor. */ + rc = usb_request_get_device_descriptor(&dev->ctrl_pipe, + &dev->descriptors.device); + if (rc != EOK) { + usb_log_error("Failed to retrieve device descriptor: %s.\n", + str_error(rc)); + return rc; + } + + /* Get the full configuration descriptor. */ + rc = usb_request_get_full_configuration_descriptor_alloc( + &dev->ctrl_pipe, 0, (void **) &dev->descriptors.configuration, + &dev->descriptors.configuration_size); + if (rc != EOK) { + usb_log_error("Failed retrieving configuration descriptor: %s. %s\n", + dev->ddf_dev->name, str_error(rc)); + return rc; + } + + if (driver->endpoints != NULL) { + rc = initialize_other_pipes(driver, dev); + } + + /* No checking here. */ + usb_pipe_end_session(&dev->ctrl_pipe); + + /* Rollback actions. */ + if (rc != EOK) { + if (dev->descriptors.configuration != NULL) { + free(dev->descriptors.configuration); + } + } + + return rc; +} + +/** 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 = malloc(sizeof(usb_device_t)); + if (dev == NULL) { + usb_log_error("Out of memory when adding device `%s'.\n", + gen_dev->name); + return ENOMEM; + } + + + dev->ddf_dev = gen_dev; + dev->ddf_dev->driver_data = dev; + dev->driver_data = NULL; + dev->descriptors.configuration = NULL; + + rc = initialize_pipes(dev); + if (rc != EOK) { + free(dev); + return rc; + } + + return driver->ops->add_device(dev); +} + +/** + * @} + */ Index: uspace/lib/usb/src/devpoll.c =================================================================== --- uspace/lib/usb/src/devpoll.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/src/devpoll.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -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 libusb + * @{ + */ +/** @file + * USB device driver framework - automatic interrupt polling. + */ +#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 { + usb_device_t *dev; + size_t pipe_index; + usb_polling_callback_t callback; + usb_polling_terminted_callback_t terminated_callback; + 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; + + size_t failed_attempts = 0; + while (failed_attempts < MAX_FAILED_ATTEMPTS) { + int rc; + + rc = usb_pipe_start_session(pipe); + if (rc != EOK) { + failed_attempts++; + continue; + } + + size_t actual_size; + rc = usb_pipe_read(pipe, polling_data->buffer, + polling_data->request_size, &actual_size); + + /* Quit the session regardless of errors. */ + usb_pipe_end_session(pipe); + + if (rc != EOK) { + failed_attempts++; + continue; + } + + /* We have the data, execute the callback now. */ + bool carry_on = polling_data->callback(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; + } + + if (failed_attempts > 0) { + usb_log_error( + "Polling of device `%s' terminated: recurring failures.\n", + polling_data->dev->ddf_dev->name); + } + + if (polling_data->terminated_callback != NULL) { + polling_data->terminated_callback(polling_data->dev, + failed_attempts > 0, polling_data->custom_arg); + } + + /* 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; + } + + polling_data_t *polling_data = malloc(sizeof(polling_data_t)); + if (polling_data == NULL) { + return ENOMEM; + } + + /* Allocate now to prevent immediate failure in the polling fibril. */ + polling_data->buffer = malloc(request_size); + if (polling_data->buffer == NULL) { + free(polling_data); + return ENOMEM; + } + polling_data->dev = dev; + polling_data->pipe_index = pipe_index; + polling_data->callback = callback; + polling_data->terminated_callback = terminated_callback; + polling_data->request_size = request_size; + polling_data->custom_arg = arg; + + fid_t fibril = fibril_create(polling_fibril, polling_data); + if (fibril == 0) { + free(polling_data->buffer); + free(polling_data); + /* FIXME: better error code. */ + return ENOMEM; + } + fibril_add_ready(fibril); + + /* The allocated buffer etc. will be freed by the fibril. */ + + return EOK; +} + +/** + * @} + */ Index: uspace/lib/usb/src/dp.c =================================================================== --- uspace/lib/usb/src/dp.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/src/dp.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -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 libusb + * @{ + */ +/** + * @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/usb/src/dump.c =================================================================== --- uspace/lib/usb/src/dump.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/src/dump.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,292 @@ +/* + * 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 +#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/hidparser.c =================================================================== --- uspace/lib/usb/src/hidparser.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/src/hidparser.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,1327 @@ +/* + * 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 + * HID report descriptor and report data parser implementation. + */ +#include +#include +#include +#include +#include +#include + +/** */ +#define USB_HID_NEW_REPORT_ITEM 1 + +/** */ +#define USB_HID_NO_ACTION 2 + +/** */ +#define USB_HID_UNKNOWN_TAG -99 + +/* + * 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); +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); +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) +{ + switch(b) { + case 0: + return 1; + break; + case 1: + return a; + break; + default: + return a * usb_pow(a, b-1); + break; + } +} + +/** + * 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)); + list_initialize(&(parser->output)); + list_initialize(&(parser->feature)); + + return EOK; +} + + +/** Parse HID report descriptor. + * + * @param parser Opaque HID report parser structure. + * @param data Data describing the report. + * @return Error code. + */ +int usb_hid_parse_report_descriptor(usb_hid_report_parser_t *parser, + 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; + usb_hid_report_path_t *tmp_usage_path; + + size_t offset_input=0; + size_t offset_output=0; + size_t offset_feature=0; + + + /* parser structure initialization*/ + if(usb_hid_parser_init(parser) != 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; + } + + while(i= size){ + return EINVAL; // TODO ERROR CODE + } + + tag = USB_HID_ITEM_TAG(data[i]); + item_size = USB_HID_ITEM_SIZE(data[i]); + class = USB_HID_ITEM_TAG_CLASS(data[i]); + + usb_log_debug2( + "i(%u) data(%X) value(%X): TAG %u, class %u, size %u - ", i, + data[i], usb_hid_report_tag_data_int32(data+i+1,item_size), + tag, class, item_size); + + ret = usb_hid_report_parse_tag(tag,class,data+i+1, + item_size,report_item, usage_path); + usb_log_debug2("ret: %u\n", ret); + switch(ret){ + case USB_HID_NEW_REPORT_ITEM: + // store report item to report and create the new one + usb_log_debug("\nNEW REPORT ITEM: %X",ret); + + // store current usage path + report_item->usage_path = usage_path; + + // clone path to the new one + tmp_usage_path = usb_hid_report_path_clone(usage_path); + + // swap + usage_path = tmp_usage_path; + tmp_usage_path = NULL; + + + switch(tag) { + case USB_HID_REPORT_TAG_INPUT: + report_item->offset = offset_input; + offset_input += report_item->count * report_item->size; + usb_log_debug(" - INPUT\n"); + list_append(&(report_item->link), &(parser->input)); + break; + case USB_HID_REPORT_TAG_OUTPUT: + report_item->offset = offset_output; + offset_output += report_item->count * report_item->size; + usb_log_debug(" - OUTPUT\n"); + list_append(&(report_item->link), &(parser->output)); + + break; + case USB_HID_REPORT_TAG_FEATURE: + report_item->offset = offset_feature; + offset_feature += report_item->count * report_item->size; + usb_log_debug(" - FEATURE\n"); + list_append(&(report_item->link), &(parser->feature)); + break; + default: + usb_log_debug("\tjump over - tag %X\n", tag); + break; + } + + /* clone current state table to the new item */ + if(!(new_report_item = malloc(sizeof(usb_hid_report_item_t)))) { + return ENOMEM; + } + memcpy(new_report_item,report_item, sizeof(usb_hid_report_item_t)); + /* reset local items */ + new_report_item->usage_minimum = 0; + new_report_item->usage_maximum = 0; + + link_initialize(&(new_report_item->link)); + report_item = new_report_item; + + break; + case USB_HID_REPORT_TAG_PUSH: + // push current state to stack + // not yet implemented + break; + case USB_HID_REPORT_TAG_POP: + // restore current state from stack + // not yet implemented + 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 input report. + * + * @param data Data for report + * @param size Size of report + * @param callbacks Callbacks for report actions + * @param arg Custom arguments + * + * @return Error code + */ +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 i; + usb_hid_report_item_t item; + + /* fill item due to the boot protocol report descriptor */ + // modifier keys are in the first byte + uint8_t modifiers = data[0]; + + item.offset = 2; /* second byte is reserved */ + item.size = 8; + item.count = 6; + item.usage_minimum = 0; + item.usage_maximum = 255; + item.logical_minimum = 0; + item.logical_maximum = 255; + + if (size != 8) { + return -1; //ERANGE; + } + + uint8_t keys[6]; + for (i = 0; i < item.count; i++) { + keys[i] = data[i + item.offset]; + } + + callbacks->keyboard(keys, 6, modifiers, arg); + return EOK; +} + +/** + * Makes output report for keyboard boot protocol + * + * @param leds + * @param output Output report data buffer + * @param size Size of the output buffer + * @return Error code + */ +int usb_hid_boot_keyboard_output_report(uint8_t leds, uint8_t *data, size_t size) +{ + if(size != 1){ + return -1; + } + + /* used only first five bits, others are only padding*/ + *data = leds; + 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 { + /*TODO process the error */ + 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) +{ + 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: + usb_hid_report_path_append_item(usage_path, 0, 0); + + return USB_HID_NO_ACTION; + break; + + case USB_HID_REPORT_TAG_END_COLLECTION: + // TODO + // znici posledni uroven ve vsech usage paths + // otazka jestli nema nicit dve, respektive novou posledni vynulovat? + 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) +{ + // TODO take care about the bit length of data + switch(tag) + { + case USB_HID_REPORT_TAG_USAGE_PAGE: + // zmeni to jenom v poslednim poli aktualni usage path + usb_hid_report_set_last_item(usage_path, USB_HID_TAG_CLASS_GLOBAL, + usb_hid_report_tag_data_int32(data,item_size)); + break; + case USB_HID_REPORT_TAG_LOGICAL_MINIMUM: + report_item->logical_minimum = usb_hid_report_tag_data_int32(data,item_size); + break; + case USB_HID_REPORT_TAG_LOGICAL_MAXIMUM: + report_item->logical_maximum = usb_hid_report_tag_data_int32(data,item_size); + break; + case USB_HID_REPORT_TAG_PHYSICAL_MINIMUM: + report_item->physical_minimum = usb_hid_report_tag_data_int32(data,item_size); + break; + case USB_HID_REPORT_TAG_PHYSICAL_MAXIMUM: + report_item->physical_maximum = usb_hid_report_tag_data_int32(data,item_size); + break; + case USB_HID_REPORT_TAG_UNIT_EXPONENT: + report_item->unit_exponent = usb_hid_report_tag_data_int32(data,item_size); + break; + case USB_HID_REPORT_TAG_UNIT: + report_item->unit = usb_hid_report_tag_data_int32(data,item_size); + break; + case USB_HID_REPORT_TAG_REPORT_SIZE: + report_item->size = usb_hid_report_tag_data_int32(data,item_size); + break; + case USB_HID_REPORT_TAG_REPORT_COUNT: + report_item->count = usb_hid_report_tag_data_int32(data,item_size); + break; + case USB_HID_REPORT_TAG_REPORT_ID: + report_item->id = usb_hid_report_tag_data_int32(data,item_size); + break; + case USB_HID_REPORT_TAG_PUSH: + case USB_HID_REPORT_TAG_POP: + 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) +{ + switch(tag) + { + case USB_HID_REPORT_TAG_USAGE: + usb_hid_report_set_last_item(usage_path, USB_HID_TAG_CLASS_LOCAL, + usb_hid_report_tag_data_int32(data,item_size)); + break; + case USB_HID_REPORT_TAG_USAGE_MINIMUM: + report_item->usage_minimum = usb_hid_report_tag_data_int32(data,item_size); + break; + case USB_HID_REPORT_TAG_USAGE_MAXIMUM: + report_item->usage_maximum = usb_hid_report_tag_data_int32(data,item_size); + break; + case USB_HID_REPORT_TAG_DESIGNATOR_INDEX: + report_item->designator_index = usb_hid_report_tag_data_int32(data,item_size); + break; + case USB_HID_REPORT_TAG_DESIGNATOR_MINIMUM: + report_item->designator_minimum = usb_hid_report_tag_data_int32(data,item_size); + break; + case USB_HID_REPORT_TAG_DESIGNATOR_MAXIMUM: + report_item->designator_maximum = usb_hid_report_tag_data_int32(data,item_size); + break; + case USB_HID_REPORT_TAG_STRING_INDEX: + report_item->string_index = usb_hid_report_tag_data_int32(data,item_size); + break; + case USB_HID_REPORT_TAG_STRING_MINIMUM: + report_item->string_minimum = usb_hid_report_tag_data_int32(data,item_size); + break; + case USB_HID_REPORT_TAG_STRING_MAXIMUM: + report_item->string_maximum = usb_hid_report_tag_data_int32(data,item_size); + break; + case USB_HID_REPORT_TAG_DELIMITER: + report_item->delimiter = usb_hid_report_tag_data_int32(data,item_size); + break; + + default: + return USB_HID_NO_ACTION; + } + + return EOK; +} + +/** + * Converts raw data to int32 (thats the maximum length of short item data) + * + * @param Data buffer + * @param Size of buffer + * @return Converted int32 number + */ +int32_t usb_hid_report_tag_data_int32(const uint8_t *data, size_t size) +{ + unsigned int i; + int32_t result; + + result = 0; + for(i=0; inext; item != head; item = item->next) { + + report_item = list_get_instance(item, usb_hid_report_item_t, link); + + usb_log_debug("\tOFFSET: %X\n", report_item->offset); + usb_log_debug("\tCOUNT: %X\n", report_item->count); + usb_log_debug("\tSIZE: %X\n", report_item->size); + usb_log_debug("\tCONSTANT/VAR: %X\n", USB_HID_ITEM_FLAG_CONSTANT(report_item->item_flags)); + usb_log_debug("\tVARIABLE/ARRAY: %X\n", USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags)); + usb_log_debug("\tUSAGE PATH:\n"); + + path = report_item->usage_path->link.next; + while(path != &report_item->usage_path->link) { + path_item = list_get_instance(path, usb_hid_report_usage_path_t, link); + usb_log_debug("\t\tUSAGE PAGE: %X, USAGE: %X\n", path_item->usage_page, path_item->usage); + path = path->next; + } + + usb_log_debug("\tLOGMIN: %X\n", report_item->logical_minimum); + usb_log_debug("\tLOGMAX: %X\n", report_item->logical_maximum); + usb_log_debug("\tPHYMIN: %X\n", report_item->physical_minimum); + usb_log_debug("\tPHYMAX: %X\n", report_item->physical_maximum); + usb_log_debug("\tUSAGEMIN: %X\n", report_item->usage_minimum); + usb_log_debug("\tUSAGEMAX: %X\n", report_item->usage_maximum); + + 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_parser_t *parser) +{ + if(parser == NULL) { + return; + } + + usb_log_debug("INPUT:\n"); + usb_hid_descriptor_print_list(&parser->input); + + usb_log_debug("OUTPUT: \n"); + usb_hid_descriptor_print_list(&parser->output); + + usb_log_debug("FEATURE:\n"); + usb_hid_descriptor_print_list(&parser->feature); + +} + +/** + * 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_parser(usb_hid_report_parser_t *parser) +{ + if(parser == NULL){ + return; + } + + usb_hid_free_report_list(&parser->input); + usb_hid_free_report_list(&parser->output); + usb_hid_free_report_list(&parser->feature); + + return; +} + +/** 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. + * @param callbacks Callbacks for report actions. + * @param arg Custom argument (passed through to the callbacks). + * @return Error code. + */ +int usb_hid_parse_report(const usb_hid_report_parser_t *parser, + const uint8_t *data, size_t size, + usb_hid_report_path_t *path, int flags, + const usb_hid_report_in_callbacks_t *callbacks, void *arg) +{ + link_t *list_item; + usb_hid_report_item_t *item; + uint8_t *keys; + uint8_t item_value; + size_t key_count=0; + size_t i=0; + size_t j=0; + + if(parser == NULL) { + return EINVAL; + } + + /* get the size of result array */ + key_count = usb_hid_report_input_length(parser, path, flags); + + if(!(keys = malloc(sizeof(uint8_t) * key_count))){ + return ENOMEM; + } + + /* read data */ + list_item = parser->input.next; + while(list_item != &(parser->input)) { + + item = list_get_instance(list_item, usb_hid_report_item_t, link); + if(!USB_HID_ITEM_FLAG_CONSTANT(item->item_flags) && + (usb_hid_report_compare_usage_path(item->usage_path, path, flags) == EOK)) { + for(j=0; j<(size_t)(item->count); j++) { + if((USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0) || + ((item->usage_minimum == 0) && (item->usage_maximum == 0))) { + // variable item + keys[i++] = usb_hid_translate_data(item, data,j); + } + else { + // bitmapa + if((item_value = usb_hid_translate_data(item, data, j)) != 0) { + keys[i++] = (item->count - 1 - j) + item->usage_minimum; + } + else { + keys[i++] = 0; + } + } + } + } + list_item = list_item->next; + } + + callbacks->keyboard(keys, key_count, 0, arg); + + free(keys); + return EOK; + +} + +/** + * 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) +{ + int resolution; + int offset; + int part_size; + + int32_t value; + int32_t mask; + const uint8_t *foo; + + // now only common numbers llowed + 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 + (j * item->size); + + // FIXME + if((offset/8) != ((offset+item->size)/8)) { + usb_log_debug2("offset %d\n", offset); + + part_size = ((offset+item->size)%8); + usb_log_debug2("part size %d\n",part_size); + + // the higher one + foo = data+(offset/8); + mask = ((1 << (item->size-part_size))-1); + value = (*foo & mask) << part_size; + + usb_log_debug2("hfoo %x\n", *foo); + usb_log_debug2("hmaska %x\n", mask); + usb_log_debug2("hval %d\n", value); + + // the lower one + foo = data+((offset+item->size)/8); + mask = ((1 << part_size)-1) << (8-part_size); + value += ((*foo & mask) >> (8-part_size)); + + usb_log_debug2("lfoo %x\n", *foo); + usb_log_debug2("lmaska %x\n", mask); + usb_log_debug2("lval %d\n", ((*foo & mask) >> (8-(item->size-part_size)))); + usb_log_debug2("val %d\n", value); + + + } + else { + foo = data+(offset/8); + mask = ((1 << item->size)-1) << (8-((offset%8)+item->size)); + value = (*foo & mask) >> (8-((offset%8)+item->size)); + + usb_log_debug2("offset %d\n", offset); + + usb_log_debug2("foo %x\n", *foo); + usb_log_debug2("maska %x\n", mask); + usb_log_debug2("val %d\n", value); + } + + usb_log_debug2("---\n\n"); + + return (int)(((value - item->logical_minimum) / resolution) + item->physical_minimum); + +} + +/** + * + * + * @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) +{ + size_t ret = 0; + link_t *item; + usb_hid_report_item_t *report_item; + + if(parser == NULL) { + return 0; + } + + item = parser->input.next; + while(&parser->input != 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; +} + + +/** + * + * @param usage_path + * @param usage_page + * @param usage + * @return + */ +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; + + list_append (&usage_path->link, &item->link); + usage_path->depth++; + return EOK; +} + +/** + * + * @param usage_path + * @return + */ +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->link)){ + item = list_get_instance(usage_path->link.prev, usb_hid_report_usage_path_t, link); + list_remove(usage_path->link.prev); + usage_path->depth--; + free(item); + } +} + +/** + * + * @param usage_path + * @return + */ +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->link)){ + item = list_get_instance(usage_path->link.prev, usb_hid_report_usage_path_t, link); + memset(item, 0, sizeof(usb_hid_report_usage_path_t)); + } +} + +/** + * + * @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) +{ + usb_hid_report_usage_path_t *item; + + if(!list_empty(&usage_path->link)){ + item = list_get_instance(usage_path->link.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; + } + } + +} + +/** + * + * + * @param report_path + * @param path + * @param flags + * @return + */ +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(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 must be completly identical */ + case USB_HID_PATH_COMPARE_STRICT: + if(report_path->depth != path->depth){ + return 1; + } + + report_link = report_path->link.next; + path_link = path->link.next; + + while((report_link != &report_path->link) && (path_link != &path->link)) { + 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((report_item->usage_page != path_item->usage_page) || + ((only_page == 0) && (report_item->usage != path_item->usage))) { + return 1; + } else { + report_link = report_link->next; + path_link = path_link->next; + } + + } + + if((report_link == &report_path->link) && (path_link == &path->link)) { + return EOK; + } + else { + return 1; + } + break; + + /* compare with only the end of path*/ + case USB_HID_PATH_COMPARE_END: + report_link = report_path->link.prev; + path_link = path->link.prev; + + if(list_empty(&path->link)){ + return EOK; + } + + while((report_link != &report_path->link) && (path_link != &path->link)) { + 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((report_item->usage_page != path_item->usage_page) || + ((only_page == 0) && (report_item->usage != path_item->usage))) { + return 1; + } else { + report_link = report_link->prev; + path_link = path_link->prev; + } + + } + + if(path_link == &path->link) { + return EOK; + } + else { + return 1; + } + + break; + + default: + return EINVAL; + } + + + + +} + +/** + * + * @return + */ +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){ + return NULL; + } + else { + path->depth = 0; + list_initialize(&path->link); + return path; + } +} + +/** + * + * @param path + * @return void + */ +void usb_hid_report_path_free(usb_hid_report_path_t *path) +{ + while(!list_empty(&path->link)){ + usb_hid_report_remove_last_item(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 new_usage_path; + } + + path_link = usage_path->link.next; + while(path_link != &usage_path->link) { + path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, link); + usb_hid_report_path_append_item (new_usage_path, path_item->usage_page, path_item->usage); + + path_link = path_link->next; + } + + 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/hidreport.c =================================================================== --- uspace/lib/usb/src/hidreport.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/src/hidreport.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,228 @@ +/* + * 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 libusb + * @{ + */ +/** + * @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); + } + + 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 hass wrong size (%u, expected %u" + ")\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; + + /* + * Start session for the control transfer. + */ + int sess_rc = usb_pipe_start_session(&dev->ctrl_pipe); + if (sess_rc != EOK) { + usb_log_warning("Failed to start a session: %s.\n", + str_error(sess_rc)); + return sess_rc; + } + + /* + * 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 (%u, expected " + "%u)\n", actual_size, length); + return EINVAL; + } + + /* + * End session for the control transfer. + */ + sess_rc = usb_pipe_end_session(&dev->ctrl_pipe); + if (sess_rc != EOK) { + usb_log_warning("Failed to end a session: %s.\n", + str_error(sess_rc)); + free(*report_desc); + *report_desc = NULL; + return sess_rc; + } + + *size = length; + + usb_log_debug("Done.\n"); + + return EOK; +} + +/*----------------------------------------------------------------------------*/ + +int usb_hid_process_report_descriptor(usb_device_t *dev, + usb_hid_report_parser_t *parser) +{ + if (dev == NULL || parser == 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); + } + return rc; + } + + assert(report_desc != NULL); + + rc = usb_hid_parse_report_descriptor(parser, report_desc, report_size); + if (rc != EOK) { + usb_log_error("Problem parsing Report descriptor: %s.\n", + str_error(rc)); + free(report_desc); + return rc; + } + + usb_hid_descriptor_print(parser); + free(report_desc); + + return EOK; +} + +/** + * @} + */ Index: uspace/lib/usb/src/hidreq.c =================================================================== --- uspace/lib/usb/src/hidreq.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/src/hidreq.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,479 @@ +/* + * 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 one of functions + * usb_pipe_start_session(), usb_pipe_end_session(), + * 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, sess_rc; + + sess_rc = usb_pipe_start_session(ctrl_pipe); + if (sess_rc != EOK) { + usb_log_warning("Failed to start a session: %s.\n", + str_error(sess_rc)); + return sess_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); + + sess_rc = usb_pipe_end_session(ctrl_pipe); + + if (rc != EOK) { + usb_log_warning("Error sending output report to the keyboard: " + "%s.\n", str_error(rc)); + return rc; + } + + if (sess_rc != EOK) { + usb_log_warning("Error closing session: %s.\n", + str_error(sess_rc)); + return sess_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 one of functions + * usb_pipe_start_session(), usb_pipe_end_session(), + * 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, sess_rc; + + sess_rc = usb_pipe_start_session(ctrl_pipe); + if (sess_rc != EOK) { + usb_log_warning("Failed to start a session: %s.\n", + str_error(sess_rc)); + return sess_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); + + sess_rc = usb_pipe_end_session(ctrl_pipe); + + if (rc != EOK) { + usb_log_warning("Error sending output report to the keyboard: " + "%s.\n", str_error(rc)); + return rc; + } + + if (sess_rc != EOK) { + usb_log_warning("Error closing session: %s.\n", + str_error(sess_rc)); + return sess_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 one of functions + * usb_pipe_start_session(), usb_pipe_end_session(), + * 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, sess_rc; + + sess_rc = usb_pipe_start_session(ctrl_pipe); + if (sess_rc != EOK) { + usb_log_warning("Failed to start a session: %s.\n", + str_error(sess_rc)); + return sess_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); + + sess_rc = usb_pipe_end_session(ctrl_pipe); + + if (rc != EOK) { + usb_log_warning("Error sending output report to the keyboard: " + "%s.\n", str_error(rc)); + return rc; + } + + if (sess_rc != EOK) { + usb_log_warning("Error closing session: %s.\n", + str_error(sess_rc)); + return sess_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 one of functions + * usb_pipe_start_session(), usb_pipe_end_session(), + * 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, sess_rc; + + sess_rc = usb_pipe_start_session(ctrl_pipe); + if (sess_rc != EOK) { + usb_log_warning("Failed to start a session: %s.\n", + str_error(sess_rc)); + return sess_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); + + sess_rc = usb_pipe_end_session(ctrl_pipe); + + if (rc != EOK) { + usb_log_warning("Error sending output report to the keyboard: " + "%s.\n", str_error(rc)); + return rc; + } + + if (sess_rc != EOK) { + usb_log_warning("Error closing session: %s.\n", + str_error(sess_rc)); + return sess_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 one of functions + * usb_pipe_start_session(), usb_pipe_end_session(), + * 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, sess_rc; + + sess_rc = usb_pipe_start_session(ctrl_pipe); + if (sess_rc != EOK) { + usb_log_warning("Failed to start a session: %s.\n", + str_error(sess_rc)); + return sess_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); + + sess_rc = usb_pipe_end_session(ctrl_pipe); + + if (rc != EOK) { + usb_log_warning("Error sending output report to the keyboard: " + "%s.\n", str_error(rc)); + return rc; + } + + if (sess_rc != EOK) { + usb_log_warning("Error closing session: %s.\n", + str_error(sess_rc)); + return sess_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, sess_rc; + + sess_rc = usb_pipe_start_session(ctrl_pipe); + if (sess_rc != EOK) { + usb_log_warning("Failed to start a session: %s.\n", + str_error(sess_rc)); + return sess_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); + + sess_rc = usb_pipe_end_session(ctrl_pipe); + + if (rc != EOK) { + usb_log_warning("Error sending output report to the keyboard: " + "%s.\n", str_error(rc)); + return rc; + } + + if (sess_rc != EOK) { + usb_log_warning("Error closing session: %s.\n", + str_error(sess_rc)); + return sess_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/usb/src/host/batch.c =================================================================== --- uspace/lib/usb/src/host/batch.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/src/host/batch.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,142 @@ +/* + * 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 + * USB transfer transaction structures (implementation). + */ +#include +#include + +#include +#include +#include + +void usb_transfer_batch_init( + usb_transfer_batch_t *instance, + usb_target_t target, + usb_transfer_type_t transfer_type, + usb_speed_t speed, + size_t max_packet_size, + char *buffer, + char *transport_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 + ) +{ + assert(instance); + link_initialize(&instance->link); + instance->target = target; + instance->transfer_type = transfer_type; + instance->speed = speed; + instance->direction = USB_DIRECTION_BOTH; + instance->callback_in = func_in; + instance->callback_out = func_out; + instance->arg = arg; + instance->buffer = buffer; + instance->transport_buffer = transport_buffer; + instance->buffer_size = buffer_size; + instance->setup_buffer = setup_buffer; + instance->setup_size = setup_size; + instance->max_packet_size = max_packet_size; + instance->fun = fun; + instance->private_data = private_data; + instance->transfered_size = 0; + instance->next_step = NULL; + instance->error = EOK; + +} +/*----------------------------------------------------------------------------*/ +/** 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, int error) +{ + assert(instance); + instance->error = error; + 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); + + /* We are data in, we need data */ + memcpy(instance->buffer, instance->transport_buffer, + instance->buffer_size); + + usb_log_debug("Batch %p done (T%d.%d, %s %s in, %zuB): %s (%d).\n", + instance, + instance->target.address, instance->target.endpoint, + usb_str_speed(instance->speed), + usb_str_transfer_type_short(instance->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->target.address, instance->target.endpoint, + usb_str_speed(instance->speed), + usb_str_transfer_type_short(instance->transfer_type), + str_error(instance->error), instance->error); + + instance->callback_out(instance->fun, + instance->error, instance->arg); +} +/** + * @} + */ Index: uspace/lib/usb/src/host/device_keeper.c =================================================================== --- uspace/lib/usb/src/host/device_keeper.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/src/host/device_keeper.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,335 @@ +/* + * 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 (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); + fibril_mutex_initialize(&instance->guard); + fibril_condvar_initialize(&instance->change); + instance->last_address = 0; + unsigned i = 0; + for (; i < USB_ADDRESS_COUNT; ++i) { + instance->devices[i].occupied = false; + instance->devices[i].control_used = false; + instance->devices[i].handle = 0; + instance->devices[i].toggle_status[0] = 0; + instance->devices[i].toggle_status[1] = 0; + } +} +/*----------------------------------------------------------------------------*/ +/** Attempt to obtain address 0, blocks. + * + * @param[in] instance Device keeper structure to use. + * @param[in] speed Speed of the device requesting default address. + */ +void usb_device_keeper_reserve_default_address(usb_device_keeper_t *instance, + usb_speed_t speed) +{ + assert(instance); + fibril_mutex_lock(&instance->guard); + while (instance->devices[USB_ADDRESS_DEFAULT].occupied) { + fibril_condvar_wait(&instance->change, &instance->guard); + } + instance->devices[USB_ADDRESS_DEFAULT].occupied = true; + instance->devices[USB_ADDRESS_DEFAULT].speed = speed; + fibril_mutex_unlock(&instance->guard); +} +/*----------------------------------------------------------------------------*/ +/** Attempt to obtain address 0, blocks. + * + * @param[in] instance Device keeper structure to use. + * @param[in] speed Speed of the device requesting default address. + */ +void usb_device_keeper_release_default_address(usb_device_keeper_t *instance) +{ + assert(instance); + fibril_mutex_lock(&instance->guard); + instance->devices[USB_ADDRESS_DEFAULT].occupied = false; + fibril_mutex_unlock(&instance->guard); + fibril_condvar_signal(&instance->change); +} +/*----------------------------------------------------------------------------*/ +/** 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_device_keeper_reset_if_need(usb_device_keeper_t *instance, + usb_target_t target, const uint8_t *data) +{ + assert(instance); + fibril_mutex_lock(&instance->guard); + if (target.endpoint > 15 || target.endpoint < 0 + || target.address >= USB_ADDRESS_COUNT || target.address < 0 + || !instance->devices[target.address].occupied) { + fibril_mutex_unlock(&instance->guard); + 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 */ + instance->devices[target.address].toggle_status[0] &= + ~(1 << data[4]); + instance->devices[target.address].toggle_status[1] &= + ~(1 << data[4]); + } + break; + + case 0x9: /* set configuration */ + case 0x11: /* set interface */ + /* target must be device */ + if ((data[0] & 0xf) == 0) { + instance->devices[target.address].toggle_status[0] = 0; + instance->devices[target.address].toggle_status[1] = 0; + } + break; + } + fibril_mutex_unlock(&instance->guard); +} +/*----------------------------------------------------------------------------*/ +/** Get current value of endpoint toggle. + * + * @param[in] instance Device keeper structure to use. + * @param[in] target Device and endpoint used. + * @return Error code + */ +int usb_device_keeper_get_toggle(usb_device_keeper_t *instance, + usb_target_t target, usb_direction_t direction) +{ + assert(instance); + /* only control pipes are bi-directional and those do not need toggle */ + if (direction == USB_DIRECTION_BOTH) + return ENOENT; + int ret; + fibril_mutex_lock(&instance->guard); + if (target.endpoint > 15 || target.endpoint < 0 + || target.address >= USB_ADDRESS_COUNT || target.address < 0 + || !instance->devices[target.address].occupied) { + usb_log_error("Invalid data when asking for toggle value.\n"); + ret = EINVAL; + } else { + ret = (instance->devices[target.address].toggle_status[direction] + >> target.endpoint) & 1; + } + fibril_mutex_unlock(&instance->guard); + return ret; +} +/*----------------------------------------------------------------------------*/ +/** Set current value of endpoint toggle. + * + * @param[in] instance Device keeper structure to use. + * @param[in] target Device and endpoint used. + * @param[in] toggle Toggle value. + * @return Error code. + */ +int usb_device_keeper_set_toggle(usb_device_keeper_t *instance, + usb_target_t target, usb_direction_t direction, bool toggle) +{ + assert(instance); + /* only control pipes are bi-directional and those do not need toggle */ + if (direction == USB_DIRECTION_BOTH) + return ENOENT; + int ret; + fibril_mutex_lock(&instance->guard); + if (target.endpoint > 15 || target.endpoint < 0 + || target.address >= USB_ADDRESS_COUNT || target.address < 0 + || !instance->devices[target.address].occupied) { + usb_log_error("Invalid data when setting toggle value.\n"); + ret = EINVAL; + } else { + if (toggle) { + instance->devices[target.address].toggle_status[direction] + |= (1 << target.endpoint); + } else { + instance->devices[target.address].toggle_status[direction] + &= ~(1 << target.endpoint); + } + ret = EOK; + } + fibril_mutex_unlock(&instance->guard); + return ret; +} +/*----------------------------------------------------------------------------*/ +/** 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->devices[new_address].toggle_status[0] = 0; + instance->devices[new_address].toggle_status[1] = 0; + instance->last_address = new_address; + fibril_mutex_unlock(&instance->guard); + 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) { + fibril_mutex_unlock(&instance->guard); + return address; + } + ++address; + } + fibril_mutex_unlock(&instance->guard); + return ENOENT; +} +/*----------------------------------------------------------------------------*/ +/** 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; +} +/*----------------------------------------------------------------------------*/ +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) { + fibril_condvar_wait(&instance->change, &instance->guard); + } + instance->devices[address].control_used = true; + fibril_mutex_unlock(&instance->guard); +} +/*----------------------------------------------------------------------------*/ +void usb_device_keeper_release_control(usb_device_keeper_t *instance, + usb_address_t address) +{ + assert(instance); + fibril_mutex_lock(&instance->guard); + instance->devices[address].control_used = false; + fibril_mutex_unlock(&instance->guard); + fibril_condvar_signal(&instance->change); +} +/** + * @} + */ Index: uspace/lib/usb/src/hub.c =================================================================== --- uspace/lib/usb/src/hub.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/src/hub.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,321 @@ +/* + * 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 + * Functions needed by hub drivers. + */ +#include +#include +#include +#include +#include +#include +#include + +/** 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) + + +/** Tell host controller to reserve default address. + * + * @param connection Opened connection to host controller. + * @param speed Speed of the device that will respond on the default address. + * @return Error code. + */ +int usb_hc_reserve_default_address(usb_hc_connection_t *connection, + usb_speed_t speed) +{ + CHECK_CONNECTION(connection); + + return async_req_2_0(connection->hc_phone, + DEV_IFACE_ID(USBHC_DEV_IFACE), + IPC_M_USBHC_RESERVE_DEFAULT_ADDRESS, speed); +} + +/** Tell host controller to release default address. + * + * @param connection Opened connection to host controller. + * @return Error code. + */ +int usb_hc_release_default_address(usb_hc_connection_t *connection) +{ + CHECK_CONNECTION(connection); + + return async_req_1_0(connection->hc_phone, + DEV_IFACE_ID(USBHC_DEV_IFACE), + IPC_M_USBHC_RELEASE_DEFAULT_ADDRESS); +} + +/** 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); + + sysarg_t address; + int rc = async_req_2_1(connection->hc_phone, + DEV_IFACE_ID(USBHC_DEV_IFACE), + IPC_M_USBHC_REQUEST_ADDRESS, speed, + &address); + if (rc != EOK) { + return (usb_address_t) rc; + } else { + 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; + } + + return async_req_3_0(connection->hc_phone, + DEV_IFACE_ID(USBHC_DEV_IFACE), + IPC_M_USBHC_BIND_ADDRESS, + attached_device->address, attached_device->handle); +} + +/** 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); + + return async_req_2_0(connection->hc_phone, + DEV_IFACE_ID(USBHC_DEV_IFACE), + IPC_M_USBHC_RELEASE_ADDRESS, address); +} + + +/** 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). + * + * @param[in] parent Parent device (i.e. the hub device). + * @param[in] connection Opened 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) +{ + CHECK_CONNECTION(connection); + + /* + * Request new address. + */ + usb_address_t dev_addr = usb_hc_request_address(connection, dev_speed); + if (dev_addr < 0) { + return EADDRNOTAVAIL; + } + + int rc; + + /* + * Reserve the default address. + */ + rc = usb_hc_reserve_default_address(connection, dev_speed); + if (rc != EOK) { + rc = EBUSY; + goto leave_release_free_address; + } + + /* + * Enable the port (i.e. allow signaling through this port). + */ + rc = enable_port(port_no, arg); + if (rc != EOK) { + goto leave_release_default_address; + } + + /* + * Change the address from default to the free one. + * We need to create a new control pipe for that. + */ + usb_device_connection_t dev_conn; + rc = usb_device_connection_initialize_on_default_address(&dev_conn, + connection); + if (rc != EOK) { + rc = ENOTCONN; + goto leave_release_default_address; + } + + usb_pipe_t ctrl_pipe; + rc = usb_pipe_initialize_default_control(&ctrl_pipe, + &dev_conn); + if (rc != EOK) { + rc = ENOTCONN; + goto leave_release_default_address; + } + rc = usb_pipe_probe_default_control(&ctrl_pipe); + if (rc != EOK) { + rc = ENOTCONN; + goto leave_release_default_address; + } + + rc = usb_pipe_start_session(&ctrl_pipe); + if (rc != EOK) { + rc = ENOTCONN; + goto leave_release_default_address; + } + + rc = usb_request_set_address(&ctrl_pipe, dev_addr); + if (rc != EOK) { + rc = ESTALL; + goto leave_stop_session; + } + + usb_pipe_end_session(&ctrl_pipe); + + /* + * Once the address is changed, we can return the default address. + */ + usb_hc_release_default_address(connection); + + /* + * 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(connection, &new_device); + if (rc != EOK) { + rc = EDESTADDRREQ; + goto leave_release_free_address; + } + + /* + * 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_stop_session: + usb_pipe_end_session(&ctrl_pipe); + +leave_release_default_address: + usb_hc_release_default_address(connection); + +leave_release_free_address: + usb_hc_unregister_device(connection, dev_addr); + + return rc; +} + +/** + * @} + */ Index: uspace/lib/usb/src/pipes.c =================================================================== --- uspace/lib/usb/src/pipes.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/src/pipes.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,305 @@ +/* + * 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 endpoint pipes miscellaneous functions. + */ +#include +#include +#include +#include +#include +#include +#include +#include + +#define IPC_AGAIN_DELAY (1000 * 2) /* 2ms */ + +/** Tell USB address assigned to given device. + * + * @param phone Phone to parent device. + * @param dev Device in question. + * @return USB address or error code. + */ +static usb_address_t get_my_address(int phone, ddf_dev_t *dev) +{ + sysarg_t address; + + /* + * 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. + */ + int rc = async_req_2_1(phone, DEV_IFACE_ID(USB_DEV_IFACE), + IPC_M_USB_GET_ADDRESS, + 0, &address); + + 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) +{ + int parent_phone = devman_parent_device_connect(device->handle, + IPC_FLAG_BLOCKING); + if (parent_phone < 0) { + return -1; + } + + sysarg_t iface_no; + int rc = async_req_2_1(parent_phone, DEV_IFACE_ID(USB_DEV_IFACE), + IPC_M_USB_GET_INTERFACE, + device->handle, &iface_no); + + async_hangup(parent_phone); + + if (rc != EOK) { + return -1; + } + + return (int) iface_no; +} + +/** Tell USB address assigned to given device. + * + * @param dev_handle Devman handle of the USB device in question. + * @return USB address or negative error code. + */ +usb_address_t usb_device_get_assigned_address(devman_handle_t dev_handle) +{ + int parent_phone = devman_parent_device_connect(dev_handle, + IPC_FLAG_BLOCKING); + if (parent_phone < 0) { + return parent_phone; + } + + sysarg_t address; + + int rc = async_req_2_1(parent_phone, DEV_IFACE_ID(USB_DEV_IFACE), + IPC_M_USB_GET_ADDRESS, + dev_handle, &address); + + if (rc != EOK) { + return rc; + } + + async_hangup(parent_phone); + + return (usb_address_t) address; +} + +/** 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; + } + + int parent_phone = devman_parent_device_connect(dev->handle, + IPC_FLAG_BLOCKING); + if (parent_phone < 0) { + return parent_phone; + } + + /* + * 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_phone, 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_phone); + 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); +} + + +/** Start a session on the endpoint pipe. + * + * A session is something inside what any communication occurs. + * It is expected that sessions would be started right before the transfer + * and ended - see usb_pipe_end_session() - after the last + * transfer. + * The reason for this is that session actually opens some communication + * channel to the host controller (or to the physical hardware if you + * wish) and thus it involves acquiring kernel resources. + * Since they are limited, sessions shall not be longer than strictly + * necessary. + * + * @param pipe Endpoint pipe to start the session on. + * @return Error code. + */ +int usb_pipe_start_session(usb_pipe_t *pipe) +{ + assert(pipe); + + if (usb_pipe_is_session_started(pipe)) { + return EBUSY; + } + + int phone = devman_device_connect(pipe->wire->hc_handle, 0); + if (phone < 0) { + return phone; + } + + pipe->hc_phone = phone; + + return EOK; +} + + +/** Ends a session on the endpoint pipe. + * + * @see usb_pipe_start_session + * + * @param pipe Endpoint pipe to end the session on. + * @return Error code. + */ +int usb_pipe_end_session(usb_pipe_t *pipe) +{ + assert(pipe); + + if (!usb_pipe_is_session_started(pipe)) { + return ENOENT; + } + + int rc = async_hangup(pipe->hc_phone); + if (rc != EOK) { + return rc; + } + + pipe->hc_phone = -1; + + return EOK; +} + +/** Tell whether a session is started (open) on the endpoint pipe. + * + * The expected usage of this function is in assertions for some + * nested functions. + * + * @param pipe Endpoint pipe in question. + * @return Whether @p pipe has opened a session. + */ +bool usb_pipe_is_session_started(usb_pipe_t *pipe) +{ + return (pipe->hc_phone >= 0); +} + +/** + * @} + */ Index: uspace/lib/usb/src/pipesinit.c =================================================================== --- uspace/lib/usb/src/pipesinit.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/src/pipesinit.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,498 @@ +/* + * 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 + * 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) +{ + while (mapping_count > 0) { + bool interface_number_fits = (mapping->interface_no < 0) + || (mapping->interface_no == interface_number); + + bool endpoint_descriptions_fits = endpoint_fits_description( + mapping->description, found_endpoint); + + if (interface_number_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); + 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); + + pipe->wire = connection; + pipe->hc_phone = -1; + pipe->endpoint_no = endpoint_no; + pipe->transfer_type = transfer_type; + pipe->max_packet_size = max_packet_size; + pipe->direction = direction; + + 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); + + 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; + + TRY_LOOP(failed_attempts) { + rc = usb_pipe_start_session(pipe); + if (rc == EOK) { + break; + } + } + if (rc != EOK) { + return rc; + } + + + 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_session(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) +{ + assert(pipe); + assert(hc_connection); + + if (!usb_hc_connection_is_opened(hc_connection)) { + return EBADF; + } + +#define _PACK(high, low) ((high) * 256 + (low)) + + return async_req_5_0(hc_connection->hc_phone, + DEV_IFACE_ID(USBHC_DEV_IFACE), IPC_M_USBHC_REGISTER_ENDPOINT, + _PACK(pipe->wire->address, pipe->endpoint_no), + _PACK(pipe->transfer_type, pipe->direction), + pipe->max_packet_size, interval); + +#undef _PACK +} + +/** 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; + } + + return async_req_4_0(hc_connection->hc_phone, + DEV_IFACE_ID(USBHC_DEV_IFACE), IPC_M_USBHC_UNREGISTER_ENDPOINT, + pipe->wire->address, pipe->endpoint_no, pipe->direction); +} + +/** + * @} + */ Index: uspace/lib/usb/src/pipesio.c =================================================================== --- uspace/lib/usb/src/pipesio.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/src/pipesio.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,511 @@ +/* + * 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 + * 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 + +/** 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; + } + + /* + * Make call identifying target USB device and type of transfer. + */ + aid_t opening_request = async_send_4(pipe->hc_phone, + DEV_IFACE_ID(USBHC_DEV_IFACE), ipc_method, + pipe->wire->address, pipe->endpoint_no, + pipe->max_packet_size, + NULL); + if (opening_request == 0) { + return ENOMEM; + } + + /* + * Retrieve the data. + */ + ipc_call_t data_request_call; + aid_t data_request = async_data_read(pipe->hc_phone, buffer, size, + &data_request_call); + + 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 (!usb_pipe_is_session_started(pipe)) { + return EBADF; + } + + if (pipe->direction != USB_DIRECTION_IN) { + return EBADF; + } + + if (pipe->transfer_type == USB_TRANSFER_CONTROL) { + return EBADF; + } + + size_t act_size = 0; + int rc; + + rc = usb_pipe_read_no_checks(pipe, buffer, size, &act_size); + 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; + } + + /* + * Make call identifying target USB device and type of transfer. + */ + aid_t opening_request = async_send_4(pipe->hc_phone, + DEV_IFACE_ID(USBHC_DEV_IFACE), ipc_method, + pipe->wire->address, pipe->endpoint_no, + pipe->max_packet_size, + NULL); + if (opening_request == 0) { + return ENOMEM; + } + + /* + * Send the data. + */ + int rc = async_data_write_start(pipe->hc_phone, buffer, size); + 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 (!usb_pipe_is_session_started(pipe)) { + return EBADF; + } + + if (pipe->direction != USB_DIRECTION_OUT) { + return EBADF; + } + + if (pipe->transfer_type == USB_TRANSFER_CONTROL) { + return EBADF; + } + + int rc = usb_pipe_write_no_check(pipe, buffer, size); + + return rc; +} + + +/** 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) +{ + /* + * Make call identifying target USB device and control transfer type. + */ + aid_t opening_request = async_send_4(pipe->hc_phone, + DEV_IFACE_ID(USBHC_DEV_IFACE), IPC_M_USBHC_CONTROL_READ, + pipe->wire->address, pipe->endpoint_no, + pipe->max_packet_size, + NULL); + if (opening_request == 0) { + return ENOMEM; + } + + /* + * Send the setup packet. + */ + int rc = async_data_write_start(pipe->hc_phone, + setup_buffer, setup_buffer_size); + if (rc != EOK) { + async_wait_for(opening_request, NULL); + return rc; + } + + /* + * Retrieve the data. + */ + ipc_call_t data_request_call; + aid_t data_request = async_data_read(pipe->hc_phone, + data_buffer, data_buffer_size, + &data_request_call); + 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 (!usb_pipe_is_session_started(pipe)) { + return EBADF; + } + + if ((pipe->direction != USB_DIRECTION_BOTH) + || (pipe->transfer_type != USB_TRANSFER_CONTROL)) { + return EBADF; + } + + size_t act_size = 0; + int rc = usb_pipe_control_read_no_check(pipe, + setup_buffer, setup_buffer_size, + data_buffer, data_buffer_size, &act_size); + + 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) +{ + /* + * Make call identifying target USB device and control transfer type. + */ + aid_t opening_request = async_send_5(pipe->hc_phone, + DEV_IFACE_ID(USBHC_DEV_IFACE), IPC_M_USBHC_CONTROL_WRITE, + pipe->wire->address, pipe->endpoint_no, + data_buffer_size, + pipe->max_packet_size, + NULL); + if (opening_request == 0) { + return ENOMEM; + } + + /* + * Send the setup packet. + */ + int rc = async_data_write_start(pipe->hc_phone, + setup_buffer, setup_buffer_size); + if (rc != EOK) { + async_wait_for(opening_request, NULL); + return rc; + } + + /* + * Send the data (if any). + */ + if (data_buffer_size > 0) { + rc = async_data_write_start(pipe->hc_phone, + data_buffer, data_buffer_size); + 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 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 (!usb_pipe_is_session_started(pipe)) { + return EBADF; + } + + if ((pipe->direction != USB_DIRECTION_BOTH) + || (pipe->transfer_type != USB_TRANSFER_CONTROL)) { + return EBADF; + } + + int rc = usb_pipe_control_write_no_check(pipe, + setup_buffer, setup_buffer_size, data_buffer, data_buffer_size); + + return rc; +} + + +/** + * @} + */ Index: uspace/lib/usb/src/recognise.c =================================================================== --- uspace/lib/usb/src/recognise.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/src/recognise.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,452 @@ +/* + * 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 + * 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_pipe_start_session(&ctrl_pipe); + if (rc != EOK) { + goto failure; + } + + rc = usb_device_create_match_ids(&ctrl_pipe, &child->match_ids); + if (rc != EOK) { + goto failure; + } + + rc = usb_pipe_end_session(&ctrl_pipe); + 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/usb/src/request.c =================================================================== --- uspace/lib/usb/src/request.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/src/request.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,875 @@ +/* + * 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 + * 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; +} + +/** + * @} + */ Index: uspace/lib/usb/src/usb.c =================================================================== --- uspace/lib/usb/src/usb.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/src/usb.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -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/usb/src/usbdevice.c =================================================================== --- uspace/lib/usb/src/usbdevice.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usb/src/usbdevice.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -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 libusb + * @{ + */ +/** @file + * General communication between device drivers and host controller driver. + */ +#include +#include +#include +#include +#include +#include +#include + +/** 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) +{ + int parent_phone = devman_parent_device_connect(device_handle, + IPC_FLAG_BLOCKING); + if (parent_phone < 0) { + return parent_phone; + } + + devman_handle_t h; + usb_log_debug("asking for HC handle (my handle is %zu).\n", device_handle); + int rc = async_req_1_1(parent_phone, DEV_IFACE_ID(USB_DEV_IFACE), + IPC_M_USB_GET_HOST_CONTROLLER_HANDLE, &h); + + async_hangup(parent_phone); + + if (rc != EOK) { + return rc; + } + + if (hc_handle != NULL) { + *hc_handle = h; + } + + return EOK; +} + +/** 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_phone = -1; + + 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; + } + + int phone = devman_device_connect(connection->hc_handle, 0); + if (phone < 0) { + return phone; + } + + connection->hc_phone = phone; + + 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_phone >= 0); +} + +/** 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_phone); + if (rc != EOK) { + return rc; + } + + connection->hc_phone = -1; + + return EOK; +} + +/** + * @} + */ Index: uspace/lib/usbvirt/Makefile =================================================================== --- uspace/lib/usbvirt/Makefile (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usbvirt/Makefile (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,42 @@ +# +# 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 = libusbvirt + +EXTRA_CFLAGS = -I$(LIBUSB_PREFIX)/include -I$(LIBDRV_PREFIX)/include -Iinclude + +SOURCES = \ + src/callback.c \ + src/ctrlpipe.c \ + src/debug.c \ + src/main.c \ + src/stdreq.c \ + src/transaction.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/lib/usbvirt/include/usbvirt/device.h =================================================================== --- uspace/lib/usbvirt/include/usbvirt/device.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usbvirt/include/usbvirt/device.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,285 @@ +/* + * 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 libusbvirt + * @{ + */ +/** @file + * @brief Virtual USB device. + */ +#ifndef LIBUSBVIRT_DEVICE_H_ +#define LIBUSBVIRT_DEVICE_H_ + +#include +#include +#include + +/** Request type of a control transfer. */ +typedef enum { + /** Standard USB request. */ + USBVIRT_REQUEST_TYPE_STANDARD = 0, + /** Standard class USB request. */ + USBVIRT_REQUEST_TYPE_CLASS = 1 +} usbvirt_request_type_t; + +/** Recipient of control request. */ +typedef enum { + /** Device is the recipient of the control request. */ + USBVIRT_REQUEST_RECIPIENT_DEVICE = 0, + /** Interface is the recipient of the control request. */ + USBVIRT_REQUEST_RECIPIENT_INTERFACE = 1, + /** Endpoint is the recipient of the control request. */ + USBVIRT_REQUEST_RECIPIENT_ENDPOINT = 2, + /** Other part of the device is the recipient of the control request. */ + USBVIRT_REQUEST_RECIPIENT_OTHER = 3 +} usbvirt_request_recipient_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; + +typedef struct usbvirt_device usbvirt_device_t; +struct usbvirt_control_transfer; + +typedef int (*usbvirt_on_device_request_t)(usbvirt_device_t *dev, + usb_device_request_setup_packet_t *request, + uint8_t *data); + +/** Callback for control request over pipe zero. + * + * @param dev Virtual device answering the call. + * @param request Request setup packet. + * @param data Data when DATA stage is present. + * @return Error code. + */ +typedef int (*usbvirt_control_request_callback_t)(usbvirt_device_t *dev, + usb_device_request_setup_packet_t *request, + uint8_t *data); + +/** Handler for control transfer on endpoint zero. */ +typedef struct { + /** Request type bitmap. + * Use USBVIRT_MAKE_CONTROL_REQUEST_TYPE for creating the bitmap. + */ + uint8_t request_type; + /** Request code. */ + uint8_t request; + /** Request name for debugging. */ + const char *name; + /** Callback for the request. + * NULL value here announces end of a list. + */ + usbvirt_control_request_callback_t callback; +} usbvirt_control_transfer_handler_t; + +/** Create control request type bitmap. + * + * @param direction Transfer direction (use usb_direction_t). + * @param type Request type (use usbvirt_request_type_t). + * @param recipient Recipient of the request (use usbvirt_request_recipient_t). + * @return Request type bitmap. + */ +#define USBVIRT_MAKE_CONTROL_REQUEST_TYPE(direction, type, recipient) \ + ((((direction) == USB_DIRECTION_IN) ? 1 : 0) << 7) \ + | (((type) & 3) << 5) \ + | (((recipient) & 31)) + +/** Create last item in an array of control request handlers. */ +#define USBVIRT_CONTROL_TRANSFER_HANDLER_LAST { 0, 0, NULL, NULL } + +/** Device operations. */ +typedef struct { + /** Callbacks for transfers over control pipe zero. */ + usbvirt_control_transfer_handler_t *control_transfer_handlers; + + int (*on_control_transfer)(usbvirt_device_t *dev, + usb_endpoint_t endpoint, struct usbvirt_control_transfer *transfer); + + /** Callback for all other incoming data. */ + int (*on_data)(usbvirt_device_t *dev, + usb_endpoint_t endpoint, void *buffer, size_t size); + + /** Callback for host request for data. */ + int (*on_data_request)(usbvirt_device_t *dev, + usb_endpoint_t endpoint, void *buffer, size_t size, size_t *actual_size); + + /** Decides direction of control transfer. */ + usb_direction_t (*decide_control_transfer_direction)( + usb_endpoint_t endpoint, void *buffer, size_t size); + + /** Callback when device changes its state. + * + * It is correct that this function is called when both states + * are equal (e.g. this function is called during SET_CONFIGURATION + * request done on already configured device). + * + * @warning The value of dev->state before calling + * this function is not specified (i.e. can be @p old_state or + * @p new_state). + */ + void (*on_state_change)(usbvirt_device_t *dev, + usbvirt_device_state_t old_state, usbvirt_device_state_t new_state); +} usbvirt_device_ops_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. */ +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; + /** Index of currently selected configuration. */ + uint8_t current_configuration; +} usbvirt_descriptors_t; + +/** Information about on-going control transfer. + */ +typedef struct usbvirt_control_transfer { + /** Transfer direction (read/write control transfer). */ + usb_direction_t direction; + /** Request data. */ + void *request; + /** Size of request data. */ + size_t request_size; + /** Payload. */ + void *data; + /** Size of payload. */ + size_t data_size; +} usbvirt_control_transfer_t; + +typedef enum { + USBVIRT_DEBUGTAG_BASE = 1, + USBVIRT_DEBUGTAG_TRANSACTION = 2, + USBVIRT_DEBUGTAG_CONTROL_PIPE_ZERO = 4, + USBVIRT_DEBUGTAG_ALL = 255 +} usbvirt_debug_tags_t; + +/** Virtual USB device. */ +struct usbvirt_device { + /** Callback device operations. */ + usbvirt_device_ops_t *ops; + + /** Custom device data. */ + void *device_data; + + /** Reply onto control transfer. + */ + int (*control_transfer_reply)(usbvirt_device_t *dev, + usb_endpoint_t endpoint, void *buffer, size_t size); + + /** Device name. + * Used in debug prints and sent to virtual host controller. + */ + const char *name; + + /** Standard descriptors. */ + usbvirt_descriptors_t *descriptors; + + /** Current device state. */ + usbvirt_device_state_t state; + + /** Device address. */ + usb_address_t address; + /** New device address. + * This field is used during SET_ADDRESS request. + * On all other occasions, it holds invalid address (e.g. -1). + */ + usb_address_t new_address; + + /** Process OUT transaction. */ + int (*transaction_out)(usbvirt_device_t *dev, + usb_endpoint_t endpoint, void *buffer, size_t size); + /** Process SETUP transaction. */ + int (*transaction_setup)(usbvirt_device_t *dev, + usb_endpoint_t endpoint, void *buffer, size_t size); + /** Process IN transaction. */ + int (*transaction_in)(usbvirt_device_t *dev, + usb_endpoint_t endpoint, void *buffer, size_t size, size_t *data_size); + + /** State information on control-transfer endpoints. */ + usbvirt_control_transfer_t current_control_transfers[USB11_ENDPOINT_MAX]; + + /* User debugging. */ + + /** Debug print. */ + void (*debug)(usbvirt_device_t *dev, int level, uint8_t tag, + const char *format, ...); + + /** Current debug level. */ + int debug_level; + + /** Bitmap of currently enabled tags. */ + uint8_t debug_enabled_tags; + + /* Library debugging. */ + + /** Debug print. */ + void (*lib_debug)(usbvirt_device_t *dev, int level, uint8_t tag, + const char *format, ...); + + /** Current debug level. */ + int lib_debug_level; + + /** Bitmap of currently enabled tags. */ + uint8_t lib_debug_enabled_tags; +}; + +#endif +/** + * @} + */ Index: uspace/lib/usbvirt/include/usbvirt/hub.h =================================================================== --- uspace/lib/usbvirt/include/usbvirt/hub.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usbvirt/include/usbvirt/hub.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,68 @@ +/* + * 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 libusbvirt + * @{ + */ +/** @file + * @brief Virtual USB device. + */ +#ifndef LIBUSBVIRT_HUB_H_ +#define LIBUSBVIRT_HUB_H_ + +#include "device.h" + +/** USB transaction type. + * This types does not correspond directly to types in USB specification, + * as actually DATA transactions are marked with these types to identify + * their direction (and tag). + */ +typedef enum { + USBVIRT_TRANSACTION_SETUP, + USBVIRT_TRANSACTION_IN, + USBVIRT_TRANSACTION_OUT +} usbvirt_transaction_type_t; + +const char *usbvirt_str_transaction_type(usbvirt_transaction_type_t type); + +/** Telephony methods of virtual devices. */ +typedef enum { + IPC_M_USBVIRT_GET_NAME = IPC_FIRST_USER_METHOD, + IPC_M_USBVIRT_TRANSACTION_SETUP, + IPC_M_USBVIRT_TRANSACTION_OUT, + IPC_M_USBVIRT_TRANSACTION_IN, +} usbvirt_device_method_t; + +int usbvirt_connect(usbvirt_device_t *); +int usbvirt_connect_local(usbvirt_device_t *); +int usbvirt_disconnect(usbvirt_device_t *dev); + +#endif +/** + * @} + */ Index: uspace/lib/usbvirt/src/callback.c =================================================================== --- uspace/lib/usbvirt/src/callback.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usbvirt/src/callback.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,237 @@ +/* + * 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 libusbvirt + * @{ + */ +/** @file + * @brief Callback connection handling. + */ +#include +#include +#include +#include +#include +#include + +#include "private.h" + +#define NAMESPACE "usb" +#define USB_MAX_PAYLOAD_SIZE 1020 + +/** Wrapper for SETUP transaction over telephone. */ +static void handle_setup_transaction(usbvirt_device_t *device, + ipc_callid_t iid, ipc_call_t icall) +{ + usb_address_t address = IPC_GET_ARG1(icall); + usb_endpoint_t endpoint = IPC_GET_ARG2(icall); + size_t expected_len = IPC_GET_ARG3(icall); + + if (address != device->address) { + async_answer_0(iid, EADDRNOTAVAIL); + return; + } + + if ((endpoint < 0) || (endpoint >= USB11_ENDPOINT_MAX)) { + async_answer_0(iid, EINVAL); + return; + } + + if (expected_len == 0) { + async_answer_0(iid, EINVAL); + return; + } + + 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(iid, rc); + return; + } + + rc = device->transaction_setup(device, endpoint, buffer, len); + + async_answer_0(iid, rc); +} + +/** Wrapper for OUT transaction over telephone. */ +static void handle_out_transaction(usbvirt_device_t *device, + ipc_callid_t iid, ipc_call_t icall) +{ + usb_address_t address = IPC_GET_ARG1(icall); + usb_endpoint_t endpoint = IPC_GET_ARG2(icall); + size_t expected_len = IPC_GET_ARG3(icall); + + if (address != device->address) { + async_answer_0(iid, EADDRNOTAVAIL); + return; + } + + if ((endpoint < 0) || (endpoint >= USB11_ENDPOINT_MAX)) { + async_answer_0(iid, EINVAL); + return; + } + + int rc = EOK; + + size_t len = 0; + void *buffer = NULL; + + if (expected_len > 0) { + rc = async_data_write_accept(&buffer, false, + 1, USB_MAX_PAYLOAD_SIZE, 0, &len); + + if (rc != EOK) { + async_answer_0(iid, rc); + return; + } + } + + rc = device->transaction_out(device, endpoint, buffer, len); + + if (buffer != NULL) { + free(buffer); + } + + async_answer_0(iid, rc); +} + + +/** Wrapper for IN transaction over telephone. */ +static void handle_in_transaction(usbvirt_device_t *device, + ipc_callid_t iid, ipc_call_t icall) +{ + usb_address_t address = IPC_GET_ARG1(icall); + usb_endpoint_t endpoint = IPC_GET_ARG2(icall); + size_t expected_len = IPC_GET_ARG3(icall); + + if (address != device->address) { + async_answer_0(iid, EADDRNOTAVAIL); + return; + } + + if ((endpoint < 0) || (endpoint >= USB11_ENDPOINT_MAX)) { + async_answer_0(iid, EINVAL); + return; + } + + int rc = EOK; + + void *buffer = expected_len > 0 ? malloc(expected_len) : NULL; + size_t len; + + rc = device->transaction_in(device, endpoint, buffer, expected_len, &len); + /* + * If the request was processed, we will send data back. + */ + if ((rc == EOK) && (expected_len > 0)) { + size_t receive_len; + ipc_callid_t callid; + if (!async_data_read_receive(&callid, &receive_len)) { + async_answer_0(iid, EINVAL); + return; + } + if (len > receive_len) { + len = receive_len; + } + async_data_read_finalize(callid, buffer, len); + } + + async_answer_1(iid, rc, len); +} + +/** Wrapper for getting device name. */ +static void handle_get_name(usbvirt_device_t *device, + ipc_callid_t iid, ipc_call_t icall) +{ + if (device->name == NULL) { + async_answer_0(iid, ENOENT); + } + + size_t size = str_size(device->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, device->name, accepted_size); + + async_answer_1(iid, EOK, accepted_size); +} + +/** Callback connection for a given device. */ +void device_callback_connection(usbvirt_device_t *device, ipc_callid_t iid, ipc_call_t *icall) +{ + async_answer_0(iid, EOK); + + while (true) { + ipc_callid_t callid; + ipc_call_t call; + + callid = async_get_call(&call); + switch (IPC_GET_IMETHOD(call)) { + case IPC_M_PHONE_HUNGUP: + async_answer_0(callid, EOK); + return; + + case IPC_M_USBVIRT_GET_NAME: + handle_get_name(device, callid, call); + break; + + case IPC_M_USBVIRT_TRANSACTION_SETUP: + handle_setup_transaction(device, callid, call); + break; + + case IPC_M_USBVIRT_TRANSACTION_OUT: + handle_out_transaction(device, callid, call); + break; + + case IPC_M_USBVIRT_TRANSACTION_IN: + handle_in_transaction(device, callid, call); + break; + + default: + async_answer_0(callid, EINVAL); + break; + } + } +} + + +/** + * @} + */ Index: uspace/lib/usbvirt/src/ctrlpipe.c =================================================================== --- uspace/lib/usbvirt/src/ctrlpipe.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usbvirt/src/ctrlpipe.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,182 @@ +/* + * 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 libusbvirt + * @{ + */ +/** @file + * @brief Device control pipe. + */ +#include + +#include "private.h" + +/** Compares handler type with request packet type. + * + * @param handler Handler. + * @param request_packet Request packet. + * @return Whether handler can serve this packet. + */ +static bool is_suitable_handler(usbvirt_control_transfer_handler_t *handler, + usb_device_request_setup_packet_t *request_packet) +{ + return ( + (handler->request_type == request_packet->request_type) + && (handler->request == request_packet->request)); + +} + +/** Find suitable transfer handler for given request packet. + * + * @param handlers Array of available handlers. + * @param request_packet Request SETUP packet. + * @return Handler or NULL. + */ +static usbvirt_control_transfer_handler_t *find_handler( + usbvirt_control_transfer_handler_t *handlers, + usb_device_request_setup_packet_t *request_packet) +{ + if (handlers == NULL) { + return NULL; + } + + while (handlers->callback != NULL) { + if (is_suitable_handler(handlers, request_packet)) { + return handlers; + } + handlers++; + } + + return NULL; +} + +#define _GET_BIT(byte, bit) \ + (((byte) & (1 << (bit))) ? '1' : '0') +#define _GET_BITS(byte) \ + _GET_BIT(byte, 7), _GET_BIT(byte, 6), _GET_BIT(byte, 5), \ + _GET_BIT(byte, 4), _GET_BIT(byte, 3), _GET_BIT(byte, 2), \ + _GET_BIT(byte, 1), _GET_BIT(byte, 0) + +static int find_and_run_handler(usbvirt_device_t *device, + usbvirt_control_transfer_handler_t *handlers, + usb_device_request_setup_packet_t *setup_packet, + uint8_t *data) +{ + int rc = EFORWARD; + usbvirt_control_transfer_handler_t *suitable_handler + = find_handler(handlers, setup_packet); + if (suitable_handler != NULL) { + const char *callback_name = "user handler"; + if (suitable_handler->name != NULL) { + callback_name = suitable_handler->name; + } + device->lib_debug(device, 1, USBVIRT_DEBUGTAG_CONTROL_PIPE_ZERO, + "pipe #0 - calling %s " \ + "[%c.%c%c.%c%c%c%c%c, R%d, V%d, I%d, L%d]", + callback_name, + _GET_BITS(setup_packet->request_type), + setup_packet->request, setup_packet->value, + setup_packet->index, setup_packet->length); + rc = suitable_handler->callback(device, setup_packet, data); + } + + return rc; +} +#undef _GET_BITS +#undef _GET_BIT + + +/** Handle communication over control pipe zero. + */ +int control_pipe(usbvirt_device_t *device, usbvirt_control_transfer_t *transfer) +{ + device->lib_debug(device, 2, USBVIRT_DEBUGTAG_CONTROL_PIPE_ZERO, + "op on control pipe zero (request_size=%u)", transfer->request_size); + + if (transfer->request_size < sizeof(usb_device_request_setup_packet_t)) { + return ENOMEM; + } + + usb_device_request_setup_packet_t *request + = (usb_device_request_setup_packet_t *) transfer->request; + + /* + * First, see whether user provided its own callback. + */ + int rc = EFORWARD; + if (device->ops) { + rc = find_and_run_handler(device, + device->ops->control_transfer_handlers, + request, transfer->data); + } + + /* + * If there was no user callback or the callback returned EFORWARD, + * we need to run a local handler. + */ + if (rc == EFORWARD) { + rc = find_and_run_handler(device, + control_pipe_zero_local_handlers, + request, transfer->data); + } + + /* + * Check for SET_ADDRESS finalization. + */ + if (device->new_address != -1) { + /* + * TODO: handle when this request is invalid (e.g. + * setting address when in configured state). + */ + usbvirt_device_state_t new_state; + if (device->new_address == 0) { + new_state = USBVIRT_STATE_DEFAULT; + } else { + new_state = USBVIRT_STATE_ADDRESS; + } + device->address = device->new_address; + + device->new_address = -1; + + if (DEVICE_HAS_OP(device, on_state_change)) { + device->ops->on_state_change(device, device->state, + new_state); + } + device->state = new_state; + + device->lib_debug(device, 2, USBVIRT_DEBUGTAG_CONTROL_PIPE_ZERO, + "device address changed to %d (state %s)", + device->address, str_device_state(device->state)); + } + + return rc; +} + +/** + * @} + */ Index: uspace/lib/usbvirt/src/debug.c =================================================================== --- uspace/lib/usbvirt/src/debug.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usbvirt/src/debug.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,103 @@ +/* + * 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 libusbvirt + * @{ + */ +/** @file + * @brief Debugging support. + */ +#include +#include + +#include "private.h" + + +static void debug_print(int level, uint8_t tag, + int current_level, uint8_t enabled_tags, + const char *format, va_list args) +{ + if (level > current_level) { + return; + } + + if ((tag & enabled_tags) == 0) { + return; + } + + bool print_prefix = true; + + if ((format[0] == '%') && (format[1] == 'M')) { + format += 2; + print_prefix = false; + } + + if (print_prefix) { + printf("[vusb]: "); + while (--level > 0) { + printf(" "); + } + } + + vprintf(format, args); + + if (print_prefix) { + printf("\n"); + } +} + + +void user_debug(usbvirt_device_t *device, int level, uint8_t tag, + const char *format, ...) +{ + va_list args; + va_start(args, format); + + debug_print(level, tag, + device->debug_level, device->debug_enabled_tags, + format, args); + + va_end(args); +} + +void lib_debug(usbvirt_device_t *device, int level, uint8_t tag, + const char *format, ...) +{ + va_list args; + va_start(args, format); + + debug_print(level, tag, + device->lib_debug_level, device->lib_debug_enabled_tags, + format, args); + + va_end(args); +} + +/** + * @} + */ Index: uspace/lib/usbvirt/src/main.c =================================================================== --- uspace/lib/usbvirt/src/main.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usbvirt/src/main.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,284 @@ +/* + * 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 libusbvirt + * @{ + */ +/** @file + * @brief Device registration with virtual USB framework. + */ +#include +#include +#include +#include +#include + +#include "private.h" + +#define NAMESPACE "usb" + +/** Virtual device wrapper. */ +typedef struct { + /** Actual device. */ + usbvirt_device_t *device; + /** Phone to host controller. */ + int vhcd_phone; + /** Device id. */ + sysarg_t id; + /** Linked-list member. */ + link_t link; +} virtual_device_t; + +/*** List of known device. */ +static LIST_INITIALIZE(device_list); + +/** Find virtual device wrapper based on the contents. */ +static virtual_device_t *find_device(usbvirt_device_t *device) +{ + if (list_empty(&device_list)) { + return NULL; + } + + link_t *pos; + for (pos = device_list.next; pos != &device_list; pos = pos->next) { + virtual_device_t *dev + = list_get_instance(pos, virtual_device_t, link); + if (dev->device == device) { + return dev; + } + } + + return NULL; +} + +/** Find virtual device wrapper by its id. */ +static virtual_device_t *find_device_by_id(sysarg_t id) +{ + if (list_empty(&device_list)) { + return NULL; + } + + link_t *pos; + for (pos = device_list.next; pos != &device_list; pos = pos->next) { + virtual_device_t *dev + = list_get_instance(pos, virtual_device_t, link); + if (dev->id == id) { + return dev; + } + } + + return NULL; +} + +/** Reply to a control transfer. */ +static int control_transfer_reply(usbvirt_device_t *device, + usb_endpoint_t endpoint, void *buffer, size_t size) +{ + usbvirt_control_transfer_t *transfer = &device->current_control_transfers[endpoint]; + if (transfer->data != NULL) { + free(transfer->data); + } + transfer->data = malloc(size); + memcpy(transfer->data, buffer, size); + transfer->data_size = size; + + return EOK; +} + +/** Initialize virtual device. */ +static void device_init(usbvirt_device_t *dev) +{ + dev->transaction_out = transaction_out; + dev->transaction_setup = transaction_setup; + dev->transaction_in = transaction_in; + + dev->control_transfer_reply = control_transfer_reply; + + dev->debug = user_debug; + dev->lib_debug = lib_debug; + + dev->state = USBVIRT_STATE_DEFAULT; + dev->address = 0; + dev->new_address = -1; + + size_t i; + for (i = 0; i < USB11_ENDPOINT_MAX; i++) { + usbvirt_control_transfer_t *transfer = &dev->current_control_transfers[i]; + transfer->direction = 0; + transfer->request = NULL; + transfer->request_size = 0; + transfer->data = NULL; + transfer->data_size = 0; + } +} + +/** Add a virtual device. + * The returned device (if not NULL) shall be destroy via destroy_device(). + */ +static virtual_device_t *add_device(usbvirt_device_t *dev) +{ + assert(find_device(dev) == NULL); + virtual_device_t *new_device + = (virtual_device_t *) malloc(sizeof(virtual_device_t)); + + new_device->device = dev; + link_initialize(&new_device->link); + + list_append(&new_device->link, &device_list); + + return new_device; +} + +/** Destroy virtual device. */ +static void destroy_device(virtual_device_t *dev) +{ + if (dev->vhcd_phone > 0) { + async_hangup(dev->vhcd_phone); + } + + list_remove(&dev->link); + + free(dev); +} + +/** Callback connection handler. */ +static void callback_connection(ipc_callid_t iid, ipc_call_t *icall) +{ + // FIXME - determine which device just called back + virtual_device_t *dev = find_device_by_id(0); + if (dev == NULL) { + async_answer_0(iid, EINVAL); + printf("Ooops\n"); + return; + } + + device_callback_connection(dev->device, iid, icall); +} + +/** Create necessary phones for communication with virtual HCD. + * This function wraps following calls: + * -# open /dev/devices/\\virt\\usbhc for reading + * -# access phone of file opened in previous step + * -# create callback through just opened phone + * -# create handler for calling on data from host to function + * -# return the (outgoing) phone + * + * @warning This function is wrapper for several actions and therefore + * it is not possible - in case of error - to determine at which point + * error occurred. + * + * @param dev Device to connect. + * @return EOK on success or error code from errno.h. + */ +int usbvirt_connect(usbvirt_device_t *dev) +{ + virtual_device_t *virtual_device = find_device(dev); + if (virtual_device != NULL) { + return EEXISTS; + } + + const char *vhc_path = "/virt/usbhc/hc"; + int rc; + devman_handle_t handle; + + rc = devman_device_get_handle(vhc_path, &handle, 0); + if (rc != EOK) { + printf("devman_device_get_handle() failed\n"); + return rc; + } + + int hcd_phone = devman_device_connect(handle, 0); + + if (hcd_phone < 0) { + printf("devman_device_connect() failed\n"); + return hcd_phone; + } + + rc = async_connect_to_me(hcd_phone, 0, 0, 0, callback_connection); + if (rc != EOK) { + printf("ipc_connect_to_me() failed\n"); + return rc; + } + + device_init(dev); + + virtual_device = add_device(dev); + virtual_device->vhcd_phone = hcd_phone; + virtual_device->id = 0; + + return EOK; +} + +/** Prepares device as local. + * This is useful if you want to have a virtual device in the same task + * as HCD. + * + * @param dev Device to connect. + * @return Error code. + * @retval EOK Device connected. + * @retval EEXISTS This device is already connected. + */ +int usbvirt_connect_local(usbvirt_device_t *dev) +{ + virtual_device_t *virtual_device = find_device(dev); + if (virtual_device != NULL) { + return EEXISTS; + } + + device_init(dev); + + virtual_device = add_device(dev); + virtual_device->vhcd_phone = -1; + virtual_device->id = 0; + + return EOK; +} + +/** Disconnects device from HCD. + * + * @param dev Device to be disconnected. + * @return Error code. + * @retval EOK Device connected. + * @retval ENOENT This device is not connected. + */ +int usbvirt_disconnect(usbvirt_device_t *dev) +{ + virtual_device_t *virtual_device = find_device(dev); + if (virtual_device == NULL) { + return ENOENT; + } + + destroy_device(virtual_device); + + return EOK; +} + + +/** + * @} + */ Index: uspace/lib/usbvirt/src/private.h =================================================================== --- uspace/lib/usbvirt/src/private.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usbvirt/src/private.h (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,94 @@ +/* + * 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 libusbvirt + * @{ + */ +/** @file + * @brief Virtual USB private header. + */ +#ifndef LIBUSBVIRT_PRIVATE_H_ +#define LIBUSBVIRT_PRIVATE_H_ + +#include +#include +#include + + +#define DEVICE_HAS_OP(dev, op) \ + ( \ + ( ((dev)->ops) != NULL ) \ + && \ + ( ((dev)->ops->op) != NULL ) \ + ) + +int usbvirt_data_to_host(struct usbvirt_device *dev, + usb_endpoint_t endpoint, void *buffer, size_t size); + +int handle_incoming_data(struct usbvirt_device *dev, + usb_endpoint_t endpoint, void *buffer, size_t size); + +int control_pipe(usbvirt_device_t *device, usbvirt_control_transfer_t *transfer); + +int handle_std_request(usbvirt_device_t *device, usb_device_request_setup_packet_t *request, uint8_t *data); + +void device_callback_connection(usbvirt_device_t *device, ipc_callid_t iid, ipc_call_t *icall); + +int transaction_setup(usbvirt_device_t *device, usb_endpoint_t endpoint, + void *buffer, size_t size); +int transaction_out(usbvirt_device_t *device, usb_endpoint_t endpoint, + void *buffer, size_t size); +int transaction_in(usbvirt_device_t *device, usb_endpoint_t endpoint, + void *buffer, size_t size, size_t *data_size); + + +void user_debug(usbvirt_device_t *device, int level, uint8_t tag, + const char *format, ...); +void lib_debug(usbvirt_device_t *device, int level, uint8_t tag, + const char *format, ...); + +static inline const char *str_device_state(usbvirt_device_state_t state) +{ + switch (state) { + case USBVIRT_STATE_DEFAULT: + return "default"; + case USBVIRT_STATE_ADDRESS: + return "address"; + case USBVIRT_STATE_CONFIGURED: + return "configured"; + default: + return "unknown"; + } +} + +extern usbvirt_control_transfer_handler_t control_pipe_zero_local_handlers[]; + +#endif +/** + * @} + */ Index: uspace/lib/usbvirt/src/stdreq.c =================================================================== --- uspace/lib/usbvirt/src/stdreq.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usbvirt/src/stdreq.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -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 libusbvirt + * @{ + */ +/** @file + * @brief Preprocessing of standard device requests. + */ +#include +#include +#include +#include + +#include "private.h" + +/* + * All sub handlers must return EFORWARD to inform the caller that + * they were not able to process the request (yes, it is abuse of + * this error code but such error code shall not collide with anything + * else in this context). + */ + +/** GET_DESCRIPTOR handler. */ +static int handle_get_descriptor(usbvirt_device_t *device, + usb_device_request_setup_packet_t *setup_packet, uint8_t *extra_data) +{ + 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) { + return device->control_transfer_reply(device, 0, + device->descriptors->device, + device->descriptors->device->length); + } 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; + } + + int rc = device->control_transfer_reply(device, 0, + all_data, config->descriptor->total_length); + + free(all_data); + + return rc; + } + + return EFORWARD; +} + +/** SET_ADDRESS handler. */ +static int handle_set_address(usbvirt_device_t *device, + usb_device_request_setup_packet_t *setup_packet, uint8_t *extra_data) +{ + 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->new_address = new_address; + + return EOK; +} + +/** SET_CONFIGURATION handler. */ +static int handle_set_configuration(usbvirt_device_t *device, + usb_device_request_setup_packet_t *setup_packet, uint8_t *extra_data) +{ + 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; + } + + if (configuration_value == 0) { + if (DEVICE_HAS_OP(device, on_state_change)) { + device->ops->on_state_change(device, device->state, + USBVIRT_STATE_ADDRESS); + } + device->state = USBVIRT_STATE_ADDRESS; + } else { + /* + * TODO: browse provided configurations and verify that + * user selected existing configuration. + */ + if (DEVICE_HAS_OP(device, on_state_change)) { + device->ops->on_state_change(device, device->state, + USBVIRT_STATE_CONFIGURED); + } + device->state = USBVIRT_STATE_CONFIGURED; + if (device->descriptors) { + device->descriptors->current_configuration + = configuration_value; + } + } + + return EOK; +} + + +#define MAKE_BM_REQUEST(direction, recipient) \ + USBVIRT_MAKE_CONTROL_REQUEST_TYPE(direction, \ + USBVIRT_REQUEST_TYPE_STANDARD, recipient) +#define MAKE_BM_REQUEST_DEV(direction) \ + MAKE_BM_REQUEST(direction, USBVIRT_REQUEST_RECIPIENT_DEVICE) + +usbvirt_control_transfer_handler_t control_pipe_zero_local_handlers[] = { + { + .request_type = MAKE_BM_REQUEST_DEV(USB_DIRECTION_IN), + .request = USB_DEVREQ_GET_DESCRIPTOR, + .name = "GetDescriptor()", + .callback = handle_get_descriptor + }, + { + .request_type = MAKE_BM_REQUEST_DEV(USB_DIRECTION_OUT), + .request = USB_DEVREQ_SET_ADDRESS, + .name = "SetAddress()", + .callback = handle_set_address + }, + { + .request_type = MAKE_BM_REQUEST_DEV(USB_DIRECTION_OUT), + .request = USB_DEVREQ_SET_CONFIGURATION, + .name = "SetConfiguration()", + .callback = handle_set_configuration + }, + USBVIRT_CONTROL_TRANSFER_HANDLER_LAST +}; + +/** + * @} + */ Index: uspace/lib/usbvirt/src/transaction.c =================================================================== --- uspace/lib/usbvirt/src/transaction.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) +++ uspace/lib/usbvirt/src/transaction.c (revision c6ba274aa68a445083bad01216d871fc194dcdd6) @@ -0,0 +1,268 @@ +/* + * 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 libusbvirt + * @{ + */ +/** @file + * @brief Transaction processing. + */ +#include +#include +#include + +#include "private.h" + +static usb_direction_t setup_transaction_direction(usbvirt_device_t *, + usb_endpoint_t, void *, size_t); +static void process_control_transfer(usbvirt_device_t *, + usb_endpoint_t, usbvirt_control_transfer_t *); + +/** Convert virtual USB transaction type to string. + */ +const char *usbvirt_str_transaction_type(usbvirt_transaction_type_t type) +{ + switch (type) { + case USBVIRT_TRANSACTION_SETUP: + return "setup"; + case USBVIRT_TRANSACTION_IN: + return "in"; + case USBVIRT_TRANSACTION_OUT: + return "out"; + default: + return "unknown"; + } +} + +/** SETUP transaction handling. + * The setup transaction only prepares control transfer on given endpoint. + */ +int transaction_setup(usbvirt_device_t *device, usb_endpoint_t endpoint, + void *buffer, size_t size) +{ + device->lib_debug(device, 1, USBVIRT_DEBUGTAG_TRANSACTION, + "setup transaction: endpoint=%d, size=%u", endpoint, size); + + usbvirt_control_transfer_t *transfer = &device->current_control_transfers[endpoint]; + + if (transfer->request != NULL) { + free(transfer->request); + } + if (transfer->data != NULL) { + free(transfer->data); + } + + transfer->direction = setup_transaction_direction(device, endpoint, + buffer, size); + transfer->request = malloc(size); + memcpy(transfer->request, buffer, size); + transfer->request_size = size; + transfer->data = NULL; + transfer->data_size = 0; + + if (transfer->direction == USB_DIRECTION_IN) { + process_control_transfer(device, endpoint, transfer); + } + + return EOK; +} + +/** OUT transaction handling. + * The OUT transaction can trigger processing of a control transfer. + */ +int transaction_out(usbvirt_device_t *device, usb_endpoint_t endpoint, + void *buffer, size_t size) +{ + device->lib_debug(device, 1, USBVIRT_DEBUGTAG_TRANSACTION, + "out transaction: endpoint=%d, size=%u", endpoint, size); + + /* + * First check whether it is a transaction over control pipe. + */ + usbvirt_control_transfer_t *transfer = &device->current_control_transfers[endpoint]; + if (transfer->request != NULL) { + if (transfer->direction == USB_DIRECTION_OUT) { + /* + * For out transactions, append the data to the buffer. + */ + uint8_t *new_buffer = (uint8_t *) malloc(transfer->data_size + size); + if (transfer->data) { + memcpy(new_buffer, transfer->data, transfer->data_size); + } + memcpy(new_buffer + transfer->data_size, buffer, size); + + if (transfer->data) { + free(transfer->data); + } + transfer->data = new_buffer; + transfer->data_size += size; + } else { + /* + * For in transactions, this means end of the + * transaction. + */ + free(transfer->request); + if (transfer->data) { + free(transfer->data); + } + transfer->request = NULL; + transfer->request_size = 0; + transfer->data = NULL; + transfer->data_size = 0; + } + + return EOK; + } + + /* + * Otherwise, announce that some data has come. + */ + if (device->ops && device->ops->on_data) { + return device->ops->on_data(device, endpoint, buffer, size); + } else { + return ENOTSUP; + } +} + +/** IN transaction handling. + * The IN transaction can trigger processing of a control transfer. + */ +int transaction_in(usbvirt_device_t *device, usb_endpoint_t endpoint, + void *buffer, size_t size, size_t *data_size) +{ + device->lib_debug(device, 1, USBVIRT_DEBUGTAG_TRANSACTION, + "in transaction: endpoint=%d, size=%u", endpoint, size); + + /* + * First check whether it is a transaction over control pipe. + */ + usbvirt_control_transfer_t *transfer = &device->current_control_transfers[endpoint]; + if (transfer->request != NULL) { + if (transfer->direction == USB_DIRECTION_OUT) { + /* + * This means end of input data. + */ + process_control_transfer(device, endpoint, transfer); + } else { + /* + * For in transactions, this means sending next part + * of the buffer. + */ + // FIXME: handle when the HC wants the data back + // in more chunks + size_t actual_size = 0; + if (transfer->data) { + actual_size = transfer->data_size; + } + if (actual_size > size) { + actual_size = size; + } + device->lib_debug(device, 1, USBVIRT_DEBUGTAG_TRANSACTION, + "in transaction: will copy %zu bytes", actual_size); + if (actual_size > 0) { + memcpy(buffer, transfer->data, actual_size); + if (data_size) { + *data_size = actual_size; + } + } + } + + return EOK; + } + + if (size == 0) { + return EINVAL; + } + + int rc = 1; + + if (device->ops && device->ops->on_data_request) { + rc = device->ops->on_data_request(device, endpoint, buffer, size, data_size); + } + + return rc; +} + +/** Determine direction of control transfer. + * First, try the user provided callback, otherwise guess, believing that + * it uses the same format as control pipe 0. + */ +static usb_direction_t setup_transaction_direction(usbvirt_device_t *device, + usb_endpoint_t endpoint, + void *data, size_t size) +{ + int direction = -1; + if (device->ops && device->ops->decide_control_transfer_direction) { + direction = device->ops->decide_control_transfer_direction(endpoint, + data, size); + } + + /* + * If the user-supplied routine have not handled the direction + * (or simply was not provided) we will guess, hoping that it + * uses same format as standard request on control pipe zero. + */ + if (direction < 0) { + if (size > 0) { + uint8_t *ptr = (uint8_t *) data; + if ((ptr[0] & 128) == 128) { + direction = USB_DIRECTION_IN; + } else { + direction = USB_DIRECTION_OUT; + } + } else { + /* This shall not happen anyway. */ + direction = USB_DIRECTION_OUT; + } + } + + return (usb_direction_t) direction; +} + +/** Process control transfer. + */ +static void process_control_transfer(usbvirt_device_t *device, + usb_endpoint_t endpoint, + usbvirt_control_transfer_t *transfer) +{ + int rc = EFORWARD; + + if (device->ops && device->ops->on_control_transfer) { + rc = device->ops->on_control_transfer(device, endpoint, transfer); + } + + if (rc == EFORWARD) { + if (endpoint == 0) { + rc = control_pipe(device, transfer); + } + } +} + +/** + * @} + */