drivers/pinctrl/samsung/pinctrl-samsung.c

   1 /*
   2  * pin-controller/pin-mux/pin-config/gpio-driver for Samsung's SoC's.
   3  *
   4  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
   5  *              http://www.samsung.com
   6  * Copyright (c) 2012 Linaro Ltd
   7  *              http://www.linaro.org
   8  *
   9  * Author: Thomas Abraham <thomas.ab@samsung.com>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This driver implements the Samsung pinctrl driver. It supports setting up of
  17  * pinmux and pinconf configurations. The gpiolib interface is also included.
  18  * External interrupt (gpio and wakeup) support are not included in this driver
  19  * but provides extensions to which platform specific implementation of the gpio
  20  * and wakeup interrupts can be hooked to.
  21  */
  22
  23 #include <linux/init.h>
  24 #include <linux/platform_device.h>
  25 #include <linux/io.h>
  26 #include <linux/slab.h>
  27 #include <linux/err.h>
  28 #include <linux/gpio.h>
  29 #include <linux/irqdomain.h>
  30 #include <linux/of_device.h>
  31 #include <linux/spinlock.h>
  32
  33 #include <dt-bindings/pinctrl/samsung.h>
  34
  35 #include "../core.h"
  36 #include "pinctrl-samsung.h"
  37
  38 /* maximum number of the memory resources */
  39 #define SAMSUNG_PINCTRL_NUM_RESOURCES   2
  40
  41 /* list of all possible config options supported */
  42 static struct pin_config {
  43         const char *property;
  44         enum pincfg_type param;
  45 } cfg_params[] = {
  46         { "samsung,pin-pud", PINCFG_TYPE_PUD },
  47         { "samsung,pin-drv", PINCFG_TYPE_DRV },
  48         { "samsung,pin-con-pdn", PINCFG_TYPE_CON_PDN },
  49         { "samsung,pin-pud-pdn", PINCFG_TYPE_PUD_PDN },
  50         { "samsung,pin-val", PINCFG_TYPE_DAT },
  51 };
  52
  53 static unsigned int pin_base;
  54
  55 static int samsung_get_group_count(struct pinctrl_dev *pctldev)
  56 {
  57         struct samsung_pinctrl_drv_data *pmx = pinctrl_dev_get_drvdata(pctldev);
  58
  59         return pmx->nr_groups;
  60 }
  61
  62 static const char *samsung_get_group_name(struct pinctrl_dev *pctldev,
  63                                                 unsigned group)
  64 {
  65         struct samsung_pinctrl_drv_data *pmx = pinctrl_dev_get_drvdata(pctldev);
  66
  67         return pmx->pin_groups[group].name;
  68 }
  69
  70 static int samsung_get_group_pins(struct pinctrl_dev *pctldev,
  71                                         unsigned group,
  72                                         const unsigned **pins,
  73                                         unsigned *num_pins)
  74 {
  75         struct samsung_pinctrl_drv_data *pmx = pinctrl_dev_get_drvdata(pctldev);
  76
  77         *pins = pmx->pin_groups[group].pins;
  78         *num_pins = pmx->pin_groups[group].num_pins;
  79
  80         return 0;
  81 }
  82
  83 static int reserve_map(struct device *dev, struct pinctrl_map **map,
  84                        unsigned *reserved_maps, unsigned *num_maps,
  85                        unsigned reserve)
  86 {
  87         unsigned old_num = *reserved_maps;
  88         unsigned new_num = *num_maps + reserve;
  89         struct pinctrl_map *new_map;
  90
  91         if (old_num >= new_num)
  92                 return 0;
  93
  94         new_map = krealloc(*map, sizeof(*new_map) * new_num, GFP_KERNEL);
  95         if (!new_map)
  96                 return -ENOMEM;
  97
  98         memset(new_map + old_num, 0, (new_num - old_num) * sizeof(*new_map));
  99
 100         *map = new_map;
 101         *reserved_maps = new_num;
 102
 103         return 0;
 104 }
 105
 106 static int add_map_mux(struct pinctrl_map **map, unsigned *reserved_maps,
 107                        unsigned *num_maps, const char *group,
 108                        const char *function)
 109 {
 110         if (WARN_ON(*num_maps == *reserved_maps))
 111                 return -ENOSPC;
 112
 113         (*map)[*num_maps].type = PIN_MAP_TYPE_MUX_GROUP;
 114         (*map)[*num_maps].data.mux.group = group;
 115         (*map)[*num_maps].data.mux.function = function;
 116         (*num_maps)++;
 117
 118         return 0;
 119 }
 120
 121 static int add_map_configs(struct device *dev, struct pinctrl_map **map,
 122                            unsigned *reserved_maps, unsigned *num_maps,
 123                            const char *group, unsigned long *configs,
 124                            unsigned num_configs)
 125 {
 126         unsigned long *dup_configs;
 127
 128         if (WARN_ON(*num_maps == *reserved_maps))
 129                 return -ENOSPC;
 130
 131         dup_configs = kmemdup(configs, num_configs * sizeof(*dup_configs),
 132                               GFP_KERNEL);
 133         if (!dup_configs)
 134                 return -ENOMEM;
 135
 136         (*map)[*num_maps].type = PIN_MAP_TYPE_CONFIGS_GROUP;
 137         (*map)[*num_maps].data.configs.group_or_pin = group;
 138         (*map)[*num_maps].data.configs.configs = dup_configs;
 139         (*map)[*num_maps].data.configs.num_configs = num_configs;
 140         (*num_maps)++;
 141
 142         return 0;
 143 }
 144
 145 static int add_config(struct device *dev, unsigned long **configs,
 146                       unsigned *num_configs, unsigned long config)
 147 {
 148         unsigned old_num = *num_configs;
 149         unsigned new_num = old_num + 1;
 150         unsigned long *new_configs;
 151
 152         new_configs = krealloc(*configs, sizeof(*new_configs) * new_num,
 153                                GFP_KERNEL);
 154         if (!new_configs)
 155                 return -ENOMEM;
 156
 157         new_configs[old_num] = config;
 158
 159         *configs = new_configs;
 160         *num_configs = new_num;
 161
 162         return 0;
 163 }
 164
 165 static void samsung_dt_free_map(struct pinctrl_dev *pctldev,
 166                                       struct pinctrl_map *map,
 167                                       unsigned num_maps)
 168 {
 169         int i;
 170
 171         for (i = 0; i < num_maps; i++)
 172                 if (map[i].type == PIN_MAP_TYPE_CONFIGS_GROUP)
 173                         kfree(map[i].data.configs.configs);
 174
 175         kfree(map);
 176 }
 177
 178 static int samsung_dt_subnode_to_map(struct samsung_pinctrl_drv_data *drvdata,
 179                                      struct device *dev,
 180                                      struct device_node *np,
 181                                      struct pinctrl_map **map,
 182                                      unsigned *reserved_maps,
 183                                      unsigned *num_maps)
 184 {
 185         int ret, i;
 186         u32 val;
 187         unsigned long config;
 188         unsigned long *configs = NULL;
 189         unsigned num_configs = 0;
 190         unsigned reserve;
 191         struct property *prop;
 192         const char *group;
 193         bool has_func = false;
 194
 195         ret = of_property_read_u32(np, "samsung,pin-function", &val);
 196         if (!ret)
 197                 has_func = true;
 198
 199         for (i = 0; i < ARRAY_SIZE(cfg_params); i++) {
 200                 ret = of_property_read_u32(np, cfg_params[i].property, &val);
 201                 if (!ret) {
 202                         config = PINCFG_PACK(cfg_params[i].param, val);
 203                         ret = add_config(dev, &configs, &num_configs, config);
 204                         if (ret < 0)
 205                                 goto exit;
 206                 /* EINVAL=missing, which is fine since it's optional */
 207                 } else if (ret != -EINVAL) {
 208                         dev_err(dev, "could not parse property %s\n",
 209                                 cfg_params[i].property);
 210                 }
 211         }
 212
 213         reserve = 0;
 214         if (has_func)
 215                 reserve++;
 216         if (num_configs)
 217                 reserve++;
 218         ret = of_property_count_strings(np, "samsung,pins");
 219         if (ret < 0) {
 220                 dev_err(dev, "could not parse property samsung,pins\n");
 221                 goto exit;
 222         }
 223         reserve *= ret;
 224
 225         ret = reserve_map(dev, map, reserved_maps, num_maps, reserve);
 226         if (ret < 0)
 227                 goto exit;
 228
 229         of_property_for_each_string(np, "samsung,pins", prop, group) {
 230                 if (has_func) {
 231                         ret = add_map_mux(map, reserved_maps,
 232                                                 num_maps, group, np->full_name);
 233                         if (ret < 0)
 234                                 goto exit;
 235                 }
 236
 237                 if (num_configs) {
 238                         ret = add_map_configs(dev, map, reserved_maps,
 239                                               num_maps, group, configs,
 240                                               num_configs);
 241                         if (ret < 0)
 242                                 goto exit;
 243                 }
 244         }
 245
 246         ret = 0;
 247
 248 exit:
 249         kfree(configs);
 250         return ret;
 251 }
 252
 253 static int samsung_dt_node_to_map(struct pinctrl_dev *pctldev,
 254                                         struct device_node *np_config,
 255                                         struct pinctrl_map **map,
 256                                         unsigned *num_maps)
 257 {
 258         struct samsung_pinctrl_drv_data *drvdata;
 259         unsigned reserved_maps;
 260         struct device_node *np;
 261         int ret;
 262
 263         drvdata = pinctrl_dev_get_drvdata(pctldev);
 264
 265         reserved_maps = 0;
 266         *map = NULL;
 267         *num_maps = 0;
 268
 269         if (!of_get_child_count(np_config))
 270                 return samsung_dt_subnode_to_map(drvdata, pctldev->dev,
 271                                                         np_config, map,
 272                                                         &reserved_maps,
 273                                                         num_maps);
 274
 275         for_each_child_of_node(np_config, np) {
 276                 ret = samsung_dt_subnode_to_map(drvdata, pctldev->dev, np, map,
 277                                                 &reserved_maps, num_maps);
 278                 if (ret < 0) {
 279                         samsung_dt_free_map(pctldev, *map, *num_maps);
 280                         return ret;
 281                 }
 282         }
 283
 284         return 0;
 285 }
 286
 287 /* list of pinctrl callbacks for the pinctrl core */
 288 static const struct pinctrl_ops samsung_pctrl_ops = {
 289         .get_groups_count       = samsung_get_group_count,
 290         .get_group_name         = samsung_get_group_name,
 291         .get_group_pins         = samsung_get_group_pins,
 292         .dt_node_to_map         = samsung_dt_node_to_map,
 293         .dt_free_map            = samsung_dt_free_map,
 294 };
 295
 296 /* check if the selector is a valid pin function selector */
 297 static int samsung_get_functions_count(struct pinctrl_dev *pctldev)
 298 {
 299         struct samsung_pinctrl_drv_data *drvdata;
 300
 301         drvdata = pinctrl_dev_get_drvdata(pctldev);
 302         return drvdata->nr_functions;
 303 }
 304
 305 /* return the name of the pin function specified */
 306 static const char *samsung_pinmux_get_fname(struct pinctrl_dev *pctldev,
 307                                                 unsigned selector)
 308 {
 309         struct samsung_pinctrl_drv_data *drvdata;
 310
 311         drvdata = pinctrl_dev_get_drvdata(pctldev);
 312         return drvdata->pmx_functions[selector].name;
 313 }
 314
 315 /* return the groups associated for the specified function selector */
 316 static int samsung_pinmux_get_groups(struct pinctrl_dev *pctldev,
 317                 unsigned selector, const char * const **groups,
 318                 unsigned * const num_groups)
 319 {
 320         struct samsung_pinctrl_drv_data *drvdata;
 321
 322         drvdata = pinctrl_dev_get_drvdata(pctldev);
 323         *groups = drvdata->pmx_functions[selector].groups;
 324         *num_groups = drvdata->pmx_functions[selector].num_groups;
 325         return 0;
 326 }
 327
 328 /*
 329  * given a pin number that is local to a pin controller, find out the pin bank
 330  * and the register base of the pin bank.
 331  */
 332 static void pin_to_reg_bank(struct samsung_pinctrl_drv_data *drvdata,
 333                         unsigned pin, void __iomem **reg, u32 *offset,
 334                         struct samsung_pin_bank **bank)
 335 {
 336         struct samsung_pin_bank *b;
 337
 338         b = drvdata->pin_banks;
 339
 340         while ((pin >= b->pin_base) &&
 341                         ((b->pin_base + b->nr_pins - 1) < pin))
 342                 b++;
 343
 344         *reg = b->pctl_base + b->pctl_offset;
 345         *offset = pin - b->pin_base;
 346         if (bank)
 347                 *bank = b;
 348 }
 349
 350 /* enable or disable a pinmux function */
 351 static void samsung_pinmux_setup(struct pinctrl_dev *pctldev, unsigned selector,
 352                                         unsigned group)
 353 {
 354         struct samsung_pinctrl_drv_data *drvdata;
 355         const struct samsung_pin_bank_type *type;
 356         struct samsung_pin_bank *bank;
 357         void __iomem *reg;
 358         u32 mask, shift, data, pin_offset;
 359         unsigned long flags;
 360         const struct samsung_pmx_func *func;
 361         const struct samsung_pin_group *grp;
 362
 363         drvdata = pinctrl_dev_get_drvdata(pctldev);
 364         func = &drvdata->pmx_functions[selector];
 365         grp = &drvdata->pin_groups[group];
 366
 367         pin_to_reg_bank(drvdata, grp->pins[0] - drvdata->pin_base,
 368                         &reg, &pin_offset, &bank);
 369         type = bank->type;
 370         mask = (1 << type->fld_width[PINCFG_TYPE_FUNC]) - 1;
 371         shift = pin_offset * type->fld_width[PINCFG_TYPE_FUNC];
 372         if (shift >= 32) {
 373                 /* Some banks have two config registers */
 374                 shift -= 32;
 375                 reg += 4;
 376         }
 377
 378         spin_lock_irqsave(&bank->slock, flags);
 379
 380         data = readl(reg + type->reg_offset[PINCFG_TYPE_FUNC]);
 381         data &= ~(mask << shift);
 382         data |= func->val << shift;
 383         writel(data, reg + type->reg_offset[PINCFG_TYPE_FUNC]);
 384
 385         spin_unlock_irqrestore(&bank->slock, flags);
 386 }
 387
 388 /* enable a specified pinmux by writing to registers */
 389 static int samsung_pinmux_set_mux(struct pinctrl_dev *pctldev,
 390                                   unsigned selector,
 391                                   unsigned group)
 392 {
 393         samsung_pinmux_setup(pctldev, selector, group);
 394         return 0;
 395 }
 396
 397 /* list of pinmux callbacks for the pinmux vertical in pinctrl core */
 398 static const struct pinmux_ops samsung_pinmux_ops = {
 399         .get_functions_count    = samsung_get_functions_count,
 400         .get_function_name      = samsung_pinmux_get_fname,
 401         .get_function_groups    = samsung_pinmux_get_groups,
 402         .set_mux                = samsung_pinmux_set_mux,
 403 };
 404
 405 /* set or get the pin config settings for a specified pin */
 406 static int samsung_pinconf_rw(struct pinctrl_dev *pctldev, unsigned int pin,
 407                                 unsigned long *config, bool set)
 408 {
 409         struct samsung_pinctrl_drv_data *drvdata;
 410         const struct samsung_pin_bank_type *type;
 411         struct samsung_pin_bank *bank;
 412         void __iomem *reg_base;
 413         enum pincfg_type cfg_type = PINCFG_UNPACK_TYPE(*config);
 414         u32 data, width, pin_offset, mask, shift;
 415         u32 cfg_value, cfg_reg;
 416         unsigned long flags;
 417
 418         drvdata = pinctrl_dev_get_drvdata(pctldev);
 419         pin_to_reg_bank(drvdata, pin - drvdata->pin_base, &reg_base,
 420                                         &pin_offset, &bank);
 421         type = bank->type;
 422
 423         if (cfg_type >= PINCFG_TYPE_NUM || !type->fld_width[cfg_type])
 424                 return -EINVAL;
 425
 426         width = type->fld_width[cfg_type];
 427         cfg_reg = type->reg_offset[cfg_type];
 428
 429         spin_lock_irqsave(&bank->slock, flags);
 430
 431         mask = (1 << width) - 1;
 432         shift = pin_offset * width;
 433         data = readl(reg_base + cfg_reg);
 434
 435         if (set) {
 436                 cfg_value = PINCFG_UNPACK_VALUE(*config);
 437                 data &= ~(mask << shift);
 438                 data |= (cfg_value << shift);
 439                 writel(data, reg_base + cfg_reg);
 440         } else {
 441                 data >>= shift;
 442                 data &= mask;
 443                 *config = PINCFG_PACK(cfg_type, data);
 444         }
 445
 446         spin_unlock_irqrestore(&bank->slock, flags);
 447
 448         return 0;
 449 }
 450
 451 /* set the pin config settings for a specified pin */
 452 static int samsung_pinconf_set(struct pinctrl_dev *pctldev, unsigned int pin,
 453                                 unsigned long *configs, unsigned num_configs)
 454 {
 455         int i, ret;
 456
 457         for (i = 0; i < num_configs; i++) {
 458                 ret = samsung_pinconf_rw(pctldev, pin, &configs[i], true);
 459                 if (ret < 0)
 460                         return ret;
 461         } /* for each config */
 462
 463         return 0;
 464 }
 465
 466 /* get the pin config settings for a specified pin */
 467 static int samsung_pinconf_get(struct pinctrl_dev *pctldev, unsigned int pin,
 468                                         unsigned long *config)
 469 {
 470         return samsung_pinconf_rw(pctldev, pin, config, false);
 471 }
 472
 473 /* set the pin config settings for a specified pin group */
 474 static int samsung_pinconf_group_set(struct pinctrl_dev *pctldev,
 475                         unsigned group, unsigned long *configs,
 476                         unsigned num_configs)
 477 {
 478         struct samsung_pinctrl_drv_data *drvdata;
 479         const unsigned int *pins;
 480         unsigned int cnt;
 481
 482         drvdata = pinctrl_dev_get_drvdata(pctldev);
 483         pins = drvdata->pin_groups[group].pins;
 484
 485         for (cnt = 0; cnt < drvdata->pin_groups[group].num_pins; cnt++)
 486                 samsung_pinconf_set(pctldev, pins[cnt], configs, num_configs);
 487
 488         return 0;
 489 }
 490
 491 /* get the pin config settings for a specified pin group */
 492 static int samsung_pinconf_group_get(struct pinctrl_dev *pctldev,
 493                                 unsigned int group, unsigned long *config)
 494 {
 495         struct samsung_pinctrl_drv_data *drvdata;
 496         const unsigned int *pins;
 497
 498         drvdata = pinctrl_dev_get_drvdata(pctldev);
 499         pins = drvdata->pin_groups[group].pins;
 500         samsung_pinconf_get(pctldev, pins[0], config);
 501         return 0;
 502 }
 503
 504 /* list of pinconfig callbacks for pinconfig vertical in the pinctrl code */
 505 static const struct pinconf_ops samsung_pinconf_ops = {
 506         .pin_config_get         = samsung_pinconf_get,
 507         .pin_config_set         = samsung_pinconf_set,
 508         .pin_config_group_get   = samsung_pinconf_group_get,
 509         .pin_config_group_set   = samsung_pinconf_group_set,
 510 };
 511
 512 /*
 513  * The samsung_gpio_set_vlaue() should be called with "bank->slock" held
 514  * to avoid race condition.
 515  */
 516 static void samsung_gpio_set_value(struct gpio_chip *gc,
 517                                           unsigned offset, int value)
 518 {
 519         struct samsung_pin_bank *bank = gpiochip_get_data(gc);
 520         const struct samsung_pin_bank_type *type = bank->type;
 521         void __iomem *reg;
 522         u32 data;
 523
 524         reg = bank->pctl_base + bank->pctl_offset;
 525
 526         data = readl(reg + type->reg_offset[PINCFG_TYPE_DAT]);
 527         data &= ~(1 << offset);
 528         if (value)
 529                 data |= 1 << offset;
 530         writel(data, reg + type->reg_offset[PINCFG_TYPE_DAT]);
 531 }
 532
 533 /* gpiolib gpio_set callback function */
 534 static void samsung_gpio_set(struct gpio_chip *gc, unsigned offset, int value)
 535 {
 536         struct samsung_pin_bank *bank = gpiochip_get_data(gc);
 537         unsigned long flags;
 538
 539         spin_lock_irqsave(&bank->slock, flags);
 540         samsung_gpio_set_value(gc, offset, value);
 541         spin_unlock_irqrestore(&bank->slock, flags);
 542 }
 543
 544 /* gpiolib gpio_get callback function */
 545 static int samsung_gpio_get(struct gpio_chip *gc, unsigned offset)
 546 {
 547         void __iomem *reg;
 548         u32 data;
 549         struct samsung_pin_bank *bank = gpiochip_get_data(gc);
 550         const struct samsung_pin_bank_type *type = bank->type;
 551
 552         reg = bank->pctl_base + bank->pctl_offset;
 553
 554         data = readl(reg + type->reg_offset[PINCFG_TYPE_DAT]);
 555         data >>= offset;
 556         data &= 1;
 557         return data;
 558 }
 559
 560 /*
 561  * The samsung_gpio_set_direction() should be called with "bank->slock" held
 562  * to avoid race condition.
 563  * The calls to gpio_direction_output() and gpio_direction_input()
 564  * leads to this function call.
 565  */
 566 static int samsung_gpio_set_direction(struct gpio_chip *gc,
 567                                              unsigned offset, bool input)
 568 {
 569         const struct samsung_pin_bank_type *type;
 570         struct samsung_pin_bank *bank;
 571         void __iomem *reg;
 572         u32 data, mask, shift;
 573
 574         bank = gpiochip_get_data(gc);
 575         type = bank->type;
 576
 577         reg = bank->pctl_base + bank->pctl_offset
 578                         + type->reg_offset[PINCFG_TYPE_FUNC];
 579
 580         mask = (1 << type->fld_width[PINCFG_TYPE_FUNC]) - 1;
 581         shift = offset * type->fld_width[PINCFG_TYPE_FUNC];
 582         if (shift >= 32) {
 583                 /* Some banks have two config registers */
 584                 shift -= 32;
 585                 reg += 4;
 586         }
 587
 588         data = readl(reg);
 589         data &= ~(mask << shift);
 590         if (!input)
 591                 data |= EXYNOS_PIN_FUNC_OUTPUT << shift;
 592         writel(data, reg);
 593
 594         return 0;
 595 }
 596
 597 /* gpiolib gpio_direction_input callback function. */
 598 static int samsung_gpio_direction_input(struct gpio_chip *gc, unsigned offset)
 599 {
 600         struct samsung_pin_bank *bank = gpiochip_get_data(gc);
 601         unsigned long flags;
 602         int ret;
 603
 604         spin_lock_irqsave(&bank->slock, flags);
 605         ret = samsung_gpio_set_direction(gc, offset, true);
 606         spin_unlock_irqrestore(&bank->slock, flags);
 607         return ret;
 608 }
 609
 610 /* gpiolib gpio_direction_output callback function. */
 611 static int samsung_gpio_direction_output(struct gpio_chip *gc, unsigned offset,
 612                                                         int value)
 613 {
 614         struct samsung_pin_bank *bank = gpiochip_get_data(gc);
 615         unsigned long flags;
 616         int ret;
 617
 618         spin_lock_irqsave(&bank->slock, flags);
 619         samsung_gpio_set_value(gc, offset, value);
 620         ret = samsung_gpio_set_direction(gc, offset, false);
 621         spin_unlock_irqrestore(&bank->slock, flags);
 622
 623         return ret;
 624 }
 625
 626 /*
 627  * gpiolib gpio_to_irq callback function. Creates a mapping between a GPIO pin
 628  * and a virtual IRQ, if not already present.
 629  */
 630 static int samsung_gpio_to_irq(struct gpio_chip *gc, unsigned offset)
 631 {
 632         struct samsung_pin_bank *bank = gpiochip_get_data(gc);
 633         unsigned int virq;
 634
 635         if (!bank->irq_domain)
 636                 return -ENXIO;
 637
 638         virq = irq_create_mapping(bank->irq_domain, offset);
 639
 640         return (virq) ? : -ENXIO;
 641 }
 642
 643 static struct samsung_pin_group *samsung_pinctrl_create_groups(
 644                                 struct device *dev,
 645                                 struct samsung_pinctrl_drv_data *drvdata,
 646                                 unsigned int *cnt)
 647 {
 648         struct pinctrl_desc *ctrldesc = &drvdata->pctl;
 649         struct samsung_pin_group *groups, *grp;
 650         const struct pinctrl_pin_desc *pdesc;
 651         int i;
 652
 653         groups = devm_kzalloc(dev, ctrldesc->npins * sizeof(*groups),
 654                                 GFP_KERNEL);
 655         if (!groups)
 656                 return ERR_PTR(-EINVAL);
 657         grp = groups;
 658
 659         pdesc = ctrldesc->pins;
 660         for (i = 0; i < ctrldesc->npins; ++i, ++pdesc, ++grp) {
 661                 grp->name = pdesc->name;
 662                 grp->pins = &pdesc->number;
 663                 grp->num_pins = 1;
 664         }
 665
 666         *cnt = ctrldesc->npins;
 667         return groups;
 668 }
 669
 670 static int samsung_pinctrl_create_function(struct device *dev,
 671                                 struct samsung_pinctrl_drv_data *drvdata,
 672                                 struct device_node *func_np,
 673                                 struct samsung_pmx_func *func)
 674 {
 675         int npins;
 676         int ret;
 677         int i;
 678
 679         if (of_property_read_u32(func_np, "samsung,pin-function", &func->val))
 680                 return 0;
 681
 682         npins = of_property_count_strings(func_np, "samsung,pins");
 683         if (npins < 1) {
 684                 dev_err(dev, "invalid pin list in %pOFn node", func_np);
 685                 return -EINVAL;
 686         }
 687
 688         func->name = func_np->full_name;
 689
 690         func->groups = devm_kzalloc(dev, npins * sizeof(char *), GFP_KERNEL);
 691         if (!func->groups)
 692                 return -ENOMEM;
 693
 694         for (i = 0; i < npins; ++i) {
 695                 const char *gname;
 696
 697                 ret = of_property_read_string_index(func_np, "samsung,pins",
 698                                                         i, &gname);
 699                 if (ret) {
 700                         dev_err(dev,
 701                                 "failed to read pin name %d from %pOFn node\n",
 702                                 i, func_np);
 703                         return ret;
 704                 }
 705
 706                 func->groups[i] = gname;
 707         }
 708
 709         func->num_groups = npins;
 710         return 1;
 711 }
 712
 713 static struct samsung_pmx_func *samsung_pinctrl_create_functions(
 714                                 struct device *dev,
 715                                 struct samsung_pinctrl_drv_data *drvdata,
 716                                 unsigned int *cnt)
 717 {
 718         struct samsung_pmx_func *functions, *func;
 719         struct device_node *dev_np = dev->of_node;
 720         struct device_node *cfg_np;
 721         unsigned int func_cnt = 0;
 722         int ret;
 723
 724         /*
 725          * Iterate over all the child nodes of the pin controller node
 726          * and create pin groups and pin function lists.
 727          */
 728         for_each_child_of_node(dev_np, cfg_np) {
 729                 struct device_node *func_np;
 730
 731                 if (!of_get_child_count(cfg_np)) {
 732                         if (!of_find_property(cfg_np,
 733                             "samsung,pin-function", NULL))
 734                                 continue;
 735                         ++func_cnt;
 736                         continue;
 737                 }
 738
 739                 for_each_child_of_node(cfg_np, func_np) {
 740                         if (!of_find_property(func_np,
 741                             "samsung,pin-function", NULL))
 742                                 continue;
 743                         ++func_cnt;
 744                 }
 745         }
 746
 747         functions = devm_kzalloc(dev, func_cnt * sizeof(*functions),
 748                                         GFP_KERNEL);
 749         if (!functions)
 750                 return ERR_PTR(-ENOMEM);
 751         func = functions;
 752
 753         /*
 754          * Iterate over all the child nodes of the pin controller node
 755          * and create pin groups and pin function lists.
 756          */
 757         func_cnt = 0;
 758         for_each_child_of_node(dev_np, cfg_np) {
 759                 struct device_node *func_np;
 760
 761                 if (!of_get_child_count(cfg_np)) {
 762                         ret = samsung_pinctrl_create_function(dev, drvdata,
 763                                                         cfg_np, func);
 764                         if (ret < 0)
 765                                 return ERR_PTR(ret);
 766                         if (ret > 0) {
 767                                 ++func;
 768                                 ++func_cnt;
 769                         }
 770                         continue;
 771                 }
 772
 773                 for_each_child_of_node(cfg_np, func_np) {
 774                         ret = samsung_pinctrl_create_function(dev, drvdata,
 775                                                 func_np, func);
 776                         if (ret < 0)
 777                                 return ERR_PTR(ret);
 778                         if (ret > 0) {
 779                                 ++func;
 780                                 ++func_cnt;
 781                         }
 782                 }
 783         }
 784
 785         *cnt = func_cnt;
 786         return functions;
 787 }
 788
 789 /*
 790  * Parse the information about all the available pin groups and pin functions
 791  * from device node of the pin-controller. A pin group is formed with all
 792  * the pins listed in the "samsung,pins" property.
 793  */
 794
 795 static int samsung_pinctrl_parse_dt(struct platform_device *pdev,
 796                                     struct samsung_pinctrl_drv_data *drvdata)
 797 {
 798         struct device *dev = &pdev->dev;
 799         struct samsung_pin_group *groups;
 800         struct samsung_pmx_func *functions;
 801         unsigned int grp_cnt = 0, func_cnt = 0;
 802
 803         groups = samsung_pinctrl_create_groups(dev, drvdata, &grp_cnt);
 804         if (IS_ERR(groups)) {
 805                 dev_err(dev, "failed to parse pin groups\n");
 806                 return PTR_ERR(groups);
 807         }
 808
 809         functions = samsung_pinctrl_create_functions(dev, drvdata, &func_cnt);
 810         if (IS_ERR(functions)) {
 811                 dev_err(dev, "failed to parse pin functions\n");
 812                 return PTR_ERR(functions);
 813         }
 814
 815         drvdata->pin_groups = groups;
 816         drvdata->nr_groups = grp_cnt;
 817         drvdata->pmx_functions = functions;
 818         drvdata->nr_functions = func_cnt;
 819
 820         return 0;
 821 }
 822
 823 /* register the pinctrl interface with the pinctrl subsystem */
 824 static int samsung_pinctrl_register(struct platform_device *pdev,
 825                                     struct samsung_pinctrl_drv_data *drvdata)
 826 {
 827         struct pinctrl_desc *ctrldesc = &drvdata->pctl;
 828         struct pinctrl_pin_desc *pindesc, *pdesc;
 829         struct samsung_pin_bank *pin_bank;
 830         char *pin_names;
 831         int pin, bank, ret;
 832
 833         ctrldesc->name = "samsung-pinctrl";
 834         ctrldesc->owner = THIS_MODULE;
 835         ctrldesc->pctlops = &samsung_pctrl_ops;
 836         ctrldesc->pmxops = &samsung_pinmux_ops;
 837         ctrldesc->confops = &samsung_pinconf_ops;
 838
 839         pindesc = devm_kzalloc(&pdev->dev, sizeof(*pindesc) *
 840                         drvdata->nr_pins, GFP_KERNEL);
 841         if (!pindesc)
 842                 return -ENOMEM;
 843         ctrldesc->pins = pindesc;
 844         ctrldesc->npins = drvdata->nr_pins;
 845
 846         /* dynamically populate the pin number and pin name for pindesc */
 847         for (pin = 0, pdesc = pindesc; pin < ctrldesc->npins; pin++, pdesc++)
 848                 pdesc->number = pin + drvdata->pin_base;
 849
 850         /*
 851          * allocate space for storing the dynamically generated names for all
 852          * the pins which belong to this pin-controller.
 853          */
 854         pin_names = devm_kzalloc(&pdev->dev, sizeof(char) * PIN_NAME_LENGTH *
 855                                         drvdata->nr_pins, GFP_KERNEL);
 856         if (!pin_names)
 857                 return -ENOMEM;
 858
 859         /* for each pin, the name of the pin is pin-bank name + pin number */
 860         for (bank = 0; bank < drvdata->nr_banks; bank++) {
 861                 pin_bank = &drvdata->pin_banks[bank];
 862                 for (pin = 0; pin < pin_bank->nr_pins; pin++) {
 863                         sprintf(pin_names, "%s-%d", pin_bank->name, pin);
 864                         pdesc = pindesc + pin_bank->pin_base + pin;
 865                         pdesc->name = pin_names;
 866                         pin_names += PIN_NAME_LENGTH;
 867                 }
 868         }
 869
 870         ret = samsung_pinctrl_parse_dt(pdev, drvdata);
 871         if (ret)
 872                 return ret;
 873
 874         drvdata->pctl_dev = devm_pinctrl_register(&pdev->dev, ctrldesc,
 875                                                   drvdata);
 876         if (IS_ERR(drvdata->pctl_dev)) {
 877                 dev_err(&pdev->dev, "could not register pinctrl driver\n");
 878                 return PTR_ERR(drvdata->pctl_dev);
 879         }
 880
 881         for (bank = 0; bank < drvdata->nr_banks; ++bank) {
 882                 pin_bank = &drvdata->pin_banks[bank];
 883                 pin_bank->grange.name = pin_bank->name;
 884                 pin_bank->grange.id = bank;
 885                 pin_bank->grange.pin_base = drvdata->pin_base
 886                                                 + pin_bank->pin_base;
 887                 pin_bank->grange.base = pin_bank->grange.pin_base;
 888                 pin_bank->grange.npins = pin_bank->gpio_chip.ngpio;
 889                 pin_bank->grange.gc = &pin_bank->gpio_chip;
 890                 pinctrl_add_gpio_range(drvdata->pctl_dev, &pin_bank->grange);
 891         }
 892
 893         return 0;
 894 }
 895
 896 /* unregister the pinctrl interface with the pinctrl subsystem */
 897 static int samsung_pinctrl_unregister(struct platform_device *pdev,
 898                                       struct samsung_pinctrl_drv_data *drvdata)
 899 {
 900         struct samsung_pin_bank *bank = drvdata->pin_banks;
 901         int i;
 902
 903         for (i = 0; i < drvdata->nr_banks; ++i, ++bank)
 904                 pinctrl_remove_gpio_range(drvdata->pctl_dev, &bank->grange);
 905
 906         return 0;
 907 }
 908
 909 static const struct gpio_chip samsung_gpiolib_chip = {
 910         .request = gpiochip_generic_request,
 911         .free = gpiochip_generic_free,
 912         .set = samsung_gpio_set,
 913         .get = samsung_gpio_get,
 914         .direction_input = samsung_gpio_direction_input,
 915         .direction_output = samsung_gpio_direction_output,
 916         .to_irq = samsung_gpio_to_irq,
 917         .owner = THIS_MODULE,
 918 };
 919
 920 /* register the gpiolib interface with the gpiolib subsystem */
 921 static int samsung_gpiolib_register(struct platform_device *pdev,
 922                                     struct samsung_pinctrl_drv_data *drvdata)
 923 {
 924         struct samsung_pin_bank *bank = drvdata->pin_banks;
 925         struct gpio_chip *gc;
 926         int ret;
 927         int i;
 928
 929         for (i = 0; i < drvdata->nr_banks; ++i, ++bank) {
 930                 bank->gpio_chip = samsung_gpiolib_chip;
 931
 932                 gc = &bank->gpio_chip;
 933                 gc->base = bank->grange.base;
 934                 gc->ngpio = bank->nr_pins;
 935                 gc->parent = &pdev->dev;
 936                 gc->of_node = bank->of_node;
 937                 gc->label = bank->name;
 938
 939                 ret = devm_gpiochip_add_data(&pdev->dev, gc, bank);
 940                 if (ret) {
 941                         dev_err(&pdev->dev, "failed to register gpio_chip %s, error code: %d\n",
 942                                                         gc->label, ret);
 943                         return ret;
 944                 }
 945         }
 946
 947         return 0;
 948 }
 949
 950 /* retrieve the soc specific data */
 951 static const struct samsung_pin_ctrl *
 952 samsung_pinctrl_get_soc_data(struct samsung_pinctrl_drv_data *d,
 953                              struct platform_device *pdev)
 954 {
 955         int id;
 956         struct device_node *node = pdev->dev.of_node;
 957         struct device_node *np;
 958         const struct samsung_pin_bank_data *bdata;
 959         const struct samsung_pin_ctrl *ctrl;
 960         struct samsung_pin_bank *bank;
 961         struct resource *res;
 962         void __iomem *virt_base[SAMSUNG_PINCTRL_NUM_RESOURCES];
 963         unsigned int i;
 964
 965         id = of_alias_get_id(node, "pinctrl");
 966         if (id < 0) {
 967                 dev_err(&pdev->dev, "failed to get alias id\n");
 968                 return ERR_PTR(-ENOENT);
 969         }
 970         ctrl = of_device_get_match_data(&pdev->dev);
 971         ctrl += id;
 972
 973         d->suspend = ctrl->suspend;
 974         d->resume = ctrl->resume;
 975         d->nr_banks = ctrl->nr_banks;
 976         d->pin_banks = devm_kcalloc(&pdev->dev, d->nr_banks,
 977                                         sizeof(*d->pin_banks), GFP_KERNEL);
 978         if (!d->pin_banks)
 979                 return ERR_PTR(-ENOMEM);
 980
 981         if (ctrl->nr_ext_resources + 1 > SAMSUNG_PINCTRL_NUM_RESOURCES)
 982                 return ERR_PTR(-EINVAL);
 983
 984         for (i = 0; i < ctrl->nr_ext_resources + 1; i++) {
 985                 res = platform_get_resource(pdev, IORESOURCE_MEM, i);
 986                 if (!res) {
 987                         dev_err(&pdev->dev, "failed to get mem%d resource\n", i);
 988                         return ERR_PTR(-EINVAL);
 989                 }
 990                 virt_base[i] = devm_ioremap(&pdev->dev, res->start,
 991                                                 resource_size(res));
 992                 if (!virt_base[i]) {
 993                         dev_err(&pdev->dev, "failed to ioremap %pR\n", res);
 994                         return ERR_PTR(-EIO);
 995                 }
 996         }
 997
 998         bank = d->pin_banks;
 999         bdata = ctrl->pin_banks;
1000         for (i = 0; i < ctrl->nr_banks; ++i, ++bdata, ++bank) {
1001                 bank->type = bdata->type;
1002                 bank->pctl_offset = bdata->pctl_offset;
1003                 bank->nr_pins = bdata->nr_pins;
1004                 bank->eint_func = bdata->eint_func;
1005                 bank->eint_type = bdata->eint_type;
1006                 bank->eint_mask = bdata->eint_mask;
1007                 bank->eint_offset = bdata->eint_offset;
1008                 bank->name = bdata->name;
1009
1010                 spin_lock_init(&bank->slock);
1011                 bank->drvdata = d;
1012                 bank->pin_base = d->nr_pins;
1013                 d->nr_pins += bank->nr_pins;
1014
1015                 bank->eint_base = virt_base[0];
1016                 bank->pctl_base = virt_base[bdata->pctl_res_idx];
1017         }
1018         /*
1019          * Legacy platforms should provide only one resource with IO memory.
1020          * Store it as virt_base because legacy driver needs to access it
1021          * through samsung_pinctrl_drv_data.
1022          */
1023         d->virt_base = virt_base[0];
1024
1025         for_each_child_of_node(node, np) {
1026                 if (!of_find_property(np, "gpio-controller", NULL))
1027                         continue;
1028                 bank = d->pin_banks;
1029                 for (i = 0; i < d->nr_banks; ++i, ++bank) {
1030                         if (!strcmp(bank->name, np->name)) {
1031                                 bank->of_node = np;
1032                                 break;
1033                         }
1034                 }
1035         }
1036
1037         d->pin_base = pin_base;
1038         pin_base += d->nr_pins;
1039
1040         return ctrl;
1041 }
1042
1043 static int samsung_pinctrl_probe(struct platform_device *pdev)
1044 {
1045         struct samsung_pinctrl_drv_data *drvdata;
1046         const struct samsung_pin_ctrl *ctrl;
1047         struct device *dev = &pdev->dev;
1048         struct resource *res;
1049         int ret;
1050
1051         drvdata = devm_kzalloc(dev, sizeof(*drvdata), GFP_KERNEL);
1052         if (!drvdata)
1053                 return -ENOMEM;
1054
1055         ctrl = samsung_pinctrl_get_soc_data(drvdata, pdev);
1056         if (IS_ERR(ctrl)) {
1057                 dev_err(&pdev->dev, "driver data not available\n");
1058                 return PTR_ERR(ctrl);
1059         }
1060         drvdata->dev = dev;
1061
1062         res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
1063         if (res)
1064                 drvdata->irq = res->start;
1065
1066         if (ctrl->retention_data) {
1067                 drvdata->retention_ctrl = ctrl->retention_data->init(drvdata,
1068                                                           ctrl->retention_data);
1069                 if (IS_ERR(drvdata->retention_ctrl))
1070                         return PTR_ERR(drvdata->retention_ctrl);
1071         }
1072
1073         ret = samsung_pinctrl_register(pdev, drvdata);
1074         if (ret)
1075                 return ret;
1076
1077         ret = samsung_gpiolib_register(pdev, drvdata);
1078         if (ret) {
1079                 samsung_pinctrl_unregister(pdev, drvdata);
1080                 return ret;
1081         }
1082
1083         if (ctrl->eint_gpio_init)
1084                 ctrl->eint_gpio_init(drvdata);
1085         if (ctrl->eint_wkup_init)
1086                 ctrl->eint_wkup_init(drvdata);
1087
1088         platform_set_drvdata(pdev, drvdata);
1089
1090         return 0;
1091 }
1092
1093 /**
1094  * samsung_pinctrl_suspend - save pinctrl state for suspend
1095  *
1096  * Save data for all banks handled by this device.
1097  */
1098 static int __maybe_unused samsung_pinctrl_suspend(struct device *dev)
1099 {
1100         struct samsung_pinctrl_drv_data *drvdata = dev_get_drvdata(dev);
1101         int i;
1102
1103         for (i = 0; i < drvdata->nr_banks; i++) {
1104                 struct samsung_pin_bank *bank = &drvdata->pin_banks[i];
1105                 void __iomem *reg = bank->pctl_base + bank->pctl_offset;
1106                 const u8 *offs = bank->type->reg_offset;
1107                 const u8 *widths = bank->type->fld_width;
1108                 enum pincfg_type type;
1109
1110                 /* Registers without a powerdown config aren't lost */
1111                 if (!widths[PINCFG_TYPE_CON_PDN])
1112                         continue;
1113
1114                 for (type = 0; type < PINCFG_TYPE_NUM; type++)
1115                         if (widths[type])
1116                                 bank->pm_save[type] = readl(reg + offs[type]);
1117
1118                 if (widths[PINCFG_TYPE_FUNC] * bank->nr_pins > 32) {
1119                         /* Some banks have two config registers */
1120                         bank->pm_save[PINCFG_TYPE_NUM] =
1121                                 readl(reg + offs[PINCFG_TYPE_FUNC] + 4);
1122                         pr_debug("Save %s @ %p (con %#010x %08x)\n",
1123                                  bank->name, reg,
1124                                  bank->pm_save[PINCFG_TYPE_FUNC],
1125                                  bank->pm_save[PINCFG_TYPE_NUM]);
1126                 } else {
1127                         pr_debug("Save %s @ %p (con %#010x)\n", bank->name,
1128                                  reg, bank->pm_save[PINCFG_TYPE_FUNC]);
1129                 }
1130         }
1131
1132         if (drvdata->suspend)
1133                 drvdata->suspend(drvdata);
1134         if (drvdata->retention_ctrl && drvdata->retention_ctrl->enable)
1135                 drvdata->retention_ctrl->enable(drvdata);
1136
1137         return 0;
1138 }
1139
1140 /**
1141  * samsung_pinctrl_resume - restore pinctrl state from suspend
1142  *
1143  * Restore one of the banks that was saved during suspend.
1144  *
1145  * We don't bother doing anything complicated to avoid glitching lines since
1146  * we're called before pad retention is turned off.
1147  */
1148 static int __maybe_unused samsung_pinctrl_resume(struct device *dev)
1149 {
1150         struct samsung_pinctrl_drv_data *drvdata = dev_get_drvdata(dev);
1151         int i;
1152
1153         if (drvdata->resume)
1154                 drvdata->resume(drvdata);
1155
1156         for (i = 0; i < drvdata->nr_banks; i++) {
1157                 struct samsung_pin_bank *bank = &drvdata->pin_banks[i];
1158                 void __iomem *reg = bank->pctl_base + bank->pctl_offset;
1159                 const u8 *offs = bank->type->reg_offset;
1160                 const u8 *widths = bank->type->fld_width;
1161                 enum pincfg_type type;
1162
1163                 /* Registers without a powerdown config aren't lost */
1164                 if (!widths[PINCFG_TYPE_CON_PDN])
1165                         continue;
1166
1167                 if (widths[PINCFG_TYPE_FUNC] * bank->nr_pins > 32) {
1168                         /* Some banks have two config registers */
1169                         pr_debug("%s @ %p (con %#010x %08x => %#010x %08x)\n",
1170                                  bank->name, reg,
1171                                  readl(reg + offs[PINCFG_TYPE_FUNC]),
1172                                  readl(reg + offs[PINCFG_TYPE_FUNC] + 4),
1173                                  bank->pm_save[PINCFG_TYPE_FUNC],
1174                                  bank->pm_save[PINCFG_TYPE_NUM]);
1175                         writel(bank->pm_save[PINCFG_TYPE_NUM],
1176                                reg + offs[PINCFG_TYPE_FUNC] + 4);
1177                 } else {
1178                         pr_debug("%s @ %p (con %#010x => %#010x)\n", bank->name,
1179                                  reg, readl(reg + offs[PINCFG_TYPE_FUNC]),
1180                                  bank->pm_save[PINCFG_TYPE_FUNC]);
1181                 }
1182                 for (type = 0; type < PINCFG_TYPE_NUM; type++)
1183                         if (widths[type])
1184                                 writel(bank->pm_save[type], reg + offs[type]);
1185         }
1186
1187         if (drvdata->retention_ctrl && drvdata->retention_ctrl->disable)
1188                 drvdata->retention_ctrl->disable(drvdata);
1189
1190         return 0;
1191 }
1192
1193 static const struct of_device_id samsung_pinctrl_dt_match[] = {
1194 #ifdef CONFIG_PINCTRL_EXYNOS_ARM
1195         { .compatible = "samsung,exynos3250-pinctrl",
1196                 .data = exynos3250_pin_ctrl },
1197         { .compatible = "samsung,exynos4210-pinctrl",
1198                 .data = exynos4210_pin_ctrl },
1199         { .compatible = "samsung,exynos4x12-pinctrl",
1200                 .data = exynos4x12_pin_ctrl },
1201         { .compatible = "samsung,exynos5250-pinctrl",
1202                 .data = exynos5250_pin_ctrl },
1203         { .compatible = "samsung,exynos5260-pinctrl",
1204                 .data = exynos5260_pin_ctrl },
1205         { .compatible = "samsung,exynos5410-pinctrl",
1206                 .data = exynos5410_pin_ctrl },
1207         { .compatible = "samsung,exynos5420-pinctrl",
1208                 .data = exynos5420_pin_ctrl },
1209         { .compatible = "samsung,s5pv210-pinctrl",
1210                 .data = s5pv210_pin_ctrl },
1211 #endif
1212 #ifdef CONFIG_PINCTRL_EXYNOS_ARM64
1213         { .compatible = "samsung,exynos5433-pinctrl",
1214                 .data = exynos5433_pin_ctrl },
1215         { .compatible = "samsung,exynos7-pinctrl",
1216                 .data = exynos7_pin_ctrl },
1217 #endif
1218 #ifdef CONFIG_PINCTRL_S3C64XX
1219         { .compatible = "samsung,s3c64xx-pinctrl",
1220                 .data = s3c64xx_pin_ctrl },
1221 #endif
1222 #ifdef CONFIG_PINCTRL_S3C24XX
1223         { .compatible = "samsung,s3c2412-pinctrl",
1224                 .data = s3c2412_pin_ctrl },
1225         { .compatible = "samsung,s3c2416-pinctrl",
1226                 .data = s3c2416_pin_ctrl },
1227         { .compatible = "samsung,s3c2440-pinctrl",
1228                 .data = s3c2440_pin_ctrl },
1229         { .compatible = "samsung,s3c2450-pinctrl",
1230                 .data = s3c2450_pin_ctrl },
1231 #endif
1232         {},
1233 };
1234
1235 static const struct dev_pm_ops samsung_pinctrl_pm_ops = {
1236         SET_LATE_SYSTEM_SLEEP_PM_OPS(samsung_pinctrl_suspend,
1237                                      samsung_pinctrl_resume)
1238 };
1239
1240 static struct platform_driver samsung_pinctrl_driver = {
1241         .probe          = samsung_pinctrl_probe,
1242         .driver = {
1243                 .name   = "samsung-pinctrl",
1244                 .of_match_table = samsung_pinctrl_dt_match,
1245                 .suppress_bind_attrs = true,
1246                 .pm = &samsung_pinctrl_pm_ops,
1247         },
1248 };
1249
1250 static int __init samsung_pinctrl_drv_register(void)
1251 {
1252         return platform_driver_register(&samsung_pinctrl_driver);
1253 }
1254 postcore_initcall(samsung_pinctrl_drv_register);