static int exynos_read(struct hwrng *rng, void *buf, size_t max, bool wait) { struct exynos_rng *exynos_rng = container_of(rng, struct exynos_rng, rng); u32 *data = buf; int retry = 100; int ret = 4; pm_runtime_get_sync(exynos_rng->dev); exynos_rng_writel(exynos_rng, PRNG_START, 0); while (!(exynos_rng_readl(exynos_rng, EXYNOS_PRNG_STATUS_OFFSET) & PRNG_DONE) && --retry) cpu_relax(); if (!retry) { ret = -ETIMEDOUT; goto out; } exynos_rng_writel(exynos_rng, PRNG_DONE, EXYNOS_PRNG_STATUS_OFFSET); *data = exynos_rng_readl(exynos_rng, EXYNOS_PRNG_OUT1_OFFSET); out: pm_runtime_mark_last_busy(exynos_rng->dev); pm_runtime_put_sync_autosuspend(exynos_rng->dev); return ret; }
static ssize_t esa_write(struct file *file, const char *buffer, size_t size, loff_t *pos) { int ret; mutex_lock(&esa_mutex); pm_runtime_get_sync(&si.pdev->dev); if (!si.fx_ext_on) { esa_debug("%s: fx ext not enabled\n", __func__); ret = -EINVAL; goto out; } if (!si.fx_work_buf) { esa_debug("%s: fx buf not ready\n", __func__); ret = -EBUSY; goto out; } if (copy_from_user(si.fx_work_buf, buffer, size)) { esa_err("%s: failed to copy_from_user\n", __func__); ret = -EFAULT; } else { esa_debug("%s: %lu bytes\n", __func__, size); ret = FX_BUF_SIZE; } out: pm_runtime_mark_last_busy(&si.pdev->dev); pm_runtime_put_sync_autosuspend(&si.pdev->dev); mutex_unlock(&esa_mutex); return ret; }
void escore_pm_enable(void) { struct escore_priv *escore = &escore_priv; int ret = 0; dev_dbg(escore->dev, "%s()\n", __func__); if (escore->pm_enable) { pr_err("%s(): Already Enabled\n", __func__); return; } escore->pm_enable = ES_PM_ON; escore->pm_status = ES_PM_ON; pm_runtime_set_active(escore->dev); pm_runtime_mark_last_busy(escore->dev); pm_runtime_set_autosuspend_delay(escore->dev, ES_PM_AUTOSUSPEND_DELAY); pm_runtime_use_autosuspend(escore->dev); pm_runtime_enable(escore->dev); device_init_wakeup(escore->dev, true); if (pm_runtime_get_sync(escore->dev) >= 0) { ret = pm_runtime_put_sync_autosuspend(escore->dev); if (ret < 0) { dev_err(escore->dev, "%s() escore PM put failed ret = %d\n", __func__, ret); } } else dev_err(escore->dev, "%s() escore PM get failed ret = %d\n", __func__, ret); return; }
void esa_dma_close(int ch) { if (!si.dma_ch[ch] || (ch >= DMA_CH_MAX)) return; si.dma_ch[ch] = false; si.dma_cb[ch] = NULL; si.dma_cb_param[ch] = NULL; pm_runtime_mark_last_busy(&si.pdev->dev); pm_runtime_put_sync_autosuspend(&si.pdev->dev); }
static void dwc3_pci_resume_work(struct work_struct *work) { struct dwc3_pci *dwc = container_of(work, struct dwc3_pci, wakeup_work); struct platform_device *dwc3 = dwc->dwc3; int ret; ret = pm_runtime_get_sync(&dwc3->dev); if (ret) return; pm_runtime_mark_last_busy(&dwc3->dev); pm_runtime_put_sync_autosuspend(&dwc3->dev); }
int esa_effect_write(int type, int *value, int count) { int effect_count = count; void __iomem *effect_addr; int i, *effect_value; int ret = 0; pm_runtime_get_sync(&si.pdev->dev); effect_value = (int *)kzalloc(effect_count * sizeof(int), GFP_KERNEL); effect_value = value; switch (type) { case SOUNDALIVE: effect_addr = si.effect_ram + SA_BASE; break; case MYSOUND: effect_addr = si.effect_ram + MYSOUND_BASE; break; case PLAYSPEED: effect_addr = si.effect_ram + VSP_BASE; break; case SOUNDBALANCE: effect_addr = si.effect_ram + LRSM_BASE; break; default : pr_err("Not support effect type : %d\n", type); ret = -EINVAL; goto out; } if ((effect_value[1] == 0) && (effect_value[15] == 2) && (effect_value[16] == 2)) si.effect_on = 0; else si.effect_on = 1; for (i = 0; i < effect_count; i++) { pr_debug("effect_value[%d] = %d\n", i, effect_value[i]); writel(effect_value[i], effect_addr + 0x10 + (i * 4)); } writel(CHANGE_BIT, effect_addr); esa_update_qos(); out: pm_runtime_mark_last_busy(&si.pdev->dev); pm_runtime_put_sync_autosuspend(&si.pdev->dev); return ret; }
void escore_pm_put_autosuspend(void) { struct escore_priv *escore = &escore_priv; int ret = 0; dev_dbg(escore->dev, "%s()\n", __func__); if (!escore->pm_enable) return; pm_runtime_mark_last_busy(escore->dev); ret = pm_runtime_put_sync_autosuspend(escore->dev); if (ret) dev_err(escore->dev, "%s(): fail %d\n", __func__, ret); }
static ssize_t lpeff_show(struct device *dev, struct device_attribute *attr, char *buf) { u32 elpe_cmd; u32 arg0, arg1, arg2, arg3, arg4, arg5, arg6; u32 arg7, arg8, arg9, arg10, arg11, arg12; mutex_lock(&esa_mutex); pm_runtime_get_sync(&g_si.pdev->dev); elpe_cmd = readl(g_effect_addr + ELPE_BASE + ELPE_CMD); arg0 = readl(g_effect_addr + ELPE_BASE + ELPE_ARG0); arg1 = readl(g_effect_addr + ELPE_BASE + ELPE_ARG1); arg2 = readl(g_effect_addr + ELPE_BASE + ELPE_ARG2); arg3 = readl(g_effect_addr + ELPE_BASE + ELPE_ARG3); arg4 = readl(g_effect_addr + ELPE_BASE + ELPE_ARG4); arg5 = readl(g_effect_addr + ELPE_BASE + ELPE_ARG5); arg6 = readl(g_effect_addr + ELPE_BASE + ELPE_ARG6); arg7 = readl(g_effect_addr + ELPE_BASE + ELPE_ARG7); arg8 = readl(g_effect_addr + ELPE_BASE + ELPE_ARG8); arg9 = readl(g_effect_addr + ELPE_BASE + ELPE_ARG9); arg10 = readl(g_effect_addr + ELPE_BASE + ELPE_ARG10); arg11 = readl(g_effect_addr + ELPE_BASE + ELPE_ARG11); arg12 = readl(g_effect_addr + ELPE_BASE + ELPE_ARG12); /* change src, dst address to offset value */ #if 0 src = (src & 0xFFFFFF) - 0x400000; dst = (dst & 0xFFFFFF) - 0x400000; #endif pm_runtime_mark_last_busy(&g_si.pdev->dev); pm_runtime_put_sync_autosuspend(&g_si.pdev->dev); mutex_unlock(&esa_mutex); // flush_cache_all(); return scnprintf(buf, PAGE_SIZE, "%d %d %d %d %d %d %d %d %d %d %d %d %d %d\n", elpe_cmd, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12); }
static ssize_t esa_read(struct file *file, char *buffer, size_t size, loff_t *pos) { int ret; mutex_lock(&esa_mutex); pm_runtime_get_sync(&si.pdev->dev); if (!si.fx_ext_on) { esa_debug("%s: fx ext not enabled\n", __func__); ret = -EINVAL; goto out; } ret = wait_event_interruptible_timeout(esa_fx_wq, si.fx_irq_done, HZ); if (!ret) { esa_err("%s: fx irq timeout\n", __func__); ret = -EBUSY; goto out; } si.fx_irq_done = false; si.fx_work_buf = (unsigned char *)(si.sram + FX_BUF_OFFSET); si.fx_work_buf += si.fx_next_idx * FX_BUF_SIZE; esa_debug("%s: buf_idx = %d\n", __func__, si.fx_next_idx); if (copy_to_user((void *)buffer, si.fx_work_buf, FX_BUF_SIZE)) { esa_err("%s: failed to copy_to_user\n", __func__); ret = -EFAULT; } else { ret = FX_BUF_SIZE; } out: pm_runtime_mark_last_busy(&si.pdev->dev); pm_runtime_put_sync_autosuspend(&si.pdev->dev); mutex_unlock(&esa_mutex); return ret; }
static long esa_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { int ret = 0; mutex_lock(&esa_mutex); pm_runtime_get_sync(&si.pdev->dev); switch (cmd) { case SEIREN_IOCTL_FX_EXT: si.fx_ext_on = arg ? true : false; writel(si.fx_ext_on ? 1 : 0, si.mailbox + EFFECT_EXT_ON); break; default: esa_err("%s: unknown cmd:%08X, arg:%08X\n", __func__, cmd, (unsigned int)arg); break; } pm_runtime_mark_last_busy(&si.pdev->dev); pm_runtime_put_sync_autosuspend(&si.pdev->dev); mutex_unlock(&esa_mutex); return ret; }
static void request_pm_put_sync(void) { pm_runtime_put_sync_autosuspend(&srp.pdev->dev); }
static void request_pm_put_sync(void) { pm_runtime_use_autosuspend(&srp.pdev->dev); pm_runtime_mark_last_busy(&srp.pdev->dev); pm_runtime_put_sync_autosuspend(&srp.pdev->dev); }
static ssize_t esa_read(struct file *file, char *buffer, size_t size, loff_t *pos) { struct esa_rtd *rtd = file->private_data; unsigned char *obuf; unsigned int *obuf_filled_size; bool *obuf_filled; unsigned char *obuf_; unsigned int *obuf_filled_size_; bool *obuf_filled_; mutex_lock(&esa_mutex); pm_runtime_get_sync(&si.pdev->dev); /* select OBUF0 or OBUF1 */ if (rtd->select_obuf == 0) { obuf = rtd->obuf0; obuf_filled = &rtd->obuf0_filled; obuf_filled_size = &rtd->obuf0_filled_size; obuf_ = rtd->obuf1; obuf_filled_ = &rtd->obuf1_filled; obuf_filled_size_ = &rtd->obuf1_filled_size; esa_debug("%s: use obuf0\n", __func__); } else { obuf = rtd->obuf1; obuf_filled = &rtd->obuf1_filled; obuf_filled_size = &rtd->obuf1_filled_size; obuf_ = rtd->obuf0; obuf_filled_ = &rtd->obuf0_filled; obuf_filled_size_ = &rtd->obuf0_filled_size; esa_debug("%s: use obuf1\n", __func__); } /* select OBUF0 or OBUF1 for next reading */ rtd->select_obuf = !rtd->select_obuf; /* later... invalidate obuf cache */ /* send pcm data to user */ if (copy_to_user((void *)buffer, obuf, *obuf_filled_size)) { esa_err("%s: failed to copy_to_user\n", __func__); goto err; } /* if meet eos, it sholud also collect data of another buff */ if (rtd->get_eos && !*obuf_filled_) { rtd->get_eos = EOS_FINAL; } esa_debug("%s: handle_id[%x], idx:[%d], obuf:[%d], obuf_filled_size:[%d]\n", __func__, rtd->handle_id, rtd->idx, !rtd->select_obuf, (u32)*obuf_filled_size); *obuf_filled = false; pm_runtime_mark_last_busy(&si.pdev->dev); pm_runtime_put_sync_autosuspend(&si.pdev->dev); mutex_unlock(&esa_mutex); return *obuf_filled_size; err: pm_runtime_mark_last_busy(&si.pdev->dev); pm_runtime_put_sync_autosuspend(&si.pdev->dev); mutex_unlock(&esa_mutex); return -EFAULT; }
static ssize_t esa_write(struct file *file, const char *buffer, size_t size, loff_t *pos) { struct esa_rtd *rtd = file->private_data; unsigned char *ibuf; unsigned char *obuf; unsigned int *obuf_filled_size; bool *obuf_filled; int response, consumed_size = 0; mutex_lock(&esa_mutex); pm_runtime_get_sync(&si.pdev->dev); if (rtd->obuf0_filled && rtd->obuf1_filled) { esa_err("%s: There is no unfilled obuf\n", __func__); goto err; } /* select IBUF0 or IBUF1 */ if (rtd->select_ibuf == 0) { ibuf = rtd->ibuf0; obuf = rtd->obuf0; obuf_filled = &rtd->obuf0_filled; obuf_filled_size = &rtd->obuf0_filled_size; esa_debug("%s: use ibuf0\n", __func__); } else { ibuf = rtd->ibuf1; obuf = rtd->obuf1; obuf_filled = &rtd->obuf1_filled; obuf_filled_size = &rtd->obuf1_filled_size; esa_debug("%s: use ibuf1\n", __func__); } /* receive stream data from user */ if (copy_from_user(ibuf, buffer, size)) { esa_err("%s: failed to copy_from_user\n", __func__); goto err; } /* select IBUF0 or IBUF1 for next writing */ rtd->select_ibuf = !rtd->select_ibuf; /* send execute command to FW for decoding */ response = esa_send_cmd_exe(rtd, ibuf, obuf, size); /* filled size in OBUF */ *obuf_filled_size = readl(si.mailbox + SIZE_OUT_DATA); /* consumed size */ consumed_size = readl(si.mailbox + CONSUMED_BYTE_IN); if (response == 0 && *obuf_filled_size > 0) { *obuf_filled = true; } else { if (consumed_size <= 0) consumed_size = response; if (rtd->need_config) rtd->need_config = false; else if (size != 0) esa_debug("%s: No output? response:%x\n", __func__, response); } pm_runtime_mark_last_busy(&si.pdev->dev); pm_runtime_put_sync_autosuspend(&si.pdev->dev); mutex_unlock(&esa_mutex); esa_debug("%s: handle_id[%x], idx:[%d], consumed:[%d], filled_size:[%d], ibuf:[%d]\n", __func__, rtd->handle_id, rtd->idx, consumed_size, *obuf_filled_size, !rtd->select_ibuf); return consumed_size; err: pm_runtime_mark_last_busy(&si.pdev->dev); pm_runtime_put_sync_autosuspend(&si.pdev->dev); mutex_unlock(&esa_mutex); return -EFAULT; }
void esa_compr_close(void) { pm_runtime_mark_last_busy(&si.pdev->dev); pm_runtime_put_sync_autosuspend(&si.pdev->dev); ptr_ap = NULL; }
static long esa_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { struct esa_rtd *rtd = file->private_data; int ret = 0; unsigned int param = cmd >> 16; cmd = cmd & 0xffff; esa_debug("%s: idx:%d, param:%x, cmd:%x\n", __func__, rtd->idx, param, cmd); mutex_lock(&esa_mutex); pm_runtime_get_sync(&si.pdev->dev); switch (cmd) { case SEIREN_IOCTL_CH_CREATE: rtd->ip_type = (unsigned int) arg; arg = arg << 16; writel(arg, si.mailbox + IP_TYPE); ret = esa_send_cmd(CMD_CREATE); if (ret == -EBUSY) break; ret = readl(si.mailbox + RETURN_CMD); if (ret != 0) break; rtd->handle_id = readl(si.mailbox + IP_ID); esa_buffer_init(file); esa_debug("CH_CREATE: ret_val:%x, handle_id:%x\n", readl(si.mailbox + RETURN_CMD), rtd->handle_id); esa_update_qos(); break; case SEIREN_IOCTL_CH_DESTROY: writel(rtd->handle_id, si.mailbox + HANDLE_ID); ret = esa_send_cmd(CMD_DESTROY); if (ret == -EBUSY) break; ret = readl(si.mailbox + RETURN_CMD); if (ret != 0) break; esa_debug("CH_DESTROY: ret_val:%x, handle_id:%x\n", readl(si.mailbox + RETURN_CMD), rtd->handle_id); break; case SEIREN_IOCTL_CH_EXE: esa_debug("CH_EXE\n"); ret = esa_exe(file, param, arg); break; case SEIREN_IOCTL_CH_SET_PARAMS: esa_debug("CH_SET_PARAMS\n"); ret = esa_set_params(file, param, arg); break; case SEIREN_IOCTL_CH_GET_PARAMS: esa_debug("CH_GET_PARAMS\n"); ret = esa_get_params(file, param, arg); break; case SEIREN_IOCTL_CH_RESET: esa_debug("CH_RESET\n"); break; case SEIREN_IOCTL_CH_FLUSH: arg = arg << 16; writel(rtd->handle_id, si.mailbox + HANDLE_ID); esa_send_cmd(CMD_RESET); esa_debug("CH_FLUSH: val: %x, handle_id : %x\n", readl(si.mailbox + RETURN_CMD), rtd->handle_id); rtd->get_eos = EOS_NO; rtd->select_ibuf = 0; rtd->select_obuf = 0; rtd->obuf0_filled = false; rtd->obuf1_filled = false; break; case SEIREN_IOCTL_CH_CONFIG: esa_debug("CH_CONFIG\n"); rtd->need_config = true; break; } pm_runtime_mark_last_busy(&si.pdev->dev); pm_runtime_put_sync_autosuspend(&si.pdev->dev); mutex_unlock(&esa_mutex); return ret; }