yealink.c

Go to the documentation of this file.

/*
 * drivers/usb/input/yealink.c
 *
 * Copyright (c) 2005 Henk Vergonet <[email protected]>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of
 * the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
/*
 * Description:
 *   Driver for the USB-P1K voip usb phone.
 *   This device is produced by Yealink Network Technology Co Ltd
 *   but may be branded under several names:
 *  - Yealink usb-p1k
 *  - Tiptel 115
 *  - ...
 *
 * This driver is based on:
 *   - the usbb2k-api   http://savannah.nongnu.org/projects/usbb2k-api/
 *   - information from http://memeteau.free.fr/usbb2k
 *   - the xpad-driver  drivers/input/joystick/xpad.c
 *
 * Thanks to:
 *   - Olivier Vandorpe, for providing the usbb2k-api.
 *   - Martin Diehl, for spotting my memory allocation bug.
 *
 * History:
 *   20050527 henk  First version, functional keyboard. Keyboard events
 *          will pop-up on the ../input/eventX bus.
 *   20050531 henk  Added led, LCD, dialtone and sysfs interface.
 *   20050610 henk  Cleanups, make it ready for public consumption.
 *   20050630 henk  Cleanups, fixes in response to comments.
 *   20050701 henk  sysfs write serialisation, fix potential unload races
 *   20050801 henk  Added ringtone, restructure USB
 *   20050816 henk  Merge 2.6.13-rc6
 */

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/rwsem.h>
#include <linux/usb/input.h>
#include <linux/map_to_7segment.h>

#include "yealink.h"

#define DRIVER_VERSION "yld-20051230"
#define DRIVER_AUTHOR "Henk Vergonet"
#define DRIVER_DESC "Yealink phone driver"

#define YEALINK_POLLING_FREQUENCY   10  /* in [Hz] */

struct yld_status {
    u8  lcd[24];
    u8  led;
    u8  dialtone;
    u8  ringtone;
    u8  keynum;
} __attribute__ ((packed));

/*
 * Register the LCD segment and icon map
 */
#define _LOC(k,l)   { .a = (k), .m = (l) }
#define _SEG(t, a, am, b, bm, c, cm, d, dm, e, em, f, fm, g, gm)    \
    { .type = (t),                          \
      .u = { .s = { _LOC(a, am), _LOC(b, bm), _LOC(c, cm),      \
                _LOC(d, dm), _LOC(e, em), _LOC(g, gm),      \
            _LOC(f, fm) } } }
#define _PIC(t, h, hm, n)                       \
    { .type = (t),                          \
      .u = { .p = { .name = (n), .a = (h), .m = (hm) } } }

static const struct lcd_segment_map {
    char    type;
    union {
        struct pictogram_map {
            u8  a,m;
            char    name[10];
        }   p;
        struct segment_map {
            u8  a,m;
        } s[7];
    } u;
} lcdMap[] = {
#include "yealink.h"
};

struct yealink_dev {
    struct input_dev *idev;     /* input device */
    struct usb_device *udev;    /* usb device */
    struct usb_interface *intf; /* usb interface */

    /* irq input channel */
    struct yld_ctl_packet   *irq_data;
    dma_addr_t      irq_dma;
    struct urb      *urb_irq;

    /* control output channel */
    struct yld_ctl_packet   *ctl_data;
    dma_addr_t      ctl_dma;
    struct usb_ctrlrequest  *ctl_req;
    struct urb      *urb_ctl;

    char phys[64];          /* physical device path */

    u8 lcdMap[ARRAY_SIZE(lcdMap)];  /* state of LCD, LED ... */
    int key_code;           /* last reported key     */

    unsigned int shutdown:1;

    int stat_ix;
    union {
        struct yld_status s;
        u8        b[sizeof(struct yld_status)];
    } master, copy;
};


/*******************************************************************************
 * Yealink lcd interface
 ******************************************************************************/

/*
 * Register a default 7 segment character set
 */
static SEG7_DEFAULT_MAP(map_seg7);

 /* Display a char,
  * char '\9' and '\n' are placeholders and do not overwrite the original text.
  * A space will always hide an icon.
  */
