Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit cd636458 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input 

Pull some more input subsystem updates from Dmitry Torokhov:
 "An updated xpad driver with a few more recognized device IDs, and a
  new psxpad-spi driver, allowing connecting Playstation 1 and 2 joypads
  via SPI bus"

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input:
  Input: cros_ec_keyb - remove extraneous 'const'
  Input: add support for PlayStation 1/2 joypads connected via SPI
  Input: xpad - add USB IDs for Mad Catz Brawlstick and Razer Sabertooth
  Input: xpad - sync supported devices with xboxdrv
  Input: xpad - sort supported devices by USB ID
parents b53c4d5e 3af92561

drivers/input/joystick/Kconfig

+21 −0
Original line number Diff line number Diff line
@@ -330,4 +330,25 @@ config JOYSTICK_MAPLE 
	  To compile this as a module choose M here: the module will be called

	  maplecontrol.



config JOYSTICK_PSXPAD_SPI

	tristate "PlayStation 1/2 joypads via SPI interface"

	depends on SPI

	select INPUT_POLLDEV

	help

	  Say Y here if you wish to connect PlayStation 1/2 joypads

	  via SPI interface.



	  To compile this driver as a module, choose M here: the

	  module will be called psxpad-spi.



config JOYSTICK_PSXPAD_SPI_FF

	bool "PlayStation 1/2 joypads force feedback (rumble) support"

	depends on JOYSTICK_PSXPAD_SPI

	select INPUT_FF_MEMLESS

	help

	  Say Y here if you want to take advantage of PlayStation 1/2

	  joypads rumble features.



	  To drive rumble motor a dedicated power supply is required.



endif

drivers/input/joystick/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -21,6 +21,7 @@ obj-$(CONFIG_JOYSTICK_INTERACT) += interact.o 
obj-$(CONFIG_JOYSTICK_JOYDUMP)		+= joydump.o

obj-$(CONFIG_JOYSTICK_MAGELLAN)		+= magellan.o

obj-$(CONFIG_JOYSTICK_MAPLE)		+= maplecontrol.o

obj-$(CONFIG_JOYSTICK_PSXPAD_SPI)	+= psxpad-spi.o

obj-$(CONFIG_JOYSTICK_SIDEWINDER)	+= sidewinder.o

obj-$(CONFIG_JOYSTICK_SPACEBALL)	+= spaceball.o

obj-$(CONFIG_JOYSTICK_SPACEORB)		+= spaceorb.o

drivers/input/joystick/psxpad-spi.c

0 → 100644
+401 −0
Original line number Diff line number Diff line 
/*

 * PlayStation 1/2 joypads via SPI interface Driver

 *

 * Copyright (C) 2017 Tomohiro Yoshidomi <sylph23k@gmail.com>

 * Licensed under the GPL-2 or later.

 *

 * PlayStation 1/2 joypad's plug (not socket)

 *  123 456 789

 * (...|...|...)

 *

 * 1: DAT -> MISO (pullup with 1k owm to 3.3V)

 * 2: CMD -> MOSI

 * 3: 9V (for motor, if not use N.C.)

 * 4: GND

 * 5: 3.3V

 * 6: Attention -> CS(SS)

 * 7: SCK -> SCK

 * 8: N.C.

 * 9: ACK -> N.C.

 */



#include <linux/kernel.h>

#include <linux/device.h>

#include <linux/input.h>

#include <linux/input-polldev.h>

#include <linux/module.h>

#include <linux/spi/spi.h>

#include <linux/types.h>

#include <linux/pm.h>

#include <linux/pm_runtime.h>



#define REVERSE_BIT(x) ((((x) & 0x80) >> 7) | (((x) & 0x40) >> 5) | \

	(((x) & 0x20) >> 3) | (((x) & 0x10) >> 1) | (((x) & 0x08) << 1) | \

	(((x) & 0x04) << 3) | (((x) & 0x02) << 5) | (((x) & 0x01) << 7))



/* PlayStation 1/2 joypad command and response are LSBFIRST. */



/*

 *	0x01, 0x42, 0x00, 0x00, 0x00,

 *	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

 *	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00

 */

static const u8 PSX_CMD_POLL[] = {

	0x80, 0x42, 0x00, 0x00, 0x00,

	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00

};

/*	0x01, 0x43, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 */

