Changeset e1e47e116d4dcf9a1da4955a6d21d84baa73649e

Timestamp:

04/25/07 02:41:13 (6 years ago)

Author:

dsmith <dsmith@…>

Children:

c01a5a46907834f0636fddd3ab08d48f01e70449

Parents:

aeed7f70e058dad1d2a938bcf9a60652fd288552

git-author:

L. Donnie Smith <donnie.smith@…> (04/25/07 02:41:13)

git-committer:

dsmith <dsmith@…> (04/25/07 02:41:13)

Message:

merge api_overhaul into head (#22, #24, #29)

git-svn-id: http://abstrakraft.org/cwiid/svn/trunk@101 918edb2d-ff29-0410-9de2-eb38e7f22bc7

Files:

• ChangeLog (modified) (1 diff)
• NEWS (modified) (1 diff)
• libcwiid/Makefile.in (modified) (1 diff)
• libcwiid/bluetooth.c (modified) (6 diffs)
• libcwiid/command.c (modified) (5 diffs)
• libcwiid/connect.c (modified) (7 diffs)
• libcwiid/cwiid.h (modified) (15 diffs)
• libcwiid/cwiid_internal.h (modified) (6 diffs)
• libcwiid/event.c (deleted)
• libcwiid/interface.c (added)
• libcwiid/process.c (added)
• libcwiid/queue.c (deleted)
• libcwiid/queue.h (deleted)
• libcwiid/rw.c (deleted)
• libcwiid/state.c (added)
• libcwiid/thread.c (added)
• libcwiid/util.c (modified) (9 diffs)
• wmdemo/wmdemo.c (modified) (10 diffs)
• wmgui/main.c (modified) (10 diffs)
• wminput/main.c (modified) (14 diffs)
• wminput/plugins/acc/acc.c (modified) (2 diffs)
• wminput/plugins/ir_ptr/ir_ptr.c (modified) (11 diffs)
• wminput/plugins/nunchuk_acc/nunchuk_acc.c (modified) (5 diffs)

ChangeLog

@@ +1 @@
+2007-04-24 L. Donnie Smith <cwiid@abstrakraft.org>
+        libcwiid
+        * rewrite (API overhaul)
+
+        wmdemo
+        * updated for API overhaul
+
+        wmgui
+        * updated for API overhaul
+
+        wminput
+        * updated for API overhaul
+
 2007-04-15 <work.eric@gmail.com>
         wminput

NEWS

@@ +1 @@
+0.5.03
+        - Bugfixes, lswm utility, disconnect messages, wminput infinite wait
+
 0.5.02
         - Bugfixes, configure --disable-ldconfig

libcwiid/Makefile.in

@@ -6 +6 @@
 MAJOR_VER = 0
 MINOR_VER = 1
-SOURCES = connect.c command.c event.c rw.c bluetooth.c util.c queue.c
+SOURCES = bluetooth.c command.c connect.c interface.c process.c state.c \
+          thread.c util.c
 LDLIBS += -lbluetooth -lpthread -lrt
 LIB_INST_DIR = @libdir@

libcwiid/bluetooth.c

@@ -16 +16 @@
  *
  *  ChangeLog:
+ *  2007-04-24 L. Donnie Smith (cwiid@abstrakraft.org>
+ *  * revised error messages
+ *
  *  2007-04-12 L. Donnie Smith <cwiid@abstrakraft.org>
  *  * streamlined wiimote filter
@@ -81 +84 @@
         if ((dev_count = hci_inquiry(dev_id, timeout, max_inquiry, NULL,
                                      &dev_list, IREQ_CACHE_FLUSH)) == -1) {
-                cwiid_err(NULL, "Error on bluetooth device inquiry");
+                cwiid_err(NULL, "Bluetooth device inquiry error");
                 err = 1;
                 goto CODA;
@@ -93 +96 @@
         /* Open connection to Bluetooth Interface */
         if ((sock = hci_open_dev(dev_id)) == -1) {
-                cwiid_err(NULL, "Error opening Bluetooth interface");
+                cwiid_err(NULL, "Bluetooth interface open error");
                 err = 1;
                 goto CODA;
@@ -103 +106 @@
         }
         if ((*bdinfo = malloc(max_bdinfo * sizeof **bdinfo)) == NULL) {
-                cwiid_err(NULL, "Error mallocing bdinfo array");
+                cwiid_err(NULL, "Memory allocation error (bdinfo array)");
                 err = 1;
                 goto CODA;
@@ -122 +125 @@
                 if (hci_remote_name(sock, &dev_list[i].bdaddr, BT_NAME_LEN,
                                     (*bdinfo)[bdinfo_count].name, 10000)) {
-                        cwiid_err(NULL, "Error reading Bluetooth device name");
+                        cwiid_err(NULL, "Bluetooth name read error");
                         err = 1;
                         goto CODA;
@@ -148 +151 @@
                 if ((*bdinfo = realloc(*bdinfo, bdinfo_count * sizeof **bdinfo))
                   == NULL) {
-                        cwiid_err(NULL, "Error reallocing bdinfo array");
+                        cwiid_err(NULL, "Memory reallocation error (bdinfo array)");
                         err = 1;
                         goto CODA;

libcwiid/command.c

@@ -16 +16 @@
  *
  *  ChangeLog:
+ *  2007-04-24 L. Donnie Smith <cwiid@abstrakraft.org>
+ *  * rewrite for API overhaul
+ *  * added rw and beep functions from rw.c
+ *
  *  2007-04-09 L. Donnie Smith <cwiid@abstrakraft.org>
  *  * renamed wiimote to libcwiid, renamed structures accordingly
+ *
+ *  2007-04-04 L. Donnie Smith <cwiid@abstrakraft.org>
+ *  * updated cwiid_read and cwiid_write to trigger and detect rw_error
  *
  *  2007-03-14 L. Donnie Smith <cwiid@abstrakraft.org>
  *  * audited error checking (coda and error handler sections)
  *  * updated comments
+ *  * cwiid_read - changed to obey decode flag only for register read
  *
  *  2007-03-06 L. Donnie Smith <cwiid@abstrakraft.org>
@@ -32 +40 @@
 
 #include <stdint.h>
+#include <time.h>
+#include <pthread.h>
 #include <unistd.h>
 #include "cwiid_internal.h"
 
-/* IR Sensitivity Block */
-unsigned char ir_block1[] = CLIFF_IR_BLOCK_1;
-unsigned char ir_block2[] = CLIFF_IR_BLOCK_2;
-
-struct write_seq ir_enable10_seq[] = {
-        {WRITE_SEQ_RPT, RPT_IR_ENABLE1, (const void *)"\x04", 1, 0},
-        {WRITE_SEQ_RPT, RPT_IR_ENABLE2, (const void *)"\x04", 1, 0},
-        {WRITE_SEQ_MEM, 0xB00030, (const void *)"\x08", 1,     CWIID_RW_REG},
-        {WRITE_SEQ_MEM, 0xB00000, ir_block1, sizeof(ir_block1)-1, CWIID_RW_REG},
-        {WRITE_SEQ_MEM, 0xB0001A, ir_block2, sizeof(ir_block2)-1, CWIID_RW_REG},
-        {WRITE_SEQ_MEM, 0xB00033, (const void *)"\x01", 1,     CWIID_RW_REG}
-};
-
-struct write_seq ir_enable12_seq[] = {
-        {WRITE_SEQ_RPT, RPT_IR_ENABLE1, (const void *)"\x04", 1, 0},
-        {WRITE_SEQ_RPT, RPT_IR_ENABLE2, (const void *)"\x04", 1, 0},
-        {WRITE_SEQ_MEM, 0xB00030, (const void *)"\x08", 1,     CWIID_RW_REG},
-        {WRITE_SEQ_MEM, 0xB00000, ir_block1, sizeof(ir_block1)-1, CWIID_RW_REG},
-        {WRITE_SEQ_MEM, 0xB0001A, ir_block2, sizeof(ir_block2)-1, CWIID_RW_REG},
-        {WRITE_SEQ_MEM, 0xB00033, (const void *)"\x03", 1,     CWIID_RW_REG}
-};
-
-struct write_seq ir_disable_seq[] = {
-        {WRITE_SEQ_RPT, RPT_IR_ENABLE1, (const void *)"\x00", 1, 0},
-        {WRITE_SEQ_RPT, RPT_IR_ENABLE2, (const void *)"\x00", 1, 0}
-};
-
 #define CMD_BUF_LEN     21
 int cwiid_command(struct wiimote *wiimote, enum cwiid_command command,
-                  uint8_t flags) {
+                  int flags) {
         int ret = 0;
         unsigned char buf[CMD_BUF_LEN];
 
+        /* TODO: assumption: char assignments are atomic, no mutex lock needed */
         switch (command) {
         case CWIID_CMD_STATUS:
                 buf[0] = 0;
                 if (send_report(wiimote, 0, RPT_STATUS_REQ, 1, buf)) {
-                        cwiid_err(wiimote, "Error requesting status");
+                        cwiid_err(wiimote, "Status request error");
                         ret = -1;
                 }
                 break;
         case CWIID_CMD_LED:
-                wiimote->led_rumble_state = ((flags & 0x0F)<<4) |
-                                            (wiimote->led_rumble_state & 0x01);
-                buf[0]=wiimote->led_rumble_state;
+                wiimote->state.led = flags & 0x0F;
+                buf[0] = wiimote->state.led<<4 | wiimote->state.rumble;
                 if (send_report(wiimote, SEND_RPT_NO_RUMBLE, RPT_LED_RUMBLE, 1, buf)) {
-                        cwiid_err(wiimote, "Error setting LEDs");
+                        cwiid_err(wiimote, "Report send error (led)");
                         ret = -1;
                 }
                 break;
         case CWIID_CMD_RUMBLE:
-                wiimote->led_rumble_state = (wiimote->led_rumble_state & 0xFE) |
-                                            (flags ? 1 : 0);
-                buf[0]=wiimote->led_rumble_state;
+                wiimote->state.rumble = flags ? 1 : 0;
+                buf[0] = wiimote->state.led<<4 | wiimote->state.rumble;
                 if (send_report(wiimote, SEND_RPT_NO_RUMBLE, RPT_LED_RUMBLE, 1, buf)) {
-                        cwiid_err(wiimote, "Error setting rumble");
+                        cwiid_err(wiimote, "Report send error (rumble)");
                         ret = -1;
                 }
@@ -98 +80 @@
                 break;
         default:
-                cwiid_err(wiimote, "Unknown command");
                 ret = -1;
                 break;
@@ -106 +87 @@
 }
 
-#define RPT_MODE_BUF_LEN 2
-int update_rpt_mode(struct wiimote *wiimote, int8_t flags)
+#define RPT_READ_REQ_LEN 6
+int cwiid_read(struct wiimote *wiimote, uint8_t flags, uint32_t offset,
+               uint16_t len, void *data)
 {
-        unsigned char buf[RPT_MODE_BUF_LEN];
-        uint8_t rpt_mode;
-        struct write_seq *ir_enable_seq;
-        int seq_len;
+        unsigned char buf[RPT_READ_REQ_LEN];
+        struct rw_mesg mesg;
+        unsigned char *cursor;
         int ret = 0;
-
-        /* Lock wiimote access */
-        if (pthread_mutex_lock(&wiimote->wiimote_mutex)) {
-                cwiid_err(wiimote, "Error locking wiimote_mutex");
+        int i;
+
+        /* Compose read request packet */
+        buf[0]=flags & (CWIID_RW_EEPROM | CWIID_RW_REG);
+        buf[1]=(unsigned char)((offset>>16) & 0xFF);
+        buf[2]=(unsigned char)((offset>>8) & 0xFF);
+        buf[3]=(unsigned char)(offset & 0xFF);
+        buf[4]=(unsigned char)((len>>8) & 0xFF);
+        buf[5]=(unsigned char)(len & 0xFF);
+
+        /* Lock wiimote rw access */
+        if (pthread_mutex_lock(&wiimote->rw_mutex)) {
+                cwiid_err(wiimote, "Mutex lock error (rw_mutex)");
+                return -1;
+        }
+
+        /* Setup read info */
+        wiimote->rw_status = RW_READ;
+
+        /* TODO: Document: user is responsible for ensuring that read/write
+         * operations are not in flight while disconnecting.  Nothing serious,
+         * just accesses to freed memory */
+        /* Send read request packet */
+        if (send_report(wiimote, 0, RPT_READ_REQ, RPT_READ_REQ_LEN, buf)) {
+                cwiid_err(wiimote, "Report send error (read)");
                 ret = -1;
                 goto CODA;
         }
 
-        /* Use -1 to update the reporting mode without changing flags */
-        if (flags == -1) {
-                flags = wiimote->rpt_mode_flags;
-        }
-
-        /* Pick a report mode based on report flags */
-        if ((flags & CWIID_RPT_EXT) &&
-          ((wiimote->extension == CWIID_EXT_NUNCHUK) ||
-           (wiimote->extension == CWIID_EXT_CLASSIC))) {
-                if ((flags & CWIID_RPT_IR) &&
-                  (flags & CWIID_RPT_ACC)) {
-                        rpt_mode = RPT_BTN_ACC_IR10_EXT6;
-                        ir_enable_seq = ir_enable10_seq;
-                        seq_len = SEQ_LEN(ir_enable10_seq);
-                }
-                else if (flags & CWIID_RPT_IR) {
-                        rpt_mode = RPT_BTN_IR10_EXT9;
-                        ir_enable_seq = ir_enable10_seq;
-                        seq_len = SEQ_LEN(ir_enable10_seq);
-                }
-                else if (flags & CWIID_RPT_ACC) {
-                        rpt_mode = RPT_BTN_ACC_EXT16;
-                }
-                else if (flags & CWIID_RPT_BTN) {
-                        rpt_mode = RPT_BTN_EXT8;
-                }
-                else {
-                        rpt_mode = RPT_EXT21;
-                }       
-        }
-        else {
-                if (flags & CWIID_RPT_IR) {
-                        rpt_mode = RPT_BTN_ACC_IR12;
-                        ir_enable_seq = ir_enable12_seq;
-                        seq_len = SEQ_LEN(ir_enable12_seq);
-                }
-                else if (flags & CWIID_RPT_ACC) {
-                        rpt_mode = RPT_BTN_ACC;
-                }
-                else {
-                        rpt_mode = RPT_BTN;
-                }
-        }
-
-        /* Enable IR */
-        /* TODO: only do this when necessary (record old IR mode) */
-        if ((flags & CWIID_RPT_IR)) {
-                if (exec_write_seq(wiimote, seq_len, ir_enable_seq)) {
-                        cwiid_err(wiimote, "Error on IR enable");
-                        ret = -1;
-                        goto CODA;
-                }
-        }
-        /* Disable IR */
-        else if ((wiimote->rpt_mode_flags & CWIID_RPT_IR) &
-                 !(flags & CWIID_RPT_IR)) {
-                if (exec_write_seq(wiimote, SEQ_LEN(ir_disable_seq),
-                                   ir_disable_seq)) {
-                        cwiid_err(wiimote, "Error on IR enable");
-                        ret = -1;
-                        goto CODA;
-                }
-        }
-
-        /* Send SET_REPORT */
-        buf[0]=0;
-        buf[1]=rpt_mode;
-        if (send_report(wiimote, 0, RPT_RPT_MODE, RPT_MODE_BUF_LEN, buf)) {
-                cwiid_err(wiimote, "Error setting report state");
-                ret = -1;
-                goto CODA;
-        }
-
-        wiimote->rpt_mode_flags = flags;
+        /* TODO:Better sanity checks (offset) */
+        /* Read packets */
+        for (cursor = data; cursor - (unsigned char *)data < len;
+             cursor += mesg.len) {
+                if (full_read(wiimote->rw_pipe[0], &mesg, sizeof mesg)) {
+                        cwiid_err(wiimote, "Pipe read error (rw pipe)");
+                        ret = -1;
+                        goto CODA;
+                }
+
+                if (mesg.type == RW_CANCEL) {
+                        ret = -1;
+                        goto CODA;
+                }
+                else if (mesg.type != RW_READ) {
+                        cwiid_err(wiimote, "Unexpected write message");
+                        ret = -1;
+                        goto CODA;
+                }
+
+                if (mesg.error) {
+                        cwiid_err(wiimote, "Wiimote read error");
+                        ret = -1;
+                        goto CODA;
+                }
+
+                memcpy(cursor, &mesg.data, mesg.len);
+        }
 
 CODA:
-        /* Unlock cwiid_mutex */
-        if (pthread_mutex_unlock(&wiimote->wiimote_mutex)) {
-                cwiid_err(wiimote, "Error unlocking wiimote_mutex: deadlock warning");
+        /* Clear rw_status */
+        wiimote->rw_status = RW_IDLE;
+
+        /* Unlock rw_mutex */
+        if (pthread_mutex_unlock(&wiimote->rw_mutex)) {
+                cwiid_err(wiimote, "Mutex unlock error (rw_mutex) - deadlock warning");
+        }
+
+        /* Decode (only for register reads) */
+        if ((ret == 0) && (flags & CWIID_RW_DECODE) && (flags & CWIID_RW_REG)) {
+                for (i=0; i < len; i++) {
+                        ((unsigned char *)data)[i] = DECODE(((unsigned char *)data)[i]);
+                }
         }
 
@@ -206 +172 @@
 }
 
+#define RPT_WRITE_LEN 21
+int cwiid_write(struct wiimote *wiimote, uint8_t flags, uint32_t offset,
+                  uint16_t len, const void *data)
+{
+        unsigned char buf[RPT_WRITE_LEN];
+        uint16_t sent=0;
+        struct rw_mesg mesg;
+        int ret = 0;
+
+        /* Compose write packet header */
+        buf[0]=flags;
+
+        /* Lock wiimote rw access */
+        if (pthread_mutex_lock(&wiimote->rw_mutex)) {
+                cwiid_err(wiimote, "Mutex lock error (rw mutex)");
+                return -1;
+        }
+
+        /* Send packets */
+        wiimote->rw_status = RW_WRITE;
+        while (sent<len) {
+                /* Compose write packet */
+                buf[1]=(unsigned char)(((offset+sent)>>16) & 0xFF);
+                buf[2]=(unsigned char)(((offset+sent)>>8) & 0xFF);
+                buf[3]=(unsigned char)((offset+sent) & 0xFF);
+                if (len-sent >= 0x10) {
+                        buf[4]=(unsigned char)0x10;
+                }
+                else {
+                        buf[4]=(unsigned char)(len-sent);
+                }
+                memcpy(buf+5, data+sent, buf[4]);
+
+                if (send_report(wiimote, 0, RPT_WRITE, RPT_WRITE_LEN, buf)) {
+                        cwiid_err(wiimote, "Report send error (write)");
+                        ret = -1;
+                        goto CODA;
+                }
+
+                /* Read packets from pipe */
+                if (read(wiimote->rw_pipe[0], &mesg, sizeof mesg) != sizeof mesg) {
+                        cwiid_err(wiimote, "Pipe read error (rw pipe)");
+                        ret = -1;
+                        goto CODA;
+                }
+
+                if (mesg.type == RW_CANCEL) {
+                        ret = -1;
+                        goto CODA;
+                }
+                else if (mesg.type != RW_WRITE) {
+                        cwiid_err(wiimote, "Unexpected read message");
+                        ret = -1;
+                        goto CODA;
+                }
+
+                if (mesg.error) {
+                        cwiid_err(wiimote, "Wiimote write error");
+                        ret = -1;
+                        goto CODA;
+                };
+
+                sent+=buf[4];
+        }
+
+CODA:
+        /* Clear rw_status */
+        wiimote->rw_status = RW_IDLE;
+
+        /* Unlock rw_mutex */
+        if (pthread_mutex_unlock(&wiimote->rw_mutex)) {
+                cwiid_err(wiimote, "Mutex unlock error (rw_mutex) - deadlock warning");
+        }
+
+        return ret;
+}
+
+
+struct write_seq speaker_enable_seq[] = {
+        {WRITE_SEQ_RPT, RPT_SPEAKER_ENABLE, (const void *)"\x04", 1, 0},
+        {WRITE_SEQ_RPT,   RPT_SPEAKER_MUTE, (const void *)"\x04", 1, 0},
+        {WRITE_SEQ_MEM, 0xA20009, (const void *)"\x01", 1, CWIID_RW_REG},
+        {WRITE_SEQ_MEM, 0xA20001, (const void *)"\x08", 1, CWIID_RW_REG},
+        {WRITE_SEQ_MEM, 0xA20001, (const void *)"\x00\x00\x00\x0C\x40\x00\x00",
+                                  7, CWIID_RW_REG},
+        {WRITE_SEQ_MEM, 0xA20008, (const void *)"\x01", 1, CWIID_RW_REG},
+        {WRITE_SEQ_RPT,   RPT_SPEAKER_MUTE, (const void *)"\x00", 1, 0}
+};
+
+struct write_seq speaker_disable_seq[] = {
+        {WRITE_SEQ_RPT,   RPT_SPEAKER_MUTE, (const void *)"\x04", 1, 0},
+        {WRITE_SEQ_RPT, RPT_SPEAKER_ENABLE, (const void *)"\x00", 1, 0}
+};
+
+#define SOUND_BUF_LEN   21
+int cwiid_beep(cwiid_wiimote_t *wiimote)
+{
+        /* unsigned char buf[SOUND_BUF_LEN] = { 0xA0, 0xCC, 0x33, 0xCC, 0x33,
+            0xCC, 0x33, 0xCC, 0x33, 0xCC, 0x33, 0xCC, 0x33, 0xCC, 0x33, 0xCC, 0x33,
+            0xCC, 0x33, 0xCC, 0x33}; */
+        unsigned char buf[SOUND_BUF_LEN] = { 0xA0, 0xC3, 0xC3, 0xC3, 0xC3,
+            0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3,
+            0xC3, 0xC3, 0xC3, 0xC3};
+        int i;
+        int ret = 0;
+        pthread_mutex_t timer_mutex = PTHREAD_MUTEX_INITIALIZER;
+        pthread_cond_t timer_cond = PTHREAD_COND_INITIALIZER;
+        struct timespec t;
+
+        if (exec_write_seq(wiimote, SEQ_LEN(speaker_enable_seq),
+                           speaker_enable_seq)) {
+                cwiid_err(wiimote, "Speaker enable error");
+                ret = -1;
+        }
+
+        pthread_mutex_lock(&timer_mutex);
+
+        for (i=0; i<100; i++) {
+                clock_gettime(CLOCK_REALTIME, &t);
+                t.tv_nsec += 10204081;
+                /* t.tv_nsec += 7000000; */
+                if (send_report(wiimote, 0, RPT_SPEAKER_DATA, SOUND_BUF_LEN, buf)) {
+                        printf("%d\n", i);
+                        cwiid_err(wiimote, "Report send error (speaker data)");
+                        ret = -1;
+                        break;
+                }
+                /* TODO: I should be shot for this, but hey, it works.
+                 * longterm - find a better wait */
+                pthread_cond_timedwait(&timer_cond, &timer_mutex, &t);
+        }
+
+        pthread_mutex_unlock(&timer_mutex);
+
+        if (exec_write_seq(wiimote, SEQ_LEN(speaker_disable_seq),
+                           speaker_disable_seq)) {
+                cwiid_err(wiimote, "Speaker disable error");
+                ret = -1;
+        }
+
+        return ret;
+}

libcwiid/connect.c

@@ -16 +16 @@
  *
  *  ChangeLog:
+ *  2007-04-24 L. Donnie Smith <cwiid@abstrakraft.org>
+ *  * rewrite for API overhaul
+ *
  *  2007-04-09 L. Donnie Smith <cwiid@abstrakraft.org>
  *  * renamed wiimote to libcwiid, renamed structures accordingly
@@ -38 +41 @@
  */
 
-#include <pthread.h>
 #include <stdlib.h>
 #include <string.h>
+#include <fcntl.h>
+#include <pthread.h>
 #include <sys/types.h>
 #include <sys/socket.h>
@@ -47 +51 @@
 #include <bluetooth/l2cap.h>
 #include "cwiid_internal.h"
-#include "queue.h"
 
 pthread_mutex_t global_mutex = PTHREAD_MUTEX_INITIALIZER;
 static int wiimote_id = 0;
 
-cwiid_wiimote_t *cwiid_connect(bdaddr_t *bdaddr,
-                               cwiid_mesg_callback_t *mesg_callback, int *id)
+cwiid_wiimote_t *cwiid_connect(bdaddr_t *bdaddr, int flags)
 {
         struct wiimote *wiimote = NULL;
-        struct sockaddr_l2 ctl_remote_addr, int_remote_addr;
+        struct sockaddr_l2 remote_addr;
+        char mesg_pipe_init = 0, status_pipe_init = 0, error_pipe_init = 0,
+             rw_pipe_init = 0, state_mutex_init = 0, rw_mutex_init = 0,
+             rpt_mutex_init = 0, router_thread_init = 0, status_thread_init = 0;
+        void *pthread_ret;
 
         /* Allocate wiimote */
         if ((wiimote = malloc(sizeof *wiimote)) == NULL) {
-                cwiid_err(NULL, "Error allocating cwiid_wiimote");
-                goto ERR_HND;
-        }
-
-        /* Set wiimote members for proper error detection */
-        wiimote->ctl_socket = -1;
-        wiimote->int_socket = -1;
-        wiimote->dispatch_queue = NULL;
+                cwiid_err(NULL, "Memory allocation error (cwiid_wiimote_t)");
+                goto ERR_HND;
+        }
+
+        /* set flags */
+        wiimote->flags = flags;
+
+        /* For error detection */
+        wiimote->ctl_socket = wiimote->int_socket = -1;
 
         /* Global Lock, Store and Increment wiimote_id */
         if (pthread_mutex_lock(&global_mutex)) {
-                cwiid_err(NULL, "Error locking global lock");
+                cwiid_err(NULL, "Mutex lock error (global mutex)");
                 goto ERR_HND;
         }
         wiimote->id = wiimote_id++;
         if (pthread_mutex_unlock(&global_mutex)) {
-                cwiid_err(wiimote, "Error unlocking global lock");
-                goto ERR_HND;
-        }
-        /* Return the id in a pointer, if desired */
-        if (id) {
-                *id = wiimote->id;
-        }
-
-        /* Store mesg callback */
-        wiimote->mesg_callback = mesg_callback;
+                cwiid_err(wiimote, "Mutex unlock error (global mutex) - "
+                                   "deadlock warning");
+                goto ERR_HND;
+        }
 
         /* If BDADDR_ANY is given, find available wiimote */
@@ -94 +95 @@
         }
 
-        /* Clear address structs, fill address family, address, and ports */
-        memset(&ctl_remote_addr, 0, sizeof(ctl_remote_addr));
-        ctl_remote_addr.l2_family = AF_BLUETOOTH;
-        ctl_remote_addr.l2_bdaddr = *bdaddr;
-        ctl_remote_addr.l2_psm = htobs(CTL_PSM);
-
-        memset(&int_remote_addr, 0, sizeof(int_remote_addr));
-        int_remote_addr.l2_family = AF_BLUETOOTH;
-        int_remote_addr.l2_bdaddr = *bdaddr;
-        int_remote_addr.l2_psm = htobs(INT_PSM);
-
-        /* Get Bluetooth Sockets */
+        /* Connect to Wiimote */
+        /* Control Channel */
+        memset(&remote_addr, 0, sizeof remote_addr);
+        remote_addr.l2_family = AF_BLUETOOTH;
+        remote_addr.l2_bdaddr = *bdaddr;
+        remote_addr.l2_psm = htobs(CTL_PSM);
         if ((wiimote->ctl_socket =
           socket(AF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP)) == -1) {
-                cwiid_err(wiimote, "Error opening control socket");
-                goto ERR_HND;
-        }
+                cwiid_err(wiimote, "Socket creation error (control socket)");
+                goto ERR_HND;
+        }
+        if (connect(wiimote->ctl_socket, (struct sockaddr *)&remote_addr,
+                        sizeof remote_addr)) {
+                cwiid_err(wiimote, "Socket connect error (control channel)");
+                goto ERR_HND;
+        }
+
+        /* Interrupt Channel */
+        remote_addr.l2_psm = htobs(INT_PSM);
         if ((wiimote->int_socket =
           socket(AF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP)) == -1) {
-                cwiid_err(wiimote, "Error opening interrupt socket");
-                goto ERR_HND;
-        }
-
-        /* Connect to Wiimote */
-        if (connect(wiimote->ctl_socket, (struct sockaddr *)&ctl_remote_addr,
-                        sizeof(ctl_remote_addr))) {
-                cwiid_err(wiimote, "Error opening control channel");
-                goto ERR_HND;
-        }
-        if (connect(wiimote->int_socket, (struct sockaddr *)&int_remote_addr,
-                        sizeof(int_remote_addr))) {
-                cwiid_err(wiimote, "Error opening interrupt channel");
-                goto ERR_HND;
-        }
-
-        /* Create Dispatch Queue */
-        if ((wiimote->dispatch_queue = queue_new()) == NULL) {
-                cwiid_err(wiimote, "Error creating dispatch queue");
-                goto ERR_HND;
-        }
-
-        /* TODO: backout logic (pthread_*_destroy) */
-        /* Mutex and cond init */
-        if (pthread_mutex_init(&wiimote->wiimote_mutex, NULL) ||
-          pthread_mutex_init(&wiimote->rw_mutex, NULL) ||
-          pthread_cond_init(&wiimote->rw_cond, NULL) ||
-          pthread_mutex_init(&wiimote->rw_cond_mutex, NULL)) {
-                cwiid_err(wiimote, "Error initializing synchronization variables");
-                goto ERR_HND;
-        }
-
-        /* Set rw_status before interrupt thread */
-        wiimote->rw_status = RW_NONE;
-        wiimote->rw_error = 0;
+                cwiid_err(wiimote, "Socket creation error (interrupt socket)");
+                goto ERR_HND;
+        }
+        if (connect(wiimote->int_socket, (struct sockaddr *)&remote_addr,
+                        sizeof remote_addr)) {
+                cwiid_err(wiimote, "Socket connect error (interrupt channel)");
+                goto ERR_HND;
+        }
+
+        /* Create pipes */
+        if (pipe(wiimote->mesg_pipe)) {
+                cwiid_err(wiimote, "Pipe creation error (mesg pipe)");
+                goto ERR_HND;
+        }
+        mesg_pipe_init = 1;
+        if (pipe(wiimote->status_pipe)) {
+                cwiid_err(wiimote, "Pipe creation error (status pipe)");
+                goto ERR_HND;
+        }
+        status_pipe_init = 1;
+        if (pipe(wiimote->error_pipe)) {
+                cwiid_err(wiimote, "Pipe creation error (error pipe)");
+                goto ERR_HND;
+        }
+        error_pipe_init = 1;
+        if (pipe(wiimote->rw_pipe)) {
+                cwiid_err(wiimote, "Pipe creation error (rw pipe)");
+                goto ERR_HND;
+        }
+        rw_pipe_init = 1;
+
+        /* Setup blocking */
+        if (fcntl(wiimote->mesg_pipe[1], F_SETFL, O_NONBLOCK)) {
+                cwiid_err(wiimote, "File control error (mesg write pipe)");
+                goto ERR_HND;
+        }
+        if (wiimote->flags & CWIID_FLAG_NONBLOCK) {
+                if (fcntl(wiimote->mesg_pipe[0], F_SETFL, O_NONBLOCK)) {
+                        cwiid_err(wiimote, "File control error (mesg read pipe)");
+                        goto ERR_HND;
+                }
+        }
+
+        /* Init mutexes */
+        if (pthread_mutex_init(&wiimote->state_mutex, NULL)) {
+                cwiid_err(wiimote, "Mutex initialization error (state mutex)");
+                goto ERR_HND;
+        }
+        state_mutex_init = 1;
+        if (pthread_mutex_init(&wiimote->rw_mutex, NULL)) {
+                cwiid_err(wiimote, "Mutex initialization error (rw mutex)");
+                goto ERR_HND;
+        }
+        rw_mutex_init = 1;
+        if (pthread_mutex_init(&wiimote->rpt_mutex, NULL)) {
+                cwiid_err(wiimote, "Mutex initialization error (rpt mutex)");
+                goto ERR_HND;
+        }
+        rpt_mutex_init = 1;
+
+        /* Set rw_status before starting router thread */
+        wiimote->rw_status = RW_IDLE;
 
         /* Launch interrupt channel listener and dispatch threads */
-        if (pthread_create(&wiimote->int_listen_thread, NULL,
-                           (void *(*)(void *))&int_listen, wiimote)) {
-                cwiid_err(wiimote, "Error creating interrupt channel listener thread");
-                goto ERR_HND;
-        }
-        if (pthread_create(&wiimote->dispatch_thread, NULL,
-                           (void *(*)(void *))&dispatch, wiimote)) {
-                pthread_cancel(wiimote->int_listen_thread);
-                pthread_join(wiimote->int_listen_thread, NULL);
-                cwiid_err(wiimote, "Error creating dispatch thread");
-                goto ERR_HND;
-        }
+        if (pthread_create(&wiimote->router_thread, NULL,
+                           (void *(*)(void *))&router_thread, wiimote)) {
+                cwiid_err(wiimote, "Thread creation error (router thread)");
+                goto ERR_HND;
+        }
+        router_thread_init = 1;
+        if (pthread_create(&wiimote->status_thread, NULL,
+                           (void *(*)(void *))&status_thread, wiimote)) {
+                cwiid_err(wiimote, "Thread creation error (status thread)");
+                goto ERR_HND;
+        }
+        status_thread_init = 1;
 
         /* Success!  Update state */
-        wiimote->buttons = 0;
-        wiimote->rpt_mode_flags = 0;
-        wiimote->extension = CWIID_EXT_NONE;
-        wiimote->led_rumble_state = 0;
+        memset(&wiimote->state, 0, sizeof wiimote->state);
+        wiimote->mesg_callback = NULL;
         cwiid_command(wiimote, CWIID_CMD_LED, 0);
         cwiid_command(wiimote, CWIID_CMD_STATUS, 0);
@@ -175 +203 @@
 ERR_HND:
         if (wiimote) {
-                if (wiimote->dispatch_queue) {
-                        queue_free(wiimote->dispatch_queue,
-                                   (free_func_t *)free_mesg_array);
-                }
+                /* Close threads */
+                if (router_thread_init) {
+                        pthread_cancel(wiimote->router_thread);
+                        if (pthread_join(wiimote->router_thread, &pthread_ret)) {
+                                cwiid_err(wiimote, "Thread join error (router thread)");
+                        }
+                        else if (!((pthread_ret == PTHREAD_CANCELED) &&
+                                 (pthread_ret == NULL))) {
+                                cwiid_err(wiimote, "Bad return value from router thread");
+                        }
+                }
+
+                if (status_thread_init) {
+                        pthread_cancel(wiimote->status_thread);
+                        if (pthread_join(wiimote->status_thread, &pthread_ret)) {
+                                cwiid_err(wiimote, "Thread join error (status thread)");
+                        }
+                        else if (!((pthread_ret == PTHREAD_CANCELED) && (pthread_ret == NULL))) {
+                                cwiid_err(wiimote, "Bad return value from status thread");
+                        }
+                }
+
+                /* Close Sockets */
                 if (wiimote->int_socket != -1) {
                         if (close(wiimote->int_socket)) {
-                                cwiid_err(wiimote, "Error closing interrupt channel");
+                                cwiid_err(wiimote, "Socket close error (interrupt channel)");
                         }
                 }
                 if (wiimote->ctl_socket != -1) {
                         if (close(wiimote->ctl_socket)) {
-                                cwiid_err(wiimote, "Error closing control channel");
+                                cwiid_err(wiimote, "Socket close error (control channel)");
+                        }
+                }
+                /* Close Pipes */
+                if (mesg_pipe_init) {
+                        if (close(wiimote->mesg_pipe[0]) || close(wiimote->mesg_pipe[1])) {
+                                cwiid_err(wiimote, "Pipe close error (mesg pipe)");
+                        }
+                }
+                if (status_pipe_init) {
+                        if (close(wiimote->status_pipe[0]) ||
+                          close(wiimote->status_pipe[1])) {
+                                cwiid_err(wiimote, "Pipe close error (status pipe)");
+                        }
+                }
+                if (error_pipe_init) {
+                        if (close(wiimote->error_pipe[0]) ||
+                          close(wiimote->error_pipe[1])) {
+                                cwiid_err(wiimote, "Pipe close error (error pipe)");
+                        }
+                }
+                if (rw_pipe_init) {
+                        if (close(wiimote->rw_pipe[0]) || close(wiimote->rw_pipe[1])) {
+                                cwiid_err(wiimote, "Pipe close error (rw pipe)");
+                        }
+                }
+                /* Destroy Mutexes */
+                if (state_mutex_init) {
+                        if (pthread_mutex_destroy(&wiimote->state_mutex)) {
+                                cwiid_err(wiimote, "Mutex destroy error (state mutex)");
+                        }
+                }
+                if (rw_mutex_init) {
+                        if (pthread_mutex_destroy(&wiimote->rw_mutex)) {
+                                cwiid_err(wiimote, "Mutex destroy error (rw mutex)");
+                        }
+                }
+                if (rpt_mutex_init) {
+                        if (pthread_mutex_destroy(&wiimote->rpt_mutex)) {
+                                cwiid_err(wiimote, "Mutex destroy error (rpt mutex)");
                         }
                 }
@@ -198 +284 @@
         void *pthread_ret;
 
-        /* Cancel and join int_thread */
-        if (pthread_cancel(wiimote->int_listen_thread)) {
-                /* int could exit on it's own, so we don't care */
-                /* cwiid_err(wiimote, "Error canceling int_listen_thread"); */
-        }
-        else {
-                if (pthread_join(wiimote->int_listen_thread, &pthread_ret)) {
-                        cwiid_err(wiimote, "Error joining int_listen_thread");
-                }
-                else if (pthread_ret != PTHREAD_CANCELED) {
-                        cwiid_err(wiimote, "Invalid return value from int_listen_thread");
-                }
-        }
-
-        /* Cancel any RW operations in progress */
-        wiimote->rw_error = 1;
-        if (pthread_mutex_lock(&wiimote->rw_cond_mutex)) {
-                cwiid_err(wiimote, "Error locking rw_cond_mutex: deadlock warning");
-        }
-        else {
-                if (pthread_cond_signal(&wiimote->rw_cond)) {
-                        cwiid_err(wiimote, "Error signaling rw_cond: deadlock warning");
-                }
-                if (pthread_mutex_unlock(
-                  &wiimote->rw_cond_mutex)) {
-                        cwiid_err(wiimote, "Error unlocking rw_cond_mutex");
-                }
-        }
-
-        /* Cancel and detach dispatch_thread */
-        /* We detach to decouple dispatch (which runs the callback) from callback
-         * code - specifically, a race condition exists for gtk apps */
-        if (pthread_cancel(wiimote->dispatch_thread)) {
-                cwiid_err(wiimote, "Error canceling dispatch_thread");
-        }
-        if (pthread_detach(wiimote->dispatch_thread)) {
-                cwiid_err(wiimote, "Error detaching dispatch_thread");
+        /* Cancel and join router_thread and status_thread */
+        if (pthread_cancel(wiimote->router_thread)) {
+                /* if thread quit abnormally, would have printed it's own error */
+        }
+        if (pthread_join(wiimote->router_thread, &pthread_ret)) {
+                cwiid_err(wiimote, "Thread join error (router thread)");
+        }
+        else if (!((pthread_ret == PTHREAD_CANCELED) || (pthread_ret == NULL))) {
+                cwiid_err(wiimote, "Bad return value from router thread");
+        }
+
+        if (pthread_cancel(wiimote->status_thread)) {
+                /* if thread quit abnormally, would have printed it's own error */
+        }
+        if (pthread_join(wiimote->status_thread, &pthread_ret)) {
+                cwiid_err(wiimote, "Thread join error (status thread)");
+        }
+        else if (!((pthread_ret == PTHREAD_CANCELED) || (pthread_ret == NULL))) {
+                cwiid_err(wiimote, "Bad return value from status thread");
+        }
+
+        if (wiimote->mesg_callback) {
+                if (cancel_mesg_callback(wiimote)) {
+                        /* prints it's own errors */
+                }
+        }
+
+        if (cancel_rw(wiimote)) {
+                /* prints it's own errors */
         }
 
         /* Close sockets */
         if (close(wiimote->int_socket)) {
-                cwiid_err(wiimote, "Error closing interrupt channel");
+                cwiid_err(wiimote, "Socket close error (interrupt channel)");
         }
         if (close(wiimote->ctl_socket)) {
-                cwiid_err(wiimote, "Error closing control channel");
-        }
-
-        /* TODO: We have no way of telling if all in flight rw operations
-         * have exited yet, so for now, user must verify that all have returned
-         * before calling disconnect */
-
-        /* Destroy sync variables */
-        if (pthread_mutex_destroy(&wiimote->wiimote_mutex)) {
-                cwiid_err(wiimote, "Error destroying cwiid_mutex");
+                cwiid_err(wiimote, "Socket close error (control channel)");
+        }
+        /* Close Pipes */
+        if (close(wiimote->mesg_pipe[0]) || close(wiimote->mesg_pipe[1])) {
+                cwiid_err(wiimote, "Pipe close error (mesg pipe)");
+        }
+        if (close(wiimote->status_pipe[0]) || close(wiimote->status_pipe[1])) {
+                cwiid_err(wiimote, "Pipe close error (status pipe)");
+        }
+        if (close(wiimote->error_pipe[0]) || close(wiimote->error_pipe[1])) {
+                cwiid_err(wiimote, "Pipe close error (error pipe)");
+        }
+        if (close(wiimote->rw_pipe[0]) || close(wiimote->rw_pipe[1])) {
+                cwiid_err(wiimote, "Pipe close error (rw pipe)");
+        }
+        /* Destroy mutexes */
+        if (pthread_mutex_destroy(&wiimote->state_mutex)) {
+                cwiid_err(wiimote, "Mutex destroy error (state)");
         }
         if (pthread_mutex_destroy(&wiimote->rw_mutex)) {
-                cwiid_err(wiimote, "Error destroying rw_mutex");
-        }
-        if (pthread_cond_destroy(&wiimote->rw_cond)) {
-                cwiid_err(wiimote, "Error destroying rw_cond");
-        }
-        if (pthread_mutex_destroy(&wiimote->rw_cond_mutex)) {
-                cwiid_err(wiimote, "Error destroying rw_cond_mutex");
+                cwiid_err(wiimote, "Mutex destroy error (rw)");
+        }
+        if (pthread_mutex_destroy(&wiimote->rpt_mutex)) {
+                cwiid_err(wiimote, "Mutex destroy error (rpt)");
         }
 
@@ -267 +350 @@
         return 0;
 }
-

libcwiid/cwiid.h

@@ -16 +16 @@
  *
  *  ChangeLog:
+ *  2007-04-24 L. Donnie Smith <cwiid@abstrakraft.org>
+ *  * rewrite for API overhaul
+ *
  *  2007-04-09 L. Donnie Smith <cwiid@abstrakraft.org>
  *  * renamed wiimote to libcwiid, renamed structures accordingly
@@ -43 +46 @@
 #define CWIID_H
 
+#include <stdarg.h>
 #include <stdint.h>
 #include <bluetooth/bluetooth.h>        /* bdaddr_t */
+
+/* Flags */
+#define CWIID_FLAG_MESG_IFC             0x01
+#define CWIID_FLAG_CONTINUOUS   0x02
+#define CWIID_FLAG_REPEAT_BTN   0x04
+#define CWIID_FLAG_NONBLOCK             0x08
 
 /* Report Mode Flags */
@@ -56 +66 @@
 
 /* LED flags */
-#define CWIID_LED1_ON           0x01
-#define CWIID_LED2_ON           0x02
-#define CWIID_LED3_ON           0x04
-#define CWIID_LED4_ON           0x08
+#define CWIID_LED1_ON   0x01
+#define CWIID_LED2_ON   0x02
+#define CWIID_LED3_ON   0x04
+#define CWIID_LED4_ON   0x08
 
 /* Button flags */
@@ -71 +81 @@
 #define CWIID_BTN_RIGHT 0x0200
 #define CWIID_BTN_DOWN  0x0400
-#define CWIID_BTN_UP            0x0800
+#define CWIID_BTN_UP    0x0800
 #define CWIID_BTN_PLUS  0x1000
 
@@ -77 +87 @@
 #define CWIID_NUNCHUK_BTN_C     0x02
 
-#define CWIID_CLASSIC_BTN_UP            0x0001
+#define CWIID_CLASSIC_BTN_UP    0x0001
 #define CWIID_CLASSIC_BTN_LEFT  0x0002
-#define CWIID_CLASSIC_BTN_ZR            0x0004
+#define CWIID_CLASSIC_BTN_ZR    0x0004
 #define CWIID_CLASSIC_BTN_X             0x0008
 #define CWIID_CLASSIC_BTN_A             0x0010
 #define CWIID_CLASSIC_BTN_Y             0x0020
 #define CWIID_CLASSIC_BTN_B             0x0040
-#define CWIID_CLASSIC_BTN_ZL            0x0080
+#define CWIID_CLASSIC_BTN_ZL    0x0080
 #define CWIID_CLASSIC_BTN_R             0x0200
 #define CWIID_CLASSIC_BTN_PLUS  0x0400
@@ -95 +105 @@
 /* Data Read/Write flags */
 #define CWIID_RW_EEPROM 0x00
-#define CWIID_RW_REG            0x04
+#define CWIID_RW_REG    0x04
 #define CWIID_RW_DECODE 0x01
 
 /* Maximum Data Read Length */
 #define CWIID_MAX_READ_LEN      0xFFFF
+
+/* Array Index Defs */
+#define CWIID_X         0
+#define CWIID_Y         1
+#define CWIID_Z         2
+
+/* Acc Defs */
+#define CWIID_ACC_MAX   0xFF
 
 /* IR Defs */
@@ -120 +138 @@
 #define CWIID_MAX_MESG_COUNT    5
 
+/* Enumerations */
 enum cwiid_command {
         CWIID_CMD_STATUS,
@@ -146 +165 @@
 
 enum cwiid_error {
+        CWIID_ERROR_NONE,
         CWIID_ERROR_DISCONNECT,
-        CWIID_ERROR_COMM,
-};
-
+        CWIID_ERROR_COMM
+};
+
+/* Message Structs */
 struct cwiid_status_mesg {
         enum cwiid_mesg_type type;
         uint8_t battery;
-        enum cwiid_ext_type extension;
+        enum cwiid_ext_type ext_type;
 };      
 
@@ -163 +184 @@
 struct cwiid_acc_mesg {
         enum cwiid_mesg_type type;
-        uint8_t x;
-        uint8_t y;
-        uint8_t z;
+        uint8_t acc[3];
 };
 
 struct cwiid_ir_src {
-        int valid;
-        uint16_t x;
-        uint16_t y;
+        char valid;
+        uint16_t pos[2];
         int8_t size;
 };
@@ -182 +200 @@
 struct cwiid_nunchuk_mesg {
         enum cwiid_mesg_type type;
-        uint8_t stick_x;
-        uint8_t stick_y;
-        uint8_t acc_x;
-        uint8_t acc_y;
-        uint8_t acc_z;
+        uint8_t stick[2];
+        uint8_t acc[3];
         uint8_t buttons;
 };
@@ -192 +207 @@
 struct cwiid_classic_mesg {
         enum cwiid_mesg_type type;
-        uint8_t l_stick_x;
-        uint8_t l_stick_y;
-        uint8_t r_stick_x;
-        uint8_t r_stick_y;
+        uint8_t l_stick[2];
+        uint8_t r_stick[2];
         uint8_t l;
         uint8_t r;
@@ -217 +230 @@
 };
 
+/* State Structs */
+struct nunchuk_state {
+        uint8_t stick[2];
+        uint8_t acc[3];
+        uint8_t buttons;
+};
+
+struct classic_state {
+        uint8_t l_stick[2];
+        uint8_t r_stick[2];
+        uint8_t l;
+        uint8_t r;
+        uint16_t buttons;
+};
+
+union ext_state {
+        struct nunchuk_state nunchuk;
+        struct classic_state classic;
+};
+
+struct cwiid_state {
+        uint8_t rpt_mode;
+        uint8_t led;
+        uint8_t rumble;
+        uint8_t battery;
+        uint16_t buttons;
+        uint8_t acc[3];
+        struct cwiid_ir_src ir_src[CWIID_IR_SRC_COUNT];
+        enum cwiid_ext_type ext_type;
+        union ext_state ext;
+        enum cwiid_error error;
+};
+
+/* Typedefs */
 typedef struct wiimote cwiid_wiimote_t;
 
-typedef void cwiid_mesg_callback_t(int, int, union cwiid_mesg* []);
-typedef void cwiid_err_t(int, const char *, ...);
-
-/* getinfo flags */
+typedef void cwiid_mesg_callback_t(cwiid_wiimote_t *, int,
+                                   union cwiid_mesg []);
+typedef void cwiid_err_t(cwiid_wiimote_t *, const char *, va_list ap);
+
+/* get_bdinfo */
 #define BT_NO_WIIMOTE_FILTER 0x01
 #define BT_NAME_LEN 32
@@ -236 +284 @@
 #endif
 
+/* Error reporting (library wide) */
 int cwiid_set_err(cwiid_err_t *err);
-cwiid_wiimote_t *cwiid_connect(bdaddr_t *bdaddr,
-                               cwiid_mesg_callback_t *mesg_callback,
-                               int *id);
+
+/* Connection */
+cwiid_wiimote_t *cwiid_connect(bdaddr_t *bdaddr, int flags);
 int cwiid_disconnect(cwiid_wiimote_t *wiimote);
+
+int cwiid_get_id(cwiid_wiimote_t *wiimote);
+int cwiid_set_data(cwiid_wiimote_t *wiimote, const void *data);
+const void *cwiid_get_data(cwiid_wiimote_t *wiimote);
+int cwiid_enable(cwiid_wiimote_t *wiimote, int flags);
+int cwiid_disable(cwiid_wiimote_t *wiimote, int flags);
+
+/* Interfaces */
+int cwiid_set_mesg_callback(cwiid_wiimote_t *wiimote,
+                       cwiid_mesg_callback_t *callback);
+int cwiid_get_mesg(cwiid_wiimote_t *wiimote, int *mesg_count,
+                   union cwiid_mesg *mesg[]);
+int cwiid_get_state(cwiid_wiimote_t *wiimote, struct cwiid_state *state);
+
+/* Operations */
 int cwiid_command(cwiid_wiimote_t *wiimote, enum cwiid_command command,
-                  uint8_t flags);
+                  int flags);
 int cwiid_read(cwiid_wiimote_t *wiimote, uint8_t flags, uint32_t offset,
                uint16_t len, void *data);
@@ -248 +312 @@
                 uint16_t len, const void *data);
 /* int cwiid_beep(cwiid_wiimote_t *wiimote); */
+
+/* HCI functions */
 int cwiid_get_bdinfo_array(int dev_id, unsigned int timeout, int max_bdinfo,
                            struct cwiid_bdinfo **bdinfo, uint8_t flags);
@@ -257 +323 @@
 
 #endif
-

libcwiid/cwiid_internal.h

@@ -16 +16 @@
  *
  *  ChangeLog:
+ *  2007-04-24 L. Donnie Smith <cwiid@abstrakraft.org>
+ *  * rewrite for API overhaul
+ *
  *  2007-04-09 L. Donnie Smith <cwiid@abstrakraft.org>
  *  * renamed wiimote to libcwiid, renamed structures accordingly
@@ -38 +41 @@
 #include <stdint.h>
 #include <pthread.h>
+#include <sys/types.h>  /* ssize_t */
 #include "cwiid.h"
 
@@ -117 +121 @@
 #define DECODE(a)       (((a ^ 0x17)+0x17)&0xFF)
 
+/* Write Sequences */
 enum write_seq_type {
         WRITE_SEQ_RPT,
@@ -123 +128 @@
 
 /* send_report flags */
-#define SEND_RPT_NO_RUMBLE      0x01
+#define SEND_RPT_NO_RUMBLE    0x01
 
 struct write_seq {
@@ -135 +140 @@
 #define SEQ_LEN(seq) (sizeof(seq)/sizeof(struct write_seq))
 
+/* Message arrays */
+struct mesg_array {
+        uint8_t count;
+        union cwiid_mesg array[CWIID_MAX_MESG_COUNT];
+};
+
+/* RW State/Mesg */
 enum rw_status {
-        RW_NONE,
-        RW_PENDING,
-        RW_READY
-};
-
-struct mesg_array {
-        int count;
-        union cwiid_mesg *mesg[CWIID_MAX_MESG_COUNT];
-};
-
+        RW_IDLE,
+        RW_READ,
+        RW_WRITE,
+        RW_CANCEL
+};
+
+struct rw_mesg {
+        enum rw_status type;
+        uint8_t error;
+        uint32_t offset;
+        uint8_t len;
+        char data[16];
+};
+
+/* Wiimote struct */
 struct wiimote {
-        int id;
+        int flags;
         int ctl_socket;
         int int_socket;
-        uint8_t led_rumble_state;
-        uint8_t rpt_mode_flags;
-        uint16_t buttons;
-        enum cwiid_ext_type extension;
+        pthread_t router_thread;
+        pthread_t status_thread;
+        pthread_t mesg_callback_thread;
+        int mesg_pipe[2];
+        int status_pipe[2];
+        int error_pipe[2];
+        int rw_pipe[2];
+        struct cwiid_state state;
+        enum rw_status rw_status;
         cwiid_mesg_callback_t *mesg_callback;
-        pthread_t int_listen_thread;
-        pthread_t dispatch_thread;
-        struct queue *dispatch_queue;
-        pthread_mutex_t wiimote_mutex;
+        pthread_mutex_t state_mutex;
         pthread_mutex_t rw_mutex;
-        pthread_cond_t rw_cond;
-        pthread_mutex_t rw_cond_mutex;
-        enum rw_status rw_status;
-        char rw_error;
-        void *read_buf;
-        uint16_t read_len;
-        uint16_t read_received;
+        pthread_mutex_t rpt_mutex;
+        int id;
+        const void *data;
 };
 
 /* prototypes */
-void *int_listen(struct wiimote *wiimote);
-void *dispatch(struct wiimote *wiimote);
-
-int update_rpt_mode(struct wiimote *wiimote, int8_t flags);
-
+/* thread.c */
+void *router_thread(struct wiimote *wiimote);
+void *status_thread(struct wiimote *wiimote);
+void *mesg_callback_thread(struct wiimote *wiimote);
+
+/* util.c */
 void cwiid_err(struct wiimote *wiimote, const char *str, ...);
 int verify_handshake(struct wiimote *wiimote);
@@ -181 +197 @@
 int exec_write_seq(struct wiimote *wiimote, unsigned int len,
                    struct write_seq *seq);
-void free_mesg_array(struct mesg_array *array);
+int full_read(int fd, void *buf, size_t len);
+int write_mesg_array(struct wiimote *wiimote, struct mesg_array *ma);
+int read_mesg_array(int fd, struct mesg_array *ma);
+int cancel_rw(struct wiimote *wiimote);
+int cancel_mesg_callback(struct wiimote *wiimote);
+
+/* process.c */
+int process_error(struct wiimote *, ssize_t);
+int process_status(struct wiimote *, const unsigned char *,
+                   struct mesg_array *);
+int process_btn(struct wiimote *, const unsigned char *, struct mesg_array *);
+int process_acc(struct wiimote *, const unsigned char *, struct mesg_array *);
+int process_ir10(struct wiimote *, const unsigned char *, struct mesg_array *);
+int process_ir12(struct wiimote *, const unsigned char *, struct mesg_array *);
+int process_ext(struct wiimote *, unsigned char *, unsigned char,
+                struct mesg_array *);
+int process_read(struct wiimote *, unsigned char *);
+int process_write(struct wiimote *, unsigned char *);
+
+/* state.c */
+int update_state(struct wiimote *wiimote, struct mesg_array *ma);
+int update_rpt_mode(struct wiimote *wiimote, int8_t rpt_mode);
 
 #endif
-

libcwiid/util.c

@@ -16 +16 @@
  *
  *  ChangeLog:
+ *  2007-04-24 L. Donnie Smith <cwiid@abstrakraft.org>
+ *  * rewrite for API overhaul
+ *
  *  2007-04-09 L. Donnie Smith <cwiid@abstrakraft.org>
  *  * renamed wiimote to libcwiid, renamed structures accordingly
@@ -42 +45 @@
  */
 
+#include <errno.h>
 #include <stdarg.h>
 #include <stdint.h>
@@ -47 +51 @@
 #include <stdlib.h>
 #include <string.h>
+#include <fcntl.h>
 #include <unistd.h>
 #include "cwiid_internal.h"
@@ -63 +68 @@
 }
 
-static void cwiid_err_default(int id, const char *str, ...)
-{
-        va_list ap;
-
-        va_start(ap, str);
+static void cwiid_err_default(struct wiimote *wiimote, const char *str,
+                              va_list ap)
+{
         vfprintf(stderr, str, ap);
         fprintf(stderr, "\n");
-        va_end(ap);
 }
 
@@ -80 +82 @@
                 va_start(ap, str);
                 if (wiimote) {
-                        (*cwiid_err_func)(wiimote->id, str, ap);
+                        (*cwiid_err_func)(wiimote, str, ap);
                 }
                 else {
-                        (*cwiid_err_func)(-1, str, ap);
+                        (*cwiid_err_func)(NULL, str, ap);
                 }
                 va_end(ap);
@@ -93 +95 @@
         unsigned char handshake;
         if (read(wiimote->ctl_socket, &handshake, 1) != 1) {
-                cwiid_err(wiimote, "Error on read handshake");
+                cwiid_err(wiimote, "Socket read error (handshake)");
                 return -1;
         }
@@ -122 +124 @@
         memcpy(buf+2, data, len);
         if (!(flags & SEND_RPT_NO_RUMBLE)) {
-                buf[2] |= wiimote->led_rumble_state & 0x01;
+                buf[2] |= wiimote->state.rumble;
         }
 
@@ -150 +152 @@
                 case WRITE_SEQ_MEM:
                         if (cwiid_write(wiimote, seq[i].flags, seq[i].report_offset,
-                                          seq[i].len, seq[i].data)) {
+                                        seq[i].len, seq[i].data)) {
                                 return -1;
                         }
@@ -160 +162 @@
 }
 
-void free_mesg_array(struct mesg_array *array)
-{
-        int i;
-
-        for (i=0; i < array->count; i++) {
-                free(array->mesg[i]);
-        }
-        free(array);
-}
-
+int full_read(int fd, void *buf, size_t len)
+{
+        ssize_t last_len = 0;
+
+        do {
+                if ((last_len = read(fd, buf, len)) == -1) {
+                        return -1;
+                }
+                len -= last_len;
+                buf += last_len;
+        } while (len > 0);
+
+        return 0;
+}
+
+int write_mesg_array(struct wiimote *wiimote, struct mesg_array *ma)
+{
+        ssize_t len = (void *)&ma->array[ma->count] - (void *)ma;
+        int ret = 0;
+
+        /* This must remain a single write operation to ensure atomicity,
+         * which is required to avoid mutexes and cancellation issues */
+        if (write(wiimote->mesg_pipe[1], ma, len) != len) {
+                if (errno == EAGAIN) {
+                        cwiid_err(wiimote, "Mesg pipe overflow");
+                        if (fcntl(wiimote->mesg_pipe[1], F_SETFL, 0)) {
+                                cwiid_err(wiimote, "File control error (mesg pipe)");
+                                ret = -1;
+                        }
+                        else {
+                                if (write(wiimote->mesg_pipe[1], ma, len) != len) {
+                                        cwiid_err(wiimote, "Pipe write error (mesg pipe)");
+                                        ret = -1;
+                                }
+                                if (fcntl(wiimote->mesg_pipe[1], F_SETFL, O_NONBLOCK)) {
+                                        cwiid_err(wiimote, "File control error (mesg pipe");
+                                }
+                        }
+                }
+                else {
+                        cwiid_err(wiimote, "Pipe write error (mesg pipe)");
+                        ret = -1;
+                }
+        }
+
+        return ret;
+}
+
+int read_mesg_array(int fd, struct mesg_array *ma)
+{
+        ssize_t len;
+
+        /* there may be padding after ma->count */
+        len = (void *)&ma->array[0] - (void *)ma;
+        if (full_read(fd, ma, len)) {
+                return -1;
+        }
+
+        len = ma->count * sizeof ma->array[0];
+        if (full_read(fd, &ma->array[0], len)) {
+                return -1;
+        }
+
+        return 0;
+}
+
+int cancel_rw(struct wiimote *wiimote)
+{
+        struct rw_mesg rw_mesg;
+
+        rw_mesg.type = RW_CANCEL;
+
+        if (write(wiimote->rw_pipe[1], &rw_mesg, sizeof rw_mesg) !=
+          sizeof rw_mesg) {
+                cwiid_err(wiimote, "Pipe write error (rw)");
+                return -1;
+        }
+
+        return 0;
+}
+
+int cancel_mesg_callback(struct wiimote *wiimote)
+{
+        int ret = 0;
+
+        if (pthread_cancel(wiimote->mesg_callback_thread)) {
+                cwiid_err(wiimote, "Thread cancel error (callback thread)");
+                ret = -1;
+        }
+
+        if (pthread_detach(wiimote->mesg_callback_thread)) {
+                cwiid_err(wiimote, "Thread detach error (callback thread)");
+                ret = -1;
+        }
+
+        return ret;
+}

wmdemo/wmdemo.c

@@ -22 +22 @@
                : ((bf) | (b))
 
+#define MENU \
+        "1: toggle LED 1\n" \
+        "2: toggle LED 2\n" \
+        "3: toggle LED 3\n" \
+        "4: toggle LED 4\n" \
+        "5: toggle rumble\n" \
+        "a: toggle accelerometer reporting\n" \
+        "b: toggle button reporting\n" \
+        "e: toggle extension reporting\n" \
+        "i: toggle ir reporting\n" \
+        "m: toggle messages\n" \
+        "p: print this menu\n" \
+        "r: request status message ((t) enables callback output)\n" \
+        "s: print current state\n" \
+        "t: toggle status reporting\n" \
+        "x: exit\n"
+
 void set_led_state(cwiid_wiimote_t *wiimote, unsigned char led_state);
 void set_rpt_mode(cwiid_wiimote_t *wiimote, unsigned char rpt_mode);
+void print_state(struct cwiid_state *state);
 
 cwiid_err_t err;
-void err(int id, const char *s, ...)
-{
-        va_list ap;
-
-        va_start(ap, s);
-        printf("%d:", id);
+void err(cwiid_wiimote_t *wiimote, const char *s, va_list ap)
+{
+        if (wiimote) printf("%d:", cwiid_get_id(wiimote));
+        else printf("-1:");
         vprintf(s, ap);
         printf("\n");
-        va_end(ap);
-}
-
-/* wiimote handle */
-cwiid_wiimote_t *wiimote;
+}
 
 int main(int argc, char *argv[])
 {
+        cwiid_wiimote_t *wiimote;       /* wiimote handle */
+        struct cwiid_state state;       /* wiimote state */
         bdaddr_t bdaddr;        /* bluetooth device address */
-        int cwiid_id;           /* wiimote id: useful for handling multiple wiimotes
-                               with a single callback */
+        unsigned char mesg = 0;
         unsigned char led_state = 0;
         unsigned char rpt_mode = 0;
         unsigned char rumble = 0;
         int exit = 0;
-        char *str_addr;
-        int c;
 
         cwiid_set_err(err);
 
-        
         /* Connect to address given on command-line, if present */
         if (argc > 1) {
@@ -65 +75 @@
         /* Connect to the wiimote */
         printf("Put Wiimote in discoverable mode now (press 1+2)...\n");
-        if (!(wiimote = cwiid_connect(&bdaddr, cwiid_callback, &cwiid_id))) {
+        if (!(wiimote = cwiid_connect(&bdaddr, 0))) {
                 fprintf(stderr, "Unable to connect to wiimote\n");
                 return -1;
         }
+        if (cwiid_set_mesg_callback(wiimote, cwiid_callback)) {
+                fprintf(stderr, "Unable to set message callback\n");
+        }
+
+        printf("Note: To demonstrate the new API interfaces, wmdemo no longer "
+               "enables messages by default.\n"
+                   "Output can be gathered through the new state-based interface (s), "
+               "or by enabling the messages interface (c).\n");
 
         /* Menu */
-        printf("1: toggle LED 1\n"
-               "2: toggle LED 2\n"
-               "3: toggle LED 3\n"
-               "4: toggle LED 4\n"
-               "a: toggle accelerometer output\n"
-               "b: toggle button output\n"
-               "e: toggle extension output\n"
-               "i: toggle ir output\n"
-               "r: toggle rumble\n"
-               "s: request status message (use t to turn on output)\n"
-               "t: toggle status output\n"
-               "x: exit\n");
+        printf("%s", MENU);
 
         while (!exit) {
@@ -102 +109 @@
                         set_led_state(wiimote, led_state);
                         break;
+                case '5':
+                        toggle_bit(rumble, 1);
+                        if (cwiid_command(wiimote, CWIID_CMD_RUMBLE, rumble)) {
+                                fprintf(stderr, "Error setting rumble\n");
+                        }
+                        break;
                 case 'a':
                         toggle_bit(rpt_mode, CWIID_RPT_ACC);
@@ -123 +136 @@
                         set_rpt_mode(wiimote, rpt_mode);
                         break;
+                case 'm':
+                        if (!mesg) {
+                                if (cwiid_enable(wiimote, CWIID_FLAG_MESG_IFC)) {
+                                        fprintf(stderr, "Error enabling messages\n");
+                                }
+                                else {
+                                        mesg = 1;
+                                }
+                        }
+                        else {
+                                if (cwiid_disable(wiimote, CWIID_FLAG_MESG_IFC)) {
+                                        fprintf(stderr, "Error disabling message\n");
+                                }
+                                else {
+                                        mesg = 0;
+                                }
+                        }
+                        break;
+                case 'p':
+                        printf("%s", MENU);
+                        break;
                 case 'r':
-                        toggle_bit(rumble, 1);
-                        if (cwiid_command(wiimote, CWIID_CMD_RUMBLE, rumble)) {
-                                fprintf(stderr, "Error setting rumble\n");
-                        }
-                        break;
-                case 's':
                         if (cwiid_command(wiimote, CWIID_CMD_STATUS, 0)) {
                                 fprintf(stderr, "Error requesting status message\n");
                         }
+                        break;
+                case 's':
+                        if (cwiid_get_state(wiimote, &state)) {
+                                fprintf(stderr, "Error getting state\n");
+                        }
+                        print_state(&state);
                         break;
                 case 't':
@@ -167 +201 @@
         if (cwiid_command(wiimote, CWIID_CMD_RPT_MODE, rpt_mode)) {
                 fprintf(stderr, "Error setting report mode\n");
+        }
+}
+
+void print_state(struct cwiid_state *state)
+{
+        int i;
+        int valid_source = 0;
+
+        printf("Report Mode:");
+        if (state->rpt_mode & CWIID_RPT_STATUS) printf(" STATUS");
+        if (state->rpt_mode & CWIID_RPT_BTN) printf(" BTN");
+        if (state->rpt_mode & CWIID_RPT_ACC) printf(" ACC");
+        if (state->rpt_mode & CWIID_RPT_IR) printf(" IR");
+        if (state->rpt_mode & CWIID_RPT_NUNCHUK) printf(" NUNCHUK");
+        if (state->rpt_mode & CWIID_RPT_CLASSIC) printf(" CLASSIC");
+        printf("\n");
+        
+        printf("Active LEDs:");
+        if (state->led & CWIID_LED1_ON) printf(" 1");
+        if (state->led & CWIID_LED2_ON) printf(" 2");
+        if (state->led & CWIID_LED3_ON) printf(" 3");
+        if (state->led & CWIID_LED4_ON) printf(" 4");
+        printf("\n");
+
+        printf("Rumble: %s\n", state->rumble ? "On" : "Off");
+
+        printf("Battery: %d%%\n",
+               (int)(100.0 * state->battery / CWIID_BATTERY_MAX));
+
+        printf("Buttons: %X\n", state->buttons);
+
+        printf("Acc: x=%d y=%d z=%d\n", state->acc[CWIID_X], state->acc[CWIID_Y],
+               state->acc[CWIID_Z]);
+
+        printf("IR: ");
+        for (i = 0; i < CWIID_IR_SRC_COUNT; i++) {
+                if (state->ir_src[i].valid) {
+                        valid_source = 1;
+                        printf("(%d,%d) ", state->ir_src[i].pos[CWIID_X],
+                                           state->ir_src[i].pos[CWIID_Y]);
+                }
+        }
+        if (!valid_source) {
+                printf("no sources detected");
+        }
+        printf("\n");
+
+        switch (state->ext_type) {
+        case CWIID_EXT_NONE:
+                printf("No extension\n");
+                break;
+        case CWIID_EXT_UNKNOWN:
+                printf("Unknown extension attached\n");
+                break;
+        case CWIID_EXT_NUNCHUK:
+                printf("Nunchuk: btns=%.2X stick=(%d,%d) acc.x=%d acc.y=%d "
+                       "acc.z=%d\n", state->ext.nunchuk.buttons,
+                       state->ext.nunchuk.stick[CWIID_X],
+                       state->ext.nunchuk.stick[CWIID_Y],
+                       state->ext.nunchuk.acc[CWIID_X],
+                       state->ext.nunchuk.acc[CWIID_Y],
+                       state->ext.nunchuk.acc[CWIID_Z]);
+                break;
+        case CWIID_EXT_CLASSIC:
+                printf("Classic: btns=%.4X l_stick=(%d,%d) r_stick=(%d,%d) "
+                       "l=%d r=%d\n", state->ext.classic.buttons,
+                       state->ext.classic.l_stick[CWIID_X],
+                       state->ext.classic.l_stick[CWIID_Y],
+                       state->ext.classic.r_stick[CWIID_X],
+                       state->ext.classic.r_stick[CWIID_Y],
+                       state->ext.classic.l, state->ext.classic.r);
+                break;
         }
 }
@@ -180 +286 @@
  * The id is to distinguish between multiple wiimotes using the same callback.
  * */
-void cwiid_callback(int id, int mesg_count, union cwiid_mesg *mesg[])
+void cwiid_callback(cwiid_wiimote_t *wiimote, int mesg_count,
+                    union cwiid_mesg mesg[])
 {
         int i, j;
@@ -187 +294 @@
         for (i=0; i < mesg_count; i++)
         {
-                switch (mesg[i]->type) {
+                switch (mesg[i].type) {
                 case CWIID_MESG_STATUS:
                         printf("Status Report: battery=%d extension=",
-                               mesg[i]->status_mesg.battery);
-                        switch (mesg[i]->status_mesg.extension) {
+                               mesg[i].status_mesg.battery);
+                        switch (mesg[i].status_mesg.ext_type) {
                         case CWIID_EXT_NONE:
                                 printf("none");
@@ -208 +315 @@
                         break;
                 case CWIID_MESG_BTN:
-                        printf("Button Report: %.4X\n", mesg[i]->btn_mesg.buttons);
+                        printf("Button Report: %.4X\n", mesg[i].btn_mesg.buttons);
                         break;
                 case CWIID_MESG_ACC:
-                        printf("Acc Report: x=%d, y=%d, z=%d\n", mesg[i]->acc_mesg.x,
-                                                                 mesg[i]->acc_mesg.y,
-                                                                 mesg[i]->acc_mesg.z);
+                        printf("Acc Report: x=%d, y=%d, z=%d\n",
+                   mesg[i].acc_mesg.acc[CWIID_X],
+                               mesg[i].acc_mesg.acc[CWIID_Y],
+                               mesg[i].acc_mesg.acc[CWIID_Z]);
                         break;
                 case CWIID_MESG_IR:
@@ -219 +327 @@
                         valid_source = 0;
                         for (j = 0; j < CWIID_IR_SRC_COUNT; j++) {
-                                if (mesg[i]->ir_mesg.src[j].valid) {
+                                if (mesg[i].ir_mesg.src[j].valid) {
                                         valid_source = 1;
-                                        printf("(%d,%d) ", mesg[i]->ir_mesg.src[j].x,
-                                                           mesg[i]->ir_mesg.src[j].y);
+                                        printf("(%d,%d) ", mesg[i].ir_mesg.src[j].pos[CWIID_X],
+                                                           mesg[i].ir_mesg.src[j].pos[CWIID_Y]);
                                 }
                         }
@@ -232 +340 @@
                 case CWIID_MESG_NUNCHUK:
                         printf("Nunchuk Report: btns=%.2X stick=(%d,%d) acc.x=%d acc.y=%d "
-                               "acc.z=%d\n", mesg[i]->nunchuk_mesg.buttons,
-                               mesg[i]->nunchuk_mesg.stick_x,
-                               mesg[i]->nunchuk_mesg.stick_y, mesg[i]->nunchuk_mesg.acc_x,
-                               mesg[i]->nunchuk_mesg.acc_y, mesg[i]->nunchuk_mesg.acc_z);
+                               "acc.z=%d\n", mesg[i].nunchuk_mesg.buttons,
+                               mesg[i].nunchuk_mesg.stick[CWIID_X],
+                               mesg[i].nunchuk_mesg.stick[CWIID_Y],
+                               mesg[i].nunchuk_mesg.acc[CWIID_X],
+                               mesg[i].nunchuk_mesg.acc[CWIID_Y],
+                               mesg[i].nunchuk_mesg.acc[CWIID_Z]);
                         break;
                 case CWIID_MESG_CLASSIC:
                         printf("Classic Report: btns=%.4X l_stick=(%d,%d) r_stick=(%d,%d) "
-                               "l=%d r=%d\n", mesg[i]->classic_mesg.buttons,
-                               mesg[i]->classic_mesg.l_stick_x,
-                               mesg[i]->classic_mesg.l_stick_y,
-                               mesg[i]->classic_mesg.r_stick_x,
-                               mesg[i]->classic_mesg.r_stick_y,
-                               mesg[i]->classic_mesg.l, mesg[i]->classic_mesg.r);
+                               "l=%d r=%d\n", mesg[i].classic_mesg.buttons,
+                               mesg[i].classic_mesg.l_stick[CWIID_X],
+                               mesg[i].classic_mesg.l_stick[CWIID_Y],
+                               mesg[i].classic_mesg.r_stick[CWIID_X],
+                               mesg[i].classic_mesg.r_stick[CWIID_Y],
+                               mesg[i].classic_mesg.l, mesg[i].classic_mesg.r);
                         break;
                 case CWIID_MESG_ERROR:

wmgui/main.c

@@ -16 +16 @@
  *
  *  ChangeLog:
+ *  2007-04-24 L. Donnie Smith <cwiid@abstrakraft.org>
+ *  * updated for API overhaul
+ *
  *  2007-04-09 L. Donnie Smith <cwiid@abstrakraft.org>
  *  * updated for libcwiid rename
@@ -577 +580 @@
 
         for (i=0; i < CWIID_IR_SRC_COUNT; i++) {
-                ir_data.src[i].x = -1;
-                ir_data.src[i].y = -1;
+                ir_data.src[i].pos[CWIID_X] = -1;
+                ir_data.src[i].pos[CWIID_Y] = -1;
                 ir_data.src[i].size = -1;
         }
@@ -636 +639 @@
                 "Put Wiimote in discoverable mode (press 1+2) and press OK",
                  GTK_WINDOW(winMain));
-        if ((wiimote = cwiid_connect(&bdaddr, &cwiid_callback, NULL)) == NULL) {
+        if ((wiimote = cwiid_connect(&bdaddr, CWIID_FLAG_MESG_IFC)) == NULL) {
                 message(GTK_MESSAGE_ERROR, "Unable to connect", GTK_WINDOW(winMain));
+                status("No connection");
+        }
+        else if (cwiid_set_mesg_callback(wiimote, &cwiid_callback)) {
+                message(GTK_MESSAGE_ERROR, "Error setting callback",
+                        GTK_WINDOW(winMain));
+                if (cwiid_disconnect(wiimote)) {
+                        message(GTK_MESSAGE_ERROR, "Error on disconnect",
+                                GTK_WINDOW(winMain));
+                }
+                wiimote = NULL;
                 status("No connection");
         }
@@ -783 +796 @@
                                      drawIR->style->fg_gc[GTK_WIDGET_STATE(drawIR)],
                                      TRUE,
-                                                 ir_data.src[i].x*width/CWIID_IR_X_MAX,
-                                                 height - ir_data.src[i].y*height/CWIID_IR_Y_MAX,
+                                                 ir_data.src[i].pos[CWIID_X] * width / CWIID_IR_X_MAX,
+                                                 height - ir_data.src[i].pos[CWIID_Y] * height /
+                                              CWIID_IR_Y_MAX,
                                                  size, size,
                                                  0, 64 * 360);
@@ -1002 +1016 @@
 
 #define BATTERY_STR_LEN 14      /* "Battery: 100%" + '\0' */
-void cwiid_callback(int id, int mesg_count, union cwiid_mesg *mesg_array[])
+void cwiid_callback(cwiid_wiimote_t *wiimote, int mesg_count,
+                    union cwiid_mesg mesg_array[])
 {
         int i;
@@ -1012 +1027 @@
         gdk_threads_enter();
         for (i=0; i < mesg_count; i++) {
-                switch (mesg_array[i]->type) {
+                switch (mesg_array[i].type) {
                 case CWIID_MESG_STATUS:
                         snprintf(battery, BATTERY_STR_LEN,"Battery:%d%%",
-                                 (int) (100.0 * mesg_array[i]->status_mesg.battery /
+                                 (int) (100.0 * mesg_array[i].status_mesg.battery /
                                         CWIID_BATTERY_MAX));
                         gtk_statusbar_push(GTK_STATUSBAR(statBattery), 0, battery);
-                        switch (mesg_array[i]->status_mesg.extension) {
+                        switch (mesg_array[i].status_mesg.ext_type) {
                         case CWIID_EXT_NONE:
                                 ext_str = "No extension";
@@ -1051 +1066 @@
                         clear_nunchuk_widgets();
                         clear_classic_widgets();
-                        ext_type = mesg_array[i]->status_mesg.extension;
+                        ext_type = mesg_array[i].status_mesg.ext_type;
                         break;
                 case CWIID_MESG_BTN:
-                        cwiid_btn(&mesg_array[i]->btn_mesg);
+                        cwiid_btn(&mesg_array[i].btn_mesg);
                         break;
                 case CWIID_MESG_ACC:
-                        cwiid_acc(&mesg_array[i]->acc_mesg);
+                        cwiid_acc(&mesg_array[i].acc_mesg);
                         break;
                 case CWIID_MESG_IR:
-                        cwiid_ir(&mesg_array[i]->ir_mesg);
+                        cwiid_ir(&mesg_array[i].ir_mesg);
                         break;
                 case CWIID_MESG_NUNCHUK:
-                        cwiid_nunchuk(&mesg_array[i]->nunchuk_mesg);
+                        cwiid_nunchuk(&mesg_array[i].nunchuk_mesg);
                         break;
                 case CWIID_MESG_CLASSIC:
-                        cwiid_classic(&mesg_array[i]->classic_mesg);
+                        cwiid_classic(&mesg_array[i].classic_mesg);
                         break;
                 case CWIID_MESG_ERROR:
@@ -1113 +1128 @@
         
         if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(chkAcc))) {
-                g_snprintf(str, LBLVAL_LEN, "%X", mesg->x);
+                g_snprintf(str, LBLVAL_LEN, "%X", mesg->acc[CWIID_X]);
                 gtk_label_set_text(GTK_LABEL(lblAccXVal), str);
                 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progAccX),
-                                              (double)mesg->x/0xFF);
-                g_snprintf(str, LBLVAL_LEN, "%X", mesg->y);
+                                              (double)mesg->acc[CWIID_X]/0xFF);
+                g_snprintf(str, LBLVAL_LEN, "%X", mesg->acc[CWIID_Y]);
                 gtk_label_set_text(GTK_LABEL(lblAccYVal), str);
                 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progAccY),
-                                              (double)mesg->y/0xFF);
-                g_snprintf(str, LBLVAL_LEN, "%X", mesg->z);
+                                              (double)mesg->acc[CWIID_Y]/0xFF);
+                g_snprintf(str, LBLVAL_LEN, "%X", mesg->acc[CWIID_Z]);
                 gtk_label_set_text(GTK_LABEL(lblAccZVal), str);
                 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progAccZ),
-                                              (double)mesg->z/0xFF);
-
-                a_x = ((double)mesg->x - acc_zero.x) /
+                                              (double)mesg->acc[CWIID_Z]/0xFF);
+
+                a_x = ((double)mesg->acc[CWIID_X] - acc_zero.x) /
                       (acc_one.x - acc_zero.x);
-                a_y = ((double)mesg->y - acc_zero.y) /
+                a_y = ((double)mesg->acc[CWIID_Y] - acc_zero.y) /
                       (acc_one.y - acc_zero.y);
-                a_z = ((double)mesg->z - acc_zero.z) /
+                a_z = ((double)mesg->acc[CWIID_Z] - acc_zero.z) /
                       (acc_one.z - acc_zero.z);
                 a = sqrt(pow(a_x,2)+pow(a_y,2)+pow(a_z,2));
@@ -1173 +1188 @@
 
                 nc_stick.valid = 1;
-                nc_stick.x = mesg->stick_x;
-                nc_stick.y = mesg->stick_y;
+                nc_stick.x = mesg->stick[CWIID_X];
+                nc_stick.y = mesg->stick[CWIID_Y];
                 gtk_widget_queue_draw(drawNCStick);
 
-                g_snprintf(str, LBLVAL_LEN, "%X", mesg->acc_x);
+                g_snprintf(str, LBLVAL_LEN, "%X", mesg->acc[CWIID_X]);
                 gtk_label_set_text(GTK_LABEL(lblNCAccXVal), str);
                 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progNCAccX),
-                                              (double)mesg->acc_x/0xFF);
-                g_snprintf(str, LBLVAL_LEN, "%X", mesg->acc_y);
+                                              (double)mesg->acc[CWIID_X]/0xFF);
+                g_snprintf(str, LBLVAL_LEN, "%X", mesg->acc[CWIID_Y]);
                 gtk_label_set_text(GTK_LABEL(lblNCAccYVal), str);
                 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progNCAccY),
-                                              (double)mesg->acc_y/0xFF);
-                g_snprintf(str, LBLVAL_LEN, "%X", mesg->acc_z);
+                                              (double)mesg->acc[CWIID_Y]/0xFF);
+                g_snprintf(str, LBLVAL_LEN, "%X", mesg->acc[CWIID_Z]);
                 gtk_label_set_text(GTK_LABEL(lblNCAccZVal), str);
                 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progNCAccZ),
