2 * drivers/usb/input/yealink.c
4 * Copyright (c) 2005 Henk Vergonet <Henk.Vergonet@gmail.com>
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.
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.
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
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:
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
35 * - Olivier Vandorpe, for providing the usbb2k-api.
36 * - Martin Diehl, for spotting my memory allocation bug.
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
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>
59 #define DRIVER_VERSION "yld-20051230"
60 #define DRIVER_AUTHOR "Henk Vergonet"
61 #define DRIVER_DESC "Yealink phone driver"
63 #define YEALINK_POLLING_FREQUENCY 10 /* in [Hz] */
71 } __attribute__ ((packed));
74 * Register the LCD segment and icon map
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) \
79 .u = { .s = { _LOC(a, am), _LOC(b, bm), _LOC(c, cm), \
80 _LOC(d, dm), _LOC(e, em), _LOC(g, gm), \
82 #define _PIC(t, h, hm, n) \
84 .u = { .p = { .name = (n), .a = (h), .m = (hm) } } }
86 static const struct lcd_segment_map {
89 struct pictogram_map {
102 struct input_dev *idev; /* input device */
103 struct usb_device *udev; /* usb device */
105 /* irq input channel */
106 struct yld_ctl_packet *irq_data;
110 /* control output channel */
111 struct yld_ctl_packet *ctl_data;
113 struct usb_ctrlrequest *ctl_req;
116 char phys[64]; /* physical device path */
118 u8 lcdMap[ARRAY_SIZE(lcdMap)]; /* state of LCD, LED ... */
119 int key_code; /* last reported key */
121 unsigned int shutdown:1;
126 u8 b[sizeof(struct yld_status)];
131 /*******************************************************************************
132 * Yealink lcd interface
133 ******************************************************************************/
136 * Register a default 7 segment character set
138 static SEG7_DEFAULT_MAP(map_seg7);
141 * char '\9' and '\n' are placeholders and do not overwrite the original text.
142 * A space will always hide an icon.
144 static int setChar(struct yealink_dev *yld, int el, int chr)
148 if (el >= ARRAY_SIZE(lcdMap))
151 if (chr == '\t' || chr == '\n')
154 yld->lcdMap[el] = chr;
156 if (lcdMap[el].type == '.') {
157 a = lcdMap[el].u.p.a;
158 m = lcdMap[el].u.p.m;
160 yld->master.b[a] |= m;
162 yld->master.b[a] &= ~m;
166 val = map_to_seg7(&map_seg7, chr);
167 for (i = 0; i < ARRAY_SIZE(lcdMap[0].u.s); i++) {
168 m = lcdMap[el].u.s[i].m;
173 a = lcdMap[el].u.s[i].a;
175 yld->master.b[a] |= m;
177 yld->master.b[a] &= ~m;
183 /*******************************************************************************
184 * Yealink key interface
185 ******************************************************************************/
187 /* Map device buttons to internal key events.
189 * USB-P1K button layout:
201 * The "up" and "down" keys, are symbolised by arrows on the button.
202 * The "pickup" and "hangup" keys are symbolised by a green and red phone
205 static int map_p1k_to_key(int scancode)
207 switch(scancode) { /* phone key: */
208 case 0x23: return KEY_LEFT; /* IN */
209 case 0x33: return KEY_UP; /* up */
210 case 0x04: return KEY_RIGHT; /* OUT */
211 case 0x24: return KEY_DOWN; /* down */
212 case 0x03: return KEY_ENTER; /* pickup */
213 case 0x14: return KEY_BACKSPACE; /* C */
214 case 0x13: return KEY_ESC; /* hangup */
215 case 0x00: return KEY_1; /* 1 */
216 case 0x01: return KEY_2; /* 2 */
217 case 0x02: return KEY_3; /* 3 */
218 case 0x10: return KEY_4; /* 4 */
219 case 0x11: return KEY_5; /* 5 */
220 case 0x12: return KEY_6; /* 6 */
221 case 0x20: return KEY_7; /* 7 */
222 case 0x21: return KEY_8; /* 8 */
223 case 0x22: return KEY_9; /* 9 */
224 case 0x30: return KEY_KPASTERISK; /* * */
225 case 0x31: return KEY_0; /* 0 */
226 case 0x32: return KEY_LEFTSHIFT |
232 /* Completes a request by converting the data into events for the
235 * The key parameter can be cascaded: key2 << 8 | key1
237 static void report_key(struct yealink_dev *yld, int key)
239 struct input_dev *idev = yld->idev;
241 if (yld->key_code >= 0) {
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);
251 input_report_key(idev, key & 0xff, 1);
253 input_report_key(idev, key >> 8, 1);
258 /*******************************************************************************
259 * Yealink usb communication interface
260 ******************************************************************************/
262 static int yealink_cmd(struct yealink_dev *yld, struct yld_ctl_packet *p)
268 for(i=0; i<USB_PKT_LEN-1; i++)
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,
277 USB_CTRL_SET_TIMEOUT);
280 static 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 */
294 static int yealink_set_ringtone(struct yealink_dev *yld, u8 *buf, size_t size)
296 struct yld_ctl_packet *p = yld->ctl_data;
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];
312 p->cmd = CMD_RING_NOTE;
316 if (len > sizeof(p->data))
317 len = sizeof(p->data);
319 p->offset = cpu_to_be16(ix);
320 memcpy(p->data, &buf[ix], len);
327 /* keep stat_master & stat_copy in sync.
329 static int yealink_do_idle_tasks(struct yealink_dev *yld)
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;
341 /* If state update pointer wraps do a KEYPRESS first. */
342 if (ix >= sizeof(yld->master)) {
347 /* find update candidates: copy != master */
349 val = yld->master.b[ix];
350 if (val != yld->copy.b[ix])
352 } while (++ix < sizeof(yld->master));
354 /* nothing todo, wait a bit and poll for a KEYPRESS */
356 /* TODO how can we wait abit. ??
357 * msleep_interruptible(1000 / YEALINK_POLLING_FREQUENCY);
363 /* Setup an appropriate update request */
364 yld->copy.b[ix] = val;
365 yld->ctl_data->data[0] = val;
368 case offsetof(struct yld_status, led):
369 yld->ctl_data->cmd = CMD_LED;
370 yld->ctl_data->sum = -1 - CMD_LED - val;
372 case offsetof(struct yld_status, dialtone):
373 yld->ctl_data->cmd = CMD_DIALTONE;
374 yld->ctl_data->sum = -1 - CMD_DIALTONE - val;
376 case offsetof(struct yld_status, ringtone):
377 yld->ctl_data->cmd = CMD_RINGTONE;
378 yld->ctl_data->sum = -1 - CMD_RINGTONE - val;
380 case offsetof(struct yld_status, keynum):
383 yld->ctl_data->cmd = CMD_SCANCODE;
384 yld->ctl_data->offset = cpu_to_be16(val);
385 yld->ctl_data->data[0] = 0;
386 yld->ctl_data->sum = -1 - CMD_SCANCODE - val;
389 len = sizeof(yld->master.s.lcd) - ix;
390 if (len > sizeof(yld->ctl_data->data))
391 len = sizeof(yld->ctl_data->data);
393 /* Combine up to <len> consecutive LCD bytes in a singe request
395 yld->ctl_data->cmd = CMD_LCD;
396 yld->ctl_data->offset = cpu_to_be16(ix);
397 yld->ctl_data->size = len;
398 yld->ctl_data->sum = -CMD_LCD - ix - val - len;
399 for(i=1; i<len; i++) {
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;
407 yld->stat_ix = ix + 1;
411 /* Decide on how to handle responses
413 * The state transition diagram is somethhing like:
419 * init --ok--> waitForKey --ok--> getKey
421 * | +-------ok-------+
425 static void urb_irq_callback(struct urb *urb)
427 struct yealink_dev *yld = urb->context;
428 int ret, status = urb->status;
431 dev_err(&yld->idev->dev, "%s - urb status %d\n",
434 switch (yld->irq_data->cmd) {
437 yld->master.s.keynum = yld->irq_data->data[0];
441 dbg("get scancode %x", yld->irq_data->data[0]);
443 report_key(yld, map_p1k_to_key(yld->irq_data->data[0]));
447 dev_err(&yld->idev->dev, "unexpected response %x\n",
451 yealink_do_idle_tasks(yld);
453 if (!yld->shutdown) {
454 ret = usb_submit_urb(yld->urb_ctl, GFP_ATOMIC);
455 if (ret && ret != -EPERM)
456 dev_err(&yld->idev->dev,
457 "%s - usb_submit_urb failed %d\n",
462 static void urb_ctl_callback(struct urb *urb)
464 struct yealink_dev *yld = urb->context;
465 int ret = 0, status = urb->status;
468 dev_err(&yld->idev->dev, "%s - urb status %d\n",
471 switch (yld->ctl_data->cmd) {
474 /* ask for a response */
476 ret = usb_submit_urb(yld->urb_irq, GFP_ATOMIC);
479 /* send new command */
480 yealink_do_idle_tasks(yld);
482 ret = usb_submit_urb(yld->urb_ctl, GFP_ATOMIC);
486 if (ret && ret != -EPERM)
487 dev_err(&yld->idev->dev, "%s - usb_submit_urb failed %d\n",
491 /*******************************************************************************
492 * input event interface
493 ******************************************************************************/
495 /* TODO should we issue a ringtone on a SND_BELL event?
496 static int input_ev(struct input_dev *dev, unsigned int type,
497 unsigned int code, int value)
515 static int input_open(struct input_dev *dev)
517 struct yealink_dev *yld = input_get_drvdata(dev);
522 /* force updates to device */
523 for (i = 0; i<sizeof(yld->master); i++)
524 yld->copy.b[i] = ~yld->master.b[i];
525 yld->key_code = -1; /* no keys pressed */
527 yealink_set_ringtone(yld, default_ringtone, sizeof(default_ringtone));
530 memset(yld->ctl_data, 0, sizeof(*(yld->ctl_data)));
531 yld->ctl_data->cmd = CMD_INIT;
532 yld->ctl_data->size = 10;
533 yld->ctl_data->sum = 0x100-CMD_INIT-10;
534 if ((ret = usb_submit_urb(yld->urb_ctl, GFP_KERNEL)) != 0) {
535 dbg("%s - usb_submit_urb failed with result %d",
542 static void input_close(struct input_dev *dev)
544 struct yealink_dev *yld = input_get_drvdata(dev);
548 * Make sure the flag is seen by other CPUs before we start
549 * killing URBs so new URBs won't be submitted
553 usb_kill_urb(yld->urb_ctl);
554 usb_kill_urb(yld->urb_irq);
560 /*******************************************************************************
562 ******************************************************************************/
564 static DECLARE_RWSEM(sysfs_rwsema);
566 /* Interface to the 7-segments translation table aka. char set.
568 static ssize_t show_map(struct device *dev, struct device_attribute *attr,
571 memcpy(buf, &map_seg7, sizeof(map_seg7));
572 return sizeof(map_seg7);
575 static ssize_t store_map(struct device *dev, struct device_attribute *attr,
576 const char *buf, size_t cnt)
578 if (cnt != sizeof(map_seg7))
580 memcpy(&map_seg7, buf, sizeof(map_seg7));
581 return sizeof(map_seg7);
584 /* Interface to the LCD.
587 /* Reading /sys/../lineX will return the format string with its settings:
594 static ssize_t show_line(struct device *dev, char *buf, int a, int b)
596 struct yealink_dev *yld;
599 down_read(&sysfs_rwsema);
600 yld = dev_get_drvdata(dev);
602 up_read(&sysfs_rwsema);
606 for (i = a; i < b; i++)
607 *buf++ = lcdMap[i].type;
609 for (i = a; i < b; i++)
610 *buf++ = yld->lcdMap[i];
614 up_read(&sysfs_rwsema);
615 return 3 + ((b - a) << 1);
618 static ssize_t show_line1(struct device *dev, struct device_attribute *attr,
621 return show_line(dev, buf, LCD_LINE1_OFFSET, LCD_LINE2_OFFSET);
624 static ssize_t show_line2(struct device *dev, struct device_attribute *attr,
627 return show_line(dev, buf, LCD_LINE2_OFFSET, LCD_LINE3_OFFSET);
630 static ssize_t show_line3(struct device *dev, struct device_attribute *attr,
633 return show_line(dev, buf, LCD_LINE3_OFFSET, LCD_LINE4_OFFSET);
636 /* Writing to /sys/../lineX will set the coresponding LCD line.
637 * - Excess characters are ignored.
638 * - If less characters are written than allowed, the remaining digits are
640 * - The '\n' or '\t' char is a placeholder, it does not overwrite the
643 static ssize_t store_line(struct device *dev, const char *buf, size_t count,
646 struct yealink_dev *yld;
649 down_write(&sysfs_rwsema);
650 yld = dev_get_drvdata(dev);
652 up_write(&sysfs_rwsema);
658 for (i = 0; i < len; i++)
659 setChar(yld, el++, buf[i]);
661 up_write(&sysfs_rwsema);
665 static ssize_t store_line1(struct device *dev, struct device_attribute *attr,
666 const char *buf, size_t count)
668 return store_line(dev, buf, count, LCD_LINE1_OFFSET, LCD_LINE1_SIZE);
671 static ssize_t store_line2(struct device *dev, struct device_attribute *attr,
672 const char *buf, size_t count)
674 return store_line(dev, buf, count, LCD_LINE2_OFFSET, LCD_LINE2_SIZE);
677 static ssize_t store_line3(struct device *dev, struct device_attribute *attr,
678 const char *buf, size_t count)
680 return store_line(dev, buf, count, LCD_LINE3_OFFSET, LCD_LINE3_SIZE);
683 /* Interface to visible and audible "icons", these include:
684 * pictures on the LCD, the LED, and the dialtone signal.
687 /* Get a list of "switchable elements" with their current state. */
688 static ssize_t get_icons(struct device *dev, struct device_attribute *attr,
691 struct yealink_dev *yld;
694 down_read(&sysfs_rwsema);
695 yld = dev_get_drvdata(dev);
697 up_read(&sysfs_rwsema);
701 for (i = 0; i < ARRAY_SIZE(lcdMap); i++) {
702 if (lcdMap[i].type != '.')
704 ret += sprintf(&buf[ret], "%s %s\n",
705 yld->lcdMap[i] == ' ' ? " " : "on",
708 up_read(&sysfs_rwsema);
712 /* Change the visibility of a particular element. */
713 static ssize_t set_icon(struct device *dev, const char *buf, size_t count,
716 struct yealink_dev *yld;
719 down_write(&sysfs_rwsema);
720 yld = dev_get_drvdata(dev);
722 up_write(&sysfs_rwsema);
726 for (i = 0; i < ARRAY_SIZE(lcdMap); i++) {
727 if (lcdMap[i].type != '.')
729 if (strncmp(buf, lcdMap[i].u.p.name, count) == 0) {
730 setChar(yld, i, chr);
735 up_write(&sysfs_rwsema);
739 static ssize_t show_icon(struct device *dev, struct device_attribute *attr,
740 const char *buf, size_t count)
742 return set_icon(dev, buf, count, buf[0]);
745 static ssize_t hide_icon(struct device *dev, struct device_attribute *attr,
746 const char *buf, size_t count)
748 return set_icon(dev, buf, count, ' ');
751 /* Upload a ringtone to the device.
754 /* Stores raw ringtone data in the phone */
755 static ssize_t store_ringtone(struct device *dev,
756 struct device_attribute *attr,
757 const char *buf, size_t count)
759 struct yealink_dev *yld;
761 down_write(&sysfs_rwsema);
762 yld = dev_get_drvdata(dev);
764 up_write(&sysfs_rwsema);
768 /* TODO locking with async usb control interface??? */
769 yealink_set_ringtone(yld, (char *)buf, count);
770 up_write(&sysfs_rwsema);
774 #define _M444 S_IRUGO
775 #define _M664 S_IRUGO|S_IWUSR|S_IWGRP
776 #define _M220 S_IWUSR|S_IWGRP
778 static DEVICE_ATTR(map_seg7 , _M664, show_map , store_map );
779 static DEVICE_ATTR(line1 , _M664, show_line1 , store_line1 );
780 static DEVICE_ATTR(line2 , _M664, show_line2 , store_line2 );
781 static DEVICE_ATTR(line3 , _M664, show_line3 , store_line3 );
782 static DEVICE_ATTR(get_icons , _M444, get_icons , NULL );
783 static DEVICE_ATTR(show_icon , _M220, NULL , show_icon );
784 static DEVICE_ATTR(hide_icon , _M220, NULL , hide_icon );
785 static DEVICE_ATTR(ringtone , _M220, NULL , store_ringtone);
787 static struct attribute *yld_attributes[] = {
788 &dev_attr_line1.attr,
789 &dev_attr_line2.attr,
790 &dev_attr_line3.attr,
791 &dev_attr_get_icons.attr,
792 &dev_attr_show_icon.attr,
793 &dev_attr_hide_icon.attr,
794 &dev_attr_map_seg7.attr,
795 &dev_attr_ringtone.attr,
799 static struct attribute_group yld_attr_group = {
800 .attrs = yld_attributes
803 /*******************************************************************************
804 * Linux interface and usb initialisation
805 ******************************************************************************/
811 static const struct driver_info info_P1K = {
812 .name = "Yealink usb-p1k",
815 static const struct usb_device_id usb_table [] = {
817 .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
818 USB_DEVICE_ID_MATCH_INT_INFO,
821 .bInterfaceClass = USB_CLASS_HID,
822 .bInterfaceSubClass = 0,
823 .bInterfaceProtocol = 0,
824 .driver_info = (kernel_ulong_t)&info_P1K
829 static int usb_cleanup(struct yealink_dev *yld, int err)
836 input_free_device(yld->idev);
838 input_unregister_device(yld->idev);
841 usb_free_urb(yld->urb_irq);
842 usb_free_urb(yld->urb_ctl);
845 usb_free_coherent(yld->udev, USB_PKT_LEN, yld->ctl_data, yld->ctl_dma);
846 usb_free_coherent(yld->udev, USB_PKT_LEN, yld->irq_data, yld->irq_dma);
852 static void usb_disconnect(struct usb_interface *intf)
854 struct yealink_dev *yld;
856 down_write(&sysfs_rwsema);
857 yld = usb_get_intfdata(intf);
858 sysfs_remove_group(&intf->dev.kobj, &yld_attr_group);
859 usb_set_intfdata(intf, NULL);
860 up_write(&sysfs_rwsema);
865 static int usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
867 struct usb_device *udev = interface_to_usbdev (intf);
868 struct driver_info *nfo = (struct driver_info *)id->driver_info;
869 struct usb_host_interface *interface;
870 struct usb_endpoint_descriptor *endpoint;
871 struct yealink_dev *yld;
872 struct input_dev *input_dev;
875 interface = intf->cur_altsetting;
876 endpoint = &interface->endpoint[0].desc;
877 if (!usb_endpoint_is_int_in(endpoint))
880 yld = kzalloc(sizeof(struct yealink_dev), GFP_KERNEL);
886 yld->idev = input_dev = input_allocate_device();
888 return usb_cleanup(yld, -ENOMEM);
890 /* allocate usb buffers */
891 yld->irq_data = usb_alloc_coherent(udev, USB_PKT_LEN,
892 GFP_ATOMIC, &yld->irq_dma);
893 if (yld->irq_data == NULL)
894 return usb_cleanup(yld, -ENOMEM);
896 yld->ctl_data = usb_alloc_coherent(udev, USB_PKT_LEN,
897 GFP_ATOMIC, &yld->ctl_dma);
899 return usb_cleanup(yld, -ENOMEM);
901 yld->ctl_req = kmalloc(sizeof(*(yld->ctl_req)), GFP_KERNEL);
902 if (yld->ctl_req == NULL)
903 return usb_cleanup(yld, -ENOMEM);
905 /* allocate urb structures */
906 yld->urb_irq = usb_alloc_urb(0, GFP_KERNEL);
907 if (yld->urb_irq == NULL)
908 return usb_cleanup(yld, -ENOMEM);
910 yld->urb_ctl = usb_alloc_urb(0, GFP_KERNEL);
911 if (yld->urb_ctl == NULL)
912 return usb_cleanup(yld, -ENOMEM);
914 /* get a handle to the interrupt data pipe */
915 pipe = usb_rcvintpipe(udev, endpoint->bEndpointAddress);
916 ret = usb_maxpacket(udev, pipe, usb_pipeout(pipe));
917 if (ret != USB_PKT_LEN)
918 dev_err(&intf->dev, "invalid payload size %d, expected %zd\n",
921 /* initialise irq urb */
922 usb_fill_int_urb(yld->urb_irq, udev, pipe, yld->irq_data,
925 yld, endpoint->bInterval);
926 yld->urb_irq->transfer_dma = yld->irq_dma;
927 yld->urb_irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
928 yld->urb_irq->dev = udev;
930 /* initialise ctl urb */
931 yld->ctl_req->bRequestType = USB_TYPE_CLASS | USB_RECIP_INTERFACE |
933 yld->ctl_req->bRequest = USB_REQ_SET_CONFIGURATION;
934 yld->ctl_req->wValue = cpu_to_le16(0x200);
935 yld->ctl_req->wIndex = cpu_to_le16(interface->desc.bInterfaceNumber);
936 yld->ctl_req->wLength = cpu_to_le16(USB_PKT_LEN);
938 usb_fill_control_urb(yld->urb_ctl, udev, usb_sndctrlpipe(udev, 0),
939 (void *)yld->ctl_req, yld->ctl_data, USB_PKT_LEN,
940 urb_ctl_callback, yld);
941 yld->urb_ctl->transfer_dma = yld->ctl_dma;
942 yld->urb_ctl->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
943 yld->urb_ctl->dev = udev;
945 /* find out the physical bus location */
946 usb_make_path(udev, yld->phys, sizeof(yld->phys));
947 strlcat(yld->phys, "/input0", sizeof(yld->phys));
949 /* register settings for the input device */
950 input_dev->name = nfo->name;
951 input_dev->phys = yld->phys;
952 usb_to_input_id(udev, &input_dev->id);
953 input_dev->dev.parent = &intf->dev;
955 input_set_drvdata(input_dev, yld);
957 input_dev->open = input_open;
958 input_dev->close = input_close;
959 /* input_dev->event = input_ev; TODO */
961 /* register available key events */
962 input_dev->evbit[0] = BIT_MASK(EV_KEY);
963 for (i = 0; i < 256; i++) {
964 int k = map_p1k_to_key(i);
966 set_bit(k & 0xff, input_dev->keybit);
968 set_bit(k >> 8, input_dev->keybit);
972 ret = input_register_device(yld->idev);
974 return usb_cleanup(yld, ret);
976 usb_set_intfdata(intf, yld);
978 /* clear visible elements */
979 for (i = 0; i < ARRAY_SIZE(lcdMap); i++)
980 setChar(yld, i, ' ');
982 /* display driver version on LCD line 3 */
983 store_line3(&intf->dev, NULL,
984 DRIVER_VERSION, sizeof(DRIVER_VERSION));
986 /* Register sysfs hooks (don't care about failure) */
987 ret = sysfs_create_group(&intf->dev.kobj, &yld_attr_group);
991 static struct usb_driver yealink_driver = {
994 .disconnect = usb_disconnect,
995 .id_table = usb_table,
998 module_usb_driver(yealink_driver);
1000 MODULE_DEVICE_TABLE (usb, usb_table);
1002 MODULE_AUTHOR(DRIVER_AUTHOR);
1003 MODULE_DESCRIPTION(DRIVER_DESC);
1004 MODULE_LICENSE("GPL");