Eric Lee / linux-smarc-t335x-v3.2

Download as
Browse Code ยป

Commit aeb35ebc5f54bcdd7163f5282a3f39bc48c75cae

Authored by Julia Lawall
Committed by Mauro Carvalho Chehab
1 parent da4b7b2011
Exists in master and in 4 other branches v3.2_AM335xPSP_04.06.00.11, v3.2_NEWT335xPSP_04.06.00.11, v3.2_SBC_SMARTMEN, v3.2_SMARCT335xPSP_04.06.00.11

[media] imon: Correct call to input_free_device 

ictx->touch is intialied in imon_init_intf1, to the result of calling the
function that contains this code.  Thus, in this code, input_free_device
should be called on touch itself.

A simplified version of the semantic match that finds this problem is:
(http://coccinelle.lip6.fr/)

// <smpl>
@r exists@
local idexpression struct input_dev * x;
expression ra,rr;
position p1,p2;
@@

x = input_allocate_device@p1(...)
...  when != x = rr
    when != input_free_device(x,...)
    when != if (...) { ... input_free_device(x,...) ...}
if(...) { ... when != x = ra
    when forall
    when != input_free_device(x,...)
\(return <+...x...+>; \| return@p2...; \) }

@script:python@
p1 << r.p1;
p2 << r.p2;
@@

cocci.print_main("input_allocate_device",p1)
cocci.print_secs("input_free_device",p2)
// </smpl>

Signed-off-by: Julia Lawall <julia@diku.dk>
Signed-off-by: Jarod Wilson <jarod@redhat.com>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>

Showing 1 changed file with 1 additions and 1 deletions Inline Diff

drivers/media/rc/imon.c
Diff comments   View file @ aeb35eb
1 /* 1 /*
2 * imon.c: input and display driver for SoundGraph iMON IR/VFD/LCD 2 * imon.c: input and display driver for SoundGraph iMON IR/VFD/LCD
3 * 3 *
4 * Copyright(C) 2010 Jarod Wilson <jarod@wilsonet.com> 4 * Copyright(C) 2010 Jarod Wilson <jarod@wilsonet.com>
5 * Portions based on the original lirc_imon driver, 5 * Portions based on the original lirc_imon driver,
6 * Copyright(C) 2004 Venky Raju(dev@venky.ws) 6 * Copyright(C) 2004 Venky Raju(dev@venky.ws)
7 * 7 *
8 * Huge thanks to R. Geoff Newbury for invaluable debugging on the 8 * Huge thanks to R. Geoff Newbury for invaluable debugging on the
9 * 0xffdc iMON devices, and for sending me one to hack on, without 9 * 0xffdc iMON devices, and for sending me one to hack on, without
10 * which the support for them wouldn't be nearly as good. Thanks 10 * which the support for them wouldn't be nearly as good. Thanks
11 * also to the numerous 0xffdc device owners that tested auto-config 11 * also to the numerous 0xffdc device owners that tested auto-config
12 * support for me and provided debug dumps from their devices. 12 * support for me and provided debug dumps from their devices.
13 * 13 *
14 * imon is free software; you can redistribute it and/or modify 14 * imon is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by 15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; either version 2 of the License, or 16 * the Free Software Foundation; either version 2 of the License, or
17 * (at your option) any later version. 17 * (at your option) any later version.
18 * 18 *
19 * This program is distributed in the hope that it will be useful, 19 * This program is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of 20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details. 22 * GNU General Public License for more details.
23 * 23 *
24 * You should have received a copy of the GNU General Public License 24 * You should have received a copy of the GNU General Public License
25 * along with this program; if not, write to the Free Software 25 * along with this program; if not, write to the Free Software
26 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 26 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 */ 27 */
28 28
29 #define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__ 29 #define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__
30 30
31 #include <linux/errno.h> 31 #include <linux/errno.h>
32 #include <linux/init.h> 32 #include <linux/init.h>
33 #include <linux/kernel.h> 33 #include <linux/kernel.h>
34 #include <linux/module.h> 34 #include <linux/module.h>
35 #include <linux/slab.h> 35 #include <linux/slab.h>
36 #include <linux/uaccess.h> 36 #include <linux/uaccess.h>
37 37
38 #include <linux/input.h> 38 #include <linux/input.h>
39 #include <linux/usb.h> 39 #include <linux/usb.h>
40 #include <linux/usb/input.h> 40 #include <linux/usb/input.h>
41 #include <media/rc-core.h> 41 #include <media/rc-core.h>
42 42
43 #include <linux/time.h> 43 #include <linux/time.h>
44 #include <linux/timer.h> 44 #include <linux/timer.h>
45 45
46 #define MOD_AUTHOR "Jarod Wilson <jarod@wilsonet.com>" 46 #define MOD_AUTHOR "Jarod Wilson <jarod@wilsonet.com>"
47 #define MOD_DESC "Driver for SoundGraph iMON MultiMedia IR/Display" 47 #define MOD_DESC "Driver for SoundGraph iMON MultiMedia IR/Display"
48 #define MOD_NAME "imon" 48 #define MOD_NAME "imon"
49 #define MOD_VERSION "0.9.3" 49 #define MOD_VERSION "0.9.3"
50 50
51 #define DISPLAY_MINOR_BASE 144 51 #define DISPLAY_MINOR_BASE 144
52 #define DEVICE_NAME "lcd%d" 52 #define DEVICE_NAME "lcd%d"
53 53
54 #define BUF_CHUNK_SIZE 8 54 #define BUF_CHUNK_SIZE 8
55 #define BUF_SIZE 128 55 #define BUF_SIZE 128
56 56
57 #define BIT_DURATION 250 /* each bit received is 250us */ 57 #define BIT_DURATION 250 /* each bit received is 250us */
58 58
59 #define IMON_CLOCK_ENABLE_PACKETS 2 59 #define IMON_CLOCK_ENABLE_PACKETS 2
60 60
61 /*** P R O T O T Y P E S ***/ 61 /*** P R O T O T Y P E S ***/
62 62
63 /* USB Callback prototypes */ 63 /* USB Callback prototypes */
64 static int imon_probe(struct usb_interface *interface, 64 static int imon_probe(struct usb_interface *interface,
65 const struct usb_device_id *id); 65 const struct usb_device_id *id);
66 static void imon_disconnect(struct usb_interface *interface); 66 static void imon_disconnect(struct usb_interface *interface);
67 static void usb_rx_callback_intf0(struct urb *urb); 67 static void usb_rx_callback_intf0(struct urb *urb);
68 static void usb_rx_callback_intf1(struct urb *urb); 68 static void usb_rx_callback_intf1(struct urb *urb);
69 static void usb_tx_callback(struct urb *urb); 69 static void usb_tx_callback(struct urb *urb);
70 70
71 /* suspend/resume support */ 71 /* suspend/resume support */
72 static int imon_resume(struct usb_interface *intf); 72 static int imon_resume(struct usb_interface *intf);
73 static int imon_suspend(struct usb_interface *intf, pm_message_t message); 73 static int imon_suspend(struct usb_interface *intf, pm_message_t message);
74 74
75 /* Display file_operations function prototypes */ 75 /* Display file_operations function prototypes */
76 static int display_open(struct inode *inode, struct file *file); 76 static int display_open(struct inode *inode, struct file *file);
77 static int display_close(struct inode *inode, struct file *file); 77 static int display_close(struct inode *inode, struct file *file);
78 78
79 /* VFD write operation */ 79 /* VFD write operation */
80 static ssize_t vfd_write(struct file *file, const char *buf, 80 static ssize_t vfd_write(struct file *file, const char *buf,
81 size_t n_bytes, loff_t *pos); 81 size_t n_bytes, loff_t *pos);
82 82
83 /* LCD file_operations override function prototypes */ 83 /* LCD file_operations override function prototypes */
84 static ssize_t lcd_write(struct file *file, const char *buf, 84 static ssize_t lcd_write(struct file *file, const char *buf,
85 size_t n_bytes, loff_t *pos); 85 size_t n_bytes, loff_t *pos);
86 86
87 /*** G L O B A L S ***/ 87 /*** G L O B A L S ***/
88 88
89 struct imon_context { 89 struct imon_context {
90 struct device *dev; 90 struct device *dev;
91 /* Newer devices have two interfaces */ 91 /* Newer devices have two interfaces */
92 struct usb_device *usbdev_intf0; 92 struct usb_device *usbdev_intf0;
93 struct usb_device *usbdev_intf1; 93 struct usb_device *usbdev_intf1;
94 94
95 bool display_supported; /* not all controllers do */ 95 bool display_supported; /* not all controllers do */
96 bool display_isopen; /* display port has been opened */ 96 bool display_isopen; /* display port has been opened */
97 bool rf_device; /* true if iMON 2.4G LT/DT RF device */ 97 bool rf_device; /* true if iMON 2.4G LT/DT RF device */
98 bool rf_isassociating; /* RF remote associating */ 98 bool rf_isassociating; /* RF remote associating */
99 bool dev_present_intf0; /* USB device presence, interface 0 */ 99 bool dev_present_intf0; /* USB device presence, interface 0 */
100 bool dev_present_intf1; /* USB device presence, interface 1 */ 100 bool dev_present_intf1; /* USB device presence, interface 1 */
101 101
102 struct mutex lock; /* to lock this object */ 102 struct mutex lock; /* to lock this object */
103 wait_queue_head_t remove_ok; /* For unexpected USB disconnects */ 103 wait_queue_head_t remove_ok; /* For unexpected USB disconnects */
104 104
105 struct usb_endpoint_descriptor *rx_endpoint_intf0; 105 struct usb_endpoint_descriptor *rx_endpoint_intf0;
106 struct usb_endpoint_descriptor *rx_endpoint_intf1; 106 struct usb_endpoint_descriptor *rx_endpoint_intf1;
107 struct usb_endpoint_descriptor *tx_endpoint; 107 struct usb_endpoint_descriptor *tx_endpoint;
108 struct urb *rx_urb_intf0; 108 struct urb *rx_urb_intf0;
109 struct urb *rx_urb_intf1; 109 struct urb *rx_urb_intf1;
110 struct urb *tx_urb; 110 struct urb *tx_urb;
111 bool tx_control; 111 bool tx_control;
112 unsigned char usb_rx_buf[8]; 112 unsigned char usb_rx_buf[8];
113 unsigned char usb_tx_buf[8]; 113 unsigned char usb_tx_buf[8];
114 114
115 struct tx_t { 115 struct tx_t {
116 unsigned char data_buf[35]; /* user data buffer */ 116 unsigned char data_buf[35]; /* user data buffer */
117 struct completion finished; /* wait for write to finish */ 117 struct completion finished; /* wait for write to finish */
118 bool busy; /* write in progress */ 118 bool busy; /* write in progress */
119 int status; /* status of tx completion */ 119 int status; /* status of tx completion */
120 } tx; 120 } tx;
121 121
122 u16 vendor; /* usb vendor ID */ 122 u16 vendor; /* usb vendor ID */
123 u16 product; /* usb product ID */ 123 u16 product; /* usb product ID */
124 124
125 struct rc_dev *rdev; /* rc-core device for remote */ 125 struct rc_dev *rdev; /* rc-core device for remote */
126 struct input_dev *idev; /* input device for panel & IR mouse */ 126 struct input_dev *idev; /* input device for panel & IR mouse */
127 struct input_dev *touch; /* input device for touchscreen */ 127 struct input_dev *touch; /* input device for touchscreen */
128 128
129 spinlock_t kc_lock; /* make sure we get keycodes right */ 129 spinlock_t kc_lock; /* make sure we get keycodes right */
130 u32 kc; /* current input keycode */ 130 u32 kc; /* current input keycode */
131 u32 last_keycode; /* last reported input keycode */ 131 u32 last_keycode; /* last reported input keycode */
132 u32 rc_scancode; /* the computed remote scancode */ 132 u32 rc_scancode; /* the computed remote scancode */
133 u8 rc_toggle; /* the computed remote toggle bit */ 133 u8 rc_toggle; /* the computed remote toggle bit */
134 u64 rc_type; /* iMON or MCE (RC6) IR protocol? */ 134 u64 rc_type; /* iMON or MCE (RC6) IR protocol? */
135 bool release_code; /* some keys send a release code */ 135 bool release_code; /* some keys send a release code */
136 136
137 u8 display_type; /* store the display type */ 137 u8 display_type; /* store the display type */
138 bool pad_mouse; /* toggle kbd(0)/mouse(1) mode */ 138 bool pad_mouse; /* toggle kbd(0)/mouse(1) mode */
139 139
140 char name_rdev[128]; /* rc input device name */ 140 char name_rdev[128]; /* rc input device name */
141 char phys_rdev[64]; /* rc input device phys path */ 141 char phys_rdev[64]; /* rc input device phys path */
142 142
143 char name_idev[128]; /* input device name */ 143 char name_idev[128]; /* input device name */
144 char phys_idev[64]; /* input device phys path */ 144 char phys_idev[64]; /* input device phys path */
145 145
146 char name_touch[128]; /* touch screen name */ 146 char name_touch[128]; /* touch screen name */
147 char phys_touch[64]; /* touch screen phys path */ 147 char phys_touch[64]; /* touch screen phys path */
148 struct timer_list ttimer; /* touch screen timer */ 148 struct timer_list ttimer; /* touch screen timer */
149 int touch_x; /* x coordinate on touchscreen */ 149 int touch_x; /* x coordinate on touchscreen */
150 int touch_y; /* y coordinate on touchscreen */ 150 int touch_y; /* y coordinate on touchscreen */
151 }; 151 };
152 152
153 #define TOUCH_TIMEOUT (HZ/30) 153 #define TOUCH_TIMEOUT (HZ/30)
154 154
155 /* vfd character device file operations */ 155 /* vfd character device file operations */
156 static const struct file_operations vfd_fops = { 156 static const struct file_operations vfd_fops = {
157 .owner = THIS_MODULE, 157 .owner = THIS_MODULE,
158 .open = &display_open, 158 .open = &display_open,
159 .write = &vfd_write, 159 .write = &vfd_write,
160 .release = &display_close, 160 .release = &display_close,
161 .llseek = noop_llseek, 161 .llseek = noop_llseek,
162 }; 162 };
163 163
164 /* lcd character device file operations */ 164 /* lcd character device file operations */
165 static const struct file_operations lcd_fops = { 165 static const struct file_operations lcd_fops = {
166 .owner = THIS_MODULE, 166 .owner = THIS_MODULE,
167 .open = &display_open, 167 .open = &display_open,
168 .write = &lcd_write, 168 .write = &lcd_write,
169 .release = &display_close, 169 .release = &display_close,
170 .llseek = noop_llseek, 170 .llseek = noop_llseek,
171 }; 171 };
172 172
173 enum { 173 enum {
174 IMON_DISPLAY_TYPE_AUTO = 0, 174 IMON_DISPLAY_TYPE_AUTO = 0,
175 IMON_DISPLAY_TYPE_VFD = 1, 175 IMON_DISPLAY_TYPE_VFD = 1,
176 IMON_DISPLAY_TYPE_LCD = 2, 176 IMON_DISPLAY_TYPE_LCD = 2,
177 IMON_DISPLAY_TYPE_VGA = 3, 177 IMON_DISPLAY_TYPE_VGA = 3,
178 IMON_DISPLAY_TYPE_NONE = 4, 178 IMON_DISPLAY_TYPE_NONE = 4,
179 }; 179 };
180 180
181 enum { 181 enum {
182 IMON_KEY_IMON = 0, 182 IMON_KEY_IMON = 0,
183 IMON_KEY_MCE = 1, 183 IMON_KEY_MCE = 1,
184 IMON_KEY_PANEL = 2, 184 IMON_KEY_PANEL = 2,
185 }; 185 };
186 186
187 /* 187 /*
188 * USB Device ID for iMON USB Control Boards 188 * USB Device ID for iMON USB Control Boards
189 * 189 *
190 * The Windows drivers contain 6 different inf files, more or less one for 190 * The Windows drivers contain 6 different inf files, more or less one for
191 * each new device until the 0x0034-0x0046 devices, which all use the same 191 * each new device until the 0x0034-0x0046 devices, which all use the same
192 * driver. Some of the devices in the 34-46 range haven't been definitively 192 * driver. Some of the devices in the 34-46 range haven't been definitively
193 * identified yet. Early devices have either a TriGem Computer, Inc. or a 193 * identified yet. Early devices have either a TriGem Computer, Inc. or a
194 * Samsung vendor ID (0x0aa8 and 0x04e8 respectively), while all later 194 * Samsung vendor ID (0x0aa8 and 0x04e8 respectively), while all later
195 * devices use the SoundGraph vendor ID (0x15c2). This driver only supports 195 * devices use the SoundGraph vendor ID (0x15c2). This driver only supports
196 * the ffdc and later devices, which do onboard decoding. 196 * the ffdc and later devices, which do onboard decoding.
197 */ 197 */
198 static struct usb_device_id imon_usb_id_table[] = { 198 static struct usb_device_id imon_usb_id_table[] = {
199 /* 199 /*
200 * Several devices with this same device ID, all use iMON_PAD.inf 200 * Several devices with this same device ID, all use iMON_PAD.inf
201 * SoundGraph iMON PAD (IR & VFD) 201 * SoundGraph iMON PAD (IR & VFD)
202 * SoundGraph iMON PAD (IR & LCD) 202 * SoundGraph iMON PAD (IR & LCD)
203 * SoundGraph iMON Knob (IR only) 203 * SoundGraph iMON Knob (IR only)
204 */ 204 */
205 { USB_DEVICE(0x15c2, 0xffdc) }, 205 { USB_DEVICE(0x15c2, 0xffdc) },
206 206
207 /* 207 /*
208 * Newer devices, all driven by the latest iMON Windows driver, full 208 * Newer devices, all driven by the latest iMON Windows driver, full
209 * list of device IDs extracted via 'strings Setup/data1.hdr |grep 15c2' 209 * list of device IDs extracted via 'strings Setup/data1.hdr |grep 15c2'
210 * Need user input to fill in details on unknown devices. 210 * Need user input to fill in details on unknown devices.
211 */ 211 */
212 /* SoundGraph iMON OEM Touch LCD (IR & 7" VGA LCD) */ 212 /* SoundGraph iMON OEM Touch LCD (IR & 7" VGA LCD) */
213 { USB_DEVICE(0x15c2, 0x0034) }, 213 { USB_DEVICE(0x15c2, 0x0034) },
214 /* SoundGraph iMON OEM Touch LCD (IR & 4.3" VGA LCD) */ 214 /* SoundGraph iMON OEM Touch LCD (IR & 4.3" VGA LCD) */
215 { USB_DEVICE(0x15c2, 0x0035) }, 215 { USB_DEVICE(0x15c2, 0x0035) },
216 /* SoundGraph iMON OEM VFD (IR & VFD) */ 216 /* SoundGraph iMON OEM VFD (IR & VFD) */
217 { USB_DEVICE(0x15c2, 0x0036) }, 217 { USB_DEVICE(0x15c2, 0x0036) },
218 /* device specifics unknown */ 218 /* device specifics unknown */
219 { USB_DEVICE(0x15c2, 0x0037) }, 219 { USB_DEVICE(0x15c2, 0x0037) },
220 /* SoundGraph iMON OEM LCD (IR & LCD) */ 220 /* SoundGraph iMON OEM LCD (IR & LCD) */
221 { USB_DEVICE(0x15c2, 0x0038) }, 221 { USB_DEVICE(0x15c2, 0x0038) },
222 /* SoundGraph iMON UltraBay (IR & LCD) */ 222 /* SoundGraph iMON UltraBay (IR & LCD) */
223 { USB_DEVICE(0x15c2, 0x0039) }, 223 { USB_DEVICE(0x15c2, 0x0039) },
224 /* device specifics unknown */ 224 /* device specifics unknown */
225 { USB_DEVICE(0x15c2, 0x003a) }, 225 { USB_DEVICE(0x15c2, 0x003a) },
226 /* device specifics unknown */ 226 /* device specifics unknown */
227 { USB_DEVICE(0x15c2, 0x003b) }, 227 { USB_DEVICE(0x15c2, 0x003b) },
228 /* SoundGraph iMON OEM Inside (IR only) */ 228 /* SoundGraph iMON OEM Inside (IR only) */
229 { USB_DEVICE(0x15c2, 0x003c) }, 229 { USB_DEVICE(0x15c2, 0x003c) },
230 /* device specifics unknown */ 230 /* device specifics unknown */
231 { USB_DEVICE(0x15c2, 0x003d) }, 231 { USB_DEVICE(0x15c2, 0x003d) },
232 /* device specifics unknown */ 232 /* device specifics unknown */
233 { USB_DEVICE(0x15c2, 0x003e) }, 233 { USB_DEVICE(0x15c2, 0x003e) },
234 /* device specifics unknown */ 234 /* device specifics unknown */
235 { USB_DEVICE(0x15c2, 0x003f) }, 235 { USB_DEVICE(0x15c2, 0x003f) },
236 /* device specifics unknown */ 236 /* device specifics unknown */
237 { USB_DEVICE(0x15c2, 0x0040) }, 237 { USB_DEVICE(0x15c2, 0x0040) },
238 /* SoundGraph iMON MINI (IR only) */ 238 /* SoundGraph iMON MINI (IR only) */
239 { USB_DEVICE(0x15c2, 0x0041) }, 239 { USB_DEVICE(0x15c2, 0x0041) },
240 /* Antec Veris Multimedia Station EZ External (IR only) */ 240 /* Antec Veris Multimedia Station EZ External (IR only) */
241 { USB_DEVICE(0x15c2, 0x0042) }, 241 { USB_DEVICE(0x15c2, 0x0042) },
242 /* Antec Veris Multimedia Station Basic Internal (IR only) */ 242 /* Antec Veris Multimedia Station Basic Internal (IR only) */
243 { USB_DEVICE(0x15c2, 0x0043) }, 243 { USB_DEVICE(0x15c2, 0x0043) },
244 /* Antec Veris Multimedia Station Elite (IR & VFD) */ 244 /* Antec Veris Multimedia Station Elite (IR & VFD) */
245 { USB_DEVICE(0x15c2, 0x0044) }, 245 { USB_DEVICE(0x15c2, 0x0044) },
246 /* Antec Veris Multimedia Station Premiere (IR & LCD) */ 246 /* Antec Veris Multimedia Station Premiere (IR & LCD) */
247 { USB_DEVICE(0x15c2, 0x0045) }, 247 { USB_DEVICE(0x15c2, 0x0045) },
248 /* device specifics unknown */ 248 /* device specifics unknown */
249 { USB_DEVICE(0x15c2, 0x0046) }, 249 { USB_DEVICE(0x15c2, 0x0046) },
250 {} 250 {}
251 }; 251 };
252 252
253 /* USB Device data */ 253 /* USB Device data */
254 static struct usb_driver imon_driver = { 254 static struct usb_driver imon_driver = {
255 .name = MOD_NAME, 255 .name = MOD_NAME,
256 .probe = imon_probe, 256 .probe = imon_probe,
257 .disconnect = imon_disconnect, 257 .disconnect = imon_disconnect,
258 .suspend = imon_suspend, 258 .suspend = imon_suspend,
259 .resume = imon_resume, 259 .resume = imon_resume,
260 .id_table = imon_usb_id_table, 260 .id_table = imon_usb_id_table,
261 }; 261 };
262 262
263 static struct usb_class_driver imon_vfd_class = { 263 static struct usb_class_driver imon_vfd_class = {
264 .name = DEVICE_NAME, 264 .name = DEVICE_NAME,
265 .fops = &vfd_fops, 265 .fops = &vfd_fops,
266 .minor_base = DISPLAY_MINOR_BASE, 266 .minor_base = DISPLAY_MINOR_BASE,
267 }; 267 };
268 268
269 static struct usb_class_driver imon_lcd_class = { 269 static struct usb_class_driver imon_lcd_class = {
270 .name = DEVICE_NAME, 270 .name = DEVICE_NAME,
271 .fops = &lcd_fops, 271 .fops = &lcd_fops,
272 .minor_base = DISPLAY_MINOR_BASE, 272 .minor_base = DISPLAY_MINOR_BASE,
273 }; 273 };
274 274
275 /* imon receiver front panel/knob key table */ 275 /* imon receiver front panel/knob key table */
276 static const struct { 276 static const struct {
277 u64 hw_code; 277 u64 hw_code;
278 u32 keycode; 278 u32 keycode;
279 } imon_panel_key_table[] = { 279 } imon_panel_key_table[] = {
280 { 0x000000000f00ffeell, KEY_MEDIA }, /* Go */ 280 { 0x000000000f00ffeell, KEY_MEDIA }, /* Go */
281 { 0x000000001200ffeell, KEY_UP }, 281 { 0x000000001200ffeell, KEY_UP },
282 { 0x000000001300ffeell, KEY_DOWN }, 282 { 0x000000001300ffeell, KEY_DOWN },
283 { 0x000000001400ffeell, KEY_LEFT }, 283 { 0x000000001400ffeell, KEY_LEFT },
284 { 0x000000001500ffeell, KEY_RIGHT }, 284 { 0x000000001500ffeell, KEY_RIGHT },
285 { 0x000000001600ffeell, KEY_ENTER }, 285 { 0x000000001600ffeell, KEY_ENTER },
286 { 0x000000001700ffeell, KEY_ESC }, 286 { 0x000000001700ffeell, KEY_ESC },
287 { 0x000000001f00ffeell, KEY_AUDIO }, 287 { 0x000000001f00ffeell, KEY_AUDIO },
288 { 0x000000002000ffeell, KEY_VIDEO }, 288 { 0x000000002000ffeell, KEY_VIDEO },
289 { 0x000000002100ffeell, KEY_CAMERA }, 289 { 0x000000002100ffeell, KEY_CAMERA },
290 { 0x000000002700ffeell, KEY_DVD }, 290 { 0x000000002700ffeell, KEY_DVD },
291 { 0x000000002300ffeell, KEY_TV }, 291 { 0x000000002300ffeell, KEY_TV },
292 { 0x000000002b00ffeell, KEY_EXIT }, 292 { 0x000000002b00ffeell, KEY_EXIT },
293 { 0x000000002c00ffeell, KEY_SELECT }, 293 { 0x000000002c00ffeell, KEY_SELECT },
294 { 0x000000002d00ffeell, KEY_MENU }, 294 { 0x000000002d00ffeell, KEY_MENU },
295 { 0x000000000500ffeell, KEY_PREVIOUS }, 295 { 0x000000000500ffeell, KEY_PREVIOUS },
296 { 0x000000000700ffeell, KEY_REWIND }, 296 { 0x000000000700ffeell, KEY_REWIND },
297 { 0x000000000400ffeell, KEY_STOP }, 297 { 0x000000000400ffeell, KEY_STOP },
298 { 0x000000003c00ffeell, KEY_PLAYPAUSE }, 298 { 0x000000003c00ffeell, KEY_PLAYPAUSE },
299 { 0x000000000800ffeell, KEY_FASTFORWARD }, 299 { 0x000000000800ffeell, KEY_FASTFORWARD },
300 { 0x000000000600ffeell, KEY_NEXT }, 300 { 0x000000000600ffeell, KEY_NEXT },
301 { 0x000000010000ffeell, KEY_RIGHT }, 301 { 0x000000010000ffeell, KEY_RIGHT },
302 { 0x000001000000ffeell, KEY_LEFT }, 302 { 0x000001000000ffeell, KEY_LEFT },
303 { 0x000000003d00ffeell, KEY_SELECT }, 303 { 0x000000003d00ffeell, KEY_SELECT },
304 { 0x000100000000ffeell, KEY_VOLUMEUP }, 304 { 0x000100000000ffeell, KEY_VOLUMEUP },
305 { 0x010000000000ffeell, KEY_VOLUMEDOWN }, 305 { 0x010000000000ffeell, KEY_VOLUMEDOWN },
306 { 0x000000000100ffeell, KEY_MUTE }, 306 { 0x000000000100ffeell, KEY_MUTE },
307 /* 0xffdc iMON MCE VFD */ 307 /* 0xffdc iMON MCE VFD */
308 { 0x00010000ffffffeell, KEY_VOLUMEUP }, 308 { 0x00010000ffffffeell, KEY_VOLUMEUP },
309 { 0x01000000ffffffeell, KEY_VOLUMEDOWN }, 309 { 0x01000000ffffffeell, KEY_VOLUMEDOWN },
310 /* iMON Knob values */ 310 /* iMON Knob values */
311 { 0x000100ffffffffeell, KEY_VOLUMEUP }, 311 { 0x000100ffffffffeell, KEY_VOLUMEUP },
312 { 0x010000ffffffffeell, KEY_VOLUMEDOWN }, 312 { 0x010000ffffffffeell, KEY_VOLUMEDOWN },
313 { 0x000008ffffffffeell, KEY_MUTE }, 313 { 0x000008ffffffffeell, KEY_MUTE },
314 }; 314 };
315 315
316 /* to prevent races between open() and disconnect(), probing, etc */ 316 /* to prevent races between open() and disconnect(), probing, etc */
317 static DEFINE_MUTEX(driver_lock); 317 static DEFINE_MUTEX(driver_lock);
318 318
319 /* Module bookkeeping bits */ 319 /* Module bookkeeping bits */
320 MODULE_AUTHOR(MOD_AUTHOR); 320 MODULE_AUTHOR(MOD_AUTHOR);
321 MODULE_DESCRIPTION(MOD_DESC); 321 MODULE_DESCRIPTION(MOD_DESC);
322 MODULE_VERSION(MOD_VERSION); 322 MODULE_VERSION(MOD_VERSION);
323 MODULE_LICENSE("GPL"); 323 MODULE_LICENSE("GPL");
324 MODULE_DEVICE_TABLE(usb, imon_usb_id_table); 324 MODULE_DEVICE_TABLE(usb, imon_usb_id_table);
325 325
326 static bool debug; 326 static bool debug;
327 module_param(debug, bool, S_IRUGO | S_IWUSR); 327 module_param(debug, bool, S_IRUGO | S_IWUSR);
328 MODULE_PARM_DESC(debug, "Debug messages: 0=no, 1=yes (default: no)"); 328 MODULE_PARM_DESC(debug, "Debug messages: 0=no, 1=yes (default: no)");
329 329
330 /* lcd, vfd, vga or none? should be auto-detected, but can be overridden... */ 330 /* lcd, vfd, vga or none? should be auto-detected, but can be overridden... */
331 static int display_type; 331 static int display_type;
332 module_param(display_type, int, S_IRUGO); 332 module_param(display_type, int, S_IRUGO);
333 MODULE_PARM_DESC(display_type, "Type of attached display. 0=autodetect, " 333 MODULE_PARM_DESC(display_type, "Type of attached display. 0=autodetect, "
334 "1=vfd, 2=lcd, 3=vga, 4=none (default: autodetect)"); 334 "1=vfd, 2=lcd, 3=vga, 4=none (default: autodetect)");
335 335
336 static int pad_stabilize = 1; 336 static int pad_stabilize = 1;
337 module_param(pad_stabilize, int, S_IRUGO | S_IWUSR); 337 module_param(pad_stabilize, int, S_IRUGO | S_IWUSR);
338 MODULE_PARM_DESC(pad_stabilize, "Apply stabilization algorithm to iMON PAD " 338 MODULE_PARM_DESC(pad_stabilize, "Apply stabilization algorithm to iMON PAD "
339 "presses in arrow key mode. 0=disable, 1=enable (default)."); 339 "presses in arrow key mode. 0=disable, 1=enable (default).");
340 340
341 /* 341 /*
342 * In certain use cases, mouse mode isn't really helpful, and could actually 342 * In certain use cases, mouse mode isn't really helpful, and could actually
343 * cause confusion, so allow disabling it when the IR device is open. 343 * cause confusion, so allow disabling it when the IR device is open.
344 */ 344 */
345 static bool nomouse; 345 static bool nomouse;
346 module_param(nomouse, bool, S_IRUGO | S_IWUSR); 346 module_param(nomouse, bool, S_IRUGO | S_IWUSR);
347 MODULE_PARM_DESC(nomouse, "Disable mouse input device mode when IR device is " 347 MODULE_PARM_DESC(nomouse, "Disable mouse input device mode when IR device is "
348 "open. 0=don't disable, 1=disable. (default: don't disable)"); 348 "open. 0=don't disable, 1=disable. (default: don't disable)");
349 349
350 /* threshold at which a pad push registers as an arrow key in kbd mode */ 350 /* threshold at which a pad push registers as an arrow key in kbd mode */
351 static int pad_thresh; 351 static int pad_thresh;
352 module_param(pad_thresh, int, S_IRUGO | S_IWUSR); 352 module_param(pad_thresh, int, S_IRUGO | S_IWUSR);
353 MODULE_PARM_DESC(pad_thresh, "Threshold at which a pad push registers as an " 353 MODULE_PARM_DESC(pad_thresh, "Threshold at which a pad push registers as an "
354 "arrow key in kbd mode (default: 28)"); 354 "arrow key in kbd mode (default: 28)");
355 355
356 356
357 static void free_imon_context(struct imon_context *ictx) 357 static void free_imon_context(struct imon_context *ictx)
358 { 358 {
359 struct device *dev = ictx->dev; 359 struct device *dev = ictx->dev;
360 360
361 usb_free_urb(ictx->tx_urb); 361 usb_free_urb(ictx->tx_urb);
362 usb_free_urb(ictx->rx_urb_intf0); 362 usb_free_urb(ictx->rx_urb_intf0);
363 usb_free_urb(ictx->rx_urb_intf1); 363 usb_free_urb(ictx->rx_urb_intf1);
364 kfree(ictx); 364 kfree(ictx);
365 365
366 dev_dbg(dev, "%s: iMON context freed\n", __func__); 366 dev_dbg(dev, "%s: iMON context freed\n", __func__);
367 } 367 }
368 368
369 /** 369 /**
370 * Called when the Display device (e.g. /dev/lcd0) 370 * Called when the Display device (e.g. /dev/lcd0)
371 * is opened by the application. 371 * is opened by the application.
372 */ 372 */
373 static int display_open(struct inode *inode, struct file *file) 373 static int display_open(struct inode *inode, struct file *file)
374 { 374 {
375 struct usb_interface *interface; 375 struct usb_interface *interface;
376 struct imon_context *ictx = NULL; 376 struct imon_context *ictx = NULL;
377 int subminor; 377 int subminor;
378 int retval = 0; 378 int retval = 0;
379 379
380 /* prevent races with disconnect */ 380 /* prevent races with disconnect */
381 mutex_lock(&driver_lock); 381 mutex_lock(&driver_lock);
382 382
383 subminor = iminor(inode); 383 subminor = iminor(inode);
384 interface = usb_find_interface(&imon_driver, subminor); 384 interface = usb_find_interface(&imon_driver, subminor);
385 if (!interface) { 385 if (!interface) {
386 pr_err("could not find interface for minor %d\n", subminor); 386 pr_err("could not find interface for minor %d\n", subminor);
387 retval = -ENODEV; 387 retval = -ENODEV;
388 goto exit; 388 goto exit;
389 } 389 }
390 ictx = usb_get_intfdata(interface); 390 ictx = usb_get_intfdata(interface);
391 391
392 if (!ictx) { 392 if (!ictx) {
393 pr_err("no context found for minor %d\n", subminor); 393 pr_err("no context found for minor %d\n", subminor);
394 retval = -ENODEV; 394 retval = -ENODEV;
395 goto exit; 395 goto exit;
396 } 396 }
397 397
398 mutex_lock(&ictx->lock); 398 mutex_lock(&ictx->lock);
399 399
400 if (!ictx->display_supported) { 400 if (!ictx->display_supported) {
401 pr_err("display not supported by device\n"); 401 pr_err("display not supported by device\n");
402 retval = -ENODEV; 402 retval = -ENODEV;
403 } else if (ictx->display_isopen) { 403 } else if (ictx->display_isopen) {
404 pr_err("display port is already open\n"); 404 pr_err("display port is already open\n");
405 retval = -EBUSY; 405 retval = -EBUSY;
406 } else { 406 } else {
407 ictx->display_isopen = true; 407 ictx->display_isopen = true;
408 file->private_data = ictx; 408 file->private_data = ictx;
409 dev_dbg(ictx->dev, "display port opened\n"); 409 dev_dbg(ictx->dev, "display port opened\n");
410 } 410 }
411 411
412 mutex_unlock(&ictx->lock); 412 mutex_unlock(&ictx->lock);
413 413
414 exit: 414 exit:
415 mutex_unlock(&driver_lock); 415 mutex_unlock(&driver_lock);
416 return retval; 416 return retval;
417 } 417 }
418 418
419 /** 419 /**
420 * Called when the display device (e.g. /dev/lcd0) 420 * Called when the display device (e.g. /dev/lcd0)
421 * is closed by the application. 421 * is closed by the application.
422 */ 422 */
423 static int display_close(struct inode *inode, struct file *file) 423 static int display_close(struct inode *inode, struct file *file)
424 { 424 {
425 struct imon_context *ictx = NULL; 425 struct imon_context *ictx = NULL;
426 int retval = 0; 426 int retval = 0;
427 427
428 ictx = file->private_data; 428 ictx = file->private_data;
429 429
430 if (!ictx) { 430 if (!ictx) {
431 pr_err("no context for device\n"); 431 pr_err("no context for device\n");
432 return -ENODEV; 432 return -ENODEV;
433 } 433 }
434 434
435 mutex_lock(&ictx->lock); 435 mutex_lock(&ictx->lock);
436 436
437 if (!ictx->display_supported) { 437 if (!ictx->display_supported) {
438 pr_err("display not supported by device\n"); 438 pr_err("display not supported by device\n");
439 retval = -ENODEV; 439 retval = -ENODEV;
440 } else if (!ictx->display_isopen) { 440 } else if (!ictx->display_isopen) {
441 pr_err("display is not open\n"); 441 pr_err("display is not open\n");
442 retval = -EIO; 442 retval = -EIO;
443 } else { 443 } else {
444 ictx->display_isopen = false; 444 ictx->display_isopen = false;
445 dev_dbg(ictx->dev, "display port closed\n"); 445 dev_dbg(ictx->dev, "display port closed\n");
446 } 446 }
447 447
448 mutex_unlock(&ictx->lock); 448 mutex_unlock(&ictx->lock);
449 return retval; 449 return retval;
450 } 450 }
451 451
452 /** 452 /**
453 * Sends a packet to the device -- this function must be called with 453 * Sends a packet to the device -- this function must be called with
454 * ictx->lock held, or its unlock/lock sequence while waiting for tx 454 * ictx->lock held, or its unlock/lock sequence while waiting for tx
455 * to complete can/will lead to a deadlock. 455 * to complete can/will lead to a deadlock.
456 */ 456 */
457 static int send_packet(struct imon_context *ictx) 457 static int send_packet(struct imon_context *ictx)
458 { 458 {
459 unsigned int pipe; 459 unsigned int pipe;
460 unsigned long timeout; 460 unsigned long timeout;
461 int interval = 0; 461 int interval = 0;
462 int retval = 0; 462 int retval = 0;
463 struct usb_ctrlrequest *control_req = NULL; 463 struct usb_ctrlrequest *control_req = NULL;
464 464
465 /* Check if we need to use control or interrupt urb */ 465 /* Check if we need to use control or interrupt urb */
466 if (!ictx->tx_control) { 466 if (!ictx->tx_control) {
467 pipe = usb_sndintpipe(ictx->usbdev_intf0, 467 pipe = usb_sndintpipe(ictx->usbdev_intf0,
468 ictx->tx_endpoint->bEndpointAddress); 468 ictx->tx_endpoint->bEndpointAddress);
469 interval = ictx->tx_endpoint->bInterval; 469 interval = ictx->tx_endpoint->bInterval;
470 470
471 usb_fill_int_urb(ictx->tx_urb, ictx->usbdev_intf0, pipe, 471 usb_fill_int_urb(ictx->tx_urb, ictx->usbdev_intf0, pipe,
472 ictx->usb_tx_buf, 472 ictx->usb_tx_buf,
473 sizeof(ictx->usb_tx_buf), 473 sizeof(ictx->usb_tx_buf),
474 usb_tx_callback, ictx, interval); 474 usb_tx_callback, ictx, interval);
475 475
476 ictx->tx_urb->actual_length = 0; 476 ictx->tx_urb->actual_length = 0;
477 } else { 477 } else {
478 /* fill request into kmalloc'ed space: */ 478 /* fill request into kmalloc'ed space: */
479 control_req = kmalloc(sizeof(struct usb_ctrlrequest), 479 control_req = kmalloc(sizeof(struct usb_ctrlrequest),
480 GFP_KERNEL); 480 GFP_KERNEL);
481 if (control_req == NULL) 481 if (control_req == NULL)
482 return -ENOMEM; 482 return -ENOMEM;
483 483
484 /* setup packet is '21 09 0200 0001 0008' */ 484 /* setup packet is '21 09 0200 0001 0008' */
485 control_req->bRequestType = 0x21; 485 control_req->bRequestType = 0x21;
486 control_req->bRequest = 0x09; 486 control_req->bRequest = 0x09;
487 control_req->wValue = cpu_to_le16(0x0200); 487 control_req->wValue = cpu_to_le16(0x0200);
488 control_req->wIndex = cpu_to_le16(0x0001); 488 control_req->wIndex = cpu_to_le16(0x0001);
489 control_req->wLength = cpu_to_le16(0x0008); 489 control_req->wLength = cpu_to_le16(0x0008);
490 490
491 /* control pipe is endpoint 0x00 */ 491 /* control pipe is endpoint 0x00 */
492 pipe = usb_sndctrlpipe(ictx->usbdev_intf0, 0); 492 pipe = usb_sndctrlpipe(ictx->usbdev_intf0, 0);
493 493
494 /* build the control urb */ 494 /* build the control urb */
495 usb_fill_control_urb(ictx->tx_urb, ictx->usbdev_intf0, 495 usb_fill_control_urb(ictx->tx_urb, ictx->usbdev_intf0,
496 pipe, (unsigned char *)control_req, 496 pipe, (unsigned char *)control_req,
497 ictx->usb_tx_buf, 497 ictx->usb_tx_buf,
498 sizeof(ictx->usb_tx_buf), 498 sizeof(ictx->usb_tx_buf),
499 usb_tx_callback, ictx); 499 usb_tx_callback, ictx);
500 ictx->tx_urb->actual_length = 0; 500 ictx->tx_urb->actual_length = 0;
501 } 501 }
502 502
503 init_completion(&ictx->tx.finished); 503 init_completion(&ictx->tx.finished);
504 ictx->tx.busy = true; 504 ictx->tx.busy = true;
505 smp_rmb(); /* ensure later readers know we're busy */ 505 smp_rmb(); /* ensure later readers know we're busy */
506 506
507 retval = usb_submit_urb(ictx->tx_urb, GFP_KERNEL); 507 retval = usb_submit_urb(ictx->tx_urb, GFP_KERNEL);
508 if (retval) { 508 if (retval) {
509 ictx->tx.busy = false; 509 ictx->tx.busy = false;
510 smp_rmb(); /* ensure later readers know we're not busy */ 510 smp_rmb(); /* ensure later readers know we're not busy */
511 pr_err("error submitting urb(%d)\n", retval); 511 pr_err("error submitting urb(%d)\n", retval);
512 } else { 512 } else {
513 /* Wait for transmission to complete (or abort) */ 513 /* Wait for transmission to complete (or abort) */
514 mutex_unlock(&ictx->lock); 514 mutex_unlock(&ictx->lock);
515 retval = wait_for_completion_interruptible( 515 retval = wait_for_completion_interruptible(
516 &ictx->tx.finished); 516 &ictx->tx.finished);
517 if (retval) 517 if (retval)
518 pr_err("task interrupted\n"); 518 pr_err("task interrupted\n");
519 mutex_lock(&ictx->lock); 519 mutex_lock(&ictx->lock);
520 520
521 retval = ictx->tx.status; 521 retval = ictx->tx.status;
522 if (retval) 522 if (retval)
523 pr_err("packet tx failed (%d)\n", retval); 523 pr_err("packet tx failed (%d)\n", retval);
524 } 524 }
525 525
526 kfree(control_req); 526 kfree(control_req);
527 527
528 /* 528 /*
529 * Induce a mandatory 5ms delay before returning, as otherwise, 529 * Induce a mandatory 5ms delay before returning, as otherwise,
530 * send_packet can get called so rapidly as to overwhelm the device, 530 * send_packet can get called so rapidly as to overwhelm the device,
531 * particularly on faster systems and/or those with quirky usb. 531 * particularly on faster systems and/or those with quirky usb.
532 */ 532 */
533 timeout = msecs_to_jiffies(5); 533 timeout = msecs_to_jiffies(5);
534 set_current_state(TASK_UNINTERRUPTIBLE); 534 set_current_state(TASK_UNINTERRUPTIBLE);
535 schedule_timeout(timeout); 535 schedule_timeout(timeout);
536 536
537 return retval; 537 return retval;
538 } 538 }
539 539
540 /** 540 /**
541 * Sends an associate packet to the iMON 2.4G. 541 * Sends an associate packet to the iMON 2.4G.
542 * 542 *
543 * This might not be such a good idea, since it has an id collision with 543 * This might not be such a good idea, since it has an id collision with
544 * some versions of the "IR & VFD" combo. The only way to determine if it 544 * some versions of the "IR & VFD" combo. The only way to determine if it
545 * is an RF version is to look at the product description string. (Which 545 * is an RF version is to look at the product description string. (Which
546 * we currently do not fetch). 546 * we currently do not fetch).
547 */ 547 */
548 static int send_associate_24g(struct imon_context *ictx) 548 static int send_associate_24g(struct imon_context *ictx)
549 { 549 {
550 int retval; 550 int retval;
551 const unsigned char packet[8] = { 0x01, 0x00, 0x00, 0x00, 551 const unsigned char packet[8] = { 0x01, 0x00, 0x00, 0x00,
552 0x00, 0x00, 0x00, 0x20 }; 552 0x00, 0x00, 0x00, 0x20 };
553 553
554 if (!ictx) { 554 if (!ictx) {
555 pr_err("no context for device\n"); 555 pr_err("no context for device\n");
556 return -ENODEV; 556 return -ENODEV;
557 } 557 }
558 558
559 if (!ictx->dev_present_intf0) { 559 if (!ictx->dev_present_intf0) {
560 pr_err("no iMON device present\n"); 560 pr_err("no iMON device present\n");
561 return -ENODEV; 561 return -ENODEV;
562 } 562 }
563 563
564 memcpy(ictx->usb_tx_buf, packet, sizeof(packet)); 564 memcpy(ictx->usb_tx_buf, packet, sizeof(packet));
565 retval = send_packet(ictx); 565 retval = send_packet(ictx);
566 566
567 return retval; 567 return retval;
568 } 568 }
569 569
570 /** 570 /**
571 * Sends packets to setup and show clock on iMON display 571 * Sends packets to setup and show clock on iMON display
572 * 572 *
573 * Arguments: year - last 2 digits of year, month - 1..12, 573 * Arguments: year - last 2 digits of year, month - 1..12,
574 * day - 1..31, dow - day of the week (0-Sun...6-Sat), 574 * day - 1..31, dow - day of the week (0-Sun...6-Sat),
575 * hour - 0..23, minute - 0..59, second - 0..59 575 * hour - 0..23, minute - 0..59, second - 0..59
576 */ 576 */
577 static int send_set_imon_clock(struct imon_context *ictx, 577 static int send_set_imon_clock(struct imon_context *ictx,
578 unsigned int year, unsigned int month, 578 unsigned int year, unsigned int month,
579 unsigned int day, unsigned int dow, 579 unsigned int day, unsigned int dow,
580 unsigned int hour, unsigned int minute, 580 unsigned int hour, unsigned int minute,
581 unsigned int second) 581 unsigned int second)
582 { 582 {
583 unsigned char clock_enable_pkt[IMON_CLOCK_ENABLE_PACKETS][8]; 583 unsigned char clock_enable_pkt[IMON_CLOCK_ENABLE_PACKETS][8];
584 int retval = 0; 584 int retval = 0;
585 int i; 585 int i;
586 586
587 if (!ictx) { 587 if (!ictx) {
588 pr_err("no context for device\n"); 588 pr_err("no context for device\n");
589 return -ENODEV; 589 return -ENODEV;
590 } 590 }
591 591
592 switch (ictx->display_type) { 592 switch (ictx->display_type) {
593 case IMON_DISPLAY_TYPE_LCD: 593 case IMON_DISPLAY_TYPE_LCD:
594 clock_enable_pkt[0][0] = 0x80; 594 clock_enable_pkt[0][0] = 0x80;
595 clock_enable_pkt[0][1] = year; 595 clock_enable_pkt[0][1] = year;
596 clock_enable_pkt[0][2] = month-1; 596 clock_enable_pkt[0][2] = month-1;
597 clock_enable_pkt[0][3] = day; 597 clock_enable_pkt[0][3] = day;
598 clock_enable_pkt[0][4] = hour; 598 clock_enable_pkt[0][4] = hour;
599 clock_enable_pkt[0][5] = minute; 599 clock_enable_pkt[0][5] = minute;
600 clock_enable_pkt[0][6] = second; 600 clock_enable_pkt[0][6] = second;
601 601
602 clock_enable_pkt[1][0] = 0x80; 602 clock_enable_pkt[1][0] = 0x80;
603 clock_enable_pkt[1][1] = 0; 603 clock_enable_pkt[1][1] = 0;
604 clock_enable_pkt[1][2] = 0; 604 clock_enable_pkt[1][2] = 0;
605 clock_enable_pkt[1][3] = 0; 605 clock_enable_pkt[1][3] = 0;
606 clock_enable_pkt[1][4] = 0; 606 clock_enable_pkt[1][4] = 0;
607 clock_enable_pkt[1][5] = 0; 607 clock_enable_pkt[1][5] = 0;
608 clock_enable_pkt[1][6] = 0; 608 clock_enable_pkt[1][6] = 0;
609 609
610 if (ictx->product == 0xffdc) { 610 if (ictx->product == 0xffdc) {
611 clock_enable_pkt[0][7] = 0x50; 611 clock_enable_pkt[0][7] = 0x50;
612 clock_enable_pkt[1][7] = 0x51; 612 clock_enable_pkt[1][7] = 0x51;
613 } else { 613 } else {
614 clock_enable_pkt[0][7] = 0x88; 614 clock_enable_pkt[0][7] = 0x88;
615 clock_enable_pkt[1][7] = 0x8a; 615 clock_enable_pkt[1][7] = 0x8a;
616 } 616 }
617 617
618 break; 618 break;
619 619
620 case IMON_DISPLAY_TYPE_VFD: 620 case IMON_DISPLAY_TYPE_VFD:
621 clock_enable_pkt[0][0] = year; 621 clock_enable_pkt[0][0] = year;
622 clock_enable_pkt[0][1] = month-1; 622 clock_enable_pkt[0][1] = month-1;
623 clock_enable_pkt[0][2] = day; 623 clock_enable_pkt[0][2] = day;
624 clock_enable_pkt[0][3] = dow; 624 clock_enable_pkt[0][3] = dow;
625 clock_enable_pkt[0][4] = hour; 625 clock_enable_pkt[0][4] = hour;
626 clock_enable_pkt[0][5] = minute; 626 clock_enable_pkt[0][5] = minute;
627 clock_enable_pkt[0][6] = second; 627 clock_enable_pkt[0][6] = second;
628 clock_enable_pkt[0][7] = 0x40; 628 clock_enable_pkt[0][7] = 0x40;
629 629
630 clock_enable_pkt[1][0] = 0; 630 clock_enable_pkt[1][0] = 0;
631 clock_enable_pkt[1][1] = 0; 631 clock_enable_pkt[1][1] = 0;
632 clock_enable_pkt[1][2] = 1; 632 clock_enable_pkt[1][2] = 1;
633 clock_enable_pkt[1][3] = 0; 633 clock_enable_pkt[1][3] = 0;
634 clock_enable_pkt[1][4] = 0; 634 clock_enable_pkt[1][4] = 0;
635 clock_enable_pkt[1][5] = 0; 635 clock_enable_pkt[1][5] = 0;
636 clock_enable_pkt[1][6] = 0; 636 clock_enable_pkt[1][6] = 0;
637 clock_enable_pkt[1][7] = 0x42; 637 clock_enable_pkt[1][7] = 0x42;
638 638
639 break; 639 break;
640 640
641 default: 641 default:
642 return -ENODEV; 642 return -ENODEV;
643 } 643 }
644 644
645 for (i = 0; i < IMON_CLOCK_ENABLE_PACKETS; i++) { 645 for (i = 0; i < IMON_CLOCK_ENABLE_PACKETS; i++) {
646 memcpy(ictx->usb_tx_buf, clock_enable_pkt[i], 8); 646 memcpy(ictx->usb_tx_buf, clock_enable_pkt[i], 8);
647 retval = send_packet(ictx); 647 retval = send_packet(ictx);
648 if (retval) { 648 if (retval) {
649 pr_err("send_packet failed for packet %d\n", i); 649 pr_err("send_packet failed for packet %d\n", i);
650 break; 650 break;
651 } 651 }
652 } 652 }
653 653
654 return retval; 654 return retval;
655 } 655 }
656 656
657 /** 657 /**
658 * These are the sysfs functions to handle the association on the iMON 2.4G LT. 658 * These are the sysfs functions to handle the association on the iMON 2.4G LT.
659 */ 659 */
660 static ssize_t show_associate_remote(struct device *d, 660 static ssize_t show_associate_remote(struct device *d,
661 struct device_attribute *attr, 661 struct device_attribute *attr,
662 char *buf) 662 char *buf)
663 { 663 {
664 struct imon_context *ictx = dev_get_drvdata(d); 664 struct imon_context *ictx = dev_get_drvdata(d);
665 665
666 if (!ictx) 666 if (!ictx)
667 return -ENODEV; 667 return -ENODEV;
668 668
669 mutex_lock(&ictx->lock); 669 mutex_lock(&ictx->lock);
670 if (ictx->rf_isassociating) 670 if (ictx->rf_isassociating)
671 strcpy(buf, "associating\n"); 671 strcpy(buf, "associating\n");
672 else 672 else
673 strcpy(buf, "closed\n"); 673 strcpy(buf, "closed\n");
674 674
675 dev_info(d, "Visit http://www.lirc.org/html/imon-24g.html for " 675 dev_info(d, "Visit http://www.lirc.org/html/imon-24g.html for "
676 "instructions on how to associate your iMON 2.4G DT/LT " 676 "instructions on how to associate your iMON 2.4G DT/LT "
677 "remote\n"); 677 "remote\n");
678 mutex_unlock(&ictx->lock); 678 mutex_unlock(&ictx->lock);
679 return strlen(buf); 679 return strlen(buf);
680 } 680 }
681 681
682 static ssize_t store_associate_remote(struct device *d, 682 static ssize_t store_associate_remote(struct device *d,
683 struct device_attribute *attr, 683 struct device_attribute *attr,
684 const char *buf, size_t count) 684 const char *buf, size_t count)
685 { 685 {
686 struct imon_context *ictx; 686 struct imon_context *ictx;
687 687
688 ictx = dev_get_drvdata(d); 688 ictx = dev_get_drvdata(d);
689 689
690 if (!ictx) 690 if (!ictx)
691 return -ENODEV; 691 return -ENODEV;
692 692
693 mutex_lock(&ictx->lock); 693 mutex_lock(&ictx->lock);
694 ictx->rf_isassociating = true; 694 ictx->rf_isassociating = true;
695 send_associate_24g(ictx); 695 send_associate_24g(ictx);
696 mutex_unlock(&ictx->lock); 696 mutex_unlock(&ictx->lock);
697 697
698 return count; 698 return count;
699 } 699 }
700 700
701 /** 701 /**
702 * sysfs functions to control internal imon clock 702 * sysfs functions to control internal imon clock
703 */ 703 */
704 static ssize_t show_imon_clock(struct device *d, 704 static ssize_t show_imon_clock(struct device *d,
705 struct device_attribute *attr, char *buf) 705 struct device_attribute *attr, char *buf)
706 { 706 {
707 struct imon_context *ictx = dev_get_drvdata(d); 707 struct imon_context *ictx = dev_get_drvdata(d);
708 size_t len; 708 size_t len;
709 709
710 if (!ictx) 710 if (!ictx)
711 return -ENODEV; 711 return -ENODEV;
712 712
713 mutex_lock(&ictx->lock); 713 mutex_lock(&ictx->lock);
714 714
715 if (!ictx->display_supported) { 715 if (!ictx->display_supported) {
716 len = snprintf(buf, PAGE_SIZE, "Not supported."); 716 len = snprintf(buf, PAGE_SIZE, "Not supported.");
717 } else { 717 } else {
718 len = snprintf(buf, PAGE_SIZE, 718 len = snprintf(buf, PAGE_SIZE,
719 "To set the clock on your iMON display:\n" 719 "To set the clock on your iMON display:\n"
720 "# date \"+%%y %%m %%d %%w %%H %%M %%S\" > imon_clock\n" 720 "# date \"+%%y %%m %%d %%w %%H %%M %%S\" > imon_clock\n"
721 "%s", ictx->display_isopen ? 721 "%s", ictx->display_isopen ?
722 "\nNOTE: imon device must be closed\n" : ""); 722 "\nNOTE: imon device must be closed\n" : "");
723 } 723 }
724 724
725 mutex_unlock(&ictx->lock); 725 mutex_unlock(&ictx->lock);
726 726
727 return len; 727 return len;
728 } 728 }
729 729
730 static ssize_t store_imon_clock(struct device *d, 730 static ssize_t store_imon_clock(struct device *d,
731 struct device_attribute *attr, 731 struct device_attribute *attr,
732 const char *buf, size_t count) 732 const char *buf, size_t count)
733 { 733 {
734 struct imon_context *ictx = dev_get_drvdata(d); 734 struct imon_context *ictx = dev_get_drvdata(d);
735 ssize_t retval; 735 ssize_t retval;
736 unsigned int year, month, day, dow, hour, minute, second; 736 unsigned int year, month, day, dow, hour, minute, second;
737 737
738 if (!ictx) 738 if (!ictx)
739 return -ENODEV; 739 return -ENODEV;
740 740
741 mutex_lock(&ictx->lock); 741 mutex_lock(&ictx->lock);
742 742
743 if (!ictx->display_supported) { 743 if (!ictx->display_supported) {
744 retval = -ENODEV; 744 retval = -ENODEV;
745 goto exit; 745 goto exit;
746 } else if (ictx->display_isopen) { 746 } else if (ictx->display_isopen) {
747 retval = -EBUSY; 747 retval = -EBUSY;
748 goto exit; 748 goto exit;
749 } 749 }
750 750
751 if (sscanf(buf, "%u %u %u %u %u %u %u", &year, &month, &day, &dow, 751 if (sscanf(buf, "%u %u %u %u %u %u %u", &year, &month, &day, &dow,
752 &hour, &minute, &second) != 7) { 752 &hour, &minute, &second) != 7) {
753 retval = -EINVAL; 753 retval = -EINVAL;
754 goto exit; 754 goto exit;
755 } 755 }
756 756
757 if ((month < 1 || month > 12) || 757 if ((month < 1 || month > 12) ||
758 (day < 1 || day > 31) || (dow > 6) || 758 (day < 1 || day > 31) || (dow > 6) ||
759 (hour > 23) || (minute > 59) || (second > 59)) { 759 (hour > 23) || (minute > 59) || (second > 59)) {
760 retval = -EINVAL; 760 retval = -EINVAL;
761 goto exit; 761 goto exit;
762 } 762 }
763 763
764 retval = send_set_imon_clock(ictx, year, month, day, dow, 764 retval = send_set_imon_clock(ictx, year, month, day, dow,
765 hour, minute, second); 765 hour, minute, second);
766 if (retval) 766 if (retval)
767 goto exit; 767 goto exit;
768 768
769 retval = count; 769 retval = count;
770 exit: 770 exit:
771 mutex_unlock(&ictx->lock); 771 mutex_unlock(&ictx->lock);
772 772
773 return retval; 773 return retval;
774 } 774 }
775 775
776 776
777 static DEVICE_ATTR(imon_clock, S_IWUSR | S_IRUGO, show_imon_clock, 777 static DEVICE_ATTR(imon_clock, S_IWUSR | S_IRUGO, show_imon_clock,
778 store_imon_clock); 778 store_imon_clock);
779 779
780 static DEVICE_ATTR(associate_remote, S_IWUSR | S_IRUGO, show_associate_remote, 780 static DEVICE_ATTR(associate_remote, S_IWUSR | S_IRUGO, show_associate_remote,
781 store_associate_remote); 781 store_associate_remote);
782 782
783 static struct attribute *imon_display_sysfs_entries[] = { 783 static struct attribute *imon_display_sysfs_entries[] = {
784 &dev_attr_imon_clock.attr, 784 &dev_attr_imon_clock.attr,
785 NULL 785 NULL
786 }; 786 };
787 787
788 static struct attribute_group imon_display_attr_group = { 788 static struct attribute_group imon_display_attr_group = {
789 .attrs = imon_display_sysfs_entries 789 .attrs = imon_display_sysfs_entries
790 }; 790 };
791 791
792 static struct attribute *imon_rf_sysfs_entries[] = { 792 static struct attribute *imon_rf_sysfs_entries[] = {
793 &dev_attr_associate_remote.attr, 793 &dev_attr_associate_remote.attr,
794 NULL 794 NULL
795 }; 795 };
796 796
797 static struct attribute_group imon_rf_attr_group = { 797 static struct attribute_group imon_rf_attr_group = {
798 .attrs = imon_rf_sysfs_entries 798 .attrs = imon_rf_sysfs_entries
799 }; 799 };
800 800
801 /** 801 /**
802 * Writes data to the VFD. The iMON VFD is 2x16 characters 802 * Writes data to the VFD. The iMON VFD is 2x16 characters
803 * and requires data in 5 consecutive USB interrupt packets, 803 * and requires data in 5 consecutive USB interrupt packets,
804 * each packet but the last carrying 7 bytes. 804 * each packet but the last carrying 7 bytes.
805 * 805 *
806 * I don't know if the VFD board supports features such as 806 * I don't know if the VFD board supports features such as
807 * scrolling, clearing rows, blanking, etc. so at 807 * scrolling, clearing rows, blanking, etc. so at
808 * the caller must provide a full screen of data. If fewer 808 * the caller must provide a full screen of data. If fewer
809 * than 32 bytes are provided spaces will be appended to 809 * than 32 bytes are provided spaces will be appended to
810 * generate a full screen. 810 * generate a full screen.
811 */ 811 */
812 static ssize_t vfd_write(struct file *file, const char *buf, 812 static ssize_t vfd_write(struct file *file, const char *buf,
813 size_t n_bytes, loff_t *pos) 813 size_t n_bytes, loff_t *pos)
814 { 814 {
815 int i; 815 int i;
816 int offset; 816 int offset;
817 int seq; 817 int seq;
818 int retval = 0; 818 int retval = 0;
819 struct imon_context *ictx; 819 struct imon_context *ictx;
820 const unsigned char vfd_packet6[] = { 820 const unsigned char vfd_packet6[] = {
821 0x01, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF }; 821 0x01, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF };
822 822
823 ictx = file->private_data; 823 ictx = file->private_data;
824 if (!ictx) { 824 if (!ictx) {
825 pr_err("no context for device\n"); 825 pr_err("no context for device\n");
826 return -ENODEV; 826 return -ENODEV;
827 } 827 }
828 828
829 mutex_lock(&ictx->lock); 829 mutex_lock(&ictx->lock);
830 830
831 if (!ictx->dev_present_intf0) { 831 if (!ictx->dev_present_intf0) {
832 pr_err("no iMON device present\n"); 832 pr_err("no iMON device present\n");
833 retval = -ENODEV; 833 retval = -ENODEV;
834 goto exit; 834 goto exit;
835 } 835 }
836 836
837 if (n_bytes <= 0 || n_bytes > 32) { 837 if (n_bytes <= 0 || n_bytes > 32) {
838 pr_err("invalid payload size\n"); 838 pr_err("invalid payload size\n");
839 retval = -EINVAL; 839 retval = -EINVAL;
840 goto exit; 840 goto exit;
841 } 841 }
842 842
843 if (copy_from_user(ictx->tx.data_buf, buf, n_bytes)) { 843 if (copy_from_user(ictx->tx.data_buf, buf, n_bytes)) {
844 retval = -EFAULT; 844 retval = -EFAULT;
845 goto exit; 845 goto exit;
846 } 846 }
847 847
848 /* Pad with spaces */ 848 /* Pad with spaces */
849 for (i = n_bytes; i < 32; ++i) 849 for (i = n_bytes; i < 32; ++i)
850 ictx->tx.data_buf[i] = ' '; 850 ictx->tx.data_buf[i] = ' ';
851 851
852 for (i = 32; i < 35; ++i) 852 for (i = 32; i < 35; ++i)
853 ictx->tx.data_buf[i] = 0xFF; 853 ictx->tx.data_buf[i] = 0xFF;
854 854
855 offset = 0; 855 offset = 0;
856 seq = 0; 856 seq = 0;
857 857
858 do { 858 do {
859 memcpy(ictx->usb_tx_buf, ictx->tx.data_buf + offset, 7); 859 memcpy(ictx->usb_tx_buf, ictx->tx.data_buf + offset, 7);
860 ictx->usb_tx_buf[7] = (unsigned char) seq; 860 ictx->usb_tx_buf[7] = (unsigned char) seq;
861 861
862 retval = send_packet(ictx); 862 retval = send_packet(ictx);
863 if (retval) { 863 if (retval) {
864 pr_err("send packet failed for packet #%d\n", seq / 2); 864 pr_err("send packet failed for packet #%d\n", seq / 2);
865 goto exit; 865 goto exit;
866 } else { 866 } else {
867 seq += 2; 867 seq += 2;
868 offset += 7; 868 offset += 7;
869 } 869 }
870 870
871 } while (offset < 35); 871 } while (offset < 35);
872 872
873 /* Send packet #6 */ 873 /* Send packet #6 */
874 memcpy(ictx->usb_tx_buf, &vfd_packet6, sizeof(vfd_packet6)); 874 memcpy(ictx->usb_tx_buf, &vfd_packet6, sizeof(vfd_packet6));
875 ictx->usb_tx_buf[7] = (unsigned char) seq; 875 ictx->usb_tx_buf[7] = (unsigned char) seq;
876 retval = send_packet(ictx); 876 retval = send_packet(ictx);
877 if (retval) 877 if (retval)
878 pr_err("send packet failed for packet #%d\n", seq / 2); 878 pr_err("send packet failed for packet #%d\n", seq / 2);
879 879
880 exit: 880 exit:
881 mutex_unlock(&ictx->lock); 881 mutex_unlock(&ictx->lock);
882 882
883 return (!retval) ? n_bytes : retval; 883 return (!retval) ? n_bytes : retval;
884 } 884 }
885 885
886 /** 886 /**
887 * Writes data to the LCD. The iMON OEM LCD screen expects 8-byte 887 * Writes data to the LCD. The iMON OEM LCD screen expects 8-byte
888 * packets. We accept data as 16 hexadecimal digits, followed by a 888 * packets. We accept data as 16 hexadecimal digits, followed by a
889 * newline (to make it easy to drive the device from a command-line 889 * newline (to make it easy to drive the device from a command-line
890 * -- even though the actual binary data is a bit complicated). 890 * -- even though the actual binary data is a bit complicated).
891 * 891 *
892 * The device itself is not a "traditional" text-mode display. It's 892 * The device itself is not a "traditional" text-mode display. It's
893 * actually a 16x96 pixel bitmap display. That means if you want to 893 * actually a 16x96 pixel bitmap display. That means if you want to
894 * display text, you've got to have your own "font" and translate the 894 * display text, you've got to have your own "font" and translate the
895 * text into bitmaps for display. This is really flexible (you can 895 * text into bitmaps for display. This is really flexible (you can
896 * display whatever diacritics you need, and so on), but it's also 896 * display whatever diacritics you need, and so on), but it's also
897 * a lot more complicated than most LCDs... 897 * a lot more complicated than most LCDs...
898 */ 898 */
899 static ssize_t lcd_write(struct file *file, const char *buf, 899 static ssize_t lcd_write(struct file *file, const char *buf,
900 size_t n_bytes, loff_t *pos) 900 size_t n_bytes, loff_t *pos)
901 { 901 {
902 int retval = 0; 902 int retval = 0;
903 struct imon_context *ictx; 903 struct imon_context *ictx;
904 904
905 ictx = file->private_data; 905 ictx = file->private_data;
906 if (!ictx) { 906 if (!ictx) {
907 pr_err("no context for device\n"); 907 pr_err("no context for device\n");
908 return -ENODEV; 908 return -ENODEV;
909 } 909 }
910 910
911 mutex_lock(&ictx->lock); 911 mutex_lock(&ictx->lock);
912 912
913 if (!ictx->display_supported) { 913 if (!ictx->display_supported) {
914 pr_err("no iMON display present\n"); 914 pr_err("no iMON display present\n");
915 retval = -ENODEV; 915 retval = -ENODEV;
916 goto exit; 916 goto exit;
917 } 917 }
918 918
919 if (n_bytes != 8) { 919 if (n_bytes != 8) {
920 pr_err("invalid payload size: %d (expected 8)\n", (int)n_bytes); 920 pr_err("invalid payload size: %d (expected 8)\n", (int)n_bytes);
921 retval = -EINVAL; 921 retval = -EINVAL;
922 goto exit; 922 goto exit;
923 } 923 }
924 924
925 if (copy_from_user(ictx->usb_tx_buf, buf, 8)) { 925 if (copy_from_user(ictx->usb_tx_buf, buf, 8)) {
926 retval = -EFAULT; 926 retval = -EFAULT;
927 goto exit; 927 goto exit;
928 } 928 }
929 929
930 retval = send_packet(ictx); 930 retval = send_packet(ictx);
931 if (retval) { 931 if (retval) {
932 pr_err("send packet failed!\n"); 932 pr_err("send packet failed!\n");
933 goto exit; 933 goto exit;
934 } else { 934 } else {
935 dev_dbg(ictx->dev, "%s: write %d bytes to LCD\n", 935 dev_dbg(ictx->dev, "%s: write %d bytes to LCD\n",
936 __func__, (int) n_bytes); 936 __func__, (int) n_bytes);
937 } 937 }
938 exit: 938 exit:
939 mutex_unlock(&ictx->lock); 939 mutex_unlock(&ictx->lock);
940 return (!retval) ? n_bytes : retval; 940 return (!retval) ? n_bytes : retval;
941 } 941 }
942 942
943 /** 943 /**
944 * Callback function for USB core API: transmit data 944 * Callback function for USB core API: transmit data
945 */ 945 */
946 static void usb_tx_callback(struct urb *urb) 946 static void usb_tx_callback(struct urb *urb)
947 { 947 {
948 struct imon_context *ictx; 948 struct imon_context *ictx;
949 949
950 if (!urb) 950 if (!urb)
951 return; 951 return;
952 ictx = (struct imon_context *)urb->context; 952 ictx = (struct imon_context *)urb->context;
953 if (!ictx) 953 if (!ictx)
954 return; 954 return;
955 955
956 ictx->tx.status = urb->status; 956 ictx->tx.status = urb->status;
957 957
958 /* notify waiters that write has finished */ 958 /* notify waiters that write has finished */
959 ictx->tx.busy = false; 959 ictx->tx.busy = false;
960 smp_rmb(); /* ensure later readers know we're not busy */ 960 smp_rmb(); /* ensure later readers know we're not busy */
961 complete(&ictx->tx.finished); 961 complete(&ictx->tx.finished);
962 } 962 }
963 963
964 /** 964 /**
965 * report touchscreen input 965 * report touchscreen input
966 */ 966 */
967 static void imon_touch_display_timeout(unsigned long data) 967 static void imon_touch_display_timeout(unsigned long data)
968 { 968 {
969 struct imon_context *ictx = (struct imon_context *)data; 969 struct imon_context *ictx = (struct imon_context *)data;
970 970
971 if (ictx->display_type != IMON_DISPLAY_TYPE_VGA) 971 if (ictx->display_type != IMON_DISPLAY_TYPE_VGA)
972 return; 972 return;
973 973
974 input_report_abs(ictx->touch, ABS_X, ictx->touch_x); 974 input_report_abs(ictx->touch, ABS_X, ictx->touch_x);
975 input_report_abs(ictx->touch, ABS_Y, ictx->touch_y); 975 input_report_abs(ictx->touch, ABS_Y, ictx->touch_y);
976 input_report_key(ictx->touch, BTN_TOUCH, 0x00); 976 input_report_key(ictx->touch, BTN_TOUCH, 0x00);
977 input_sync(ictx->touch); 977 input_sync(ictx->touch);
978 } 978 }
979 979
980 /** 980 /**
981 * iMON IR receivers support two different signal sets -- those used by 981 * iMON IR receivers support two different signal sets -- those used by
982 * the iMON remotes, and those used by the Windows MCE remotes (which is 982 * the iMON remotes, and those used by the Windows MCE remotes (which is
983 * really just RC-6), but only one or the other at a time, as the signals 983 * really just RC-6), but only one or the other at a time, as the signals
984 * are decoded onboard the receiver. 984 * are decoded onboard the receiver.
985 * 985 *
986 * This function gets called two different ways, one way is from 986 * This function gets called two different ways, one way is from
987 * rc_register_device, for initial protocol selection/setup, and the other is 987 * rc_register_device, for initial protocol selection/setup, and the other is
988 * via a userspace-initiated protocol change request, either by direct sysfs 988 * via a userspace-initiated protocol change request, either by direct sysfs
989 * prodding or by something like ir-keytable. In the rc_register_device case, 989 * prodding or by something like ir-keytable. In the rc_register_device case,
990 * the imon context lock is already held, but when initiated from userspace, 990 * the imon context lock is already held, but when initiated from userspace,
991 * it is not, so we must acquire it prior to calling send_packet, which 991 * it is not, so we must acquire it prior to calling send_packet, which
992 * requires that the lock is held. 992 * requires that the lock is held.
993 */ 993 */
994 static int imon_ir_change_protocol(struct rc_dev *rc, u64 rc_type) 994 static int imon_ir_change_protocol(struct rc_dev *rc, u64 rc_type)
995 { 995 {
996 int retval; 996 int retval;
997 struct imon_context *ictx = rc->priv; 997 struct imon_context *ictx = rc->priv;
998 struct device *dev = ictx->dev; 998 struct device *dev = ictx->dev;
999 bool unlock = false; 999 bool unlock = false;
1000 unsigned char ir_proto_packet[] = { 1000 unsigned char ir_proto_packet[] = {
1001 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86 }; 1001 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86 };
1002 1002
1003 if (rc_type && !(rc_type & rc->allowed_protos)) 1003 if (rc_type && !(rc_type & rc->allowed_protos))
1004 dev_warn(dev, "Looks like you're trying to use an IR protocol " 1004 dev_warn(dev, "Looks like you're trying to use an IR protocol "
1005 "this device does not support\n"); 1005 "this device does not support\n");
1006 1006
1007 switch (rc_type) { 1007 switch (rc_type) {
1008 case RC_TYPE_RC6: 1008 case RC_TYPE_RC6:
1009 dev_dbg(dev, "Configuring IR receiver for MCE protocol\n"); 1009 dev_dbg(dev, "Configuring IR receiver for MCE protocol\n");
1010 ir_proto_packet[0] = 0x01; 1010 ir_proto_packet[0] = 0x01;
1011 break; 1011 break;
1012 case RC_TYPE_UNKNOWN: 1012 case RC_TYPE_UNKNOWN:
1013 case RC_TYPE_OTHER: 1013 case RC_TYPE_OTHER:
1014 dev_dbg(dev, "Configuring IR receiver for iMON protocol\n"); 1014 dev_dbg(dev, "Configuring IR receiver for iMON protocol\n");
1015 if (!pad_stabilize) 1015 if (!pad_stabilize)
1016 dev_dbg(dev, "PAD stabilize functionality disabled\n"); 1016 dev_dbg(dev, "PAD stabilize functionality disabled\n");
1017 /* ir_proto_packet[0] = 0x00; // already the default */ 1017 /* ir_proto_packet[0] = 0x00; // already the default */
1018 rc_type = RC_TYPE_OTHER; 1018 rc_type = RC_TYPE_OTHER;
1019 break; 1019 break;
1020 default: 1020 default:
1021 dev_warn(dev, "Unsupported IR protocol specified, overriding " 1021 dev_warn(dev, "Unsupported IR protocol specified, overriding "
1022 "to iMON IR protocol\n"); 1022 "to iMON IR protocol\n");
1023 if (!pad_stabilize) 1023 if (!pad_stabilize)
1024 dev_dbg(dev, "PAD stabilize functionality disabled\n"); 1024 dev_dbg(dev, "PAD stabilize functionality disabled\n");
1025 /* ir_proto_packet[0] = 0x00; // already the default */ 1025 /* ir_proto_packet[0] = 0x00; // already the default */
1026 rc_type = RC_TYPE_OTHER; 1026 rc_type = RC_TYPE_OTHER;
1027 break; 1027 break;
1028 } 1028 }
1029 1029
1030 memcpy(ictx->usb_tx_buf, &ir_proto_packet, sizeof(ir_proto_packet)); 1030 memcpy(ictx->usb_tx_buf, &ir_proto_packet, sizeof(ir_proto_packet));
1031 1031
1032 if (!mutex_is_locked(&ictx->lock)) { 1032 if (!mutex_is_locked(&ictx->lock)) {
1033 unlock = true; 1033 unlock = true;
1034 mutex_lock(&ictx->lock); 1034 mutex_lock(&ictx->lock);
1035 } 1035 }
1036 1036
1037 retval = send_packet(ictx); 1037 retval = send_packet(ictx);
1038 if (retval) 1038 if (retval)
1039 goto out; 1039 goto out;
1040 1040
1041 ictx->rc_type = rc_type; 1041 ictx->rc_type = rc_type;
1042 ictx->pad_mouse = false; 1042 ictx->pad_mouse = false;
1043 1043
1044 out: 1044 out:
1045 if (unlock) 1045 if (unlock)
1046 mutex_unlock(&ictx->lock); 1046 mutex_unlock(&ictx->lock);
1047 1047
1048 return retval; 1048 return retval;
1049 } 1049 }
1050 1050
1051 static inline int tv2int(const struct timeval *a, const struct timeval *b) 1051 static inline int tv2int(const struct timeval *a, const struct timeval *b)
1052 { 1052 {
1053 int usecs = 0; 1053 int usecs = 0;
1054 int sec = 0; 1054 int sec = 0;
1055 1055
1056 if (b->tv_usec > a->tv_usec) { 1056 if (b->tv_usec > a->tv_usec) {
1057 usecs = 1000000; 1057 usecs = 1000000;
1058 sec--; 1058 sec--;
1059 } 1059 }
1060 1060
1061 usecs += a->tv_usec - b->tv_usec; 1061 usecs += a->tv_usec - b->tv_usec;
1062 1062
1063 sec += a->tv_sec - b->tv_sec; 1063 sec += a->tv_sec - b->tv_sec;
1064 sec *= 1000; 1064 sec *= 1000;
1065 usecs /= 1000; 1065 usecs /= 1000;
1066 sec += usecs; 1066 sec += usecs;
1067 1067
1068 if (sec < 0) 1068 if (sec < 0)
1069 sec = 1000; 1069 sec = 1000;
1070 1070
1071 return sec; 1071 return sec;
1072 } 1072 }
1073 1073
1074 /** 1074 /**
1075 * The directional pad behaves a bit differently, depending on whether this is 1075 * The directional pad behaves a bit differently, depending on whether this is
1076 * one of the older ffdc devices or a newer device. Newer devices appear to 1076 * one of the older ffdc devices or a newer device. Newer devices appear to
1077 * have a higher resolution matrix for more precise mouse movement, but it 1077 * have a higher resolution matrix for more precise mouse movement, but it
1078 * makes things overly sensitive in keyboard mode, so we do some interesting 1078 * makes things overly sensitive in keyboard mode, so we do some interesting
1079 * contortions to make it less touchy. Older devices run through the same 1079 * contortions to make it less touchy. Older devices run through the same
1080 * routine with shorter timeout and a smaller threshold. 1080 * routine with shorter timeout and a smaller threshold.
1081 */ 1081 */
1082 static int stabilize(int a, int b, u16 timeout, u16 threshold) 1082 static int stabilize(int a, int b, u16 timeout, u16 threshold)
1083 { 1083 {
1084 struct timeval ct; 1084 struct timeval ct;
1085 static struct timeval prev_time = {0, 0}; 1085 static struct timeval prev_time = {0, 0};
1086 static struct timeval hit_time = {0, 0}; 1086 static struct timeval hit_time = {0, 0};
1087 static int x, y, prev_result, hits; 1087 static int x, y, prev_result, hits;
1088 int result = 0; 1088 int result = 0;
1089 int msec, msec_hit; 1089 int msec, msec_hit;
1090 1090
1091 do_gettimeofday(&ct); 1091 do_gettimeofday(&ct);
1092 msec = tv2int(&ct, &prev_time); 1092 msec = tv2int(&ct, &prev_time);
1093 msec_hit = tv2int(&ct, &hit_time); 1093 msec_hit = tv2int(&ct, &hit_time);
1094 1094
1095 if (msec > 100) { 1095 if (msec > 100) {
1096 x = 0; 1096 x = 0;
1097 y = 0; 1097 y = 0;
1098 hits = 0; 1098 hits = 0;
1099 } 1099 }
1100 1100
1101 x += a; 1101 x += a;
1102 y += b; 1102 y += b;
1103 1103
1104 prev_time = ct; 1104 prev_time = ct;
1105 1105
1106 if (abs(x) > threshold || abs(y) > threshold) { 1106 if (abs(x) > threshold || abs(y) > threshold) {
1107 if (abs(y) > abs(x)) 1107 if (abs(y) > abs(x))
1108 result = (y > 0) ? 0x7F : 0x80; 1108 result = (y > 0) ? 0x7F : 0x80;
1109 else 1109 else
1110 result = (x > 0) ? 0x7F00 : 0x8000; 1110 result = (x > 0) ? 0x7F00 : 0x8000;
1111 1111
1112 x = 0; 1112 x = 0;
1113 y = 0; 1113 y = 0;
1114 1114
1115 if (result == prev_result) { 1115 if (result == prev_result) {
1116 hits++; 1116 hits++;
1117 1117
1118 if (hits > 3) { 1118 if (hits > 3) {
1119 switch (result) { 1119 switch (result) {
1120 case 0x7F: 1120 case 0x7F:
1121 y = 17 * threshold / 30; 1121 y = 17 * threshold / 30;
1122 break; 1122 break;
1123 case 0x80: 1123 case 0x80:
1124 y -= 17 * threshold / 30; 1124 y -= 17 * threshold / 30;
1125 break; 1125 break;
1126 case 0x7F00: 1126 case 0x7F00:
1127 x = 17 * threshold / 30; 1127 x = 17 * threshold / 30;
1128 break; 1128 break;
1129 case 0x8000: 1129 case 0x8000:
1130 x -= 17 * threshold / 30; 1130 x -= 17 * threshold / 30;
1131 break; 1131 break;
1132 } 1132 }
1133 } 1133 }
1134 1134
1135 if (hits == 2 && msec_hit < timeout) { 1135 if (hits == 2 && msec_hit < timeout) {
1136 result = 0; 1136 result = 0;
1137 hits = 1; 1137 hits = 1;
1138 } 1138 }
1139 } else { 1139 } else {
1140 prev_result = result; 1140 prev_result = result;
1141 hits = 1; 1141 hits = 1;
1142 hit_time = ct; 1142 hit_time = ct;
1143 } 1143 }
1144 } 1144 }
1145 1145
1146 return result; 1146 return result;
1147 } 1147 }
1148 1148
1149 static u32 imon_remote_key_lookup(struct imon_context *ictx, u32 scancode) 1149 static u32 imon_remote_key_lookup(struct imon_context *ictx, u32 scancode)
1150 { 1150 {
1151 u32 keycode; 1151 u32 keycode;
1152 u32 release; 1152 u32 release;
1153 bool is_release_code = false; 1153 bool is_release_code = false;
1154 1154
1155 /* Look for the initial press of a button */ 1155 /* Look for the initial press of a button */
1156 keycode = rc_g_keycode_from_table(ictx->rdev, scancode); 1156 keycode = rc_g_keycode_from_table(ictx->rdev, scancode);
1157 ictx->rc_toggle = 0x0; 1157 ictx->rc_toggle = 0x0;
1158 ictx->rc_scancode = scancode; 1158 ictx->rc_scancode = scancode;
1159 1159
1160 /* Look for the release of a button */ 1160 /* Look for the release of a button */
1161 if (keycode == KEY_RESERVED) { 1161 if (keycode == KEY_RESERVED) {
1162 release = scancode & ~0x4000; 1162 release = scancode & ~0x4000;
1163 keycode = rc_g_keycode_from_table(ictx->rdev, release); 1163 keycode = rc_g_keycode_from_table(ictx->rdev, release);
1164 if (keycode != KEY_RESERVED) 1164 if (keycode != KEY_RESERVED)
1165 is_release_code = true; 1165 is_release_code = true;
1166 } 1166 }
1167 1167
1168 ictx->release_code = is_release_code; 1168 ictx->release_code = is_release_code;
1169 1169
1170 return keycode; 1170 return keycode;
1171 } 1171 }
1172 1172
1173 static u32 imon_mce_key_lookup(struct imon_context *ictx, u32 scancode) 1173 static u32 imon_mce_key_lookup(struct imon_context *ictx, u32 scancode)
1174 { 1174 {
1175 u32 keycode; 1175 u32 keycode;
1176 1176
1177 #define MCE_KEY_MASK 0x7000 1177 #define MCE_KEY_MASK 0x7000
1178 #define MCE_TOGGLE_BIT 0x8000 1178 #define MCE_TOGGLE_BIT 0x8000
1179 1179
1180 /* 1180 /*
1181 * On some receivers, mce keys decode to 0x8000f04xx and 0x8000f84xx 1181 * On some receivers, mce keys decode to 0x8000f04xx and 0x8000f84xx
1182 * (the toggle bit flipping between alternating key presses), while 1182 * (the toggle bit flipping between alternating key presses), while
1183 * on other receivers, we see 0x8000f74xx and 0x8000ff4xx. To keep 1183 * on other receivers, we see 0x8000f74xx and 0x8000ff4xx. To keep
1184 * the table trim, we always or in the bits to look up 0x8000ff4xx, 1184 * the table trim, we always or in the bits to look up 0x8000ff4xx,
1185 * but we can't or them into all codes, as some keys are decoded in 1185 * but we can't or them into all codes, as some keys are decoded in
1186 * a different way w/o the same use of the toggle bit... 1186 * a different way w/o the same use of the toggle bit...
1187 */ 1187 */
1188 if (scancode & 0x80000000) 1188 if (scancode & 0x80000000)
1189 scancode = scancode | MCE_KEY_MASK | MCE_TOGGLE_BIT; 1189 scancode = scancode | MCE_KEY_MASK | MCE_TOGGLE_BIT;
1190 1190
1191 ictx->rc_scancode = scancode; 1191 ictx->rc_scancode = scancode;
1192 keycode = rc_g_keycode_from_table(ictx->rdev, scancode); 1192 keycode = rc_g_keycode_from_table(ictx->rdev, scancode);
1193 1193
1194 /* not used in mce mode, but make sure we know its false */ 1194 /* not used in mce mode, but make sure we know its false */
1195 ictx->release_code = false; 1195 ictx->release_code = false;
1196 1196
1197 return keycode; 1197 return keycode;
1198 } 1198 }
1199 1199
1200 static u32 imon_panel_key_lookup(u64 code) 1200 static u32 imon_panel_key_lookup(u64 code)
1201 { 1201 {
1202 int i; 1202 int i;
1203 u32 keycode = KEY_RESERVED; 1203 u32 keycode = KEY_RESERVED;
1204 1204
1205 for (i = 0; i < ARRAY_SIZE(imon_panel_key_table); i++) { 1205 for (i = 0; i < ARRAY_SIZE(imon_panel_key_table); i++) {
1206 if (imon_panel_key_table[i].hw_code == (code | 0xffee)) { 1206 if (imon_panel_key_table[i].hw_code == (code | 0xffee)) {
1207 keycode = imon_panel_key_table[i].keycode; 1207 keycode = imon_panel_key_table[i].keycode;
1208 break; 1208 break;
1209 } 1209 }
1210 } 1210 }
1211 1211
1212 return keycode; 1212 return keycode;
1213 } 1213 }
1214 1214
1215 static bool imon_mouse_event(struct imon_context *ictx, 1215 static bool imon_mouse_event(struct imon_context *ictx,
1216 unsigned char *buf, int len) 1216 unsigned char *buf, int len)
1217 { 1217 {
1218 char rel_x = 0x00, rel_y = 0x00; 1218 char rel_x = 0x00, rel_y = 0x00;
1219 u8 right_shift = 1; 1219 u8 right_shift = 1;
1220 bool mouse_input = true; 1220 bool mouse_input = true;
1221 int dir = 0; 1221 int dir = 0;
1222 unsigned long flags; 1222 unsigned long flags;
1223 1223
1224 spin_lock_irqsave(&ictx->kc_lock, flags); 1224 spin_lock_irqsave(&ictx->kc_lock, flags);
1225 1225
1226 /* newer iMON device PAD or mouse button */ 1226 /* newer iMON device PAD or mouse button */
1227 if (ictx->product != 0xffdc && (buf[0] & 0x01) && len == 5) { 1227 if (ictx->product != 0xffdc && (buf[0] & 0x01) && len == 5) {
1228 rel_x = buf[2]; 1228 rel_x = buf[2];
1229 rel_y = buf[3]; 1229 rel_y = buf[3];
1230 right_shift = 1; 1230 right_shift = 1;
1231 /* 0xffdc iMON PAD or mouse button input */ 1231 /* 0xffdc iMON PAD or mouse button input */
1232 } else if (ictx->product == 0xffdc && (buf[0] & 0x40) && 1232 } else if (ictx->product == 0xffdc && (buf[0] & 0x40) &&
1233 !((buf[1] & 0x01) || ((buf[1] >> 2) & 0x01))) { 1233 !((buf[1] & 0x01) || ((buf[1] >> 2) & 0x01))) {
1234 rel_x = (buf[1] & 0x08) | (buf[1] & 0x10) >> 2 | 1234 rel_x = (buf[1] & 0x08) | (buf[1] & 0x10) >> 2 |
1235 (buf[1] & 0x20) >> 4 | (buf[1] & 0x40) >> 6; 1235 (buf[1] & 0x20) >> 4 | (buf[1] & 0x40) >> 6;
1236 if (buf[0] & 0x02) 1236 if (buf[0] & 0x02)
1237 rel_x |= ~0x0f; 1237 rel_x |= ~0x0f;
1238 rel_x = rel_x + rel_x / 2; 1238 rel_x = rel_x + rel_x / 2;
1239 rel_y = (buf[2] & 0x08) | (buf[2] & 0x10) >> 2 | 1239 rel_y = (buf[2] & 0x08) | (buf[2] & 0x10) >> 2 |
1240 (buf[2] & 0x20) >> 4 | (buf[2] & 0x40) >> 6; 1240 (buf[2] & 0x20) >> 4 | (buf[2] & 0x40) >> 6;
1241 if (buf[0] & 0x01) 1241 if (buf[0] & 0x01)
1242 rel_y |= ~0x0f; 1242 rel_y |= ~0x0f;
1243 rel_y = rel_y + rel_y / 2; 1243 rel_y = rel_y + rel_y / 2;
1244 right_shift = 2; 1244 right_shift = 2;
1245 /* some ffdc devices decode mouse buttons differently... */ 1245 /* some ffdc devices decode mouse buttons differently... */
1246 } else if (ictx->product == 0xffdc && (buf[0] == 0x68)) { 1246 } else if (ictx->product == 0xffdc && (buf[0] == 0x68)) {
1247 right_shift = 2; 1247 right_shift = 2;
1248 /* ch+/- buttons, which we use for an emulated scroll wheel */ 1248 /* ch+/- buttons, which we use for an emulated scroll wheel */
1249 } else if (ictx->kc == KEY_CHANNELUP && (buf[2] & 0x40) != 0x40) { 1249 } else if (ictx->kc == KEY_CHANNELUP && (buf[2] & 0x40) != 0x40) {
1250 dir = 1; 1250 dir = 1;
1251 } else if (ictx->kc == KEY_CHANNELDOWN && (buf[2] & 0x40) != 0x40) { 1251 } else if (ictx->kc == KEY_CHANNELDOWN && (buf[2] & 0x40) != 0x40) {
1252 dir = -1; 1252 dir = -1;
1253 } else 1253 } else
1254 mouse_input = false; 1254 mouse_input = false;
1255 1255
1256 spin_unlock_irqrestore(&ictx->kc_lock, flags); 1256 spin_unlock_irqrestore(&ictx->kc_lock, flags);
1257 1257
1258 if (mouse_input) { 1258 if (mouse_input) {
1259 dev_dbg(ictx->dev, "sending mouse data via input subsystem\n"); 1259 dev_dbg(ictx->dev, "sending mouse data via input subsystem\n");
1260 1260
1261 if (dir) { 1261 if (dir) {
1262 input_report_rel(ictx->idev, REL_WHEEL, dir); 1262 input_report_rel(ictx->idev, REL_WHEEL, dir);
1263 } else if (rel_x || rel_y) { 1263 } else if (rel_x || rel_y) {
1264 input_report_rel(ictx->idev, REL_X, rel_x); 1264 input_report_rel(ictx->idev, REL_X, rel_x);
1265 input_report_rel(ictx->idev, REL_Y, rel_y); 1265 input_report_rel(ictx->idev, REL_Y, rel_y);
1266 } else { 1266 } else {
1267 input_report_key(ictx->idev, BTN_LEFT, buf[1] & 0x1); 1267 input_report_key(ictx->idev, BTN_LEFT, buf[1] & 0x1);
1268 input_report_key(ictx->idev, BTN_RIGHT, 1268 input_report_key(ictx->idev, BTN_RIGHT,
1269 buf[1] >> right_shift & 0x1); 1269 buf[1] >> right_shift & 0x1);
1270 } 1270 }
1271 input_sync(ictx->idev); 1271 input_sync(ictx->idev);
1272 spin_lock_irqsave(&ictx->kc_lock, flags); 1272 spin_lock_irqsave(&ictx->kc_lock, flags);
1273 ictx->last_keycode = ictx->kc; 1273 ictx->last_keycode = ictx->kc;
1274 spin_unlock_irqrestore(&ictx->kc_lock, flags); 1274 spin_unlock_irqrestore(&ictx->kc_lock, flags);
1275 } 1275 }
1276 1276
1277 return mouse_input; 1277 return mouse_input;
1278 } 1278 }
1279 1279
1280 static void imon_touch_event(struct imon_context *ictx, unsigned char *buf) 1280 static void imon_touch_event(struct imon_context *ictx, unsigned char *buf)
1281 { 1281 {
1282 mod_timer(&ictx->ttimer, jiffies + TOUCH_TIMEOUT); 1282 mod_timer(&ictx->ttimer, jiffies + TOUCH_TIMEOUT);
1283 ictx->touch_x = (buf[0] << 4) | (buf[1] >> 4); 1283 ictx->touch_x = (buf[0] << 4) | (buf[1] >> 4);
1284 ictx->touch_y = 0xfff - ((buf[2] << 4) | (buf[1] & 0xf)); 1284 ictx->touch_y = 0xfff - ((buf[2] << 4) | (buf[1] & 0xf));
1285 input_report_abs(ictx->touch, ABS_X, ictx->touch_x); 1285 input_report_abs(ictx->touch, ABS_X, ictx->touch_x);
1286 input_report_abs(ictx->touch, ABS_Y, ictx->touch_y); 1286 input_report_abs(ictx->touch, ABS_Y, ictx->touch_y);
1287 input_report_key(ictx->touch, BTN_TOUCH, 0x01); 1287 input_report_key(ictx->touch, BTN_TOUCH, 0x01);
1288 input_sync(ictx->touch); 1288 input_sync(ictx->touch);
1289 } 1289 }
1290 1290
1291 static void imon_pad_to_keys(struct imon_context *ictx, unsigned char *buf) 1291 static void imon_pad_to_keys(struct imon_context *ictx, unsigned char *buf)
1292 { 1292 {
1293 int dir = 0; 1293 int dir = 0;
1294 char rel_x = 0x00, rel_y = 0x00; 1294 char rel_x = 0x00, rel_y = 0x00;
1295 u16 timeout, threshold; 1295 u16 timeout, threshold;
1296 u32 scancode = KEY_RESERVED; 1296 u32 scancode = KEY_RESERVED;
1297 unsigned long flags; 1297 unsigned long flags;
1298 1298
1299 /* 1299 /*
1300 * The imon directional pad functions more like a touchpad. Bytes 3 & 4 1300 * The imon directional pad functions more like a touchpad. Bytes 3 & 4
1301 * contain a position coordinate (x,y), with each component ranging 1301 * contain a position coordinate (x,y), with each component ranging
1302 * from -14 to 14. We want to down-sample this to only 4 discrete values 1302 * from -14 to 14. We want to down-sample this to only 4 discrete values
1303 * for up/down/left/right arrow keys. Also, when you get too close to 1303 * for up/down/left/right arrow keys. Also, when you get too close to
1304 * diagonals, it has a tendency to jump back and forth, so lets try to 1304 * diagonals, it has a tendency to jump back and forth, so lets try to
1305 * ignore when they get too close. 1305 * ignore when they get too close.
1306 */ 1306 */
1307 if (ictx->product != 0xffdc) { 1307 if (ictx->product != 0xffdc) {
1308 /* first, pad to 8 bytes so it conforms with everything else */ 1308 /* first, pad to 8 bytes so it conforms with everything else */
1309 buf[5] = buf[6] = buf[7] = 0; 1309 buf[5] = buf[6] = buf[7] = 0;
1310 timeout = 500; /* in msecs */ 1310 timeout = 500; /* in msecs */
1311 /* (2*threshold) x (2*threshold) square */ 1311 /* (2*threshold) x (2*threshold) square */
1312 threshold = pad_thresh ? pad_thresh : 28; 1312 threshold = pad_thresh ? pad_thresh : 28;
1313 rel_x = buf[2]; 1313 rel_x = buf[2];
1314 rel_y = buf[3]; 1314 rel_y = buf[3];
1315 1315
1316 if (ictx->rc_type == RC_TYPE_OTHER && pad_stabilize) { 1316 if (ictx->rc_type == RC_TYPE_OTHER && pad_stabilize) {
1317 if ((buf[1] == 0) && ((rel_x != 0) || (rel_y != 0))) { 1317 if ((buf[1] == 0) && ((rel_x != 0) || (rel_y != 0))) {
1318 dir = stabilize((int)rel_x, (int)rel_y, 1318 dir = stabilize((int)rel_x, (int)rel_y,
1319 timeout, threshold); 1319 timeout, threshold);
1320 if (!dir) { 1320 if (!dir) {
1321 spin_lock_irqsave(&ictx->kc_lock, 1321 spin_lock_irqsave(&ictx->kc_lock,
1322 flags); 1322 flags);
1323 ictx->kc = KEY_UNKNOWN; 1323 ictx->kc = KEY_UNKNOWN;
1324 spin_unlock_irqrestore(&ictx->kc_lock, 1324 spin_unlock_irqrestore(&ictx->kc_lock,
1325 flags); 1325 flags);
1326 return; 1326 return;
1327 } 1327 }
1328 buf[2] = dir & 0xFF; 1328 buf[2] = dir & 0xFF;
1329 buf[3] = (dir >> 8) & 0xFF; 1329 buf[3] = (dir >> 8) & 0xFF;
1330 scancode = be32_to_cpu(*((u32 *)buf)); 1330 scancode = be32_to_cpu(*((u32 *)buf));
1331 } 1331 }
1332 } else { 1332 } else {
1333 /* 1333 /*
1334 * Hack alert: instead of using keycodes, we have 1334 * Hack alert: instead of using keycodes, we have
1335 * to use hard-coded scancodes here... 1335 * to use hard-coded scancodes here...
1336 */ 1336 */
1337 if (abs(rel_y) > abs(rel_x)) { 1337 if (abs(rel_y) > abs(rel_x)) {
1338 buf[2] = (rel_y > 0) ? 0x7F : 0x80; 1338 buf[2] = (rel_y > 0) ? 0x7F : 0x80;
1339 buf[3] = 0; 1339 buf[3] = 0;
1340 if (rel_y > 0) 1340 if (rel_y > 0)
1341 scancode = 0x01007f00; /* KEY_DOWN */ 1341 scancode = 0x01007f00; /* KEY_DOWN */
1342 else 1342 else
1343 scancode = 0x01008000; /* KEY_UP */ 1343 scancode = 0x01008000; /* KEY_UP */
1344 } else { 1344 } else {
1345 buf[2] = 0; 1345 buf[2] = 0;
1346 buf[3] = (rel_x > 0) ? 0x7F : 0x80; 1346 buf[3] = (rel_x > 0) ? 0x7F : 0x80;
1347 if (rel_x > 0) 1347 if (rel_x > 0)
1348 scancode = 0x0100007f; /* KEY_RIGHT */ 1348 scancode = 0x0100007f; /* KEY_RIGHT */
1349 else 1349 else
1350 scancode = 0x01000080; /* KEY_LEFT */ 1350 scancode = 0x01000080; /* KEY_LEFT */
1351 } 1351 }
1352 } 1352 }
1353 1353
1354 /* 1354 /*
1355 * Handle on-board decoded pad events for e.g. older VFD/iMON-Pad 1355 * Handle on-board decoded pad events for e.g. older VFD/iMON-Pad
1356 * device (15c2:ffdc). The remote generates various codes from 1356 * device (15c2:ffdc). The remote generates various codes from
1357 * 0x68nnnnB7 to 0x6AnnnnB7, the left mouse button generates 1357 * 0x68nnnnB7 to 0x6AnnnnB7, the left mouse button generates
1358 * 0x688301b7 and the right one 0x688481b7. All other keys generate 1358 * 0x688301b7 and the right one 0x688481b7. All other keys generate
1359 * 0x2nnnnnnn. Position coordinate is encoded in buf[1] and buf[2] with 1359 * 0x2nnnnnnn. Position coordinate is encoded in buf[1] and buf[2] with
1360 * reversed endianess. Extract direction from buffer, rotate endianess, 1360 * reversed endianess. Extract direction from buffer, rotate endianess,
1361 * adjust sign and feed the values into stabilize(). The resulting codes 1361 * adjust sign and feed the values into stabilize(). The resulting codes
1362 * will be 0x01008000, 0x01007F00, which match the newer devices. 1362 * will be 0x01008000, 0x01007F00, which match the newer devices.
1363 */ 1363 */
1364 } else { 1364 } else {
1365 timeout = 10; /* in msecs */ 1365 timeout = 10; /* in msecs */
1366 /* (2*threshold) x (2*threshold) square */ 1366 /* (2*threshold) x (2*threshold) square */
1367 threshold = pad_thresh ? pad_thresh : 15; 1367 threshold = pad_thresh ? pad_thresh : 15;
1368 1368
1369 /* buf[1] is x */ 1369 /* buf[1] is x */
1370 rel_x = (buf[1] & 0x08) | (buf[1] & 0x10) >> 2 | 1370 rel_x = (buf[1] & 0x08) | (buf[1] & 0x10) >> 2 |
1371 (buf[1] & 0x20) >> 4 | (buf[1] & 0x40) >> 6; 1371 (buf[1] & 0x20) >> 4 | (buf[1] & 0x40) >> 6;
1372 if (buf[0] & 0x02) 1372 if (buf[0] & 0x02)
1373 rel_x |= ~0x10+1; 1373 rel_x |= ~0x10+1;
1374 /* buf[2] is y */ 1374 /* buf[2] is y */
1375 rel_y = (buf[2] & 0x08) | (buf[2] & 0x10) >> 2 | 1375 rel_y = (buf[2] & 0x08) | (buf[2] & 0x10) >> 2 |
1376 (buf[2] & 0x20) >> 4 | (buf[2] & 0x40) >> 6; 1376 (buf[2] & 0x20) >> 4 | (buf[2] & 0x40) >> 6;
1377 if (buf[0] & 0x01) 1377 if (buf[0] & 0x01)
1378 rel_y |= ~0x10+1; 1378 rel_y |= ~0x10+1;
1379 1379
1380 buf[0] = 0x01; 1380 buf[0] = 0x01;
1381 buf[1] = buf[4] = buf[5] = buf[6] = buf[7] = 0; 1381 buf[1] = buf[4] = buf[5] = buf[6] = buf[7] = 0;
1382 1382
1383 if (ictx->rc_type == RC_TYPE_OTHER && pad_stabilize) { 1383 if (ictx->rc_type == RC_TYPE_OTHER && pad_stabilize) {
1384 dir = stabilize((int)rel_x, (int)rel_y, 1384 dir = stabilize((int)rel_x, (int)rel_y,
1385 timeout, threshold); 1385 timeout, threshold);
1386 if (!dir) { 1386 if (!dir) {
1387 spin_lock_irqsave(&ictx->kc_lock, flags); 1387 spin_lock_irqsave(&ictx->kc_lock, flags);
1388 ictx->kc = KEY_UNKNOWN; 1388 ictx->kc = KEY_UNKNOWN;
1389 spin_unlock_irqrestore(&ictx->kc_lock, flags); 1389 spin_unlock_irqrestore(&ictx->kc_lock, flags);
1390 return; 1390 return;
1391 } 1391 }
1392 buf[2] = dir & 0xFF; 1392 buf[2] = dir & 0xFF;
1393 buf[3] = (dir >> 8) & 0xFF; 1393 buf[3] = (dir >> 8) & 0xFF;
1394 scancode = be32_to_cpu(*((u32 *)buf)); 1394 scancode = be32_to_cpu(*((u32 *)buf));
1395 } else { 1395 } else {
1396 /* 1396 /*
1397 * Hack alert: instead of using keycodes, we have 1397 * Hack alert: instead of using keycodes, we have
1398 * to use hard-coded scancodes here... 1398 * to use hard-coded scancodes here...
1399 */ 1399 */
1400 if (abs(rel_y) > abs(rel_x)) { 1400 if (abs(rel_y) > abs(rel_x)) {
1401 buf[2] = (rel_y > 0) ? 0x7F : 0x80; 1401 buf[2] = (rel_y > 0) ? 0x7F : 0x80;
1402 buf[3] = 0; 1402 buf[3] = 0;
1403 if (rel_y > 0) 1403 if (rel_y > 0)
1404 scancode = 0x01007f00; /* KEY_DOWN */ 1404 scancode = 0x01007f00; /* KEY_DOWN */
1405 else 1405 else
1406 scancode = 0x01008000; /* KEY_UP */ 1406 scancode = 0x01008000; /* KEY_UP */
1407 } else { 1407 } else {
1408 buf[2] = 0; 1408 buf[2] = 0;
1409 buf[3] = (rel_x > 0) ? 0x7F : 0x80; 1409 buf[3] = (rel_x > 0) ? 0x7F : 0x80;
1410 if (rel_x > 0) 1410 if (rel_x > 0)
1411 scancode = 0x0100007f; /* KEY_RIGHT */ 1411 scancode = 0x0100007f; /* KEY_RIGHT */
1412 else 1412 else
1413 scancode = 0x01000080; /* KEY_LEFT */ 1413 scancode = 0x01000080; /* KEY_LEFT */
1414 } 1414 }
1415 } 1415 }
1416 } 1416 }
1417 1417
1418 if (scancode) { 1418 if (scancode) {
1419 spin_lock_irqsave(&ictx->kc_lock, flags); 1419 spin_lock_irqsave(&ictx->kc_lock, flags);
1420 ictx->kc = imon_remote_key_lookup(ictx, scancode); 1420 ictx->kc = imon_remote_key_lookup(ictx, scancode);
1421 spin_unlock_irqrestore(&ictx->kc_lock, flags); 1421 spin_unlock_irqrestore(&ictx->kc_lock, flags);
1422 } 1422 }
1423 } 1423 }
1424 1424
1425 /** 1425 /**
1426 * figure out if these is a press or a release. We don't actually 1426 * figure out if these is a press or a release. We don't actually
1427 * care about repeats, as those will be auto-generated within the IR 1427 * care about repeats, as those will be auto-generated within the IR
1428 * subsystem for repeating scancodes. 1428 * subsystem for repeating scancodes.
1429 */ 1429 */
1430 static int imon_parse_press_type(struct imon_context *ictx, 1430 static int imon_parse_press_type(struct imon_context *ictx,
1431 unsigned char *buf, u8 ktype) 1431 unsigned char *buf, u8 ktype)
1432 { 1432 {
1433 int press_type = 0; 1433 int press_type = 0;
1434 unsigned long flags; 1434 unsigned long flags;
1435 1435
1436 spin_lock_irqsave(&ictx->kc_lock, flags); 1436 spin_lock_irqsave(&ictx->kc_lock, flags);
1437 1437
1438 /* key release of 0x02XXXXXX key */ 1438 /* key release of 0x02XXXXXX key */
1439 if (ictx->kc == KEY_RESERVED && buf[0] == 0x02 && buf[3] == 0x00) 1439 if (ictx->kc == KEY_RESERVED && buf[0] == 0x02 && buf[3] == 0x00)
1440 ictx->kc = ictx->last_keycode; 1440 ictx->kc = ictx->last_keycode;
1441 1441
1442 /* mouse button release on (some) 0xffdc devices */ 1442 /* mouse button release on (some) 0xffdc devices */
1443 else if (ictx->kc == KEY_RESERVED && buf[0] == 0x68 && buf[1] == 0x82 && 1443 else if (ictx->kc == KEY_RESERVED && buf[0] == 0x68 && buf[1] == 0x82 &&
1444 buf[2] == 0x81 && buf[3] == 0xb7) 1444 buf[2] == 0x81 && buf[3] == 0xb7)
1445 ictx->kc = ictx->last_keycode; 1445 ictx->kc = ictx->last_keycode;
1446 1446
1447 /* mouse button release on (some other) 0xffdc devices */ 1447 /* mouse button release on (some other) 0xffdc devices */
1448 else if (ictx->kc == KEY_RESERVED && buf[0] == 0x01 && buf[1] == 0x00 && 1448 else if (ictx->kc == KEY_RESERVED && buf[0] == 0x01 && buf[1] == 0x00 &&
1449 buf[2] == 0x81 && buf[3] == 0xb7) 1449 buf[2] == 0x81 && buf[3] == 0xb7)
1450 ictx->kc = ictx->last_keycode; 1450 ictx->kc = ictx->last_keycode;
1451 1451
1452 /* mce-specific button handling, no keyup events */ 1452 /* mce-specific button handling, no keyup events */
1453 else if (ktype == IMON_KEY_MCE) { 1453 else if (ktype == IMON_KEY_MCE) {
1454 ictx->rc_toggle = buf[2]; 1454 ictx->rc_toggle = buf[2];
1455 press_type = 1; 1455 press_type = 1;
1456 1456
1457 /* incoherent or irrelevant data */ 1457 /* incoherent or irrelevant data */
1458 } else if (ictx->kc == KEY_RESERVED) 1458 } else if (ictx->kc == KEY_RESERVED)
1459 press_type = -EINVAL; 1459 press_type = -EINVAL;
1460 1460
1461 /* key release of 0xXXXXXXb7 key */ 1461 /* key release of 0xXXXXXXb7 key */
1462 else if (ictx->release_code) 1462 else if (ictx->release_code)
1463 press_type = 0; 1463 press_type = 0;
1464 1464
1465 /* this is a button press */ 1465 /* this is a button press */
1466 else 1466 else
1467 press_type = 1; 1467 press_type = 1;
1468 1468
1469 spin_unlock_irqrestore(&ictx->kc_lock, flags); 1469 spin_unlock_irqrestore(&ictx->kc_lock, flags);
1470 1470
1471 return press_type; 1471 return press_type;
1472 } 1472 }
1473 1473
1474 /** 1474 /**
1475 * Process the incoming packet 1475 * Process the incoming packet
1476 */ 1476 */
1477 static void imon_incoming_packet(struct imon_context *ictx, 1477 static void imon_incoming_packet(struct imon_context *ictx,
1478 struct urb *urb, int intf) 1478 struct urb *urb, int intf)
1479 { 1479 {
1480 int len = urb->actual_length; 1480 int len = urb->actual_length;
1481 unsigned char *buf = urb->transfer_buffer; 1481 unsigned char *buf = urb->transfer_buffer;
1482 struct device *dev = ictx->dev; 1482 struct device *dev = ictx->dev;
1483 unsigned long flags; 1483 unsigned long flags;
1484 u32 kc; 1484 u32 kc;
1485 int i; 1485 int i;
1486 u64 scancode; 1486 u64 scancode;
1487 int press_type = 0; 1487 int press_type = 0;
1488 int msec; 1488 int msec;
1489 struct timeval t; 1489 struct timeval t;
1490 static struct timeval prev_time = { 0, 0 }; 1490 static struct timeval prev_time = { 0, 0 };
1491 u8 ktype; 1491 u8 ktype;
1492 1492
1493 /* filter out junk data on the older 0xffdc imon devices */ 1493 /* filter out junk data on the older 0xffdc imon devices */
1494 if ((buf[0] == 0xff) && (buf[1] == 0xff) && (buf[2] == 0xff)) 1494 if ((buf[0] == 0xff) && (buf[1] == 0xff) && (buf[2] == 0xff))
1495 return; 1495 return;
1496 1496
1497 /* Figure out what key was pressed */ 1497 /* Figure out what key was pressed */
1498 if (len == 8 && buf[7] == 0xee) { 1498 if (len == 8 && buf[7] == 0xee) {
1499 scancode = be64_to_cpu(*((u64 *)buf)); 1499 scancode = be64_to_cpu(*((u64 *)buf));
1500 ktype = IMON_KEY_PANEL; 1500 ktype = IMON_KEY_PANEL;
1501 kc = imon_panel_key_lookup(scancode); 1501 kc = imon_panel_key_lookup(scancode);
1502 } else { 1502 } else {
1503 scancode = be32_to_cpu(*((u32 *)buf)); 1503 scancode = be32_to_cpu(*((u32 *)buf));
1504 if (ictx->rc_type == RC_TYPE_RC6) { 1504 if (ictx->rc_type == RC_TYPE_RC6) {
1505 ktype = IMON_KEY_IMON; 1505 ktype = IMON_KEY_IMON;
1506 if (buf[0] == 0x80) 1506 if (buf[0] == 0x80)
1507 ktype = IMON_KEY_MCE; 1507 ktype = IMON_KEY_MCE;
1508 kc = imon_mce_key_lookup(ictx, scancode); 1508 kc = imon_mce_key_lookup(ictx, scancode);
1509 } else { 1509 } else {
1510 ktype = IMON_KEY_IMON; 1510 ktype = IMON_KEY_IMON;
1511 kc = imon_remote_key_lookup(ictx, scancode); 1511 kc = imon_remote_key_lookup(ictx, scancode);
1512 } 1512 }
1513 } 1513 }
1514 1514
1515 spin_lock_irqsave(&ictx->kc_lock, flags); 1515 spin_lock_irqsave(&ictx->kc_lock, flags);
1516 /* keyboard/mouse mode toggle button */ 1516 /* keyboard/mouse mode toggle button */
1517 if (kc == KEY_KEYBOARD && !ictx->release_code) { 1517 if (kc == KEY_KEYBOARD && !ictx->release_code) {
1518 ictx->last_keycode = kc; 1518 ictx->last_keycode = kc;
1519 if (!nomouse) { 1519 if (!nomouse) {
1520 ictx->pad_mouse = ~(ictx->pad_mouse) & 0x1; 1520 ictx->pad_mouse = ~(ictx->pad_mouse) & 0x1;
1521 dev_dbg(dev, "toggling to %s mode\n", 1521 dev_dbg(dev, "toggling to %s mode\n",
1522 ictx->pad_mouse ? "mouse" : "keyboard"); 1522 ictx->pad_mouse ? "mouse" : "keyboard");
1523 spin_unlock_irqrestore(&ictx->kc_lock, flags); 1523 spin_unlock_irqrestore(&ictx->kc_lock, flags);
1524 return; 1524 return;
1525 } else { 1525 } else {
1526 ictx->pad_mouse = false; 1526 ictx->pad_mouse = false;
1527 dev_dbg(dev, "mouse mode disabled, passing key value\n"); 1527 dev_dbg(dev, "mouse mode disabled, passing key value\n");
1528 } 1528 }
1529 } 1529 }
1530 1530
1531 ictx->kc = kc; 1531 ictx->kc = kc;
1532 spin_unlock_irqrestore(&ictx->kc_lock, flags); 1532 spin_unlock_irqrestore(&ictx->kc_lock, flags);
1533 1533
1534 /* send touchscreen events through input subsystem if touchpad data */ 1534 /* send touchscreen events through input subsystem if touchpad data */
1535 if (ictx->display_type == IMON_DISPLAY_TYPE_VGA && len == 8 && 1535 if (ictx->display_type == IMON_DISPLAY_TYPE_VGA && len == 8 &&
1536 buf[7] == 0x86) { 1536 buf[7] == 0x86) {
1537 imon_touch_event(ictx, buf); 1537 imon_touch_event(ictx, buf);
1538 return; 1538 return;
1539 1539
1540 /* look for mouse events with pad in mouse mode */ 1540 /* look for mouse events with pad in mouse mode */
1541 } else if (ictx->pad_mouse) { 1541 } else if (ictx->pad_mouse) {
1542 if (imon_mouse_event(ictx, buf, len)) 1542 if (imon_mouse_event(ictx, buf, len))
1543 return; 1543 return;
1544 } 1544 }
1545 1545
1546 /* Now for some special handling to convert pad input to arrow keys */ 1546 /* Now for some special handling to convert pad input to arrow keys */
1547 if (((len == 5) && (buf[0] == 0x01) && (buf[4] == 0x00)) || 1547 if (((len == 5) && (buf[0] == 0x01) && (buf[4] == 0x00)) ||
1548 ((len == 8) && (buf[0] & 0x40) && 1548 ((len == 8) && (buf[0] & 0x40) &&
1549 !(buf[1] & 0x1 || buf[1] >> 2 & 0x1))) { 1549 !(buf[1] & 0x1 || buf[1] >> 2 & 0x1))) {
1550 len = 8; 1550 len = 8;
1551 imon_pad_to_keys(ictx, buf); 1551 imon_pad_to_keys(ictx, buf);
1552 } 1552 }
1553 1553
1554 if (debug) { 1554 if (debug) {
1555 printk(KERN_INFO "intf%d decoded packet: ", intf); 1555 printk(KERN_INFO "intf%d decoded packet: ", intf);
1556 for (i = 0; i < len; ++i) 1556 for (i = 0; i < len; ++i)
1557 printk("%02x ", buf[i]); 1557 printk("%02x ", buf[i]);
1558 printk("\n"); 1558 printk("\n");
1559 } 1559 }
1560 1560
1561 press_type = imon_parse_press_type(ictx, buf, ktype); 1561 press_type = imon_parse_press_type(ictx, buf, ktype);
1562 if (press_type < 0) 1562 if (press_type < 0)
1563 goto not_input_data; 1563 goto not_input_data;
1564 1564
1565 spin_lock_irqsave(&ictx->kc_lock, flags); 1565 spin_lock_irqsave(&ictx->kc_lock, flags);
1566 if (ictx->kc == KEY_UNKNOWN) 1566 if (ictx->kc == KEY_UNKNOWN)
1567 goto unknown_key; 1567 goto unknown_key;
1568 spin_unlock_irqrestore(&ictx->kc_lock, flags); 1568 spin_unlock_irqrestore(&ictx->kc_lock, flags);
1569 1569
1570 if (ktype != IMON_KEY_PANEL) { 1570 if (ktype != IMON_KEY_PANEL) {
1571 if (press_type == 0) 1571 if (press_type == 0)
1572 rc_keyup(ictx->rdev); 1572 rc_keyup(ictx->rdev);
1573 else { 1573 else {
1574 rc_keydown(ictx->rdev, ictx->rc_scancode, ictx->rc_toggle); 1574 rc_keydown(ictx->rdev, ictx->rc_scancode, ictx->rc_toggle);
1575 spin_lock_irqsave(&ictx->kc_lock, flags); 1575 spin_lock_irqsave(&ictx->kc_lock, flags);
1576 ictx->last_keycode = ictx->kc; 1576 ictx->last_keycode = ictx->kc;
1577 spin_unlock_irqrestore(&ictx->kc_lock, flags); 1577 spin_unlock_irqrestore(&ictx->kc_lock, flags);
1578 } 1578 }
1579 return; 1579 return;
1580 } 1580 }
1581 1581
1582 /* Only panel type events left to process now */ 1582 /* Only panel type events left to process now */
1583 spin_lock_irqsave(&ictx->kc_lock, flags); 1583 spin_lock_irqsave(&ictx->kc_lock, flags);
1584 1584
1585 /* KEY_MUTE repeats from knob need to be suppressed */ 1585 /* KEY_MUTE repeats from knob need to be suppressed */
1586 if (ictx->kc == KEY_MUTE && ictx->kc == ictx->last_keycode) { 1586 if (ictx->kc == KEY_MUTE && ictx->kc == ictx->last_keycode) {
1587 do_gettimeofday(&t); 1587 do_gettimeofday(&t);
1588 msec = tv2int(&t, &prev_time); 1588 msec = tv2int(&t, &prev_time);
1589 prev_time = t; 1589 prev_time = t;
1590 if (msec < ictx->idev->rep[REP_DELAY]) { 1590 if (msec < ictx->idev->rep[REP_DELAY]) {
1591 spin_unlock_irqrestore(&ictx->kc_lock, flags); 1591 spin_unlock_irqrestore(&ictx->kc_lock, flags);
1592 return; 1592 return;
1593 } 1593 }
1594 } 1594 }
1595 kc = ictx->kc; 1595 kc = ictx->kc;
1596 1596
1597 spin_unlock_irqrestore(&ictx->kc_lock, flags); 1597 spin_unlock_irqrestore(&ictx->kc_lock, flags);
1598 1598
1599 input_report_key(ictx->idev, kc, press_type); 1599 input_report_key(ictx->idev, kc, press_type);
1600 input_sync(ictx->idev); 1600 input_sync(ictx->idev);
1601 1601
1602 /* panel keys don't generate a release */ 1602 /* panel keys don't generate a release */
1603 input_report_key(ictx->idev, kc, 0); 1603 input_report_key(ictx->idev, kc, 0);
1604 input_sync(ictx->idev); 1604 input_sync(ictx->idev);
1605 1605
1606 ictx->last_keycode = kc; 1606 ictx->last_keycode = kc;
1607 1607
1608 return; 1608 return;
1609 1609
1610 unknown_key: 1610 unknown_key:
1611 spin_unlock_irqrestore(&ictx->kc_lock, flags); 1611 spin_unlock_irqrestore(&ictx->kc_lock, flags);
1612 dev_info(dev, "%s: unknown keypress, code 0x%llx\n", __func__, 1612 dev_info(dev, "%s: unknown keypress, code 0x%llx\n", __func__,
1613 (long long)scancode); 1613 (long long)scancode);
1614 return; 1614 return;
1615 1615
1616 not_input_data: 1616 not_input_data:
1617 if (len != 8) { 1617 if (len != 8) {
1618 dev_warn(dev, "imon %s: invalid incoming packet " 1618 dev_warn(dev, "imon %s: invalid incoming packet "
1619 "size (len = %d, intf%d)\n", __func__, len, intf); 1619 "size (len = %d, intf%d)\n", __func__, len, intf);
1620 return; 1620 return;
1621 } 1621 }
1622 1622
1623 /* iMON 2.4G associate frame */ 1623 /* iMON 2.4G associate frame */
1624 if (buf[0] == 0x00 && 1624 if (buf[0] == 0x00 &&
1625 buf[2] == 0xFF && /* REFID */ 1625 buf[2] == 0xFF && /* REFID */
1626 buf[3] == 0xFF && 1626 buf[3] == 0xFF &&
1627 buf[4] == 0xFF && 1627 buf[4] == 0xFF &&
1628 buf[5] == 0xFF && /* iMON 2.4G */ 1628 buf[5] == 0xFF && /* iMON 2.4G */
1629 ((buf[6] == 0x4E && buf[7] == 0xDF) || /* LT */ 1629 ((buf[6] == 0x4E && buf[7] == 0xDF) || /* LT */
1630 (buf[6] == 0x5E && buf[7] == 0xDF))) { /* DT */ 1630 (buf[6] == 0x5E && buf[7] == 0xDF))) { /* DT */
1631 dev_warn(dev, "%s: remote associated refid=%02X\n", 1631 dev_warn(dev, "%s: remote associated refid=%02X\n",
1632 __func__, buf[1]); 1632 __func__, buf[1]);
1633 ictx->rf_isassociating = false; 1633 ictx->rf_isassociating = false;
1634 } 1634 }
1635 } 1635 }
1636 1636
1637 /** 1637 /**
1638 * Callback function for USB core API: receive data 1638 * Callback function for USB core API: receive data
1639 */ 1639 */
1640 static void usb_rx_callback_intf0(struct urb *urb) 1640 static void usb_rx_callback_intf0(struct urb *urb)
1641 { 1641 {
1642 struct imon_context *ictx; 1642 struct imon_context *ictx;
1643 int intfnum = 0; 1643 int intfnum = 0;
1644 1644
1645 if (!urb) 1645 if (!urb)
1646 return; 1646 return;
1647 1647
1648 ictx = (struct imon_context *)urb->context; 1648 ictx = (struct imon_context *)urb->context;
1649 if (!ictx) 1649 if (!ictx)
1650 return; 1650 return;
1651 1651
1652 switch (urb->status) { 1652 switch (urb->status) {
1653 case -ENOENT: /* usbcore unlink successful! */ 1653 case -ENOENT: /* usbcore unlink successful! */
1654 return; 1654 return;
1655 1655
1656 case -ESHUTDOWN: /* transport endpoint was shut down */ 1656 case -ESHUTDOWN: /* transport endpoint was shut down */
1657 break; 1657 break;
1658 1658
1659 case 0: 1659 case 0:
1660 imon_incoming_packet(ictx, urb, intfnum); 1660 imon_incoming_packet(ictx, urb, intfnum);
1661 break; 1661 break;
1662 1662
1663 default: 1663 default:
1664 dev_warn(ictx->dev, "imon %s: status(%d): ignored\n", 1664 dev_warn(ictx->dev, "imon %s: status(%d): ignored\n",
1665 __func__, urb->status); 1665 __func__, urb->status);
1666 break; 1666 break;
1667 } 1667 }
1668 1668
1669 usb_submit_urb(ictx->rx_urb_intf0, GFP_ATOMIC); 1669 usb_submit_urb(ictx->rx_urb_intf0, GFP_ATOMIC);
1670 } 1670 }
1671 1671
1672 static void usb_rx_callback_intf1(struct urb *urb) 1672 static void usb_rx_callback_intf1(struct urb *urb)
1673 { 1673 {
1674 struct imon_context *ictx; 1674 struct imon_context *ictx;
1675 int intfnum = 1; 1675 int intfnum = 1;
1676 1676
1677 if (!urb) 1677 if (!urb)
1678 return; 1678 return;
1679 1679
1680 ictx = (struct imon_context *)urb->context; 1680 ictx = (struct imon_context *)urb->context;
1681 if (!ictx) 1681 if (!ictx)
1682 return; 1682 return;
1683 1683
1684 switch (urb->status) { 1684 switch (urb->status) {
1685 case -ENOENT: /* usbcore unlink successful! */ 1685 case -ENOENT: /* usbcore unlink successful! */
1686 return; 1686 return;
1687 1687
1688 case -ESHUTDOWN: /* transport endpoint was shut down */ 1688 case -ESHUTDOWN: /* transport endpoint was shut down */
1689 break; 1689 break;
1690 1690
1691 case 0: 1691 case 0:
1692 imon_incoming_packet(ictx, urb, intfnum); 1692 imon_incoming_packet(ictx, urb, intfnum);
1693 break; 1693 break;
1694 1694
1695 default: 1695 default:
1696 dev_warn(ictx->dev, "imon %s: status(%d): ignored\n", 1696 dev_warn(ictx->dev, "imon %s: status(%d): ignored\n",
1697 __func__, urb->status); 1697 __func__, urb->status);
1698 break; 1698 break;
1699 } 1699 }
1700 1700
1701 usb_submit_urb(ictx->rx_urb_intf1, GFP_ATOMIC); 1701 usb_submit_urb(ictx->rx_urb_intf1, GFP_ATOMIC);
1702 } 1702 }
1703 1703
1704 /* 1704 /*
1705 * The 0x15c2:0xffdc device ID was used for umpteen different imon 1705 * The 0x15c2:0xffdc device ID was used for umpteen different imon
1706 * devices, and all of them constantly spew interrupts, even when there 1706 * devices, and all of them constantly spew interrupts, even when there
1707 * is no actual data to report. However, byte 6 of this buffer looks like 1707 * is no actual data to report. However, byte 6 of this buffer looks like
1708 * its unique across device variants, so we're trying to key off that to 1708 * its unique across device variants, so we're trying to key off that to
1709 * figure out which display type (if any) and what IR protocol the device 1709 * figure out which display type (if any) and what IR protocol the device
1710 * actually supports. These devices have their IR protocol hard-coded into 1710 * actually supports. These devices have their IR protocol hard-coded into
1711 * their firmware, they can't be changed on the fly like the newer hardware. 1711 * their firmware, they can't be changed on the fly like the newer hardware.
1712 */ 1712 */
1713 static void imon_get_ffdc_type(struct imon_context *ictx) 1713 static void imon_get_ffdc_type(struct imon_context *ictx)
1714 { 1714 {
1715 u8 ffdc_cfg_byte = ictx->usb_rx_buf[6]; 1715 u8 ffdc_cfg_byte = ictx->usb_rx_buf[6];
1716 u8 detected_display_type = IMON_DISPLAY_TYPE_NONE; 1716 u8 detected_display_type = IMON_DISPLAY_TYPE_NONE;
1717 u64 allowed_protos = RC_TYPE_OTHER; 1717 u64 allowed_protos = RC_TYPE_OTHER;
1718 1718
1719 switch (ffdc_cfg_byte) { 1719 switch (ffdc_cfg_byte) {
1720 /* iMON Knob, no display, iMON IR + vol knob */ 1720 /* iMON Knob, no display, iMON IR + vol knob */
1721 case 0x21: 1721 case 0x21:
1722 dev_info(ictx->dev, "0xffdc iMON Knob, iMON IR"); 1722 dev_info(ictx->dev, "0xffdc iMON Knob, iMON IR");
1723 ictx->display_supported = false; 1723 ictx->display_supported = false;
1724 break; 1724 break;
1725 /* iMON 2.4G LT (usb stick), no display, iMON RF */ 1725 /* iMON 2.4G LT (usb stick), no display, iMON RF */
1726 case 0x4e: 1726 case 0x4e:
1727 dev_info(ictx->dev, "0xffdc iMON 2.4G LT, iMON RF"); 1727 dev_info(ictx->dev, "0xffdc iMON 2.4G LT, iMON RF");
1728 ictx->display_supported = false; 1728 ictx->display_supported = false;
1729 ictx->rf_device = true; 1729 ictx->rf_device = true;
1730 break; 1730 break;
1731 /* iMON VFD, no IR (does have vol knob tho) */ 1731 /* iMON VFD, no IR (does have vol knob tho) */
1732 case 0x35: 1732 case 0x35:
1733 dev_info(ictx->dev, "0xffdc iMON VFD + knob, no IR"); 1733 dev_info(ictx->dev, "0xffdc iMON VFD + knob, no IR");
1734 detected_display_type = IMON_DISPLAY_TYPE_VFD; 1734 detected_display_type = IMON_DISPLAY_TYPE_VFD;
1735 break; 1735 break;
1736 /* iMON VFD, iMON IR */ 1736 /* iMON VFD, iMON IR */
1737 case 0x24: 1737 case 0x24:
1738 case 0x85: 1738 case 0x85:
1739 dev_info(ictx->dev, "0xffdc iMON VFD, iMON IR"); 1739 dev_info(ictx->dev, "0xffdc iMON VFD, iMON IR");
1740 detected_display_type = IMON_DISPLAY_TYPE_VFD; 1740 detected_display_type = IMON_DISPLAY_TYPE_VFD;
1741 break; 1741 break;
1742 /* iMON VFD, MCE IR */ 1742 /* iMON VFD, MCE IR */
1743 case 0x9e: 1743 case 0x9e:
1744 dev_info(ictx->dev, "0xffdc iMON VFD, MCE IR"); 1744 dev_info(ictx->dev, "0xffdc iMON VFD, MCE IR");
1745 detected_display_type = IMON_DISPLAY_TYPE_VFD; 1745 detected_display_type = IMON_DISPLAY_TYPE_VFD;
1746 allowed_protos = RC_TYPE_RC6; 1746 allowed_protos = RC_TYPE_RC6;
1747 break; 1747 break;
1748 /* iMON LCD, MCE IR */ 1748 /* iMON LCD, MCE IR */
1749 case 0x9f: 1749 case 0x9f:
1750 dev_info(ictx->dev, "0xffdc iMON LCD, MCE IR"); 1750 dev_info(ictx->dev, "0xffdc iMON LCD, MCE IR");
1751 detected_display_type = IMON_DISPLAY_TYPE_LCD; 1751 detected_display_type = IMON_DISPLAY_TYPE_LCD;
1752 allowed_protos = RC_TYPE_RC6; 1752 allowed_protos = RC_TYPE_RC6;
1753 break; 1753 break;
1754 default: 1754 default:
1755 dev_info(ictx->dev, "Unknown 0xffdc device, " 1755 dev_info(ictx->dev, "Unknown 0xffdc device, "
1756 "defaulting to VFD and iMON IR"); 1756 "defaulting to VFD and iMON IR");
1757 detected_display_type = IMON_DISPLAY_TYPE_VFD; 1757 detected_display_type = IMON_DISPLAY_TYPE_VFD;
1758 break; 1758 break;
1759 } 1759 }
1760 1760
1761 printk(KERN_CONT " (id 0x%02x)\n", ffdc_cfg_byte); 1761 printk(KERN_CONT " (id 0x%02x)\n", ffdc_cfg_byte);
1762 1762
1763 ictx->display_type = detected_display_type; 1763 ictx->display_type = detected_display_type;
1764 ictx->rc_type = allowed_protos; 1764 ictx->rc_type = allowed_protos;
1765 } 1765 }
1766 1766
1767 static void imon_set_display_type(struct imon_context *ictx) 1767 static void imon_set_display_type(struct imon_context *ictx)
1768 { 1768 {
1769 u8 configured_display_type = IMON_DISPLAY_TYPE_VFD; 1769 u8 configured_display_type = IMON_DISPLAY_TYPE_VFD;
1770 1770
1771 /* 1771 /*
1772 * Try to auto-detect the type of display if the user hasn't set 1772 * Try to auto-detect the type of display if the user hasn't set
1773 * it by hand via the display_type modparam. Default is VFD. 1773 * it by hand via the display_type modparam. Default is VFD.
1774 */ 1774 */
1775 1775
1776 if (display_type == IMON_DISPLAY_TYPE_AUTO) { 1776 if (display_type == IMON_DISPLAY_TYPE_AUTO) {
1777 switch (ictx->product) { 1777 switch (ictx->product) {
1778 case 0xffdc: 1778 case 0xffdc:
1779 /* set in imon_get_ffdc_type() */ 1779 /* set in imon_get_ffdc_type() */
1780 configured_display_type = ictx->display_type; 1780 configured_display_type = ictx->display_type;
1781 break; 1781 break;
1782 case 0x0034: 1782 case 0x0034:
1783 case 0x0035: 1783 case 0x0035:
1784 configured_display_type = IMON_DISPLAY_TYPE_VGA; 1784 configured_display_type = IMON_DISPLAY_TYPE_VGA;
1785 break; 1785 break;
1786 case 0x0038: 1786 case 0x0038:
1787 case 0x0039: 1787 case 0x0039:
1788 case 0x0045: 1788 case 0x0045:
1789 configured_display_type = IMON_DISPLAY_TYPE_LCD; 1789 configured_display_type = IMON_DISPLAY_TYPE_LCD;
1790 break; 1790 break;
1791 case 0x003c: 1791 case 0x003c:
1792 case 0x0041: 1792 case 0x0041:
1793 case 0x0042: 1793 case 0x0042:
1794 case 0x0043: 1794 case 0x0043:
1795 configured_display_type = IMON_DISPLAY_TYPE_NONE; 1795 configured_display_type = IMON_DISPLAY_TYPE_NONE;
1796 ictx->display_supported = false; 1796 ictx->display_supported = false;
1797 break; 1797 break;
1798 case 0x0036: 1798 case 0x0036:
1799 case 0x0044: 1799 case 0x0044:
1800 default: 1800 default:
1801 configured_display_type = IMON_DISPLAY_TYPE_VFD; 1801 configured_display_type = IMON_DISPLAY_TYPE_VFD;
1802 break; 1802 break;
1803 } 1803 }
1804 } else { 1804 } else {
1805 configured_display_type = display_type; 1805 configured_display_type = display_type;
1806 if (display_type == IMON_DISPLAY_TYPE_NONE) 1806 if (display_type == IMON_DISPLAY_TYPE_NONE)
1807 ictx->display_supported = false; 1807 ictx->display_supported = false;
1808 else 1808 else
1809 ictx->display_supported = true; 1809 ictx->display_supported = true;
1810 dev_info(ictx->dev, "%s: overriding display type to %d via " 1810 dev_info(ictx->dev, "%s: overriding display type to %d via "
1811 "modparam\n", __func__, display_type); 1811 "modparam\n", __func__, display_type);
1812 } 1812 }
1813 1813
1814 ictx->display_type = configured_display_type; 1814 ictx->display_type = configured_display_type;
1815 } 1815 }
1816 1816
1817 static struct rc_dev *imon_init_rdev(struct imon_context *ictx) 1817 static struct rc_dev *imon_init_rdev(struct imon_context *ictx)
1818 { 1818 {
1819 struct rc_dev *rdev; 1819 struct rc_dev *rdev;
1820 int ret; 1820 int ret;
1821 const unsigned char fp_packet[] = { 0x40, 0x00, 0x00, 0x00, 1821 const unsigned char fp_packet[] = { 0x40, 0x00, 0x00, 0x00,
1822 0x00, 0x00, 0x00, 0x88 }; 1822 0x00, 0x00, 0x00, 0x88 };
1823 1823
1824 rdev = rc_allocate_device(); 1824 rdev = rc_allocate_device();
1825 if (!rdev) { 1825 if (!rdev) {
1826 dev_err(ictx->dev, "remote control dev allocation failed\n"); 1826 dev_err(ictx->dev, "remote control dev allocation failed\n");
1827 goto out; 1827 goto out;
1828 } 1828 }
1829 1829
1830 snprintf(ictx->name_rdev, sizeof(ictx->name_rdev), 1830 snprintf(ictx->name_rdev, sizeof(ictx->name_rdev),
1831 "iMON Remote (%04x:%04x)", ictx->vendor, ictx->product); 1831 "iMON Remote (%04x:%04x)", ictx->vendor, ictx->product);
1832 usb_make_path(ictx->usbdev_intf0, ictx->phys_rdev, 1832 usb_make_path(ictx->usbdev_intf0, ictx->phys_rdev,
1833 sizeof(ictx->phys_rdev)); 1833 sizeof(ictx->phys_rdev));
1834 strlcat(ictx->phys_rdev, "/input0", sizeof(ictx->phys_rdev)); 1834 strlcat(ictx->phys_rdev, "/input0", sizeof(ictx->phys_rdev));
1835 1835
1836 rdev->input_name = ictx->name_rdev; 1836 rdev->input_name = ictx->name_rdev;
1837 rdev->input_phys = ictx->phys_rdev; 1837 rdev->input_phys = ictx->phys_rdev;
1838 usb_to_input_id(ictx->usbdev_intf0, &rdev->input_id); 1838 usb_to_input_id(ictx->usbdev_intf0, &rdev->input_id);
1839 rdev->dev.parent = ictx->dev; 1839 rdev->dev.parent = ictx->dev;
1840 1840
1841 rdev->priv = ictx; 1841 rdev->priv = ictx;
1842 rdev->driver_type = RC_DRIVER_SCANCODE; 1842 rdev->driver_type = RC_DRIVER_SCANCODE;
1843 rdev->allowed_protos = RC_TYPE_OTHER | RC_TYPE_RC6; /* iMON PAD or MCE */ 1843 rdev->allowed_protos = RC_TYPE_OTHER | RC_TYPE_RC6; /* iMON PAD or MCE */
1844 rdev->change_protocol = imon_ir_change_protocol; 1844 rdev->change_protocol = imon_ir_change_protocol;
1845 rdev->driver_name = MOD_NAME; 1845 rdev->driver_name = MOD_NAME;
1846 1846
1847 /* Enable front-panel buttons and/or knobs */ 1847 /* Enable front-panel buttons and/or knobs */
1848 memcpy(ictx->usb_tx_buf, &fp_packet, sizeof(fp_packet)); 1848 memcpy(ictx->usb_tx_buf, &fp_packet, sizeof(fp_packet));
1849 ret = send_packet(ictx); 1849 ret = send_packet(ictx);
1850 /* Not fatal, but warn about it */ 1850 /* Not fatal, but warn about it */
1851 if (ret) 1851 if (ret)
1852 dev_info(ictx->dev, "panel buttons/knobs setup failed\n"); 1852 dev_info(ictx->dev, "panel buttons/knobs setup failed\n");
1853 1853
1854 if (ictx->product == 0xffdc) { 1854 if (ictx->product == 0xffdc) {
1855 imon_get_ffdc_type(ictx); 1855 imon_get_ffdc_type(ictx);
1856 rdev->allowed_protos = ictx->rc_type; 1856 rdev->allowed_protos = ictx->rc_type;
1857 } 1857 }
1858 1858
1859 imon_set_display_type(ictx); 1859 imon_set_display_type(ictx);
1860 1860
1861 if (ictx->rc_type == RC_TYPE_RC6) 1861 if (ictx->rc_type == RC_TYPE_RC6)
1862 rdev->map_name = RC_MAP_IMON_MCE; 1862 rdev->map_name = RC_MAP_IMON_MCE;
1863 else 1863 else
1864 rdev->map_name = RC_MAP_IMON_PAD; 1864 rdev->map_name = RC_MAP_IMON_PAD;
1865 1865
1866 ret = rc_register_device(rdev); 1866 ret = rc_register_device(rdev);
1867 if (ret < 0) { 1867 if (ret < 0) {
1868 dev_err(ictx->dev, "remote input dev register failed\n"); 1868 dev_err(ictx->dev, "remote input dev register failed\n");
1869 goto out; 1869 goto out;
1870 } 1870 }
1871 1871
1872 return rdev; 1872 return rdev;
1873 1873
1874 out: 1874 out:
1875 rc_free_device(rdev); 1875 rc_free_device(rdev);
1876 return NULL; 1876 return NULL;
1877 } 1877 }
1878 1878
1879 static struct input_dev *imon_init_idev(struct imon_context *ictx) 1879 static struct input_dev *imon_init_idev(struct imon_context *ictx)
1880 { 1880 {
1881 struct input_dev *idev; 1881 struct input_dev *idev;
1882 int ret, i; 1882 int ret, i;
1883 1883
1884 idev = input_allocate_device(); 1884 idev = input_allocate_device();
1885 if (!idev) { 1885 if (!idev) {
1886 dev_err(ictx->dev, "input dev allocation failed\n"); 1886 dev_err(ictx->dev, "input dev allocation failed\n");
1887 goto out; 1887 goto out;
1888 } 1888 }
1889 1889
1890 snprintf(ictx->name_idev, sizeof(ictx->name_idev), 1890 snprintf(ictx->name_idev, sizeof(ictx->name_idev),
1891 "iMON Panel, Knob and Mouse(%04x:%04x)", 1891 "iMON Panel, Knob and Mouse(%04x:%04x)",
1892 ictx->vendor, ictx->product); 1892 ictx->vendor, ictx->product);
1893 idev->name = ictx->name_idev; 1893 idev->name = ictx->name_idev;
1894 1894
1895 usb_make_path(ictx->usbdev_intf0, ictx->phys_idev, 1895 usb_make_path(ictx->usbdev_intf0, ictx->phys_idev,
1896 sizeof(ictx->phys_idev)); 1896 sizeof(ictx->phys_idev));
1897 strlcat(ictx->phys_idev, "/input1", sizeof(ictx->phys_idev)); 1897 strlcat(ictx->phys_idev, "/input1", sizeof(ictx->phys_idev));
1898 idev->phys = ictx->phys_idev; 1898 idev->phys = ictx->phys_idev;
1899 1899
1900 idev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP) | BIT_MASK(EV_REL); 1900 idev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP) | BIT_MASK(EV_REL);
1901 1901
1902 idev->keybit[BIT_WORD(BTN_MOUSE)] = 1902 idev->keybit[BIT_WORD(BTN_MOUSE)] =
1903 BIT_MASK(BTN_LEFT) | BIT_MASK(BTN_RIGHT); 1903 BIT_MASK(BTN_LEFT) | BIT_MASK(BTN_RIGHT);
1904 idev->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y) | 1904 idev->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y) |
1905 BIT_MASK(REL_WHEEL); 1905 BIT_MASK(REL_WHEEL);
1906 1906
1907 /* panel and/or knob code support */ 1907 /* panel and/or knob code support */
1908 for (i = 0; i < ARRAY_SIZE(imon_panel_key_table); i++) { 1908 for (i = 0; i < ARRAY_SIZE(imon_panel_key_table); i++) {
1909 u32 kc = imon_panel_key_table[i].keycode; 1909 u32 kc = imon_panel_key_table[i].keycode;
1910 __set_bit(kc, idev->keybit); 1910 __set_bit(kc, idev->keybit);
1911 } 1911 }
1912 1912
1913 usb_to_input_id(ictx->usbdev_intf0, &idev->id); 1913 usb_to_input_id(ictx->usbdev_intf0, &idev->id);
1914 idev->dev.parent = ictx->dev; 1914 idev->dev.parent = ictx->dev;
1915 input_set_drvdata(idev, ictx); 1915 input_set_drvdata(idev, ictx);
1916 1916
1917 ret = input_register_device(idev); 1917 ret = input_register_device(idev);
1918 if (ret < 0) { 1918 if (ret < 0) {
1919 dev_err(ictx->dev, "input dev register failed\n"); 1919 dev_err(ictx->dev, "input dev register failed\n");
1920 goto out; 1920 goto out;
1921 } 1921 }
1922 1922
1923 return idev; 1923 return idev;
1924 1924
1925 out: 1925 out:
1926 input_free_device(idev); 1926 input_free_device(idev);
1927 return NULL; 1927 return NULL;
1928 } 1928 }
1929 1929
1930 static struct input_dev *imon_init_touch(struct imon_context *ictx) 1930 static struct input_dev *imon_init_touch(struct imon_context *ictx)
1931 { 1931 {
1932 struct input_dev *touch; 1932 struct input_dev *touch;
1933 int ret; 1933 int ret;
1934 1934
1935 touch = input_allocate_device(); 1935 touch = input_allocate_device();
1936 if (!touch) { 1936 if (!touch) {
1937 dev_err(ictx->dev, "touchscreen input dev allocation failed\n"); 1937 dev_err(ictx->dev, "touchscreen input dev allocation failed\n");
1938 goto touch_alloc_failed; 1938 goto touch_alloc_failed;
1939 } 1939 }
1940 1940
1941 snprintf(ictx->name_touch, sizeof(ictx->name_touch), 1941 snprintf(ictx->name_touch, sizeof(ictx->name_touch),
1942 "iMON USB Touchscreen (%04x:%04x)", 1942 "iMON USB Touchscreen (%04x:%04x)",
1943 ictx->vendor, ictx->product); 1943 ictx->vendor, ictx->product);
1944 touch->name = ictx->name_touch; 1944 touch->name = ictx->name_touch;
1945 1945
1946 usb_make_path(ictx->usbdev_intf1, ictx->phys_touch, 1946 usb_make_path(ictx->usbdev_intf1, ictx->phys_touch,
1947 sizeof(ictx->phys_touch)); 1947 sizeof(ictx->phys_touch));
1948 strlcat(ictx->phys_touch, "/input2", sizeof(ictx->phys_touch)); 1948 strlcat(ictx->phys_touch, "/input2", sizeof(ictx->phys_touch));
1949 touch->phys = ictx->phys_touch; 1949 touch->phys = ictx->phys_touch;
1950 1950
1951 touch->evbit[0] = 1951 touch->evbit[0] =
1952 BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); 1952 BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
1953 touch->keybit[BIT_WORD(BTN_TOUCH)] = 1953 touch->keybit[BIT_WORD(BTN_TOUCH)] =
1954 BIT_MASK(BTN_TOUCH); 1954 BIT_MASK(BTN_TOUCH);
1955 input_set_abs_params(touch, ABS_X, 1955 input_set_abs_params(touch, ABS_X,
1956 0x00, 0xfff, 0, 0); 1956 0x00, 0xfff, 0, 0);
1957 input_set_abs_params(touch, ABS_Y, 1957 input_set_abs_params(touch, ABS_Y,
1958 0x00, 0xfff, 0, 0); 1958 0x00, 0xfff, 0, 0);
1959 1959
1960 input_set_drvdata(touch, ictx); 1960 input_set_drvdata(touch, ictx);
1961 1961
1962 usb_to_input_id(ictx->usbdev_intf1, &touch->id); 1962 usb_to_input_id(ictx->usbdev_intf1, &touch->id);
1963 touch->dev.parent = ictx->dev; 1963 touch->dev.parent = ictx->dev;
1964 ret = input_register_device(touch); 1964 ret = input_register_device(touch);
1965 if (ret < 0) { 1965 if (ret < 0) {
1966 dev_info(ictx->dev, "touchscreen input dev register failed\n"); 1966 dev_info(ictx->dev, "touchscreen input dev register failed\n");
1967 goto touch_register_failed; 1967 goto touch_register_failed;
1968 } 1968 }
1969 1969
1970 return touch; 1970 return touch;
1971 1971
1972 touch_register_failed: 1972 touch_register_failed:
1973 input_free_device(ictx->touch); 1973 input_free_device(touch);
1974 1974
1975 touch_alloc_failed: 1975 touch_alloc_failed:
1976 return NULL; 1976 return NULL;
1977 } 1977 }
1978 1978
1979 static bool imon_find_endpoints(struct imon_context *ictx, 1979 static bool imon_find_endpoints(struct imon_context *ictx,
1980 struct usb_host_interface *iface_desc) 1980 struct usb_host_interface *iface_desc)
1981 { 1981 {
1982 struct usb_endpoint_descriptor *ep; 1982 struct usb_endpoint_descriptor *ep;
1983 struct usb_endpoint_descriptor *rx_endpoint = NULL; 1983 struct usb_endpoint_descriptor *rx_endpoint = NULL;
1984 struct usb_endpoint_descriptor *tx_endpoint = NULL; 1984 struct usb_endpoint_descriptor *tx_endpoint = NULL;
1985 int ifnum = iface_desc->desc.bInterfaceNumber; 1985 int ifnum = iface_desc->desc.bInterfaceNumber;
1986 int num_endpts = iface_desc->desc.bNumEndpoints; 1986 int num_endpts = iface_desc->desc.bNumEndpoints;
1987 int i, ep_dir, ep_type; 1987 int i, ep_dir, ep_type;
1988 bool ir_ep_found = false; 1988 bool ir_ep_found = false;
1989 bool display_ep_found = false; 1989 bool display_ep_found = false;
1990 bool tx_control = false; 1990 bool tx_control = false;
1991 1991
1992 /* 1992 /*
1993 * Scan the endpoint list and set: 1993 * Scan the endpoint list and set:
1994 * first input endpoint = IR endpoint 1994 * first input endpoint = IR endpoint
1995 * first output endpoint = display endpoint 1995 * first output endpoint = display endpoint
1996 */ 1996 */
1997 for (i = 0; i < num_endpts && !(ir_ep_found && display_ep_found); ++i) { 1997 for (i = 0; i < num_endpts && !(ir_ep_found && display_ep_found); ++i) {
1998 ep = &iface_desc->endpoint[i].desc; 1998 ep = &iface_desc->endpoint[i].desc;
1999 ep_dir = ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK; 1999 ep_dir = ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK;
2000 ep_type = ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK; 2000 ep_type = ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
2001 2001
2002 if (!ir_ep_found && ep_dir == USB_DIR_IN && 2002 if (!ir_ep_found && ep_dir == USB_DIR_IN &&
2003 ep_type == USB_ENDPOINT_XFER_INT) { 2003 ep_type == USB_ENDPOINT_XFER_INT) {
2004 2004
2005 rx_endpoint = ep; 2005 rx_endpoint = ep;
2006 ir_ep_found = true; 2006 ir_ep_found = true;
2007 dev_dbg(ictx->dev, "%s: found IR endpoint\n", __func__); 2007 dev_dbg(ictx->dev, "%s: found IR endpoint\n", __func__);
2008 2008
2009 } else if (!display_ep_found && ep_dir == USB_DIR_OUT && 2009 } else if (!display_ep_found && ep_dir == USB_DIR_OUT &&
2010 ep_type == USB_ENDPOINT_XFER_INT) { 2010 ep_type == USB_ENDPOINT_XFER_INT) {
2011 tx_endpoint = ep; 2011 tx_endpoint = ep;
2012 display_ep_found = true; 2012 display_ep_found = true;
2013 dev_dbg(ictx->dev, "%s: found display endpoint\n", __func__); 2013 dev_dbg(ictx->dev, "%s: found display endpoint\n", __func__);
2014 } 2014 }
2015 } 2015 }
2016 2016
2017 if (ifnum == 0) { 2017 if (ifnum == 0) {
2018 ictx->rx_endpoint_intf0 = rx_endpoint; 2018 ictx->rx_endpoint_intf0 = rx_endpoint;
2019 /* 2019 /*
2020 * tx is used to send characters to lcd/vfd, associate RF 2020 * tx is used to send characters to lcd/vfd, associate RF
2021 * remotes, set IR protocol, and maybe more... 2021 * remotes, set IR protocol, and maybe more...
2022 */ 2022 */
2023 ictx->tx_endpoint = tx_endpoint; 2023 ictx->tx_endpoint = tx_endpoint;
2024 } else { 2024 } else {
2025 ictx->rx_endpoint_intf1 = rx_endpoint; 2025 ictx->rx_endpoint_intf1 = rx_endpoint;
2026 } 2026 }
2027 2027
2028 /* 2028 /*
2029 * If we didn't find a display endpoint, this is probably one of the 2029 * If we didn't find a display endpoint, this is probably one of the
2030 * newer iMON devices that use control urb instead of interrupt 2030 * newer iMON devices that use control urb instead of interrupt
2031 */ 2031 */
2032 if (!display_ep_found) { 2032 if (!display_ep_found) {
2033 tx_control = true; 2033 tx_control = true;
2034 display_ep_found = true; 2034 display_ep_found = true;
2035 dev_dbg(ictx->dev, "%s: device uses control endpoint, not " 2035 dev_dbg(ictx->dev, "%s: device uses control endpoint, not "
2036 "interface OUT endpoint\n", __func__); 2036 "interface OUT endpoint\n", __func__);
2037 } 2037 }
2038 2038
2039 /* 2039 /*
2040 * Some iMON receivers have no display. Unfortunately, it seems 2040 * Some iMON receivers have no display. Unfortunately, it seems
2041 * that SoundGraph recycles device IDs between devices both with 2041 * that SoundGraph recycles device IDs between devices both with
2042 * and without... :\ 2042 * and without... :\
2043 */ 2043 */
2044 if (ictx->display_type == IMON_DISPLAY_TYPE_NONE) { 2044 if (ictx->display_type == IMON_DISPLAY_TYPE_NONE) {
2045 display_ep_found = false; 2045 display_ep_found = false;
2046 dev_dbg(ictx->dev, "%s: device has no display\n", __func__); 2046 dev_dbg(ictx->dev, "%s: device has no display\n", __func__);
2047 } 2047 }
2048 2048
2049 /* 2049 /*
2050 * iMON Touch devices have a VGA touchscreen, but no "display", as 2050 * iMON Touch devices have a VGA touchscreen, but no "display", as
2051 * that refers to e.g. /dev/lcd0 (a character device LCD or VFD). 2051 * that refers to e.g. /dev/lcd0 (a character device LCD or VFD).
2052 */ 2052 */
2053 if (ictx->display_type == IMON_DISPLAY_TYPE_VGA) { 2053 if (ictx->display_type == IMON_DISPLAY_TYPE_VGA) {
2054 display_ep_found = false; 2054 display_ep_found = false;
2055 dev_dbg(ictx->dev, "%s: iMON Touch device found\n", __func__); 2055 dev_dbg(ictx->dev, "%s: iMON Touch device found\n", __func__);
2056 } 2056 }
2057 2057
2058 /* Input endpoint is mandatory */ 2058 /* Input endpoint is mandatory */
2059 if (!ir_ep_found) 2059 if (!ir_ep_found)
2060 pr_err("no valid input (IR) endpoint found\n"); 2060 pr_err("no valid input (IR) endpoint found\n");
2061 2061
2062 ictx->tx_control = tx_control; 2062 ictx->tx_control = tx_control;
2063 2063
2064 if (display_ep_found) 2064 if (display_ep_found)
2065 ictx->display_supported = true; 2065 ictx->display_supported = true;
2066 2066
2067 return ir_ep_found; 2067 return ir_ep_found;
2068 2068
2069 } 2069 }
2070 2070
2071 static struct imon_context *imon_init_intf0(struct usb_interface *intf) 2071 static struct imon_context *imon_init_intf0(struct usb_interface *intf)
2072 { 2072 {
2073 struct imon_context *ictx; 2073 struct imon_context *ictx;
2074 struct urb *rx_urb; 2074 struct urb *rx_urb;
2075 struct urb *tx_urb; 2075 struct urb *tx_urb;
2076 struct device *dev = &intf->dev; 2076 struct device *dev = &intf->dev;
2077 struct usb_host_interface *iface_desc; 2077 struct usb_host_interface *iface_desc;
2078 int ret = -ENOMEM; 2078 int ret = -ENOMEM;
2079 2079
2080 ictx = kzalloc(sizeof(struct imon_context), GFP_KERNEL); 2080 ictx = kzalloc(sizeof(struct imon_context), GFP_KERNEL);
2081 if (!ictx) { 2081 if (!ictx) {
2082 dev_err(dev, "%s: kzalloc failed for context", __func__); 2082 dev_err(dev, "%s: kzalloc failed for context", __func__);
2083 goto exit; 2083 goto exit;
2084 } 2084 }
2085 rx_urb = usb_alloc_urb(0, GFP_KERNEL); 2085 rx_urb = usb_alloc_urb(0, GFP_KERNEL);
2086 if (!rx_urb) { 2086 if (!rx_urb) {
2087 dev_err(dev, "%s: usb_alloc_urb failed for IR urb", __func__); 2087 dev_err(dev, "%s: usb_alloc_urb failed for IR urb", __func__);
2088 goto rx_urb_alloc_failed; 2088 goto rx_urb_alloc_failed;
2089 } 2089 }
2090 tx_urb = usb_alloc_urb(0, GFP_KERNEL); 2090 tx_urb = usb_alloc_urb(0, GFP_KERNEL);
2091 if (!tx_urb) { 2091 if (!tx_urb) {
2092 dev_err(dev, "%s: usb_alloc_urb failed for display urb", 2092 dev_err(dev, "%s: usb_alloc_urb failed for display urb",
2093 __func__); 2093 __func__);
2094 goto tx_urb_alloc_failed; 2094 goto tx_urb_alloc_failed;
2095 } 2095 }
2096 2096
2097 mutex_init(&ictx->lock); 2097 mutex_init(&ictx->lock);
2098 spin_lock_init(&ictx->kc_lock); 2098 spin_lock_init(&ictx->kc_lock);
2099 2099
2100 mutex_lock(&ictx->lock); 2100 mutex_lock(&ictx->lock);
2101 2101
2102 ictx->dev = dev; 2102 ictx->dev = dev;
2103 ictx->usbdev_intf0 = usb_get_dev(interface_to_usbdev(intf)); 2103 ictx->usbdev_intf0 = usb_get_dev(interface_to_usbdev(intf));
2104 ictx->dev_present_intf0 = true; 2104 ictx->dev_present_intf0 = true;
2105 ictx->rx_urb_intf0 = rx_urb; 2105 ictx->rx_urb_intf0 = rx_urb;
2106 ictx->tx_urb = tx_urb; 2106 ictx->tx_urb = tx_urb;
2107 ictx->rf_device = false; 2107 ictx->rf_device = false;
2108 2108
2109 ictx->vendor = le16_to_cpu(ictx->usbdev_intf0->descriptor.idVendor); 2109 ictx->vendor = le16_to_cpu(ictx->usbdev_intf0->descriptor.idVendor);
2110 ictx->product = le16_to_cpu(ictx->usbdev_intf0->descriptor.idProduct); 2110 ictx->product = le16_to_cpu(ictx->usbdev_intf0->descriptor.idProduct);
2111 2111
2112 ret = -ENODEV; 2112 ret = -ENODEV;
2113 iface_desc = intf->cur_altsetting; 2113 iface_desc = intf->cur_altsetting;
2114 if (!imon_find_endpoints(ictx, iface_desc)) { 2114 if (!imon_find_endpoints(ictx, iface_desc)) {
2115 goto find_endpoint_failed; 2115 goto find_endpoint_failed;
2116 } 2116 }
2117 2117
2118 usb_fill_int_urb(ictx->rx_urb_intf0, ictx->usbdev_intf0, 2118 usb_fill_int_urb(ictx->rx_urb_intf0, ictx->usbdev_intf0,
2119 usb_rcvintpipe(ictx->usbdev_intf0, 2119 usb_rcvintpipe(ictx->usbdev_intf0,
2120 ictx->rx_endpoint_intf0->bEndpointAddress), 2120 ictx->rx_endpoint_intf0->bEndpointAddress),
2121 ictx->usb_rx_buf, sizeof(ictx->usb_rx_buf), 2121 ictx->usb_rx_buf, sizeof(ictx->usb_rx_buf),
2122 usb_rx_callback_intf0, ictx, 2122 usb_rx_callback_intf0, ictx,
2123 ictx->rx_endpoint_intf0->bInterval); 2123 ictx->rx_endpoint_intf0->bInterval);
2124 2124
2125 ret = usb_submit_urb(ictx->rx_urb_intf0, GFP_KERNEL); 2125 ret = usb_submit_urb(ictx->rx_urb_intf0, GFP_KERNEL);
2126 if (ret) { 2126 if (ret) {
2127 pr_err("usb_submit_urb failed for intf0 (%d)\n", ret); 2127 pr_err("usb_submit_urb failed for intf0 (%d)\n", ret);
2128 goto urb_submit_failed; 2128 goto urb_submit_failed;
2129 } 2129 }
2130 2130
2131 ictx->idev = imon_init_idev(ictx); 2131 ictx->idev = imon_init_idev(ictx);
2132 if (!ictx->idev) { 2132 if (!ictx->idev) {
2133 dev_err(dev, "%s: input device setup failed\n", __func__); 2133 dev_err(dev, "%s: input device setup failed\n", __func__);
2134 goto idev_setup_failed; 2134 goto idev_setup_failed;
2135 } 2135 }
2136 2136
2137 ictx->rdev = imon_init_rdev(ictx); 2137 ictx->rdev = imon_init_rdev(ictx);
2138 if (!ictx->rdev) { 2138 if (!ictx->rdev) {
2139 dev_err(dev, "%s: rc device setup failed\n", __func__); 2139 dev_err(dev, "%s: rc device setup failed\n", __func__);
2140 goto rdev_setup_failed; 2140 goto rdev_setup_failed;
2141 } 2141 }
2142 2142
2143 mutex_unlock(&ictx->lock); 2143 mutex_unlock(&ictx->lock);
2144 return ictx; 2144 return ictx;
2145 2145
2146 rdev_setup_failed: 2146 rdev_setup_failed:
2147 input_unregister_device(ictx->idev); 2147 input_unregister_device(ictx->idev);
2148 idev_setup_failed: 2148 idev_setup_failed:
2149 usb_kill_urb(ictx->rx_urb_intf0); 2149 usb_kill_urb(ictx->rx_urb_intf0);
2150 urb_submit_failed: 2150 urb_submit_failed:
2151 find_endpoint_failed: 2151 find_endpoint_failed:
2152 mutex_unlock(&ictx->lock); 2152 mutex_unlock(&ictx->lock);
2153 usb_free_urb(tx_urb); 2153 usb_free_urb(tx_urb);
2154 tx_urb_alloc_failed: 2154 tx_urb_alloc_failed:
2155 usb_free_urb(rx_urb); 2155 usb_free_urb(rx_urb);
2156 rx_urb_alloc_failed: 2156 rx_urb_alloc_failed:
2157 kfree(ictx); 2157 kfree(ictx);
2158 exit: 2158 exit:
2159 dev_err(dev, "unable to initialize intf0, err %d\n", ret); 2159 dev_err(dev, "unable to initialize intf0, err %d\n", ret);
2160 2160
2161 return NULL; 2161 return NULL;
2162 } 2162 }
2163 2163
2164 static struct imon_context *imon_init_intf1(struct usb_interface *intf, 2164 static struct imon_context *imon_init_intf1(struct usb_interface *intf,
2165 struct imon_context *ictx) 2165 struct imon_context *ictx)
2166 { 2166 {
2167 struct urb *rx_urb; 2167 struct urb *rx_urb;
2168 struct usb_host_interface *iface_desc; 2168 struct usb_host_interface *iface_desc;
2169 int ret = -ENOMEM; 2169 int ret = -ENOMEM;
2170 2170
2171 rx_urb = usb_alloc_urb(0, GFP_KERNEL); 2171 rx_urb = usb_alloc_urb(0, GFP_KERNEL);
2172 if (!rx_urb) { 2172 if (!rx_urb) {
2173 pr_err("usb_alloc_urb failed for IR urb\n"); 2173 pr_err("usb_alloc_urb failed for IR urb\n");
2174 goto rx_urb_alloc_failed; 2174 goto rx_urb_alloc_failed;
2175 } 2175 }
2176 2176
2177 mutex_lock(&ictx->lock); 2177 mutex_lock(&ictx->lock);
2178 2178
2179 if (ictx->display_type == IMON_DISPLAY_TYPE_VGA) { 2179 if (ictx->display_type == IMON_DISPLAY_TYPE_VGA) {
2180 init_timer(&ictx->ttimer); 2180 init_timer(&ictx->ttimer);
2181 ictx->ttimer.data = (unsigned long)ictx; 2181 ictx->ttimer.data = (unsigned long)ictx;
2182 ictx->ttimer.function = imon_touch_display_timeout; 2182 ictx->ttimer.function = imon_touch_display_timeout;
2183 } 2183 }
2184 2184
2185 ictx->usbdev_intf1 = usb_get_dev(interface_to_usbdev(intf)); 2185 ictx->usbdev_intf1 = usb_get_dev(interface_to_usbdev(intf));
2186 ictx->dev_present_intf1 = true; 2186 ictx->dev_present_intf1 = true;
2187 ictx->rx_urb_intf1 = rx_urb; 2187 ictx->rx_urb_intf1 = rx_urb;
2188 2188
2189 ret = -ENODEV; 2189 ret = -ENODEV;
2190 iface_desc = intf->cur_altsetting; 2190 iface_desc = intf->cur_altsetting;
2191 if (!imon_find_endpoints(ictx, iface_desc)) 2191 if (!imon_find_endpoints(ictx, iface_desc))
2192 goto find_endpoint_failed; 2192 goto find_endpoint_failed;
2193 2193
2194 if (ictx->display_type == IMON_DISPLAY_TYPE_VGA) { 2194 if (ictx->display_type == IMON_DISPLAY_TYPE_VGA) {
2195 ictx->touch = imon_init_touch(ictx); 2195 ictx->touch = imon_init_touch(ictx);
2196 if (!ictx->touch) 2196 if (!ictx->touch)
2197 goto touch_setup_failed; 2197 goto touch_setup_failed;
2198 } else 2198 } else
2199 ictx->touch = NULL; 2199 ictx->touch = NULL;
2200 2200
2201 usb_fill_int_urb(ictx->rx_urb_intf1, ictx->usbdev_intf1, 2201 usb_fill_int_urb(ictx->rx_urb_intf1, ictx->usbdev_intf1,
2202 usb_rcvintpipe(ictx->usbdev_intf1, 2202 usb_rcvintpipe(ictx->usbdev_intf1,
2203 ictx->rx_endpoint_intf1->bEndpointAddress), 2203 ictx->rx_endpoint_intf1->bEndpointAddress),
2204 ictx->usb_rx_buf, sizeof(ictx->usb_rx_buf), 2204 ictx->usb_rx_buf, sizeof(ictx->usb_rx_buf),
2205 usb_rx_callback_intf1, ictx, 2205 usb_rx_callback_intf1, ictx,
2206 ictx->rx_endpoint_intf1->bInterval); 2206 ictx->rx_endpoint_intf1->bInterval);
2207 2207
2208 ret = usb_submit_urb(ictx->rx_urb_intf1, GFP_KERNEL); 2208 ret = usb_submit_urb(ictx->rx_urb_intf1, GFP_KERNEL);
2209 2209
2210 if (ret) { 2210 if (ret) {
2211 pr_err("usb_submit_urb failed for intf1 (%d)\n", ret); 2211 pr_err("usb_submit_urb failed for intf1 (%d)\n", ret);
2212 goto urb_submit_failed; 2212 goto urb_submit_failed;
2213 } 2213 }
2214 2214
2215 mutex_unlock(&ictx->lock); 2215 mutex_unlock(&ictx->lock);
2216 return ictx; 2216 return ictx;
2217 2217
2218 urb_submit_failed: 2218 urb_submit_failed:
2219 if (ictx->touch) 2219 if (ictx->touch)
2220 input_unregister_device(ictx->touch); 2220 input_unregister_device(ictx->touch);
2221 touch_setup_failed: 2221 touch_setup_failed:
2222 find_endpoint_failed: 2222 find_endpoint_failed:
2223 mutex_unlock(&ictx->lock); 2223 mutex_unlock(&ictx->lock);
2224 usb_free_urb(rx_urb); 2224 usb_free_urb(rx_urb);
2225 rx_urb_alloc_failed: 2225 rx_urb_alloc_failed:
2226 dev_err(ictx->dev, "unable to initialize intf0, err %d\n", ret); 2226 dev_err(ictx->dev, "unable to initialize intf0, err %d\n", ret);
2227 2227
2228 return NULL; 2228 return NULL;
2229 } 2229 }
2230 2230
2231 static void imon_init_display(struct imon_context *ictx, 2231 static void imon_init_display(struct imon_context *ictx,
2232 struct usb_interface *intf) 2232 struct usb_interface *intf)
2233 { 2233 {
2234 int ret; 2234 int ret;
2235 2235
2236 dev_dbg(ictx->dev, "Registering iMON display with sysfs\n"); 2236 dev_dbg(ictx->dev, "Registering iMON display with sysfs\n");
2237 2237
2238 /* set up sysfs entry for built-in clock */ 2238 /* set up sysfs entry for built-in clock */
2239 ret = sysfs_create_group(&intf->dev.kobj, &imon_display_attr_group); 2239 ret = sysfs_create_group(&intf->dev.kobj, &imon_display_attr_group);
2240 if (ret) 2240 if (ret)
2241 dev_err(ictx->dev, "Could not create display sysfs " 2241 dev_err(ictx->dev, "Could not create display sysfs "
2242 "entries(%d)", ret); 2242 "entries(%d)", ret);
2243 2243
2244 if (ictx->display_type == IMON_DISPLAY_TYPE_LCD) 2244 if (ictx->display_type == IMON_DISPLAY_TYPE_LCD)
2245 ret = usb_register_dev(intf, &imon_lcd_class); 2245 ret = usb_register_dev(intf, &imon_lcd_class);
2246 else 2246 else
2247 ret = usb_register_dev(intf, &imon_vfd_class); 2247 ret = usb_register_dev(intf, &imon_vfd_class);
2248 if (ret) 2248 if (ret)
2249 /* Not a fatal error, so ignore */ 2249 /* Not a fatal error, so ignore */
2250 dev_info(ictx->dev, "could not get a minor number for " 2250 dev_info(ictx->dev, "could not get a minor number for "
2251 "display\n"); 2251 "display\n");
2252 2252
2253 } 2253 }
2254 2254
2255 /** 2255 /**
2256 * Callback function for USB core API: Probe 2256 * Callback function for USB core API: Probe
2257 */ 2257 */
2258 static int __devinit imon_probe(struct usb_interface *interface, 2258 static int __devinit imon_probe(struct usb_interface *interface,
2259 const struct usb_device_id *id) 2259 const struct usb_device_id *id)
2260 { 2260 {
2261 struct usb_device *usbdev = NULL; 2261 struct usb_device *usbdev = NULL;
2262 struct usb_host_interface *iface_desc = NULL; 2262 struct usb_host_interface *iface_desc = NULL;
2263 struct usb_interface *first_if; 2263 struct usb_interface *first_if;
2264 struct device *dev = &interface->dev; 2264 struct device *dev = &interface->dev;
2265 int ifnum, sysfs_err; 2265 int ifnum, sysfs_err;
2266 int ret = 0; 2266 int ret = 0;
2267 struct imon_context *ictx = NULL; 2267 struct imon_context *ictx = NULL;
2268 struct imon_context *first_if_ctx = NULL; 2268 struct imon_context *first_if_ctx = NULL;
2269 u16 vendor, product; 2269 u16 vendor, product;
2270 2270
2271 usbdev = usb_get_dev(interface_to_usbdev(interface)); 2271 usbdev = usb_get_dev(interface_to_usbdev(interface));
2272 iface_desc = interface->cur_altsetting; 2272 iface_desc = interface->cur_altsetting;
2273 ifnum = iface_desc->desc.bInterfaceNumber; 2273 ifnum = iface_desc->desc.bInterfaceNumber;
2274 vendor = le16_to_cpu(usbdev->descriptor.idVendor); 2274 vendor = le16_to_cpu(usbdev->descriptor.idVendor);
2275 product = le16_to_cpu(usbdev->descriptor.idProduct); 2275 product = le16_to_cpu(usbdev->descriptor.idProduct);
2276 2276
2277 dev_dbg(dev, "%s: found iMON device (%04x:%04x, intf%d)\n", 2277 dev_dbg(dev, "%s: found iMON device (%04x:%04x, intf%d)\n",
2278 __func__, vendor, product, ifnum); 2278 __func__, vendor, product, ifnum);
2279 2279
2280 /* prevent races probing devices w/multiple interfaces */ 2280 /* prevent races probing devices w/multiple interfaces */
2281 mutex_lock(&driver_lock); 2281 mutex_lock(&driver_lock);
2282 2282
2283 first_if = usb_ifnum_to_if(usbdev, 0); 2283 first_if = usb_ifnum_to_if(usbdev, 0);
2284 first_if_ctx = usb_get_intfdata(first_if); 2284 first_if_ctx = usb_get_intfdata(first_if);
2285 2285
2286 if (ifnum == 0) { 2286 if (ifnum == 0) {
2287 ictx = imon_init_intf0(interface); 2287 ictx = imon_init_intf0(interface);
2288 if (!ictx) { 2288 if (!ictx) {
2289 pr_err("failed to initialize context!\n"); 2289 pr_err("failed to initialize context!\n");
2290 ret = -ENODEV; 2290 ret = -ENODEV;
2291 goto fail; 2291 goto fail;
2292 } 2292 }
2293 2293
2294 } else { 2294 } else {
2295 /* this is the secondary interface on the device */ 2295 /* this is the secondary interface on the device */
2296 ictx = imon_init_intf1(interface, first_if_ctx); 2296 ictx = imon_init_intf1(interface, first_if_ctx);
2297 if (!ictx) { 2297 if (!ictx) {
2298 pr_err("failed to attach to context!\n"); 2298 pr_err("failed to attach to context!\n");
2299 ret = -ENODEV; 2299 ret = -ENODEV;
2300 goto fail; 2300 goto fail;
2301 } 2301 }
2302 2302
2303 } 2303 }
2304 2304
2305 usb_set_intfdata(interface, ictx); 2305 usb_set_intfdata(interface, ictx);
2306 2306
2307 if (ifnum == 0) { 2307 if (ifnum == 0) {
2308 mutex_lock(&ictx->lock); 2308 mutex_lock(&ictx->lock);
2309 2309
2310 if (product == 0xffdc && ictx->rf_device) { 2310 if (product == 0xffdc && ictx->rf_device) {
2311 sysfs_err = sysfs_create_group(&interface->dev.kobj, 2311 sysfs_err = sysfs_create_group(&interface->dev.kobj,
2312 &imon_rf_attr_group); 2312 &imon_rf_attr_group);
2313 if (sysfs_err) 2313 if (sysfs_err)
2314 pr_err("Could not create RF sysfs entries(%d)\n", 2314 pr_err("Could not create RF sysfs entries(%d)\n",
2315 sysfs_err); 2315 sysfs_err);
2316 } 2316 }
2317 2317
2318 if (ictx->display_supported) 2318 if (ictx->display_supported)
2319 imon_init_display(ictx, interface); 2319 imon_init_display(ictx, interface);
2320 2320
2321 mutex_unlock(&ictx->lock); 2321 mutex_unlock(&ictx->lock);
2322 } 2322 }
2323 2323
2324 dev_info(dev, "iMON device (%04x:%04x, intf%d) on " 2324 dev_info(dev, "iMON device (%04x:%04x, intf%d) on "
2325 "usb<%d:%d> initialized\n", vendor, product, ifnum, 2325 "usb<%d:%d> initialized\n", vendor, product, ifnum,
2326 usbdev->bus->busnum, usbdev->devnum); 2326 usbdev->bus->busnum, usbdev->devnum);
2327 2327
2328 mutex_unlock(&driver_lock); 2328 mutex_unlock(&driver_lock);
2329 2329
2330 return 0; 2330 return 0;
2331 2331
2332 fail: 2332 fail:
2333 mutex_unlock(&driver_lock); 2333 mutex_unlock(&driver_lock);
2334 dev_err(dev, "unable to register, err %d\n", ret); 2334 dev_err(dev, "unable to register, err %d\n", ret);
2335 2335
2336 return ret; 2336 return ret;
2337 } 2337 }
2338 2338
2339 /** 2339 /**
2340 * Callback function for USB core API: disconnect 2340 * Callback function for USB core API: disconnect
2341 */ 2341 */
2342 static void __devexit imon_disconnect(struct usb_interface *interface) 2342 static void __devexit imon_disconnect(struct usb_interface *interface)
2343 { 2343 {
2344 struct imon_context *ictx; 2344 struct imon_context *ictx;
2345 struct device *dev; 2345 struct device *dev;
2346 int ifnum; 2346 int ifnum;
2347 2347
2348 /* prevent races with multi-interface device probing and display_open */ 2348 /* prevent races with multi-interface device probing and display_open */
2349 mutex_lock(&driver_lock); 2349 mutex_lock(&driver_lock);
2350 2350
2351 ictx = usb_get_intfdata(interface); 2351 ictx = usb_get_intfdata(interface);
2352 dev = ictx->dev; 2352 dev = ictx->dev;
2353 ifnum = interface->cur_altsetting->desc.bInterfaceNumber; 2353 ifnum = interface->cur_altsetting->desc.bInterfaceNumber;
2354 2354
2355 /* 2355 /*
2356 * sysfs_remove_group is safe to call even if sysfs_create_group 2356 * sysfs_remove_group is safe to call even if sysfs_create_group
2357 * hasn't been called 2357 * hasn't been called
2358 */ 2358 */
2359 sysfs_remove_group(&interface->dev.kobj, &imon_display_attr_group); 2359 sysfs_remove_group(&interface->dev.kobj, &imon_display_attr_group);
2360 sysfs_remove_group(&interface->dev.kobj, &imon_rf_attr_group); 2360 sysfs_remove_group(&interface->dev.kobj, &imon_rf_attr_group);
2361 2361
2362 usb_set_intfdata(interface, NULL); 2362 usb_set_intfdata(interface, NULL);
2363 2363
2364 /* Abort ongoing write */ 2364 /* Abort ongoing write */
2365 if (ictx->tx.busy) { 2365 if (ictx->tx.busy) {
2366 usb_kill_urb(ictx->tx_urb); 2366 usb_kill_urb(ictx->tx_urb);
2367 complete_all(&ictx->tx.finished); 2367 complete_all(&ictx->tx.finished);
2368 } 2368 }
2369 2369
2370 if (ifnum == 0) { 2370 if (ifnum == 0) {
2371 ictx->dev_present_intf0 = false; 2371 ictx->dev_present_intf0 = false;
2372 usb_kill_urb(ictx->rx_urb_intf0); 2372 usb_kill_urb(ictx->rx_urb_intf0);
2373 input_unregister_device(ictx->idev); 2373 input_unregister_device(ictx->idev);
2374 rc_unregister_device(ictx->rdev); 2374 rc_unregister_device(ictx->rdev);
2375 if (ictx->display_supported) { 2375 if (ictx->display_supported) {
2376 if (ictx->display_type == IMON_DISPLAY_TYPE_LCD) 2376 if (ictx->display_type == IMON_DISPLAY_TYPE_LCD)
2377 usb_deregister_dev(interface, &imon_lcd_class); 2377 usb_deregister_dev(interface, &imon_lcd_class);
2378 else if (ictx->display_type == IMON_DISPLAY_TYPE_VFD) 2378 else if (ictx->display_type == IMON_DISPLAY_TYPE_VFD)
2379 usb_deregister_dev(interface, &imon_vfd_class); 2379 usb_deregister_dev(interface, &imon_vfd_class);
2380 } 2380 }
2381 } else { 2381 } else {
2382 ictx->dev_present_intf1 = false; 2382 ictx->dev_present_intf1 = false;
2383 usb_kill_urb(ictx->rx_urb_intf1); 2383 usb_kill_urb(ictx->rx_urb_intf1);
2384 if (ictx->display_type == IMON_DISPLAY_TYPE_VGA) { 2384 if (ictx->display_type == IMON_DISPLAY_TYPE_VGA) {
2385 input_unregister_device(ictx->touch); 2385 input_unregister_device(ictx->touch);
2386 del_timer_sync(&ictx->ttimer); 2386 del_timer_sync(&ictx->ttimer);
2387 } 2387 }
2388 } 2388 }
2389 2389
2390 if (!ictx->dev_present_intf0 && !ictx->dev_present_intf1) 2390 if (!ictx->dev_present_intf0 && !ictx->dev_present_intf1)
2391 free_imon_context(ictx); 2391 free_imon_context(ictx);
2392 2392
2393 mutex_unlock(&driver_lock); 2393 mutex_unlock(&driver_lock);
2394 2394
2395 dev_dbg(dev, "%s: iMON device (intf%d) disconnected\n", 2395 dev_dbg(dev, "%s: iMON device (intf%d) disconnected\n",
2396 __func__, ifnum); 2396 __func__, ifnum);
2397 } 2397 }
2398 2398
2399 static int imon_suspend(struct usb_interface *intf, pm_message_t message) 2399 static int imon_suspend(struct usb_interface *intf, pm_message_t message)
2400 { 2400 {
2401 struct imon_context *ictx = usb_get_intfdata(intf); 2401 struct imon_context *ictx = usb_get_intfdata(intf);
2402 int ifnum = intf->cur_altsetting->desc.bInterfaceNumber; 2402 int ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
2403 2403
2404 if (ifnum == 0) 2404 if (ifnum == 0)
2405 usb_kill_urb(ictx->rx_urb_intf0); 2405 usb_kill_urb(ictx->rx_urb_intf0);
2406 else 2406 else
2407 usb_kill_urb(ictx->rx_urb_intf1); 2407 usb_kill_urb(ictx->rx_urb_intf1);
2408 2408
2409 return 0; 2409 return 0;
2410 } 2410 }
2411 2411
2412 static int imon_resume(struct usb_interface *intf) 2412 static int imon_resume(struct usb_interface *intf)
2413 { 2413 {
2414 int rc = 0; 2414 int rc = 0;
2415 struct imon_context *ictx = usb_get_intfdata(intf); 2415 struct imon_context *ictx = usb_get_intfdata(intf);
2416 int ifnum = intf->cur_altsetting->desc.bInterfaceNumber; 2416 int ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
2417 2417
2418 if (ifnum == 0) { 2418 if (ifnum == 0) {
2419 usb_fill_int_urb(ictx->rx_urb_intf0, ictx->usbdev_intf0, 2419 usb_fill_int_urb(ictx->rx_urb_intf0, ictx->usbdev_intf0,
2420 usb_rcvintpipe(ictx->usbdev_intf0, 2420 usb_rcvintpipe(ictx->usbdev_intf0,
2421 ictx->rx_endpoint_intf0->bEndpointAddress), 2421 ictx->rx_endpoint_intf0->bEndpointAddress),
2422 ictx->usb_rx_buf, sizeof(ictx->usb_rx_buf), 2422 ictx->usb_rx_buf, sizeof(ictx->usb_rx_buf),
2423 usb_rx_callback_intf0, ictx, 2423 usb_rx_callback_intf0, ictx,
2424 ictx->rx_endpoint_intf0->bInterval); 2424 ictx->rx_endpoint_intf0->bInterval);
2425 2425
2426 rc = usb_submit_urb(ictx->rx_urb_intf0, GFP_ATOMIC); 2426 rc = usb_submit_urb(ictx->rx_urb_intf0, GFP_ATOMIC);
2427 2427
2428 } else { 2428 } else {
2429 usb_fill_int_urb(ictx->rx_urb_intf1, ictx->usbdev_intf1, 2429 usb_fill_int_urb(ictx->rx_urb_intf1, ictx->usbdev_intf1,
2430 usb_rcvintpipe(ictx->usbdev_intf1, 2430 usb_rcvintpipe(ictx->usbdev_intf1,
2431 ictx->rx_endpoint_intf1->bEndpointAddress), 2431 ictx->rx_endpoint_intf1->bEndpointAddress),
2432 ictx->usb_rx_buf, sizeof(ictx->usb_rx_buf), 2432 ictx->usb_rx_buf, sizeof(ictx->usb_rx_buf),
2433 usb_rx_callback_intf1, ictx, 2433 usb_rx_callback_intf1, ictx,
2434 ictx->rx_endpoint_intf1->bInterval); 2434 ictx->rx_endpoint_intf1->bInterval);
2435 2435
2436 rc = usb_submit_urb(ictx->rx_urb_intf1, GFP_ATOMIC); 2436 rc = usb_submit_urb(ictx->rx_urb_intf1, GFP_ATOMIC);
2437 } 2437 }
2438 2438
2439 return rc; 2439 return rc;
2440 } 2440 }
2441 2441
2442 static int __init imon_init(void) 2442 static int __init imon_init(void)
2443 { 2443 {
2444 int rc; 2444 int rc;
2445 2445
2446 rc = usb_register(&imon_driver); 2446 rc = usb_register(&imon_driver);
2447 if (rc) { 2447 if (rc) {
2448 pr_err("usb register failed(%d)\n", rc); 2448 pr_err("usb register failed(%d)\n", rc);
2449 rc = -ENODEV; 2449 rc = -ENODEV;
2450 } 2450 }
2451 2451
2452 return rc; 2452 return rc;
2453 } 2453 }
2454 2454
2455 static void __exit imon_exit(void) 2455 static void __exit imon_exit(void)
2456 { 2456 {
2457 usb_deregister(&imon_driver); 2457 usb_deregister(&imon_driver);
2458 } 2458 }
2459 2459
2460 module_init(imon_init); 2460 module_init(imon_init);
2461 module_exit(imon_exit); 2461 module_exit(imon_exit);
2462 2462