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