| /* arch/arm/mach-msm/qdsp5/adsp_video_verify_cmd.c |
| * |
| * Verificion code for aDSP VENC packets from userspace. |
| * |
| * Copyright (c) 2008 QUALCOMM Incorporated |
| * Copyright (C) 2008 Google, Inc. |
| * |
| * This software is licensed under the terms of the GNU General Public |
| * License version 2, as published by the Free Software Foundation, and |
| * may be copied, distributed, and modified under those terms. |
| * |
| * 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/io.h> |
| |
| #define ADSP_DEBUG_MSGS 0 |
| #if ADSP_DEBUG_MSGS |
| #define DLOG(fmt,args...) \ |
| do { printk(KERN_INFO "[%s:%s:%d] "fmt, __FILE__, __func__, __LINE__, \ |
| ##args); } \ |
| while (0) |
| #else |
| #define DLOG(x...) do {} while (0) |
| #endif |
| |
| #include <mach/qdsp5/qdsp5venccmdi.h> |
| #include "adsp.h" |
| |
| |
| static unsigned short x_dimension, y_dimension; |
| |
| static inline void *high_low_short_to_ptr(unsigned short high, |
| unsigned short low) |
| { |
| return (void *)((((unsigned long)high) << 16) | ((unsigned long)low)); |
| } |
| |
| static inline void ptr_to_high_low_short(void *ptr, unsigned short *high, |
| unsigned short *low) |
| { |
| *high = (unsigned short)((((unsigned long)ptr) >> 16) & 0xffff); |
| *low = (unsigned short)((unsigned long)ptr & 0xffff); |
| } |
| |
| static int pmem_fixup_high_low(unsigned short *high, |
| unsigned short *low, |
| unsigned short size_high, |
| unsigned short size_low, |
| struct msm_adsp_module *module, |
| unsigned long *addr, unsigned long *size) |
| { |
| void *phys_addr; |
| unsigned long phys_size; |
| unsigned long kvaddr; |
| |
| phys_addr = high_low_short_to_ptr(*high, *low); |
| phys_size = (unsigned long)high_low_short_to_ptr(size_high, size_low); |
| DLOG("virt %x %x\n", phys_addr, phys_size); |
| if (adsp_pmem_fixup_kvaddr(module, &phys_addr, &kvaddr, phys_size)) { |
| DLOG("ah%x al%x sh%x sl%x addr %x size %x\n", |
| *high, *low, size_high, size_low, phys_addr, phys_size); |
| return -1; |
| } |
| ptr_to_high_low_short(phys_addr, high, low); |
| DLOG("phys %x %x\n", phys_addr, phys_size); |
| if (addr) |
| *addr = kvaddr; |
| if (size) |
| *size = phys_size; |
| return 0; |
| } |
| |
| static int verify_venc_cmd(struct msm_adsp_module *module, |
| void *cmd_data, size_t cmd_size) |
| { |
| unsigned short cmd_id = ((unsigned short *)cmd_data)[0]; |
| unsigned long frame_buf_size, luma_buf_size, chroma_buf_size; |
| unsigned short frame_buf_size_high, frame_buf_size_low; |
| unsigned short luma_buf_size_high, luma_buf_size_low; |
| unsigned short chroma_buf_size_high, chroma_buf_size_low; |
| videnc_cmd_cfg *config_cmd; |
| videnc_cmd_frame_start *frame_cmd; |
| videnc_cmd_dis *dis_cmd; |
| |
| DLOG("cmd_size %d cmd_id %d cmd_data %x\n", cmd_size, cmd_id, cmd_data); |
| switch (cmd_id) { |
| case VIDENC_CMD_ACTIVE: |
| if (cmd_size < sizeof(videnc_cmd_active)) |
| return -1; |
| break; |
| case VIDENC_CMD_IDLE: |
| if (cmd_size < sizeof(videnc_cmd_idle)) |
| return -1; |
| x_dimension = y_dimension = 0; |
| break; |
| case VIDENC_CMD_STATUS_QUERY: |
| if (cmd_size < sizeof(videnc_cmd_status_query)) |
| return -1; |
| break; |
| case VIDENC_CMD_RC_CFG: |
| if (cmd_size < sizeof(videnc_cmd_rc_cfg)) |
| return -1; |
| break; |
| case VIDENC_CMD_INTRA_REFRESH: |
| if (cmd_size < sizeof(videnc_cmd_intra_refresh)) |
| return -1; |
| break; |
| case VIDENC_CMD_DIGITAL_ZOOM: |
| if (cmd_size < sizeof(videnc_cmd_digital_zoom)) |
| return -1; |
| break; |
| case VIDENC_CMD_DIS_CFG: |
| if (cmd_size < sizeof(videnc_cmd_dis_cfg)) |
| return -1; |
| break; |
| case VIDENC_CMD_CFG: |
| if (cmd_size < sizeof(videnc_cmd_cfg)) |
| return -1; |
| config_cmd = (videnc_cmd_cfg *)cmd_data; |
| x_dimension = ((config_cmd->venc_frame_dim) & 0xFF00)>>8; |
| x_dimension = x_dimension*16; |
| y_dimension = (config_cmd->venc_frame_dim) & 0xFF; |
| y_dimension = y_dimension * 16; |
| break; |
| case VIDENC_CMD_FRAME_START: |
| if (cmd_size < sizeof(videnc_cmd_frame_start)) |
| return -1; |
| frame_cmd = (videnc_cmd_frame_start *)cmd_data; |
| luma_buf_size = x_dimension * y_dimension; |
| chroma_buf_size = luma_buf_size>>1; |
| frame_buf_size = luma_buf_size + chroma_buf_size; |
| ptr_to_high_low_short((void *)luma_buf_size, |
| &luma_buf_size_high, |
| &luma_buf_size_low); |
| ptr_to_high_low_short((void *)chroma_buf_size, |
| &chroma_buf_size_high, |
| &chroma_buf_size_low); |
| ptr_to_high_low_short((void *)frame_buf_size, |
| &frame_buf_size_high, |
| &frame_buf_size_low); |
| /* Address of raw Y data. */ |
| if (pmem_fixup_high_low(&frame_cmd->input_luma_addr_high, |
| &frame_cmd->input_luma_addr_low, |
| luma_buf_size_high, |
| luma_buf_size_low, |
| module, |
| NULL, NULL)) |
| return -1; |
| /* Address of raw CbCr data */ |
| if (pmem_fixup_high_low(&frame_cmd->input_chroma_addr_high, |
| &frame_cmd->input_chroma_addr_low, |
| chroma_buf_size_high, |
| chroma_buf_size_low, |
| module, |
| NULL, NULL)) |
| return -1; |
| /* Reference VOP */ |
| if (pmem_fixup_high_low(&frame_cmd->ref_vop_buf_ptr_high, |
| &frame_cmd->ref_vop_buf_ptr_low, |
| frame_buf_size_high, |
| frame_buf_size_low, |
| module, |
| NULL, NULL)) |
| return -1; |
| /* Encoded Packet Address */ |
| if (pmem_fixup_high_low(&frame_cmd->enc_pkt_buf_ptr_high, |
| &frame_cmd->enc_pkt_buf_ptr_low, |
| frame_cmd->enc_pkt_buf_size_high, |
| frame_cmd->enc_pkt_buf_size_low, |
| module, |
| NULL, NULL)) |
| return -1; |
| /* Unfiltered VOP Buffer Address */ |
| if (pmem_fixup_high_low( |
| &frame_cmd->unfilt_recon_vop_buf_ptr_high, |
| &frame_cmd->unfilt_recon_vop_buf_ptr_low, |
| frame_buf_size_high, |
| frame_buf_size_low, |
| module, |
| NULL, NULL)) |
| return -1; |
| /* Filtered VOP Buffer Address */ |
| if (pmem_fixup_high_low(&frame_cmd->filt_recon_vop_buf_ptr_high, |
| &frame_cmd->filt_recon_vop_buf_ptr_low, |
| frame_buf_size_high, |
| frame_buf_size_low, |
| module, |
| NULL, NULL)) |
| return -1; |
| break; |
| case VIDENC_CMD_DIS: |
| if (cmd_size < sizeof(videnc_cmd_dis)) |
| return -1; |
| dis_cmd = (videnc_cmd_dis *)cmd_data; |
| luma_buf_size = x_dimension * y_dimension; |
| ptr_to_high_low_short((void *)luma_buf_size, |
| &luma_buf_size_high, |
| &luma_buf_size_low); |
| /* Prev VFE Luma Output Address */ |
| if (pmem_fixup_high_low(&dis_cmd->vfe_out_prev_luma_addr_high, |
| &dis_cmd->vfe_out_prev_luma_addr_low, |
| luma_buf_size_high, |
| luma_buf_size_low, |
| module, |
| NULL, NULL)) |
| return -1; |
| break; |
| default: |
| printk(KERN_INFO "adsp_video:unknown encoder video command %u\n", |
| cmd_id); |
| return 0; |
| } |
| |
| return 0; |
| } |
| |
| |
| int adsp_videoenc_verify_cmd(struct msm_adsp_module *module, |
| unsigned int queue_id, void *cmd_data, |
| size_t cmd_size) |
| { |
| switch (queue_id) { |
| case QDSP_mpuVEncCmdQueue: |
| DLOG("\n"); |
| return verify_venc_cmd(module, cmd_data, cmd_size); |
| default: |
| printk(KERN_INFO "unknown video queue %u\n", queue_id); |
| return 0; |
| } |
| } |
| |
