Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 4b9f3e9d authored by qctecmdr's avatar qctecmdr Committed by Gerrit - the friendly Code Review server
Browse files

Merge "msm: cvp: Support CVP clock and b/w scaling"

parents b75c34b4 e1382742

drivers/media/platform/msm/cvp/cvp_hfi.c

+151 −21
Original line number Diff line number Diff line
@@ -214,6 +214,28 @@ const struct msm_cvp_hfi_defs cvp_hfi_defs[] = { 
		.buf_num = HFI_PYS_HCD_BUF_NUM,

		.resp = HAL_NO_RESP,

	},

	{

		.size = 0xFFFFFFFF,

		.type = HFI_CMD_SESSION_CVP_SET_MODEL_BUFFERS,

		.buf_offset = 0,

		.buf_num = 0,

		.resp = HAL_SESSION_MODEL_BUF_CMD_DONE,

	},

	{

		.size = 0xFFFFFFFF,

		.type = HFI_CMD_SESSION_CVP_FD_CONFIG,

		.buf_offset = 0,

		.buf_num = 0,

		.resp = HAL_SESSION_FD_CONFIG_CMD_DONE,

	},

	{

		.size = 0xFFFFFFFF,

		.type = HFI_CMD_SESSION_CVP_FD_FRAME,

		.buf_offset = 0,

		.buf_num = 0,

		.resp = HAL_NO_RESP,

	},



};



static struct cvp_hal_device_data hal_ctxt;
@@ -272,21 +294,22 @@ static int __disable_subcaches(struct iris_hfi_device *device); 
static int __power_collapse(struct iris_hfi_device *device, bool force);

static int venus_hfi_noc_error_info(void *dev);



static void interrupt_init_vpu5(struct iris_hfi_device *device);

static void interrupt_init_iris2(struct iris_hfi_device *device);

static void setup_dsp_uc_memmap_vpu5(struct iris_hfi_device *device);

static void clock_config_on_enable_vpu5(struct iris_hfi_device *device);

static int reset_ahb2axi_bridge(struct iris_hfi_device *device);

static void power_off_iris2(struct iris_hfi_device *device);



static int __set_ubwc_config(struct iris_hfi_device *device);

static void __noc_error_info_iris2(struct iris_hfi_device *device);



static struct iris_hfi_vpu_ops iris2_ops = {

	.interrupt_init = interrupt_init_vpu5,

	.interrupt_init = interrupt_init_iris2,

	.setup_dsp_uc_memmap = setup_dsp_uc_memmap_vpu5,

	.clock_config_on_enable = clock_config_on_enable_vpu5,

	.reset_ahb2axi_bridge = reset_ahb2axi_bridge,

	.power_off = power_off_iris2,

	.noc_error_info = NULL,

	.noc_error_info = __noc_error_info_iris2,

};



/**
@@ -1219,7 +1242,7 @@ static int __vote_buses(struct iris_hfi_device *device, 
			}

#else

			rc = msm_bus_scale_update_bw(bus->client,

				bus->range[1]*1000, 0);

				bus->range[1], 0);

			if (rc)

				dprintk(CVP_ERR,

				"Failed voting bus %s to ab %u\n",
@@ -2283,8 +2306,10 @@ static int venus_hfi_core_release(void *dev) 
	__unload_fw(device);



	/* unlink all sessions from device */

	list_for_each_entry_safe(session, next, &device->sess_head, list)

	list_for_each_entry_safe(session, next, &device->sess_head, list) {

		list_del(&session->list);

		session->device = NULL;

	}



	dprintk(CVP_DBG, "Core released successfully\n");

	mutex_unlock(&device->lock);
