Updated HID drivers for INTEGRITY

This patch icnludes new INTEGRITY keyboard and mouse drivers.

Task-number:QTBUG-24175
Change-Id: Ifbb01357a601c44bab5961cdfe82d1c7bd44b889
Reviewed-by: Rolland Dudemaine <rolland@ghs.com>
Reviewed-by: Harald Fernengel <harald.fernengel@nokia.com>

1 files changed, 177 insertions, 68 deletions

diff --git a/src/gui/embedded/qkbdintegrity_qws.cpp b/src/gui/embedded/qkbdintegrity_qws.cpp
index ad4be91..c58c176 100644
--- a/src/gui/embedded/qkbdintegrity_qws.cpp
+++ b/src/gui/embedded/qkbdintegrity_qws.cpp
@@ -45,10 +45,9 @@
 #include <qwindowsystem_qws.h>
 #include <qapplication.h>
 #include <qtimer.h>
-#include <qthread.h>
-
 #include <INTEGRITY.h>
-
+#include <QThread>
+#include <device/hiddriver.h>
 
 //===========================================================================
 
@@ -58,6 +57,70 @@ QT_BEGIN_NAMESPACE
 // INTEGRITY keyboard
 //
 
+static const struct KeyMapEntryStruct {
+    int key;
+    QChar qchar;
+} keyMap[] = {
+    { 0, 0 },
+    { Qt::Key_Escape, 0 },
+    { Qt::Key_1, '1' },
+    { Qt::Key_2, '2' },
+    { Qt::Key_3, '3' },
+    { Qt::Key_4, '4' },
+    { Qt::Key_5, '5' },
+    { Qt::Key_6, '6' },
+    { Qt::Key_7, '7' },
+    { Qt::Key_8, '8' },
+    { Qt::Key_9, '9' },
+    { Qt::Key_0, '0' },
+    { Qt::Key_Minus, '-' },
+    { Qt::Key_Equal, '=' },
+    { Qt::Key_Backspace, 0 },
+    { Qt::Key_Tab, '\t' },
+    { Qt::Key_Q, 'q' },
+    { Qt::Key_W, 'w' },
+    { Qt::Key_E, 'e' },
+    { Qt::Key_R, 'r' },
+    { Qt::Key_T, 't' },
+    { Qt::Key_Y, 'y' },
+    { Qt::Key_U, 'u' },
+    { Qt::Key_I, 'i' },
+    { Qt::Key_O, 'o' },
+    { Qt::Key_P, 'p' },
+    { Qt::Key_BraceLeft, '{' },
+    { Qt::Key_BraceRight, '}' },
+    { Qt::Key_Enter, '\n' },
+    { Qt::Key_Control, 0 },
+    { Qt::Key_A, 'a' },
+    { Qt::Key_S, 's' },
+    { Qt::Key_D, 'd' },
+    { Qt::Key_F, 'f' },
+    { Qt::Key_G, 'g' },
+    { Qt::Key_H, 'h' },
+    { Qt::Key_J, 'j' },
+    { Qt::Key_K, 'k' },
+    { Qt::Key_L, 'l' },
+    { Qt::Key_Semicolon, ';' },
+    { Qt::Key_Apostrophe, '\'' },
+    { Qt::Key_Dead_Grave, 0 },
+    { Qt::Key_Shift, 0 },
+    { Qt::Key_Backslash, '\\' },
+    { Qt::Key_Z, 'z' },
+    { Qt::Key_X, 'x' },
+    { Qt::Key_C, 'c' },
+    { Qt::Key_V, 'v' },
+    { Qt::Key_B, 'b' },
+    { Qt::Key_N, 'n' },
+    { Qt::Key_M, 'm' },
+    { Qt::Key_Comma, ',' },
+    { Qt::Key_NumberSign, '.' },
+    { Qt::Key_Slash, '/' },
+    { Qt::Key_Shift, 0 },
+    { Qt::Key_Asterisk, '*' },
+    { Qt::Key_Alt, 0 },
+};
+
+
 class QIntKeyboardListenThread;
 
 class QWSIntKbPrivate : public QObject
@@ -67,16 +130,13 @@ class QWSIntKbPrivate : public QObject
 public:
     QWSIntKbPrivate(QWSKeyboardHandler *, const QString &device);
     ~QWSIntKbPrivate();
