linux-input.cpp

Go to the documentation of this file.

/*
 * linux-input.cpp
 *
 * Copyright (C) 2009  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.
 *
 *
 * Input support built on the linux/input.h system.  See linux-input.h
 */

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

#include <linux/input.h>
#include <sstream>

#include "perf/perf.h"
#include "util/file.h"


namespace gamepad {



static const char * s_devicePath        = "/dev/input/";
static const char * s_prefix            = "LinuxInput";

static SetString s_devicePaths; // set of recognized device paths

enum eFFState {
        eFF_NotLoaded           = 1,    // nothing done
        eFF_Loaded              = 2,    // loaded, not playing
        eFF_Playing             = 3,    // actively playing

        // keep this last
        eFF_Invalid             = 0
};



struct rumble_t {
        // constructor, manipulators
        rumble_t(void) throw() { this->clear(); }
        void clear(void) throw() {
                        state = eFF_Invalid;
                        id = -1;
                }

        // data fields
        eFFState        state;
        int             id;
};


////////////////////////////////////////////////////////////////////////////////
//
//      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 bool
isInputEntry
(
IN smart_fd& fd
)
{
        ASSERT(fd, "invalid");

        // what can it do?
        byte_t eventTypes[(EV_MAX + 7) / 8];
        if (ioctl(fd, EVIOCGBIT(0, sizeof(eventTypes)), eventTypes) < 0) {
                return false;           // failed--assume not a joystick!
        }

        // we'll call it a "joystick" (or "gamepad-capable device") if it has
        //      buttons and potentiometers (absolute axes)
        if (!test_bit(EV_KEY, eventTypes) ||
            !test_bit(EV_ABS, eventTypes)) {
                return false;
        }

        // touchpads and other devices sometimes claim absolute potentiometers!
        // require at least one interesting potentiometer and button
        byte_t potTypes[(ABS_MAX + 7) / 8];
        byte_t keyTypes[(KEY_MAX + 7) / 8];
        if (ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(potTypes)), potTypes) < 0 ||
            ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(keyTypes)), keyTypes) < 0) {
                return false;   // failed to retrieve pot/key capabilities
        }

        if (!test_bit(ABS_X, potTypes) || !test_bit(ABS_Y, potTypes)) {
                return false;   // no joystick at all
        }
        if (test_bit(BTN_TRIGGER, keyTypes) ||
            test_bit(BTN_A, keyTypes) ||
            test_bit(BTN_1, keyTypes)) {
                return true;    // joystick plus at least one cool button
        }

        // got here?  No cool buttons
        return false;
}



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

        const char * key = "/dev/input/event";

        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;
}



////////////////////////////////////////////////////////////////////////////////
//
//      LIDevice -- class that implements the gamepad::SourceDevice interface
//              for Linux Input objects (using the unified event model, input.h)
//
////////////////////////////////////////////////////////////////////////////////

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

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

        // 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);
/*
        // Jan 2011: removing all force feedback support for now
        int getNumRumblers(void) throw() { return m_nRumble; }
        bool playRumble(IN int rumbleIndex,
                                IN uint16_t highFreqMagnitude,
                                IN uint16_t lowFreqMagnitude,
                                IN int durationMilliseconds);
 */

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<int>        m_buttonMap;    // local -> device
        std::vector<int>        m_potMap;       // local -> device
        std::vector<byte_t>     m_button;
        std::vector<pot_value_t> m_pot;
        std::vector<rumble_t>   m_rumble;
};


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


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