-                                              (double)mesg->acc_z/0xFF);
+                                              (double)mesg->acc[CWIID_Z]/0xFF);
 
                 /* TODO: get nunchuk calibration */
-                a_x = ((double)mesg->acc_x - nc_acc_zero.x) /
+                a_x = ((double)mesg->acc[CWIID_X] - nc_acc_zero.x) /
                       (nc_acc_one.x - nc_acc_zero.x);
-                a_y = ((double)mesg->acc_y - nc_acc_zero.y) /
+                a_y = ((double)mesg->acc[CWIID_Y] - nc_acc_zero.y) /
                       (nc_acc_one.y - nc_acc_zero.y);
-                a_z = ((double)mesg->acc_z - nc_acc_zero.z) /
+                a_z = ((double)mesg->acc[CWIID_Z] - nc_acc_zero.z) /
                       (nc_acc_one.z - nc_acc_zero.z);
                 a = sqrt(pow(a_x,2)+pow(a_y,2)+pow(a_z,2));
@@ -1248 +1263 @@
 
                 cc_l_stick.valid = 1;
-                cc_l_stick.x = mesg->l_stick_x;
-                cc_l_stick.y = mesg->l_stick_y;
+                cc_l_stick.x = mesg->l_stick[CWIID_X];
+                cc_l_stick.y = mesg->l_stick[CWIID_Y];
                 gtk_widget_queue_draw(drawCCLStick);
 
                 cc_r_stick.valid = 1;
