2 * Driver for the VoIP USB phones with CM109 chipsets.
4 * Copyright (C) 2007 - 2008 Alfred E. Heggestad <aeh@db.org>
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License as
8 * published by the Free Software Foundation, version 2.
13 * - Komunikate KIP1000
15 * - Allied-Telesis Corega USBPH01
18 * This driver is based on the yealink.c driver
21 * - Authors of yealink.c
23 * - Oliver Neukum for good review comments and code
24 * - Shaun Jackman <sjackman@gmail.com> for Genius G-talk keymap
25 * - Dmitry Torokhov for valuable input and review
31 #include <linux/kernel.h>
32 #include <linux/init.h>
33 #include <linux/slab.h>
34 #include <linux/module.h>
35 #include <linux/moduleparam.h>
36 #include <linux/rwsem.h>
37 #include <linux/usb/input.h>
39 #define DRIVER_VERSION "20080805"
40 #define DRIVER_AUTHOR "Alfred E. Heggestad"
41 #define DRIVER_DESC "CM109 phone driver"
43 static char *phone
= "kip1000";
44 module_param(phone
, charp
, S_IRUSR
);
45 MODULE_PARM_DESC(phone
, "Phone name {kip1000, gtalk, usbph01, atcom}");
49 HID_IR0
= 0x00, /* Record/Playback-mute button, Volume up/down */
50 HID_IR1
= 0x01, /* GPI, generic registers or EEPROM_DATA0 */
51 HID_IR2
= 0x02, /* Generic registers or EEPROM_DATA1 */
52 HID_IR3
= 0x03, /* Generic registers or EEPROM_CTRL */
53 HID_OR0
= 0x00, /* Mapping control, buzzer, SPDIF (offset 0x04) */
54 HID_OR1
= 0x01, /* GPO - General Purpose Output */
55 HID_OR2
= 0x02, /* Set GPIO to input/output mode */
56 HID_OR3
= 0x03, /* SPDIF status channel or EEPROM_CTRL */
60 PLAYBACK_MUTE
= 1 << 2,
66 0: HID_OR1-2 are used for GPO; HID_OR0, 3 are used for buzzer
68 1: HID_OR0-3 are used as generic HID registers
69 2: Values written to HID_OR0-3 are also mapped to MCU_CTRL,
70 EEPROM_DATA0-1, EEPROM_CTRL (see Note)
73 HID_OR_GPO_BUZ_SPDIF
= 0 << 6,
74 HID_OR_GENERIC_HID_REG
= 1 << 6,
75 HID_OR_MAP_MCU_EEPROM
= 2 << 6,
79 /* up to 256 normal keys, up to 16 special keys */
80 KEYMAP_SIZE
= 256 + 16,
83 /* CM109 protocol packet */
84 struct cm109_ctl_packet
{
86 } __attribute__ ((packed
));
88 enum { USB_PKT_LEN
= sizeof(struct cm109_ctl_packet
) };
90 /* CM109 device structure */
92 struct input_dev
*idev
; /* input device */
93 struct usb_device
*udev
; /* usb device */
94 struct usb_interface
*intf
;
96 /* irq input channel */
97 struct cm109_ctl_packet
*irq_data
;
101 /* control output channel */
102 struct cm109_ctl_packet
*ctl_data
;
104 struct usb_ctrlrequest
*ctl_req
;
107 * The 3 bitfields below are protected by ctl_submit_lock.
108 * They have to be separate since they are accessed from IRQ
111 unsigned irq_urb_pending
:1; /* irq_urb is in flight */
112 unsigned ctl_urb_pending
:1; /* ctl_urb is in flight */
113 unsigned buzzer_pending
:1; /* need to issue buzz command */
114 spinlock_t ctl_submit_lock
;
116 unsigned char buzzer_state
; /* on/off */
120 unsigned resetting
:1;
123 /* This mutex protects writes to the above flags */
124 struct mutex pm_mutex
;
126 unsigned short keymap
[KEYMAP_SIZE
];
128 char phys
[64]; /* physical device path */
129 int key_code
; /* last reported key */
130 int keybit
; /* 0=new scan 1,2,4,8=scan columns */
131 u8 gpi
; /* Cached value of GPI (high nibble) */
134 /******************************************************************************
135 * CM109 key interface
136 *****************************************************************************/
138 static unsigned short special_keymap(int code
)
141 switch (code
- 0xff) {
142 case RECORD_MUTE
: return KEY_MUTE
;
143 case PLAYBACK_MUTE
: return KEY_MUTE
;
144 case VOLUME_DOWN
: return KEY_VOLUMEDOWN
;
145 case VOLUME_UP
: return KEY_VOLUMEUP
;
151 /* Map device buttons to internal key events.
153 * The "up" and "down" keys, are symbolised by arrows on the button.
154 * The "pickup" and "hangup" keys are symbolised by a green and red phone
157 Komunikate KIP1000 Keyboard Matrix
159 -> -- 1 -- 2 -- 3 --> GPI pin 4 (0x10)
161 <- -- 4 -- 5 -- 6 --> GPI pin 5 (0x20)
163 END - 7 -- 8 -- 9 --> GPI pin 6 (0x40)
165 OK -- * -- 0 -- # --> GPI pin 7 (0x80)
175 static unsigned short keymap_kip1000(int scancode
)
177 switch (scancode
) { /* phone key: */
178 case 0x82: return KEY_NUMERIC_0
; /* 0 */
179 case 0x14: return KEY_NUMERIC_1
; /* 1 */
180 case 0x12: return KEY_NUMERIC_2
; /* 2 */
181 case 0x11: return KEY_NUMERIC_3
; /* 3 */
182 case 0x24: return KEY_NUMERIC_4
; /* 4 */
183 case 0x22: return KEY_NUMERIC_5
; /* 5 */
184 case 0x21: return KEY_NUMERIC_6
; /* 6 */
185 case 0x44: return KEY_NUMERIC_7
; /* 7 */
186 case 0x42: return KEY_NUMERIC_8
; /* 8 */
187 case 0x41: return KEY_NUMERIC_9
; /* 9 */
188 case 0x81: return KEY_NUMERIC_POUND
; /* # */
189 case 0x84: return KEY_NUMERIC_STAR
; /* * */
190 case 0x88: return KEY_ENTER
; /* pickup */
191 case 0x48: return KEY_ESC
; /* hangup */
192 case 0x28: return KEY_LEFT
; /* IN */
193 case 0x18: return KEY_RIGHT
; /* OUT */
194 default: return special_keymap(scancode
);
199 Contributed by Shaun Jackman <sjackman@gmail.com>
201 Genius G-Talk keyboard matrix
208 static unsigned short keymap_gtalk(int scancode
)
211 case 0x11: return KEY_NUMERIC_0
;
212 case 0x21: return KEY_NUMERIC_1
;
213 case 0x41: return KEY_NUMERIC_2
;
214 case 0x81: return KEY_NUMERIC_3
;
215 case 0x12: return KEY_NUMERIC_4
;
216 case 0x22: return KEY_NUMERIC_5
;
217 case 0x42: return KEY_NUMERIC_6
;
218 case 0x82: return KEY_NUMERIC_7
;
219 case 0x14: return KEY_NUMERIC_8
;
220 case 0x24: return KEY_NUMERIC_9
;
221 case 0x44: return KEY_NUMERIC_POUND
; /* # */
222 case 0x84: return KEY_NUMERIC_STAR
; /* * */
223 case 0x18: return KEY_ENTER
; /* Talk (green handset) */
224 case 0x28: return KEY_ESC
; /* End (red handset) */
225 case 0x48: return KEY_UP
; /* Menu up (rocker switch) */
226 case 0x88: return KEY_DOWN
; /* Menu down (rocker switch) */
227 default: return special_keymap(scancode
);
232 * Keymap for Allied-Telesis Corega USBPH01
233 * http://www.alliedtelesis-corega.com/2/1344/1437/1360/chprd.html
235 * Contributed by july@nat.bg
237 static unsigned short keymap_usbph01(int scancode
)
240 case 0x11: return KEY_NUMERIC_0
; /* 0 */
241 case 0x21: return KEY_NUMERIC_1
; /* 1 */
242 case 0x41: return KEY_NUMERIC_2
; /* 2 */
243 case 0x81: return KEY_NUMERIC_3
; /* 3 */
244 case 0x12: return KEY_NUMERIC_4
; /* 4 */
245 case 0x22: return KEY_NUMERIC_5
; /* 5 */
246 case 0x42: return KEY_NUMERIC_6
; /* 6 */
247 case 0x82: return KEY_NUMERIC_7
; /* 7 */
248 case 0x14: return KEY_NUMERIC_8
; /* 8 */
249 case 0x24: return KEY_NUMERIC_9
; /* 9 */
250 case 0x44: return KEY_NUMERIC_POUND
; /* # */
251 case 0x84: return KEY_NUMERIC_STAR
; /* * */
252 case 0x18: return KEY_ENTER
; /* pickup */
253 case 0x28: return KEY_ESC
; /* hangup */
254 case 0x48: return KEY_LEFT
; /* IN */
255 case 0x88: return KEY_RIGHT
; /* OUT */
256 default: return special_keymap(scancode
);
261 * Keymap for ATCom AU-100
262 * http://www.atcom.cn/products.html
263 * http://www.packetizer.com/products/au100/
264 * http://www.voip-info.org/wiki/view/AU-100
266 * Contributed by daniel@gimpelevich.san-francisco.ca.us
268 static unsigned short keymap_atcom(int scancode
)
270 switch (scancode
) { /* phone key: */
271 case 0x82: return KEY_NUMERIC_0
; /* 0 */
272 case 0x11: return KEY_NUMERIC_1
; /* 1 */
273 case 0x12: return KEY_NUMERIC_2
; /* 2 */
274 case 0x14: return KEY_NUMERIC_3
; /* 3 */
275 case 0x21: return KEY_NUMERIC_4
; /* 4 */
276 case 0x22: return KEY_NUMERIC_5
; /* 5 */
277 case 0x24: return KEY_NUMERIC_6
; /* 6 */
278 case 0x41: return KEY_NUMERIC_7
; /* 7 */
279 case 0x42: return KEY_NUMERIC_8
; /* 8 */
280 case 0x44: return KEY_NUMERIC_9
; /* 9 */
281 case 0x84: return KEY_NUMERIC_POUND
; /* # */
282 case 0x81: return KEY_NUMERIC_STAR
; /* * */
283 case 0x18: return KEY_ENTER
; /* pickup */
284 case 0x28: return KEY_ESC
; /* hangup */
285 case 0x48: return KEY_LEFT
; /* left arrow */
286 case 0x88: return KEY_RIGHT
; /* right arrow */
287 default: return special_keymap(scancode
);
291 static unsigned short (*keymap
)(int) = keymap_kip1000
;
294 * Completes a request by converting the data into events for the
297 static void report_key(struct cm109_dev
*dev
, int key
)
299 struct input_dev
*idev
= dev
->idev
;
301 if (dev
->key_code
>= 0) {
303 input_report_key(idev
, dev
->key_code
, 0);
309 input_report_key(idev
, key
, 1);
315 /******************************************************************************
316 * CM109 usb communication interface
317 *****************************************************************************/
319 static void cm109_submit_buzz_toggle(struct cm109_dev
*dev
)
323 if (dev
->buzzer_state
)
324 dev
->ctl_data
->byte
[HID_OR0
] |= BUZZER_ON
;
326 dev
->ctl_data
->byte
[HID_OR0
] &= ~BUZZER_ON
;
328 error
= usb_submit_urb(dev
->urb_ctl
, GFP_ATOMIC
);
330 dev_err(&dev
->intf
->dev
,
331 "%s: usb_submit_urb (urb_ctl) failed %d\n",
338 static void cm109_urb_irq_callback(struct urb
*urb
)
340 struct cm109_dev
*dev
= urb
->context
;
341 const int status
= urb
->status
;
344 dev_dbg(&dev
->intf
->dev
, "### URB IRQ: [0x%02x 0x%02x 0x%02x 0x%02x] keybit=0x%02x\n",
345 dev
->irq_data
->byte
[0],
346 dev
->irq_data
->byte
[1],
347 dev
->irq_data
->byte
[2],
348 dev
->irq_data
->byte
[3],
352 if (status
== -ESHUTDOWN
)
354 dev_err_ratelimited(&dev
->intf
->dev
, "%s: urb status %d\n",
360 if (dev
->irq_data
->byte
[HID_IR0
] & 0x0f) {
361 const int code
= (dev
->irq_data
->byte
[HID_IR0
] & 0x0f);
362 report_key(dev
, dev
->keymap
[0xff + code
]);
365 /* Scan key column */
366 if (dev
->keybit
== 0xf) {
369 if ((dev
->gpi
& 0xf0) == (dev
->irq_data
->byte
[HID_IR1
] & 0xf0))
372 dev
->gpi
= dev
->irq_data
->byte
[HID_IR1
] & 0xf0;
375 report_key(dev
, dev
->keymap
[dev
->irq_data
->byte
[HID_IR1
]]);
378 if (dev
->keybit
> 0x8)
384 spin_lock(&dev
->ctl_submit_lock
);
386 dev
->irq_urb_pending
= 0;
388 if (likely(!dev
->shutdown
)) {
390 if (dev
->buzzer_state
)
391 dev
->ctl_data
->byte
[HID_OR0
] |= BUZZER_ON
;
393 dev
->ctl_data
->byte
[HID_OR0
] &= ~BUZZER_ON
;
395 dev
->ctl_data
->byte
[HID_OR1
] = dev
->keybit
;
396 dev
->ctl_data
->byte
[HID_OR2
] = dev
->keybit
;
398 dev
->buzzer_pending
= 0;
399 dev
->ctl_urb_pending
= 1;
401 error
= usb_submit_urb(dev
->urb_ctl
, GFP_ATOMIC
);
403 dev_err(&dev
->intf
->dev
,
404 "%s: usb_submit_urb (urb_ctl) failed %d\n",
408 spin_unlock(&dev
->ctl_submit_lock
);
411 static void cm109_urb_ctl_callback(struct urb
*urb
)
413 struct cm109_dev
*dev
= urb
->context
;
414 const int status
= urb
->status
;
417 dev_dbg(&dev
->intf
->dev
, "### URB CTL: [0x%02x 0x%02x 0x%02x 0x%02x]\n",
418 dev
->ctl_data
->byte
[0],
419 dev
->ctl_data
->byte
[1],
420 dev
->ctl_data
->byte
[2],
421 dev
->ctl_data
->byte
[3]);
424 if (status
== -ESHUTDOWN
)
426 dev_err_ratelimited(&dev
->intf
->dev
, "%s: urb status %d\n",
430 spin_lock(&dev
->ctl_submit_lock
);
432 dev
->ctl_urb_pending
= 0;
434 if (likely(!dev
->shutdown
)) {
436 if (dev
->buzzer_pending
|| status
) {
437 dev
->buzzer_pending
= 0;
438 dev
->ctl_urb_pending
= 1;
439 cm109_submit_buzz_toggle(dev
);
440 } else if (likely(!dev
->irq_urb_pending
)) {
441 /* ask for key data */
442 dev
->irq_urb_pending
= 1;
443 error
= usb_submit_urb(dev
->urb_irq
, GFP_ATOMIC
);
445 dev_err(&dev
->intf
->dev
,
446 "%s: usb_submit_urb (urb_irq) failed %d\n",
451 spin_unlock(&dev
->ctl_submit_lock
);
454 static void cm109_toggle_buzzer_async(struct cm109_dev
*dev
)
458 spin_lock_irqsave(&dev
->ctl_submit_lock
, flags
);
460 if (dev
->ctl_urb_pending
) {
461 /* URB completion will resubmit */
462 dev
->buzzer_pending
= 1;
464 dev
->ctl_urb_pending
= 1;
465 cm109_submit_buzz_toggle(dev
);
468 spin_unlock_irqrestore(&dev
->ctl_submit_lock
, flags
);
471 static void cm109_toggle_buzzer_sync(struct cm109_dev
*dev
, int on
)
476 dev
->ctl_data
->byte
[HID_OR0
] |= BUZZER_ON
;
478 dev
->ctl_data
->byte
[HID_OR0
] &= ~BUZZER_ON
;
480 error
= usb_control_msg(dev
->udev
,
481 usb_sndctrlpipe(dev
->udev
, 0),
482 dev
->ctl_req
->bRequest
,
483 dev
->ctl_req
->bRequestType
,
484 le16_to_cpu(dev
->ctl_req
->wValue
),
485 le16_to_cpu(dev
->ctl_req
->wIndex
),
487 USB_PKT_LEN
, USB_CTRL_SET_TIMEOUT
);
488 if (error
< 0 && error
!= -EINTR
)
489 dev_err(&dev
->intf
->dev
, "%s: usb_control_msg() failed %d\n",
493 static void cm109_stop_traffic(struct cm109_dev
*dev
)
497 * Make sure other CPUs see this
501 usb_kill_urb(dev
->urb_ctl
);
502 usb_kill_urb(dev
->urb_irq
);
504 cm109_toggle_buzzer_sync(dev
, 0);
510 static void cm109_restore_state(struct cm109_dev
*dev
)
514 * Restore buzzer state.
515 * This will also kick regular URB submission
517 cm109_toggle_buzzer_async(dev
);
521 /******************************************************************************
522 * input event interface
523 *****************************************************************************/
525 static int cm109_input_open(struct input_dev
*idev
)
527 struct cm109_dev
*dev
= input_get_drvdata(idev
);
530 error
= usb_autopm_get_interface(dev
->intf
);
532 dev_err(&idev
->dev
, "%s - cannot autoresume, result %d\n",
537 mutex_lock(&dev
->pm_mutex
);
539 dev
->buzzer_state
= 0;
540 dev
->key_code
= -1; /* no keys pressed */
544 dev
->ctl_data
->byte
[HID_OR0
] = HID_OR_GPO_BUZ_SPDIF
;
545 dev
->ctl_data
->byte
[HID_OR1
] = dev
->keybit
;
546 dev
->ctl_data
->byte
[HID_OR2
] = dev
->keybit
;
547 dev
->ctl_data
->byte
[HID_OR3
] = 0x00;
549 error
= usb_submit_urb(dev
->urb_ctl
, GFP_KERNEL
);
551 dev_err(&dev
->intf
->dev
, "%s: usb_submit_urb (urb_ctl) failed %d\n",
556 mutex_unlock(&dev
->pm_mutex
);
559 usb_autopm_put_interface(dev
->intf
);
564 static void cm109_input_close(struct input_dev
*idev
)
566 struct cm109_dev
*dev
= input_get_drvdata(idev
);
568 mutex_lock(&dev
->pm_mutex
);
571 * Once we are here event delivery is stopped so we
572 * don't need to worry about someone starting buzzer
575 cm109_stop_traffic(dev
);
578 mutex_unlock(&dev
->pm_mutex
);
580 usb_autopm_put_interface(dev
->intf
);
583 static int cm109_input_ev(struct input_dev
*idev
, unsigned int type
,
584 unsigned int code
, int value
)
586 struct cm109_dev
*dev
= input_get_drvdata(idev
);
588 dev_dbg(&dev
->intf
->dev
,
589 "input_ev: type=%u code=%u value=%d\n", type
, code
, value
);
597 dev
->buzzer_state
= !!value
;
599 cm109_toggle_buzzer_async(dev
);
608 /******************************************************************************
609 * Linux interface and usb initialisation
610 *****************************************************************************/
616 static const struct driver_info info_cm109
= {
617 .name
= "CM109 USB driver",
621 VENDOR_ID
= 0x0d8c, /* C-Media Electronics */
622 PRODUCT_ID_CM109
= 0x000e, /* CM109 defines range 0x0008 - 0x000f */
625 /* table of devices that work with this driver */
626 static const struct usb_device_id cm109_usb_table
[] = {
628 .match_flags
= USB_DEVICE_ID_MATCH_DEVICE
|
629 USB_DEVICE_ID_MATCH_INT_INFO
,
630 .idVendor
= VENDOR_ID
,
631 .idProduct
= PRODUCT_ID_CM109
,
632 .bInterfaceClass
= USB_CLASS_HID
,
633 .bInterfaceSubClass
= 0,
634 .bInterfaceProtocol
= 0,
635 .driver_info
= (kernel_ulong_t
) &info_cm109
637 /* you can add more devices here with product ID 0x0008 - 0x000f */
641 static void cm109_usb_cleanup(struct cm109_dev
*dev
)
645 usb_free_coherent(dev
->udev
, USB_PKT_LEN
,
646 dev
->ctl_data
, dev
->ctl_dma
);
648 usb_free_coherent(dev
->udev
, USB_PKT_LEN
,
649 dev
->irq_data
, dev
->irq_dma
);
651 usb_free_urb(dev
->urb_irq
); /* parameter validation in core/urb */
652 usb_free_urb(dev
->urb_ctl
); /* parameter validation in core/urb */
656 static void cm109_usb_disconnect(struct usb_interface
*interface
)
658 struct cm109_dev
*dev
= usb_get_intfdata(interface
);
660 usb_set_intfdata(interface
, NULL
);
661 input_unregister_device(dev
->idev
);
662 cm109_usb_cleanup(dev
);
665 static int cm109_usb_probe(struct usb_interface
*intf
,
666 const struct usb_device_id
*id
)
668 struct usb_device
*udev
= interface_to_usbdev(intf
);
669 struct driver_info
*nfo
= (struct driver_info
*)id
->driver_info
;
670 struct usb_host_interface
*interface
;
671 struct usb_endpoint_descriptor
*endpoint
;
672 struct cm109_dev
*dev
;
673 struct input_dev
*input_dev
= NULL
;
677 interface
= intf
->cur_altsetting
;
678 endpoint
= &interface
->endpoint
[0].desc
;
680 if (!usb_endpoint_is_int_in(endpoint
))
683 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
687 spin_lock_init(&dev
->ctl_submit_lock
);
688 mutex_init(&dev
->pm_mutex
);
693 dev
->idev
= input_dev
= input_allocate_device();
697 /* allocate usb buffers */
698 dev
->irq_data
= usb_alloc_coherent(udev
, USB_PKT_LEN
,
699 GFP_KERNEL
, &dev
->irq_dma
);
703 dev
->ctl_data
= usb_alloc_coherent(udev
, USB_PKT_LEN
,
704 GFP_KERNEL
, &dev
->ctl_dma
);
708 dev
->ctl_req
= kmalloc(sizeof(*(dev
->ctl_req
)), GFP_KERNEL
);
712 /* allocate urb structures */
713 dev
->urb_irq
= usb_alloc_urb(0, GFP_KERNEL
);
717 dev
->urb_ctl
= usb_alloc_urb(0, GFP_KERNEL
);
721 /* get a handle to the interrupt data pipe */
722 pipe
= usb_rcvintpipe(udev
, endpoint
->bEndpointAddress
);
723 ret
= usb_maxpacket(udev
, pipe
, usb_pipeout(pipe
));
724 if (ret
!= USB_PKT_LEN
)
725 dev_err(&intf
->dev
, "invalid payload size %d, expected %d\n",
728 /* initialise irq urb */
729 usb_fill_int_urb(dev
->urb_irq
, udev
, pipe
, dev
->irq_data
,
731 cm109_urb_irq_callback
, dev
, endpoint
->bInterval
);
732 dev
->urb_irq
->transfer_dma
= dev
->irq_dma
;
733 dev
->urb_irq
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
734 dev
->urb_irq
->dev
= udev
;
736 /* initialise ctl urb */
737 dev
->ctl_req
->bRequestType
= USB_TYPE_CLASS
| USB_RECIP_INTERFACE
|
739 dev
->ctl_req
->bRequest
= USB_REQ_SET_CONFIGURATION
;
740 dev
->ctl_req
->wValue
= cpu_to_le16(0x200);
741 dev
->ctl_req
->wIndex
= cpu_to_le16(interface
->desc
.bInterfaceNumber
);
742 dev
->ctl_req
->wLength
= cpu_to_le16(USB_PKT_LEN
);
744 usb_fill_control_urb(dev
->urb_ctl
, udev
, usb_sndctrlpipe(udev
, 0),
745 (void *)dev
->ctl_req
, dev
->ctl_data
, USB_PKT_LEN
,
746 cm109_urb_ctl_callback
, dev
);
747 dev
->urb_ctl
->transfer_dma
= dev
->ctl_dma
;
748 dev
->urb_ctl
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
749 dev
->urb_ctl
->dev
= udev
;
751 /* find out the physical bus location */
752 usb_make_path(udev
, dev
->phys
, sizeof(dev
->phys
));
753 strlcat(dev
->phys
, "/input0", sizeof(dev
->phys
));
755 /* register settings for the input device */
756 input_dev
->name
= nfo
->name
;
757 input_dev
->phys
= dev
->phys
;
758 usb_to_input_id(udev
, &input_dev
->id
);
759 input_dev
->dev
.parent
= &intf
->dev
;
761 input_set_drvdata(input_dev
, dev
);
762 input_dev
->open
= cm109_input_open
;
763 input_dev
->close
= cm109_input_close
;
764 input_dev
->event
= cm109_input_ev
;
766 input_dev
->keycode
= dev
->keymap
;
767 input_dev
->keycodesize
= sizeof(unsigned char);
768 input_dev
->keycodemax
= ARRAY_SIZE(dev
->keymap
);
770 input_dev
->evbit
[0] = BIT_MASK(EV_KEY
) | BIT_MASK(EV_SND
);
771 input_dev
->sndbit
[0] = BIT_MASK(SND_BELL
) | BIT_MASK(SND_TONE
);
773 /* register available key events */
774 for (i
= 0; i
< KEYMAP_SIZE
; i
++) {
775 unsigned short k
= keymap(i
);
777 __set_bit(k
, input_dev
->keybit
);
779 __clear_bit(KEY_RESERVED
, input_dev
->keybit
);
781 error
= input_register_device(dev
->idev
);
785 usb_set_intfdata(intf
, dev
);
790 input_free_device(input_dev
);
791 cm109_usb_cleanup(dev
);
795 static int cm109_usb_suspend(struct usb_interface
*intf
, pm_message_t message
)
797 struct cm109_dev
*dev
= usb_get_intfdata(intf
);
799 dev_info(&intf
->dev
, "cm109: usb_suspend (event=%d)\n", message
.event
);
801 mutex_lock(&dev
->pm_mutex
);
802 cm109_stop_traffic(dev
);
803 mutex_unlock(&dev
->pm_mutex
);
808 static int cm109_usb_resume(struct usb_interface
*intf
)
810 struct cm109_dev
*dev
= usb_get_intfdata(intf
);
812 dev_info(&intf
->dev
, "cm109: usb_resume\n");
814 mutex_lock(&dev
->pm_mutex
);
815 cm109_restore_state(dev
);
816 mutex_unlock(&dev
->pm_mutex
);
821 static int cm109_usb_pre_reset(struct usb_interface
*intf
)
823 struct cm109_dev
*dev
= usb_get_intfdata(intf
);
825 mutex_lock(&dev
->pm_mutex
);
828 * Make sure input events don't try to toggle buzzer
829 * while we are resetting
834 cm109_stop_traffic(dev
);
839 static int cm109_usb_post_reset(struct usb_interface
*intf
)
841 struct cm109_dev
*dev
= usb_get_intfdata(intf
);
846 cm109_restore_state(dev
);
848 mutex_unlock(&dev
->pm_mutex
);
853 static struct usb_driver cm109_driver
= {
855 .probe
= cm109_usb_probe
,
856 .disconnect
= cm109_usb_disconnect
,
857 .suspend
= cm109_usb_suspend
,
858 .resume
= cm109_usb_resume
,
859 .reset_resume
= cm109_usb_resume
,
860 .pre_reset
= cm109_usb_pre_reset
,
861 .post_reset
= cm109_usb_post_reset
,
862 .id_table
= cm109_usb_table
,
863 .supports_autosuspend
= 1,
866 static int __init
cm109_select_keymap(void)
868 /* Load the phone keymap */
869 if (!strcasecmp(phone
, "kip1000")) {
870 keymap
= keymap_kip1000
;
871 printk(KERN_INFO KBUILD_MODNAME
": "
872 "Keymap for Komunikate KIP1000 phone loaded\n");
873 } else if (!strcasecmp(phone
, "gtalk")) {
874 keymap
= keymap_gtalk
;
875 printk(KERN_INFO KBUILD_MODNAME
": "
876 "Keymap for Genius G-talk phone loaded\n");
877 } else if (!strcasecmp(phone
, "usbph01")) {
878 keymap
= keymap_usbph01
;
879 printk(KERN_INFO KBUILD_MODNAME
": "
880 "Keymap for Allied-Telesis Corega USBPH01 phone loaded\n");
881 } else if (!strcasecmp(phone
, "atcom")) {
882 keymap
= keymap_atcom
;
883 printk(KERN_INFO KBUILD_MODNAME
": "
884 "Keymap for ATCom AU-100 phone loaded\n");
886 printk(KERN_ERR KBUILD_MODNAME
": "
887 "Unsupported phone: %s\n", phone
);
894 static int __init
cm109_init(void)
898 err
= cm109_select_keymap();
902 err
= usb_register(&cm109_driver
);
906 printk(KERN_INFO KBUILD_MODNAME
": "
907 DRIVER_DESC
": " DRIVER_VERSION
" (C) " DRIVER_AUTHOR
"\n");
912 static void __exit
cm109_exit(void)
914 usb_deregister(&cm109_driver
);
917 module_init(cm109_init
);
918 module_exit(cm109_exit
);
920 MODULE_DEVICE_TABLE(usb
, cm109_usb_table
);
922 MODULE_AUTHOR(DRIVER_AUTHOR
);
923 MODULE_DESCRIPTION(DRIVER_DESC
);
924 MODULE_LICENSE("GPL");