2 * pin-controller/pin-mux/pin-config/gpio-driver for Samsung's SoC's.
4 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
5 * http://www.samsung.com
6 * Copyright (c) 2012 Linaro Ltd
7 * http://www.linaro.org
9 * Author: Thomas Abraham <thomas.ab@samsung.com>
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.
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.
23 #include <linux/module.h>
24 #include <linux/platform_device.h>
26 #include <linux/slab.h>
27 #include <linux/err.h>
28 #include <linux/gpio.h>
29 #include <linux/irqdomain.h>
30 #include <linux/spinlock.h>
31 #include <linux/syscore_ops.h>
34 #include "pinctrl-samsung.h"
36 #define GROUP_SUFFIX "-grp"
37 #define GSUFFIX_LEN sizeof(GROUP_SUFFIX)
38 #define FUNCTION_SUFFIX "-mux"
39 #define FSUFFIX_LEN sizeof(FUNCTION_SUFFIX)
41 /* list of all possible config options supported */
42 static struct pin_config
{
44 enum pincfg_type param
;
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
},
53 /* Global list of devices (struct samsung_pinctrl_drv_data) */
54 static LIST_HEAD(drvdata_list
);
56 static unsigned int pin_base
;
58 static inline struct samsung_pin_bank
*gc_to_pin_bank(struct gpio_chip
*gc
)
60 return container_of(gc
, struct samsung_pin_bank
, gpio_chip
);
63 static int samsung_get_group_count(struct pinctrl_dev
*pctldev
)
65 struct samsung_pinctrl_drv_data
*pmx
= pinctrl_dev_get_drvdata(pctldev
);
67 return pmx
->nr_groups
;
70 static const char *samsung_get_group_name(struct pinctrl_dev
*pctldev
,
73 struct samsung_pinctrl_drv_data
*pmx
= pinctrl_dev_get_drvdata(pctldev
);
75 return pmx
->pin_groups
[group
].name
;
78 static int samsung_get_group_pins(struct pinctrl_dev
*pctldev
,
80 const unsigned **pins
,
83 struct samsung_pinctrl_drv_data
*pmx
= pinctrl_dev_get_drvdata(pctldev
);
85 *pins
= pmx
->pin_groups
[group
].pins
;
86 *num_pins
= pmx
->pin_groups
[group
].num_pins
;
91 static int reserve_map(struct device
*dev
, struct pinctrl_map
**map
,
92 unsigned *reserved_maps
, unsigned *num_maps
,
95 unsigned old_num
= *reserved_maps
;
96 unsigned new_num
= *num_maps
+ reserve
;
97 struct pinctrl_map
*new_map
;
99 if (old_num
>= new_num
)
102 new_map
= krealloc(*map
, sizeof(*new_map
) * new_num
, GFP_KERNEL
);
104 dev_err(dev
, "krealloc(map) failed\n");
108 memset(new_map
+ old_num
, 0, (new_num
- old_num
) * sizeof(*new_map
));
111 *reserved_maps
= new_num
;
116 static int add_map_mux(struct pinctrl_map
**map
, unsigned *reserved_maps
,
117 unsigned *num_maps
, const char *group
,
118 const char *function
)
120 if (WARN_ON(*num_maps
== *reserved_maps
))
123 (*map
)[*num_maps
].type
= PIN_MAP_TYPE_MUX_GROUP
;
124 (*map
)[*num_maps
].data
.mux
.group
= group
;
125 (*map
)[*num_maps
].data
.mux
.function
= function
;
131 static int add_map_configs(struct device
*dev
, struct pinctrl_map
**map
,
132 unsigned *reserved_maps
, unsigned *num_maps
,
133 const char *group
, unsigned long *configs
,
134 unsigned num_configs
)
136 unsigned long *dup_configs
;
138 if (WARN_ON(*num_maps
== *reserved_maps
))
141 dup_configs
= kmemdup(configs
, num_configs
* sizeof(*dup_configs
),
144 dev_err(dev
, "kmemdup(configs) failed\n");
148 (*map
)[*num_maps
].type
= PIN_MAP_TYPE_CONFIGS_GROUP
;
149 (*map
)[*num_maps
].data
.configs
.group_or_pin
= group
;
150 (*map
)[*num_maps
].data
.configs
.configs
= dup_configs
;
151 (*map
)[*num_maps
].data
.configs
.num_configs
= num_configs
;
157 static int add_config(struct device
*dev
, unsigned long **configs
,
158 unsigned *num_configs
, unsigned long config
)
160 unsigned old_num
= *num_configs
;
161 unsigned new_num
= old_num
+ 1;
162 unsigned long *new_configs
;
164 new_configs
= krealloc(*configs
, sizeof(*new_configs
) * new_num
,
167 dev_err(dev
, "krealloc(configs) failed\n");
171 new_configs
[old_num
] = config
;
173 *configs
= new_configs
;
174 *num_configs
= new_num
;
179 static void samsung_dt_free_map(struct pinctrl_dev
*pctldev
,
180 struct pinctrl_map
*map
,
185 for (i
= 0; i
< num_maps
; i
++)
186 if (map
[i
].type
== PIN_MAP_TYPE_CONFIGS_GROUP
)
187 kfree(map
[i
].data
.configs
.configs
);
192 static int samsung_dt_subnode_to_map(struct samsung_pinctrl_drv_data
*drvdata
,
194 struct device_node
*np
,
195 struct pinctrl_map
**map
,
196 unsigned *reserved_maps
,
201 unsigned long config
;
202 unsigned long *configs
= NULL
;
203 unsigned num_configs
= 0;
205 struct property
*prop
;
207 bool has_func
= false;
209 ret
= of_property_read_u32(np
, "samsung,pin-function", &val
);
213 for (i
= 0; i
< ARRAY_SIZE(cfg_params
); i
++) {
214 ret
= of_property_read_u32(np
, cfg_params
[i
].property
, &val
);
216 config
= PINCFG_PACK(cfg_params
[i
].param
, val
);
217 ret
= add_config(dev
, &configs
, &num_configs
, config
);
220 /* EINVAL=missing, which is fine since it's optional */
221 } else if (ret
!= -EINVAL
) {
222 dev_err(dev
, "could not parse property %s\n",
223 cfg_params
[i
].property
);
232 ret
= of_property_count_strings(np
, "samsung,pins");
234 dev_err(dev
, "could not parse property samsung,pins\n");
239 ret
= reserve_map(dev
, map
, reserved_maps
, num_maps
, reserve
);
243 of_property_for_each_string(np
, "samsung,pins", prop
, group
) {
245 ret
= add_map_mux(map
, reserved_maps
,
246 num_maps
, group
, np
->full_name
);
252 ret
= add_map_configs(dev
, map
, reserved_maps
,
253 num_maps
, group
, configs
,
267 static int samsung_dt_node_to_map(struct pinctrl_dev
*pctldev
,
268 struct device_node
*np_config
,
269 struct pinctrl_map
**map
,
272 struct samsung_pinctrl_drv_data
*drvdata
;
273 unsigned reserved_maps
;
274 struct device_node
*np
;
277 drvdata
= pinctrl_dev_get_drvdata(pctldev
);
283 if (!of_get_child_count(np_config
))
284 return samsung_dt_subnode_to_map(drvdata
, pctldev
->dev
,
289 for_each_child_of_node(np_config
, np
) {
290 ret
= samsung_dt_subnode_to_map(drvdata
, pctldev
->dev
, np
, map
,
291 &reserved_maps
, num_maps
);
293 samsung_dt_free_map(pctldev
, *map
, *num_maps
);
301 /* list of pinctrl callbacks for the pinctrl core */
302 static const struct pinctrl_ops samsung_pctrl_ops
= {
303 .get_groups_count
= samsung_get_group_count
,
304 .get_group_name
= samsung_get_group_name
,
305 .get_group_pins
= samsung_get_group_pins
,
306 .dt_node_to_map
= samsung_dt_node_to_map
,
307 .dt_free_map
= samsung_dt_free_map
,
310 /* check if the selector is a valid pin function selector */
311 static int samsung_get_functions_count(struct pinctrl_dev
*pctldev
)
313 struct samsung_pinctrl_drv_data
*drvdata
;
315 drvdata
= pinctrl_dev_get_drvdata(pctldev
);
316 return drvdata
->nr_functions
;
319 /* return the name of the pin function specified */
320 static const char *samsung_pinmux_get_fname(struct pinctrl_dev
*pctldev
,
323 struct samsung_pinctrl_drv_data
*drvdata
;
325 drvdata
= pinctrl_dev_get_drvdata(pctldev
);
326 return drvdata
->pmx_functions
[selector
].name
;
329 /* return the groups associated for the specified function selector */
330 static int samsung_pinmux_get_groups(struct pinctrl_dev
*pctldev
,
331 unsigned selector
, const char * const **groups
,
332 unsigned * const num_groups
)
334 struct samsung_pinctrl_drv_data
*drvdata
;
336 drvdata
= pinctrl_dev_get_drvdata(pctldev
);
337 *groups
= drvdata
->pmx_functions
[selector
].groups
;
338 *num_groups
= drvdata
->pmx_functions
[selector
].num_groups
;
343 * given a pin number that is local to a pin controller, find out the pin bank
344 * and the register base of the pin bank.
346 static void pin_to_reg_bank(struct samsung_pinctrl_drv_data
*drvdata
,
347 unsigned pin
, void __iomem
**reg
, u32
*offset
,
348 struct samsung_pin_bank
**bank
)
350 struct samsung_pin_bank
*b
;
352 b
= drvdata
->ctrl
->pin_banks
;
354 while ((pin
>= b
->pin_base
) &&
355 ((b
->pin_base
+ b
->nr_pins
- 1) < pin
))
358 *reg
= drvdata
->virt_base
+ b
->pctl_offset
;
359 *offset
= pin
- b
->pin_base
;
364 /* enable or disable a pinmux function */
365 static void samsung_pinmux_setup(struct pinctrl_dev
*pctldev
, unsigned selector
,
366 unsigned group
, bool enable
)
368 struct samsung_pinctrl_drv_data
*drvdata
;
369 struct samsung_pin_bank_type
*type
;
370 struct samsung_pin_bank
*bank
;
372 u32 mask
, shift
, data
, pin_offset
;
374 const struct samsung_pmx_func
*func
;
375 const struct samsung_pin_group
*grp
;
377 drvdata
= pinctrl_dev_get_drvdata(pctldev
);
378 func
= &drvdata
->pmx_functions
[selector
];
379 grp
= &drvdata
->pin_groups
[group
];
381 pin_to_reg_bank(drvdata
, grp
->pins
[0] - drvdata
->ctrl
->base
,
382 ®
, &pin_offset
, &bank
);
384 mask
= (1 << type
->fld_width
[PINCFG_TYPE_FUNC
]) - 1;
385 shift
= pin_offset
* type
->fld_width
[PINCFG_TYPE_FUNC
];
387 /* Some banks have two config registers */
392 spin_lock_irqsave(&bank
->slock
, flags
);
394 data
= readl(reg
+ type
->reg_offset
[PINCFG_TYPE_FUNC
]);
395 data
&= ~(mask
<< shift
);
397 data
|= func
->val
<< shift
;
398 writel(data
, reg
+ type
->reg_offset
[PINCFG_TYPE_FUNC
]);
400 spin_unlock_irqrestore(&bank
->slock
, flags
);
403 /* enable a specified pinmux by writing to registers */
404 static int samsung_pinmux_enable(struct pinctrl_dev
*pctldev
, unsigned selector
,
407 samsung_pinmux_setup(pctldev
, selector
, group
, true);
411 /* list of pinmux callbacks for the pinmux vertical in pinctrl core */
412 static const struct pinmux_ops samsung_pinmux_ops
= {
413 .get_functions_count
= samsung_get_functions_count
,
414 .get_function_name
= samsung_pinmux_get_fname
,
415 .get_function_groups
= samsung_pinmux_get_groups
,
416 .enable
= samsung_pinmux_enable
,
419 /* set or get the pin config settings for a specified pin */
420 static int samsung_pinconf_rw(struct pinctrl_dev
*pctldev
, unsigned int pin
,
421 unsigned long *config
, bool set
)
423 struct samsung_pinctrl_drv_data
*drvdata
;
424 struct samsung_pin_bank_type
*type
;
425 struct samsung_pin_bank
*bank
;
426 void __iomem
*reg_base
;
427 enum pincfg_type cfg_type
= PINCFG_UNPACK_TYPE(*config
);
428 u32 data
, width
, pin_offset
, mask
, shift
;
429 u32 cfg_value
, cfg_reg
;
432 drvdata
= pinctrl_dev_get_drvdata(pctldev
);
433 pin_to_reg_bank(drvdata
, pin
- drvdata
->ctrl
->base
, ®_base
,
437 if (cfg_type
>= PINCFG_TYPE_NUM
|| !type
->fld_width
[cfg_type
])
440 width
= type
->fld_width
[cfg_type
];
441 cfg_reg
= type
->reg_offset
[cfg_type
];
443 spin_lock_irqsave(&bank
->slock
, flags
);
445 mask
= (1 << width
) - 1;
446 shift
= pin_offset
* width
;
447 data
= readl(reg_base
+ cfg_reg
);
450 cfg_value
= PINCFG_UNPACK_VALUE(*config
);
451 data
&= ~(mask
<< shift
);
452 data
|= (cfg_value
<< shift
);
453 writel(data
, reg_base
+ cfg_reg
);
457 *config
= PINCFG_PACK(cfg_type
, data
);
460 spin_unlock_irqrestore(&bank
->slock
, flags
);
465 /* set the pin config settings for a specified pin */
466 static int samsung_pinconf_set(struct pinctrl_dev
*pctldev
, unsigned int pin
,
467 unsigned long *configs
, unsigned num_configs
)
471 for (i
= 0; i
< num_configs
; i
++) {
472 ret
= samsung_pinconf_rw(pctldev
, pin
, &configs
[i
], true);
475 } /* for each config */
480 /* get the pin config settings for a specified pin */
481 static int samsung_pinconf_get(struct pinctrl_dev
*pctldev
, unsigned int pin
,
482 unsigned long *config
)
484 return samsung_pinconf_rw(pctldev
, pin
, config
, false);
487 /* set the pin config settings for a specified pin group */
488 static int samsung_pinconf_group_set(struct pinctrl_dev
*pctldev
,
489 unsigned group
, unsigned long *configs
,
490 unsigned num_configs
)
492 struct samsung_pinctrl_drv_data
*drvdata
;
493 const unsigned int *pins
;
496 drvdata
= pinctrl_dev_get_drvdata(pctldev
);
497 pins
= drvdata
->pin_groups
[group
].pins
;
499 for (cnt
= 0; cnt
< drvdata
->pin_groups
[group
].num_pins
; cnt
++)
500 samsung_pinconf_set(pctldev
, pins
[cnt
], configs
, num_configs
);
505 /* get the pin config settings for a specified pin group */
506 static int samsung_pinconf_group_get(struct pinctrl_dev
*pctldev
,
507 unsigned int group
, unsigned long *config
)
509 struct samsung_pinctrl_drv_data
*drvdata
;
510 const unsigned int *pins
;
512 drvdata
= pinctrl_dev_get_drvdata(pctldev
);
513 pins
= drvdata
->pin_groups
[group
].pins
;
514 samsung_pinconf_get(pctldev
, pins
[0], config
);
518 /* list of pinconfig callbacks for pinconfig vertical in the pinctrl code */
519 static const struct pinconf_ops samsung_pinconf_ops
= {
520 .pin_config_get
= samsung_pinconf_get
,
521 .pin_config_set
= samsung_pinconf_set
,
522 .pin_config_group_get
= samsung_pinconf_group_get
,
523 .pin_config_group_set
= samsung_pinconf_group_set
,
526 /* gpiolib gpio_set callback function */
527 static void samsung_gpio_set(struct gpio_chip
*gc
, unsigned offset
, int value
)
529 struct samsung_pin_bank
*bank
= gc_to_pin_bank(gc
);
530 struct samsung_pin_bank_type
*type
= bank
->type
;
535 reg
= bank
->drvdata
->virt_base
+ bank
->pctl_offset
;
537 spin_lock_irqsave(&bank
->slock
, flags
);
539 data
= readl(reg
+ type
->reg_offset
[PINCFG_TYPE_DAT
]);
540 data
&= ~(1 << offset
);
543 writel(data
, reg
+ type
->reg_offset
[PINCFG_TYPE_DAT
]);
545 spin_unlock_irqrestore(&bank
->slock
, flags
);
548 /* gpiolib gpio_get callback function */
549 static int samsung_gpio_get(struct gpio_chip
*gc
, unsigned offset
)
553 struct samsung_pin_bank
*bank
= gc_to_pin_bank(gc
);
554 struct samsung_pin_bank_type
*type
= bank
->type
;
556 reg
= bank
->drvdata
->virt_base
+ bank
->pctl_offset
;
558 data
= readl(reg
+ type
->reg_offset
[PINCFG_TYPE_DAT
]);
565 * The calls to gpio_direction_output() and gpio_direction_input()
566 * leads to this function call.
568 static int samsung_gpio_set_direction(struct gpio_chip
*gc
,
569 unsigned offset
, bool input
)
571 struct samsung_pin_bank_type
*type
;
572 struct samsung_pin_bank
*bank
;
573 struct samsung_pinctrl_drv_data
*drvdata
;
575 u32 data
, mask
, shift
;
578 bank
= gc_to_pin_bank(gc
);
580 drvdata
= bank
->drvdata
;
582 reg
= drvdata
->virt_base
+ bank
->pctl_offset
+
583 type
->reg_offset
[PINCFG_TYPE_FUNC
];
585 mask
= (1 << type
->fld_width
[PINCFG_TYPE_FUNC
]) - 1;
586 shift
= offset
* type
->fld_width
[PINCFG_TYPE_FUNC
];
588 /* Some banks have two config registers */
593 spin_lock_irqsave(&bank
->slock
, flags
);
596 data
&= ~(mask
<< shift
);
598 data
|= FUNC_OUTPUT
<< shift
;
601 spin_unlock_irqrestore(&bank
->slock
, flags
);
606 /* gpiolib gpio_direction_input callback function. */
607 static int samsung_gpio_direction_input(struct gpio_chip
*gc
, unsigned offset
)
609 return samsung_gpio_set_direction(gc
, offset
, true);
612 /* gpiolib gpio_direction_output callback function. */
613 static int samsung_gpio_direction_output(struct gpio_chip
*gc
, unsigned offset
,
616 samsung_gpio_set(gc
, offset
, value
);
617 return samsung_gpio_set_direction(gc
, offset
, false);
621 * gpiolib gpio_to_irq callback function. Creates a mapping between a GPIO pin
622 * and a virtual IRQ, if not already present.
624 static int samsung_gpio_to_irq(struct gpio_chip
*gc
, unsigned offset
)
626 struct samsung_pin_bank
*bank
= gc_to_pin_bank(gc
);
629 if (!bank
->irq_domain
)
632 virq
= irq_create_mapping(bank
->irq_domain
, offset
);
634 return (virq
) ? : -ENXIO
;
637 static struct samsung_pin_group
*samsung_pinctrl_create_groups(
639 struct samsung_pinctrl_drv_data
*drvdata
,
642 struct pinctrl_desc
*ctrldesc
= &drvdata
->pctl
;
643 struct samsung_pin_group
*groups
, *grp
;
644 const struct pinctrl_pin_desc
*pdesc
;
647 groups
= devm_kzalloc(dev
, ctrldesc
->npins
* sizeof(*groups
),
650 return ERR_PTR(-EINVAL
);
653 pdesc
= ctrldesc
->pins
;
654 for (i
= 0; i
< ctrldesc
->npins
; ++i
, ++pdesc
, ++grp
) {
655 grp
->name
= pdesc
->name
;
656 grp
->pins
= &pdesc
->number
;
660 *cnt
= ctrldesc
->npins
;
664 static int samsung_pinctrl_create_function(struct device
*dev
,
665 struct samsung_pinctrl_drv_data
*drvdata
,
666 struct device_node
*func_np
,
667 struct samsung_pmx_func
*func
)
673 if (of_property_read_u32(func_np
, "samsung,pin-function", &func
->val
))
676 npins
= of_property_count_strings(func_np
, "samsung,pins");
678 dev_err(dev
, "invalid pin list in %s node", func_np
->name
);
682 func
->name
= func_np
->full_name
;
684 func
->groups
= devm_kzalloc(dev
, npins
* sizeof(char *), GFP_KERNEL
);
688 for (i
= 0; i
< npins
; ++i
) {
691 ret
= of_property_read_string_index(func_np
, "samsung,pins",
695 "failed to read pin name %d from %s node\n",
700 func
->groups
[i
] = gname
;
703 func
->num_groups
= npins
;
707 static struct samsung_pmx_func
*samsung_pinctrl_create_functions(
709 struct samsung_pinctrl_drv_data
*drvdata
,
712 struct samsung_pmx_func
*functions
, *func
;
713 struct device_node
*dev_np
= dev
->of_node
;
714 struct device_node
*cfg_np
;
715 unsigned int func_cnt
= 0;
719 * Iterate over all the child nodes of the pin controller node
720 * and create pin groups and pin function lists.
722 for_each_child_of_node(dev_np
, cfg_np
) {
723 struct device_node
*func_np
;
725 if (!of_get_child_count(cfg_np
)) {
726 if (!of_find_property(cfg_np
,
727 "samsung,pin-function", NULL
))
733 for_each_child_of_node(cfg_np
, func_np
) {
734 if (!of_find_property(func_np
,
735 "samsung,pin-function", NULL
))
741 functions
= devm_kzalloc(dev
, func_cnt
* sizeof(*functions
),
744 dev_err(dev
, "failed to allocate memory for function list\n");
745 return ERR_PTR(-EINVAL
);
750 * Iterate over all the child nodes of the pin controller node
751 * and create pin groups and pin function lists.
754 for_each_child_of_node(dev_np
, cfg_np
) {
755 struct device_node
*func_np
;
757 if (!of_get_child_count(cfg_np
)) {
758 ret
= samsung_pinctrl_create_function(dev
, drvdata
,
769 for_each_child_of_node(cfg_np
, func_np
) {
770 ret
= samsung_pinctrl_create_function(dev
, drvdata
,
786 * Parse the information about all the available pin groups and pin functions
787 * from device node of the pin-controller. A pin group is formed with all
788 * the pins listed in the "samsung,pins" property.
791 static int samsung_pinctrl_parse_dt(struct platform_device
*pdev
,
792 struct samsung_pinctrl_drv_data
*drvdata
)
794 struct device
*dev
= &pdev
->dev
;
795 struct samsung_pin_group
*groups
;
796 struct samsung_pmx_func
*functions
;
797 unsigned int grp_cnt
= 0, func_cnt
= 0;
799 groups
= samsung_pinctrl_create_groups(dev
, drvdata
, &grp_cnt
);
800 if (IS_ERR(groups
)) {
801 dev_err(dev
, "failed to parse pin groups\n");
802 return PTR_ERR(groups
);
805 functions
= samsung_pinctrl_create_functions(dev
, drvdata
, &func_cnt
);
806 if (IS_ERR(functions
)) {
807 dev_err(dev
, "failed to parse pin functions\n");
808 return PTR_ERR(groups
);
811 drvdata
->pin_groups
= groups
;
812 drvdata
->nr_groups
= grp_cnt
;
813 drvdata
->pmx_functions
= functions
;
814 drvdata
->nr_functions
= func_cnt
;
819 /* register the pinctrl interface with the pinctrl subsystem */
820 static int samsung_pinctrl_register(struct platform_device
*pdev
,
821 struct samsung_pinctrl_drv_data
*drvdata
)
823 struct pinctrl_desc
*ctrldesc
= &drvdata
->pctl
;
824 struct pinctrl_pin_desc
*pindesc
, *pdesc
;
825 struct samsung_pin_bank
*pin_bank
;
829 ctrldesc
->name
= "samsung-pinctrl";
830 ctrldesc
->owner
= THIS_MODULE
;
831 ctrldesc
->pctlops
= &samsung_pctrl_ops
;
832 ctrldesc
->pmxops
= &samsung_pinmux_ops
;
833 ctrldesc
->confops
= &samsung_pinconf_ops
;
835 pindesc
= devm_kzalloc(&pdev
->dev
, sizeof(*pindesc
) *
836 drvdata
->ctrl
->nr_pins
, GFP_KERNEL
);
838 dev_err(&pdev
->dev
, "mem alloc for pin descriptors failed\n");
841 ctrldesc
->pins
= pindesc
;
842 ctrldesc
->npins
= drvdata
->ctrl
->nr_pins
;
844 /* dynamically populate the pin number and pin name for pindesc */
845 for (pin
= 0, pdesc
= pindesc
; pin
< ctrldesc
->npins
; pin
++, pdesc
++)
846 pdesc
->number
= pin
+ drvdata
->ctrl
->base
;
849 * allocate space for storing the dynamically generated names for all
850 * the pins which belong to this pin-controller.
852 pin_names
= devm_kzalloc(&pdev
->dev
, sizeof(char) * PIN_NAME_LENGTH
*
853 drvdata
->ctrl
->nr_pins
, GFP_KERNEL
);
855 dev_err(&pdev
->dev
, "mem alloc for pin names failed\n");
859 /* for each pin, the name of the pin is pin-bank name + pin number */
860 for (bank
= 0; bank
< drvdata
->ctrl
->nr_banks
; bank
++) {
861 pin_bank
= &drvdata
->ctrl
->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
;
870 ret
= samsung_pinctrl_parse_dt(pdev
, drvdata
);
874 drvdata
->pctl_dev
= pinctrl_register(ctrldesc
, &pdev
->dev
, drvdata
);
875 if (!drvdata
->pctl_dev
) {
876 dev_err(&pdev
->dev
, "could not register pinctrl driver\n");
880 for (bank
= 0; bank
< drvdata
->ctrl
->nr_banks
; ++bank
) {
881 pin_bank
= &drvdata
->ctrl
->pin_banks
[bank
];
882 pin_bank
->grange
.name
= pin_bank
->name
;
883 pin_bank
->grange
.id
= bank
;
884 pin_bank
->grange
.pin_base
= drvdata
->ctrl
->base
885 + pin_bank
->pin_base
;
886 pin_bank
->grange
.base
= pin_bank
->gpio_chip
.base
;
887 pin_bank
->grange
.npins
= pin_bank
->gpio_chip
.ngpio
;
888 pin_bank
->grange
.gc
= &pin_bank
->gpio_chip
;
889 pinctrl_add_gpio_range(drvdata
->pctl_dev
, &pin_bank
->grange
);
895 static int samsung_gpio_request(struct gpio_chip
*chip
, unsigned offset
)
897 return pinctrl_request_gpio(chip
->base
+ offset
);
900 static void samsung_gpio_free(struct gpio_chip
*chip
, unsigned offset
)
902 pinctrl_free_gpio(chip
->base
+ offset
);
905 static const struct gpio_chip samsung_gpiolib_chip
= {
906 .request
= samsung_gpio_request
,
907 .free
= samsung_gpio_free
,
908 .set
= samsung_gpio_set
,
909 .get
= samsung_gpio_get
,
910 .direction_input
= samsung_gpio_direction_input
,
911 .direction_output
= samsung_gpio_direction_output
,
912 .to_irq
= samsung_gpio_to_irq
,
913 .owner
= THIS_MODULE
,
916 /* register the gpiolib interface with the gpiolib subsystem */
917 static int samsung_gpiolib_register(struct platform_device
*pdev
,
918 struct samsung_pinctrl_drv_data
*drvdata
)
920 struct samsung_pin_ctrl
*ctrl
= drvdata
->ctrl
;
921 struct samsung_pin_bank
*bank
= ctrl
->pin_banks
;
922 struct gpio_chip
*gc
;
926 for (i
= 0; i
< ctrl
->nr_banks
; ++i
, ++bank
) {
927 bank
->gpio_chip
= samsung_gpiolib_chip
;
929 gc
= &bank
->gpio_chip
;
930 gc
->base
= ctrl
->base
+ bank
->pin_base
;
931 gc
->ngpio
= bank
->nr_pins
;
932 gc
->dev
= &pdev
->dev
;
933 gc
->of_node
= bank
->of_node
;
934 gc
->label
= bank
->name
;
936 ret
= gpiochip_add(gc
);
938 dev_err(&pdev
->dev
, "failed to register gpio_chip %s, error code: %d\n",
947 for (--i
, --bank
; i
>= 0; --i
, --bank
)
948 if (gpiochip_remove(&bank
->gpio_chip
))
949 dev_err(&pdev
->dev
, "gpio chip %s remove failed\n",
950 bank
->gpio_chip
.label
);
954 /* unregister the gpiolib interface with the gpiolib subsystem */
955 static int samsung_gpiolib_unregister(struct platform_device
*pdev
,
956 struct samsung_pinctrl_drv_data
*drvdata
)
958 struct samsung_pin_ctrl
*ctrl
= drvdata
->ctrl
;
959 struct samsung_pin_bank
*bank
= ctrl
->pin_banks
;
963 for (i
= 0; !ret
&& i
< ctrl
->nr_banks
; ++i
, ++bank
)
964 ret
= gpiochip_remove(&bank
->gpio_chip
);
967 dev_err(&pdev
->dev
, "gpio chip remove failed\n");
972 static const struct of_device_id samsung_pinctrl_dt_match
[];
974 /* retrieve the soc specific data */
975 static struct samsung_pin_ctrl
*samsung_pinctrl_get_soc_data(
976 struct samsung_pinctrl_drv_data
*d
,
977 struct platform_device
*pdev
)
980 const struct of_device_id
*match
;
981 struct device_node
*node
= pdev
->dev
.of_node
;
982 struct device_node
*np
;
983 struct samsung_pin_ctrl
*ctrl
;
984 struct samsung_pin_bank
*bank
;
987 id
= of_alias_get_id(node
, "pinctrl");
989 dev_err(&pdev
->dev
, "failed to get alias id\n");
992 match
= of_match_node(samsung_pinctrl_dt_match
, node
);
993 ctrl
= (struct samsung_pin_ctrl
*)match
->data
+ id
;
995 bank
= ctrl
->pin_banks
;
996 for (i
= 0; i
< ctrl
->nr_banks
; ++i
, ++bank
) {
997 spin_lock_init(&bank
->slock
);
999 bank
->pin_base
= ctrl
->nr_pins
;
1000 ctrl
->nr_pins
+= bank
->nr_pins
;
1003 for_each_child_of_node(node
, np
) {
1004 if (!of_find_property(np
, "gpio-controller", NULL
))
1006 bank
= ctrl
->pin_banks
;
1007 for (i
= 0; i
< ctrl
->nr_banks
; ++i
, ++bank
) {
1008 if (!strcmp(bank
->name
, np
->name
)) {
1015 ctrl
->base
= pin_base
;
1016 pin_base
+= ctrl
->nr_pins
;
1021 static int samsung_pinctrl_probe(struct platform_device
*pdev
)
1023 struct samsung_pinctrl_drv_data
*drvdata
;
1024 struct device
*dev
= &pdev
->dev
;
1025 struct samsung_pin_ctrl
*ctrl
;
1026 struct resource
*res
;
1029 if (!dev
->of_node
) {
1030 dev_err(dev
, "device tree node not found\n");
1034 drvdata
= devm_kzalloc(dev
, sizeof(*drvdata
), GFP_KERNEL
);
1036 dev_err(dev
, "failed to allocate memory for driver's "
1041 ctrl
= samsung_pinctrl_get_soc_data(drvdata
, pdev
);
1043 dev_err(&pdev
->dev
, "driver data not available\n");
1046 drvdata
->ctrl
= ctrl
;
1049 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
1050 drvdata
->virt_base
= devm_ioremap_resource(&pdev
->dev
, res
);
1051 if (IS_ERR(drvdata
->virt_base
))
1052 return PTR_ERR(drvdata
->virt_base
);
1054 res
= platform_get_resource(pdev
, IORESOURCE_IRQ
, 0);
1056 drvdata
->irq
= res
->start
;
1058 ret
= samsung_gpiolib_register(pdev
, drvdata
);
1062 ret
= samsung_pinctrl_register(pdev
, drvdata
);
1064 samsung_gpiolib_unregister(pdev
, drvdata
);
1068 if (ctrl
->eint_gpio_init
)
1069 ctrl
->eint_gpio_init(drvdata
);
1070 if (ctrl
->eint_wkup_init
)
1071 ctrl
->eint_wkup_init(drvdata
);
1073 platform_set_drvdata(pdev
, drvdata
);
1075 /* Add to the global list */
1076 list_add_tail(&drvdata
->node
, &drvdata_list
);
1084 * samsung_pinctrl_suspend_dev - save pinctrl state for suspend for a device
1086 * Save data for all banks handled by this device.
1088 static void samsung_pinctrl_suspend_dev(
1089 struct samsung_pinctrl_drv_data
*drvdata
)
1091 struct samsung_pin_ctrl
*ctrl
= drvdata
->ctrl
;
1092 void __iomem
*virt_base
= drvdata
->virt_base
;
1095 for (i
= 0; i
< ctrl
->nr_banks
; i
++) {
1096 struct samsung_pin_bank
*bank
= &ctrl
->pin_banks
[i
];
1097 void __iomem
*reg
= virt_base
+ bank
->pctl_offset
;
1099 u8
*offs
= bank
->type
->reg_offset
;
1100 u8
*widths
= bank
->type
->fld_width
;
1101 enum pincfg_type type
;
1103 /* Registers without a powerdown config aren't lost */
1104 if (!widths
[PINCFG_TYPE_CON_PDN
])
1107 for (type
= 0; type
< PINCFG_TYPE_NUM
; type
++)
1109 bank
->pm_save
[type
] = readl(reg
+ offs
[type
]);
1111 if (widths
[PINCFG_TYPE_FUNC
] * bank
->nr_pins
> 32) {
1112 /* Some banks have two config registers */
1113 bank
->pm_save
[PINCFG_TYPE_NUM
] =
1114 readl(reg
+ offs
[PINCFG_TYPE_FUNC
] + 4);
1115 pr_debug("Save %s @ %p (con %#010x %08x)\n",
1117 bank
->pm_save
[PINCFG_TYPE_FUNC
],
1118 bank
->pm_save
[PINCFG_TYPE_NUM
]);
1120 pr_debug("Save %s @ %p (con %#010x)\n", bank
->name
,
1121 reg
, bank
->pm_save
[PINCFG_TYPE_FUNC
]);
1126 ctrl
->suspend(drvdata
);
1130 * samsung_pinctrl_resume_dev - restore pinctrl state from suspend for a device
1132 * Restore one of the banks that was saved during suspend.
1134 * We don't bother doing anything complicated to avoid glitching lines since
1135 * we're called before pad retention is turned off.
1137 static void samsung_pinctrl_resume_dev(struct samsung_pinctrl_drv_data
*drvdata
)
1139 struct samsung_pin_ctrl
*ctrl
= drvdata
->ctrl
;
1140 void __iomem
*virt_base
= drvdata
->virt_base
;
1144 ctrl
->resume(drvdata
);
1146 for (i
= 0; i
< ctrl
->nr_banks
; i
++) {
1147 struct samsung_pin_bank
*bank
= &ctrl
->pin_banks
[i
];
1148 void __iomem
*reg
= virt_base
+ bank
->pctl_offset
;
1150 u8
*offs
= bank
->type
->reg_offset
;
1151 u8
*widths
= bank
->type
->fld_width
;
1152 enum pincfg_type type
;
1154 /* Registers without a powerdown config aren't lost */
1155 if (!widths
[PINCFG_TYPE_CON_PDN
])
1158 if (widths
[PINCFG_TYPE_FUNC
] * bank
->nr_pins
> 32) {
1159 /* Some banks have two config registers */
1160 pr_debug("%s @ %p (con %#010x %08x => %#010x %08x)\n",
1162 readl(reg
+ offs
[PINCFG_TYPE_FUNC
]),
1163 readl(reg
+ offs
[PINCFG_TYPE_FUNC
] + 4),
1164 bank
->pm_save
[PINCFG_TYPE_FUNC
],
1165 bank
->pm_save
[PINCFG_TYPE_NUM
]);
1166 writel(bank
->pm_save
[PINCFG_TYPE_NUM
],
1167 reg
+ offs
[PINCFG_TYPE_FUNC
] + 4);
1169 pr_debug("%s @ %p (con %#010x => %#010x)\n", bank
->name
,
1170 reg
, readl(reg
+ offs
[PINCFG_TYPE_FUNC
]),
1171 bank
->pm_save
[PINCFG_TYPE_FUNC
]);
1173 for (type
= 0; type
< PINCFG_TYPE_NUM
; type
++)
1175 writel(bank
->pm_save
[type
], reg
+ offs
[type
]);
1180 * samsung_pinctrl_suspend - save pinctrl state for suspend
1182 * Save data for all banks across all devices.
1184 static int samsung_pinctrl_suspend(void)
1186 struct samsung_pinctrl_drv_data
*drvdata
;
1188 list_for_each_entry(drvdata
, &drvdata_list
, node
) {
1189 samsung_pinctrl_suspend_dev(drvdata
);
1196 * samsung_pinctrl_resume - restore pinctrl state for suspend
1198 * Restore data for all banks across all devices.
1200 static void samsung_pinctrl_resume(void)
1202 struct samsung_pinctrl_drv_data
*drvdata
;
1204 list_for_each_entry_reverse(drvdata
, &drvdata_list
, node
) {
1205 samsung_pinctrl_resume_dev(drvdata
);
1210 #define samsung_pinctrl_suspend NULL
1211 #define samsung_pinctrl_resume NULL
1214 static struct syscore_ops samsung_pinctrl_syscore_ops
= {
1215 .suspend
= samsung_pinctrl_suspend
,
1216 .resume
= samsung_pinctrl_resume
,
1219 static const struct of_device_id samsung_pinctrl_dt_match
[] = {
1220 #ifdef CONFIG_PINCTRL_EXYNOS
1221 { .compatible
= "samsung,exynos3250-pinctrl",
1222 .data
= (void *)exynos3250_pin_ctrl
},
1223 { .compatible
= "samsung,exynos4210-pinctrl",
1224 .data
= (void *)exynos4210_pin_ctrl
},
1225 { .compatible
= "samsung,exynos4x12-pinctrl",
1226 .data
= (void *)exynos4x12_pin_ctrl
},
1227 { .compatible
= "samsung,exynos5250-pinctrl",
1228 .data
= (void *)exynos5250_pin_ctrl
},
1229 { .compatible
= "samsung,exynos5260-pinctrl",
1230 .data
= (void *)exynos5260_pin_ctrl
},
1231 { .compatible
= "samsung,exynos5420-pinctrl",
1232 .data
= (void *)exynos5420_pin_ctrl
},
1233 { .compatible
= "samsung,s5pv210-pinctrl",
1234 .data
= (void *)s5pv210_pin_ctrl
},
1236 #ifdef CONFIG_PINCTRL_S3C64XX
1237 { .compatible
= "samsung,s3c64xx-pinctrl",
1238 .data
= s3c64xx_pin_ctrl
},
1240 #ifdef CONFIG_PINCTRL_S3C24XX
1241 { .compatible
= "samsung,s3c2412-pinctrl",
1242 .data
= s3c2412_pin_ctrl
},
1243 { .compatible
= "samsung,s3c2416-pinctrl",
1244 .data
= s3c2416_pin_ctrl
},
1245 { .compatible
= "samsung,s3c2440-pinctrl",
1246 .data
= s3c2440_pin_ctrl
},
1247 { .compatible
= "samsung,s3c2450-pinctrl",
1248 .data
= s3c2450_pin_ctrl
},
1252 MODULE_DEVICE_TABLE(of
, samsung_pinctrl_dt_match
);
1254 static struct platform_driver samsung_pinctrl_driver
= {
1255 .probe
= samsung_pinctrl_probe
,
1257 .name
= "samsung-pinctrl",
1258 .owner
= THIS_MODULE
,
1259 .of_match_table
= samsung_pinctrl_dt_match
,
1263 static int __init
samsung_pinctrl_drv_register(void)
1266 * Register syscore ops for save/restore of registers across suspend.
1267 * It's important to ensure that this driver is running at an earlier
1268 * initcall level than any arch-specific init calls that install syscore
1269 * ops that turn off pad retention (like exynos_pm_resume).
1271 register_syscore_ops(&samsung_pinctrl_syscore_ops
);
1273 return platform_driver_register(&samsung_pinctrl_driver
);
1275 postcore_initcall(samsung_pinctrl_drv_register
);
1277 static void __exit
samsung_pinctrl_drv_unregister(void)
1279 platform_driver_unregister(&samsung_pinctrl_driver
);
1281 module_exit(samsung_pinctrl_drv_unregister
);
1283 MODULE_AUTHOR("Thomas Abraham <thomas.ab@samsung.com>");
1284 MODULE_DESCRIPTION("Samsung pinctrl driver");
1285 MODULE_LICENSE("GPL v2");