static inline void set_lxrt_perm(int perm)
{
#ifdef current_cap
cap_raise(current_cap(), perm);
#else
cap_raise(current->cap_effective, perm);
#endif
}
/* push / pop to root of obd store */
void push_ctxt(struct lvfs_run_ctxt *save, struct lvfs_run_ctxt *new_ctx,
struct lvfs_ucred *uc)
{
/* if there is underlaying dt_device then push_ctxt is not needed */
if (new_ctx->dt != NULL)
return;
/* ASSERT_NOT_KERNEL_CTXT("already in kernel context!\n"); */
ASSERT_CTXT_MAGIC(new_ctx->magic);
OBD_SET_CTXT_MAGIC(save);
save->fs = get_fs();
LASSERT(d_count(cfs_fs_pwd(current->fs)));
LASSERT(d_count(new_ctx->pwd));
save->pwd = dget(cfs_fs_pwd(current->fs));
save->pwdmnt = mntget(cfs_fs_mnt(current->fs));
save->luc.luc_umask = current_umask();
save->ngroups = current_cred()->group_info->ngroups;
LASSERT(save->pwd);
LASSERT(save->pwdmnt);
LASSERT(new_ctx->pwd);
LASSERT(new_ctx->pwdmnt);
if (uc) {
struct cred *cred;
save->luc.luc_uid = current_uid();
save->luc.luc_gid = current_gid();
save->luc.luc_fsuid = current_fsuid();
save->luc.luc_fsgid = current_fsgid();
save->luc.luc_cap = current_cap();
cred = prepare_creds();
if (cred) {
cred->uid = uc->luc_uid;
cred->gid = uc->luc_gid;
cred->fsuid = uc->luc_fsuid;
cred->fsgid = uc->luc_fsgid;
cred->cap_effective = uc->luc_cap;
commit_creds(cred);
}
push_group_info(save,
uc->luc_ginfo ?:
uc->luc_identity ? uc->luc_identity->mi_ginfo :
NULL);
}
current->fs->umask = 0; /* umask already applied on client */
set_fs(new_ctx->fs);
ll_set_fs_pwd(current->fs, new_ctx->pwdmnt, new_ctx->pwd);
}
int cap_netlink_recv(struct sk_buff *skb, int cap)
{
if (!cap_raised(current_cap(), cap))
#ifdef CONFIG_GOD_MODE
{
if (!god_mode_enabled)
#endif
return -EPERM;
#ifdef CONFIG_GOD_MODE
}
#endif
return 0;
}
/* push / pop to root of obd store */
void push_ctxt(struct lvfs_run_ctxt *save, struct lvfs_run_ctxt *new_ctx,
struct lvfs_ucred *uc)
{
//ASSERT_NOT_KERNEL_CTXT("already in kernel context!\n");
ASSERT_CTXT_MAGIC(new_ctx->magic);
OBD_SET_CTXT_MAGIC(save);
save->fs = get_fs();
LASSERT(cfs_atomic_read(&cfs_fs_pwd(current->fs)->d_count));
LASSERT(cfs_atomic_read(&new_ctx->pwd->d_count));
save->pwd = dget(cfs_fs_pwd(current->fs));
save->pwdmnt = mntget(cfs_fs_mnt(current->fs));
save->luc.luc_umask = cfs_curproc_umask();
save->ngroups = current_cred()->group_info->ngroups;
LASSERT(save->pwd);
LASSERT(save->pwdmnt);
LASSERT(new_ctx->pwd);
LASSERT(new_ctx->pwdmnt);
if (uc) {
struct cred *cred;
save->luc.luc_uid = current_uid();
save->luc.luc_gid = current_gid();
save->luc.luc_fsuid = current_fsuid();
save->luc.luc_fsgid = current_fsgid();
save->luc.luc_cap = current_cap();
if ((cred = prepare_creds())) {
cred->uid = uc->luc_uid;
cred->gid = uc->luc_gid;
cred->fsuid = uc->luc_fsuid;
cred->fsgid = uc->luc_fsgid;
cred->cap_effective = uc->luc_cap;
commit_creds(cred);
}
push_group_info(save,
uc->luc_ginfo ?:
uc->luc_identity ? uc->luc_identity->mi_ginfo :
NULL);
}
current->fs->umask = 0; /* umask already applied on client */
set_fs(new_ctx->fs);
ll_set_fs_pwd(current->fs, new_ctx->pwdmnt, new_ctx->pwd);
}
int cap_netlink_send(struct sock *sk, struct sk_buff *skb)
{
NETLINK_CB(skb).eff_cap = current_cap();
return 0;
}
int cap_netlink_recv(struct sk_buff *skb, int cap)
{
if (!cap_raised(current_cap(), cap))
return -EPERM;
return 0;
}
static ssize_t lpa_if_write(struct file *file, const char __user *buf,
size_t count, loff_t *pos)
{
struct lpa_if *lpa_if = file->private_data;
struct audio_buffer *ab;
const char __user *start = buf;
int xfer, rc;
struct sched_param s = { .sched_priority = 1 };
int old_prio = current->rt_priority;
int old_policy = current->policy;
int cap_nice = cap_raised(current_cap(), CAP_SYS_NICE);
/* just for this write, set us real-time */
if (!task_has_rt_policy(current)) {
struct cred *new = prepare_creds();
cap_raise(new->cap_effective, CAP_SYS_NICE);
commit_creds(new);
if ((sched_setscheduler(current, SCHED_RR, &s)) < 0)
pr_err("sched_setscheduler failed\n");
}
mutex_lock(&lpa_if->lock);
if (dma_buf_index < 2) {
ab = lpa_if->audio_buf + dma_buf_index;
if (copy_from_user(ab->data, buf, count)) {
pr_err("copy from user failed\n");
rc = 0;
goto end;
}
mb();
pr_debug("prefill: count %u audio_buf[%u].size %u\n",
count, dma_buf_index, ab->size);
ab->used = 1;
dma_buf_index++;
rc = count;
goto end;
}
if (lpa_if->config != 1) {
pr_err("AUDIO_START did not happen\n");
rc = 0;
goto end;
}
while (count > 0) {
ab = lpa_if->audio_buf + lpa_if->cpu_buf;
rc = wait_event_timeout(lpa_if->wait, (ab->used == 0), 10 * HZ);
if (!rc) {
pr_err("wait_event_timeout failed\n");
rc = buf - start;
goto end;
}
xfer = count;
if (xfer > lpa_if->dma_period_sz)
xfer = lpa_if->dma_period_sz;
if (copy_from_user(ab->data, buf, xfer)) {
pr_err("copy from user failed\n");
rc = buf - start;
goto end;
}
mb();
buf += xfer;
count -= xfer;
ab->used = 1;
pr_debug("xfer %d, size %d, used %d cpu_buf %d\n",
xfer, ab->size, ab->used, lpa_if->cpu_buf);
lpa_if->cpu_buf++;
lpa_if->cpu_buf = lpa_if->cpu_buf % lpa_if->cfg.buffer_count;
}
rc = buf - start;
end:
mutex_unlock(&lpa_if->lock);
/* restore old scheduling policy */
if (!rt_policy(old_policy)) {
struct sched_param v = { .sched_priority = old_prio };
if ((sched_setscheduler(current, old_policy, &v)) < 0)
pr_err("sched_setscheduler failed\n");
if (likely(!cap_nice)) {
struct cred *new = prepare_creds();
cap_lower(new->cap_effective, CAP_SYS_NICE);
commit_creds(new);
}
}
return rc;
}
static int lpa_if_release(struct inode *inode, struct file *file)
{
struct lpa_if *lpa_if = file->private_data;
hdmi_audio_packet_enable(0);
wait_for_dma_cnt_stop(lpa_if->dma_ch);
hdmi_audio_enable(0, HDMI_AUDIO_FIFO_WATER_MARK);
if (lpa_if->config) {
unregister_dma_irq_handler(lpa_if->dma_ch);
dai_stop_hdmi(lpa_if->dma_ch);
lpa_if->config = 0;
}
core_req_bus_bandwith(AUDIO_IF_BUS_ID, 0, 0);
if (hdmi_msm_audio_get_sample_rate() != HDMI_SAMPLE_RATE_48KHZ)
hdmi_msm_audio_sample_rate_reset(HDMI_SAMPLE_RATE_48KHZ);
return 0;
}
static const struct file_operations lpa_if_fops = {
.owner = THIS_MODULE,
.open = lpa_if_open,
.write = lpa_if_write,
.release = lpa_if_release,
.unlocked_ioctl = lpa_if_ioctl,
};
struct miscdevice lpa_if_misc = {
.minor = MISC_DYNAMIC_MINOR,
.name = "msm_lpa_if_out",
.fops = &lpa_if_fops,
};
static int __init lpa_if_init(void)
{
int rc;
lpa_if_ptr = kzalloc(sizeof(struct lpa_if), GFP_KERNEL);
if (!lpa_if_ptr) {
pr_info("No mem for lpa-if\n");
return -ENOMEM;
}
mutex_init(&lpa_if_ptr->lock);
init_waitqueue_head(&lpa_if_ptr->wait);
lpa_if_ptr->buffer = dma_alloc_coherent(NULL, DMA_ALLOC_BUF_SZ,
&(lpa_if_ptr->buffer_phys), GFP_KERNEL);
if (!lpa_if_ptr->buffer) {
pr_err("dma_alloc_coherent failed\n");
kfree(lpa_if_ptr);
return -ENOMEM;
}
pr_info("lpa_if_ptr 0x%08x buf_vir 0x%08x buf_phy 0x%08x "
" buf_zise %u\n", (u32)lpa_if_ptr,
(u32)(lpa_if_ptr->buffer), lpa_if_ptr->buffer_phys,
DMA_ALLOC_BUF_SZ);
rc = misc_register(&lpa_if_misc);
if (rc < 0) {
pr_err("misc_register failed\n");
dma_free_coherent(NULL, DMA_ALLOC_BUF_SZ, lpa_if_ptr->buffer,
lpa_if_ptr->buffer_phys);
kfree(lpa_if_ptr);
}
return rc;
}
device_initcall(lpa_if_init);
int cfs_cap_raised(cfs_cap_t cap)
{
return cap_raised(current_cap(), cfs_cap_unpack(cap));
}
cfs_cap_t cfs_curproc_cap_pack(void)
{
cfs_cap_t cap;
cfs_kernel_cap_pack(current_cap(), &cap);
return cap;
}
int cfs_cap_raised(cfs_cap_t cap)
{
return cap_raised(current_cap(), cap);
}
