?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'trace-v6.13-rc7-2' of git://git.kernel.org/pub/scm/linux/kernel/git/trace...
[linux.git] / drivers / platform / cznic / turris-omnia-mcu-gpio.c
blob5f35f7c5d5d7ed041e9e3153ebfaab52ed5dce5f
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * CZ.NIC's Turris Omnia MCU GPIO and IRQ driver
4 *
5 * 2024 by Marek Behún <kabel@kernel.org>
6 */
7
8 #include <linux/array_size.h>
9 #include <linux/bitfield.h>
10 #include <linux/bitops.h>
11 #include <linux/bug.h>
12 #include <linux/cleanup.h>
13 #include <linux/device.h>
14 #include <linux/devm-helpers.h>
15 #include <linux/errno.h>
16 #include <linux/gpio/driver.h>
17 #include <linux/i2c.h>
18 #include <linux/interrupt.h>
19 #include <linux/mutex.h>
20 #include <linux/sysfs.h>
21 #include <linux/types.h>
22 #include <linux/workqueue.h>
23 #include <linux/unaligned.h>
24
25 #include <linux/turris-omnia-mcu-interface.h>
26 #include "turris-omnia-mcu.h"
27
28 #define OMNIA_CMD_INT_ARG_LEN 8
29 #define FRONT_BUTTON_RELEASE_DELAY_MS 50
30
31 static const char * const omnia_mcu_gpio_names[64] = {
32 /* GPIOs with value read from the 16-bit wide status */
33 [4] = "MiniPCIe0 Card Detect",
34 [5] = "MiniPCIe0 mSATA Indicator",
35 [6] = "Front USB3 port over-current",
36 [7] = "Rear USB3 port over-current",
37 [8] = "Front USB3 port power",
38 [9] = "Rear USB3 port power",
39 [12] = "Front Button",
40
41 /* GPIOs with value read from the 32-bit wide extended status */
42 [16] = "SFP nDET",
43 [28] = "MiniPCIe0 LED",
44 [29] = "MiniPCIe1 LED",
45 [30] = "MiniPCIe2 LED",
46 [31] = "MiniPCIe0 PAN LED",
47 [32] = "MiniPCIe1 PAN LED",
48 [33] = "MiniPCIe2 PAN LED",
49 [34] = "WAN PHY LED0",
50 [35] = "WAN PHY LED1",
51 [36] = "LAN switch p0 LED0",
52 [37] = "LAN switch p0 LED1",
53 [38] = "LAN switch p1 LED0",
54 [39] = "LAN switch p1 LED1",
55 [40] = "LAN switch p2 LED0",
56 [41] = "LAN switch p2 LED1",
57 [42] = "LAN switch p3 LED0",
58 [43] = "LAN switch p3 LED1",
59 [44] = "LAN switch p4 LED0",
60 [45] = "LAN switch p4 LED1",
61 [46] = "LAN switch p5 LED0",
62 [47] = "LAN switch p5 LED1",
63
64 /* GPIOs with value read from the 16-bit wide extended control status */
65 [48] = "eMMC nRESET",
66 [49] = "LAN switch nRESET",
67 [50] = "WAN PHY nRESET",
68 [51] = "MiniPCIe0 nPERST",
69 [52] = "MiniPCIe1 nPERST",
70 [53] = "MiniPCIe2 nPERST",
71 [54] = "WAN PHY SFP mux",
72 [56] = "VHV power disable",
73 };
74
75 struct omnia_gpio {
76 u8 cmd;
77 u8 ctl_cmd;
78 u8 bit;
79 u8 ctl_bit;
80 u8 int_bit;
81 u16 feat;
82 u16 feat_mask;
83 };
84
85 #define OMNIA_GPIO_INVALID_INT_BIT 0xff
86
87 #define _DEF_GPIO(_cmd, _ctl_cmd, _bit, _ctl_bit, _int_bit, _feat, _feat_mask) \
88 { \
89 .cmd = _cmd, \
90 .ctl_cmd = _ctl_cmd, \
91 .bit = _bit, \
92 .ctl_bit = _ctl_bit, \
93 .int_bit = (_int_bit) < 0 ? OMNIA_GPIO_INVALID_INT_BIT \
94 : (_int_bit), \
95 .feat = _feat, \
96 .feat_mask = _feat_mask, \
97 }
98
99 #define _DEF_GPIO_STS(_name) \
100 _DEF_GPIO(OMNIA_CMD_GET_STATUS_WORD, 0, __bf_shf(OMNIA_STS_ ## _name), \
101 0, __bf_shf(OMNIA_INT_ ## _name), 0, 0)
102
103 #define _DEF_GPIO_CTL(_name) \
104 _DEF_GPIO(OMNIA_CMD_GET_STATUS_WORD, OMNIA_CMD_GENERAL_CONTROL, \
105 __bf_shf(OMNIA_STS_ ## _name), __bf_shf(OMNIA_CTL_ ## _name), \
106 -1, 0, 0)
107
108 #define _DEF_GPIO_EXT_STS(_name, _feat) \
109 _DEF_GPIO(OMNIA_CMD_GET_EXT_STATUS_DWORD, 0, \
110 __bf_shf(OMNIA_EXT_STS_ ## _name), 0, \
111 __bf_shf(OMNIA_INT_ ## _name), \
112 OMNIA_FEAT_ ## _feat | OMNIA_FEAT_EXT_CMDS, \
113 OMNIA_FEAT_ ## _feat | OMNIA_FEAT_EXT_CMDS)
114
115 #define _DEF_GPIO_EXT_STS_LED(_name, _ledext) \
116 _DEF_GPIO(OMNIA_CMD_GET_EXT_STATUS_DWORD, 0, \
117 __bf_shf(OMNIA_EXT_STS_ ## _name), 0, \
118 __bf_shf(OMNIA_INT_ ## _name), \
119 OMNIA_FEAT_LED_STATE_ ## _ledext, \
120 OMNIA_FEAT_LED_STATE_EXT_MASK)
121
122 #define _DEF_GPIO_EXT_STS_LEDALL(_name) \
123 _DEF_GPIO(OMNIA_CMD_GET_EXT_STATUS_DWORD, 0, \
124 __bf_shf(OMNIA_EXT_STS_ ## _name), 0, \
125 __bf_shf(OMNIA_INT_ ## _name), \
126 OMNIA_FEAT_LED_STATE_EXT_MASK, 0)
127
128 #define _DEF_GPIO_EXT_CTL(_name, _feat) \
129 _DEF_GPIO(OMNIA_CMD_GET_EXT_CONTROL_STATUS, OMNIA_CMD_EXT_CONTROL, \
130 __bf_shf(OMNIA_EXT_CTL_ ## _name), \
131 __bf_shf(OMNIA_EXT_CTL_ ## _name), -1, \
132 OMNIA_FEAT_ ## _feat | OMNIA_FEAT_EXT_CMDS, \
133 OMNIA_FEAT_ ## _feat | OMNIA_FEAT_EXT_CMDS)
134
135 #define _DEF_INT(_name) \
136 _DEF_GPIO(0, 0, 0, 0, __bf_shf(OMNIA_INT_ ## _name), 0, 0)
137
138 static inline bool is_int_bit_valid(const struct omnia_gpio *gpio)
139 {
140 return gpio->int_bit != OMNIA_GPIO_INVALID_INT_BIT;
141 }
142
143 static const struct omnia_gpio omnia_gpios[64] = {
144 /* GPIOs with value read from the 16-bit wide status */
145 [4] = _DEF_GPIO_STS(CARD_DET),
146 [5] = _DEF_GPIO_STS(MSATA_IND),
147 [6] = _DEF_GPIO_STS(USB30_OVC),
148 [7] = _DEF_GPIO_STS(USB31_OVC),
149 [8] = _DEF_GPIO_CTL(USB30_PWRON),
150 [9] = _DEF_GPIO_CTL(USB31_PWRON),
151
152 /* brightness changed interrupt, no GPIO */
153 [11] = _DEF_INT(BRIGHTNESS_CHANGED),
154
155 [12] = _DEF_GPIO_STS(BUTTON_PRESSED),
156
157 /* TRNG interrupt, no GPIO */
158 [13] = _DEF_INT(TRNG),
159
160 /* MESSAGE_SIGNED interrupt, no GPIO */
161 [14] = _DEF_INT(MESSAGE_SIGNED),
162
163 /* GPIOs with value read from the 32-bit wide extended status */
164 [16] = _DEF_GPIO_EXT_STS(SFP_nDET, PERIPH_MCU),
165 [28] = _DEF_GPIO_EXT_STS_LEDALL(WLAN0_MSATA_LED),
166 [29] = _DEF_GPIO_EXT_STS_LEDALL(WLAN1_LED),
167 [30] = _DEF_GPIO_EXT_STS_LEDALL(WLAN2_LED),
168 [31] = _DEF_GPIO_EXT_STS_LED(WPAN0_LED, EXT),
169 [32] = _DEF_GPIO_EXT_STS_LED(WPAN1_LED, EXT),
170 [33] = _DEF_GPIO_EXT_STS_LED(WPAN2_LED, EXT),
171 [34] = _DEF_GPIO_EXT_STS_LEDALL(WAN_LED0),
172 [35] = _DEF_GPIO_EXT_STS_LED(WAN_LED1, EXT_V32),
173 [36] = _DEF_GPIO_EXT_STS_LEDALL(LAN0_LED0),
174 [37] = _DEF_GPIO_EXT_STS_LEDALL(LAN0_LED1),
175 [38] = _DEF_GPIO_EXT_STS_LEDALL(LAN1_LED0),
176 [39] = _DEF_GPIO_EXT_STS_LEDALL(LAN1_LED1),
177 [40] = _DEF_GPIO_EXT_STS_LEDALL(LAN2_LED0),
178 [41] = _DEF_GPIO_EXT_STS_LEDALL(LAN2_LED1),
179 [42] = _DEF_GPIO_EXT_STS_LEDALL(LAN3_LED0),
180 [43] = _DEF_GPIO_EXT_STS_LEDALL(LAN3_LED1),
181 [44] = _DEF_GPIO_EXT_STS_LEDALL(LAN4_LED0),
182 [45] = _DEF_GPIO_EXT_STS_LEDALL(LAN4_LED1),
183 [46] = _DEF_GPIO_EXT_STS_LEDALL(LAN5_LED0),
184 [47] = _DEF_GPIO_EXT_STS_LEDALL(LAN5_LED1),
185
186 /* GPIOs with value read from the 16-bit wide extended control status */
187 [48] = _DEF_GPIO_EXT_CTL(nRES_MMC, PERIPH_MCU),
188 [49] = _DEF_GPIO_EXT_CTL(nRES_LAN, PERIPH_MCU),
189 [50] = _DEF_GPIO_EXT_CTL(nRES_PHY, PERIPH_MCU),
190 [51] = _DEF_GPIO_EXT_CTL(nPERST0, PERIPH_MCU),
191 [52] = _DEF_GPIO_EXT_CTL(nPERST1, PERIPH_MCU),
192 [53] = _DEF_GPIO_EXT_CTL(nPERST2, PERIPH_MCU),
193 [54] = _DEF_GPIO_EXT_CTL(PHY_SFP, PERIPH_MCU),
194 [56] = _DEF_GPIO_EXT_CTL(nVHV_CTRL, PERIPH_MCU),
195 };
196
197 /* mapping from interrupts to indexes of GPIOs in the omnia_gpios array */
198 const u8 omnia_int_to_gpio_idx[32] = {
199 [__bf_shf(OMNIA_INT_CARD_DET)] = 4,
200 [__bf_shf(OMNIA_INT_MSATA_IND)] = 5,
201 [__bf_shf(OMNIA_INT_USB30_OVC)] = 6,
202 [__bf_shf(OMNIA_INT_USB31_OVC)] = 7,
203 [__bf_shf(OMNIA_INT_BUTTON_PRESSED)] = 12,
204 [__bf_shf(OMNIA_INT_TRNG)] = 13,
205 [__bf_shf(OMNIA_INT_MESSAGE_SIGNED)] = 14,
206 [__bf_shf(OMNIA_INT_SFP_nDET)] = 16,
207 [__bf_shf(OMNIA_INT_BRIGHTNESS_CHANGED)] = 11,
208 [__bf_shf(OMNIA_INT_WLAN0_MSATA_LED)] = 28,
209 [__bf_shf(OMNIA_INT_WLAN1_LED)] = 29,
210 [__bf_shf(OMNIA_INT_WLAN2_LED)] = 30,
211 [__bf_shf(OMNIA_INT_WPAN0_LED)] = 31,
212 [__bf_shf(OMNIA_INT_WPAN1_LED)] = 32,
213 [__bf_shf(OMNIA_INT_WPAN2_LED)] = 33,
214 [__bf_shf(OMNIA_INT_WAN_LED0)] = 34,
215 [__bf_shf(OMNIA_INT_WAN_LED1)] = 35,
216 [__bf_shf(OMNIA_INT_LAN0_LED0)] = 36,
217 [__bf_shf(OMNIA_INT_LAN0_LED1)] = 37,
218 [__bf_shf(OMNIA_INT_LAN1_LED0)] = 38,
219 [__bf_shf(OMNIA_INT_LAN1_LED1)] = 39,
220 [__bf_shf(OMNIA_INT_LAN2_LED0)] = 40,
221 [__bf_shf(OMNIA_INT_LAN2_LED1)] = 41,
222 [__bf_shf(OMNIA_INT_LAN3_LED0)] = 42,
223 [__bf_shf(OMNIA_INT_LAN3_LED1)] = 43,
224 [__bf_shf(OMNIA_INT_LAN4_LED0)] = 44,
225 [__bf_shf(OMNIA_INT_LAN4_LED1)] = 45,
226 [__bf_shf(OMNIA_INT_LAN5_LED0)] = 46,
227 [__bf_shf(OMNIA_INT_LAN5_LED1)] = 47,
228 };
229
230 /* index of PHY_SFP GPIO in the omnia_gpios array */
231 #define OMNIA_GPIO_PHY_SFP_OFFSET 54
232
233 static int omnia_ctl_cmd_locked(struct omnia_mcu *mcu, u8 cmd, u16 val, u16 mask)
234 {
235 unsigned int len;
236 u8 buf[5];
237
238 buf[0] = cmd;
239
240 switch (cmd) {
241 case OMNIA_CMD_GENERAL_CONTROL:
242 buf[1] = val;
243 buf[2] = mask;
244 len = 3;
245 break;
246
247 case OMNIA_CMD_EXT_CONTROL:
248 put_unaligned_le16(val, &buf[1]);
249 put_unaligned_le16(mask, &buf[3]);
250 len = 5;
251 break;
252
253 default:
254 BUG();
255 }
256
257 return omnia_cmd_write(mcu->client, buf, len);
258 }
259
260 static int omnia_ctl_cmd(struct omnia_mcu *mcu, u8 cmd, u16 val, u16 mask)
261 {
262 guard(mutex)(&mcu->lock);
263
264 return omnia_ctl_cmd_locked(mcu, cmd, val, mask);
265 }
266
267 static int omnia_gpio_request(struct gpio_chip *gc, unsigned int offset)
268 {
269 if (!omnia_gpios[offset].cmd)
270 return -EINVAL;
271
272 return 0;
273 }
274
275 static int omnia_gpio_get_direction(struct gpio_chip *gc, unsigned int offset)
276 {
277 struct omnia_mcu *mcu = gpiochip_get_data(gc);
278
279 if (offset == OMNIA_GPIO_PHY_SFP_OFFSET) {
280 int val;
281
282 scoped_guard(mutex, &mcu->lock) {
283 val = omnia_cmd_read_bit(mcu->client,
284 OMNIA_CMD_GET_EXT_CONTROL_STATUS,
285 OMNIA_EXT_CTL_PHY_SFP_AUTO);
286 if (val < 0)
287 return val;
288 }
289
290 if (val)
291 return GPIO_LINE_DIRECTION_IN;
292
293 return GPIO_LINE_DIRECTION_OUT;
294 }
295
296 if (omnia_gpios[offset].ctl_cmd)
297 return GPIO_LINE_DIRECTION_OUT;
298
299 return GPIO_LINE_DIRECTION_IN;
300 }
301
302 static int omnia_gpio_direction_input(struct gpio_chip *gc, unsigned int offset)
303 {
304 const struct omnia_gpio *gpio = &omnia_gpios[offset];
305 struct omnia_mcu *mcu = gpiochip_get_data(gc);
306
307 if (offset == OMNIA_GPIO_PHY_SFP_OFFSET)
308 return omnia_ctl_cmd(mcu, OMNIA_CMD_EXT_CONTROL,
309 OMNIA_EXT_CTL_PHY_SFP_AUTO,
310 OMNIA_EXT_CTL_PHY_SFP_AUTO);
311
312 if (gpio->ctl_cmd)
313 return -ENOTSUPP;
314
315 return 0;
316 }
317
318 static int omnia_gpio_direction_output(struct gpio_chip *gc,
319 unsigned int offset, int value)
320 {
321 const struct omnia_gpio *gpio = &omnia_gpios[offset];
322 struct omnia_mcu *mcu = gpiochip_get_data(gc);
323 u16 val, mask;
324
325 if (!gpio->ctl_cmd)
326 return -ENOTSUPP;
327
328 mask = BIT(gpio->ctl_bit);
329 val = value ? mask : 0;
330
331 if (offset == OMNIA_GPIO_PHY_SFP_OFFSET)
332 mask |= OMNIA_EXT_CTL_PHY_SFP_AUTO;
333
334 return omnia_ctl_cmd(mcu, gpio->ctl_cmd, val, mask);
335 }
336
337 static int omnia_gpio_get(struct gpio_chip *gc, unsigned int offset)
338 {
339 const struct omnia_gpio *gpio = &omnia_gpios[offset];
340 struct omnia_mcu *mcu = gpiochip_get_data(gc);
341
342 /*
343 * If firmware does not support the new interrupt API, we are informed
344 * of every change of the status word by an interrupt from MCU and save
345 * its value in the interrupt service routine. Simply return the saved
346 * value.
347 */
348 if (gpio->cmd == OMNIA_CMD_GET_STATUS_WORD &&
349 !(mcu->features & OMNIA_FEAT_NEW_INT_API))
350 return test_bit(gpio->bit, &mcu->last_status);
351
352 guard(mutex)(&mcu->lock);
353
354 /*
355 * If firmware does support the new interrupt API, we may have cached
356 * the value of a GPIO in the interrupt service routine. If not, read
357 * the relevant bit now.
358 */
359 if (is_int_bit_valid(gpio) && test_bit(gpio->int_bit, &mcu->is_cached))
360 return test_bit(gpio->int_bit, &mcu->cached);
361
362 return omnia_cmd_read_bit(mcu->client, gpio->cmd, BIT(gpio->bit));
363 }
364
365 static unsigned long *
366 _relevant_field_for_sts_cmd(u8 cmd, unsigned long *sts, unsigned long *ext_sts,
367 unsigned long *ext_ctl)
368 {
369 switch (cmd) {
370 case OMNIA_CMD_GET_STATUS_WORD:
371 return sts;
372 case OMNIA_CMD_GET_EXT_STATUS_DWORD:
373 return ext_sts;
374 case OMNIA_CMD_GET_EXT_CONTROL_STATUS:
375 return ext_ctl;
376 default:
377 return NULL;
378 }
379 }
380
381 static int omnia_gpio_get_multiple(struct gpio_chip *gc, unsigned long *mask,
382 unsigned long *bits)
383 {
384 unsigned long sts = 0, ext_sts = 0, ext_ctl = 0, *field;
385 struct omnia_mcu *mcu = gpiochip_get_data(gc);
386 struct i2c_client *client = mcu->client;
387 unsigned int i;
388 int err;
389
390 /* determine which bits to read from the 3 possible commands */
391 for_each_set_bit(i, mask, ARRAY_SIZE(omnia_gpios)) {
392 field = _relevant_field_for_sts_cmd(omnia_gpios[i].cmd,
393 &sts, &ext_sts, &ext_ctl);
394 if (!field)
395 continue;
396
397 __set_bit(omnia_gpios[i].bit, field);
398 }
399
400 guard(mutex)(&mcu->lock);
401
402 if (mcu->features & OMNIA_FEAT_NEW_INT_API) {
403 /* read relevant bits from status */
404 err = omnia_cmd_read_bits(client, OMNIA_CMD_GET_STATUS_WORD,
405 sts, &sts);
406 if (err)
407 return err;
408 } else {
409 /*
410 * Use status word value cached in the interrupt service routine
411 * if firmware does not support the new interrupt API.
412 */
413 sts = mcu->last_status;
414 }
415
416 /* read relevant bits from extended status */
417 err = omnia_cmd_read_bits(client, OMNIA_CMD_GET_EXT_STATUS_DWORD,
418 ext_sts, &ext_sts);
419 if (err)
420 return err;
421
422 /* read relevant bits from extended control */
423 err = omnia_cmd_read_bits(client, OMNIA_CMD_GET_EXT_CONTROL_STATUS,
424 ext_ctl, &ext_ctl);
425 if (err)
426 return err;
427
428 /* assign relevant bits in result */
429 for_each_set_bit(i, mask, ARRAY_SIZE(omnia_gpios)) {
430 field = _relevant_field_for_sts_cmd(omnia_gpios[i].cmd,
431 &sts, &ext_sts, &ext_ctl);
432 if (!field)
433 continue;
434
435 __assign_bit(i, bits, test_bit(omnia_gpios[i].bit, field));
436 }
437
438 return 0;
439 }
440
441 static void omnia_gpio_set(struct gpio_chip *gc, unsigned int offset, int value)
442 {
443 const struct omnia_gpio *gpio = &omnia_gpios[offset];
444 struct omnia_mcu *mcu = gpiochip_get_data(gc);
445 u16 val, mask;
446
447 if (!gpio->ctl_cmd)
448 return;
449
450 mask = BIT(gpio->ctl_bit);
451 val = value ? mask : 0;
452
453 omnia_ctl_cmd(mcu, gpio->ctl_cmd, val, mask);
454 }
455
456 static void omnia_gpio_set_multiple(struct gpio_chip *gc, unsigned long *mask,
457 unsigned long *bits)
458 {
459 unsigned long ctl = 0, ctl_mask = 0, ext_ctl = 0, ext_ctl_mask = 0;
460 struct omnia_mcu *mcu = gpiochip_get_data(gc);
461 unsigned int i;
462
463 for_each_set_bit(i, mask, ARRAY_SIZE(omnia_gpios)) {
464 unsigned long *field, *field_mask;
465 u8 bit = omnia_gpios[i].ctl_bit;
466
467 switch (omnia_gpios[i].ctl_cmd) {
468 case OMNIA_CMD_GENERAL_CONTROL:
469 field = &ctl;
470 field_mask = &ctl_mask;
471 break;
472 case OMNIA_CMD_EXT_CONTROL:
473 field = &ext_ctl;
474 field_mask = &ext_ctl_mask;
475 break;
476 default:
477 field = field_mask = NULL;
478 break;
479 }
480
481 if (!field)
482 continue;
483
484 __set_bit(bit, field_mask);
485 __assign_bit(bit, field, test_bit(i, bits));
486 }
487
488 guard(mutex)(&mcu->lock);
489
490 if (ctl_mask)
491 omnia_ctl_cmd_locked(mcu, OMNIA_CMD_GENERAL_CONTROL,
492 ctl, ctl_mask);
493
494 if (ext_ctl_mask)
495 omnia_ctl_cmd_locked(mcu, OMNIA_CMD_EXT_CONTROL,
496 ext_ctl, ext_ctl_mask);
497 }
498
499 static bool omnia_gpio_available(struct omnia_mcu *mcu,
500 const struct omnia_gpio *gpio)
501 {
502 if (gpio->feat_mask)
503 return (mcu->features & gpio->feat_mask) == gpio->feat;
504
505 if (gpio->feat)
506 return mcu->features & gpio->feat;
507
508 return true;
509 }
510
511 static int omnia_gpio_init_valid_mask(struct gpio_chip *gc,
512 unsigned long *valid_mask,
513 unsigned int ngpios)
514 {
515 struct omnia_mcu *mcu = gpiochip_get_data(gc);
516
517 for (unsigned int i = 0; i < ngpios; i++) {
518 const struct omnia_gpio *gpio = &omnia_gpios[i];
519
520 if (gpio->cmd || is_int_bit_valid(gpio))
521 __assign_bit(i, valid_mask,
522 omnia_gpio_available(mcu, gpio));
523 else
524 __clear_bit(i, valid_mask);
525 }
526
527 return 0;
528 }
529
530 static int omnia_gpio_of_xlate(struct gpio_chip *gc,
531 const struct of_phandle_args *gpiospec,
532 u32 *flags)
533 {
534 u32 bank, gpio;
535
536 if (WARN_ON(gpiospec->args_count != 3))
537 return -EINVAL;
538
539 if (flags)
540 *flags = gpiospec->args[2];
541
542 bank = gpiospec->args[0];
543 gpio = gpiospec->args[1];
544
545 switch (bank) {
546 case 0:
547 return gpio < 16 ? gpio : -EINVAL;
548 case 1:
549 return gpio < 32 ? 16 + gpio : -EINVAL;
550 case 2:
551 return gpio < 16 ? 48 + gpio : -EINVAL;
552 default:
553 return -EINVAL;
554 }
555 }
556
557 static void omnia_irq_shutdown(struct irq_data *d)
558 {
559 struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
560 struct omnia_mcu *mcu = gpiochip_get_data(gc);
561 irq_hw_number_t hwirq = irqd_to_hwirq(d);
562 u8 bit = omnia_gpios[hwirq].int_bit;
563
564 __clear_bit(bit, &mcu->rising);
565 __clear_bit(bit, &mcu->falling);
566 }
567
568 static void omnia_irq_mask(struct irq_data *d)
569 {
570 struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
571 struct omnia_mcu *mcu = gpiochip_get_data(gc);
572 irq_hw_number_t hwirq = irqd_to_hwirq(d);
573 u8 bit = omnia_gpios[hwirq].int_bit;
574
575 if (!omnia_gpios[hwirq].cmd)
576 __clear_bit(bit, &mcu->rising);
577 __clear_bit(bit, &mcu->mask);
578 gpiochip_disable_irq(gc, hwirq);
579 }
580
581 static void omnia_irq_unmask(struct irq_data *d)
582 {
583 struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
584 struct omnia_mcu *mcu = gpiochip_get_data(gc);
585 irq_hw_number_t hwirq = irqd_to_hwirq(d);
586 u8 bit = omnia_gpios[hwirq].int_bit;
587
588 gpiochip_enable_irq(gc, hwirq);
589 __set_bit(bit, &mcu->mask);
590 if (!omnia_gpios[hwirq].cmd)
591 __set_bit(bit, &mcu->rising);
592 }
593
594 static int omnia_irq_set_type(struct irq_data *d, unsigned int type)
595 {
596 struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
597 struct omnia_mcu *mcu = gpiochip_get_data(gc);
598 irq_hw_number_t hwirq = irqd_to_hwirq(d);
599 struct device *dev = &mcu->client->dev;
600 u8 bit = omnia_gpios[hwirq].int_bit;
601
602 if (!(type & IRQ_TYPE_EDGE_BOTH)) {
603 dev_err(dev, "irq %u: unsupported type %u\n", d->irq, type);
604 return -EINVAL;
605 }
606
607 __assign_bit(bit, &mcu->rising, type & IRQ_TYPE_EDGE_RISING);
608 __assign_bit(bit, &mcu->falling, type & IRQ_TYPE_EDGE_FALLING);
609
610 return 0;
611 }
612
613 static void omnia_irq_bus_lock(struct irq_data *d)
614 {
615 struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
616 struct omnia_mcu *mcu = gpiochip_get_data(gc);
617
618 /* nothing to do if MCU firmware does not support new interrupt API */
619 if (!(mcu->features & OMNIA_FEAT_NEW_INT_API))
620 return;
621
622 mutex_lock(&mcu->lock);
623 }
624
625 /**
626 * omnia_mask_interleave - Interleaves the bytes from @rising and @falling
627 * @dst: the destination u8 array of interleaved bytes
628 * @rising: rising mask
629 * @falling: falling mask
630 *
631 * Interleaves the little-endian bytes from @rising and @falling words.
632 *
633 * If @rising = (r0, r1, r2, r3) and @falling = (f0, f1, f2, f3), the result is
634 * @dst = (r0, f0, r1, f1, r2, f2, r3, f3).
635 *
636 * The MCU receives an interrupt mask and reports a pending interrupt bitmap in
637 * this interleaved format. The rationale behind this is that the low-indexed
638 * bits are more important - in many cases, the user will be interested only in
639 * interrupts with indexes 0 to 7, and so the system can stop reading after
640 * first 2 bytes (r0, f0), to save time on the slow I2C bus.
641 *
642 * Feel free to remove this function and its inverse, omnia_mask_deinterleave,
643 * and use an appropriate bitmap_*() function once such a function exists.
644 */
645 static void
646 omnia_mask_interleave(u8 *dst, unsigned long rising, unsigned long falling)
647 {
648 for (unsigned int i = 0; i < sizeof(u32); i++) {
649 dst[2 * i] = rising >> (8 * i);
650 dst[2 * i + 1] = falling >> (8 * i);
651 }
652 }
653
654 /**
655 * omnia_mask_deinterleave - Deinterleaves the bytes into @rising and @falling
656 * @src: the source u8 array containing the interleaved bytes
657 * @rising: pointer where to store the rising mask gathered from @src
658 * @falling: pointer where to store the falling mask gathered from @src
659 *
660 * This is the inverse function to omnia_mask_interleave.
661 */
662 static void omnia_mask_deinterleave(const u8 *src, unsigned long *rising,
663 unsigned long *falling)
664 {
665 *rising = *falling = 0;
666
667 for (unsigned int i = 0; i < sizeof(u32); i++) {
668 *rising |= src[2 * i] << (8 * i);
669 *falling |= src[2 * i + 1] << (8 * i);
670 }
671 }
672
673 static void omnia_irq_bus_sync_unlock(struct irq_data *d)
674 {
675 struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
676 struct omnia_mcu *mcu = gpiochip_get_data(gc);
677 struct device *dev = &mcu->client->dev;
678 u8 cmd[1 + OMNIA_CMD_INT_ARG_LEN];
679 unsigned long rising, falling;
680 int err;
681
682 /* nothing to do if MCU firmware does not support new interrupt API */
683 if (!(mcu->features & OMNIA_FEAT_NEW_INT_API))
684 return;
685
686 cmd[0] = OMNIA_CMD_SET_INT_MASK;
687
688 rising = mcu->rising & mcu->mask;
689 falling = mcu->falling & mcu->mask;
690
691 /* interleave the rising and falling bytes into the command arguments */
692 omnia_mask_interleave(&cmd[1], rising, falling);
693
694 dev_dbg(dev, "set int mask %8ph\n", &cmd[1]);
695
696 err = omnia_cmd_write(mcu->client, cmd, sizeof(cmd));
697 if (err) {
698 dev_err(dev, "Cannot set mask: %d\n", err);
699 goto unlock;
700 }
701
702 /*
703 * Remember which GPIOs have both rising and falling interrupts enabled.
704 * For those we will cache their value so that .get() method is faster.
705 * We also need to forget cached values of GPIOs that aren't cached
706 * anymore.
707 */
708 mcu->both = rising & falling;
709 mcu->is_cached &= mcu->both;
710
711 unlock:
712 mutex_unlock(&mcu->lock);
713 }
714
715 static const struct irq_chip omnia_mcu_irq_chip = {
716 .name = "Turris Omnia MCU interrupts",
717 .irq_shutdown = omnia_irq_shutdown,
718 .irq_mask = omnia_irq_mask,
719 .irq_unmask = omnia_irq_unmask,
720 .irq_set_type = omnia_irq_set_type,
721 .irq_bus_lock = omnia_irq_bus_lock,
722 .irq_bus_sync_unlock = omnia_irq_bus_sync_unlock,
723 .flags = IRQCHIP_IMMUTABLE,
724 GPIOCHIP_IRQ_RESOURCE_HELPERS,
725 };
726
727 static void omnia_irq_init_valid_mask(struct gpio_chip *gc,
728 unsigned long *valid_mask,
729 unsigned int ngpios)
730 {
731 struct omnia_mcu *mcu = gpiochip_get_data(gc);
732
733 for (unsigned int i = 0; i < ngpios; i++) {
734 const struct omnia_gpio *gpio = &omnia_gpios[i];
735
736 if (is_int_bit_valid(gpio))
737 __assign_bit(i, valid_mask,
738 omnia_gpio_available(mcu, gpio));
739 else
740 __clear_bit(i, valid_mask);
741 }
742 }
743
744 static int omnia_irq_init_hw(struct gpio_chip *gc)
745 {
746 struct omnia_mcu *mcu = gpiochip_get_data(gc);
747 u8 cmd[1 + OMNIA_CMD_INT_ARG_LEN] = {};
748
749 cmd[0] = OMNIA_CMD_SET_INT_MASK;
750
751 return omnia_cmd_write(mcu->client, cmd, sizeof(cmd));
752 }
753
754 /*
755 * Determine how many bytes we need to read from the reply to the
756 * OMNIA_CMD_GET_INT_AND_CLEAR command in order to retrieve all unmasked
757 * interrupts.
758 */
759 static unsigned int
760 omnia_irq_compute_pending_length(unsigned long rising, unsigned long falling)
761 {
762 return max(omnia_compute_reply_length(rising, true, 0),
763 omnia_compute_reply_length(falling, true, 1));
764 }
765
766 static bool omnia_irq_read_pending_new(struct omnia_mcu *mcu,
767 unsigned long *pending)
768 {
769 struct device *dev = &mcu->client->dev;
770 u8 reply[OMNIA_CMD_INT_ARG_LEN] = {};
771 unsigned long rising, falling;
772 unsigned int len;
773 int err;
774
775 len = omnia_irq_compute_pending_length(mcu->rising & mcu->mask,
776 mcu->falling & mcu->mask);
777 if (!len)
778 return false;
779
780 guard(mutex)(&mcu->lock);
781
782 err = omnia_cmd_read(mcu->client, OMNIA_CMD_GET_INT_AND_CLEAR, reply,
783 len);
784 if (err) {
785 dev_err(dev, "Cannot read pending IRQs: %d\n", err);
786 return false;
787 }
788
789 /* deinterleave the reply bytes into rising and falling */
790 omnia_mask_deinterleave(reply, &rising, &falling);
791
792 rising &= mcu->mask;
793 falling &= mcu->mask;
794 *pending = rising | falling;
795
796 /* cache values for GPIOs that have both edges enabled */
797 mcu->is_cached &= ~(rising & falling);
798 mcu->is_cached |= mcu->both & (rising ^ falling);
799 mcu->cached = (mcu->cached | rising) & ~falling;
800
801 return true;
802 }
803
804 static int omnia_read_status_word_old_fw(struct omnia_mcu *mcu,
805 unsigned long *status)
806 {
807 u16 raw_status;
808 int err;
809
810 err = omnia_cmd_read_u16(mcu->client, OMNIA_CMD_GET_STATUS_WORD,
811 &raw_status);
812 if (err)
813 return err;
814
815 /*
816 * Old firmware has a bug wherein it never resets the USB port
817 * overcurrent bits back to zero. Ignore them.
818 */
819 *status = raw_status & ~(OMNIA_STS_USB30_OVC | OMNIA_STS_USB31_OVC);
820
821 return 0;
822 }
823
824 static void button_release_emul_fn(struct work_struct *work)
825 {
826 struct omnia_mcu *mcu = container_of(to_delayed_work(work),
827 struct omnia_mcu,
828 button_release_emul_work);
829
830 mcu->button_pressed_emul = false;
831 generic_handle_irq_safe(mcu->client->irq);
832 }
833
834 static void
835 fill_int_from_sts(unsigned long *rising, unsigned long *falling,
836 unsigned long rising_sts, unsigned long falling_sts,
837 unsigned long sts_bit, unsigned long int_bit)
838 {
839 if (rising_sts & sts_bit)
840 *rising |= int_bit;
841 if (falling_sts & sts_bit)
842 *falling |= int_bit;
843 }
844
845 static bool omnia_irq_read_pending_old(struct omnia_mcu *mcu,
846 unsigned long *pending)
847 {
848 unsigned long status, rising_sts, falling_sts, rising, falling;
849 struct device *dev = &mcu->client->dev;
850 int err;
851
852 guard(mutex)(&mcu->lock);
853
854 err = omnia_read_status_word_old_fw(mcu, &status);
855 if (err) {
856 dev_err(dev, "Cannot read pending IRQs: %d\n", err);
857 return false;
858 }
859
860 /*
861 * The old firmware triggers an interrupt whenever status word changes,
862 * but does not inform about which bits rose or fell. We need to compute
863 * this here by comparing with the last status word value.
864 *
865 * The OMNIA_STS_BUTTON_PRESSED bit needs special handling, because the
866 * old firmware clears the OMNIA_STS_BUTTON_PRESSED bit on successful
867 * completion of the OMNIA_CMD_GET_STATUS_WORD command, resulting in
868 * another interrupt:
869 * - first we get an interrupt, we read the status word where
870 * OMNIA_STS_BUTTON_PRESSED is present,
871 * - MCU clears the OMNIA_STS_BUTTON_PRESSED bit because we read the
872 * status word,
873 * - we get another interrupt because the status word changed again
874 * (the OMNIA_STS_BUTTON_PRESSED bit was cleared).
875 *
876 * The gpiolib-cdev, gpiolib-sysfs and gpio-keys input driver all call
877 * the gpiochip's .get() method after an edge event on a requested GPIO
878 * occurs.
879 *
880 * We ensure that the .get() method reads 1 for the button GPIO for some
881 * time.
882 */
883
884 if (status & OMNIA_STS_BUTTON_PRESSED) {
885 mcu->button_pressed_emul = true;
886 mod_delayed_work(system_wq, &mcu->button_release_emul_work,
887 msecs_to_jiffies(FRONT_BUTTON_RELEASE_DELAY_MS));
888 } else if (mcu->button_pressed_emul) {
889 status |= OMNIA_STS_BUTTON_PRESSED;
890 }
891
892 rising_sts = ~mcu->last_status & status;
893 falling_sts = mcu->last_status & ~status;
894
895 mcu->last_status = status;
896
897 /*
898 * Fill in the relevant interrupt bits from status bits for CARD_DET,
899 * MSATA_IND and BUTTON_PRESSED.
900 */
901 rising = 0;
902 falling = 0;
903 fill_int_from_sts(&rising, &falling, rising_sts, falling_sts,
904 OMNIA_STS_CARD_DET, OMNIA_INT_CARD_DET);
905 fill_int_from_sts(&rising, &falling, rising_sts, falling_sts,
906 OMNIA_STS_MSATA_IND, OMNIA_INT_MSATA_IND);
907 fill_int_from_sts(&rising, &falling, rising_sts, falling_sts,
908 OMNIA_STS_BUTTON_PRESSED, OMNIA_INT_BUTTON_PRESSED);
909
910 /* Use only bits that are enabled */
911 rising &= mcu->rising & mcu->mask;
912 falling &= mcu->falling & mcu->mask;
913 *pending = rising | falling;
914
915 return true;
916 }
917
918 static bool omnia_irq_read_pending(struct omnia_mcu *mcu,
919 unsigned long *pending)
920 {
921 if (mcu->features & OMNIA_FEAT_NEW_INT_API)
922 return omnia_irq_read_pending_new(mcu, pending);
923 else
924 return omnia_irq_read_pending_old(mcu, pending);
925 }
926
927 static irqreturn_t omnia_irq_thread_handler(int irq, void *dev_id)
928 {
929 struct omnia_mcu *mcu = dev_id;
930 struct irq_domain *domain;
931 unsigned long pending;
932 unsigned int i;
933
934 if (!omnia_irq_read_pending(mcu, &pending))
935 return IRQ_NONE;
936
937 domain = mcu->gc.irq.domain;
938
939 for_each_set_bit(i, &pending, 32) {
940 unsigned int nested_irq;
941
942 nested_irq = irq_find_mapping(domain, omnia_int_to_gpio_idx[i]);
943
944 handle_nested_irq(nested_irq);
945 }
946
947 return IRQ_RETVAL(pending);
948 }
949
950 static const char * const front_button_modes[] = { "mcu", "cpu" };
951
952 static ssize_t front_button_mode_show(struct device *dev,
953 struct device_attribute *a, char *buf)
954 {
955 struct omnia_mcu *mcu = dev_get_drvdata(dev);
956 int val;
957
958 if (mcu->features & OMNIA_FEAT_NEW_INT_API) {
959 val = omnia_cmd_read_bit(mcu->client, OMNIA_CMD_GET_STATUS_WORD,
960 OMNIA_STS_BUTTON_MODE);
961 if (val < 0)
962 return val;
963 } else {
964 val = !!(mcu->last_status & OMNIA_STS_BUTTON_MODE);
965 }
966
967 return sysfs_emit(buf, "%s\n", front_button_modes[val]);
968 }
969
970 static ssize_t front_button_mode_store(struct device *dev,
971 struct device_attribute *a,
972 const char *buf, size_t count)
973 {
974 struct omnia_mcu *mcu = dev_get_drvdata(dev);
975 int err, i;
976
977 i = sysfs_match_string(front_button_modes, buf);
978 if (i < 0)
979 return i;
980
981 err = omnia_ctl_cmd_locked(mcu, OMNIA_CMD_GENERAL_CONTROL,
982 i ? OMNIA_CTL_BUTTON_MODE : 0,
983 OMNIA_CTL_BUTTON_MODE);
984 if (err)
985 return err;
986
987 return count;
988 }
989 static DEVICE_ATTR_RW(front_button_mode);
990
991 static struct attribute *omnia_mcu_gpio_attrs[] = {
992 &dev_attr_front_button_mode.attr,
993 NULL
994 };
995
996 const struct attribute_group omnia_mcu_gpio_group = {
997 .attrs = omnia_mcu_gpio_attrs,
998 };
999
1000 int omnia_mcu_register_gpiochip(struct omnia_mcu *mcu)
1001 {
1002 bool new_api = mcu->features & OMNIA_FEAT_NEW_INT_API;
1003 struct device *dev = &mcu->client->dev;
1004 unsigned long irqflags;
1005 int err;
1006
1007 err = devm_mutex_init(dev, &mcu->lock);
1008 if (err)
1009 return err;
1010
1011 mcu->gc.request = omnia_gpio_request;
1012 mcu->gc.get_direction = omnia_gpio_get_direction;
1013 mcu->gc.direction_input = omnia_gpio_direction_input;
1014 mcu->gc.direction_output = omnia_gpio_direction_output;
1015 mcu->gc.get = omnia_gpio_get;
1016 mcu->gc.get_multiple = omnia_gpio_get_multiple;
1017 mcu->gc.set = omnia_gpio_set;
1018 mcu->gc.set_multiple = omnia_gpio_set_multiple;
1019 mcu->gc.init_valid_mask = omnia_gpio_init_valid_mask;
1020 mcu->gc.can_sleep = true;
1021 mcu->gc.names = omnia_mcu_gpio_names;
1022 mcu->gc.base = -1;
1023 mcu->gc.ngpio = ARRAY_SIZE(omnia_gpios);
1024 mcu->gc.label = "Turris Omnia MCU GPIOs";
1025 mcu->gc.parent = dev;
1026 mcu->gc.owner = THIS_MODULE;
1027 mcu->gc.of_gpio_n_cells = 3;
1028 mcu->gc.of_xlate = omnia_gpio_of_xlate;
1029
1030 gpio_irq_chip_set_chip(&mcu->gc.irq, &omnia_mcu_irq_chip);
1031 /* This will let us handle the parent IRQ in the driver */
1032 mcu->gc.irq.parent_handler = NULL;
1033 mcu->gc.irq.num_parents = 0;
1034 mcu->gc.irq.parents = NULL;
1035 mcu->gc.irq.default_type = IRQ_TYPE_NONE;
1036 mcu->gc.irq.handler = handle_bad_irq;
1037 mcu->gc.irq.threaded = true;
1038 if (new_api)
1039 mcu->gc.irq.init_hw = omnia_irq_init_hw;
1040 mcu->gc.irq.init_valid_mask = omnia_irq_init_valid_mask;
1041
1042 err = devm_gpiochip_add_data(dev, &mcu->gc, mcu);
1043 if (err)
1044 return dev_err_probe(dev, err, "Cannot add GPIO chip\n");
1045
1046 /*
1047 * Before requesting the interrupt, if firmware does not support the new
1048 * interrupt API, we need to cache the value of the status word, so that
1049 * when it changes, we may compare the new value with the cached one in
1050 * the interrupt handler.
1051 */
1052 if (!new_api) {
1053 err = omnia_read_status_word_old_fw(mcu, &mcu->last_status);
1054 if (err)
1055 return dev_err_probe(dev, err,
1056 "Cannot read status word\n");
1057
1058 INIT_DELAYED_WORK(&mcu->button_release_emul_work,
1059 button_release_emul_fn);
1060 }
1061
1062 irqflags = IRQF_ONESHOT;
1063 if (new_api)
1064 irqflags |= IRQF_TRIGGER_LOW;
1065 else
1066 irqflags |= IRQF_TRIGGER_FALLING;
1067
1068 err = devm_request_threaded_irq(dev, mcu->client->irq, NULL,
1069 omnia_irq_thread_handler, irqflags,
1070 "turris-omnia-mcu", mcu);
1071 if (err)
1072 return dev_err_probe(dev, err, "Cannot request IRQ\n");
1073
1074 if (!new_api) {
1075 /*
1076 * The button_release_emul_work has to be initialized before the
1077 * thread is requested, and on driver remove it needs to be
1078 * canceled before the thread is freed. Therefore we can't use
1079 * devm_delayed_work_autocancel() directly, because the order
1080 * devm_delayed_work_autocancel();
1081 * devm_request_threaded_irq();
1082 * would cause improper release order:
1083 * free_irq();
1084 * cancel_delayed_work_sync();
1085 * Instead we first initialize the work above, and only now
1086 * after IRQ is requested we add the work devm action.
1087 */
1088 err = devm_add_action(dev, devm_delayed_work_drop,
1089 &mcu->button_release_emul_work);
1090 if (err)
1091 return err;
1092 }
1093
1094 return 0;
1095 }
Linux Kernel