-    void dataReady(int amount) { emit kbdDataAvailable(amount); }
-    uint8_t scancodebuf[32 /* USB_SCANCODE_BUF_LEN */ ];
-    uint8_t rxpost;
-    uint8_t rxack;
+    void dataReady(uint32_t keycode, bool pressed) { emit kbdDataAvailable(keycode, pressed); }
 
 Q_SIGNALS:
-    void kbdDataAvailable(int amount);
+    void kbdDataAvailable(uint32_t keycode, bool pressed);
 
 private Q_SLOTS:
-    void readKeyboardData(int amount);
+    void readKeyboardData(uint32_t keycode, bool pressed);
 
 private:
     QWSKeyboardHandler *handler;
@@ -87,11 +147,15 @@ class QIntKeyboardListenThread : public QThread
 protected:
     QWSIntKbPrivate *imp;
     bool loop;
+    QList<HIDHandle> handleList;
+    QList<Activity> actList;
+    Semaphore loopsem;
 public:
     QIntKeyboardListenThread(QWSIntKbPrivate *im) : QThread(), imp(im) {};
     ~QIntKeyboardListenThread() {};
+    bool setup(QString driverName, uint32_t index);
     void run();
-    void stoploop() { loop = false; };
+    void stoploop() { loop = false; ReleaseSemaphore(loopsem); };
 };
 
 
@@ -106,78 +170,124 @@ QWSIntKeyboardHandler::~QWSIntKeyboardHandler()
     delete d;
 }
 
