/** Change address of connected device. * This function automatically updates the backing connection to point to * the new address. It also unregisterrs the old endpoint and registers * a new one. * This creates whole bunch of problems: * 1. All pipes using this wire are broken because they are not * registered for new address * 2. All other pipes for this device are using wrong address, * possibly targeting completely different device * * @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. */ static 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; } assert(pipe); assert(pipe->wire != NULL); const 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; } /* TODO: prevent others from accessing the wire now. */ if (usb_pipe_unregister(pipe) != EOK) { usb_log_warning( "Failed to unregister the old pipe on address change.\n"); } /* Address changed. We can release the old one, thus * allowing other to us it. */ usb_hc_release_address(pipe->wire->hc_connection, pipe->wire->address); /* The address is already changed so set it in the wire */ pipe->wire->address = new_address; rc = usb_pipe_register(pipe, 0); if (rc != EOK) return EADDRNOTAVAIL; return EOK; }
/** Destroy pipes previously created by usb_device_create_pipes. * * @param[in] usb_dev USB device. * */ void usb_device_destroy_pipes(usb_device_t *usb_dev) { assert(usb_dev); assert(usb_dev->pipes || usb_dev->pipes_count == 0); /* Destroy the pipes. */ for (size_t i = 0; i < usb_dev->pipes_count; ++i) { usb_log_debug2("Unregistering pipe %zu: %spresent.\n", i, usb_dev->pipes[i].present ? "" : "not "); if (usb_dev->pipes[i].present) usb_pipe_unregister(&usb_dev->pipes[i].pipe); } free(usb_dev->pipes); usb_dev->pipes = NULL; usb_dev->pipes_count = 0; }
/** 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; }
/** Create pipes for a device. * * This is more or less a wrapper that does following actions: * - allocate and initialize pipes * - map endpoints to the pipes based on the descriptions * - registers endpoints with the host controller * * @param[in] endpoints Endpoints description, NULL terminated. * @param[in] config_descr Configuration descriptor of active configuration. * @param[in] config_descr_size Size of @p config_descr in bytes. * @param[in] interface_no Interface to map from. * @param[in] interface_setting Interface setting (default is usually 0). * @param[out] pipes_ptr Where to store array of created pipes * (not NULL terminated). * @param[out] pipes_count_ptr Where to store number of pipes * (set to NULL if you wish to ignore the count). * @return Error code. */ int usb_device_create_pipes(usb_device_t *usb_dev, const usb_endpoint_description_t **endpoints) { assert(usb_dev); assert(usb_dev->descriptors.full_config); assert(usb_dev->pipes == NULL); assert(usb_dev->pipes_count == 0); size_t pipe_count = count_pipes(endpoints); if (pipe_count == 0) { return EOK; } usb_endpoint_mapping_t *pipes = calloc(pipe_count, sizeof(usb_endpoint_mapping_t)); if (pipes == NULL) { return ENOMEM; } /* Now initialize. */ for (size_t i = 0; i < pipe_count; i++) { pipes[i].description = endpoints[i]; pipes[i].interface_no = usb_dev->interface_no; pipes[i].interface_setting = usb_dev->alternate_interfaces.current; } /* Find the mapping from configuration descriptor. */ int rc = usb_pipe_initialize_from_configuration(pipes, pipe_count, usb_dev->descriptors.full_config, usb_dev->descriptors.full_config_size, usb_dev->bus_session); if (rc != EOK) { free(pipes); return rc; } /* Register created pipes. */ for (size_t i = 0; i < pipe_count; i++) { if (pipes[i].present) { rc = usb_pipe_register(&pipes[i].pipe, pipes[i].descriptor->poll_interval); if (rc != EOK) { goto rollback_unregister_endpoints; } } } usb_dev->pipes = pipes; usb_dev->pipes_count = pipe_count; return EOK; /* * Jump here if something went wrong after endpoints have * been registered. * This is also the target when the registration of * endpoints fails. */ rollback_unregister_endpoints: for (size_t i = 0; i < pipe_count; i++) { if (pipes[i].present) { usb_pipe_unregister(&pipes[i].pipe); } } free(pipes); return rc; }