| /* 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/android_pmem.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); |