static int capella_cm3602_disable(struct capella_cm3602_data *data) { int rc = -EIO; int irq = data->pdata->irq; IPS("%s\n", __func__); if (!data->enabled) { DPS("%s: already disabled\n", __func__); return 0; } disable_irq(irq); rc = irq_set_irq_wake(irq, 0); if (rc < 0) EPS("%s: failed to set irq %d as a non-wake interrupt\n", __func__, irq); rc = gpio_direction_output(data->pdata->p_en, 1); if (rc < 0) return rc; data->pdata->power(PS_PWR_ON, 0); data->enabled = 0; input_event(data->input_dev, EV_SYN, SYN_CONFIG, 0); return rc; }
static int __devinit msm_gpio_probe(struct platform_device *dev) { int i, j = 0; int grp_irq; for (i = FIRST_GPIO_IRQ; i < FIRST_GPIO_IRQ + NR_GPIO_IRQS; i++) { if (i - FIRST_GPIO_IRQ >= msm_gpio_chips[j].chip.base + msm_gpio_chips[j].chip.ngpio) j++; irq_set_chip_data(i, &msm_gpio_chips[j]); irq_set_chip_and_handler(i, &msm_gpio_irq_chip, handle_edge_irq); set_irq_flags(i, IRQF_VALID); } for (i = 0; i < dev->num_resources; i++) { grp_irq = platform_get_irq(dev, i); if (grp_irq < 0) return -ENXIO; irq_set_chained_handler(grp_irq, msm_gpio_irq_handler); irq_set_irq_wake(grp_irq, (i + 1)); } for (i = 0; i < ARRAY_SIZE(msm_gpio_chips); i++) { spin_lock_init(&msm_gpio_chips[i].lock); __raw_writel(0, msm_gpio_chips[i].regs.int_en); gpiochip_add(&msm_gpio_chips[i].chip); } mb(); return 0; }
static uint32_t msm_sdcc_setup_power(struct device *dv, unsigned int vdd) { int rc = 0; struct platform_device *pdev; static int first_setup = 1; pdev = container_of(dv, struct platform_device, dev); rc = msm_sdcc_setup_gpio(pdev->id, !!vdd); if (rc) goto out; rc = msm_sdcc_setup_vreg(pdev->id, !!vdd); /* if first called related to sdcc1, * irq should be registered as wakeup source * [email protected], 2010-02-19 */ if (vdd && first_setup) { struct mmc_platform_data *pdata = pdev->dev.platform_data; if (pdev->id == 1) { first_setup = 0; irq_set_irq_wake(pdata->status_irq, 1); } } out: return rc; }
static int bcm_bt_lpm_init(struct platform_device *pdev) { int irq; int ret; hrtimer_init(&bt_lpm.enter_lpm_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); bt_lpm.enter_lpm_delay = ktime_set(1, 0); /* 1 sec */ bt_lpm.enter_lpm_timer.function = enter_lpm; bt_lpm.host_wake = 0; bt_is_running = 0; irq = IRQ_BT_HOST_WAKE; ret = request_irq(irq, host_wake_isr, IRQF_TRIGGER_HIGH, "bt host_wake", NULL); if (ret) { pr_err("[BT] Request_host wake irq failed.\n"); return ret; } ret = irq_set_irq_wake(irq, 1); if (ret) { pr_err("[BT] Set_irq_wake failed.\n"); return ret; } snprintf(bt_lpm.wake_lock_name, sizeof(bt_lpm.wake_lock_name), "BTLowPower"); wake_lock_init(&bt_lpm.wake_lock, WAKE_LOCK_SUSPEND, bt_lpm.wake_lock_name); return 0; }
static void sdhci_s3c_setup_card_detect_gpio(struct sdhci_s3c *sc) { struct s3c_sdhci_platdata *pdata = sc->pdata; struct device *dev = &sc->pdev->dev; if (sc->ext_cd_gpio > 0) { sc->ext_cd_irq = gpio_to_irq(pdata->ext_cd_gpio); if (sc->ext_cd_irq && request_threaded_irq(sc->ext_cd_irq, NULL, sdhci_s3c_gpio_card_detect_thread, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, dev_name(dev), sc) == 0) { int status = gpio_get_value(sc->ext_cd_gpio); if (pdata->ext_cd_gpio_invert) status = !status; if (status) mmc_host_sd_set_present(sc->host->mmc); else mmc_host_sd_clear_present(sc->host->mmc); /* T-Flash EINT for CD SHOULD be wakeup source */ irq_set_irq_wake(sc->ext_cd_irq, 1); sdhci_s3c_notify_change(sc->pdev, status); } else { dev_warn(dev, "cannot request irq for card detect\n"); sc->ext_cd_irq = 0; } } }
static int bcm_bt_lpm_probe(struct platform_device *pdev) { int irq; int ret; struct bcm_bt_lpm_platform_data *pdata = pdev->dev.platform_data; if (bt_lpm.request_clock_off_locked != NULL) { printk(KERN_ERR "Cannot register two bcm_bt_lpm drivers\n"); return -EINVAL; } bt_lpm.gpio_wake = pdata->gpio_wake; bt_lpm.gpio_host_wake = pdata->gpio_host_wake; bt_lpm.request_clock_off_locked = pdata->request_clock_off_locked; bt_lpm.request_clock_on_locked = pdata->request_clock_on_locked; hrtimer_init(&bt_lpm.enter_lpm_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); bt_lpm.enter_lpm_delay = ktime_set(1, 0); /* 1 sec */ bt_lpm.enter_lpm_timer.function = enter_lpm; gpio_set_value(bt_lpm.gpio_wake, 0); bt_lpm.host_wake = 0; irq = gpio_to_irq(bt_lpm.gpio_host_wake); ret = request_irq(irq, host_wake_isr, IRQF_TRIGGER_HIGH, "bt host_wake", NULL); if (ret) return ret; ret = irq_set_irq_wake(irq, 1); if (ret) return ret; return 0; }
static int capella_cm3602_enable(struct capella_cm3602_data *data) { int rc; int irq = data->pdata->irq; IPS("%s\n", __func__); if (data->enabled) { DPS("%s: already enabled\n", __func__); return 0; } /* dummy report */ input_report_abs(data->input_dev, ABS_DISTANCE, -1); input_sync(data->input_dev); data->pdata->power(PS_PWR_ON, 1); rc = gpio_direction_output(data->pdata->p_en, 0); msleep(220); data->enabled = !rc; if (!rc) capella_cm3602_report(data); enable_irq(irq); rc = irq_set_irq_wake(irq, 1); if (rc < 0) EPS("%s: failed to set irq %d as a wake interrupt\n", __func__, irq); return rc; }
static int felica_rfs_init(void) { int rc; #ifdef FEATURE_DEBUG_LOW FELICA_DEBUG_MSG("[FELICA_RFS] felica_rfs_init - start \n"); #endif /* register the device file */ rc = misc_register(&felica_rfs_device); if (rc < 0) { FELICA_DEBUG_MSG("[FELICA_RFS] FAIL!! can not register felica_rfs \n"); return rc; } #ifdef FELICA_LED_SUPPORT FELICA_DEBUG_MSG("[FELICA_RFS] FELICA LED NEW SUPPORT !!\n"); rc= request_irq(gpio_to_irq(GPIO_FELICA_RFS), felica_rfs_detect_interrupt, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING|IRQF_NO_SUSPEND , FELICA_RFS_NAME, NULL); if (rc) { FELICA_DEBUG_MSG("[FELICA_RFS] FAIL!! can not request_irq \n"); return rc; } irq_set_irq_wake(gpio_to_irq(GPIO_FELICA_RFS),1); init_felica_rfs_wake_lock(); #else FELICA_DEBUG_MSG("[FELICA_RFS] FELICA LED NOT SUPPORT !! \n"); #endif #ifdef FEATURE_DEBUG_LOW FELICA_DEBUG_MSG("[FELICA_RFS] felica_rfs_init - end \n"); #endif return 0; }
static void msm_shutdown(struct uart_port *port) { struct msm_port *msm_port = UART_TO_MSM(port); if (msm_port->uim) msm_write(port, UART_SIM_CFG_SIM_CLK_STOP_HIGH, UART_SIM_CFG); msm_port->imr = 0; msm_write(port, 0, UART_IMR); /* disable interrupts */ free_irq(port->irq, port); #ifdef CONFIG_SERIAL_MSM_RX_WAKEUP if (use_low_power_wakeup(msm_port)) { irq_set_irq_wake(msm_port->wakeup.irq, 0); free_irq(msm_port->wakeup.irq, msm_port); } #endif #ifndef CONFIG_PM_RUNTIME msm_deinit_clock(port); #endif pm_runtime_put_sync(port->dev); }
static __always_inline void max14688_disable_irq (struct max14688 *me, u8 irq_bits) { int rc; if (unlikely(me->irq < 0)) { return; } if (unlikely((me->irq_unmask & irq_bits) == 0)) { /* already masked */ return; } /* clear enabled flag */ me->irq_unmask &= ~irq_bits; if (unlikely(!me->irq_unmask)) { if (likely(device_may_wakeup(me->dev))) { disable_irq_wake(me->irq); } disable_irq(me->irq); irq_set_irq_wake(me->irq, 0); } rc = max14688_write(me, MASK, me->irq_unmask & IRQ_ALL); if (unlikely(rc)) { log_err("MASK write error [%d]n", rc); } }
static int __init msm_mpm_init(void) { unsigned int irq = msm_mpm_dev_data.mpm_ipc_irq; int rc; rc = request_irq(irq, msm_mpm_irq, IRQF_TRIGGER_RISING, "mpm_drv", msm_mpm_irq); if (rc) { pr_err("%s: failed to request irq %u: %d\n", __func__, irq, rc); goto init_bail; } rc = irq_set_irq_wake(irq, 1); if (rc) { pr_err("%s: failed to set wakeup irq %u: %d\n", __func__, irq, rc); goto init_free_bail; } return 0; init_free_bail: free_irq(irq, msm_mpm_irq); init_bail: return rc; }
static void remove_headset(void) { #ifdef FEATURE_AUD_HOOK_BTN unsigned long irq_flags; #endif H2W_DBG(""); hi->ignore_btn = 1; /* FIH-SW2-MM-AY-TAP_Tapioca-00746_00 */ pmic_hsed_enable(PM_HSED_CONTROLLER_0, PM_HSED_ENABLE_OFF); /* FIH-SW2-MM-AY-TAP-ControlHSED_BIAS1-01 */ switch_set_state(&hi->sdev, NO_DEVICE); input_sync(hi->hs_input); #ifdef FEATURE_AUD_HOOK_BTN mHeadphone = false; if (bn_irq_enable) { local_irq_save(irq_flags); disable_irq(hi->irq_btn); local_irq_restore(irq_flags); bn_irq_enable=0; irq_set_irq_wake(hi->irq_btn, 0); } if (atomic_read(&hi->btn_state)) button_released(); #endif }
static int felica_rws_init(void) { int rc = 0; #ifdef FEATURE_DEBUG_LOW FELICA_DEBUG_MSG("[FELICA_RWS] felica_rws_init - start \n"); #endif /* register the device file */ rc = misc_register(&felica_rws_device); if (rc) { FELICA_DEBUG_MSG("[FELICA_RWS] FAIL!! can not register felica_int \n"); return rc; } rc= request_irq(gpio_to_irq(GPIO_FELICA_INT), felica_int_low_isr, IRQF_TRIGGER_FALLING|IRQF_NO_SUSPEND, FELICA_RWS_NAME, NULL); if (rc) { FELICA_DEBUG_MSG("[FELICA_RWS] FAIL!! can not request_irq \n"); return rc; } irq_set_irq_wake(gpio_to_irq(GPIO_FELICA_INT),1); #ifdef FEATURE_DEBUG_LOW FELICA_DEBUG_MSG("[FELICA_RWS] felica_rws_init - end \n"); #endif return 0; }
static void remove_headset(void) { unsigned long irq_flags; pr_info("remove_headset\n"); gpio_set_value(MSM_GPIO_EAR_MICBIAS_EN, 0); mutex_lock(&hi->mutex_lock); switch_set_state(&hi->sdev, switch_get_state(&hi->sdev) & ~(BIT_HEADSET | BIT_HEADSET_NO_MIC)); mutex_unlock(&hi->mutex_lock); if (hi->btn_11pin_35mm_flag) { irq_set_irq_wake(hi->irq_btn, 0); local_irq_save(irq_flags); disable_irq(hi->irq_btn); local_irq_restore(irq_flags); hi->btn_11pin_35mm_flag = 0; if (atomic_read(&hi->btn_state)) headset_button_event(0); } hi->debounce_time = ktime_set(0, 200000000); /* 100 ms */ hrtimer_cancel(&hi->btn_timer); hrtimer_cancel(&hi->irq_delay_timer); hi->btn_irq_available = 0; #ifdef CONFIG_MACH_RAY if (sec_jack_pm_qos) { pm_qos_update_request(&jack_qos_req, PM_QOS_DEFAULT_VALUE); sec_jack_pm_qos = 0; } #endif }
/********************************************************** ** Function: Jack detection-in gpio configuration function ** Parameter: none ** Return value: if sucess, then returns 0 ** ************************************************************/ static int jack_config_gpio() { int ret; printk("HEADSET: Config Jack-in detection gpio\n"); hs_micbias_power(ON); tegra_gpio_enable(JACK_GPIO); ret = gpio_request(JACK_GPIO, "h2w_detect"); ret = gpio_direction_input(JACK_GPIO); hs_data->irq = gpio_to_irq(JACK_GPIO); ret = request_irq(hs_data->irq, detect_irq_handler, IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING, "h2w_detect", NULL); ret = irq_set_irq_wake(hs_data->irq, 1); msleep(1); if (gpio_get_value(JACK_GPIO) == 0){ insert_headset(); }else { hs_micbias_power(OFF); headset_alive = false; remove_headset(); } return 0; }
#ifdef CONFIG_PM static int apds9130_suspend(struct i2c_client *client, pm_message_t mesg) { #if 1 #else struct apds9130_data *data = i2c_get_clientdata(client); if(data->sw_mode == PROX_STAT_SHUTDOWN) return 0; apds9130_set_enable(client, 0); apds9130_set_command(client, 2); __cancel_delayed_work(&data->dwork); flush_delayed_work(&data->dwork); flush_workqueue(apds9130_workqueue); data->sw_mode = PROX_STAT_SHUTDOWN; disable_irq(client->irq); /* err = pdata->power(0); if(err < 0) { printk(KERN_INFO "%s, Proximity Power Off Fail in susped\n",__func__); return err; } */ irq_set_irq_wake(client->irq, 0); if(NULL != apds9130_workqueue){ destroy_workqueue(apds9130_workqueue); printk(KERN_INFO "%s, Destroy workqueue\n",__func__); apds9130_workqueue = NULL; } #endif
static int gpio_rcar_irq_set_wake(struct irq_data *d, unsigned int on) { struct gpio_chip *gc = irq_data_get_irq_chip_data(d); struct gpio_rcar_priv *p = gpiochip_get_data(gc); int error; if (p->irq_parent) { error = irq_set_irq_wake(p->irq_parent, on); if (error) { dev_dbg(&p->pdev->dev, "irq %u doesn't support irq_set_wake\n", p->irq_parent); p->irq_parent = 0; } } if (!p->clk) return 0; if (on) clk_enable(p->clk); else clk_disable(p->clk); return 0; }
static int cw1200_sdio_pm(struct hwbus_priv *self, bool suspend) { int ret = 0; if (self->pdata->irq) ret = irq_set_irq_wake(self->pdata->irq, suspend); return ret; }
int arizona_set_irq_wake(struct arizona *arizona, int irq, int on) { int val = 0; if (on) { val = 0xffff; irq_set_irq_wake(arizona->irq, 1); } else { irq_set_irq_wake(arizona->irq, 0); } switch (irq) { case ARIZONA_IRQ_MICD_CLAMP_RISE: return regmap_update_bits(arizona->regmap, ARIZONA_WAKE_CONTROL, val & ARIZONA_WKUP_MICD_CLAMP_RISE, val & ARIZONA_WKUP_MICD_CLAMP_RISE); case ARIZONA_IRQ_MICD_CLAMP_FALL: return regmap_update_bits(arizona->regmap, ARIZONA_WAKE_CONTROL, val & ARIZONA_WKUP_MICD_CLAMP_FALL, val & ARIZONA_WKUP_MICD_CLAMP_FALL); case ARIZONA_IRQ_GP5_FALL: return regmap_update_bits(arizona->regmap, ARIZONA_WAKE_CONTROL, val & ARIZONA_WKUP_GP5_RISE, val & ARIZONA_WKUP_GP5_RISE); case ARIZONA_IRQ_GP5_RISE: return regmap_update_bits(arizona->regmap, ARIZONA_WAKE_CONTROL, val & ARIZONA_WKUP_GP5_FALL, val & ARIZONA_WKUP_GP5_FALL); case ARIZONA_IRQ_JD_RISE: return regmap_update_bits(arizona->regmap, ARIZONA_WAKE_CONTROL, val & ARIZONA_WKUP_JD1_RISE, val & ARIZONA_WKUP_JD1_RISE); case ARIZONA_IRQ_JD_FALL: return regmap_update_bits(arizona->regmap, ARIZONA_WAKE_CONTROL, val & ARIZONA_WKUP_JD1_FALL, val & ARIZONA_WKUP_JD1_FALL); default: return -ENXIO; } }
int arizona_set_irq_wake(struct arizona *arizona, int irq, int on) { irq = arizona_map_irq(arizona, irq); if (irq < 0) return irq; return irq_set_irq_wake(irq, on); }
static int Remote_Interrupt_Enable(int en) { int ret =0; struct pm8xxx_mpp_config_data sky_handset_digital_adc = { .type = PM8XXX_MPP_TYPE_D_INPUT, .level = PM8058_MPP_DIG_LEVEL_S3, .control = PM8XXX_MPP_DIN_TO_INT, }; if(en) { ret=gpio_get_value_cansleep(hspd->ear_det); if(ret!=hspd->ear_det_active) { printk("EARJACK_DET %d\n",ret); return -1; } if(hspd->curr_state == MSM_HEADSET && hspd->remote_is_int==0) { #if AT1_BDVER_GE(AT1_WS22) ret = pm8xxx_mpp_config(PM8058_MPP_PM_TO_SYS(XOADC_MPP_3), &sky_handset_digital_adc); if (ret < 0) printk("%s: pm8058_mpp_config_DIG ret=%d\n",__func__, ret); /* ret = pm8058_mpp_config_digital_in(PM8058_MPP_SYS_TO_PM(hspd->remote_det), PM8058_MPP_DIG_LEVEL_S3, PM_MPP_DIN_TO_INT); */ #else gpio_tlmm_config(GPIO_CFG(hspd->remote_det, 0, GPIO_CFG_INPUT,GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE); #endif enable_irq(gpio_to_irq(hspd->remote_det)); irq_set_irq_wake(gpio_to_irq(hspd->remote_det),1); hspd->remote_is_int = 1; } } else { if(hspd->remote_is_int==1) { irq_set_irq_wake(gpio_to_irq(hspd->remote_det),0); disable_irq(gpio_to_irq(hspd->remote_det)); hspd->remote_is_int = 0; #if AT1_BDVER_E(AT1_WS21) gpio_tlmm_config(GPIO_CFG(hspd->remote_det, 0, GPIO_CFG_INPUT,GPIO_CFG_PULL_UP, GPIO_CFG_2MA), GPIO_CFG_ENABLE); #endif } } return 0; }
static long pn544_dev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) { struct pn544_dev *pn544_dev = filp->private_data; switch (cmd) { case PN544_SET_PWR: if (arg == 2) { /* power on with firmware download (requires hw reset) */ printk("%s power on with firmware\n", __func__); gpio_set_value(pn544_dev->ven_gpio, 1); gpio_set_value(pn544_dev->firm_gpio, 1); msleep(10); gpio_set_value(pn544_dev->ven_gpio, 0); msleep(50); gpio_set_value(pn544_dev->ven_gpio, 1); msleep(10); } else if (arg == 1) { /* power on */ //pmu_enable(); printk("%s power on\n", __func__); gpio_set_value(pn544_dev->firm_gpio, 0); gpio_set_value(pn544_dev->ven_gpio, 1); irq_set_irq_wake(pn544_dev->client->irq, 1); msleep(10); } else if (arg == 0) { /* power off */ //pmu_disable(); printk("%s power off\n", __func__); gpio_set_value(pn544_dev->firm_gpio, 0); gpio_set_value(pn544_dev->ven_gpio, 0); irq_set_irq_wake(pn544_dev->client->irq, 0); msleep(10); } else { printk("%s bad arg %lu\n", __func__, arg); return -EINVAL; } break; default: printk("%s bad ioctl %u\n", __func__, cmd); return -EINVAL; } return 0; }
static int max8997_resume(struct device *dev) { struct i2c_client *i2c = container_of(dev, struct i2c_client, dev); struct max8997_dev *max8997 = i2c_get_clientdata(i2c); if (device_may_wakeup(dev)) irq_set_irq_wake(max8997->irq, 0); return max8997_irq_resume(max8997); }
static int max77693_suspend(struct device *dev) { struct i2c_client *i2c = container_of(dev, struct i2c_client, dev); struct max77693_dev *max77693 = i2c_get_clientdata(i2c); if (device_may_wakeup(dev)) irq_set_irq_wake(max77693->irq, 1); return 0; }
/* * cpu irq handler */ void __init nxp_cpu_irq_init(void) { pr_debug("%s:%d\n", __func__, __LINE__); __gic_init(GIC_DIST_BASE, (void __iomem *)GIC_CPUI_BASE); gpio_init(GPIO_INT_BASE , IRQ_GPIO_START, GPIO_INT_MASK, 0); /* 64 ~ 223 (A,B,C,D,E) */ alive_init(ALIVE_INT_BASE, IRQ_ALIVE_START, ALIVE_INT_MASK, 0); /* 224 ~ 231 */ #ifdef CONFIG_FIQ init_FIQ(); #endif /* wake up source from idle */ irq_set_irq_wake(IRQ_PHY_CLKPWR_ALIVEIRQ + GIC_PHY_OFFSET, 1); #if PM_RTC_WAKE irq_set_irq_wake(IRQ_PHY_CLKPWR_RTCIRQ + GIC_PHY_OFFSET, 1); #endif }
static int max8998_suspend(struct device *dev) { struct i2c_client *i2c = container_of(dev, struct i2c_client, dev); struct max8998_dev *max8998 = i2c_get_clientdata(i2c); if (max8998->wakeup) irq_set_irq_wake(max8998->irq, 1); return 0; }
static int max8998_suspend(struct device *dev) { struct i2c_client *i2c = to_i2c_client(dev); struct max8998_dev *max8998 = i2c_get_clientdata(i2c); if (device_may_wakeup(dev)) irq_set_irq_wake(max8998->irq, 1); return 0; }
static void stm32_ipcc_set_irq_wake(struct device *dev, bool enable) { struct stm32_ipcc *ipcc = dev_get_drvdata(dev); unsigned int i; if (device_may_wakeup(dev)) for (i = 0; i < IPCC_IRQ_NUM; i++) irq_set_irq_wake(ipcc->irqs[i], enable); }
int __init x3proto_gpio_setup(void) { int ilsel; int ret, i; ilsel = ilsel_enable(ILSEL_KEY); if (unlikely(ilsel < 0)) return ilsel; ret = gpiochip_add(&x3proto_gpio_chip); if (unlikely(ret)) goto err_gpio; for (i = 0; i < NR_BASEBOARD_GPIOS; i++) { unsigned long flags; int irq = create_irq(); if (unlikely(irq < 0)) { ret = -EINVAL; goto err_irq; } spin_lock_irqsave(&x3proto_gpio_lock, flags); x3proto_gpio_irq_map[i] = irq; irq_set_chip_and_handler_name(irq, &dummy_irq_chip, handle_simple_irq, "gpio"); spin_unlock_irqrestore(&x3proto_gpio_lock, flags); } pr_info("registering '%s' support, handling GPIOs %u -> %u, " "bound to IRQ %u\n", x3proto_gpio_chip.label, x3proto_gpio_chip.base, x3proto_gpio_chip.base + x3proto_gpio_chip.ngpio, ilsel); irq_set_chained_handler(ilsel, x3proto_gpio_irq_handler); irq_set_irq_wake(ilsel, 1); return 0; err_irq: for (; i >= 0; --i) if (x3proto_gpio_irq_map[i]) destroy_irq(x3proto_gpio_irq_map[i]); ret = gpiochip_remove(&x3proto_gpio_chip); if (unlikely(ret)) pr_err("Failed deregistering GPIO\n"); err_gpio: synchronize_irq(ilsel); ilsel_disable(ILSEL_KEY); return ret; }
int __init msm_rpm_init(struct msm_rpm_platform_data *data) { unsigned int irq; int rc; if (cpu_is_apq8064()) return 0; msm_rpm_platform = data; fw_major = msm_rpm_read(MSM_RPM_PAGE_STATUS, MSM_RPM_STATUS_ID_VERSION_MAJOR); fw_minor = msm_rpm_read(MSM_RPM_PAGE_STATUS, MSM_RPM_STATUS_ID_VERSION_MINOR); fw_build = msm_rpm_read(MSM_RPM_PAGE_STATUS, MSM_RPM_STATUS_ID_VERSION_BUILD); pr_info("%s: RPM firmware %u.%u.%u\n", __func__, fw_major, fw_minor, fw_build); if (fw_major != RPM_MAJOR_VER) { pr_err("%s: RPM version %u.%u.%u incompatible with " "this driver version %u.%u.%u\n", __func__, fw_major, fw_minor, fw_build, RPM_MAJOR_VER, RPM_MINOR_VER, RPM_BUILD_VER); return -EFAULT; } msm_rpm_write(MSM_RPM_PAGE_CTRL, MSM_RPM_CTRL_VERSION_MAJOR, RPM_MAJOR_VER); msm_rpm_write(MSM_RPM_PAGE_CTRL, MSM_RPM_CTRL_VERSION_MINOR, RPM_MINOR_VER); msm_rpm_write(MSM_RPM_PAGE_CTRL, MSM_RPM_CTRL_VERSION_BUILD, RPM_BUILD_VER); irq = msm_rpm_platform->irq_ack; rc = request_irq(irq, msm_rpm_ack_interrupt, IRQF_TRIGGER_RISING | IRQF_NO_SUSPEND, "rpm_drv", msm_rpm_ack_interrupt); if (rc) { pr_err("%s: failed to request irq %d: %d\n", __func__, irq, rc); return rc; } rc = irq_set_irq_wake(irq, 1); if (rc) { pr_err("%s: failed to set wakeup irq %u: %d\n", __func__, irq, rc); return rc; } msm_rpm_populate_map(); return platform_driver_register(&msm_rpm_platform_driver); }