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