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

Commit 9a4a5574 authored by Benjamin Tissoires's avatar Benjamin Tissoires Committed by Jiri Kosina
Browse files

HID: appleir: add support for Apple ir devices 



This driver was originally written by James McKenzie, updated by
Greg Kroah-Hartman, further updated by Bastien Nocera, with suspend
support added.
I ported it to the HID subsystem, in order to simplify it a litle
and allow lirc to use it through hiddev.

More recent versions of the IR receiver are also supported through
a patch by Alex Karpenko. The patch also adds support for the 2nd
and 5th generation of the controller, and the menu key on newer
brushed metal remotes.

Tested-by: default avatarFabien André <fabien.andre@gmail.com>
Signed-off-by: default avatarBenjamin Tissoires <benjamin.tissoires@redhat.com>
Signed-off-by: default avatarJiri Kosina <jkosina@suse.cz>
parent 014642cb

drivers/hid/Kconfig

+11 −0
Original line number Diff line number Diff line
@@ -122,6 +122,17 @@ config HID_APPLE 
	Say Y here if you want support for keyboards of	Apple iBooks, PowerBooks,

	MacBooks, MacBook Pros and Apple Aluminum.



config HID_APPLEIR

	tristate "Apple infrared receiver"

	depends on (USB_HID)

	---help---

	Support for Apple infrared remote control. All the Apple computers from

	  2005 onwards include such a port, except the unibody Macbook (2009),

	  and Mac Pros. This receiver is also used in the Apple TV set-top box

	  prior to the 2010 model.



	Say Y here if you want support for Apple infrared remote control.



config HID_AUREAL

	tristate "Aureal"

	depends on USB_HID

drivers/hid/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -39,6 +39,7 @@ endif 
obj-$(CONFIG_HID_A4TECH)	+= hid-a4tech.o

obj-$(CONFIG_HID_ACRUX)		+= hid-axff.o

obj-$(CONFIG_HID_APPLE)		+= hid-apple.o

obj-$(CONFIG_HID_APPLEIR)	+= hid-appleir.o

obj-$(CONFIG_HID_AUREAL)        += hid-aureal.o

obj-$(CONFIG_HID_BELKIN)	+= hid-belkin.o

obj-$(CONFIG_HID_CHERRY)	+= hid-cherry.o

drivers/hid/hid-apple.c

+0 −4
Original line number Diff line number Diff line
@@ -390,10 +390,6 @@ static void apple_remove(struct hid_device *hdev) 
}



static const struct hid_device_id apple_devices[] = {

	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ATV_IRCONTROL),

		.driver_data = APPLE_HIDDEV | APPLE_IGNORE_HIDINPUT },

	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL4),

		.driver_data = APPLE_HIDDEV | APPLE_IGNORE_HIDINPUT },

	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MIGHTYMOUSE),

		.driver_data = APPLE_MIGHTYMOUSE | APPLE_INVERT_HWHEEL },

drivers/hid/hid-appleir.c

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

 * HID driver for the apple ir device

 *

 * Original driver written by James McKenzie

 * Ported to recent 2.6 kernel versions by Greg Kroah-Hartman <gregkh@suse.de>

 * Updated to support newer remotes by Bastien Nocera <hadess@hadess.net>

 * Ported to HID subsystem by Benjamin Tissoires <benjamin.tissoires@gmail.com>

 *

 * Copyright (C) 2006 James McKenzie

 * Copyright (C) 2008 Greg Kroah-Hartman <greg@kroah.com>

 * Copyright (C) 2008 Novell Inc.

 * Copyright (C) 2010, 2012 Bastien Nocera <hadess@hadess.net>

 * Copyright (C) 2013 Benjamin Tissoires <benjamin.tissoires@gmail.com>

 * Copyright (C) 2013 Red Hat Inc. All Rights Reserved

 *

 * This software is licensed under the terms of the GNU General Public

 * License version 2, as published by the Free Software Foundation, and

 * may be copied, distributed, and modified under those terms.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 */



