/** Initialize new instance of USB device.
*
* @param[in] usb_dev Pointer to the new device.
* @param[in] ddf_dev Generic DDF device backing the USB one.
* @param[in] endpoints NULL terminated array of endpoints (NULL for none).
* @param[out] errstr_ptr Where to store description of context
* (in case error occurs).
* @return Error code.
*/
static int usb_device_init(usb_device_t *usb_dev, ddf_dev_t *ddf_dev,
const usb_endpoint_description_t **endpoints, const char **errstr_ptr,
devman_handle_t handle, int interface_no)
{
assert(usb_dev != NULL);
assert(errstr_ptr);
*errstr_ptr = NULL;
usb_dev->ddf_dev = ddf_dev;
usb_dev->handle = handle;
usb_dev->interface_no = interface_no;
usb_dev->driver_data = NULL;
usb_dev->descriptors.full_config = NULL;
usb_dev->descriptors.full_config_size = 0;
usb_dev->pipes_count = 0;
usb_dev->pipes = NULL;
usb_dev->bus_session = usb_dev_connect(handle);
if (!usb_dev->bus_session) {
*errstr_ptr = "device bus session create";
return ENOMEM;
}
/* This pipe was registered by the hub driver,
* during device initialization. */
int rc = usb_pipe_initialize_default_control(
&usb_dev->ctrl_pipe, usb_dev->bus_session);
if (rc != EOK) {
usb_dev_disconnect(usb_dev->bus_session);
*errstr_ptr = "default control pipe initialization";
return rc;
}
/* Retrieve standard descriptors. */
rc = usb_device_retrieve_descriptors(usb_dev);
if (rc != EOK) {
*errstr_ptr = "descriptor retrieval";
usb_dev_disconnect(usb_dev->bus_session);
return rc;
}
/* Create alternate interfaces. We will silently ignore failure.
* We might either control one interface or an entire device,
* it makes no sense to speak about alternate interfaces when
* controlling a device. */
rc = usb_alternate_interfaces_init(&usb_dev->alternate_interfaces,
usb_dev->descriptors.full_config,
usb_dev->descriptors.full_config_size, usb_dev->interface_no);
if (endpoints) {
/* Create and register other pipes than default control (EP 0)*/
rc = usb_device_create_pipes(usb_dev, endpoints);
if (rc != EOK) {
usb_device_fini(usb_dev);
*errstr_ptr = "pipes initialization";
return rc;
}
}
return EOK;
}
/** Wrapper for registering attached device to the hub.
*
* The @p enable_port function is expected to enable signaling on given
* port.
* The argument can have arbitrary meaning and it is not touched at all
* by this function (it is passed as is to the @p enable_port function).
*
* If the @p enable_port fails (i.e. does not return EOK), the device
* addition is canceled.
* The return value is then returned (it is good idea to use different
* error codes than those listed as return codes by this function itself).
*
* The @p connection representing connection with host controller does not
* need to be started.
* This function duplicates the connection to allow simultaneous calls of
* this function (i.e. from different fibrils).
*
* @param[in] parent Parent device (i.e. the hub device).
* @param[in] connection Connection to host controller. Must be non-null.
* @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] arg Any data argument to @p enable_port.
* @param[out] assigned_address USB address of the device.
* @param[in] dev_ops Child device ops. Will use default if not provided.
* @param[in] new_dev_data Arbitrary pointer to be stored in the child
* as @c driver_data. Will allocate and assign usb_hub_attached_device_t
* structure if NULL.
* @param[out] new_fun Storage where pointer to allocated child function
* will be written. Must be non-null.
* @return Error code.
* @retval EINVAL Either connection or new_fun is a NULL pointer.
* @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 *hc_conn, usb_speed_t dev_speed,
int (*enable_port)(void *arg), void *arg, usb_address_t *assigned_address,
ddf_dev_ops_t *dev_ops, void *new_dev_data, ddf_fun_t **new_fun)
{
if ((new_fun == NULL) || (hc_conn == NULL))
return EINVAL;
int rc;
struct timeval start_time;
rc = gettimeofday(&start_time, NULL);
if (rc != EOK) {
return rc;
}
/* We are gona do a lot of communication better open it in advance. */
rc = usb_hc_connection_open(hc_conn);
if (rc != EOK) {
return rc;
}
/* Request a new address. */
usb_address_t dev_addr =
usb_hc_request_address(hc_conn, 0, false, dev_speed);
if (dev_addr < 0) {
rc = EADDRNOTAVAIL;
goto close_connection;
}
/* Initialize connection to device. */
usb_device_connection_t dev_conn;
rc = usb_device_connection_initialize(
&dev_conn, hc_conn, USB_ADDRESS_DEFAULT);
if (rc != EOK) {
rc = ENOTCONN;
goto leave_release_free_address;
}
/* Initialize control pipe on default address. Don't register yet. */
usb_pipe_t ctrl_pipe;
rc = usb_pipe_initialize_default_control(&ctrl_pipe, &dev_conn);
if (rc != EOK) {
rc = ENOTCONN;
goto leave_release_free_address;
}
/*
* The default address request might fail.
* That means that someone else is already using that address.
* We will simply wait and try again.
* (Someone else already wants to add a new device.)
*/
do {
rc = usb_hc_request_address(hc_conn, USB_ADDRESS_DEFAULT,
true, dev_speed);
if (rc == ENOENT) {
/* Do not overheat the CPU ;-). */
async_usleep(DEFAULT_ADDRESS_ATTEMPT_DELAY_USEC);
}
} while (rc == ENOENT);
if (rc < 0) {
goto leave_release_free_address;
}
/* Register control pipe on default address. 0 means no interval. */
rc = usb_pipe_register(&ctrl_pipe, 0);
if (rc != EOK) {
rc = ENOTCONN;
goto leave_release_default_address;
}
struct timeval end_time;
rc = gettimeofday(&end_time, NULL);
if (rc != EOK) {
goto leave_release_default_address;
}
/* According to the USB spec part 9.1.2 host allows 100ms time for
* the insertion process to complete. According to 7.1.7.1 this is the
* time between attach detected and port reset. However, the setup done
* above might use much of this time so we should only wait to fill
* up the 100ms quota*/
const suseconds_t elapsed = tv_sub(&end_time, &start_time);
if (elapsed < 100000) {
async_usleep(100000 - elapsed);
}
/* Endpoint is registered. We can enable the port and change address. */
rc = enable_port(arg);
if (rc != EOK) {
goto leave_release_default_address;
}
/* USB spec 7.1.7.1: The USB System Software guarantees a minimum of
* 10ms for reset recovery. Device response to any bus transactions
* addressed to the default device address during the reset recovery
* time is undefined.
*/
async_usleep(10000);
/* Get max_packet_size value. */
rc = usb_pipe_probe_default_control(&ctrl_pipe);
if (rc != EOK) {
rc = ESTALL;
goto leave_release_default_address;
}
rc = usb_request_set_address(&ctrl_pipe, dev_addr);
if (rc != EOK) {
rc = ESTALL;
goto leave_release_default_address;
}
/* Register the device with devman. */
/* FIXME: create device_register that will get opened ctrl pipe. */
ddf_fun_t *child_fun;
rc = usb_device_register_child_in_devman(&ctrl_pipe,
parent, dev_ops, new_dev_data, &child_fun);
if (rc != EOK) {
goto leave_release_free_address;
}
const usb_hub_attached_device_t new_device = {
.address = dev_addr,
.fun = child_fun,
};
/* Inform the host controller about the handle. */
rc = usb_hub_register_device(hc_conn, &new_device);
if (rc != EOK) {
/* We know nothing about that data. */
if (new_dev_data)
child_fun->driver_data = NULL;
/* The child function is already created. */
ddf_fun_destroy(child_fun);
rc = EDESTADDRREQ;
goto leave_release_free_address;
}
if (assigned_address != NULL) {
*assigned_address = dev_addr;
}
*new_fun = child_fun;
rc = EOK;
goto close_connection;
/*
* Error handling (like nested exceptions) starts here.
* Completely ignoring errors here.
*/
leave_release_default_address:
if (usb_hc_release_address(hc_conn, USB_ADDRESS_DEFAULT) != EOK)
usb_log_warning("%s: Failed to release defaut address.\n",
__FUNCTION__);
leave_release_free_address:
/* This might be either 0:0 or dev_addr:0 */
if (usb_pipe_unregister(&ctrl_pipe) != EOK)
usb_log_warning("%s: Failed to unregister default pipe.\n",
__FUNCTION__);
if (usb_hc_release_address(hc_conn, dev_addr) != EOK)
usb_log_warning("%s: Failed to release address: %d.\n",
__FUNCTION__, dev_addr);
close_connection:
if (usb_hc_connection_close(hc_conn) != EOK)
usb_log_warning("%s: Failed to close hc connection.\n",
__FUNCTION__);
return rc;
}
usbinfo_device_t *prepare_device(const char *name,
devman_handle_t hc_handle, usb_address_t dev_addr)
{
usbinfo_device_t *dev = malloc(sizeof(usbinfo_device_t));
if (dev == NULL) {
fprintf(stderr, NAME ": memory allocation failed.\n");
return NULL;
}
int rc;
bool transfer_started = false;
usb_hc_connection_initialize(&dev->hc_conn, hc_handle);
rc = usb_device_connection_initialize(
&dev->wire, &dev->hc_conn, dev_addr);
if (rc != EOK) {
fprintf(stderr,
NAME ": failed to create connection to device %s: %s.\n",
name, str_error(rc));
goto leave;
}
rc = usb_pipe_initialize_default_control(&dev->ctrl_pipe,
&dev->wire);
if (rc != EOK) {
fprintf(stderr,
NAME ": failed to create default control pipe to %s: %s.\n",
name, str_error(rc));
goto leave;
}
rc = usb_pipe_probe_default_control(&dev->ctrl_pipe);
if (rc != EOK) {
if (rc == ENOENT) {
fprintf(stderr, NAME ": " \
"device %s not present or malfunctioning.\n",
name);
} else {
fprintf(stderr, NAME ": " \
"probing default control pipe of %s failed: %s.\n",
name, str_error(rc));
}
goto leave;
}
usb_pipe_start_long_transfer(&dev->ctrl_pipe);
transfer_started = true;
rc = usb_request_get_device_descriptor(&dev->ctrl_pipe,
&dev->device_descriptor);
if (rc != EOK) {
fprintf(stderr,
NAME ": failed to retrieve device descriptor of %s: %s.\n",
name, str_error(rc));
goto leave;
}
rc = usb_request_get_full_configuration_descriptor_alloc(
&dev->ctrl_pipe, 0, (void **)&dev->full_configuration_descriptor,
&dev->full_configuration_descriptor_size);
if (rc != EOK) {
fprintf(stderr, NAME ": " \
"failed to retrieve configuration descriptor of %s: %s.\n",
name, str_error(rc));
goto leave;
}
return dev;
leave:
if (transfer_started) {
usb_pipe_end_long_transfer(&dev->ctrl_pipe);
}
free(dev);
return NULL;
}
