static int msm_pmem_table_add(struct hlist_head *ptype, struct msm_pmem_info *info, struct ion_client *client) { unsigned long paddr; #ifndef CONFIG_MSM_MULTIMEDIA_USE_ION unsigned long kvstart; struct file *file; #endif int rc = -ENOMEM; unsigned long len; struct msm_pmem_region *region; region = kmalloc(sizeof(struct msm_pmem_region), GFP_KERNEL); if (!region) goto out; #ifdef CONFIG_MSM_MULTIMEDIA_USE_ION region->handle = ion_import_dma_buf(client, info->fd); if (IS_ERR_OR_NULL(region->handle)) goto out1; if (ion_map_iommu(client, region->handle, CAMERA_DOMAIN, GEN_POOL, SZ_4K, 0, &paddr, &len, 0, 0) < 0) goto out2; #else paddr = 0; file = NULL; kvstart = 0; #endif if (!info->len) info->len = len; paddr += info->offset; len = info->len; if (check_overlap(ptype, paddr, len) < 0) { rc = -EINVAL; goto out3; } CDBG("%s: type %d, active flag %d, paddr 0x%lx, vaddr 0x%lx\n", __func__, info->type, info->active, paddr, (unsigned long)info->vaddr); INIT_HLIST_NODE(®ion->list); region->paddr = paddr; region->len = len; memcpy(®ion->info, info, sizeof(region->info)); D("%s Adding region to list with type %d\n", __func__, region->info.type); D("%s pmem_stats address is 0x%p\n", __func__, ptype); hlist_add_head(&(region->list), ptype); return 0; out3: #ifdef CONFIG_MSM_MULTIMEDIA_USE_ION ion_unmap_iommu(client, region->handle, CAMERA_DOMAIN, GEN_POOL); #endif #ifdef CONFIG_MSM_MULTIMEDIA_USE_ION out2: ion_free(client, region->handle); #endif out1: kfree(region); out: return rc; }
void msm_io_w(u32 data, void __iomem *addr) { CDBG("%s: %08x %08x\n", __func__, (int) (addr), (data)); writel_relaxed((data), (addr)); }
void msm_io_memcpy(void __iomem *dest_addr, void __iomem *src_addr, u32 len) { CDBG("%s: %p %p %d\n", __func__, dest_addr, src_addr, len); msm_io_memcpy_toio(dest_addr, src_addr, len / 4); msm_io_dump(dest_addr, len); }
static int32_t msm_sensor_get_dt_data(struct device_node *of_node, struct msm_sensor_ctrl_t *s_ctrl) { int32_t rc = 0, i = 0, ret = 0; struct msm_camera_gpio_conf *gconf = NULL; struct msm_camera_sensor_board_info *sensordata = NULL; uint16_t *gpio_array = NULL; uint16_t gpio_array_size = 0; uint32_t id_info[3]; s_ctrl->sensordata = kzalloc(sizeof( struct msm_camera_sensor_board_info), GFP_KERNEL); if (!s_ctrl->sensordata) { pr_err("%s failed %d\n", __func__, __LINE__); return -ENOMEM; } sensordata = s_ctrl->sensordata; rc = of_property_read_string(of_node, "qcom,sensor-name", &sensordata->sensor_name); CDBG("%s qcom,sensor-name %s, rc %d\n", __func__, sensordata->sensor_name, rc); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto FREE_SENSORDATA; } rc = of_property_read_u32(of_node, "qcom,cci-master", &s_ctrl->cci_i2c_master); CDBG("%s qcom,cci-master %d, rc %d\n", __func__, s_ctrl->cci_i2c_master, rc); if (rc < 0) { /* Set default master 0 */ s_ctrl->cci_i2c_master = MASTER_0; rc = 0; } rc = msm_sensor_get_sub_module_index(of_node, &sensordata->sensor_info); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto FREE_SENSORDATA; } /* Get sensor mount angle */ rc = of_property_read_u32(of_node, "qcom,mount-angle", &sensordata->sensor_info->sensor_mount_angle); CDBG("%s qcom,mount-angle %d, rc %d\n", __func__, sensordata->sensor_info->sensor_mount_angle, rc); if (rc < 0) { /* Invalidate mount angle flag */ pr_err("%s Default sensor mount angle %d\n", __func__, __LINE__); sensordata->sensor_info->is_mount_angle_valid = 0; sensordata->sensor_info->sensor_mount_angle = 0; rc = 0; } else { sensordata->sensor_info->is_mount_angle_valid = 1; } rc = of_property_read_u32(of_node, "qcom,sensor-position", &sensordata->sensor_info->position); CDBG("%s qcom,sensor-position %d, rc %d\n", __func__, sensordata->sensor_info->position, rc); if (rc < 0) { pr_err("%s Default sensor position %d\n", __func__, __LINE__); sensordata->sensor_info->position = 0; rc = 0; } rc = of_property_read_u32(of_node, "qcom,sensor-mode", &sensordata->sensor_info->modes_supported); CDBG("%s qcom,sensor-mode %d, rc %d\n", __func__, sensordata->sensor_info->modes_supported, rc); if (rc < 0) { pr_err("%s Default sensor mode %d\n", __func__, __LINE__); sensordata->sensor_info->modes_supported = 0; rc = 0; } rc = msm_sensor_get_dt_csi_data(of_node, &sensordata->csi_lane_params); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto FREE_SENSOR_INFO; } rc = msm_camera_get_dt_vreg_data(of_node, &sensordata->power_info.cam_vreg, &sensordata->power_info.num_vreg); if (rc < 0) goto FREE_CSI; rc = msm_camera_get_dt_power_setting_data(of_node, sensordata->power_info.cam_vreg, sensordata->power_info.num_vreg, &sensordata->power_info); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto FREE_VREG; } #if !defined(CONFIG_SONY_CAM_V4L2) rc = msm_camera_get_power_settimgs_from_sensor_lib( &sensordata->power_info, &s_ctrl->power_setting_array); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto FREE_VREG; } #endif sensordata->power_info.gpio_conf = kzalloc( sizeof(struct msm_camera_gpio_conf), GFP_KERNEL); if (!sensordata->power_info.gpio_conf) { pr_err("%s failed %d\n", __func__, __LINE__); rc = -ENOMEM; goto FREE_PS; } gconf = sensordata->power_info.gpio_conf; gpio_array_size = of_gpio_count(of_node); CDBG("%s gpio count %d\n", __func__, gpio_array_size); if (gpio_array_size) { gpio_array = kzalloc(sizeof(uint16_t) * gpio_array_size, GFP_KERNEL); if (!gpio_array) { pr_err("%s failed %d\n", __func__, __LINE__); goto FREE_GPIO_CONF; } for (i = 0; i < gpio_array_size; i++) { gpio_array[i] = of_get_gpio(of_node, i); CDBG("%s gpio_array[%d] = %d\n", __func__, i, gpio_array[i]); } rc = msm_camera_get_dt_gpio_req_tbl(of_node, gconf, gpio_array, gpio_array_size); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto FREE_GPIO_CONF; } rc = msm_camera_get_dt_gpio_set_tbl(of_node, gconf, gpio_array, gpio_array_size); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto FREE_GPIO_REQ_TBL; } rc = msm_camera_init_gpio_pin_tbl(of_node, gconf, gpio_array, gpio_array_size); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto FREE_GPIO_SET_TBL; } } rc = msm_sensor_get_dt_actuator_data(of_node, &sensordata->actuator_info); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto FREE_GPIO_PIN_TBL; } sensordata->slave_info = kzalloc(sizeof(struct msm_camera_slave_info), GFP_KERNEL); if (!sensordata->slave_info) { pr_err("%s failed %d\n", __func__, __LINE__); rc = -ENOMEM; goto FREE_ACTUATOR_INFO; } rc = of_property_read_u32_array(of_node, "qcom,slave-id", id_info, 3); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto FREE_SLAVE_INFO; } sensordata->slave_info->sensor_slave_addr = id_info[0]; sensordata->slave_info->sensor_id_reg_addr = id_info[1]; sensordata->slave_info->sensor_id = id_info[2]; CDBG("%s:%d slave addr %x sensor reg %x id %x\n", __func__, __LINE__, sensordata->slave_info->sensor_slave_addr, sensordata->slave_info->sensor_id_reg_addr, sensordata->slave_info->sensor_id); /*Optional property, don't return error if absent */ ret = of_property_read_string(of_node, "qcom,vdd-cx-name", &sensordata->misc_regulator); CDBG("%s qcom,misc_regulator %s, rc %d\n", __func__, sensordata->misc_regulator, ret); kfree(gpio_array); return rc; FREE_SLAVE_INFO: kfree(s_ctrl->sensordata->slave_info); FREE_ACTUATOR_INFO: kfree(s_ctrl->sensordata->actuator_info); FREE_GPIO_PIN_TBL: kfree(s_ctrl->sensordata->power_info.gpio_conf->gpio_num_info); FREE_GPIO_SET_TBL: kfree(s_ctrl->sensordata->power_info.gpio_conf->cam_gpio_set_tbl); FREE_GPIO_REQ_TBL: kfree(s_ctrl->sensordata->power_info.gpio_conf->cam_gpio_req_tbl); FREE_GPIO_CONF: kfree(s_ctrl->sensordata->power_info.gpio_conf); FREE_PS: kfree(s_ctrl->sensordata->power_info.power_setting); kfree(s_ctrl->sensordata->power_info.power_down_setting); FREE_VREG: kfree(s_ctrl->sensordata->power_info.cam_vreg); FREE_CSI: kfree(s_ctrl->sensordata->csi_lane_params); FREE_SENSOR_INFO: kfree(s_ctrl->sensordata->sensor_info); FREE_SENSORDATA: kfree(s_ctrl->sensordata); kfree(gpio_array); return rc; }
static int mm_camera_stream_util_reg_buf(mm_camera_obj_t * my_obj, mm_camera_stream_t *stream, mm_camera_buf_def_t *vbuf) { int32_t i, rc = MM_CAMERA_OK, j; int *ret; struct v4l2_requestbuffers bufreq; int image_type; uint8_t num_planes; uint32_t planes[VIDEO_MAX_PLANES]; if(vbuf->num > MM_CAMERA_MAX_NUM_FRAMES) { rc = -MM_CAMERA_E_GENERAL; CDBG_ERROR("%s: buf num %d > max limit %d\n", __func__, vbuf->num, MM_CAMERA_MAX_NUM_FRAMES); goto end; } switch(stream->stream_type) { case MM_CAMERA_STREAM_PREVIEW: image_type = OUTPUT_TYPE_P; break; case MM_CAMERA_STREAM_SNAPSHOT: case MM_CAMERA_STREAM_RAW: image_type = OUTPUT_TYPE_S; break; case MM_CAMERA_STREAM_THUMBNAIL: image_type = OUTPUT_TYPE_T; break; case MM_CAMERA_STREAM_VIDEO: default: image_type = OUTPUT_TYPE_V; break; } stream->frame.frame_len = mm_camera_get_msm_frame_len(stream->cam_fmt, my_obj->current_mode, stream->fmt.fmt.pix.width, stream->fmt.fmt.pix.height, image_type, &num_planes, planes); if(stream->frame.frame_len == 0) { CDBG_ERROR("%s:incorrect frame size = %d\n", __func__, stream->frame.frame_len); rc = -1; goto end; } stream->frame.num_frame = vbuf->num; bufreq.count = stream->frame.num_frame; bufreq.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; bufreq.memory = V4L2_MEMORY_USERPTR; CDBG("%s: calling VIDIOC_REQBUFS - fd=%d, num_buf=%d, type=%d, memory=%d\n", __func__,stream->fd, bufreq.count, bufreq.type, bufreq.memory); rc = ioctl(stream->fd, VIDIOC_REQBUFS, &bufreq); if (rc < 0) { CDBG_ERROR("%s: fd=%d, ioctl VIDIOC_REQBUFS failed: rc=%d\n", __func__, stream->fd, rc); goto end; } CDBG("%s: stream fd=%d, ioctl VIDIOC_REQBUFS: memtype = %d," "num_frames = %d, rc=%d\n", __func__, stream->fd, bufreq.memory, bufreq.count, rc); for(i = 0; i < vbuf->num; i++){ vbuf->buf.mp[i].idx = i; /* remember the index to stream frame if first time qbuf */ memcpy(&stream->frame.frame[i].frame, &(vbuf->buf.mp[i].frame), sizeof(vbuf->buf.mp[i].frame)); stream->frame.frame[i].idx = i; stream->frame.frame[i].num_planes = vbuf->buf.mp[i].num_planes; for(j = 0; j < vbuf->buf.mp[i].num_planes; j++) { stream->frame.frame[i].planes[j] = vbuf->buf.mp[i].planes[j]; } if(vbuf->buf.mp[i].frame_offset) { stream->frame.frame_offset[i] = vbuf->buf.mp[i].frame_offset; } else { stream->frame.frame_offset[i] = 0; } rc = mm_camera_stream_qbuf(my_obj, stream, stream->frame.frame[i].idx); if (rc < 0) { CDBG_ERROR("%s: VIDIOC_QBUF rc = %d\n", __func__, rc); goto end; } stream->frame.ref_count[i] = 0; CDBG("%s: stream_fd = %d, frame_fd = %d, frame ID = %d, offset = %d\n", __func__, stream->fd, stream->frame.frame[i].frame.fd, i, stream->frame.frame_offset[i]); } stream->frame.qbuf = 1; end: return rc; }
int32_t msm_sensor_power_up(struct msm_sensor_ctrl_t *s_ctrl) { int32_t rc = 0; struct msm_camera_sensor_info *data = s_ctrl->sensordata; CDBG("%s: %d\n", __func__, __LINE__); s_ctrl->reg_ptr = kzalloc(sizeof(struct regulator *) * data->sensor_platform_info->num_vreg, GFP_KERNEL); if (!s_ctrl->reg_ptr) { pr_err("%s: could not allocate mem for regulators\n", __func__); return -ENOMEM; } rc = msm_camera_request_gpio_table(data, 1); if (rc < 0) { pr_err("%s: request gpio failed\n", __func__); goto request_gpio_failed; } rc = msm_camera_config_vreg(&s_ctrl->sensor_i2c_client->client->dev, s_ctrl->sensordata->sensor_platform_info->cam_vreg, s_ctrl->sensordata->sensor_platform_info->num_vreg, s_ctrl->reg_ptr, 1); if (rc < 0) { pr_err("%s: regulator on failed\n", __func__); goto config_vreg_failed; } rc = msm_camera_enable_vreg(&s_ctrl->sensor_i2c_client->client->dev, s_ctrl->sensordata->sensor_platform_info->cam_vreg, s_ctrl->sensordata->sensor_platform_info->num_vreg, s_ctrl->reg_ptr, 1); if (rc < 0) { pr_err("%s: enable regulator failed\n", __func__); goto enable_vreg_failed; } rc = msm_camera_config_gpio_table(data, 1); if (rc < 0) { pr_err("%s: config gpio failed\n", __func__); goto config_gpio_failed; } if (s_ctrl->clk_rate != 0) cam_clk_info->clk_rate = s_ctrl->clk_rate; rc = msm_cam_clk_enable(&s_ctrl->sensor_i2c_client->client->dev, cam_clk_info, &s_ctrl->cam_clk, ARRAY_SIZE(cam_clk_info), 1); if (rc < 0) { pr_err("%s: clk enable failed\n", __func__); goto enable_clk_failed; } usleep_range(1000, 2000); if (data->sensor_platform_info->ext_power_ctrl != NULL) data->sensor_platform_info->ext_power_ctrl(1); if (data->sensor_platform_info->i2c_conf && data->sensor_platform_info->i2c_conf->use_i2c_mux) msm_sensor_enable_i2c_mux(data->sensor_platform_info->i2c_conf); return rc; enable_clk_failed: msm_camera_config_gpio_table(data, 0); config_gpio_failed: msm_camera_enable_vreg(&s_ctrl->sensor_i2c_client->client->dev, s_ctrl->sensordata->sensor_platform_info->cam_vreg, s_ctrl->sensordata->sensor_platform_info->num_vreg, s_ctrl->reg_ptr, 0); enable_vreg_failed: msm_camera_config_vreg(&s_ctrl->sensor_i2c_client->client->dev, s_ctrl->sensordata->sensor_platform_info->cam_vreg, s_ctrl->sensordata->sensor_platform_info->num_vreg, s_ctrl->reg_ptr, 0); config_vreg_failed: msm_camera_request_gpio_table(data, 0); request_gpio_failed: kfree(s_ctrl->reg_ptr); return rc; }
static int32_t msm_cci_data_queue(struct cci_device *cci_dev, struct msm_camera_cci_ctrl *c_ctrl, enum cci_i2c_queue_t queue) { uint16_t i = 0, j = 0, k = 0, h = 0, len = 0; int32_t rc = 0; uint32_t cmd = 0, delay = 0; uint8_t data[11]; uint16_t reg_addr = 0; struct msm_camera_i2c_reg_setting *i2c_msg = &c_ctrl->cfg.cci_i2c_write_cfg; uint16_t cmd_size = i2c_msg->size; struct msm_camera_i2c_reg_array *i2c_cmd = i2c_msg->reg_setting; enum cci_i2c_master_t master = c_ctrl->cci_info->cci_i2c_master; if (i2c_cmd == NULL) { pr_err("%s:%d Failed line\n", __func__, __LINE__); return -EINVAL; } if ((!cmd_size) || (cmd_size > CCI_I2C_MAX_WRITE)) { pr_err("%s:%d Failed line\n", __func__, __LINE__); return -EINVAL; } CDBG("%s addr type %d data type %d\n", __func__, i2c_msg->addr_type, i2c_msg->data_type); if (i2c_msg->addr_type >= MSM_CAMERA_I2C_ADDR_TYPE_MAX) { pr_err("%s failed line %d\n", __func__, __LINE__); return -EINVAL; } if (i2c_msg->data_type >= MSM_CAMERA_I2C_DATA_TYPE_MAX) { pr_err("%s failed line %d\n", __func__, __LINE__); return -EINVAL; } reg_addr = i2c_cmd->reg_addr; while (cmd_size) { CDBG("%s cmd_size %d addr 0x%x data 0x%x\n", __func__, cmd_size, i2c_cmd->reg_addr, i2c_cmd->reg_data); delay = i2c_cmd->delay; data[i++] = CCI_I2C_WRITE_CMD; /* in case of multiple command * MSM_CCI_I2C_WRITE : address is not continuous, so update * address for a new packet. * MSM_CCI_I2C_WRITE_SEQ : address is continuous, need to keep * the incremented address for a * new packet */ if (c_ctrl->cmd == MSM_CCI_I2C_WRITE) reg_addr = i2c_cmd->reg_addr; /* either byte or word addr */ if (i2c_msg->addr_type == MSM_CAMERA_I2C_BYTE_ADDR) data[i++] = reg_addr; else { data[i++] = (reg_addr & 0xFF00) >> 8; data[i++] = reg_addr & 0x00FF; } /* max of 10 data bytes */ do { if (i2c_msg->data_type == MSM_CAMERA_I2C_BYTE_DATA) { data[i++] = i2c_cmd->reg_data; reg_addr++; } else { if ((i + 1) <= 10) { data[i++] = (i2c_cmd->reg_data & 0xFF00) >> 8; /* MSB */ data[i++] = i2c_cmd->reg_data & 0x00FF; /* LSB */ reg_addr += 2; } else break; } i2c_cmd++; --cmd_size; } while ((c_ctrl->cmd == MSM_CCI_I2C_WRITE_SEQ) &&
int msm_camera_init_gpio_pin_tbl(struct device_node *of_node, struct msm_camera_gpio_conf *gconf, uint16_t *gpio_array, uint16_t gpio_array_size) { int rc = 0, val = 0; gconf->gpio_num_info = kzalloc(sizeof(struct msm_camera_gpio_num_info), GFP_KERNEL); if (!gconf->gpio_num_info) { pr_err("%s failed %d\n", __func__, __LINE__); rc = -ENOMEM; return rc; } if (of_property_read_bool(of_node, "qcom,gpio-vdig") == true) { rc = of_property_read_u32(of_node, "qcom,gpio-vdig", &val); if (rc < 0) { pr_err("%s:%d read qcom,gpio-reset failed rc %d\n", __func__, __LINE__, rc); goto ERROR; } else if (val >= gpio_array_size) { pr_err("%s:%d qcom,gpio-reset invalid %d\n", __func__, __LINE__, val); goto ERROR; } gconf->gpio_num_info->gpio_num[SENSOR_GPIO_VDIG] = gpio_array[val]; gconf->gpio_num_info->valid[SENSOR_GPIO_VDIG] = 1; CDBG("%s qcom,gpio-reset %d\n", __func__, gconf->gpio_num_info->gpio_num[SENSOR_GPIO_VDIG]); } if (of_property_read_bool(of_node, "qcom,gpio-reset") == true) { rc = of_property_read_u32(of_node, "qcom,gpio-reset", &val); if (rc < 0) { pr_err("%s:%d read qcom,gpio-reset failed rc %d\n", __func__, __LINE__, rc); goto ERROR; } else if (val >= gpio_array_size) { pr_err("%s:%d qcom,gpio-reset invalid %d\n", __func__, __LINE__, val); goto ERROR; } gconf->gpio_num_info->gpio_num[SENSOR_GPIO_RESET] = gpio_array[val]; gconf->gpio_num_info->valid[SENSOR_GPIO_RESET] = 1; CDBG("%s qcom,gpio-reset %d\n", __func__, gconf->gpio_num_info->gpio_num[SENSOR_GPIO_RESET]); } if (of_property_read_bool(of_node, "qcom,gpio-standby") == true) { rc = of_property_read_u32(of_node, "qcom,gpio-standby", &val); if (rc < 0) { pr_err("%s:%d read qcom,gpio-standby failed rc %d\n", __func__, __LINE__, rc); goto ERROR; } else if (val >= gpio_array_size) { pr_err("%s:%d qcom,gpio-standby invalid %d\n", __func__, __LINE__, val); goto ERROR; } gconf->gpio_num_info->gpio_num[SENSOR_GPIO_STANDBY] = gpio_array[val]; gconf->gpio_num_info->valid[SENSOR_GPIO_STANDBY] = 1; CDBG("%s qcom,gpio-reset %d\n", __func__, gconf->gpio_num_info->gpio_num[SENSOR_GPIO_STANDBY]); } if (of_property_read_bool(of_node, "qcom,gpio-flash-en") == true) { rc = of_property_read_u32(of_node, "qcom,gpio-flash-en", &val); if (rc < 0) { pr_err("%s:%d read qcom,gpio-flash-en failed rc %d\n", __func__, __LINE__, rc); goto ERROR; } else if (val >= gpio_array_size) { pr_err("%s:%d qcom,gpio-flash-en invalid %d\n", __func__, __LINE__, val); goto ERROR; } gconf->gpio_num_info->gpio_num[SENSOR_GPIO_FL_EN] = gpio_array[val]; gconf->gpio_num_info->valid[SENSOR_GPIO_FL_EN] = 1; CDBG("%s qcom,gpio-flash-en %d\n", __func__, gconf->gpio_num_info->gpio_num[SENSOR_GPIO_FL_EN]); } if (of_property_read_bool(of_node, "qcom,gpio-flash-now") == true) { rc = of_property_read_u32(of_node, "qcom,gpio-flash-now", &val); if (rc < 0) { pr_err("%s:%d read qcom,gpio-flash-now failed rc %d\n", __func__, __LINE__, rc); goto ERROR; } else if (val >= gpio_array_size) { pr_err("%s:%d qcom,gpio-flash-now invalid %d\n", __func__, __LINE__, val); goto ERROR; } gconf->gpio_num_info->gpio_num[SENSOR_GPIO_FL_NOW] = gpio_array[val]; gconf->gpio_num_info->valid[SENSOR_GPIO_FL_NOW] = 1; CDBG("%s qcom,gpio-flash-now %d\n", __func__, gconf->gpio_num_info->gpio_num[SENSOR_GPIO_FL_NOW]); } if (of_property_read_bool(of_node, "qcom,gpio-vana") == true) { rc = of_property_read_u32(of_node, "qcom,gpio-vana", &val); if (rc < 0) { pr_err("%s:%d read qcom,gpio-vana failed rc %d\n", __func__, __LINE__, rc); goto ERROR; } else if (val >= gpio_array_size) { pr_err("%s:%d qcom,gpio-vana invalid %d\n", __func__, __LINE__, val); goto ERROR; } gconf->gpio_num_info->gpio_num[SENSOR_GPIO_VANA] = gpio_array[val]; gconf->gpio_num_info->valid[SENSOR_GPIO_VANA] = 1; CDBG("%s qcom,gpio-vana %d\n", __func__, gconf->gpio_num_info->gpio_num[SENSOR_GPIO_VANA]); } if (of_property_read_bool(of_node, "qcom,gpio-vio") == true) { rc = of_property_read_u32(of_node, "qcom,gpio-vio", &val); if (rc < 0) { pr_err("%s:%d read qcom,gpio-vio failed rc %d\n", __func__, __LINE__, rc); goto ERROR; } else if (val >= gpio_array_size) { pr_err("%s:%d qcom,gpio-vio invalid %d\n", __func__, __LINE__, val); goto ERROR; } gconf->gpio_num_info->gpio_num[SENSOR_GPIO_VIO] = gpio_array[val]; gconf->gpio_num_info->valid[SENSOR_GPIO_VIO] = 1; CDBG("%s qcom,gpio-vio %d\n", __func__, gconf->gpio_num_info->gpio_num[SENSOR_GPIO_VIO]); } if (of_property_read_bool(of_node, "qcom,gpio-vaf") == true) { rc = of_property_read_u32(of_node, "qcom,gpio-vaf", &val); if (rc < 0) { pr_err("%s:%d read qcom,gpio-vaf failed rc %d\n", __func__, __LINE__, rc); goto ERROR; } else if (val >= gpio_array_size) { pr_err("%s:%d qcom,gpio-vaf invalid %d\n", __func__, __LINE__, val); goto ERROR; } gconf->gpio_num_info->gpio_num[SENSOR_GPIO_VAF] = gpio_array[val]; gconf->gpio_num_info->valid[SENSOR_GPIO_VAF] = 1; CDBG("%s qcom,gpio-vaf %d\n", __func__, gconf->gpio_num_info->gpio_num[SENSOR_GPIO_VAF]); } if (of_property_read_bool(of_node, "qcom,gpio-ois-ldo") == true) { rc = of_property_read_u32(of_node, "qcom,gpio-ois-ldo", &val); if (rc < 0) { pr_err("%s:%d read qcom,gpio-ois-ldo failed rc %d\n", __func__, __LINE__, rc); goto ERROR; } else if (val >= gpio_array_size) { pr_err("%s:%d qcom,gpio-ois-ldo invalid %d\n", __func__, __LINE__, val); goto ERROR; } gconf->gpio_num_info->gpio_num[SENSOR_GPIO_OIS_LDO_EN] = gpio_array[val]; gconf->gpio_num_info->valid[SENSOR_GPIO_OIS_LDO_EN] = 1; CDBG("%s qcom,gpio-ois-ldo %d\n", __func__, gconf->gpio_num_info->gpio_num[SENSOR_GPIO_OIS_LDO_EN]); } if (of_property_read_bool(of_node, "qcom,gpio-ois-reset") == true) { rc = of_property_read_u32(of_node, "qcom,gpio-ois-reset", &val); if (rc < 0) { pr_err("%s:%d read qcom,gpio-ois-reset failed rc %d\n", __func__, __LINE__, rc); goto ERROR; } else if (val >= gpio_array_size) { pr_err("%s:%d qcom,gpio-ois-reset invalid %d\n", __func__, __LINE__, val); goto ERROR; } gconf->gpio_num_info->gpio_num[SENSOR_GPIO_OIS_RESET] = gpio_array[val]; gconf->gpio_num_info->valid[SENSOR_GPIO_OIS_RESET] = 1; CDBG("%s qcom,gpio-ois-reset %d\n", __func__, gconf->gpio_num_info->gpio_num[SENSOR_GPIO_OIS_RESET]); } if (of_property_read_bool(of_node, "qcom,gpio-ldaf-en") == true) { rc = of_property_read_u32(of_node, "qcom,gpio-ldaf-en", &val); if (rc < 0) { pr_err("%s:%d read qcom,gpio-ldaf-en failed rc %d\n", __func__, __LINE__, rc); goto ERROR; } else if (val >= gpio_array_size) { pr_err("%s:%d qcom,gpio-ldaf-en invalid %d\n", __func__, __LINE__, val); goto ERROR; } gconf->gpio_num_info->gpio_num[SENSOR_GPIO_LDAF_EN] = gpio_array[val]; gconf->gpio_num_info->valid[SENSOR_GPIO_LDAF_EN] = 1; CDBG("%s qcom,gpio-ldaf-en %d\n", __func__, gconf->gpio_num_info->gpio_num[SENSOR_GPIO_LDAF_EN]); } return rc; ERROR: kfree(gconf->gpio_num_info); gconf->gpio_num_info = NULL; return rc; }
int msm_camera_get_dt_vreg_data(struct device_node *of_node, struct camera_vreg_t **cam_vreg, int *num_vreg) { int rc = 0, i = 0; uint32_t count = 0; uint32_t *vreg_array = NULL; struct camera_vreg_t *vreg = NULL; count = of_property_count_strings(of_node, "qcom,cam-vreg-name"); CDBG("%s qcom,cam-vreg-name count %d\n", __func__, count); if (!count) return 0; vreg = kzalloc(sizeof(*vreg) * count, GFP_KERNEL); if (!vreg) { pr_err("%s failed %d\n", __func__, __LINE__); return -ENOMEM; } *cam_vreg = vreg; *num_vreg = count; for (i = 0; i < count; i++) { rc = of_property_read_string_index(of_node, "qcom,cam-vreg-name", i, &vreg[i].reg_name); CDBG("%s reg_name[%d] = %s\n", __func__, i, vreg[i].reg_name); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto ERROR1; } } vreg_array = kzalloc(sizeof(uint32_t) * count, GFP_KERNEL); if (!vreg_array) { pr_err("%s failed %d\n", __func__, __LINE__); rc = -ENOMEM; goto ERROR1; } rc = of_property_read_u32_array(of_node, "qcom,cam-vreg-type", vreg_array, count); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto ERROR2; } for (i = 0; i < count; i++) { vreg[i].type = vreg_array[i]; CDBG("%s cam_vreg[%d].type = %d\n", __func__, i, vreg[i].type); } rc = of_property_read_u32_array(of_node, "qcom,cam-vreg-min-voltage", vreg_array, count); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto ERROR2; } for (i = 0; i < count; i++) { vreg[i].min_voltage = vreg_array[i]; CDBG("%s cam_vreg[%d].min_voltage = %d\n", __func__, i, vreg[i].min_voltage); } rc = of_property_read_u32_array(of_node, "qcom,cam-vreg-max-voltage", vreg_array, count); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto ERROR2; } for (i = 0; i < count; i++) { vreg[i].max_voltage = vreg_array[i]; CDBG("%s cam_vreg[%d].max_voltage = %d\n", __func__, i, vreg[i].max_voltage); } rc = of_property_read_u32_array(of_node, "qcom,cam-vreg-op-mode", vreg_array, count); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto ERROR2; } for (i = 0; i < count; i++) { vreg[i].op_mode = vreg_array[i]; CDBG("%s cam_vreg[%d].op_mode = %d\n", __func__, i, vreg[i].op_mode); } kfree(vreg_array); return rc; ERROR2: kfree(vreg_array); ERROR1: kfree(vreg); *num_vreg = 0; return rc; }
int msm_camera_get_dt_power_setting_data(struct device_node *of_node, struct camera_vreg_t *cam_vreg, int num_vreg, struct msm_camera_power_ctrl_t *power_info) { int rc = 0, i, j; int count = 0; const char *seq_name = NULL; uint32_t *array = NULL; struct msm_sensor_power_setting *ps; struct msm_sensor_power_setting *power_setting; uint16_t *power_setting_size, size = 0; bool need_reverse = 0; if (!power_info) return -EINVAL; power_setting = power_info->power_setting; power_setting_size = &power_info->power_setting_size; count = of_property_count_strings(of_node, "qcom,cam-power-seq-type"); *power_setting_size = count; CDBG("%s qcom,cam-power-seq-type count %d\n", __func__, count); if (count <= 0) return 0; ps = kzalloc(sizeof(*ps) * count, GFP_KERNEL); if (!ps) { pr_err("%s failed %d\n", __func__, __LINE__); return -ENOMEM; } power_setting = ps; power_info->power_setting = ps; for (i = 0; i < count; i++) { rc = of_property_read_string_index(of_node, "qcom,cam-power-seq-type", i, &seq_name); CDBG("%s seq_name[%d] = %s\n", __func__, i, seq_name); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto ERROR1; } if (!strcmp(seq_name, "sensor_vreg")) { ps[i].seq_type = SENSOR_VREG; CDBG("%s:%d seq_type[%d] %d\n", __func__, __LINE__, i, ps[i].seq_type); } else if (!strcmp(seq_name, "sensor_gpio")) { ps[i].seq_type = SENSOR_GPIO; CDBG("%s:%d seq_type[%d] %d\n", __func__, __LINE__, i, ps[i].seq_type); } else if (!strcmp(seq_name, "sensor_clk")) { ps[i].seq_type = SENSOR_CLK; CDBG("%s:%d seq_type[%d] %d\n", __func__, __LINE__, i, ps[i].seq_type); } else if (!strcmp(seq_name, "sensor_i2c_mux")) { ps[i].seq_type = SENSOR_I2C_MUX; CDBG("%s:%d seq_type[%d] %d\n", __func__, __LINE__, i, ps[i].seq_type); } else { CDBG("%s: unrecognized seq-type\n", __func__); rc = -EILSEQ; goto ERROR1; } } for (i = 0; i < count; i++) { rc = of_property_read_string_index(of_node, "qcom,cam-power-seq-val", i, &seq_name); CDBG("%s seq_name[%d] = %s\n", __func__, i, seq_name); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto ERROR1; } switch (ps[i].seq_type) { case SENSOR_VREG: for (j = 0; j < num_vreg; j++) { if (!strcmp(seq_name, cam_vreg[j].reg_name)) break; } if (j < num_vreg) ps[i].seq_val = j; else rc = -EILSEQ; break; case SENSOR_GPIO: if (!strcmp(seq_name, "sensor_gpio_reset")) ps[i].seq_val = SENSOR_GPIO_RESET; else if (!strcmp(seq_name, "sensor_gpio_standby")) ps[i].seq_val = SENSOR_GPIO_STANDBY; else if (!strcmp(seq_name, "sensor_gpio_vdig")) ps[i].seq_val = SENSOR_GPIO_VDIG; else if (!strcmp(seq_name, "sensor_gpio_vio")) ps[i].seq_val = SENSOR_GPIO_VIO; else if (!strcmp(seq_name, "sensor_gpio_vana")) ps[i].seq_val = SENSOR_GPIO_VANA; else if (!strcmp(seq_name, "sensor_gpio_vaf")) ps[i].seq_val = SENSOR_GPIO_VAF; else rc = -EILSEQ; break; case SENSOR_CLK: if (!strcmp(seq_name, "sensor_cam_mclk")) ps[i].seq_val = SENSOR_CAM_MCLK; else if (!strcmp(seq_name, "sensor_cam_clk")) ps[i].seq_val = SENSOR_CAM_CLK; else rc = -EILSEQ; break; case SENSOR_I2C_MUX: if (!strcmp(seq_name, "none")) ps[i].seq_val = 0; else rc = -EILSEQ; break; default: rc = -EILSEQ; break; } if (rc < 0) { CDBG("%s: unrecognized seq-val\n", __func__); goto ERROR1; } } array = kzalloc(sizeof(uint32_t) * count, GFP_KERNEL); if (!array) { pr_err("%s failed %d\n", __func__, __LINE__); rc = -ENOMEM; goto ERROR1; } rc = of_property_read_u32_array(of_node, "qcom,cam-power-seq-cfg-val", array, count); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto ERROR2; } for (i = 0; i < count; i++) { if (ps[i].seq_type == SENSOR_GPIO) { if (array[i] == 0) ps[i].config_val = GPIO_OUT_LOW; else if (array[i] == 1) ps[i].config_val = GPIO_OUT_HIGH; } else { ps[i].config_val = array[i]; } CDBG("%s power_setting[%d].config_val = %ld\n", __func__, i, ps[i].config_val); } rc = of_property_read_u32_array(of_node, "qcom,cam-power-seq-delay", array, count); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto ERROR2; } for (i = 0; i < count; i++) { ps[i].delay = array[i]; CDBG("%s power_setting[%d].delay = %d\n", __func__, i, ps[i].delay); } kfree(array); size = *power_setting_size; if (NULL != ps && 0 != size) need_reverse = 1; power_info->power_down_setting = kzalloc(sizeof(*ps) * size, GFP_KERNEL); if (!power_info->power_down_setting) { pr_err("%s failed %d\n", __func__, __LINE__); rc = -ENOMEM; goto ERROR1; } memcpy(power_info->power_down_setting, ps, sizeof(*ps) * size); power_info->power_down_setting_size = size; if (need_reverse) { int c, end = size - 1; struct msm_sensor_power_setting power_down_setting_t; for (c = 0; c < size/2; c++) { power_down_setting_t = power_info->power_down_setting[c]; power_info->power_down_setting[c] = power_info->power_down_setting[end]; power_info->power_down_setting[end] = power_down_setting_t; end--; } } return rc; ERROR2: kfree(array); ERROR1: kfree(ps); power_setting_size = 0; return rc; }
int msm_camera_get_dt_gpio_set_tbl(struct device_node *of_node, struct msm_camera_gpio_conf *gconf, uint16_t *gpio_array, uint16_t gpio_array_size) { int rc = 0, i = 0; uint32_t count = 0; uint32_t *val_array = NULL; if (!of_get_property(of_node, "qcom,gpio-set-tbl-num", &count)) return 0; count /= sizeof(uint32_t); if (!count) { pr_err("%s qcom,gpio-set-tbl-num 0\n", __func__); return 0; } val_array = kzalloc(sizeof(uint32_t) * count, GFP_KERNEL); if (!val_array) { pr_err("%s failed %d\n", __func__, __LINE__); return -ENOMEM; } gconf->cam_gpio_set_tbl = kzalloc(sizeof(struct msm_gpio_set_tbl) * count, GFP_KERNEL); if (!gconf->cam_gpio_set_tbl) { pr_err("%s failed %d\n", __func__, __LINE__); rc = -ENOMEM; goto ERROR1; } gconf->cam_gpio_set_tbl_size = count; rc = of_property_read_u32_array(of_node, "qcom,gpio-set-tbl-num", val_array, count); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto ERROR2; } for (i = 0; i < count; i++) { if (val_array[i] >= gpio_array_size) { pr_err("%s gpio set tbl index %d invalid\n", __func__, val_array[i]); return -EINVAL; } gconf->cam_gpio_set_tbl[i].gpio = gpio_array[val_array[i]]; CDBG("%s cam_gpio_set_tbl[%d].gpio = %d\n", __func__, i, gconf->cam_gpio_set_tbl[i].gpio); } rc = of_property_read_u32_array(of_node, "qcom,gpio-set-tbl-flags", val_array, count); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto ERROR2; } for (i = 0; i < count; i++) { gconf->cam_gpio_set_tbl[i].flags = val_array[i]; CDBG("%s cam_gpio_set_tbl[%d].flags = %ld\n", __func__, i, gconf->cam_gpio_set_tbl[i].flags); } rc = of_property_read_u32_array(of_node, "qcom,gpio-set-tbl-delay", val_array, count); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto ERROR2; } for (i = 0; i < count; i++) { gconf->cam_gpio_set_tbl[i].delay = val_array[i]; CDBG("%s cam_gpio_set_tbl[%d].delay = %d\n", __func__, i, gconf->cam_gpio_set_tbl[i].delay); } kfree(val_array); return rc; ERROR2: kfree(gconf->cam_gpio_set_tbl); ERROR1: kfree(val_array); gconf->cam_gpio_set_tbl_size = 0; return rc; }
int msm_camera_power_down(struct msm_camera_power_ctrl_t *ctrl, enum msm_camera_device_type_t device_type, struct msm_camera_i2c_client *sensor_i2c_client) { int index = 0; struct msm_sensor_power_setting *pd = NULL; struct msm_sensor_power_setting *ps; CDBG("%s:%d\n", __func__, __LINE__); if (!ctrl || !sensor_i2c_client) { pr_err("failed ctrl %p sensor_i2c_client %p\n", ctrl, sensor_i2c_client); return -EINVAL; } if (device_type == MSM_CAMERA_PLATFORM_DEVICE) sensor_i2c_client->i2c_func_tbl->i2c_util( sensor_i2c_client, MSM_CCI_RELEASE); for (index = 0; index < ctrl->power_down_setting_size; index++) { CDBG("%s index %d\n", __func__, index); pd = &ctrl->power_down_setting[index]; ps = NULL; CDBG("%s type %d\n", __func__, pd->seq_type); switch (pd->seq_type) { case SENSOR_CLK: ps = msm_camera_get_power_settings(ctrl, pd->seq_type, pd->seq_val); if (ps) msm_cam_clk_enable(ctrl->dev, &ctrl->clk_info[0], (struct clk **)&ps->data[0], ctrl->clk_info_size, 0); else pr_err("%s error in power up/down seq data\n", __func__); break; case SENSOR_GPIO: if (pd->seq_val >= SENSOR_GPIO_MAX || !ctrl->gpio_conf->gpio_num_info) { pr_err("%s gpio index %d >= max %d\n", __func__, pd->seq_val, SENSOR_GPIO_MAX); continue; } #if defined(CONFIG_MACH_LGE) if((pd->seq_val == SENSOR_GPIO_RESET || pd->seq_val == SENSOR_GPIO_OIS_RESET) && ctrl->gpio_conf->gpio_num_info->gpio_num[pd->config_val] != GPIO_OUT_LOW) { pr_err("%s skip seq_val = %d, value = %d\n", __func__, pd->seq_val, ctrl->gpio_conf->gpio_num_info->gpio_num[pd->config_val]); continue; } #endif if (!ctrl->gpio_conf->gpio_num_info->valid [pd->seq_val]) continue; gpio_set_value_cansleep( ctrl->gpio_conf->gpio_num_info->gpio_num [pd->seq_val], ctrl->gpio_conf->gpio_num_info->gpio_num [pd->config_val]); break; case SENSOR_VREG: if (pd->seq_val >= CAM_VREG_MAX) { pr_err("%s vreg index %d >= max %d\n", __func__, pd->seq_val, SENSOR_GPIO_MAX); continue; } ps = msm_camera_get_power_settings(ctrl, pd->seq_type, pd->seq_val); if (ps) msm_camera_config_single_vreg(ctrl->dev, &ctrl->cam_vreg[pd->seq_val], (struct regulator **)&ps->data[0], 0); else pr_err("%s error in power up/down seq data\n", __func__); break; case SENSOR_I2C_MUX: if (ctrl->i2c_conf && ctrl->i2c_conf->use_i2c_mux) msm_camera_disable_i2c_mux(ctrl->i2c_conf); break; default: pr_err("%s error power seq type %d\n", __func__, pd->seq_type); break; } if (pd->delay > 20) { msleep(pd->delay); } else if (pd->delay) { usleep_range(pd->delay * 1000, (pd->delay * 1000) + 1000); } } msm_camera_request_gpio_table( ctrl->gpio_conf->cam_gpio_req_tbl, ctrl->gpio_conf->cam_gpio_req_tbl_size, 0); CDBG("%s exit\n", __func__); return 0; }
int msm_camera_power_up(struct msm_camera_power_ctrl_t *ctrl, enum msm_camera_device_type_t device_type, struct msm_camera_i2c_client *sensor_i2c_client) { int rc = 0, index = 0, no_gpio = 0; struct msm_sensor_power_setting *power_setting = NULL; CDBG("%s:%d\n", __func__, __LINE__); if (!ctrl || !sensor_i2c_client) { pr_err("failed ctrl %p sensor_i2c_client %p\n", ctrl, sensor_i2c_client); return -EINVAL; } if (ctrl->gpio_conf->cam_gpiomux_conf_tbl != NULL) { pr_err("%s:%d mux install\n", __func__, __LINE__); msm_gpiomux_install( (struct msm_gpiomux_config *) ctrl->gpio_conf->cam_gpiomux_conf_tbl, ctrl->gpio_conf->cam_gpiomux_conf_tbl_size); } rc = msm_camera_request_gpio_table( ctrl->gpio_conf->cam_gpio_req_tbl, ctrl->gpio_conf->cam_gpio_req_tbl_size, 1); if (rc < 0) no_gpio = rc; for (index = 0; index < ctrl->power_setting_size; index++) { CDBG("%s index %d\n", __func__, index); power_setting = &ctrl->power_setting[index]; CDBG("%s type %d\n", __func__, power_setting->seq_type); if(!power_setting) { CDBG("power_setting is null\n"); continue; } switch (power_setting->seq_type) { case SENSOR_CLK: if (power_setting->seq_val >= ctrl->clk_info_size) { pr_err("%s clk index %d >= max %d\n", __func__, power_setting->seq_val, ctrl->clk_info_size); goto power_up_failed; } if (power_setting->config_val) ctrl->clk_info[power_setting->seq_val]. clk_rate = power_setting->config_val; rc = msm_cam_clk_enable(ctrl->dev, &ctrl->clk_info[0], (struct clk **)&power_setting->data[0], ctrl->clk_info_size, 1); if (rc < 0) { pr_err("%s: clk enable failed\n", __func__); goto power_up_failed; } break; case SENSOR_GPIO: if (no_gpio) { pr_err("%s: request gpio failed\n", __func__); return no_gpio; } if (power_setting->seq_val >= SENSOR_GPIO_MAX || !ctrl->gpio_conf->gpio_num_info) { pr_err("%s gpio index %d >= max %d\n", __func__, power_setting->seq_val, SENSOR_GPIO_MAX); goto power_up_failed; } if (!ctrl->gpio_conf->gpio_num_info->valid [power_setting->seq_val]) continue; CDBG("%s:%d gpio set val %d\n", __func__, __LINE__, ctrl->gpio_conf->gpio_num_info->gpio_num [power_setting->seq_val]); gpio_set_value_cansleep( ctrl->gpio_conf->gpio_num_info->gpio_num [power_setting->seq_val], power_setting->config_val); break; case SENSOR_VREG: if (power_setting->seq_val >= CAM_VREG_MAX) { pr_err("%s vreg index %d >= max %d\n", __func__, power_setting->seq_val, SENSOR_GPIO_MAX); goto power_up_failed; } msm_camera_config_single_vreg(ctrl->dev, &ctrl->cam_vreg[power_setting->seq_val], (struct regulator **)&power_setting->data[0], 1); break; case SENSOR_I2C_MUX: if (ctrl->i2c_conf && ctrl->i2c_conf->use_i2c_mux) msm_camera_enable_i2c_mux(ctrl->i2c_conf); break; default: pr_err("%s error power seq type %d\n", __func__, power_setting->seq_type); break; } if (power_setting->delay > 20) { msleep(power_setting->delay); } else if (power_setting->delay) { usleep_range(power_setting->delay * 1000, (power_setting->delay * 1000) + 1000); } } if (device_type == MSM_CAMERA_PLATFORM_DEVICE) { rc = sensor_i2c_client->i2c_func_tbl->i2c_util( sensor_i2c_client, MSM_CCI_INIT); if (rc < 0) { pr_err("%s cci_init failed\n", __func__); goto power_up_failed; } } CDBG("%s exit\n", __func__); return 0; power_up_failed: pr_err("%s:%d failed\n", __func__, __LINE__); for (index--; index >= 0; index--) { CDBG("%s index %d\n", __func__, index); power_setting = &ctrl->power_setting[index]; CDBG("%s type %d\n", __func__, power_setting->seq_type); switch (power_setting->seq_type) { case SENSOR_CLK: msm_cam_clk_enable(ctrl->dev, &ctrl->clk_info[0], (struct clk **)&power_setting->data[0], ctrl->clk_info_size, 0); break; case SENSOR_GPIO: if (!ctrl->gpio_conf->gpio_num_info->valid [power_setting->seq_val]) continue; gpio_set_value_cansleep( ctrl->gpio_conf->gpio_num_info->gpio_num [power_setting->seq_val], GPIOF_OUT_INIT_LOW); break; case SENSOR_VREG: msm_camera_config_single_vreg(ctrl->dev, &ctrl->cam_vreg[power_setting->seq_val], (struct regulator **)&power_setting->data[0], 0); break; case SENSOR_I2C_MUX: if (ctrl->i2c_conf && ctrl->i2c_conf->use_i2c_mux) msm_camera_disable_i2c_mux(ctrl->i2c_conf); break; default: pr_err("%s error power seq type %d\n", __func__, power_setting->seq_type); break; } if (power_setting->delay > 20) { msleep(power_setting->delay); } else if (power_setting->delay) { usleep_range(power_setting->delay * 1000, (power_setting->delay * 1000) + 1000); } } msm_camera_request_gpio_table( ctrl->gpio_conf->cam_gpio_req_tbl, ctrl->gpio_conf->cam_gpio_req_tbl_size, 0); return rc; }
int msm_sensor_get_sub_module_index(struct device_node *of_node, struct msm_sensor_info_t **s_info) { int rc = 0, i = 0; uint32_t val = 0, count = 0; uint32_t *val_array = NULL; struct device_node *src_node = NULL; struct msm_sensor_info_t *sensor_info; sensor_info = kzalloc(sizeof(*sensor_info), GFP_KERNEL); if (!sensor_info) { pr_err("%s:%d failed\n", __func__, __LINE__); return -ENOMEM; } for (i = 0; i < SUB_MODULE_MAX; i++) sensor_info->subdev_id[i] = -1; src_node = of_parse_phandle(of_node, "qcom,actuator-src", 0); if (!src_node) { CDBG("%s:%d src_node NULL\n", __func__, __LINE__); } else { rc = of_property_read_u32(src_node, "cell-index", &val); CDBG("%s qcom,actuator cell index %d, rc %d\n", __func__, val, rc); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto ERROR; } sensor_info->subdev_id[SUB_MODULE_ACTUATOR] = val; of_node_put(src_node); src_node = NULL; } src_node = of_parse_phandle(of_node, "qcom,eeprom-src", 0); if (!src_node) { CDBG("%s:%d eeprom src_node NULL\n", __func__, __LINE__); } else { rc = of_property_read_u32(src_node, "cell-index", &val); CDBG("%s qcom,eeprom cell index %d, rc %d\n", __func__, val, rc); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto ERROR; } sensor_info->subdev_id[SUB_MODULE_EEPROM] = val; of_node_put(src_node); src_node = NULL; } if (of_property_read_bool(of_node, "qcom,eeprom-sd-index") == true) { rc = of_property_read_u32(of_node, "qcom,eeprom-sd-index", &val); CDBG("%s qcom,eeprom-sd-index %d, rc %d\n", __func__, val, rc); if (rc < 0) { pr_err("%s:%d failed rc %d\n", __func__, __LINE__, rc); goto ERROR; } sensor_info->subdev_id[SUB_MODULE_EEPROM] = val; } src_node = of_parse_phandle(of_node, "qcom,led-flash-src", 0); if (!src_node) { CDBG("%s:%d src_node NULL\n", __func__, __LINE__); } else { rc = of_property_read_u32(src_node, "cell-index", &val); CDBG("%s qcom,led flash cell index %d, rc %d\n", __func__, val, rc); if (rc < 0) { pr_err("%s:%d failed %d\n", __func__, __LINE__, rc); goto ERROR; } sensor_info->subdev_id[SUB_MODULE_LED_FLASH] = val; of_node_put(src_node); src_node = NULL; } if (of_property_read_bool(of_node, "qcom,strobe-flash-sd-index") == true) { rc = of_property_read_u32(of_node, "qcom,strobe-flash-sd-index", &val); CDBG("%s qcom,strobe-flash-sd-index %d, rc %d\n", __func__, val, rc); if (rc < 0) { pr_err("%s:%d failed rc %d\n", __func__, __LINE__, rc); goto ERROR; } sensor_info->subdev_id[SUB_MODULE_STROBE_FLASH] = val; } if (of_get_property(of_node, "qcom,csiphy-sd-index", &count)) { count /= sizeof(uint32_t); if (count > 2) { pr_err("%s qcom,csiphy-sd-index count %d > 2\n", __func__, count); goto ERROR; } val_array = kzalloc(sizeof(uint32_t) * count, GFP_KERNEL); if (!val_array) { pr_err("%s failed %d\n", __func__, __LINE__); rc = -ENOMEM; goto ERROR; } rc = of_property_read_u32_array(of_node, "qcom,csiphy-sd-index", val_array, count); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); kfree(val_array); goto ERROR; } for (i = 0; i < count; i++) { sensor_info->subdev_id[SUB_MODULE_CSIPHY + i] = val_array[i]; CDBG("%s csiphy_core[%d] = %d\n", __func__, i, val_array[i]); } kfree(val_array); } else { pr_err("%s:%d qcom,csiphy-sd-index not present\n", __func__, __LINE__); rc = -EINVAL; goto ERROR; } if (of_get_property(of_node, "qcom,csid-sd-index", &count)) { count /= sizeof(uint32_t); if (count > 2) { pr_err("%s qcom,csid-sd-index count %d > 2\n", __func__, count); rc = -EINVAL; goto ERROR; } val_array = kzalloc(sizeof(uint32_t) * count, GFP_KERNEL); if (!val_array) { pr_err("%s failed %d\n", __func__, __LINE__); rc = -ENOMEM; goto ERROR; } rc = of_property_read_u32_array(of_node, "qcom,csid-sd-index", val_array, count); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); kfree(val_array); goto ERROR; } for (i = 0; i < count; i++) { sensor_info->subdev_id [SUB_MODULE_CSID + i] = val_array[i]; CDBG("%s csid_core[%d] = %d\n", __func__, i, val_array[i]); } kfree(val_array); } else { pr_err("%s:%d qcom,csid-sd-index not present\n", __func__, __LINE__); rc = -EINVAL; goto ERROR; } *s_info = sensor_info; return rc; ERROR: kfree(sensor_info); return rc; }
static int vfe_config(struct msm_vfe_cfg_cmd_t *cmd, void *data) { struct msm_pmem_region *regptr; struct msm_vfe_command_8k vfecmd; uint32_t i; void *cmd_data = NULL; long rc = 0; struct vfe_cmd_axi_output_config *axio = NULL; struct vfe_cmd_stats_setting *scfg_t = NULL; 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(struct msm_vfe_command_8k))) return -EFAULT; } CDBG("vfe_config: cmdType = %d\n", 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: { struct axidata_t *axid; axid = data; if (!axid) return -EFAULT; scfg_t = kmalloc(sizeof(struct vfe_cmd_stats_setting), GFP_ATOMIC); if (!scfg_t) return -ENOMEM; if (copy_from_user(scfg_t, (void __user *)(vfecmd.value), vfecmd.length)) { kfree(scfg_t); return -EFAULT; } regptr = axid->region; if (axid->bufnum1 > 0) { for (i = 0; i < axid->bufnum1; i++) { scfg_t->awbBuffer[i] = (uint32_t)(regptr->paddr); regptr++; } } if (axid->bufnum2 > 0) { for (i = 0; i < axid->bufnum2; i++) { scfg_t->afBuffer[i] = (uint32_t)(regptr->paddr); regptr++; } } vfe_stats_setting(scfg_t); } break; case CMD_FRAME_BUF_RELEASE: { /* preview buffer release */ struct msm_frame_t *b; unsigned long p; struct vfe_cmd_output_ack fack; if (!data) return -EFAULT; b = (struct msm_frame_t *)(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; case CMD_SNAP_BUF_RELEASE: { } break; case CMD_STATS_BUF_RELEASE: { struct vfe_cmd_stats_wb_exp_ack sack; if (!data) return -EFAULT; sack.nextWbExpOutputBufferAddr = *(uint32_t *)data; vfe_stats_wb_exp_ack(&sack); } break; case CMD_STATS_AF_BUF_RELEASE: { struct vfe_cmd_stats_af_ack ack; if (!data) return -EFAULT; ack.nextAFOutputBufferAddr = *(uint32_t *)data; vfe_stats_af_ack(&ack); } break; case CMD_AXI_CFG_OUT1: { struct axidata_t *axid; axid = data; if (!axid) return -EFAULT; axio = kmalloc(sizeof(struct vfe_cmd_axi_output_config), GFP_ATOMIC); if (!axio) return -ENOMEM; if (copy_from_user(axio, (void __user *)(vfecmd.value), sizeof(struct vfe_cmd_axi_output_config))) { kfree(axio); return -EFAULT; } vfe_config_axi(OUTPUT_1, axid, axio); vfe_axi_output_config(axio); } break; case CMD_AXI_CFG_OUT2: case CMD_RAW_PICT_AXI_CFG: { struct axidata_t *axid; axid = data; if (!axid) return -EFAULT; axio = kmalloc(sizeof(struct vfe_cmd_axi_output_config), GFP_ATOMIC); if (!axio) return -ENOMEM; if (copy_from_user(axio, (void __user *)(vfecmd.value), sizeof(struct vfe_cmd_axi_output_config))) { kfree(axio); return -EFAULT; } vfe_config_axi(OUTPUT_2, axid, axio); vfe_axi_output_config(axio); } break; case CMD_AXI_CFG_SNAP_O1_AND_O2: { struct axidata_t *axid; axid = data; if (!axid) return -EFAULT; axio = kmalloc(sizeof(struct vfe_cmd_axi_output_config), GFP_ATOMIC); if (!axio) return -ENOMEM; if (copy_from_user(axio, (void __user *)(vfecmd.value), sizeof(struct vfe_cmd_axi_output_config))) { kfree(axio); return -EFAULT; } vfe_config_axi(OUTPUT_1_AND_2, axid, axio); vfe_axi_output_config(axio); cmd_data = axio; } break; default: break; } /* switch */ kfree(scfg_t); kfree(axio); /* if (cmd->length > 256 && cmd_data && (cmd->cmd_type == CMD_GENERAL || cmd->cmd_type == CMD_STATS_DISABLE)) { kfree(cmd_data); } */ return rc; }
int32_t imx132_sensor_power_up(struct msm_sensor_ctrl_t *s_ctrl) { int32_t rc = 0; struct msm_camera_sensor_info *data = s_ctrl->sensordata; CDBG("%s: %d\n", __func__, __LINE__); #ifdef LGIT_IEF_SWITCH if(system_state != SYSTEM_BOOTING) { mipi_lgit_lcd_ief_off(); } #endif s_ctrl->reg_ptr = kzalloc(sizeof(struct regulator *) * data->sensor_platform_info->num_vreg, GFP_KERNEL); if (!s_ctrl->reg_ptr) { pr_err("%s: could not allocate mem for regulators\n", __func__); return -ENOMEM; } pr_err("%s: before request gpio, sensor name : %s", __func__, s_ctrl->sensordata->sensor_name); rc = msm_camera_request_gpio_table(data, 1); if (rc < 0) { pr_err("%s: request gpio failed\n", __func__); goto request_gpio_failed; } rc = gpio_request(MSM_VT_PWR_EN, "VT_PWR_EN"); rc = gpio_request(MSM_CAM2_RST_EN, "VTCAM_RST_EN"); if (rc) { LDBGE("%s: PM request gpio failed\n", __func__); } rc = msm_camera_config_vreg(&s_ctrl->sensor_i2c_client->client->dev, s_ctrl->sensordata->sensor_platform_info->cam_vreg, s_ctrl->sensordata->sensor_platform_info->num_vreg, s_ctrl->vreg_seq, s_ctrl->num_vreg_seq, s_ctrl->reg_ptr, 1); if (rc < 0) { LDBGE("%s: regulator on failed\n", __func__); goto config_vreg_failed; } rc =pm8xxx_gpio_config(MSM_VT_PWR_EN, &gpio35_param); rc =pm8xxx_gpio_config(MSM_CAM2_RST_EN, &gpio28_param); if (rc) { LDBGE("%s: pm8xxx_gpio_config on failed\n", __func__); } rc = gpio_direction_output(MSM_VT_PWR_EN, 0); usleep(5); rc = gpio_direction_output(MSM_VT_PWR_EN, 1); if (rc) { LDBGE("%s: gpio_direction_output enable failed\n", __func__); } rc = msm_camera_enable_vreg(&s_ctrl->sensor_i2c_client->client->dev, s_ctrl->sensordata->sensor_platform_info->cam_vreg, s_ctrl->sensordata->sensor_platform_info->num_vreg, s_ctrl->vreg_seq, s_ctrl->num_vreg_seq, s_ctrl->reg_ptr, 1); if (rc < 0) { LDBGE("%s: enable regulator failed\n", __func__); goto enable_vreg_failed; } usleep(10); rc = gpio_direction_output(MSM_CAM2_RST_EN, 1); if (s_ctrl->clk_rate != 0) imx132_cam_clk_info->clk_rate = s_ctrl->clk_rate; rc = msm_cam_clk_enable(&s_ctrl->sensor_i2c_client->client->dev, imx132_cam_clk_info, s_ctrl->cam_clk, ARRAY_SIZE(imx132_cam_clk_info), 1); if (rc < 0) { LDBGE("%s: clk enable failed\n", __func__); goto enable_clk_failed; } usleep_range(1000, 2000); if (data->sensor_platform_info->ext_power_ctrl != NULL) data->sensor_platform_info->ext_power_ctrl(1); if (data->sensor_platform_info->i2c_conf && data->sensor_platform_info->i2c_conf->use_i2c_mux) imx132_msm_sensor_enable_i2c_mux(data->sensor_platform_info->i2c_conf); return rc; enable_clk_failed: rc = gpio_direction_output(MSM_CAM2_RST_EN, 0); enable_vreg_failed: msm_camera_config_vreg(&s_ctrl->sensor_i2c_client->client->dev, s_ctrl->sensordata->sensor_platform_info->cam_vreg, s_ctrl->sensordata->sensor_platform_info->num_vreg, s_ctrl->vreg_seq, s_ctrl->num_vreg_seq, s_ctrl->reg_ptr, 0); config_vreg_failed: msm_camera_request_gpio_table(data, 0); request_gpio_failed: kfree(s_ctrl->reg_ptr); return rc; }
int32_t msm_sensor_config(struct msm_sensor_ctrl_t *s_ctrl, void __user *argp) { struct sensor_cfg_data cdata; long rc = 0; if (copy_from_user(&cdata, (void *)argp, sizeof(struct sensor_cfg_data))) return -EFAULT; mutex_lock(s_ctrl->msm_sensor_mutex); CDBG("msm_sensor_config: cfgtype = %d\n", cdata.cfgtype); switch (cdata.cfgtype) { case CFG_SET_FPS: case CFG_SET_PICT_FPS: if (s_ctrl->func_tbl-> sensor_set_fps == NULL) { rc = -EFAULT; break; } rc = s_ctrl->func_tbl-> sensor_set_fps( s_ctrl, &(cdata.cfg.fps)); break; case CFG_SET_EXP_GAIN: if (s_ctrl->func_tbl-> sensor_write_exp_gain == NULL) { rc = -EFAULT; break; } rc = s_ctrl->func_tbl-> sensor_write_exp_gain( s_ctrl, cdata.cfg.exp_gain.gain, cdata.cfg.exp_gain.line); s_ctrl->prev_gain = cdata.cfg.exp_gain.gain; s_ctrl->prev_line = cdata.cfg.exp_gain.line; break; case CFG_SET_PICT_EXP_GAIN: if (s_ctrl->func_tbl-> sensor_write_snapshot_exp_gain == NULL) { rc = -EFAULT; break; } rc = s_ctrl->func_tbl-> sensor_write_snapshot_exp_gain( s_ctrl, cdata.cfg.exp_gain.gain, cdata.cfg.exp_gain.line); break; case CFG_SET_MODE: if (s_ctrl->func_tbl-> sensor_set_sensor_mode == NULL) { rc = -EFAULT; break; } rc = s_ctrl->func_tbl-> sensor_set_sensor_mode( s_ctrl, cdata.mode, cdata.rs); break; case CFG_SET_EFFECT: break; case CFG_SENSOR_INIT: if (s_ctrl->func_tbl-> sensor_mode_init == NULL) { rc = -EFAULT; break; } rc = s_ctrl->func_tbl-> sensor_mode_init( s_ctrl, cdata.mode, &(cdata.cfg.init_info)); break; case CFG_GET_OUTPUT_INFO: if (s_ctrl->func_tbl-> sensor_get_output_info == NULL) { rc = -EFAULT; break; } rc = s_ctrl->func_tbl-> sensor_get_output_info( s_ctrl, &cdata.cfg.output_info); if (copy_to_user((void *)argp, &cdata, sizeof(struct sensor_cfg_data))) rc = -EFAULT; break; case CFG_START_STREAM: if (s_ctrl->func_tbl->sensor_start_stream == NULL) { rc = -EFAULT; break; } s_ctrl->func_tbl->sensor_start_stream(s_ctrl); break; case CFG_STOP_STREAM: if (s_ctrl->func_tbl->sensor_stop_stream == NULL) { rc = -EFAULT; break; } s_ctrl->func_tbl->sensor_stop_stream(s_ctrl); break; case CFG_GET_CSI_PARAMS: if (s_ctrl->func_tbl->sensor_get_csi_params == NULL) { rc = -EFAULT; break; } rc = s_ctrl->func_tbl->sensor_get_csi_params( s_ctrl, &cdata.cfg.csi_lane_params); if (copy_to_user((void *)argp, &cdata, sizeof(struct sensor_cfg_data))) rc = -EFAULT; break; default: rc = -EFAULT; break; } mutex_unlock(s_ctrl->msm_sensor_mutex); return rc; }
int32_t imx132_sensor_power_down(struct msm_sensor_ctrl_t *s_ctrl) { int32_t rc = 0; struct msm_camera_sensor_info *data = s_ctrl->sensordata; CDBG("%s\n", __func__); pr_err("%s\n", __func__); /* LGE_CHANGE_S, [email protected], 2012-10-31, Wise screen / Because of the display engine */ sub_cam_id_for_keep_screen_on = -1; /* LGE_CHANGE_E, [email protected], 2012-10-31, Wise screen / Because of the display engine */ /*LGE_UPDATE_S Color Engine Switch for camera, 2012.11.19, [email protected]*/ #ifdef LGIT_COLOR_ENGINE_SWITCH if(system_state != SYSTEM_BOOTING) { mipi_lgit_lcd_color_engine_on(); } #endif /*LGE_UPDATE_E Color Engine Switch for camera, 2012.11.19, [email protected]*/ if (data->sensor_platform_info->i2c_conf && data->sensor_platform_info->i2c_conf->use_i2c_mux) imx132_msm_sensor_disable_i2c_mux( data->sensor_platform_info->i2c_conf); if (data->sensor_platform_info->ext_power_ctrl != NULL) data->sensor_platform_info->ext_power_ctrl(0); msm_cam_clk_enable(&s_ctrl->sensor_i2c_client->client->dev, imx132_cam_clk_info, s_ctrl->cam_clk, ARRAY_SIZE(imx132_cam_clk_info), 0); /* LGE_CHANGE_S, increase timing margin, 2012.06.19, [email protected] */ usleep(5); /* LGE_CHANGE_E, increase timing margin, 2012.06.19, [email protected] */ rc = gpio_direction_output(MSM_CAM2_RST_EN, 0 ); /* LGE_CHANGE_S, Avoid Kernel Panic, 2012.11.12, jungki.kim[Start] */ if(s_ctrl->reg_ptr != NULL) { msm_camera_enable_vreg(&s_ctrl->sensor_i2c_client->client->dev, s_ctrl->sensordata->sensor_platform_info->cam_vreg, s_ctrl->sensordata->sensor_platform_info->num_vreg, s_ctrl->vreg_seq, s_ctrl->num_vreg_seq, s_ctrl->reg_ptr, 0); msm_camera_config_vreg(&s_ctrl->sensor_i2c_client->client->dev, s_ctrl->sensordata->sensor_platform_info->cam_vreg, s_ctrl->sensordata->sensor_platform_info->num_vreg, s_ctrl->vreg_seq, s_ctrl->num_vreg_seq, s_ctrl->reg_ptr, 0); kfree(s_ctrl->reg_ptr); } else { // NULL! LDBGE("%s: No Regulator Pointer!\n", __func__); } /* LGE_CHANGE_E, Avoid Kernel Panic, 2012.11.12, jungki.kim[End] */ rc = gpio_direction_output(MSM_VT_PWR_EN, 0); if (rc) { pr_err("%s: gpio_direction_output enable failed\n", __func__); } msm_camera_request_gpio_table(data, 0); gpio_free(MSM_VT_PWR_EN); gpio_free(MSM_CAM2_RST_EN); return 0; }
static int msm_sensor_debugfs_test_s(void *data, u64 val) { CDBG("val: %llu\n", val); return 0; }
int test_isp_init_modules() { boolean rc = FALSE; mct_module_t *ispif_module = NULL; mct_module_t *isp_module = NULL; mct_port_t *iface_sink_port = NULL; mct_port_t *iface_src_port = NULL; mct_port_t *isp_sink_port = NULL; mct_list_t *srcports, *sinkports; mct_event_t event; uint32_t i = 0; CDBG("%s TEST_ISP: E", __func__); ispif_module = module_iface_init("iface"); CDBG("%s TEST_ISP: module_iface_init = %p", __func__, ispif_module); if (ispif_module== NULL) { CDBG_ERROR("%s: ispif_module = NULL\n", __func__); exit(1); } rc = ispif_module->start_session(ispif_module, session_id); if (rc == FALSE) { CDBG_ERROR("%s: TEST_ISP: ispif_module start error = %d\n", __func__, rc); exit(1); } isp_module = module_isp_init("isp"); CDBG("%s TEST_ISP: module_isp_init = %p", __func__, isp_module); if (isp_module== NULL) { CDBG_ERROR("%s: isp_module = NULL\n", __func__); exit(1); } rc = isp_module->start_session(isp_module, session_id); if (rc == FALSE) { CDBG_ERROR("%s: TEST_ISP: isp_module start error = %d\n", __func__, rc); exit(1); } sinkports = MCT_MODULE_SINKPORTS(ispif_module); CDBG("%s TEST_ISP: ispif MCT_MODULE_SINKPORTS = %p", __func__, sinkports); iface_sink_port = (mct_port_t *)sinkports->data; srcports = MCT_MODULE_SRCPORTS(ispif_module); CDBG("%s TEST_ISP: ispif MCT_MODULE_SRCPORTS = %p", __func__, srcports); iface_src_port = (mct_port_t *)srcports->data; sinkports = MCT_MODULE_SINKPORTS(isp_module); CDBG("%s TEST_ISP: isp MCT_MODULE_SRCPORTS = %p", __func__, sinkports); isp_sink_port = (mct_port_t *)sinkports->data; if (iface_sink_port == NULL || iface_sink_port->direction != MCT_PORT_SINK) { CDBG_ERROR("%s: no iface sink port %p\n", __func__, iface_sink_port); exit(1); } if (iface_src_port == NULL || iface_src_port->direction != MCT_PORT_SRC) { CDBG_ERROR("%s: no iface src port %p\n", __func__, iface_src_port); exit(1); } if (isp_sink_port == NULL || isp_sink_port->direction != MCT_PORT_SINK) { CDBG_ERROR("%s: no isp sink port %p\n", __func__, isp_sink_port); exit(1); } CDBG("%s TEST_ISP: reserve port", __func__); rc = reserve_ports(iface_sink_port, iface_src_port, isp_sink_port); CDBG("%s TEST_ISP: reserve port, rc = %d", __func__, rc); rc = config_isp(iface_sink_port, iface_src_port, isp_sink_port); CDBG("%s TEST_ISP: config_isp, rc = %d", __func__, rc); rc = start_stream(iface_sink_port, iface_src_port, isp_sink_port); CDBG("%s TEST_ISP: start_stream, rc = %d", __func__, rc); CDBG("%s TEST_ISP: X, rc = %d", __func__, rc); return 0; }
int32_t mt9m114_sensor_config(struct msm_sensor_ctrl_t *s_ctrl, void __user *argp) { struct sensorb_cfg_data *cdata = (struct sensorb_cfg_data *)argp; long rc = 0; int32_t i = 0; mutex_lock(s_ctrl->msm_sensor_mutex); CDBG("%s:%d %s cfgtype = %d\n", __func__, __LINE__, s_ctrl->sensordata->sensor_name, cdata->cfgtype); switch (cdata->cfgtype) { case CFG_GET_SENSOR_INFO: memcpy(cdata->cfg.sensor_info.sensor_name, s_ctrl->sensordata->sensor_name, sizeof(cdata->cfg.sensor_info.sensor_name)); cdata->cfg.sensor_info.session_id = s_ctrl->sensordata->sensor_info->session_id; for (i = 0; i < SUB_MODULE_MAX; i++) cdata->cfg.sensor_info.subdev_id[i] = s_ctrl->sensordata->sensor_info->subdev_id[i]; CDBG("%s:%d sensor name %s\n", __func__, __LINE__, cdata->cfg.sensor_info.sensor_name); CDBG("%s:%d session id %d\n", __func__, __LINE__, cdata->cfg.sensor_info.session_id); for (i = 0; i < SUB_MODULE_MAX; i++) CDBG("%s:%d subdev_id[%d] %d\n", __func__, __LINE__, i, cdata->cfg.sensor_info.subdev_id[i]); CDBG("%s:%d mount angle valid %d value %d\n", __func__, __LINE__, cdata->cfg.sensor_info.is_mount_angle_valid, cdata->cfg.sensor_info.sensor_mount_angle); break; case CFG_SET_INIT_SETTING: /* 1. Write Recommend settings */ /* 2. Write change settings */ rc = s_ctrl->sensor_i2c_client->i2c_func_tbl-> i2c_write_conf_tbl( s_ctrl->sensor_i2c_client, mt9m114_recommend_settings, ARRAY_SIZE(mt9m114_recommend_settings), MSM_CAMERA_I2C_WORD_DATA); rc = s_ctrl->sensor_i2c_client->i2c_func_tbl-> i2c_write_conf_tbl( s_ctrl->sensor_i2c_client, mt9m114_config_change_settings, ARRAY_SIZE(mt9m114_config_change_settings), MSM_CAMERA_I2C_WORD_DATA); break; case CFG_SET_RESOLUTION: rc = s_ctrl->sensor_i2c_client->i2c_func_tbl-> i2c_write_conf_tbl( s_ctrl->sensor_i2c_client, mt9m114_720p_settings, ARRAY_SIZE(mt9m114_720p_settings), MSM_CAMERA_I2C_WORD_DATA); break; case CFG_SET_STOP_STREAM: break; case CFG_SET_START_STREAM: rc = s_ctrl->sensor_i2c_client->i2c_func_tbl-> i2c_write_conf_tbl( s_ctrl->sensor_i2c_client, mt9m114_config_change_settings, ARRAY_SIZE(mt9m114_config_change_settings), MSM_CAMERA_I2C_WORD_DATA); break; case CFG_GET_SENSOR_INIT_PARAMS: cdata->cfg.sensor_init_params.modes_supported = s_ctrl->sensordata->sensor_info->modes_supported; cdata->cfg.sensor_init_params.position = s_ctrl->sensordata->sensor_info->position; cdata->cfg.sensor_init_params.sensor_mount_angle = s_ctrl->sensordata->sensor_info->sensor_mount_angle; CDBG("%s:%d init params mode %d pos %d mount %d\n", __func__, __LINE__, cdata->cfg.sensor_init_params.modes_supported, cdata->cfg.sensor_init_params.position, cdata->cfg.sensor_init_params.sensor_mount_angle); break; case CFG_SET_SLAVE_INFO: { struct msm_camera_sensor_slave_info sensor_slave_info; struct msm_camera_power_ctrl_t *p_ctrl; uint16_t size; int slave_index = 0; if (copy_from_user(&sensor_slave_info, (void *)cdata->cfg.setting, sizeof(struct msm_camera_sensor_slave_info))) { pr_err("%s:%d failed\n", __func__, __LINE__); rc = -EFAULT; break; } /* Update sensor slave address */ if (sensor_slave_info.slave_addr) { s_ctrl->sensor_i2c_client->cci_client->sid = sensor_slave_info.slave_addr >> 1; } /* Update sensor address type */ s_ctrl->sensor_i2c_client->addr_type = sensor_slave_info.addr_type; /* Update power up / down sequence */ p_ctrl = &s_ctrl->sensordata->power_info; size = sensor_slave_info.power_setting_array.size; if (p_ctrl->power_setting_size < size) { struct msm_sensor_power_setting *tmp; tmp = kmalloc(sizeof(struct msm_sensor_power_setting) * size, GFP_KERNEL); if (!tmp) { pr_err("%s: failed to alloc mem\n", __func__); rc = -ENOMEM; break; } kfree(p_ctrl->power_setting); p_ctrl->power_setting = tmp; } p_ctrl->power_setting_size = size; rc = copy_from_user(p_ctrl->power_setting, (void *) sensor_slave_info.power_setting_array.power_setting, size * sizeof(struct msm_sensor_power_setting)); if (rc) { pr_err("%s:%d failed\n", __func__, __LINE__); rc = -EFAULT; break; } CDBG("%s sensor id %x\n", __func__, sensor_slave_info.slave_addr); CDBG("%s sensor addr type %d\n", __func__, sensor_slave_info.addr_type); CDBG("%s sensor reg %x\n", __func__, sensor_slave_info.sensor_id_info.sensor_id_reg_addr); CDBG("%s sensor id %x\n", __func__, sensor_slave_info.sensor_id_info.sensor_id); for (slave_index = 0; slave_index < p_ctrl->power_setting_size; slave_index++) { CDBG("%s i %d power setting %d %d %ld %d\n", __func__, slave_index, p_ctrl->power_setting[slave_index].seq_type, p_ctrl->power_setting[slave_index].seq_val, p_ctrl->power_setting[slave_index].config_val, p_ctrl->power_setting[slave_index].delay); } break; } case CFG_WRITE_I2C_ARRAY: { struct msm_camera_i2c_reg_setting conf_array; struct msm_camera_i2c_reg_array *reg_setting = NULL; if (copy_from_user(&conf_array, (void *)cdata->cfg.setting, sizeof(struct msm_camera_i2c_reg_setting))) { pr_err("%s:%d failed\n", __func__, __LINE__); rc = -EFAULT; break; } reg_setting = kzalloc(conf_array.size * (sizeof(struct msm_camera_i2c_reg_array)), GFP_KERNEL); if (!reg_setting) { pr_err("%s:%d failed\n", __func__, __LINE__); rc = -ENOMEM; break; } if (copy_from_user(reg_setting, (void *)conf_array.reg_setting, conf_array.size * sizeof(struct msm_camera_i2c_reg_array))) { pr_err("%s:%d failed\n", __func__, __LINE__); kfree(reg_setting); rc = -EFAULT; break; } conf_array.reg_setting = reg_setting; rc = s_ctrl->sensor_i2c_client->i2c_func_tbl->i2c_write_table( s_ctrl->sensor_i2c_client, &conf_array); kfree(reg_setting); break; } case CFG_WRITE_I2C_SEQ_ARRAY: { struct msm_camera_i2c_seq_reg_setting conf_array; struct msm_camera_i2c_seq_reg_array *reg_setting = NULL; if (copy_from_user(&conf_array, (void *)cdata->cfg.setting, sizeof(struct msm_camera_i2c_seq_reg_setting))) { pr_err("%s:%d failed\n", __func__, __LINE__); rc = -EFAULT; break; } reg_setting = kzalloc(conf_array.size * (sizeof(struct msm_camera_i2c_seq_reg_array)), GFP_KERNEL); if (!reg_setting) { pr_err("%s:%d failed\n", __func__, __LINE__); rc = -ENOMEM; break; } if (copy_from_user(reg_setting, (void *)conf_array.reg_setting, conf_array.size * sizeof(struct msm_camera_i2c_seq_reg_array))) { pr_err("%s:%d failed\n", __func__, __LINE__); kfree(reg_setting); rc = -EFAULT; break; } conf_array.reg_setting = reg_setting; rc = s_ctrl->sensor_i2c_client->i2c_func_tbl-> i2c_write_seq_table(s_ctrl->sensor_i2c_client, &conf_array); kfree(reg_setting); break; } case CFG_POWER_UP: if (s_ctrl->func_tbl->sensor_power_up) rc = s_ctrl->func_tbl->sensor_power_up(s_ctrl); else rc = -EFAULT; break; case CFG_POWER_DOWN: if (s_ctrl->func_tbl->sensor_power_down) rc = s_ctrl->func_tbl->sensor_power_down(s_ctrl); else rc = -EFAULT; break; case CFG_SET_STOP_STREAM_SETTING: { struct msm_camera_i2c_reg_setting *stop_setting = &s_ctrl->stop_setting; struct msm_camera_i2c_reg_array *reg_setting = NULL; if (copy_from_user(stop_setting, (void *)cdata->cfg.setting, sizeof(struct msm_camera_i2c_reg_setting))) { pr_err("%s:%d failed\n", __func__, __LINE__); rc = -EFAULT; break; } reg_setting = stop_setting->reg_setting; stop_setting->reg_setting = kzalloc(stop_setting->size * (sizeof(struct msm_camera_i2c_reg_array)), GFP_KERNEL); if (!stop_setting->reg_setting) { pr_err("%s:%d failed\n", __func__, __LINE__); rc = -ENOMEM; break; } if (copy_from_user(stop_setting->reg_setting, (void *)reg_setting, stop_setting->size * sizeof(struct msm_camera_i2c_reg_array))) { pr_err("%s:%d failed\n", __func__, __LINE__); kfree(stop_setting->reg_setting); stop_setting->reg_setting = NULL; stop_setting->size = 0; rc = -EFAULT; break; } break; } case CFG_SET_SATURATION: { int32_t sat_lev; if (copy_from_user(&sat_lev, (void *)cdata->cfg.setting, sizeof(int32_t))) { pr_err("%s:%d failed\n", __func__, __LINE__); rc = -EFAULT; break; } pr_debug("%s: Saturation Value is %d", __func__, sat_lev); break; } case CFG_SET_CONTRAST: { int32_t con_lev; if (copy_from_user(&con_lev, (void *)cdata->cfg.setting, sizeof(int32_t))) { pr_err("%s:%d failed\n", __func__, __LINE__); rc = -EFAULT; break; } pr_debug("%s: Contrast Value is %d", __func__, con_lev); break; } case CFG_SET_SHARPNESS: { int32_t shp_lev; if (copy_from_user(&shp_lev, (void *)cdata->cfg.setting, sizeof(int32_t))) { pr_err("%s:%d failed\n", __func__, __LINE__); rc = -EFAULT; break; } pr_debug("%s: Sharpness Value is %d", __func__, shp_lev); break; } case CFG_SET_AUTOFOCUS: { /* TO-DO: set the Auto Focus */ pr_debug("%s: Setting Auto Focus", __func__); break; } case CFG_CANCEL_AUTOFOCUS: { /* TO-DO: Cancel the Auto Focus */ pr_debug("%s: Cancelling Auto Focus", __func__); break; } default: rc = -EFAULT; break; }
int32_t imx111_sensor_setting(struct msm_sensor_ctrl_t *s_ctrl, int update_type, int res) { int32_t rc = 0; int linecount; int frame_time,exposure_time; struct msm_sensor_output_info_t curr_info,new_info; curr_info = imx111_dimensions[s_ctrl->curr_res]; new_info = imx111_dimensions[res]; if( res != 0) { v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev, NOTIFY_ISPIF_STREAM, (void *)ISPIF_STREAM( PIX_0, ISPIF_OFF_IMMEDIATELY)); s_ctrl->func_tbl->sensor_stop_stream(s_ctrl); } if (update_type == MSM_SENSOR_REG_INIT) { curr_frame_length_lines = 0; s_ctrl->curr_csi_params = NULL; rc = msm_sensor_enable_debugfs(s_ctrl); if(rc < 0){ CDBG("%s: msm_sensor_enable_debugfs (rc:%d)\n", __func__,rc); } rc = msm_sensor_write_init_settings(s_ctrl); if (rc < 0) { return rc; } } else if (update_type == MSM_SENSOR_UPDATE_PERIODIC) { if( s_ctrl->curr_res != MSM_SENSOR_INVALID_RES) { CDBG("imx111.c %s: setting change %d -> %d\n", __func__, s_ctrl->curr_res,res); if (curr_info.frame_length_lines > curr_frame_length_lines ) { linecount = curr_info.frame_length_lines; } else { linecount = curr_frame_length_lines; } frame_time = 1000/(curr_info.vt_pixel_clk/(curr_info.line_length_pclk*linecount)); if ( res != 0 ) { CDBG("imx111.c %s: current frame_out_time = %d line_length_pclk =%d linecount = %d vt_pixel_clk = %d\n", __func__,frame_time,curr_info.line_length_pclk,linecount,curr_info.vt_pixel_clk); msleep(frame_time); } } curr_frame_length_lines = new_info.frame_length_lines; exposure_time = 1000/(new_info.vt_pixel_clk/(new_info.line_length_pclk*new_info.frame_length_lines)); if( s_ctrl->curr_res != 0 && res == 0) { rc = msm_camera_i2c_write_tbl(s_ctrl->sensor_i2c_client, (struct msm_camera_i2c_reg_conf *) imx111_comm_confs[0].conf, imx111_comm_confs[0].size, imx111_comm_confs[0].data_type); if (rc < 0){ return rc; } rc = msm_sensor_write_res_settings(s_ctrl, res); if (rc < 0){ return rc; } if (s_ctrl->curr_csi_params != s_ctrl->csi_params[res]) { s_ctrl->curr_csi_params = s_ctrl->csi_params[res]; v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev, NOTIFY_CSID_CFG, &s_ctrl->curr_csi_params->csid_params); v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev, NOTIFY_CID_CHANGE, NULL); mb(); v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev, NOTIFY_CSIPHY_CFG, &s_ctrl->curr_csi_params->csiphy_params); mb(); msleep(20); } v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev, NOTIFY_PCLK_CHANGE, &s_ctrl->msm_sensor_reg-> output_settings[res].op_pixel_clk); v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev, NOTIFY_ISPIF_STREAM, (void *)ISPIF_STREAM( PIX_0, ISPIF_ON_FRAME_BOUNDARY)); rc = msm_camera_i2c_write_tbl(s_ctrl->sensor_i2c_client, (struct msm_camera_i2c_reg_conf *) imx111_comm_confs[1].conf, imx111_comm_confs[1].size, imx111_comm_confs[1].data_type); if (rc < 0){ return rc; } s_ctrl->func_tbl->sensor_start_stream(s_ctrl); msleep(10); rc = msm_camera_i2c_write_tbl(s_ctrl->sensor_i2c_client, (struct msm_camera_i2c_reg_conf *) imx111_comm_confs[2].conf, imx111_comm_confs[2].size, imx111_comm_confs[2].data_type); if (rc < 0){ return rc; } } else { rc = msm_sensor_write_res_settings(s_ctrl, res); if(rc < 0){ return rc; } if (s_ctrl->curr_csi_params != s_ctrl->csi_params[res]) { s_ctrl->curr_csi_params = s_ctrl->csi_params[res]; v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev, NOTIFY_CSID_CFG, &s_ctrl->curr_csi_params->csid_params); v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev, NOTIFY_CID_CHANGE, NULL); mb(); v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev, NOTIFY_CSIPHY_CFG, &s_ctrl->curr_csi_params->csiphy_params); mb(); msleep(20); } v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev, NOTIFY_PCLK_CHANGE, &s_ctrl->msm_sensor_reg-> output_settings[res].op_pixel_clk); v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev, NOTIFY_ISPIF_STREAM, (void *)ISPIF_STREAM( PIX_0, ISPIF_ON_FRAME_BOUNDARY)); s_ctrl->func_tbl->sensor_start_stream(s_ctrl); msleep(exposure_time); } } return rc; }
int msm_sensor_config(struct msm_sensor_ctrl_t *s_ctrl, void __user *argp) { struct sensorb_cfg_data *cdata = (struct sensorb_cfg_data *)argp; long rc = 0; int i = 0; mutex_lock(s_ctrl->msm_sensor_mutex); CDBG("%s:%d %s cfgtype = %d\n", __func__, __LINE__, s_ctrl->sensordata->sensor_name, cdata->cfgtype); switch (cdata->cfgtype) { case CFG_GET_SENSOR_INFO: memcpy(cdata->cfg.sensor_info.sensor_name, s_ctrl->sensordata->sensor_name, sizeof(cdata->cfg.sensor_info.sensor_name)); cdata->cfg.sensor_info.session_id = s_ctrl->sensordata->sensor_info->session_id; for (i = 0; i < SUB_MODULE_MAX; i++) cdata->cfg.sensor_info.subdev_id[i] = s_ctrl->sensordata->sensor_info->subdev_id[i]; cdata->cfg.sensor_info.is_mount_angle_valid = s_ctrl->sensordata->sensor_info->is_mount_angle_valid; cdata->cfg.sensor_info.sensor_mount_angle = s_ctrl->sensordata->sensor_info->sensor_mount_angle; cdata->cfg.sensor_info.position = s_ctrl->sensordata->sensor_info->position; cdata->cfg.sensor_info.modes_supported = s_ctrl->sensordata->sensor_info->modes_supported; CDBG("%s:%d sensor name %s\n", __func__, __LINE__, cdata->cfg.sensor_info.sensor_name); CDBG("%s:%d session id %d\n", __func__, __LINE__, cdata->cfg.sensor_info.session_id); for (i = 0; i < SUB_MODULE_MAX; i++) CDBG("%s:%d subdev_id[%d] %d\n", __func__, __LINE__, i, cdata->cfg.sensor_info.subdev_id[i]); CDBG("%s:%d mount angle valid %d value %d\n", __func__, __LINE__, cdata->cfg.sensor_info.is_mount_angle_valid, cdata->cfg.sensor_info.sensor_mount_angle); break; case CFG_GET_SENSOR_INIT_PARAMS: cdata->cfg.sensor_init_params.modes_supported = s_ctrl->sensordata->sensor_info->modes_supported; cdata->cfg.sensor_init_params.position = s_ctrl->sensordata->sensor_info->position; cdata->cfg.sensor_init_params.sensor_mount_angle = s_ctrl->sensordata->sensor_info->sensor_mount_angle; CDBG("%s:%d init params mode %d pos %d mount %d\n", __func__, __LINE__, cdata->cfg.sensor_init_params.modes_supported, cdata->cfg.sensor_init_params.position, cdata->cfg.sensor_init_params.sensor_mount_angle); break; case CFG_SET_SLAVE_INFO: { struct msm_camera_sensor_slave_info sensor_slave_info; struct msm_camera_power_ctrl_t *p_ctrl; uint16_t size; int s_index = 0; if (copy_from_user(&sensor_slave_info, (void *)cdata->cfg.setting, sizeof(sensor_slave_info))) { pr_err("%s:%d failed\n", __func__, __LINE__); rc = -EFAULT; break; } /* Update sensor slave address */ if (sensor_slave_info.slave_addr) { s_ctrl->sensor_i2c_client->cci_client->sid = sensor_slave_info.slave_addr >> 1; } /* Update sensor address type */ s_ctrl->sensor_i2c_client->addr_type = sensor_slave_info.addr_type; p_ctrl = &s_ctrl->sensordata->power_info; /* Update power up sequence */ size = sensor_slave_info.power_setting_array.size; if (p_ctrl->power_setting_size < size) { struct msm_sensor_power_setting *tmp; tmp = kmalloc(sizeof(*tmp) * size, GFP_KERNEL); if (!tmp) { pr_err("%s: failed to alloc mem\n", __func__); rc = -ENOMEM; break; } kfree(p_ctrl->power_setting); p_ctrl->power_setting = tmp; } p_ctrl->power_setting_size = size; rc = copy_from_user(p_ctrl->power_setting, (void *) sensor_slave_info.power_setting_array.power_setting, size * sizeof(struct msm_sensor_power_setting)); if (rc) { pr_err("%s:%d failed\n", __func__, __LINE__); kfree(sensor_slave_info.power_setting_array. power_setting); rc = -EFAULT; break; } CDBG("%s sensor id %x\n", __func__, sensor_slave_info.slave_addr); CDBG("%s sensor addr type %d\n", __func__, sensor_slave_info.addr_type); CDBG("%s sensor reg %x\n", __func__, sensor_slave_info.sensor_id_info.sensor_id_reg_addr); CDBG("%s sensor id %x\n", __func__, sensor_slave_info.sensor_id_info.sensor_id); for (s_index = 0; s_index < p_ctrl->power_setting_size; s_index++) { CDBG("%s i %d power up setting %d %d %ld %d\n", __func__, s_index, p_ctrl->power_setting[s_index].seq_type, p_ctrl->power_setting[s_index].seq_val, p_ctrl->power_setting[s_index].config_val, p_ctrl->power_setting[s_index].delay); } /* Update power down sequence */ if (!sensor_slave_info.power_setting_array.power_down_setting || 0 == size) { pr_err("%s: Missing dedicated power down sequence\n", __func__); break; } size = sensor_slave_info.power_setting_array.size_down; if (p_ctrl->power_down_setting_size < size) { struct msm_sensor_power_setting *tmp; tmp = kmalloc(sizeof(*tmp) * size, GFP_KERNEL); if (!tmp) { pr_err("%s: failed to alloc mem\n", __func__); rc = -ENOMEM; break; } kfree(p_ctrl->power_down_setting); p_ctrl->power_down_setting = tmp; } p_ctrl->power_down_setting_size = size; rc = copy_from_user(p_ctrl->power_down_setting, (void *) sensor_slave_info.power_setting_array. power_down_setting, size * sizeof(struct msm_sensor_power_setting)); if (rc) { pr_err("%s:%d failed\n", __func__, __LINE__); kfree(sensor_slave_info.power_setting_array. power_down_setting); rc = -EFAULT; break; } for (s_index = 0; s_index < p_ctrl->power_down_setting_size; s_index++) { CDBG("%s i %d power DOWN setting %d %d %ld %d\n", __func__, s_index, p_ctrl->power_down_setting[s_index].seq_type, p_ctrl->power_down_setting[s_index].seq_val, p_ctrl->power_down_setting[s_index].config_val, p_ctrl->power_down_setting[s_index].delay); } break; } case CFG_WRITE_I2C_ARRAY: { struct msm_camera_i2c_reg_setting conf_array; struct msm_camera_i2c_reg_array *reg_setting = NULL; if (s_ctrl->sensor_state != MSM_SENSOR_POWER_UP) { pr_err("%s:%d failed: invalid state %d\n", __func__, __LINE__, s_ctrl->sensor_state); rc = -EFAULT; break; } if (copy_from_user(&conf_array, (void *)cdata->cfg.setting, sizeof(struct msm_camera_i2c_reg_setting))) { pr_err("%s:%d failed\n", __func__, __LINE__); rc = -EFAULT; break; } if (!conf_array.size) { pr_err("%s:%d failed\n", __func__, __LINE__); rc = -EFAULT; break; } reg_setting = kzalloc(conf_array.size * (sizeof(struct msm_camera_i2c_reg_array)), GFP_KERNEL); if (!reg_setting) { pr_err("%s:%d failed\n", __func__, __LINE__); rc = -ENOMEM; break; } if (copy_from_user(reg_setting, (void *)conf_array.reg_setting, conf_array.size * sizeof(struct msm_camera_i2c_reg_array))) { pr_err("%s:%d failed\n", __func__, __LINE__); kfree(reg_setting); rc = -EFAULT; break; } conf_array.reg_setting = reg_setting; rc = s_ctrl->sensor_i2c_client->i2c_func_tbl->i2c_write_table( s_ctrl->sensor_i2c_client, &conf_array); kfree(reg_setting); break; } case CFG_SLAVE_READ_I2C: { struct msm_camera_i2c_read_config read_config; uint16_t local_data = 0; uint16_t orig_slave_addr = 0, read_slave_addr = 0; #if defined(CONFIG_SONY_CAM_V4L2) uint16_t orig_addr_type = 0; #endif if (copy_from_user(&read_config, (void *)cdata->cfg.setting, sizeof(struct msm_camera_i2c_read_config))) { pr_err("%s:%d failed\n", __func__, __LINE__); rc = -EFAULT; break; } read_slave_addr = read_config.slave_addr; CDBG("%s:CFG_SLAVE_READ_I2C:", __func__); CDBG("%s:slave_addr=0x%x reg_addr=0x%x, data_type=%d\n", __func__, read_config.slave_addr, read_config.reg_addr, read_config.data_type); if (s_ctrl->sensor_i2c_client->cci_client) { orig_slave_addr = s_ctrl->sensor_i2c_client->cci_client->sid; s_ctrl->sensor_i2c_client->cci_client->sid = read_slave_addr >> 1; } else if (s_ctrl->sensor_i2c_client->client) {
int32_t msm_sensor_imx111_power_down(struct msm_sensor_ctrl_t *s_ctrl) { struct msm_camera_sensor_info *data = s_ctrl->sensordata; CDBG("%s\n", __func__); msleep(IMX111_WAIT_PWOFF_MCLK); gpio_direction_output(IMX111_GPIO_CAM_MCLK0, 0); msm_cam_clk_enable(&s_ctrl->sensor_i2c_client->client->dev, imx111_cam_clk_info, &s_ctrl->cam_clk, ARRAY_SIZE(imx111_cam_clk_info), 0); msm_camera_enable_vreg(&s_ctrl->sensor_i2c_client->client->dev, s_ctrl->sensordata->sensor_platform_info->cam_vreg, s_ctrl->sensordata->sensor_platform_info->num_vreg, s_ctrl->reg_ptr, 0); msm_camera_config_vreg(&s_ctrl->sensor_i2c_client->client->dev, s_ctrl->sensordata->sensor_platform_info->cam_vreg, s_ctrl->sensordata->sensor_platform_info->num_vreg, s_ctrl->reg_ptr, 0); msm_camera_request_gpio_table(data, 0); kfree(s_ctrl->reg_ptr); msleep(IMX111_WAIT_PWOFF_RST_L); gpio_direction_output(data->sensor_platform_info->sensor_reset, 0); gpio_free(data->sensor_platform_info->sensor_reset); msleep(IMX111_WAIT_PWOFF_VREG_L11); if (cam_vana) { regulator_set_optimum_mode(cam_vana, 0); regulator_set_voltage(cam_vana, 0, CAM_VANA_MAXUV); regulator_disable(cam_vana); regulator_put(cam_vana); cam_vana = NULL; } msleep(IMX111_WAIT_PWOFF_V_EN1); gpio_direction_output(IMX111_GPIO_CAM_V_EN1, 0); gpio_free(IMX111_GPIO_CAM_V_EN1); msleep(IMX111_WAIT_PWOFF_V_EN2); gpio_free(IMX111_GPIO_CAM_I2C_SDA); gpio_free(IMX111_GPIO_CAM_I2C_SCL); pm8xxx_gpio_config(IMX111_PMGPIO_CAM_V_EN2, &imx111_cam_v_en2_off); msleep(IMX111_WAIT_PWOFF_V_EN3); gpio_direction_output(IMX111_GPIO_CAM_V_EN3, 0); gpio_free(IMX111_GPIO_CAM_V_EN3); msleep(IMX111_WAIT_PWOFF_VREG_L12); if (cam_vdig) { regulator_set_voltage(cam_vdig, 0, CAM_VDIG_MAXUV); regulator_set_optimum_mode(cam_vdig, 0); regulator_disable(cam_vdig); regulator_put(cam_vdig); cam_vdig = NULL; } return 0; }
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, ®ion[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 = ®ion[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, ®ion[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 = ®ion[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, ®ion[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 = ®ion[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, ®ion[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 = ®ion[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, ®ion[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 = ®ion[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, ®ion[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 = ®ion[0]; return msm_isp_subdev_ioctl(sd, &cfgcmd, &axi_data); case CMD_STATS_AEC_AWB_ENABLE: axi_data.bufnum1 = msm_pmem_region_lookup( &mctl->stats_info.pmem_stats_list, MSM_PMEM_AEC_AWB, ®ion[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 = ®ion[0]; return msm_isp_subdev_ioctl(sd, &cfgcmd, &axi_data); case CMD_STATS_IHIST_ENABLE: axi_data.bufnum1 = msm_pmem_region_lookup( &mctl->stats_info.pmem_stats_list, MSM_PMEM_IHIST, ®ion[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 = ®ion[0]; return msm_isp_subdev_ioctl(sd, &cfgcmd, &axi_data); case CMD_STATS_RS_ENABLE: axi_data.bufnum1 = msm_pmem_region_lookup( &mctl->stats_info.pmem_stats_list, MSM_PMEM_RS, ®ion[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 = ®ion[0]; return msm_isp_subdev_ioctl(sd, &cfgcmd, &axi_data); case CMD_STATS_CS_ENABLE: axi_data.bufnum1 = msm_pmem_region_lookup( &mctl->stats_info.pmem_stats_list, MSM_PMEM_CS, ®ion[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 = ®ion[0]; return msm_isp_subdev_ioctl(sd, &cfgcmd, &axi_data); case CMD_GENERAL: case CMD_STATS_DISABLE: return msm_isp_subdev_ioctl(sd, &cfgcmd, &axi_data); default: pr_err("%s: unknown command type %d\n", __func__, cfgcmd.cmd_type); } return -EINVAL; }
int32_t msm_sensor_imx111_power_up(struct msm_sensor_ctrl_t *s_ctrl) { int32_t rc = 0; struct msm_camera_sensor_info *data = s_ctrl->sensordata; CDBG("%s: %d\n", __func__, __LINE__); s_ctrl->reg_ptr = kzalloc(sizeof(struct regulator *) * data->sensor_platform_info->num_vreg, GFP_KERNEL); if (!s_ctrl->reg_ptr) { pr_err("%s: could not allocate mem for regulators\n", __func__); return -ENOMEM; } rc = msm_camera_request_gpio_table(data, 1); if (rc < 0) { pr_err("%s: request gpio failed\n", __func__); msm_sensor_imx111_power_down(s_ctrl); return -EFAULT; } rc = msm_camera_config_vreg(&s_ctrl->sensor_i2c_client->client->dev, s_ctrl->sensordata->sensor_platform_info->cam_vreg, s_ctrl->sensordata->sensor_platform_info->num_vreg, s_ctrl->reg_ptr, 1); if (rc < 0) { pr_err("%s: regulator on failed\n", __func__); msm_sensor_imx111_power_down(s_ctrl); return -EFAULT; } rc = msm_camera_enable_vreg(&s_ctrl->sensor_i2c_client->client->dev, s_ctrl->sensordata->sensor_platform_info->cam_vreg, s_ctrl->sensordata->sensor_platform_info->num_vreg, s_ctrl->reg_ptr, 1); if (rc < 0) { pr_err("%s: enable regulator failed\n", __func__); msm_sensor_imx111_power_down(s_ctrl); return -EFAULT; } rc = gpio_request(IMX111_GPIO_CAM_V_EN3, SENSOR_NAME); if (rc < 0) { CDBG("IMX111_GPIO_CAM_V_EN3(%d) Error, rc = %d\n", IMX111_GPIO_CAM_V_EN3, rc); msm_sensor_imx111_power_down(s_ctrl); return -EFAULT; } gpio_direction_output(IMX111_GPIO_CAM_V_EN3, 1); if (cam_vdig == NULL) { cam_vdig = regulator_get(&s_ctrl->sensor_i2c_client->client->dev, "cam_vdig"); if (IS_ERR(cam_vdig)) { CDBG("%s: VREG CAM VDIG get failed\n", __func__); cam_vdig = NULL; rc = -1; } if (regulator_set_voltage(cam_vdig, CAM_VDIG_MINUV, CAM_VDIG_MAXUV)) { CDBG("%s: VREG CAM VDIG set voltage failed\n", __func__); rc = -1; } if (regulator_set_optimum_mode(cam_vdig, CAM_VDIG_LOAD_UA) < 0) { CDBG("%s: VREG CAM VDIG set optimum mode failed\n", __func__); rc = -1; } if (regulator_enable(cam_vdig)) { CDBG("%s: VREG CAM VDIG enable failed\n", __func__); rc = -1; } } mdelay(IMX111_WAIT_PWON_EN2); rc = pm8xxx_gpio_config(IMX111_PMGPIO_CAM_V_EN2, &imx111_cam_v_en2_on); if (rc) { CDBG("IMX111_PMGPIO_CAM_V_EN2(%d) Error, rc = %d\n", IMX111_PMGPIO_CAM_V_EN2, rc); msm_sensor_imx111_power_down(s_ctrl); return -EFAULT; } rc = gpio_request(IMX111_GPIO_CAM_I2C_SDA, SENSOR_NAME); if (rc < 0) { CDBG("IMX111_GPIO_CAM_I2C_SDA(%d) Error, rc = %d\n", IMX111_GPIO_CAM_V_EN3, rc); msm_sensor_imx111_power_down(s_ctrl); return -EFAULT; } rc = gpio_request(IMX111_GPIO_CAM_I2C_SCL, SENSOR_NAME); if (rc < 0) { CDBG("IMX111_GPIO_CAM_I2C_SCL(%d) Error, rc = %d\n", IMX111_GPIO_CAM_V_EN3, rc); msm_sensor_imx111_power_down(s_ctrl); return -EFAULT; } mdelay(IMX111_WAIT_PWON_EN1); rc = gpio_request(IMX111_GPIO_CAM_V_EN1, SENSOR_NAME); if (!rc) { CDBG("%s: cam_v_en on\n", __func__); gpio_direction_output(IMX111_GPIO_CAM_V_EN1, 1); } else { CDBG("VDD_CAM2_V_EN1(%d) Error, rc = %d\n", IMX111_GPIO_CAM_V_EN3, rc); msm_sensor_imx111_power_down(s_ctrl); return -EFAULT; } mdelay(IMX111_WAIT_PWON_VREG_L11); if (cam_vana == NULL) { cam_vana = regulator_get(&s_ctrl->sensor_i2c_client->client->dev, "cam_vana"); if (IS_ERR(cam_vana)) { CDBG("%s: VREG CAM VANA get failed\n", __func__); rc = -1; } if (regulator_set_voltage(cam_vana, CAM_VANA_MINUV, CAM_VANA_MAXUV)) { CDBG("%s: VREG CAM VANA set voltage failed\n", __func__); rc = -1; } if (regulator_set_optimum_mode(cam_vana, CAM_VANA_LOAD_UA) < 0) { CDBG("%s: VREG CAM VANA set optimum mode failed\n", __func__); rc = -1; } if (regulator_enable(cam_vana)) { CDBG("%s: VREG CAM VANA enable failed\n", __func__); rc = -1; } } if (rc < 0) { CDBG("cam_vana enable Error, rc = %d\n", rc); msm_sensor_imx111_power_down(s_ctrl); return -EFAULT; } mdelay(IMX111_WAIT_PWON_RST_H); rc = gpio_request(data->sensor_platform_info->sensor_reset, SENSOR_NAME); if (!rc) { CDBG("%s: reset sensor\n", __func__); gpio_direction_output(data->sensor_platform_info->sensor_reset, 1); } else { CDBG("%s: gpio request fail", __func__); } udelay(IMX111_WAIT_PWON_CLK); if (s_ctrl->clk_rate != 0) imx111_cam_clk_info->clk_rate = s_ctrl->clk_rate; rc = msm_cam_clk_enable(&s_ctrl->sensor_i2c_client->client->dev, imx111_cam_clk_info, &s_ctrl->cam_clk, ARRAY_SIZE(imx111_cam_clk_info), 1); if (rc < 0) { pr_err("%s: clk enable failed\n", __func__); msm_sensor_imx111_power_down(s_ctrl); return -EFAULT; } gpio_direction_output(IMX111_GPIO_CAM_MCLK0, 1); mdelay(IMX111_WAIT_PWON_CLK_2); return rc; }
u32 msm_io_r(void __iomem *addr) { uint32_t data = readl_relaxed(addr); CDBG("%s: %08x %08x\n", __func__, (int) (addr), (data)); return data; }
static int vfe_proc_general(struct msm_vfe_command_8k *cmd) { int rc = 0; CDBG("vfe_proc_general: cmdID = %d\n", cmd->id); switch (cmd->id) { case VFE_CMD_ID_RESET: msm_camio_vfe_blk_reset(); msm_camio_camif_pad_reg_reset_2(); vfe_reset(); break; case VFE_CMD_ID_START: { struct vfe_cmd_start start; if (copy_from_user(&start, (void __user *) cmd->value, cmd->length)) rc = -EFAULT; /* msm_camio_camif_pad_reg_reset_2(); */ msm_camio_camif_pad_reg_reset(); vfe_start(&start); } break; case VFE_CMD_ID_CAMIF_CONFIG: { struct vfe_cmd_camif_config camif; if (copy_from_user(&camif, (void __user *) cmd->value, cmd->length)) rc = -EFAULT; vfe_camif_config(&camif); } break; case VFE_CMD_ID_BLACK_LEVEL_CONFIG: { struct vfe_cmd_black_level_config bl; if (copy_from_user(&bl, (void __user *) cmd->value, cmd->length)) rc = -EFAULT; vfe_black_level_config(&bl); } break; case VFE_CMD_ID_ROLL_OFF_CONFIG: { struct vfe_cmd_roll_off_config rolloff; if (copy_from_user(&rolloff, (void __user *) cmd->value, cmd->length)) rc = -EFAULT; vfe_roll_off_config(&rolloff); } break; case VFE_CMD_ID_DEMUX_CHANNEL_GAIN_CONFIG: { struct vfe_cmd_demux_channel_gain_config demuxc; if (copy_from_user(&demuxc, (void __user *) cmd->value, cmd->length)) rc = -EFAULT; /* demux is always enabled. */ vfe_demux_channel_gain_config(&demuxc); } break; case VFE_CMD_ID_DEMOSAIC_CONFIG: { struct vfe_cmd_demosaic_config demosaic; if (copy_from_user(&demosaic, (void __user *) cmd->value, cmd->length)) rc = -EFAULT; vfe_demosaic_config(&demosaic); } break; case VFE_CMD_ID_FOV_CROP_CONFIG: case VFE_CMD_ID_FOV_CROP_UPDATE: { struct vfe_cmd_fov_crop_config fov; if (copy_from_user(&fov, (void __user *) cmd->value, cmd->length)) rc = -EFAULT; vfe_fov_crop_config(&fov); } break; case VFE_CMD_ID_MAIN_SCALER_CONFIG: case VFE_CMD_ID_MAIN_SCALER_UPDATE: { struct vfe_cmd_main_scaler_config mainds; if (copy_from_user(&mainds, (void __user *) cmd->value, cmd->length)) rc = -EFAULT; vfe_main_scaler_config(&mainds); } break; case VFE_CMD_ID_WHITE_BALANCE_CONFIG: case VFE_CMD_ID_WHITE_BALANCE_UPDATE: { struct vfe_cmd_white_balance_config wb; if (copy_from_user(&wb, (void __user *) cmd->value, cmd->length)) rc = -EFAULT; vfe_white_balance_config(&wb); } break; case VFE_CMD_ID_COLOR_CORRECTION_CONFIG: case VFE_CMD_ID_COLOR_CORRECTION_UPDATE: { struct vfe_cmd_color_correction_config cc; if (copy_from_user(&cc, (void __user *) cmd->value, cmd->length)) rc = -EFAULT; vfe_color_correction_config(&cc); } break; case VFE_CMD_ID_LA_CONFIG: { struct vfe_cmd_la_config la; if (copy_from_user(&la, (void __user *) cmd->value, cmd->length)) rc = -EFAULT; vfe_la_config(&la); } break; case VFE_CMD_ID_RGB_GAMMA_CONFIG: { struct vfe_cmd_rgb_gamma_config rgb; if (copy_from_user(&rgb, (void __user *) cmd->value, cmd->length)) rc = -EFAULT; rc = vfe_rgb_gamma_config(&rgb); } break; case VFE_CMD_ID_CHROMA_ENHAN_CONFIG: case VFE_CMD_ID_CHROMA_ENHAN_UPDATE: { struct vfe_cmd_chroma_enhan_config chrom; if (copy_from_user(&chrom, (void __user *) cmd->value, cmd->length)) rc = -EFAULT; vfe_chroma_enhan_config(&chrom); } break; case VFE_CMD_ID_CHROMA_SUPPRESSION_CONFIG: case VFE_CMD_ID_CHROMA_SUPPRESSION_UPDATE: { struct vfe_cmd_chroma_suppression_config chromsup; if (copy_from_user(&chromsup, (void __user *) cmd->value, cmd->length)) rc = -EFAULT; vfe_chroma_sup_config(&chromsup); } break; case VFE_CMD_ID_ASF_CONFIG: { struct vfe_cmd_asf_config asf; if (copy_from_user(&asf, (void __user *) cmd->value, cmd->length)) rc = -EFAULT; vfe_asf_config(&asf); } break; case VFE_CMD_ID_SCALER2Y_CONFIG: case VFE_CMD_ID_SCALER2Y_UPDATE: { struct vfe_cmd_scaler2_config ds2y; if (copy_from_user(&ds2y, (void __user *) cmd->value, cmd->length)) rc = -EFAULT; vfe_scaler2y_config(&ds2y); } break; case VFE_CMD_ID_SCALER2CbCr_CONFIG: case VFE_CMD_ID_SCALER2CbCr_UPDATE: { struct vfe_cmd_scaler2_config ds2cbcr; if (copy_from_user(&ds2cbcr, (void __user *) cmd->value, cmd->length)) rc = -EFAULT; vfe_scaler2cbcr_config(&ds2cbcr); } break; case VFE_CMD_ID_CHROMA_SUBSAMPLE_CONFIG: { struct vfe_cmd_chroma_subsample_config sub; if (copy_from_user(&sub, (void __user *) cmd->value, cmd->length)) rc = -EFAULT; vfe_chroma_subsample_config(&sub); } break; case VFE_CMD_ID_FRAME_SKIP_CONFIG: { struct vfe_cmd_frame_skip_config fskip; if (copy_from_user(&fskip, (void __user *) cmd->value, cmd->length)) rc = -EFAULT; vfe_frame_skip_config(&fskip); } break; case VFE_CMD_ID_OUTPUT_CLAMP_CONFIG: { struct vfe_cmd_output_clamp_config clamp; if (copy_from_user(&clamp, (void __user *) cmd->value, cmd->length)) rc = -EFAULT; vfe_output_clamp_config(&clamp); } break; /* module update commands */ case VFE_CMD_ID_BLACK_LEVEL_UPDATE: { struct vfe_cmd_black_level_config blk; if (copy_from_user(&blk, (void __user *) cmd->value, cmd->length)) rc = -EFAULT; vfe_black_level_update(&blk); } break; case VFE_CMD_ID_DEMUX_CHANNEL_GAIN_UPDATE: { struct vfe_cmd_demux_channel_gain_config dmu; if (copy_from_user(&dmu, (void __user *) cmd->value, cmd->length)) rc = -EFAULT; vfe_demux_channel_gain_update(&dmu); } break; case VFE_CMD_ID_DEMOSAIC_BPC_UPDATE: { struct vfe_cmd_demosaic_bpc_update demo_bpc; if (copy_from_user(&demo_bpc, (void __user *) cmd->value, cmd->length)) rc = -EFAULT; vfe_demosaic_bpc_update(&demo_bpc); } break; case VFE_CMD_ID_DEMOSAIC_ABF_UPDATE: { struct vfe_cmd_demosaic_abf_update demo_abf; if (copy_from_user(&demo_abf, (void __user *) cmd->value, cmd->length)) rc = -EFAULT; vfe_demosaic_abf_update(&demo_abf); } break; case VFE_CMD_ID_LA_UPDATE: { struct vfe_cmd_la_config la; if (copy_from_user(&la, (void __user *) cmd->value, cmd->length)) rc = -EFAULT; vfe_la_update(&la); } break; case VFE_CMD_ID_RGB_GAMMA_UPDATE: { struct vfe_cmd_rgb_gamma_config rgb; if (copy_from_user(&rgb, (void __user *) cmd->value, cmd->length)) rc = -EFAULT; rc = vfe_rgb_gamma_update(&rgb); } break; case VFE_CMD_ID_ASF_UPDATE: { struct vfe_cmd_asf_update asf; if (copy_from_user(&asf, (void __user *) cmd->value, cmd->length)) rc = -EFAULT; vfe_asf_update(&asf); } break; case VFE_CMD_ID_FRAME_SKIP_UPDATE: { struct vfe_cmd_frame_skip_update fskip; if (copy_from_user(&fskip, (void __user *) cmd->value, cmd->length)) rc = -EFAULT; vfe_frame_skip_update(&fskip); } break; case VFE_CMD_ID_CAMIF_FRAME_UPDATE: { struct vfe_cmds_camif_frame fup; if (copy_from_user(&fup, (void __user *) cmd->value, cmd->length)) rc = -EFAULT; vfe_camif_frame_update(&fup); } break; /* stats update commands */ case VFE_CMD_ID_STATS_AUTOFOCUS_UPDATE: { struct vfe_cmd_stats_af_update afup; if (copy_from_user(&afup, (void __user *) cmd->value, cmd->length)) rc = -EFAULT; vfe_stats_update_af(&afup); } break; case VFE_CMD_ID_STATS_WB_EXP_UPDATE: { struct vfe_cmd_stats_wb_exp_update wbexp; if (copy_from_user(&wbexp, (void __user *) cmd->value, cmd->length)) rc = -EFAULT; vfe_stats_update_wb_exp(&wbexp); } break; /* control of start, stop, update, etc... */ case VFE_CMD_ID_STOP: vfe_stop(); break; case VFE_CMD_ID_GET_HW_VERSION: break; /* stats */ case VFE_CMD_ID_STATS_SETTING: { struct vfe_cmd_stats_setting stats; if (copy_from_user(&stats, (void __user *) cmd->value, cmd->length)) rc = -EFAULT; vfe_stats_setting(&stats); } break; case VFE_CMD_ID_STATS_AUTOFOCUS_START: { struct vfe_cmd_stats_af_start af; if (copy_from_user(&af, (void __user *) cmd->value, cmd->length)) rc = -EFAULT; vfe_stats_start_af(&af); } break; case VFE_CMD_ID_STATS_AUTOFOCUS_STOP: vfe_stats_af_stop(); break; case VFE_CMD_ID_STATS_WB_EXP_START: { struct vfe_cmd_stats_wb_exp_start awexp; if (copy_from_user(&awexp, (void __user *) cmd->value, cmd->length)) rc = -EFAULT; vfe_stats_start_wb_exp(&awexp); } break; case VFE_CMD_ID_STATS_WB_EXP_STOP: vfe_stats_wb_exp_stop(); break; case VFE_CMD_ID_ASYNC_TIMER_SETTING: break; case VFE_CMD_ID_UPDATE: vfe_update(); break; /* test gen */ case VFE_CMD_ID_TEST_GEN_START: break; /* acknowledge from upper layer these are not in general command. case VFE_CMD_ID_OUTPUT1_ACK: break; case VFE_CMD_ID_OUTPUT2_ACK: break; case VFE_CMD_ID_EPOCH1_ACK: break; case VFE_CMD_ID_EPOCH2_ACK: break; case VFE_CMD_ID_STATS_AUTOFOCUS_ACK: break; case VFE_CMD_ID_STATS_WB_EXP_ACK: break; */ default: break; } /* switch */ return rc; }
static void msm_camera_vreg_enable(void) { #if 0 //samsung (LTE) , not used.[[ ldo15 = regulator_get(NULL, "8058_l15"); if (IS_ERR(ldo15)) { pr_err("%s: VREG LDO15 get failed\n", __func__); ldo15 = NULL; return; } if (regulator_set_voltage(ldo15, 2850000, 2850000)) { pr_err("%s: VREG LDO15 set voltage failed\n", __func__); goto ldo15_disable; } if (regulator_enable(ldo15)) { pr_err("%s: VREG LDO15 enable failed\n", __func__); goto ldo15_put; } lvs0 = regulator_get(NULL, "8058_lvs0"); if (IS_ERR(lvs0)) { pr_err("%s: VREG LVS0 get failed\n", __func__); lvs0 = NULL; goto ldo15_disable; } if (regulator_enable(lvs0)) { pr_err("%s: VREG LVS0 enable failed\n", __func__); goto lvs0_put; } ldo25 = regulator_get(NULL, "8058_l25"); if (IS_ERR(ldo25)) { pr_err("%s: VREG LDO25 get failed\n", __func__); ldo25 = NULL; goto ldo25_disable; } if (regulator_set_voltage(ldo25, 1200000, 1200000)) { pr_err("%s: VREG LDO25 set voltage failed\n", __func__); goto ldo25_disable; } if (regulator_enable(ldo25)) { pr_err("%s: VREG LDO25 enable failed\n", __func__); goto ldo25_put; } #endif // ]] fs_vfe = regulator_get(NULL, "fs_vfe"); if (IS_ERR(fs_vfe)) { CDBG("%s: Regulator FS_VFE get failed %ld\n", __func__, PTR_ERR(fs_vfe)); fs_vfe = NULL; } else if (regulator_enable(fs_vfe)) { CDBG("%s: Regulator FS_VFE enable failed\n", __func__); regulator_put(fs_vfe); } return; #if 0 //samsung (LTE) , not used.[[ ldo25_disable: regulator_disable(ldo25); ldo25_put: regulator_put(ldo25); lvs0_disable: regulator_disable(lvs0); lvs0_put: regulator_put(lvs0); ldo15_disable: regulator_disable(ldo15); ldo15_put: regulator_put(ldo15); #endif//]] }
int32_t hi256_sensor_config(struct msm_sensor_ctrl_t *s_ctrl, void __user *argp) { struct sensorb_cfg_data *cdata = (struct sensorb_cfg_data *)argp; long rc = 0; int32_t i = 0; mutex_lock(s_ctrl->msm_sensor_mutex); CDBG("%s:%d %s cfgtype = %d\n", __func__, __LINE__, s_ctrl->sensordata->sensor_name, cdata->cfgtype); switch (cdata->cfgtype) { case CFG_GET_SENSOR_INFO: memcpy(cdata->cfg.sensor_info.sensor_name, s_ctrl->sensordata->sensor_name, sizeof(cdata->cfg.sensor_info.sensor_name)); cdata->cfg.sensor_info.session_id = s_ctrl->sensordata->sensor_info->session_id; for (i = 0; i < SUB_MODULE_MAX; i++) cdata->cfg.sensor_info.subdev_id[i] = s_ctrl->sensordata->sensor_info->subdev_id[i]; CDBG("%s:%d sensor name %s\n", __func__, __LINE__, cdata->cfg.sensor_info.sensor_name); CDBG("%s:%d session id %d\n", __func__, __LINE__, cdata->cfg.sensor_info.session_id); for (i = 0; i < SUB_MODULE_MAX; i++) CDBG("%s:%d subdev_id[%d] %d\n", __func__, __LINE__, i, cdata->cfg.sensor_info.subdev_id[i]); break; case CFG_SET_INIT_SETTING: CDBG("init setting"); hi256_i2c_write_table(s_ctrl, &hi256_recommend_settings[0], ARRAY_SIZE(hi256_recommend_settings)); CDBG("init setting X"); break; case CFG_SET_RESOLUTION: { int val = 0; if (copy_from_user(&val, (void *)cdata->cfg.setting, sizeof(int))) { pr_err("%s:%d failed\n", __func__, __LINE__); rc = -EFAULT; break; } if (val == 0) hi256_i2c_write_table(s_ctrl, &hi256_uxga_settings[0], ARRAY_SIZE(hi256_uxga_settings)); else if (val == 1) hi256_i2c_write_table(s_ctrl, &hi256_svga_settings[0], ARRAY_SIZE(hi256_svga_settings)); break; } case CFG_SET_STOP_STREAM: hi256_i2c_write_table(s_ctrl, &hi256_stop_settings[0], ARRAY_SIZE(hi256_stop_settings)); break; case CFG_SET_START_STREAM: hi256_i2c_write_table(s_ctrl, &hi256_start_settings[0], ARRAY_SIZE(hi256_start_settings)); break; case CFG_GET_SENSOR_INIT_PARAMS: cdata->cfg.sensor_init_params = *s_ctrl->sensordata->sensor_init_params; CDBG("%s:%d init params mode %d pos %d mount %d\n", __func__, __LINE__, cdata->cfg.sensor_init_params.modes_supported, cdata->cfg.sensor_init_params.position, cdata->cfg.sensor_init_params.sensor_mount_angle); break; case CFG_SET_SLAVE_INFO: { struct msm_camera_sensor_slave_info sensor_slave_info; struct msm_sensor_power_setting_array *power_setting_array; int slave_index = 0; if (copy_from_user(&sensor_slave_info, (void *)cdata->cfg.setting, sizeof(struct msm_camera_sensor_slave_info))) { pr_err("%s:%d failed\n", __func__, __LINE__); rc = -EFAULT; break; } /* Update sensor slave address */ if (sensor_slave_info.slave_addr) { s_ctrl->sensor_i2c_client->cci_client->sid = sensor_slave_info.slave_addr >> 1; } /* Update sensor address type */ s_ctrl->sensor_i2c_client->addr_type = sensor_slave_info.addr_type; /* Update power up / down sequence */ s_ctrl->power_setting_array = sensor_slave_info.power_setting_array; power_setting_array = &s_ctrl->power_setting_array; power_setting_array->power_setting = kzalloc( power_setting_array->size * sizeof(struct msm_sensor_power_setting), GFP_KERNEL); if (!power_setting_array->power_setting) { pr_err("%s:%d failed\n", __func__, __LINE__); rc = -ENOMEM; break; } if (copy_from_user(power_setting_array->power_setting, (void *) sensor_slave_info.power_setting_array.power_setting, power_setting_array->size * sizeof(struct msm_sensor_power_setting))) { kfree(power_setting_array->power_setting); pr_err("%s:%d failed\n", __func__, __LINE__); rc = -EFAULT; break; } s_ctrl->free_power_setting = true; CDBG("%s sensor id %x\n", __func__, sensor_slave_info.slave_addr); CDBG("%s sensor addr type %d\n", __func__, sensor_slave_info.addr_type); CDBG("%s sensor reg %x\n", __func__, sensor_slave_info.sensor_id_info.sensor_id_reg_addr); CDBG("%s sensor id %x\n", __func__, sensor_slave_info.sensor_id_info.sensor_id); for (slave_index = 0; slave_index < power_setting_array->size; slave_index++) { CDBG("%s i %d power setting %d %d %ld %d\n", __func__, slave_index, power_setting_array->power_setting[slave_index]. seq_type, power_setting_array->power_setting[slave_index]. seq_val, power_setting_array->power_setting[slave_index]. config_val, power_setting_array->power_setting[slave_index]. delay); } kfree(power_setting_array->power_setting); break; } case CFG_WRITE_I2C_ARRAY: { struct msm_camera_i2c_reg_setting conf_array; struct msm_camera_i2c_reg_array *reg_setting = NULL; if (copy_from_user(&conf_array, (void *)cdata->cfg.setting, sizeof(struct msm_camera_i2c_reg_setting))) { pr_err("%s:%d failed\n", __func__, __LINE__); rc = -EFAULT; break; } reg_setting = kzalloc(conf_array.size * (sizeof(struct msm_camera_i2c_reg_array)), GFP_KERNEL); if (!reg_setting) { pr_err("%s:%d failed\n", __func__, __LINE__); rc = -ENOMEM; break; } if (copy_from_user(reg_setting, (void *)conf_array.reg_setting, conf_array.size * sizeof(struct msm_camera_i2c_reg_array))) { pr_err("%s:%d failed\n", __func__, __LINE__); kfree(reg_setting); rc = -EFAULT; break; } conf_array.reg_setting = reg_setting; rc = s_ctrl->sensor_i2c_client->i2c_func_tbl->i2c_write_table( s_ctrl->sensor_i2c_client, &conf_array); kfree(reg_setting); break; } case CFG_WRITE_I2C_SEQ_ARRAY: { struct msm_camera_i2c_seq_reg_setting conf_array; struct msm_camera_i2c_seq_reg_array *reg_setting = NULL; if (copy_from_user(&conf_array, (void *)cdata->cfg.setting, sizeof(struct msm_camera_i2c_seq_reg_setting))) { pr_err("%s:%d failed\n", __func__, __LINE__); rc = -EFAULT; break; } reg_setting = kzalloc(conf_array.size * (sizeof(struct msm_camera_i2c_seq_reg_array)), GFP_KERNEL); if (!reg_setting) { pr_err("%s:%d failed\n", __func__, __LINE__); rc = -ENOMEM; break; } if (copy_from_user(reg_setting, (void *)conf_array.reg_setting, conf_array.size * sizeof(struct msm_camera_i2c_seq_reg_array))) { pr_err("%s:%d failed\n", __func__, __LINE__); kfree(reg_setting); rc = -EFAULT; break; } conf_array.reg_setting = reg_setting; rc = s_ctrl->sensor_i2c_client->i2c_func_tbl-> i2c_write_seq_table(s_ctrl->sensor_i2c_client, &conf_array); kfree(reg_setting); break; } case CFG_POWER_UP: if (s_ctrl->func_tbl->sensor_power_up) rc = s_ctrl->func_tbl->sensor_power_up(s_ctrl); else rc = -EFAULT; break; case CFG_POWER_DOWN: if (s_ctrl->func_tbl->sensor_power_down) rc = s_ctrl->func_tbl->sensor_power_down(s_ctrl); else rc = -EFAULT; break; case CFG_SET_STOP_STREAM_SETTING: { struct msm_camera_i2c_reg_setting *stop_setting = &s_ctrl->stop_setting; struct msm_camera_i2c_reg_array *reg_setting = NULL; if (copy_from_user(stop_setting, (void *)cdata->cfg.setting, sizeof(struct msm_camera_i2c_reg_setting))) { pr_err("%s:%d failed\n", __func__, __LINE__); rc = -EFAULT; break; } reg_setting = stop_setting->reg_setting; stop_setting->reg_setting = kzalloc(stop_setting->size * (sizeof(struct msm_camera_i2c_reg_array)), GFP_KERNEL); if (!stop_setting->reg_setting) { pr_err("%s:%d failed\n", __func__, __LINE__); rc = -ENOMEM; break; } if (copy_from_user(stop_setting->reg_setting, (void *)reg_setting, stop_setting->size * sizeof(struct msm_camera_i2c_reg_array))) { pr_err("%s:%d failed\n", __func__, __LINE__); kfree(stop_setting->reg_setting); stop_setting->reg_setting = NULL; stop_setting->size = 0; rc = -EFAULT; break; } break; } case CFG_SET_SATURATION: { int32_t sat_lev; if (copy_from_user(&sat_lev, (void *)cdata->cfg.setting, sizeof(int32_t))) { pr_err("%s:%d failed\n", __func__, __LINE__); rc = -EFAULT; break; } pr_debug("%s: Saturation Value is %d", __func__, sat_lev); hi256_set_stauration(s_ctrl, sat_lev); break; } case CFG_SET_CONTRAST: { int32_t con_lev; if (copy_from_user(&con_lev, (void *)cdata->cfg.setting, sizeof(int32_t))) { pr_err("%s:%d failed\n", __func__, __LINE__); rc = -EFAULT; break; } pr_debug("%s: Contrast Value is %d", __func__, con_lev); hi256_set_contrast(s_ctrl, con_lev); break; } case CFG_SET_SHARPNESS: { int32_t shp_lev; if (copy_from_user(&shp_lev, (void *)cdata->cfg.setting, sizeof(int32_t))) { pr_err("%s:%d failed\n", __func__, __LINE__); rc = -EFAULT; break; } pr_debug("%s: Sharpness Value is %d", __func__, shp_lev); hi256_set_sharpness(s_ctrl, shp_lev); break; } case CFG_SET_ISO: { int32_t iso_lev; if (copy_from_user(&iso_lev, (void *)cdata->cfg.setting, sizeof(int32_t))) { pr_err("%s:%d failed\n", __func__, __LINE__); rc = -EFAULT; break; } pr_debug("%s: ISO Value is %d", __func__, iso_lev); hi256_set_iso(s_ctrl, iso_lev); break; } case CFG_SET_EXPOSURE_COMPENSATION: { int32_t ec_lev; if (copy_from_user(&ec_lev, (void *)cdata->cfg.setting, sizeof(int32_t))) { pr_err("%s:%d failed\n", __func__, __LINE__); rc = -EFAULT; break; } pr_debug("%s: Exposure compensation Value is %d", __func__, ec_lev); hi256_set_exposure_compensation(s_ctrl, ec_lev); break; } case CFG_SET_EFFECT: { int32_t effect_mode; if (copy_from_user(&effect_mode, (void *)cdata->cfg.setting, sizeof(int32_t))) { pr_err("%s:%d failed\n", __func__, __LINE__); rc = -EFAULT; break; } pr_debug("%s: Effect mode is %d", __func__, effect_mode); hi256_set_effect(s_ctrl, effect_mode); break; } case CFG_SET_ANTIBANDING: { int32_t antibanding_mode; if (copy_from_user(&antibanding_mode, (void *)cdata->cfg.setting, sizeof(int32_t))) { pr_err("%s:%d failed\n", __func__, __LINE__); rc = -EFAULT; break; } pr_debug("%s: anti-banding mode is %d", __func__, antibanding_mode); hi256_set_antibanding(s_ctrl, antibanding_mode); break; } case CFG_SET_BESTSHOT_MODE: { int32_t bs_mode; if (copy_from_user(&bs_mode, (void *)cdata->cfg.setting, sizeof(int32_t))) { pr_err("%s:%d failed\n", __func__, __LINE__); rc = -EFAULT; break; } pr_debug("%s: best shot mode is %d", __func__, bs_mode); hi256_set_scene_mode(s_ctrl, bs_mode); break; } case CFG_SET_WHITE_BALANCE: { int32_t wb_mode; if (copy_from_user(&wb_mode, (void *)cdata->cfg.setting, sizeof(int32_t))) { pr_err("%s:%d failed\n", __func__, __LINE__); rc = -EFAULT; break; } pr_debug("%s: white balance is %d", __func__, wb_mode); hi256_set_white_balance_mode(s_ctrl, wb_mode); break; } default: rc = -EFAULT; break; }