static int setChar(struct yealink_dev *yld, int el, int chr)
{
    int i, a, m, val;

    if (el >= ARRAY_SIZE(lcdMap))
        return -EINVAL;

    if (chr == '\t' || chr == '\n')
        return 0;

    yld->lcdMap[el] = chr;

    if (lcdMap[el].type == '.') {
        a = lcdMap[el].u.p.a;
        m = lcdMap[el].u.p.m;
        if (chr != ' ')
            yld->master.b[a] |= m;
        else
            yld->master.b[a] &= ~m;
        return 0;
    }

    val = map_to_seg7(&map_seg7, chr);
    for (i = 0; i < ARRAY_SIZE(lcdMap[0].u.s); i++) {
        m = lcdMap[el].u.s[i].m;

        if (m == 0)
            continue;

        a = lcdMap[el].u.s[i].a;
        if (val & 1)
            yld->master.b[a] |= m;
        else
            yld->master.b[a] &= ~m;
        val = val >> 1;
    }
    return 0;
};

/*******************************************************************************
 * Yealink key interface
 ******************************************************************************/

/* Map device buttons to internal key events.
 *
 * USB-P1K button layout:
 *
 *             up
 *       IN           OUT
 *            down
 *
 *     pickup   C    hangup
 *       1      2      3
 *       4      5      6
 *       7      8      9
 *       *      0      #
 *
 * The "up" and "down" keys, are symbolised by arrows on the button.
 * The "pickup" and "hangup" keys are symbolised by a green and red phone
 * on the button.
 */
static int map_p1k_to_key(int scancode)
{
    switch(scancode) {      /* phone key:   */
    case 0x23: return KEY_LEFT; /*   IN     */
    case 0x33: return KEY_UP;   /*   up     */
    case 0x04: return KEY_RIGHT;    /*   OUT    */
    case 0x24: return KEY_DOWN; /*   down   */
    case 0x03: return KEY_ENTER;    /*   pickup */
    case 0x14: return KEY_BACKSPACE; /*  C      */
    case 0x13: return KEY_ESC;  /*   hangup */
    case 0x00: return KEY_1;    /*   1      */
    case 0x01: return KEY_2;    /*   2      */
    case 0x02: return KEY_3;    /*   3      */
    case 0x10: return KEY_4;    /*   4      */
    case 0x11: return KEY_5;    /*   5      */
    case 0x12: return KEY_6;    /*   6      */
    case 0x20: return KEY_7;    /*   7      */
    case 0x21: return KEY_8;    /*   8      */
    case 0x22: return KEY_9;    /*   9      */
    case 0x30: return KEY_KPASTERISK; /* *      */
    case 0x31: return KEY_0;    /*   0      */
    case 0x32: return KEY_LEFTSHIFT |
              KEY_3 << 8;   /*   #      */
    }
    return -EINVAL;
}

/* Completes a request by converting the data into events for the
 * input subsystem.
 *
 * The key parameter can be cascaded: key2 << 8 | key1
 */
static void report_key(struct yealink_dev *yld, int key)
{
    struct input_dev *idev = yld->idev;

    if (yld->key_code >= 0) {
        /* old key up */
        input_report_key(idev, yld->key_code & 0xff, 0);
        if (yld->key_code >> 8)
            input_report_key(idev, yld->key_code >> 8, 0);
    }

    yld->key_code = key;
    if (key >= 0) {
        /* new valid key */
        input_report_key(idev, key & 0xff, 1);
        if (key >> 8)
            input_report_key(idev, key >> 8, 1);
    }
    input_sync(idev);
}

/*******************************************************************************
 * Yealink usb communication interface
 ******************************************************************************/

static int yealink_cmd(struct yealink_dev *yld, struct yld_ctl_packet *p)
{
    u8  *buf = (u8 *)p;
    int i;
    u8  sum = 0;

    for(i=0; i<USB_PKT_LEN-1; i++)
        sum -= buf[i];
    p->sum = sum;
    return usb_control_msg(yld->udev,
            usb_sndctrlpipe(yld->udev, 0),
            USB_REQ_SET_CONFIGURATION,
            USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT,
            0x200, 3,
            p, sizeof(*p),
            USB_CTRL_SET_TIMEOUT);
}

