void pinconf_show_setting(struct seq_file *s, struct pinctrl_setting const *setting) { struct pinctrl_dev *pctldev = setting->pctldev; const struct pinctrl_ops *pctlops = pctldev->desc->pctlops; struct pin_desc *desc; switch (setting->type) { case PIN_MAP_TYPE_CONFIGS_PIN: desc = pin_desc_get(setting->pctldev, setting->data.configs.group_or_pin); seq_printf(s, "pin %s (%d)", desc->name, setting->data.configs.group_or_pin); break; case PIN_MAP_TYPE_CONFIGS_GROUP: seq_printf(s, "group %s (%d)", pctlops->get_group_name(pctldev, setting->data.configs.group_or_pin), setting->data.configs.group_or_pin); break; default: break; } /* * FIXME: We should really get the pin controler to dump the config * values, so they can be decoded to something meaningful. */ pinconf_show_config(s, pctldev, setting->data.configs.configs, setting->data.configs.num_configs); }
static int pinconf_pins_show(struct seq_file *s, void *what) { struct pinctrl_dev *pctldev = s->private; unsigned i, pin; seq_puts(s, "Pin config settings per pin\n"); seq_puts(s, "Format: pin (name): configs\n"); mutex_lock(&pctldev->mutex); /* The pin number can be retrived from the pin controller descriptor */ for (i = 0; i < pctldev->desc->npins; i++) { struct pin_desc *desc; pin = pctldev->desc->pins[i].number; desc = pin_desc_get(pctldev, pin); /* Skip if we cannot search the pin */ if (desc == NULL) continue; seq_printf(s, "pin %d (%s): ", pin, desc->name); pinconf_dump_pin(pctldev, s, pin); seq_printf(s, "\n"); } mutex_unlock(&pctldev->mutex); return 0; }
static int amlogic_pinctrl_request(struct pinctrl_dev *pctldev, unsigned offset) { struct pin_desc *desc; desc = pin_desc_get(pctldev, offset); if(desc->gpio_owner){ printk("%s is using the pin %s as gpio\n",desc->gpio_owner,desc->name); return -EINVAL; } return 0; }
static int amlogic_gpio_request_enable (struct pinctrl_dev *pctldev, struct pinctrl_gpio_range *range, unsigned offset) { struct pin_desc *desc; desc = pin_desc_get(pctldev, offset); if(desc->mux_owner){ printk("%s is using the pin %s as pinmux\n",desc->mux_owner,desc->name); return -EINVAL; } return 0; }
static int pinmux_pins_show(struct seq_file *s, void *what) { struct pinctrl_dev *pctldev = s->private; const struct pinctrl_ops *pctlops = pctldev->desc->pctlops; const struct pinmux_ops *pmxops = pctldev->desc->pmxops; unsigned i, pin; if (!pmxops) return 0; seq_puts(s, "Pinmux settings per pin\n"); seq_puts(s, "Format: pin (name): mux_owner gpio_owner hog?\n"); mutex_lock(&pinctrl_mutex); /* The pin number can be retrived from the pin controller descriptor */ for (i = 0; i < pctldev->desc->npins; i++) { struct pin_desc *desc; bool is_hog = false; pin = pctldev->desc->pins[i].number; desc = pin_desc_get(pctldev, pin); /* Skip if we cannot search the pin */ if (desc == NULL) continue; if (desc->mux_owner && !strcmp(desc->mux_owner, pinctrl_dev_get_name(pctldev))) is_hog = true; seq_printf(s, "pin %d (%s): %s %s%s", pin, desc->name ? desc->name : "unnamed", desc->mux_owner ? desc->mux_owner : "(MUX UNCLAIMED)", desc->gpio_owner ? desc->gpio_owner : "(GPIO UNCLAIMED)", is_hog ? " (HOG)" : ""); if (desc->mux_setting) seq_printf(s, " function %s group %s\n", pmxops->get_function_name(pctldev, desc->mux_setting->func), pctlops->get_group_name(pctldev, desc->mux_setting->group)); else seq_printf(s, "\n"); } mutex_unlock(&pinctrl_mutex); return 0; }
void pinmux_disable_setting(struct pinctrl_setting const *setting) { struct pinctrl_dev *pctldev = setting->pctldev; const struct pinctrl_ops *pctlops = pctldev->desc->pctlops; int ret = 0; const unsigned *pins = NULL; unsigned num_pins = 0; int i; struct pin_desc *desc; if (pctlops->get_group_pins) ret = pctlops->get_group_pins(pctldev, setting->data.mux.group, &pins, &num_pins); if (ret) { const char *gname; /* errors only affect debug data, so just warn */ gname = pctlops->get_group_name(pctldev, setting->data.mux.group); dev_warn(pctldev->dev, "could not get pins for group %s\n", gname); num_pins = 0; } /* Flag the descs that no setting is active */ for (i = 0; i < num_pins; i++) { desc = pin_desc_get(pctldev, pins[i]); if (desc == NULL) { dev_warn(pctldev->dev, "could not get pin desc for pin %d\n", pins[i]); continue; } if (desc->mux_setting == &(setting->data.mux)) { desc->mux_setting = NULL; /* And release the pin */ pin_free(pctldev, pins[i], NULL); } else { const char *gname; gname = pctlops->get_group_name(pctldev, setting->data.mux.group); dev_warn(pctldev->dev, "not freeing pin %d (%s) as part of " "deactivating group %s - it is already " "used for some other setting", pins[i], desc->name, gname); } } }
static int amlogic_gpio_request_enable(struct pinctrl_dev *pctldev, struct pinctrl_gpio_range *range, unsigned offset) { struct pin_desc *desc; struct amlogic_pmx *pmx = pinctrl_dev_get_drvdata(pctldev); desc = pin_desc_get(pctldev, offset); if (desc->mux_owner) { pr_info("%s is using the pin %s as pinmux\n", desc->mux_owner, desc->name); return -EINVAL; } return pmx->soc->meson_clear_pinmux(pmx, offset); }
static int imx1_pinconf_set(struct pinctrl_dev *pctldev, unsigned pin_id, unsigned long *configs, unsigned num_configs) { struct imx1_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev); int i; for (i = 0; i != num_configs; ++i) { imx1_write_bit(ipctl, pin_id, configs[i] & 0x01, MX1_PUEN); dev_dbg(ipctl->dev, "pinconf set pullup pin %s\n", pin_desc_get(pctldev, pin_id)->name); } return 0; }
/** * pin_free() - release a single muxed in pin so something else can be muxed * @pctldev: pin controller device handling this pin * @pin: the pin to free * @gpio_range: the range matching the GPIO pin if this is a request for a * single GPIO pin * * This function returns a pointer to the previous owner. This is used * for callers that dynamically allocate an owner name so it can be freed * once the pin is free. This is done for GPIO request functions. */ static const char *pin_free(struct pinctrl_dev *pctldev, int pin, struct pinctrl_gpio_range *gpio_range) { const struct pinmux_ops *ops = pctldev->desc->pmxops; struct pin_desc *desc; const char *owner; desc = pin_desc_get(pctldev, pin); if (desc == NULL) { dev_err(pctldev->dev, "pin is not registered so it cannot be freed\n"); return NULL; } if (!gpio_range) { /* * A pin should not be freed more times than allocated. */ if (WARN_ON(!desc->mux_usecount)) return NULL; desc->mux_usecount--; if (desc->mux_usecount) return NULL; } /* * If there is no kind of request function for the pin we just assume * we got it by default and proceed. */ if (gpio_range && ops->gpio_disable_free) ops->gpio_disable_free(pctldev, gpio_range, pin); else if (ops->free) ops->free(pctldev, pin); if (gpio_range) { owner = desc->gpio_owner; desc->gpio_owner = NULL; } else { owner = desc->mux_owner; desc->mux_owner = NULL; desc->mux_setting = NULL; } module_put(pctldev->owner); return owner; }
void pinconf_show_setting(struct seq_file *s, struct pinctrl_setting const *setting) { struct pinctrl_dev *pctldev = setting->pctldev; const struct pinctrl_ops *pctlops = pctldev->desc->pctlops; const struct pinconf_ops *confops = pctldev->desc->confops; struct pin_desc *desc; int i; switch (setting->type) { case PIN_MAP_TYPE_CONFIGS_PIN: desc = pin_desc_get(setting->pctldev, setting->data.configs.group_or_pin); seq_printf(s, "pin %s (%d)", desc->name ? desc->name : "unnamed", setting->data.configs.group_or_pin); break; case PIN_MAP_TYPE_CONFIGS_GROUP: seq_printf(s, "group %s (%d)", pctlops->get_group_name(pctldev, setting->data.configs.group_or_pin), setting->data.configs.group_or_pin); break; default: break; } /* * FIXME: We should really get the pin controler to dump the config * values, so they can be decoded to something meaningful. */ for (i = 0; i < setting->data.configs.num_configs; i++) { seq_printf(s, " "); if (confops && confops->pin_config_config_dbg_show) confops->pin_config_config_dbg_show(pctldev, s, setting->data.configs.configs[i]); else seq_printf(s, "%08lx", setting->data.configs.configs[i]); } seq_printf(s, "\n"); }
static const char *pin_free(struct pinctrl_dev *pctldev, int pin, struct pinctrl_gpio_range *gpio_range) { const struct pinmux_ops *ops = pctldev->desc->pmxops; struct pin_desc *desc; const char *owner; desc = pin_desc_get(pctldev, pin); if (desc == NULL) { dev_err(pctldev->dev, "pin is not registered so it cannot be freed\n"); return NULL; } if (!gpio_range) { if (WARN_ON(!desc->mux_usecount)) return NULL; desc->mux_usecount--; if (desc->mux_usecount) return NULL; } if (gpio_range && ops->gpio_disable_free) ops->gpio_disable_free(pctldev, gpio_range, pin); else if (ops->free) ops->free(pctldev, pin); if (gpio_range) { owner = desc->gpio_owner; desc->gpio_owner = NULL; } else { owner = desc->mux_owner; desc->mux_owner = NULL; desc->mux_setting = NULL; } module_put(pctldev->owner); return owner; }
void pinmux_disable_setting(struct pinctrl_setting const *setting) { struct pinctrl_dev *pctldev = setting->pctldev; const struct pinctrl_ops *pctlops = pctldev->desc->pctlops; const struct pinmux_ops *ops = pctldev->desc->pmxops; int ret; const unsigned *pins; unsigned num_pins; int i; struct pin_desc *desc; ret = pctlops->get_group_pins(pctldev, setting->data.mux.group, &pins, &num_pins); if (ret) { dev_warn(pctldev->dev, "could not get pins for group selector %d\n", setting->data.mux.group); num_pins = 0; } for (i = 0; i < num_pins; i++) { desc = pin_desc_get(pctldev, pins[i]); if (desc == NULL) { dev_warn(pctldev->dev, "could not get pin desc for pin %d\n", pins[i]); continue; } desc->mux_setting = NULL; } for (i = 0; i < num_pins; i++) pin_free(pctldev, pins[i], NULL); if (ops->disable) ops->disable(pctldev, setting->data.mux.func, setting->data.mux.group); }
void pinmux_disable_setting(struct pinctrl_setting const *setting) { struct pinctrl_dev *pctldev = setting->pctldev; const struct pinctrl_ops *pctlops = pctldev->desc->pctlops; const struct pinmux_ops *ops = pctldev->desc->pmxops; int ret; const unsigned *pins; unsigned num_pins; int i; struct pin_desc *desc; ret = pctlops->get_group_pins(pctldev, setting->data.mux.group, &pins, &num_pins); if (ret) { /* errors only affect debug data, so just warn */ dev_warn(pctldev->dev, "could not get pins for group selector %d\n", setting->data.mux.group); num_pins = 0; } /* Flag the descs that no setting is active */ for (i = 0; i < num_pins; i++) { desc = pin_desc_get(pctldev, pins[i]); if (desc == NULL) { dev_warn(pctldev->dev, "could not get pin desc for pin %d\n", pins[i]); continue; } desc->mux_setting = NULL; } /* And release the pins */ for (i = 0; i < num_pins; i++) pin_free(pctldev, pins[i], NULL); if (ops->disable) ops->disable(pctldev, setting->data.mux.func, setting->data.mux.group); }
static int hi6402_get_function(struct pinctrl_dev *pctldev, unsigned pin, const struct hi6402_pinctrl_function **func) { struct hi6402_pinctrl_device *pindev = pinctrl_dev_get_drvdata(pctldev); struct pin_desc *pdesc = pin_desc_get(pctldev, pin); const struct pinctrl_setting_mux *setting; unsigned fselector; /* If pin is not described in DTS & enabled, mux_setting is NULL. */ setting = pdesc->mux_setting; if (!setting) { dev_err(pindev->dev, "PIN-%d does not be registered\n", pin); return -ENOTSUPP; } fselector = setting->func; *func = &pindev->pmx_functions[fselector]; if (!(*func)) { dev_err(pindev->dev, "%s could not find function%i\n", __func__, fselector); return -ENOTSUPP; } return 0; }
int pinmux_enable_setting(struct pinctrl_setting const *setting) { struct pinctrl_dev *pctldev = setting->pctldev; const struct pinctrl_ops *pctlops = pctldev->desc->pctlops; const struct pinmux_ops *ops = pctldev->desc->pmxops; int ret; const unsigned *pins; unsigned num_pins; int i; struct pin_desc *desc; ret = pctlops->get_group_pins(pctldev, setting->data.mux.group, &pins, &num_pins); if (ret) { dev_warn(pctldev->dev, "could not get pins for group selector %d\n", setting->data.mux.group); num_pins = 0; } for (i = 0; i < num_pins; i++) { ret = pin_request(pctldev, pins[i], setting->dev_name, NULL); if (ret) { dev_err(pctldev->dev, "could not request pin %d on device %s\n", pins[i], pinctrl_dev_get_name(pctldev)); goto err_pin_request; } } for (i = 0; i < num_pins; i++) { desc = pin_desc_get(pctldev, pins[i]); if (desc == NULL) { dev_warn(pctldev->dev, "could not get pin desc for pin %d\n", pins[i]); continue; } desc->mux_setting = &(setting->data.mux); } ret = ops->enable(pctldev, setting->data.mux.func, setting->data.mux.group); if (ret) goto err_enable; return 0; err_enable: for (i = 0; i < num_pins; i++) { desc = pin_desc_get(pctldev, pins[i]); if (desc) desc->mux_setting = NULL; } err_pin_request: while (--i >= 0) pin_free(pctldev, pins[i], NULL); return ret; }
/** * pin_request() - request a single pin to be muxed in, typically for GPIO * @pin: the pin number in the global pin space * @owner: a representation of the owner of this pin; typically the device * name that controls its mux function, or the requested GPIO name * @gpio_range: the range matching the GPIO pin if this is a request for a * single GPIO pin */ static int pin_request(struct pinctrl_dev *pctldev, int pin, const char *owner, struct pinctrl_gpio_range *gpio_range) { struct pin_desc *desc; const struct pinmux_ops *ops = pctldev->desc->pmxops; int status = -EINVAL; desc = pin_desc_get(pctldev, pin); if (desc == NULL) { dev_err(pctldev->dev, "pin %d is not registered so it cannot be requested\n", pin); goto out; } dev_dbg(pctldev->dev, "request pin %d (%s) for %s\n", pin, desc->name, owner); if (gpio_range) { /* There's no need to support multiple GPIO requests */ if (desc->gpio_owner) { dev_err(pctldev->dev, "pin %s already requested by %s; cannot claim for %s\n", desc->name, desc->gpio_owner, owner); goto out; } desc->gpio_owner = owner; } else { if (desc->mux_usecount && strcmp(desc->mux_owner, owner)) { dev_err(pctldev->dev, "pin %s already requested by %s; cannot claim for %s\n", desc->name, desc->mux_owner, owner); goto out; } desc->mux_usecount++; if (desc->mux_usecount > 1) return 0; desc->mux_owner = owner; } /* Let each pin increase references to this module */ if (!try_module_get(pctldev->owner)) { dev_err(pctldev->dev, "could not increase module refcount for pin %d\n", pin); status = -EINVAL; goto out_free_pin; } /* * If there is no kind of request function for the pin we just assume * we got it by default and proceed. */ if (gpio_range && ops->gpio_request_enable) /* This requests and enables a single GPIO pin */ status = ops->gpio_request_enable(pctldev, gpio_range, pin); else if (ops->request) status = ops->request(pctldev, pin); else status = 0; if (status) { dev_err(pctldev->dev, "request() failed for pin %d\n", pin); module_put(pctldev->owner); } out_free_pin: if (status) { if (gpio_range) { desc->gpio_owner = NULL; } else { desc->mux_usecount--; if (!desc->mux_usecount) desc->mux_owner = NULL; } } out: if (status) dev_err(pctldev->dev, "pin-%d (%s) status %d\n", pin, owner, status); return status; }
int pinmux_enable_setting(struct pinctrl_setting const *setting) { struct pinctrl_dev *pctldev = setting->pctldev; const struct pinctrl_ops *pctlops = pctldev->desc->pctlops; const struct pinmux_ops *ops = pctldev->desc->pmxops; int ret; const unsigned *pins; unsigned num_pins; int i; struct pin_desc *desc; ret = pctlops->get_group_pins(pctldev, setting->data.mux.group, &pins, &num_pins); if (ret) { /* errors only affect debug data, so just warn */ dev_warn(pctldev->dev, "could not get pins for group selector %d\n", setting->data.mux.group); num_pins = 0; } /* Try to allocate all pins in this group, one by one */ for (i = 0; i < num_pins; i++) { ret = pin_request(pctldev, pins[i], setting->dev_name, NULL); if (ret) { dev_err(pctldev->dev, "could not request pin %d on device %s\n", pins[i], pinctrl_dev_get_name(pctldev)); goto err_pin_request; } } /* Now that we have acquired the pins, encode the mux setting */ for (i = 0; i < num_pins; i++) { desc = pin_desc_get(pctldev, pins[i]); if (desc == NULL) { dev_warn(pctldev->dev, "could not get pin desc for pin %d\n", pins[i]); continue; } desc->mux_setting = &(setting->data.mux); } ret = ops->enable(pctldev, setting->data.mux.func, setting->data.mux.group); if (ret) goto err_enable; return 0; err_enable: for (i = 0; i < num_pins; i++) { desc = pin_desc_get(pctldev, pins[i]); if (desc) desc->mux_setting = NULL; } err_pin_request: /* On error release all taken pins */ while (--i >= 0) pin_free(pctldev, pins[i], NULL); return ret; }
static int pin_request(struct pinctrl_dev *pctldev, int pin, const char *owner, struct pinctrl_gpio_range *gpio_range) { struct pin_desc *desc; const struct pinmux_ops *ops = pctldev->desc->pmxops; int status = -EINVAL; desc = pin_desc_get(pctldev, pin); if (desc == NULL) { dev_err(pctldev->dev, "pin %d is not registered so it cannot be requested\n", pin); goto out; } dev_dbg(pctldev->dev, "request pin %d (%s) for %s\n", pin, desc->name, owner); if (gpio_range) { if (desc->gpio_owner) { dev_err(pctldev->dev, "pin %s already requested by %s; cannot claim for %s\n", desc->name, desc->gpio_owner, owner); goto out; } desc->gpio_owner = owner; } else { if (desc->mux_usecount && strcmp(desc->mux_owner, owner)) { dev_err(pctldev->dev, "pin %s already requested by %s; cannot claim for %s\n", desc->name, desc->mux_owner, owner); goto out; } desc->mux_usecount++; if (desc->mux_usecount > 1) return 0; desc->mux_owner = owner; } if (!try_module_get(pctldev->owner)) { dev_err(pctldev->dev, "could not increase module refcount for pin %d\n", pin); status = -EINVAL; goto out_free_pin; } if (gpio_range && ops->gpio_request_enable) status = ops->gpio_request_enable(pctldev, gpio_range, pin); else if (ops->request) status = ops->request(pctldev, pin); else status = 0; if (status) { dev_err(pctldev->dev, "request() failed for pin %d\n", pin); module_put(pctldev->owner); } out_free_pin: if (status) { if (gpio_range) { desc->gpio_owner = NULL; } else { desc->mux_usecount--; if (!desc->mux_usecount) desc->mux_owner = NULL; } } out: if (status) dev_err(pctldev->dev, "pin-%d (%s) status %d\n", pin, owner, status); return status; }