Changeset 03f7952 in mainline

Timestamp:

2011-03-04T21:59:20Z (13 years ago)

Author:

Vojtech Horky <vojtechhorky@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

80fdffe, f43c4d2, f5246b6

Parents:

4e900c1 (diff), ff4185e6 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Small improvements

USB mouse stops polling after first failed transmission
(dirty hack for unplug).

Added function for dumping buffers (usb_debug_str_buffer).

Location:

uspace

Files:

• drv/usbmouse/main.c (modified) (1 diff)
• drv/usbmouse/mouse.c (modified) (3 diffs)
• lib/usb/include/usb/debug.h (modified) (1 diff)
• lib/usb/src/debug.c (modified) (1 diff)

uspace/drv/usbmouse/main.c

@@ -74 +74 @@
 int main(int argc, char *argv[])
 {
-        usb_log_enable(USB_LOG_LEVEL_DEBUG, NAME);
+        usb_log_enable(USB_LOG_LEVEL_DEBUG2, NAME);
 
         return ddf_driver_main(&mouse_driver);

uspace/drv/usbmouse/mouse.c

@@ -37 +37 @@
 #include <usb/debug.h>
 #include <errno.h>
+#include <str_error.h>
 #include <ipc/mouse.h>
 
@@ -64 +65 @@
 
                 size_t actual_size;
+                int rc;
 
-                /* FIXME: check for errors. */
-                usb_endpoint_pipe_start_session(&mouse->poll_pipe);
+                /*
+                 * Error checking note:
+                 * - failure when starting a session is considered
+                 *   temporary (e.g. out of phones, next try might succeed)
+                 * - failure of transfer considered fatal (probably the
+                 *   device was unplugged)
+                 * - session closing not checked (shall not fail anyway)
+                 */
 
-                usb_endpoint_pipe_read(&mouse->poll_pipe,
+                rc = usb_endpoint_pipe_start_session(&mouse->poll_pipe);
+                if (rc != EOK) {
+                        usb_log_warning("Failed to start session, will try again: %s.\n",
+                            str_error(rc));
+                        continue;
+                }
+
+                rc = usb_endpoint_pipe_read(&mouse->poll_pipe,
                     buffer, buffer_size, &actual_size);
 
                 usb_endpoint_pipe_end_session(&mouse->poll_pipe);
+
+                if (rc != EOK) {
+                        usb_log_error("Failed reading mouse input: %s.\n",
+                            str_error(rc));
+                        break;
+                }
+
+                usb_log_debug2("got buffer: %s.\n",
+                    usb_debug_str_buffer(buffer, buffer_size, 0));
 
                 uint8_t butt = buffer[0];
@@ -115 +139 @@
         }
 
+        /*
+         * Device was probably unplugged.
+         * Hang-up the phone to the console.
+         * FIXME: release allocated memory.
+         */
+        async_hangup(mouse->console_phone);
+        mouse->console_phone = -1;
+
+        usb_log_error("Mouse polling fibril terminated.\n");
+
         return EOK;
 }

uspace/lib/usb/include/usb/debug.h

@@ -79 +79 @@
         usb_log_printf(USB_LOG_LEVEL_DEBUG2, format, ##__VA_ARGS__)
 
+const char *usb_debug_str_buffer(uint8_t *, size_t, size_t);
 
 

uspace/lib/usb/src/debug.c

@@ -252 +252 @@
 }
 
+
+#define REMAINDER_STR_FMT " (%zu)..."
+/* string + terminator + number width (enough for 4GB)*/
+#define REMAINDER_STR_LEN (5 + 1 + 10)
+#define BUFFER_DUMP_GROUP_SIZE 4
+#define BUFFER_DUMP_LEN 240 /* Ought to be enough for everybody ;-). */
+static fibril_local char buffer_dump[BUFFER_DUMP_LEN];
+
+/** Dump buffer into string.
+ *
+ * The function dumps given buffer into hexadecimal format and stores it
+ * in a static fibril local string.
+ * That means that you do not have to deallocate the string (actually, you
+ * can not do that) and you do not have to save it agains concurrent
+ * calls to it.
+ * The only limitation is that each call rewrites the buffer again.
+ * Thus, it is necessary to copy the buffer elsewhere (that includes printing
+ * to screen or writing to file).
+ * Since this function is expected to be used for debugging prints only,
+ * that is not a big limitation.
+ *
+ * @warning You cannot use this function twice in the same printf
+ * (see detailed explanation).
+ *
+ * @param buffer Buffer to be printed (can be NULL).
+ * @param size Size of the buffer in bytes (can be zero).
+ * @param dumped_size How many bytes to actually dump (zero means all).
+ * @return Dumped buffer as a static (but fibril local) string.
+ */
+const char *usb_debug_str_buffer(uint8_t *buffer, size_t size,
+    size_t dumped_size)
+{
+        /*
+         * Remove previous string (that might also reveal double usage of
+         * this function).
+         */
+        bzero(buffer_dump, BUFFER_DUMP_LEN);
+
+        if (buffer == NULL) {
+                return "(null)";
+        }
+        if (size == 0) {
+                return "(empty)";
+        }
+        if ((dumped_size == 0) || (dumped_size > size)) {
+                dumped_size = size;
+        }
+
+        /* How many bytes are available in the output buffer. */
+        size_t buffer_remaining_size = BUFFER_DUMP_LEN - 1 - REMAINDER_STR_LEN;
+        char *it = buffer_dump;
+
+        size_t index = 0;
+
+        while (index < size) {
+                /* Determine space before the number. */
+                const char *space_before;
+                if (index == 0) {
+                        space_before = "";
+                } else if ((index % BUFFER_DUMP_GROUP_SIZE) == 0) {
+                        space_before = "  ";
+                } else {
+                        space_before = " ";
+                }
+
+                /*
+                 * Add the byte as a hexadecimal number plus the space.
+                 * We do it into temporary buffer to ensure that always
+                 * the whole byte is printed.
+                 */
+                int val = buffer[index];
+                char current_byte[16];
+                int printed = snprintf(current_byte, 16,
+                    "%s%02x", space_before, val);
+                if (printed < 0) {
+                        break;
+                }
+
+                if ((size_t) printed > buffer_remaining_size) {
+                        break;
+                }
+
+                /* We can safely add 1, because space for end 0 is reserved. */
+                str_append(it, buffer_remaining_size + 1, current_byte);
+
+                buffer_remaining_size -= printed;
+                /* Point at the terminator 0. */
+                it += printed;
+                index++;
+
+                if (index >= dumped_size) {
+                        break;
+                }
+        }
+
+        /* Add how many bytes were not printed. */
+        if (index < size) {
+                snprintf(it, REMAINDER_STR_LEN,
+                    REMAINDER_STR_FMT, size - index);
+        }
+
+        return buffer_dump;
+}
+
+
 /**
  * @}