source: src/linux/universal/linux-3.18/drivers/input/misc/cm109.c @ 31885

Last change on this file since 31885 was 31885, checked in by brainslayer, 2 months ago

update

File size: 23.8 KB
Line 
1/*
2 * Driver for the VoIP USB phones with CM109 chipsets.
3 *
4 * Copyright (C) 2007 - 2008 Alfred E. Heggestad <aeh@db.org>
5 *
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.
9 */
10
11/*
12 *   Tested devices:
13 *      - Komunikate KIP1000
14 *      - Genius G-talk
15 *      - Allied-Telesis Corega USBPH01
16 *      - ...
17 *
18 * This driver is based on the yealink.c driver
19 *
20 * Thanks to:
21 *   - Authors of yealink.c
22 *   - Thomas Reitmayr
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
26 *
27 * Todo:
28 *   - Read/write EEPROM
29 */
30
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>
38
39#define DRIVER_VERSION "20080805"
40#define DRIVER_AUTHOR  "Alfred E. Heggestad"
41#define DRIVER_DESC    "CM109 phone driver"
42
43static char *phone = "kip1000";
44module_param(phone, charp, S_IRUSR);
45MODULE_PARM_DESC(phone, "Phone name {kip1000, gtalk, usbph01, atcom}");
46
47enum {
48        /* HID Registers */
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          */
57
58        /* HID_IR0 */
59        RECORD_MUTE   = 1 << 3,
60        PLAYBACK_MUTE = 1 << 2,
61        VOLUME_DOWN   = 1 << 1,
62        VOLUME_UP     = 1 << 0,
63
64        /* HID_OR0 */
65        /* bits 7-6
66           0: HID_OR1-2 are used for GPO; HID_OR0, 3 are used for buzzer
67              and SPDIF
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)
71           3: Reserved
72         */
73        HID_OR_GPO_BUZ_SPDIF   = 0 << 6,
74        HID_OR_GENERIC_HID_REG = 1 << 6,
75        HID_OR_MAP_MCU_EEPROM  = 2 << 6,
76
77        BUZZER_ON = 1 << 5,
78
79        /* up to 256 normal keys, up to 16 special keys */
80        KEYMAP_SIZE = 256 + 16,
81};
82
83/* CM109 protocol packet */
84struct cm109_ctl_packet {
85        u8 byte[4];
86} __attribute__ ((packed));
87
88enum { USB_PKT_LEN = sizeof(struct cm109_ctl_packet) };
89
90/* CM109 device structure */
91struct cm109_dev {
92        struct input_dev *idev;  /* input device */
93        struct usb_device *udev; /* usb device */
94        struct usb_interface *intf;
95
96        /* irq input channel */
97        struct cm109_ctl_packet *irq_data;
98        dma_addr_t irq_dma;
99        struct urb *urb_irq;
100
101        /* control output channel */
102        struct cm109_ctl_packet *ctl_data;
103        dma_addr_t ctl_dma;
104        struct usb_ctrlrequest *ctl_req;
105        struct urb *urb_ctl;
106        /*
107         * The 3 bitfields below are protected by ctl_submit_lock.
108         * They have to be separate since they are accessed from IRQ
109         * context.
110         */
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;
115
116        unsigned char buzzer_state;     /* on/off */
117
118        /* flags */
119        unsigned open:1;
120        unsigned resetting:1;
121        unsigned shutdown:1;
122
123        /* This mutex protects writes to the above flags */
124        struct mutex pm_mutex;
125
126        unsigned short keymap[KEYMAP_SIZE];
127
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) */
132};
133
134/******************************************************************************
135 * CM109 key interface
136 *****************************************************************************/
137
138static unsigned short special_keymap(int code)
139{
140        if (code > 0xff) {
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;
146                }
147        }
148        return KEY_RESERVED;
149}
150
151/* Map device buttons to internal key events.
152 *
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
155 * on the button.
156
157 Komunikate KIP1000 Keyboard Matrix
158
159     -> -- 1 -- 2 -- 3  --> GPI pin 4 (0x10)
160      |    |    |    |
161     <- -- 4 -- 5 -- 6  --> GPI pin 5 (0x20)
162      |    |    |    |
163     END - 7 -- 8 -- 9  --> GPI pin 6 (0x40)
164      |    |    |    |
165     OK -- * -- 0 -- #  --> GPI pin 7 (0x80)
166      |    |    |    |
167
168     /|\  /|\  /|\  /|\
169      |    |    |    |
170GPO
171pin:  3    2    1    0
172     0x8  0x4  0x2  0x1
173
174 */
175static unsigned short keymap_kip1000(int scancode)
176{
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);
195        }
196}
197
198/*
199  Contributed by Shaun Jackman <sjackman@gmail.com>
200
201  Genius G-Talk keyboard matrix
202     0 1 2 3
203  4: 0 4 8 Talk
204  5: 1 5 9 End
205  6: 2 6 # Up
206  7: 3 7 * Down
207*/
208static unsigned short keymap_gtalk(int scancode)
209{
210        switch (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);
228        }
229}
230
231/*
232 * Keymap for Allied-Telesis Corega USBPH01
233 * http://www.alliedtelesis-corega.com/2/1344/1437/1360/chprd.html
234 *
235 * Contributed by july@nat.bg
236 */
237static unsigned short keymap_usbph01(int scancode)
238{
239        switch (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);
257        }
258}
259
260/*
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
265 *
266 * Contributed by daniel@gimpelevich.san-francisco.ca.us
267 */
268static unsigned short keymap_atcom(int scancode)
269{
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);
288        }
289}
290
291static unsigned short (*keymap)(int) = keymap_kip1000;
292
293/*
294 * Completes a request by converting the data into events for the
295 * input subsystem.
296 */
297static void report_key(struct cm109_dev *dev, int key)
298{
299        struct input_dev *idev = dev->idev;
300
301        if (dev->key_code >= 0) {
302                /* old key up */
303                input_report_key(idev, dev->key_code, 0);
304        }
305
306        dev->key_code = key;
307        if (key >= 0) {
308                /* new valid key */
309                input_report_key(idev, key, 1);
310        }
311
312        input_sync(idev);
313}
314
315/******************************************************************************
316 * CM109 usb communication interface
317 *****************************************************************************/
318
319static void cm109_submit_buzz_toggle(struct cm109_dev *dev)
320{
321        int error;
322
323        if (dev->buzzer_state)
324                dev->ctl_data->byte[HID_OR0] |= BUZZER_ON;
325        else
326                dev->ctl_data->byte[HID_OR0] &= ~BUZZER_ON;
327
328        error = usb_submit_urb(dev->urb_ctl, GFP_ATOMIC);
329        if (error)
330                dev_err(&dev->intf->dev,
331                        "%s: usb_submit_urb (urb_ctl) failed %d\n",
332                        __func__, error);
333}
334
335/*
336 * IRQ handler
337 */
338static void cm109_urb_irq_callback(struct urb *urb)
339{
340        struct cm109_dev *dev = urb->context;
341        const int status = urb->status;
342        int error;
343
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],
349             dev->keybit);
350
351        if (status) {
352                if (status == -ESHUTDOWN)
353                        return;
354                dev_err_ratelimited(&dev->intf->dev, "%s: urb status %d\n",
355                                    __func__, status);
356                goto out;
357        }
358
359        /* Special keys */
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]);
363        }
364
365        /* Scan key column */
366        if (dev->keybit == 0xf) {
367
368                /* Any changes ? */
369                if ((dev->gpi & 0xf0) == (dev->irq_data->byte[HID_IR1] & 0xf0))
370                        goto out;
371
372                dev->gpi = dev->irq_data->byte[HID_IR1] & 0xf0;
373                dev->keybit = 0x1;
374        } else {
375                report_key(dev, dev->keymap[dev->irq_data->byte[HID_IR1]]);
376
377                dev->keybit <<= 1;
378                if (dev->keybit > 0x8)
379                        dev->keybit = 0xf;
380        }
381
382 out:
383
384        spin_lock(&dev->ctl_submit_lock);
385
386        dev->irq_urb_pending = 0;
387
388        if (likely(!dev->shutdown)) {
389
390                if (dev->buzzer_state)
391                        dev->ctl_data->byte[HID_OR0] |= BUZZER_ON;
392                else
393                        dev->ctl_data->byte[HID_OR0] &= ~BUZZER_ON;
394
395                dev->ctl_data->byte[HID_OR1] = dev->keybit;
396                dev->ctl_data->byte[HID_OR2] = dev->keybit;
397
398                dev->buzzer_pending = 0;
399                dev->ctl_urb_pending = 1;
400
401                error = usb_submit_urb(dev->urb_ctl, GFP_ATOMIC);
402                if (error)
403                        dev_err(&dev->intf->dev,
404                                "%s: usb_submit_urb (urb_ctl) failed %d\n",
405                                __func__, error);
406        }
407
408        spin_unlock(&dev->ctl_submit_lock);
409}
410
411static void cm109_urb_ctl_callback(struct urb *urb)
412{
413        struct cm109_dev *dev = urb->context;
414        const int status = urb->status;
415        int error;
416
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]);
422
423        if (status) {
424                if (status == -ESHUTDOWN)
425                        return;
426                dev_err_ratelimited(&dev->intf->dev, "%s: urb status %d\n",
427                                    __func__, status);
428        }
429
430        spin_lock(&dev->ctl_submit_lock);
431
432        dev->ctl_urb_pending = 0;
433
434        if (likely(!dev->shutdown)) {
435
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);
444                        if (error)
445                                dev_err(&dev->intf->dev,
446                                        "%s: usb_submit_urb (urb_irq) failed %d\n",
447                                        __func__, error);
448                }
449        }
450
451        spin_unlock(&dev->ctl_submit_lock);
452}
453
454static void cm109_toggle_buzzer_async(struct cm109_dev *dev)
455{
456        unsigned long flags;
457
458        spin_lock_irqsave(&dev->ctl_submit_lock, flags);
459
460        if (dev->ctl_urb_pending) {
461                /* URB completion will resubmit */
462                dev->buzzer_pending = 1;
463        } else {
464                dev->ctl_urb_pending = 1;
465                cm109_submit_buzz_toggle(dev);
466        }
467
468        spin_unlock_irqrestore(&dev->ctl_submit_lock, flags);
469}
470
471static void cm109_toggle_buzzer_sync(struct cm109_dev *dev, int on)
472{
473        int error;
474
475        if (on)
476                dev->ctl_data->byte[HID_OR0] |= BUZZER_ON;
477        else
478                dev->ctl_data->byte[HID_OR0] &= ~BUZZER_ON;
479
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),
486                                dev->ctl_data,
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",
490                        __func__, error);
491}
492
493static void cm109_stop_traffic(struct cm109_dev *dev)
494{
495        dev->shutdown = 1;
496        /*
497         * Make sure other CPUs see this
498         */
499        smp_wmb();
500
501        usb_kill_urb(dev->urb_ctl);
502        usb_kill_urb(dev->urb_irq);
503
504        cm109_toggle_buzzer_sync(dev, 0);
505
506        dev->shutdown = 0;
507        smp_wmb();
508}
509
510static void cm109_restore_state(struct cm109_dev *dev)
511{
512        if (dev->open) {
513                /*
514                 * Restore buzzer state.
515                 * This will also kick regular URB submission
516                 */
517                cm109_toggle_buzzer_async(dev);
518        }
519}
520
521/******************************************************************************
522 * input event interface
523 *****************************************************************************/
524
525static int cm109_input_open(struct input_dev *idev)
526{
527        struct cm109_dev *dev = input_get_drvdata(idev);
528        int error;
529
530        error = usb_autopm_get_interface(dev->intf);
531        if (error < 0) {
532                dev_err(&idev->dev, "%s - cannot autoresume, result %d\n",
533                        __func__, error);
534                return error;
535        }
536
537        mutex_lock(&dev->pm_mutex);
538
539        dev->buzzer_state = 0;
540        dev->key_code = -1;     /* no keys pressed */
541        dev->keybit = 0xf;
542
543        /* issue INIT */
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;
548
549        error = usb_submit_urb(dev->urb_ctl, GFP_KERNEL);
550        if (error)
551                dev_err(&dev->intf->dev, "%s: usb_submit_urb (urb_ctl) failed %d\n",
552                        __func__, error);
553        else
554                dev->open = 1;
555
556        mutex_unlock(&dev->pm_mutex);
557
558        if (error)
559                usb_autopm_put_interface(dev->intf);
560
561        return error;
562}
563
564static void cm109_input_close(struct input_dev *idev)
565{
566        struct cm109_dev *dev = input_get_drvdata(idev);
567
568        mutex_lock(&dev->pm_mutex);
569
570        /*
571         * Once we are here event delivery is stopped so we
572         * don't need to worry about someone starting buzzer
573         * again
574         */
575        cm109_stop_traffic(dev);
576        dev->open = 0;
577
578        mutex_unlock(&dev->pm_mutex);
579
580        usb_autopm_put_interface(dev->intf);
581}
582
583static int cm109_input_ev(struct input_dev *idev, unsigned int type,
584                          unsigned int code, int value)
585{
586        struct cm109_dev *dev = input_get_drvdata(idev);
587
588        dev_dbg(&dev->intf->dev,
589                "input_ev: type=%u code=%u value=%d\n", type, code, value);
590
591        if (type != EV_SND)
592                return -EINVAL;
593
594        switch (code) {
595        case SND_TONE:
596        case SND_BELL:
597                dev->buzzer_state = !!value;
598                if (!dev->resetting)
599                        cm109_toggle_buzzer_async(dev);
600                return 0;
601
602        default:
603                return -EINVAL;
604        }
605}
606
607
608/******************************************************************************
609 * Linux interface and usb initialisation
610 *****************************************************************************/
611
612struct driver_info {
613        char *name;
614};
615
616static const struct driver_info info_cm109 = {
617        .name = "CM109 USB driver",
618};
619
620enum {
621        VENDOR_ID        = 0x0d8c, /* C-Media Electronics */
622        PRODUCT_ID_CM109 = 0x000e, /* CM109 defines range 0x0008 - 0x000f */
623};
624
625/* table of devices that work with this driver */
626static const struct usb_device_id cm109_usb_table[] = {
627        {
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
636        },
637        /* you can add more devices here with product ID 0x0008 - 0x000f */
638        { }
639};
640
641static void cm109_usb_cleanup(struct cm109_dev *dev)
642{
643        kfree(dev->ctl_req);
644        if (dev->ctl_data)
645                usb_free_coherent(dev->udev, USB_PKT_LEN,
646                                  dev->ctl_data, dev->ctl_dma);
647        if (dev->irq_data)
648                usb_free_coherent(dev->udev, USB_PKT_LEN,
649                                  dev->irq_data, dev->irq_dma);
650
651        usb_free_urb(dev->urb_irq);     /* parameter validation in core/urb */
652        usb_free_urb(dev->urb_ctl);     /* parameter validation in core/urb */
653        kfree(dev);
654}
655
656static void cm109_usb_disconnect(struct usb_interface *interface)
657{
658        struct cm109_dev *dev = usb_get_intfdata(interface);
659
660        usb_set_intfdata(interface, NULL);
661        input_unregister_device(dev->idev);
662        cm109_usb_cleanup(dev);
663}
664
665static int cm109_usb_probe(struct usb_interface *intf,
666                           const struct usb_device_id *id)
667{
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;
674        int ret, pipe, i;
675        int error = -ENOMEM;
676
677        interface = intf->cur_altsetting;
678
679        if (interface->desc.bNumEndpoints < 1)
680                return -ENODEV;
681
682        endpoint = &interface->endpoint[0].desc;
683
684        if (!usb_endpoint_is_int_in(endpoint))
685                return -ENODEV;
686
687        dev = kzalloc(sizeof(*dev), GFP_KERNEL);
688        if (!dev)
689                return -ENOMEM;
690
691        spin_lock_init(&dev->ctl_submit_lock);
692        mutex_init(&dev->pm_mutex);
693
694        dev->udev = udev;
695        dev->intf = intf;
696
697        dev->idev = input_dev = input_allocate_device();
698        if (!input_dev)
699                goto err_out;
700
701        /* allocate usb buffers */
702        dev->irq_data = usb_alloc_coherent(udev, USB_PKT_LEN,
703                                           GFP_KERNEL, &dev->irq_dma);
704        if (!dev->irq_data)
705                goto err_out;
706
707        dev->ctl_data = usb_alloc_coherent(udev, USB_PKT_LEN,
708                                           GFP_KERNEL, &dev->ctl_dma);
709        if (!dev->ctl_data)
710                goto err_out;
711
712        dev->ctl_req = kmalloc(sizeof(*(dev->ctl_req)), GFP_KERNEL);
713        if (!dev->ctl_req)
714                goto err_out;
715
716        /* allocate urb structures */
717        dev->urb_irq = usb_alloc_urb(0, GFP_KERNEL);
718        if (!dev->urb_irq)
719                goto err_out;
720
721        dev->urb_ctl = usb_alloc_urb(0, GFP_KERNEL);
722        if (!dev->urb_ctl)
723                goto err_out;
724
725        /* get a handle to the interrupt data pipe */
726        pipe = usb_rcvintpipe(udev, endpoint->bEndpointAddress);
727        ret = usb_maxpacket(udev, pipe, usb_pipeout(pipe));
728        if (ret != USB_PKT_LEN)
729                dev_err(&intf->dev, "invalid payload size %d, expected %d\n",
730                        ret, USB_PKT_LEN);
731
732        /* initialise irq urb */
733        usb_fill_int_urb(dev->urb_irq, udev, pipe, dev->irq_data,
734                         USB_PKT_LEN,
735                         cm109_urb_irq_callback, dev, endpoint->bInterval);
736        dev->urb_irq->transfer_dma = dev->irq_dma;
737        dev->urb_irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
738        dev->urb_irq->dev = udev;
739
740        /* initialise ctl urb */
741        dev->ctl_req->bRequestType = USB_TYPE_CLASS | USB_RECIP_INTERFACE |
742                                        USB_DIR_OUT;
743        dev->ctl_req->bRequest = USB_REQ_SET_CONFIGURATION;
744        dev->ctl_req->wValue = cpu_to_le16(0x200);
745        dev->ctl_req->wIndex = cpu_to_le16(interface->desc.bInterfaceNumber);
746        dev->ctl_req->wLength = cpu_to_le16(USB_PKT_LEN);
747
748        usb_fill_control_urb(dev->urb_ctl, udev, usb_sndctrlpipe(udev, 0),
749                             (void *)dev->ctl_req, dev->ctl_data, USB_PKT_LEN,
750                             cm109_urb_ctl_callback, dev);
751        dev->urb_ctl->transfer_dma = dev->ctl_dma;
752        dev->urb_ctl->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
753        dev->urb_ctl->dev = udev;
754
755        /* find out the physical bus location */
756        usb_make_path(udev, dev->phys, sizeof(dev->phys));
757        strlcat(dev->phys, "/input0", sizeof(dev->phys));
758
759        /* register settings for the input device */
760        input_dev->name = nfo->name;
761        input_dev->phys = dev->phys;
762        usb_to_input_id(udev, &input_dev->id);
763        input_dev->dev.parent = &intf->dev;
764
765        input_set_drvdata(input_dev, dev);
766        input_dev->open = cm109_input_open;
767        input_dev->close = cm109_input_close;
768        input_dev->event = cm109_input_ev;
769
770        input_dev->keycode = dev->keymap;
771        input_dev->keycodesize = sizeof(unsigned char);
772        input_dev->keycodemax = ARRAY_SIZE(dev->keymap);
773
774        input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_SND);
775        input_dev->sndbit[0] = BIT_MASK(SND_BELL) | BIT_MASK(SND_TONE);
776
777        /* register available key events */
778        for (i = 0; i < KEYMAP_SIZE; i++) {
779                unsigned short k = keymap(i);
780                dev->keymap[i] = k;
781                __set_bit(k, input_dev->keybit);
782        }
783        __clear_bit(KEY_RESERVED, input_dev->keybit);
784
785        error = input_register_device(dev->idev);
786        if (error)
787                goto err_out;
788
789        usb_set_intfdata(intf, dev);
790
791        return 0;
792
793 err_out:
794        input_free_device(input_dev);
795        cm109_usb_cleanup(dev);
796        return error;
797}
798
799static int cm109_usb_suspend(struct usb_interface *intf, pm_message_t message)
800{
801        struct cm109_dev *dev = usb_get_intfdata(intf);
802
803        dev_info(&intf->dev, "cm109: usb_suspend (event=%d)\n", message.event);
804
805        mutex_lock(&dev->pm_mutex);
806        cm109_stop_traffic(dev);
807        mutex_unlock(&dev->pm_mutex);
808
809        return 0;
810}
811
812static int cm109_usb_resume(struct usb_interface *intf)
813{
814        struct cm109_dev *dev = usb_get_intfdata(intf);
815
816        dev_info(&intf->dev, "cm109: usb_resume\n");
817
818        mutex_lock(&dev->pm_mutex);
819        cm109_restore_state(dev);
820        mutex_unlock(&dev->pm_mutex);
821
822        return 0;
823}
824
825static int cm109_usb_pre_reset(struct usb_interface *intf)
826{
827        struct cm109_dev *dev = usb_get_intfdata(intf);
828
829        mutex_lock(&dev->pm_mutex);
830
831        /*
832         * Make sure input events don't try to toggle buzzer
833         * while we are resetting
834         */
835        dev->resetting = 1;
836        smp_wmb();
837
838        cm109_stop_traffic(dev);
839
840        return 0;
841}
842
843static int cm109_usb_post_reset(struct usb_interface *intf)
844{
845        struct cm109_dev *dev = usb_get_intfdata(intf);
846
847        dev->resetting = 0;
848        smp_wmb();
849
850        cm109_restore_state(dev);
851
852        mutex_unlock(&dev->pm_mutex);
853
854        return 0;
855}
856
857static struct usb_driver cm109_driver = {
858        .name           = "cm109",
859        .probe          = cm109_usb_probe,
860        .disconnect     = cm109_usb_disconnect,
861        .suspend        = cm109_usb_suspend,
862        .resume         = cm109_usb_resume,
863        .reset_resume   = cm109_usb_resume,
864        .pre_reset      = cm109_usb_pre_reset,
865        .post_reset     = cm109_usb_post_reset,
866        .id_table       = cm109_usb_table,
867        .supports_autosuspend = 1,
868};
869
870static int __init cm109_select_keymap(void)
871{
872        /* Load the phone keymap */
873        if (!strcasecmp(phone, "kip1000")) {
874                keymap = keymap_kip1000;
875                printk(KERN_INFO KBUILD_MODNAME ": "
876                        "Keymap for Komunikate KIP1000 phone loaded\n");
877        } else if (!strcasecmp(phone, "gtalk")) {
878                keymap = keymap_gtalk;
879                printk(KERN_INFO KBUILD_MODNAME ": "
880                        "Keymap for Genius G-talk phone loaded\n");
881        } else if (!strcasecmp(phone, "usbph01")) {
882                keymap = keymap_usbph01;
883                printk(KERN_INFO KBUILD_MODNAME ": "
884                        "Keymap for Allied-Telesis Corega USBPH01 phone loaded\n");
885        } else if (!strcasecmp(phone, "atcom")) {
886                keymap = keymap_atcom;
887                printk(KERN_INFO KBUILD_MODNAME ": "
888                        "Keymap for ATCom AU-100 phone loaded\n");
889        } else {
890                printk(KERN_ERR KBUILD_MODNAME ": "
891                        "Unsupported phone: %s\n", phone);
892                return -EINVAL;
893        }
894
895        return 0;
896}
897
898static int __init cm109_init(void)
899{
900        int err;
901
902        err = cm109_select_keymap();
903        if (err)
904                return err;
905
906        err = usb_register(&cm109_driver);
907        if (err)
908                return err;
909
910        printk(KERN_INFO KBUILD_MODNAME ": "
911                DRIVER_DESC ": " DRIVER_VERSION " (C) " DRIVER_AUTHOR "\n");
912
913        return 0;
914}
915
916static void __exit cm109_exit(void)
917{
918        usb_deregister(&cm109_driver);
919}
920
921module_init(cm109_init);
922module_exit(cm109_exit);
923
924MODULE_DEVICE_TABLE(usb, cm109_usb_table);
925
926MODULE_AUTHOR(DRIVER_AUTHOR);
927MODULE_DESCRIPTION(DRIVER_DESC);
928MODULE_LICENSE("GPL");
Note: See TracBrowser for help on using the repository browser.