dolphin/Source/Core/InputCommon/ControllerInterface/evdev/evdev.cpp

// Copyright 2015 Dolphin Emulator Project
// Licensed under GPLv2+
// Refer to the license.txt file included.

#include <fcntl.h>
#include <libudev.h>
#include <map>
#include <unistd.h>

#include "Common/Assert.h"
#include "Common/Logging/Log.h"
#include "InputCommon/ControllerInterface/evdev/evdev.h"

namespace ciface
{
namespace evdev
{
static std::string GetName(const std::string& devnode)
{
  int fd = open(devnode.c_str(), O_RDWR | O_NONBLOCK);
  libevdev* dev = nullptr;
  int ret = libevdev_new_from_fd(fd, &dev);
  if (ret != 0)
  {
    close(fd);
    return std::string();
  }
  std::string res = libevdev_get_name(dev);
  libevdev_free(dev);
  close(fd);
  return res;
}

void Init(std::vector<Core::Device*>& controllerDevices)
{
  // this is used to number the joysticks
  // multiple joysticks with the same name shall get unique ids starting at 0
  std::map<std::string, int> name_counts;

  int num_controllers = 0;

  // We use Udev to find any devices. In the future this will allow for hotplugging.
  // But for now it is essentially iterating over /dev/input/event0 to event31. However if the
  // naming scheme is ever updated in the future, this *should* be forwards compatable.

  struct udev* udev = udev_new();
  _assert_msg_(PAD, udev != 0, "Couldn't initilize libudev.");

  // List all input devices
  udev_enumerate* enumerate = udev_enumerate_new(udev);
  udev_enumerate_add_match_subsystem(enumerate, "input");
  udev_enumerate_scan_devices(enumerate);
  udev_list_entry* devices = udev_enumerate_get_list_entry(enumerate);

  // Iterate over all input devices
  udev_list_entry* dev_list_entry;
  udev_list_entry_foreach(dev_list_entry, devices)
  {
    const char* path = udev_list_entry_get_name(dev_list_entry);

    udev_device* dev = udev_device_new_from_syspath(udev, path);

    const char* devnode = udev_device_get_devnode(dev);
    // We only care about devices which we have read/write access to.
    if (devnode && access(devnode, W_OK) == 0)
    {
      // Unfortunately udev gives us no way to filter out the non event device interfaces.
      // So we open it and see if it works with evdev ioctls or not.
      std::string name = GetName(devnode);
      evdevDevice* input = new evdevDevice(devnode, name_counts[name]++);

      if (input->IsInteresting())
      {
        controllerDevices.push_back(input);
        num_controllers++;
      }
      else
      {
        // Either it wasn't a evdev device, or it didn't have at least 8 buttons or two axis.
        delete input;
      }
    }
    udev_device_unref(dev);
  }
  udev_enumerate_unref(enumerate);
  udev_unref(udev);
}

evdevDevice::evdevDevice(const std::string& devnode, int id) : m_devfile(devnode), m_id(id)
{
  // The device file will be read on one of the main threads, so we open in non-blocking mode.
  m_fd = open(devnode.c_str(), O_RDWR | O_NONBLOCK);
  int ret = libevdev_new_from_fd(m_fd, &m_dev);

  if (ret != 0)
  {
    // This useally fails because the device node isn't an evdev device, such as /dev/input/js0
    m_initialized = false;
    close(m_fd);
    return;
  }

  m_name = libevdev_get_name(m_dev);

  // Controller buttons (and keyboard keys)
  int num_buttons = 0;
  for (int key = 0; key < KEY_MAX; key++)
    if (libevdev_has_event_code(m_dev, EV_KEY, key))
      AddInput(new Button(num_buttons++, key, m_dev));

  // Absolute axis (thumbsticks)
  int num_axis = 0;
  for (int axis = 0; axis < 0x100; axis++)
    if (libevdev_has_event_code(m_dev, EV_ABS, axis))
    {
      AddAnalogInputs(new Axis(num_axis, axis, false, m_dev),
                      new Axis(num_axis, axis, true, m_dev));
      num_axis++;
    }

  // Force feedback
  if (libevdev_has_event_code(m_dev, EV_FF, FF_PERIODIC))
  {
    for (auto type : {FF_SINE, FF_SQUARE, FF_TRIANGLE, FF_SAW_UP, FF_SAW_DOWN})
      if (libevdev_has_event_code(m_dev, EV_FF, type))
        AddOutput(new ForceFeedback(type, m_dev));
  }
  if (libevdev_has_event_code(m_dev, EV_FF, FF_RUMBLE))
  {
    AddOutput(new ForceFeedback(FF_RUMBLE, m_dev));
  }

  // TODO: Add leds as output devices

  m_initialized = true;
  m_interesting = num_axis >= 2 || num_buttons >= 8;
}

evdevDevice::~evdevDevice()
{
  if (m_initialized)
  {
    libevdev_free(m_dev);
    close(m_fd);
  }
}

void evdevDevice::UpdateInput()
{
  // Run through all evdev events
  // libevdev will keep track of the actual controller state internally which can be queried
  // later with libevdev_fetch_event_value()
  input_event ev;
  int rc = LIBEVDEV_READ_STATUS_SUCCESS;
  do
  {
    if (rc == LIBEVDEV_READ_STATUS_SYNC)
      rc = libevdev_next_event(m_dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
    else
      rc = libevdev_next_event(m_dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
  } while (rc >= 0);
}

std::string evdevDevice::Button::GetName() const
{
  // Buttons below 0x100 are mostly keyboard keys, and the names make sense
  if (m_code < 0x100)
  {
    const char* name = libevdev_event_code_get_name(EV_KEY, m_code);
    if (name)
      return std::string(name);
  }
  // But controllers use codes above 0x100, and the standard label often doesn't match.
  // We are better off with Button 0 and so on.
  return "Button " + std::to_string(m_index);
}

ControlState evdevDevice::Button::GetState() const
{
  int value = 0;
  libevdev_fetch_event_value(m_dev, EV_KEY, m_code, &value);
  return value;
}

evdevDevice::Axis::Axis(u8 index, u16 code, bool upper, libevdev* dev)
    : m_code(code), m_index(index), m_upper(upper), m_dev(dev)
{
  m_min = libevdev_get_abs_minimum(m_dev, m_code);
  m_range = libevdev_get_abs_maximum(m_dev, m_code) + abs(m_min);
}

std::string evdevDevice::Axis::GetName() const
{
  return "Axis " + std::to_string(m_index) + (m_upper ? "+" : "-");
}

ControlState evdevDevice::Axis::GetState() const
{
  int value = 0;
  libevdev_fetch_event_value(m_dev, EV_ABS, m_code, &value);

  // Value from 0.0 to 1.0
  ControlState fvalue = double(value - m_min) / double(m_range);

  // Split into two axis, each covering half the range from 0.0 to 1.0
  if (m_upper)
    return std::max(0.0, fvalue - 0.5) * 2.0;
  else
    return (0.5 - std::min(0.5, fvalue)) * 2.0;
}

std::string evdevDevice::ForceFeedback::GetName() const
{
  // We have some default names.
  switch (m_type)
  {
  case FF_SINE:
    return "Sine";
  case FF_TRIANGLE:
    return "Triangle";
  case FF_SQUARE:
    return "Square";
  case FF_RUMBLE:
    return "LeftRight";
  default:
  {
    const char* name = libevdev_event_code_get_name(EV_FF, m_type);
    if (name)
      return std::string(name);
    return "Unknown";
  }
  }
}

void evdevDevice::ForceFeedback::SetState(ControlState state)
{
  // libevdev doesn't have nice helpers for forcefeedback
  // we will use the file descriptors directly.

  if (m_id != -1)  // delete the previous effect (which also stops it)
  {
    ioctl(m_fd, EVIOCRMFF, m_id);
    m_id = -1;
  }

  if (state > 0)  // Upload and start an effect.
  {
    ff_effect effect;

    effect.id = -1;
    effect.direction = 0;        // down
    effect.replay.length = 500;  // 500ms
    effect.replay.delay = 0;
    effect.trigger.button = 0;  // don't trigger on button press
    effect.trigger.interval = 0;

    // This is the the interface that XInput uses, with 2 motors of differing sizes/frequencies that
    // are controlled seperatally
    if (m_type == FF_RUMBLE)
    {
      effect.type = FF_RUMBLE;
      // max ranges tuned to 'feel' similar in magnitude to triangle/sine on xbox360 controller
      effect.u.rumble.strong_magnitude = u16(state * 0x4000);
      effect.u.rumble.weak_magnitude = u16(state * 0xFFFF);
    }
    else  // FF_PERIODIC, a more generic interface.
    {
      effect.type = FF_PERIODIC;
      effect.u.periodic.waveform = m_type;
      effect.u.periodic.phase = 0x7fff;  // 180 degrees
      effect.u.periodic.offset = 0;
      effect.u.periodic.period = 10;
      effect.u.periodic.magnitude = s16(state * 0x7FFF);
      effect.u.periodic.envelope.attack_length = 0;  // no attack
      effect.u.periodic.envelope.attack_level = 0;
      effect.u.periodic.envelope.fade_length = 0;
      effect.u.periodic.envelope.fade_level = 0;
    }

    ioctl(m_fd, EVIOCSFF, &effect);
    m_id = effect.id;

    input_event play;
    play.type = EV_FF;
    play.code = m_id;
    play.value = 1;

    write(m_fd, (const void*)&play, sizeof(play));
  }
}

evdevDevice::ForceFeedback::~ForceFeedback()
{
  // delete the uploaded effect, so we don't leak it.
  if (m_id != -1)
  {
    ioctl(m_fd, EVIOCRMFF, m_id);
  }
}
}
}