Ticket #7354: usb_hid.patch

HIDReportItem.h

@@ -27 +27 @@
 
         uint32                  UsageMinimum() { return fUsageMinimum; };
         uint32                  UsageMaximum() { return fUsageMaximum; };
+        
+        uint32                  Minimum() { return fMinimum; };
+        uint32                  Maximum() { return fMaximum; };
 
         status_t                Extract();
         status_t                Insert();

Jamfile

@@ -12 +12 @@
     HIDDevice.cpp
     KeyboardDevice.cpp
     MouseDevice.cpp
+    TabletDevice.cpp
     ProtocolHandler.cpp
 
     HIDCollection.cpp

ProtocolHandler.cpp

@@ -15 +15 @@
 // includes for the different protocol handlers
 #include "KeyboardDevice.h"
 #include "MouseDevice.h"
+#include "TabletDevice.h"
 //#include "GenericDevice.h"
 
 
@@ -83 +84 @@
         handler = KeyboardDevice::AddHandler(device, report);
         if (handler != NULL)
             (*handlerList)[usedCount++] = handler;
-        handler = MouseDevice::AddHandler(device, report);
-        if (handler != NULL)
-            (*handlerList)[usedCount++] = handler;
+            
+        handler = TabletDevice::AddHandler(device, report);
+        if (handler != NULL) {
+            (*handlerList)[usedCount++] = handler;
+        }
+        else {
+            handler = MouseDevice::AddHandler(device, report);
+            if (handler != NULL) {
+                (*handlerList)[usedCount++] = handler;
+            }
+        }
+            
     }
 
     if (usedCount == 0) {

TabletDevice.cpp

@@ +1 @@
+/*
+ * Copyright 2010-2011 Enrique Medina Gremaldos <quiqueiii@gmail.com>
+ * Distributed under the terms of the MIT license.
+ */
+
+
+//! Driver for USB Human Interface Devices.
+
+
+#include "Driver.h"
+#include "TabletDevice.h"
+
+#include "HIDDevice.h"
+#include "HIDReport.h"
+#include "HIDReportItem.h"
+
+#include <new>
+#include <string.h>
+#include <usb/USB_hid.h>
+
+#include <keyboard_mouse_driver.h>
+
+
+TabletDevice::TabletDevice(HIDReport *report)
+    :
+    ProtocolHandler(report->Device(), "input/tablet/usb/", 512),
+    fReport(report),
+    fPressure(NULL),
+    fXAxis(NULL),
+    fYAxis(NULL),
+    fWheel(NULL),
+    fLastButtons(0),
+    fClickCount(0),
+    fLastClickTime(0),
+    fClickSpeed(250000)
+{
+    uint32 buttonCount = 0;
+    for (uint32 i = 0; i < report->CountItems(); i++) {
+        HIDReportItem *item = report->ItemAt(i);
+        if (!item->HasData())
+            continue;
+
+        if (item->UsagePage() == B_HID_USAGE_PAGE_BUTTON
+            && item->UsageID() - 1 < B_MAX_MOUSE_BUTTONS)
+            fButtons[buttonCount++] = item;
+    }
+
+    fButtons[buttonCount] = NULL;
+
+    fWheel = report->FindItem(B_HID_USAGE_PAGE_GENERIC_DESKTOP,B_HID_UID_GD_WHEEL);
+
+    TRACE_ALWAYS("tablet device with %lu buttons and %swheel\n", buttonCount,
+        fWheel == NULL ? "no " : "");
+    TRACE_ALWAYS("report id: %u\n", report->ID());
+    
+    fRange = report->FindItem(B_HID_USAGE_PAGE_DIGITIZER,B_HID_UID_DIG_IN_RANGE);
+    if(fRange!=NULL)
+        TRACE_ALWAYS("TabletDevice: found range\n");
+        
+    fTip = report->FindItem(B_HID_USAGE_PAGE_DIGITIZER,B_HID_UID_DIG_TIP_SWITCH);
+    if(fTip!=NULL)
+        TRACE_ALWAYS("TabletDevice: found Tip\n");
+
+    fBarrelSwitch = report->FindItem(B_HID_USAGE_PAGE_DIGITIZER,B_HID_UID_DIG_BARREL_SWITCH);
+    if(fBarrelSwitch!=NULL)
+        TRACE_ALWAYS("TabletDevice: found Barrel Tip\n");
+    
+    fPressure = report->FindItem(B_HID_USAGE_PAGE_DIGITIZER,B_HID_UID_DIG_TIP_PRESSURE);
+    if(fPressure!=NULL)
+        TRACE_ALWAYS("TabletDevice: found pressure\n");
+        
+    fXAxis = report->FindItem(B_HID_USAGE_PAGE_GENERIC_DESKTOP,B_HID_UID_GD_X);
+    if (fXAxis != NULL)
+        TRACE_ALWAYS("TabletDevice: found X\n");
+    
+    fYAxis = report->FindItem(B_HID_USAGE_PAGE_GENERIC_DESKTOP,B_HID_UID_GD_Y);
+    if (fYAxis != NULL)
+        TRACE_ALWAYS("TabletDevice: found Y\n");
+    
+    
+    
+}
+
+
+ProtocolHandler *
+TabletDevice::AddHandler(HIDDevice *device, HIDReport *report)
+{
+    
+    TRACE_ALWAYS("report type:%x\n",report->Type());
+    TRACE_ALWAYS("report id:%x\n",report->ID());
+    for(int n=0;n<report->CountItems();n++) {
+        TRACE_ALWAYS("item usage page:%x id:%x\n",report->ItemAt(n)->UsagePage(),report->ItemAt(n)->UsageID());
+    }
+    
+    HIDReportItem * x = report->FindItem(B_HID_USAGE_PAGE_GENERIC_DESKTOP,B_HID_UID_GD_X);
+    HIDReportItem * y = report->FindItem(B_HID_USAGE_PAGE_GENERIC_DESKTOP,B_HID_UID_GD_Y);
+    
+    if(x!=NULL && y!=NULL) {
+        if(x->Relative() || y->Relative())
+            return NULL;    
+    }else return NULL;
+    
+    return new(std::nothrow) TabletDevice(report);
+}
+
+
+status_t
+TabletDevice::Control(uint32 *cookie, uint32 op, void *buffer, size_t length)
+{
+    switch (op) {
+        case MS_READ:
+            while (RingBufferReadable() == 0) {
+                status_t result = _ReadReport();
+                if (result != B_OK)
+                    return result;
+            }
+
+            return RingBufferRead(buffer, sizeof(tablet_movement));
+
+        case MS_NUM_EVENTS:
+        {
+            int32 count = RingBufferReadable() / sizeof(tablet_movement);
+            if (count == 0 && fReport->Device()->IsRemoved())
+                return B_DEV_NOT_READY;
+            return count;
+        }
+
+        case MS_SET_CLICKSPEED:
+#ifdef __HAIKU__
+                return user_memcpy(&fClickSpeed, buffer, sizeof(bigtime_t));
+#else
+                fClickSpeed = *(bigtime_t *)buffer;
+                return B_OK;
+#endif
+    }
+
+    return B_ERROR;
+}
+
+
+status_t
+TabletDevice::_ReadReport()
+{
+    
+    status_t result = fReport->WaitForReport(B_INFINITE_TIMEOUT);
+    
+    
+    if (result != B_OK) {
+    
+        if (fReport->Device()->IsRemoved()) {
+            TRACE("device has been removed\n");
+            return B_DEV_NOT_READY;
+        }
+
+        if (result != B_INTERRUPTED) {
+            // interrupts happen when other reports come in on the same
+            // input as ours
+            TRACE_ALWAYS("error waiting for report: %s\n", strerror(result));
+        }
+        else TRACE_ALWAYS("Report %d has been interrumpted\n",fReport->ID());
+        
+
+        // signal that we simply want to try again
+        return B_OK;
+    }//else TRACE_ALWAYS("Report ok for:%d\n",fReport->ID());
+
+    tablet_movement info;
+    memset(&info, 0, sizeof(info));
+    float usage_delta;
+    info.pressure=0.0f;
+    
+    
+    if (fXAxis->Extract() == B_OK && fXAxis->Valid()) {
+        usage_delta = fXAxis->Maximum() - fXAxis->Minimum();
+        info.xpos = (fXAxis->Data() - fXAxis->Minimum()) / usage_delta ;            
+    }
+    
+    if (fYAxis->Extract() == B_OK && fYAxis->Valid()) {
+        usage_delta = fYAxis->Maximum() - fYAxis->Minimum();
+        info.ypos = (fYAxis->Data() - fYAxis->Minimum()) / usage_delta;         
+    }
+    
+    
+    if(fPressure!=NULL && fPressure->Extract() == B_OK && fPressure->Valid()) {
+        usage_delta = fPressure->Maximum() - fPressure->Minimum();
+        info.pressure = (fPressure->Data() - fPressure->Minimum()) / usage_delta;           
+    }
+        
+
+    if (fWheel != NULL && fWheel->Extract() == B_OK && fWheel->Valid())
+        info.wheel_ydelta = -fWheel->Data();
+
+
+    if(fTip!=NULL && fTip->Extract()==B_OK && fTip->Valid()) {
+        info.buttons |= fTip->Data();
+    }
+    
+    if(fBarrelSwitch!=NULL && fBarrelSwitch->Extract()==B_OK && fBarrelSwitch->Valid()) {
+        info.buttons |= fBarrelSwitch->Data()<<1;
+    }
+    
+
+    for (uint32 i = 0; i < B_MAX_MOUSE_BUTTONS; i++) {
+        HIDReportItem *button = fButtons[i];
+        if (button == NULL)
+            break;
+
+        if (button->Extract() == B_OK && button->Valid())
+            info.buttons |= (button->Data() & 1) << (button->UsageID() - 1);
+    }
+
+    fReport->DoneProcessing();
+    //TRACE_ALWAYS("Sent tablet report:%d\n",fReport->ID());
+    //TRACE("got mouse report\n");
+
+    bigtime_t timestamp = system_time();
+    if (info.buttons != 0) {
+        if (fLastButtons == 0) {
+            if (fLastClickTime + fClickSpeed > timestamp)
+                fClickCount++;
+            else
+                fClickCount = 1;
+        }
+
+        fLastClickTime = timestamp;
+        info.clicks = fClickCount;
+    }
+
+    fLastButtons = info.buttons;
+    info.timestamp = timestamp;
+    return RingBufferWrite(&info, sizeof(tablet_movement));
+}

TabletDevice.h

@@ +1 @@
+/*
+ * Copyright 20010-2011 Enrique Medina Gremaldos <quiqueiii@gmail.com>
+ * Distributed under the terms of the MIT license.
+ */
+#ifndef USB_TABLET_DEVICE_H
+#define USB_TABLET_DEVICE_H
+
+
+#include <InterfaceDefs.h>
+
+#include "ProtocolHandler.h"
+
+
+class HIDReportItem;
+
+
+#ifndef B_MAX_MOUSE_BUTTONS
+#   define B_MAX_MOUSE_BUTTONS      8
+#endif
+
+
+class TabletDevice : public ProtocolHandler {
+public:
+                                TabletDevice(HIDReport *report);
+
+    static  ProtocolHandler *   AddHandler(HIDDevice *device,
+                                    HIDReport *report);
+
+    virtual status_t            Control(uint32 *cookie, uint32 op, void *buffer,
+                                    size_t length);
+
+private:
+            status_t            _ReadReport();
+
+private:
+            HIDReport *         fReport;
+
+            HIDReportItem *     fPressure;
+            HIDReportItem *     fXAxis;
+            HIDReportItem *     fYAxis;
+            HIDReportItem *     fWheel;
+            HIDReportItem *     fButtons[B_MAX_MOUSE_BUTTONS];
+            HIDReportItem *     fRange;
+            HIDReportItem *     fTip;
+            HIDReportItem *     fBarrelSwitch;
+
+            uint32              fLastButtons;
+            uint32              fClickCount;
+            bigtime_t           fLastClickTime;
+            bigtime_t           fClickSpeed;
+            uint32              fMaxButtons;
+            
+            uint32              lastX;
+            uint32              lastY;
+};
+
+#endif // USB_TABLET_DEVICE_H