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