static int msm_eeprom_spi_setup(struct spi_device *spi) { struct msm_eeprom_ctrl_t *e_ctrl = NULL; struct msm_camera_i2c_client *client = NULL; struct msm_camera_spi_client *spi_client; struct msm_eeprom_board_info *eb_info; struct msm_camera_power_ctrl_t *power_info = NULL; int rc = 0; e_ctrl = kzalloc(sizeof(struct msm_eeprom_ctrl_t), GFP_KERNEL); if (!e_ctrl) { pr_err("%s:%d kzalloc failed\n", __func__, __LINE__); return -ENOMEM; } e_ctrl->eeprom_v4l2_subdev_ops = &msm_eeprom_subdev_ops; e_ctrl->eeprom_mutex = &msm_eeprom_mutex; client = &e_ctrl->i2c_client; e_ctrl->is_supported = 0; spi_client = kzalloc(sizeof(spi_client), GFP_KERNEL); if (!spi_client) { pr_err("%s:%d kzalloc failed\n", __func__, __LINE__); kfree(e_ctrl); return -ENOMEM; } rc = of_property_read_u32(spi->dev.of_node, "cell-index", &e_ctrl->subdev_id); CDBG("cell-index %d, rc %d\n", e_ctrl->subdev_id, rc); if (rc) { pr_err("failed rc %d\n", rc); return rc; } e_ctrl->eeprom_device_type = MSM_CAMERA_SPI_DEVICE; client->spi_client = spi_client; spi_client->spi_master = spi; client->i2c_func_tbl = &msm_eeprom_spi_func_tbl; client->addr_type = MSM_CAMERA_I2C_3B_ADDR; eb_info = kzalloc(sizeof(eb_info), GFP_KERNEL); if (!eb_info) goto spi_free; e_ctrl->eboard_info = eb_info; rc = of_property_read_string(spi->dev.of_node, "qcom,eeprom-name", &eb_info->eeprom_name); CDBG("%s qcom,eeprom-name %s, rc %d\n", __func__, eb_info->eeprom_name, rc); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto board_free; } power_info = &eb_info->power_info; power_info->clk_info = cam_8974_clk_info; power_info->clk_info_size = ARRAY_SIZE(cam_8974_clk_info); power_info->dev = &spi->dev; rc = msm_eeprom_get_dt_data(e_ctrl); if (rc) goto board_free; /* set spi instruction info */ spi_client->retry_delay = 1; spi_client->retries = 0; if (msm_eeprom_spi_parse_of(spi_client)) { dev_err(&spi->dev, "%s: Error parsing device properties\n", __func__); goto board_free; } rc = msm_eeprom_alloc_memory_map(e_ctrl, spi->dev.of_node); if (rc) goto board_free; rc = msm_camera_power_up(power_info, e_ctrl->eeprom_device_type, &e_ctrl->i2c_client); if (rc) { pr_err("failed rc %d\n", rc); goto memmap_free; } /* check eeprom id */ rc = msm_eeprom_check_id(e_ctrl); if (rc) { CDBG("%s: eeprom not matching %d\n", __func__, rc); goto power_down; } /* read eeprom */ rc = read_eeprom_memory(e_ctrl); if (rc) { dev_err(&spi->dev, "%s: read eeprom memory failed\n", __func__); goto power_down; } rc = msm_camera_power_down(power_info, e_ctrl->eeprom_device_type, &e_ctrl->i2c_client); if (rc) { pr_err("failed rc %d\n", rc); goto memmap_free; } /* initiazlie subdev */ v4l2_spi_subdev_init(&e_ctrl->msm_sd.sd, e_ctrl->i2c_client.spi_client->spi_master, e_ctrl->eeprom_v4l2_subdev_ops); v4l2_set_subdevdata(&e_ctrl->msm_sd.sd, e_ctrl); e_ctrl->msm_sd.sd.internal_ops = &msm_eeprom_internal_ops; e_ctrl->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; media_entity_init(&e_ctrl->msm_sd.sd.entity, 0, NULL, 0); e_ctrl->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV; e_ctrl->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_EEPROM; msm_sd_register(&e_ctrl->msm_sd); e_ctrl->is_supported = 1; CDBG("%s success result=%d X\n", __func__, rc); return 0; power_down: msm_camera_power_down(power_info, e_ctrl->eeprom_device_type, &e_ctrl->i2c_client); memmap_free: kfree(e_ctrl->eboard_info->eeprom_map); kfree(e_ctrl->memory_data); board_free: kfree(e_ctrl->eboard_info); spi_free: kfree(spi_client); return rc; }
static int ssp_parse_dt(struct device *dev, struct ssp_data *data) { struct device_node *np = dev->of_node; enum of_gpio_flags flags; int errorno = 0; data->mcu_int1 = of_get_named_gpio_flags(np, "ssp,mcu_int1-gpio", 0, &flags); if (data->mcu_int1 < 0) { errorno = data->mcu_int1; goto dt_exit; } data->mcu_int2 = of_get_named_gpio_flags(np, "ssp,mcu_int2-gpio", 0, &flags); if (data->mcu_int2 < 0) { errorno = data->mcu_int2; goto dt_exit; } data->ap_int = of_get_named_gpio_flags(np, "ssp,ap_int-gpio", 0, &flags); if (data->ap_int < 0) { errorno = data->ap_int; goto dt_exit; } #if defined(CONFIG_SEC_PATEK_PROJECT) if (of_property_read_string(np, "ssp,ges_vdd_1p8", &data->ges_vdd) < 0) pr_err("%s - get ges_vdd error\n", __func__); if (of_property_read_string(np, "ssp,ges_led_3p3", &data->ges_led) < 0) pr_err("%s - get ges_led error\n", __func__); pr_err("%s - get ges_vcc pass\n", __func__); #endif #if defined(CONFIG_MACH_KLTE_JPN) || defined(CONFIG_MACH_KACTIVELTE_DCM) #if defined(CONFIG_MACH_KLTE_MAX77828_JPN) data->rst = of_get_named_gpio_flags(np, "ssp,rst-gpio", 0, &flags); #else of_property_read_u32(np, "ssp,rst-gpio", &data->rst); #endif #else data->rst = of_get_named_gpio_flags(np, "ssp,rst-gpio", 0, &flags); #endif if (data->rst < 0) { errorno = data->rst ; goto dt_exit; } if (of_property_read_u32(np, "ssp,acc-position", &data->accel_position)) data->accel_position = 0; if (of_property_read_u32(np, "ssp,mag-position", &data->mag_position)) data->mag_position = 0; if (of_property_read_u32(np, "ssp,ap-rev", &data->ap_rev)) data->ap_rev = 0; errorno = gpio_request(data->mcu_int1, "mpu_ap_int1"); if (errorno) { pr_err("[SSP] failed to request MCU_INT2 for SSP\n"); goto dt_exit; } errorno = gpio_direction_input(data->mcu_int1); if (errorno) { pr_err("[SSP] failed to set mcu_int1 as input\n"); goto dt_exit; } errorno = gpio_request(data->mcu_int2, "MCU_INT2"); if (errorno) { pr_err("[SSP] failed to request MCU_INT2 for SSP\n"); goto dt_exit; } gpio_direction_input(data->mcu_int2); errorno = gpio_request(data->ap_int, "AP_MCU_INT"); if (errorno) { pr_err("[SSP] failed to request AP_INT for SSP\n"); goto dt_exit; } gpio_direction_output(data->ap_int, 1); errorno = gpio_request(data->rst, "MCU_RST"); if (errorno) { pr_err("[SSP] failed to request MCU_RST for SSP\n"); goto dt_exit; } gpio_direction_output(data->rst, 1); data->reg_hub = devm_regulator_get(dev, "hub_vreg"); if (IS_ERR(data->reg_hub)) { pr_err("[SSP] could not get hub_vreg, %ld\n", PTR_ERR(data->reg_hub)); } else { regulator_enable(data->reg_hub); } data->reg_sns= devm_regulator_get(dev, "psns_vreg"); if (IS_ERR(data->reg_hub)) { pr_err("[SSP] could not get psns_vreg, %ld\n", PTR_ERR(data->reg_sns)); } else { regulator_enable(data->reg_sns); } dt_exit: return errorno; }
static struct msm_bus_node_info_type *get_node_info_data( struct device_node * const dev_node, struct platform_device * const pdev) { struct msm_bus_node_info_type *node_info; unsigned int ret; int size; int i; struct device_node *con_node; struct device_node *bus_dev; node_info = devm_kzalloc(&pdev->dev, sizeof(struct msm_bus_node_info_type), GFP_KERNEL); if (!node_info) { dev_err(&pdev->dev, "Error: Unable to allocate memory for node_info\n"); return NULL; } ret = of_property_read_u32(dev_node, "cell-id", &node_info->id); if (ret) { dev_warn(&pdev->dev, "Bus node is missing cell-id\n"); goto node_info_err; } ret = of_property_read_string(dev_node, "label", &node_info->name); if (ret) { dev_warn(&pdev->dev, "Bus node is missing name\n"); goto node_info_err; } node_info->qport = get_arr(pdev, dev_node, "qcom,qport", &node_info->num_qports); ret = of_property_read_u32(dev_node, "qcom,agg-ports", &node_info->num_aggports); if (ret) node_info->num_aggports = node_info->num_qports; if (of_get_property(dev_node, "qcom,connections", &size)) { node_info->num_connections = size / sizeof(int); node_info->connections = devm_kzalloc(&pdev->dev, size, GFP_KERNEL); } else { node_info->num_connections = 0; node_info->connections = 0; } for (i = 0; i < node_info->num_connections; i++) { con_node = of_parse_phandle(dev_node, "qcom,connections", i); if (IS_ERR_OR_NULL(con_node)) goto node_info_err; if (of_property_read_u32(con_node, "cell-id", &node_info->connections[i])) goto node_info_err; of_node_put(con_node); } if (of_get_property(dev_node, "qcom,blacklist", &size)) { node_info->num_blist = size/sizeof(u32); node_info->black_listed_connections = devm_kzalloc(&pdev->dev, size, GFP_KERNEL); } else { node_info->num_blist = 0; node_info->black_listed_connections = 0; } for (i = 0; i < node_info->num_blist; i++) { con_node = of_parse_phandle(dev_node, "qcom,blacklist", i); if (IS_ERR_OR_NULL(con_node)) goto node_info_err; if (of_property_read_u32(con_node, "cell-id", &node_info->black_listed_connections[i])) goto node_info_err; of_node_put(con_node); } bus_dev = of_parse_phandle(dev_node, "qcom,bus-dev", 0); if (!IS_ERR_OR_NULL(bus_dev)) { if (of_property_read_u32(bus_dev, "cell-id", &node_info->bus_device_id)) { dev_err(&pdev->dev, "Can't find bus device. Node %d", node_info->id); goto node_info_err; } of_node_put(bus_dev); } else dev_dbg(&pdev->dev, "Can't find bdev phandle for %d", node_info->id); node_info->is_fab_dev = of_property_read_bool(dev_node, "qcom,fab-dev"); node_info->virt_dev = of_property_read_bool(dev_node, "qcom,virt-dev"); ret = of_property_read_u32(dev_node, "qcom,buswidth", &node_info->buswidth); if (ret) { dev_dbg(&pdev->dev, "Using default 8 bytes %d", node_info->id); node_info->buswidth = 8; } ret = of_property_read_u32(dev_node, "qcom,mas-rpm-id", &node_info->mas_rpm_id); if (ret) { dev_dbg(&pdev->dev, "mas rpm id is missing\n"); node_info->mas_rpm_id = -1; } ret = of_property_read_u32(dev_node, "qcom,slv-rpm-id", &node_info->slv_rpm_id); if (ret) { dev_dbg(&pdev->dev, "slv rpm id is missing\n"); node_info->slv_rpm_id = -1; } ret = of_property_read_u32(dev_node, "qcom,util-fact", &node_info->util_fact); if (ret) node_info->util_fact = 0; ret = of_property_read_u32(dev_node, "qcom,vrail-comp", &node_info->vrail_comp); if (ret) node_info->vrail_comp = 0; get_qos_params(dev_node, pdev, node_info); return node_info; node_info_err: devm_kfree(&pdev->dev, node_info); node_info = 0; return NULL; }
static int parse_dt(struct device *dev, struct synaptics_dsx_board_data *bdata) { int retval; u32 value; const char *name; struct property *prop; struct device_node *np = dev->of_node; bdata->irq_gpio = of_get_named_gpio_flags(np, "synaptics,irq-gpio", 0, (enum of_gpio_flags *)&bdata->irq_flags); retval = of_property_read_u32(np, "synaptics,irq-on-state", &value); if (retval < 0) bdata->irq_on_state = 0; else bdata->irq_on_state = value; retval = of_property_read_string(np, "synaptics,pwr-reg-name", &name); if (retval < 0) bdata->pwr_reg_name = NULL; else bdata->pwr_reg_name = name; retval = of_property_read_string(np, "synaptics,bus-reg-name", &name); if (retval < 0) bdata->bus_reg_name = NULL; else bdata->bus_reg_name = name; prop = of_find_property(np, "synaptics,power-gpio", NULL); if (prop && prop->length) { bdata->power_gpio = of_get_named_gpio_flags(np, "synaptics,power-gpio", 0, NULL); retval = of_property_read_u32(np, "synaptics,power-on-state", &value); if (retval < 0) { dev_err(dev, "%s: Unable to read synaptics,power-on-state property\n", __func__); return retval; } else { bdata->power_on_state = value; } } else { bdata->power_gpio = -1; } prop = of_find_property(np, "synaptics,power-delay-ms", NULL); if (prop && prop->length) { retval = of_property_read_u32(np, "synaptics,power-delay-ms", &value); if (retval < 0) { dev_err(dev, "%s: Unable to read synaptics,power-delay-ms property\n", __func__); return retval; } else { bdata->power_delay_ms = value; } } else { bdata->power_delay_ms = 0; } prop = of_find_property(np, "synaptics,reset-gpio", NULL); if (prop && prop->length) { bdata->reset_gpio = of_get_named_gpio_flags(np, "synaptics,reset-gpio", 0, NULL); retval = of_property_read_u32(np, "synaptics,reset-on-state", &value); if (retval < 0) { dev_err(dev, "%s: Unable to read synaptics,reset-on-state property\n", __func__); return retval; } else { bdata->reset_on_state = value; } retval = of_property_read_u32(np, "synaptics,reset-active-ms", &value); if (retval < 0) { dev_err(dev, "%s: Unable to read synaptics,reset-active-ms property\n", __func__); return retval; } else { bdata->reset_active_ms = value; } } else { bdata->reset_gpio = -1; } prop = of_find_property(np, "synaptics,reset-delay-ms", NULL); if (prop && prop->length) { retval = of_property_read_u32(np, "synaptics,reset-delay-ms", &value); if (retval < 0) { dev_err(dev, "%s: Unable to read synaptics,reset-delay-ms property\n", __func__); return retval; } else { bdata->reset_delay_ms = value; } } else { bdata->reset_delay_ms = 0; } prop = of_find_property(np, "synaptics,dev-dscrptr-addr", NULL); if (prop && prop->length) { retval = of_property_read_u32(np, "synaptics,dev-dscrptr-addr", &value); if (retval < 0) { dev_err(dev, "%s: Unable to read synaptics,dev-dscrptr-addr property\n", __func__); return retval; } else { bdata->device_descriptor_addr = (unsigned short)value; } } else { bdata->device_descriptor_addr = 0; } prop = of_find_property(np, "synaptics,max-y-for-2d", NULL); if (prop && prop->length) { retval = of_property_read_u32(np, "synaptics,max-y-for-2d", &value); if (retval < 0) { dev_err(dev, "%s: Unable to read synaptics,max-y-for-2d property\n", __func__); return retval; } else { bdata->max_y_for_2d = value; } } else { bdata->max_y_for_2d = -1; } prop = of_find_property(np, "synaptics,swap-axes", NULL); bdata->swap_axes = prop > 0 ? true : false; prop = of_find_property(np, "synaptics,x-flip", NULL); bdata->x_flip = prop > 0 ? true : false; prop = of_find_property(np, "synaptics,y-flip", NULL); bdata->y_flip = prop > 0 ? true : false; prop = of_find_property(np, "synaptics,ub-i2c-addr", NULL); if (prop && prop->length) { retval = of_property_read_u32(np, "synaptics,ub-i2c-addr", &value); if (retval < 0) { dev_err(dev, "%s: Unable to read synaptics,ub-i2c-addr property\n", __func__); return retval; } else { bdata->ub_i2c_addr = (unsigned short)value; } } else { bdata->ub_i2c_addr = -1; } prop = of_find_property(np, "synaptics,cap-button-codes", NULL); if (prop && prop->length) { bdata->cap_button_map->map = devm_kzalloc(dev, prop->length, GFP_KERNEL); if (!bdata->cap_button_map->map) return -ENOMEM; bdata->cap_button_map->nbuttons = prop->length / sizeof(u32); retval = of_property_read_u32_array(np, "synaptics,cap-button-codes", bdata->cap_button_map->map, bdata->cap_button_map->nbuttons); if (retval < 0) { bdata->cap_button_map->nbuttons = 0; bdata->cap_button_map->map = NULL; } } else { bdata->cap_button_map->nbuttons = 0; bdata->cap_button_map->map = NULL; } prop = of_find_property(np, "synaptics,vir-button-codes", NULL); if (prop && prop->length) { bdata->vir_button_map->map = devm_kzalloc(dev, prop->length, GFP_KERNEL); if (!bdata->vir_button_map->map) return -ENOMEM; bdata->vir_button_map->nbuttons = prop->length / sizeof(u32); bdata->vir_button_map->nbuttons /= 5; retval = of_property_read_u32_array(np, "synaptics,vir-button-codes", bdata->vir_button_map->map, bdata->vir_button_map->nbuttons * 5); if (retval < 0) { bdata->vir_button_map->nbuttons = 0; bdata->vir_button_map->map = NULL; } } else { bdata->vir_button_map->nbuttons = 0; bdata->vir_button_map->map = NULL; } return 0; }
static struct ncp6335d_platform_data * ncp6335d_get_of_platform_data(struct i2c_client *client) { struct ncp6335d_platform_data *pdata = NULL; struct regulator_init_data *init_data; const char *mode_name; int rc; init_data = of_get_regulator_init_data(&client->dev, client->dev.of_node); if (!init_data) { dev_err(&client->dev, "regulator init data is missing\n"); return pdata; } pdata = devm_kzalloc(&client->dev, sizeof(struct ncp6335d_platform_data), GFP_KERNEL); if (!pdata) { dev_err(&client->dev, "ncp6335d_platform_data allocation failed.\n"); return pdata; } rc = of_property_read_u32(client->dev.of_node, "onnn,vsel", &pdata->default_vsel); if (rc < 0) { dev_err(&client->dev, "onnn,vsel property missing: rc = %d.\n", rc); return NULL; } rc = of_property_read_u32(client->dev.of_node, "onnn,slew-ns", &pdata->slew_rate_ns); if (rc < 0) { dev_err(&client->dev, "onnn,slew-ns property missing: rc = %d.\n", rc); return NULL; } pdata->discharge_enable = of_property_read_bool(client->dev.of_node, "onnn,discharge-enable"); pdata->sleep_enable = of_property_read_bool(client->dev.of_node, "onnn,sleep-enable"); pdata->init_data = init_data; init_data->constraints.input_uV = init_data->constraints.max_uV; init_data->constraints.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE | REGULATOR_CHANGE_STATUS | REGULATOR_CHANGE_MODE; init_data->constraints.valid_modes_mask = REGULATOR_MODE_NORMAL | REGULATOR_MODE_FAST; rc = of_property_read_string(client->dev.of_node, "onnn,mode", &mode_name); if (!rc) { if (strcmp("pwm", mode_name) == 0) { init_data->constraints.initial_mode = REGULATOR_MODE_FAST; } else if (strcmp("auto", mode_name) == 0) { init_data->constraints.initial_mode = REGULATOR_MODE_NORMAL; } else { dev_err(&client->dev, "onnn,mode, unknown regulator mode: %s\n", mode_name); return NULL; } } return pdata; }
static int mdss_dsi_get_dt_vreg_data(struct device *dev, struct dss_module_power *mp) { int i = 0, rc = 0; u32 tmp = 0; struct device_node *of_node = NULL, *supply_node = NULL; if (!dev || !mp) { pr_err("%s: invalid input\n", __func__); rc = -EINVAL; goto error; } of_node = dev->of_node; mp->num_vreg = 0; for_each_child_of_node(of_node, supply_node) { if (!strncmp(supply_node->name, "qcom,platform-supply-entry", 26)) ++mp->num_vreg; } if (mp->num_vreg == 0) { pr_debug("%s: no vreg\n", __func__); goto novreg; } else { pr_debug("%s: vreg found. count=%d\n", __func__, mp->num_vreg); } mp->vreg_config = devm_kzalloc(dev, sizeof(struct dss_vreg) * mp->num_vreg, GFP_KERNEL); if (!mp->vreg_config) { pr_err("%s: can't alloc vreg mem\n", __func__); rc = -ENOMEM; goto error; } for_each_child_of_node(of_node, supply_node) { if (!strncmp(supply_node->name, "qcom,platform-supply-entry", 26)) { const char *st = NULL; /* vreg-name */ rc = of_property_read_string(supply_node, "qcom,supply-name", &st); if (rc) { pr_err("%s: error reading name. rc=%d\n", __func__, rc); goto error; } snprintf(mp->vreg_config[i].vreg_name, ARRAY_SIZE((mp->vreg_config[i].vreg_name)), "%s", st); /* vreg-min-voltage */ rc = of_property_read_u32(supply_node, "qcom,supply-min-voltage", &tmp); if (rc) { pr_err("%s: error reading min volt. rc=%d\n", __func__, rc); goto error; } mp->vreg_config[i].min_voltage = tmp; /* vreg-max-voltage */ rc = of_property_read_u32(supply_node, "qcom,supply-max-voltage", &tmp); if (rc) { pr_err("%s: error reading max volt. rc=%d\n", __func__, rc); goto error; } mp->vreg_config[i].max_voltage = tmp; /* enable-load */ rc = of_property_read_u32(supply_node, "qcom,supply-enable-load", &tmp); if (rc) { pr_err("%s: error reading enable load. rc=%d\n", __func__, rc); goto error; } mp->vreg_config[i].enable_load = tmp; /* disable-load */ rc = of_property_read_u32(supply_node, "qcom,supply-disable-load", &tmp); if (rc) { pr_err("%s: error reading disable load. rc=%d\n", __func__, rc); goto error; } mp->vreg_config[i].disable_load = tmp; /* pre-sleep */ rc = of_property_read_u32(supply_node, "qcom,supply-pre-on-sleep", &tmp); if (rc) { pr_debug("%s: error reading supply pre sleep value. rc=%d\n", __func__, rc); } mp->vreg_config[i].pre_on_sleep = (!rc ? tmp : 0); rc = of_property_read_u32(supply_node, "qcom,supply-pre-off-sleep", &tmp); if (rc) { pr_debug("%s: error reading supply pre sleep value. rc=%d\n", __func__, rc); } mp->vreg_config[i].pre_off_sleep = (!rc ? tmp : 0); /* post-sleep */ rc = of_property_read_u32(supply_node, "qcom,supply-post-on-sleep", &tmp); if (rc) { pr_debug("%s: error reading supply post sleep value. rc=%d\n", __func__, rc); } mp->vreg_config[i].post_on_sleep = (!rc ? tmp : 0); rc = of_property_read_u32(supply_node, "qcom,supply-post-off-sleep", &tmp); if (rc) { pr_debug("%s: error reading supply post sleep value. rc=%d\n", __func__, rc); } mp->vreg_config[i].post_off_sleep = (!rc ? tmp : 0); pr_debug("%s: %s min=%d, max=%d, enable=%d, disable=%d, preonsleep=%d, postonsleep=%d, preoffsleep=%d, postoffsleep=%d\n", __func__, mp->vreg_config[i].vreg_name, mp->vreg_config[i].min_voltage, mp->vreg_config[i].max_voltage, mp->vreg_config[i].enable_load, mp->vreg_config[i].disable_load, mp->vreg_config[i].pre_on_sleep, mp->vreg_config[i].post_on_sleep, mp->vreg_config[i].pre_off_sleep, mp->vreg_config[i].post_off_sleep ); ++i; } } return rc; error: if (mp->vreg_config) { devm_kfree(dev, mp->vreg_config); mp->vreg_config = NULL; } novreg: mp->num_vreg = 0; return rc; }
static struct msm_bus_scale_pdata *get_pdata(struct platform_device *pdev, struct device_node *of_node) { struct msm_bus_scale_pdata *pdata = NULL; struct msm_bus_paths *usecase = NULL; int i = 0, j, ret, num_usecases = 0, num_paths, len; const uint32_t *vec_arr = NULL; bool mem_err = false; if (!pdev) { pr_err("Error: Null Platform device\n"); return NULL; } pdata = devm_kzalloc(&pdev->dev, sizeof(struct msm_bus_scale_pdata), GFP_KERNEL); if (!pdata) { pr_err("Error: Memory allocation for pdata failed\n"); mem_err = true; goto err; } ret = of_property_read_string(of_node, "qcom,msm-bus,name", &pdata->name); if (ret) { pr_err("Error: Client name not found\n"); goto err; } ret = of_property_read_u32(of_node, "qcom,msm-bus,num-cases", &num_usecases); if (ret) { pr_err("Error: num-usecases not found\n"); goto err; } pdata->num_usecases = num_usecases; if (of_property_read_bool(of_node, "qcom,msm-bus,active-only")) pdata->active_only = 1; else { pr_debug("active_only flag absent.\n"); pr_debug("Using dual context by default\n"); } usecase = devm_kzalloc(&pdev->dev, (sizeof(struct msm_bus_paths) * pdata->num_usecases), GFP_KERNEL); if (!usecase) { pr_err("Error: Memory allocation for paths failed\n"); mem_err = true; goto err; } ret = of_property_read_u32(of_node, "qcom,msm-bus,num-paths", &num_paths); if (ret) { pr_err("Error: num_paths not found\n"); goto err; } vec_arr = of_get_property(of_node, "qcom,msm-bus,vectors-KBps", &len); if (vec_arr == NULL) { pr_err("Error: Vector array not found\n"); goto err; } if (len != num_usecases * num_paths * sizeof(uint32_t) * 4) { pr_err("Error: Length-error on getting vectors\n"); goto err; } for (i = 0; i < num_usecases; i++) { usecase[i].num_paths = num_paths; usecase[i].vectors = devm_kzalloc(&pdev->dev, num_paths * sizeof(struct msm_bus_vectors), GFP_KERNEL); if (!usecase[i].vectors) { mem_err = true; pr_err("Error: Mem alloc failure in vectors\n"); goto err; } for (j = 0; j < num_paths; j++) { int index = ((i * num_paths) + j) * 4; usecase[i].vectors[j].src = be32_to_cpu(vec_arr[index]); usecase[i].vectors[j].dst = be32_to_cpu(vec_arr[index + 1]); usecase[i].vectors[j].ab = (uint64_t) KBTOB(be32_to_cpu(vec_arr[index + 2])); usecase[i].vectors[j].ib = (uint64_t) KBTOB(be32_to_cpu(vec_arr[index + 3])); } } pdata->usecase = usecase; return pdata; err: if (mem_err) { for (; i > 0; i--) kfree(usecase[i-1].vectors); kfree(usecase); kfree(pdata); } return NULL; }
static __init void vtwm_device_clk_init(struct device_node *node) { u32 en_reg, div_reg; struct clk *clk; struct clk_device *dev_clk; const char *clk_name = node->name; const char *parent_name; struct clk_init_data init; int rc; int clk_init_flags = 0; dev_clk = kzalloc(sizeof(*dev_clk), GFP_KERNEL); if (WARN_ON(!dev_clk)) return; dev_clk->lock = &_lock; rc = of_property_read_u32(node, "enable-reg", &en_reg); if (!rc) { dev_clk->en_reg = pmc_base + en_reg; rc = of_property_read_u32(node, "enable-bit", &dev_clk->en_bit); if (rc) { pr_err("%s: enable-bit property required for gated clock\n", __func__); return; } clk_init_flags |= CLK_INIT_GATED; } rc = of_property_read_u32(node, "divisor-reg", &div_reg); if (!rc) { dev_clk->div_reg = pmc_base + div_reg; /* * use 0x1f as the default mask since it covers * almost all the clocks and reduces dts properties */ dev_clk->div_mask = 0x1f; of_property_read_u32(node, "divisor-mask", &dev_clk->div_mask); clk_init_flags |= CLK_INIT_DIVISOR; } of_property_read_string(node, "clock-output-names", &clk_name); switch (clk_init_flags) { case CLK_INIT_GATED: init.ops = &vt8500_gated_clk_ops; break; case CLK_INIT_DIVISOR: init.ops = &vt8500_divisor_clk_ops; break; case CLK_INIT_GATED_DIVISOR: init.ops = &vt8500_gated_divisor_clk_ops; break; default: pr_err("%s: Invalid clock description in device tree\n", __func__); kfree(dev_clk); return; } init.name = clk_name; init.flags = 0; parent_name = of_clk_get_parent_name(node, 0); init.parent_names = &parent_name; init.num_parents = 1; dev_clk->hw.init = &init; clk = clk_register(NULL, &dev_clk->hw); if (WARN_ON(IS_ERR(clk))) { kfree(dev_clk); return; } rc = of_clk_add_provider(node, of_clk_src_simple_get, clk); clk_register_clkdev(clk, clk_name, NULL); }
static int __init meson_mx_socinfo_init(void) { struct soc_device_attribute *soc_dev_attr; struct soc_device *soc_dev; struct device_node *np; struct regmap *assist_regmap, *bootrom_regmap, *analog_top_regmap; unsigned int major_ver, misc_ver, metal_rev = 0; int ret; assist_regmap = syscon_regmap_lookup_by_compatible("amlogic,meson-mx-assist"); if (IS_ERR(assist_regmap)) return PTR_ERR(assist_regmap); bootrom_regmap = syscon_regmap_lookup_by_compatible("amlogic,meson-mx-bootrom"); if (IS_ERR(bootrom_regmap)) return PTR_ERR(bootrom_regmap); np = of_find_matching_node(NULL, meson_mx_socinfo_analog_top_ids); if (np) { analog_top_regmap = syscon_node_to_regmap(np); if (IS_ERR(analog_top_regmap)) return PTR_ERR(analog_top_regmap); ret = regmap_read(analog_top_regmap, MESON_MX_ANALOG_TOP_METAL_REVISION, &metal_rev); if (ret) return ret; } ret = regmap_read(assist_regmap, MESON_MX_ASSIST_HW_REV, &major_ver); if (ret < 0) return ret; ret = regmap_read(bootrom_regmap, MESON_MX_BOOTROM_MISC_VER, &misc_ver); if (ret < 0) return ret; soc_dev_attr = kzalloc(sizeof(*soc_dev_attr), GFP_KERNEL); if (!soc_dev_attr) return -ENODEV; soc_dev_attr->family = "Amlogic Meson"; np = of_find_node_by_path("/"); of_property_read_string(np, "model", &soc_dev_attr->machine); of_node_put(np); soc_dev_attr->revision = meson_mx_socinfo_revision(major_ver, misc_ver, metal_rev); soc_dev_attr->soc_id = meson_mx_socinfo_soc_id(major_ver, metal_rev); soc_dev = soc_device_register(soc_dev_attr); if (IS_ERR(soc_dev)) { kfree_const(soc_dev_attr->revision); kfree_const(soc_dev_attr->soc_id); kfree(soc_dev_attr); return PTR_ERR(soc_dev); } dev_info(soc_device_to_device(soc_dev), "Amlogic %s %s detected\n", soc_dev_attr->soc_id, soc_dev_attr->revision); return 0; }
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; 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; } 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) { 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 = 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.power_setting, &sensordata->power_info.power_setting_size); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto FREE_PS; } rc = msm_camera_get_dt_power_off_setting_data(of_node, sensordata->power_info.cam_vreg, sensordata->power_info.num_vreg, &sensordata->power_info.power_off_setting, &sensordata->power_info.power_off_setting_size); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto FREE_PS; } 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_VREG; } 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]; 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_VREG: kfree(s_ctrl->sensordata->power_info.cam_vreg); FREE_PS: kfree(s_ctrl->sensordata->power_info.power_setting); 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 __devinit pil_pronto_probe(struct platform_device *pdev) { struct pronto_data *drv; struct resource *res; struct pil_desc *desc; int ret; uint32_t regval; drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_KERNEL); if (!drv) return -ENOMEM; platform_set_drvdata(pdev, drv); res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pmu_base"); drv->base = devm_request_and_ioremap(&pdev->dev, res); if (!drv->base) return -ENOMEM; res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "clk_base"); drv->reset_base = devm_request_and_ioremap(&pdev->dev, res); if (!drv->reset_base) return -ENOMEM; res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "halt_base"); drv->axi_halt_base = devm_request_and_ioremap(&pdev->dev, res); if (!drv->axi_halt_base) return -ENOMEM; desc = &drv->desc; ret = of_property_read_string(pdev->dev.of_node, "qcom,firmware-name", &desc->name); if (ret) return ret; desc->dev = &pdev->dev; desc->owner = THIS_MODULE; desc->proxy_timeout = 10000; if (pas_supported(PAS_WCNSS) > 0) { desc->ops = &pil_pronto_ops_trusted; dev_info(&pdev->dev, "using secure boot\n"); } else { desc->ops = &pil_pronto_ops; dev_info(&pdev->dev, "using non-secure boot\n"); } drv->vreg = devm_regulator_get(&pdev->dev, "vdd_pronto_pll"); if (IS_ERR(drv->vreg)) { dev_err(&pdev->dev, "failed to get pronto pll supply"); return PTR_ERR(drv->vreg); } ret = regulator_set_voltage(drv->vreg, 1800000, 1800000); if (ret) { dev_err(&pdev->dev, "failed to set pll supply voltage\n"); return ret; } ret = regulator_set_optimum_mode(drv->vreg, 18000); if (ret < 0) { dev_err(&pdev->dev, "failed to set pll supply mode\n"); return ret; } drv->cxo = devm_clk_get(&pdev->dev, "xo"); if (IS_ERR(drv->cxo)) return PTR_ERR(drv->cxo); scm_pas_init(MSM_BUS_MASTER_CRYPTO_CORE0); ret = pil_desc_init(desc); if (ret) return ret; drv->subsys_desc.name = desc->name; drv->subsys_desc.dev = &pdev->dev; drv->subsys_desc.owner = THIS_MODULE; drv->subsys_desc.shutdown = wcnss_shutdown; drv->subsys_desc.powerup = wcnss_powerup; drv->subsys_desc.ramdump = wcnss_ramdump; drv->subsys_desc.crash_shutdown = crash_shutdown; drv->subsys_desc.start = pronto_start; drv->subsys_desc.stop = pronto_stop; drv->subsys_desc.err_fatal_handler = wcnss_err_fatal_intr_handler; drv->subsys_desc.wdog_bite_handler = wcnss_wdog_bite_irq_hdlr; INIT_DELAYED_WORK(&drv->cancel_vote_work, wcnss_post_bootup); INIT_WORK(&drv->wcnss_wdog_bite_work, wcnss_wdog_bite_work_hdlr); //S [VY52/VY55][bug_1807] Frank_Chan add INIT_DELAYED_WORK(&drv->subsys_crash_work, wcnss_subsys_crash_info); //E [VY52/VY55][bug_1807] Frank_Chan add drv->subsys = subsys_register(&drv->subsys_desc); if (IS_ERR(drv->subsys)) { ret = PTR_ERR(drv->subsys); goto err_subsys; } drv->ramdump_dev = create_ramdump_device("pronto", &pdev->dev); if (!drv->ramdump_dev) { ret = -ENOMEM; goto err_irq; } /* Initialize common_ss GDSCR to wait 4 cycles between states */ regval = readl_relaxed(drv->base + PRONTO_PMU_COMMON_GDSCR) & PRONTO_PMU_COMMON_GDSCR_SW_COLLAPSE; regval |= (2 << EN_REST_WAIT) | (2 << EN_FEW_WAIT) | (2 << CLK_DIS_WAIT); writel_relaxed(regval, drv->base + PRONTO_PMU_COMMON_GDSCR); return 0; err_irq: subsys_unregister(drv->subsys); err_subsys: pil_desc_release(desc); return ret; }
static int32_t msm_sensor_fill_eeprom_subdevid_by_name( struct msm_sensor_ctrl_t *s_ctrl) { int32_t rc = 0; const char *eeprom_name; struct device_node *src_node = NULL; uint32_t val = 0, count = 0, eeprom_name_len; int i; int32_t *eeprom_subdev_id; struct msm_sensor_info_t *sensor_info; struct device_node *of_node = s_ctrl->of_node; const void *p; if (!s_ctrl->sensordata->eeprom_name || !of_node) return -EINVAL; eeprom_name_len = strlen(s_ctrl->sensordata->eeprom_name); if (eeprom_name_len >= MAX_SENSOR_NAME) return -EINVAL; sensor_info = s_ctrl->sensordata->sensor_info; eeprom_subdev_id = &sensor_info->subdev_id[SUB_MODULE_EEPROM]; /* * string for eeprom name is valid, set sudev id to -1 * and try to found new id */ *eeprom_subdev_id = -1; if (0 == eeprom_name_len) return 0; CDBG("Try to find eeprom subdev for %s\n", s_ctrl->sensordata->eeprom_name); p = of_get_property(of_node, "qcom,eeprom-src", &count); if (!p || !count) return 0; count /= sizeof(uint32_t); for (i = 0; i < count; i++) { eeprom_name = NULL; src_node = of_parse_phandle(of_node, "qcom,eeprom-src", i); if (!src_node) { pr_err("eeprom src node NULL\n"); continue; } rc = of_property_read_string(src_node, "qcom,eeprom-name", &eeprom_name); if (rc < 0) { pr_err("failed\n"); of_node_put(src_node); continue; } if (strcmp(eeprom_name, s_ctrl->sensordata->eeprom_name)) continue; 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("failed\n"); of_node_put(src_node); continue; } *eeprom_subdev_id = val; CDBG("Done. Eeprom subdevice id is %d\n", val); of_node_put(src_node); src_node = NULL; break; } return rc; }
static int32_t msm_sensor_driver_get_dt_data(struct msm_sensor_ctrl_t *s_ctrl) { int32_t rc = 0; struct msm_camera_sensor_board_info *sensordata = NULL; struct device_node *of_node = s_ctrl->of_node; uint32_t cell_id; int32_t i; s_ctrl->sensordata = kzalloc(sizeof(*sensordata), GFP_KERNEL); if (!s_ctrl->sensordata) { pr_err("failed: no memory"); return -ENOMEM; } sensordata = s_ctrl->sensordata; /* * Read cell index - this cell index will be the camera slot where * this camera will be mounted */ rc = of_property_read_u32(of_node, "cell-index", &cell_id); if (rc < 0) { pr_err("failed: cell-index rc %d", rc); goto FREE_SENSOR_DATA; } s_ctrl->id = cell_id; /* Validate cell_id */ if (cell_id >= MAX_CAMERAS) { pr_err("failed: invalid cell_id %d", cell_id); rc = -EINVAL; goto FREE_SENSOR_DATA; } /* Check whether g_sctrl is already filled for this cell_id */ if (g_sctrl[cell_id]) { pr_err("failed: sctrl already filled for cell_id %d", cell_id); rc = -EINVAL; goto FREE_SENSOR_DATA; } sensordata->special_support_size = of_property_count_strings(of_node, "qcom,special-support-sensors"); if (sensordata->special_support_size < 0) sensordata->special_support_size = 0; if (sensordata->special_support_size > MAX_SPECIAL_SUPPORT_SIZE) { pr_err("%s:support_size exceed max support size\n",__func__); sensordata->special_support_size = MAX_SPECIAL_SUPPORT_SIZE; } if (sensordata->special_support_size) { for( i = 0; i < sensordata->special_support_size; i++) { rc = of_property_read_string_index(of_node, "qcom,special-support-sensors", i, &(sensordata->special_support_sensors[i])); if(rc < 0 ) { /* if read sensor support names failed, * set support all sensors, break; */ sensordata->special_support_size = 0; break ; } CDBG("%s special_support_sensors[%d] = %s\n", __func__, i, sensordata->special_support_sensors[i]); } } /* Read subdev info */ rc = msm_sensor_get_sub_module_index(of_node, &sensordata->sensor_info); if (rc < 0) { pr_err("failed"); goto FREE_SENSOR_DATA; } /* Read vreg information */ rc = msm_camera_get_dt_vreg_data(of_node, &sensordata->power_info.cam_vreg, &sensordata->power_info.num_vreg); if (rc < 0) { pr_err("failed: msm_camera_get_dt_vreg_data rc %d", rc); goto FREE_SUB_MODULE_DATA; } /* Read gpio information */ rc = msm_sensor_driver_get_gpio_data(sensordata, of_node); if (rc < 0) { pr_err("failed: msm_sensor_driver_get_gpio_data rc %d", rc); goto FREE_VREG_DATA; } /* Get CCI master */ rc = of_property_read_u32(of_node, "qcom,cci-master", &s_ctrl->cci_i2c_master); CDBG("qcom,cci-master %d, rc %d", s_ctrl->cci_i2c_master, rc); if (rc < 0) { /* Set default master 0 */ s_ctrl->cci_i2c_master = MASTER_0; rc = 0; } /* Get mount angle */ if (0 > of_property_read_u32(of_node, "qcom,mount-angle", &sensordata->sensor_info->sensor_mount_angle)) { /* Invalidate mount angle flag */ sensordata->sensor_info->is_mount_angle_valid = 0; sensordata->sensor_info->sensor_mount_angle = 0; } else { sensordata->sensor_info->is_mount_angle_valid = 1; } CDBG("%s qcom,mount-angle %d\n", __func__, sensordata->sensor_info->sensor_mount_angle); if (0 > of_property_read_u32(of_node, "qcom,sensor-position", &sensordata->sensor_info->position)) { CDBG("%s:%d Invalid sensor position\n", __func__, __LINE__); sensordata->sensor_info->position = INVALID_CAMERA_B; } if (0 > of_property_read_u32(of_node, "qcom,sensor-mode", &sensordata->sensor_info->modes_supported)) { CDBG("%s:%d Invalid sensor mode supported\n", __func__, __LINE__); sensordata->sensor_info->modes_supported = CAMERA_MODE_INVALID; } /* Get vdd-cx regulator */ /*Optional property, don't return error if absent */ of_property_read_string(of_node, "qcom,vdd-cx-name", &sensordata->misc_regulator); CDBG("qcom,misc_regulator %s", sensordata->misc_regulator); s_ctrl->set_mclk_23880000 = of_property_read_bool(of_node, "qcom,mclk-23880000"); CDBG("%s qcom,mclk-23880000 = %d\n", __func__, s_ctrl->set_mclk_23880000); return rc; FREE_VREG_DATA: kfree(sensordata->power_info.cam_vreg); FREE_SUB_MODULE_DATA: kfree(sensordata->sensor_info); FREE_SENSOR_DATA: kfree(sensordata); return rc; }
static int32_t msm_eeprom_platform_probe(struct platform_device *pdev) { int32_t rc = 0; #ifdef QULCOMM_ORIGINAL int32_t j = 0; #endif uint32_t temp; struct msm_camera_cci_client *cci_client = NULL; struct msm_eeprom_ctrl_t *e_ctrl = NULL; struct msm_eeprom_board_info *eb_info = NULL; struct device_node *of_node = pdev->dev.of_node; struct msm_camera_power_ctrl_t *power_info = NULL; CDBG("%s E\n", __func__); e_ctrl = kzalloc(sizeof(struct msm_eeprom_ctrl_t), GFP_KERNEL); if (!e_ctrl) { pr_err("%s:%d kzalloc failed\n", __func__, __LINE__); return -ENOMEM; } e_ctrl->eeprom_v4l2_subdev_ops = &msm_eeprom_subdev_ops; e_ctrl->eeprom_mutex = &msm_eeprom_mutex; e_ctrl->is_supported = 0; if (!of_node) { pr_err("%s dev.of_node NULL\n", __func__); kfree(e_ctrl); return -EINVAL; } rc = of_property_read_u32(of_node, "cell-index", &pdev->id); CDBG("cell-index %d, rc %d\n", pdev->id, rc); if (rc < 0) { pr_err("failed rc %d\n", rc); kfree(e_ctrl); return rc; } e_ctrl->subdev_id = pdev->id; rc = of_property_read_u32(of_node, "qcom,cci-master", &e_ctrl->cci_master); CDBG("qcom,cci-master %d, rc %d\n", e_ctrl->cci_master, rc); if (rc < 0) { pr_err("%s failed rc %d\n", __func__, rc); kfree(e_ctrl); return rc; } rc = of_property_read_u32(of_node, "qcom,slave-addr", &temp); if (rc < 0) { pr_err("%s failed rc %d\n", __func__, rc); kfree(e_ctrl); return rc; } /* Set platform device handle */ e_ctrl->pdev = pdev; /* Set device type as platform device */ e_ctrl->eeprom_device_type = MSM_CAMERA_PLATFORM_DEVICE; e_ctrl->i2c_client.i2c_func_tbl = &msm_eeprom_cci_func_tbl; e_ctrl->i2c_client.cci_client = kzalloc(sizeof( struct msm_camera_cci_client), GFP_KERNEL); if (!e_ctrl->i2c_client.cci_client) { pr_err("%s failed no memory\n", __func__); kfree(e_ctrl); return -ENOMEM; } e_ctrl->eboard_info = kzalloc(sizeof( struct msm_eeprom_board_info), GFP_KERNEL); if (!e_ctrl->eboard_info) { pr_err("%s failed line %d\n", __func__, __LINE__); rc = -ENOMEM; goto cciclient_free; } eb_info = e_ctrl->eboard_info; power_info = &eb_info->power_info; eb_info->i2c_slaveaddr = temp; power_info->clk_info = cam_8974_clk_info; power_info->clk_info_size = ARRAY_SIZE(cam_8974_clk_info); power_info->dev = &pdev->dev; CDBG("qcom,slave-addr = 0x%X\n", eb_info->i2c_slaveaddr); cci_client = e_ctrl->i2c_client.cci_client; cci_client->cci_subdev = msm_cci_get_subdev(); cci_client->cci_i2c_master = e_ctrl->cci_master; cci_client->sid = eb_info->i2c_slaveaddr >> 1; cci_client->retries = 3; cci_client->id_map = 0; rc = of_property_read_string(of_node, "qcom,eeprom-name", &eb_info->eeprom_name); CDBG("%s qcom,eeprom-name %s, rc %d\n", __func__, eb_info->eeprom_name, rc); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto board_free; } #ifdef QULCOMM_ORIGINAL rc = msm_eeprom_get_dt_data(e_ctrl); if (rc) goto board_free; #else if (e_ctrl->eeprom_device_type == MSM_CAMERA_PLATFORM_DEVICE) { rc = e_ctrl->i2c_client.i2c_func_tbl->i2c_util( &e_ctrl->i2c_client, MSM_CCI_INIT); if (rc < 0) pr_err("%s cci_init failed\n", __func__); } #endif rc = msm_eeprom_alloc_memory_map(e_ctrl, of_node); if (rc) goto board_free; #ifdef QULCOMM_ORIGINAL rc = msm_camera_power_up(power_info, e_ctrl->eeprom_device_type, &e_ctrl->i2c_client); if (rc) { pr_err("failed rc %d\n", rc); goto memdata_free; } rc = read_eeprom_memory(e_ctrl); if (rc < 0) { pr_err("%s read_eeprom_memory failed\n", __func__); goto power_down; } pr_err("%s line %d\n", __func__, __LINE__); for (j = 0; j < e_ctrl->num_bytes; j++) CDBG("memory_data[%d] = 0x%X\n", j, e_ctrl->memory_data[j]); rc = msm_camera_power_down(power_info, e_ctrl->eeprom_device_type, &e_ctrl->i2c_client); if (rc) { pr_err("failed rc %d\n", rc); goto memdata_free; } #else /* */ global_e_ctrl = e_ctrl; global_eb_info = eb_info; /* */ #endif v4l2_subdev_init(&e_ctrl->msm_sd.sd, e_ctrl->eeprom_v4l2_subdev_ops); v4l2_set_subdevdata(&e_ctrl->msm_sd.sd, e_ctrl); platform_set_drvdata(pdev, &e_ctrl->msm_sd.sd); e_ctrl->msm_sd.sd.internal_ops = &msm_eeprom_internal_ops; e_ctrl->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; snprintf(e_ctrl->msm_sd.sd.name, ARRAY_SIZE(e_ctrl->msm_sd.sd.name), "msm_eeprom"); media_entity_init(&e_ctrl->msm_sd.sd.entity, 0, NULL, 0); e_ctrl->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV; e_ctrl->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_EEPROM; msm_sd_register(&e_ctrl->msm_sd); if (e_ctrl->eeprom_device_type == MSM_CAMERA_PLATFORM_DEVICE) { rc = e_ctrl->i2c_client.i2c_func_tbl->i2c_util( &e_ctrl->i2c_client, MSM_CCI_RELEASE); if (rc < 0) pr_err("%s cci_init failed\n", __func__); } e_ctrl->is_supported = 1; CDBG("%s X\n", __func__); return rc; /* */ #ifdef QULCOMM_ORIGINAL power_down: msm_camera_power_down(power_info, e_ctrl->eeprom_device_type, &e_ctrl->i2c_client); memdata_free: kfree(e_ctrl->memory_data); kfree(eb_info->eeprom_map); #endif /* */ board_free: kfree(e_ctrl->eboard_info); cciclient_free: kfree(e_ctrl->i2c_client.cci_client); kfree(e_ctrl); return rc; }
/** * nvs_of_dt - NVS sensor device tree configuration. * @np: mandatory device node pointer. * @cfg: sensor's configuration pointer. * This can be called early with cfg == NULL to determine * if the device is available based on returned -ENODEV or * -EINVAL. * @dev_name: name of sensor device. If this is NULL then the * sensor configuration's name member is used. * * Returns: -EINVAL = np and/or cfg are NULL. * -ENODEV = if device is not available. * 0 = no default configuration changes were made. * >0 = number of default configuration changes made. * Note this does not include expected device tree * configuration settings such as matrix and * calibration. Also not included is whether the * device was disabled via the NVS mechanism. */ int nvs_of_dt(const struct device_node *np, struct sensor_cfg *cfg, const char *dev_name) { s32 s32tmp = 0; u32 u32tmp = 0; char str[256]; const char *charp; int lenp; unsigned int i; unsigned int cfg_changes = 0; if (np == NULL) return -EINVAL; if (!of_device_is_available(np)) return -ENODEV; if (cfg == NULL) return -EINVAL; if (dev_name == NULL) dev_name = cfg->name; if (sprintf(str, "%s_disable", dev_name) > 0) { if (!of_property_read_u32(np, str, (u32 *)&i)) { if (i) cfg->snsr_id = -1; } } if (sprintf(str, "%s_float_significance", dev_name) > 0) { if (!of_property_read_string((struct device_node *)np, str, &charp)) { u32tmp = ARRAY_SIZE(nvs_float_significances); for (i = 0; i < u32tmp; i++) { if (!strcasecmp(charp, nvs_float_significances[i])) { if (cfg->float_significance != i) { cfg->float_significance = i; cfg_changes++; } break; } } } } if (sprintf(str, "%s_flags", dev_name) > 0) { if (!of_property_read_u32(np, str, &u32tmp)) { i = cfg->flags & SENSOR_FLAG_READONLY_MASK; u32tmp &= ~SENSOR_FLAG_READONLY_MASK; i |= u32tmp; if (cfg->flags != i) { cfg->flags = i; cfg_changes++; } } } if (sprintf(str, "%s_kbuffer_size", dev_name) > 0) { if (!of_property_read_s32(np, str, &s32tmp)) { if (cfg->kbuf_sz != s32tmp) { cfg->kbuf_sz = s32tmp; cfg_changes++; } } } if (sprintf(str, "%s_max_range_ival", dev_name) > 0) { if (!of_property_read_s32(np, str, &s32tmp)) { if (cfg->max_range.ival != s32tmp) { cfg->max_range.ival = s32tmp; cfg_changes++; } } } if (sprintf(str, "%s_max_range_fval", dev_name) > 0) { if (!of_property_read_s32(np, str, &s32tmp)) { if (cfg->max_range.fval != s32tmp) { cfg->max_range.fval = s32tmp; cfg_changes++; } } } if (sprintf(str, "%s_resolution_ival", dev_name) > 0) { if (!of_property_read_s32(np, str, &s32tmp)) { if (cfg->resolution.ival != s32tmp) { cfg->resolution.ival = s32tmp; cfg_changes++; } } } if (sprintf(str, "%s_resolution_fval", dev_name) > 0) { if (!of_property_read_s32(np, str, &s32tmp)) { if (cfg->resolution.fval != s32tmp) { cfg->resolution.fval = s32tmp; cfg_changes++; } } } if (sprintf(str, "%s_milliamp_ival", dev_name) > 0) { if (!of_property_read_s32(np, str, &s32tmp)) { if (cfg->milliamp.ival != s32tmp) { cfg->milliamp.ival = s32tmp; cfg_changes++; } } } if (sprintf(str, "%s_milliamp_fval", dev_name) > 0) { if (!of_property_read_s32(np, str, &s32tmp)) { if (cfg->milliamp.fval != s32tmp) { cfg->milliamp.fval = s32tmp; cfg_changes++; } } } if (sprintf(str, "%s_delay_us_min", dev_name) > 0) { if (!of_property_read_s32(np, str, &s32tmp)) { if (cfg->delay_us_min != s32tmp) { cfg->delay_us_min = s32tmp; cfg_changes++; } } } if (sprintf(str, "%s_delay_us_max", dev_name) > 0) { if (!of_property_read_s32(np, str, &s32tmp)) { if (cfg->delay_us_max != s32tmp) { cfg->delay_us_max = s32tmp; cfg_changes++; } } } if (sprintf(str, "%s_fifo_reserved_event_count", dev_name) > 0) { if (!of_property_read_u32(np, str, &u32tmp)) { if (cfg->fifo_rsrv_evnt_cnt != u32tmp) { cfg->fifo_rsrv_evnt_cnt = u32tmp; cfg_changes++; } } } if (sprintf(str, "%s_fifo_max_event_count", dev_name) > 0) { if (!of_property_read_u32(np, str, &u32tmp)) { if (cfg->fifo_max_evnt_cnt != u32tmp) { cfg->fifo_max_evnt_cnt = u32tmp; cfg_changes++; } } } if (sprintf(str, "%s_matrix", dev_name) > 0) { charp = of_get_property(np, str, &lenp); if (charp && lenp == sizeof(cfg->matrix)) memcpy(&cfg->matrix, charp, lenp); } if (sprintf(str, "%s_uncalibrated_lo", dev_name) > 0) of_property_read_s32(np, str, (s32 *)&cfg->uncal_lo); if (sprintf(str, "%s_uncalibrated_hi", dev_name) > 0) of_property_read_s32(np, str, (s32 *)&cfg->uncal_hi); if (sprintf(str, "%s_calibrated_lo", dev_name) > 0) of_property_read_s32(np, str, (s32 *)&cfg->cal_lo); if (sprintf(str, "%s_calibrated_hi", dev_name) > 0) of_property_read_s32(np, str, (s32 *)&cfg->cal_hi); if (sprintf(str, "%s_threshold_lo", dev_name) > 0) { if (!of_property_read_s32(np, str, &s32tmp)) { if (cfg->thresh_lo != s32tmp) { cfg->thresh_lo = s32tmp; cfg_changes++; } } } if (sprintf(str, "%s_threshold_hi", dev_name) > 0) { if (!of_property_read_s32(np, str, &s32tmp)) { if (cfg->thresh_hi != s32tmp) { cfg->thresh_hi = s32tmp; cfg_changes++; } } } if (sprintf(str, "%s_report_count", dev_name) > 0) { if (!of_property_read_s32(np, str, &s32tmp)) { if (cfg->report_n != s32tmp) { cfg->report_n = s32tmp; cfg_changes++; } } } if (sprintf(str, "%s_scale_ival", dev_name) > 0) { if (!of_property_read_s32(np, str, &s32tmp)) { if (cfg->scale.ival != s32tmp) { cfg->scale.ival = s32tmp; cfg_changes++; } } } if (sprintf(str, "%s_scale_fval", dev_name) > 0) { if (!of_property_read_s32(np, str, &s32tmp)) { if (cfg->scale.fval != s32tmp) { cfg->scale.fval = s32tmp; cfg_changes++; } } } if (sprintf(str, "%s_offset_ival", dev_name) > 0) { if (!of_property_read_s32(np, str, &s32tmp)) { if (cfg->offset.ival != s32tmp) { cfg->offset.ival = s32tmp; cfg_changes++; } } } if (sprintf(str, "%s_offset_fval", dev_name) > 0) { if (!of_property_read_s32(np, str, &s32tmp)) { if (cfg->offset.fval != s32tmp) { cfg->offset.fval = s32tmp; cfg_changes++; } } } for (i = 0; i < cfg->ch_n_max; i++) { if (sprintf(str, "%s_scale_ival_ch%u", dev_name, i) > 0) { if (!of_property_read_s32(np, str, &s32tmp)) { if (cfg->scales[i].ival != s32tmp) { cfg->scales[i].ival = s32tmp; cfg_changes++; } } } if (sprintf(str, "%s_scale_fval_ch%u", dev_name, i) > 0) { if (!of_property_read_s32(np, str, &s32tmp)) { if (cfg->scales[i].fval != s32tmp) { cfg->scales[i].fval = s32tmp; cfg_changes++; } } } if (sprintf(str, "%s_offset_ival_ch%u", dev_name, i) > 0) { if (!of_property_read_s32(np, str, &s32tmp)) { if (cfg->offsets[i].ival != s32tmp) { cfg->offsets[i].ival = s32tmp; cfg_changes++; } } } if (sprintf(str, "%s_offset_fval_ch%u", dev_name, i) > 0) { if (!of_property_read_s32(np, str, &s32tmp)) { if (cfg->offsets[i].fval != s32tmp) { cfg->offsets[i].fval = s32tmp; cfg_changes++; } } } } return cfg_changes; }
static int sti_mbox_probe(struct platform_device *pdev) { const struct of_device_id *match; struct mbox_controller *mbox; struct sti_mbox_device *mdev; struct device_node *np = pdev->dev.of_node; struct mbox_chan *chans; struct resource *res; int irq; int ret; match = of_match_device(sti_mailbox_match, &pdev->dev); if (!match) { dev_err(&pdev->dev, "No configuration found\n"); return -ENODEV; } pdev->dev.platform_data = (struct sti_mbox_pdata *) match->data; mdev = devm_kzalloc(&pdev->dev, sizeof(*mdev), GFP_KERNEL); if (!mdev) return -ENOMEM; platform_set_drvdata(pdev, mdev); res = platform_get_resource(pdev, IORESOURCE_MEM, 0); mdev->base = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(mdev->base)) return PTR_ERR(mdev->base); ret = of_property_read_string(np, "mbox-name", &mdev->name); if (ret) mdev->name = np->full_name; mbox = devm_kzalloc(&pdev->dev, sizeof(*mbox), GFP_KERNEL); if (!mbox) return -ENOMEM; chans = devm_kzalloc(&pdev->dev, sizeof(*chans) * STI_MBOX_CHAN_MAX, GFP_KERNEL); if (!chans) return -ENOMEM; mdev->dev = &pdev->dev; mdev->mbox = mbox; spin_lock_init(&mdev->lock); /* STi Mailbox does not have a Tx-Done or Tx-Ready IRQ */ mbox->txdone_irq = false; mbox->txdone_poll = true; mbox->txpoll_period = 100; mbox->ops = &sti_mbox_ops; mbox->dev = mdev->dev; mbox->of_xlate = sti_mbox_xlate; mbox->chans = chans; mbox->num_chans = STI_MBOX_CHAN_MAX; ret = mbox_controller_register(mbox); if (ret) return ret; /* It's okay for Tx Mailboxes to not supply IRQs */ irq = platform_get_irq(pdev, 0); if (irq < 0) { dev_info(&pdev->dev, "%s: Registered Tx only Mailbox\n", mdev->name); return 0; } ret = devm_request_threaded_irq(&pdev->dev, irq, sti_mbox_irq_handler, sti_mbox_thread_handler, IRQF_ONESHOT, mdev->name, mdev); if (ret) { dev_err(&pdev->dev, "Can't claim IRQ %d\n", irq); mbox_controller_unregister(mbox); return -EINVAL; } dev_info(&pdev->dev, "%s: Registered Tx/Rx Mailbox\n", mdev->name); return 0; }
static int SM5414_charger_parse_dt(struct sec_charger_info *charger) { struct device_node *np = of_find_node_by_name(NULL, "charger"); sec_battery_platform_data_t *pdata = charger->pdata; int ret = 0; int i, len; const u32 *p; if (np == NULL) { pr_err("%s np NULL\n", __func__); return -1; } else { ret = of_get_named_gpio(np, "battery,vbus_ctrl_gpio", 0); if (ret > 0) { pdata->vbus_ctrl_gpio = ret; pr_info("%s reading vbus_ctrl_gpio = %d\n", __func__, ret); } else { pdata->vbus_ctrl_gpio = 0; pr_info("%s vbus_ctrl_gpio read fail\n", __func__); } ret = of_property_read_u32(np, "battery,chg_float_voltage", &pdata->chg_float_voltage); if (ret < 0) pr_err("%s: chg_float_voltage read failed (%d)\n", __func__, ret); ret = of_property_read_u32(np, "battery,ovp_uvlo_check_type", &pdata->ovp_uvlo_check_type); if (ret < 0) pr_err("%s: ovp_uvlo_check_type read failed (%d)\n", __func__, ret); ret = of_property_read_u32(np, "battery,full_check_type", &pdata->full_check_type); if (ret < 0) pr_err("%s: full_check_type read failed (%d)\n", __func__, ret); p = of_get_property(np, "battery,input_current_limit", &len); len = len / sizeof(u32); pdata->charging_current = kzalloc(sizeof(sec_charging_current_t) * len, GFP_KERNEL); for(i = 0; i < len; i++) { ret = SM5414_charger_read_u32_index_dt(np, "battery,input_current_limit", i, &pdata->charging_current[i].input_current_limit); ret = SM5414_charger_read_u32_index_dt(np, "battery,fast_charging_current", i, &pdata->charging_current[i].fast_charging_current); ret = SM5414_charger_read_u32_index_dt(np, "battery,full_check_current_1st", i, &pdata->charging_current[i].full_check_current_1st); ret = SM5414_charger_read_u32_index_dt(np, "battery,full_check_current_2nd", i, &pdata->charging_current[i].full_check_current_2nd); } ret = of_property_read_string(np, "battery,fuelgauge_name", (char const **)&pdata->fuelgauge_name); if (ret) pr_err("%s: fuelgauge_name read failed\n", __func__); } return ret; }
static int sprd_dt_node_to_map(struct pinctrl_dev *pctldev, struct device_node *np, struct pinctrl_map **map, unsigned int *num_maps) { struct sprd_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev); const struct sprd_pin_group *grp; unsigned long *configs = NULL; unsigned int num_configs = 0; unsigned int reserved_maps = 0; unsigned int reserve = 0; const char *function; enum pinctrl_map_type type; int ret; grp = sprd_pinctrl_find_group_by_name(pctl, np->name); if (!grp) { dev_err(pctl->dev, "unable to find group for node %s\n", of_node_full_name(np)); return -EINVAL; } ret = of_property_count_strings(np, "pins"); if (ret < 0) return ret; if (ret == 1) type = PIN_MAP_TYPE_CONFIGS_PIN; else type = PIN_MAP_TYPE_CONFIGS_GROUP; ret = of_property_read_string(np, "function", &function); if (ret < 0) { if (ret != -EINVAL) dev_err(pctl->dev, "%s: could not parse property function\n", of_node_full_name(np)); function = NULL; } ret = pinconf_generic_parse_dt_config(np, pctldev, &configs, &num_configs); if (ret < 0) { dev_err(pctl->dev, "%s: could not parse node property\n", of_node_full_name(np)); return ret; } *map = NULL; *num_maps = 0; if (function != NULL) reserve++; if (num_configs) reserve++; ret = pinctrl_utils_reserve_map(pctldev, map, &reserved_maps, num_maps, reserve); if (ret < 0) goto out; if (function) { ret = pinctrl_utils_add_map_mux(pctldev, map, &reserved_maps, num_maps, grp->name, function); if (ret < 0) goto out; } if (num_configs) { const char *group_or_pin; unsigned int pin_id; if (type == PIN_MAP_TYPE_CONFIGS_PIN) { pin_id = grp->pins[0]; group_or_pin = pin_get_name(pctldev, pin_id); } else { group_or_pin = grp->name; } ret = pinctrl_utils_add_map_configs(pctldev, map, &reserved_maps, num_maps, group_or_pin, configs, num_configs, type); } out: kfree(configs); return ret; }
static struct msm_bus_node_info *get_nodes(struct device_node *of_node, struct platform_device *pdev, struct msm_bus_fabric_registration *pdata) { struct msm_bus_node_info *info; struct device_node *child_node = NULL; int i = 0, ret; int j, max_masterp = 0, max_slavep = 0; u32 temp; for_each_child_of_node(of_node, child_node) { i++; } pdata->len = i; info = (struct msm_bus_node_info *) devm_kzalloc(&pdev->dev, sizeof(struct msm_bus_node_info) * pdata->len, GFP_KERNEL); if (ZERO_OR_NULL_PTR(info)) { pr_err("Failed to alloc memory for nodes: %d\n", pdata->len); goto err; } i = 0; child_node = NULL; for_each_child_of_node(of_node, child_node) { const char *sel_str; ret = of_property_read_string(child_node, "label", &info[i].name); if (ret) pr_err("Error reading node label\n"); ret = of_property_read_u32(child_node, "cell-id", &info[i].id); if (ret) { pr_err("Error reading node id\n"); goto err; } if (of_property_read_bool(child_node, "qcom,gateway")) info[i].gateway = 1; of_property_read_u32(child_node, "qcom,mas-hw-id", &info[i].mas_hw_id); of_property_read_u32(child_node, "qcom,slv-hw-id", &info[i].slv_hw_id); info[i].masterp = get_arr(pdev, child_node, "qcom,masterp", &info[i].num_mports); /* No need to store number of qports */ info[i].qport = get_arr(pdev, child_node, "qcom,qport", &ret); pdata->nmasters += info[i].num_mports; for (j = 0; j < info[i].num_mports; j++) max_masterp = max(info[i].masterp[j], max_masterp); info[i].slavep = get_arr(pdev, child_node, "qcom,slavep", &info[i].num_sports); pdata->nslaves += info[i].num_sports; for (j = 0; j < info[i].num_sports; j++) max_slavep = max(info[i].slavep[j], max_slavep); info[i].tier = get_arr(pdev, child_node, "qcom,tier", &info[i].num_tiers); if (of_property_read_bool(child_node, "qcom,ahb")) info[i].ahb = 1; ret = of_property_read_string(child_node, "qcom,hw-sel", &sel_str); if (ret) info[i].hw_sel = 0; else { ret = get_num(hw_sel_name, sel_str); if (ret < 0) { pr_err("Invalid hw-sel\n"); goto err; } info[i].hw_sel = ret; } of_property_read_u32(child_node, "qcom,buswidth", &info[i].buswidth); of_property_read_u32(child_node, "qcom,ws", &info[i].ws); ret = of_property_read_u32(child_node, "qcom,thresh", &temp); if (!ret) info[i].th = (uint64_t)KBTOB(temp); ret = of_property_read_u32(child_node, "qcom,bimc,bw", &temp); if (!ret) info[i].bimc_bw = (uint64_t)KBTOB(temp); of_property_read_u32(child_node, "qcom,bimc,gp", &info[i].bimc_gp); of_property_read_u32(child_node, "qcom,bimc,thmp", &info[i].bimc_thmp); ret = of_property_read_string(child_node, "qcom,mode", &sel_str); if (ret) info[i].mode = 0; else { ret = get_num(mode_sel_name, sel_str); if (ret < 0) { pr_err("Unknown mode :%s\n", sel_str); goto err; } info[i].mode = ret; } info[i].dual_conf = of_property_read_bool(child_node, "qcom,dual-conf"); ret = of_property_read_string(child_node, "qcom,mode-thresh", &sel_str); if (ret) info[i].mode_thresh = 0; else { ret = get_num(mode_sel_name, sel_str); if (ret < 0) { pr_err("Unknown mode :%s\n", sel_str); goto err; } info[i].mode_thresh = ret; MSM_BUS_DBG("AXI: THreshold mode set: %d\n", info[i].mode_thresh); } ret = of_property_read_string(child_node, "qcom,perm-mode", &sel_str); if (ret) info[i].perm_mode = 0; else { ret = get_num(mode_sel_name, sel_str); if (ret < 0) goto err; info[i].perm_mode = 1 << ret; } of_property_read_u32(child_node, "qcom,prio-lvl", &info[i].prio_lvl); of_property_read_u32(child_node, "qcom,prio-rd", &info[i].prio_rd); of_property_read_u32(child_node, "qcom,prio-wr", &info[i].prio_wr); of_property_read_u32(child_node, "qcom,prio0", &info[i].prio0); of_property_read_u32(child_node, "qcom,prio1", &info[i].prio1); ret = of_property_read_string(child_node, "qcom,slaveclk-dual", &info[i].slaveclk[DUAL_CTX]); if (!ret) pr_debug("Got slaveclk_dual: %s\n", info[i].slaveclk[DUAL_CTX]); else info[i].slaveclk[DUAL_CTX] = NULL; ret = of_property_read_string(child_node, "qcom,slaveclk-active", &info[i].slaveclk[ACTIVE_CTX]); if (!ret) pr_debug("Got slaveclk_active\n"); else info[i].slaveclk[ACTIVE_CTX] = NULL; ret = of_property_read_string(child_node, "qcom,memclk-dual", &info[i].memclk[DUAL_CTX]); if (!ret) pr_debug("Got memclk_dual\n"); else info[i].memclk[DUAL_CTX] = NULL; ret = of_property_read_string(child_node, "qcom,memclk-active", &info[i].memclk[ACTIVE_CTX]); if (!ret) pr_debug("Got memclk_active\n"); else info[i].memclk[ACTIVE_CTX] = NULL; ret = of_property_read_string(child_node, "qcom,iface-clk-node", &info[i].iface_clk_node); if (!ret) pr_debug("Got iface_clk_node\n"); else info[i].iface_clk_node = NULL; pr_debug("Node name: %s\n", info[i].name); of_node_put(child_node); i++; } if (pdata->nmasters) pdata->nmasters = max(pdata->nmasters, (unsigned int)(max_masterp + 1)); if (pdata->nslaves) pdata->nslaves = max(pdata->nslaves, (unsigned int)(max_slavep + 1)); pr_debug("Bus %d added: %d masters\n", pdata->id, pdata->nmasters); pr_debug("Bus %d added: %d slaves\n", pdata->id, pdata->nslaves); return info; err: return NULL; }
static int __devinit gdsc_probe(struct platform_device *pdev) { static atomic_t gdsc_count = ATOMIC_INIT(-1); struct regulator_init_data *init_data; struct resource *res; struct gdsc *sc; uint32_t regval; bool retain_mem, retain_periph; int i, ret; sc = devm_kzalloc(&pdev->dev, sizeof(struct gdsc), GFP_KERNEL); if (sc == NULL) return -ENOMEM; init_data = of_get_regulator_init_data(&pdev->dev, pdev->dev.of_node); if (init_data == NULL) return -ENOMEM; if (of_get_property(pdev->dev.of_node, "parent-supply", NULL)) init_data->supply_regulator = "parent"; ret = of_property_read_string(pdev->dev.of_node, "regulator-name", &sc->rdesc.name); if (ret) return ret; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (res == NULL) return -EINVAL; sc->gdscr = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (sc->gdscr == NULL) return -ENOMEM; sc->clock_count = of_property_count_strings(pdev->dev.of_node, "qcom,clock-names"); if (sc->clock_count == -EINVAL) { sc->clock_count = 0; } else if (IS_ERR_VALUE(sc->clock_count)) { dev_err(&pdev->dev, "Failed to get clock names\n"); return -EINVAL; } sc->clocks = devm_kzalloc(&pdev->dev, sizeof(struct clk *) * sc->clock_count, GFP_KERNEL); if (!sc->clocks) return -ENOMEM; for (i = 0; i < sc->clock_count; i++) { const char *clock_name; of_property_read_string_index(pdev->dev.of_node, "qcom,clock-names", i, &clock_name); sc->clocks[i] = devm_clk_get(&pdev->dev, clock_name); if (IS_ERR(sc->clocks[i])) { int rc = PTR_ERR(sc->clocks[i]); if (rc != -EPROBE_DEFER) dev_err(&pdev->dev, "Failed to get %s\n", clock_name); return rc; } } sc->rdesc.id = atomic_inc_return(&gdsc_count); sc->rdesc.ops = &gdsc_ops; sc->rdesc.type = REGULATOR_VOLTAGE; sc->rdesc.owner = THIS_MODULE; platform_set_drvdata(pdev, sc); /* * Disable HW trigger: collapse/restore occur based on registers writes. * Disable SW override: Use hardware state-machine for sequencing. */ regval = readl_relaxed(sc->gdscr); regval &= ~(HW_CONTROL_MASK | SW_OVERRIDE_MASK); /* Configure wait time between states. */ regval &= ~(EN_REST_WAIT_MASK | EN_FEW_WAIT_MASK | CLK_DIS_WAIT_MASK); regval |= EN_REST_WAIT_VAL | EN_FEW_WAIT_VAL | CLK_DIS_WAIT_VAL; writel_relaxed(regval, sc->gdscr); retain_mem = of_property_read_bool(pdev->dev.of_node, "qcom,retain-mem"); retain_periph = of_property_read_bool(pdev->dev.of_node, "qcom,retain-periph"); for (i = 0; i < sc->clock_count; i++) { if (retain_mem || (regval & PWR_ON_MASK)) clk_set_flags(sc->clocks[i], CLKFLAG_RETAIN_MEM); else clk_set_flags(sc->clocks[i], CLKFLAG_NORETAIN_MEM); if (retain_periph || (regval & PWR_ON_MASK)) clk_set_flags(sc->clocks[i], CLKFLAG_RETAIN_PERIPH); else clk_set_flags(sc->clocks[i], CLKFLAG_NORETAIN_PERIPH); } sc->toggle_mem = !retain_mem; sc->toggle_periph = !retain_periph; sc->toggle_logic = !of_property_read_bool(pdev->dev.of_node, "qcom,skip-logic-collapse"); if (!sc->toggle_logic) { regval &= ~SW_COLLAPSE_MASK; writel_relaxed(regval, sc->gdscr); ret = readl_tight_poll_timeout(sc->gdscr, regval, regval & PWR_ON_MASK, TIMEOUT_US); if (ret) { dev_err(&pdev->dev, "%s enable timed out\n", sc->rdesc.name); return ret; } } sc->rdev = regulator_register(&sc->rdesc, &pdev->dev, init_data, sc, pdev->dev.of_node); if (IS_ERR(sc->rdev)) { dev_err(&pdev->dev, "regulator_register(\"%s\") failed.\n", sc->rdesc.name); return PTR_ERR(sc->rdev); } return 0; }
struct msm_bus_fabric_registration *msm_bus_of_get_fab_data(struct platform_device *pdev) { struct device_node *of_node; struct msm_bus_fabric_registration *pdata; bool mem_err = false; int ret = 0; const char *sel_str; if (!pdev) { pr_err("Error: Null platform device\n"); return NULL; } of_node = pdev->dev.of_node; pdata = devm_kzalloc(&pdev->dev, sizeof(struct msm_bus_fabric_registration), GFP_KERNEL); if (!pdata) { pr_err("Error: Memory allocation for pdata failed\n"); mem_err = true; goto err; } ret = of_property_read_string(of_node, "label", &pdata->name); if (ret) { pr_err("Error: label not found\n"); goto err; } pr_debug("Fab_of: Read name: %s\n", pdata->name); ret = of_property_read_u32(of_node, "cell-id", &pdata->id); if (ret) { pr_err("Error: num-usecases not found\n"); goto err; } pr_debug("Fab_of: Read id: %u\n", pdata->id); if (of_property_read_bool(of_node, "qcom,ahb")) pdata->ahb = 1; ret = of_property_read_string(of_node, "qcom,fabclk-dual", &pdata->fabclk[DUAL_CTX]); if (ret) { pr_debug("fabclk_dual not available\n"); pdata->fabclk[DUAL_CTX] = NULL; } else pr_debug("Fab_of: Read clk dual ctx: %s\n", pdata->fabclk[DUAL_CTX]); ret = of_property_read_string(of_node, "qcom,fabclk-active", &pdata->fabclk[ACTIVE_CTX]); if (ret) { pr_debug("Error: fabclk_active not available\n"); pdata->fabclk[ACTIVE_CTX] = NULL; } else pr_debug("Fab_of: Read clk act ctx: %s\n", pdata->fabclk[ACTIVE_CTX]); ret = of_property_read_u32(of_node, "qcom,ntieredslaves", &pdata->ntieredslaves); if (ret) { pr_err("Error: ntieredslaves not found\n"); goto err; } ret = of_property_read_u32(of_node, "qcom,qos-freq", &pdata->qos_freq); if (ret) pr_debug("qos_freq not available\n"); ret = of_property_read_string(of_node, "qcom,hw-sel", &sel_str); if (ret) { pr_err("Error: hw_sel not found\n"); goto err; } else { ret = get_num(hw_sel_name, sel_str); if (ret < 0) goto err; pdata->hw_sel = ret; } if (of_property_read_bool(of_node, "qcom,virt")) pdata->virt = true; ret = of_property_read_u32(of_node, "qcom,qos-baseoffset", &pdata->qos_baseoffset); if (ret) pr_debug("%s:qos_baseoffset not available\n", __func__); if (of_property_read_bool(of_node, "qcom,rpm-en")) pdata->rpm_enabled = 1; pdata->info = get_nodes(of_node, pdev, pdata); return pdata; err: return NULL; }
static int msm_iommu_parse_dt(struct platform_device *pdev, struct msm_iommu_drvdata *drvdata) { struct device_node *child; int ret = 0; struct resource *r; drvdata->dev = &pdev->dev; ret = __get_bus_vote_client(pdev, drvdata); if (ret) goto fail; ret = msm_iommu_parse_bfb_settings(pdev, drvdata); if (ret) goto fail; for_each_child_of_node(pdev->dev.of_node, child) drvdata->ncb++; drvdata->asid = devm_kzalloc(&pdev->dev, drvdata->ncb * sizeof(int), GFP_KERNEL); if (!drvdata->asid) { pr_err("Unable to get memory for asid array\n"); ret = -ENOMEM; goto fail; } ret = of_property_read_string(pdev->dev.of_node, "label", &drvdata->name); if (ret) goto fail; drvdata->sec_id = -1; of_property_read_u32(pdev->dev.of_node, "qcom,iommu-secure-id", &drvdata->sec_id); r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "clk_base"); if (r) { drvdata->clk_reg_virt = devm_ioremap(&pdev->dev, r->start, resource_size(r)); if (!drvdata->clk_reg_virt) { pr_err("Failed to map resource for iommu clk: %pr\n", r); ret = -ENOMEM; goto fail; } } drvdata->halt_enabled = of_property_read_bool(pdev->dev.of_node, "qcom,iommu-enable-halt"); ret = of_platform_populate(pdev->dev.of_node, msm_iommu_v1_ctx_match_table, NULL, &pdev->dev); if (ret) pr_err("Failed to create iommu context device\n"); msm_iommu_add_drv(drvdata); fail: __put_bus_vote_client(drvdata); return ret; }
static int32_t msm_led_get_dt_data(struct device_node *of_node, struct msm_led_flash_ctrl_t *fctrl) { int32_t rc = 0, i = 0; struct msm_camera_gpio_conf *gconf = NULL; struct device_node *flash_src_node = NULL; struct msm_camera_sensor_board_info *flashdata = NULL; struct msm_camera_power_ctrl_t *power_info = NULL; uint32_t count = 0; uint16_t *gpio_array = NULL; uint16_t gpio_array_size = 0; uint32_t id_info[3]; CDBG("called\n"); if (!of_node) { pr_err("of_node NULL\n"); return -EINVAL; } fctrl->flashdata = kzalloc(sizeof( struct msm_camera_sensor_board_info), GFP_KERNEL); if (!fctrl->flashdata) { pr_err("%s failed %d\n", __func__, __LINE__); return -ENOMEM; } flashdata = fctrl->flashdata; power_info = &flashdata->power_info; rc = of_property_read_u32(of_node, "cell-index", &fctrl->subdev_id); if (rc < 0) { pr_err("failed\n"); return -EINVAL; } CDBG("subdev id %d\n", fctrl->subdev_id); rc = of_property_read_string(of_node, "label", &flashdata->sensor_name); CDBG("%s label %s, rc %d\n", __func__, flashdata->sensor_name, rc); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto ERROR1; } rc = of_property_read_u32(of_node, "qcom,cci-master", &fctrl->cci_i2c_master); CDBG("%s qcom,cci-master %d, rc %d\n", __func__, fctrl->cci_i2c_master, rc); if (rc < 0) { /* Set default master 0 */ fctrl->cci_i2c_master = MASTER_0; rc = 0; } if (of_get_property(of_node, "qcom,flash-source", &count)) { count /= sizeof(uint32_t); CDBG("count %d\n", count); if (count > MAX_LED_TRIGGERS) { pr_err("failed\n"); return -EINVAL; } for (i = 0; i < count; i++) { flash_src_node = of_parse_phandle(of_node, "qcom,flash-source", i); if (!flash_src_node) { pr_err("flash_src_node NULL\n"); continue; } rc = of_property_read_string(flash_src_node, "linux,default-trigger", &fctrl->flash_trigger_name[i]); if (rc < 0) { pr_err("failed\n"); of_node_put(flash_src_node); continue; } CDBG("default trigger %s\n", fctrl->flash_trigger_name[i]); rc = of_property_read_u32(flash_src_node, "qcom,max-current", &fctrl->flash_op_current[i]); if (rc < 0) { pr_err("failed rc %d\n", rc); of_node_put(flash_src_node); continue; } of_node_put(flash_src_node); CDBG("max_current[%d] %d\n", i, fctrl->flash_op_current[i]); led_trigger_register_simple( fctrl->flash_trigger_name[i], &fctrl->flash_trigger[i]); } } else { /*Handle LED Flash Ctrl by GPIO*/ power_info->gpio_conf = kzalloc(sizeof(struct msm_camera_gpio_conf), GFP_KERNEL); if (!power_info->gpio_conf) { pr_err("%s failed %d\n", __func__, __LINE__); rc = -ENOMEM; return rc; } gconf = 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__); rc = -ENOMEM; goto ERROR4; } 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 ERROR4; } 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 ERROR5; } 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 ERROR6; } } /* Read the max current for an LED if present */ if (of_get_property(of_node, "qcom,max-current", &count)) { count /= sizeof(uint32_t); if (count > MAX_LED_TRIGGERS) { pr_err("failed\n"); rc = -EINVAL; goto ERROR8; } rc = of_property_read_u32_array(of_node, "qcom,max-current", fctrl->flash_max_current, count); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto ERROR8; } for (; count < MAX_LED_TRIGGERS; count++) fctrl->flash_max_current[count] = 0; } /* Read the max duration for an LED if present */ if (of_get_property(of_node, "qcom,max-duration", &count)) { count /= sizeof(uint32_t); if (count > MAX_LED_TRIGGERS) { pr_err("failed\n"); rc = -EINVAL; goto ERROR8; } rc = of_property_read_u32_array(of_node, "qcom,max-duration", fctrl->flash_max_duration, count); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto ERROR8; } for (; count < MAX_LED_TRIGGERS; count++) fctrl->flash_max_duration[count] = 0; } flashdata->slave_info = kzalloc(sizeof(struct msm_camera_slave_info), GFP_KERNEL); if (!flashdata->slave_info) { pr_err("%s failed %d\n", __func__, __LINE__); rc = -ENOMEM; goto ERROR8; } 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 ERROR9; } fctrl->flashdata->slave_info->sensor_slave_addr = id_info[0]; fctrl->flashdata->slave_info->sensor_id_reg_addr = id_info[1]; fctrl->flashdata->slave_info->sensor_id = id_info[2]; kfree(gpio_array); return rc; ERROR9: kfree(fctrl->flashdata->slave_info); ERROR8: kfree(fctrl->flashdata->power_info.gpio_conf->gpio_num_info); ERROR6: kfree(gconf->cam_gpio_set_tbl); ERROR5: kfree(gconf->cam_gpio_req_tbl); ERROR4: kfree(gconf); ERROR1: kfree(fctrl->flashdata); kfree(gpio_array); } return rc; }
static int msm_iommu_ctx_parse_dt(struct platform_device *pdev, struct msm_iommu_ctx_drvdata *ctx_drvdata) { struct resource *r, rp; int irq = 0, ret = 0; u32 nsid; ctx_drvdata->secure_context = of_property_read_bool(pdev->dev.of_node, "qcom,secure-context"); if (ctx_drvdata->secure_context) { irq = platform_get_irq(pdev, 1); if (irq > 0) { ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, msm_iommu_secure_fault_handler_v2, IRQF_ONESHOT | IRQF_SHARED, "msm_iommu_secure_irq", pdev); if (ret) { pr_err("Request IRQ %d failed with ret=%d\n", irq, ret); return ret; } } } else { irq = platform_get_irq(pdev, 0); if (irq > 0) { ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, msm_iommu_fault_handler_v2, IRQF_ONESHOT | IRQF_SHARED, "msm_iommu_nonsecure_irq", pdev); if (ret) { pr_err("Request IRQ %d failed with ret=%d\n", irq, ret); goto out; } } } r = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!r) { ret = -EINVAL; goto out; } ret = of_address_to_resource(pdev->dev.parent->of_node, 0, &rp); if (ret) goto out; /* Calculate the context bank number using the base addresses. The * first 8 pages belong to the global address space which is followed * by the context banks, hence subtract by 8 to get the context bank * number. */ ctx_drvdata->num = ((r->start - rp.start) >> CTX_SHIFT) - 8; if (of_property_read_string(pdev->dev.of_node, "label", &ctx_drvdata->name)) ctx_drvdata->name = dev_name(&pdev->dev); if (!of_get_property(pdev->dev.of_node, "qcom,iommu-ctx-sids", &nsid)) { ret = -EINVAL; goto out; } if (nsid >= sizeof(ctx_drvdata->sids)) { ret = -EINVAL; goto out; } if (of_property_read_u32_array(pdev->dev.of_node, "qcom,iommu-ctx-sids", ctx_drvdata->sids, nsid / sizeof(*ctx_drvdata->sids))) { ret = -EINVAL; goto out; } ctx_drvdata->nsid = nsid; ctx_drvdata->asid = -1; out: return ret; }
static int of_sii8240_parse_dt(void) { struct sii8240_platform_data *pdata = g_pdata; struct device_node *np = pdata->tmds_client->dev.of_node; struct device *pdev = &pdata->tmds_client->dev; char *temp_string = NULL; struct platform_device *hdmi_pdev = NULL; struct device_node *hdmi_tx_node = NULL; pdata->gpio_mhl_irq = of_get_named_gpio_flags(np, "sii8240,gpio_mhl_irq", 0, NULL); if (pdata->gpio_mhl_irq > 0) pr_info("gpio: mhl_irq = %d\n", pdata->gpio_mhl_irq); pdata->gpio_mhl_reset = of_get_named_gpio_flags(np, "sii8240,gpio_mhl_reset", 0, NULL); if (pdata->gpio_mhl_reset > 0) pr_info("gpio: mhl_reset = %d\n", pdata->gpio_mhl_reset); if(of_property_read_string(np, "sii8240,gpio_mhl_reset_type", (const char **)&temp_string) == 0) { pdata->gpio_mhl_reset_type = of_sii8240_get_gpio_type(temp_string); pr_info("%s() gpio_mhl_reset_type = %d\n", __func__, pdata->gpio_mhl_reset_type); } pdata->gpio_mhl_wakeup = of_get_named_gpio_flags(np, "sii8240,gpio_mhl_wakeup", 0, NULL); if (pdata->gpio_mhl_wakeup > 0) pr_info("gpio: mhl_wakeup = %d\n", pdata->gpio_mhl_wakeup); pdata->gpio_mhl_scl = of_get_named_gpio_flags(np, "sii8240,gpio_mhl_scl", 0, NULL); if (pdata->gpio_mhl_scl > 0) pr_info("gpio: mhl_scl = %d\n", pdata->gpio_mhl_scl); pdata->gpio_mhl_sda = of_get_named_gpio_flags(np, "sii8240,gpio_mhl_sda", 0, NULL); if (pdata->gpio_mhl_sda > 0) pr_info("gpio: mhl_sda = %d\n", pdata->gpio_mhl_sda); pdata->gpio_mhl_en = of_get_named_gpio_flags(np, "sii8240,gpio_mhl_en", 0, NULL); if (pdata->gpio_mhl_en > 0) pr_info("gpio: mhl_en = %d\n", pdata->gpio_mhl_en); temp_string = NULL; if(of_property_read_string(np, "sii8240,gpio_mhl_en_type", (const char **)&temp_string) == 0) { pdata->gpio_mhl_en_type = of_sii8240_get_gpio_type(temp_string); pr_info("%s() gpio_mhl_en_type = %d\n", __func__, pdata->gpio_mhl_en_type); } pdata->gpio_ta_int = of_get_named_gpio_flags(np, "sii8240,gpio_ta_int", 0, NULL); if (pdata->gpio_ta_int > 0) pr_info("gpio: ta_int = %d\n", pdata->gpio_ta_int); #ifdef CONFIG_MACH_LT03_EUR pdata->swing_level = 0x0D; /*1 5*/ pr_info("swing_level = 0x%X\n", pdata->swing_level); #else if (!of_property_read_u32(np, "sii8240,swing_level", &pdata->swing_level)) pr_info("swing_level = 0x%X\n", pdata->swing_level); #endif if (!of_property_read_u32(np, "sii8240,damping", &pdata->damping)) pr_info("damping = 0x%X\n", pdata->damping); else pdata->damping = BIT_MHLTX_CTL3_DAMPING_SEL_OFF; pdata->gpio_barcode_emul = of_property_read_bool(np, "sii8240,barcode_emul"); pr_info("barcode_emul = %s\n", pdata->gpio_barcode_emul ? "true" : "false"); pdata->drm_workaround = of_property_read_bool(np, "sii8240,drm_workaround"); pr_info("drm_workaround = %s\n", pdata->drm_workaround ? "true" : "false"); pdata->vcc_1p2v = regulator_get(pdev, "vcc_1p2v"); if (IS_ERR(pdata->vcc_1p2v)) { pdata->vcc_1p2v = regulator_get(pdev, "max77826_ldo3"); if (IS_ERR(pdata->vcc_1p2v)) { pr_err("sii8240,vcc_1p2v is not exist in device tree\n"); pdata->vcc_1p2v = NULL; } } pdata->vcc_1p8v = regulator_get(pdev, "vcc_1p8v"); if (IS_ERR(pdata->vcc_1p8v)) { pdata->vcc_1p8v = regulator_get(pdev, "max77826_ldo7"); if (IS_ERR(pdata->vcc_1p8v)) { pr_err("sii8240,vcc_1p8v is not exist in device tree\n"); pdata->vcc_1p8v = NULL; } } pdata->vcc_3p3v = regulator_get(pdev, "vcc_3p3v"); if (IS_ERR(pdata->vcc_3p3v)) { pdata->vcc_3p3v = regulator_get(pdev, "max77826_ldo14"); if (IS_ERR(pdata->vcc_3p3v)) { pr_err("sii8240,vcc_3p3v is not exist in device tree\n"); pdata->vcc_3p3v = NULL; } } /* parse phandle for hdmi tx */ hdmi_tx_node = of_parse_phandle(np, "qcom,hdmi-tx-map", 0); if (!hdmi_tx_node) { pr_err("%s: can't find hdmi phandle\n", __func__); goto finish; } hdmi_pdev = of_find_device_by_node(hdmi_tx_node); if (!hdmi_pdev) { pr_err("%s: can't find the device by node\n", __func__); goto finish; } pr_info("%s: hdmi_pdev [0X%x] to pdata->pdev\n", __func__, (unsigned int)hdmi_pdev); pdata->hdmi_pdev = hdmi_pdev; finish: return 0; }
int fimc_is_sensor_parse_dt_with_companion(struct platform_device *pdev) { int ret = 0; u32 temp; char *pprop; struct exynos_platform_fimc_is_sensor *pdata; struct device_node *dnode; struct device *dev; int gpio_reset = 0, gpio_standby = 0; #ifdef CONFIG_SOC_EXYNOS5422 int gpios_cam_en = 0; #endif #if !defined(CONFIG_USE_VENDER_FEATURE) /* LSI Patch */ int gpio_cam_en = 0; int gpio_comp_en, gpio_comp_rst; #else const char *name; #endif #ifdef CONFIG_SOC_EXYNOS5433 struct pinctrl *pinctrl_ch = NULL; #endif int gpio_none = 0; u32 id; BUG_ON(!pdev); BUG_ON(!pdev->dev.of_node); dev = &pdev->dev; dnode = dev->of_node; pdata = kzalloc(sizeof(struct exynos_platform_fimc_is_sensor), GFP_KERNEL); if (!pdata) { pr_err("%s: no memory for platform data\n", __func__); return -ENOMEM; } pdata->gpio_cfg = exynos_fimc_is_sensor_pins_cfg; pdata->iclk_cfg = exynos_fimc_is_sensor_iclk_cfg; pdata->iclk_on = exynos_fimc_is_sensor_iclk_on; pdata->iclk_off = exynos_fimc_is_sensor_iclk_off; pdata->mclk_on = exynos_fimc_is_sensor_mclk_on; pdata->mclk_off = exynos_fimc_is_sensor_mclk_off; ret = of_property_read_u32(dnode, "scenario", &pdata->scenario); if (ret) { err("scenario read is fail(%d)", ret); goto p_err; } ret = of_property_read_u32(dnode, "mclk_ch", &pdata->mclk_ch); if (ret) { err("mclk_ch read is fail(%d)", ret); goto p_err; } ret = of_property_read_u32(dnode, "csi_ch", &pdata->csi_ch); if (ret) { err("csi_ch read is fail(%d)", ret); goto p_err; } ret = of_property_read_u32(dnode, "flite_ch", &pdata->flite_ch); if (ret) { err("flite_ch read is fail(%d)", ret); goto p_err; } ret = of_property_read_u32(dnode, "i2c_ch", &pdata->i2c_ch); if (ret) { err("i2c_ch read is fail(%d)", ret); goto p_err; } ret = of_property_read_u32(dnode, "i2c_addr", &pdata->i2c_addr); if (ret) { err("i2c_addr read is fail(%d)", ret); goto p_err; } ret = of_property_read_u32(dnode, "is_bns", &pdata->is_bns); if (ret) { err("is_bns read is fail(%d)", ret); goto p_err; } ret = of_property_read_u32(dnode, "id", &id); if (ret) { err("id read is fail(%d)", ret); goto p_err; } pdata->id = id; DT_READ_U32(dnode, "flash_first_gpio", pdata->flash_first_gpio ); DT_READ_U32(dnode, "flash_second_gpio", pdata->flash_second_gpio); #ifdef CONFIG_USE_VENDER_FEATURE ret = of_property_read_string(dnode, "sensor_name", &name); if (ret) { err("sensor_name read is fail(%d)", ret); goto p_err; } strcpy(pdata->sensor_name, name); ret = of_property_read_u32(dnode, "sensor_id", &pdata->sensor_id); if (ret) { err("sensor_id read is fail(%d)", ret); goto p_err; } #endif gpio_reset = of_get_named_gpio(dnode, "gpio_reset", 0); if (!gpio_is_valid(gpio_reset)) { dev_err(dev, "failed to get PIN_RESET\n"); ret = -EINVAL; goto p_err; } else { gpio_request_one(gpio_reset, GPIOF_OUT_INIT_LOW, "CAM_GPIO_OUTPUT_LOW"); gpio_free(gpio_reset); } #ifdef CONFIG_SOC_EXYNOS5422 gpios_cam_en = of_get_named_gpio(dnode, "gpios_cam_en", 0); if (!gpio_is_valid(gpios_cam_en)) { dev_err(dev, "failed to get main/front cam en gpio\n"); } else { gpio_request_one(gpios_cam_en, GPIOF_OUT_INIT_LOW, "CAM_GPIO_OUTPUT_LOW"); gpio_free(gpios_cam_en); } #endif #if !defined(CONFIG_USE_VENDER_FEATURE) /* LSI Patch */ /* Optional Feature */ gpio_comp_en = of_get_named_gpio(dnode, "gpios_comp_en", 0); if (!gpio_is_valid(gpio_comp_en)) dev_err(dev, "failed to get main comp en gpio\n"); gpio_comp_rst = of_get_named_gpio(dnode, "gpios_comp_reset", 0); if (!gpio_is_valid(gpio_comp_rst)) dev_err(dev, "failed to get main comp reset gpio\n"); gpio_standby = of_get_named_gpio(dnode, "gpio_standby", 0); if (!gpio_is_valid(gpio_standby)) dev_err(dev, "failed to get gpio_standby\n"); gpio_cam_en = of_get_named_gpio(dnode, "gpios_cam_en", 0); if (!gpio_is_valid(gpio_cam_en)) dev_err(dev, "failed to get gpio_cam_en\n"); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 0, gpio_cam_en, 0, NULL, PIN_OUTPUT_HIGH); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 1, gpio_reset, 0, NULL, PIN_RESET); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 2, gpio_none, 0, "ch", PIN_FUNCTION); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 3, gpio_comp_en, 0, NULL, PIN_OUTPUT_HIGH); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 4, gpio_comp_rst, 0, NULL, PIN_RESET); if (id == SENSOR_POSITION_REAR) { SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 5, gpio_none, 0, "af", PIN_FUNCTION); } SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 6, gpio_none, 0, NULL, PIN_END); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 0, gpio_reset, 0, NULL, PIN_RESET); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 1, gpio_reset, 0, NULL, PIN_INPUT); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 2, gpio_comp_rst, 0, NULL, PIN_RESET); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 3, gpio_comp_rst, 0, NULL, PIN_INPUT); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 4, gpio_comp_en, 0, NULL, PIN_INPUT); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 5, gpio_cam_en, 0, NULL, PIN_OUTPUT_LOW); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 6, gpio_none, 0, NULL, PIN_END); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON, 0, gpio_cam_en, 0, NULL, PIN_OUTPUT_HIGH); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON, 1, gpio_reset, 0, NULL, PIN_OUTPUT_LOW); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON, 2, gpio_standby, 0, NULL, PIN_OUTPUT_HIGH); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON, 3, gpio_none, 0, NULL, PIN_END); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, 0, gpio_reset, 0, NULL, PIN_RESET); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, 1, gpio_reset, 0, NULL, PIN_INPUT); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, 2, gpio_standby, 0, NULL, PIN_OUTPUT_LOW); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, 4, gpio_cam_en, 0, NULL, PIN_OUTPUT_LOW); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, 3, gpio_none, 0, NULL, PIN_END); #else /* TN CODE */ if (id == SENSOR_POSITION_FRONT) { gpio_standby = of_get_named_gpio(dnode, "gpio_standby", 0); if (!gpio_is_valid(gpio_standby)) { dev_err(dev, "failed to get gpio_standby\n"); } else { gpio_request_one(gpio_standby, GPIOF_OUT_INIT_LOW, "CAM_GPIO_OUTPUT_LOW"); gpio_free(gpio_standby); } #ifdef CONFIG_SOC_EXYNOS5433 /* initial - i2c off */ pinctrl_ch = devm_pinctrl_get_select(&pdev->dev, "off1"); if (IS_ERR_OR_NULL(pinctrl_ch)) { pr_err("%s: cam %s pins are not configured\n", __func__, "off1"); } else { devm_pinctrl_put(pinctrl_ch); } #endif } #ifdef CONFIG_SOC_EXYNOS5422 if (id == SENSOR_POSITION_REAR) { /* BACK CAMERA - POWER ON */ SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 0, gpio_none, 0, NULL, 0, PIN_END); /* BACK CAMERA - POWER OFF */ SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 0, gpio_none, 0, NULL, 0, PIN_END); } else { /* FRONT CAMERA - POWER ON */ SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 0, gpio_standby, 0, NULL, 0, PIN_OUTPUT_LOW); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 1, gpio_none, 0, "VT_CAM_1.8V", 0, PIN_REGULATOR_ON); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 2, gpio_none, 0, "VT_CAM_2.8V", 0, PIN_REGULATOR_ON); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 3, gpios_cam_en, 0, NULL, 1000, PIN_OUTPUT_HIGH); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 4, gpio_reset, 0, NULL, 0, PIN_OUTPUT_HIGH); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 5, gpio_none, 0, "ch", 0, PIN_FUNCTION); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 6, gpio_none, 0, NULL, 0, PIN_END); /* FRONT CAMERA - POWER OFF */ SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 0, gpio_standby, 0, NULL, 0, PIN_OUTPUT_LOW); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 1, gpio_none, 0, "off", 0, PIN_FUNCTION); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 2, gpio_reset, 0, NULL, 0, PIN_OUTPUT_LOW); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 3, gpios_cam_en, 0, NULL, 0, PIN_OUTPUT_LOW); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 4, gpio_none, 0, "VT_CAM_2.8V", 0, PIN_REGULATOR_OFF); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 5, gpio_none, 0, "VT_CAM_1.8V", 0, PIN_REGULATOR_OFF); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 6, gpio_none, 0, NULL, 0, PIN_END); /* VISION CAMERA - POWER ON */ SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON, 0, gpio_reset, 0, NULL, 0, PIN_OUTPUT_LOW); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON, 1, gpio_none, 0, "VT_CAM_1.8V", 0, PIN_REGULATOR_ON); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON, 2, gpio_none, 0, "VT_CAM_2.8V", 0, PIN_REGULATOR_ON); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON, 3, gpios_cam_en, 0, NULL, 1000, PIN_OUTPUT_HIGH); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON, 4, gpio_standby, 0, NULL, 0, PIN_OUTPUT_HIGH); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON, 5, gpio_none, 0, "ch", 0, PIN_FUNCTION); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON, 6, gpio_none, 0, NULL, 0, PIN_END); /* VISION CAMERA - POWER OFF */ SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, 0, gpio_reset, 0, NULL, 0, PIN_OUTPUT_LOW); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, 1, gpio_none, 0, "off", 0, PIN_FUNCTION); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, 2, gpio_standby, 0, NULL, 0, PIN_OUTPUT_LOW); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, 3, gpios_cam_en, 0, NULL, 0, PIN_OUTPUT_LOW); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, 4, gpio_none, 0, "VT_CAM_2.8V", 0, PIN_REGULATOR_OFF); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, 5, gpio_none, 0, "VT_CAM_1.8V", 0, PIN_REGULATOR_OFF); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, 6, gpio_none, 0, NULL, 0, PIN_END); } #else /*CONFIG_SOC_EXYNOS5430*/ if (id == SENSOR_POSITION_REAR) { /* BACK CAMERA - POWER ON */ SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 0, gpio_none, 0, NULL, 0, PIN_END); /* BACK CAMERA - POWER OFF */ SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 0, gpio_none, 0, NULL, 0, PIN_END); } else { /* FRONT CAMERA - POWER ON */ SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 0, gpio_standby, 0, NULL, 0, PIN_OUTPUT_LOW); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 1, gpio_none, 0, "VT_CAM_1.8V", 0, PIN_REGULATOR_ON); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 2, gpio_none, 0, "VT_CAM_2.8V", 0, PIN_REGULATOR_ON); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 3, gpio_none, 0, "VT_CAM_1.2V", 1000, PIN_REGULATOR_ON); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 4, gpio_reset, 0, NULL, 0, PIN_OUTPUT_HIGH); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 5, gpio_none, 0, "ch", 0, PIN_FUNCTION); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 6, gpio_none, 0, NULL, 0, PIN_END); /* FRONT CAMERA - POWER OFF */ SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 0, gpio_standby, 0, NULL, 0, PIN_OUTPUT_LOW); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 1, gpio_none, 0, "off", 0, PIN_FUNCTION); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 2, gpio_reset, 0, NULL, 0, PIN_OUTPUT_LOW); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 3, gpio_none, 0, "VT_CAM_1.2V", 0, PIN_REGULATOR_OFF); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 4, gpio_none, 0, "VT_CAM_2.8V", 0, PIN_REGULATOR_OFF); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 5, gpio_none, 0, "VT_CAM_1.8V", 0, PIN_REGULATOR_OFF); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 6, gpio_none, 0, NULL, 0, PIN_END); /* VISION CAMERA - POWER ON */ SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON, 0, gpio_reset, 0, NULL, 0, PIN_OUTPUT_LOW); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON, 1, gpio_none, 0, "VT_CAM_1.8V", 0, PIN_REGULATOR_ON); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON, 2, gpio_none, 0, "VT_CAM_2.8V", 0, PIN_REGULATOR_ON); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON, 3, gpio_none, 0, "VT_CAM_1.2V", 1000, PIN_REGULATOR_ON); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON, 4, gpio_standby, 0, NULL, 0, PIN_OUTPUT_HIGH); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON, 5, gpio_none, 0, "ch", 0, PIN_FUNCTION); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON, 6, gpio_none, 0, NULL, 0, PIN_END); /* VISION CAMERA - POWER OFF */ SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, 0, gpio_reset, 0, NULL, 0, PIN_OUTPUT_LOW); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, 1, gpio_none, 0, "off", 0, PIN_FUNCTION); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, 2, gpio_standby, 0, NULL, 0, PIN_OUTPUT_LOW); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, 3, gpio_none, 0, "VT_CAM_1.2V", 0, PIN_REGULATOR_OFF); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, 4, gpio_none, 0, "VT_CAM_2.8V", 0, PIN_REGULATOR_OFF); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, 5, gpio_none, 0, "VT_CAM_1.8V", 0, PIN_REGULATOR_OFF); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, 6, gpio_none, 0, NULL, 0, PIN_END); } #endif #endif pdev->id = id; dev->platform_data = pdata; pdata->pinctrl = devm_pinctrl_get(dev); if (IS_ERR(pdata->pinctrl)) { err("devm_pinctrl_get is fail"); goto p_err; } else { ret = get_pin_lookup_state(dev, pdata); if (ret < 0) { err("fimc_is_get_pin_lookup_state is fail"); goto p_err; } } return ret; p_err: kfree(pdata); return ret; }
static int32_t msm_led_trigger_probe(struct platform_device *pdev) { int32_t rc = 0, rc_1 = 0, i = 0; struct device_node *of_node = pdev->dev.of_node; struct device_node *flash_src_node = NULL; uint32_t count = 0; struct led_trigger *temp = NULL; CDBG("called\n"); if (!of_node) { pr_err("of_node NULL\n"); return -EINVAL; } fctrl.pdev = pdev; fctrl.num_sources = 0; rc = of_property_read_u32(of_node, "cell-index", &pdev->id); if (rc < 0) { pr_err("failed\n"); return -EINVAL; } CDBG("pdev id %d\n", pdev->id); rc = of_property_read_u32(of_node, "qcom,flash-type", &flashtype); if (rc < 0) { pr_err("flash-type: read failed\n"); return -EINVAL; } if (of_get_property(of_node, "qcom,flash-source", &count)) { count /= sizeof(uint32_t); CDBG("count %d\n", count); if (count > MAX_LED_TRIGGERS) { pr_err("invalid count\n"); return -EINVAL; } fctrl.num_sources = count; for (i = 0; i < count; i++) { flash_src_node = of_parse_phandle(of_node, "qcom,flash-source", i); if (!flash_src_node) { pr_err("flash_src_node NULL\n"); continue; } rc = of_property_read_string(flash_src_node, "linux,default-trigger", &fctrl.flash_trigger_name[i]); if (rc < 0) { pr_err("default-trigger: read failed\n"); of_node_put(flash_src_node); continue; } CDBG("default trigger %s\n", fctrl.flash_trigger_name[i]); if (flashtype == GPIO_FLASH) { /* use fake current */ fctrl.flash_op_current[i] = LED_FULL; } else { rc = of_property_read_u32(flash_src_node, "qcom,current", &fctrl.flash_op_current[i]); rc_1 = of_property_read_u32(flash_src_node, "qcom,max-current", &fctrl.flash_max_current[i]); if ((rc < 0) || (rc_1 < 0)) { pr_err("current: read failed\n"); of_node_put(flash_src_node); continue; } } of_node_put(flash_src_node); CDBG("max_current[%d] %d\n", i, fctrl.flash_op_current[i]); led_trigger_register_simple(fctrl.flash_trigger_name[i], &fctrl.flash_trigger[i]); if (flashtype == GPIO_FLASH) if (fctrl.flash_trigger[i]) temp = fctrl.flash_trigger[i]; } /* Torch source */ flash_src_node = of_parse_phandle(of_node, "qcom,torch-source", 0); if (flash_src_node) { rc = of_property_read_string(flash_src_node, "linux,default-trigger", &fctrl.torch_trigger_name); if (rc < 0) { pr_err("default-trigger: read failed\n"); goto torch_failed; } CDBG("default trigger %s\n", fctrl.torch_trigger_name); if (flashtype == GPIO_FLASH) { /* use fake current */ fctrl.torch_op_current = LED_FULL; if (temp) fctrl.torch_trigger = temp; else led_trigger_register_simple( fctrl.torch_trigger_name, &fctrl.torch_trigger); } else { rc = of_property_read_u32(flash_src_node, "qcom,current", &fctrl.torch_op_current); rc_1 = of_property_read_u32(flash_src_node, "qcom,max-current", &fctrl.torch_max_current); if ((rc < 0) || (rc_1 < 0)) { pr_err("current: read failed\n"); goto torch_failed; } CDBG("torch max_current %d\n", fctrl.torch_op_current); led_trigger_register_simple( fctrl.torch_trigger_name, &fctrl.torch_trigger); } torch_failed: of_node_put(flash_src_node); } } rc = msm_led_flash_create_v4lsubdev(pdev, &fctrl); if (!rc) msm_led_torch_create_classdev(pdev, &fctrl); return rc; }
GET_DT_ERR_TYPE get_dt_data(struct device_node* of_node, struct touch_pdata *pdata) { const char *str; int err, retry, i; int irq_table[4] = { GPIO_IRQ_HIGH, GPIO_IRQ_LOW, GPIO_IRQ_RISING, GPIO_IRQ_FALLING, }; const char *irq_string[] = { "GPIO_IRQ_HIGH", "GPIO_IRQ_LOW", "GPIO_IRQ_RISING", "GPIO_IRQ_FALLING", }; if (pdata->fw_file) strcpy(pdata->fw_file, "/system/etc/touch/touch.fw"); if (pdata->config_file) strcpy(pdata->config_file, "/system/etc/touch/touch.cfg"); if (!of_node) { printk("%s: dev.of_node == NULL!\n", pdata->owner); return ERR_NO_NODE; } err = of_property_read_string(of_node, "touch_name", (const char **)&pdata->owner); if (err) { pdata->owner = "amlogic"; printk("info: set name amlogic!\n"); } err = of_property_read_u32(of_node,"reg",&pdata->reg); if (err) { printk("%s info: get ic type!\n", pdata->owner); pdata->reg = 0; } printk("%s: reg=%x\n", pdata->owner, pdata->reg); err = of_property_read_string(of_node, "i2c_bus", &str); if (err) { printk("%s info: get i2c_bus str,use default i2c bus!\n", pdata->owner); pdata->bus_type = AML_I2C_BUS_A; } else { if (!strncmp(str, "i2c_bus_a", 9)) pdata->bus_type = AML_I2C_BUS_A; else if (!strncmp(str, "i2c_bus_b", 9)) pdata->bus_type = AML_I2C_BUS_B; else if (!strncmp(str, "i2c_bus_ao", 10)) pdata->bus_type = AML_I2C_BUS_AO; else pdata->bus_type = AML_I2C_BUS_A; } printk("%s: bus_type=%d\n", pdata->owner, pdata->bus_type); err = of_property_read_u32(of_node,"ic_type",&pdata->ic_type); if (err) { printk("%s info: get ic type!\n", pdata->owner); pdata->ic_type = 0; } printk("%s: IC type=%d\n", pdata->owner, pdata->ic_type); err = of_property_read_u32(of_node,"irq",&pdata->irq); if (err) { printk("%s: get IRQ number!\n", pdata->owner); pdata->irq = 0; } pdata->irq += INT_GPIO_0; printk("%s: IRQ number=%d\n",pdata->owner, pdata->irq); err = of_property_read_string(of_node,"irq_edge",&str); if (err) { printk("%s info: get irq edge, set irq edge GPIO_IRQ_FALLING!\n", pdata->owner); pdata->irq_edge = irq_table[3]; } else { for (retry=0; retry<4; retry++) { if (!strcmp(str, irq_string[retry])) break; } if (retry == 4) { printk("%s info: get irq edge, set irq edge GPIO_IRQ_FALLING!\n", pdata->owner); pdata->irq_edge = irq_table[3]; } else pdata->irq_edge = irq_table[retry]; } err = of_property_read_u32(of_node,"auto_update_fw",&pdata->auto_update_fw); if (err) { printk("%s info: get auto_update_fw!\n", pdata->owner); pdata->auto_update_fw = 0; } err = of_property_read_u32(of_node,"xres",&pdata->xres); if (err) { printk("%s info: get x resolution!\n", pdata->owner); return ERR_GET_DATA; } err = of_property_read_u32(of_node,"yres",&pdata->yres); if (err) { printk("%s info: get y resolution!\n",pdata->owner); return ERR_GET_DATA; } err = of_property_read_u32(of_node,"pol",&pdata->pol); if (err) { printk("%s info: get pol!\n", pdata->owner); pdata->pol = 0; } err = of_property_read_u32(of_node,"max_num",&pdata->max_num); if (err) { printk("%s info: get max num, set max num 5!\n", pdata->owner); pdata->max_num = 5; } printk("%s: xres=%d, yres=%d, pol=0x%x, max_num=%d\n",pdata->owner,pdata->xres,pdata->yres,pdata->pol,pdata->max_num); err = of_property_read_string(of_node, "gpio_interrupt", &str); if (err) { printk("%s info: get gpio interrupt!\n", pdata->owner); pdata->gpio_interrupt = 0; return ERR_GET_DATA; } else { pdata->gpio_interrupt = amlogic_gpio_name_map_num(str); printk("%s: alloc gpio_interrupt(%s)!\n", pdata->owner, str); if (pdata->gpio_interrupt <= 0) { pdata->gpio_interrupt = 0; printk("%s info: alloc gpio_interrupt(%s)!\n", pdata->owner, str); //return ERR_GPIO_REQ; } } err = of_property_read_string(of_node, "gpio_reset", &str); if (!err){ pdata->gpio_reset = amlogic_gpio_name_map_num(str); printk("%s: alloc gpio_reset(%s)!\n", pdata->owner, str); if (pdata->gpio_reset <= 0) { pdata->gpio_reset = 0; printk("%s info: alloc gpio_reset(%s)!\n", pdata->owner, str); } } else { pdata->gpio_reset = 0; } err = of_property_read_string(of_node, "gpio_power", &str); if (!err){ pdata->gpio_power = amlogic_gpio_name_map_num(str); printk("%s: alloc gpio_power(%s)!\n", pdata->owner, str); if (pdata->gpio_power <= 0) { pdata->gpio_power = 0; printk("%s info: alloc gpio_power(%s)!\n", pdata->owner, str); } } else { pdata->gpio_power = 0; } err = of_property_read_string(of_node,"fw_file",&str); if (err) { printk("%s info: get fw_file, set firmware %s!\n",pdata->owner, pdata->fw_file); } else { strcpy(pdata->fw_file, str); printk("%s get fw_file, set firmware %s!\n",pdata->owner, pdata->fw_file); } err = of_property_read_string(of_node,"config_file", &str); if (err) { printk("%s info: get config_file, set config_file %s!\n", pdata->owner, pdata->config_file); } else { strcpy(pdata->config_file, str); printk("%s get config_file, set config_file %s!\n", pdata->owner, pdata->config_file); } err = of_property_read_u32(of_node,"select_gpio_num",&pdata->select_gpio_num); if (err) { printk("%s info: get select_gpio_num!\n", pdata->owner); pdata->select_gpio_num = 0; } if (pdata->select_gpio_num > 0) { for (i=0; i<pdata->select_gpio_num; i++) { err = of_property_read_string_index(of_node, "select_fw_gpio", i, &str); if(err < 0){ printk("%s: find select_fw_gpio[%d] faild\n", pdata->owner, i); break; } else { pdata->select_fw_gpio[i] = amlogic_gpio_name_map_num(str); printk("%s: alloc select_fw_gpio[%d](%s)!\n", pdata->owner, i, str); if (pdata->select_fw_gpio[i] <= 0) { pdata->select_fw_gpio[i] = 0; printk("%s info: alloc select_fw_gpio[%d](%s)!\n", pdata->owner, i, str); //return ERR_GPIO_REQ; } } } } return ERR_NO; }
static struct msm_bus_fab_device_type *get_fab_device_info( struct device_node *dev_node, struct platform_device *pdev) { struct msm_bus_fab_device_type *fab_dev; unsigned int ret; struct resource *res; const char *base_name; fab_dev = devm_kzalloc(&pdev->dev, sizeof(struct msm_bus_fab_device_type), GFP_KERNEL); if (!fab_dev) { dev_err(&pdev->dev, "Error: Unable to allocate memory for fab_dev\n"); return NULL; } ret = of_property_read_string(dev_node, "qcom,base-name", &base_name); if (ret) { dev_err(&pdev->dev, "Error: Unable to get base address name\n"); goto fab_dev_err; } res = platform_get_resource_byname(pdev, IORESOURCE_MEM, base_name); if (!res) { dev_err(&pdev->dev, "Error getting qos base addr %s\n", base_name); goto fab_dev_err; } fab_dev->pqos_base = res->start; fab_dev->qos_range = resource_size(res); fab_dev->bypass_qos_prg = of_property_read_bool(dev_node, "qcom,bypass-qos-prg"); ret = of_property_read_u32(dev_node, "qcom,base-offset", &fab_dev->base_offset); if (ret) dev_dbg(&pdev->dev, "Bus base offset is missing\n"); ret = of_property_read_u32(dev_node, "qcom,qos-off", &fab_dev->qos_off); if (ret) dev_dbg(&pdev->dev, "Bus qos off is missing\n"); ret = of_property_read_u32(dev_node, "qcom,bus-type", &fab_dev->bus_type); if (ret) { dev_warn(&pdev->dev, "Bus type is missing\n"); goto fab_dev_err; } ret = of_property_read_u32(dev_node, "qcom,qos-freq", &fab_dev->qos_freq); if (ret) { dev_dbg(&pdev->dev, "Bus qos freq is missing\n"); fab_dev->qos_freq = DEFAULT_QOS_FREQ; } ret = of_property_read_u32(dev_node, "qcom,util-fact", &fab_dev->util_fact); if (ret) { dev_info(&pdev->dev, "Util-fact is missing, default to %d\n", DEFAULT_UTIL_FACT); fab_dev->util_fact = DEFAULT_UTIL_FACT; } ret = of_property_read_u32(dev_node, "qcom,vrail-comp", &fab_dev->vrail_comp); if (ret) { dev_info(&pdev->dev, "Vrail-comp is missing, default to %d\n", DEFAULT_VRAIL_COMP); fab_dev->vrail_comp = DEFAULT_VRAIL_COMP; } return fab_dev; fab_dev_err: devm_kfree(&pdev->dev, fab_dev); fab_dev = 0; return NULL; }
int32_t msm_eeprom_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { int rc = 0; int32_t j = 0; uint32_t temp = 0; struct msm_eeprom_ctrl_t *e_ctrl = NULL; struct msm_camera_power_ctrl_t *power_info = NULL; struct device_node *of_node = client->dev.of_node; CDBG("%s E\n", __func__); if (!of_node) { pr_err("%s of_node NULL\n", __func__); return -EINVAL; } if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { pr_err("%s i2c_check_functionality failed\n", __func__); goto probe_failure; } e_ctrl = kzalloc(sizeof(struct msm_eeprom_ctrl_t), GFP_KERNEL); if (!e_ctrl) { pr_err("%s:%d kzalloc failed\n", __func__, __LINE__); return -ENOMEM; } e_ctrl->eeprom_v4l2_subdev_ops = &msm_eeprom_subdev_ops; e_ctrl->eeprom_mutex = &msm_eeprom_mutex; CDBG("%s client = %x\n", __func__, (unsigned int)client); e_ctrl->eboard_info = kzalloc(sizeof( struct msm_eeprom_board_info), GFP_KERNEL); if (!e_ctrl->eboard_info) { pr_err("%s:%d board info NULL\n", __func__, __LINE__); return -EINVAL; } rc = of_property_read_u32(of_node, "qcom,slave-addr", &temp); if (rc < 0) { pr_err("%s failed rc %d\n", __func__, rc); return rc; } power_info = &e_ctrl->eboard_info->power_info; e_ctrl->eboard_info->i2c_slaveaddr = temp; e_ctrl->i2c_client.client = client; e_ctrl->is_supported = 0; /* Set device type as I2C */ e_ctrl->eeprom_device_type = MSM_CAMERA_I2C_DEVICE; e_ctrl->i2c_client.i2c_func_tbl = &msm_eeprom_qup_func_tbl; if (e_ctrl->eboard_info->i2c_slaveaddr != 0) e_ctrl->i2c_client.client->addr = e_ctrl->eboard_info->i2c_slaveaddr; power_info->clk_info = cam_8960_clk_info; power_info->clk_info_size = ARRAY_SIZE(cam_8960_clk_info); power_info->dev = &client->dev; rc = of_property_read_string(of_node, "qcom,eeprom-name", &e_ctrl->eboard_info->eeprom_name); CDBG("%s qcom,eeprom-name %s, rc %d\n", __func__, e_ctrl->eboard_info->eeprom_name, rc); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto board_free; } rc = msm_eeprom_get_dt_data(e_ctrl); if (rc) goto board_free; rc = msm_eeprom_alloc_memory_map(e_ctrl, of_node); if (rc) goto board_free; rc = msm_camera_power_up(power_info, e_ctrl->eeprom_device_type, &e_ctrl->i2c_client); if (rc) { pr_err("%s failed power up %d\n", __func__, __LINE__); goto memdata_free; } rc = read_eeprom_memory(e_ctrl); if (rc < 0) { pr_err("%s read_eeprom_memory failed\n", __func__); goto power_down; } for (j = 0; j < e_ctrl->num_bytes; j++) CDBG("memory_data[%d] = 0x%X\n", j, e_ctrl->memory_data[j]); rc = msm_camera_power_down(power_info, e_ctrl->eeprom_device_type, &e_ctrl->i2c_client); if (rc) { pr_err("failed rc %d\n", rc); goto power_down; } /*IMPLEMENT READING PART*/ /* Initialize sub device */ v4l2_i2c_subdev_init(&e_ctrl->msm_sd.sd, e_ctrl->i2c_client.client, e_ctrl->eeprom_v4l2_subdev_ops); v4l2_set_subdevdata(&e_ctrl->msm_sd.sd, e_ctrl); e_ctrl->msm_sd.sd.internal_ops = &msm_eeprom_internal_ops; e_ctrl->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; media_entity_init(&e_ctrl->msm_sd.sd.entity, 0, NULL, 0); e_ctrl->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV; e_ctrl->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_EEPROM; msm_sd_register(&e_ctrl->msm_sd); e_ctrl->is_supported = 1; CDBG("%s success result=%d X\n", __func__, rc); return rc; power_down: msm_camera_power_down(power_info, e_ctrl->eeprom_device_type, &e_ctrl->i2c_client); memdata_free: kfree(e_ctrl->memory_data); kfree(e_ctrl->eboard_info->eeprom_map); board_free: kfree(e_ctrl->eboard_info); probe_failure: pr_err("%s failed! rc = %d\n", __func__, rc); return rc; }