Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/usbdev/src/hub.c

    r2179cf95 r79ae36dd  
    3737#include <usb/dev/request.h>
    3838#include <usb/dev/recognise.h>
    39 #include <usb/debug.h>
    4039#include <usbhc_iface.h>
    4140#include <errno.h>
     
    5857                assert((conn)); \
    5958                if (!usb_hc_connection_is_opened((conn))) { \
    60                         usb_log_error("Connection not open.\n"); \
    61                         return ENOTCONN; \
     59                        return ENOENT; \
    6260                } \
    6361        } while (false)
     
    6664 *
    6765 * @param connection Opened connection to host controller.
    68  * @param preferred Preferred SUB address.
    69  * @param strict Fail if the preferred address is not avialable.
    7066 * @param speed Speed of the new device (device that will be assigned
    7167 *    the returned address).
     
    7369 */
    7470usb_address_t usb_hc_request_address(usb_hc_connection_t *connection,
    75     usb_address_t preferred, bool strict, usb_speed_t speed)
     71    usb_speed_t speed)
    7672{
    7773        CHECK_CONNECTION(connection);
     
    8076       
    8177        sysarg_t address;
    82         int rc = async_req_4_1(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
    83             IPC_M_USBHC_REQUEST_ADDRESS, preferred, strict, speed, &address);
     78        int rc = async_req_2_1(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
     79            IPC_M_USBHC_REQUEST_ADDRESS, speed,
     80            &address);
    8481       
    8582        async_exchange_end(exch);
     
    9895 */
    9996int usb_hc_register_device(usb_hc_connection_t * connection,
    100     const usb_hub_attached_device_t *attached_device)
     97    const usb_hc_attached_device_t *attached_device)
    10198{
    10299        CHECK_CONNECTION(connection);
     
    108105        int rc = async_req_3_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
    109106            IPC_M_USBHC_BIND_ADDRESS,
    110             attached_device->address, attached_device->fun->handle);
     107            attached_device->address, attached_device->handle);
    111108        async_exchange_end(exch);
    112109       
     
    133130}
    134131
    135 /** Change address of connected device.
    136  * This function automatically updates the backing connection to point to
    137  * the new address. It also unregisterrs the old endpoint and registers
    138  * a new one.
    139  * This creates whole bunch of problems:
    140  *  1. All pipes using this wire are broken because they are not
    141  *     registered for new address
    142  *  2. All other pipes for this device are using wrong address,
    143  *     possibly targeting completely different device
    144  *
    145  * @param pipe Control endpoint pipe (session must be already started).
    146  * @param new_address New USB address to be set (in native endianness).
    147  * @return Error code.
    148  */
    149 static int usb_request_set_address(usb_pipe_t *pipe, usb_address_t new_address,
    150     usb_hc_connection_t *hc_conn)
    151 {
    152         if ((new_address < 0) || (new_address >= USB11_ADDRESS_MAX)) {
    153                 return EINVAL;
    154         }
    155         assert(pipe);
    156         assert(hc_conn);
    157         assert(pipe->wire != NULL);
    158 
    159         const uint16_t addr = uint16_host2usb((uint16_t)new_address);
    160 
    161         int rc = usb_control_request_set(pipe,
    162             USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
    163             USB_DEVREQ_SET_ADDRESS, addr, 0, NULL, 0);
    164 
    165         if (rc != EOK) {
    166                 return rc;
    167         }
    168 
    169         /* TODO: prevent others from accessing the wire now. */
    170         if (usb_pipe_unregister(pipe, hc_conn) != EOK) {
    171                 usb_log_warning(
    172                     "Failed to unregister the old pipe on address change.\n");
    173         }
    174         /* The address is already changed so set it in the wire */
    175         pipe->wire->address = new_address;
    176         rc = usb_pipe_register(pipe, 0, hc_conn);
    177         if (rc != EOK)
    178                 return EADDRNOTAVAIL;
    179 
    180         return EOK;
     132
     133static void unregister_control_endpoint_on_default_address(
     134    usb_hc_connection_t *connection)
     135{
     136        usb_device_connection_t dev_conn;
     137        int rc = usb_device_connection_initialize_on_default_address(&dev_conn,
     138            connection);
     139        if (rc != EOK) {
     140                return;
     141        }
     142
     143        usb_pipe_t ctrl_pipe;
     144        rc = usb_pipe_initialize_default_control(&ctrl_pipe, &dev_conn);
     145        if (rc != EOK) {
     146                return;
     147        }
     148
     149        usb_pipe_unregister(&ctrl_pipe, connection);
    181150}
    182151
     
    186155 * The @p enable_port function is expected to enable signaling on given
    187156 * port.
    188  * The argument can have arbitrary meaning and it is not touched at all
    189  * by this function (it is passed as is to the @p enable_port function).
     157 * The two arguments to it can have arbitrary meaning
     158 * (the @p port_no is only a suggestion)
     159 * and are not touched at all by this function
     160 * (they are passed as is to the @p enable_port function).
    190161 *
    191162 * If the @p enable_port fails (i.e. does not return EOK), the device
     
    200171 *
    201172 * @param[in] parent Parent device (i.e. the hub device).
    202  * @param[in] connection Connection to host controller. Must be non-null.
     173 * @param[in] connection Connection to host controller.
    203174 * @param[in] dev_speed New device speed.
    204175 * @param[in] enable_port Function for enabling signaling through the port the
    205176 *      device is attached to.
     177 * @param[in] port_no Port number (passed through to @p enable_port).
    206178 * @param[in] arg Any data argument to @p enable_port.
    207179 * @param[out] assigned_address USB address of the device.
    208  * @param[in] dev_ops Child device ops. Will use default if not provided.
     180 * @param[out] assigned_handle Devman handle of the new device.
     181 * @param[in] dev_ops Child device ops.
    209182 * @param[in] new_dev_data Arbitrary pointer to be stored in the child
    210  *      as @c driver_data. Will allocate and assign usb_hub_attached_device_t
    211  *      structure if NULL.
     183 *      as @c driver_data.
    212184 * @param[out] new_fun Storage where pointer to allocated child function
    213  *      will be written. Must be non-null.
     185 *      will be written.
    214186 * @return Error code.
    215  * @retval EINVAL Either connection or new_fun is a NULL pointer.
    216187 * @retval ENOENT Connection to HC not opened.
    217188 * @retval EADDRNOTAVAIL Failed retrieving free address from host controller.
     
    223194int usb_hc_new_device_wrapper(ddf_dev_t *parent, usb_hc_connection_t *connection,
    224195    usb_speed_t dev_speed,
    225     int (*enable_port)(void *arg), void *arg, usb_address_t *assigned_address,
     196    int (*enable_port)(int port_no, void *arg), int port_no, void *arg,
     197    usb_address_t *assigned_address, devman_handle_t *assigned_handle,
    226198    ddf_dev_ops_t *dev_ops, void *new_dev_data, ddf_fun_t **new_fun)
    227199{
    228         if (new_fun == NULL || connection == NULL)
    229                 return EINVAL;
    230 
     200        assert(connection != NULL);
    231201        // FIXME: this is awful, we are accessing directly the structure.
    232         // TODO: Why not use provided connection?
    233202        usb_hc_connection_t hc_conn = {
    234203                .hc_handle = connection->hc_handle,
     
    249218        }
    250219
     220
    251221        /*
    252222         * Request new address.
    253223         */
    254         usb_address_t dev_addr =
    255             usb_hc_request_address(&hc_conn, 0, false, dev_speed);
     224        usb_address_t dev_addr = usb_hc_request_address(&hc_conn, dev_speed);
    256225        if (dev_addr < 0) {
    257                 rc = EADDRNOTAVAIL;
    258                 goto close_connection;
     226                usb_hc_connection_close(&hc_conn);
     227                return EADDRNOTAVAIL;
    259228        }
    260229
     
    274243
    275244        usb_pipe_t ctrl_pipe;
    276         rc = usb_pipe_initialize_default_control(&ctrl_pipe, &dev_conn);
     245        rc = usb_pipe_initialize_default_control(&ctrl_pipe,
     246            &dev_conn);
    277247        if (rc != EOK) {
    278248                rc = ENOTCONN;
     
    281251
    282252        do {
    283                 rc = usb_hc_request_address(&hc_conn, USB_ADDRESS_DEFAULT,
    284                     true, dev_speed);
    285                 if (rc == ENOENT) {
     253                rc = usb_pipe_register_with_speed(&ctrl_pipe, dev_speed, 0,
     254                    &hc_conn);
     255                if (rc != EOK) {
    286256                        /* Do not overheat the CPU ;-). */
    287257                        async_usleep(ENDPOINT_0_0_REGISTER_ATTEMPT_DELAY_USEC);
    288258                }
    289         } while (rc == ENOENT);
    290         if (rc < 0) {
    291                 goto leave_release_free_address;
    292         }
    293 
    294         /* Register control pipe on default address. */
    295         rc = usb_pipe_register(&ctrl_pipe, 0, &hc_conn);
    296         if (rc != EOK) {
    297                 rc = ENOTCONN;
    298                 goto leave_release_default_address;
    299         }
    300 
     259        } while (rc != EOK);
    301260        struct timeval end_time;
    302261
     
    311270         * above might use much of this time so we should only wait to fill
    312271         * up the 100ms quota*/
    313         const suseconds_t elapsed = tv_sub(&end_time, &start_time);
     272        suseconds_t elapsed = tv_sub(&end_time, &start_time);
    314273        if (elapsed < 100000) {
    315274                async_usleep(100000 - elapsed);
    316275        }
    317276
    318         /* Endpoint is registered. We can enable the port and change address. */
    319         rc = enable_port(arg);
     277        /*
     278         * Endpoint is registered. We can enable the port and change
     279         * device address.
     280         */
     281        rc = enable_port(port_no, arg);
    320282        if (rc != EOK) {
    321283                goto leave_release_default_address;
     
    328290        async_usleep(10000);
    329291
    330         /* Get max_packet_size value. */
    331292        rc = usb_pipe_probe_default_control(&ctrl_pipe);
    332293        if (rc != EOK) {
     
    335296        }
    336297
    337         rc = usb_request_set_address(&ctrl_pipe, dev_addr, &hc_conn);
     298        rc = usb_request_set_address(&ctrl_pipe, dev_addr);
    338299        if (rc != EOK) {
    339300                rc = ESTALL;
     
    341302        }
    342303
    343         /* Address changed. We can release the default, thus
    344          * allowing other to access the default address. */
    345         usb_hc_unregister_device(&hc_conn, USB_ADDRESS_DEFAULT);
    346 
    347         /* Register the device with devman. */
     304        /*
     305         * Address changed. We can release the original endpoint, thus
     306         * allowing other to access the default address.
     307         */
     308        unregister_control_endpoint_on_default_address(&hc_conn);
     309
     310        /*
     311         * Time to register the new endpoint.
     312         */
     313        rc = usb_pipe_register(&ctrl_pipe, 0, &hc_conn);
     314        if (rc != EOK) {
     315                goto leave_release_free_address;
     316        }
     317
     318        /*
     319         * It is time to register the device with devman.
     320         */
    348321        /* FIXME: create device_register that will get opened ctrl pipe. */
    349         ddf_fun_t *child_fun;
    350         rc = usb_device_register_child_in_devman(&ctrl_pipe,
    351             parent, dev_ops, new_dev_data, &child_fun);
    352         if (rc != EOK) {
    353                 goto leave_release_free_address;
    354         }
    355 
    356         const usb_hub_attached_device_t new_device = {
     322        devman_handle_t child_handle;
     323        rc = usb_device_register_child_in_devman(dev_addr, dev_conn.hc_handle,
     324            parent, &child_handle,
     325            dev_ops, new_dev_data, new_fun);
     326        if (rc != EOK) {
     327                rc = ESTALL;
     328                goto leave_release_free_address;
     329        }
     330
     331        /*
     332         * And now inform the host controller about the handle.
     333         */
     334        usb_hc_attached_device_t new_device = {
    357335                .address = dev_addr,
    358                 .fun = child_fun,
     336                .handle = child_handle
    359337        };
    360 
    361 
    362         /* Inform the host controller about the handle. */
    363338        rc = usb_hc_register_device(&hc_conn, &new_device);
    364339        if (rc != EOK) {
    365                 /* We know nothing about that data. */
    366                 if (new_dev_data)
    367                         child_fun->driver_data = NULL;
    368                 /* The child function is already created. */
    369                 ddf_fun_destroy(child_fun);
    370340                rc = EDESTADDRREQ;
    371341                goto leave_release_free_address;
    372342        }
    373 
     343       
     344        usb_hc_connection_close(&hc_conn);
     345
     346        /*
     347         * And we are done.
     348         */
    374349        if (assigned_address != NULL) {
    375350                *assigned_address = dev_addr;
    376351        }
    377 
    378         *new_fun = child_fun;
    379 
    380         rc = EOK;
    381         goto close_connection;
     352        if (assigned_handle != NULL) {
     353                *assigned_handle = child_handle;
     354        }
     355
     356        return EOK;
     357
     358
    382359
    383360        /*
     
    386363         */
    387364leave_release_default_address:
    388         usb_hc_unregister_device(&hc_conn, USB_ADDRESS_DEFAULT);
     365        usb_pipe_unregister(&ctrl_pipe, &hc_conn);
    389366
    390367leave_release_free_address:
    391         /* This might be either 0:0 or dev_addr:0 */
    392         if (usb_pipe_unregister(&ctrl_pipe, &hc_conn) != EOK)
    393                 usb_log_warning("%s: Failed to unregister default pipe.\n",
    394                     __FUNCTION__);
    395 
    396         if (usb_hc_unregister_device(&hc_conn, dev_addr) != EOK)
    397                 usb_log_warning("%s: Failed to unregister device.\n",
    398                     __FUNCTION__);
    399 
    400 close_connection:
    401         if (usb_hc_connection_close(&hc_conn) != EOK)
    402                 usb_log_warning("%s: Failed to close hc connection.\n",
    403                     __FUNCTION__);
     368        usb_hc_unregister_device(&hc_conn, dev_addr);
     369
     370        usb_hc_connection_close(&hc_conn);
    404371
    405372        return rc;
Note: See TracChangeset for help on using the changeset viewer.