-//void QWSIntKeyboardHandler::processKeyEvent(int keycode, bool isPress,
-//                                            bool autoRepeat)
-//{
-//    QWSKeyboardHandler::processKeyEvent(keycode, isPress, autoRepeat);
-//}
+bool QIntKeyboardListenThread::setup(QString driverName, uint32_t index)
+{
+    int i;
+    int devices;
+    Error driverError, deviceError;
+    HIDDriver *driver;
+    HIDHandle handle;
+    /* FIXME : take a list of driver names/indexes for setup */
+    devices = 0;
+    i = 0;
+    do {
+        driverError = gh_hid_get_driver(i, &driver);
+        if (driverError == Success) {
+            int j = 0;
+            do {
+                deviceError = gh_hid_init_device(driver, j, &handle);
+                if (deviceError == Success) {
+                    int32_t type;
+                    /* only accept non-pointing devices */
+                    deviceError = gh_hid_get_setting(handle, HID_SETTING_CAPABILITIES, &type);
+                    if ((deviceError == Success) && !(type & HID_TYPE_AXIS)) {
+                        handleList.append(handle);
+                        devices++;
+                    } else
+                        gh_hid_close(handle);
+                        j++;
+                }
+            } while (deviceError == Success);
+            i++;
+        }
+    } while (driverError == Success);
+    return (devices > 0);
+}
 
 void QIntKeyboardListenThread::run(void)
 {
-    Error E;
-    Buffer b;
-    Connection kbdc;
-    bool waitforresource = true;
+    Value id;
+    HIDEvent event;
+    Activity loopact;
+    QPoint currentpos(0,0);
+    Qt::MouseButtons currentbutton = Qt::NoButton;
+    Qt::KeyboardModifiers keymod;
+
+    /* first create all Activities for the main loop.
+     * We couldn't do this in setup() because this Task is different */
+    Activity act;
+    int i = 0;
+    foreach (HIDHandle h, handleList) {
+        CheckSuccess(CreateActivity(CurrentTask(), 2, false, i, &act));
+        actList.append(act);
+        i++;
+        CheckSuccess(gh_hid_async_wait_for_event(h, act));
+    }
+
+    /* setup a Semaphore used to watch for a request for exit */
+    CheckSuccess(CreateSemaphore(0, &loopsem));
+    CheckSuccess(CreateActivity(CurrentTask(), 2, false, 0, &loopact));
+    CheckSuccess(AsynchronousReceive(loopact, (Object)loopsem, NULL));
+
+    loop = true;
     do {
-        E = RequestResource((Object*)&kbdc,
-                "USBKeyboardClient", "!systempassword");
-        if (E == Success) {
-            loop = false;
-        } else {
-            E = RequestResource((Object*)&kbdc,
-                    "KeyboardClient", "!systempassword");
-            if (E == Success) {
-                waitforresource = false;
+        Boolean nokeynotify = false;
+        uint32_t num_events = 1;
+        WaitForActivity(&id);
+        if (loop) {
+            while (gh_hid_get_event(handleList.at(id), &event, &num_events) == Success) {
+                if (event.type == HID_TYPE_KEY) {
+                switch (event.index) {
+                    case HID_KEY_LEFTALT:
+                    case HID_KEY_RIGHTALT:
+                        if (event.value)
+                            keymod |= Qt::AltModifier;
+                        else
+                            keymod &= ~Qt::AltModifier;
+                        break;
+                    case HID_KEY_LEFTSHIFT:
+                    case HID_KEY_RIGHTSHIFT:
+                        if (event.value)
+                            keymod |= Qt::ShiftModifier;
+                        else
+                            keymod &= ~Qt::ShiftModifier;
+                        break;
+                    case HID_KEY_LEFTCTRL:
+                    case HID_KEY_RIGHTCTRL:
+                        if (event.value)
+                            keymod |= Qt::ControlModifier;
+                        else
+                            keymod &= ~Qt::ControlModifier;
+                        break;
+                    default:
+                        break;
+                }
+                QEvent::Type type;
+                if (event.value)
+                    type = QEvent::KeyPress;
+                else
+                    type = QEvent::KeyRelease;
+                //QWindowSystemInterface::handleKeyEvent(0, type,
+                //keyMap[event.index].key, keymod, keyMap[event.index].qchar);
+                imp->dataReady(event.index, event.value);
+                }
             }
-        }
-        if (waitforresource)
-            ::sleep(1);
-    } while (loop && waitforresource);
-    if (!loop)
-        return;
-    b.BufferType = DataBuffer | LastBuffer;
-    b.Length = sizeof(imp->scancodebuf);
-    b.TheAddress = (Address)imp->scancodebuf;
-    do {
-        b.Transferred = 0;
-        b.TheAddress = (Address)imp->scancodebuf + imp->rxpost;
-        CheckSuccess(SynchronousReceive(kbdc, &b));
-        imp->rxpost += b.Transferred;
-        if (imp->rxpost >= 32 /* USB_SCANCODE_BUF_LEN */)
-            imp->rxpost = 0;
-        if (imp->rxpost == (imp->rxack + b.Transferred) % 32 /* USB_SCANCODE_BUF_LEN */) {
-            imp->kbdDataAvailable(b.Transferred);
+            CheckSuccess(gh_hid_async_wait_for_event(handleList.at(id), actList.at(id)));
         }
     } while (loop);
+    QThread::exit(0);
 }
 
-void QWSIntKbPrivate::readKeyboardData(int amount)
+void QWSIntKbPrivate::readKeyboardData(uint32_t keycode, bool pressed)
 {
-    uint16_t keycode;
-    do {
-        if (scancodebuf[rxack] == 0xe0) {
-            keycode = scancodebuf[rxack] << 8;
-            rxack++;
-            if (rxack >= 32 /* USB_SCANCODE_BUF_LEN */)
-                rxack = 0;
-        } else {
-            keycode = 0;
-        }
-
-        handler->processKeycode(keycode + (scancodebuf[rxack] & 0x7f),
-                (scancodebuf[rxack] & 0x80) == 0,
-                scancodebuf[rxack] == 2);
-        rxack++;
-        if (rxack >= 32 /* USB_SCANCODE_BUF_LEN */)
-            rxack = 0;
-    } while (rxack != rxpost);
+    handler->processKeycode(keycode, pressed, false);
 }
 
 QWSIntKbPrivate::QWSIntKbPrivate(QWSKeyboardHandler *h, const QString &device) : handler(h)
 {
-    connect(this, SIGNAL(kbdDataAvailable(int)), this, SLOT(readKeyboardData(int)));
+    connect(this, SIGNAL(kbdDataAvailable(uint32_t, bool)), this, SLOT(readKeyboardData(uint32_t, bool)));
     this->handler = handler;
-    rxack = rxpost = 0;
+    qDebug("Opening INTEGRITY keyboard");
     kbdthread = new QIntKeyboardListenThread(this);
     kbdthread->start();
 }
@@ -189,7 +299,6 @@ QWSIntKbPrivate::~QWSIntKbPrivate()
     delete kbdthread;
 }
 
-
 QT_END_NAMESPACE
 
 #include "qkbdintegrity_qws.moc"