Changes in uspace/lib/usbdev/include/usb/dev/pipes.h [bdb23c63:b77931d] in mainline

File:

• uspace/lib/usbdev/include/usb/dev/pipes.h (modified) (5 diffs)

uspace/lib/usbdev/include/usb/dev/pipes.h

@@ -26 +26 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
+
 /** @addtogroup libusbdev
  * @{
@@ -36 +37 @@
 
 #include <sys/types.h>
+#include <usb/usb.h>
+#include <usb/hc.h>
+#include <usb/descriptor.h>
 #include <ipc/devman.h>
 #include <ddf/driver.h>
 #include <fibril_synch.h>
-#include <usb/usb.h>
-#include <usb/descriptor.h>
-#include <usb/dev/usb_device_connection.h>
+#include <async.h>
 
-#define CTRL_PIPE_MIN_PACKET_SIZE 8
+/** Abstraction of a physical connection to the device.
+ * This type is an abstraction of the USB wire that connects the host and
+ * the function (device).
+ */
+typedef struct {
+        /** Handle of the host controller device is connected to. */
+        devman_handle_t hc_handle;
+        /** Address of the device. */
+        usb_address_t address;
+} usb_device_connection_t;
+
 /** Abstraction of a logical connection to USB device endpoint.
- * It encapsulates endpoint attributes (transfer type etc.).
+ * It encapsulates endpoint attributes (transfer type etc.) as well
+ * as information about currently running sessions.
  * This endpoint must be bound with existing usb_device_connection_t
  * (i.e. the wire to send data over).
+ *
+ * Locking order: if you want to lock both mutexes
+ * (@c guard and @c hc_sess_mutex), lock @c guard first.
+ * It is not necessary to lock @c guard if you want to lock @c hc_sess_mutex
+ * only.
  */
 typedef struct {
+        /** Guard of the whole pipe. */
+        fibril_mutex_t guard;
+
         /** The connection used for sending the data. */
         usb_device_connection_t *wire;
@@ -65 +86 @@
         size_t max_packet_size;
 
+        /** Session to the host controller.
+         * NULL when no session is active.
+         * It is an error to access this member without @c hc_sess_mutex
+         * being locked.
+         * If call over the phone is to be made, it must be preceeded by
+         * call to pipe_add_ref() [internal libusb function].
+         */
+        async_sess_t *hc_sess;
+
+        /** Guard for serialization of requests over the session. */
+        fibril_mutex_t hc_sess_mutex;
+
+        /** Number of active transfers over the pipe. */
+        int refcount;
+        /** Number of failed attempts to open the HC phone.
+         * When user requests usb_pipe_start_long_transfer() and the operation
+         * fails, there is no way to report this to the user.
+         * That the soft reference counter is increased to record the attempt.
+         * When the user then request e.g. usb_pipe_read(), it will try to
+         * add reference as well.
+         * If that fails, it is reported to the user. If it is okay, the
+         * real reference counter is incremented.
+         * The problem might arise when ending the long transfer (since
+         * the number of references would be only 1, but logically it shall be
+         * two).
+         * Decrementing the soft counter first shall solve this.
+         */
+        int refcount_soft;
+
         /** Whether to automatically reset halt on the endpoint.
          * Valid only for control endpoint zero.
@@ -70 +120 @@
         bool auto_reset_halt;
 } usb_pipe_t;
+
 
 /** Description of endpoint characteristics. */
@@ -105 +156 @@
 } usb_endpoint_mapping_t;
 
+int usb_device_connection_initialize_on_default_address(
+    usb_device_connection_t *, usb_hc_connection_t *);
+int usb_device_connection_initialize_from_device(usb_device_connection_t *,
+    const ddf_dev_t *);
+int usb_device_connection_initialize(usb_device_connection_t *,
+    devman_handle_t, usb_address_t);
+
+int usb_device_get_assigned_interface(const ddf_dev_t *);
+
 int usb_pipe_initialize(usb_pipe_t *, usb_device_connection_t *,
     usb_endpoint_t, usb_transfer_type_t, size_t, usb_direction_t);
 int usb_pipe_initialize_default_control(usb_pipe_t *,
     usb_device_connection_t *);
-
 int usb_pipe_probe_default_control(usb_pipe_t *);
 int usb_pipe_initialize_from_configuration(usb_endpoint_mapping_t *,
     size_t, const uint8_t *, size_t, usb_device_connection_t *);
+int usb_pipe_register(usb_pipe_t *, unsigned int, usb_hc_connection_t *);
+int usb_pipe_unregister(usb_pipe_t *, usb_hc_connection_t *);
 
-int usb_pipe_register(usb_pipe_t *, unsigned);
-int usb_pipe_unregister(usb_pipe_t *);
-
-int usb_pipe_start_long_transfer(usb_pipe_t *);
-int usb_pipe_end_long_transfer(usb_pipe_t *);
+void usb_pipe_start_long_transfer(usb_pipe_t *);
+void usb_pipe_end_long_transfer(usb_pipe_t *);
 
 int usb_pipe_read(usb_pipe_t *, void *, size_t, size_t *);
-int usb_pipe_write(usb_pipe_t *, const void *, size_t);
+int usb_pipe_write(usb_pipe_t *, void *, size_t);
 
 int usb_pipe_control_read(usb_pipe_t *, const void *, size_t,