Changes in / [151293d:4166fb1] in mainline

Files:

• HelenOS.config (modified) (2 diffs)
• uspace/drv/usbhid/generic/hiddev.c (modified) (2 diffs)
• uspace/drv/usbhid/kbd/kbddev.c (modified) (1 diff)
• uspace/drv/usbhid/multimedia/multimedia.c (modified) (1 diff)
• uspace/drv/usbhub/ports.c (modified) (6 diffs)
• uspace/drv/usbhub/usbhub.c (modified) (4 diffs)
• uspace/drv/usbhub/usbhub.h (modified) (2 diffs)
• uspace/lib/drv/generic/driver.c (modified) (1 diff)

HelenOS.config

@@ -570 +570 @@
 
 % USB release build (less logging)
-! CONFIG_USB_RELEASE_BUILD (n/y)
+! CONFIG_USB_RELEASE_BUILD (y/n)
 
 % Start virtual USB host controller
@@ -576 +576 @@
 
 % Polling UHCI & OHCI (no interrupts)
-! [PLATFORM=ia32|PLATFORM=amd64] CONFIG_USBHC_NO_INTERRUPTS (y/n)
+! [PLATFORM=ia32|PLATFORM=amd64] CONFIG_USBHC_NO_INTERRUPTS (n/y)
 
 % Run devman in kconsole (not recommended)

uspace/drv/usbhid/generic/hiddev.c

@@ -99 +99 @@
         usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
         
-        usb_log_debug2("hid_dev: %p, Max input report size (%d).\n",
+        usb_log_debug2("hid_dev: %p, Max input report size (%zu).\n",
             hid_dev, hid_dev->max_input_report_size);
         
@@ -226 +226 @@
         }
         
-        usb_log_debug("HID function created. Handle: %d\n", fun->handle);
+        usb_log_debug("HID function created. Handle: %" PRIun "\n", fun->handle);
         
         return EOK;

uspace/drv/usbhid/kbd/kbddev.c

@@ -798 +798 @@
         }
         
-        usb_log_debug("%s function created. Handle: %d\n", HID_KBD_FUN_NAME,
-            fun->handle);
+        usb_log_debug("%s function created. Handle: %" PRIun "\n",
+            HID_KBD_FUN_NAME, fun->handle);
         
         usb_log_debug("Adding DDF function to class %s...\n", 

uspace/drv/usbhid/multimedia/multimedia.c

@@ -211 +211 @@
         }
         
-        usb_log_debug("%s function created. Handle: %d\n", NAME, fun->handle);
+        usb_log_debug("%s function created (jandle: %" PRIun ").\n",
+            NAME, fun->handle);
         
         rc = ddf_fun_add_to_class(fun, "keyboard");

uspace/drv/usbhub/ports.c

@@ -202 +202 @@
 
         //close address
-        if(hub->ports[port].attached_device.address >= 0){
-                /*uncomment this code to use it when DDF allows device removal
-                opResult = usb_hc_unregister_device(
-                        &hub->connection,
-                        hub->attached_devs[port].address);
-                if(opResult != EOK) {
-                        dprintf(USB_LOG_LEVEL_WARNING, "could not release "
-                                "address of "
-                            "removed device: %d", opResult);
-                }
-                hub->attached_devs[port].address = 0;
-                hub->attached_devs[port].handle = 0;
-                 */
+
+        usb_hub_port_t *the_port = hub->ports + port;
+
+        fibril_mutex_lock(&hub->port_mutex);
+
+        if (the_port->attached_device.address >= 0) {
+                usb_log_warning("Device unplug on `%s' (port %zu): " \
+                    "not implemented.\n", hub->usb_device->ddf_dev->name,
+                    (size_t) port);
+                the_port->attached_device.address = -1;
+                the_port->attached_device.handle = 0;
         } else {
                 usb_log_warning("Device removed before being registered.\n");
@@ -223 +221 @@
                  * port reset callback from new device wrapper.
                  */
-                usb_hub_port_t *the_port = hub->ports + port;
                 fibril_mutex_lock(&the_port->reset_mutex);
                 the_port->reset_completed = true;
@@ -230 +227 @@
                 fibril_mutex_unlock(&the_port->reset_mutex);
         }
+
+        fibril_mutex_unlock(&hub->port_mutex);
 }
 
@@ -396 +395 @@
         }
 
+        fibril_mutex_lock(&data->hub->port_mutex);
         data->hub->ports[data->port].attached_device.handle = child_handle;
         data->hub->ports[data->port].attached_device.address = new_address;
