1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Driver for the VoIP USB phones with CM109 chipsets. |
4 | * |
5 | * Copyright (C) 2007 - 2008 Alfred E. Heggestad <aeh@db.org> |
6 | */ |
7 | |
8 | /* |
9 | * Tested devices: |
10 | * - Komunikate KIP1000 |
11 | * - Genius G-talk |
12 | * - Allied-Telesis Corega USBPH01 |
13 | * - ... |
14 | * |
15 | * This driver is based on the yealink.c driver |
16 | * |
17 | * Thanks to: |
18 | * - Authors of yealink.c |
19 | * - Thomas Reitmayr |
20 | * - Oliver Neukum for good review comments and code |
21 | * - Shaun Jackman <sjackman@gmail.com> for Genius G-talk keymap |
22 | * - Dmitry Torokhov for valuable input and review |
23 | * |
24 | * Todo: |
25 | * - Read/write EEPROM |
26 | */ |
27 | |
28 | #include <linux/kernel.h> |
29 | #include <linux/init.h> |
30 | #include <linux/slab.h> |
31 | #include <linux/module.h> |
32 | #include <linux/moduleparam.h> |
33 | #include <linux/rwsem.h> |
34 | #include <linux/usb/input.h> |
35 | |
36 | #define DRIVER_VERSION "20080805" |
37 | #define DRIVER_AUTHOR "Alfred E. Heggestad" |
38 | #define DRIVER_DESC "CM109 phone driver" |
39 | |
40 | static char *phone = "kip1000" ; |
41 | module_param(phone, charp, S_IRUSR); |
42 | MODULE_PARM_DESC(phone, "Phone name {kip1000, gtalk, usbph01, atcom}" ); |
43 | |
44 | enum { |
45 | /* HID Registers */ |
46 | HID_IR0 = 0x00, /* Record/Playback-mute button, Volume up/down */ |
47 | HID_IR1 = 0x01, /* GPI, generic registers or EEPROM_DATA0 */ |
48 | HID_IR2 = 0x02, /* Generic registers or EEPROM_DATA1 */ |
49 | HID_IR3 = 0x03, /* Generic registers or EEPROM_CTRL */ |
50 | HID_OR0 = 0x00, /* Mapping control, buzzer, SPDIF (offset 0x04) */ |
51 | HID_OR1 = 0x01, /* GPO - General Purpose Output */ |
52 | HID_OR2 = 0x02, /* Set GPIO to input/output mode */ |
53 | HID_OR3 = 0x03, /* SPDIF status channel or EEPROM_CTRL */ |
54 | |
55 | /* HID_IR0 */ |
56 | RECORD_MUTE = 1 << 3, |
57 | PLAYBACK_MUTE = 1 << 2, |
58 | VOLUME_DOWN = 1 << 1, |
59 | VOLUME_UP = 1 << 0, |
60 | |
61 | /* HID_OR0 */ |
62 | /* bits 7-6 |
63 | 0: HID_OR1-2 are used for GPO; HID_OR0, 3 are used for buzzer |
64 | and SPDIF |
65 | 1: HID_OR0-3 are used as generic HID registers |
66 | 2: Values written to HID_OR0-3 are also mapped to MCU_CTRL, |
67 | EEPROM_DATA0-1, EEPROM_CTRL (see Note) |
68 | 3: Reserved |
69 | */ |
70 | HID_OR_GPO_BUZ_SPDIF = 0 << 6, |
71 | HID_OR_GENERIC_HID_REG = 1 << 6, |
72 | HID_OR_MAP_MCU_EEPROM = 2 << 6, |
73 | |
74 | BUZZER_ON = 1 << 5, |
75 | |
76 | /* up to 256 normal keys, up to 15 special key combinations */ |
77 | KEYMAP_SIZE = 256 + 15, |
78 | }; |
79 | |
80 | /* CM109 protocol packet */ |
81 | struct cm109_ctl_packet { |
82 | u8 byte[4]; |
83 | } __attribute__ ((packed)); |
84 | |
85 | enum { USB_PKT_LEN = sizeof(struct cm109_ctl_packet) }; |
86 | |
87 | /* CM109 device structure */ |
88 | struct cm109_dev { |
89 | struct input_dev *idev; /* input device */ |
90 | struct usb_device *udev; /* usb device */ |
91 | struct usb_interface *intf; |
92 | |
93 | /* irq input channel */ |
94 | struct cm109_ctl_packet *irq_data; |
95 | dma_addr_t irq_dma; |
96 | struct urb *urb_irq; |
97 | |
98 | /* control output channel */ |
99 | struct cm109_ctl_packet *ctl_data; |
100 | dma_addr_t ctl_dma; |
101 | struct usb_ctrlrequest *ctl_req; |
102 | struct urb *urb_ctl; |
103 | /* |
104 | * The 3 bitfields below are protected by ctl_submit_lock. |
105 | * They have to be separate since they are accessed from IRQ |
106 | * context. |
107 | */ |
108 | unsigned irq_urb_pending:1; /* irq_urb is in flight */ |
109 | unsigned ctl_urb_pending:1; /* ctl_urb is in flight */ |
110 | unsigned buzzer_pending:1; /* need to issue buzz command */ |
111 | spinlock_t ctl_submit_lock; |
112 | |
113 | unsigned char buzzer_state; /* on/off */ |
114 | |
115 | /* flags */ |
116 | unsigned open:1; |
117 | unsigned resetting:1; |
118 | unsigned shutdown:1; |
119 | |
120 | /* This mutex protects writes to the above flags */ |
121 | struct mutex pm_mutex; |
122 | |
123 | unsigned short keymap[KEYMAP_SIZE]; |
124 | |
125 | char phys[64]; /* physical device path */ |
126 | int key_code; /* last reported key */ |
127 | int keybit; /* 0=new scan 1,2,4,8=scan columns */ |
128 | u8 gpi; /* Cached value of GPI (high nibble) */ |
129 | }; |
130 | |
131 | /****************************************************************************** |
132 | * CM109 key interface |
133 | *****************************************************************************/ |
134 | |
135 | static unsigned short special_keymap(int code) |
136 | { |
137 | if (code > 0xff) { |
138 | switch (code - 0xff) { |
139 | case RECORD_MUTE: return KEY_MICMUTE; |
140 | case PLAYBACK_MUTE: return KEY_MUTE; |
141 | case VOLUME_DOWN: return KEY_VOLUMEDOWN; |
142 | case VOLUME_UP: return KEY_VOLUMEUP; |
143 | } |
144 | } |
145 | return KEY_RESERVED; |
146 | } |
147 | |
148 | /* Map device buttons to internal key events. |
149 | * |
150 | * The "up" and "down" keys, are symbolised by arrows on the button. |
151 | * The "pickup" and "hangup" keys are symbolised by a green and red phone |
152 | * on the button. |
153 | |
154 | Komunikate KIP1000 Keyboard Matrix |
155 | |
156 | -> -- 1 -- 2 -- 3 --> GPI pin 4 (0x10) |
157 | | | | | |
158 | <- -- 4 -- 5 -- 6 --> GPI pin 5 (0x20) |
159 | | | | | |
160 | END - 7 -- 8 -- 9 --> GPI pin 6 (0x40) |
161 | | | | | |
162 | OK -- * -- 0 -- # --> GPI pin 7 (0x80) |
163 | | | | | |
164 | |
165 | /|\ /|\ /|\ /|\ |
166 | | | | | |
167 | GPO |
168 | pin: 3 2 1 0 |
169 | 0x8 0x4 0x2 0x1 |
170 | |
171 | */ |
172 | static unsigned short keymap_kip1000(int scancode) |
173 | { |
174 | switch (scancode) { /* phone key: */ |
175 | case 0x82: return KEY_NUMERIC_0; /* 0 */ |
176 | case 0x14: return KEY_NUMERIC_1; /* 1 */ |
177 | case 0x12: return KEY_NUMERIC_2; /* 2 */ |
178 | case 0x11: return KEY_NUMERIC_3; /* 3 */ |
179 | case 0x24: return KEY_NUMERIC_4; /* 4 */ |
180 | case 0x22: return KEY_NUMERIC_5; /* 5 */ |
181 | case 0x21: return KEY_NUMERIC_6; /* 6 */ |
182 | case 0x44: return KEY_NUMERIC_7; /* 7 */ |
183 | case 0x42: return KEY_NUMERIC_8; /* 8 */ |
184 | case 0x41: return KEY_NUMERIC_9; /* 9 */ |
185 | case 0x81: return KEY_NUMERIC_POUND; /* # */ |
186 | case 0x84: return KEY_NUMERIC_STAR; /* * */ |
187 | case 0x88: return KEY_ENTER; /* pickup */ |
188 | case 0x48: return KEY_ESC; /* hangup */ |
189 | case 0x28: return KEY_LEFT; /* IN */ |
190 | case 0x18: return KEY_RIGHT; /* OUT */ |
191 | default: return special_keymap(code: scancode); |
192 | } |
193 | } |
194 | |
195 | /* |
196 | Contributed by Shaun Jackman <sjackman@gmail.com> |
197 | |
198 | Genius G-Talk keyboard matrix |
199 | 0 1 2 3 |
200 | 4: 0 4 8 Talk |
201 | 5: 1 5 9 End |
202 | 6: 2 6 # Up |
203 | 7: 3 7 * Down |
204 | */ |
205 | static unsigned short keymap_gtalk(int scancode) |
206 | { |
207 | switch (scancode) { |
208 | case 0x11: return KEY_NUMERIC_0; |
209 | case 0x21: return KEY_NUMERIC_1; |
210 | case 0x41: return KEY_NUMERIC_2; |
211 | case 0x81: return KEY_NUMERIC_3; |
212 | case 0x12: return KEY_NUMERIC_4; |
213 | case 0x22: return KEY_NUMERIC_5; |
214 | case 0x42: return KEY_NUMERIC_6; |
215 | case 0x82: return KEY_NUMERIC_7; |
216 | case 0x14: return KEY_NUMERIC_8; |
217 | case 0x24: return KEY_NUMERIC_9; |
218 | case 0x44: return KEY_NUMERIC_POUND; /* # */ |
219 | case 0x84: return KEY_NUMERIC_STAR; /* * */ |
220 | case 0x18: return KEY_ENTER; /* Talk (green handset) */ |
221 | case 0x28: return KEY_ESC; /* End (red handset) */ |
222 | case 0x48: return KEY_UP; /* Menu up (rocker switch) */ |
223 | case 0x88: return KEY_DOWN; /* Menu down (rocker switch) */ |
224 | default: return special_keymap(code: scancode); |
225 | } |
226 | } |
227 | |
228 | /* |
229 | * Keymap for Allied-Telesis Corega USBPH01 |
230 | * http://www.alliedtelesis-corega.com/2/1344/1437/1360/chprd.html |
231 | * |
232 | * Contributed by july@nat.bg |
233 | */ |
234 | static unsigned short keymap_usbph01(int scancode) |
235 | { |
236 | switch (scancode) { |
237 | case 0x11: return KEY_NUMERIC_0; /* 0 */ |
238 | case 0x21: return KEY_NUMERIC_1; /* 1 */ |
239 | case 0x41: return KEY_NUMERIC_2; /* 2 */ |
240 | case 0x81: return KEY_NUMERIC_3; /* 3 */ |
241 | case 0x12: return KEY_NUMERIC_4; /* 4 */ |
242 | case 0x22: return KEY_NUMERIC_5; /* 5 */ |
243 | case 0x42: return KEY_NUMERIC_6; /* 6 */ |
244 | case 0x82: return KEY_NUMERIC_7; /* 7 */ |
245 | case 0x14: return KEY_NUMERIC_8; /* 8 */ |
246 | case 0x24: return KEY_NUMERIC_9; /* 9 */ |
247 | case 0x44: return KEY_NUMERIC_POUND; /* # */ |
248 | case 0x84: return KEY_NUMERIC_STAR; /* * */ |
249 | case 0x18: return KEY_ENTER; /* pickup */ |
250 | case 0x28: return KEY_ESC; /* hangup */ |
251 | case 0x48: return KEY_LEFT; /* IN */ |
252 | case 0x88: return KEY_RIGHT; /* OUT */ |
253 | default: return special_keymap(code: scancode); |
254 | } |
255 | } |
256 | |
257 | /* |
258 | * Keymap for ATCom AU-100 |
259 | * http://www.atcom.cn/products.html |
260 | * http://www.packetizer.com/products/au100/ |
261 | * http://www.voip-info.org/wiki/view/AU-100 |
262 | * |
263 | * Contributed by daniel@gimpelevich.san-francisco.ca.us |
264 | */ |
265 | static unsigned short keymap_atcom(int scancode) |
266 | { |
267 | switch (scancode) { /* phone key: */ |
268 | case 0x82: return KEY_NUMERIC_0; /* 0 */ |
269 | case 0x11: return KEY_NUMERIC_1; /* 1 */ |
270 | case 0x12: return KEY_NUMERIC_2; /* 2 */ |
271 | case 0x14: return KEY_NUMERIC_3; /* 3 */ |
272 | case 0x21: return KEY_NUMERIC_4; /* 4 */ |
273 | case 0x22: return KEY_NUMERIC_5; /* 5 */ |
274 | case 0x24: return KEY_NUMERIC_6; /* 6 */ |
275 | case 0x41: return KEY_NUMERIC_7; /* 7 */ |
276 | case 0x42: return KEY_NUMERIC_8; /* 8 */ |
277 | case 0x44: return KEY_NUMERIC_9; /* 9 */ |
278 | case 0x84: return KEY_NUMERIC_POUND; /* # */ |
279 | case 0x81: return KEY_NUMERIC_STAR; /* * */ |
280 | case 0x18: return KEY_ENTER; /* pickup */ |
281 | case 0x28: return KEY_ESC; /* hangup */ |
282 | case 0x48: return KEY_LEFT; /* left arrow */ |
283 | case 0x88: return KEY_RIGHT; /* right arrow */ |
284 | default: return special_keymap(code: scancode); |
285 | } |
286 | } |
287 | |
288 | static unsigned short (*keymap)(int) = keymap_kip1000; |
289 | |
290 | /* |
291 | * Completes a request by converting the data into events for the |
292 | * input subsystem. |
293 | */ |
294 | static void report_key(struct cm109_dev *dev, int key) |
295 | { |
296 | struct input_dev *idev = dev->idev; |
297 | |
298 | if (dev->key_code >= 0) { |
299 | /* old key up */ |
300 | input_report_key(dev: idev, code: dev->key_code, value: 0); |
301 | } |
302 | |
303 | dev->key_code = key; |
304 | if (key >= 0) { |
305 | /* new valid key */ |
306 | input_report_key(dev: idev, code: key, value: 1); |
307 | } |
308 | |
309 | input_sync(dev: idev); |
310 | } |
311 | |
312 | /* |
313 | * Converts data of special key presses (volume, mute) into events |
314 | * for the input subsystem, sends press-n-release for mute keys. |
315 | */ |
316 | static void cm109_report_special(struct cm109_dev *dev) |
317 | { |
318 | static const u8 autorelease = RECORD_MUTE | PLAYBACK_MUTE; |
319 | struct input_dev *idev = dev->idev; |
320 | u8 data = dev->irq_data->byte[HID_IR0]; |
321 | unsigned short keycode; |
322 | int i; |
323 | |
324 | for (i = 0; i < 4; i++) { |
325 | keycode = dev->keymap[0xff + BIT(i)]; |
326 | if (keycode == KEY_RESERVED) |
327 | continue; |
328 | |
329 | input_report_key(dev: idev, code: keycode, value: data & BIT(i)); |
330 | if (data & autorelease & BIT(i)) { |
331 | input_sync(dev: idev); |
332 | input_report_key(dev: idev, code: keycode, value: 0); |
333 | } |
334 | } |
335 | input_sync(dev: idev); |
336 | } |
337 | |
338 | /****************************************************************************** |
339 | * CM109 usb communication interface |
340 | *****************************************************************************/ |
341 | |
342 | static void cm109_submit_buzz_toggle(struct cm109_dev *dev) |
343 | { |
344 | int error; |
345 | |
346 | if (dev->buzzer_state) |
347 | dev->ctl_data->byte[HID_OR0] |= BUZZER_ON; |
348 | else |
349 | dev->ctl_data->byte[HID_OR0] &= ~BUZZER_ON; |
350 | |
351 | error = usb_submit_urb(urb: dev->urb_ctl, GFP_ATOMIC); |
352 | if (error) |
353 | dev_err(&dev->intf->dev, |
354 | "%s: usb_submit_urb (urb_ctl) failed %d\n" , |
355 | __func__, error); |
356 | } |
357 | |
358 | /* |
359 | * IRQ handler |
360 | */ |
361 | static void cm109_urb_irq_callback(struct urb *urb) |
362 | { |
363 | struct cm109_dev *dev = urb->context; |
364 | const int status = urb->status; |
365 | int error; |
366 | unsigned long flags; |
367 | |
368 | dev_dbg(&dev->intf->dev, "### URB IRQ: [0x%02x 0x%02x 0x%02x 0x%02x] keybit=0x%02x\n" , |
369 | dev->irq_data->byte[0], |
370 | dev->irq_data->byte[1], |
371 | dev->irq_data->byte[2], |
372 | dev->irq_data->byte[3], |
373 | dev->keybit); |
374 | |
375 | if (status) { |
376 | if (status == -ESHUTDOWN) |
377 | return; |
378 | dev_err_ratelimited(&dev->intf->dev, "%s: urb status %d\n" , |
379 | __func__, status); |
380 | goto out; |
381 | } |
382 | |
383 | /* Special keys */ |
384 | cm109_report_special(dev); |
385 | |
386 | /* Scan key column */ |
387 | if (dev->keybit == 0xf) { |
388 | |
389 | /* Any changes ? */ |
390 | if ((dev->gpi & 0xf0) == (dev->irq_data->byte[HID_IR1] & 0xf0)) |
391 | goto out; |
392 | |
393 | dev->gpi = dev->irq_data->byte[HID_IR1] & 0xf0; |
394 | dev->keybit = 0x1; |
395 | } else { |
396 | report_key(dev, key: dev->keymap[dev->irq_data->byte[HID_IR1]]); |
397 | |
398 | dev->keybit <<= 1; |
399 | if (dev->keybit > 0x8) |
400 | dev->keybit = 0xf; |
401 | } |
402 | |
403 | out: |
404 | |
405 | spin_lock_irqsave(&dev->ctl_submit_lock, flags); |
406 | |
407 | dev->irq_urb_pending = 0; |
408 | |
409 | if (likely(!dev->shutdown)) { |
410 | |
411 | if (dev->buzzer_state) |
412 | dev->ctl_data->byte[HID_OR0] |= BUZZER_ON; |
413 | else |
414 | dev->ctl_data->byte[HID_OR0] &= ~BUZZER_ON; |
415 | |
416 | dev->ctl_data->byte[HID_OR1] = dev->keybit; |
417 | dev->ctl_data->byte[HID_OR2] = dev->keybit; |
418 | |
419 | dev->buzzer_pending = 0; |
420 | dev->ctl_urb_pending = 1; |
421 | |
422 | error = usb_submit_urb(urb: dev->urb_ctl, GFP_ATOMIC); |
423 | if (error) |
424 | dev_err(&dev->intf->dev, |
425 | "%s: usb_submit_urb (urb_ctl) failed %d\n" , |
426 | __func__, error); |
427 | } |
428 | |
429 | spin_unlock_irqrestore(lock: &dev->ctl_submit_lock, flags); |
430 | } |
431 | |
432 | static void cm109_urb_ctl_callback(struct urb *urb) |
433 | { |
434 | struct cm109_dev *dev = urb->context; |
435 | const int status = urb->status; |
436 | int error; |
437 | unsigned long flags; |
438 | |
439 | dev_dbg(&dev->intf->dev, "### URB CTL: [0x%02x 0x%02x 0x%02x 0x%02x]\n" , |
440 | dev->ctl_data->byte[0], |
441 | dev->ctl_data->byte[1], |
442 | dev->ctl_data->byte[2], |
443 | dev->ctl_data->byte[3]); |
444 | |
445 | if (status) { |
446 | if (status == -ESHUTDOWN) |
447 | return; |
448 | dev_err_ratelimited(&dev->intf->dev, "%s: urb status %d\n" , |
449 | __func__, status); |
450 | } |
451 | |
452 | spin_lock_irqsave(&dev->ctl_submit_lock, flags); |
453 | |
454 | dev->ctl_urb_pending = 0; |
455 | |
456 | if (likely(!dev->shutdown)) { |
457 | |
458 | if (dev->buzzer_pending || status) { |
459 | dev->buzzer_pending = 0; |
460 | dev->ctl_urb_pending = 1; |
461 | cm109_submit_buzz_toggle(dev); |
462 | } else if (likely(!dev->irq_urb_pending)) { |
463 | /* ask for key data */ |
464 | dev->irq_urb_pending = 1; |
465 | error = usb_submit_urb(urb: dev->urb_irq, GFP_ATOMIC); |
466 | if (error) |
467 | dev_err(&dev->intf->dev, |
468 | "%s: usb_submit_urb (urb_irq) failed %d\n" , |
469 | __func__, error); |
470 | } |
471 | } |
472 | |
473 | spin_unlock_irqrestore(lock: &dev->ctl_submit_lock, flags); |
474 | } |
475 | |
476 | static void cm109_toggle_buzzer_async(struct cm109_dev *dev) |
477 | { |
478 | unsigned long flags; |
479 | |
480 | spin_lock_irqsave(&dev->ctl_submit_lock, flags); |
481 | |
482 | if (dev->ctl_urb_pending) { |
483 | /* URB completion will resubmit */ |
484 | dev->buzzer_pending = 1; |
485 | } else { |
486 | dev->ctl_urb_pending = 1; |
487 | cm109_submit_buzz_toggle(dev); |
488 | } |
489 | |
490 | spin_unlock_irqrestore(lock: &dev->ctl_submit_lock, flags); |
491 | } |
492 | |
493 | static void cm109_toggle_buzzer_sync(struct cm109_dev *dev, int on) |
494 | { |
495 | int error; |
496 | |
497 | if (on) |
498 | dev->ctl_data->byte[HID_OR0] |= BUZZER_ON; |
499 | else |
500 | dev->ctl_data->byte[HID_OR0] &= ~BUZZER_ON; |
501 | |
502 | error = usb_control_msg(dev: dev->udev, |
503 | usb_sndctrlpipe(dev->udev, 0), |
504 | request: dev->ctl_req->bRequest, |
505 | requesttype: dev->ctl_req->bRequestType, |
506 | le16_to_cpu(dev->ctl_req->wValue), |
507 | le16_to_cpu(dev->ctl_req->wIndex), |
508 | data: dev->ctl_data, |
509 | size: USB_PKT_LEN, USB_CTRL_SET_TIMEOUT); |
510 | if (error < 0 && error != -EINTR) |
511 | dev_err(&dev->intf->dev, "%s: usb_control_msg() failed %d\n" , |
512 | __func__, error); |
513 | } |
514 | |
515 | static void cm109_stop_traffic(struct cm109_dev *dev) |
516 | { |
517 | dev->shutdown = 1; |
518 | /* |
519 | * Make sure other CPUs see this |
520 | */ |
521 | smp_wmb(); |
522 | |
523 | usb_kill_urb(urb: dev->urb_ctl); |
524 | usb_kill_urb(urb: dev->urb_irq); |
525 | |
526 | cm109_toggle_buzzer_sync(dev, on: 0); |
527 | |
528 | dev->shutdown = 0; |
529 | smp_wmb(); |
530 | } |
531 | |
532 | static void cm109_restore_state(struct cm109_dev *dev) |
533 | { |
534 | if (dev->open) { |
535 | /* |
536 | * Restore buzzer state. |
537 | * This will also kick regular URB submission |
538 | */ |
539 | cm109_toggle_buzzer_async(dev); |
540 | } |
541 | } |
542 | |
543 | /****************************************************************************** |
544 | * input event interface |
545 | *****************************************************************************/ |
546 | |
547 | static int cm109_input_open(struct input_dev *idev) |
548 | { |
549 | struct cm109_dev *dev = input_get_drvdata(dev: idev); |
550 | int error; |
551 | |
552 | error = usb_autopm_get_interface(intf: dev->intf); |
553 | if (error < 0) { |
554 | dev_err(&idev->dev, "%s - cannot autoresume, result %d\n" , |
555 | __func__, error); |
556 | return error; |
557 | } |
558 | |
559 | mutex_lock(&dev->pm_mutex); |
560 | |
561 | dev->buzzer_state = 0; |
562 | dev->key_code = -1; /* no keys pressed */ |
563 | dev->keybit = 0xf; |
564 | |
565 | /* issue INIT */ |
566 | dev->ctl_data->byte[HID_OR0] = HID_OR_GPO_BUZ_SPDIF; |
567 | dev->ctl_data->byte[HID_OR1] = dev->keybit; |
568 | dev->ctl_data->byte[HID_OR2] = dev->keybit; |
569 | dev->ctl_data->byte[HID_OR3] = 0x00; |
570 | |
571 | dev->ctl_urb_pending = 1; |
572 | error = usb_submit_urb(urb: dev->urb_ctl, GFP_KERNEL); |
573 | if (error) { |
574 | dev->ctl_urb_pending = 0; |
575 | dev_err(&dev->intf->dev, "%s: usb_submit_urb (urb_ctl) failed %d\n" , |
576 | __func__, error); |
577 | } else { |
578 | dev->open = 1; |
579 | } |
580 | |
581 | mutex_unlock(lock: &dev->pm_mutex); |
582 | |
583 | if (error) |
584 | usb_autopm_put_interface(intf: dev->intf); |
585 | |
586 | return error; |
587 | } |
588 | |
589 | static void cm109_input_close(struct input_dev *idev) |
590 | { |
591 | struct cm109_dev *dev = input_get_drvdata(dev: idev); |
592 | |
593 | mutex_lock(&dev->pm_mutex); |
594 | |
595 | /* |
596 | * Once we are here event delivery is stopped so we |
597 | * don't need to worry about someone starting buzzer |
598 | * again |
599 | */ |
600 | cm109_stop_traffic(dev); |
601 | dev->open = 0; |
602 | |
603 | mutex_unlock(lock: &dev->pm_mutex); |
604 | |
605 | usb_autopm_put_interface(intf: dev->intf); |
606 | } |
607 | |
608 | static int cm109_input_ev(struct input_dev *idev, unsigned int type, |
609 | unsigned int code, int value) |
610 | { |
611 | struct cm109_dev *dev = input_get_drvdata(dev: idev); |
612 | |
613 | dev_dbg(&dev->intf->dev, |
614 | "input_ev: type=%u code=%u value=%d\n" , type, code, value); |
615 | |
616 | if (type != EV_SND) |
617 | return -EINVAL; |
618 | |
619 | switch (code) { |
620 | case SND_TONE: |
621 | case SND_BELL: |
622 | dev->buzzer_state = !!value; |
623 | if (!dev->resetting) |
624 | cm109_toggle_buzzer_async(dev); |
625 | return 0; |
626 | |
627 | default: |
628 | return -EINVAL; |
629 | } |
630 | } |
631 | |
632 | |
633 | /****************************************************************************** |
634 | * Linux interface and usb initialisation |
635 | *****************************************************************************/ |
636 | |
637 | struct driver_info { |
638 | char *name; |
639 | }; |
640 | |
641 | static const struct driver_info info_cm109 = { |
642 | .name = "CM109 USB driver" , |
643 | }; |
644 | |
645 | enum { |
646 | VENDOR_ID = 0x0d8c, /* C-Media Electronics */ |
647 | PRODUCT_ID_CM109 = 0x000e, /* CM109 defines range 0x0008 - 0x000f */ |
648 | }; |
649 | |
650 | /* table of devices that work with this driver */ |
651 | static const struct usb_device_id cm109_usb_table[] = { |
652 | { |
653 | .match_flags = USB_DEVICE_ID_MATCH_DEVICE | |
654 | USB_DEVICE_ID_MATCH_INT_INFO, |
655 | .idVendor = VENDOR_ID, |
656 | .idProduct = PRODUCT_ID_CM109, |
657 | .bInterfaceClass = USB_CLASS_HID, |
658 | .bInterfaceSubClass = 0, |
659 | .bInterfaceProtocol = 0, |
660 | .driver_info = (kernel_ulong_t) &info_cm109 |
661 | }, |
662 | /* you can add more devices here with product ID 0x0008 - 0x000f */ |
663 | { } |
664 | }; |
665 | |
666 | static void cm109_usb_cleanup(struct cm109_dev *dev) |
667 | { |
668 | kfree(objp: dev->ctl_req); |
669 | usb_free_coherent(dev: dev->udev, size: USB_PKT_LEN, addr: dev->ctl_data, dma: dev->ctl_dma); |
670 | usb_free_coherent(dev: dev->udev, size: USB_PKT_LEN, addr: dev->irq_data, dma: dev->irq_dma); |
671 | |
672 | usb_free_urb(urb: dev->urb_irq); /* parameter validation in core/urb */ |
673 | usb_free_urb(urb: dev->urb_ctl); /* parameter validation in core/urb */ |
674 | kfree(objp: dev); |
675 | } |
676 | |
677 | static void cm109_usb_disconnect(struct usb_interface *interface) |
678 | { |
679 | struct cm109_dev *dev = usb_get_intfdata(intf: interface); |
680 | |
681 | usb_set_intfdata(intf: interface, NULL); |
682 | input_unregister_device(dev->idev); |
683 | cm109_usb_cleanup(dev); |
684 | } |
685 | |
686 | static int cm109_usb_probe(struct usb_interface *intf, |
687 | const struct usb_device_id *id) |
688 | { |
689 | struct usb_device *udev = interface_to_usbdev(intf); |
690 | struct driver_info *nfo = (struct driver_info *)id->driver_info; |
691 | struct usb_host_interface *interface; |
692 | struct usb_endpoint_descriptor *endpoint; |
693 | struct cm109_dev *dev; |
694 | struct input_dev *input_dev = NULL; |
695 | int ret, pipe, i; |
696 | int error = -ENOMEM; |
697 | |
698 | interface = intf->cur_altsetting; |
699 | |
700 | if (interface->desc.bNumEndpoints < 1) |
701 | return -ENODEV; |
702 | |
703 | endpoint = &interface->endpoint[0].desc; |
704 | |
705 | if (!usb_endpoint_is_int_in(epd: endpoint)) |
706 | return -ENODEV; |
707 | |
708 | dev = kzalloc(size: sizeof(*dev), GFP_KERNEL); |
709 | if (!dev) |
710 | return -ENOMEM; |
711 | |
712 | spin_lock_init(&dev->ctl_submit_lock); |
713 | mutex_init(&dev->pm_mutex); |
714 | |
715 | dev->udev = udev; |
716 | dev->intf = intf; |
717 | |
718 | dev->idev = input_dev = input_allocate_device(); |
719 | if (!input_dev) |
720 | goto err_out; |
721 | |
722 | /* allocate usb buffers */ |
723 | dev->irq_data = usb_alloc_coherent(dev: udev, size: USB_PKT_LEN, |
724 | GFP_KERNEL, dma: &dev->irq_dma); |
725 | if (!dev->irq_data) |
726 | goto err_out; |
727 | |
728 | dev->ctl_data = usb_alloc_coherent(dev: udev, size: USB_PKT_LEN, |
729 | GFP_KERNEL, dma: &dev->ctl_dma); |
730 | if (!dev->ctl_data) |
731 | goto err_out; |
732 | |
733 | dev->ctl_req = kmalloc(size: sizeof(*(dev->ctl_req)), GFP_KERNEL); |
734 | if (!dev->ctl_req) |
735 | goto err_out; |
736 | |
737 | /* allocate urb structures */ |
738 | dev->urb_irq = usb_alloc_urb(iso_packets: 0, GFP_KERNEL); |
739 | if (!dev->urb_irq) |
740 | goto err_out; |
741 | |
742 | dev->urb_ctl = usb_alloc_urb(iso_packets: 0, GFP_KERNEL); |
743 | if (!dev->urb_ctl) |
744 | goto err_out; |
745 | |
746 | /* get a handle to the interrupt data pipe */ |
747 | pipe = usb_rcvintpipe(udev, endpoint->bEndpointAddress); |
748 | ret = usb_maxpacket(udev, pipe); |
749 | if (ret != USB_PKT_LEN) |
750 | dev_err(&intf->dev, "invalid payload size %d, expected %d\n" , |
751 | ret, USB_PKT_LEN); |
752 | |
753 | /* initialise irq urb */ |
754 | usb_fill_int_urb(urb: dev->urb_irq, dev: udev, pipe, transfer_buffer: dev->irq_data, |
755 | buffer_length: USB_PKT_LEN, |
756 | complete_fn: cm109_urb_irq_callback, context: dev, interval: endpoint->bInterval); |
757 | dev->urb_irq->transfer_dma = dev->irq_dma; |
758 | dev->urb_irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; |
759 | dev->urb_irq->dev = udev; |
760 | |
761 | /* initialise ctl urb */ |
762 | dev->ctl_req->bRequestType = USB_TYPE_CLASS | USB_RECIP_INTERFACE | |
763 | USB_DIR_OUT; |
764 | dev->ctl_req->bRequest = USB_REQ_SET_CONFIGURATION; |
765 | dev->ctl_req->wValue = cpu_to_le16(0x200); |
766 | dev->ctl_req->wIndex = cpu_to_le16(interface->desc.bInterfaceNumber); |
767 | dev->ctl_req->wLength = cpu_to_le16(USB_PKT_LEN); |
768 | |
769 | usb_fill_control_urb(urb: dev->urb_ctl, dev: udev, usb_sndctrlpipe(udev, 0), |
770 | setup_packet: (void *)dev->ctl_req, transfer_buffer: dev->ctl_data, buffer_length: USB_PKT_LEN, |
771 | complete_fn: cm109_urb_ctl_callback, context: dev); |
772 | dev->urb_ctl->transfer_dma = dev->ctl_dma; |
773 | dev->urb_ctl->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; |
774 | dev->urb_ctl->dev = udev; |
775 | |
776 | /* find out the physical bus location */ |
777 | usb_make_path(dev: udev, buf: dev->phys, size: sizeof(dev->phys)); |
778 | strlcat(p: dev->phys, q: "/input0" , avail: sizeof(dev->phys)); |
779 | |
780 | /* register settings for the input device */ |
781 | input_dev->name = nfo->name; |
782 | input_dev->phys = dev->phys; |
783 | usb_to_input_id(dev: udev, id: &input_dev->id); |
784 | input_dev->dev.parent = &intf->dev; |
785 | |
786 | input_set_drvdata(dev: input_dev, data: dev); |
787 | input_dev->open = cm109_input_open; |
788 | input_dev->close = cm109_input_close; |
789 | input_dev->event = cm109_input_ev; |
790 | |
791 | input_dev->keycode = dev->keymap; |
792 | input_dev->keycodesize = sizeof(unsigned char); |
793 | input_dev->keycodemax = ARRAY_SIZE(dev->keymap); |
794 | |
795 | input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_SND); |
796 | input_dev->sndbit[0] = BIT_MASK(SND_BELL) | BIT_MASK(SND_TONE); |
797 | |
798 | /* register available key events */ |
799 | for (i = 0; i < KEYMAP_SIZE; i++) { |
800 | unsigned short k = keymap(i); |
801 | dev->keymap[i] = k; |
802 | __set_bit(k, input_dev->keybit); |
803 | } |
804 | __clear_bit(KEY_RESERVED, input_dev->keybit); |
805 | |
806 | error = input_register_device(dev->idev); |
807 | if (error) |
808 | goto err_out; |
809 | |
810 | usb_set_intfdata(intf, data: dev); |
811 | |
812 | return 0; |
813 | |
814 | err_out: |
815 | input_free_device(dev: input_dev); |
816 | cm109_usb_cleanup(dev); |
817 | return error; |
818 | } |
819 | |
820 | static int cm109_usb_suspend(struct usb_interface *intf, pm_message_t message) |
821 | { |
822 | struct cm109_dev *dev = usb_get_intfdata(intf); |
823 | |
824 | dev_info(&intf->dev, "cm109: usb_suspend (event=%d)\n" , message.event); |
825 | |
826 | mutex_lock(&dev->pm_mutex); |
827 | cm109_stop_traffic(dev); |
828 | mutex_unlock(lock: &dev->pm_mutex); |
829 | |
830 | return 0; |
831 | } |
832 | |
833 | static int cm109_usb_resume(struct usb_interface *intf) |
834 | { |
835 | struct cm109_dev *dev = usb_get_intfdata(intf); |
836 | |
837 | dev_info(&intf->dev, "cm109: usb_resume\n" ); |
838 | |
839 | mutex_lock(&dev->pm_mutex); |
840 | cm109_restore_state(dev); |
841 | mutex_unlock(lock: &dev->pm_mutex); |
842 | |
843 | return 0; |
844 | } |
845 | |
846 | static int cm109_usb_pre_reset(struct usb_interface *intf) |
847 | { |
848 | struct cm109_dev *dev = usb_get_intfdata(intf); |
849 | |
850 | mutex_lock(&dev->pm_mutex); |
851 | |
852 | /* |
853 | * Make sure input events don't try to toggle buzzer |
854 | * while we are resetting |
855 | */ |
856 | dev->resetting = 1; |
857 | smp_wmb(); |
858 | |
859 | cm109_stop_traffic(dev); |
860 | |
861 | return 0; |
862 | } |
863 | |
864 | static int cm109_usb_post_reset(struct usb_interface *intf) |
865 | { |
866 | struct cm109_dev *dev = usb_get_intfdata(intf); |
867 | |
868 | dev->resetting = 0; |
869 | smp_wmb(); |
870 | |
871 | cm109_restore_state(dev); |
872 | |
873 | mutex_unlock(lock: &dev->pm_mutex); |
874 | |
875 | return 0; |
876 | } |
877 | |
878 | static struct usb_driver cm109_driver = { |
879 | .name = "cm109" , |
880 | .probe = cm109_usb_probe, |
881 | .disconnect = cm109_usb_disconnect, |
882 | .suspend = cm109_usb_suspend, |
883 | .resume = cm109_usb_resume, |
884 | .reset_resume = cm109_usb_resume, |
885 | .pre_reset = cm109_usb_pre_reset, |
886 | .post_reset = cm109_usb_post_reset, |
887 | .id_table = cm109_usb_table, |
888 | .supports_autosuspend = 1, |
889 | }; |
890 | |
891 | static int __init cm109_select_keymap(void) |
892 | { |
893 | /* Load the phone keymap */ |
894 | if (!strcasecmp(s1: phone, s2: "kip1000" )) { |
895 | keymap = keymap_kip1000; |
896 | printk(KERN_INFO KBUILD_MODNAME ": " |
897 | "Keymap for Komunikate KIP1000 phone loaded\n" ); |
898 | } else if (!strcasecmp(s1: phone, s2: "gtalk" )) { |
899 | keymap = keymap_gtalk; |
900 | printk(KERN_INFO KBUILD_MODNAME ": " |
901 | "Keymap for Genius G-talk phone loaded\n" ); |
902 | } else if (!strcasecmp(s1: phone, s2: "usbph01" )) { |
903 | keymap = keymap_usbph01; |
904 | printk(KERN_INFO KBUILD_MODNAME ": " |
905 | "Keymap for Allied-Telesis Corega USBPH01 phone loaded\n" ); |
906 | } else if (!strcasecmp(s1: phone, s2: "atcom" )) { |
907 | keymap = keymap_atcom; |
908 | printk(KERN_INFO KBUILD_MODNAME ": " |
909 | "Keymap for ATCom AU-100 phone loaded\n" ); |
910 | } else { |
911 | printk(KERN_ERR KBUILD_MODNAME ": " |
912 | "Unsupported phone: %s\n" , phone); |
913 | return -EINVAL; |
914 | } |
915 | |
916 | return 0; |
917 | } |
918 | |
919 | static int __init cm109_init(void) |
920 | { |
921 | int err; |
922 | |
923 | err = cm109_select_keymap(); |
924 | if (err) |
925 | return err; |
926 | |
927 | err = usb_register(&cm109_driver); |
928 | if (err) |
929 | return err; |
930 | |
931 | printk(KERN_INFO KBUILD_MODNAME ": " |
932 | DRIVER_DESC ": " DRIVER_VERSION " (C) " DRIVER_AUTHOR "\n" ); |
933 | |
934 | return 0; |
935 | } |
936 | |
937 | static void __exit cm109_exit(void) |
938 | { |
939 | usb_deregister(&cm109_driver); |
940 | } |
941 | |
942 | module_init(cm109_init); |
943 | module_exit(cm109_exit); |
944 | |
945 | MODULE_DEVICE_TABLE(usb, cm109_usb_table); |
946 | |
947 | MODULE_AUTHOR(DRIVER_AUTHOR); |
948 | MODULE_DESCRIPTION(DRIVER_DESC); |
949 | MODULE_LICENSE("GPL" ); |
950 | |