1 /* 2 * Copyright (C) ST-Ericsson SA 2013 3 * 4 * Author: Patrice Chotard <patrice.chotard@st.com> 5 * License terms: GNU General Public License (GPL) version 2 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 */ 11 #include <linux/kernel.h> 12 #include <linux/types.h> 13 #include <linux/slab.h> 14 #include <linux/init.h> 15 #include <linux/module.h> 16 #include <linux/err.h> 17 #include <linux/of.h> 18 #include <linux/of_device.h> 19 #include <linux/platform_device.h> 20 #include <linux/gpio.h> 21 #include <linux/irq.h> 22 #include <linux/irqdomain.h> 23 #include <linux/interrupt.h> 24 #include <linux/bitops.h> 25 #include <linux/mfd/abx500.h> 26 #include <linux/mfd/abx500/ab8500.h> 27 #include <linux/pinctrl/pinctrl.h> 28 #include <linux/pinctrl/consumer.h> 29 #include <linux/pinctrl/pinmux.h> 30 #include <linux/pinctrl/pinconf.h> 31 #include <linux/pinctrl/pinconf-generic.h> 32 #include <linux/pinctrl/machine.h> 33 34 #include "pinctrl-abx500.h" 35 #include "../core.h" 36 #include "../pinconf.h" 37 #include "../pinctrl-utils.h" 38 39 /* 40 * The AB9540 and AB8540 GPIO support are extended versions 41 * of the AB8500 GPIO support. 42 * The AB9540 supports an additional (7th) register so that 43 * more GPIO may be configured and used. 44 * The AB8540 supports 4 new gpios (GPIOx_VBAT) that have 45 * internal pull-up and pull-down capabilities. 46 */ 47 48 /* 49 * GPIO registers offset 50 * Bank: 0x10 51 */ 52 #define AB8500_GPIO_SEL1_REG 0x00 53 #define AB8500_GPIO_SEL2_REG 0x01 54 #define AB8500_GPIO_SEL3_REG 0x02 55 #define AB8500_GPIO_SEL4_REG 0x03 56 #define AB8500_GPIO_SEL5_REG 0x04 57 #define AB8500_GPIO_SEL6_REG 0x05 58 #define AB9540_GPIO_SEL7_REG 0x06 59 60 #define AB8500_GPIO_DIR1_REG 0x10 61 #define AB8500_GPIO_DIR2_REG 0x11 62 #define AB8500_GPIO_DIR3_REG 0x12 63 #define AB8500_GPIO_DIR4_REG 0x13 64 #define AB8500_GPIO_DIR5_REG 0x14 65 #define AB8500_GPIO_DIR6_REG 0x15 66 #define AB9540_GPIO_DIR7_REG 0x16 67 68 #define AB8500_GPIO_OUT1_REG 0x20 69 #define AB8500_GPIO_OUT2_REG 0x21 70 #define AB8500_GPIO_OUT3_REG 0x22 71 #define AB8500_GPIO_OUT4_REG 0x23 72 #define AB8500_GPIO_OUT5_REG 0x24 73 #define AB8500_GPIO_OUT6_REG 0x25 74 #define AB9540_GPIO_OUT7_REG 0x26 75 76 #define AB8500_GPIO_PUD1_REG 0x30 77 #define AB8500_GPIO_PUD2_REG 0x31 78 #define AB8500_GPIO_PUD3_REG 0x32 79 #define AB8500_GPIO_PUD4_REG 0x33 80 #define AB8500_GPIO_PUD5_REG 0x34 81 #define AB8500_GPIO_PUD6_REG 0x35 82 #define AB9540_GPIO_PUD7_REG 0x36 83 84 #define AB8500_GPIO_IN1_REG 0x40 85 #define AB8500_GPIO_IN2_REG 0x41 86 #define AB8500_GPIO_IN3_REG 0x42 87 #define AB8500_GPIO_IN4_REG 0x43 88 #define AB8500_GPIO_IN5_REG 0x44 89 #define AB8500_GPIO_IN6_REG 0x45 90 #define AB9540_GPIO_IN7_REG 0x46 91 #define AB8540_GPIO_VINSEL_REG 0x47 92 #define AB8540_GPIO_PULL_UPDOWN_REG 0x48 93 #define AB8500_GPIO_ALTFUN_REG 0x50 94 #define AB8540_GPIO_PULL_UPDOWN_MASK 0x03 95 #define AB8540_GPIO_VINSEL_MASK 0x03 96 #define AB8540_GPIOX_VBAT_START 51 97 #define AB8540_GPIOX_VBAT_END 54 98 99 #define ABX500_GPIO_INPUT 0 100 #define ABX500_GPIO_OUTPUT 1 101 102 struct abx500_pinctrl { 103 struct device *dev; 104 struct pinctrl_dev *pctldev; 105 struct abx500_pinctrl_soc_data *soc; 106 struct gpio_chip chip; 107 struct ab8500 *parent; 108 struct abx500_gpio_irq_cluster *irq_cluster; 109 int irq_cluster_size; 110 }; 111 112 /** 113 * to_abx500_pinctrl() - get the pointer to abx500_pinctrl 114 * @chip: Member of the structure abx500_pinctrl 115 */ 116 static inline struct abx500_pinctrl *to_abx500_pinctrl(struct gpio_chip *chip) 117 { 118 return container_of(chip, struct abx500_pinctrl, chip); 119 } 120 121 static int abx500_gpio_get_bit(struct gpio_chip *chip, u8 reg, 122 unsigned offset, bool *bit) 123 { 124 struct abx500_pinctrl *pct = to_abx500_pinctrl(chip); 125 u8 pos = offset % 8; 126 u8 val; 127 int ret; 128 129 reg += offset / 8; 130 ret = abx500_get_register_interruptible(pct->dev, 131 AB8500_MISC, reg, &val); 132 133 *bit = !!(val & BIT(pos)); 134 135 if (ret < 0) 136 dev_err(pct->dev, 137 "%s read reg =%x, offset=%x failed (%d)\n", 138 __func__, reg, offset, ret); 139 140 return ret; 141 } 142 143 static int abx500_gpio_set_bits(struct gpio_chip *chip, u8 reg, 144 unsigned offset, int val) 145 { 146 struct abx500_pinctrl *pct = to_abx500_pinctrl(chip); 147 u8 pos = offset % 8; 148 int ret; 149 150 reg += offset / 8; 151 ret = abx500_mask_and_set_register_interruptible(pct->dev, 152 AB8500_MISC, reg, BIT(pos), val << pos); 153 if (ret < 0) 154 dev_err(pct->dev, "%s write reg, %x offset %x failed (%d)\n", 155 __func__, reg, offset, ret); 156 157 return ret; 158 } 159 160 /** 161 * abx500_gpio_get() - Get the particular GPIO value 162 * @chip: Gpio device 163 * @offset: GPIO number to read 164 */ 165 static int abx500_gpio_get(struct gpio_chip *chip, unsigned offset) 166 { 167 struct abx500_pinctrl *pct = to_abx500_pinctrl(chip); 168 bool bit; 169 bool is_out; 170 u8 gpio_offset = offset - 1; 171 int ret; 172 173 ret = abx500_gpio_get_bit(chip, AB8500_GPIO_DIR1_REG, 174 gpio_offset, &is_out); 175 if (ret < 0) 176 goto out; 177 178 if (is_out) 179 ret = abx500_gpio_get_bit(chip, AB8500_GPIO_OUT1_REG, 180 gpio_offset, &bit); 181 else 182 ret = abx500_gpio_get_bit(chip, AB8500_GPIO_IN1_REG, 183 gpio_offset, &bit); 184 out: 185 if (ret < 0) { 186 dev_err(pct->dev, "%s failed (%d)\n", __func__, ret); 187 return ret; 188 } 189 190 return bit; 191 } 192 193 static void abx500_gpio_set(struct gpio_chip *chip, unsigned offset, int val) 194 { 195 struct abx500_pinctrl *pct = to_abx500_pinctrl(chip); 196 int ret; 197 198 ret = abx500_gpio_set_bits(chip, AB8500_GPIO_OUT1_REG, offset, val); 199 if (ret < 0) 200 dev_err(pct->dev, "%s write failed (%d)\n", __func__, ret); 201 } 202 203 static int abx500_get_pull_updown(struct abx500_pinctrl *pct, int offset, 204 enum abx500_gpio_pull_updown *pull_updown) 205 { 206 u8 pos; 207 u8 val; 208 int ret; 209 struct pullud *pullud; 210 211 if (!pct->soc->pullud) { 212 dev_err(pct->dev, "%s AB chip doesn't support pull up/down feature", 213 __func__); 214 ret = -EPERM; 215 goto out; 216 } 217 218 pullud = pct->soc->pullud; 219 220 if ((offset < pullud->first_pin) 221 || (offset > pullud->last_pin)) { 222 ret = -EINVAL; 223 goto out; 224 } 225 226 ret = abx500_get_register_interruptible(pct->dev, 227 AB8500_MISC, AB8540_GPIO_PULL_UPDOWN_REG, &val); 228 229 pos = (offset - pullud->first_pin) << 1; 230 *pull_updown = (val >> pos) & AB8540_GPIO_PULL_UPDOWN_MASK; 231 232 out: 233 if (ret < 0) 234 dev_err(pct->dev, "%s failed (%d)\n", __func__, ret); 235 236 return ret; 237 } 238 239 static int abx500_set_pull_updown(struct abx500_pinctrl *pct, 240 int offset, enum abx500_gpio_pull_updown val) 241 { 242 u8 pos; 243 int ret; 244 struct pullud *pullud; 245 246 if (!pct->soc->pullud) { 247 dev_err(pct->dev, "%s AB chip doesn't support pull up/down feature", 248 __func__); 249 ret = -EPERM; 250 goto out; 251 } 252 253 pullud = pct->soc->pullud; 254 255 if ((offset < pullud->first_pin) 256 || (offset > pullud->last_pin)) { 257 ret = -EINVAL; 258 goto out; 259 } 260 pos = (offset - pullud->first_pin) << 1; 261 262 ret = abx500_mask_and_set_register_interruptible(pct->dev, 263 AB8500_MISC, AB8540_GPIO_PULL_UPDOWN_REG, 264 AB8540_GPIO_PULL_UPDOWN_MASK << pos, val << pos); 265 266 out: 267 if (ret < 0) 268 dev_err(pct->dev, "%s failed (%d)\n", __func__, ret); 269 270 return ret; 271 } 272 273 static bool abx500_pullud_supported(struct gpio_chip *chip, unsigned gpio) 274 { 275 struct abx500_pinctrl *pct = to_abx500_pinctrl(chip); 276 struct pullud *pullud = pct->soc->pullud; 277 278 return (pullud && 279 gpio >= pullud->first_pin && 280 gpio <= pullud->last_pin); 281 } 282 283 static int abx500_gpio_direction_output(struct gpio_chip *chip, 284 unsigned offset, 285 int val) 286 { 287 struct abx500_pinctrl *pct = to_abx500_pinctrl(chip); 288 unsigned gpio; 289 int ret; 290 291 /* set direction as output */ 292 ret = abx500_gpio_set_bits(chip, 293 AB8500_GPIO_DIR1_REG, 294 offset, 295 ABX500_GPIO_OUTPUT); 296 if (ret < 0) 297 goto out; 298 299 /* disable pull down */ 300 ret = abx500_gpio_set_bits(chip, 301 AB8500_GPIO_PUD1_REG, 302 offset, 303 ABX500_GPIO_PULL_NONE); 304 if (ret < 0) 305 goto out; 306 307 /* if supported, disable both pull down and pull up */ 308 gpio = offset + 1; 309 if (abx500_pullud_supported(chip, gpio)) { 310 ret = abx500_set_pull_updown(pct, 311 gpio, 312 ABX500_GPIO_PULL_NONE); 313 } 314 out: 315 if (ret < 0) { 316 dev_err(pct->dev, "%s failed (%d)\n", __func__, ret); 317 return ret; 318 } 319 320 /* set the output as 1 or 0 */ 321 return abx500_gpio_set_bits(chip, AB8500_GPIO_OUT1_REG, offset, val); 322 } 323 324 static int abx500_gpio_direction_input(struct gpio_chip *chip, unsigned offset) 325 { 326 /* set the register as input */ 327 return abx500_gpio_set_bits(chip, 328 AB8500_GPIO_DIR1_REG, 329 offset, 330 ABX500_GPIO_INPUT); 331 } 332 333 static int abx500_gpio_to_irq(struct gpio_chip *chip, unsigned offset) 334 { 335 struct abx500_pinctrl *pct = to_abx500_pinctrl(chip); 336 /* The AB8500 GPIO numbers are off by one */ 337 int gpio = offset + 1; 338 int hwirq; 339 int i; 340 341 for (i = 0; i < pct->irq_cluster_size; i++) { 342 struct abx500_gpio_irq_cluster *cluster = 343 &pct->irq_cluster[i]; 344 345 if (gpio >= cluster->start && gpio <= cluster->end) { 346 /* 347 * The ABx500 GPIO's associated IRQs are clustered together 348 * throughout the interrupt numbers at irregular intervals. 349 * To solve this quandry, we have placed the read-in values 350 * into the cluster information table. 351 */ 352 hwirq = gpio - cluster->start + cluster->to_irq; 353 return irq_create_mapping(pct->parent->domain, hwirq); 354 } 355 } 356 357 return -EINVAL; 358 } 359 360 static int abx500_set_mode(struct pinctrl_dev *pctldev, struct gpio_chip *chip, 361 unsigned gpio, int alt_setting) 362 { 363 struct abx500_pinctrl *pct = pinctrl_dev_get_drvdata(pctldev); 364 struct alternate_functions af = pct->soc->alternate_functions[gpio]; 365 int ret; 366 int val; 367 unsigned offset; 368 369 const char *modes[] = { 370 [ABX500_DEFAULT] = "default", 371 [ABX500_ALT_A] = "altA", 372 [ABX500_ALT_B] = "altB", 373 [ABX500_ALT_C] = "altC", 374 }; 375 376 /* sanity check */ 377 if (((alt_setting == ABX500_ALT_A) && (af.gpiosel_bit == UNUSED)) || 378 ((alt_setting == ABX500_ALT_B) && (af.alt_bit1 == UNUSED)) || 379 ((alt_setting == ABX500_ALT_C) && (af.alt_bit2 == UNUSED))) { 380 dev_dbg(pct->dev, "pin %d doesn't support %s mode\n", gpio, 381 modes[alt_setting]); 382 return -EINVAL; 383 } 384 385 /* on ABx5xx, there is no GPIO0, so adjust the offset */ 386 offset = gpio - 1; 387 388 switch (alt_setting) { 389 case ABX500_DEFAULT: 390 /* 391 * for ABx5xx family, default mode is always selected by 392 * writing 0 to GPIOSELx register, except for pins which 393 * support at least ALT_B mode, default mode is selected 394 * by writing 1 to GPIOSELx register 395 */ 396 val = 0; 397 if (af.alt_bit1 != UNUSED) 398 val++; 399 400 ret = abx500_gpio_set_bits(chip, AB8500_GPIO_SEL1_REG, 401 offset, val); 402 break; 403 404 case ABX500_ALT_A: 405 /* 406 * for ABx5xx family, alt_a mode is always selected by 407 * writing 1 to GPIOSELx register, except for pins which 408 * support at least ALT_B mode, alt_a mode is selected 409 * by writing 0 to GPIOSELx register and 0 in ALTFUNC 410 * register 411 */ 412 if (af.alt_bit1 != UNUSED) { 413 ret = abx500_gpio_set_bits(chip, AB8500_GPIO_SEL1_REG, 414 offset, 0); 415 if (ret < 0) 416 goto out; 417 418 ret = abx500_gpio_set_bits(chip, 419 AB8500_GPIO_ALTFUN_REG, 420 af.alt_bit1, 421 !!(af.alta_val & BIT(0))); 422 if (ret < 0) 423 goto out; 424 425 if (af.alt_bit2 != UNUSED) 426 ret = abx500_gpio_set_bits(chip, 427 AB8500_GPIO_ALTFUN_REG, 428 af.alt_bit2, 429 !!(af.alta_val & BIT(1))); 430 } else 431 ret = abx500_gpio_set_bits(chip, AB8500_GPIO_SEL1_REG, 432 offset, 1); 433 break; 434 435 case ABX500_ALT_B: 436 ret = abx500_gpio_set_bits(chip, AB8500_GPIO_SEL1_REG, 437 offset, 0); 438 if (ret < 0) 439 goto out; 440 441 ret = abx500_gpio_set_bits(chip, AB8500_GPIO_ALTFUN_REG, 442 af.alt_bit1, !!(af.altb_val & BIT(0))); 443 if (ret < 0) 444 goto out; 445 446 if (af.alt_bit2 != UNUSED) 447 ret = abx500_gpio_set_bits(chip, 448 AB8500_GPIO_ALTFUN_REG, 449 af.alt_bit2, 450 !!(af.altb_val & BIT(1))); 451 break; 452 453 case ABX500_ALT_C: 454 ret = abx500_gpio_set_bits(chip, AB8500_GPIO_SEL1_REG, 455 offset, 0); 456 if (ret < 0) 457 goto out; 458 459 ret = abx500_gpio_set_bits(chip, AB8500_GPIO_ALTFUN_REG, 460 af.alt_bit2, !!(af.altc_val & BIT(0))); 461 if (ret < 0) 462 goto out; 463 464 ret = abx500_gpio_set_bits(chip, AB8500_GPIO_ALTFUN_REG, 465 af.alt_bit2, !!(af.altc_val & BIT(1))); 466 break; 467 468 default: 469 dev_dbg(pct->dev, "unknown alt_setting %d\n", alt_setting); 470 471 return -EINVAL; 472 } 473 out: 474 if (ret < 0) 475 dev_err(pct->dev, "%s failed (%d)\n", __func__, ret); 476 477 return ret; 478 } 479 480 static int abx500_get_mode(struct pinctrl_dev *pctldev, struct gpio_chip *chip, 481 unsigned gpio) 482 { 483 u8 mode; 484 bool bit_mode; 485 bool alt_bit1; 486 bool alt_bit2; 487 struct abx500_pinctrl *pct = pinctrl_dev_get_drvdata(pctldev); 488 struct alternate_functions af = pct->soc->alternate_functions[gpio]; 489 /* on ABx5xx, there is no GPIO0, so adjust the offset */ 490 unsigned offset = gpio - 1; 491 int ret; 492 493 /* 494 * if gpiosel_bit is set to unused, 495 * it means no GPIO or special case 496 */ 497 if (af.gpiosel_bit == UNUSED) 498 return ABX500_DEFAULT; 499 500 /* read GpioSelx register */ 501 ret = abx500_gpio_get_bit(chip, AB8500_GPIO_SEL1_REG + (offset / 8), 502 af.gpiosel_bit, &bit_mode); 503 if (ret < 0) 504 goto out; 505 506 mode = bit_mode; 507 508 /* sanity check */ 509 if ((af.alt_bit1 < UNUSED) || (af.alt_bit1 > 7) || 510 (af.alt_bit2 < UNUSED) || (af.alt_bit2 > 7)) { 511 dev_err(pct->dev, 512 "alt_bitX value not in correct range (-1 to 7)\n"); 513 return -EINVAL; 514 } 515 516 /* if alt_bit2 is used, alt_bit1 must be used too */ 517 if ((af.alt_bit2 != UNUSED) && (af.alt_bit1 == UNUSED)) { 518 dev_err(pct->dev, 519 "if alt_bit2 is used, alt_bit1 can't be unused\n"); 520 return -EINVAL; 521 } 522 523 /* check if pin use AlternateFunction register */ 524 if ((af.alt_bit1 == UNUSED) && (af.alt_bit2 == UNUSED)) 525 return mode; 526 /* 527 * if pin GPIOSEL bit is set and pin supports alternate function, 528 * it means DEFAULT mode 529 */ 530 if (mode) 531 return ABX500_DEFAULT; 532 533 /* 534 * pin use the AlternatFunction register 535 * read alt_bit1 value 536 */ 537 ret = abx500_gpio_get_bit(chip, AB8500_GPIO_ALTFUN_REG, 538 af.alt_bit1, &alt_bit1); 539 if (ret < 0) 540 goto out; 541 542 if (af.alt_bit2 != UNUSED) { 543 /* read alt_bit2 value */ 544 ret = abx500_gpio_get_bit(chip, AB8500_GPIO_ALTFUN_REG, 545 af.alt_bit2, 546 &alt_bit2); 547 if (ret < 0) 548 goto out; 549 } else 550 alt_bit2 = 0; 551 552 mode = (alt_bit2 << 1) + alt_bit1; 553 if (mode == af.alta_val) 554 return ABX500_ALT_A; 555 else if (mode == af.altb_val) 556 return ABX500_ALT_B; 557 else 558 return ABX500_ALT_C; 559 560 out: 561 dev_err(pct->dev, "%s failed (%d)\n", __func__, ret); 562 return ret; 563 } 564 565 #ifdef CONFIG_DEBUG_FS 566 567 #include <linux/seq_file.h> 568 569 static void abx500_gpio_dbg_show_one(struct seq_file *s, 570 struct pinctrl_dev *pctldev, 571 struct gpio_chip *chip, 572 unsigned offset, unsigned gpio) 573 { 574 struct abx500_pinctrl *pct = pinctrl_dev_get_drvdata(pctldev); 575 const char *label = gpiochip_is_requested(chip, offset - 1); 576 u8 gpio_offset = offset - 1; 577 int mode = -1; 578 bool is_out; 579 bool pd; 580 enum abx500_gpio_pull_updown pud = 0; 581 int ret; 582 583 const char *modes[] = { 584 [ABX500_DEFAULT] = "default", 585 [ABX500_ALT_A] = "altA", 586 [ABX500_ALT_B] = "altB", 587 [ABX500_ALT_C] = "altC", 588 }; 589 590 const char *pull_up_down[] = { 591 [ABX500_GPIO_PULL_DOWN] = "pull down", 592 [ABX500_GPIO_PULL_NONE] = "pull none", 593 [ABX500_GPIO_PULL_NONE + 1] = "pull none", 594 [ABX500_GPIO_PULL_UP] = "pull up", 595 }; 596 597 ret = abx500_gpio_get_bit(chip, AB8500_GPIO_DIR1_REG, 598 gpio_offset, &is_out); 599 if (ret < 0) 600 goto out; 601 602 seq_printf(s, " gpio-%-3d (%-20.20s) %-3s", 603 gpio, label ?: "(none)", 604 is_out ? "out" : "in "); 605 606 if (!is_out) { 607 if (abx500_pullud_supported(chip, offset)) { 608 ret = abx500_get_pull_updown(pct, offset, &pud); 609 if (ret < 0) 610 goto out; 611 612 seq_printf(s, " %-9s", pull_up_down[pud]); 613 } else { 614 ret = abx500_gpio_get_bit(chip, AB8500_GPIO_PUD1_REG, 615 gpio_offset, &pd); 616 if (ret < 0) 617 goto out; 618 619 seq_printf(s, " %-9s", pull_up_down[pd]); 620 } 621 } else 622 seq_printf(s, " %-9s", chip->get(chip, offset) ? "hi" : "lo"); 623 624 mode = abx500_get_mode(pctldev, chip, offset); 625 626 seq_printf(s, " %s", (mode < 0) ? "unknown" : modes[mode]); 627 628 out: 629 if (ret < 0) 630 dev_err(pct->dev, "%s failed (%d)\n", __func__, ret); 631 } 632 633 static void abx500_gpio_dbg_show(struct seq_file *s, struct gpio_chip *chip) 634 { 635 unsigned i; 636 unsigned gpio = chip->base; 637 struct abx500_pinctrl *pct = to_abx500_pinctrl(chip); 638 struct pinctrl_dev *pctldev = pct->pctldev; 639 640 for (i = 0; i < chip->ngpio; i++, gpio++) { 641 /* On AB8500, there is no GPIO0, the first is the GPIO 1 */ 642 abx500_gpio_dbg_show_one(s, pctldev, chip, i + 1, gpio); 643 seq_printf(s, "\n"); 644 } 645 } 646 647 #else 648 static inline void abx500_gpio_dbg_show_one(struct seq_file *s, 649 struct pinctrl_dev *pctldev, 650 struct gpio_chip *chip, 651 unsigned offset, unsigned gpio) 652 { 653 } 654 #define abx500_gpio_dbg_show NULL 655 #endif 656 657 static int abx500_gpio_request(struct gpio_chip *chip, unsigned offset) 658 { 659 int gpio = chip->base + offset; 660 661 return pinctrl_request_gpio(gpio); 662 } 663 664 static void abx500_gpio_free(struct gpio_chip *chip, unsigned offset) 665 { 666 int gpio = chip->base + offset; 667 668 pinctrl_free_gpio(gpio); 669 } 670 671 static struct gpio_chip abx500gpio_chip = { 672 .label = "abx500-gpio", 673 .owner = THIS_MODULE, 674 .request = abx500_gpio_request, 675 .free = abx500_gpio_free, 676 .direction_input = abx500_gpio_direction_input, 677 .get = abx500_gpio_get, 678 .direction_output = abx500_gpio_direction_output, 679 .set = abx500_gpio_set, 680 .to_irq = abx500_gpio_to_irq, 681 .dbg_show = abx500_gpio_dbg_show, 682 }; 683 684 static int abx500_pmx_get_funcs_cnt(struct pinctrl_dev *pctldev) 685 { 686 struct abx500_pinctrl *pct = pinctrl_dev_get_drvdata(pctldev); 687 688 return pct->soc->nfunctions; 689 } 690 691 static const char *abx500_pmx_get_func_name(struct pinctrl_dev *pctldev, 692 unsigned function) 693 { 694 struct abx500_pinctrl *pct = pinctrl_dev_get_drvdata(pctldev); 695 696 return pct->soc->functions[function].name; 697 } 698 699 static int abx500_pmx_get_func_groups(struct pinctrl_dev *pctldev, 700 unsigned function, 701 const char * const **groups, 702 unsigned * const num_groups) 703 { 704 struct abx500_pinctrl *pct = pinctrl_dev_get_drvdata(pctldev); 705 706 *groups = pct->soc->functions[function].groups; 707 *num_groups = pct->soc->functions[function].ngroups; 708 709 return 0; 710 } 711 712 static int abx500_pmx_set(struct pinctrl_dev *pctldev, unsigned function, 713 unsigned group) 714 { 715 struct abx500_pinctrl *pct = pinctrl_dev_get_drvdata(pctldev); 716 struct gpio_chip *chip = &pct->chip; 717 const struct abx500_pingroup *g; 718 int i; 719 int ret = 0; 720 721 g = &pct->soc->groups[group]; 722 if (g->altsetting < 0) 723 return -EINVAL; 724 725 dev_dbg(pct->dev, "enable group %s, %u pins\n", g->name, g->npins); 726 727 for (i = 0; i < g->npins; i++) { 728 dev_dbg(pct->dev, "setting pin %d to altsetting %d\n", 729 g->pins[i], g->altsetting); 730 731 ret = abx500_set_mode(pctldev, chip, g->pins[i], g->altsetting); 732 } 733 734 if (ret < 0) 735 dev_err(pct->dev, "%s failed (%d)\n", __func__, ret); 736 737 return ret; 738 } 739 740 static int abx500_gpio_request_enable(struct pinctrl_dev *pctldev, 741 struct pinctrl_gpio_range *range, 742 unsigned offset) 743 { 744 struct abx500_pinctrl *pct = pinctrl_dev_get_drvdata(pctldev); 745 const struct abx500_pinrange *p; 746 int ret; 747 int i; 748 749 /* 750 * Different ranges have different ways to enable GPIO function on a 751 * pin, so refer back to our local range type, where we handily define 752 * what altfunc enables GPIO for a certain pin. 753 */ 754 for (i = 0; i < pct->soc->gpio_num_ranges; i++) { 755 p = &pct->soc->gpio_ranges[i]; 756 if ((offset >= p->offset) && 757 (offset < (p->offset + p->npins))) 758 break; 759 } 760 761 if (i == pct->soc->gpio_num_ranges) { 762 dev_err(pct->dev, "%s failed to locate range\n", __func__); 763 return -ENODEV; 764 } 765 766 dev_dbg(pct->dev, "enable GPIO by altfunc %d at gpio %d\n", 767 p->altfunc, offset); 768 769 ret = abx500_set_mode(pct->pctldev, &pct->chip, 770 offset, p->altfunc); 771 if (ret < 0) 772 dev_err(pct->dev, "%s setting altfunc failed\n", __func__); 773 774 return ret; 775 } 776 777 static void abx500_gpio_disable_free(struct pinctrl_dev *pctldev, 778 struct pinctrl_gpio_range *range, 779 unsigned offset) 780 { 781 } 782 783 static const struct pinmux_ops abx500_pinmux_ops = { 784 .get_functions_count = abx500_pmx_get_funcs_cnt, 785 .get_function_name = abx500_pmx_get_func_name, 786 .get_function_groups = abx500_pmx_get_func_groups, 787 .set_mux = abx500_pmx_set, 788 .gpio_request_enable = abx500_gpio_request_enable, 789 .gpio_disable_free = abx500_gpio_disable_free, 790 .strict = true, 791 }; 792 793 static int abx500_get_groups_cnt(struct pinctrl_dev *pctldev) 794 { 795 struct abx500_pinctrl *pct = pinctrl_dev_get_drvdata(pctldev); 796 797 return pct->soc->ngroups; 798 } 799 800 static const char *abx500_get_group_name(struct pinctrl_dev *pctldev, 801 unsigned selector) 802 { 803 struct abx500_pinctrl *pct = pinctrl_dev_get_drvdata(pctldev); 804 805 return pct->soc->groups[selector].name; 806 } 807 808 static int abx500_get_group_pins(struct pinctrl_dev *pctldev, 809 unsigned selector, 810 const unsigned **pins, 811 unsigned *num_pins) 812 { 813 struct abx500_pinctrl *pct = pinctrl_dev_get_drvdata(pctldev); 814 815 *pins = pct->soc->groups[selector].pins; 816 *num_pins = pct->soc->groups[selector].npins; 817 818 return 0; 819 } 820 821 static void abx500_pin_dbg_show(struct pinctrl_dev *pctldev, 822 struct seq_file *s, unsigned offset) 823 { 824 struct abx500_pinctrl *pct = pinctrl_dev_get_drvdata(pctldev); 825 struct gpio_chip *chip = &pct->chip; 826 827 abx500_gpio_dbg_show_one(s, pctldev, chip, offset, 828 chip->base + offset - 1); 829 } 830 831 static int abx500_dt_add_map_mux(struct pinctrl_map **map, 832 unsigned *reserved_maps, 833 unsigned *num_maps, const char *group, 834 const char *function) 835 { 836 if (*num_maps == *reserved_maps) 837 return -ENOSPC; 838 839 (*map)[*num_maps].type = PIN_MAP_TYPE_MUX_GROUP; 840 (*map)[*num_maps].data.mux.group = group; 841 (*map)[*num_maps].data.mux.function = function; 842 (*num_maps)++; 843 844 return 0; 845 } 846 847 static int abx500_dt_add_map_configs(struct pinctrl_map **map, 848 unsigned *reserved_maps, 849 unsigned *num_maps, const char *group, 850 unsigned long *configs, unsigned num_configs) 851 { 852 unsigned long *dup_configs; 853 854 if (*num_maps == *reserved_maps) 855 return -ENOSPC; 856 857 dup_configs = kmemdup(configs, num_configs * sizeof(*dup_configs), 858 GFP_KERNEL); 859 if (!dup_configs) 860 return -ENOMEM; 861 862 (*map)[*num_maps].type = PIN_MAP_TYPE_CONFIGS_PIN; 863 864 (*map)[*num_maps].data.configs.group_or_pin = group; 865 (*map)[*num_maps].data.configs.configs = dup_configs; 866 (*map)[*num_maps].data.configs.num_configs = num_configs; 867 (*num_maps)++; 868 869 return 0; 870 } 871 872 static const char *abx500_find_pin_name(struct pinctrl_dev *pctldev, 873 const char *pin_name) 874 { 875 int i, pin_number; 876 struct abx500_pinctrl *npct = pinctrl_dev_get_drvdata(pctldev); 877 878 if (sscanf((char *)pin_name, "GPIO%d", &pin_number) == 1) 879 for (i = 0; i < npct->soc->npins; i++) 880 if (npct->soc->pins[i].number == pin_number) 881 return npct->soc->pins[i].name; 882 return NULL; 883 } 884 885 static int abx500_dt_subnode_to_map(struct pinctrl_dev *pctldev, 886 struct device_node *np, 887 struct pinctrl_map **map, 888 unsigned *reserved_maps, 889 unsigned *num_maps) 890 { 891 int ret; 892 const char *function = NULL; 893 unsigned long *configs; 894 unsigned int nconfigs = 0; 895 struct property *prop; 896 897 ret = of_property_read_string(np, "function", &function); 898 if (ret >= 0) { 899 const char *group; 900 901 ret = of_property_count_strings(np, "groups"); 902 if (ret < 0) 903 goto exit; 904 905 ret = pinctrl_utils_reserve_map(pctldev, map, reserved_maps, 906 num_maps, ret); 907 if (ret < 0) 908 goto exit; 909 910 of_property_for_each_string(np, "groups", prop, group) { 911 ret = abx500_dt_add_map_mux(map, reserved_maps, 912 num_maps, group, function); 913 if (ret < 0) 914 goto exit; 915 } 916 } 917 918 ret = pinconf_generic_parse_dt_config(np, pctldev, &configs, &nconfigs); 919 if (nconfigs) { 920 const char *gpio_name; 921 const char *pin; 922 923 ret = of_property_count_strings(np, "pins"); 924 if (ret < 0) 925 goto exit; 926 927 ret = pinctrl_utils_reserve_map(pctldev, map, 928 reserved_maps, 929 num_maps, ret); 930 if (ret < 0) 931 goto exit; 932 933 of_property_for_each_string(np, "pins", prop, pin) { 934 gpio_name = abx500_find_pin_name(pctldev, pin); 935 936 ret = abx500_dt_add_map_configs(map, reserved_maps, 937 num_maps, gpio_name, configs, 1); 938 if (ret < 0) 939 goto exit; 940 } 941 } 942 943 exit: 944 return ret; 945 } 946 947 static int abx500_dt_node_to_map(struct pinctrl_dev *pctldev, 948 struct device_node *np_config, 949 struct pinctrl_map **map, unsigned *num_maps) 950 { 951 unsigned reserved_maps; 952 struct device_node *np; 953 int ret; 954 955 reserved_maps = 0; 956 *map = NULL; 957 *num_maps = 0; 958 959 for_each_child_of_node(np_config, np) { 960 ret = abx500_dt_subnode_to_map(pctldev, np, map, 961 &reserved_maps, num_maps); 962 if (ret < 0) { 963 pinctrl_utils_dt_free_map(pctldev, *map, *num_maps); 964 return ret; 965 } 966 } 967 968 return 0; 969 } 970 971 static const struct pinctrl_ops abx500_pinctrl_ops = { 972 .get_groups_count = abx500_get_groups_cnt, 973 .get_group_name = abx500_get_group_name, 974 .get_group_pins = abx500_get_group_pins, 975 .pin_dbg_show = abx500_pin_dbg_show, 976 .dt_node_to_map = abx500_dt_node_to_map, 977 .dt_free_map = pinctrl_utils_dt_free_map, 978 }; 979 980 static int abx500_pin_config_get(struct pinctrl_dev *pctldev, 981 unsigned pin, 982 unsigned long *config) 983 { 984 return -ENOSYS; 985 } 986 987 static int abx500_pin_config_set(struct pinctrl_dev *pctldev, 988 unsigned pin, 989 unsigned long *configs, 990 unsigned num_configs) 991 { 992 struct abx500_pinctrl *pct = pinctrl_dev_get_drvdata(pctldev); 993 struct gpio_chip *chip = &pct->chip; 994 unsigned offset; 995 int ret = -EINVAL; 996 int i; 997 enum pin_config_param param; 998 enum pin_config_param argument; 999 1000 for (i = 0; i < num_configs; i++) { 1001 param = pinconf_to_config_param(configs[i]); 1002 argument = pinconf_to_config_argument(configs[i]); 1003 1004 dev_dbg(chip->dev, "pin %d [%#lx]: %s %s\n", 1005 pin, configs[i], 1006 (param == PIN_CONFIG_OUTPUT) ? "output " : "input", 1007 (param == PIN_CONFIG_OUTPUT) ? 1008 (argument ? "high" : "low") : 1009 (argument ? "pull up" : "pull down")); 1010 1011 /* on ABx500, there is no GPIO0, so adjust the offset */ 1012 offset = pin - 1; 1013 1014 switch (param) { 1015 case PIN_CONFIG_BIAS_DISABLE: 1016 ret = abx500_gpio_direction_input(chip, offset); 1017 if (ret < 0) 1018 goto out; 1019 /* 1020 * Some chips only support pull down, while some 1021 * actually support both pull up and pull down. Such 1022 * chips have a "pullud" range specified for the pins 1023 * that support both features. If the pin is not 1024 * within that range, we fall back to the old bit set 1025 * that only support pull down. 1026 */ 1027 if (abx500_pullud_supported(chip, pin)) 1028 ret = abx500_set_pull_updown(pct, 1029 pin, 1030 ABX500_GPIO_PULL_NONE); 1031 else 1032 /* Chip only supports pull down */ 1033 ret = abx500_gpio_set_bits(chip, 1034 AB8500_GPIO_PUD1_REG, offset, 1035 ABX500_GPIO_PULL_NONE); 1036 break; 1037 1038 case PIN_CONFIG_BIAS_PULL_DOWN: 1039 ret = abx500_gpio_direction_input(chip, offset); 1040 if (ret < 0) 1041 goto out; 1042 /* 1043 * if argument = 1 set the pull down 1044 * else clear the pull down 1045 * Some chips only support pull down, while some 1046 * actually support both pull up and pull down. Such 1047 * chips have a "pullud" range specified for the pins 1048 * that support both features. If the pin is not 1049 * within that range, we fall back to the old bit set 1050 * that only support pull down. 1051 */ 1052 if (abx500_pullud_supported(chip, pin)) 1053 ret = abx500_set_pull_updown(pct, 1054 pin, 1055 argument ? ABX500_GPIO_PULL_DOWN : 1056 ABX500_GPIO_PULL_NONE); 1057 else 1058 /* Chip only supports pull down */ 1059 ret = abx500_gpio_set_bits(chip, 1060 AB8500_GPIO_PUD1_REG, 1061 offset, 1062 argument ? ABX500_GPIO_PULL_DOWN : 1063 ABX500_GPIO_PULL_NONE); 1064 break; 1065 1066 case PIN_CONFIG_BIAS_PULL_UP: 1067 ret = abx500_gpio_direction_input(chip, offset); 1068 if (ret < 0) 1069 goto out; 1070 /* 1071 * if argument = 1 set the pull up 1072 * else clear the pull up 1073 */ 1074 ret = abx500_gpio_direction_input(chip, offset); 1075 /* 1076 * Some chips only support pull down, while some 1077 * actually support both pull up and pull down. Such 1078 * chips have a "pullud" range specified for the pins 1079 * that support both features. If the pin is not 1080 * within that range, do nothing 1081 */ 1082 if (abx500_pullud_supported(chip, pin)) 1083 ret = abx500_set_pull_updown(pct, 1084 pin, 1085 argument ? ABX500_GPIO_PULL_UP : 1086 ABX500_GPIO_PULL_NONE); 1087 break; 1088 1089 case PIN_CONFIG_OUTPUT: 1090 ret = abx500_gpio_direction_output(chip, offset, 1091 argument); 1092 break; 1093 1094 default: 1095 dev_err(chip->dev, "illegal configuration requested\n"); 1096 } 1097 } /* for each config */ 1098 out: 1099 if (ret < 0) 1100 dev_err(pct->dev, "%s failed (%d)\n", __func__, ret); 1101 1102 return ret; 1103 } 1104 1105 static const struct pinconf_ops abx500_pinconf_ops = { 1106 .pin_config_get = abx500_pin_config_get, 1107 .pin_config_set = abx500_pin_config_set, 1108 .is_generic = true, 1109 }; 1110 1111 static struct pinctrl_desc abx500_pinctrl_desc = { 1112 .name = "pinctrl-abx500", 1113 .pctlops = &abx500_pinctrl_ops, 1114 .pmxops = &abx500_pinmux_ops, 1115 .confops = &abx500_pinconf_ops, 1116 .owner = THIS_MODULE, 1117 }; 1118 1119 static int abx500_get_gpio_num(struct abx500_pinctrl_soc_data *soc) 1120 { 1121 unsigned int lowest = 0; 1122 unsigned int highest = 0; 1123 unsigned int npins = 0; 1124 int i; 1125 1126 /* 1127 * Compute number of GPIOs from the last SoC gpio range descriptors 1128 * These ranges may include "holes" but the GPIO number space shall 1129 * still be homogeneous, so we need to detect and account for any 1130 * such holes so that these are included in the number of GPIO pins. 1131 */ 1132 for (i = 0; i < soc->gpio_num_ranges; i++) { 1133 unsigned gstart; 1134 unsigned gend; 1135 const struct abx500_pinrange *p; 1136 1137 p = &soc->gpio_ranges[i]; 1138 gstart = p->offset; 1139 gend = p->offset + p->npins - 1; 1140 1141 if (i == 0) { 1142 /* First iteration, set start values */ 1143 lowest = gstart; 1144 highest = gend; 1145 } else { 1146 if (gstart < lowest) 1147 lowest = gstart; 1148 if (gend > highest) 1149 highest = gend; 1150 } 1151 } 1152 /* this gives the absolute number of pins */ 1153 npins = highest - lowest + 1; 1154 return npins; 1155 } 1156 1157 static const struct of_device_id abx500_gpio_match[] = { 1158 { .compatible = "stericsson,ab8500-gpio", .data = (void *)PINCTRL_AB8500, }, 1159 { .compatible = "stericsson,ab8505-gpio", .data = (void *)PINCTRL_AB8505, }, 1160 { .compatible = "stericsson,ab8540-gpio", .data = (void *)PINCTRL_AB8540, }, 1161 { .compatible = "stericsson,ab9540-gpio", .data = (void *)PINCTRL_AB9540, }, 1162 { } 1163 }; 1164 1165 static int abx500_gpio_probe(struct platform_device *pdev) 1166 { 1167 struct device_node *np = pdev->dev.of_node; 1168 const struct of_device_id *match; 1169 struct abx500_pinctrl *pct; 1170 unsigned int id = -1; 1171 int ret; 1172 int i; 1173 1174 if (!np) { 1175 dev_err(&pdev->dev, "gpio dt node missing\n"); 1176 return -ENODEV; 1177 } 1178 1179 pct = devm_kzalloc(&pdev->dev, sizeof(struct abx500_pinctrl), 1180 GFP_KERNEL); 1181 if (pct == NULL) { 1182 dev_err(&pdev->dev, 1183 "failed to allocate memory for pct\n"); 1184 return -ENOMEM; 1185 } 1186 1187 pct->dev = &pdev->dev; 1188 pct->parent = dev_get_drvdata(pdev->dev.parent); 1189 pct->chip = abx500gpio_chip; 1190 pct->chip.dev = &pdev->dev; 1191 pct->chip.base = -1; /* Dynamic allocation */ 1192 1193 match = of_match_device(abx500_gpio_match, &pdev->dev); 1194 if (!match) { 1195 dev_err(&pdev->dev, "gpio dt not matching\n"); 1196 return -ENODEV; 1197 } 1198 id = (unsigned long)match->data; 1199 1200 /* Poke in other ASIC variants here */ 1201 switch (id) { 1202 case PINCTRL_AB8500: 1203 abx500_pinctrl_ab8500_init(&pct->soc); 1204 break; 1205 case PINCTRL_AB8540: 1206 abx500_pinctrl_ab8540_init(&pct->soc); 1207 break; 1208 case PINCTRL_AB9540: 1209 abx500_pinctrl_ab9540_init(&pct->soc); 1210 break; 1211 case PINCTRL_AB8505: 1212 abx500_pinctrl_ab8505_init(&pct->soc); 1213 break; 1214 default: 1215 dev_err(&pdev->dev, "Unsupported pinctrl sub driver (%d)\n", id); 1216 return -EINVAL; 1217 } 1218 1219 if (!pct->soc) { 1220 dev_err(&pdev->dev, "Invalid SOC data\n"); 1221 return -EINVAL; 1222 } 1223 1224 pct->chip.ngpio = abx500_get_gpio_num(pct->soc); 1225 pct->irq_cluster = pct->soc->gpio_irq_cluster; 1226 pct->irq_cluster_size = pct->soc->ngpio_irq_cluster; 1227 1228 ret = gpiochip_add(&pct->chip); 1229 if (ret) { 1230 dev_err(&pdev->dev, "unable to add gpiochip: %d\n", ret); 1231 return ret; 1232 } 1233 dev_info(&pdev->dev, "added gpiochip\n"); 1234 1235 abx500_pinctrl_desc.pins = pct->soc->pins; 1236 abx500_pinctrl_desc.npins = pct->soc->npins; 1237 pct->pctldev = pinctrl_register(&abx500_pinctrl_desc, &pdev->dev, pct); 1238 if (IS_ERR(pct->pctldev)) { 1239 dev_err(&pdev->dev, 1240 "could not register abx500 pinctrl driver\n"); 1241 ret = PTR_ERR(pct->pctldev); 1242 goto out_rem_chip; 1243 } 1244 dev_info(&pdev->dev, "registered pin controller\n"); 1245 1246 /* We will handle a range of GPIO pins */ 1247 for (i = 0; i < pct->soc->gpio_num_ranges; i++) { 1248 const struct abx500_pinrange *p = &pct->soc->gpio_ranges[i]; 1249 1250 ret = gpiochip_add_pin_range(&pct->chip, 1251 dev_name(&pdev->dev), 1252 p->offset - 1, p->offset, p->npins); 1253 if (ret < 0) 1254 goto out_rem_chip; 1255 } 1256 1257 platform_set_drvdata(pdev, pct); 1258 dev_info(&pdev->dev, "initialized abx500 pinctrl driver\n"); 1259 1260 return 0; 1261 1262 out_rem_chip: 1263 gpiochip_remove(&pct->chip); 1264 return ret; 1265 } 1266 1267 /** 1268 * abx500_gpio_remove() - remove Ab8500-gpio driver 1269 * @pdev: Platform device registered 1270 */ 1271 static int abx500_gpio_remove(struct platform_device *pdev) 1272 { 1273 struct abx500_pinctrl *pct = platform_get_drvdata(pdev); 1274 1275 gpiochip_remove(&pct->chip); 1276 return 0; 1277 } 1278 1279 static struct platform_driver abx500_gpio_driver = { 1280 .driver = { 1281 .name = "abx500-gpio", 1282 .of_match_table = abx500_gpio_match, 1283 }, 1284 .probe = abx500_gpio_probe, 1285 .remove = abx500_gpio_remove, 1286 }; 1287 1288 static int __init abx500_gpio_init(void) 1289 { 1290 return platform_driver_register(&abx500_gpio_driver); 1291 } 1292 core_initcall(abx500_gpio_init); 1293 1294 MODULE_AUTHOR("Patrice Chotard <patrice.chotard@st.com>"); 1295 MODULE_DESCRIPTION("Driver allows to use AxB5xx unused pins to be used as GPIO"); 1296 MODULE_ALIAS("platform:abx500-gpio"); 1297 MODULE_LICENSE("GPL v2"); 1298