After discussion with Mark Brown in an unrelated thread about ADC lookups, it came to my knowledge that the ability to pass a struct device * in the regulator consumers is just a historical artifact, and not really recommended. Since there are no in-kernel users of these pointers, we just kill them right now, before someone starts to use them.
Unified · Split
| @@ -805,10 +805,7 @@ must match a function provided by the pinmux driver handling this pin range. · 804 unmodified lines | ||
| 805 | 805 | |
| 806 | 806 | As you can see we may have several pin controllers on the system and thus |
| 807 | 807 | we need to specify which one of them that contain the functions we wish |
| 808 | −to map. The map can also use struct device * directly, so there is no | |
| 809 | −inherent need to use strings to specify .dev_name or .ctrl_dev_name, these | |
| 810 | −are for the situation where you do not have a handle to the struct device *, | |
| 811 | −for example if they are not yet instantiated or cumbersome to obtain. | |
| 808 | +to map. | |
| 812 | 809 | |
| 813 | 810 | You register this pinmux mapping to the pinmux subsystem by simply: |
| 814 | 811 | |
| @@ -48,31 +48,23 @@ void *pinctrl_dev_get_drvdata(struct pinctrl_dev *pctldev) · 47 unmodified lines | ||
| 48 | 48 | EXPORT_SYMBOL_GPL(pinctrl_dev_get_drvdata); |
| 49 | 49 | |
| 50 | 50 | /** |
| 51 | − * get_pinctrl_dev_from_dev() - look up pin controller device | |
| 52 | − * @dev: a device pointer, this may be NULL but then devname needs to be | |
| 53 | − * defined instead | |
| 54 | − * @devname: the name of a device instance, as returned by dev_name(), this | |
| 55 | − * may be NULL but then dev needs to be defined instead | |
| 51 | + * get_pinctrl_dev_from_devname() - look up pin controller device | |
| 52 | + * @devname: the name of a device instance, as returned by dev_name() | |
| 56 | 53 | * |
| 57 | 54 | * Looks up a pin control device matching a certain device name or pure device |
| 58 | 55 | * pointer, the pure device pointer will take precedence. |
| 59 | 56 | */ |
| 60 | −struct pinctrl_dev *get_pinctrl_dev_from_dev(struct device *dev, | |
| 61 | − const char *devname) | |
| 57 | +struct pinctrl_dev *get_pinctrl_dev_from_devname(const char *devname) | |
| 62 | 58 | { |
| 63 | 59 | struct pinctrl_dev *pctldev = NULL; |
| 64 | 60 | bool found = false; |
| 65 | 61 | |
| 62 | + if (!devname) | |
| 63 | + return NULL; | |
| 64 | + | |
| 66 | 65 | mutex_lock(&pinctrldev_list_mutex); |
| 67 | 66 | list_for_each_entry(pctldev, &pinctrldev_list, node) { |
| 68 | − if (dev && pctldev->dev == dev) { | |
| 69 | − /* Matched on device pointer */ | |
| 70 | − found = true; | |
| 71 | − break; | |
| 72 | − } | |
| 73 | − | |
| 74 | − if (devname && | |
| 75 | − !strcmp(dev_name(pctldev->dev), devname)) { | |
| 67 | + if (!strcmp(dev_name(pctldev->dev), devname)) { | |
| 76 | 68 | /* Matched on device name */ |
| 77 | 69 | found = true; |
| 78 | 70 | break; |
| @@ -72,8 +72,7 @@ struct pin_desc { · 71 unmodified lines | ||
| 72 | 72 | #endif |
| 73 | 73 | }; |
| 74 | 74 | |
| 75 | −struct pinctrl_dev *get_pinctrl_dev_from_dev(struct device *dev, | |
| 76 | − const char *dev_name); | |
| 75 | +struct pinctrl_dev *get_pinctrl_dev_from_devname(const char *dev_name); | |
| 77 | 76 | struct pin_desc *pin_desc_get(struct pinctrl_dev *pctldev, unsigned int pin); |
| 78 | 77 | int pin_get_from_name(struct pinctrl_dev *pctldev, const char *name); |
| 79 | 78 | int pinctrl_get_device_gpio_range(unsigned gpio, |
| @@ -51,7 +51,7 @@ int pin_config_get(const char *dev_name, const char *name, · 50 unmodified lines | ||
| 51 | 51 | struct pinctrl_dev *pctldev; |
| 52 | 52 | int pin; |
| 53 | 53 | |
| 54 | − pctldev = get_pinctrl_dev_from_dev(NULL, dev_name); | |
| 54 | + pctldev = get_pinctrl_dev_from_devname(dev_name); | |
| 55 | 55 | if (!pctldev) |
| 56 | 56 | return -EINVAL; |
| 57 | 57 | |
| @@ -99,7 +99,7 @@ int pin_config_set(const char *dev_name, const char *name, · 41 unmodified lines | ||
| 99 | 99 | struct pinctrl_dev *pctldev; |
| 100 | 100 | int pin; |
| 101 | 101 | |
| 102 | − pctldev = get_pinctrl_dev_from_dev(NULL, dev_name); | |
| 102 | + pctldev = get_pinctrl_dev_from_devname(dev_name); | |
| 103 | 103 | if (!pctldev) |
| 104 | 104 | return -EINVAL; |
| 105 | 105 | |
| @@ -118,7 +118,7 @@ int pin_config_group_get(const char *dev_name, const char *pin_group, · 12 unmodified lines | ||
| 118 | 118 | const struct pinconf_ops *ops; |
| 119 | 119 | int selector; |
| 120 | 120 | |
| 121 | − pctldev = get_pinctrl_dev_from_dev(NULL, dev_name); | |
| 121 | + pctldev = get_pinctrl_dev_from_devname(dev_name); | |
| 122 | 122 | if (!pctldev) |
| 123 | 123 | return -EINVAL; |
| 124 | 124 | ops = pctldev->desc->confops; |
| @@ -151,7 +151,7 @@ int pin_config_group_set(const char *dev_name, const char *pin_group, · 26 unmodified lines | ||
| 151 | 151 | int ret; |
| 152 | 152 | int i; |
| 153 | 153 | |
| 154 | − pctldev = get_pinctrl_dev_from_dev(NULL, dev_name); | |
| 154 | + pctldev = get_pinctrl_dev_from_devname(dev_name); | |
| 155 | 155 | if (!pctldev) |
| 156 | 156 | return -EINVAL; |
| 157 | 157 | ops = pctldev->desc->confops; |
| @@ -354,7 +354,7 @@ int __init pinmux_register_mappings(struct pinmux_map const *maps, · 353 unmodified lines | ||
| 354 | 354 | return -EINVAL; |
| 355 | 355 | } |
| 356 | 356 | |
| 357 | − if (!maps[i].ctrl_dev && !maps[i].ctrl_dev_name) { | |
| 357 | + if (!maps[i].ctrl_dev_name) { | |
| 358 | 358 | pr_err("failed to register map %s (%d): no pin control device given\n", |
| 359 | 359 | maps[i].name, i); |
| 360 | 360 | return -EINVAL; |
| @@ -366,7 +366,7 @@ int __init pinmux_register_mappings(struct pinmux_map const *maps, · 5 unmodified lines | ||
| 366 | 366 | return -EINVAL; |
| 367 | 367 | } |
| 368 | 368 | |
| 369 | − if (!maps[i].dev && !maps[i].dev_name) | |
| 369 | + if (!maps[i].dev_name) | |
| 370 | 370 | pr_debug("add system map %s function %s with no device\n", |
| 371 | 371 | maps[i].name, |
| 372 | 372 | maps[i].function); |
| @@ -721,20 +721,12 @@ struct pinmux *pinmux_get(struct device *dev, const char *name) · 348 unmodified lines | ||
| 721 | 721 | /* |
| 722 | 722 | * First, try to find the pctldev given in the map |
| 723 | 723 | */ |
| 724 | − pctldev = get_pinctrl_dev_from_dev(map->ctrl_dev, | |
| 725 | − map->ctrl_dev_name); | |
| 724 | + pctldev = get_pinctrl_dev_from_devname(map->ctrl_dev_name); | |
| 726 | 725 | if (!pctldev) { |
| 727 | − const char *devname = NULL; | |
| 728 | − | |
| 729 | − if (map->ctrl_dev) | |
| 730 | − devname = dev_name(map->ctrl_dev); | |
| 731 | − else if (map->ctrl_dev_name) | |
| 732 | − devname = map->ctrl_dev_name; | |
| 733 | − | |
| 734 | 726 | pr_warning("could not find a pinctrl device for pinmux function %s, fishy, they shall all have one\n", |
| 735 | 727 | map->function); |
| 736 | 728 | pr_warning("given pinctrl device name: %s", |
| 737 | − devname ? devname : "UNDEFINED"); | |
| 729 | + map->ctrl_dev_name); | |
| 738 | 730 | |
| 739 | 731 | /* Continue to check the other mappings anyway... */ |
| 740 | 732 | continue; |
| @@ -925,7 +917,7 @@ static int pinmux_hog_map(struct pinctrl_dev *pctldev, · 184 unmodified lines | ||
| 925 | 917 | struct pinmux *pmx; |
| 926 | 918 | int ret; |
| 927 | 919 | |
| 928 | − if (map->dev || map->dev_name) { | |
| 920 | + if (map->dev_name) { | |
| 929 | 921 | /* |
| 930 | 922 | * TODO: the day we have device tree support, we can |
| 931 | 923 | * traverse the device tree and hog to specific device nodes |
| @@ -996,9 +988,8 @@ int pinmux_hog_maps(struct pinctrl_dev *pctldev) · 64 unmodified lines | ||
| 996 | 988 | if (!map->hog_on_boot) |
| 997 | 989 | continue; |
| 998 | 990 | |
| 999 | − if ((map->ctrl_dev == dev) || | |
| 1000 | − (map->ctrl_dev_name && | |
| 1001 | − !strcmp(map->ctrl_dev_name, devname))) { | |
| 991 | + if (map->ctrl_dev_name && | |
| 992 | + !strcmp(map->ctrl_dev_name, devname)) { | |
| 1002 | 993 | /* OK time to hog! */ |
| 1003 | 994 | ret = pinmux_hog_map(pctldev, map); |
| 1004 | 995 | if (ret) |
| @@ -1156,14 +1147,12 @@ static int pinmux_maps_show(struct seq_file *s, void *what) · 151 unmodified lines | ||
| 1156 | 1147 | struct pinmux_map const *map = &pinmux_maps[i]; |
| 1157 | 1148 | |
| 1158 | 1149 | seq_printf(s, "%s:\n", map->name); |
| 1159 | − if (map->dev || map->dev_name) | |
| 1150 | + if (map->dev_name) | |
| 1160 | 1151 | seq_printf(s, " device: %s\n", |
| 1161 | − map->dev ? dev_name(map->dev) : | |
| 1162 | 1152 | map->dev_name); |
| 1163 | 1153 | else |
| 1164 | 1154 | seq_printf(s, " SYSTEM MUX\n"); |
| 1165 | 1155 | seq_printf(s, " controlling device %s\n", |
| 1166 | − map->ctrl_dev ? dev_name(map->ctrl_dev) : | |
| 1167 | 1156 | map->ctrl_dev_name); |
| 1168 | 1157 | seq_printf(s, " function: %s\n", map->function); |
| 1169 | 1158 | seq_printf(s, " group: %s\n", map->group ? map->group : |
| @@ -17,22 +17,16 @@ · 16 unmodified lines | ||
| 17 | 17 | * @name: the name of this specific map entry for the particular machine. |
| 18 | 18 | * This is the second parameter passed to pinmux_get() when you want |
| 19 | 19 | * to have several mappings to the same device |
| 20 | − * @ctrl_dev: the pin control device to be used by this mapping, may be NULL | |
| 21 | − * if you provide .ctrl_dev_name instead (this is more common) | |
| 22 | 20 | * @ctrl_dev_name: the name of the device controlling this specific mapping, |
| 23 | − * the name must be the same as in your struct device*, may be NULL if | |
| 24 | − * you provide .ctrl_dev instead | |
| 21 | + * the name must be the same as in your struct device* | |
| 25 | 22 | * @function: a function in the driver to use for this mapping, the driver |
| 26 | 23 | * will lookup the function referenced by this ID on the specified |
| 27 | 24 | * pin control device |
| 28 | 25 | * @group: sometimes a function can map to different pin groups, so this |
| 29 | 26 | * selects a certain specific pin group to activate for the function, if |
| 30 | 27 | * left as NULL, the first applicable group will be used |
| 31 | − * @dev: the device using this specific mapping, may be NULL if you provide | |
| 32 | − * .dev_name instead (this is more common) | |
| 33 | 28 | * @dev_name: the name of the device using this specific mapping, the name |
| 34 | − * must be the same as in your struct device*, may be NULL if you | |
| 35 | − * provide .dev instead | |
| 29 | + * must be the same as in your struct device* | |
| 36 | 30 | * @hog_on_boot: if this is set to true, the pin control subsystem will itself |
| 37 | 31 | * hog the mappings as the pinmux device drivers are attached, so this is |
| 38 | 32 | * typically used with system maps (mux mappings without an assigned |
| @@ -42,11 +36,9 @@ · 3 unmodified lines | ||
| 42 | 36 | */ |
| 43 | 37 | struct pinmux_map { |
| 44 | 38 | const char *name; |
| 45 | − struct device *ctrl_dev; | |
| 46 | 39 | const char *ctrl_dev_name; |
| 47 | 40 | const char *function; |
| 48 | 41 | const char *group; |
| 49 | − struct device *dev; | |
| 50 | 42 | const char *dev_name; |
| 51 | 43 | bool hog_on_boot; |
| 52 | 44 | }; |