pinctrl-bcm6328.c (9887B)
1// SPDX-License-Identifier: GPL-2.0+ 2/* 3 * Driver for BCM6328 GPIO unit (pinctrl + GPIO) 4 * 5 * Copyright (C) 2021 Álvaro Fernández Rojas <noltari@gmail.com> 6 * Copyright (C) 2016 Jonas Gorski <jonas.gorski@gmail.com> 7 */ 8 9#include <linux/bits.h> 10#include <linux/gpio/driver.h> 11#include <linux/kernel.h> 12#include <linux/of.h> 13#include <linux/pinctrl/pinmux.h> 14#include <linux/platform_device.h> 15#include <linux/regmap.h> 16 17#include "../pinctrl-utils.h" 18 19#include "pinctrl-bcm63xx.h" 20 21#define BCM6328_NUM_GPIOS 32 22 23#define BCM6328_MODE_REG 0x18 24#define BCM6328_MUX_HI_REG 0x1c 25#define BCM6328_MUX_LO_REG 0x20 26#define BCM6328_MUX_OTHER_REG 0x24 27#define BCM6328_MUX_MASK GENMASK(1, 0) 28 29struct bcm6328_pingroup { 30 const char *name; 31 const unsigned * const pins; 32 const unsigned num_pins; 33}; 34 35struct bcm6328_function { 36 const char *name; 37 const char * const *groups; 38 const unsigned num_groups; 39 40 unsigned mode_val:1; 41 unsigned mux_val:2; 42}; 43 44static const unsigned int bcm6328_mux[] = { 45 BCM6328_MUX_LO_REG, 46 BCM6328_MUX_HI_REG, 47 BCM6328_MUX_OTHER_REG 48}; 49 50static const struct pinctrl_pin_desc bcm6328_pins[] = { 51 PINCTRL_PIN(0, "gpio0"), 52 PINCTRL_PIN(1, "gpio1"), 53 PINCTRL_PIN(2, "gpio2"), 54 PINCTRL_PIN(3, "gpio3"), 55 PINCTRL_PIN(4, "gpio4"), 56 PINCTRL_PIN(5, "gpio5"), 57 PINCTRL_PIN(6, "gpio6"), 58 PINCTRL_PIN(7, "gpio7"), 59 PINCTRL_PIN(8, "gpio8"), 60 PINCTRL_PIN(9, "gpio9"), 61 PINCTRL_PIN(10, "gpio10"), 62 PINCTRL_PIN(11, "gpio11"), 63 PINCTRL_PIN(12, "gpio12"), 64 PINCTRL_PIN(13, "gpio13"), 65 PINCTRL_PIN(14, "gpio14"), 66 PINCTRL_PIN(15, "gpio15"), 67 PINCTRL_PIN(16, "gpio16"), 68 PINCTRL_PIN(17, "gpio17"), 69 PINCTRL_PIN(18, "gpio18"), 70 PINCTRL_PIN(19, "gpio19"), 71 PINCTRL_PIN(20, "gpio20"), 72 PINCTRL_PIN(21, "gpio21"), 73 PINCTRL_PIN(22, "gpio22"), 74 PINCTRL_PIN(23, "gpio23"), 75 PINCTRL_PIN(24, "gpio24"), 76 PINCTRL_PIN(25, "gpio25"), 77 PINCTRL_PIN(26, "gpio26"), 78 PINCTRL_PIN(27, "gpio27"), 79 PINCTRL_PIN(28, "gpio28"), 80 PINCTRL_PIN(29, "gpio29"), 81 PINCTRL_PIN(30, "gpio30"), 82 PINCTRL_PIN(31, "gpio31"), 83 84 /* 85 * No idea where they really are; so let's put them according 86 * to their mux offsets. 87 */ 88 PINCTRL_PIN(36, "hsspi_cs1"), 89 PINCTRL_PIN(38, "usb_p2"), 90}; 91 92static unsigned gpio0_pins[] = { 0 }; 93static unsigned gpio1_pins[] = { 1 }; 94static unsigned gpio2_pins[] = { 2 }; 95static unsigned gpio3_pins[] = { 3 }; 96static unsigned gpio4_pins[] = { 4 }; 97static unsigned gpio5_pins[] = { 5 }; 98static unsigned gpio6_pins[] = { 6 }; 99static unsigned gpio7_pins[] = { 7 }; 100static unsigned gpio8_pins[] = { 8 }; 101static unsigned gpio9_pins[] = { 9 }; 102static unsigned gpio10_pins[] = { 10 }; 103static unsigned gpio11_pins[] = { 11 }; 104static unsigned gpio12_pins[] = { 12 }; 105static unsigned gpio13_pins[] = { 13 }; 106static unsigned gpio14_pins[] = { 14 }; 107static unsigned gpio15_pins[] = { 15 }; 108static unsigned gpio16_pins[] = { 16 }; 109static unsigned gpio17_pins[] = { 17 }; 110static unsigned gpio18_pins[] = { 18 }; 111static unsigned gpio19_pins[] = { 19 }; 112static unsigned gpio20_pins[] = { 20 }; 113static unsigned gpio21_pins[] = { 21 }; 114static unsigned gpio22_pins[] = { 22 }; 115static unsigned gpio23_pins[] = { 23 }; 116static unsigned gpio24_pins[] = { 24 }; 117static unsigned gpio25_pins[] = { 25 }; 118static unsigned gpio26_pins[] = { 26 }; 119static unsigned gpio27_pins[] = { 27 }; 120static unsigned gpio28_pins[] = { 28 }; 121static unsigned gpio29_pins[] = { 29 }; 122static unsigned gpio30_pins[] = { 30 }; 123static unsigned gpio31_pins[] = { 31 }; 124 125static unsigned hsspi_cs1_pins[] = { 36 }; 126static unsigned usb_port1_pins[] = { 38 }; 127 128#define BCM6328_GROUP(n) \ 129 { \ 130 .name = #n, \ 131 .pins = n##_pins, \ 132 .num_pins = ARRAY_SIZE(n##_pins), \ 133 } 134 135static struct bcm6328_pingroup bcm6328_groups[] = { 136 BCM6328_GROUP(gpio0), 137 BCM6328_GROUP(gpio1), 138 BCM6328_GROUP(gpio2), 139 BCM6328_GROUP(gpio3), 140 BCM6328_GROUP(gpio4), 141 BCM6328_GROUP(gpio5), 142 BCM6328_GROUP(gpio6), 143 BCM6328_GROUP(gpio7), 144 BCM6328_GROUP(gpio8), 145 BCM6328_GROUP(gpio9), 146 BCM6328_GROUP(gpio10), 147 BCM6328_GROUP(gpio11), 148 BCM6328_GROUP(gpio12), 149 BCM6328_GROUP(gpio13), 150 BCM6328_GROUP(gpio14), 151 BCM6328_GROUP(gpio15), 152 BCM6328_GROUP(gpio16), 153 BCM6328_GROUP(gpio17), 154 BCM6328_GROUP(gpio18), 155 BCM6328_GROUP(gpio19), 156 BCM6328_GROUP(gpio20), 157 BCM6328_GROUP(gpio21), 158 BCM6328_GROUP(gpio22), 159 BCM6328_GROUP(gpio23), 160 BCM6328_GROUP(gpio24), 161 BCM6328_GROUP(gpio25), 162 BCM6328_GROUP(gpio26), 163 BCM6328_GROUP(gpio27), 164 BCM6328_GROUP(gpio28), 165 BCM6328_GROUP(gpio29), 166 BCM6328_GROUP(gpio30), 167 BCM6328_GROUP(gpio31), 168 169 BCM6328_GROUP(hsspi_cs1), 170 BCM6328_GROUP(usb_port1), 171}; 172 173/* GPIO_MODE */ 174static const char * const led_groups[] = { 175 "gpio0", 176 "gpio1", 177 "gpio2", 178 "gpio3", 179 "gpio4", 180 "gpio5", 181 "gpio6", 182 "gpio7", 183 "gpio8", 184 "gpio9", 185 "gpio10", 186 "gpio11", 187 "gpio12", 188 "gpio13", 189 "gpio14", 190 "gpio15", 191 "gpio16", 192 "gpio17", 193 "gpio18", 194 "gpio19", 195 "gpio20", 196 "gpio21", 197 "gpio22", 198 "gpio23", 199}; 200 201/* PINMUX_SEL */ 202static const char * const serial_led_data_groups[] = { 203 "gpio6", 204}; 205 206static const char * const serial_led_clk_groups[] = { 207 "gpio7", 208}; 209 210static const char * const inet_act_led_groups[] = { 211 "gpio11", 212}; 213 214static const char * const pcie_clkreq_groups[] = { 215 "gpio16", 216}; 217 218static const char * const ephy0_act_led_groups[] = { 219 "gpio25", 220}; 221 222static const char * const ephy1_act_led_groups[] = { 223 "gpio26", 224}; 225 226static const char * const ephy2_act_led_groups[] = { 227 "gpio27", 228}; 229 230static const char * const ephy3_act_led_groups[] = { 231 "gpio28", 232}; 233 234static const char * const hsspi_cs1_groups[] = { 235 "hsspi_cs1" 236}; 237 238static const char * const usb_host_port_groups[] = { 239 "usb_port1", 240}; 241 242static const char * const usb_device_port_groups[] = { 243 "usb_port1", 244}; 245 246#define BCM6328_MODE_FUN(n) \ 247 { \ 248 .name = #n, \ 249 .groups = n##_groups, \ 250 .num_groups = ARRAY_SIZE(n##_groups), \ 251 .mode_val = 1, \ 252 } 253 254#define BCM6328_MUX_FUN(n, mux) \ 255 { \ 256 .name = #n, \ 257 .groups = n##_groups, \ 258 .num_groups = ARRAY_SIZE(n##_groups), \ 259 .mux_val = mux, \ 260 } 261 262static const struct bcm6328_function bcm6328_funcs[] = { 263 BCM6328_MODE_FUN(led), 264 BCM6328_MUX_FUN(serial_led_data, 2), 265 BCM6328_MUX_FUN(serial_led_clk, 2), 266 BCM6328_MUX_FUN(inet_act_led, 1), 267 BCM6328_MUX_FUN(pcie_clkreq, 2), 268 BCM6328_MUX_FUN(ephy0_act_led, 1), 269 BCM6328_MUX_FUN(ephy1_act_led, 1), 270 BCM6328_MUX_FUN(ephy2_act_led, 1), 271 BCM6328_MUX_FUN(ephy3_act_led, 1), 272 BCM6328_MUX_FUN(hsspi_cs1, 2), 273 BCM6328_MUX_FUN(usb_host_port, 1), 274 BCM6328_MUX_FUN(usb_device_port, 2), 275}; 276 277static inline unsigned int bcm6328_mux_off(unsigned int pin) 278{ 279 return bcm6328_mux[pin / 16]; 280} 281 282static int bcm6328_pinctrl_get_group_count(struct pinctrl_dev *pctldev) 283{ 284 return ARRAY_SIZE(bcm6328_groups); 285} 286 287static const char *bcm6328_pinctrl_get_group_name(struct pinctrl_dev *pctldev, 288 unsigned group) 289{ 290 return bcm6328_groups[group].name; 291} 292 293static int bcm6328_pinctrl_get_group_pins(struct pinctrl_dev *pctldev, 294 unsigned group, const unsigned **pins, 295 unsigned *num_pins) 296{ 297 *pins = bcm6328_groups[group].pins; 298 *num_pins = bcm6328_groups[group].num_pins; 299 300 return 0; 301} 302 303static int bcm6328_pinctrl_get_func_count(struct pinctrl_dev *pctldev) 304{ 305 return ARRAY_SIZE(bcm6328_funcs); 306} 307 308static const char *bcm6328_pinctrl_get_func_name(struct pinctrl_dev *pctldev, 309 unsigned selector) 310{ 311 return bcm6328_funcs[selector].name; 312} 313 314static int bcm6328_pinctrl_get_groups(struct pinctrl_dev *pctldev, 315 unsigned selector, 316 const char * const **groups, 317 unsigned * const num_groups) 318{ 319 *groups = bcm6328_funcs[selector].groups; 320 *num_groups = bcm6328_funcs[selector].num_groups; 321 322 return 0; 323} 324 325static void bcm6328_rmw_mux(struct bcm63xx_pinctrl *pc, unsigned pin, 326 unsigned int mode, unsigned int mux) 327{ 328 if (pin < BCM6328_NUM_GPIOS) 329 regmap_update_bits(pc->regs, BCM6328_MODE_REG, BIT(pin), 330 mode ? BIT(pin) : 0); 331 332 regmap_update_bits(pc->regs, bcm6328_mux_off(pin), 333 BCM6328_MUX_MASK << ((pin % 16) * 2), 334 mux << ((pin % 16) * 2)); 335} 336 337static int bcm6328_pinctrl_set_mux(struct pinctrl_dev *pctldev, 338 unsigned selector, unsigned group) 339{ 340 struct bcm63xx_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev); 341 const struct bcm6328_pingroup *pg = &bcm6328_groups[group]; 342 const struct bcm6328_function *f = &bcm6328_funcs[selector]; 343 344 bcm6328_rmw_mux(pc, pg->pins[0], f->mode_val, f->mux_val); 345 346 return 0; 347} 348 349static int bcm6328_gpio_request_enable(struct pinctrl_dev *pctldev, 350 struct pinctrl_gpio_range *range, 351 unsigned offset) 352{ 353 struct bcm63xx_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev); 354 355 /* disable all functions using this pin */ 356 bcm6328_rmw_mux(pc, offset, 0, 0); 357 358 return 0; 359} 360 361static const struct pinctrl_ops bcm6328_pctl_ops = { 362 .dt_free_map = pinctrl_utils_free_map, 363 .dt_node_to_map = pinconf_generic_dt_node_to_map_pin, 364 .get_group_name = bcm6328_pinctrl_get_group_name, 365 .get_group_pins = bcm6328_pinctrl_get_group_pins, 366 .get_groups_count = bcm6328_pinctrl_get_group_count, 367}; 368 369static const struct pinmux_ops bcm6328_pmx_ops = { 370 .get_function_groups = bcm6328_pinctrl_get_groups, 371 .get_function_name = bcm6328_pinctrl_get_func_name, 372 .get_functions_count = bcm6328_pinctrl_get_func_count, 373 .gpio_request_enable = bcm6328_gpio_request_enable, 374 .set_mux = bcm6328_pinctrl_set_mux, 375 .strict = true, 376}; 377 378static const struct bcm63xx_pinctrl_soc bcm6328_soc = { 379 .ngpios = BCM6328_NUM_GPIOS, 380 .npins = ARRAY_SIZE(bcm6328_pins), 381 .pctl_ops = &bcm6328_pctl_ops, 382 .pins = bcm6328_pins, 383 .pmx_ops = &bcm6328_pmx_ops, 384}; 385 386static int bcm6328_pinctrl_probe(struct platform_device *pdev) 387{ 388 return bcm63xx_pinctrl_probe(pdev, &bcm6328_soc, NULL); 389} 390 391static const struct of_device_id bcm6328_pinctrl_match[] = { 392 { .compatible = "brcm,bcm6328-pinctrl", }, 393 { /* sentinel */ } 394}; 395 396static struct platform_driver bcm6328_pinctrl_driver = { 397 .probe = bcm6328_pinctrl_probe, 398 .driver = { 399 .name = "bcm6328-pinctrl", 400 .of_match_table = bcm6328_pinctrl_match, 401 }, 402}; 403 404builtin_platform_driver(bcm6328_pinctrl_driver);