static u8 default_ringtone[] = {
    0xEF,           /* volume [0-255] */
    0xFB, 0x1E, 0x00, 0x0C, /* 1250 [hz], 12/100 [s] */
    0xFC, 0x18, 0x00, 0x0C, /* 1000 [hz], 12/100 [s] */
    0xFB, 0x1E, 0x00, 0x0C,
    0xFC, 0x18, 0x00, 0x0C,
    0xFB, 0x1E, 0x00, 0x0C,
    0xFC, 0x18, 0x00, 0x0C,
    0xFB, 0x1E, 0x00, 0x0C,
    0xFC, 0x18, 0x00, 0x0C,
    0xFF, 0xFF, 0x01, 0x90, /* silent, 400/100 [s] */
    0x00, 0x00      /* end of sequence */
};

static int yealink_set_ringtone(struct yealink_dev *yld, u8 *buf, size_t size)
{
    struct yld_ctl_packet *p = yld->ctl_data;
    int ix, len;

    if (size <= 0)
        return -EINVAL;

    /* Set the ringtone volume */
    memset(yld->ctl_data, 0, sizeof(*(yld->ctl_data)));
    yld->ctl_data->cmd  = CMD_RING_VOLUME;
    yld->ctl_data->size = 1;
    yld->ctl_data->data[0]  = buf[0];
    yealink_cmd(yld, p);

    buf++;
    size--;

    p->cmd = CMD_RING_NOTE;
    ix = 0;
    while (size != ix) {
        len = size - ix;
        if (len > sizeof(p->data))
            len = sizeof(p->data);
        p->size   = len;
        p->offset = cpu_to_be16(ix);
        memcpy(p->data, &buf[ix], len);
        yealink_cmd(yld, p);
        ix += len;
    }
    return 0;
}

/* keep stat_master & stat_copy in sync.
 */
static int yealink_do_idle_tasks(struct yealink_dev *yld)
{
    u8 val;
    int i, ix, len;

    ix = yld->stat_ix;

    memset(yld->ctl_data, 0, sizeof(*(yld->ctl_data)));
    yld->ctl_data->cmd  = CMD_KEYPRESS;
    yld->ctl_data->size = 1;
    yld->ctl_data->sum  = 0xff - CMD_KEYPRESS;

    /* If state update pointer wraps do a KEYPRESS first. */
    if (ix >= sizeof(yld->master)) {
        yld->stat_ix = 0;
        return 0;
    }

    /* find update candidates: copy != master */
    do {
        val = yld->master.b[ix];
        if (val != yld->copy.b[ix])
            goto send_update;
    } while (++ix < sizeof(yld->master));

    /* nothing todo, wait a bit and poll for a KEYPRESS */
    yld->stat_ix = 0;
    /* TODO how can we wait abit. ??
     * msleep_interruptible(1000 / YEALINK_POLLING_FREQUENCY);
     */
    return 0;

send_update:

    /* Setup an appropriate update request */
    yld->copy.b[ix] = val;
    yld->ctl_data->data[0] = val;

    switch(ix) {
    case offsetof(struct yld_status, led):
        yld->ctl_data->cmd  = CMD_LED;
        yld->ctl_data->sum  = -1 - CMD_LED - val;
        break;
    case offsetof(struct yld_status, dialtone):
        yld->ctl_data->cmd  = CMD_DIALTONE;
        yld->ctl_data->sum  = -1 - CMD_DIALTONE - val;
        break;
    case offsetof(struct yld_status, ringtone):
        yld->ctl_data->cmd  = CMD_RINGTONE;
        yld->ctl_data->sum  = -1 - CMD_RINGTONE - val;
        break;
    case offsetof(struct yld_status, keynum):
        val--;
        val &= 0x1f;
        yld->ctl_data->cmd  = CMD_SCANCODE;
        yld->ctl_data->offset   = cpu_to_be16(val);
        yld->ctl_data->data[0]  = 0;
        yld->ctl_data->sum  = -1 - CMD_SCANCODE - val;
        break;
    default:
        len = sizeof(yld->master.s.lcd) - ix;
        if (len > sizeof(yld->ctl_data->data))
            len = sizeof(yld->ctl_data->data);

        /* Combine up to <len> consecutive LCD bytes in a singe request
         */
        yld->ctl_data->cmd  = CMD_LCD;
        yld->ctl_data->offset   = cpu_to_be16(ix);
        yld->ctl_data->size = len;
        yld->ctl_data->sum  = -CMD_LCD - ix - val - len;
        for(i=1; i<len; i++) {
            ix++;
            val = yld->master.b[ix];
            yld->copy.b[ix]     = val;
            yld->ctl_data->data[i]  = val;
            yld->ctl_data->sum     -= val;
        }
    }
    yld->stat_ix = ix + 1;
    return 1;
}