static const u8 PSX_CMD_ENTER_CFG[] = {

	0x80, 0xC2, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00

};

/*	0x01, 0x43, 0x00, 0x00, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A */

static const u8 PSX_CMD_EXIT_CFG[] = {

	0x80, 0xC2, 0x00, 0x00, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A

};

/*	0x01, 0x4D, 0x00, 0x00, 0x01, 0xFF, 0xFF, 0xFF, 0xFF */

static const u8 PSX_CMD_ENABLE_MOTOR[]	= {

	0x80, 0xB2, 0x00, 0x00, 0x80, 0xFF, 0xFF, 0xFF, 0xFF

};



struct psxpad {

	struct spi_device *spi;

	struct input_polled_dev *pdev;

	char phys[0x20];

	bool motor1enable;

	bool motor2enable;

	u8 motor1level;

	u8 motor2level;

	u8 sendbuf[0x20] ____cacheline_aligned;

	u8 response[sizeof(PSX_CMD_POLL)] ____cacheline_aligned;

};



static int psxpad_command(struct psxpad *pad, const u8 sendcmdlen)

{

	struct spi_transfer xfers = {

		.tx_buf		= pad->sendbuf,

		.rx_buf		= pad->response,

		.len		= sendcmdlen,

	};

	int err;



	err = spi_sync_transfer(pad->spi, &xfers, 1);

	if (err) {

		dev_err(&pad->spi->dev,

			"%s: failed to SPI xfers mode: %d\n",

			__func__, err);

		return err;

	}



	return 0;

}



#ifdef CONFIG_JOYSTICK_PSXPAD_SPI_FF

static void psxpad_control_motor(struct psxpad *pad,

				 bool motor1enable, bool motor2enable)

{

	int err;



	pad->motor1enable = motor1enable;

	pad->motor2enable = motor2enable;



	memcpy(pad->sendbuf, PSX_CMD_ENTER_CFG, sizeof(PSX_CMD_ENTER_CFG));

	err = psxpad_command(pad, sizeof(PSX_CMD_ENTER_CFG));

	if (err) {

		dev_err(&pad->spi->dev,

			"%s: failed to enter config mode: %d\n",

			__func__, err);

		return;

	}



	memcpy(pad->sendbuf, PSX_CMD_ENABLE_MOTOR,

	       sizeof(PSX_CMD_ENABLE_MOTOR));

	pad->sendbuf[3] = pad->motor1enable ? 0x00 : 0xFF;

	pad->sendbuf[4] = pad->motor2enable ? 0x80 : 0xFF;

	err = psxpad_command(pad, sizeof(PSX_CMD_ENABLE_MOTOR));

	if (err) {

		dev_err(&pad->spi->dev,

			"%s: failed to enable motor mode: %d\n",

			__func__, err);

		return;

	}



	memcpy(pad->sendbuf, PSX_CMD_EXIT_CFG, sizeof(PSX_CMD_EXIT_CFG));

	err = psxpad_command(pad, sizeof(PSX_CMD_EXIT_CFG));

	if (err) {

		dev_err(&pad->spi->dev,

			"%s: failed to exit config mode: %d\n",

			__func__, err);

		return;

	}

}



static void psxpad_set_motor_level(struct psxpad *pad,

				   u8 motor1level, u8 motor2level)

{

	pad->motor1level = motor1level ? 0xFF : 0x00;

	pad->motor2level = REVERSE_BIT(motor2level);

}



static int psxpad_spi_play_effect(struct input_dev *idev,

				  void *data, struct ff_effect *effect)

{

	struct input_polled_dev *pdev = input_get_drvdata(idev);

	struct psxpad *pad = pdev->private;



	switch (effect->type) {

	case FF_RUMBLE:

		psxpad_set_motor_level(pad,

			(effect->u.rumble.weak_magnitude >> 8) & 0xFFU,

			(effect->u.rumble.strong_magnitude >> 8) & 0xFFU);

		break;

	}



	return 0;

}



static int psxpad_spi_init_ff(struct psxpad *pad)

{

	int err;



	input_set_capability(pad->pdev->input, EV_FF, FF_RUMBLE);



	err = input_ff_create_memless(pad->pdev->input, NULL,

				      psxpad_spi_play_effect);

	if (err) {

		dev_err(&pad->spi->dev,

			"input_ff_create_memless() failed: %d\n", err);

		return err;

	}



	return 0;

}



