1 /* 2 * Copyright (c) 2012-2014, The Linux Foundation. All rights reserved. 3 * 4 * This program is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU General Public License version 2 and 6 * only version 2 as published by the Free Software Foundation. 7 * 8 * This program is distributed in the hope that it will be useful, 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11 * GNU General Public License for more details. 12 */ 13 14 #include <linux/gpio.h> 15 #include <linux/module.h> 16 #include <linux/of.h> 17 #include <linux/pinctrl/pinconf-generic.h> 18 #include <linux/pinctrl/pinconf.h> 19 #include <linux/pinctrl/pinmux.h> 20 #include <linux/platform_device.h> 21 #include <linux/regmap.h> 22 #include <linux/slab.h> 23 #include <linux/types.h> 24 25 #include <dt-bindings/pinctrl/qcom,pmic-gpio.h> 26 27 #include "../core.h" 28 #include "../pinctrl-utils.h" 29 30 #define PMIC_GPIO_ADDRESS_RANGE 0x100 31 32 /* type and subtype registers base address offsets */ 33 #define PMIC_GPIO_REG_TYPE 0x4 34 #define PMIC_GPIO_REG_SUBTYPE 0x5 35 36 /* GPIO peripheral type and subtype out_values */ 37 #define PMIC_GPIO_TYPE 0x10 38 #define PMIC_GPIO_SUBTYPE_GPIO_4CH 0x1 39 #define PMIC_GPIO_SUBTYPE_GPIOC_4CH 0x5 40 #define PMIC_GPIO_SUBTYPE_GPIO_8CH 0x9 41 #define PMIC_GPIO_SUBTYPE_GPIOC_8CH 0xd 42 43 #define PMIC_MPP_REG_RT_STS 0x10 44 #define PMIC_MPP_REG_RT_STS_VAL_MASK 0x1 45 46 /* control register base address offsets */ 47 #define PMIC_GPIO_REG_MODE_CTL 0x40 48 #define PMIC_GPIO_REG_DIG_VIN_CTL 0x41 49 #define PMIC_GPIO_REG_DIG_PULL_CTL 0x42 50 #define PMIC_GPIO_REG_DIG_OUT_CTL 0x45 51 #define PMIC_GPIO_REG_EN_CTL 0x46 52 53 /* PMIC_GPIO_REG_MODE_CTL */ 54 #define PMIC_GPIO_REG_MODE_VALUE_SHIFT 0x1 55 #define PMIC_GPIO_REG_MODE_FUNCTION_SHIFT 1 56 #define PMIC_GPIO_REG_MODE_FUNCTION_MASK 0x7 57 #define PMIC_GPIO_REG_MODE_DIR_SHIFT 4 58 #define PMIC_GPIO_REG_MODE_DIR_MASK 0x7 59 60 /* PMIC_GPIO_REG_DIG_VIN_CTL */ 61 #define PMIC_GPIO_REG_VIN_SHIFT 0 62 #define PMIC_GPIO_REG_VIN_MASK 0x7 63 64 /* PMIC_GPIO_REG_DIG_PULL_CTL */ 65 #define PMIC_GPIO_REG_PULL_SHIFT 0 66 #define PMIC_GPIO_REG_PULL_MASK 0x7 67 68 #define PMIC_GPIO_PULL_DOWN 4 69 #define PMIC_GPIO_PULL_DISABLE 5 70 71 /* PMIC_GPIO_REG_DIG_OUT_CTL */ 72 #define PMIC_GPIO_REG_OUT_STRENGTH_SHIFT 0 73 #define PMIC_GPIO_REG_OUT_STRENGTH_MASK 0x3 74 #define PMIC_GPIO_REG_OUT_TYPE_SHIFT 4 75 #define PMIC_GPIO_REG_OUT_TYPE_MASK 0x3 76 77 /* 78 * Output type - indicates pin should be configured as push-pull, 79 * open drain or open source. 80 */ 81 #define PMIC_GPIO_OUT_BUF_CMOS 0 82 #define PMIC_GPIO_OUT_BUF_OPEN_DRAIN_NMOS 1 83 #define PMIC_GPIO_OUT_BUF_OPEN_DRAIN_PMOS 2 84 85 /* PMIC_GPIO_REG_EN_CTL */ 86 #define PMIC_GPIO_REG_MASTER_EN_SHIFT 7 87 88 #define PMIC_GPIO_PHYSICAL_OFFSET 1 89 90 /* Qualcomm specific pin configurations */ 91 #define PMIC_GPIO_CONF_PULL_UP (PIN_CONFIG_END + 1) 92 #define PMIC_GPIO_CONF_STRENGTH (PIN_CONFIG_END + 2) 93 94 /** 95 * struct pmic_gpio_pad - keep current GPIO settings 96 * @base: Address base in SPMI device. 97 * @irq: IRQ number which this GPIO generate. 98 * @is_enabled: Set to false when GPIO should be put in high Z state. 99 * @out_value: Cached pin output value 100 * @have_buffer: Set to true if GPIO output could be configured in push-pull, 101 * open-drain or open-source mode. 102 * @output_enabled: Set to true if GPIO output logic is enabled. 103 * @input_enabled: Set to true if GPIO input buffer logic is enabled. 104 * @num_sources: Number of power-sources supported by this GPIO. 105 * @power_source: Current power-source used. 106 * @buffer_type: Push-pull, open-drain or open-source. 107 * @pullup: Constant current which flow trough GPIO output buffer. 108 * @strength: No, Low, Medium, High 109 * @function: See pmic_gpio_functions[] 110 */ 111 struct pmic_gpio_pad { 112 u16 base; 113 int irq; 114 bool is_enabled; 115 bool out_value; 116 bool have_buffer; 117 bool output_enabled; 118 bool input_enabled; 119 unsigned int num_sources; 120 unsigned int power_source; 121 unsigned int buffer_type; 122 unsigned int pullup; 123 unsigned int strength; 124 unsigned int function; 125 }; 126 127 struct pmic_gpio_state { 128 struct device *dev; 129 struct regmap *map; 130 struct pinctrl_dev *ctrl; 131 struct gpio_chip chip; 132 }; 133 134 struct pmic_gpio_bindings { 135 const char *property; 136 unsigned param; 137 }; 138 139 static struct pmic_gpio_bindings pmic_gpio_bindings[] = { 140 {"qcom,pull-up-strength", PMIC_GPIO_CONF_PULL_UP}, 141 {"qcom,drive-strength", PMIC_GPIO_CONF_STRENGTH}, 142 }; 143 144 static const char *const pmic_gpio_groups[] = { 145 "gpio1", "gpio2", "gpio3", "gpio4", "gpio5", "gpio6", "gpio7", "gpio8", 146 "gpio9", "gpio10", "gpio11", "gpio12", "gpio13", "gpio14", "gpio15", 147 "gpio16", "gpio17", "gpio18", "gpio19", "gpio20", "gpio21", "gpio22", 148 "gpio23", "gpio24", "gpio25", "gpio26", "gpio27", "gpio28", "gpio29", 149 "gpio30", "gpio31", "gpio32", "gpio33", "gpio34", "gpio35", "gpio36", 150 }; 151 152 static const char *const pmic_gpio_functions[] = { 153 PMIC_GPIO_FUNC_NORMAL, PMIC_GPIO_FUNC_PAIRED, 154 PMIC_GPIO_FUNC_FUNC1, PMIC_GPIO_FUNC_FUNC2, 155 PMIC_GPIO_FUNC_DTEST1, PMIC_GPIO_FUNC_DTEST2, 156 PMIC_GPIO_FUNC_DTEST3, PMIC_GPIO_FUNC_DTEST4, 157 }; 158 159 static inline struct pmic_gpio_state *to_gpio_state(struct gpio_chip *chip) 160 { 161 return container_of(chip, struct pmic_gpio_state, chip); 162 }; 163 164 static int pmic_gpio_read(struct pmic_gpio_state *state, 165 struct pmic_gpio_pad *pad, unsigned int addr) 166 { 167 unsigned int val; 168 int ret; 169 170 ret = regmap_read(state->map, pad->base + addr, &val); 171 if (ret < 0) 172 dev_err(state->dev, "read 0x%x failed\n", addr); 173 else 174 ret = val; 175 176 return ret; 177 } 178 179 static int pmic_gpio_write(struct pmic_gpio_state *state, 180 struct pmic_gpio_pad *pad, unsigned int addr, 181 unsigned int val) 182 { 183 int ret; 184 185 ret = regmap_write(state->map, pad->base + addr, val); 186 if (ret < 0) 187 dev_err(state->dev, "write 0x%x failed\n", addr); 188 189 return ret; 190 } 191 192 static int pmic_gpio_get_groups_count(struct pinctrl_dev *pctldev) 193 { 194 /* Every PIN is a group */ 195 return pctldev->desc->npins; 196 } 197 198 static const char *pmic_gpio_get_group_name(struct pinctrl_dev *pctldev, 199 unsigned pin) 200 { 201 return pctldev->desc->pins[pin].name; 202 } 203 204 static int pmic_gpio_get_group_pins(struct pinctrl_dev *pctldev, unsigned pin, 205 const unsigned **pins, unsigned *num_pins) 206 { 207 *pins = &pctldev->desc->pins[pin].number; 208 *num_pins = 1; 209 return 0; 210 } 211 212 static int pmic_gpio_parse_dt_config(struct device_node *np, 213 struct pinctrl_dev *pctldev, 214 unsigned long **configs, 215 unsigned int *nconfs) 216 { 217 struct pmic_gpio_bindings *par; 218 unsigned long cfg; 219 int ret, i; 220 u32 val; 221 222 for (i = 0; i < ARRAY_SIZE(pmic_gpio_bindings); i++) { 223 par = &pmic_gpio_bindings[i]; 224 ret = of_property_read_u32(np, par->property, &val); 225 226 /* property not found */ 227 if (ret == -EINVAL) 228 continue; 229 230 /* use zero as default value */ 231 if (ret) 232 val = 0; 233 234 dev_dbg(pctldev->dev, "found %s with value %u\n", 235 par->property, val); 236 237 cfg = pinconf_to_config_packed(par->param, val); 238 239 ret = pinctrl_utils_add_config(pctldev, configs, nconfs, cfg); 240 if (ret) 241 return ret; 242 } 243 244 return 0; 245 } 246 247 static int pmic_gpio_dt_subnode_to_map(struct pinctrl_dev *pctldev, 248 struct device_node *np, 249 struct pinctrl_map **map, 250 unsigned *reserv, unsigned *nmaps, 251 enum pinctrl_map_type type) 252 { 253 unsigned long *configs = NULL; 254 unsigned nconfs = 0; 255 struct property *prop; 256 const char *group; 257 int ret; 258 259 ret = pmic_gpio_parse_dt_config(np, pctldev, &configs, &nconfs); 260 if (ret < 0) 261 return ret; 262 263 if (!nconfs) 264 return 0; 265 266 ret = of_property_count_strings(np, "pins"); 267 if (ret < 0) 268 goto exit; 269 270 ret = pinctrl_utils_reserve_map(pctldev, map, reserv, nmaps, ret); 271 if (ret < 0) 272 goto exit; 273 274 of_property_for_each_string(np, "pins", prop, group) { 275 ret = pinctrl_utils_add_map_configs(pctldev, map, 276 reserv, nmaps, group, 277 configs, nconfs, type); 278 if (ret < 0) 279 break; 280 } 281 exit: 282 kfree(configs); 283 return ret; 284 } 285 286 static int pmic_gpio_dt_node_to_map(struct pinctrl_dev *pctldev, 287 struct device_node *np_config, 288 struct pinctrl_map **map, unsigned *nmaps) 289 { 290 enum pinctrl_map_type type; 291 struct device_node *np; 292 unsigned reserv; 293 int ret; 294 295 ret = 0; 296 *map = NULL; 297 *nmaps = 0; 298 reserv = 0; 299 type = PIN_MAP_TYPE_CONFIGS_GROUP; 300 301 for_each_child_of_node(np_config, np) { 302 ret = pinconf_generic_dt_subnode_to_map(pctldev, np, map, 303 &reserv, nmaps, type); 304 if (ret) 305 break; 306 307 ret = pmic_gpio_dt_subnode_to_map(pctldev, np, map, &reserv, 308 nmaps, type); 309 if (ret) 310 break; 311 } 312 313 if (ret < 0) 314 pinctrl_utils_dt_free_map(pctldev, *map, *nmaps); 315 316 return ret; 317 } 318 319 static const struct pinctrl_ops pmic_gpio_pinctrl_ops = { 320 .get_groups_count = pmic_gpio_get_groups_count, 321 .get_group_name = pmic_gpio_get_group_name, 322 .get_group_pins = pmic_gpio_get_group_pins, 323 .dt_node_to_map = pmic_gpio_dt_node_to_map, 324 .dt_free_map = pinctrl_utils_dt_free_map, 325 }; 326 327 static int pmic_gpio_get_functions_count(struct pinctrl_dev *pctldev) 328 { 329 return ARRAY_SIZE(pmic_gpio_functions); 330 } 331 332 static const char *pmic_gpio_get_function_name(struct pinctrl_dev *pctldev, 333 unsigned function) 334 { 335 return pmic_gpio_functions[function]; 336 } 337 338 static int pmic_gpio_get_function_groups(struct pinctrl_dev *pctldev, 339 unsigned function, 340 const char *const **groups, 341 unsigned *const num_qgroups) 342 { 343 *groups = pmic_gpio_groups; 344 *num_qgroups = pctldev->desc->npins; 345 return 0; 346 } 347 348 static int pmic_gpio_set_mux(struct pinctrl_dev *pctldev, unsigned function, 349 unsigned pin) 350 { 351 struct pmic_gpio_state *state = pinctrl_dev_get_drvdata(pctldev); 352 struct pmic_gpio_pad *pad; 353 unsigned int val; 354 int ret; 355 356 pad = pctldev->desc->pins[pin].drv_data; 357 358 pad->function = function; 359 360 val = 0; 361 if (pad->output_enabled) { 362 if (pad->input_enabled) 363 val = 2; 364 else 365 val = 1; 366 } 367 368 val |= pad->function << PMIC_GPIO_REG_MODE_FUNCTION_SHIFT; 369 val |= pad->out_value & PMIC_GPIO_REG_MODE_VALUE_SHIFT; 370 371 ret = pmic_gpio_write(state, pad, PMIC_GPIO_REG_MODE_CTL, val); 372 if (ret < 0) 373 return ret; 374 375 val = pad->is_enabled << PMIC_GPIO_REG_MASTER_EN_SHIFT; 376 377 return pmic_gpio_write(state, pad, PMIC_GPIO_REG_EN_CTL, val); 378 } 379 380 static const struct pinmux_ops pmic_gpio_pinmux_ops = { 381 .get_functions_count = pmic_gpio_get_functions_count, 382 .get_function_name = pmic_gpio_get_function_name, 383 .get_function_groups = pmic_gpio_get_function_groups, 384 .set_mux = pmic_gpio_set_mux, 385 }; 386 387 static int pmic_gpio_config_get(struct pinctrl_dev *pctldev, 388 unsigned int pin, unsigned long *config) 389 { 390 unsigned param = pinconf_to_config_param(*config); 391 struct pmic_gpio_pad *pad; 392 unsigned arg; 393 394 pad = pctldev->desc->pins[pin].drv_data; 395 396 switch (param) { 397 case PIN_CONFIG_DRIVE_PUSH_PULL: 398 arg = pad->buffer_type == PMIC_GPIO_OUT_BUF_CMOS; 399 break; 400 case PIN_CONFIG_DRIVE_OPEN_DRAIN: 401 arg = pad->buffer_type == PMIC_GPIO_OUT_BUF_OPEN_DRAIN_NMOS; 402 break; 403 case PIN_CONFIG_DRIVE_OPEN_SOURCE: 404 arg = pad->buffer_type == PMIC_GPIO_OUT_BUF_OPEN_DRAIN_PMOS; 405 break; 406 case PIN_CONFIG_BIAS_PULL_DOWN: 407 arg = pad->pullup == PMIC_GPIO_PULL_DOWN; 408 break; 409 case PIN_CONFIG_BIAS_DISABLE: 410 arg = pad->pullup = PMIC_GPIO_PULL_DISABLE; 411 break; 412 case PIN_CONFIG_BIAS_PULL_UP: 413 arg = pad->pullup == PMIC_GPIO_PULL_UP_30; 414 break; 415 case PIN_CONFIG_BIAS_HIGH_IMPEDANCE: 416 arg = !pad->is_enabled; 417 break; 418 case PIN_CONFIG_POWER_SOURCE: 419 arg = pad->power_source; 420 break; 421 case PIN_CONFIG_INPUT_ENABLE: 422 arg = pad->input_enabled; 423 break; 424 case PIN_CONFIG_OUTPUT: 425 arg = pad->out_value; 426 break; 427 case PMIC_GPIO_CONF_PULL_UP: 428 arg = pad->pullup; 429 break; 430 case PMIC_GPIO_CONF_STRENGTH: 431 arg = pad->strength; 432 break; 433 default: 434 return -EINVAL; 435 } 436 437 *config = pinconf_to_config_packed(param, arg); 438 return 0; 439 } 440 441 static int pmic_gpio_config_set(struct pinctrl_dev *pctldev, unsigned int pin, 442 unsigned long *configs, unsigned nconfs) 443 { 444 struct pmic_gpio_state *state = pinctrl_dev_get_drvdata(pctldev); 445 struct pmic_gpio_pad *pad; 446 unsigned param, arg; 447 unsigned int val; 448 int i, ret; 449 450 pad = pctldev->desc->pins[pin].drv_data; 451 452 for (i = 0; i < nconfs; i++) { 453 param = pinconf_to_config_param(configs[i]); 454 arg = pinconf_to_config_argument(configs[i]); 455 456 switch (param) { 457 case PIN_CONFIG_DRIVE_PUSH_PULL: 458 pad->buffer_type = PMIC_GPIO_OUT_BUF_CMOS; 459 break; 460 case PIN_CONFIG_DRIVE_OPEN_DRAIN: 461 if (!pad->have_buffer) 462 return -EINVAL; 463 pad->buffer_type = PMIC_GPIO_OUT_BUF_OPEN_DRAIN_NMOS; 464 break; 465 case PIN_CONFIG_DRIVE_OPEN_SOURCE: 466 if (!pad->have_buffer) 467 return -EINVAL; 468 pad->buffer_type = PMIC_GPIO_OUT_BUF_OPEN_DRAIN_PMOS; 469 break; 470 case PIN_CONFIG_BIAS_DISABLE: 471 pad->pullup = PMIC_GPIO_PULL_DISABLE; 472 break; 473 case PIN_CONFIG_BIAS_PULL_UP: 474 pad->pullup = PMIC_GPIO_PULL_UP_30; 475 break; 476 case PIN_CONFIG_BIAS_PULL_DOWN: 477 if (arg) 478 pad->pullup = PMIC_GPIO_PULL_DOWN; 479 else 480 pad->pullup = PMIC_GPIO_PULL_DISABLE; 481 break; 482 case PIN_CONFIG_BIAS_HIGH_IMPEDANCE: 483 pad->is_enabled = false; 484 break; 485 case PIN_CONFIG_POWER_SOURCE: 486 if (arg > pad->num_sources) 487 return -EINVAL; 488 pad->power_source = arg; 489 break; 490 case PIN_CONFIG_INPUT_ENABLE: 491 pad->input_enabled = arg ? true : false; 492 break; 493 case PIN_CONFIG_OUTPUT: 494 pad->output_enabled = true; 495 pad->out_value = arg; 496 break; 497 case PMIC_GPIO_CONF_PULL_UP: 498 if (arg > PMIC_GPIO_PULL_UP_1P5_30) 499 return -EINVAL; 500 pad->pullup = arg; 501 break; 502 case PMIC_GPIO_CONF_STRENGTH: 503 if (arg > PMIC_GPIO_STRENGTH_LOW) 504 return -EINVAL; 505 pad->strength = arg; 506 break; 507 default: 508 return -EINVAL; 509 } 510 } 511 512 val = pad->power_source << PMIC_GPIO_REG_VIN_SHIFT; 513 514 ret = pmic_gpio_write(state, pad, PMIC_GPIO_REG_DIG_VIN_CTL, val); 515 if (ret < 0) 516 return ret; 517 518 val = pad->pullup << PMIC_GPIO_REG_PULL_SHIFT; 519 520 ret = pmic_gpio_write(state, pad, PMIC_GPIO_REG_DIG_PULL_CTL, val); 521 if (ret < 0) 522 return ret; 523 524 val = pad->buffer_type << PMIC_GPIO_REG_OUT_TYPE_SHIFT; 525 val = pad->strength << PMIC_GPIO_REG_OUT_STRENGTH_SHIFT; 526 527 ret = pmic_gpio_write(state, pad, PMIC_GPIO_REG_DIG_OUT_CTL, val); 528 if (ret < 0) 529 return ret; 530 531 val = 0; 532 if (pad->output_enabled) { 533 if (pad->input_enabled) 534 val = 2; 535 else 536 val = 1; 537 } 538 539 val = val << PMIC_GPIO_REG_MODE_DIR_SHIFT; 540 val |= pad->function << PMIC_GPIO_REG_MODE_FUNCTION_SHIFT; 541 val |= pad->out_value & PMIC_GPIO_REG_MODE_VALUE_SHIFT; 542 543 return pmic_gpio_write(state, pad, PMIC_GPIO_REG_MODE_CTL, val); 544 } 545 546 static void pmic_gpio_config_dbg_show(struct pinctrl_dev *pctldev, 547 struct seq_file *s, unsigned pin) 548 { 549 struct pmic_gpio_state *state = pinctrl_dev_get_drvdata(pctldev); 550 struct pmic_gpio_pad *pad; 551 int ret, val; 552 553 static const char *const biases[] = { 554 "pull-up 30uA", "pull-up 1.5uA", "pull-up 31.5uA", 555 "pull-up 1.5uA + 30uA boost", "pull-down 10uA", "no pull" 556 }; 557 static const char *const buffer_types[] = { 558 "push-pull", "open-drain", "open-source" 559 }; 560 static const char *const strengths[] = { 561 "no", "high", "medium", "low" 562 }; 563 564 pad = pctldev->desc->pins[pin].drv_data; 565 566 seq_printf(s, " gpio%-2d:", pin + PMIC_GPIO_PHYSICAL_OFFSET); 567 568 val = pmic_gpio_read(state, pad, PMIC_GPIO_REG_EN_CTL); 569 570 if (val < 0 || !(val >> PMIC_GPIO_REG_MASTER_EN_SHIFT)) { 571 seq_puts(s, " ---"); 572 } else { 573 574 if (!pad->input_enabled) { 575 ret = pmic_gpio_read(state, pad, PMIC_MPP_REG_RT_STS); 576 if (!ret) { 577 ret &= PMIC_MPP_REG_RT_STS_VAL_MASK; 578 pad->out_value = ret; 579 } 580 } 581 582 seq_printf(s, " %-4s", pad->output_enabled ? "out" : "in"); 583 seq_printf(s, " %-7s", pmic_gpio_functions[pad->function]); 584 seq_printf(s, " vin-%d", pad->power_source); 585 seq_printf(s, " %-27s", biases[pad->pullup]); 586 seq_printf(s, " %-10s", buffer_types[pad->buffer_type]); 587 seq_printf(s, " %-4s", pad->out_value ? "high" : "low"); 588 seq_printf(s, " %-7s", strengths[pad->strength]); 589 } 590 } 591 592 static const struct pinconf_ops pmic_gpio_pinconf_ops = { 593 .pin_config_group_get = pmic_gpio_config_get, 594 .pin_config_group_set = pmic_gpio_config_set, 595 .pin_config_group_dbg_show = pmic_gpio_config_dbg_show, 596 }; 597 598 static int pmic_gpio_direction_input(struct gpio_chip *chip, unsigned pin) 599 { 600 struct pmic_gpio_state *state = to_gpio_state(chip); 601 unsigned long config; 602 603 config = pinconf_to_config_packed(PIN_CONFIG_INPUT_ENABLE, 1); 604 605 return pmic_gpio_config_set(state->ctrl, pin, &config, 1); 606 } 607 608 static int pmic_gpio_direction_output(struct gpio_chip *chip, 609 unsigned pin, int val) 610 { 611 struct pmic_gpio_state *state = to_gpio_state(chip); 612 unsigned long config; 613 614 config = pinconf_to_config_packed(PIN_CONFIG_OUTPUT, val); 615 616 return pmic_gpio_config_set(state->ctrl, pin, &config, 1); 617 } 618 619 static int pmic_gpio_get(struct gpio_chip *chip, unsigned pin) 620 { 621 struct pmic_gpio_state *state = to_gpio_state(chip); 622 struct pmic_gpio_pad *pad; 623 int ret; 624 625 pad = state->ctrl->desc->pins[pin].drv_data; 626 627 if (!pad->is_enabled) 628 return -EINVAL; 629 630 if (pad->input_enabled) { 631 ret = pmic_gpio_read(state, pad, PMIC_MPP_REG_RT_STS); 632 if (ret < 0) 633 return ret; 634 635 pad->out_value = ret & PMIC_MPP_REG_RT_STS_VAL_MASK; 636 } 637 638 return pad->out_value; 639 } 640 641 static void pmic_gpio_set(struct gpio_chip *chip, unsigned pin, int value) 642 { 643 struct pmic_gpio_state *state = to_gpio_state(chip); 644 unsigned long config; 645 646 config = pinconf_to_config_packed(PIN_CONFIG_OUTPUT, value); 647 648 pmic_gpio_config_set(state->ctrl, pin, &config, 1); 649 } 650 651 static int pmic_gpio_request(struct gpio_chip *chip, unsigned base) 652 { 653 return pinctrl_request_gpio(chip->base + base); 654 } 655 656 static void pmic_gpio_free(struct gpio_chip *chip, unsigned base) 657 { 658 pinctrl_free_gpio(chip->base + base); 659 } 660 661 static int pmic_gpio_of_xlate(struct gpio_chip *chip, 662 const struct of_phandle_args *gpio_desc, 663 u32 *flags) 664 { 665 if (chip->of_gpio_n_cells < 2) 666 return -EINVAL; 667 668 if (flags) 669 *flags = gpio_desc->args[1]; 670 671 return gpio_desc->args[0] - PMIC_GPIO_PHYSICAL_OFFSET; 672 } 673 674 static int pmic_gpio_to_irq(struct gpio_chip *chip, unsigned pin) 675 { 676 struct pmic_gpio_state *state = to_gpio_state(chip); 677 struct pmic_gpio_pad *pad; 678 679 pad = state->ctrl->desc->pins[pin].drv_data; 680 681 return pad->irq; 682 } 683 684 static void pmic_gpio_dbg_show(struct seq_file *s, struct gpio_chip *chip) 685 { 686 struct pmic_gpio_state *state = to_gpio_state(chip); 687 unsigned i; 688 689 for (i = 0; i < chip->ngpio; i++) { 690 pmic_gpio_config_dbg_show(state->ctrl, s, i); 691 seq_puts(s, "\n"); 692 } 693 } 694 695 static const struct gpio_chip pmic_gpio_gpio_template = { 696 .direction_input = pmic_gpio_direction_input, 697 .direction_output = pmic_gpio_direction_output, 698 .get = pmic_gpio_get, 699 .set = pmic_gpio_set, 700 .request = pmic_gpio_request, 701 .free = pmic_gpio_free, 702 .of_xlate = pmic_gpio_of_xlate, 703 .to_irq = pmic_gpio_to_irq, 704 .dbg_show = pmic_gpio_dbg_show, 705 }; 706 707 static int pmic_gpio_populate(struct pmic_gpio_state *state, 708 struct pmic_gpio_pad *pad) 709 { 710 int type, subtype, val, dir; 711 712 type = pmic_gpio_read(state, pad, PMIC_GPIO_REG_TYPE); 713 if (type < 0) 714 return type; 715 716 if (type != PMIC_GPIO_TYPE) { 717 dev_err(state->dev, "incorrect block type 0x%x at 0x%x\n", 718 type, pad->base); 719 return -ENODEV; 720 } 721 722 subtype = pmic_gpio_read(state, pad, PMIC_GPIO_REG_SUBTYPE); 723 if (subtype < 0) 724 return subtype; 725 726 switch (subtype) { 727 case PMIC_GPIO_SUBTYPE_GPIO_4CH: 728 pad->have_buffer = true; 729 case PMIC_GPIO_SUBTYPE_GPIOC_4CH: 730 pad->num_sources = 4; 731 break; 732 case PMIC_GPIO_SUBTYPE_GPIO_8CH: 733 pad->have_buffer = true; 734 case PMIC_GPIO_SUBTYPE_GPIOC_8CH: 735 pad->num_sources = 8; 736 break; 737 default: 738 dev_err(state->dev, "unknown GPIO type 0x%x\n", subtype); 739 return -ENODEV; 740 } 741 742 val = pmic_gpio_read(state, pad, PMIC_GPIO_REG_MODE_CTL); 743 if (val < 0) 744 return val; 745 746 pad->out_value = val & PMIC_GPIO_REG_MODE_VALUE_SHIFT; 747 748 dir = val >> PMIC_GPIO_REG_MODE_DIR_SHIFT; 749 dir &= PMIC_GPIO_REG_MODE_DIR_MASK; 750 switch (dir) { 751 case 0: 752 pad->input_enabled = true; 753 pad->output_enabled = false; 754 break; 755 case 1: 756 pad->input_enabled = false; 757 pad->output_enabled = true; 758 break; 759 case 2: 760 pad->input_enabled = true; 761 pad->output_enabled = true; 762 break; 763 default: 764 dev_err(state->dev, "unknown GPIO direction\n"); 765 return -ENODEV; 766 } 767 768 pad->function = val >> PMIC_GPIO_REG_MODE_FUNCTION_SHIFT; 769 pad->function &= PMIC_GPIO_REG_MODE_FUNCTION_MASK; 770 771 val = pmic_gpio_read(state, pad, PMIC_GPIO_REG_DIG_VIN_CTL); 772 if (val < 0) 773 return val; 774 775 pad->power_source = val >> PMIC_GPIO_REG_VIN_SHIFT; 776 pad->power_source &= PMIC_GPIO_REG_VIN_MASK; 777 778 val = pmic_gpio_read(state, pad, PMIC_GPIO_REG_DIG_PULL_CTL); 779 if (val < 0) 780 return val; 781 782 pad->pullup = val >> PMIC_GPIO_REG_PULL_SHIFT; 783 pad->pullup &= PMIC_GPIO_REG_PULL_MASK; 784 785 val = pmic_gpio_read(state, pad, PMIC_GPIO_REG_DIG_OUT_CTL); 786 if (val < 0) 787 return val; 788 789 pad->strength = val >> PMIC_GPIO_REG_OUT_STRENGTH_SHIFT; 790 pad->strength &= PMIC_GPIO_REG_OUT_STRENGTH_MASK; 791 792 pad->buffer_type = val >> PMIC_GPIO_REG_OUT_TYPE_SHIFT; 793 pad->buffer_type &= PMIC_GPIO_REG_OUT_TYPE_MASK; 794 795 /* Pin could be disabled with PIN_CONFIG_BIAS_HIGH_IMPEDANCE */ 796 pad->is_enabled = true; 797 return 0; 798 } 799 800 static int pmic_gpio_probe(struct platform_device *pdev) 801 { 802 struct device *dev = &pdev->dev; 803 struct pinctrl_pin_desc *pindesc; 804 struct pinctrl_desc *pctrldesc; 805 struct pmic_gpio_pad *pad, *pads; 806 struct pmic_gpio_state *state; 807 int ret, npins, i; 808 u32 res[2]; 809 810 ret = of_property_read_u32_array(dev->of_node, "reg", res, 2); 811 if (ret < 0) { 812 dev_err(dev, "missing base address and/or range"); 813 return ret; 814 } 815 816 npins = res[1] / PMIC_GPIO_ADDRESS_RANGE; 817 818 if (!npins) 819 return -EINVAL; 820 821 BUG_ON(npins > ARRAY_SIZE(pmic_gpio_groups)); 822 823 state = devm_kzalloc(dev, sizeof(*state), GFP_KERNEL); 824 if (!state) 825 return -ENOMEM; 826 827 platform_set_drvdata(pdev, state); 828 829 state->dev = &pdev->dev; 830 state->map = dev_get_regmap(dev->parent, NULL); 831 832 pindesc = devm_kcalloc(dev, npins, sizeof(*pindesc), GFP_KERNEL); 833 if (!pindesc) 834 return -ENOMEM; 835 836 pads = devm_kcalloc(dev, npins, sizeof(*pads), GFP_KERNEL); 837 if (!pads) 838 return -ENOMEM; 839 840 pctrldesc = devm_kzalloc(dev, sizeof(*pctrldesc), GFP_KERNEL); 841 if (!pctrldesc) 842 return -ENOMEM; 843 844 pctrldesc->pctlops = &pmic_gpio_pinctrl_ops; 845 pctrldesc->pmxops = &pmic_gpio_pinmux_ops; 846 pctrldesc->confops = &pmic_gpio_pinconf_ops; 847 pctrldesc->owner = THIS_MODULE; 848 pctrldesc->name = dev_name(dev); 849 pctrldesc->pins = pindesc; 850 pctrldesc->npins = npins; 851 852 for (i = 0; i < npins; i++, pindesc++) { 853 pad = &pads[i]; 854 pindesc->drv_data = pad; 855 pindesc->number = i; 856 pindesc->name = pmic_gpio_groups[i]; 857 858 pad->irq = platform_get_irq(pdev, i); 859 if (pad->irq < 0) 860 return pad->irq; 861 862 pad->base = res[0] + i * PMIC_GPIO_ADDRESS_RANGE; 863 864 ret = pmic_gpio_populate(state, pad); 865 if (ret < 0) 866 return ret; 867 } 868 869 state->chip = pmic_gpio_gpio_template; 870 state->chip.dev = dev; 871 state->chip.base = -1; 872 state->chip.ngpio = npins; 873 state->chip.label = dev_name(dev); 874 state->chip.of_gpio_n_cells = 2; 875 state->chip.can_sleep = false; 876 877 state->ctrl = pinctrl_register(pctrldesc, dev, state); 878 if (!state->ctrl) 879 return -ENODEV; 880 881 ret = gpiochip_add(&state->chip); 882 if (ret) { 883 dev_err(state->dev, "can't add gpio chip\n"); 884 goto err_chip; 885 } 886 887 ret = gpiochip_add_pin_range(&state->chip, dev_name(dev), 0, 0, npins); 888 if (ret) { 889 dev_err(dev, "failed to add pin range\n"); 890 goto err_range; 891 } 892 893 return 0; 894 895 err_range: 896 gpiochip_remove(&state->chip); 897 err_chip: 898 pinctrl_unregister(state->ctrl); 899 return ret; 900 } 901 902 static int pmic_gpio_remove(struct platform_device *pdev) 903 { 904 struct pmic_gpio_state *state = platform_get_drvdata(pdev); 905 906 gpiochip_remove(&state->chip); 907 pinctrl_unregister(state->ctrl); 908 return 0; 909 } 910 911 static const struct of_device_id pmic_gpio_of_match[] = { 912 { .compatible = "qcom,pm8941-gpio" }, /* 36 GPIO's */ 913 { .compatible = "qcom,pma8084-gpio" }, /* 22 GPIO's */ 914 { }, 915 }; 916 917 MODULE_DEVICE_TABLE(of, pmic_gpio_of_match); 918 919 static struct platform_driver pmic_gpio_driver = { 920 .driver = { 921 .name = "qcom-spmi-gpio", 922 .of_match_table = pmic_gpio_of_match, 923 }, 924 .probe = pmic_gpio_probe, 925 .remove = pmic_gpio_remove, 926 }; 927 928 module_platform_driver(pmic_gpio_driver); 929 930 MODULE_AUTHOR("Ivan T. Ivanov <iivanov@mm-sol.com>"); 931 MODULE_DESCRIPTION("Qualcomm SPMI PMIC GPIO pin control driver"); 932 MODULE_ALIAS("platform:qcom-spmi-gpio"); 933 MODULE_LICENSE("GPL v2"); 934