-                cc_r_stick.x = mesg->r_stick_x;
-                cc_r_stick.y = mesg->r_stick_y;
+                cc_r_stick.x = mesg->r_stick[CWIID_X];
+                cc_r_stick.y = mesg->r_stick[CWIID_Y];
                 gtk_widget_queue_draw(drawCCRStick);
                 

wminput/main.c

@@ -16 +16 @@
  *
  *  ChangeLog:
+ *  2007-04-24 L. Donnie Smith <cwiid@abstrakraft.org>
+ *  * update for API overhaul
+ *
  *  2007-04-09 L. Donnie Smith <cwiid@abstrakraft.org>
  *  * updated for libcwiid rename
@@ -55 +58 @@
 void process_nunchuk_mesg(struct cwiid_nunchuk_mesg *mesg);
 void process_classic_mesg(struct cwiid_classic_mesg *mesg);
-void process_plugin(struct plugin *, int, union cwiid_mesg * []);
+void process_plugin(struct plugin *, int, union cwiid_mesg []);
 
 /* Globals */
@@ -159 +162 @@
                 }
         }
-        if ((wiimote = cwiid_connect(&bdaddr, cwiid_callback, NULL)) == NULL) {
+        if ((wiimote = cwiid_connect(&bdaddr, CWIID_FLAG_MESG_IFC)) == NULL) {
                 wminput_err("unable to connect");
+                conf_unload(&conf);
+                return -1;
+        }
+        if (cwiid_set_mesg_callback(wiimote, &cwiid_callback)) {
+                wminput_err("error setting callback");
                 conf_unload(&conf);
                 return -1;
@@ -258 +266 @@
 }
 
-void cwiid_callback(int id, int mesg_count, union cwiid_mesg *mesg[])
+void cwiid_callback(cwiid_wiimote_t *wiimote, int mesg_count,
+                    union cwiid_mesg mesg[])
 {
         int i;
 
         for (i=0; i < mesg_count; i++) {
-                switch (mesg[i]->type) {
+                switch (mesg[i].type) {
                 case CWIID_MESG_BTN:
-                        process_btn_mesg((struct cwiid_btn_mesg *) mesg[i]);
+                        process_btn_mesg((struct cwiid_btn_mesg *) &mesg[i]);
                         break;
                 case CWIID_MESG_NUNCHUK:
-                        process_nunchuk_mesg((struct cwiid_nunchuk_mesg *) mesg[i]);
+                        process_nunchuk_mesg((struct cwiid_nunchuk_mesg *) &mesg[i]);
                         break;
                 case CWIID_MESG_CLASSIC:
-                        process_classic_mesg((struct cwiid_classic_mesg *) mesg[i]);
+                        process_classic_mesg((struct cwiid_classic_mesg *) &mesg[i]);
                         break;
                 case CWIID_MESG_ERROR:
@@ -367 +376 @@
         /* Nunchuk.Stick.X */
         if (conf.amap[CONF_NC_AXIS_STICK_X].active) {
-                axis_value = mesg->stick_x;
+                axis_value = mesg->stick[CWIID_X];
                 if (conf.amap[CONF_NC_AXIS_STICK_X].flags & CONF_INVERT) {
                         axis_value = 0xFF - axis_value;
@@ -377 +386 @@
         /* Nunchuk.Stick.Y */
         if (conf.amap[CONF_NC_AXIS_STICK_Y].active) {
-                axis_value = mesg->stick_y;
+                axis_value = mesg->stick[CWIID_Y];
                 if (conf.amap[CONF_NC_AXIS_STICK_Y].flags & CONF_INVERT) {
                         axis_value = 0xFF - axis_value;
@@ -442 +451 @@
         /* Classic.LStick.X */
         if (conf.amap[CONF_CC_AXIS_L_STICK_X].active) {
-                axis_value = mesg->l_stick_x;
+                axis_value = mesg->l_stick[CWIID_X];
                 if (conf.amap[CONF_CC_AXIS_L_STICK_X].flags & CONF_INVERT) {
                         axis_value = CWIID_CLASSIC_L_STICK_MAX - axis_value;
@@ -452 +461 @@
         /* Classic.LStick.Y */
         if (conf.amap[CONF_CC_AXIS_L_STICK_Y].active) {
-                axis_value = mesg->l_stick_y;
+                axis_value = mesg->l_stick[CWIID_Y];
                 if (conf.amap[CONF_CC_AXIS_L_STICK_Y].flags & CONF_INVERT) {
                         axis_value = CWIID_CLASSIC_L_STICK_MAX - axis_value;
@@ -462 +471 @@
         /* Classic.RStick.X */
         if (conf.amap[CONF_CC_AXIS_R_STICK_X].active) {
-                axis_value = mesg->r_stick_x;
+                axis_value = mesg->r_stick[CWIID_X];
                 if (conf.amap[CONF_CC_AXIS_R_STICK_X].flags & CONF_INVERT) {
                         axis_value = CWIID_CLASSIC_R_STICK_MAX - axis_value;
@@ -472 +481 @@
         /* Classic.RStick.Y */
         if (conf.amap[CONF_CC_AXIS_R_STICK_Y].active) {
-                axis_value = mesg->r_stick_y;
+                axis_value = mesg->r_stick[CWIID_Y];
                 if (conf.amap[CONF_CC_AXIS_R_STICK_Y].flags & CONF_INVERT) {
                         axis_value = CWIID_CLASSIC_R_STICK_MAX - axis_value;
@@ -502 +511 @@
 
 void process_plugin(struct plugin *plugin, int mesg_count,
-                    union cwiid_mesg *mesg[])
+                    union cwiid_mesg mesg[])
 {
         union cwiid_mesg *plugin_mesg[CWIID_MAX_MESG_COUNT];
@@ -513 +522 @@
 
         for (i=0; i < mesg_count; i++) {
-                switch (mesg[i]->type) {
+                switch (mesg[i].type) {
                 case CWIID_MESG_STATUS:
                         flag = CWIID_RPT_STATUS;
@@ -536 +545 @@
                 }
                 if (plugin->rpt_mode_flags & flag) {
-                        plugin_mesg[plugin_mesg_count++] = mesg[i];
+                        plugin_mesg[plugin_mesg_count++] = &mesg[i];
                 }
         }
@@ -574 +583 @@
         }
 }
-

wminput/plugins/acc/acc.c

@@ -16 +16 @@
  *
  *  ChangeLog:
+ *  2007-04-24 L. Donnie Smith <cwiid@abstrakraft.org>
+ *  * updated for API overhaul
+ *
  *  2007-04-09 L. Donnie Smith <cwiid@abstrakraft.org>
  *  * updated for libcwiid rename
@@ -160 +163 @@
         double roll, pitch;
 
-        a_x = (((double)mesg->x - acc_zero.x) /
+        a_x = (((double)mesg->acc[CWIID_X] - acc_zero.x) /
               (acc_one.x - acc_zero.x))*NEW_AMOUNT + a_x*OLD_AMOUNT;
-        a_y = (((double)mesg->y - acc_zero.y) /
+        a_y = (((double)mesg->acc[CWIID_Y] - acc_zero.y) /
               (acc_one.y - acc_zero.y))*NEW_AMOUNT + a_y*OLD_AMOUNT;
-        a_z = (((double)mesg->z - acc_zero.z) /
+        a_z = (((double)mesg->acc[CWIID_Z] - acc_zero.z) /
               (acc_one.z - acc_zero.z))*NEW_AMOUNT + a_z*OLD_AMOUNT;
 

wminput/plugins/ir_ptr/ir_ptr.c

@@ -16 +16 @@
  *
  *  ChangeLog:
+ *  2007-04-24 L. Donnie Smith <cwiid@abstrakraft.org>
+ *  * updated for API overhaul
+ *
  *  2007-04-09 L. Donnie Smith <cwiid@abstrakraft.org>
  *  * updated for libcwiid rename
@@ -39 +42 @@
 struct cursor {
         unsigned char valid;
-        uint16_t x;
-        uint16_t y;
+        uint16_t pos[2];
 };
 int a_debounce, b_debounce;
@@ -161 +163 @@
         else {
                 a = ir_mesg->src[a_index];
-                a.x = CWIID_IR_X_MAX - a.x;
+                a.pos[CWIID_X] = CWIID_IR_X_MAX - a.pos[CWIID_X];
                 a_debounce = 0;
         }
@@ -175 +177 @@
         else {
                 b = ir_mesg->src[b_index];
-                b.x = CWIID_IR_X_MAX - b.x;
+                b.pos[CWIID_X] = CWIID_IR_X_MAX - b.pos[CWIID_X];
                 b_debounce = 0;
         }
@@ -182 +184 @@
         if (a.valid && b.valid) {
                 c.valid = 1;
-                c.x = (a.x + b.x)/2;
-                c.y = (a.y + b.y)/2;
+                for (i=0; i < 2; i++) {
+                        c.pos[i] = (a.pos[i] + b.pos[i])/2;
+                }
         }
         /* if either source is valid, use best guess */
@@ -191 +194 @@
                 if (prev_a.valid && prev_c.valid) {
                         c.valid = 1;
-                        c.x = a.x + (prev_c.x - prev_a.x);
-                        c.y = a.y + (prev_c.y - prev_a.y);
+                        for (i=0; i < 2; i++) {
+                                c.pos[i] = a.pos[i] + (prev_c.pos[i] - prev_a.pos[i]);
+                        }
                 }
                 /* if a is new or we don't have a previous center,
@@ -198 +202 @@
                 else {
                         c.valid = 1;
-                        c.x = a.x;
-                        c.y = a.y;
+                        for (i=0; i < 2; i++) {
+                                c.pos[i] = a.pos[i];
+                        }
                 }
         }
@@ -207 +212 @@
                 if (prev_b.valid && prev_c.valid) {
                         c.valid = 1;
-                        c.x = b.x + (prev_c.x - prev_b.x);
-                        c.y = b.y + (prev_c.y - prev_b.y);
+                        for (i=0; i < 2; i++) {
+                                c.pos[i] = b.pos[i] + (prev_c.pos[i] - prev_b.pos[i]);
+                        }
                 }
                 /* if b is new or we don't have a previous center,
@@ -214 +220 @@
                 else {
                         c.valid = 1;
-                        c.x = b.x;
-                        c.y = b.y;
+                        for (i=0; i < 2; i++) {
+                                c.pos[i] = b.pos[i];
+                        }
                 }
         }
@@ -238 +245 @@
         }
         if (flags != old_flags) {
-                /* TODO: if this message is sent every time, we get a battery meter of
-                 * blinking lights - why? */
                 cwiid_command(wiimote, CWIID_CMD_LED, flags);
         }
@@ -249 +254 @@
 #define OLD_AMOUNT (1.0-NEW_AMOUNT)
 
-        data.axes[0].value = c.x*NEW_AMOUNT + data.axes[0].value*OLD_AMOUNT;
-        data.axes[1].value = c.y*NEW_AMOUNT + data.axes[1].value*OLD_AMOUNT;
+        data.axes[0].value = c.pos[CWIID_X]*NEW_AMOUNT +
+                             data.axes[0].value*OLD_AMOUNT;
+        data.axes[1].value = c.pos[CWIID_Y]*NEW_AMOUNT +
+                             data.axes[1].value*OLD_AMOUNT;
 
         return &data;
 }
-

wminput/plugins/nunchuk_acc/nunchuk_acc.c

@@ -16 +16 @@
  *
  *  ChangeLog:
+ *  2007-04-24 L. Donnie Smith <cwiid@abstrakraft.org>
+ *  * updated for API overhaul
+ *
  *  2007-04-09 L. Donnie Smith <cwiid@abstrakraft.org>
  *  * updated for libcwiid rename
@@ -123 +126 @@
 {
         int i;
-        enum cwiid_ext_type extension = CWIID_EXT_NONE;
+        enum cwiid_ext_type ext_type = CWIID_EXT_NONE;
         unsigned char buf[7];
         struct wmplugin_data *ret = NULL;
@@ -130 +133 @@
                 switch (mesg[i]->type) {
                 case CWIID_MESG_STATUS:
-                        if ((mesg[i]->status_mesg.extension == CWIID_EXT_NUNCHUK) &&
-                          (extension != CWIID_EXT_NUNCHUK)) {
+                        if ((mesg[i]->status_mesg.ext_type == CWIID_EXT_NUNCHUK) &&
+                          (ext_type != CWIID_EXT_NUNCHUK)) {
                                 if (cwiid_read(wiimote, CWIID_RW_REG | CWIID_RW_DECODE,
                                                  0xA40020, 7, buf)) {
@@ -143 +146 @@
                                 acc_one.z  = buf[6];
                         }
-                        extension = mesg[i]->status_mesg.extension;
+                        ext_type = mesg[i]->status_mesg.ext_type;
                         break;
                 case CWIID_MESG_NUNCHUK:
@@ -166 +169 @@
         double roll, pitch;
 
-        a_x = (((double)mesg->acc_x - acc_zero.x) /
+        a_x = (((double)mesg->acc[CWIID_X] - acc_zero.x) /
               (acc_one.x - acc_zero.x))*NEW_AMOUNT + a_x*OLD_AMOUNT;
-        a_y = (((double)mesg->acc_y - acc_zero.y) /
+        a_y = (((double)mesg->acc[CWIID_Y] - acc_zero.y) /
               (acc_one.y - acc_zero.y))*NEW_AMOUNT + a_y*OLD_AMOUNT;
-        a_z = (((double)mesg->acc_z - acc_zero.z) /
+        a_z = (((double)mesg->acc[CWIID_Z] - acc_zero.z) /
               (acc_one.z - acc_zero.z))*NEW_AMOUNT + a_z*OLD_AMOUNT;