Changes in uspace/lib/usbdev/src/hub.c [2179cf95:79ae36dd] in mainline
- File:
-
- 1 edited
-
uspace/lib/usbdev/src/hub.c (modified) (19 diffs)
Legend:
- Unmodified
- Added
- Removed
-
uspace/lib/usbdev/src/hub.c
r2179cf95 r79ae36dd 37 37 #include <usb/dev/request.h> 38 38 #include <usb/dev/recognise.h> 39 #include <usb/debug.h>40 39 #include <usbhc_iface.h> 41 40 #include <errno.h> … … 58 57 assert((conn)); \ 59 58 if (!usb_hc_connection_is_opened((conn))) { \ 60 usb_log_error("Connection not open.\n"); \ 61 return ENOTCONN; \ 59 return ENOENT; \ 62 60 } \ 63 61 } while (false) … … 66 64 * 67 65 * @param connection Opened connection to host controller. 68 * @param preferred Preferred SUB address.69 * @param strict Fail if the preferred address is not avialable.70 66 * @param speed Speed of the new device (device that will be assigned 71 67 * the returned address). … … 73 69 */ 74 70 usb_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) 76 72 { 77 73 CHECK_CONNECTION(connection); … … 80 76 81 77 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); 84 81 85 82 async_exchange_end(exch); … … 98 95 */ 99 96 int usb_hc_register_device(usb_hc_connection_t * connection, 100 const usb_h ub_attached_device_t *attached_device)97 const usb_hc_attached_device_t *attached_device) 101 98 { 102 99 CHECK_CONNECTION(connection); … … 108 105 int rc = async_req_3_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE), 109 106 IPC_M_USBHC_BIND_ADDRESS, 110 attached_device->address, attached_device-> fun->handle);107 attached_device->address, attached_device->handle); 111 108 async_exchange_end(exch); 112 109 … … 133 130 } 134 131 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 133 static 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); 181 150 } 182 151 … … 186 155 * The @p enable_port function is expected to enable signaling on given 187 156 * 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). 190 161 * 191 162 * If the @p enable_port fails (i.e. does not return EOK), the device … … 200 171 * 201 172 * @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. 203 174 * @param[in] dev_speed New device speed. 204 175 * @param[in] enable_port Function for enabling signaling through the port the 205 176 * device is attached to. 177 * @param[in] port_no Port number (passed through to @p enable_port). 206 178 * @param[in] arg Any data argument to @p enable_port. 207 179 * @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. 209 182 * @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. 212 184 * @param[out] new_fun Storage where pointer to allocated child function 213 * will be written. Must be non-null.185 * will be written. 214 186 * @return Error code. 215 * @retval EINVAL Either connection or new_fun is a NULL pointer.216 187 * @retval ENOENT Connection to HC not opened. 217 188 * @retval EADDRNOTAVAIL Failed retrieving free address from host controller. … … 223 194 int usb_hc_new_device_wrapper(ddf_dev_t *parent, usb_hc_connection_t *connection, 224 195 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, 226 198 ddf_dev_ops_t *dev_ops, void *new_dev_data, ddf_fun_t **new_fun) 227 199 { 228 if (new_fun == NULL || connection == NULL) 229 return EINVAL; 230 200 assert(connection != NULL); 231 201 // FIXME: this is awful, we are accessing directly the structure. 232 // TODO: Why not use provided connection?233 202 usb_hc_connection_t hc_conn = { 234 203 .hc_handle = connection->hc_handle, … … 249 218 } 250 219 220 251 221 /* 252 222 * Request new address. 253 223 */ 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); 256 225 if (dev_addr < 0) { 257 rc = EADDRNOTAVAIL;258 goto close_connection;226 usb_hc_connection_close(&hc_conn); 227 return EADDRNOTAVAIL; 259 228 } 260 229 … … 274 243 275 244 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); 277 247 if (rc != EOK) { 278 248 rc = ENOTCONN; … … 281 251 282 252 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) { 286 256 /* Do not overheat the CPU ;-). */ 287 257 async_usleep(ENDPOINT_0_0_REGISTER_ATTEMPT_DELAY_USEC); 288 258 } 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); 301 260 struct timeval end_time; 302 261 … … 311 270 * above might use much of this time so we should only wait to fill 312 271 * up the 100ms quota*/ 313 constsuseconds_t elapsed = tv_sub(&end_time, &start_time);272 suseconds_t elapsed = tv_sub(&end_time, &start_time); 314 273 if (elapsed < 100000) { 315 274 async_usleep(100000 - elapsed); 316 275 } 317 276 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); 320 282 if (rc != EOK) { 321 283 goto leave_release_default_address; … … 328 290 async_usleep(10000); 329 291 330 /* Get max_packet_size value. */331 292 rc = usb_pipe_probe_default_control(&ctrl_pipe); 332 293 if (rc != EOK) { … … 335 296 } 336 297 337 rc = usb_request_set_address(&ctrl_pipe, dev_addr , &hc_conn);298 rc = usb_request_set_address(&ctrl_pipe, dev_addr); 338 299 if (rc != EOK) { 339 300 rc = ESTALL; … … 341 302 } 342 303 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 */ 348 321 /* 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 = { 357 335 .address = dev_addr, 358 . fun = child_fun,336 .handle = child_handle 359 337 }; 360 361 362 /* Inform the host controller about the handle. */363 338 rc = usb_hc_register_device(&hc_conn, &new_device); 364 339 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);370 340 rc = EDESTADDRREQ; 371 341 goto leave_release_free_address; 372 342 } 373 343 344 usb_hc_connection_close(&hc_conn); 345 346 /* 347 * And we are done. 348 */ 374 349 if (assigned_address != NULL) { 375 350 *assigned_address = dev_addr; 376 351 } 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 382 359 383 360 /* … … 386 363 */ 387 364 leave_release_default_address: 388 usb_ hc_unregister_device(&hc_conn, USB_ADDRESS_DEFAULT);365 usb_pipe_unregister(&ctrl_pipe, &hc_conn); 389 366 390 367 leave_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); 404 371 405 372 return rc;
Note:
See TracChangeset
for help on using the changeset viewer.
