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