1
2
3
4
5
6
7
8
9
10
11#include <dt-bindings/pinctrl/pinctrl-zynqmp.h>
12
13#include <linux/init.h>
14#include <linux/module.h>
15#include <linux/of_address.h>
16#include <linux/platform_device.h>
17#include <linux/firmware/xlnx-zynqmp.h>
18
19#include <linux/pinctrl/pinmux.h>
20#include <linux/pinctrl/pinconf-generic.h>
21
22#include "core.h"
23#include "pinctrl-utils.h"
24
25#define ZYNQMP_PIN_PREFIX "MIO"
26#define PINCTRL_GET_FUNC_NAME_RESP_LEN 16
27#define MAX_FUNC_NAME_LEN 16
28#define MAX_GROUP_PIN 50
29#define MAX_PIN_GROUPS 50
30#define END_OF_FUNCTIONS "END_OF_FUNCTIONS"
31#define NUM_GROUPS_PER_RESP 6
32
33#define PINCTRL_GET_FUNC_GROUPS_RESP_LEN 12
34#define PINCTRL_GET_PIN_GROUPS_RESP_LEN 12
35#define NA_GROUP 0xFFFF
36#define RESERVED_GROUP 0xFFFE
37
38#define DRIVE_STRENGTH_2MA 2
39#define DRIVE_STRENGTH_4MA 4
40#define DRIVE_STRENGTH_8MA 8
41#define DRIVE_STRENGTH_12MA 12
42
43
44
45
46
47
48
49
50
51
52
53struct zynqmp_pmux_function {
54 char name[MAX_FUNC_NAME_LEN];
55 const char * const *groups;
56 unsigned int ngroups;
57};
58
59
60
61
62
63
64
65
66
67
68
69
70
71struct zynqmp_pinctrl {
72 struct pinctrl_dev *pctrl;
73 const struct zynqmp_pctrl_group *groups;
74 unsigned int ngroups;
75 const struct zynqmp_pmux_function *funcs;
76 unsigned int nfuncs;
77};
78
79
80
81
82
83
84
85struct zynqmp_pctrl_group {
86 const char *name;
87 unsigned int pins[MAX_GROUP_PIN];
88 unsigned int npins;
89};
90
91static struct pinctrl_desc zynqmp_desc;
92
93static int zynqmp_pctrl_get_groups_count(struct pinctrl_dev *pctldev)
94{
95 struct zynqmp_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
96
97 return pctrl->ngroups;
98}
99
100static const char *zynqmp_pctrl_get_group_name(struct pinctrl_dev *pctldev,
101 unsigned int selector)
102{
103 struct zynqmp_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
104
105 return pctrl->groups[selector].name;
106}
107
108static int zynqmp_pctrl_get_group_pins(struct pinctrl_dev *pctldev,
109 unsigned int selector,
110 const unsigned int **pins,
111 unsigned int *npins)
112{
113 struct zynqmp_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
114
115 *pins = pctrl->groups[selector].pins;
116 *npins = pctrl->groups[selector].npins;
117
118 return 0;
119}
120
121static const struct pinctrl_ops zynqmp_pctrl_ops = {
122 .get_groups_count = zynqmp_pctrl_get_groups_count,
123 .get_group_name = zynqmp_pctrl_get_group_name,
124 .get_group_pins = zynqmp_pctrl_get_group_pins,
125 .dt_node_to_map = pinconf_generic_dt_node_to_map_all,
126 .dt_free_map = pinctrl_utils_free_map,
127};
128
129static int zynqmp_pinmux_request_pin(struct pinctrl_dev *pctldev,
130 unsigned int pin)
131{
132 int ret;
133
134 ret = zynqmp_pm_pinctrl_request(pin);
135 if (ret) {
136 dev_err(pctldev->dev, "request failed for pin %u\n", pin);
137 return ret;
138 }
139
140 return 0;
141}
142
143static int zynqmp_pmux_get_functions_count(struct pinctrl_dev *pctldev)
144{
145 struct zynqmp_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
146
147 return pctrl->nfuncs;
148}
149
150static const char *zynqmp_pmux_get_function_name(struct pinctrl_dev *pctldev,
151 unsigned int selector)
152{
153 struct zynqmp_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
154
155 return pctrl->funcs[selector].name;
156}
157
158
159
160
161
162
163
164
165
166
167static int zynqmp_pmux_get_function_groups(struct pinctrl_dev *pctldev,
168 unsigned int selector,
169 const char * const **groups,
170 unsigned * const num_groups)
171{
172 struct zynqmp_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
173
174 *groups = pctrl->funcs[selector].groups;
175 *num_groups = pctrl->funcs[selector].ngroups;
176
177 return 0;
178}
179
180
181
182
183
184
185
186
187
188
189
190
191static int zynqmp_pinmux_set_mux(struct pinctrl_dev *pctldev,
192 unsigned int function,
193 unsigned int group)
194{
195 struct zynqmp_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
196 const struct zynqmp_pctrl_group *pgrp = &pctrl->groups[group];
197 int ret, i;
198
199 for (i = 0; i < pgrp->npins; i++) {
200 unsigned int pin = pgrp->pins[i];
201
202 ret = zynqmp_pm_pinctrl_set_function(pin, function);
203 if (ret) {
204 dev_err(pctldev->dev, "set mux failed for pin %u\n",
205 pin);
206 return ret;
207 }
208 }
209
210 return 0;
211}
212
213static int zynqmp_pinmux_release_pin(struct pinctrl_dev *pctldev,
214 unsigned int pin)
215{
216 int ret;
217
218 ret = zynqmp_pm_pinctrl_release(pin);
219 if (ret) {
220 dev_err(pctldev->dev, "free pin failed for pin %u\n",
221 pin);
222 return ret;
223 }
224
225 return 0;
226}
227
228static const struct pinmux_ops zynqmp_pinmux_ops = {
229 .request = zynqmp_pinmux_request_pin,
230 .get_functions_count = zynqmp_pmux_get_functions_count,
231 .get_function_name = zynqmp_pmux_get_function_name,
232 .get_function_groups = zynqmp_pmux_get_function_groups,
233 .set_mux = zynqmp_pinmux_set_mux,
234 .free = zynqmp_pinmux_release_pin,
235};
236
237
238
239
240
241
242
243
244
245
246
247
248static int zynqmp_pinconf_cfg_get(struct pinctrl_dev *pctldev,
249 unsigned int pin,
250 unsigned long *config)
251{
252 unsigned int arg, param = pinconf_to_config_param(*config);
253 int ret;
254
255 switch (param) {
256 case PIN_CONFIG_SLEW_RATE:
257 param = PM_PINCTRL_CONFIG_SLEW_RATE;
258 ret = zynqmp_pm_pinctrl_get_config(pin, param, &arg);
259 break;
260 case PIN_CONFIG_BIAS_PULL_UP:
261 param = PM_PINCTRL_CONFIG_PULL_CTRL;
262 ret = zynqmp_pm_pinctrl_get_config(pin, param, &arg);
263 if (arg != PM_PINCTRL_BIAS_PULL_UP)
264 return -EINVAL;
265
266 arg = 1;
267 break;
268 case PIN_CONFIG_BIAS_PULL_DOWN:
269 param = PM_PINCTRL_CONFIG_PULL_CTRL;
270 ret = zynqmp_pm_pinctrl_get_config(pin, param, &arg);
271 if (arg != PM_PINCTRL_BIAS_PULL_DOWN)
272 return -EINVAL;
273
274 arg = 1;
275 break;
276 case PIN_CONFIG_BIAS_DISABLE:
277 param = PM_PINCTRL_CONFIG_BIAS_STATUS;
278 ret = zynqmp_pm_pinctrl_get_config(pin, param, &arg);
279 if (arg != PM_PINCTRL_BIAS_DISABLE)
280 return -EINVAL;
281
282 arg = 1;
283 break;
284 case PIN_CONFIG_POWER_SOURCE:
285 param = PM_PINCTRL_CONFIG_VOLTAGE_STATUS;
286 ret = zynqmp_pm_pinctrl_get_config(pin, param, &arg);
287 break;
288 case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
289 param = PM_PINCTRL_CONFIG_SCHMITT_CMOS;
290 ret = zynqmp_pm_pinctrl_get_config(pin, param, &arg);
291 break;
292 case PIN_CONFIG_DRIVE_STRENGTH:
293 param = PM_PINCTRL_CONFIG_DRIVE_STRENGTH;
294 ret = zynqmp_pm_pinctrl_get_config(pin, param, &arg);
295 switch (arg) {
296 case PM_PINCTRL_DRIVE_STRENGTH_2MA:
297 arg = DRIVE_STRENGTH_2MA;
298 break;
299 case PM_PINCTRL_DRIVE_STRENGTH_4MA:
300 arg = DRIVE_STRENGTH_4MA;
301 break;
302 case PM_PINCTRL_DRIVE_STRENGTH_8MA:
303 arg = DRIVE_STRENGTH_8MA;
304 break;
305 case PM_PINCTRL_DRIVE_STRENGTH_12MA:
306 arg = DRIVE_STRENGTH_12MA;
307 break;
308 default:
309
310 dev_warn(pctldev->dev,
311 "Invalid drive strength for pin %d\n",
312 pin);
313 return -EINVAL;
314 }
315 break;
316 default:
317 ret = -ENOTSUPP;
318 break;
319 }
320
321 if (ret)
322 return ret;
323
324 param = pinconf_to_config_param(*config);
325 *config = pinconf_to_config_packed(param, arg);
326
327 return 0;
328}
329
330
331
332
333
334
335
336
337
338
339
340
341
342static int zynqmp_pinconf_cfg_set(struct pinctrl_dev *pctldev,
343 unsigned int pin, unsigned long *configs,
344 unsigned int num_configs)
345{
346 int i, ret;
347
348 for (i = 0; i < num_configs; i++) {
349 unsigned int param = pinconf_to_config_param(configs[i]);
350 unsigned int arg = pinconf_to_config_argument(configs[i]);
351 unsigned int value;
352
353 switch (param) {
354 case PIN_CONFIG_SLEW_RATE:
355 param = PM_PINCTRL_CONFIG_SLEW_RATE;
356 ret = zynqmp_pm_pinctrl_set_config(pin, param, arg);
357 break;
358 case PIN_CONFIG_BIAS_PULL_UP:
359 param = PM_PINCTRL_CONFIG_PULL_CTRL;
360 arg = PM_PINCTRL_BIAS_PULL_UP;
361 ret = zynqmp_pm_pinctrl_set_config(pin, param, arg);
362 break;
363 case PIN_CONFIG_BIAS_PULL_DOWN:
364 param = PM_PINCTRL_CONFIG_PULL_CTRL;
365 arg = PM_PINCTRL_BIAS_PULL_DOWN;
366 ret = zynqmp_pm_pinctrl_set_config(pin, param, arg);
367 break;
368 case PIN_CONFIG_BIAS_DISABLE:
369 param = PM_PINCTRL_CONFIG_BIAS_STATUS;
370 arg = PM_PINCTRL_BIAS_DISABLE;
371 ret = zynqmp_pm_pinctrl_set_config(pin, param, arg);
372 break;
373 case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
374 param = PM_PINCTRL_CONFIG_SCHMITT_CMOS;
375 ret = zynqmp_pm_pinctrl_set_config(pin, param, arg);
376 break;
377 case PIN_CONFIG_DRIVE_STRENGTH:
378 switch (arg) {
379 case DRIVE_STRENGTH_2MA:
380 value = PM_PINCTRL_DRIVE_STRENGTH_2MA;
381 break;
382 case DRIVE_STRENGTH_4MA:
383 value = PM_PINCTRL_DRIVE_STRENGTH_4MA;
384 break;
385 case DRIVE_STRENGTH_8MA:
386 value = PM_PINCTRL_DRIVE_STRENGTH_8MA;
387 break;
388 case DRIVE_STRENGTH_12MA:
389 value = PM_PINCTRL_DRIVE_STRENGTH_12MA;
390 break;
391 default:
392
393 dev_warn(pctldev->dev,
394 "Invalid drive strength for pin %d\n",
395 pin);
396 return -EINVAL;
397 }
398
399 param = PM_PINCTRL_CONFIG_DRIVE_STRENGTH;
400 ret = zynqmp_pm_pinctrl_set_config(pin, param, value);
401 break;
402 case PIN_CONFIG_POWER_SOURCE:
403 param = PM_PINCTRL_CONFIG_VOLTAGE_STATUS;
404 ret = zynqmp_pm_pinctrl_get_config(pin, param, &value);
405
406 if (arg != value)
407 dev_warn(pctldev->dev,
408 "Invalid IO Standard requested for pin %d\n",
409 pin);
410
411 break;
412 case PIN_CONFIG_BIAS_HIGH_IMPEDANCE:
413 case PIN_CONFIG_MODE_LOW_POWER:
414
415
416
417
418
419 ret = 0;
420 break;
421 default:
422 dev_warn(pctldev->dev,
423 "unsupported configuration parameter '%u'\n",
424 param);
425 ret = -ENOTSUPP;
426 break;
427 }
428
429 param = pinconf_to_config_param(configs[i]);
430 arg = pinconf_to_config_argument(configs[i]);
431 if (ret)
432 dev_warn(pctldev->dev,
433 "failed to set: pin %u param %u value %u\n",
434 pin, param, arg);
435 }
436
437 return 0;
438}
439
440
441
442
443
444
445
446
447
448
449
450
451static int zynqmp_pinconf_group_set(struct pinctrl_dev *pctldev,
452 unsigned int selector,
453 unsigned long *configs,
454 unsigned int num_configs)
455{
456 int i, ret;
457 struct zynqmp_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
458 const struct zynqmp_pctrl_group *pgrp = &pctrl->groups[selector];
459
460 for (i = 0; i < pgrp->npins; i++) {
461 ret = zynqmp_pinconf_cfg_set(pctldev, pgrp->pins[i], configs,
462 num_configs);
463 if (ret)
464 return ret;
465 }
466
467 return 0;
468}
469
470static const struct pinconf_ops zynqmp_pinconf_ops = {
471 .is_generic = true,
472 .pin_config_get = zynqmp_pinconf_cfg_get,
473 .pin_config_set = zynqmp_pinconf_cfg_set,
474 .pin_config_group_set = zynqmp_pinconf_group_set,
475};
476
477static struct pinctrl_desc zynqmp_desc = {
478 .name = "zynqmp_pinctrl",
479 .owner = THIS_MODULE,
480 .pctlops = &zynqmp_pctrl_ops,
481 .pmxops = &zynqmp_pinmux_ops,
482 .confops = &zynqmp_pinconf_ops,
483};
484
485static int zynqmp_pinctrl_get_function_groups(u32 fid, u32 index, u16 *groups)
486{
487 struct zynqmp_pm_query_data qdata = {0};
488 u32 payload[PAYLOAD_ARG_CNT];
489 int ret;
490
491 qdata.qid = PM_QID_PINCTRL_GET_FUNCTION_GROUPS;
492 qdata.arg1 = fid;
493 qdata.arg2 = index;
494
495 ret = zynqmp_pm_query_data(qdata, payload);
496 if (ret)
497 return ret;
498
499 memcpy(groups, &payload[1], PINCTRL_GET_FUNC_GROUPS_RESP_LEN);
500
501 return 0;
502}
503
504static int zynqmp_pinctrl_get_func_num_groups(u32 fid, unsigned int *ngroups)
505{
506 struct zynqmp_pm_query_data qdata = {0};
507 u32 payload[PAYLOAD_ARG_CNT];
508 int ret;
509
510 qdata.qid = PM_QID_PINCTRL_GET_NUM_FUNCTION_GROUPS;
511 qdata.arg1 = fid;
512
513 ret = zynqmp_pm_query_data(qdata, payload);
514 if (ret)
515 return ret;
516
517 *ngroups = payload[1];
518
519 return 0;
520}
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543static int zynqmp_pinctrl_prepare_func_groups(struct device *dev, u32 fid,
544 struct zynqmp_pmux_function *func,
545 struct zynqmp_pctrl_group *groups)
546{
547 u16 resp[NUM_GROUPS_PER_RESP] = {0};
548 const char **fgroups;
549 int ret, index, i;
550
551 fgroups = devm_kzalloc(dev, sizeof(*fgroups) * func->ngroups, GFP_KERNEL);
552 if (!fgroups)
553 return -ENOMEM;
554
555 for (index = 0; index < func->ngroups; index += NUM_GROUPS_PER_RESP) {
556 ret = zynqmp_pinctrl_get_function_groups(fid, index, resp);
557 if (ret)
558 return ret;
559
560 for (i = 0; i < NUM_GROUPS_PER_RESP; i++) {
561 if (resp[i] == NA_GROUP)
562 goto done;
563
564 if (resp[i] == RESERVED_GROUP)
565 continue;
566
567 fgroups[index + i] = devm_kasprintf(dev, GFP_KERNEL,
568 "%s_%d_grp",
569 func->name,
570 index + i);
571 if (!fgroups[index + i])
572 return -ENOMEM;
573
574 groups[resp[i]].name = devm_kasprintf(dev, GFP_KERNEL,
575 "%s_%d_grp",
576 func->name,
577 index + i);
578 if (!groups[resp[i]].name)
579 return -ENOMEM;
580 }
581 }
582done:
583 func->groups = fgroups;
584
585 return 0;
586}
587
588static void zynqmp_pinctrl_get_function_name(u32 fid, char *name)
589{
590 struct zynqmp_pm_query_data qdata = {0};
591 u32 payload[PAYLOAD_ARG_CNT];
592
593 qdata.qid = PM_QID_PINCTRL_GET_FUNCTION_NAME;
594 qdata.arg1 = fid;
595
596
597
598
599
600
601 zynqmp_pm_query_data(qdata, payload);
602 memcpy(name, payload, PINCTRL_GET_FUNC_NAME_RESP_LEN);
603}
604
605static int zynqmp_pinctrl_get_num_functions(unsigned int *nfuncs)
606{
607 struct zynqmp_pm_query_data qdata = {0};
608 u32 payload[PAYLOAD_ARG_CNT];
609 int ret;
610
611 qdata.qid = PM_QID_PINCTRL_GET_NUM_FUNCTIONS;
612
613 ret = zynqmp_pm_query_data(qdata, payload);
614 if (ret)
615 return ret;
616
617 *nfuncs = payload[1];
618
619 return 0;
620}
621
622static int zynqmp_pinctrl_get_pin_groups(u32 pin, u32 index, u16 *groups)
623{
624 struct zynqmp_pm_query_data qdata = {0};
625 u32 payload[PAYLOAD_ARG_CNT];
626 int ret;
627
628 qdata.qid = PM_QID_PINCTRL_GET_PIN_GROUPS;
629 qdata.arg1 = pin;
630 qdata.arg2 = index;
631
632 ret = zynqmp_pm_query_data(qdata, payload);
633 if (ret)
634 return ret;
635
636 memcpy(groups, &payload[1], PINCTRL_GET_PIN_GROUPS_RESP_LEN);
637
638 return 0;
639}
640
641static void zynqmp_pinctrl_group_add_pin(struct zynqmp_pctrl_group *group,
642 unsigned int pin)
643{
644 group->pins[group->npins++] = pin;
645}
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662static int zynqmp_pinctrl_create_pin_groups(struct device *dev,
663 struct zynqmp_pctrl_group *groups,
664 unsigned int pin)
665{
666 u16 resp[NUM_GROUPS_PER_RESP] = {0};
667 int ret, i, index = 0;
668
669 do {
670 ret = zynqmp_pinctrl_get_pin_groups(pin, index, resp);
671 if (ret)
672 return ret;
673
674 for (i = 0; i < NUM_GROUPS_PER_RESP; i++) {
675 if (resp[i] == NA_GROUP)
676 return ret;
677
678 if (resp[i] == RESERVED_GROUP)
679 continue;
680
681 zynqmp_pinctrl_group_add_pin(&groups[resp[i]], pin);
682 }
683 index += NUM_GROUPS_PER_RESP;
684 } while (index <= MAX_PIN_GROUPS);
685
686 return 0;
687}
688
689
690
691
692
693
694
695
696
697
698
699static int zynqmp_pinctrl_prepare_group_pins(struct device *dev,
700 struct zynqmp_pctrl_group *groups,
701 unsigned int ngroups)
702{
703 unsigned int pin;
704 int ret;
705
706 for (pin = 0; pin < zynqmp_desc.npins; pin++) {
707 ret = zynqmp_pinctrl_create_pin_groups(dev, groups, pin);
708 if (ret)
709 return ret;
710 }
711
712 return 0;
713}
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732static int zynqmp_pinctrl_prepare_function_info(struct device *dev,
733 struct zynqmp_pinctrl *pctrl)
734{
735 struct zynqmp_pmux_function *funcs;
736 struct zynqmp_pctrl_group *groups;
737 int ret, i;
738
739 ret = zynqmp_pinctrl_get_num_functions(&pctrl->nfuncs);
740 if (ret)
741 return ret;
742
743 funcs = devm_kzalloc(dev, sizeof(*funcs) * pctrl->nfuncs, GFP_KERNEL);
744 if (!funcs)
745 return -ENOMEM;
746
747 for (i = 0; i < pctrl->nfuncs; i++) {
748 zynqmp_pinctrl_get_function_name(i, funcs[i].name);
749
750 ret = zynqmp_pinctrl_get_func_num_groups(i, &funcs[i].ngroups);
751 if (ret)
752 return ret;
753
754 pctrl->ngroups += funcs[i].ngroups;
755 }
756
757 groups = devm_kzalloc(dev, sizeof(*groups) * pctrl->ngroups, GFP_KERNEL);
758 if (!groups)
759 return -ENOMEM;
760
761 for (i = 0; i < pctrl->nfuncs; i++) {
762 ret = zynqmp_pinctrl_prepare_func_groups(dev, i, &funcs[i],
763 groups);
764 if (ret)
765 return ret;
766 }
767
768 ret = zynqmp_pinctrl_prepare_group_pins(dev, groups, pctrl->ngroups);
769 if (ret)
770 return ret;
771
772 pctrl->funcs = funcs;
773 pctrl->groups = groups;
774
775 return 0;
776}
777
778static int zynqmp_pinctrl_get_num_pins(unsigned int *npins)
779{
780 struct zynqmp_pm_query_data qdata = {0};
781 u32 payload[PAYLOAD_ARG_CNT];
782 int ret;
783
784 qdata.qid = PM_QID_PINCTRL_GET_NUM_PINS;
785
786 ret = zynqmp_pm_query_data(qdata, payload);
787 if (ret)
788 return ret;
789
790 *npins = payload[1];
791
792 return 0;
793}
794
795
796
797
798
799
800
801
802
803
804
805
806static int zynqmp_pinctrl_prepare_pin_desc(struct device *dev,
807 const struct pinctrl_pin_desc
808 **zynqmp_pins,
809 unsigned int *npins)
810{
811 struct pinctrl_pin_desc *pins, *pin;
812 int ret;
813 int i;
814
815 ret = zynqmp_pinctrl_get_num_pins(npins);
816 if (ret)
817 return ret;
818
819 pins = devm_kzalloc(dev, sizeof(*pins) * *npins, GFP_KERNEL);
820 if (!pins)
821 return -ENOMEM;
822
823 for (i = 0; i < *npins; i++) {
824 pin = &pins[i];
825 pin->number = i;
826 pin->name = devm_kasprintf(dev, GFP_KERNEL, "%s%d",
827 ZYNQMP_PIN_PREFIX, i);
828 if (!pin->name)
829 return -ENOMEM;
830 }
831
832 *zynqmp_pins = pins;
833
834 return 0;
835}
836
837static int zynqmp_pinctrl_probe(struct platform_device *pdev)
838{
839 struct zynqmp_pinctrl *pctrl;
840 int ret;
841
842 pctrl = devm_kzalloc(&pdev->dev, sizeof(*pctrl), GFP_KERNEL);
843 if (!pctrl)
844 return -ENOMEM;
845
846 ret = zynqmp_pinctrl_prepare_pin_desc(&pdev->dev,
847 &zynqmp_desc.pins,
848 &zynqmp_desc.npins);
849 if (ret) {
850 dev_err(&pdev->dev, "pin desc prepare fail with %d\n", ret);
851 return ret;
852 }
853
854 ret = zynqmp_pinctrl_prepare_function_info(&pdev->dev, pctrl);
855 if (ret) {
856 dev_err(&pdev->dev, "function info prepare fail with %d\n", ret);
857 return ret;
858 }
859
860 pctrl->pctrl = devm_pinctrl_register(&pdev->dev, &zynqmp_desc, pctrl);
861 if (IS_ERR(pctrl->pctrl))
862 return PTR_ERR(pctrl->pctrl);
863
864 platform_set_drvdata(pdev, pctrl);
865
866 return ret;
867}
868
869static const struct of_device_id zynqmp_pinctrl_of_match[] = {
870 { .compatible = "xlnx,zynqmp-pinctrl" },
871 { }
872};
873MODULE_DEVICE_TABLE(of, zynqmp_pinctrl_of_match);
874
875static struct platform_driver zynqmp_pinctrl_driver = {
876 .driver = {
877 .name = "zynqmp-pinctrl",
878 .of_match_table = zynqmp_pinctrl_of_match,
879 },
880 .probe = zynqmp_pinctrl_probe,
881};
882module_platform_driver(zynqmp_pinctrl_driver);
883
884MODULE_AUTHOR("Sai Krishna Potthuri <lakshmi.sai.krishna.potthuri@xilinx.com>");
885MODULE_DESCRIPTION("ZynqMP Pin Controller Driver");
886MODULE_LICENSE("GPL v2");
887