forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
996 lines
24 KiB
996 lines
24 KiB
// SPDX-License-Identifier: GPL-2.0-or-later |
|
/* |
|
* drivers/usb/input/yealink.c |
|
* |
|
* Copyright (c) 2005 Henk Vergonet <[email protected]> |
|
*/ |
|
/* |
|
* 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/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 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 const 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; |
|
|
|
if (interface->desc.bNumEndpoints < 1) |
|
return -ENODEV; |
|
|
|
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_KERNEL, &yld->irq_dma); |
|
if (yld->irq_data == NULL) |
|
return usb_cleanup(yld, -ENOMEM); |
|
|
|
yld->ctl_data = usb_alloc_coherent(udev, USB_PKT_LEN, |
|
GFP_KERNEL, &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("Henk Vergonet"); |
|
MODULE_DESCRIPTION("Yealink phone driver"); |
|
MODULE_LICENSE("GPL");
|
|
|