#include <linux/device.h>

#include <linux/hid.h>

#include <linux/module.h>

#include "hid-ids.h"



MODULE_AUTHOR("James McKenzie");

MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@redhat.com>");

MODULE_DESCRIPTION("HID Apple IR remote controls");

MODULE_LICENSE("GPL");



#define KEY_MASK		0x0F

#define TWO_PACKETS_MASK	0x40



/*

 * James McKenzie has two devices both of which report the following

 * 25 87 ee 83 0a	+

 * 25 87 ee 83 0c	-

 * 25 87 ee 83 09	<<

 * 25 87 ee 83 06	>>

 * 25 87 ee 83 05	>"

 * 25 87 ee 83 03	menu

 * 26 00 00 00 00	for key repeat

 */



/*

 * Thomas Glanzmann reports the following responses

 * 25 87 ee ca 0b	+

 * 25 87 ee ca 0d	-

 * 25 87 ee ca 08	<<

 * 25 87 ee ca 07	>>

 * 25 87 ee ca 04	>"

 * 25 87 ee ca 02	menu

 * 26 00 00 00 00       for key repeat

 *

 * He also observes the following event sometimes

 * sent after a key is release, which I interpret

 * as a flat battery message

 * 25 87 e0 ca 06	flat battery

 */



/*

 * Alexandre Karpenko reports the following responses for Device ID 0x8242

 * 25 87 ee 47 0b	+

 * 25 87 ee 47 0d	-

 * 25 87 ee 47 08	<<

 * 25 87 ee 47 07	>>

 * 25 87 ee 47 04	>"

 * 25 87 ee 47 02	menu

 * 26 87 ee 47 **	for key repeat (** is the code of the key being held)

 */



/*

 * Bastien Nocera's remote

 * 25 87 ee 91 5f	followed by

 * 25 87 ee 91 05	gives you >"

 *

 * 25 87 ee 91 5c	followed by

 * 25 87 ee 91 05	gives you the middle button

 */



/*

 * Fabien Andre's remote

 * 25 87 ee a3 5e	followed by

 * 25 87 ee a3 04	gives you >"

 *

 * 25 87 ee a3 5d	followed by

 * 25 87 ee a3 04	gives you the middle button

 */



static const unsigned short appleir_key_table[] = {

	KEY_RESERVED,

	KEY_MENU,

	KEY_PLAYPAUSE,

	KEY_FORWARD,

	KEY_BACK,

	KEY_VOLUMEUP,

	KEY_VOLUMEDOWN,

	KEY_RESERVED,

	KEY_RESERVED,

	KEY_RESERVED,

	KEY_RESERVED,

	KEY_RESERVED,

	KEY_RESERVED,

	KEY_RESERVED,

	KEY_ENTER,

	KEY_PLAYPAUSE,

	KEY_RESERVED,

};



struct appleir {

	struct input_dev *input_dev;

	struct hid_device *hid;

	unsigned short keymap[ARRAY_SIZE(appleir_key_table)];

	struct timer_list key_up_timer;	/* timer for key up */

	spinlock_t lock;		/* protects .current_key */

	int current_key;		/* the currently pressed key */

	int prev_key_idx;		/* key index in a 2 packets message */

};



static int get_key(int data)

