1 /* SPDX-License-Identifier: GPL-2.0-only */ 2 /* 3 * Interface the pinmux subsystem 4 * 5 * Copyright (C) 2011 ST-Ericsson SA 6 * Written on behalf of Linaro for ST-Ericsson 7 * Based on bits of regulator core, gpio core and clk core 8 * 9 * Author: Linus Walleij <linus.walleij@linaro.org> 10 */ 11 #ifndef __LINUX_PINCTRL_PINMUX_H 12 #define __LINUX_PINCTRL_PINMUX_H 13 14 #include <linux/types.h> 15 16 struct pinctrl_dev; 17 struct pinctrl_gpio_range; 18 19 /** 20 * struct pinmux_ops - pinmux operations, to be implemented by pin controller 21 * drivers that support pinmuxing 22 * @request: called by the core to see if a certain pin can be made 23 * available for muxing. This is called by the core to acquire the pins 24 * before selecting any actual mux setting across a function. The driver 25 * is allowed to answer "no" by returning a negative error code 26 * @free: the reverse function of the request() callback, frees a pin after 27 * being requested 28 * @get_functions_count: returns number of selectable named functions available 29 * in this pinmux driver 30 * @get_function_name: return the function name of the muxing selector, 31 * called by the core to figure out which mux setting it shall map a 32 * certain device to 33 * @get_function_groups: return an array of groups names (in turn 34 * referencing pins) connected to a certain function selector. The group 35 * name can be used with the generic @pinctrl_ops to retrieve the 36 * actual pins affected. The applicable groups will be returned in 37 * @groups and the number of groups in @num_groups 38 * @set_mux: enable a certain muxing function with a certain pin group. The 39 * driver does not need to figure out whether enabling this function 40 * conflicts some other use of the pins in that group, such collisions 41 * are handled by the pinmux subsystem. The @func_selector selects a 42 * certain function whereas @group_selector selects a certain set of pins 43 * to be used. On simple controllers the latter argument may be ignored 44 * @gpio_request_enable: requests and enables GPIO on a certain pin. 45 * Implement this only if you can mux every pin individually as GPIO. The 46 * affected GPIO range is passed along with an offset(pin number) into that 47 * specific GPIO range - function selectors and pin groups are orthogonal 48 * to this, the core will however make sure the pins do not collide. 49 * @gpio_disable_free: free up GPIO muxing on a certain pin, the reverse of 50 * @gpio_request_enable 51 * @gpio_set_direction: Since controllers may need different configurations 52 * depending on whether the GPIO is configured as input or output, 53 * a direction selector function may be implemented as a backing 54 * to the GPIO controllers that need pin muxing. 55 * @strict: do not allow simultaneous use of the same pin for GPIO and another 56 * function. Check both gpio_owner and mux_owner strictly before approving 57 * the pin request. 58 */ 59 struct pinmux_ops { 60 int (*request) (struct pinctrl_dev *pctldev, unsigned int offset); 61 int (*free) (struct pinctrl_dev *pctldev, unsigned int offset); 62 int (*get_functions_count) (struct pinctrl_dev *pctldev); 63 const char *(*get_function_name) (struct pinctrl_dev *pctldev, 64 unsigned int selector); 65 int (*get_function_groups) (struct pinctrl_dev *pctldev, 66 unsigned int selector, 67 const char * const **groups, 68 unsigned int *num_groups); 69 int (*set_mux) (struct pinctrl_dev *pctldev, unsigned int func_selector, 70 unsigned int group_selector); 71 int (*gpio_request_enable) (struct pinctrl_dev *pctldev, 72 struct pinctrl_gpio_range *range, 73 unsigned int offset); 74 void (*gpio_disable_free) (struct pinctrl_dev *pctldev, 75 struct pinctrl_gpio_range *range, 76 unsigned int offset); 77 int (*gpio_set_direction) (struct pinctrl_dev *pctldev, 78 struct pinctrl_gpio_range *range, 79 unsigned int offset, 80 bool input); 81 bool strict; 82 }; 83 84 #endif /* __LINUX_PINCTRL_PINMUX_H */ 85