1 /* 2 * Pinctrl driver for the Wondermedia SoC's 3 * 4 * Copyright (c) 2013 Tony Prisk <linux@prisktech.co.nz> 5 * 6 * This program is free software; you can redistribute it and/or modify it 7 * under the terms and conditions of the GNU General Public License, 8 * version 2, as published by the Free Software Foundation. 9 * 10 * This program is distributed in the hope it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 13 * more details. 14 */ 15 16 #include <linux/err.h> 17 #include <linux/gpio/driver.h> 18 #include <linux/interrupt.h> 19 #include <linux/io.h> 20 #include <linux/irq.h> 21 #include <linux/of.h> 22 #include <linux/of_irq.h> 23 #include <linux/pinctrl/consumer.h> 24 #include <linux/pinctrl/machine.h> 25 #include <linux/pinctrl/pinconf.h> 26 #include <linux/pinctrl/pinconf-generic.h> 27 #include <linux/pinctrl/pinctrl.h> 28 #include <linux/pinctrl/pinmux.h> 29 #include <linux/platform_device.h> 30 #include <linux/slab.h> 31 32 #include "pinctrl-wmt.h" 33 34 static inline void wmt_setbits(struct wmt_pinctrl_data *data, u32 reg, 35 u32 mask) 36 { 37 u32 val; 38 39 val = readl_relaxed(data->base + reg); 40 val |= mask; 41 writel_relaxed(val, data->base + reg); 42 } 43 44 static inline void wmt_clearbits(struct wmt_pinctrl_data *data, u32 reg, 45 u32 mask) 46 { 47 u32 val; 48 49 val = readl_relaxed(data->base + reg); 50 val &= ~mask; 51 writel_relaxed(val, data->base + reg); 52 } 53 54 enum wmt_func_sel { 55 WMT_FSEL_GPIO_IN = 0, 56 WMT_FSEL_GPIO_OUT = 1, 57 WMT_FSEL_ALT = 2, 58 WMT_FSEL_COUNT = 3, 59 }; 60 61 static const char * const wmt_functions[WMT_FSEL_COUNT] = { 62 [WMT_FSEL_GPIO_IN] = "gpio_in", 63 [WMT_FSEL_GPIO_OUT] = "gpio_out", 64 [WMT_FSEL_ALT] = "alt", 65 }; 66 67 static int wmt_pmx_get_functions_count(struct pinctrl_dev *pctldev) 68 { 69 return WMT_FSEL_COUNT; 70 } 71 72 static const char *wmt_pmx_get_function_name(struct pinctrl_dev *pctldev, 73 unsigned selector) 74 { 75 return wmt_functions[selector]; 76 } 77 78 static int wmt_pmx_get_function_groups(struct pinctrl_dev *pctldev, 79 unsigned selector, 80 const char * const **groups, 81 unsigned * const num_groups) 82 { 83 struct wmt_pinctrl_data *data = pinctrl_dev_get_drvdata(pctldev); 84 85 /* every pin does every function */ 86 *groups = data->groups; 87 *num_groups = data->ngroups; 88 89 return 0; 90 } 91 92 static int wmt_set_pinmux(struct wmt_pinctrl_data *data, unsigned func, 93 unsigned pin) 94 { 95 u32 bank = WMT_BANK_FROM_PIN(pin); 96 u32 bit = WMT_BIT_FROM_PIN(pin); 97 u32 reg_en = data->banks[bank].reg_en; 98 u32 reg_dir = data->banks[bank].reg_dir; 99 100 if (reg_dir == NO_REG) { 101 dev_err(data->dev, "pin:%d no direction register defined\n", 102 pin); 103 return -EINVAL; 104 } 105 106 /* 107 * If reg_en == NO_REG, we assume it is a dedicated GPIO and cannot be 108 * disabled (as on VT8500) and that no alternate function is available. 109 */ 110 switch (func) { 111 case WMT_FSEL_GPIO_IN: 112 if (reg_en != NO_REG) 113 wmt_setbits(data, reg_en, BIT(bit)); 114 wmt_clearbits(data, reg_dir, BIT(bit)); 115 break; 116 case WMT_FSEL_GPIO_OUT: 117 if (reg_en != NO_REG) 118 wmt_setbits(data, reg_en, BIT(bit)); 119 wmt_setbits(data, reg_dir, BIT(bit)); 120 break; 121 case WMT_FSEL_ALT: 122 if (reg_en == NO_REG) { 123 dev_err(data->dev, "pin:%d no alt function available\n", 124 pin); 125 return -EINVAL; 126 } 127 wmt_clearbits(data, reg_en, BIT(bit)); 128 } 129 130 return 0; 131 } 132 133 static int wmt_pmx_set_mux(struct pinctrl_dev *pctldev, 134 unsigned func_selector, 135 unsigned group_selector) 136 { 137 struct wmt_pinctrl_data *data = pinctrl_dev_get_drvdata(pctldev); 138 u32 pinnum = data->pins[group_selector].number; 139 140 return wmt_set_pinmux(data, func_selector, pinnum); 141 } 142 143 static void wmt_pmx_gpio_disable_free(struct pinctrl_dev *pctldev, 144 struct pinctrl_gpio_range *range, 145 unsigned offset) 146 { 147 struct wmt_pinctrl_data *data = pinctrl_dev_get_drvdata(pctldev); 148 149 /* disable by setting GPIO_IN */ 150 wmt_set_pinmux(data, WMT_FSEL_GPIO_IN, offset); 151 } 152 153 static int wmt_pmx_gpio_set_direction(struct pinctrl_dev *pctldev, 154 struct pinctrl_gpio_range *range, 155 unsigned offset, 156 bool input) 157 { 158 struct wmt_pinctrl_data *data = pinctrl_dev_get_drvdata(pctldev); 159 160 wmt_set_pinmux(data, (input ? WMT_FSEL_GPIO_IN : WMT_FSEL_GPIO_OUT), 161 offset); 162 163 return 0; 164 } 165 166 static const struct pinmux_ops wmt_pinmux_ops = { 167 .get_functions_count = wmt_pmx_get_functions_count, 168 .get_function_name = wmt_pmx_get_function_name, 169 .get_function_groups = wmt_pmx_get_function_groups, 170 .set_mux = wmt_pmx_set_mux, 171 .gpio_disable_free = wmt_pmx_gpio_disable_free, 172 .gpio_set_direction = wmt_pmx_gpio_set_direction, 173 }; 174 175 static int wmt_get_groups_count(struct pinctrl_dev *pctldev) 176 { 177 struct wmt_pinctrl_data *data = pinctrl_dev_get_drvdata(pctldev); 178 179 return data->ngroups; 180 } 181 182 static const char *wmt_get_group_name(struct pinctrl_dev *pctldev, 183 unsigned selector) 184 { 185 struct wmt_pinctrl_data *data = pinctrl_dev_get_drvdata(pctldev); 186 187 return data->groups[selector]; 188 } 189 190 static int wmt_get_group_pins(struct pinctrl_dev *pctldev, 191 unsigned selector, 192 const unsigned **pins, 193 unsigned *num_pins) 194 { 195 struct wmt_pinctrl_data *data = pinctrl_dev_get_drvdata(pctldev); 196 197 *pins = &data->pins[selector].number; 198 *num_pins = 1; 199 200 return 0; 201 } 202 203 static int wmt_pctl_find_group_by_pin(struct wmt_pinctrl_data *data, u32 pin) 204 { 205 int i; 206 207 for (i = 0; i < data->npins; i++) { 208 if (data->pins[i].number == pin) 209 return i; 210 } 211 212 return -EINVAL; 213 } 214 215 static int wmt_pctl_dt_node_to_map_func(struct wmt_pinctrl_data *data, 216 struct device_node *np, 217 u32 pin, u32 fnum, 218 struct pinctrl_map **maps) 219 { 220 int group; 221 struct pinctrl_map *map = *maps; 222 223 if (fnum >= ARRAY_SIZE(wmt_functions)) { 224 dev_err(data->dev, "invalid wm,function %d\n", fnum); 225 return -EINVAL; 226 } 227 228 group = wmt_pctl_find_group_by_pin(data, pin); 229 if (group < 0) { 230 dev_err(data->dev, "unable to match pin %d to group\n", pin); 231 return group; 232 } 233 234 map->type = PIN_MAP_TYPE_MUX_GROUP; 235 map->data.mux.group = data->groups[group]; 236 map->data.mux.function = wmt_functions[fnum]; 237 (*maps)++; 238 239 return 0; 240 } 241 242 static int wmt_pctl_dt_node_to_map_pull(struct wmt_pinctrl_data *data, 243 struct device_node *np, 244 u32 pin, u32 pull, 245 struct pinctrl_map **maps) 246 { 247 int group; 248 unsigned long *configs; 249 struct pinctrl_map *map = *maps; 250 251 if (pull > 2) { 252 dev_err(data->dev, "invalid wm,pull %d\n", pull); 253 return -EINVAL; 254 } 255 256 group = wmt_pctl_find_group_by_pin(data, pin); 257 if (group < 0) { 258 dev_err(data->dev, "unable to match pin %d to group\n", pin); 259 return group; 260 } 261 262 configs = kzalloc(sizeof(*configs), GFP_KERNEL); 263 if (!configs) 264 return -ENOMEM; 265 266 switch (pull) { 267 case 0: 268 configs[0] = PIN_CONFIG_BIAS_DISABLE; 269 break; 270 case 1: 271 configs[0] = PIN_CONFIG_BIAS_PULL_DOWN; 272 break; 273 case 2: 274 configs[0] = PIN_CONFIG_BIAS_PULL_UP; 275 break; 276 default: 277 configs[0] = PIN_CONFIG_BIAS_DISABLE; 278 dev_err(data->dev, "invalid pull state %d - disabling\n", pull); 279 } 280 281 map->type = PIN_MAP_TYPE_CONFIGS_PIN; 282 map->data.configs.group_or_pin = data->groups[group]; 283 map->data.configs.configs = configs; 284 map->data.configs.num_configs = 1; 285 (*maps)++; 286 287 return 0; 288 } 289 290 static void wmt_pctl_dt_free_map(struct pinctrl_dev *pctldev, 291 struct pinctrl_map *maps, 292 unsigned num_maps) 293 { 294 int i; 295 296 for (i = 0; i < num_maps; i++) 297 if (maps[i].type == PIN_MAP_TYPE_CONFIGS_PIN) 298 kfree(maps[i].data.configs.configs); 299 300 kfree(maps); 301 } 302 303 static int wmt_pctl_dt_node_to_map(struct pinctrl_dev *pctldev, 304 struct device_node *np, 305 struct pinctrl_map **map, 306 unsigned *num_maps) 307 { 308 struct pinctrl_map *maps, *cur_map; 309 struct property *pins, *funcs, *pulls; 310 u32 pin, func, pull; 311 int num_pins, num_funcs, num_pulls, maps_per_pin; 312 int i, err; 313 struct wmt_pinctrl_data *data = pinctrl_dev_get_drvdata(pctldev); 314 315 pins = of_find_property(np, "wm,pins", NULL); 316 if (!pins) { 317 dev_err(data->dev, "missing wmt,pins property\n"); 318 return -EINVAL; 319 } 320 321 funcs = of_find_property(np, "wm,function", NULL); 322 pulls = of_find_property(np, "wm,pull", NULL); 323 324 if (!funcs && !pulls) { 325 dev_err(data->dev, "neither wm,function nor wm,pull specified\n"); 326 return -EINVAL; 327 } 328 329 /* 330 * The following lines calculate how many values are defined for each 331 * of the properties. 332 */ 333 num_pins = pins->length / sizeof(u32); 334 num_funcs = funcs ? (funcs->length / sizeof(u32)) : 0; 335 num_pulls = pulls ? (pulls->length / sizeof(u32)) : 0; 336 337 if (num_funcs > 1 && num_funcs != num_pins) { 338 dev_err(data->dev, "wm,function must have 1 or %d entries\n", 339 num_pins); 340 return -EINVAL; 341 } 342 343 if (num_pulls > 1 && num_pulls != num_pins) { 344 dev_err(data->dev, "wm,pull must have 1 or %d entries\n", 345 num_pins); 346 return -EINVAL; 347 } 348 349 maps_per_pin = 0; 350 if (num_funcs) 351 maps_per_pin++; 352 if (num_pulls) 353 maps_per_pin++; 354 355 cur_map = maps = kcalloc(num_pins * maps_per_pin, sizeof(*maps), 356 GFP_KERNEL); 357 if (!maps) 358 return -ENOMEM; 359 360 for (i = 0; i < num_pins; i++) { 361 err = of_property_read_u32_index(np, "wm,pins", i, &pin); 362 if (err) 363 goto fail; 364 365 if (pin >= (data->nbanks * 32)) { 366 dev_err(data->dev, "invalid wm,pins value\n"); 367 err = -EINVAL; 368 goto fail; 369 } 370 371 if (num_funcs) { 372 err = of_property_read_u32_index(np, "wm,function", 373 (num_funcs > 1 ? i : 0), &func); 374 if (err) 375 goto fail; 376 377 err = wmt_pctl_dt_node_to_map_func(data, np, pin, func, 378 &cur_map); 379 if (err) 380 goto fail; 381 } 382 383 if (num_pulls) { 384 err = of_property_read_u32_index(np, "wm,pull", 385 (num_pulls > 1 ? i : 0), &pull); 386 if (err) 387 goto fail; 388 389 err = wmt_pctl_dt_node_to_map_pull(data, np, pin, pull, 390 &cur_map); 391 if (err) 392 goto fail; 393 } 394 } 395 *map = maps; 396 *num_maps = num_pins * maps_per_pin; 397 return 0; 398 399 /* 400 * The fail path removes any maps that have been allocated. The fail path is 401 * only called from code after maps has been kzalloc'd. It is also safe to 402 * pass 'num_pins * maps_per_pin' as the map count even though we probably 403 * failed before all the mappings were read as all maps are allocated at once, 404 * and configs are only allocated for .type = PIN_MAP_TYPE_CONFIGS_PIN - there 405 * is no failpath where a config can be allocated without .type being set. 406 */ 407 fail: 408 wmt_pctl_dt_free_map(pctldev, maps, num_pins * maps_per_pin); 409 return err; 410 } 411 412 static const struct pinctrl_ops wmt_pctl_ops = { 413 .get_groups_count = wmt_get_groups_count, 414 .get_group_name = wmt_get_group_name, 415 .get_group_pins = wmt_get_group_pins, 416 .dt_node_to_map = wmt_pctl_dt_node_to_map, 417 .dt_free_map = wmt_pctl_dt_free_map, 418 }; 419 420 static int wmt_pinconf_get(struct pinctrl_dev *pctldev, unsigned pin, 421 unsigned long *config) 422 { 423 return -ENOTSUPP; 424 } 425 426 static int wmt_pinconf_set(struct pinctrl_dev *pctldev, unsigned pin, 427 unsigned long *configs, unsigned num_configs) 428 { 429 struct wmt_pinctrl_data *data = pinctrl_dev_get_drvdata(pctldev); 430 enum pin_config_param param; 431 u32 arg; 432 u32 bank = WMT_BANK_FROM_PIN(pin); 433 u32 bit = WMT_BIT_FROM_PIN(pin); 434 u32 reg_pull_en = data->banks[bank].reg_pull_en; 435 u32 reg_pull_cfg = data->banks[bank].reg_pull_cfg; 436 int i; 437 438 if ((reg_pull_en == NO_REG) || (reg_pull_cfg == NO_REG)) { 439 dev_err(data->dev, "bias functions not supported on pin %d\n", 440 pin); 441 return -EINVAL; 442 } 443 444 for (i = 0; i < num_configs; i++) { 445 param = pinconf_to_config_param(configs[i]); 446 arg = pinconf_to_config_argument(configs[i]); 447 448 if ((param == PIN_CONFIG_BIAS_PULL_DOWN) || 449 (param == PIN_CONFIG_BIAS_PULL_UP)) { 450 if (arg == 0) 451 param = PIN_CONFIG_BIAS_DISABLE; 452 } 453 454 switch (param) { 455 case PIN_CONFIG_BIAS_DISABLE: 456 wmt_clearbits(data, reg_pull_en, BIT(bit)); 457 break; 458 case PIN_CONFIG_BIAS_PULL_DOWN: 459 wmt_clearbits(data, reg_pull_cfg, BIT(bit)); 460 wmt_setbits(data, reg_pull_en, BIT(bit)); 461 break; 462 case PIN_CONFIG_BIAS_PULL_UP: 463 wmt_setbits(data, reg_pull_cfg, BIT(bit)); 464 wmt_setbits(data, reg_pull_en, BIT(bit)); 465 break; 466 default: 467 dev_err(data->dev, "unknown pinconf param\n"); 468 return -EINVAL; 469 } 470 } /* for each config */ 471 472 return 0; 473 } 474 475 static const struct pinconf_ops wmt_pinconf_ops = { 476 .pin_config_get = wmt_pinconf_get, 477 .pin_config_set = wmt_pinconf_set, 478 }; 479 480 static struct pinctrl_desc wmt_desc = { 481 .owner = THIS_MODULE, 482 .name = "pinctrl-wmt", 483 .pctlops = &wmt_pctl_ops, 484 .pmxops = &wmt_pinmux_ops, 485 .confops = &wmt_pinconf_ops, 486 }; 487 488 static int wmt_gpio_get_direction(struct gpio_chip *chip, unsigned offset) 489 { 490 struct wmt_pinctrl_data *data = gpiochip_get_data(chip); 491 u32 bank = WMT_BANK_FROM_PIN(offset); 492 u32 bit = WMT_BIT_FROM_PIN(offset); 493 u32 reg_dir = data->banks[bank].reg_dir; 494 u32 val; 495 496 val = readl_relaxed(data->base + reg_dir); 497 /* Return 0 == output, 1 == input */ 498 return !(val & BIT(bit)); 499 } 500 501 static int wmt_gpio_get_value(struct gpio_chip *chip, unsigned offset) 502 { 503 struct wmt_pinctrl_data *data = gpiochip_get_data(chip); 504 u32 bank = WMT_BANK_FROM_PIN(offset); 505 u32 bit = WMT_BIT_FROM_PIN(offset); 506 u32 reg_data_in = data->banks[bank].reg_data_in; 507 508 if (reg_data_in == NO_REG) { 509 dev_err(data->dev, "no data in register defined\n"); 510 return -EINVAL; 511 } 512 513 return !!(readl_relaxed(data->base + reg_data_in) & BIT(bit)); 514 } 515 516 static void wmt_gpio_set_value(struct gpio_chip *chip, unsigned offset, 517 int val) 518 { 519 struct wmt_pinctrl_data *data = gpiochip_get_data(chip); 520 u32 bank = WMT_BANK_FROM_PIN(offset); 521 u32 bit = WMT_BIT_FROM_PIN(offset); 522 u32 reg_data_out = data->banks[bank].reg_data_out; 523 524 if (reg_data_out == NO_REG) { 525 dev_err(data->dev, "no data out register defined\n"); 526 return; 527 } 528 529 if (val) 530 wmt_setbits(data, reg_data_out, BIT(bit)); 531 else 532 wmt_clearbits(data, reg_data_out, BIT(bit)); 533 } 534 535 static int wmt_gpio_direction_input(struct gpio_chip *chip, unsigned offset) 536 { 537 return pinctrl_gpio_direction_input(chip->base + offset); 538 } 539 540 static int wmt_gpio_direction_output(struct gpio_chip *chip, unsigned offset, 541 int value) 542 { 543 wmt_gpio_set_value(chip, offset, value); 544 return pinctrl_gpio_direction_output(chip->base + offset); 545 } 546 547 static const struct gpio_chip wmt_gpio_chip = { 548 .label = "gpio-wmt", 549 .owner = THIS_MODULE, 550 .request = gpiochip_generic_request, 551 .free = gpiochip_generic_free, 552 .get_direction = wmt_gpio_get_direction, 553 .direction_input = wmt_gpio_direction_input, 554 .direction_output = wmt_gpio_direction_output, 555 .get = wmt_gpio_get_value, 556 .set = wmt_gpio_set_value, 557 .can_sleep = false, 558 }; 559 560 int wmt_pinctrl_probe(struct platform_device *pdev, 561 struct wmt_pinctrl_data *data) 562 { 563 int err; 564 struct resource *res; 565 566 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 567 data->base = devm_ioremap_resource(&pdev->dev, res); 568 if (IS_ERR(data->base)) 569 return PTR_ERR(data->base); 570 571 wmt_desc.pins = data->pins; 572 wmt_desc.npins = data->npins; 573 574 data->gpio_chip = wmt_gpio_chip; 575 data->gpio_chip.parent = &pdev->dev; 576 data->gpio_chip.of_node = pdev->dev.of_node; 577 data->gpio_chip.ngpio = data->nbanks * 32; 578 579 platform_set_drvdata(pdev, data); 580 581 data->dev = &pdev->dev; 582 583 data->pctl_dev = devm_pinctrl_register(&pdev->dev, &wmt_desc, data); 584 if (IS_ERR(data->pctl_dev)) { 585 dev_err(&pdev->dev, "Failed to register pinctrl\n"); 586 return PTR_ERR(data->pctl_dev); 587 } 588 589 err = gpiochip_add_data(&data->gpio_chip, data); 590 if (err) { 591 dev_err(&pdev->dev, "could not add GPIO chip\n"); 592 return err; 593 } 594 595 err = gpiochip_add_pin_range(&data->gpio_chip, dev_name(data->dev), 596 0, 0, data->nbanks * 32); 597 if (err) 598 goto fail_range; 599 600 dev_info(&pdev->dev, "Pin controller initialized\n"); 601 602 return 0; 603 604 fail_range: 605 gpiochip_remove(&data->gpio_chip); 606 return err; 607 } 608