static int __devinit omap_temp_sensor_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct omap_temp_sensor_pdata *pdata = pdev->dev.platform_data; struct omap_temp_sensor *temp_sensor; struct resource *mem; int ret = 0, val; if (!pdata) { dev_err(dev, "%s: platform data missing\n", __func__); return -EINVAL; } temp_sensor = kzalloc(sizeof(struct omap_temp_sensor), GFP_KERNEL); if (!temp_sensor) return -ENOMEM; spin_lock_init(&temp_sensor->lock); mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!mem) { dev_err(dev, "%s:no mem resource\n", __func__); ret = -EINVAL; goto plat_res_err; } temp_sensor->irq = platform_get_irq_byname(pdev, "thermal_alert"); if (temp_sensor->irq < 0) { dev_err(dev, "%s:Cannot get thermal alert irq\n", __func__); ret = -EINVAL; goto get_irq_err; } ret = gpio_request_one(OMAP_TSHUT_GPIO, GPIOF_DIR_IN, "thermal_shutdown"); if (ret) { dev_err(dev, "%s: Could not get tshut_gpio\n", __func__); goto tshut_gpio_req_err; } temp_sensor->tshut_irq = gpio_to_irq(OMAP_TSHUT_GPIO); if (temp_sensor->tshut_irq < 0) { dev_err(dev, "%s:Cannot get thermal shutdown irq\n", __func__); ret = -EINVAL; goto get_tshut_irq_err; } temp_sensor->phy_base = pdata->offset; temp_sensor->pdev = pdev; temp_sensor->dev = dev; pm_runtime_enable(dev); pm_runtime_irq_safe(dev); /* * check if the efuse has a non-zero value if not * it is an untrimmed sample and the temperatures * may not be accurate */ if (omap_readl(OMAP4_CTRL_MODULE_CORE + OMAP4_CTRL_MODULE_CORE_STD_FUSE_OPP_BGAP)) temp_sensor->is_efuse_valid = 1; temp_sensor->clock = clk_get(&temp_sensor->pdev->dev, "fck"); if (IS_ERR(temp_sensor->clock)) { ret = PTR_ERR(temp_sensor->clock); pr_err("%s:Unable to get fclk: %d\n", __func__, ret); ret = -EINVAL; goto clk_get_err; } /* Init delayed work for throttle decision */ INIT_DELAYED_WORK(&temp_sensor->throttle_work, throttle_delayed_work_fn); platform_set_drvdata(pdev, temp_sensor); ret = omap_temp_sensor_enable(temp_sensor); if (ret) { dev_err(dev, "%s:Cannot enable temp sensor\n", __func__); goto sensor_enable_err; } omap_enable_continuous_mode(temp_sensor); omap_configure_temp_sensor_thresholds(temp_sensor); /* 1 ms */ omap_configure_temp_sensor_counter(temp_sensor, 1); /* Wait till the first conversion is done wait for at least 1ms */ mdelay(2); /* Read the temperature once due to hw issue*/ omap_read_current_temp(temp_sensor); /* Set 2 seconds time as default counter */ omap_configure_temp_sensor_counter(temp_sensor, temp_sensor->clk_rate * 2); ret = request_threaded_irq(temp_sensor->irq, NULL, omap_talert_irq_handler, IRQF_TRIGGER_RISING | IRQF_ONESHOT, "temp_sensor", (void *)temp_sensor); if (ret) { dev_err(dev, "Request threaded irq failed.\n"); goto req_irq_err; } ret = request_threaded_irq(temp_sensor->tshut_irq, NULL, omap_tshut_irq_handler, IRQF_TRIGGER_RISING | IRQF_ONESHOT, "tshut", (void *)temp_sensor); if (ret) { dev_err(dev, "Request threaded irq failed for TSHUT.\n"); goto tshut_irq_req_err; } ret = sysfs_create_group(&pdev->dev.kobj, &omap_temp_sensor_group); if (ret) { dev_err(&pdev->dev, "could not create sysfs files\n"); goto sysfs_create_err; } /* unmask the T_COLD and unmask T_HOT at init */ val = omap_temp_sensor_readl(temp_sensor, BGAP_CTRL_OFFSET); val |= OMAP4_MASK_COLD_MASK; val |= OMAP4_MASK_HOT_MASK; omap_temp_sensor_writel(temp_sensor, val, BGAP_CTRL_OFFSET); dev_info(dev, "%s probed", pdata->name); temp_sensor_pm = temp_sensor; return 0; sysfs_create_err: free_irq(temp_sensor->tshut_irq, temp_sensor); cancel_delayed_work_sync(&temp_sensor->throttle_work); tshut_irq_req_err: free_irq(temp_sensor->irq, temp_sensor); req_irq_err: platform_set_drvdata(pdev, NULL); omap_temp_sensor_disable(temp_sensor); sensor_enable_err: clk_put(temp_sensor->clock); clk_get_err: pm_runtime_disable(dev); get_tshut_irq_err: gpio_free(OMAP_TSHUT_GPIO); tshut_gpio_req_err: get_irq_err: plat_res_err: kfree(temp_sensor); return ret; }
static int __init w1_gpio_probe(struct platform_device *pdev) { struct w1_bus_master *master; struct w1_gpio_platform_data *pdata; int err; err = w1_gpio_probe_dt(pdev); if (err < 0) return err; pdata = pdev->dev.platform_data; if (!pdata) return -ENXIO; master = kzalloc(sizeof(struct w1_bus_master), GFP_KERNEL); if (!master) return -ENOMEM; err = gpio_request(pdata->pin, "w1"); if (err) goto free_master; if (gpio_is_valid(pdata->ext_pullup_enable_pin)) { err = gpio_request_one(pdata->ext_pullup_enable_pin, GPIOF_INIT_LOW, "w1 pullup"); if (err < 0) goto free_gpio; } master->data = pdata; master->read_bit = w1_gpio_read_bit; if (pdata->is_open_drain) { gpio_direction_output(pdata->pin, 1); master->write_bit = w1_gpio_write_bit_val; } else { gpio_direction_input(pdata->pin); master->write_bit = w1_gpio_write_bit_dir; } err = w1_add_master_device(master); if (err) goto free_gpio_ext_pu; if (pdata->enable_external_pullup) pdata->enable_external_pullup(1); if (gpio_is_valid(pdata->ext_pullup_enable_pin)) gpio_set_value(pdata->ext_pullup_enable_pin, 1); platform_set_drvdata(pdev, master); return 0; free_gpio_ext_pu: if (gpio_is_valid(pdata->ext_pullup_enable_pin)) gpio_free(pdata->ext_pullup_enable_pin); free_gpio: gpio_free(pdata->pin); free_master: kfree(master); return err; }
static int __init wd_init(void) { struct device_node *node; int rc; node = of_find_node_by_path("/wd@0"); if (!node) { pr_err("Find node by path failed.\n"); return -ENOENT; } wd = kzalloc(sizeof(struct _wd), GFP_KERNEL); if (!wd) return -ENOMEM; wd->gpio_clock = be32_to_cpup(of_get_property(node, "wd,gpio_clock", NULL)); wd->gpio_inhib = be32_to_cpup(of_get_property(node, "wd,gpio_inhib", NULL)); wd->gpio_trig = be32_to_cpup(of_get_property(node, "wd,gpio_trig", NULL)); wd->period_s = be32_to_cpup(of_get_property(node, "wd,period_s", NULL)); wd->last_trig_s = jiffies / HZ; if (!(gpio_is_valid(wd->gpio_inhib)) || !(gpio_is_valid(wd->gpio_clock)) || !(gpio_is_valid(wd->gpio_trig))) { pr_err("GPIO are not valid (problem with device tree ?)\n"); rc = -EACCES; goto free_mem; } rc = gpio_request_one(wd->gpio_clock, GPIOF_IN, "wd-clock"); if (rc < 0) { pr_err("wd-clock GPIO not available\n"); goto free_mem; } rc = gpio_request_one(wd->gpio_inhib ,GPIOF_IN, "wd-inhib"); if (rc < 0) { pr_err("wd-inhib GPIO not available\n"); goto free_gpio_clock; } rc = gpio_request_one(wd->gpio_trig, GPIOF_OUT_INIT_LOW, "wd-trig"); if (rc < 0) { pr_err("wd-trig GPIO not available\n"); goto free_gpio_inhib; } wd_trig(); wd->kobj = kobject_create_and_add("watchdog", kernel_kobj->parent); if (!wd->kobj) { pr_err("Kobject creation failed\n"); rc = -ENOMEM; goto free_gpio_trig; } if (sysfs_create_group(wd->kobj, &wd_attr_group)) { pr_err("Sysfs group creation failed\n"); rc = -ENOMEM; goto put_kobj; } return 0; put_kobj: kobject_put(wd->kobj); free_gpio_trig: gpio_free(wd->gpio_trig); free_gpio_inhib: gpio_free(wd->gpio_inhib); free_gpio_clock: gpio_free(wd->gpio_clock); free_mem: kfree(wd); return rc; }
static int bcm2079x_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret; struct bcm2079x_platform_data *platform_data; struct bcm2079x_dev *bcm2079x_dev; platform_data = client->dev.platform_data; dev_info(&client->dev, "%s, probing bcm2079x driver flags = %x\n", __func__, client->flags); if (platform_data == NULL) { dev_err(&client->dev, "nfc probe fail\n"); return -ENODEV; } if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { dev_err(&client->dev, "need I2C_FUNC_I2C\n"); return -ENODEV; } ret = gpio_request_one(platform_data->irq_gpio, GPIOF_IN, "nfc_int"); if (ret) return -ENODEV; ret = gpio_request_one(platform_data->en_gpio, GPIOF_OUT_INIT_LOW, "nfc_ven"); if (ret) goto err_en; ret = gpio_request_one(platform_data->wake_gpio, GPIOF_OUT_INIT_LOW,"nfc_firm"); if (ret) goto err_firm; gpio_set_value(platform_data->en_gpio, 0); gpio_set_value(platform_data->wake_gpio, 0); bcm2079x_dev = kzalloc(sizeof(*bcm2079x_dev), GFP_KERNEL); if (bcm2079x_dev == NULL) { dev_err(&client->dev, "failed to allocate memory for module data\n"); ret = -ENOMEM; goto err_exit; } bcm2079x_dev->wake_gpio = platform_data->wake_gpio; bcm2079x_dev->irq_gpio = platform_data->irq_gpio; bcm2079x_dev->en_gpio = platform_data->en_gpio; bcm2079x_dev->client = client; /* init mutex and queues */ init_waitqueue_head(&bcm2079x_dev->read_wq); mutex_init(&bcm2079x_dev->read_mutex); spin_lock_init(&bcm2079x_dev->irq_enabled_lock); bcm2079x_dev->bcm2079x_device.minor = MISC_DYNAMIC_MINOR; bcm2079x_dev->bcm2079x_device.name = "bcm2079x-i2c"; bcm2079x_dev->bcm2079x_device.fops = &bcm2079x_dev_fops; ret = misc_register(&bcm2079x_dev->bcm2079x_device); if (ret) { dev_err(&client->dev, "misc_register failed\n"); goto err_misc_register; } /* request irq. the irq is set whenever the chip has data available * for reading. it is cleared when all data has been read. */ dev_info(&client->dev, "requesting IRQ %d\n", client->irq); bcm2079x_dev->irq_enabled = true; ret = request_irq(client->irq, bcm2079x_dev_irq_handler, IRQF_TRIGGER_RISING, client->name, bcm2079x_dev); if (ret) { dev_err(&client->dev, "request_irq failed\n"); goto err_request_irq_failed; } bcm2079x_disable_irq(bcm2079x_dev); i2c_set_clientdata(client, bcm2079x_dev); dev_info(&client->dev, "%s, probing bcm2079x driver exited successfully\n", __func__); return 0; err_request_irq_failed: misc_deregister(&bcm2079x_dev->bcm2079x_device); err_misc_register: mutex_destroy(&bcm2079x_dev->read_mutex); kfree(bcm2079x_dev); err_exit: gpio_free(platform_data->wake_gpio); err_firm: gpio_free(platform_data->en_gpio); err_en: gpio_free(platform_data->irq_gpio); return ret; }
static int gpio_keys_setup_key(struct platform_device *pdev, struct input_dev *input, struct gpio_button_data *bdata, struct gpio_keys_button *button) { const char *desc = button->desc ? button->desc : "gpio_keys"; struct device *dev = &pdev->dev; irq_handler_t isr; unsigned long irqflags; int irq, error; bdata->input = input; bdata->button = button; spin_lock_init(&bdata->lock); if (gpio_is_valid(button->gpio)) { error = gpio_request_one(button->gpio, GPIOF_IN, desc); if (error < 0) { dev_err(dev, "Failed to request GPIO %d, error %d\n", button->gpio, error); return error; } if (button->debounce_interval) { error = gpio_set_debounce(button->gpio, button->debounce_interval * 1000); /* use timer if gpiolib doesn't provide debounce */ if (error < 0) bdata->timer_debounce = button->debounce_interval; } if (!bdata->irq) { irq = gpio_to_irq(button->gpio); if (irq < 0) { error = irq; dev_err(dev, "Unable to get irq number for GPIO %d, error %d\n", button->gpio, error); goto fail; } bdata->irq = irq; } bdata->workqueue = alloc_workqueue("gpio-keys/highpri", WQ_HIGHPRI, 0); if (!bdata->workqueue) dev_err(dev, "failed to alloc own workqueue\n"); INIT_WORK(&bdata->work, gpio_keys_gpio_work_func); setup_timer(&bdata->timer, gpio_keys_gpio_timer, (unsigned long)bdata); isr = gpio_keys_gpio_isr; irqflags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING; } else { if (!button->irq) { dev_err(dev, "No IRQ specified\n"); return -EINVAL; } bdata->irq = button->irq; if (button->type && button->type != EV_KEY) { dev_err(dev, "Only EV_KEY allowed for IRQ buttons.\n"); return -EINVAL; } bdata->timer_debounce = button->debounce_interval; setup_timer(&bdata->timer, gpio_keys_irq_timer, (unsigned long)bdata); isr = gpio_keys_irq_isr; irqflags = 0; } input_set_capability(input, button->type ?: EV_KEY, button->code); /* * If platform has specified that the button can be disabled, * we don't want it to share the interrupt line. */ if (!button->can_disable) irqflags |= IRQF_SHARED; if (button->wakeup) irqflags |= IRQF_NO_SUSPEND; error = request_any_context_irq(bdata->irq, isr, irqflags, desc, bdata); if (error < 0) { dev_err(dev, "Unable to claim irq %d; error %d\n", bdata->irq, error); goto fail; } return 0; fail: if (gpio_is_valid(button->gpio)) gpio_free(button->gpio); return error; }
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; #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_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 SET_PIN_INIT(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON); SET_PIN_INIT(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF); SET_PIN_INIT(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON); SET_PIN_INIT(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF); #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, gpio_cam_en, NULL, PIN_OUTPUT, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_reset, NULL, PIN_RESET, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "ch", PIN_FUNCTION, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_comp_en, NULL, PIN_OUTPUT, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_comp_rst, NULL, PIN_RESET, 0, 0); if (id == SENSOR_POSITION_REAR) { SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "af", PIN_FUNCTION, 0, 0); } SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_reset, NULL, PIN_RESET, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_reset, NULL, PIN_INPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_comp_rst, NULL, PIN_RESET, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_comp_rst, NULL, PIN_INPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_comp_en, NULL, PIN_INPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_cam_en, NULL, PIN_OUTPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON, gpio_cam_en, NULL, PIN_OUTPUT, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON, gpio_reset, NULL, PIN_OUTPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON, gpio_standby, NULL, PIN_OUTPUT, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, gpio_reset, NULL, PIN_RESET, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, gpio_reset, NULL, PIN_INPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, gpio_standby, NULL, PIN_OUTPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, gpio_cam_en, NULL, PIN_OUTPUT, 0, 0); #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 */ /* BACK CAMERA - POWER OFF */ } else { /* FRONT CAMERA - POWER ON */ SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_standby, NULL, PIN_OUTPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "VT_CAM_1.8V", PIN_REGULATOR, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "VT_CAM_2.8V", PIN_REGULATOR, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpios_cam_en, NULL, PIN_OUTPUT, 1, 1000); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_reset, NULL, PIN_OUTPUT, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "ch", PIN_FUNCTION, 1, 0); /* FRONT CAMERA - POWER OFF */ SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_standby, NULL, PIN_OUTPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "off", PIN_FUNCTION, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_reset, NULL, PIN_OUTPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpios_cam_en, NULL, PIN_OUTPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "VT_CAM_2.8V", PIN_REGULATOR, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "VT_CAM_1.8V", PIN_REGULATOR, 0, 0); /* VISION CAMERA - POWER ON */ SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON, gpio_reset, NULL, PIN_OUTPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON, gpio_none, "VT_CAM_1.8V", PIN_REGULATOR, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON, gpio_none, "VT_CAM_2.8V", PIN_REGULATOR, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON, gpios_cam_en, NULL,, PIN_OUTPUT 1, 1000); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON, gpio_standby, NULL, PIN_OUTPUT, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON, gpio_none, "ch", PIN_FUNCTION, 1, 0); /* VISION CAMERA - POWER OFF */ SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, gpio_reset, NULL, PIN_OUTPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, gpio_none, "off", PIN_FUNCTION, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, gpio_standby, NULL, PIN_OUTPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, gpios_cam_en, NULL, PIN_OUTPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, gpio_none, "VT_CAM_2.8V", PIN_REGULATOR, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, gpio_none, "VT_CAM_1.8V", PIN_REGULATOR, 0, 0); } #else /*CONFIG_SOC_EXYNOS5430*/ if (id == SENSOR_POSITION_REAR) { /* BACK CAMERA - POWER ON */ /* BACK CAMERA - POWER OFF */ } else { /* FRONT CAMERA - POWER ON */ SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_standby, NULL, PIN_OUTPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "VT_CAM_1.8V", PIN_REGULATOR, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "VT_CAM_2.8V", PIN_REGULATOR, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "VT_CAM_1.2V", PIN_REGULATOR, 1, 1000); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_reset, NULL, PIN_OUTPUT, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "ch", PIN_FUNCTION, 1, 0); /* FRONT CAMERA - POWER OFF */ SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_standby, NULL, PIN_OUTPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "off", PIN_FUNCTION, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_reset, NULL, PIN_OUTPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "VT_CAM_1.2V", PIN_REGULATOR, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "VT_CAM_2.8V", PIN_REGULATOR, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "VT_CAM_1.8V", PIN_REGULATOR, 0, 0); /* VISION CAMERA - POWER ON */ SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON, gpio_reset, NULL, PIN_OUTPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON, gpio_none, "VT_CAM_1.8V", PIN_REGULATOR, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON, gpio_none, "VT_CAM_2.8V", PIN_REGULATOR, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON, gpio_none, "VT_CAM_1.2V", PIN_REGULATOR, 1, 1000); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON, gpio_standby, NULL, PIN_OUTPUT, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON, gpio_none, "ch", PIN_FUNCTION, 1, 0); /* VISION CAMERA - POWER OFF */ SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, gpio_reset, NULL, PIN_OUTPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, gpio_none, "off", PIN_FUNCTION, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, gpio_standby, NULL, PIN_OUTPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, gpio_none, "VT_CAM_1.2V", PIN_REGULATOR, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, gpio_none, "VT_CAM_2.8V", PIN_REGULATOR, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF, gpio_none, "VT_CAM_1.8V", PIN_REGULATOR, 0, 0); } #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->pinctrl, pdata->pin_ctrls); if (ret < 0) { err("fimc_is_get_pin_lookup_state is fail"); goto p_err; } } return ret; p_err: kfree(pdata); return ret; }
static int cs42l73_i2c_probe(struct i2c_client *i2c_client, const struct i2c_device_id *id) { struct cs42l73_private *cs42l73; struct cs42l73_platform_data *pdata = dev_get_platdata(&i2c_client->dev); int ret; unsigned int devid = 0; unsigned int reg; u32 val32; cs42l73 = devm_kzalloc(&i2c_client->dev, sizeof(struct cs42l73_private), GFP_KERNEL); if (!cs42l73) { dev_err(&i2c_client->dev, "could not allocate codec\n"); return -ENOMEM; } cs42l73->regmap = devm_regmap_init_i2c(i2c_client, &cs42l73_regmap); if (IS_ERR(cs42l73->regmap)) { ret = PTR_ERR(cs42l73->regmap); dev_err(&i2c_client->dev, "regmap_init() failed: %d\n", ret); return ret; } if (pdata) { cs42l73->pdata = *pdata; } else { pdata = devm_kzalloc(&i2c_client->dev, sizeof(struct cs42l73_platform_data), GFP_KERNEL); if (!pdata) { dev_err(&i2c_client->dev, "could not allocate pdata\n"); return -ENOMEM; } if (i2c_client->dev.of_node) { if (of_property_read_u32(i2c_client->dev.of_node, "chgfreq", &val32) >= 0) pdata->chgfreq = val32; } pdata->reset_gpio = of_get_named_gpio(i2c_client->dev.of_node, "reset-gpio", 0); cs42l73->pdata = *pdata; } i2c_set_clientdata(i2c_client, cs42l73); if (cs42l73->pdata.reset_gpio) { ret = gpio_request_one(cs42l73->pdata.reset_gpio, GPIOF_OUT_INIT_HIGH, "CS42L73 /RST"); if (ret < 0) { dev_err(&i2c_client->dev, "Failed to request /RST %d: %d\n", cs42l73->pdata.reset_gpio, ret); return ret; } gpio_set_value_cansleep(cs42l73->pdata.reset_gpio, 0); gpio_set_value_cansleep(cs42l73->pdata.reset_gpio, 1); } regcache_cache_bypass(cs42l73->regmap, true); /* initialize codec */ ret = regmap_read(cs42l73->regmap, CS42L73_DEVID_AB, ®); devid = (reg & 0xFF) << 12; ret = regmap_read(cs42l73->regmap, CS42L73_DEVID_CD, ®); devid |= (reg & 0xFF) << 4; ret = regmap_read(cs42l73->regmap, CS42L73_DEVID_E, ®); devid |= (reg & 0xF0) >> 4; if (devid != CS42L73_DEVID) { ret = -ENODEV; dev_err(&i2c_client->dev, "CS42L73 Device ID (%X). Expected %X\n", devid, CS42L73_DEVID); return ret; } ret = regmap_read(cs42l73->regmap, CS42L73_REVID, ®); if (ret < 0) { dev_err(&i2c_client->dev, "Get Revision ID failed\n"); return ret;; } dev_info(&i2c_client->dev, "Cirrus Logic CS42L73, Revision: %02X\n", reg & 0xFF); regcache_cache_bypass(cs42l73->regmap, false); ret = snd_soc_register_codec(&i2c_client->dev, &soc_codec_dev_cs42l73, cs42l73_dai, ARRAY_SIZE(cs42l73_dai)); if (ret < 0) return ret; return 0; }
int tegra_output_probe(struct tegra_output *output) { struct device_node *ddc, *panel; enum of_gpio_flags flags; int err, size; if (!output->of_node) output->of_node = output->dev->of_node; panel = of_parse_phandle(output->of_node, "nvidia,panel", 0); if (panel) { output->panel = of_drm_find_panel(panel); if (!output->panel) return -EPROBE_DEFER; of_node_put(panel); } output->edid = of_get_property(output->of_node, "nvidia,edid", &size); ddc = of_parse_phandle(output->of_node, "nvidia,ddc-i2c-bus", 0); if (ddc) { output->ddc = of_find_i2c_adapter_by_node(ddc); if (!output->ddc) { err = -EPROBE_DEFER; of_node_put(ddc); return err; } of_node_put(ddc); } output->hpd_gpio = of_get_named_gpio_flags(output->of_node, "nvidia,hpd-gpio", 0, &flags); if (gpio_is_valid(output->hpd_gpio)) { unsigned long flags; err = gpio_request_one(output->hpd_gpio, GPIOF_DIR_IN, "HDMI hotplug detect"); if (err < 0) { dev_err(output->dev, "gpio_request_one(): %d\n", err); return err; } err = gpio_to_irq(output->hpd_gpio); if (err < 0) { dev_err(output->dev, "gpio_to_irq(): %d\n", err); gpio_free(output->hpd_gpio); return err; } output->hpd_irq = err; flags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT; err = request_threaded_irq(output->hpd_irq, NULL, hpd_irq, flags, "hpd", output); if (err < 0) { dev_err(output->dev, "failed to request IRQ#%u: %d\n", output->hpd_irq, err); gpio_free(output->hpd_gpio); return err; } output->connector.polled = DRM_CONNECTOR_POLL_HPD; /* * Disable the interrupt until the connector has been * initialized to avoid a race in the hotplug interrupt * handler. */ disable_irq(output->hpd_irq); } return 0; }
static void __init rb2011_gpio_init(void) { gpio_request_one(RB2011_GPIO_NAND_NCE, GPIOF_OUT_INIT_HIGH, "NAND nCE"); }
static struct clk *clk_register_gpio(struct device *dev, const char *name, const char * const *parent_names, u8 num_parents, unsigned gpio, bool active_low, unsigned long flags, const struct clk_ops *clk_gpio_ops) { struct clk_gpio *clk_gpio; struct clk *clk; struct clk_init_data init = {}; unsigned long gpio_flags; int err; if (dev) clk_gpio = devm_kzalloc(dev, sizeof(*clk_gpio), GFP_KERNEL); else clk_gpio = kzalloc(sizeof(*clk_gpio), GFP_KERNEL); if (!clk_gpio) return ERR_PTR(-ENOMEM); if (active_low) gpio_flags = GPIOF_ACTIVE_LOW | GPIOF_OUT_INIT_HIGH; else gpio_flags = GPIOF_OUT_INIT_LOW; if (dev) err = devm_gpio_request_one(dev, gpio, gpio_flags, name); else err = gpio_request_one(gpio, gpio_flags, name); if (err) { if (err != -EPROBE_DEFER) pr_err("%s: %s: Error requesting clock control gpio %u\n", __func__, name, gpio); if (!dev) kfree(clk_gpio); return ERR_PTR(err); } init.name = name; init.ops = clk_gpio_ops; init.flags = flags | CLK_IS_BASIC; init.parent_names = parent_names; init.num_parents = num_parents; clk_gpio->gpiod = gpio_to_desc(gpio); clk_gpio->hw.init = &init; if (dev) clk = devm_clk_register(dev, &clk_gpio->hw); else clk = clk_register(NULL, &clk_gpio->hw); if (!IS_ERR(clk)) return clk; if (!dev) { gpiod_put(clk_gpio->gpiod); kfree(clk_gpio); } return clk; }
static int edb93xx_cs4271_hw_setup(struct spi_device *spi) { return gpio_request_one(EP93XX_GPIO_LINE_EGPIO6, GPIOF_OUT_INIT_HIGH, spi->modalias); }
static int __devinit reg_fixed_voltage_probe(struct platform_device *pdev) { struct fixed_voltage_config *config = pdev->dev.platform_data; struct fixed_voltage_data *drvdata; int ret; drvdata = kzalloc(sizeof(struct fixed_voltage_data), GFP_KERNEL); if (drvdata == NULL) { dev_err(&pdev->dev, "Failed to allocate device data\n"); ret = -ENOMEM; goto err; } drvdata->desc.name = kstrdup(config->supply_name, GFP_KERNEL); if (drvdata->desc.name == NULL) { dev_err(&pdev->dev, "Failed to allocate supply name\n"); ret = -ENOMEM; goto err; } drvdata->desc.type = REGULATOR_VOLTAGE; drvdata->desc.owner = THIS_MODULE; drvdata->desc.ops = &fixed_voltage_ops; drvdata->desc.n_voltages = 1; drvdata->microvolts = config->microvolts; drvdata->gpio = config->gpio; drvdata->startup_delay = config->startup_delay; if (gpio_is_valid(config->gpio)) { int gpio_flag; drvdata->enable_high = config->enable_high; /* FIXME: Remove below print warning * * config->gpio must be set to -EINVAL by platform code if * GPIO control is not required. However, early adopters * not requiring GPIO control may forget to initialize * config->gpio to -EINVAL. This will cause GPIO 0 to be used * for GPIO control. * * This warning will be removed once there are a couple of users * for this driver. */ if (!config->gpio) dev_warn(&pdev->dev, "using GPIO 0 for regulator enable control\n"); /* * set output direction without changing state * to prevent glitch */ drvdata->is_enabled = config->enabled_at_boot; ret = drvdata->is_enabled ? config->enable_high : !config->enable_high; gpio_flag = ret ? GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW; if (config->gpio_is_open_drain) gpio_flag |= GPIOF_OPEN_DRAIN; ret = gpio_request_one(config->gpio, gpio_flag, config->supply_name); if (ret) { dev_err(&pdev->dev, "Could not obtain regulator enable GPIO %d: %d\n", config->gpio, ret); goto err_name; } } else { /* Regulator without GPIO control is considered * always enabled */ drvdata->is_enabled = true; } drvdata->dev = regulator_register(&drvdata->desc, &pdev->dev, config->init_data, drvdata); if (IS_ERR(drvdata->dev)) { ret = PTR_ERR(drvdata->dev); dev_err(&pdev->dev, "Failed to register regulator: %d\n", ret); goto err_gpio; } platform_set_drvdata(pdev, drvdata); dev_dbg(&pdev->dev, "%s supplying %duV\n", drvdata->desc.name, drvdata->microvolts); return 0; err_gpio: if (gpio_is_valid(config->gpio)) gpio_free(config->gpio); err_name: kfree(drvdata->desc.name); err: kfree(drvdata); return ret; }
static int sensor_2t2_power_setpin(struct platform_device *pdev, struct exynos_platform_fimc_is_module *pdata) { struct device *dev; struct device_node *dnode; int gpio_reset = 0; int gpio_comp_rst = 0; int gpio_mclk = 0; int gpio_none = 0; BUG_ON(!pdev); dev = &pdev->dev; dnode = dev->of_node; dev_info(dev, "%s E v4\n", __func__); gpio_comp_rst = of_get_named_gpio(dnode, "gpio_comp_reset", 0); if (!gpio_is_valid(gpio_comp_rst)) { dev_err(dev, "%s: failed to get main comp reset gpio\n", __func__); return -EINVAL; } gpio_reset = of_get_named_gpio(dnode, "gpio_reset", 0); if (!gpio_is_valid(gpio_reset)) { dev_err(dev, "%s: failed to get PIN_RESET\n", __func__); return -EINVAL; } else { gpio_request_one(gpio_reset, GPIOF_OUT_INIT_LOW, "CAM_GPIO_OUTPUT_LOW"); gpio_free(gpio_reset); } gpio_mclk = of_get_named_gpio(dnode, "gpio_mclk", 0); if (!gpio_is_valid(gpio_mclk)) { dev_err(dev, "%s: failed to get mclk\n", __func__); return -EINVAL; } else { if (gpio_request_one(gpio_mclk, GPIOF_OUT_INIT_LOW, "CAM_MCLK_OUTPUT_LOW")) { dev_err(dev, "%s: failed to gpio request mclk\n", __func__); return -ENODEV; } gpio_free(gpio_mclk); } SET_PIN_INIT(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON); SET_PIN_INIT(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF); #ifdef CONFIG_COMPANION_STANDBY_USE SET_PIN_INIT(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_STANDBY_ENABLE); SET_PIN_INIT(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_STANDBY_DISABLE); #endif SET_PIN_INIT(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_ON); SET_PIN_INIT(pdata, SENSOR_SCENARIO_VISION, GPIO_SCENARIO_OFF); #ifdef CONFIG_OIS_USE SET_PIN_INIT(pdata, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_ON); SET_PIN_INIT(pdata, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_OFF); #endif /* Normal on */ SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_reset, "sen_rst low", PIN_OUTPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "VDDAF_2.8V_CAM", PIN_REGULATOR, 1, 2000); SET_PIN_VOLTAGE(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "VDDA_2.9V_CAM", PIN_REGULATOR, 1, 0, 2900000); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "OIS_VDD_2.8V", PIN_REGULATOR, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "OIS_VM_2.8V", PIN_REGULATOR, 1, 2500); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "VDDIO_1.8V_CAM", PIN_REGULATOR, 1, 0); SET_PIN_VOLTAGE(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "VDDD_1.2V_CAM", PIN_REGULATOR, 1, 0, 1000000); SET_PIN_VOLTAGE(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "VDDD_RET_1.0V_COMP", PIN_REGULATOR, 1, 0, 1000000); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "VDDIO_1.8V_COMP", PIN_REGULATOR, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "VDDA_1.8V_COMP", PIN_REGULATOR, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "VDDD_CORE_1.0V_COMP", PIN_REGULATOR, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "VDDD_NORET_0.9V_COMP", PIN_REGULATOR, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "VDDD_CORE_0.8V_COMP", PIN_REGULATOR, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "pin", PIN_FUNCTION, 2, 2000); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_comp_rst, "comp_rst high", PIN_OUTPUT, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_reset, "sen_rst high", PIN_OUTPUT, 1, 2000); /* Normal off */ SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "VDDAF_2.8V_CAM", PIN_REGULATOR, 0, 1000); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "pin", PIN_FUNCTION, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "pin", PIN_FUNCTION, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "pin", PIN_FUNCTION, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_reset, "sen_rst", PIN_OUTPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_comp_rst, "comp_rst low", PIN_OUTPUT, 0, 10); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "VDDD_CORE_0.8V_COMP", PIN_REGULATOR, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "VDDD_NORET_0.9V_COMP", PIN_REGULATOR, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "VDDD_CORE_1.0V_COMP", PIN_REGULATOR, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "VDDA_1.8V_COMP", PIN_REGULATOR, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "VDDIO_1.8V_COMP", PIN_REGULATOR, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "VDDD_RET_1.0V_COMP", PIN_REGULATOR, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "VDDA_2.9V_CAM", PIN_REGULATOR, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "VDDD_1.2V_CAM", PIN_REGULATOR, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "VDDIO_1.8V_CAM", PIN_REGULATOR, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "OIS_VDD_2.8V", PIN_REGULATOR, 0, 2000); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "OIS_VM_2.8V", PIN_REGULATOR, 0, 0); #ifdef CONFIG_COMPANION_STANDBY_USE /* STANDBY DISABLE */ SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_STANDBY_DISABLE, gpio_reset, "sen_rst low", PIN_OUTPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_STANDBY_DISABLE, gpio_none, "VDDAF_2.8V_CAM", PIN_REGULATOR, 1, 2000); SET_PIN_VOLTAGE(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_STANDBY_DISABLE, gpio_none, "VDDA_2.9V_CAM", PIN_REGULATOR, 1, 0, 2900000); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_STANDBY_DISABLE, gpio_none, "OIS_VDD_2.8V", PIN_REGULATOR, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_STANDBY_DISABLE, gpio_none, "OIS_VM_2.8V", PIN_REGULATOR, 1, 2500); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_STANDBY_DISABLE, gpio_none, "VDDIO_1.8V_CAM", PIN_REGULATOR, 1, 0); SET_PIN_VOLTAGE(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_STANDBY_DISABLE, gpio_none, "VDDD_1.2V_CAM", PIN_REGULATOR, 1, 0, 1000000); SET_PIN_VOLTAGE(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_STANDBY_DISABLE, gpio_none, "VDDD_RET_1.0V_COMP", PIN_REGULATOR, 1, 0, 1000000); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_STANDBY_DISABLE, gpio_none, "VDDA_1.8V_COMP", PIN_REGULATOR, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_STANDBY_DISABLE, gpio_none, "VDDD_CORE_1.0V_COMP", PIN_REGULATOR, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_STANDBY_DISABLE, gpio_none, "VDDD_NORET_0.9V_COMP", PIN_REGULATOR, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_STANDBY_DISABLE, gpio_none, "VDDD_CORE_0.8V_COMP", PIN_REGULATOR, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_STANDBY_DISABLE, gpio_none, "pin", PIN_FUNCTION, 2, 2000); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_STANDBY_DISABLE, gpio_comp_rst, "comp_rst high", PIN_OUTPUT, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_STANDBY_DISABLE, gpio_reset, "sen_rst high", PIN_OUTPUT, 1, 2000); /* STANDBY ENABLE */ SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_STANDBY_ENABLE, gpio_none, "VDDAF_2.8V_CAM", PIN_REGULATOR, 0, 1000); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_STANDBY_ENABLE, gpio_none, "pin", PIN_FUNCTION, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_STANDBY_ENABLE, gpio_none, "pin", PIN_FUNCTION, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_STANDBY_ENABLE, gpio_none, "pin", PIN_FUNCTION, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_STANDBY_ENABLE, gpio_reset, "sen_rst", PIN_OUTPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_STANDBY_ENABLE, gpio_comp_rst, "comp_rst low", PIN_OUTPUT, 0, 10); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_STANDBY_ENABLE, gpio_none, "VDDD_CORE_0.8V_COMP", PIN_REGULATOR, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_STANDBY_ENABLE, gpio_none, "VDDD_NORET_0.9V_COMP", PIN_REGULATOR, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_STANDBY_ENABLE, gpio_none, "VDDD_CORE_1.0V_COMP", PIN_REGULATOR, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_STANDBY_ENABLE, gpio_none, "VDDA_1.8V_COMP", PIN_REGULATOR, 0, 1000); SET_PIN_VOLTAGE(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_STANDBY_ENABLE, gpio_none, "VDDD_RET_1.0V_COMP", PIN_REGULATOR, 1, 0, 700000); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_STANDBY_ENABLE, gpio_none, "VDDA_2.9V_CAM", PIN_REGULATOR, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_STANDBY_ENABLE, gpio_none, "VDDD_1.2V_CAM", PIN_REGULATOR, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_STANDBY_ENABLE, gpio_none, "VDDIO_1.8V_CAM", PIN_REGULATOR, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_STANDBY_ENABLE, gpio_none, "OIS_VDD_2.8V", PIN_REGULATOR, 0, 2000); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_STANDBY_ENABLE, gpio_none, "OIS_VM_2.8V", PIN_REGULATOR, 0, 0); #endif #ifdef CONFIG_OIS_USE /* OIS_FACTORY - POWER ON */ SET_PIN(pdata, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_ON, gpio_none, "VDDAF_2.8V_CAM", PIN_REGULATOR, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_ON, gpio_none, "OIS_VDD_2.8V", PIN_REGULATOR, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_ON, gpio_none, "OIS_VM_2.8V", PIN_REGULATOR, 1, 2500); SET_PIN(pdata, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_ON, gpio_none, "VDDIO_1.8V_CAM", PIN_REGULATOR, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_ON, gpio_reset, "sen_rst high", PIN_OUTPUT, 1, 0); /* OIS_FACTORY - POWER OFF */ SET_PIN(pdata, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_OFF, gpio_reset, "sen_rst low", PIN_OUTPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_OFF, gpio_none, "VDDIO_1.8V_CAM", PIN_REGULATOR, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_OFF, gpio_none, "OIS_VDD_2.8V", PIN_REGULATOR, 0, 2000); SET_PIN(pdata, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_OFF, gpio_none, "OIS_VM_2.8V", PIN_REGULATOR, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_OFF, gpio_none, "VDDAF_2.8V_CAM", PIN_REGULATOR, 0, 0); #endif dev_info(dev, "%s X v4\n", __func__); return 0; }
static int w1_gpio_msm_probe(struct platform_device *pdev) { struct w1_bus_master *master; struct w1_gpio_msm_platform_data *pdata; struct input_dev *input; int err; int ret, irq; int temp_irq; printk(KERN_ERR "\nw1_gpio_msm_probe start\n"); if (of_have_populated_dt()) { err = w1_gpio_msm_probe_dt(pdev); if (err < 0) { dev_err(&pdev->dev, "Failed to parse DT\n"); return err; } } pdata = pdev->dev.platform_data; if (!pdata) { dev_err(&pdev->dev, "No configuration data\n"); return -ENXIO; } master = kzalloc(sizeof(struct w1_bus_master), GFP_KERNEL); if (!master) { dev_err(&pdev->dev, "Out of memory\n"); return -ENOMEM; } temp_irq = pdata->irq_gpio; if (temp_irq >= 0) { pr_info("%s: IRQ mode is enabled\n", __func__); irq = gpio_to_irq(pdata->irq_gpio); INIT_DELAYED_WORK(&master->w1_irqwork, w1_irqwork); schedule_delayed_work(&master->w1_irqwork, 10); master->irq_mode=true; } /* add for sending uevent */ input = input_allocate_device(); if (!input) { err = -ENODEV; goto free_master; /* need to change*/ } master->input = input; input_set_drvdata(input, master); input->name = "w1"; input->phys = "w1"; input->dev.parent = &pdev->dev; input->evbit[0] |= BIT_MASK(EV_SW); input_set_capability(input, EV_SW, SW_W1); input->open = hall_open; input->close = hall_close; /* Enable auto repeat feature of Linux input subsystem */ __set_bit(EV_REP, input->evbit); err = input_register_device(input); if(err) { dev_err(&pdev->dev, "input_register_device failed!\n"); goto free_input; } spin_lock_init(&w1_gpio_msm_lock); err = gpio_request(pdata->pin, "w1"); if (err) { dev_err(&pdev->dev, "gpio_request (pin) failed\n"); goto free_input; } if (gpio_is_valid(pdata->ext_pullup_enable_pin)) { err = gpio_request_one(pdata->ext_pullup_enable_pin, GPIOF_INIT_LOW, "w1 pullup"); if (err < 0) { dev_err(&pdev->dev, "gpio_request_one " "(ext_pullup_enable_pin) failed\n"); goto free_gpio; } } master->data = pdata; master->read_bit = w1_gpio_read_bit_val; master->touch_bit = w1_gpio_touch_bit; master->read_byte = w1_gpio_read_8; master->write_byte = w1_gpio_write_8; master->read_block = w1_gpio_read_block; master->write_block = w1_gpio_write_block; master->triplet = w1_gpio_triplet; master->reset_bus = w1_gpio_reset_bus; master->set_pullup = w1_gpio_set_pullup; if (pdata->is_open_drain) { gpio_direction_output(pdata->pin, 1); master->write_bit = w1_gpio_write_bit_val; } else { gpio_direction_input(pdata->pin); master->write_bit = w1_gpio_write_bit_dir; } err = w1_add_master_device(master); if (err) { dev_err(&pdev->dev, "w1_add_master device failed\n"); goto free_gpio_ext_pu; } if (master->irq_mode) { REQUEST_IRQ(irq, "w1-detect"); enable_irq_wake(irq); } if (pdata->enable_external_pullup) pdata->enable_external_pullup(1); if (gpio_is_valid(pdata->ext_pullup_enable_pin)) gpio_set_value_msm(pdata->ext_pullup_enable_pin, 1); platform_set_drvdata(pdev, master); return 0; free_gpio_ext_pu: if (gpio_is_valid(pdata->ext_pullup_enable_pin)) gpio_free(pdata->ext_pullup_enable_pin); free_gpio: gpio_free(pdata->pin); free_input: kfree(input); free_master: kfree(master); return err; }
static void __init __maybe_unused smdk5410_drd1_init(void) { /* Initialize DRD1 gpio */ if (gpio_request(EXYNOS5410_GPK2(4), "UDRD3_1_OVERCUR_U2")) { pr_err("failed to request UDRD3_1_OVERCUR_U2\n"); } else { s3c_gpio_cfgpin(EXYNOS5410_GPK2(4), (0x2 << 16)); s3c_gpio_setpull(EXYNOS5410_GPK2(4), S3C_GPIO_PULL_NONE); gpio_free(EXYNOS5410_GPK2(4)); } if (gpio_request(EXYNOS5410_GPK2(5), "UDRD3_1_OVERCUR_U3")) { pr_err("failed to request UDRD3_1_OVERCUR_U3\n"); } else { s3c_gpio_cfgpin(EXYNOS5410_GPK2(5), (0x2 << 20)); s3c_gpio_setpull(EXYNOS5410_GPK2(5), S3C_GPIO_PULL_NONE); gpio_free(EXYNOS5410_GPK2(5)); } if (gpio_request_one(EXYNOS5410_GPK2(6), GPIOF_OUT_INIT_LOW, "UDRD3_1_VBUSCTRL_U2")) { pr_err("failed to request UDRD3_1_VBUSCTRL_U2\n"); } else { s3c_gpio_setpull(EXYNOS5410_GPK2(6), S3C_GPIO_PULL_NONE); gpio_free(EXYNOS5410_GPK2(6)); } if (gpio_request_one(EXYNOS5410_GPK2(7), GPIOF_OUT_INIT_LOW, "UDRD3_1_VBUSCTRL_U3")) { pr_err("failed to request UDRD3_1_VBUSCTRL_U3\n"); } else { s3c_gpio_setpull(EXYNOS5410_GPK2(7), S3C_GPIO_PULL_NONE); gpio_free(EXYNOS5410_GPK2(7)); } #if defined(CONFIG_USB_EXYNOS5_USB3_DRD_CH1) if (gpio_request_one(SMDK5410_ID1_GPIO, GPIOF_IN, "UDRD3_1_ID")) { pr_err("failed to request UDRD3_1_ID\n"); smdk5410_drd_pdata.id_irq = -1; } else { s3c_gpio_cfgpin(SMDK5410_ID1_GPIO, S3C_GPIO_SFN(0xF)); s3c_gpio_setpull(SMDK5410_ID1_GPIO, S3C_GPIO_PULL_NONE); gpio_free(SMDK5410_ID1_GPIO); smdk5410_drd_pdata.id_irq = gpio_to_irq(SMDK5410_ID1_GPIO); } if (gpio_request_one(SMDK5410_VBUS1_GPIO, GPIOF_IN, "UDRD3_1_VBUS")) { pr_err("failed to request UDRD3_1_VBUS\n"); smdk5410_drd_pdata.vbus_irq = -1; } else { s3c_gpio_cfgpin(SMDK5410_VBUS1_GPIO, S3C_GPIO_SFN(0xF)); s3c_gpio_setpull(SMDK5410_VBUS1_GPIO, S3C_GPIO_PULL_NONE); gpio_free(SMDK5410_VBUS1_GPIO); smdk5410_drd_pdata.vbus_irq = gpio_to_irq(SMDK5410_VBUS1_GPIO); } smdk5410_drd_pdata.quirks = 0; #if !defined(CONFIG_USB_XHCI_EXYNOS) smdk5410_drd_pdata.quirks |= FORCE_RUN_PERIPHERAL; #endif #else smdk5410_drd_pdata.id_irq = -1; smdk5410_drd_pdata.vbus_irq = -1; smdk5410_drd_pdata.quirks = DUMMY_DRD; #endif exynos5_usb3_drd1_set_platdata(&smdk5410_drd_pdata); }
static int beagle_twl_gpio_setup(struct device *dev, unsigned gpio, unsigned ngpio) { int r, usb_pwr_level; if (omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_XM) { mmc[0].gpio_wp = -EINVAL; } else if ((omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_C1_3) || (omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_C4)) { omap_mux_init_gpio(23, OMAP_PIN_INPUT); mmc[0].gpio_wp = 23; } else { omap_mux_init_gpio(29, OMAP_PIN_INPUT); } /* gpio + 0 is "mmc0_cd" (input/IRQ) */ mmc[0].gpio_cd = gpio + 0; omap2_hsmmc_init(mmc); /* link regulators to MMC adapters */ beagle_vmmc1_supply.dev = mmc[0].dev; beagle_vsim_supply.dev = mmc[0].dev; /* * TWL4030_GPIO_MAX + 0 == ledA, EHCI nEN_USB_PWR (out, XM active * high / others active low) * DVI reset GPIO is different between beagle revisions */ if (omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_XM) { usb_pwr_level = GPIOF_OUT_INIT_HIGH; beagle_dvi_device.reset_gpio = 129; /* * gpio + 1 on Xm controls the TFP410's enable line (active low) * gpio + 2 control varies depending on the board rev as below: * P7/P8 revisions(prototype): Camera EN * A2+ revisions (production): LDO (DVI, serial, led blocks) */ r = gpio_request_one(gpio + 1, GPIOF_OUT_INIT_LOW, "nDVI_PWR_EN"); if (r) pr_err("%s: unable to configure nDVI_PWR_EN\n", __func__); r = gpio_request_one(gpio + 2, GPIOF_OUT_INIT_HIGH, "DVI_LDO_EN"); if (r) pr_err("%s: unable to configure DVI_LDO_EN\n", __func__); } else { usb_pwr_level = GPIOF_OUT_INIT_LOW; beagle_dvi_device.reset_gpio = 170; /* * REVISIT: need ehci-omap hooks for external VBUS * power switch and overcurrent detect */ if (gpio_request_one(gpio + 1, GPIOF_IN, "EHCI_nOC")) pr_err("%s: unable to configure EHCI_nOC\n", __func__); } gpio_request_one(gpio + TWL4030_GPIO_MAX, usb_pwr_level, "nEN_USB_PWR"); /* TWL4030_GPIO_MAX + 1 == ledB, PMU_STAT (out, active low LED) */ gpio_leds[2].gpio = gpio + TWL4030_GPIO_MAX + 1; return 0; }
/** * bu21013_probe() - initializes the i2c-client touchscreen driver * @client: i2c client structure pointer * @id: i2c device id pointer * * This function used to initializes the i2c-client touchscreen * driver and returns integer. */ static int bu21013_probe(struct i2c_client *client, const struct i2c_device_id *id) { const struct bu21013_platform_device *pdata = dev_get_platdata(&client->dev); struct bu21013_ts_data *bu21013_data; struct input_dev *in_dev; int error; if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { dev_err(&client->dev, "i2c smbus byte data not supported\n"); return -EIO; } if (!pdata) { pdata = bu21013_parse_dt(&client->dev); if (IS_ERR(pdata)) return PTR_ERR(pdata); } if (!gpio_is_valid(pdata->touch_pin)) { dev_err(&client->dev, "invalid touch_pin supplied\n"); return -EINVAL; } bu21013_data = kzalloc(sizeof(struct bu21013_ts_data), GFP_KERNEL); in_dev = input_allocate_device(); if (!bu21013_data || !in_dev) { dev_err(&client->dev, "device memory alloc failed\n"); error = -ENOMEM; goto err_free_mem; } bu21013_data->in_dev = in_dev; bu21013_data->chip = pdata; bu21013_data->client = client; bu21013_data->irq = gpio_to_irq(pdata->touch_pin); bu21013_data->regulator = regulator_get(&client->dev, "avdd"); if (IS_ERR(bu21013_data->regulator)) { dev_err(&client->dev, "regulator_get failed\n"); error = PTR_ERR(bu21013_data->regulator); goto err_free_mem; } error = regulator_enable(bu21013_data->regulator); if (error < 0) { dev_err(&client->dev, "regulator enable failed\n"); goto err_put_regulator; } bu21013_data->touch_stopped = false; init_waitqueue_head(&bu21013_data->wait); /* configure the gpio pins */ error = gpio_request_one(pdata->cs_pin, GPIOF_OUT_INIT_HIGH, "touchp_reset"); if (error < 0) { dev_err(&client->dev, "Unable to request gpio reset_pin\n"); goto err_disable_regulator; } /* configure the touch panel controller */ error = bu21013_init_chip(bu21013_data); if (error) { dev_err(&client->dev, "error in bu21013 config\n"); goto err_cs_disable; } /* register the device to input subsystem */ in_dev->name = DRIVER_TP; in_dev->id.bustype = BUS_I2C; in_dev->dev.parent = &client->dev; __set_bit(EV_SYN, in_dev->evbit); __set_bit(EV_KEY, in_dev->evbit); __set_bit(EV_ABS, in_dev->evbit); input_set_abs_params(in_dev, ABS_MT_POSITION_X, 0, pdata->touch_x_max, 0, 0); input_set_abs_params(in_dev, ABS_MT_POSITION_Y, 0, pdata->touch_y_max, 0, 0); input_set_drvdata(in_dev, bu21013_data); error = request_threaded_irq(bu21013_data->irq, NULL, bu21013_gpio_irq, IRQF_TRIGGER_FALLING | IRQF_SHARED | IRQF_ONESHOT, DRIVER_TP, bu21013_data); if (error) { dev_err(&client->dev, "request irq %d failed\n", bu21013_data->irq); goto err_cs_disable; } error = input_register_device(in_dev); if (error) { dev_err(&client->dev, "failed to register input device\n"); goto err_free_irq; } device_init_wakeup(&client->dev, pdata->wakeup); i2c_set_clientdata(client, bu21013_data); return 0; err_free_irq: bu21013_free_irq(bu21013_data); err_cs_disable: bu21013_cs_disable(bu21013_data); err_disable_regulator: regulator_disable(bu21013_data->regulator); err_put_regulator: regulator_put(bu21013_data->regulator); err_free_mem: input_free_device(in_dev); kfree(bu21013_data); return error; }
int s3cfb_backlight_on(struct platform_device *pdev) { int err; #if 0 //VLED_EN err = gpio_request(EXYNOS4_GPC1(2), "GPC1_2"); if (err) { printk(KERN_ERR "failed to request GPC1_2 for " "lcd power control\n"); return err; } gpio_direction_output(EXYNOS4_GPC1(2), 1); s3c_gpio_cfgpin(EXYNOS4_GPC1(2), S3C_GPIO_OUTPUT); gpio_free(EXYNOS4_GPC1(2)); mdelay(5); printk("(%s, %d): BK_LCD_EN\n", __FUNCTION__, __LINE__); #endif /*modify by cym 20121017 */ #if 0 //VLED_ON err = gpio_request(EXYNOS4_GPC0(1), "GPC0_1"); if (err) { printk(KERN_ERR "failed to request GPC0_1 for " "lcd power control\n"); return err; } gpio_direction_output(EXYNOS4_GPC0(1), 1); s3c_gpio_cfgpin(EXYNOS4_GPC0(1), S3C_GPIO_OUTPUT); gpio_free(EXYNOS4_GPC0(1)); mdelay(5); //err = gpio_request(EXYNOS4_GPD0(1), "GPD0_1"); if (err) { printk(KERN_ERR "failed to request GPD0 for " "lcd backlight control\n"); //return err; } #if !defined(CONFIG_BACKLIGHT_PWM) gpio_direction_output(EXYNOS4_GPD0(1), 1); gpio_free(EXYNOS4_GPD0(1)); #else gpio_direction_output(EXYNOS4_GPD0(1), 0); s3c_gpio_cfgpin(EXYNOS4_GPD0(1), EXYNOS4_GPD_0_1_TOUT_1); //gpio_free(EXYNOS4_GPD0(1)); #endif mdelay(5); //LED_EN18 err = gpio_request(EXYNOS4_GPC1(1), "GPC1_1"); if (err) { printk(KERN_ERR "failed to request GPC1_1 for " "lcd power control\n"); return err; } gpio_direction_output(EXYNOS4_GPC1(1), 1); s3c_gpio_cfgpin(EXYNOS4_GPC1(1), S3C_GPIO_OUTPUT); gpio_free(EXYNOS4_GPC1(1)); mdelay(5); #else //VLED_ON #if 0 err = gpio_request(EXYNOS4_GPC0(1), "GPC0_1"); if (err) { printk(KERN_ERR "failed to request GPC0_1 for " "lcd power control\n"); return err; } gpio_direction_output(EXYNOS4_GPC0(1), 1); s3c_gpio_cfgpin(EXYNOS4_GPC0(1), S3C_GPIO_OUTPUT); gpio_free(EXYNOS4_GPC0(1)); printk("(%s, %d): VLED_ON\n", __FUNCTION__, __LINE__); #endif //mdelay(5); mdelay(250); //PWM err = gpio_request(EXYNOS4_GPD0(1), "GPD0_1"); if (err) { printk(KERN_ERR "failed to request GPD0 for " "lcd backlight control\n"); //return err; } #if !defined(CONFIG_BACKLIGHT_PWM) gpio_direction_output(EXYNOS4_GPD0(1), 1); gpio_free(EXYNOS4_GPD0(1)); #else /* modify by cym 20130417 for TSC2007 TouchScreen */ //#ifdef CONFIG_TOUCHSCREEN_TSC2007 // gpio_direction_output(EXYNOS4_GPD0(1), 0); //#else gpio_direction_output(EXYNOS4_GPD0(1), 0); s3c_gpio_cfgpin(EXYNOS4_GPD0(1), EXYNOS4_GPD_0_1_TOUT_1); gpio_free(EXYNOS4_GPD0(1)); printk("(%s, %d): LCD_PWM_ON\n", __FUNCTION__, __LINE__); //#endif /* end modify */ #endif mdelay(5); #if 0 //TP1_EN err = gpio_request(EXYNOS4_GPL0(2), "TP1_EN"); if (err) { printk(KERN_ERR "failed to request TP1_EN for " "I2C control\n"); return err; } //because in uboot we enable,we want to enable it again we must disable it 20121109 //gpio_direction_output(EXYNOS4_GPL0(2), 0); 20130508 //mdelay(100); gpio_direction_output(EXYNOS4_GPL0(2), 1); s3c_gpio_cfgpin(EXYNOS4_GPL0(2), S3C_GPIO_OUTPUT); gpio_free(EXYNOS4_GPL0(2)); printk("(%s, %d): TP1_EN_ON\n", __FUNCTION__, __LINE__); mdelay(5); #endif #endif #if 1 err = gpio_request_one(EXYNOS4_GPC0(2), 0, "GPC0_2"); if (err) { printk(KERN_ERR "failed to request GPC0_2 for " "4.3 LCD control\n"); return err; } s3c_gpio_setpull(EXYNOS4_GPC0(2), S3C_GPIO_PULL_UP); //gpio_set_value(EXYNOS4_GPC0(2), 0); //mdelay(10); gpio_set_value(EXYNOS4_GPC0(2), 1); gpio_free(EXYNOS4_GPC0(2)); #endif #if 0 err = gpio_request_one(EXYNOS4_GPL1(1), 0, "GPL1_1"); if (err) { printk(KERN_ERR "failed to request GPL1_1 for " "4.3 LCD control\n"); return err; } s3c_gpio_setpull(EXYNOS4_GPL1(1), S3C_GPIO_PULL_UP); gpio_set_value(EXYNOS4_GPL1(1), 0); gpio_free(EXYNOS4_GPL1(1)); #endif /*end modify */ /* add by cym 20141125 */ err = gpio_request(EXYNOS4_GPC0(2), "VGA_EN"); if (err) { printk(KERN_ERR "failed to request VGA_EN\n"); return err; } gpio_direction_output(EXYNOS4_GPC0(2), 1); s3c_gpio_cfgpin(EXYNOS4_GPC0(2), S3C_GPIO_OUTPUT); gpio_free(EXYNOS4_GPC0(2)); printk("(%s, %d): VGA_EN_ON\n", __FUNCTION__, __LINE__); /* end add */ return 0; }
int fimc_is_companion_parse_dt(struct platform_device *pdev) { int ret = 0; struct exynos_platform_fimc_is_companion *pdata; struct device_node *dnode; struct device *dev; int gpio_comp_en = 0, gpio_comp_rst = 0; int gpio_none = 0; int gpio_reset = 0; int gpios_cam_en = -EINVAL; #ifdef CONFIG_OIS_USE int gpios_ois_en = 0; #endif BUG_ON(!pdev); BUG_ON(!pdev->dev.of_node); dev = &pdev->dev; dnode = dev->of_node; pdata = kzalloc(sizeof(struct exynos_platform_fimc_is_companion), 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_companion_iclk_cfg; pdata->iclk_on = exynos_fimc_is_companion_iclk_on; pdata->iclk_off = exynos_fimc_is_companion_iclk_off; pdata->mclk_on = exynos_fimc_is_companion_mclk_on; pdata->mclk_off = exynos_fimc_is_companion_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; } 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"); } else { gpio_request_one(gpio_comp_en, GPIOF_OUT_INIT_LOW, "CAM_GPIO_OUTPUT_LOW"); gpio_free(gpio_comp_en); } 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"); } else { gpio_request_one(gpio_comp_rst, GPIOF_OUT_INIT_LOW, "CAM_GPIO_OUTPUT_LOW"); gpio_free(gpio_comp_rst); } 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); } #else /* EXYNOS5430, EXYNOS5433 */ if (of_get_property(dnode, "gpios_cam_en", NULL)) { 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 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 #ifdef CONFIG_OIS_USE gpios_ois_en = of_get_named_gpio(dnode, "gpios_ois_en", 0); pdata->pin_ois_en = gpios_ois_en; if (!gpio_is_valid(gpios_ois_en)) { dev_err(dev, "failed to get ois en gpio\n"); } else { gpio_request_one(gpios_ois_en, GPIOF_OUT_INIT_LOW, "CAM_GPIO_OUTPUT_LOW"); gpio_free(gpios_ois_en); } #endif pdata->companion_use_pmic = of_property_read_bool(dnode, "companion_use_pmic"); if (!pdata->companion_use_pmic) { err("use_pmic not use(%d)", pdata->companion_use_pmic); } SET_PIN_INIT(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON); SET_PIN_INIT(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF); #ifdef CONFIG_SOC_EXYNOS5422 /* COMPANION - POWER ON */ SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpios_cam_en, NULL, PIN_OUTPUT, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "CAM_SEN_CORE_1.2V_AP", PIN_REGULATOR, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "CAM_AF_2.8V_AP", PIN_REGULATOR, 1, 2000); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "CAM_IO_1.8V_AP", PIN_REGULATOR, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "VDDA_1.8V_COMP", PIN_REGULATOR, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_comp_en, NULL, PIN_OUTPUT, 1, 150); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_comp_rst, NULL, PIN_OUTPUT, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "ch", PIN_FUNCTION, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_reset, NULL, PIN_OUTPUT, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "af", PIN_FUNCTION, 0, 0); /* COMPANION - POWER OFF */ SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "CAM_AF_2.8V_AP", PIN_REGULATOR, 0, 2000); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "off", PIN_FUNCTION, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_reset, NULL, PIN_OUTPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_comp_rst, NULL, PIN_OUTPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_comp_en, NULL, PIN_OUTPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "VDDA_1.8V_COMP", PIN_REGULATOR, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpios_cam_en, NULL, PIN_OUTPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "CAM_SEN_CORE_1.2V_AP", PIN_REGULATOR, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "CAM_IO_1.8V_AP", PIN_REGULATOR, 0, 0); #else /* CONFIG_SOC_EXYNOS5430, CONFIG_SOC_EXYNOS5433 */ if (gpio_is_valid(gpios_cam_en)) { SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpios_cam_en, NULL, PIN_OUTPUT, 1, 0); } else { SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "CAM_SEN_A2.8V_AP", PIN_REGULATOR, 1, 0); } SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "CAM_SEN_CORE_1.2V_AP", PIN_REGULATOR, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "CAM_AF_2.8V_AP", PIN_REGULATOR, 1, 2000); #ifdef CONFIG_OIS_USE SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpios_ois_en, NULL, PIN_OUTPUT, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "OIS_VM_2.8V", PIN_REGULATOR, 1, 0); #endif SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "CAM_IO_1.8V_AP", PIN_REGULATOR, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "VDDA_1.8V_COMP", PIN_REGULATOR, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_comp_en, NULL, PIN_OUTPUT, 1, 150); if (pdata->companion_use_pmic) { SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "VDD_MIPI_1.0V_COMP", PIN_REGULATOR, 1, 0); } SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_comp_rst, NULL, PIN_OUTPUT, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "ch", PIN_FUNCTION, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_none, "af", PIN_FUNCTION, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, gpio_reset, NULL, PIN_OUTPUT, 1, 0); /* BACK CAMERA - POWER OFF */ SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "CAM_AF_2.8V_AP", PIN_REGULATOR, 0, 2000); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "off", PIN_FUNCTION, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_reset, NULL, PIN_OUTPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_comp_rst, NULL, PIN_OUTPUT, 0, 0); if (pdata->companion_use_pmic) { SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "VDD_MIPI_1.0V_COMP", PIN_REGULATOR, 0, 0); } SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_comp_en, NULL, PIN_OUTPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "VDDA_1.8V_COMP", PIN_REGULATOR, 0, 0); if (gpio_is_valid(gpios_cam_en)) { SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpios_cam_en, NULL, PIN_OUTPUT, 0, 0); } else { SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "CAM_SEN_A2.8V_AP", PIN_REGULATOR, 0, 0); } SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "CAM_SEN_CORE_1.2V_AP", PIN_REGULATOR, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "CAM_IO_1.8V_AP", PIN_REGULATOR, 0, 0); #ifdef CONFIG_OIS_USE SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpios_ois_en, NULL, PIN_OUTPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, gpio_none, "OIS_VM_2.8V", PIN_REGULATOR, 0, 0); #endif #endif #ifdef CONFIG_OIS_USE /* OIS_FACTORY - POWER ON */ SET_PIN(pdata, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_ON, gpio_none, "CAM_AF_2.8V_AP", PIN_REGULATOR, 1, 2000); SET_PIN(pdata, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_ON, gpios_ois_en, NULL, PIN_OUTPUT, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_ON, gpio_none, "OIS_VM_2.8V", PIN_REGULATOR, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_ON, gpio_none, "CAM_IO_1.8V_AP", PIN_REGULATOR, 1, 0); SET_PIN(pdata, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_ON, gpio_reset, NULL, PIN_OUTPUT, 1, 0); /* OIS_FACTORY - POWER OFF */ SET_PIN(pdata, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_OFF, gpio_none, "CAM_AF_2.8V_AP", PIN_REGULATOR, 0, 2000); SET_PIN(pdata, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_OFF, gpio_reset, NULL, PIN_OUTPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_OFF, gpio_none, "CAM_IO_1.8V_AP", PIN_REGULATOR, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_OFF, gpios_ois_en, NULL, PIN_OUTPUT, 0, 0); SET_PIN(pdata, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_OFF, gpio_none, "OIS_VM_2.8V", PIN_REGULATOR, 0, 0); #endif 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->pinctrl, pdata->pin_ctrls); if (ret < 0) { err("fimc_is_get_pin_lookup_state is fail"); goto p_err; } } return ret; p_err: kfree(pdata); return ret; }
int s3cfb_backlight_off(struct platform_device *pdev) { int err; //err = gpio_request(EXYNOS4_GPD0(1), "GPD0"); //if (err) { // printk(KERN_ERR "failed to request GPD0 for " // "lcd backlight control\n"); // return err; //} /* modify by cym 20121017 */ #if 0 gpio_direction_output(EXYNOS4_GPD0(1), 0); //gpio_free(EXYNOS4_GPD0(1)); //LED_EN18 err = gpio_request(EXYNOS4_GPC1(1), "GPC1_1"); if (err) { printk(KERN_ERR "failed to request GPC1_1 for " "lcd power control\n"); return err; } gpio_direction_output(EXYNOS4_GPC1(1), 0); s3c_gpio_cfgpin(EXYNOS4_GPC1(1), S3C_GPIO_OUTPUT); gpio_free(EXYNOS4_GPC1(1)); //VLED_EN err = gpio_request(EXYNOS4_GPC1(2), "GPC1_2"); if (err) { printk(KERN_ERR "failed to request GPC1_2 for " "lcd power control\n"); return err; } gpio_direction_output(EXYNOS4_GPC1(2), 0); s3c_gpio_cfgpin(EXYNOS4_GPC1(2), S3C_GPIO_OUTPUT); gpio_free(EXYNOS4_GPC1(2)); //VLED_ON err = gpio_request(EXYNOS4_GPC0(1), "GPC0_1"); if (err) { printk(KERN_ERR "failed to request GPC0_1 for " "lcd power control\n"); return err; } gpio_direction_output(EXYNOS4_GPC0(1), 0); s3c_gpio_cfgpin(EXYNOS4_GPC0(1), S3C_GPIO_OUTPUT); gpio_free(EXYNOS4_GPC0(1)); #else //gpio_direction_output(EXYNOS4_GPD0(1), 0); //gpio_free(EXYNOS4_GPD0(1)); //printk("(%s, %d): LCD_PWM_OFF\n", __FUNCTION__, __LINE__); #if 0 //TP1_EN err = gpio_request(EXYNOS4_GPL0(2), "TP1_EN"); if (err) { printk(KERN_ERR "failed to request TP1_EN for " "I2C control\n"); return err; } gpio_direction_output(EXYNOS4_GPL0(2), 0); s3c_gpio_cfgpin(EXYNOS4_GPL0(2), S3C_GPIO_OUTPUT); gpio_free(EXYNOS4_GPL0(2)); mdelay(5); printk("(%s, %d): TP1_EN_OFF\n", __FUNCTION__, __LINE__); #endif //VLED_ON #if 0 err = gpio_request(EXYNOS4_GPC0(1), "GPC0_1"); if (err) { printk(KERN_ERR "failed to request GPC0_1 for " "lcd power control\n"); return err; } gpio_direction_output(EXYNOS4_GPC0(1), 0); s3c_gpio_cfgpin(EXYNOS4_GPC0(1), S3C_GPIO_OUTPUT); gpio_free(EXYNOS4_GPC0(1)); printk("(%s, %d): VLED_OFF\n", __FUNCTION__, __LINE__); #endif #endif /* end modify */ /* add by cym 20150120 */ #if 1 err = gpio_request(EXYNOS4_GPD0(1), "GPD0_1"); if (err) { printk(KERN_ERR "failed to request GPD0 for " "lcd backlight control\n"); //return err; } gpio_direction_output(EXYNOS4_GPD0(1), 0); s3c_gpio_cfgpin(EXYNOS4_GPD0(1), S3C_GPIO_OUTPUT); gpio_free(EXYNOS4_GPD0(1)); printk("(%s, %d): LCD_PWM_OFF\n", __FUNCTION__, __LINE__); #endif //LVDS_PWDN err = gpio_request(EXYNOS4_GPL1(0), "GPL1_0"); if (err) { printk(KERN_ERR "failed to request GPL1 for " "lcd power control\n"); return err; } gpio_direction_output(EXYNOS4_GPL1(0), 0); s3c_gpio_cfgpin(EXYNOS4_GPL1(0), S3C_GPIO_OUTPUT); gpio_free(EXYNOS4_GPL1(0)); #if 0 err = gpio_request_one(EXYNOS4_GPL1(1), 0, "GPL1_1"); if (err) { printk(KERN_ERR "failed to request GPL1_1 for " "4.3 LCD control\n"); return err; } s3c_gpio_setpull(EXYNOS4_GPL1(1), S3C_GPIO_PULL_UP); gpio_set_value(EXYNOS4_GPL1(1), 1); gpio_free(EXYNOS4_GPL1(1)); #endif /* add by cym 20141125 */ err = gpio_request(EXYNOS4_GPC0(2), "VGA_EN"); if (err) { printk(KERN_ERR "failed to request VGA_EN\n"); return err; } gpio_direction_output(EXYNOS4_GPC0(2), 0); s3c_gpio_cfgpin(EXYNOS4_GPC0(2), S3C_GPIO_OUTPUT); gpio_free(EXYNOS4_GPC0(2)); printk("(%s, %d): VGA_EN_OFF\n", __FUNCTION__, __LINE__); /* end add */ /* add by cym 20150120 */ err = gpio_request(EXYNOS4_GPL0(4), "BK_VDD_EN"); if (err) { printk(KERN_ERR "failed to request BK_VDD_EN for\n"); return err; } gpio_direction_output(EXYNOS4_GPL0(4), 0); s3c_gpio_cfgpin(EXYNOS4_GPL0(4), S3C_GPIO_OUTPUT); gpio_free(EXYNOS4_GPL0(4)); printk("(%s, %d): BK_VDD_OFF\n", __FUNCTION__, __LINE__); /* end add */ return 0; }
static void __init eva_init(void) { struct platform_device *usb = NULL; regulator_register_always_on(0, "fixed-3.3V", fixed3v3_power_consumers, ARRAY_SIZE(fixed3v3_power_consumers), 3300000); r8a7740_pinmux_init(); r8a7740_meram_workaround(); /* SCIFA1 */ gpio_request(GPIO_FN_SCIFA1_RXD, NULL); gpio_request(GPIO_FN_SCIFA1_TXD, NULL); /* LCDC0 */ gpio_request(GPIO_FN_LCDC0_SELECT, NULL); gpio_request(GPIO_FN_LCD0_D0, NULL); gpio_request(GPIO_FN_LCD0_D1, NULL); gpio_request(GPIO_FN_LCD0_D2, NULL); gpio_request(GPIO_FN_LCD0_D3, NULL); gpio_request(GPIO_FN_LCD0_D4, NULL); gpio_request(GPIO_FN_LCD0_D5, NULL); gpio_request(GPIO_FN_LCD0_D6, NULL); gpio_request(GPIO_FN_LCD0_D7, NULL); gpio_request(GPIO_FN_LCD0_D8, NULL); gpio_request(GPIO_FN_LCD0_D9, NULL); gpio_request(GPIO_FN_LCD0_D10, NULL); gpio_request(GPIO_FN_LCD0_D11, NULL); gpio_request(GPIO_FN_LCD0_D12, NULL); gpio_request(GPIO_FN_LCD0_D13, NULL); gpio_request(GPIO_FN_LCD0_D14, NULL); gpio_request(GPIO_FN_LCD0_D15, NULL); gpio_request(GPIO_FN_LCD0_D16, NULL); gpio_request(GPIO_FN_LCD0_D17, NULL); gpio_request(GPIO_FN_LCD0_D18_PORT40, NULL); gpio_request(GPIO_FN_LCD0_D19_PORT4, NULL); gpio_request(GPIO_FN_LCD0_D20_PORT3, NULL); gpio_request(GPIO_FN_LCD0_D21_PORT2, NULL); gpio_request(GPIO_FN_LCD0_D22_PORT0, NULL); gpio_request(GPIO_FN_LCD0_D23_PORT1, NULL); gpio_request(GPIO_FN_LCD0_DCK, NULL); gpio_request(GPIO_FN_LCD0_VSYN, NULL); gpio_request(GPIO_FN_LCD0_HSYN, NULL); gpio_request(GPIO_FN_LCD0_DISP, NULL); gpio_request(GPIO_FN_LCD0_LCLK_PORT165, NULL); gpio_request_one(GPIO_PORT61, GPIOF_OUT_INIT_HIGH, NULL); /* LCDDON */ gpio_request_one(GPIO_PORT202, GPIOF_OUT_INIT_LOW, NULL); /* LCD0_LED_CONT */ /* Touchscreen */ gpio_request(GPIO_FN_IRQ10, NULL); /* TP_INT */ gpio_request_one(GPIO_PORT166, GPIOF_OUT_INIT_HIGH, NULL); /* TP_RST_B */ /* GETHER */ gpio_request(GPIO_FN_ET_CRS, NULL); gpio_request(GPIO_FN_ET_MDC, NULL); gpio_request(GPIO_FN_ET_MDIO, NULL); gpio_request(GPIO_FN_ET_TX_ER, NULL); gpio_request(GPIO_FN_ET_RX_ER, NULL); gpio_request(GPIO_FN_ET_ERXD0, NULL); gpio_request(GPIO_FN_ET_ERXD1, NULL); gpio_request(GPIO_FN_ET_ERXD2, NULL); gpio_request(GPIO_FN_ET_ERXD3, NULL); gpio_request(GPIO_FN_ET_TX_CLK, NULL); gpio_request(GPIO_FN_ET_TX_EN, NULL); gpio_request(GPIO_FN_ET_ETXD0, NULL); gpio_request(GPIO_FN_ET_ETXD1, NULL); gpio_request(GPIO_FN_ET_ETXD2, NULL); gpio_request(GPIO_FN_ET_ETXD3, NULL); gpio_request(GPIO_FN_ET_PHY_INT, NULL); gpio_request(GPIO_FN_ET_COL, NULL); gpio_request(GPIO_FN_ET_RX_DV, NULL); gpio_request(GPIO_FN_ET_RX_CLK, NULL); gpio_request_one(GPIO_PORT18, GPIOF_OUT_INIT_HIGH, NULL); /* PHY_RST */ /* USB */ gpio_request_one(GPIO_PORT159, GPIOF_IN, NULL); /* USB_DEVICE_MODE */ if (gpio_get_value(GPIO_PORT159)) { /* USB Host */ } else { /* USB Func */ /* * A1 chip has 2 IRQ7 pin and it was controled by MSEL register. * OTOH, usbhs interrupt needs its value (HI/LOW) to decide * USB connection/disconnection (usbhsf_get_vbus()). * This means we needs to select GPIO_FN_IRQ7_PORT209 first, * and select GPIO_PORT209 here */ gpio_request(GPIO_FN_IRQ7_PORT209, NULL); gpio_request_one(GPIO_PORT209, GPIOF_IN, NULL); platform_device_register(&usbhsf_device); usb = &usbhsf_device; } /* SDHI0 */ gpio_request(GPIO_FN_SDHI0_CMD, NULL); gpio_request(GPIO_FN_SDHI0_CLK, NULL); gpio_request(GPIO_FN_SDHI0_D0, NULL); gpio_request(GPIO_FN_SDHI0_D1, NULL); gpio_request(GPIO_FN_SDHI0_D2, NULL); gpio_request(GPIO_FN_SDHI0_D3, NULL); gpio_request(GPIO_FN_SDHI0_WP, NULL); gpio_request_one(GPIO_PORT17, GPIOF_OUT_INIT_LOW, NULL); /* SDHI0_18/33_B */ gpio_request_one(GPIO_PORT74, GPIOF_OUT_INIT_HIGH, NULL); /* SDHI0_PON */ gpio_request_one(GPIO_PORT75, GPIOF_OUT_INIT_HIGH, NULL); /* SDSLOT1_PON */ /* we can use GPIO_FN_IRQ31_PORT167 here for SDHI0 CD irq */ /* * MMCIF * * Here doesn't care SW1.4 status, * since CON2 is not mounted. */ gpio_request(GPIO_FN_MMC1_CLK_PORT103, NULL); gpio_request(GPIO_FN_MMC1_CMD_PORT104, NULL); gpio_request(GPIO_FN_MMC1_D0_PORT149, NULL); gpio_request(GPIO_FN_MMC1_D1_PORT148, NULL); gpio_request(GPIO_FN_MMC1_D2_PORT147, NULL); gpio_request(GPIO_FN_MMC1_D3_PORT146, NULL); gpio_request(GPIO_FN_MMC1_D4_PORT145, NULL); gpio_request(GPIO_FN_MMC1_D5_PORT144, NULL); gpio_request(GPIO_FN_MMC1_D6_PORT143, NULL); gpio_request(GPIO_FN_MMC1_D7_PORT142, NULL); /* CEU0 */ gpio_request(GPIO_FN_VIO0_D7, NULL); gpio_request(GPIO_FN_VIO0_D6, NULL); gpio_request(GPIO_FN_VIO0_D5, NULL); gpio_request(GPIO_FN_VIO0_D4, NULL); gpio_request(GPIO_FN_VIO0_D3, NULL); gpio_request(GPIO_FN_VIO0_D2, NULL); gpio_request(GPIO_FN_VIO0_D1, NULL); gpio_request(GPIO_FN_VIO0_D0, NULL); gpio_request(GPIO_FN_VIO0_CLK, NULL); gpio_request(GPIO_FN_VIO0_HD, NULL); gpio_request(GPIO_FN_VIO0_VD, NULL); gpio_request(GPIO_FN_VIO0_FIELD, NULL); gpio_request(GPIO_FN_VIO_CKO, NULL); /* CON1/CON15 Camera */ gpio_request_one(GPIO_PORT173, GPIOF_OUT_INIT_LOW, NULL); /* STANDBY */ gpio_request_one(GPIO_PORT172, GPIOF_OUT_INIT_HIGH, NULL); /* RST */ /* see mt9t111_power() */ gpio_request_one(GPIO_PORT158, GPIOF_OUT_INIT_LOW, NULL); /* CAM_PON */ /* FSI-WM8978 */ gpio_request(GPIO_FN_FSIAIBT, NULL); gpio_request(GPIO_FN_FSIAILR, NULL); gpio_request(GPIO_FN_FSIAOMC, NULL); gpio_request(GPIO_FN_FSIAOSLD, NULL); gpio_request(GPIO_FN_FSIAISLD_PORT5, NULL); gpio_request(GPIO_PORT7, NULL); gpio_request(GPIO_PORT8, NULL); gpio_direction_none(GPIO_PORT7CR); /* FSIAOBT needs no direction */ gpio_direction_none(GPIO_PORT8CR); /* FSIAOLR needs no direction */ /* FSI-HDMI */ gpio_request(GPIO_FN_FSIBCK, NULL); /* HDMI */ gpio_request(GPIO_FN_HDMI_HPD, NULL); gpio_request(GPIO_FN_HDMI_CEC, NULL); /* * CAUTION * * DBGMD/LCDC0/FSIA MUX * DBGMD_SELECT_B should be set after setting PFC Function. */ gpio_request_one(GPIO_PORT176, GPIOF_OUT_INIT_HIGH, NULL); /* * We can switch CON8/CON14 by SW1.5, * but it needs after DBGMD_SELECT_B */ gpio_request_one(GPIO_PORT6, GPIOF_IN, NULL); if (gpio_get_value(GPIO_PORT6)) { /* CON14 enable */ } else { /* CON8 (SDHI1) enable */ gpio_request(GPIO_FN_SDHI1_CLK, NULL); gpio_request(GPIO_FN_SDHI1_CMD, NULL); gpio_request(GPIO_FN_SDHI1_D0, NULL); gpio_request(GPIO_FN_SDHI1_D1, NULL); gpio_request(GPIO_FN_SDHI1_D2, NULL); gpio_request(GPIO_FN_SDHI1_D3, NULL); gpio_request(GPIO_FN_SDHI1_CD, NULL); gpio_request(GPIO_FN_SDHI1_WP, NULL); /* SDSLOT2_PON */ gpio_request_one(GPIO_PORT16, GPIOF_OUT_INIT_HIGH, NULL); platform_device_register(&sdhi1_device); } #ifdef CONFIG_CACHE_L2X0 /* Early BRESP enable, Shared attribute override enable, 32K*8way */ l2x0_init(IOMEM(0xf0002000), 0x40440000, 0x82000fff); #endif i2c_register_board_info(0, i2c0_devices, ARRAY_SIZE(i2c0_devices)); i2c_register_board_info(2, i2c2_devices, ARRAY_SIZE(i2c2_devices)); r8a7740_add_standard_devices(); platform_add_devices(eva_devices, ARRAY_SIZE(eva_devices)); rmobile_add_device_to_domain("A4LC", &lcdc0_device); rmobile_add_device_to_domain("A4LC", &hdmi_lcdc_device); if (usb) rmobile_add_device_to_domain("A3SP", usb); r8a7740_pm_init(); }
static int earjack_debugger_probe(struct platform_device *pdev) { int ret = 0; struct earjack_debugger_device *adev; struct earjack_debugger_platform_data *pdata = pdev->dev.platform_data; if (!pdata) { pr_err("%s: no pdata\n", __func__); return -ENODEV; } adev = kzalloc(sizeof(struct earjack_debugger_device), GFP_KERNEL); if (!adev) { pr_err("%s: no memory\n", __func__); return -ENOMEM; } adev->gpio = pdata->gpio_trigger; adev->irq = gpio_to_irq(pdata->gpio_trigger); adev->set_uart_console = pdata->set_uart_console; if (adev->set_uart_console) adev->set_uart_console(0); platform_set_drvdata(pdev, adev); ret = gpio_request_one(adev->gpio, GPIOF_IN, "gpio_earjack_debugger"); if (ret < 0) { pr_err("%s: failed to request gpio %d\n", __func__, adev->gpio); goto err_gpio_request; } INIT_DELAYED_WORK(&adev->work, set_console_work); ret = request_threaded_irq(adev->irq, NULL, earjack_debugger_irq_handler, IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING, "earjack_debugger_trigger", adev); if (ret < 0) { pr_err("%s: failed to request irq\n", __func__); goto err_request_irq; } if (earjack_debugger_detected(adev)) { if (adev->set_uart_console) { mako_uart_initialized = true; earjack_debugger_set_gpiomux_uart(1); adev->set_uart_console(1); } } else { earjack_debugger_set_gpiomux_uart(0); } pr_info("earjack debugger probed\n"); return ret; err_request_irq: gpio_free(adev->gpio); err_gpio_request: kfree(adev); return ret; }
static int em28xx_dvb_init(struct em28xx *dev) { int result = 0, mfe_shared = 0; struct em28xx_dvb *dvb; if (!dev->board.has_dvb) { /* This device does not support the extension */ printk(KERN_INFO "em28xx_dvb: This device does not support the extension\n"); return 0; } dvb = kzalloc(sizeof(struct em28xx_dvb), GFP_KERNEL); if (dvb == NULL) { em28xx_info("em28xx_dvb: memory allocation failed\n"); return -ENOMEM; } dev->dvb = dvb; dvb->fe[0] = dvb->fe[1] = NULL; mutex_lock(&dev->lock); em28xx_set_mode(dev, EM28XX_DIGITAL_MODE); /* init frontend */ switch (dev->model) { case EM2874_BOARD_LEADERSHIP_ISDBT: dvb->fe[0] = dvb_attach(s921_attach, &sharp_isdbt, &dev->i2c_adap[dev->def_i2c_bus]); if (!dvb->fe[0]) { result = -EINVAL; goto out_free; } break; case EM2883_BOARD_HAUPPAUGE_WINTV_HVR_850: case EM2883_BOARD_HAUPPAUGE_WINTV_HVR_950: case EM2880_BOARD_PINNACLE_PCTV_HD_PRO: case EM2880_BOARD_AMD_ATI_TV_WONDER_HD_600: dvb->fe[0] = dvb_attach(lgdt330x_attach, &em2880_lgdt3303_dev, &dev->i2c_adap[dev->def_i2c_bus]); if (em28xx_attach_xc3028(0x61, dev) < 0) { result = -EINVAL; goto out_free; } break; case EM2880_BOARD_KWORLD_DVB_310U: dvb->fe[0] = dvb_attach(zl10353_attach, &em28xx_zl10353_with_xc3028, &dev->i2c_adap[dev->def_i2c_bus]); if (em28xx_attach_xc3028(0x61, dev) < 0) { result = -EINVAL; goto out_free; } break; case EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900: case EM2882_BOARD_TERRATEC_HYBRID_XS: case EM2880_BOARD_EMPIRE_DUAL_TV: dvb->fe[0] = dvb_attach(zl10353_attach, &em28xx_zl10353_xc3028_no_i2c_gate, &dev->i2c_adap[dev->def_i2c_bus]); if (em28xx_attach_xc3028(0x61, dev) < 0) { result = -EINVAL; goto out_free; } break; case EM2880_BOARD_TERRATEC_HYBRID_XS: case EM2880_BOARD_TERRATEC_HYBRID_XS_FR: case EM2881_BOARD_PINNACLE_HYBRID_PRO: case EM2882_BOARD_DIKOM_DK300: case EM2882_BOARD_KWORLD_VS_DVBT: dvb->fe[0] = dvb_attach(zl10353_attach, &em28xx_zl10353_xc3028_no_i2c_gate, &dev->i2c_adap[dev->def_i2c_bus]); if (dvb->fe[0] == NULL) { /* This board could have either a zl10353 or a mt352. If the chip id isn't for zl10353, try mt352 */ dvb->fe[0] = dvb_attach(mt352_attach, &terratec_xs_mt352_cfg, &dev->i2c_adap[dev->def_i2c_bus]); } if (em28xx_attach_xc3028(0x61, dev) < 0) { result = -EINVAL; goto out_free; } break; case EM2870_BOARD_KWORLD_355U: dvb->fe[0] = dvb_attach(zl10353_attach, &em28xx_zl10353_no_i2c_gate_dev, &dev->i2c_adap[dev->def_i2c_bus]); if (dvb->fe[0] != NULL) dvb_attach(qt1010_attach, dvb->fe[0], &dev->i2c_adap[dev->def_i2c_bus], &em28xx_qt1010_config); break; case EM2883_BOARD_KWORLD_HYBRID_330U: case EM2882_BOARD_EVGA_INDTUBE: dvb->fe[0] = dvb_attach(s5h1409_attach, &em28xx_s5h1409_with_xc3028, &dev->i2c_adap[dev->def_i2c_bus]); if (em28xx_attach_xc3028(0x61, dev) < 0) { result = -EINVAL; goto out_free; } break; case EM2882_BOARD_KWORLD_ATSC_315U: dvb->fe[0] = dvb_attach(lgdt330x_attach, &em2880_lgdt3303_dev, &dev->i2c_adap[dev->def_i2c_bus]); if (dvb->fe[0] != NULL) { if (!dvb_attach(simple_tuner_attach, dvb->fe[0], &dev->i2c_adap[dev->def_i2c_bus], 0x61, TUNER_THOMSON_DTT761X)) { result = -EINVAL; goto out_free; } } break; case EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900_R2: case EM2882_BOARD_PINNACLE_HYBRID_PRO_330E: dvb->fe[0] = dvb_attach(drxd_attach, &em28xx_drxd, NULL, &dev->i2c_adap[dev->def_i2c_bus], &dev->udev->dev); if (em28xx_attach_xc3028(0x61, dev) < 0) { result = -EINVAL; goto out_free; } break; case EM2870_BOARD_REDDO_DVB_C_USB_BOX: /* Philips CU1216L NIM (Philips TDA10023 + Infineon TUA6034) */ dvb->fe[0] = dvb_attach(tda10023_attach, &em28xx_tda10023_config, &dev->i2c_adap[dev->def_i2c_bus], 0x48); if (dvb->fe[0]) { if (!dvb_attach(simple_tuner_attach, dvb->fe[0], &dev->i2c_adap[dev->def_i2c_bus], 0x60, TUNER_PHILIPS_CU1216L)) { result = -EINVAL; goto out_free; } } break; case EM2870_BOARD_KWORLD_A340: dvb->fe[0] = dvb_attach(lgdt3305_attach, &em2870_lgdt3304_dev, &dev->i2c_adap[dev->def_i2c_bus]); if (dvb->fe[0] != NULL) dvb_attach(tda18271_attach, dvb->fe[0], 0x60, &dev->i2c_adap[dev->def_i2c_bus], &kworld_a340_config); break; case EM28174_BOARD_PCTV_290E: /* set default GPIO0 for LNA, used if GPIOLIB is undefined */ dvb->lna_gpio = CXD2820R_GPIO_E | CXD2820R_GPIO_O | CXD2820R_GPIO_L; dvb->fe[0] = dvb_attach(cxd2820r_attach, &em28xx_cxd2820r_config, &dev->i2c_adap[dev->def_i2c_bus], &dvb->lna_gpio); if (dvb->fe[0]) { /* FE 0 attach tuner */ if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60, &dev->i2c_adap[dev->def_i2c_bus], &em28xx_cxd2820r_tda18271_config)) { dvb_frontend_detach(dvb->fe[0]); result = -EINVAL; goto out_free; } #ifdef CONFIG_GPIOLIB /* enable LNA for DVB-T, DVB-T2 and DVB-C */ result = gpio_request_one(dvb->lna_gpio, GPIOF_OUT_INIT_LOW, NULL); if (result) em28xx_errdev("gpio request failed %d\n", result); else gpio_free(dvb->lna_gpio); result = 0; /* continue even set LNA fails */ #endif dvb->fe[0]->ops.set_lna = em28xx_pctv_290e_set_lna; } break; case EM2884_BOARD_HAUPPAUGE_WINTV_HVR_930C: { struct xc5000_config cfg; hauppauge_hvr930c_init(dev); dvb->fe[0] = dvb_attach(drxk_attach, &hauppauge_930c_drxk, &dev->i2c_adap[dev->def_i2c_bus]); if (!dvb->fe[0]) { result = -EINVAL; goto out_free; } /* FIXME: do we need a pll semaphore? */ dvb->fe[0]->sec_priv = dvb; sema_init(&dvb->pll_mutex, 1); dvb->gate_ctrl = dvb->fe[0]->ops.i2c_gate_ctrl; dvb->fe[0]->ops.i2c_gate_ctrl = drxk_gate_ctrl; /* Attach xc5000 */ memset(&cfg, 0, sizeof(cfg)); cfg.i2c_address = 0x61; cfg.if_khz = 4000; if (dvb->fe[0]->ops.i2c_gate_ctrl) dvb->fe[0]->ops.i2c_gate_ctrl(dvb->fe[0], 1); if (!dvb_attach(xc5000_attach, dvb->fe[0], &dev->i2c_adap[dev->def_i2c_bus], &cfg)) { result = -EINVAL; goto out_free; } if (dvb->fe[0]->ops.i2c_gate_ctrl) dvb->fe[0]->ops.i2c_gate_ctrl(dvb->fe[0], 0); break; } case EM2884_BOARD_TERRATEC_H5: terratec_h5_init(dev); dvb->fe[0] = dvb_attach(drxk_attach, &terratec_h5_drxk, &dev->i2c_adap[dev->def_i2c_bus]); if (!dvb->fe[0]) { result = -EINVAL; goto out_free; } /* FIXME: do we need a pll semaphore? */ dvb->fe[0]->sec_priv = dvb; sema_init(&dvb->pll_mutex, 1); dvb->gate_ctrl = dvb->fe[0]->ops.i2c_gate_ctrl; dvb->fe[0]->ops.i2c_gate_ctrl = drxk_gate_ctrl; /* Attach tda18271 to DVB-C frontend */ if (dvb->fe[0]->ops.i2c_gate_ctrl) dvb->fe[0]->ops.i2c_gate_ctrl(dvb->fe[0], 1); if (!dvb_attach(tda18271c2dd_attach, dvb->fe[0], &dev->i2c_adap[dev->def_i2c_bus], 0x60)) { result = -EINVAL; goto out_free; } if (dvb->fe[0]->ops.i2c_gate_ctrl) dvb->fe[0]->ops.i2c_gate_ctrl(dvb->fe[0], 0); break; case EM2884_BOARD_C3TECH_DIGITAL_DUO: dvb->fe[0] = dvb_attach(mb86a20s_attach, &c3tech_duo_mb86a20s_config, &dev->i2c_adap[dev->def_i2c_bus]); if (dvb->fe[0] != NULL) dvb_attach(tda18271_attach, dvb->fe[0], 0x60, &dev->i2c_adap[dev->def_i2c_bus], &c3tech_duo_tda18271_config); break; case EM28174_BOARD_PCTV_460E: /* attach demod */ dvb->fe[0] = dvb_attach(tda10071_attach, &em28xx_tda10071_config, &dev->i2c_adap[dev->def_i2c_bus]); /* attach SEC */ if (dvb->fe[0]) dvb_attach(a8293_attach, dvb->fe[0], &dev->i2c_adap[dev->def_i2c_bus], &em28xx_a8293_config); break; case EM2874_BOARD_DELOCK_61959: case EM2874_BOARD_MAXMEDIA_UB425_TC: /* attach demodulator */ dvb->fe[0] = dvb_attach(drxk_attach, &maxmedia_ub425_tc_drxk, &dev->i2c_adap[dev->def_i2c_bus]); if (dvb->fe[0]) { /* disable I2C-gate */ dvb->fe[0]->ops.i2c_gate_ctrl = NULL; /* attach tuner */ if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60, &dev->i2c_adap[dev->def_i2c_bus], &em28xx_cxd2820r_tda18271_config)) { dvb_frontend_detach(dvb->fe[0]); result = -EINVAL; goto out_free; } } break; case EM2884_BOARD_PCTV_510E: case EM2884_BOARD_PCTV_520E: pctv_520e_init(dev); /* attach demodulator */ dvb->fe[0] = dvb_attach(drxk_attach, &pctv_520e_drxk, &dev->i2c_adap[dev->def_i2c_bus]); if (dvb->fe[0]) { /* attach tuner */ if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60, &dev->i2c_adap[dev->def_i2c_bus], &em28xx_cxd2820r_tda18271_config)) { dvb_frontend_detach(dvb->fe[0]); result = -EINVAL; goto out_free; } } break; case EM2884_BOARD_CINERGY_HTC_STICK: terratec_htc_stick_init(dev); /* attach demodulator */ dvb->fe[0] = dvb_attach(drxk_attach, &terratec_htc_stick_drxk, &dev->i2c_adap[dev->def_i2c_bus]); if (!dvb->fe[0]) { result = -EINVAL; goto out_free; } /* Attach the demodulator. */ if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60, &dev->i2c_adap[dev->def_i2c_bus], &em28xx_cxd2820r_tda18271_config)) { result = -EINVAL; goto out_free; } break; case EM2884_BOARD_TERRATEC_HTC_USB_XS: terratec_htc_usb_xs_init(dev); /* attach demodulator */ dvb->fe[0] = dvb_attach(drxk_attach, &terratec_htc_stick_drxk, &dev->i2c_adap[dev->def_i2c_bus]); if (!dvb->fe[0]) { result = -EINVAL; goto out_free; } /* Attach the demodulator. */ if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60, &dev->i2c_adap[dev->def_i2c_bus], &em28xx_cxd2820r_tda18271_config)) { result = -EINVAL; goto out_free; } break; case EM2874_BOARD_KWORLD_UB435Q_V2: dvb->fe[0] = dvb_attach(lgdt3305_attach, &em2874_lgdt3305_dev, &dev->i2c_adap[dev->def_i2c_bus]); if (!dvb->fe[0]) { result = -EINVAL; goto out_free; } /* Attach the demodulator. */ if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60, &dev->i2c_adap[dev->def_i2c_bus], &kworld_ub435q_v2_config)) { result = -EINVAL; goto out_free; } break; default: em28xx_errdev("/2: The frontend of your DVB/ATSC card" " isn't supported yet\n"); break; } if (NULL == dvb->fe[0]) { em28xx_errdev("/2: frontend initialization failed\n"); result = -EINVAL; goto out_free; } /* define general-purpose callback pointer */ dvb->fe[0]->callback = em28xx_tuner_callback; if (dvb->fe[1]) dvb->fe[1]->callback = em28xx_tuner_callback; /* register everything */ result = em28xx_register_dvb(dvb, THIS_MODULE, dev, &dev->udev->dev); if (result < 0) goto out_free; /* MFE lock */ dvb->adapter.mfe_shared = mfe_shared; em28xx_info("Successfully loaded em28xx-dvb\n"); ret: em28xx_set_mode(dev, EM28XX_SUSPEND); mutex_unlock(&dev->lock); return result; out_free: kfree(dvb); dev->dvb = NULL; goto ret; }
static int exynos_fimc_is_sensor_pin_control(struct platform_device *pdev, struct pinctrl *pinctrl, struct exynos_sensor_pin *pin_ctrls, int channel) { int ret = 0; char ch_name[30]; int pin = pin_ctrls->pin; int delay = pin_ctrls->delay; char* name = pin_ctrls->name; enum pin_act act = pin_ctrls->act; int voltage = pin_ctrls->voltage; struct pinctrl_state *s; snprintf(ch_name, sizeof(ch_name), "%s%d", name, channel); pr_info("%s(pin(%d), act(%d), ch(%s), delay(%d), voltage(%d))\n", __func__, pin, act, ch_name, delay, voltage); switch (act) { case PIN_PULL_NONE: break; case PIN_OUTPUT_HIGH: if (gpio_is_valid(pin)) { gpio_request_one(pin, GPIOF_OUT_INIT_HIGH, "CAM_GPIO_OUTPUT_HIGH"); usleep_range(delay, delay); gpio_free(pin); } break; case PIN_OUTPUT_LOW: if (gpio_is_valid(pin)) { gpio_request_one(pin, GPIOF_OUT_INIT_LOW, "CAM_GPIO_OUTPUT_LOW"); usleep_range(delay, delay); gpio_free(pin); } break; case PIN_INPUT: if (gpio_is_valid(pin)) { gpio_request_one(pin, GPIOF_IN, "CAM_GPIO_INPUT"); gpio_free(pin); } break; case PIN_RESET: if (gpio_is_valid(pin)) { gpio_request_one(pin, GPIOF_OUT_INIT_HIGH, "CAM_GPIO_RESET"); usleep_range(1000, 1000); __gpio_set_value(pin, 0); usleep_range(1000, 1000); __gpio_set_value(pin, 1); usleep_range(1000, 1000); gpio_free(pin); } break; case PIN_FUNCTION: s = (struct pinctrl_state *)pin_ctrls->pin; ret = pinctrl_select_state(pinctrl, s); if (ret < 0) { pr_err("%s: cam %s, state %p pinctrl_select_statee is failed\n", __func__, ch_name, s); return ret; } usleep_range(1000, 1000); break; case PIN_REGULATOR_ON: { struct regulator *regulator; regulator = regulator_get(&pdev->dev, name); if (IS_ERR_OR_NULL(regulator)) { pr_err("%s : regulator_get(%s) fail\n", __func__, name); return PTR_ERR(regulator); } if(voltage > 0) { pr_info("%s : regulator_set_voltage(%d)\n",__func__, voltage); ret = regulator_set_voltage(regulator, voltage, voltage); if(ret) { pr_err("%s : regulator_set_voltage(%d) fail\n", __func__, ret); } } if (regulator_is_enabled(regulator)) { pr_warning("%s regulator is already enabled\n", name); regulator_put(regulator); return 0; } ret = regulator_enable(regulator); if (ret) { pr_err("%s : regulator_enable(%s) fail\n", __func__, name); regulator_put(regulator); return ret; } usleep_range(delay, delay); regulator_put(regulator); } break; case PIN_REGULATOR_OFF: { struct regulator *regulator; regulator = regulator_get(&pdev->dev, name); if (IS_ERR_OR_NULL(regulator)) { pr_err("%s : regulator_get(%s) fail\n", __func__, name); return PTR_ERR(regulator); } if (!regulator_is_enabled(regulator)) { pr_warning("%s regulator is already disabled\n", name); regulator_put(regulator); return 0; } ret = regulator_disable(regulator); if (ret) { pr_err("%s : regulator_disable(%s) fail\n", __func__, name); regulator_put(regulator); return ret; } usleep_range(delay, delay); regulator_put(regulator); } break; default: pr_err("unknown act for pin\n"); break; } return ret; }
static int ak8975_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct ak8975_data *data; struct iio_dev *indio_dev; int eoc_gpio; int err; /* Grab and set up the supplied GPIO. */ if (client->dev.platform_data) eoc_gpio = *(int *)(client->dev.platform_data); else if (client->dev.of_node) eoc_gpio = of_get_gpio(client->dev.of_node, 0); else eoc_gpio = -1; if (eoc_gpio == -EPROBE_DEFER) return -EPROBE_DEFER; /* We may not have a GPIO based IRQ to scan, that is fine, we will poll if so */ if (gpio_is_valid(eoc_gpio)) { err = gpio_request_one(eoc_gpio, GPIOF_IN, "ak_8975"); if (err < 0) { dev_err(&client->dev, "failed to request GPIO %d, error %d\n", eoc_gpio, err); goto exit; } } /* Register with IIO */ indio_dev = iio_device_alloc(sizeof(*data)); if (indio_dev == NULL) { err = -ENOMEM; goto exit_gpio; } data = iio_priv(indio_dev); i2c_set_clientdata(client, indio_dev); data->client = client; data->eoc_gpio = eoc_gpio; data->eoc_irq = 0; /* Perform some basic start-of-day setup of the device. */ err = ak8975_setup(client); if (err < 0) { dev_err(&client->dev, "AK8975 initialization fails\n"); goto exit_free_iio; } data->client = client; mutex_init(&data->lock); data->eoc_gpio = eoc_gpio; indio_dev->dev.parent = &client->dev; indio_dev->channels = ak8975_channels; indio_dev->num_channels = ARRAY_SIZE(ak8975_channels); indio_dev->info = &ak8975_info; indio_dev->modes = INDIO_DIRECT_MODE; err = iio_device_register(indio_dev); if (err < 0) goto exit_free_iio; return 0; exit_free_iio: iio_device_free(indio_dev); if (data->eoc_irq) free_irq(data->eoc_irq, data); exit_gpio: if (gpio_is_valid(eoc_gpio)) gpio_free(eoc_gpio); exit: return err; }
static long mtx1_wdt_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { void __user *argp = (void __user *)arg; int __user *p = (int __user *)argp; unsigned int value; static const struct watchdog_info ident = { .options = WDIOF_CARDRESET, .identity = "MTX-1 WDT", }; switch (cmd) { case WDIOC_GETSUPPORT: if (copy_to_user(argp, &ident, sizeof(ident))) return -EFAULT; break; case WDIOC_GETSTATUS: case WDIOC_GETBOOTSTATUS: put_user(0, p); break; case WDIOC_SETOPTIONS: if (get_user(value, p)) return -EFAULT; if (value & WDIOS_ENABLECARD) mtx1_wdt_start(); else if (value & WDIOS_DISABLECARD) mtx1_wdt_stop(); else return -EINVAL; return 0; case WDIOC_KEEPALIVE: mtx1_wdt_reset(); break; default: return -ENOTTY; } return 0; } static ssize_t mtx1_wdt_write(struct file *file, const char *buf, size_t count, loff_t *ppos) { if (!count) return -EIO; mtx1_wdt_reset(); return count; } static const struct file_operations mtx1_wdt_fops = { .owner = THIS_MODULE, .llseek = no_llseek, .unlocked_ioctl = mtx1_wdt_ioctl, .open = mtx1_wdt_open, .write = mtx1_wdt_write, .release = mtx1_wdt_release, }; static struct miscdevice mtx1_wdt_misc = { .minor = WATCHDOG_MINOR, .name = "watchdog", .fops = &mtx1_wdt_fops, }; static int __devinit mtx1_wdt_probe(struct platform_device *pdev) { int ret; mtx1_wdt_device.gpio = pdev->resource[0].start; ret = gpio_request_one(mtx1_wdt_device.gpio, GPIOF_OUT_INIT_HIGH, "mtx1-wdt"); if (ret < 0) { dev_err(&pdev->dev, "failed to request gpio"); return ret; } spin_lock_init(&mtx1_wdt_device.lock); init_completion(&mtx1_wdt_device.stop); mtx1_wdt_device.queue = 0; clear_bit(0, &mtx1_wdt_device.inuse); setup_timer(&mtx1_wdt_device.timer, mtx1_wdt_trigger, 0L); mtx1_wdt_device.default_ticks = ticks; ret = misc_register(&mtx1_wdt_misc); if (ret < 0) { dev_err(&pdev->dev, "failed to register\n"); return ret; } mtx1_wdt_start(); dev_info(&pdev->dev, "MTX-1 Watchdog driver\n"); return 0; } static int __devexit mtx1_wdt_remove(struct platform_device *pdev) { /* FIXME: do we need to lock this test ? */ if (mtx1_wdt_device.queue) { mtx1_wdt_device.queue = 0; wait_for_completion(&mtx1_wdt_device.stop); } gpio_free(mtx1_wdt_device.gpio); misc_deregister(&mtx1_wdt_misc); return 0; } static struct platform_driver mtx1_wdt_driver = { .probe = mtx1_wdt_probe, .remove = __devexit_p(mtx1_wdt_remove), .driver.name = "mtx1-wdt", .driver.owner = THIS_MODULE, }; static int __init mtx1_wdt_init(void) { return platform_driver_register(&mtx1_wdt_driver); } static void __exit mtx1_wdt_exit(void) { platform_driver_unregister(&mtx1_wdt_driver); } module_init(mtx1_wdt_init); module_exit(mtx1_wdt_exit); MODULE_AUTHOR("Michael Stickel, Florian Fainelli"); MODULE_DESCRIPTION("Driver for the MTX-1 watchdog"); MODULE_LICENSE("GPL"); MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); MODULE_ALIAS("platform:mtx1-wdt");
static int rx51_lp5523_setup(void) { return gpio_request_one(RX51_LP5523_CHIP_EN_GPIO, GPIOF_DIR_OUT, "lp5523_enable"); }
int arizona_dev_init(struct arizona *arizona) { struct device *dev = arizona->dev; const char *type_name = "Unknown"; unsigned int reg, val; int (*apply_patch)(struct arizona *) = NULL; int ret, i; char revision_char; dev_set_drvdata(arizona->dev, arizona); mutex_init(&arizona->clk_lock); init_completion(&arizona->gpio_allocated); if (dev_get_platdata(arizona->dev)) memcpy(&arizona->pdata, dev_get_platdata(arizona->dev), sizeof(arizona->pdata)); else arizona_of_get_core_pdata(arizona); regcache_cache_only(arizona->regmap, true); switch (arizona->type) { case WM5102: case WM5110: case WM8280: case WM8997: for (i = 0; i < ARRAY_SIZE(wm5102_core_supplies); i++) arizona->core_supplies[i].supply = wm5102_core_supplies[i]; arizona->num_core_supplies = ARRAY_SIZE(wm5102_core_supplies); break; default: dev_err(arizona->dev, "Unknown device type %d\n", arizona->type); return -EINVAL; } /* Mark DCVDD as external, LDO1 driver will clear if internal */ arizona->external_dcvdd = true; ret = mfd_add_devices(arizona->dev, -1, early_devs, ARRAY_SIZE(early_devs), NULL, 0, NULL); if (ret != 0) { dev_err(dev, "Failed to add early children: %d\n", ret); return ret; } ret = devm_regulator_bulk_get(dev, arizona->num_core_supplies, arizona->core_supplies); if (ret != 0) { dev_err(dev, "Failed to request core supplies: %d\n", ret); goto err_early; } arizona->dcvdd = devm_regulator_get(arizona->dev, "DCVDD"); if (IS_ERR(arizona->dcvdd)) { ret = PTR_ERR(arizona->dcvdd); dev_err(dev, "Failed to request DCVDD: %d\n", ret); goto err_early; } if (arizona->pdata.reset) { /* Start out with /RESET low to put the chip into reset */ ret = gpio_request_one(arizona->pdata.reset, GPIOF_DIR_OUT | GPIOF_INIT_LOW, "arizona /RESET"); if (ret != 0) { dev_err(dev, "Failed to request /RESET: %d\n", ret); goto err_early; } } ret = regulator_bulk_enable(arizona->num_core_supplies, arizona->core_supplies); if (ret != 0) { dev_err(dev, "Failed to enable core supplies: %d\n", ret); goto err_early; } ret = regulator_enable(arizona->dcvdd); if (ret != 0) { dev_err(dev, "Failed to enable DCVDD: %d\n", ret); goto err_enable; } switch (arizona->type) { case WM5110: case WM8280: msleep(5); break; default: break; } if (arizona->pdata.reset) { gpio_set_value_cansleep(arizona->pdata.reset, 1); msleep(1); } regcache_cache_only(arizona->regmap, false); /* Verify that this is a chip we know about */ ret = regmap_read(arizona->regmap, ARIZONA_SOFTWARE_RESET, ®); if (ret != 0) { dev_err(dev, "Failed to read ID register: %d\n", ret); goto err_reset; } switch (reg) { case 0x5102: case 0x5110: case 0x8997: break; default: dev_err(arizona->dev, "Unknown device ID: %x\n", reg); goto err_reset; } /* If we have a /RESET GPIO we'll already be reset */ if (!arizona->pdata.reset) { regcache_mark_dirty(arizona->regmap); ret = arizona_soft_reset(arizona); if (ret != 0) goto err_reset; ret = regcache_sync(arizona->regmap); if (ret != 0) { dev_err(dev, "Failed to sync device: %d\n", ret); goto err_reset; } } /* Ensure device startup is complete */ switch (arizona->type) { case WM5102: ret = regmap_read(arizona->regmap, 0x19, &val); if (ret != 0) dev_err(dev, "Failed to check write sequencer state: %d\n", ret); else if (val & 0x01) break; /* Fall through */ default: ret = arizona_wait_for_boot(arizona); if (ret != 0) { dev_err(arizona->dev, "Device failed initial boot: %d\n", ret); goto err_reset; } break; } /* Read the device ID information & do device specific stuff */ ret = regmap_read(arizona->regmap, ARIZONA_SOFTWARE_RESET, ®); if (ret != 0) { dev_err(dev, "Failed to read ID register: %d\n", ret); goto err_reset; } ret = regmap_read(arizona->regmap, ARIZONA_DEVICE_REVISION, &arizona->rev); if (ret != 0) { dev_err(dev, "Failed to read revision register: %d\n", ret); goto err_reset; } arizona->rev &= ARIZONA_DEVICE_REVISION_MASK; switch (reg) { #ifdef CONFIG_MFD_WM5102 case 0x5102: type_name = "WM5102"; if (arizona->type != WM5102) { dev_err(arizona->dev, "WM5102 registered as %d\n", arizona->type); arizona->type = WM5102; } apply_patch = wm5102_patch; arizona->rev &= 0x7; revision_char = arizona->rev + 'A'; break; #endif #ifdef CONFIG_MFD_FLORIDA case 0x5110: switch (arizona->type) { case WM8280: if (arizona->rev >= 0x5) { type_name = "WM8281"; revision_char = arizona->rev + 60; } else { type_name = "WM8280"; revision_char = arizona->rev + 61; } break; case WM5110: type_name = "WM5110"; revision_char = arizona->rev + 'A'; break; default: dev_err(arizona->dev, "Florida codec registered as %d\n", arizona->type); arizona->type = WM8280; type_name = "Florida"; revision_char = arizona->rev + 61; break; } apply_patch = florida_patch; break; #endif #ifdef CONFIG_MFD_WM8997 case 0x8997: type_name = "WM8997"; revision_char = arizona->rev + 'A'; if (arizona->type != WM8997) { dev_err(arizona->dev, "WM8997 registered as %d\n", arizona->type); arizona->type = WM8997; } apply_patch = wm8997_patch; break; #endif default: dev_err(arizona->dev, "Unknown device ID %x\n", reg); goto err_reset; } dev_info(dev, "%s revision %c\n", type_name, revision_char); if (apply_patch) { ret = apply_patch(arizona); if (ret != 0) { dev_err(arizona->dev, "Failed to apply patch: %d\n", ret); goto err_reset; } switch (arizona->type) { case WM5102: ret = arizona_apply_hardware_patch(arizona); if (ret != 0) { dev_err(arizona->dev, "Failed to apply hardware patch: %d\n", ret); goto err_reset; } break; case WM5110: case WM8280: ret = arizona_apply_sleep_patch(arizona); if (ret != 0) { dev_err(arizona->dev, "Failed to apply sleep patch: %d\n", ret); goto err_reset; } break; default: break; } } for (i = 0; i < ARRAY_SIZE(arizona->pdata.gpio_defaults); i++) { if (!arizona->pdata.gpio_defaults[i]) continue; regmap_write(arizona->regmap, ARIZONA_GPIO1_CTRL + i, arizona->pdata.gpio_defaults[i]); } pm_runtime_set_autosuspend_delay(arizona->dev, 100); pm_runtime_use_autosuspend(arizona->dev); pm_runtime_enable(arizona->dev); /* Chip default */ if (!arizona->pdata.clk32k_src) arizona->pdata.clk32k_src = ARIZONA_32KZ_MCLK2; switch (arizona->pdata.clk32k_src) { case ARIZONA_32KZ_MCLK1: case ARIZONA_32KZ_MCLK2: regmap_update_bits(arizona->regmap, ARIZONA_CLOCK_32K_1, ARIZONA_CLK_32K_SRC_MASK, arizona->pdata.clk32k_src - 1); arizona_clk32k_enable(arizona); break; case ARIZONA_32KZ_NONE: regmap_update_bits(arizona->regmap, ARIZONA_CLOCK_32K_1, ARIZONA_CLK_32K_SRC_MASK, 2); break; default: dev_err(arizona->dev, "Invalid 32kHz clock source: %d\n", arizona->pdata.clk32k_src); ret = -EINVAL; goto err_reset; } for (i = 0; i < ARIZONA_MAX_MICBIAS; i++) { if (!arizona->pdata.micbias[i].mV && !arizona->pdata.micbias[i].bypass) continue; /* Apply default for bypass mode */ if (!arizona->pdata.micbias[i].mV) arizona->pdata.micbias[i].mV = 2800; val = (arizona->pdata.micbias[i].mV - 1500) / 100; val <<= ARIZONA_MICB1_LVL_SHIFT; if (arizona->pdata.micbias[i].ext_cap) val |= ARIZONA_MICB1_EXT_CAP; if (arizona->pdata.micbias[i].discharge) val |= ARIZONA_MICB1_DISCH; if (arizona->pdata.micbias[i].soft_start) val |= ARIZONA_MICB1_RATE; if (arizona->pdata.micbias[i].bypass) val |= ARIZONA_MICB1_BYPASS; regmap_update_bits(arizona->regmap, ARIZONA_MIC_BIAS_CTRL_1 + i, ARIZONA_MICB1_LVL_MASK | ARIZONA_MICB1_DISCH | ARIZONA_MICB1_BYPASS | ARIZONA_MICB1_RATE, val); } for (i = 0; i < ARIZONA_MAX_INPUT; i++) { /* Default for both is 0 so noop with defaults */ val = arizona->pdata.dmic_ref[i] << ARIZONA_IN1_DMIC_SUP_SHIFT; val |= arizona->pdata.inmode[i] << ARIZONA_IN1_MODE_SHIFT; regmap_update_bits(arizona->regmap, ARIZONA_IN1L_CONTROL + (i * 8), ARIZONA_IN1_DMIC_SUP_MASK | ARIZONA_IN1_MODE_MASK, val); } for (i = 0; i < ARIZONA_MAX_OUTPUT; i++) { /* Default is 0 so noop with defaults */ if (arizona->pdata.out_mono[i]) val = ARIZONA_OUT1_MONO; else val = 0; regmap_update_bits(arizona->regmap, ARIZONA_OUTPUT_PATH_CONFIG_1L + (i * 8), ARIZONA_OUT1_MONO, val); } for (i = 0; i < ARIZONA_MAX_PDM_SPK; i++) { if (arizona->pdata.spk_mute[i]) regmap_update_bits(arizona->regmap, ARIZONA_PDM_SPK1_CTRL_1 + (i * 2), ARIZONA_SPK1_MUTE_ENDIAN_MASK | ARIZONA_SPK1_MUTE_SEQ1_MASK, arizona->pdata.spk_mute[i]); if (arizona->pdata.spk_fmt[i]) regmap_update_bits(arizona->regmap, ARIZONA_PDM_SPK1_CTRL_2 + (i * 2), ARIZONA_SPK1_FMT_MASK, arizona->pdata.spk_fmt[i]); } /* Set up for interrupts */ ret = arizona_irq_init(arizona); if (ret != 0) goto err_reset; arizona_request_irq(arizona, ARIZONA_IRQ_CLKGEN_ERR, "CLKGEN error", arizona_clkgen_err, arizona); arizona_request_irq(arizona, ARIZONA_IRQ_OVERCLOCKED, "Overclocked", arizona_overclocked, arizona); arizona_request_irq(arizona, ARIZONA_IRQ_UNDERCLOCKED, "Underclocked", arizona_underclocked, arizona); switch (arizona->type) { case WM5102: ret = mfd_add_devices(arizona->dev, -1, wm5102_devs, ARRAY_SIZE(wm5102_devs), NULL, 0, NULL); break; case WM8280: case WM5110: ret = mfd_add_devices(arizona->dev, -1, florida_devs, ARRAY_SIZE(florida_devs), NULL, 0, NULL); break; case WM8997: ret = mfd_add_devices(arizona->dev, -1, wm8997_devs, ARRAY_SIZE(wm8997_devs), NULL, 0, NULL); break; } if (ret != 0) { dev_err(arizona->dev, "Failed to add subdevices: %d\n", ret); goto err_irq; } #ifdef CONFIG_PM_RUNTIME regulator_disable(arizona->dcvdd); #endif return 0; err_irq: arizona_irq_exit(arizona); err_reset: if (arizona->pdata.reset) { gpio_set_value_cansleep(arizona->pdata.reset, 0); gpio_free(arizona->pdata.reset); } regulator_disable(arizona->dcvdd); err_enable: regulator_bulk_disable(arizona->num_core_supplies, arizona->core_supplies); err_early: mfd_remove_devices(dev); return ret; }
static void __init eva_init(void) { struct platform_device *usb = NULL; regulator_register_always_on(0, "fixed-3.3V", fixed3v3_power_consumers, ARRAY_SIZE(fixed3v3_power_consumers), 3300000); pinctrl_register_mappings(eva_pinctrl_map, ARRAY_SIZE(eva_pinctrl_map)); pwm_add_table(pwm_lookup, ARRAY_SIZE(pwm_lookup)); r8a7740_pinmux_init(); r8a7740_meram_workaround(); /* LCDC0 */ gpio_request_one(61, GPIOF_OUT_INIT_HIGH, NULL); /* LCDDON */ /* GETHER */ gpio_request_one(18, GPIOF_OUT_INIT_HIGH, NULL); /* PHY_RST */ /* USB */ gpio_request_one(159, GPIOF_IN, NULL); /* USB_DEVICE_MODE */ if (gpio_get_value(159)) { /* USB Host */ } else { /* USB Func */ /* * The USBHS interrupt handlers needs to read the IRQ pin value * (HI/LOW) to diffentiate USB connection and disconnection * events (usbhsf_get_vbus()). We thus need to select both the * intc_irq7_1 pin group and GPIO 209 here. */ gpio_request_one(209, GPIOF_IN, NULL); platform_device_register(&usbhsf_device); usb = &usbhsf_device; } /* CON1/CON15 Camera */ gpio_request_one(173, GPIOF_OUT_INIT_LOW, NULL); /* STANDBY */ gpio_request_one(172, GPIOF_OUT_INIT_HIGH, NULL); /* RST */ /* see mt9t111_power() */ gpio_request_one(158, GPIOF_OUT_INIT_LOW, NULL); /* CAM_PON */ /* FSI-WM8978 */ gpio_request(7, NULL); gpio_request(8, NULL); gpio_direction_none(GPIO_PORT7CR); /* FSIAOBT needs no direction */ gpio_direction_none(GPIO_PORT8CR); /* FSIAOLR needs no direction */ /* * CAUTION * * DBGMD/LCDC0/FSIA MUX * DBGMD_SELECT_B should be set after setting PFC Function. */ gpio_request_one(176, GPIOF_OUT_INIT_HIGH, NULL); /* * We can switch CON8/CON14 by SW1.5, * but it needs after DBGMD_SELECT_B */ gpio_request_one(6, GPIOF_IN, NULL); if (gpio_get_value(6)) { /* CON14 enable */ } else { /* CON8 (SDHI1) enable */ pinctrl_register_mappings(eva_sdhi1_pinctrl_map, ARRAY_SIZE(eva_sdhi1_pinctrl_map)); platform_device_register(&vcc_sdhi1); platform_device_register(&sdhi1_device); } #ifdef CONFIG_CACHE_L2X0 /* Early BRESP enable, Shared attribute override enable, 32K*8way */ l2x0_init(IOMEM(0xf0002000), 0x40440000, 0x82000fff); #endif i2c_register_board_info(0, i2c0_devices, ARRAY_SIZE(i2c0_devices)); i2c_register_board_info(2, i2c2_devices, ARRAY_SIZE(i2c2_devices)); r8a7740_add_standard_devices(); platform_add_devices(eva_devices, ARRAY_SIZE(eva_devices)); rmobile_add_device_to_domain("A4LC", &lcdc0_device); rmobile_add_device_to_domain("A4LC", &hdmi_lcdc_device); if (usb) rmobile_add_device_to_domain("A3SP", usb); r8a7740_pm_init(); }
static int __devinit bq5101xb_charger_probe(struct platform_device *pdev) { int ret = 0; struct bq5101xb_chip *chip; const struct bq5101xb_charger_platform_data *pdata = pdev->dev.platform_data; if ((pdata->en1_pin < 0) && (pdata->en2_pin < 0) && (pdata->ts_ctrl_term_b_pin < 0) && (pdata->ts_ctrl_fault_pin < 0) && (pdata->chrg_b_pin < 0)) { ret = -ENODEV; goto fail; } chip = kzalloc(sizeof(*chip), GFP_KERNEL); if (!chip) { ret = -ENOMEM; goto fail; } chip->state = BQ5101XB_WAIT; INIT_DELAYED_WORK(&chip->bq5101xb_work, bq5101xb_worker); chip->wl_psy.name = BQ5101XB_PSY_NAME; chip->wl_psy.type = POWER_SUPPLY_TYPE_WIRELESS; if (pdata->num_supplies) { chip->wl_psy.supplied_to = pdata->supply_list; chip->wl_psy.num_supplicants = pdata->num_supplies; } chip->wl_psy.properties = bq5101xb_props; chip->wl_psy.num_properties = ARRAY_SIZE(bq5101xb_props); chip->wl_psy.get_property = bq5101xb_get_property; ret = power_supply_register(&pdev->dev, &chip->wl_psy); if (ret < 0) { dev_err(&pdev->dev, "power_supply_register wireless failed ret = %d\n", ret); goto fail_free_dev; } chip->psy_notifier.notifier_call = bq5101xb_psy_notify; if (pdata->en1_pin >= 0) { ret = gpio_request_one(pdata->en1_pin, GPIOF_OUT_INIT_LOW, "bq5101xb_en1"); if (ret) { dev_err(&pdev->dev, "Failed to request en1_pin: %d\n", ret); goto fail_free_dev; } ret = gpio_export(pdata->en1_pin, false); if (ret) dev_err(&pdev->dev, "GPIO export failed: %d\n", ret); ret = gpio_export_link(&pdev->dev, "en1_pin", pdata->en1_pin); if (ret) dev_err(&pdev->dev, "GPIO export link failed: %d\n", ret); } if (pdata->en2_pin >= 0) { ret = gpio_request_one(pdata->en2_pin, GPIOF_OUT_INIT_LOW, "bq5101xb_en2"); if (ret) { dev_err(&pdev->dev, "Failed to request en2_pin: %d\n", ret); goto fail_free_en1; } ret = gpio_export(pdata->en2_pin, false); if (ret) dev_err(&pdev->dev, "GPIO export failed: %d\n", ret); ret = gpio_export_link(&pdev->dev, "en2_pin", pdata->en2_pin); if (ret) dev_err(&pdev->dev, "GPIO export link failed: %d\n", ret); } if (pdata->ts_ctrl_term_b_pin >= 0) { ret = gpio_request_one(pdata->ts_ctrl_term_b_pin, GPIOF_OUT_INIT_HIGH, "bq5101xb_ts_ctrl_term_b"); if (ret) { dev_err(&pdev->dev, "Failed to request ts_ctrl_term_b_pin: %d\n", ret); goto fail_free_en2; } ret = gpio_export(pdata->ts_ctrl_term_b_pin, false); if (ret) dev_err(&pdev->dev, "GPIO export failed: %d\n", ret); ret = gpio_export_link(&pdev->dev, "ts_ctrl_term_b_pin", pdata->ts_ctrl_term_b_pin); if (ret) dev_err(&pdev->dev, "GPIO export link failed: %d\n", ret); } if (pdata->ts_ctrl_fault_pin >= 0) { ret = gpio_request_one(pdata->ts_ctrl_fault_pin, GPIOF_OUT_INIT_LOW, "bq5101xb_ts_ctrl_fault"); if (ret) { dev_err(&pdev->dev, "Failed to request ts_ctrl_fault_pin: %d\n", ret); goto fail_free_term; } ret = gpio_export(pdata->ts_ctrl_fault_pin, false); if (ret) dev_err(&pdev->dev, "GPIO export failed: %d\n", ret); ret = gpio_export_link(&pdev->dev, "ts_ctrl_fault_pin", pdata->ts_ctrl_fault_pin); if (ret) dev_err(&pdev->dev, "GPIO export link failed: %d\n", ret); } if (pdata->chrg_b_pin >= 0) { ret = gpio_request_one(pdata->chrg_b_pin, GPIOF_IN, "bq5101xb_chrg_b"); if (ret) { dev_err(&pdev->dev, "Failed to request chrg_b_pin: %d\n", ret); goto fail_free_fault; } ret = gpio_export(pdata->chrg_b_pin, false); if (ret) dev_err(&pdev->dev, "GPIO export failed: %d\n", ret); ret = gpio_export_link(&pdev->dev, "chrg_b_pin", pdata->chrg_b_pin); if (ret) dev_err(&pdev->dev, "GPIO export link failed: %d\n", ret); } platform_set_drvdata(pdev, chip); chip->dev = &pdev->dev; schedule_delayed_work(&chip->bq5101xb_work, msecs_to_jiffies(100)); return 0; fail_free_fault: if (pdata->ts_ctrl_fault_pin >= 0) gpio_free(pdata->ts_ctrl_fault_pin); fail_free_term: if (pdata->ts_ctrl_term_b_pin >= 0) gpio_free(pdata->ts_ctrl_term_b_pin); fail_free_en2: if (pdata->en2_pin >= 0) gpio_free(pdata->en2_pin); fail_free_en1: if (pdata->en1_pin >= 0) gpio_free(pdata->en1_pin); fail_free_dev: kfree(chip); fail: return ret; }