int fimc_is_resourcemgr_probe(struct fimc_is_resourcemgr *resourcemgr,
void *private_data)
{
int ret = 0;
BUG_ON(!resourcemgr);
BUG_ON(!private_data);
resourcemgr->private_data = private_data;
clear_bit(FIMC_IS_RM_COM_POWER_ON, &resourcemgr->state);
clear_bit(FIMC_IS_RM_SS0_POWER_ON, &resourcemgr->state);
clear_bit(FIMC_IS_RM_SS1_POWER_ON, &resourcemgr->state);
clear_bit(FIMC_IS_RM_SS2_POWER_ON, &resourcemgr->state);
clear_bit(FIMC_IS_RM_SS3_POWER_ON, &resourcemgr->state);
clear_bit(FIMC_IS_RM_ISC_POWER_ON, &resourcemgr->state);
clear_bit(FIMC_IS_RM_POWER_ON, &resourcemgr->state);
atomic_set(&resourcemgr->rsccount, 0);
atomic_set(&resourcemgr->resource_sensor0.rsccount, 0);
atomic_set(&resourcemgr->resource_sensor1.rsccount, 0);
atomic_set(&resourcemgr->resource_ischain.rsccount, 0);
atomic_set(&resourcemgr->resource_companion.rsccount, 0);
resourcemgr->hal_version = IS_HAL_VER_1_0;
#if defined(ENABLE_TMU_NOTIFIER)
resourcemgr->tmu_state = ISP_NORMAL;
resourcemgr->limited_fps = 0;
resourcemgr->notifier.notifier_call = fimc_is_tmu_notifier;
resourcemgr->notifier.priority = 0;
ret = exynos_tmu_isp_add_notifier(&resourcemgr->notifier);
if (ret) {
probe_err("exynos_tmu_isp_add_notifier is fail(%d)", ret);
goto p_err;
}
#endif
#ifdef ENABLE_RESERVED_MEM
ret = fimc_is_resourcemgr_initmem(resourcemgr);
if (ret) {
probe_err("fimc_is_resourcemgr_initmem is fail(%d)", ret);
goto p_err;
}
#endif
#ifdef ENABLE_DVFS
/* dvfs controller init */
ret = fimc_is_dvfs_init(resourcemgr);
if (ret) {
probe_err("%s: fimc_is_dvfs_init failed!\n", __func__);
goto p_err;
}
#endif
p_err:
probe_info("[RSC] %s(%d)\n", __func__, ret);
return ret;
}
bool G_SoldierMakeMgr::init() {
auto tab_info = the_app->script()->read_table("the_soldier_make_info");
if (tab_info->is_nil()) {
return false;
}
G_SoldierMakeInfo *info = nullptr;
for (unsigned i = 1; ; ++i) {
auto tab_item = tab_info->read_table(i);
if (tab_item->is_nil()) {
break;
}
int item_id = tab_item->read_integer("itemid", -1);
if (item_id < 0) {
if (!info) {
continue;
}
}
else {
const G_ItemInfo *item_info = G_ItemMgr::instance()->get_info(item_id);
if (!item_info) {
log_error("unknown item id '%d'.", item_id);
return false;
}
info = probe_info(item_id);
if (info->_use_item) {
log_error("dup item id '%d'.", item_id);
return false;
}
info->_use_item = item_info;
info->_use_count = tab_item->read_integer("itemnumber", 0);
if (!info->_use_count) {
log_error("bad use item count.");
return false;
}
}
int soldier_id = tab_item->read_integer("heroid", -1);
if (soldier_id < 0) {
continue;
}
const G_SoldierInfo *soldier_info = G_SoldierMgr::instance()->get_info(soldier_id);
if (!soldier_info) {
log_error("unknown soldier id '%d'.", soldier_id);
return false;
}
info->_soldiers.push_back(soldier_info);
}
return true;
}
bool G_SoldierMgr::init() {
auto tab_info = the_app->script()->read_table("the_soldier_info");
if (tab_info->is_nil()) {
return false;
}
for (unsigned i = 1; ; ++i) {
auto tab_item = tab_info->read_table(i);
if (tab_item->is_nil()) {
break;
}
int id = tab_item->read_integer("id", -1);
if (id < 0) {
continue;
}
int type2 = tab_item->read_integer("type2", 0);
if (type2 != G_TYPE_HERO && type2 != G_TYPE_SOLDIER) {
log_error("unknown soldier type '%d'.", type2);
}
G_SoldierInfo *info = probe_info(id);
info->_is_hero = (type2 == G_TYPE_HERO);
info->_quality = tab_item->read_integer("qua", 0);
info->_star = tab_item->read_integer("star", 0);
info->_hp = tab_item->read_integer("hp", 0);
info->_attack = tab_item->read_integer("att", 0);
info->_attack_speed = tab_item->read_integer("as", 0);
info->_hp_param = tab_item->read_integer("hpup", 0);
info->_attack_param = tab_item->read_integer("attup", 0);
info->_people = tab_item->read_integer("peo", 0);
if (!info->_is_hero && !info->_people) {
log_error("bad soldier people.");
return false;
}
}
return true;
}
int sensor_2p2_probe(struct platform_device *pdev)
{
int ret = 0;
struct fimc_is_core *core;
struct v4l2_subdev *subdev_module;
struct fimc_is_module_enum *module;
struct fimc_is_device_sensor *device;
struct sensor_open_extended *ext;
struct exynos_platform_fimc_is_module *pdata;
struct device *dev;
BUG_ON(!fimc_is_dev);
core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
if (!core) {
probe_err("core device is not yet probed");
return -EPROBE_DEFER;
}
dev = &pdev->dev;
#ifdef CONFIG_OF
fimc_is_sensor_module_parse_dt(pdev, sensor_2p2_power_setpin);
#endif
pdata = dev_get_platdata(dev);
device = &core->sensor[pdata->id];
subdev_module = kzalloc(sizeof(struct v4l2_subdev), GFP_KERNEL);
if (!subdev_module) {
probe_err("subdev_module is NULL");
ret = -ENOMEM;
goto p_err;
}
module = &device->module_enum[atomic_read(&core->resourcemgr.rsccount_module)];
atomic_inc(&core->resourcemgr.rsccount_module);
clear_bit(FIMC_IS_MODULE_GPIO_ON, &module->state);
module->pdata = pdata;
module->pdev = pdev;
module->sensor_id = SENSOR_NAME_S5K2P2;
module->subdev = subdev_module;
module->device = pdata->id;
module->client = NULL;
module->active_width = 5312;
module->active_height = 2990;
module->pixel_width = module->active_width + 16;
module->pixel_height = module->active_height + 10;
module->max_framerate = 300;
module->position = pdata->position;
module->mode = CSI_MODE_DT_ONLY;
module->lanes = CSI_DATA_LANES_4;
module->vcis = ARRAY_SIZE(vci_2p2);
module->vci = vci_2p2;
module->sensor_maker = "SLSI";
module->sensor_name = "S5K2P2";
module->setfile_name = "setfile_2p2.bin";
module->cfgs = ARRAY_SIZE(config_2p2);
module->cfg = config_2p2;
module->ops = NULL;
module->private_data = NULL;
ext = &module->ext;
ext->mipi_lane_num = module->lanes;
ext->I2CSclk = I2C_L0;
ext->sensor_con.product_name = SENSOR_NAME_S5K2P2;
ext->sensor_con.peri_type = SE_I2C;
ext->sensor_con.peri_setting.i2c.channel = pdata->sensor_i2c_ch;
ext->sensor_con.peri_setting.i2c.slave_address = pdata->sensor_i2c_addr;
ext->sensor_con.peri_setting.i2c.speed = 400000;
if (pdata->af_product_name != ACTUATOR_NAME_NOTHING) {
ext->actuator_con.product_name = pdata->af_product_name;
ext->actuator_con.peri_type = SE_I2C;
ext->actuator_con.peri_setting.i2c.channel = pdata->af_i2c_ch;
ext->actuator_con.peri_setting.i2c.slave_address = pdata->af_i2c_addr;
ext->actuator_con.peri_setting.i2c.speed = 400000;
}
if (pdata->flash_product_name != FLADRV_NAME_NOTHING) {
ext->flash_con.product_name = pdata->flash_product_name;
ext->flash_con.peri_type = SE_GPIO;
ext->flash_con.peri_setting.gpio.first_gpio_port_no = pdata->flash_first_gpio;
ext->flash_con.peri_setting.gpio.second_gpio_port_no = pdata->flash_second_gpio;
}
ext->from_con.product_name = FROMDRV_NAME_NOTHING;
if (pdata->companion_product_name != COMPANION_NAME_NOTHING) {
ext->companion_con.product_name = pdata->companion_product_name;
ext->companion_con.peri_info0.valid = true;
ext->companion_con.peri_info0.peri_type = SE_SPI;
ext->companion_con.peri_info0.peri_setting.spi.channel = pdata->companion_spi_channel;
ext->companion_con.peri_info1.valid = true;
ext->companion_con.peri_info1.peri_type = SE_I2C;
ext->companion_con.peri_info1.peri_setting.i2c.channel = pdata->companion_i2c_ch;
ext->companion_con.peri_info1.peri_setting.i2c.slave_address = pdata->companion_i2c_addr;
ext->companion_con.peri_info1.peri_setting.i2c.speed = 400000;
ext->companion_con.peri_info2.valid = true;
ext->companion_con.peri_info2.peri_type = SE_FIMC_LITE;
ext->companion_con.peri_info2.peri_setting.fimc_lite.channel = FLITE_ID_D;
} else {
ext->companion_con.product_name = pdata->companion_product_name;
}
if (pdata->ois_product_name != OIS_NAME_NOTHING) {
ext->ois_con.product_name = pdata->ois_product_name;
ext->ois_con.peri_type = SE_I2C;
ext->ois_con.peri_setting.i2c.channel = pdata->ois_i2c_ch;
ext->ois_con.peri_setting.i2c.slave_address = pdata->ois_i2c_addr;
ext->ois_con.peri_setting.i2c.speed = 400000;
} else {
ext->ois_con.product_name = pdata->ois_product_name;
ext->ois_con.peri_type = SE_NULL;
}
v4l2_subdev_init(subdev_module, &subdev_ops);
v4l2_set_subdevdata(subdev_module, module);
v4l2_set_subdev_hostdata(subdev_module, device);
snprintf(subdev_module->name, V4L2_SUBDEV_NAME_SIZE, "sensor-subdev.%d", module->sensor_id);
p_err:
probe_info("%s(%d)\n", __func__, ret);
return ret;
}
int sensor_4h5_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int ret = 0;
struct fimc_is_core *core;
struct v4l2_subdev *subdev_module;
struct fimc_is_module_enum *module;
struct fimc_is_device_sensor *device;
struct sensor_open_extended *ext;
BUG_ON(!fimc_is_dev);
core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
if (!core) {
err("core device is not yet probed");
return -EPROBE_DEFER;
}
device = &core->sensor[SENSOR_S5K4H5_INSTANCE];
subdev_module = kzalloc(sizeof(struct v4l2_subdev), GFP_KERNEL);
if (!subdev_module) {
err("subdev_module is NULL");
ret = -ENOMEM;
goto p_err;
}
module = &device->module_enum[atomic_read(&core->resourcemgr.rsccount_module)];
atomic_inc(&core->resourcemgr.rsccount_module);
clear_bit(FIMC_IS_MODULE_GPIO_ON, &module->state);
module->sensor_id = SENSOR_NAME_S5K4H5;
module->subdev = subdev_module;
module->device = SENSOR_S5K4H5_INSTANCE;
module->ops = NULL;
module->client = client;
module->active_width = 3264;
module->active_height = 2448;
module->pixel_width = module->active_width + 16;
module->pixel_height = module->active_height + 10;
module->max_framerate = 120;
module->position = SENSOR_POSITION_REAR;
module->mode = CSI_MODE_CH0_ONLY;
module->lanes = CSI_DATA_LANES_4;
module->bitwidth = 10;
module->sensor_maker = "SLSI";
module->sensor_name = "S5K4H5";
module->setfile_name = "setfile_4h5.bin";
module->cfgs = ARRAY_SIZE(config_4h5);
module->cfg = config_4h5;
module->ops = NULL;
module->private_data = NULL;
ext = &module->ext;
ext->mipi_lane_num = module->lanes;
ext->I2CSclk = I2C_L0;
ext->sensor_con.product_name = 0;
ext->sensor_con.peri_type = SE_I2C;
ext->sensor_con.peri_setting.i2c.channel = SENSOR_CONTROL_I2C0;
ext->sensor_con.peri_setting.i2c.slave_address = 0x6E;
ext->sensor_con.peri_setting.i2c.speed = 400000;
ext->actuator_con.product_name = ACTUATOR_NAME_DW9804;
ext->actuator_con.peri_type = SE_I2C;
ext->actuator_con.peri_setting.i2c.channel
= SENSOR_CONTROL_I2C0;
ext->flash_con.product_name = FLADRV_NAME_RT5033;
ext->flash_con.peri_type = SE_GPIO;
ext->flash_con.peri_setting.gpio.first_gpio_port_no = 8;
ext->flash_con.peri_setting.gpio.second_gpio_port_no = 6;
/* ext->from_con.product_name = FROMDRV_NAME_W25Q80BW; */
ext->from_con.product_name = FROMDRV_NAME_NOTHING;
ext->mclk = 0;
ext->mipi_lane_num = 0;
ext->mipi_speed = 0;
ext->fast_open_sensor = 0;
ext->self_calibration_mode = 0;
ext->I2CSclk = I2C_L0;
ext->preprocessor_con.product_name = PREPROCESSOR_NAME_NOTHING;
if (client) {
v4l2_i2c_subdev_init(subdev_module, client, &subdev_ops);
} else {
v4l2_subdev_init(subdev_module, &subdev_ops);
}
v4l2_set_subdevdata(subdev_module, module);
v4l2_set_subdev_hostdata(subdev_module, device);
snprintf(subdev_module->name, V4L2_SUBDEV_NAME_SIZE, "sensor-subdev.%d", module->id);
p_err:
probe_info("%s(%d)\n", __func__, ret);
return ret;
}
int sensor_ak7348_actuator_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int ret = 0;
struct fimc_is_core *core= NULL;
struct v4l2_subdev *subdev_actuator = NULL;
struct fimc_is_actuator *actuator = NULL;
struct fimc_is_device_sensor *device = NULL;
struct fimc_is_device_sensor_peri *sensor_peri = NULL;
u32 sensor_id = 0;
struct device *dev;
struct device_node *dnode;
BUG_ON(!fimc_is_dev);
BUG_ON(!client);
core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
if (!core) {
err("core device is not yet probed");
ret = -EPROBE_DEFER;
goto p_err;
}
dev = &client->dev;
dnode = dev->of_node;
ret = of_property_read_u32(dnode, "id", &sensor_id);
if (ret) {
err("id read is fail(%d)", ret);
goto p_err;
}
probe_info("%s sensor_id %d\n", __func__, sensor_id);
device = &core->sensor[sensor_id];
if (!device) {
err("sensor device is NULL");
ret = -ENOMEM;
goto p_err;
}
sensor_peri = find_peri_by_act_id(device, ACTUATOR_NAME_AK7348);
if (!sensor_peri) {
probe_err("sensor peri is net yet probed");
return -EPROBE_DEFER;
}
actuator = &sensor_peri->actuator;
if (!actuator) {
err("acuator is NULL");
ret = -ENOMEM;
goto p_err;
}
subdev_actuator = kzalloc(sizeof(struct v4l2_subdev), GFP_KERNEL);
if (!subdev_actuator) {
err("subdev_actuator is NULL");
ret = -ENOMEM;
goto p_err;
}
sensor_peri->subdev_actuator = subdev_actuator;
/* This name must is match to sensor_open_extended actuator name */
actuator->id = ACTUATOR_NAME_AK7348;
actuator->subdev = subdev_actuator;
actuator->device = sensor_id;
actuator->client = client;
actuator->position = 0;
actuator->max_position = AK7348_POS_MAX_SIZE;
actuator->pos_size_bit = AK7348_POS_SIZE_BIT;
actuator->pos_direction = AK7348_POS_DIRECTION;
v4l2_i2c_subdev_init(subdev_actuator, client, &subdev_ops);
v4l2_set_subdevdata(subdev_actuator, actuator);
v4l2_set_subdev_hostdata(subdev_actuator, device);
ret = v4l2_device_register_subdev(&device->v4l2_dev, subdev_actuator);
if (ret) {
merr("v4l2_device_register_subdev is fail(%d)", device, ret);
goto p_err;
}
set_bit(FIMC_IS_SENSOR_ACTUATOR_AVAILABLE, &sensor_peri->peri_state);
snprintf(subdev_actuator->name, V4L2_SUBDEV_NAME_SIZE, "actuator-subdev.%d", actuator->id);
p_err:
probe_info("%s done\n", __func__);
return ret;
}
int sensor_imx134_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int ret = 0;
struct fimc_is_core *core;
struct v4l2_subdev *subdev_module;
struct fimc_is_module_enum *module;
struct fimc_is_device_sensor *device;
struct sensor_open_extended *ext;
BUG_ON(!fimc_is_dev);
core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
if (!core) {
probe_err("core device is not yet probed");
return -EPROBE_DEFER;
}
device = &core->sensor[SENSOR_IMX134_INSTANCE];
subdev_module = kzalloc(sizeof(struct v4l2_subdev), GFP_KERNEL);
if (!subdev_module) {
probe_err("subdev_module is NULL");
ret = -ENOMEM;
goto p_err;
}
module = &device->module_enum[atomic_read(&core->resourcemgr.rsccount_module)];
atomic_inc(&core->resourcemgr.rsccount_module);
module->sensor_id = SENSOR_NAME_IMX134;
module->subdev = subdev_module;
module->device = SENSOR_IMX134_INSTANCE;
module->ops = NULL;
module->client = client;
module->active_width = 3264;
module->active_height = 2448;
module->pixel_width = module->active_width + 16;
module->pixel_height = module->active_height + 10;
module->max_framerate = 300;
module->position = SENSOR_POSITION_REAR;
module->mode = CSI_MODE_CH0_ONLY;
module->lanes = CSI_DATA_LANES_4;
module->sensor_maker = "SONY";
module->sensor_name = "IMX134";
module->setfile_name = "setfile_imx134.bin";
module->cfgs = ARRAY_SIZE(config_imx134);
module->cfg = config_imx134;
module->ops = NULL;
module->private_data = NULL;
#ifdef CONFIG_OF
module->power_setpin = sensor_imx134_power_setpin;
#endif
ext = &module->ext;
ext->mipi_lane_num = module->lanes;
ext->I2CSclk = I2C_L0;
ext->sensor_con.product_name = SENSOR_NAME_IMX134;
ext->sensor_con.peri_type = SE_I2C;
ext->sensor_con.peri_setting.i2c.channel = SENSOR_CONTROL_I2C0;
ext->sensor_con.peri_setting.i2c.slave_address = 0x34;
ext->sensor_con.peri_setting.i2c.speed = 400000;
ext->actuator_con.product_name = ACTUATOR_NAME_AK7345;//ACTUATOR_NAME_NOTHING;
ext->actuator_con.peri_type = SE_I2C;
ext->actuator_con.peri_setting.i2c.channel = SENSOR_CONTROL_I2C1;
ext->actuator_con.peri_setting.i2c.slave_address = 0x34;
ext->actuator_con.peri_setting.i2c.speed = 400000;
#ifdef CONFIG_LEDS_MAX77804
ext->flash_con.product_name = FLADRV_NAME_MAX77693;
#endif
#ifdef CONFIG_LEDS_LM3560
ext->flash_con.product_name = FLADRV_NAME_LM3560;
#endif
#ifdef CONFIG_LEDS_SKY81296
ext->flash_con.product_name = FLADRV_NAME_SKY81296;
#endif
#ifdef CONFIG_LEDS_KTD2692
ext->flash_con.product_name = FLADRV_NAME_KTD2692;
#endif
ext->flash_con.peri_type = SE_GPIO;
ext->flash_con.peri_setting.gpio.first_gpio_port_no = 1;
ext->flash_con.peri_setting.gpio.second_gpio_port_no = 2;
ext->from_con.product_name = FROMDRV_NAME_NOTHING;
ext->companion_con.product_name = COMPANION_NAME_NOTHING;
if (client) {
v4l2_i2c_subdev_init(subdev_module, client, &subdev_ops);
} else {
v4l2_subdev_init(subdev_module, &subdev_ops);
}
v4l2_set_subdevdata(subdev_module, module);
v4l2_set_subdev_hostdata(subdev_module, device);
snprintf(subdev_module->name, V4L2_SUBDEV_NAME_SIZE, "sensor-subdev.%d", module->id);
p_err:
probe_info("%s(%d)\n", __func__, ret);
return ret;
}
int sensor_2p3_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int ret = 0;
struct fimc_is_core *core;
struct v4l2_subdev *subdev_module;
struct fimc_is_module_enum *module;
struct fimc_is_device_sensor *device;
struct sensor_open_extended *ext;
BUG_ON(!fimc_is_dev);
core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
if (!core) {
probe_err("core device is not yet probed");
return -EPROBE_DEFER;
}
device = &core->sensor[SENSOR_2P3_INSTANCE];
subdev_module = kzalloc(sizeof(struct v4l2_subdev), GFP_KERNEL);
if (!subdev_module) {
probe_err("subdev_module is NULL");
ret = -ENOMEM;
goto p_err;
}
module = &device->module_enum[atomic_read(&core->resourcemgr.rsccount_module)];
atomic_inc(&core->resourcemgr.rsccount_module);
clear_bit(FIMC_IS_MODULE_GPIO_ON, &module->state);
module->sensor_id = SENSOR_NAME_S5K2P3;
module->subdev = subdev_module;
module->device = SENSOR_2P3_INSTANCE;
module->client = client;
module->active_width = 5312;
module->active_height = 2990;
module->margin_left = 8;
module->margin_right = 8;
module->margin_top = 6;
module->margin_bottom = 4;
module->pixel_width = module->active_width + 16;
module->pixel_height = module->active_height + 10;
module->max_framerate = 300;
module->position = SENSOR_POSITION_REAR;
module->mode = CSI_MODE_CH0_ONLY;
module->lanes = CSI_DATA_LANES_4;
module->sensor_maker = "SLSI";
module->sensor_name = "S5K2P3";
module->setfile_name = "setfile_2p3.bin";
module->cfgs = ARRAY_SIZE(config_2p3);
module->cfg = config_2p3;
module->ops = NULL;
module->private_data = NULL;
#ifdef CONFIG_OF
module->power_setpin = sensor_2p3_power_setpin;
#endif
ext = &module->ext;
ext->mipi_lane_num = module->lanes;
ext->I2CSclk = I2C_L0;
ext->sensor_con.product_name = SENSOR_NAME_S5K2P3;
ext->sensor_con.peri_type = SE_I2C;
ext->sensor_con.peri_setting.i2c.channel = SENSOR_CONTROL_I2C0;
ext->sensor_con.peri_setting.i2c.slave_address = 0x20;
ext->sensor_con.peri_setting.i2c.speed = 400000;
ext->actuator_con.product_name = ACTUATOR_NAME_AK7345;
ext->actuator_con.peri_type = SE_I2C;
ext->actuator_con.peri_setting.i2c.channel = SENSOR_CONTROL_I2C1;
ext->actuator_con.peri_setting.i2c.slave_address = 0x20;
ext->actuator_con.peri_setting.i2c.speed = 400000;
#ifdef CONFIG_LEDS_MAX77804
ext->flash_con.product_name = FLADRV_NAME_MAX77693;
#endif
#if defined(CONFIG_LEDS_LM3560) || !defined(CONFIG_USE_VENDER_FEATURE)
ext->flash_con.product_name = FLADRV_NAME_LM3560;
#endif
#ifdef CONFIG_LEDS_SKY81296
ext->flash_con.product_name = FLADRV_NAME_SKY81296;
#endif
ext->flash_con.peri_type = SE_GPIO;
#ifdef CONFIG_USE_VENDER_FEATURE
ext->flash_con.peri_setting.gpio.first_gpio_port_no = 1;
ext->flash_con.peri_setting.gpio.second_gpio_port_no = 2;
#else
ext->flash_con.peri_setting.gpio.first_gpio_port_no = 2;
ext->flash_con.peri_setting.gpio.second_gpio_port_no = 3;
#endif
ext->from_con.product_name = FROMDRV_NAME_NOTHING;
#ifdef CONFIG_COMPANION_USE
ext->companion_con.product_name = COMPANION_NAME_73C1;
ext->companion_con.peri_info0.valid = true;
ext->companion_con.peri_info0.peri_type = SE_SPI;
ext->companion_con.peri_info0.peri_setting.spi.channel = 0;
ext->companion_con.peri_info1.valid = true;
ext->companion_con.peri_info1.peri_type = SE_I2C;
ext->companion_con.peri_info1.peri_setting.i2c.channel = 0;
ext->companion_con.peri_info1.peri_setting.i2c.slave_address = 0x7A;
ext->companion_con.peri_info1.peri_setting.i2c.speed = 400000;
ext->companion_con.peri_info2.valid = true;
ext->companion_con.peri_info2.peri_type = SE_FIMC_LITE;
ext->companion_con.peri_info2.peri_setting.fimc_lite.channel = FLITE_ID_D;
#else
ext->companion_con.product_name = COMPANION_NAME_NOTHING;
#endif
#if defined(CONFIG_OIS_USE)
ext->ois_con.product_name = OIS_NAME_IDG2030;
ext->ois_con.peri_type = SE_I2C;
ext->ois_con.peri_setting.i2c.channel = SENSOR_CONTROL_I2C1;
ext->ois_con.peri_setting.i2c.slave_address = 0x48;
ext->ois_con.peri_setting.i2c.speed = 400000;
#else
ext->ois_con.product_name = OIS_NAME_NOTHING;
ext->ois_con.peri_type = SE_NULL;
#endif
if (client) {
v4l2_i2c_subdev_init(subdev_module, client, &subdev_ops);
} else {
v4l2_subdev_init(subdev_module, &subdev_ops);
}
v4l2_set_subdevdata(subdev_module, module);
v4l2_set_subdev_hostdata(subdev_module, device);
snprintf(subdev_module->name, V4L2_SUBDEV_NAME_SIZE, "sensor-subdev.%d", module->id);
p_err:
probe_info("%s(%d)\n", __func__, ret);
return ret;
}
int cis_2p8_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int ret = 0;
struct fimc_is_core *core = NULL;
struct v4l2_subdev *subdev_cis = NULL;
struct fimc_is_cis *cis = NULL;
struct fimc_is_device_sensor *device = NULL;
struct fimc_is_device_sensor_peri *sensor_peri = NULL;
u32 sensor_id = 0;
char const *setfile;
struct device *dev;
struct device_node *dnode;
BUG_ON(!client);
BUG_ON(!fimc_is_dev);
core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
if (!core) {
probe_err("core device is not yet probed");
return -EPROBE_DEFER;
}
dev = &client->dev;
dnode = dev->of_node;
ret = of_property_read_u32(dnode, "id", &sensor_id);
if (ret) {
err("sensor id read is fail(%d)", ret);
goto p_err;
}
probe_info("%s sensor id %d\n", __func__, sensor_id);
device = &core->sensor[sensor_id];
sensor_peri = find_peri_by_cis_id(device, SENSOR_NAME_S5K2P8);
if (!sensor_peri) {
probe_err("sensor peri is net yet probed");
return -EPROBE_DEFER;
}
cis = &sensor_peri->cis;
if (!cis) {
err("cis is NULL");
ret = -ENOMEM;
goto p_err;
}
subdev_cis = kzalloc(sizeof(struct v4l2_subdev), GFP_KERNEL);
if (!subdev_cis) {
probe_err("subdev_cis is NULL");
ret = -ENOMEM;
goto p_err;
}
sensor_peri->subdev_cis = subdev_cis;
cis->id = SENSOR_NAME_S5K2P8;
cis->subdev = subdev_cis;
cis->device = 0;
cis->client = client;
sensor_peri->module->client = cis->client;
cis->cis_data = kzalloc(sizeof(cis_shared_data), GFP_KERNEL);
if (!cis->cis_data) {
err("cis_data is NULL");
ret = -ENOMEM;
goto p_err;
}
cis->cis_ops = &cis_ops;
/* belows are depend on sensor cis. MUST check sensor spec */
cis->bayer_order = OTF_INPUT_ORDER_BAYER_GR_BG;
cis->aperture_num = F2_2;
cis->use_dgain = true;
cis->hdr_ctrl_by_again = false;
ret = of_property_read_string(dnode, "setfile", &setfile);
if (ret) {
err("setfile index read fail(%d), take default setfile!!", ret);
setfile = "default";
}
if (strcmp(setfile, "default") == 0 ||
strcmp(setfile, "setA") == 0) {
probe_info("%s setfile_A\n", __func__);
sensor_2p8_setfiles = sensor_2p8_setfiles_A;
sensor_2p8_setfile_sizes = sensor_2p8_setfile_A_sizes;
sensor_2p8_pllinfos = sensor_2p8_pllinfos_A;
sensor_2p8_max_setfile_num = sizeof(sensor_2p8_setfiles_A) / sizeof(sensor_2p8_setfiles_A[0]);
} else if (strcmp(setfile, "setB") == 0) {
probe_info("%s setfile_B\n", __func__);
sensor_2p8_setfiles = sensor_2p8_setfiles_B;
sensor_2p8_setfile_sizes = sensor_2p8_setfile_B_sizes;
sensor_2p8_pllinfos = sensor_2p8_pllinfos_B;
sensor_2p8_max_setfile_num = sizeof(sensor_2p8_setfiles_B) / sizeof(sensor_2p8_setfiles_B[0]);
} else {
err("%s setfile index out of bound, take default (setfile_A)", __func__);
sensor_2p8_setfiles = sensor_2p8_setfiles_A;
sensor_2p8_setfile_sizes = sensor_2p8_setfile_A_sizes;
sensor_2p8_pllinfos = sensor_2p8_pllinfos_A;
sensor_2p8_max_setfile_num = sizeof(sensor_2p8_setfiles_A) / sizeof(sensor_2p8_setfiles_A[0]);
}
v4l2_i2c_subdev_init(subdev_cis, client, &subdev_ops);
v4l2_set_subdevdata(subdev_cis, cis);
v4l2_set_subdev_hostdata(subdev_cis, device);
snprintf(subdev_cis->name, V4L2_SUBDEV_NAME_SIZE, "cis-subdev.%d", cis->id);
probe_info("%s done\n", __func__);
p_err:
return ret;
}
int sensor_sr200_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int ret = 0;
struct fimc_is_core *core;
struct v4l2_subdev *subdev_module;
struct fimc_is_module_enum *module;
struct fimc_is_device_sensor *device;
struct exynos_platform_fimc_is_module *pdata;
BUG_ON(!fimc_is_dev);
core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
if (!core) {
probe_err("core device is not yet probed");
return -EPROBE_DEFER;
}
device = &core->sensor[SENSOR_SR200_INSTANCE];
core->client_soc = client;
pdata = kzalloc(sizeof(struct exynos_platform_fimc_is_module), GFP_KERNEL);
if (!pdata) {
pr_err("%s: no memory for platform data\n", __func__);
return -ENOMEM;
}
#ifdef CONFIG_OF
fimc_is_sensor_module_soc_parse_dt(client, pdata, sensor_sr200_power_setpin);
#endif
subdev_module = kzalloc(sizeof(struct v4l2_subdev), GFP_KERNEL);
if (!subdev_module) {
probe_err("subdev_module is NULL");
ret = -ENOMEM;
goto p_err;
}
/* SR200 */
module = &device->module_enum[atomic_read(&core->resourcemgr.rsccount_module)];
atomic_inc(&core->resourcemgr.rsccount_module);
module->pdata = pdata;
module->sensor_id = SENSOR_SR200_NAME;
module->subdev = subdev_module;
module->device = SENSOR_SR200_INSTANCE;
module->ops = &module_sr200_ops;
module->client = client;
module->active_width = 1600;
module->active_height = 1200;
module->pixel_width = module->active_width + 20;
module->pixel_height = module->active_height + 20;
module->max_framerate = 30;
module->position = SENSOR_POSITION_FRONT;
module->mode = CSI_MODE_CH0_ONLY;
module->lanes = CSI_DATA_LANES_1;
module->vcis = ARRAY_SIZE(vci_sr200);
module->vci = vci_sr200;
module->sensor_maker = "SF";
module->sensor_name = "SR200PC20M";
module->cfgs = ARRAY_SIZE(settle_sr200);
module->cfg = settle_sr200;
module->private_data = kzalloc(sizeof(struct sr200_state), GFP_KERNEL);
if (!module->private_data) {
probe_err("private_data is NULL");
ret = -ENOMEM;
kfree(subdev_module);
goto p_err;
}
v4l2_i2c_subdev_init(subdev_module, client, &subdev_ops);
v4l2_set_subdevdata(subdev_module, module);
v4l2_set_subdev_hostdata(subdev_module, device);
snprintf(subdev_module->name, V4L2_SUBDEV_NAME_SIZE, "sensor-subdev.%d", module->sensor_id);
p_err:
probe_info("%s(%d)\n", __func__, ret);
return ret;
}
static int fimc_is_probe(struct platform_device *pdev)
{
struct exynos_platform_fimc_is *pdata;
#if defined (ENABLE_IS_CORE) || defined (USE_MCUCTL)
struct resource *mem_res;
struct resource *regs_res;
#endif
struct fimc_is_core *core;
int ret = -ENODEV;
#ifndef ENABLE_IS_CORE
int i;
#endif
u32 stream;
struct pinctrl_state *s;
probe_info("%s:start(%ld, %ld)\n", __func__,
sizeof(struct fimc_is_core), sizeof(struct fimc_is_video_ctx));
core = kzalloc(sizeof(struct fimc_is_core), GFP_KERNEL);
if (!core) {
probe_err("core is NULL");
return -ENOMEM;
}
fimc_is_dev = &pdev->dev;
dev_set_drvdata(fimc_is_dev, core);
pdata = dev_get_platdata(&pdev->dev);
if (!pdata) {
#ifdef CONFIG_OF
ret = fimc_is_parse_dt(pdev);
if (ret) {
err("fimc_is_parse_dt is fail(%d)", ret);
return ret;
}
pdata = dev_get_platdata(&pdev->dev);
#else
BUG();
#endif
}
#ifdef USE_ION_ALLOC
core->fimc_ion_client = ion_client_create(ion_exynos, "fimc-is");
#endif
core->pdev = pdev;
core->pdata = pdata;
core->current_position = SENSOR_POSITION_REAR;
device_init_wakeup(&pdev->dev, true);
/* for mideaserver force down */
atomic_set(&core->rsccount, 0);
#if defined (ENABLE_IS_CORE) || defined (USE_MCUCTL)
mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!mem_res) {
probe_err("Failed to get io memory region(%p)", mem_res);
goto p_err1;
}
regs_res = request_mem_region(mem_res->start, resource_size(mem_res), pdev->name);
if (!regs_res) {
probe_err("Failed to request io memory region(%p)", regs_res);
goto p_err1;
}
core->regs_res = regs_res;
core->regs = ioremap_nocache(mem_res->start, resource_size(mem_res));
if (!core->regs) {
probe_err("Failed to remap io region(%p)", core->regs);
goto p_err2;
}
#else
core->regs_res = NULL;
core->regs = NULL;
#endif
#ifdef ENABLE_IS_CORE
core->irq = platform_get_irq(pdev, 0);
if (core->irq < 0) {
probe_err("Failed to get irq(%d)", core->irq);
goto p_err3;
}
#endif
ret = pdata->clk_get(&pdev->dev);
if (ret) {
probe_err("clk_get is fail(%d)", ret);
goto p_err3;
}
ret = fimc_is_mem_probe(&core->resourcemgr.mem, core->pdev);
if (ret) {
probe_err("fimc_is_mem_probe is fail(%d)", ret);
goto p_err3;
}
ret = fimc_is_resourcemgr_probe(&core->resourcemgr, core);
if (ret) {
probe_err("fimc_is_resourcemgr_probe is fail(%d)", ret);
goto p_err3;
}
ret = fimc_is_interface_probe(&core->interface,
&core->resourcemgr.minfo,
(ulong)core->regs,
core->irq,
core);
if (ret) {
probe_err("fimc_is_interface_probe is fail(%d)", ret);
goto p_err3;
}
ret = fimc_is_debug_probe();
if (ret) {
probe_err("fimc_is_deubg_probe is fail(%d)", ret);
goto p_err3;
}
ret = fimc_is_vender_probe(&core->vender);
if (ret) {
probe_err("fimc_is_vender_probe is fail(%d)", ret);
goto p_err3;
}
/* group initialization */
ret = fimc_is_groupmgr_probe(&core->groupmgr);
if (ret) {
probe_err("fimc_is_groupmgr_probe is fail(%d)", ret);
goto p_err3;
}
for (stream = 0; stream < FIMC_IS_STREAM_COUNT; ++stream) {
ret = fimc_is_ischain_probe(&core->ischain[stream],
&core->interface,
&core->resourcemgr,
&core->groupmgr,
&core->resourcemgr.mem,
core->pdev,
stream);
if (ret) {
probe_err("fimc_is_ischain_probe(%d) is fail(%d)", stream, ret);
goto p_err3;
}
#ifndef ENABLE_IS_CORE
core->ischain[stream].hardware = &core->hardware;
#endif
}
ret = v4l2_device_register(&pdev->dev, &core->v4l2_dev);
if (ret) {
dev_err(&pdev->dev, "failed to register fimc-is v4l2 device\n");
goto p_err3;
}
#ifdef SOC_30S
/* video entity - 3a0 */
fimc_is_30s_video_probe(core);
#endif
#ifdef SOC_30C
/* video entity - 3a0 capture */
fimc_is_30c_video_probe(core);
#endif
#ifdef SOC_30P
/* video entity - 3a0 preview */
fimc_is_30p_video_probe(core);
#endif
#ifdef SOC_31S
/* video entity - 3a1 */
fimc_is_31s_video_probe(core);
#endif
#ifdef SOC_31C
/* video entity - 3a1 capture */
fimc_is_31c_video_probe(core);
#endif
#ifdef SOC_31P
/* video entity - 3a1 preview */
fimc_is_31p_video_probe(core);
#endif
#ifdef SOC_I0S
/* video entity - isp0 */
fimc_is_i0s_video_probe(core);
#endif
#ifdef SOC_I0C
/* video entity - isp0 capture */
fimc_is_i0c_video_probe(core);
#endif
#ifdef SOC_I0P
/* video entity - isp0 preview */
fimc_is_i0p_video_probe(core);
#endif
#ifdef SOC_I1S
/* video entity - isp1 */
fimc_is_i1s_video_probe(core);
#endif
#ifdef SOC_I1C
/* video entity - isp1 capture */
fimc_is_i1c_video_probe(core);
#endif
#ifdef SOC_I1P
/* video entity - isp1 preview */
fimc_is_i1p_video_probe(core);
#endif
#ifdef SOC_DIS
/* video entity - dis */
fimc_is_dis_video_probe(core);
#endif
#ifdef SOC_SCC
/* video entity - scc */
fimc_is_scc_video_probe(core);
#endif
#ifdef SOC_SCP
/* video entity - scp */
fimc_is_scp_video_probe(core);
#endif
#ifdef SOC_MCS
/* video entity - scp */
fimc_is_m0s_video_probe(core);
fimc_is_m1s_video_probe(core);
fimc_is_m0p_video_probe(core);
fimc_is_m1p_video_probe(core);
fimc_is_m2p_video_probe(core);
fimc_is_m3p_video_probe(core);
fimc_is_m4p_video_probe(core);
#endif
platform_set_drvdata(pdev, core);
#ifndef ENABLE_IS_CORE
ret = fimc_is_interface_ischain_probe(&core->interface_ischain,
&core->hardware,
&core->resourcemgr,
core->pdev,
(ulong)core->regs);
if (ret) {
dev_err(&pdev->dev, "interface_ischain_probe fail\n");
goto p_err1;
}
ret = fimc_is_hardware_probe(&core->hardware, &core->interface, &core->interface_ischain);
if (ret) {
dev_err(&pdev->dev, "hardware_probe fail\n");
goto p_err1;
}
/* set sysfs for set position to actuator */
sysfs_actuator.init_step = 0;
for (i = 0; i < INIT_MAX_SETTING; i++) {
sysfs_actuator.init_positions[i] = -1;
sysfs_actuator.init_delays[i] = -1;
}
#endif
#if defined(CONFIG_SOC_EXYNOS5430) || defined(CONFIG_SOC_EXYNOS5433)
#if defined(CONFIG_VIDEOBUF2_ION)
if (core->resourcemgr.mem.alloc_ctx)
vb2_ion_attach_iommu(core->resourcemgr.mem.alloc_ctx);
#endif
#endif
EXYNOS_MIF_ADD_NOTIFIER(&exynos_fimc_is_mif_throttling_nb);
#if defined(CONFIG_PM_RUNTIME)
pm_runtime_enable(&pdev->dev);
#endif
#ifdef ENABLE_FAULT_HANDLER
#if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 9, 0))
exynos_sysmmu_set_fault_handler(fimc_is_dev, fimc_is_fault_handler);
#else
iovmm_set_fault_handler(fimc_is_dev, fimc_is_fault_handler, NULL);
#endif
#endif
/* set sysfs for debuging */
sysfs_debug.en_clk_gate = 0;
sysfs_debug.en_dvfs = 1;
#ifdef ENABLE_CLOCK_GATE
sysfs_debug.en_clk_gate = 1;
#ifdef HAS_FW_CLOCK_GATE
sysfs_debug.clk_gate_mode = CLOCK_GATE_MODE_FW;
#else
sysfs_debug.clk_gate_mode = CLOCK_GATE_MODE_HOST;
#endif
#endif
ret = sysfs_create_group(&core->pdev->dev.kobj, &fimc_is_debug_attr_group);
s = pinctrl_lookup_state(pdata->pinctrl, "release");
if (pinctrl_select_state(pdata->pinctrl, s) < 0) {
probe_err("pinctrl_select_state is fail\n");
goto p_err3;
}
probe_info("%s:end\n", __func__);
return 0;
p_err3:
iounmap(core->regs);
#if defined (ENABLE_IS_CORE) || defined (USE_MCUCTL)
p_err2:
release_mem_region(regs_res->start, resource_size(regs_res));
#endif
p_err1:
kfree(core);
return ret;
}