+        fibril_mutex_unlock(&data->hub->port_mutex);
 
         usb_log_info("Detected new device on `%s' (port %zu), "
@@ -406 +407 @@
 leave:
         free(arg);
+
+        fibril_mutex_lock(&data->hub->pending_ops_mutex);
+        assert(data->hub->pending_ops_count > 0);
+        data->hub->pending_ops_count--;
+        fibril_condvar_signal(&data->hub->pending_ops_cv);
+        fibril_mutex_unlock(&data->hub->pending_ops_mutex);
+
 
         return EOK;
@@ -452 +460 @@
                 return ENOMEM;
         }
+        fibril_mutex_lock(&hub->pending_ops_mutex);
+        hub->pending_ops_count++;
+        fibril_mutex_unlock(&hub->pending_ops_mutex);
         fibril_add_ready(fibril);
 

uspace/drv/usbhub/usbhub.c

@@ -72 +72 @@
 static void usb_hub_process_global_interrupt(usb_hub_info_t * hub_info);
 
-static void usb_hub_polling_terminted_callback(usb_device_t * device,
+static void usb_hub_polling_terminated_callback(usb_device_t * device,
     bool was_error, void * data);
 
@@ -200 +200 @@
         result->control_pipe = &usb_dev->ctrl_pipe;
         result->is_default_address_used = false;
+
+        result->ports = NULL;
+        result->port_count = (size_t) -1;
+        fibril_mutex_initialize(&result->port_mutex);
+
+        fibril_mutex_initialize(&result->pending_ops_mutex);
+        fibril_condvar_initialize(&result->pending_ops_cv);
+        result->pending_ops_count = 0;
         return result;
 }
@@ -340 +348 @@
         rc = usb_device_auto_poll(hub_info->usb_device, 0,
             hub_port_changes_callback, ((hub_info->port_count + 1) / 8) + 1,
-            usb_hub_polling_terminted_callback, hub_info);
+            usb_hub_polling_terminated_callback, hub_info);
         if (rc != EOK) {
                 usb_log_error("Failed to create polling fibril: %s.\n",
@@ -473 +481 @@
  * @param data pointer to usb_hub_info_t structure
  */
-static void usb_hub_polling_terminted_callback(usb_device_t * device,
+static void usb_hub_polling_terminated_callback(usb_device_t * device,
     bool was_error, void * data){
-        usb_hub_info_t * hub_info = data;
-        if(!hub_info) return;
-        free(hub_info->ports);
-        free(hub_info);
+        usb_hub_info_t * hub = data;
+        assert(hub);
+
+        fibril_mutex_lock(&hub->pending_ops_mutex);
+
+        /* The device is dead. However there might be some pending operations
+         * that we need to wait for.
+         * One of them is device adding in progress.
+         * The respective fibril is probably waiting for status change
+         * in port reset (port enable) callback.
+         * Such change would never come (otherwise we would not be here).
+         * Thus, we would flush all pending port resets.
+         */
+        if (hub->pending_ops_count > 0) {
+                fibril_mutex_lock(&hub->port_mutex);
+                size_t port;
+                for (port = 0; port < hub->port_count; port++) {
+                        usb_hub_port_t *the_port = hub->ports + port;
+                        fibril_mutex_lock(&the_port->reset_mutex);
+                        the_port->reset_completed = true;
+                        the_port->reset_okay = false;
+                        fibril_condvar_broadcast(&the_port->reset_cv);
+                        fibril_mutex_unlock(&the_port->reset_mutex);
+                }
+                fibril_mutex_unlock(&hub->port_mutex);
+        }
+        /* And now wait for them. */
+        while (hub->pending_ops_count > 0) {
+                fibril_condvar_wait(&hub->pending_ops_cv,
+                    &hub->pending_ops_mutex);
+        }
+        fibril_mutex_unlock(&hub->pending_ops_mutex);
+
+        free(hub->ports);
+        free(hub);
 }
 

uspace/drv/usbhub/usbhub.h

@@ -61 +61 @@
         usb_hub_port_t *ports;
 
+        fibril_mutex_t port_mutex;
+
         /** connection to hcd */
         usb_hc_connection_t connection;
@@ -89 +91 @@
         /** generic usb device data*/
         usb_device_t * usb_device;
+
+        /** Number of pending operations on the mutex to prevent shooting
+         * ourselves in the foot.
+         * When the hub is disconnected but we are in the middle of some
+         * operation, we cannot destroy this structure right away because
+         * the pending operation might use it.
+         */
+        size_t pending_ops_count;
+        /** Guard for pending_ops_count. */
+        fibril_mutex_t pending_ops_mutex;
+        /** Condition variable for pending_ops_count. */
+        fibril_condvar_t pending_ops_cv;
+
 };
 

uspace/lib/drv/generic/driver.c

@@ -405 +405 @@
                                 /* The interface has not such method */
                                 printf("%s: driver_connection_gen error - "
-                                    "invalid interface method (%d).\n",
+                                    "invalid interface method "
+                                    "(index %" PRIun ").\n",
                                     driver->name, iface_method_idx);
                                 async_answer_0(callid, ENOTSUP);