Changeset d3b6d5e in mainline for uspace/drv/usbhid/multimedia/multimedia.c

Timestamp:

2011-05-12T08:33:24Z (14 years ago)

Author:

Lubos Slovak <lubos.slovak@…>

Branches:

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

Children:

373bc2d

Parents:

cecb1a97

Message:

Renamed lgtch-ultrax subdriver to multimedia

File:

• uspace/drv/usbhid/multimedia/multimedia.c (moved) (moved from uspace/drv/usbhid/lgtch-ultrax/lgtch-ultrax.c ) (21 diffs)

uspace/drv/usbhid/multimedia/multimedia.c

@@ -32 +32 @@
 /**
  * @file
- * USB Logitech UltraX Keyboard sample driver.
- */
-
-
-#include "lgtch-ultrax.h"
+ * USB Keyboard multimedia keys subdriver.
+ */
+
+
+#include "multimedia.h"
 #include "../usbhid.h"
 #include "keymap.h"
@@ -50 +50 @@
 #include <io/console.h>
 
-#define NAME "lgtch-ultrax"
-
-typedef enum usb_lgtch_flags {
-        USB_LGTCH_STATUS_UNINITIALIZED = 0,
-        USB_LGTCH_STATUS_INITIALIZED = 1,
-        USB_LGTCH_STATUS_TO_DESTROY = -1
-} usb_lgtch_flags;
+#define NAME "multimedia-keys"
 
 /*----------------------------------------------------------------------------*/
@@ -62 +56 @@
  * Logitech UltraX device type.
  */
-typedef struct usb_lgtch_ultrax_t {
+typedef struct usb_multimedia_t {
         /** Previously pressed keys (not translated to key codes). */
         int32_t *keys_old;
@@ -68 +62 @@
         int32_t *keys;
         /** Count of stored keys (i.e. number of keys in the report). */
-        size_t key_count;
-        
+        size_t key_count;       
         /** IPC phone to the console device (for sending key events). */
         int console_phone;
-
-        /** Information for auto-repeat of keys. */
-//      usb_kbd_repeat_t repeat;
-        
-        /** Mutex for accessing the information about auto-repeat. */
-//      fibril_mutex_t *repeat_mtx;
-
-        /** State of the structure (for checking before use). 
-         * 
-         * 0 - not initialized
-         * 1 - initialized
-         * -1 - ready for destroying
-         */
-        int initialized;
-} usb_lgtch_ultrax_t;
+} usb_multimedia_t;
 
 
@@ -117 +96 @@
         assert(hid_dev != NULL);
         assert(hid_dev->data != NULL);
