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 #if defined(CONFIG_AP6210) || defined(CONFIG_AP6335)
 270     struct rfkill_rk_gpio* rts = &rfkill->pdata->rts_gpio;
 271     struct pinctrl *pinctrl = rfkill->pdata->pinctrl;
 272 #endif
 273     int power = 0, vref_ctrl_enable = 0;
 274     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 (!rfkill_get_wifi_power_state(&power, &vref_ctrl_enable)) {
 282         if (true == toggle && 1 == power) {
 283             LOG("%s: bt shouldn't control the power, it was enabled by wifi!\n", __func__);
 284             return 0;
 285         }
 286     } else {
 287         LOG("%s: cannot get wifi power state!\n", __func__);
 288         return -1;
 289     }
 290
 291         if (false == blocked) {
 292         if (1 == vref_ctrl_enable && 0 == power)
 293             rockchip_wifi_ref_voltage(1);
 294
 295         rfkill_rk_sleep_bt(BT_WAKEUP); // ensure bt is wakeup
 296
 297                 if (gpio_is_valid(poweron->io))
 298         {
 299                         gpio_direction_output(poweron->io, !poweron->enable);
 300             msleep(20);
 301                         gpio_direction_output(poweron->io, poweron->enable);
 302             msleep(20);
 303         }
 304                 if (gpio_is_valid(reset->io))
 305         {
 306                         gpio_direction_output(reset->io, !reset->enable);
 307             msleep(20);
 308                         gpio_direction_output(reset->io, reset->enable);
 309         }
 310 #if defined(CONFIG_AP6210) || defined(CONFIG_AP6335)
 311         if (pinctrl != NULL && gpio_is_valid(rts->io))
 312         {
 313             pinctrl_select_state(pinctrl, rts->gpio_state);
 314             LOG("ENABLE UART_RTS\n");
 315             gpio_direction_output(rts->io, rts->enable);
 316             msleep(100);
 317             LOG("DISABLE UART_RTS\n");
 318             gpio_direction_output(rts->io, !rts->enable);
 319             pinctrl_select_state(pinctrl, rts->default_state);
 320         }
 321 #endif
 322         bt_power_state = 1;
 323         LOG("bt turn on power\n");
 324         } else {
 325             if (gpio_is_valid(poweron->io))
 326             {
 327                 gpio_direction_output(poweron->io, !poweron->enable);
 328                 msleep(20);
 329             }
 330
 331             bt_power_state = 0;
 332                 LOG("bt shut off power\n");
 333                 if (gpio_is_valid(reset->io))
 334         {
 335                         gpio_direction_output(reset->io, !reset->enable);/* bt reset active*/
 336             msleep(20);
 337         }
 338
 339         if (1 == vref_ctrl_enable && 0 == power)
 340             rockchip_wifi_ref_voltage(0);
 341         }
 342
 343         return 0;
 344 }
 345
 346 static int rfkill_rk_pm_prepare(struct device *dev)
 347 {
 348     struct rfkill_rk_data *rfkill = g_rfkill;
 349     struct rfkill_rk_gpio* rts;
 350     struct rfkill_rk_irq*  wake_host_irq;
 351     struct pinctrl *pinctrl = rfkill->pdata->pinctrl;
 352
 353     DBG("Enter %s\n",__FUNCTION__);
 354
 355     if (!rfkill)
 356         return 0;
 357
 358     rts = &rfkill->pdata->rts_gpio;
 359     wake_host_irq = &rfkill->pdata->wake_host_irq;
 360
 361     //To prevent uart to receive bt data when suspended
 362     if (pinctrl != NULL && gpio_is_valid(rts->io))
 363     {
 364         DBG("Disable UART_RTS\n");
 365         pinctrl_select_state(pinctrl, rts->gpio_state);
 366         gpio_direction_output(rts->io, !rts->enable);
 367     }
 368
 369 #ifdef CONFIG_BT_AUTOSLEEP
 370     rfkill_rk_sleep_bt(BT_SLEEP);
 371 #endif
 372
 373     // enable bt wakeup host
 374     if (gpio_is_valid(wake_host_irq->gpio.io))
 375     {
 376         DBG("enable irq for bt wakeup host\n");
 377         enable_irq(wake_host_irq->irq);
 378     }
 379
 380 #ifdef CONFIG_RFKILL_RESET
 381     rfkill_set_states(rfkill->rfkill_dev, BT_BLOCKED, false);
 382     rfkill_rk_set_power(rfkill, BT_BLOCKED);
 383 #endif
 384
 385     return 0;
 386 }
 387
 388 static void rfkill_rk_pm_complete(struct device *dev)
 389 {
 390     struct rfkill_rk_data *rfkill = g_rfkill;
 391     struct rfkill_rk_irq*  wake_host_irq;
 392     struct rfkill_rk_gpio* rts;
 393     struct pinctrl *pinctrl = rfkill->pdata->pinctrl;
 394
 395     DBG("Enter %s\n",__FUNCTION__);
 396
 397     if (!rfkill)
 398         return;
 399
 400     wake_host_irq = &rfkill->pdata->wake_host_irq;
 401     rts = &rfkill->pdata->rts_gpio;
 402
 403     if (gpio_is_valid(wake_host_irq->gpio.io))
 404     {
 405         LOG("** disable irq\n");
 406         disable_irq(wake_host_irq->irq);
 407     }
 408
 409     if (pinctrl != NULL && gpio_is_valid(rts->io))
 410     {
 411         DBG("Enable UART_RTS\n");
 412         gpio_direction_output(rts->io, rts->enable);
 413         pinctrl_select_state(pinctrl, rts->default_state);
 414     }
 415 }
 416
 417 static const struct rfkill_ops rfkill_rk_ops = {
 418     .set_block = rfkill_rk_set_power,
 419 };
 420
 421 #define PROC_DIR        "bluetooth/sleep"
 422
 423 static struct proc_dir_entry *bluetooth_dir, *sleep_dir;
 424
 425 static ssize_t bluesleep_read_proc_lpm(struct file *file, char __user *buffer,
 426                                        size_t count, loff_t *data)
 427 {
 428     return sprintf(buffer, "unsupported to read\n");
 429 }
 430
 431 static ssize_t bluesleep_write_proc_lpm(struct file *file,
 432                                         const char __user *buffer,
 433                                         size_t count, loff_t *data)
 434 {
 435     return count;
 436 }
 437
 438 static ssize_t bluesleep_read_proc_btwrite(struct file *file,
 439                                            char __user *buffer,
 440                                            size_t count, loff_t *data)
 441 {
 442     return sprintf(buffer, "unsupported to read\n");
 443 }
 444
 445 static ssize_t bluesleep_write_proc_btwrite(struct file *file,
 446                                             const char __user *buffer,
 447                                             size_t count, loff_t *data)
 448 {
 449     char b;
 450
 451     if (count < 1)
 452         return -EINVAL;
 453
 454     if (copy_from_user(&b, buffer, 1))
 455         return -EFAULT;
 456
 457     DBG("btwrite %c\n", b);
 458     /* HCI_DEV_WRITE */
 459     if (b != '0') {
 460         rfkill_rk_sleep_bt(BT_WAKEUP);
 461     }
 462
 463     return count;
 464 }
 465
 466 #ifdef CONFIG_OF
 467 static int bluetooth_platdata_parse_dt(struct device *dev,
 468                   struct rfkill_rk_platform_data *data)
 469 {
 470     struct device_node *node = dev->of_node;
 471     int gpio;
 472     enum of_gpio_flags flags;
 473
 474     if (!node)
 475         return -ENODEV;
 476
 477     memset(data, 0, sizeof(*data));
 478
 479     if (of_find_property(node, "wifi-bt-power-toggle", NULL)) {
 480         data->power_toggle = true;
 481         LOG("%s: get property wifi-bt-power-toggle.\n", __func__);
 482     } else {
 483         data->power_toggle = false;
 484     }
 485
 486     gpio = of_get_named_gpio_flags(node, "uart_rts_gpios", 0, &flags);
 487     if (gpio_is_valid(gpio)) {
 488         data->rts_gpio.io = gpio;
 489         data->rts_gpio.enable = (flags == GPIO_ACTIVE_HIGH)? 1:0;
 490         LOG("%s: get property: uart_rts_gpios = %d.\n", __func__, gpio);
 491         data->pinctrl = devm_pinctrl_get(dev);
 492         if (!IS_ERR(data->pinctrl)) {
 493             data->rts_gpio.default_state = pinctrl_lookup_state(data->pinctrl, "default");
 494             data->rts_gpio.gpio_state = pinctrl_lookup_state(data->pinctrl, "rts_gpio");
 495         } else {
 496             data->pinctrl = NULL;
 497             LOG("%s: dts does't define the uart rts iomux.\n", __func__);
 498             return -EINVAL;
 499         }
 500     } else {
 501         data->pinctrl = NULL;
 502         LOG("%s: uart_rts_gpios is unvalid.\n", __func__);
 503         return -EINVAL;
 504     }
 505
 506     gpio = of_get_named_gpio_flags(node, "BT,power_gpio", 0, &flags);
 507     if (gpio_is_valid(gpio)){
 508         data->poweron_gpio.io = gpio;
 509         data->poweron_gpio.enable = (flags == GPIO_ACTIVE_HIGH)? 1:0;
 510         LOG("%s: get property: BT,power_gpio = %d.\n", __func__, gpio);
 511     } else data->poweron_gpio.io = -1;
 512     gpio = of_get_named_gpio_flags(node, "BT,reset_gpio", 0, &flags);
 513     if (gpio_is_valid(gpio)){
 514         data->reset_gpio.io = gpio;
 515         data->reset_gpio.enable = (flags == GPIO_ACTIVE_HIGH)? 1:0;
 516         LOG("%s: get property: BT,reset_gpio = %d.\n", __func__, gpio);
 517     } else data->reset_gpio.io = -1;
 518     gpio = of_get_named_gpio_flags(node, "BT,wake_gpio", 0, &flags);
 519     if (gpio_is_valid(gpio)){
 520         data->wake_gpio.io = gpio;
 521         data->wake_gpio.enable = (flags == GPIO_ACTIVE_HIGH)? 1:0;
 522         LOG("%s: get property: BT,wake_gpio = %d.\n", __func__, gpio);
 523     } else data->wake_gpio.io = -1;
 524     gpio = of_get_named_gpio_flags(node, "BT,wake_host_irq", 0, &flags);
 525     if (gpio_is_valid(gpio)) {
 526         data->wake_host_irq.gpio.io = gpio;
 527         data->wake_host_irq.gpio.enable = flags;
 528         LOG("%s: get property: BT,wake_host_irq = %d.\n", __func__, gpio);
 529     } else data->wake_host_irq.gpio.io = -1;
 530
 531     return 0;
 532 }
 533 #endif //CONFIG_OF
 534
 535 static const struct file_operations bluesleep_lpm = {
 536     .owner = THIS_MODULE,
 537     .read = bluesleep_read_proc_lpm,
 538     .write = bluesleep_write_proc_lpm,
 539 };
 540
 541 static const struct file_operations bluesleep_btwrite = {
 542     .owner = THIS_MODULE,
 543     .read = bluesleep_read_proc_btwrite,
 544     .write = bluesleep_write_proc_btwrite,
 545 };
 546
 547 static int rfkill_rk_probe(struct platform_device *pdev)
 548 {
 549         struct rfkill_rk_data *rfkill;
 550         struct rfkill_rk_platform_data *pdata = pdev->dev.platform_data;
 551         int ret = 0;
 552     struct proc_dir_entry *ent;
 553
 554     DBG("Enter %s\n", __func__);
 555
 556     if (!pdata) {
 557 #ifdef CONFIG_OF
 558         pdata = devm_kzalloc(&pdev->dev, sizeof(struct rfkill_rk_platform_data), GFP_KERNEL);
 559         if (!pdata)
 560             return -ENOMEM;
 561
 562         ret = bluetooth_platdata_parse_dt(&pdev->dev, pdata);
 563         if (ret < 0) {
 564 #endif
 565             LOG("%s: No platform data specified\n", __func__);
 566             return ret;
 567 #ifdef CONFIG_OF
 568         }
 569 #endif
 570     }
 571
 572     pdata->name = (char*)bt_name;
 573     pdata->type = RFKILL_TYPE_BLUETOOTH;
 574
 575         rfkill = devm_kzalloc(&pdev->dev, sizeof(*rfkill), GFP_KERNEL);
 576         if (!rfkill) {
 577         kfree(pdata);
 578                 return -ENOMEM;
 579     }
 580
 581         rfkill->pdata = pdata;
 582     rfkill->pdev = pdev;
 583     g_rfkill = rfkill;
 584
 585     bluetooth_dir = proc_mkdir("bluetooth", NULL);
 586     if (bluetooth_dir == NULL) {
 587         LOG("Unable to create /proc/bluetooth directory");
 588         return -ENOMEM;
 589     }
 590
 591     sleep_dir = proc_mkdir("sleep", bluetooth_dir);
 592     if (sleep_dir == NULL) {
 593         LOG("Unable to create /proc/%s directory", PROC_DIR);
 594         return -ENOMEM;
 595     }
 596
 597         /* read/write proc entries */
 598     ent = proc_create("lpm", 0, sleep_dir, &bluesleep_lpm);
 599     if (ent == NULL) {
 600         LOG("Unable to create /proc/%s/lpm entry", PROC_DIR);
 601         ret = -ENOMEM;
 602         goto fail_alloc;
 603     }
 604
 605     /* read/write proc entries */
 606     ent = proc_create("btwrite", 0, sleep_dir, &bluesleep_btwrite);
 607     if (ent == NULL) {
 608         LOG("Unable to create /proc/%s/btwrite entry", PROC_DIR);
 609         ret = -ENOMEM;
 610         goto fail_alloc;
 611     }
 612
 613     DBG("init gpio\n");
 614
 615     ret = rfkill_rk_setup_gpio(pdev, &pdata->poweron_gpio, pdata->name, "poweron");
 616     if (ret) goto fail_gpio;
 617
 618     ret = rfkill_rk_setup_gpio(pdev, &pdata->reset_gpio, pdata->name, "reset");
 619     if (ret) goto fail_gpio;
 620
 621     ret = rfkill_rk_setup_gpio(pdev, &pdata->wake_gpio, pdata->name, "wake");
 622     if (ret) goto fail_gpio;
 623
 624     ret = rfkill_rk_setup_gpio(pdev, &pdata->rts_gpio, rfkill->pdata->name, "rts");
 625     if (ret) goto fail_gpio;
 626
 627     wake_lock_init(&(rfkill->bt_irq_wl), WAKE_LOCK_SUSPEND, "rfkill_rk_irq_wl");
 628
 629     ret = rfkill_rk_setup_wake_irq(rfkill);
 630     if (ret) goto fail_gpio;
 631
 632     DBG("setup rfkill\n");
 633         rfkill->rfkill_dev = rfkill_alloc(pdata->name, &pdev->dev, pdata->type,
 634                                 &rfkill_rk_ops, rfkill);
 635         if (!rfkill->rfkill_dev)
 636                 goto fail_alloc;
 637
 638     rfkill_set_states(rfkill->rfkill_dev, BT_BLOCKED, false);
 639         ret = rfkill_register(rfkill->rfkill_dev);
 640         if (ret < 0)
 641                 goto fail_rfkill;
 642
 643     INIT_DELAYED_WORK(&rfkill->bt_sleep_delay_work, rfkill_rk_delay_sleep_bt);
 644
 645     //rfkill_rk_set_power(rfkill, BT_BLOCKED);
 646     // bt turn off power
 647     if (gpio_is_valid(pdata->poweron_gpio.io))
 648     {
 649         gpio_direction_output(pdata->poweron_gpio.io, !pdata->poweron_gpio.enable);
 650     }
 651     if (gpio_is_valid(pdata->reset_gpio.io))
 652     {
 653         gpio_direction_output(pdata->reset_gpio.io, !pdata->reset_gpio.enable);
 654     }
 655
 656         platform_set_drvdata(pdev, rfkill);
 657
 658     LOG("%s device registered.\n", pdata->name);
 659
 660         return 0;
 661
 662 fail_rfkill:
 663         rfkill_destroy(rfkill->rfkill_dev);
 664 fail_alloc:
 665
 666         remove_proc_entry("btwrite", sleep_dir);
 667         remove_proc_entry("lpm", sleep_dir);
 668 fail_gpio:
 669
 670         g_rfkill = NULL;
 671         return ret;
 672 }
 673
 674 static int rfkill_rk_remove(struct platform_device *pdev)
 675 {
 676         struct rfkill_rk_data *rfkill = platform_get_drvdata(pdev);
 677
 678     LOG("Enter %s\n", __func__);
 679
 680         rfkill_unregister(rfkill->rfkill_dev);
 681         rfkill_destroy(rfkill->rfkill_dev);
 682
 683
 684     cancel_delayed_work_sync(&rfkill->bt_sleep_delay_work);
 685
 686     // free gpio
 687     if (gpio_is_valid(rfkill->pdata->rts_gpio.io))
 688         gpio_free(rfkill->pdata->rts_gpio.io);
 689
 690     if (gpio_is_valid(rfkill->pdata->wake_host_irq.gpio.io)){
 691         free_irq(rfkill->pdata->wake_host_irq.irq, rfkill);
 692 #ifndef CONFIG_BK3515A_COMBO
 693         gpio_free(rfkill->pdata->wake_host_irq.gpio.io);
 694 #endif
 695     }
 696
 697 #ifndef CONFIG_BK3515A_COMBO
 698     if (gpio_is_valid(rfkill->pdata->wake_gpio.io))
 699         gpio_free(rfkill->pdata->wake_gpio.io);
 700 #endif
 701
 702     if (gpio_is_valid(rfkill->pdata->reset_gpio.io))
 703         gpio_free(rfkill->pdata->reset_gpio.io);
 704
 705     if (gpio_is_valid(rfkill->pdata->poweron_gpio.io))
 706         gpio_free(rfkill->pdata->poweron_gpio.io);
 707
 708     kfree(rfkill);
 709     g_rfkill = NULL;
 710
 711         return 0;
 712 }
 713
 714 static const struct dev_pm_ops rfkill_rk_pm_ops = {
 715         .prepare = rfkill_rk_pm_prepare,
 716         .complete = rfkill_rk_pm_complete,
 717 };
 718
 719 #ifdef CONFIG_OF
 720 static struct of_device_id bt_platdata_of_match[] = {
 721     { .compatible = "bluetooth-platdata" },
 722     { }
 723 };
 724 MODULE_DEVICE_TABLE(of, bt_platdata_of_match);
 725 #endif //CONFIG_OF
 726
 727 static struct platform_driver rfkill_rk_driver = {
 728         .probe = rfkill_rk_probe,
 729         .remove = rfkill_rk_remove,
 730         .driver = {
 731                 .name = "rfkill_bt",
 732                 .owner = THIS_MODULE,
 733                 .pm = &rfkill_rk_pm_ops,
 734         .of_match_table = of_match_ptr(bt_platdata_of_match),
 735         },
 736 };
 737
 738 static int __init rfkill_rk_init(void)
 739 {
 740     LOG("Enter %s\n", __func__);
 741         return platform_driver_register(&rfkill_rk_driver);
 742 }
 743
 744 static void __exit rfkill_rk_exit(void)
 745 {
 746     LOG("Enter %s\n", __func__);
 747         platform_driver_unregister(&rfkill_rk_driver);
 748 }
 749
 750 module_init(rfkill_rk_init);
 751 module_exit(rfkill_rk_exit);
 752
 753 MODULE_DESCRIPTION("rock-chips rfkill for Bluetooth v0.3");
 754 MODULE_AUTHOR("cmy@rock-chips.com, gwl@rock-chips.com");
 755 MODULE_LICENSE("GPL");
 756