/* Decide on how to handle responses
 *
 * The state transition diagram is somethhing like:
 *
 *          syncState<--+
 *               |      |
 *               |    idle
 *              \|/     |
 * init --ok--> waitForKey --ok--> getKey
 *  ^               ^                |
 *  |               +-------ok-------+
 * error,start
 *
 */
static void urb_irq_callback(struct urb *urb)
{
    struct yealink_dev *yld = urb->context;
    int ret, status = urb->status;

    if (status)
        dev_err(&yld->intf->dev, "%s - urb status %d\n",
            __func__, status);

    switch (yld->irq_data->cmd) {
    case CMD_KEYPRESS:

        yld->master.s.keynum = yld->irq_data->data[0];
        break;

    case CMD_SCANCODE:
        dev_dbg(&yld->intf->dev, "get scancode %x\n",
            yld->irq_data->data[0]);

        report_key(yld, map_p1k_to_key(yld->irq_data->data[0]));
        break;

    default:
        dev_err(&yld->intf->dev, "unexpected response %x\n",
            yld->irq_data->cmd);
    }

    yealink_do_idle_tasks(yld);

    if (!yld->shutdown) {
        ret = usb_submit_urb(yld->urb_ctl, GFP_ATOMIC);
        if (ret && ret != -EPERM)
            dev_err(&yld->intf->dev,
                "%s - usb_submit_urb failed %d\n",
                __func__, ret);
    }
}

static void urb_ctl_callback(struct urb *urb)
{
    struct yealink_dev *yld = urb->context;
    int ret = 0, status = urb->status;

    if (status)
        dev_err(&yld->intf->dev, "%s - urb status %d\n",
            __func__, status);

    switch (yld->ctl_data->cmd) {
    case CMD_KEYPRESS:
    case CMD_SCANCODE:
        /* ask for a response */
        if (!yld->shutdown)
            ret = usb_submit_urb(yld->urb_irq, GFP_ATOMIC);
        break;
    default:
        /* send new command */
        yealink_do_idle_tasks(yld);
        if (!yld->shutdown)
            ret = usb_submit_urb(yld->urb_ctl, GFP_ATOMIC);
        break;
    }

    if (ret && ret != -EPERM)
        dev_err(&yld->intf->dev, "%s - usb_submit_urb failed %d\n",
            __func__, ret);
}

/*******************************************************************************
 * input event interface
 ******************************************************************************/

/* TODO should we issue a ringtone on a SND_BELL event?
static int input_ev(struct input_dev *dev, unsigned int type,
        unsigned int code, int value)
{

    if (type != EV_SND)
        return -EINVAL;

    switch (code) {
    case SND_BELL:
    case SND_TONE:
        break;
    default:
        return -EINVAL;
    }

    return 0;
}
*/

