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

Commit 1986f0ce authored by Linux Build Service Account's avatar Linux Build Service Account
Browse files

Merge 8412327d on remote branch 

Change-Id: I02c0da5b1b09b41fff98d7ac11848c25c2bd80d7
parents cf1dd71a 8412327d

drivers/cam_icp/icp_hw/icp_hw_mgr/cam_icp_hw_mgr.c

+10 −2
Original line number Diff line number Diff line
@@ -4189,7 +4189,8 @@ static bool cam_icp_mgr_is_valid_outconfig(struct cam_packet *packet) 
					packet->io_configs_offset/4);



	for (i = 0 ; i < packet->num_io_configs; i++)

		if (io_cfg_ptr[i].direction == CAM_BUF_OUTPUT)

		if ((io_cfg_ptr[i].direction == CAM_BUF_OUTPUT) ||

			(io_cfg_ptr[i].direction == CAM_BUF_IN_OUT))

			num_out_map_entries++;



	if (num_out_map_entries <= CAM_MAX_OUT_RES) {
@@ -4342,10 +4343,17 @@ static int cam_icp_mgr_process_io_cfg(struct cam_icp_hw_mgr *hw_mgr, 
		if (io_cfg_ptr[i].direction == CAM_BUF_INPUT) {

			sync_in_obj[j++] = io_cfg_ptr[i].fence;

			prepare_args->num_in_map_entries++;

		} else {

		} else if ((io_cfg_ptr[i].direction == CAM_BUF_OUTPUT) ||

			(io_cfg_ptr[i].direction == CAM_BUF_IN_OUT)) {

			prepare_args->out_map_entries[k++].sync_id =

				io_cfg_ptr[i].fence;

			prepare_args->num_out_map_entries++;

		} else {

			CAM_ERR(CAM_ICP, "dir: %d, max_out:%u, out %u",

				io_cfg_ptr[i].direction,

				prepare_args->max_out_map_entries,

				prepare_args->num_out_map_entries);

			return -EINVAL;

		}

		CAM_DBG(CAM_REQ,

			"ctx_id: %u req_id: %llu dir[%d]: %u, fence: %u resource_type = %u memh %x",

drivers/cam_req_mgr/cam_mem_mgr.c

+4 −25
Original line number Diff line number Diff line
@@ -188,7 +188,6 @@ static int32_t cam_mem_get_slot(void) 
		set_bit(idx, tbl.bitmap);

		tbl.bufq[idx].active = true;

		mutex_init(&tbl.bufq[idx].q_lock);

		mutex_init(&tbl.bufq[idx].ref_lock);

		mutex_unlock(&tbl.m_lock);

		return idx;

	}
@@ -202,13 +201,10 @@ static void cam_mem_put_slot(int32_t idx) 
	mutex_lock(&tbl.m_lock);

	mutex_lock(&tbl.bufq[idx].q_lock);

	tbl.bufq[idx].active = false;

	kref_init(&tbl.bufq[idx].krefcount);

	kref_init(&tbl.bufq[idx].urefcount);

	mutex_unlock(&tbl.bufq[idx].q_lock);

	mutex_lock(&tbl.bufq[idx].ref_lock);

	memset(&tbl.bufq[idx].krefcount, 0, sizeof(struct kref));

	memset(&tbl.bufq[idx].urefcount, 0, sizeof(struct kref));

	mutex_unlock(&tbl.bufq[idx].ref_lock);

	mutex_destroy(&tbl.bufq[idx].q_lock);

	mutex_destroy(&tbl.bufq[idx].ref_lock);

	clear_bit(idx, tbl.bitmap);

	mutex_unlock(&tbl.m_lock);

}
@@ -301,18 +297,15 @@ int cam_mem_get_cpu_buf(int32_t buf_handle, uintptr_t *vaddr_ptr, size_t *len) 
		return -EINVAL;

	}



	mutex_lock(&tbl.bufq[idx].ref_lock);

	if (tbl.bufq[idx].kmdvaddr && kref_get_unless_zero(&tbl.bufq[idx].krefcount)) {

		*vaddr_ptr = tbl.bufq[idx].kmdvaddr;

		*len = tbl.bufq[idx].len;

	} else {

		mutex_unlock(&tbl.bufq[idx].ref_lock);

		CAM_ERR(CAM_MEM,

			"No KMD access request, vaddr= %p, idx= %d, handle= %d",

			tbl.bufq[idx].kmdvaddr, idx, buf_handle);

		return -EINVAL;

	}

	mutex_unlock(&tbl.bufq[idx].ref_lock);



	return 0;

}
@@ -971,13 +964,10 @@ static int cam_mem_mgr_cleanup_table(void) 
		tbl.bufq[i].num_hdl = 0;

		tbl.bufq[i].dma_buf = NULL;

		tbl.bufq[i].active = false;

		kref_init(&tbl.bufq[i].krefcount);

		kref_init(&tbl.bufq[i].urefcount);

		mutex_unlock(&tbl.bufq[i].q_lock);

		mutex_lock(&tbl.bufq[i].ref_lock);

		memset(&tbl.bufq[i].krefcount, 0, sizeof(struct kref));

		memset(&tbl.bufq[i].urefcount, 0, sizeof(struct kref));

		mutex_unlock(&tbl.bufq[i].ref_lock);

		mutex_destroy(&tbl.bufq[i].q_lock);

		mutex_destroy(&tbl.bufq[i].ref_lock);

	}



	bitmap_zero(tbl.bitmap, tbl.bits);
