guamna: Add eeprom operation READ_LOOP

1. add eeprom operation READ_LOOP for hi556
2. remove eeprom name

Change-Id: I65cc19d8956c5bbeb9a0db4f9051d7a8e4b21c51
Signed-off-by: zhouguangcheng <zhouguangcheng@longcheer.com>
Reviewed-on: https://gerrit.mot.com/1621339
SLTApproved: Slta Waiver
SME-Granted: SME Approvals Granted
Tested-by: Jira Key
Reviewed-by: Dawei Wang <wangdw10@motorola.com>
Reviewed-by: Wang Liu <liuwang2@lenovo.com>
Reviewed-by: Long Cheng <chengl1@motorola.com>
Reviewed-by: Zhuoran Xu <xuzr3@motorola.com>
Reviewed-by: Zhichao Chen <chenzc2@motorola.com>
Submit-Approved: Jira Key

drivers/cam_sensor_module/cam_eeprom/cam_eeprom_core.c

@@ -105,31 +105,32 @@ static int cam_eeprom_read_memory(struct cam_eeprom_ctrl_t *e_ctrl,
 		}
 
 		if (emap[j].mem.valid_size) {
-			if (0 == strcmp(eb_info->i2c_info.eeprom_name, "mot_hi556_otp")) {
-				for (sz = 0; sz < emap[j].mem.valid_size; sz++) {
-					rc = camera_io_dev_read(&e_ctrl->io_master_info,
-						emap[j].mem.addr, &sz_read,
-						emap[j].mem.addr_type,
-						emap[j].mem.data_type);
-					if (rc) {
-						CAM_ERR(CAM_EEPROM, "read failed rc %d", rc);
-						return rc;
-					}
-					*memptr = (uint8_t)sz_read;
-					memptr++;
-				}
-			} else {
-				rc = camera_io_dev_read_seq(&e_ctrl->io_master_info,
-					emap[j].mem.addr, memptr,
-					emap[j].mem.addr_type,
-					emap[j].mem.data_type,
-					emap[j].mem.valid_size);
+			rc = camera_io_dev_read_seq(&e_ctrl->io_master_info,
+				emap[j].mem.addr, memptr,
+				emap[j].mem.addr_type,
+				emap[j].mem.data_type,
+				emap[j].mem.valid_size);
+			if (rc) {
+				CAM_ERR(CAM_EEPROM, "read failed rc %d",
+					rc);
+				return rc;
+			}
+			memptr += emap[j].mem.valid_size;
+		}
+
+		if (emap[j].mem_rl.valid_size) {
+			for (sz = 0; sz < emap[j].mem_rl.valid_size; sz++) {
+				rc = camera_io_dev_read(&e_ctrl->io_master_info,
+					emap[j].mem_rl.addr, &sz_read,
+					emap[j].mem_rl.addr_type,
+					emap[j].mem_rl.data_type);
 				if (rc) {
 					CAM_ERR(CAM_EEPROM, "read failed rc %d",
 						rc);
 					return rc;
 				}
-				memptr += emap[j].mem.valid_size;
+				*memptr = (uint8_t)sz_read;
+				memptr++;
 			}
 		}
 
@@ -407,9 +408,6 @@ static int32_t cam_eeprom_update_slaveInfo(struct cam_eeprom_ctrl_t *e_ctrl,
 	cmd_i2c_info = (struct cam_cmd_i2c_info *)cmd_buf;
 	soc_private->i2c_info.slave_addr = cmd_i2c_info->slave_addr;
 	soc_private->i2c_info.i2c_freq_mode = cmd_i2c_info->i2c_freq_mode;
-	if (strlen(cmd_i2c_info->eeprom_name) != 0) {
-		strcpy(soc_private->i2c_info.eeprom_name, cmd_i2c_info->eeprom_name);
-	}
 
 	rc = cam_eeprom_update_i2c_info(e_ctrl,
 		&soc_private->i2c_info);
@@ -445,6 +443,7 @@ static int32_t cam_eeprom_parse_memory_map(
 	uint16_t                           cmd_length_in_bytes = 0;
 	struct cam_cmd_i2c_random_wr      *i2c_random_wr = NULL;
 	struct cam_cmd_i2c_continuous_rd  *i2c_cont_rd = NULL;
+	struct cam_cmd_i2c_random_rd      *i2c_random_rd = NULL;
 	struct cam_cmd_conditional_wait   *i2c_poll = NULL;
 	struct cam_cmd_unconditional_wait *i2c_uncond_wait = NULL;
 	size_t                             validate_size = 0;
@@ -455,6 +454,8 @@ static int32_t cam_eeprom_parse_memory_map(
 		validate_size = sizeof(struct cam_cmd_i2c_random_wr);
 	else if (cmm_hdr->cmd_type == CAMERA_SENSOR_CMD_TYPE_I2C_CONT_RD)
 		validate_size = sizeof(struct cam_cmd_i2c_continuous_rd);
+	else if (cmm_hdr->cmd_type == CAMERA_SENSOR_CMD_TYPE_I2C_RNDM_RD)
+		validate_size = sizeof(struct cam_cmd_i2c_random_rd);
 	else if (cmm_hdr->cmd_type == CAMERA_SENSOR_CMD_TYPE_WAIT)
 		validate_size = sizeof(struct cam_cmd_unconditional_wait);
 
@@ -521,6 +522,25 @@ static int32_t cam_eeprom_parse_memory_map(
 			cmd_length_in_bytes;
 		data->num_data += map[*num_map].mem.valid_size;
 		break;
+	case CAMERA_SENSOR_CMD_TYPE_I2C_RNDM_RD:
+		i2c_random_rd = (struct cam_cmd_i2c_random_rd *)cmd_buf;
+		cmd_length_in_bytes = sizeof(struct cam_cmd_i2c_random_rd) - sizeof(int32_t);
+
+		if (i2c_random_rd->header.count >= U32_MAX - data->num_data) {
+			CAM_ERR(CAM_EEPROM,
+				"int overflow on eeprom memory block");
+			return -EINVAL;
+		}
+		map[*num_map].mem_rl.addr = i2c_random_rd->data_read[0].reg_data;
+		map[*num_map].mem_rl.addr_type = i2c_random_rd->header.addr_type;
+		map[*num_map].mem_rl.data_type = i2c_random_rd->header.data_type;
+		map[*num_map].mem_rl.valid_size =
+			i2c_random_rd->header.count;
+		cmd_buf += cmd_length_in_bytes / sizeof(int32_t);
+		processed_size +=
+			cmd_length_in_bytes;
+		data->num_data += map[*num_map].mem_rl.valid_size;
+		break;
 	case CAMERA_SENSOR_CMD_TYPE_WAIT:
 		if (generic_op_code ==
 			CAMERA_SENSOR_WAIT_OP_HW_UCND ||
@@ -1050,6 +1070,7 @@ static int32_t cam_eeprom_init_pkt_parser(struct cam_eeprom_ctrl_t *e_ctrl,
 				break;
 			case CAMERA_SENSOR_CMD_TYPE_I2C_RNDM_WR:
 			case CAMERA_SENSOR_CMD_TYPE_I2C_CONT_RD:
+			case CAMERA_SENSOR_CMD_TYPE_I2C_RNDM_RD:
 			case CAMERA_SENSOR_CMD_TYPE_WAIT:
 				num_map++;
 				rc = cam_eeprom_parse_memory_map(

drivers/cam_sensor_module/cam_eeprom/cam_eeprom_dev.h

@@ -63,6 +63,7 @@ struct cam_eeprom_map_t {
  * @pageen          :   pageen memory
  * @poll            :   poll memory
  * @mem             :   mem
+ * @mem_rl          :   mem_rl: used for operation READ_LOOP
  * @saddr           :   slave addr
  *
  */
@@ -71,6 +72,7 @@ struct cam_eeprom_memory_map_t {
 	struct cam_eeprom_map_t pageen;
 	struct cam_eeprom_map_t poll;
 	struct cam_eeprom_map_t mem;
+	struct cam_eeprom_map_t mem_rl;
 	uint32_t saddr;
 };
 
@@ -111,7 +113,6 @@ struct cam_eeprom_cmm_t {
  *
  */
 struct cam_eeprom_i2c_info_t {
-	char eeprom_name[MAX_OIS_NAME_SIZE];
 	uint16_t slave_addr;
 	uint8_t i2c_freq_mode;
 };

include/uapi/media/cam_sensor.h

@@ -102,7 +102,6 @@ struct cam_cmd_i2c_info {
 	uint32_t    slave_addr;
 	uint8_t     i2c_freq_mode;
 	uint8_t     cmd_type;
-	char        eeprom_name[MAX_OIS_NAME_SIZE];
 	uint16_t    reserved;
 } __attribute__((packed));