projects/linux·blob master · refs

950 lines · 23.0 KiB

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