2 * Driver for Conexant Digicolor General Purpose Pin Mapping
4 * Author: Baruch Siach <baruch@tkos.co.il>
6 * Copyright (C) 2015 Paradox Innovation Ltd.
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
14 * - GPIO interrupt support
15 * - Pin pad configuration (pull up/down, strength)
18 #include <linux/module.h>
19 #include <linux/platform_device.h>
21 #include <linux/of_device.h>
23 #include <linux/gpio.h>
24 #include <linux/gpio/driver.h>
25 #include <linux/spinlock.h>
26 #include <linux/pinctrl/machine.h>
27 #include <linux/pinctrl/pinconf.h>
28 #include <linux/pinctrl/pinconf-generic.h>
29 #include <linux/pinctrl/pinctrl.h>
30 #include <linux/pinctrl/pinmux.h>
31 #include "pinctrl-utils.h"
33 #define DRIVER_NAME "pinctrl-digicolor"
35 #define GP_CLIENTSEL(clct) ((clct)*8 + 0x20)
36 #define GP_DRIVE0(clct) (GP_CLIENTSEL(clct) + 2)
37 #define GP_OUTPUT0(clct) (GP_CLIENTSEL(clct) + 3)
38 #define GP_INPUT(clct) (GP_CLIENTSEL(clct) + 6)
40 #define PIN_COLLECTIONS ('R' - 'A' + 1)
41 #define PINS_PER_COLLECTION 8
42 #define PINS_COUNT (PIN_COLLECTIONS * PINS_PER_COLLECTION)
47 struct pinctrl_dev
*pctl
;
49 struct pinctrl_desc
*desc
;
50 const char *pin_names
[PINS_COUNT
];
52 struct gpio_chip chip
;
56 static int dc_get_groups_count(struct pinctrl_dev
*pctldev
)
61 static const char *dc_get_group_name(struct pinctrl_dev
*pctldev
,
64 struct dc_pinmap
*pmap
= pinctrl_dev_get_drvdata(pctldev
);
66 /* Exactly one group per pin */
67 return pmap
->desc
->pins
[selector
].name
;
70 static int dc_get_group_pins(struct pinctrl_dev
*pctldev
, unsigned selector
,
71 const unsigned **pins
,
74 struct dc_pinmap
*pmap
= pinctrl_dev_get_drvdata(pctldev
);
76 *pins
= &pmap
->desc
->pins
[selector
].number
;
82 static struct pinctrl_ops dc_pinctrl_ops
= {
83 .get_groups_count
= dc_get_groups_count
,
84 .get_group_name
= dc_get_group_name
,
85 .get_group_pins
= dc_get_group_pins
,
86 .dt_node_to_map
= pinconf_generic_dt_node_to_map_pin
,
87 .dt_free_map
= pinctrl_utils_dt_free_map
,
90 static const char *const dc_functions
[] = {
97 static int dc_get_functions_count(struct pinctrl_dev
*pctldev
)
99 return ARRAY_SIZE(dc_functions
);
102 static const char *dc_get_fname(struct pinctrl_dev
*pctldev
, unsigned selector
)
104 return dc_functions
[selector
];
107 static int dc_get_groups(struct pinctrl_dev
*pctldev
, unsigned selector
,
108 const char * const **groups
,
109 unsigned * const num_groups
)
111 struct dc_pinmap
*pmap
= pinctrl_dev_get_drvdata(pctldev
);
113 *groups
= pmap
->pin_names
;
114 *num_groups
= PINS_COUNT
;
119 static void dc_client_sel(int pin_num
, int *reg
, int *bit
)
121 *bit
= (pin_num
% PINS_PER_COLLECTION
) * 2;
122 *reg
= GP_CLIENTSEL(pin_num
/PINS_PER_COLLECTION
);
124 if (*bit
>= PINS_PER_COLLECTION
) {
125 *bit
-= PINS_PER_COLLECTION
;
130 static int dc_set_mux(struct pinctrl_dev
*pctldev
, unsigned selector
,
133 struct dc_pinmap
*pmap
= pinctrl_dev_get_drvdata(pctldev
);
134 int bit_off
, reg_off
;
137 dc_client_sel(group
, ®_off
, &bit_off
);
139 reg
= readb_relaxed(pmap
->regs
+ reg_off
);
140 reg
&= ~(3 << bit_off
);
141 reg
|= (selector
<< bit_off
);
142 writeb_relaxed(reg
, pmap
->regs
+ reg_off
);
147 static int dc_pmx_request_gpio(struct pinctrl_dev
*pcdev
,
148 struct pinctrl_gpio_range
*range
,
151 struct dc_pinmap
*pmap
= pinctrl_dev_get_drvdata(pcdev
);
152 int bit_off
, reg_off
;
155 dc_client_sel(offset
, ®_off
, &bit_off
);
157 reg
= readb_relaxed(pmap
->regs
+ reg_off
);
158 if ((reg
& (3 << bit_off
)) != 0)
164 static struct pinmux_ops dc_pmxops
= {
165 .get_functions_count
= dc_get_functions_count
,
166 .get_function_name
= dc_get_fname
,
167 .get_function_groups
= dc_get_groups
,
168 .set_mux
= dc_set_mux
,
169 .gpio_request_enable
= dc_pmx_request_gpio
,
172 static int dc_gpio_request(struct gpio_chip
*chip
, unsigned gpio
)
174 return pinctrl_request_gpio(chip
->base
+ gpio
);
177 static void dc_gpio_free(struct gpio_chip
*chip
, unsigned gpio
)
179 pinctrl_free_gpio(chip
->base
+ gpio
);
182 static int dc_gpio_direction_input(struct gpio_chip
*chip
, unsigned gpio
)
184 struct dc_pinmap
*pmap
= container_of(chip
, struct dc_pinmap
, chip
);
185 int reg_off
= GP_DRIVE0(gpio
/PINS_PER_COLLECTION
);
186 int bit_off
= gpio
% PINS_PER_COLLECTION
;
190 spin_lock_irqsave(&pmap
->lock
, flags
);
191 drive
= readb_relaxed(pmap
->regs
+ reg_off
);
192 drive
&= ~BIT(bit_off
);
193 writeb_relaxed(drive
, pmap
->regs
+ reg_off
);
194 spin_unlock_irqrestore(&pmap
->lock
, flags
);
199 static void dc_gpio_set(struct gpio_chip
*chip
, unsigned gpio
, int value
);
201 static int dc_gpio_direction_output(struct gpio_chip
*chip
, unsigned gpio
,
204 struct dc_pinmap
*pmap
= container_of(chip
, struct dc_pinmap
, chip
);
205 int reg_off
= GP_DRIVE0(gpio
/PINS_PER_COLLECTION
);
206 int bit_off
= gpio
% PINS_PER_COLLECTION
;
210 dc_gpio_set(chip
, gpio
, value
);
212 spin_lock_irqsave(&pmap
->lock
, flags
);
213 drive
= readb_relaxed(pmap
->regs
+ reg_off
);
214 drive
|= BIT(bit_off
);
215 writeb_relaxed(drive
, pmap
->regs
+ reg_off
);
216 spin_unlock_irqrestore(&pmap
->lock
, flags
);
221 static int dc_gpio_get(struct gpio_chip
*chip
, unsigned gpio
)
223 struct dc_pinmap
*pmap
= container_of(chip
, struct dc_pinmap
, chip
);
224 int reg_off
= GP_INPUT(gpio
/PINS_PER_COLLECTION
);
225 int bit_off
= gpio
% PINS_PER_COLLECTION
;
228 input
= readb_relaxed(pmap
->regs
+ reg_off
);
230 return !!(input
& BIT(bit_off
));
233 static void dc_gpio_set(struct gpio_chip
*chip
, unsigned gpio
, int value
)
235 struct dc_pinmap
*pmap
= container_of(chip
, struct dc_pinmap
, chip
);
236 int reg_off
= GP_OUTPUT0(gpio
/PINS_PER_COLLECTION
);
237 int bit_off
= gpio
% PINS_PER_COLLECTION
;
241 spin_lock_irqsave(&pmap
->lock
, flags
);
242 output
= readb_relaxed(pmap
->regs
+ reg_off
);
244 output
|= BIT(bit_off
);
246 output
&= ~BIT(bit_off
);
247 writeb_relaxed(output
, pmap
->regs
+ reg_off
);
248 spin_unlock_irqrestore(&pmap
->lock
, flags
);
251 static int dc_gpiochip_add(struct dc_pinmap
*pmap
, struct device_node
*np
)
253 struct gpio_chip
*chip
= &pmap
->chip
;
256 chip
->label
= DRIVER_NAME
;
257 chip
->dev
= pmap
->dev
;
258 chip
->request
= dc_gpio_request
;
259 chip
->free
= dc_gpio_free
;
260 chip
->direction_input
= dc_gpio_direction_input
;
261 chip
->direction_output
= dc_gpio_direction_output
;
262 chip
->get
= dc_gpio_get
;
263 chip
->set
= dc_gpio_set
;
265 chip
->ngpio
= PINS_COUNT
;
267 chip
->of_gpio_n_cells
= 2;
269 spin_lock_init(&pmap
->lock
);
271 ret
= gpiochip_add(chip
);
275 ret
= gpiochip_add_pin_range(chip
, dev_name(pmap
->dev
), 0, 0,
278 gpiochip_remove(chip
);
285 static int dc_pinctrl_probe(struct platform_device
*pdev
)
287 struct dc_pinmap
*pmap
;
289 struct pinctrl_pin_desc
*pins
;
290 struct pinctrl_desc
*pctl_desc
;
292 int name_len
= strlen("GP_xx") + 1;
295 pmap
= devm_kzalloc(&pdev
->dev
, sizeof(*pmap
), GFP_KERNEL
);
299 r
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
300 pmap
->regs
= devm_ioremap_resource(&pdev
->dev
, r
);
301 if (IS_ERR(pmap
->regs
))
302 return PTR_ERR(pmap
->regs
);
304 pins
= devm_kzalloc(&pdev
->dev
, sizeof(*pins
)*PINS_COUNT
, GFP_KERNEL
);
307 pin_names
= devm_kzalloc(&pdev
->dev
, name_len
* PINS_COUNT
,
312 for (i
= 0; i
< PIN_COLLECTIONS
; i
++) {
313 for (j
= 0; j
< PINS_PER_COLLECTION
; j
++) {
314 int pin_id
= i
*PINS_PER_COLLECTION
+ j
;
315 char *name
= &pin_names
[pin_id
* name_len
];
317 snprintf(name
, name_len
, "GP_%c%c", 'A'+i
, '0'+j
);
319 pins
[pin_id
].number
= pin_id
;
320 pins
[pin_id
].name
= name
;
321 pmap
->pin_names
[pin_id
] = name
;
325 pctl_desc
= devm_kzalloc(&pdev
->dev
, sizeof(*pctl_desc
), GFP_KERNEL
);
329 pctl_desc
->name
= DRIVER_NAME
,
330 pctl_desc
->owner
= THIS_MODULE
,
331 pctl_desc
->pctlops
= &dc_pinctrl_ops
,
332 pctl_desc
->pmxops
= &dc_pmxops
,
333 pctl_desc
->npins
= PINS_COUNT
;
334 pctl_desc
->pins
= pins
;
335 pmap
->desc
= pctl_desc
;
337 pmap
->dev
= &pdev
->dev
;
339 pmap
->pctl
= pinctrl_register(pctl_desc
, &pdev
->dev
, pmap
);
340 if (IS_ERR(pmap
->pctl
)) {
341 dev_err(&pdev
->dev
, "pinctrl driver registration failed\n");
342 return PTR_ERR(pmap
->pctl
);
345 ret
= dc_gpiochip_add(pmap
, pdev
->dev
.of_node
);
347 pinctrl_unregister(pmap
->pctl
);
354 static int dc_pinctrl_remove(struct platform_device
*pdev
)
356 struct dc_pinmap
*pmap
= platform_get_drvdata(pdev
);
358 pinctrl_unregister(pmap
->pctl
);
359 gpiochip_remove(&pmap
->chip
);
364 static const struct of_device_id dc_pinctrl_ids
[] = {
365 { .compatible
= "cnxt,cx92755-pinctrl" },
368 MODULE_DEVICE_TABLE(of
, dc_pinctrl_ids
);
370 static struct platform_driver dc_pinctrl_driver
= {
373 .of_match_table
= dc_pinctrl_ids
,
375 .probe
= dc_pinctrl_probe
,
376 .remove
= dc_pinctrl_remove
,
378 module_platform_driver(dc_pinctrl_driver
);