int msm_mctl_pp_ioctl(struct msm_cam_media_controller *p_mctl, unsigned int cmd, unsigned long arg) { int rc = -EINVAL; struct msm_mctl_post_proc_cmd pp_cmd; void __user *argp = (void __user *)arg; if (copy_from_user(&pp_cmd, argp, sizeof(pp_cmd))) return -EFAULT; switch (pp_cmd.type) { case MSM_PP_CMD_TYPE_VPE: rc = msm_mctl_pp_proc_vpe_cmd(p_mctl, &pp_cmd.cmd); break; case MSM_PP_CMD_TYPE_MCTL: rc = msm_mctl_pp_proc_cmd(p_mctl, &pp_cmd.cmd); break; default: rc = -EPERM; break; } if (!rc) { /* deep copy back the return value */ if (copy_to_user((void *)arg, &pp_cmd, sizeof(struct msm_mctl_post_proc_cmd))) { ERR_COPY_TO_USER(); rc = -EFAULT; } } return rc; }
static int msm_get_sensor_info(struct msm_sync *sync, void __user *arg) { int rc = 0; struct msm_camsensor_info info; struct msm_camera_sensor_info *sdata; if (copy_from_user(&info, arg, sizeof(struct msm_camsensor_info))) { ERR_COPY_FROM_USER(); return -EFAULT; } sdata = sync->pdev->dev.platform_data; D("%s: sensor_name %s\n", __func__, sdata->sensor_name); memcpy(&info.name[0], sdata->sensor_name, MAX_SENSOR_NAME); info.flash_enabled = sdata->flash_data->flash_type != MSM_CAMERA_FLASH_NONE; /* copy back to user space */ if (copy_to_user((void *)arg, &info, sizeof(struct msm_camsensor_info))) { ERR_COPY_TO_USER(); rc = -EFAULT; } return rc; }
int msm_mctl_pp_proc_cmd(struct msm_cam_media_controller *p_mctl, struct msm_mctl_pp_cmd *pp_cmd) { int rc = 0; struct msm_mctl_pp_frame_buffer pp_buffer; struct msm_frame_buffer *buf = NULL; void __user *argp = (void __user *)pp_cmd->value; int msg_type = VFE_MSG_OUTPUT_V; unsigned long flags; switch (pp_cmd->id) { case MCTL_CMD_GET_FRAME_BUFFER: { if (copy_from_user(&pp_buffer, pp_cmd->value, sizeof(pp_buffer))) return -EFAULT; msg_type = msm_mctl_pp_path_to_msg_type(pp_buffer.path); buf = msm_mctl_get_free_buf(p_mctl, msg_type); pp_buffer.buf_handle = (uint32_t)buf; if (copy_to_user((void *)argp, &pp_buffer, sizeof(struct msm_mctl_pp_frame_buffer))) { ERR_COPY_TO_USER(); rc = -EFAULT; } break; } case MCTL_CMD_PUT_FRAME_BUFFER: { if (copy_from_user(&pp_buffer, pp_cmd->value, sizeof(pp_buffer))) return -EFAULT; msg_type = msm_mctl_pp_path_to_msg_type(pp_buffer.path); buf = (struct msm_frame_buffer *)pp_buffer.buf_handle; msm_mctl_put_free_buf(p_mctl, msg_type, buf); break; } case MCTL_CMD_DIVERT_FRAME_PP_PATH: { struct msm_mctl_pp_divert_pp divert_pp; if (copy_from_user(&divert_pp, pp_cmd->value, sizeof(divert_pp))) return -EFAULT; D("%s: PP_PATH, path=%d", __func__, divert_pp.path); spin_lock_irqsave(&p_mctl->pp_info.lock, flags); if (divert_pp.enable) p_mctl->pp_info.pp_ctrl.pp_msg_type |= divert_pp.path; else p_mctl->pp_info.pp_ctrl.pp_msg_type &= ~divert_pp.path; spin_unlock_irqrestore(&p_mctl->pp_info.lock, flags); D("%s: pp path = 0x%x", __func__, p_mctl->pp_info.pp_ctrl.pp_msg_type); break; } default: rc = -EPERM; break; } return rc; }
int msm_mctl_pp_reserve_free_frame( struct msm_cam_media_controller *p_mctl, void __user *arg) { struct msm_cam_evt_divert_frame frame; int msg_type, image_mode, rc = 0; struct msm_free_buf free_buf; int idx; struct msm_cam_v4l2_dev_inst *pcam_inst; memset(&free_buf, 0, sizeof(struct msm_free_buf)); if (copy_from_user(&frame, arg, sizeof(struct msm_cam_evt_divert_frame))) return -EFAULT; switch (frame.frame.path) { case OUTPUT_TYPE_P: msg_type = VFE_MSG_OUTPUT_P; image_mode = MSM_V4L2_EXT_CAPTURE_MODE_PREVIEW; break; case OUTPUT_TYPE_S: msg_type = VFE_MSG_OUTPUT_S; image_mode = MSM_V4L2_EXT_CAPTURE_MODE_MAIN; break; case OUTPUT_TYPE_V: msg_type = VFE_MSG_OUTPUT_V; image_mode = MSM_V4L2_EXT_CAPTURE_MODE_VIDEO; break; case OUTPUT_TYPE_T: default: rc = -EFAULT; return rc; } idx = msm_mctl_out_type_to_inst_index( p_mctl->sync.pcam_sync, msg_type); if (idx < 0) { pr_err("%s Invalid instance. returning\n", __func__); return -EINVAL; } pcam_inst = p_mctl->sync.pcam_sync->dev_inst[idx]; rc = msm_mctl_reserve_free_buf(p_mctl, msg_type, &free_buf); if (rc == 0) { msm_mctl_pp_get_phy_addr(pcam_inst, free_buf.vb, &frame.frame); if (copy_to_user((void *)arg, &frame, sizeof(frame))) { ERR_COPY_TO_USER(); rc = -EFAULT; } } D("%s: reserve free buf, rc = %d, phy = 0x%x", __func__, rc, free_buf.ch_paddr[0]); return rc; }
int msm_mctl_pp_reserve_free_frame( struct msm_cam_media_controller *p_mctl, void __user *arg) { struct msm_cam_evt_divert_frame frame; int msg_type, image_mode, rc = 0; struct msm_free_buf free_buf; memset(&free_buf, 0, sizeof(struct msm_free_buf)); if (copy_from_user(&frame, arg, sizeof(struct msm_cam_evt_divert_frame))) return -EFAULT; switch (frame.frame.path) { case OUTPUT_TYPE_P: msg_type = VFE_MSG_OUTPUT_P; image_mode = MSM_V4L2_EXT_CAPTURE_MODE_PREVIEW; break; case OUTPUT_TYPE_S: msg_type = VFE_MSG_OUTPUT_S; image_mode = MSM_V4L2_EXT_CAPTURE_MODE_MAIN; break; case OUTPUT_TYPE_V: msg_type = VFE_MSG_OUTPUT_V; image_mode = MSM_V4L2_EXT_CAPTURE_MODE_VIDEO; break; case OUTPUT_TYPE_T: default: rc = -EFAULT; return rc; } rc = msm_mctl_reserve_free_buf(p_mctl, msg_type, &free_buf); if (rc == 0) { frame.frame.sp.phy_addr = free_buf.ch_paddr[0]; frame.frame.handle = free_buf.vb; if (copy_to_user((void *)arg, &frame, sizeof(frame))) { ERR_COPY_TO_USER(); rc = -EFAULT; } } D("%s: reserve free buf, rc = %d, phy = 0x%x", __func__, rc, free_buf.ch_paddr[0]); return rc; }
static int acoustic_get_capabilities(void __user *arg) { int rc = 0; struct msm_acoustic_capabilities capabilities = {}; capabilities.voc_cal_field_size = amss_data->voc_cal_field_size; if (htc_acoustic_wce_board_data) { capabilities.dual_mic_supported = htc_acoustic_wce_board_data->dual_mic_supported; } if (copy_to_user((void __user *)arg, &capabilities, sizeof(struct msm_acoustic_capabilities)) ) { ERR_COPY_TO_USER(); rc = -EFAULT; } return rc; }
int msm_mctl_pp_proc_vpe_cmd( struct msm_cam_media_controller *p_mctl, struct msm_mctl_pp_cmd *pp_cmd) { int rc = 0, idx; void __user *argp = (void __user *)pp_cmd->value; struct msm_cam_v4l2_dev_inst *pcam_inst; switch (pp_cmd->id) { case VPE_CMD_INIT: case VPE_CMD_DEINIT: rc = msm_isp_subdev_ioctl_vpe( p_mctl->isp_sdev->sd_vpe, pp_cmd, NULL); break; case VPE_CMD_DISABLE: case VPE_CMD_RESET: rc = msm_isp_subdev_ioctl_vpe( p_mctl->isp_sdev->sd_vpe, pp_cmd, NULL); break; case VPE_CMD_ENABLE: { struct msm_vpe_clock_rate clk_rate; if (sizeof(struct msm_vpe_clock_rate) != pp_cmd->length) { D("%s: vpe cmd size mismatch " "(id=%d, length = %d, expect size = %d", __func__, pp_cmd->id, pp_cmd->length, sizeof(struct msm_vpe_clock_rate)); rc = -EINVAL; break; } if (copy_from_user(&clk_rate, pp_cmd->value, sizeof(struct msm_vpe_clock_rate))) { D("%s:clk_rate copy failed", __func__); return -EFAULT; } pp_cmd->value = (void *)&clk_rate; rc = msm_isp_subdev_ioctl_vpe( p_mctl->isp_sdev->sd_vpe, pp_cmd, NULL); pp_cmd->value = argp; break; } case VPE_CMD_FLUSH: { struct msm_vpe_flush_frame_buffer flush_buf; if (sizeof(struct msm_vpe_flush_frame_buffer) != pp_cmd->length) { D("%s: size mismatch(id=%d, len = %d, expected = %d", __func__, pp_cmd->id, pp_cmd->length, sizeof(struct msm_vpe_flush_frame_buffer)); rc = -EINVAL; break; } if (copy_from_user( &flush_buf, pp_cmd->value, sizeof(flush_buf))) return -EFAULT; pp_cmd->value = (void *)&flush_buf; rc = msm_isp_subdev_ioctl_vpe( p_mctl->isp_sdev->sd_vpe, pp_cmd, NULL); if (rc == 0) { if (copy_to_user((void *)argp, &flush_buf, sizeof(flush_buf))) { ERR_COPY_TO_USER(); rc = -EFAULT; } pp_cmd->value = argp; } } break; case VPE_CMD_OPERATION_MODE_CFG: { struct msm_vpe_op_mode_cfg_zsl op_mode_cfg; if (sizeof(struct msm_vpe_op_mode_cfg_zsl) != pp_cmd->length) { D("%s: size mismatch(id=%d, len = %d, expected = %d", __func__, pp_cmd->id, pp_cmd->length, sizeof(struct msm_vpe_op_mode_cfg_zsl)); rc = -EINVAL; break; } if (copy_from_user(&op_mode_cfg, pp_cmd->value, sizeof(op_mode_cfg))) return -EFAULT; pp_cmd->value = (void *)&op_mode_cfg; rc = msm_isp_subdev_ioctl_vpe( p_mctl->isp_sdev->sd_vpe, pp_cmd, NULL); break; } case VPE_CMD_INPUT_PLANE_CFG: { struct msm_vpe_input_plane_cfg input_cfg; if (sizeof(struct msm_vpe_input_plane_cfg) != pp_cmd->length) { D("%s: mismatch(id=%d, len = %d, expected = %d", __func__, pp_cmd->id, pp_cmd->length, sizeof(struct msm_vpe_input_plane_cfg)); rc = -EINVAL; break; } if (copy_from_user( &input_cfg, pp_cmd->value, sizeof(input_cfg))) return -EFAULT; pp_cmd->value = (void *)&input_cfg; rc = msm_isp_subdev_ioctl_vpe( p_mctl->isp_sdev->sd_vpe, pp_cmd, NULL); break; } case VPE_CMD_OUTPUT_PLANE_CFG: { struct msm_vpe_output_plane_cfg_zsl output_cfg; if (sizeof(struct msm_vpe_output_plane_cfg_zsl) != pp_cmd->length) { D("%s: size mismatch(id=%d, len = %d, expected = %d", __func__, pp_cmd->id, pp_cmd->length, sizeof(struct msm_vpe_output_plane_cfg_zsl)); rc = -EINVAL; break; } if (copy_from_user(&output_cfg, pp_cmd->value, sizeof(output_cfg))) { D("%s: cannot copy pp_cmd->value, size=%d", __func__, pp_cmd->length); return -EFAULT; } pp_cmd->value = (void *)&output_cfg; rc = msm_isp_subdev_ioctl_vpe( p_mctl->isp_sdev->sd_vpe, pp_cmd, NULL); break; } case VPE_CMD_INPUT_PLANE_UPDATE: { struct msm_vpe_input_plane_update_cfg input_update_cfg; if (sizeof(struct msm_vpe_input_plane_update_cfg) != pp_cmd->length) { D("%s: size mismatch(id=%d, len = %d, expected = %d", __func__, pp_cmd->id, pp_cmd->length, sizeof(struct msm_vpe_input_plane_update_cfg)); rc = -EINVAL; break; } if (copy_from_user(&input_update_cfg, pp_cmd->value, sizeof(input_update_cfg))) return -EFAULT; pp_cmd->value = (void *)&input_update_cfg; rc = msm_isp_subdev_ioctl_vpe( p_mctl->isp_sdev->sd_vpe, pp_cmd, NULL); break; } case VPE_CMD_SCALE_CFG_TYPE: { struct msm_vpe_scaler_cfg scaler_cfg; if (sizeof(struct msm_vpe_scaler_cfg) != pp_cmd->length) { D("%s: size mismatch(id=%d, len = %d, expected = %d", __func__, pp_cmd->id, pp_cmd->length, sizeof(struct msm_vpe_scaler_cfg)); rc = -EINVAL; break; } if (copy_from_user(&scaler_cfg, pp_cmd->value, sizeof(scaler_cfg))) return -EFAULT; pp_cmd->value = (void *)&scaler_cfg; rc = msm_isp_subdev_ioctl_vpe( p_mctl->isp_sdev->sd_vpe, pp_cmd, NULL); break; } case VPE_CMD_ZOOM: { struct msm_mctl_pp_frame_info *zoom; zoom = kmalloc(sizeof(struct msm_mctl_pp_frame_info), GFP_ATOMIC); if (!zoom) { rc = -ENOMEM; break; } if (sizeof(zoom->pp_frame_cmd) != pp_cmd->length) { D("%s: size mismatch(id=%d, len = %d, expected = %d", __func__, pp_cmd->id, pp_cmd->length, sizeof(zoom->pp_frame_cmd)); rc = -EINVAL; kfree(zoom); break; } if (copy_from_user(&zoom->pp_frame_cmd, pp_cmd->value, sizeof(zoom->pp_frame_cmd))) { kfree(zoom); return -EFAULT; } D("%s: src=0x%x, dest=0x%x,cookie=0x%x,action=0x%x,path=0x%x", __func__, zoom->pp_frame_cmd.src_buf_handle, zoom->pp_frame_cmd.dest_buf_handle, zoom->pp_frame_cmd.cookie, zoom->pp_frame_cmd.vpe_output_action, zoom->pp_frame_cmd.path); idx = msm_mctl_pp_path_to_inst_index(p_mctl->sync.pcam_sync, zoom->pp_frame_cmd.path); if (idx < 0) { pr_err("%s Invalid path, returning\n", __func__); kfree(zoom); return idx; } pcam_inst = p_mctl->sync.pcam_sync->dev_inst[idx]; if (!pcam_inst) { pr_err("%s Invalid instance, returning\n", __func__); kfree(zoom); return -EINVAL; } zoom->user_cmd = pp_cmd->id; rc = msm_mctl_pp_get_phy_addr(pcam_inst, zoom->pp_frame_cmd.src_buf_handle, &zoom->src_frame); if (rc) { kfree(zoom); break; } rc = msm_mctl_pp_get_phy_addr(pcam_inst, zoom->pp_frame_cmd.dest_buf_handle, &zoom->dest_frame); if (rc) { kfree(zoom); break; } rc = msm_mctl_pp_copy_timestamp_and_frame_id( zoom->pp_frame_cmd.src_buf_handle, zoom->pp_frame_cmd.dest_buf_handle); if (rc) { kfree(zoom); break; } rc = msm_isp_subdev_ioctl_vpe( p_mctl->isp_sdev->sd_vpe, pp_cmd, (void *)zoom); if (rc) { kfree(zoom); break; } break; } default: rc = -1; break; } return rc; }