自学教程：C++ ERR_COPY_FROM_USER函数代码示例

static int msm_set_crop(struct msm_sync *sync, void __user *arg){	struct crop_info crop;	if (copy_from_user(&crop,				arg,				sizeof(struct crop_info))) {		ERR_COPY_FROM_USER();		return -EFAULT;	}	if (!sync->croplen) {		sync->cropinfo = kmalloc(crop.len, GFP_KERNEL);		if (!sync->cropinfo)			return -ENOMEM;	} else if (sync->croplen < crop.len)		return -EINVAL;	if (copy_from_user(sync->cropinfo,				crop.info,				crop.len)) {		ERR_COPY_FROM_USER();		kfree(sync->cropinfo);		return -EFAULT;	}	sync->croplen = crop.len;	return 0;}

static int update_hw_audio_path(void __user *arg){	struct msm_audio_path audio_path;	if (copy_from_user(&audio_path, arg, sizeof(audio_path))) {		ERR_COPY_FROM_USER();		return -EFAULT;	}	D("%s: mic=%d, dual_mic=%d, speaker=%d, headset = %d/n",			__func__,	       audio_path.enable_mic, audio_path.enable_dual_mic,	       audio_path.enable_speaker, audio_path.enable_headset);	/* Switch microphone on/off */	turn_mic_bias_on_internal(audio_path.enable_mic,                     audio_path.enable_dual_mic);	/* Switch headset HW on/off */	headphone_amp_power(audio_path.enable_headset);	/* Switch Speaker HW on/off */	speaker_amp_power(audio_path.enable_speaker);	return 0;}

static int msm_axi_config(struct v4l2_subdev *sd,		struct msm_cam_media_controller *mctl, void __user *arg){	struct msm_vfe_cfg_cmd cfgcmd;	if (copy_from_user(&cfgcmd, arg, sizeof(cfgcmd))) {		ERR_COPY_FROM_USER();		return -EFAULT;	}	switch (cfgcmd.cmd_type) {	case CMD_AXI_CFG_PRIM:	case CMD_AXI_CFG_SEC:	case CMD_AXI_CFG_ZSL:	case CMD_RAW_PICT_AXI_CFG:	case CMD_AXI_CFG_PRIM_ALL_CHNLS:	case CMD_AXI_CFG_PRIM|CMD_AXI_CFG_SEC:	case CMD_AXI_CFG_PRIM|CMD_AXI_CFG_SEC_ALL_CHNLS:	case CMD_AXI_CFG_PRIM_ALL_CHNLS|CMD_AXI_CFG_SEC:		return msm_isp_subdev_ioctl(sd, &cfgcmd, NULL);	default:		pr_err("%s: unknown command type %d/n",			__func__,			cfgcmd.cmd_type);		return -EINVAL;	}	return 0;}

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;}

static int update_codec_table(void __user * arg){	struct msm_dex_command dex = {		.cmd = PCOM_UPDATE_AUDIO,		.has_data = 1,		.data = DEX_UPDATE_VOC,	};	struct htc_voc_cal_table table;	uint16_t *table_array;	int rc = -EIO;	if (copy_from_user(&table, arg, sizeof(table))) {		ERR_COPY_FROM_USER();		return -EFAULT;	} else {		D("%s : table size = %d/n", __func__, table.size);		table_array = kmalloc(table.size, GFP_ATOMIC);		if (table_array != NULL) {			if (copy_from_user			    (table_array, table.pArray, table.size)) {				ERR_COPY_FROM_USER();				rc = -EFAULT;				goto free_exit;			}            memcpy(amss_data->codec_table, table_array, table.size);	        msm_proc_comm_wince(&dex,0);			rc = 0;		}	} free_exit:	if (table_array != NULL) {		kfree(table_array);	}	return rc;}/* Adie updates */static void ADIE_Force8k(bool bOn) {    int adie = readl(MSM_SHARED_RAM_BASE + 0xfc0d0);    if (bOn) {        adie |= 0x1;    } else {        adie &= ~0x1;    }    writel(adie, MSM_SHARED_RAM_BASE + 0xfc0d0);}

long msm_irqrouter_subdev_ioctl(struct v4l2_subdev *sd,	unsigned int cmd, void *arg){	struct irqrouter_ctrl_type *irqrouter_ctrl = v4l2_get_subdevdata(sd);	struct msm_camera_irq_cfg *irq_cfg;	struct intr_table_entry irq_req;	int rc = 0;	/* Handle all IRQ Router Subdev IOCTLs here.	 * Userspace sends the composite irq configuration.	 * IRQ Router subdev then configures the registers to group	 * together individual core hw irqs into a composite IRQ	 * to the MSM IRQ controller. It also registers them with	 * the irq manager in the camera server. */	switch (cmd) {	case MSM_IRQROUTER_CFG_COMPIRQ:		COPY_FROM_USER(rc, &irq_cfg, (void __user *)arg,			sizeof(struct msm_camera_irq_cfg));		if (rc) {			ERR_COPY_FROM_USER();			break;		}		if (!irq_cfg ||			(irq_cfg->irq_idx < CAMERA_SS_IRQ_0) ||			(irq_cfg->irq_idx >= CAMERA_SS_IRQ_MAX)) {			pr_err("%s Invalid input", __func__);			return -EINVAL;		} else {			irq_req.cam_hw_mask      = irq_cfg->cam_hw_mask;			irq_req.irq_idx          = irq_cfg->irq_idx;			irq_req.irq_num          =			irqrouter_ctrl->def_hw_irqmap[irq_cfg->irq_idx].irq_num;			irq_req.is_composite     = 1;			irq_req.irq_trigger_type = IRQF_TRIGGER_RISING;			irq_req.num_hwcore       = irq_cfg->num_hwcore;			irq_req.data             = NULL;			rc = msm_cam_server_request_irq(&irq_req);			if (rc < 0) {				pr_err("%s Error requesting comp irq %d ",					__func__, irq_req.irq_idx);				return rc;			}			irqrouter_ctrl->def_hw_irqmap				[irq_cfg->irq_idx].is_composite = 1;		}		break;	default:		pr_err("%s Invalid cmd %d ", __func__, cmd);		break;	}	return rc;}