static int input_open(struct input_dev *dev)
{
    struct yealink_dev *yld = input_get_drvdata(dev);
    int i, ret;

    dev_dbg(&yld->intf->dev, "%s\n", __func__);

    /* force updates to device */
    for (i = 0; i<sizeof(yld->master); i++)
        yld->copy.b[i] = ~yld->master.b[i];
    yld->key_code = -1; /* no keys pressed */

        yealink_set_ringtone(yld, default_ringtone, sizeof(default_ringtone));

    /* issue INIT */
    memset(yld->ctl_data, 0, sizeof(*(yld->ctl_data)));
    yld->ctl_data->cmd  = CMD_INIT;
    yld->ctl_data->size = 10;
    yld->ctl_data->sum  = 0x100-CMD_INIT-10;
    if ((ret = usb_submit_urb(yld->urb_ctl, GFP_KERNEL)) != 0) {
        dev_dbg(&yld->intf->dev,
            "%s - usb_submit_urb failed with result %d\n",
            __func__, ret);
        return ret;
    }
    return 0;
}

static void input_close(struct input_dev *dev)
{
    struct yealink_dev *yld = input_get_drvdata(dev);

    yld->shutdown = 1;
    /*
     * Make sure the flag is seen by other CPUs before we start
     * killing URBs so new URBs won't be submitted
     */
    smp_wmb();

    usb_kill_urb(yld->urb_ctl);
    usb_kill_urb(yld->urb_irq);

    yld->shutdown = 0;
    smp_wmb();
}

/*******************************************************************************
 * sysfs interface
 ******************************************************************************/

static DECLARE_RWSEM(sysfs_rwsema);

/* Interface to the 7-segments translation table aka. char set.
 */
static ssize_t show_map(struct device *dev, struct device_attribute *attr,
                char *buf)
{
    memcpy(buf, &map_seg7, sizeof(map_seg7));
    return sizeof(map_seg7);
}

static ssize_t store_map(struct device *dev, struct device_attribute *attr,
                const char *buf, size_t cnt)
{
    if (cnt != sizeof(map_seg7))
        return -EINVAL;
    memcpy(&map_seg7, buf, sizeof(map_seg7));
    return sizeof(map_seg7);
}

/* Interface to the LCD.
 */

/* Reading /sys/../lineX will return the format string with its settings:
 *
 * Example:
 * cat ./line3
 * 888888888888
 * Linux Rocks!
 */
static ssize_t show_line(struct device *dev, char *buf, int a, int b)
{
    struct yealink_dev *yld;
    int i;

    down_read(&sysfs_rwsema);
    yld = dev_get_drvdata(dev);
    if (yld == NULL) {
        up_read(&sysfs_rwsema);
        return -ENODEV;
    }

    for (i = a; i < b; i++)
        *buf++ = lcdMap[i].type;
    *buf++ = '\n';
    for (i = a; i < b; i++)
        *buf++ = yld->lcdMap[i];
    *buf++ = '\n';
    *buf = 0;

    up_read(&sysfs_rwsema);
    return 3 + ((b - a) << 1);
}

static ssize_t show_line1(struct device *dev, struct device_attribute *attr,
            char *buf)
{
    return show_line(dev, buf, LCD_LINE1_OFFSET, LCD_LINE2_OFFSET);
}

static ssize_t show_line2(struct device *dev, struct device_attribute *attr,
            char *buf)
{
    return show_line(dev, buf, LCD_LINE2_OFFSET, LCD_LINE3_OFFSET);
}

static ssize_t show_line3(struct device *dev, struct device_attribute *attr,
            char *buf)
{
    return show_line(dev, buf, LCD_LINE3_OFFSET, LCD_LINE4_OFFSET);
}

/* Writing to /sys/../lineX will set the coresponding LCD line.
 * - Excess characters are ignored.
 * - If less characters are written than allowed, the remaining digits are
 *   unchanged.
 * - The '\n' or '\t' char is a placeholder, it does not overwrite the
 *   original content.
 */
static ssize_t store_line(struct device *dev, const char *buf, size_t count,
        int el, size_t len)
{
    struct yealink_dev *yld;
    int i;

    down_write(&sysfs_rwsema);
    yld = dev_get_drvdata(dev);
    if (yld == NULL) {
        up_write(&sysfs_rwsema);
        return -ENODEV;
    }

    if (len > count)
        len = count;
    for (i = 0; i < len; i++)
        setChar(yld, el++, buf[i]);

    up_write(&sysfs_rwsema);
    return count;
}

