void msm_camio_set_perf_lvl(enum msm_bus_perf_setting perf_setting)
{
switch (perf_setting) {
case S_INIT:
add_axi_qos();
break;
case S_PREVIEW:
update_axi_qos(MSM_AXI_QOS_PREVIEW);
break;
case S_VIDEO:
update_axi_qos(MSM_AXI_QOS_RECORDING);
break;
case S_CAPTURE:
update_axi_qos(MSM_AXI_QOS_SNAPSHOT);
break;
case S_DEFAULT:
update_axi_qos(PM_QOS_DEFAULT_VALUE);
break;
case S_EXIT:
release_axi_qos();
break;
default:
CDBG("%s: INVALID CASE\n", __func__);
}
}
void msm_camio_set_perf_lvl(enum msm_bus_perf_setting perf_setting)
{
switch (perf_setting) {
case S_INIT:
add_axi_qos();
update_axi_qos(MSM_AXI_QOS_PREVIEW);
axi_allocate(AXI_FLOW_VIEWFINDER_HI);
break;
case S_PREVIEW:
// do nothing as axi clock/bandwidth is already set while INIT
break;
case S_VIDEO:
update_axi_qos(MSM_AXI_QOS_RECORDING);
break;
case S_CAPTURE:
update_axi_qos(MSM_AXI_QOS_SNAPSHOT);
break;
case S_DEFAULT:
update_axi_qos(PM_QOS_DEFAULT_VALUE);
break;
case S_EXIT:
axi_free(AXI_FLOW_VIEWFINDER_HI);
release_axi_qos();
break;
default:
CDBG("%s: INVALID CASE\n", __func__);
}
}
static void vfe_release(struct platform_device *dev)
{
msm_camio_disable(dev);
vfe_cmd_release(dev);
update_axi_qos(PM_QOS_DEFAULT_VALUE);
vfe_syncdata = NULL;
}
void msm_camio_set_perf_lvl(enum msm_bus_perf_setting perf_setting)
{
switch (perf_setting) {
case S_INIT:
add_axi_qos();
update_axi_qos(MSM_AXI_QOS_PREVIEW);
axi_allocate(AXI_FLOW_VIEWFINDER_HI);
break;
case S_PREVIEW:
break;
case S_VIDEO:
break;
case S_CAPTURE:
break;
case S_DEFAULT:
break;
case S_EXIT:
axi_free(AXI_FLOW_VIEWFINDER_HI);
release_axi_qos();
break;
default:
CDBG("%s: INVALID CASE\n", __func__);
}
}
static void vfe_7x_ops(void *driver_data, unsigned id, size_t len,
void (*getevent)(void *ptr, size_t len))
{
uint32_t evt_buf[3];
struct msm_vfe_resp *rp;
void *data;
CDBG("%s:id=%d\n", __func__, id);
len = (id == VFE_ADSP_EVENT) ? 0 : len;
data = resp->vfe_alloc(sizeof(struct msm_vfe_resp) + len,
vfe_syncdata, GFP_ATOMIC);
if (!data) {
pr_err("%s: rp: cannot allocate buffer\n", __func__);
return;
}
rp = (struct msm_vfe_resp *)data;
rp->evt_msg.len = len;
if (id == VFE_ADSP_EVENT) {
/* event */
rp->type = VFE_EVENT;
rp->evt_msg.type = MSM_CAMERA_EVT;
getevent(evt_buf, sizeof(evt_buf));
rp->evt_msg.msg_id = evt_buf[0];
CDBG("%s:event:msg_id=%d\n", __func__, rp->evt_msg.msg_id);
resp->vfe_resp(rp, MSM_CAM_Q_VFE_EVT, vfe_syncdata,
GFP_ATOMIC);
} else {
/* messages */
rp->evt_msg.type = MSM_CAMERA_MSG;
rp->evt_msg.msg_id = id;
rp->evt_msg.data = rp + 1;
getevent(rp->evt_msg.data, len);
CDBG("%s:messages:msg_id=%d\n", __func__, rp->evt_msg.msg_id);
switch (rp->evt_msg.msg_id) {
case MSG_SNAPSHOT:
update_axi_qos(MSM_AXI_QOS_PREVIEW);
rp->type = VFE_MSG_SNAPSHOT;
break;
case MSG_OUTPUT1:
case MSG_OUTPUT2:
rp->type = VFE_MSG_OUTPUT_P;
vfe_7x_convert(&(rp->phy), VFE_MSG_OUTPUT_P,
rp->evt_msg.data, &(rp->extdata),
&(rp->extlen));
break;
case MSG_STATS_AF:
rp->type = VFE_MSG_STATS_AF;
vfe_7x_convert(&(rp->phy), VFE_MSG_STATS_AF,
rp->evt_msg.data, NULL, NULL);
break;
case MSG_STATS_WE:
rp->type = VFE_MSG_STATS_WE;
vfe_7x_convert(&(rp->phy), VFE_MSG_STATS_WE,
rp->evt_msg.data, NULL, NULL);
CDBG("MSG_STATS_WE: phy = 0x%x\n", rp->phy.sbuf_phy);
break;
case MSG_STOP_ACK:
rp->type = VFE_MSG_GENERAL;
stopevent.state = 1;
wake_up(&stopevent.wait);
break;
default:
rp->type = VFE_MSG_GENERAL;
break;
}
resp->vfe_resp(rp, MSM_CAM_Q_VFE_MSG, vfe_syncdata, GFP_ATOMIC);
}
}
static int vfe_proc_general(struct msm_vfe_command_8k *cmd)
{
int rc = 0;
CDBG("%s: cmdID = %d\n", __func__, cmd->id);
switch (cmd->id) {
case VFE_CMD_ID_RESET:
msm_camio_vfe_blk_reset();
msm_camio_camif_pad_reg_reset_2();
vfe_reset();
break;
case VFE_CMD_ID_START: {
struct vfe_cmd_start start;
CHECKED_COPY_FROM_USER(&start);
msm_camio_camif_pad_reg_reset();
vfe_start(&start);
}
break;
case VFE_CMD_ID_CAMIF_CONFIG: {
struct vfe_cmd_camif_config camif;
CHECKED_COPY_FROM_USER(&camif);
vfe_camif_config(&camif);
}
break;
case VFE_CMD_ID_BLACK_LEVEL_CONFIG: {
struct vfe_cmd_black_level_config bl;
CHECKED_COPY_FROM_USER(&bl);
vfe_black_level_config(&bl);
}
break;
case VFE_CMD_ID_ROLL_OFF_CONFIG:{
struct vfe_cmd_roll_off_config *rolloff =
kmalloc(sizeof(struct vfe_cmd_roll_off_config),
GFP_KERNEL);
if (!rolloff) {
pr_err("%s: out of memory\n", __func__);
rc = -ENOMEM;
break;
}
do {
CHECKED_COPY_FROM_USER(rolloff);
vfe_roll_off_config(rolloff);
} while (0);
kfree(rolloff);
}
break;
case VFE_CMD_ID_DEMUX_CHANNEL_GAIN_CONFIG: {
struct vfe_cmd_demux_channel_gain_config demuxc;
CHECKED_COPY_FROM_USER(&demuxc);
vfe_demux_channel_gain_config(&demuxc);
}
break;
case VFE_CMD_ID_DEMOSAIC_CONFIG: {
struct vfe_cmd_demosaic_config demosaic;
CHECKED_COPY_FROM_USER(&demosaic);
vfe_demosaic_config(&demosaic);
}
break;
case VFE_CMD_ID_FOV_CROP_CONFIG:
case VFE_CMD_ID_FOV_CROP_UPDATE: {
struct vfe_cmd_fov_crop_config fov;
CHECKED_COPY_FROM_USER(&fov);
vfe_fov_crop_config(&fov);
}
break;
case VFE_CMD_ID_MAIN_SCALER_CONFIG:
case VFE_CMD_ID_MAIN_SCALER_UPDATE: {
struct vfe_cmd_main_scaler_config mainds;
CHECKED_COPY_FROM_USER(&mainds);
vfe_main_scaler_config(&mainds);
}
break;
case VFE_CMD_ID_WHITE_BALANCE_CONFIG:
case VFE_CMD_ID_WHITE_BALANCE_UPDATE: {
struct vfe_cmd_white_balance_config wb;
CHECKED_COPY_FROM_USER(&wb);
vfe_white_balance_config(&wb);
}
break;
case VFE_CMD_ID_COLOR_CORRECTION_CONFIG:
case VFE_CMD_ID_COLOR_CORRECTION_UPDATE: {
struct vfe_cmd_color_correction_config cc;
CHECKED_COPY_FROM_USER(&cc);
vfe_color_correction_config(&cc);
}
break;
case VFE_CMD_ID_LA_CONFIG: {
struct vfe_cmd_la_config la;
CHECKED_COPY_FROM_USER(&la);
vfe_la_config(&la);
}
break;
case VFE_CMD_ID_RGB_GAMMA_CONFIG: {
struct vfe_cmd_rgb_gamma_config rgb;
CHECKED_COPY_FROM_USER(&rgb);
rc = vfe_rgb_gamma_config(&rgb);
}
break;
case VFE_CMD_ID_CHROMA_ENHAN_CONFIG:
case VFE_CMD_ID_CHROMA_ENHAN_UPDATE: {
struct vfe_cmd_chroma_enhan_config chrom;
CHECKED_COPY_FROM_USER(&chrom);
vfe_chroma_enhan_config(&chrom);
}
break;
case VFE_CMD_ID_CHROMA_SUPPRESSION_CONFIG:
case VFE_CMD_ID_CHROMA_SUPPRESSION_UPDATE: {
struct vfe_cmd_chroma_suppression_config chromsup;
CHECKED_COPY_FROM_USER(&chromsup);
vfe_chroma_sup_config(&chromsup);
}
break;
case VFE_CMD_ID_ASF_CONFIG: {
struct vfe_cmd_asf_config asf;
CHECKED_COPY_FROM_USER(&asf);
vfe_asf_config(&asf);
}
break;
case VFE_CMD_ID_SCALER2Y_CONFIG:
case VFE_CMD_ID_SCALER2Y_UPDATE: {
struct vfe_cmd_scaler2_config ds2y;
CHECKED_COPY_FROM_USER(&ds2y);
vfe_scaler2y_config(&ds2y);
}
break;
case VFE_CMD_ID_SCALER2CbCr_CONFIG:
case VFE_CMD_ID_SCALER2CbCr_UPDATE: {
struct vfe_cmd_scaler2_config ds2cbcr;
CHECKED_COPY_FROM_USER(&ds2cbcr);
vfe_scaler2cbcr_config(&ds2cbcr);
}
break;
case VFE_CMD_ID_CHROMA_SUBSAMPLE_CONFIG: {
struct vfe_cmd_chroma_subsample_config sub;
CHECKED_COPY_FROM_USER(&sub);
vfe_chroma_subsample_config(&sub);
}
break;
case VFE_CMD_ID_FRAME_SKIP_CONFIG: {
struct vfe_cmd_frame_skip_config fskip;
CHECKED_COPY_FROM_USER(&fskip);
vfe_frame_skip_config(&fskip);
}
break;
case VFE_CMD_ID_OUTPUT_CLAMP_CONFIG: {
struct vfe_cmd_output_clamp_config clamp;
CHECKED_COPY_FROM_USER(&clamp);
vfe_output_clamp_config(&clamp);
}
break;
case VFE_CMD_ID_BLACK_LEVEL_UPDATE: {
struct vfe_cmd_black_level_config blk;
CHECKED_COPY_FROM_USER(&blk);
vfe_black_level_update(&blk);
}
break;
case VFE_CMD_ID_DEMUX_CHANNEL_GAIN_UPDATE: {
struct vfe_cmd_demux_channel_gain_config dmu;
CHECKED_COPY_FROM_USER(&dmu);
vfe_demux_channel_gain_update(&dmu);
}
break;
case VFE_CMD_ID_DEMOSAIC_BPC_UPDATE: {
struct vfe_cmd_demosaic_bpc_update demo_bpc;
CHECKED_COPY_FROM_USER(&demo_bpc);
vfe_demosaic_bpc_update(&demo_bpc);
}
break;
case VFE_CMD_ID_DEMOSAIC_ABF_UPDATE: {
struct vfe_cmd_demosaic_abf_update demo_abf;
CHECKED_COPY_FROM_USER(&demo_abf);
vfe_demosaic_abf_update(&demo_abf);
}
break;
case VFE_CMD_ID_LA_UPDATE: {
struct vfe_cmd_la_config la;
CHECKED_COPY_FROM_USER(&la);
vfe_la_update(&la);
}
break;
case VFE_CMD_ID_RGB_GAMMA_UPDATE: {
struct vfe_cmd_rgb_gamma_config rgb;
CHECKED_COPY_FROM_USER(&rgb);
rc = vfe_rgb_gamma_update(&rgb);
}
break;
case VFE_CMD_ID_ASF_UPDATE: {
struct vfe_cmd_asf_update asf;
CHECKED_COPY_FROM_USER(&asf);
vfe_asf_update(&asf);
}
break;
case VFE_CMD_ID_FRAME_SKIP_UPDATE: {
struct vfe_cmd_frame_skip_update fskip;
CHECKED_COPY_FROM_USER(&fskip);
if (fskip.output2Pattern == 0xffffffff)
update_axi_qos(MSM_AXI_QOS_RECORDING);
else if (fskip.output2Pattern == 0)
update_axi_qos(MSM_AXI_QOS_PREVIEW);
vfe_frame_skip_update(&fskip);
}
break;
case VFE_CMD_ID_CAMIF_FRAME_UPDATE: {
struct vfe_cmds_camif_frame fup;
CHECKED_COPY_FROM_USER(&fup);
vfe_camif_frame_update(&fup);
}
break;
case VFE_CMD_ID_STATS_AUTOFOCUS_UPDATE: {
struct vfe_cmd_stats_af_update afup;
CHECKED_COPY_FROM_USER(&afup);
vfe_stats_update_af(&afup);
}
break;
case VFE_CMD_ID_STATS_WB_EXP_UPDATE: {
struct vfe_cmd_stats_wb_exp_update wbexp;
CHECKED_COPY_FROM_USER(&wbexp);
vfe_stats_update_wb_exp(&wbexp);
}
break;
case VFE_CMD_ID_STOP:
vfe_stop();
break;
case VFE_CMD_ID_GET_HW_VERSION:
break;
case VFE_CMD_ID_STATS_SETTING: {
struct vfe_cmd_stats_setting stats;
CHECKED_COPY_FROM_USER(&stats);
vfe_stats_setting(&stats);
}
break;
case VFE_CMD_ID_STATS_AUTOFOCUS_START: {
struct vfe_cmd_stats_af_start af;
CHECKED_COPY_FROM_USER(&af);
vfe_stats_start_af(&af);
}
break;
case VFE_CMD_ID_STATS_AUTOFOCUS_STOP:
vfe_stats_af_stop();
break;
case VFE_CMD_ID_STATS_WB_EXP_START: {
struct vfe_cmd_stats_wb_exp_start awexp;
CHECKED_COPY_FROM_USER(&awexp);
vfe_stats_start_wb_exp(&awexp);
}
break;
case VFE_CMD_ID_STATS_WB_EXP_STOP:
vfe_stats_wb_exp_stop();
break;
case VFE_CMD_ID_ASYNC_TIMER_SETTING:
break;
case VFE_CMD_ID_UPDATE:
vfe_update();
break;
case VFE_CMD_ID_TEST_GEN_START:
break;
default:
pr_err("%s: invalid cmd id %d\n", __func__, cmd->id);
rc = -EINVAL;
break;
}
return rc;
}
