1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * HID driver for the apple ir device 4 * 5 * Original driver written by James McKenzie 6 * Ported to recent 2.6 kernel versions by Greg Kroah-Hartman <gregkh@suse.de> 7 * Updated to support newer remotes by Bastien Nocera <hadess@hadess.net> 8 * Ported to HID subsystem by Benjamin Tissoires <benjamin.tissoires@gmail.com> 9 * 10 * Copyright (C) 2006 James McKenzie 11 * Copyright (C) 2008 Greg Kroah-Hartman <greg@kroah.com> 12 * Copyright (C) 2008 Novell Inc. 13 * Copyright (C) 2010, 2012 Bastien Nocera <hadess@hadess.net> 14 * Copyright (C) 2013 Benjamin Tissoires <benjamin.tissoires@gmail.com> 15 * Copyright (C) 2013 Red Hat Inc. All Rights Reserved 16 */ 17 18 #include <linux/device.h> 19 #include <linux/hid.h> 20 #include <linux/module.h> 21 #include "hid-ids.h" 22 23 MODULE_AUTHOR("James McKenzie"); 24 MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@redhat.com>"); 25 MODULE_DESCRIPTION("HID Apple IR remote controls"); 26 MODULE_LICENSE("GPL"); 27 28 #define KEY_MASK 0x0F 29 #define TWO_PACKETS_MASK 0x40 30 31 /* 32 * James McKenzie has two devices both of which report the following 33 * 25 87 ee 83 0a + 34 * 25 87 ee 83 0c - 35 * 25 87 ee 83 09 << 36 * 25 87 ee 83 06 >> 37 * 25 87 ee 83 05 >" 38 * 25 87 ee 83 03 menu 39 * 26 00 00 00 00 for key repeat 40 */ 41 42 /* 43 * Thomas Glanzmann reports the following responses 44 * 25 87 ee ca 0b + 45 * 25 87 ee ca 0d - 46 * 25 87 ee ca 08 << 47 * 25 87 ee ca 07 >> 48 * 25 87 ee ca 04 >" 49 * 25 87 ee ca 02 menu 50 * 26 00 00 00 00 for key repeat 51 * 52 * He also observes the following event sometimes 53 * sent after a key is release, which I interpret 54 * as a flat battery message 55 * 25 87 e0 ca 06 flat battery 56 */ 57 58 /* 59 * Alexandre Karpenko reports the following responses for Device ID 0x8242 60 * 25 87 ee 47 0b + 61 * 25 87 ee 47 0d - 62 * 25 87 ee 47 08 << 63 * 25 87 ee 47 07 >> 64 * 25 87 ee 47 04 >" 65 * 25 87 ee 47 02 menu 66 * 26 87 ee 47 ** for key repeat (** is the code of the key being held) 67 */ 68 69 /* 70 * Bastien Nocera's remote 71 * 25 87 ee 91 5f followed by 72 * 25 87 ee 91 05 gives you >" 73 * 74 * 25 87 ee 91 5c followed by 75 * 25 87 ee 91 05 gives you the middle button 76 */ 77 78 /* 79 * Fabien Andre's remote 80 * 25 87 ee a3 5e followed by 81 * 25 87 ee a3 04 gives you >" 82 * 83 * 25 87 ee a3 5d followed by 84 * 25 87 ee a3 04 gives you the middle button 85 */ 86 87 static const unsigned short appleir_key_table[] = { 88 KEY_RESERVED, 89 KEY_MENU, 90 KEY_PLAYPAUSE, 91 KEY_FORWARD, 92 KEY_BACK, 93 KEY_VOLUMEUP, 94 KEY_VOLUMEDOWN, 95 KEY_RESERVED, 96 KEY_RESERVED, 97 KEY_RESERVED, 98 KEY_RESERVED, 99 KEY_RESERVED, 100 KEY_RESERVED, 101 KEY_RESERVED, 102 KEY_ENTER, 103 KEY_PLAYPAUSE, 104 KEY_RESERVED, 105 }; 106 107 struct appleir { 108 struct input_dev *input_dev; 109 struct hid_device *hid; 110 unsigned short keymap[ARRAY_SIZE(appleir_key_table)]; 111 struct timer_list key_up_timer; /* timer for key up */ 112 spinlock_t lock; /* protects .current_key */ 113 int current_key; /* the currently pressed key */ 114 int prev_key_idx; /* key index in a 2 packets message */ 115 }; 116 117 static int get_key(int data) 118 { 119 /* 120 * The key is coded accross bits 2..9: 121 * 122 * 0x00 or 0x01 ( ) key: 0 -> KEY_RESERVED 123 * 0x02 or 0x03 ( menu ) key: 1 -> KEY_MENU 124 * 0x04 or 0x05 ( >" ) key: 2 -> KEY_PLAYPAUSE 125 * 0x06 or 0x07 ( >> ) key: 3 -> KEY_FORWARD 126 * 0x08 or 0x09 ( << ) key: 4 -> KEY_BACK 127 * 0x0a or 0x0b ( + ) key: 5 -> KEY_VOLUMEUP 128 * 0x0c or 0x0d ( - ) key: 6 -> KEY_VOLUMEDOWN 129 * 0x0e or 0x0f ( ) key: 7 -> KEY_RESERVED 130 * 0x50 or 0x51 ( ) key: 8 -> KEY_RESERVED 131 * 0x52 or 0x53 ( ) key: 9 -> KEY_RESERVED 132 * 0x54 or 0x55 ( ) key: 10 -> KEY_RESERVED 133 * 0x56 or 0x57 ( ) key: 11 -> KEY_RESERVED 134 * 0x58 or 0x59 ( ) key: 12 -> KEY_RESERVED 135 * 0x5a or 0x5b ( ) key: 13 -> KEY_RESERVED 136 * 0x5c or 0x5d ( middle ) key: 14 -> KEY_ENTER 137 * 0x5e or 0x5f ( >" ) key: 15 -> KEY_PLAYPAUSE 138 * 139 * Packets starting with 0x5 are part of a two-packets message, 140 * we notify the caller by sending a negative value. 141 */ 142 int key = (data >> 1) & KEY_MASK; 143 144 if ((data & TWO_PACKETS_MASK)) 145 /* Part of a 2 packets-command */ 146 key = -key; 147 148 return key; 149 } 150 151 static void key_up(struct hid_device *hid, struct appleir *appleir, int key) 152 { 153 input_report_key(appleir->input_dev, key, 0); 154 input_sync(appleir->input_dev); 155 } 156 157 static void key_down(struct hid_device *hid, struct appleir *appleir, int key) 158 { 159 input_report_key(appleir->input_dev, key, 1); 160 input_sync(appleir->input_dev); 161 } 162 163 static void battery_flat(struct appleir *appleir) 164 { 165 dev_err(&appleir->input_dev->dev, "possible flat battery?\n"); 166 } 167 168 static void key_up_tick(struct timer_list *t) 169 { 170 struct appleir *appleir = from_timer(appleir, t, key_up_timer); 171 struct hid_device *hid = appleir->hid; 172 unsigned long flags; 173 174 spin_lock_irqsave(&appleir->lock, flags); 175 if (appleir->current_key) { 176 key_up(hid, appleir, appleir->current_key); 177 appleir->current_key = 0; 178 } 179 spin_unlock_irqrestore(&appleir->lock, flags); 180 } 181 182 static int appleir_raw_event(struct hid_device *hid, struct hid_report *report, 183 u8 *data, int len) 184 { 185 struct appleir *appleir = hid_get_drvdata(hid); 186 static const u8 keydown[] = { 0x25, 0x87, 0xee }; 187 static const u8 keyrepeat[] = { 0x26, }; 188 static const u8 flatbattery[] = { 0x25, 0x87, 0xe0 }; 189 unsigned long flags; 190 191 if (len != 5) 192 goto out; 193 194 if (!memcmp(data, keydown, sizeof(keydown))) { 195 int index; 196 197 spin_lock_irqsave(&appleir->lock, flags); 198 /* 199 * If we already have a key down, take it up before marking 200 * this one down 201 */ 202 if (appleir->current_key) 203 key_up(hid, appleir, appleir->current_key); 204 205 /* Handle dual packet commands */ 206 if (appleir->prev_key_idx > 0) 207 index = appleir->prev_key_idx; 208 else 209 index = get_key(data[4]); 210 211 if (index >= 0) { 212 appleir->current_key = appleir->keymap[index]; 213 214 key_down(hid, appleir, appleir->current_key); 215 /* 216 * Remote doesn't do key up, either pull them up, in 217 * the test above, or here set a timer which pulls 218 * them up after 1/8 s 219 */ 220 mod_timer(&appleir->key_up_timer, jiffies + HZ / 8); 221 appleir->prev_key_idx = 0; 222 } else 223 /* Remember key for next packet */ 224 appleir->prev_key_idx = -index; 225 spin_unlock_irqrestore(&appleir->lock, flags); 226 goto out; 227 } 228 229 appleir->prev_key_idx = 0; 230 231 if (!memcmp(data, keyrepeat, sizeof(keyrepeat))) { 232 key_down(hid, appleir, appleir->current_key); 233 /* 234 * Remote doesn't do key up, either pull them up, in the test 235 * above, or here set a timer which pulls them up after 1/8 s 236 */ 237 mod_timer(&appleir->key_up_timer, jiffies + HZ / 8); 238 goto out; 239 } 240 241 if (!memcmp(data, flatbattery, sizeof(flatbattery))) { 242 battery_flat(appleir); 243 /* Fall through */ 244 } 245 246 out: 247 /* let hidraw and hiddev handle the report */ 248 return 0; 249 } 250 251 static int appleir_input_configured(struct hid_device *hid, 252 struct hid_input *hidinput) 253 { 254 struct input_dev *input_dev = hidinput->input; 255 struct appleir *appleir = hid_get_drvdata(hid); 256 int i; 257 258 appleir->input_dev = input_dev; 259 260 input_dev->keycode = appleir->keymap; 261 input_dev->keycodesize = sizeof(unsigned short); 262 input_dev->keycodemax = ARRAY_SIZE(appleir->keymap); 263 264 input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_REP); 265 266 memcpy(appleir->keymap, appleir_key_table, sizeof(appleir->keymap)); 267 for (i = 0; i < ARRAY_SIZE(appleir_key_table); i++) 268 set_bit(appleir->keymap[i], input_dev->keybit); 269 clear_bit(KEY_RESERVED, input_dev->keybit); 270 271 return 0; 272 } 273 274 static int appleir_input_mapping(struct hid_device *hid, 275 struct hid_input *hi, struct hid_field *field, 276 struct hid_usage *usage, unsigned long **bit, int *max) 277 { 278 return -1; 279 } 280 281 static int appleir_probe(struct hid_device *hid, const struct hid_device_id *id) 282 { 283 int ret; 284 struct appleir *appleir; 285 286 appleir = kzalloc(sizeof(struct appleir), GFP_KERNEL); 287 if (!appleir) { 288 ret = -ENOMEM; 289 goto allocfail; 290 } 291 292 appleir->hid = hid; 293 294 /* force input as some remotes bypass the input registration */ 295 hid->quirks |= HID_QUIRK_HIDINPUT_FORCE; 296 297 spin_lock_init(&appleir->lock); 298 timer_setup(&appleir->key_up_timer, key_up_tick, 0); 299 300 hid_set_drvdata(hid, appleir); 301 302 ret = hid_parse(hid); 303 if (ret) { 304 hid_err(hid, "parse failed\n"); 305 goto fail; 306 } 307 308 ret = hid_hw_start(hid, HID_CONNECT_DEFAULT | HID_CONNECT_HIDDEV_FORCE); 309 if (ret) { 310 hid_err(hid, "hw start failed\n"); 311 goto fail; 312 } 313 314 return 0; 315 fail: 316 kfree(appleir); 317 allocfail: 318 return ret; 319 } 320 321 static void appleir_remove(struct hid_device *hid) 322 { 323 struct appleir *appleir = hid_get_drvdata(hid); 324 hid_hw_stop(hid); 325 del_timer_sync(&appleir->key_up_timer); 326 kfree(appleir); 327 } 328 329 static const struct hid_device_id appleir_devices[] = { 330 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL) }, 331 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL2) }, 332 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL3) }, 333 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL4) }, 334 { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL5) }, 335 { } 336 }; 337 MODULE_DEVICE_TABLE(hid, appleir_devices); 338 339 static struct hid_driver appleir_driver = { 340 .name = "appleir", 341 .id_table = appleir_devices, 342 .raw_event = appleir_raw_event, 343 .input_configured = appleir_input_configured, 344 .probe = appleir_probe, 345 .remove = appleir_remove, 346 .input_mapping = appleir_input_mapping, 347 }; 348 module_hid_driver(appleir_driver); 349