static ssize_t store_line1(struct device *dev, struct device_attribute *attr,
                const char *buf, size_t count)
{
    return store_line(dev, buf, count, LCD_LINE1_OFFSET, LCD_LINE1_SIZE);
}

static ssize_t store_line2(struct device *dev, struct device_attribute *attr,
                const char *buf, size_t count)
{
    return store_line(dev, buf, count, LCD_LINE2_OFFSET, LCD_LINE2_SIZE);
}

static ssize_t store_line3(struct device *dev, struct device_attribute *attr,
                const char *buf, size_t count)
{
    return store_line(dev, buf, count, LCD_LINE3_OFFSET, LCD_LINE3_SIZE);
}

/* Interface to visible and audible "icons", these include:
 * pictures on the LCD, the LED, and the dialtone signal.
 */

/* Get a list of "switchable elements" with their current state. */
static ssize_t get_icons(struct device *dev, struct device_attribute *attr,
            char *buf)
{
    struct yealink_dev *yld;
    int i, ret = 1;

    down_read(&sysfs_rwsema);
    yld = dev_get_drvdata(dev);
    if (yld == NULL) {
        up_read(&sysfs_rwsema);
        return -ENODEV;
    }

    for (i = 0; i < ARRAY_SIZE(lcdMap); i++) {
        if (lcdMap[i].type != '.')
            continue;
        ret += sprintf(&buf[ret], "%s %s\n",
                yld->lcdMap[i] == ' ' ? "  " : "on",
                lcdMap[i].u.p.name);
    }
    up_read(&sysfs_rwsema);
    return ret;
}

/* Change the visibility of a particular element. */
static ssize_t set_icon(struct device *dev, const char *buf, size_t count,
            int chr)
{
    struct yealink_dev *yld;
    int i;

    down_write(&sysfs_rwsema);
    yld = dev_get_drvdata(dev);
    if (yld == NULL) {
        up_write(&sysfs_rwsema);
        return -ENODEV;
    }

    for (i = 0; i < ARRAY_SIZE(lcdMap); i++) {
        if (lcdMap[i].type != '.')
            continue;
        if (strncmp(buf, lcdMap[i].u.p.name, count) == 0) {
            setChar(yld, i, chr);
            break;
        }
    }

    up_write(&sysfs_rwsema);
    return count;
}

static ssize_t show_icon(struct device *dev, struct device_attribute *attr,
        const char *buf, size_t count)
{
    return set_icon(dev, buf, count, buf[0]);
}

static ssize_t hide_icon(struct device *dev, struct device_attribute *attr,
        const char *buf, size_t count)
{
    return set_icon(dev, buf, count, ' ');
}

/* Upload a ringtone to the device.
 */

/* Stores raw ringtone data in the phone */
static ssize_t store_ringtone(struct device *dev,
        struct device_attribute *attr,
        const char *buf, size_t count)
{
    struct yealink_dev *yld;

    down_write(&sysfs_rwsema);
    yld = dev_get_drvdata(dev);
    if (yld == NULL) {
        up_write(&sysfs_rwsema);
        return -ENODEV;
    }

    /* TODO locking with async usb control interface??? */
    yealink_set_ringtone(yld, (char *)buf, count);
    up_write(&sysfs_rwsema);
    return count;
}

#define _M444   S_IRUGO
#define _M664   S_IRUGO|S_IWUSR|S_IWGRP
#define _M220   S_IWUSR|S_IWGRP

static DEVICE_ATTR(map_seg7 , _M664, show_map   , store_map );
static DEVICE_ATTR(line1    , _M664, show_line1 , store_line1   );
static DEVICE_ATTR(line2    , _M664, show_line2 , store_line2   );
static DEVICE_ATTR(line3    , _M664, show_line3 , store_line3   );
static DEVICE_ATTR(get_icons    , _M444, get_icons  , NULL      );
static DEVICE_ATTR(show_icon    , _M220, NULL       , show_icon );
static DEVICE_ATTR(hide_icon    , _M220, NULL       , hide_icon );
static DEVICE_ATTR(ringtone , _M220, NULL       , store_ringtone);