-        usb_lgtch_ultrax_t *lgtch_dev = (usb_lgtch_ultrax_t *)hid_dev->data;
+        usb_multimedia_t *multim_dev = (usb_multimedia_t *)hid_dev->data;
 
         if (method == IPC_M_CONNECT_TO_ME) {
                 int callback = IPC_GET_ARG5(*icall);
 
-                if (lgtch_dev->console_phone != -1) {
+                if (multim_dev->console_phone != -1) {
                         async_answer_0(icallid, ELIMIT);
                         return;
                 }
 
-                lgtch_dev->console_phone = callback;
+                multim_dev->console_phone = callback;
                 usb_log_debug(NAME " Saved phone to console: %d\n", callback);
                 async_answer_0(icallid, EOK);
@@ -138 +117 @@
 /*----------------------------------------------------------------------------*/
 
-static ddf_dev_ops_t lgtch_ultrax_ops = {
+static ddf_dev_ops_t multimedia_ops = {
         .default_handler = default_connection_handler
 };
-
-/*----------------------------------------------------------------------------*/
-
-//static void usb_lgtch_process_keycodes(const uint8_t *key_codes, size_t count,
-//    uint8_t report_id, void *arg);
-
-//static const usb_hid_report_in_callbacks_t usb_lgtch_parser_callbacks = {
-//      .keyboard = usb_lgtch_process_keycodes
-//};
-
-///*----------------------------------------------------------------------------*/
-
-//static void usb_lgtch_process_keycodes(const uint8_t *key_codes, size_t count,
-//    uint8_t report_id, void *arg)
-//{
-//      // TODO: checks
-        
-//      usb_log_debug(NAME " Got keys from parser (report id: %u): %s\n", 
-//          report_id, usb_debug_str_buffer(key_codes, count, 0));
-//}
 
 /*----------------------------------------------------------------------------*/
@@ -180 +139 @@
  * @param key Key code of the key according to HID Usage Tables.
  */
-static void usb_lgtch_push_ev(usb_hid_dev_t *hid_dev, int type, 
+static void usb_multimedia_push_ev(usb_hid_dev_t *hid_dev, int type, 
     unsigned int key)
 {
@@ -186 +145 @@
         assert(hid_dev->data != NULL);
         
-        usb_lgtch_ultrax_t *lgtch_dev = (usb_lgtch_ultrax_t *)hid_dev->data;
+        usb_multimedia_t *multim_dev = (usb_multimedia_t *)hid_dev->data;
         
         console_event_t ev;
@@ -193 +152 @@
         ev.key = key;
         ev.mods = 0;
-
         ev.c = 0;
 
         usb_log_debug2(NAME " Sending key %d to the console\n", ev.key);
-        if (lgtch_dev->console_phone < 0) {
+        if (multim_dev->console_phone < 0) {
                 usb_log_warning(
                     "Connection to console not ready, key discarded.\n");
@@ -203 +161 @@
         }
         
-        async_msg_4(lgtch_dev->console_phone, KBD_EVENT, ev.type, ev.key, 
+        async_msg_4(multim_dev->console_phone, KBD_EVENT, ev.type, ev.key, 
             ev.mods, ev.c);
 }
@@ -209 +167 @@
 /*----------------------------------------------------------------------------*/
 
-static void usb_lgtch_free(usb_lgtch_ultrax_t **lgtch_dev)
-{
-        if (lgtch_dev == NULL || *lgtch_dev == NULL) {
+static void usb_multimedia_free(usb_multimedia_t **multim_dev)
+{
+        if (multim_dev == NULL || *multim_dev == NULL) {
                 return;
         }
         
         // hangup phone to the console
-        async_hangup((*lgtch_dev)->console_phone);
-        
-//      if ((*lgtch_dev)->repeat_mtx != NULL) {
-//              /* TODO: replace by some check and wait */
-//              assert(!fibril_mutex_is_locked((*lgtch_dev)->repeat_mtx));
-//              free((*lgtch_dev)->repeat_mtx);
-//      }
+        async_hangup((*multim_dev)->console_phone);
         
         // free all buffers
-        if ((*lgtch_dev)->keys != NULL) {
-                free((*lgtch_dev)->keys);
-        }
-        if ((*lgtch_dev)->keys_old != NULL) {
-                free((*lgtch_dev)->keys_old);
-        }
-
-        free(*lgtch_dev);
-        *lgtch_dev = NULL;
-}
-
-/*----------------------------------------------------------------------------*/
-
-static int usb_lgtch_create_function(usb_hid_dev_t *hid_dev)
+        if ((*multim_dev)->keys != NULL) {
+                free((*multim_dev)->keys);
+        }
+        if ((*multim_dev)->keys_old != NULL) {
+                free((*multim_dev)->keys_old);
+        }
+
+        free(*multim_dev);
+        *multim_dev = NULL;
+}
+
+/*----------------------------------------------------------------------------*/
+
+static int usb_multimedia_create_function(usb_hid_dev_t *hid_dev)
 {
         /* Create the function exposed under /dev/devices. */
@@ -252 +204 @@
          * to the DDF function.
          */
-        fun->ops = &lgtch_ultrax_ops;
+        fun->ops = &multimedia_ops;
         fun->driver_data = hid_dev;   // TODO: maybe change to hid_dev->data
         
@@ -279 +231 @@
 /*----------------------------------------------------------------------------*/
 
-int usb_lgtch_init(struct usb_hid_dev *hid_dev)
+int usb_multimedia_init(struct usb_hid_dev *hid_dev)
 {
         if (hid_dev == NULL || hid_dev->usb_dev == NULL) {
@@ -285 +237 @@
         }
         
-        usb_log_debug(NAME " Initializing HID/lgtch_ultrax structure...\n");
-        
-        usb_lgtch_ultrax_t *lgtch_dev = (usb_lgtch_ultrax_t *)malloc(
-            sizeof(usb_lgtch_ultrax_t));
-        if (lgtch_dev == NULL) {
+        usb_log_debug(NAME " Initializing HID/multimedia structure...\n");
+        
+        usb_multimedia_t *multim_dev = (usb_multimedia_t *)malloc(
+            sizeof(usb_multimedia_t));
+        if (multim_dev == NULL) {
                 return ENOMEM;
         }
         
-        lgtch_dev->console_phone = -1;
+        multim_dev->console_phone = -1;
         
         usb_hid_report_path_t *path = usb_hid_report_path();
@@ -300 +252 @@
         usb_hid_report_path_set_report_id(path, 1);
         
-        lgtch_dev->key_count = usb_hid_report_input_length(
+        multim_dev->key_count = usb_hid_report_input_length(
             hid_dev->report, path, 
             USB_HID_PATH_COMPARE_END | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY);
@@ -306 +258 @@
         
         usb_log_debug(NAME " Size of the input report: %zu\n", 
-            lgtch_dev->key_count);
-        
-        lgtch_dev->keys = (int32_t *)calloc(lgtch_dev->key_count, 
+            multim_dev->key_count);
+        
+        multim_dev->keys = (int32_t *)calloc(multim_dev->key_count, 
             sizeof(int32_t));
         
-        if (lgtch_dev->keys == NULL) {
+        if (multim_dev->keys == NULL) {
                 usb_log_fatal("No memory!\n");
-                free(lgtch_dev);
+                free(multim_dev);
                 return ENOMEM;
         }
         
-        lgtch_dev->keys_old = 
-                (int32_t *)calloc(lgtch_dev->key_count, sizeof(int32_t));
-        
-        if (lgtch_dev->keys_old == NULL) {
+        multim_dev->keys_old = 
+                (int32_t *)calloc(multim_dev->key_count, sizeof(int32_t));
+        
+        if (multim_dev->keys_old == NULL) {
                 usb_log_fatal("No memory!\n");
-                free(lgtch_dev->keys);
-                free(lgtch_dev);
+                free(multim_dev->keys);
+                free(multim_dev);
                 return ENOMEM;
         }
@@ -330 +282 @@
         
         // save the KBD device structure into the HID device structure
-        hid_dev->data = lgtch_dev;
-        
-        lgtch_dev->initialized = USB_LGTCH_STATUS_INITIALIZED;
-        usb_log_debug(NAME " HID/lgtch_ultrax device structure initialized.\n");
-        
-        int rc = usb_lgtch_create_function(hid_dev);
+        hid_dev->data = multim_dev;
+        
+        usb_log_debug(NAME " HID/multimedia device structure initialized.\n");
+        
+        int rc = usb_multimedia_create_function(hid_dev);
         if (rc != EOK) {
-                usb_lgtch_free(&lgtch_dev);
+                usb_multimedia_free(&multim_dev);
                 return rc;
         }
         
-        usb_log_debug(NAME " HID/lgtch_ultrax structure initialized.\n");
+        usb_log_debug(NAME " HID/multimedia structure initialized.\n");
         
         return EOK;
@@ -348 +299 @@
 /*----------------------------------------------------------------------------*/
 
-void usb_lgtch_deinit(struct usb_hid_dev *hid_dev)
+void usb_multimedia_deinit(struct usb_hid_dev *hid_dev)
 {
         if (hid_dev == NULL) {
@@ -355 +306 @@
         
         if (hid_dev->data != NULL) {
-                usb_lgtch_ultrax_t *lgtch_dev = 
-                    (usb_lgtch_ultrax_t *)hid_dev->data;
-//              if (usb_kbd_is_initialized(kbd_dev)) {
-//                      usb_kbd_mark_unusable(kbd_dev);
-//              } else {
-                        usb_lgtch_free(&lgtch_dev);
-                        hid_dev->data = NULL;
-//              }
-        }
-}
-
-/*----------------------------------------------------------------------------*/
-
-bool usb_lgtch_polling_callback(struct usb_hid_dev *hid_dev, 
+                usb_multimedia_t *multim_dev = 
+                    (usb_multimedia_t *)hid_dev->data;
+                usb_multimedia_free(&multim_dev);
+                hid_dev->data = NULL;
+        }
+}
+
+/*----------------------------------------------------------------------------*/
+
+bool usb_multimedia_polling_callback(struct usb_hid_dev *hid_dev, 
     uint8_t *buffer, size_t buffer_size)
 {
@@ -380 +327 @@
         
         usb_hid_report_path_t *path = usb_hid_report_path();
-        usb_hid_report_path_append_item(path, 0xc, 0);
+        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_CONSUMER, 0);
 
         uint8_t report_id;
@@ -409 +356 @@
                     field->usage);
                 
-                key = usb_lgtch_map_usage(field->usage);
-                usb_lgtch_push_ev(hid_dev, KEY_PRESS, key);
+                key = usb_multimedia_map_usage(field->usage);
+                const char *key_str = usb_multimedia_usage_to_str(field->usage);
+                usb_log_info("Pressed key: %s\n", key_str);
+                usb_multimedia_push_ev(hid_dev, KEY_PRESS, key);
                 
                 field = usb_hid_report_get_sibling(