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

Configure Feed

Select the types of activity you want to include in your feed.

Merge tag 'pinctrl-v6.6-3' of git://git.kernel.org/pub/scm/linux/kernel/git/linusw/linux-pinctrl

Pull pin control fixes from Linus Walleij:

- Concurrent register updates in the Qualcomm LPASS pin controller gets
a proper lock.

- revert a mutex fix that was causing problems: contention on the mutex
or something of the sort lead to probe reordering and MMC block
devices start to register in a different order, which unsuspecting
userspace is not ready to handle

* tag 'pinctrl-v6.6-3' of git://git.kernel.org/pub/scm/linux/kernel/git/linusw/linux-pinctrl:
Revert "pinctrl: avoid unsafe code pattern in find_pinctrl()"
pinctrl: qcom: lpass-lpi: fix concurrent register updates

Linus Torvalds 659eaa00 f6176471

+18 -15
+7 -9
drivers/pinctrl/core.c
··· 1022 1022 1023 1023 static struct pinctrl *find_pinctrl(struct device *dev) 1024 1024 { 1025 - struct pinctrl *entry, *p = NULL; 1025 + struct pinctrl *p; 1026 1026 1027 1027 mutex_lock(&pinctrl_list_mutex); 1028 - 1029 - list_for_each_entry(entry, &pinctrl_list, node) { 1030 - if (entry->dev == dev) { 1031 - p = entry; 1032 - kref_get(&p->users); 1033 - break; 1028 + list_for_each_entry(p, &pinctrl_list, node) 1029 + if (p->dev == dev) { 1030 + mutex_unlock(&pinctrl_list_mutex); 1031 + return p; 1034 1032 } 1035 - } 1036 1033 1037 1034 mutex_unlock(&pinctrl_list_mutex); 1038 - return p; 1035 + return NULL; 1039 1036 } 1040 1037 1041 1038 static void pinctrl_free(struct pinctrl *p, bool inlist); ··· 1140 1143 p = find_pinctrl(dev); 1141 1144 if (p) { 1142 1145 dev_dbg(dev, "obtain a copy of previously claimed pinctrl\n"); 1146 + kref_get(&p->users); 1143 1147 return p; 1144 1148 } 1145 1149
+11 -6
drivers/pinctrl/qcom/pinctrl-lpass-lpi.c
··· 32 32 char __iomem *tlmm_base; 33 33 char __iomem *slew_base; 34 34 struct clk_bulk_data clks[MAX_LPI_NUM_CLKS]; 35 - struct mutex slew_access_lock; 35 + /* Protects from concurrent register updates */ 36 + struct mutex lock; 36 37 DECLARE_BITMAP(ever_gpio, MAX_NR_GPIO); 37 38 const struct lpi_pinctrl_variant_data *data; 38 39 }; ··· 104 103 if (WARN_ON(i == g->nfuncs)) 105 104 return -EINVAL; 106 105 106 + mutex_lock(&pctrl->lock); 107 107 val = lpi_gpio_read(pctrl, pin, LPI_GPIO_CFG_REG); 108 108 109 109 /* ··· 130 128 131 129 u32p_replace_bits(&val, i, LPI_GPIO_FUNCTION_MASK); 132 130 lpi_gpio_write(pctrl, pin, LPI_GPIO_CFG_REG, val); 131 + mutex_unlock(&pctrl->lock); 133 132 134 133 return 0; 135 134 } ··· 236 233 if (slew_offset == LPI_NO_SLEW) 237 234 break; 238 235 239 - mutex_lock(&pctrl->slew_access_lock); 236 + mutex_lock(&pctrl->lock); 240 237 241 238 sval = ioread32(pctrl->slew_base + LPI_SLEW_RATE_CTL_REG); 242 239 sval &= ~(LPI_SLEW_RATE_MASK << slew_offset); 243 240 sval |= arg << slew_offset; 244 241 iowrite32(sval, pctrl->slew_base + LPI_SLEW_RATE_CTL_REG); 245 242 246 - mutex_unlock(&pctrl->slew_access_lock); 243 + mutex_unlock(&pctrl->lock); 247 244 break; 248 245 default: 249 246 return -EINVAL; ··· 259 256 lpi_gpio_write(pctrl, group, LPI_GPIO_VALUE_REG, val); 260 257 } 261 258 259 + mutex_lock(&pctrl->lock); 262 260 val = lpi_gpio_read(pctrl, group, LPI_GPIO_CFG_REG); 263 261 264 262 u32p_replace_bits(&val, pullup, LPI_GPIO_PULL_MASK); ··· 268 264 u32p_replace_bits(&val, output_enabled, LPI_GPIO_OE_MASK); 269 265 270 266 lpi_gpio_write(pctrl, group, LPI_GPIO_CFG_REG, val); 267 + mutex_unlock(&pctrl->lock); 271 268 272 269 return 0; 273 270 } ··· 466 461 pctrl->chip.label = dev_name(dev); 467 462 pctrl->chip.can_sleep = false; 468 463 469 - mutex_init(&pctrl->slew_access_lock); 464 + mutex_init(&pctrl->lock); 470 465 471 466 pctrl->ctrl = devm_pinctrl_register(dev, &pctrl->desc, pctrl); 472 467 if (IS_ERR(pctrl->ctrl)) { ··· 488 483 return 0; 489 484 490 485 err_pinctrl: 491 - mutex_destroy(&pctrl->slew_access_lock); 486 + mutex_destroy(&pctrl->lock); 492 487 clk_bulk_disable_unprepare(MAX_LPI_NUM_CLKS, pctrl->clks); 493 488 494 489 return ret; ··· 500 495 struct lpi_pinctrl *pctrl = platform_get_drvdata(pdev); 501 496 int i; 502 497 503 - mutex_destroy(&pctrl->slew_access_lock); 498 + mutex_destroy(&pctrl->lock); 504 499 clk_bulk_disable_unprepare(MAX_LPI_NUM_CLKS, pctrl->clks); 505 500 506 501 for (i = 0; i < pctrl->data->npins; i++)