This source file includes following definitions.
- pmic_gpio_read
- pmic_gpio_write
- pmic_gpio_get_groups_count
- pmic_gpio_get_group_name
- pmic_gpio_get_group_pins
- pmic_gpio_get_functions_count
- pmic_gpio_get_function_name
- pmic_gpio_get_function_groups
- pmic_gpio_set_mux
- pmic_gpio_config_get
- pmic_gpio_config_set
- pmic_gpio_config_dbg_show
- pmic_gpio_direction_input
- pmic_gpio_direction_output
- pmic_gpio_get
- pmic_gpio_set
- pmic_gpio_of_xlate
- pmic_gpio_dbg_show
- pmic_gpio_populate
- pmic_gpio_domain_translate
- pmic_gpio_child_offset_to_irq
- pmic_gpio_child_to_parent_hwirq
- pmic_gpio_probe
- pmic_gpio_remove
1
2
3
4
5
6 #include <linux/gpio/driver.h>
7 #include <linux/interrupt.h>
8 #include <linux/module.h>
9 #include <linux/of.h>
10 #include <linux/of_irq.h>
11 #include <linux/pinctrl/pinconf-generic.h>
12 #include <linux/pinctrl/pinconf.h>
13 #include <linux/pinctrl/pinmux.h>
14 #include <linux/platform_device.h>
15 #include <linux/regmap.h>
16 #include <linux/slab.h>
17 #include <linux/types.h>
18
19 #include <dt-bindings/pinctrl/qcom,pmic-gpio.h>
20
21 #include "../core.h"
22 #include "../pinctrl-utils.h"
23
24 #define PMIC_GPIO_ADDRESS_RANGE 0x100
25
26
27 #define PMIC_GPIO_REG_TYPE 0x4
28 #define PMIC_GPIO_REG_SUBTYPE 0x5
29
30
31 #define PMIC_GPIO_TYPE 0x10
32 #define PMIC_GPIO_SUBTYPE_GPIO_4CH 0x1
33 #define PMIC_GPIO_SUBTYPE_GPIOC_4CH 0x5
34 #define PMIC_GPIO_SUBTYPE_GPIO_8CH 0x9
35 #define PMIC_GPIO_SUBTYPE_GPIOC_8CH 0xd
36 #define PMIC_GPIO_SUBTYPE_GPIO_LV 0x10
37 #define PMIC_GPIO_SUBTYPE_GPIO_MV 0x11
38
39 #define PMIC_MPP_REG_RT_STS 0x10
40 #define PMIC_MPP_REG_RT_STS_VAL_MASK 0x1
41
42
43 #define PMIC_GPIO_REG_MODE_CTL 0x40
44 #define PMIC_GPIO_REG_DIG_VIN_CTL 0x41
45 #define PMIC_GPIO_REG_DIG_PULL_CTL 0x42
46 #define PMIC_GPIO_REG_LV_MV_DIG_OUT_SOURCE_CTL 0x44
47 #define PMIC_GPIO_REG_DIG_IN_CTL 0x43
48 #define PMIC_GPIO_REG_DIG_OUT_CTL 0x45
49 #define PMIC_GPIO_REG_EN_CTL 0x46
50 #define PMIC_GPIO_REG_LV_MV_ANA_PASS_THRU_SEL 0x4A
51
52
53 #define PMIC_GPIO_REG_MODE_VALUE_SHIFT 0x1
54 #define PMIC_GPIO_REG_MODE_FUNCTION_SHIFT 1
55 #define PMIC_GPIO_REG_MODE_FUNCTION_MASK 0x7
56 #define PMIC_GPIO_REG_MODE_DIR_SHIFT 4
57 #define PMIC_GPIO_REG_MODE_DIR_MASK 0x7
58
59 #define PMIC_GPIO_MODE_DIGITAL_INPUT 0
60 #define PMIC_GPIO_MODE_DIGITAL_OUTPUT 1
61 #define PMIC_GPIO_MODE_DIGITAL_INPUT_OUTPUT 2
62 #define PMIC_GPIO_MODE_ANALOG_PASS_THRU 3
63 #define PMIC_GPIO_REG_LV_MV_MODE_DIR_MASK 0x3
64
65
66 #define PMIC_GPIO_REG_VIN_SHIFT 0
67 #define PMIC_GPIO_REG_VIN_MASK 0x7
68
69
70 #define PMIC_GPIO_REG_PULL_SHIFT 0
71 #define PMIC_GPIO_REG_PULL_MASK 0x7
72
73 #define PMIC_GPIO_PULL_DOWN 4
74 #define PMIC_GPIO_PULL_DISABLE 5
75
76
77 #define PMIC_GPIO_LV_MV_OUTPUT_INVERT 0x80
78 #define PMIC_GPIO_LV_MV_OUTPUT_INVERT_SHIFT 7
79 #define PMIC_GPIO_LV_MV_OUTPUT_SOURCE_SEL_MASK 0xF
80
81
82 #define PMIC_GPIO_LV_MV_DIG_IN_DTEST_EN 0x80
83 #define PMIC_GPIO_LV_MV_DIG_IN_DTEST_SEL_MASK 0x7
84 #define PMIC_GPIO_DIG_IN_DTEST_SEL_MASK 0xf
85
86
87 #define PMIC_GPIO_REG_OUT_STRENGTH_SHIFT 0
88 #define PMIC_GPIO_REG_OUT_STRENGTH_MASK 0x3
89 #define PMIC_GPIO_REG_OUT_TYPE_SHIFT 4
90 #define PMIC_GPIO_REG_OUT_TYPE_MASK 0x3
91
92
93
94
95
96 #define PMIC_GPIO_OUT_BUF_CMOS 0
97 #define PMIC_GPIO_OUT_BUF_OPEN_DRAIN_NMOS 1
98 #define PMIC_GPIO_OUT_BUF_OPEN_DRAIN_PMOS 2
99
100
101 #define PMIC_GPIO_REG_MASTER_EN_SHIFT 7
102
103 #define PMIC_GPIO_PHYSICAL_OFFSET 1
104
105
106 #define PMIC_GPIO_LV_MV_ANA_MUX_SEL_MASK 0x3
107
108
109 #define PMIC_GPIO_CONF_PULL_UP (PIN_CONFIG_END + 1)
110 #define PMIC_GPIO_CONF_STRENGTH (PIN_CONFIG_END + 2)
111 #define PMIC_GPIO_CONF_ATEST (PIN_CONFIG_END + 3)
112 #define PMIC_GPIO_CONF_ANALOG_PASS (PIN_CONFIG_END + 4)
113 #define PMIC_GPIO_CONF_DTEST_BUFFER (PIN_CONFIG_END + 5)
114
115
116 enum pmic_gpio_func_index {
117 PMIC_GPIO_FUNC_INDEX_NORMAL,
118 PMIC_GPIO_FUNC_INDEX_PAIRED,
119 PMIC_GPIO_FUNC_INDEX_FUNC1,
120 PMIC_GPIO_FUNC_INDEX_FUNC2,
121 PMIC_GPIO_FUNC_INDEX_FUNC3,
122 PMIC_GPIO_FUNC_INDEX_FUNC4,
123 PMIC_GPIO_FUNC_INDEX_DTEST1,
124 PMIC_GPIO_FUNC_INDEX_DTEST2,
125 PMIC_GPIO_FUNC_INDEX_DTEST3,
126 PMIC_GPIO_FUNC_INDEX_DTEST4,
127 };
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149 struct pmic_gpio_pad {
150 u16 base;
151 bool is_enabled;
152 bool out_value;
153 bool have_buffer;
154 bool output_enabled;
155 bool input_enabled;
156 bool analog_pass;
157 bool lv_mv_type;
158 unsigned int num_sources;
159 unsigned int power_source;
160 unsigned int buffer_type;
161 unsigned int pullup;
162 unsigned int strength;
163 unsigned int function;
164 unsigned int atest;
165 unsigned int dtest_buffer;
166 };
167
168 struct pmic_gpio_state {
169 struct device *dev;
170 struct regmap *map;
171 struct pinctrl_dev *ctrl;
172 struct gpio_chip chip;
173 };
174
175 static const struct pinconf_generic_params pmic_gpio_bindings[] = {
176 {"qcom,pull-up-strength", PMIC_GPIO_CONF_PULL_UP, 0},
177 {"qcom,drive-strength", PMIC_GPIO_CONF_STRENGTH, 0},
178 {"qcom,atest", PMIC_GPIO_CONF_ATEST, 0},
179 {"qcom,analog-pass", PMIC_GPIO_CONF_ANALOG_PASS, 0},
180 {"qcom,dtest-buffer", PMIC_GPIO_CONF_DTEST_BUFFER, 0},
181 };
182
183 #ifdef CONFIG_DEBUG_FS
184 static const struct pin_config_item pmic_conf_items[ARRAY_SIZE(pmic_gpio_bindings)] = {
185 PCONFDUMP(PMIC_GPIO_CONF_PULL_UP, "pull up strength", NULL, true),
186 PCONFDUMP(PMIC_GPIO_CONF_STRENGTH, "drive-strength", NULL, true),
187 PCONFDUMP(PMIC_GPIO_CONF_ATEST, "atest", NULL, true),
188 PCONFDUMP(PMIC_GPIO_CONF_ANALOG_PASS, "analog-pass", NULL, true),
189 PCONFDUMP(PMIC_GPIO_CONF_DTEST_BUFFER, "dtest-buffer", NULL, true),
190 };
191 #endif
192
193 static const char *const pmic_gpio_groups[] = {
194 "gpio1", "gpio2", "gpio3", "gpio4", "gpio5", "gpio6", "gpio7", "gpio8",
195 "gpio9", "gpio10", "gpio11", "gpio12", "gpio13", "gpio14", "gpio15",
196 "gpio16", "gpio17", "gpio18", "gpio19", "gpio20", "gpio21", "gpio22",
197 "gpio23", "gpio24", "gpio25", "gpio26", "gpio27", "gpio28", "gpio29",
198 "gpio30", "gpio31", "gpio32", "gpio33", "gpio34", "gpio35", "gpio36",
199 };
200
201 static const char *const pmic_gpio_functions[] = {
202 [PMIC_GPIO_FUNC_INDEX_NORMAL] = PMIC_GPIO_FUNC_NORMAL,
203 [PMIC_GPIO_FUNC_INDEX_PAIRED] = PMIC_GPIO_FUNC_PAIRED,
204 [PMIC_GPIO_FUNC_INDEX_FUNC1] = PMIC_GPIO_FUNC_FUNC1,
205 [PMIC_GPIO_FUNC_INDEX_FUNC2] = PMIC_GPIO_FUNC_FUNC2,
206 [PMIC_GPIO_FUNC_INDEX_FUNC3] = PMIC_GPIO_FUNC_FUNC3,
207 [PMIC_GPIO_FUNC_INDEX_FUNC4] = PMIC_GPIO_FUNC_FUNC4,
208 [PMIC_GPIO_FUNC_INDEX_DTEST1] = PMIC_GPIO_FUNC_DTEST1,
209 [PMIC_GPIO_FUNC_INDEX_DTEST2] = PMIC_GPIO_FUNC_DTEST2,
210 [PMIC_GPIO_FUNC_INDEX_DTEST3] = PMIC_GPIO_FUNC_DTEST3,
211 [PMIC_GPIO_FUNC_INDEX_DTEST4] = PMIC_GPIO_FUNC_DTEST4,
212 };
213
214 static int pmic_gpio_read(struct pmic_gpio_state *state,
215 struct pmic_gpio_pad *pad, unsigned int addr)
216 {
217 unsigned int val;
218 int ret;
219
220 ret = regmap_read(state->map, pad->base + addr, &val);
221 if (ret < 0)
222 dev_err(state->dev, "read 0x%x failed\n", addr);
223 else
224 ret = val;
225
226 return ret;
227 }
228
229 static int pmic_gpio_write(struct pmic_gpio_state *state,
230 struct pmic_gpio_pad *pad, unsigned int addr,
231 unsigned int val)
232 {
233 int ret;
234
235 ret = regmap_write(state->map, pad->base + addr, val);
236 if (ret < 0)
237 dev_err(state->dev, "write 0x%x failed\n", addr);
238
239 return ret;
240 }
241
242 static int pmic_gpio_get_groups_count(struct pinctrl_dev *pctldev)
243 {
244
245 return pctldev->desc->npins;
246 }
247
248 static const char *pmic_gpio_get_group_name(struct pinctrl_dev *pctldev,
249 unsigned pin)
250 {
251 return pctldev->desc->pins[pin].name;
252 }
253
254 static int pmic_gpio_get_group_pins(struct pinctrl_dev *pctldev, unsigned pin,
255 const unsigned **pins, unsigned *num_pins)
256 {
257 *pins = &pctldev->desc->pins[pin].number;
258 *num_pins = 1;
259 return 0;
260 }
261
262 static const struct pinctrl_ops pmic_gpio_pinctrl_ops = {
263 .get_groups_count = pmic_gpio_get_groups_count,
264 .get_group_name = pmic_gpio_get_group_name,
265 .get_group_pins = pmic_gpio_get_group_pins,
266 .dt_node_to_map = pinconf_generic_dt_node_to_map_group,
267 .dt_free_map = pinctrl_utils_free_map,
268 };
269
270 static int pmic_gpio_get_functions_count(struct pinctrl_dev *pctldev)
271 {
272 return ARRAY_SIZE(pmic_gpio_functions);
273 }
274
275 static const char *pmic_gpio_get_function_name(struct pinctrl_dev *pctldev,
276 unsigned function)
277 {
278 return pmic_gpio_functions[function];
279 }
280
281 static int pmic_gpio_get_function_groups(struct pinctrl_dev *pctldev,
282 unsigned function,
283 const char *const **groups,
284 unsigned *const num_qgroups)
285 {
286 *groups = pmic_gpio_groups;
287 *num_qgroups = pctldev->desc->npins;
288 return 0;
289 }
290
291 static int pmic_gpio_set_mux(struct pinctrl_dev *pctldev, unsigned function,
292 unsigned pin)
293 {
294 struct pmic_gpio_state *state = pinctrl_dev_get_drvdata(pctldev);
295 struct pmic_gpio_pad *pad;
296 unsigned int val;
297 int ret;
298
299 if (function > PMIC_GPIO_FUNC_INDEX_DTEST4) {
300 pr_err("function: %d is not defined\n", function);
301 return -EINVAL;
302 }
303
304 pad = pctldev->desc->pins[pin].drv_data;
305
306
307
308
309 if (!pad->lv_mv_type) {
310 if (function == PMIC_GPIO_FUNC_INDEX_FUNC3 ||
311 function == PMIC_GPIO_FUNC_INDEX_FUNC4) {
312 pr_err("LV/MV subtype doesn't have func3/func4\n");
313 return -EINVAL;
314 }
315 if (function >= PMIC_GPIO_FUNC_INDEX_DTEST1)
316 function -= (PMIC_GPIO_FUNC_INDEX_DTEST1 -
317 PMIC_GPIO_FUNC_INDEX_FUNC3);
318 }
319
320 pad->function = function;
321
322 if (pad->analog_pass)
323 val = PMIC_GPIO_MODE_ANALOG_PASS_THRU;
324 else if (pad->output_enabled && pad->input_enabled)
325 val = PMIC_GPIO_MODE_DIGITAL_INPUT_OUTPUT;
326 else if (pad->output_enabled)
327 val = PMIC_GPIO_MODE_DIGITAL_OUTPUT;
328 else
329 val = PMIC_GPIO_MODE_DIGITAL_INPUT;
330
331 if (pad->lv_mv_type) {
332 ret = pmic_gpio_write(state, pad,
333 PMIC_GPIO_REG_MODE_CTL, val);
334 if (ret < 0)
335 return ret;
336
337 val = pad->atest - 1;
338 ret = pmic_gpio_write(state, pad,
339 PMIC_GPIO_REG_LV_MV_ANA_PASS_THRU_SEL, val);
340 if (ret < 0)
341 return ret;
342
343 val = pad->out_value
344 << PMIC_GPIO_LV_MV_OUTPUT_INVERT_SHIFT;
345 val |= pad->function
346 & PMIC_GPIO_LV_MV_OUTPUT_SOURCE_SEL_MASK;
347 ret = pmic_gpio_write(state, pad,
348 PMIC_GPIO_REG_LV_MV_DIG_OUT_SOURCE_CTL, val);
349 if (ret < 0)
350 return ret;
351 } else {
352 val = val << PMIC_GPIO_REG_MODE_DIR_SHIFT;
353 val |= pad->function << PMIC_GPIO_REG_MODE_FUNCTION_SHIFT;
354 val |= pad->out_value & PMIC_GPIO_REG_MODE_VALUE_SHIFT;
355
356 ret = pmic_gpio_write(state, pad, PMIC_GPIO_REG_MODE_CTL, val);
357 if (ret < 0)
358 return ret;
359 }
360
361 val = pad->is_enabled << PMIC_GPIO_REG_MASTER_EN_SHIFT;
362
363 return pmic_gpio_write(state, pad, PMIC_GPIO_REG_EN_CTL, val);
364 }
365
366 static const struct pinmux_ops pmic_gpio_pinmux_ops = {
367 .get_functions_count = pmic_gpio_get_functions_count,
368 .get_function_name = pmic_gpio_get_function_name,
369 .get_function_groups = pmic_gpio_get_function_groups,
370 .set_mux = pmic_gpio_set_mux,
371 };
372
373 static int pmic_gpio_config_get(struct pinctrl_dev *pctldev,
374 unsigned int pin, unsigned long *config)
375 {
376 unsigned param = pinconf_to_config_param(*config);
377 struct pmic_gpio_pad *pad;
378 unsigned arg;
379
380 pad = pctldev->desc->pins[pin].drv_data;
381
382 switch (param) {
383 case PIN_CONFIG_DRIVE_PUSH_PULL:
384 if (pad->buffer_type != PMIC_GPIO_OUT_BUF_CMOS)
385 return -EINVAL;
386 arg = 1;
387 break;
388 case PIN_CONFIG_DRIVE_OPEN_DRAIN:
389 if (pad->buffer_type != PMIC_GPIO_OUT_BUF_OPEN_DRAIN_NMOS)
390 return -EINVAL;
391 arg = 1;
392 break;
393 case PIN_CONFIG_DRIVE_OPEN_SOURCE:
394 if (pad->buffer_type != PMIC_GPIO_OUT_BUF_OPEN_DRAIN_PMOS)
395 return -EINVAL;
396 arg = 1;
397 break;
398 case PIN_CONFIG_BIAS_PULL_DOWN:
399 if (pad->pullup != PMIC_GPIO_PULL_DOWN)
400 return -EINVAL;
401 arg = 1;
402 break;
403 case PIN_CONFIG_BIAS_DISABLE:
404 if (pad->pullup != PMIC_GPIO_PULL_DISABLE)
405 return -EINVAL;
406 arg = 1;
407 break;
408 case PIN_CONFIG_BIAS_PULL_UP:
409 if (pad->pullup != PMIC_GPIO_PULL_UP_30)
410 return -EINVAL;
411 arg = 1;
412 break;
413 case PIN_CONFIG_BIAS_HIGH_IMPEDANCE:
414 if (pad->is_enabled)
415 return -EINVAL;
416 arg = 1;
417 break;
418 case PIN_CONFIG_POWER_SOURCE:
419 arg = pad->power_source;
420 break;
421 case PIN_CONFIG_INPUT_ENABLE:
422 if (!pad->input_enabled)
423 return -EINVAL;
424 arg = 1;
425 break;
426 case PIN_CONFIG_OUTPUT:
427 arg = pad->out_value;
428 break;
429 case PMIC_GPIO_CONF_PULL_UP:
430 arg = pad->pullup;
431 break;
432 case PMIC_GPIO_CONF_STRENGTH:
433 arg = pad->strength;
434 break;
435 case PMIC_GPIO_CONF_ATEST:
436 arg = pad->atest;
437 break;
438 case PMIC_GPIO_CONF_ANALOG_PASS:
439 arg = pad->analog_pass;
440 break;
441 case PMIC_GPIO_CONF_DTEST_BUFFER:
442 arg = pad->dtest_buffer;
443 break;
444 default:
445 return -EINVAL;
446 }
447
448 *config = pinconf_to_config_packed(param, arg);
449 return 0;
450 }
451
452 static int pmic_gpio_config_set(struct pinctrl_dev *pctldev, unsigned int pin,
453 unsigned long *configs, unsigned nconfs)
454 {
455 struct pmic_gpio_state *state = pinctrl_dev_get_drvdata(pctldev);
456 struct pmic_gpio_pad *pad;
457 unsigned param, arg;
458 unsigned int val;
459 int i, ret;
460
461 pad = pctldev->desc->pins[pin].drv_data;
462
463 pad->is_enabled = true;
464 for (i = 0; i < nconfs; i++) {
465 param = pinconf_to_config_param(configs[i]);
466 arg = pinconf_to_config_argument(configs[i]);
467
468 switch (param) {
469 case PIN_CONFIG_DRIVE_PUSH_PULL:
470 pad->buffer_type = PMIC_GPIO_OUT_BUF_CMOS;
471 break;
472 case PIN_CONFIG_DRIVE_OPEN_DRAIN:
473 if (!pad->have_buffer)
474 return -EINVAL;
475 pad->buffer_type = PMIC_GPIO_OUT_BUF_OPEN_DRAIN_NMOS;
476 break;
477 case PIN_CONFIG_DRIVE_OPEN_SOURCE:
478 if (!pad->have_buffer)
479 return -EINVAL;
480 pad->buffer_type = PMIC_GPIO_OUT_BUF_OPEN_DRAIN_PMOS;
481 break;
482 case PIN_CONFIG_BIAS_DISABLE:
483 pad->pullup = PMIC_GPIO_PULL_DISABLE;
484 break;
485 case PIN_CONFIG_BIAS_PULL_UP:
486 pad->pullup = PMIC_GPIO_PULL_UP_30;
487 break;
488 case PIN_CONFIG_BIAS_PULL_DOWN:
489 if (arg)
490 pad->pullup = PMIC_GPIO_PULL_DOWN;
491 else
492 pad->pullup = PMIC_GPIO_PULL_DISABLE;
493 break;
494 case PIN_CONFIG_BIAS_HIGH_IMPEDANCE:
495 pad->is_enabled = false;
496 break;
497 case PIN_CONFIG_POWER_SOURCE:
498 if (arg >= pad->num_sources)
499 return -EINVAL;
500 pad->power_source = arg;
501 break;
502 case PIN_CONFIG_INPUT_ENABLE:
503 pad->input_enabled = arg ? true : false;
504 break;
505 case PIN_CONFIG_OUTPUT:
506 pad->output_enabled = true;
507 pad->out_value = arg;
508 break;
509 case PMIC_GPIO_CONF_PULL_UP:
510 if (arg > PMIC_GPIO_PULL_UP_1P5_30)
511 return -EINVAL;
512 pad->pullup = arg;
513 break;
514 case PMIC_GPIO_CONF_STRENGTH:
515 if (arg > PMIC_GPIO_STRENGTH_LOW)
516 return -EINVAL;
517 pad->strength = arg;
518 break;
519 case PMIC_GPIO_CONF_ATEST:
520 if (!pad->lv_mv_type || arg > 4)
521 return -EINVAL;
522 pad->atest = arg;
523 break;
524 case PMIC_GPIO_CONF_ANALOG_PASS:
525 if (!pad->lv_mv_type)
526 return -EINVAL;
527 pad->analog_pass = true;
528 break;
529 case PMIC_GPIO_CONF_DTEST_BUFFER:
530 if (arg > 4)
531 return -EINVAL;
532 pad->dtest_buffer = arg;
533 break;
534 default:
535 return -EINVAL;
536 }
537 }
538
539 val = pad->power_source << PMIC_GPIO_REG_VIN_SHIFT;
540
541 ret = pmic_gpio_write(state, pad, PMIC_GPIO_REG_DIG_VIN_CTL, val);
542 if (ret < 0)
543 return ret;
544
545 val = pad->pullup << PMIC_GPIO_REG_PULL_SHIFT;
546
547 ret = pmic_gpio_write(state, pad, PMIC_GPIO_REG_DIG_PULL_CTL, val);
548 if (ret < 0)
549 return ret;
550
551 val = pad->buffer_type << PMIC_GPIO_REG_OUT_TYPE_SHIFT;
552 val |= pad->strength << PMIC_GPIO_REG_OUT_STRENGTH_SHIFT;
553
554 ret = pmic_gpio_write(state, pad, PMIC_GPIO_REG_DIG_OUT_CTL, val);
555 if (ret < 0)
556 return ret;
557
558 if (pad->dtest_buffer == 0) {
559 val = 0;
560 } else {
561 if (pad->lv_mv_type) {
562 val = pad->dtest_buffer - 1;
563 val |= PMIC_GPIO_LV_MV_DIG_IN_DTEST_EN;
564 } else {
565 val = BIT(pad->dtest_buffer - 1);
566 }
567 }
568 ret = pmic_gpio_write(state, pad, PMIC_GPIO_REG_DIG_IN_CTL, val);
569 if (ret < 0)
570 return ret;
571
572 if (pad->analog_pass)
573 val = PMIC_GPIO_MODE_ANALOG_PASS_THRU;
574 else if (pad->output_enabled && pad->input_enabled)
575 val = PMIC_GPIO_MODE_DIGITAL_INPUT_OUTPUT;
576 else if (pad->output_enabled)
577 val = PMIC_GPIO_MODE_DIGITAL_OUTPUT;
578 else
579 val = PMIC_GPIO_MODE_DIGITAL_INPUT;
580
581 if (pad->lv_mv_type) {
582 ret = pmic_gpio_write(state, pad,
583 PMIC_GPIO_REG_MODE_CTL, val);
584 if (ret < 0)
585 return ret;
586
587 val = pad->atest - 1;
588 ret = pmic_gpio_write(state, pad,
589 PMIC_GPIO_REG_LV_MV_ANA_PASS_THRU_SEL, val);
590 if (ret < 0)
591 return ret;
592
593 val = pad->out_value
594 << PMIC_GPIO_LV_MV_OUTPUT_INVERT_SHIFT;
595 val |= pad->function
596 & PMIC_GPIO_LV_MV_OUTPUT_SOURCE_SEL_MASK;
597 ret = pmic_gpio_write(state, pad,
598 PMIC_GPIO_REG_LV_MV_DIG_OUT_SOURCE_CTL, val);
599 if (ret < 0)
600 return ret;
601 } else {
602 val = val << PMIC_GPIO_REG_MODE_DIR_SHIFT;
603 val |= pad->function << PMIC_GPIO_REG_MODE_FUNCTION_SHIFT;
604 val |= pad->out_value & PMIC_GPIO_REG_MODE_VALUE_SHIFT;
605
606 ret = pmic_gpio_write(state, pad, PMIC_GPIO_REG_MODE_CTL, val);
607 if (ret < 0)
608 return ret;
609 }
610
611 val = pad->is_enabled << PMIC_GPIO_REG_MASTER_EN_SHIFT;
612
613 ret = pmic_gpio_write(state, pad, PMIC_GPIO_REG_EN_CTL, val);
614
615 return ret;
616 }
617
618 static void pmic_gpio_config_dbg_show(struct pinctrl_dev *pctldev,
619 struct seq_file *s, unsigned pin)
620 {
621 struct pmic_gpio_state *state = pinctrl_dev_get_drvdata(pctldev);
622 struct pmic_gpio_pad *pad;
623 int ret, val, function;
624
625 static const char *const biases[] = {
626 "pull-up 30uA", "pull-up 1.5uA", "pull-up 31.5uA",
627 "pull-up 1.5uA + 30uA boost", "pull-down 10uA", "no pull"
628 };
629 static const char *const buffer_types[] = {
630 "push-pull", "open-drain", "open-source"
631 };
632 static const char *const strengths[] = {
633 "no", "high", "medium", "low"
634 };
635
636 pad = pctldev->desc->pins[pin].drv_data;
637
638 seq_printf(s, " gpio%-2d:", pin + PMIC_GPIO_PHYSICAL_OFFSET);
639
640 val = pmic_gpio_read(state, pad, PMIC_GPIO_REG_EN_CTL);
641
642 if (val < 0 || !(val >> PMIC_GPIO_REG_MASTER_EN_SHIFT)) {
643 seq_puts(s, " ---");
644 } else {
645 if (pad->input_enabled) {
646 ret = pmic_gpio_read(state, pad, PMIC_MPP_REG_RT_STS);
647 if (ret < 0)
648 return;
649
650 ret &= PMIC_MPP_REG_RT_STS_VAL_MASK;
651 pad->out_value = ret;
652 }
653
654
655
656
657 function = pad->function;
658 if (!pad->lv_mv_type &&
659 pad->function >= PMIC_GPIO_FUNC_INDEX_FUNC3)
660 function += PMIC_GPIO_FUNC_INDEX_DTEST1 -
661 PMIC_GPIO_FUNC_INDEX_FUNC3;
662
663 if (pad->analog_pass)
664 seq_puts(s, " analog-pass");
665 else
666 seq_printf(s, " %-4s",
667 pad->output_enabled ? "out" : "in");
668 seq_printf(s, " %-4s", pad->out_value ? "high" : "low");
669 seq_printf(s, " %-7s", pmic_gpio_functions[function]);
670 seq_printf(s, " vin-%d", pad->power_source);
671 seq_printf(s, " %-27s", biases[pad->pullup]);
672 seq_printf(s, " %-10s", buffer_types[pad->buffer_type]);
673 seq_printf(s, " %-7s", strengths[pad->strength]);
674 seq_printf(s, " atest-%d", pad->atest);
675 seq_printf(s, " dtest-%d", pad->dtest_buffer);
676 }
677 }
678
679 static const struct pinconf_ops pmic_gpio_pinconf_ops = {
680 .is_generic = true,
681 .pin_config_group_get = pmic_gpio_config_get,
682 .pin_config_group_set = pmic_gpio_config_set,
683 .pin_config_group_dbg_show = pmic_gpio_config_dbg_show,
684 };
685
686 static int pmic_gpio_direction_input(struct gpio_chip *chip, unsigned pin)
687 {
688 struct pmic_gpio_state *state = gpiochip_get_data(chip);
689 unsigned long config;
690
691 config = pinconf_to_config_packed(PIN_CONFIG_INPUT_ENABLE, 1);
692
693 return pmic_gpio_config_set(state->ctrl, pin, &config, 1);
694 }
695
696 static int pmic_gpio_direction_output(struct gpio_chip *chip,
697 unsigned pin, int val)
698 {
699 struct pmic_gpio_state *state = gpiochip_get_data(chip);
700 unsigned long config;
701
702 config = pinconf_to_config_packed(PIN_CONFIG_OUTPUT, val);
703
704 return pmic_gpio_config_set(state->ctrl, pin, &config, 1);
705 }
706
707 static int pmic_gpio_get(struct gpio_chip *chip, unsigned pin)
708 {
709 struct pmic_gpio_state *state = gpiochip_get_data(chip);
710 struct pmic_gpio_pad *pad;
711 int ret;
712
713 pad = state->ctrl->desc->pins[pin].drv_data;
714
715 if (!pad->is_enabled)
716 return -EINVAL;
717
718 if (pad->input_enabled) {
719 ret = pmic_gpio_read(state, pad, PMIC_MPP_REG_RT_STS);
720 if (ret < 0)
721 return ret;
722
723 pad->out_value = ret & PMIC_MPP_REG_RT_STS_VAL_MASK;
724 }
725
726 return !!pad->out_value;
727 }
728
729 static void pmic_gpio_set(struct gpio_chip *chip, unsigned pin, int value)
730 {
731 struct pmic_gpio_state *state = gpiochip_get_data(chip);
732 unsigned long config;
733
734 config = pinconf_to_config_packed(PIN_CONFIG_OUTPUT, value);
735
736 pmic_gpio_config_set(state->ctrl, pin, &config, 1);
737 }
738
739 static int pmic_gpio_of_xlate(struct gpio_chip *chip,
740 const struct of_phandle_args *gpio_desc,
741 u32 *flags)
742 {
743 if (chip->of_gpio_n_cells < 2)
744 return -EINVAL;
745
746 if (flags)
747 *flags = gpio_desc->args[1];
748
749 return gpio_desc->args[0] - PMIC_GPIO_PHYSICAL_OFFSET;
750 }
751
752 static void pmic_gpio_dbg_show(struct seq_file *s, struct gpio_chip *chip)
753 {
754 struct pmic_gpio_state *state = gpiochip_get_data(chip);
755 unsigned i;
756
757 for (i = 0; i < chip->ngpio; i++) {
758 pmic_gpio_config_dbg_show(state->ctrl, s, i);
759 seq_puts(s, "\n");
760 }
761 }
762
763 static const struct gpio_chip pmic_gpio_gpio_template = {
764 .direction_input = pmic_gpio_direction_input,
765 .direction_output = pmic_gpio_direction_output,
766 .get = pmic_gpio_get,
767 .set = pmic_gpio_set,
768 .request = gpiochip_generic_request,
769 .free = gpiochip_generic_free,
770 .of_xlate = pmic_gpio_of_xlate,
771 .dbg_show = pmic_gpio_dbg_show,
772 };
773
774 static int pmic_gpio_populate(struct pmic_gpio_state *state,
775 struct pmic_gpio_pad *pad)
776 {
777 int type, subtype, val, dir;
778
779 type = pmic_gpio_read(state, pad, PMIC_GPIO_REG_TYPE);
780 if (type < 0)
781 return type;
782
783 if (type != PMIC_GPIO_TYPE) {
784 dev_err(state->dev, "incorrect block type 0x%x at 0x%x\n",
785 type, pad->base);
786 return -ENODEV;
787 }
788
789 subtype = pmic_gpio_read(state, pad, PMIC_GPIO_REG_SUBTYPE);
790 if (subtype < 0)
791 return subtype;
792
793 switch (subtype) {
794 case PMIC_GPIO_SUBTYPE_GPIO_4CH:
795 pad->have_buffer = true;
796
797 case PMIC_GPIO_SUBTYPE_GPIOC_4CH:
798 pad->num_sources = 4;
799 break;
800 case PMIC_GPIO_SUBTYPE_GPIO_8CH:
801 pad->have_buffer = true;
802
803 case PMIC_GPIO_SUBTYPE_GPIOC_8CH:
804 pad->num_sources = 8;
805 break;
806 case PMIC_GPIO_SUBTYPE_GPIO_LV:
807 pad->num_sources = 1;
808 pad->have_buffer = true;
809 pad->lv_mv_type = true;
810 break;
811 case PMIC_GPIO_SUBTYPE_GPIO_MV:
812 pad->num_sources = 2;
813 pad->have_buffer = true;
814 pad->lv_mv_type = true;
815 break;
816 default:
817 dev_err(state->dev, "unknown GPIO type 0x%x\n", subtype);
818 return -ENODEV;
819 }
820
821 if (pad->lv_mv_type) {
822 val = pmic_gpio_read(state, pad,
823 PMIC_GPIO_REG_LV_MV_DIG_OUT_SOURCE_CTL);
824 if (val < 0)
825 return val;
826
827 pad->out_value = !!(val & PMIC_GPIO_LV_MV_OUTPUT_INVERT);
828 pad->function = val & PMIC_GPIO_LV_MV_OUTPUT_SOURCE_SEL_MASK;
829
830 val = pmic_gpio_read(state, pad, PMIC_GPIO_REG_MODE_CTL);
831 if (val < 0)
832 return val;
833
834 dir = val & PMIC_GPIO_REG_LV_MV_MODE_DIR_MASK;
835 } else {
836 val = pmic_gpio_read(state, pad, PMIC_GPIO_REG_MODE_CTL);
837 if (val < 0)
838 return val;
839
840 pad->out_value = val & PMIC_GPIO_REG_MODE_VALUE_SHIFT;
841
842 dir = val >> PMIC_GPIO_REG_MODE_DIR_SHIFT;
843 dir &= PMIC_GPIO_REG_MODE_DIR_MASK;
844 pad->function = val >> PMIC_GPIO_REG_MODE_FUNCTION_SHIFT;
845 pad->function &= PMIC_GPIO_REG_MODE_FUNCTION_MASK;
846 }
847
848 switch (dir) {
849 case PMIC_GPIO_MODE_DIGITAL_INPUT:
850 pad->input_enabled = true;
851 pad->output_enabled = false;
852 break;
853 case PMIC_GPIO_MODE_DIGITAL_OUTPUT:
854 pad->input_enabled = false;
855 pad->output_enabled = true;
856 break;
857 case PMIC_GPIO_MODE_DIGITAL_INPUT_OUTPUT:
858 pad->input_enabled = true;
859 pad->output_enabled = true;
860 break;
861 case PMIC_GPIO_MODE_ANALOG_PASS_THRU:
862 if (!pad->lv_mv_type)
863 return -ENODEV;
864 pad->analog_pass = true;
865 break;
866 default:
867 dev_err(state->dev, "unknown GPIO direction\n");
868 return -ENODEV;
869 }
870
871 val = pmic_gpio_read(state, pad, PMIC_GPIO_REG_DIG_VIN_CTL);
872 if (val < 0)
873 return val;
874
875 pad->power_source = val >> PMIC_GPIO_REG_VIN_SHIFT;
876 pad->power_source &= PMIC_GPIO_REG_VIN_MASK;
877
878 val = pmic_gpio_read(state, pad, PMIC_GPIO_REG_DIG_PULL_CTL);
879 if (val < 0)
880 return val;
881
882 pad->pullup = val >> PMIC_GPIO_REG_PULL_SHIFT;
883 pad->pullup &= PMIC_GPIO_REG_PULL_MASK;
884
885 val = pmic_gpio_read(state, pad, PMIC_GPIO_REG_DIG_IN_CTL);
886 if (val < 0)
887 return val;
888
889 if (pad->lv_mv_type && (val & PMIC_GPIO_LV_MV_DIG_IN_DTEST_EN))
890 pad->dtest_buffer =
891 (val & PMIC_GPIO_LV_MV_DIG_IN_DTEST_SEL_MASK) + 1;
892 else if (!pad->lv_mv_type)
893 pad->dtest_buffer = ffs(val);
894 else
895 pad->dtest_buffer = 0;
896
897 val = pmic_gpio_read(state, pad, PMIC_GPIO_REG_DIG_OUT_CTL);
898 if (val < 0)
899 return val;
900
901 pad->strength = val >> PMIC_GPIO_REG_OUT_STRENGTH_SHIFT;
902 pad->strength &= PMIC_GPIO_REG_OUT_STRENGTH_MASK;
903
904 pad->buffer_type = val >> PMIC_GPIO_REG_OUT_TYPE_SHIFT;
905 pad->buffer_type &= PMIC_GPIO_REG_OUT_TYPE_MASK;
906
907 if (pad->lv_mv_type) {
908 val = pmic_gpio_read(state, pad,
909 PMIC_GPIO_REG_LV_MV_ANA_PASS_THRU_SEL);
910 if (val < 0)
911 return val;
912 pad->atest = (val & PMIC_GPIO_LV_MV_ANA_MUX_SEL_MASK) + 1;
913 }
914
915
916 pad->is_enabled = true;
917 return 0;
918 }
919
920 static struct irq_chip pmic_gpio_irq_chip = {
921 .name = "spmi-gpio",
922 .irq_ack = irq_chip_ack_parent,
923 .irq_mask = irq_chip_mask_parent,
924 .irq_unmask = irq_chip_unmask_parent,
925 .irq_set_type = irq_chip_set_type_parent,
926 .irq_set_wake = irq_chip_set_wake_parent,
927 .flags = IRQCHIP_MASK_ON_SUSPEND,
928 };
929
930 static int pmic_gpio_domain_translate(struct irq_domain *domain,
931 struct irq_fwspec *fwspec,
932 unsigned long *hwirq,
933 unsigned int *type)
934 {
935 struct pmic_gpio_state *state = container_of(domain->host_data,
936 struct pmic_gpio_state,
937 chip);
938
939 if (fwspec->param_count != 2 ||
940 fwspec->param[0] < 1 || fwspec->param[0] > state->chip.ngpio)
941 return -EINVAL;
942
943 *hwirq = fwspec->param[0] - PMIC_GPIO_PHYSICAL_OFFSET;
944 *type = fwspec->param[1];
945
946 return 0;
947 }
948
949 static unsigned int pmic_gpio_child_offset_to_irq(struct gpio_chip *chip,
950 unsigned int offset)
951 {
952 return offset + PMIC_GPIO_PHYSICAL_OFFSET;
953 }
954
955 static int pmic_gpio_child_to_parent_hwirq(struct gpio_chip *chip,
956 unsigned int child_hwirq,
957 unsigned int child_type,
958 unsigned int *parent_hwirq,
959 unsigned int *parent_type)
960 {
961 *parent_hwirq = child_hwirq + 0xc0;
962 *parent_type = child_type;
963
964 return 0;
965 }
966
967 static int pmic_gpio_probe(struct platform_device *pdev)
968 {
969 struct irq_domain *parent_domain;
970 struct device_node *parent_node;
971 struct device *dev = &pdev->dev;
972 struct pinctrl_pin_desc *pindesc;
973 struct pinctrl_desc *pctrldesc;
974 struct pmic_gpio_pad *pad, *pads;
975 struct pmic_gpio_state *state;
976 struct gpio_irq_chip *girq;
977 int ret, npins, i;
978 u32 reg;
979
980 ret = of_property_read_u32(dev->of_node, "reg", ®);
981 if (ret < 0) {
982 dev_err(dev, "missing base address");
983 return ret;
984 }
985
986 npins = (uintptr_t) device_get_match_data(&pdev->dev);
987
988 state = devm_kzalloc(dev, sizeof(*state), GFP_KERNEL);
989 if (!state)
990 return -ENOMEM;
991
992 platform_set_drvdata(pdev, state);
993
994 state->dev = &pdev->dev;
995 state->map = dev_get_regmap(dev->parent, NULL);
996
997 pindesc = devm_kcalloc(dev, npins, sizeof(*pindesc), GFP_KERNEL);
998 if (!pindesc)
999 return -ENOMEM;
1000
1001 pads = devm_kcalloc(dev, npins, sizeof(*pads), GFP_KERNEL);
1002 if (!pads)
1003 return -ENOMEM;
1004
1005 pctrldesc = devm_kzalloc(dev, sizeof(*pctrldesc), GFP_KERNEL);
1006 if (!pctrldesc)
1007 return -ENOMEM;
1008
1009 pctrldesc->pctlops = &pmic_gpio_pinctrl_ops;
1010 pctrldesc->pmxops = &pmic_gpio_pinmux_ops;
1011 pctrldesc->confops = &pmic_gpio_pinconf_ops;
1012 pctrldesc->owner = THIS_MODULE;
1013 pctrldesc->name = dev_name(dev);
1014 pctrldesc->pins = pindesc;
1015 pctrldesc->npins = npins;
1016 pctrldesc->num_custom_params = ARRAY_SIZE(pmic_gpio_bindings);
1017 pctrldesc->custom_params = pmic_gpio_bindings;
1018 #ifdef CONFIG_DEBUG_FS
1019 pctrldesc->custom_conf_items = pmic_conf_items;
1020 #endif
1021
1022 for (i = 0; i < npins; i++, pindesc++) {
1023 pad = &pads[i];
1024 pindesc->drv_data = pad;
1025 pindesc->number = i;
1026 pindesc->name = pmic_gpio_groups[i];
1027
1028 pad->base = reg + i * PMIC_GPIO_ADDRESS_RANGE;
1029
1030 ret = pmic_gpio_populate(state, pad);
1031 if (ret < 0)
1032 return ret;
1033 }
1034
1035 state->chip = pmic_gpio_gpio_template;
1036 state->chip.parent = dev;
1037 state->chip.base = -1;
1038 state->chip.ngpio = npins;
1039 state->chip.label = dev_name(dev);
1040 state->chip.of_gpio_n_cells = 2;
1041 state->chip.can_sleep = false;
1042
1043 state->ctrl = devm_pinctrl_register(dev, pctrldesc, state);
1044 if (IS_ERR(state->ctrl))
1045 return PTR_ERR(state->ctrl);
1046
1047 parent_node = of_irq_find_parent(state->dev->of_node);
1048 if (!parent_node)
1049 return -ENXIO;
1050
1051 parent_domain = irq_find_host(parent_node);
1052 of_node_put(parent_node);
1053 if (!parent_domain)
1054 return -ENXIO;
1055
1056 girq = &state->chip.irq;
1057 girq->chip = &pmic_gpio_irq_chip;
1058 girq->default_type = IRQ_TYPE_NONE;
1059 girq->handler = handle_level_irq;
1060 girq->fwnode = of_node_to_fwnode(state->dev->of_node);
1061 girq->parent_domain = parent_domain;
1062 girq->child_to_parent_hwirq = pmic_gpio_child_to_parent_hwirq;
1063 girq->populate_parent_fwspec = gpiochip_populate_parent_fwspec_fourcell;
1064 girq->child_offset_to_irq = pmic_gpio_child_offset_to_irq;
1065 girq->child_irq_domain_ops.translate = pmic_gpio_domain_translate;
1066
1067 ret = gpiochip_add_data(&state->chip, state);
1068 if (ret) {
1069 dev_err(state->dev, "can't add gpio chip\n");
1070 return ret;
1071 }
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083 if (!of_property_read_bool(dev->of_node, "gpio-ranges")) {
1084 ret = gpiochip_add_pin_range(&state->chip, dev_name(dev), 0, 0,
1085 npins);
1086 if (ret) {
1087 dev_err(dev, "failed to add pin range\n");
1088 goto err_range;
1089 }
1090 }
1091
1092 return 0;
1093
1094 err_range:
1095 gpiochip_remove(&state->chip);
1096 return ret;
1097 }
1098
1099 static int pmic_gpio_remove(struct platform_device *pdev)
1100 {
1101 struct pmic_gpio_state *state = platform_get_drvdata(pdev);
1102
1103 gpiochip_remove(&state->chip);
1104 return 0;
1105 }
1106
1107 static const struct of_device_id pmic_gpio_of_match[] = {
1108 { .compatible = "qcom,pm8005-gpio", .data = (void *) 4 },
1109 { .compatible = "qcom,pm8916-gpio", .data = (void *) 4 },
1110 { .compatible = "qcom,pm8941-gpio", .data = (void *) 36 },
1111 { .compatible = "qcom,pm8994-gpio", .data = (void *) 22 },
1112 { .compatible = "qcom,pmi8994-gpio", .data = (void *) 10 },
1113 { .compatible = "qcom,pm8998-gpio", .data = (void *) 26 },
1114 { .compatible = "qcom,pmi8998-gpio", .data = (void *) 14 },
1115 { .compatible = "qcom,pma8084-gpio", .data = (void *) 22 },
1116
1117 { .compatible = "qcom,pms405-gpio", .data = (void *) 12 },
1118
1119 { .compatible = "qcom,pm8150-gpio", .data = (void *) 10 },
1120
1121 { .compatible = "qcom,pm8150b-gpio", .data = (void *) 12 },
1122
1123 { .compatible = "qcom,pm8150l-gpio", .data = (void *) 12 },
1124 { },
1125 };
1126
1127 MODULE_DEVICE_TABLE(of, pmic_gpio_of_match);
1128
1129 static struct platform_driver pmic_gpio_driver = {
1130 .driver = {
1131 .name = "qcom-spmi-gpio",
1132 .of_match_table = pmic_gpio_of_match,
1133 },
1134 .probe = pmic_gpio_probe,
1135 .remove = pmic_gpio_remove,
1136 };
1137
1138 module_platform_driver(pmic_gpio_driver);
1139
1140 MODULE_AUTHOR("Ivan T. Ivanov <iivanov@mm-sol.com>");
1141 MODULE_DESCRIPTION("Qualcomm SPMI PMIC GPIO pin control driver");
1142 MODULE_ALIAS("platform:qcom-spmi-gpio");
1143 MODULE_LICENSE("GPL v2");