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/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]; 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 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 105 /* irq input channel */ 106 struct yld_ctl_packet *irq_data; 107 dma_addr_t irq_dma; 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 struct urb *urb_ctl; 115 116 char phys[64]; /* physical device path */ 117 118 u8 lcdMap[ARRAY_SIZE(lcdMap)]; /* state of LCD, LED ... */ 119 int key_code; /* last reported key */ 120 121 unsigned int shutdown:1; 122 123 int stat_ix; 124 union { 125 struct yld_status s; 126 u8 b[sizeof(struct yld_status)]; 127 } master, copy; 128 }; 129 130 131 /******************************************************************************* 132 * Yealink lcd interface 133 ******************************************************************************/ 134 135 /* 136 * Register a default 7 segment character set 137 */ 138 static SEG7_DEFAULT_MAP(map_seg7); 139 140 /* Display a char, 141 * char '\9' and '\n' are placeholders and do not overwrite the original text. 142 * A space will always hide an icon. 143 */ 144 static int setChar(struct yealink_dev *yld, int el, int chr) 145 { 146 int i, a, m, val; 147 148 if (el >= ARRAY_SIZE(lcdMap)) 149 return -EINVAL; 150 151 if (chr == '\t' || chr == '\n') 152 return 0; 153 154 yld->lcdMap[el] = chr; 155 156 if (lcdMap[el].type == '.') { 157 a = lcdMap[el].u.p.a; 158 m = lcdMap[el].u.p.m; 159 if (chr != ' ') 160 yld->master.b[a] |= m; 161 else 162 yld->master.b[a] &= ~m; 163 return 0; 164 } 165 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; 169 170 if (m == 0) 171 continue; 172 173 a = lcdMap[el].u.s[i].a; 174 if (val & 1) 175 yld->master.b[a] |= m; 176 else 177 yld->master.b[a] &= ~m; 178 val = val >> 1; 179 } 180 return 0; 181 }; 182 183 /******************************************************************************* 184 * Yealink key interface 185 ******************************************************************************/ 186 187 /* Map device buttons to internal key events. 188 * 189 * USB-P1K button layout: 190 * 191 * up 192 * IN OUT 193 * down 194 * 195 * pickup C hangup 196 * 1 2 3 197 * 4 5 6 198 * 7 8 9 199 * * 0 # 200 * 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 203 * on the button. 204 */ 205 static int map_p1k_to_key(int scancode) 206 { 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 | 227 KEY_3 << 8; /* # */ 228 } 229 return -EINVAL; 230 } 231 232 /* Completes a request by converting the data into events for the 233 * input subsystem. 234 * 235 * The key parameter can be cascaded: key2 << 8 | key1 236 */ 237 static void report_key(struct yealink_dev *yld, int key) 238 { 239 struct input_dev *idev = yld->idev; 240 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 262 static 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 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 */ 292 }; 293 294 static 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; 319 p->offset = cpu_to_be16(ix); 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 */ 329 static 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 361 send_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; 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; 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; 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++) { 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 */ 425 static void urb_irq_callback(struct urb *urb) 426 { 427 struct yealink_dev *yld = urb->context; 428 int ret, status = urb->status; 429 430 if (status) 431 err("%s - urb status %d", __func__, 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])); 443 break; 444 445 default: 446 err("unexpected response %x", yld->irq_data->cmd); 447 } 448 449 yealink_do_idle_tasks(yld); 450 451 if (!yld->shutdown) { 452 ret = usb_submit_urb(yld->urb_ctl, GFP_ATOMIC); 453 if (ret && ret != -EPERM) 454 err("%s - usb_submit_urb failed %d", __func__, ret); 455 } 456 } 457 458 static void urb_ctl_callback(struct urb *urb) 459 { 460 struct yealink_dev *yld = urb->context; 461 int ret = 0, status = urb->status; 462 463 if (status) 464 err("%s - urb status %d", __func__, status); 465 466 switch (yld->ctl_data->cmd) { 467 case CMD_KEYPRESS: 468 case CMD_SCANCODE: 469 /* ask for a response */ 470 if (!yld->shutdown) 471 ret = usb_submit_urb(yld->urb_irq, GFP_ATOMIC); 472 break; 473 default: 474 /* send new command */ 475 yealink_do_idle_tasks(yld); 476 if (!yld->shutdown) 477 ret = usb_submit_urb(yld->urb_ctl, GFP_ATOMIC); 478 break; 479 } 480 481 if (ret && ret != -EPERM) 482 err("%s - usb_submit_urb failed %d", __func__, ret); 483 } 484 485 /******************************************************************************* 486 * input event interface 487 ******************************************************************************/ 488 489 /* TODO should we issue a ringtone on a SND_BELL event? 490 static int input_ev(struct input_dev *dev, unsigned int type, 491 unsigned int code, int value) 492 { 493 494 if (type != EV_SND) 495 return -EINVAL; 496 497 switch (code) { 498 case SND_BELL: 499 case SND_TONE: 500 break; 501 default: 502 return -EINVAL; 503 } 504 505 return 0; 506 } 507 */ 508 509 static int input_open(struct input_dev *dev) 510 { 511 struct yealink_dev *yld = input_get_drvdata(dev); 512 int i, ret; 513 514 dbg("%s", __func__); 515 516 /* force updates to device */ 517 for (i = 0; i<sizeof(yld->master); i++) 518 yld->copy.b[i] = ~yld->master.b[i]; 519 yld->key_code = -1; /* no keys pressed */ 520 521 yealink_set_ringtone(yld, default_ringtone, sizeof(default_ringtone)); 522 523 /* issue INIT */ 524 memset(yld->ctl_data, 0, sizeof(*(yld->ctl_data))); 525 yld->ctl_data->cmd = CMD_INIT; 526 yld->ctl_data->size = 10; 527 yld->ctl_data->sum = 0x100-CMD_INIT-10; 528 if ((ret = usb_submit_urb(yld->urb_ctl, GFP_KERNEL)) != 0) { 529 dbg("%s - usb_submit_urb failed with result %d", 530 __func__, ret); 531 return ret; 532 } 533 return 0; 534 } 535 536 static void input_close(struct input_dev *dev) 537 { 538 struct yealink_dev *yld = input_get_drvdata(dev); 539 540 yld->shutdown = 1; 541 /* 542 * Make sure the flag is seen by other CPUs before we start 543 * killing URBs so new URBs won't be submitted 544 */ 545 smp_wmb(); 546 547 usb_kill_urb(yld->urb_ctl); 548 usb_kill_urb(yld->urb_irq); 549 550 yld->shutdown = 0; 551 smp_wmb(); 552 } 553 554 /******************************************************************************* 555 * sysfs interface 556 ******************************************************************************/ 557 558 static DECLARE_RWSEM(sysfs_rwsema); 559 560 /* Interface to the 7-segments translation table aka. char set. 561 */ 562 static ssize_t show_map(struct device *dev, struct device_attribute *attr, 563 char *buf) 564 { 565 memcpy(buf, &map_seg7, sizeof(map_seg7)); 566 return sizeof(map_seg7); 567 } 568 569 static ssize_t store_map(struct device *dev, struct device_attribute *attr, 570 const char *buf, size_t cnt) 571 { 572 if (cnt != sizeof(map_seg7)) 573 return -EINVAL; 574 memcpy(&map_seg7, buf, sizeof(map_seg7)); 575 return sizeof(map_seg7); 576 } 577 578 /* Interface to the LCD. 579 */ 580 581 /* Reading /sys/../lineX will return the format string with its settings: 582 * 583 * Example: 584 * cat ./line3 585 * 888888888888 586 * Linux Rocks! 587 */ 588 static ssize_t show_line(struct device *dev, char *buf, int a, int b) 589 { 590 struct yealink_dev *yld; 591 int i; 592 593 down_read(&sysfs_rwsema); 594 yld = dev_get_drvdata(dev); 595 if (yld == NULL) { 596 up_read(&sysfs_rwsema); 597 return -ENODEV; 598 } 599 600 for (i = a; i < b; i++) 601 *buf++ = lcdMap[i].type; 602 *buf++ = '\n'; 603 for (i = a; i < b; i++) 604 *buf++ = yld->lcdMap[i]; 605 *buf++ = '\n'; 606 *buf = 0; 607 608 up_read(&sysfs_rwsema); 609 return 3 + ((b - a) << 1); 610 } 611 612 static ssize_t show_line1(struct device *dev, struct device_attribute *attr, 613 char *buf) 614 { 615 return show_line(dev, buf, LCD_LINE1_OFFSET, LCD_LINE2_OFFSET); 616 } 617 618 static ssize_t show_line2(struct device *dev, struct device_attribute *attr, 619 char *buf) 620 { 621 return show_line(dev, buf, LCD_LINE2_OFFSET, LCD_LINE3_OFFSET); 622 } 623 624 static ssize_t show_line3(struct device *dev, struct device_attribute *attr, 625 char *buf) 626 { 627 return show_line(dev, buf, LCD_LINE3_OFFSET, LCD_LINE4_OFFSET); 628 } 629 630 /* Writing to /sys/../lineX will set the coresponding LCD line. 631 * - Excess characters are ignored. 632 * - If less characters are written than allowed, the remaining digits are 633 * unchanged. 634 * - The '\n' or '\t' char is a placeholder, it does not overwrite the 635 * original content. 636 */ 637 static ssize_t store_line(struct device *dev, const char *buf, size_t count, 638 int el, size_t len) 639 { 640 struct yealink_dev *yld; 641 int i; 642 643 down_write(&sysfs_rwsema); 644 yld = dev_get_drvdata(dev); 645 if (yld == NULL) { 646 up_write(&sysfs_rwsema); 647 return -ENODEV; 648 } 649 650 if (len > count) 651 len = count; 652 for (i = 0; i < len; i++) 653 setChar(yld, el++, buf[i]); 654 655 up_write(&sysfs_rwsema); 656 return count; 657 } 658 659 static ssize_t store_line1(struct device *dev, struct device_attribute *attr, 660 const char *buf, size_t count) 661 { 662 return store_line(dev, buf, count, LCD_LINE1_OFFSET, LCD_LINE1_SIZE); 663 } 664 665 static ssize_t store_line2(struct device *dev, struct device_attribute *attr, 666 const char *buf, size_t count) 667 { 668 return store_line(dev, buf, count, LCD_LINE2_OFFSET, LCD_LINE2_SIZE); 669 } 670 671 static ssize_t store_line3(struct device *dev, struct device_attribute *attr, 672 const char *buf, size_t count) 673 { 674 return store_line(dev, buf, count, LCD_LINE3_OFFSET, LCD_LINE3_SIZE); 675 } 676 677 /* Interface to visible and audible "icons", these include: 678 * pictures on the LCD, the LED, and the dialtone signal. 679 */ 680 681 /* Get a list of "switchable elements" with their current state. */ 682 static ssize_t get_icons(struct device *dev, struct device_attribute *attr, 683 char *buf) 684 { 685 struct yealink_dev *yld; 686 int i, ret = 1; 687 688 down_read(&sysfs_rwsema); 689 yld = dev_get_drvdata(dev); 690 if (yld == NULL) { 691 up_read(&sysfs_rwsema); 692 return -ENODEV; 693 } 694 695 for (i = 0; i < ARRAY_SIZE(lcdMap); i++) { 696 if (lcdMap[i].type != '.') 697 continue; 698 ret += sprintf(&buf[ret], "%s %s\n", 699 yld->lcdMap[i] == ' ' ? " " : "on", 700 lcdMap[i].u.p.name); 701 } 702 up_read(&sysfs_rwsema); 703 return ret; 704 } 705 706 /* Change the visibility of a particular element. */ 707 static ssize_t set_icon(struct device *dev, const char *buf, size_t count, 708 int chr) 709 { 710 struct yealink_dev *yld; 711 int i; 712 713 down_write(&sysfs_rwsema); 714 yld = dev_get_drvdata(dev); 715 if (yld == NULL) { 716 up_write(&sysfs_rwsema); 717 return -ENODEV; 718 } 719 720 for (i = 0; i < ARRAY_SIZE(lcdMap); i++) { 721 if (lcdMap[i].type != '.') 722 continue; 723 if (strncmp(buf, lcdMap[i].u.p.name, count) == 0) { 724 setChar(yld, i, chr); 725 break; 726 } 727 } 728 729 up_write(&sysfs_rwsema); 730 return count; 731 } 732 733 static ssize_t show_icon(struct device *dev, struct device_attribute *attr, 734 const char *buf, size_t count) 735 { 736 return set_icon(dev, buf, count, buf[0]); 737 } 738 739 static ssize_t hide_icon(struct device *dev, struct device_attribute *attr, 740 const char *buf, size_t count) 741 { 742 return set_icon(dev, buf, count, ' '); 743 } 744 745 /* Upload a ringtone to the device. 746 */ 747 748 /* Stores raw ringtone data in the phone */ 749 static ssize_t store_ringtone(struct device *dev, 750 struct device_attribute *attr, 751 const char *buf, size_t count) 752 { 753 struct yealink_dev *yld; 754 755 down_write(&sysfs_rwsema); 756 yld = dev_get_drvdata(dev); 757 if (yld == NULL) { 758 up_write(&sysfs_rwsema); 759 return -ENODEV; 760 } 761 762 /* TODO locking with async usb control interface??? */ 763 yealink_set_ringtone(yld, (char *)buf, count); 764 up_write(&sysfs_rwsema); 765 return count; 766 } 767 768 #define _M444 S_IRUGO 769 #define _M664 S_IRUGO|S_IWUSR|S_IWGRP 770 #define _M220 S_IWUSR|S_IWGRP 771 772 static DEVICE_ATTR(map_seg7 , _M664, show_map , store_map ); 773 static DEVICE_ATTR(line1 , _M664, show_line1 , store_line1 ); 774 static DEVICE_ATTR(line2 , _M664, show_line2 , store_line2 ); 775 static DEVICE_ATTR(line3 , _M664, show_line3 , store_line3 ); 776 static DEVICE_ATTR(get_icons , _M444, get_icons , NULL ); 777 static DEVICE_ATTR(show_icon , _M220, NULL , show_icon ); 778 static DEVICE_ATTR(hide_icon , _M220, NULL , hide_icon ); 779 static DEVICE_ATTR(ringtone , _M220, NULL , store_ringtone); 780 781 static struct attribute *yld_attributes[] = { 782 &dev_attr_line1.attr, 783 &dev_attr_line2.attr, 784 &dev_attr_line3.attr, 785 &dev_attr_get_icons.attr, 786 &dev_attr_show_icon.attr, 787 &dev_attr_hide_icon.attr, 788 &dev_attr_map_seg7.attr, 789 &dev_attr_ringtone.attr, 790 NULL 791 }; 792 793 static struct attribute_group yld_attr_group = { 794 .attrs = yld_attributes 795 }; 796 797 /******************************************************************************* 798 * Linux interface and usb initialisation 799 ******************************************************************************/ 800 801 struct driver_info { 802 char *name; 803 }; 804 805 static const struct driver_info info_P1K = { 806 .name = "Yealink usb-p1k", 807 }; 808 809 static const struct usb_device_id usb_table [] = { 810 { 811 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 812 USB_DEVICE_ID_MATCH_INT_INFO, 813 .idVendor = 0x6993, 814 .idProduct = 0xb001, 815 .bInterfaceClass = USB_CLASS_HID, 816 .bInterfaceSubClass = 0, 817 .bInterfaceProtocol = 0, 818 .driver_info = (kernel_ulong_t)&info_P1K 819 }, 820 { } 821 }; 822 823 static int usb_cleanup(struct yealink_dev *yld, int err) 824 { 825 if (yld == NULL) 826 return err; 827 828 if (yld->idev) { 829 if (err) 830 input_free_device(yld->idev); 831 else 832 input_unregister_device(yld->idev); 833 } 834 835 usb_free_urb(yld->urb_irq); 836 usb_free_urb(yld->urb_ctl); 837 838 kfree(yld->ctl_req); 839 usb_buffer_free(yld->udev, USB_PKT_LEN, 840 yld->ctl_data, yld->ctl_dma); 841 usb_buffer_free(yld->udev, USB_PKT_LEN, 842 yld->irq_data, yld->irq_dma); 843 844 kfree(yld); 845 return err; 846 } 847 848 static void usb_disconnect(struct usb_interface *intf) 849 { 850 struct yealink_dev *yld; 851 852 down_write(&sysfs_rwsema); 853 yld = usb_get_intfdata(intf); 854 sysfs_remove_group(&intf->dev.kobj, &yld_attr_group); 855 usb_set_intfdata(intf, NULL); 856 up_write(&sysfs_rwsema); 857 858 usb_cleanup(yld, 0); 859 } 860 861 static int usb_probe(struct usb_interface *intf, const struct usb_device_id *id) 862 { 863 struct usb_device *udev = interface_to_usbdev (intf); 864 struct driver_info *nfo = (struct driver_info *)id->driver_info; 865 struct usb_host_interface *interface; 866 struct usb_endpoint_descriptor *endpoint; 867 struct yealink_dev *yld; 868 struct input_dev *input_dev; 869 int ret, pipe, i; 870 871 interface = intf->cur_altsetting; 872 endpoint = &interface->endpoint[0].desc; 873 if (!usb_endpoint_is_int_in(endpoint)) 874 return -ENODEV; 875 876 yld = kzalloc(sizeof(struct yealink_dev), GFP_KERNEL); 877 if (!yld) 878 return -ENOMEM; 879 880 yld->udev = udev; 881 882 yld->idev = input_dev = input_allocate_device(); 883 if (!input_dev) 884 return usb_cleanup(yld, -ENOMEM); 885 886 /* allocate usb buffers */ 887 yld->irq_data = usb_buffer_alloc(udev, USB_PKT_LEN, 888 GFP_ATOMIC, &yld->irq_dma); 889 if (yld->irq_data == NULL) 890 return usb_cleanup(yld, -ENOMEM); 891 892 yld->ctl_data = usb_buffer_alloc(udev, USB_PKT_LEN, 893 GFP_ATOMIC, &yld->ctl_dma); 894 if (!yld->ctl_data) 895 return usb_cleanup(yld, -ENOMEM); 896 897 yld->ctl_req = kmalloc(sizeof(*(yld->ctl_req)), GFP_KERNEL); 898 if (yld->ctl_req == NULL) 899 return usb_cleanup(yld, -ENOMEM); 900 901 /* allocate urb structures */ 902 yld->urb_irq = usb_alloc_urb(0, GFP_KERNEL); 903 if (yld->urb_irq == NULL) 904 return usb_cleanup(yld, -ENOMEM); 905 906 yld->urb_ctl = usb_alloc_urb(0, GFP_KERNEL); 907 if (yld->urb_ctl == NULL) 908 return usb_cleanup(yld, -ENOMEM); 909 910 /* get a handle to the interrupt data pipe */ 911 pipe = usb_rcvintpipe(udev, endpoint->bEndpointAddress); 912 ret = usb_maxpacket(udev, pipe, usb_pipeout(pipe)); 913 if (ret != USB_PKT_LEN) 914 err("invalid payload size %d, expected %zd", ret, USB_PKT_LEN); 915 916 /* initialise irq urb */ 917 usb_fill_int_urb(yld->urb_irq, udev, pipe, yld->irq_data, 918 USB_PKT_LEN, 919 urb_irq_callback, 920 yld, endpoint->bInterval); 921 yld->urb_irq->transfer_dma = yld->irq_dma; 922 yld->urb_irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 923 yld->urb_irq->dev = udev; 924 925 /* initialise ctl urb */ 926 yld->ctl_req->bRequestType = USB_TYPE_CLASS | USB_RECIP_INTERFACE | 927 USB_DIR_OUT; 928 yld->ctl_req->bRequest = USB_REQ_SET_CONFIGURATION; 929 yld->ctl_req->wValue = cpu_to_le16(0x200); 930 yld->ctl_req->wIndex = cpu_to_le16(interface->desc.bInterfaceNumber); 931 yld->ctl_req->wLength = cpu_to_le16(USB_PKT_LEN); 932 933 usb_fill_control_urb(yld->urb_ctl, udev, usb_sndctrlpipe(udev, 0), 934 (void *)yld->ctl_req, yld->ctl_data, USB_PKT_LEN, 935 urb_ctl_callback, yld); 936 yld->urb_ctl->transfer_dma = yld->ctl_dma; 937 yld->urb_ctl->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 938 yld->urb_ctl->dev = udev; 939 940 /* find out the physical bus location */ 941 usb_make_path(udev, yld->phys, sizeof(yld->phys)); 942 strlcat(yld->phys, "/input0", sizeof(yld->phys)); 943 944 /* register settings for the input device */ 945 input_dev->name = nfo->name; 946 input_dev->phys = yld->phys; 947 usb_to_input_id(udev, &input_dev->id); 948 input_dev->dev.parent = &intf->dev; 949 950 input_set_drvdata(input_dev, yld); 951 952 input_dev->open = input_open; 953 input_dev->close = input_close; 954 /* input_dev->event = input_ev; TODO */ 955 956 /* register available key events */ 957 input_dev->evbit[0] = BIT_MASK(EV_KEY); 958 for (i = 0; i < 256; i++) { 959 int k = map_p1k_to_key(i); 960 if (k >= 0) { 961 set_bit(k & 0xff, input_dev->keybit); 962 if (k >> 8) 963 set_bit(k >> 8, input_dev->keybit); 964 } 965 } 966 967 ret = input_register_device(yld->idev); 968 if (ret) 969 return usb_cleanup(yld, ret); 970 971 usb_set_intfdata(intf, yld); 972 973 /* clear visible elements */ 974 for (i = 0; i < ARRAY_SIZE(lcdMap); i++) 975 setChar(yld, i, ' '); 976 977 /* display driver version on LCD line 3 */ 978 store_line3(&intf->dev, NULL, 979 DRIVER_VERSION, sizeof(DRIVER_VERSION)); 980 981 /* Register sysfs hooks (don't care about failure) */ 982 ret = sysfs_create_group(&intf->dev.kobj, &yld_attr_group); 983 return 0; 984 } 985 986 static struct usb_driver yealink_driver = { 987 .name = "yealink", 988 .probe = usb_probe, 989 .disconnect = usb_disconnect, 990 .id_table = usb_table, 991 }; 992 993 static int __init yealink_dev_init(void) 994 { 995 int ret = usb_register(&yealink_driver); 996 if (ret == 0) 997 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 998 DRIVER_DESC "\n"); 999 return ret; 1000 } 1001 1002 static void __exit yealink_dev_exit(void) 1003 { 1004 usb_deregister(&yealink_driver); 1005 } 1006 1007 module_init(yealink_dev_init); 1008 module_exit(yealink_dev_exit); 1009 1010 MODULE_DEVICE_TABLE (usb, usb_table); 1011 1012 MODULE_AUTHOR(DRIVER_AUTHOR); 1013 MODULE_DESCRIPTION(DRIVER_DESC); 1014 MODULE_LICENSE("GPL"); 1015