////////////////////////////////////////////////////////////////////////////////
//
//      LIDevice -- public class methods
//
////////////////////////////////////////////////////////////////////////////////

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

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

        // hopefully someday this can be removed
        if (wantForceFeedback) {
                DPRINTF("Enabling force feedback.");
                DPRINTF("Watch out for kernel crashes when you unplug the gamepad!");
        }

        // remember path
        m_path = path;

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

        // get the name of the device
        char buffer[256];
        THROW(ioctl(m_fd, EVIOCGNAME(sizeof(buffer)), buffer) >= 0,
            "Failed to acquire linux joystick device name");
        m_name = buffer;
        DPRINTF("  public name: '%s'", m_name.c_str());

        // get the device information
        struct input_id iid;
        THROW(ioctl(m_fd, EVIOCGID, &iid) >= 0,
            "Failed to acquire event input ID data");

        // construct the unique ID
        std::ostringstream out;
        out << s_prefix << ",";
        out << buffer << ",";
        out << "vendor:" << iid.vendor << ",";
        out << "product:" << iid.product << ",";
        out << "version:" << iid.version << ",";
        out << "idx:" << getInputIndex(path);

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

        // determine device capabilities
        THROW(ioctl(m_fd, EVIOCGBIT(0, sizeof(m_eventTypes)), m_eventTypes) >= 0,
            "Failed to acquire device capabilities");
        dumpCapabilities(m_eventTypes);

        // construct button map
        THROW(test_bit(EV_KEY, m_eventTypes),
            "Device reported no buttons/keys");
        m_buttonMap.clear();
        byte_t keyStats[(KEY_MAX + 7) / 8];
        THROW(ioctl(m_fd, EVIOCGBIT(EV_KEY, sizeof(keyStats)), keyStats) >= 0,
            "Failed to retrieve key/button bitfield");
        for (int i = 0; i < KEY_MAX; ++i) {
                if (test_bit(i, keyStats)) {
                        m_buttonMap.push_back(i);
                        m_button.push_back(eButtonUp);
                }
        }
        m_nButtons = m_buttonMap.size();
        DPRINTF("Found %d buttons on device", m_nButtons);

        // get count of potentiometers
        THROW(test_bit(EV_ABS, m_eventTypes),
            "Device reported no potentiometers");
        m_potMap.clear();
        byte_t potStats[(ABS_MAX + 7) / 8];
        THROW(ioctl(m_fd, EVIOCGBIT(EV_ABS, sizeof(potStats)), potStats) >= 0,
            "Failed to retrieve absolute potentiometer bitfield");
        for (int i = 0; i < ABS_MAX; ++i) {
                if (test_bit(i, potStats)) {
                        m_potMap.push_back(i);
                        pot_value_t pv;
                        m_pot.push_back(pv);
                }
        }
        m_nPots = m_potMap.size();
        DPRINTF("Found %d potentiometers on device", m_nPots);

/*
        // Jan 2011: removing all force feedback support for now
        // get count of force feedback effects (just rumble for now)
        m_nRumble = 0;
        m_rumble.clear();
        int nEffects = 0;
        if (test_bit(EV_FF, m_eventTypes) &&
            ioctl(m_fd, EVIOCGEFFECTS, &nEffects) >= 0 &&
            nEffects > 0) {
                byte_t ffStats[(FF_MAX + 7) / 8];
                if (ioctl(m_fd, EVIOCGBIT(EV_FF, sizeof(ffStats)), ffStats) >= 0) {
                        if (test_bit(FF_RUMBLE, ffStats)) {
                                m_nRumble = nEffects;
                        }
                }
        }
        DPRINTF("Found %d rumble effects", m_nRumble);

        // Ouch!  In testing I've found that repeatedly loading, playing, and
        // unloading rumble effects results in a kernel crash when I unplug the
        // gamepad (!).
        // Observed 12/7/2009 with kernel 2.6.27.38-170.2.113.fc10.i686
        if (!wantForceFeedback) {
                DPRINTF("Resetting rumble count to 0 to avoid kernel crashes");
                m_nRumble = 0;
        }
        rumble_t r;
        r.state = eFF_NotLoaded;
        r.id = -1;
        for (int i = 0; i < m_nRumble; ++i) {
                m_rumble.push_back(r);
        }
 */

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



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

eDeviceState
LIDevice::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
LIDevice::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 input_event event[32];
        while (true) {
                int len = read(m_fd, event, sizeof(event));
                if (len <= 0) {
                        break;          // no more events!
                }

                int nEvents = len / sizeof(event[0]);
                for (int i = 0; i < nEvents; ++i) {
                        int idx = -1;
                        switch (event[i].type) {
                        case EV_ABS:
                                idx = getIndex(event[i].code, m_potMap.data(), m_nPots);
                                if (idx >= 0 && idx < m_nPots) {
                                        pot_value_t& pv = m_pot[idx];
                                        pv.value = event[i].value;
                                        if (pv.value < pv.minSeen) {
                                                pv.minSeen = pv.value;
                                        }
                                        if (pv.value > pv.maxSeen) {
                                                pv.maxSeen = pv.value;
                                        }
                                }
                                break;

                        case EV_KEY:
                                idx = getIndex(event[i].code, m_buttonMap.data(), m_nButtons);
                                if (idx < 0 || idx >= m_nButtons)
                                        break;
                                if (event[i].value) {
                                        // need to set "was pushed" and "is down" bits
                                        m_button[idx] |= eButtonWasPushed;
                                        m_button[idx] |= eButtonDown;
                                } else {
                                        // need to clear "is down" bit
                                        m_button[idx] &= ~eButtonDown;

                                        // need to set "was released" bit
                                        m_button[idx] |= eButtonWasReleased;
                                }
                                break;
                        }
                }
        }
}



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



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



