Merge branch 'release' of git://git.kernel.org/pub/scm/linux/kernel/git/lenb/linux...
[linux-2.6] / drivers / usb / input / yealink.c
1 /*
2  * drivers/usb/input/yealink.c
3  *
4  * Copyright (c) 2005 Henk Vergonet <Henk.Vergonet@gmail.com>
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; either version 2 of
9  * the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19  */
20 /*
21  * Description:
22  *   Driver for the USB-P1K voip usb phone.
23  *   This device is produced by Yealink Network Technology Co Ltd
24  *   but may be branded under several names:
25  *      - Yealink usb-p1k
26  *      - Tiptel 115
27  *      - ...
28  *
29  * This driver is based on:
30  *   - the usbb2k-api   http://savannah.nongnu.org/projects/usbb2k-api/
31  *   - information from http://memeteau.free.fr/usbb2k
32  *   - the xpad-driver  drivers/usb/input/xpad.c
33  *
34  * Thanks to:
35  *   - Olivier Vandorpe, for providing the usbb2k-api.
36  *   - Martin Diehl, for spotting my memory allocation bug.
37  *
38  * History:
39  *   20050527 henk      First version, functional keyboard. Keyboard events
40  *                      will pop-up on the ../input/eventX bus.
41  *   20050531 henk      Added led, LCD, dialtone and sysfs interface.
42  *   20050610 henk      Cleanups, make it ready for public consumption.
43  *   20050630 henk      Cleanups, fixes in response to comments.
44  *   20050701 henk      sysfs write serialisation, fix potential unload races
45  *   20050801 henk      Added ringtone, restructure USB
46  *   20050816 henk      Merge 2.6.13-rc6
47  */
48
49 #include <linux/config.h>
50 #include <linux/kernel.h>
51 #include <linux/input.h>
52 #include <linux/init.h>
53 #include <linux/slab.h>
54 #include <linux/module.h>
55 #include <linux/rwsem.h>
56 #include <linux/usb.h>
57 #include <linux/usb_input.h>
58
59 #include "map_to_7segment.h"
60 #include "yealink.h"
61
62 #define DRIVER_VERSION "yld-20051230"
63 #define DRIVER_AUTHOR "Henk Vergonet"
64 #define DRIVER_DESC "Yealink phone driver"
65
66 #define YEALINK_POLLING_FREQUENCY       10      /* in [Hz] */
67
68 struct yld_status {
69         u8      lcd[24];
70         u8      led;
71         u8      dialtone;
72         u8      ringtone;
73         u8      keynum;
74 } __attribute__ ((packed));
75
76 /*
77  * Register the LCD segment and icon map
78  */
79 #define _LOC(k,l)       { .a = (k), .m = (l) }
80 #define _SEG(t, a, am, b, bm, c, cm, d, dm, e, em, f, fm, g, gm)        \
81         { .type = (t),                                                  \
82           .u = { .s = { _LOC(a, am), _LOC(b, bm), _LOC(c, cm),          \
83                         _LOC(d, dm), _LOC(e, em), _LOC(g, gm),          \
84                         _LOC(f, fm) } } }
85 #define _PIC(t, h, hm, n)                                               \
86         { .type = (t),                                                  \
87           .u = { .p = { .name = (n), .a = (h), .m = (hm) } } }
88
89 static const struct lcd_segment_map {
90         char    type;
91         union {
92                 struct pictogram_map {
93                         u8      a,m;
94                         char    name[10];
95                 }       p;
96                 struct segment_map {
97                         u8      a,m;
98                 } s[7];
99         } u;
100 } lcdMap[] = {
101 #include "yealink.h"
102 };
103
104 struct yealink_dev {
105         struct input_dev *idev;         /* input device */
106         struct usb_device *udev;        /* usb device */
107
108         /* irq input channel */
109         struct yld_ctl_packet   *irq_data;
110         dma_addr_t              irq_dma;
111         struct urb              *urb_irq;
112
113         /* control output channel */
114         struct yld_ctl_packet   *ctl_data;
115         dma_addr_t              ctl_dma;
116         struct usb_ctrlrequest  *ctl_req;
117         dma_addr_t              ctl_req_dma;
118         struct urb              *urb_ctl;
119
120         char phys[64];                  /* physical device path */
121
122         u8 lcdMap[ARRAY_SIZE(lcdMap)];  /* state of LCD, LED ... */
123         int key_code;                   /* last reported key     */
124
125         int     stat_ix;
126         union {
127                 struct yld_status s;
128                 u8                b[sizeof(struct yld_status)];
129         } master, copy;
130 };
131
132
133 /*******************************************************************************
134  * Yealink lcd interface
135  ******************************************************************************/
136
137 /*
138  * Register a default 7 segment character set
139  */
140 static SEG7_DEFAULT_MAP(map_seg7);
141
142  /* Display a char,
143   * char '\9' and '\n' are placeholders and do not overwrite the original text.
144   * A space will always hide an icon.
145   */
146 static int setChar(struct yealink_dev *yld, int el, int chr)
147 {
148         int i, a, m, val;
149
150         if (el >= ARRAY_SIZE(lcdMap))
151                 return -EINVAL;
152
153         if (chr == '\t' || chr == '\n')
154             return 0;
155
156         yld->lcdMap[el] = chr;
157
158         if (lcdMap[el].type == '.') {
159                 a = lcdMap[el].u.p.a;
160                 m = lcdMap[el].u.p.m;
161                 if (chr != ' ')
162                         yld->master.b[a] |= m;
163                 else
164                         yld->master.b[a] &= ~m;
165                 return 0;
166         }
167
168         val = map_to_seg7(&map_seg7, chr);
169         for (i = 0; i < ARRAY_SIZE(lcdMap[0].u.s); i++) {
170                 m = lcdMap[el].u.s[i].m;
171
172                 if (m == 0)
173                         continue;
174
175                 a = lcdMap[el].u.s[i].a;
176                 if (val & 1)
177                         yld->master.b[a] |= m;
178                 else
179                         yld->master.b[a] &= ~m;
180                 val = val >> 1;
181         }
182         return 0;
183 };
184
185 /*******************************************************************************
186  * Yealink key interface
187  ******************************************************************************/
188
189 /* Map device buttons to internal key events.
190  *
191  * USB-P1K button layout:
192  *
193  *             up
194  *       IN           OUT
195  *            down
196  *
197  *     pickup   C    hangup
198  *       1      2      3
199  *       4      5      6
200  *       7      8      9
201  *       *      0      #
202  *
203  * The "up" and "down" keys, are symbolised by arrows on the button.
204  * The "pickup" and "hangup" keys are symbolised by a green and red phone
205  * on the button.
206  */
207 static int map_p1k_to_key(int scancode)
208 {
209         switch(scancode) {              /* phone key:   */
210         case 0x23: return KEY_LEFT;     /*   IN         */
211         case 0x33: return KEY_UP;       /*   up         */
212         case 0x04: return KEY_RIGHT;    /*   OUT        */
213         case 0x24: return KEY_DOWN;     /*   down       */
214         case 0x03: return KEY_ENTER;    /*   pickup     */
215         case 0x14: return KEY_BACKSPACE; /*  C          */
216         case 0x13: return KEY_ESC;      /*   hangup     */
217         case 0x00: return KEY_1;        /*   1          */
218         case 0x01: return KEY_2;        /*   2          */
219         case 0x02: return KEY_3;        /*   3          */
220         case 0x10: return KEY_4;        /*   4          */
221         case 0x11: return KEY_5;        /*   5          */
222         case 0x12: return KEY_6;        /*   6          */
223         case 0x20: return KEY_7;        /*   7          */
224         case 0x21: return KEY_8;        /*   8          */
225         case 0x22: return KEY_9;        /*   9          */
226         case 0x30: return KEY_KPASTERISK; /* *          */
227         case 0x31: return KEY_0;        /*   0          */
228         case 0x32: return KEY_LEFTSHIFT |
229                           KEY_3 << 8;   /*   #          */
230         }
231         return -EINVAL;
232 }
233
234 /* Completes a request by converting the data into events for the
235  * input subsystem.
236  *
237  * The key parameter can be cascaded: key2 << 8 | key1
238  */
239 static void report_key(struct yealink_dev *yld, int key, struct pt_regs *regs)
240 {
241         struct input_dev *idev = yld->idev;
242
243         input_regs(idev, regs);
244         if (yld->key_code >= 0) {
245                 /* old key up */
246                 input_report_key(idev, yld->key_code & 0xff, 0);
247                 if (yld->key_code >> 8)
248                         input_report_key(idev, yld->key_code >> 8, 0);
249         }
250
251         yld->key_code = key;
252         if (key >= 0) {
253                 /* new valid key */
254                 input_report_key(idev, key & 0xff, 1);
255                 if (key >> 8)
256                         input_report_key(idev, key >> 8, 1);
257         }
258         input_sync(idev);
259 }
260
261 /*******************************************************************************
262  * Yealink usb communication interface
263  ******************************************************************************/
264
265 static int yealink_cmd(struct yealink_dev *yld, struct yld_ctl_packet *p)
266 {
267         u8      *buf = (u8 *)p;
268         int     i;
269         u8      sum = 0;
270
271         for(i=0; i<USB_PKT_LEN-1; i++)
272                 sum -= buf[i];
273         p->sum = sum;
274         return usb_control_msg(yld->udev,
275                         usb_sndctrlpipe(yld->udev, 0),
276                         USB_REQ_SET_CONFIGURATION,
277                         USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT,
278                         0x200, 3,
279                         p, sizeof(*p),
280                         USB_CTRL_SET_TIMEOUT);
281 }
282
283 static u8 default_ringtone[] = {
284         0xEF,                   /* volume [0-255] */
285         0xFB, 0x1E, 0x00, 0x0C, /* 1250 [hz], 12/100 [s] */
286         0xFC, 0x18, 0x00, 0x0C, /* 1000 [hz], 12/100 [s] */
287         0xFB, 0x1E, 0x00, 0x0C,
288         0xFC, 0x18, 0x00, 0x0C,
289         0xFB, 0x1E, 0x00, 0x0C,
290         0xFC, 0x18, 0x00, 0x0C,
291         0xFB, 0x1E, 0x00, 0x0C,
292         0xFC, 0x18, 0x00, 0x0C,
293         0xFF, 0xFF, 0x01, 0x90, /* silent, 400/100 [s] */
294         0x00, 0x00              /* end of sequence */
295 };
296
297 static int yealink_set_ringtone(struct yealink_dev *yld, u8 *buf, size_t size)
298 {
299         struct yld_ctl_packet *p = yld->ctl_data;
300         int     ix, len;
301
302         if (size <= 0)
303                 return -EINVAL;
304
305         /* Set the ringtone volume */
306         memset(yld->ctl_data, 0, sizeof(*(yld->ctl_data)));
307         yld->ctl_data->cmd      = CMD_RING_VOLUME;
308         yld->ctl_data->size     = 1;
309         yld->ctl_data->data[0]  = buf[0];
310         yealink_cmd(yld, p);
311
312         buf++;
313         size--;
314
315         p->cmd = CMD_RING_NOTE;
316         ix = 0;
317         while (size != ix) {
318                 len = size - ix;
319                 if (len > sizeof(p->data))
320                         len = sizeof(p->data);
321                 p->size   = len;
322                 p->offset = cpu_to_be16(ix);
323                 memcpy(p->data, &buf[ix], len);
324                 yealink_cmd(yld, p);
325                 ix += len;
326         }
327         return 0;
328 }
329
330 /* keep stat_master & stat_copy in sync.
331  */
332 static int yealink_do_idle_tasks(struct yealink_dev *yld)
333 {
334         u8 val;
335         int i, ix, len;
336
337         ix = yld->stat_ix;
338
339         memset(yld->ctl_data, 0, sizeof(*(yld->ctl_data)));
340         yld->ctl_data->cmd  = CMD_KEYPRESS;
341         yld->ctl_data->size = 1;
342         yld->ctl_data->sum  = 0xff - CMD_KEYPRESS;
343
344         /* If state update pointer wraps do a KEYPRESS first. */
345         if (ix >= sizeof(yld->master)) {
346                 yld->stat_ix = 0;
347                 return 0;
348         }
349
350         /* find update candidates: copy != master */
351         do {
352                 val = yld->master.b[ix];
353                 if (val != yld->copy.b[ix])
354                         goto send_update;
355         } while (++ix < sizeof(yld->master));
356
357         /* nothing todo, wait a bit and poll for a KEYPRESS */
358         yld->stat_ix = 0;
359         /* TODO how can we wait abit. ??
360          * msleep_interruptible(1000 / YEALINK_POLLING_FREQUENCY);
361          */
362         return 0;
363
364 send_update:
365
366         /* Setup an appropriate update request */
367         yld->copy.b[ix] = val;
368         yld->ctl_data->data[0] = val;
369
370         switch(ix) {
371         case offsetof(struct yld_status, led):
372                 yld->ctl_data->cmd      = CMD_LED;
373                 yld->ctl_data->sum      = -1 - CMD_LED - val;
374                 break;
375         case offsetof(struct yld_status, dialtone):
376                 yld->ctl_data->cmd      = CMD_DIALTONE;
377                 yld->ctl_data->sum      = -1 - CMD_DIALTONE - val;
378                 break;
379         case offsetof(struct yld_status, ringtone):
380                 yld->ctl_data->cmd      = CMD_RINGTONE;
381                 yld->ctl_data->sum      = -1 - CMD_RINGTONE - val;
382                 break;
383         case offsetof(struct yld_status, keynum):
384                 val--;
385                 val &= 0x1f;
386                 yld->ctl_data->cmd      = CMD_SCANCODE;
387                 yld->ctl_data->offset   = cpu_to_be16(val);
388                 yld->ctl_data->data[0]  = 0;
389                 yld->ctl_data->sum      = -1 - CMD_SCANCODE - val;
390                 break;
391         default:
392                 len = sizeof(yld->master.s.lcd) - ix;
393                 if (len > sizeof(yld->ctl_data->data))
394                         len = sizeof(yld->ctl_data->data);
395
396                 /* Combine up to <len> consecutive LCD bytes in a singe request
397                  */
398                 yld->ctl_data->cmd      = CMD_LCD;
399                 yld->ctl_data->offset   = cpu_to_be16(ix);
400                 yld->ctl_data->size     = len;
401                 yld->ctl_data->sum      = -CMD_LCD - ix - val - len;
402                 for(i=1; i<len; i++) {
403                         ix++;
404                         val = yld->master.b[ix];
405                         yld->copy.b[ix]         = val;
406                         yld->ctl_data->data[i]  = val;
407                         yld->ctl_data->sum     -= val;
408                 }
409         }
410         yld->stat_ix = ix + 1;
411         return 1;
412 }
413
414 /* Decide on how to handle responses
415  *
416  * The state transition diagram is somethhing like:
417  *
418  *          syncState<--+
419  *               |      |
420  *               |    idle
421  *              \|/     |
422  * init --ok--> waitForKey --ok--> getKey
423  *  ^               ^                |
424  *  |               +-------ok-------+
425  * error,start
426  *
427  */
428 static void urb_irq_callback(struct urb *urb, struct pt_regs *regs)
429 {
430         struct yealink_dev *yld = urb->context;
431         int ret;
432
433         if (urb->status)
434                 err("%s - urb status %d", __FUNCTION__, urb->status);
435
436         switch (yld->irq_data->cmd) {
437         case CMD_KEYPRESS:
438
439                 yld->master.s.keynum = yld->irq_data->data[0];
440                 break;
441
442         case CMD_SCANCODE:
443                 dbg("get scancode %x", yld->irq_data->data[0]);
444
445                 report_key(yld, map_p1k_to_key(yld->irq_data->data[0]), regs);
446                 break;
447
448         default:
449                 err("unexpected response %x", yld->irq_data->cmd);
450         }
451
452         yealink_do_idle_tasks(yld);
453
454         ret = usb_submit_urb(yld->urb_ctl, GFP_ATOMIC);
455         if (ret)
456                 err("%s - usb_submit_urb failed %d", __FUNCTION__, ret);
457 }
458
459 static void urb_ctl_callback(struct urb *urb, struct pt_regs *regs)
460 {
461         struct yealink_dev *yld = urb->context;
462         int ret;
463
464         if (urb->status)
465                 err("%s - urb status %d", __FUNCTION__, urb->status);
466
467         switch (yld->ctl_data->cmd) {
468         case CMD_KEYPRESS:
469         case CMD_SCANCODE:
470                 /* ask for a response */
471                 ret = usb_submit_urb(yld->urb_irq, GFP_ATOMIC);
472                 break;
473         default:
474                 /* send new command */
475                 yealink_do_idle_tasks(yld);
476                 ret = usb_submit_urb(yld->urb_ctl, GFP_ATOMIC);
477         }
478
479         if (ret)
480                 err("%s - usb_submit_urb failed %d", __FUNCTION__, ret);
481 }
482
483 /*******************************************************************************
484  * input event interface
485  ******************************************************************************/
486
487 /* TODO should we issue a ringtone on a SND_BELL event?
488 static int input_ev(struct input_dev *dev, unsigned int type,
489                 unsigned int code, int value)
490 {
491
492         if (type != EV_SND)
493                 return -EINVAL;
494
495         switch (code) {
496         case SND_BELL:
497         case SND_TONE:
498                 break;
499         default:
500                 return -EINVAL;
501         }
502
503         return 0;
504 }
505 */
506
507 static int input_open(struct input_dev *dev)
508 {
509         struct yealink_dev *yld = dev->private;
510         int i, ret;
511
512         dbg("%s", __FUNCTION__);
513
514         /* force updates to device */
515         for (i = 0; i<sizeof(yld->master); i++)
516                 yld->copy.b[i] = ~yld->master.b[i];
517         yld->key_code = -1;     /* no keys pressed */
518
519         yealink_set_ringtone(yld, default_ringtone, sizeof(default_ringtone));
520
521         /* issue INIT */
522         memset(yld->ctl_data, 0, sizeof(*(yld->ctl_data)));
523         yld->ctl_data->cmd      = CMD_INIT;
524         yld->ctl_data->size     = 10;
525         yld->ctl_data->sum      = 0x100-CMD_INIT-10;
526         if ((ret = usb_submit_urb(yld->urb_ctl, GFP_KERNEL)) != 0) {
527                 dbg("%s - usb_submit_urb failed with result %d",
528                      __FUNCTION__, ret);
529                 return ret;
530         }
531         return 0;
532 }
533
534 static void input_close(struct input_dev *dev)
535 {
536         struct yealink_dev *yld = dev->private;
537
538         usb_kill_urb(yld->urb_ctl);
539         usb_kill_urb(yld->urb_irq);
540 }
541
542 /*******************************************************************************
543  * sysfs interface
544  ******************************************************************************/
545
546 static DECLARE_RWSEM(sysfs_rwsema);
547
548 /* Interface to the 7-segments translation table aka. char set.
549  */
550 static ssize_t show_map(struct device *dev, struct device_attribute *attr,
551                                 char *buf)
552 {
553         memcpy(buf, &map_seg7, sizeof(map_seg7));
554         return sizeof(map_seg7);
555 }
556
557 static ssize_t store_map(struct device *dev, struct device_attribute *attr,
558                                 const char *buf, size_t cnt)
559 {
560         if (cnt != sizeof(map_seg7))
561                 return -EINVAL;
562         memcpy(&map_seg7, buf, sizeof(map_seg7));
563         return sizeof(map_seg7);
564 }
565
566 /* Interface to the LCD.
567  */
568
569 /* Reading /sys/../lineX will return the format string with its settings:
570  *
571  * Example:
572  * cat ./line3
573  * 888888888888
574  * Linux Rocks!
575  */
576 static ssize_t show_line(struct device *dev, char *buf, int a, int b)
577 {
578         struct yealink_dev *yld;
579         int i;
580
581         down_read(&sysfs_rwsema);
582         yld = dev_get_drvdata(dev);
583         if (yld == NULL) {
584                 up_read(&sysfs_rwsema);
585                 return -ENODEV;
586         }
587
588         for (i = a; i < b; i++)
589                 *buf++ = lcdMap[i].type;
590         *buf++ = '\n';
591         for (i = a; i < b; i++)
592                 *buf++ = yld->lcdMap[i];
593         *buf++ = '\n';
594         *buf = 0;
595
596         up_read(&sysfs_rwsema);
597         return 3 + ((b - a) << 1);
598 }
599
600 static ssize_t show_line1(struct device *dev, struct device_attribute *attr,
601                         char *buf)
602 {
603         return show_line(dev, buf, LCD_LINE1_OFFSET, LCD_LINE2_OFFSET);
604 }
605
606 static ssize_t show_line2(struct device *dev, struct device_attribute *attr,
607                         char *buf)
608 {
609         return show_line(dev, buf, LCD_LINE2_OFFSET, LCD_LINE3_OFFSET);
610 }
611
612 static ssize_t show_line3(struct device *dev, struct device_attribute *attr,
613                         char *buf)
614 {
615         return show_line(dev, buf, LCD_LINE3_OFFSET, LCD_LINE4_OFFSET);
616 }
617
618 /* Writing to /sys/../lineX will set the coresponding LCD line.
619  * - Excess characters are ignored.
620  * - If less characters are written than allowed, the remaining digits are
621  *   unchanged.
622  * - The '\n' or '\t' char is a placeholder, it does not overwrite the
623  *   original content.
624  */
625 static ssize_t store_line(struct device *dev, const char *buf, size_t count,
626                 int el, size_t len)
627 {
628         struct yealink_dev *yld;
629         int i;
630
631         down_write(&sysfs_rwsema);
632         yld = dev_get_drvdata(dev);
633         if (yld == NULL) {
634                 up_write(&sysfs_rwsema);
635                 return -ENODEV;
636         }
637
638         if (len > count)
639                 len = count;
640         for (i = 0; i < len; i++)
641                 setChar(yld, el++, buf[i]);
642
643         up_write(&sysfs_rwsema);
644         return count;
645 }
646
647 static ssize_t store_line1(struct device *dev, struct device_attribute *attr,
648                                 const char *buf, size_t count)
649 {
650         return store_line(dev, buf, count, LCD_LINE1_OFFSET, LCD_LINE1_SIZE);
651 }
652
653 static ssize_t store_line2(struct device *dev, struct device_attribute *attr,
654                                 const char *buf, size_t count)
655 {
656         return store_line(dev, buf, count, LCD_LINE2_OFFSET, LCD_LINE2_SIZE);
657 }
658
659 static ssize_t store_line3(struct device *dev, struct device_attribute *attr,
660                                 const char *buf, size_t count)
661 {
662         return store_line(dev, buf, count, LCD_LINE3_OFFSET, LCD_LINE3_SIZE);
663 }
664
665 /* Interface to visible and audible "icons", these include:
666  * pictures on the LCD, the LED, and the dialtone signal.
667  */
668
669 /* Get a list of "switchable elements" with their current state. */
670 static ssize_t get_icons(struct device *dev, struct device_attribute *attr,
671                         char *buf)
672 {
673         struct yealink_dev *yld;
674         int i, ret = 1;
675
676         down_read(&sysfs_rwsema);
677         yld = dev_get_drvdata(dev);
678         if (yld == NULL) {
679                 up_read(&sysfs_rwsema);
680                 return -ENODEV;
681         }
682
683         for (i = 0; i < ARRAY_SIZE(lcdMap); i++) {
684                 if (lcdMap[i].type != '.')
685                         continue;
686                 ret += sprintf(&buf[ret], "%s %s\n",
687                                 yld->lcdMap[i] == ' ' ? "  " : "on",
688                                 lcdMap[i].u.p.name);
689         }
690         up_read(&sysfs_rwsema);
691         return ret;
692 }
693
694 /* Change the visibility of a particular element. */
695 static ssize_t set_icon(struct device *dev, const char *buf, size_t count,
696                         int chr)
697 {
698         struct yealink_dev *yld;
699         int i;
700
701         down_write(&sysfs_rwsema);
702         yld = dev_get_drvdata(dev);
703         if (yld == NULL) {
704                 up_write(&sysfs_rwsema);
705                 return -ENODEV;
706         }
707
708         for (i = 0; i < ARRAY_SIZE(lcdMap); i++) {
709                 if (lcdMap[i].type != '.')
710                         continue;
711                 if (strncmp(buf, lcdMap[i].u.p.name, count) == 0) {
712                         setChar(yld, i, chr);
713                         break;
714                 }
715         }
716
717         up_write(&sysfs_rwsema);
718         return count;
719 }
720
721 static ssize_t show_icon(struct device *dev, struct device_attribute *attr,
722                 const char *buf, size_t count)
723 {
724         return set_icon(dev, buf, count, buf[0]);
725 }
726
727 static ssize_t hide_icon(struct device *dev, struct device_attribute *attr,
728                 const char *buf, size_t count)
729 {
730         return set_icon(dev, buf, count, ' ');
731 }
732
733 /* Upload a ringtone to the device.
734  */
735
736 /* Stores raw ringtone data in the phone */
737 static ssize_t store_ringtone(struct device *dev,
738                 struct device_attribute *attr,
739                 const char *buf, size_t count)
740 {
741         struct yealink_dev *yld;
742
743         down_write(&sysfs_rwsema);
744         yld = dev_get_drvdata(dev);
745         if (yld == NULL) {
746                 up_write(&sysfs_rwsema);
747                 return -ENODEV;
748         }
749
750         /* TODO locking with async usb control interface??? */
751         yealink_set_ringtone(yld, (char *)buf, count);
752         up_write(&sysfs_rwsema);
753         return count;
754 }
755
756 #define _M444   S_IRUGO
757 #define _M664   S_IRUGO|S_IWUSR|S_IWGRP
758 #define _M220   S_IWUSR|S_IWGRP
759
760 static DEVICE_ATTR(map_seg7     , _M664, show_map       , store_map     );
761 static DEVICE_ATTR(line1        , _M664, show_line1     , store_line1   );
762 static DEVICE_ATTR(line2        , _M664, show_line2     , store_line2   );
763 static DEVICE_ATTR(line3        , _M664, show_line3     , store_line3   );
764 static DEVICE_ATTR(get_icons    , _M444, get_icons      , NULL          );
765 static DEVICE_ATTR(show_icon    , _M220, NULL           , show_icon     );
766 static DEVICE_ATTR(hide_icon    , _M220, NULL           , hide_icon     );
767 static DEVICE_ATTR(ringtone     , _M220, NULL           , store_ringtone);
768
769 static struct attribute *yld_attributes[] = {
770         &dev_attr_line1.attr,
771         &dev_attr_line2.attr,
772         &dev_attr_line3.attr,
773         &dev_attr_get_icons.attr,
774         &dev_attr_show_icon.attr,
775         &dev_attr_hide_icon.attr,
776         &dev_attr_map_seg7.attr,
777         &dev_attr_ringtone.attr,
778         NULL
779 };
780
781 static struct attribute_group yld_attr_group = {
782         .attrs = yld_attributes
783 };
784
785 /*******************************************************************************
786  * Linux interface and usb initialisation
787  ******************************************************************************/
788
789 struct driver_info {
790         char *name;
791 };
792
793 static const struct driver_info info_P1K = {
794         .name   = "Yealink usb-p1k",
795 };
796
797 static const struct usb_device_id usb_table [] = {
798         {
799                 .match_flags            = USB_DEVICE_ID_MATCH_DEVICE |
800                                                 USB_DEVICE_ID_MATCH_INT_INFO,
801                 .idVendor               = 0x6993,
802                 .idProduct              = 0xb001,
803                 .bInterfaceClass        = USB_CLASS_HID,
804                 .bInterfaceSubClass     = 0,
805                 .bInterfaceProtocol     = 0,
806                 .driver_info            = (kernel_ulong_t)&info_P1K
807         },
808         { }
809 };
810
811 static int usb_cleanup(struct yealink_dev *yld, int err)
812 {
813         if (yld == NULL)
814                 return err;
815
816         if (yld->urb_irq) {
817                 usb_kill_urb(yld->urb_irq);
818                 usb_free_urb(yld->urb_irq);
819         }
820         if (yld->urb_ctl)
821                 usb_free_urb(yld->urb_ctl);
822         if (yld->idev) {
823                 if (err)
824                         input_free_device(yld->idev);
825                 else
826                         input_unregister_device(yld->idev);
827         }
828         if (yld->ctl_req)
829                 usb_buffer_free(yld->udev, sizeof(*(yld->ctl_req)),
830                                 yld->ctl_req, yld->ctl_req_dma);
831         if (yld->ctl_data)
832                 usb_buffer_free(yld->udev, USB_PKT_LEN,
833                                 yld->ctl_data, yld->ctl_dma);
834         if (yld->irq_data)
835                 usb_buffer_free(yld->udev, USB_PKT_LEN,
836                                 yld->irq_data, yld->irq_dma);
837         kfree(yld);
838         return err;
839 }
840
841 static void usb_disconnect(struct usb_interface *intf)
842 {
843         struct yealink_dev *yld;
844
845         down_write(&sysfs_rwsema);
846         yld = usb_get_intfdata(intf);
847         sysfs_remove_group(&intf->dev.kobj, &yld_attr_group);
848         usb_set_intfdata(intf, NULL);
849         up_write(&sysfs_rwsema);
850
851         usb_cleanup(yld, 0);
852 }
853
854 static int usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
855 {
856         struct usb_device *udev = interface_to_usbdev (intf);
857         struct driver_info *nfo = (struct driver_info *)id->driver_info;
858         struct usb_host_interface *interface;
859         struct usb_endpoint_descriptor *endpoint;
860         struct yealink_dev *yld;
861         struct input_dev *input_dev;
862         int ret, pipe, i;
863
864         interface = intf->cur_altsetting;
865         endpoint = &interface->endpoint[0].desc;
866         if (!(endpoint->bEndpointAddress & USB_DIR_IN))
867                 return -EIO;
868         if ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_INT)
869                 return -EIO;
870
871         yld = kzalloc(sizeof(struct yealink_dev), GFP_KERNEL);
872         if (!yld)
873                 return -ENOMEM;
874
875         yld->udev = udev;
876
877         yld->idev = input_dev = input_allocate_device();
878         if (!input_dev)
879                 return usb_cleanup(yld, -ENOMEM);
880
881         /* allocate usb buffers */
882         yld->irq_data = usb_buffer_alloc(udev, USB_PKT_LEN,
883                                         SLAB_ATOMIC, &yld->irq_dma);
884         if (yld->irq_data == NULL)
885                 return usb_cleanup(yld, -ENOMEM);
886
887         yld->ctl_data = usb_buffer_alloc(udev, USB_PKT_LEN,
888                                         SLAB_ATOMIC, &yld->ctl_dma);
889         if (!yld->ctl_data)
890                 return usb_cleanup(yld, -ENOMEM);
891
892         yld->ctl_req = usb_buffer_alloc(udev, sizeof(*(yld->ctl_req)),
893                                         SLAB_ATOMIC, &yld->ctl_req_dma);
894         if (yld->ctl_req == NULL)
895                 return usb_cleanup(yld, -ENOMEM);
896
897         /* allocate urb structures */
898         yld->urb_irq = usb_alloc_urb(0, GFP_KERNEL);
899         if (yld->urb_irq == NULL)
900                 return usb_cleanup(yld, -ENOMEM);
901
902         yld->urb_ctl = usb_alloc_urb(0, GFP_KERNEL);
903         if (yld->urb_ctl == NULL)
904                 return usb_cleanup(yld, -ENOMEM);
905
906         /* get a handle to the interrupt data pipe */
907         pipe = usb_rcvintpipe(udev, endpoint->bEndpointAddress);
908         ret = usb_maxpacket(udev, pipe, usb_pipeout(pipe));
909         if (ret != USB_PKT_LEN)
910                 err("invalid payload size %d, expected %zd", ret, USB_PKT_LEN);
911
912         /* initialise irq urb */
913         usb_fill_int_urb(yld->urb_irq, udev, pipe, yld->irq_data,
914                         USB_PKT_LEN,
915                         urb_irq_callback,
916                         yld, endpoint->bInterval);
917         yld->urb_irq->transfer_dma = yld->irq_dma;
918         yld->urb_irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
919         yld->urb_irq->dev = udev;
920
921         /* initialise ctl urb */
922         yld->ctl_req->bRequestType = USB_TYPE_CLASS | USB_RECIP_INTERFACE |
923                                       USB_DIR_OUT;
924         yld->ctl_req->bRequest  = USB_REQ_SET_CONFIGURATION;
925         yld->ctl_req->wValue    = cpu_to_le16(0x200);
926         yld->ctl_req->wIndex    = cpu_to_le16(interface->desc.bInterfaceNumber);
927         yld->ctl_req->wLength   = cpu_to_le16(USB_PKT_LEN);
928
929         usb_fill_control_urb(yld->urb_ctl, udev, usb_sndctrlpipe(udev, 0),
930                         (void *)yld->ctl_req, yld->ctl_data, USB_PKT_LEN,
931                         urb_ctl_callback, yld);
932         yld->urb_ctl->setup_dma = yld->ctl_req_dma;
933         yld->urb_ctl->transfer_dma      = yld->ctl_dma;
934         yld->urb_ctl->transfer_flags    |= URB_NO_SETUP_DMA_MAP |
935                                         URB_NO_TRANSFER_DMA_MAP;
936         yld->urb_ctl->dev = udev;
937
938         /* find out the physical bus location */
939         usb_make_path(udev, yld->phys, sizeof(yld->phys));
940         strlcat(yld->phys,  "/input0", sizeof(yld->phys));
941
942         /* register settings for the input device */
943         input_dev->name = nfo->name;
944         input_dev->phys = yld->phys;
945         usb_to_input_id(udev, &input_dev->id);
946         input_dev->cdev.dev = &intf->dev;
947
948         input_dev->private = yld;
949         input_dev->open = input_open;
950         input_dev->close = input_close;
951         /* input_dev->event = input_ev; TODO */
952
953         /* register available key events */
954         input_dev->evbit[0] = BIT(EV_KEY);
955         for (i = 0; i < 256; i++) {
956                 int k = map_p1k_to_key(i);
957                 if (k >= 0) {
958                         set_bit(k & 0xff, input_dev->keybit);
959                         if (k >> 8)
960                                 set_bit(k >> 8, input_dev->keybit);
961                 }
962         }
963
964         input_register_device(yld->idev);
965
966         usb_set_intfdata(intf, yld);
967
968         /* clear visible elements */
969         for (i = 0; i < ARRAY_SIZE(lcdMap); i++)
970                 setChar(yld, i, ' ');
971
972         /* display driver version on LCD line 3 */
973         store_line3(&intf->dev, NULL,
974                         DRIVER_VERSION, sizeof(DRIVER_VERSION));
975
976         /* Register sysfs hooks (don't care about failure) */
977         sysfs_create_group(&intf->dev.kobj, &yld_attr_group);
978         return 0;
979 }
980
981 static struct usb_driver yealink_driver = {
982         .name           = "yealink",
983         .probe          = usb_probe,
984         .disconnect     = usb_disconnect,
985         .id_table       = usb_table,
986 };
987
988 static int __init yealink_dev_init(void)
989 {
990         int ret = usb_register(&yealink_driver);
991         if (ret == 0)
992                 info(DRIVER_DESC ":" DRIVER_VERSION);
993         return ret;
994 }
995
996 static void __exit yealink_dev_exit(void)
997 {
998         usb_deregister(&yealink_driver);
999 }
1000
1001 module_init(yealink_dev_init);
1002 module_exit(yealink_dev_exit);
1003
1004 MODULE_DEVICE_TABLE (usb, usb_table);
1005
1006 MODULE_AUTHOR(DRIVER_AUTHOR);
1007 MODULE_DESCRIPTION(DRIVER_DESC);
1008 MODULE_LICENSE("GPL");