]>
Commit | Line | Data |
---|---|---|
0bcb6069 | 1 | /* |
74600ee0 | 2 | * Xilinx gpio driver for xps/axi_gpio IP. |
0bcb6069 | 3 | * |
74600ee0 | 4 | * Copyright 2008 - 2013 Xilinx, Inc. |
0bcb6069 JL |
5 | * |
6 | * This program is free software; you can redistribute it and/or modify | |
7 | * it under the terms of the GNU General Public License version 2 | |
8 | * as published by the Free Software Foundation. | |
9 | * | |
10 | * You should have received a copy of the GNU General Public License | |
11 | * along with this program; if not, write to the Free Software | |
12 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
13 | */ | |
14 | ||
74600ee0 | 15 | #include <linux/bitops.h> |
0bcb6069 JL |
16 | #include <linux/init.h> |
17 | #include <linux/errno.h> | |
bb207ef1 | 18 | #include <linux/module.h> |
0bcb6069 JL |
19 | #include <linux/of_device.h> |
20 | #include <linux/of_platform.h> | |
21 | #include <linux/of_gpio.h> | |
22 | #include <linux/io.h> | |
23 | #include <linux/gpio.h> | |
5a0e3ad6 | 24 | #include <linux/slab.h> |
0bcb6069 JL |
25 | |
26 | /* Register Offset Definitions */ | |
27 | #define XGPIO_DATA_OFFSET (0x0) /* Data register */ | |
28 | #define XGPIO_TRI_OFFSET (0x4) /* I/O direction register */ | |
29 | ||
74600ee0 MS |
30 | #define XGPIO_CHANNEL_OFFSET 0x8 |
31 | ||
32 | /* Read/Write access to the GPIO registers */ | |
c54c58ba | 33 | #if defined(CONFIG_ARCH_ZYNQ) || defined(CONFIG_X86) |
cc090d61 MS |
34 | # define xgpio_readreg(offset) readl(offset) |
35 | # define xgpio_writereg(offset, val) writel(val, offset) | |
36 | #else | |
37 | # define xgpio_readreg(offset) __raw_readl(offset) | |
38 | # define xgpio_writereg(offset, val) __raw_writel(val, offset) | |
39 | #endif | |
74600ee0 MS |
40 | |
41 | /** | |
42 | * struct xgpio_instance - Stores information about GPIO device | |
4ae798fa RRD |
43 | * @mmchip: OF GPIO chip for memory mapped banks |
44 | * @gpio_state: GPIO state shadow register | |
45 | * @gpio_dir: GPIO direction shadow register | |
46 | * @gpio_lock: Lock used for synchronization | |
47 | * @inited: True if the port has been inited | |
74600ee0 | 48 | */ |
0bcb6069 JL |
49 | struct xgpio_instance { |
50 | struct of_mm_gpio_chip mmchip; | |
1d6902d3 RRD |
51 | unsigned int gpio_width[2]; |
52 | u32 gpio_state[2]; | |
53 | u32 gpio_dir[2]; | |
54 | spinlock_t gpio_lock[2]; | |
749564ff RRD |
55 | }; |
56 | ||
1d6902d3 RRD |
57 | static inline int xgpio_index(struct xgpio_instance *chip, int gpio) |
58 | { | |
59 | if (gpio >= chip->gpio_width[0]) | |
60 | return 1; | |
61 | ||
62 | return 0; | |
63 | } | |
64 | ||
65 | static inline int xgpio_regoffset(struct xgpio_instance *chip, int gpio) | |
66 | { | |
67 | if (xgpio_index(chip, gpio)) | |
68 | return XGPIO_CHANNEL_OFFSET; | |
69 | ||
70 | return 0; | |
71 | } | |
72 | ||
73 | static inline int xgpio_offset(struct xgpio_instance *chip, int gpio) | |
74 | { | |
75 | if (xgpio_index(chip, gpio)) | |
76 | return gpio - chip->gpio_width[0]; | |
77 | ||
78 | return gpio; | |
79 | } | |
0bcb6069 JL |
80 | |
81 | /** | |
82 | * xgpio_get - Read the specified signal of the GPIO device. | |
83 | * @gc: Pointer to gpio_chip device structure. | |
84 | * @gpio: GPIO signal number. | |
85 | * | |
4ae798fa RRD |
86 | * This function reads the specified signal of the GPIO device. |
87 | * | |
88 | * Return: | |
89 | * 0 if direction of GPIO signals is set as input otherwise it | |
90 | * returns negative error value. | |
0bcb6069 JL |
91 | */ |
92 | static int xgpio_get(struct gpio_chip *gc, unsigned int gpio) | |
93 | { | |
94 | struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc); | |
1d6902d3 RRD |
95 | struct xgpio_instance *chip = |
96 | container_of(mm_gc, struct xgpio_instance, mmchip); | |
97 | u32 val; | |
0bcb6069 | 98 | |
1d6902d3 RRD |
99 | val = xgpio_readreg(mm_gc->regs + XGPIO_DATA_OFFSET + |
100 | xgpio_regoffset(chip, gpio)); | |
101 | ||
102 | return !!(val & BIT(xgpio_offset(chip, gpio))); | |
0bcb6069 JL |
103 | } |
104 | ||
105 | /** | |
106 | * xgpio_set - Write the specified signal of the GPIO device. | |
107 | * @gc: Pointer to gpio_chip device structure. | |
108 | * @gpio: GPIO signal number. | |
109 | * @val: Value to be written to specified signal. | |
110 | * | |
111 | * This function writes the specified value in to the specified signal of the | |
112 | * GPIO device. | |
113 | */ | |
114 | static void xgpio_set(struct gpio_chip *gc, unsigned int gpio, int val) | |
115 | { | |
116 | unsigned long flags; | |
117 | struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc); | |
118 | struct xgpio_instance *chip = | |
119 | container_of(mm_gc, struct xgpio_instance, mmchip); | |
1d6902d3 RRD |
120 | int index = xgpio_index(chip, gpio); |
121 | int offset = xgpio_offset(chip, gpio); | |
0bcb6069 | 122 | |
1d6902d3 | 123 | spin_lock_irqsave(&chip->gpio_lock[index], flags); |
0bcb6069 JL |
124 | |
125 | /* Write to GPIO signal and set its direction to output */ | |
126 | if (val) | |
1d6902d3 | 127 | chip->gpio_state[index] |= BIT(offset); |
0bcb6069 | 128 | else |
1d6902d3 | 129 | chip->gpio_state[index] &= ~BIT(offset); |
74600ee0 | 130 | |
1d6902d3 RRD |
131 | xgpio_writereg(mm_gc->regs + XGPIO_DATA_OFFSET + |
132 | xgpio_regoffset(chip, gpio), chip->gpio_state[index]); | |
0bcb6069 | 133 | |
1d6902d3 | 134 | spin_unlock_irqrestore(&chip->gpio_lock[index], flags); |
0bcb6069 JL |
135 | } |
136 | ||
137 | /** | |
138 | * xgpio_dir_in - Set the direction of the specified GPIO signal as input. | |
139 | * @gc: Pointer to gpio_chip device structure. | |
140 | * @gpio: GPIO signal number. | |
141 | * | |
4ae798fa RRD |
142 | * Return: |
143 | * 0 - if direction of GPIO signals is set as input | |
144 | * otherwise it returns negative error value. | |
0bcb6069 JL |
145 | */ |
146 | static int xgpio_dir_in(struct gpio_chip *gc, unsigned int gpio) | |
147 | { | |
148 | unsigned long flags; | |
149 | struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc); | |
150 | struct xgpio_instance *chip = | |
151 | container_of(mm_gc, struct xgpio_instance, mmchip); | |
1d6902d3 RRD |
152 | int index = xgpio_index(chip, gpio); |
153 | int offset = xgpio_offset(chip, gpio); | |
0bcb6069 | 154 | |
1d6902d3 | 155 | spin_lock_irqsave(&chip->gpio_lock[index], flags); |
0bcb6069 JL |
156 | |
157 | /* Set the GPIO bit in shadow register and set direction as input */ | |
1d6902d3 RRD |
158 | chip->gpio_dir[index] |= BIT(offset); |
159 | xgpio_writereg(mm_gc->regs + XGPIO_TRI_OFFSET + | |
160 | xgpio_regoffset(chip, gpio), chip->gpio_dir[index]); | |
0bcb6069 | 161 | |
1d6902d3 | 162 | spin_unlock_irqrestore(&chip->gpio_lock[index], flags); |
0bcb6069 JL |
163 | |
164 | return 0; | |
165 | } | |
166 | ||
167 | /** | |
168 | * xgpio_dir_out - Set the direction of the specified GPIO signal as output. | |
169 | * @gc: Pointer to gpio_chip device structure. | |
170 | * @gpio: GPIO signal number. | |
171 | * @val: Value to be written to specified signal. | |
172 | * | |
4ae798fa RRD |
173 | * This function sets the direction of specified GPIO signal as output. |
174 | * | |
175 | * Return: | |
176 | * If all GPIO signals of GPIO chip is configured as input then it returns | |
0bcb6069 JL |
177 | * error otherwise it returns 0. |
178 | */ | |
179 | static int xgpio_dir_out(struct gpio_chip *gc, unsigned int gpio, int val) | |
180 | { | |
181 | unsigned long flags; | |
182 | struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc); | |
183 | struct xgpio_instance *chip = | |
184 | container_of(mm_gc, struct xgpio_instance, mmchip); | |
1d6902d3 RRD |
185 | int index = xgpio_index(chip, gpio); |
186 | int offset = xgpio_offset(chip, gpio); | |
0bcb6069 | 187 | |
1d6902d3 | 188 | spin_lock_irqsave(&chip->gpio_lock[index], flags); |
0bcb6069 JL |
189 | |
190 | /* Write state of GPIO signal */ | |
191 | if (val) | |
1d6902d3 | 192 | chip->gpio_state[index] |= BIT(offset); |
0bcb6069 | 193 | else |
1d6902d3 RRD |
194 | chip->gpio_state[index] &= ~BIT(offset); |
195 | xgpio_writereg(mm_gc->regs + XGPIO_DATA_OFFSET + | |
196 | xgpio_regoffset(chip, gpio), chip->gpio_state[index]); | |
0bcb6069 JL |
197 | |
198 | /* Clear the GPIO bit in shadow register and set direction as output */ | |
1d6902d3 RRD |
199 | chip->gpio_dir[index] &= ~BIT(offset); |
200 | xgpio_writereg(mm_gc->regs + XGPIO_TRI_OFFSET + | |
201 | xgpio_regoffset(chip, gpio), chip->gpio_dir[index]); | |
0bcb6069 | 202 | |
1d6902d3 | 203 | spin_unlock_irqrestore(&chip->gpio_lock[index], flags); |
0bcb6069 JL |
204 | |
205 | return 0; | |
206 | } | |
207 | ||
208 | /** | |
209 | * xgpio_save_regs - Set initial values of GPIO pins | |
4ae798fa | 210 | * @mm_gc: Pointer to memory mapped GPIO chip structure |
0bcb6069 JL |
211 | */ |
212 | static void xgpio_save_regs(struct of_mm_gpio_chip *mm_gc) | |
213 | { | |
214 | struct xgpio_instance *chip = | |
215 | container_of(mm_gc, struct xgpio_instance, mmchip); | |
216 | ||
1d6902d3 RRD |
217 | xgpio_writereg(mm_gc->regs + XGPIO_DATA_OFFSET, chip->gpio_state[0]); |
218 | xgpio_writereg(mm_gc->regs + XGPIO_TRI_OFFSET, chip->gpio_dir[0]); | |
219 | ||
220 | if (!chip->gpio_width[1]) | |
221 | return; | |
222 | ||
223 | xgpio_writereg(mm_gc->regs + XGPIO_DATA_OFFSET + XGPIO_TRI_OFFSET, | |
224 | chip->gpio_state[1]); | |
225 | xgpio_writereg(mm_gc->regs + XGPIO_TRI_OFFSET + XGPIO_TRI_OFFSET, | |
226 | chip->gpio_dir[1]); | |
0bcb6069 JL |
227 | } |
228 | ||
749564ff RRD |
229 | /** |
230 | * xgpio_remove - Remove method for the GPIO device. | |
231 | * @pdev: pointer to the platform device | |
232 | * | |
233 | * This function remove gpiochips and frees all the allocated resources. | |
234 | */ | |
235 | static int xgpio_remove(struct platform_device *pdev) | |
236 | { | |
1d6902d3 | 237 | struct xgpio_instance *chip = platform_get_drvdata(pdev); |
749564ff | 238 | |
c458e450 | 239 | of_mm_gpiochip_remove(&chip->mmchip); |
749564ff RRD |
240 | |
241 | return 0; | |
242 | } | |
243 | ||
0bcb6069 JL |
244 | /** |
245 | * xgpio_of_probe - Probe method for the GPIO device. | |
749564ff | 246 | * @pdev: pointer to the platform device |
0bcb6069 | 247 | * |
4ae798fa RRD |
248 | * Return: |
249 | * It returns 0, if the driver is bound to the GPIO device, or | |
250 | * a negative value if there is an error. | |
0bcb6069 | 251 | */ |
749564ff | 252 | static int xgpio_probe(struct platform_device *pdev) |
0bcb6069 JL |
253 | { |
254 | struct xgpio_instance *chip; | |
0bcb6069 | 255 | int status = 0; |
749564ff | 256 | struct device_node *np = pdev->dev.of_node; |
1d6902d3 | 257 | u32 is_dual; |
0bcb6069 | 258 | |
1d6902d3 RRD |
259 | chip = devm_kzalloc(&pdev->dev, sizeof(*chip), GFP_KERNEL); |
260 | if (!chip) | |
0bcb6069 | 261 | return -ENOMEM; |
0bcb6069 | 262 | |
1d6902d3 | 263 | platform_set_drvdata(pdev, chip); |
749564ff | 264 | |
0bcb6069 | 265 | /* Update GPIO state shadow register with default value */ |
1d6902d3 | 266 | of_property_read_u32(np, "xlnx,dout-default", &chip->gpio_state[0]); |
0bcb6069 JL |
267 | |
268 | /* Update GPIO direction shadow register with default value */ | |
1d6902d3 RRD |
269 | if (of_property_read_u32(np, "xlnx,tri-default", &chip->gpio_dir[0])) |
270 | chip->gpio_dir[0] = 0xFFFFFFFF; | |
6f8bf500 | 271 | |
1b4c5a6e GV |
272 | /* |
273 | * Check device node and parent device node for device width | |
274 | * and assume default width of 32 | |
275 | */ | |
1d6902d3 RRD |
276 | if (of_property_read_u32(np, "xlnx,gpio-width", &chip->gpio_width[0])) |
277 | chip->gpio_width[0] = 32; | |
278 | ||
279 | spin_lock_init(&chip->gpio_lock[0]); | |
280 | ||
281 | if (of_property_read_u32(np, "xlnx,is-dual", &is_dual)) | |
282 | is_dual = 0; | |
0bcb6069 | 283 | |
1d6902d3 RRD |
284 | if (is_dual) { |
285 | /* Update GPIO state shadow register with default value */ | |
286 | of_property_read_u32(np, "xlnx,dout-default-2", | |
287 | &chip->gpio_state[1]); | |
288 | ||
289 | /* Update GPIO direction shadow register with default value */ | |
290 | if (of_property_read_u32(np, "xlnx,tri-default-2", | |
291 | &chip->gpio_dir[1])) | |
292 | chip->gpio_dir[1] = 0xFFFFFFFF; | |
0bcb6069 | 293 | |
1d6902d3 RRD |
294 | /* |
295 | * Check device node and parent device node for device width | |
296 | * and assume default width of 32 | |
297 | */ | |
298 | if (of_property_read_u32(np, "xlnx,gpio2-width", | |
299 | &chip->gpio_width[1])) | |
300 | chip->gpio_width[1] = 32; | |
301 | ||
302 | spin_lock_init(&chip->gpio_lock[1]); | |
303 | } | |
304 | ||
305 | chip->mmchip.gc.ngpio = chip->gpio_width[0] + chip->gpio_width[1]; | |
749564ff | 306 | chip->mmchip.gc.dev = &pdev->dev; |
a19e3da5 AV |
307 | chip->mmchip.gc.direction_input = xgpio_dir_in; |
308 | chip->mmchip.gc.direction_output = xgpio_dir_out; | |
309 | chip->mmchip.gc.get = xgpio_get; | |
310 | chip->mmchip.gc.set = xgpio_set; | |
0bcb6069 JL |
311 | |
312 | chip->mmchip.save_regs = xgpio_save_regs; | |
313 | ||
314 | /* Call the OF gpio helper to setup and register the GPIO device */ | |
315 | status = of_mm_gpiochip_add(np, &chip->mmchip); | |
316 | if (status) { | |
0bcb6069 JL |
317 | pr_err("%s: error in probe function with status %d\n", |
318 | np->full_name, status); | |
319 | return status; | |
320 | } | |
74600ee0 | 321 | |
0bcb6069 JL |
322 | return 0; |
323 | } | |
324 | ||
9992bc95 | 325 | static const struct of_device_id xgpio_of_match[] = { |
0bcb6069 JL |
326 | { .compatible = "xlnx,xps-gpio-1.00.a", }, |
327 | { /* end of list */ }, | |
328 | }; | |
329 | ||
749564ff | 330 | MODULE_DEVICE_TABLE(of, xgpio_of_match); |
0bcb6069 | 331 | |
749564ff RRD |
332 | static struct platform_driver xgpio_plat_driver = { |
333 | .probe = xgpio_probe, | |
334 | .remove = xgpio_remove, | |
335 | .driver = { | |
336 | .name = "gpio-xilinx", | |
337 | .of_match_table = xgpio_of_match, | |
338 | }, | |
339 | }; | |
0bcb6069 | 340 | |
749564ff RRD |
341 | static int __init xgpio_init(void) |
342 | { | |
343 | return platform_driver_register(&xgpio_plat_driver); | |
0bcb6069 JL |
344 | } |
345 | ||
0bcb6069 | 346 | subsys_initcall(xgpio_init); |
749564ff RRD |
347 | |
348 | static void __exit xgpio_exit(void) | |
349 | { | |
350 | platform_driver_unregister(&xgpio_plat_driver); | |
351 | } | |
352 | module_exit(xgpio_exit); | |
0bcb6069 JL |
353 | |
354 | MODULE_AUTHOR("Xilinx, Inc."); | |
355 | MODULE_DESCRIPTION("Xilinx GPIO driver"); | |
356 | MODULE_LICENSE("GPL"); |