/*
bool
LIDevice::playRumble
(
IN int rumbleIndex,
IN uint16_t highFreqMagnitude,
IN uint16_t lowFreqMagnitude,
IN int durationMilliseconds
)
{
        THROW(rumbleIndex >= 0 && rumbleIndex < m_nRumble,
            "Invalid rumble index: " << rumbleIndex);

        rumble_t& r = m_rumble[rumbleIndex];
        bool wantPlay = (durationMilliseconds > 0) &&
            (highFreqMagnitude || lowFreqMagnitude);

        // stop if necessary
        if (eFF_Playing == r.state) {
                input_event stop;
                stop.type = EV_FF;
                stop.code = r.id;
                stop.value = 0;
                if (write(m_fd, (const void *) &stop, sizeof(stop)) <= 0) {
                        DPRINTF("Failed to stop rumble");
                        return false;
                }
                r.state = eFF_Loaded;
        }

        // unload if necessary
        if (eFF_Loaded == r.state) {
                if (ioctl(m_fd, EVIOCRMFF, r.id) < 0) {
                        DPRINTF("Failed to unload rumble");
                        return false;
                }
                r.state = eFF_NotLoaded;
                r.id = -1;
        }

        // need to load?
        if (wantPlay && eFF_NotLoaded == r.state) {
                // upload effect to device
                ff_effect e;
                e.type = FF_RUMBLE;
                e.id = -1;
                e.u.rumble.strong_magnitude = lowFreqMagnitude;
                e.u.rumble.weak_magnitude = highFreqMagnitude;
                e.replay.length = durationMilliseconds;
                e.replay.delay = 0;

                if (ioctl(m_fd, EVIOCSFF, &e) < 0) {
                        DPRINTF("Failed to upload rumble");
                        return false;
                }
                r.state = eFF_Loaded;
                r.id = e.id;
        }

        // play!
        if (wantPlay && eFF_NotLoaded != r.state) {
                input_event play;
                play.type = EV_FF;
                play.code = r.id;
                play.value = 1;
                if (write(m_fd, (const void *) &play, sizeof(play)) <= 0) {
                        DPRINTF("Failed to play rumble");
                        return false;
                }
                r.state = eFF_Playing;
        }

        // all done!
        return true;
}
 */



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

        // 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
        SetString newSet;
        struct dirent entry;
        while (dir.getNextEntry(entry)) {
                // only look at entries beginning with "event"
                if (strncmp("event", entry.d_name, 5)) {
                        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) && isInputEntry(fd)) {
                        newSet.insert(path);
                }
        }

        // copy over
        s_devicePaths = newSet;
}



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

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

        // all done
        return local;
}



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

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

        // public class methods ------------------------------------------------
        void initialize(IN bool wantForceFeedback) {
                        m_wantForceFeedback = wantForceFeedback;
                }

        // gamepad::SourceDeviceFactory class interface methods ----------------
        const char * getName(void) const throw()
                                { return "Linux Input 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 -------------------------------------------------
        bool            m_wantForceFeedback;
        device_map_t    m_devices;      // instantiated devices (path -> device)
};



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

        // 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 =
            getLinuxInputSourceDevice(path, m_wantForceFeedback);
        ASSERT(device, "failed to create linux input source device");
        m_devices[path] = device;
        return device;
}



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

smart_ptr<SourceDeviceFactory>
getLinuxInputSourceDeviceFactory
(
IN bool wantForceFeedback
)
{
        smart_ptr<Factory> local = new Factory;
        ASSERT(local, "out of memory");

        local->initialize(wantForceFeedback);

        return local;
}



};      // gamepad namespace