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