drivers/pinctrl/mvebu/pinctrl-mvebu.c

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