Commit | Line | Data |
---|---|---|
d2912cb1 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
6596e59e SM |
2 | /* |
3 | * GPIO driver for Exar XR17V35X chip | |
4 | * | |
5 | * Copyright (C) 2015 Sudip Mukherjee <sudip.mukherjee@codethink.co.uk> | |
6596e59e SM |
6 | */ |
7 | #include <linux/bitops.h> | |
8 | #include <linux/device.h> | |
9 | #include <linux/gpio/driver.h> | |
10 | #include <linux/init.h> | |
11 | #include <linux/kernel.h> | |
12 | #include <linux/module.h> | |
13 | #include <linux/pci.h> | |
14 | #include <linux/platform_device.h> | |
15 | ||
16 | #define EXAR_OFFSET_MPIOLVL_LO 0x90 | |
17 | #define EXAR_OFFSET_MPIOSEL_LO 0x93 | |
18 | #define EXAR_OFFSET_MPIOLVL_HI 0x96 | |
19 | #define EXAR_OFFSET_MPIOSEL_HI 0x99 | |
20 | ||
21 | #define DRIVER_NAME "gpio_exar" | |
22 | ||
23 | static DEFINE_IDA(ida_index); | |
24 | ||
25 | struct exar_gpio_chip { | |
26 | struct gpio_chip gpio_chip; | |
27 | struct mutex lock; | |
28 | int index; | |
29 | void __iomem *regs; | |
30 | char name[20]; | |
380b1e2f | 31 | unsigned int first_pin; |
6596e59e SM |
32 | }; |
33 | ||
34 | static void exar_update(struct gpio_chip *chip, unsigned int reg, int val, | |
35 | unsigned int offset) | |
36 | { | |
37 | struct exar_gpio_chip *exar_gpio = gpiochip_get_data(chip); | |
38 | int temp; | |
39 | ||
40 | mutex_lock(&exar_gpio->lock); | |
41 | temp = readb(exar_gpio->regs + reg); | |
42 | temp &= ~BIT(offset); | |
43 | if (val) | |
44 | temp |= BIT(offset); | |
45 | writeb(temp, exar_gpio->regs + reg); | |
46 | mutex_unlock(&exar_gpio->lock); | |
47 | } | |
48 | ||
49 | static int exar_set_direction(struct gpio_chip *chip, int direction, | |
50 | unsigned int offset) | |
51 | { | |
380b1e2f JK |
52 | struct exar_gpio_chip *exar_gpio = gpiochip_get_data(chip); |
53 | unsigned int addr = (offset + exar_gpio->first_pin) / 8 ? | |
54 | EXAR_OFFSET_MPIOSEL_HI : EXAR_OFFSET_MPIOSEL_LO; | |
55 | unsigned int bit = (offset + exar_gpio->first_pin) % 8; | |
6596e59e | 56 | |
380b1e2f | 57 | exar_update(chip, addr, direction, bit); |
6596e59e SM |
58 | return 0; |
59 | } | |
60 | ||
6596e59e SM |
61 | static int exar_get(struct gpio_chip *chip, unsigned int reg) |
62 | { | |
63 | struct exar_gpio_chip *exar_gpio = gpiochip_get_data(chip); | |
64 | int value; | |
65 | ||
66 | mutex_lock(&exar_gpio->lock); | |
67 | value = readb(exar_gpio->regs + reg); | |
68 | mutex_unlock(&exar_gpio->lock); | |
69 | ||
7f45a875 | 70 | return value; |
6596e59e SM |
71 | } |
72 | ||
73 | static int exar_get_direction(struct gpio_chip *chip, unsigned int offset) | |
74 | { | |
380b1e2f JK |
75 | struct exar_gpio_chip *exar_gpio = gpiochip_get_data(chip); |
76 | unsigned int addr = (offset + exar_gpio->first_pin) / 8 ? | |
77 | EXAR_OFFSET_MPIOSEL_HI : EXAR_OFFSET_MPIOSEL_LO; | |
78 | unsigned int bit = (offset + exar_gpio->first_pin) % 8; | |
6596e59e | 79 | |
380b1e2f | 80 | return !!(exar_get(chip, addr) & BIT(bit)); |
6596e59e SM |
81 | } |
82 | ||
83 | static int exar_get_value(struct gpio_chip *chip, unsigned int offset) | |
84 | { | |
380b1e2f JK |
85 | struct exar_gpio_chip *exar_gpio = gpiochip_get_data(chip); |
86 | unsigned int addr = (offset + exar_gpio->first_pin) / 8 ? | |
87 | EXAR_OFFSET_MPIOLVL_HI : EXAR_OFFSET_MPIOLVL_LO; | |
88 | unsigned int bit = (offset + exar_gpio->first_pin) % 8; | |
6596e59e | 89 | |
380b1e2f | 90 | return !!(exar_get(chip, addr) & BIT(bit)); |
6596e59e SM |
91 | } |
92 | ||
93 | static void exar_set_value(struct gpio_chip *chip, unsigned int offset, | |
94 | int value) | |
95 | { | |
380b1e2f JK |
96 | struct exar_gpio_chip *exar_gpio = gpiochip_get_data(chip); |
97 | unsigned int addr = (offset + exar_gpio->first_pin) / 8 ? | |
98 | EXAR_OFFSET_MPIOLVL_HI : EXAR_OFFSET_MPIOLVL_LO; | |
99 | unsigned int bit = (offset + exar_gpio->first_pin) % 8; | |
6596e59e | 100 | |
380b1e2f | 101 | exar_update(chip, addr, value, bit); |
6596e59e SM |
102 | } |
103 | ||
eddeae07 AL |
104 | static int exar_direction_output(struct gpio_chip *chip, unsigned int offset, |
105 | int value) | |
106 | { | |
107 | exar_set_value(chip, offset, value); | |
108 | return exar_set_direction(chip, 0, offset); | |
109 | } | |
110 | ||
111 | static int exar_direction_input(struct gpio_chip *chip, unsigned int offset) | |
112 | { | |
113 | return exar_set_direction(chip, 1, offset); | |
114 | } | |
115 | ||
6596e59e SM |
116 | static int gpio_exar_probe(struct platform_device *pdev) |
117 | { | |
d3936d74 | 118 | struct pci_dev *pcidev = to_pci_dev(pdev->dev.parent); |
6596e59e | 119 | struct exar_gpio_chip *exar_gpio; |
380b1e2f | 120 | u32 first_pin, ngpios; |
6596e59e SM |
121 | void __iomem *p; |
122 | int index, ret; | |
123 | ||
6596e59e | 124 | /* |
8847f5f9 JK |
125 | * The UART driver must have mapped region 0 prior to registering this |
126 | * device - use it. | |
6596e59e | 127 | */ |
8847f5f9 | 128 | p = pcim_iomap_table(pcidev)[0]; |
6596e59e SM |
129 | if (!p) |
130 | return -ENOMEM; | |
131 | ||
a589e211 | 132 | ret = device_property_read_u32(&pdev->dev, "exar,first-pin", |
380b1e2f JK |
133 | &first_pin); |
134 | if (ret) | |
135 | return ret; | |
136 | ||
137 | ret = device_property_read_u32(&pdev->dev, "ngpios", &ngpios); | |
138 | if (ret) | |
139 | return ret; | |
140 | ||
5dab5872 | 141 | exar_gpio = devm_kzalloc(&pdev->dev, sizeof(*exar_gpio), GFP_KERNEL); |
6596e59e SM |
142 | if (!exar_gpio) |
143 | return -ENOMEM; | |
144 | ||
145 | mutex_init(&exar_gpio->lock); | |
146 | ||
147 | index = ida_simple_get(&ida_index, 0, 0, GFP_KERNEL); | |
7ecced09 KL |
148 | if (index < 0) |
149 | goto err_destroy; | |
6596e59e SM |
150 | |
151 | sprintf(exar_gpio->name, "exar_gpio%d", index); | |
152 | exar_gpio->gpio_chip.label = exar_gpio->name; | |
4076cf08 | 153 | exar_gpio->gpio_chip.parent = &pdev->dev; |
6596e59e SM |
154 | exar_gpio->gpio_chip.direction_output = exar_direction_output; |
155 | exar_gpio->gpio_chip.direction_input = exar_direction_input; | |
156 | exar_gpio->gpio_chip.get_direction = exar_get_direction; | |
157 | exar_gpio->gpio_chip.get = exar_get_value; | |
158 | exar_gpio->gpio_chip.set = exar_set_value; | |
159 | exar_gpio->gpio_chip.base = -1; | |
380b1e2f | 160 | exar_gpio->gpio_chip.ngpio = ngpios; |
6596e59e SM |
161 | exar_gpio->regs = p; |
162 | exar_gpio->index = index; | |
380b1e2f | 163 | exar_gpio->first_pin = first_pin; |
6596e59e | 164 | |
5dab5872 | 165 | ret = devm_gpiochip_add_data(&pdev->dev, |
6596e59e SM |
166 | &exar_gpio->gpio_chip, exar_gpio); |
167 | if (ret) | |
168 | goto err_destroy; | |
169 | ||
170 | platform_set_drvdata(pdev, exar_gpio); | |
171 | ||
172 | return 0; | |
173 | ||
174 | err_destroy: | |
175 | ida_simple_remove(&ida_index, index); | |
176 | mutex_destroy(&exar_gpio->lock); | |
177 | return ret; | |
178 | } | |
179 | ||
180 | static int gpio_exar_remove(struct platform_device *pdev) | |
181 | { | |
182 | struct exar_gpio_chip *exar_gpio = platform_get_drvdata(pdev); | |
183 | ||
184 | ida_simple_remove(&ida_index, exar_gpio->index); | |
185 | mutex_destroy(&exar_gpio->lock); | |
186 | ||
187 | return 0; | |
188 | } | |
189 | ||
190 | static struct platform_driver gpio_exar_driver = { | |
191 | .probe = gpio_exar_probe, | |
192 | .remove = gpio_exar_remove, | |
193 | .driver = { | |
194 | .name = DRIVER_NAME, | |
195 | }, | |
196 | }; | |
197 | ||
198 | module_platform_driver(gpio_exar_driver); | |
199 | ||
200 | MODULE_ALIAS("platform:" DRIVER_NAME); | |
201 | MODULE_DESCRIPTION("Exar GPIO driver"); | |
202 | MODULE_AUTHOR("Sudip Mukherjee <sudip.mukherjee@codethink.co.uk>"); | |
203 | MODULE_LICENSE("GPL"); |