Lines Matching +full:pin +full:- +full:node
1 // SPDX-License-Identifier: GPL-2.0-only
3 * Core driver for the pin control subsystem
5 * Copyright (C) 2011-2012 ST-Ericsson SA
6 * Written on behalf of Linaro for ST-Ericsson
51 /* Global list of pin control devices (struct pinctrl_dev) */
54 /* List of pin controller handles (struct pinctrl) */
62 * pinctrl_provide_dummies() - indicate if pinctrl provides dummy state support
78 return pctldev->desc->name; in pinctrl_dev_get_name()
84 return dev_name(pctldev->dev); in pinctrl_dev_get_devname()
90 return pctldev->driver_data; in pinctrl_dev_get_drvdata()
95 * get_pinctrl_dev_from_devname() - look up pin controller device
98 * Looks up a pin control device matching a certain device name or pure device
110 list_for_each_entry(pctldev, &pinctrldev_list, node) { in get_pinctrl_dev_from_devname()
111 if (!strcmp(dev_name(pctldev->dev), devname)) { in get_pinctrl_dev_from_devname()
129 list_for_each_entry(pctldev, &pinctrldev_list, node) in get_pinctrl_dev_from_of_node()
130 if (device_match_of_node(pctldev->dev, np)) { in get_pinctrl_dev_from_of_node()
141 * pin_get_from_name() - look up a pin number from a name
142 * @pctldev: the pin control device to lookup the pin on
143 * @name: the name of the pin to look up
147 unsigned int i, pin; in pin_get_from_name() local
149 /* The pin number can be retrived from the pin controller descriptor */ in pin_get_from_name()
150 for (i = 0; i < pctldev->desc->npins; i++) { in pin_get_from_name()
153 pin = pctldev->desc->pins[i].number; in pin_get_from_name()
154 desc = pin_desc_get(pctldev, pin); in pin_get_from_name()
155 /* Pin space may be sparse */ in pin_get_from_name()
156 if (desc && !strcmp(name, desc->name)) in pin_get_from_name()
157 return pin; in pin_get_from_name()
160 return -EINVAL; in pin_get_from_name()
164 * pin_get_name() - look up a pin name from a pin id
165 * @pctldev: the pin control device to lookup the pin on
166 * @pin: pin number/id to look up
168 const char *pin_get_name(struct pinctrl_dev *pctldev, const unsigned int pin) in pin_get_name() argument
172 desc = pin_desc_get(pctldev, pin); in pin_get_name()
174 dev_err(pctldev->dev, "failed to get pin(%d) name\n", in pin_get_name()
175 pin); in pin_get_name()
179 return desc->name; in pin_get_name()
183 /* Deletes a range of pin descriptors */
193 pindesc = radix_tree_lookup(&pctldev->pin_desc_tree, in pinctrl_free_pindescs()
196 radix_tree_delete(&pctldev->pin_desc_tree, in pinctrl_free_pindescs()
198 if (pindesc->dynamic_name) in pinctrl_free_pindescs()
199 kfree(pindesc->name); in pinctrl_free_pindescs()
206 const struct pinctrl_pin_desc *pin) in pinctrl_register_one_pin() argument
211 pindesc = pin_desc_get(pctldev, pin->number); in pinctrl_register_one_pin()
213 dev_err(pctldev->dev, "pin %d already registered\n", in pinctrl_register_one_pin()
214 pin->number); in pinctrl_register_one_pin()
215 return -EINVAL; in pinctrl_register_one_pin()
220 return -ENOMEM; in pinctrl_register_one_pin()
223 pindesc->pctldev = pctldev; in pinctrl_register_one_pin()
225 mutex_init(&pindesc->mux_lock); in pinctrl_register_one_pin()
228 /* Copy basic pin info */ in pinctrl_register_one_pin()
229 if (pin->name) { in pinctrl_register_one_pin()
230 pindesc->name = pin->name; in pinctrl_register_one_pin()
232 pindesc->name = kasprintf(GFP_KERNEL, "PIN%u", pin->number); in pinctrl_register_one_pin()
233 if (!pindesc->name) { in pinctrl_register_one_pin()
234 error = -ENOMEM; in pinctrl_register_one_pin()
237 pindesc->dynamic_name = true; in pinctrl_register_one_pin()
240 pindesc->drv_data = pin->drv_data; in pinctrl_register_one_pin()
242 error = radix_tree_insert(&pctldev->pin_desc_tree, pin->number, pindesc); in pinctrl_register_one_pin()
246 pr_debug("registered pin %d (%s) on %s\n", in pinctrl_register_one_pin()
247 pin->number, pindesc->name, pctldev->desc->name); in pinctrl_register_one_pin()
272 * gpio_to_pin() - GPIO range GPIO number to pin number translation
277 * Finds the pin number for a given GPIO using the specified GPIO range
279 * and pin list based GPIO ranges is managed correctly by this function.
288 unsigned int pin = gc->base + offset - range->base; in gpio_to_pin() local
289 if (range->pins) in gpio_to_pin()
290 return range->pins[pin]; in gpio_to_pin()
292 return range->pin_base + pin; in gpio_to_pin()
296 * pinctrl_match_gpio_range() - check if a certain GPIO pin is in range
297 * @pctldev: pin controller device to check
301 * Tries to match a GPIO pin number to the ranges handled by a certain pin
310 mutex_lock(&pctldev->mutex); in pinctrl_match_gpio_range()
312 list_for_each_entry(range, &pctldev->gpio_ranges, node) { in pinctrl_match_gpio_range()
314 if ((gc->base + offset) >= range->base && in pinctrl_match_gpio_range()
315 (gc->base + offset) < range->base + range->npins) { in pinctrl_match_gpio_range()
316 mutex_unlock(&pctldev->mutex); in pinctrl_match_gpio_range()
320 mutex_unlock(&pctldev->mutex); in pinctrl_match_gpio_range()
325 * pinctrl_ready_for_gpio_range() - check if other GPIO pins of
333 * of the same GPIO chip don't have back-end pinctrl interface.
335 * certain GPIO pin doesn't have back-end pinctrl device. If the return value
347 /* Loop over the pin controllers */ in pinctrl_ready_for_gpio_range()
348 list_for_each_entry(pctldev, &pinctrldev_list, node) { in pinctrl_ready_for_gpio_range()
350 mutex_lock(&pctldev->mutex); in pinctrl_ready_for_gpio_range()
351 list_for_each_entry(range, &pctldev->gpio_ranges, node) { in pinctrl_ready_for_gpio_range()
353 if (range->base + range->npins - 1 < gc->base || in pinctrl_ready_for_gpio_range()
354 range->base > gc->base + gc->ngpio - 1) in pinctrl_ready_for_gpio_range()
356 mutex_unlock(&pctldev->mutex); in pinctrl_ready_for_gpio_range()
360 mutex_unlock(&pctldev->mutex); in pinctrl_ready_for_gpio_range()
376 * pinctrl_get_device_gpio_range() - find device for GPIO range
379 * @outdev: the pin control device if found
382 * Find the pin controller handling a certain GPIO pin from the pinspace of
384 * -EPROBE_DEFER if the GPIO range could not be found in any device since it
396 /* Loop over the pin controllers */ in pinctrl_get_device_gpio_range()
397 list_for_each_entry(pctldev, &pinctrldev_list, node) { in pinctrl_get_device_gpio_range()
411 return -EPROBE_DEFER; in pinctrl_get_device_gpio_range()
415 * pinctrl_add_gpio_range() - register a GPIO range for a controller
416 * @pctldev: pin controller device to add the range to
423 * This adds a range of GPIOs to be handled by a certain pin controller. Call
424 * this to register handled ranges after registering your pin controller.
429 mutex_lock(&pctldev->mutex); in pinctrl_add_gpio_range()
430 list_add_tail(&range->node, &pctldev->gpio_ranges); in pinctrl_add_gpio_range()
431 mutex_unlock(&pctldev->mutex); in pinctrl_add_gpio_range()
459 return ERR_PTR(-EPROBE_DEFER); in pinctrl_find_and_add_gpio_range()
470 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops; in pinctrl_get_group_pins()
473 if (!pctlops->get_group_pins) in pinctrl_get_group_pins()
474 return -EINVAL; in pinctrl_get_group_pins()
480 return pctlops->get_group_pins(pctldev, gs, pins, num_pins); in pinctrl_get_group_pins()
486 unsigned int pin) in pinctrl_find_gpio_range_from_pin_nolock() argument
491 list_for_each_entry(range, &pctldev->gpio_ranges, node) { in pinctrl_find_gpio_range_from_pin_nolock()
493 if (range->pins) { in pinctrl_find_gpio_range_from_pin_nolock()
495 for (a = 0; a < range->npins; a++) { in pinctrl_find_gpio_range_from_pin_nolock()
496 if (range->pins[a] == pin) in pinctrl_find_gpio_range_from_pin_nolock()
499 } else if (pin >= range->pin_base && in pinctrl_find_gpio_range_from_pin_nolock()
500 pin < range->pin_base + range->npins) in pinctrl_find_gpio_range_from_pin_nolock()
509 * pinctrl_find_gpio_range_from_pin() - locate the GPIO range for a pin
510 * @pctldev: the pin controller device to look in
511 * @pin: a controller-local number to find the range for
515 unsigned int pin) in pinctrl_find_gpio_range_from_pin() argument
519 mutex_lock(&pctldev->mutex); in pinctrl_find_gpio_range_from_pin()
520 range = pinctrl_find_gpio_range_from_pin_nolock(pctldev, pin); in pinctrl_find_gpio_range_from_pin()
521 mutex_unlock(&pctldev->mutex); in pinctrl_find_gpio_range_from_pin()
528 * pinctrl_remove_gpio_range() - remove a range of GPIOs from a pin controller
529 * @pctldev: pin controller device to remove the range from
535 mutex_lock(&pctldev->mutex); in pinctrl_remove_gpio_range()
536 list_del(&range->node); in pinctrl_remove_gpio_range()
537 mutex_unlock(&pctldev->mutex); in pinctrl_remove_gpio_range()
544 * pinctrl_generic_get_group_count() - returns the number of pin groups
545 * @pctldev: pin controller device
549 return pctldev->num_groups; in pinctrl_generic_get_group_count()
554 * pinctrl_generic_get_group_name() - returns the name of a pin group
555 * @pctldev: pin controller device
563 group = radix_tree_lookup(&pctldev->pin_group_tree, in pinctrl_generic_get_group_name()
568 return group->grp.name; in pinctrl_generic_get_group_name()
573 * pinctrl_generic_get_group_pins() - gets the pin group pins
574 * @pctldev: pin controller device
586 group = radix_tree_lookup(&pctldev->pin_group_tree, in pinctrl_generic_get_group_pins()
589 dev_err(pctldev->dev, "%s could not find pingroup%i\n", in pinctrl_generic_get_group_pins()
591 return -EINVAL; in pinctrl_generic_get_group_pins()
594 *pins = group->grp.pins; in pinctrl_generic_get_group_pins()
595 *num_pins = group->grp.npins; in pinctrl_generic_get_group_pins()
602 * pinctrl_generic_get_group() - returns a pin group based on the number
603 * @pctldev: pin controller device
611 group = radix_tree_lookup(&pctldev->pin_group_tree, in pinctrl_generic_get_group()
623 const struct pinctrl_ops *ops = pctldev->desc->pctlops; in pinctrl_generic_group_name_to_selector()
624 int ngroups = ops->get_groups_count(pctldev); in pinctrl_generic_group_name_to_selector()
629 const char *gname = ops->get_group_name(pctldev, selector); in pinctrl_generic_group_name_to_selector()
637 return -EINVAL; in pinctrl_generic_group_name_to_selector()
641 * pinctrl_generic_add_group() - adds a new pin group
642 * @pctldev: pin controller device
643 * @name: name of the pin group
644 * @pins: pins in the pin group
645 * @num_pins: number of pins in the pin group
646 * @data: pin controller driver specific data
657 return -EINVAL; in pinctrl_generic_add_group()
663 selector = pctldev->num_groups; in pinctrl_generic_add_group()
665 group = devm_kzalloc(pctldev->dev, sizeof(*group), GFP_KERNEL); in pinctrl_generic_add_group()
667 return -ENOMEM; in pinctrl_generic_add_group()
671 error = radix_tree_insert(&pctldev->pin_group_tree, selector, group); in pinctrl_generic_add_group()
675 pctldev->num_groups++; in pinctrl_generic_add_group()
682 * pinctrl_generic_remove_group() - removes a numbered pin group
683 * @pctldev: pin controller device
693 group = radix_tree_lookup(&pctldev->pin_group_tree, in pinctrl_generic_remove_group()
696 return -ENOENT; in pinctrl_generic_remove_group()
698 radix_tree_delete(&pctldev->pin_group_tree, selector); in pinctrl_generic_remove_group()
699 devm_kfree(pctldev->dev, group); in pinctrl_generic_remove_group()
701 pctldev->num_groups--; in pinctrl_generic_remove_group()
708 * pinctrl_generic_free_groups() - removes all pin groups
709 * @pctldev: pin controller device
719 radix_tree_for_each_slot(slot, &pctldev->pin_group_tree, &iter, 0) in pinctrl_generic_free_groups()
720 radix_tree_delete(&pctldev->pin_group_tree, iter.index); in pinctrl_generic_free_groups()
722 pctldev->num_groups = 0; in pinctrl_generic_free_groups()
732 * pinctrl_get_group_selector() - returns the group selector for a group
733 * @pctldev: the pin controller handling the group
734 * @pin_group: the pin group to look up
739 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops; in pinctrl_get_group_selector()
740 unsigned int ngroups = pctlops->get_groups_count(pctldev); in pinctrl_get_group_selector()
744 const char *gname = pctlops->get_group_name(pctldev, in pinctrl_get_group_selector()
747 dev_dbg(pctldev->dev, in pinctrl_get_group_selector()
757 dev_err(pctldev->dev, "does not have pin group %s\n", in pinctrl_get_group_selector()
760 return -EINVAL; in pinctrl_get_group_selector()
768 int pin; in pinctrl_gpio_can_use_line() local
773 * without a backing pin controller - bail out. in pinctrl_gpio_can_use_line()
778 mutex_lock(&pctldev->mutex); in pinctrl_gpio_can_use_line()
780 /* Convert to the pin controllers number space */ in pinctrl_gpio_can_use_line()
781 pin = gpio_to_pin(range, gc, offset); in pinctrl_gpio_can_use_line()
783 result = pinmux_can_be_used_for_gpio(pctldev, pin); in pinctrl_gpio_can_use_line()
785 mutex_unlock(&pctldev->mutex); in pinctrl_gpio_can_use_line()
792 * pinctrl_gpio_request() - request a single pin to be used as GPIO
796 * This function should *ONLY* be used from gpiolib-based GPIO drivers,
804 int ret, pin; in pinctrl_gpio_request() local
813 mutex_lock(&pctldev->mutex); in pinctrl_gpio_request()
815 /* Convert to the pin controllers number space */ in pinctrl_gpio_request()
816 pin = gpio_to_pin(range, gc, offset); in pinctrl_gpio_request()
818 ret = pinmux_request_gpio(pctldev, range, pin, gc->base + offset); in pinctrl_gpio_request()
820 mutex_unlock(&pctldev->mutex); in pinctrl_gpio_request()
827 * pinctrl_gpio_free() - free control on a single pin, currently used as GPIO
831 * This function should *ONLY* be used from gpiolib-based GPIO drivers,
839 int ret, pin; in pinctrl_gpio_free() local
845 mutex_lock(&pctldev->mutex); in pinctrl_gpio_free()
847 /* Convert to the pin controllers number space */ in pinctrl_gpio_free()
848 pin = gpio_to_pin(range, gc, offset); in pinctrl_gpio_free()
850 pinmux_free_gpio(pctldev, pin, range); in pinctrl_gpio_free()
852 mutex_unlock(&pctldev->mutex); in pinctrl_gpio_free()
862 int pin; in pinctrl_gpio_direction() local
869 mutex_lock(&pctldev->mutex); in pinctrl_gpio_direction()
871 /* Convert to the pin controllers number space */ in pinctrl_gpio_direction()
872 pin = gpio_to_pin(range, gc, offset); in pinctrl_gpio_direction()
873 ret = pinmux_gpio_direction(pctldev, range, pin, input); in pinctrl_gpio_direction()
875 mutex_unlock(&pctldev->mutex); in pinctrl_gpio_direction()
881 * pinctrl_gpio_direction_input() - request a GPIO pin to go into input mode
885 * This function should *ONLY* be used from gpiolib-based GPIO drivers,
887 * drivers shall *NOT* touch pin control GPIO calls.
896 * pinctrl_gpio_direction_output() - request a GPIO pin to go into output mode
900 * This function should *ONLY* be used from gpiolib-based GPIO drivers,
902 * drivers shall *NOT* touch pin control GPIO calls.
911 * pinctrl_gpio_set_config() - Apply config to given GPIO pin
916 * This function should *ONLY* be used from gpiolib-based GPIO drivers, if
917 * they need to call the underlying pin controller to change GPIO config
926 int ret, pin; in pinctrl_gpio_set_config() local
932 mutex_lock(&pctldev->mutex); in pinctrl_gpio_set_config()
933 pin = gpio_to_pin(range, gc, offset); in pinctrl_gpio_set_config()
934 ret = pinconf_set_config(pctldev, pin, configs, ARRAY_SIZE(configs)); in pinctrl_gpio_set_config()
935 mutex_unlock(&pctldev->mutex); in pinctrl_gpio_set_config()
946 list_for_each_entry(state, &p->states, node) in find_state()
947 if (!strcmp(state->name, name)) in find_state()
960 return ERR_PTR(-ENOMEM); in create_state()
962 state->name = name; in create_state()
963 INIT_LIST_HEAD(&state->settings); in create_state()
965 list_add_tail(&state->node, &p->states); in create_state()
977 state = find_state(p, map->name); in add_setting()
979 state = create_state(p, map->name); in add_setting()
983 if (map->type == PIN_MAP_TYPE_DUMMY_STATE) in add_setting()
988 return -ENOMEM; in add_setting()
990 setting->type = map->type; in add_setting()
993 setting->pctldev = pctldev; in add_setting()
995 setting->pctldev = in add_setting()
996 get_pinctrl_dev_from_devname(map->ctrl_dev_name); in add_setting()
997 if (!setting->pctldev) { in add_setting()
1000 if (!strcmp(map->ctrl_dev_name, map->dev_name)) in add_setting()
1001 return -ENODEV; in add_setting()
1006 dev_info(p->dev, "unknown pinctrl device %s in map entry, deferring probe", in add_setting()
1007 map->ctrl_dev_name); in add_setting()
1008 return -EPROBE_DEFER; in add_setting()
1011 setting->dev_name = map->dev_name; in add_setting()
1013 switch (map->type) { in add_setting()
1022 ret = -EINVAL; in add_setting()
1030 list_add_tail(&setting->node, &state->settings); in add_setting()
1040 list_for_each_entry(p, &pinctrl_list, node) in find_pinctrl()
1041 if (p->dev == dev) { in find_pinctrl()
1064 * a pin control handle with pinctrl_get() in create_pinctrl()
1068 return ERR_PTR(-ENOMEM); in create_pinctrl()
1069 p->dev = dev; in create_pinctrl()
1070 INIT_LIST_HEAD(&p->states); in create_pinctrl()
1071 INIT_LIST_HEAD(&p->dt_maps); in create_pinctrl()
1082 /* Iterate over the pin control maps to locate the right ones */ in create_pinctrl()
1085 if (strcmp(map->dev_name, devname)) in create_pinctrl()
1095 strcmp(dev_name(pctldev->dev), map->ctrl_dev_name)) in create_pinctrl()
1102 * - Defer, if the pinctrl device is not yet available in create_pinctrl()
1103 * - Fail, if the pinctrl device is not yet available, in create_pinctrl()
1108 * If the error returned was not -EPROBE_DEFER then we in create_pinctrl()
1110 * an -EPROBE_DEFER later, as that is the worst case. in create_pinctrl()
1112 if (ret == -EPROBE_DEFER) { in create_pinctrl()
1126 kref_init(&p->users); in create_pinctrl()
1130 list_add_tail(&p->node, &pinctrl_list); in create_pinctrl()
1137 * pinctrl_get() - retrieves the pinctrl handle for a device
1145 return ERR_PTR(-EINVAL); in pinctrl_get()
1155 kref_get(&p->users); in pinctrl_get()
1166 switch (setting->type) { in pinctrl_free_setting()
1187 list_for_each_entry_safe(state, n1, &p->states, node) { in pinctrl_free()
1188 list_for_each_entry_safe(setting, n2, &state->settings, node) { in pinctrl_free()
1189 pinctrl_free_setting(state == p->state, setting); in pinctrl_free()
1190 list_del(&setting->node); in pinctrl_free()
1193 list_del(&state->node); in pinctrl_free()
1200 list_del(&p->node); in pinctrl_free()
1206 * pinctrl_release() - release the pinctrl handle
1217 * pinctrl_put() - decrease use count on a previously claimed pinctrl handle
1222 kref_put(&p->users, pinctrl_release); in pinctrl_put()
1227 * pinctrl_lookup_state() - retrieves a state handle from a pinctrl handle
1240 dev_dbg(p->dev, "using pinctrl dummy state (%s)\n", in pinctrl_lookup_state()
1244 state = ERR_PTR(-ENODEV); in pinctrl_lookup_state()
1254 if (pctldev->desc->link_consumers) in pinctrl_link_add()
1255 device_link_add(consumer, pctldev->dev, in pinctrl_link_add()
1265 list_for_each_entry(setting, &state->settings, node) { in pinctrl_cond_disable_mux_setting()
1266 if (target_setting && (&setting->node == &target_setting->node)) in pinctrl_cond_disable_mux_setting()
1269 if (setting->type == PIN_MAP_TYPE_MUX_GROUP) in pinctrl_cond_disable_mux_setting()
1275 * pinctrl_commit_state() - select/activate/program a pinctrl state to HW
1282 struct pinctrl_state *old_state = READ_ONCE(p->state); in pinctrl_commit_state()
1289 * still owned by the new state will be re-acquired by the call in pinctrl_commit_state()
1295 p->state = NULL; in pinctrl_commit_state()
1297 /* Apply all the settings for the new state - pinmux first */ in pinctrl_commit_state()
1298 list_for_each_entry(setting, &state->settings, node) { in pinctrl_commit_state()
1299 switch (setting->type) { in pinctrl_commit_state()
1308 ret = -EINVAL; in pinctrl_commit_state()
1316 if (p != setting->pctldev->p) in pinctrl_commit_state()
1317 pinctrl_link_add(setting->pctldev, p->dev); in pinctrl_commit_state()
1320 /* Apply all the settings for the new state - pinconf after */ in pinctrl_commit_state()
1321 list_for_each_entry(setting, &state->settings, node) { in pinctrl_commit_state()
1322 switch (setting->type) { in pinctrl_commit_state()
1331 ret = -EINVAL; in pinctrl_commit_state()
1340 if (p != setting->pctldev->p) in pinctrl_commit_state()
1341 pinctrl_link_add(setting->pctldev, p->dev); in pinctrl_commit_state()
1344 p->state = state; in pinctrl_commit_state()
1353 dev_err(p->dev, "Error applying setting, reverse things back\n"); in pinctrl_commit_state()
1359 * "unmux a pin"!), but it's not a big deal since the pins in pinctrl_commit_state()
1365 /* There's no infinite recursive loop here because p->state is NULL */ in pinctrl_commit_state()
1373 * pinctrl_select_state() - select/activate/program a pinctrl state to HW
1379 if (p->state == state) in pinctrl_select_state()
1392 * devm_pinctrl_get() - Resource managed pinctrl_get()
1404 return ERR_PTR(-ENOMEM); in devm_pinctrl_get()
1426 * devm_pinctrl_put() - Resource managed pinctrl_put()
1435 WARN_ON(devres_release(p->dev, devm_pinctrl_release, in devm_pinctrl_put()
1441 * pinctrl_register_mappings() - register a set of pin controller mappings
1442 * @maps: the pincontrol mappings table to register. Note the pinctrl-core
1460 return -EINVAL; in pinctrl_register_mappings()
1466 return -EINVAL; in pinctrl_register_mappings()
1471 pr_err("failed to register map %s (%d): no pin control device given\n", in pinctrl_register_mappings()
1473 return -EINVAL; in pinctrl_register_mappings()
1493 return -EINVAL; in pinctrl_register_mappings()
1499 return -ENOMEM; in pinctrl_register_mappings()
1501 maps_node->maps = maps; in pinctrl_register_mappings()
1502 maps_node->num_maps = num_maps; in pinctrl_register_mappings()
1505 list_add_tail(&maps_node->node, &pinctrl_maps); in pinctrl_register_mappings()
1513 * pinctrl_unregister_mappings() - unregister a set of pin controller mappings
1522 list_for_each_entry(maps_node, &pinctrl_maps, node) { in pinctrl_unregister_mappings()
1523 if (maps_node->maps == map) { in pinctrl_unregister_mappings()
1524 list_del(&maps_node->node); in pinctrl_unregister_mappings()
1540 * devm_pinctrl_register_mappings() - Resource managed pinctrl_register_mappings()
1542 * @maps: the pincontrol mappings table to register. Note the pinctrl-core
1564 * pinctrl_force_sleep() - turn a given controller device into sleep state
1565 * @pctldev: pin controller device
1569 if (!IS_ERR(pctldev->p) && !IS_ERR(pctldev->hog_sleep)) in pinctrl_force_sleep()
1570 return pinctrl_commit_state(pctldev->p, pctldev->hog_sleep); in pinctrl_force_sleep()
1576 * pinctrl_force_default() - turn a given controller device into default state
1577 * @pctldev: pin controller device
1581 if (!IS_ERR(pctldev->p) && !IS_ERR(pctldev->hog_default)) in pinctrl_force_default()
1582 return pinctrl_commit_state(pctldev->p, pctldev->hog_default); in pinctrl_force_default()
1588 * pinctrl_init_done() - tell pinctrl probe is done
1597 struct dev_pin_info *pins = dev->pins; in pinctrl_init_done()
1603 if (IS_ERR(pins->init_state)) in pinctrl_init_done()
1606 if (pins->p->state != pins->init_state) in pinctrl_init_done()
1609 if (IS_ERR(pins->default_state)) in pinctrl_init_done()
1612 ret = pinctrl_select_state(pins->p, pins->default_state); in pinctrl_init_done()
1622 struct dev_pin_info *pins = dev->pins; in pinctrl_select_bound_state()
1627 ret = pinctrl_select_state(pins->p, state); in pinctrl_select_bound_state()
1630 state->name); in pinctrl_select_bound_state()
1635 * pinctrl_select_default_state() - select default pinctrl state
1640 if (!dev->pins) in pinctrl_select_default_state()
1643 return pinctrl_select_bound_state(dev, dev->pins->default_state); in pinctrl_select_default_state()
1650 * pinctrl_pm_select_default_state() - select default pinctrl state for PM
1660 * pinctrl_pm_select_init_state() - select init pinctrl state for PM
1665 if (!dev->pins) in pinctrl_pm_select_init_state()
1668 return pinctrl_select_bound_state(dev, dev->pins->init_state); in pinctrl_pm_select_init_state()
1673 * pinctrl_pm_select_sleep_state() - select sleep pinctrl state for PM
1678 if (!dev->pins) in pinctrl_pm_select_sleep_state()
1681 return pinctrl_select_bound_state(dev, dev->pins->sleep_state); in pinctrl_pm_select_sleep_state()
1686 * pinctrl_pm_select_idle_state() - select idle pinctrl state for PM
1691 if (!dev->pins) in pinctrl_pm_select_idle_state()
1694 return pinctrl_select_bound_state(dev, dev->pins->idle_state); in pinctrl_pm_select_idle_state()
1703 struct pinctrl_dev *pctldev = s->private; in pinctrl_pins_show()
1704 const struct pinctrl_ops *ops = pctldev->desc->pctlops; in pinctrl_pins_show()
1705 unsigned int i, pin; in pinctrl_pins_show() local
1712 seq_printf(s, "registered pins: %d\n", pctldev->desc->npins); in pinctrl_pins_show()
1714 mutex_lock(&pctldev->mutex); in pinctrl_pins_show()
1716 /* The pin number can be retrived from the pin controller descriptor */ in pinctrl_pins_show()
1717 for (i = 0; i < pctldev->desc->npins; i++) { in pinctrl_pins_show()
1720 pin = pctldev->desc->pins[i].number; in pinctrl_pins_show()
1721 desc = pin_desc_get(pctldev, pin); in pinctrl_pins_show()
1722 /* Pin space may be sparse */ in pinctrl_pins_show()
1726 seq_printf(s, "pin %d (%s) ", pin, desc->name); in pinctrl_pins_show()
1730 gpio_num = -1; in pinctrl_pins_show()
1731 list_for_each_entry(range, &pctldev->gpio_ranges, node) { in pinctrl_pins_show()
1732 if (range->pins != NULL) { in pinctrl_pins_show()
1733 for (int i = 0; i < range->npins; ++i) { in pinctrl_pins_show()
1734 if (range->pins[i] == pin) { in pinctrl_pins_show()
1735 gpio_num = range->base + i; in pinctrl_pins_show()
1739 } else if ((pin >= range->pin_base) && in pinctrl_pins_show()
1740 (pin < (range->pin_base + range->npins))) { in pinctrl_pins_show()
1742 range->base + (pin - range->pin_base); in pinctrl_pins_show()
1744 if (gpio_num != -1) in pinctrl_pins_show()
1750 * we need to get rid of the range->base eventually and in pinctrl_pins_show()
1756 gpio_num - gpio_device_get_base(gdev), in pinctrl_pins_show()
1762 /* Driver-specific info per pin */ in pinctrl_pins_show()
1763 if (ops->pin_dbg_show) in pinctrl_pins_show()
1764 ops->pin_dbg_show(pctldev, s, pin); in pinctrl_pins_show()
1769 mutex_unlock(&pctldev->mutex); in pinctrl_pins_show()
1777 struct pinctrl_dev *pctldev = s->private; in pinctrl_groups_show()
1778 const struct pinctrl_ops *ops = pctldev->desc->pctlops; in pinctrl_groups_show()
1781 mutex_lock(&pctldev->mutex); in pinctrl_groups_show()
1783 ngroups = ops->get_groups_count(pctldev); in pinctrl_groups_show()
1785 seq_puts(s, "registered pin groups:\n"); in pinctrl_groups_show()
1789 const char *gname = ops->get_group_name(pctldev, selector); in pinctrl_groups_show()
1794 if (ops->get_group_pins) in pinctrl_groups_show()
1795 ret = ops->get_group_pins(pctldev, selector, in pinctrl_groups_show()
1805 mutex_unlock(&pctldev->mutex); in pinctrl_groups_show()
1806 return -EINVAL; in pinctrl_groups_show()
1808 seq_printf(s, "pin %d (%s)\n", pins[i], pname); in pinctrl_groups_show()
1815 mutex_unlock(&pctldev->mutex); in pinctrl_groups_show()
1823 struct pinctrl_dev *pctldev = s->private; in pinctrl_gpioranges_show()
1828 mutex_lock(&pctldev->mutex); in pinctrl_gpioranges_show()
1831 list_for_each_entry(range, &pctldev->gpio_ranges, node) { in pinctrl_gpioranges_show()
1832 if (range->pins) { in pinctrl_gpioranges_show()
1834 seq_printf(s, "%u: %s GPIOS [%u - %u] PINS {", in pinctrl_gpioranges_show()
1835 range->id, range->name, in pinctrl_gpioranges_show()
1836 range->base, (range->base + range->npins - 1)); in pinctrl_gpioranges_show()
1837 for (a = 0; a < range->npins - 1; a++) in pinctrl_gpioranges_show()
1838 seq_printf(s, "%u, ", range->pins[a]); in pinctrl_gpioranges_show()
1839 seq_printf(s, "%u}\n", range->pins[a]); in pinctrl_gpioranges_show()
1842 seq_printf(s, "%u: %s GPIOS [%u - %u] PINS [%u - %u]\n", in pinctrl_gpioranges_show()
1843 range->id, range->name, in pinctrl_gpioranges_show()
1844 range->base, (range->base + range->npins - 1), in pinctrl_gpioranges_show()
1845 range->pin_base, in pinctrl_gpioranges_show()
1846 (range->pin_base + range->npins - 1)); in pinctrl_gpioranges_show()
1849 mutex_unlock(&pctldev->mutex); in pinctrl_gpioranges_show()
1863 list_for_each_entry(pctldev, &pinctrldev_list, node) { in pinctrl_devices_show()
1864 seq_printf(s, "%s ", pctldev->desc->name); in pinctrl_devices_show()
1865 if (pctldev->desc->pmxops) in pinctrl_devices_show()
1869 if (pctldev->desc->confops) in pinctrl_devices_show()
1908 map->dev_name, map->name, map_type(map->type), in pinctrl_maps_show()
1909 map->type); in pinctrl_maps_show()
1911 if (map->type != PIN_MAP_TYPE_DUMMY_STATE) in pinctrl_maps_show()
1913 map->ctrl_dev_name); in pinctrl_maps_show()
1915 switch (map->type) { in pinctrl_maps_show()
1941 seq_puts(s, "Requested pin control handlers their pinmux maps:\n"); in pinctrl_show()
1945 list_for_each_entry(p, &pinctrl_list, node) { in pinctrl_show()
1947 dev_name(p->dev), in pinctrl_show()
1948 p->state ? p->state->name : "none"); in pinctrl_show()
1950 list_for_each_entry(state, &p->states, node) { in pinctrl_show()
1951 seq_printf(s, " state: %s\n", state->name); in pinctrl_show()
1953 list_for_each_entry(setting, &state->settings, node) { in pinctrl_show()
1954 struct pinctrl_dev *pctldev = setting->pctldev; in pinctrl_show()
1957 map_type(setting->type), in pinctrl_show()
1960 switch (setting->type) { in pinctrl_show()
1988 if (pctldev->desc->name && in pinctrl_init_device_debugfs()
1989 strcmp(dev_name(pctldev->dev), pctldev->desc->name)) { in pinctrl_init_device_debugfs()
1990 debugfs_name = devm_kasprintf(pctldev->dev, GFP_KERNEL, in pinctrl_init_device_debugfs()
1991 "%s-%s", dev_name(pctldev->dev), in pinctrl_init_device_debugfs()
1992 pctldev->desc->name); in pinctrl_init_device_debugfs()
1995 dev_name(pctldev->dev)); in pinctrl_init_device_debugfs()
1999 debugfs_name = dev_name(pctldev->dev); in pinctrl_init_device_debugfs()
2003 pctldev->device_root = device_root; in pinctrl_init_device_debugfs()
2007 dev_name(pctldev->dev)); in pinctrl_init_device_debugfs()
2014 debugfs_create_file("gpio-ranges", 0444, in pinctrl_init_device_debugfs()
2016 if (pctldev->desc->pmxops) in pinctrl_init_device_debugfs()
2018 if (pctldev->desc->confops) in pinctrl_init_device_debugfs()
2024 debugfs_remove_recursive(pctldev->device_root); in pinctrl_remove_device_debugfs()
2036 debugfs_create_file("pinctrl-devices", 0444, in pinctrl_init_debugfs()
2038 debugfs_create_file("pinctrl-maps", 0444, in pinctrl_init_debugfs()
2040 debugfs_create_file("pinctrl-handles", 0444, in pinctrl_init_debugfs()
2062 const struct pinctrl_ops *ops = pctldev->desc->pctlops; in pinctrl_check_ops()
2065 !ops->get_groups_count || in pinctrl_check_ops()
2066 !ops->get_group_name) in pinctrl_check_ops()
2067 return -EINVAL; in pinctrl_check_ops()
2073 * pinctrl_init_controller() - init a pin controller device
2074 * @pctldesc: descriptor for this pin controller
2075 * @dev: parent device for this pin controller
2076 * @driver_data: private pin controller data for this pin controller
2086 return ERR_PTR(-EINVAL); in pinctrl_init_controller()
2087 if (!pctldesc->name) in pinctrl_init_controller()
2088 return ERR_PTR(-EINVAL); in pinctrl_init_controller()
2092 return ERR_PTR(-ENOMEM); in pinctrl_init_controller()
2094 /* Initialize pin control device struct */ in pinctrl_init_controller()
2095 pctldev->owner = pctldesc->owner; in pinctrl_init_controller()
2096 pctldev->desc = pctldesc; in pinctrl_init_controller()
2097 pctldev->driver_data = driver_data; in pinctrl_init_controller()
2098 INIT_RADIX_TREE(&pctldev->pin_desc_tree, GFP_KERNEL); in pinctrl_init_controller()
2100 INIT_RADIX_TREE(&pctldev->pin_group_tree, GFP_KERNEL); in pinctrl_init_controller()
2103 INIT_RADIX_TREE(&pctldev->pin_function_tree, GFP_KERNEL); in pinctrl_init_controller()
2105 INIT_LIST_HEAD(&pctldev->gpio_ranges); in pinctrl_init_controller()
2106 INIT_LIST_HEAD(&pctldev->node); in pinctrl_init_controller()
2107 pctldev->dev = dev; in pinctrl_init_controller()
2108 mutex_init(&pctldev->mutex); in pinctrl_init_controller()
2118 if (pctldesc->pmxops) { in pinctrl_init_controller()
2125 if (pctldesc->confops) { in pinctrl_init_controller()
2132 dev_dbg(dev, "try to register %d pins ...\n", pctldesc->npins); in pinctrl_init_controller()
2133 ret = pinctrl_register_pins(pctldev, pctldesc->pins, pctldesc->npins); in pinctrl_init_controller()
2135 dev_err(dev, "error during pin registration\n"); in pinctrl_init_controller()
2136 pinctrl_free_pindescs(pctldev, pctldesc->pins, in pinctrl_init_controller()
2137 pctldesc->npins); in pinctrl_init_controller()
2144 mutex_destroy(&pctldev->mutex); in pinctrl_init_controller()
2152 pinctrl_free_pindescs(pctldev, pctldesc->pins, in pinctrl_uninit_controller()
2153 pctldesc->npins); in pinctrl_uninit_controller()
2154 mutex_destroy(&pctldev->mutex); in pinctrl_uninit_controller()
2160 pctldev->p = create_pinctrl(pctldev->dev, pctldev); in pinctrl_claim_hogs()
2161 if (PTR_ERR(pctldev->p) == -ENODEV) { in pinctrl_claim_hogs()
2162 dev_dbg(pctldev->dev, "no hogs found\n"); in pinctrl_claim_hogs()
2167 if (IS_ERR(pctldev->p)) { in pinctrl_claim_hogs()
2168 dev_err(pctldev->dev, "error claiming hogs: %li\n", in pinctrl_claim_hogs()
2169 PTR_ERR(pctldev->p)); in pinctrl_claim_hogs()
2171 return PTR_ERR(pctldev->p); in pinctrl_claim_hogs()
2174 pctldev->hog_default = in pinctrl_claim_hogs()
2175 pinctrl_lookup_state(pctldev->p, PINCTRL_STATE_DEFAULT); in pinctrl_claim_hogs()
2176 if (IS_ERR(pctldev->hog_default)) { in pinctrl_claim_hogs()
2177 dev_dbg(pctldev->dev, in pinctrl_claim_hogs()
2180 if (pinctrl_select_state(pctldev->p, in pinctrl_claim_hogs()
2181 pctldev->hog_default)) in pinctrl_claim_hogs()
2182 dev_err(pctldev->dev, in pinctrl_claim_hogs()
2186 pctldev->hog_sleep = in pinctrl_claim_hogs()
2187 pinctrl_lookup_state(pctldev->p, in pinctrl_claim_hogs()
2189 if (IS_ERR(pctldev->hog_sleep)) in pinctrl_claim_hogs()
2190 dev_dbg(pctldev->dev, in pinctrl_claim_hogs()
2202 dev_err(pctldev->dev, "could not claim hogs: %i\n", error); in pinctrl_enable()
2207 list_add_tail(&pctldev->node, &pinctrldev_list); in pinctrl_enable()
2217 * pinctrl_register() - register a pin controller device
2218 * @pctldesc: descriptor for this pin controller
2219 * @dev: parent device for this pin controller
2220 * @driver_data: private pin controller data for this pin controller
2222 * Note that pinctrl_register() is known to have problems as the pin
2248 * pinctrl_register_and_init() - register and init pin controller device
2249 * @pctldesc: descriptor for this pin controller
2250 * @dev: parent device for this pin controller
2251 * @driver_data: private pin controller data for this pin controller
2252 * @pctldev: pin controller device
2268 * We have pinctrl_start() call functions in the pin controller in pinctrl_register_and_init()
2271 * pin controller driver before we do anything. in pinctrl_register_and_init()
2280 * pinctrl_unregister() - unregister pinmux
2281 * @pctldev: pin controller to unregister
2292 mutex_lock(&pctldev->mutex); in pinctrl_unregister()
2294 mutex_unlock(&pctldev->mutex); in pinctrl_unregister()
2296 if (!IS_ERR_OR_NULL(pctldev->p)) in pinctrl_unregister()
2297 pinctrl_put(pctldev->p); in pinctrl_unregister()
2300 mutex_lock(&pctldev->mutex); in pinctrl_unregister()
2302 list_del(&pctldev->node); in pinctrl_unregister()
2306 pinctrl_free_pindescs(pctldev, pctldev->desc->pins, in pinctrl_unregister()
2307 pctldev->desc->npins); in pinctrl_unregister()
2309 list_for_each_entry_safe(range, n, &pctldev->gpio_ranges, node) in pinctrl_unregister()
2310 list_del(&range->node); in pinctrl_unregister()
2312 mutex_unlock(&pctldev->mutex); in pinctrl_unregister()
2313 mutex_destroy(&pctldev->mutex); in pinctrl_unregister()
2337 * devm_pinctrl_register() - Resource managed version of pinctrl_register().
2338 * @dev: parent device for this pin controller
2339 * @pctldesc: descriptor for this pin controller
2340 * @driver_data: private pin controller data for this pin controller
2355 return ERR_PTR(-ENOMEM); in devm_pinctrl_register()
2371 * devm_pinctrl_register_and_init() - Resource managed pinctrl register and init
2372 * @dev: parent device for this pin controller
2373 * @pctldesc: descriptor for this pin controller
2374 * @driver_data: private pin controller data for this pin controller
2375 * @pctldev: pin controller device
2391 return -ENOMEM; in devm_pinctrl_register_and_init()
2407 * devm_pinctrl_unregister() - Resource managed version of pinctrl_unregister().