drivers/hid/hid-steam.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
steam_recv_report
steam_send_report
steam_send_report_byte
steam_write_registers
steam_get_serial
steam_request_conn_status
steam_set_lizard_mode
steam_input_open
steam_input_close
steam_battery_get_property
steam_battery_register
steam_input_register
steam_input_unregister
steam_battery_unregister
steam_register
steam_unregister
steam_work_connect_cb
steam_is_valve_interface
steam_client_ll_parse
steam_client_ll_start
steam_client_ll_stop
steam_client_ll_open
steam_client_ll_close
steam_client_ll_raw_request
steam_create_client_hid
steam_probe
steam_remove
steam_do_connect_event
steam_le16
steam_do_input_event
steam_do_battery_event
steam_raw_event
steam_param_set_lizard_mode
   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * HID driver for Valve Steam Controller
   4  *
   5  * Copyright (c) 2018 Rodrigo Rivas Costa <rodrigorivascosta@gmail.com>
   6  *
   7  * Supports both the wired and wireless interfaces.
   8  *
   9  * This controller has a builtin emulation of mouse and keyboard: the right pad
  10  * can be used as a mouse, the shoulder buttons are mouse buttons, A and B
  11  * buttons are ENTER and ESCAPE, and so on. This is implemented as additional
  12  * HID interfaces.
  13  *
  14  * This is known as the "lizard mode", because apparently lizards like to use
  15  * the computer from the coach, without a proper mouse and keyboard.
  16  *
  17  * This driver will disable the lizard mode when the input device is opened
  18  * and re-enable it when the input device is closed, so as not to break user
  19  * mode behaviour. The lizard_mode parameter can be used to change that.
  20  *
  21  * There are a few user space applications (notably Steam Client) that use
  22  * the hidraw interface directly to create input devices (XTest, uinput...).
  23  * In order to avoid breaking them this driver creates a layered hidraw device,
  24  * so it can detect when the client is running and then:
  25  *  - it will not send any command to the controller.
  26  *  - this input device will be removed, to avoid double input of the same
  27  *    user action.
  28  * When the client is closed, this input device will be created again.
  29  *
  30  * For additional functions, such as changing the right-pad margin or switching
  31  * the led, you can use the user-space tool at:
  32  *
  33  *   https://github.com/rodrigorc/steamctrl
  34  */
  35 
  36 #include <linux/device.h>
  37 #include <linux/input.h>
  38 #include <linux/hid.h>
  39 #include <linux/module.h>
  40 #include <linux/workqueue.h>
  41 #include <linux/mutex.h>
  42 #include <linux/rcupdate.h>
  43 #include <linux/delay.h>
  44 #include <linux/power_supply.h>
  45 #include "hid-ids.h"
  46 
  47 MODULE_LICENSE("GPL");
  48 MODULE_AUTHOR("Rodrigo Rivas Costa <rodrigorivascosta@gmail.com>");
  49 
  50 static bool lizard_mode = true;
  51 
  52 static DEFINE_MUTEX(steam_devices_lock);
  53 static LIST_HEAD(steam_devices);
  54 
  55 #define STEAM_QUIRK_WIRELESS            BIT(0)
  56 
  57 /* Touch pads are 40 mm in diameter and 65535 units */
  58 #define STEAM_PAD_RESOLUTION 1638
  59 /* Trigger runs are about 5 mm and 256 units */
  60 #define STEAM_TRIGGER_RESOLUTION 51
  61 /* Joystick runs are about 5 mm and 256 units */
  62 #define STEAM_JOYSTICK_RESOLUTION 51
  63 
  64 #define STEAM_PAD_FUZZ 256
  65 
  66 /*
  67  * Commands that can be sent in a feature report.
  68  * Thanks to Valve for some valuable hints.
  69  */
  70 #define STEAM_CMD_SET_MAPPINGS          0x80
  71 #define STEAM_CMD_CLEAR_MAPPINGS        0x81
  72 #define STEAM_CMD_GET_MAPPINGS          0x82
  73 #define STEAM_CMD_GET_ATTRIB            0x83
  74 #define STEAM_CMD_GET_ATTRIB_LABEL      0x84
  75 #define STEAM_CMD_DEFAULT_MAPPINGS      0x85
  76 #define STEAM_CMD_FACTORY_RESET         0x86
  77 #define STEAM_CMD_WRITE_REGISTER        0x87
  78 #define STEAM_CMD_CLEAR_REGISTER        0x88
  79 #define STEAM_CMD_READ_REGISTER         0x89
  80 #define STEAM_CMD_GET_REGISTER_LABEL    0x8a
  81 #define STEAM_CMD_GET_REGISTER_MAX      0x8b
  82 #define STEAM_CMD_GET_REGISTER_DEFAULT  0x8c
  83 #define STEAM_CMD_SET_MODE              0x8d
  84 #define STEAM_CMD_DEFAULT_MOUSE         0x8e
  85 #define STEAM_CMD_FORCEFEEDBAK          0x8f
  86 #define STEAM_CMD_REQUEST_COMM_STATUS   0xb4
  87 #define STEAM_CMD_GET_SERIAL            0xae
  88 
  89 /* Some useful register ids */
  90 #define STEAM_REG_LPAD_MODE             0x07
  91 #define STEAM_REG_RPAD_MODE             0x08
  92 #define STEAM_REG_RPAD_MARGIN           0x18
  93 #define STEAM_REG_LED                   0x2d
  94 #define STEAM_REG_GYRO_MODE             0x30
  95 
  96 /* Raw event identifiers */
  97 #define STEAM_EV_INPUT_DATA             0x01
  98 #define STEAM_EV_CONNECT                0x03
  99 #define STEAM_EV_BATTERY                0x04
 100 
 101 /* Values for GYRO_MODE (bitmask) */
 102 #define STEAM_GYRO_MODE_OFF             0x0000
 103 #define STEAM_GYRO_MODE_STEERING        0x0001
 104 #define STEAM_GYRO_MODE_TILT            0x0002
 105 #define STEAM_GYRO_MODE_SEND_ORIENTATION        0x0004
 106 #define STEAM_GYRO_MODE_SEND_RAW_ACCEL          0x0008
 107 #define STEAM_GYRO_MODE_SEND_RAW_GYRO           0x0010
 108 
 109 /* Other random constants */
 110 #define STEAM_SERIAL_LEN 10
 111 
 112 struct steam_device {
 113         struct list_head list;
 114         spinlock_t lock;
 115         struct hid_device *hdev, *client_hdev;
 116         struct mutex mutex;
 117         bool client_opened;
 118         struct input_dev __rcu *input;
 119         unsigned long quirks;
 120         struct work_struct work_connect;
 121         bool connected;
 122         char serial_no[STEAM_SERIAL_LEN + 1];
 123         struct power_supply_desc battery_desc;
 124         struct power_supply __rcu *battery;
 125         u8 battery_charge;
 126         u16 voltage;
 127 };
 128 
 129 static int steam_recv_report(struct steam_device *steam,
 130                 u8 *data, int size)
 131 {
 132         struct hid_report *r;
 133         u8 *buf;
 134         int ret;
 135 
 136         r = steam->hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[0];
 137         if (hid_report_len(r) < 64)
 138                 return -EINVAL;
 139 
 140         buf = hid_alloc_report_buf(r, GFP_KERNEL);
 141         if (!buf)
 142                 return -ENOMEM;
 143 
 144         /*
 145          * The report ID is always 0, so strip the first byte from the output.
 146          * hid_report_len() is not counting the report ID, so +1 to the length
 147          * or else we get a EOVERFLOW. We are safe from a buffer overflow
 148          * because hid_alloc_report_buf() allocates +7 bytes.
 149          */
 150         ret = hid_hw_raw_request(steam->hdev, 0x00,
 151                         buf, hid_report_len(r) + 1,
 152                         HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
 153         if (ret > 0)
 154                 memcpy(data, buf + 1, min(size, ret - 1));
 155         kfree(buf);
 156         return ret;
 157 }
 158 
 159 static int steam_send_report(struct steam_device *steam,
 160                 u8 *cmd, int size)
 161 {
 162         struct hid_report *r;
 163         u8 *buf;
 164         unsigned int retries = 50;
 165         int ret;
 166 
 167         r = steam->hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[0];
 168         if (hid_report_len(r) < 64)
 169                 return -EINVAL;
 170 
 171         buf = hid_alloc_report_buf(r, GFP_KERNEL);
 172         if (!buf)
 173                 return -ENOMEM;
 174 
 175         /* The report ID is always 0 */
 176         memcpy(buf + 1, cmd, size);
 177 
 178         /*
 179          * Sometimes the wireless controller fails with EPIPE
 180          * when sending a feature report.
 181          * Doing a HID_REQ_GET_REPORT and waiting for a while
 182          * seems to fix that.
 183          */
 184         do {
 185                 ret = hid_hw_raw_request(steam->hdev, 0,
 186                                 buf, size + 1,
 187                                 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
 188                 if (ret != -EPIPE)
 189                         break;
 190                 msleep(20);
 191         } while (--retries);
 192 
 193         kfree(buf);
 194         if (ret < 0)
 195                 hid_err(steam->hdev, "%s: error %d (%*ph)\n", __func__,
 196                                 ret, size, cmd);
 197         return ret;
 198 }
 199 
 200 static inline int steam_send_report_byte(struct steam_device *steam, u8 cmd)
 201 {
 202         return steam_send_report(steam, &cmd, 1);
 203 }
 204 
 205 static int steam_write_registers(struct steam_device *steam,
 206                 /* u8 reg, u16 val */...)
 207 {
 208         /* Send: 0x87 len (reg valLo valHi)* */
 209         u8 reg;
 210         u16 val;
 211         u8 cmd[64] = {STEAM_CMD_WRITE_REGISTER, 0x00};
 212         va_list args;
 213 
 214         va_start(args, steam);
 215         for (;;) {
 216                 reg = va_arg(args, int);
 217                 if (reg == 0)
 218                         break;
 219                 val = va_arg(args, int);
 220                 cmd[cmd[1] + 2] = reg;
 221                 cmd[cmd[1] + 3] = val & 0xff;
 222                 cmd[cmd[1] + 4] = val >> 8;
 223                 cmd[1] += 3;
 224         }
 225         va_end(args);
 226 
 227         return steam_send_report(steam, cmd, 2 + cmd[1]);
 228 }
 229 
 230 static int steam_get_serial(struct steam_device *steam)
 231 {
 232         /*
 233          * Send: 0xae 0x15 0x01
 234          * Recv: 0xae 0x15 0x01 serialnumber (10 chars)
 235          */
 236         int ret;
 237         u8 cmd[] = {STEAM_CMD_GET_SERIAL, 0x15, 0x01};
 238         u8 reply[3 + STEAM_SERIAL_LEN + 1];
 239 
 240         ret = steam_send_report(steam, cmd, sizeof(cmd));
 241         if (ret < 0)
 242                 return ret;
 243         ret = steam_recv_report(steam, reply, sizeof(reply));
 244         if (ret < 0)
 245                 return ret;
 246         if (reply[0] != 0xae || reply[1] != 0x15 || reply[2] != 0x01)
 247                 return -EIO;
 248         reply[3 + STEAM_SERIAL_LEN] = 0;
 249         strlcpy(steam->serial_no, reply + 3, sizeof(steam->serial_no));
 250         return 0;
 251 }
 252 
 253 /*
 254  * This command requests the wireless adaptor to post an event
 255  * with the connection status. Useful if this driver is loaded when
 256  * the controller is already connected.
 257  */
 258 static inline int steam_request_conn_status(struct steam_device *steam)
 259 {
 260         return steam_send_report_byte(steam, STEAM_CMD_REQUEST_COMM_STATUS);
 261 }
 262 
 263 static void steam_set_lizard_mode(struct steam_device *steam, bool enable)
 264 {
 265         if (enable) {
 266                 /* enable esc, enter, cursors */
 267                 steam_send_report_byte(steam, STEAM_CMD_DEFAULT_MAPPINGS);
 268                 /* enable mouse */
 269                 steam_send_report_byte(steam, STEAM_CMD_DEFAULT_MOUSE);
 270                 steam_write_registers(steam,
 271                         STEAM_REG_RPAD_MARGIN, 0x01, /* enable margin */
 272                         0);
 273         } else {
 274                 /* disable esc, enter, cursor */
 275                 steam_send_report_byte(steam, STEAM_CMD_CLEAR_MAPPINGS);
 276                 steam_write_registers(steam,
 277                         STEAM_REG_RPAD_MODE, 0x07, /* disable mouse */
 278                         STEAM_REG_RPAD_MARGIN, 0x00, /* disable margin */
 279                         0);
 280         }
 281 }
 282 
 283 static int steam_input_open(struct input_dev *dev)
 284 {
 285         struct steam_device *steam = input_get_drvdata(dev);
 286 
 287         mutex_lock(&steam->mutex);
 288         if (!steam->client_opened && lizard_mode)
 289                 steam_set_lizard_mode(steam, false);
 290         mutex_unlock(&steam->mutex);
 291         return 0;
 292 }
 293 
 294 static void steam_input_close(struct input_dev *dev)
 295 {
 296         struct steam_device *steam = input_get_drvdata(dev);
 297 
 298         mutex_lock(&steam->mutex);
 299         if (!steam->client_opened && lizard_mode)
 300                 steam_set_lizard_mode(steam, true);
 301         mutex_unlock(&steam->mutex);
 302 }
 303 
 304 static enum power_supply_property steam_battery_props[] = {
 305         POWER_SUPPLY_PROP_PRESENT,
 306         POWER_SUPPLY_PROP_SCOPE,
 307         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 308         POWER_SUPPLY_PROP_CAPACITY,
 309 };
 310 
 311 static int steam_battery_get_property(struct power_supply *psy,
 312                                 enum power_supply_property psp,
 313                                 union power_supply_propval *val)
 314 {
 315         struct steam_device *steam = power_supply_get_drvdata(psy);
 316         unsigned long flags;
 317         s16 volts;
 318         u8 batt;
 319         int ret = 0;
 320 
 321         spin_lock_irqsave(&steam->lock, flags);
 322         volts = steam->voltage;
 323         batt = steam->battery_charge;
 324         spin_unlock_irqrestore(&steam->lock, flags);
 325 
 326         switch (psp) {
 327         case POWER_SUPPLY_PROP_PRESENT:
 328                 val->intval = 1;
 329                 break;
 330         case POWER_SUPPLY_PROP_SCOPE:
 331                 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
 332                 break;
 333         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 334                 val->intval = volts * 1000; /* mV -> uV */
 335                 break;
 336         case POWER_SUPPLY_PROP_CAPACITY:
 337                 val->intval = batt;
 338                 break;
 339         default:
 340                 ret = -EINVAL;
 341                 break;
 342         }
 343         return ret;
 344 }
 345 
 346 static int steam_battery_register(struct steam_device *steam)
 347 {
 348         struct power_supply *battery;
 349         struct power_supply_config battery_cfg = { .drv_data = steam, };
 350         unsigned long flags;
 351         int ret;
 352 
 353         steam->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;
 354         steam->battery_desc.properties = steam_battery_props;
 355         steam->battery_desc.num_properties = ARRAY_SIZE(steam_battery_props);
 356         steam->battery_desc.get_property = steam_battery_get_property;
 357         steam->battery_desc.name = devm_kasprintf(&steam->hdev->dev,
 358                         GFP_KERNEL, "steam-controller-%s-battery",
 359                         steam->serial_no);
 360         if (!steam->battery_desc.name)
 361                 return -ENOMEM;
 362 
 363         /* avoid the warning of 0% battery while waiting for the first info */
 364         spin_lock_irqsave(&steam->lock, flags);
 365         steam->voltage = 3000;
 366         steam->battery_charge = 100;
 367         spin_unlock_irqrestore(&steam->lock, flags);
 368 
 369         battery = power_supply_register(&steam->hdev->dev,
 370                         &steam->battery_desc, &battery_cfg);
 371         if (IS_ERR(battery)) {
 372                 ret = PTR_ERR(battery);
 373                 hid_err(steam->hdev,
 374                                 "%s:power_supply_register failed with error %d\n",
 375                                 __func__, ret);
 376                 return ret;
 377         }
 378         rcu_assign_pointer(steam->battery, battery);
 379         power_supply_powers(battery, &steam->hdev->dev);
 380         return 0;
 381 }
 382 
 383 static int steam_input_register(struct steam_device *steam)
 384 {
 385         struct hid_device *hdev = steam->hdev;
 386         struct input_dev *input;
 387         int ret;
 388 
 389         rcu_read_lock();
 390         input = rcu_dereference(steam->input);
 391         rcu_read_unlock();
 392         if (input) {
 393                 dbg_hid("%s: already connected\n", __func__);
 394                 return 0;
 395         }
 396 
 397         input = input_allocate_device();
 398         if (!input)
 399                 return -ENOMEM;
 400 
 401         input_set_drvdata(input, steam);
 402         input->dev.parent = &hdev->dev;
 403         input->open = steam_input_open;
 404         input->close = steam_input_close;
 405 
 406         input->name = (steam->quirks & STEAM_QUIRK_WIRELESS) ?
 407                 "Wireless Steam Controller" :
 408                 "Steam Controller";
 409         input->phys = hdev->phys;
 410         input->uniq = steam->serial_no;
 411         input->id.bustype = hdev->bus;
 412         input->id.vendor = hdev->vendor;
 413         input->id.product = hdev->product;
 414         input->id.version = hdev->version;
 415 
 416         input_set_capability(input, EV_KEY, BTN_TR2);
 417         input_set_capability(input, EV_KEY, BTN_TL2);
 418         input_set_capability(input, EV_KEY, BTN_TR);
 419         input_set_capability(input, EV_KEY, BTN_TL);
 420         input_set_capability(input, EV_KEY, BTN_Y);
 421         input_set_capability(input, EV_KEY, BTN_B);
 422         input_set_capability(input, EV_KEY, BTN_X);
 423         input_set_capability(input, EV_KEY, BTN_A);
 424         input_set_capability(input, EV_KEY, BTN_DPAD_UP);
 425         input_set_capability(input, EV_KEY, BTN_DPAD_RIGHT);
 426         input_set_capability(input, EV_KEY, BTN_DPAD_LEFT);
 427         input_set_capability(input, EV_KEY, BTN_DPAD_DOWN);
 428         input_set_capability(input, EV_KEY, BTN_SELECT);
 429         input_set_capability(input, EV_KEY, BTN_MODE);
 430         input_set_capability(input, EV_KEY, BTN_START);
 431         input_set_capability(input, EV_KEY, BTN_GEAR_DOWN);
 432         input_set_capability(input, EV_KEY, BTN_GEAR_UP);
 433         input_set_capability(input, EV_KEY, BTN_THUMBR);
 434         input_set_capability(input, EV_KEY, BTN_THUMBL);
 435         input_set_capability(input, EV_KEY, BTN_THUMB);
 436         input_set_capability(input, EV_KEY, BTN_THUMB2);
 437 
 438         input_set_abs_params(input, ABS_HAT2Y, 0, 255, 0, 0);
 439         input_set_abs_params(input, ABS_HAT2X, 0, 255, 0, 0);
 440         input_set_abs_params(input, ABS_X, -32767, 32767, 0, 0);
 441         input_set_abs_params(input, ABS_Y, -32767, 32767, 0, 0);
 442         input_set_abs_params(input, ABS_RX, -32767, 32767,
 443                         STEAM_PAD_FUZZ, 0);
 444         input_set_abs_params(input, ABS_RY, -32767, 32767,
 445                         STEAM_PAD_FUZZ, 0);
 446         input_set_abs_params(input, ABS_HAT0X, -32767, 32767,
 447                         STEAM_PAD_FUZZ, 0);
 448         input_set_abs_params(input, ABS_HAT0Y, -32767, 32767,
 449                         STEAM_PAD_FUZZ, 0);
 450         input_abs_set_res(input, ABS_X, STEAM_JOYSTICK_RESOLUTION);
 451         input_abs_set_res(input, ABS_Y, STEAM_JOYSTICK_RESOLUTION);
 452         input_abs_set_res(input, ABS_RX, STEAM_PAD_RESOLUTION);
 453         input_abs_set_res(input, ABS_RY, STEAM_PAD_RESOLUTION);
 454         input_abs_set_res(input, ABS_HAT0X, STEAM_PAD_RESOLUTION);
 455         input_abs_set_res(input, ABS_HAT0Y, STEAM_PAD_RESOLUTION);
 456         input_abs_set_res(input, ABS_HAT2Y, STEAM_TRIGGER_RESOLUTION);
 457         input_abs_set_res(input, ABS_HAT2X, STEAM_TRIGGER_RESOLUTION);
 458 
 459         ret = input_register_device(input);
 460         if (ret)
 461                 goto input_register_fail;
 462 
 463         rcu_assign_pointer(steam->input, input);
 464         return 0;
 465 
 466 input_register_fail:
 467         input_free_device(input);
 468         return ret;
 469 }
 470 
 471 static void steam_input_unregister(struct steam_device *steam)
 472 {
 473         struct input_dev *input;
 474         rcu_read_lock();
 475         input = rcu_dereference(steam->input);
 476         rcu_read_unlock();
 477         if (!input)
 478                 return;
 479         RCU_INIT_POINTER(steam->input, NULL);
 480         synchronize_rcu();
 481         input_unregister_device(input);
 482 }
 483 
 484 static void steam_battery_unregister(struct steam_device *steam)
 485 {
 486         struct power_supply *battery;
 487 
 488         rcu_read_lock();
 489         battery = rcu_dereference(steam->battery);
 490         rcu_read_unlock();
 491 
 492         if (!battery)
 493                 return;
 494         RCU_INIT_POINTER(steam->battery, NULL);
 495         synchronize_rcu();
 496         power_supply_unregister(battery);
 497 }
 498 
 499 static int steam_register(struct steam_device *steam)
 500 {
 501         int ret;
 502         bool client_opened;
 503 
 504         /*
 505          * This function can be called several times in a row with the
 506          * wireless adaptor, without steam_unregister() between them, because
 507          * another client send a get_connection_status command, for example.
 508          * The battery and serial number are set just once per device.
 509          */
 510         if (!steam->serial_no[0]) {
 511                 /*
 512                  * Unlikely, but getting the serial could fail, and it is not so
 513                  * important, so make up a serial number and go on.
 514                  */
 515                 mutex_lock(&steam->mutex);
 516                 if (steam_get_serial(steam) < 0)
 517                         strlcpy(steam->serial_no, "XXXXXXXXXX",
 518                                         sizeof(steam->serial_no));
 519                 mutex_unlock(&steam->mutex);
 520 
 521                 hid_info(steam->hdev, "Steam Controller '%s' connected",
 522                                 steam->serial_no);
 523 
 524                 /* ignore battery errors, we can live without it */
 525                 if (steam->quirks & STEAM_QUIRK_WIRELESS)
 526                         steam_battery_register(steam);
 527 
 528                 mutex_lock(&steam_devices_lock);
 529                 list_add(&steam->list, &steam_devices);
 530                 mutex_unlock(&steam_devices_lock);
 531         }
 532 
 533         mutex_lock(&steam->mutex);
 534         client_opened = steam->client_opened;
 535         if (!client_opened)
 536                 steam_set_lizard_mode(steam, lizard_mode);
 537         mutex_unlock(&steam->mutex);
 538 
 539         if (!client_opened)
 540                 ret = steam_input_register(steam);
 541         else
 542                 ret = 0;
 543 
 544         return ret;
 545 }
 546 
 547 static void steam_unregister(struct steam_device *steam)
 548 {
 549         steam_battery_unregister(steam);
 550         steam_input_unregister(steam);
 551         if (steam->serial_no[0]) {
 552                 hid_info(steam->hdev, "Steam Controller '%s' disconnected",
 553                                 steam->serial_no);
 554                 mutex_lock(&steam_devices_lock);
 555                 list_del(&steam->list);
 556                 mutex_unlock(&steam_devices_lock);
 557                 steam->serial_no[0] = 0;
 558         }
 559 }
 560 
 561 static void steam_work_connect_cb(struct work_struct *work)
 562 {
 563         struct steam_device *steam = container_of(work, struct steam_device,
 564                                                         work_connect);
 565         unsigned long flags;
 566         bool connected;
 567         int ret;
 568 
 569         spin_lock_irqsave(&steam->lock, flags);
 570         connected = steam->connected;
 571         spin_unlock_irqrestore(&steam->lock, flags);
 572 
 573         if (connected) {
 574                 ret = steam_register(steam);
 575                 if (ret) {
 576                         hid_err(steam->hdev,
 577                                 "%s:steam_register failed with error %d\n",
 578                                 __func__, ret);
 579                 }
 580         } else {
 581                 steam_unregister(steam);
 582         }
 583 }
 584 
 585 static bool steam_is_valve_interface(struct hid_device *hdev)
 586 {
 587         struct hid_report_enum *rep_enum;
 588 
 589         /*
 590          * The wired device creates 3 interfaces:
 591          *  0: emulated mouse.
 592          *  1: emulated keyboard.
 593          *  2: the real game pad.
 594          * The wireless device creates 5 interfaces:
 595          *  0: emulated keyboard.
 596          *  1-4: slots where up to 4 real game pads will be connected to.
 597          * We know which one is the real gamepad interface because they are the
 598          * only ones with a feature report.
 599          */
 600         rep_enum = &hdev->report_enum[HID_FEATURE_REPORT];
 601         return !list_empty(&rep_enum->report_list);
 602 }
 603 
 604 static int steam_client_ll_parse(struct hid_device *hdev)
 605 {
 606         struct steam_device *steam = hdev->driver_data;
 607 
 608         return hid_parse_report(hdev, steam->hdev->dev_rdesc,
 609                         steam->hdev->dev_rsize);
 610 }
 611 
 612 static int steam_client_ll_start(struct hid_device *hdev)
 613 {
 614         return 0;
 615 }
 616 
 617 static void steam_client_ll_stop(struct hid_device *hdev)
 618 {
 619 }
 620 
 621 static int steam_client_ll_open(struct hid_device *hdev)
 622 {
 623         struct steam_device *steam = hdev->driver_data;
 624 
 625         mutex_lock(&steam->mutex);
 626         steam->client_opened = true;
 627         mutex_unlock(&steam->mutex);
 628 
 629         steam_input_unregister(steam);
 630 
 631         return 0;
 632 }
 633 
 634 static void steam_client_ll_close(struct hid_device *hdev)
 635 {
 636         struct steam_device *steam = hdev->driver_data;
 637 
 638         unsigned long flags;
 639         bool connected;
 640 
 641         spin_lock_irqsave(&steam->lock, flags);
 642         connected = steam->connected;
 643         spin_unlock_irqrestore(&steam->lock, flags);
 644 
 645         mutex_lock(&steam->mutex);
 646         steam->client_opened = false;
 647         if (connected)
 648                 steam_set_lizard_mode(steam, lizard_mode);
 649         mutex_unlock(&steam->mutex);
 650 
 651         if (connected)
 652                 steam_input_register(steam);
 653 }
 654 
 655 static int steam_client_ll_raw_request(struct hid_device *hdev,
 656                                 unsigned char reportnum, u8 *buf,
 657                                 size_t count, unsigned char report_type,
 658                                 int reqtype)
 659 {
 660         struct steam_device *steam = hdev->driver_data;
 661 
 662         return hid_hw_raw_request(steam->hdev, reportnum, buf, count,
 663                         report_type, reqtype);
 664 }
 665 
 666 static struct hid_ll_driver steam_client_ll_driver = {
 667         .parse = steam_client_ll_parse,
 668         .start = steam_client_ll_start,
 669         .stop = steam_client_ll_stop,
 670         .open = steam_client_ll_open,
 671         .close = steam_client_ll_close,
 672         .raw_request = steam_client_ll_raw_request,
 673 };
 674 
 675 static struct hid_device *steam_create_client_hid(struct hid_device *hdev)
 676 {
 677         struct hid_device *client_hdev;
 678 
 679         client_hdev = hid_allocate_device();
 680         if (IS_ERR(client_hdev))
 681                 return client_hdev;
 682 
 683         client_hdev->ll_driver = &steam_client_ll_driver;
 684         client_hdev->dev.parent = hdev->dev.parent;
 685         client_hdev->bus = hdev->bus;
 686         client_hdev->vendor = hdev->vendor;
 687         client_hdev->product = hdev->product;
 688         client_hdev->version = hdev->version;
 689         client_hdev->type = hdev->type;
 690         client_hdev->country = hdev->country;
 691         strlcpy(client_hdev->name, hdev->name,
 692                         sizeof(client_hdev->name));
 693         strlcpy(client_hdev->phys, hdev->phys,
 694                         sizeof(client_hdev->phys));
 695         /*
 696          * Since we use the same device info than the real interface to
 697          * trick userspace, we will be calling steam_probe recursively.
 698          * We need to recognize the client interface somehow.
 699          */
 700         client_hdev->group = HID_GROUP_STEAM;
 701         return client_hdev;
 702 }
 703 
 704 static int steam_probe(struct hid_device *hdev,
 705                                 const struct hid_device_id *id)
 706 {
 707         struct steam_device *steam;
 708         int ret;
 709 
 710         ret = hid_parse(hdev);
 711         if (ret) {
 712                 hid_err(hdev,
 713                         "%s:parse of hid interface failed\n", __func__);
 714                 return ret;
 715         }
 716 
 717         /*
 718          * The virtual client_dev is only used for hidraw.
 719          * Also avoid the recursive probe.
 720          */
 721         if (hdev->group == HID_GROUP_STEAM)
 722                 return hid_hw_start(hdev, HID_CONNECT_HIDRAW);
 723         /*
 724          * The non-valve interfaces (mouse and keyboard emulation) are
 725          * connected without changes.
 726          */
 727         if (!steam_is_valve_interface(hdev))
 728                 return hid_hw_start(hdev, HID_CONNECT_DEFAULT);
 729 
 730         steam = devm_kzalloc(&hdev->dev, sizeof(*steam), GFP_KERNEL);
 731         if (!steam) {
 732                 ret = -ENOMEM;
 733                 goto steam_alloc_fail;
 734         }
 735         steam->hdev = hdev;
 736         hid_set_drvdata(hdev, steam);
 737         spin_lock_init(&steam->lock);
 738         mutex_init(&steam->mutex);
 739         steam->quirks = id->driver_data;
 740         INIT_WORK(&steam->work_connect, steam_work_connect_cb);
 741 
 742         steam->client_hdev = steam_create_client_hid(hdev);
 743         if (IS_ERR(steam->client_hdev)) {
 744                 ret = PTR_ERR(steam->client_hdev);
 745                 goto client_hdev_fail;
 746         }
 747         steam->client_hdev->driver_data = steam;
 748 
 749         /*
 750          * With the real steam controller interface, do not connect hidraw.
 751          * Instead, create the client_hid and connect that.
 752          */
 753         ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_HIDRAW);
 754         if (ret)
 755                 goto hid_hw_start_fail;
 756 
 757         ret = hid_add_device(steam->client_hdev);
 758         if (ret)
 759                 goto client_hdev_add_fail;
 760 
 761         ret = hid_hw_open(hdev);
 762         if (ret) {
 763                 hid_err(hdev,
 764                         "%s:hid_hw_open\n",
 765                         __func__);
 766                 goto hid_hw_open_fail;
 767         }
 768 
 769         if (steam->quirks & STEAM_QUIRK_WIRELESS) {
 770                 hid_info(hdev, "Steam wireless receiver connected");
 771                 /* If using a wireless adaptor ask for connection status */
 772                 steam->connected = false;
 773                 steam_request_conn_status(steam);
 774         } else {
 775                 /* A wired connection is always present */
 776                 steam->connected = true;
 777                 ret = steam_register(steam);
 778                 if (ret) {
 779                         hid_err(hdev,
 780                                 "%s:steam_register failed with error %d\n",
 781                                 __func__, ret);
 782                         goto input_register_fail;
 783                 }
 784         }
 785 
 786         return 0;
 787 
 788 input_register_fail:
 789 hid_hw_open_fail:
 790 client_hdev_add_fail:
 791         hid_hw_stop(hdev);
 792 hid_hw_start_fail:
 793         hid_destroy_device(steam->client_hdev);
 794 client_hdev_fail:
 795         cancel_work_sync(&steam->work_connect);
 796 steam_alloc_fail:
 797         hid_err(hdev, "%s: failed with error %d\n",
 798                         __func__, ret);
 799         return ret;
 800 }
 801 
 802 static void steam_remove(struct hid_device *hdev)
 803 {
 804         struct steam_device *steam = hid_get_drvdata(hdev);
 805 
 806         if (!steam || hdev->group == HID_GROUP_STEAM) {
 807                 hid_hw_stop(hdev);
 808                 return;
 809         }
 810 
 811         hid_destroy_device(steam->client_hdev);
 812         steam->client_opened = false;
 813         cancel_work_sync(&steam->work_connect);
 814         if (steam->quirks & STEAM_QUIRK_WIRELESS) {
 815                 hid_info(hdev, "Steam wireless receiver disconnected");
 816         }
 817         hid_hw_close(hdev);
 818         hid_hw_stop(hdev);
 819         steam_unregister(steam);
 820 }
 821 
 822 static void steam_do_connect_event(struct steam_device *steam, bool connected)
 823 {
 824         unsigned long flags;
 825         bool changed;
 826 
 827         spin_lock_irqsave(&steam->lock, flags);
 828         changed = steam->connected != connected;
 829         steam->connected = connected;
 830         spin_unlock_irqrestore(&steam->lock, flags);
 831 
 832         if (changed && schedule_work(&steam->work_connect) == 0)
 833                 dbg_hid("%s: connected=%d event already queued\n",
 834                                 __func__, connected);
 835 }
 836 
 837 /*
 838  * Some input data in the protocol has the opposite sign.
 839  * Clamp the values to 32767..-32767 so that the range is
 840  * symmetrical and can be negated safely.
 841  */
 842 static inline s16 steam_le16(u8 *data)
 843 {
 844         s16 x = (s16) le16_to_cpup((__le16 *)data);
 845 
 846         return x == -32768 ? -32767 : x;
 847 }
 848 
 849 /*
 850  * The size for this message payload is 60.
 851  * The known values are:
 852  *  (* values are not sent through wireless)
 853  *  (* accelerator/gyro is disabled by default)
 854  *  Offset| Type  | Mapped to |Meaning
 855  * -------+-------+-----------+--------------------------
 856  *  4-7   | u32   | --        | sequence number
 857  *  8-10  | 24bit | see below | buttons
 858  *  11    | u8    | ABS_HAT2Y | left trigger
 859  *  12    | u8    | ABS_HAT2X | right trigger
 860  *  13-15 | --    | --        | always 0
 861  *  16-17 | s16   | ABS_X/ABS_HAT0X     | X value
 862  *  18-19 | s16   | ABS_Y/ABS_HAT0Y     | Y value
 863  *  20-21 | s16   | ABS_RX    | right-pad X value
 864  *  22-23 | s16   | ABS_RY    | right-pad Y value
 865  *  24-25 | s16   | --        | * left trigger
 866  *  26-27 | s16   | --        | * right trigger
 867  *  28-29 | s16   | --        | * accelerometer X value
 868  *  30-31 | s16   | --        | * accelerometer Y value
 869  *  32-33 | s16   | --        | * accelerometer Z value
 870  *  34-35 | s16   | --        | gyro X value
 871  *  36-36 | s16   | --        | gyro Y value
 872  *  38-39 | s16   | --        | gyro Z value
 873  *  40-41 | s16   | --        | quaternion W value
 874  *  42-43 | s16   | --        | quaternion X value
 875  *  44-45 | s16   | --        | quaternion Y value
 876  *  46-47 | s16   | --        | quaternion Z value
 877  *  48-49 | --    | --        | always 0
 878  *  50-51 | s16   | --        | * left trigger (uncalibrated)
 879  *  52-53 | s16   | --        | * right trigger (uncalibrated)
 880  *  54-55 | s16   | --        | * joystick X value (uncalibrated)
 881  *  56-57 | s16   | --        | * joystick Y value (uncalibrated)
 882  *  58-59 | s16   | --        | * left-pad X value
 883  *  60-61 | s16   | --        | * left-pad Y value
 884  *  62-63 | u16   | --        | * battery voltage
 885  *
 886  * The buttons are:
 887  *  Bit  | Mapped to  | Description
 888  * ------+------------+--------------------------------
 889  *  8.0  | BTN_TR2    | right trigger fully pressed
 890  *  8.1  | BTN_TL2    | left trigger fully pressed
 891  *  8.2  | BTN_TR     | right shoulder
 892  *  8.3  | BTN_TL     | left shoulder
 893  *  8.4  | BTN_Y      | button Y
 894  *  8.5  | BTN_B      | button B
 895  *  8.6  | BTN_X      | button X
 896  *  8.7  | BTN_A      | button A
 897  *  9.0  | BTN_DPAD_UP    | lef-pad up
 898  *  9.1  | BTN_DPAD_RIGHT | lef-pad right
 899  *  9.2  | BTN_DPAD_LEFT  | lef-pad left
 900  *  9.3  | BTN_DPAD_DOWN  | lef-pad down
 901  *  9.4  | BTN_SELECT | menu left
 902  *  9.5  | BTN_MODE   | steam logo
 903  *  9.6  | BTN_START  | menu right
 904  *  9.7  | BTN_GEAR_DOWN | left back lever
 905  * 10.0  | BTN_GEAR_UP   | right back lever
 906  * 10.1  | --         | left-pad clicked
 907  * 10.2  | BTN_THUMBR | right-pad clicked
 908  * 10.3  | BTN_THUMB  | left-pad touched (but see explanation below)
 909  * 10.4  | BTN_THUMB2 | right-pad touched
 910  * 10.5  | --         | unknown
 911  * 10.6  | BTN_THUMBL | joystick clicked
 912  * 10.7  | --         | lpad_and_joy
 913  */
 914 
 915 static void steam_do_input_event(struct steam_device *steam,
 916                 struct input_dev *input, u8 *data)
 917 {
 918         /* 24 bits of buttons */
 919         u8 b8, b9, b10;
 920         s16 x, y;
 921         bool lpad_touched, lpad_and_joy;
 922 
 923         b8 = data[8];
 924         b9 = data[9];
 925         b10 = data[10];
 926 
 927         input_report_abs(input, ABS_HAT2Y, data[11]);
 928         input_report_abs(input, ABS_HAT2X, data[12]);
 929 
 930         /*
 931          * These two bits tells how to interpret the values X and Y.
 932          * lpad_and_joy tells that the joystick and the lpad are used at the
 933          * same time.
 934          * lpad_touched tells whether X/Y are to be read as lpad coord or
 935          * joystick values.
 936          * (lpad_touched || lpad_and_joy) tells if the lpad is really touched.
 937          */
 938         lpad_touched = b10 & BIT(3);
 939         lpad_and_joy = b10 & BIT(7);
 940         x = steam_le16(data + 16);
 941         y = -steam_le16(data + 18);
 942 
 943         input_report_abs(input, lpad_touched ? ABS_HAT0X : ABS_X, x);
 944         input_report_abs(input, lpad_touched ? ABS_HAT0Y : ABS_Y, y);
 945         /* Check if joystick is centered */
 946         if (lpad_touched && !lpad_and_joy) {
 947                 input_report_abs(input, ABS_X, 0);
 948                 input_report_abs(input, ABS_Y, 0);
 949         }
 950         /* Check if lpad is untouched */
 951         if (!(lpad_touched || lpad_and_joy)) {
 952                 input_report_abs(input, ABS_HAT0X, 0);
 953                 input_report_abs(input, ABS_HAT0Y, 0);
 954         }
 955 
 956         input_report_abs(input, ABS_RX, steam_le16(data + 20));
 957         input_report_abs(input, ABS_RY, -steam_le16(data + 22));
 958 
 959         input_event(input, EV_KEY, BTN_TR2, !!(b8 & BIT(0)));
 960         input_event(input, EV_KEY, BTN_TL2, !!(b8 & BIT(1)));
 961         input_event(input, EV_KEY, BTN_TR, !!(b8 & BIT(2)));
 962         input_event(input, EV_KEY, BTN_TL, !!(b8 & BIT(3)));
 963         input_event(input, EV_KEY, BTN_Y, !!(b8 & BIT(4)));
 964         input_event(input, EV_KEY, BTN_B, !!(b8 & BIT(5)));
 965         input_event(input, EV_KEY, BTN_X, !!(b8 & BIT(6)));
 966         input_event(input, EV_KEY, BTN_A, !!(b8 & BIT(7)));
 967         input_event(input, EV_KEY, BTN_SELECT, !!(b9 & BIT(4)));
 968         input_event(input, EV_KEY, BTN_MODE, !!(b9 & BIT(5)));
 969         input_event(input, EV_KEY, BTN_START, !!(b9 & BIT(6)));
 970         input_event(input, EV_KEY, BTN_GEAR_DOWN, !!(b9 & BIT(7)));
 971         input_event(input, EV_KEY, BTN_GEAR_UP, !!(b10 & BIT(0)));
 972         input_event(input, EV_KEY, BTN_THUMBR, !!(b10 & BIT(2)));
 973         input_event(input, EV_KEY, BTN_THUMBL, !!(b10 & BIT(6)));
 974         input_event(input, EV_KEY, BTN_THUMB, lpad_touched || lpad_and_joy);
 975         input_event(input, EV_KEY, BTN_THUMB2, !!(b10 & BIT(4)));
 976         input_event(input, EV_KEY, BTN_DPAD_UP, !!(b9 & BIT(0)));
 977         input_event(input, EV_KEY, BTN_DPAD_RIGHT, !!(b9 & BIT(1)));
 978         input_event(input, EV_KEY, BTN_DPAD_LEFT, !!(b9 & BIT(2)));
 979         input_event(input, EV_KEY, BTN_DPAD_DOWN, !!(b9 & BIT(3)));
 980 
 981         input_sync(input);
 982 }
 983 
 984 /*
 985  * The size for this message payload is 11.
 986  * The known values are:
 987  *  Offset| Type  | Meaning
 988  * -------+-------+---------------------------
 989  *  4-7   | u32   | sequence number
 990  *  8-11  | --    | always 0
 991  *  12-13 | u16   | voltage (mV)
 992  *  14    | u8    | battery percent
 993  */
 994 static void steam_do_battery_event(struct steam_device *steam,
 995                 struct power_supply *battery, u8 *data)
 996 {
 997         unsigned long flags;
 998 
 999         s16 volts = steam_le16(data + 12);
1000         u8 batt = data[14];
1001 
1002         /* Creating the battery may have failed */
1003         rcu_read_lock();
1004         battery = rcu_dereference(steam->battery);
1005         if (likely(battery)) {
1006                 spin_lock_irqsave(&steam->lock, flags);
1007                 steam->voltage = volts;
1008                 steam->battery_charge = batt;
1009                 spin_unlock_irqrestore(&steam->lock, flags);
1010                 power_supply_changed(battery);
1011         }
1012         rcu_read_unlock();
1013 }
1014 
1015 static int steam_raw_event(struct hid_device *hdev,
1016                         struct hid_report *report, u8 *data,
1017                         int size)
1018 {
1019         struct steam_device *steam = hid_get_drvdata(hdev);
1020         struct input_dev *input;
1021         struct power_supply *battery;
1022 
1023         if (!steam)
1024                 return 0;
1025 
1026         if (steam->client_opened)
1027                 hid_input_report(steam->client_hdev, HID_FEATURE_REPORT,
1028                                 data, size, 0);
1029         /*
1030          * All messages are size=64, all values little-endian.
1031          * The format is:
1032          *  Offset| Meaning
1033          * -------+--------------------------------------------
1034          *  0-1   | always 0x01, 0x00, maybe protocol version?
1035          *  2     | type of message
1036          *  3     | length of the real payload (not checked)
1037          *  4-n   | payload data, depends on the type
1038          *
1039          * There are these known types of message:
1040          *  0x01: input data (60 bytes)
1041          *  0x03: wireless connect/disconnect (1 byte)
1042          *  0x04: battery status (11 bytes)
1043          */
1044 
1045         if (size != 64 || data[0] != 1 || data[1] != 0)
1046                 return 0;
1047 
1048         switch (data[2]) {
1049         case STEAM_EV_INPUT_DATA:
1050                 if (steam->client_opened)
1051                         return 0;
1052                 rcu_read_lock();
1053                 input = rcu_dereference(steam->input);
1054                 if (likely(input))
1055                         steam_do_input_event(steam, input, data);
1056                 rcu_read_unlock();
1057                 break;
1058         case STEAM_EV_CONNECT:
1059                 /*
1060                  * The payload of this event is a single byte:
1061                  *  0x01: disconnected.
1062                  *  0x02: connected.
1063                  */
1064                 switch (data[4]) {
1065                 case 0x01:
1066                         steam_do_connect_event(steam, false);
1067                         break;
1068                 case 0x02:
1069                         steam_do_connect_event(steam, true);
1070                         break;
1071                 }
1072                 break;
1073         case STEAM_EV_BATTERY:
1074                 if (steam->quirks & STEAM_QUIRK_WIRELESS) {
1075                         rcu_read_lock();
1076                         battery = rcu_dereference(steam->battery);
1077                         if (likely(battery)) {
1078                                 steam_do_battery_event(steam, battery, data);
1079                         } else {
1080                                 dbg_hid(
1081                                         "%s: battery data without connect event\n",
1082                                         __func__);
1083                                 steam_do_connect_event(steam, true);
1084                         }
1085                         rcu_read_unlock();
1086                 }
1087                 break;
1088         }
1089         return 0;
1090 }
1091 
1092 static int steam_param_set_lizard_mode(const char *val,
1093                                         const struct kernel_param *kp)
1094 {
1095         struct steam_device *steam;
1096         int ret;
1097 
1098         ret = param_set_bool(val, kp);
1099         if (ret)
1100                 return ret;
1101 
1102         mutex_lock(&steam_devices_lock);
1103         list_for_each_entry(steam, &steam_devices, list) {
1104                 mutex_lock(&steam->mutex);
1105                 if (!steam->client_opened)
1106                         steam_set_lizard_mode(steam, lizard_mode);
1107                 mutex_unlock(&steam->mutex);
1108         }
1109         mutex_unlock(&steam_devices_lock);
1110         return 0;
1111 }
1112 
1113 static const struct kernel_param_ops steam_lizard_mode_ops = {
1114         .set    = steam_param_set_lizard_mode,
1115         .get    = param_get_bool,
1116 };
1117 
1118 module_param_cb(lizard_mode, &steam_lizard_mode_ops, &lizard_mode, 0644);
1119 MODULE_PARM_DESC(lizard_mode,
1120         "Enable mouse and keyboard emulation (lizard mode) when the gamepad is not in use");
1121 
1122 static const struct hid_device_id steam_controllers[] = {
1123         { /* Wired Steam Controller */
1124           HID_USB_DEVICE(USB_VENDOR_ID_VALVE,
1125                 USB_DEVICE_ID_STEAM_CONTROLLER)
1126         },
1127         { /* Wireless Steam Controller */
1128           HID_USB_DEVICE(USB_VENDOR_ID_VALVE,
1129                 USB_DEVICE_ID_STEAM_CONTROLLER_WIRELESS),
1130           .driver_data = STEAM_QUIRK_WIRELESS
1131         },
1132         {}
1133 };
1134 
1135 MODULE_DEVICE_TABLE(hid, steam_controllers);
1136 
1137 static struct hid_driver steam_controller_driver = {
1138         .name = "hid-steam",
1139         .id_table = steam_controllers,
1140         .probe = steam_probe,
1141         .remove = steam_remove,
1142         .raw_event = steam_raw_event,
1143 };
1144 
1145 module_hid_driver(steam_controller_driver);
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/hid/hid-steam.c

DEFINITIONS
