static void smd_tty_port_shutdown(struct tty_port *tport) { struct smd_tty_info *info; struct tty_struct *tty = tty_port_tty_get(tport); unsigned long flags; #ifdef CONFIG_LGE_USES_SMD_DS_TTY int res = 0; #endif info = tty->driver_data; if (info == 0) { tty_kref_put(tty); return; } mutex_lock(&info->open_lock_lha1); spin_lock_irqsave(&info->reset_lock_lha2, flags); info->is_open = 0; spin_unlock_irqrestore(&info->reset_lock_lha2, flags); tasklet_kill(&info->tty_tsklt); wakeup_source_trash(&info->pending_ws); wakeup_source_trash(&info->ra_wakeup_source); SMD_TTY_INFO("%s with PID %u closed port %s", current->comm, current->pid, info->ch_name); tty->driver_data = NULL; del_timer(&info->buf_req_timer); smd_close(info->ch); #ifdef CONFIG_LGE_USES_SMD_DS_TTY /* */ pr_info("%s: waiting to close smd %s completely\n", __func__, info->ch_name); /* wait for reopen ready status in seconds */ res = wait_event_interruptible_timeout( info->ch_opened_wait_queue, !info->is_open, (lge_ds_modem_wait * HZ)); if (res == 0) { /* just in case, remain result value */ res = -ETIMEDOUT; pr_err("%s: timeout to wait for %s smd_close.\ next smd_open may fail....%d\n", __func__, info->ch_name, res); }
static int __devexit pm80x_onkey_remove(struct platform_device *pdev) { struct pm80x_onkey_info *info = platform_get_drvdata(pdev); device_init_wakeup(&pdev->dev, 0); pm80x_free_irq(info->pm80x, info->irq, info); input_unregister_device(info->idev); kfree(info); #ifdef CONFIG_FAKE_SYSTEMOFF wakeup_source_trash(&suspend_longkey_lock); #endif return 0; }
static int mxhci_hsic_remove(struct platform_device *pdev) { struct usb_hcd *hcd = platform_get_drvdata(pdev); struct xhci_hcd *xhci = hcd_to_xhci(hcd); struct mxhci_hsic_hcd *mxhci = hcd_to_hsic(hcd); u32 reg; /* disable STROBE_PAD_CTL */ reg = readl_relaxed(TLMM_GPIO_HSIC_STROBE_PAD_CTL); writel_relaxed(reg & 0xfdffffff, TLMM_GPIO_HSIC_STROBE_PAD_CTL); /* disable DATA_PAD_CTL */ reg = readl_relaxed(TLMM_GPIO_HSIC_DATA_PAD_CTL); writel_relaxed(reg & 0xfdffffff, TLMM_GPIO_HSIC_DATA_PAD_CTL); mb(); device_remove_file(&pdev->dev, &dev_attr_config_imod); /* If the device was removed no need to call pm_runtime_disable */ if (pdev->dev.power.power_state.event != PM_EVENT_INVALID) pm_runtime_disable(&pdev->dev); pm_runtime_set_suspended(&pdev->dev); usb_remove_hcd(xhci->shared_hcd); usb_put_hcd(xhci->shared_hcd); usb_remove_hcd(hcd); if (mxhci->wakeup_irq_enabled) disable_irq_wake(mxhci->wakeup_irq); mxhci->bus_vote = false; cancel_work_sync(&mxhci->bus_vote_w); if (mxhci->bus_perf_client) msm_bus_scale_unregister_client(mxhci->bus_perf_client); destroy_workqueue(mxhci->wq); device_init_wakeup(&pdev->dev, 0); mxhci_hsic_init_vddcx(mxhci, 0); mxhci_hsic_init_clocks(mxhci, 0); mxhci_msm_config_gdsc(mxhci, 0); wakeup_source_trash(&mxhci->ws); usb_put_hcd(hcd); return 0; }
static int ehci_msm2_remove(struct platform_device *pdev) { struct usb_hcd *hcd = platform_get_drvdata(pdev); struct msm_hcd *mhcd = hcd_to_mhcd(hcd); if (mhcd->pmic_gpio_dp_irq) { if (mhcd->pmic_gpio_dp_irq_enabled) disable_irq_wake(mhcd->pmic_gpio_dp_irq); free_irq(mhcd->pmic_gpio_dp_irq, mhcd); } if (mhcd->async_irq) { if (mhcd->async_irq_enabled) disable_irq_wake(mhcd->async_irq); free_irq(mhcd->async_irq, mhcd); } if (mhcd->wakeup_irq) { if (mhcd->wakeup_irq_enabled) disable_irq_wake(mhcd->wakeup_irq); free_irq(mhcd->wakeup_irq, mhcd); } device_init_wakeup(&pdev->dev, 0); pm_runtime_set_suspended(&pdev->dev); usb_remove_hcd(hcd); if (mhcd->xo_clk) { clk_disable_unprepare(mhcd->xo_clk); clk_put(mhcd->xo_clk); } else { msm_xo_put(mhcd->xo_handle); } msm_ehci_vbus_power(mhcd, 0); msm_ehci_init_vbus(mhcd, 0); msm_ehci_ldo_enable(mhcd, 0); msm_ehci_ldo_init(mhcd, 0); msm_ehci_init_vddcx(mhcd, 0); msm_ehci_init_clocks(mhcd, 0); wakeup_source_trash(&mhcd->ws); iounmap(hcd->regs); usb_put_hcd(hcd); #if defined(CONFIG_DEBUG_FS) debugfs_remove_recursive(dent_ehci); #endif return 0; }
/* acipc_exit used to unregister interrupt call-back function */ void acipc_exit(void) { acipc_event_unbind(ACIPC_PORT_FLOWCONTROL); acipc_event_unbind(ACIPC_RINGBUF_TX_RESUME); acipc_event_unbind(ACIPC_RINGBUF_TX_STOP); acipc_event_unbind(ACIPC_MUDP_KEY); acipc_event_unbind(ACIPC_MODEM_DDR_UPDATE_REQ); acipc_event_unbind(ACIPC_IPM); pm_qos_remove_request(&cp_block_cpuidle_axi); wakeup_source_trash(&acipc_wakeup); #ifdef CONFIG_DDR_DEVFREQ destroy_workqueue(acipc_wq); pm_qos_remove_request(&modem_ddr_cons); #endif }
INT32 wmt_plat_deinit(VOID) { INT32 iret = 0; /* 2. unreg to cmb_stub */ iret = mtk_wcn_cmb_stub_unreg(); /*3. wmt wakelock deinit */ #ifdef CFG_WMT_WAKELOCK_SUPPORT #ifdef CONFIG_PM_WAKELOCKS wakeup_source_trash(&wmtWakeLock); #else wake_lock_destroy(&wmtWakeLock); #endif mutex_destroy(&gOsSLock); WMT_PLAT_DBG_FUNC("destroy wmtWakeLock\n"); #endif iret += mtk_wcn_consys_hw_deinit(); WMT_PLAT_DBG_FUNC("WMT-PLAT: ALPS platform init (%d)\n", iret); return 0; }
static void __exit alarm_dev_exit(void) { misc_deregister(&alarm_device); wakeup_source_trash(&alarm_wake_lock); }
static int ehci_msm2_remove(struct platform_device *pdev) { struct usb_hcd *hcd = platform_get_drvdata(pdev); struct msm_hcd *mhcd = hcd_to_mhcd(hcd); struct pinctrl_state *set_state; if (mhcd->pmic_gpio_dp_irq) { if (mhcd->pmic_gpio_dp_irq_enabled) disable_irq_wake(mhcd->pmic_gpio_dp_irq); free_irq(mhcd->pmic_gpio_dp_irq, mhcd); } if (mhcd->async_irq) { if (mhcd->async_irq_enabled) disable_irq_wake(mhcd->async_irq); free_irq(mhcd->async_irq, mhcd); } if (mhcd->wakeup_irq) { if (mhcd->wakeup_irq_enabled) disable_irq_wake(mhcd->wakeup_irq); free_irq(mhcd->wakeup_irq, mhcd); } /* If the device was removed no need to call pm_runtime_disable */ if (pdev->dev.power.power_state.event != PM_EVENT_INVALID) pm_runtime_disable(&pdev->dev); device_init_wakeup(&pdev->dev, 0); pm_runtime_set_suspended(&pdev->dev); usb_remove_hcd(hcd); if (hcd->phy) usb_phy_shutdown(hcd->phy); if (mhcd->xo_clk) { clk_disable_unprepare(mhcd->xo_clk); clk_put(mhcd->xo_clk); } msm_ehci_vbus_power(mhcd, 0); msm_ehci_init_vbus(mhcd, 0); msm_ehci_ldo_enable(mhcd, 0); msm_ehci_ldo_init(mhcd, 0); msm_ehci_init_vddcx(mhcd, 0); if (mhcd->hsusb_pinctrl) { set_state = pinctrl_lookup_state(mhcd->hsusb_pinctrl, "ehci_sleep"); if (IS_ERR(set_state)) pr_err("cannot get hsusb pinctrl sleep state\n"); else pinctrl_select_state(mhcd->hsusb_pinctrl, set_state); } msm_ehci_init_clocks(mhcd, 0); wakeup_source_trash(&mhcd->ws); iounmap(hcd->regs); usb_put_hcd(hcd); #if defined(CONFIG_DEBUG_FS) debugfs_remove_recursive(dent_ehci); #endif return 0; }
void cnss_pm_wake_lock_destroy(struct wakeup_source *ws) { wakeup_source_trash(ws); }
int gpio_event_matrix_func(struct gpio_event_input_devs *input_devs, struct gpio_event_info *info, void **data, int func) { int i; int err; int key_count; struct gpio_kp *kp; struct gpio_event_matrix_info *mi; mi = container_of(info, struct gpio_event_matrix_info, info); if (func == GPIO_EVENT_FUNC_SUSPEND || func == GPIO_EVENT_FUNC_RESUME) { /* TODO: disable scanning */ return 0; } if (func == GPIO_EVENT_FUNC_INIT) { if (mi->keymap == NULL || mi->input_gpios == NULL || mi->output_gpios == NULL) { err = -ENODEV; pr_err("gpiomatrix: Incomplete pdata\n"); goto err_invalid_platform_data; } key_count = mi->ninputs * mi->noutputs; *data = kp = kzalloc(sizeof(*kp) + sizeof(kp->keys_pressed[0]) * BITS_TO_LONGS(key_count), GFP_KERNEL); if (kp == NULL) { err = -ENOMEM; pr_err("gpiomatrix: Failed to allocate private data\n"); goto err_kp_alloc_failed; } kp->input_devs = input_devs; kp->keypad_info = mi; for (i = 0; i < key_count; i++) { unsigned short keyentry = mi->keymap[i]; unsigned short keycode = keyentry & MATRIX_KEY_MASK; unsigned short dev = keyentry >> MATRIX_CODE_BITS; if (dev >= input_devs->count) { pr_err("gpiomatrix: bad device index %d >= " "%d for key code %d\n", dev, input_devs->count, keycode); err = -EINVAL; goto err_bad_keymap; } if (keycode && keycode <= KEY_MAX) input_set_capability(input_devs->dev[dev], EV_KEY, keycode); } for (i = 0; i < mi->noutputs; i++) { err = gpio_request(mi->output_gpios[i], "gpio_kp_out"); if (err) { pr_err("gpiomatrix: gpio_request failed for " "output %d\n", mi->output_gpios[i]); goto err_request_output_gpio_failed; } if (gpio_cansleep(mi->output_gpios[i])) { pr_err("gpiomatrix: unsupported output gpio %d," " can sleep\n", mi->output_gpios[i]); err = -EINVAL; goto err_output_gpio_configure_failed; } if (mi->flags & GPIOKPF_DRIVE_INACTIVE) err = gpio_direction_output(mi->output_gpios[i], !(mi->flags & GPIOKPF_ACTIVE_HIGH)); else err = gpio_direction_input(mi->output_gpios[i]); if (err) { pr_err("gpiomatrix: gpio_configure failed for " "output %d\n", mi->output_gpios[i]); goto err_output_gpio_configure_failed; } } for (i = 0; i < mi->ninputs; i++) { err = gpio_request(mi->input_gpios[i], "gpio_kp_in"); if (err) { pr_err("gpiomatrix: gpio_request failed for " "input %d\n", mi->input_gpios[i]); goto err_request_input_gpio_failed; } err = gpio_direction_input(mi->input_gpios[i]); if (err) { pr_err("gpiomatrix: gpio_direction_input failed" " for input %d\n", mi->input_gpios[i]); goto err_gpio_direction_input_failed; } } kp->current_output = mi->noutputs; kp->key_state_changed = 1; hrtimer_init(&kp->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); kp->timer.function = gpio_keypad_timer_func; wakeup_source_init(&kp->wakeup_source,"gpio_kp"); err = gpio_keypad_request_irqs(kp); kp->use_irq = err == 0; pr_info("GPIO Matrix Keypad Driver: Start keypad matrix for " "%s%s in %s mode\n", input_devs->dev[0]->name, (input_devs->count > 1) ? "..." : "", kp->use_irq ? "interrupt" : "polling"); if (kp->use_irq) __pm_stay_awake(&kp->wakeup_source); hrtimer_start(&kp->timer, ktime_set(0, 0), HRTIMER_MODE_REL); return 0; } err = 0; kp = *data; if (kp->use_irq) for (i = mi->noutputs - 1; i >= 0; i--) free_irq(gpio_to_irq(mi->input_gpios[i]), kp); hrtimer_cancel(&kp->timer); wakeup_source_trash(&kp->wakeup_source); for (i = mi->noutputs - 1; i >= 0; i--) { err_gpio_direction_input_failed: gpio_free(mi->input_gpios[i]); err_request_input_gpio_failed: ; } for (i = mi->noutputs - 1; i >= 0; i--) { err_output_gpio_configure_failed: gpio_free(mi->output_gpios[i]); err_request_output_gpio_failed: ; } err_bad_keymap: kfree(kp); err_kp_alloc_failed: err_invalid_platform_data: return err; }
static int smd_tty_port_activate(struct tty_port *tport, struct tty_struct *tty) { int res = 0; unsigned int n = tty->index; struct smd_tty_info *info; const char *peripheral = NULL; if (n >= MAX_SMD_TTYS || !smd_tty[n].ch_name) return -ENODEV; info = smd_tty + n; mutex_lock(&info->open_lock_lha1); tty->driver_data = info; peripheral = smd_edge_to_subsystem(smd_tty[n].edge); if (peripheral) { info->pil = subsystem_get(peripheral); if (IS_ERR(info->pil)) { SMD_TTY_INFO( "%s failed on smd_tty device :%s subsystem_get failed for %s", __func__, info->ch_name, peripheral); /* * Sleep, inorder to reduce the frequency of * retry by user-space modules and to avoid * possible watchdog bite. */ msleep((smd_tty[n].open_wait * 1000)); res = PTR_ERR(info->pil); goto out; } /* Wait for the modem SMSM to be inited for the SMD * Loopback channel to be allocated at the modem. Since * the wait need to be done atmost once, using msleep * doesn't degrade the performance. */ if (n == LOOPBACK_IDX) { if (!is_modem_smsm_inited()) msleep(5000); smsm_change_state(SMSM_APPS_STATE, 0, SMSM_SMD_LOOPBACK); msleep(100); } /* * Wait for a channel to be allocated so we know * the modem is ready enough. */ if (smd_tty[n].open_wait) { res = wait_for_completion_interruptible_timeout( &info->ch_allocated, msecs_to_jiffies(smd_tty[n].open_wait * 1000)); if (res == 0) { SMD_TTY_INFO( "Timed out waiting for SMD channel %s", info->ch_name); res = -ETIMEDOUT; goto release_pil; } else if (res < 0) { SMD_TTY_INFO( "Error waiting for SMD channel %s : %d\n", info->ch_name, res); goto release_pil; } } #ifdef CONFIG_LGE_USES_SMD_DS_TTY /* */ if (n == DS_IDX) { /* wait for open ready status in seconds */ pr_info("%s: checking DS modem status\n", __func__); res = wait_event_interruptible_timeout( info->ch_opened_wait_queue, info->is_dsmodem_ready, (lge_ds_modem_wait * HZ)); if (res == 0) { res = -ETIMEDOUT; pr_err("%s: timeout to wait for %s modem: %d\n", __func__, info->ch_name, res); goto release_pil; } if (res < 0) { pr_err("%s: timeout to wait for %s modem: %d\n", __func__, info->ch_name, res); goto release_pil; } pr_info("%s: DS modem is OK, open smd0..\n", __func__); } #endif } tasklet_init(&info->tty_tsklt, smd_tty_read, (unsigned long)info); wakeup_source_init(&info->pending_ws, info->ch_name); scnprintf(info->ra_wakeup_source_name, MAX_RA_WAKE_LOCK_NAME_LEN, "SMD_TTY_%s_RA", info->ch_name); wakeup_source_init(&info->ra_wakeup_source, info->ra_wakeup_source_name); res = smd_named_open_on_edge(info->ch_name, smd_tty[n].edge, &info->ch, info, smd_tty_notify); if (res < 0) { SMD_TTY_INFO("%s: %s open failed %d\n", __func__, info->ch_name, res); goto release_wl_tl; } res = wait_event_interruptible_timeout(info->ch_opened_wait_queue, info->is_open, (2 * HZ)); if (res == 0) res = -ETIMEDOUT; if (res < 0) { SMD_TTY_INFO("%s: wait for %s smd_open failed %d\n", __func__, info->ch_name, res); goto close_ch; } SMD_TTY_INFO("%s with PID %u opened port %s", current->comm, current->pid, info->ch_name); smd_disable_read_intr(info->ch); mutex_unlock(&info->open_lock_lha1); return 0; close_ch: smd_close(info->ch); info->ch = NULL; release_wl_tl: tasklet_kill(&info->tty_tsklt); wakeup_source_trash(&info->pending_ws); wakeup_source_trash(&info->ra_wakeup_source); release_pil: subsystem_put(info->pil); out: mutex_unlock(&info->open_lock_lha1); return res; }