static int pico_rfkill_probe(struct platform_device *pdev) { int rc = 0; bool default_state = true; /* off */ /* always turn on clock */ htc_wifi_bt_sleep_clk_ctl(CLK_ON, ID_BT); mdelay(2); bluetooth_set_power(NULL, default_state); bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH, &pico_rfkill_ops, NULL); if (!bt_rfk) { rc = -ENOMEM; goto err_rfkill_alloc; } rfkill_set_states(bt_rfk, default_state, false); /* userspace cannot take exclusive control */ rc = rfkill_register(bt_rfk); if (rc) goto err_rfkill_reg; return 0; err_rfkill_reg: rfkill_destroy(bt_rfk); err_rfkill_alloc: return rc; }
static int spade_rfkill_probe(struct platform_device *pdev) { int rc = 0; bool default_state = true; /* off */ spade_config_bt_init(); /* bt gpio initial config */ bluetooth_set_power(NULL, default_state); bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH, &spade_rfkill_ops, NULL); if (!bt_rfk) { rc = -ENOMEM; goto err_rfkill_reset; } rfkill_set_states(bt_rfk, default_state, false); /* userspace cannot take exclusive control */ rc = rfkill_register(bt_rfk); if (rc) goto err_rfkill_reg; return 0; err_rfkill_reg: rfkill_destroy(bt_rfk); err_rfkill_reset: return rc; }
static int mogami_rfkill_probe(struct platform_device *pdev) { int rc = 0; bool default_state = true; /* off */ rc = bluetooth_set_power(pdev->dev.platform_data, default_state); if (rc) goto err_rfkill; bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH, &mogami_rfkill_ops, pdev->dev.platform_data); if (!bt_rfk) { rc = -ENOMEM; goto err_rfkill; } rfkill_set_states(bt_rfk, default_state, false); /* userspace cannot take exclusive control */ rc = rfkill_register(bt_rfk); if (rc) goto err_rfkill_reg; platform_set_drvdata(pdev, bt_rfk); return 0; err_rfkill_reg: rfkill_destroy(bt_rfk); err_rfkill: return rc; }
static int m4_rfkill_probe(struct platform_device *pdev) { int rc = 0; bool default_state = true; bluetooth_set_power(NULL, default_state); bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH, &m4_rfkill_ops, NULL); if (!bt_rfk) { rc = -ENOMEM; goto err_rfkill_alloc; } rfkill_set_states(bt_rfk, default_state, false); rc = rfkill_register(bt_rfk); if (rc) goto err_rfkill_reg; return 0; err_rfkill_reg: rfkill_destroy(bt_rfk); err_rfkill_alloc: return rc; }
static int __init bcm4329_rfkill_probe(struct platform_device *pdev) { int rc = 0; bool default_state = true; DBG("Enter::%s,line=%d\n",__FUNCTION__,__LINE__); /* default to bluetooth off */ bcm4329_set_block(NULL, default_state); /* blocked -> bt off */ bt_rfk = rfkill_alloc(bt_name, NULL, RFKILL_TYPE_BLUETOOTH, &bcm4329_rfk_ops, NULL); if (!bt_rfk) { printk("fail to rfkill_allocate************\n"); return -ENOMEM; } rfkill_set_states(bt_rfk, default_state, false); rc = rfkill_register(bt_rfk); if (rc) rfkill_destroy(bt_rfk); printk("rc=0x%x\n", rc); return rc; }
static int hp_wmi_rfkill2_refresh(void) { struct bios_rfkill2_state state; int err, i; err = hp_wmi_perform_query(HPWMI_WIRELESS2_QUERY, HPWMI_READ, &state, 0, sizeof(state)); if (err) return err; for (i = 0; i < rfkill2_count; i++) { int num = rfkill2[i].num; struct bios_rfkill2_device_state *devstate; devstate = &state.device[num]; if (num >= state.count || devstate->rfkill_id != rfkill2[i].id) { pr_warn("power configuration of the wireless devices unexpectedly changed\n"); continue; } rfkill_set_states(rfkill2[i].rfkill, IS_SWBLOCKED(devstate->power), IS_HWBLOCKED(devstate->power)); } return 0; }
static int emev_rfkill_probe(struct platform_device *pdev) { debug_print("Rfkill bt probe\n"); int rc = 0; struct emev_rfkill_platform_data *pdata = pdev->dev.platform_data; bcm2048_hw_init(); pdata->rfkill = rfkill_alloc("emev_bt", &pdev->dev, RFKILL_TYPE_BLUETOOTH, &emev_bt_rfkill_ops, NULL); if (unlikely(!pdata->rfkill)) { return -ENOMEM; } /* set default status */ rfkill_set_states(pdata->rfkill, true, true); rc = rfkill_register(pdata->rfkill); if (unlikely(rc)) { rfkill_destroy(pdata->rfkill); } return 0; }
static int lgps3_rfkill_probe(struct platform_device *pdev) { int rc = 0; bool default_state = true; /* off */ #if defined(CONFIG_BCM4335BT) //+++BRCM 4335 AXI Patch bcm_btlock_init(); //---BRCM #endif // defined(CONFIG_BCM4335BT) printk(KERN_ERR"lgps3_rfkill_probe\n"); rc = gpio_request(LGPS3_GPIO_BT_RESET_N, "bt_reset"); if (rc) { printk(KERN_ERR "GPIO req error no=%d",rc); gpio_free(LGPS3_GPIO_BT_RESET_N); rc = gpio_request(LGPS3_GPIO_BT_RESET_N, "bt_reset"); if(rc) { printk(KERN_ERR "GPIO req error no=%d",rc); goto err_gpio_reset; } } gpio_direction_output(LGPS3_GPIO_BT_RESET_N, 0); bluetooth_set_power(NULL, default_state); bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH, &lgps3_rfkill_ops, NULL); if (!bt_rfk) { printk(KERN_ERR"rfkill alloc failed.\n"); rc = -ENOMEM; goto err_rfkill_alloc; } rfkill_set_states(bt_rfk, default_state, false); /* userspace cannot take exclusive control */ rc = rfkill_register(bt_rfk); if (rc) goto err_rfkill_reg; return 0; err_rfkill_reg: rfkill_destroy(bt_rfk); err_rfkill_alloc: err_gpio_reset: gpio_free(LGPS3_GPIO_BT_RESET_N); printk(KERN_ERR"lgps3_rfkill_probe error!\n"); return rc; }
static void rbtn_rfkill_query(struct rfkill *rfkill, void *data) { struct acpi_device *device = data; int state; state = rbtn_get(device); if (state < 0) return; rfkill_set_states(rfkill, state, state); }
static int endeavortd_rfkill_probe(struct platform_device *pdev) { int ret = 0; int err = 0; bool default_state = true; /* off */ pr_info("[BT]%s: starting initialize endeavortd_rfkill\n" , __func__); gpio_request(ENDEAVORTD_GPIO_BT_SHUTDOWN_N, "bcm4334_nshutdown_gpio"); if (err) pr_err("BT_SHUTDOWN_N gpio request failed:%d\n", err); gpio_request(ENDEAVORTD_GPIO_BT_UART3_CTS, "bcm4334_uart3_cts"); if (err) pr_err("BT_CTS_N gpio request failed:%d\n", err); gpio_request(ENDEAVORTD_GPIO_BT_UART3_RTS, "bcm4334_uart3_rts"); if (err) pr_err("BT_RTS_N gpio request failed:%d\n", err); gpio_request(ENDEAVORTD_GPIO_BT_UART3_TX, "bcm4334_uart3_tx"); if (err) pr_err("BT_TXD gpio request failed:%d\n", err); gpio_request(ENDEAVORTD_GPIO_BT_UART3_RX, "bcm4334_uart3_rx"); if (err) pr_err("BT_RXD gpio request failed:%d\n", err); tegra_gpio_enable(ENDEAVORTD_GPIO_BT_SHUTDOWN_N); gpio_direction_output(ENDEAVORTD_GPIO_BT_SHUTDOWN_N, 0); bluetooth_set_power(NULL, default_state); bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH, &endeavortd_rfkill_ops, NULL); if (!bt_rfk) { ret = -ENOMEM; goto err_rfkill_alloc; } rfkill_set_states(bt_rfk, default_state, false); /* userspace cannot take exclusive control */ ret = rfkill_register(bt_rfk); if (ret) goto err_rfkill_reg; return 0; err_rfkill_reg: rfkill_destroy(bt_rfk); err_rfkill_alloc: return ret; }
static int shooter_rfkill_probe(struct platform_device *pdev) { int rc = 0; bool default_state = true; /* off */ #if 0 /* Is this necessary? */ rc = gpio_request(SHOOTER_GPIO_BT_RESET_N, "bt_reset"); if (rc) goto err_gpio_reset; rc = gpio_request(SHOOTER_GPIO_BT_SHUTDOWN_N, "bt_shutdown"); if (rc) goto err_gpio_shutdown; #endif /* always turn on clock? */ /* htc_wifi_bt_sleep_clk_ctl(CLK_ON, ID_BT); */ mdelay(2); bluetooth_set_power(NULL, default_state); bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH, &shooter_rfkill_ops, NULL); if (!bt_rfk) { rc = -ENOMEM; goto err_rfkill_alloc; } rfkill_set_states(bt_rfk, default_state, false); /* userspace cannot take exclusive control */ rc = rfkill_register(bt_rfk); if (rc) goto err_rfkill_reg; return 0; err_rfkill_reg: rfkill_destroy(bt_rfk); err_rfkill_alloc: #if 0 gpio_free(SHOOTER_GPIO_BT_SHUTDOWN_N); err_gpio_shutdown: gpio_free(SHOOTER_GPIO_BT_RESET_N); err_gpio_reset: #endif return rc; }
static int hp_wmi_resume_handler(struct device *device) { /* * Hardware state may have changed while suspended, so trigger * input events for the current state. As this is a switch, * the input layer will only actually pass it on if the state * changed. */ if (hp_wmi_input_dev) { if (test_bit(SW_DOCK, hp_wmi_input_dev->swbit)) input_report_switch(hp_wmi_input_dev, SW_DOCK, hp_wmi_hw_state(HPWMI_DOCK_MASK)); if (test_bit(SW_TABLET_MODE, hp_wmi_input_dev->swbit)) input_report_switch(hp_wmi_input_dev, SW_TABLET_MODE, hp_wmi_hw_state(HPWMI_TABLET_MASK)); input_sync(hp_wmi_input_dev); } if (rfkill2_count) hp_wmi_rfkill2_refresh(); if (wifi_rfkill) rfkill_set_states(wifi_rfkill, hp_wmi_get_sw_state(HPWMI_WIFI), hp_wmi_get_hw_state(HPWMI_WIFI)); if (bluetooth_rfkill) rfkill_set_states(bluetooth_rfkill, hp_wmi_get_sw_state(HPWMI_BLUETOOTH), hp_wmi_get_hw_state(HPWMI_BLUETOOTH)); if (wwan_rfkill) rfkill_set_states(wwan_rfkill, hp_wmi_get_sw_state(HPWMI_WWAN), hp_wmi_get_hw_state(HPWMI_WWAN)); return 0; }
static int rfkill_rk_pm_prepare(struct device *dev) { struct rfkill_rk_data *rfkill = g_rfkill; struct rfkill_rk_gpio* rts; struct rfkill_rk_irq* wake_host_irq; DBG("Enter %s\n",__FUNCTION__); if (!rfkill) return 0; rts = &rfkill->pdata->rts_gpio; wake_host_irq = &rfkill->pdata->wake_host_irq; //To prevent uart to receive bt data when suspended if (gpio_is_valid(rts->io)) { DBG("Disable UART_RTS\n"); if (rts->iomux.name) { rk_mux_api_set(rts->iomux.name, rts->iomux.fgpio); } gpio_direction_output(rts->io, !rts->enable); } #ifdef CONFIG_BT_AUTOSLEEP // BT进入睡眠状态,不接收主控数据 rfkill_rk_sleep_bt(BT_SLEEP); #endif /* 至此,蓝牙不再送数据到UART,也不再接收主控的UART数据 * 接着调用enable_irq使能 bt_wake_host irq,当远端设备有数据 * 到来时,将通过该IRQ唤醒主控 */ // enable bt wakeup host if (gpio_is_valid(wake_host_irq->gpio.io)) { DBG("enable irq for bt wakeup host\n"); enable_irq(wake_host_irq->irq); } #ifdef CONFIG_RFKILL_RESET rfkill_set_states(rfkill->rfkill_dev, BT_BLOCKED, false); rfkill_rk_set_power(rfkill, BT_BLOCKED); #endif return 0; }
static int sw_rfkill_probe(struct platform_device *pdev) { int ret = 0; sw_rfkill = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH, &sw_rfkill_ops, NULL); if (unlikely(!sw_rfkill)) return -ENOMEM; rfkill_set_states(sw_rfkill, true, false); ret = rfkill_register(sw_rfkill); if (unlikely(ret)) { rfkill_destroy(sw_rfkill); } return ret; }
static int pyramid_rfkill_probe(struct platform_device *pdev) { int rc = 0; bool default_state = true; #if 0 rc = gpio_request(PYRAMID_GPIO_BT_RESET_N, "bt_reset"); if (rc) goto err_gpio_reset; rc = gpio_request(PYRAMID_GPIO_BT_SHUTDOWN_N, "bt_shutdown"); if (rc) goto err_gpio_shutdown; #endif mdelay(2); bluetooth_set_power(NULL, default_state); bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH, &pyramid_rfkill_ops, NULL); if (!bt_rfk) { rc = -ENOMEM; goto err_rfkill_alloc; } rfkill_set_states(bt_rfk, default_state, false); rc = rfkill_register(bt_rfk); if (rc) goto err_rfkill_reg; return 0; err_rfkill_reg: rfkill_destroy(bt_rfk); err_rfkill_alloc: #if 0 gpio_free(PYRAMID_GPIO_BT_SHUTDOWN_N); err_gpio_shutdown: gpio_free(PYRAMID_GPIO_BT_RESET_N); err_gpio_reset: #endif return rc; }
static int hero_rfkill_probe(struct platform_device *pdev) { int ret; bool default_state = true; /* off */ ret = gpio_request(HERO_GPIO_WB_SHUT_DOWN_N, "hero_gpio_wb_shut_down_n"); if (ret) { printk(KERN_ERR "%s: Could not request gpio: %d\n", __func__, ret); goto err_gpio_shutdown; } hero_bt_status = 0; config_bt_table(hero_bt_init_table, ARRAY_SIZE(hero_bt_init_table)); mdelay(5); gpio_direction_output(HERO_GPIO_WB_SHUT_DOWN_N, 0); bluetooth_set_power(NULL, default_state); bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH, &hero_rfkill_ops, NULL); if (!bt_rfk){ printk(KERN_ERR "%s: Could not allocate memmory\n", __func__); ret = -ENOMEM; goto err_rfkill_alloc; } /* userspace cannot take exclusive control */ rfkill_set_states(bt_rfk, default_state, false); ret = rfkill_register(bt_rfk); if (ret) { printk(KERN_ERR "%s: failed to register rfkill: %d\n", __func__, ret); goto err_rfkill_reg; } return 0; err_rfkill_reg: rfkill_destroy(bt_rfk); err_rfkill_alloc: gpio_free(HERO_GPIO_WB_SHUT_DOWN_N); err_gpio_shutdown: return ret; }
static int holiday_rfkill_probe(struct platform_device *pdev) { int rc = 0; bool default_state = true; /* off */ #if 0 /* Is this necessary? */ rc = gpio_request(HOLIDAY_GPIO_BT_RESET_N, "bt_reset"); if (rc) goto err_gpio_reset; rc = gpio_request(HOLIDAY_GPIO_BT_SHUTDOWN_N, "bt_shutdown"); if (rc) goto err_gpio_shutdown; #endif bluetooth_set_power(NULL, default_state); bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH, &holiday_rfkill_ops, NULL); if (!bt_rfk) { rc = -ENOMEM; goto err_rfkill_alloc; } rfkill_set_states(bt_rfk, default_state, false); /* userspace cannot take exclusive control */ rc = rfkill_register(bt_rfk); if (rc) goto err_rfkill_reg; return 0; err_rfkill_reg: rfkill_destroy(bt_rfk); err_rfkill_alloc: #if 0 gpio_free(HOLIDAY_GPIO_BT_SHUTDOWN_N); err_gpio_shutdown: gpio_free(HOLIDAY_GPIO_BT_RESET_N); err_gpio_reset: #endif return rc; }
static int bcm4329_rfkill_probe(struct platform_device *pdev) { int rc = 0; bool default_state = true; pr_info("Enter::%s,line=%d\n",__FUNCTION__,__LINE__); rc = gpio_request(INFOIT50_BT_GPIO_POWER_N, "bt_shutdown"); if (rc) return rc; rc = gpio_request(INFOIT50_BT_GPIO_RESET_N, "bt_reset"); if (rc){ gpio_free(INFOIT50_BT_GPIO_POWER_N); return rc; } /* default to bluetooth off */ bcm4329_set_block(NULL, default_state); /* blocked -> bt off */ bt_rfk = rfkill_alloc(bt_name, NULL, RFKILL_TYPE_BLUETOOTH, &bcm4329_rfk_ops, NULL); if (!bt_rfk) { printk("fail to rfkill_allocate************\n"); return -ENOMEM; } rfkill_set_states(bt_rfk, default_state, false); rc = rfkill_register(bt_rfk); if (rc) rfkill_destroy(bt_rfk); printk("rc=0x%x\n", rc); return rc; }
static int mahimahi_rfkill_probe(struct platform_device *pdev) { int rc = 0; bool default_state = true; /* */ rc = gpio_request(MAHIMAHI_GPIO_BT_RESET_N, "bt_reset"); if (rc) goto err_gpio_reset; rc = gpio_request(MAHIMAHI_GPIO_BT_SHUTDOWN_N, "bt_shutdown"); if (rc) goto err_gpio_shutdown; bluetooth_set_power(NULL, default_state); bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH, &mahimahi_rfkill_ops, NULL); if (!bt_rfk) { rc = -ENOMEM; goto err_rfkill_alloc; } rfkill_set_states(bt_rfk, default_state, false); /* */ rc = rfkill_register(bt_rfk); if (rc) goto err_rfkill_reg; return 0; err_rfkill_reg: rfkill_destroy(bt_rfk); err_rfkill_alloc: gpio_free(MAHIMAHI_GPIO_BT_SHUTDOWN_N); err_gpio_shutdown: gpio_free(MAHIMAHI_GPIO_BT_RESET_N); err_gpio_reset: return rc; }
static int trout_rfkill_probe(struct platform_device *pdev) { int rc = 0; bool default_state = true; /* off */ bluetooth_set_power(NULL, default_state); bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH, &trout_rfkill_ops, NULL); if (!bt_rfk) return -ENOMEM; rfkill_set_states(bt_rfk, default_state, default_state); /* userspace cannot take exclusive control */ rc = rfkill_register(bt_rfk); if (rc) rfkill_destroy(bt_rfk); return rc; }
static int ruby_rfkill_probe(struct platform_device *pdev) { int rc = 0; bool default_state = true; rc = gpio_request(RUBY_GPIO_BT_EN, "bt_en"); if (rc) goto err_gpio_en; htc_wifi_bt_sleep_clk_ctl(CLK_ON, ID_BT); mdelay(2); bluetooth_set_power(NULL, default_state); bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH, &ruby_rfkill_ops, NULL); if (!bt_rfk) { rc = -ENOMEM; goto err_rfkill_alloc; } rfkill_set_states(bt_rfk, default_state, false); rc = rfkill_register(bt_rfk); if (rc) goto err_rfkill_reg; return 0; err_rfkill_reg: rfkill_destroy(bt_rfk); err_rfkill_alloc: gpio_free(RUBY_GPIO_BT_EN); err_gpio_en: return rc; }
static int wl127x_rfkill_probe(struct platform_device *pdev) { int rc = 0; struct wl127x_rfkill_platform_data *pdata = pdev->dev.platform_data; if (pdata->bt_nshutdown_gpio >= 0) { bool default_blocked = true; /* power off */ rc = gpio_request(pdata->bt_nshutdown_gpio, "wl127x_bt_nshutdown_gpio"); if (unlikely(rc)) return rc; rc = gpio_direction_output(pdata->bt_nshutdown_gpio, 0); if (unlikely(rc)) return rc; if (pdata->bt_hw_init) rc = pdata->bt_hw_init(); if (unlikely(rc)) return rc; wl127x_bt_rfkill_set_power((void *)pdata, default_blocked); pdata->rfkill[WL127X_BLUETOOTH] = rfkill_alloc( "wl127x Bluetooth", &pdev->dev, RFKILL_TYPE_BLUETOOTH, &wl127x_bt_rfkill_ops, (void *)pdata); if (unlikely(!pdata->rfkill[WL127X_BLUETOOTH])) return -ENOMEM; rfkill_set_states(pdata->rfkill[WL127X_BLUETOOTH], default_blocked, false); rc = rfkill_register(pdata->rfkill[WL127X_BLUETOOTH]); if (unlikely(rc)) { rfkill_destroy(pdata->rfkill[WL127X_BLUETOOTH]); return rc; } } if (pdata->fm_enable_gpio >= 0) { bool default_blocked = true; /* power off */ rc = gpio_request(pdata->fm_enable_gpio, "wl127x_fm_enable_gpio"); if (unlikely(rc)) return rc; rc = gpio_direction_output(pdata->fm_enable_gpio, 0); if (unlikely(rc)) return rc; wl127x_fm_rfkill_set_power((void *)pdata->fm_enable_gpio, default_blocked); pdata->rfkill[WL127X_FM] = rfkill_alloc("wl127x FM Radio", &pdev->dev, RFKILL_TYPE_FM, &wl127x_fm_rfkill_ops, (void *)pdata->fm_enable_gpio); if (unlikely(!pdata->rfkill[WL127X_FM])) return -ENOMEM; rfkill_set_states(pdata->rfkill[WL127X_FM], default_blocked, false); rc = rfkill_register(pdata->rfkill[WL127X_FM]); if (unlikely(rc)) { rfkill_destroy(pdata->rfkill[WL127X_FM]); return rc; } } return 0; }
static int htc_rfkill_probe(struct platform_device *pdev) { int rc = 0; bool default_state = true; struct pinctrl_state *set_state; printk(KERN_INFO "[BT]== rfkill_probe ==\n"); bt_export_bd_address(); fm_ant_node_init(); if (pdev->dev.of_node) { gpio_bt_reg_on = of_get_named_gpio(pdev->dev.of_node, "brcm,bt-regon-gpio", 0); if (gpio_bt_reg_on < 0) { printk("[BT]bt-regon-gpio not provided in device tree !!!"); } else { printk("[BT]bt-regon-gpio: %d", gpio_bt_reg_on); } } bt_pinctrl = devm_pinctrl_get(&pdev->dev); if (IS_ERR(bt_pinctrl)) { if (PTR_ERR(bt_pinctrl) == -EPROBE_DEFER) { printk("[BT] bt_pinctrl EPROBE_DEFER !!"); return -EPROBE_DEFER; } } if (bt_pinctrl) { printk("[BT] Init GPIO pins\n"); set_state = pinctrl_lookup_state(bt_pinctrl, "bt_wake_host_gpio_on"); if (IS_ERR(set_state)) { printk("[BT] cannot get BT pinctrl state bt_wake_host_gpio_on\n"); } else bt_wake_host_set_state_on = set_state; set_state = pinctrl_lookup_state(bt_pinctrl, "bt_wake_host_gpio_off"); if (IS_ERR(set_state)) { printk("[BT] cannot get BT pinctrl state bt_wake_host_gpio_off\n"); } else bt_wake_host_set_state_off = set_state; } bluetooth_set_power(NULL, default_state); bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH, &htc_rfkill_ops, NULL); if (!bt_rfk) { rc = -ENOMEM; goto err_rfkill_alloc; } rfkill_set_states(bt_rfk, default_state, false); rc = rfkill_register(bt_rfk); if (rc) goto err_rfkill_reg; return 0; err_rfkill_reg: rfkill_destroy(bt_rfk); err_rfkill_alloc: return rc; }
static int rfkill_rk_probe(struct platform_device *pdev) { struct rfkill_rk_data *rfkill; struct rfkill_rk_platform_data *pdata = pdev->dev.platform_data; int ret = 0; DBG("Enter %s\n", __func__); if (!pdata) { LOG("%s: No platform data specified\n", __func__); return -EINVAL; } pdata->name = (char*)bt_name; rfkill = kzalloc(sizeof(*rfkill), GFP_KERNEL); if (!rfkill) return -ENOMEM; rfkill->pdata = pdata; g_rfkill = rfkill; // 申请GPIO以及IRQ DBG("init gpio\n"); // 对于RK29 BCM4329,它的poweron io与wifi共用,在boad文件中已经request // 此处不用去申请 #if !WIFI_BT_POWER_TOGGLE ret = rfkill_rk_setup_gpio(&pdata->poweron_gpio, IOMUX_FGPIO, pdata->name, "poweron"); if (ret) goto fail_alloc; #endif ret = rfkill_rk_setup_gpio(&pdata->reset_gpio, IOMUX_FGPIO, pdata->name, "reset"); if (ret) goto fail_poweron; ret = rfkill_rk_setup_gpio(&pdata->wake_gpio, IOMUX_FGPIO, pdata->name, "wake"); if (ret) goto fail_reset; ret = rfkill_rk_setup_wake_irq(rfkill); if (ret) goto fail_wake; ret = rfkill_rk_setup_gpio(&(pdata->rts_gpio), IOMUX_FNORMAL, rfkill->pdata->name, "rts"); if (ret) goto fail_wake_host_irq; // 创建并注册RFKILL设备 DBG("setup rfkill\n"); rfkill->rfkill_dev = rfkill_alloc(pdata->name, &pdev->dev, pdata->type, &rfkill_rk_ops, rfkill); if (!rfkill->rfkill_dev) goto fail_rts; // cmy: 设置rfkill初始状态为blocked,在注册时不会调用 set_blocked函数 rfkill_set_states(rfkill->rfkill_dev, BT_BLOCKED, false); ret = rfkill_register(rfkill->rfkill_dev); if (ret < 0) goto fail_rfkill; wake_lock_init(&(rfkill->bt_irq_wl), WAKE_LOCK_SUSPEND, "rfkill_rk_irq_wl"); INIT_DELAYED_WORK(&rfkill->bt_sleep_delay_work, rfkill_rk_delay_sleep_bt); // cmy: 设置蓝牙电源的状态为 blocked rfkill_rk_set_power(rfkill, BT_BLOCKED); platform_set_drvdata(pdev, rfkill); LOG("%s device registered.\n", pdata->name); return 0; fail_rfkill: rfkill_destroy(rfkill->rfkill_dev); fail_rts: if (gpio_is_valid(pdata->rts_gpio.io)) gpio_free(pdata->rts_gpio.io); fail_wake_host_irq: if (gpio_is_valid(pdata->wake_host_irq.gpio.io)){ free_irq(pdata->wake_host_irq.irq, rfkill); gpio_free(pdata->wake_host_irq.gpio.io); } fail_wake: if (gpio_is_valid(pdata->wake_gpio.io)) gpio_free(pdata->wake_gpio.io); fail_reset: if (gpio_is_valid(pdata->reset_gpio.io)) gpio_free(pdata->reset_gpio.io); fail_poweron: #if !WIFI_BT_POWER_TOGGLE if (gpio_is_valid(pdata->poweron_gpio.io)) gpio_free(pdata->poweron_gpio.io); #endif fail_alloc: kfree(rfkill); g_rfkill = NULL; return ret; }
static int rfkill_rk_probe(struct platform_device *pdev) { struct rfkill_rk_data *rfkill; struct rfkill_rk_platform_data *pdata = pdev->dev.platform_data; int ret = 0; struct proc_dir_entry *ent; DBG("Enter %s\n", __func__); if (!pdata) { LOG("%s: No platform data specified\n", __func__); return -EINVAL; } pdata->name = (char*)bt_name; rfkill = kzalloc(sizeof(*rfkill), GFP_KERNEL); if (!rfkill) return -ENOMEM; rfkill->pdata = pdata; g_rfkill = rfkill; bluetooth_dir = proc_mkdir("bluetooth", NULL); if (bluetooth_dir == NULL) { LOG("Unable to create /proc/bluetooth directory"); return -ENOMEM; } sleep_dir = proc_mkdir("sleep", bluetooth_dir); if (sleep_dir == NULL) { LOG("Unable to create /proc/%s directory", PROC_DIR); return -ENOMEM; } /* read/write proc entries */ ent = create_proc_entry("lpm", 0, sleep_dir); if (ent == NULL) { LOG("Unable to create /proc/%s/lpm entry", PROC_DIR); ret = -ENOMEM; goto fail_alloc; } ent->read_proc = bluesleep_read_proc_lpm; ent->write_proc = bluesleep_write_proc_lpm; /* read/write proc entries */ ent = create_proc_entry("btwrite", 0, sleep_dir); if (ent == NULL) { LOG("Unable to create /proc/%s/btwrite entry", PROC_DIR); ret = -ENOMEM; goto fail_alloc; } ent->read_proc = bluesleep_read_proc_btwrite; ent->write_proc = bluesleep_write_proc_btwrite; // 申请GPIO以及IRQ DBG("init gpio\n"); // 对于RK29 BCM4329,它的poweron io与wifi共用,在boad文件中已经request // 此处不用去申请 #if !WIFI_BT_POWER_TOGGLE ret = rfkill_rk_setup_gpio(&pdata->poweron_gpio, IOMUX_FGPIO, pdata->name, "poweron"); if (ret) goto fail_alloc; #endif ret = rfkill_rk_setup_gpio(&pdata->reset_gpio, IOMUX_FGPIO, pdata->name, "reset"); if (ret) goto fail_poweron; ret = rfkill_rk_setup_gpio(&pdata->wake_gpio, IOMUX_FGPIO, pdata->name, "wake"); if (ret) goto fail_reset; ret = rfkill_rk_setup_wake_irq(rfkill); if (ret) goto fail_wake; ret = rfkill_rk_setup_gpio(&pdata->rts_gpio, IOMUX_FMUX, rfkill->pdata->name, "rts"); if (ret) goto fail_wake_host_irq; // 创建并注册RFKILL设备 DBG("setup rfkill\n"); rfkill->rfkill_dev = rfkill_alloc(pdata->name, &pdev->dev, pdata->type, &rfkill_rk_ops, rfkill); if (!rfkill->rfkill_dev) goto fail_rts; // cmy: 设置rfkill初始状态为blocked,在注册时不会调用 set_blocked函数 rfkill_set_states(rfkill->rfkill_dev, BT_BLOCKED, false); ret = rfkill_register(rfkill->rfkill_dev); if (ret < 0) goto fail_rfkill; wake_lock_init(&(rfkill->bt_irq_wl), WAKE_LOCK_SUSPEND, "rfkill_rk_irq_wl"); INIT_DELAYED_WORK(&rfkill->bt_sleep_delay_work, rfkill_rk_delay_sleep_bt); // cmy: 设置蓝牙电源的状态为 blocked rfkill_rk_set_power(rfkill, BT_BLOCKED); platform_set_drvdata(pdev, rfkill); LOG("%s device registered.\n", pdata->name); return 0; fail_rfkill: rfkill_destroy(rfkill->rfkill_dev); fail_rts: if (gpio_is_valid(pdata->rts_gpio.io)) gpio_free(pdata->rts_gpio.io); fail_wake_host_irq: if (gpio_is_valid(pdata->wake_host_irq.gpio.io)){ free_irq(pdata->wake_host_irq.irq, rfkill); gpio_free(pdata->wake_host_irq.gpio.io); } fail_wake: if (gpio_is_valid(pdata->wake_gpio.io)) gpio_free(pdata->wake_gpio.io); fail_reset: if (gpio_is_valid(pdata->reset_gpio.io)) gpio_free(pdata->reset_gpio.io); fail_poweron: #if !WIFI_BT_POWER_TOGGLE if (gpio_is_valid(pdata->poweron_gpio.io)) gpio_free(pdata->poweron_gpio.io); #endif fail_alloc: kfree(rfkill); g_rfkill = NULL; remove_proc_entry("btwrite", sleep_dir); remove_proc_entry("lpm", sleep_dir); return ret; }
static int bluedroid_pm_probe(struct platform_device *pdev) { static struct bluedroid_pm_data *bluedroid_pm; struct rfkill *rfkill; struct resource *res; int ret; bool enable = false; /* off */ bool default_sw_block_state; bluedroid_pm = kzalloc(sizeof(*bluedroid_pm), GFP_KERNEL); if (!bluedroid_pm) return -ENOMEM; bluedroid_pm->vdd_3v3 = regulator_get(&pdev->dev, "vdd_bt_3v3"); if (IS_ERR_OR_NULL(bluedroid_pm->vdd_3v3)) { pr_warn("%s: regulator vdd_bt_3v3 not available\n", __func__); bluedroid_pm->vdd_3v3 = NULL; } bluedroid_pm->vdd_1v8 = regulator_get(&pdev->dev, "vddio_bt_1v8"); if (IS_ERR_OR_NULL(bluedroid_pm->vdd_1v8)) { pr_warn("%s: regulator vddio_bt_1v8 not available\n", __func__); bluedroid_pm->vdd_1v8 = NULL; } res = platform_get_resource_byname(pdev, IORESOURCE_IO, "reset_gpio"); if (res) { bluedroid_pm->gpio_reset = res->start; ret = gpio_request(bluedroid_pm->gpio_reset, "reset_gpio"); if (ret) { pr_err("%s: Failed to get reset gpio\n", __func__); goto free_res; } gpio_direction_output(bluedroid_pm->gpio_reset, enable); } else { pr_debug("%s: Reset gpio not registered.\n", __func__); bluedroid_pm->gpio_reset = 0; } res = platform_get_resource_byname(pdev, IORESOURCE_IO, "shutdown_gpio"); if (res) { bluedroid_pm->gpio_shutdown = res->start; ret = gpio_request(bluedroid_pm->gpio_shutdown, "shutdown_gpio"); if (ret) { pr_err("%s: Failed to get shutdown gpio\n", __func__); goto free_res; } gpio_direction_output(bluedroid_pm->gpio_shutdown, enable); } else { pr_debug("%s: shutdown gpio not registered\n", __func__); bluedroid_pm->gpio_shutdown = 0; } /* * make sure at-least one of the GPIO or regulators avaiable to * register with rfkill is defined */ if (bluedroid_pm->gpio_reset || bluedroid_pm->gpio_shutdown || bluedroid_pm->vdd_1v8 || bluedroid_pm->vdd_3v3) { rfkill = rfkill_alloc(pdev->name, &pdev->dev, RFKILL_TYPE_BLUETOOTH, &bluedroid_pm_rfkill_ops, bluedroid_pm); if (unlikely(!rfkill)) goto free_res; default_sw_block_state = !enable; rfkill_set_states(rfkill, default_sw_block_state, false); ret = rfkill_register(rfkill); if (unlikely(ret)) { rfkill_destroy(rfkill); kfree(rfkill); goto free_res; } bluedroid_pm->rfkill = rfkill; } res = platform_get_resource_byname(pdev, IORESOURCE_IO, "gpio_host_wake"); if (res) { bluedroid_pm->host_wake = res->start; ret = gpio_request(bluedroid_pm->host_wake, "bt_host_wake"); if (ret) { pr_err("%s: Failed to get host_wake gpio\n", __func__); goto free_res; } /* configure host_wake as input */ gpio_direction_input(bluedroid_pm->host_wake); } else { pr_debug("%s: gpio_host_wake not registered\n", __func__); bluedroid_pm->host_wake = 0; } res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "host_wake"); if (res) { pr_err("%s : found host_wake irq\n", __func__); bluedroid_pm->host_wake_irq = res->start; ret = request_irq(bluedroid_pm->host_wake_irq, bluedroid_pm_hostwake_isr, IRQF_DISABLED | IRQF_TRIGGER_RISING, "bluetooth hostwake", bluedroid_pm); if (ret) { pr_err("%s: Failed to get host_wake irq\n", __func__); goto free_res; } } else { pr_debug("%s: host_wake not registered\n", __func__); bluedroid_pm->host_wake_irq = 0; } res = platform_get_resource_byname(pdev, IORESOURCE_IO, "gpio_ext_wake"); if (res) { bluedroid_pm->ext_wake = res->start; ret = gpio_request(bluedroid_pm->ext_wake, "bt_ext_wake"); if (ret) { pr_err("%s: Failed to get ext_wake gpio\n", __func__); goto free_res; } /* configure ext_wake as output mode*/ gpio_direction_output(bluedroid_pm->ext_wake, 1); if (create_bt_proc_interface(bluedroid_pm)) { pr_err("%s: Failed to create proc interface", __func__); goto free_res; } } else { pr_debug("%s: gpio_ext_wake not registered\n", __func__); bluedroid_pm->ext_wake = 0; } platform_set_drvdata(pdev, bluedroid_pm); pr_debug("RFKILL BT driver successfully registered"); return 0; free_res: if (bluedroid_pm->vdd_3v3) regulator_put(bluedroid_pm->vdd_3v3); if (bluedroid_pm->vdd_1v8) regulator_put(bluedroid_pm->vdd_1v8); if (bluedroid_pm->gpio_shutdown) gpio_free(bluedroid_pm->gpio_shutdown); if (bluedroid_pm->gpio_reset) gpio_free(bluedroid_pm->gpio_reset); if (bluedroid_pm->ext_wake) gpio_free(bluedroid_pm->ext_wake); if (bluedroid_pm->host_wake) gpio_free(bluedroid_pm->host_wake); if (bluedroid_pm->rfkill) { rfkill_unregister(bluedroid_pm->rfkill); rfkill_destroy(bluedroid_pm->rfkill); kfree(bluedroid_pm->rfkill); } kfree(bluedroid_pm); return -ENODEV; }
static int bcm4329_rfkill_probe(struct platform_device *pdev) { struct rfkill *bt_rfkill; struct resource *res; int ret; bool enable = false; /* off */ bool default_sw_block_state; bcm4329_rfkill = kzalloc(sizeof(*bcm4329_rfkill), GFP_KERNEL); if (!bcm4329_rfkill) return -ENOMEM; /** bcm4329_rfkill->bt_32k_clk = clk_get(&pdev->dev, "bcm4329_32k_clk"); if (IS_ERR(bcm4329_rfkill->bt_32k_clk)) { pr_warn("%s: can't find bcm4329_32k_clk.\ assuming 32k clock to chip\n", __func__); bcm4329_rfkill->bt_32k_clk = NULL; } **/ res = platform_get_resource_byname(pdev, IORESOURCE_IO, "bcm4329_nreset_gpio"); if (res) { bcm4329_rfkill->gpio_reset = res->start; ret = gpio_request(bcm4329_rfkill->gpio_reset, "bcm4329_nreset_gpio"); } else { pr_warn("%s : can't find reset gpio. " "reset gpio may not be defined for " "this platform \n", __func__); bcm4329_rfkill->gpio_reset = 0; } res = platform_get_resource_byname(pdev, IORESOURCE_IO, "bcm4329_nshutdown_gpio"); if (res) { bcm4329_rfkill->gpio_shutdown = res->start; ret = gpio_request(bcm4329_rfkill->gpio_shutdown, "bcm4329_nshutdown_gpio"); } else { pr_warn("%s : can't find shutdown gpio " "shutdown gpio may not be defined for " "this platform \n", __func__); bcm4329_rfkill->gpio_shutdown = 0; } /* make sure at-least one of the GPIO is defined */ if (!bcm4329_rfkill->gpio_reset && !bcm4329_rfkill->gpio_shutdown) goto free_bcm_res; /** if (bcm4329_rfkill->bt_32k_clk && enable) clk_enable(bcm4329_rfkill->bt_32k_clk); **/ if (bcm4329_rfkill->gpio_shutdown) gpio_direction_output(bcm4329_rfkill->gpio_shutdown, enable); if (bcm4329_rfkill->gpio_reset) gpio_direction_output(bcm4329_rfkill->gpio_reset, enable); bt_rfkill = rfkill_alloc("bcm4329 Bluetooth", &pdev->dev, RFKILL_TYPE_BLUETOOTH, &bcm4329_bt_rfkill_ops, NULL); if (unlikely(!bt_rfkill)) goto free_bcm_res; default_sw_block_state = !enable; rfkill_set_states(bt_rfkill, default_sw_block_state, false); ret = rfkill_register(bt_rfkill); if (unlikely(ret)) { rfkill_destroy(bt_rfkill); goto free_bcm_res; } return 0; free_bcm_res: if (bcm4329_rfkill->gpio_shutdown) gpio_free(bcm4329_rfkill->gpio_shutdown); if (bcm4329_rfkill->gpio_reset) gpio_free(bcm4329_rfkill->gpio_reset); /** if (bcm4329_rfkill->bt_32k_clk && enable) clk_disable(bcm4329_rfkill->bt_32k_clk); if (bcm4329_rfkill->bt_32k_clk) clk_put(bcm4329_rfkill->bt_32k_clk); **/ kfree(bcm4329_rfkill); return -ENODEV; }
static int __devinit bcm4329_rfkill_probe(struct platform_device *pdev) { int rc = 0; bool default_state = true; DBG("Enter::%s,line=%d\n",__FUNCTION__,__LINE__); /* default to bluetooth off */ bcm4329_set_block(NULL, default_state); /* blocked -> bt off */ gBtCtrl.bt_rfk = rfkill_alloc(bt_name, NULL, RFKILL_TYPE_BLUETOOTH, &bcm4329_rfk_ops, NULL); if (!gBtCtrl.bt_rfk) { printk("fail to rfkill_allocate************\n"); return -ENOMEM; } rfkill_set_states(gBtCtrl.bt_rfk, default_state, false); rc = rfkill_register(gBtCtrl.bt_rfk); if (rc) { printk("failed to rfkill_register,rc=0x%x\n",rc); rfkill_destroy(gBtCtrl.bt_rfk); } gpio_request(BT_GPIO_POWER, NULL); gpio_request(BT_GPIO_RESET, NULL); gpio_request(BT_GPIO_WAKE_UP, NULL); #if BT_WAKE_HOST_SUPPORT init_timer(&(gBtCtrl.tl)); gBtCtrl.tl.expires = jiffies + BT_WAKE_LOCK_TIMEOUT*HZ; gBtCtrl.tl.function = timer_hostSleep; add_timer(&(gBtCtrl.tl)); gBtCtrl.b_HostWake = false; wake_lock_init(&(gBtCtrl.bt_wakelock), WAKE_LOCK_SUSPEND, "bt_wake"); rc = gpio_request(BT_GPIO_WAKE_UP_HOST, "bt_wake"); if (rc) { printk("%s:failed to request RAHO_BT_WAKE_UP_HOST\n",__FUNCTION__); } IOMUX_BT_GPIO_WAKE_UP_HOST(); gpio_pull_updown(BT_GPIO_WAKE_UP_HOST,GPIOPullUp); rc = request_irq(gpio_to_irq(BT_GPIO_WAKE_UP_HOST),bcm4329_wake_host_irq,IRQF_TRIGGER_FALLING,NULL,NULL); if(rc) { printk("%s:failed to request RAHO_BT_WAKE_UP_HOST irq\n",__FUNCTION__); gpio_free(BT_GPIO_WAKE_UP_HOST); } enable_irq_wake(gpio_to_irq(BT_GPIO_WAKE_UP_HOST)); // so RAHO_BT_WAKE_UP_HOST can wake up system printk(KERN_INFO "bcm4329 module has been initialized,rc=0x%x\n",rc); #endif return rc; }
static int __devinit bcm4329_rfkill_probe(struct platform_device *pdev) { int rc = 0; bool default_state = true; DBG("Enter %s\n",__FUNCTION__); /* default to bluetooth off */ bcm4329_set_block(NULL, default_state); /* blocked -> bt off */ gBtCtrl.bt_rfk = rfkill_alloc(bt_name, NULL, RFKILL_TYPE_BLUETOOTH, &bcm4329_rfk_ops, NULL); if (!gBtCtrl.bt_rfk) { LOG("fail to rfkill_allocate\n"); return -ENOMEM; } rfkill_set_states(gBtCtrl.bt_rfk, default_state, false); rc = rfkill_register(gBtCtrl.bt_rfk); if (rc) { LOG("failed to rfkill_register,rc=0x%x\n",rc); rfkill_destroy(gBtCtrl.bt_rfk); } gpio_request(BT_GPIO_POWER, NULL); gpio_request(BT_GPIO_RESET, NULL); gpio_request(BT_GPIO_WAKE_UP, NULL); #ifdef CONFIG_BT_AUTOSLEEP init_timer(&bt_sleep_tl); bt_sleep_tl.expires = 0; bt_sleep_tl.function = bcm4325_sleep; bt_sleep_tl.data = 1; add_timer(&bt_sleep_tl); #endif #if BT_WAKE_HOST_SUPPORT init_timer(&(gBtCtrl.tl)); gBtCtrl.tl.expires = 0; gBtCtrl.tl.function = timer_hostSleep; add_timer(&(gBtCtrl.tl)); gBtCtrl.b_HostWake = false; wake_lock_init(&(gBtCtrl.bt_wakelock), WAKE_LOCK_SUSPEND, "bt_wake"); rc = gpio_request(BT_GPIO_WAKE_UP_HOST, "bt_wake"); if (rc) { LOG("Failed to request BT_WAKE_UP_HOST\n"); } IOMUX_BT_GPIO_WAKE_UP_HOST(); gpio_pull_updown(BT_GPIO_WAKE_UP_HOST,GPIOPullUp); #endif LOG("bcm4329 module has been initialized,rc=0x%x\n",rc); return rc; }
static int tcc_bluetooth_probe(struct platform_device *pdev) { int rc = 0; int ret = 0; printk("[## BT ##] tcc_bluetooth_probe\n"); if( machine_is_tcc8800()|| machine_is_tcc8920()) { // #elif defined (CONFIG_MACH_TCC9300) //gpio_set_value(TCC_GPEXT1(7), 0); /* BT-ON Disable */ gpio_request(TCC_GPEXT3(2), "bt_wake"); gpio_request(TCC_GPEXT2(4), "bt_reset"); gpio_direction_output(TCC_GPEXT3(2), 0); // output gpio_direction_output(TCC_GPEXT2(4), 0); #if defined(CONFIG_TCC_CSR_BC0406_MODULE_SUPPORT) && defined(CONFIG_TCC_CSR_HOST_WAKE_UP) tcc_gpio_config(TCC_GPB(31), GPIO_FN(0)); gpio_request(TCC_GPEXT3(3), "bt_hwake"); gpio_direction_input(TCC_GPEXT3(3)); #endif // for CSR Bluetooth host wake up } else if(machine_is_m801_88() || machine_is_m803()) { #if defined(CONFIG_TCC_RDA_587X_MODULE_SUPPORT) gpio_request(TCC_GPA(13), "LDO_ON"); tcc_gpio_config(TCC_GPA(13), GPIO_FN(0)); gpio_direction_output(TCC_GPA(13), 0); #else gpio_request(TCC_GPA(13), "bt_reset"); gpio_request(TCC_GPB(22), "BT WAKE"); gpio_direction_output(TCC_GPA(13), 0); // output gpio_direction_output(TCC_GPB(22), 0); // output #endif } else if(machine_is_tcc8800st()) { gpio_request(TCC_GPC(31), "bt_power"); gpio_request(TCC_GPD(12), "bt_reset"); gpio_direction_output(TCC_GPC(31), 0); // output gpio_direction_output(TCC_GPD(12), 0); // output } /* rc = gpio_request(BT_RESET_GPIO, "bcm4330_nreset_gpip"); if (unlikely(rc)) { return rc; } rc = gpio_request(BT_REG_GPIO, "bcm4330_nshutdown_gpio"); if (unlikely(rc)) { gpio_free(BT_RESET_GPIO); return rc; } */ bt_rfkill = rfkill_alloc("Telechips Bluetooth", &pdev->dev, RFKILL_TYPE_BLUETOOTH, &tcc_bt_rfkill_ops, NULL); if (unlikely(!bt_rfkill)) { //gpio_free(BT_RESET_GPIO); //gpio_free(BT_REG_GPIO); printk("[## BT ##] rfkill_alloc failed \n"); return -ENOMEM; } rc = rfkill_register(bt_rfkill); if (unlikely(rc)) { printk("[## BT ##] rfkill_register failed \n"); rfkill_destroy(bt_rfkill); //gpio_free(BT_RESET_GPIO); //gpio_free(BT_REG_GPIO); return -1; } printk("[## BT ##] rfkill_register Telechips Bluetooth \n"); rfkill_set_states(bt_rfkill, true, false); tcc_bt_rfkill_set_power(NULL, true); #if defined (CONFIG_TCC_BRCM_BCM4330_MODULE_SUPPORT) ret = bcm_bt_lpm_init(pdev); if (ret) { rfkill_unregister(bt_rfkill); rfkill_destroy(bt_rfkill); //gpio_free(BT_RESET_GPIO); //gpio_free(BT_REG_GPIO); } #endif return ret; }