drivers/pinctrl/vt8500/pinctrl-wmt.c

   1 /*
   2  * Pinctrl driver for the Wondermedia SoC's
   3  *
   4  * Copyright (c) 2013 Tony Prisk <linux@prisktech.co.nz>
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms and conditions of the GNU General Public License,
   8  * version 2, as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13  * more details.
  14  */
  15
  16 #include <linux/err.h>
  17 #include <linux/gpio.h>
  18 #include <linux/interrupt.h>
  19 #include <linux/io.h>
  20 #include <linux/irq.h>
  21 #include <linux/module.h>
  22 #include <linux/of.h>
  23 #include <linux/of_irq.h>
  24 #include <linux/pinctrl/consumer.h>
  25 #include <linux/pinctrl/machine.h>
  26 #include <linux/pinctrl/pinconf.h>
  27 #include <linux/pinctrl/pinconf-generic.h>
  28 #include <linux/pinctrl/pinctrl.h>
  29 #include <linux/pinctrl/pinmux.h>
  30 #include <linux/platform_device.h>
  31 #include <linux/slab.h>
  32
  33 #include "pinctrl-wmt.h"
  34
  35 static inline void wmt_setbits(struct wmt_pinctrl_data *data, u32 reg,
  36                                  u32 mask)
  37 {
  38         u32 val;
  39
  40         val = readl_relaxed(data->base + reg);
  41         val |= mask;
  42         writel_relaxed(val, data->base + reg);
  43 }
  44
  45 static inline void wmt_clearbits(struct wmt_pinctrl_data *data, u32 reg,
  46                                    u32 mask)
  47 {
  48         u32 val;
  49
  50         val = readl_relaxed(data->base + reg);
  51         val &= ~mask;
  52         writel_relaxed(val, data->base + reg);
  53 }
  54
  55 enum wmt_func_sel {
  56         WMT_FSEL_GPIO_IN = 0,
  57         WMT_FSEL_GPIO_OUT = 1,
  58         WMT_FSEL_ALT = 2,
  59         WMT_FSEL_COUNT = 3,
  60 };
  61
  62 static const char * const wmt_functions[WMT_FSEL_COUNT] = {
  63         [WMT_FSEL_GPIO_IN] = "gpio_in",
  64         [WMT_FSEL_GPIO_OUT] = "gpio_out",
  65         [WMT_FSEL_ALT] = "alt",
  66 };
  67
  68 static int wmt_pmx_get_functions_count(struct pinctrl_dev *pctldev)
  69 {
  70         return WMT_FSEL_COUNT;
  71 }
  72
  73 static const char *wmt_pmx_get_function_name(struct pinctrl_dev *pctldev,
  74                                              unsigned selector)
  75 {
  76         return wmt_functions[selector];
  77 }
  78
  79 static int wmt_pmx_get_function_groups(struct pinctrl_dev *pctldev,
  80                                        unsigned selector,
  81                                        const char * const **groups,
  82                                        unsigned * const num_groups)
  83 {
  84         struct wmt_pinctrl_data *data = pinctrl_dev_get_drvdata(pctldev);
  85
  86         /* every pin does every function */
  87         *groups = data->groups;
  88         *num_groups = data->ngroups;
  89
  90         return 0;
  91 }
  92
  93 static int wmt_set_pinmux(struct wmt_pinctrl_data *data, unsigned func,
  94                           unsigned pin)
  95 {
  96         u32 bank = WMT_BANK_FROM_PIN(pin);
  97         u32 bit = WMT_BIT_FROM_PIN(pin);
  98         u32 reg_en = data->banks[bank].reg_en;
  99         u32 reg_dir = data->banks[bank].reg_dir;
 100
 101         if (reg_dir == NO_REG) {
 102                 dev_err(data->dev, "pin:%d no direction register defined\n",
 103                         pin);
 104                 return -EINVAL;
 105         }
 106
 107         /*
 108          * If reg_en == NO_REG, we assume it is a dedicated GPIO and cannot be
 109          * disabled (as on VT8500) and that no alternate function is available.
 110          */
 111         switch (func) {
 112         case WMT_FSEL_GPIO_IN:
 113                 if (reg_en != NO_REG)
 114                         wmt_setbits(data, reg_en, BIT(bit));
 115                 wmt_clearbits(data, reg_dir, BIT(bit));
 116                 break;
 117         case WMT_FSEL_GPIO_OUT:
 118                 if (reg_en != NO_REG)
 119                         wmt_setbits(data, reg_en, BIT(bit));
 120                 wmt_setbits(data, reg_dir, BIT(bit));
 121                 break;
 122         case WMT_FSEL_ALT:
 123                 if (reg_en == NO_REG) {
 124                         dev_err(data->dev, "pin:%d no alt function available\n",
 125                                 pin);
 126                         return -EINVAL;
 127                 }
 128                 wmt_clearbits(data, reg_en, BIT(bit));
 129         }
 130
 131         return 0;
 132 }
 133
 134 static int wmt_pmx_enable(struct pinctrl_dev *pctldev,
 135                           unsigned func_selector,
 136                           unsigned group_selector)
 137 {
 138         struct wmt_pinctrl_data *data = pinctrl_dev_get_drvdata(pctldev);
 139         u32 pinnum = data->pins[group_selector].number;
 140
 141         return wmt_set_pinmux(data, func_selector, pinnum);
 142 }
 143
 144 static void wmt_pmx_disable(struct pinctrl_dev *pctldev,
 145                             unsigned func_selector,
 146                             unsigned group_selector)
 147 {
 148         struct wmt_pinctrl_data *data = pinctrl_dev_get_drvdata(pctldev);
 149         u32 pinnum = data->pins[group_selector].number;
 150
 151         /* disable by setting GPIO_IN */
 152         wmt_set_pinmux(data, WMT_FSEL_GPIO_IN, pinnum);
 153 }
 154
 155 static void wmt_pmx_gpio_disable_free(struct pinctrl_dev *pctldev,
 156                                       struct pinctrl_gpio_range *range,
 157                                       unsigned offset)
 158 {
 159         struct wmt_pinctrl_data *data = pinctrl_dev_get_drvdata(pctldev);
 160
 161         /* disable by setting GPIO_IN */
 162         wmt_set_pinmux(data, WMT_FSEL_GPIO_IN, offset);
 163 }
 164
 165 static int wmt_pmx_gpio_set_direction(struct pinctrl_dev *pctldev,
 166                                       struct pinctrl_gpio_range *range,
 167                                       unsigned offset,
 168                                       bool input)
 169 {
 170         struct wmt_pinctrl_data *data = pinctrl_dev_get_drvdata(pctldev);
 171
 172         wmt_set_pinmux(data, (input ? WMT_FSEL_GPIO_IN : WMT_FSEL_GPIO_OUT),
 173                        offset);
 174
 175         return 0;
 176 }
 177
 178 static struct pinmux_ops wmt_pinmux_ops = {
 179         .get_functions_count = wmt_pmx_get_functions_count,
 180         .get_function_name = wmt_pmx_get_function_name,
 181         .get_function_groups = wmt_pmx_get_function_groups,
 182         .enable = wmt_pmx_enable,
 183         .disable = wmt_pmx_disable,
 184         .gpio_disable_free = wmt_pmx_gpio_disable_free,
 185         .gpio_set_direction = wmt_pmx_gpio_set_direction,
 186 };
 187
 188 static int wmt_get_groups_count(struct pinctrl_dev *pctldev)
 189 {
 190         struct wmt_pinctrl_data *data = pinctrl_dev_get_drvdata(pctldev);
 191
 192         return data->ngroups;
 193 }
 194
 195 static const char *wmt_get_group_name(struct pinctrl_dev *pctldev,
 196                                       unsigned selector)
 197 {
 198         struct wmt_pinctrl_data *data = pinctrl_dev_get_drvdata(pctldev);
 199
 200         return data->groups[selector];
 201 }
 202
 203 static int wmt_get_group_pins(struct pinctrl_dev *pctldev,
 204                               unsigned selector,
 205                               const unsigned **pins,
 206                               unsigned *num_pins)
 207 {
 208         struct wmt_pinctrl_data *data = pinctrl_dev_get_drvdata(pctldev);
 209
 210         *pins = &data->pins[selector].number;
 211         *num_pins = 1;
 212
 213         return 0;
 214 }
 215
 216 static int wmt_pctl_find_group_by_pin(struct wmt_pinctrl_data *data, u32 pin)
 217 {
 218         int i;
 219
 220         for (i = 0; i < data->npins; i++) {
 221                 if (data->pins[i].number == pin)
 222                         return i;
 223         }
 224
 225         return -EINVAL;
 226 }
 227
 228 static int wmt_pctl_dt_node_to_map_func(struct wmt_pinctrl_data *data,
 229                                         struct device_node *np,
 230                                         u32 pin, u32 fnum,
 231                                         struct pinctrl_map **maps)
 232 {
 233         int group;
 234         struct pinctrl_map *map = *maps;
 235
 236         if (fnum >= ARRAY_SIZE(wmt_functions)) {
 237                 dev_err(data->dev, "invalid wm,function %d\n", fnum);
 238                 return -EINVAL;
 239         }
 240
 241         group = wmt_pctl_find_group_by_pin(data, pin);
 242         if (group < 0) {
 243                 dev_err(data->dev, "unable to match pin %d to group\n", pin);
 244                 return group;
 245         }
 246
 247         map->type = PIN_MAP_TYPE_MUX_GROUP;
 248         map->data.mux.group = data->groups[group];
 249         map->data.mux.function = wmt_functions[fnum];
 250         (*maps)++;
 251
 252         return 0;
 253 }
 254
 255 static int wmt_pctl_dt_node_to_map_pull(struct wmt_pinctrl_data *data,
 256                                         struct device_node *np,
 257                                         u32 pin, u32 pull,
 258                                         struct pinctrl_map **maps)
 259 {
 260         int group;
 261         unsigned long *configs;
 262         struct pinctrl_map *map = *maps;
 263
 264         if (pull > 2) {
 265                 dev_err(data->dev, "invalid wm,pull %d\n", pull);
 266                 return -EINVAL;
 267         }
 268
 269         group = wmt_pctl_find_group_by_pin(data, pin);
 270         if (group < 0) {
 271                 dev_err(data->dev, "unable to match pin %d to group\n", pin);
 272                 return group;
 273         }
 274
 275         configs = kzalloc(sizeof(*configs), GFP_KERNEL);
 276         if (!configs)
 277                 return -ENOMEM;
 278
 279         switch (pull) {
 280         case 0:
 281                 configs[0] = PIN_CONFIG_BIAS_DISABLE;
 282                 break;
 283         case 1:
 284                 configs[0] = PIN_CONFIG_BIAS_PULL_DOWN;
 285                 break;
 286         case 2:
 287                 configs[0] = PIN_CONFIG_BIAS_PULL_UP;
 288                 break;
 289         default:
 290                 configs[0] = PIN_CONFIG_BIAS_DISABLE;
 291                 dev_err(data->dev, "invalid pull state %d - disabling\n", pull);
 292         }
 293
 294         map->type = PIN_MAP_TYPE_CONFIGS_PIN;
 295         map->data.configs.group_or_pin = data->groups[group];
 296         map->data.configs.configs = configs;
 297         map->data.configs.num_configs = 1;
 298         (*maps)++;
 299
 300         return 0;
 301 }
 302
 303 static void wmt_pctl_dt_free_map(struct pinctrl_dev *pctldev,
 304                                  struct pinctrl_map *maps,
 305                                  unsigned num_maps)
 306 {
 307         int i;
 308
 309         for (i = 0; i < num_maps; i++)
 310                 if (maps[i].type == PIN_MAP_TYPE_CONFIGS_PIN)
 311                         kfree(maps[i].data.configs.configs);
 312
 313         kfree(maps);
 314 }
 315
 316 static int wmt_pctl_dt_node_to_map(struct pinctrl_dev *pctldev,
 317                                    struct device_node *np,
 318                                    struct pinctrl_map **map,
 319                                    unsigned *num_maps)
 320 {
 321         struct pinctrl_map *maps, *cur_map;
 322         struct property *pins, *funcs, *pulls;
 323         u32 pin, func, pull;
 324         int num_pins, num_funcs, num_pulls, maps_per_pin;
 325         int i, err;
 326         struct wmt_pinctrl_data *data = pinctrl_dev_get_drvdata(pctldev);
 327
 328         pins = of_find_property(np, "wm,pins", NULL);
 329         if (!pins) {
 330                 dev_err(data->dev, "missing wmt,pins property\n");
 331                 return -EINVAL;
 332         }
 333
 334         funcs = of_find_property(np, "wm,function", NULL);
 335         pulls = of_find_property(np, "wm,pull", NULL);
 336
 337         if (!funcs && !pulls) {
 338                 dev_err(data->dev, "neither wm,function nor wm,pull specified\n");
 339                 return -EINVAL;
 340         }
 341
 342         /*
 343          * The following lines calculate how many values are defined for each
 344          * of the properties.
 345          */
 346         num_pins = pins->length / sizeof(u32);
 347         num_funcs = funcs ? (funcs->length / sizeof(u32)) : 0;
 348         num_pulls = pulls ? (pulls->length / sizeof(u32)) : 0;
 349
 350         if (num_funcs > 1 && num_funcs != num_pins) {
 351                 dev_err(data->dev, "wm,function must have 1 or %d entries\n",
 352                         num_pins);
 353                 return -EINVAL;
 354         }
 355
 356         if (num_pulls > 1 && num_pulls != num_pins) {
 357                 dev_err(data->dev, "wm,pull must have 1 or %d entries\n",
 358                         num_pins);
 359                 return -EINVAL;
 360         }
 361
 362         maps_per_pin = 0;
 363         if (num_funcs)
 364                 maps_per_pin++;
 365         if (num_pulls)
 366                 maps_per_pin++;
 367
 368         cur_map = maps = kzalloc(num_pins * maps_per_pin * sizeof(*maps),
 369                                  GFP_KERNEL);
 370         if (!maps)
 371                 return -ENOMEM;
 372
 373         for (i = 0; i < num_pins; i++) {
 374                 err = of_property_read_u32_index(np, "wm,pins", i, &pin);
 375                 if (err)
 376                         goto fail;
 377
 378                 if (pin >= (data->nbanks * 32)) {
 379                         dev_err(data->dev, "invalid wm,pins value\n");
 380                         err = -EINVAL;
 381                         goto fail;
 382                 }
 383
 384                 if (num_funcs) {
 385                         err = of_property_read_u32_index(np, "wm,function",
 386                                                 (num_funcs > 1 ? i : 0), &func);
 387                         if (err)
 388                                 goto fail;
 389
 390                         err = wmt_pctl_dt_node_to_map_func(data, np, pin, func,
 391                                                            &cur_map);
 392                         if (err)
 393                                 goto fail;
 394                 }
 395
 396                 if (num_pulls) {
 397                         err = of_property_read_u32_index(np, "wm,pull",
 398                                                 (num_pulls > 1 ? i : 0), &pull);
 399                         if (err)
 400                                 goto fail;
 401
 402                         err = wmt_pctl_dt_node_to_map_pull(data, np, pin, pull,
 403                                                            &cur_map);
 404                         if (err)
 405                                 goto fail;
 406                 }
 407         }
 408         *map = maps;
 409         *num_maps = num_pins * maps_per_pin;
 410         return 0;
 411
 412 /*
 413  * The fail path removes any maps that have been allocated. The fail path is
 414  * only called from code after maps has been kzalloc'd. It is also safe to
 415  * pass 'num_pins * maps_per_pin' as the map count even though we probably
 416  * failed before all the mappings were read as all maps are allocated at once,
 417  * and configs are only allocated for .type = PIN_MAP_TYPE_CONFIGS_PIN - there
 418  * is no failpath where a config can be allocated without .type being set.
 419  */
 420 fail:
 421         wmt_pctl_dt_free_map(pctldev, maps, num_pins * maps_per_pin);
 422         return err;
 423 }
 424
 425 static struct pinctrl_ops wmt_pctl_ops = {
 426         .get_groups_count = wmt_get_groups_count,
 427         .get_group_name = wmt_get_group_name,
 428         .get_group_pins = wmt_get_group_pins,
 429         .dt_node_to_map = wmt_pctl_dt_node_to_map,
 430         .dt_free_map = wmt_pctl_dt_free_map,
 431 };
 432
 433 static int wmt_pinconf_get(struct pinctrl_dev *pctldev, unsigned pin,
 434                            unsigned long *config)
 435 {
 436         return -ENOTSUPP;
 437 }
 438
 439 static int wmt_pinconf_set(struct pinctrl_dev *pctldev, unsigned pin,
 440                            unsigned long *configs, unsigned num_configs)
 441 {
 442         struct wmt_pinctrl_data *data = pinctrl_dev_get_drvdata(pctldev);
 443         enum pin_config_param param;
 444         u16 arg;
 445         u32 bank = WMT_BANK_FROM_PIN(pin);
 446         u32 bit = WMT_BIT_FROM_PIN(pin);
 447         u32 reg_pull_en = data->banks[bank].reg_pull_en;
 448         u32 reg_pull_cfg = data->banks[bank].reg_pull_cfg;
 449         int i;
 450
 451         if ((reg_pull_en == NO_REG) || (reg_pull_cfg == NO_REG)) {
 452                 dev_err(data->dev, "bias functions not supported on pin %d\n",
 453                         pin);
 454                 return -EINVAL;
 455         }
 456
 457         for (i = 0; i < num_configs; i++) {
 458                 param = pinconf_to_config_param(configs[i]);
 459                 arg = pinconf_to_config_argument(configs[i]);
 460
 461                 if ((param == PIN_CONFIG_BIAS_PULL_DOWN) ||
 462                     (param == PIN_CONFIG_BIAS_PULL_UP)) {
 463                         if (arg == 0)
 464                                 param = PIN_CONFIG_BIAS_DISABLE;
 465                 }
 466
 467                 switch (param) {
 468                 case PIN_CONFIG_BIAS_DISABLE:
 469                         wmt_clearbits(data, reg_pull_en, BIT(bit));
 470                         break;
 471                 case PIN_CONFIG_BIAS_PULL_DOWN:
 472                         wmt_clearbits(data, reg_pull_cfg, BIT(bit));
 473                         wmt_setbits(data, reg_pull_en, BIT(bit));
 474                         break;
 475                 case PIN_CONFIG_BIAS_PULL_UP:
 476                         wmt_setbits(data, reg_pull_cfg, BIT(bit));
 477                         wmt_setbits(data, reg_pull_en, BIT(bit));
 478                         break;
 479                 default:
 480                         dev_err(data->dev, "unknown pinconf param\n");
 481                         return -EINVAL;
 482                 }
 483         } /* for each config */
 484
 485         return 0;
 486 }
 487
 488 static struct pinconf_ops wmt_pinconf_ops = {
 489         .pin_config_get = wmt_pinconf_get,
 490         .pin_config_set = wmt_pinconf_set,
 491 };
 492
 493 static struct pinctrl_desc wmt_desc = {
 494         .owner = THIS_MODULE,
 495         .name = "pinctrl-wmt",
 496         .pctlops = &wmt_pctl_ops,
 497         .pmxops = &wmt_pinmux_ops,
 498         .confops = &wmt_pinconf_ops,
 499 };
 500
 501 static int wmt_gpio_request(struct gpio_chip *chip, unsigned offset)
 502 {
 503         return pinctrl_request_gpio(chip->base + offset);
 504 }
 505
 506 static void wmt_gpio_free(struct gpio_chip *chip, unsigned offset)
 507 {
 508         pinctrl_free_gpio(chip->base + offset);
 509 }
 510
 511 static int wmt_gpio_get_direction(struct gpio_chip *chip, unsigned offset)
 512 {
 513         struct wmt_pinctrl_data *data = dev_get_drvdata(chip->dev);
 514         u32 bank = WMT_BANK_FROM_PIN(offset);
 515         u32 bit = WMT_BIT_FROM_PIN(offset);
 516         u32 reg_dir = data->banks[bank].reg_dir;
 517         u32 val;
 518
 519         val = readl_relaxed(data->base + reg_dir);
 520         if (val & BIT(bit))
 521                 return GPIOF_DIR_OUT;
 522         else
 523                 return GPIOF_DIR_IN;
 524 }
 525
 526 static int wmt_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 527 {
 528         return pinctrl_gpio_direction_input(chip->base + offset);
 529 }
 530
 531 static int wmt_gpio_direction_output(struct gpio_chip *chip, unsigned offset,
 532                                      int value)
 533 {
 534         return pinctrl_gpio_direction_output(chip->base + offset);
 535 }
 536
 537 static int wmt_gpio_get_value(struct gpio_chip *chip, unsigned offset)
 538 {
 539         struct wmt_pinctrl_data *data = dev_get_drvdata(chip->dev);
 540         u32 bank = WMT_BANK_FROM_PIN(offset);
 541         u32 bit = WMT_BIT_FROM_PIN(offset);
 542         u32 reg_data_in = data->banks[bank].reg_data_in;
 543
 544         if (reg_data_in == NO_REG) {
 545                 dev_err(data->dev, "no data in register defined\n");
 546                 return -EINVAL;
 547         }
 548
 549         return !!(readl_relaxed(data->base + reg_data_in) & BIT(bit));
 550 }
 551
 552 static void wmt_gpio_set_value(struct gpio_chip *chip, unsigned offset,
 553                                int val)
 554 {
 555         struct wmt_pinctrl_data *data = dev_get_drvdata(chip->dev);
 556         u32 bank = WMT_BANK_FROM_PIN(offset);
 557         u32 bit = WMT_BIT_FROM_PIN(offset);
 558         u32 reg_data_out = data->banks[bank].reg_data_out;
 559
 560         if (reg_data_out == NO_REG) {
 561                 dev_err(data->dev, "no data out register defined\n");
 562                 return;
 563         }
 564
 565         if (val)
 566                 wmt_setbits(data, reg_data_out, BIT(bit));
 567         else
 568                 wmt_clearbits(data, reg_data_out, BIT(bit));
 569 }
 570
 571 static struct gpio_chip wmt_gpio_chip = {
 572         .label = "gpio-wmt",
 573         .owner = THIS_MODULE,
 574         .request = wmt_gpio_request,
 575         .free = wmt_gpio_free,
 576         .get_direction = wmt_gpio_get_direction,
 577         .direction_input = wmt_gpio_direction_input,
 578         .direction_output = wmt_gpio_direction_output,
 579         .get = wmt_gpio_get_value,
 580         .set = wmt_gpio_set_value,
 581         .can_sleep = 0,
 582 };
 583
 584 int wmt_pinctrl_probe(struct platform_device *pdev,
 585                       struct wmt_pinctrl_data *data)
 586 {
 587         int err;
 588         struct resource *res;
 589
 590         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 591         data->base = devm_ioremap_resource(&pdev->dev, res);
 592         if (IS_ERR(data->base))
 593                 return PTR_ERR(data->base);
 594
 595         wmt_desc.pins = data->pins;
 596         wmt_desc.npins = data->npins;
 597
 598         data->gpio_chip = wmt_gpio_chip;
 599         data->gpio_chip.dev = &pdev->dev;
 600         data->gpio_chip.of_node = pdev->dev.of_node;
 601         data->gpio_chip.ngpio = data->nbanks * 32;
 602
 603         platform_set_drvdata(pdev, data);
 604
 605         data->dev = &pdev->dev;
 606
 607         data->pctl_dev = pinctrl_register(&wmt_desc, &pdev->dev, data);
 608         if (!data->pctl_dev) {
 609                 dev_err(&pdev->dev, "Failed to register pinctrl\n");
 610                 return -EINVAL;
 611         }
 612
 613         err = gpiochip_add(&data->gpio_chip);
 614         if (err) {
 615                 dev_err(&pdev->dev, "could not add GPIO chip\n");
 616                 goto fail_gpio;
 617         }
 618
 619         err = gpiochip_add_pin_range(&data->gpio_chip, dev_name(data->dev),
 620                                      0, 0, data->nbanks * 32);
 621         if (err)
 622                 goto fail_range;
 623
 624         dev_info(&pdev->dev, "Pin controller initialized\n");
 625
 626         return 0;
 627
 628 fail_range:
 629         if (gpiochip_remove(&data->gpio_chip))
 630                 dev_err(&pdev->dev, "failed to remove gpio chip\n");
 631 fail_gpio:
 632         pinctrl_unregister(data->pctl_dev);
 633         return err;
 634 }
 635
 636 int wmt_pinctrl_remove(struct platform_device *pdev)
 637 {
 638         struct wmt_pinctrl_data *data = platform_get_drvdata(pdev);
 639         int err;
 640
 641         err = gpiochip_remove(&data->gpio_chip);
 642         if (err)
 643                 dev_err(&pdev->dev, "failed to remove gpio chip\n");
 644
 645         pinctrl_unregister(data->pctl_dev);
 646
 647         return 0;
 648 }