#else	/* CONFIG_JOYSTICK_PSXPAD_SPI_FF */



static void psxpad_control_motor(struct psxpad *pad,

				 bool motor1enable, bool motor2enable)

{

}



static void psxpad_set_motor_level(struct psxpad *pad,

				   u8 motor1level, u8 motor2level)

{

}



static inline int psxpad_spi_init_ff(struct psxpad *pad)

{

	return 0;

}

#endif	/* CONFIG_JOYSTICK_PSXPAD_SPI_FF */



static void psxpad_spi_poll_open(struct input_polled_dev *pdev)

{

	struct psxpad *pad = pdev->private;



	pm_runtime_get_sync(&pad->spi->dev);

}



static void psxpad_spi_poll_close(struct input_polled_dev *pdev)

{

	struct psxpad *pad = pdev->private;



	pm_runtime_put_sync(&pad->spi->dev);

}



static void psxpad_spi_poll(struct input_polled_dev *pdev)

{

	struct psxpad *pad = pdev->private;

	struct input_dev *input = pdev->input;

	u8 b_rsp3, b_rsp4;

	int err;



	psxpad_control_motor(pad, true, true);



	memcpy(pad->sendbuf, PSX_CMD_POLL, sizeof(PSX_CMD_POLL));

	pad->sendbuf[3] = pad->motor1enable ? pad->motor1level : 0x00;

	pad->sendbuf[4] = pad->motor2enable ? pad->motor2level : 0x00;

	err = psxpad_command(pad, sizeof(PSX_CMD_POLL));

	if (err) {

		dev_err(&pad->spi->dev,

			"%s: poll command failed mode: %d\n", __func__, err);

		return;

	}



	switch (pad->response[1]) {

	case 0xCE:	/* 0x73 : analog 1 */

		/* button data is inverted */

		b_rsp3 = ~pad->response[3];

		b_rsp4 = ~pad->response[4];



		input_report_abs(input, ABS_X, REVERSE_BIT(pad->response[7]));

		input_report_abs(input, ABS_Y, REVERSE_BIT(pad->response[8]));

		input_report_abs(input, ABS_RX, REVERSE_BIT(pad->response[5]));

		input_report_abs(input, ABS_RY, REVERSE_BIT(pad->response[6]));

		input_report_key(input, BTN_DPAD_UP, b_rsp3 & BIT(3));

		input_report_key(input, BTN_DPAD_DOWN, b_rsp3 & BIT(1));

		input_report_key(input, BTN_DPAD_LEFT, b_rsp3 & BIT(0));

		input_report_key(input, BTN_DPAD_RIGHT, b_rsp3 & BIT(2));

		input_report_key(input, BTN_X, b_rsp4 & BIT(3));

		input_report_key(input, BTN_A, b_rsp4 & BIT(2));

		input_report_key(input, BTN_B, b_rsp4 & BIT(1));

		input_report_key(input, BTN_Y, b_rsp4 & BIT(0));

		input_report_key(input, BTN_TL, b_rsp4 & BIT(5));

		input_report_key(input, BTN_TR, b_rsp4 & BIT(4));

		input_report_key(input, BTN_TL2, b_rsp4 & BIT(7));

		input_report_key(input, BTN_TR2, b_rsp4 & BIT(6));

		input_report_key(input, BTN_THUMBL, b_rsp3 & BIT(6));

		input_report_key(input, BTN_THUMBR, b_rsp3 & BIT(5));

		input_report_key(input, BTN_SELECT, b_rsp3 & BIT(7));

		input_report_key(input, BTN_START, b_rsp3 & BIT(4));

		break;



	case 0x82:	/* 0x41 : digital */

		/* button data is inverted */

		b_rsp3 = ~pad->response[3];

		b_rsp4 = ~pad->response[4];



		input_report_abs(input, ABS_X, 0x80);

		input_report_abs(input, ABS_Y, 0x80);

		input_report_abs(input, ABS_RX, 0x80);

		input_report_abs(input, ABS_RY, 0x80);

		input_report_key(input, BTN_DPAD_UP, b_rsp3 & BIT(3));

		input_report_key(input, BTN_DPAD_DOWN, b_rsp3 & BIT(1));

		input_report_key(input, BTN_DPAD_LEFT, b_rsp3 & BIT(0));

		input_report_key(input, BTN_DPAD_RIGHT, b_rsp3 & BIT(2));

		input_report_key(input, BTN_X, b_rsp4 & BIT(3));

		input_report_key(input, BTN_A, b_rsp4 & BIT(2));

		input_report_key(input, BTN_B, b_rsp4 & BIT(1));

		input_report_key(input, BTN_Y, b_rsp4 & BIT(0));

		input_report_key(input, BTN_TL, b_rsp4 & BIT(5));

		input_report_key(input, BTN_TR, b_rsp4 & BIT(4));

		input_report_key(input, BTN_TL2, b_rsp4 & BIT(7));

		input_report_key(input, BTN_TR2, b_rsp4 & BIT(6));

		input_report_key(input, BTN_THUMBL, false);

		input_report_key(input, BTN_THUMBR, false);

		input_report_key(input, BTN_SELECT, b_rsp3 & BIT(7));

		input_report_key(input, BTN_START, b_rsp3 & BIT(4));

		break;

	}



	input_sync(input);

}



