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