Commit | Line | Data |
---|---|---|
3c2a0909 S |
1 | /* drivers/misc/sec_jack.c |
2 | * | |
3 | * Copyright (C) 2015 Samsung Electronics Co.Ltd | |
4 | * | |
5 | * This program is free software; you can redistribute it and/or modify | |
6 | * it under the terms of the GNU General Public License as published by | |
7 | * the Free Software Foundation; either version 2 of the License, or | |
8 | * (at your option) any later version. | |
9 | * | |
10 | * This program is distributed in the hope that it will be useful, | |
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | * GNU General Public License for more details. | |
14 | */ | |
15 | #define DEBUG | |
16 | #include <linux/module.h> | |
17 | #include <linux/interrupt.h> | |
18 | #include <linux/workqueue.h> | |
19 | #include <linux/irq.h> | |
20 | #include <linux/delay.h> | |
21 | #include <linux/types.h> | |
22 | #include <linux/input.h> | |
23 | #include <linux/platform_device.h> | |
24 | #include <linux/errno.h> | |
25 | #include <linux/err.h> | |
26 | #include <linux/switch.h> | |
27 | #include <linux/input.h> | |
28 | #include <linux/timer.h> | |
29 | #include <linux/wakelock.h> | |
30 | #include <linux/slab.h> | |
31 | #include <linux/gpio.h> | |
32 | #include <linux/gpio_event.h> | |
33 | #include <linux/sec_jack.h> | |
34 | #include <linux/of_gpio.h> | |
35 | #include <linux/regulator/consumer.h> | |
36 | ||
37 | #define NUM_INPUT_DEVICE_ID 2 | |
38 | #define MAX_ZONE_LIMIT 10 | |
39 | #define DEFAULT_KEY_DEBOUNCE_TIME_MS 30 | |
40 | #define DEFAULT_DET_DEBOUNCE_TIME_MS 100 | |
41 | #define WAKE_LOCK_TIME (HZ * 5) /* 5 sec */ | |
42 | ||
43 | struct sec_jack_info { | |
44 | struct platform_device *client; | |
45 | struct sec_jack_platform_data *pdata; | |
46 | struct work_struct buttons_work; | |
47 | struct work_struct detect_work; | |
48 | struct workqueue_struct *detect_wq; | |
49 | struct workqueue_struct *buttons_wq; | |
50 | struct timer_list timer; | |
51 | struct input_dev *input_dev; | |
52 | struct wake_lock det_wake_lock; | |
53 | struct input_handler jack_handler; | |
54 | struct input_device_id ids[NUM_INPUT_DEVICE_ID]; | |
55 | int det_irq; | |
56 | int dev_id; | |
57 | int pressed; | |
58 | int pressed_code; | |
59 | bool buttons_enable; | |
60 | struct platform_device *send_key_dev; | |
61 | unsigned int cur_jack_type; | |
62 | }; | |
63 | ||
64 | /* define call back function for buuton notifcation */ | |
65 | static sec_jack_button_notify_cb button_notify_cb; | |
66 | ||
67 | /* with some modifications like moving all the gpio structs inside | |
68 | * the platform data and getting the name for the switch and | |
69 | * gpio_event from the platform data, the driver could support more than | |
70 | * one headset jack, but currently user space is looking only for | |
71 | * one key file and switch for a headset so it'd be overkill and | |
72 | * untestable so we limit to one instantiation for now. | |
73 | */ | |
74 | static atomic_t instantiated = ATOMIC_INIT(0); | |
75 | ||
76 | /* sysfs name HeadsetObserver.java looks for to track headset state | |
77 | */ | |
78 | struct switch_dev switch_jack_detection = { | |
79 | .name = "h2w", | |
80 | }; | |
81 | ||
82 | /* Samsung factory test application looks for to track button state | |
83 | */ | |
84 | struct switch_dev switch_sendend = { | |
85 | .name = "send_end", /* /sys/class/switch/send_end/state */ | |
86 | }; | |
87 | ||
88 | static struct gpio_event_direct_entry sec_jack_key_map[] = { | |
89 | { | |
90 | .code = KEY_UNKNOWN, | |
91 | }, | |
92 | }; | |
93 | ||
94 | static struct gpio_event_input_info sec_jack_key_info = { | |
95 | .info.func = gpio_event_input_func, | |
96 | .info.no_suspend = true, | |
97 | .type = EV_KEY, | |
98 | .debounce_time.tv64 = DEFAULT_KEY_DEBOUNCE_TIME_MS * NSEC_PER_MSEC, | |
99 | .keymap = sec_jack_key_map, | |
100 | .keymap_size = ARRAY_SIZE(sec_jack_key_map) | |
101 | }; | |
102 | ||
103 | static struct gpio_event_info *sec_jack_input_info[] = { | |
104 | &sec_jack_key_info.info, | |
105 | }; | |
106 | ||
107 | static struct gpio_event_platform_data sec_jack_input_data = { | |
108 | .name = "sec_jack", | |
109 | .info = sec_jack_input_info, | |
110 | .info_count = ARRAY_SIZE(sec_jack_input_info), | |
111 | }; | |
112 | ||
113 | struct sec_jack_control_data jack_controls; | |
114 | EXPORT_SYMBOL_GPL(jack_controls); | |
115 | ||
116 | int sec_jack_register_button_notify_cb(sec_jack_button_notify_cb func) | |
117 | { | |
118 | if (func == NULL) | |
119 | return -1; | |
120 | button_notify_cb = func; | |
121 | return 0; | |
122 | } | |
123 | EXPORT_SYMBOL_GPL(sec_jack_register_button_notify_cb); | |
124 | ||
125 | static void sec_jack_gpio_init(struct sec_jack_platform_data *pdata) | |
126 | { | |
127 | int ret; | |
128 | ||
129 | if (pdata->ear_micbias_en_gpio > 0) { | |
130 | ret = gpio_request(pdata->ear_micbias_en_gpio, | |
131 | "ear_micbias_en"); | |
132 | if (ret) { | |
133 | pr_err("%s : gpio_request failed for ear_micbias_en\n", | |
134 | __func__); | |
135 | return; | |
136 | } | |
137 | gpio_direction_output(pdata->ear_micbias_en_gpio, 0); | |
138 | } | |
139 | } | |
140 | ||
141 | static int sec_jack_get_adc_value(struct sec_jack_info *hi) | |
142 | { | |
143 | struct sec_jack_platform_data *pdata = hi->pdata; | |
144 | int adc_val; | |
145 | ||
146 | if (pdata->jack_controls->get_adc) { | |
147 | adc_val = pdata->jack_controls->get_adc(); | |
148 | dev_info(&hi->client->dev, "%s: %d\n", __func__, adc_val); | |
149 | } else { | |
150 | dev_err(&hi->client->dev, "No function for get_adc\n"); | |
151 | return -EFAULT; | |
152 | } | |
153 | ||
154 | return adc_val; | |
155 | } | |
156 | ||
157 | static void set_sec_micbias_state(struct sec_jack_info *hi, bool state) | |
158 | { | |
159 | struct sec_jack_platform_data *pdata = hi->pdata; | |
160 | ||
161 | if (pdata->ear_micbias_en_gpio > 0) | |
162 | gpio_set_value_cansleep(pdata->ear_micbias_en_gpio, state); | |
163 | else if (pdata->jack_controls->set_micbias) | |
164 | pdata->jack_controls->set_micbias(state); | |
165 | else | |
166 | dev_err(&hi->client->dev, "No gpio or function for bias control\n"); | |
167 | } | |
168 | ||
169 | /* gpio_input driver does not support to read adc value. | |
170 | * We use input filter to support 3-buttons of headset | |
171 | * without changing gpio_input driver. | |
172 | */ | |
173 | static bool sec_jack_buttons_filter(struct input_handle *jack_handle, | |
174 | unsigned int type, unsigned int code, int value) | |
175 | { | |
176 | struct sec_jack_info *hi = jack_handle->handler->private; | |
177 | ||
178 | if (type != EV_KEY || code != KEY_UNKNOWN) | |
179 | return false; | |
180 | ||
181 | hi->pressed = value; | |
182 | ||
183 | /* This is called in timer handler of gpio_input driver. | |
184 | * We use workqueue to read adc value. | |
185 | */ | |
186 | queue_work(hi->buttons_wq, &hi->buttons_work); | |
187 | ||
188 | return true; | |
189 | } | |
190 | ||
191 | static int sec_jack_buttons_connect(struct input_handler *jack_handler, | |
192 | struct input_dev *dev, const struct input_device_id *id) | |
193 | { | |
194 | struct sec_jack_info *hi; | |
195 | struct sec_jack_platform_data *pdata; | |
196 | struct sec_jack_buttons_zone *btn_zones; | |
197 | int err; | |
198 | int i; | |
199 | int num_buttons_zones; | |
200 | struct input_handle *jack_handle; | |
201 | ||
202 | /* bind input_handler to input device related to only sec_jack */ | |
203 | if (dev->name != sec_jack_input_data.name) | |
204 | return -ENODEV; | |
205 | ||
206 | hi = jack_handler->private; | |
207 | pdata = hi->pdata; | |
208 | btn_zones = pdata->jack_buttons_zones; | |
209 | num_buttons_zones = ARRAY_SIZE(pdata->jack_buttons_zones); | |
210 | ||
211 | hi->input_dev = dev; | |
212 | ||
213 | jack_handle = kzalloc(sizeof(*jack_handle), GFP_KERNEL); | |
214 | if (!jack_handle) { | |
215 | dev_err(&hi->client->dev, "Failed to alloc jack_handle\n"); | |
216 | return -ENOMEM; | |
217 | } | |
218 | ||
219 | jack_handle->dev = dev; | |
220 | jack_handle->handler = jack_handler; | |
221 | jack_handle->name = "sec_jack_buttons"; | |
222 | ||
223 | err = input_register_handle(jack_handle); | |
224 | if (err) { | |
225 | dev_err(&hi->client->dev, | |
226 | "Failed to input_register_handle %d\n", err); | |
227 | goto err_register_handle; | |
228 | } | |
229 | ||
230 | err = input_open_device(jack_handle); | |
231 | if (err) { | |
232 | dev_err(&hi->client->dev, | |
233 | "Failed to input_open_device %d\n", err); | |
234 | goto err_open_device; | |
235 | } | |
236 | ||
237 | for (i = 0; i < num_buttons_zones; i++) | |
238 | input_set_capability(dev, EV_KEY, btn_zones[i].code); | |
239 | ||
240 | return 0; | |
241 | ||
242 | err_open_device: | |
243 | input_unregister_handle(jack_handle); | |
244 | err_register_handle: | |
245 | kfree(jack_handle); | |
246 | ||
247 | return err; | |
248 | } | |
249 | ||
250 | static void sec_jack_buttons_disconnect(struct input_handle *jack_handle) | |
251 | { | |
252 | input_close_device(jack_handle); | |
253 | input_unregister_handle(jack_handle); | |
254 | kfree(jack_handle); | |
255 | } | |
256 | ||
257 | static void sec_jack_set_type(struct sec_jack_info *hi, | |
258 | enum sec_jack_type jack_type) | |
259 | { | |
260 | /* this can happen during slow inserts where we think we identified | |
261 | * the type but then we get another interrupt and do it again | |
262 | */ | |
263 | if (jack_type == hi->cur_jack_type) { | |
264 | if ((jack_type != SEC_HEADSET_4POLE) && | |
265 | (jack_type != SEC_EXTERNAL_ANTENNA)) | |
266 | set_sec_micbias_state(hi, false); | |
267 | return; | |
268 | } | |
269 | ||
270 | if ((jack_type == SEC_HEADSET_4POLE) || | |
271 | (jack_type == SEC_EXTERNAL_ANTENNA)) { | |
272 | /* for a 4 pole headset, enable detection of send/end key */ | |
273 | if (hi->send_key_dev == NULL) | |
274 | /* enable to get events again */ | |
275 | hi->send_key_dev = platform_device_register_data(NULL, | |
276 | GPIO_EVENT_DEV_NAME, | |
277 | hi->dev_id, | |
278 | &sec_jack_input_data, | |
279 | sizeof(sec_jack_input_data)); | |
280 | mod_timer(&hi->timer, | |
281 | jiffies + msecs_to_jiffies(1000)); | |
282 | } else { | |
283 | /* for all other jacks, disable send/end key detection */ | |
284 | if (hi->send_key_dev != NULL) { | |
285 | /* disable to prevent false events on next insert */ | |
286 | platform_device_unregister(hi->send_key_dev); | |
287 | hi->send_key_dev = NULL; | |
288 | del_timer_sync(&hi->timer); | |
289 | hi->buttons_enable = false; | |
290 | } | |
291 | /* micbias is left enabled for 4pole and disabled otherwise */ | |
292 | set_sec_micbias_state(hi, false); | |
293 | } | |
294 | ||
295 | hi->cur_jack_type = jack_type; | |
296 | dev_info(&hi->client->dev, "jack_type: %d\n", jack_type); | |
297 | ||
298 | switch_set_state(&switch_jack_detection, jack_type); | |
299 | } | |
300 | ||
301 | static void handle_jack_not_inserted(struct sec_jack_info *hi) | |
302 | { | |
303 | sec_jack_set_type(hi, SEC_JACK_NO_DEVICE); | |
304 | } | |
305 | ||
306 | static void determine_jack_type(struct sec_jack_info *hi) | |
307 | { | |
308 | struct sec_jack_platform_data *pdata = hi->pdata; | |
309 | struct sec_jack_zone *zones = pdata->jack_zones; | |
310 | int size = ARRAY_SIZE(pdata->jack_zones); | |
311 | int count[MAX_ZONE_LIMIT] = {0}; | |
312 | int adc; | |
313 | int i; | |
314 | unsigned npolarity = !pdata->det_active_high; | |
315 | ||
316 | /* set mic bias to enable adc */ | |
317 | set_sec_micbias_state(hi, true); | |
318 | ||
319 | while (gpio_get_value(pdata->det_gpio) ^ npolarity) { | |
320 | adc = sec_jack_get_adc_value(hi); | |
321 | if (adc < 0) { | |
322 | dev_err(&hi->client->dev, "Unavailable ADC %d\n", adc); | |
323 | return; | |
324 | } | |
325 | ||
326 | /* determine the type of headset based on the | |
327 | * adc value. An adc value can fall in various | |
328 | * ranges or zones. Within some ranges, the type | |
329 | * can be returned immediately. Within others, the | |
330 | * value is considered unstable and we need to sample | |
331 | * a few more types (up to the limit determined by | |
332 | * the range) before we return the type for that range. | |
333 | */ | |
334 | ||
335 | for (i = 0; i < size; i++) { | |
336 | if (adc <= zones[i].adc_high) { | |
337 | if (++count[i] > zones[i].check_count) { | |
338 | sec_jack_set_type(hi, | |
339 | zones[i].jack_type); | |
340 | return; | |
341 | } | |
342 | if (zones[i].delay_us > 0) | |
343 | usleep_range(zones[i].delay_us, | |
344 | zones[i].delay_us); | |
345 | break; | |
346 | } | |
347 | } | |
348 | } | |
349 | ||
350 | /* jack removed before detection complete */ | |
351 | dev_info(&hi->client->dev, "jack removed before detection complete\n"); | |
352 | handle_jack_not_inserted(hi); | |
353 | } | |
354 | ||
355 | static ssize_t key_state_onoff_show(struct device *dev, | |
356 | struct device_attribute *attr, char *buf) | |
357 | { | |
358 | struct sec_jack_info *hi = dev_get_drvdata(dev); | |
359 | int value = 0; | |
360 | ||
361 | if (hi->pressed && hi->pressed_code == KEY_MEDIA) | |
362 | value = 1; | |
363 | ||
364 | return snprintf(buf, 4, "%d\n", value); | |
365 | } | |
366 | ||
367 | static DEVICE_ATTR(key_state, 0444 , key_state_onoff_show, | |
368 | NULL); | |
369 | ||
370 | static ssize_t earjack_state_onoff_show(struct device *dev, | |
371 | struct device_attribute *attr, char *buf) | |
372 | { | |
373 | struct sec_jack_info *hi = dev_get_drvdata(dev); | |
374 | int value = 0; | |
375 | ||
376 | if (hi->cur_jack_type == SEC_HEADSET_4POLE) | |
377 | value = 1; | |
378 | ||
379 | return snprintf(buf, 4, "%d\n", value); | |
380 | } | |
381 | ||
382 | static DEVICE_ATTR(state, 0444 , earjack_state_onoff_show, | |
383 | NULL); | |
384 | ||
385 | static ssize_t earjack_mic_adc_show(struct device *dev, | |
386 | struct device_attribute *attr, char *buf) | |
387 | { | |
388 | struct sec_jack_info *hi = dev_get_drvdata(dev); | |
389 | struct sec_jack_platform_data *pdata = hi->pdata; | |
390 | int adc_val = 0; | |
391 | ||
392 | if (pdata->jack_controls->get_adc) { | |
393 | adc_val = pdata->jack_controls->get_adc(); | |
394 | dev_info(&hi->client->dev, "%s: %d\n", __func__, adc_val); | |
395 | } | |
396 | ||
397 | return snprintf(buf, 5, "%d\n", adc_val); | |
398 | } | |
399 | ||
400 | static DEVICE_ATTR(mic_adc, 0444 , earjack_mic_adc_show, | |
401 | NULL); | |
402 | ||
403 | static void sec_jack_timer_handler(unsigned long data) | |
404 | { | |
405 | struct sec_jack_info *hi = (struct sec_jack_info *)data; | |
406 | ||
407 | hi->buttons_enable = true; | |
408 | ||
409 | } | |
410 | /* thread run whenever the headset detect state changes (either insertion | |
411 | * or removal). | |
412 | */ | |
413 | static irqreturn_t sec_jack_detect_irq(int irq, void *dev_id) | |
414 | { | |
415 | struct sec_jack_info *hi = dev_id; | |
416 | ||
417 | queue_work(hi->detect_wq, &hi->detect_work); | |
418 | ||
419 | return IRQ_HANDLED; | |
420 | } | |
421 | ||
422 | void sec_jack_detect_work(struct work_struct *work) | |
423 | { | |
424 | struct sec_jack_info *hi = | |
425 | container_of(work, struct sec_jack_info, detect_work); | |
426 | struct sec_jack_platform_data *pdata = hi->pdata; | |
427 | unsigned npolarity = !hi->pdata->det_active_high; | |
428 | int time_left_ms; | |
429 | ||
430 | if (pdata->det_debounce_time_ms > 0) | |
431 | time_left_ms = pdata->det_debounce_time_ms; | |
432 | else | |
433 | time_left_ms = DEFAULT_DET_DEBOUNCE_TIME_MS; | |
434 | ||
435 | /* prevent suspend to allow user space to respond to switch */ | |
436 | wake_lock_timeout(&hi->det_wake_lock, WAKE_LOCK_TIME); | |
437 | ||
438 | dev_info(&hi->client->dev, "%s: irq(%d)\n", __func__, | |
439 | gpio_get_value(pdata->det_gpio) ^ npolarity); | |
440 | ||
441 | /* debounce headset jack. don't try to determine the type of | |
442 | * headset until the detect state is true for a while. | |
443 | */ | |
444 | while (time_left_ms > 0) { | |
445 | if (!(gpio_get_value(hi->pdata->det_gpio) ^ npolarity)) { | |
446 | /* jack not detected. */ | |
447 | handle_jack_not_inserted(hi); | |
448 | return; | |
449 | } | |
450 | usleep_range(10000, 11000); | |
451 | time_left_ms -= 10; | |
452 | } | |
453 | ||
454 | /* jack presence was detected the whole time, figure out which type */ | |
455 | determine_jack_type(hi); | |
456 | } | |
457 | ||
458 | /* thread run whenever the button of headset is pressed or released */ | |
459 | void sec_jack_buttons_work(struct work_struct *work) | |
460 | { | |
461 | struct sec_jack_info *hi = | |
462 | container_of(work, struct sec_jack_info, buttons_work); | |
463 | struct sec_jack_platform_data *pdata = hi->pdata; | |
464 | struct sec_jack_buttons_zone *btn_zones = pdata->jack_buttons_zones; | |
465 | int num_buttons_zones = ARRAY_SIZE(pdata->jack_buttons_zones); | |
466 | int adc; | |
467 | int i; | |
468 | ||
469 | if (!hi->buttons_enable) { | |
470 | dev_info(&hi->client->dev, "key %d is skipped\n", | |
471 | hi->pressed_code); | |
472 | return; | |
473 | } | |
474 | /* prevent suspend to allow user space to respond to switch */ | |
475 | wake_lock_timeout(&hi->det_wake_lock, WAKE_LOCK_TIME); | |
476 | ||
477 | /* when button is released */ | |
478 | if (hi->pressed == 0) { | |
479 | input_report_key(hi->input_dev, hi->pressed_code, 0); | |
480 | input_sync(hi->input_dev); | |
481 | switch_set_state(&switch_sendend, 0); | |
482 | dev_info(&hi->client->dev, "key %d is released\n", | |
483 | hi->pressed_code); | |
484 | if (button_notify_cb) | |
485 | button_notify_cb(hi->pressed_code, 0); | |
486 | return; | |
487 | } | |
488 | ||
489 | /* when button is pressed */ | |
490 | adc = sec_jack_get_adc_value(hi); | |
491 | ||
492 | if (adc < 0) { | |
493 | dev_err(&hi->client->dev, "Unavailable key ADC %d\n", adc); | |
494 | return; | |
495 | } | |
496 | ||
497 | for (i = 0; i < num_buttons_zones; i++) | |
498 | if (adc >= btn_zones[i].adc_low && | |
499 | adc <= btn_zones[i].adc_high) { | |
500 | hi->pressed_code = btn_zones[i].code; | |
501 | input_report_key(hi->input_dev, btn_zones[i].code, 1); | |
502 | input_sync(hi->input_dev); | |
503 | switch_set_state(&switch_sendend, 1); | |
504 | dev_info(&hi->client->dev, "adc = %d, key %d is pressed\n", | |
505 | adc, btn_zones[i].code); | |
506 | if (button_notify_cb) | |
507 | button_notify_cb(btn_zones[i].code, true); | |
508 | return; | |
509 | } | |
510 | ||
511 | dev_warn(&hi->client->dev, "key skipped. ADC %d\n", adc); | |
512 | } | |
513 | ||
514 | #ifdef CONFIG_OF | |
515 | static struct sec_jack_platform_data | |
516 | *sec_jack_populate_dt_pdata(struct device *dev) | |
517 | { | |
518 | struct sec_jack_platform_data *pdata; | |
519 | struct of_phandle_args args; | |
520 | int i = 0; | |
521 | ||
522 | pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); | |
523 | if (!pdata) { | |
524 | dev_err(dev, "Failed to allocate memory for pdata\n"); | |
525 | goto alloc_err; | |
526 | } | |
527 | ||
528 | pdata->det_gpio = of_get_named_gpio(dev->of_node, "detect-gpio", 0); | |
529 | if (pdata->det_gpio < 0) { | |
530 | dev_err(dev, "Failed to find detect-gpio\n"); | |
531 | goto of_parse_err; | |
532 | } | |
533 | ||
534 | pdata->key_gpio = of_get_named_gpio(dev->of_node, "key-gpio", 0); | |
535 | if (pdata->key_gpio < 0) { | |
536 | dev_err(dev, "Failed to find key-gpio\n"); | |
537 | // goto of_parse_err; | |
538 | } | |
539 | ||
540 | pdata->ear_micbias_en_gpio = of_get_named_gpio(dev->of_node, | |
541 | "ear-micbias-en-gpio", 0); | |
542 | if (pdata->ear_micbias_en_gpio < 0) | |
543 | dev_info(dev, "ear-micbias-en-gpio not found\n"); | |
544 | ||
545 | if (of_property_read_u32(dev->of_node, | |
546 | "key-dbtime", &pdata->key_debounce_time_ms)) | |
547 | dev_info(dev, "key-dbtime not found, use default\n"); | |
548 | ||
549 | if (of_property_read_u32(dev->of_node, | |
550 | "det-dbtime", &pdata->det_debounce_time_ms)) | |
551 | dev_info(dev, "det-dbtime not found, use default\n"); | |
552 | ||
553 | for (i = 0; i < 4; i++) { | |
554 | of_parse_phandle_with_args(dev->of_node, | |
555 | "det-zones-list", "#list-det-cells", i, &args); | |
556 | pdata->jack_zones[i].adc_high = args.args[0]; | |
557 | pdata->jack_zones[i].delay_us = args.args[1]; | |
558 | pdata->jack_zones[i].check_count = args.args[2]; | |
559 | pdata->jack_zones[i].jack_type = args.args[3]; | |
560 | dev_dbg(dev, "det-zones-list %d, %d, %d, %d, %d\n", | |
561 | args.args_count, args.args[0], | |
562 | args.args[1], args.args[2], args.args[3]); | |
563 | } | |
564 | ||
565 | for (i = 0; i < 4; i++) { | |
566 | of_parse_phandle_with_args(dev->of_node, | |
567 | "but-zones-list", "#list-but-cells", i, &args); | |
568 | pdata->jack_buttons_zones[i].code = args.args[0]; | |
569 | pdata->jack_buttons_zones[i].adc_low = args.args[1]; | |
570 | pdata->jack_buttons_zones[i].adc_high = args.args[2]; | |
571 | dev_dbg(dev, "but-zones-list %d, %d, %d, %d\n", | |
572 | args.args_count, args.args[0], | |
573 | args.args[1], args.args[2]); | |
574 | } | |
575 | ||
576 | if (of_find_property(dev->of_node, "det-active-high", NULL)) | |
577 | pdata->det_active_high = true; | |
578 | ||
579 | if (of_find_property(dev->of_node, "send-end-active-high", NULL)) | |
580 | pdata->send_end_active_high = true; | |
581 | ||
582 | return pdata; | |
583 | ||
584 | of_parse_err: | |
585 | devm_kfree(dev, pdata); | |
586 | alloc_err: | |
587 | return NULL; | |
588 | } | |
589 | #else | |
590 | static struct sec_jack_platform_data | |
591 | *sec_jack_populate_dt_pdata(struct device *dev) | |
592 | { | |
593 | return NULL; | |
594 | } | |
595 | #endif | |
596 | ||
597 | static int sec_jack_probe(struct platform_device *pdev) | |
598 | { | |
599 | struct sec_jack_info *hi; | |
600 | struct sec_jack_platform_data *pdata; | |
601 | struct class *audio; | |
602 | struct device *earjack; | |
603 | int ret; | |
604 | ||
605 | dev_info(&pdev->dev, "Registering sec_jack driver\n"); | |
606 | if (jack_controls.snd_card_registered != 1) { | |
607 | dev_info(&pdev->dev, "defer as sound card not registered\n"); | |
608 | return -EPROBE_DEFER; | |
609 | } | |
610 | ||
611 | ||
612 | if (dev_get_platdata(&pdev->dev)) | |
613 | pdata = pdev->dev.platform_data; | |
614 | else | |
615 | pdata = sec_jack_populate_dt_pdata(&pdev->dev); | |
616 | ||
617 | if (!pdata) { | |
618 | dev_err(&pdev->dev, "pdata is NULL\n"); | |
619 | return -ENODEV; | |
620 | } else | |
621 | sec_jack_gpio_init(pdata); | |
622 | ||
623 | if (atomic_xchg(&instantiated, 1)) { | |
624 | dev_err(&pdev->dev, "already instantiated, can only have one\n"); | |
625 | return -ENODEV; | |
626 | } | |
627 | ||
628 | sec_jack_key_map[0].gpio = pdata->key_gpio; | |
629 | ||
630 | pdata->jack_controls = &jack_controls; | |
631 | ||
632 | hi = kzalloc(sizeof(struct sec_jack_info), GFP_KERNEL); | |
633 | if (hi == NULL) { | |
634 | dev_err(&pdev->dev, "Failed to allocate memory\n"); | |
635 | ret = -ENOMEM; | |
636 | goto err_kzalloc; | |
637 | } | |
638 | ||
639 | hi->pdata = pdata; | |
640 | ||
641 | /* make the id of our gpi_event device the same as our platform device, | |
642 | * which makes it the responsiblity of the board file to make sure | |
643 | * it is unique relative to other gpio_event devices | |
644 | */ | |
645 | hi->dev_id = pdev->id; | |
646 | /* to read the vadc */ | |
647 | hi->client = pdev; | |
648 | ||
649 | if (pdata->det_gpio > 0) { | |
650 | ret = gpio_request(pdata->det_gpio, "jack_detect"); | |
651 | if (ret) { | |
652 | dev_err(&pdev->dev, "gpio_request failed for det_gpio\n"); | |
653 | goto err_gpio_request; | |
654 | } | |
655 | } | |
656 | ||
657 | ret = switch_dev_register(&switch_jack_detection); | |
658 | if (ret < 0) { | |
659 | dev_err(&pdev->dev, "Failed to register h2w switch device\n"); | |
660 | goto err_h2w_dev_register; | |
661 | } | |
662 | ||
663 | ret = switch_dev_register(&switch_sendend); | |
664 | if (ret < 0) { | |
665 | dev_err(&pdev->dev, "Failed to register key switch device\n"); | |
666 | goto err_send_end_dev_register; | |
667 | } | |
668 | ||
669 | wake_lock_init(&hi->det_wake_lock, WAKE_LOCK_SUSPEND, "sec_jack_det"); | |
670 | ||
671 | setup_timer(&hi->timer, sec_jack_timer_handler, (unsigned long)hi); | |
672 | ||
673 | INIT_WORK(&hi->detect_work, sec_jack_detect_work); | |
674 | INIT_WORK(&hi->buttons_work, sec_jack_buttons_work); | |
675 | ||
676 | hi->detect_wq = create_singlethread_workqueue("detect_wq"); | |
677 | if (hi->detect_wq == NULL) { | |
678 | ret = -ENOMEM; | |
679 | dev_err(&pdev->dev, "Failed to create detect_wq\n"); | |
680 | goto err_create_detect_wq_failed; | |
681 | } | |
682 | ||
683 | hi->buttons_wq = create_singlethread_workqueue("buttons_wq"); | |
684 | if (hi->buttons_wq == NULL) { | |
685 | ret = -ENOMEM; | |
686 | dev_err(&pdev->dev, "Failed to create buttons_wq\n"); | |
687 | goto err_create_buttons_wq_failed; | |
688 | } | |
689 | ||
690 | queue_work(hi->detect_wq, &hi->detect_work); | |
691 | ||
692 | hi->det_irq = gpio_to_irq(pdata->det_gpio); | |
693 | ||
694 | set_bit(EV_KEY, hi->ids[0].evbit); | |
695 | hi->ids[0].flags = INPUT_DEVICE_ID_MATCH_EVBIT; | |
696 | hi->jack_handler.filter = sec_jack_buttons_filter; | |
697 | hi->jack_handler.connect = sec_jack_buttons_connect; | |
698 | hi->jack_handler.disconnect = sec_jack_buttons_disconnect; | |
699 | hi->jack_handler.name = "sec_jack_buttons"; | |
700 | hi->jack_handler.id_table = hi->ids; | |
701 | hi->jack_handler.private = hi; | |
702 | ||
703 | ret = input_register_handler(&hi->jack_handler); | |
704 | if (ret) { | |
705 | dev_err(&pdev->dev, "Failed to input_register_handler\n"); | |
706 | goto err_input_register_handler; | |
707 | } | |
708 | ||
709 | /* We are going to remove this code later */ | |
710 | if (pdata->send_end_active_high == true) | |
711 | sec_jack_key_info.flags = 1; | |
712 | ||
713 | if (pdata->key_debounce_time_ms > 0) | |
714 | sec_jack_key_info.debounce_time.tv64 | |
715 | = pdata->key_debounce_time_ms * NSEC_PER_MSEC; | |
716 | ||
717 | ret = request_irq(hi->det_irq, sec_jack_detect_irq, | |
718 | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | | |
719 | IRQF_ONESHOT, "sec_headset_detect", hi); | |
720 | if (ret) { | |
721 | dev_err(&pdev->dev, "Failed to request_irq\n"); | |
722 | goto err_request_detect_irq; | |
723 | } | |
724 | ||
725 | /* to handle insert/removal when we're sleeping in a call */ | |
726 | ret = enable_irq_wake(hi->det_irq); | |
727 | if (ret) { | |
728 | dev_err(&pdev->dev, "Failed to enable_irq_wake\n"); | |
729 | goto err_enable_irq_wake; | |
730 | } | |
731 | ||
732 | dev_set_drvdata(&pdev->dev, hi); | |
733 | ||
734 | /* Create sysfs to support PBA test */ | |
735 | audio = class_create(THIS_MODULE, "audio"); | |
736 | if (IS_ERR(audio)) { | |
737 | dev_err(&pdev->dev, "Failed to create class audio\n"); | |
738 | ret = -ENODEV; | |
739 | goto err_class_create; | |
740 | } | |
741 | ||
742 | earjack = device_create(audio, NULL, 0, NULL, "earjack"); | |
743 | if (IS_ERR(earjack)) { | |
744 | dev_err(&pdev->dev, "Failed to create device earjack\n"); | |
745 | ret = -ENODEV; | |
746 | goto err_device_create; | |
747 | } | |
748 | ||
749 | ret = device_create_file(earjack, &dev_attr_key_state); | |
750 | if (ret) { | |
751 | dev_err(&pdev->dev, "Failed to create device file in %s\n", | |
752 | dev_attr_key_state.attr.name); | |
753 | goto err_dev_attr_key_state; | |
754 | } | |
755 | ||
756 | ret = device_create_file(earjack, &dev_attr_state); | |
757 | if (ret) { | |
758 | dev_err(&pdev->dev, "Failed to create device file in %s\n", | |
759 | dev_attr_state.attr.name); | |
760 | goto err_dev_attr_state; | |
761 | } | |
762 | ||
763 | ret = device_create_file(earjack, &dev_attr_mic_adc); | |
764 | if (ret) { | |
765 | dev_err(&pdev->dev, "Failed to create device file in %s\n", | |
766 | dev_attr_mic_adc.attr.name); | |
767 | goto err_dev_attr_mic_adc; | |
768 | } | |
769 | dev_set_drvdata(earjack, hi); | |
770 | ||
771 | dev_info(&pdev->dev, "Registering sec_jack driver\n"); | |
772 | return 0; | |
773 | err_dev_attr_mic_adc: | |
774 | device_remove_file(earjack, &dev_attr_state); | |
775 | err_dev_attr_state: | |
776 | device_remove_file(earjack, &dev_attr_key_state); | |
777 | err_dev_attr_key_state: | |
778 | device_destroy(audio, 0); | |
779 | err_device_create: | |
780 | class_destroy(audio); | |
781 | err_class_create: | |
782 | disable_irq_wake(hi->det_irq); | |
783 | err_enable_irq_wake: | |
784 | free_irq(hi->det_irq, hi); | |
785 | err_request_detect_irq: | |
786 | input_unregister_handler(&hi->jack_handler); | |
787 | err_input_register_handler: | |
788 | destroy_workqueue(hi->buttons_wq); | |
789 | err_create_buttons_wq_failed: | |
790 | destroy_workqueue(hi->detect_wq); | |
791 | err_create_detect_wq_failed: | |
792 | wake_lock_destroy(&hi->det_wake_lock); | |
793 | switch_dev_unregister(&switch_sendend); | |
794 | err_send_end_dev_register: | |
795 | switch_dev_unregister(&switch_jack_detection); | |
796 | err_h2w_dev_register: | |
797 | gpio_free(pdata->det_gpio); | |
798 | err_gpio_request: | |
799 | kfree(hi); | |
800 | err_kzalloc: | |
801 | atomic_set(&instantiated, 0); | |
802 | ||
803 | return ret; | |
804 | } | |
805 | ||
806 | static int sec_jack_remove(struct platform_device *pdev) | |
807 | { | |
808 | ||
809 | struct sec_jack_info *hi = dev_get_drvdata(&pdev->dev); | |
810 | ||
811 | disable_irq_wake(hi->det_irq); | |
812 | free_irq(hi->det_irq, hi); | |
813 | destroy_workqueue(hi->detect_wq); | |
814 | destroy_workqueue(hi->buttons_wq); | |
815 | if (hi->send_key_dev) { | |
816 | platform_device_unregister(hi->send_key_dev); | |
817 | hi->send_key_dev = NULL; | |
818 | } | |
819 | input_unregister_handler(&hi->jack_handler); | |
820 | wake_lock_destroy(&hi->det_wake_lock); | |
821 | switch_dev_unregister(&switch_jack_detection); | |
822 | switch_dev_unregister(&switch_sendend); | |
823 | gpio_free(hi->pdata->det_gpio); | |
824 | kfree(hi); | |
825 | atomic_set(&instantiated, 0); | |
826 | ||
827 | return 0; | |
828 | } | |
829 | ||
830 | static const struct of_device_id sec_jack_dt_match[] = { | |
831 | { .compatible = "sec_jack" }, | |
832 | { } | |
833 | }; | |
834 | MODULE_DEVICE_TABLE(of, sec_jack_dt_match); | |
835 | ||
836 | static struct platform_driver sec_jack_driver = { | |
837 | .probe = sec_jack_probe, | |
838 | .remove = sec_jack_remove, | |
839 | .driver = { | |
840 | .name = "sec_jack", | |
841 | .owner = THIS_MODULE, | |
842 | .of_match_table = of_match_ptr(sec_jack_dt_match), | |
843 | }, | |
844 | }; | |
845 | ||
846 | static int __init sec_jack_init(void) | |
847 | { | |
848 | return platform_driver_register(&sec_jack_driver); | |
849 | } | |
850 | ||
851 | static void __exit sec_jack_exit(void) | |
852 | { | |
853 | platform_driver_unregister(&sec_jack_driver); | |
854 | } | |
855 | ||
856 | late_initcall(sec_jack_init); | |
857 | module_exit(sec_jack_exit); | |
858 | ||
859 | MODULE_DESCRIPTION("Samsung Electronics Extcon driver"); | |
860 | MODULE_LICENSE("GPL"); |