Skip to content

Commit

Permalink
HID: sony: Add LED support for Sixaxis/Dualshock3 USB
Browse files Browse the repository at this point in the history 
The PS3 Sixaxis controller has 4 LEDs which can be controlled using the same
command as the rumble functionality. It seems not to be possible to only change
the LED without modifying the rumble motor state. Thus both have to be stored
on the host and retransmitted when either the LED or rumble state is changed.

Third party controllers may not support to disable all LEDs at once. These
controllers automatically switch to blinking of all LEDs when no LED is active
anymore.

Signed-off-by: Sven Eckelmann <sven@narfation.org>
Tested-by: Simon Wood <simon@mungewell.org>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
  • Loading branch information
Sven Eckelmann authored and Jiri Kosina committed Nov 20, 2013
1 parent 2251b85 commit 0a286ef
Showing 1 changed file with 72 additions and 48 deletions.
120 changes: 72 additions & 48 deletions drivers/hid/hid-sony.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -39,6 +39,8 @@
#define BUZZ_CONTROLLER BIT(3)
#define PS3REMOTE BIT(4)

#define SONY_LED_SUPPORT (SIXAXIS_CONTROLLER_USB | BUZZ_CONTROLLER)

static const u8 sixaxis_rdesc_fixup[] = {
0x95, 0x13, 0x09, 0x01, 0x81, 0x02, 0x95, 0x0C,
0x81, 0x01, 0x75, 0x10, 0x95, 0x04, 0x26, 0xFF,
Expand Down Expand Up @@ -223,12 +225,12 @@ static const unsigned int buzz_keymap[] = {
};

struct sony_sc {
struct hid_device *hdev;
struct led_classdev *leds[4];
unsigned long quirks;
struct work_struct state_worker;

#ifdef CONFIG_SONY_FF
struct work_struct state_worker;
struct hid_device *hdev;
__u8 left;
__u8 right;
#endif
Expand Down Expand Up @@ -462,6 +464,18 @@ static void buzz_set_leds(struct hid_device *hdev, int leds)
hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
}

static void sony_set_leds(struct hid_device *hdev, __u8 leds)
{
struct sony_sc *drv_data = hid_get_drvdata(hdev);

if (drv_data->quirks & BUZZ_CONTROLLER) {
buzz_set_leds(hdev, leds);
} else if (drv_data->quirks & SIXAXIS_CONTROLLER_USB) {
drv_data->led_state = leds;
schedule_work(&drv_data->state_worker);
}
}

static void sony_led_set_brightness(struct led_classdev *led,
enum led_brightness value)
{
Expand All @@ -482,10 +496,10 @@ static void sony_led_set_brightness(struct led_classdev *led,
int on = !!(drv_data->led_state & (1 << n));
if (value == LED_OFF && on) {
drv_data->led_state &= ~(1 << n);
buzz_set_leds(hdev, drv_data->led_state);
sony_set_leds(hdev, drv_data->led_state);
} else if (value != LED_OFF && !on) {
drv_data->led_state |= (1 << n);
buzz_set_leds(hdev, drv_data->led_state);
sony_set_leds(hdev, drv_data->led_state);
}
break;
}
Expand Down Expand Up @@ -517,27 +531,55 @@ static enum led_brightness sony_led_get_brightness(struct led_classdev *led)
return on ? LED_FULL : LED_OFF;
}

static void sony_leds_remove(struct hid_device *hdev)
{
struct sony_sc *drv_data;
struct led_classdev *led;
int n;

drv_data = hid_get_drvdata(hdev);
BUG_ON(!(drv_data->quirks & SONY_LED_SUPPORT));

for (n = 0; n < 4; n++) {
led = drv_data->leds[n];
drv_data->leds[n] = NULL;
if (!led)
continue;
led_classdev_unregister(led);
kfree(led);
}
}

static int sony_leds_init(struct hid_device *hdev)
{
struct sony_sc *drv_data;
int n, ret = 0;
struct led_classdev *led;
size_t name_sz;
char *name;
size_t name_len;
const char *name_fmt;

drv_data = hid_get_drvdata(hdev);
BUG_ON(!(drv_data->quirks & BUZZ_CONTROLLER));

/* Validate expected report characteristics. */
if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
return -ENODEV;
BUG_ON(!(drv_data->quirks & SONY_LED_SUPPORT));

if (drv_data->quirks & BUZZ_CONTROLLER) {
name_len = strlen("::buzz#");
name_fmt = "%s::buzz%d";
/* Validate expected report characteristics. */
if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 0, 0, 7))
return -ENODEV;
} else {
name_len = strlen("::sony#");
name_fmt = "%s::sony%d";
}

/* Clear LEDs as we have no way of reading their initial state. This is
* only relevant if the driver is loaded after somebody actively set the
* LEDs to on */
buzz_set_leds(hdev, 0x00);
sony_set_leds(hdev, 0x00);

