11e182882365f342c880bb8e2ee5e5c407f6ea3f
[firefly-linux-kernel-4.4.55.git] / net / rfkill / rfkill-bt.c
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...)   printk(KERN_INFO "[BT_RFKILL]: "x)
45 #else
46 #define DBG(x...)
47 #endif
48
49 #define LOG(x...)   printk(KERN_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 };
72
73 static struct rfkill_rk_data *g_rfkill = NULL;
74
75 static const char bt_name[] = 
76 #if defined (CONFIG_BCM4330)
77     #if defined (CONFIG_BT_MODULE_NH660)
78         "nh660"
79     #else
80         "bcm4330"
81     #endif
82 #elif defined (CONFIG_RK903)
83     #if defined(CONFIG_RKWIFI_26M)
84         "rk903_26M"
85     #else
86         "rk903"
87     #endif
88 #elif defined(CONFIG_BCM4329)
89         "bcm4329"
90 #elif defined(CONFIG_MV8787)
91         "mv8787"
92 #elif defined(CONFIG_AP6210)
93     #if defined(CONFIG_RKWIFI_26M)
94         "ap6210"
95     #else
96         "ap6210_24M"
97     #endif
98 #elif defined(CONFIG_AP6330)
99                 "ap6330"
100 #elif defined(CONFIG_AP6476)
101                 "ap6476"
102 #elif defined(CONFIG_AP6493)
103                 "ap6493"
104 #elif defined(CONFIG_AP6441)
105         "ap6441"
106 #elif defined(CONFIG_AP6335)
107         "ap6335"
108 #elif defined(CONFIG_GB86302I)
109         "gb86302i"
110 #else
111         "bt_default"
112 #endif
113 ;
114
115 static irqreturn_t rfkill_rk_wake_host_irq(int irq, void *dev)
116 {
117     struct rfkill_rk_data *rfkill = dev;
118     LOG("BT_WAKE_HOST IRQ fired\n");
119     
120     DBG("BT IRQ wakeup, request %dms wakelock\n", BT_IRQ_WAKELOCK_TIMEOUT);
121
122     wake_lock_timeout(&rfkill->bt_irq_wl, 
123                     msecs_to_jiffies(BT_IRQ_WAKELOCK_TIMEOUT));
124     
125         return IRQ_HANDLED;
126 }
127
128 static int rfkill_rk_setup_gpio(struct platform_device *pdev, struct rfkill_rk_gpio* gpio, 
129         const char* prefix, const char* name)
130 {
131         if (gpio_is_valid(gpio->io)) {
132         int ret=0;
133         sprintf(gpio->name, "%s_%s", prefix, name);
134                 ret = devm_gpio_request(&pdev->dev, gpio->io, gpio->name);
135                 if (ret) {
136                         LOG("Failed to get %s gpio.\n", gpio->name);
137                         return -1;
138                 }
139         }
140
141     return 0;
142 }
143
144 static int rfkill_rk_setup_wake_irq(struct rfkill_rk_data* rfkill)
145 {
146     int ret=0;
147     struct rfkill_rk_irq* irq = &(rfkill->pdata->wake_host_irq);
148     
149     ret = rfkill_rk_setup_gpio(rfkill->pdev, &irq->gpio, rfkill->pdata->name, "wake_host");
150     if (ret) goto fail1;
151     if (gpio_is_valid(irq->gpio.io))
152     {
153         //ret = gpio_pull_updown(irq->gpio.io, (irq->gpio.enable==GPIO_ACTIVE_LOW)?GPIOPullUp:GPIOPullDown);
154         //if (ret) goto fail2;
155         LOG("Request irq for bt wakeup host\n");
156         irq->irq = gpio_to_irq(irq->gpio.io);
157         sprintf(irq->name, "%s_irq", irq->gpio.name);
158         ret = request_irq(irq->irq,
159                     rfkill_rk_wake_host_irq,
160                     (irq->gpio.enable==GPIO_ACTIVE_LOW)?IRQF_TRIGGER_FALLING:IRQF_TRIGGER_RISING,
161                     irq->name,
162                     rfkill);
163         if (ret) goto fail2;
164         LOG("** disable irq\n");
165         disable_irq(irq->irq);
166         ret = enable_irq_wake(irq->irq);
167         if (ret) goto fail3;
168     }
169
170     return ret;
171
172 fail3:
173     free_irq(irq->gpio.io, rfkill);
174 fail2:
175     gpio_free(irq->gpio.io);
176 fail1:
177     return ret;
178 }
179
180 static inline void rfkill_rk_sleep_bt_internal(struct rfkill_rk_data *rfkill, bool sleep)
181 {
182     struct rfkill_rk_gpio *wake = &rfkill->pdata->wake_gpio;
183     
184     DBG("*** bt sleep: %d ***\n", sleep);
185 #ifndef CONFIG_BK3515A_COMBO
186     gpio_direction_output(wake->io, sleep?!wake->enable:wake->enable);
187 #else
188     if(!sleep)
189     {
190         DBG("HOST_UART0_TX pull down 10us\n");
191         if (rfkill_rk_setup_gpio(rfkill->pdev, wake, rfkill->pdata->name, "wake") != 0) {
192             return;
193         }
194
195         gpio_direction_output(wake->io, wake->enable);
196         udelay(10);
197         gpio_direction_output(wake->io, !wake->enable);
198
199         gpio_free(wake->io);
200     }
201 #endif
202 }
203
204 static void rfkill_rk_delay_sleep_bt(struct work_struct *work)
205 {
206     struct rfkill_rk_data *rfkill = NULL;
207     DBG("Enter %s\n",__FUNCTION__);
208
209     rfkill = container_of(work, struct rfkill_rk_data, bt_sleep_delay_work.work);
210
211     rfkill_rk_sleep_bt_internal(rfkill, BT_SLEEP);
212 }
213
214 void rfkill_rk_sleep_bt(bool sleep)
215 {
216     struct rfkill_rk_data *rfkill = g_rfkill;
217     struct rfkill_rk_gpio *wake;
218     bool ret;
219     DBG("Enter %s\n",__FUNCTION__);
220     
221     if (rfkill==NULL)
222     {
223         LOG("*** RFKILL is empty???\n");
224         return;
225     }
226
227     wake = &rfkill->pdata->wake_gpio;
228     if (!gpio_is_valid(wake->io))
229     {
230         DBG("*** Not support bt wakeup and sleep\n");
231         return;
232     }
233
234     ret = cancel_delayed_work_sync(&rfkill->bt_sleep_delay_work);
235
236     rfkill_rk_sleep_bt_internal(rfkill, sleep);
237
238 #ifdef CONFIG_BT_AUTOSLEEP
239     if (sleep==BT_WAKEUP)
240     {
241         schedule_delayed_work(&rfkill->bt_sleep_delay_work, 
242                             msecs_to_jiffies(BT_WAKEUP_TIMEOUT));
243     }
244 #endif
245 }
246 EXPORT_SYMBOL(rfkill_rk_sleep_bt);
247
248 static int bt_power_state = 0;
249 int rfkill_get_bt_power_state(int *power, bool *toggle)
250 {
251     struct rfkill_rk_data *mrfkill = g_rfkill;
252
253     if (mrfkill == NULL) {
254         LOG("%s: rfkill-bt driver has not Successful initialized\n", __func__);
255         return -1;
256     }
257
258     *toggle = mrfkill->pdata->power_toggle;
259     *power = bt_power_state;
260
261     return 0;
262 }
263
264 static int rfkill_rk_set_power(void *data, bool blocked)
265 {
266         struct rfkill_rk_data *rfkill = data;
267     struct rfkill_rk_gpio *poweron = &rfkill->pdata->poweron_gpio;
268     struct rfkill_rk_gpio *reset = &rfkill->pdata->reset_gpio;
269     struct rfkill_rk_gpio* rts = &rfkill->pdata->rts_gpio;
270     struct pinctrl *pinctrl = rfkill->pdata->pinctrl;
271     int power = 0, vref_ctrl_enable = 0;
272     bool toggle = false;
273
274     DBG("Enter %s\n", __func__);
275
276     DBG("Set blocked:%d\n", blocked);
277
278     toggle = rfkill->pdata->power_toggle;
279     if (!rfkill_get_wifi_power_state(&power, &vref_ctrl_enable)) {
280         if (true == toggle && 1 == power) {
281             LOG("%s: bt shouldn't control the power, it was enabled by wifi!\n", __func__);
282             return 0;
283         }
284     } else {
285         LOG("%s: cannot get wifi power state!\n", __func__);
286         return -1;
287     }
288
289         if (false == blocked) { 
290
291         rfkill_rk_sleep_bt(BT_WAKEUP); // ensure bt is wakeup
292
293                 if (gpio_is_valid(poweron->io))
294         {
295                         gpio_direction_output(poweron->io, !poweron->enable);
296             msleep(20);
297                         gpio_direction_output(poweron->io, poweron->enable);
298             msleep(20);
299         }
300                 if (gpio_is_valid(reset->io))
301         {
302                         gpio_direction_output(reset->io, !reset->enable);
303             msleep(20);
304                         gpio_direction_output(reset->io, reset->enable);
305         }
306
307         if (pinctrl != NULL && gpio_is_valid(rts->io))
308         {
309             pinctrl_select_state(pinctrl, rts->gpio_state);
310             LOG("ENABLE UART_RTS\n");
311             gpio_direction_output(rts->io, rts->enable);
312             msleep(100);
313             LOG("DISABLE UART_RTS\n");
314             gpio_direction_output(rts->io, !rts->enable);
315             pinctrl_select_state(pinctrl, rts->default_state);
316         }
317
318         bt_power_state = 1;
319         LOG("bt turn on power\n");
320         } else {
321             if (gpio_is_valid(poweron->io))
322             {      
323                 gpio_direction_output(poweron->io, !poweron->enable);
324                 msleep(20);
325             }
326
327             bt_power_state = 0;
328                 LOG("bt shut off power\n");
329                 if (gpio_is_valid(reset->io))
330         {      
331                         gpio_direction_output(reset->io, !reset->enable);/* bt reset active*/
332             msleep(20);
333         }
334
335         }
336
337         return 0;
338 }
339
340 static int rfkill_rk_pm_prepare(struct device *dev)
341 {
342     struct rfkill_rk_data *rfkill = g_rfkill;
343     struct rfkill_rk_gpio* rts;
344     struct rfkill_rk_irq*  wake_host_irq;
345     struct pinctrl *pinctrl = rfkill->pdata->pinctrl;
346
347     DBG("Enter %s\n",__FUNCTION__);
348
349     if (!rfkill)
350         return 0;
351
352     rts = &rfkill->pdata->rts_gpio;
353     wake_host_irq = &rfkill->pdata->wake_host_irq;
354
355     //To prevent uart to receive bt data when suspended
356     if (pinctrl != NULL && gpio_is_valid(rts->io))
357     {
358         DBG("Disable UART_RTS\n");
359         pinctrl_select_state(pinctrl, rts->gpio_state);
360         gpio_direction_output(rts->io, !rts->enable);
361     }
362
363 #ifdef CONFIG_BT_AUTOSLEEP
364     rfkill_rk_sleep_bt(BT_SLEEP);
365 #endif
366
367     // enable bt wakeup host
368     if (gpio_is_valid(wake_host_irq->gpio.io))
369     {
370         DBG("enable irq for bt wakeup host\n");
371         enable_irq(wake_host_irq->irq);
372     }
373
374 #ifdef CONFIG_RFKILL_RESET
375     rfkill_set_states(rfkill->rfkill_dev, BT_BLOCKED, false);
376     rfkill_rk_set_power(rfkill, BT_BLOCKED);
377 #endif
378
379     return 0;
380 }
381
382 static void rfkill_rk_pm_complete(struct device *dev)
383 {
384     struct rfkill_rk_data *rfkill = g_rfkill;
385     struct rfkill_rk_irq*  wake_host_irq;
386     struct rfkill_rk_gpio* rts;
387     struct pinctrl *pinctrl = rfkill->pdata->pinctrl;
388
389     DBG("Enter %s\n",__FUNCTION__);
390
391     if (!rfkill)
392         return;
393
394     wake_host_irq = &rfkill->pdata->wake_host_irq;
395     rts = &rfkill->pdata->rts_gpio;
396
397     if (gpio_is_valid(wake_host_irq->gpio.io))
398     {
399         LOG("** disable irq\n");
400         disable_irq(wake_host_irq->irq);
401     }
402
403     if (pinctrl != NULL && gpio_is_valid(rts->io))
404     {
405         DBG("Enable UART_RTS\n");
406         gpio_direction_output(rts->io, rts->enable);
407         pinctrl_select_state(pinctrl, rts->default_state);
408     }
409 }
410
411 static const struct rfkill_ops rfkill_rk_ops = {
412     .set_block = rfkill_rk_set_power,
413 };
414
415 #define PROC_DIR        "bluetooth/sleep"
416
417 static struct proc_dir_entry *bluetooth_dir, *sleep_dir;
418
419 static ssize_t bluesleep_read_proc_lpm(struct file *file, char __user *buffer,
420                                        size_t count, loff_t *data)
421 {
422     return sprintf(buffer, "unsupported to read\n");
423 }
424
425 static ssize_t bluesleep_write_proc_lpm(struct file *file,
426                                         const char __user *buffer,
427                                         size_t count, loff_t *data)
428 {
429     return count;
430 }
431
432 static ssize_t bluesleep_read_proc_btwrite(struct file *file,
433                                            char __user *buffer,
434                                            size_t count, loff_t *data)
435 {
436     return sprintf(buffer, "unsupported to read\n");
437 }
438
439 static ssize_t bluesleep_write_proc_btwrite(struct file *file,
440                                             const char __user *buffer,
441                                             size_t count, loff_t *data)
442 {
443     char b;
444
445     if (count < 1)
446         return -EINVAL;
447
448     if (copy_from_user(&b, buffer, 1))
449         return -EFAULT;
450
451     DBG("btwrite %c\n", b);
452     /* HCI_DEV_WRITE */
453     if (b != '0') {
454         rfkill_rk_sleep_bt(BT_WAKEUP);
455     }
456
457     return count;
458 }
459
460 #ifdef CONFIG_OF
461 static int bluetooth_platdata_parse_dt(struct device *dev,
462                   struct rfkill_rk_platform_data *data)
463 {
464     struct device_node *node = dev->of_node;
465     int gpio;
466     enum of_gpio_flags flags;
467
468     if (!node)
469         return -ENODEV;
470
471     memset(data, 0, sizeof(*data));
472
473     if (of_find_property(node, "wifi-bt-power-toggle", NULL)) {
474         data->power_toggle = true;
475         LOG("%s: get property wifi-bt-power-toggle.\n", __func__);
476     } else {
477         data->power_toggle = false;
478     }
479
480     gpio = of_get_named_gpio_flags(node, "uart_rts_gpios", 0, &flags);
481     if (gpio_is_valid(gpio)) {
482         data->rts_gpio.io = gpio;
483         data->rts_gpio.enable = (flags == GPIO_ACTIVE_HIGH)? 1:0;
484         LOG("%s: get property: uart_rts_gpios = %d.\n", __func__, gpio);
485         data->pinctrl = devm_pinctrl_get(dev);
486         if (!IS_ERR(data->pinctrl)) {
487             data->rts_gpio.default_state = pinctrl_lookup_state(data->pinctrl, "default");
488             data->rts_gpio.gpio_state = pinctrl_lookup_state(data->pinctrl, "rts_gpio");
489         } else {
490             data->pinctrl = NULL;
491             LOG("%s: dts does't define the uart rts iomux.\n", __func__);
492             return -EINVAL;
493         }
494     } else {
495         data->pinctrl = NULL;
496         LOG("%s: uart_rts_gpios is unvalid.\n", __func__);
497         return -EINVAL;
498     }
499
500     gpio = of_get_named_gpio_flags(node, "BT,power_gpio", 0, &flags);
501     if (gpio_is_valid(gpio)){
502         data->poweron_gpio.io = gpio;
503         data->poweron_gpio.enable = (flags == GPIO_ACTIVE_HIGH)? 1:0;
504         LOG("%s: get property: BT,power_gpio = %d.\n", __func__, gpio);
505     } else data->poweron_gpio.io = -1;
506     gpio = of_get_named_gpio_flags(node, "BT,reset_gpio", 0, &flags);
507     if (gpio_is_valid(gpio)){
508         data->reset_gpio.io = gpio;
509         data->reset_gpio.enable = (flags == GPIO_ACTIVE_HIGH)? 1:0;
510         LOG("%s: get property: BT,reset_gpio = %d.\n", __func__, gpio);
511     } else data->reset_gpio.io = -1;
512     gpio = of_get_named_gpio_flags(node, "BT,wake_gpio", 0, &flags);
513     if (gpio_is_valid(gpio)){
514         data->wake_gpio.io = gpio;
515         data->wake_gpio.enable = (flags == GPIO_ACTIVE_HIGH)? 1:0;
516         LOG("%s: get property: BT,wake_gpio = %d.\n", __func__, gpio);
517     } else data->wake_gpio.io = -1;
518     gpio = of_get_named_gpio_flags(node, "BT,wake_host_irq", 0, &flags);
519     if (gpio_is_valid(gpio)) {
520         data->wake_host_irq.gpio.io = gpio;
521         data->wake_host_irq.gpio.enable = flags;
522         LOG("%s: get property: BT,wake_host_irq = %d.\n", __func__, gpio);
523     } else data->wake_host_irq.gpio.io = -1;
524
525     return 0;
526 }
527 #endif //CONFIG_OF
528
529 static const struct file_operations bluesleep_lpm = {
530     .owner = THIS_MODULE,
531     .read = bluesleep_read_proc_lpm,
532     .write = bluesleep_write_proc_lpm,
533 };
534
535 static const struct file_operations bluesleep_btwrite = {
536     .owner = THIS_MODULE,
537     .read = bluesleep_read_proc_btwrite,
538     .write = bluesleep_write_proc_btwrite,
539 };
540
541 static int rfkill_rk_probe(struct platform_device *pdev)
542 {
543         struct rfkill_rk_data *rfkill;
544         struct rfkill_rk_platform_data *pdata = pdev->dev.platform_data;
545         int ret = 0;
546     struct proc_dir_entry *ent;
547
548     DBG("Enter %s\n", __func__);
549
550     if (!pdata) {
551 #ifdef CONFIG_OF
552         pdata = devm_kzalloc(&pdev->dev, sizeof(struct rfkill_rk_platform_data), GFP_KERNEL);
553         if (!pdata)
554             return -ENOMEM;
555
556         ret = bluetooth_platdata_parse_dt(&pdev->dev, pdata);
557         if (ret < 0) {
558 #endif
559             LOG("%s: No platform data specified\n", __func__);
560             return ret;
561 #ifdef CONFIG_OF
562         }
563 #endif
564     }
565
566     pdata->name = (char*)bt_name;
567     pdata->type = RFKILL_TYPE_BLUETOOTH;
568
569         rfkill = devm_kzalloc(&pdev->dev, sizeof(*rfkill), GFP_KERNEL);
570         if (!rfkill)
571                 return -ENOMEM;
572
573         rfkill->pdata = pdata;
574     rfkill->pdev = pdev;
575     g_rfkill = rfkill;
576
577     bluetooth_dir = proc_mkdir("bluetooth", NULL);
578     if (bluetooth_dir == NULL) {
579         LOG("Unable to create /proc/bluetooth directory");
580         return -ENOMEM;
581     }
582
583     sleep_dir = proc_mkdir("sleep", bluetooth_dir);
584     if (sleep_dir == NULL) {
585         LOG("Unable to create /proc/%s directory", PROC_DIR);
586         return -ENOMEM;
587     }
588
589         /* read/write proc entries */
590     ent = proc_create("lpm", 0, sleep_dir, &bluesleep_lpm);
591     if (ent == NULL) {
592         LOG("Unable to create /proc/%s/lpm entry", PROC_DIR);
593         ret = -ENOMEM;
594         goto fail_alloc;
595     }
596
597     /* read/write proc entries */
598     ent = proc_create("btwrite", 0, sleep_dir, &bluesleep_btwrite);
599     if (ent == NULL) {
600         LOG("Unable to create /proc/%s/btwrite entry", PROC_DIR);
601         ret = -ENOMEM;
602         goto fail_alloc;
603     }
604
605     DBG("init gpio\n");
606
607     ret = rfkill_rk_setup_gpio(pdev, &pdata->poweron_gpio, pdata->name, "poweron");
608     if (ret) goto fail_gpio;
609
610     ret = rfkill_rk_setup_gpio(pdev, &pdata->reset_gpio, pdata->name, "reset");
611     if (ret) goto fail_gpio;
612
613     ret = rfkill_rk_setup_gpio(pdev, &pdata->wake_gpio, pdata->name, "wake");
614     if (ret) goto fail_gpio;
615
616     ret = rfkill_rk_setup_gpio(pdev, &pdata->rts_gpio, rfkill->pdata->name, "rts"); 
617     if (ret) goto fail_gpio;
618
619     wake_lock_init(&(rfkill->bt_irq_wl), WAKE_LOCK_SUSPEND, "rfkill_rk_irq_wl");
620
621     ret = rfkill_rk_setup_wake_irq(rfkill);
622     if (ret) goto fail_gpio;
623
624     DBG("setup rfkill\n");
625         rfkill->rfkill_dev = rfkill_alloc(pdata->name, &pdev->dev, pdata->type,
626                                 &rfkill_rk_ops, rfkill);
627         if (!rfkill->rfkill_dev)
628                 goto fail_alloc;
629
630     rfkill_set_states(rfkill->rfkill_dev, BT_BLOCKED, false);
631         ret = rfkill_register(rfkill->rfkill_dev);
632         if (ret < 0)
633                 goto fail_rfkill;
634
635     INIT_DELAYED_WORK(&rfkill->bt_sleep_delay_work, rfkill_rk_delay_sleep_bt);
636
637     //rfkill_rk_set_power(rfkill, BT_BLOCKED);
638     // bt turn off power
639     if (gpio_is_valid(pdata->poweron_gpio.io))
640     {
641         gpio_direction_output(pdata->poweron_gpio.io, !pdata->poweron_gpio.enable);
642     }
643     if (gpio_is_valid(pdata->reset_gpio.io))
644     {
645         gpio_direction_output(pdata->reset_gpio.io, !pdata->reset_gpio.enable);
646     }
647
648         platform_set_drvdata(pdev, rfkill);
649
650     LOG("%s device registered.\n", pdata->name);
651
652         return 0;
653
654 fail_rfkill:
655         rfkill_destroy(rfkill->rfkill_dev);
656 fail_alloc:
657
658         remove_proc_entry("btwrite", sleep_dir);
659         remove_proc_entry("lpm", sleep_dir);
660 fail_gpio:
661
662         g_rfkill = NULL;
663         return ret;
664 }
665
666 static int rfkill_rk_remove(struct platform_device *pdev)
667 {
668         struct rfkill_rk_data *rfkill = platform_get_drvdata(pdev);
669
670     LOG("Enter %s\n", __func__);
671
672         rfkill_unregister(rfkill->rfkill_dev);
673         rfkill_destroy(rfkill->rfkill_dev);
674
675     
676     cancel_delayed_work_sync(&rfkill->bt_sleep_delay_work);
677
678     // free gpio
679     if (gpio_is_valid(rfkill->pdata->rts_gpio.io))
680         gpio_free(rfkill->pdata->rts_gpio.io);
681     
682     if (gpio_is_valid(rfkill->pdata->wake_host_irq.gpio.io)){
683         free_irq(rfkill->pdata->wake_host_irq.irq, rfkill);
684 #ifndef CONFIG_BK3515A_COMBO
685         gpio_free(rfkill->pdata->wake_host_irq.gpio.io);
686 #endif
687     }
688     
689 #ifndef CONFIG_BK3515A_COMBO
690     if (gpio_is_valid(rfkill->pdata->wake_gpio.io))
691         gpio_free(rfkill->pdata->wake_gpio.io);
692 #endif
693     
694     if (gpio_is_valid(rfkill->pdata->reset_gpio.io))
695         gpio_free(rfkill->pdata->reset_gpio.io);
696     
697     if (gpio_is_valid(rfkill->pdata->poweron_gpio.io))
698         gpio_free(rfkill->pdata->poweron_gpio.io);
699
700     g_rfkill = NULL;
701
702         return 0;
703 }
704
705 static const struct dev_pm_ops rfkill_rk_pm_ops = {
706         .prepare = rfkill_rk_pm_prepare,
707         .complete = rfkill_rk_pm_complete,
708 };
709
710 #ifdef CONFIG_OF
711 static struct of_device_id bt_platdata_of_match[] = {
712     { .compatible = "bluetooth-platdata" },
713     { }
714 };
715 MODULE_DEVICE_TABLE(of, bt_platdata_of_match);
716 #endif //CONFIG_OF
717
718 static struct platform_driver rfkill_rk_driver = {
719         .probe = rfkill_rk_probe,
720         .remove = rfkill_rk_remove,
721         .driver = {
722                 .name = "rfkill_bt",
723                 .owner = THIS_MODULE,
724                 .pm = &rfkill_rk_pm_ops,
725         .of_match_table = of_match_ptr(bt_platdata_of_match),
726         },
727 };
728
729 static int __init rfkill_rk_init(void)
730 {
731     LOG("Enter %s\n", __func__);
732         return platform_driver_register(&rfkill_rk_driver);
733 }
734
735 static void __exit rfkill_rk_exit(void)
736 {
737     LOG("Enter %s\n", __func__);
738         platform_driver_unregister(&rfkill_rk_driver);
739 }
740
741 module_init(rfkill_rk_init);
742 module_exit(rfkill_rk_exit);
743
744 MODULE_DESCRIPTION("rock-chips rfkill for Bluetooth v0.3");
745 MODULE_AUTHOR("cmy@rock-chips.com, gwl@rock-chips.com");
746 MODULE_LICENSE("GPL");
747