Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
yealink.c
Go to the documentation of this file.
1 /*
2  * drivers/usb/input/yealink.c
3  *
4  * Copyright (c) 2005 Henk Vergonet <[email protected]>
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/input/joystick/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/kernel.h>
50 #include <linux/init.h>
51 #include <linux/slab.h>
52 #include <linux/module.h>
53 #include <linux/rwsem.h>
54 #include <linux/usb/input.h>
55 #include <linux/map_to_7segment.h>
56 
57 #include "yealink.h"
58 
59 #define DRIVER_VERSION "yld-20051230"
60 #define DRIVER_AUTHOR "Henk Vergonet"
61 #define DRIVER_DESC "Yealink phone driver"
62 
63 #define YEALINK_POLLING_FREQUENCY 10 /* in [Hz] */
64 
65 struct yld_status {
66  u8 lcd[24];
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 
86 static 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 
101 struct yealink_dev {
102  struct input_dev *idev; /* input device */
103  struct usb_device *udev; /* usb device */
104  struct usb_interface *intf; /* usb interface */
105 
106  /* irq input channel */
109  struct urb *urb_irq;
110 
111  /* control output channel */
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  unsigned int shutdown:1;
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  */
139 static 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  */
145 static 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  */
206 static 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  */
238 static void report_key(struct yealink_dev *yld, int key)
239 {
240  struct input_dev *idev = yld->idev;
241 
242  if (yld->key_code >= 0) {
243  /* old key up */
244  input_report_key(idev, yld->key_code & 0xff, 0);
245  if (yld->key_code >> 8)
246  input_report_key(idev, yld->key_code >> 8, 0);
247  }
248 
249  yld->key_code = key;
250  if (key >= 0) {
251  /* new valid key */
252  input_report_key(idev, key & 0xff, 1);
253  if (key >> 8)
254  input_report_key(idev, key >> 8, 1);
255  }
256  input_sync(idev);
257 }
258 
259 /*******************************************************************************
260  * Yealink usb communication interface
261  ******************************************************************************/
262 
263 static int yealink_cmd(struct yealink_dev *yld, struct yld_ctl_packet *p)
264 {
265  u8 *buf = (u8 *)p;
266  int i;
267  u8 sum = 0;
268 
269  for(i=0; i<USB_PKT_LEN-1; i++)
270  sum -= buf[i];
271  p->sum = sum;
272  return usb_control_msg(yld->udev,
273  usb_sndctrlpipe(yld->udev, 0),
276  0x200, 3,
277  p, sizeof(*p),
278  USB_CTRL_SET_TIMEOUT);
279 }
280 
281 static u8 default_ringtone[] = {
282  0xEF, /* volume [0-255] */
283  0xFB, 0x1E, 0x00, 0x0C, /* 1250 [hz], 12/100 [s] */
284  0xFC, 0x18, 0x00, 0x0C, /* 1000 [hz], 12/100 [s] */
285  0xFB, 0x1E, 0x00, 0x0C,
286  0xFC, 0x18, 0x00, 0x0C,
287  0xFB, 0x1E, 0x00, 0x0C,
288  0xFC, 0x18, 0x00, 0x0C,
289  0xFB, 0x1E, 0x00, 0x0C,
290  0xFC, 0x18, 0x00, 0x0C,
291  0xFF, 0xFF, 0x01, 0x90, /* silent, 400/100 [s] */
292  0x00, 0x00 /* end of sequence */
293 };
294 
295 static int yealink_set_ringtone(struct yealink_dev *yld, u8 *buf, size_t size)
296 {
297  struct yld_ctl_packet *p = yld->ctl_data;
298  int ix, len;
299 
300  if (size <= 0)
301  return -EINVAL;
302 
303  /* Set the ringtone volume */
304  memset(yld->ctl_data, 0, sizeof(*(yld->ctl_data)));
305  yld->ctl_data->cmd = CMD_RING_VOLUME;
306  yld->ctl_data->size = 1;
307  yld->ctl_data->data[0] = buf[0];
308  yealink_cmd(yld, p);
309 
310  buf++;
311  size--;
312 
313  p->cmd = CMD_RING_NOTE;
314  ix = 0;
315  while (size != ix) {
316  len = size - ix;
317  if (len > sizeof(p->data))
318  len = sizeof(p->data);
319  p->size = len;
320  p->offset = cpu_to_be16(ix);
321  memcpy(p->data, &buf[ix], len);
322  yealink_cmd(yld, p);
323  ix += len;
324  }
325  return 0;
326 }
327 
328 /* keep stat_master & stat_copy in sync.
329  */
330 static int yealink_do_idle_tasks(struct yealink_dev *yld)
331 {
332  u8 val;
333  int i, ix, len;
334 
335  ix = yld->stat_ix;
336 
337  memset(yld->ctl_data, 0, sizeof(*(yld->ctl_data)));
338  yld->ctl_data->cmd = CMD_KEYPRESS;
339  yld->ctl_data->size = 1;
340  yld->ctl_data->sum = 0xff - CMD_KEYPRESS;
341 
342  /* If state update pointer wraps do a KEYPRESS first. */
343  if (ix >= sizeof(yld->master)) {
344  yld->stat_ix = 0;
345  return 0;
346  }
347 
348  /* find update candidates: copy != master */
349  do {
350  val = yld->master.b[ix];
351  if (val != yld->copy.b[ix])
352  goto send_update;
353  } while (++ix < sizeof(yld->master));
354 
355  /* nothing todo, wait a bit and poll for a KEYPRESS */
356  yld->stat_ix = 0;
357  /* TODO how can we wait abit. ??
358  * msleep_interruptible(1000 / YEALINK_POLLING_FREQUENCY);
359  */
360  return 0;
361 
362 send_update:
363 
364  /* Setup an appropriate update request */
365  yld->copy.b[ix] = val;
366  yld->ctl_data->data[0] = val;
367 
368  switch(ix) {
369  case offsetof(struct yld_status, led):
370  yld->ctl_data->cmd = CMD_LED;
371  yld->ctl_data->sum = -1 - CMD_LED - val;
372  break;
373  case offsetof(struct yld_status, dialtone):
374  yld->ctl_data->cmd = CMD_DIALTONE;
375  yld->ctl_data->sum = -1 - CMD_DIALTONE - val;
376  break;
377  case offsetof(struct yld_status, ringtone):
378  yld->ctl_data->cmd = CMD_RINGTONE;
379  yld->ctl_data->sum = -1 - CMD_RINGTONE - val;
380  break;
381  case offsetof(struct yld_status, keynum):
382  val--;
383  val &= 0x1f;
384  yld->ctl_data->cmd = CMD_SCANCODE;
385  yld->ctl_data->offset = cpu_to_be16(val);
386  yld->ctl_data->data[0] = 0;
387  yld->ctl_data->sum = -1 - CMD_SCANCODE - val;
388  break;
389  default:
390  len = sizeof(yld->master.s.lcd) - ix;
391  if (len > sizeof(yld->ctl_data->data))
392  len = sizeof(yld->ctl_data->data);
393 
394  /* Combine up to <len> consecutive LCD bytes in a singe request
395  */
396  yld->ctl_data->cmd = CMD_LCD;
397  yld->ctl_data->offset = cpu_to_be16(ix);
398  yld->ctl_data->size = len;
399  yld->ctl_data->sum = -CMD_LCD - ix - val - len;
400  for(i=1; i<len; i++) {
401  ix++;
402  val = yld->master.b[ix];
403  yld->copy.b[ix] = val;
404  yld->ctl_data->data[i] = val;
405  yld->ctl_data->sum -= val;
406  }
407  }
408  yld->stat_ix = ix + 1;
409  return 1;
410 }
411 
412 /* Decide on how to handle responses
413  *
414  * The state transition diagram is somethhing like:
415  *
416  * syncState<--+
417  * | |
418  * | idle
419  * \|/ |
420  * init --ok--> waitForKey --ok--> getKey
421  * ^ ^ |
422  * | +-------ok-------+
423  * error,start
424  *
425  */
426 static void urb_irq_callback(struct urb *urb)
427 {
428  struct yealink_dev *yld = urb->context;
429  int ret, status = urb->status;
430 
431  if (status)
432  dev_err(&yld->intf->dev, "%s - urb status %d\n",
433  __func__, 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  dev_dbg(&yld->intf->dev, "get scancode %x\n",
443  yld->irq_data->data[0]);
444 
445  report_key(yld, map_p1k_to_key(yld->irq_data->data[0]));
446  break;
447 
448  default:
449  dev_err(&yld->intf->dev, "unexpected response %x\n",
450  yld->irq_data->cmd);
451  }
452 
453  yealink_do_idle_tasks(yld);
454 
455  if (!yld->shutdown) {
456  ret = usb_submit_urb(yld->urb_ctl, GFP_ATOMIC);
457  if (ret && ret != -EPERM)
458  dev_err(&yld->intf->dev,
459  "%s - usb_submit_urb failed %d\n",
460  __func__, ret);
461  }
462 }
463 
464 static void urb_ctl_callback(struct urb *urb)
465 {
466  struct yealink_dev *yld = urb->context;
467  int ret = 0, status = urb->status;
468 
469  if (status)
470  dev_err(&yld->intf->dev, "%s - urb status %d\n",
471  __func__, status);
472 
473  switch (yld->ctl_data->cmd) {
474  case CMD_KEYPRESS:
475  case CMD_SCANCODE:
476  /* ask for a response */
477  if (!yld->shutdown)
478  ret = usb_submit_urb(yld->urb_irq, GFP_ATOMIC);
479  break;
480  default:
481  /* send new command */
482  yealink_do_idle_tasks(yld);
483  if (!yld->shutdown)
484  ret = usb_submit_urb(yld->urb_ctl, GFP_ATOMIC);
485  break;
486  }
487 
488  if (ret && ret != -EPERM)
489  dev_err(&yld->intf->dev, "%s - usb_submit_urb failed %d\n",
490  __func__, ret);
491 }
492 
493 /*******************************************************************************
494  * input event interface
495  ******************************************************************************/
496 
497 /* TODO should we issue a ringtone on a SND_BELL event?
498 static int input_ev(struct input_dev *dev, unsigned int type,
499  unsigned int code, int value)
500 {
501 
502  if (type != EV_SND)
503  return -EINVAL;
504 
505  switch (code) {
506  case SND_BELL:
507  case SND_TONE:
508  break;
509  default:
510  return -EINVAL;
511  }
512 
513  return 0;
514 }
515 */
516 
517 static int input_open(struct input_dev *dev)
518 {
519  struct yealink_dev *yld = input_get_drvdata(dev);
520  int i, ret;
521 
522  dev_dbg(&yld->intf->dev, "%s\n", __func__);
523 
524  /* force updates to device */
525  for (i = 0; i<sizeof(yld->master); i++)
526  yld->copy.b[i] = ~yld->master.b[i];
527  yld->key_code = -1; /* no keys pressed */
528 
529  yealink_set_ringtone(yld, default_ringtone, sizeof(default_ringtone));
530 
531  /* issue INIT */
532  memset(yld->ctl_data, 0, sizeof(*(yld->ctl_data)));
533  yld->ctl_data->cmd = CMD_INIT;
534  yld->ctl_data->size = 10;
535  yld->ctl_data->sum = 0x100-CMD_INIT-10;
536  if ((ret = usb_submit_urb(yld->urb_ctl, GFP_KERNEL)) != 0) {
537  dev_dbg(&yld->intf->dev,
538  "%s - usb_submit_urb failed with result %d\n",
539  __func__, ret);
540  return ret;
541  }
542  return 0;
543 }
544 
545 static void input_close(struct input_dev *dev)
546 {
547  struct yealink_dev *yld = input_get_drvdata(dev);
548 
549  yld->shutdown = 1;
550  /*
551  * Make sure the flag is seen by other CPUs before we start
552  * killing URBs so new URBs won't be submitted
553  */
554  smp_wmb();
555 
556  usb_kill_urb(yld->urb_ctl);
557  usb_kill_urb(yld->urb_irq);
558 
559  yld->shutdown = 0;
560  smp_wmb();
561 }
562 
563 /*******************************************************************************
564  * sysfs interface
565  ******************************************************************************/
566 
567 static DECLARE_RWSEM(sysfs_rwsema);
568 
569 /* Interface to the 7-segments translation table aka. char set.
570  */
571 static ssize_t show_map(struct device *dev, struct device_attribute *attr,
572  char *buf)
573 {
574  memcpy(buf, &map_seg7, sizeof(map_seg7));
575  return sizeof(map_seg7);
576 }
577 
578 static ssize_t store_map(struct device *dev, struct device_attribute *attr,
579  const char *buf, size_t cnt)
580 {
581  if (cnt != sizeof(map_seg7))
582  return -EINVAL;
583  memcpy(&map_seg7, buf, sizeof(map_seg7));
584  return sizeof(map_seg7);
585 }
586 
587 /* Interface to the LCD.
588  */
589 
590 /* Reading /sys/../lineX will return the format string with its settings:
591  *
592  * Example:
593  * cat ./line3
594  * 888888888888
595  * Linux Rocks!
596  */
597 static ssize_t show_line(struct device *dev, char *buf, int a, int b)
598 {
599  struct yealink_dev *yld;
600  int i;
601 
602  down_read(&sysfs_rwsema);
603  yld = dev_get_drvdata(dev);
604  if (yld == NULL) {
605  up_read(&sysfs_rwsema);
606  return -ENODEV;
607  }
608 
609  for (i = a; i < b; i++)
610  *buf++ = lcdMap[i].type;
611  *buf++ = '\n';
612  for (i = a; i < b; i++)
613  *buf++ = yld->lcdMap[i];
614  *buf++ = '\n';
615  *buf = 0;
616 
617  up_read(&sysfs_rwsema);
618  return 3 + ((b - a) << 1);
619 }
620 
621 static ssize_t show_line1(struct device *dev, struct device_attribute *attr,
622  char *buf)
623 {
624  return show_line(dev, buf, LCD_LINE1_OFFSET, LCD_LINE2_OFFSET);
625 }
626 
627 static ssize_t show_line2(struct device *dev, struct device_attribute *attr,
628  char *buf)
629 {
630  return show_line(dev, buf, LCD_LINE2_OFFSET, LCD_LINE3_OFFSET);
631 }
632 
633 static ssize_t show_line3(struct device *dev, struct device_attribute *attr,
634  char *buf)
635 {
636  return show_line(dev, buf, LCD_LINE3_OFFSET, LCD_LINE4_OFFSET);
637 }
638 
639 /* Writing to /sys/../lineX will set the coresponding LCD line.
640  * - Excess characters are ignored.
641  * - If less characters are written than allowed, the remaining digits are
642  * unchanged.
643  * - The '\n' or '\t' char is a placeholder, it does not overwrite the
644  * original content.
645  */
646 static ssize_t store_line(struct device *dev, const char *buf, size_t count,
647  int el, size_t len)
648 {
649  struct yealink_dev *yld;
650  int i;
651 
652  down_write(&sysfs_rwsema);
653  yld = dev_get_drvdata(dev);
654  if (yld == NULL) {
655  up_write(&sysfs_rwsema);
656  return -ENODEV;
657  }
658 
659  if (len > count)
660  len = count;
661  for (i = 0; i < len; i++)
662  setChar(yld, el++, buf[i]);
663 
664  up_write(&sysfs_rwsema);
665  return count;
666 }
667 
668 static ssize_t store_line1(struct device *dev, struct device_attribute *attr,
669  const char *buf, size_t count)
670 {
671  return store_line(dev, buf, count, LCD_LINE1_OFFSET, LCD_LINE1_SIZE);
672 }
673 
674 static ssize_t store_line2(struct device *dev, struct device_attribute *attr,
675  const char *buf, size_t count)
676 {
677  return store_line(dev, buf, count, LCD_LINE2_OFFSET, LCD_LINE2_SIZE);
678 }
679 
680 static ssize_t store_line3(struct device *dev, struct device_attribute *attr,
681  const char *buf, size_t count)
682 {
683  return store_line(dev, buf, count, LCD_LINE3_OFFSET, LCD_LINE3_SIZE);
684 }
685 
686 /* Interface to visible and audible "icons", these include:
687  * pictures on the LCD, the LED, and the dialtone signal.
688  */
689 
690 /* Get a list of "switchable elements" with their current state. */
691 static ssize_t get_icons(struct device *dev, struct device_attribute *attr,
692  char *buf)
693 {
694  struct yealink_dev *yld;
695  int i, ret = 1;
696 
697  down_read(&sysfs_rwsema);
698  yld = dev_get_drvdata(dev);
699  if (yld == NULL) {
700  up_read(&sysfs_rwsema);
701  return -ENODEV;
702  }
703 
704  for (i = 0; i < ARRAY_SIZE(lcdMap); i++) {
705  if (lcdMap[i].type != '.')
706  continue;
707  ret += sprintf(&buf[ret], "%s %s\n",
708  yld->lcdMap[i] == ' ' ? " " : "on",
709  lcdMap[i].u.p.name);
710  }
711  up_read(&sysfs_rwsema);
712  return ret;
713 }
714 
715 /* Change the visibility of a particular element. */
716 static ssize_t set_icon(struct device *dev, const char *buf, size_t count,
717  int chr)
718 {
719  struct yealink_dev *yld;
720  int i;
721 
722  down_write(&sysfs_rwsema);
723  yld = dev_get_drvdata(dev);
724  if (yld == NULL) {
725  up_write(&sysfs_rwsema);
726  return -ENODEV;
727  }
728 
729  for (i = 0; i < ARRAY_SIZE(lcdMap); i++) {
730  if (lcdMap[i].type != '.')
731  continue;
732  if (strncmp(buf, lcdMap[i].u.p.name, count) == 0) {
733  setChar(yld, i, chr);
734  break;
735  }
736  }
737 
738  up_write(&sysfs_rwsema);
739  return count;
740 }
741 
742 static ssize_t show_icon(struct device *dev, struct device_attribute *attr,
743  const char *buf, size_t count)
744 {
745  return set_icon(dev, buf, count, buf[0]);
746 }
747 
748 static ssize_t hide_icon(struct device *dev, struct device_attribute *attr,
749  const char *buf, size_t count)
750 {
751  return set_icon(dev, buf, count, ' ');
752 }
753 
754 /* Upload a ringtone to the device.
755  */
756 
757 /* Stores raw ringtone data in the phone */
758 static ssize_t store_ringtone(struct device *dev,
759  struct device_attribute *attr,
760  const char *buf, size_t count)
761 {
762  struct yealink_dev *yld;
763 
764  down_write(&sysfs_rwsema);
765  yld = dev_get_drvdata(dev);
766  if (yld == NULL) {
767  up_write(&sysfs_rwsema);
768  return -ENODEV;
769  }
770 
771  /* TODO locking with async usb control interface??? */
772  yealink_set_ringtone(yld, (char *)buf, count);
773  up_write(&sysfs_rwsema);
774  return count;
775 }
776 
777 #define _M444 S_IRUGO
778 #define _M664 S_IRUGO|S_IWUSR|S_IWGRP
779 #define _M220 S_IWUSR|S_IWGRP
780 
781 static DEVICE_ATTR(map_seg7 , _M664, show_map , store_map );
782 static DEVICE_ATTR(line1 , _M664, show_line1 , store_line1 );
783 static DEVICE_ATTR(line2 , _M664, show_line2 , store_line2 );
784 static DEVICE_ATTR(line3 , _M664, show_line3 , store_line3 );
785 static DEVICE_ATTR(get_icons , _M444, get_icons , NULL );
786 static DEVICE_ATTR(show_icon , _M220, NULL , show_icon );
787 static DEVICE_ATTR(hide_icon , _M220, NULL , hide_icon );
788 static DEVICE_ATTR(ringtone , _M220, NULL , store_ringtone);
789 
790 static struct attribute *yld_attributes[] = {
791  &dev_attr_line1.attr,
792  &dev_attr_line2.attr,
793  &dev_attr_line3.attr,
794  &dev_attr_get_icons.attr,
795  &dev_attr_show_icon.attr,
796  &dev_attr_hide_icon.attr,
797  &dev_attr_map_seg7.attr,
798  &dev_attr_ringtone.attr,
799  NULL
800 };
801 
802 static struct attribute_group yld_attr_group = {
803  .attrs = yld_attributes
804 };
805 
806 /*******************************************************************************
807  * Linux interface and usb initialisation
808  ******************************************************************************/
809 
810 struct driver_info {
811  char *name;
812 };
813 
814 static const struct driver_info info_P1K = {
815  .name = "Yealink usb-p1k",
816 };
817 
818 static const struct usb_device_id usb_table [] = {
819  {
820  .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
821  USB_DEVICE_ID_MATCH_INT_INFO,
822  .idVendor = 0x6993,
823  .idProduct = 0xb001,
824  .bInterfaceClass = USB_CLASS_HID,
825  .bInterfaceSubClass = 0,
826  .bInterfaceProtocol = 0,
827  .driver_info = (kernel_ulong_t)&info_P1K
828  },
829  { }
830 };
831 
832 static int usb_cleanup(struct yealink_dev *yld, int err)
833 {
834  if (yld == NULL)
835  return err;
836 
837  if (yld->idev) {
838  if (err)
839  input_free_device(yld->idev);
840  else
841  input_unregister_device(yld->idev);
842  }
843 
844  usb_free_urb(yld->urb_irq);
845  usb_free_urb(yld->urb_ctl);
846 
847  kfree(yld->ctl_req);
848  usb_free_coherent(yld->udev, USB_PKT_LEN, yld->ctl_data, yld->ctl_dma);
849  usb_free_coherent(yld->udev, USB_PKT_LEN, yld->irq_data, yld->irq_dma);
850 
851  kfree(yld);
852  return err;
853 }
854 
855 static void usb_disconnect(struct usb_interface *intf)
856 {
857  struct yealink_dev *yld;
858 
859  down_write(&sysfs_rwsema);
860  yld = usb_get_intfdata(intf);
861  sysfs_remove_group(&intf->dev.kobj, &yld_attr_group);
862  usb_set_intfdata(intf, NULL);
863  up_write(&sysfs_rwsema);
864 
865  usb_cleanup(yld, 0);
866 }
867 
868 static int usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
869 {
870  struct usb_device *udev = interface_to_usbdev (intf);
871  struct driver_info *nfo = (struct driver_info *)id->driver_info;
872  struct usb_host_interface *interface;
874  struct yealink_dev *yld;
875  struct input_dev *input_dev;
876  int ret, pipe, i;
877 
878  interface = intf->cur_altsetting;
879  endpoint = &interface->endpoint[0].desc;
880  if (!usb_endpoint_is_int_in(endpoint))
881  return -ENODEV;
882 
883  yld = kzalloc(sizeof(struct yealink_dev), GFP_KERNEL);
884  if (!yld)
885  return -ENOMEM;
886 
887  yld->udev = udev;
888  yld->intf = intf;
889 
890  yld->idev = input_dev = input_allocate_device();
891  if (!input_dev)
892  return usb_cleanup(yld, -ENOMEM);
893 
894  /* allocate usb buffers */
895  yld->irq_data = usb_alloc_coherent(udev, USB_PKT_LEN,
896  GFP_ATOMIC, &yld->irq_dma);
897  if (yld->irq_data == NULL)
898  return usb_cleanup(yld, -ENOMEM);
899 
900  yld->ctl_data = usb_alloc_coherent(udev, USB_PKT_LEN,
901  GFP_ATOMIC, &yld->ctl_dma);
902  if (!yld->ctl_data)
903  return usb_cleanup(yld, -ENOMEM);
904 
905  yld->ctl_req = kmalloc(sizeof(*(yld->ctl_req)), GFP_KERNEL);
906  if (yld->ctl_req == NULL)
907  return usb_cleanup(yld, -ENOMEM);
908 
909  /* allocate urb structures */
910  yld->urb_irq = usb_alloc_urb(0, GFP_KERNEL);
911  if (yld->urb_irq == NULL)
912  return usb_cleanup(yld, -ENOMEM);
913 
914  yld->urb_ctl = usb_alloc_urb(0, GFP_KERNEL);
915  if (yld->urb_ctl == NULL)
916  return usb_cleanup(yld, -ENOMEM);
917 
918  /* get a handle to the interrupt data pipe */
919  pipe = usb_rcvintpipe(udev, endpoint->bEndpointAddress);
920  ret = usb_maxpacket(udev, pipe, usb_pipeout(pipe));
921  if (ret != USB_PKT_LEN)
922  dev_err(&intf->dev, "invalid payload size %d, expected %zd\n",
923  ret, USB_PKT_LEN);
924 
925  /* initialise irq urb */
926  usb_fill_int_urb(yld->urb_irq, udev, pipe, yld->irq_data,
927  USB_PKT_LEN,
928  urb_irq_callback,
929  yld, endpoint->bInterval);
930  yld->urb_irq->transfer_dma = yld->irq_dma;
931  yld->urb_irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
932  yld->urb_irq->dev = udev;
933 
934  /* initialise ctl urb */
935  yld->ctl_req->bRequestType = USB_TYPE_CLASS | USB_RECIP_INTERFACE |
936  USB_DIR_OUT;
937  yld->ctl_req->bRequest = USB_REQ_SET_CONFIGURATION;
938  yld->ctl_req->wValue = cpu_to_le16(0x200);
939  yld->ctl_req->wIndex = cpu_to_le16(interface->desc.bInterfaceNumber);
940  yld->ctl_req->wLength = cpu_to_le16(USB_PKT_LEN);
941 
942  usb_fill_control_urb(yld->urb_ctl, udev, usb_sndctrlpipe(udev, 0),
943  (void *)yld->ctl_req, yld->ctl_data, USB_PKT_LEN,
944  urb_ctl_callback, yld);
945  yld->urb_ctl->transfer_dma = yld->ctl_dma;
946  yld->urb_ctl->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
947  yld->urb_ctl->dev = udev;
948 
949  /* find out the physical bus location */
950  usb_make_path(udev, yld->phys, sizeof(yld->phys));
951  strlcat(yld->phys, "/input0", sizeof(yld->phys));
952 
953  /* register settings for the input device */
954  input_dev->name = nfo->name;
955  input_dev->phys = yld->phys;
956  usb_to_input_id(udev, &input_dev->id);
957  input_dev->dev.parent = &intf->dev;
958 
959  input_set_drvdata(input_dev, yld);
960 
961  input_dev->open = input_open;
962  input_dev->close = input_close;
963  /* input_dev->event = input_ev; TODO */
964 
965  /* register available key events */
966  input_dev->evbit[0] = BIT_MASK(EV_KEY);
967  for (i = 0; i < 256; i++) {
968  int k = map_p1k_to_key(i);
969  if (k >= 0) {
970  set_bit(k & 0xff, input_dev->keybit);
971  if (k >> 8)
972  set_bit(k >> 8, input_dev->keybit);
973  }
974  }
975 
976  ret = input_register_device(yld->idev);
977  if (ret)
978  return usb_cleanup(yld, ret);
979 
980  usb_set_intfdata(intf, yld);
981 
982  /* clear visible elements */
983  for (i = 0; i < ARRAY_SIZE(lcdMap); i++)
984  setChar(yld, i, ' ');
985 
986  /* display driver version on LCD line 3 */
987  store_line3(&intf->dev, NULL,
988  DRIVER_VERSION, sizeof(DRIVER_VERSION));
989 
990  /* Register sysfs hooks (don't care about failure) */
991  ret = sysfs_create_group(&intf->dev.kobj, &yld_attr_group);
992  return 0;
993 }
994 
995 static struct usb_driver yealink_driver = {
996  .name = "yealink",
997  .probe = usb_probe,
998  .disconnect = usb_disconnect,
999  .id_table = usb_table,
1000 };
1001 
1002 module_usb_driver(yealink_driver);
1003 
1004 MODULE_DEVICE_TABLE (usb, usb_table);
1005 
1008 MODULE_LICENSE("GPL");