static int update_audio_adie_table(void __user *arg){	struct adie_table table;	char pcArray[0x80];	int rc = -EIO;	if (copy_from_user(&table, arg, sizeof(table))) {		ERR_COPY_FROM_USER();		return -EFAULT;	} else {		if (copy_from_user(pcArray, table.pcArray, 0x80)) {			ERR_COPY_FROM_USER();			return -EFAULT;		}		memcpy((amss_data->adie_table +				(table.table_num * 0x80)), pcArray, 0x80);		rc = 0;	}	return rc;}

static int update_wb_volume_table(void __user *arg){	uint16_t wb_table[0xCD];	if (copy_from_user(&wb_table, arg, sizeof(wb_table))) {		ERR_COPY_FROM_USER();		return -EFAULT;	} else {		memcpy(amss_data->wb_volume_table, wb_table, sizeof(wb_table));	}	return 0;}

static int update_ce_table(void __user *arg){	uint16_t table[0x50];	if (copy_from_user(&table, arg, sizeof(table))) {		ERR_COPY_FROM_USER();		return -EFAULT;	} else {		memcpy(amss_data->ce_table, table, sizeof(table));	}	return 0;}

static int msm_set_dropframe_num(struct v4l2_subdev *sd,			struct msm_cam_media_controller *pmctl, void __user *arg){	int snap_dropframe_num;	if (copy_from_user(&snap_dropframe_num, arg, sizeof(snap_dropframe_num))) {		ERR_COPY_FROM_USER();		return -EFAULT;	} else {		atomic_set(&pmctl->snap_dropframe_num, snap_dropframe_num);		pr_info("%s: set snap_dropframe_num %d", __func__, atomic_read(&pmctl->snap_dropframe_num));	}	return 0;}

static int msm_axi_config(struct v4l2_subdev *sd,			struct msm_sync *sync, void __user *arg){	struct msm_vfe_cfg_cmd cfgcmd;	if (copy_from_user(&cfgcmd, arg, sizeof(cfgcmd))) {		ERR_COPY_FROM_USER();		return -EFAULT;	}	switch (cfgcmd.cmd_type) {	case CMD_AXI_CFG_VIDEO:	case CMD_AXI_CFG_PREVIEW:	case CMD_AXI_CFG_SNAP:	case CMD_AXI_CFG_ZSL:	case CMD_AXI_CFG_VIDEO_ALL_CHNLS:	case CMD_AXI_CFG_ZSL_ALL_CHNLS:	case CMD_RAW_PICT_AXI_CFG:	case CMD_AXI_CFG_PRIM:	case CMD_AXI_CFG_PRIM_ALL_CHNLS:	case CMD_AXI_CFG_PRIM|CMD_AXI_CFG_SEC:	case CMD_AXI_CFG_PRIM|CMD_AXI_CFG_SEC_ALL_CHNLS:	case CMD_AXI_CFG_PRIM_ALL_CHNLS|CMD_AXI_CFG_SEC:		/* Dont need to pass buffer information.		 * subdev will get the buffer from media		 * controller free queue.		 */		return msm_isp_subdev_ioctl(sd, &cfgcmd, NULL);	case CMD_AXI_CFG_VPE:		return 0;		return msm_vpe_frame_cfg(sync, (void *)&cfgcmd);	case CMD_STATS_AXI_CFG:	case CMD_STATS_AF_AXI_CFG:		return msm_stats_axi_cfg(sd, sync, &cfgcmd);	default:		pr_err("%s: unknown command type %d/n",			__func__,			cfgcmd.cmd_type);		return -EINVAL;	}	return 0;}

static int msm_enable_dropframe(struct v4l2_subdev *sd,			struct msm_cam_media_controller *pmctl, void __user *arg){	int dropframe_enabled;	if (copy_from_user(&dropframe_enabled, arg, sizeof(dropframe_enabled))) {		ERR_COPY_FROM_USER();		return -EFAULT;	} else {		atomic_set(&pmctl->dropframe_enabled, dropframe_enabled);		pr_info("%s: set dropframe_enabled %d", __func__, atomic_read(&pmctl->dropframe_enabled));				if (!dropframe_enabled)			atomic_set(&pmctl->snap_dropframe_num, 0);	}	return 0;}