static int psxpad_spi_probe(struct spi_device *spi)

{

	struct psxpad *pad;

	struct input_polled_dev *pdev;

	struct input_dev *idev;

	int err;



	pad = devm_kzalloc(&spi->dev, sizeof(struct psxpad), GFP_KERNEL);

	if (!pad)

		return -ENOMEM;



	pdev = input_allocate_polled_device();

	if (!pdev) {

		dev_err(&spi->dev, "failed to allocate input device\n");

		return -ENOMEM;

	}



	/* input poll device settings */

	pad->pdev = pdev;

	pad->spi = spi;



	pdev->private = pad;

	pdev->open = psxpad_spi_poll_open;

	pdev->close = psxpad_spi_poll_close;

	pdev->poll = psxpad_spi_poll;

	/* poll interval is about 60fps */

	pdev->poll_interval = 16;

	pdev->poll_interval_min = 8;

	pdev->poll_interval_max = 32;



	/* input device settings */

	idev = pdev->input;

	idev->name = "PlayStation 1/2 joypad";

	snprintf(pad->phys, sizeof(pad->phys), "%s/input", dev_name(&spi->dev));

	idev->id.bustype = BUS_SPI;



	/* key/value map settings */

	input_set_abs_params(idev, ABS_X, 0, 255, 0, 0);

	input_set_abs_params(idev, ABS_Y, 0, 255, 0, 0);

	input_set_abs_params(idev, ABS_RX, 0, 255, 0, 0);

	input_set_abs_params(idev, ABS_RY, 0, 255, 0, 0);

	input_set_capability(idev, EV_KEY, BTN_DPAD_UP);

	input_set_capability(idev, EV_KEY, BTN_DPAD_DOWN);

	input_set_capability(idev, EV_KEY, BTN_DPAD_LEFT);

	input_set_capability(idev, EV_KEY, BTN_DPAD_RIGHT);

	input_set_capability(idev, EV_KEY, BTN_A);

	input_set_capability(idev, EV_KEY, BTN_B);

	input_set_capability(idev, EV_KEY, BTN_X);

	input_set_capability(idev, EV_KEY, BTN_Y);

	input_set_capability(idev, EV_KEY, BTN_TL);

	input_set_capability(idev, EV_KEY, BTN_TR);

	input_set_capability(idev, EV_KEY, BTN_TL2);

	input_set_capability(idev, EV_KEY, BTN_TR2);

	input_set_capability(idev, EV_KEY, BTN_THUMBL);

	input_set_capability(idev, EV_KEY, BTN_THUMBR);

	input_set_capability(idev, EV_KEY, BTN_SELECT);

	input_set_capability(idev, EV_KEY, BTN_START);



	err = psxpad_spi_init_ff(pad);

	if (err)

		return err;



	/* SPI settings */

	spi->mode = SPI_MODE_3;

	spi->bits_per_word = 8;

	/* (PlayStation 1/2 joypad might be possible works 250kHz/500kHz) */

	spi->master->min_speed_hz = 125000;

	spi->master->max_speed_hz = 125000;

	spi_setup(spi);



	/* pad settings */

	psxpad_set_motor_level(pad, 0, 0);



	/* register input poll device */

	err = input_register_polled_device(pdev);

	if (err) {

		dev_err(&spi->dev,

			"failed to register input poll device: %d\n", err);

		return err;

	}



	pm_runtime_enable(&spi->dev);



	return 0;

}



