static int legend_rfkill_probe(struct platform_device *pdev) { int rc = 0; enum rfkill_state default_state = RFKILL_STATE_SOFT_BLOCKED; /* off */ /* force BT on and off to do GPIO setting when initiate */ bluetooth_set_power(NULL, RFKILL_STATE_UNBLOCKED); legend_config_bt_init(); /* bt gpio initial config */ rfkill_set_default(RFKILL_TYPE_BLUETOOTH, default_state); bluetooth_set_power(NULL, default_state); bt_rfk = rfkill_allocate(&pdev->dev, RFKILL_TYPE_BLUETOOTH); if (!bt_rfk) return -ENOMEM; bt_rfk->name = bt_name; bt_rfk->state = default_state; /* userspace cannot take exclusive control */ bt_rfk->user_claim_unsupported = 1; bt_rfk->user_claim = 0; bt_rfk->data = NULL; /* user data */ bt_rfk->toggle_radio = bluetooth_set_power; rc = rfkill_register(bt_rfk); if (rc) rfkill_free(bt_rfk); return rc; }
/* Export an interface for the other drivers */ int bliss_bluetooth_set_power(int on) { if (on) bluetooth_set_power(NULL, false); else bluetooth_set_power(NULL, true); return 0; }
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 __init socle_rfkill_probe(struct platform_device *pdev) { int rc = 0; /* default to bluetooth off */ rfkill_switch_all(RFKILL_TYPE_BLUETOOTH, RFKILL_STATE_SOFT_BLOCKED); bluetooth_set_power(NULL, RFKILL_STATE_SOFT_BLOCKED); bt_rfk = rfkill_allocate(&pdev->dev, RFKILL_TYPE_BLUETOOTH); if (!bt_rfk) return -ENOMEM; bt_rfk->name = bt_name; bt_rfk->state = RFKILL_STATE_SOFT_BLOCKED; /* userspace cannot take exclusive control */ bt_rfk->user_claim_unsupported = 1; bt_rfk->user_claim = 0; bt_rfk->data = NULL; // user data bt_rfk->toggle_radio = bluetooth_set_power; rc = rfkill_register(bt_rfk); if (rc) rfkill_free(bt_rfk); 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 liberty_rfkill_probe(struct platform_device *pdev) { int rc = 0; enum rfkill_state default_state = RFKILL_STATE_SOFT_BLOCKED; liberty_config_bt_init(); /* bt gpio initial config */ rfkill_set_default(RFKILL_TYPE_BLUETOOTH, default_state); bluetooth_set_power(NULL, default_state); bt_rfk = rfkill_allocate(&pdev->dev, RFKILL_TYPE_BLUETOOTH); if (!bt_rfk) return -ENOMEM; bt_rfk->name = bt_name; bt_rfk->state = default_state; /* userspace cannot take exclusive control */ bt_rfk->user_claim_unsupported = 1; bt_rfk->user_claim = 0; bt_rfk->data = NULL; bt_rfk->toggle_radio = bluetooth_set_power; rc = rfkill_register(bt_rfk); if (rc) goto err_rfkill_reg; return 0; err_rfkill_reg: rfkill_free(bt_rfk); 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 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 rfkill_bluetooth_probe(struct platform_device *pdev) { int rc = 0; bool default_state = true; printk(KERN_INFO "-->%s\n", __func__); getIoResource(pdev); bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH, &rfkill_bluetooth_ops, NULL); if (!bt_rfk) { rc = -ENOMEM; goto err_rfkill_alloc; } rfkill_gpio_init(); /* userspace cannot take exclusive control */ rfkill_init_sw_state(bt_rfk,false); rc = rfkill_register(bt_rfk); if (rc) goto err_rfkill_reg; rfkill_set_sw_state(bt_rfk,true); bluetooth_set_power(NULL, default_state); printk(KERN_INFO "<--%s\n", __func__); return 0; err_rfkill_reg: rfkill_destroy(bt_rfk); err_rfkill_alloc: return rc; }
static int bt_rfkill_set_block(void *data, bool blocked) { unsigned int ret =0; ret = bluetooth_set_power(data, blocked? RFKILL_USER_STATE_SOFT_BLOCKED : RFKILL_USER_STATE_UNBLOCKED); return ret; }
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 int __init smdk6410_rfkill_probe(struct platform_device *pdev) #endif /* #ifdef CONFIG_MACH_JET */ #endif /* #ifdef CONFIG_MACH_SPICA */ #endif /* #ifdef CONFIG_MACH_INSTINCTQ */ { int rc = 0; int irq,ret; //Initialize wake locks wake_lock_init(&rfkill_wake_lock, WAKE_LOCK_SUSPEND, "board-rfkill"); wake_lock_init(&bt_wake_lock, WAKE_LOCK_SUSPEND, "bt-rfkill"); //BT Host Wake IRQ irq = IRQ_BT_HOST_WAKE; ret = request_irq(irq, bt_host_wake_irq_handler, 0, "bt_host_wake_irq_handler", NULL); if(ret < 0) #ifdef CONFIG_MACH_INSTINCTQ printk("[BT] Request_irq failed \n"); #else printk(KERN_DEBUG "[BT] Request_irq failed \n"); #endif /* #else #ifdef CONFIG_MACH_INSTINCTQ */ set_irq_type(irq, IRQ_TYPE_EDGE_BOTH); enable_irq(IRQ_EINT(22)); //RFKILL init - default to bluetooth off rfkill_switch_all(RFKILL_TYPE_BLUETOOTH, RFKILL_STATE_SOFT_BLOCKED); bt_rfk = rfkill_allocate(&pdev->dev, RFKILL_TYPE_BLUETOOTH); if (!bt_rfk) return -ENOMEM; bt_rfk->name = bt_name; bt_rfk->state = RFKILL_STATE_SOFT_BLOCKED; /* userspace cannot take exclusive control */ bt_rfk->user_claim_unsupported = 1; bt_rfk->user_claim = 0; bt_rfk->data = NULL; // user data bt_rfk->toggle_radio = bluetooth_set_power; #ifdef CONFIG_MACH_INSTINCTQ printk("[BT] rfkill_register(bt_rfk) \n"); #else printk(KERN_DEBUG "[BT] rfkill_register(bt_rfk) \n"); #endif /* #ifdef CONFIG_MACH_INSTINCTQ */ rc = rfkill_register(bt_rfk); if (rc) rfkill_free(bt_rfk); bluetooth_set_power(NULL, RFKILL_STATE_SOFT_BLOCKED); return rc; }
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 __init jupiter_rfkill_probe(struct platform_device *pdev) { int rc = 0; int irq,ret; //Initialize wake locks wake_lock_init(&rfkill_wake_lock, WAKE_LOCK_SUSPEND, "board-rfkill"); wake_lock_init(&bt_wake_lock, WAKE_LOCK_SUSPEND, "bt-rfkill"); //BT Host Wake IRQ irq = IRQ_BT_HOST_WAKE; set_irq_type(irq, IRQ_TYPE_EDGE_BOTH); ret = request_irq(irq, bt_host_wake_irq_handler, 0, "bt_host_wake_irq_handler", NULL); if(ret < 0) printk(KERN_ERR "[BT] Request_irq failed \n"); set_irq_type(irq, IRQ_TYPE_EDGE_BOTH); // enable_irq(IRQ_EINT(22)); //RFKILL init - default to bluetooth off rfkill_switch_all(RFKILL_TYPE_BLUETOOTH, RFKILL_STATE_SOFT_BLOCKED); bt_rfk = rfkill_allocate(&pdev->dev, RFKILL_TYPE_BLUETOOTH); if (!bt_rfk) return -ENOMEM; bt_rfk->name = bt_name; bt_rfk->state = RFKILL_STATE_SOFT_BLOCKED; /* userspace cannot take exclusive control */ bt_rfk->user_claim_unsupported = 1; bt_rfk->user_claim = 0; bt_rfk->data = NULL; // user data bt_rfk->toggle_radio = bluetooth_set_power; printk(KERN_DEBUG "[BT] rfkill_register(bt_rfk) \n"); rc = rfkill_register(bt_rfk); if (rc) { printk (KERN_ERR "***********ERROR IN REGISTERING THE RFKILL***********\n"); rfkill_free(bt_rfk); } bluetooth_set_power(NULL, RFKILL_STATE_SOFT_BLOCKED); rfkill_force_state(bt_rfk, RFKILL_STATE_SOFT_BLOCKED); return rc; }
static int __init jupiter_rfkill_probe(struct platform_device *pdev) { int rc = 0; int irq,ret; //Initialize wake locks wake_lock_init(&rfkill_wake_lock, WAKE_LOCK_SUSPEND, "board-rfkill"); #ifdef BT_SLEEP_ENABLER wake_lock_init(&bt_wake_lock, WAKE_LOCK_SUSPEND, "bt-rfkill"); #endif //BT Host Wake IRQ irq = IRQ_BT_HOST_WAKE; s3c_gpio_cfgpin(GPIO_BT_HOST_WAKE, S3C_GPIO_SFN(GPIO_BT_HOST_WAKE_AF)); s3c_gpio_setpull(S5PV210_GPH2(5), S3C_GPIO_PULL_DOWN); set_irq_type(IRQ_EINT(21), IRQ_TYPE_EDGE_BOTH); set_irq_type(irq, IRQ_TYPE_EDGE_RISING); ret = request_irq(irq, bt_host_wake_irq_handler, 0, "bt_host_wake_irq_handler", NULL); if(ret < 0) printk(KERN_ERR "[BT] Request_irq failed \n"); // enable_irq(IRQ_BT_HOST_WAKE); //RFKILL init - default to bluetooth off //rfkill_switch_all(RFKILL_TYPE_BLUETOOTH, RFKILL_USER_STATE_SOFT_BLOCKED); bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH, &bt_rfkill_ops, NULL); if (!bt_rfk) return -ENOMEM; rfkill_init_sw_state(bt_rfk, 0); printk(KERN_DEBUG "[BT] rfkill_register(bt_rfk) \n"); rc = rfkill_register(bt_rfk); if (rc) { printk ("***********ERROR IN REGISTERING THE RFKILL***********\n"); rfkill_destroy(bt_rfk); } rfkill_set_sw_state(bt_rfk, 1); bluetooth_set_power(NULL, RFKILL_USER_STATE_SOFT_BLOCKED); return rc; }
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 __init jupiter_rfkill_probe(struct platform_device *pdev) { int rc = 0; int irq,ret; //Initialize wake locks wake_lock_init(&rfkill_wake_lock, WAKE_LOCK_SUSPEND, "board-rfkill"); #ifdef BT_SLEEP_ENABLER wake_lock_init(&bt_wake_lock, WAKE_LOCK_SUSPEND, "bt-rfkill"); #endif //BT Host Wake IRQ irq = IRQ_BT_HOST_WAKE; // p9p9 2010.11.12 Merged from Victory [When AP is in sleep, AP is not waken up by BT_HOST_WAKE] set_irq_type(irq, IRQ_TYPE_EDGE_BOTH ); //set_irq_type(irq, IRQ_TYPE_EDGE_RISING); ret = request_irq(irq, bt_host_wake_irq_handler, 0, "bt_host_wake_irq_handler", NULL); if(ret < 0) printk(KERN_ERR "[BT] Request_irq failed ret=%d %d<-->%d\n", ret, IRQ_EINT(4), IRQ_EINT4); // enable_irq(IRQ_BT_HOST_WAKE); //RFKILL init - default to bluetooth off //rfkill_switch_all(RFKILL_TYPE_BLUETOOTH, RFKILL_USER_STATE_SOFT_BLOCKED); bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH, &bt_rfkill_ops, NULL); if (!bt_rfk) return -ENOMEM; rfkill_init_sw_state(bt_rfk, 0); printk(KERN_DEBUG "[BT] rfkill_register(bt_rfk) \n"); rc = rfkill_register(bt_rfk); if (rc) { printk ("***********ERROR IN REGISTERING THE RFKILL***********\n"); rfkill_destroy(bt_rfk); } rfkill_set_sw_state(bt_rfk, 1); bluetooth_set_power(NULL, RFKILL_USER_STATE_SOFT_BLOCKED); return rc; }
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 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 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 __init aries_rfkill_probe(struct platform_device *pdev) { int irq,ret; /* Initialize wake locks */ wake_lock_init(&rfkill_wake_lock, WAKE_LOCK_SUSPEND, "bt_host_wake"); ret = gpio_request(GPIO_WLAN_BT_EN, "GPB"); if (ret < 0) { pr_err("[BT] Failed to request GPIO_WLAN_BT_EN!\n"); goto err_req_gpio_wlan_bt_en; } ret = gpio_request(GPIO_BT_nRST, "GPB"); if (ret < 0) { pr_err("[BT] Failed to request GPIO_BT_nRST!\n"); goto err_req_gpio_bt_nrst; } //BT Host Wake IRQ irq = IRQ_BT_HOST_WAKE; ret = request_irq(irq, bt_host_wake_irq_handler, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "bt_host_wake_irq_handler", NULL); if (ret < 0) { pr_err("[BT] Request_irq failed\n"); goto err_req_irq; } disable_irq(irq); bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH, &bt_rfkill_ops, NULL); if (!bt_rfk) { pr_err("[BT] bt_rfk : rfkill_alloc is failed\n"); ret = -ENOMEM; goto err_alloc; } rfkill_init_sw_state(bt_rfk, 0); pr_debug("[BT] rfkill_register(bt_rfk)\n"); ret = rfkill_register(bt_rfk); if (ret) { pr_debug("********ERROR IN REGISTERING THE RFKILL********\n"); goto err_register; } rfkill_set_sw_state(bt_rfk, 1); bluetooth_set_power(NULL, RFKILL_USER_STATE_SOFT_BLOCKED); #ifdef BT_SLEEP_ENABLER wake_lock_init(&bt_wake_lock, WAKE_LOCK_SUSPEND, "bt_wake"); ret = gpio_request(GPIO_BT_WAKE, "gpio_bt_wake"); if (ret < 0) { pr_err("[BT] Failed to request GPIO_BT_WAKE\n"); goto err_req_gpio_bt_wake; } gpio_direction_output(GPIO_BT_WAKE, GPIO_LEVEL_LOW); bt_sleep_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH, &btsleep_rfkill_ops, NULL); if (!bt_sleep_rfk) { pr_err("[BT] bt_sleep_rfk : rfkill_alloc is failed\n"); ret = -ENOMEM; goto err_sleep_alloc; } rfkill_set_sw_state(bt_sleep_rfk, 1); pr_debug("[BT] rfkill_register(bt_sleep_rfk)\n"); ret = rfkill_register(bt_sleep_rfk); if (ret) { pr_err("********ERROR IN REGISTERING THE bt_sleep_rfk********\n"); goto err_sleep_register; } #endif #ifdef USE_LOCK_DVFS bt_lock_dvfs_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH, &bt_lock_dvfs_rfkill_ops, NULL); if (!bt_lock_dvfs_rfk) { pr_err("[BT] bt_lock_dvfs_rfk : rfkill_alloc is failed\n"); ret = -ENOMEM; goto err_dvfs_lock_alloc; } pr_debug("[BT] rfkill_register(bt_lock_dvfs_rfk)\n"); ret = rfkill_register(bt_lock_dvfs_rfk); if (ret) { pr_err("********ERROR IN REGISTERING THE bt_lock_dvfs_rfk********\n"); goto err_lock_dvfs_register; } bt_lock_dvfs_l2_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH, &bt_lock_dvfs_l2_rfkill_ops, NULL); if (!bt_lock_dvfs_l2_rfk) { pr_err("[BT] bt_lock_dvfs_l2_rfk : rfkill_alloc is failed\n"); ret = -ENOMEM; goto err_dvfs_l2_lock_alloc; } pr_debug("[BT] rfkill_register(bt_lock_dvfs_l2_rfk)\n"); ret = rfkill_register(bt_lock_dvfs_l2_rfk); if (ret) { pr_err("********ERROR IN REGISTERING THE bt_lock_dvfs_l2_rfk********\n"); goto err_lock_dvfs_l2_register; } #endif return ret; #ifdef USE_LOCK_DVFS err_lock_dvfs_l2_register: rfkill_destroy(bt_lock_dvfs_l2_rfk); err_dvfs_l2_lock_alloc: rfkill_unregister(bt_lock_dvfs_rfk); err_lock_dvfs_register: rfkill_destroy(bt_lock_dvfs_rfk); err_dvfs_lock_alloc: rfkill_unregister(bt_sleep_rfk); #endif #ifdef BT_SLEEP_ENABLER err_sleep_register: rfkill_destroy(bt_sleep_rfk); err_sleep_alloc: gpio_free(GPIO_BT_WAKE); err_req_gpio_bt_wake: rfkill_unregister(bt_rfk); #endif err_register: rfkill_destroy(bt_rfk); err_alloc: free_irq(irq, NULL); err_req_irq: gpio_free(GPIO_BT_nRST); err_req_gpio_bt_nrst: gpio_free(GPIO_WLAN_BT_EN); err_req_gpio_wlan_bt_en: return ret; }
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 __init herring_rfkill_probe(struct platform_device *pdev) { int irq; int ret; /* Initialize wake locks */ wake_lock_init(&rfkill_wake_lock, WAKE_LOCK_SUSPEND, "bt_host_wake"); ret = gpio_request(GPIO_WLAN_BT_EN, "GPB"); if (ret < 0) { pr_err("[BT] Failed to request GPIO_WLAN_BT_EN!\n"); goto err_req_gpio_wlan_bt_en; } ret = gpio_request(GPIO_BT_nRST, "GPB"); if (ret < 0) { pr_err("[BT] Failed to request GPIO_BT_nRST!\n"); goto err_req_gpio_bt_nrst; } /* BT Host Wake IRQ */ irq = IRQ_BT_HOST_WAKE; ret = request_irq(irq, bt_host_wake_irq_handler, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "bt_host_wake_irq_handler", NULL); if (ret < 0) { pr_err("[BT] Request_irq failed\n"); goto err_req_irq; } disable_irq(irq); bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH, &bt_rfkill_ops, NULL); if (!bt_rfk) { pr_err("[BT] bt_rfk : rfkill_alloc is failed\n"); ret = -ENOMEM; goto err_alloc; } rfkill_init_sw_state(bt_rfk, 0); pr_debug("[BT] rfkill_register(bt_rfk)\n"); ret = rfkill_register(bt_rfk); if (ret) { pr_debug("********ERROR IN REGISTERING THE RFKILL********\n"); goto err_register; } rfkill_set_sw_state(bt_rfk, 1); bluetooth_set_power(NULL, RFKILL_USER_STATE_SOFT_BLOCKED); return ret; err_register: rfkill_destroy(bt_rfk); err_alloc: free_irq(irq, NULL); err_req_irq: gpio_free(GPIO_BT_nRST); err_req_gpio_bt_nrst: gpio_free(GPIO_WLAN_BT_EN); err_req_gpio_wlan_bt_en: return ret; }