static int dex_update_audio(int data){	struct msm_dex_command dex = {		.cmd = DEX_UPDATE_AUDIO,		.has_data = 1,		.data = data,	};	msm_dex_comm(&dex, 0);	return 0;}static int dex_update_audio_done(void) {	struct msm_dex_command dex = {		.cmd = DEX_UPDATE_AUDIO,		.has_data = 1,		.data = DEX_AUDIO_DONE,	};	D("%s/n", __func__);	return msm_dex_comm(&dex, 0);}static int update_audio_setting(void __user *arg){    int ret = -EFAULT;    struct audio_update_req req;	if (copy_from_user(&req, arg, sizeof(struct audio_update_req))) {		ERR_COPY_FROM_USER();		return -EFAULT;	} else {        switch (req.type) {            case PCOM_UPDATE_REQ:                ret = dex_update_audio(req.value);            break;            case ADIE_FORCE8K_REQ:                ADIE_Force8k( (req.value)?true:false );                ret = 0;            break;            case ADIE_FORCE_ADIE_AWAKE_REQ:                ADIE_ForceADIEAwake( (req.value)?true:false );                ret = 0;            break;            case ADIE_FORCE_ADIE_UPDATE_REQ:                ADIE_ForceADIEUpdate( (req.value)?true:false );                ret = 0;            break;            case ADIE_UPDATE_AUDIO_METHOD:                ADIE_UpdateAudioMethod( (req.value)?true:false );                ret = 0;            break;            default:            break;        }    }    return ret;}static int turn_mic_bias_on(bool on, bool enable_dualmic){	D("%s(%d)/n", __func__, on);	/* enable handset mic */	writel(0xffff0080 | (on ? 0x100 : 0), amss_data->mic_offset);	dex_update_audio_done();	if (amss_data->mic_bias_callback)		amss_data->mic_bias_callback(on, enable_dualmic);	return 0;}

static int dex_update_audio(int data){	struct msm_dex_command dex = {		.cmd = PCOM_UPDATE_AUDIO,		.has_data = 1,		.data = data,	};	msm_proc_comm_wince(&dex, 0);	return 0;}static int dex_update_audio_done(void) {	struct msm_dex_command dex = {		.cmd = PCOM_UPDATE_AUDIO,		.has_data = 1,		.data = DEX_AUDIO_DONE,	};	D("%s/n", __func__);	return msm_proc_comm_wince(&dex, 0);}static int update_audio_setting(void __user *arg){    int ret = -EFAULT;    struct audio_update_req req;	if (copy_from_user(&req, arg, sizeof(struct audio_update_req))) {		ERR_COPY_FROM_USER();		return -EFAULT;	} else {        switch (req.type) {            case PCOM_UPDATE_REQ:                ret = dex_update_audio(req.value);            break;            case ADIE_FORCE8K_REQ:                ADIE_Force8k( (req.value)?true:false );                ret = 0;            break;            case ADIE_FORCE_ADIE_AWAKE_REQ:                ADIE_ForceADIEAwake( (req.value)?true:false );                ret = 0;            break;            case ADIE_FORCE_ADIE_UPDATE_REQ:                ADIE_ForceADIEUpdate( (req.value)?true:false );                ret = 0;            break;            case ADIE_UPDATE_AUDIO_METHOD:                ADIE_UpdateAudioMethod( (req.value)?true:false );                ret = 0;            break;            default:            break;        }    }    return ret;}static int turn_mic_bias_on_internal(bool on, bool bDualMicEn){	char pmSpeakerGain[2][10] = { 			{0x93, 0, 0x93, 7, 0x93, 1, 0x93, 7, 0xFF, 0xFF},			{0x93, 0, 0x93, 4, 0x93, 1, 0x93, 4, 0xFF, 0xFF} };	D("%s(%d)/n", __func__, on);	/* enable handset mic *//* r0bin: photon doesnt have mic offset, or at least it wasnt found yet.  * uncomment those line is safe, we enable mic with pmic_en below *	if ( machine_is_htcrhodium() && bDualMicEn && on ) {		memcpy(amss_data->mic_offset, pmSpeakerGain[1], 10);	} else {		writel(0xffff0080 | (on ? 0x100 : 0), amss_data->mic_offset);   	}	dex_update_audio_done();	if ( machine_is_htcrhodium() ) {		if ( bDualMicEn && on ) {			ADC3001_wakeup();		} else {			ADC3001_powerdown();		}	}*/	if (amss_data->mic_bias_callback)		amss_data->mic_bias_callback(on);	dex_update_audio_done();		return 0;}

