1// SPDX-License-Identifier: GPL-2.0-or-later 2/* 3 * Marvell MVEBU pinctrl core driver 4 * 5 * Authors: Sebastian Hesselbarth <sebastian.hesselbarth@gmail.com> 6 * Thomas Petazzoni <thomas.petazzoni@free-electrons.com> 7 */ 8 9#include <linux/platform_device.h> 10#include <linux/slab.h> 11#include <linux/io.h> 12#include <linux/of.h> 13#include <linux/of_address.h> 14#include <linux/of_platform.h> 15#include <linux/err.h> 16#include <linux/gpio/driver.h> 17#include <linux/pinctrl/machine.h> 18#include <linux/pinctrl/pinconf.h> 19#include <linux/pinctrl/pinctrl.h> 20#include <linux/pinctrl/pinmux.h> 21#include <linux/mfd/syscon.h> 22#include <linux/regmap.h> 23 24#include "pinctrl-mvebu.h" 25 26#define MPPS_PER_REG 8 27#define MPP_BITS 4 28#define MPP_MASK 0xf 29 30struct mvebu_pinctrl_function { 31 const char *name; 32 const char **groups; 33 unsigned num_groups; 34}; 35 36struct mvebu_pinctrl_group { 37 const char *name; 38 const struct mvebu_mpp_ctrl *ctrl; 39 struct mvebu_mpp_ctrl_data *data; 40 struct mvebu_mpp_ctrl_setting *settings; 41 unsigned num_settings; 42 unsigned gid; 43 unsigned *pins; 44 unsigned npins; 45}; 46 47struct mvebu_pinctrl { 48 struct device *dev; 49 struct pinctrl_dev *pctldev; 50 struct pinctrl_desc desc; 51 struct mvebu_pinctrl_group *groups; 52 unsigned num_groups; 53 struct mvebu_pinctrl_function *functions; 54 unsigned num_functions; 55 u8 variant; 56}; 57 58int mvebu_mmio_mpp_ctrl_get(struct mvebu_mpp_ctrl_data *data, 59 unsigned int pid, unsigned long *config) 60{ 61 unsigned off = (pid / MVEBU_MPPS_PER_REG) * MVEBU_MPP_BITS; 62 unsigned shift = (pid % MVEBU_MPPS_PER_REG) * MVEBU_MPP_BITS; 63 64 *config = (readl(data->base + off) >> shift) & MVEBU_MPP_MASK; 65 66 return 0; 67} 68 69int mvebu_mmio_mpp_ctrl_set(struct mvebu_mpp_ctrl_data *data, 70 unsigned int pid, unsigned long config) 71{ 72 unsigned off = (pid / MVEBU_MPPS_PER_REG) * MVEBU_MPP_BITS; 73 unsigned shift = (pid % MVEBU_MPPS_PER_REG) * MVEBU_MPP_BITS; 74 unsigned long reg; 75 76 reg = readl(data->base + off) & ~(MVEBU_MPP_MASK << shift); 77 writel(reg | (config << shift), data->base + off); 78 79 return 0; 80} 81 82static struct mvebu_pinctrl_group *mvebu_pinctrl_find_group_by_pid( 83 struct mvebu_pinctrl *pctl, unsigned pid) 84{ 85 unsigned n; 86 for (n = 0; n < pctl->num_groups; n++) { 87 if (pid >= pctl->groups[n].pins[0] && 88 pid < pctl->groups[n].pins[0] + 89 pctl->groups[n].npins) 90 return &pctl->groups[n]; 91 } 92 return NULL; 93} 94 95static struct mvebu_pinctrl_group *mvebu_pinctrl_find_group_by_name( 96 struct mvebu_pinctrl *pctl, const char *name) 97{ 98 unsigned n; 99 for (n = 0; n < pctl->num_groups; n++) { 100 if (strcmp(name, pctl->groups[n].name) == 0) 101 return &pctl->groups[n]; 102 } 103 return NULL; 104} 105 106static struct mvebu_mpp_ctrl_setting *mvebu_pinctrl_find_setting_by_val( 107 struct mvebu_pinctrl *pctl, struct mvebu_pinctrl_group *grp, 108 unsigned long config) 109{ 110 unsigned n; 111 for (n = 0; n < grp->num_settings; n++) { 112 if (config == grp->settings[n].val) { 113 if (!pctl->variant || (pctl->variant & 114 grp->settings[n].variant)) 115 return &grp->settings[n]; 116 } 117 } 118 return NULL; 119} 120 121static struct mvebu_mpp_ctrl_setting *mvebu_pinctrl_find_setting_by_name( 122 struct mvebu_pinctrl *pctl, struct mvebu_pinctrl_group *grp, 123 const char *name) 124{ 125 unsigned n; 126 for (n = 0; n < grp->num_settings; n++) { 127 if (strcmp(name, grp->settings[n].name) == 0) { 128 if (!pctl->variant || (pctl->variant & 129 grp->settings[n].variant)) 130 return &grp->settings[n]; 131 } 132 } 133 return NULL; 134} 135 136static struct mvebu_mpp_ctrl_setting *mvebu_pinctrl_find_gpio_setting( 137 struct mvebu_pinctrl *pctl, struct mvebu_pinctrl_group *grp) 138{ 139 unsigned n; 140 for (n = 0; n < grp->num_settings; n++) { 141 if (grp->settings[n].flags & 142 (MVEBU_SETTING_GPO | MVEBU_SETTING_GPI)) { 143 if (!pctl->variant || (pctl->variant & 144 grp->settings[n].variant)) 145 return &grp->settings[n]; 146 } 147 } 148 return NULL; 149} 150 151static struct mvebu_pinctrl_function *mvebu_pinctrl_find_function_by_name( 152 struct mvebu_pinctrl *pctl, const char *name) 153{ 154 unsigned n; 155 for (n = 0; n < pctl->num_functions; n++) { 156 if (strcmp(name, pctl->functions[n].name) == 0) 157 return &pctl->functions[n]; 158 } 159 return NULL; 160} 161 162static int mvebu_pinconf_group_get(struct pinctrl_dev *pctldev, 163 unsigned gid, unsigned long *config) 164{ 165 struct mvebu_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev); 166 struct mvebu_pinctrl_group *grp = &pctl->groups[gid]; 167 168 if (!grp->ctrl) 169 return -EINVAL; 170 171 return grp->ctrl->mpp_get(grp->data, grp->pins[0], config); 172} 173 174static int mvebu_pinconf_group_set(struct pinctrl_dev *pctldev, 175 unsigned gid, unsigned long *configs, 176 unsigned num_configs) 177{ 178 struct mvebu_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev); 179 struct mvebu_pinctrl_group *grp = &pctl->groups[gid]; 180 int i, ret; 181 182 if (!grp->ctrl) 183 return -EINVAL; 184 185 for (i = 0; i < num_configs; i++) { 186 ret = grp->ctrl->mpp_set(grp->data, grp->pins[0], configs[i]); 187 if (ret) 188 return ret; 189 } /* for each config */ 190 191 return 0; 192} 193 194static void mvebu_pinconf_group_dbg_show(struct pinctrl_dev *pctldev, 195 struct seq_file *s, unsigned gid) 196{ 197 struct mvebu_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev); 198 struct mvebu_pinctrl_group *grp = &pctl->groups[gid]; 199 struct mvebu_mpp_ctrl_setting *curr; 200 unsigned long config; 201 unsigned n; 202 203 if (mvebu_pinconf_group_get(pctldev, gid, &config)) 204 return; 205 206 curr = mvebu_pinctrl_find_setting_by_val(pctl, grp, config); 207 208 if (curr) { 209 seq_printf(s, "current: %s", curr->name); 210 if (curr->subname) 211 seq_printf(s, "(%s)", curr->subname); 212 if (curr->flags & (MVEBU_SETTING_GPO | MVEBU_SETTING_GPI)) { 213 seq_putc(s, '('); 214 if (curr->flags & MVEBU_SETTING_GPI) 215 seq_putc(s, 'i'); 216 if (curr->flags & MVEBU_SETTING_GPO) 217 seq_putc(s, 'o'); 218 seq_putc(s, ')'); 219 } 220 } else { 221 seq_puts(s, "current: UNKNOWN"); 222 } 223 224 if (grp->num_settings > 1) { 225 seq_puts(s, ", available = ["); 226 for (n = 0; n < grp->num_settings; n++) { 227 if (curr == &grp->settings[n]) 228 continue; 229 230 /* skip unsupported settings for this variant */ 231 if (pctl->variant && 232 !(pctl->variant & grp->settings[n].variant)) 233 continue; 234 235 seq_printf(s, " %s", grp->settings[n].name); 236 if (grp->settings[n].subname) 237 seq_printf(s, "(%s)", grp->settings[n].subname); 238 if (grp->settings[n].flags & 239 (MVEBU_SETTING_GPO | MVEBU_SETTING_GPI)) { 240 seq_putc(s, '('); 241 if (grp->settings[n].flags & MVEBU_SETTING_GPI) 242 seq_putc(s, 'i'); 243 if (grp->settings[n].flags & MVEBU_SETTING_GPO) 244 seq_putc(s, 'o'); 245 seq_putc(s, ')'); 246 } 247 } 248 seq_puts(s, " ]"); 249 } 250} 251 252static const struct pinconf_ops mvebu_pinconf_ops = { 253 .pin_config_group_get = mvebu_pinconf_group_get, 254 .pin_config_group_set = mvebu_pinconf_group_set, 255 .pin_config_group_dbg_show = mvebu_pinconf_group_dbg_show, 256}; 257 258static int mvebu_pinmux_get_funcs_count(struct pinctrl_dev *pctldev) 259{ 260 struct mvebu_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev); 261 262 return pctl->num_functions; 263} 264 265static const char *mvebu_pinmux_get_func_name(struct pinctrl_dev *pctldev, 266 unsigned fid) 267{ 268 struct mvebu_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev); 269 270 return pctl->functions[fid].name; 271} 272 273static int mvebu_pinmux_get_groups(struct pinctrl_dev *pctldev, unsigned fid, 274 const char * const **groups, 275 unsigned * const num_groups) 276{ 277 struct mvebu_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev); 278 279 *groups = pctl->functions[fid].groups; 280 *num_groups = pctl->functions[fid].num_groups; 281 return 0; 282} 283 284static int mvebu_pinmux_set(struct pinctrl_dev *pctldev, unsigned fid, 285 unsigned gid) 286{ 287 struct mvebu_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev); 288 struct mvebu_pinctrl_function *func = &pctl->functions[fid]; 289 struct mvebu_pinctrl_group *grp = &pctl->groups[gid]; 290 struct mvebu_mpp_ctrl_setting *setting; 291 int ret; 292 unsigned long config; 293 294 setting = mvebu_pinctrl_find_setting_by_name(pctl, grp, 295 func->name); 296 if (!setting) { 297 dev_err(pctl->dev, 298 "unable to find setting %s in group %s\n", 299 func->name, func->groups[gid]); 300 return -EINVAL; 301 } 302 303 config = setting->val; 304 ret = mvebu_pinconf_group_set(pctldev, grp->gid, &config, 1); 305 if (ret) { 306 dev_err(pctl->dev, "cannot set group %s to %s\n", 307 func->groups[gid], func->name); 308 return ret; 309 } 310 311 return 0; 312} 313 314static int mvebu_pinmux_gpio_request_enable(struct pinctrl_dev *pctldev, 315 struct pinctrl_gpio_range *range, unsigned offset) 316{ 317 struct mvebu_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev); 318 struct mvebu_pinctrl_group *grp; 319 struct mvebu_mpp_ctrl_setting *setting; 320 unsigned long config; 321 322 grp = mvebu_pinctrl_find_group_by_pid(pctl, offset); 323 if (!grp) 324 return -EINVAL; 325 326 if (grp->ctrl->mpp_gpio_req) 327 return grp->ctrl->mpp_gpio_req(grp->data, offset); 328 329 setting = mvebu_pinctrl_find_gpio_setting(pctl, grp); 330 if (!setting) 331 return -ENOTSUPP; 332 333 config = setting->val; 334 335 return mvebu_pinconf_group_set(pctldev, grp->gid, &config, 1); 336} 337 338static int mvebu_pinmux_gpio_set_direction(struct pinctrl_dev *pctldev, 339 struct pinctrl_gpio_range *range, unsigned offset, bool input) 340{ 341 struct mvebu_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev); 342 struct mvebu_pinctrl_group *grp; 343 struct mvebu_mpp_ctrl_setting *setting; 344 345 grp = mvebu_pinctrl_find_group_by_pid(pctl, offset); 346 if (!grp) 347 return -EINVAL; 348 349 if (grp->ctrl->mpp_gpio_dir) 350 return grp->ctrl->mpp_gpio_dir(grp->data, offset, input); 351 352 setting = mvebu_pinctrl_find_gpio_setting(pctl, grp); 353 if (!setting) 354 return -ENOTSUPP; 355 356 if ((input && (setting->flags & MVEBU_SETTING_GPI)) || 357 (!input && (setting->flags & MVEBU_SETTING_GPO))) 358 return 0; 359 360 return -ENOTSUPP; 361} 362 363static const struct pinmux_ops mvebu_pinmux_ops = { 364 .get_functions_count = mvebu_pinmux_get_funcs_count, 365 .get_function_name = mvebu_pinmux_get_func_name, 366 .get_function_groups = mvebu_pinmux_get_groups, 367 .gpio_request_enable = mvebu_pinmux_gpio_request_enable, 368 .gpio_set_direction = mvebu_pinmux_gpio_set_direction, 369 .set_mux = mvebu_pinmux_set, 370}; 371 372static int mvebu_pinctrl_get_groups_count(struct pinctrl_dev *pctldev) 373{ 374 struct mvebu_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev); 375 return pctl->num_groups; 376} 377 378static const char *mvebu_pinctrl_get_group_name(struct pinctrl_dev *pctldev, 379 unsigned gid) 380{ 381 struct mvebu_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev); 382 return pctl->groups[gid].name; 383} 384 385static int mvebu_pinctrl_get_group_pins(struct pinctrl_dev *pctldev, 386 unsigned gid, const unsigned **pins, 387 unsigned *num_pins) 388{ 389 struct mvebu_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev); 390 *pins = pctl->groups[gid].pins; 391 *num_pins = pctl->groups[gid].npins; 392 return 0; 393} 394 395static int mvebu_pinctrl_dt_node_to_map(struct pinctrl_dev *pctldev, 396 struct device_node *np, 397 struct pinctrl_map **map, 398 unsigned *num_maps) 399{ 400 struct mvebu_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev); 401 struct property *prop; 402 const char *function; 403 const char *group; 404 int ret, nmaps, n; 405 406 *map = NULL; 407 *num_maps = 0; 408 409 ret = of_property_read_string(np, "marvell,function", &function); 410 if (ret) { 411 dev_err(pctl->dev, 412 "missing marvell,function in node %pOFn\n", np); 413 return 0; 414 } 415 416 nmaps = of_property_count_strings(np, "marvell,pins"); 417 if (nmaps < 0) { 418 dev_err(pctl->dev, 419 "missing marvell,pins in node %pOFn\n", np); 420 return 0; 421 } 422 423 *map = kmalloc_array(nmaps, sizeof(**map), GFP_KERNEL); 424 if (!*map) 425 return -ENOMEM; 426 427 n = 0; 428 of_property_for_each_string(np, "marvell,pins", prop, group) { 429 struct mvebu_pinctrl_group *grp = 430 mvebu_pinctrl_find_group_by_name(pctl, group); 431 432 if (!grp) { 433 dev_err(pctl->dev, "unknown pin %s", group); 434 continue; 435 } 436 437 if (!mvebu_pinctrl_find_setting_by_name(pctl, grp, function)) { 438 dev_err(pctl->dev, "unsupported function %s on pin %s", 439 function, group); 440 continue; 441 } 442 443 (*map)[n].type = PIN_MAP_TYPE_MUX_GROUP; 444 (*map)[n].data.mux.group = group; 445 (*map)[n].data.mux.function = function; 446 n++; 447 } 448 449 *num_maps = nmaps; 450 451 return 0; 452} 453 454static void mvebu_pinctrl_dt_free_map(struct pinctrl_dev *pctldev, 455 struct pinctrl_map *map, unsigned num_maps) 456{ 457 kfree(map); 458} 459 460static const struct pinctrl_ops mvebu_pinctrl_ops = { 461 .get_groups_count = mvebu_pinctrl_get_groups_count, 462 .get_group_name = mvebu_pinctrl_get_group_name, 463 .get_group_pins = mvebu_pinctrl_get_group_pins, 464 .dt_node_to_map = mvebu_pinctrl_dt_node_to_map, 465 .dt_free_map = mvebu_pinctrl_dt_free_map, 466}; 467 468static int _add_function(struct mvebu_pinctrl_function *funcs, int *funcsize, 469 const char *name) 470{ 471 if (*funcsize <= 0) 472 return -EOVERFLOW; 473 474 while (funcs->num_groups) { 475 /* function already there */ 476 if (strcmp(funcs->name, name) == 0) { 477 funcs->num_groups++; 478 return -EEXIST; 479 } 480 funcs++; 481 } 482 483 /* append new unique function */ 484 funcs->name = name; 485 funcs->num_groups = 1; 486 (*funcsize)--; 487 488 return 0; 489} 490 491static int mvebu_pinctrl_build_functions(struct platform_device *pdev, 492 struct mvebu_pinctrl *pctl) 493{ 494 struct mvebu_pinctrl_function *funcs; 495 int num = 0, funcsize = pctl->desc.npins; 496 int n, s; 497 498 /* we allocate functions for number of pins and hope 499 * there are fewer unique functions than pins available */ 500 funcs = devm_kcalloc(&pdev->dev, 501 funcsize, sizeof(struct mvebu_pinctrl_function), 502 GFP_KERNEL); 503 if (!funcs) 504 return -ENOMEM; 505 506 for (n = 0; n < pctl->num_groups; n++) { 507 struct mvebu_pinctrl_group *grp = &pctl->groups[n]; 508 for (s = 0; s < grp->num_settings; s++) { 509 int ret; 510 511 /* skip unsupported settings on this variant */ 512 if (pctl->variant && 513 !(pctl->variant & grp->settings[s].variant)) 514 continue; 515 516 /* check for unique functions and count groups */ 517 ret = _add_function(funcs, &funcsize, 518 grp->settings[s].name); 519 if (ret == -EOVERFLOW) 520 dev_err(&pdev->dev, 521 "More functions than pins(%d)\n", 522 pctl->desc.npins); 523 if (ret < 0) 524 continue; 525 526 num++; 527 } 528 } 529 530 pctl->num_functions = num; 531 pctl->functions = funcs; 532 533 for (n = 0; n < pctl->num_groups; n++) { 534 struct mvebu_pinctrl_group *grp = &pctl->groups[n]; 535 for (s = 0; s < grp->num_settings; s++) { 536 struct mvebu_pinctrl_function *f; 537 const char **groups; 538 539 /* skip unsupported settings on this variant */ 540 if (pctl->variant && 541 !(pctl->variant & grp->settings[s].variant)) 542 continue; 543 544 f = mvebu_pinctrl_find_function_by_name(pctl, 545 grp->settings[s].name); 546 547 /* allocate group name array if not done already */ 548 if (!f->groups) { 549 f->groups = devm_kcalloc(&pdev->dev, 550 f->num_groups, 551 sizeof(char *), 552 GFP_KERNEL); 553 if (!f->groups) 554 return -ENOMEM; 555 } 556 557 /* find next free group name and assign current name */ 558 groups = f->groups; 559 while (*groups) 560 groups++; 561 *groups = grp->name; 562 } 563 } 564 565 return 0; 566} 567 568int mvebu_pinctrl_probe(struct platform_device *pdev) 569{ 570 struct mvebu_pinctrl_soc_info *soc = dev_get_platdata(&pdev->dev); 571 struct mvebu_pinctrl *pctl; 572 struct pinctrl_pin_desc *pdesc; 573 unsigned gid, n, k; 574 unsigned size, noname = 0; 575 char *noname_buf; 576 void *p; 577 int ret; 578 579 if (!soc || !soc->controls || !soc->modes) { 580 dev_err(&pdev->dev, "wrong pinctrl soc info\n"); 581 return -EINVAL; 582 } 583 584 pctl = devm_kzalloc(&pdev->dev, sizeof(struct mvebu_pinctrl), 585 GFP_KERNEL); 586 if (!pctl) 587 return -ENOMEM; 588 589 pctl->desc.name = dev_name(&pdev->dev); 590 pctl->desc.owner = THIS_MODULE; 591 pctl->desc.pctlops = &mvebu_pinctrl_ops; 592 pctl->desc.pmxops = &mvebu_pinmux_ops; 593 pctl->desc.confops = &mvebu_pinconf_ops; 594 pctl->variant = soc->variant; 595 pctl->dev = &pdev->dev; 596 platform_set_drvdata(pdev, pctl); 597 598 /* count controls and create names for mvebu generic 599 register controls; also does sanity checks */ 600 pctl->num_groups = 0; 601 pctl->desc.npins = 0; 602 for (n = 0; n < soc->ncontrols; n++) { 603 const struct mvebu_mpp_ctrl *ctrl = &soc->controls[n]; 604 605 pctl->desc.npins += ctrl->npins; 606 /* initialize control's pins[] array */ 607 for (k = 0; k < ctrl->npins; k++) 608 ctrl->pins[k] = ctrl->pid + k; 609 610 /* 611 * We allow to pass controls with NULL name that we treat 612 * as a range of one-pin groups with generic mvebu register 613 * controls. 614 */ 615 if (!ctrl->name) { 616 pctl->num_groups += ctrl->npins; 617 noname += ctrl->npins; 618 } else { 619 pctl->num_groups += 1; 620 } 621 } 622 623 pdesc = devm_kcalloc(&pdev->dev, 624 pctl->desc.npins, 625 sizeof(struct pinctrl_pin_desc), 626 GFP_KERNEL); 627 if (!pdesc) 628 return -ENOMEM; 629 630 for (n = 0; n < pctl->desc.npins; n++) 631 pdesc[n].number = n; 632 pctl->desc.pins = pdesc; 633 634 /* 635 * allocate groups and name buffers for unnamed groups. 636 */ 637 size = pctl->num_groups * sizeof(*pctl->groups) + noname * 8; 638 p = devm_kzalloc(&pdev->dev, size, GFP_KERNEL); 639 if (!p) 640 return -ENOMEM; 641 642 pctl->groups = p; 643 noname_buf = p + pctl->num_groups * sizeof(*pctl->groups); 644 645 /* assign mpp controls to groups */ 646 gid = 0; 647 for (n = 0; n < soc->ncontrols; n++) { 648 const struct mvebu_mpp_ctrl *ctrl = &soc->controls[n]; 649 struct mvebu_mpp_ctrl_data *data = soc->control_data ? 650 &soc->control_data[n] : NULL; 651 652 pctl->groups[gid].gid = gid; 653 pctl->groups[gid].ctrl = ctrl; 654 pctl->groups[gid].data = data; 655 pctl->groups[gid].name = ctrl->name; 656 pctl->groups[gid].pins = ctrl->pins; 657 pctl->groups[gid].npins = ctrl->npins; 658 659 /* 660 * We treat unnamed controls as a range of one-pin groups 661 * with generic mvebu register controls. Use one group for 662 * each in this range and assign a default group name. 663 */ 664 if (!ctrl->name) { 665 pctl->groups[gid].name = noname_buf; 666 pctl->groups[gid].npins = 1; 667 sprintf(noname_buf, "mpp%d", ctrl->pid+0); 668 noname_buf += 8; 669 670 for (k = 1; k < ctrl->npins; k++) { 671 gid++; 672 pctl->groups[gid].gid = gid; 673 pctl->groups[gid].ctrl = ctrl; 674 pctl->groups[gid].data = data; 675 pctl->groups[gid].name = noname_buf; 676 pctl->groups[gid].pins = &ctrl->pins[k]; 677 pctl->groups[gid].npins = 1; 678 sprintf(noname_buf, "mpp%d", ctrl->pid+k); 679 noname_buf += 8; 680 } 681 } 682 gid++; 683 } 684 685 /* assign mpp modes to groups */ 686 for (n = 0; n < soc->nmodes; n++) { 687 struct mvebu_mpp_mode *mode = &soc->modes[n]; 688 struct mvebu_mpp_ctrl_setting *set = &mode->settings[0]; 689 struct mvebu_pinctrl_group *grp; 690 unsigned num_settings; 691 unsigned supp_settings; 692 693 for (num_settings = 0, supp_settings = 0; ; set++) { 694 if (!set->name) 695 break; 696 697 num_settings++; 698 699 /* skip unsupported settings for this variant */ 700 if (pctl->variant && !(pctl->variant & set->variant)) 701 continue; 702 703 supp_settings++; 704 705 /* find gpio/gpo/gpi settings */ 706 if (strcmp(set->name, "gpio") == 0) 707 set->flags = MVEBU_SETTING_GPI | 708 MVEBU_SETTING_GPO; 709 else if (strcmp(set->name, "gpo") == 0) 710 set->flags = MVEBU_SETTING_GPO; 711 else if (strcmp(set->name, "gpi") == 0) 712 set->flags = MVEBU_SETTING_GPI; 713 } 714 715 /* skip modes with no settings for this variant */ 716 if (!supp_settings) 717 continue; 718 719 grp = mvebu_pinctrl_find_group_by_pid(pctl, mode->pid); 720 if (!grp) { 721 dev_warn(&pdev->dev, "unknown pinctrl group %d\n", 722 mode->pid); 723 continue; 724 } 725 726 grp->settings = mode->settings; 727 grp->num_settings = num_settings; 728 } 729 730 ret = mvebu_pinctrl_build_functions(pdev, pctl); 731 if (ret) { 732 dev_err(&pdev->dev, "unable to build functions\n"); 733 return ret; 734 } 735 736 pctl->pctldev = devm_pinctrl_register(&pdev->dev, &pctl->desc, pctl); 737 if (IS_ERR(pctl->pctldev)) { 738 dev_err(&pdev->dev, "unable to register pinctrl driver\n"); 739 return PTR_ERR(pctl->pctldev); 740 } 741 742 dev_info(&pdev->dev, "registered pinctrl driver\n"); 743 744 /* register gpio ranges */ 745 for (n = 0; n < soc->ngpioranges; n++) 746 pinctrl_add_gpio_range(pctl->pctldev, &soc->gpioranges[n]); 747 748 return 0; 749} 750 751/* 752 * mvebu_pinctrl_simple_mmio_probe - probe a simple mmio pinctrl 753 * @pdev: platform device (with platform data already attached) 754 * 755 * Initialise a simple (single base address) mmio pinctrl driver, 756 * assigning the MMIO base address to all mvebu mpp ctrl instances. 757 */ 758int mvebu_pinctrl_simple_mmio_probe(struct platform_device *pdev) 759{ 760 struct mvebu_pinctrl_soc_info *soc = dev_get_platdata(&pdev->dev); 761 struct mvebu_mpp_ctrl_data *mpp_data; 762 void __iomem *base; 763 int i; 764 765 base = devm_platform_ioremap_resource(pdev, 0); 766 if (IS_ERR(base)) 767 return PTR_ERR(base); 768 769 mpp_data = devm_kcalloc(&pdev->dev, soc->ncontrols, sizeof(*mpp_data), 770 GFP_KERNEL); 771 if (!mpp_data) 772 return -ENOMEM; 773 774 for (i = 0; i < soc->ncontrols; i++) 775 mpp_data[i].base = base; 776 777 soc->control_data = mpp_data; 778 779 return mvebu_pinctrl_probe(pdev); 780} 781 782int mvebu_regmap_mpp_ctrl_get(struct mvebu_mpp_ctrl_data *data, 783 unsigned int pid, unsigned long *config) 784{ 785 unsigned off = (pid / MVEBU_MPPS_PER_REG) * MVEBU_MPP_BITS; 786 unsigned shift = (pid % MVEBU_MPPS_PER_REG) * MVEBU_MPP_BITS; 787 unsigned int val; 788 int err; 789 790 err = regmap_read(data->regmap.map, data->regmap.offset + off, &val); 791 if (err) 792 return err; 793 794 *config = (val >> shift) & MVEBU_MPP_MASK; 795 796 return 0; 797} 798 799int mvebu_regmap_mpp_ctrl_set(struct mvebu_mpp_ctrl_data *data, 800 unsigned int pid, unsigned long config) 801{ 802 unsigned off = (pid / MVEBU_MPPS_PER_REG) * MVEBU_MPP_BITS; 803 unsigned shift = (pid % MVEBU_MPPS_PER_REG) * MVEBU_MPP_BITS; 804 805 return regmap_update_bits(data->regmap.map, data->regmap.offset + off, 806 MVEBU_MPP_MASK << shift, config << shift); 807} 808 809int mvebu_pinctrl_simple_regmap_probe(struct platform_device *pdev, 810 struct device *syscon_dev, u32 offset) 811{ 812 struct mvebu_pinctrl_soc_info *soc = dev_get_platdata(&pdev->dev); 813 struct mvebu_mpp_ctrl_data *mpp_data; 814 struct regmap *regmap; 815 int i; 816 817 regmap = syscon_node_to_regmap(syscon_dev->of_node); 818 if (IS_ERR(regmap)) 819 return PTR_ERR(regmap); 820 821 mpp_data = devm_kcalloc(&pdev->dev, soc->ncontrols, sizeof(*mpp_data), 822 GFP_KERNEL); 823 if (!mpp_data) 824 return -ENOMEM; 825 826 for (i = 0; i < soc->ncontrols; i++) { 827 mpp_data[i].regmap.map = regmap; 828 mpp_data[i].regmap.offset = offset; 829 } 830 831 soc->control_data = mpp_data; 832 833 return mvebu_pinctrl_probe(pdev); 834} 835