{

	/*

	 * The key is coded accross bits 2..9:

	 *

	 * 0x00 or 0x01 (        )	key:  0		-> KEY_RESERVED

	 * 0x02 or 0x03 (  menu  )	key:  1		-> KEY_MENU

	 * 0x04 or 0x05 (   >"   )	key:  2		-> KEY_PLAYPAUSE

	 * 0x06 or 0x07 (   >>   )	key:  3		-> KEY_FORWARD

	 * 0x08 or 0x09 (   <<   )	key:  4		-> KEY_BACK

	 * 0x0a or 0x0b (    +   )	key:  5		-> KEY_VOLUMEUP

	 * 0x0c or 0x0d (    -   )	key:  6		-> KEY_VOLUMEDOWN

	 * 0x0e or 0x0f (        )	key:  7		-> KEY_RESERVED

	 * 0x50 or 0x51 (        )	key:  8		-> KEY_RESERVED

	 * 0x52 or 0x53 (        )	key:  9		-> KEY_RESERVED

	 * 0x54 or 0x55 (        )	key: 10		-> KEY_RESERVED

	 * 0x56 or 0x57 (        )	key: 11		-> KEY_RESERVED

	 * 0x58 or 0x59 (        )	key: 12		-> KEY_RESERVED

	 * 0x5a or 0x5b (        )	key: 13		-> KEY_RESERVED

	 * 0x5c or 0x5d ( middle )	key: 14		-> KEY_ENTER

	 * 0x5e or 0x5f (   >"   )	key: 15		-> KEY_PLAYPAUSE

	 *

	 * Packets starting with 0x5 are part of a two-packets message,

	 * we notify the caller by sending a negative value.

	 */

	int key = (data >> 1) & KEY_MASK;



	if ((data & TWO_PACKETS_MASK))

		/* Part of a 2 packets-command */

		key = -key;



	return key;

}



static void key_up(struct hid_device *hid, struct appleir *appleir, int key)

{

	input_report_key(appleir->input_dev, key, 0);

	input_sync(appleir->input_dev);

}



static void key_down(struct hid_device *hid, struct appleir *appleir, int key)

{

	input_report_key(appleir->input_dev, key, 1);

	input_sync(appleir->input_dev);

}



static void battery_flat(struct appleir *appleir)

{

	dev_err(&appleir->input_dev->dev, "possible flat battery?\n");

}



static void key_up_tick(unsigned long data)

{

	struct appleir *appleir = (struct appleir *)data;

	struct hid_device *hid = appleir->hid;

	unsigned long flags;



	spin_lock_irqsave(&appleir->lock, flags);

	if (appleir->current_key) {

		key_up(hid, appleir, appleir->current_key);

		appleir->current_key = 0;

	}

	spin_unlock_irqrestore(&appleir->lock, flags);

}



static int appleir_raw_event(struct hid_device *hid, struct hid_report *report,

	 u8 *data, int len)

{

	struct appleir *appleir = hid_get_drvdata(hid);

	static const u8 keydown[] = { 0x25, 0x87, 0xee };

	static const u8 keyrepeat[] = { 0x26, };

	static const u8 flatbattery[] = { 0x25, 0x87, 0xe0 };

	unsigned long flags;



	if (len != 5)

		goto out;



	if (!memcmp(data, keydown, sizeof(keydown))) {

		int index;



		spin_lock_irqsave(&appleir->lock, flags);

		/*

		 * If we already have a key down, take it up before marking

		 * this one down

		 */

		if (appleir->current_key)

			key_up(hid, appleir, appleir->current_key);



		/* Handle dual packet commands */

		if (appleir->prev_key_idx > 0)

			index = appleir->prev_key_idx;

		else

			index = get_key(data[4]);



		if (index >= 0) {

			appleir->current_key = appleir->keymap[index];



			key_down(hid, appleir, appleir->current_key);

			/*

			 * Remote doesn't do key up, either pull them up, in

			 * the test above, or here set a timer which pulls

			 * them up after 1/8 s

			 */

			mod_timer(&appleir->key_up_timer, jiffies + HZ / 8);

			appleir->prev_key_idx = 0;

		} else

			/* Remember key for next packet */

			appleir->prev_key_idx = -index;

		spin_unlock_irqrestore(&appleir->lock, flags);

		goto out;

	}



	appleir->prev_key_idx = 0;



	if (!memcmp(data, keyrepeat, sizeof(keyrepeat))) {

		key_down(hid, appleir, appleir->current_key);

		/*

		 * Remote doesn't do key up, either pull them up, in the test

		 * above, or here set a timer which pulls them up after 1/8 s

		 */

		mod_timer(&appleir->key_up_timer, jiffies + HZ / 8);

		goto out;

	}



	if (!memcmp(data, flatbattery, sizeof(flatbattery))) {

		battery_flat(appleir);

		/* Fall through */

	}



out:

	/* let hidraw and hiddev handle the report */

	return 0;

}



