drivers/usb/input/yealink.c

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