]>
Commit | Line | Data |
---|---|---|
a55f4506 LPC |
1 | /* |
2 | * Copyright (C) 2009-2010, Lars-Peter Clausen <lars@metafoo.de> | |
3 | * JZ4740 platform GPIO support | |
4 | * | |
5 | * This program is free software; you can redistribute it and/or modify it | |
70342287 | 6 | * under the terms of the GNU General Public License as published by the |
a55f4506 LPC |
7 | * Free Software Foundation; either version 2 of the License, or (at your |
8 | * option) any later version. | |
9 | * | |
10 | * You should have received a copy of the GNU General Public License along | |
11 | * with this program; if not, write to the Free Software Foundation, Inc., | |
12 | * 675 Mass Ave, Cambridge, MA 02139, USA. | |
13 | * | |
14 | */ | |
15 | ||
16 | #include <linux/kernel.h> | |
17 | #include <linux/module.h> | |
18 | #include <linux/init.h> | |
19 | ||
a55f4506 | 20 | #include <linux/io.h> |
f5abf9ee LW |
21 | #include <linux/gpio/driver.h> |
22 | /* FIXME: needed for gpio_request(), try to remove consumer API from driver */ | |
a55f4506 LPC |
23 | #include <linux/gpio.h> |
24 | #include <linux/delay.h> | |
25 | #include <linux/interrupt.h> | |
44e08e70 | 26 | #include <linux/irqchip/ingenic.h> |
a55f4506 LPC |
27 | #include <linux/bitops.h> |
28 | ||
29 | #include <linux/debugfs.h> | |
30 | #include <linux/seq_file.h> | |
31 | ||
32 | #include <asm/mach-jz4740/base.h> | |
5b235dc2 | 33 | #include <asm/mach-jz4740/gpio.h> |
a55f4506 LPC |
34 | |
35 | #define JZ4740_GPIO_BASE_A (32*0) | |
36 | #define JZ4740_GPIO_BASE_B (32*1) | |
37 | #define JZ4740_GPIO_BASE_C (32*2) | |
38 | #define JZ4740_GPIO_BASE_D (32*3) | |
39 | ||
40 | #define JZ4740_GPIO_NUM_A 32 | |
41 | #define JZ4740_GPIO_NUM_B 32 | |
42 | #define JZ4740_GPIO_NUM_C 31 | |
43 | #define JZ4740_GPIO_NUM_D 32 | |
44 | ||
45 | #define JZ4740_IRQ_GPIO_BASE_A (JZ4740_IRQ_GPIO(0) + JZ4740_GPIO_BASE_A) | |
46 | #define JZ4740_IRQ_GPIO_BASE_B (JZ4740_IRQ_GPIO(0) + JZ4740_GPIO_BASE_B) | |
47 | #define JZ4740_IRQ_GPIO_BASE_C (JZ4740_IRQ_GPIO(0) + JZ4740_GPIO_BASE_C) | |
48 | #define JZ4740_IRQ_GPIO_BASE_D (JZ4740_IRQ_GPIO(0) + JZ4740_GPIO_BASE_D) | |
49 | ||
50 | #define JZ_REG_GPIO_PIN 0x00 | |
51 | #define JZ_REG_GPIO_DATA 0x10 | |
52 | #define JZ_REG_GPIO_DATA_SET 0x14 | |
53 | #define JZ_REG_GPIO_DATA_CLEAR 0x18 | |
54 | #define JZ_REG_GPIO_MASK 0x20 | |
55 | #define JZ_REG_GPIO_MASK_SET 0x24 | |
56 | #define JZ_REG_GPIO_MASK_CLEAR 0x28 | |
57 | #define JZ_REG_GPIO_PULL 0x30 | |
58 | #define JZ_REG_GPIO_PULL_SET 0x34 | |
59 | #define JZ_REG_GPIO_PULL_CLEAR 0x38 | |
60 | #define JZ_REG_GPIO_FUNC 0x40 | |
61 | #define JZ_REG_GPIO_FUNC_SET 0x44 | |
62 | #define JZ_REG_GPIO_FUNC_CLEAR 0x48 | |
63 | #define JZ_REG_GPIO_SELECT 0x50 | |
64 | #define JZ_REG_GPIO_SELECT_SET 0x54 | |
65 | #define JZ_REG_GPIO_SELECT_CLEAR 0x58 | |
66 | #define JZ_REG_GPIO_DIRECTION 0x60 | |
67 | #define JZ_REG_GPIO_DIRECTION_SET 0x64 | |
68 | #define JZ_REG_GPIO_DIRECTION_CLEAR 0x68 | |
69 | #define JZ_REG_GPIO_TRIGGER 0x70 | |
70 | #define JZ_REG_GPIO_TRIGGER_SET 0x74 | |
71 | #define JZ_REG_GPIO_TRIGGER_CLEAR 0x78 | |
72 | #define JZ_REG_GPIO_FLAG 0x80 | |
73 | #define JZ_REG_GPIO_FLAG_CLEAR 0x14 | |
74 | ||
75 | #define GPIO_TO_BIT(gpio) BIT(gpio & 0x1f) | |
76 | #define GPIO_TO_REG(gpio, reg) (gpio_to_jz_gpio_chip(gpio)->base + (reg)) | |
77 | #define CHIP_TO_REG(chip, reg) (gpio_chip_to_jz_gpio_chip(chip)->base + (reg)) | |
78 | ||
79 | struct jz_gpio_chip { | |
80 | unsigned int irq; | |
81 | unsigned int irq_base; | |
a55f4506 LPC |
82 | uint32_t edge_trigger_both; |
83 | ||
84 | void __iomem *base; | |
85 | ||
a55f4506 | 86 | struct gpio_chip gpio_chip; |
a55f4506 LPC |
87 | }; |
88 | ||
89 | static struct jz_gpio_chip jz4740_gpio_chips[]; | |
90 | ||
91 | static inline struct jz_gpio_chip *gpio_to_jz_gpio_chip(unsigned int gpio) | |
92 | { | |
93 | return &jz4740_gpio_chips[gpio >> 5]; | |
94 | } | |
95 | ||
f5abf9ee | 96 | static inline struct jz_gpio_chip *gpio_chip_to_jz_gpio_chip(struct gpio_chip *gc) |
a55f4506 | 97 | { |
f5abf9ee | 98 | return gpiochip_get_data(gc); |
a55f4506 LPC |
99 | } |
100 | ||
42b64f38 | 101 | static inline struct jz_gpio_chip *irq_to_jz_gpio_chip(struct irq_data *data) |
a55f4506 | 102 | { |
83bc7692 LPC |
103 | struct irq_chip_generic *gc = irq_data_get_irq_chip_data(data); |
104 | return gc->private; | |
a55f4506 LPC |
105 | } |
106 | ||
107 | static inline void jz_gpio_write_bit(unsigned int gpio, unsigned int reg) | |
108 | { | |
109 | writel(GPIO_TO_BIT(gpio), GPIO_TO_REG(gpio, reg)); | |
110 | } | |
111 | ||
112 | int jz_gpio_set_function(int gpio, enum jz_gpio_function function) | |
113 | { | |
114 | if (function == JZ_GPIO_FUNC_NONE) { | |
115 | jz_gpio_write_bit(gpio, JZ_REG_GPIO_FUNC_CLEAR); | |
116 | jz_gpio_write_bit(gpio, JZ_REG_GPIO_SELECT_CLEAR); | |
117 | jz_gpio_write_bit(gpio, JZ_REG_GPIO_TRIGGER_CLEAR); | |
118 | } else { | |
119 | jz_gpio_write_bit(gpio, JZ_REG_GPIO_FUNC_SET); | |
120 | jz_gpio_write_bit(gpio, JZ_REG_GPIO_TRIGGER_CLEAR); | |
121 | switch (function) { | |
122 | case JZ_GPIO_FUNC1: | |
123 | jz_gpio_write_bit(gpio, JZ_REG_GPIO_SELECT_CLEAR); | |
124 | break; | |
125 | case JZ_GPIO_FUNC3: | |
126 | jz_gpio_write_bit(gpio, JZ_REG_GPIO_TRIGGER_SET); | |
127 | case JZ_GPIO_FUNC2: /* Falltrough */ | |
128 | jz_gpio_write_bit(gpio, JZ_REG_GPIO_SELECT_SET); | |
129 | break; | |
130 | default: | |
131 | BUG(); | |
132 | break; | |
133 | } | |
134 | } | |
135 | ||
136 | return 0; | |
137 | } | |
138 | EXPORT_SYMBOL_GPL(jz_gpio_set_function); | |
139 | ||
140 | int jz_gpio_bulk_request(const struct jz_gpio_bulk_request *request, size_t num) | |
141 | { | |
142 | size_t i; | |
143 | int ret; | |
144 | ||
145 | for (i = 0; i < num; ++i, ++request) { | |
146 | ret = gpio_request(request->gpio, request->name); | |
147 | if (ret) | |
148 | goto err; | |
149 | jz_gpio_set_function(request->gpio, request->function); | |
150 | } | |
151 | ||
152 | return 0; | |
153 | ||
154 | err: | |
155 | for (--request; i > 0; --i, --request) { | |
156 | gpio_free(request->gpio); | |
157 | jz_gpio_set_function(request->gpio, JZ_GPIO_FUNC_NONE); | |
158 | } | |
159 | ||
160 | return ret; | |
161 | } | |
162 | EXPORT_SYMBOL_GPL(jz_gpio_bulk_request); | |
163 | ||
164 | void jz_gpio_bulk_free(const struct jz_gpio_bulk_request *request, size_t num) | |
165 | { | |
166 | size_t i; | |
167 | ||
168 | for (i = 0; i < num; ++i, ++request) { | |
169 | gpio_free(request->gpio); | |
170 | jz_gpio_set_function(request->gpio, JZ_GPIO_FUNC_NONE); | |
171 | } | |
172 | ||
173 | } | |
174 | EXPORT_SYMBOL_GPL(jz_gpio_bulk_free); | |
175 | ||
176 | void jz_gpio_bulk_suspend(const struct jz_gpio_bulk_request *request, size_t num) | |
177 | { | |
178 | size_t i; | |
179 | ||
180 | for (i = 0; i < num; ++i, ++request) { | |
181 | jz_gpio_set_function(request->gpio, JZ_GPIO_FUNC_NONE); | |
182 | jz_gpio_write_bit(request->gpio, JZ_REG_GPIO_DIRECTION_CLEAR); | |
183 | jz_gpio_write_bit(request->gpio, JZ_REG_GPIO_PULL_SET); | |
184 | } | |
185 | } | |
186 | EXPORT_SYMBOL_GPL(jz_gpio_bulk_suspend); | |
187 | ||
188 | void jz_gpio_bulk_resume(const struct jz_gpio_bulk_request *request, size_t num) | |
189 | { | |
190 | size_t i; | |
191 | ||
192 | for (i = 0; i < num; ++i, ++request) | |
193 | jz_gpio_set_function(request->gpio, request->function); | |
194 | } | |
195 | EXPORT_SYMBOL_GPL(jz_gpio_bulk_resume); | |
196 | ||
197 | void jz_gpio_enable_pullup(unsigned gpio) | |
198 | { | |
199 | jz_gpio_write_bit(gpio, JZ_REG_GPIO_PULL_CLEAR); | |
200 | } | |
201 | EXPORT_SYMBOL_GPL(jz_gpio_enable_pullup); | |
202 | ||
203 | void jz_gpio_disable_pullup(unsigned gpio) | |
204 | { | |
205 | jz_gpio_write_bit(gpio, JZ_REG_GPIO_PULL_SET); | |
206 | } | |
207 | EXPORT_SYMBOL_GPL(jz_gpio_disable_pullup); | |
208 | ||
209 | static int jz_gpio_get_value(struct gpio_chip *chip, unsigned gpio) | |
210 | { | |
211 | return !!(readl(CHIP_TO_REG(chip, JZ_REG_GPIO_PIN)) & BIT(gpio)); | |
212 | } | |
213 | ||
214 | static void jz_gpio_set_value(struct gpio_chip *chip, unsigned gpio, int value) | |
215 | { | |
216 | uint32_t __iomem *reg = CHIP_TO_REG(chip, JZ_REG_GPIO_DATA_SET); | |
217 | reg += !value; | |
218 | writel(BIT(gpio), reg); | |
219 | } | |
220 | ||
221 | static int jz_gpio_direction_output(struct gpio_chip *chip, unsigned gpio, | |
222 | int value) | |
223 | { | |
224 | writel(BIT(gpio), CHIP_TO_REG(chip, JZ_REG_GPIO_DIRECTION_SET)); | |
225 | jz_gpio_set_value(chip, gpio, value); | |
226 | ||
227 | return 0; | |
228 | } | |
229 | ||
230 | static int jz_gpio_direction_input(struct gpio_chip *chip, unsigned gpio) | |
231 | { | |
232 | writel(BIT(gpio), CHIP_TO_REG(chip, JZ_REG_GPIO_DIRECTION_CLEAR)); | |
233 | ||
234 | return 0; | |
235 | } | |
236 | ||
832f5dac AB |
237 | static int jz_gpio_to_irq(struct gpio_chip *chip, unsigned gpio) |
238 | { | |
f5abf9ee | 239 | struct jz_gpio_chip *jz_gpio = gpiochip_get_data(chip); |
832f5dac AB |
240 | |
241 | return jz_gpio->irq_base + gpio; | |
242 | } | |
243 | ||
a55f4506 LPC |
244 | int jz_gpio_port_direction_input(int port, uint32_t mask) |
245 | { | |
246 | writel(mask, GPIO_TO_REG(port, JZ_REG_GPIO_DIRECTION_CLEAR)); | |
247 | ||
248 | return 0; | |
249 | } | |
250 | EXPORT_SYMBOL(jz_gpio_port_direction_input); | |
251 | ||
252 | int jz_gpio_port_direction_output(int port, uint32_t mask) | |
253 | { | |
254 | writel(mask, GPIO_TO_REG(port, JZ_REG_GPIO_DIRECTION_SET)); | |
255 | ||
256 | return 0; | |
257 | } | |
258 | EXPORT_SYMBOL(jz_gpio_port_direction_output); | |
259 | ||
260 | void jz_gpio_port_set_value(int port, uint32_t value, uint32_t mask) | |
261 | { | |
262 | writel(~value & mask, GPIO_TO_REG(port, JZ_REG_GPIO_DATA_CLEAR)); | |
263 | writel(value & mask, GPIO_TO_REG(port, JZ_REG_GPIO_DATA_SET)); | |
264 | } | |
265 | EXPORT_SYMBOL(jz_gpio_port_set_value); | |
266 | ||
267 | uint32_t jz_gpio_port_get_value(int port, uint32_t mask) | |
268 | { | |
269 | uint32_t value = readl(GPIO_TO_REG(port, JZ_REG_GPIO_PIN)); | |
270 | ||
271 | return value & mask; | |
272 | } | |
273 | EXPORT_SYMBOL(jz_gpio_port_get_value); | |
274 | ||
b61a459f | 275 | #define IRQ_TO_BIT(irq) BIT((irq - JZ4740_IRQ_GPIO(0)) & 0x1f) |
a55f4506 LPC |
276 | |
277 | static void jz_gpio_check_trigger_both(struct jz_gpio_chip *chip, unsigned int irq) | |
278 | { | |
279 | uint32_t value; | |
280 | void __iomem *reg; | |
281 | uint32_t mask = IRQ_TO_BIT(irq); | |
282 | ||
283 | if (!(chip->edge_trigger_both & mask)) | |
284 | return; | |
285 | ||
286 | reg = chip->base; | |
287 | ||
288 | value = readl(chip->base + JZ_REG_GPIO_PIN); | |
289 | if (value & mask) | |
290 | reg += JZ_REG_GPIO_DIRECTION_CLEAR; | |
291 | else | |
292 | reg += JZ_REG_GPIO_DIRECTION_SET; | |
293 | ||
294 | writel(mask, reg); | |
295 | } | |
296 | ||
bd0b9ac4 | 297 | static void jz_gpio_irq_demux_handler(struct irq_desc *desc) |
a55f4506 LPC |
298 | { |
299 | uint32_t flag; | |
300 | unsigned int gpio_irq; | |
e4ec7989 | 301 | struct jz_gpio_chip *chip = irq_desc_get_handler_data(desc); |
a55f4506 | 302 | |
a55f4506 | 303 | flag = readl(chip->base + JZ_REG_GPIO_FLAG); |
a55f4506 LPC |
304 | if (!flag) |
305 | return; | |
306 | ||
fe5a8b7f | 307 | gpio_irq = chip->irq_base + __fls(flag); |
a55f4506 | 308 | |
93303638 | 309 | jz_gpio_check_trigger_both(chip, gpio_irq); |
a55f4506 | 310 | |
a55f4506 LPC |
311 | generic_handle_irq(gpio_irq); |
312 | }; | |
313 | ||
42b64f38 | 314 | static inline void jz_gpio_set_irq_bit(struct irq_data *data, unsigned int reg) |
a55f4506 | 315 | { |
42b64f38 TG |
316 | struct jz_gpio_chip *chip = irq_to_jz_gpio_chip(data); |
317 | writel(IRQ_TO_BIT(data->irq), chip->base + reg); | |
a55f4506 LPC |
318 | } |
319 | ||
42b64f38 | 320 | static void jz_gpio_irq_unmask(struct irq_data *data) |
a55f4506 | 321 | { |
42b64f38 | 322 | struct jz_gpio_chip *chip = irq_to_jz_gpio_chip(data); |
a55f4506 | 323 | |
42b64f38 | 324 | jz_gpio_check_trigger_both(chip, data->irq); |
83bc7692 | 325 | irq_gc_unmask_enable_reg(data); |
a55f4506 LPC |
326 | }; |
327 | ||
328 | /* TODO: Check if function is gpio */ | |
42b64f38 | 329 | static unsigned int jz_gpio_irq_startup(struct irq_data *data) |
a55f4506 | 330 | { |
42b64f38 | 331 | jz_gpio_set_irq_bit(data, JZ_REG_GPIO_SELECT_SET); |
42b64f38 | 332 | jz_gpio_irq_unmask(data); |
a55f4506 LPC |
333 | return 0; |
334 | } | |
335 | ||
42b64f38 | 336 | static void jz_gpio_irq_shutdown(struct irq_data *data) |
a55f4506 | 337 | { |
83bc7692 | 338 | irq_gc_mask_disable_reg(data); |
a55f4506 LPC |
339 | |
340 | /* Set direction to input */ | |
42b64f38 TG |
341 | jz_gpio_set_irq_bit(data, JZ_REG_GPIO_DIRECTION_CLEAR); |
342 | jz_gpio_set_irq_bit(data, JZ_REG_GPIO_SELECT_CLEAR); | |
a55f4506 LPC |
343 | } |
344 | ||
42b64f38 | 345 | static int jz_gpio_irq_set_type(struct irq_data *data, unsigned int flow_type) |
a55f4506 | 346 | { |
42b64f38 | 347 | struct jz_gpio_chip *chip = irq_to_jz_gpio_chip(data); |
42b64f38 | 348 | unsigned int irq = data->irq; |
a55f4506 | 349 | |
a55f4506 LPC |
350 | if (flow_type == IRQ_TYPE_EDGE_BOTH) { |
351 | uint32_t value = readl(chip->base + JZ_REG_GPIO_PIN); | |
352 | if (value & IRQ_TO_BIT(irq)) | |
353 | flow_type = IRQ_TYPE_EDGE_FALLING; | |
354 | else | |
355 | flow_type = IRQ_TYPE_EDGE_RISING; | |
356 | chip->edge_trigger_both |= IRQ_TO_BIT(irq); | |
357 | } else { | |
358 | chip->edge_trigger_both &= ~IRQ_TO_BIT(irq); | |
359 | } | |
360 | ||
361 | switch (flow_type) { | |
362 | case IRQ_TYPE_EDGE_RISING: | |
42b64f38 TG |
363 | jz_gpio_set_irq_bit(data, JZ_REG_GPIO_DIRECTION_SET); |
364 | jz_gpio_set_irq_bit(data, JZ_REG_GPIO_TRIGGER_SET); | |
a55f4506 LPC |
365 | break; |
366 | case IRQ_TYPE_EDGE_FALLING: | |
42b64f38 TG |
367 | jz_gpio_set_irq_bit(data, JZ_REG_GPIO_DIRECTION_CLEAR); |
368 | jz_gpio_set_irq_bit(data, JZ_REG_GPIO_TRIGGER_SET); | |
a55f4506 LPC |
369 | break; |
370 | case IRQ_TYPE_LEVEL_HIGH: | |
42b64f38 TG |
371 | jz_gpio_set_irq_bit(data, JZ_REG_GPIO_DIRECTION_SET); |
372 | jz_gpio_set_irq_bit(data, JZ_REG_GPIO_TRIGGER_CLEAR); | |
a55f4506 LPC |
373 | break; |
374 | case IRQ_TYPE_LEVEL_LOW: | |
42b64f38 TG |
375 | jz_gpio_set_irq_bit(data, JZ_REG_GPIO_DIRECTION_CLEAR); |
376 | jz_gpio_set_irq_bit(data, JZ_REG_GPIO_TRIGGER_CLEAR); | |
a55f4506 LPC |
377 | break; |
378 | default: | |
379 | return -EINVAL; | |
380 | } | |
381 | ||
a55f4506 LPC |
382 | return 0; |
383 | } | |
384 | ||
42b64f38 | 385 | static int jz_gpio_irq_set_wake(struct irq_data *data, unsigned int on) |
a55f4506 | 386 | { |
42b64f38 | 387 | struct jz_gpio_chip *chip = irq_to_jz_gpio_chip(data); |
a55f4506 | 388 | |
83bc7692 | 389 | irq_gc_set_wake(data, on); |
e4ec7989 | 390 | irq_set_irq_wake(chip->irq, on); |
83bc7692 | 391 | |
a55f4506 LPC |
392 | return 0; |
393 | } | |
394 | ||
a55f4506 LPC |
395 | #define JZ4740_GPIO_CHIP(_bank) { \ |
396 | .irq_base = JZ4740_IRQ_GPIO_BASE_ ## _bank, \ | |
397 | .gpio_chip = { \ | |
398 | .label = "Bank " # _bank, \ | |
399 | .owner = THIS_MODULE, \ | |
400 | .set = jz_gpio_set_value, \ | |
401 | .get = jz_gpio_get_value, \ | |
402 | .direction_output = jz_gpio_direction_output, \ | |
403 | .direction_input = jz_gpio_direction_input, \ | |
832f5dac | 404 | .to_irq = jz_gpio_to_irq, \ |
a55f4506 LPC |
405 | .base = JZ4740_GPIO_BASE_ ## _bank, \ |
406 | .ngpio = JZ4740_GPIO_NUM_ ## _bank, \ | |
407 | }, \ | |
a55f4506 LPC |
408 | } |
409 | ||
410 | static struct jz_gpio_chip jz4740_gpio_chips[] = { | |
411 | JZ4740_GPIO_CHIP(A), | |
412 | JZ4740_GPIO_CHIP(B), | |
413 | JZ4740_GPIO_CHIP(C), | |
414 | JZ4740_GPIO_CHIP(D), | |
415 | }; | |
416 | ||
83bc7692 | 417 | static void jz4740_gpio_chip_init(struct jz_gpio_chip *chip, unsigned int id) |
a55f4506 | 418 | { |
83bc7692 LPC |
419 | struct irq_chip_generic *gc; |
420 | struct irq_chip_type *ct; | |
a55f4506 | 421 | |
83bc7692 | 422 | chip->base = ioremap(JZ4740_GPIO_BASE_ADDR + (id * 0x100), 0x100); |
a55f4506 | 423 | |
83bc7692 | 424 | chip->irq = JZ4740_IRQ_INTC_GPIO(id); |
f058dc80 TG |
425 | irq_set_chained_handler_and_data(chip->irq, |
426 | jz_gpio_irq_demux_handler, chip); | |
bd710009 | 427 | |
83bc7692 LPC |
428 | gc = irq_alloc_generic_chip(chip->gpio_chip.label, 1, chip->irq_base, |
429 | chip->base, handle_level_irq); | |
a55f4506 | 430 | |
83bc7692 LPC |
431 | gc->wake_enabled = IRQ_MSK(chip->gpio_chip.ngpio); |
432 | gc->private = chip; | |
a55f4506 | 433 | |
83bc7692 LPC |
434 | ct = gc->chip_types; |
435 | ct->regs.enable = JZ_REG_GPIO_MASK_CLEAR; | |
436 | ct->regs.disable = JZ_REG_GPIO_MASK_SET; | |
437 | ct->regs.ack = JZ_REG_GPIO_FLAG_CLEAR; | |
a55f4506 | 438 | |
83bc7692 LPC |
439 | ct->chip.name = "GPIO"; |
440 | ct->chip.irq_mask = irq_gc_mask_disable_reg; | |
441 | ct->chip.irq_unmask = jz_gpio_irq_unmask; | |
442 | ct->chip.irq_ack = irq_gc_ack_set_bit; | |
2da01884 PB |
443 | ct->chip.irq_suspend = ingenic_intc_irq_suspend; |
444 | ct->chip.irq_resume = ingenic_intc_irq_resume; | |
83bc7692 LPC |
445 | ct->chip.irq_startup = jz_gpio_irq_startup; |
446 | ct->chip.irq_shutdown = jz_gpio_irq_shutdown; | |
447 | ct->chip.irq_set_type = jz_gpio_irq_set_type; | |
448 | ct->chip.irq_set_wake = jz_gpio_irq_set_wake; | |
449 | ct->chip.flags = IRQCHIP_SET_TYPE_MASKED; | |
a55f4506 | 450 | |
83bc7692 LPC |
451 | irq_setup_generic_chip(gc, IRQ_MSK(chip->gpio_chip.ngpio), |
452 | IRQ_GC_INIT_NESTED_LOCK, 0, IRQ_NOPROBE | IRQ_LEVEL); | |
a55f4506 | 453 | |
f5abf9ee | 454 | gpiochip_add_data(&chip->gpio_chip, chip); |
a55f4506 LPC |
455 | } |
456 | ||
457 | static int __init jz4740_gpio_init(void) | |
458 | { | |
459 | unsigned int i; | |
a55f4506 LPC |
460 | |
461 | for (i = 0; i < ARRAY_SIZE(jz4740_gpio_chips); ++i) | |
462 | jz4740_gpio_chip_init(&jz4740_gpio_chips[i], i); | |
463 | ||
b595076a | 464 | printk(KERN_INFO "JZ4740 GPIO initialized\n"); |
a55f4506 LPC |
465 | |
466 | return 0; | |
467 | } | |
468 | arch_initcall(jz4740_gpio_init); | |
469 | ||
470 | #ifdef CONFIG_DEBUG_FS | |
471 | ||
472 | static inline void gpio_seq_reg(struct seq_file *s, struct jz_gpio_chip *chip, | |
473 | const char *name, unsigned int reg) | |
474 | { | |
475 | seq_printf(s, "\t%s: %08x\n", name, readl(chip->base + reg)); | |
476 | } | |
477 | ||
478 | static int gpio_regs_show(struct seq_file *s, void *unused) | |
479 | { | |
480 | struct jz_gpio_chip *chip = jz4740_gpio_chips; | |
481 | int i; | |
482 | ||
483 | for (i = 0; i < ARRAY_SIZE(jz4740_gpio_chips); ++i, ++chip) { | |
484 | seq_printf(s, "==GPIO %d==\n", i); | |
485 | gpio_seq_reg(s, chip, "Pin", JZ_REG_GPIO_PIN); | |
486 | gpio_seq_reg(s, chip, "Data", JZ_REG_GPIO_DATA); | |
487 | gpio_seq_reg(s, chip, "Mask", JZ_REG_GPIO_MASK); | |
488 | gpio_seq_reg(s, chip, "Pull", JZ_REG_GPIO_PULL); | |
489 | gpio_seq_reg(s, chip, "Func", JZ_REG_GPIO_FUNC); | |
490 | gpio_seq_reg(s, chip, "Select", JZ_REG_GPIO_SELECT); | |
491 | gpio_seq_reg(s, chip, "Direction", JZ_REG_GPIO_DIRECTION); | |
492 | gpio_seq_reg(s, chip, "Trigger", JZ_REG_GPIO_TRIGGER); | |
493 | gpio_seq_reg(s, chip, "Flag", JZ_REG_GPIO_FLAG); | |
494 | } | |
495 | ||
496 | return 0; | |
497 | } | |
498 | ||
499 | static int gpio_regs_open(struct inode *inode, struct file *file) | |
500 | { | |
501 | return single_open(file, gpio_regs_show, NULL); | |
502 | } | |
503 | ||
504 | static const struct file_operations gpio_regs_operations = { | |
505 | .open = gpio_regs_open, | |
506 | .read = seq_read, | |
507 | .llseek = seq_lseek, | |
508 | .release = single_release, | |
509 | }; | |
510 | ||
511 | static int __init gpio_debugfs_init(void) | |
512 | { | |
513 | (void) debugfs_create_file("jz_regs_gpio", S_IFREG | S_IRUGO, | |
514 | NULL, NULL, &gpio_regs_operations); | |
515 | return 0; | |
516 | } | |
517 | subsys_initcall(gpio_debugfs_init); | |
518 | ||
519 | #endif |