static int nokia_modem_remove(struct device *dev) { struct nokia_modem_device *modem = dev_get_drvdata(dev); if (!modem) return 0; if (modem->ssi_protocol) { hsi_remove_client(&modem->ssi_protocol->device, NULL); modem->ssi_protocol = NULL; } nokia_modem_gpio_unexport(dev); dev_set_drvdata(dev, NULL); disable_irq_wake(modem->nokia_modem_rst_ind_irq); tasklet_kill(&modem->nokia_modem_rst_ind_tasklet); return 0; }
void reset_mcu(struct ssp_data *data) { disable_irq(data->iIrq); disable_irq_wake(data->iIrq); toggle_mcu_reset(data); msleep(SSP_SW_RESET_TIME); if (initialize_mcu(data) < 0) data->bCheckShutdown = true; sync_sensor_state(data); enable_irq(data->iIrq); enable_irq_wake(data->iIrq); #ifdef CONFIG_SENSORS_SSP_SENSORHUB ssp_report_sensorhub_notice(data, MSG2SSP_AP_STATUS_RESET); #endif }
void seport_platform_unregister_plug_detect_gpio_callback(void *data) { int irq; (void)gpio_direction_output(seport_conf->headset_detect_enable_pin, 0); if (seport_plug_detect_interrupt_enabled) { irq = gpio_to_irq(seport_conf->plug_detect_read_pin); if (0 <= irq) { disable_irq_wake(irq); free_irq(irq, data); seport_plug_detect_interrupt_enabled = 0; } else { printk(KERN_CRIT "%s - Failed to disable plug detect" \ "interrupt. GPIO (%d) does not exist\n", __func__, seport_conf->plug_detect_read_pin); } } }
static int st_rc_resume(struct device *dev) { struct st_rc_device *rc_dev = dev_get_drvdata(dev); struct rc_dev *rdev = rc_dev->rdev; if (rc_dev->irq_wake) { disable_irq_wake(rc_dev->irq); rc_dev->irq_wake = 0; } else { pinctrl_pm_select_default_state(dev); st_rc_hardware_init(rc_dev); if (rdev->users) { writel(IRB_RX_INTS, rc_dev->rx_base + IRB_RX_INT_EN); writel(0x01, rc_dev->rx_base + IRB_RX_EN); } } return 0; }
static ssize_t proximity_enable_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct gp2a_data *gp2a = dev_get_drvdata(dev); bool new_value; if (sysfs_streq(buf, "1")) new_value = true; else if (sysfs_streq(buf, "0")) new_value = false; else { pr_err("%s: invalid value %d\n", __func__, *buf); return -EINVAL; } #ifdef CONFIG_TOUCH_WAKE if (!new_value) proximity_off(); #endif mutex_lock(&gp2a->power_lock); gp2a_dbgmsg("new_value = %d, old state = %d\n", new_value, (gp2a->power_state & PROXIMITY_ENABLED) ? 1 : 0); if (new_value && !(gp2a->power_state & PROXIMITY_ENABLED)) { if (!gp2a->power_state) gp2a->pdata->power(true); gp2a->power_state |= PROXIMITY_ENABLED; enable_irq(gp2a->irq); enable_irq_wake(gp2a->irq); gp2a_i2c_write(gp2a, REGS_GAIN, ®_defaults[1]); gp2a_i2c_write(gp2a, REGS_HYS, ®_defaults[2]); gp2a_i2c_write(gp2a, REGS_CYCLE, ®_defaults[3]); gp2a_i2c_write(gp2a, REGS_OPMOD, ®_defaults[4]); } else if (!new_value && (gp2a->power_state & PROXIMITY_ENABLED)) { disable_irq_wake(gp2a->irq); disable_irq(gp2a->irq); gp2a_i2c_write(gp2a, REGS_OPMOD, ®_defaults[0]); gp2a->power_state &= ~PROXIMITY_ENABLED; if (!gp2a->power_state) gp2a->pdata->power(false); } mutex_unlock(&gp2a->power_lock); return size; }
static void gp2a_prox_work_func(struct work_struct *work) { struct gp2a_data *gp2a = container_of(work, struct gp2a_data, work_prox); u8 vo, value; if (gp2a->irq != 0) { disable_irq_wake(gp2a->irq); disable_irq(gp2a->irq); } else { return ; } gp2a_i2c_read(gp2a, REGS_PROX, &vo); vo = 0x01 & vo; if (vo == gp2a->val_state) { if (!vo) { /* close */ vo = 0x01; value = nondetect; } else { /* far */ vo = 0x00; value = detect; } gp2a_i2c_write(gp2a, REGS_HYS, &value); gp2a->val_state = vo; } input_report_abs(gp2a->proximity_input_dev, ABS_DISTANCE, gp2a->val_state); input_sync(gp2a->proximity_input_dev); /* 1 : far, 0 : close */ pr_info("%s: %d(1:far/0:close)\n", __func__, gp2a->val_state); msleep(20); value = 0x18; gp2a_i2c_write(gp2a, REGS_CON, &value); if (gp2a->irq != 0) { enable_irq(gp2a->irq); enable_irq_wake(gp2a->irq); } value = 0x00; gp2a_i2c_write(gp2a, REGS_CON, &value); }
static int pmic8xxx_kp_resume(struct device *dev) { struct platform_device *pdev = to_platform_device(dev); struct pmic8xxx_kp *kp = platform_get_drvdata(pdev); struct input_dev *input_dev = kp->input; if (device_may_wakeup(dev)) { disable_irq_wake(kp->key_sense_irq); } else { mutex_lock(&input_dev->mutex); if (input_dev->users) pmic8xxx_kp_enable(kp); mutex_unlock(&input_dev->mutex); } return 0; }
static int tegra_rtc_resume(struct platform_device *pdev) { struct device *dev=&pdev->dev; //unsigned long sl_irq_flags; unsigned int intr_status; /* clear */ intr_status = tegra_rtc_read(RTC_TEGRA_REG_INTR_STATUS); if (intr_status & RTC_TEGRA_INTR_STATUS_SEC_ALARM0) { tegra_rtc_write_not_busy(dev, RTC_TEGRA_REG_INTR_MASK, 0); tegra_rtc_write_not_busy(dev, RTC_TEGRA_REG_INTR_STATUS, -1); } dev_vdbg(dev, "Resume (device_may_wakeup=%d)\n", device_may_wakeup(dev)); /* alarms were left on as a wake source, turn them off. */ if (device_may_wakeup(dev)) disable_irq_wake(tegra_rtc_irq); return 0; }
static int cmos_resume(struct device *dev) { struct cmos_rtc *cmos = dev_get_drvdata(dev); unsigned char tmp = cmos->suspend_ctrl; /* re-enable any irqs previously active */ if (tmp & RTC_IRQMASK) { unsigned char mask; if (cmos->enabled_wake) { if (cmos->wake_off) cmos->wake_off(dev); else disable_irq_wake(cmos->irq); cmos->enabled_wake = 0; } spin_lock_irq(&rtc_lock); do { CMOS_WRITE(tmp, RTC_CONTROL); hpet_set_rtc_irq_bit(tmp & RTC_IRQMASK); mask = CMOS_READ(RTC_INTR_FLAGS); mask &= (tmp & RTC_IRQMASK) | RTC_IRQF; if (!is_hpet_enabled() || !is_intr(mask)) break; /* force one-shot behavior if HPET blocked * the wake alarm's irq */ rtc_update_irq(cmos->rtc, 1, mask); tmp &= ~RTC_AIE; hpet_mask_rtc_irq_bit(RTC_AIE); } while (mask & RTC_AIE); spin_unlock_irq(&rtc_lock); } pr_debug("%s: resume, ctrl %02x\n", dev_name(&cmos_rtc.rtc->dev), tmp); return 0; }
static int xgene_rtc_resume(struct device *dev) { struct platform_device *pdev = to_platform_device(dev); struct xgene_rtc_dev *pdata = platform_get_drvdata(pdev); int irq; irq = platform_get_irq(pdev, 0); if (device_may_wakeup(&pdev->dev)) { if (pdata->irq_wake) { disable_irq_wake(irq); pdata->irq_wake = 0; } } else { clk_enable(pdata->clk); xgene_rtc_alarm_irq_enable(dev, 1); } return 0; }
static int mpu6050_input_suspend(struct device *dev) { struct i2c_client *client = to_i2c_client(dev); struct mpu6050_input_data *data = i2c_get_clientdata(client); if (!atomic_read(&data->reactive_enable)) { #ifdef CONFIG_INPUT_MPU6050_POLLING if (atomic_read(&data->accel_enable)) cancel_delayed_work_sync(&data->accel_work); if (atomic_read(&data->gyro_enable)) cancel_delayed_work_sync(&data->gyro_work); #else disable_irq_wake(client->irq); disable_irq(client->irq); #endif mpu6050_input_set_mode(data, MPU6050_MODE_SLEEP); } return 0; }
int capts_resume(struct device *dev) { struct capts *ts = dev_get_drvdata(dev); if(ts->pdata->power_on) ts->pdata->power_on(); spin_lock_irq(&ts->lock); ts->is_suspended = 0; if (ts->irq) { enable_irq(ts->irq); if (device_may_wakeup(dev)) { disable_irq_wake(ts->irq); } } spin_unlock_irq(&ts->lock); return 0; }
static int gpio_keys_resume(struct device *dev) { struct gpio_keys_drvdata *ddata = dev_get_drvdata(dev); int i; for (i = 0; i < ddata->n_buttons; i++) { struct gpio_keys_button *button = ddata->data[i].button; if (button->wakeup && device_may_wakeup(dev)) { int irq = gpio_to_irq(button->gpio); disable_irq_wake(irq); } gpio_keys_report_event(&ddata->data[i]); } input_sync(ddata->input); return 0; }
static int gpio_keys_resume(struct device *dev) { struct platform_device *pdev = to_platform_device(dev); struct gpio_keys_drvdata *ddata = dev_get_drvdata(dev); struct gpio_keys_platform_data *pdata = pdev->dev.platform_data; int wakeup_key = KEY_RESERVED; int i; if (pdata && pdata->wakeup_key) wakeup_key = pdata->wakeup_key(); for (i = 0; i < ddata->n_buttons; i++) { struct gpio_button_data *bdata = &ddata->data[i]; #ifdef CONFIG_MACH_BOSE_ATT if (bdata->button->wakeup && device_may_wakeup(dev)) { disable_irq_wake(bdata->irq); if (wakeup_key == bdata->button->code) { if (gpio_powerkey_resume == 2) { unsigned int type = bdata->button->type ?: EV_KEY; input_event(ddata->input, type, bdata->button->code, 1); input_event(ddata->input, type, bdata->button->code, 0); input_sync(ddata->input); printk(KERN_DEBUG "[KEY] %s code : %d\n", __func__, bdata->button->code); } else if (gpio_powerkey_resume == 1) { printk(KERN_DEBUG "[KEY] %s do not report fake key\n", __func__); } else { gpio_powerkey_resume_error = true; unsigned int type = bdata->button->type ?: EV_KEY; input_event(ddata->input, type, bdata->button->code, 1); input_event(ddata->input, type, bdata->button->code, 0); input_sync(ddata->input); printk(KERN_DEBUG "[KEY] %s code : %d(%d)\n", __func__, bdata->button->code, gpio_powerkey_resume); } }
static int smb347_remove(struct i2c_client *client) { struct smb347_charger *smb = i2c_get_clientdata(client); if (!IS_ERR_OR_NULL(smb->dentry)) debugfs_remove(smb->dentry); if (client->irq) { smb347_irq_disable(smb); disable_irq_wake(client->irq); free_irq(client->irq, smb); gpio_free(smb->pdata->irq_gpio); } power_supply_unregister(&smb->battery); power_supply_unregister(&smb->usb); power_supply_unregister(&smb->mains); return 0; }
static int s3c_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm) { struct rtc_time *tm = &alrm->time; void __iomem *base = s3c_rtc_base; unsigned int alrm_en; pr_debug("s3c_rtc_setalarm: %d, %02x/%02x/%02x %02x.%02x.%02x\n", alrm->enabled, tm->tm_mday & 0xff, tm->tm_mon & 0xff, tm->tm_year & 0xff, tm->tm_hour & 0xff, tm->tm_min & 0xff, tm->tm_sec); alrm_en = readb(base + S3C2410_RTCALM) & S3C2410_RTCALM_ALMEN; writeb(0x00, base + S3C2410_RTCALM); if (tm->tm_sec < 60 && tm->tm_sec >= 0) { alrm_en |= S3C2410_RTCALM_SECEN; writeb(bin2bcd(tm->tm_sec), base + S3C2410_ALMSEC); } if (tm->tm_min < 60 && tm->tm_min >= 0) { alrm_en |= S3C2410_RTCALM_MINEN; writeb(bin2bcd(tm->tm_min), base + S3C2410_ALMMIN); } if (tm->tm_hour < 24 && tm->tm_hour >= 0) { alrm_en |= S3C2410_RTCALM_HOUREN; writeb(bin2bcd(tm->tm_hour), base + S3C2410_ALMHOUR); } pr_debug("setting S3C2410_RTCALM to %08x\n", alrm_en); writeb(alrm_en, base + S3C2410_RTCALM); s3c_rtc_setaie(alrm->enabled); if (alrm->enabled) enable_irq_wake(s3c_rtc_alarmno); else disable_irq_wake(s3c_rtc_alarmno); return 0; }
int forced_to_download_binary(struct ssp_data *data, int iBinType) { int iRet = 0; ssp_dbg("[SSP]: %s - mcu binany update!\n", __func__); if (data->bSspShutdown == false) { data->bSspShutdown = true; disable_irq_wake(data->iIrq); disable_irq(data->iIrq); } iRet = update_mcu_bin(data, iBinType); if (iRet < 0) { iRet = ERROR; ssp_dbg("[SSP]: %s - update_mcu_bin failed!\n", __func__); goto out; } iRet = initialize_mcu(data); if (iRet < 0) { iRet = ERROR; ssp_dbg("[SSP]: %s - initialize_mcu failed!\n", __func__); goto out; } sync_sensor_state(data); #ifdef CONFIG_SENSORS_SSP_SENSORHUB ssp_sensorhub_report_notice(data, MSG2SSP_AP_STATUS_RESET); #endif if (data->bSspShutdown == true) { data->bSspShutdown = false; enable_irq(data->iIrq); enable_irq_wake(data->iIrq); } iRet = SUCCESS; out: return iRet; }
static int s3c2410_rtc_setalarm(struct rtc_wkalrm *alrm) { struct rtc_time *tm = &alrm->time; unsigned int alrm_en; pr_debug("s3c2410_rtc_setalarm: %d, %02x/%02x/%02x %02x.%02x.%02x\n", alrm->enabled, tm->tm_mday & 0xff, tm->tm_mon & 0xff, tm->tm_year & 0xff, tm->tm_hour & 0xff, tm->tm_min & 0xff, tm->tm_sec); if (alrm->enabled || 1) { alrm_en = readb(S3C2410_RTCALM) & S3C2410_RTCALM_ALMEN; writeb(0x00, S3C2410_RTCALM); if (tm->tm_sec < 60 && tm->tm_sec >= 0) { alrm_en |= S3C2410_RTCALM_SECEN; writeb(BIN2BCD(tm->tm_sec), S3C2410_ALMSEC); } if (tm->tm_min < 60 && tm->tm_min >= 0) { alrm_en |= S3C2410_RTCALM_MINEN; writeb(BIN2BCD(tm->tm_min), S3C2410_ALMMIN); } if (tm->tm_hour < 24 && tm->tm_hour >= 0) { alrm_en |= S3C2410_RTCALM_HOUREN; writeb(BIN2BCD(tm->tm_hour), S3C2410_ALMHOUR); } pr_debug("setting S3C2410_RTCALM to %08x\n", alrm_en); writeb(alrm_en, S3C2410_RTCALM); enable_irq_wake(s3c2410_rtc_alarmno); } else { alrm_en = readb(S3C2410_RTCALM); alrm_en &= ~S3C2410_RTCALM_ALMEN; writeb(alrm_en, S3C2410_RTCALM); disable_irq_wake(s3c2410_rtc_alarmno); } return 0; }
static int __devexit ehci_hsic_msm_remove(struct platform_device *pdev) { struct usb_hcd *hcd = platform_get_drvdata(pdev); struct msm_hsic_hcd *mehci = hcd_to_hsic(hcd); if (mehci->peripheral_status_irq) free_irq(mehci->peripheral_status_irq, mehci); if (mehci->wakeup_irq) { if (mehci->wakeup_irq_enabled) disable_irq_wake(mehci->wakeup_irq); free_irq(mehci->wakeup_irq, mehci); } /* * If the update request is called after unregister, the request will * fail. Results are undefined if unregister is called in the middle of * update request. */ mehci->bus_vote = false; cancel_work_sync(&mehci->bus_vote_w); if (mehci->bus_perf_client) msm_bus_scale_unregister_client(mehci->bus_perf_client); ehci_hsic_msm_debugfs_cleanup(); device_init_wakeup(&pdev->dev, 0); pm_runtime_set_suspended(&pdev->dev); destroy_workqueue(ehci_wq); usb_remove_hcd(hcd); msm_hsic_config_gpios(mehci, 0); msm_hsic_init_vddcx(mehci, 0); msm_hsic_init_clocks(mehci, 0); wake_lock_destroy(&mehci->wlock); iounmap(hcd->regs); usb_put_hcd(hcd); return 0; }
static int tegra_sdhci_resume(struct platform_device *pdev) { struct tegra_sdhci_host *host = platform_get_drvdata(pdev); int ret; u8 pwr; MMC_printk("%s:+", mmc_hostname(host->sdhci->mmc)); if ((host->card_always_on && is_card_sdio(host->sdhci->mmc->card))||is_card_mmc(host->sdhci->mmc->card)) { int ret = 0; if (device_may_wakeup(&pdev->dev)) { disable_irq_wake(host->sdhci->irq); } /* soft reset SD host controller and enable interrupts */ ret = tegra_sdhci_restore(host->sdhci); if (ret) { pr_err("%s: failed, error = %d\n", __func__, ret); return ret; } mmiowb(); host->sdhci->mmc->ops->set_ios(host->sdhci->mmc, &host->sdhci->mmc->ios); printk("tegra_sdhci_suspend: skip %s resume(always on)!\n",is_card_mmc(host->sdhci->mmc->card)?"eMMC":"SDIO"); return 0; } tegra_sdhci_enable_clock(host, 1); pwr = SDHCI_POWER_ON; sdhci_writeb(host->sdhci, pwr, SDHCI_POWER_CONTROL); host->sdhci->pwr = 0; ret = sdhci_resume_host(host->sdhci); if (ret) pr_err("%s: failed, error = %d\n", __func__, ret); MMC_printk("%s:-", mmc_hostname(host->sdhci->mmc)); return ret; }
static int max77804_resume(struct device *dev) { struct i2c_client *i2c = container_of(dev, struct i2c_client, dev); struct max77804_dev *max77804 = i2c_get_clientdata(i2c); #if !defined(CONFIG_SAMSUNG_PRODUCT_SHIP) pr_info("%s:%s\n", MFD_DEV_NAME, __func__); #endif /* CONFIG_SAMSUNG_PRODUCT_SHIP */ if (device_may_wakeup(dev)) disable_irq_wake(max77804->irq); enable_irq(max77804->irq); #if defined(CONFIG_MFD_MAX77804) return max77804_irq_resume(max77804); #elif defined(CONFIG_MFD_MAX77804K) return max77804k_irq_resume(max77804); #endif }
static int msm_hsic_pm_suspend(struct device *dev) { int ret; struct usb_hcd *hcd = dev_get_drvdata(dev); struct msm_hsic_hcd *mehci = hcd_to_hsic(hcd); dev_dbg(dev, "ehci-msm-hsic PM suspend\n"); dbg_log_event(NULL, "PM Suspend", 0); if (device_may_wakeup(dev)) enable_irq_wake(hcd->irq); ret = msm_hsic_suspend(mehci); if (ret && device_may_wakeup(dev)) disable_irq_wake(hcd->irq); return ret; }
static int s3c_rtc_resume(struct platform_device *pdev) { unsigned int tmp; clk_enable(rtc_clk); s3c_rtc_enable(pdev, 1); writeb(ticnt_save, s3c_rtc_base + S3C2410_TICNT); if (s3c_rtc_cpu_type == TYPE_S3C64XX && ticnt_en_save) { tmp = readw(s3c_rtc_base + S3C2410_RTCCON); writew(tmp | ticnt_en_save, s3c_rtc_base + S3C2410_RTCCON); } if (device_may_wakeup(&pdev->dev) && wake_en) { disable_irq_wake(s3c_rtc_alarmno); wake_en = false; } clk_disable(rtc_clk); return 0; }
static int msm_serial_hsl_resume(struct device *dev) { struct platform_device *pdev = to_platform_device(dev); struct uart_port *port; port = get_port_from_line(pdev->id); D("%s ():port->line %d, ir\n", __func__, port->line); if (port) { D("%s ():uart_resume_port:port->line %d, ir\n", __func__, port->line); enable_irda(3); uart_resume_port(&msm_hsl_uart_driver, port); if (device_may_wakeup(dev)) disable_irq_wake(port->irq); if (is_console(port)) msm_hsl_init_clock(port); } return 0; }
static int lge_ts_misc_enable(struct lge_ts_misc_info *info, bool onoff) { static bool irq_enabled = true; if (!info->client->irq) { return 0; } if (onoff && !irq_enabled) { irq_enabled = true; enable_irq(info->client->irq); enable_irq_wake(info->client->irq); } else if (!onoff && irq_enabled) { irq_enabled = false; disable_irq_nosync(info->client->irq); disable_irq_wake(info->client->irq); } return 0; }
static void bluesleep_abnormal_stop(void) { BT_ERR("bluesleep_abnormal_stop"); if (!test_bit(BT_PROTO, &flags)) { BT_ERR("(bluesleep_abnormal_stop) proto is not set. Failed to stop bluesleep"); bsi->uport = NULL; return; } del_timer(&tx_timer); clear_bit(BT_PROTO, &flags); if (disable_irq_wake(bsi->host_wake_irq)) BT_ERR("Couldn't disable hostwake IRQ wakeup mode\n"); wake_lock_timeout(&bsi->wake_lock, msecs_to_jiffies(125)); clear_bit(BT_TXDATA, &flags); bsi->uport = NULL; }
static int rmi_spi_resume(struct device *dev) { struct spi_device *spi = to_spi_device(dev); struct rmi_spi_xport *rmi_spi = spi_get_drvdata(spi); int ret; enable_irq(rmi_spi->irq); if (device_may_wakeup(&spi->dev)) { ret = disable_irq_wake(rmi_spi->irq); if (!ret) dev_warn(dev, "Failed to disable irq for wake: %d\n", ret); } ret = rmi_driver_resume(rmi_spi->xport.rmi_dev); if (ret) dev_warn(dev, "Failed to resume device: %d\n", ret); return ret; }
static int gpio_keys_resume(struct device *dev) { struct gpio_keys_drvdata *ddata = dev_get_drvdata(dev); int i; for (i = 0; i < ddata->n_buttons; i++) { struct gpio_button_data *bdata = &ddata->data[i]; if (bdata->button->wakeup && device_may_wakeup(dev)) { disable_irq_wake(bdata->irq); bdata->button->goog.last_suspend_cnt = get_suspend_cnt(); bdata->button->goog.synth_sent = 0; } if (gpio_is_valid(bdata->button->gpio)) gpio_keys_gpio_report_event(bdata, GPIO_KEYS_RESUME); } input_sync(ddata->input); return 0; }
static int spear_rtc_resume(struct device *dev) { struct platform_device *pdev = to_platform_device(dev); struct spear_rtc_config *config = platform_get_drvdata(pdev); int irq; irq = platform_get_irq(pdev, 0); if (device_may_wakeup(&pdev->dev)) { if (config->irq_wake) { disable_irq_wake(irq); config->irq_wake = 0; } } else { clk_enable(config->clk); spear_rtc_enable_interrupt(config); } return 0; }
int mtk23d_resume(struct platform_device *pdev) { struct rk2818_23d_data *pdata = pdev->dev.platform_data; int irq = 0; MODEMDBG("%s \n", __FUNCTION__); irq = gpio_to_irq(pdata->bp_statue); if(irq) { printk("disable pdata->bp_statue irq_wake!! \n"); bpstatus_irq_enable = false; disable_irq_wake(irq); } ap_wakeup(pdev); ap_wakeup_bp(pdev, 1); return 0; }