GNU Linux-libre 5.19-rc6-gnu
[releases.git] / drivers / gpio / gpio-ts5500.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Digital I/O driver for Technologic Systems TS-5500
4  *
5  * Copyright (c) 2012 Savoir-faire Linux Inc.
6  *      Vivien Didelot <vivien.didelot@savoirfairelinux.com>
7  *
8  * Technologic Systems platforms have pin blocks, exposing several Digital
9  * Input/Output lines (DIO). This driver aims to support single pin blocks.
10  * In that sense, the support is not limited to the TS-5500 blocks.
11  * Actually, the following platforms have DIO support:
12  *
13  * TS-5500:
14  *   Documentation: https://docs.embeddedts.com/TS-5500
15  *   Blocks: DIO1, DIO2 and LCD port.
16  *
17  * TS-5600:
18  *   Documentation: https://docs.embeddedts.com/TS-5600
19  *   Blocks: LCD port (identical to TS-5500 LCD).
20  */
21
22 #include <linux/bitops.h>
23 #include <linux/gpio/driver.h>
24 #include <linux/io.h>
25 #include <linux/module.h>
26 #include <linux/platform_device.h>
27 #include <linux/slab.h>
28
29 /* List of supported Technologic Systems platforms DIO blocks */
30 enum ts5500_blocks { TS5500_DIO1, TS5500_DIO2, TS5500_LCD, TS5600_LCD };
31
32 struct ts5500_priv {
33         const struct ts5500_dio *pinout;
34         struct gpio_chip gpio_chip;
35         spinlock_t lock;
36         bool strap;
37         u8 hwirq;
38 };
39
40 /*
41  * Hex 7D is used to control several blocks (e.g. DIO2 and LCD port).
42  * This flag ensures that the region has been requested by this driver.
43  */
44 static bool hex7d_reserved;
45
46 /*
47  * This structure is used to describe capabilities of DIO lines,
48  * such as available directions and connected interrupt (if any).
49  */
50 struct ts5500_dio {
51         const u8 value_addr;
52         const u8 value_mask;
53         const u8 control_addr;
54         const u8 control_mask;
55         const bool no_input;
56         const bool no_output;
57         const u8 irq;
58 };
59
60 #define TS5500_DIO_IN_OUT(vaddr, vbit, caddr, cbit)     \
61         {                                               \
62                 .value_addr = vaddr,                    \
63                 .value_mask = BIT(vbit),                \
64                 .control_addr = caddr,                  \
65                 .control_mask = BIT(cbit),              \
66         }
67
68 #define TS5500_DIO_IN(addr, bit)                \
69         {                                       \
70                 .value_addr = addr,             \
71                 .value_mask = BIT(bit),         \
72                 .no_output = true,              \
73         }
74
75 #define TS5500_DIO_IN_IRQ(addr, bit, _irq)      \
76         {                                       \
77                 .value_addr = addr,             \
78                 .value_mask = BIT(bit),         \
79                 .no_output = true,              \
80                 .irq = _irq,                    \
81         }
82
83 #define TS5500_DIO_OUT(addr, bit)               \
84         {                                       \
85                 .value_addr = addr,             \
86                 .value_mask = BIT(bit),         \
87                 .no_input = true,               \
88         }
89
90 /*
91  * Input/Output DIO lines are programmed in groups of 4. Their values are
92  * available through 4 consecutive bits in a value port, whereas the direction
93  * of these 4 lines is driven by only 1 bit in a control port.
94  */
95 #define TS5500_DIO_GROUP(vaddr, vbitfrom, caddr, cbit)          \
96         TS5500_DIO_IN_OUT(vaddr, vbitfrom + 0, caddr, cbit),    \
97         TS5500_DIO_IN_OUT(vaddr, vbitfrom + 1, caddr, cbit),    \
98         TS5500_DIO_IN_OUT(vaddr, vbitfrom + 2, caddr, cbit),    \
99         TS5500_DIO_IN_OUT(vaddr, vbitfrom + 3, caddr, cbit)
100
101 /*
102  * TS-5500 DIO1 block
103  *
104  *  value    control  dir    hw
105  *  addr bit addr bit in out irq name     pin offset
106  *
107  *  0x7b  0  0x7a  0  x   x      DIO1_0   1   0
108  *  0x7b  1  0x7a  0  x   x      DIO1_1   3   1
109  *  0x7b  2  0x7a  0  x   x      DIO1_2   5   2
110  *  0x7b  3  0x7a  0  x   x      DIO1_3   7   3
111  *  0x7b  4  0x7a  1  x   x      DIO1_4   9   4
112  *  0x7b  5  0x7a  1  x   x      DIO1_5   11  5
113  *  0x7b  6  0x7a  1  x   x      DIO1_6   13  6
114  *  0x7b  7  0x7a  1  x   x      DIO1_7   15  7
115  *  0x7c  0  0x7a  5  x   x      DIO1_8   4   8
116  *  0x7c  1  0x7a  5  x   x      DIO1_9   6   9
117  *  0x7c  2  0x7a  5  x   x      DIO1_10  8   10
118  *  0x7c  3  0x7a  5  x   x      DIO1_11  10  11
119  *  0x7c  4           x          DIO1_12  12  12
120  *  0x7c  5           x      7   DIO1_13  14  13
121  */
122 static const struct ts5500_dio ts5500_dio1[] = {
123         TS5500_DIO_GROUP(0x7b, 0, 0x7a, 0),
124         TS5500_DIO_GROUP(0x7b, 4, 0x7a, 1),
125         TS5500_DIO_GROUP(0x7c, 0, 0x7a, 5),
126         TS5500_DIO_IN(0x7c, 4),
127         TS5500_DIO_IN_IRQ(0x7c, 5, 7),
128 };
129
130 /*
131  * TS-5500 DIO2 block
132  *
133  *  value    control  dir    hw
134  *  addr bit addr bit in out irq name     pin offset
135  *
136  *  0x7e  0  0x7d  0  x   x      DIO2_0   1   0
137  *  0x7e  1  0x7d  0  x   x      DIO2_1   3   1
138  *  0x7e  2  0x7d  0  x   x      DIO2_2   5   2
139  *  0x7e  3  0x7d  0  x   x      DIO2_3   7   3
140  *  0x7e  4  0x7d  1  x   x      DIO2_4   9   4
141  *  0x7e  5  0x7d  1  x   x      DIO2_5   11  5
142  *  0x7e  6  0x7d  1  x   x      DIO2_6   13  6
143  *  0x7e  7  0x7d  1  x   x      DIO2_7   15  7
144  *  0x7f  0  0x7d  5  x   x      DIO2_8   4   8
145  *  0x7f  1  0x7d  5  x   x      DIO2_9   6   9
146  *  0x7f  2  0x7d  5  x   x      DIO2_10  8   10
147  *  0x7f  3  0x7d  5  x   x      DIO2_11  10  11
148  *  0x7f  4           x      6   DIO2_13  14  12
149  */
150 static const struct ts5500_dio ts5500_dio2[] = {
151         TS5500_DIO_GROUP(0x7e, 0, 0x7d, 0),
152         TS5500_DIO_GROUP(0x7e, 4, 0x7d, 1),
153         TS5500_DIO_GROUP(0x7f, 0, 0x7d, 5),
154         TS5500_DIO_IN_IRQ(0x7f, 4, 6),
155 };
156
157 /*
158  * TS-5500 LCD port used as DIO block
159  * TS-5600 LCD port is identical
160  *
161  *  value    control  dir    hw
162  *  addr bit addr bit in out irq name    pin offset
163  *
164  *  0x72  0  0x7d  2  x   x      LCD_0   8   0
165  *  0x72  1  0x7d  2  x   x      LCD_1   7   1
166  *  0x72  2  0x7d  2  x   x      LCD_2   10  2
167  *  0x72  3  0x7d  2  x   x      LCD_3   9   3
168  *  0x72  4  0x7d  3  x   x      LCD_4   12  4
169  *  0x72  5  0x7d  3  x   x      LCD_5   11  5
170  *  0x72  6  0x7d  3  x   x      LCD_6   14  6
171  *  0x72  7  0x7d  3  x   x      LCD_7   13  7
172  *  0x73  0               x      LCD_EN  5   8
173  *  0x73  6           x          LCD_WR  6   9
174  *  0x73  7           x      1   LCD_RS  3   10
175  */
176 static const struct ts5500_dio ts5500_lcd[] = {
177         TS5500_DIO_GROUP(0x72, 0, 0x7d, 2),
178         TS5500_DIO_GROUP(0x72, 4, 0x7d, 3),
179         TS5500_DIO_OUT(0x73, 0),
180         TS5500_DIO_IN(0x73, 6),
181         TS5500_DIO_IN_IRQ(0x73, 7, 1),
182 };
183
184 static inline void ts5500_set_mask(u8 mask, u8 addr)
185 {
186         u8 val = inb(addr);
187         val |= mask;
188         outb(val, addr);
189 }
190
191 static inline void ts5500_clear_mask(u8 mask, u8 addr)
192 {
193         u8 val = inb(addr);
194         val &= ~mask;
195         outb(val, addr);
196 }
197
198 static int ts5500_gpio_input(struct gpio_chip *chip, unsigned offset)
199 {
200         struct ts5500_priv *priv = gpiochip_get_data(chip);
201         const struct ts5500_dio line = priv->pinout[offset];
202         unsigned long flags;
203
204         if (line.no_input)
205                 return -ENXIO;
206
207         if (line.no_output)
208                 return 0;
209
210         spin_lock_irqsave(&priv->lock, flags);
211         ts5500_clear_mask(line.control_mask, line.control_addr);
212         spin_unlock_irqrestore(&priv->lock, flags);
213
214         return 0;
215 }
216
217 static int ts5500_gpio_get(struct gpio_chip *chip, unsigned offset)
218 {
219         struct ts5500_priv *priv = gpiochip_get_data(chip);
220         const struct ts5500_dio line = priv->pinout[offset];
221
222         return !!(inb(line.value_addr) & line.value_mask);
223 }
224
225 static int ts5500_gpio_output(struct gpio_chip *chip, unsigned offset, int val)
226 {
227         struct ts5500_priv *priv = gpiochip_get_data(chip);
228         const struct ts5500_dio line = priv->pinout[offset];
229         unsigned long flags;
230
231         if (line.no_output)
232                 return -ENXIO;
233
234         spin_lock_irqsave(&priv->lock, flags);
235         if (!line.no_input)
236                 ts5500_set_mask(line.control_mask, line.control_addr);
237
238         if (val)
239                 ts5500_set_mask(line.value_mask, line.value_addr);
240         else
241                 ts5500_clear_mask(line.value_mask, line.value_addr);
242         spin_unlock_irqrestore(&priv->lock, flags);
243
244         return 0;
245 }
246
247 static void ts5500_gpio_set(struct gpio_chip *chip, unsigned offset, int val)
248 {
249         struct ts5500_priv *priv = gpiochip_get_data(chip);
250         const struct ts5500_dio line = priv->pinout[offset];
251         unsigned long flags;
252
253         spin_lock_irqsave(&priv->lock, flags);
254         if (val)
255                 ts5500_set_mask(line.value_mask, line.value_addr);
256         else
257                 ts5500_clear_mask(line.value_mask, line.value_addr);
258         spin_unlock_irqrestore(&priv->lock, flags);
259 }
260
261 static int ts5500_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
262 {
263         struct ts5500_priv *priv = gpiochip_get_data(chip);
264         const struct ts5500_dio *block = priv->pinout;
265         const struct ts5500_dio line = block[offset];
266
267         /* Only one pin is connected to an interrupt */
268         if (line.irq)
269                 return line.irq;
270
271         /* As this pin is input-only, we may strap it to another in/out pin */
272         if (priv->strap)
273                 return priv->hwirq;
274
275         return -ENXIO;
276 }
277
278 static int ts5500_enable_irq(struct ts5500_priv *priv)
279 {
280         int ret = 0;
281         unsigned long flags;
282
283         spin_lock_irqsave(&priv->lock, flags);
284         if (priv->hwirq == 7)
285                 ts5500_set_mask(BIT(7), 0x7a); /* DIO1_13 on IRQ7 */
286         else if (priv->hwirq == 6)
287                 ts5500_set_mask(BIT(7), 0x7d); /* DIO2_13 on IRQ6 */
288         else if (priv->hwirq == 1)
289                 ts5500_set_mask(BIT(6), 0x7d); /* LCD_RS on IRQ1 */
290         else
291                 ret = -EINVAL;
292         spin_unlock_irqrestore(&priv->lock, flags);
293
294         return ret;
295 }
296
297 static void ts5500_disable_irq(struct ts5500_priv *priv)
298 {
299         unsigned long flags;
300
301         spin_lock_irqsave(&priv->lock, flags);
302         if (priv->hwirq == 7)
303                 ts5500_clear_mask(BIT(7), 0x7a); /* DIO1_13 on IRQ7 */
304         else if (priv->hwirq == 6)
305                 ts5500_clear_mask(BIT(7), 0x7d); /* DIO2_13 on IRQ6 */
306         else if (priv->hwirq == 1)
307                 ts5500_clear_mask(BIT(6), 0x7d); /* LCD_RS on IRQ1 */
308         else
309                 dev_err(priv->gpio_chip.parent, "invalid hwirq %d\n",
310                         priv->hwirq);
311         spin_unlock_irqrestore(&priv->lock, flags);
312 }
313
314 static int ts5500_dio_probe(struct platform_device *pdev)
315 {
316         enum ts5500_blocks block = platform_get_device_id(pdev)->driver_data;
317         struct device *dev = &pdev->dev;
318         const char *name = dev_name(dev);
319         struct ts5500_priv *priv;
320         unsigned long flags;
321         int ret;
322
323         ret = platform_get_irq(pdev, 0);
324         if (ret < 0)
325                 return ret;
326
327         priv = devm_kzalloc(dev, sizeof(struct ts5500_priv), GFP_KERNEL);
328         if (!priv)
329                 return -ENOMEM;
330
331         platform_set_drvdata(pdev, priv);
332         priv->hwirq = ret;
333         spin_lock_init(&priv->lock);
334
335         priv->gpio_chip.owner = THIS_MODULE;
336         priv->gpio_chip.label = name;
337         priv->gpio_chip.parent = dev;
338         priv->gpio_chip.direction_input = ts5500_gpio_input;
339         priv->gpio_chip.direction_output = ts5500_gpio_output;
340         priv->gpio_chip.get = ts5500_gpio_get;
341         priv->gpio_chip.set = ts5500_gpio_set;
342         priv->gpio_chip.to_irq = ts5500_gpio_to_irq;
343         priv->gpio_chip.base = -1;
344
345         switch (block) {
346         case TS5500_DIO1:
347                 priv->pinout = ts5500_dio1;
348                 priv->gpio_chip.ngpio = ARRAY_SIZE(ts5500_dio1);
349
350                 if (!devm_request_region(dev, 0x7a, 3, name)) {
351                         dev_err(dev, "failed to request %s ports\n", name);
352                         return -EBUSY;
353                 }
354                 break;
355         case TS5500_DIO2:
356                 priv->pinout = ts5500_dio2;
357                 priv->gpio_chip.ngpio = ARRAY_SIZE(ts5500_dio2);
358
359                 if (!devm_request_region(dev, 0x7e, 2, name)) {
360                         dev_err(dev, "failed to request %s ports\n", name);
361                         return -EBUSY;
362                 }
363
364                 if (hex7d_reserved)
365                         break;
366
367                 if (!devm_request_region(dev, 0x7d, 1, name)) {
368                         dev_err(dev, "failed to request %s 7D\n", name);
369                         return -EBUSY;
370                 }
371
372                 hex7d_reserved = true;
373                 break;
374         case TS5500_LCD:
375         case TS5600_LCD:
376                 priv->pinout = ts5500_lcd;
377                 priv->gpio_chip.ngpio = ARRAY_SIZE(ts5500_lcd);
378
379                 if (!devm_request_region(dev, 0x72, 2, name)) {
380                         dev_err(dev, "failed to request %s ports\n", name);
381                         return -EBUSY;
382                 }
383
384                 if (!hex7d_reserved) {
385                         if (!devm_request_region(dev, 0x7d, 1, name)) {
386                                 dev_err(dev, "failed to request %s 7D\n", name);
387                                 return -EBUSY;
388                         }
389
390                         hex7d_reserved = true;
391                 }
392
393                 /* Ensure usage of LCD port as DIO */
394                 spin_lock_irqsave(&priv->lock, flags);
395                 ts5500_clear_mask(BIT(4), 0x7d);
396                 spin_unlock_irqrestore(&priv->lock, flags);
397                 break;
398         }
399
400         ret = devm_gpiochip_add_data(dev, &priv->gpio_chip, priv);
401         if (ret) {
402                 dev_err(dev, "failed to register the gpio chip\n");
403                 return ret;
404         }
405
406         ret = ts5500_enable_irq(priv);
407         if (ret) {
408                 dev_err(dev, "invalid interrupt %d\n", priv->hwirq);
409                 return ret;
410         }
411
412         return 0;
413 }
414
415 static int ts5500_dio_remove(struct platform_device *pdev)
416 {
417         struct ts5500_priv *priv = platform_get_drvdata(pdev);
418
419         ts5500_disable_irq(priv);
420
421         return 0;
422 }
423
424 static const struct platform_device_id ts5500_dio_ids[] = {
425         { "ts5500-dio1", TS5500_DIO1 },
426         { "ts5500-dio2", TS5500_DIO2 },
427         { "ts5500-dio-lcd", TS5500_LCD },
428         { "ts5600-dio-lcd", TS5600_LCD },
429         { }
430 };
431 MODULE_DEVICE_TABLE(platform, ts5500_dio_ids);
432
433 static struct platform_driver ts5500_dio_driver = {
434         .driver = {
435                 .name = "ts5500-dio",
436         },
437         .probe = ts5500_dio_probe,
438         .remove = ts5500_dio_remove,
439         .id_table = ts5500_dio_ids,
440 };
441
442 module_platform_driver(ts5500_dio_driver);
443
444 MODULE_LICENSE("GPL");
445 MODULE_AUTHOR("Savoir-faire Linux Inc. <kernel@savoirfairelinux.com>");
446 MODULE_DESCRIPTION("Technologic Systems TS-5500 Digital I/O driver");