static struct attribute *yld_attributes[] = {
    &dev_attr_line1.attr,
    &dev_attr_line2.attr,
    &dev_attr_line3.attr,
    &dev_attr_get_icons.attr,
    &dev_attr_show_icon.attr,
    &dev_attr_hide_icon.attr,
    &dev_attr_map_seg7.attr,
    &dev_attr_ringtone.attr,
    NULL
};

static struct attribute_group yld_attr_group = {
    .attrs = yld_attributes
};

/*******************************************************************************
 * Linux interface and usb initialisation
 ******************************************************************************/

struct driver_info {
    char *name;
};

static const struct driver_info info_P1K = {
    .name   = "Yealink usb-p1k",
};

static const struct usb_device_id usb_table [] = {
    {
        .match_flags        = USB_DEVICE_ID_MATCH_DEVICE |
                        USB_DEVICE_ID_MATCH_INT_INFO,
        .idVendor       = 0x6993,
        .idProduct      = 0xb001,
        .bInterfaceClass    = USB_CLASS_HID,
        .bInterfaceSubClass = 0,
        .bInterfaceProtocol = 0,
        .driver_info        = (kernel_ulong_t)&info_P1K
    },
    { }
};

static int usb_cleanup(struct yealink_dev *yld, int err)
{
    if (yld == NULL)
        return err;

        if (yld->idev) {
        if (err)
            input_free_device(yld->idev);
        else
            input_unregister_device(yld->idev);
    }

    usb_free_urb(yld->urb_irq);
    usb_free_urb(yld->urb_ctl);

    kfree(yld->ctl_req);
    usb_free_coherent(yld->udev, USB_PKT_LEN, yld->ctl_data, yld->ctl_dma);
    usb_free_coherent(yld->udev, USB_PKT_LEN, yld->irq_data, yld->irq_dma);

    kfree(yld);
    return err;
}

static void usb_disconnect(struct usb_interface *intf)
{
    struct yealink_dev *yld;

    down_write(&sysfs_rwsema);
    yld = usb_get_intfdata(intf);
    sysfs_remove_group(&intf->dev.kobj, &yld_attr_group);
    usb_set_intfdata(intf, NULL);
    up_write(&sysfs_rwsema);

    usb_cleanup(yld, 0);
}

