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