rfkill-bt.c 20 KB

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