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