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