static int __maybe_unused psxpad_spi_suspend(struct device *dev)

{

	struct spi_device *spi = to_spi_device(dev);

	struct psxpad *pad = spi_get_drvdata(spi);



	psxpad_set_motor_level(pad, 0, 0);



	return 0;

}



static SIMPLE_DEV_PM_OPS(psxpad_spi_pm, psxpad_spi_suspend, NULL);



static const struct spi_device_id psxpad_spi_id[] = {

	{ "psxpad-spi", 0 },

	{ }

};

MODULE_DEVICE_TABLE(spi, psxpad_spi_id);



static struct spi_driver psxpad_spi_driver = {

	.driver = {

		.name = "psxpad-spi",

		.pm = &psxpad_spi_pm,

	},

	.id_table = psxpad_spi_id,

	.probe   = psxpad_spi_probe,

};



module_spi_driver(psxpad_spi_driver);



MODULE_AUTHOR("Tomohiro Yoshidomi <sylph23k@gmail.com>");

MODULE_DESCRIPTION("PlayStation 1/2 joypads via SPI interface Driver");

MODULE_LICENSE("GPL");

drivers/input/joystick/xpad.c

+21 −6
Original line number Diff line number Diff line
@@ -126,25 +126,26 @@ static const struct xpad_device { 
	u8 mapping;

	u8 xtype;

} xpad_device[] = {

	{ 0x044f, 0x0f07, "Thrustmaster, Inc. Controller", 0, XTYPE_XBOX },

	{ 0x044f, 0xb326, "Thrustmaster Gamepad GP XID", 0, XTYPE_XBOX360 },

	{ 0x045e, 0x0202, "Microsoft X-Box pad v1 (US)", 0, XTYPE_XBOX },

	{ 0x045e, 0x0285, "Microsoft X-Box pad (Japan)", 0, XTYPE_XBOX },

	{ 0x045e, 0x0287, "Microsoft Xbox Controller S", 0, XTYPE_XBOX },

	{ 0x045e, 0x0289, "Microsoft X-Box pad v2 (US)", 0, XTYPE_XBOX },

	{ 0x045e, 0x028e, "Microsoft X-Box 360 pad", 0, XTYPE_XBOX360 },

	{ 0x045e, 0x0291, "Xbox 360 Wireless Receiver (XBOX)", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360W },

	{ 0x045e, 0x02d1, "Microsoft X-Box One pad", 0, XTYPE_XBOXONE },

	{ 0x045e, 0x02dd, "Microsoft X-Box One pad (Firmware 2015)", 0, XTYPE_XBOXONE },

	{ 0x045e, 0x02e3, "Microsoft X-Box One Elite pad", 0, XTYPE_XBOXONE },

	{ 0x045e, 0x02ea, "Microsoft X-Box One S pad", 0, XTYPE_XBOXONE },

	{ 0x045e, 0x0291, "Xbox 360 Wireless Receiver (XBOX)", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360W },

	{ 0x045e, 0x0719, "Xbox 360 Wireless Receiver", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360W },

	{ 0x044f, 0x0f07, "Thrustmaster, Inc. Controller", 0, XTYPE_XBOX },

	{ 0x044f, 0xb326, "Thrustmaster Gamepad GP XID", 0, XTYPE_XBOX360 },

	{ 0x046d, 0xc21d, "Logitech Gamepad F310", 0, XTYPE_XBOX360 },

	{ 0x046d, 0xc21e, "Logitech Gamepad F510", 0, XTYPE_XBOX360 },

	{ 0x046d, 0xc21f, "Logitech Gamepad F710", 0, XTYPE_XBOX360 },

	{ 0x046d, 0xc242, "Logitech Chillstream Controller", 0, XTYPE_XBOX360 },

	{ 0x046d, 0xca84, "Logitech Xbox Cordless Controller", 0, XTYPE_XBOX },

	{ 0x046d, 0xca88, "Logitech Compact Controller for Xbox", 0, XTYPE_XBOX },

	{ 0x056e, 0x2004, "Elecom JC-U3613M", 0, XTYPE_XBOX360 },

	{ 0x05fd, 0x1007, "Mad Catz Controller (unverified)", 0, XTYPE_XBOX },

	{ 0x05fd, 0x107a, "InterAct 'PowerPad Pro' X-Box pad (Germany)", 0, XTYPE_XBOX },

	{ 0x0738, 0x4516, "Mad Catz Control Pad", 0, XTYPE_XBOX },
@@ -179,13 +180,15 @@ static const struct xpad_device { 
	{ 0x0e6f, 0x0006, "Edge wireless Controller", 0, XTYPE_XBOX },

	{ 0x0e6f, 0x0105, "HSM3 Xbox360 dancepad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360 },

	{ 0x0e6f, 0x0113, "Afterglow AX.1 Gamepad for Xbox 360", 0, XTYPE_XBOX360 },

	{ 0x0e6f, 0x011f, "Rock Candy Gamepad Wired Controller", 0, XTYPE_XBOX360 },

	{ 0x0e6f, 0x0139, "Afterglow Prismatic Wired Controller", 0, XTYPE_XBOXONE },

	{ 0x0e6f, 0x0146, "Rock Candy Wired Controller for Xbox One", 0, XTYPE_XBOXONE },

	{ 0x0e6f, 0x0201, "Pelican PL-3601 'TSZ' Wired Xbox 360 Controller", 0, XTYPE_XBOX360 },

	{ 0x0e6f, 0x0213, "Afterglow Gamepad for Xbox 360", 0, XTYPE_XBOX360 },

	{ 0x0e6f, 0x021f, "Rock Candy Gamepad for Xbox 360", 0, XTYPE_XBOX360 },

	{ 0x0e6f, 0x0146, "Rock Candy Wired Controller for Xbox One", 0, XTYPE_XBOXONE },

	{ 0x0e6f, 0x0301, "Logic3 Controller", 0, XTYPE_XBOX360 },

	{ 0x0e6f, 0x0401, "Logic3 Controller", 0, XTYPE_XBOX360 },

	{ 0x0e6f, 0x0413, "Afterglow AX.1 Gamepad for Xbox 360", 0, XTYPE_XBOX360 },

	{ 0x0e8f, 0x0201, "SmartJoy Frag Xpad/PS2 adaptor", 0, XTYPE_XBOX },

	{ 0x0e8f, 0x3008, "Generic xbox control (dealextreme)", 0, XTYPE_XBOX },

	{ 0x0f0d, 0x000a, "Hori Co. DOA4 FightStick", 0, XTYPE_XBOX360 },
@@ -209,27 +212,38 @@ static const struct xpad_device { 
	{ 0x162e, 0xbeef, "Joytech Neo-Se Take2", 0, XTYPE_XBOX360 },

	{ 0x1689, 0xfd00, "Razer Onza Tournament Edition", 0, XTYPE_XBOX360 },

	{ 0x1689, 0xfd01, "Razer Onza Classic Edition", 0, XTYPE_XBOX360 },

	{ 0x24c6, 0x542a, "Xbox ONE spectra", 0, XTYPE_XBOXONE },

	{ 0x24c6, 0x5d04, "Razer Sabertooth", 0, XTYPE_XBOX360 },

	{ 0x1689, 0xfe00, "Razer Sabertooth", 0, XTYPE_XBOX360 },

	{ 0x1bad, 0x0002, "Harmonix Rock Band Guitar", 0, XTYPE_XBOX360 },

	{ 0x1bad, 0x0003, "Harmonix Rock Band Drumkit", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360 },

	{ 0x1bad, 0xf016, "Mad Catz Xbox 360 Controller", 0, XTYPE_XBOX360 },

	{ 0x1bad, 0xf018, "Mad Catz Street Fighter IV SE Fighting Stick", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },

	{ 0x1bad, 0xf019, "Mad Catz Brawlstick for Xbox 360", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },

	{ 0x1bad, 0xf021, "Mad Cats Ghost Recon FS GamePad", 0, XTYPE_XBOX360 },

	{ 0x1bad, 0xf023, "MLG Pro Circuit Controller (Xbox)", 0, XTYPE_XBOX360 },

	{ 0x1bad, 0xf028, "Street Fighter IV FightPad", 0, XTYPE_XBOX360 },

	{ 0x1bad, 0xf02e, "Mad Catz Fightpad", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },

	{ 0x1bad, 0xf038, "Street Fighter IV FightStick TE", 0, XTYPE_XBOX360 },

	{ 0x1bad, 0xf03a, "Mad Catz SFxT Fightstick Pro", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },

	{ 0x1bad, 0xf900, "Harmonix Xbox 360 Controller", 0, XTYPE_XBOX360 },

	{ 0x1bad, 0xf901, "Gamestop Xbox 360 Controller", 0, XTYPE_XBOX360 },

	{ 0x1bad, 0xf903, "Tron Xbox 360 controller", 0, XTYPE_XBOX360 },

	{ 0x1bad, 0xfa01, "MadCatz GamePad", 0, XTYPE_XBOX360 },

	{ 0x24c6, 0x5000, "Razer Atrox Arcade Stick", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },

	{ 0x24c6, 0x5300, "PowerA MINI PROEX Controller", 0, XTYPE_XBOX360 },

	{ 0x24c6, 0x5303, "Xbox Airflo wired controller", 0, XTYPE_XBOX360 },

	{ 0x24c6, 0x531a, "PowerA Pro Ex", 0, XTYPE_XBOX360 },

	{ 0x24c6, 0x5397, "FUS1ON Tournament Controller", 0, XTYPE_XBOX360 },

	{ 0x24c6, 0x541a, "PowerA Xbox One Mini Wired Controller", 0, XTYPE_XBOXONE },

	{ 0x24c6, 0x542a, "Xbox ONE spectra", 0, XTYPE_XBOXONE },

	{ 0x24c6, 0x543a, "PowerA Xbox One wired controller", 0, XTYPE_XBOXONE },

	{ 0x24c6, 0x5500, "Hori XBOX 360 EX 2 with Turbo", 0, XTYPE_XBOX360 },

	{ 0x24c6, 0x5501, "Hori Real Arcade Pro VX-SA", 0, XTYPE_XBOX360 },

	{ 0x24c6, 0x5503, "Hori Fighting Edge", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },

	{ 0x24c6, 0x5506, "Hori SOULCALIBUR V Stick", 0, XTYPE_XBOX360 },

	{ 0x24c6, 0x550d, "Hori GEM Xbox controller", 0, XTYPE_XBOX360 },

	{ 0x24c6, 0x5b02, "Thrustmaster, Inc. GPX Controller", 0, XTYPE_XBOX360 },

	{ 0x24c6, 0x5b03, "Thrustmaster Ferrari 458 Racing Wheel", 0, XTYPE_XBOX360 },

	{ 0x24c6, 0x5d04, "Razer Sabertooth", 0, XTYPE_XBOX360 },

	{ 0xffff, 0xffff, "Chinese-made Xbox Controller", 0, XTYPE_XBOX },

	{ 0x0000, 0x0000, "Generic X-Box pad", 0, XTYPE_UNKNOWN }

};
@@ -316,6 +330,7 @@ static struct usb_device_id xpad_table[] = { 
	XPAD_XBOX360_VENDOR(0x045e),		/* Microsoft X-Box 360 controllers */

	XPAD_XBOXONE_VENDOR(0x045e),		/* Microsoft X-Box One controllers */

	XPAD_XBOX360_VENDOR(0x046d),		/* Logitech X-Box 360 style controllers */

	XPAD_XBOX360_VENDOR(0x056e),		/* Elecom JC-U3613M */

	XPAD_XBOX360_VENDOR(0x0738),		/* Mad Catz X-Box 360 controllers */

	{ USB_DEVICE(0x0738, 0x4540) },		/* Mad Catz Beat Pad */

	XPAD_XBOXONE_VENDOR(0x0738),		/* Mad Catz FightStick TE 2 */

drivers/input/keyboard/cros_ec_keyb.c

+1 −1
Original line number Diff line number Diff line
@@ -660,7 +660,7 @@ static const struct of_device_id cros_ec_keyb_of_match[] = { 
MODULE_DEVICE_TABLE(of, cros_ec_keyb_of_match);

#endif



static const SIMPLE_DEV_PM_OPS(cros_ec_keyb_pm_ops, NULL, cros_ec_keyb_resume);

static SIMPLE_DEV_PM_OPS(cros_ec_keyb_pm_ops, NULL, cros_ec_keyb_resume);



static struct platform_driver cros_ec_keyb_driver = {

	.probe = cros_ec_keyb_probe,