static void appleir_input_configured(struct hid_device *hid,

		struct hid_input *hidinput)

{

	struct input_dev *input_dev = hidinput->input;

	struct appleir *appleir = hid_get_drvdata(hid);

	int i;



	appleir->input_dev = input_dev;



	input_dev->keycode = appleir->keymap;

	input_dev->keycodesize = sizeof(unsigned short);

	input_dev->keycodemax = ARRAY_SIZE(appleir->keymap);



	input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_REP);



	memcpy(appleir->keymap, appleir_key_table, sizeof(appleir->keymap));

	for (i = 0; i < ARRAY_SIZE(appleir_key_table); i++)

		set_bit(appleir->keymap[i], input_dev->keybit);

	clear_bit(KEY_RESERVED, input_dev->keybit);

}



static int appleir_input_mapping(struct hid_device *hid,

		struct hid_input *hi, struct hid_field *field,

		struct hid_usage *usage, unsigned long **bit, int *max)

{

	return -1;

}



static int appleir_probe(struct hid_device *hid, const struct hid_device_id *id)

{

	int ret;

	struct appleir *appleir;



	appleir = kzalloc(sizeof(struct appleir), GFP_KERNEL);

	if (!appleir) {

		ret = -ENOMEM;

		goto allocfail;

	}



	appleir->hid = hid;



	spin_lock_init(&appleir->lock);

	setup_timer(&appleir->key_up_timer,

		    key_up_tick, (unsigned long) appleir);



	hid_set_drvdata(hid, appleir);



	ret = hid_parse(hid);

	if (ret) {

		hid_err(hid, "parse failed\n");

		goto fail;

	}



	ret = hid_hw_start(hid, HID_CONNECT_DEFAULT | HID_CONNECT_HIDDEV_FORCE);

	if (ret) {

		hid_err(hid, "hw start failed\n");

		goto fail;

	}



	return 0;

fail:

	kfree(appleir);

allocfail:

	return ret;

}



static void appleir_remove(struct hid_device *hid)

{

	struct appleir *appleir = hid_get_drvdata(hid);

	hid_hw_stop(hid);

	del_timer_sync(&appleir->key_up_timer);

	kfree(appleir);

}



static const struct hid_device_id appleir_devices[] = {

	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL2) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL3) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL4) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL5) },

	{ }

};

MODULE_DEVICE_TABLE(hid, appleir_devices);



static struct hid_driver appleir_driver = {

	.name = "appleir",

	.id_table = appleir_devices,

	.raw_event = appleir_raw_event,

	.input_configured = appleir_input_configured,

	.probe = appleir_probe,

	.remove = appleir_remove,

	.input_mapping = appleir_input_mapping,

};

module_hid_driver(appleir_driver);

drivers/hid/hid-core.c

+5 −2
Original line number Diff line number Diff line
@@ -1502,8 +1502,6 @@ static const struct hid_device_id hid_have_special_driver[] = { 
	{ HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_X5_005D) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_RP_649) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_ACRUX, 0x0802) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ATV_IRCONTROL) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL4) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MIGHTYMOUSE) },

	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGICMOUSE) },

	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGICTRACKPAD) },
@@ -1527,6 +1525,11 @@ static const struct hid_device_id hid_have_special_driver[] = { 
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL2) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL3) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL4) },

	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL5) },

	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI) },

	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO) },

	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS) },