tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

pinctrl: Convert unsigned to unsigned int

Simple type conversion with no functional change implied.
While at it, adjust indentation where it makes sense.

Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
Link: https://lore.kernel.org/r/20231129161459.1002323-24-andriy.shevchenko@linux.intel.com
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>

authored by

Andy Shevchenko and committed by
Linus Walleij 7cc4e6b0 26ea8229

+134 -134
+14 -14
drivers/pinctrl/core.c
··· 143 143 */ 144 144 int pin_get_from_name(struct pinctrl_dev *pctldev, const char *name) 145 145 { 146 - unsigned i, pin; 146 + unsigned int i, pin; 147 147 148 148 /* The pin number can be retrived from the pin controller descriptor */ 149 149 for (i = 0; i < pctldev->desc->npins; i++) { ··· 164 164 * @pctldev: the pin control device to lookup the pin on 165 165 * @pin: pin number/id to look up 166 166 */ 167 - const char *pin_get_name(struct pinctrl_dev *pctldev, const unsigned pin) 167 + const char *pin_get_name(struct pinctrl_dev *pctldev, const unsigned int pin) 168 168 { 169 169 const struct pin_desc *desc; 170 170 ··· 182 182 /* Deletes a range of pin descriptors */ 183 183 static void pinctrl_free_pindescs(struct pinctrl_dev *pctldev, 184 184 const struct pinctrl_pin_desc *pins, 185 - unsigned num_pins) 185 + unsigned int num_pins) 186 186 { 187 187 int i; 188 188 ··· 250 250 251 251 static int pinctrl_register_pins(struct pinctrl_dev *pctldev, 252 252 const struct pinctrl_pin_desc *pins, 253 - unsigned num_descs) 253 + unsigned int num_descs) 254 254 { 255 - unsigned i; 255 + unsigned int i; 256 256 int ret = 0; 257 257 258 258 for (i = 0; i < num_descs; i++) { ··· 426 426 427 427 void pinctrl_add_gpio_ranges(struct pinctrl_dev *pctldev, 428 428 struct pinctrl_gpio_range *ranges, 429 - unsigned nranges) 429 + unsigned int nranges) 430 430 { 431 431 int i; 432 432 ··· 457 457 EXPORT_SYMBOL_GPL(pinctrl_find_and_add_gpio_range); 458 458 459 459 int pinctrl_get_group_pins(struct pinctrl_dev *pctldev, const char *pin_group, 460 - const unsigned **pins, unsigned *num_pins) 460 + const unsigned int **pins, unsigned int *num_pins) 461 461 { 462 462 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops; 463 463 int gs; ··· 732 732 const char *pin_group) 733 733 { 734 734 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops; 735 - unsigned ngroups = pctlops->get_groups_count(pctldev); 736 - unsigned group_selector = 0; 735 + unsigned int ngroups = pctlops->get_groups_count(pctldev); 736 + unsigned int group_selector = 0; 737 737 738 738 while (group_selector < ngroups) { 739 739 const char *gname = pctlops->get_group_name(pctldev, ··· 1430 1430 * @num_maps: the number of maps in the mapping table 1431 1431 */ 1432 1432 int pinctrl_register_mappings(const struct pinctrl_map *maps, 1433 - unsigned num_maps) 1433 + unsigned int num_maps) 1434 1434 { 1435 1435 int i, ret; 1436 1436 struct pinctrl_maps *maps_node; ··· 1645 1645 { 1646 1646 struct pinctrl_dev *pctldev = s->private; 1647 1647 const struct pinctrl_ops *ops = pctldev->desc->pctlops; 1648 - unsigned i, pin; 1648 + unsigned int i, pin; 1649 1649 #ifdef CONFIG_GPIOLIB 1650 1650 struct gpio_device *gdev __free(gpio_device_put) = NULL; 1651 1651 struct pinctrl_gpio_range *range; ··· 1709 1709 { 1710 1710 struct pinctrl_dev *pctldev = s->private; 1711 1711 const struct pinctrl_ops *ops = pctldev->desc->pctlops; 1712 - unsigned ngroups, selector = 0; 1712 + unsigned int ngroups, selector = 0; 1713 1713 1714 1714 mutex_lock(&pctldev->mutex); 1715 1715 ··· 1717 1717 1718 1718 seq_puts(s, "registered pin groups:\n"); 1719 1719 while (selector < ngroups) { 1720 - const unsigned *pins = NULL; 1721 - unsigned num_pins = 0; 1720 + const unsigned int *pins = NULL; 1721 + unsigned int num_pins = 0; 1722 1722 const char *gname = ops->get_group_name(pctldev, selector); 1723 1723 const char *pname; 1724 1724 int ret = 0;
+7 -7
drivers/pinctrl/core.h
··· 111 111 * @func: the function selector to program 112 112 */ 113 113 struct pinctrl_setting_mux { 114 - unsigned group; 115 - unsigned func; 114 + unsigned int group; 115 + unsigned int func; 116 116 }; 117 117 118 118 /** ··· 124 124 * @num_configs: the number of entries in array @configs 125 125 */ 126 126 struct pinctrl_setting_configs { 127 - unsigned group_or_pin; 127 + unsigned int group_or_pin; 128 128 unsigned long *configs; 129 - unsigned num_configs; 129 + unsigned int num_configs; 130 130 }; 131 131 132 132 /** ··· 173 173 void *drv_data; 174 174 /* These fields only added when supporting pinmux drivers */ 175 175 #ifdef CONFIG_PINMUX 176 - unsigned mux_usecount; 176 + unsigned int mux_usecount; 177 177 const char *mux_owner; 178 178 const struct pinctrl_setting_mux *mux_setting; 179 179 const char *gpio_owner; ··· 189 189 struct pinctrl_maps { 190 190 struct list_head node; 191 191 const struct pinctrl_map *maps; 192 - unsigned num_maps; 192 + unsigned int num_maps; 193 193 }; 194 194 195 195 #ifdef CONFIG_GENERIC_PINCTRL_GROUPS ··· 232 232 struct pinctrl_dev *get_pinctrl_dev_from_devname(const char *dev_name); 233 233 struct pinctrl_dev *get_pinctrl_dev_from_of_node(struct device_node *np); 234 234 int pin_get_from_name(struct pinctrl_dev *pctldev, const char *name); 235 - const char *pin_get_name(struct pinctrl_dev *pctldev, const unsigned pin); 235 + const char *pin_get_name(struct pinctrl_dev *pctldev, const unsigned int pin); 236 236 int pinctrl_get_group_selector(struct pinctrl_dev *pctldev, 237 237 const char *pin_group); 238 238
+4 -4
drivers/pinctrl/devicetree.c
··· 24 24 struct list_head node; 25 25 struct pinctrl_dev *pctldev; 26 26 struct pinctrl_map *map; 27 - unsigned num_maps; 27 + unsigned int num_maps; 28 28 }; 29 29 30 30 static void dt_free_map(struct pinctrl_dev *pctldev, 31 - struct pinctrl_map *map, unsigned num_maps) 31 + struct pinctrl_map *map, unsigned int num_maps) 32 32 { 33 33 int i; 34 34 ··· 64 64 65 65 static int dt_remember_or_free_map(struct pinctrl *p, const char *statename, 66 66 struct pinctrl_dev *pctldev, 67 - struct pinctrl_map *map, unsigned num_maps) 67 + struct pinctrl_map *map, unsigned int num_maps) 68 68 { 69 69 int i; 70 70 struct pinctrl_dt_map *dt_map; ··· 116 116 const struct pinctrl_ops *ops; 117 117 int ret; 118 118 struct pinctrl_map *map; 119 - unsigned num_maps; 119 + unsigned int num_maps; 120 120 bool allow_default = false; 121 121 122 122 /* Find the pin controller containing np_config */
+8 -8
drivers/pinctrl/pinconf-generic.c
··· 57 57 58 58 static void pinconf_generic_dump_one(struct pinctrl_dev *pctldev, 59 59 struct seq_file *s, const char *gname, 60 - unsigned pin, 60 + unsigned int pin, 61 61 const struct pin_config_item *items, 62 62 int nitems, int *print_sep) 63 63 { ··· 110 110 * to be specified the other can be NULL/0. 111 111 */ 112 112 void pinconf_generic_dump_pins(struct pinctrl_dev *pctldev, struct seq_file *s, 113 - const char *gname, unsigned pin) 113 + const char *gname, unsigned int pin) 114 114 { 115 115 const struct pinconf_ops *ops = pctldev->desc->confops; 116 116 int print_sep = 0; ··· 295 295 296 296 int pinconf_generic_dt_subnode_to_map(struct pinctrl_dev *pctldev, 297 297 struct device_node *np, struct pinctrl_map **map, 298 - unsigned *reserved_maps, unsigned *num_maps, 298 + unsigned int *reserved_maps, unsigned int *num_maps, 299 299 enum pinctrl_map_type type) 300 300 { 301 301 int ret; 302 302 const char *function; 303 303 struct device *dev = pctldev->dev; 304 304 unsigned long *configs = NULL; 305 - unsigned num_configs = 0; 306 - unsigned reserve, strings_count; 305 + unsigned int num_configs = 0; 306 + unsigned int reserve, strings_count; 307 307 struct property *prop; 308 308 const char *group; 309 309 const char *subnode_target_type = "pins"; ··· 379 379 380 380 int pinconf_generic_dt_node_to_map(struct pinctrl_dev *pctldev, 381 381 struct device_node *np_config, struct pinctrl_map **map, 382 - unsigned *num_maps, enum pinctrl_map_type type) 382 + unsigned int *num_maps, enum pinctrl_map_type type) 383 383 { 384 - unsigned reserved_maps; 384 + unsigned int reserved_maps; 385 385 struct device_node *np; 386 386 int ret; 387 387 ··· 412 412 413 413 void pinconf_generic_dt_free_map(struct pinctrl_dev *pctldev, 414 414 struct pinctrl_map *map, 415 - unsigned num_maps) 415 + unsigned int num_maps) 416 416 { 417 417 pinctrl_utils_free_map(pctldev, map, num_maps); 418 418 }
+7 -7
drivers/pinctrl/pinconf.c
··· 55 55 return 0; 56 56 } 57 57 58 - int pin_config_get_for_pin(struct pinctrl_dev *pctldev, unsigned pin, 58 + int pin_config_get_for_pin(struct pinctrl_dev *pctldev, unsigned int pin, 59 59 unsigned long *config) 60 60 { 61 61 const struct pinconf_ops *ops = pctldev->desc->confops; ··· 199 199 return 0; 200 200 } 201 201 202 - int pinconf_set_config(struct pinctrl_dev *pctldev, unsigned pin, 202 + int pinconf_set_config(struct pinctrl_dev *pctldev, unsigned int pin, 203 203 unsigned long *configs, size_t nconfigs) 204 204 { 205 205 const struct pinconf_ops *ops; ··· 214 214 #ifdef CONFIG_DEBUG_FS 215 215 216 216 static void pinconf_show_config(struct seq_file *s, struct pinctrl_dev *pctldev, 217 - unsigned long *configs, unsigned num_configs) 217 + unsigned long *configs, unsigned int num_configs) 218 218 { 219 219 const struct pinconf_ops *confops; 220 220 int i; ··· 304 304 static int pinconf_pins_show(struct seq_file *s, void *what) 305 305 { 306 306 struct pinctrl_dev *pctldev = s->private; 307 - unsigned i, pin; 307 + unsigned int i, pin; 308 308 309 309 seq_puts(s, "Pin config settings per pin\n"); 310 310 seq_puts(s, "Format: pin (name): configs\n"); ··· 333 333 } 334 334 335 335 static void pinconf_dump_group(struct pinctrl_dev *pctldev, 336 - struct seq_file *s, unsigned selector, 336 + struct seq_file *s, unsigned int selector, 337 337 const char *gname) 338 338 { 339 339 const struct pinconf_ops *ops = pctldev->desc->confops; ··· 348 348 { 349 349 struct pinctrl_dev *pctldev = s->private; 350 350 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops; 351 - unsigned ngroups = pctlops->get_groups_count(pctldev); 352 - unsigned selector = 0; 351 + unsigned int ngroups = pctlops->get_groups_count(pctldev); 352 + unsigned int selector = 0; 353 353 354 354 seq_puts(s, "Pin config settings per pin group\n"); 355 355 seq_puts(s, "Format: group (name): configs\n");
+5 -5
drivers/pinctrl/pinconf.h
··· 29 29 void pinconf_free_setting(const struct pinctrl_setting *setting); 30 30 int pinconf_apply_setting(const struct pinctrl_setting *setting); 31 31 32 - int pinconf_set_config(struct pinctrl_dev *pctldev, unsigned pin, 32 + int pinconf_set_config(struct pinctrl_dev *pctldev, unsigned int pin, 33 33 unsigned long *configs, size_t nconfigs); 34 34 35 35 /* 36 36 * You will only be interested in these if you're using PINCONF 37 37 * so don't supply any stubs for these. 38 38 */ 39 - int pin_config_get_for_pin(struct pinctrl_dev *pctldev, unsigned pin, 39 + int pin_config_get_for_pin(struct pinctrl_dev *pctldev, unsigned int pin, 40 40 unsigned long *config); 41 41 int pin_config_group_get(const char *dev_name, const char *pin_group, 42 42 unsigned long *config); ··· 68 68 return 0; 69 69 } 70 70 71 - static inline int pinconf_set_config(struct pinctrl_dev *pctldev, unsigned pin, 71 + static inline int pinconf_set_config(struct pinctrl_dev *pctldev, unsigned int pin, 72 72 unsigned long *configs, size_t nconfigs) 73 73 { 74 74 return -ENOTSUPP; ··· 112 112 113 113 void pinconf_generic_dump_pins(struct pinctrl_dev *pctldev, 114 114 struct seq_file *s, const char *gname, 115 - unsigned pin); 115 + unsigned int pin); 116 116 117 117 void pinconf_generic_dump_config(struct pinctrl_dev *pctldev, 118 118 struct seq_file *s, unsigned long config); ··· 120 120 121 121 static inline void pinconf_generic_dump_pins(struct pinctrl_dev *pctldev, 122 122 struct seq_file *s, 123 - const char *gname, unsigned pin) 123 + const char *gname, unsigned int pin) 124 124 { 125 125 return; 126 126 }
+13 -13
drivers/pinctrl/pinctrl-utils.c
··· 18 18 #include "pinctrl-utils.h" 19 19 20 20 int pinctrl_utils_reserve_map(struct pinctrl_dev *pctldev, 21 - struct pinctrl_map **map, unsigned *reserved_maps, 22 - unsigned *num_maps, unsigned reserve) 21 + struct pinctrl_map **map, unsigned int *reserved_maps, 22 + unsigned int *num_maps, unsigned int reserve) 23 23 { 24 - unsigned old_num = *reserved_maps; 25 - unsigned new_num = *num_maps + reserve; 24 + unsigned int old_num = *reserved_maps; 25 + unsigned int new_num = *num_maps + reserve; 26 26 struct pinctrl_map *new_map; 27 27 28 28 if (old_num >= new_num) ··· 43 43 EXPORT_SYMBOL_GPL(pinctrl_utils_reserve_map); 44 44 45 45 int pinctrl_utils_add_map_mux(struct pinctrl_dev *pctldev, 46 - struct pinctrl_map **map, unsigned *reserved_maps, 47 - unsigned *num_maps, const char *group, 46 + struct pinctrl_map **map, unsigned int *reserved_maps, 47 + unsigned int *num_maps, const char *group, 48 48 const char *function) 49 49 { 50 50 if (WARN_ON(*num_maps == *reserved_maps)) ··· 60 60 EXPORT_SYMBOL_GPL(pinctrl_utils_add_map_mux); 61 61 62 62 int pinctrl_utils_add_map_configs(struct pinctrl_dev *pctldev, 63 - struct pinctrl_map **map, unsigned *reserved_maps, 64 - unsigned *num_maps, const char *group, 65 - unsigned long *configs, unsigned num_configs, 63 + struct pinctrl_map **map, unsigned int *reserved_maps, 64 + unsigned int *num_maps, const char *group, 65 + unsigned long *configs, unsigned int num_configs, 66 66 enum pinctrl_map_type type) 67 67 { 68 68 unsigned long *dup_configs; ··· 86 86 EXPORT_SYMBOL_GPL(pinctrl_utils_add_map_configs); 87 87 88 88 int pinctrl_utils_add_config(struct pinctrl_dev *pctldev, 89 - unsigned long **configs, unsigned *num_configs, 89 + unsigned long **configs, unsigned int *num_configs, 90 90 unsigned long config) 91 91 { 92 - unsigned old_num = *num_configs; 93 - unsigned new_num = old_num + 1; 92 + unsigned int old_num = *num_configs; 93 + unsigned int new_num = old_num + 1; 94 94 unsigned long *new_configs; 95 95 96 96 new_configs = krealloc(*configs, sizeof(*new_configs) * new_num, ··· 110 110 EXPORT_SYMBOL_GPL(pinctrl_utils_add_config); 111 111 112 112 void pinctrl_utils_free_map(struct pinctrl_dev *pctldev, 113 - struct pinctrl_map *map, unsigned num_maps) 113 + struct pinctrl_map *map, unsigned int num_maps) 114 114 { 115 115 int i; 116 116
+9 -9
drivers/pinctrl/pinctrl-utils.h
··· 15 15 struct pinctrl_map; 16 16 17 17 int pinctrl_utils_reserve_map(struct pinctrl_dev *pctldev, 18 - struct pinctrl_map **map, unsigned *reserved_maps, 19 - unsigned *num_maps, unsigned reserve); 18 + struct pinctrl_map **map, unsigned int *reserved_maps, 19 + unsigned int *num_maps, unsigned int reserve); 20 20 int pinctrl_utils_add_map_mux(struct pinctrl_dev *pctldev, 21 - struct pinctrl_map **map, unsigned *reserved_maps, 22 - unsigned *num_maps, const char *group, 21 + struct pinctrl_map **map, unsigned int *reserved_maps, 22 + unsigned int *num_maps, const char *group, 23 23 const char *function); 24 24 int pinctrl_utils_add_map_configs(struct pinctrl_dev *pctldev, 25 - struct pinctrl_map **map, unsigned *reserved_maps, 26 - unsigned *num_maps, const char *group, 27 - unsigned long *configs, unsigned num_configs, 25 + struct pinctrl_map **map, unsigned int *reserved_maps, 26 + unsigned int *num_maps, const char *group, 27 + unsigned long *configs, unsigned int num_configs, 28 28 enum pinctrl_map_type type); 29 29 int pinctrl_utils_add_config(struct pinctrl_dev *pctldev, 30 - unsigned long **configs, unsigned *num_configs, 30 + unsigned long **configs, unsigned int *num_configs, 31 31 unsigned long config); 32 32 void pinctrl_utils_free_map(struct pinctrl_dev *pctldev, 33 - struct pinctrl_map *map, unsigned num_maps); 33 + struct pinctrl_map *map, unsigned int num_maps); 34 34 35 35 #endif /* __PINCTRL_UTILS_H__ */
+18 -18
drivers/pinctrl/pinmux.c
··· 35 35 int pinmux_check_ops(struct pinctrl_dev *pctldev) 36 36 { 37 37 const struct pinmux_ops *ops = pctldev->desc->pmxops; 38 - unsigned nfuncs; 39 - unsigned selector = 0; 38 + unsigned int nfuncs; 39 + unsigned int selector = 0; 40 40 41 41 /* Check that we implement required operations */ 42 42 if (!ops || ··· 84 84 * Controllers not defined as strict will always return true, 85 85 * menaning that the gpio can be used. 86 86 */ 87 - bool pinmux_can_be_used_for_gpio(struct pinctrl_dev *pctldev, unsigned pin) 87 + bool pinmux_can_be_used_for_gpio(struct pinctrl_dev *pctldev, unsigned int pin) 88 88 { 89 89 struct pin_desc *desc = pin_desc_get(pctldev, pin); 90 90 const struct pinmux_ops *ops = pctldev->desc->pmxops; ··· 262 262 */ 263 263 int pinmux_request_gpio(struct pinctrl_dev *pctldev, 264 264 struct pinctrl_gpio_range *range, 265 - unsigned pin, unsigned gpio) 265 + unsigned int pin, unsigned int gpio) 266 266 { 267 267 const char *owner; 268 268 int ret; ··· 285 285 * @pin: the affected currently GPIO-muxed in pin 286 286 * @range: applicable GPIO range 287 287 */ 288 - void pinmux_free_gpio(struct pinctrl_dev *pctldev, unsigned pin, 288 + void pinmux_free_gpio(struct pinctrl_dev *pctldev, unsigned int pin, 289 289 struct pinctrl_gpio_range *range) 290 290 { 291 291 const char *owner; ··· 303 303 */ 304 304 int pinmux_gpio_direction(struct pinctrl_dev *pctldev, 305 305 struct pinctrl_gpio_range *range, 306 - unsigned pin, bool input) 306 + unsigned int pin, bool input) 307 307 { 308 308 const struct pinmux_ops *ops; 309 309 int ret; ··· 322 322 const char *function) 323 323 { 324 324 const struct pinmux_ops *ops = pctldev->desc->pmxops; 325 - unsigned nfuncs = ops->get_functions_count(pctldev); 326 - unsigned selector = 0; 325 + unsigned int nfuncs = ops->get_functions_count(pctldev); 326 + unsigned int selector = 0; 327 327 328 328 /* See if this pctldev has this function */ 329 329 while (selector < nfuncs) { ··· 344 344 struct pinctrl_dev *pctldev = setting->pctldev; 345 345 const struct pinmux_ops *pmxops = pctldev->desc->pmxops; 346 346 char const * const *groups; 347 - unsigned num_groups; 347 + unsigned int num_groups; 348 348 int ret; 349 349 const char *group; 350 350 ··· 409 409 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops; 410 410 const struct pinmux_ops *ops = pctldev->desc->pmxops; 411 411 int ret = 0; 412 - const unsigned *pins = NULL; 413 - unsigned num_pins = 0; 412 + const unsigned int *pins = NULL; 413 + unsigned int num_pins = 0; 414 414 int i; 415 415 struct pin_desc *desc; 416 416 ··· 489 489 struct pinctrl_dev *pctldev = setting->pctldev; 490 490 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops; 491 491 int ret = 0; 492 - const unsigned *pins = NULL; 493 - unsigned num_pins = 0; 492 + const unsigned int *pins = NULL; 493 + unsigned int num_pins = 0; 494 494 int i; 495 495 struct pin_desc *desc; 496 496 ··· 541 541 { 542 542 struct pinctrl_dev *pctldev = s->private; 543 543 const struct pinmux_ops *pmxops = pctldev->desc->pmxops; 544 - unsigned nfuncs; 545 - unsigned func_selector = 0; 544 + unsigned int nfuncs; 545 + unsigned int func_selector = 0; 546 546 547 547 if (!pmxops) 548 548 return 0; ··· 553 553 const char *func = pmxops->get_function_name(pctldev, 554 554 func_selector); 555 555 const char * const *groups; 556 - unsigned num_groups; 556 + unsigned int num_groups; 557 557 int ret; 558 558 int i; 559 559 ··· 584 584 struct pinctrl_dev *pctldev = s->private; 585 585 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops; 586 586 const struct pinmux_ops *pmxops = pctldev->desc->pmxops; 587 - unsigned i, pin; 587 + unsigned int i, pin; 588 588 589 589 if (!pmxops) 590 590 return 0; ··· 818 818 int pinmux_generic_get_function_groups(struct pinctrl_dev *pctldev, 819 819 unsigned int selector, 820 820 const char * const **groups, 821 - unsigned * const num_groups) 821 + unsigned int * const num_groups) 822 822 { 823 823 struct function_desc *function; 824 824
+10 -10
drivers/pinctrl/pinmux.h
··· 26 26 27 27 int pinmux_validate_map(const struct pinctrl_map *map, int i); 28 28 29 - bool pinmux_can_be_used_for_gpio(struct pinctrl_dev *pctldev, unsigned pin); 29 + bool pinmux_can_be_used_for_gpio(struct pinctrl_dev *pctldev, unsigned int pin); 30 30 31 31 int pinmux_request_gpio(struct pinctrl_dev *pctldev, 32 32 struct pinctrl_gpio_range *range, 33 - unsigned pin, unsigned gpio); 34 - void pinmux_free_gpio(struct pinctrl_dev *pctldev, unsigned pin, 33 + unsigned int pin, unsigned int gpio); 34 + void pinmux_free_gpio(struct pinctrl_dev *pctldev, unsigned int pin, 35 35 struct pinctrl_gpio_range *range); 36 36 int pinmux_gpio_direction(struct pinctrl_dev *pctldev, 37 37 struct pinctrl_gpio_range *range, 38 - unsigned pin, bool input); 38 + unsigned int pin, bool input); 39 39 40 40 int pinmux_map_to_setting(const struct pinctrl_map *map, 41 41 struct pinctrl_setting *setting); ··· 56 56 } 57 57 58 58 static inline bool pinmux_can_be_used_for_gpio(struct pinctrl_dev *pctldev, 59 - unsigned pin) 59 + unsigned int pin) 60 60 { 61 61 return true; 62 62 } 63 63 64 64 static inline int pinmux_request_gpio(struct pinctrl_dev *pctldev, 65 65 struct pinctrl_gpio_range *range, 66 - unsigned pin, unsigned gpio) 66 + unsigned int pin, unsigned int gpio) 67 67 { 68 68 return 0; 69 69 } 70 70 71 71 static inline void pinmux_free_gpio(struct pinctrl_dev *pctldev, 72 - unsigned pin, 72 + unsigned int pin, 73 73 struct pinctrl_gpio_range *range) 74 74 { 75 75 } 76 76 77 77 static inline int pinmux_gpio_direction(struct pinctrl_dev *pctldev, 78 78 struct pinctrl_gpio_range *range, 79 - unsigned pin, bool input) 79 + unsigned int pin, bool input) 80 80 { 81 81 return 0; 82 82 } ··· 154 154 int pinmux_generic_get_function_groups(struct pinctrl_dev *pctldev, 155 155 unsigned int selector, 156 156 const char * const **groups, 157 - unsigned * const num_groups); 157 + unsigned int * const num_groups); 158 158 159 159 struct function_desc *pinmux_generic_get_function(struct pinctrl_dev *pctldev, 160 160 unsigned int selector); ··· 162 162 int pinmux_generic_add_function(struct pinctrl_dev *pctldev, 163 163 const char *name, 164 164 const char * const *groups, 165 - unsigned const num_groups, 165 + unsigned int const num_groups, 166 166 void *data); 167 167 168 168 int pinmux_generic_remove_function(struct pinctrl_dev *pctldev,
+3 -3
include/linux/pinctrl/machine.h
··· 47 47 struct pinctrl_map_configs { 48 48 const char *group_or_pin; 49 49 unsigned long *configs; 50 - unsigned num_configs; 50 + unsigned int num_configs; 51 51 }; 52 52 53 53 /** ··· 154 154 #ifdef CONFIG_PINCTRL 155 155 156 156 extern int pinctrl_register_mappings(const struct pinctrl_map *map, 157 - unsigned num_maps); 157 + unsigned int num_maps); 158 158 extern void pinctrl_unregister_mappings(const struct pinctrl_map *map); 159 159 extern void pinctrl_provide_dummies(void); 160 160 #else 161 161 162 162 static inline int pinctrl_register_mappings(const struct pinctrl_map *map, 163 - unsigned num_maps) 163 + unsigned int num_maps) 164 164 { 165 165 return 0; 166 166 }
+5 -5
include/linux/pinctrl/pinconf-generic.h
··· 193 193 194 194 int pinconf_generic_dt_subnode_to_map(struct pinctrl_dev *pctldev, 195 195 struct device_node *np, struct pinctrl_map **map, 196 - unsigned *reserved_maps, unsigned *num_maps, 196 + unsigned int *reserved_maps, unsigned int *num_maps, 197 197 enum pinctrl_map_type type); 198 198 int pinconf_generic_dt_node_to_map(struct pinctrl_dev *pctldev, 199 199 struct device_node *np_config, struct pinctrl_map **map, 200 - unsigned *num_maps, enum pinctrl_map_type type); 200 + unsigned int *num_maps, enum pinctrl_map_type type); 201 201 void pinconf_generic_dt_free_map(struct pinctrl_dev *pctldev, 202 - struct pinctrl_map *map, unsigned num_maps); 202 + struct pinctrl_map *map, unsigned int num_maps); 203 203 204 204 static inline int pinconf_generic_dt_node_to_map_group(struct pinctrl_dev *pctldev, 205 205 struct device_node *np_config, struct pinctrl_map **map, 206 - unsigned *num_maps) 206 + unsigned int *num_maps) 207 207 { 208 208 return pinconf_generic_dt_node_to_map(pctldev, np_config, map, num_maps, 209 209 PIN_MAP_TYPE_CONFIGS_GROUP); ··· 211 211 212 212 static inline int pinconf_generic_dt_node_to_map_pin(struct pinctrl_dev *pctldev, 213 213 struct device_node *np_config, struct pinctrl_map **map, 214 - unsigned *num_maps) 214 + unsigned int *num_maps) 215 215 { 216 216 return pinconf_generic_dt_node_to_map(pctldev, np_config, map, num_maps, 217 217 PIN_MAP_TYPE_CONFIGS_PIN);
+8 -8
include/linux/pinctrl/pinconf.h
··· 40 40 bool is_generic; 41 41 #endif 42 42 int (*pin_config_get) (struct pinctrl_dev *pctldev, 43 - unsigned pin, 43 + unsigned int pin, 44 44 unsigned long *config); 45 45 int (*pin_config_set) (struct pinctrl_dev *pctldev, 46 - unsigned pin, 46 + unsigned int pin, 47 47 unsigned long *configs, 48 - unsigned num_configs); 48 + unsigned int num_configs); 49 49 int (*pin_config_group_get) (struct pinctrl_dev *pctldev, 50 - unsigned selector, 50 + unsigned int selector, 51 51 unsigned long *config); 52 52 int (*pin_config_group_set) (struct pinctrl_dev *pctldev, 53 - unsigned selector, 53 + unsigned int selector, 54 54 unsigned long *configs, 55 - unsigned num_configs); 55 + unsigned int num_configs); 56 56 void (*pin_config_dbg_show) (struct pinctrl_dev *pctldev, 57 57 struct seq_file *s, 58 - unsigned offset); 58 + unsigned int offset); 59 59 void (*pin_config_group_dbg_show) (struct pinctrl_dev *pctldev, 60 60 struct seq_file *s, 61 - unsigned selector); 61 + unsigned int selector); 62 62 void (*pin_config_config_dbg_show) (struct pinctrl_dev *pctldev, 63 63 struct seq_file *s, 64 64 unsigned long config);
+12 -12
include/linux/pinctrl/pinctrl.h
··· 54 54 * @drv_data: driver-defined per-pin data. pinctrl core does not touch this 55 55 */ 56 56 struct pinctrl_pin_desc { 57 - unsigned number; 57 + unsigned int number; 58 58 const char *name; 59 59 void *drv_data; 60 60 }; ··· 82 82 unsigned int base; 83 83 unsigned int pin_base; 84 84 unsigned int npins; 85 - unsigned const *pins; 85 + unsigned int const *pins; 86 86 struct gpio_chip *gc; 87 87 }; 88 88 ··· 108 108 struct pinctrl_ops { 109 109 int (*get_groups_count) (struct pinctrl_dev *pctldev); 110 110 const char *(*get_group_name) (struct pinctrl_dev *pctldev, 111 - unsigned selector); 111 + unsigned int selector); 112 112 int (*get_group_pins) (struct pinctrl_dev *pctldev, 113 - unsigned selector, 114 - const unsigned **pins, 115 - unsigned *num_pins); 113 + unsigned int selector, 114 + const unsigned int **pins, 115 + unsigned int *num_pins); 116 116 void (*pin_dbg_show) (struct pinctrl_dev *pctldev, struct seq_file *s, 117 - unsigned offset); 117 + unsigned int offset); 118 118 int (*dt_node_to_map) (struct pinctrl_dev *pctldev, 119 119 struct device_node *np_config, 120 - struct pinctrl_map **map, unsigned *num_maps); 120 + struct pinctrl_map **map, unsigned int *num_maps); 121 121 void (*dt_free_map) (struct pinctrl_dev *pctldev, 122 - struct pinctrl_map *map, unsigned num_maps); 122 + struct pinctrl_map *map, unsigned int num_maps); 123 123 }; 124 124 125 125 /** ··· 193 193 struct pinctrl_gpio_range *range); 194 194 extern void pinctrl_add_gpio_ranges(struct pinctrl_dev *pctldev, 195 195 struct pinctrl_gpio_range *ranges, 196 - unsigned nranges); 196 + unsigned int nranges); 197 197 extern void pinctrl_remove_gpio_range(struct pinctrl_dev *pctldev, 198 198 struct pinctrl_gpio_range *range); 199 199 ··· 203 203 pinctrl_find_gpio_range_from_pin(struct pinctrl_dev *pctldev, 204 204 unsigned int pin); 205 205 extern int pinctrl_get_group_pins(struct pinctrl_dev *pctldev, 206 - const char *pin_group, const unsigned **pins, 207 - unsigned *num_pins); 206 + const char *pin_group, const unsigned int **pins, 207 + unsigned int *num_pins); 208 208 209 209 /** 210 210 * struct pinfunction - Description about a function
+11 -11
include/linux/pinctrl/pinmux.h
··· 57 57 * the pin request. 58 58 */ 59 59 struct pinmux_ops { 60 - int (*request) (struct pinctrl_dev *pctldev, unsigned offset); 61 - int (*free) (struct pinctrl_dev *pctldev, unsigned offset); 60 + int (*request) (struct pinctrl_dev *pctldev, unsigned int offset); 61 + int (*free) (struct pinctrl_dev *pctldev, unsigned int offset); 62 62 int (*get_functions_count) (struct pinctrl_dev *pctldev); 63 63 const char *(*get_function_name) (struct pinctrl_dev *pctldev, 64 - unsigned selector); 64 + unsigned int selector); 65 65 int (*get_function_groups) (struct pinctrl_dev *pctldev, 66 - unsigned selector, 67 - const char * const **groups, 68 - unsigned *num_groups); 69 - int (*set_mux) (struct pinctrl_dev *pctldev, unsigned func_selector, 70 - unsigned group_selector); 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 71 int (*gpio_request_enable) (struct pinctrl_dev *pctldev, 72 72 struct pinctrl_gpio_range *range, 73 - unsigned offset); 73 + unsigned int offset); 74 74 void (*gpio_disable_free) (struct pinctrl_dev *pctldev, 75 75 struct pinctrl_gpio_range *range, 76 - unsigned offset); 76 + unsigned int offset); 77 77 int (*gpio_set_direction) (struct pinctrl_dev *pctldev, 78 78 struct pinctrl_gpio_range *range, 79 - unsigned offset, 79 + unsigned int offset, 80 80 bool input); 81 81 bool strict; 82 82 };