GNU Linux-libre 5.19-rc6-gnu
[releases.git] / drivers / gpio / gpio-msc313.c
1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (C) 2020 Daniel Palmer<daniel@thingy.jp> */
3
4 #include <linux/bitops.h>
5 #include <linux/kernel.h>
6 #include <linux/types.h>
7 #include <linux/io.h>
8 #include <linux/of.h>
9 #include <linux/of_device.h>
10 #include <linux/of_irq.h>
11 #include <linux/gpio/driver.h>
12 #include <linux/module.h>
13 #include <linux/platform_device.h>
14
15 #include <dt-bindings/gpio/msc313-gpio.h>
16 #include <dt-bindings/interrupt-controller/arm-gic.h>
17
18 #define DRIVER_NAME "gpio-msc313"
19
20 #define MSC313_GPIO_IN  BIT(0)
21 #define MSC313_GPIO_OUT BIT(4)
22 #define MSC313_GPIO_OEN BIT(5)
23
24 /*
25  * These bits need to be saved to correctly restore the
26  * gpio state when resuming from suspend to memory.
27  */
28 #define MSC313_GPIO_BITSTOSAVE (MSC313_GPIO_OUT | MSC313_GPIO_OEN)
29
30 /* pad names for fuart, same for all SoCs so far */
31 #define MSC313_PINNAME_FUART_RX         "fuart_rx"
32 #define MSC313_PINNAME_FUART_TX         "fuart_tx"
33 #define MSC313_PINNAME_FUART_CTS        "fuart_cts"
34 #define MSC313_PINNAME_FUART_RTS        "fuart_rts"
35
36 /* pad names for sr, mercury5 is different */
37 #define MSC313_PINNAME_SR_IO2           "sr_io2"
38 #define MSC313_PINNAME_SR_IO3           "sr_io3"
39 #define MSC313_PINNAME_SR_IO4           "sr_io4"
40 #define MSC313_PINNAME_SR_IO5           "sr_io5"
41 #define MSC313_PINNAME_SR_IO6           "sr_io6"
42 #define MSC313_PINNAME_SR_IO7           "sr_io7"
43 #define MSC313_PINNAME_SR_IO8           "sr_io8"
44 #define MSC313_PINNAME_SR_IO9           "sr_io9"
45 #define MSC313_PINNAME_SR_IO10          "sr_io10"
46 #define MSC313_PINNAME_SR_IO11          "sr_io11"
47 #define MSC313_PINNAME_SR_IO12          "sr_io12"
48 #define MSC313_PINNAME_SR_IO13          "sr_io13"
49 #define MSC313_PINNAME_SR_IO14          "sr_io14"
50 #define MSC313_PINNAME_SR_IO15          "sr_io15"
51 #define MSC313_PINNAME_SR_IO16          "sr_io16"
52 #define MSC313_PINNAME_SR_IO17          "sr_io17"
53
54 /* pad names for sd, same for all SoCs so far */
55 #define MSC313_PINNAME_SD_CLK           "sd_clk"
56 #define MSC313_PINNAME_SD_CMD           "sd_cmd"
57 #define MSC313_PINNAME_SD_D0            "sd_d0"
58 #define MSC313_PINNAME_SD_D1            "sd_d1"
59 #define MSC313_PINNAME_SD_D2            "sd_d2"
60 #define MSC313_PINNAME_SD_D3            "sd_d3"
61
62 /* pad names for i2c1, same for all SoCs so for */
63 #define MSC313_PINNAME_I2C1_SCL         "i2c1_scl"
64 #define MSC313_PINNAME_I2C1_SCA         "i2c1_sda"
65
66 /* pad names for spi0, same for all SoCs so far */
67 #define MSC313_PINNAME_SPI0_CZ          "spi0_cz"
68 #define MSC313_PINNAME_SPI0_CK          "spi0_ck"
69 #define MSC313_PINNAME_SPI0_DI          "spi0_di"
70 #define MSC313_PINNAME_SPI0_DO          "spi0_do"
71
72 #define FUART_NAMES                     \
73         MSC313_PINNAME_FUART_RX,        \
74         MSC313_PINNAME_FUART_TX,        \
75         MSC313_PINNAME_FUART_CTS,       \
76         MSC313_PINNAME_FUART_RTS
77
78 #define OFF_FUART_RX    0x50
79 #define OFF_FUART_TX    0x54
80 #define OFF_FUART_CTS   0x58
81 #define OFF_FUART_RTS   0x5c
82
83 #define FUART_OFFSETS   \
84         OFF_FUART_RX,   \
85         OFF_FUART_TX,   \
86         OFF_FUART_CTS,  \
87         OFF_FUART_RTS
88
89 #define SR_NAMES                \
90         MSC313_PINNAME_SR_IO2,  \
91         MSC313_PINNAME_SR_IO3,  \
92         MSC313_PINNAME_SR_IO4,  \
93         MSC313_PINNAME_SR_IO5,  \
94         MSC313_PINNAME_SR_IO6,  \
95         MSC313_PINNAME_SR_IO7,  \
96         MSC313_PINNAME_SR_IO8,  \
97         MSC313_PINNAME_SR_IO9,  \
98         MSC313_PINNAME_SR_IO10, \
99         MSC313_PINNAME_SR_IO11, \
100         MSC313_PINNAME_SR_IO12, \
101         MSC313_PINNAME_SR_IO13, \
102         MSC313_PINNAME_SR_IO14, \
103         MSC313_PINNAME_SR_IO15, \
104         MSC313_PINNAME_SR_IO16, \
105         MSC313_PINNAME_SR_IO17
106
107 #define OFF_SR_IO2      0x88
108 #define OFF_SR_IO3      0x8c
109 #define OFF_SR_IO4      0x90
110 #define OFF_SR_IO5      0x94
111 #define OFF_SR_IO6      0x98
112 #define OFF_SR_IO7      0x9c
113 #define OFF_SR_IO8      0xa0
114 #define OFF_SR_IO9      0xa4
115 #define OFF_SR_IO10     0xa8
116 #define OFF_SR_IO11     0xac
117 #define OFF_SR_IO12     0xb0
118 #define OFF_SR_IO13     0xb4
119 #define OFF_SR_IO14     0xb8
120 #define OFF_SR_IO15     0xbc
121 #define OFF_SR_IO16     0xc0
122 #define OFF_SR_IO17     0xc4
123
124 #define SR_OFFSETS      \
125         OFF_SR_IO2,     \
126         OFF_SR_IO3,     \
127         OFF_SR_IO4,     \
128         OFF_SR_IO5,     \
129         OFF_SR_IO6,     \
130         OFF_SR_IO7,     \
131         OFF_SR_IO8,     \
132         OFF_SR_IO9,     \
133         OFF_SR_IO10,    \
134         OFF_SR_IO11,    \
135         OFF_SR_IO12,    \
136         OFF_SR_IO13,    \
137         OFF_SR_IO14,    \
138         OFF_SR_IO15,    \
139         OFF_SR_IO16,    \
140         OFF_SR_IO17
141
142 #define SD_NAMES                \
143         MSC313_PINNAME_SD_CLK,  \
144         MSC313_PINNAME_SD_CMD,  \
145         MSC313_PINNAME_SD_D0,   \
146         MSC313_PINNAME_SD_D1,   \
147         MSC313_PINNAME_SD_D2,   \
148         MSC313_PINNAME_SD_D3
149
150 #define OFF_SD_CLK      0x140
151 #define OFF_SD_CMD      0x144
152 #define OFF_SD_D0       0x148
153 #define OFF_SD_D1       0x14c
154 #define OFF_SD_D2       0x150
155 #define OFF_SD_D3       0x154
156
157 #define SD_OFFSETS      \
158         OFF_SD_CLK,     \
159         OFF_SD_CMD,     \
160         OFF_SD_D0,      \
161         OFF_SD_D1,      \
162         OFF_SD_D2,      \
163         OFF_SD_D3
164
165 #define I2C1_NAMES                      \
166         MSC313_PINNAME_I2C1_SCL,        \
167         MSC313_PINNAME_I2C1_SCA
168
169 #define OFF_I2C1_SCL    0x188
170 #define OFF_I2C1_SCA    0x18c
171
172 #define I2C1_OFFSETS    \
173         OFF_I2C1_SCL,   \
174         OFF_I2C1_SCA
175
176 #define SPI0_NAMES              \
177         MSC313_PINNAME_SPI0_CZ, \
178         MSC313_PINNAME_SPI0_CK, \
179         MSC313_PINNAME_SPI0_DI, \
180         MSC313_PINNAME_SPI0_DO
181
182 #define OFF_SPI0_CZ     0x1c0
183 #define OFF_SPI0_CK     0x1c4
184 #define OFF_SPI0_DI     0x1c8
185 #define OFF_SPI0_DO     0x1cc
186
187 #define SPI0_OFFSETS    \
188         OFF_SPI0_CZ,    \
189         OFF_SPI0_CK,    \
190         OFF_SPI0_DI,    \
191         OFF_SPI0_DO
192
193 struct msc313_gpio_data {
194         const char * const *names;
195         const unsigned int *offsets;
196         const unsigned int num;
197 };
198
199 #define MSC313_GPIO_CHIPDATA(_chip) \
200 static const struct msc313_gpio_data _chip##_data = { \
201         .names = _chip##_names, \
202         .offsets = _chip##_offsets, \
203         .num = ARRAY_SIZE(_chip##_offsets), \
204 }
205
206 #ifdef CONFIG_MACH_INFINITY
207 static const char * const msc313_names[] = {
208         FUART_NAMES,
209         SR_NAMES,
210         SD_NAMES,
211         I2C1_NAMES,
212         SPI0_NAMES,
213 };
214
215 static const unsigned int msc313_offsets[] = {
216         FUART_OFFSETS,
217         SR_OFFSETS,
218         SD_OFFSETS,
219         I2C1_OFFSETS,
220         SPI0_OFFSETS,
221 };
222
223 MSC313_GPIO_CHIPDATA(msc313);
224
225 /*
226  * Unlike the msc313(e) the ssd20xd have a bunch of pins
227  * that are actually called gpio probably because they
228  * have no dedicated function.
229  */
230 #define SSD20XD_PINNAME_GPIO0           "gpio0"
231 #define SSD20XD_PINNAME_GPIO1           "gpio1"
232 #define SSD20XD_PINNAME_GPIO2           "gpio2"
233 #define SSD20XD_PINNAME_GPIO3           "gpio3"
234 #define SSD20XD_PINNAME_GPIO4           "gpio4"
235 #define SSD20XD_PINNAME_GPIO5           "gpio5"
236 #define SSD20XD_PINNAME_GPIO6           "gpio6"
237 #define SSD20XD_PINNAME_GPIO7           "gpio7"
238 #define SSD20XD_PINNAME_GPIO10          "gpio10"
239 #define SSD20XD_PINNAME_GPIO11          "gpio11"
240 #define SSD20XD_PINNAME_GPIO12          "gpio12"
241 #define SSD20XD_PINNAME_GPIO13          "gpio13"
242 #define SSD20XD_PINNAME_GPIO14          "gpio14"
243 #define SSD20XD_PINNAME_GPIO85          "gpio85"
244 #define SSD20XD_PINNAME_GPIO86          "gpio86"
245 #define SSD20XD_PINNAME_GPIO90          "gpio90"
246
247 #define SSD20XD_GPIO_NAMES SSD20XD_PINNAME_GPIO0,  \
248                            SSD20XD_PINNAME_GPIO1,  \
249                            SSD20XD_PINNAME_GPIO2,  \
250                            SSD20XD_PINNAME_GPIO3,  \
251                            SSD20XD_PINNAME_GPIO4,  \
252                            SSD20XD_PINNAME_GPIO5,  \
253                            SSD20XD_PINNAME_GPIO6,  \
254                            SSD20XD_PINNAME_GPIO7,  \
255                            SSD20XD_PINNAME_GPIO10, \
256                            SSD20XD_PINNAME_GPIO11, \
257                            SSD20XD_PINNAME_GPIO12, \
258                            SSD20XD_PINNAME_GPIO13, \
259                            SSD20XD_PINNAME_GPIO14, \
260                            SSD20XD_PINNAME_GPIO85, \
261                            SSD20XD_PINNAME_GPIO86, \
262                            SSD20XD_PINNAME_GPIO90
263
264 #define SSD20XD_GPIO_OFF_GPIO0 0x0
265 #define SSD20XD_GPIO_OFF_GPIO1 0x4
266 #define SSD20XD_GPIO_OFF_GPIO2 0x8
267 #define SSD20XD_GPIO_OFF_GPIO3 0xc
268 #define SSD20XD_GPIO_OFF_GPIO4 0x10
269 #define SSD20XD_GPIO_OFF_GPIO5 0x14
270 #define SSD20XD_GPIO_OFF_GPIO6 0x18
271 #define SSD20XD_GPIO_OFF_GPIO7 0x1c
272 #define SSD20XD_GPIO_OFF_GPIO10 0x28
273 #define SSD20XD_GPIO_OFF_GPIO11 0x2c
274 #define SSD20XD_GPIO_OFF_GPIO12 0x30
275 #define SSD20XD_GPIO_OFF_GPIO13 0x34
276 #define SSD20XD_GPIO_OFF_GPIO14 0x38
277 #define SSD20XD_GPIO_OFF_GPIO85 0x100
278 #define SSD20XD_GPIO_OFF_GPIO86 0x104
279 #define SSD20XD_GPIO_OFF_GPIO90 0x114
280
281 #define SSD20XD_GPIO_OFFSETS SSD20XD_GPIO_OFF_GPIO0,  \
282                              SSD20XD_GPIO_OFF_GPIO1,  \
283                              SSD20XD_GPIO_OFF_GPIO2,  \
284                              SSD20XD_GPIO_OFF_GPIO3,  \
285                              SSD20XD_GPIO_OFF_GPIO4,  \
286                              SSD20XD_GPIO_OFF_GPIO5,  \
287                              SSD20XD_GPIO_OFF_GPIO6,  \
288                              SSD20XD_GPIO_OFF_GPIO7,  \
289                              SSD20XD_GPIO_OFF_GPIO10, \
290                              SSD20XD_GPIO_OFF_GPIO11, \
291                              SSD20XD_GPIO_OFF_GPIO12, \
292                              SSD20XD_GPIO_OFF_GPIO13, \
293                              SSD20XD_GPIO_OFF_GPIO14, \
294                              SSD20XD_GPIO_OFF_GPIO85, \
295                              SSD20XD_GPIO_OFF_GPIO86, \
296                              SSD20XD_GPIO_OFF_GPIO90
297
298 /* "ttl" pins lcd interface pins */
299 #define SSD20XD_PINNAME_TTL0    "ttl0"
300 #define SSD20XD_PINNAME_TTL1    "ttl1"
301 #define SSD20XD_PINNAME_TTL2    "ttl2"
302 #define SSD20XD_PINNAME_TTL3    "ttl3"
303 #define SSD20XD_PINNAME_TTL4    "ttl4"
304 #define SSD20XD_PINNAME_TTL5    "ttl5"
305 #define SSD20XD_PINNAME_TTL6    "ttl6"
306 #define SSD20XD_PINNAME_TTL7    "ttl7"
307 #define SSD20XD_PINNAME_TTL8    "ttl8"
308 #define SSD20XD_PINNAME_TTL9    "ttl9"
309 #define SSD20XD_PINNAME_TTL10   "ttl10"
310 #define SSD20XD_PINNAME_TTL11   "ttl11"
311 #define SSD20XD_PINNAME_TTL12   "ttl12"
312 #define SSD20XD_PINNAME_TTL13   "ttl13"
313 #define SSD20XD_PINNAME_TTL14   "ttl14"
314 #define SSD20XD_PINNAME_TTL15   "ttl15"
315 #define SSD20XD_PINNAME_TTL16   "ttl16"
316 #define SSD20XD_PINNAME_TTL17   "ttl17"
317 #define SSD20XD_PINNAME_TTL18   "ttl18"
318 #define SSD20XD_PINNAME_TTL19   "ttl19"
319 #define SSD20XD_PINNAME_TTL20   "ttl20"
320 #define SSD20XD_PINNAME_TTL21   "ttl21"
321 #define SSD20XD_PINNAME_TTL22   "ttl22"
322 #define SSD20XD_PINNAME_TTL23   "ttl23"
323 #define SSD20XD_PINNAME_TTL24   "ttl24"
324 #define SSD20XD_PINNAME_TTL25   "ttl25"
325 #define SSD20XD_PINNAME_TTL26   "ttl26"
326 #define SSD20XD_PINNAME_TTL27   "ttl27"
327
328 #define SSD20XD_TTL_PINNAMES SSD20XD_PINNAME_TTL0,  \
329                              SSD20XD_PINNAME_TTL1,  \
330                              SSD20XD_PINNAME_TTL2,  \
331                              SSD20XD_PINNAME_TTL3,  \
332                              SSD20XD_PINNAME_TTL4,  \
333                              SSD20XD_PINNAME_TTL5,  \
334                              SSD20XD_PINNAME_TTL6,  \
335                              SSD20XD_PINNAME_TTL7,  \
336                              SSD20XD_PINNAME_TTL8,  \
337                              SSD20XD_PINNAME_TTL9,  \
338                              SSD20XD_PINNAME_TTL10, \
339                              SSD20XD_PINNAME_TTL11, \
340                              SSD20XD_PINNAME_TTL12, \
341                              SSD20XD_PINNAME_TTL13, \
342                              SSD20XD_PINNAME_TTL14, \
343                              SSD20XD_PINNAME_TTL15, \
344                              SSD20XD_PINNAME_TTL16, \
345                              SSD20XD_PINNAME_TTL17, \
346                              SSD20XD_PINNAME_TTL18, \
347                              SSD20XD_PINNAME_TTL19, \
348                              SSD20XD_PINNAME_TTL20, \
349                              SSD20XD_PINNAME_TTL21, \
350                              SSD20XD_PINNAME_TTL22, \
351                              SSD20XD_PINNAME_TTL23, \
352                              SSD20XD_PINNAME_TTL24, \
353                              SSD20XD_PINNAME_TTL25, \
354                              SSD20XD_PINNAME_TTL26, \
355                              SSD20XD_PINNAME_TTL27
356
357 #define SSD20XD_TTL_OFFSET_TTL0         0x80
358 #define SSD20XD_TTL_OFFSET_TTL1         0x84
359 #define SSD20XD_TTL_OFFSET_TTL2         0x88
360 #define SSD20XD_TTL_OFFSET_TTL3         0x8c
361 #define SSD20XD_TTL_OFFSET_TTL4         0x90
362 #define SSD20XD_TTL_OFFSET_TTL5         0x94
363 #define SSD20XD_TTL_OFFSET_TTL6         0x98
364 #define SSD20XD_TTL_OFFSET_TTL7         0x9c
365 #define SSD20XD_TTL_OFFSET_TTL8         0xa0
366 #define SSD20XD_TTL_OFFSET_TTL9         0xa4
367 #define SSD20XD_TTL_OFFSET_TTL10        0xa8
368 #define SSD20XD_TTL_OFFSET_TTL11        0xac
369 #define SSD20XD_TTL_OFFSET_TTL12        0xb0
370 #define SSD20XD_TTL_OFFSET_TTL13        0xb4
371 #define SSD20XD_TTL_OFFSET_TTL14        0xb8
372 #define SSD20XD_TTL_OFFSET_TTL15        0xbc
373 #define SSD20XD_TTL_OFFSET_TTL16        0xc0
374 #define SSD20XD_TTL_OFFSET_TTL17        0xc4
375 #define SSD20XD_TTL_OFFSET_TTL18        0xc8
376 #define SSD20XD_TTL_OFFSET_TTL19        0xcc
377 #define SSD20XD_TTL_OFFSET_TTL20        0xd0
378 #define SSD20XD_TTL_OFFSET_TTL21        0xd4
379 #define SSD20XD_TTL_OFFSET_TTL22        0xd8
380 #define SSD20XD_TTL_OFFSET_TTL23        0xdc
381 #define SSD20XD_TTL_OFFSET_TTL24        0xe0
382 #define SSD20XD_TTL_OFFSET_TTL25        0xe4
383 #define SSD20XD_TTL_OFFSET_TTL26        0xe8
384 #define SSD20XD_TTL_OFFSET_TTL27        0xec
385
386 #define SSD20XD_TTL_OFFSETS SSD20XD_TTL_OFFSET_TTL0,  \
387                             SSD20XD_TTL_OFFSET_TTL1,  \
388                             SSD20XD_TTL_OFFSET_TTL2,  \
389                             SSD20XD_TTL_OFFSET_TTL3,  \
390                             SSD20XD_TTL_OFFSET_TTL4,  \
391                             SSD20XD_TTL_OFFSET_TTL5,  \
392                             SSD20XD_TTL_OFFSET_TTL6,  \
393                             SSD20XD_TTL_OFFSET_TTL7,  \
394                             SSD20XD_TTL_OFFSET_TTL8,  \
395                             SSD20XD_TTL_OFFSET_TTL9,  \
396                             SSD20XD_TTL_OFFSET_TTL10, \
397                             SSD20XD_TTL_OFFSET_TTL11, \
398                             SSD20XD_TTL_OFFSET_TTL12, \
399                             SSD20XD_TTL_OFFSET_TTL13, \
400                             SSD20XD_TTL_OFFSET_TTL14, \
401                             SSD20XD_TTL_OFFSET_TTL15, \
402                             SSD20XD_TTL_OFFSET_TTL16, \
403                             SSD20XD_TTL_OFFSET_TTL17, \
404                             SSD20XD_TTL_OFFSET_TTL18, \
405                             SSD20XD_TTL_OFFSET_TTL19, \
406                             SSD20XD_TTL_OFFSET_TTL20, \
407                             SSD20XD_TTL_OFFSET_TTL21, \
408                             SSD20XD_TTL_OFFSET_TTL22, \
409                             SSD20XD_TTL_OFFSET_TTL23, \
410                             SSD20XD_TTL_OFFSET_TTL24, \
411                             SSD20XD_TTL_OFFSET_TTL25, \
412                             SSD20XD_TTL_OFFSET_TTL26, \
413                             SSD20XD_TTL_OFFSET_TTL27
414
415 /* On the ssd20xd the two normal uarts have dedicated pins */
416 #define SSD20XD_PINNAME_UART0_RX        "uart0_rx"
417 #define SSD20XD_PINNAME_UART0_TX        "uart0_tx"
418
419 #define SSD20XD_UART0_NAMES       \
420         SSD20XD_PINNAME_UART0_RX, \
421         SSD20XD_PINNAME_UART0_TX
422
423 #define SSD20XD_PINNAME_UART1_RX        "uart1_rx"
424 #define SSD20XD_PINNAME_UART1_TX        "uart1_tx"
425
426 #define SSD20XD_UART1_NAMES       \
427         SSD20XD_PINNAME_UART1_RX, \
428         SSD20XD_PINNAME_UART1_TX
429
430 #define SSD20XD_OFF_UART0_RX    0x60
431 #define SSD20XD_OFF_UART0_TX    0x64
432
433 #define SSD20XD_UART0_OFFSETS \
434         SSD20XD_OFF_UART0_RX, \
435         SSD20XD_OFF_UART0_TX
436
437 #define SSD20XD_OFF_UART1_RX    0x68
438 #define SSD20XD_OFF_UART1_TX    0x6c
439
440 #define SSD20XD_UART1_OFFSETS \
441         SSD20XD_OFF_UART1_RX, \
442         SSD20XD_OFF_UART1_TX
443
444 /*
445  * ssd20x has the same pin names but different ordering
446  * of the registers that control the gpio.
447  */
448 #define SSD20XD_OFF_SD_D0       0x140
449 #define SSD20XD_OFF_SD_D1       0x144
450 #define SSD20XD_OFF_SD_D2       0x148
451 #define SSD20XD_OFF_SD_D3       0x14c
452 #define SSD20XD_OFF_SD_CMD      0x150
453 #define SSD20XD_OFF_SD_CLK      0x154
454
455 #define SSD20XD_SD_OFFSETS      SSD20XD_OFF_SD_CLK, \
456                                 SSD20XD_OFF_SD_CMD, \
457                                 SSD20XD_OFF_SD_D0,  \
458                                 SSD20XD_OFF_SD_D1,  \
459                                 SSD20XD_OFF_SD_D2,  \
460                                 SSD20XD_OFF_SD_D3
461
462 static const char * const ssd20xd_names[] = {
463         FUART_NAMES,
464         SD_NAMES,
465         SSD20XD_UART0_NAMES,
466         SSD20XD_UART1_NAMES,
467         SSD20XD_TTL_PINNAMES,
468         SSD20XD_GPIO_NAMES,
469 };
470
471 static const unsigned int ssd20xd_offsets[] = {
472         FUART_OFFSETS,
473         SSD20XD_SD_OFFSETS,
474         SSD20XD_UART0_OFFSETS,
475         SSD20XD_UART1_OFFSETS,
476         SSD20XD_TTL_OFFSETS,
477         SSD20XD_GPIO_OFFSETS,
478 };
479
480 MSC313_GPIO_CHIPDATA(ssd20xd);
481 #endif
482
483 struct msc313_gpio {
484         void __iomem *base;
485         const struct msc313_gpio_data *gpio_data;
486         u8 *saved;
487 };
488
489 static void msc313_gpio_set(struct gpio_chip *chip, unsigned int offset, int value)
490 {
491         struct msc313_gpio *gpio = gpiochip_get_data(chip);
492         u8 gpioreg = readb_relaxed(gpio->base + gpio->gpio_data->offsets[offset]);
493
494         if (value)
495                 gpioreg |= MSC313_GPIO_OUT;
496         else
497                 gpioreg &= ~MSC313_GPIO_OUT;
498
499         writeb_relaxed(gpioreg, gpio->base + gpio->gpio_data->offsets[offset]);
500 }
501
502 static int msc313_gpio_get(struct gpio_chip *chip, unsigned int offset)
503 {
504         struct msc313_gpio *gpio = gpiochip_get_data(chip);
505
506         return readb_relaxed(gpio->base + gpio->gpio_data->offsets[offset]) & MSC313_GPIO_IN;
507 }
508
509 static int msc313_gpio_direction_input(struct gpio_chip *chip, unsigned int offset)
510 {
511         struct msc313_gpio *gpio = gpiochip_get_data(chip);
512         u8 gpioreg = readb_relaxed(gpio->base + gpio->gpio_data->offsets[offset]);
513
514         gpioreg |= MSC313_GPIO_OEN;
515         writeb_relaxed(gpioreg, gpio->base + gpio->gpio_data->offsets[offset]);
516
517         return 0;
518 }
519
520 static int msc313_gpio_direction_output(struct gpio_chip *chip, unsigned int offset, int value)
521 {
522         struct msc313_gpio *gpio = gpiochip_get_data(chip);
523         u8 gpioreg = readb_relaxed(gpio->base + gpio->gpio_data->offsets[offset]);
524
525         gpioreg &= ~MSC313_GPIO_OEN;
526         if (value)
527                 gpioreg |= MSC313_GPIO_OUT;
528         else
529                 gpioreg &= ~MSC313_GPIO_OUT;
530         writeb_relaxed(gpioreg, gpio->base + gpio->gpio_data->offsets[offset]);
531
532         return 0;
533 }
534
535 /*
536  * The interrupt handling happens in the parent interrupt controller,
537  * we don't do anything here.
538  */
539 static struct irq_chip msc313_gpio_irqchip = {
540         .name = "GPIO",
541         .irq_eoi = irq_chip_eoi_parent,
542         .irq_mask = irq_chip_mask_parent,
543         .irq_unmask = irq_chip_unmask_parent,
544         .irq_set_type = irq_chip_set_type_parent,
545         .irq_set_affinity = irq_chip_set_affinity_parent,
546 };
547
548 /*
549  * The parent interrupt controller needs the GIC interrupt type set to GIC_SPI
550  * so we need to provide the fwspec. Essentially gpiochip_populate_parent_fwspec_twocell
551  * that puts GIC_SPI into the first cell.
552  */
553 static void *msc313_gpio_populate_parent_fwspec(struct gpio_chip *gc,
554                                              unsigned int parent_hwirq,
555                                              unsigned int parent_type)
556 {
557         struct irq_fwspec *fwspec;
558
559         fwspec = kmalloc(sizeof(*fwspec), GFP_KERNEL);
560         if (!fwspec)
561                 return NULL;
562
563         fwspec->fwnode = gc->irq.parent_domain->fwnode;
564         fwspec->param_count = 3;
565         fwspec->param[0] = GIC_SPI;
566         fwspec->param[1] = parent_hwirq;
567         fwspec->param[2] = parent_type;
568
569         return fwspec;
570 }
571
572 static int msc313e_gpio_child_to_parent_hwirq(struct gpio_chip *chip,
573                                              unsigned int child,
574                                              unsigned int child_type,
575                                              unsigned int *parent,
576                                              unsigned int *parent_type)
577 {
578         struct msc313_gpio *priv = gpiochip_get_data(chip);
579         unsigned int offset = priv->gpio_data->offsets[child];
580
581         /*
582          * only the spi0 pins have interrupts on the parent
583          * on all of the known chips and so far they are all
584          * mapped to the same place
585          */
586         if (offset >= OFF_SPI0_CZ && offset <= OFF_SPI0_DO) {
587                 *parent_type = child_type;
588                 *parent = ((offset - OFF_SPI0_CZ) >> 2) + 28;
589                 return 0;
590         }
591
592         return -EINVAL;
593 }
594
595 static int msc313_gpio_probe(struct platform_device *pdev)
596 {
597         const struct msc313_gpio_data *match_data;
598         struct msc313_gpio *gpio;
599         struct gpio_chip *gpiochip;
600         struct gpio_irq_chip *gpioirqchip;
601         struct irq_domain *parent_domain;
602         struct device_node *parent_node;
603         struct device *dev = &pdev->dev;
604
605         match_data = of_device_get_match_data(dev);
606         if (!match_data)
607                 return -EINVAL;
608
609         parent_node = of_irq_find_parent(dev->of_node);
610         if (!parent_node)
611                 return -ENODEV;
612
613         parent_domain = irq_find_host(parent_node);
614         if (!parent_domain)
615                 return -ENODEV;
616
617         gpio = devm_kzalloc(dev, sizeof(*gpio), GFP_KERNEL);
618         if (!gpio)
619                 return -ENOMEM;
620
621         gpio->gpio_data = match_data;
622
623         gpio->saved = devm_kcalloc(dev, gpio->gpio_data->num, sizeof(*gpio->saved), GFP_KERNEL);
624         if (!gpio->saved)
625                 return -ENOMEM;
626
627         gpio->base = devm_platform_ioremap_resource(pdev, 0);
628         if (IS_ERR(gpio->base))
629                 return PTR_ERR(gpio->base);
630
631         platform_set_drvdata(pdev, gpio);
632
633         gpiochip = devm_kzalloc(dev, sizeof(*gpiochip), GFP_KERNEL);
634         if (!gpiochip)
635                 return -ENOMEM;
636
637         gpiochip->label = DRIVER_NAME;
638         gpiochip->parent = dev;
639         gpiochip->request = gpiochip_generic_request;
640         gpiochip->free = gpiochip_generic_free;
641         gpiochip->direction_input = msc313_gpio_direction_input;
642         gpiochip->direction_output = msc313_gpio_direction_output;
643         gpiochip->get = msc313_gpio_get;
644         gpiochip->set = msc313_gpio_set;
645         gpiochip->base = -1;
646         gpiochip->ngpio = gpio->gpio_data->num;
647         gpiochip->names = gpio->gpio_data->names;
648
649         gpioirqchip = &gpiochip->irq;
650         gpioirqchip->chip = &msc313_gpio_irqchip;
651         gpioirqchip->fwnode = of_node_to_fwnode(dev->of_node);
652         gpioirqchip->parent_domain = parent_domain;
653         gpioirqchip->child_to_parent_hwirq = msc313e_gpio_child_to_parent_hwirq;
654         gpioirqchip->populate_parent_alloc_arg = msc313_gpio_populate_parent_fwspec;
655         gpioirqchip->handler = handle_bad_irq;
656         gpioirqchip->default_type = IRQ_TYPE_NONE;
657
658         return devm_gpiochip_add_data(dev, gpiochip, gpio);
659 }
660
661 static int msc313_gpio_remove(struct platform_device *pdev)
662 {
663         return 0;
664 }
665
666 static const struct of_device_id msc313_gpio_of_match[] = {
667 #ifdef CONFIG_MACH_INFINITY
668         {
669                 .compatible = "mstar,msc313-gpio",
670                 .data = &msc313_data,
671         },
672         {
673                 .compatible = "sstar,ssd20xd-gpio",
674                 .data = &ssd20xd_data,
675         },
676 #endif
677         { }
678 };
679
680 /*
681  * The GPIO controller loses the state of the registers when the
682  * SoC goes into suspend to memory mode so we need to save some
683  * of the register bits before suspending and put it back when resuming
684  */
685 static int __maybe_unused msc313_gpio_suspend(struct device *dev)
686 {
687         struct msc313_gpio *gpio = dev_get_drvdata(dev);
688         int i;
689
690         for (i = 0; i < gpio->gpio_data->num; i++)
691                 gpio->saved[i] = readb_relaxed(gpio->base + gpio->gpio_data->offsets[i]) & MSC313_GPIO_BITSTOSAVE;
692
693         return 0;
694 }
695
696 static int __maybe_unused msc313_gpio_resume(struct device *dev)
697 {
698         struct msc313_gpio *gpio = dev_get_drvdata(dev);
699         int i;
700
701         for (i = 0; i < gpio->gpio_data->num; i++)
702                 writeb_relaxed(gpio->saved[i], gpio->base + gpio->gpio_data->offsets[i]);
703
704         return 0;
705 }
706
707 static SIMPLE_DEV_PM_OPS(msc313_gpio_ops, msc313_gpio_suspend, msc313_gpio_resume);
708
709 static struct platform_driver msc313_gpio_driver = {
710         .driver = {
711                 .name = DRIVER_NAME,
712                 .of_match_table = msc313_gpio_of_match,
713                 .pm = &msc313_gpio_ops,
714         },
715         .probe = msc313_gpio_probe,
716         .remove = msc313_gpio_remove,
717 };
718 builtin_platform_driver(msc313_gpio_driver);