tobi/M7350
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
f9cc65cfda
M7350/kernel/arch/arm/mach-msm/qdsp6/msm_q6venc.c
T f9cc65cfda M7350v1_en_gpl
2024-09-09 08:52:07 +00:00

1201 lines
31 KiB
C
Raw Blame History

/* Copyright (c) 2008-2009, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
* only version 2 as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
*/
#include <linux/slab.h>
#include <linux/cdev.h>
#include <linux/file.h>
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/spinlock.h>
#include <linux/uaccess.h>
#include <linux/wakelock.h>
#include <linux/msm_q6venc.h>
#include <linux/pm_qos.h>
#include <mach/cpuidle.h>
#include "dal.h"
#define DALDEVICEID_VENC_DEVICE 0x0200002D
#define DALDEVICEID_VENC_PORTNAME "DAL_AQ_VID"
#define VENC_NAME "q6venc"
#define VENC_MSG_MAX 128
#define VENC_INTERFACE_VERSION 0x00020000
#define MAJOR_MASK 0xFFFF0000
#define MINOR_MASK 0x0000FFFF
#define VENC_GET_MAJOR_VERSION(version) ((version & MAJOR_MASK)>>16)
#define VENC_GET_MINOR_VERSION(version) (version & MINOR_MASK)
enum {
VENC_BUFFER_TYPE_INPUT,
VENC_BUFFER_TYPE_OUTPUT,
VENC_BUFFER_TYPE_QDSP6,
VENC_BUFFER_TYPE_HDR
};
enum {
VENC_DALRPC_GET_SYNTAX_HEADER = DAL_OP_FIRST_DEVICE_API,
VENC_DALRPC_UPDATE_INTRA_REFRESH,
VENC_DALRPC_UPDATE_FRAME_RATE,
VENC_DALRPC_UPDATE_BITRATE,
VENC_DALRPC_UPDATE_QP_RANGE,
VENC_DALRPC_UPDATE_INTRA_PERIOD,
VENC_DALRPC_REQUEST_IFRAME,
VENC_DALRPC_START,
VENC_DALRPC_STOP,
VENC_DALRPC_SUSPEND,
VENC_DALRPC_RESUME,
VENC_DALRPC_FLUSH,
VENC_DALRPC_QUEUE_INPUT,
VENC_DALRPC_QUEUE_OUTPUT
};
struct venc_input_payload {
u32 data;
};
struct venc_output_payload {
u32 size;
long long time_stamp;
u32 flags;
u32 data;
u32 client_data_from_input;
};
union venc_payload {
struct venc_input_payload input_payload;
struct venc_output_payload output_payload;
};
struct venc_msg_type {
u32 event;
u32 status;
union venc_payload payload;
};
struct venc_input_buf {
struct venc_buf_type yuv_buf;
u32 data_size;
long long time_stamp;
u32 flags;
u32 dvs_offsetx;
u32 dvs_offsety;
u32 client_data;
u32 op_client_data;
};
struct venc_output_buf {
struct venc_buf_type bit_stream_buf;
u32 client_data;
};
struct venc_msg_list {
struct list_head list;
struct venc_msg msg_data;
};
struct venc_buf {
int fd;
u32 src;
u32 offset;
u32 size;
u32 btype;
unsigned long paddr;
struct file *file;
};
struct venc_pmem_list {
struct list_head list;
struct venc_buf buf;
};
struct venc_dev {
bool is_active;
bool pmem_freed;
enum venc_state_type state;
struct list_head venc_msg_list_head;
struct list_head venc_msg_list_free;
spinlock_t venc_msg_list_lock;
struct list_head venc_pmem_list_head;
spinlock_t venc_pmem_list_lock;
struct dal_client *q6_handle;
wait_queue_head_t venc_msg_evt;
struct device *class_devp;
};
#define DEBUG_VENC 0
#if DEBUG_VENC
#define TRACE(fmt, x...) \
do { pr_debug("%s:%d " fmt, __func__, __LINE__, ##x); } while (0)
#else
#define TRACE(fmt, x...) do { } while (0)
#endif
static struct cdev cdev;
static dev_t venc_dev_num;
static struct class *venc_class;
static struct venc_dev *venc_device_p;
static int venc_ref;
static DEFINE_MUTEX(idlecount_lock);
static int idlecount;
static struct wake_lock wakelock;
static struct pm_qos_request pm_qos_req;
static void prevent_sleep(void)
{
mutex_lock(&idlecount_lock);
if (++idlecount == 1) {
pm_qos_update_request(&pm_qos_req,
msm_cpuidle_get_deep_idle_latency());
wake_lock(&wakelock);
}
mutex_unlock(&idlecount_lock);
}
static void allow_sleep(void)
{
mutex_lock(&idlecount_lock);
if (--idlecount == 0) {
wake_unlock(&wakelock);
pm_qos_update_request(&pm_qos_req, PM_QOS_DEFAULT_VALUE);
}
mutex_unlock(&idlecount_lock);
}
static inline int venc_check_version(u32 client, u32 server)
{
int ret = -EINVAL;
if ((VENC_GET_MAJOR_VERSION(client) == VENC_GET_MAJOR_VERSION(server))
&& (VENC_GET_MINOR_VERSION(client) <=
VENC_GET_MINOR_VERSION(server)))
ret = 0;
return ret;
}
static int venc_get_msg(struct venc_dev *dvenc, void *msg)
{
struct venc_msg_list *l;
unsigned long flags;
int ret = 0;
struct venc_msg qdsp_msg;
if (!dvenc->is_active)
return -EPERM;
spin_lock_irqsave(&dvenc->venc_msg_list_lock, flags);
list_for_each_entry_reverse(l, &dvenc->venc_msg_list_head, list) {
memcpy(&qdsp_msg, &l->msg_data, sizeof(struct venc_msg));
list_del(&l->list);
list_add(&l->list, &dvenc->venc_msg_list_free);
ret = 1;
break;
}
spin_unlock_irqrestore(&dvenc->venc_msg_list_lock, flags);
if (copy_to_user(msg, &qdsp_msg, sizeof(struct venc_msg)))
pr_err("%s failed to copy_to_user\n", __func__);
return ret;
}
static void venc_put_msg(struct venc_dev *dvenc, struct venc_msg *msg)
{
struct venc_msg_list *l;
unsigned long flags;
int found = 0;
spin_lock_irqsave(&dvenc->venc_msg_list_lock, flags);
list_for_each_entry(l, &dvenc->venc_msg_list_free, list) {
memcpy(&l->msg_data, msg, sizeof(struct venc_msg));
list_del(&l->list);
list_add(&l->list, &dvenc->venc_msg_list_head);
found = 1;
break;
}
spin_unlock_irqrestore(&dvenc->venc_msg_list_lock, flags);
if (found)
wake_up(&dvenc->venc_msg_evt);
else
pr_err("%s: failed to find a free node\n", __func__);
}
static struct venc_pmem_list *venc_add_pmem_to_list(struct venc_dev *dvenc,
struct venc_pmem *mptr,
u32 btype)
{
int ret = 0;
unsigned long flags;
unsigned long len;
unsigned long vaddr;
struct venc_pmem_list *plist = NULL;
plist = kzalloc(sizeof(struct venc_pmem_list), GFP_KERNEL);
if (!plist) {
pr_err("%s: kzalloc failed\n", __func__);
return NULL;
}
ret = get_pmem_file(mptr->fd, &(plist->buf.paddr),
&vaddr, &len, &(plist->buf.file));
if (ret) {
pr_err("%s: get_pmem_file failed for fd=%d offset=%d\n",
__func__, mptr->fd, mptr->offset);
goto err_venc_add_pmem;
} else if (mptr->offset >= len) {
pr_err("%s: invalid offset (%d > %ld) for fd=%d\n",
__func__, mptr->offset, len, mptr->fd);
ret = -EINVAL;
goto err_venc_get_pmem;
}
plist->buf.fd = mptr->fd;
plist->buf.paddr += mptr->offset;
plist->buf.size = mptr->size;
plist->buf.btype = btype;
plist->buf.offset = mptr->offset;
plist->buf.src = mptr->src;
spin_lock_irqsave(&dvenc->venc_pmem_list_lock, flags);
list_add(&plist->list, &dvenc->venc_pmem_list_head);
spin_unlock_irqrestore(&dvenc->venc_pmem_list_lock, flags);
return plist;
err_venc_get_pmem:
put_pmem_file(plist->buf.file);
err_venc_add_pmem:
kfree(plist);
return NULL;
}
static struct venc_pmem_list *venc_get_pmem_from_list(
struct venc_dev *dvenc, u32 pmem_fd,
u32 offset, u32 btype)
{
struct venc_pmem_list *plist;
unsigned long flags;
struct file *file;
int found = 0;
file = fget(pmem_fd);
if (!file) {
pr_err("%s: invalid encoder buffer fd(%d)\n", __func__,
pmem_fd);
return NULL;
}
spin_lock_irqsave(&dvenc->venc_pmem_list_lock, flags);
list_for_each_entry(plist, &dvenc->venc_pmem_list_head, list) {
if (plist->buf.btype == btype && plist->buf.file == file &&
plist->buf.offset == offset) {
found = 1;
break;
}
}
spin_unlock_irqrestore(&dvenc->venc_pmem_list_lock, flags);
fput(file);
if (found)
return plist;
else
return NULL;
}
static int venc_set_buffer(struct venc_dev *dvenc, void *argp,
u32 btype)
{
struct venc_pmem pmem;
struct venc_pmem_list *plist;
int ret = 0;
ret = copy_from_user(&pmem, argp, sizeof(pmem));
if (ret) {
pr_err("%s: copy_from_user failed\n", __func__);
return ret;
}
plist = venc_add_pmem_to_list(dvenc, &pmem, btype);
if (plist == NULL) {
pr_err("%s: buffer add_to_pmem_list failed\n",
__func__);
return -EPERM;
}
return ret;
}
static int venc_assign_q6_buffers(struct venc_dev *dvenc,
struct venc_buffers *pbufs,
struct venc_nonio_buf_config *pcfg)
{
int ret = 0;
struct venc_pmem_list *plist;
plist = venc_add_pmem_to_list(dvenc, &(pbufs->recon_buf[0]),
VENC_BUFFER_TYPE_QDSP6);
if (plist == NULL) {
pr_err("%s: recon_buf0 failed to add_to_pmem_list\n",
__func__);
return -EPERM;
}
pcfg->recon_buf1.region = pbufs->recon_buf[0].src;
pcfg->recon_buf1.phys = plist->buf.paddr;
pcfg->recon_buf1.size = plist->buf.size;
pcfg->recon_buf1.offset = 0;
plist = venc_add_pmem_to_list(dvenc, &(pbufs->recon_buf[1]),
VENC_BUFFER_TYPE_QDSP6);
if (plist == NULL) {
pr_err("%s: recons_buf1 failed to add_to_pmem_list\n",
__func__);
return -EPERM;
}
pcfg->recon_buf2.region = pbufs->recon_buf[1].src;
pcfg->recon_buf2.phys = plist->buf.paddr;
pcfg->recon_buf2.size = plist->buf.size;
pcfg->recon_buf2.offset = 0;
plist = venc_add_pmem_to_list(dvenc, &(pbufs->wb_buf),
VENC_BUFFER_TYPE_QDSP6);
if (plist == NULL) {
pr_err("%s: wb_buf failed to add_to_pmem_list\n",
__func__);
return -EPERM;
}
pcfg->wb_buf.region = pbufs->wb_buf.src;
pcfg->wb_buf.phys = plist->buf.paddr;
pcfg->wb_buf.size = plist->buf.size;
pcfg->wb_buf.offset = 0;
plist = venc_add_pmem_to_list(dvenc, &(pbufs->cmd_buf),
VENC_BUFFER_TYPE_QDSP6);
if (plist == NULL) {
pr_err("%s: cmd_buf failed to add_to_pmem_list\n",
__func__);
return -EPERM;
}
pcfg->cmd_buf.region = pbufs->cmd_buf.src;
pcfg->cmd_buf.phys = plist->buf.paddr;
pcfg->cmd_buf.size = plist->buf.size;
pcfg->cmd_buf.offset = 0;
plist = venc_add_pmem_to_list(dvenc, &(pbufs->vlc_buf),
VENC_BUFFER_TYPE_QDSP6);
if (plist == NULL) {
pr_err("%s: vlc_buf failed to add_to_pmem_list"
" failed\n", __func__);
return -EPERM;
}
pcfg->vlc_buf.region = pbufs->vlc_buf.src;
pcfg->vlc_buf.phys = plist->buf.paddr;
pcfg->vlc_buf.size = plist->buf.size;
pcfg->vlc_buf.offset = 0;
return ret;
}
static int venc_start(struct venc_dev *dvenc, void *argp)
{
int ret = 0;
struct venc_q6_config q6_config;
struct venc_init_config vconfig;
dvenc->state = VENC_STATE_START;
ret = copy_from_user(&vconfig, argp, sizeof(struct venc_init_config));
if (ret) {
pr_err("%s: copy_from_user failed\n", __func__);
return ret;
}
memcpy(&q6_config, &(vconfig.q6_config), sizeof(q6_config));
ret = venc_assign_q6_buffers(dvenc, &(vconfig.q6_bufs),
&(q6_config.buf_params));
if (ret != 0) {
pr_err("%s: assign_q6_buffers failed\n", __func__);
return -EPERM;
}
q6_config.callback_event = dvenc->q6_handle;
TRACE("%s: parameters: handle:%p, config:%p, callback:%p \n", __func__,
dvenc->q6_handle, &q6_config, q6_config.callback_event);
TRACE("%s: parameters:recon1:0x%x, recon2:0x%x,"
" wb_buf:0x%x, cmd:0x%x, vlc:0x%x\n", __func__,
q6_config.buf_params.recon_buf1.phys,
q6_config.buf_params.recon_buf2.phys,
q6_config.buf_params.wb_buf.phys,
q6_config.buf_params.cmd_buf.phys,
q6_config.buf_params.vlc_buf.phys);
TRACE("%s: size of param:%d \n", __func__, sizeof(q6_config));
ret = dal_call_f5(dvenc->q6_handle, VENC_DALRPC_START, &q6_config,
sizeof(q6_config));
if (ret != 0) {
pr_err("%s: remote function failed (%d)\n", __func__, ret);
return ret;
}
return ret;
}
static int venc_encode_frame(struct venc_dev *dvenc, void *argp)
{
int ret = 0;
struct venc_pmem buf;
struct venc_input_buf q6_input;
struct venc_pmem_list *plist;
struct venc_buffer input;
ret = copy_from_user(&input, argp, sizeof(struct venc_buffer));
if (ret) {
pr_err("%s: copy_from_user failed\n", __func__);
return ret;
}
ret = copy_from_user(&buf,
((struct venc_buffer *)argp)->ptr_buffer,
sizeof(struct venc_pmem));
if (ret) {
pr_err("%s: copy_from_user failed\n", __func__);
return ret;
}
plist = venc_get_pmem_from_list(dvenc, buf.fd, buf.offset,
VENC_BUFFER_TYPE_INPUT);
if (NULL == plist) {
plist = venc_add_pmem_to_list(dvenc, &buf,
VENC_BUFFER_TYPE_INPUT);
if (plist == NULL) {
pr_err("%s: buffer add_to_pmem_list failed\n",
__func__);
return -EPERM;
}
}
q6_input.flags = 0;
if (input.flags & VENC_FLAG_EOS)
q6_input.flags |= 0x00000001;
q6_input.yuv_buf.region = plist->buf.src;
q6_input.yuv_buf.phys = plist->buf.paddr;
q6_input.yuv_buf.size = plist->buf.size;
q6_input.yuv_buf.offset = 0;
q6_input.data_size = plist->buf.size;
q6_input.client_data = (u32)input.client_data;
q6_input.time_stamp = input.time_stamp;
q6_input.dvs_offsetx = 0;
q6_input.dvs_offsety = 0;
TRACE("Pushing down input phys=0x%x fd= %d, client_data: 0x%x,"
" time_stamp:%lld \n", q6_input.yuv_buf.phys, plist->buf.fd,
input.client_data, input.time_stamp);
ret = dal_call_f5(dvenc->q6_handle, VENC_DALRPC_QUEUE_INPUT,
&q6_input, sizeof(q6_input));
if (ret != 0)
pr_err("%s: Q6 queue_input failed (%d)\n", __func__,
(int)ret);
return ret;
}
static int venc_fill_output(struct venc_dev *dvenc, void *argp)
{
int ret = 0;
struct venc_pmem buf;
struct venc_output_buf q6_output;
struct venc_pmem_list *plist;
struct venc_buffer output;
ret = copy_from_user(&output, argp, sizeof(struct venc_buffer));
if (ret) {
pr_err("%s: copy_from_user failed\n", __func__);
return ret;
}
ret = copy_from_user(&buf,
((struct venc_buffer *)argp)->ptr_buffer,
sizeof(struct venc_pmem));
if (ret) {
pr_err("%s: copy_from_user failed\n", __func__);
return ret;
}
plist = venc_get_pmem_from_list(dvenc, buf.fd, buf.offset,
VENC_BUFFER_TYPE_OUTPUT);
if (NULL == plist) {
plist = venc_add_pmem_to_list(dvenc, &buf,
VENC_BUFFER_TYPE_OUTPUT);
if (NULL == plist) {
pr_err("%s: output buffer failed to add_to_pmem_list"
"\n", __func__);
return -EPERM;
}
}
q6_output.bit_stream_buf.region = plist->buf.src;
q6_output.bit_stream_buf.phys = (u32)plist->buf.paddr;
q6_output.bit_stream_buf.size = plist->buf.size;
q6_output.bit_stream_buf.offset = 0;
q6_output.client_data = (u32)output.client_data;
ret =
dal_call_f5(dvenc->q6_handle, VENC_DALRPC_QUEUE_OUTPUT, &q6_output,
sizeof(q6_output));
if (ret != 0)
pr_err("%s: remote function failed (%d)\n", __func__, ret);
return ret;
}
static int venc_stop(struct venc_dev *dvenc)
{
int ret = 0;
struct venc_msg msg;
ret = dal_call_f0(dvenc->q6_handle, VENC_DALRPC_STOP, 1);
if (ret) {
pr_err("%s: remote runction failed (%d)\n", __func__, ret);
msg.msg_code = VENC_MSG_STOP;
msg.msg_data_size = 0;
msg.status_code = VENC_S_EFAIL;
venc_put_msg(dvenc, &msg);
}
return ret;
}
static int venc_pause(struct venc_dev *dvenc)
{
int ret = 0;
struct venc_msg msg;
ret = dal_call_f0(dvenc->q6_handle, VENC_DALRPC_SUSPEND, 1);
if (ret) {
pr_err("%s: remote function failed (%d)\n", __func__, ret);
msg.msg_code = VENC_MSG_PAUSE;
msg.status_code = VENC_S_EFAIL;
msg.msg_data_size = 0;
venc_put_msg(dvenc, &msg);
}
return ret;
}
static int venc_resume(struct venc_dev *dvenc)
{
int ret = 0;
struct venc_msg msg;
ret = dal_call_f0(dvenc->q6_handle, VENC_DALRPC_RESUME, 1);
if (ret) {
pr_err("%s: remote function failed (%d)\n", __func__, ret);
msg.msg_code = VENC_MSG_RESUME;
msg.msg_data_size = 0;
msg.status_code = VENC_S_EFAIL;
venc_put_msg(dvenc, &msg);
}
return ret;
}
static int venc_flush(struct venc_dev *dvenc, void *argp)
{
int ret = 0;
struct venc_msg msg;
union venc_msg_data smsg;
int status = VENC_S_SUCCESS;
struct venc_buffer_flush flush;
if (copy_from_user(&flush, argp, sizeof(struct venc_buffer_flush)))
return -EFAULT;
if (flush.flush_mode == VENC_FLUSH_ALL) {
ret = dal_call_f0(dvenc->q6_handle, VENC_DALRPC_FLUSH, 1);
if (ret)
status = VENC_S_EFAIL;
} else
status = VENC_S_ENOTSUPP;
if (status != VENC_S_SUCCESS) {
if ((flush.flush_mode == VENC_FLUSH_INPUT) ||
(flush.flush_mode == VENC_FLUSH_ALL)) {
smsg.flush_ret.flush_mode = VENC_FLUSH_INPUT;
msg.msg_data = smsg;
msg.status_code = status;
msg.msg_code = VENC_MSG_FLUSH;
msg.msg_data_size = sizeof(union venc_msg_data);
venc_put_msg(dvenc, &msg);
}
if (flush.flush_mode == VENC_FLUSH_OUTPUT ||
(flush.flush_mode == VENC_FLUSH_ALL)) {
smsg.flush_ret.flush_mode = VENC_FLUSH_OUTPUT;
msg.msg_data = smsg;
msg.status_code = status;
msg.msg_code = VENC_MSG_FLUSH;
msg.msg_data_size = sizeof(union venc_msg_data);
venc_put_msg(dvenc, &msg);
}
return -EIO;
}
return ret;
}
static int venc_get_sequence_hdr(struct venc_dev *dvenc, void *argp)
{
pr_err("%s not supported\n", __func__);
return -EIO;
}
static int venc_set_qp_range(struct venc_dev *dvenc, void *argp)
{
int ret = 0;
struct venc_qp_range qp;
ret = copy_from_user(&qp, argp, sizeof(struct venc_qp_range));
if (ret) {
pr_err("%s: copy_from_user failed\n", __func__);
return ret;
}
if (dvenc->state == VENC_STATE_START ||
dvenc->state == VENC_STATE_PAUSE) {
ret =
dal_call_f5(dvenc->q6_handle, VENC_DALRPC_UPDATE_QP_RANGE,
&qp, sizeof(struct venc_qp_range));
if (ret) {
pr_err("%s: remote function failed (%d) \n", __func__,
ret);
return ret;
}
}
return ret;
}
static int venc_set_intra_period(struct venc_dev *dvenc, void *argp)
{
int ret = 0;
u32 pnum = 0;
ret = copy_from_user(&pnum, argp, sizeof(int));
if (ret) {
pr_err("%s: copy_from_user failed\n", __func__);
return ret;
}
if (dvenc->state == VENC_STATE_START ||
dvenc->state == VENC_STATE_PAUSE) {
ret = dal_call_f0(dvenc->q6_handle,
VENC_DALRPC_UPDATE_INTRA_PERIOD, pnum);
if (ret)
pr_err("%s: remote function failed (%d)\n", __func__,
ret);
}
return ret;
}
static int venc_set_intra_refresh(struct venc_dev *dvenc, void *argp)
{
int ret = 0;
u32 mb_num = 0;
ret = copy_from_user(&mb_num, argp, sizeof(int));
if (ret) {
pr_err("%s: copy_from_user failed\n", __func__);
return ret;
}
if (dvenc->state == VENC_STATE_START ||
dvenc->state == VENC_STATE_PAUSE) {
ret = dal_call_f0(dvenc->q6_handle,
VENC_DALRPC_UPDATE_INTRA_REFRESH, mb_num);
if (ret)
pr_err("%s: remote function failed (%d)\n", __func__,
ret);
}
return ret;
}
static int venc_set_frame_rate(struct venc_dev *dvenc, void *argp)
{
int ret = 0;
struct venc_frame_rate pdata;
ret = copy_from_user(&pdata, argp, sizeof(struct venc_frame_rate));
if (ret) {
pr_err("%s: copy_from_user failed\n", __func__);
return ret;
}
if (dvenc->state == VENC_STATE_START ||
dvenc->state == VENC_STATE_PAUSE) {
ret = dal_call_f5(dvenc->q6_handle,
VENC_DALRPC_UPDATE_FRAME_RATE,
(void *)&(pdata),
sizeof(struct venc_frame_rate));
if (ret)
pr_err("%s: remote function failed (%d)\n", __func__,
ret);
}
return ret;
}
static int venc_set_target_bitrate(struct venc_dev *dvenc, void *argp)
{
int ret = 0;
u32 pdata = 0;
ret = copy_from_user(&pdata, argp, sizeof(int));
if (ret) {
pr_err("%s: copy_from_user failed\n", __func__);
return ret;
}
if (dvenc->state == VENC_STATE_START ||
dvenc->state == VENC_STATE_PAUSE) {
ret = dal_call_f0(dvenc->q6_handle,
VENC_DALRPC_UPDATE_BITRATE, pdata);
if (ret)
pr_err("%s: remote function failed (%d)\n", __func__,
ret);
}
return ret;
}
static int venc_request_iframe(struct venc_dev *dvenc)
{
int ret = 0;
if (dvenc->state != VENC_STATE_START)
return -EINVAL;
ret = dal_call_f0(dvenc->q6_handle, VENC_DALRPC_REQUEST_IFRAME, 1);
if (ret)
pr_err("%s: remote function failed (%d)\n", __func__, ret);
return ret;
}
static int venc_stop_read_msg(struct venc_dev *dvenc)
{
struct venc_msg msg;
int ret = 0;
msg.status_code = 0;
msg.msg_code = VENC_MSG_STOP_READING_MSG;
msg.msg_data_size = 0;
venc_put_msg(dvenc, &msg);
return ret;
}
static int venc_q6_stop(struct venc_dev *dvenc)
{
int ret = 0;
struct venc_pmem_list *plist;
unsigned long flags;
wake_up(&dvenc->venc_msg_evt);
spin_lock_irqsave(&dvenc->venc_pmem_list_lock, flags);
if (!dvenc->pmem_freed) {
list_for_each_entry(plist, &dvenc->venc_pmem_list_head, list)
put_pmem_file(plist->buf.file);
dvenc->pmem_freed = 1;
}
spin_unlock_irqrestore(&dvenc->venc_pmem_list_lock, flags);
dvenc->state = VENC_STATE_STOP;
return ret;
}
static int venc_translate_error(enum venc_status_code q6_status)
{
int ret = 0;
switch (q6_status) {
case VENC_STATUS_SUCCESS:
ret = VENC_S_SUCCESS;
break;
case VENC_STATUS_ERROR:
ret = VENC_S_EFAIL;
break;
case VENC_STATUS_INVALID_STATE:
ret = VENC_S_EINVALSTATE;
break;
case VENC_STATUS_FLUSHING:
ret = VENC_S_EFLUSHED;
break;
case VENC_STATUS_INVALID_PARAM:
ret = VENC_S_EBADPARAM;
break;
case VENC_STATUS_CMD_QUEUE_FULL:
ret = VENC_S_ECMDQFULL;
break;
case VENC_STATUS_CRITICAL:
ret = VENC_S_EFATAL;
break;
case VENC_STATUS_INSUFFICIENT_RESOURCES:
ret = VENC_S_ENOHWRES;
break;
case VENC_STATUS_TIMEOUT:
ret = VENC_S_ETIMEOUT;
break;
}
if (q6_status != VENC_STATUS_SUCCESS)
pr_err("%s: Q6 failed (%d)", __func__, (int)q6_status);
return ret;
}
static void venc_q6_callback(void *data, int len, void *cookie)
{
int status = 0;
struct venc_dev *dvenc = (struct venc_dev *)cookie;
struct venc_msg_type *q6_msg = NULL;
struct venc_msg msg, msg1;
union venc_msg_data smsg1, smsg2;
unsigned long msg_code = 0;
struct venc_input_payload *pload1;
struct venc_output_payload *pload2;
uint32_t * tmp = (uint32_t *) data;
if (dvenc == NULL) {
pr_err("%s: empty driver parameter\n", __func__);
return;
}
if (tmp[2] == sizeof(struct venc_msg_type)) {
q6_msg = (struct venc_msg_type *)&tmp[3];
} else {
pr_err("%s: callback with empty message (%d, %d)\n",
__func__, tmp[2], sizeof(struct venc_msg_type));
return;
}
msg.msg_data_size = 0;
status = venc_translate_error(q6_msg->status);
switch ((enum venc_event_type_enum)q6_msg->event) {
case VENC_EVENT_START_STATUS:
dvenc->state = VENC_STATE_START;
msg_code = VENC_MSG_START;
break;
case VENC_EVENT_STOP_STATUS:
venc_q6_stop(dvenc);
msg_code = VENC_MSG_STOP;
break;
case VENC_EVENT_SUSPEND_STATUS:
dvenc->state = VENC_STATE_PAUSE;
msg_code = VENC_MSG_PAUSE;
break;
case VENC_EVENT_RESUME_STATUS:
dvenc->state = VENC_STATE_START;
msg_code = VENC_MSG_RESUME;
break;
case VENC_EVENT_FLUSH_STATUS:
smsg1.flush_ret.flush_mode = VENC_FLUSH_INPUT;
msg1.status_code = status;
msg1.msg_code = VENC_MSG_FLUSH;
msg1.msg_data = smsg1;
msg1.msg_data_size = sizeof(union venc_msg_data);
venc_put_msg(dvenc, &msg1);
smsg2.flush_ret.flush_mode = VENC_FLUSH_OUTPUT;
msg_code = VENC_MSG_FLUSH;
msg.msg_data = smsg2;
msg.msg_data_size = sizeof(union venc_msg_data);
break;
case VENC_EVENT_RELEASE_INPUT:
pload1 = &((q6_msg->payload).input_payload);
TRACE("Release_input: data: 0x%x \n", pload1->data);
if (pload1 != NULL) {
msg.msg_data.buf.client_data = pload1->data;
msg_code = VENC_MSG_INPUT_BUFFER_DONE;
msg.msg_data_size = sizeof(union venc_msg_data);
}
break;
case VENC_EVENT_DELIVER_OUTPUT:
pload2 = &((q6_msg->payload).output_payload);
smsg1.buf.flags = 0;
if (pload2->flags & VENC_FLAG_SYNC_FRAME)
smsg1.buf.flags |= VENC_FLAG_SYNC_FRAME;
if (pload2->flags & VENC_FLAG_CODEC_CONFIG)
smsg1.buf.flags |= VENC_FLAG_CODEC_CONFIG;
if (pload2->flags & VENC_FLAG_END_OF_FRAME)
smsg1.buf.flags |= VENC_FLAG_END_OF_FRAME;
if (pload2->flags & VENC_FLAG_EOS)
smsg1.buf.flags |= VENC_FLAG_EOS;
smsg1.buf.len = pload2->size;
smsg1.buf.offset = 0;
smsg1.buf.time_stamp = pload2->time_stamp;
smsg1.buf.client_data = pload2->data;
msg_code = VENC_MSG_OUTPUT_BUFFER_DONE;
msg.msg_data = smsg1;
msg.msg_data_size = sizeof(union venc_msg_data);
break;
default:
pr_err("%s: invalid response from Q6 (%d)\n", __func__,
(int)q6_msg->event);
return;
}
msg.status_code = status;
msg.msg_code = msg_code;
venc_put_msg(dvenc, &msg);
return;
}
static int venc_get_version(struct venc_dev *dvenc, void *argp)
{
struct venc_version ver_info;
int ret = 0;
ver_info.major = VENC_GET_MAJOR_VERSION(VENC_INTERFACE_VERSION);
ver_info.minor = VENC_GET_MINOR_VERSION(VENC_INTERFACE_VERSION);
ret = copy_to_user(((struct venc_version *)argp),
&ver_info, sizeof(ver_info));
if (ret)
pr_err("%s failed to copy_to_user\n", __func__);
return ret;
}
static long q6venc_ioctl(struct file *file, u32 cmd,
unsigned long arg)
{
long ret = 0;
void __user *argp = (void __user *)arg;
struct venc_dev *dvenc = file->private_data;
if (!dvenc || !dvenc->is_active)
return -EPERM;
switch (cmd) {
case VENC_IOCTL_SET_INPUT_BUFFER:
ret = venc_set_buffer(dvenc, argp, VENC_BUFFER_TYPE_INPUT);
break;
case VENC_IOCTL_SET_OUTPUT_BUFFER:
ret = venc_set_buffer(dvenc, argp, VENC_BUFFER_TYPE_OUTPUT);
break;
case VENC_IOCTL_GET_SEQUENCE_HDR:
ret = venc_get_sequence_hdr(dvenc, argp);
break;
case VENC_IOCTL_SET_QP_RANGE:
ret = venc_set_qp_range(dvenc, argp);
break;
case VENC_IOCTL_SET_INTRA_PERIOD:
ret = venc_set_intra_period(dvenc, argp);
break;
case VENC_IOCTL_SET_INTRA_REFRESH:
ret = venc_set_intra_refresh(dvenc, argp);
break;
case VENC_IOCTL_SET_FRAME_RATE:
ret = venc_set_frame_rate(dvenc, argp);
break;
case VENC_IOCTL_SET_TARGET_BITRATE:
ret = venc_set_target_bitrate(dvenc, argp);
break;
case VENC_IOCTL_CMD_REQUEST_IFRAME:
if (dvenc->state == VENC_STATE_START)
ret = venc_request_iframe(dvenc);
break;
case VENC_IOCTL_CMD_START:
ret = venc_start(dvenc, argp);
break;
case VENC_IOCTL_CMD_STOP:
ret = venc_stop(dvenc);
break;
case VENC_IOCTL_CMD_PAUSE:
ret = venc_pause(dvenc);
break;
case VENC_IOCTL_CMD_RESUME:
ret = venc_resume(dvenc);
break;
case VENC_IOCTL_CMD_ENCODE_FRAME:
ret = venc_encode_frame(dvenc, argp);
break;
case VENC_IOCTL_CMD_FILL_OUTPUT_BUFFER:
ret = venc_fill_output(dvenc, argp);
break;
case VENC_IOCTL_CMD_FLUSH:
ret = venc_flush(dvenc, argp);
break;
case VENC_IOCTL_CMD_READ_NEXT_MSG:
wait_event_interruptible(dvenc->venc_msg_evt,
venc_get_msg(dvenc, argp));
break;
case VENC_IOCTL_CMD_STOP_READ_MSG:
ret = venc_stop_read_msg(dvenc);
break;
case VENC_IOCTL_GET_VERSION:
ret = venc_get_version(dvenc, argp);
break;
default:
pr_err("%s: invalid ioctl code (%d)\n", __func__, cmd);
ret = -ENOTTY;
break;
}
return ret;
}
static int q6venc_open(struct inode *inode, struct file *file)
{
int i;
int ret = 0;
struct venc_dev *dvenc;
struct venc_msg_list *plist, *tmp;
struct dal_info version_info;
dvenc = kzalloc(sizeof(struct venc_dev), GFP_KERNEL);
if (!dvenc) {
pr_err("%s: unable to allocate memory for struct venc_dev\n",
__func__);
return -ENOMEM;
}
file->private_data = dvenc;
INIT_LIST_HEAD(&dvenc->venc_msg_list_head);
INIT_LIST_HEAD(&dvenc->venc_msg_list_free);
INIT_LIST_HEAD(&dvenc->venc_pmem_list_head);
init_waitqueue_head(&dvenc->venc_msg_evt);
spin_lock_init(&dvenc->venc_msg_list_lock);
spin_lock_init(&dvenc->venc_pmem_list_lock);
venc_ref++;
for (i = 0; i < VENC_MSG_MAX; i++) {
plist = kzalloc(sizeof(struct venc_msg_list), GFP_KERNEL);
if (!plist) {
pr_err("%s: kzalloc failed\n", __func__);
ret = -ENOMEM;
goto err_venc_create_msg_list;
}
list_add(&plist->list, &dvenc->venc_msg_list_free);
}
dvenc->q6_handle =
dal_attach(DALDEVICEID_VENC_DEVICE, DALDEVICEID_VENC_PORTNAME, 1,
venc_q6_callback, (void *)dvenc);
if (!(dvenc->q6_handle)) {
pr_err("%s: daldevice_attach failed (%d)\n", __func__, ret);
goto err_venc_dal_attach;
}
ret = dal_call_f9(dvenc->q6_handle, DAL_OP_INFO, &version_info,
sizeof(struct dal_info));
if (ret) {
pr_err("%s: failed to get version\n", __func__);
goto err_venc_dal_open;
}
if (venc_check_version(VENC_INTERFACE_VERSION, version_info.version)) {
pr_err("%s: driver version mismatch\n", __func__);
goto err_venc_dal_open;
}
ret = dal_call_f0(dvenc->q6_handle, DAL_OP_OPEN, 1);
if (ret) {
pr_err("%s: dal_call_open failed (%d)\n", __func__, ret);
goto err_venc_dal_open;
}
dvenc->state = VENC_STATE_STOP;
dvenc->is_active = 1;
prevent_sleep();
return ret;
err_venc_dal_open:
dal_detach(dvenc->q6_handle);
err_venc_dal_attach:
list_for_each_entry_safe(plist, tmp, &dvenc->venc_msg_list_free, list) {
list_del(&plist->list);
kfree(plist);
}
err_venc_create_msg_list:
kfree(dvenc);
venc_ref--;
return ret;
}
static int q6venc_release(struct inode *inode, struct file *file)
{
int ret = 0;
struct venc_msg_list *l, *n;
struct venc_pmem_list *plist, *m;
struct venc_dev *dvenc;
unsigned long flags;
venc_ref--;
dvenc = file->private_data;
dvenc->is_active = 0;
wake_up_all(&dvenc->venc_msg_evt);
dal_call_f0(dvenc->q6_handle, VENC_DALRPC_STOP, 1);
dal_call_f0(dvenc->q6_handle, DAL_OP_CLOSE, 1);
dal_detach(dvenc->q6_handle);
list_for_each_entry_safe(l, n, &dvenc->venc_msg_list_free, list) {
list_del(&l->list);
kfree(l);
}
list_for_each_entry_safe(l, n, &dvenc->venc_msg_list_head, list) {
list_del(&l->list);
kfree(l);
}
spin_lock_irqsave(&dvenc->venc_pmem_list_lock, flags);
if (!dvenc->pmem_freed) {
list_for_each_entry(plist, &dvenc->venc_pmem_list_head, list)
put_pmem_file(plist->buf.file);
dvenc->pmem_freed = 1;
}
spin_unlock_irqrestore(&dvenc->venc_pmem_list_lock, flags);
list_for_each_entry_safe(plist, m, &dvenc->venc_pmem_list_head, list) {
list_del(&plist->list);
kfree(plist);
}
kfree(dvenc);
allow_sleep();
return ret;
}
const struct file_operations q6venc_fops = {
.owner = THIS_MODULE,
.open = q6venc_open,
.release = q6venc_release,
.unlocked_ioctl = q6venc_ioctl,
};
static int __init q6venc_init(void)
{
int ret = 0;
pm_qos_add_request(&pm_qos_req, PM_QOS_CPU_DMA_LATENCY,
PM_QOS_DEFAULT_VALUE);
wake_lock_init(&wakelock, WAKE_LOCK_SUSPEND, "venc_suspend");
venc_device_p = kzalloc(sizeof(struct venc_dev), GFP_KERNEL);
if (!venc_device_p) {
pr_err("%s: unable to allocate memory for venc_device_p\n",
__func__);
return -ENOMEM;
}
ret = alloc_chrdev_region(&venc_dev_num, 0, 1, VENC_NAME);
if (ret < 0) {
pr_err("%s: alloc_chrdev_region failed (%d)\n", __func__,
ret);
return ret;
}
venc_class = class_create(THIS_MODULE, VENC_NAME);
if (IS_ERR(venc_class)) {
ret = PTR_ERR(venc_class);
pr_err("%s: failed to create venc_class (%d)\n",
__func__, ret);
goto err_venc_class_create;
}
venc_device_p->class_devp =
device_create(venc_class, NULL, venc_dev_num, NULL,
VENC_NAME);
if (IS_ERR(venc_device_p->class_devp)) {
ret = PTR_ERR(venc_device_p->class_devp);
pr_err("%s: failed to create class_device (%d)\n", __func__,
ret);
goto err_venc_class_device_create;
}
cdev_init(&cdev, &q6venc_fops);
cdev.owner = THIS_MODULE;
ret = cdev_add(&cdev, venc_dev_num, 1);
if (ret < 0) {
pr_err("%s: cdev_add failed (%d)\n", __func__, ret);
goto err_venc_cdev_add;
}
init_waitqueue_head(&venc_device_p->venc_msg_evt);
return ret;
err_venc_cdev_add:
device_destroy(venc_class, venc_dev_num);
err_venc_class_device_create:
class_destroy(venc_class);
err_venc_class_create:
unregister_chrdev_region(venc_dev_num, 1);
return ret;
}
static void __exit q6venc_exit(void)
{
cdev_del(&(cdev));
device_destroy(venc_class, venc_dev_num);
class_destroy(venc_class);
unregister_chrdev_region(venc_dev_num, 1);
}
MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("Video encoder driver for QDSP6");
MODULE_VERSION("2.0");
module_init(q6venc_init);
module_exit(q6venc_exit);
Reference in New Issue View Git Blame Copy Permalink