int pxa3xx_pinctrl_register(struct platform_device *pdev, struct pxa3xx_pinmux_info *info) { struct pinctrl_desc *desc; struct resource *res; if (!info || !info->cputype) return -EINVAL; desc = info->desc; desc->pins = info->pads; desc->npins = info->num_pads; desc->pctlops = &pxa3xx_pctrl_ops; desc->pmxops = &pxa3xx_pmx_ops; info->dev = &pdev->dev; pxa3xx_pinctrl_gpio_range.npins = info->num_gpio; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) return -ENOENT; info->virt_base = devm_request_and_ioremap(&pdev->dev, res); if (!info->virt_base) return -ENOMEM; info->pctrl = pinctrl_register(desc, &pdev->dev, info); if (!info->pctrl) { dev_err(&pdev->dev, "failed to register PXA pinmux driver\n"); return -EINVAL; } pinctrl_add_gpio_range(info->pctrl, &pxa3xx_pinctrl_gpio_range); platform_set_drvdata(pdev, info); return 0; }
int sh_pfc_register_pinctrl(struct sh_pfc *pfc) { struct sh_pfc_pinctrl *pmx; int nr_ranges; pmx = devm_kzalloc(pfc->dev, sizeof(*pmx), GFP_KERNEL); if (unlikely(!pmx)) return -ENOMEM; pmx->pfc = pfc; pfc->pinctrl = pmx; nr_ranges = sh_pfc_map_pins(pfc, pmx); if (unlikely(nr_ranges < 0)) return nr_ranges; pmx->pctl_desc.name = DRV_NAME; pmx->pctl_desc.owner = THIS_MODULE; pmx->pctl_desc.pctlops = &sh_pfc_pinctrl_ops; pmx->pctl_desc.pmxops = &sh_pfc_pinmux_ops; pmx->pctl_desc.confops = &sh_pfc_pinconf_ops; pmx->pctl_desc.pins = pmx->pins; pmx->pctl_desc.npins = pfc->info->nr_pins; pmx->pctl = pinctrl_register(&pmx->pctl_desc, pfc->dev, pmx); if (pmx->pctl == NULL) return -EINVAL; return 0; }
static int as3722_pinctrl_probe(struct platform_device *pdev) { struct as3722_pctrl_info *as_pci; int ret; as_pci = devm_kzalloc(&pdev->dev, sizeof(*as_pci), GFP_KERNEL); if (!as_pci) return -ENOMEM; as_pci->dev = &pdev->dev; as_pci->dev->of_node = pdev->dev.parent->of_node; as_pci->as3722 = dev_get_drvdata(pdev->dev.parent); platform_set_drvdata(pdev, as_pci); as_pci->pins = as3722_pins_desc; as_pci->num_pins = ARRAY_SIZE(as3722_pins_desc); as_pci->functions = as3722_pin_function; as_pci->num_functions = ARRAY_SIZE(as3722_pin_function); as_pci->pin_groups = as3722_pingroups; as_pci->num_pin_groups = ARRAY_SIZE(as3722_pingroups); as3722_pinctrl_desc.name = dev_name(&pdev->dev); as3722_pinctrl_desc.pins = as3722_pins_desc; as3722_pinctrl_desc.npins = ARRAY_SIZE(as3722_pins_desc); as_pci->pctl = pinctrl_register(&as3722_pinctrl_desc, &pdev->dev, as_pci); if (!as_pci->pctl) { dev_err(&pdev->dev, "Couldn't register pinctrl driver\n"); return -EINVAL; } as_pci->gpio_chip = as3722_gpio_chip; as_pci->gpio_chip.dev = &pdev->dev; as_pci->gpio_chip.of_node = pdev->dev.parent->of_node; ret = gpiochip_add(&as_pci->gpio_chip); if (ret < 0) { dev_err(&pdev->dev, "Couldn't register gpiochip, %d\n", ret); goto fail_chip_add; } ret = gpiochip_add_pin_range(&as_pci->gpio_chip, dev_name(&pdev->dev), 0, 0, AS3722_PIN_NUM); if (ret < 0) { dev_err(&pdev->dev, "Couldn't add pin range, %d\n", ret); goto fail_range_add; } return 0; fail_range_add: gpiochip_remove(&as_pci->gpio_chip); fail_chip_add: pinctrl_unregister(as_pci->pctl); return ret; }
static int __devinit nmk_pinctrl_probe(struct platform_device *pdev) { const struct platform_device_id *platid = platform_get_device_id(pdev); struct device_node *np = pdev->dev.of_node; struct nmk_pinctrl *npct; unsigned int version = 0; int i; npct = devm_kzalloc(&pdev->dev, sizeof(*npct), GFP_KERNEL); if (!npct) return -ENOMEM; if (platid) version = platid->driver_data; else if (np) version = (unsigned int) of_match_device(nmk_pinctrl_match, &pdev->dev)->data; /* Poke in other ASIC variants here */ if (version == PINCTRL_NMK_DB8500) nmk_pinctrl_db8500_init(&npct->soc); /* * We need all the GPIO drivers to probe FIRST, or we will not be able * to obtain references to the struct gpio_chip * for them, and we * need this to proceed. */ for (i = 0; i < npct->soc->gpio_num_ranges; i++) { if (!nmk_gpio_chips[i]) { dev_warn(&pdev->dev, "GPIO chip %d not registered yet\n", i); devm_kfree(&pdev->dev, npct); return -EPROBE_DEFER; } npct->soc->gpio_ranges[i].gc = &nmk_gpio_chips[i]->chip; } nmk_pinctrl_desc.pins = npct->soc->pins; nmk_pinctrl_desc.npins = npct->soc->npins; npct->dev = &pdev->dev; npct->pctl = pinctrl_register(&nmk_pinctrl_desc, &pdev->dev, npct); if (!npct->pctl) { dev_err(&pdev->dev, "could not register Nomadik pinctrl driver\n"); return -EINVAL; } /* We will handle a range of GPIO pins */ for (i = 0; i < npct->soc->gpio_num_ranges; i++) pinctrl_add_gpio_range(npct->pctl, &npct->soc->gpio_ranges[i]); platform_set_drvdata(pdev, npct); dev_info(&pdev->dev, "initialized Nomadik pin control driver\n"); return 0; }
int wmt_pinctrl_probe(struct platform_device *pdev, struct wmt_pinctrl_data *data) { int err; struct resource *res; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); data->base = devm_request_and_ioremap(&pdev->dev, res); if (!data->base) { dev_err(&pdev->dev, "failed to map memory resource\n"); return -EBUSY; } wmt_desc.pins = data->pins; wmt_desc.npins = data->npins; data->gpio_chip = wmt_gpio_chip; data->gpio_chip.dev = &pdev->dev; data->gpio_chip.of_node = pdev->dev.of_node; data->gpio_chip.ngpio = data->nbanks * 32; platform_set_drvdata(pdev, data); data->dev = &pdev->dev; data->pctl_dev = pinctrl_register(&wmt_desc, &pdev->dev, data); if (!data->pctl_dev) { dev_err(&pdev->dev, "Failed to register pinctrl\n"); return -EINVAL; } err = gpiochip_add(&data->gpio_chip); if (err) { dev_err(&pdev->dev, "could not add GPIO chip\n"); goto fail_gpio; } err = gpiochip_add_pin_range(&data->gpio_chip, dev_name(data->dev), 0, 0, data->nbanks * 32); if (err) goto fail_range; dev_info(&pdev->dev, "Pin controller initialized\n"); return 0; fail_range: if (gpiochip_remove(&data->gpio_chip)) dev_err(&pdev->dev, "failed to remove gpio chip\n"); fail_gpio: pinctrl_unregister(data->pctl_dev); return err; }
static int pcs_probe(struct device_d *dev) { struct pinctrl_single *pcs; struct device_node *np = dev->device_node; int ret = 0; pcs = xzalloc(sizeof(*pcs)); pcs->base = dev_request_mem_region(dev, 0); pcs->pinctrl.dev = dev; pcs->pinctrl.ops = &pcs_ops; ret = of_property_read_u32(np, "pinctrl-single,register-width", &pcs->width); if (ret) { dev_dbg(dev, "no pinctrl-single,register-width property\n"); goto out; } switch (pcs->width) { case 8: pcs->read = pcs_readb; pcs->write = pcs_writeb; break; case 16: pcs->read = pcs_readw; pcs->write = pcs_writew; break; case 32: pcs->read = pcs_readl; pcs->write = pcs_writel; break; default: ret = -EINVAL; dev_dbg(dev, "invalid register width: %d\n", pcs->width); goto out; } ret = pinctrl_register(&pcs->pinctrl); if (ret) goto out; return 0; out: free(pcs); return ret; }
int __devinit mxs_pinctrl_probe(struct platform_device *pdev, struct mxs_pinctrl_soc_data *soc) { struct device_node *np = pdev->dev.of_node; struct mxs_pinctrl_data *d; int ret; d = devm_kzalloc(&pdev->dev, sizeof(*d), GFP_KERNEL); if (!d) return -ENOMEM; d->dev = &pdev->dev; d->soc = soc; d->base = of_iomap(np, 0); if (!d->base) return -EADDRNOTAVAIL; mxs_pinctrl_desc.pins = d->soc->pins; mxs_pinctrl_desc.npins = d->soc->npins; mxs_pinctrl_desc.name = dev_name(&pdev->dev); platform_set_drvdata(pdev, d); ret = mxs_pinctrl_probe_dt(pdev, d); if (ret) { dev_err(&pdev->dev, "dt probe failed: %d\n", ret); goto err; } d->pctl = pinctrl_register(&mxs_pinctrl_desc, &pdev->dev, d); if (!d->pctl) { dev_err(&pdev->dev, "Couldn't register MXS pinctrl driver\n"); ret = -EINVAL; goto err; } return 0; err: platform_set_drvdata(pdev, NULL); iounmap(d->base); return ret; }
static int lpc18xx_scu_probe(struct platform_device *pdev) { struct lpc18xx_scu_data *scu; struct resource *res; int ret; scu = devm_kzalloc(&pdev->dev, sizeof(*scu), GFP_KERNEL); if (!scu) return -ENOMEM; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); scu->base = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(scu->base)) return PTR_ERR(scu->base); scu->clk = devm_clk_get(&pdev->dev, NULL); if (IS_ERR(scu->clk)) { dev_err(&pdev->dev, "Input clock not found.\n"); return PTR_ERR(scu->clk); } ret = lpc18xx_create_group_func_map(&pdev->dev, scu); if (ret) { dev_err(&pdev->dev, "Unable to create group func map.\n"); return ret; } ret = clk_prepare_enable(scu->clk); if (ret) { dev_err(&pdev->dev, "Unable to enable clock.\n"); return ret; } platform_set_drvdata(pdev, scu); scu->pctl = pinctrl_register(&lpc18xx_scu_desc, &pdev->dev, scu); if (IS_ERR(scu->pctl)) { dev_err(&pdev->dev, "Could not register pinctrl driver\n"); clk_disable_unprepare(scu->clk); return PTR_ERR(scu->pctl); } return 0; }
static int __devinit sh_pfc_pinctrl_probe(struct platform_device *pdev) { struct sh_pfc *pfc; int ret; if (unlikely(!sh_pfc_pmx)) return -ENODEV; pfc = sh_pfc_pmx->pfc; ret = sh_pfc_map_gpios(pfc, sh_pfc_pmx); if (unlikely(ret != 0)) return ret; ret = sh_pfc_map_functions(pfc, sh_pfc_pmx); if (unlikely(ret != 0)) goto free_pads; sh_pfc_pmx->pctl = pinctrl_register(&sh_pfc_pinctrl_desc, &pdev->dev, sh_pfc_pmx); if (IS_ERR(sh_pfc_pmx->pctl)) { ret = PTR_ERR(sh_pfc_pmx->pctl); goto free_functions; } sh_pfc_gpio_range.npins = pfc->last_gpio - pfc->first_gpio + 1; sh_pfc_gpio_range.base = pfc->first_gpio; sh_pfc_gpio_range.pin_base = pfc->first_gpio; pinctrl_add_gpio_range(sh_pfc_pmx->pctl, &sh_pfc_gpio_range); platform_set_drvdata(pdev, sh_pfc_pmx); return 0; free_functions: kfree(sh_pfc_pmx->functions); free_pads: kfree(sh_pfc_pmx->pads); kfree(sh_pfc_pmx); return ret; }
static int zynq_pinctrl_probe(struct platform_device *pdev) { struct resource *res; struct zynq_pinctrl *pctrl; pctrl = devm_kzalloc(&pdev->dev, sizeof(*pctrl), GFP_KERNEL); if (!pctrl) return -ENOMEM; pctrl->syscon = syscon_regmap_lookup_by_phandle(pdev->dev.of_node, "syscon"); if (IS_ERR(pctrl->syscon)) { dev_err(&pdev->dev, "unable to get syscon\n"); return PTR_ERR(pctrl->syscon); } res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) { dev_err(&pdev->dev, "missing IO resource\n"); return -ENODEV; } pctrl->pctrl_offset = res->start; pctrl->groups = zynq_pctrl_groups; pctrl->ngroups = ARRAY_SIZE(zynq_pctrl_groups); pctrl->funcs = zynq_pmux_functions; pctrl->nfuncs = ARRAY_SIZE(zynq_pmux_functions); pctrl->pctrl = pinctrl_register(&zynq_desc, &pdev->dev, pctrl); if (IS_ERR(pctrl->pctrl)) return PTR_ERR(pctrl->pctrl); platform_set_drvdata(pdev, pctrl); dev_info(&pdev->dev, "zynq pinctrl initialized\n"); return 0; }
static int oxnas_pinctrl_probe(struct platform_device *pdev) { struct oxnas_pinctrl *pctl; pctl = devm_kzalloc(&pdev->dev, sizeof(*pctl), GFP_KERNEL); if (!pctl) return -ENOMEM; pctl->dev = &pdev->dev; dev_set_drvdata(&pdev->dev, pctl); pctl->regmap = syscon_regmap_lookup_by_phandle(pdev->dev.of_node, "oxsemi,sys-ctrl"); if (IS_ERR(pctl->regmap)) { dev_err(&pdev->dev, "failed to get sys ctrl regmap\n"); return -ENODEV; } pctl->pins = oxnas_pins; pctl->npins = ARRAY_SIZE(oxnas_pins); pctl->functions = oxnas_functions; pctl->nfunctions = ARRAY_SIZE(oxnas_functions); pctl->groups = oxnas_groups; pctl->ngroups = ARRAY_SIZE(oxnas_groups); pctl->gpio_banks = oxnas_gpio_banks; pctl->nbanks = ARRAY_SIZE(oxnas_gpio_banks); oxnas_pinctrl_desc.pins = pctl->pins; oxnas_pinctrl_desc.npins = pctl->npins; pctl->pctldev = pinctrl_register(&oxnas_pinctrl_desc, &pdev->dev, pctl); if (IS_ERR(pctl->pctldev)) { dev_err(&pdev->dev, "Failed to register pinctrl device\n"); return PTR_ERR(pctl->pctldev); } return 0; }
static int axp_pinctrl_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct axp_pinctrl *pctl; struct pinctrl_pin_desc *pins; int ret; int i, rc; /* allocate and initialize axp-pinctrl */ pctl = devm_kzalloc(dev, sizeof(*pctl), GFP_KERNEL); if (!pctl) { dev_err(dev, "allocate memory for axp-pinctrl structure failed\n"); return -ENOMEM; } platform_set_drvdata(pdev, pctl); pctl->dev = dev; pctl->desc = &axp_pinctrl_pins_desc; ret = axp_pinctrl_build_state(pdev); if (ret) { dev_err(&pdev->dev, "dt probe failed: %d\n", ret); return ret; } /* register axp pinctrl */ pins = devm_kzalloc(&pdev->dev, pctl->desc->npins * sizeof(*pins), GFP_KERNEL); if (!pins) { return -ENOMEM; } for (i = 0; i < pctl->desc->npins; i++) { pins[i] = pctl->desc->pins[i].pin; } axp_pinctrl_desc.name = dev_name(&pdev->dev); axp_pinctrl_desc.owner = THIS_MODULE; axp_pinctrl_desc.pins = pins; axp_pinctrl_desc.npins = pctl->desc->npins; pctl->pctl_dev = pinctrl_register(&axp_pinctrl_desc, dev, pctl); if (!pctl->pctl_dev) { rc = gpiochip_remove(pctl->gpio_chip); if (rc < 0) return rc; return -EINVAL; } /* initialize axp-gpio-chip */ pctl->gpio_chip = &axp_gpio_chip; pctl->gpio_chip->dev = dev; ret = gpiochip_add(pctl->gpio_chip); if (ret) { dev_err(dev, "could not add GPIO chip\n"); return ret; } for (i = 0; i < pctl->desc->npins; i++) { const struct axp_desc_pin *pin = pctl->desc->pins + i; ret = gpiochip_add_pin_range(pctl->gpio_chip, dev_name(&pdev->dev), pin->pin.number, pin->pin.number, 1); if (ret) { dev_err(dev, "could not add GPIO pin range\n"); rc = gpiochip_remove(pctl->gpio_chip); if (rc < 0) return rc; return ret; } } axp_pinctrl_parse_pin_cfg(pdev); return 0; }
static int pinctrl_tegra_xusb_probe(struct device_d *dev) { struct resource *iores; struct tegra_xusb_padctl *padctl; struct phy *phy; int err; padctl = xzalloc(sizeof(*padctl)); dev->priv = padctl; padctl->dev = dev; dev_get_drvdata(dev, (const void **)&padctl->soc); iores = dev_request_mem_resource(dev, 0); if (IS_ERR(iores)) { dev_err(dev, "Could not get iomem region\n"); return PTR_ERR(iores); } padctl->regs = IOMEM(iores->start); padctl->rst = reset_control_get(dev, NULL); if (IS_ERR(padctl->rst)) return PTR_ERR(padctl->rst); err = reset_control_deassert(padctl->rst); if (err < 0) return err; padctl->pinctrl.dev = dev; padctl->pinctrl.ops = &pinctrl_tegra_xusb_ops; err = pinctrl_register(&padctl->pinctrl); if (err) { dev_err(dev, "failed to register pincontrol\n"); err = -ENODEV; goto reset; } phy = phy_create(dev, NULL, &pcie_phy_ops, NULL); if (IS_ERR(phy)) { err = PTR_ERR(phy); goto unregister; } padctl->phys[TEGRA_XUSB_PADCTL_PCIE] = phy; phy_set_drvdata(phy, padctl); phy = phy_create(dev, NULL, &sata_phy_ops, NULL); if (IS_ERR(phy)) { err = PTR_ERR(phy); goto unregister; } padctl->phys[TEGRA_XUSB_PADCTL_SATA] = phy; phy_set_drvdata(phy, padctl); padctl->provider = of_phy_provider_register(dev, tegra_xusb_padctl_xlate); if (IS_ERR(padctl->provider)) { err = PTR_ERR(padctl->provider); dev_err(dev, "failed to register PHYs: %d\n", err); goto unregister; } return 0; unregister: pinctrl_unregister(&padctl->pinctrl); reset: reset_control_assert(padctl->rst); return err; }
static int omap_rtc_probe(struct platform_device *pdev) { struct omap_rtc *rtc; struct resource *res; u8 reg, mask, new_ctrl; const struct platform_device_id *id_entry; const struct of_device_id *of_id; int ret; rtc = devm_kzalloc(&pdev->dev, sizeof(*rtc), GFP_KERNEL); if (!rtc) return -ENOMEM; of_id = of_match_device(omap_rtc_of_match, &pdev->dev); if (of_id) { rtc->type = of_id->data; rtc->is_pmic_controller = rtc->type->has_pmic_mode && of_property_read_bool(pdev->dev.of_node, "system-power-controller"); } else { id_entry = platform_get_device_id(pdev); rtc->type = (void *)id_entry->driver_data; } rtc->irq_timer = platform_get_irq(pdev, 0); if (rtc->irq_timer <= 0) return -ENOENT; rtc->irq_alarm = platform_get_irq(pdev, 1); if (rtc->irq_alarm <= 0) return -ENOENT; rtc->clk = devm_clk_get(&pdev->dev, "ext-clk"); if (!IS_ERR(rtc->clk)) rtc->has_ext_clk = true; else rtc->clk = devm_clk_get(&pdev->dev, "int-clk"); if (!IS_ERR(rtc->clk)) clk_prepare_enable(rtc->clk); res = platform_get_resource(pdev, IORESOURCE_MEM, 0); rtc->base = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(rtc->base)) return PTR_ERR(rtc->base); platform_set_drvdata(pdev, rtc); /* Enable the clock/module so that we can access the registers */ pm_runtime_enable(&pdev->dev); pm_runtime_get_sync(&pdev->dev); rtc->type->unlock(rtc); /* * disable interrupts * * NOTE: ALARM2 is not cleared on AM3352 if rtc_write (writeb) is used */ rtc_writel(rtc, OMAP_RTC_INTERRUPTS_REG, 0); /* enable RTC functional clock */ if (rtc->type->has_32kclk_en) { reg = rtc_read(rtc, OMAP_RTC_OSC_REG); rtc_writel(rtc, OMAP_RTC_OSC_REG, reg | OMAP_RTC_OSC_32KCLK_EN); } /* clear old status */ reg = rtc_read(rtc, OMAP_RTC_STATUS_REG); mask = OMAP_RTC_STATUS_ALARM; if (rtc->type->has_pmic_mode) mask |= OMAP_RTC_STATUS_ALARM2; if (rtc->type->has_power_up_reset) { mask |= OMAP_RTC_STATUS_POWER_UP; if (reg & OMAP_RTC_STATUS_POWER_UP) dev_info(&pdev->dev, "RTC power up reset detected\n"); } if (reg & mask) rtc_write(rtc, OMAP_RTC_STATUS_REG, reg & mask); /* On boards with split power, RTC_ON_NOFF won't reset the RTC */ reg = rtc_read(rtc, OMAP_RTC_CTRL_REG); if (reg & OMAP_RTC_CTRL_STOP) dev_info(&pdev->dev, "already running\n"); /* force to 24 hour mode */ new_ctrl = reg & (OMAP_RTC_CTRL_SPLIT | OMAP_RTC_CTRL_AUTO_COMP); new_ctrl |= OMAP_RTC_CTRL_STOP; /* * BOARD-SPECIFIC CUSTOMIZATION CAN GO HERE: * * - Device wake-up capability setting should come through chip * init logic. OMAP1 boards should initialize the "wakeup capable" * flag in the platform device if the board is wired right for * being woken up by RTC alarm. For OMAP-L138, this capability * is built into the SoC by the "Deep Sleep" capability. * * - Boards wired so RTC_ON_nOFF is used as the reset signal, * rather than nPWRON_RESET, should forcibly enable split * power mode. (Some chip errata report that RTC_CTRL_SPLIT * is write-only, and always reads as zero...) */ if (new_ctrl & OMAP_RTC_CTRL_SPLIT) dev_info(&pdev->dev, "split power mode\n"); if (reg != new_ctrl) rtc_write(rtc, OMAP_RTC_CTRL_REG, new_ctrl); /* * If we have the external clock then switch to it so we can keep * ticking across suspend. */ if (rtc->has_ext_clk) { reg = rtc_read(rtc, OMAP_RTC_OSC_REG); reg &= ~OMAP_RTC_OSC_OSC32K_GZ_DISABLE; reg |= OMAP_RTC_OSC_32KCLK_EN | OMAP_RTC_OSC_SEL_32KCLK_SRC; rtc_writel(rtc, OMAP_RTC_OSC_REG, reg); } rtc->type->lock(rtc); device_init_wakeup(&pdev->dev, true); rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name, &omap_rtc_ops, THIS_MODULE); if (IS_ERR(rtc->rtc)) { ret = PTR_ERR(rtc->rtc); goto err; } /* handle periodic and alarm irqs */ ret = devm_request_irq(&pdev->dev, rtc->irq_timer, rtc_irq, 0, dev_name(&rtc->rtc->dev), rtc); if (ret) goto err; if (rtc->irq_timer != rtc->irq_alarm) { ret = devm_request_irq(&pdev->dev, rtc->irq_alarm, rtc_irq, 0, dev_name(&rtc->rtc->dev), rtc); if (ret) goto err; } if (rtc->is_pmic_controller) { if (!pm_power_off) { omap_rtc_power_off_rtc = rtc; pm_power_off = omap_rtc_power_off; } } /* Support ext_wakeup pinconf */ rtc_pinctrl_desc.name = dev_name(&pdev->dev); rtc->pctldev = pinctrl_register(&rtc_pinctrl_desc, &pdev->dev, rtc); if (IS_ERR(rtc->pctldev)) { dev_err(&pdev->dev, "Couldn't register pinctrl driver\n"); return PTR_ERR(rtc->pctldev); } return 0; err: device_init_wakeup(&pdev->dev, false); rtc->type->lock(rtc); pm_runtime_put_sync(&pdev->dev); pm_runtime_disable(&pdev->dev); return ret; }
static int pmic_mpp_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct pinctrl_pin_desc *pindesc; struct pinctrl_desc *pctrldesc; struct pmic_mpp_pad *pad, *pads; struct pmic_mpp_state *state; int ret, npins, i; u32 reg; ret = of_property_read_u32(dev->of_node, "reg", ®); if (ret < 0) { dev_err(dev, "missing base address"); return ret; } npins = platform_irq_count(pdev); if (!npins) return -EINVAL; if (npins < 0) return npins; BUG_ON(npins > ARRAY_SIZE(pmic_mpp_groups)); state = devm_kzalloc(dev, sizeof(*state), GFP_KERNEL); if (!state) return -ENOMEM; platform_set_drvdata(pdev, state); state->dev = &pdev->dev; state->map = dev_get_regmap(dev->parent, NULL); pindesc = devm_kcalloc(dev, npins, sizeof(*pindesc), GFP_KERNEL); if (!pindesc) return -ENOMEM; pads = devm_kcalloc(dev, npins, sizeof(*pads), GFP_KERNEL); if (!pads) return -ENOMEM; pctrldesc = devm_kzalloc(dev, sizeof(*pctrldesc), GFP_KERNEL); if (!pctrldesc) return -ENOMEM; pctrldesc->pctlops = &pmic_mpp_pinctrl_ops; pctrldesc->pmxops = &pmic_mpp_pinmux_ops; pctrldesc->confops = &pmic_mpp_pinconf_ops; pctrldesc->owner = THIS_MODULE; pctrldesc->name = dev_name(dev); pctrldesc->pins = pindesc; pctrldesc->npins = npins; pctrldesc->num_custom_params = ARRAY_SIZE(pmic_mpp_bindings); pctrldesc->custom_params = pmic_mpp_bindings; #ifdef CONFIG_DEBUG_FS pctrldesc->custom_conf_items = pmic_conf_items; #endif for (i = 0; i < npins; i++, pindesc++) { pad = &pads[i]; pindesc->drv_data = pad; pindesc->number = i; pindesc->name = pmic_mpp_groups[i]; pad->irq = platform_get_irq(pdev, i); if (pad->irq < 0) return pad->irq; pad->base = reg + i * PMIC_MPP_ADDRESS_RANGE; ret = pmic_mpp_populate(state, pad); if (ret < 0) return ret; } state->chip = pmic_mpp_gpio_template; state->chip.parent = dev; state->chip.base = -1; state->chip.ngpio = npins; state->chip.label = dev_name(dev); state->chip.of_gpio_n_cells = 2; state->chip.can_sleep = false; state->ctrl = pinctrl_register(pctrldesc, dev, state); if (IS_ERR(state->ctrl)) return PTR_ERR(state->ctrl); ret = gpiochip_add_data(&state->chip, state); if (ret) { dev_err(state->dev, "can't add gpio chip\n"); goto err_chip; } ret = gpiochip_add_pin_range(&state->chip, dev_name(dev), 0, 0, npins); if (ret) { dev_err(dev, "failed to add pin range\n"); goto err_range; } return 0; err_range: gpiochip_remove(&state->chip); err_chip: pinctrl_unregister(state->ctrl); return ret; }
int amlogic_pmx_probe(struct platform_device *pdev, struct amlogic_pinctrl_soc_data *soc_data) { struct amlogic_pmx *apmx; int ret, val; pr_info("Init pinux probe!\n"); apmx = devm_kzalloc(&pdev->dev, sizeof(*apmx), GFP_KERNEL); if (!apmx) { dev_err(&pdev->dev, "Can't alloc amlogic_pmx\n"); return -ENOMEM; } apmx->dev = &pdev->dev; apmx->soc = soc_data; platform_set_drvdata(pdev, apmx); ret = meson_pinctrl_parse_dt(apmx, pdev->dev.of_node); if (ret) return ret; ret = of_property_read_u32(pdev->dev.of_node, "#pinmux-cells", &val); if (ret) { dev_err(&pdev->dev, "dt probe #pinmux-cells failed: %d\n", ret); goto err; } apmx->pinmux_cell = val; ret = amlogic_pinctrl_probe_dt(pdev, apmx); if (ret) { dev_err(&pdev->dev, "dt probe failed: %d\n", ret); goto err; } #ifdef AML_PIN_DEBUG_GUP amlogic_dump_pinctrl_data(pdev); #endif amlogic_gpio_ranges.npins = apmx->soc->npins; amlogic_pmx_desc.name = dev_name(&pdev->dev); amlogic_pmx_desc.pins = apmx->soc->pins; amlogic_pmx_desc.npins = apmx->soc->npins; apmx->pctl = pinctrl_register(&amlogic_pmx_desc, &pdev->dev, apmx); if (!apmx->pctl) { dev_err(&pdev->dev, "Couldn't register pinctrl driver\n"); goto err; } ret = meson_gpiolib_register(apmx); if (ret) { pinctrl_unregister(apmx->pctl); return ret; } /* pinctrl_add_gpio_range(apmx->pctl, &amlogic_gpio_ranges); */ pctdev_name = dev_name(&pdev->dev); pinctrl_provide_dummies(); dev_info(&pdev->dev, "Probed amlogic pinctrl driver\n"); pctl = apmx->pctl; int_reg = meson_map(&pdev->dev, pdev->dev.of_node, "Int"); gl_pmx = apmx; return 0; err: devm_kfree(&pdev->dev, apmx); return ret; }
static int dc_pinctrl_probe(struct platform_device *pdev) { struct dc_pinmap *pmap; struct resource *r; struct pinctrl_pin_desc *pins; struct pinctrl_desc *pctl_desc; char *pin_names; int name_len = strlen("GP_xx") + 1; int i, j, ret; pmap = devm_kzalloc(&pdev->dev, sizeof(*pmap), GFP_KERNEL); if (!pmap) return -ENOMEM; r = platform_get_resource(pdev, IORESOURCE_MEM, 0); pmap->regs = devm_ioremap_resource(&pdev->dev, r); if (IS_ERR(pmap->regs)) return PTR_ERR(pmap->regs); pins = devm_kzalloc(&pdev->dev, sizeof(*pins)*PINS_COUNT, GFP_KERNEL); if (!pins) return -ENOMEM; pin_names = devm_kzalloc(&pdev->dev, name_len * PINS_COUNT, GFP_KERNEL); if (!pin_names) return -ENOMEM; for (i = 0; i < PIN_COLLECTIONS; i++) { for (j = 0; j < PINS_PER_COLLECTION; j++) { int pin_id = i*PINS_PER_COLLECTION + j; char *name = &pin_names[pin_id * name_len]; snprintf(name, name_len, "GP_%c%c", 'A'+i, '0'+j); pins[pin_id].number = pin_id; pins[pin_id].name = name; pmap->pin_names[pin_id] = name; } } pctl_desc = devm_kzalloc(&pdev->dev, sizeof(*pctl_desc), GFP_KERNEL); if (!pctl_desc) return -ENOMEM; pctl_desc->name = DRIVER_NAME, pctl_desc->owner = THIS_MODULE, pctl_desc->pctlops = &dc_pinctrl_ops, pctl_desc->pmxops = &dc_pmxops, pctl_desc->npins = PINS_COUNT; pctl_desc->pins = pins; pmap->desc = pctl_desc; pmap->dev = &pdev->dev; pmap->pctl = pinctrl_register(pctl_desc, &pdev->dev, pmap); if (IS_ERR(pmap->pctl)) { dev_err(&pdev->dev, "pinctrl driver registration failed\n"); return PTR_ERR(pmap->pctl); } ret = dc_gpiochip_add(pmap, pdev->dev.of_node); if (ret < 0) { pinctrl_unregister(pmap->pctl); return ret; } return 0; }