static int as3722_pinctrl_remove(struct platform_device *pdev) { struct as3722_pctrl_info *as_pci = platform_get_drvdata(pdev); gpiochip_remove(&as_pci->gpio_chip); pinctrl_unregister(as_pci->pctl); return 0; }
static int pmic_mpp_remove(struct platform_device *pdev) { struct pmic_mpp_state *state = platform_get_drvdata(pdev); gpiochip_remove(&state->chip); pinctrl_unregister(state->ctrl); return 0; }
static int zynq_pinctrl_remove(struct platform_device *pdev) { struct zynq_pinctrl *pctrl = platform_get_drvdata(pdev); pinctrl_unregister(pctrl->pctrl); return 0; }
int pxa3xx_pinctrl_unregister(struct platform_device *pdev) { struct pxa3xx_pinmux_info *info = platform_get_drvdata(pdev); pinctrl_unregister(info->pctrl); platform_set_drvdata(pdev, NULL); return 0; }
static int dc_pinctrl_remove(struct platform_device *pdev) { struct dc_pinmap *pmap = platform_get_drvdata(pdev); pinctrl_unregister(pmap->pctl); gpiochip_remove(&pmap->chip); return 0; }
int wmt_pinctrl_remove(struct platform_device *pdev) { struct wmt_pinctrl_data *data = platform_get_drvdata(pdev); gpiochip_remove(&data->gpio_chip); pinctrl_unregister(data->pctl_dev); return 0; }
int sh_pfc_unregister_pinctrl(struct sh_pfc *pfc) { struct sh_pfc_pinctrl *pmx = pfc->pinctrl; pinctrl_unregister(pmx->pctl); pfc->pinctrl = NULL; return 0; }
int mxs_pinctrl_remove(struct platform_device *pdev) { struct mxs_pinctrl_data *d = platform_get_drvdata(pdev); pinctrl_unregister(d->pctl); iounmap(d->base); return 0; }
static int lpc18xx_scu_remove(struct platform_device *pdev) { struct lpc18xx_scu_data *scu = platform_get_drvdata(pdev); pinctrl_unregister(scu->pctl); clk_disable_unprepare(scu->clk); 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 axp_pinctrl_remove(struct platform_device *pdev) { struct axp_pinctrl *pc = platform_get_drvdata(pdev); int rc; pinctrl_unregister(pc->pctl_dev); rc = gpiochip_remove(pc->gpio_chip); if (rc < 0) return rc; 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; }
int wmt_pinctrl_remove(struct platform_device *pdev) { struct wmt_pinctrl_data *data = platform_get_drvdata(pdev); int err; err = gpiochip_remove(&data->gpio_chip); if (err) dev_err(&pdev->dev, "failed to remove gpio chip\n"); pinctrl_unregister(data->pctl_dev); return 0; }
static int __devexit sh_pfc_pinctrl_remove(struct platform_device *pdev) { struct sh_pfc_pinctrl *pmx = platform_get_drvdata(pdev); pinctrl_unregister(pmx->pctl); platform_set_drvdata(pdev, NULL); kfree(sh_pfc_pmx->functions); kfree(sh_pfc_pmx->pads); kfree(sh_pfc_pmx); return 0; }
static int __exit omap_rtc_remove(struct platform_device *pdev) { struct omap_rtc *rtc = platform_get_drvdata(pdev); u8 reg; if (pm_power_off == omap_rtc_power_off && omap_rtc_power_off_rtc == rtc) { pm_power_off = NULL; omap_rtc_power_off_rtc = NULL; } device_init_wakeup(&pdev->dev, 0); if (!IS_ERR(rtc->clk)) clk_disable_unprepare(rtc->clk); rtc->type->unlock(rtc); /* leave rtc running, but disable irqs */ rtc_write(rtc, OMAP_RTC_INTERRUPTS_REG, 0); if (rtc->has_ext_clk) { reg = rtc_read(rtc, OMAP_RTC_OSC_REG); reg &= ~OMAP_RTC_OSC_SEL_32KCLK_SRC; rtc_write(rtc, OMAP_RTC_OSC_REG, reg); } rtc->type->lock(rtc); /* Disable the clock/module */ pm_runtime_put_sync(&pdev->dev); pm_runtime_disable(&pdev->dev); /* Remove ext_wakeup pinconf */ pinctrl_unregister(rtc->pctldev); 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 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; }
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 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_remove(struct platform_device *pdev) { struct amlogic_pmx *pmx = platform_get_drvdata(pdev); pinctrl_unregister(pmx->pctl); return 0; }