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