1 /*
2 * Copyright (C) 2012 ROCKCHIP, Inc.
3 *
4 * This software is licensed under the terms of the GNU General Public
5 * License version 2, as published by the Free Software Foundation, and
6 * may be copied, distributed, and modified under those terms.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 */
14 /* Rock-chips rfkill driver for bluetooth
15 *
16 */
17
18 #include <linux/kernel.h>
19 #include <linux/platform_device.h>
20 #include <linux/module.h>
21 #include <linux/rfkill.h>
22 #include <linux/init.h>
23 #include <linux/slab.h>
24 #include <linux/delay.h>
25 #include <linux/rfkill-bt.h>
26 #include <linux/rfkill-wlan.h>
27 #include <linux/wakelock.h>
28 #include <linux/interrupt.h>
29 #include <asm/irq.h>
30 #include <linux/suspend.h>
31 #include <linux/proc_fs.h>
32 #include <linux/uaccess.h>
33 #include <linux/gpio.h>
34 #include <linux/fs.h>
35 #include <dt-bindings/gpio/gpio.h>
36 #include <uapi/linux/rfkill.h>
37 #ifdef CONFIG_OF
38 #include <linux/of.h>
39 #include <linux/of_device.h>
40 #include <linux/of_gpio.h>
41 #endif
42
43 #if 0
44 #define DBG(x...) pr_info("[BT_RFKILL]: " x)
45 #else
46 #define DBG(x...)
47 #endif
48
49 #define LOG(x...) pr_info("[BT_RFKILL]: " x)
50
51 #define BT_WAKEUP_TIMEOUT 10000
52 #define BT_IRQ_WAKELOCK_TIMEOUT (10 * 1000)
53
54 #define BT_BLOCKED true
55 #define BT_UNBLOCK false
56 #define BT_SLEEP true
57 #define BT_WAKEUP false
58
59 enum {
60 IOMUX_FNORMAL = 0,
61 IOMUX_FGPIO,
62 IOMUX_FMUX,
63 };
64
65 struct rfkill_rk_data {
66 struct rfkill_rk_platform_data *pdata;
67 struct platform_device *pdev;
68 struct rfkill *rfkill_dev;
69 struct wake_lock bt_irq_wl;
70 struct delayed_work bt_sleep_delay_work;
71 int irq_req;
72 };
73
74 static struct rfkill_rk_data *g_rfkill = NULL;
75
76 static const char bt_name[] =
77 #if defined(CONFIG_BCM4330)
78 #if defined(CONFIG_BT_MODULE_NH660)
79 "nh660"
80 #else
81 "bcm4330"
82 #endif
83 #elif defined(CONFIG_RK903)
84 #if defined(CONFIG_RKWIFI_26M)
85 "rk903_26M"
86 #else
87 "rk903"
88 #endif
89 #elif defined(CONFIG_BCM4329)
90 "bcm4329"
91 #elif defined(CONFIG_MV8787)
92 "mv8787"
93 #elif defined(CONFIG_AP6210)
94 #if defined(CONFIG_RKWIFI_26M)
95 "ap6210"
96 #else
97 "ap6210_24M"
98 #endif
99 #elif defined(CONFIG_AP6330)
100 "ap6330"
101 #elif defined(CONFIG_AP6476)
102 "ap6476"
103 #elif defined(CONFIG_AP6493)
104 "ap6493"
105 #elif defined(CONFIG_AP6441)
106 "ap6441"
107 #elif defined(CONFIG_AP6335)
108 "ap6335"
109 #elif defined(CONFIG_GB86302I)
110 "gb86302i"
111 #else
112 "bt_default"
113 #endif
114 ;
115
rfkill_rk_wake_host_irq(int irq,void * dev)116 static irqreturn_t rfkill_rk_wake_host_irq(int irq, void *dev)
117 {
118 struct rfkill_rk_data *rfkill = dev;
119
120 LOG("BT_WAKE_HOST IRQ fired\n");
121
122 DBG("BT IRQ wakeup, request %dms wakelock\n", BT_IRQ_WAKELOCK_TIMEOUT);
123
124 wake_lock_timeout(&rfkill->bt_irq_wl,
125 msecs_to_jiffies(BT_IRQ_WAKELOCK_TIMEOUT));
126
127 return IRQ_HANDLED;
128 }
129
rfkill_rk_setup_gpio(struct platform_device * pdev,struct rfkill_rk_gpio * gpio,const char * prefix,const char * name)130 static int rfkill_rk_setup_gpio(struct platform_device *pdev,
131 struct rfkill_rk_gpio *gpio, const char *prefix,
132 const char *name)
133 {
134 if (gpio_is_valid(gpio->io)) {
135 int ret = 0;
136
137 sprintf(gpio->name, "%s_%s", prefix, name);
138 ret = devm_gpio_request(&pdev->dev, gpio->io, gpio->name);
139 if (ret) {
140 LOG("Failed to get %s gpio.\n", gpio->name);
141 return -1;
142 }
143 }
144
145 return 0;
146 }
147
rfkill_rk_setup_wake_irq(struct rfkill_rk_data * rfkill,int flag)148 static int rfkill_rk_setup_wake_irq(struct rfkill_rk_data *rfkill, int flag)
149 {
150 int ret = 0;
151 struct rfkill_rk_irq *irq = &rfkill->pdata->wake_host_irq;
152
153 if (!flag) {
154 rfkill->irq_req = 0;
155 ret = rfkill_rk_setup_gpio(rfkill->pdev, &irq->gpio,
156 rfkill->pdata->name, "wake_host");
157 if (ret)
158 goto fail1;
159 }
160 if (gpio_is_valid(irq->gpio.io)) {
161 if (rfkill->irq_req) {
162 rfkill->irq_req = 0;
163 free_irq(irq->irq, rfkill);
164 }
165 LOG("Request irq for bt wakeup host\n");
166 irq->irq = gpio_to_irq(irq->gpio.io);
167 sprintf(irq->name, "%s_irq", irq->gpio.name);
168 ret = request_irq(irq->irq, rfkill_rk_wake_host_irq,
169 (irq->gpio.enable == GPIO_ACTIVE_LOW) ?
170 IRQF_TRIGGER_FALLING :
171 IRQF_TRIGGER_RISING,
172 irq->name, rfkill);
173 if (ret)
174 goto fail2;
175 rfkill->irq_req = 1;
176 LOG("** disable irq\n");
177 disable_irq(irq->irq);
178 ret = enable_irq_wake(irq->irq);
179 if (ret)
180 goto fail3;
181 }
182
183 return ret;
184
185 fail3:
186 free_irq(irq->irq, rfkill);
187 fail2:
188 gpio_free(irq->gpio.io);
189 fail1:
190 return ret;
191 }
192
rfkill_rk_sleep_bt_internal(struct rfkill_rk_data * rfkill,bool sleep)193 static inline void rfkill_rk_sleep_bt_internal(struct rfkill_rk_data *rfkill,
194 bool sleep)
195 {
196 struct rfkill_rk_gpio *wake = &rfkill->pdata->wake_gpio;
197
198 DBG("*** bt sleep: %d ***\n", sleep);
199 #ifndef CONFIG_BK3515A_COMBO
200 gpio_direction_output(wake->io, sleep ? !wake->enable : wake->enable);
201 #else
202 if (!sleep) {
203 DBG("HOST_UART0_TX pull down 10us\n");
204 if (rfkill_rk_setup_gpio(rfkill->pdev, wake,
205 rfkill->pdata->name, "wake") != 0) {
206 return;
207 }
208
209 gpio_direction_output(wake->io, wake->enable);
210 usleep_range(10, 20);
211 gpio_direction_output(wake->io, !wake->enable);
212
213 gpio_free(wake->io);
214 }
215 #endif
216 }
217
rfkill_rk_delay_sleep_bt(struct work_struct * work)218 static void rfkill_rk_delay_sleep_bt(struct work_struct *work)
219 {
220 struct rfkill_rk_data *rfkill = NULL;
221
222 DBG("Enter %s\n", __func__);
223
224 rfkill = container_of(work, struct rfkill_rk_data,
225 bt_sleep_delay_work.work);
226
227 rfkill_rk_sleep_bt_internal(rfkill, BT_SLEEP);
228 }
229
rfkill_rk_sleep_bt(bool sleep)230 void rfkill_rk_sleep_bt(bool sleep)
231 {
232 struct rfkill_rk_data *rfkill = g_rfkill;
233 struct rfkill_rk_gpio *wake;
234
235 DBG("Enter %s\n", __func__);
236
237 if (!rfkill) {
238 LOG("*** RFKILL is empty???\n");
239 return;
240 }
241
242 wake = &rfkill->pdata->wake_gpio;
243 if (!gpio_is_valid(wake->io)) {
244 DBG("*** Not support bt wakeup and sleep\n");
245 return;
246 }
247
248 cancel_delayed_work_sync(&rfkill->bt_sleep_delay_work);
249
250 rfkill_rk_sleep_bt_internal(rfkill, sleep);
251
252 #ifdef CONFIG_BT_AUTOSLEEP
253 if (sleep == BT_WAKEUP) {
254 schedule_delayed_work(&rfkill->bt_sleep_delay_work,
255 msecs_to_jiffies(BT_WAKEUP_TIMEOUT));
256 }
257 #endif
258 }
259 EXPORT_SYMBOL(rfkill_rk_sleep_bt);
260
261 static int bt_power_state = 0;
rfkill_get_bt_power_state(int * power,bool * toggle)262 int rfkill_get_bt_power_state(int *power, bool *toggle)
263 {
264 struct rfkill_rk_data *mrfkill = g_rfkill;
265
266 if (!mrfkill) {
267 LOG("%s: rfkill-bt driver has not Successful initialized\n",
268 __func__);
269 return -1;
270 }
271
272 *toggle = mrfkill->pdata->power_toggle;
273 *power = bt_power_state;
274
275 return 0;
276 }
277
rfkill_rk_set_power(void * data,bool blocked)278 static int rfkill_rk_set_power(void *data, bool blocked)
279 {
280 struct rfkill_rk_data *rfkill = data;
281 struct rfkill_rk_gpio *wake_host = &rfkill->pdata->wake_host_irq.gpio;
282 struct rfkill_rk_gpio *poweron = &rfkill->pdata->poweron_gpio;
283 struct rfkill_rk_gpio *reset = &rfkill->pdata->reset_gpio;
284 struct rfkill_rk_gpio *rts = &rfkill->pdata->rts_gpio;
285 struct pinctrl *pinctrl = rfkill->pdata->pinctrl;
286 int wifi_power = 0;
287 bool toggle = false;
288
289 DBG("Enter %s\n", __func__);
290
291 DBG("Set blocked:%d\n", blocked);
292
293 toggle = rfkill->pdata->power_toggle;
294
295 if (toggle) {
296 if (rfkill_get_wifi_power_state(&wifi_power)) {
297 LOG("%s: cannot get wifi power state!\n", __func__);
298 return -1;
299 }
300 }
301
302 DBG("%s: toggle = %s\n", __func__, toggle ? "true" : "false");
303
304 if (!blocked) {
305 if (toggle) {
306 rfkill_set_wifi_bt_power(1);
307 msleep(100);
308 }
309
310 rfkill_rk_sleep_bt(BT_WAKEUP); // ensure bt is wakeup
311
312 if (gpio_is_valid(wake_host->io)) {
313 LOG("%s: set bt wake_host high!\n", __func__);
314 gpio_direction_output(wake_host->io, 1);
315 msleep(20);
316 }
317
318 if (gpio_is_valid(poweron->io)) {
319 if (gpio_get_value(poweron->io) == !poweron->enable) {
320 gpio_direction_output(poweron->io,
321 !poweron->enable);
322 msleep(20);
323 gpio_direction_output(poweron->io,
324 poweron->enable);
325 msleep(20);
326 if (gpio_is_valid(wake_host->io))
327 gpio_direction_input(wake_host->io);
328 }
329 }
330
331 if (gpio_is_valid(reset->io)) {
332 if (gpio_get_value(reset->io) == !reset->enable) {
333 gpio_direction_output(reset->io,
334 !reset->enable);
335 msleep(20);
336 gpio_direction_output(reset->io, reset->enable);
337 }
338 }
339
340 if (pinctrl && gpio_is_valid(rts->io)) {
341 pinctrl_select_state(pinctrl, rts->gpio_state);
342 LOG("ENABLE UART_RTS\n");
343 gpio_direction_output(rts->io, rts->enable);
344 msleep(100);
345 LOG("DISABLE UART_RTS\n");
346 gpio_direction_output(rts->io, !rts->enable);
347 pinctrl_select_state(pinctrl, rts->default_state);
348 }
349
350 bt_power_state = 1;
351 LOG("bt turn on power\n");
352 rfkill_rk_setup_wake_irq(rfkill, 1);
353 } else {
354 if (gpio_is_valid(poweron->io)) {
355 if (gpio_get_value(poweron->io) == poweron->enable) {
356 gpio_direction_output(poweron->io,
357 !poweron->enable);
358 msleep(20);
359 }
360 }
361
362 bt_power_state = 0;
363 LOG("bt shut off power\n");
364 if (gpio_is_valid(reset->io)) {
365 if (gpio_get_value(reset->io) == reset->enable) {
366 gpio_direction_output(reset->io,
367 !reset->enable);
368 msleep(20);
369 }
370 }
371 if (toggle) {
372 if (!wifi_power) {
373 LOG("%s: bt will set vbat to low\n", __func__);
374 rfkill_set_wifi_bt_power(0);
375 } else {
376 LOG("%s: bt shouldn't control the vbat\n", __func__);
377 }
378 }
379 }
380
381 return 0;
382 }
383
rfkill_rk_pm_prepare(struct device * dev)384 static int rfkill_rk_pm_prepare(struct device *dev)
385 {
386 struct rfkill_rk_data *rfkill = g_rfkill;
387 struct rfkill_rk_gpio *rts;
388 struct rfkill_rk_irq *wake_host_irq;
389
390 DBG("Enter %s\n", __func__);
391
392 if (!rfkill)
393 return 0;
394
395 rts = &rfkill->pdata->rts_gpio;
396 wake_host_irq = &rfkill->pdata->wake_host_irq;
397
398 //To prevent uart to receive bt data when suspended
399 if (rfkill->pdata->pinctrl && gpio_is_valid(rts->io)) {
400 DBG("Disable UART_RTS\n");
401 pinctrl_select_state(rfkill->pdata->pinctrl, rts->gpio_state);
402 gpio_direction_output(rts->io, !rts->enable);
403 }
404
405 #ifdef CONFIG_BT_AUTOSLEEP
406 rfkill_rk_sleep_bt(BT_SLEEP);
407 #endif
408
409 // enable bt wakeup host
410 if (gpio_is_valid(wake_host_irq->gpio.io) && bt_power_state) {
411 DBG("enable irq for bt wakeup host\n");
412 enable_irq(wake_host_irq->irq);
413 }
414
415 #ifdef CONFIG_RFKILL_RESET
416 rfkill_init_sw_state(rfkill->rfkill_dev, BT_BLOCKED);
417 rfkill_set_sw_state(rfkill->rfkill_dev, BT_BLOCKED);
418 rfkill_set_hw_state(rfkill->rfkill_dev, false);
419 rfkill_rk_set_power(rfkill, BT_BLOCKED);
420 #endif
421
422 return 0;
423 }
424
rfkill_rk_pm_complete(struct device * dev)425 static void rfkill_rk_pm_complete(struct device *dev)
426 {
427 struct rfkill_rk_data *rfkill = g_rfkill;
428 struct rfkill_rk_irq *wake_host_irq;
429 struct rfkill_rk_gpio *rts;
430
431 DBG("Enter %s\n", __func__);
432
433 if (!rfkill)
434 return;
435
436 wake_host_irq = &rfkill->pdata->wake_host_irq;
437 rts = &rfkill->pdata->rts_gpio;
438
439 if (gpio_is_valid(wake_host_irq->gpio.io) && bt_power_state) {
440 LOG("** disable irq\n");
441 disable_irq(wake_host_irq->irq);
442 }
443
444 if (rfkill->pdata->pinctrl && gpio_is_valid(rts->io)) {
445 DBG("Enable UART_RTS\n");
446 gpio_direction_output(rts->io, rts->enable);
447 pinctrl_select_state(rfkill->pdata->pinctrl, rts->default_state);
448 }
449 }
450
451 static const struct rfkill_ops rfkill_rk_ops = {
452 .set_block = rfkill_rk_set_power,
453 };
454
455 #define PROC_DIR "bluetooth/sleep"
456
457 static struct proc_dir_entry *bluetooth_dir, *sleep_dir;
458
bluesleep_read_proc_lpm(struct file * file,char __user * buffer,size_t count,loff_t * data)459 static ssize_t bluesleep_read_proc_lpm(struct file *file, char __user *buffer,
460 size_t count, loff_t *data)
461 {
462 return sprintf(buffer, "unsupported to read\n");
463 }
464
bluesleep_write_proc_lpm(struct file * file,const char __user * buffer,size_t count,loff_t * data)465 static ssize_t bluesleep_write_proc_lpm(struct file *file,
466 const char __user *buffer, size_t count,
467 loff_t *data)
468 {
469 return count;
470 }
471
bluesleep_read_proc_btwrite(struct file * file,char __user * buffer,size_t count,loff_t * data)472 static ssize_t bluesleep_read_proc_btwrite(struct file *file,
473 char __user *buffer, size_t count,
474 loff_t *data)
475 {
476 return sprintf(buffer, "unsupported to read\n");
477 }
478
bluesleep_write_proc_btwrite(struct file * file,const char __user * buffer,size_t count,loff_t * data)479 static ssize_t bluesleep_write_proc_btwrite(struct file *file,
480 const char __user *buffer,
481 size_t count, loff_t *data)
482 {
483 char b;
484
485 if (count < 1)
486 return -EINVAL;
487
488 if (copy_from_user(&b, buffer, 1))
489 return -EFAULT;
490
491 DBG("btwrite %c\n", b);
492 /* HCI_DEV_WRITE */
493 if (b != '0')
494 rfkill_rk_sleep_bt(BT_WAKEUP);
495 else
496 rfkill_rk_sleep_bt(BT_SLEEP);
497
498 return count;
499 }
500
501 #ifdef CONFIG_OF
bluetooth_platdata_parse_dt(struct device * dev,struct rfkill_rk_platform_data * data)502 static int bluetooth_platdata_parse_dt(struct device *dev,
503 struct rfkill_rk_platform_data *data)
504 {
505 struct device_node *node = dev->of_node;
506 int gpio;
507 enum of_gpio_flags flags;
508
509 if (!node)
510 return -ENODEV;
511
512 memset(data, 0, sizeof(*data));
513
514 if (of_find_property(node, "wifi-bt-power-toggle", NULL)) {
515 data->power_toggle = true;
516 LOG("%s: get property wifi-bt-power-toggle.\n", __func__);
517 } else {
518 data->power_toggle = false;
519 }
520
521 gpio = of_get_named_gpio_flags(node, "uart_rts_gpios", 0, &flags);
522 if (gpio_is_valid(gpio)) {
523 data->rts_gpio.io = gpio;
524 data->rts_gpio.enable = (flags == GPIO_ACTIVE_HIGH) ? 1 : 0;
525 LOG("%s: get property: uart_rts_gpios = %d.\n", __func__, gpio);
526 data->pinctrl = devm_pinctrl_get(dev);
527 if (!IS_ERR(data->pinctrl)) {
528 data->rts_gpio.default_state =
529 pinctrl_lookup_state(data->pinctrl, "default");
530 data->rts_gpio.gpio_state =
531 pinctrl_lookup_state(data->pinctrl, "rts_gpio");
532 } else {
533 data->pinctrl = NULL;
534 LOG("%s: dts does't define the uart rts iomux.\n",
535 __func__);
536 return -EINVAL;
537 }
538 } else {
539 data->pinctrl = NULL;
540 data->rts_gpio.io = -EINVAL;
541 LOG("%s: uart_rts_gpios is no-in-use.\n", __func__);
542 }
543
544 gpio = of_get_named_gpio_flags(node, "BT,power_gpio", 0, &flags);
545 if (gpio_is_valid(gpio)) {
546 data->poweron_gpio.io = gpio;
547 data->poweron_gpio.enable = (flags == GPIO_ACTIVE_HIGH) ? 1 : 0;
548 LOG("%s: get property: BT,power_gpio = %d.\n", __func__, gpio);
549 } else {
550 data->poweron_gpio.io = -1;
551 }
552 gpio = of_get_named_gpio_flags(node, "BT,reset_gpio", 0, &flags);
553 if (gpio_is_valid(gpio)) {
554 data->reset_gpio.io = gpio;
555 data->reset_gpio.enable = (flags == GPIO_ACTIVE_HIGH) ? 1 : 0;
556 LOG("%s: get property: BT,reset_gpio = %d.\n", __func__, gpio);
557 } else {
558 data->reset_gpio.io = -1;
559 }
560 gpio = of_get_named_gpio_flags(node, "BT,wake_gpio", 0, &flags);
561 if (gpio_is_valid(gpio)) {
562 data->wake_gpio.io = gpio;
563 data->wake_gpio.enable = (flags == GPIO_ACTIVE_HIGH) ? 1 : 0;
564 LOG("%s: get property: BT,wake_gpio = %d.\n", __func__, gpio);
565 } else {
566 data->wake_gpio.io = -1;
567 }
568 gpio = of_get_named_gpio_flags(node, "BT,wake_host_irq", 0, &flags);
569 if (gpio_is_valid(gpio)) {
570 data->wake_host_irq.gpio.io = gpio;
571 data->wake_host_irq.gpio.enable = flags;
572 LOG("%s: get property: BT,wake_host_irq = %d.\n", __func__,
573 gpio);
574 } else {
575 data->wake_host_irq.gpio.io = -1;
576 }
577
578 data->ext_clk = devm_clk_get(dev, "ext_clock");
579 if (IS_ERR(data->ext_clk)) {
580 LOG("%s: clk_get failed!!!.\n", __func__);
581 } else {
582 clk_prepare_enable(data->ext_clk);
583 }
584 return 0;
585 }
586 #endif //CONFIG_OF
587
588 static const struct proc_ops bluesleep_lpm = {
589 .proc_read = bluesleep_read_proc_lpm,
590 .proc_write = bluesleep_write_proc_lpm,
591 };
592
593 static const struct proc_ops bluesleep_btwrite = {
594 .proc_read = bluesleep_read_proc_btwrite,
595 .proc_write = bluesleep_write_proc_btwrite,
596 };
597
rfkill_rk_probe(struct platform_device * pdev)598 static int rfkill_rk_probe(struct platform_device *pdev)
599 {
600 struct rfkill_rk_data *rfkill;
601 struct rfkill_rk_platform_data *pdata = pdev->dev.platform_data;
602 int ret = 0;
603 struct proc_dir_entry *ent;
604
605 DBG("Enter %s\n", __func__);
606
607 if (!pdata) {
608 #ifdef CONFIG_OF
609 pdata = devm_kzalloc(&pdev->dev,
610 sizeof(struct rfkill_rk_platform_data),
611 GFP_KERNEL);
612 if (!pdata)
613 return -ENOMEM;
614
615 ret = bluetooth_platdata_parse_dt(&pdev->dev, pdata);
616 if (ret < 0) {
617 #endif
618 LOG("%s: No platform data specified\n", __func__);
619 return ret;
620 #ifdef CONFIG_OF
621 }
622 #endif
623 }
624
625 pdata->name = (char *)bt_name;
626 pdata->type = RFKILL_TYPE_BLUETOOTH;
627
628 rfkill = devm_kzalloc(&pdev->dev, sizeof(*rfkill), GFP_KERNEL);
629 if (!rfkill)
630 return -ENOMEM;
631
632 rfkill->pdata = pdata;
633 rfkill->pdev = pdev;
634 g_rfkill = rfkill;
635
636 bluetooth_dir = proc_mkdir("bluetooth", NULL);
637 if (!bluetooth_dir) {
638 LOG("Unable to create /proc/bluetooth directory");
639 return -ENOMEM;
640 }
641
642 sleep_dir = proc_mkdir("sleep", bluetooth_dir);
643 if (!sleep_dir) {
644 LOG("Unable to create /proc/%s directory", PROC_DIR);
645 return -ENOMEM;
646 }
647
648 /* read/write proc entries */
649 ent = proc_create("lpm", 0444, sleep_dir, &bluesleep_lpm);
650 if (!ent) {
651 LOG("Unable to create /proc/%s/lpm entry", PROC_DIR);
652 ret = -ENOMEM;
653 goto fail_alloc;
654 }
655
656 /* read/write proc entries */
657 ent = proc_create("btwrite", 0444, sleep_dir, &bluesleep_btwrite);
658 if (!ent) {
659 LOG("Unable to create /proc/%s/btwrite entry", PROC_DIR);
660 ret = -ENOMEM;
661 goto fail_alloc;
662 }
663
664 DBG("init gpio\n");
665
666 ret = rfkill_rk_setup_gpio(pdev, &pdata->poweron_gpio, pdata->name,
667 "poweron");
668 if (ret)
669 goto fail_gpio;
670
671 ret = rfkill_rk_setup_gpio(pdev, &pdata->reset_gpio, pdata->name,
672 "reset");
673 if (ret)
674 goto fail_gpio;
675
676 ret = rfkill_rk_setup_gpio(pdev, &pdata->wake_gpio, pdata->name,
677 "wake");
678 if (ret)
679 goto fail_gpio;
680
681 ret = rfkill_rk_setup_gpio(pdev, &pdata->rts_gpio, rfkill->pdata->name,
682 "rts");
683 if (ret)
684 goto fail_gpio;
685
686 wake_lock_init(&rfkill->bt_irq_wl, WAKE_LOCK_SUSPEND,
687 "rfkill_rk_irq_wl");
688
689 ret = rfkill_rk_setup_wake_irq(rfkill, 0);
690 if (ret)
691 goto fail_setup_wake_irq;
692
693 DBG("setup rfkill\n");
694 rfkill->rfkill_dev = rfkill_alloc(pdata->name, &pdev->dev, pdata->type,
695 &rfkill_rk_ops, rfkill);
696 if (!rfkill->rfkill_dev)
697 goto fail_alloc;
698
699 rfkill_init_sw_state(rfkill->rfkill_dev, BT_BLOCKED);
700 rfkill_set_sw_state(rfkill->rfkill_dev, BT_BLOCKED);
701 rfkill_set_hw_state(rfkill->rfkill_dev, false);
702 ret = rfkill_register(rfkill->rfkill_dev);
703 if (ret < 0)
704 goto fail_rfkill;
705
706 INIT_DELAYED_WORK(&rfkill->bt_sleep_delay_work,
707 rfkill_rk_delay_sleep_bt);
708
709 //rfkill_rk_set_power(rfkill, BT_BLOCKED);
710 // bt turn off power
711 if (gpio_is_valid(pdata->poweron_gpio.io)) {
712 gpio_direction_output(pdata->poweron_gpio.io,
713 !pdata->poweron_gpio.enable);
714 }
715 if (gpio_is_valid(pdata->reset_gpio.io)) {
716 gpio_direction_output(pdata->reset_gpio.io,
717 !pdata->reset_gpio.enable);
718 }
719
720 platform_set_drvdata(pdev, rfkill);
721
722 LOG("%s device registered.\n", pdata->name);
723
724 return 0;
725
726 fail_rfkill:
727 rfkill_destroy(rfkill->rfkill_dev);
728 fail_alloc:
729
730 remove_proc_entry("btwrite", sleep_dir);
731 remove_proc_entry("lpm", sleep_dir);
732 fail_setup_wake_irq:
733 wake_lock_destroy(&rfkill->bt_irq_wl);
734 fail_gpio:
735
736 g_rfkill = NULL;
737 return ret;
738 }
739
rfkill_rk_remove(struct platform_device * pdev)740 static int rfkill_rk_remove(struct platform_device *pdev)
741 {
742 struct rfkill_rk_data *rfkill = platform_get_drvdata(pdev);
743
744 LOG("Enter %s\n", __func__);
745
746 rfkill_unregister(rfkill->rfkill_dev);
747 rfkill_destroy(rfkill->rfkill_dev);
748
749 cancel_delayed_work_sync(&rfkill->bt_sleep_delay_work);
750
751 // free gpio
752 if (gpio_is_valid(rfkill->pdata->rts_gpio.io))
753 gpio_free(rfkill->pdata->rts_gpio.io);
754
755 if (gpio_is_valid(rfkill->pdata->wake_host_irq.gpio.io)) {
756 free_irq(rfkill->pdata->wake_host_irq.irq, rfkill);
757 #ifndef CONFIG_BK3515A_COMBO
758 gpio_free(rfkill->pdata->wake_host_irq.gpio.io);
759 #endif
760 }
761
762 #ifndef CONFIG_BK3515A_COMBO
763 if (gpio_is_valid(rfkill->pdata->wake_gpio.io))
764 gpio_free(rfkill->pdata->wake_gpio.io);
765 #endif
766
767 if (gpio_is_valid(rfkill->pdata->reset_gpio.io))
768 gpio_free(rfkill->pdata->reset_gpio.io);
769
770 if (gpio_is_valid(rfkill->pdata->poweron_gpio.io))
771 gpio_free(rfkill->pdata->poweron_gpio.io);
772 clk_disable_unprepare(rfkill->pdata->ext_clk);
773 wake_lock_destroy(&rfkill->bt_irq_wl);
774 g_rfkill = NULL;
775
776 return 0;
777 }
778
779 static const struct dev_pm_ops rfkill_rk_pm_ops = {
780 .prepare = rfkill_rk_pm_prepare,
781 .complete = rfkill_rk_pm_complete,
782 };
783
784 #ifdef CONFIG_OF
785 static struct of_device_id bt_platdata_of_match[] = {
786 { .compatible = "bluetooth-platdata" },
787 {}
788 };
789 MODULE_DEVICE_TABLE(of, bt_platdata_of_match);
790 #endif //CONFIG_OF
791
792 static struct platform_driver rfkill_rk_driver = {
793 .probe = rfkill_rk_probe,
794 .remove = rfkill_rk_remove,
795 .driver = {
796 .name = "rfkill_bt",
797 .owner = THIS_MODULE,
798 .pm = &rfkill_rk_pm_ops,
799 .of_match_table = of_match_ptr(bt_platdata_of_match),
800 },
801 };
802
rfkill_rk_init(void)803 static int __init rfkill_rk_init(void)
804 {
805 int err;
806
807 LOG("Enter %s\n", __func__);
808 err = rfkill_wlan_init();
809 if (err)
810 return err;
811 return platform_driver_register(&rfkill_rk_driver);
812 }
813
rfkill_rk_exit(void)814 static void __exit rfkill_rk_exit(void)
815 {
816 LOG("Enter %s\n", __func__);
817 platform_driver_unregister(&rfkill_rk_driver);
818 rfkill_wlan_exit();
819 }
820
821 module_init(rfkill_rk_init);
822 module_exit(rfkill_rk_exit);
823
824 MODULE_DESCRIPTION("rock-chips rfkill for Bluetooth v0.3");
825 MODULE_AUTHOR("cmy@rock-chips.com, gwl@rock-chips.com");
826 MODULE_LICENSE("GPL");
827