static int dex_update_audio(int data){	struct msm_dex_command dex = {		.cmd = PCOM_UPDATE_AUDIO,		.has_data = 1,		.data = data,	};	msm_proc_comm_wince(&dex, 0);	return 0;}static int dex_update_audio_done(void) {	struct msm_dex_command dex = {		.cmd = PCOM_UPDATE_AUDIO,		.has_data = 1,		.data = DEX_AUDIO_DONE,	};	D("%s/n", __func__);	return msm_proc_comm_wince(&dex, 0);}static int update_audio_setting(void __user *arg){    int ret = -EFAULT;    struct audio_update_req req;	if (copy_from_user(&req, arg, sizeof(struct audio_update_req))) {		ERR_COPY_FROM_USER();		return -EFAULT;	} else {        switch (req.type) {            case PCOM_UPDATE_REQ:                ret = dex_update_audio(req.value);            break;            case ADIE_FORCE8K_REQ:                ADIE_Force8k( (req.value)?true:false );                ret = 0;            break;            case ADIE_FORCE_ADIE_AWAKE_REQ:                ADIE_ForceADIEAwake( (req.value)?true:false );                ret = 0;            break;            case ADIE_FORCE_ADIE_UPDATE_REQ:                ADIE_ForceADIEUpdate( (req.value)?true:false );                ret = 0;            break;            case ADIE_UPDATE_AUDIO_METHOD:                ADIE_UpdateAudioMethod( (req.value)?true:false );                ret = 0;            break;            default:            break;        }    }    return ret;}static int turn_mic_bias_on_internal(bool on, bool bDualMicEn){	if (amss_data->mic_bias_callback)		amss_data->mic_bias_callback(on);	dex_update_audio_done();		return 0;}int turn_mic_bias_on(bool on){	return turn_mic_bias_on_internal(on, false);}EXPORT_SYMBOL(turn_mic_bias_on);static int update_hw_audio_path(void __user *arg){	struct msm_audio_path audio_path;	if (copy_from_user(&audio_path, arg, sizeof(audio_path))) {		ERR_COPY_FROM_USER();		return -EFAULT;	}	D("%s: mic=%d, dual_mic=%d, speaker=%d, headset = %d/n",			__func__,	       audio_path.enable_mic, audio_path.enable_dual_mic,	       audio_path.enable_speaker, audio_path.enable_headset);	/* Switch microphone on/off */	turn_mic_bias_on_internal(audio_path.enable_mic,                     audio_path.enable_dual_mic);	/* Switch headset HW on/off */	headphone_amp_power(audio_path.enable_headset);//.........这里部分代码省略.........

static int msm_vpe_process_vpe_cmd(struct msm_vpe_cfg_cmd *vpe_cmd){	int rc = 0;	switch (vpe_cmd->cmd_type) {	case VPE_CMD_RESET:		rc = vpe_reset();		break;	case VPE_CMD_OPERATION_MODE_CFG: {		struct msm_vpe_op_mode_cfg op_mode_cfg;		if (sizeof(struct msm_vpe_op_mode_cfg) != vpe_cmd->length) {			pr_err("%s: size mismatch cmd=%d, len=%d, expected=%d",				__func__, vpe_cmd->cmd_type, vpe_cmd->length,				sizeof(struct msm_vpe_op_mode_cfg));			rc = -EINVAL;			break;		}		COPY_FROM_USER(rc, &op_mode_cfg, (void __user *)vpe_cmd->value,			sizeof(op_mode_cfg));		if (rc) {			ERR_COPY_FROM_USER();			break;		}		vpe_cmd->value = (void *)&op_mode_cfg;		rc = vpe_operation_config(vpe_cmd->value);		break;		}	case VPE_CMD_INPUT_PLANE_CFG: {		struct msm_vpe_input_plane_cfg input_cfg;		if (sizeof(struct msm_vpe_input_plane_cfg) != vpe_cmd->length) {			pr_err("%s: mismatch cmd = %d, len = %d, expected = %d",				__func__, vpe_cmd->cmd_type, vpe_cmd->length,				sizeof(struct msm_vpe_input_plane_cfg));			rc = -EINVAL;			break;		}		COPY_FROM_USER(rc, &input_cfg, (void __user *)vpe_cmd->value,			sizeof(input_cfg));		if (rc) {			ERR_COPY_FROM_USER();			break;		}		vpe_cmd->value = (void *)&input_cfg;		vpe_input_plane_config(vpe_cmd->value);		break;		}	case VPE_CMD_OUTPUT_PLANE_CFG: {		struct msm_vpe_output_plane_cfg output_cfg;		if (sizeof(struct msm_vpe_output_plane_cfg) !=			vpe_cmd->length) {			pr_err("%s: size mismatch cmd=%d, len=%d, expected=%d",				__func__, vpe_cmd->cmd_type, vpe_cmd->length,				sizeof(struct msm_vpe_output_plane_cfg));				rc = -EINVAL;				break;		}		COPY_FROM_USER(rc, &output_cfg, (void __user *)vpe_cmd->value,			sizeof(output_cfg));		if (rc) {			ERR_COPY_FROM_USER();			break;		}		vpe_cmd->value = (void *)&output_cfg;		vpe_output_plane_config(vpe_cmd->value);		break;		}	case VPE_CMD_SCALE_CFG_TYPE:{		struct msm_vpe_scaler_cfg scaler_cfg;		if (sizeof(struct msm_vpe_scaler_cfg) != vpe_cmd->length) {			pr_err("%s: size mismatch cmd=%d, len=%d, expected=%d",				__func__, vpe_cmd->cmd_type, vpe_cmd->length,				sizeof(struct msm_vpe_scaler_cfg));			rc = -EINVAL;			break;		}		COPY_FROM_USER(rc, &scaler_cfg, (void __user *)vpe_cmd->value,			sizeof(scaler_cfg));		if (rc) {			ERR_COPY_FROM_USER();			break;		}		vpe_cmd->value = (void *)&scaler_cfg;		vpe_update_scale_coef(vpe_cmd->value);		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) {			pr_err("%s Not enough memory ", __func__);//.........这里部分代码省略.........

static int msm_axi_config(struct v4l2_subdev *sd, void __user *arg){	struct msm_vfe_cfg_cmd cfgcmd;	struct msm_isp_cmd vfecmd;	int rc = 0;	struct axi_ctrl_t *axi_ctrl = v4l2_get_subdevdata(sd);	if (!axi_ctrl->share_ctrl->vfebase) {		pr_err("%s: base address unmapped/n", __func__);		return -EFAULT;	}	if (NULL != arg) {		if (copy_from_user(&cfgcmd, arg, sizeof(cfgcmd))) {			ERR_COPY_FROM_USER();			return -EFAULT;		}	}	if (NULL != cfgcmd.value) {		if (copy_from_user(&vfecmd,				(void __user *)(cfgcmd.value),				sizeof(vfecmd))) {			pr_err("%s %d: copy_from_user failed/n", __func__,				__LINE__);			return -EFAULT;		}	}	switch (cfgcmd.cmd_type) {	case CMD_AXI_CFG_PRIM: {		uint32_t *axio = NULL;		axio = kmalloc(vfe40_cmd[VFE_CMD_AXI_OUT_CFG].length,				GFP_ATOMIC);		if (!axio) {			rc = -ENOMEM;			break;		}		if (copy_from_user(axio, (void __user *)(vfecmd.value),				vfe40_cmd[VFE_CMD_AXI_OUT_CFG].length)) {			kfree(axio);			rc = -EFAULT;			break;		}		vfe40_config_axi(axi_ctrl, OUTPUT_PRIM, axio);		kfree(axio);	}		break;	case CMD_AXI_CFG_PRIM_ALL_CHNLS: {		uint32_t *axio = NULL;		axio = kmalloc(vfe40_cmd[VFE_CMD_AXI_OUT_CFG].length,				GFP_ATOMIC);		if (!axio) {			rc = -ENOMEM;			break;		}		if (copy_from_user(axio, (void __user *)(vfecmd.value),				vfe40_cmd[VFE_CMD_AXI_OUT_CFG].length)) {			kfree(axio);			rc = -EFAULT;			break;		}		vfe40_config_axi(axi_ctrl, OUTPUT_PRIM_ALL_CHNLS, axio);		kfree(axio);	}		break;	case CMD_AXI_CFG_PRIM|CMD_AXI_CFG_SEC: {		uint32_t *axio = NULL;		axio = kmalloc(vfe40_cmd[VFE_CMD_AXI_OUT_CFG].length,				GFP_ATOMIC);		if (!axio) {			rc = -ENOMEM;			break;		}		if (copy_from_user(axio, (void __user *)(vfecmd.value),				vfe40_cmd[VFE_CMD_AXI_OUT_CFG].length)) {			kfree(axio);			rc = -EFAULT;			break;		}		vfe40_config_axi(axi_ctrl, OUTPUT_PRIM|OUTPUT_SEC, axio);		kfree(axio);	}		break;	case CMD_AXI_CFG_PRIM|CMD_AXI_CFG_SEC_ALL_CHNLS: {		uint32_t *axio = NULL;		axio = kmalloc(vfe40_cmd[VFE_CMD_AXI_OUT_CFG].length,				GFP_ATOMIC);		if (!axio) {			rc = -ENOMEM;			break;		}		if (copy_from_user(axio, (void __user *)(vfecmd.value),				vfe40_cmd[VFE_CMD_AXI_OUT_CFG].length)) {			kfree(axio);			rc = -EFAULT;			break;		}//.........这里部分代码省略.........

static int msm_config_vfe(struct v4l2_subdev *sd,	struct msm_cam_media_controller *mctl, void __user *arg){	struct msm_vfe_cfg_cmd cfgcmd;	struct msm_pmem_region region[8];	struct axidata axi_data;	if (copy_from_user(&cfgcmd, arg, sizeof(cfgcmd))) {		ERR_COPY_FROM_USER();		return -EFAULT;	}	memset(&axi_data, 0, sizeof(axi_data));	CDBG("%s: cmd_type %d/n", __func__, cfgcmd.cmd_type);	switch (cfgcmd.cmd_type) {	case CMD_STATS_BG_ENABLE:		axi_data.bufnum1 =			msm_pmem_region_lookup(				&mctl->stats_info.pmem_stats_list,				MSM_PMEM_BAYER_GRID, &region[0],				NUM_STAT_OUTPUT_BUFFERS);		if (!axi_data.bufnum1) {			pr_err("%s %d: pmem region lookup error/n",				__func__, __LINE__);			return -EINVAL;		}		axi_data.region = &region[0];		return msm_isp_subdev_ioctl(sd, &cfgcmd,							&axi_data);	case CMD_STATS_BF_ENABLE:		axi_data.bufnum1 =			msm_pmem_region_lookup(				&mctl->stats_info.pmem_stats_list,				MSM_PMEM_BAYER_FOCUS, &region[0],				NUM_STAT_OUTPUT_BUFFERS);		if (!axi_data.bufnum1) {			pr_err("%s %d: pmem region lookup error/n",				__func__, __LINE__);			return -EINVAL;		}		axi_data.region = &region[0];		return msm_isp_subdev_ioctl(sd, &cfgcmd,							&axi_data);	case CMD_STATS_BHIST_ENABLE:		axi_data.bufnum1 =			msm_pmem_region_lookup(				&mctl->stats_info.pmem_stats_list,				MSM_PMEM_BAYER_HIST, &region[0],				NUM_STAT_OUTPUT_BUFFERS);		if (!axi_data.bufnum1) {			pr_err("%s %d: pmem region lookup error/n",				__func__, __LINE__);			return -EINVAL;		}		axi_data.region = &region[0];		return msm_isp_subdev_ioctl(sd, &cfgcmd,							&axi_data);	case CMD_STATS_AF_ENABLE:		axi_data.bufnum1 =			msm_pmem_region_lookup(				&mctl->stats_info.pmem_stats_list,				MSM_PMEM_AF, &region[0],				NUM_STAT_OUTPUT_BUFFERS);		if (!axi_data.bufnum1) {			pr_err("%s %d: pmem region lookup error/n",				__func__, __LINE__);			return -EINVAL;		}		axi_data.region = &region[0];		return msm_isp_subdev_ioctl(sd, &cfgcmd,							&axi_data);	case CMD_STATS_AEC_ENABLE:		axi_data.bufnum1 =			msm_pmem_region_lookup(				&mctl->stats_info.pmem_stats_list,				MSM_PMEM_AEC, &region[0],				NUM_STAT_OUTPUT_BUFFERS);		if (!axi_data.bufnum1) {			pr_err("%s %d: pmem region lookup error/n",				__func__, __LINE__);			return -EINVAL;		}		axi_data.region = &region[0];		return msm_isp_subdev_ioctl(sd, &cfgcmd,							&axi_data);	case CMD_STATS_AWB_ENABLE:		axi_data.bufnum1 =			msm_pmem_region_lookup(				&mctl->stats_info.pmem_stats_list,				MSM_PMEM_AWB, &region[0],				NUM_STAT_OUTPUT_BUFFERS);		if (!axi_data.bufnum1) {			pr_err("%s %d: pmem region lookup error/n",				__func__, __LINE__);			return -EINVAL;		}		axi_data.region = &region[0];		return msm_isp_subdev_ioctl(sd, &cfgcmd,							&axi_data);	case CMD_STATS_AEC_AWB_ENABLE://.........这里部分代码省略.........

static int vfe_config(struct msm_vfe_cfg_cmd *cmd, void *data){	struct msm_pmem_region *regptr;	struct msm_vfe_command_8k vfecmd;	struct vfe_cmd_axi_output_config axio;	struct axidata *axid = data;	int rc = 0;	if (cmd->cmd_type != CMD_FRAME_BUF_RELEASE &&	    cmd->cmd_type != CMD_STATS_BUF_RELEASE &&	    cmd->cmd_type != CMD_STATS_AF_BUF_RELEASE) {		if (copy_from_user(&vfecmd,				   (void __user *)(cmd->value), sizeof(vfecmd))) {			ERR_COPY_FROM_USER();			return -EFAULT;		}	}	CDBG("%s: cmdType = %d/n", __func__, cmd->cmd_type);	switch (cmd->cmd_type) {	case CMD_GENERAL:		rc = vfe_proc_general(&vfecmd);		break;	case CMD_STATS_ENABLE:	case CMD_STATS_AXI_CFG: {			int i;			struct vfe_cmd_stats_setting scfg;			BUG_ON(!axid);			if (vfecmd.length != sizeof(scfg)) {				pr_err				    ("msm_camera: %s: cmd %d: user-space "/				     "data size %d != kernel data size %d/n",				     __func__,				     cmd->cmd_type, vfecmd.length,				     sizeof(scfg));				return -EIO;			}			if (copy_from_user(&scfg,					   (void __user *)(vfecmd.value),					   sizeof(scfg))) {				ERR_COPY_FROM_USER();				return -EFAULT;			}			regptr = axid->region;			if (axid->bufnum1 > 0) {				for (i = 0; i < axid->bufnum1; i++) {					scfg.awbBuffer[i] =					    (uint32_t) (regptr->paddr);					regptr++;				}			}			if (axid->bufnum2 > 0) {				for (i = 0; i < axid->bufnum2; i++) {					scfg.afBuffer[i] =					    (uint32_t) (regptr->paddr);					regptr++;				}			}			vfe_stats_setting(&scfg);		}		break;	case CMD_STATS_AF_AXI_CFG:		break;	case CMD_FRAME_BUF_RELEASE: {			/* preview buffer release */			struct msm_frame *b;			unsigned long p;			struct vfe_cmd_output_ack fack;			BUG_ON(!data);			b = (struct msm_frame *)(cmd->value);			p = *(unsigned long *)data;			b->path = MSM_FRAME_ENC;			fack.ybufaddr[0] = (uint32_t) (p + b->y_off);			fack.chromabufaddr[0] = (uint32_t) (p + b->cbcr_off);			if (b->path == MSM_FRAME_PREV_1)				vfe_output1_ack(&fack);			if (b->path == MSM_FRAME_ENC ||			    b->path == MSM_FRAME_PREV_2)				vfe_output2_ack(&fack);		}		break;//.........这里部分代码省略.........

/* called by the server or the config nodes to handle user space	commands*/static int msm_mctl_cmd(struct msm_cam_media_controller *p_mctl,			unsigned int cmd, unsigned long arg){	int rc = -EINVAL;	void __user *argp = (void __user *)arg;	if (!p_mctl) {		pr_err("%s: param is NULL", __func__);		return -EINVAL;	}	D("%s cmd = %d/n", __func__, _IOC_NR(cmd));	/* ... call sensor, ISPIF or VEF subdev*/	switch (cmd) {		/* sensor config*/	case MSM_CAM_IOCTL_GET_SENSOR_INFO:			rc = msm_get_sensor_info(&p_mctl->sync, argp);			break;	case MSM_CAM_IOCTL_SENSOR_IO_CFG:			rc = p_mctl->sync.sctrl.s_config(argp);			break;	case MSM_CAM_IOCTL_SENSOR_V4l2_S_CTRL: {			struct v4l2_control v4l2_ctrl;			CDBG("subdev call/n");			if (copy_from_user(&v4l2_ctrl,				(void *)argp,				sizeof(struct v4l2_control))) {				CDBG("copy fail/n");				return -EFAULT;			}			CDBG("subdev call ok/n");			rc = v4l2_subdev_call(p_mctl->sensor_sdev,				core, s_ctrl, &v4l2_ctrl);			break;	}	case MSM_CAM_IOCTL_SENSOR_V4l2_QUERY_CTRL: {			struct v4l2_queryctrl v4l2_qctrl;			CDBG("query called/n");			if (copy_from_user(&v4l2_qctrl,				(void *)argp,				sizeof(struct v4l2_queryctrl))) {				CDBG("copy fail/n");				rc = -EFAULT;				break;			}			rc = v4l2_subdev_call(p_mctl->sensor_sdev,				core, queryctrl, &v4l2_qctrl);			if (rc < 0) {				rc = -EFAULT;				break;			}			if (copy_to_user((void *)argp,					 &v4l2_qctrl,					 sizeof(struct v4l2_queryctrl))) {				rc = -EFAULT;			}			break;	}	case MSM_CAM_IOCTL_ACTUATOR_IO_CFG: {		struct msm_actuator_cfg_data act_data;		if (p_mctl->sync.actctrl.a_config) {			rc = p_mctl->sync.actctrl.a_config(argp);		} else {			rc = copy_from_user(				&act_data,				(void *)argp,				sizeof(struct msm_actuator_cfg_data));			if (rc != 0) {				rc = -EFAULT;				break;			}			act_data.is_af_supported = 0;			rc = copy_to_user((void *)argp,					 &act_data,					 sizeof(struct msm_actuator_cfg_data));			if (rc != 0) {				rc = -EFAULT;				break;			}		}		break;	}	case MSM_CAM_IOCTL_GET_KERNEL_SYSTEM_TIME: {		struct timeval timestamp;		if (copy_from_user(&timestamp, argp, sizeof(timestamp))) {			ERR_COPY_FROM_USER();			rc = -EFAULT;		} else {			msm_mctl_gettimeofday(&timestamp);			rc = copy_to_user((void *)argp,				 &timestamp, sizeof(timestamp));		}		break;	}//.........这里部分代码省略.........

static int msm_vpe_process_vpe_cmd(struct msm_vpe_cfg_cmd *vpe_cmd,				struct msm_cam_media_controller *mctl){	int rc = 0;	switch (vpe_cmd->cmd_type) {	case VPE_CMD_RESET:		rc = vpe_reset();		break;	case VPE_CMD_OPERATION_MODE_CFG: {		struct msm_vpe_op_mode_cfg op_mode_cfg;		if (sizeof(struct msm_vpe_op_mode_cfg) != vpe_cmd->length) {			pr_err("%s: size mismatch cmd=%d, len=%d, expected=%d",				__func__, vpe_cmd->cmd_type, vpe_cmd->length,				sizeof(struct msm_vpe_op_mode_cfg));			rc = -EINVAL;			break;		}		COPY_FROM_USER(rc, &op_mode_cfg, (void __user *)vpe_cmd->value,			sizeof(op_mode_cfg));		if (rc) {			ERR_COPY_FROM_USER();			break;		}		vpe_cmd->value = (void *)&op_mode_cfg;		rc = vpe_operation_config(vpe_cmd->value);		break;		}	case VPE_CMD_INPUT_PLANE_CFG: {		struct msm_vpe_input_plane_cfg input_cfg;		if (sizeof(struct msm_vpe_input_plane_cfg) != vpe_cmd->length) {			pr_err("%s: mismatch cmd = %d, len = %d, expected = %d",				__func__, vpe_cmd->cmd_type, vpe_cmd->length,				sizeof(struct msm_vpe_input_plane_cfg));			rc = -EINVAL;			break;		}		COPY_FROM_USER(rc, &input_cfg, (void __user *)vpe_cmd->value,			sizeof(input_cfg));		if (rc) {			ERR_COPY_FROM_USER();			break;		}		vpe_cmd->value = (void *)&input_cfg;		vpe_input_plane_config(vpe_cmd->value);		break;		}	case VPE_CMD_OUTPUT_PLANE_CFG: {		struct msm_vpe_output_plane_cfg output_cfg;		if (sizeof(struct msm_vpe_output_plane_cfg) !=			vpe_cmd->length) {			pr_err("%s: size mismatch cmd=%d, len=%d, expected=%d",				__func__, vpe_cmd->cmd_type, vpe_cmd->length,				sizeof(struct msm_vpe_output_plane_cfg));				rc = -EINVAL;				break;		}		COPY_FROM_USER(rc, &output_cfg, (void __user *)vpe_cmd->value,			sizeof(output_cfg));		if (rc) {			ERR_COPY_FROM_USER();			break;		}		vpe_cmd->value = (void *)&output_cfg;		vpe_output_plane_config(vpe_cmd->value);		break;		}	case VPE_CMD_SCALE_CFG_TYPE:{		struct msm_vpe_scaler_cfg scaler_cfg;		if (sizeof(struct msm_vpe_scaler_cfg) != vpe_cmd->length) {			pr_err("%s: size mismatch cmd=%d, len=%d, expected=%d",				__func__, vpe_cmd->cmd_type, vpe_cmd->length,				sizeof(struct msm_vpe_scaler_cfg));			rc = -EINVAL;			break;		}		COPY_FROM_USER(rc, &scaler_cfg, (void __user *)vpe_cmd->value,			sizeof(scaler_cfg));		if (rc) {			ERR_COPY_FROM_USER();			break;		}		vpe_cmd->value = (void *)&scaler_cfg;		vpe_update_scale_coef(vpe_cmd->value);		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) {//.........这里部分代码省略.........

long msm_cpp_subdev_ioctl(struct v4l2_subdev *sd,			unsigned int cmd, void *arg){	struct cpp_device *cpp_dev = v4l2_get_subdevdata(sd);	struct msm_camera_v4l2_ioctl_t *ioctl_ptr = arg;	int rc = 0;	CPP_DBG("%s: %d/n", __func__, __LINE__);	mutex_lock(&cpp_dev->mutex);	CPP_DBG("%s cmd: %d/n", __func__, cmd);	switch (cmd) {	case VIDIOC_MSM_CPP_CFG: {		struct msm_queue_cmd *frame_qcmd;		struct msm_cpp_frame_info_t *new_frame =			kzalloc(sizeof(struct msm_cpp_frame_info_t),					GFP_KERNEL);		if (!new_frame) {			pr_err("%s Insufficient memory. return", __func__);			mutex_unlock(&cpp_dev->mutex);			return -ENOMEM;		}		COPY_FROM_USER(rc, new_frame,			       (void __user *)ioctl_ptr->ioctl_ptr,			       sizeof(struct msm_cpp_frame_info_t));		if (rc) {			ERR_COPY_FROM_USER();			kfree(new_frame);			mutex_unlock(&cpp_dev->mutex);			return -EINVAL;		}		frame_qcmd = kzalloc(sizeof(struct msm_queue_cmd), GFP_KERNEL);		if (!frame_qcmd) {			pr_err("%s Insufficient memory. return", __func__);			kfree(new_frame);			mutex_unlock(&cpp_dev->mutex);			return -ENOMEM;		}		atomic_set(&frame_qcmd->on_heap, 1);		frame_qcmd->command = new_frame;		if (new_frame->frame_type == MSM_CPP_REALTIME_FRAME) {			msm_enqueue(&cpp_dev->realtime_q,						&frame_qcmd->list_frame);		} else if (new_frame->frame_type == MSM_CPP_OFFLINE_FRAME) {			msm_enqueue(&cpp_dev->offline_q,						&frame_qcmd->list_frame);		} else {			pr_err("%s: Invalid frame type/n", __func__);			kfree(new_frame);			kfree(frame_qcmd);			mutex_unlock(&cpp_dev->mutex);			return -EINVAL;		}		break;	}	case VIDIOC_MSM_CPP_GET_EVENTPAYLOAD: {		struct msm_device_queue *queue = &cpp_dev->eventData_q;		struct msm_queue_cmd *event_qcmd;		struct msm_cpp_frame_info_t *process_frame;		event_qcmd = msm_dequeue(queue, list_eventdata);		process_frame = event_qcmd->command;		CPP_DBG("fid %d/n", process_frame->frame_id);		if (copy_to_user((void __user *)ioctl_ptr->ioctl_ptr,				process_frame,				sizeof(struct msm_cpp_frame_info_t))) {					mutex_unlock(&cpp_dev->mutex);					return -EINVAL;		}		kfree(process_frame);		kfree(event_qcmd);		break;	}	}	mutex_unlock(&cpp_dev->mutex);	CPP_DBG("%s: %d/n", __func__, __LINE__);	return 0;}