@@ -2330,14 +2355,13 @@ static void __core_clear_interrupt(struct iris_hfi_device *device) 
	}



	intr_status = __read_register(device, CVP_WRAPPER_INTR_STATUS);

	mask = (CVP_WRAPPER_INTR_STATUS_A2H_BMSK |

		CVP_WRAPPER_INTR_STATUS_A2HWD_BMSK);

	mask = (CVP_WRAPPER_INTR_MASK_A2HCPU_BMSK | CVP_FATAL_INTR_BMSK);



	if (intr_status & mask) {

		device->intr_status |= intr_status;

		device->reg_count++;

		dprintk(CVP_DBG,

			"INTERRUPT for device: %pK: times: %d interrupt_status: %d\n",

			"INTERRUPT for device: %pK: times: %d status: %d\n",

			device, device->reg_count, intr_status);

	} else {

		device->spur_count++;
@@ -2395,7 +2419,7 @@ static int venus_hfi_session_set_property(void *sess, 


	dprintk(CVP_INFO, "in set_prop,with prop id: %#x\n", ptype);

	if (!__is_session_valid(device, session, __func__)) {

		rc = -EINVAL;

		rc = -ECONNRESET;

		goto err_set_prop;

	}
@@ -2441,7 +2465,7 @@ static int venus_hfi_session_get_property(void *sess, 


	dprintk(CVP_INFO, "%s: property id: %d\n", __func__, ptype);

	if (!__is_session_valid(device, session, __func__)) {

		rc = -EINVAL;

		rc = -ECONNRESET;

		goto err_create_pkt;

	}
@@ -2584,7 +2608,7 @@ static int __send_session_cmd(struct cvp_hal_session *session, int pkt_type) 
	struct iris_hfi_device *device = session->device;



	if (!__is_session_valid(device, session, __func__))

		return -EINVAL;

		return -ECONNRESET;



	rc = call_hfi_pkt_op(device, session_cmd,

			&pkt, pkt_type, session);
@@ -2616,6 +2640,10 @@ static int venus_hfi_session_end(void *session) 


	sess = session;

	device = sess->device;

	if (!device) {

		dprintk(CVP_ERR, "Invalid session %s\n", __func__);

		return -EINVAL;

	}



	mutex_lock(&device->lock);
@@ -2671,7 +2699,7 @@ static int venus_hfi_session_set_buffers(void *sess, 
	mutex_lock(&device->lock);



	if (!__is_session_valid(device, session, __func__)) {

		rc = -EINVAL;

		rc = -ECONNRESET;

		goto err_create_pkt;

	}
@@ -2708,7 +2736,7 @@ static int venus_hfi_session_release_buffers(void *sess, 
	mutex_lock(&device->lock);



	if (!__is_session_valid(device, session, __func__)) {

		rc = -EINVAL;

		rc = -ECONNRESET;

		goto err_create_pkt;

	}

	if (buffer_info->buffer_type != HAL_BUFFER_INTERNAL_PERSIST_1) {
@@ -2767,7 +2795,7 @@ static int venus_hfi_session_send(void *sess, 
	mutex_lock(&device->lock);



	if (!__is_session_valid(device, session, __func__)) {

		rc = -EINVAL;

		rc = -ECONNRESET;

		goto err_send_pkt;

	}

	rc = call_hfi_pkt_op(device, session_send,
@@ -2804,7 +2832,7 @@ static int venus_hfi_session_get_buf_req(void *sess) 
	mutex_lock(&device->lock);



	if (!__is_session_valid(device, session, __func__)) {

		rc = -EINVAL;

		rc = -ECONNRESET;

		goto err_create_pkt;

	}

	rc = call_hfi_pkt_op(device, session_get_buf_req,
@@ -3230,6 +3258,8 @@ static void **get_session_id(struct msm_cvp_cb_info *info) 
	case HAL_SESSION_DME_FRAME_CMD_DONE:

	case HAL_SESSION_ICA_FRAME_CMD_DONE:

	case HAL_SESSION_PERSIST_CMD_DONE:

	case HAL_SESSION_FD_CONFIG_CMD_DONE:

	case HAL_SESSION_MODEL_BUF_CMD_DONE:

	case HAL_SESSION_PROPERTY_INFO:

		session_id = &info->response.cmd.session_id;

		break;
@@ -3298,7 +3328,7 @@ static int __response_handler(struct iris_hfi_device *device) 
		return 0;

	}



	if (device->intr_status & CVP_WRAPPER_INTR_STATUS_A2HWD_BMSK) {

	if (device->intr_status & CVP_FATAL_INTR_BMSK) {

		struct cvp_hfi_sfr_struct *vsfr = (struct cvp_hfi_sfr_struct *)

			device->sfr.align_virtual_addr;

		struct msm_cvp_cb_info info = {
@@ -3311,8 +3341,15 @@ static int __response_handler(struct iris_hfi_device *device) 
		if (vsfr)

			dprintk(CVP_ERR, "SFR Message from FW: %s\n",

					vsfr->rg_data);

		if (device->intr_status & CVP_WRAPPER_INTR_MASK_CPU_NOC_BMSK)

			dprintk(CVP_ERR, "Received Xtensa NOC error\n");



		if (device->intr_status & CVP_WRAPPER_INTR_MASK_CORE_NOC_BMSK)

			dprintk(CVP_ERR, "Received CVP core NOC error\n");



		if (device->intr_status & CVP_WRAPPER_INTR_MASK_A2HWD_BMSK)

			dprintk(CVP_ERR, "Received CVP watchdog timeout\n");



		dprintk(CVP_ERR, "Received watchdog timeout\n");

		packets[packet_count++] = info;

		goto exit;

	}
@@ -4351,7 +4388,7 @@ static int __disable_subcaches(struct iris_hfi_device *device) 
	return 0;

}



static void interrupt_init_vpu5(struct iris_hfi_device *device)

static void interrupt_init_iris2(struct iris_hfi_device *device)

{

	u32 mask_val = 0;
@@ -4359,8 +4396,7 @@ static void interrupt_init_vpu5(struct iris_hfi_device *device) 
	mask_val = __read_register(device, CVP_WRAPPER_INTR_MASK);



	/* Write 0 to unmask CPU and WD interrupts */

	mask_val &= ~(CVP_WRAPPER_INTR_MASK_A2HWD_BMSK |

			CVP_WRAPPER_INTR_MASK_A2HCPU_BMSK);

	mask_val &= ~(CVP_FATAL_INTR_BMSK | CVP_WRAPPER_INTR_MASK_A2HCPU_BMSK);

	__write_register(device, CVP_WRAPPER_INTR_MASK, mask_val);

	dprintk(CVP_DBG, "Init irq: reg: %x, mask value %x\n",

		CVP_WRAPPER_INTR_MASK, mask_val);
@@ -4842,9 +4878,82 @@ static int venus_hfi_get_core_capabilities(void *dev) 
	return 0;

}



static void __noc_error_info_iris2(struct iris_hfi_device *device)

{

	u32 val = 0;



	val = __read_register(device, CVP_NOC_ERR_SWID_LOW_OFFS);

	dprintk(CVP_ERR, "CVP_NOC_ERL_MAIN_SWID_LOW:     %#x\n", val);

	val = __read_register(device, CVP_NOC_ERR_SWID_HIGH_OFFS);

	dprintk(CVP_ERR, "CVP_NOC_ERL_MAIN_SWID_HIGH:     %#x\n", val);

	val = __read_register(device, CVP_NOC_ERR_MAINCTL_LOW_OFFS);

	dprintk(CVP_ERR, "CVP_NOC_ERL_MAIN_MAINCTL_LOW:     %#x\n", val);

	val = __read_register(device, CVP_NOC_ERR_ERRVLD_LOW_OFFS);

	dprintk(CVP_ERR, "CVP_NOC_ERL_MAIN_ERRVLD_LOW:     %#x\n", val);

	val = __read_register(device, CVP_NOC_ERR_ERRCLR_LOW_OFFS);

	dprintk(CVP_ERR, "CVP_NOC_ERL_MAIN_ERRCLR_LOW:     %#x\n", val);

	val = __read_register(device, CVP_NOC_ERR_ERRLOG0_LOW_OFFS);

	dprintk(CVP_ERR, "CVP_NOC_ERL_MAIN_ERRLOG0_LOW:     %#x\n", val);

	val = __read_register(device, CVP_NOC_ERR_ERRLOG0_HIGH_OFFS);

	dprintk(CVP_ERR, "CVP_NOC_ERL_MAIN_ERRLOG0_HIGH:     %#x\n", val);

	val = __read_register(device, CVP_NOC_ERR_ERRLOG1_LOW_OFFS);

	dprintk(CVP_ERR, "CVP_NOC_ERL_MAIN_ERRLOG1_LOW:     %#x\n", val);

	val = __read_register(device, CVP_NOC_ERR_ERRLOG1_HIGH_OFFS);

	dprintk(CVP_ERR, "CVP_NOC_ERL_MAIN_ERRLOG1_HIGH:     %#x\n", val);

	val = __read_register(device, CVP_NOC_ERR_ERRLOG2_LOW_OFFS);

	dprintk(CVP_ERR, "CVP_NOC_ERL_MAIN_ERRLOG2_LOW:     %#x\n", val);

	val = __read_register(device, CVP_NOC_ERR_ERRLOG2_HIGH_OFFS);

	dprintk(CVP_ERR, "CVP_NOC_ERL_MAIN_ERRLOG2_HIGH:     %#x\n", val);

	val = __read_register(device, CVP_NOC_ERR_ERRLOG3_LOW_OFFS);

	dprintk(CVP_ERR, "CVP_NOC_ERL_MAIN_ERRLOG3_LOW:     %#x\n", val);

	val = __read_register(device, CVP_NOC_ERR_ERRLOG3_HIGH_OFFS);

	dprintk(CVP_ERR, "CVP_NOC_ERL_MAIN_ERRLOG3_HIGH:     %#x\n", val);



	val = __read_register(device, CVP_NOC_CORE_ERR_SWID_LOW_OFFS);

	dprintk(CVP_ERR, "CVP_NOC__CORE_ERL_MAIN_SWID_LOW:     %#x\n", val);

	val = __read_register(device, CVP_NOC_CORE_ERR_SWID_HIGH_OFFS);

	dprintk(CVP_ERR, "CVP_NOC_CORE_ERL_MAIN_SWID_HIGH:     %#x\n", val);

	val = __read_register(device, CVP_NOC_CORE_ERR_MAINCTL_LOW_OFFS);

	dprintk(CVP_ERR, "CVP_NOC_CORE_ERL_MAIN_MAINCTL_LOW:     %#x\n", val);

	val = __read_register(device, CVP_NOC_CORE_ERR_ERRVLD_LOW_OFFS);

	dprintk(CVP_ERR, "CVP_NOC_CORE_ERL_MAIN_ERRVLD_LOW:     %#x\n", val);

	val = __read_register(device, CVP_NOC_CORE_ERR_ERRCLR_LOW_OFFS);

	dprintk(CVP_ERR, "CVP_NOC_CORE_ERL_MAIN_ERRCLR_LOW:     %#x\n", val);

	val = __read_register(device, CVP_NOC_CORE_ERR_ERRLOG0_LOW_OFFS);

	dprintk(CVP_ERR, "CVP_NOC_CORE_ERL_MAIN_ERRLOG0_LOW:     %#x\n", val);

	val = __read_register(device, CVP_NOC_CORE_ERR_ERRLOG0_HIGH_OFFS);

	dprintk(CVP_ERR, "CVP_NOC_CORE_ERL_MAIN_ERRLOG0_HIGH:     %#x\n", val);

	val = __read_register(device, CVP_NOC_CORE_ERR_ERRLOG1_LOW_OFFS);

	dprintk(CVP_ERR, "CVP_NOC_CORE_ERL_MAIN_ERRLOG1_LOW:     %#x\n", val);

	val = __read_register(device, CVP_NOC_CORE_ERR_ERRLOG1_HIGH_OFFS);

	dprintk(CVP_ERR, "CVP_NOC_CORE_ERL_MAIN_ERRLOG1_HIGH:     %#x\n", val);

	val = __read_register(device, CVP_NOC_CORE_ERR_ERRLOG2_LOW_OFFS);

	dprintk(CVP_ERR, "CVP_NOC_CORE_ERL_MAIN_ERRLOG2_LOW:     %#x\n", val);

	val = __read_register(device, CVP_NOC_CORE_ERR_ERRLOG2_HIGH_OFFS);

	dprintk(CVP_ERR, "CVP_NOC_CORE_ERL_MAIN_ERRLOG2_HIGH:     %#x\n", val);

	val = __read_register(device, CVP_NOC_CORE_ERR_ERRLOG3_LOW_OFFS);

	dprintk(CVP_ERR, "CVP_NOC_CORE_ERL_MAIN_ERRLOG3_LOW:     %#x\n", val);

	val = __read_register(device, CVP_NOC_CORE_ERR_ERRLOG3_HIGH_OFFS);

	dprintk(CVP_ERR, "CVP_NOC_CORE_ERL_MAIN_ERRLOG3_HIGH:     %#x\n", val);

}



static int venus_hfi_noc_error_info(void *dev)

{

	dprintk(CVP_ERR, "%s not supported yet!\n", __func__);

	struct iris_hfi_device *device;



	if (!dev) {

		dprintk(CVP_ERR, "%s: null device\n", __func__);

		return -EINVAL;

	}

	device = dev;



	mutex_lock(&device->lock);

	dprintk(CVP_ERR, "%s: non error information\n", __func__);



	call_venus_op(device, noc_error_info, device);



	mutex_unlock(&device->lock);



	return 0;

}
@@ -4999,6 +5108,26 @@ void cvp_venus_hfi_delete_device(void *device) 
	}

}



static int venus_hfi_validate_session(void *sess, const char *func)

{

	struct cvp_hal_session *session = sess;

	int rc = 0;

	struct iris_hfi_device *device;



	if (!session || !session->device) {

		dprintk(CVP_ERR, " %s Invalid Params %pK\n", __func__, session);

		return -EINVAL;

	}



	device = session->device;

	mutex_lock(&device->lock);

	if (!__is_session_valid(device, session, func))

		rc = -ECONNRESET;



	mutex_unlock(&device->lock);

	return rc;

}



static void venus_init_hfi_callbacks(struct cvp_hfi_device *hdev)

{

	hdev->core_init = venus_hfi_core_init;
@@ -5027,6 +5156,7 @@ static void venus_init_hfi_callbacks(struct cvp_hfi_device *hdev) 
	hdev->suspend = venus_hfi_suspend;

	hdev->flush_debug_queue = venus_hfi_flush_debug_queue;

	hdev->noc_error_info = venus_hfi_noc_error_info;

	hdev->validate_session = venus_hfi_validate_session;

}



int cvp_venus_hfi_initialize(struct cvp_hfi_device *hdev, u32 device_id,

drivers/media/platform/msm/cvp/cvp_hfi.h

+6 −0
Original line number Diff line number Diff line
@@ -134,6 +134,12 @@ 
	(HFI_CMD_SESSION_CVP_START + 0x050)

#define HFI_CMD_SESSION_CVP_PYS_HCD_FRAME\

	(HFI_CMD_SESSION_CVP_START + 0x051)

#define HFI_CMD_SESSION_CVP_SET_MODEL_BUFFERS\

	(HFI_CMD_SESSION_CVP_START + 0x052)

#define HFI_CMD_SESSION_CVP_FD_CONFIG\

	(HFI_CMD_SESSION_CVP_START + 0x053)

#define HFI_CMD_SESSION_CVP_FD_FRAME\

	(HFI_CMD_SESSION_CVP_START + 0x054)

#define  HFI_CMD_SESSION_CVP_ICA_FRAME\

	(HFI_CMD_SESSION_CVP_START + 0x100)

#define  HFI_CMD_SESSION_CVP_ICA_CONFIG\

drivers/media/platform/msm/cvp/cvp_hfi_api.h

+3 −0
Original line number Diff line number Diff line
@@ -337,7 +337,9 @@ enum hal_command_response { 
	HAL_SESSION_DC_CONFIG_CMD_DONE,

	HAL_SESSION_DCM_CONFIG_CMD_DONE,

	HAL_SESSION_PYS_HCD_CONFIG_CMD_DONE,

	HAL_SESSION_FD_CONFIG_CMD_DONE,

	HAL_SESSION_PERSIST_CMD_DONE,

	HAL_SESSION_MODEL_BUF_CMD_DONE,

	HAL_SESSION_ICA_FRAME_CMD_DONE,

	HAL_SESSION_PROPERTY_INFO,

	HAL_SESSION_ERROR,
@@ -564,6 +566,7 @@ struct cvp_hfi_device { 
	int (*suspend)(void *dev);

	int (*flush_debug_queue)(void *dev);

	int (*noc_error_info)(void *dev);

	int (*validate_session)(void *sess, const char *func);

};



typedef void (*hfi_cmd_response_callback) (enum hal_command_response cmd,

drivers/media/platform/msm/cvp/cvp_hfi_io.h

+35 −15
Original line number Diff line number Diff line
@@ -89,6 +89,11 @@ 
#define CVP_WRAPPER_INTR_STATUS_A2H_BMSK	0x4



#define CVP_WRAPPER_INTR_MASK		(CVP_WRAPPER_BASE_OFFS + 0x10)

#define CVP_FATAL_INTR_BMSK	(CVP_WRAPPER_INTR_MASK_CPU_NOC_BMSK | \

				CVP_WRAPPER_INTR_MASK_CORE_NOC_BMSK | \

				CVP_WRAPPER_INTR_MASK_A2HWD_BMSK)

#define CVP_WRAPPER_INTR_MASK_CPU_NOC_BMSK	0x40

#define CVP_WRAPPER_INTR_MASK_CORE_NOC_BMSK	0x20

#define CVP_WRAPPER_INTR_MASK_A2HWD_BMSK	0x8

#define CVP_WRAPPER_INTR_MASK_A2HCPU_BMSK	0x4

#define CVP_WRAPPER_INTR_MASK_A2HCPU_SHFT	0x2
@@ -168,21 +173,36 @@ 
 * MODULE: vcodec noc error log registers

 * --------------------------------------------------------------------------

 */

#define VCODEC_CORE0_VIDEO_NOC_BASE_OFFS		0x00004000

#define VCODEC_CORE1_VIDEO_NOC_BASE_OFFS		0x0000C000

#define VCODEC_COREX_VIDEO_NOC_ERR_SWID_LOW_OFFS	0x0500

#define VCODEC_COREX_VIDEO_NOC_ERR_SWID_HIGH_OFFS	0x0504

#define VCODEC_COREX_VIDEO_NOC_ERR_MAINCTL_LOW_OFFS	0x0508

#define VCODEC_COREX_VIDEO_NOC_ERR_ERRVLD_LOW_OFFS	0x0510

#define VCODEC_COREX_VIDEO_NOC_ERR_ERRCLR_LOW_OFFS	0x0518

#define VCODEC_COREX_VIDEO_NOC_ERR_ERRLOG0_LOW_OFFS	0x0520

#define VCODEC_COREX_VIDEO_NOC_ERR_ERRLOG0_HIGH_OFFS	0x0524

#define VCODEC_COREX_VIDEO_NOC_ERR_ERRLOG1_LOW_OFFS	0x0528

#define VCODEC_COREX_VIDEO_NOC_ERR_ERRLOG1_HIGH_OFFS	0x052C

#define VCODEC_COREX_VIDEO_NOC_ERR_ERRLOG2_LOW_OFFS	0x0530

#define VCODEC_COREX_VIDEO_NOC_ERR_ERRLOG2_HIGH_OFFS	0x0534

#define VCODEC_COREX_VIDEO_NOC_ERR_ERRLOG3_LOW_OFFS	0x0538

#define VCODEC_COREX_VIDEO_NOC_ERR_ERRLOG3_HIGH_OFFS	0x053C

#define CVP_NOC_BASE_OFFS		0x000D0000

#define CVP_NOC_ERR_SWID_LOW_OFFS	(CVP_NOC_BASE_OFFS + 0x80)

#define CVP_NOC_ERR_SWID_HIGH_OFFS	(CVP_NOC_BASE_OFFS + 0x84)

#define CVP_NOC_ERR_MAINCTL_LOW_OFFS	(CVP_NOC_BASE_OFFS + 0x88)

#define CVP_NOC_ERR_ERRVLD_LOW_OFFS	(CVP_NOC_BASE_OFFS + 0x90)

#define CVP_NOC_ERR_ERRCLR_LOW_OFFS	(CVP_NOC_BASE_OFFS + 0x98)

#define CVP_NOC_ERR_ERRLOG0_LOW_OFFS	(CVP_NOC_BASE_OFFS + 0xA0)

#define CVP_NOC_ERR_ERRLOG0_HIGH_OFFS	(CVP_NOC_BASE_OFFS + 0xA4)

#define CVP_NOC_ERR_ERRLOG1_LOW_OFFS	(CVP_NOC_BASE_OFFS + 0xA8)

#define CVP_NOC_ERR_ERRLOG1_HIGH_OFFS	(CVP_NOC_BASE_OFFS + 0xAC)

#define CVP_NOC_ERR_ERRLOG2_LOW_OFFS	(CVP_NOC_BASE_OFFS + 0xB0)

#define CVP_NOC_ERR_ERRLOG2_HIGH_OFFS	(CVP_NOC_BASE_OFFS + 0xB4)

#define CVP_NOC_ERR_ERRLOG3_LOW_OFFS	(CVP_NOC_BASE_OFFS + 0xB8)

#define CVP_NOC_ERR_ERRLOG3_HIGH_OFFS	(CVP_NOC_BASE_OFFS + 0xBC)



#define CVP_NOC_CORE_BASE_OFFS			0x00010000

#define CVP_NOC_CORE_ERR_SWID_LOW_OFFS		(CVP_NOC_CORE_BASE_OFFS + 0x80)

#define CVP_NOC_CORE_ERR_SWID_HIGH_OFFS		(CVP_NOC_CORE_BASE_OFFS + 0x84)

#define CVP_NOC_CORE_ERR_MAINCTL_LOW_OFFS	(CVP_NOC_CORE_BASE_OFFS + 0x88)

#define CVP_NOC_CORE_ERR_ERRVLD_LOW_OFFS	(CVP_NOC_CORE_BASE_OFFS + 0x90)

#define CVP_NOC_CORE_ERR_ERRCLR_LOW_OFFS	(CVP_NOC_CORE_BASE_OFFS + 0x98)

#define CVP_NOC_CORE_ERR_ERRLOG0_LOW_OFFS	(CVP_NOC_CORE_BASE_OFFS + 0xA0)

#define CVP_NOC_CORE_ERR_ERRLOG0_HIGH_OFFS	(CVP_NOC_CORE_BASE_OFFS + 0xA4)

#define CVP_NOC_CORE_ERR_ERRLOG1_LOW_OFFS	(CVP_NOC_CORE_BASE_OFFS + 0xA8)

#define CVP_NOC_CORE_ERR_ERRLOG1_HIGH_OFFS	(CVP_NOC_CORE_BASE_OFFS + 0xAC)

#define CVP_NOC_CORE_ERR_ERRLOG2_LOW_OFFS	(CVP_NOC_CORE_BASE_OFFS + 0xB0)

#define CVP_NOC_CORE_ERR_ERRLOG2_HIGH_OFFS	(CVP_NOC_CORE_BASE_OFFS + 0xB4)

#define CVP_NOC_CORE_ERR_ERRLOG3_LOW_OFFS	(CVP_NOC_CORE_BASE_OFFS + 0xB8)

#define CVP_NOC_CORE_ERR_ERRLOG3_HIGH_OFFS	(CVP_NOC_CORE_BASE_OFFS + 0xBC)





#define CVP_AON_WRAPPER_MVP_NOC_LPI_CONTROL	(CVP_AON_BASE_OFFS)

#define CVP_AON_WRAPPER_MVP_NOC_LPI_STATUS	(CVP_AON_BASE_OFFS + 0x4)

drivers/media/platform/msm/cvp/msm_cvp.c

+210 −151

File changed.

Preview size limit exceeded, changes collapsed.