drivers/input/misc/yealink.c

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