static int usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
{
    struct usb_device *udev = interface_to_usbdev (intf);
    struct driver_info *nfo = (struct driver_info *)id->driver_info;
    struct usb_host_interface *interface;
    struct usb_endpoint_descriptor *endpoint;
    struct yealink_dev *yld;
    struct input_dev *input_dev;
    int ret, pipe, i;

    interface = intf->cur_altsetting;
    endpoint = &interface->endpoint[0].desc;
    if (!usb_endpoint_is_int_in(endpoint))
        return -ENODEV;

    yld = kzalloc(sizeof(struct yealink_dev), GFP_KERNEL);
    if (!yld)
        return -ENOMEM;

    yld->udev = udev;
    yld->intf = intf;

    yld->idev = input_dev = input_allocate_device();
    if (!input_dev)
        return usb_cleanup(yld, -ENOMEM);

    /* allocate usb buffers */
    yld->irq_data = usb_alloc_coherent(udev, USB_PKT_LEN,
                       GFP_ATOMIC, &yld->irq_dma);
    if (yld->irq_data == NULL)
        return usb_cleanup(yld, -ENOMEM);

    yld->ctl_data = usb_alloc_coherent(udev, USB_PKT_LEN,
                       GFP_ATOMIC, &yld->ctl_dma);
    if (!yld->ctl_data)
        return usb_cleanup(yld, -ENOMEM);

    yld->ctl_req = kmalloc(sizeof(*(yld->ctl_req)), GFP_KERNEL);
    if (yld->ctl_req == NULL)
        return usb_cleanup(yld, -ENOMEM);

    /* allocate urb structures */
    yld->urb_irq = usb_alloc_urb(0, GFP_KERNEL);
        if (yld->urb_irq == NULL)
        return usb_cleanup(yld, -ENOMEM);

    yld->urb_ctl = usb_alloc_urb(0, GFP_KERNEL);
        if (yld->urb_ctl == NULL)
        return usb_cleanup(yld, -ENOMEM);

    /* get a handle to the interrupt data pipe */
    pipe = usb_rcvintpipe(udev, endpoint->bEndpointAddress);
    ret = usb_maxpacket(udev, pipe, usb_pipeout(pipe));
    if (ret != USB_PKT_LEN)
        dev_err(&intf->dev, "invalid payload size %d, expected %zd\n",
            ret, USB_PKT_LEN);

    /* initialise irq urb */
    usb_fill_int_urb(yld->urb_irq, udev, pipe, yld->irq_data,
            USB_PKT_LEN,
            urb_irq_callback,
            yld, endpoint->bInterval);
    yld->urb_irq->transfer_dma = yld->irq_dma;
    yld->urb_irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
    yld->urb_irq->dev = udev;

    /* initialise ctl urb */
    yld->ctl_req->bRequestType = USB_TYPE_CLASS | USB_RECIP_INTERFACE |
                      USB_DIR_OUT;
    yld->ctl_req->bRequest  = USB_REQ_SET_CONFIGURATION;
    yld->ctl_req->wValue    = cpu_to_le16(0x200);
    yld->ctl_req->wIndex    = cpu_to_le16(interface->desc.bInterfaceNumber);
    yld->ctl_req->wLength   = cpu_to_le16(USB_PKT_LEN);

    usb_fill_control_urb(yld->urb_ctl, udev, usb_sndctrlpipe(udev, 0),
            (void *)yld->ctl_req, yld->ctl_data, USB_PKT_LEN,
            urb_ctl_callback, yld);
    yld->urb_ctl->transfer_dma  = yld->ctl_dma;
    yld->urb_ctl->transfer_flags    |= URB_NO_TRANSFER_DMA_MAP;
    yld->urb_ctl->dev = udev;

    /* find out the physical bus location */
    usb_make_path(udev, yld->phys, sizeof(yld->phys));
    strlcat(yld->phys,  "/input0", sizeof(yld->phys));

    /* register settings for the input device */
    input_dev->name = nfo->name;
    input_dev->phys = yld->phys;
    usb_to_input_id(udev, &input_dev->id);
    input_dev->dev.parent = &intf->dev;

    input_set_drvdata(input_dev, yld);

    input_dev->open = input_open;
    input_dev->close = input_close;
    /* input_dev->event = input_ev; TODO */

    /* register available key events */
    input_dev->evbit[0] = BIT_MASK(EV_KEY);
    for (i = 0; i < 256; i++) {
        int k = map_p1k_to_key(i);
        if (k >= 0) {
            set_bit(k & 0xff, input_dev->keybit);
            if (k >> 8)
                set_bit(k >> 8, input_dev->keybit);
        }
    }

    ret = input_register_device(yld->idev);
    if (ret)
        return usb_cleanup(yld, ret);

    usb_set_intfdata(intf, yld);

    /* clear visible elements */
    for (i = 0; i < ARRAY_SIZE(lcdMap); i++)
        setChar(yld, i, ' ');

    /* display driver version on LCD line 3 */
    store_line3(&intf->dev, NULL,
            DRIVER_VERSION, sizeof(DRIVER_VERSION));

    /* Register sysfs hooks (don't care about failure) */
    ret = sysfs_create_group(&intf->dev.kobj, &yld_attr_group);
    return 0;
}

static struct usb_driver yealink_driver = {
    .name       = "yealink",
    .probe      = usb_probe,
    .disconnect = usb_disconnect,
    .id_table   = usb_table,
};

module_usb_driver(yealink_driver);

MODULE_DEVICE_TABLE (usb, usb_table);

MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL");