Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 1 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | * USB ATI Remote support |
| 3 | * |
Anssi Hannula | 9d454d4 | 2012-04-01 16:41:46 -0300 | [diff] [blame] | 4 | * Copyright (c) 2011, 2012 Anssi Hannula <anssi.hannula@iki.fi> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 5 | * Version 2.2.0 Copyright (c) 2004 Torrey Hoffman <thoffman@arnor.net> |
| 6 | * Version 2.1.1 Copyright (c) 2002 Vladimir Dergachev |
| 7 | * |
| 8 | * This 2.2.0 version is a rewrite / cleanup of the 2.1.1 driver, including |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 9 | * porting to the 2.6 kernel interfaces, along with other modification |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 10 | * to better match the style of the existing usb/input drivers. However, the |
| 11 | * protocol and hardware handling is essentially unchanged from 2.1.1. |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 12 | * |
| 13 | * The 2.1.1 driver was derived from the usbati_remote and usbkbd drivers by |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 14 | * Vojtech Pavlik. |
| 15 | * |
| 16 | * Changes: |
| 17 | * |
| 18 | * Feb 2004: Torrey Hoffman <thoffman@arnor.net> |
| 19 | * Version 2.2.0 |
| 20 | * Jun 2004: Torrey Hoffman <thoffman@arnor.net> |
| 21 | * Version 2.2.1 |
| 22 | * Added key repeat support contributed by: |
| 23 | * Vincent Vanackere <vanackere@lif.univ-mrs.fr> |
| 24 | * Added support for the "Lola" remote contributed by: |
| 25 | * Seth Cohn <sethcohn@yahoo.com> |
| 26 | * |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 27 | * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 28 | * |
| 29 | * This program is free software; you can redistribute it and/or modify |
| 30 | * it under the terms of the GNU General Public License as published by |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 31 | * the Free Software Foundation; either version 2 of the License, or |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 32 | * (at your option) any later version. |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 33 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 34 | * This program is distributed in the hope that it will be useful, |
| 35 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 36 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 37 | * GNU General Public License for more details. |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 38 | * |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 39 | * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 40 | * |
| 41 | * Hardware & software notes |
| 42 | * |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 43 | * These remote controls are distributed by ATI as part of their |
| 44 | * "All-In-Wonder" video card packages. The receiver self-identifies as a |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 45 | * "USB Receiver" with manufacturer "X10 Wireless Technology Inc". |
| 46 | * |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 47 | * The "Lola" remote is available from X10. See: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 48 | * http://www.x10.com/products/lola_sg1.htm |
| 49 | * The Lola is similar to the ATI remote but has no mouse support, and slightly |
| 50 | * different keys. |
| 51 | * |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 52 | * It is possible to use multiple receivers and remotes on multiple computers |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 53 | * simultaneously by configuring them to use specific channels. |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 54 | * |
| 55 | * The RF protocol used by the remote supports 16 distinct channels, 1 to 16. |
| 56 | * Actually, it may even support more, at least in some revisions of the |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 57 | * hardware. |
| 58 | * |
| 59 | * Each remote can be configured to transmit on one channel as follows: |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 60 | * - Press and hold the "hand icon" button. |
| 61 | * - When the red LED starts to blink, let go of the "hand icon" button. |
| 62 | * - When it stops blinking, input the channel code as two digits, from 01 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 63 | * to 16, and press the hand icon again. |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 64 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 65 | * The timing can be a little tricky. Try loading the module with debug=1 |
| 66 | * to have the kernel print out messages about the remote control number |
| 67 | * and mask. Note: debugging prints remote numbers as zero-based hexadecimal. |
| 68 | * |
| 69 | * The driver has a "channel_mask" parameter. This bitmask specifies which |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 70 | * channels will be ignored by the module. To mask out channels, just add |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 71 | * all the 2^channel_number values together. |
| 72 | * |
| 73 | * For instance, set channel_mask = 2^4 = 16 (binary 10000) to make ati_remote |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 74 | * ignore signals coming from remote controls transmitting on channel 4, but |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 75 | * accept all other channels. |
| 76 | * |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 77 | * Or, set channel_mask = 65533, (0xFFFD), and all channels except 1 will be |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 78 | * ignored. |
| 79 | * |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 80 | * The default is 0 (respond to all channels). Bit 0 and bits 17-32 of this |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 81 | * parameter are unused. |
| 82 | * |
| 83 | */ |
| 84 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 85 | #include <linux/kernel.h> |
| 86 | #include <linux/errno.h> |
| 87 | #include <linux/init.h> |
| 88 | #include <linux/slab.h> |
| 89 | #include <linux/module.h> |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 90 | #include <linux/mutex.h> |
David Brownell | ae0dadc | 2006-06-13 10:04:34 -0700 | [diff] [blame] | 91 | #include <linux/usb/input.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 92 | #include <linux/wait.h> |
Marcelo Feitoza Parisi | f0b80fb | 2005-12-01 00:50:39 +0300 | [diff] [blame] | 93 | #include <linux/jiffies.h> |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 94 | #include <media/rc-core.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 95 | |
| 96 | /* |
| 97 | * Module and Version Information, Module Parameters |
| 98 | */ |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 99 | |
Jarod Wilson | 5132088 | 2010-05-03 23:30:32 -0700 | [diff] [blame] | 100 | #define ATI_REMOTE_VENDOR_ID 0x0bc7 |
| 101 | #define LOLA_REMOTE_PRODUCT_ID 0x0002 |
| 102 | #define LOLA2_REMOTE_PRODUCT_ID 0x0003 |
| 103 | #define ATI_REMOTE_PRODUCT_ID 0x0004 |
| 104 | #define NVIDIA_REMOTE_PRODUCT_ID 0x0005 |
| 105 | #define MEDION_REMOTE_PRODUCT_ID 0x0006 |
Anssi Hannula | 999d6bc | 2011-08-06 18:18:12 -0300 | [diff] [blame] | 106 | #define FIREFLY_REMOTE_PRODUCT_ID 0x0008 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 107 | |
Anssi Hannula | 9688efd | 2011-08-06 18:18:07 -0300 | [diff] [blame] | 108 | #define DRIVER_VERSION "2.2.1" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 109 | #define DRIVER_AUTHOR "Torrey Hoffman <thoffman@arnor.net>" |
| 110 | #define DRIVER_DESC "ATI/X10 RF USB Remote Control" |
| 111 | |
| 112 | #define NAME_BUFSIZE 80 /* size of product name, path buffers */ |
| 113 | #define DATA_BUFSIZE 63 /* size of URB data buffers */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 114 | |
Edwin Huffstutler | c669869 | 2006-08-04 22:53:02 -0400 | [diff] [blame] | 115 | /* |
| 116 | * Duplicate event filtering time. |
| 117 | * Sequential, identical KIND_FILTERED inputs with less than |
| 118 | * FILTER_TIME milliseconds between them are considered as repeat |
| 119 | * events. The hardware generates 5 events for the first keypress |
| 120 | * and we have to take this into account for an accurate repeat |
| 121 | * behaviour. |
| 122 | */ |
| 123 | #define FILTER_TIME 60 /* msec */ |
Karl Pickett | 0de9550 | 2007-04-12 01:35:59 -0400 | [diff] [blame] | 124 | #define REPEAT_DELAY 500 /* msec */ |
Edwin Huffstutler | c669869 | 2006-08-04 22:53:02 -0400 | [diff] [blame] | 125 | |
Dmitry Torokhov | 65cde54 | 2005-05-29 02:29:38 -0500 | [diff] [blame] | 126 | static unsigned long channel_mask; |
Dmitry Torokhov | c605b67 | 2006-08-04 22:53:15 -0400 | [diff] [blame] | 127 | module_param(channel_mask, ulong, 0644); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 128 | MODULE_PARM_DESC(channel_mask, "Bitmask of remote control channels to ignore"); |
| 129 | |
Dmitry Torokhov | 65cde54 | 2005-05-29 02:29:38 -0500 | [diff] [blame] | 130 | static int debug; |
Dmitry Torokhov | c605b67 | 2006-08-04 22:53:15 -0400 | [diff] [blame] | 131 | module_param(debug, int, 0644); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 132 | MODULE_PARM_DESC(debug, "Enable extra debug messages and information"); |
| 133 | |
Edwin Huffstutler | c669869 | 2006-08-04 22:53:02 -0400 | [diff] [blame] | 134 | static int repeat_filter = FILTER_TIME; |
| 135 | module_param(repeat_filter, int, 0644); |
| 136 | MODULE_PARM_DESC(repeat_filter, "Repeat filter time, default = 60 msec"); |
| 137 | |
Karl Pickett | 0de9550 | 2007-04-12 01:35:59 -0400 | [diff] [blame] | 138 | static int repeat_delay = REPEAT_DELAY; |
| 139 | module_param(repeat_delay, int, 0644); |
| 140 | MODULE_PARM_DESC(repeat_delay, "Delay before sending repeats, default = 500 msec"); |
| 141 | |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 142 | static bool mouse = true; |
| 143 | module_param(mouse, bool, 0444); |
| 144 | MODULE_PARM_DESC(mouse, "Enable mouse device, default = yes"); |
| 145 | |
Du, Changbin | a342daea | 2012-07-07 03:53:28 -0300 | [diff] [blame] | 146 | #define dbginfo(dev, format, arg...) \ |
| 147 | do { if (debug) dev_info(dev , format , ## arg); } while (0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 148 | #undef err |
| 149 | #define err(format, arg...) printk(KERN_ERR format , ## arg) |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 150 | |
Anssi Hannula | 0d74679 | 2012-04-01 16:41:45 -0300 | [diff] [blame] | 151 | struct ati_receiver_type { |
| 152 | /* either default_keymap or get_default_keymap should be set */ |
| 153 | const char *default_keymap; |
| 154 | const char *(*get_default_keymap)(struct usb_interface *interface); |
| 155 | }; |
| 156 | |
Anssi Hannula | 9d454d4 | 2012-04-01 16:41:46 -0300 | [diff] [blame] | 157 | static const char *get_medion_keymap(struct usb_interface *interface) |
| 158 | { |
| 159 | struct usb_device *udev = interface_to_usbdev(interface); |
| 160 | |
Anssi Hannula | 5085c99 | 2012-05-14 09:52:37 -0300 | [diff] [blame] | 161 | /* |
| 162 | * There are many different Medion remotes shipped with a receiver |
| 163 | * with the same usb id, but the receivers have subtle differences |
| 164 | * in the USB descriptors allowing us to detect them. |
| 165 | */ |
| 166 | |
| 167 | if (udev->manufacturer && udev->product) { |
| 168 | if (udev->actconfig->desc.bmAttributes & USB_CONFIG_ATT_WAKEUP) { |
| 169 | |
| 170 | if (!strcmp(udev->manufacturer, "X10 Wireless Technology Inc") |
| 171 | && !strcmp(udev->product, "USB Receiver")) |
| 172 | return RC_MAP_MEDION_X10_DIGITAINER; |
| 173 | |
| 174 | if (!strcmp(udev->manufacturer, "X10 WTI") |
| 175 | && !strcmp(udev->product, "RF receiver")) |
| 176 | return RC_MAP_MEDION_X10_OR2X; |
| 177 | } else { |
| 178 | |
| 179 | if (!strcmp(udev->manufacturer, "X10 Wireless Technology Inc") |
| 180 | && !strcmp(udev->product, "USB Receiver")) |
| 181 | return RC_MAP_MEDION_X10; |
| 182 | } |
| 183 | } |
| 184 | |
| 185 | dev_info(&interface->dev, |
| 186 | "Unknown Medion X10 receiver, using default ati_remote Medion keymap\n"); |
Anssi Hannula | 9d454d4 | 2012-04-01 16:41:46 -0300 | [diff] [blame] | 187 | |
| 188 | return RC_MAP_MEDION_X10; |
| 189 | } |
| 190 | |
Du, Changbin | a342daea | 2012-07-07 03:53:28 -0300 | [diff] [blame] | 191 | static const struct ati_receiver_type type_ati = { |
| 192 | .default_keymap = RC_MAP_ATI_X10 |
| 193 | }; |
| 194 | static const struct ati_receiver_type type_medion = { |
| 195 | .get_default_keymap = get_medion_keymap |
| 196 | }; |
| 197 | static const struct ati_receiver_type type_firefly = { |
| 198 | .default_keymap = RC_MAP_SNAPSTREAM_FIREFLY |
| 199 | }; |
Anssi Hannula | 0d74679 | 2012-04-01 16:41:45 -0300 | [diff] [blame] | 200 | |
Arvind Yadav | 5fad16b | 2017-08-13 05:54:44 -0300 | [diff] [blame] | 201 | static const struct usb_device_id ati_remote_table[] = { |
Du, Changbin | a342daea | 2012-07-07 03:53:28 -0300 | [diff] [blame] | 202 | { |
| 203 | USB_DEVICE(ATI_REMOTE_VENDOR_ID, LOLA_REMOTE_PRODUCT_ID), |
| 204 | .driver_info = (unsigned long)&type_ati |
| 205 | }, |
| 206 | { |
| 207 | USB_DEVICE(ATI_REMOTE_VENDOR_ID, LOLA2_REMOTE_PRODUCT_ID), |
| 208 | .driver_info = (unsigned long)&type_ati |
| 209 | }, |
| 210 | { |
| 211 | USB_DEVICE(ATI_REMOTE_VENDOR_ID, ATI_REMOTE_PRODUCT_ID), |
| 212 | .driver_info = (unsigned long)&type_ati |
| 213 | }, |
| 214 | { |
| 215 | USB_DEVICE(ATI_REMOTE_VENDOR_ID, NVIDIA_REMOTE_PRODUCT_ID), |
| 216 | .driver_info = (unsigned long)&type_ati |
| 217 | }, |
| 218 | { |
| 219 | USB_DEVICE(ATI_REMOTE_VENDOR_ID, MEDION_REMOTE_PRODUCT_ID), |
| 220 | .driver_info = (unsigned long)&type_medion |
| 221 | }, |
| 222 | { |
| 223 | USB_DEVICE(ATI_REMOTE_VENDOR_ID, FIREFLY_REMOTE_PRODUCT_ID), |
| 224 | .driver_info = (unsigned long)&type_firefly |
| 225 | }, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 226 | {} /* Terminating entry */ |
| 227 | }; |
| 228 | |
| 229 | MODULE_DEVICE_TABLE(usb, ati_remote_table); |
| 230 | |
| 231 | /* Get hi and low bytes of a 16-bits int */ |
| 232 | #define HI(a) ((unsigned char)((a) >> 8)) |
| 233 | #define LO(a) ((unsigned char)((a) & 0xff)) |
| 234 | |
| 235 | #define SEND_FLAG_IN_PROGRESS 1 |
| 236 | #define SEND_FLAG_COMPLETE 2 |
| 237 | |
| 238 | /* Device initialization strings */ |
| 239 | static char init1[] = { 0x01, 0x00, 0x20, 0x14 }; |
| 240 | static char init2[] = { 0x01, 0x00, 0x20, 0x14, 0x20, 0x20, 0x20 }; |
| 241 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 242 | struct ati_remote { |
Dmitry Torokhov | c5b7c7c | 2005-09-15 02:01:47 -0500 | [diff] [blame] | 243 | struct input_dev *idev; |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 244 | struct rc_dev *rdev; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 245 | struct usb_device *udev; |
| 246 | struct usb_interface *interface; |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 247 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 248 | struct urb *irq_urb; |
| 249 | struct urb *out_urb; |
| 250 | struct usb_endpoint_descriptor *endpoint_in; |
| 251 | struct usb_endpoint_descriptor *endpoint_out; |
| 252 | unsigned char *inbuf; |
| 253 | unsigned char *outbuf; |
| 254 | dma_addr_t inbuf_dma; |
| 255 | dma_addr_t outbuf_dma; |
| 256 | |
Anssi Hannula | 5eefb4f | 2011-12-06 22:34:29 -0300 | [diff] [blame] | 257 | unsigned char old_data; /* Detect duplicate events */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 258 | unsigned long old_jiffies; |
| 259 | unsigned long acc_jiffies; /* handle acceleration */ |
Karl Pickett | 0de9550 | 2007-04-12 01:35:59 -0400 | [diff] [blame] | 260 | unsigned long first_jiffies; |
| 261 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 262 | unsigned int repeat_count; |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 263 | |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 264 | char rc_name[NAME_BUFSIZE]; |
| 265 | char rc_phys[NAME_BUFSIZE]; |
| 266 | char mouse_name[NAME_BUFSIZE]; |
| 267 | char mouse_phys[NAME_BUFSIZE]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 268 | |
| 269 | wait_queue_head_t wait; |
| 270 | int send_flags; |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 271 | |
| 272 | int users; /* 0-2, users are rc and input */ |
| 273 | struct mutex open_mutex; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 274 | }; |
| 275 | |
| 276 | /* "Kinds" of messages sent from the hardware to the driver. */ |
| 277 | #define KIND_END 0 |
George Spelvin | 3f245b9 | 2014-05-11 08:14:54 -0300 | [diff] [blame] | 278 | #define KIND_LITERAL 1 /* Simply pass to input system as EV_KEY */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 279 | #define KIND_FILTERED 2 /* Add artificial key-up events, drop keyrepeats */ |
George Spelvin | 3f245b9 | 2014-05-11 08:14:54 -0300 | [diff] [blame] | 280 | #define KIND_ACCEL 3 /* Translate to EV_REL mouse-move events */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 281 | |
| 282 | /* Translation table from hardware messages to input events. */ |
Arjan van de Ven | 4c4c943 | 2005-11-29 09:43:42 +0100 | [diff] [blame] | 283 | static const struct { |
George Spelvin | 528abb9 | 2014-05-11 08:12:55 -0300 | [diff] [blame] | 284 | unsigned char kind; |
George Spelvin | 3f245b9 | 2014-05-11 08:14:54 -0300 | [diff] [blame] | 285 | unsigned char data; /* Raw key code from remote */ |
| 286 | unsigned short code; /* Input layer translation */ |
Dmitry Torokhov | c5b7c7c | 2005-09-15 02:01:47 -0500 | [diff] [blame] | 287 | } ati_remote_tbl[] = { |
George Spelvin | 8ecd5e3 | 2014-05-11 08:14:18 -0300 | [diff] [blame] | 288 | /* Directional control pad axes. Code is xxyy */ |
George Spelvin | 3f245b9 | 2014-05-11 08:14:54 -0300 | [diff] [blame] | 289 | {KIND_ACCEL, 0x70, 0xff00}, /* left */ |
| 290 | {KIND_ACCEL, 0x71, 0x0100}, /* right */ |
| 291 | {KIND_ACCEL, 0x72, 0x00ff}, /* up */ |
| 292 | {KIND_ACCEL, 0x73, 0x0001}, /* down */ |
George Spelvin | 8ecd5e3 | 2014-05-11 08:14:18 -0300 | [diff] [blame] | 293 | |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 294 | /* Directional control pad diagonals */ |
George Spelvin | 3f245b9 | 2014-05-11 08:14:54 -0300 | [diff] [blame] | 295 | {KIND_ACCEL, 0x74, 0xffff}, /* left up */ |
| 296 | {KIND_ACCEL, 0x75, 0x01ff}, /* right up */ |
| 297 | {KIND_ACCEL, 0x77, 0xff01}, /* left down */ |
| 298 | {KIND_ACCEL, 0x76, 0x0101}, /* right down */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 299 | |
George Spelvin | 3f245b9 | 2014-05-11 08:14:54 -0300 | [diff] [blame] | 300 | /* "Mouse button" buttons. The code below uses the fact that the |
| 301 | * lsbit of the raw code is a down/up indicator. */ |
| 302 | {KIND_LITERAL, 0x78, BTN_LEFT}, /* left btn down */ |
| 303 | {KIND_LITERAL, 0x79, BTN_LEFT}, /* left btn up */ |
| 304 | {KIND_LITERAL, 0x7c, BTN_RIGHT},/* right btn down */ |
| 305 | {KIND_LITERAL, 0x7d, BTN_RIGHT},/* right btn up */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 306 | |
Mauro Carvalho Chehab | 04ad301 | 2019-02-18 14:29:01 -0500 | [diff] [blame] | 307 | /* Artificial "double-click" events are generated by the hardware. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 308 | * They are mapped to the "side" and "extra" mouse buttons here. */ |
George Spelvin | 3f245b9 | 2014-05-11 08:14:54 -0300 | [diff] [blame] | 309 | {KIND_FILTERED, 0x7a, BTN_SIDE}, /* left dblclick */ |
| 310 | {KIND_FILTERED, 0x7e, BTN_EXTRA},/* right dblclick */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 311 | |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 312 | /* Non-mouse events are handled by rc-core */ |
George Spelvin | 3f245b9 | 2014-05-11 08:14:54 -0300 | [diff] [blame] | 313 | {KIND_END, 0x00, 0} |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 314 | }; |
| 315 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 316 | /* |
Du, Changbin | a342daea | 2012-07-07 03:53:28 -0300 | [diff] [blame] | 317 | * ati_remote_dump_input |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 318 | */ |
Greg Kroah-Hartman | 1817b16 | 2008-08-14 09:37:34 -0700 | [diff] [blame] | 319 | static void ati_remote_dump(struct device *dev, unsigned char *data, |
| 320 | unsigned int len) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 321 | { |
Anssi Hannula | 0224e04 | 2011-08-06 18:18:10 -0300 | [diff] [blame] | 322 | if (len == 1) { |
| 323 | if (data[0] != (unsigned char)0xff && data[0] != 0x00) |
| 324 | dev_warn(dev, "Weird byte 0x%02x\n", data[0]); |
| 325 | } else if (len == 4) |
Andy Shevchenko | 7c94c69 | 2012-08-07 12:43:09 -0300 | [diff] [blame] | 326 | dev_warn(dev, "Weird key %*ph\n", 4, data); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 327 | else |
Andy Shevchenko | 7c94c69 | 2012-08-07 12:43:09 -0300 | [diff] [blame] | 328 | dev_warn(dev, "Weird data, len=%d %*ph ...\n", len, 6, data); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 329 | } |
| 330 | |
| 331 | /* |
Du, Changbin | a342daea | 2012-07-07 03:53:28 -0300 | [diff] [blame] | 332 | * ati_remote_open |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 333 | */ |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 334 | static int ati_remote_open(struct ati_remote *ati_remote) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 335 | { |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 336 | int err = 0; |
| 337 | |
| 338 | mutex_lock(&ati_remote->open_mutex); |
| 339 | |
| 340 | if (ati_remote->users++ != 0) |
| 341 | goto out; /* one was already active */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 342 | |
| 343 | /* On first open, submit the read urb which was set up previously. */ |
| 344 | ati_remote->irq_urb->dev = ati_remote->udev; |
| 345 | if (usb_submit_urb(ati_remote->irq_urb, GFP_KERNEL)) { |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 346 | dev_err(&ati_remote->interface->dev, |
Harvey Harrison | ea3e6c5 | 2008-05-05 11:36:18 -0400 | [diff] [blame] | 347 | "%s: usb_submit_urb failed!\n", __func__); |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 348 | err = -EIO; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 349 | } |
| 350 | |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 351 | out: mutex_unlock(&ati_remote->open_mutex); |
| 352 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 353 | } |
| 354 | |
| 355 | /* |
Du, Changbin | a342daea | 2012-07-07 03:53:28 -0300 | [diff] [blame] | 356 | * ati_remote_close |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 357 | */ |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 358 | static void ati_remote_close(struct ati_remote *ati_remote) |
| 359 | { |
| 360 | mutex_lock(&ati_remote->open_mutex); |
| 361 | if (--ati_remote->users == 0) |
| 362 | usb_kill_urb(ati_remote->irq_urb); |
| 363 | mutex_unlock(&ati_remote->open_mutex); |
| 364 | } |
| 365 | |
| 366 | static int ati_remote_input_open(struct input_dev *inputdev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 367 | { |
Dmitry Torokhov | 7791bda | 2007-04-12 01:34:39 -0400 | [diff] [blame] | 368 | struct ati_remote *ati_remote = input_get_drvdata(inputdev); |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 369 | return ati_remote_open(ati_remote); |
| 370 | } |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 371 | |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 372 | static void ati_remote_input_close(struct input_dev *inputdev) |
| 373 | { |
| 374 | struct ati_remote *ati_remote = input_get_drvdata(inputdev); |
| 375 | ati_remote_close(ati_remote); |
| 376 | } |
| 377 | |
| 378 | static int ati_remote_rc_open(struct rc_dev *rdev) |
| 379 | { |
| 380 | struct ati_remote *ati_remote = rdev->priv; |
| 381 | return ati_remote_open(ati_remote); |
| 382 | } |
| 383 | |
| 384 | static void ati_remote_rc_close(struct rc_dev *rdev) |
| 385 | { |
| 386 | struct ati_remote *ati_remote = rdev->priv; |
| 387 | ati_remote_close(ati_remote); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 388 | } |
| 389 | |
| 390 | /* |
Du, Changbin | a342daea | 2012-07-07 03:53:28 -0300 | [diff] [blame] | 391 | * ati_remote_irq_out |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 392 | */ |
David Howells | 7d12e78 | 2006-10-05 14:55:46 +0100 | [diff] [blame] | 393 | static void ati_remote_irq_out(struct urb *urb) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 394 | { |
| 395 | struct ati_remote *ati_remote = urb->context; |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 396 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 397 | if (urb->status) { |
| 398 | dev_dbg(&ati_remote->interface->dev, "%s: status %d\n", |
Harvey Harrison | ea3e6c5 | 2008-05-05 11:36:18 -0400 | [diff] [blame] | 399 | __func__, urb->status); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 400 | return; |
| 401 | } |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 402 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 403 | ati_remote->send_flags |= SEND_FLAG_COMPLETE; |
| 404 | wmb(); |
| 405 | wake_up(&ati_remote->wait); |
| 406 | } |
| 407 | |
| 408 | /* |
Du, Changbin | a342daea | 2012-07-07 03:53:28 -0300 | [diff] [blame] | 409 | * ati_remote_sendpacket |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 410 | * |
Du, Changbin | a342daea | 2012-07-07 03:53:28 -0300 | [diff] [blame] | 411 | * Used to send device initialization strings |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 412 | */ |
Du, Changbin | a342daea | 2012-07-07 03:53:28 -0300 | [diff] [blame] | 413 | static int ati_remote_sendpacket(struct ati_remote *ati_remote, u16 cmd, |
| 414 | unsigned char *data) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 415 | { |
| 416 | int retval = 0; |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 417 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 418 | /* Set up out_urb */ |
| 419 | memcpy(ati_remote->out_urb->transfer_buffer + 1, data, LO(cmd)); |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 420 | ((char *) ati_remote->out_urb->transfer_buffer)[0] = HI(cmd); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 421 | |
| 422 | ati_remote->out_urb->transfer_buffer_length = LO(cmd) + 1; |
| 423 | ati_remote->out_urb->dev = ati_remote->udev; |
| 424 | ati_remote->send_flags = SEND_FLAG_IN_PROGRESS; |
| 425 | |
| 426 | retval = usb_submit_urb(ati_remote->out_urb, GFP_ATOMIC); |
| 427 | if (retval) { |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 428 | dev_dbg(&ati_remote->interface->dev, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 429 | "sendpacket: usb_submit_urb failed: %d\n", retval); |
| 430 | return retval; |
| 431 | } |
| 432 | |
| 433 | wait_event_timeout(ati_remote->wait, |
| 434 | ((ati_remote->out_urb->status != -EINPROGRESS) || |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 435 | (ati_remote->send_flags & SEND_FLAG_COMPLETE)), |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 436 | HZ); |
| 437 | usb_kill_urb(ati_remote->out_urb); |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 438 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 439 | return retval; |
| 440 | } |
| 441 | |
Mauro Carvalho Chehab | fe28f5d | 2016-02-27 07:51:12 -0300 | [diff] [blame] | 442 | struct accel_times { |
| 443 | const char value; |
| 444 | unsigned int msecs; |
| 445 | }; |
| 446 | |
| 447 | static const struct accel_times accel[] = { |
| 448 | { 1, 125 }, |
| 449 | { 2, 250 }, |
| 450 | { 4, 500 }, |
| 451 | { 6, 1000 }, |
| 452 | { 9, 1500 }, |
| 453 | { 13, 2000 }, |
| 454 | { 20, 0 }, |
| 455 | }; |
| 456 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 457 | /* |
Du, Changbin | a342daea | 2012-07-07 03:53:28 -0300 | [diff] [blame] | 458 | * ati_remote_compute_accel |
Dmitry Torokhov | 2ffc1cc | 2006-08-04 22:53:37 -0400 | [diff] [blame] | 459 | * |
| 460 | * Implements acceleration curve for directional control pad |
| 461 | * If elapsed time since last event is > 1/4 second, user "stopped", |
| 462 | * so reset acceleration. Otherwise, user is probably holding the control |
| 463 | * pad down, so we increase acceleration, ramping up over two seconds to |
| 464 | * a maximum speed. |
| 465 | */ |
| 466 | static int ati_remote_compute_accel(struct ati_remote *ati_remote) |
| 467 | { |
Mauro Carvalho Chehab | fe28f5d | 2016-02-27 07:51:12 -0300 | [diff] [blame] | 468 | unsigned long now = jiffies, reset_time; |
| 469 | int i; |
Dmitry Torokhov | 2ffc1cc | 2006-08-04 22:53:37 -0400 | [diff] [blame] | 470 | |
Mauro Carvalho Chehab | fe28f5d | 2016-02-27 07:51:12 -0300 | [diff] [blame] | 471 | reset_time = msecs_to_jiffies(250); |
| 472 | |
| 473 | if (time_after(now, ati_remote->old_jiffies + reset_time)) { |
Dmitry Torokhov | 2ffc1cc | 2006-08-04 22:53:37 -0400 | [diff] [blame] | 474 | ati_remote->acc_jiffies = now; |
Mauro Carvalho Chehab | fe28f5d | 2016-02-27 07:51:12 -0300 | [diff] [blame] | 475 | return 1; |
Dmitry Torokhov | 2ffc1cc | 2006-08-04 22:53:37 -0400 | [diff] [blame] | 476 | } |
Mauro Carvalho Chehab | fe28f5d | 2016-02-27 07:51:12 -0300 | [diff] [blame] | 477 | for (i = 0; i < ARRAY_SIZE(accel) - 1; i++) { |
| 478 | unsigned long timeout = msecs_to_jiffies(accel[i].msecs); |
Dmitry Torokhov | 2ffc1cc | 2006-08-04 22:53:37 -0400 | [diff] [blame] | 479 | |
Mauro Carvalho Chehab | fe28f5d | 2016-02-27 07:51:12 -0300 | [diff] [blame] | 480 | if (time_before(now, ati_remote->acc_jiffies + timeout)) |
| 481 | return accel[i].value; |
| 482 | } |
| 483 | return accel[i].value; |
Dmitry Torokhov | 2ffc1cc | 2006-08-04 22:53:37 -0400 | [diff] [blame] | 484 | } |
| 485 | |
| 486 | /* |
Du, Changbin | a342daea | 2012-07-07 03:53:28 -0300 | [diff] [blame] | 487 | * ati_remote_report_input |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 488 | */ |
David Howells | 7d12e78 | 2006-10-05 14:55:46 +0100 | [diff] [blame] | 489 | static void ati_remote_input_report(struct urb *urb) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 490 | { |
| 491 | struct ati_remote *ati_remote = urb->context; |
| 492 | unsigned char *data= ati_remote->inbuf; |
Dmitry Torokhov | c5b7c7c | 2005-09-15 02:01:47 -0500 | [diff] [blame] | 493 | struct input_dev *dev = ati_remote->idev; |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 494 | int index = -1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 495 | int remote_num; |
Anssi Hannula | 5eefb4f | 2011-12-06 22:34:29 -0300 | [diff] [blame] | 496 | unsigned char scancode; |
Anssi Hannula | 9d454d4 | 2012-04-01 16:41:46 -0300 | [diff] [blame] | 497 | u32 wheel_keycode = KEY_RESERVED; |
Anssi Hannula | 5eefb4f | 2011-12-06 22:34:29 -0300 | [diff] [blame] | 498 | int i; |
| 499 | |
| 500 | /* |
| 501 | * data[0] = 0x14 |
| 502 | * data[1] = data[2] + data[3] + 0xd5 (a checksum byte) |
| 503 | * data[2] = the key code (with toggle bit in MSB with some models) |
| 504 | * data[3] = channel << 4 (the low 4 bits must be zero) |
| 505 | */ |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 506 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 507 | /* Deal with strange looking inputs */ |
George Spelvin | 20d7e3c | 2014-05-11 08:12:09 -0300 | [diff] [blame] | 508 | if ( urb->actual_length != 4 || data[0] != 0x14 || |
| 509 | data[1] != (unsigned char)(data[2] + data[3] + 0xD5) || |
| 510 | (data[3] & 0x0f) != 0x00) { |
Greg Kroah-Hartman | 1817b16 | 2008-08-14 09:37:34 -0700 | [diff] [blame] | 511 | ati_remote_dump(&urb->dev->dev, data, urb->actual_length); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 512 | return; |
| 513 | } |
| 514 | |
Anssi Hannula | 5eefb4f | 2011-12-06 22:34:29 -0300 | [diff] [blame] | 515 | if (data[1] != ((data[2] + data[3] + 0xd5) & 0xff)) { |
| 516 | dbginfo(&ati_remote->interface->dev, |
Andy Shevchenko | 7c94c69 | 2012-08-07 12:43:09 -0300 | [diff] [blame] | 517 | "wrong checksum in input: %*ph\n", 4, data); |
Anssi Hannula | 5eefb4f | 2011-12-06 22:34:29 -0300 | [diff] [blame] | 518 | return; |
| 519 | } |
| 520 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 521 | /* Mask unwanted remote channels. */ |
| 522 | /* note: remote_num is 0-based, channel 1 on remote == 0 here */ |
| 523 | remote_num = (data[3] >> 4) & 0x0f; |
Anssi Hannula | 9688efd | 2011-08-06 18:18:07 -0300 | [diff] [blame] | 524 | if (channel_mask & (1 << (remote_num + 1))) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 525 | dbginfo(&ati_remote->interface->dev, |
Mauro Carvalho Chehab | 25ec587 | 2016-10-18 17:44:25 -0200 | [diff] [blame] | 526 | "Masked input from channel 0x%02x: data %02x, mask= 0x%02lx\n", |
George Spelvin | 20d7e3c | 2014-05-11 08:12:09 -0300 | [diff] [blame] | 527 | remote_num, data[2], channel_mask); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 528 | return; |
| 529 | } |
| 530 | |
Anssi Hannula | 999d6bc | 2011-08-06 18:18:12 -0300 | [diff] [blame] | 531 | /* |
Anssi Hannula | 5eefb4f | 2011-12-06 22:34:29 -0300 | [diff] [blame] | 532 | * MSB is a toggle code, though only used by some devices |
| 533 | * (e.g. SnapStream Firefly) |
Anssi Hannula | 999d6bc | 2011-08-06 18:18:12 -0300 | [diff] [blame] | 534 | */ |
Anssi Hannula | 5eefb4f | 2011-12-06 22:34:29 -0300 | [diff] [blame] | 535 | scancode = data[2] & 0x7f; |
Anssi Hannula | 999d6bc | 2011-08-06 18:18:12 -0300 | [diff] [blame] | 536 | |
Anssi Hannula | 9d454d4 | 2012-04-01 16:41:46 -0300 | [diff] [blame] | 537 | dbginfo(&ati_remote->interface->dev, |
| 538 | "channel 0x%02x; key data %02x, scancode %02x\n", |
| 539 | remote_num, data[2], scancode); |
| 540 | |
| 541 | if (scancode >= 0x70) { |
| 542 | /* |
| 543 | * This is either a mouse or scrollwheel event, depending on |
| 544 | * the remote/keymap. |
| 545 | * Get the keycode assigned to scancode 0x78/0x70. If it is |
| 546 | * set, assume this is a scrollwheel up/down event. |
| 547 | */ |
| 548 | wheel_keycode = rc_g_keycode_from_table(ati_remote->rdev, |
| 549 | scancode & 0x78); |
| 550 | |
| 551 | if (wheel_keycode == KEY_RESERVED) { |
| 552 | /* scrollwheel was not mapped, assume mouse */ |
| 553 | |
Du, Changbin | a342daea | 2012-07-07 03:53:28 -0300 | [diff] [blame] | 554 | /* Look up event code index in the mouse translation |
| 555 | * table. |
| 556 | */ |
Anssi Hannula | 9d454d4 | 2012-04-01 16:41:46 -0300 | [diff] [blame] | 557 | for (i = 0; ati_remote_tbl[i].kind != KIND_END; i++) { |
| 558 | if (scancode == ati_remote_tbl[i].data) { |
| 559 | index = i; |
| 560 | break; |
| 561 | } |
| 562 | } |
Anssi Hannula | 5eefb4f | 2011-12-06 22:34:29 -0300 | [diff] [blame] | 563 | } |
| 564 | } |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 565 | |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 566 | if (index >= 0 && ati_remote_tbl[index].kind == KIND_LITERAL) { |
George Spelvin | 3f245b9 | 2014-05-11 08:14:54 -0300 | [diff] [blame] | 567 | /* |
| 568 | * The lsbit of the raw key code is a down/up flag. |
| 569 | * Invert it to match the input layer's conventions. |
| 570 | */ |
| 571 | input_event(dev, EV_KEY, ati_remote_tbl[index].code, |
| 572 | !(data[2] & 1)); |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 573 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 574 | ati_remote->old_jiffies = jiffies; |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 575 | |
George Spelvin | 8ecd5e3 | 2014-05-11 08:14:18 -0300 | [diff] [blame] | 576 | } else if (index < 0 || ati_remote_tbl[index].kind == KIND_FILTERED) { |
Karl Pickett | 0de9550 | 2007-04-12 01:35:59 -0400 | [diff] [blame] | 577 | unsigned long now = jiffies; |
| 578 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 579 | /* Filter duplicate events which happen "too close" together. */ |
Anssi Hannula | 5eefb4f | 2011-12-06 22:34:29 -0300 | [diff] [blame] | 580 | if (ati_remote->old_data == data[2] && |
Karl Pickett | 0de9550 | 2007-04-12 01:35:59 -0400 | [diff] [blame] | 581 | time_before(now, ati_remote->old_jiffies + |
| 582 | msecs_to_jiffies(repeat_filter))) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 583 | ati_remote->repeat_count++; |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 584 | } else { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 585 | ati_remote->repeat_count = 0; |
Karl Pickett | 0de9550 | 2007-04-12 01:35:59 -0400 | [diff] [blame] | 586 | ati_remote->first_jiffies = now; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 587 | } |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 588 | |
Karl Pickett | 0de9550 | 2007-04-12 01:35:59 -0400 | [diff] [blame] | 589 | ati_remote->old_jiffies = now; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 590 | |
George Spelvin | 3f245b9 | 2014-05-11 08:14:54 -0300 | [diff] [blame] | 591 | /* Ensure we skip at least the 4 first duplicate events |
| 592 | * (generated by a single keypress), and continue skipping |
| 593 | * until repeat_delay msecs have passed. |
Karl Pickett | 0de9550 | 2007-04-12 01:35:59 -0400 | [diff] [blame] | 594 | */ |
Edwin Huffstutler | c669869 | 2006-08-04 22:53:02 -0400 | [diff] [blame] | 595 | if (ati_remote->repeat_count > 0 && |
Karl Pickett | 0de9550 | 2007-04-12 01:35:59 -0400 | [diff] [blame] | 596 | (ati_remote->repeat_count < 5 || |
| 597 | time_before(now, ati_remote->first_jiffies + |
| 598 | msecs_to_jiffies(repeat_delay)))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 599 | return; |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 600 | |
George Spelvin | 89b0c0d | 2014-05-11 08:15:44 -0300 | [diff] [blame] | 601 | if (index >= 0) { |
| 602 | input_event(dev, EV_KEY, ati_remote_tbl[index].code, 1); |
| 603 | input_event(dev, EV_KEY, ati_remote_tbl[index].code, 0); |
| 604 | } else { |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 605 | /* Not a mouse event, hand it to rc-core. */ |
Anssi Hannula | 9d454d4 | 2012-04-01 16:41:46 -0300 | [diff] [blame] | 606 | int count = 1; |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 607 | |
Anssi Hannula | 9d454d4 | 2012-04-01 16:41:46 -0300 | [diff] [blame] | 608 | if (wheel_keycode != KEY_RESERVED) { |
| 609 | /* |
| 610 | * This is a scrollwheel event, send the |
| 611 | * scroll up (0x78) / down (0x70) scancode |
| 612 | * repeatedly as many times as indicated by |
| 613 | * rest of the scancode. |
| 614 | */ |
| 615 | count = (scancode & 0x07) + 1; |
| 616 | scancode &= 0x78; |
| 617 | } |
| 618 | |
| 619 | while (count--) { |
| 620 | /* |
| 621 | * We don't use the rc-core repeat handling yet as |
| 622 | * it would cause ghost repeats which would be a |
| 623 | * regression for this driver. |
| 624 | */ |
Sean Young | 6d741bf | 2017-08-07 16:20:58 -0400 | [diff] [blame] | 625 | rc_keydown_notimeout(ati_remote->rdev, |
| 626 | RC_PROTO_OTHER, |
David Härdeman | 120703f | 2014-04-03 20:31:30 -0300 | [diff] [blame] | 627 | scancode, data[2]); |
Anssi Hannula | 9d454d4 | 2012-04-01 16:41:46 -0300 | [diff] [blame] | 628 | rc_keyup(ati_remote->rdev); |
| 629 | } |
George Spelvin | 89b0c0d | 2014-05-11 08:15:44 -0300 | [diff] [blame] | 630 | goto nosync; |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 631 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 632 | |
George Spelvin | 8ecd5e3 | 2014-05-11 08:14:18 -0300 | [diff] [blame] | 633 | } else if (ati_remote_tbl[index].kind == KIND_ACCEL) { |
| 634 | signed char dx = ati_remote_tbl[index].code >> 8; |
| 635 | signed char dy = ati_remote_tbl[index].code & 255; |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 636 | |
Dmitry Torokhov | 2ffc1cc | 2006-08-04 22:53:37 -0400 | [diff] [blame] | 637 | /* |
Du, Changbin | a342daea | 2012-07-07 03:53:28 -0300 | [diff] [blame] | 638 | * Other event kinds are from the directional control pad, and |
| 639 | * have an acceleration factor applied to them. Without this |
| 640 | * acceleration, the control pad is mostly unusable. |
Dmitry Torokhov | 2ffc1cc | 2006-08-04 22:53:37 -0400 | [diff] [blame] | 641 | */ |
George Spelvin | 8ecd5e3 | 2014-05-11 08:14:18 -0300 | [diff] [blame] | 642 | int acc = ati_remote_compute_accel(ati_remote); |
| 643 | if (dx) |
| 644 | input_report_rel(dev, REL_X, dx * acc); |
| 645 | if (dy) |
| 646 | input_report_rel(dev, REL_Y, dy * acc); |
Dmitry Torokhov | 2ffc1cc | 2006-08-04 22:53:37 -0400 | [diff] [blame] | 647 | ati_remote->old_jiffies = jiffies; |
George Spelvin | 89b0c0d | 2014-05-11 08:15:44 -0300 | [diff] [blame] | 648 | |
George Spelvin | 8ecd5e3 | 2014-05-11 08:14:18 -0300 | [diff] [blame] | 649 | } else { |
| 650 | dev_dbg(&ati_remote->interface->dev, "ati_remote kind=%d\n", |
| 651 | ati_remote_tbl[index].kind); |
George Spelvin | 89b0c0d | 2014-05-11 08:15:44 -0300 | [diff] [blame] | 652 | return; |
Dmitry Torokhov | 2ffc1cc | 2006-08-04 22:53:37 -0400 | [diff] [blame] | 653 | } |
George Spelvin | 89b0c0d | 2014-05-11 08:15:44 -0300 | [diff] [blame] | 654 | input_sync(dev); |
| 655 | nosync: |
| 656 | ati_remote->old_data = data[2]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 657 | } |
| 658 | |
| 659 | /* |
Du, Changbin | a342daea | 2012-07-07 03:53:28 -0300 | [diff] [blame] | 660 | * ati_remote_irq_in |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 661 | */ |
David Howells | 7d12e78 | 2006-10-05 14:55:46 +0100 | [diff] [blame] | 662 | static void ati_remote_irq_in(struct urb *urb) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 663 | { |
| 664 | struct ati_remote *ati_remote = urb->context; |
| 665 | int retval; |
| 666 | |
| 667 | switch (urb->status) { |
| 668 | case 0: /* success */ |
David Howells | 7d12e78 | 2006-10-05 14:55:46 +0100 | [diff] [blame] | 669 | ati_remote_input_report(urb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 670 | break; |
| 671 | case -ECONNRESET: /* unlink */ |
| 672 | case -ENOENT: |
| 673 | case -ESHUTDOWN: |
Du, Changbin | a342daea | 2012-07-07 03:53:28 -0300 | [diff] [blame] | 674 | dev_dbg(&ati_remote->interface->dev, |
| 675 | "%s: urb error status, unlink?\n", |
Harvey Harrison | ea3e6c5 | 2008-05-05 11:36:18 -0400 | [diff] [blame] | 676 | __func__); |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 677 | return; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 678 | default: /* error */ |
Du, Changbin | a342daea | 2012-07-07 03:53:28 -0300 | [diff] [blame] | 679 | dev_dbg(&ati_remote->interface->dev, |
| 680 | "%s: Nonzero urb status %d\n", |
Harvey Harrison | ea3e6c5 | 2008-05-05 11:36:18 -0400 | [diff] [blame] | 681 | __func__, urb->status); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 682 | } |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 683 | |
Christoph Lameter | 54e6ecb | 2006-12-06 20:33:16 -0800 | [diff] [blame] | 684 | retval = usb_submit_urb(urb, GFP_ATOMIC); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 685 | if (retval) |
Du, Changbin | a342daea | 2012-07-07 03:53:28 -0300 | [diff] [blame] | 686 | dev_err(&ati_remote->interface->dev, |
| 687 | "%s: usb_submit_urb()=%d\n", |
Harvey Harrison | ea3e6c5 | 2008-05-05 11:36:18 -0400 | [diff] [blame] | 688 | __func__, retval); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 689 | } |
| 690 | |
| 691 | /* |
Du, Changbin | a342daea | 2012-07-07 03:53:28 -0300 | [diff] [blame] | 692 | * ati_remote_alloc_buffers |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 693 | */ |
Dmitry Torokhov | c5b7c7c | 2005-09-15 02:01:47 -0500 | [diff] [blame] | 694 | static int ati_remote_alloc_buffers(struct usb_device *udev, |
| 695 | struct ati_remote *ati_remote) |
| 696 | { |
Daniel Mack | 997ea58 | 2010-04-12 13:17:25 +0200 | [diff] [blame] | 697 | ati_remote->inbuf = usb_alloc_coherent(udev, DATA_BUFSIZE, GFP_ATOMIC, |
| 698 | &ati_remote->inbuf_dma); |
Dmitry Torokhov | c5b7c7c | 2005-09-15 02:01:47 -0500 | [diff] [blame] | 699 | if (!ati_remote->inbuf) |
| 700 | return -1; |
| 701 | |
Daniel Mack | 997ea58 | 2010-04-12 13:17:25 +0200 | [diff] [blame] | 702 | ati_remote->outbuf = usb_alloc_coherent(udev, DATA_BUFSIZE, GFP_ATOMIC, |
Anssi Hannula | 9688efd | 2011-08-06 18:18:07 -0300 | [diff] [blame] | 703 | &ati_remote->outbuf_dma); |
Dmitry Torokhov | c5b7c7c | 2005-09-15 02:01:47 -0500 | [diff] [blame] | 704 | if (!ati_remote->outbuf) |
| 705 | return -1; |
| 706 | |
| 707 | ati_remote->irq_urb = usb_alloc_urb(0, GFP_KERNEL); |
| 708 | if (!ati_remote->irq_urb) |
| 709 | return -1; |
| 710 | |
| 711 | ati_remote->out_urb = usb_alloc_urb(0, GFP_KERNEL); |
| 712 | if (!ati_remote->out_urb) |
| 713 | return -1; |
| 714 | |
| 715 | return 0; |
| 716 | } |
| 717 | |
| 718 | /* |
Du, Changbin | a342daea | 2012-07-07 03:53:28 -0300 | [diff] [blame] | 719 | * ati_remote_free_buffers |
Dmitry Torokhov | c5b7c7c | 2005-09-15 02:01:47 -0500 | [diff] [blame] | 720 | */ |
| 721 | static void ati_remote_free_buffers(struct ati_remote *ati_remote) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 722 | { |
Mariusz Kozlowski | 459f836 | 2006-11-08 15:35:46 +0100 | [diff] [blame] | 723 | usb_free_urb(ati_remote->irq_urb); |
| 724 | usb_free_urb(ati_remote->out_urb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 725 | |
Daniel Mack | 997ea58 | 2010-04-12 13:17:25 +0200 | [diff] [blame] | 726 | usb_free_coherent(ati_remote->udev, DATA_BUFSIZE, |
Mariusz Kozlowski | 9dce447 | 2006-11-25 11:09:38 -0800 | [diff] [blame] | 727 | ati_remote->inbuf, ati_remote->inbuf_dma); |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 728 | |
Daniel Mack | 997ea58 | 2010-04-12 13:17:25 +0200 | [diff] [blame] | 729 | usb_free_coherent(ati_remote->udev, DATA_BUFSIZE, |
Mariusz Kozlowski | 9dce447 | 2006-11-25 11:09:38 -0800 | [diff] [blame] | 730 | ati_remote->outbuf, ati_remote->outbuf_dma); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 731 | } |
| 732 | |
| 733 | static void ati_remote_input_init(struct ati_remote *ati_remote) |
| 734 | { |
Dmitry Torokhov | c5b7c7c | 2005-09-15 02:01:47 -0500 | [diff] [blame] | 735 | struct input_dev *idev = ati_remote->idev; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 736 | int i; |
| 737 | |
Jiri Slaby | 7b19ada | 2007-10-18 23:40:32 -0700 | [diff] [blame] | 738 | idev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL); |
| 739 | idev->keybit[BIT_WORD(BTN_MOUSE)] = BIT_MASK(BTN_LEFT) | |
| 740 | BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_SIDE) | BIT_MASK(BTN_EXTRA); |
| 741 | idev->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 742 | for (i = 0; ati_remote_tbl[i].kind != KIND_END; i++) |
George Spelvin | 3f245b9 | 2014-05-11 08:14:54 -0300 | [diff] [blame] | 743 | if (ati_remote_tbl[i].kind == KIND_LITERAL || |
| 744 | ati_remote_tbl[i].kind == KIND_FILTERED) |
George Spelvin | 1e18270 | 2014-05-11 08:16:15 -0300 | [diff] [blame] | 745 | __set_bit(ati_remote_tbl[i].code, idev->keybit); |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 746 | |
Dmitry Torokhov | 7791bda | 2007-04-12 01:34:39 -0400 | [diff] [blame] | 747 | input_set_drvdata(idev, ati_remote); |
| 748 | |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 749 | idev->open = ati_remote_input_open; |
| 750 | idev->close = ati_remote_input_close; |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 751 | |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 752 | idev->name = ati_remote->mouse_name; |
| 753 | idev->phys = ati_remote->mouse_phys; |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 754 | |
Dmitry Torokhov | 16a334c | 2005-06-30 00:49:08 -0500 | [diff] [blame] | 755 | usb_to_input_id(ati_remote->udev, &idev->id); |
Anssi Hannula | 44fd0b6 | 2011-08-06 18:18:09 -0300 | [diff] [blame] | 756 | idev->dev.parent = &ati_remote->interface->dev; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 757 | } |
| 758 | |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 759 | static void ati_remote_rc_init(struct ati_remote *ati_remote) |
| 760 | { |
| 761 | struct rc_dev *rdev = ati_remote->rdev; |
| 762 | |
| 763 | rdev->priv = ati_remote; |
Sean Young | 6d741bf | 2017-08-07 16:20:58 -0400 | [diff] [blame] | 764 | rdev->allowed_protocols = RC_PROTO_BIT_OTHER; |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 765 | rdev->driver_name = "ati_remote"; |
| 766 | |
| 767 | rdev->open = ati_remote_rc_open; |
| 768 | rdev->close = ati_remote_rc_close; |
| 769 | |
Sean Young | 518f4b2 | 2017-07-01 12:13:19 -0400 | [diff] [blame] | 770 | rdev->device_name = ati_remote->rc_name; |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 771 | rdev->input_phys = ati_remote->rc_phys; |
| 772 | |
| 773 | usb_to_input_id(ati_remote->udev, &rdev->input_id); |
Anssi Hannula | 44fd0b6 | 2011-08-06 18:18:09 -0300 | [diff] [blame] | 774 | rdev->dev.parent = &ati_remote->interface->dev; |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 775 | } |
| 776 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 777 | static int ati_remote_initialize(struct ati_remote *ati_remote) |
| 778 | { |
| 779 | struct usb_device *udev = ati_remote->udev; |
| 780 | int pipe, maxp; |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 781 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 782 | init_waitqueue_head(&ati_remote->wait); |
| 783 | |
| 784 | /* Set up irq_urb */ |
| 785 | pipe = usb_rcvintpipe(udev, ati_remote->endpoint_in->bEndpointAddress); |
| 786 | maxp = usb_maxpacket(udev, pipe, usb_pipeout(pipe)); |
| 787 | maxp = (maxp > DATA_BUFSIZE) ? DATA_BUFSIZE : maxp; |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 788 | |
| 789 | usb_fill_int_urb(ati_remote->irq_urb, udev, pipe, ati_remote->inbuf, |
| 790 | maxp, ati_remote_irq_in, ati_remote, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 791 | ati_remote->endpoint_in->bInterval); |
| 792 | ati_remote->irq_urb->transfer_dma = ati_remote->inbuf_dma; |
| 793 | ati_remote->irq_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 794 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 795 | /* Set up out_urb */ |
| 796 | pipe = usb_sndintpipe(udev, ati_remote->endpoint_out->bEndpointAddress); |
| 797 | maxp = usb_maxpacket(udev, pipe, usb_pipeout(pipe)); |
| 798 | maxp = (maxp > DATA_BUFSIZE) ? DATA_BUFSIZE : maxp; |
| 799 | |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 800 | usb_fill_int_urb(ati_remote->out_urb, udev, pipe, ati_remote->outbuf, |
| 801 | maxp, ati_remote_irq_out, ati_remote, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 802 | ati_remote->endpoint_out->bInterval); |
| 803 | ati_remote->out_urb->transfer_dma = ati_remote->outbuf_dma; |
| 804 | ati_remote->out_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; |
| 805 | |
| 806 | /* send initialization strings */ |
| 807 | if ((ati_remote_sendpacket(ati_remote, 0x8004, init1)) || |
| 808 | (ati_remote_sendpacket(ati_remote, 0x8007, init2))) { |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 809 | dev_err(&ati_remote->interface->dev, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 810 | "Initializing ati_remote hardware failed.\n"); |
Dmitry Torokhov | c5b7c7c | 2005-09-15 02:01:47 -0500 | [diff] [blame] | 811 | return -EIO; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 812 | } |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 813 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 814 | return 0; |
| 815 | } |
| 816 | |
| 817 | /* |
Du, Changbin | a342daea | 2012-07-07 03:53:28 -0300 | [diff] [blame] | 818 | * ati_remote_probe |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 819 | */ |
Du, Changbin | a342daea | 2012-07-07 03:53:28 -0300 | [diff] [blame] | 820 | static int ati_remote_probe(struct usb_interface *interface, |
| 821 | const struct usb_device_id *id) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 822 | { |
| 823 | struct usb_device *udev = interface_to_usbdev(interface); |
Dmitry Torokhov | c5b7c7c | 2005-09-15 02:01:47 -0500 | [diff] [blame] | 824 | struct usb_host_interface *iface_host = interface->cur_altsetting; |
| 825 | struct usb_endpoint_descriptor *endpoint_in, *endpoint_out; |
Anssi Hannula | 0d74679 | 2012-04-01 16:41:45 -0300 | [diff] [blame] | 826 | struct ati_receiver_type *type = (struct ati_receiver_type *)id->driver_info; |
Dmitry Torokhov | c5b7c7c | 2005-09-15 02:01:47 -0500 | [diff] [blame] | 827 | struct ati_remote *ati_remote; |
| 828 | struct input_dev *input_dev; |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 829 | struct rc_dev *rc_dev; |
Dmitry Torokhov | c5b7c7c | 2005-09-15 02:01:47 -0500 | [diff] [blame] | 830 | int err = -ENOMEM; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 831 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 832 | if (iface_host->desc.bNumEndpoints != 2) { |
Harvey Harrison | ea3e6c5 | 2008-05-05 11:36:18 -0400 | [diff] [blame] | 833 | err("%s: Unexpected desc.bNumEndpoints\n", __func__); |
Dmitry Torokhov | c5b7c7c | 2005-09-15 02:01:47 -0500 | [diff] [blame] | 834 | return -ENODEV; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 835 | } |
| 836 | |
Dmitry Torokhov | c5b7c7c | 2005-09-15 02:01:47 -0500 | [diff] [blame] | 837 | endpoint_in = &iface_host->endpoint[0].desc; |
| 838 | endpoint_out = &iface_host->endpoint[1].desc; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 839 | |
Luiz Fernando N. Capitulino | 96642a2 | 2006-09-27 11:58:53 -0700 | [diff] [blame] | 840 | if (!usb_endpoint_is_int_in(endpoint_in)) { |
Harvey Harrison | ea3e6c5 | 2008-05-05 11:36:18 -0400 | [diff] [blame] | 841 | err("%s: Unexpected endpoint_in\n", __func__); |
Dmitry Torokhov | c5b7c7c | 2005-09-15 02:01:47 -0500 | [diff] [blame] | 842 | return -ENODEV; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 843 | } |
Dmitry Torokhov | c5b7c7c | 2005-09-15 02:01:47 -0500 | [diff] [blame] | 844 | if (le16_to_cpu(endpoint_in->wMaxPacketSize) == 0) { |
Harvey Harrison | ea3e6c5 | 2008-05-05 11:36:18 -0400 | [diff] [blame] | 845 | err("%s: endpoint_in message size==0? \n", __func__); |
Dmitry Torokhov | c5b7c7c | 2005-09-15 02:01:47 -0500 | [diff] [blame] | 846 | return -ENODEV; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 847 | } |
| 848 | |
Dmitry Torokhov | c5b7c7c | 2005-09-15 02:01:47 -0500 | [diff] [blame] | 849 | ati_remote = kzalloc(sizeof (struct ati_remote), GFP_KERNEL); |
Andi Shyti | 0f7499f | 2016-12-16 06:50:58 -0200 | [diff] [blame] | 850 | rc_dev = rc_allocate_device(RC_DRIVER_SCANCODE); |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 851 | if (!ati_remote || !rc_dev) |
Matthijs Kooijman | 70ef699 | 2012-11-02 09:13:54 -0300 | [diff] [blame] | 852 | goto exit_free_dev_rdev; |
Dmitry Torokhov | c5b7c7c | 2005-09-15 02:01:47 -0500 | [diff] [blame] | 853 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 854 | /* Allocate URB buffers, URBs */ |
Dmitry Torokhov | c5b7c7c | 2005-09-15 02:01:47 -0500 | [diff] [blame] | 855 | if (ati_remote_alloc_buffers(udev, ati_remote)) |
Matthijs Kooijman | 70ef699 | 2012-11-02 09:13:54 -0300 | [diff] [blame] | 856 | goto exit_free_buffers; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 857 | |
Dmitry Torokhov | c5b7c7c | 2005-09-15 02:01:47 -0500 | [diff] [blame] | 858 | ati_remote->endpoint_in = endpoint_in; |
| 859 | ati_remote->endpoint_out = endpoint_out; |
| 860 | ati_remote->udev = udev; |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 861 | ati_remote->rdev = rc_dev; |
Dmitry Torokhov | c5b7c7c | 2005-09-15 02:01:47 -0500 | [diff] [blame] | 862 | ati_remote->interface = interface; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 863 | |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 864 | usb_make_path(udev, ati_remote->rc_phys, sizeof(ati_remote->rc_phys)); |
Mauro Carvalho Chehab | c0decac | 2018-09-10 08:19:14 -0400 | [diff] [blame] | 865 | strscpy(ati_remote->mouse_phys, ati_remote->rc_phys, |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 866 | sizeof(ati_remote->mouse_phys)); |
| 867 | |
| 868 | strlcat(ati_remote->rc_phys, "/input0", sizeof(ati_remote->rc_phys)); |
| 869 | strlcat(ati_remote->mouse_phys, "/input1", sizeof(ati_remote->mouse_phys)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 870 | |
Rasmus Villemoes | 869f076 | 2016-03-08 17:40:53 -0300 | [diff] [blame] | 871 | snprintf(ati_remote->rc_name, sizeof(ati_remote->rc_name), "%s%s%s", |
| 872 | udev->manufacturer ?: "", |
| 873 | udev->manufacturer && udev->product ? " " : "", |
| 874 | udev->product ?: ""); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 875 | |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 876 | if (!strlen(ati_remote->rc_name)) |
| 877 | snprintf(ati_remote->rc_name, sizeof(ati_remote->rc_name), |
Dmitry Torokhov | c5b7c7c | 2005-09-15 02:01:47 -0500 | [diff] [blame] | 878 | DRIVER_DESC "(%04x,%04x)", |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 879 | le16_to_cpu(ati_remote->udev->descriptor.idVendor), |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 880 | le16_to_cpu(ati_remote->udev->descriptor.idProduct)); |
| 881 | |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 882 | snprintf(ati_remote->mouse_name, sizeof(ati_remote->mouse_name), |
| 883 | "%s mouse", ati_remote->rc_name); |
| 884 | |
Anssi Hannula | 0d74679 | 2012-04-01 16:41:45 -0300 | [diff] [blame] | 885 | rc_dev->map_name = RC_MAP_ATI_X10; /* default map */ |
| 886 | |
| 887 | /* set default keymap according to receiver model */ |
| 888 | if (type) { |
| 889 | if (type->default_keymap) |
| 890 | rc_dev->map_name = type->default_keymap; |
| 891 | else if (type->get_default_keymap) |
| 892 | rc_dev->map_name = type->get_default_keymap(interface); |
| 893 | } |
Anssi Hannula | 175fcec | 2011-08-06 18:18:11 -0300 | [diff] [blame] | 894 | |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 895 | ati_remote_rc_init(ati_remote); |
| 896 | mutex_init(&ati_remote->open_mutex); |
Dmitry Torokhov | c5b7c7c | 2005-09-15 02:01:47 -0500 | [diff] [blame] | 897 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 898 | /* Device Hardware Initialization - fills in ati_remote->idev from udev. */ |
Dmitry Torokhov | c5b7c7c | 2005-09-15 02:01:47 -0500 | [diff] [blame] | 899 | err = ati_remote_initialize(ati_remote); |
| 900 | if (err) |
Matthijs Kooijman | 70ef699 | 2012-11-02 09:13:54 -0300 | [diff] [blame] | 901 | goto exit_kill_urbs; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 902 | |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 903 | /* Set up and register rc device */ |
| 904 | err = rc_register_device(ati_remote->rdev); |
Dmitry Torokhov | 5014186 | 2007-04-12 01:33:39 -0400 | [diff] [blame] | 905 | if (err) |
Matthijs Kooijman | 70ef699 | 2012-11-02 09:13:54 -0300 | [diff] [blame] | 906 | goto exit_kill_urbs; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 907 | |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 908 | /* Set up and register mouse input device */ |
| 909 | if (mouse) { |
| 910 | input_dev = input_allocate_device(); |
Peter Senna Tschudin | a84b17e | 2012-09-04 08:05:04 -0300 | [diff] [blame] | 911 | if (!input_dev) { |
| 912 | err = -ENOMEM; |
Matthijs Kooijman | 70ef699 | 2012-11-02 09:13:54 -0300 | [diff] [blame] | 913 | goto exit_unregister_device; |
Peter Senna Tschudin | a84b17e | 2012-09-04 08:05:04 -0300 | [diff] [blame] | 914 | } |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 915 | |
| 916 | ati_remote->idev = input_dev; |
| 917 | ati_remote_input_init(ati_remote); |
| 918 | err = input_register_device(input_dev); |
| 919 | |
| 920 | if (err) |
Matthijs Kooijman | 70ef699 | 2012-11-02 09:13:54 -0300 | [diff] [blame] | 921 | goto exit_free_input_device; |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 922 | } |
| 923 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 924 | usb_set_intfdata(interface, ati_remote); |
Dmitry Torokhov | c5b7c7c | 2005-09-15 02:01:47 -0500 | [diff] [blame] | 925 | return 0; |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 926 | |
Matthijs Kooijman | 70ef699 | 2012-11-02 09:13:54 -0300 | [diff] [blame] | 927 | exit_free_input_device: |
| 928 | input_free_device(input_dev); |
| 929 | exit_unregister_device: |
| 930 | rc_unregister_device(rc_dev); |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 931 | rc_dev = NULL; |
Matthijs Kooijman | 70ef699 | 2012-11-02 09:13:54 -0300 | [diff] [blame] | 932 | exit_kill_urbs: |
| 933 | usb_kill_urb(ati_remote->irq_urb); |
Dmitry Torokhov | c5b7c7c | 2005-09-15 02:01:47 -0500 | [diff] [blame] | 934 | usb_kill_urb(ati_remote->out_urb); |
Matthijs Kooijman | 70ef699 | 2012-11-02 09:13:54 -0300 | [diff] [blame] | 935 | exit_free_buffers: |
| 936 | ati_remote_free_buffers(ati_remote); |
| 937 | exit_free_dev_rdev: |
| 938 | rc_free_device(rc_dev); |
Dmitry Torokhov | c5b7c7c | 2005-09-15 02:01:47 -0500 | [diff] [blame] | 939 | kfree(ati_remote); |
| 940 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 941 | } |
| 942 | |
| 943 | /* |
Du, Changbin | a342daea | 2012-07-07 03:53:28 -0300 | [diff] [blame] | 944 | * ati_remote_disconnect |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 945 | */ |
| 946 | static void ati_remote_disconnect(struct usb_interface *interface) |
| 947 | { |
| 948 | struct ati_remote *ati_remote; |
| 949 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 950 | ati_remote = usb_get_intfdata(interface); |
| 951 | usb_set_intfdata(interface, NULL); |
| 952 | if (!ati_remote) { |
Greg Kroah-Hartman | 1817b16 | 2008-08-14 09:37:34 -0700 | [diff] [blame] | 953 | dev_warn(&interface->dev, "%s - null device?\n", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 954 | return; |
| 955 | } |
Dmitry Torokhov | 05f091ab | 2005-05-29 02:29:01 -0500 | [diff] [blame] | 956 | |
Dmitry Torokhov | c5b7c7c | 2005-09-15 02:01:47 -0500 | [diff] [blame] | 957 | usb_kill_urb(ati_remote->irq_urb); |
| 958 | usb_kill_urb(ati_remote->out_urb); |
Anssi Hannula | c34516e | 2011-08-06 18:18:08 -0300 | [diff] [blame] | 959 | if (ati_remote->idev) |
| 960 | input_unregister_device(ati_remote->idev); |
| 961 | rc_unregister_device(ati_remote->rdev); |
Dmitry Torokhov | c5b7c7c | 2005-09-15 02:01:47 -0500 | [diff] [blame] | 962 | ati_remote_free_buffers(ati_remote); |
| 963 | kfree(ati_remote); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 964 | } |
| 965 | |
Du, Changbin | a342daea | 2012-07-07 03:53:28 -0300 | [diff] [blame] | 966 | /* usb specific object to register with the usb subsystem */ |
| 967 | static struct usb_driver ati_remote_driver = { |
| 968 | .name = "ati_remote", |
| 969 | .probe = ati_remote_probe, |
| 970 | .disconnect = ati_remote_disconnect, |
| 971 | .id_table = ati_remote_table, |
| 972 | }; |
| 973 | |
Greg Kroah-Hartman | ecb3b2b | 2011-11-18 09:46:12 -0800 | [diff] [blame] | 974 | module_usb_driver(ati_remote_driver); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 975 | |
| 976 | MODULE_AUTHOR(DRIVER_AUTHOR); |
| 977 | MODULE_DESCRIPTION(DRIVER_DESC); |
| 978 | MODULE_LICENSE("GPL"); |