linux-joystick.cpp

Go to the documentation of this file.

/*
 * linux-joystick.cpp
 *
 * Copyright (C) 2009,2011  Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * Device support built on the linux/joystick.h system.  See linux-joystick.h
 */

// includes --------------------------------------------------------------------
#include "linux-joystick.h"             // always include our own header first

#ifdef WIN32
#error "Can't compile linux-joystick module under Windows"
#endif  // WIN32

#include <linux/joystick.h>
#include <sstream>
#include <iostream>

#include "perf/perf.h"
#include "util/file.h"
#include "wave-nix/wave-nix.h"


namespace gamepad {



#define s_devicePath            "/dev/input/"
#define s_devicePrefix          "js"

const int s_maxName = 80;       // everyone on the Internets uses this value...

static const char * s_prefix            = "LinuxJoystick";

static SetString s_devicePaths; // set of recognized device paths


////////////////////////////////////////////////////////////////////////////////
//
//      static helper methods
//
////////////////////////////////////////////////////////////////////////////////

static bool
test_bit
(
IN int bit,
IN const byte_t * array
)
{
        ASSERT(bit >= 0, "Bad bit: %d", bit);
        ASSERT(array, "null");

        int offset = bit / 8;
        byte_t b = array[offset];
        byte_t mask = 1 << (bit % 8);
        return b & mask;
}



#define DUMP_EVBIT(name, desc) {                                        \
        if (test_bit(EV_ ##name , pb)) { DPRINTF("  %s", desc); }       \
        }

static void
dumpCapabilities
(
IN const byte_t * pb
)
throw()
{
        ASSERT(pb, "null");

        DPRINTF("Device capabilities:");        // examples
        DUMP_EVBIT(SYN, "Synchronizes");
        DUMP_EVBIT(KEY, "Buttons/keys");
        DUMP_EVBIT(REL, "Relative input");      // trackballs
        DUMP_EVBIT(ABS, "Absolute input");      // joysticks
        DUMP_EVBIT(MSC, "Miscellaneous");       // ???
        DUMP_EVBIT(SW,  "Switch");
        DUMP_EVBIT(LED, "LEDs");
        DUMP_EVBIT(SND, "Sound");
        DUMP_EVBIT(REP, "Repeat events");
        DUMP_EVBIT(FF,  "Force Feedback");
        DUMP_EVBIT(PWR, "Power management");
        DUMP_EVBIT(FF_STATUS, "Force feedback status");
}



static int
getIndex
(
IN int value,
IN const int * map,
IN int size
)
{
        THROW(value >= 0, "Bad input index value: " << value);
        ASSERT(map, "null");
        ASSERT(size > 0, "Bad map size: %d", size);

        for (int i = 0; i < size; ++i) {
                if (value == map[i])
                        return i;
        }

        // couldn't find input index in map!
//      THROW(false, "Input index not found in map: " << value);
        DPRINTF("WARNING: input index not found in map?  %d", value);

        return -1;      // never get here
}



static inline void
diagnoseError
(
void
)
{
        dumpErrorInfo(std::cerr, errno);
}



static bool
isJoystickEntry
(
IN smart_fd& fd
)
{
        ASSERT(fd, "invalid");

        // get the version
        dword_t version;
        if (ioctl(fd, JSIOCGVERSION, &version)) {
                diagnoseError();
                DPRINTF("  ...unable to retrieve joystick version");
                return false;
        }
        DPRINTF("Version = 0x%08x", version);
        int16_t majorV = version >> 16;
        byte_t minorV = (version >> 8) & 0xff;
        byte_t patchV = version & 0xff;
        DPRINTF("  major:%d  minor:%d  patch:%d", majorV, minorV, patchV);

        // get the name
        char name[s_maxName];
        int nchars = ioctl(fd, JSIOCGNAME(s_maxName), &name);
        if (nchars < 1 || nchars > s_maxName) {
                diagnoseError();
                DPRINTF("   ...failed to get joystick name");
                return false;
        }
        DPRINTF("Joystick name: '%s'", name);

        // should have at least 2 axes...
        static const int s_minAxes = 2;
        int numAxes = 0;
        if (ioctl(fd, JSIOCGAXES, &numAxes)) {
                diagnoseError();
                DPRINTF("  ...failed to retrieve axis count");
                return false;
        }
        DPRINTF("Number of axes: %d", numAxes);
        if (numAxes < s_minAxes) {
                DPRINTF("  ...not enough axes (want %d, only found %d)",
                    s_minAxes, numAxes);
                return false;
        }

        // should have at least 1 button...
        int numButtons = 0;
        if (ioctl(fd, JSIOCGBUTTONS, &numButtons)) {
                diagnoseError();
                DPRINTF("  ...failed to retrieve button count");
                return false;
        }
        DPRINTF("Number of buttons: %d", numButtons);
        if (numButtons < 1) {
                DPRINTF("  ...does not contain any buttons?");
                return false;
        }

        // got here?  all good.
        return true;
}



const char *
getJoystickIndex
(
IN const char * path
)
{
        ASSERT(path, "null");

        const char * key = s_devicePath s_devicePrefix;

        const char * p = strstr(path, key);
        THROW(p, "Bad joystick device path: " << path);

        p += strlen(key);

        DPRINTF("path: '%s' --> index '%s'", path, p);
        return p;
}



////////////////////////////////////////////////////////////////////////////////
//
//      LJDevice -- class that implements the gamepad::SourceDevice interface
//              for Linux Joystick objects (using linux/joystick.h)
//
////////////////////////////////////////////////////////////////////////////////

class LJDevice : public SourceDevice {
public:
        // constructor, destructor ---------------------------------------------
        LJDevice(void) throw();
        ~LJDevice(void) throw();

        // public class methods ------------------------------------------------
        void initialize(IN const char * path);

        // gamepad::SourceDevice class interface methods -----------------------
        const char * getPublicName(void) throw() { return m_name.c_str(); }
        const char * getUniqueId(void) throw() { return m_uid.c_str(); }
        eDeviceState getState(void) throw();
        int getNumPots(void) throw() { return m_nPots; }
        int getNumButtons(void) throw() { return m_nButtons; }
        void poll(void) throw();
        const pot_value_t& getPotValue(IN int potIndex);
        eButton getButtonValue(IN int buttonIndex);

private:
        // private helper methods ----------------------------------------------
        // private member data -------------------------------------------------
        std::string             m_path;         // device path
        std::string             m_name;         // public name
        std::string             m_uid;          // unique ID
        smart_fd                m_fd;           // device handle
        byte_t                  m_eventTypes[(EV_MAX + 7) / 8];// capabilities
        int                     m_nPots;        // count of potentiometers
        int                     m_nButtons;     // count of buttons
        std::vector<byte_t>     m_button;
        std::vector<pot_value_t> m_pot;
};


LJDevice::LJDevice(void)
throw()
{
        m_nPots = 0;
        m_nButtons = 0;
}


LJDevice::~LJDevice(void)
throw()
{
}



////////////////////////////////////////////////////////////////////////////////
//
//      LJDevice -- public class methods
//
////////////////////////////////////////////////////////////////////////////////

void
LJDevice::initialize
(
IN const char * path
)
{
        perf::Timer timer("LinuxInputDevice::initialize()");
        ASSERT(path, "null");

        DPRINTF("Opening linux joystick source device: '%s'", path);

        // remember path
        m_path = path;

        // open device
        THROW(m_fd.open(path, O_RDONLY),
            "Failed to open linux joystick device: " << path);

        // get the name of the device
        char buffer[s_maxName];
        int nchars = ioctl(m_fd, JSIOCGNAME(s_maxName), &buffer);
        THROW(nchars > 0 || nchars <= s_maxName,
            "Failed to acquire linux joystick device name");
        m_name = buffer;
        DPRINTF("  public name: '%s'", m_name.c_str());

        // construct the unique ID
        std::ostringstream out;
        out << s_prefix << ",";
        out << m_name << ",";
        out << "idx:" << getJoystickIndex(path);

        m_uid = out.str();
        DPRINTF("  unique ID: '%s'", m_uid.c_str());

        // construct button map
        if (ioctl(m_fd, JSIOCGBUTTONS, &m_nButtons)) {
                diagnoseError();
                THROW(false, "Failed to acquire button count");
        }
        DPRINTF("Found %d buttons on device", m_nButtons);
        m_button.resize(m_nButtons, eButtonUp);

        // get count of potentiometers
        if (ioctl(m_fd, JSIOCGAXES, &m_nPots)) {
                diagnoseError();
                THROW(false, "Failed to acquire axis count");
        }
        DPRINTF("Found %d potentiometers on device", m_nPots);
        m_pot.resize(m_nPots);

        // last thing: set to non-blocking
        THROW(!fcntl(m_fd, F_SETFL, O_NONBLOCK),
            "Failed to set linux joystick device to nonblocking i/o");
}



////////////////////////////////////////////////////////////////////////////////
//
//      LJDevice -- gamepad::SourceDevice class interface methods
//
////////////////////////////////////////////////////////////////////////////////

eDeviceState
LJDevice::getState
(
void
)
throw()
{
        if (s_devicePaths.end() == s_devicePaths.find(m_path.c_str())) {
                // cannot find device!
                return eDevice_Detached;
        }

        // device appears to be there...
        return eDevice_Attached;
}



void
LJDevice::poll
(
void
)
throw()
{
        ASSERT(m_fd, "need to open device first");

        // clear "was pushed" and "was released" bits for all buttons
        for (int i = 0; i < m_nButtons; ++i) {
                m_button[i] &= ~eButtonWasPushed;
                m_button[i] &= ~eButtonWasReleased;
        }

        // grab all available events
        struct js_event event;
        while (true) {
                int len = read(m_fd, &event, sizeof(event));
                if (!len) {
                        break;          // no more events!
                }
                if (len < 0) {
                        // read call failed--why?
                        if (EAGAIN == errno)
                                break;  // no more data--fine

                        // failed for some other (unexpected) reason
                        diagnoseError();
                        DPRINTF("Failed to read from joystick!");
                        break;
                }

                int idx = event.number;
                switch (event.type) {
                case JS_EVENT_INIT | JS_EVENT_AXIS:
                case JS_EVENT_AXIS:
                        if (idx < 0 || idx >= m_nPots)
                                break;
                        m_pot[idx].update(event.value);
                        break;

                case JS_EVENT_INIT | JS_EVENT_BUTTON:
                case JS_EVENT_BUTTON:
                        if (idx < 0 || idx >= m_nButtons)
                                break;
                        m_button[idx] =
                            updateButton(m_button[idx], event.value);
                        break;

                default:
                        DPRINTF("Unrecognized joystick event: %d", event.type);
                }
        }
}



const pot_value_t&
LJDevice::getPotValue
(
IN int potIndex
)
{
        THROW(potIndex >= 0 && potIndex < m_nPots,
            "Bad pot index: " << potIndex);
        return m_pot[potIndex];
}



eButton
LJDevice::getButtonValue
(
IN int buttonIndex
)
{
        THROW(buttonIndex >= 0 && buttonIndex < m_nButtons,
            "Bad button index: " << buttonIndex);
        return (eButton) m_button[buttonIndex];
}



static void
refreshLinuxJoystickDevicePaths
(
void
)
{
        perf::Timer timer("refreshLinuxJoystickDevicePaths");

        // get the count of joystick entries!
        smart_dir dir;
        dir.open(s_devicePath);
        ASSERT(dir, "should have a valid open directory now");

        // go ahead and parse the directory
        int prefixLength = strlen(s_devicePrefix);
        SetString newSet;
        struct dirent entry;
        while (dir.getNextEntry(entry)) {
                // only look at entries beginning with "js"
                if (strncmp(s_devicePrefix, entry.d_name, prefixLength)) {
                        continue;       // some other prefix
                }

                std::string path;
                appendPath(s_devicePath, entry.d_name, path);

                // quick check--already know about this one?
                if (s_devicePaths.end() != s_devicePaths.find(path.c_str())) {
                        // yes, known good path
                        newSet.insert(path);
                        continue;
                }

                // new path--see if this is a joystick object
                smart_fd fd;
                if (fd.open(path.c_str(), O_RDONLY) && isJoystickEntry(fd)) {
                        newSet.insert(path);
                }
        }

        // copy over
        s_devicePaths = newSet;
}



smart_ptr<SourceDevice>
getLinuxJoystickSourceDevice
(
IN const char * path
)
{
        ASSERT(path, "null");

        // okay, create device!
        smart_ptr<LJDevice> local = new LJDevice;
        ASSERT(local, "out of memory");
        local->initialize(path);

        // all done
        return local;
}



////////////////////////////////////////////////////////////////////////////////
//
//      Factory -- class that implements the gamepad::SourceDeviceFactory
//              interface for linux joysticks.
//
////////////////////////////////////////////////////////////////////////////////

class Factory : public SourceDeviceFactory {
public:
        // constructor, destructor ---------------------------------------------
        ~Factory(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(void) { }

        // gamepad::SourceDeviceFactory class interface methods ----------------
        const char * getName(void) const throw()
                                { return "Linux Joystick Factory"; }
        int getCount(void); 
        smart_ptr<SourceDevice> getSourceDevice(IN int index);

private:
        // private typedefs ----------------------------------------------------
        typedef std::map<std::string, smart_ptr<SourceDevice> > device_map_t;

        // private member data -------------------------------------------------
        device_map_t    m_devices;      // instantiated devices (path -> device)
};



int
Factory::getCount
(
void
)
{
        // refresh our set of device paths
        refreshLinuxJoystickDevicePaths();

        // get rid of any source devices we no longer recognize
        VecString badPaths;
        for (device_map_t::iterator i = m_devices.begin(); i != m_devices.end();
             ++i) {
                const char * path = i->first.c_str();
                if (s_devicePaths.end() == s_devicePaths.find(path)) {
                        // no longer recognize this path--device detached?
                        badPaths.push_back(path);
                }
        }
        for (VecString::iterator i = badPaths.begin(); i != badPaths.end();
             ++i) {
                device_map_t::iterator iBad = m_devices.find(*i);
                ASSERT(m_devices.end() != iBad, "Just saw this in map!");
                m_devices.erase(iBad);
        }
        ASSERT(m_devices.size() <= s_devicePaths.size(),
            "Should have devices for a subset of paths!");

        // return size
        return s_devicePaths.size();
}



smart_ptr<SourceDevice>
Factory::getSourceDevice
(
IN int index
)
{
        // get path for this index
        const char * path = NULL;
        for (SetString::const_iterator i = s_devicePaths.begin();
             i != s_devicePaths.end(); ++i, --index) {
                if (!index) {
                        path = i->c_str();
                        break;
                }
        }
        if (!path) {
                DPRINTF("Invalid source device index: %d", index);
                return NULL;
        }

        // return device if we've already got it
        device_map_t::iterator i = m_devices.find(path);
        if (m_devices.end() != i) {
                return i->second;
        }

        // don't know this device!  Add it
        smart_ptr<SourceDevice> device =
            getLinuxJoystickSourceDevice(path);
        ASSERT(device, "failed to create linux input source device");
        m_devices[path] = device;
        return device;
}



////////////////////////////////////////////////////////////////////////////////
//
//      public API
//
////////////////////////////////////////////////////////////////////////////////

smart_ptr<SourceDeviceFactory>
getLinuxJoystickSourceDeviceFactory
(
void
)
{
        smart_ptr<Factory> local = new Factory;
        ASSERT(local, "out of memory");

        local->initialize();

        return local;
}



};      // gamepad namespace