Index: uspace/lib/usb/hcd.c =================================================================== --- uspace/lib/usb/hcd.c (revision fa2a3611e963c611a00be931fc762129e542bea4) +++ uspace/lib/usb/hcd.c (revision 1d1f8944ede1a0aa44224dfdbf374178bcb040a0) @@ -90,23 +90,19 @@ } -/** Create necessary phones for comunicating with HCD. +/** Create necessary phones for communicating 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. + * error occurred. * * @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) + * @return Phone for communicating with HCD or error code from errno.h. + */ +int usb_hcd_connect(const char * hcd_path) { char dev_path[DEVMAP_NAME_MAXLEN + 1]; @@ -124,242 +120,7 @@ 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; -} - - -static int send_buffer(int phone, ipcarg_t method, usb_target_t target, - void *buffer, size_t size, usb_transaction_handle_t * transaction_handle) -{ - if (phone < 0) { - return EINVAL; - } - - if ((buffer == NULL) && (size > 0)) { - return EINVAL; - } - - ipc_call_t answer_data; - ipcarg_t answer_rc; - aid_t req; - int rc; - - req = async_send_3(phone, - method, - target.address, target.endpoint, - size, - &answer_data); - - if (size > 0) { - rc = async_data_write_start(phone, buffer, size); - 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; -} - - -static int prep_receive_data(int phone, ipcarg_t method, usb_target_t target, - size_t size, usb_transaction_handle_t * transaction_handle) -{ - if (phone < 0) { - return EINVAL; - } - - usb_transaction_handle_t handle; - - int rc = ipc_call_sync_3_1(phone, - method, - target.address, target.endpoint, - size, - &handle); - - if (rc != EOK) { - return rc; - } - - if (transaction_handle != NULL) { - *transaction_handle = handle; - } - - return EOK; -} - - -int usb_hcd_transfer_interrupt_out(int hcd_phone, usb_target_t target, - void *buffer, size_t size, usb_transaction_handle_t *handle) -{ - return send_buffer(hcd_phone, IPC_M_USB_HCD_INTERRUPT_OUT, - target, buffer, size, handle); -} - -int usb_hcd_transfer_interrupt_in(int hcd_phone, usb_target_t target, - size_t size, usb_transaction_handle_t *handle) -{ - return prep_receive_data(hcd_phone, IPC_M_USB_HCD_INTERRUPT_IN, - target, size, handle); -} - -int usb_hcd_transfer_control_write_setup(int hcd_phone, usb_target_t target, - void *buffer, size_t size, usb_transaction_handle_t *handle) -{ - return send_buffer(hcd_phone, IPC_M_USB_HCD_CONTROL_WRITE_SETUP, - target, buffer, size, handle); -} - -int usb_hcd_transfer_control_write_data(int hcd_phone, usb_target_t target, - void *buffer, size_t size, usb_transaction_handle_t *handle) -{ - return send_buffer(hcd_phone, IPC_M_USB_HCD_CONTROL_WRITE_DATA, - target, buffer, size, handle); - -} -int usb_hcd_transfer_control_write_status(int hcd_phone, usb_target_t target, - usb_transaction_handle_t *handle) -{ - return prep_receive_data(hcd_phone, IPC_M_USB_HCD_CONTROL_WRITE_STATUS, - target, 0, handle); -} - -int usb_hcd_transfer_control_read_setup(int hcd_phone, usb_target_t target, - void *buffer, size_t size, usb_transaction_handle_t *handle) -{ - return send_buffer(hcd_phone, IPC_M_USB_HCD_CONTROL_READ_SETUP, - target, buffer, size, handle); -} -int usb_hcd_transfer_control_read_data(int hcd_phone, usb_target_t target, - size_t size, usb_transaction_handle_t *handle) -{ - return prep_receive_data(hcd_phone, IPC_M_USB_HCD_CONTROL_READ_DATA, - target, size, handle); -} -int usb_hcd_transfer_control_read_status(int hcd_phone, usb_target_t target, - usb_transaction_handle_t *handle) -{ - return send_buffer(hcd_phone, IPC_M_USB_HCD_CONTROL_READ_STATUS, - target, NULL, 0, handle); -} - - - - - -/* - * ================= - * async versions of the above functions - * ================= - */ /** Send data to HCD. Index: uspace/lib/usb/hcd.h =================================================================== --- uspace/lib/usb/hcd.h (revision fa2a3611e963c611a00be931fc762129e542bea4) +++ uspace/lib/usb/hcd.h (revision 1d1f8944ede1a0aa44224dfdbf374178bcb040a0) @@ -133,53 +133,7 @@ * OUT transactions buffers can be freed immediatelly after call is dispatched * (i.e. after return from wrapping function). - * - * Async methods for retrieving data from device: - */ -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, - + * + */ +typedef enum { /** Tell maximum size of the transaction buffer (payload). * @@ -193,19 +147,5 @@ * - buffer size (in bytes): */ - IPC_M_USB_HCD_TRANSACTION_SIZE, - - - IPC_M_USB_HCD_INTERRUPT_OUT, - IPC_M_USB_HCD_INTERRUPT_IN, - - IPC_M_USB_HCD_CONTROL_WRITE_SETUP, - IPC_M_USB_HCD_CONTROL_WRITE_DATA, - IPC_M_USB_HCD_CONTROL_WRITE_STATUS, - - IPC_M_USB_HCD_CONTROL_READ_SETUP, - IPC_M_USB_HCD_CONTROL_READ_DATA, - IPC_M_USB_HCD_CONTROL_READ_STATUS, - - /* async methods */ + IPC_M_USB_HCD_TRANSACTION_SIZE = IPC_FIRST_USER_METHOD, /** Asks for data buffer. @@ -293,29 +233,5 @@ -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 *); - - -int usb_hcd_transfer_interrupt_out(int, usb_target_t, - void *, size_t, usb_transaction_handle_t *); -int usb_hcd_transfer_interrupt_in(int, usb_target_t, - size_t, usb_transaction_handle_t *); - -int usb_hcd_transfer_control_write_setup(int, usb_target_t, - void *, size_t, usb_transaction_handle_t *); -int usb_hcd_transfer_control_write_data(int, usb_target_t, - void *, size_t, usb_transaction_handle_t *); -int usb_hcd_transfer_control_write_status(int, usb_target_t, - usb_transaction_handle_t *); - -int usb_hcd_transfer_control_read_setup(int, usb_target_t, - void *, size_t, usb_transaction_handle_t *); -int usb_hcd_transfer_control_read_data(int, usb_target_t, - size_t, usb_transaction_handle_t *); -int usb_hcd_transfer_control_read_status(int, usb_target_t, - usb_transaction_handle_t *); +int usb_hcd_connect(const char *); int usb_hcd_async_transfer_interrupt_out(int, usb_target_t,