]>
Commit | Line | Data |
---|---|---|
1a59d1b8 | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
aca951a2 HV |
2 | /* |
3 | * drivers/usb/input/yealink.c | |
4 | * | |
5 | * Copyright (c) 2005 Henk Vergonet <Henk.Vergonet@gmail.com> | |
aca951a2 HV |
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 | |
ba0acb5e | 19 | * - the xpad-driver drivers/input/joystick/xpad.c |
aca951a2 HV |
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 | ||
aca951a2 | 36 | #include <linux/kernel.h> |
aca951a2 HV |
37 | #include <linux/slab.h> |
38 | #include <linux/module.h> | |
39 | #include <linux/rwsem.h> | |
ae0dadcf | 40 | #include <linux/usb/input.h> |
f9da8d15 | 41 | #include <linux/map_to_7segment.h> |
aca951a2 | 42 | |
aca951a2 HV |
43 | #include "yealink.h" |
44 | ||
8e2ce4f9 | 45 | #define DRIVER_VERSION "yld-20051230" |
aca951a2 HV |
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 { | |
c5b7c7c3 | 86 | struct input_dev *idev; /* input device */ |
aca951a2 | 87 | struct usb_device *udev; /* usb device */ |
73e66cea | 88 | struct usb_interface *intf; /* usb interface */ |
aca951a2 HV |
89 | |
90 | /* irq input channel */ | |
91 | struct yld_ctl_packet *irq_data; | |
c5b7c7c3 | 92 | dma_addr_t irq_dma; |
aca951a2 HV |
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; | |
aca951a2 HV |
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 | ||
b4ecda3e ON |
106 | unsigned int shutdown:1; |
107 | ||
aca951a2 HV |
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 | */ | |
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 | */ | |
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 | */ | |
7d12e780 | 222 | static void report_key(struct yealink_dev *yld, int key) |
aca951a2 | 223 | { |
c5b7c7c3 | 224 | struct input_dev *idev = yld->idev; |
aca951a2 | 225 | |
aca951a2 HV |
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 | ||
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 | ||
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; | |
b71e318c | 304 | p->offset = cpu_to_be16(ix); |
aca951a2 HV |
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 | */ | |
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; | |
b71e318c | 369 | yld->ctl_data->offset = cpu_to_be16(val); |
aca951a2 HV |
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; | |
b71e318c | 381 | yld->ctl_data->offset = cpu_to_be16(ix); |
aca951a2 HV |
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 | */ | |
7d12e780 | 410 | static void urb_irq_callback(struct urb *urb) |
aca951a2 HV |
411 | { |
412 | struct yealink_dev *yld = urb->context; | |
b4ecda3e | 413 | int ret, status = urb->status; |
aca951a2 | 414 | |
b4ecda3e | 415 | if (status) |
73e66cea | 416 | dev_err(&yld->intf->dev, "%s - urb status %d\n", |
08813d35 | 417 | __func__, status); |
aca951a2 HV |
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: | |
73e66cea | 426 | dev_dbg(&yld->intf->dev, "get scancode %x\n", |
938476f9 | 427 | yld->irq_data->data[0]); |
aca951a2 | 428 | |
7d12e780 | 429 | report_key(yld, map_p1k_to_key(yld->irq_data->data[0])); |
aca951a2 HV |
430 | break; |
431 | ||
432 | default: | |
73e66cea | 433 | dev_err(&yld->intf->dev, "unexpected response %x\n", |
08813d35 | 434 | yld->irq_data->cmd); |
aca951a2 HV |
435 | } |
436 | ||
437 | yealink_do_idle_tasks(yld); | |
438 | ||
b4ecda3e ON |
439 | if (!yld->shutdown) { |
440 | ret = usb_submit_urb(yld->urb_ctl, GFP_ATOMIC); | |
441 | if (ret && ret != -EPERM) | |
73e66cea | 442 | dev_err(&yld->intf->dev, |
08813d35 GKH |
443 | "%s - usb_submit_urb failed %d\n", |
444 | __func__, ret); | |
b4ecda3e | 445 | } |
aca951a2 HV |
446 | } |
447 | ||
7d12e780 | 448 | static void urb_ctl_callback(struct urb *urb) |
aca951a2 HV |
449 | { |
450 | struct yealink_dev *yld = urb->context; | |
b4ecda3e | 451 | int ret = 0, status = urb->status; |
aca951a2 | 452 | |
b4ecda3e | 453 | if (status) |
73e66cea | 454 | dev_err(&yld->intf->dev, "%s - urb status %d\n", |
08813d35 | 455 | __func__, status); |
aca951a2 HV |
456 | |
457 | switch (yld->ctl_data->cmd) { | |
458 | case CMD_KEYPRESS: | |
459 | case CMD_SCANCODE: | |
460 | /* ask for a response */ | |
b4ecda3e ON |
461 | if (!yld->shutdown) |
462 | ret = usb_submit_urb(yld->urb_irq, GFP_ATOMIC); | |
aca951a2 HV |
463 | break; |
464 | default: | |
465 | /* send new command */ | |
466 | yealink_do_idle_tasks(yld); | |
b4ecda3e ON |
467 | if (!yld->shutdown) |
468 | ret = usb_submit_urb(yld->urb_ctl, GFP_ATOMIC); | |
469 | break; | |
aca951a2 HV |
470 | } |
471 | ||
b4ecda3e | 472 | if (ret && ret != -EPERM) |
73e66cea | 473 | dev_err(&yld->intf->dev, "%s - usb_submit_urb failed %d\n", |
08813d35 | 474 | __func__, ret); |
aca951a2 HV |
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 | ||
501 | static int input_open(struct input_dev *dev) | |
502 | { | |
7791bdae | 503 | struct yealink_dev *yld = input_get_drvdata(dev); |
aca951a2 HV |
504 | int i, ret; |
505 | ||
73e66cea | 506 | dev_dbg(&yld->intf->dev, "%s\n", __func__); |
aca951a2 HV |
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) { | |
73e66cea | 521 | dev_dbg(&yld->intf->dev, |
938476f9 GKH |
522 | "%s - usb_submit_urb failed with result %d\n", |
523 | __func__, ret); | |
aca951a2 HV |
524 | return ret; |
525 | } | |
526 | return 0; | |
527 | } | |
528 | ||
529 | static void input_close(struct input_dev *dev) | |
530 | { | |
7791bdae | 531 | struct yealink_dev *yld = input_get_drvdata(dev); |
aca951a2 | 532 | |
b4ecda3e ON |
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 | ||
aca951a2 HV |
540 | usb_kill_urb(yld->urb_ctl); |
541 | usb_kill_urb(yld->urb_irq); | |
b4ecda3e ON |
542 | |
543 | yld->shutdown = 0; | |
544 | smp_wmb(); | |
aca951a2 HV |
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 | */ | |
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 | ||
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 | */ | |
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 | ||
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 | ||
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 | ||
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 | */ | |
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 | ||
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 | ||
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 | ||
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. */ | |
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. */ | |
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 | ||
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 | ||
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 */ | |
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 | ||
aa335071 | 786 | static const struct attribute_group yld_attr_group = { |
aca951a2 HV |
787 | .attrs = yld_attributes |
788 | }; | |
789 | ||
790 | /******************************************************************************* | |
791 | * Linux interface and usb initialisation | |
792 | ******************************************************************************/ | |
793 | ||
8e2ce4f9 | 794 | struct driver_info { |
aca951a2 | 795 | char *name; |
aca951a2 HV |
796 | }; |
797 | ||
8e2ce4f9 HV |
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 | }, | |
aca951a2 HV |
813 | { } |
814 | }; | |
815 | ||
816 | static int usb_cleanup(struct yealink_dev *yld, int err) | |
817 | { | |
818 | if (yld == NULL) | |
819 | return err; | |
820 | ||
c5b7c7c3 DT |
821 | if (yld->idev) { |
822 | if (err) | |
823 | input_free_device(yld->idev); | |
824 | else | |
825 | input_unregister_device(yld->idev); | |
826 | } | |
e37a97d4 DT |
827 | |
828 | usb_free_urb(yld->urb_irq); | |
829 | usb_free_urb(yld->urb_ctl); | |
830 | ||
0ede76fc | 831 | kfree(yld->ctl_req); |
997ea58e DM |
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); | |
e37a97d4 | 834 | |
aca951a2 HV |
835 | kfree(yld); |
836 | return err; | |
837 | } | |
838 | ||
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 | ||
aca951a2 HV |
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); | |
8e2ce4f9 | 855 | struct driver_info *nfo = (struct driver_info *)id->driver_info; |
aca951a2 HV |
856 | struct usb_host_interface *interface; |
857 | struct usb_endpoint_descriptor *endpoint; | |
858 | struct yealink_dev *yld; | |
c5b7c7c3 | 859 | struct input_dev *input_dev; |
aca951a2 HV |
860 | int ret, pipe, i; |
861 | ||
aca951a2 | 862 | interface = intf->cur_altsetting; |
5cc4a1a9 JH |
863 | |
864 | if (interface->desc.bNumEndpoints < 1) | |
865 | return -ENODEV; | |
866 | ||
aca951a2 | 867 | endpoint = &interface->endpoint[0].desc; |
6f7cd441 LFC |
868 | if (!usb_endpoint_is_int_in(endpoint)) |
869 | return -ENODEV; | |
aca951a2 | 870 | |
c5b7c7c3 DT |
871 | yld = kzalloc(sizeof(struct yealink_dev), GFP_KERNEL); |
872 | if (!yld) | |
aca951a2 HV |
873 | return -ENOMEM; |
874 | ||
aca951a2 | 875 | yld->udev = udev; |
73e66cea | 876 | yld->intf = intf; |
aca951a2 | 877 | |
c5b7c7c3 DT |
878 | yld->idev = input_dev = input_allocate_device(); |
879 | if (!input_dev) | |
880 | return usb_cleanup(yld, -ENOMEM); | |
881 | ||
aca951a2 | 882 | /* allocate usb buffers */ |
997ea58e | 883 | yld->irq_data = usb_alloc_coherent(udev, USB_PKT_LEN, |
434ca100 | 884 | GFP_KERNEL, &yld->irq_dma); |
aca951a2 HV |
885 | if (yld->irq_data == NULL) |
886 | return usb_cleanup(yld, -ENOMEM); | |
887 | ||
997ea58e | 888 | yld->ctl_data = usb_alloc_coherent(udev, USB_PKT_LEN, |
434ca100 | 889 | GFP_KERNEL, &yld->ctl_dma); |
aca951a2 HV |
890 | if (!yld->ctl_data) |
891 | return usb_cleanup(yld, -ENOMEM); | |
892 | ||
0ede76fc | 893 | yld->ctl_req = kmalloc(sizeof(*(yld->ctl_req)), GFP_KERNEL); |
aca951a2 HV |
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, usb_pipeout(pipe)); | |
909 | if (ret != USB_PKT_LEN) | |
08813d35 GKH |
910 | dev_err(&intf->dev, "invalid payload size %d, expected %zd\n", |
911 | ret, USB_PKT_LEN); | |
aca951a2 HV |
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); | |
aca951a2 | 933 | yld->urb_ctl->transfer_dma = yld->ctl_dma; |
0ede76fc | 934 | yld->urb_ctl->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; |
aca951a2 HV |
935 | yld->urb_ctl->dev = udev; |
936 | ||
937 | /* find out the physical bus location */ | |
c5b7c7c3 DT |
938 | usb_make_path(udev, yld->phys, sizeof(yld->phys)); |
939 | strlcat(yld->phys, "/input0", sizeof(yld->phys)); | |
aca951a2 HV |
940 | |
941 | /* register settings for the input device */ | |
8e2ce4f9 | 942 | input_dev->name = nfo->name; |
c5b7c7c3 DT |
943 | input_dev->phys = yld->phys; |
944 | usb_to_input_id(udev, &input_dev->id); | |
c0f82d57 | 945 | input_dev->dev.parent = &intf->dev; |
c5b7c7c3 | 946 | |
7791bdae DT |
947 | input_set_drvdata(input_dev, yld); |
948 | ||
c5b7c7c3 DT |
949 | input_dev->open = input_open; |
950 | input_dev->close = input_close; | |
951 | /* input_dev->event = input_ev; TODO */ | |
aca951a2 HV |
952 | |
953 | /* register available key events */ | |
7b19ada2 | 954 | input_dev->evbit[0] = BIT_MASK(EV_KEY); |
aca951a2 HV |
955 | for (i = 0; i < 256; i++) { |
956 | int k = map_p1k_to_key(i); | |
957 | if (k >= 0) { | |
c5b7c7c3 | 958 | set_bit(k & 0xff, input_dev->keybit); |
aca951a2 | 959 | if (k >> 8) |
c5b7c7c3 | 960 | set_bit(k >> 8, input_dev->keybit); |
aca951a2 HV |
961 | } |
962 | } | |
963 | ||
5014186d DT |
964 | ret = input_register_device(yld->idev); |
965 | if (ret) | |
966 | return usb_cleanup(yld, ret); | |
aca951a2 HV |
967 | |
968 | usb_set_intfdata(intf, yld); | |
969 | ||
970 | /* clear visible elements */ | |
c5b7c7c3 | 971 | for (i = 0; i < ARRAY_SIZE(lcdMap); i++) |
aca951a2 HV |
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) */ | |
657b6717 | 979 | ret = sysfs_create_group(&intf->dev.kobj, &yld_attr_group); |
aca951a2 HV |
980 | return 0; |
981 | } | |
982 | ||
983 | static struct usb_driver yealink_driver = { | |
aca951a2 HV |
984 | .name = "yealink", |
985 | .probe = usb_probe, | |
986 | .disconnect = usb_disconnect, | |
987 | .id_table = usb_table, | |
988 | }; | |
989 | ||
08642e7c | 990 | module_usb_driver(yealink_driver); |
aca951a2 HV |
991 | |
992 | MODULE_DEVICE_TABLE (usb, usb_table); | |
993 | ||
698c03b4 JL |
994 | MODULE_AUTHOR("Henk Vergonet"); |
995 | MODULE_DESCRIPTION("Yealink phone driver"); | |
aca951a2 | 996 | MODULE_LICENSE("GPL"); |