Index: uspace/lib/usb/Makefile =================================================================== --- uspace/lib/usb/Makefile (revision 4bc309bf9ecb5c52d870148e834fec37fd241140) +++ uspace/lib/usb/Makefile (revision 4bc309bf9ecb5c52d870148e834fec37fd241140) @@ -0,0 +1,35 @@ +# +# 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 + +SOURCES = \ + hcd.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/lib/usb/hcd.c =================================================================== --- uspace/lib/usb/hcd.c (revision 4bc309bf9ecb5c52d870148e834fec37fd241140) +++ uspace/lib/usb/hcd.c (revision 4bc309bf9ecb5c52d870148e834fec37fd241140) @@ -0,0 +1,215 @@ +/* + * 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 usb + * @{ + */ +/** @file + * @brief USB Host Controller Driver (implementation). + */ +#include "hcd.h" +#include +#include +#include +#include + + +#define NAMESPACE "usb" + +/** String representation for USB transfer type. */ +const char * usb_str_transfer_type(usb_transfer_type_t t) +{ + switch (t) { + case USB_TRANSFER_ISOCHRONOUS: + return "isochronous"; + case USB_TRANSFER_INTERRUPT: + return "interrupt"; + case USB_TRANSFER_CONTROL: + return "control"; + case USB_TRANSFER_BULK: + return "bulk"; + default: + return "unknown"; + } +} + +/** String representation of USB transaction outcome. */ +const char * usb_str_transaction_outcome(usb_transaction_outcome_t o) +{ + switch (o) { + case USB_OUTCOME_OK: + return "ok"; + case USB_OUTCOME_CRCERROR: + return "CRC error"; + case USB_OUTCOME_BABBLE: + return "babble"; + default: + return "unknown"; + } +} + +/** Create necessary phones for comunicating with HCD. + * This function wraps following calls: + * -# open /dev/usb/hcd_path for reading + * -# access phone of file opened in previous step + * -# create callback through just opened phone + * -# set handler for this callback + * -# 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 occured. + * + * @param hcd_path HCD identification under devfs + * (without /dev/usb/). + * @param callback_connection Handler for callbacks from HCD. + * @return Phone for comunicating with HCD or error code from errno.h. + */ +int usb_hcd_create_phones(const char * hcd_path, + async_client_conn_t callback_connection) +{ + char dev_path[DEVMAP_NAME_MAXLEN + 1]; + snprintf(dev_path, DEVMAP_NAME_MAXLEN, + "/dev/%s/%s", NAMESPACE, hcd_path); + + int fd = open(dev_path, O_RDONLY); + if (fd < 0) { + return fd; + } + + int hcd_phone = fd_phone(fd); + + if (hcd_phone < 0) { + return hcd_phone; + } + + ipcarg_t phonehash; + int rc = ipc_connect_to_me(hcd_phone, 0, 0, 0, &phonehash); + if (rc != EOK) { + return rc; + } + async_new_connection(phonehash, 0, NULL, callback_connection); + + return hcd_phone; +} + +/** Send data from USB host to a function. + * + * @param hcd_phone Connected phone to HCD. + * @param target USB function address. + * @param transfer_type USB transfer type. + * @param buffer Buffer with data to be sent. + * @param len Buffer @p buffer size. + * @param[out] transaction_handle Handle of created transaction (NULL to ignore). + * @return Error status. + * @retval EOK Everything OK, buffer transfered to HCD and queued there. + * @retval EINVAL Invalid phone. + * @retval EINVAL @p buffer is NULL. + */ +int usb_hcd_send_data_to_function(int hcd_phone, + usb_target_t target, usb_transfer_type_t transfer_type, + void * buffer, size_t len, + usb_transaction_handle_t * transaction_handle) +{ + if (hcd_phone < 0) { + return EINVAL; + } + if (buffer == NULL) { + return EINVAL; + } + + ipc_call_t answer_data; + ipcarg_t answer_rc; + aid_t req; + int rc; + + req = async_send_4(hcd_phone, + IPC_M_USB_HCD_SEND_DATA, + target.address, target.endpoint, + transfer_type, 0, + &answer_data); + + rc = async_data_write_start(hcd_phone, buffer, len); + if (rc != EOK) { + async_wait_for(req, NULL); + return rc; + } + + async_wait_for(req, &answer_rc); + rc = (int)answer_rc; + if (rc != EOK) { + return rc; + } + + if (transaction_handle != NULL) { + *transaction_handle = IPC_GET_ARG1(answer_data); + } + + return EOK; +} + + +/** Inform HCD about data reception. + * The actual reception is handled in callback. + * + * @param hcd_phone Connected phone to HCD. + * @param target USB function address. + * @param transfer_type USB transfer type. + * @param len Maximum accepted packet size. + * @param[out] transaction_handle Handle of created transaction (NULL to ignore). + * @return Error status. + */ +int usb_hcd_prepare_data_reception(int hcd_phone, + usb_target_t target, usb_transfer_type_t transfer_type, + size_t len, + usb_transaction_handle_t * transaction_handle) +{ + if (hcd_phone < 0) { + return EINVAL; + } + + usb_transaction_handle_t handle; + + int rc = ipc_call_sync_5_1(hcd_phone, IPC_M_USB_HCD_RECEIVE_DATA, + target.address, target.endpoint, + transfer_type, len, 0, &handle); + + if (rc != EOK) { + return rc; + } + + if (transaction_handle != NULL) { + *transaction_handle = handle; + } + + return EOK; +} + +/** + * @} + */ Index: uspace/lib/usb/hcd.h =================================================================== --- uspace/lib/usb/hcd.h (revision 4bc309bf9ecb5c52d870148e834fec37fd241140) +++ uspace/lib/usb/hcd.h (revision 4bc309bf9ecb5c52d870148e834fec37fd241140) @@ -0,0 +1,190 @@ +/* + * 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 usb + * @{ + */ +/** @file + * @brief USB Host Controller Driver. + */ +#ifndef LIBUSB_HCD_H_ +#define LIBUSB_HCD_H_ + +#include +#include + +/** Maximum size of transaction payload. */ +#define USB_MAX_PAYLOAD_SIZE 1020 + +/** USB transfer type. */ +typedef enum { + USB_TRANSFER_ISOCHRONOUS, + USB_TRANSFER_INTERRUPT, + USB_TRANSFER_CONTROL, + USB_TRANSFER_BULK +} usb_transfer_type_t; + +const char * usb_str_transfer_type(usb_transfer_type_t t); + +/** USB data transfer direction. */ +typedef enum { + USB_DIRECTION_IN, + USB_DIRECTION_OUT +} usb_direction_t; + +/** USB address type. + * Negative values could be used to indicate error. + */ +typedef int usb_address_t; + +/** USB endpoint number type. + * Negative values could be used to indicate error. + */ +typedef int usb_endpoint_t; + +/** 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; + +/** Opaque handle of active USB transaction. + * This handle is when informing about transaction outcome (or status). + */ +typedef ipcarg_t usb_transaction_handle_t; + +/** USB transaction outcome. */ +typedef enum { + USB_OUTCOME_OK, + USB_OUTCOME_CRCERROR, + USB_OUTCOME_BABBLE +} usb_transaction_outcome_t; + +const char * usb_str_transaction_outcome(usb_transaction_outcome_t o); + +/** IPC methods for HCD. */ +typedef enum { + /** Send data over USB to a function. + * This method initializes large data transfer that must follow + * immediatelly. + * The recipient of this method must issue immediately data reception + * and answer this call after data buffer was transfered. + * + * Arguments of the call: + * - USB address of the function + * - endpoint of the function + * - transfer type + * - flags (not used) + * + * Answer: + * - EOK - ready to accept the data buffer + * - ELIMIT - too many transactions for current connection + * - ENOENT - callback connection does not exist + * - EINVAL - other kind of error + * + * Arguments of the answer: + * - opaque transaction handle (used in callbacks) + */ + IPC_M_USB_HCD_SEND_DATA = IPC_FIRST_USER_METHOD, + + /** Initiate data receive from a function. + * This method announces the HCD that some data will come. + * When this data arrives, the HCD will call back with + * IPC_M_USB_HCD_DATA_RECEIVED. + * + * Arguments of the call: + * - USB address of the function + * - endpoint of the function + * - transfer type + * - buffer size + * - flags (not used) + * + * Answer: + * - EOK - HCD accepted the request + * - ELIMIT - too many transactions for current connection + * - ENOENT - callback connection does not exist + * + * Arguments of the answer: + * - opaque transaction handle (used in callbacks) + */ + IPC_M_USB_HCD_RECEIVE_DATA, + + /** Tell maximum size of the transaction buffer (payload). + * + * Arguments of the call: + * (none) + * + * Answer: + * - EOK - always + * + * Arguments of the answer: + * - buffer size (in bytes): + */ + IPC_M_USB_HCD_TRANSACTION_SIZE +} usb_hcd_method_t; + +/** IPC methods for callbacks from HCD. */ +typedef enum { + /** Confimation after data sent. + * + * Arguments of the call: + * - transaction handle + * - transaction outcome + */ + IPC_M_USB_HCD_DATA_SENT = IPC_FIRST_USER_METHOD, + + /** Notification of data received. + * This call initiates sending a data buffer from HCD to the client. + * See IPC_M_USB_HCD_SEND_DATA for details for buffer transfer is + * done. + * + * Arguments of the call: + * - transaction handle + * - transaction outcome + * - actual data length + */ + IPC_M_USB_HCD_DATA_RECEIVED, + + /** Notification about a serious trouble with HC. + */ + IPC_M_USB_HCD_CONTROLLER_FAILURE +} usb_hcd_callback_method_t; + + +int usb_hcd_create_phones(const char *, async_client_conn_t); +int usb_hcd_send_data_to_function(int, usb_target_t, usb_transfer_type_t, + void *, size_t, usb_transaction_handle_t *); +int usb_hcd_prepare_data_reception(int, usb_target_t, usb_transfer_type_t, + size_t, usb_transaction_handle_t *); + +#endif +/** + * @} + */