void reset_misc(void) { struct gpio_desc gpio = {}; int node; node = fdt_node_offset_by_compatible(gd->fdt_blob, 0, "samsung,emmc-reset"); if (node < 0) return; gpio_request_by_name_nodev(gd->fdt_blob, node, "reset-gpio", 0, &gpio, GPIOD_IS_OUT); if (dm_gpio_is_valid(&gpio)) { /* * Reset eMMC * * FIXME: Need to optimize delay time. Minimum 1usec pulse is * required by 'JEDEC Standard No.84-A441' (eMMC) * document but real delay time is expected to greater * than 1usec. */ dm_gpio_set_value(&gpio, 0); mdelay(10); dm_gpio_set_value(&gpio, 1); } }
static int dw_mdio_reset(struct mii_dev *bus) { struct udevice *dev = bus->priv; struct dw_eth_dev *priv = dev_get_priv(dev); struct dw_eth_pdata *pdata = dev_get_platdata(dev); int ret; if (!dm_gpio_is_valid(&priv->reset_gpio)) return 0; /* reset the phy */ ret = dm_gpio_set_value(&priv->reset_gpio, 0); if (ret) return ret; udelay(pdata->reset_delays[0]); ret = dm_gpio_set_value(&priv->reset_gpio, 1); if (ret) return ret; udelay(pdata->reset_delays[1]); ret = dm_gpio_set_value(&priv->reset_gpio, 0); if (ret) return ret; udelay(pdata->reset_delays[2]); return 0; }
static u32 cpld_read(struct udevice *dev, u8 addr) { struct renesas_ulcb_sysreset_priv *priv = dev_get_priv(dev); u32 data = 0; int i; for (i = 0; i < 8; i++) { dm_gpio_set_value(&priv->mosi, !!(addr & 0x80)); /* MSB first */ dm_gpio_set_value(&priv->sck, 1); addr <<= 1; dm_gpio_set_value(&priv->sck, 0); } dm_gpio_set_value(&priv->mosi, 0); /* READ */ dm_gpio_set_value(&priv->sstbz, 0); dm_gpio_set_value(&priv->sck, 1); dm_gpio_set_value(&priv->sck, 0); dm_gpio_set_value(&priv->sstbz, 1); for (i = 0; i < 32; i++) { dm_gpio_set_value(&priv->sck, 1); data <<= 1; data |= dm_gpio_get_value(&priv->miso); /* MSB first */ dm_gpio_set_value(&priv->sck, 0); } return data; }
int board_late_init(void) { struct gpio_desc gpio = {}; int node; node = fdt_node_offset_by_compatible(gd->fdt_blob, 0, "st,led1"); if (node < 0) return -1; gpio_request_by_name_nodev(offset_to_ofnode(node), "led-gpio", 0, &gpio, GPIOD_IS_OUT); if (dm_gpio_is_valid(&gpio)) { dm_gpio_set_value(&gpio, 0); mdelay(10); dm_gpio_set_value(&gpio, 1); } /* read button 1*/ node = fdt_node_offset_by_compatible(gd->fdt_blob, 0, "st,button1"); if (node < 0) return -1; gpio_request_by_name_nodev(offset_to_ofnode(node), "button-gpio", 0, &gpio, GPIOD_IS_IN); if (dm_gpio_is_valid(&gpio)) { if (dm_gpio_get_value(&gpio)) puts("usr button is at HIGH LEVEL\n"); else puts("usr button is at LOW LEVEL\n"); } return 0; }
/** * Handle the next stage of device init */ static int handle_stage(const void *blob, struct tegra_lcd_priv *priv) { debug("%s: stage %d\n", __func__, priv->stage); /* do the things for this stage */ switch (priv->stage) { case STAGE_START: /* * It is possible that the FDT has requested that the LCD be * disabled. We currently don't support this. It would require * changes to U-Boot LCD subsystem to have LCD support * compiled in but not used. An easier option might be to * still have a frame buffer, but leave the backlight off and * remove all mention of lcd in the stdout environment * variable. */ funcmux_select(PERIPH_ID_DISP1, FUNCMUX_DEFAULT); break; case STAGE_PANEL_VDD: if (dm_gpio_is_valid(&priv->panel_vdd)) dm_gpio_set_value(&priv->panel_vdd, 1); break; case STAGE_LVDS: if (dm_gpio_is_valid(&priv->lvds_shutdown)) dm_gpio_set_value(&priv->lvds_shutdown, 1); break; case STAGE_BACKLIGHT_VDD: if (dm_gpio_is_valid(&priv->backlight_vdd)) dm_gpio_set_value(&priv->backlight_vdd, 1); break; case STAGE_PWM: /* Enable PWM at 15/16 high, 32768 Hz with divider 1 */ pinmux_set_func(PMUX_PINGRP_GPU, PMUX_FUNC_PWM); pinmux_tristate_disable(PMUX_PINGRP_GPU); pwm_set_config(priv->pwm, priv->pwm_channel, 0xdf, 0xff); pwm_set_enable(priv->pwm, priv->pwm_channel, true); break; case STAGE_BACKLIGHT_EN: if (dm_gpio_is_valid(&priv->backlight_en)) dm_gpio_set_value(&priv->backlight_en, 1); break; case STAGE_DONE: break; } /* set up timer for next stage */ priv->timer_next = timer_get_us(); if (priv->stage < FDT_LCD_TIMINGS) priv->timer_next += priv->panel_timings[priv->stage] * 1000; /* move to next stage */ priv->stage++; return 0; }
void __weak board_netphy_reset(void *dev) { struct pic32eth_dev *priv = dev; if (!dm_gpio_is_valid(&priv->rst_gpio)) return; /* phy reset */ dm_gpio_set_value(&priv->rst_gpio, 0); udelay(300); dm_gpio_set_value(&priv->rst_gpio, 1); udelay(300); }
int i2c_arbitrator_select(struct udevice *mux, struct udevice *bus, uint channel) { struct i2c_arbitrator_priv *priv = dev_get_priv(mux); unsigned start; int ret; debug("%s: %s\n", __func__, mux->name); /* Start a round of trying to claim the bus */ start = get_timer(0); do { unsigned start_retry; int waiting = 0; /* Indicate that we want to claim the bus */ ret = dm_gpio_set_value(&priv->ap_claim, 1); if (ret) goto err; udelay(priv->slew_delay_us); /* Wait for the EC to release it */ start_retry = get_timer(0); while (get_timer(start_retry) < priv->wait_retry_ms) { ret = dm_gpio_get_value(&priv->ec_claim); if (ret < 0) { goto err; } else if (!ret) { /* We got it, so return */ return 0; } if (!waiting) waiting = 1; } /* It didn't release, so give up, wait, and try again */ ret = dm_gpio_set_value(&priv->ap_claim, 0); if (ret) goto err; mdelay(priv->wait_retry_ms); } while (get_timer(start) < priv->wait_free_ms); /* Give up, release our claim */ printf("I2C: Could not claim bus, timeout %lu\n", get_timer(start)); ret = -ETIMEDOUT; ret = 0; err: return ret; }
static int rockchip_dwmmc_pwrseq_set_power(struct udevice *dev, bool enable) { struct gpio_desc reset; int ret; ret = gpio_request_by_name(dev, "reset-gpios", 0, &reset, GPIOD_IS_OUT); if (ret) return ret; dm_gpio_set_value(&reset, 1); udelay(1); dm_gpio_set_value(&reset, 0); udelay(200); return 0; }
static int pwm_backlight_enable(struct udevice *dev) { struct pwm_backlight_priv *priv = dev_get_priv(dev); struct dm_regulator_uclass_platdata *plat; uint duty_cycle; int ret; if (priv->reg) { plat = dev_get_uclass_platdata(priv->reg); debug("%s: Enable '%s', regulator '%s'/'%s'\n", __func__, dev->name, priv->reg->name, plat->name); ret = regulator_set_enable(priv->reg, true); if (ret) { debug("%s: Cannot enable regulator for PWM '%s'\n", __func__, dev->name); return ret; } mdelay(120); } duty_cycle = priv->period_ns * (priv->default_level - priv->min_level) / (priv->max_level - priv->min_level + 1); ret = pwm_set_config(priv->pwm, priv->channel, priv->period_ns, duty_cycle); if (ret) return ret; ret = pwm_set_enable(priv->pwm, priv->channel, true); if (ret) return ret; mdelay(10); dm_gpio_set_value(&priv->enable, 1); return 0; }
/* * EHCI-initialization * Create the appropriate control structures to manage * a new EHCI host controller. */ int ehci_hcd_init(int index, enum usb_init_type init, struct ehci_hccr **hccr, struct ehci_hcor **hcor) { struct exynos_ehci *ctx = &exynos; #ifdef CONFIG_OF_CONTROL if (exynos_usb_parse_dt(gd->fdt_blob, ctx)) { debug("Unable to parse device tree for ehci-exynos\n"); return -ENODEV; } #else ctx->usb = (struct exynos_usb_phy *)samsung_get_base_usb_phy(); ctx->hcd = (struct ehci_hccr *)samsung_get_base_usb_ehci(); #endif #ifdef CONFIG_OF_CONTROL /* setup the Vbus gpio here */ if (dm_gpio_is_valid(&ctx->vbus_gpio)) dm_gpio_set_value(&ctx->vbus_gpio, 1); #endif setup_usb_phy(ctx->usb); board_usb_init(index, init); *hccr = ctx->hcd; *hcor = (struct ehci_hcor *)((uint32_t) *hccr + HC_LENGTH(ehci_readl(&(*hccr)->cr_capbase))); debug("Exynos5-ehci: init hccr %x and hcor %x hc_length %d\n", (uint32_t)*hccr, (uint32_t)*hcor, (uint32_t)HC_LENGTH(ehci_readl(&(*hccr)->cr_capbase))); return 0; }
static void spi_cs_deactivate(struct pic32_spi_priv *priv) { if (!dm_gpio_is_valid(&priv->cs_gpio)) return; dm_gpio_set_value(&priv->cs_gpio, 0); }
static int do_sdhci_init(struct sdhci_host *host) { int dev_id, flag, ret; flag = host->bus_width == 8 ? PINMUX_FLAG_8BIT_MODE : PINMUX_FLAG_NONE; dev_id = host->index + PERIPH_ID_SDMMC0; ret = exynos_pinmux_config(dev_id, flag); if (ret) { printf("external SD not configured\n"); return ret; } if (dm_gpio_is_valid(&host->pwr_gpio)) { dm_gpio_set_value(&host->pwr_gpio, 1); ret = exynos_pinmux_config(dev_id, flag); if (ret) { debug("MMC not configured\n"); return ret; } } if (dm_gpio_is_valid(&host->cd_gpio)) { ret = dm_gpio_get_value(&host->cd_gpio); if (ret) { debug("no SD card detected (%d)\n", ret); return -ENODEV; } } return s5p_sdhci_core_init(host); }
static int do_sdhci_init(struct sdhci_host *host) { int dev_id, flag; int err = 0; flag = host->bus_width == 8 ? PINMUX_FLAG_8BIT_MODE : PINMUX_FLAG_NONE; dev_id = host->index + PERIPH_ID_SDMMC0; if (dm_gpio_is_valid(&host->pwr_gpio)) { dm_gpio_set_value(&host->pwr_gpio, 1); err = exynos_pinmux_config(dev_id, flag); if (err) { debug("MMC not configured\n"); return err; } } if (dm_gpio_is_valid(&host->cd_gpio)) { if (dm_gpio_get_value(&host->cd_gpio)) return -ENODEV; err = exynos_pinmux_config(dev_id, flag); if (err) { printf("external SD not configured\n"); return err; } } return s5p_sdhci_core_init(host); }
static int fixed_regulator_set_enable(struct udevice *dev, bool enable) { struct fixed_regulator_platdata *dev_pdata = dev_get_platdata(dev); int ret; debug("%s: dev='%s', enable=%d, delay=%d, has_gpio=%d\n", __func__, dev->name, enable, dev_pdata->startup_delay_us, dm_gpio_is_valid(&dev_pdata->gpio)); /* Enable GPIO is optional */ if (!dm_gpio_is_valid(&dev_pdata->gpio)) { if (!enable) return -ENOSYS; return 0; } ret = dm_gpio_set_value(&dev_pdata->gpio, enable); if (ret) { pr_err("Can't set regulator : %s gpio to: %d\n", dev->name, enable); return ret; } if (enable && dev_pdata->startup_delay_us) udelay(dev_pdata->startup_delay_us); debug("%s: done\n", __func__); return 0; }
static int xhci_usb_probe(struct udevice *dev) { struct exynos_xhci_platdata *plat = dev_get_platdata(dev); struct exynos_xhci *ctx = dev_get_priv(dev); struct xhci_hcor *hcor; int ret; ctx->hcd = (struct xhci_hccr *)plat->hcd_base; ctx->usb3_phy = (struct exynos_usb3_phy *)plat->phy_base; ctx->dwc3_reg = (struct dwc3 *)((char *)(ctx->hcd) + DWC3_REG_OFFSET); hcor = (struct xhci_hcor *)((uint32_t)ctx->hcd + HC_LENGTH(xhci_readl(&ctx->hcd->cr_capbase))); /* setup the Vbus gpio here */ if (dm_gpio_is_valid(&plat->vbus_gpio)) dm_gpio_set_value(&plat->vbus_gpio, 1); ret = exynos_xhci_core_init(ctx); if (ret) { puts("XHCI: failed to initialize controller\n"); return -EINVAL; } return xhci_register(dev, ctx->hcd, hcor); }
static int enable_sequence(struct udevice *dev, int seq) { struct pwm_backlight_priv *priv = dev_get_priv(dev); int ret; switch (seq) { case 0: if (priv->reg) { __maybe_unused struct dm_regulator_uclass_platdata *plat; plat = dev_get_uclass_platdata(priv->reg); log_debug("Enable '%s', regulator '%s'/'%s'\n", dev->name, priv->reg->name, plat->name); ret = regulator_set_enable(priv->reg, true); if (ret) { log_debug("Cannot enable regulator for PWM '%s'\n", dev->name); return log_ret(ret); } mdelay(120); } break; case 1: mdelay(10); dm_gpio_set_value(&priv->enable, 1); break; } return 0; }
static int led_7seg_init(unsigned int segments) { int node; int ret; int i; struct gpio_desc desc[8]; node = fdt_node_offset_by_compatible(gd->fdt_blob, 0, "atl,of-led-7seg"); if (node < 0) return -ENODEV; ret = gpio_request_list_by_name_nodev(offset_to_ofnode(node), "segment-gpios", desc, ARRAY_SIZE(desc), GPIOD_IS_OUT); if (ret < 0) return ret; for (i = 0; i < ARRAY_SIZE(desc); i++) { ret = dm_gpio_set_value(&desc[i], !(segments & BIT(i))); if (ret) return ret; } return 0; }
void board_pex_config(void) { #ifdef CONFIG_SPL_BUILD uint k; struct gpio_desc gpio = {}; if (!request_gpio_by_name(&gpio, "pca9698@22", 31, "fpga-program-gpio")) { /* prepare FPGA reconfiguration */ dm_gpio_set_dir_flags(&gpio, GPIOD_IS_OUT); dm_gpio_set_value(&gpio, 0); /* give lunatic PCIe clock some time to stabilize */ mdelay(500); /* start FPGA reconfiguration */ dm_gpio_set_dir_flags(&gpio, GPIOD_IS_IN); } /* wait for FPGA done */ if (!request_gpio_by_name(&gpio, "pca9698@22", 19, "fpga-done-gpio")) { for (k = 0; k < 20; ++k) { if (dm_gpio_get_value(&gpio)) { printf("FPGA done after %u rounds\n", k); break; } mdelay(100); } } /* disable FPGA reset */ if (!request_gpio_by_name(&gpio, "gpio@18100", 6, "cpu-to-fpga-reset")) { dm_gpio_set_dir_flags(&gpio, GPIOD_IS_OUT); dm_gpio_set_value(&gpio, 1); } /* wait for FPGA ready */ if (!request_gpio_by_name(&gpio, "pca9698@22", 27, "fpga-ready-gpio")) { for (k = 0; k < 2; ++k) { if (!dm_gpio_get_value(&gpio)) break; mdelay(100); } } #endif }
static int gpio_led_set_on(struct udevice *dev, int on) { struct led_gpio_priv *priv = dev_get_priv(dev); if (!dm_gpio_is_valid(&priv->gpio)) return -EREMOTEIO; return dm_gpio_set_value(&priv->gpio, on); }
static void atmel_spi_cs_deactivate(struct udevice *dev) { struct udevice *bus = dev_get_parent(dev); struct atmel_spi_priv *priv = dev_get_priv(bus); struct dm_spi_slave_platdata *slave_plat = dev_get_parent_platdata(dev); u32 cs = slave_plat->cs; dm_gpio_set_value(&priv->cs_gpios[cs], 1); }
static void i2c_gpio_sda_set(struct gpio_desc *sda, int bit) { if (bit) { dm_gpio_set_dir_flags(sda, GPIOD_IS_IN); } else { dm_gpio_set_dir_flags(sda, GPIOD_IS_OUT); dm_gpio_set_value(sda, 0); } }
int video_bridge_set_active(struct udevice *dev, bool active) { struct video_bridge_priv *uc_priv = dev_get_uclass_priv(dev); int ret; debug("%s: %d\n", __func__, active); ret = dm_gpio_set_value(&uc_priv->sleep, !active); if (ret) return ret; if (active) { ret = dm_gpio_set_value(&uc_priv->reset, true); if (ret) return ret; udelay(10); ret = dm_gpio_set_value(&uc_priv->reset, false); } return ret; }
/** * gpio_set_value() - [COMPAT] Configure logical value on GPIO pin * gpio: GPIO number * value: Logical value to be set on the GPIO pin. * * This function implements the API that's compatible with current * GPIO API used in U-Boot. The request is forwarded to particular * GPIO driver. Returns 0 on success, negative value on error. */ int gpio_set_value(unsigned gpio, int value) { struct gpio_desc desc; int ret; ret = gpio_to_device(gpio, &desc); if (ret) return ret; return dm_gpio_set_value(&desc, value); }
static int simple_panel_enable_backlight(struct udevice *dev) { struct simple_panel_priv *priv = dev_get_priv(dev); int ret; dm_gpio_set_value(&priv->enable, 1); ret = backlight_enable(priv->backlight); if (ret) return ret; return 0; }
int i2c_arbitrator_deselect(struct udevice *mux, struct udevice *bus, uint channel) { struct i2c_arbitrator_priv *priv = dev_get_priv(mux); int ret; debug("%s: %s\n", __func__, mux->name); ret = dm_gpio_set_value(&priv->ap_claim, 0); udelay(priv->slew_delay_us); return ret; }
static int pwm_backlight_set_brightness(struct udevice *dev, int percent) { struct pwm_backlight_priv *priv = dev_get_priv(dev); bool disable = false; int level; int ret; if (!priv->enabled) { ret = enable_sequence(dev, 0); if (ret) return log_ret(ret); } if (percent == BACKLIGHT_OFF) { disable = true; percent = 0; } if (percent == BACKLIGHT_DEFAULT) { level = priv->default_level; } else { if (priv->levels) { level = priv->levels[percent * (priv->num_levels - 1) / 100]; } else { level = priv->min_level + (priv->max_level - priv->min_level) * percent / 100; } } priv->cur_level = level; ret = set_pwm(priv); if (ret) return log_ret(ret); if (!priv->enabled) { ret = enable_sequence(dev, 1); if (ret) return log_ret(ret); priv->enabled = true; } if (disable) { dm_gpio_set_value(&priv->enable, 0); if (priv->reg) { ret = regulator_set_enable(priv->reg, false); if (ret) return log_ret(ret); } priv->enabled = false; } return 0; }
static int do_mmc_init(int dev_index, bool removable) { struct mmc_host *host; struct mmc *mmc; /* DT should have been read & host config filled in */ host = &mmc_host[dev_index]; if (!host->enabled) return -1; debug(" do_mmc_init: index %d, bus width %d pwr_gpio %d cd_gpio %d\n", dev_index, host->width, gpio_get_number(&host->pwr_gpio), gpio_get_number(&host->cd_gpio)); host->clock = 0; clock_start_periph_pll(host->mmc_id, CLOCK_ID_PERIPH, 20000000); if (dm_gpio_is_valid(&host->pwr_gpio)) dm_gpio_set_value(&host->pwr_gpio, 1); memset(&host->cfg, 0, sizeof(host->cfg)); host->cfg.name = "Tegra SD/MMC"; host->cfg.ops = &tegra_mmc_ops; host->cfg.voltages = MMC_VDD_32_33 | MMC_VDD_33_34 | MMC_VDD_165_195; host->cfg.host_caps = 0; if (host->width == 8) host->cfg.host_caps |= MMC_MODE_8BIT; if (host->width >= 4) host->cfg.host_caps |= MMC_MODE_4BIT; host->cfg.host_caps |= MMC_MODE_HS_52MHz | MMC_MODE_HS; /* * min freq is for card identification, and is the highest * low-speed SDIO card frequency (actually 400KHz) * max freq is highest HS eMMC clock as per the SD/MMC spec * (actually 52MHz) */ host->cfg.f_min = 375000; host->cfg.f_max = 48000000; host->cfg.b_max = CONFIG_SYS_MMC_MAX_BLK_COUNT; mmc = mmc_create(&host->cfg, host); mmc->block_dev.removable = removable; if (mmc == NULL) return -1; return 0; }
static void atmel_spi_cs_deactivate(struct udevice *dev) { #ifdef CONFIG_DM_GPIO struct udevice *bus = dev_get_parent(dev); struct atmel_spi_priv *priv = dev_get_priv(bus); struct dm_spi_slave_platdata *slave_plat = dev_get_parent_platdata(dev); u32 cs = slave_plat->cs; if (!dm_gpio_is_valid(&priv->cs_gpios[cs])) return; dm_gpio_set_value(&priv->cs_gpios[cs], 1); #endif }
static int simple_panel_enable_backlight(struct udevice *dev) { struct simple_panel_priv *priv = dev_get_priv(dev); int ret; debug("%s: start, backlight = '%s'\n", __func__, priv->backlight->name); dm_gpio_set_value(&priv->enable, 1); ret = backlight_enable(priv->backlight); debug("%s: done, ret = %d\n", __func__, ret); if (ret) return ret; return 0; }
static void rk3399_force_power_on_reset(void) { ofnode node; struct gpio_desc sysreset_gpio; debug("%s: trying to force a power-on reset\n", __func__); node = ofnode_path("/config"); if (!ofnode_valid(node)) { debug("%s: no /config node?\n", __func__); return; } if (gpio_request_by_name_nodev(node, "sysreset-gpio", 0, &sysreset_gpio, GPIOD_IS_OUT)) { debug("%s: could not find a /config/sysreset-gpio\n", __func__); return; } dm_gpio_set_value(&sysreset_gpio, 1); }