Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0+
0002 //
0003 // pin-controller/pin-mux/pin-config/gpio-driver for Samsung's SoC's.
0004 //
0005 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
0006 //      http://www.samsung.com
0007 // Copyright (c) 2012 Linaro Ltd
0008 //      http://www.linaro.org
0009 //
0010 // Author: Thomas Abraham <thomas.ab@samsung.com>
0011 //
0012 // This driver implements the Samsung pinctrl driver. It supports setting up of
0013 // pinmux and pinconf configurations. The gpiolib interface is also included.
0014 // External interrupt (gpio and wakeup) support are not included in this driver
0015 // but provides extensions to which platform specific implementation of the gpio
0016 // and wakeup interrupts can be hooked to.
0017 
0018 #include <linux/init.h>
0019 #include <linux/platform_device.h>
0020 #include <linux/io.h>
0021 #include <linux/property.h>
0022 #include <linux/slab.h>
0023 #include <linux/err.h>
0024 #include <linux/gpio/driver.h>
0025 #include <linux/irqdomain.h>
0026 #include <linux/of_device.h>
0027 #include <linux/spinlock.h>
0028 
0029 #include "../core.h"
0030 #include "pinctrl-samsung.h"
0031 
0032 /* maximum number of the memory resources */
0033 #define SAMSUNG_PINCTRL_NUM_RESOURCES   2
0034 
0035 /* list of all possible config options supported */
0036 static struct pin_config {
0037     const char *property;
0038     enum pincfg_type param;
0039 } cfg_params[] = {
0040     { "samsung,pin-pud", PINCFG_TYPE_PUD },
0041     { "samsung,pin-drv", PINCFG_TYPE_DRV },
0042     { "samsung,pin-con-pdn", PINCFG_TYPE_CON_PDN },
0043     { "samsung,pin-pud-pdn", PINCFG_TYPE_PUD_PDN },
0044     { "samsung,pin-val", PINCFG_TYPE_DAT },
0045 };
0046 
0047 static unsigned int pin_base;
0048 
0049 static int samsung_get_group_count(struct pinctrl_dev *pctldev)
0050 {
0051     struct samsung_pinctrl_drv_data *pmx = pinctrl_dev_get_drvdata(pctldev);
0052 
0053     return pmx->nr_groups;
0054 }
0055 
0056 static const char *samsung_get_group_name(struct pinctrl_dev *pctldev,
0057                         unsigned group)
0058 {
0059     struct samsung_pinctrl_drv_data *pmx = pinctrl_dev_get_drvdata(pctldev);
0060 
0061     return pmx->pin_groups[group].name;
0062 }
0063 
0064 static int samsung_get_group_pins(struct pinctrl_dev *pctldev,
0065                     unsigned group,
0066                     const unsigned **pins,
0067                     unsigned *num_pins)
0068 {
0069     struct samsung_pinctrl_drv_data *pmx = pinctrl_dev_get_drvdata(pctldev);
0070 
0071     *pins = pmx->pin_groups[group].pins;
0072     *num_pins = pmx->pin_groups[group].num_pins;
0073 
0074     return 0;
0075 }
0076 
0077 static int reserve_map(struct device *dev, struct pinctrl_map **map,
0078                unsigned *reserved_maps, unsigned *num_maps,
0079                unsigned reserve)
0080 {
0081     unsigned old_num = *reserved_maps;
0082     unsigned new_num = *num_maps + reserve;
0083     struct pinctrl_map *new_map;
0084 
0085     if (old_num >= new_num)
0086         return 0;
0087 
0088     new_map = krealloc(*map, sizeof(*new_map) * new_num, GFP_KERNEL);
0089     if (!new_map)
0090         return -ENOMEM;
0091 
0092     memset(new_map + old_num, 0, (new_num - old_num) * sizeof(*new_map));
0093 
0094     *map = new_map;
0095     *reserved_maps = new_num;
0096 
0097     return 0;
0098 }
0099 
0100 static int add_map_mux(struct pinctrl_map **map, unsigned *reserved_maps,
0101                unsigned *num_maps, const char *group,
0102                const char *function)
0103 {
0104     if (WARN_ON(*num_maps == *reserved_maps))
0105         return -ENOSPC;
0106 
0107     (*map)[*num_maps].type = PIN_MAP_TYPE_MUX_GROUP;
0108     (*map)[*num_maps].data.mux.group = group;
0109     (*map)[*num_maps].data.mux.function = function;
0110     (*num_maps)++;
0111 
0112     return 0;
0113 }
0114 
0115 static int add_map_configs(struct device *dev, struct pinctrl_map **map,
0116                unsigned *reserved_maps, unsigned *num_maps,
0117                const char *group, unsigned long *configs,
0118                unsigned num_configs)
0119 {
0120     unsigned long *dup_configs;
0121 
0122     if (WARN_ON(*num_maps == *reserved_maps))
0123         return -ENOSPC;
0124 
0125     dup_configs = kmemdup(configs, num_configs * sizeof(*dup_configs),
0126                   GFP_KERNEL);
0127     if (!dup_configs)
0128         return -ENOMEM;
0129 
0130     (*map)[*num_maps].type = PIN_MAP_TYPE_CONFIGS_GROUP;
0131     (*map)[*num_maps].data.configs.group_or_pin = group;
0132     (*map)[*num_maps].data.configs.configs = dup_configs;
0133     (*map)[*num_maps].data.configs.num_configs = num_configs;
0134     (*num_maps)++;
0135 
0136     return 0;
0137 }
0138 
0139 static int add_config(struct device *dev, unsigned long **configs,
0140               unsigned *num_configs, unsigned long config)
0141 {
0142     unsigned old_num = *num_configs;
0143     unsigned new_num = old_num + 1;
0144     unsigned long *new_configs;
0145 
0146     new_configs = krealloc(*configs, sizeof(*new_configs) * new_num,
0147                    GFP_KERNEL);
0148     if (!new_configs)
0149         return -ENOMEM;
0150 
0151     new_configs[old_num] = config;
0152 
0153     *configs = new_configs;
0154     *num_configs = new_num;
0155 
0156     return 0;
0157 }
0158 
0159 static void samsung_dt_free_map(struct pinctrl_dev *pctldev,
0160                       struct pinctrl_map *map,
0161                       unsigned num_maps)
0162 {
0163     int i;
0164 
0165     for (i = 0; i < num_maps; i++)
0166         if (map[i].type == PIN_MAP_TYPE_CONFIGS_GROUP)
0167             kfree(map[i].data.configs.configs);
0168 
0169     kfree(map);
0170 }
0171 
0172 static int samsung_dt_subnode_to_map(struct samsung_pinctrl_drv_data *drvdata,
0173                      struct device *dev,
0174                      struct device_node *np,
0175                      struct pinctrl_map **map,
0176                      unsigned *reserved_maps,
0177                      unsigned *num_maps)
0178 {
0179     int ret, i;
0180     u32 val;
0181     unsigned long config;
0182     unsigned long *configs = NULL;
0183     unsigned num_configs = 0;
0184     unsigned reserve;
0185     struct property *prop;
0186     const char *group;
0187     bool has_func = false;
0188 
0189     ret = of_property_read_u32(np, "samsung,pin-function", &val);
0190     if (!ret)
0191         has_func = true;
0192 
0193     for (i = 0; i < ARRAY_SIZE(cfg_params); i++) {
0194         ret = of_property_read_u32(np, cfg_params[i].property, &val);
0195         if (!ret) {
0196             config = PINCFG_PACK(cfg_params[i].param, val);
0197             ret = add_config(dev, &configs, &num_configs, config);
0198             if (ret < 0)
0199                 goto exit;
0200         /* EINVAL=missing, which is fine since it's optional */
0201         } else if (ret != -EINVAL) {
0202             dev_err(dev, "could not parse property %s\n",
0203                 cfg_params[i].property);
0204         }
0205     }
0206 
0207     reserve = 0;
0208     if (has_func)
0209         reserve++;
0210     if (num_configs)
0211         reserve++;
0212     ret = of_property_count_strings(np, "samsung,pins");
0213     if (ret < 0) {
0214         dev_err(dev, "could not parse property samsung,pins\n");
0215         goto exit;
0216     }
0217     reserve *= ret;
0218 
0219     ret = reserve_map(dev, map, reserved_maps, num_maps, reserve);
0220     if (ret < 0)
0221         goto exit;
0222 
0223     of_property_for_each_string(np, "samsung,pins", prop, group) {
0224         if (has_func) {
0225             ret = add_map_mux(map, reserved_maps,
0226                         num_maps, group, np->full_name);
0227             if (ret < 0)
0228                 goto exit;
0229         }
0230 
0231         if (num_configs) {
0232             ret = add_map_configs(dev, map, reserved_maps,
0233                           num_maps, group, configs,
0234                           num_configs);
0235             if (ret < 0)
0236                 goto exit;
0237         }
0238     }
0239 
0240     ret = 0;
0241 
0242 exit:
0243     kfree(configs);
0244     return ret;
0245 }
0246 
0247 static int samsung_dt_node_to_map(struct pinctrl_dev *pctldev,
0248                     struct device_node *np_config,
0249                     struct pinctrl_map **map,
0250                     unsigned *num_maps)
0251 {
0252     struct samsung_pinctrl_drv_data *drvdata;
0253     unsigned reserved_maps;
0254     struct device_node *np;
0255     int ret;
0256 
0257     drvdata = pinctrl_dev_get_drvdata(pctldev);
0258 
0259     reserved_maps = 0;
0260     *map = NULL;
0261     *num_maps = 0;
0262 
0263     if (!of_get_child_count(np_config))
0264         return samsung_dt_subnode_to_map(drvdata, pctldev->dev,
0265                             np_config, map,
0266                             &reserved_maps,
0267                             num_maps);
0268 
0269     for_each_child_of_node(np_config, np) {
0270         ret = samsung_dt_subnode_to_map(drvdata, pctldev->dev, np, map,
0271                         &reserved_maps, num_maps);
0272         if (ret < 0) {
0273             samsung_dt_free_map(pctldev, *map, *num_maps);
0274             of_node_put(np);
0275             return ret;
0276         }
0277     }
0278 
0279     return 0;
0280 }
0281 
0282 #ifdef CONFIG_DEBUG_FS
0283 /* Forward declaration which can be used by samsung_pin_dbg_show */
0284 static int samsung_pinconf_get(struct pinctrl_dev *pctldev, unsigned int pin,
0285                     unsigned long *config);
0286 static const char * const reg_names[] = {"CON", "DAT", "PUD", "DRV", "CON_PDN",
0287                      "PUD_PDN"};
0288 
0289 static void samsung_pin_dbg_show(struct pinctrl_dev *pctldev,
0290                 struct seq_file *s, unsigned int pin)
0291 {
0292     enum pincfg_type cfg_type;
0293     unsigned long config;
0294     int ret;
0295 
0296     for (cfg_type = 0; cfg_type < PINCFG_TYPE_NUM; cfg_type++) {
0297         config = PINCFG_PACK(cfg_type, 0);
0298         ret = samsung_pinconf_get(pctldev, pin, &config);
0299         if (ret < 0)
0300             continue;
0301 
0302         seq_printf(s, " %s(0x%lx)", reg_names[cfg_type],
0303                PINCFG_UNPACK_VALUE(config));
0304     }
0305 }
0306 #endif
0307 
0308 /* list of pinctrl callbacks for the pinctrl core */
0309 static const struct pinctrl_ops samsung_pctrl_ops = {
0310     .get_groups_count   = samsung_get_group_count,
0311     .get_group_name     = samsung_get_group_name,
0312     .get_group_pins     = samsung_get_group_pins,
0313     .dt_node_to_map     = samsung_dt_node_to_map,
0314     .dt_free_map        = samsung_dt_free_map,
0315 #ifdef CONFIG_DEBUG_FS
0316     .pin_dbg_show       = samsung_pin_dbg_show,
0317 #endif
0318 };
0319 
0320 /* check if the selector is a valid pin function selector */
0321 static int samsung_get_functions_count(struct pinctrl_dev *pctldev)
0322 {
0323     struct samsung_pinctrl_drv_data *drvdata;
0324 
0325     drvdata = pinctrl_dev_get_drvdata(pctldev);
0326     return drvdata->nr_functions;
0327 }
0328 
0329 /* return the name of the pin function specified */
0330 static const char *samsung_pinmux_get_fname(struct pinctrl_dev *pctldev,
0331                         unsigned selector)
0332 {
0333     struct samsung_pinctrl_drv_data *drvdata;
0334 
0335     drvdata = pinctrl_dev_get_drvdata(pctldev);
0336     return drvdata->pmx_functions[selector].name;
0337 }
0338 
0339 /* return the groups associated for the specified function selector */
0340 static int samsung_pinmux_get_groups(struct pinctrl_dev *pctldev,
0341         unsigned selector, const char * const **groups,
0342         unsigned * const num_groups)
0343 {
0344     struct samsung_pinctrl_drv_data *drvdata;
0345 
0346     drvdata = pinctrl_dev_get_drvdata(pctldev);
0347     *groups = drvdata->pmx_functions[selector].groups;
0348     *num_groups = drvdata->pmx_functions[selector].num_groups;
0349     return 0;
0350 }
0351 
0352 /*
0353  * given a pin number that is local to a pin controller, find out the pin bank
0354  * and the register base of the pin bank.
0355  */
0356 static void pin_to_reg_bank(struct samsung_pinctrl_drv_data *drvdata,
0357             unsigned pin, void __iomem **reg, u32 *offset,
0358             struct samsung_pin_bank **bank)
0359 {
0360     struct samsung_pin_bank *b;
0361 
0362     b = drvdata->pin_banks;
0363 
0364     while ((pin >= b->pin_base) &&
0365             ((b->pin_base + b->nr_pins - 1) < pin))
0366         b++;
0367 
0368     *reg = b->pctl_base + b->pctl_offset;
0369     *offset = pin - b->pin_base;
0370     if (bank)
0371         *bank = b;
0372 }
0373 
0374 /* enable or disable a pinmux function */
0375 static void samsung_pinmux_setup(struct pinctrl_dev *pctldev, unsigned selector,
0376                     unsigned group)
0377 {
0378     struct samsung_pinctrl_drv_data *drvdata;
0379     const struct samsung_pin_bank_type *type;
0380     struct samsung_pin_bank *bank;
0381     void __iomem *reg;
0382     u32 mask, shift, data, pin_offset;
0383     unsigned long flags;
0384     const struct samsung_pmx_func *func;
0385     const struct samsung_pin_group *grp;
0386 
0387     drvdata = pinctrl_dev_get_drvdata(pctldev);
0388     func = &drvdata->pmx_functions[selector];
0389     grp = &drvdata->pin_groups[group];
0390 
0391     pin_to_reg_bank(drvdata, grp->pins[0] - drvdata->pin_base,
0392             &reg, &pin_offset, &bank);
0393     type = bank->type;
0394     mask = (1 << type->fld_width[PINCFG_TYPE_FUNC]) - 1;
0395     shift = pin_offset * type->fld_width[PINCFG_TYPE_FUNC];
0396     if (shift >= 32) {
0397         /* Some banks have two config registers */
0398         shift -= 32;
0399         reg += 4;
0400     }
0401 
0402     raw_spin_lock_irqsave(&bank->slock, flags);
0403 
0404     data = readl(reg + type->reg_offset[PINCFG_TYPE_FUNC]);
0405     data &= ~(mask << shift);
0406     data |= func->val << shift;
0407     writel(data, reg + type->reg_offset[PINCFG_TYPE_FUNC]);
0408 
0409     raw_spin_unlock_irqrestore(&bank->slock, flags);
0410 }
0411 
0412 /* enable a specified pinmux by writing to registers */
0413 static int samsung_pinmux_set_mux(struct pinctrl_dev *pctldev,
0414                   unsigned selector,
0415                   unsigned group)
0416 {
0417     samsung_pinmux_setup(pctldev, selector, group);
0418     return 0;
0419 }
0420 
0421 /* list of pinmux callbacks for the pinmux vertical in pinctrl core */
0422 static const struct pinmux_ops samsung_pinmux_ops = {
0423     .get_functions_count    = samsung_get_functions_count,
0424     .get_function_name  = samsung_pinmux_get_fname,
0425     .get_function_groups    = samsung_pinmux_get_groups,
0426     .set_mux        = samsung_pinmux_set_mux,
0427 };
0428 
0429 /* set or get the pin config settings for a specified pin */
0430 static int samsung_pinconf_rw(struct pinctrl_dev *pctldev, unsigned int pin,
0431                 unsigned long *config, bool set)
0432 {
0433     struct samsung_pinctrl_drv_data *drvdata;
0434     const struct samsung_pin_bank_type *type;
0435     struct samsung_pin_bank *bank;
0436     void __iomem *reg_base;
0437     enum pincfg_type cfg_type = PINCFG_UNPACK_TYPE(*config);
0438     u32 data, width, pin_offset, mask, shift;
0439     u32 cfg_value, cfg_reg;
0440     unsigned long flags;
0441 
0442     drvdata = pinctrl_dev_get_drvdata(pctldev);
0443     pin_to_reg_bank(drvdata, pin - drvdata->pin_base, &reg_base,
0444                     &pin_offset, &bank);
0445     type = bank->type;
0446 
0447     if (cfg_type >= PINCFG_TYPE_NUM || !type->fld_width[cfg_type])
0448         return -EINVAL;
0449 
0450     width = type->fld_width[cfg_type];
0451     cfg_reg = type->reg_offset[cfg_type];
0452 
0453     raw_spin_lock_irqsave(&bank->slock, flags);
0454 
0455     mask = (1 << width) - 1;
0456     shift = pin_offset * width;
0457     data = readl(reg_base + cfg_reg);
0458 
0459     if (set) {
0460         cfg_value = PINCFG_UNPACK_VALUE(*config);
0461         data &= ~(mask << shift);
0462         data |= (cfg_value << shift);
0463         writel(data, reg_base + cfg_reg);
0464     } else {
0465         data >>= shift;
0466         data &= mask;
0467         *config = PINCFG_PACK(cfg_type, data);
0468     }
0469 
0470     raw_spin_unlock_irqrestore(&bank->slock, flags);
0471 
0472     return 0;
0473 }
0474 
0475 /* set the pin config settings for a specified pin */
0476 static int samsung_pinconf_set(struct pinctrl_dev *pctldev, unsigned int pin,
0477                 unsigned long *configs, unsigned num_configs)
0478 {
0479     int i, ret;
0480 
0481     for (i = 0; i < num_configs; i++) {
0482         ret = samsung_pinconf_rw(pctldev, pin, &configs[i], true);
0483         if (ret < 0)
0484             return ret;
0485     } /* for each config */
0486 
0487     return 0;
0488 }
0489 
0490 /* get the pin config settings for a specified pin */
0491 static int samsung_pinconf_get(struct pinctrl_dev *pctldev, unsigned int pin,
0492                     unsigned long *config)
0493 {
0494     return samsung_pinconf_rw(pctldev, pin, config, false);
0495 }
0496 
0497 /* set the pin config settings for a specified pin group */
0498 static int samsung_pinconf_group_set(struct pinctrl_dev *pctldev,
0499             unsigned group, unsigned long *configs,
0500             unsigned num_configs)
0501 {
0502     struct samsung_pinctrl_drv_data *drvdata;
0503     const unsigned int *pins;
0504     unsigned int cnt;
0505 
0506     drvdata = pinctrl_dev_get_drvdata(pctldev);
0507     pins = drvdata->pin_groups[group].pins;
0508 
0509     for (cnt = 0; cnt < drvdata->pin_groups[group].num_pins; cnt++)
0510         samsung_pinconf_set(pctldev, pins[cnt], configs, num_configs);
0511 
0512     return 0;
0513 }
0514 
0515 /* get the pin config settings for a specified pin group */
0516 static int samsung_pinconf_group_get(struct pinctrl_dev *pctldev,
0517                 unsigned int group, unsigned long *config)
0518 {
0519     struct samsung_pinctrl_drv_data *drvdata;
0520     const unsigned int *pins;
0521 
0522     drvdata = pinctrl_dev_get_drvdata(pctldev);
0523     pins = drvdata->pin_groups[group].pins;
0524     samsung_pinconf_get(pctldev, pins[0], config);
0525     return 0;
0526 }
0527 
0528 /* list of pinconfig callbacks for pinconfig vertical in the pinctrl code */
0529 static const struct pinconf_ops samsung_pinconf_ops = {
0530     .pin_config_get     = samsung_pinconf_get,
0531     .pin_config_set     = samsung_pinconf_set,
0532     .pin_config_group_get   = samsung_pinconf_group_get,
0533     .pin_config_group_set   = samsung_pinconf_group_set,
0534 };
0535 
0536 /*
0537  * The samsung_gpio_set_vlaue() should be called with "bank->slock" held
0538  * to avoid race condition.
0539  */
0540 static void samsung_gpio_set_value(struct gpio_chip *gc,
0541                       unsigned offset, int value)
0542 {
0543     struct samsung_pin_bank *bank = gpiochip_get_data(gc);
0544     const struct samsung_pin_bank_type *type = bank->type;
0545     void __iomem *reg;
0546     u32 data;
0547 
0548     reg = bank->pctl_base + bank->pctl_offset;
0549 
0550     data = readl(reg + type->reg_offset[PINCFG_TYPE_DAT]);
0551     data &= ~(1 << offset);
0552     if (value)
0553         data |= 1 << offset;
0554     writel(data, reg + type->reg_offset[PINCFG_TYPE_DAT]);
0555 }
0556 
0557 /* gpiolib gpio_set callback function */
0558 static void samsung_gpio_set(struct gpio_chip *gc, unsigned offset, int value)
0559 {
0560     struct samsung_pin_bank *bank = gpiochip_get_data(gc);
0561     unsigned long flags;
0562 
0563     raw_spin_lock_irqsave(&bank->slock, flags);
0564     samsung_gpio_set_value(gc, offset, value);
0565     raw_spin_unlock_irqrestore(&bank->slock, flags);
0566 }
0567 
0568 /* gpiolib gpio_get callback function */
0569 static int samsung_gpio_get(struct gpio_chip *gc, unsigned offset)
0570 {
0571     void __iomem *reg;
0572     u32 data;
0573     struct samsung_pin_bank *bank = gpiochip_get_data(gc);
0574     const struct samsung_pin_bank_type *type = bank->type;
0575 
0576     reg = bank->pctl_base + bank->pctl_offset;
0577 
0578     data = readl(reg + type->reg_offset[PINCFG_TYPE_DAT]);
0579     data >>= offset;
0580     data &= 1;
0581     return data;
0582 }
0583 
0584 /*
0585  * The samsung_gpio_set_direction() should be called with "bank->slock" held
0586  * to avoid race condition.
0587  * The calls to gpio_direction_output() and gpio_direction_input()
0588  * leads to this function call.
0589  */
0590 static int samsung_gpio_set_direction(struct gpio_chip *gc,
0591                          unsigned offset, bool input)
0592 {
0593     const struct samsung_pin_bank_type *type;
0594     struct samsung_pin_bank *bank;
0595     void __iomem *reg;
0596     u32 data, mask, shift;
0597 
0598     bank = gpiochip_get_data(gc);
0599     type = bank->type;
0600 
0601     reg = bank->pctl_base + bank->pctl_offset
0602             + type->reg_offset[PINCFG_TYPE_FUNC];
0603 
0604     mask = (1 << type->fld_width[PINCFG_TYPE_FUNC]) - 1;
0605     shift = offset * type->fld_width[PINCFG_TYPE_FUNC];
0606     if (shift >= 32) {
0607         /* Some banks have two config registers */
0608         shift -= 32;
0609         reg += 4;
0610     }
0611 
0612     data = readl(reg);
0613     data &= ~(mask << shift);
0614     if (!input)
0615         data |= PIN_CON_FUNC_OUTPUT << shift;
0616     writel(data, reg);
0617 
0618     return 0;
0619 }
0620 
0621 /* gpiolib gpio_direction_input callback function. */
0622 static int samsung_gpio_direction_input(struct gpio_chip *gc, unsigned offset)
0623 {
0624     struct samsung_pin_bank *bank = gpiochip_get_data(gc);
0625     unsigned long flags;
0626     int ret;
0627 
0628     raw_spin_lock_irqsave(&bank->slock, flags);
0629     ret = samsung_gpio_set_direction(gc, offset, true);
0630     raw_spin_unlock_irqrestore(&bank->slock, flags);
0631     return ret;
0632 }
0633 
0634 /* gpiolib gpio_direction_output callback function. */
0635 static int samsung_gpio_direction_output(struct gpio_chip *gc, unsigned offset,
0636                             int value)
0637 {
0638     struct samsung_pin_bank *bank = gpiochip_get_data(gc);
0639     unsigned long flags;
0640     int ret;
0641 
0642     raw_spin_lock_irqsave(&bank->slock, flags);
0643     samsung_gpio_set_value(gc, offset, value);
0644     ret = samsung_gpio_set_direction(gc, offset, false);
0645     raw_spin_unlock_irqrestore(&bank->slock, flags);
0646 
0647     return ret;
0648 }
0649 
0650 /*
0651  * gpiolib gpio_to_irq callback function. Creates a mapping between a GPIO pin
0652  * and a virtual IRQ, if not already present.
0653  */
0654 static int samsung_gpio_to_irq(struct gpio_chip *gc, unsigned offset)
0655 {
0656     struct samsung_pin_bank *bank = gpiochip_get_data(gc);
0657     unsigned int virq;
0658 
0659     if (!bank->irq_domain)
0660         return -ENXIO;
0661 
0662     virq = irq_create_mapping(bank->irq_domain, offset);
0663 
0664     return (virq) ? : -ENXIO;
0665 }
0666 
0667 static struct samsung_pin_group *samsung_pinctrl_create_groups(
0668                 struct device *dev,
0669                 struct samsung_pinctrl_drv_data *drvdata,
0670                 unsigned int *cnt)
0671 {
0672     struct pinctrl_desc *ctrldesc = &drvdata->pctl;
0673     struct samsung_pin_group *groups, *grp;
0674     const struct pinctrl_pin_desc *pdesc;
0675     int i;
0676 
0677     groups = devm_kcalloc(dev, ctrldesc->npins, sizeof(*groups),
0678                 GFP_KERNEL);
0679     if (!groups)
0680         return ERR_PTR(-EINVAL);
0681     grp = groups;
0682 
0683     pdesc = ctrldesc->pins;
0684     for (i = 0; i < ctrldesc->npins; ++i, ++pdesc, ++grp) {
0685         grp->name = pdesc->name;
0686         grp->pins = &pdesc->number;
0687         grp->num_pins = 1;
0688     }
0689 
0690     *cnt = ctrldesc->npins;
0691     return groups;
0692 }
0693 
0694 static int samsung_pinctrl_create_function(struct device *dev,
0695                 struct samsung_pinctrl_drv_data *drvdata,
0696                 struct device_node *func_np,
0697                 struct samsung_pmx_func *func)
0698 {
0699     int npins;
0700     int ret;
0701     int i;
0702 
0703     if (of_property_read_u32(func_np, "samsung,pin-function", &func->val))
0704         return 0;
0705 
0706     npins = of_property_count_strings(func_np, "samsung,pins");
0707     if (npins < 1) {
0708         dev_err(dev, "invalid pin list in %pOFn node", func_np);
0709         return -EINVAL;
0710     }
0711 
0712     func->name = func_np->full_name;
0713 
0714     func->groups = devm_kcalloc(dev, npins, sizeof(char *), GFP_KERNEL);
0715     if (!func->groups)
0716         return -ENOMEM;
0717 
0718     for (i = 0; i < npins; ++i) {
0719         const char *gname;
0720 
0721         ret = of_property_read_string_index(func_np, "samsung,pins",
0722                             i, &gname);
0723         if (ret) {
0724             dev_err(dev,
0725                 "failed to read pin name %d from %pOFn node\n",
0726                 i, func_np);
0727             return ret;
0728         }
0729 
0730         func->groups[i] = gname;
0731     }
0732 
0733     func->num_groups = npins;
0734     return 1;
0735 }
0736 
0737 static struct samsung_pmx_func *samsung_pinctrl_create_functions(
0738                 struct device *dev,
0739                 struct samsung_pinctrl_drv_data *drvdata,
0740                 unsigned int *cnt)
0741 {
0742     struct samsung_pmx_func *functions, *func;
0743     struct device_node *dev_np = dev->of_node;
0744     struct device_node *cfg_np;
0745     unsigned int func_cnt = 0;
0746     int ret;
0747 
0748     /*
0749      * Iterate over all the child nodes of the pin controller node
0750      * and create pin groups and pin function lists.
0751      */
0752     for_each_child_of_node(dev_np, cfg_np) {
0753         struct device_node *func_np;
0754 
0755         if (!of_get_child_count(cfg_np)) {
0756             if (!of_find_property(cfg_np,
0757                 "samsung,pin-function", NULL))
0758                 continue;
0759             ++func_cnt;
0760             continue;
0761         }
0762 
0763         for_each_child_of_node(cfg_np, func_np) {
0764             if (!of_find_property(func_np,
0765                 "samsung,pin-function", NULL))
0766                 continue;
0767             ++func_cnt;
0768         }
0769     }
0770 
0771     functions = devm_kcalloc(dev, func_cnt, sizeof(*functions),
0772                     GFP_KERNEL);
0773     if (!functions)
0774         return ERR_PTR(-ENOMEM);
0775     func = functions;
0776 
0777     /*
0778      * Iterate over all the child nodes of the pin controller node
0779      * and create pin groups and pin function lists.
0780      */
0781     func_cnt = 0;
0782     for_each_child_of_node(dev_np, cfg_np) {
0783         struct device_node *func_np;
0784 
0785         if (!of_get_child_count(cfg_np)) {
0786             ret = samsung_pinctrl_create_function(dev, drvdata,
0787                             cfg_np, func);
0788             if (ret < 0) {
0789                 of_node_put(cfg_np);
0790                 return ERR_PTR(ret);
0791             }
0792             if (ret > 0) {
0793                 ++func;
0794                 ++func_cnt;
0795             }
0796             continue;
0797         }
0798 
0799         for_each_child_of_node(cfg_np, func_np) {
0800             ret = samsung_pinctrl_create_function(dev, drvdata,
0801                         func_np, func);
0802             if (ret < 0) {
0803                 of_node_put(func_np);
0804                 of_node_put(cfg_np);
0805                 return ERR_PTR(ret);
0806             }
0807             if (ret > 0) {
0808                 ++func;
0809                 ++func_cnt;
0810             }
0811         }
0812     }
0813 
0814     *cnt = func_cnt;
0815     return functions;
0816 }
0817 
0818 /*
0819  * Parse the information about all the available pin groups and pin functions
0820  * from device node of the pin-controller. A pin group is formed with all
0821  * the pins listed in the "samsung,pins" property.
0822  */
0823 
0824 static int samsung_pinctrl_parse_dt(struct platform_device *pdev,
0825                     struct samsung_pinctrl_drv_data *drvdata)
0826 {
0827     struct device *dev = &pdev->dev;
0828     struct samsung_pin_group *groups;
0829     struct samsung_pmx_func *functions;
0830     unsigned int grp_cnt = 0, func_cnt = 0;
0831 
0832     groups = samsung_pinctrl_create_groups(dev, drvdata, &grp_cnt);
0833     if (IS_ERR(groups)) {
0834         dev_err(dev, "failed to parse pin groups\n");
0835         return PTR_ERR(groups);
0836     }
0837 
0838     functions = samsung_pinctrl_create_functions(dev, drvdata, &func_cnt);
0839     if (IS_ERR(functions)) {
0840         dev_err(dev, "failed to parse pin functions\n");
0841         return PTR_ERR(functions);
0842     }
0843 
0844     drvdata->pin_groups = groups;
0845     drvdata->nr_groups = grp_cnt;
0846     drvdata->pmx_functions = functions;
0847     drvdata->nr_functions = func_cnt;
0848 
0849     return 0;
0850 }
0851 
0852 /* register the pinctrl interface with the pinctrl subsystem */
0853 static int samsung_pinctrl_register(struct platform_device *pdev,
0854                     struct samsung_pinctrl_drv_data *drvdata)
0855 {
0856     struct pinctrl_desc *ctrldesc = &drvdata->pctl;
0857     struct pinctrl_pin_desc *pindesc, *pdesc;
0858     struct samsung_pin_bank *pin_bank;
0859     char *pin_names;
0860     int pin, bank, ret;
0861 
0862     ctrldesc->name = "samsung-pinctrl";
0863     ctrldesc->owner = THIS_MODULE;
0864     ctrldesc->pctlops = &samsung_pctrl_ops;
0865     ctrldesc->pmxops = &samsung_pinmux_ops;
0866     ctrldesc->confops = &samsung_pinconf_ops;
0867 
0868     pindesc = devm_kcalloc(&pdev->dev,
0869                    drvdata->nr_pins, sizeof(*pindesc),
0870                    GFP_KERNEL);
0871     if (!pindesc)
0872         return -ENOMEM;
0873     ctrldesc->pins = pindesc;
0874     ctrldesc->npins = drvdata->nr_pins;
0875 
0876     /* dynamically populate the pin number and pin name for pindesc */
0877     for (pin = 0, pdesc = pindesc; pin < ctrldesc->npins; pin++, pdesc++)
0878         pdesc->number = pin + drvdata->pin_base;
0879 
0880     /*
0881      * allocate space for storing the dynamically generated names for all
0882      * the pins which belong to this pin-controller.
0883      */
0884     pin_names = devm_kzalloc(&pdev->dev,
0885                  array3_size(sizeof(char), PIN_NAME_LENGTH,
0886                          drvdata->nr_pins),
0887                  GFP_KERNEL);
0888     if (!pin_names)
0889         return -ENOMEM;
0890 
0891     /* for each pin, the name of the pin is pin-bank name + pin number */
0892     for (bank = 0; bank < drvdata->nr_banks; bank++) {
0893         pin_bank = &drvdata->pin_banks[bank];
0894         for (pin = 0; pin < pin_bank->nr_pins; pin++) {
0895             sprintf(pin_names, "%s-%d", pin_bank->name, pin);
0896             pdesc = pindesc + pin_bank->pin_base + pin;
0897             pdesc->name = pin_names;
0898             pin_names += PIN_NAME_LENGTH;
0899         }
0900     }
0901 
0902     ret = samsung_pinctrl_parse_dt(pdev, drvdata);
0903     if (ret)
0904         return ret;
0905 
0906     drvdata->pctl_dev = devm_pinctrl_register(&pdev->dev, ctrldesc,
0907                           drvdata);
0908     if (IS_ERR(drvdata->pctl_dev)) {
0909         dev_err(&pdev->dev, "could not register pinctrl driver\n");
0910         return PTR_ERR(drvdata->pctl_dev);
0911     }
0912 
0913     for (bank = 0; bank < drvdata->nr_banks; ++bank) {
0914         pin_bank = &drvdata->pin_banks[bank];
0915         pin_bank->grange.name = pin_bank->name;
0916         pin_bank->grange.id = bank;
0917         pin_bank->grange.pin_base = drvdata->pin_base
0918                         + pin_bank->pin_base;
0919         pin_bank->grange.base = pin_bank->grange.pin_base;
0920         pin_bank->grange.npins = pin_bank->nr_pins;
0921         pin_bank->grange.gc = &pin_bank->gpio_chip;
0922         pinctrl_add_gpio_range(drvdata->pctl_dev, &pin_bank->grange);
0923     }
0924 
0925     return 0;
0926 }
0927 
0928 /* unregister the pinctrl interface with the pinctrl subsystem */
0929 static int samsung_pinctrl_unregister(struct platform_device *pdev,
0930                       struct samsung_pinctrl_drv_data *drvdata)
0931 {
0932     struct samsung_pin_bank *bank = drvdata->pin_banks;
0933     int i;
0934 
0935     for (i = 0; i < drvdata->nr_banks; ++i, ++bank)
0936         pinctrl_remove_gpio_range(drvdata->pctl_dev, &bank->grange);
0937 
0938     return 0;
0939 }
0940 
0941 static const struct gpio_chip samsung_gpiolib_chip = {
0942     .request = gpiochip_generic_request,
0943     .free = gpiochip_generic_free,
0944     .set = samsung_gpio_set,
0945     .get = samsung_gpio_get,
0946     .direction_input = samsung_gpio_direction_input,
0947     .direction_output = samsung_gpio_direction_output,
0948     .to_irq = samsung_gpio_to_irq,
0949     .owner = THIS_MODULE,
0950 };
0951 
0952 /* register the gpiolib interface with the gpiolib subsystem */
0953 static int samsung_gpiolib_register(struct platform_device *pdev,
0954                     struct samsung_pinctrl_drv_data *drvdata)
0955 {
0956     struct samsung_pin_bank *bank = drvdata->pin_banks;
0957     struct gpio_chip *gc;
0958     int ret;
0959     int i;
0960 
0961     for (i = 0; i < drvdata->nr_banks; ++i, ++bank) {
0962         bank->gpio_chip = samsung_gpiolib_chip;
0963 
0964         gc = &bank->gpio_chip;
0965         gc->base = bank->grange.base;
0966         gc->ngpio = bank->nr_pins;
0967         gc->parent = &pdev->dev;
0968         gc->fwnode = bank->fwnode;
0969         gc->label = bank->name;
0970 
0971         ret = devm_gpiochip_add_data(&pdev->dev, gc, bank);
0972         if (ret) {
0973             dev_err(&pdev->dev, "failed to register gpio_chip %s, error code: %d\n",
0974                             gc->label, ret);
0975             return ret;
0976         }
0977     }
0978 
0979     return 0;
0980 }
0981 
0982 static const struct samsung_pin_ctrl *
0983 samsung_pinctrl_get_soc_data_for_of_alias(struct platform_device *pdev)
0984 {
0985     struct device_node *node = pdev->dev.of_node;
0986     const struct samsung_pinctrl_of_match_data *of_data;
0987     int id;
0988 
0989     id = of_alias_get_id(node, "pinctrl");
0990     if (id < 0) {
0991         dev_err(&pdev->dev, "failed to get alias id\n");
0992         return NULL;
0993     }
0994 
0995     of_data = of_device_get_match_data(&pdev->dev);
0996     if (id >= of_data->num_ctrl) {
0997         dev_err(&pdev->dev, "invalid alias id %d\n", id);
0998         return NULL;
0999     }
1000 
1001     return &(of_data->ctrl[id]);
1002 }
1003 
1004 static void samsung_banks_node_put(struct samsung_pinctrl_drv_data *d)
1005 {
1006     struct samsung_pin_bank *bank;
1007     unsigned int i;
1008 
1009     bank = d->pin_banks;
1010     for (i = 0; i < d->nr_banks; ++i, ++bank)
1011         fwnode_handle_put(bank->fwnode);
1012 }
1013 
1014 /*
1015  * Iterate over all driver pin banks to find one matching the name of node,
1016  * skipping optional "-gpio" node suffix. When found, assign node to the bank.
1017  */
1018 static void samsung_banks_node_get(struct device *dev, struct samsung_pinctrl_drv_data *d)
1019 {
1020     const char *suffix = "-gpio-bank";
1021     struct samsung_pin_bank *bank;
1022     struct fwnode_handle *child;
1023     /* Pin bank names are up to 4 characters */
1024     char node_name[20];
1025     unsigned int i;
1026     size_t len;
1027 
1028     bank = d->pin_banks;
1029     for (i = 0; i < d->nr_banks; ++i, ++bank) {
1030         strscpy(node_name, bank->name, sizeof(node_name));
1031         len = strlcat(node_name, suffix, sizeof(node_name));
1032         if (len >= sizeof(node_name)) {
1033             dev_err(dev, "Too long pin bank name '%s', ignoring\n",
1034                 bank->name);
1035             continue;
1036         }
1037 
1038         for_each_gpiochip_node(dev, child) {
1039             struct device_node *np = to_of_node(child);
1040 
1041             if (of_node_name_eq(np, node_name))
1042                 break;
1043             if (of_node_name_eq(np, bank->name))
1044                 break;
1045         }
1046 
1047         if (child)
1048             bank->fwnode = child;
1049         else
1050             dev_warn(dev, "Missing node for bank %s - invalid DTB\n",
1051                  bank->name);
1052         /* child reference dropped in samsung_drop_banks_of_node() */
1053     }
1054 }
1055 
1056 /* retrieve the soc specific data */
1057 static const struct samsung_pin_ctrl *
1058 samsung_pinctrl_get_soc_data(struct samsung_pinctrl_drv_data *d,
1059                  struct platform_device *pdev)
1060 {
1061     const struct samsung_pin_bank_data *bdata;
1062     const struct samsung_pin_ctrl *ctrl;
1063     struct samsung_pin_bank *bank;
1064     struct resource *res;
1065     void __iomem *virt_base[SAMSUNG_PINCTRL_NUM_RESOURCES];
1066     unsigned int i;
1067 
1068     ctrl = samsung_pinctrl_get_soc_data_for_of_alias(pdev);
1069     if (!ctrl)
1070         return ERR_PTR(-ENOENT);
1071 
1072     d->suspend = ctrl->suspend;
1073     d->resume = ctrl->resume;
1074     d->nr_banks = ctrl->nr_banks;
1075     d->pin_banks = devm_kcalloc(&pdev->dev, d->nr_banks,
1076                     sizeof(*d->pin_banks), GFP_KERNEL);
1077     if (!d->pin_banks)
1078         return ERR_PTR(-ENOMEM);
1079 
1080     if (ctrl->nr_ext_resources + 1 > SAMSUNG_PINCTRL_NUM_RESOURCES)
1081         return ERR_PTR(-EINVAL);
1082 
1083     for (i = 0; i < ctrl->nr_ext_resources + 1; i++) {
1084         res = platform_get_resource(pdev, IORESOURCE_MEM, i);
1085         if (!res) {
1086             dev_err(&pdev->dev, "failed to get mem%d resource\n", i);
1087             return ERR_PTR(-EINVAL);
1088         }
1089         virt_base[i] = devm_ioremap(&pdev->dev, res->start,
1090                         resource_size(res));
1091         if (!virt_base[i]) {
1092             dev_err(&pdev->dev, "failed to ioremap %pR\n", res);
1093             return ERR_PTR(-EIO);
1094         }
1095     }
1096 
1097     bank = d->pin_banks;
1098     bdata = ctrl->pin_banks;
1099     for (i = 0; i < ctrl->nr_banks; ++i, ++bdata, ++bank) {
1100         bank->type = bdata->type;
1101         bank->pctl_offset = bdata->pctl_offset;
1102         bank->nr_pins = bdata->nr_pins;
1103         bank->eint_func = bdata->eint_func;
1104         bank->eint_type = bdata->eint_type;
1105         bank->eint_mask = bdata->eint_mask;
1106         bank->eint_offset = bdata->eint_offset;
1107         bank->name = bdata->name;
1108 
1109         raw_spin_lock_init(&bank->slock);
1110         bank->drvdata = d;
1111         bank->pin_base = d->nr_pins;
1112         d->nr_pins += bank->nr_pins;
1113 
1114         bank->eint_base = virt_base[0];
1115         bank->pctl_base = virt_base[bdata->pctl_res_idx];
1116     }
1117     /*
1118      * Legacy platforms should provide only one resource with IO memory.
1119      * Store it as virt_base because legacy driver needs to access it
1120      * through samsung_pinctrl_drv_data.
1121      */
1122     d->virt_base = virt_base[0];
1123 
1124     samsung_banks_node_get(&pdev->dev, d);
1125 
1126     d->pin_base = pin_base;
1127     pin_base += d->nr_pins;
1128 
1129     return ctrl;
1130 }
1131 
1132 static int samsung_pinctrl_probe(struct platform_device *pdev)
1133 {
1134     struct samsung_pinctrl_drv_data *drvdata;
1135     const struct samsung_pin_ctrl *ctrl;
1136     struct device *dev = &pdev->dev;
1137     int ret;
1138 
1139     drvdata = devm_kzalloc(dev, sizeof(*drvdata), GFP_KERNEL);
1140     if (!drvdata)
1141         return -ENOMEM;
1142 
1143     ctrl = samsung_pinctrl_get_soc_data(drvdata, pdev);
1144     if (IS_ERR(ctrl)) {
1145         dev_err(&pdev->dev, "driver data not available\n");
1146         return PTR_ERR(ctrl);
1147     }
1148     drvdata->dev = dev;
1149 
1150     ret = platform_get_irq_optional(pdev, 0);
1151     if (ret < 0 && ret != -ENXIO)
1152         return ret;
1153     if (ret > 0)
1154         drvdata->irq = ret;
1155 
1156     if (ctrl->retention_data) {
1157         drvdata->retention_ctrl = ctrl->retention_data->init(drvdata,
1158                               ctrl->retention_data);
1159         if (IS_ERR(drvdata->retention_ctrl)) {
1160             ret = PTR_ERR(drvdata->retention_ctrl);
1161             goto err_put_banks;
1162         }
1163     }
1164 
1165     ret = samsung_pinctrl_register(pdev, drvdata);
1166     if (ret)
1167         goto err_put_banks;
1168 
1169     ret = samsung_gpiolib_register(pdev, drvdata);
1170     if (ret)
1171         goto err_unregister;
1172 
1173     if (ctrl->eint_gpio_init)
1174         ctrl->eint_gpio_init(drvdata);
1175     if (ctrl->eint_wkup_init)
1176         ctrl->eint_wkup_init(drvdata);
1177 
1178     platform_set_drvdata(pdev, drvdata);
1179 
1180     return 0;
1181 
1182 err_unregister:
1183     samsung_pinctrl_unregister(pdev, drvdata);
1184 err_put_banks:
1185     samsung_banks_node_put(drvdata);
1186     return ret;
1187 }
1188 
1189 /*
1190  * samsung_pinctrl_suspend - save pinctrl state for suspend
1191  *
1192  * Save data for all banks handled by this device.
1193  */
1194 static int __maybe_unused samsung_pinctrl_suspend(struct device *dev)
1195 {
1196     struct samsung_pinctrl_drv_data *drvdata = dev_get_drvdata(dev);
1197     int i;
1198 
1199     for (i = 0; i < drvdata->nr_banks; i++) {
1200         struct samsung_pin_bank *bank = &drvdata->pin_banks[i];
1201         void __iomem *reg = bank->pctl_base + bank->pctl_offset;
1202         const u8 *offs = bank->type->reg_offset;
1203         const u8 *widths = bank->type->fld_width;
1204         enum pincfg_type type;
1205 
1206         /* Registers without a powerdown config aren't lost */
1207         if (!widths[PINCFG_TYPE_CON_PDN])
1208             continue;
1209 
1210         for (type = 0; type < PINCFG_TYPE_NUM; type++)
1211             if (widths[type])
1212                 bank->pm_save[type] = readl(reg + offs[type]);
1213 
1214         if (widths[PINCFG_TYPE_FUNC] * bank->nr_pins > 32) {
1215             /* Some banks have two config registers */
1216             bank->pm_save[PINCFG_TYPE_NUM] =
1217                 readl(reg + offs[PINCFG_TYPE_FUNC] + 4);
1218             pr_debug("Save %s @ %p (con %#010x %08x)\n",
1219                  bank->name, reg,
1220                  bank->pm_save[PINCFG_TYPE_FUNC],
1221                  bank->pm_save[PINCFG_TYPE_NUM]);
1222         } else {
1223             pr_debug("Save %s @ %p (con %#010x)\n", bank->name,
1224                  reg, bank->pm_save[PINCFG_TYPE_FUNC]);
1225         }
1226     }
1227 
1228     if (drvdata->suspend)
1229         drvdata->suspend(drvdata);
1230     if (drvdata->retention_ctrl && drvdata->retention_ctrl->enable)
1231         drvdata->retention_ctrl->enable(drvdata);
1232 
1233     return 0;
1234 }
1235 
1236 /*
1237  * samsung_pinctrl_resume - restore pinctrl state from suspend
1238  *
1239  * Restore one of the banks that was saved during suspend.
1240  *
1241  * We don't bother doing anything complicated to avoid glitching lines since
1242  * we're called before pad retention is turned off.
1243  */
1244 static int __maybe_unused samsung_pinctrl_resume(struct device *dev)
1245 {
1246     struct samsung_pinctrl_drv_data *drvdata = dev_get_drvdata(dev);
1247     int i;
1248 
1249     if (drvdata->resume)
1250         drvdata->resume(drvdata);
1251 
1252     for (i = 0; i < drvdata->nr_banks; i++) {
1253         struct samsung_pin_bank *bank = &drvdata->pin_banks[i];
1254         void __iomem *reg = bank->pctl_base + bank->pctl_offset;
1255         const u8 *offs = bank->type->reg_offset;
1256         const u8 *widths = bank->type->fld_width;
1257         enum pincfg_type type;
1258 
1259         /* Registers without a powerdown config aren't lost */
1260         if (!widths[PINCFG_TYPE_CON_PDN])
1261             continue;
1262 
1263         if (widths[PINCFG_TYPE_FUNC] * bank->nr_pins > 32) {
1264             /* Some banks have two config registers */
1265             pr_debug("%s @ %p (con %#010x %08x => %#010x %08x)\n",
1266                  bank->name, reg,
1267                  readl(reg + offs[PINCFG_TYPE_FUNC]),
1268                  readl(reg + offs[PINCFG_TYPE_FUNC] + 4),
1269                  bank->pm_save[PINCFG_TYPE_FUNC],
1270                  bank->pm_save[PINCFG_TYPE_NUM]);
1271             writel(bank->pm_save[PINCFG_TYPE_NUM],
1272                    reg + offs[PINCFG_TYPE_FUNC] + 4);
1273         } else {
1274             pr_debug("%s @ %p (con %#010x => %#010x)\n", bank->name,
1275                  reg, readl(reg + offs[PINCFG_TYPE_FUNC]),
1276                  bank->pm_save[PINCFG_TYPE_FUNC]);
1277         }
1278         for (type = 0; type < PINCFG_TYPE_NUM; type++)
1279             if (widths[type])
1280                 writel(bank->pm_save[type], reg + offs[type]);
1281     }
1282 
1283     if (drvdata->retention_ctrl && drvdata->retention_ctrl->disable)
1284         drvdata->retention_ctrl->disable(drvdata);
1285 
1286     return 0;
1287 }
1288 
1289 static const struct of_device_id samsung_pinctrl_dt_match[] = {
1290 #ifdef CONFIG_PINCTRL_EXYNOS_ARM
1291     { .compatible = "samsung,exynos3250-pinctrl",
1292         .data = &exynos3250_of_data },
1293     { .compatible = "samsung,exynos4210-pinctrl",
1294         .data = &exynos4210_of_data },
1295     { .compatible = "samsung,exynos4x12-pinctrl",
1296         .data = &exynos4x12_of_data },
1297     { .compatible = "samsung,exynos5250-pinctrl",
1298         .data = &exynos5250_of_data },
1299     { .compatible = "samsung,exynos5260-pinctrl",
1300         .data = &exynos5260_of_data },
1301     { .compatible = "samsung,exynos5410-pinctrl",
1302         .data = &exynos5410_of_data },
1303     { .compatible = "samsung,exynos5420-pinctrl",
1304         .data = &exynos5420_of_data },
1305     { .compatible = "samsung,s5pv210-pinctrl",
1306         .data = &s5pv210_of_data },
1307 #endif
1308 #ifdef CONFIG_PINCTRL_EXYNOS_ARM64
1309     { .compatible = "samsung,exynos5433-pinctrl",
1310         .data = &exynos5433_of_data },
1311     { .compatible = "samsung,exynos7-pinctrl",
1312         .data = &exynos7_of_data },
1313     { .compatible = "samsung,exynos7885-pinctrl",
1314         .data = &exynos7885_of_data },
1315     { .compatible = "samsung,exynos850-pinctrl",
1316         .data = &exynos850_of_data },
1317     { .compatible = "samsung,exynosautov9-pinctrl",
1318         .data = &exynosautov9_of_data },
1319     { .compatible = "tesla,fsd-pinctrl",
1320         .data = &fsd_of_data },
1321 #endif
1322 #ifdef CONFIG_PINCTRL_S3C64XX
1323     { .compatible = "samsung,s3c64xx-pinctrl",
1324         .data = &s3c64xx_of_data },
1325 #endif
1326 #ifdef CONFIG_PINCTRL_S3C24XX
1327     { .compatible = "samsung,s3c2412-pinctrl",
1328         .data = &s3c2412_of_data },
1329     { .compatible = "samsung,s3c2416-pinctrl",
1330         .data = &s3c2416_of_data },
1331     { .compatible = "samsung,s3c2440-pinctrl",
1332         .data = &s3c2440_of_data },
1333     { .compatible = "samsung,s3c2450-pinctrl",
1334         .data = &s3c2450_of_data },
1335 #endif
1336     {},
1337 };
1338 
1339 static const struct dev_pm_ops samsung_pinctrl_pm_ops = {
1340     SET_LATE_SYSTEM_SLEEP_PM_OPS(samsung_pinctrl_suspend,
1341                      samsung_pinctrl_resume)
1342 };
1343 
1344 static struct platform_driver samsung_pinctrl_driver = {
1345     .probe      = samsung_pinctrl_probe,
1346     .driver = {
1347         .name   = "samsung-pinctrl",
1348         .of_match_table = samsung_pinctrl_dt_match,
1349         .suppress_bind_attrs = true,
1350         .pm = &samsung_pinctrl_pm_ops,
1351     },
1352 };
1353 
1354 static int __init samsung_pinctrl_drv_register(void)
1355 {
1356     return platform_driver_register(&samsung_pinctrl_driver);
1357 }
1358 postcore_initcall(samsung_pinctrl_drv_register);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!