Merge branch 'misc' of git://git.kernel.org/pub/scm/linux/kernel/git/mmarek/kbuild
[linux-2.6-block.git] / drivers / pinctrl / qcom / pinctrl-ssbi-mpp.c
1 /*
2  * Copyright (c) 2015, Sony Mobile Communications AB.
3  * Copyright (c) 2013, The Linux Foundation. All rights reserved.
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 and
7  * only version 2 as published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  */
14
15 #include <linux/module.h>
16 #include <linux/platform_device.h>
17 #include <linux/pinctrl/pinctrl.h>
18 #include <linux/pinctrl/pinmux.h>
19 #include <linux/pinctrl/pinconf.h>
20 #include <linux/pinctrl/pinconf-generic.h>
21 #include <linux/slab.h>
22 #include <linux/regmap.h>
23 #include <linux/gpio.h>
24 #include <linux/interrupt.h>
25 #include <linux/of_device.h>
26 #include <linux/of_irq.h>
27
28 #include <dt-bindings/pinctrl/qcom,pmic-mpp.h>
29
30 #include "../core.h"
31 #include "../pinctrl-utils.h"
32
33 /* MPP registers */
34 #define SSBI_REG_ADDR_MPP_BASE          0x50
35 #define SSBI_REG_ADDR_MPP(n)            (SSBI_REG_ADDR_MPP_BASE + n)
36
37 /* MPP Type: type */
38 #define PM8XXX_MPP_TYPE_D_INPUT         0
39 #define PM8XXX_MPP_TYPE_D_OUTPUT        1
40 #define PM8XXX_MPP_TYPE_D_BI_DIR        2
41 #define PM8XXX_MPP_TYPE_A_INPUT         3
42 #define PM8XXX_MPP_TYPE_A_OUTPUT        4
43 #define PM8XXX_MPP_TYPE_SINK            5
44 #define PM8XXX_MPP_TYPE_DTEST_SINK      6
45 #define PM8XXX_MPP_TYPE_DTEST_OUTPUT    7
46
47 /* Digital Input: control */
48 #define PM8XXX_MPP_DIN_TO_INT           0
49 #define PM8XXX_MPP_DIN_TO_DBUS1         1
50 #define PM8XXX_MPP_DIN_TO_DBUS2         2
51 #define PM8XXX_MPP_DIN_TO_DBUS3         3
52
53 /* Digital Output: control */
54 #define PM8XXX_MPP_DOUT_CTRL_LOW        0
55 #define PM8XXX_MPP_DOUT_CTRL_HIGH       1
56 #define PM8XXX_MPP_DOUT_CTRL_MPP        2
57 #define PM8XXX_MPP_DOUT_CTRL_INV_MPP    3
58
59 /* Bidirectional: control */
60 #define PM8XXX_MPP_BI_PULLUP_1KOHM      0
61 #define PM8XXX_MPP_BI_PULLUP_OPEN       1
62 #define PM8XXX_MPP_BI_PULLUP_10KOHM     2
63 #define PM8XXX_MPP_BI_PULLUP_30KOHM     3
64
65 /* Analog Output: control */
66 #define PM8XXX_MPP_AOUT_CTRL_DISABLE            0
67 #define PM8XXX_MPP_AOUT_CTRL_ENABLE             1
68 #define PM8XXX_MPP_AOUT_CTRL_MPP_HIGH_EN        2
69 #define PM8XXX_MPP_AOUT_CTRL_MPP_LOW_EN         3
70
71 /* Current Sink: control */
72 #define PM8XXX_MPP_CS_CTRL_DISABLE      0
73 #define PM8XXX_MPP_CS_CTRL_ENABLE       1
74 #define PM8XXX_MPP_CS_CTRL_MPP_HIGH_EN  2
75 #define PM8XXX_MPP_CS_CTRL_MPP_LOW_EN   3
76
77 /* DTEST Current Sink: control */
78 #define PM8XXX_MPP_DTEST_CS_CTRL_EN1    0
79 #define PM8XXX_MPP_DTEST_CS_CTRL_EN2    1
80 #define PM8XXX_MPP_DTEST_CS_CTRL_EN3    2
81 #define PM8XXX_MPP_DTEST_CS_CTRL_EN4    3
82
83 /* DTEST Digital Output: control */
84 #define PM8XXX_MPP_DTEST_DBUS1          0
85 #define PM8XXX_MPP_DTEST_DBUS2          1
86 #define PM8XXX_MPP_DTEST_DBUS3          2
87 #define PM8XXX_MPP_DTEST_DBUS4          3
88
89 /* custom pinconf parameters */
90 #define PM8XXX_CONFIG_AMUX              (PIN_CONFIG_END + 1)
91 #define PM8XXX_CONFIG_DTEST_SELECTOR    (PIN_CONFIG_END + 2)
92 #define PM8XXX_CONFIG_ALEVEL            (PIN_CONFIG_END + 3)
93 #define PM8XXX_CONFIG_PAIRED            (PIN_CONFIG_END + 4)
94
95 /**
96  * struct pm8xxx_pin_data - dynamic configuration for a pin
97  * @reg:                address of the control register
98  * @irq:                IRQ from the PMIC interrupt controller
99  * @mode:               operating mode for the pin (digital, analog or current sink)
100  * @input:              pin is input
101  * @output:             pin is output
102  * @high_z:             pin is floating
103  * @paired:             mpp operates in paired mode
104  * @output_value:       logical output value of the mpp
105  * @power_source:       selected power source
106  * @dtest:              DTEST route selector
107  * @amux:               input muxing in analog mode
108  * @aout_level:         selector of the output in analog mode
109  * @drive_strength:     drive strength of the current sink
110  * @pullup:             pull up value, when in digital bidirectional mode
111  */
112 struct pm8xxx_pin_data {
113         unsigned reg;
114         int irq;
115
116         u8 mode;
117
118         bool input;
119         bool output;
120         bool high_z;
121         bool paired;
122         bool output_value;
123
124         u8 power_source;
125         u8 dtest;
126         u8 amux;
127         u8 aout_level;
128         u8 drive_strength;
129         unsigned pullup;
130 };
131
132 struct pm8xxx_mpp {
133         struct device *dev;
134         struct regmap *regmap;
135         struct pinctrl_dev *pctrl;
136         struct gpio_chip chip;
137
138         struct pinctrl_desc desc;
139         unsigned npins;
140 };
141
142 static const struct pinconf_generic_params pm8xxx_mpp_bindings[] = {
143         {"qcom,amux-route",     PM8XXX_CONFIG_AMUX,             0},
144         {"qcom,analog-level",   PM8XXX_CONFIG_ALEVEL,           0},
145         {"qcom,dtest",          PM8XXX_CONFIG_DTEST_SELECTOR,   0},
146         {"qcom,paired",         PM8XXX_CONFIG_PAIRED,           0},
147 };
148
149 #ifdef CONFIG_DEBUG_FS
150 static const struct pin_config_item pm8xxx_conf_items[] = {
151         PCONFDUMP(PM8XXX_CONFIG_AMUX, "analog mux", NULL, true),
152         PCONFDUMP(PM8XXX_CONFIG_ALEVEL, "analog level", NULL, true),
153         PCONFDUMP(PM8XXX_CONFIG_DTEST_SELECTOR, "dtest", NULL, true),
154         PCONFDUMP(PM8XXX_CONFIG_PAIRED, "paired", NULL, false),
155 };
156 #endif
157
158 #define PM8XXX_MAX_MPPS 12
159 static const char * const pm8xxx_groups[PM8XXX_MAX_MPPS] = {
160         "mpp1", "mpp2", "mpp3", "mpp4", "mpp5", "mpp6", "mpp7", "mpp8",
161         "mpp9", "mpp10", "mpp11", "mpp12",
162 };
163
164 #define PM8XXX_MPP_DIGITAL      0
165 #define PM8XXX_MPP_ANALOG       1
166 #define PM8XXX_MPP_SINK         2
167
168 static const char * const pm8xxx_mpp_functions[] = {
169         "digital", "analog", "sink",
170 };
171
172 static int pm8xxx_mpp_update(struct pm8xxx_mpp *pctrl,
173                              struct pm8xxx_pin_data *pin)
174 {
175         unsigned level;
176         unsigned ctrl;
177         unsigned type;
178         int ret;
179         u8 val;
180
181         switch (pin->mode) {
182         case PM8XXX_MPP_DIGITAL:
183                 if (pin->dtest) {
184                         type = PM8XXX_MPP_TYPE_DTEST_OUTPUT;
185                         ctrl = pin->dtest - 1;
186                 } else if (pin->input && pin->output) {
187                         type = PM8XXX_MPP_TYPE_D_BI_DIR;
188                         if (pin->high_z)
189                                 ctrl = PM8XXX_MPP_BI_PULLUP_OPEN;
190                         else if (pin->pullup == 600)
191                                 ctrl = PM8XXX_MPP_BI_PULLUP_1KOHM;
192                         else if (pin->pullup == 10000)
193                                 ctrl = PM8XXX_MPP_BI_PULLUP_10KOHM;
194                         else
195                                 ctrl = PM8XXX_MPP_BI_PULLUP_30KOHM;
196                 } else if (pin->input) {
197                         type = PM8XXX_MPP_TYPE_D_INPUT;
198                         if (pin->dtest)
199                                 ctrl = pin->dtest;
200                         else
201                                 ctrl = PM8XXX_MPP_DIN_TO_INT;
202                 } else {
203                         type = PM8XXX_MPP_TYPE_D_OUTPUT;
204                         ctrl = !!pin->output_value;
205                         if (pin->paired)
206                                 ctrl |= BIT(1);
207                 }
208
209                 level = pin->power_source;
210                 break;
211         case PM8XXX_MPP_ANALOG:
212                 if (pin->output) {
213                         type = PM8XXX_MPP_TYPE_A_OUTPUT;
214                         level = pin->aout_level;
215                         ctrl = pin->output_value;
216                         if (pin->paired)
217                                 ctrl |= BIT(1);
218                 } else {
219                         type = PM8XXX_MPP_TYPE_A_INPUT;
220                         level = pin->amux;
221                         ctrl = 0;
222                 }
223                 break;
224         case PM8XXX_MPP_SINK:
225                 level = (pin->drive_strength / 5) - 1;
226                 if (pin->dtest) {
227                         type = PM8XXX_MPP_TYPE_DTEST_SINK;
228                         ctrl = pin->dtest - 1;
229                 } else {
230                         type = PM8XXX_MPP_TYPE_SINK;
231                         ctrl = pin->output_value;
232                         if (pin->paired)
233                                 ctrl |= BIT(1);
234                 }
235                 break;
236         default:
237                 return -EINVAL;
238         }
239
240         val = type << 5 | level << 2 | ctrl;
241         ret = regmap_write(pctrl->regmap, pin->reg, val);
242         if (ret)
243                 dev_err(pctrl->dev, "failed to write register\n");
244
245         return ret;
246 }
247
248 static int pm8xxx_get_groups_count(struct pinctrl_dev *pctldev)
249 {
250         struct pm8xxx_mpp *pctrl = pinctrl_dev_get_drvdata(pctldev);
251
252         return pctrl->npins;
253 }
254
255 static const char *pm8xxx_get_group_name(struct pinctrl_dev *pctldev,
256                                          unsigned group)
257 {
258         return pm8xxx_groups[group];
259 }
260
261
262 static int pm8xxx_get_group_pins(struct pinctrl_dev *pctldev,
263                                  unsigned group,
264                                  const unsigned **pins,
265                                  unsigned *num_pins)
266 {
267         struct pm8xxx_mpp *pctrl = pinctrl_dev_get_drvdata(pctldev);
268
269         *pins = &pctrl->desc.pins[group].number;
270         *num_pins = 1;
271
272         return 0;
273 }
274
275 static const struct pinctrl_ops pm8xxx_pinctrl_ops = {
276         .get_groups_count       = pm8xxx_get_groups_count,
277         .get_group_name         = pm8xxx_get_group_name,
278         .get_group_pins         = pm8xxx_get_group_pins,
279         .dt_node_to_map         = pinconf_generic_dt_node_to_map_group,
280         .dt_free_map            = pinctrl_utils_dt_free_map,
281 };
282
283 static int pm8xxx_get_functions_count(struct pinctrl_dev *pctldev)
284 {
285         return ARRAY_SIZE(pm8xxx_mpp_functions);
286 }
287
288 static const char *pm8xxx_get_function_name(struct pinctrl_dev *pctldev,
289                                             unsigned function)
290 {
291         return pm8xxx_mpp_functions[function];
292 }
293
294 static int pm8xxx_get_function_groups(struct pinctrl_dev *pctldev,
295                                       unsigned function,
296                                       const char * const **groups,
297                                       unsigned * const num_groups)
298 {
299         struct pm8xxx_mpp *pctrl = pinctrl_dev_get_drvdata(pctldev);
300
301         *groups = pm8xxx_groups;
302         *num_groups = pctrl->npins;
303         return 0;
304 }
305
306 static int pm8xxx_pinmux_set_mux(struct pinctrl_dev *pctldev,
307                                  unsigned function,
308                                  unsigned group)
309 {
310         struct pm8xxx_mpp *pctrl = pinctrl_dev_get_drvdata(pctldev);
311         struct pm8xxx_pin_data *pin = pctrl->desc.pins[group].drv_data;
312
313         pin->mode = function;
314         pm8xxx_mpp_update(pctrl, pin);
315
316         return 0;
317 }
318
319 static const struct pinmux_ops pm8xxx_pinmux_ops = {
320         .get_functions_count    = pm8xxx_get_functions_count,
321         .get_function_name      = pm8xxx_get_function_name,
322         .get_function_groups    = pm8xxx_get_function_groups,
323         .set_mux                = pm8xxx_pinmux_set_mux,
324 };
325
326 static int pm8xxx_pin_config_get(struct pinctrl_dev *pctldev,
327                                  unsigned int offset,
328                                  unsigned long *config)
329 {
330         struct pm8xxx_mpp *pctrl = pinctrl_dev_get_drvdata(pctldev);
331         struct pm8xxx_pin_data *pin = pctrl->desc.pins[offset].drv_data;
332         unsigned param = pinconf_to_config_param(*config);
333         unsigned arg;
334
335         switch (param) {
336         case PIN_CONFIG_BIAS_PULL_UP:
337                 arg = pin->pullup;
338                 break;
339         case PIN_CONFIG_BIAS_HIGH_IMPEDANCE:
340                 arg = pin->high_z;
341                 break;
342         case PIN_CONFIG_INPUT_ENABLE:
343                 arg = pin->input;
344                 break;
345         case PIN_CONFIG_OUTPUT:
346                 arg = pin->output_value;
347                 break;
348         case PIN_CONFIG_POWER_SOURCE:
349                 arg = pin->power_source;
350                 break;
351         case PIN_CONFIG_DRIVE_STRENGTH:
352                 arg = pin->drive_strength;
353                 break;
354         case PM8XXX_CONFIG_DTEST_SELECTOR:
355                 arg = pin->dtest;
356                 break;
357         case PM8XXX_CONFIG_AMUX:
358                 arg = pin->amux;
359                 break;
360         case PM8XXX_CONFIG_ALEVEL:
361                 arg = pin->aout_level;
362                 break;
363         case PM8XXX_CONFIG_PAIRED:
364                 arg = pin->paired;
365                 break;
366         default:
367                 return -EINVAL;
368         }
369
370         *config = pinconf_to_config_packed(param, arg);
371
372         return 0;
373 }
374
375 static int pm8xxx_pin_config_set(struct pinctrl_dev *pctldev,
376                                  unsigned int offset,
377                                  unsigned long *configs,
378                                  unsigned num_configs)
379 {
380         struct pm8xxx_mpp *pctrl = pinctrl_dev_get_drvdata(pctldev);
381         struct pm8xxx_pin_data *pin = pctrl->desc.pins[offset].drv_data;
382         unsigned param;
383         unsigned arg;
384         unsigned i;
385
386         for (i = 0; i < num_configs; i++) {
387                 param = pinconf_to_config_param(configs[i]);
388                 arg = pinconf_to_config_argument(configs[i]);
389
390                 switch (param) {
391                 case PIN_CONFIG_BIAS_PULL_UP:
392                         pin->pullup = arg;
393                         break;
394                 case PIN_CONFIG_BIAS_HIGH_IMPEDANCE:
395                         pin->high_z = true;
396                         break;
397                 case PIN_CONFIG_INPUT_ENABLE:
398                         pin->input = true;
399                         break;
400                 case PIN_CONFIG_OUTPUT:
401                         pin->output = true;
402                         pin->output_value = !!arg;
403                         break;
404                 case PIN_CONFIG_POWER_SOURCE:
405                         pin->power_source = arg;
406                         break;
407                 case PIN_CONFIG_DRIVE_STRENGTH:
408                         pin->drive_strength = arg;
409                         break;
410                 case PM8XXX_CONFIG_DTEST_SELECTOR:
411                         pin->dtest = arg;
412                         break;
413                 case PM8XXX_CONFIG_AMUX:
414                         pin->amux = arg;
415                         break;
416                 case PM8XXX_CONFIG_ALEVEL:
417                         pin->aout_level = arg;
418                         break;
419                 case PM8XXX_CONFIG_PAIRED:
420                         pin->paired = !!arg;
421                         break;
422                 default:
423                         dev_err(pctrl->dev,
424                                 "unsupported config parameter: %x\n",
425                                 param);
426                         return -EINVAL;
427                 }
428         }
429
430         pm8xxx_mpp_update(pctrl, pin);
431
432         return 0;
433 }
434
435 static const struct pinconf_ops pm8xxx_pinconf_ops = {
436         .is_generic = true,
437         .pin_config_group_get = pm8xxx_pin_config_get,
438         .pin_config_group_set = pm8xxx_pin_config_set,
439 };
440
441 static struct pinctrl_desc pm8xxx_pinctrl_desc = {
442         .name = "pm8xxx_mpp",
443         .pctlops = &pm8xxx_pinctrl_ops,
444         .pmxops = &pm8xxx_pinmux_ops,
445         .confops = &pm8xxx_pinconf_ops,
446         .owner = THIS_MODULE,
447 };
448
449 static int pm8xxx_mpp_direction_input(struct gpio_chip *chip,
450                                        unsigned offset)
451 {
452         struct pm8xxx_mpp *pctrl = gpiochip_get_data(chip);
453         struct pm8xxx_pin_data *pin = pctrl->desc.pins[offset].drv_data;
454
455         switch (pin->mode) {
456         case PM8XXX_MPP_DIGITAL:
457                 pin->input = true;
458                 break;
459         case PM8XXX_MPP_ANALOG:
460                 pin->input = true;
461                 pin->output = true;
462                 break;
463         case PM8XXX_MPP_SINK:
464                 return -EINVAL;
465         }
466
467         pm8xxx_mpp_update(pctrl, pin);
468
469         return 0;
470 }
471
472 static int pm8xxx_mpp_direction_output(struct gpio_chip *chip,
473                                         unsigned offset,
474                                         int value)
475 {
476         struct pm8xxx_mpp *pctrl = gpiochip_get_data(chip);
477         struct pm8xxx_pin_data *pin = pctrl->desc.pins[offset].drv_data;
478
479         switch (pin->mode) {
480         case PM8XXX_MPP_DIGITAL:
481                 pin->output = true;
482                 break;
483         case PM8XXX_MPP_ANALOG:
484                 pin->input = false;
485                 pin->output = true;
486                 break;
487         case PM8XXX_MPP_SINK:
488                 pin->input = false;
489                 pin->output = true;
490                 break;
491         }
492
493         pm8xxx_mpp_update(pctrl, pin);
494
495         return 0;
496 }
497
498 static int pm8xxx_mpp_get(struct gpio_chip *chip, unsigned offset)
499 {
500         struct pm8xxx_mpp *pctrl = gpiochip_get_data(chip);
501         struct pm8xxx_pin_data *pin = pctrl->desc.pins[offset].drv_data;
502         bool state;
503         int ret;
504
505         if (!pin->input)
506                 return !!pin->output_value;
507
508         ret = irq_get_irqchip_state(pin->irq, IRQCHIP_STATE_LINE_LEVEL, &state);
509         if (!ret)
510                 ret = !!state;
511
512         return ret;
513 }
514
515 static void pm8xxx_mpp_set(struct gpio_chip *chip, unsigned offset, int value)
516 {
517         struct pm8xxx_mpp *pctrl = gpiochip_get_data(chip);
518         struct pm8xxx_pin_data *pin = pctrl->desc.pins[offset].drv_data;
519
520         pin->output_value = !!value;
521
522         pm8xxx_mpp_update(pctrl, pin);
523 }
524
525 static int pm8xxx_mpp_of_xlate(struct gpio_chip *chip,
526                                 const struct of_phandle_args *gpio_desc,
527                                 u32 *flags)
528 {
529         if (chip->of_gpio_n_cells < 2)
530                 return -EINVAL;
531
532         if (flags)
533                 *flags = gpio_desc->args[1];
534
535         return gpio_desc->args[0] - 1;
536 }
537
538
539 static int pm8xxx_mpp_to_irq(struct gpio_chip *chip, unsigned offset)
540 {
541         struct pm8xxx_mpp *pctrl = gpiochip_get_data(chip);
542         struct pm8xxx_pin_data *pin = pctrl->desc.pins[offset].drv_data;
543
544         return pin->irq;
545 }
546
547 #ifdef CONFIG_DEBUG_FS
548 #include <linux/seq_file.h>
549
550 static void pm8xxx_mpp_dbg_show_one(struct seq_file *s,
551                                   struct pinctrl_dev *pctldev,
552                                   struct gpio_chip *chip,
553                                   unsigned offset,
554                                   unsigned gpio)
555 {
556         struct pm8xxx_mpp *pctrl = gpiochip_get_data(chip);
557         struct pm8xxx_pin_data *pin = pctrl->desc.pins[offset].drv_data;
558
559         static const char * const aout_lvls[] = {
560                 "1v25", "1v25_2", "0v625", "0v3125", "mpp", "abus1", "abus2",
561                 "abus3"
562         };
563
564         static const char * const amuxs[] = {
565                 "amux5", "amux6", "amux7", "amux8", "amux9", "abus1", "abus2",
566                 "abus3",
567         };
568
569         seq_printf(s, " mpp%-2d:", offset + 1);
570
571         switch (pin->mode) {
572         case PM8XXX_MPP_DIGITAL:
573                 seq_puts(s, " digital ");
574                 if (pin->dtest) {
575                         seq_printf(s, "dtest%d\n", pin->dtest);
576                 } else if (pin->input && pin->output) {
577                         if (pin->high_z)
578                                 seq_puts(s, "bi-dir high-z");
579                         else
580                                 seq_printf(s, "bi-dir %dOhm", pin->pullup);
581                 } else if (pin->input) {
582                         if (pin->dtest)
583                                 seq_printf(s, "in dtest%d", pin->dtest);
584                         else
585                                 seq_puts(s, "in gpio");
586                 } else if (pin->output) {
587                         seq_puts(s, "out ");
588
589                         if (!pin->paired) {
590                                 seq_puts(s, pin->output_value ?
591                                          "high" : "low");
592                         } else {
593                                 seq_puts(s, pin->output_value ?
594                                          "inverted" : "follow");
595                         }
596                 }
597                 break;
598         case PM8XXX_MPP_ANALOG:
599                 seq_puts(s, " analog ");
600                 if (pin->output) {
601                         seq_printf(s, "out %s ", aout_lvls[pin->aout_level]);
602                         if (!pin->paired) {
603                                 seq_puts(s, pin->output_value ?
604                                          "high" : "low");
605                         } else {
606                                 seq_puts(s, pin->output_value ?
607                                          "inverted" : "follow");
608                         }
609                 } else {
610                         seq_printf(s, "input mux %s", amuxs[pin->amux]);
611                 }
612                 break;
613         case PM8XXX_MPP_SINK:
614                 seq_printf(s, " sink %dmA ", pin->drive_strength);
615                 if (pin->dtest) {
616                         seq_printf(s, "dtest%d", pin->dtest);
617                 } else {
618                         if (!pin->paired) {
619                                 seq_puts(s, pin->output_value ?
620                                          "high" : "low");
621                         } else {
622                                 seq_puts(s, pin->output_value ?
623                                          "inverted" : "follow");
624                         }
625                 }
626                 break;
627         }
628
629 }
630
631 static void pm8xxx_mpp_dbg_show(struct seq_file *s, struct gpio_chip *chip)
632 {
633         unsigned gpio = chip->base;
634         unsigned i;
635
636         for (i = 0; i < chip->ngpio; i++, gpio++) {
637                 pm8xxx_mpp_dbg_show_one(s, NULL, chip, i, gpio);
638                 seq_puts(s, "\n");
639         }
640 }
641
642 #else
643 #define pm8xxx_mpp_dbg_show NULL
644 #endif
645
646 static struct gpio_chip pm8xxx_mpp_template = {
647         .direction_input = pm8xxx_mpp_direction_input,
648         .direction_output = pm8xxx_mpp_direction_output,
649         .get = pm8xxx_mpp_get,
650         .set = pm8xxx_mpp_set,
651         .of_xlate = pm8xxx_mpp_of_xlate,
652         .to_irq = pm8xxx_mpp_to_irq,
653         .dbg_show = pm8xxx_mpp_dbg_show,
654         .owner = THIS_MODULE,
655 };
656
657 static int pm8xxx_pin_populate(struct pm8xxx_mpp *pctrl,
658                                struct pm8xxx_pin_data *pin)
659 {
660         unsigned int val;
661         unsigned level;
662         unsigned ctrl;
663         unsigned type;
664         int ret;
665
666         ret = regmap_read(pctrl->regmap, pin->reg, &val);
667         if (ret) {
668                 dev_err(pctrl->dev, "failed to read register\n");
669                 return ret;
670         }
671
672         type = (val >> 5) & 7;
673         level = (val >> 2) & 7;
674         ctrl = (val) & 3;
675
676         switch (type) {
677         case PM8XXX_MPP_TYPE_D_INPUT:
678                 pin->mode = PM8XXX_MPP_DIGITAL;
679                 pin->input = true;
680                 pin->power_source = level;
681                 pin->dtest = ctrl;
682                 break;
683         case PM8XXX_MPP_TYPE_D_OUTPUT:
684                 pin->mode = PM8XXX_MPP_DIGITAL;
685                 pin->output = true;
686                 pin->power_source = level;
687                 pin->output_value = !!(ctrl & BIT(0));
688                 pin->paired = !!(ctrl & BIT(1));
689                 break;
690         case PM8XXX_MPP_TYPE_D_BI_DIR:
691                 pin->mode = PM8XXX_MPP_DIGITAL;
692                 pin->input = true;
693                 pin->output = true;
694                 pin->power_source = level;
695                 switch (ctrl) {
696                 case PM8XXX_MPP_BI_PULLUP_1KOHM:
697                         pin->pullup = 600;
698                         break;
699                 case PM8XXX_MPP_BI_PULLUP_OPEN:
700                         pin->high_z = true;
701                         break;
702                 case PM8XXX_MPP_BI_PULLUP_10KOHM:
703                         pin->pullup = 10000;
704                         break;
705                 case PM8XXX_MPP_BI_PULLUP_30KOHM:
706                         pin->pullup = 30000;
707                         break;
708                 }
709                 break;
710         case PM8XXX_MPP_TYPE_A_INPUT:
711                 pin->mode = PM8XXX_MPP_ANALOG;
712                 pin->input = true;
713                 pin->amux = level;
714                 break;
715         case PM8XXX_MPP_TYPE_A_OUTPUT:
716                 pin->mode = PM8XXX_MPP_ANALOG;
717                 pin->output = true;
718                 pin->aout_level = level;
719                 pin->output_value = !!(ctrl & BIT(0));
720                 pin->paired = !!(ctrl & BIT(1));
721                 break;
722         case PM8XXX_MPP_TYPE_SINK:
723                 pin->mode = PM8XXX_MPP_SINK;
724                 pin->drive_strength = 5 * (level + 1);
725                 pin->output_value = !!(ctrl & BIT(0));
726                 pin->paired = !!(ctrl & BIT(1));
727                 break;
728         case PM8XXX_MPP_TYPE_DTEST_SINK:
729                 pin->mode = PM8XXX_MPP_SINK;
730                 pin->dtest = ctrl + 1;
731                 pin->drive_strength = 5 * (level + 1);
732                 break;
733         case PM8XXX_MPP_TYPE_DTEST_OUTPUT:
734                 pin->mode = PM8XXX_MPP_DIGITAL;
735                 pin->power_source = level;
736                 if (ctrl >= 1)
737                         pin->dtest = ctrl;
738                 break;
739         }
740
741         return 0;
742 }
743
744 static const struct of_device_id pm8xxx_mpp_of_match[] = {
745         { .compatible = "qcom,pm8018-mpp" },
746         { .compatible = "qcom,pm8038-mpp" },
747         { .compatible = "qcom,pm8917-mpp" },
748         { .compatible = "qcom,pm8821-mpp" },
749         { .compatible = "qcom,pm8921-mpp" },
750         { .compatible = "qcom,ssbi-mpp" },
751         { },
752 };
753 MODULE_DEVICE_TABLE(of, pm8xxx_mpp_of_match);
754
755 static int pm8xxx_mpp_probe(struct platform_device *pdev)
756 {
757         struct pm8xxx_pin_data *pin_data;
758         struct pinctrl_pin_desc *pins;
759         struct pm8xxx_mpp *pctrl;
760         int ret;
761         int i, npins;
762
763         pctrl = devm_kzalloc(&pdev->dev, sizeof(*pctrl), GFP_KERNEL);
764         if (!pctrl)
765                 return -ENOMEM;
766
767         pctrl->dev = &pdev->dev;
768         npins = platform_irq_count(pdev);
769         if (!npins)
770                 return -EINVAL;
771         if (npins < 0)
772                 return npins;
773         pctrl->npins = npins;
774
775         pctrl->regmap = dev_get_regmap(pdev->dev.parent, NULL);
776         if (!pctrl->regmap) {
777                 dev_err(&pdev->dev, "parent regmap unavailable\n");
778                 return -ENXIO;
779         }
780
781         pctrl->desc = pm8xxx_pinctrl_desc;
782         pctrl->desc.npins = pctrl->npins;
783
784         pins = devm_kcalloc(&pdev->dev,
785                             pctrl->desc.npins,
786                             sizeof(struct pinctrl_pin_desc),
787                             GFP_KERNEL);
788         if (!pins)
789                 return -ENOMEM;
790
791         pin_data = devm_kcalloc(&pdev->dev,
792                                 pctrl->desc.npins,
793                                 sizeof(struct pm8xxx_pin_data),
794                                 GFP_KERNEL);
795         if (!pin_data)
796                 return -ENOMEM;
797
798         for (i = 0; i < pctrl->desc.npins; i++) {
799                 pin_data[i].reg = SSBI_REG_ADDR_MPP(i);
800                 pin_data[i].irq = platform_get_irq(pdev, i);
801                 if (pin_data[i].irq < 0) {
802                         dev_err(&pdev->dev,
803                                 "missing interrupts for pin %d\n", i);
804                         return pin_data[i].irq;
805                 }
806
807                 ret = pm8xxx_pin_populate(pctrl, &pin_data[i]);
808                 if (ret)
809                         return ret;
810
811                 pins[i].number = i;
812                 pins[i].name = pm8xxx_groups[i];
813                 pins[i].drv_data = &pin_data[i];
814         }
815         pctrl->desc.pins = pins;
816
817         pctrl->desc.num_custom_params = ARRAY_SIZE(pm8xxx_mpp_bindings);
818         pctrl->desc.custom_params = pm8xxx_mpp_bindings;
819 #ifdef CONFIG_DEBUG_FS
820         pctrl->desc.custom_conf_items = pm8xxx_conf_items;
821 #endif
822
823         pctrl->pctrl = pinctrl_register(&pctrl->desc, &pdev->dev, pctrl);
824         if (IS_ERR(pctrl->pctrl)) {
825                 dev_err(&pdev->dev, "couldn't register pm8xxx mpp driver\n");
826                 return PTR_ERR(pctrl->pctrl);
827         }
828
829         pctrl->chip = pm8xxx_mpp_template;
830         pctrl->chip.base = -1;
831         pctrl->chip.parent = &pdev->dev;
832         pctrl->chip.of_node = pdev->dev.of_node;
833         pctrl->chip.of_gpio_n_cells = 2;
834         pctrl->chip.label = dev_name(pctrl->dev);
835         pctrl->chip.ngpio = pctrl->npins;
836         ret = gpiochip_add_data(&pctrl->chip, pctrl);
837         if (ret) {
838                 dev_err(&pdev->dev, "failed register gpiochip\n");
839                 goto unregister_pinctrl;
840         }
841
842         ret = gpiochip_add_pin_range(&pctrl->chip,
843                                      dev_name(pctrl->dev),
844                                      0, 0, pctrl->chip.ngpio);
845         if (ret) {
846                 dev_err(pctrl->dev, "failed to add pin range\n");
847                 goto unregister_gpiochip;
848         }
849
850         platform_set_drvdata(pdev, pctrl);
851
852         dev_dbg(&pdev->dev, "Qualcomm pm8xxx mpp driver probed\n");
853
854         return 0;
855
856 unregister_gpiochip:
857         gpiochip_remove(&pctrl->chip);
858
859 unregister_pinctrl:
860         pinctrl_unregister(pctrl->pctrl);
861
862         return ret;
863 }
864
865 static int pm8xxx_mpp_remove(struct platform_device *pdev)
866 {
867         struct pm8xxx_mpp *pctrl = platform_get_drvdata(pdev);
868
869         gpiochip_remove(&pctrl->chip);
870
871         pinctrl_unregister(pctrl->pctrl);
872
873         return 0;
874 }
875
876 static struct platform_driver pm8xxx_mpp_driver = {
877         .driver = {
878                 .name = "qcom-ssbi-mpp",
879                 .of_match_table = pm8xxx_mpp_of_match,
880         },
881         .probe = pm8xxx_mpp_probe,
882         .remove = pm8xxx_mpp_remove,
883 };
884
885 module_platform_driver(pm8xxx_mpp_driver);
886
887 MODULE_AUTHOR("Bjorn Andersson <bjorn.andersson@sonymobile.com>");
888 MODULE_DESCRIPTION("Qualcomm PM8xxx MPP driver");
889 MODULE_LICENSE("GPL v2");