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);