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