name_sz = strlen(dev_name(&hdev->dev)) + strlen("::buzz#") + 1;
name_sz = strlen(dev_name(&hdev->dev)) + name_len + 1;

for (n = 0; n < 4; n++) {
led = kzalloc(sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
Expand All @@ -547,7 +589,7 @@ static int sony_leds_init(struct hid_device *hdev)
}

name = (void *)(&led[1]);
snprintf(name, name_sz, "%s::buzz%d", dev_name(&hdev->dev), n + 1);
snprintf(name, name_sz, name_fmt, dev_name(&hdev->dev), n + 1);
led->name = name;
led->brightness = 0;
led->max_brightness = 1;
Expand All @@ -566,59 +608,37 @@ static int sony_leds_init(struct hid_device *hdev)
return ret;

error_leds:
for (n = 0; n < 4; n++) {
led = drv_data->leds[n];
drv_data->leds[n] = NULL;
if (!led)
continue;
led_classdev_unregister(led);
kfree(led);
}
sony_leds_remove(hdev);

return ret;
}

static void sony_leds_remove(struct hid_device *hdev)
{
struct sony_sc *drv_data;
struct led_classdev *led;
int n;

drv_data = hid_get_drvdata(hdev);
BUG_ON(!(drv_data->quirks & BUZZ_CONTROLLER));

for (n = 0; n < 4; n++) {
led = drv_data->leds[n];
drv_data->leds[n] = NULL;
if (!led)
continue;
led_classdev_unregister(led);
kfree(led);
}
}

#ifdef CONFIG_SONY_FF
static void sony_state_worker(struct work_struct *work)
{
struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
unsigned char buf[] = {
0x01,
0x00, 0xff, 0x00, 0xff, 0x00,
0x00, 0x00, 0x00, 0x00, 0x03,
0x00, 0x00, 0x00, 0x00, 0x00,
0xff, 0x27, 0x10, 0x00, 0x32,
0xff, 0x27, 0x10, 0x00, 0x32,
0xff, 0x27, 0x10, 0x00, 0x32,
0xff, 0x27, 0x10, 0x00, 0x32,
0x00, 0x00, 0x00, 0x00, 0x00
};

#ifdef CONFIG_SONY_FF
buf[3] = sc->right;
buf[5] = sc->left;
#endif

buf[10] |= (sc->led_state & 0xf) << 1;

sc->hdev->hid_output_raw_report(sc->hdev, buf, sizeof(buf),
HID_OUTPUT_REPORT);
}

#ifdef CONFIG_SONY_FF
static int sony_play_effect(struct input_dev *dev, void *data,
struct ff_effect *effect)
{
Expand All @@ -640,10 +660,6 @@ static int sony_init_ff(struct hid_device *hdev)
struct hid_input *hidinput = list_entry(hdev->inputs.next,
struct hid_input, list);
struct input_dev *input_dev = hidinput->input;
struct sony_sc *sc = hid_get_drvdata(hdev);

sc->hdev = hdev;
INIT_WORK(&sc->state_worker, sony_state_worker);

input_set_capability(input_dev, EV_FF, FF_RUMBLE);
return input_ff_create_memless(input_dev, NULL, sony_play_effect);
Expand Down Expand Up @@ -682,6 +698,7 @@ static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)

sc->quirks = quirks;
hid_set_drvdata(hdev, sc);
sc->hdev = hdev;

ret = hid_parse(hdev);
if (ret) {
Expand All @@ -705,23 +722,30 @@ static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
hdev->hid_output_raw_report = sixaxis_usb_output_raw_report;
ret = sixaxis_set_operational_usb(hdev);
INIT_WORK(&sc->state_worker, sony_state_worker);
}
else if (sc->quirks & SIXAXIS_CONTROLLER_BT)
ret = sixaxis_set_operational_bt(hdev);
else if (sc->quirks & BUZZ_CONTROLLER)
ret = sony_leds_init(hdev);
else
ret = 0;

if (ret < 0)
goto err_stop;

if (sc->quirks & SONY_LED_SUPPORT) {
ret = sony_leds_init(hdev);
if (ret < 0)
goto err_stop;
}

ret = sony_init_ff(hdev);
if (ret < 0)
goto err_stop;

return 0;
err_stop:
if (sc->quirks & SONY_LED_SUPPORT)
sony_leds_remove(hdev);
hid_hw_stop(hdev);
return ret;
}
Expand All @@ -730,7 +754,7 @@ static void sony_remove(struct hid_device *hdev)
{
struct sony_sc *sc = hid_get_drvdata(hdev);

if (sc->quirks & BUZZ_CONTROLLER)
if (sc->quirks & SONY_LED_SUPPORT)
sony_leds_remove(hdev);

sony_destroy_ff(hdev);
Expand Down

0 comments on commit 0a286ef

Please sign in to comment.