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>
33 #include "pinctrl-samsung.h"
35 #define GROUP_SUFFIX "-grp"
36 #define GSUFFIX_LEN sizeof(GROUP_SUFFIX)
37 #define FUNCTION_SUFFIX "-mux"
38 #define FSUFFIX_LEN sizeof(FUNCTION_SUFFIX)
40 /* list of all possible config options supported */
41 static struct pin_config
{
43 unsigned int cfg_type
;
45 { "samsung,pin-pud", PINCFG_TYPE_PUD
},
46 { "samsung,pin-drv", PINCFG_TYPE_DRV
},
47 { "samsung,pin-con-pdn", PINCFG_TYPE_CON_PDN
},
48 { "samsung,pin-pud-pdn", PINCFG_TYPE_PUD_PDN
},
51 static unsigned int pin_base
;
53 static inline struct samsung_pin_bank
*gc_to_pin_bank(struct gpio_chip
*gc
)
55 return container_of(gc
, struct samsung_pin_bank
, gpio_chip
);
58 /* check if the selector is a valid pin group selector */
59 static int samsung_get_group_count(struct pinctrl_dev
*pctldev
)
61 struct samsung_pinctrl_drv_data
*drvdata
;
63 drvdata
= pinctrl_dev_get_drvdata(pctldev
);
64 return drvdata
->nr_groups
;
67 /* return the name of the group selected by the group selector */
68 static const char *samsung_get_group_name(struct pinctrl_dev
*pctldev
,
71 struct samsung_pinctrl_drv_data
*drvdata
;
73 drvdata
= pinctrl_dev_get_drvdata(pctldev
);
74 return drvdata
->pin_groups
[selector
].name
;
77 /* return the pin numbers associated with the specified group */
78 static int samsung_get_group_pins(struct pinctrl_dev
*pctldev
,
79 unsigned selector
, const unsigned **pins
, unsigned *num_pins
)
81 struct samsung_pinctrl_drv_data
*drvdata
;
83 drvdata
= pinctrl_dev_get_drvdata(pctldev
);
84 *pins
= drvdata
->pin_groups
[selector
].pins
;
85 *num_pins
= drvdata
->pin_groups
[selector
].num_pins
;
89 /* create pinctrl_map entries by parsing device tree nodes */
90 static int samsung_dt_node_to_map(struct pinctrl_dev
*pctldev
,
91 struct device_node
*np
, struct pinctrl_map
**maps
,
94 struct device
*dev
= pctldev
->dev
;
95 struct pinctrl_map
*map
;
96 unsigned long *cfg
= NULL
;
98 int cfg_cnt
= 0, map_cnt
= 0, idx
= 0;
100 /* count the number of config options specfied in the node */
101 for (idx
= 0; idx
< ARRAY_SIZE(pcfgs
); idx
++) {
102 if (of_find_property(np
, pcfgs
[idx
].prop_cfg
, NULL
))
107 * Find out the number of map entries to create. All the config options
108 * can be accomadated into a single config map entry.
112 if (of_find_property(np
, "samsung,pin-function", NULL
))
115 dev_err(dev
, "node %s does not have either config or function "
116 "configurations\n", np
->name
);
120 /* Allocate memory for pin-map entries */
121 map
= kzalloc(sizeof(*map
) * map_cnt
, GFP_KERNEL
);
123 dev_err(dev
, "could not alloc memory for pin-maps\n");
129 * Allocate memory for pin group name. The pin group name is derived
130 * from the node name from which these map entries are be created.
132 gname
= kzalloc(strlen(np
->name
) + GSUFFIX_LEN
, GFP_KERNEL
);
134 dev_err(dev
, "failed to alloc memory for group name\n");
137 sprintf(gname
, "%s%s", np
->name
, GROUP_SUFFIX
);
140 * don't have config options? then skip over to creating function
146 /* Allocate memory for config entries */
147 cfg
= kzalloc(sizeof(*cfg
) * cfg_cnt
, GFP_KERNEL
);
149 dev_err(dev
, "failed to alloc memory for configs\n");
153 /* Prepare a list of config settings */
154 for (idx
= 0, cfg_cnt
= 0; idx
< ARRAY_SIZE(pcfgs
); idx
++) {
156 if (!of_property_read_u32(np
, pcfgs
[idx
].prop_cfg
, &value
))
158 PINCFG_PACK(pcfgs
[idx
].cfg_type
, value
);
161 /* create the config map entry */
162 map
[*nmaps
].data
.configs
.group_or_pin
= gname
;
163 map
[*nmaps
].data
.configs
.configs
= cfg
;
164 map
[*nmaps
].data
.configs
.num_configs
= cfg_cnt
;
165 map
[*nmaps
].type
= PIN_MAP_TYPE_CONFIGS_GROUP
;
169 /* create the function map entry */
170 if (of_find_property(np
, "samsung,pin-function", NULL
)) {
171 fname
= kzalloc(strlen(np
->name
) + FSUFFIX_LEN
, GFP_KERNEL
);
173 dev_err(dev
, "failed to alloc memory for func name\n");
176 sprintf(fname
, "%s%s", np
->name
, FUNCTION_SUFFIX
);
178 map
[*nmaps
].data
.mux
.group
= gname
;
179 map
[*nmaps
].data
.mux
.function
= fname
;
180 map
[*nmaps
].type
= PIN_MAP_TYPE_MUX_GROUP
;
196 /* free the memory allocated to hold the pin-map table */
197 static void samsung_dt_free_map(struct pinctrl_dev
*pctldev
,
198 struct pinctrl_map
*map
, unsigned num_maps
)
202 for (idx
= 0; idx
< num_maps
; idx
++) {
203 if (map
[idx
].type
== PIN_MAP_TYPE_MUX_GROUP
) {
204 kfree(map
[idx
].data
.mux
.function
);
206 kfree(map
[idx
].data
.mux
.group
);
207 } else if (map
->type
== PIN_MAP_TYPE_CONFIGS_GROUP
) {
208 kfree(map
[idx
].data
.configs
.configs
);
210 kfree(map
[idx
].data
.configs
.group_or_pin
);
217 /* list of pinctrl callbacks for the pinctrl core */
218 static const struct pinctrl_ops samsung_pctrl_ops
= {
219 .get_groups_count
= samsung_get_group_count
,
220 .get_group_name
= samsung_get_group_name
,
221 .get_group_pins
= samsung_get_group_pins
,
222 .dt_node_to_map
= samsung_dt_node_to_map
,
223 .dt_free_map
= samsung_dt_free_map
,
226 /* check if the selector is a valid pin function selector */
227 static int samsung_get_functions_count(struct pinctrl_dev
*pctldev
)
229 struct samsung_pinctrl_drv_data
*drvdata
;
231 drvdata
= pinctrl_dev_get_drvdata(pctldev
);
232 return drvdata
->nr_functions
;
235 /* return the name of the pin function specified */
236 static const char *samsung_pinmux_get_fname(struct pinctrl_dev
*pctldev
,
239 struct samsung_pinctrl_drv_data
*drvdata
;
241 drvdata
= pinctrl_dev_get_drvdata(pctldev
);
242 return drvdata
->pmx_functions
[selector
].name
;
245 /* return the groups associated for the specified function selector */
246 static int samsung_pinmux_get_groups(struct pinctrl_dev
*pctldev
,
247 unsigned selector
, const char * const **groups
,
248 unsigned * const num_groups
)
250 struct samsung_pinctrl_drv_data
*drvdata
;
252 drvdata
= pinctrl_dev_get_drvdata(pctldev
);
253 *groups
= drvdata
->pmx_functions
[selector
].groups
;
254 *num_groups
= drvdata
->pmx_functions
[selector
].num_groups
;
259 * given a pin number that is local to a pin controller, find out the pin bank
260 * and the register base of the pin bank.
262 static void pin_to_reg_bank(struct samsung_pinctrl_drv_data
*drvdata
,
263 unsigned pin
, void __iomem
**reg
, u32
*offset
,
264 struct samsung_pin_bank
**bank
)
266 struct samsung_pin_bank
*b
;
268 b
= drvdata
->ctrl
->pin_banks
;
270 while ((pin
>= b
->pin_base
) &&
271 ((b
->pin_base
+ b
->nr_pins
- 1) < pin
))
274 *reg
= drvdata
->virt_base
+ b
->pctl_offset
;
275 *offset
= pin
- b
->pin_base
;
279 /* some banks have two config registers in a single bank */
280 if (*offset
* b
->func_width
> BITS_PER_LONG
)
284 /* enable or disable a pinmux function */
285 static void samsung_pinmux_setup(struct pinctrl_dev
*pctldev
, unsigned selector
,
286 unsigned group
, bool enable
)
288 struct samsung_pinctrl_drv_data
*drvdata
;
289 const unsigned int *pins
;
290 struct samsung_pin_bank
*bank
;
292 u32 mask
, shift
, data
, pin_offset
, cnt
;
295 drvdata
= pinctrl_dev_get_drvdata(pctldev
);
296 pins
= drvdata
->pin_groups
[group
].pins
;
299 * for each pin in the pin group selected, program the correspoding pin
300 * pin function number in the config register.
302 for (cnt
= 0; cnt
< drvdata
->pin_groups
[group
].num_pins
; cnt
++) {
303 pin_to_reg_bank(drvdata
, pins
[cnt
] - drvdata
->ctrl
->base
,
304 ®
, &pin_offset
, &bank
);
305 mask
= (1 << bank
->func_width
) - 1;
306 shift
= pin_offset
* bank
->func_width
;
308 spin_lock_irqsave(&bank
->slock
, flags
);
311 data
&= ~(mask
<< shift
);
313 data
|= drvdata
->pin_groups
[group
].func
<< shift
;
316 spin_unlock_irqrestore(&bank
->slock
, flags
);
320 /* enable a specified pinmux by writing to registers */
321 static int samsung_pinmux_enable(struct pinctrl_dev
*pctldev
, unsigned selector
,
324 samsung_pinmux_setup(pctldev
, selector
, group
, true);
328 /* disable a specified pinmux by writing to registers */
329 static void samsung_pinmux_disable(struct pinctrl_dev
*pctldev
,
330 unsigned selector
, unsigned group
)
332 samsung_pinmux_setup(pctldev
, selector
, group
, false);
336 * The calls to gpio_direction_output() and gpio_direction_input()
337 * leads to this function call (via the pinctrl_gpio_direction_{input|output}()
338 * function called from the gpiolib interface).
340 static int samsung_pinmux_gpio_set_direction(struct pinctrl_dev
*pctldev
,
341 struct pinctrl_gpio_range
*range
, unsigned offset
, bool input
)
343 struct samsung_pin_bank
*bank
;
344 struct samsung_pinctrl_drv_data
*drvdata
;
346 u32 data
, pin_offset
, mask
, shift
;
349 bank
= gc_to_pin_bank(range
->gc
);
350 drvdata
= pinctrl_dev_get_drvdata(pctldev
);
352 pin_offset
= offset
- bank
->pin_base
;
353 reg
= drvdata
->virt_base
+ bank
->pctl_offset
;
355 mask
= (1 << bank
->func_width
) - 1;
356 shift
= pin_offset
* bank
->func_width
;
358 spin_lock_irqsave(&bank
->slock
, flags
);
361 data
&= ~(mask
<< shift
);
363 data
|= FUNC_OUTPUT
<< shift
;
366 spin_unlock_irqrestore(&bank
->slock
, flags
);
371 /* list of pinmux callbacks for the pinmux vertical in pinctrl core */
372 static const struct pinmux_ops samsung_pinmux_ops
= {
373 .get_functions_count
= samsung_get_functions_count
,
374 .get_function_name
= samsung_pinmux_get_fname
,
375 .get_function_groups
= samsung_pinmux_get_groups
,
376 .enable
= samsung_pinmux_enable
,
377 .disable
= samsung_pinmux_disable
,
378 .gpio_set_direction
= samsung_pinmux_gpio_set_direction
,
381 /* set or get the pin config settings for a specified pin */
382 static int samsung_pinconf_rw(struct pinctrl_dev
*pctldev
, unsigned int pin
,
383 unsigned long *config
, bool set
)
385 struct samsung_pinctrl_drv_data
*drvdata
;
386 struct samsung_pin_bank
*bank
;
387 void __iomem
*reg_base
;
388 enum pincfg_type cfg_type
= PINCFG_UNPACK_TYPE(*config
);
389 u32 data
, width
, pin_offset
, mask
, shift
;
390 u32 cfg_value
, cfg_reg
;
393 drvdata
= pinctrl_dev_get_drvdata(pctldev
);
394 pin_to_reg_bank(drvdata
, pin
- drvdata
->ctrl
->base
, ®_base
,
398 case PINCFG_TYPE_PUD
:
399 width
= bank
->pud_width
;
402 case PINCFG_TYPE_DRV
:
403 width
= bank
->drv_width
;
406 case PINCFG_TYPE_CON_PDN
:
407 width
= bank
->conpdn_width
;
408 cfg_reg
= CONPDN_REG
;
410 case PINCFG_TYPE_PUD_PDN
:
411 width
= bank
->pudpdn_width
;
412 cfg_reg
= PUDPDN_REG
;
422 spin_lock_irqsave(&bank
->slock
, flags
);
424 mask
= (1 << width
) - 1;
425 shift
= pin_offset
* width
;
426 data
= readl(reg_base
+ cfg_reg
);
429 cfg_value
= PINCFG_UNPACK_VALUE(*config
);
430 data
&= ~(mask
<< shift
);
431 data
|= (cfg_value
<< shift
);
432 writel(data
, reg_base
+ cfg_reg
);
436 *config
= PINCFG_PACK(cfg_type
, data
);
439 spin_unlock_irqrestore(&bank
->slock
, flags
);
444 /* set the pin config settings for a specified pin */
445 static int samsung_pinconf_set(struct pinctrl_dev
*pctldev
, unsigned int pin
,
446 unsigned long config
)
448 return samsung_pinconf_rw(pctldev
, pin
, &config
, true);
451 /* get the pin config settings for a specified pin */
452 static int samsung_pinconf_get(struct pinctrl_dev
*pctldev
, unsigned int pin
,
453 unsigned long *config
)
455 return samsung_pinconf_rw(pctldev
, pin
, config
, false);
458 /* set the pin config settings for a specified pin group */
459 static int samsung_pinconf_group_set(struct pinctrl_dev
*pctldev
,
460 unsigned group
, unsigned long config
)
462 struct samsung_pinctrl_drv_data
*drvdata
;
463 const unsigned int *pins
;
466 drvdata
= pinctrl_dev_get_drvdata(pctldev
);
467 pins
= drvdata
->pin_groups
[group
].pins
;
469 for (cnt
= 0; cnt
< drvdata
->pin_groups
[group
].num_pins
; cnt
++)
470 samsung_pinconf_set(pctldev
, pins
[cnt
], config
);
475 /* get the pin config settings for a specified pin group */
476 static int samsung_pinconf_group_get(struct pinctrl_dev
*pctldev
,
477 unsigned int group
, unsigned long *config
)
479 struct samsung_pinctrl_drv_data
*drvdata
;
480 const unsigned int *pins
;
482 drvdata
= pinctrl_dev_get_drvdata(pctldev
);
483 pins
= drvdata
->pin_groups
[group
].pins
;
484 samsung_pinconf_get(pctldev
, pins
[0], config
);
488 /* list of pinconfig callbacks for pinconfig vertical in the pinctrl code */
489 static const struct pinconf_ops samsung_pinconf_ops
= {
490 .pin_config_get
= samsung_pinconf_get
,
491 .pin_config_set
= samsung_pinconf_set
,
492 .pin_config_group_get
= samsung_pinconf_group_get
,
493 .pin_config_group_set
= samsung_pinconf_group_set
,
496 /* gpiolib gpio_set callback function */
497 static void samsung_gpio_set(struct gpio_chip
*gc
, unsigned offset
, int value
)
499 struct samsung_pin_bank
*bank
= gc_to_pin_bank(gc
);
504 reg
= bank
->drvdata
->virt_base
+ bank
->pctl_offset
;
506 spin_lock_irqsave(&bank
->slock
, flags
);
508 data
= readl(reg
+ DAT_REG
);
509 data
&= ~(1 << offset
);
512 writel(data
, reg
+ DAT_REG
);
514 spin_unlock_irqrestore(&bank
->slock
, flags
);
517 /* gpiolib gpio_get callback function */
518 static int samsung_gpio_get(struct gpio_chip
*gc
, unsigned offset
)
522 struct samsung_pin_bank
*bank
= gc_to_pin_bank(gc
);
524 reg
= bank
->drvdata
->virt_base
+ bank
->pctl_offset
;
526 data
= readl(reg
+ DAT_REG
);
533 * gpiolib gpio_direction_input callback function. The setting of the pin
534 * mux function as 'gpio input' will be handled by the pinctrl susbsystem
537 static int samsung_gpio_direction_input(struct gpio_chip
*gc
, unsigned offset
)
539 return pinctrl_gpio_direction_input(gc
->base
+ offset
);
543 * gpiolib gpio_direction_output callback function. The setting of the pin
544 * mux function as 'gpio output' will be handled by the pinctrl susbsystem
547 static int samsung_gpio_direction_output(struct gpio_chip
*gc
, unsigned offset
,
550 samsung_gpio_set(gc
, offset
, value
);
551 return pinctrl_gpio_direction_output(gc
->base
+ offset
);
555 * gpiolib gpio_to_irq callback function. Creates a mapping between a GPIO pin
556 * and a virtual IRQ, if not already present.
558 static int samsung_gpio_to_irq(struct gpio_chip
*gc
, unsigned offset
)
560 struct samsung_pin_bank
*bank
= gc_to_pin_bank(gc
);
563 if (!bank
->irq_domain
)
566 virq
= irq_create_mapping(bank
->irq_domain
, offset
);
568 return (virq
) ? : -ENXIO
;
572 * Parse the pin names listed in the 'samsung,pins' property and convert it
573 * into a list of gpio numbers are create a pin group from it.
575 static int samsung_pinctrl_parse_dt_pins(struct platform_device
*pdev
,
576 struct device_node
*cfg_np
,
577 struct pinctrl_desc
*pctl
,
578 unsigned int **pin_list
,
581 struct device
*dev
= &pdev
->dev
;
582 struct property
*prop
;
583 struct pinctrl_pin_desc
const *pdesc
= pctl
->pins
;
584 unsigned int idx
= 0, cnt
;
585 const char *pin_name
;
587 *npins
= of_property_count_strings(cfg_np
, "samsung,pins");
588 if (IS_ERR_VALUE(*npins
)) {
589 dev_err(dev
, "invalid pin list in %s node", cfg_np
->name
);
593 *pin_list
= devm_kzalloc(dev
, *npins
* sizeof(**pin_list
), GFP_KERNEL
);
595 dev_err(dev
, "failed to allocate memory for pin list\n");
599 of_property_for_each_string(cfg_np
, "samsung,pins", prop
, pin_name
) {
600 for (cnt
= 0; cnt
< pctl
->npins
; cnt
++) {
601 if (pdesc
[cnt
].name
) {
602 if (!strcmp(pin_name
, pdesc
[cnt
].name
)) {
603 (*pin_list
)[idx
++] = pdesc
[cnt
].number
;
608 if (cnt
== pctl
->npins
) {
609 dev_err(dev
, "pin %s not valid in %s node\n",
610 pin_name
, cfg_np
->name
);
611 devm_kfree(dev
, *pin_list
);
620 * Parse the information about all the available pin groups and pin functions
621 * from device node of the pin-controller. A pin group is formed with all
622 * the pins listed in the "samsung,pins" property.
624 static int samsung_pinctrl_parse_dt(struct platform_device
*pdev
,
625 struct samsung_pinctrl_drv_data
*drvdata
)
627 struct device
*dev
= &pdev
->dev
;
628 struct device_node
*dev_np
= dev
->of_node
;
629 struct device_node
*cfg_np
;
630 struct samsung_pin_group
*groups
, *grp
;
631 struct samsung_pmx_func
*functions
, *func
;
633 unsigned int npins
, grp_cnt
, func_idx
= 0;
637 grp_cnt
= of_get_child_count(dev_np
);
641 groups
= devm_kzalloc(dev
, grp_cnt
* sizeof(*groups
), GFP_KERNEL
);
643 dev_err(dev
, "failed allocate memory for ping group list\n");
648 functions
= devm_kzalloc(dev
, grp_cnt
* sizeof(*functions
), GFP_KERNEL
);
650 dev_err(dev
, "failed to allocate memory for function list\n");
656 * Iterate over all the child nodes of the pin controller node
657 * and create pin groups and pin function lists.
659 for_each_child_of_node(dev_np
, cfg_np
) {
661 if (!of_find_property(cfg_np
, "samsung,pins", NULL
))
664 ret
= samsung_pinctrl_parse_dt_pins(pdev
, cfg_np
,
665 &drvdata
->pctl
, &pin_list
, &npins
);
669 /* derive pin group name from the node name */
670 gname
= devm_kzalloc(dev
, strlen(cfg_np
->name
) + GSUFFIX_LEN
,
673 dev_err(dev
, "failed to alloc memory for group name\n");
676 sprintf(gname
, "%s%s", cfg_np
->name
, GROUP_SUFFIX
);
679 grp
->pins
= pin_list
;
680 grp
->num_pins
= npins
;
681 of_property_read_u32(cfg_np
, "samsung,pin-function", &function
);
682 grp
->func
= function
;
685 if (!of_find_property(cfg_np
, "samsung,pin-function", NULL
))
688 /* derive function name from the node name */
689 fname
= devm_kzalloc(dev
, strlen(cfg_np
->name
) + FSUFFIX_LEN
,
692 dev_err(dev
, "failed to alloc memory for func name\n");
695 sprintf(fname
, "%s%s", cfg_np
->name
, FUNCTION_SUFFIX
);
698 func
->groups
= devm_kzalloc(dev
, sizeof(char *), GFP_KERNEL
);
700 dev_err(dev
, "failed to alloc memory for group list "
704 func
->groups
[0] = gname
;
705 func
->num_groups
= 1;
710 drvdata
->pin_groups
= groups
;
711 drvdata
->nr_groups
= grp_cnt
;
712 drvdata
->pmx_functions
= functions
;
713 drvdata
->nr_functions
= func_idx
;
718 /* register the pinctrl interface with the pinctrl subsystem */
719 static int samsung_pinctrl_register(struct platform_device
*pdev
,
720 struct samsung_pinctrl_drv_data
*drvdata
)
722 struct pinctrl_desc
*ctrldesc
= &drvdata
->pctl
;
723 struct pinctrl_pin_desc
*pindesc
, *pdesc
;
724 struct samsung_pin_bank
*pin_bank
;
728 ctrldesc
->name
= "samsung-pinctrl";
729 ctrldesc
->owner
= THIS_MODULE
;
730 ctrldesc
->pctlops
= &samsung_pctrl_ops
;
731 ctrldesc
->pmxops
= &samsung_pinmux_ops
;
732 ctrldesc
->confops
= &samsung_pinconf_ops
;
734 pindesc
= devm_kzalloc(&pdev
->dev
, sizeof(*pindesc
) *
735 drvdata
->ctrl
->nr_pins
, GFP_KERNEL
);
737 dev_err(&pdev
->dev
, "mem alloc for pin descriptors failed\n");
740 ctrldesc
->pins
= pindesc
;
741 ctrldesc
->npins
= drvdata
->ctrl
->nr_pins
;
743 /* dynamically populate the pin number and pin name for pindesc */
744 for (pin
= 0, pdesc
= pindesc
; pin
< ctrldesc
->npins
; pin
++, pdesc
++)
745 pdesc
->number
= pin
+ drvdata
->ctrl
->base
;
748 * allocate space for storing the dynamically generated names for all
749 * the pins which belong to this pin-controller.
751 pin_names
= devm_kzalloc(&pdev
->dev
, sizeof(char) * PIN_NAME_LENGTH
*
752 drvdata
->ctrl
->nr_pins
, GFP_KERNEL
);
754 dev_err(&pdev
->dev
, "mem alloc for pin names failed\n");
758 /* for each pin, the name of the pin is pin-bank name + pin number */
759 for (bank
= 0; bank
< drvdata
->ctrl
->nr_banks
; bank
++) {
760 pin_bank
= &drvdata
->ctrl
->pin_banks
[bank
];
761 for (pin
= 0; pin
< pin_bank
->nr_pins
; pin
++) {
762 sprintf(pin_names
, "%s-%d", pin_bank
->name
, pin
);
763 pdesc
= pindesc
+ pin_bank
->pin_base
+ pin
;
764 pdesc
->name
= pin_names
;
765 pin_names
+= PIN_NAME_LENGTH
;
769 drvdata
->pctl_dev
= pinctrl_register(ctrldesc
, &pdev
->dev
, drvdata
);
770 if (!drvdata
->pctl_dev
) {
771 dev_err(&pdev
->dev
, "could not register pinctrl driver\n");
775 for (bank
= 0; bank
< drvdata
->ctrl
->nr_banks
; ++bank
) {
776 pin_bank
= &drvdata
->ctrl
->pin_banks
[bank
];
777 pin_bank
->grange
.name
= pin_bank
->name
;
778 pin_bank
->grange
.id
= bank
;
779 pin_bank
->grange
.pin_base
= pin_bank
->pin_base
;
780 pin_bank
->grange
.base
= pin_bank
->gpio_chip
.base
;
781 pin_bank
->grange
.npins
= pin_bank
->gpio_chip
.ngpio
;
782 pin_bank
->grange
.gc
= &pin_bank
->gpio_chip
;
783 pinctrl_add_gpio_range(drvdata
->pctl_dev
, &pin_bank
->grange
);
786 ret
= samsung_pinctrl_parse_dt(pdev
, drvdata
);
788 pinctrl_unregister(drvdata
->pctl_dev
);
795 static const struct gpio_chip samsung_gpiolib_chip
= {
796 .set
= samsung_gpio_set
,
797 .get
= samsung_gpio_get
,
798 .direction_input
= samsung_gpio_direction_input
,
799 .direction_output
= samsung_gpio_direction_output
,
800 .to_irq
= samsung_gpio_to_irq
,
801 .owner
= THIS_MODULE
,
804 /* register the gpiolib interface with the gpiolib subsystem */
805 static int samsung_gpiolib_register(struct platform_device
*pdev
,
806 struct samsung_pinctrl_drv_data
*drvdata
)
808 struct samsung_pin_ctrl
*ctrl
= drvdata
->ctrl
;
809 struct samsung_pin_bank
*bank
= ctrl
->pin_banks
;
810 struct gpio_chip
*gc
;
814 for (i
= 0; i
< ctrl
->nr_banks
; ++i
, ++bank
) {
815 bank
->gpio_chip
= samsung_gpiolib_chip
;
817 gc
= &bank
->gpio_chip
;
818 gc
->base
= ctrl
->base
+ bank
->pin_base
;
819 gc
->ngpio
= bank
->nr_pins
;
820 gc
->dev
= &pdev
->dev
;
821 gc
->of_node
= bank
->of_node
;
822 gc
->label
= bank
->name
;
824 ret
= gpiochip_add(gc
);
826 dev_err(&pdev
->dev
, "failed to register gpio_chip %s, error code: %d\n",
835 for (--i
, --bank
; i
>= 0; --i
, --bank
)
836 if (gpiochip_remove(&bank
->gpio_chip
))
837 dev_err(&pdev
->dev
, "gpio chip %s remove failed\n",
838 bank
->gpio_chip
.label
);
842 /* unregister the gpiolib interface with the gpiolib subsystem */
843 static int samsung_gpiolib_unregister(struct platform_device
*pdev
,
844 struct samsung_pinctrl_drv_data
*drvdata
)
846 struct samsung_pin_ctrl
*ctrl
= drvdata
->ctrl
;
847 struct samsung_pin_bank
*bank
= ctrl
->pin_banks
;
851 for (i
= 0; !ret
&& i
< ctrl
->nr_banks
; ++i
, ++bank
)
852 ret
= gpiochip_remove(&bank
->gpio_chip
);
855 dev_err(&pdev
->dev
, "gpio chip remove failed\n");
860 static const struct of_device_id samsung_pinctrl_dt_match
[];
862 /* retrieve the soc specific data */
863 static struct samsung_pin_ctrl
*samsung_pinctrl_get_soc_data(
864 struct samsung_pinctrl_drv_data
*d
,
865 struct platform_device
*pdev
)
868 const struct of_device_id
*match
;
869 struct device_node
*node
= pdev
->dev
.of_node
;
870 struct device_node
*np
;
871 struct samsung_pin_ctrl
*ctrl
;
872 struct samsung_pin_bank
*bank
;
875 id
= of_alias_get_id(node
, "pinctrl");
877 dev_err(&pdev
->dev
, "failed to get alias id\n");
880 match
= of_match_node(samsung_pinctrl_dt_match
, node
);
881 ctrl
= (struct samsung_pin_ctrl
*)match
->data
+ id
;
883 bank
= ctrl
->pin_banks
;
884 for (i
= 0; i
< ctrl
->nr_banks
; ++i
, ++bank
) {
885 spin_lock_init(&bank
->slock
);
887 bank
->pin_base
= ctrl
->nr_pins
;
888 ctrl
->nr_pins
+= bank
->nr_pins
;
891 for_each_child_of_node(node
, np
) {
892 if (!of_find_property(np
, "gpio-controller", NULL
))
894 bank
= ctrl
->pin_banks
;
895 for (i
= 0; i
< ctrl
->nr_banks
; ++i
, ++bank
) {
896 if (!strcmp(bank
->name
, np
->name
)) {
903 ctrl
->base
= pin_base
;
904 pin_base
+= ctrl
->nr_pins
;
909 static int samsung_pinctrl_probe(struct platform_device
*pdev
)
911 struct samsung_pinctrl_drv_data
*drvdata
;
912 struct device
*dev
= &pdev
->dev
;
913 struct samsung_pin_ctrl
*ctrl
;
914 struct resource
*res
;
918 dev_err(dev
, "device tree node not found\n");
922 drvdata
= devm_kzalloc(dev
, sizeof(*drvdata
), GFP_KERNEL
);
924 dev_err(dev
, "failed to allocate memory for driver's "
929 ctrl
= samsung_pinctrl_get_soc_data(drvdata
, pdev
);
931 dev_err(&pdev
->dev
, "driver data not available\n");
934 drvdata
->ctrl
= ctrl
;
937 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
939 dev_err(dev
, "cannot find IO resource\n");
943 drvdata
->virt_base
= devm_ioremap_resource(&pdev
->dev
, res
);
944 if (IS_ERR(drvdata
->virt_base
))
945 return PTR_ERR(drvdata
->virt_base
);
947 res
= platform_get_resource(pdev
, IORESOURCE_IRQ
, 0);
949 drvdata
->irq
= res
->start
;
951 ret
= samsung_gpiolib_register(pdev
, drvdata
);
955 ret
= samsung_pinctrl_register(pdev
, drvdata
);
957 samsung_gpiolib_unregister(pdev
, drvdata
);
961 if (ctrl
->eint_gpio_init
)
962 ctrl
->eint_gpio_init(drvdata
);
963 if (ctrl
->eint_wkup_init
)
964 ctrl
->eint_wkup_init(drvdata
);
966 platform_set_drvdata(pdev
, drvdata
);
970 static const struct of_device_id samsung_pinctrl_dt_match
[] = {
971 { .compatible
= "samsung,exynos4210-pinctrl",
972 .data
= (void *)exynos4210_pin_ctrl
},
973 { .compatible
= "samsung,exynos4x12-pinctrl",
974 .data
= (void *)exynos4x12_pin_ctrl
},
977 MODULE_DEVICE_TABLE(of
, samsung_pinctrl_dt_match
);
979 static struct platform_driver samsung_pinctrl_driver
= {
980 .probe
= samsung_pinctrl_probe
,
982 .name
= "samsung-pinctrl",
983 .owner
= THIS_MODULE
,
984 .of_match_table
= of_match_ptr(samsung_pinctrl_dt_match
),
988 static int __init
samsung_pinctrl_drv_register(void)
990 return platform_driver_register(&samsung_pinctrl_driver
);
992 postcore_initcall(samsung_pinctrl_drv_register
);
994 static void __exit
samsung_pinctrl_drv_unregister(void)
996 platform_driver_unregister(&samsung_pinctrl_driver
);
998 module_exit(samsung_pinctrl_drv_unregister
);
1000 MODULE_AUTHOR("Thomas Abraham <thomas.ab@samsung.com>");
1001 MODULE_DESCRIPTION("Samsung pinctrl driver");
1002 MODULE_LICENSE("GPL v2");