static void palm27x_backlight_exit(struct device *dev) { gpio_free(palm_bl_power); if (gpio_is_valid(palm_lcd_power)) gpio_free(palm_lcd_power); }
static int __devinit gpio_keys_probe(struct platform_device *pdev) { const struct gpio_keys_platform_data *pdata = pdev->dev.platform_data; struct gpio_keys_drvdata *ddata; struct device *dev = &pdev->dev; struct gpio_keys_platform_data alt_pdata; struct input_dev *input; int i, error; int wakeup = 0; if (!pdata) { error = gpio_keys_get_devtree_pdata(dev, &alt_pdata); if (error) return error; pdata = &alt_pdata; } ddata = kzalloc(sizeof(struct gpio_keys_drvdata) + pdata->nbuttons * sizeof(struct gpio_button_data), GFP_KERNEL); input = input_allocate_device(); if (!ddata || !input) { dev_err(dev, "failed to allocate state\n"); error = -ENOMEM; goto fail1; } ddata->input = input; ddata->n_buttons = pdata->nbuttons; ddata->enable = pdata->enable; ddata->disable = pdata->disable; mutex_init(&ddata->disable_lock); platform_set_drvdata(pdev, ddata); input_set_drvdata(input, ddata); input->name = pdata->name ? : pdev->name; input->phys = "gpio-keys/input0"; input->dev.parent = &pdev->dev; input->open = gpio_keys_open; input->close = gpio_keys_close; input->id.bustype = BUS_HOST; input->id.vendor = 0x0001; input->id.product = 0x0001; input->id.version = 0x0100; /* Enable auto repeat feature of Linux input subsystem */ if (pdata->rep) __set_bit(EV_REP, input->evbit); for (i = 0; i < pdata->nbuttons; i++) { const struct gpio_keys_button *button = &pdata->buttons[i]; struct gpio_button_data *bdata = &ddata->data[i]; error = gpio_keys_setup_key(pdev, input, bdata, button); if (error) goto fail2; if (button->wakeup) wakeup = 1; } error = sysfs_create_group(&pdev->dev.kobj, &gpio_keys_attr_group); if (error) { dev_err(dev, "Unable to export keys/switches, error: %d\n", error); goto fail2; } error = input_register_device(input); if (error) { dev_err(dev, "Unable to register input device, error: %d\n", error); goto fail3; } /* get current state of buttons that are connected to GPIOs */ for (i = 0; i < pdata->nbuttons; i++) { struct gpio_button_data *bdata = &ddata->data[i]; if (gpio_is_valid(bdata->button->gpio)) gpio_keys_gpio_report_event(bdata); } input_sync(input); device_init_wakeup(&pdev->dev, wakeup); return 0; fail3: sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group); fail2: while (--i >= 0) gpio_remove_key(&ddata->data[i]); platform_set_drvdata(pdev, NULL); fail1: input_free_device(input); kfree(ddata); /* If we have no platform_data, we allocated buttons dynamically. */ if (!pdev->dev.platform_data) kfree(pdata->buttons); return error; }
int analogix_dp_bind(struct device *dev, struct drm_device *drm_dev, struct analogix_dp_plat_data *plat_data) { struct platform_device *pdev = to_platform_device(dev); struct analogix_dp_device *dp; struct resource *res; unsigned int irq_flags; int ret; if (!plat_data) { dev_err(dev, "Invalided input plat_data\n"); return -EINVAL; } dp = devm_kzalloc(dev, sizeof(struct analogix_dp_device), GFP_KERNEL); if (!dp) return -ENOMEM; dev_set_drvdata(dev, dp); dp->dev = &pdev->dev; dp->dpms_mode = DRM_MODE_DPMS_OFF; mutex_init(&dp->panel_lock); dp->panel_is_modeset = false; /* * platform dp driver need containor_of the plat_data to get * the driver private data, so we need to store the point of * plat_data, not the context of plat_data. */ dp->plat_data = plat_data; ret = analogix_dp_dt_parse_pdata(dp); if (ret) return ret; dp->phy = devm_phy_get(dp->dev, "dp"); if (IS_ERR(dp->phy)) { dev_err(dp->dev, "no DP phy configured\n"); ret = PTR_ERR(dp->phy); if (ret) { /* * phy itself is not enabled, so we can move forward * assigning NULL to phy pointer. */ if (ret == -ENOSYS || ret == -ENODEV) dp->phy = NULL; else return ret; } } dp->clock = devm_clk_get(&pdev->dev, "dp"); if (IS_ERR(dp->clock)) { dev_err(&pdev->dev, "failed to get clock\n"); return PTR_ERR(dp->clock); } clk_prepare_enable(dp->clock); res = platform_get_resource(pdev, IORESOURCE_MEM, 0); dp->reg_base = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(dp->reg_base)) return PTR_ERR(dp->reg_base); dp->force_hpd = of_property_read_bool(dev->of_node, "force-hpd"); dp->hpd_gpio = of_get_named_gpio(dev->of_node, "hpd-gpios", 0); if (!gpio_is_valid(dp->hpd_gpio)) dp->hpd_gpio = of_get_named_gpio(dev->of_node, "samsung,hpd-gpio", 0); if (gpio_is_valid(dp->hpd_gpio)) { /* * Set up the hotplug GPIO from the device tree as an interrupt. * Simply specifying a different interrupt in the device tree * doesn't work since we handle hotplug rather differently when * using a GPIO. We also need the actual GPIO specifier so * that we can get the current state of the GPIO. */ ret = devm_gpio_request_one(&pdev->dev, dp->hpd_gpio, GPIOF_IN, "hpd_gpio"); if (ret) { dev_err(&pdev->dev, "failed to get hpd gpio\n"); return ret; } dp->irq = gpio_to_irq(dp->hpd_gpio); irq_flags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING; } else { dp->hpd_gpio = -ENODEV; dp->irq = platform_get_irq(pdev, 0); irq_flags = 0; } if (dp->irq == -ENXIO) { dev_err(&pdev->dev, "failed to get irq\n"); return -ENODEV; } pm_runtime_enable(dev); phy_power_on(dp->phy); analogix_dp_init_dp(dp); ret = devm_request_threaded_irq(&pdev->dev, dp->irq, analogix_dp_hardirq, analogix_dp_irq_thread, irq_flags, "analogix-dp", dp); if (ret) { dev_err(&pdev->dev, "failed to request irq\n"); goto err_disable_pm_runtime; } disable_irq(dp->irq); dp->drm_dev = drm_dev; dp->encoder = dp->plat_data->encoder; dp->aux.name = "DP-AUX"; dp->aux.transfer = analogix_dpaux_transfer; dp->aux.dev = &pdev->dev; ret = drm_dp_aux_register(&dp->aux); if (ret) goto err_disable_pm_runtime; ret = analogix_dp_create_bridge(drm_dev, dp); if (ret) { DRM_ERROR("failed to create bridge (%d)\n", ret); drm_encoder_cleanup(dp->encoder); goto err_disable_pm_runtime; } return 0; err_disable_pm_runtime: pm_runtime_disable(dev); return ret; }
static int bq24735_charger_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret; struct bq24735 *charger; struct power_supply_desc *supply_desc; struct power_supply_config psy_cfg = {}; char *name; charger = devm_kzalloc(&client->dev, sizeof(*charger), GFP_KERNEL); if (!charger) return -ENOMEM; charger->pdata = client->dev.platform_data; if (IS_ENABLED(CONFIG_OF) && !charger->pdata && client->dev.of_node) charger->pdata = bq24735_parse_dt_data(client); if (!charger->pdata) { dev_err(&client->dev, "no platform data provided\n"); return -EINVAL; } name = (char *)charger->pdata->name; if (!name) { name = kasprintf(GFP_KERNEL, "bq24735@%s", dev_name(&client->dev)); if (!name) { dev_err(&client->dev, "Failed to alloc device name\n"); return -ENOMEM; } } charger->client = client; supply_desc = &charger->charger_desc; supply_desc->name = name; supply_desc->type = POWER_SUPPLY_TYPE_MAINS; supply_desc->properties = bq24735_charger_properties; supply_desc->num_properties = ARRAY_SIZE(bq24735_charger_properties); supply_desc->get_property = bq24735_charger_get_property; psy_cfg.supplied_to = charger->pdata->supplied_to; psy_cfg.num_supplicants = charger->pdata->num_supplicants; psy_cfg.of_node = client->dev.of_node; psy_cfg.drv_data = charger; i2c_set_clientdata(client, charger); ret = bq24735_read_word(client, BQ24735_MANUFACTURER_ID); if (ret < 0) { dev_err(&client->dev, "Failed to read manufacturer id : %d\n", ret); goto err_free_name; } else if (ret != 0x0040) { dev_err(&client->dev, "manufacturer id mismatch. 0x0040 != 0x%04x\n", ret); ret = -ENODEV; goto err_free_name; } ret = bq24735_read_word(client, BQ24735_DEVICE_ID); if (ret < 0) { dev_err(&client->dev, "Failed to read device id : %d\n", ret); goto err_free_name; } else if (ret != 0x000B) { dev_err(&client->dev, "device id mismatch. 0x000b != 0x%04x\n", ret); ret = -ENODEV; goto err_free_name; } if (gpio_is_valid(charger->pdata->status_gpio)) { ret = devm_gpio_request(&client->dev, charger->pdata->status_gpio, name); if (ret) { dev_err(&client->dev, "Failed GPIO request for GPIO %d: %d\n", charger->pdata->status_gpio, ret); } charger->pdata->status_gpio_valid = !ret; } ret = bq24735_config_charger(charger); if (ret < 0) { dev_err(&client->dev, "failed in configuring charger"); goto err_free_name; } /* check for AC adapter presence */ if (bq24735_charger_is_present(charger)) { ret = bq24735_enable_charging(charger); if (ret < 0) { dev_err(&client->dev, "Failed to enable charging\n"); goto err_free_name; } } charger->charger = power_supply_register(&client->dev, supply_desc, &psy_cfg); if (IS_ERR(charger->charger)) { ret = PTR_ERR(charger->charger); dev_err(&client->dev, "Failed to register power supply: %d\n", ret); goto err_free_name; } if (client->irq) { ret = devm_request_threaded_irq(&client->dev, client->irq, NULL, bq24735_charger_isr, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, supply_desc->name, charger->charger); if (ret) { dev_err(&client->dev, "Unable to register IRQ %d err %d\n", client->irq, ret); goto err_unregister_supply; } } return 0; err_unregister_supply: power_supply_unregister(charger->charger); err_free_name: if (name != charger->pdata->name) kfree(name); 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; char *name = NULL; /* 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 = devm_gpio_request_one(&client->dev, eoc_gpio, GPIOF_IN, "ak_8975"); if (err < 0) { dev_err(&client->dev, "failed to request GPIO %d, error %d\n", eoc_gpio, err); return err; } } /* Register with IIO */ indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); if (indio_dev == NULL) return -ENOMEM; data = iio_priv(indio_dev); i2c_set_clientdata(client, indio_dev); data->client = client; data->eoc_gpio = eoc_gpio; data->eoc_irq = 0; /* id will be NULL when enumerated via ACPI */ if (id) { data->chipset = (enum asahi_compass_chipset)(id->driver_data); name = (char *) id->name; } else if (ACPI_HANDLE(&client->dev)) name = ak8975_match_acpi_device(&client->dev, &data->chipset); else return -ENOSYS; dev_dbg(&client->dev, "Asahi compass chip %s\n", name); /* 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"); return err; } 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; indio_dev->name = name; err = devm_iio_device_register(&client->dev, indio_dev); if (err < 0) return err; return 0; }
/********** end of rk3036 usb detections **********/ static int rk_usb_control_probe(struct platform_device *pdev) { int gpio, err; struct device_node *np = pdev->dev.of_node; int ret = 0; control_usb = devm_kzalloc(&pdev->dev, sizeof(*control_usb), GFP_KERNEL); if (!control_usb) { dev_err(&pdev->dev, "unable to alloc memory for control usb\n"); ret = -ENOMEM; goto out; } control_usb->chip_id = RK3036_USB_CTLR; control_usb->remote_wakeup = of_property_read_bool(np, "rockchip,remote_wakeup"); control_usb->usb_irq_wakeup = of_property_read_bool(np, "rockchip,usb_irq_wakeup"); INIT_DELAYED_WORK(&control_usb->usb_charger_det_work, usb_battery_charger_detect_work); control_usb->host_gpios = devm_kzalloc(&pdev->dev, sizeof(struct gpio), GFP_KERNEL); if (!control_usb->host_gpios) { dev_err(&pdev->dev, "unable to alloc memory for host_gpios\n"); ret = -ENOMEM; goto out; } gpio = of_get_named_gpio(np, "host_drv_gpio", 0); control_usb->host_gpios->gpio = gpio; if (!gpio_is_valid(gpio)) { dev_err(&pdev->dev, "invalid host gpio%d\n", gpio); } else { err = devm_gpio_request(&pdev->dev, gpio, "host_drv_gpio"); if (err) { dev_err(&pdev->dev, "failed to request GPIO%d for host_drv\n", gpio); ret = err; goto out; } gpio_direction_output(control_usb->host_gpios->gpio, 1); } control_usb->otg_gpios = devm_kzalloc(&pdev->dev, sizeof(struct gpio), GFP_KERNEL); if (!control_usb->otg_gpios) { dev_err(&pdev->dev, "unable to alloc memory for otg_gpios\n"); ret = -ENOMEM; goto out; } gpio = of_get_named_gpio(np, "otg_drv_gpio", 0); control_usb->otg_gpios->gpio = gpio; if (!gpio_is_valid(gpio)) { dev_err(&pdev->dev, "invalid otg gpio%d\n", gpio); } else { err = devm_gpio_request(&pdev->dev, gpio, "otg_drv_gpio"); if (err) { dev_err(&pdev->dev, "failed to request GPIO%d for otg_drv\n", gpio); ret = err; goto out; } gpio_direction_output(control_usb->otg_gpios->gpio, 0); } out: return ret; }
static int cpm_uart_init_port(struct device_node *np, struct uart_cpm_port *pinfo) { const u32 *data; void __iomem *mem, *pram; int len; int ret; int i; data = of_get_property(np, "clock", NULL); if (data) { struct clk *clk = clk_get(NULL, (const char*)data); if (!IS_ERR(clk)) pinfo->clk = clk; } if (!pinfo->clk) { data = of_get_property(np, "fsl,cpm-brg", &len); if (!data || len != 4) { printk(KERN_ERR "CPM UART %s has no/invalid " "fsl,cpm-brg property.\n", np->name); return -EINVAL; } pinfo->brg = *data; } data = of_get_property(np, "fsl,cpm-command", &len); if (!data || len != 4) { printk(KERN_ERR "CPM UART %s has no/invalid " "fsl,cpm-command property.\n", np->name); return -EINVAL; } pinfo->command = *data; mem = of_iomap(np, 0); if (!mem) return -ENOMEM; if (of_device_is_compatible(np, "fsl,cpm1-scc-uart") || of_device_is_compatible(np, "fsl,cpm2-scc-uart")) { pinfo->sccp = mem; pinfo->sccup = pram = cpm_uart_map_pram(pinfo, np); } else if (of_device_is_compatible(np, "fsl,cpm1-smc-uart") || of_device_is_compatible(np, "fsl,cpm2-smc-uart")) { pinfo->flags |= FLAG_SMC; pinfo->smcp = mem; pinfo->smcup = pram = cpm_uart_map_pram(pinfo, np); } else { ret = -ENODEV; goto out_mem; } if (!pram) { ret = -ENOMEM; goto out_mem; } pinfo->tx_nrfifos = TX_NUM_FIFO; pinfo->tx_fifosize = TX_BUF_SIZE; pinfo->rx_nrfifos = RX_NUM_FIFO; pinfo->rx_fifosize = RX_BUF_SIZE; pinfo->port.uartclk = ppc_proc_freq; pinfo->port.mapbase = (unsigned long)mem; pinfo->port.type = PORT_CPM; pinfo->port.ops = &cpm_uart_pops, pinfo->port.iotype = UPIO_MEM; pinfo->port.fifosize = pinfo->tx_nrfifos * pinfo->tx_fifosize; spin_lock_init(&pinfo->port.lock); pinfo->port.irq = of_irq_to_resource(np, 0, NULL); if (pinfo->port.irq == NO_IRQ) { ret = -EINVAL; goto out_pram; } for (i = 0; i < NUM_GPIOS; i++) { int gpio; pinfo->gpios[i] = -1; gpio = of_get_gpio(np, i); if (gpio_is_valid(gpio)) { ret = gpio_request(gpio, "cpm_uart"); if (ret) { pr_err("can't request gpio #%d: %d\n", i, ret); continue; } if (i == GPIO_RTS || i == GPIO_DTR) ret = gpio_direction_output(gpio, 0); else ret = gpio_direction_input(gpio); if (ret) { pr_err("can't set direction for gpio #%d: %d\n", i, ret); gpio_free(gpio); continue; } pinfo->gpios[i] = gpio; } } #ifdef CONFIG_PPC_EARLY_DEBUG_CPM udbg_putc = NULL; #endif return cpm_uart_request_port(&pinfo->port); out_pram: cpm_uart_unmap_pram(pinfo, pram); out_mem: iounmap(mem); return ret; }
static int sensor_2p2_12m_power_setpin(struct device *dev) { struct exynos_platform_fimc_is_sensor *pdata; struct device_node *dnode; 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(!dev); BUG_ON(!dev->platform_data); dnode = dev->of_node; pdata = dev->platform_data; 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"); return -EINVAL; } else { gpio_request_one(gpio_reset, GPIOF_OUT_INIT_LOW, "CAM_GPIO_OUTPUT_LOW"); gpio_free(gpio_reset); } 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); } } #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 if (gpio_is_valid(gpios_cam_en)) { SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 0, gpios_cam_en, 0, NULL, 0, PIN_OUTPUT_HIGH); } else { SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 0, gpio_none, 0, "CAM_SEN_A2.8V_AP", 0, PIN_REGULATOR_ON); } SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 1, gpio_none, 0, "CAM_SEN_CORE_1.2V_AP", 0, PIN_REGULATOR_ON); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 2, gpio_none, 0, "CAM_AF_2.8V_AP", 2000, PIN_REGULATOR_ON); #ifdef CONFIG_OIS_USE SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 3, gpios_ois_en, 0, NULL, 0, PIN_OUTPUT_HIGH); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 4, gpio_none, 0, "OIS_VM_2.8V", 0, PIN_REGULATOR_ON); #endif SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 5, gpio_none, 0, "CAM_IO_1.8V_AP", 0, PIN_REGULATOR_ON); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 6, gpio_none, 0, "VDDA_1.8V_COMP", 0, PIN_REGULATOR_ON); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 7, gpio_comp_en, 0, NULL, 150, PIN_OUTPUT_HIGH); if (pdata->companion_use_pmic) { SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 8, gpio_none, 0, "VDD_MIPI_1.0V_COMP", 0, PIN_REGULATOR_ON); } SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 9, gpio_comp_rst, 0, NULL, 0, PIN_OUTPUT_HIGH); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 10, gpio_none, 0, "ch", 0, PIN_FUNCTION); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 11, gpio_none, 0, "af", 0, PIN_FUNCTION); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 12, gpio_reset, 0, NULL, 0, PIN_OUTPUT_HIGH); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_ON, 13, gpio_none, 0, NULL, 0, PIN_END); /* BACK CAMERA - POWER OFF */ SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 0, gpio_none, 0, "CAM_AF_2.8V_AP", 2000, PIN_REGULATOR_OFF); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 1, gpio_none, 0, "off", 0, PIN_FUNCTION); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 2, gpio_reset, 0, NULL, 0, PIN_OUTPUT_LOW); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 3, gpio_comp_rst, 0, NULL, 0, PIN_OUTPUT_LOW); if (pdata->companion_use_pmic) { SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 4, gpio_none, 0, "VDD_MIPI_1.0V_COMP", 0, PIN_REGULATOR_OFF); } SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 5, gpio_comp_en, 0, NULL, 0, PIN_OUTPUT_LOW); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 6, gpio_none, 0, "VDDA_1.8V_COMP", 0, PIN_REGULATOR_OFF); if (gpio_is_valid(gpios_cam_en)) { SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 7, gpios_cam_en, 0, NULL, 0, PIN_OUTPUT_LOW); } else { SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 7, gpio_none, 0, "CAM_SEN_A2.8V_AP", 0, PIN_REGULATOR_OFF); } SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 8, gpio_none, 0, "CAM_SEN_CORE_1.2V_AP", 0, PIN_REGULATOR_OFF); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 9, gpio_none, 0, "CAM_IO_1.8V_AP", 0, PIN_REGULATOR_OFF); #ifdef CONFIG_OIS_USE SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 10, gpios_ois_en, 0, NULL, 0, PIN_OUTPUT_LOW); SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 11, gpio_none, 0, "OIS_VM_2.8V", 0, PIN_REGULATOR_OFF); #endif SET_PIN(pdata, SENSOR_SCENARIO_NORMAL, GPIO_SCENARIO_OFF, 12, gpio_none, 0, NULL, 0, PIN_END); #ifdef CONFIG_OIS_USE /* OIS_FACTORY - POWER ON */ SET_PIN(pdata, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_ON, 0, gpio_none, 0, "CAM_AF_2.8V_AP", 2000, PIN_REGULATOR_ON); SET_PIN(pdata, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_ON, 1, gpios_ois_en, 0, NULL, 0, PIN_OUTPUT_HIGH); SET_PIN(pdata, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_ON, 2, gpio_none, 0, "OIS_VM_2.8V", 0, PIN_REGULATOR_ON); SET_PIN(pdata, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_ON, 3, gpio_none, 0, "CAM_IO_1.8V_AP", 0, PIN_REGULATOR_ON); SET_PIN(pdata, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_ON, 4, gpio_reset, 0, NULL, 0, PIN_OUTPUT_HIGH); SET_PIN(pdata, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_ON, 5, gpio_none, 0, NULL, 0, PIN_END); /* OIS_FACTORY - POWER OFF */ SET_PIN(pdata, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_OFF, 0, gpio_none, 0, "CAM_AF_2.8V_AP", 2000, PIN_REGULATOR_OFF); SET_PIN(pdata, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_OFF, 1, gpio_reset, 0, NULL, 0, PIN_OUTPUT_LOW); SET_PIN(pdata, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_OFF, 2, gpio_none, 0, "CAM_IO_1.8V_AP", 0, PIN_REGULATOR_OFF); SET_PIN(pdata, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_OFF, 3, gpios_ois_en, 0, NULL, 0, PIN_OUTPUT_LOW); SET_PIN(pdata, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_OFF, 4, gpio_none, 0, "OIS_VM_2.8V", 0, PIN_REGULATOR_OFF); SET_PIN(pdata, SENSOR_SCENARIO_OIS_FACTORY, GPIO_SCENARIO_OFF, 5, gpio_none, 0, NULL, 0, PIN_END); #endif return 0; }
int cyttsp5_init(struct cyttsp5_core_platform_data *pdata, int on, struct device *dev) { int rc = 0; if (!pdata) { dev_err(dev,"%s NULL Pointer detected!\n",__func__); WARN_ON(1); return -EINVAL; } /* reset, irq gpio info */ pdata->rst_gpio = rst_gpio_number; pdata->irq_gpio = irq_gpio_number; dev_dbg(dev, "--------pdata->rst_gpio------------: %d\n",(pdata->rst_gpio)); dev_dbg(dev, "--------pdata->irq_gpio------------: %d\n",(pdata->irq_gpio)); if (on) { #if 1 if(!gpio_is_valid(rst_gpio_number)) return -ENODEV; rc = gpio_request(rst_gpio_number, "CYTTSP5_I2C_RST_GPIO"); if (rc < 0) { printk("Failed to request GPIO:%d, ERRNO:%d", (s32)rst_gpio_number, rc); rc = -ENODEV; } else { gpio_direction_output(rst_gpio_number, 1); } if(!gpio_is_valid(irq_gpio_number)) return -ENODEV; rc = gpio_request(irq_gpio_number, "CYTTSP5_I2C_IRQ_GPIO"); if (rc < 0) { printk("Failed request CYTTSP5_I2C_IRQ_GPIO.\n"); return rc; } gpio_direction_input(irq_gpio_number); #else rc = gpio_request(rst_gpio, NULL); if (rc < 0) { gpio_free(rst_gpio); rc = gpio_request(rst_gpio, NULL); } if (rc < 0) { dev_err(dev, "%s: Fail request gpio=%d\n", __func__, rst_gpio); } else { rc = gpio_direction_output(rst_gpio, 1); if (rc < 0) { pr_err("%s: Fail set output gpio=%d\n", __func__, rst_gpio); gpio_free(rst_gpio); } else { rc = gpio_request(irq_gpio, NULL); if (rc < 0) { gpio_free(irq_gpio); rc = gpio_request(irq_gpio, NULL); } if (rc < 0) { dev_err(dev, "%s: Fail request gpio=%d\n", __func__, irq_gpio); gpio_free(rst_gpio); } else { gpio_direction_input(irq_gpio); } } } #endif } else { gpio_free(rst_gpio_number); gpio_free(irq_gpio_number); } dev_dbg(dev, "%s: INIT CYTTSP RST gpio=%d and IRQ gpio=%d r=%d\n", __func__, (pdata->rst_gpio), (pdata->irq_gpio), rc); return rc; }
static void omap_stop_ehc(struct ehci_hcd_omap *omap, struct usb_hcd *hcd) { unsigned long timeout = jiffies + msecs_to_jiffies(100); dev_dbg(omap->dev, "stopping TI EHCI USB Controller\n"); /* Reset OMAP modules for insmod/rmmod to work */ ehci_omap_writel(omap->uhh_base, OMAP_UHH_SYSCONFIG, is_omap_ehci_rev2(omap) ? OMAP4_UHH_SYSCONFIG_SOFTRESET : OMAP_UHH_SYSCONFIG_SOFTRESET); while (!(ehci_omap_readl(omap->uhh_base, OMAP_UHH_SYSSTATUS) & (1 << 0))) { cpu_relax(); if (time_after(jiffies, timeout)) dev_dbg(omap->dev, "operation timed out\n"); } while (!(ehci_omap_readl(omap->uhh_base, OMAP_UHH_SYSSTATUS) & (1 << 1))) { cpu_relax(); if (time_after(jiffies, timeout)) dev_dbg(omap->dev, "operation timed out\n"); } while (!(ehci_omap_readl(omap->uhh_base, OMAP_UHH_SYSSTATUS) & (1 << 2))) { cpu_relax(); if (time_after(jiffies, timeout)) dev_dbg(omap->dev, "operation timed out\n"); } ehci_omap_writel(omap->tll_base, OMAP_USBTLL_SYSCONFIG, (1 << 1)); while (!(ehci_omap_readl(omap->tll_base, OMAP_USBTLL_SYSSTATUS) & (1 << 0))) { cpu_relax(); if (time_after(jiffies, timeout)) dev_dbg(omap->dev, "operation timed out\n"); } if (omap->usbtll_fck != NULL) { clk_disable(omap->usbtll_fck); clk_put(omap->usbtll_fck); omap->usbtll_fck = NULL; } if (omap->usbhost_ick != NULL) { clk_disable(omap->usbhost_ick); clk_put(omap->usbhost_ick); omap->usbhost_ick = NULL; } if (omap->usbhost_fs_fck != NULL) { clk_disable(omap->usbhost_fs_fck); clk_put(omap->usbhost_fs_fck); omap->usbhost_fs_fck = NULL; } if (omap->usbhost_hs_fck != NULL) { clk_disable(omap->usbhost_hs_fck); clk_put(omap->usbhost_hs_fck); omap->usbhost_hs_fck = NULL; } if (omap->usbtll_ick != NULL) { clk_disable(omap->usbtll_ick); clk_put(omap->usbtll_ick); omap->usbtll_ick = NULL; } if (is_omap_ehci_rev2(omap)) { if (omap->xclk60mhsp1_ck != NULL) { clk_disable(omap->xclk60mhsp1_ck); clk_put(omap->xclk60mhsp1_ck); omap->xclk60mhsp1_ck = NULL; } if (omap->utmi_p1_fck != NULL) { clk_disable(omap->utmi_p1_fck); clk_put(omap->utmi_p1_fck); omap->utmi_p1_fck = NULL; } if (omap->xclk60mhsp2_ck != NULL) { clk_disable(omap->xclk60mhsp2_ck); clk_put(omap->xclk60mhsp2_ck); omap->xclk60mhsp2_ck = NULL; } if (omap->utmi_p2_fck != NULL) { clk_disable(omap->utmi_p2_fck); clk_put(omap->utmi_p2_fck); omap->utmi_p2_fck = NULL; } } if (omap->phy_reset) { if (gpio_is_valid(omap->reset_gpio_port[0])) gpio_free(omap->reset_gpio_port[0]); if (gpio_is_valid(omap->reset_gpio_port[1])) gpio_free(omap->reset_gpio_port[1]); } dev_dbg(omap->dev, "Clock to USB host has been disabled\n"); }
static int gpio_charger_probe(struct platform_device *pdev) { const struct gpio_charger_platform_data *pdata = pdev->dev.platform_data; struct power_supply_config psy_cfg = {}; struct gpio_charger *gpio_charger; struct power_supply_desc *charger_desc; int ret; int irq; if (!pdata) { pdata = gpio_charger_parse_dt(&pdev->dev); if (IS_ERR(pdata)) { ret = PTR_ERR(pdata); if (ret != -EPROBE_DEFER) dev_err(&pdev->dev, "No platform data\n"); return ret; } } if (!gpio_is_valid(pdata->gpio)) { dev_err(&pdev->dev, "Invalid gpio pin\n"); return -EINVAL; } gpio_charger = devm_kzalloc(&pdev->dev, sizeof(*gpio_charger), GFP_KERNEL); if (!gpio_charger) { dev_err(&pdev->dev, "Failed to alloc driver structure\n"); return -ENOMEM; } charger_desc = &gpio_charger->charger_desc; charger_desc->name = pdata->name ? pdata->name : "gpio-charger"; charger_desc->type = pdata->type; charger_desc->properties = gpio_charger_properties; charger_desc->num_properties = ARRAY_SIZE(gpio_charger_properties); charger_desc->get_property = gpio_charger_get_property; psy_cfg.supplied_to = pdata->supplied_to; psy_cfg.num_supplicants = pdata->num_supplicants; psy_cfg.of_node = pdev->dev.of_node; psy_cfg.drv_data = gpio_charger; ret = gpio_request(pdata->gpio, dev_name(&pdev->dev)); if (ret) { dev_err(&pdev->dev, "Failed to request gpio pin: %d\n", ret); goto err_free; } ret = gpio_direction_input(pdata->gpio); if (ret) { dev_err(&pdev->dev, "Failed to set gpio to input: %d\n", ret); goto err_gpio_free; } gpio_charger->pdata = pdata; gpio_charger->charger = power_supply_register(&pdev->dev, charger_desc, &psy_cfg); if (IS_ERR(gpio_charger->charger)) { ret = PTR_ERR(gpio_charger->charger); dev_err(&pdev->dev, "Failed to register power supply: %d\n", ret); goto err_gpio_free; } irq = gpio_to_irq(pdata->gpio); if (irq > 0) { ret = request_any_context_irq(irq, gpio_charger_irq, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, dev_name(&pdev->dev), gpio_charger->charger); if (ret < 0) dev_warn(&pdev->dev, "Failed to request irq: %d\n", ret); else gpio_charger->irq = irq; } platform_set_drvdata(pdev, gpio_charger); device_init_wakeup(&pdev->dev, 1); return 0; err_gpio_free: gpio_free(pdata->gpio); err_free: return ret; }
/* omap_start_ehc * - Start the TI USBHOST controller */ static int omap_start_ehc(struct ehci_hcd_omap *omap, struct usb_hcd *hcd) { unsigned long timeout = jiffies + msecs_to_jiffies(1000); u8 tll_ch_mask = 0; unsigned reg = 0; int ret = 0; dev_dbg(omap->dev, "starting TI EHCI USB Controller\n"); /* Enable Clocks for USBHOST */ omap->usbhost_ick = clk_get(omap->dev, "usbhost_ick"); if (IS_ERR(omap->usbhost_ick)) { ret = PTR_ERR(omap->usbhost_ick); goto err_host_ick; } clk_enable(omap->usbhost_ick); omap->usbhost_hs_fck = clk_get(omap->dev, "hs_fck"); if (IS_ERR(omap->usbhost_hs_fck)) { ret = PTR_ERR(omap->usbhost_hs_fck); goto err_host_120m_fck; } clk_enable(omap->usbhost_hs_fck); omap->usbhost_fs_fck = clk_get(omap->dev, "fs_fck"); if (IS_ERR(omap->usbhost_fs_fck)) { ret = PTR_ERR(omap->usbhost_fs_fck); goto err_host_48m_fck; } clk_enable(omap->usbhost_fs_fck); if (omap->phy_reset) { /* Refer: ISSUE1 */ if (gpio_is_valid(omap->reset_gpio_port[0])) { gpio_request(omap->reset_gpio_port[0], "USB1 PHY reset"); gpio_direction_output(omap->reset_gpio_port[0], 0); } if (gpio_is_valid(omap->reset_gpio_port[1])) { gpio_request(omap->reset_gpio_port[1], "USB2 PHY reset"); gpio_direction_output(omap->reset_gpio_port[1], 0); } /* Hold the PHY in RESET for enough time till DIR is high */ udelay(10); } /* Configure TLL for 60Mhz clk for ULPI */ omap->usbtll_fck = clk_get(omap->dev, "usbtll_fck"); if (IS_ERR(omap->usbtll_fck)) { ret = PTR_ERR(omap->usbtll_fck); goto err_tll_fck; } clk_enable(omap->usbtll_fck); omap->usbtll_ick = clk_get(omap->dev, "usbtll_ick"); if (IS_ERR(omap->usbtll_ick)) { ret = PTR_ERR(omap->usbtll_ick); goto err_tll_ick; } clk_enable(omap->usbtll_ick); omap->omap_ehci_rev = ehci_omap_readl(omap->uhh_base, OMAP_UHH_REVISION); dev_dbg(omap->dev, "OMAP UHH_REVISION 0x%x\n", omap->omap_ehci_rev); /* * Enable per-port clocks as needed (newer controllers only). * - External ULPI clock for PHY mode * - Internal clocks for TLL and HSIC modes (TODO) */ if (is_omap_ehci_rev2(omap)) { switch (omap->port_mode[0]) { case EHCI_HCD_OMAP_MODE_PHY: omap->xclk60mhsp1_ck = clk_get(omap->dev, "xclk60mhsp1_ck"); if (IS_ERR(omap->xclk60mhsp1_ck)) { ret = PTR_ERR(omap->xclk60mhsp1_ck); dev_err(omap->dev, "Unable to get Port1 ULPI clock\n"); } omap->utmi_p1_fck = clk_get(omap->dev, "utmi_p1_gfclk"); if (IS_ERR(omap->utmi_p1_fck)) { ret = PTR_ERR(omap->utmi_p1_fck); dev_err(omap->dev, "Unable to get utmi_p1_fck\n"); } ret = clk_set_parent(omap->utmi_p1_fck, omap->xclk60mhsp1_ck); if (ret != 0) { dev_err(omap->dev, "Unable to set P1 f-clock\n"); } break; case EHCI_HCD_OMAP_MODE_TLL: /* TODO */ default: break; } switch (omap->port_mode[1]) { case EHCI_HCD_OMAP_MODE_PHY: omap->xclk60mhsp2_ck = clk_get(omap->dev, "xclk60mhsp2_ck"); if (IS_ERR(omap->xclk60mhsp2_ck)) { ret = PTR_ERR(omap->xclk60mhsp2_ck); dev_err(omap->dev, "Unable to get Port2 ULPI clock\n"); } omap->utmi_p2_fck = clk_get(omap->dev, "utmi_p2_gfclk"); if (IS_ERR(omap->utmi_p2_fck)) { ret = PTR_ERR(omap->utmi_p2_fck); dev_err(omap->dev, "Unable to get utmi_p2_fck\n"); } ret = clk_set_parent(omap->utmi_p2_fck, omap->xclk60mhsp2_ck); if (ret != 0) { dev_err(omap->dev, "Unable to set P2 f-clock\n"); } break; case EHCI_HCD_OMAP_MODE_TLL: /* TODO */ default: break; } } /* perform TLL soft reset, and wait until reset is complete */ ehci_omap_writel(omap->tll_base, OMAP_USBTLL_SYSCONFIG, OMAP_USBTLL_SYSCONFIG_SOFTRESET); /* Wait for TLL reset to complete */ while (!(ehci_omap_readl(omap->tll_base, OMAP_USBTLL_SYSSTATUS) & OMAP_USBTLL_SYSSTATUS_RESETDONE)) { cpu_relax(); if (time_after(jiffies, timeout)) { dev_dbg(omap->dev, "operation timed out\n"); ret = -EINVAL; goto err_sys_status; } } dev_dbg(omap->dev, "TLL RESET DONE\n"); /* (1<<3) = no idle mode only for initial debugging */ ehci_omap_writel(omap->tll_base, OMAP_USBTLL_SYSCONFIG, OMAP_USBTLL_SYSCONFIG_ENAWAKEUP | OMAP_USBTLL_SYSCONFIG_SIDLEMODE | OMAP_USBTLL_SYSCONFIG_CACTIVITY); /* Put UHH in NoIdle/NoStandby mode */ reg = ehci_omap_readl(omap->uhh_base, OMAP_UHH_SYSCONFIG); if (is_omap_ehci_rev1(omap)) { reg |= (OMAP_UHH_SYSCONFIG_ENAWAKEUP | OMAP_UHH_SYSCONFIG_SIDLEMODE | OMAP_UHH_SYSCONFIG_CACTIVITY | OMAP_UHH_SYSCONFIG_MIDLEMODE); reg &= ~OMAP_UHH_SYSCONFIG_AUTOIDLE; } else if (is_omap_ehci_rev2(omap)) { reg &= ~OMAP4_UHH_SYSCONFIG_IDLEMODE_CLEAR; reg |= OMAP4_UHH_SYSCONFIG_NOIDLE; reg &= ~OMAP4_UHH_SYSCONFIG_STDBYMODE_CLEAR; reg |= OMAP4_UHH_SYSCONFIG_NOSTDBY; } ehci_omap_writel(omap->uhh_base, OMAP_UHH_SYSCONFIG, reg); reg = ehci_omap_readl(omap->uhh_base, OMAP_UHH_HOSTCONFIG); /* setup ULPI bypass and burst configurations */ reg |= (OMAP_UHH_HOSTCONFIG_INCR4_BURST_EN | OMAP_UHH_HOSTCONFIG_INCR8_BURST_EN | OMAP_UHH_HOSTCONFIG_INCR16_BURST_EN); reg &= ~OMAP_UHH_HOSTCONFIG_INCRX_ALIGN_EN; if (is_omap_ehci_rev1(omap)) { if (omap->port_mode[0] == EHCI_HCD_OMAP_MODE_UNKNOWN) reg &= ~OMAP_UHH_HOSTCONFIG_P1_CONNECT_STATUS; if (omap->port_mode[1] == EHCI_HCD_OMAP_MODE_UNKNOWN) reg &= ~OMAP_UHH_HOSTCONFIG_P2_CONNECT_STATUS; if (omap->port_mode[2] == EHCI_HCD_OMAP_MODE_UNKNOWN) reg &= ~OMAP_UHH_HOSTCONFIG_P3_CONNECT_STATUS; /* Bypass the TLL module for PHY mode operation */ if (cpu_is_omap3430() && (omap_rev() <= OMAP3430_REV_ES2_1)) { dev_dbg(omap->dev, "OMAP3 ES version <= ES2.1\n"); if (is_ehci_phy_mode(omap->port_mode[0]) || is_ehci_phy_mode(omap->port_mode[1]) || is_ehci_phy_mode(omap->port_mode[2])) reg &= ~OMAP_UHH_HOSTCONFIG_ULPI_BYPASS; else reg |= OMAP_UHH_HOSTCONFIG_ULPI_BYPASS; } else { dev_dbg(omap->dev, "OMAP3 ES version > ES2.1\n"); if (is_ehci_phy_mode(omap->port_mode[0])) reg &= ~OMAP_UHH_HOSTCONFIG_ULPI_P1_BYPASS; else if (is_ehci_tll_mode(omap->port_mode[0])) reg |= OMAP_UHH_HOSTCONFIG_ULPI_P1_BYPASS; if (is_ehci_phy_mode(omap->port_mode[1])) reg &= ~OMAP_UHH_HOSTCONFIG_ULPI_P2_BYPASS; else if (is_ehci_tll_mode(omap->port_mode[1])) reg |= OMAP_UHH_HOSTCONFIG_ULPI_P2_BYPASS; if (is_ehci_phy_mode(omap->port_mode[2])) reg &= ~OMAP_UHH_HOSTCONFIG_ULPI_P3_BYPASS; else if (is_ehci_tll_mode(omap->port_mode[2])) reg |= OMAP_UHH_HOSTCONFIG_ULPI_P3_BYPASS; } } else if (is_omap_ehci_rev2(omap)) { /* Clear port mode fields for PHY mode*/ reg &= ~OMAP4_P1_MODE_CLEAR; reg &= ~OMAP4_P2_MODE_CLEAR; if (is_ehci_tll_mode(omap->port_mode[0])) reg |= OMAP4_P1_MODE_TLL; else if (is_ehci_hsic_mode(omap->port_mode[0])) reg |= OMAP4_P1_MODE_HSIC; if (is_ehci_tll_mode(omap->port_mode[1])) reg |= OMAP4_P2_MODE_TLL; else if (is_ehci_hsic_mode(omap->port_mode[1])) reg |= OMAP4_P2_MODE_HSIC; } ehci_omap_writel(omap->uhh_base, OMAP_UHH_HOSTCONFIG, reg); dev_dbg(omap->dev, "UHH setup done, uhh_hostconfig=%x\n", reg); /* * An undocumented "feature" in the OMAP3 EHCI controller, * causes suspended ports to be taken out of suspend when * the USBCMD.Run/Stop bit is cleared (for example when * we do ehci_bus_suspend). * This breaks suspend-resume if the root-hub is allowed * to suspend. Writing 1 to this undocumented register bit * disables this feature and restores normal behavior. */ ehci_omap_writel(omap->ehci_base, EHCI_INSNREG04, EHCI_INSNREG04_DISABLE_UNSUSPEND); if ((omap->port_mode[0] == EHCI_HCD_OMAP_MODE_TLL) || (omap->port_mode[1] == EHCI_HCD_OMAP_MODE_TLL) || (omap->port_mode[2] == EHCI_HCD_OMAP_MODE_TLL)) { if (omap->port_mode[0] == EHCI_HCD_OMAP_MODE_TLL) tll_ch_mask |= OMAP_TLL_CHANNEL_1_EN_MASK; if (omap->port_mode[1] == EHCI_HCD_OMAP_MODE_TLL) tll_ch_mask |= OMAP_TLL_CHANNEL_2_EN_MASK; if (omap->port_mode[2] == EHCI_HCD_OMAP_MODE_TLL) tll_ch_mask |= OMAP_TLL_CHANNEL_3_EN_MASK; /* Enable UTMI mode for required TLL channels */ omap_usb_utmi_init(omap, tll_ch_mask, OMAP_TLL_CHANNEL_COUNT); } if (omap->phy_reset) { /* Refer ISSUE1: * Hold the PHY in RESET for enough time till * PHY is settled and ready */ udelay(10); if (gpio_is_valid(omap->reset_gpio_port[0])) gpio_set_value(omap->reset_gpio_port[0], 1); if (gpio_is_valid(omap->reset_gpio_port[1])) gpio_set_value(omap->reset_gpio_port[1], 1); } /* Soft reset the PHY using PHY reset command over ULPI */ if (omap->port_mode[0] == EHCI_HCD_OMAP_MODE_PHY) omap_ehci_soft_phy_reset(omap, 0); if (omap->port_mode[1] == EHCI_HCD_OMAP_MODE_PHY) omap_ehci_soft_phy_reset(omap, 1); return 0; err_sys_status: clk_disable(omap->utmi_p2_fck); clk_put(omap->utmi_p2_fck); clk_disable(omap->xclk60mhsp2_ck); clk_put(omap->xclk60mhsp2_ck); clk_disable(omap->utmi_p1_fck); clk_put(omap->utmi_p1_fck); clk_disable(omap->xclk60mhsp1_ck); clk_put(omap->xclk60mhsp1_ck); clk_disable(omap->usbtll_ick); clk_put(omap->usbtll_ick); err_tll_ick: clk_disable(omap->usbtll_fck); clk_put(omap->usbtll_fck); err_tll_fck: clk_disable(omap->usbhost_fs_fck); clk_put(omap->usbhost_fs_fck); if (omap->phy_reset) { if (gpio_is_valid(omap->reset_gpio_port[0])) gpio_free(omap->reset_gpio_port[0]); if (gpio_is_valid(omap->reset_gpio_port[1])) gpio_free(omap->reset_gpio_port[1]); } err_host_48m_fck: clk_disable(omap->usbhost_hs_fck); clk_put(omap->usbhost_hs_fck); err_host_120m_fck: clk_disable(omap->usbhost_ick); clk_put(omap->usbhost_ick); err_host_ick: return ret; }
static int bcm4343_bluetooth_probe(struct platform_device *pdev) { int rc = 0; #ifdef BT_LPM_ENABLE int ret; #endif pr_info("[BT] bcm4343_bluetooth_probe.\n"); bt_gpio.bt_en = of_get_gpio(pdev->dev.of_node, 0); if (!gpio_is_valid(bt_gpio.bt_en)) { pr_err("[BT] bt_gpio.bt_en get gpio failed.\n"); return -EINVAL; } rc = gpio_request(bt_gpio.bt_en, "bten_gpio"); if (unlikely(rc)) { pr_err("[BT] bt_gpio.bt_en request failed.\n"); return rc; } bt_gpio.bt_wake =of_get_gpio(pdev->dev.of_node, 1); if (!gpio_is_valid(bt_gpio.bt_wake)) { pr_err("[BT] bt_gpio.bt_wake get gpio failed.\n"); return -EINVAL; } rc = gpio_request(bt_gpio.bt_wake, "btwake_gpio"); if (unlikely(rc)) { pr_err("[BT] bt_gpio.bt_wake request failed.\n"); gpio_free(bt_gpio.bt_en); return rc; } bt_gpio.bt_hostwake =of_get_gpio(pdev->dev.of_node, 2); if (!gpio_is_valid(bt_gpio.bt_hostwake)) { pr_err("[BT] bt_gpio.bt_hostwake get gpio failed.\n"); return -EINVAL; } rc = gpio_request(bt_gpio.bt_hostwake,"bthostwake_gpio"); if (unlikely(rc)) { pr_err("[BT] bt_gpio.bt_hostwake request failed.\n"); gpio_free(bt_gpio.bt_wake); gpio_free(bt_gpio.bt_en); return rc; } gpio_direction_input(bt_gpio.bt_hostwake); gpio_direction_output(bt_gpio.bt_wake, 0); gpio_direction_output(bt_gpio.bt_en, 0); bt_rfkill = rfkill_alloc("bcm4343 Bluetooth", &pdev->dev, RFKILL_TYPE_BLUETOOTH, &bcm4343_bt_rfkill_ops, NULL); if (unlikely(!bt_rfkill)) { pr_err("[BT] bt_rfkill alloc failed.\n"); gpio_free(bt_gpio.bt_hostwake); gpio_free(bt_gpio.bt_wake); gpio_free(bt_gpio.bt_en); return -ENOMEM; } rfkill_init_sw_state(bt_rfkill, 0); rc = rfkill_register(bt_rfkill); if (unlikely(rc)) { pr_err("[BT] bt_rfkill register failed.\n"); rfkill_destroy(bt_rfkill); gpio_free(bt_gpio.bt_hostwake); gpio_free(bt_gpio.bt_wake); gpio_free(bt_gpio.bt_en); return -1; } rfkill_set_sw_state(bt_rfkill, true); #ifdef BT_LPM_ENABLE ret = bcm_bt_lpm_init(pdev); if (ret) { rfkill_unregister(bt_rfkill); rfkill_destroy(bt_rfkill); gpio_free(bt_gpio.bt_hostwake); gpio_free(bt_gpio.bt_wake); gpio_free(bt_gpio.bt_en); } #endif pr_info("[BT] bcm4343_bluetooth_probe End \n"); return rc; }
/**************************GPIO ********************************************/ int gpio_cmds_tx(struct platform_device *pdev, struct gpio_desc *cmds, int cnt) { int ret = 0; struct gpio_desc *cm = NULL; int i = 0; struct device *dev; struct device_node *np; enum of_gpio_flags gpio_flags; if (pdev) { dev = &pdev->dev; np = dev->of_node; } cm = cmds; for (i = 0; i < cnt; i++) { if ((cm == NULL) || (cm->label == NULL)) { balongfb_loge("cm or cm->label is null! index=%d\n", i); ret = -1; goto error; } if ((cm->dtype == DTYPE_GPIO_GET) && (pdev)) { *(cm->gpio) = of_get_gpio_by_prop(np, cm->label, 0, 0, &gpio_flags); if (!gpio_is_valid(*(cm->gpio))) { balongfb_loge("gpio invalid, dtype=%d, lable=%s, gpio=%d!\n", cm->dtype, cm->label, *(cm->gpio)); } } else if (cm->dtype == DTYPE_GPIO_INPUT) { if (gpio_direction_input(*(cm->gpio)) != 0) { balongfb_loge("failed to gpio_direction_input, lable=%s, gpio=%d!\n", cm->label, *(cm->gpio)); ret = -1; goto error; } } else if (cm->dtype == DTYPE_GPIO_OUTPUT) { if (gpio_direction_output(*(cm->gpio), cm->value) != 0) { balongfb_loge("failed to gpio_direction_output, label%s, gpio=%d!\n", cm->label, *(cm->gpio)); ret = -1; goto error; } } else if (cm->dtype == DTYPE_GPIO_REQUEST) { if (gpio_request(*(cm->gpio), cm->label) != 0) { balongfb_loge("failed to gpio_request, lable=%s, gpio=%d!\n", cm->label, *(cm->gpio)); ret = -1; goto error; } } else if (cm->dtype == DTYPE_GPIO_FREE) { gpio_free(*(cm->gpio)); } else { balongfb_loge("dtype=%x NOT supported\n", cm->dtype); ret = -1; goto error; } if (cm->wait) { if (cm->waittype == WAIT_TYPE_US) udelay(cm->wait); else if (cm->waittype == WAIT_TYPE_MS) mdelay(cm->wait); else mdelay(cm->wait * 1000); } cm++; } return 0; error: return ret; }
static int SN3193_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret = 0; int i, rc; enum of_gpio_flags gpio_flags; struct SN3193_sled * sn3193_sled_dev; SN3193_sled_dev_sate->ena_gpio = of_get_named_gpio_flags(client->dev.of_node, "sn3193,sdb-gpio", 0, &gpio_flags); pr_debug("%s ena_gpio:%d\n", __func__, SN3193_sled_dev_sate->ena_gpio); if (gpio_is_valid(SN3193_sled_dev_sate->ena_gpio)) { rc = gpio_request(SN3193_sled_dev_sate->ena_gpio, "sn3193"); if (rc) { pr_err("%s gpio_request for %d failed rc=%d\n", __func__, SN3193_sled_dev_sate->ena_gpio, rc); return rc; } rc = gpio_direction_output(SN3193_sled_dev_sate->ena_gpio, 0); if (rc) { pr_err("%s set enable gpio direction fail\n",__func__); gpio_free(SN3193_sled_dev_sate->ena_gpio); return rc; } } else { pr_err("%s SN3193 ena_gpio invalid\n",__func__); return -1; } //client->dev.platform_data = &rgb_pdata; /* i2c pull up Regulator configuration */ SN3193_sled_dev_sate->vcc_i2c = regulator_get(&client->dev, "vcc_i2c_sn3193"); if (IS_ERR(SN3193_sled_dev_sate->vcc_i2c)) { pr_err("%s: Failed to get i2c regulator\n", __func__); rc = PTR_ERR(SN3193_sled_dev_sate->vcc_i2c); return -1;//retval; } if (regulator_count_voltages(SN3193_sled_dev_sate->vcc_i2c) > 0) { rc = regulator_set_voltage(SN3193_sled_dev_sate->vcc_i2c, 1800000, 1800000); if (rc) { pr_err("regulator set i2c voltage failed! rc = %d\n", rc); return rc; } } rc = regulator_enable(SN3193_sled_dev_sate->vcc_i2c); if (rc) { pr_err("Regulator vcc_i2c enable failed! rc = %d\n", rc); return rc; } SN3193_power(); msleep(100); if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { pr_err("%s : need I2C_FUNC_I2C\n", __func__); return -ENODEV; } SN3193_sled_dev_sate->gi2c_dev=client; sn3193_sled_dev = kzalloc(sizeof(struct SN3193_sled), GFP_KERNEL); if (sn3193_sled_dev == NULL) { dev_err(&client->dev, "failed to allocate memory for module data\n"); ret = -ENOMEM; goto err_exit; } pr_info("%s:sn3193 probe\n",__func__); sn3193_sled_dev->i2c_dev = client; sn3193_sled_dev->SN3193_miscdev.minor = MISC_DYNAMIC_MINOR; sn3193_sled_dev->SN3193_miscdev.name = "SN3193"; sn3193_sled_dev->SN3193_miscdev.fops = &SN3193_fops; ret = misc_register(&sn3193_sled_dev->SN3193_miscdev); if (ret) { pr_err("%s : misc_register failed\n", __FILE__); goto err_misc_register; } for(i = 0; i < 3; i ++ ) { if (led_classdev_register(&client->dev, &SN3193_lcds[i])) { printk(KERN_ERR "led_classdev_register failed of SN3193_lcds!\n"); goto err_classdev_register; } } ret = sysfs_create_group(&client->dev.kobj, &blink_attr_group); if (ret) { pr_err( "%s : sysfs_create_group failed!\n", __func__); goto err_group_register; } i2c_set_clientdata(client, sn3193_sled_dev); //SN3193_config_feature_sled(0); //dvt not breath //close, light as need SN3193_SetBrightness(RED_SLED, 0); SN3193_SetBrightness(GREEN_SLED, 0); SN3193_SetBrightness(BLUE_SLED, 0); SN3193_upData_sled(); SN3193_TurnOffOut_sled(); SN3193_enable_sled(0); /**************************test*********************/ //enable sled /*SN3193_enable_sled(1); SN3193_config_feature_sled(0x00); SN3193_workmod_sled(1); SN3193_setCurrent_sled(0x01);*/ //SN3193_enable_diff_color_sled(BLUE_SLED); //mod_timer(&SN3193_sled_dev_sate->gsled_last_timer, jiffies+5*HZ); /**************************test******************/ return 0; err_group_register: for(i = 0; i < 3; i ++ ) led_classdev_unregister(&SN3193_lcds[i]); err_classdev_register: misc_deregister(&sn3193_sled_dev->SN3193_miscdev); err_misc_register: kfree(sn3193_sled_dev); err_exit: return ret; }
static int max8952_pmic_probe(struct i2c_client *client, const struct i2c_device_id *i2c_id) { struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent); struct max8952_platform_data *pdata = dev_get_platdata(&client->dev); struct regulator_config config = { }; struct max8952_data *max8952; struct regulator_dev *rdev; int ret = 0, err = 0; if (client->dev.of_node) pdata = max8952_parse_dt(&client->dev); if (!pdata) { dev_err(&client->dev, "Require the platform data\n"); return -EINVAL; } if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE)) return -EIO; max8952 = devm_kzalloc(&client->dev, sizeof(struct max8952_data), GFP_KERNEL); if (!max8952) return -ENOMEM; max8952->client = client; max8952->pdata = pdata; config.dev = &client->dev; config.init_data = pdata->reg_data; config.driver_data = max8952; config.of_node = client->dev.of_node; config.ena_gpio = pdata->gpio_en; if (client->dev.of_node) config.ena_gpio_initialized = true; if (pdata->reg_data->constraints.boot_on) config.ena_gpio_flags |= GPIOF_OUT_INIT_HIGH; rdev = devm_regulator_register(&client->dev, ®ulator, &config); if (IS_ERR(rdev)) { ret = PTR_ERR(rdev); dev_err(&client->dev, "regulator init failed (%d)\n", ret); return ret; } max8952->vid0 = pdata->default_mode & 0x1; max8952->vid1 = (pdata->default_mode >> 1) & 0x1; if (gpio_is_valid(pdata->gpio_vid0) && gpio_is_valid(pdata->gpio_vid1)) { unsigned long gpio_flags; gpio_flags = max8952->vid0 ? GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW; if (devm_gpio_request_one(&client->dev, pdata->gpio_vid0, gpio_flags, "MAX8952 VID0")) err = 1; gpio_flags = max8952->vid1 ? GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW; if (devm_gpio_request_one(&client->dev, pdata->gpio_vid1, gpio_flags, "MAX8952 VID1")) err = 2; } else err = 3; if (err) { dev_warn(&client->dev, "VID0/1 gpio invalid: " "DVS not available.\n"); max8952->vid0 = 0; max8952->vid1 = 0; /* Mark invalid */ pdata->gpio_vid0 = -1; pdata->gpio_vid1 = -1; /* Disable Pulldown of EN only */ max8952_write_reg(max8952, MAX8952_REG_CONTROL, 0x60); dev_err(&client->dev, "DVS modes disabled because VID0 and VID1" " do not have proper controls.\n"); } else { /* * Disable Pulldown on EN, VID0, VID1 to reduce * leakage current of MAX8952 assuming that MAX8952 * is turned on (EN==1). Note that without having VID0/1 * properly connected, turning pulldown off can be * problematic. Thus, turn this off only when they are * controllable by GPIO. */ max8952_write_reg(max8952, MAX8952_REG_CONTROL, 0x0); } max8952_write_reg(max8952, MAX8952_REG_MODE0, (max8952_read_reg(max8952, MAX8952_REG_MODE0) & 0xC0) | (pdata->dvs_mode[0] & 0x3F)); max8952_write_reg(max8952, MAX8952_REG_MODE1, (max8952_read_reg(max8952, MAX8952_REG_MODE1) & 0xC0) | (pdata->dvs_mode[1] & 0x3F)); max8952_write_reg(max8952, MAX8952_REG_MODE2, (max8952_read_reg(max8952, MAX8952_REG_MODE2) & 0xC0) | (pdata->dvs_mode[2] & 0x3F)); max8952_write_reg(max8952, MAX8952_REG_MODE3, (max8952_read_reg(max8952, MAX8952_REG_MODE3) & 0xC0) | (pdata->dvs_mode[3] & 0x3F)); max8952_write_reg(max8952, MAX8952_REG_SYNC, (max8952_read_reg(max8952, MAX8952_REG_SYNC) & 0x3F) | ((pdata->sync_freq & 0x3) << 6)); max8952_write_reg(max8952, MAX8952_REG_RAMP, (max8952_read_reg(max8952, MAX8952_REG_RAMP) & 0x1F) | ((pdata->ramp_speed & 0x7) << 5)); i2c_set_clientdata(client, max8952); return 0; }
static int tpo_td043_probe(struct spi_device *spi) { struct panel_drv_data *ddata; struct omap_dss_device *dssdev; int r; dev_dbg(&spi->dev, "%s\n", __func__); spi->bits_per_word = 16; spi->mode = SPI_MODE_0; r = spi_setup(spi); if (r < 0) { dev_err(&spi->dev, "spi_setup failed: %d\n", r); return r; } ddata = devm_kzalloc(&spi->dev, sizeof(*ddata), GFP_KERNEL); if (ddata == NULL) return -ENOMEM; dev_set_drvdata(&spi->dev, ddata); ddata->spi = spi; if (!spi->dev.of_node) return -ENODEV; r = tpo_td043_probe_of(spi); if (r) return r; ddata->mode = TPO_R02_MODE_800x480; memcpy(ddata->gamma, tpo_td043_def_gamma, sizeof(ddata->gamma)); ddata->vcc_reg = devm_regulator_get(&spi->dev, "vcc"); if (IS_ERR(ddata->vcc_reg)) { dev_err(&spi->dev, "failed to get LCD VCC regulator\n"); r = PTR_ERR(ddata->vcc_reg); goto err_regulator; } if (gpio_is_valid(ddata->nreset_gpio)) { r = devm_gpio_request_one(&spi->dev, ddata->nreset_gpio, GPIOF_OUT_INIT_LOW, "lcd reset"); if (r < 0) { dev_err(&spi->dev, "couldn't request reset GPIO\n"); goto err_gpio_req; } } r = sysfs_create_group(&spi->dev.kobj, &tpo_td043_attr_group); if (r) { dev_err(&spi->dev, "failed to create sysfs files\n"); goto err_sysfs; } ddata->videomode = tpo_td043_timings; dssdev = &ddata->dssdev; dssdev->dev = &spi->dev; dssdev->driver = &tpo_td043_ops; dssdev->type = OMAP_DISPLAY_TYPE_DPI; dssdev->owner = THIS_MODULE; dssdev->panel.timings = ddata->videomode; r = omapdss_register_display(dssdev); if (r) { dev_err(&spi->dev, "Failed to register panel\n"); goto err_reg; } return 0; err_reg: sysfs_remove_group(&spi->dev.kobj, &tpo_td043_attr_group); err_sysfs: err_gpio_req: err_regulator: omap_dss_put_device(ddata->in); return r; }
static void omap_usbhs_init(struct device *dev) { struct usbhs_hcd_omap *omap = dev_get_drvdata(dev); struct usbhs_omap_platform_data *pdata = &omap->platdata; unsigned long flags = 0; unsigned reg; dev_dbg(dev, "starting TI HSUSB Controller\n"); pm_runtime_get_sync(dev); spin_lock_irqsave(&omap->lock, flags); if (pdata->ehci_data->phy_reset) { if (gpio_is_valid(pdata->ehci_data->reset_gpio_port[0])) { gpio_request(pdata->ehci_data->reset_gpio_port[0], "USB1 PHY reset"); gpio_direction_output (pdata->ehci_data->reset_gpio_port[0], 0); } if (gpio_is_valid(pdata->ehci_data->reset_gpio_port[1])) { gpio_request(pdata->ehci_data->reset_gpio_port[1], "USB2 PHY reset"); gpio_direction_output (pdata->ehci_data->reset_gpio_port[1], 0); } /* Hold the PHY in RESET for enough time till DIR is high */ udelay(10); } omap->usbhs_rev = usbhs_read(omap->uhh_base, OMAP_UHH_REVISION); dev_dbg(dev, "OMAP UHH_REVISION 0x%x\n", omap->usbhs_rev); /* * Really enable the port clocks * first call of pm_runtime_get_sync does not enable these * port clocks; because omap->usbhs_rev was not available * This omap->usbhs_rev is available now! */ usbhs_runtime_resume(dev); reg = usbhs_read(omap->uhh_base, OMAP_UHH_HOSTCONFIG); /* setup ULPI bypass and burst configurations */ reg |= (OMAP_UHH_HOSTCONFIG_INCR4_BURST_EN | OMAP_UHH_HOSTCONFIG_INCR8_BURST_EN | OMAP_UHH_HOSTCONFIG_INCR16_BURST_EN); /* Keep ENA_INCR_ALIGN = 0: Known to cause OCP delays */ reg &= ~OMAP_UHH_HOSTCONFIG_INCRX_ALIGN_EN; if (is_omap_usbhs_rev1(omap)) { if (pdata->port_mode[0] == OMAP_USBHS_PORT_MODE_UNUSED) reg &= ~OMAP_UHH_HOSTCONFIG_P1_CONNECT_STATUS; if (pdata->port_mode[1] == OMAP_USBHS_PORT_MODE_UNUSED) reg &= ~OMAP_UHH_HOSTCONFIG_P2_CONNECT_STATUS; if (pdata->port_mode[2] == OMAP_USBHS_PORT_MODE_UNUSED) reg &= ~OMAP_UHH_HOSTCONFIG_P3_CONNECT_STATUS; /* Bypass the TLL module for PHY mode operation */ if (cpu_is_omap3430() && (omap_rev() <= OMAP3430_REV_ES2_1)) { dev_dbg(dev, "OMAP3 ES version <= ES2.1\n"); if (is_ehci_phy_mode(pdata->port_mode[0]) || is_ehci_phy_mode(pdata->port_mode[1]) || is_ehci_phy_mode(pdata->port_mode[2])) reg &= ~OMAP_UHH_HOSTCONFIG_ULPI_BYPASS; else reg |= OMAP_UHH_HOSTCONFIG_ULPI_BYPASS; } else { dev_dbg(dev, "OMAP3 ES version > ES2.1\n"); if (is_ehci_phy_mode(pdata->port_mode[0])) reg &= ~OMAP_UHH_HOSTCONFIG_ULPI_P1_BYPASS; else reg |= OMAP_UHH_HOSTCONFIG_ULPI_P1_BYPASS; if (is_ehci_phy_mode(pdata->port_mode[1])) reg &= ~OMAP_UHH_HOSTCONFIG_ULPI_P2_BYPASS; else reg |= OMAP_UHH_HOSTCONFIG_ULPI_P2_BYPASS; if (is_ehci_phy_mode(pdata->port_mode[2])) reg &= ~OMAP_UHH_HOSTCONFIG_ULPI_P3_BYPASS; else reg |= OMAP_UHH_HOSTCONFIG_ULPI_P3_BYPASS; } } else if (is_omap_usbhs_rev2(omap)) { /* Clear port mode fields for PHY mode*/ reg &= ~OMAP4_P1_MODE_CLEAR; reg &= ~OMAP4_P2_MODE_CLEAR; if (is_ehci_tll_mode(pdata->port_mode[0]) || (is_ohci_port(pdata->port_mode[0]))) reg |= OMAP4_P1_MODE_TLL; else if (is_ehci_hsic_mode(pdata->port_mode[0])) reg |= OMAP4_P1_MODE_HSIC; if (is_ehci_tll_mode(pdata->port_mode[1]) || (is_ohci_port(pdata->port_mode[1]))) reg |= OMAP4_P2_MODE_TLL; else if (is_ehci_hsic_mode(pdata->port_mode[1])) reg |= OMAP4_P2_MODE_HSIC; } usbhs_write(omap->uhh_base, OMAP_UHH_HOSTCONFIG, reg); dev_dbg(dev, "UHH setup done, uhh_hostconfig=%x\n", reg); if (is_ehci_tll_mode(pdata->port_mode[0]) || is_ehci_tll_mode(pdata->port_mode[1]) || is_ehci_tll_mode(pdata->port_mode[2]) || (is_ohci_port(pdata->port_mode[0])) || (is_ohci_port(pdata->port_mode[1])) || (is_ohci_port(pdata->port_mode[2]))) { /* Enable UTMI mode for required TLL channels */ if (is_omap_usbhs_rev2(omap)) usbhs_omap_tll_init(dev, OMAP_REV2_TLL_CHANNEL_COUNT); else usbhs_omap_tll_init(dev, OMAP_TLL_CHANNEL_COUNT); } if (pdata->ehci_data->phy_reset) { /* Hold the PHY in RESET for enough time till * PHY is settled and ready */ udelay(10); if (gpio_is_valid(pdata->ehci_data->reset_gpio_port[0])) gpio_set_value (pdata->ehci_data->reset_gpio_port[0], 1); if (gpio_is_valid(pdata->ehci_data->reset_gpio_port[1])) gpio_set_value (pdata->ehci_data->reset_gpio_port[1], 1); } spin_unlock_irqrestore(&omap->lock, flags); pm_runtime_put_sync(dev); }
static int bluetooth_set_power(void *data, enum rfkill_user_states state) { int ret = 0; int irq; /* BT Host Wake IRQ */ irq = IRQ_WLAN_BT_HOST_WAKE; switch (state) { case RFKILL_USER_STATE_UNBLOCKED: printk("[BT] Device Powering ON \n");//pr_debug if (!loaded) break; /* Bluetooth over SDIO */ m8_bt_power(1, sdio); msleep(100); if (sdio && m8_checkse()) sdhci_s3c_force_presence_change(&s3c_device_hsmmc0); msleep(100); if (!sdio) s3c_setup_uart_cfg_gpio(1); #if 0 // uart not work now if (gpio_is_valid(GPIO_WLAN_BT_EN)) { printk("[BT] gpio_is_valid(GPIO_WLAN_BT_EN)\n"); gpio_direction_output(GPIO_WLAN_BT_EN, GPIO_LEVEL_HIGH); } if (gpio_is_valid(GPIO_BT_nRST)) { gpio_direction_output(GPIO_BT_nRST, GPIO_LEVEL_LOW); printk("[BT] gpio_is_valid(GPIO_BT_nRST)\n"); } printk("[BT] GPIO_BT_nRST = %d\n", gpio_get_value(GPIO_BT_nRST));//pr_debug /* Set GPIO_BT_WLAN_REG_ON high */ s3c_gpio_setpull(GPIO_WLAN_BT_EN, S3C_GPIO_PULL_NONE); gpio_set_value(GPIO_WLAN_BT_EN, GPIO_LEVEL_HIGH); s3c_gpio_slp_cfgpin(GPIO_WLAN_BT_EN, S3C_GPIO_SLP_OUT1); s3c_gpio_slp_setpull_updown(GPIO_WLAN_BT_EN, S3C_GPIO_PULL_NONE); printk("[BT] GPIO_WLAN_BT_EN = %d\n", gpio_get_value(GPIO_WLAN_BT_EN)); /* * FIXME sleep should be enabled disabled since the device is * not booting if its enabled */ /* * 100msec, delay between reg_on & rst. * (powerup sequence) */ msleep(500);//100); /* Set GPIO_BT_nRST high */ s3c_gpio_setpull(GPIO_BT_nRST, S3C_GPIO_PULL_NONE); gpio_set_value(GPIO_BT_nRST, GPIO_LEVEL_HIGH); s3c_gpio_slp_cfgpin(GPIO_BT_nRST, S3C_GPIO_SLP_OUT1); s3c_gpio_slp_setpull_updown(GPIO_BT_nRST, S3C_GPIO_PULL_NONE); printk("[BT] GPIO_BT_nRST = %d\n", gpio_get_value(GPIO_BT_nRST));//pr_debug /* * 50msec, delay after bt rst * (libertas powerup sequence) */ msleep(200);//50); //ret = enable_irq_wake(irq); //if (ret < 0) // pr_err("[BT] set wakeup src failed\n"); #endif enable_irq(irq); break; case RFKILL_USER_STATE_SOFT_BLOCKED: printk("[BT] Device Powering OFF\n"); if (!loaded) break; /* Bluetooth over SDIO */ m8_bt_power(0, sdio); msleep(100); if (sdio && m8_checkse()) sdhci_s3c_force_presence_change(&s3c_device_hsmmc0); //if (!sdio) // s3c_reset_uart_cfg_gpio(1); //ret = disable_irq_wake(irq); //if (ret < 0) // pr_err("[BT] unset wakeup src failed\n"); disable_irq(irq); wake_unlock(&rfkill_wake_lock); printk("[BT] wake_unlock rfkill_wake_lock\n"); #if 0 // UART s3c_gpio_setpull(GPIO_BT_nRST, S3C_GPIO_PULL_NONE); gpio_set_value(GPIO_BT_nRST, GPIO_LEVEL_LOW); s3c_gpio_slp_cfgpin(GPIO_BT_nRST, S3C_GPIO_SLP_OUT0); s3c_gpio_slp_setpull_updown(GPIO_BT_nRST, S3C_GPIO_PULL_NONE); printk("[BT] GPIO_BT_nRST = %d\n", gpio_get_value(GPIO_BT_nRST));//pr_debug if (gpio_get_value(GPIO_BT_nRST) == 0) { //GPIO_WLAN_nRST s3c_gpio_setpull(GPIO_WLAN_BT_EN, S3C_GPIO_PULL_NONE); gpio_set_value(GPIO_WLAN_BT_EN, GPIO_LEVEL_LOW); s3c_gpio_slp_cfgpin(GPIO_WLAN_BT_EN, S3C_GPIO_SLP_OUT0); s3c_gpio_slp_setpull_updown(GPIO_WLAN_BT_EN, S3C_GPIO_PULL_NONE); printk("[BT] GPIO_WLAN_BT_EN = %d\n", gpio_get_value(GPIO_WLAN_BT_EN)); } #endif break; default: printk(KERN_ERR "[BT] Bad bluetooth rfkill state %d\n", state);//pr_err } return 0; }
/* Consider only one slot : slot 0 */ void at91_add_device_mci(short mmc_id, struct atmel_mci_platform_data *data) { resource_size_t start; if (!data) return; /* need bus_width */ if (!data->bus_width) return; /* input/irq */ if (gpio_is_valid(data->detect_pin)) { at91_set_gpio_input(data->detect_pin, 1); at91_set_deglitch(data->detect_pin, 1); } if (gpio_is_valid(data->wp_pin)) at91_set_gpio_input(data->wp_pin, 1); if (mmc_id == 0) { /* MCI0 */ start = AT91SAM9263_BASE_MCI0; /* CLK */ at91_set_A_periph(AT91_PIN_PA12, 0); if (data->slot_b) { /* CMD */ at91_set_A_periph(AT91_PIN_PA16, 1); /* DAT0, maybe DAT1..DAT3 */ at91_set_A_periph(AT91_PIN_PA17, 1); if (data->bus_width == 4) { at91_set_A_periph(AT91_PIN_PA18, 1); at91_set_A_periph(AT91_PIN_PA19, 1); at91_set_A_periph(AT91_PIN_PA20, 1); } } else { /* CMD */ at91_set_A_periph(AT91_PIN_PA1, 1); /* DAT0, maybe DAT1..DAT3 */ at91_set_A_periph(AT91_PIN_PA0, 1); if (data->bus_width == 4) { at91_set_A_periph(AT91_PIN_PA3, 1); at91_set_A_periph(AT91_PIN_PA4, 1); at91_set_A_periph(AT91_PIN_PA5, 1); } } } else { /* MCI1 */ start = AT91SAM9263_BASE_MCI1; /* CLK */ at91_set_A_periph(AT91_PIN_PA6, 0); if (data->slot_b) { /* CMD */ at91_set_A_periph(AT91_PIN_PA21, 1); /* DAT0, maybe DAT1..DAT3 */ at91_set_A_periph(AT91_PIN_PA22, 1); if (data->bus_width == 4) { at91_set_A_periph(AT91_PIN_PA23, 1); at91_set_A_periph(AT91_PIN_PA24, 1); at91_set_A_periph(AT91_PIN_PA25, 1); } } else { /* CMD */ at91_set_A_periph(AT91_PIN_PA7, 1); /* DAT0, maybe DAT1..DAT3 */ at91_set_A_periph(AT91_PIN_PA8, 1); if (data->bus_width == 4) { at91_set_A_periph(AT91_PIN_PA9, 1); at91_set_A_periph(AT91_PIN_PA10, 1); at91_set_A_periph(AT91_PIN_PA11, 1); } } } add_generic_device("atmel_mci", mmc_id, NULL, start, 4096, IORESOURCE_MEM, data); }
static int rfkill_gpio_probe(struct platform_device *pdev) { struct rfkill_gpio_data *rfkill; struct rfkill_gpio_platform_data *pdata = pdev->dev.platform_data; int ret = 0; int len = 0; if (!pdata) { pr_warn("%s: No platform data specified\n", __func__); return -EINVAL; } /* */ if (!pdata->name || (!gpio_is_valid(pdata->reset_gpio) && !gpio_is_valid(pdata->shutdown_gpio))) { pr_warn("%s: invalid platform data\n", __func__); return -EINVAL; } rfkill = kzalloc(sizeof(*rfkill), GFP_KERNEL); if (!rfkill) return -ENOMEM; if (pdata->gpio_runtime_setup) { ret = pdata->gpio_runtime_setup(pdev); if (ret) { pr_warn("%s: can't set up gpio\n", __func__); goto fail_alloc; } } rfkill->pdata = pdata; len = strlen(pdata->name); rfkill->reset_name = kzalloc(len + 7, GFP_KERNEL); if (!rfkill->reset_name) { ret = -ENOMEM; goto fail_alloc; } rfkill->shutdown_name = kzalloc(len + 10, GFP_KERNEL); if (!rfkill->shutdown_name) { ret = -ENOMEM; goto fail_reset_name; } snprintf(rfkill->reset_name, len + 6 , "%s_reset", pdata->name); snprintf(rfkill->shutdown_name, len + 9, "%s_shutdown", pdata->name); if (pdata->power_clk_name) { rfkill->pwr_clk = clk_get(&pdev->dev, pdata->power_clk_name); if (IS_ERR(rfkill->pwr_clk)) { pr_warn("%s: can't find pwr_clk.\n", __func__); goto fail_shutdown_name; } } if (gpio_is_valid(pdata->reset_gpio)) { ret = gpio_request(pdata->reset_gpio, rfkill->reset_name); if (ret) { pr_warn("%s: failed to get reset gpio.\n", __func__); goto fail_clock; } } if (gpio_is_valid(pdata->shutdown_gpio)) { ret = gpio_request(pdata->shutdown_gpio, rfkill->shutdown_name); if (ret) { pr_warn("%s: failed to get shutdown gpio.\n", __func__); goto fail_reset; } } rfkill->rfkill_dev = rfkill_alloc(pdata->name, &pdev->dev, pdata->type, &rfkill_gpio_ops, rfkill); if (!rfkill->rfkill_dev) goto fail_shutdown; ret = rfkill_register(rfkill->rfkill_dev); if (ret < 0) goto fail_rfkill; platform_set_drvdata(pdev, rfkill); dev_info(&pdev->dev, "%s device registered.\n", pdata->name); return 0; fail_rfkill: rfkill_destroy(rfkill->rfkill_dev); fail_shutdown: if (gpio_is_valid(pdata->shutdown_gpio)) gpio_free(pdata->shutdown_gpio); fail_reset: if (gpio_is_valid(pdata->reset_gpio)) gpio_free(pdata->reset_gpio); fail_clock: if (rfkill->pwr_clk) clk_put(rfkill->pwr_clk); fail_shutdown_name: kfree(rfkill->shutdown_name); fail_reset_name: kfree(rfkill->reset_name); fail_alloc: kfree(rfkill); return ret; }
static int bluetooth_set_power(void *data, enum rfkill_user_states state) { int ret = 0; int irq; /* BT Host Wake IRQ */ irq = IRQ_BT_HOST_WAKE; switch (state) { case RFKILL_USER_STATE_UNBLOCKED: pr_debug("[BT] Device Powering ON\n"); s3c_setup_uart_cfg_gpio(0); if (gpio_is_valid(GPIO_WLAN_BT_EN)) gpio_direction_output(GPIO_WLAN_BT_EN, GPIO_LEVEL_HIGH); if (gpio_is_valid(GPIO_BT_nRST)) gpio_direction_output(GPIO_BT_nRST, GPIO_LEVEL_LOW); pr_debug("[BT] GPIO_BT_nRST = %d\n", gpio_get_value(GPIO_BT_nRST)); /* Set GPIO_BT_WLAN_REG_ON high */ s3c_gpio_setpull(GPIO_WLAN_BT_EN, S3C_GPIO_PULL_NONE); gpio_set_value(GPIO_WLAN_BT_EN, GPIO_LEVEL_HIGH); s3c_gpio_slp_cfgpin(GPIO_WLAN_BT_EN, S3C_GPIO_SLP_OUT1); s3c_gpio_slp_setpull_updown(GPIO_WLAN_BT_EN, S3C_GPIO_PULL_NONE); pr_debug("[BT] GPIO_WLAN_BT_EN = %d\n", gpio_get_value(GPIO_WLAN_BT_EN)); /* * FIXME sleep should be enabled disabled since the device is * not booting if its enabled */ /* * 100msec, delay between reg_on & rst. * (bcm4329 powerup sequence) */ msleep(100); /* Set GPIO_BT_nRST high */ s3c_gpio_setpull(GPIO_BT_nRST, S3C_GPIO_PULL_NONE); gpio_set_value(GPIO_BT_nRST, GPIO_LEVEL_HIGH); s3c_gpio_slp_cfgpin(GPIO_BT_nRST, S3C_GPIO_SLP_OUT1); s3c_gpio_slp_setpull_updown(GPIO_BT_nRST, S3C_GPIO_PULL_NONE); pr_debug("[BT] GPIO_BT_nRST = %d\n", gpio_get_value(GPIO_BT_nRST)); /* * 50msec, delay after bt rst * (bcm4329 powerup sequence) */ msleep(50); ret = enable_irq_wake(irq); if (ret < 0) pr_err("[BT] set wakeup src failed\n"); enable_irq(irq); break; case RFKILL_USER_STATE_SOFT_BLOCKED: pr_debug("[BT] Device Powering OFF\n"); bt_is_running = 0; ret = disable_irq_wake(irq); if (ret < 0) pr_err("[BT] unset wakeup src failed\n"); disable_irq(irq); wake_unlock(&rfkill_wake_lock); s3c_gpio_setpull(GPIO_BT_nRST, S3C_GPIO_PULL_NONE); gpio_set_value(GPIO_BT_nRST, GPIO_LEVEL_LOW); s3c_gpio_slp_cfgpin(GPIO_BT_nRST, S3C_GPIO_SLP_OUT0); s3c_gpio_slp_setpull_updown(GPIO_BT_nRST, S3C_GPIO_PULL_NONE); pr_debug("[BT] GPIO_BT_nRST = %d\n", gpio_get_value(GPIO_BT_nRST)); if (gpio_get_value(GPIO_WLAN_nRST) == 0) { s3c_gpio_setpull(GPIO_WLAN_BT_EN, S3C_GPIO_PULL_NONE); gpio_set_value(GPIO_WLAN_BT_EN, GPIO_LEVEL_LOW); s3c_gpio_slp_cfgpin(GPIO_WLAN_BT_EN, S3C_GPIO_SLP_OUT0); s3c_gpio_slp_setpull_updown(GPIO_WLAN_BT_EN, S3C_GPIO_PULL_NONE); pr_debug("[BT] GPIO_WLAN_BT_EN = %d\n", gpio_get_value(GPIO_WLAN_BT_EN)); } break; default: pr_err("[BT] Bad bluetooth rfkill state %d\n", state); } return 0; }
/* * Emits the raw flux value for the x, y, or z axis. */ static int ak8975_read_axis(struct iio_dev *indio_dev, int index, int *val) { struct ak8975_data *data = iio_priv(indio_dev); struct i2c_client *client = data->client; int ret; mutex_lock(&data->lock); /* Set up the device for taking a sample. */ ret = ak8975_write_data(client, AK8975_REG_CNTL, AK8975_REG_CNTL_MODE_ONCE, AK8975_REG_CNTL_MODE_MASK, AK8975_REG_CNTL_MODE_SHIFT); if (ret < 0) { dev_err(&client->dev, "Error in setting operating mode\n"); goto exit; } /* Wait for the conversion to complete. */ if (data->eoc_irq) ret = wait_conversion_complete_interrupt(data); else if (gpio_is_valid(data->eoc_gpio)) ret = wait_conversion_complete_gpio(data); else ret = wait_conversion_complete_polled(data); if (ret < 0) goto exit; /* This will be executed only for non-interrupt based waiting case */ if (ret & AK8975_REG_ST1_DRDY_MASK) { ret = i2c_smbus_read_byte_data(client, AK8975_REG_ST2); if (ret < 0) { dev_err(&client->dev, "Error in reading ST2\n"); goto exit; } if (ret & (AK8975_REG_ST2_DERR_MASK | AK8975_REG_ST2_HOFL_MASK)) { dev_err(&client->dev, "ST2 status error 0x%x\n", ret); ret = -EINVAL; goto exit; } } /* Read the flux value from the appropriate register (the register is specified in the iio device attributes). */ ret = i2c_smbus_read_word_data(client, ak8975_index_to_reg[index]); if (ret < 0) { dev_err(&client->dev, "Read axis data fails\n"); goto exit; } mutex_unlock(&data->lock); /* Clamp to valid range. */ *val = clamp_t(s16, ret, -4096, 4095); return IIO_VAL_INT; exit: mutex_unlock(&data->lock); return ret; }
static int sirfsoc_uart_probe(struct platform_device *pdev) { struct device_node *np = pdev->dev.of_node; struct sirfsoc_uart_port *sirfport; struct uart_port *port; struct resource *res; int ret; struct dma_slave_config slv_cfg = { .src_maxburst = 1, }; struct dma_slave_config tx_slv_cfg = { .dst_maxburst = 2, }; const struct of_device_id *match; match = of_match_node(sirfsoc_uart_ids, np); sirfport = devm_kzalloc(&pdev->dev, sizeof(*sirfport), GFP_KERNEL); if (!sirfport) { ret = -ENOMEM; goto err; } sirfport->port.line = of_alias_get_id(np, "serial"); sirf_ports[sirfport->port.line] = sirfport; sirfport->port.iotype = UPIO_MEM; sirfport->port.flags = UPF_BOOT_AUTOCONF; port = &sirfport->port; port->dev = &pdev->dev; port->private_data = sirfport; sirfport->uart_reg = (struct sirfsoc_uart_register *)match->data; sirfport->hw_flow_ctrl = of_property_read_bool(np, "uart-has-rtscts") || of_property_read_bool(np, "sirf,uart-has-rtscts") /* deprecated */; if (of_device_is_compatible(np, "sirf,prima2-uart") || of_device_is_compatible(np, "sirf,atlas7-uart")) sirfport->uart_reg->uart_type = SIRF_REAL_UART; if (of_device_is_compatible(np, "sirf,prima2-usp-uart") || of_device_is_compatible(np, "sirf,atlas7-usp-uart")) { sirfport->uart_reg->uart_type = SIRF_USP_UART; if (!sirfport->hw_flow_ctrl) goto usp_no_flow_control; if (of_find_property(np, "cts-gpios", NULL)) sirfport->cts_gpio = of_get_named_gpio(np, "cts-gpios", 0); else sirfport->cts_gpio = -1; if (of_find_property(np, "rts-gpios", NULL)) sirfport->rts_gpio = of_get_named_gpio(np, "rts-gpios", 0); else sirfport->rts_gpio = -1; if ((!gpio_is_valid(sirfport->cts_gpio) || !gpio_is_valid(sirfport->rts_gpio))) { ret = -EINVAL; dev_err(&pdev->dev, "Usp flow control must have cts and rts gpio"); goto err; } ret = devm_gpio_request(&pdev->dev, sirfport->cts_gpio, "usp-cts-gpio"); if (ret) { dev_err(&pdev->dev, "Unable request cts gpio"); goto err; } gpio_direction_input(sirfport->cts_gpio); ret = devm_gpio_request(&pdev->dev, sirfport->rts_gpio, "usp-rts-gpio"); if (ret) { dev_err(&pdev->dev, "Unable request rts gpio"); goto err; } gpio_direction_output(sirfport->rts_gpio, 1); } usp_no_flow_control: if (of_device_is_compatible(np, "sirf,atlas7-uart") || of_device_is_compatible(np, "sirf,atlas7-usp-uart")) sirfport->is_atlas7 = true; if (of_property_read_u32(np, "fifosize", &port->fifosize)) { dev_err(&pdev->dev, "Unable to find fifosize in uart node.\n"); ret = -EFAULT; goto err; } res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (res == NULL) { dev_err(&pdev->dev, "Insufficient resources.\n"); ret = -EFAULT; goto err; } port->mapbase = res->start; port->membase = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!port->membase) { dev_err(&pdev->dev, "Cannot remap resource.\n"); ret = -ENOMEM; goto err; } res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); if (res == NULL) { dev_err(&pdev->dev, "Insufficient resources.\n"); ret = -EFAULT; goto err; } port->irq = res->start; sirfport->clk = devm_clk_get(&pdev->dev, NULL); if (IS_ERR(sirfport->clk)) { ret = PTR_ERR(sirfport->clk); goto err; } port->uartclk = clk_get_rate(sirfport->clk); port->ops = &sirfsoc_uart_ops; spin_lock_init(&port->lock); platform_set_drvdata(pdev, sirfport); ret = uart_add_one_port(&sirfsoc_uart_drv, port); if (ret != 0) { dev_err(&pdev->dev, "Cannot add UART port(%d).\n", pdev->id); goto err; } sirfport->rx_dma_chan = dma_request_slave_channel(port->dev, "rx"); sirfport->rx_dma_items.xmit.buf = dma_alloc_coherent(port->dev, SIRFSOC_RX_DMA_BUF_SIZE, &sirfport->rx_dma_items.dma_addr, GFP_KERNEL); if (!sirfport->rx_dma_items.xmit.buf) { dev_err(port->dev, "Uart alloc bufa failed\n"); ret = -ENOMEM; goto alloc_coherent_err; } sirfport->rx_dma_items.xmit.head = sirfport->rx_dma_items.xmit.tail = 0; if (sirfport->rx_dma_chan) dmaengine_slave_config(sirfport->rx_dma_chan, &slv_cfg); sirfport->tx_dma_chan = dma_request_slave_channel(port->dev, "tx"); if (sirfport->tx_dma_chan) dmaengine_slave_config(sirfport->tx_dma_chan, &tx_slv_cfg); if (sirfport->rx_dma_chan) { hrtimer_init(&sirfport->hrt, CLOCK_MONOTONIC, HRTIMER_MODE_REL); sirfport->hrt.function = sirfsoc_uart_rx_dma_hrtimer_callback; sirfport->is_hrt_enabled = false; } return 0; alloc_coherent_err: dma_free_coherent(port->dev, SIRFSOC_RX_DMA_BUF_SIZE, sirfport->rx_dma_items.xmit.buf, sirfport->rx_dma_items.dma_addr); dma_release_channel(sirfport->rx_dma_chan); err: return ret; } static int sirfsoc_uart_remove(struct platform_device *pdev) { struct sirfsoc_uart_port *sirfport = platform_get_drvdata(pdev); struct uart_port *port = &sirfport->port; uart_remove_one_port(&sirfsoc_uart_drv, port); if (sirfport->rx_dma_chan) { dmaengine_terminate_all(sirfport->rx_dma_chan); dma_release_channel(sirfport->rx_dma_chan); dma_free_coherent(port->dev, SIRFSOC_RX_DMA_BUF_SIZE, sirfport->rx_dma_items.xmit.buf, sirfport->rx_dma_items.dma_addr); } if (sirfport->tx_dma_chan) { dmaengine_terminate_all(sirfport->tx_dma_chan); dma_release_channel(sirfport->tx_dma_chan); } return 0; } #ifdef CONFIG_PM_SLEEP static int sirfsoc_uart_suspend(struct device *pdev) { struct sirfsoc_uart_port *sirfport = dev_get_drvdata(pdev); struct uart_port *port = &sirfport->port; uart_suspend_port(&sirfsoc_uart_drv, port); return 0; } static int sirfsoc_uart_resume(struct device *pdev) { struct sirfsoc_uart_port *sirfport = dev_get_drvdata(pdev); struct uart_port *port = &sirfport->port; uart_resume_port(&sirfsoc_uart_drv, port); return 0; } #endif static const struct dev_pm_ops sirfsoc_uart_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(sirfsoc_uart_suspend, sirfsoc_uart_resume) }; static struct platform_driver sirfsoc_uart_driver = { .probe = sirfsoc_uart_probe, .remove = sirfsoc_uart_remove, .driver = { .name = SIRFUART_PORT_NAME, .of_match_table = sirfsoc_uart_ids, .pm = &sirfsoc_uart_pm_ops, }, }; static int __init sirfsoc_uart_init(void) { int ret = 0; ret = uart_register_driver(&sirfsoc_uart_drv); if (ret) goto out; ret = platform_driver_register(&sirfsoc_uart_driver); if (ret) uart_unregister_driver(&sirfsoc_uart_drv); out: return ret; } module_init(sirfsoc_uart_init); static void __exit sirfsoc_uart_exit(void) { platform_driver_unregister(&sirfsoc_uart_driver); uart_unregister_driver(&sirfsoc_uart_drv); }
static int __devinit gpio_keys_setup_key(struct platform_device *pdev, struct input_dev *input, struct gpio_button_data *bdata, const 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(button->gpio, desc); if (error < 0) { dev_err(dev, "Failed to request GPIO %d, error %d\n", button->gpio, error); return error; } error = gpio_direction_input(button->gpio); if (error < 0) { dev_err(dev, "Failed to configure direction for GPIO %d, error %d\n", button->gpio, error); goto fail; } 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; } 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; 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; 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; }
void dsi_panel_reset(struct mdss_panel_data *pdata, int enable) { if (pdata == NULL) { pr_err("%s: Invalid input data\n", __func__); return; } if (!gpio_is_valid(panel_private->disp_en_gpio)) { pr_debug("%s:%d, reset line not configured\n", __func__, __LINE__); } if (!gpio_is_valid(panel_private->rst_gpio)) { pr_debug("%s:%d, reset line not configured\n", __func__, __LINE__); return; } pr_debug("%s: enable = %d\n", __func__, enable); if (enable) { dsi_panel_power(1); gpio_request(panel_private->rst_gpio, "panel_reset"); gpio_set_value(panel_private->rst_gpio, 1); /* * these delay values are by experiments currently, will need * to move to device tree late */ msleep(20); gpio_set_value(panel_private->rst_gpio, 0); udelay(200); gpio_set_value(panel_private->rst_gpio, 1); msleep(20); if (gpio_is_valid(panel_private->disp_en_gpio)) { gpio_request(panel_private->disp_en_gpio, "panel_enable"); gpio_set_value(panel_private->disp_en_gpio, 1); } if (gpio_is_valid(panel_private->video_mode_gpio)) { gpio_request(panel_private->video_mode_gpio, "panel_video_mdoe"); if (pdata->panel_info.mipi.mode == DSI_VIDEO_MODE) gpio_set_value(panel_private->video_mode_gpio, 1); else gpio_set_value(panel_private->video_mode_gpio, 0); } } else { gpio_set_value(panel_private->rst_gpio, 0); gpio_free(panel_private->rst_gpio); if (gpio_is_valid(panel_private->disp_en_gpio)) { gpio_set_value(panel_private->disp_en_gpio, 0); gpio_free(panel_private->disp_en_gpio); } if (gpio_is_valid(panel_private->video_mode_gpio)) gpio_free(panel_private->video_mode_gpio); dsi_panel_power(0); } }
/* * Probe for the device */ static int __init at91_mci_probe(struct platform_device *pdev) { struct mmc_host *mmc; struct at91mci_host *host; struct resource *res; int ret; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) return -ENXIO; if (!request_mem_region(res->start, resource_size(res), DRIVER_NAME)) return -EBUSY; mmc = mmc_alloc_host(sizeof(struct at91mci_host), &pdev->dev); if (!mmc) { ret = -ENOMEM; dev_dbg(&pdev->dev, "couldn't allocate mmc host\n"); goto fail6; } mmc->ops = &at91_mci_ops; mmc->f_min = 375000; mmc->f_max = 25000000; mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34; mmc->caps = 0; mmc->max_blk_size = MCI_MAXBLKSIZE; mmc->max_blk_count = MCI_BLKATONCE; mmc->max_req_size = MCI_BUFSIZE; mmc->max_segs = MCI_BLKATONCE; mmc->max_seg_size = MCI_BUFSIZE; host = mmc_priv(mmc); host->mmc = mmc; host->bus_mode = 0; host->board = pdev->dev.platform_data; if (host->board->wire4) { if (at91mci_is_mci1rev2xx()) mmc->caps |= MMC_CAP_4_BIT_DATA; else dev_warn(&pdev->dev, "4 wire bus mode not supported" " - using 1 wire\n"); } host->buffer = dma_alloc_coherent(&pdev->dev, MCI_BUFSIZE, &host->physical_address, GFP_KERNEL); if (!host->buffer) { ret = -ENOMEM; dev_err(&pdev->dev, "Can't allocate transmit buffer\n"); goto fail5; } /* Add SDIO capability when available */ if (at91mci_is_mci1rev2xx()) { /* at91mci MCI1 rev2xx sdio interrupt erratum */ if (host->board->wire4 || !host->board->slot_b) mmc->caps |= MMC_CAP_SDIO_IRQ; } /* * Reserve GPIOs ... board init code makes sure these pins are set * up as GPIOs with the right direction (input, except for vcc) */ if (gpio_is_valid(host->board->det_pin)) { ret = gpio_request(host->board->det_pin, "mmc_detect"); if (ret < 0) { dev_dbg(&pdev->dev, "couldn't claim card detect pin\n"); goto fail4b; } } if (gpio_is_valid(host->board->wp_pin)) { ret = gpio_request(host->board->wp_pin, "mmc_wp"); if (ret < 0) { dev_dbg(&pdev->dev, "couldn't claim wp sense pin\n"); goto fail4; } } if (gpio_is_valid(host->board->vcc_pin)) { ret = gpio_request(host->board->vcc_pin, "mmc_vcc"); if (ret < 0) { dev_dbg(&pdev->dev, "couldn't claim vcc switch pin\n"); goto fail3; } } /* * Get Clock */ host->mci_clk = clk_get(&pdev->dev, "mci_clk"); if (IS_ERR(host->mci_clk)) { ret = -ENODEV; dev_dbg(&pdev->dev, "no mci_clk?\n"); goto fail2; } /* * Map I/O region */ host->baseaddr = ioremap(res->start, resource_size(res)); if (!host->baseaddr) { ret = -ENOMEM; goto fail1; } /* * Reset hardware */ clk_enable(host->mci_clk); /* Enable the peripheral clock */ at91_mci_disable(host); at91_mci_enable(host); /* * Allocate the MCI interrupt */ host->irq = platform_get_irq(pdev, 0); ret = request_irq(host->irq, at91_mci_irq, IRQF_SHARED, mmc_hostname(mmc), host); if (ret) { dev_dbg(&pdev->dev, "request MCI interrupt failed\n"); goto fail0; } setup_timer(&host->timer, at91_timeout_timer, (unsigned long)host); platform_set_drvdata(pdev, mmc); /* * Add host to MMC layer */ if (gpio_is_valid(host->board->det_pin)) { host->present = !gpio_get_value(host->board->det_pin); } else host->present = -1; mmc_add_host(mmc); /* * monitor card insertion/removal if we can */ if (gpio_is_valid(host->board->det_pin)) { ret = request_irq(gpio_to_irq(host->board->det_pin), at91_mmc_det_irq, 0, mmc_hostname(mmc), host); if (ret) dev_warn(&pdev->dev, "request MMC detect irq failed\n"); else device_init_wakeup(&pdev->dev, 1); } pr_debug("Added MCI driver\n"); return 0; fail0: clk_disable(host->mci_clk); iounmap(host->baseaddr); fail1: clk_put(host->mci_clk); fail2: if (gpio_is_valid(host->board->vcc_pin)) gpio_free(host->board->vcc_pin); fail3: if (gpio_is_valid(host->board->wp_pin)) gpio_free(host->board->wp_pin); fail4: if (gpio_is_valid(host->board->det_pin)) gpio_free(host->board->det_pin); fail4b: if (host->buffer) dma_free_coherent(&pdev->dev, MCI_BUFSIZE, host->buffer, host->physical_address); fail5: mmc_free_host(mmc); fail6: release_mem_region(res->start, resource_size(res)); dev_err(&pdev->dev, "probe failed, err %d\n", ret); return ret; }
static int serial_omap_probe(struct platform_device *pdev) { struct uart_omap_port *up; struct resource *mem, *irq; struct omap_uart_port_info *omap_up_info = pdev->dev.platform_data; int ret; if (pdev->dev.of_node) omap_up_info = of_get_uart_port_info(&pdev->dev); mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!mem) { dev_err(&pdev->dev, "no mem resource?\n"); return -ENODEV; } irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0); if (!irq) { dev_err(&pdev->dev, "no irq resource?\n"); return -ENODEV; } if (!devm_request_mem_region(&pdev->dev, mem->start, resource_size(mem), pdev->dev.driver->name)) { dev_err(&pdev->dev, "memory region already claimed\n"); return -EBUSY; } if (gpio_is_valid(omap_up_info->DTR_gpio) && omap_up_info->DTR_present) { ret = gpio_request(omap_up_info->DTR_gpio, "omap-serial"); if (ret < 0) return ret; ret = gpio_direction_output(omap_up_info->DTR_gpio, omap_up_info->DTR_inverted); if (ret < 0) return ret; } up = devm_kzalloc(&pdev->dev, sizeof(*up), GFP_KERNEL); if (!up) return -ENOMEM; if (gpio_is_valid(omap_up_info->DTR_gpio) && omap_up_info->DTR_present) { up->DTR_gpio = omap_up_info->DTR_gpio; up->DTR_inverted = omap_up_info->DTR_inverted; } else up->DTR_gpio = -EINVAL; up->DTR_active = 0; up->dev = &pdev->dev; up->port.dev = &pdev->dev; up->port.type = PORT_OMAP; up->port.iotype = UPIO_MEM; up->port.irq = irq->start; up->port.regshift = 2; up->port.fifosize = 64; up->port.ops = &serial_omap_pops; if (pdev->dev.of_node) up->port.line = of_alias_get_id(pdev->dev.of_node, "serial"); else up->port.line = pdev->id; if (up->port.line < 0) { dev_err(&pdev->dev, "failed to get alias/pdev id, errno %d\n", up->port.line); ret = -ENODEV; goto err_port_line; } up->pins = devm_pinctrl_get_select_default(&pdev->dev); if (IS_ERR(up->pins)) { dev_warn(&pdev->dev, "did not get pins for uart%i error: %li\n", up->port.line, PTR_ERR(up->pins)); up->pins = NULL; } sprintf(up->name, "OMAP UART%d", up->port.line); up->port.mapbase = mem->start; up->port.membase = devm_ioremap(&pdev->dev, mem->start, resource_size(mem)); if (!up->port.membase) { dev_err(&pdev->dev, "can't ioremap UART\n"); ret = -ENOMEM; goto err_ioremap; } up->port.flags = omap_up_info->flags; up->port.uartclk = omap_up_info->uartclk; if (!up->port.uartclk) { up->port.uartclk = DEFAULT_CLK_SPEED; dev_warn(&pdev->dev, "No clock speed specified: using default:" "%d\n", DEFAULT_CLK_SPEED); } up->latency = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE; up->calc_latency = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE; pm_qos_add_request(&up->pm_qos_request, PM_QOS_CPU_DMA_LATENCY, up->latency); serial_omap_uart_wq = create_singlethread_workqueue(up->name); INIT_WORK(&up->qos_work, serial_omap_uart_qos_work); platform_set_drvdata(pdev, up); pm_runtime_enable(&pdev->dev); pm_runtime_use_autosuspend(&pdev->dev); pm_runtime_set_autosuspend_delay(&pdev->dev, omap_up_info->autosuspend_timeout); pm_runtime_irq_safe(&pdev->dev); pm_runtime_get_sync(&pdev->dev); omap_serial_fill_features_erratas(up); ui[up->port.line] = up; serial_omap_add_console_port(up); ret = uart_add_one_port(&serial_omap_reg, &up->port); if (ret != 0) goto err_add_port; pm_runtime_mark_last_busy(up->dev); pm_runtime_put_autosuspend(up->dev); return 0; err_add_port: pm_runtime_put(&pdev->dev); pm_runtime_disable(&pdev->dev); err_ioremap: err_port_line: dev_err(&pdev->dev, "[UART%d]: failure [%s]: %d\n", pdev->id, __func__, ret); return ret; }
/************edit by Magnum 2013-11-19 ************ ******************************************************* * turn off backlight before lcm_init when boot on * excute just one time; *******************************************************/ static int dsi_hx8394a_720p_enable(struct device *dev) { int err = 0; //printk("Ivan dsi_hx8394a_720p_enable\n"); err = dsi_hx8394a_720p_reg_get(); if (err < 0) { //printk("dsi regulator get failed\n"); goto fail; } err = dsi_hx8394a_720p_gpio_get(); if (err < 0) { printk("dsi gpio request failed\n"); goto fail; } //turn_off_bl(); if (gpio_is_valid(panel_of.panel_gpio[TEGRA_GPIO_RESET])) gpio_direction_output( panel_of.panel_gpio[TEGRA_GPIO_RESET], 0); else { if (is_in_initialized_mode) gpio_direction_output(dsi_hx8394a_720p_pdata.dsi_panel_rst_gpio, 0); } //tegra_dsi_enter_lp11(); if (avdd_lcd_3v0_2v8) { err = regulator_enable(avdd_lcd_3v0_2v8); if (err < 0) { printk("avdd_lcd regulator enable failed\n"); goto fail; } regulator_set_voltage(avdd_lcd_3v0_2v8, 2800000, 2800000); } usleep_range(3000, 5000); if (vdd_lcd_s_1v8) { err = regulator_enable(vdd_lcd_s_1v8); if (err < 0) { printk("vdd_lcd_1v8_s regulator enable failed\n"); goto fail; } } usleep_range(3000, 5000); if (vdd_sys_bl_3v7) { err = regulator_enable(vdd_sys_bl_3v7); if (err < 0) { goto fail; } } usleep_range(3000, 5000); /* gpio_direction_output( dsi_hx8394a_720p_pdata.dsi_panel_rst_gpio, 1); usleep_range(1000, 5000); gpio_direction_output( dsi_hx8394a_720p_pdata.dsi_panel_rst_gpio, 0); usleep_range(1000, 5000); */ #if 0//def DSI_PANEL_RESET gpio_direction_output( dsi_hx8394a_720p_pdata.dsi_panel_rst_gpio, 1); msleep(20); #endif /* enable backlight */ //gpio_direction_output(dsi_hx8394a_720p_pdata.dsi_panel_bl_en_gpio, 1); is_bl_powered = true; is_in_initialized_mode = true; return 0; fail: return err; }
static int __devinit gpio_keys_probe(struct platform_device *pdev) { const struct gpio_keys_platform_data *pdata = pdev->dev.platform_data; struct gpio_keys_drvdata *ddata; struct gpio_keys_button *button = NULL; struct gpio_button_data *bdata = NULL; struct device *dev = &pdev->dev; struct gpio_keys_platform_data alt_pdata; struct input_dev *input; int i, error; int wakeup = 0; int ret; struct device *sec_key; #ifdef CONFIG_SEC_PATEK_PROJECT struct device *sec_keypad; struct device *sec_flip; #endif if (!pdata) { error = gpio_keys_get_devtree_pdata(dev, &alt_pdata); if (error) return error; pdata = &alt_pdata; } ddata = kzalloc(sizeof(struct gpio_keys_drvdata) + pdata->nbuttons * sizeof(struct gpio_button_data), GFP_KERNEL); input = input_allocate_device(); if (!ddata || !input) { dev_err(dev, "failed to allocate state\n"); error = -ENOMEM; goto fail1; } ddata->input = input; ddata->n_buttons = pdata->nbuttons; ddata->enable = pdata->enable; ddata->disable = pdata->disable; #ifdef CONFIG_SENSORS_HALL_DEBOUNCE ddata->debounce_set = pdata->debounce_set; #endif #ifdef CONFIG_SENSORS_HALL #if defined (CONFIG_SEC_MILLET_PROJECT) || defined (CONFIG_SEC_BERLUTI_PROJECT)\ || defined (CONFIG_SEC_MATISSE_PROJECT) || defined (CONFIG_SEC_ATLANTIC_PROJECT)\ || defined (CONFIG_SEC_MEGA2_PROJECT) || defined (CONFIG_SEC_T8_PROJECT) || defined (CONFIG_SEC_T10_PROJECT) || defined(CONFIG_SEC_HESTIA_PROJECT) ret = gpio_request(pdata->gpio_flip_cover,"HALL"); if(ret) printk(KERN_CRIT "[HALL IC] gpio Request FAIL\n"); else { gpio_tlmm_config(GPIO_CFG(pdata->gpio_flip_cover,0, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL,GPIO_CFG_2MA),GPIO_CFG_DISABLE); } #endif ddata->gpio_flip_cover = pdata->gpio_flip_cover; ddata->flip_code = pdata->flip_code; ddata->irq_flip_cover = gpio_to_irq(ddata->gpio_flip_cover); wake_lock_init(&ddata->flip_wake_lock, WAKE_LOCK_SUSPEND, "flip_wake_lock"); flip_status_before = -1; #endif mutex_init(&ddata->disable_lock); #ifdef CONFIG_SENSORS_HALL_IRQ_CTRL mutex_init(&ddata->irq_lock); #endif platform_set_drvdata(pdev, ddata); input_set_drvdata(input, ddata); input->name = pdata->name ? : pdev->name; input->phys = "gpio-keys/input0"; input->dev.parent = &pdev->dev; #ifdef CONFIG_SENSORS_HALL if(ddata->gpio_flip_cover != 0) { input->evbit[0] |= BIT_MASK(EV_SW); input_set_capability(input, EV_SW, ddata->flip_code); } #endif #ifdef CONFIG_SENSORS_HALL_IRQ_CTRL ddata->gsm_area = false; ddata->cover_state = false; ddata->workaround_set = pdata->workaround_set; drv_data = ddata; #endif #ifdef CONFIG_SENSORS_HALL_DEBOUNCE ddata->debounce_set = false; #endif input->open = gpio_keys_open; input->close = gpio_keys_close; input->id.bustype = BUS_HOST; input->id.vendor = 0x0001; input->id.product = 0x0001; input->id.version = 0x0100; /* Enable auto repeat feature of Linux input subsystem */ if (pdata->rep) __set_bit(EV_REP, input->evbit); for (i = 0; i < pdata->nbuttons; i++) { button = &pdata->buttons[i]; bdata = &ddata->data[i]; error = gpio_keys_setup_key(pdev, input, bdata, button); if (error) goto fail2; #ifdef KEY_BOOSTER error = gpio_key_init_dvfs(bdata); if (error < 0) { dev_err(dev, "Fail get dvfs level for touch booster\n"); goto fail2; } #endif if (button->wakeup) wakeup = 1; } error = sysfs_create_group(&pdev->dev.kobj, &gpio_keys_attr_group); if (error) { dev_err(dev, "Unable to export keys/switches, error: %d\n", error); goto fail2; } error = input_register_device(input); if (error) { dev_err(dev, "Unable to register input device, error: %d\n", error); goto fail3; } /* get current state of buttons that are connected to GPIOs */ for (i = 0; i < pdata->nbuttons; i++) { bdata = &ddata->data[i]; if (gpio_is_valid(bdata->button->gpio)) gpio_keys_gpio_report_event(bdata); } input_sync(input); sec_key = device_create(sec_class, NULL, 0, NULL, "sec_key"); if (IS_ERR(sec_key)) pr_err("Failed to create device(sec_key)!\n"); #ifdef CONFIG_SEC_PATEK_PROJECT sec_keypad=device_create(sec_class, NULL, 0, NULL, "sec_keypad"); if (device_create_file(sec_keypad, &dev_attr_brightness) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_brightness.attr.name); sec_flip = device_create(sec_class, NULL, 0, NULL, "sec_flip"); if (device_create_file(sec_flip, &dev_attr_flipStatus) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_flipStatus.attr.name); #endif ret = device_create_file(sec_key, &dev_attr_sec_key_pressed); if (ret) { pr_err("Failed to create device file in sysfs entries(%s)!\n", dev_attr_sec_key_pressed.attr.name); } #if defined(CONFIG_SEC_S_PROJECT) ret = device_create_file(sec_key, &dev_attr_sec_key_pressed_code); if (ret) { pr_err("Failed to create device file in sysfs entries(%s)!\n", dev_attr_sec_key_pressed_code.attr.name); } #endif #ifdef CONFIG_SENSORS_HALL_IRQ_CTRL if(ddata->gpio_flip_cover != 0) { ret = device_create_file(sec_key, &dev_attr_hall_irq_ctrl); if (ret < 0) { pr_err("Failed to create device file(%s)!, error: %d\n", dev_attr_hall_irq_ctrl.attr.name, ret); } } #endif #if defined(CONFIG_SENSORS_HALL) if(ddata->gpio_flip_cover != 0) { ret = device_create_file(sec_key, &dev_attr_hall_detect); if (ret < 0) { pr_err("Failed to create device file(%s)!, error: %d\n", dev_attr_hall_detect.attr.name, ret); } } #if defined(CONFIG_SENSORS_HALL_DEBOUNCE) if(ddata->gpio_flip_cover != 0) { ret = device_create_file(sec_key, &dev_attr_hall_irq_ctrl); if (ret < 0) { pr_err("Failed to create device file(%s)!, error: %d\n", dev_attr_hall_irq_ctrl.attr.name, ret); } } #endif #if defined (CONFIG_SEC_MILLET_PROJECT) || defined (CONFIG_SEC_BERLUTI_PROJECT) || defined (CONFIG_SEC_T8_PROJECT) if (!lvs1_1p8) { lvs1_1p8 = regulator_get(dev, "8226_lvs1"); if(!lvs1_1p8) printk(KERN_CRIT "%s: regulator_get for 8226_lvs1 failed\n", __func__); else { ret = regulator_enable(lvs1_1p8); if (ret){ regulator_put(lvs1_1p8); printk(KERN_CRIT "%s: Failed to enable regulator lvs1_1p8.\n",__func__); } } } #endif #endif #ifdef CONFIG_USE_VM_KEYBOARD_REJECT reject_keyboard_specific_key = false; ret = device_create_file(sec_key, &dev_attr_reject_key_comb); if (ret < 0) { pr_err("Failed to create device file(%s), error: %d\n", dev_attr_reject_key_comb.attr.name, ret); } #endif ret = device_create_file(sec_key, &dev_attr_wakeup_keys); if (ret < 0) { pr_err("Failed to create device file(%s), error: %d\n", dev_attr_wakeup_keys.attr.name, ret); } dev_set_drvdata(sec_key, ddata); device_init_wakeup(&pdev->dev, wakeup); #if defined(CONFIG_SEC_PATEK_PROJECT) keypadled_powerset(&pdev->dev); dev_set_drvdata(sec_flip, ddata); #endif #ifdef PERIODIC_CHECK_GPIOS INIT_DELAYED_WORK_DEFERRABLE(&g_gpio_check_work, sec_gpiocheck_work); schedule_delayed_work(&g_gpio_check_work, msecs_to_jiffies(0)); #endif return 0; fail3: sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group); fail2: while (--i >= 0) gpio_remove_key(&ddata->data[i]); platform_set_drvdata(pdev, NULL); #ifdef CONFIG_SENSORS_HALL wake_lock_destroy(&ddata->flip_wake_lock); #endif fail1: input_free_device(input); kfree(ddata); /* If we have no platform_data, we allocated buttons dynamically. */ if (!pdev->dev.platform_data) kfree(pdata->buttons); return error; }