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