@@ -1103,7 +1093,6 @@ static void cam_mem_util_unmap_wrapper(struct kref *kref) 


	cam_mem_util_unmap(idx);



	mutex_destroy(&tbl.bufq[idx].ref_lock);

}



void cam_mem_put_cpu_buf(int32_t buf_handle)
@@ -1137,7 +1126,6 @@ void cam_mem_put_cpu_buf(int32_t buf_handle) 
		return;

	}



	mutex_lock(&tbl.bufq[idx].ref_lock);

	kref_put(&tbl.bufq[idx].krefcount, cam_mem_util_unmap_dummy);



	krefcount = kref_read(&tbl.bufq[idx].krefcount);
@@ -1155,10 +1143,7 @@ void cam_mem_put_cpu_buf(int32_t buf_handle) 
			"Unbalanced release Called buf_handle: %u, idx: %d",

			tbl.bufq[idx].buf_handle, idx);

	}

	mutex_unlock(&tbl.bufq[idx].ref_lock);



	if (unmap)

		mutex_destroy(&tbl.bufq[idx].ref_lock);



}

EXPORT_SYMBOL(cam_mem_put_cpu_buf);
@@ -1202,7 +1187,6 @@ int cam_mem_mgr_release(struct cam_mem_mgr_release_cmd *cmd) 


	CAM_DBG(CAM_MEM, "Releasing hdl = %x, idx = %d", cmd->buf_handle, idx);



	mutex_lock(&tbl.bufq[idx].ref_lock);

	kref_put(&tbl.bufq[idx].urefcount, cam_mem_util_unmap_dummy);



	urefcount = kref_read(&tbl.bufq[idx].urefcount);
@@ -1222,11 +1206,6 @@ int cam_mem_mgr_release(struct cam_mem_mgr_release_cmd *cmd) 
			"Called unmap from here, buf_handle: %u, idx: %d", cmd->buf_handle, idx);

	}



	mutex_unlock(&tbl.bufq[idx].ref_lock);



	if (unmap)

		mutex_destroy(&tbl.bufq[idx].ref_lock);



	return rc;

}

drivers/cam_req_mgr/cam_mem_mgr.h

