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