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         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_printf(s, "(");
 192                         if (curr->flags & MVEBU_SETTING_GPI)
 193                                 seq_printf(s, "i");
 194                         if (curr->flags & MVEBU_SETTING_GPO)
 195                                 seq_printf(s, "o");
 196                         seq_printf(s, ")");
 197                 }
 198         } else
 199                 seq_printf(s, "current: UNKNOWN");
 200
 201         if (grp->num_settings > 1) {
 202                 seq_printf(s, ", available = [");
 203                 for (n = 0; n < grp->num_settings; n++) {
 204                         if (curr == &grp->settings[n])
 205                                 continue;
 206
 207                         /* skip unsupported settings for this variant */
 208                         if (pctl->variant &&
 209                             !(pctl->variant & grp->settings[n].variant))
 210                                 continue;
 211
 212                         seq_printf(s, " %s", grp->settings[n].name);
 213                         if (grp->settings[n].subname)
 214                                 seq_printf(s, "(%s)", grp->settings[n].subname);
 215                         if (grp->settings[n].flags &
 216                                 (MVEBU_SETTING_GPO | MVEBU_SETTING_GPI)) {
 217                                 seq_printf(s, "(");
 218                                 if (grp->settings[n].flags & MVEBU_SETTING_GPI)
 219                                         seq_printf(s, "i");
 220                                 if (grp->settings[n].flags & MVEBU_SETTING_GPO)
 221                                         seq_printf(s, "o");
 222                                 seq_printf(s, ")");
 223                         }
 224                 }
 225                 seq_printf(s, " ]");
 226         }
 227         return;
 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(nmaps * sizeof(struct pinctrl_map), GFP_KERNEL);
 402         if (*map == NULL) {
 403                 dev_err(pctl->dev,
 404                         "cannot allocate pinctrl_map memory for %s\n",
 405                         np->name);
 406                 return -ENOMEM;
 407         }
 408
 409         n = 0;
 410         of_property_for_each_string(np, "marvell,pins", prop, group) {
 411                 struct mvebu_pinctrl_group *grp =
 412                         mvebu_pinctrl_find_group_by_name(pctl, group);
 413
 414                 if (!grp) {
 415                         dev_err(pctl->dev, "unknown pin %s", group);
 416                         continue;
 417                 }
 418
 419                 if (!mvebu_pinctrl_find_setting_by_name(pctl, grp, function)) {
 420                         dev_err(pctl->dev, "unsupported function %s on pin %s",
 421                                 function, group);
 422                         continue;
 423                 }
 424
 425                 (*map)[n].type = PIN_MAP_TYPE_MUX_GROUP;
 426                 (*map)[n].data.mux.group = group;
 427                 (*map)[n].data.mux.function = function;
 428                 n++;
 429         }
 430
 431         *num_maps = nmaps;
 432
 433         return 0;
 434 }
 435
 436 static void mvebu_pinctrl_dt_free_map(struct pinctrl_dev *pctldev,
 437                                 struct pinctrl_map *map, unsigned num_maps)
 438 {
 439         kfree(map);
 440 }
 441
 442 static const struct pinctrl_ops mvebu_pinctrl_ops = {
 443         .get_groups_count = mvebu_pinctrl_get_groups_count,
 444         .get_group_name = mvebu_pinctrl_get_group_name,
 445         .get_group_pins = mvebu_pinctrl_get_group_pins,
 446         .dt_node_to_map = mvebu_pinctrl_dt_node_to_map,
 447         .dt_free_map = mvebu_pinctrl_dt_free_map,
 448 };
 449
 450 static int _add_function(struct mvebu_pinctrl_function *funcs, int *funcsize,
 451                         const char *name)
 452 {
 453         if (*funcsize <= 0)
 454                 return -EOVERFLOW;
 455
 456         while (funcs->num_groups) {
 457                 /* function already there */
 458                 if (strcmp(funcs->name, name) == 0) {
 459                         funcs->num_groups++;
 460                         return -EEXIST;
 461                 }
 462                 funcs++;
 463         }
 464
 465         /* append new unique function */
 466         funcs->name = name;
 467         funcs->num_groups = 1;
 468         (*funcsize)--;
 469
 470         return 0;
 471 }
 472
 473 static int mvebu_pinctrl_build_functions(struct platform_device *pdev,
 474                                          struct mvebu_pinctrl *pctl)
 475 {
 476         struct mvebu_pinctrl_function *funcs;
 477         int num = 0, funcsize = pctl->desc.npins;
 478         int n, s;
 479
 480         /* we allocate functions for number of pins and hope
 481          * there are fewer unique functions than pins available */
 482         funcs = devm_kzalloc(&pdev->dev, funcsize *
 483                              sizeof(struct mvebu_pinctrl_function), GFP_KERNEL);
 484         if (!funcs)
 485                 return -ENOMEM;
 486
 487         for (n = 0; n < pctl->num_groups; n++) {
 488                 struct mvebu_pinctrl_group *grp = &pctl->groups[n];
 489                 for (s = 0; s < grp->num_settings; s++) {
 490                         int ret;
 491
 492                         /* skip unsupported settings on this variant */
 493                         if (pctl->variant &&
 494                             !(pctl->variant & grp->settings[s].variant))
 495                                 continue;
 496
 497                         /* check for unique functions and count groups */
 498                         ret = _add_function(funcs, &funcsize,
 499                                             grp->settings[s].name);
 500                         if (ret == -EOVERFLOW)
 501                                 dev_err(&pdev->dev,
 502                                         "More functions than pins(%d)\n",
 503                                         pctl->desc.npins);
 504                         if (ret < 0)
 505                                 continue;
 506
 507                         num++;
 508                 }
 509         }
 510
 511         pctl->num_functions = num;
 512         pctl->functions = funcs;
 513
 514         for (n = 0; n < pctl->num_groups; n++) {
 515                 struct mvebu_pinctrl_group *grp = &pctl->groups[n];
 516                 for (s = 0; s < grp->num_settings; s++) {
 517                         struct mvebu_pinctrl_function *f;
 518                         const char **groups;
 519
 520                         /* skip unsupported settings on this variant */
 521                         if (pctl->variant &&
 522                             !(pctl->variant & grp->settings[s].variant))
 523                                 continue;
 524
 525                         f = mvebu_pinctrl_find_function_by_name(pctl,
 526                                                         grp->settings[s].name);
 527
 528                         /* allocate group name array if not done already */
 529                         if (!f->groups) {
 530                                 f->groups = devm_kzalloc(&pdev->dev,
 531                                                  f->num_groups * sizeof(char *),
 532                                                  GFP_KERNEL);
 533                                 if (!f->groups)
 534                                         return -ENOMEM;
 535                         }
 536
 537                         /* find next free group name and assign current name */
 538                         groups = f->groups;
 539                         while (*groups)
 540                                 groups++;
 541                         *groups = grp->name;
 542                 }
 543         }
 544
 545         return 0;
 546 }
 547
 548 int mvebu_pinctrl_probe(struct platform_device *pdev)
 549 {
 550         struct mvebu_pinctrl_soc_info *soc = dev_get_platdata(&pdev->dev);
 551         struct mvebu_pinctrl *pctl;
 552         struct pinctrl_pin_desc *pdesc;
 553         unsigned gid, n, k;
 554         unsigned size, noname = 0;
 555         char *noname_buf;
 556         void *p;
 557         int ret;
 558
 559         if (!soc || !soc->controls || !soc->modes) {
 560                 dev_err(&pdev->dev, "wrong pinctrl soc info\n");
 561                 return -EINVAL;
 562         }
 563
 564         pctl = devm_kzalloc(&pdev->dev, sizeof(struct mvebu_pinctrl),
 565                         GFP_KERNEL);
 566         if (!pctl) {
 567                 dev_err(&pdev->dev, "unable to alloc driver\n");
 568                 return -ENOMEM;
 569         }
 570
 571         pctl->desc.name = dev_name(&pdev->dev);
 572         pctl->desc.owner = THIS_MODULE;
 573         pctl->desc.pctlops = &mvebu_pinctrl_ops;
 574         pctl->desc.pmxops = &mvebu_pinmux_ops;
 575         pctl->desc.confops = &mvebu_pinconf_ops;
 576         pctl->variant = soc->variant;
 577         pctl->dev = &pdev->dev;
 578         platform_set_drvdata(pdev, pctl);
 579
 580         /* count controls and create names for mvebu generic
 581            register controls; also does sanity checks */
 582         pctl->num_groups = 0;
 583         pctl->desc.npins = 0;
 584         for (n = 0; n < soc->ncontrols; n++) {
 585                 struct mvebu_mpp_ctrl *ctrl = &soc->controls[n];
 586
 587                 pctl->desc.npins += ctrl->npins;
 588                 /* initialize control's pins[] array */
 589                 for (k = 0; k < ctrl->npins; k++)
 590                         ctrl->pins[k] = ctrl->pid + k;
 591
 592                 /*
 593                  * We allow to pass controls with NULL name that we treat
 594                  * as a range of one-pin groups with generic mvebu register
 595                  * controls.
 596                  */
 597                 if (!ctrl->name) {
 598                         pctl->num_groups += ctrl->npins;
 599                         noname += ctrl->npins;
 600                 } else {
 601                         pctl->num_groups += 1;
 602                 }
 603         }
 604
 605         pdesc = devm_kzalloc(&pdev->dev, pctl->desc.npins *
 606                              sizeof(struct pinctrl_pin_desc), GFP_KERNEL);
 607         if (!pdesc) {
 608                 dev_err(&pdev->dev, "failed to alloc pinctrl pins\n");
 609                 return -ENOMEM;
 610         }
 611
 612         for (n = 0; n < pctl->desc.npins; n++)
 613                 pdesc[n].number = n;
 614         pctl->desc.pins = pdesc;
 615
 616         /*
 617          * allocate groups and name buffers for unnamed groups.
 618          */
 619         size = pctl->num_groups * sizeof(*pctl->groups) + noname * 8;
 620         p = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
 621         if (!p) {
 622                 dev_err(&pdev->dev, "failed to alloc group data\n");
 623                 return -ENOMEM;
 624         }
 625         pctl->groups = p;
 626         noname_buf = p + pctl->num_groups * sizeof(*pctl->groups);
 627
 628         /* assign mpp controls to groups */
 629         gid = 0;
 630         for (n = 0; n < soc->ncontrols; n++) {
 631                 struct mvebu_mpp_ctrl *ctrl = &soc->controls[n];
 632                 pctl->groups[gid].gid = gid;
 633                 pctl->groups[gid].ctrl = ctrl;
 634                 pctl->groups[gid].name = ctrl->name;
 635                 pctl->groups[gid].pins = ctrl->pins;
 636                 pctl->groups[gid].npins = ctrl->npins;
 637
 638                 /*
 639                  * We treat unnamed controls as a range of one-pin groups
 640                  * with generic mvebu register controls. Use one group for
 641                  * each in this range and assign a default group name.
 642                  */
 643                 if (!ctrl->name) {
 644                         pctl->groups[gid].name = noname_buf;
 645                         pctl->groups[gid].npins = 1;
 646                         sprintf(noname_buf, "mpp%d", ctrl->pid+0);
 647                         noname_buf += 8;
 648
 649                         for (k = 1; k < ctrl->npins; k++) {
 650                                 gid++;
 651                                 pctl->groups[gid].gid = gid;
 652                                 pctl->groups[gid].ctrl = ctrl;
 653                                 pctl->groups[gid].name = noname_buf;
 654                                 pctl->groups[gid].pins = &ctrl->pins[k];
 655                                 pctl->groups[gid].npins = 1;
 656                                 sprintf(noname_buf, "mpp%d", ctrl->pid+k);
 657                                 noname_buf += 8;
 658                         }
 659                 }
 660                 gid++;
 661         }
 662
 663         /* assign mpp modes to groups */
 664         for (n = 0; n < soc->nmodes; n++) {
 665                 struct mvebu_mpp_mode *mode = &soc->modes[n];
 666                 struct mvebu_mpp_ctrl_setting *set = &mode->settings[0];
 667                 struct mvebu_pinctrl_group *grp;
 668                 unsigned num_settings;
 669
 670                 for (num_settings = 0; ; set++) {
 671                         if (!set->name)
 672                                 break;
 673
 674                         /* skip unsupported settings for this variant */
 675                         if (pctl->variant && !(pctl->variant & set->variant))
 676                                 continue;
 677
 678                         num_settings++;
 679
 680                         /* find gpio/gpo/gpi settings */
 681                         if (strcmp(set->name, "gpio") == 0)
 682                                 set->flags = MVEBU_SETTING_GPI |
 683                                         MVEBU_SETTING_GPO;
 684                         else if (strcmp(set->name, "gpo") == 0)
 685                                 set->flags = MVEBU_SETTING_GPO;
 686                         else if (strcmp(set->name, "gpi") == 0)
 687                                 set->flags = MVEBU_SETTING_GPI;
 688                 }
 689
 690                 /* skip modes with no settings for this variant */
 691                 if (!num_settings)
 692                         continue;
 693
 694                 grp = mvebu_pinctrl_find_group_by_pid(pctl, mode->pid);
 695                 if (!grp) {
 696                         dev_warn(&pdev->dev, "unknown pinctrl group %d\n",
 697                                 mode->pid);
 698                         continue;
 699                 }
 700
 701                 grp->settings = mode->settings;
 702                 grp->num_settings = num_settings;
 703         }
 704
 705         ret = mvebu_pinctrl_build_functions(pdev, pctl);
 706         if (ret) {
 707                 dev_err(&pdev->dev, "unable to build functions\n");
 708                 return ret;
 709         }
 710
 711         pctl->pctldev = pinctrl_register(&pctl->desc, &pdev->dev, pctl);
 712         if (IS_ERR(pctl->pctldev)) {
 713                 dev_err(&pdev->dev, "unable to register pinctrl driver\n");
 714                 return PTR_ERR(pctl->pctldev);
 715         }
 716
 717         dev_info(&pdev->dev, "registered pinctrl driver\n");
 718
 719         /* register gpio ranges */
 720         for (n = 0; n < soc->ngpioranges; n++)
 721                 pinctrl_add_gpio_range(pctl->pctldev, &soc->gpioranges[n]);
 722
 723         return 0;
 724 }
 725
 726 int mvebu_pinctrl_remove(struct platform_device *pdev)
 727 {
 728         struct mvebu_pinctrl *pctl = platform_get_drvdata(pdev);
 729         pinctrl_unregister(pctl->pctldev);
 730         return 0;
 731 }