+0 −2
Original line number Diff line number Diff line
@@ -48,7 +48,6 @@ enum cam_smmu_mapping_client { 
 * @smmu_mapping_client: Client buffer (User or kernel)

 * @urefcount:      Reference counter to track whether the buffer is

 *                  mapped and in use by umd

 * @ref_lock:       Mutex lock for refcount

 */

struct cam_mem_buf_queue {

	struct dma_buf *dma_buf;
@@ -67,7 +66,6 @@ struct cam_mem_buf_queue { 
	struct kref krefcount;

	enum cam_smmu_mapping_client smmu_mapping_client;

	struct kref urefcount;

	struct mutex ref_lock;

};



/**

drivers/cam_sensor_module/cam_eeprom/cam_eeprom_core.c

+24 −19
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-only

/*

 * Copyright (c) 2017-2020, The Linux Foundation. All rights reserved.

 * Copyright (c) 2022-2023 Qualcomm Innovation Center, Inc. All rights reserved.

 * Copyright (c) 2022-2024 Qualcomm Innovation Center, Inc. All rights reserved.

 */



#include <linux/module.h>
@@ -418,6 +418,7 @@ static int32_t cam_eeprom_parse_memory_map( 
	int32_t                            rc = 0;

	int32_t                            cnt = 0;

	int32_t                            processed_size = 0;

	int32_t                            payload_count;

	uint8_t                            generic_op_code;

	struct cam_eeprom_memory_map_t    *map = data->map;

	struct common_header              *cmm_hdr =
@@ -447,24 +448,25 @@ static int32_t cam_eeprom_parse_memory_map( 
	switch (cmm_hdr->cmd_type) {

	case CAMERA_SENSOR_CMD_TYPE_I2C_RNDM_WR:

		i2c_random_wr = (struct cam_cmd_i2c_random_wr *)cmd_buf;

		payload_count = i2c_random_wr->header.count;



		if (i2c_random_wr->header.count == 0 ||

		    i2c_random_wr->header.count >= MSM_EEPROM_MAX_MEM_MAP_CNT ||

		if (payload_count == 0 ||

		    payload_count >= MSM_EEPROM_MAX_MEM_MAP_CNT ||

		    (size_t)*num_map >= ((MSM_EEPROM_MAX_MEM_MAP_CNT *

				MSM_EEPROM_MEMORY_MAP_MAX_SIZE) -

				i2c_random_wr->header.count)) {

				payload_count)) {

			CAM_ERR(CAM_EEPROM, "OOB Error");

			return -EINVAL;

		}

		cmd_length_in_bytes   = sizeof(struct cam_cmd_i2c_random_wr) +

			((i2c_random_wr->header.count - 1) *

			((payload_count - 1) *

			sizeof(struct i2c_random_wr_payload));



		if (cmd_length_in_bytes > remain_buf_len) {

			CAM_ERR(CAM_EEPROM, "Not enough buffer remaining");

			return -EINVAL;

		}

		for (cnt = 0; cnt < (i2c_random_wr->header.count);

		for (cnt = 0; cnt < (payload_count);

			cnt++) {

			map[*num_map + cnt].page.addr =

				i2c_random_wr->random_wr_payload[cnt].reg_addr;
@@ -477,16 +479,16 @@ static int32_t cam_eeprom_parse_memory_map( 
			map[*num_map + cnt].page.valid_size = 1;

		}



		*num_map += (i2c_random_wr->header.count - 1);

		cmd_buf += cmd_length_in_bytes / sizeof(int32_t);

		*num_map += (payload_count - 1);

		processed_size +=

			cmd_length_in_bytes;

		break;

	case CAMERA_SENSOR_CMD_TYPE_I2C_CONT_RD:

		i2c_cont_rd = (struct cam_cmd_i2c_continuous_rd *)cmd_buf;

		cmd_length_in_bytes = sizeof(struct cam_cmd_i2c_continuous_rd);

		payload_count = i2c_cont_rd->header.count;



		if (i2c_cont_rd->header.count >= U32_MAX - data->num_data) {

		if (payload_count >= U32_MAX - data->num_data) {

			CAM_ERR(CAM_EEPROM,

				"int overflow on eeprom memory block");

			return -EINVAL;
@@ -495,8 +497,7 @@ static int32_t cam_eeprom_parse_memory_map( 
		map[*num_map].mem.addr_type = i2c_cont_rd->header.addr_type;

		map[*num_map].mem.data_type = i2c_cont_rd->header.data_type;

		map[*num_map].mem.valid_size =

			i2c_cont_rd->header.count;

		cmd_buf += cmd_length_in_bytes / sizeof(int32_t);

			payload_count;

		processed_size +=

			cmd_length_in_bytes;

		data->num_data += map[*num_map].mem.valid_size;
@@ -1075,6 +1076,8 @@ static int32_t cam_eeprom_get_cal_data(struct cam_eeprom_ctrl_t *e_ctrl, 
{

	struct cam_buf_io_cfg *io_cfg;

	uint32_t              i = 0;

	size_t                plane_offset;

	int32_t               mem_handle;

	int                   rc = 0;

	uintptr_t              buf_addr;

	size_t                buf_size;
@@ -1084,6 +1087,8 @@ static int32_t cam_eeprom_get_cal_data(struct cam_eeprom_ctrl_t *e_ctrl, 
	io_cfg = (struct cam_buf_io_cfg *) ((uint8_t *)

		&csl_packet->payload +

		csl_packet->io_configs_offset);

	plane_offset = io_cfg->offsets[0];

	mem_handle   = io_cfg->mem_handle[0];



	CAM_DBG(CAM_EEPROM, "number of IO configs: %d:",

		csl_packet->num_io_configs);
@@ -1091,21 +1096,21 @@ static int32_t cam_eeprom_get_cal_data(struct cam_eeprom_ctrl_t *e_ctrl, 
	for (i = 0; i < csl_packet->num_io_configs; i++) {

		CAM_DBG(CAM_EEPROM, "Direction: %d:", io_cfg->direction);

		if (io_cfg->direction == CAM_BUF_OUTPUT) {

			rc = cam_mem_get_cpu_buf(io_cfg->mem_handle[0],

			rc = cam_mem_get_cpu_buf(mem_handle,

				&buf_addr, &buf_size);

			if (rc) {

				CAM_ERR(CAM_EEPROM, "Fail in get buffer: %d",

					rc);

				return rc;

			}

			if (buf_size <= io_cfg->offsets[0]) {

			if (buf_size <= plane_offset) {

				CAM_ERR(CAM_EEPROM, "Not enough buffer");

				cam_mem_put_cpu_buf(io_cfg->mem_handle[0]);

				cam_mem_put_cpu_buf(mem_handle);

				rc = -EINVAL;

				return rc;

			}



			remain_len = buf_size - io_cfg->offsets[0];

			remain_len = buf_size - plane_offset;

			CAM_DBG(CAM_EEPROM, "buf_addr : %pK, buf_size : %zu\n",

				(void *)buf_addr, buf_size);
@@ -1113,16 +1118,16 @@ static int32_t cam_eeprom_get_cal_data(struct cam_eeprom_ctrl_t *e_ctrl, 
			if (!read_buffer) {

				CAM_ERR(CAM_EEPROM,

					"invalid buffer to copy data");

				cam_mem_put_cpu_buf(io_cfg->mem_handle[0]);

				cam_mem_put_cpu_buf(mem_handle);

				rc = -EINVAL;

				return rc;

			}

			read_buffer += io_cfg->offsets[0];

			read_buffer += plane_offset;



			if (remain_len < e_ctrl->cal_data.num_data) {

				CAM_ERR(CAM_EEPROM,

					"failed to copy, Invalid size");

				cam_mem_put_cpu_buf(io_cfg->mem_handle[0]);

				cam_mem_put_cpu_buf(mem_handle);

				rc = -EINVAL;

				return rc;

			}
@@ -1131,7 +1136,7 @@ static int32_t cam_eeprom_get_cal_data(struct cam_eeprom_ctrl_t *e_ctrl, 
				e_ctrl->cal_data.num_data);

			memcpy(read_buffer, e_ctrl->cal_data.mapdata,

					e_ctrl->cal_data.num_data);

			cam_mem_put_cpu_buf(io_cfg->mem_handle[0]);

			cam_mem_put_cpu_buf(mem_handle);

		} else {

			CAM_ERR(CAM_EEPROM, "Invalid direction");

			rc = -EINVAL;