drivers/pinctrl/pinctrl-pic32.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * PIC32 pinctrl driver
0004  *
0005  * Joshua Henderson, <joshua.henderson@microchip.com>
0006  * Copyright (C) 2015 Microchip Technology Inc.  All rights reserved.
0007  */
0008 #include <linux/clk.h>
0009 #include <linux/gpio/driver.h>
0010 #include <linux/interrupt.h>
0011 #include <linux/io.h>
0012 #include <linux/irq.h>
0013 #include <linux/of.h>
0014 #include <linux/of_device.h>
0015 #include <linux/pinctrl/pinconf.h>
0016 #include <linux/pinctrl/pinconf-generic.h>
0017 #include <linux/pinctrl/pinctrl.h>
0018 #include <linux/pinctrl/pinmux.h>
0019 #include <linux/platform_device.h>
0020 #include <linux/slab.h>
0021 #include <linux/spinlock.h>
0022
0023 #include <asm/mach-pic32/pic32.h>
0024
0025 #include "pinctrl-utils.h"
0026 #include "pinctrl-pic32.h"
0027
0028 #define PINS_PER_BANK       16
0029
0030 #define PIC32_CNCON_EDGE    11
0031 #define PIC32_CNCON_ON      15
0032
0033 #define PIN_CONFIG_MICROCHIP_DIGITAL    (PIN_CONFIG_END + 1)
0034 #define PIN_CONFIG_MICROCHIP_ANALOG (PIN_CONFIG_END + 2)
0035
0036 static const struct pinconf_generic_params pic32_mpp_bindings[] = {
0037     {"microchip,digital",   PIN_CONFIG_MICROCHIP_DIGITAL,   0},
0038     {"microchip,analog",    PIN_CONFIG_MICROCHIP_ANALOG,    0},
0039 };
0040
0041 #define GPIO_BANK_START(bank)       ((bank) * PINS_PER_BANK)
0042
0043 struct pic32_function {
0044     const char *name;
0045     const char * const *groups;
0046     unsigned int ngroups;
0047 };
0048
0049 struct pic32_pin_group {
0050     const char *name;
0051     unsigned int pin;
0052     struct pic32_desc_function *functions;
0053 };
0054
0055 struct pic32_desc_function {
0056     const char *name;
0057     u32 muxreg;
0058     u32 muxval;
0059 };
0060
0061 struct pic32_gpio_bank {
0062     void __iomem *reg_base;
0063     struct gpio_chip gpio_chip;
0064     struct irq_chip irq_chip;
0065     struct clk *clk;
0066 };
0067
0068 struct pic32_pinctrl {
0069     void __iomem *reg_base;
0070     struct device *dev;
0071     struct pinctrl_dev *pctldev;
0072     const struct pinctrl_pin_desc *pins;
0073     unsigned int npins;
0074     const struct pic32_function *functions;
0075     unsigned int nfunctions;
0076     const struct pic32_pin_group *groups;
0077     unsigned int ngroups;
0078     struct pic32_gpio_bank *gpio_banks;
0079     unsigned int nbanks;
0080     struct clk *clk;
0081 };
0082
0083 static const struct pinctrl_pin_desc pic32_pins[] = {
0084     PINCTRL_PIN(0, "A0"),
0085     PINCTRL_PIN(1, "A1"),
0086     PINCTRL_PIN(2, "A2"),
0087     PINCTRL_PIN(3, "A3"),
0088     PINCTRL_PIN(4, "A4"),
0089     PINCTRL_PIN(5, "A5"),
0090     PINCTRL_PIN(6, "A6"),
0091     PINCTRL_PIN(7, "A7"),
0092     PINCTRL_PIN(8, "A8"),
0093     PINCTRL_PIN(9, "A9"),
0094     PINCTRL_PIN(10, "A10"),
0095     PINCTRL_PIN(11, "A11"),
0096     PINCTRL_PIN(12, "A12"),
0097     PINCTRL_PIN(13, "A13"),
0098     PINCTRL_PIN(14, "A14"),
0099     PINCTRL_PIN(15, "A15"),
0100     PINCTRL_PIN(16, "B0"),
0101     PINCTRL_PIN(17, "B1"),
0102     PINCTRL_PIN(18, "B2"),
0103     PINCTRL_PIN(19, "B3"),
0104     PINCTRL_PIN(20, "B4"),
0105     PINCTRL_PIN(21, "B5"),
0106     PINCTRL_PIN(22, "B6"),
0107     PINCTRL_PIN(23, "B7"),
0108     PINCTRL_PIN(24, "B8"),
0109     PINCTRL_PIN(25, "B9"),
0110     PINCTRL_PIN(26, "B10"),
0111     PINCTRL_PIN(27, "B11"),
0112     PINCTRL_PIN(28, "B12"),
0113     PINCTRL_PIN(29, "B13"),
0114     PINCTRL_PIN(30, "B14"),
0115     PINCTRL_PIN(31, "B15"),
0116     PINCTRL_PIN(33, "C1"),
0117     PINCTRL_PIN(34, "C2"),
0118     PINCTRL_PIN(35, "C3"),
0119     PINCTRL_PIN(36, "C4"),
0120     PINCTRL_PIN(44, "C12"),
0121     PINCTRL_PIN(45, "C13"),
0122     PINCTRL_PIN(46, "C14"),
0123     PINCTRL_PIN(47, "C15"),
0124     PINCTRL_PIN(48, "D0"),
0125     PINCTRL_PIN(49, "D1"),
0126     PINCTRL_PIN(50, "D2"),
0127     PINCTRL_PIN(51, "D3"),
0128     PINCTRL_PIN(52, "D4"),
0129     PINCTRL_PIN(53, "D5"),
0130     PINCTRL_PIN(54, "D6"),
0131     PINCTRL_PIN(55, "D7"),
0132     PINCTRL_PIN(57, "D9"),
0133     PINCTRL_PIN(58, "D10"),
0134     PINCTRL_PIN(59, "D11"),
0135     PINCTRL_PIN(60, "D12"),
0136     PINCTRL_PIN(61, "D13"),
0137     PINCTRL_PIN(62, "D14"),
0138     PINCTRL_PIN(63, "D15"),
0139     PINCTRL_PIN(64, "E0"),
0140     PINCTRL_PIN(65, "E1"),
0141     PINCTRL_PIN(66, "E2"),
0142     PINCTRL_PIN(67, "E3"),
0143     PINCTRL_PIN(68, "E4"),
0144     PINCTRL_PIN(69, "E5"),
0145     PINCTRL_PIN(70, "E6"),
0146     PINCTRL_PIN(71, "E7"),
0147     PINCTRL_PIN(72, "E8"),
0148     PINCTRL_PIN(73, "E9"),
0149     PINCTRL_PIN(80, "F0"),
0150     PINCTRL_PIN(81, "F1"),
0151     PINCTRL_PIN(82, "F2"),
0152     PINCTRL_PIN(83, "F3"),
0153     PINCTRL_PIN(84, "F4"),
0154     PINCTRL_PIN(85, "F5"),
0155     PINCTRL_PIN(88, "F8"),
0156     PINCTRL_PIN(92, "F12"),
0157     PINCTRL_PIN(93, "F13"),
0158     PINCTRL_PIN(96, "G0"),
0159     PINCTRL_PIN(97, "G1"),
0160     PINCTRL_PIN(102, "G6"),
0161     PINCTRL_PIN(103, "G7"),
0162     PINCTRL_PIN(104, "G8"),
0163     PINCTRL_PIN(105, "G9"),
0164     PINCTRL_PIN(108, "G12"),
0165     PINCTRL_PIN(109, "G13"),
0166     PINCTRL_PIN(110, "G14"),
0167     PINCTRL_PIN(111, "G15"),
0168     PINCTRL_PIN(112, "H0"),
0169     PINCTRL_PIN(113, "H1"),
0170     PINCTRL_PIN(114, "H2"),
0171     PINCTRL_PIN(115, "H3"),
0172     PINCTRL_PIN(116, "H4"),
0173     PINCTRL_PIN(117, "H5"),
0174     PINCTRL_PIN(118, "H6"),
0175     PINCTRL_PIN(119, "H7"),
0176     PINCTRL_PIN(120, "H8"),
0177     PINCTRL_PIN(121, "H9"),
0178     PINCTRL_PIN(122, "H10"),
0179     PINCTRL_PIN(123, "H11"),
0180     PINCTRL_PIN(124, "H12"),
0181     PINCTRL_PIN(125, "H13"),
0182     PINCTRL_PIN(126, "H14"),
0183     PINCTRL_PIN(127, "H15"),
0184     PINCTRL_PIN(128, "J0"),
0185     PINCTRL_PIN(129, "J1"),
0186     PINCTRL_PIN(130, "J2"),
0187     PINCTRL_PIN(131, "J3"),
0188     PINCTRL_PIN(132, "J4"),
0189     PINCTRL_PIN(133, "J5"),
0190     PINCTRL_PIN(134, "J6"),
0191     PINCTRL_PIN(135, "J7"),
0192     PINCTRL_PIN(136, "J8"),
0193     PINCTRL_PIN(137, "J9"),
0194     PINCTRL_PIN(138, "J10"),
0195     PINCTRL_PIN(139, "J11"),
0196     PINCTRL_PIN(140, "J12"),
0197     PINCTRL_PIN(141, "J13"),
0198     PINCTRL_PIN(142, "J14"),
0199     PINCTRL_PIN(143, "J15"),
0200     PINCTRL_PIN(144, "K0"),
0201     PINCTRL_PIN(145, "K1"),
0202     PINCTRL_PIN(146, "K2"),
0203     PINCTRL_PIN(147, "K3"),
0204     PINCTRL_PIN(148, "K4"),
0205     PINCTRL_PIN(149, "K5"),
0206     PINCTRL_PIN(150, "K6"),
0207     PINCTRL_PIN(151, "K7"),
0208 };
0209
0210 static const char * const pic32_input0_group[] = {
0211     "D2", "G8", "F4", "F1", "B9", "B10", "C14", "B5",
0212     "C1", "D14", "G1", "A14", "D6",
0213 };
0214
0215 static const char * const pic32_input1_group[] = {
0216     "D3", "G7", "F5", "D11", "F0", "B1", "E5", "C13",
0217     "B3", "C4", "G0", "A15", "D7",
0218 };
0219
0220 static const char * const pic32_input2_group[] = {
0221     "D9", "G6", "B8", "B15", "D4", "B0", "E3", "B7",
0222     "F12", "D12", "F8", "C3", "E9",
0223 };
0224
0225 static const char * const pic32_input3_group[] = {
0226     "G9", "B14", "D0", "B6", "D5", "B2", "F3", "F13",
0227     "F2", "C2", "E8",
0228 };
0229
0230 static const char * const pic32_output0_group[] = {
0231     "D2", "G8", "F4", "D10", "F1", "B9", "B10", "C14",
0232     "B5", "C1", "D14", "G1", "A14", "D6",
0233 };
0234
0235 static const char * const pic32_output0_1_group[] = {
0236     "D2", "G8", "F4", "D10", "F1", "B9", "B10", "C14",
0237     "B5", "C1", "D14", "G1", "A14", "D6",
0238     "D3", "G7", "F5", "D11", "F0", "B1", "E5", "C13",
0239     "B3", "C4", "D15", "G0", "A15", "D7",
0240 };
0241
0242 static const char *const pic32_output1_group[] = {
0243     "D3", "G7", "F5", "D11", "F0", "B1", "E5", "C13",
0244     "B3", "C4", "D15", "G0", "A15", "D7",
0245 };
0246
0247 static const char *const pic32_output1_3_group[] = {
0248     "D3", "G7", "F5", "D11", "F0", "B1", "E5", "C13",
0249     "B3", "C4", "D15", "G0", "A15", "D7",
0250     "G9", "B14", "D0", "B6", "D5", "B2", "F3", "F13",
0251     "C2", "E8", "F2",
0252 };
0253
0254 static const char * const pic32_output2_group[] = {
0255     "D9", "G6", "B8", "B15", "D4", "B0", "E3", "B7",
0256     "F12", "D12", "F8", "C3", "E9",
0257 };
0258
0259 static const char * const pic32_output2_3_group[] = {
0260     "D9", "G6", "B8", "B15", "D4", "B0", "E3", "B7",
0261     "F12", "D12", "F8", "C3", "E9",
0262     "G9", "B14", "D0", "B6", "D5", "B2", "F3", "F13",
0263     "C2", "E8", "F2",
0264 };
0265
0266 static const char * const pic32_output3_group[] = {
0267     "G9", "B14", "D0", "B6", "D5", "B2", "F3", "F13",
0268     "C2", "E8", "F2",
0269 };
0270
0271 #define FUNCTION(_name, _gr)                    \
0272     {                           \
0273         .name = #_name,                 \
0274         .groups = pic32_##_gr##_group,          \
0275         .ngroups = ARRAY_SIZE(pic32_##_gr##_group), \
0276     }
0277
0278 static const struct pic32_function pic32_functions[] = {
0279     FUNCTION(INT3, input0),
0280     FUNCTION(T2CK, input0),
0281     FUNCTION(T6CK, input0),
0282     FUNCTION(IC3, input0),
0283     FUNCTION(IC7, input0),
0284     FUNCTION(U1RX, input0),
0285     FUNCTION(U2CTS, input0),
0286     FUNCTION(U5RX, input0),
0287     FUNCTION(U6CTS, input0),
0288     FUNCTION(SDI1, input0),
0289     FUNCTION(SDI3, input0),
0290     FUNCTION(SDI5, input0),
0291     FUNCTION(SS6IN, input0),
0292     FUNCTION(REFCLKI1, input0),
0293     FUNCTION(INT4, input1),
0294     FUNCTION(T5CK, input1),
0295     FUNCTION(T7CK, input1),
0296     FUNCTION(IC4, input1),
0297     FUNCTION(IC8, input1),
0298     FUNCTION(U3RX, input1),
0299     FUNCTION(U4CTS, input1),
0300     FUNCTION(SDI2, input1),
0301     FUNCTION(SDI4, input1),
0302     FUNCTION(C1RX, input1),
0303     FUNCTION(REFCLKI4, input1),
0304     FUNCTION(INT2, input2),
0305     FUNCTION(T3CK, input2),
0306     FUNCTION(T8CK, input2),
0307     FUNCTION(IC2, input2),
0308     FUNCTION(IC5, input2),
0309     FUNCTION(IC9, input2),
0310     FUNCTION(U1CTS, input2),
0311     FUNCTION(U2RX, input2),
0312     FUNCTION(U5CTS, input2),
0313     FUNCTION(SS1IN, input2),
0314     FUNCTION(SS3IN, input2),
0315     FUNCTION(SS4IN, input2),
0316     FUNCTION(SS5IN, input2),
0317     FUNCTION(C2RX, input2),
0318     FUNCTION(INT1, input3),
0319     FUNCTION(T4CK, input3),
0320     FUNCTION(T9CK, input3),
0321     FUNCTION(IC1, input3),
0322     FUNCTION(IC6, input3),
0323     FUNCTION(U3CTS, input3),
0324     FUNCTION(U4RX, input3),
0325     FUNCTION(U6RX, input3),
0326     FUNCTION(SS2IN, input3),
0327     FUNCTION(SDI6, input3),
0328     FUNCTION(OCFA, input3),
0329     FUNCTION(REFCLKI3, input3),
0330     FUNCTION(U3TX, output0),
0331     FUNCTION(U4RTS, output0),
0332     FUNCTION(SDO1, output0_1),
0333     FUNCTION(SDO2, output0_1),
0334     FUNCTION(SDO3, output0_1),
0335     FUNCTION(SDO5, output0_1),
0336     FUNCTION(SS6OUT, output0),
0337     FUNCTION(OC3, output0),
0338     FUNCTION(OC6, output0),
0339     FUNCTION(REFCLKO4, output0),
0340     FUNCTION(C2OUT, output0),
0341     FUNCTION(C1TX, output0),
0342     FUNCTION(U1TX, output1),
0343     FUNCTION(U2RTS, output1),
0344     FUNCTION(U5TX, output1),
0345     FUNCTION(U6RTS, output1),
0346     FUNCTION(SDO4, output1_3),
0347     FUNCTION(OC4, output1),
0348     FUNCTION(OC7, output1),
0349     FUNCTION(REFCLKO1, output1),
0350     FUNCTION(U3RTS, output2),
0351     FUNCTION(U4TX, output2),
0352     FUNCTION(U6TX, output2_3),
0353     FUNCTION(SS1OUT, output2),
0354     FUNCTION(SS3OUT, output2),
0355     FUNCTION(SS4OUT, output2),
0356     FUNCTION(SS5OUT, output2),
0357     FUNCTION(SDO6, output2_3),
0358     FUNCTION(OC5, output2),
0359     FUNCTION(OC8, output2),
0360     FUNCTION(C1OUT, output2),
0361     FUNCTION(REFCLKO3, output2),
0362     FUNCTION(U1RTS, output3),
0363     FUNCTION(U2TX, output3),
0364     FUNCTION(U5RTS, output3),
0365     FUNCTION(SS2OUT, output3),
0366     FUNCTION(OC2, output3),
0367     FUNCTION(OC1, output3),
0368     FUNCTION(OC9, output3),
0369     FUNCTION(C2TX, output3),
0370 };
0371
0372 #define PIC32_PINCTRL_GROUP(_pin, _name, ...)               \
0373     {                               \
0374         .name = #_name,                     \
0375         .pin = _pin,                        \
0376         .functions = (struct pic32_desc_function[]){        \
0377             __VA_ARGS__, { } },             \
0378     }
0379
0380 #define PIC32_PINCTRL_FUNCTION(_name, _muxreg, _muxval) \
0381     {                       \
0382         .name = #_name,             \
0383         .muxreg = _muxreg,          \
0384         .muxval = _muxval,          \
0385     }
0386
0387 static const struct pic32_pin_group pic32_groups[] = {
0388     PIC32_PINCTRL_GROUP(14, A14,
0389             PIC32_PINCTRL_FUNCTION(INT3, INT3R, 13),
0390             PIC32_PINCTRL_FUNCTION(T2CK, T2CKR, 13),
0391             PIC32_PINCTRL_FUNCTION(T6CK, T6CKR, 13),
0392             PIC32_PINCTRL_FUNCTION(IC3, IC3R, 13),
0393             PIC32_PINCTRL_FUNCTION(IC7, IC7R, 13),
0394             PIC32_PINCTRL_FUNCTION(U1RX, U1RXR, 13),
0395             PIC32_PINCTRL_FUNCTION(U2CTS, U2CTSR, 13),
0396             PIC32_PINCTRL_FUNCTION(U5RX, U5RXR, 13),
0397             PIC32_PINCTRL_FUNCTION(U6CTS, U6CTSR, 13),
0398             PIC32_PINCTRL_FUNCTION(SDI1, SDI1R, 13),
0399             PIC32_PINCTRL_FUNCTION(SDI3, SDI3R, 13),
0400             PIC32_PINCTRL_FUNCTION(SDI5, SDI5R, 13),
0401             PIC32_PINCTRL_FUNCTION(SS6IN, SS6INR, 13),
0402             PIC32_PINCTRL_FUNCTION(REFCLKI1, REFCLKI1R, 13),
0403             PIC32_PINCTRL_FUNCTION(U3TX, RPA14R, 1),
0404             PIC32_PINCTRL_FUNCTION(U4RTS, RPA14R, 2),
0405             PIC32_PINCTRL_FUNCTION(SDO1, RPA14R, 5),
0406             PIC32_PINCTRL_FUNCTION(SDO2, RPA14R, 6),
0407             PIC32_PINCTRL_FUNCTION(SDO3, RPA14R, 7),
0408             PIC32_PINCTRL_FUNCTION(SDO5, RPA14R, 9),
0409             PIC32_PINCTRL_FUNCTION(SS6OUT, RPA14R, 10),
0410             PIC32_PINCTRL_FUNCTION(OC3, RPA14R, 11),
0411             PIC32_PINCTRL_FUNCTION(OC6, RPA14R, 12),
0412             PIC32_PINCTRL_FUNCTION(REFCLKO4, RPA14R, 13),
0413             PIC32_PINCTRL_FUNCTION(C2OUT, RPA14R, 14),
0414             PIC32_PINCTRL_FUNCTION(C1TX, RPA14R, 15)),
0415     PIC32_PINCTRL_GROUP(15, A15,
0416             PIC32_PINCTRL_FUNCTION(INT4, INT4R, 13),
0417             PIC32_PINCTRL_FUNCTION(T5CK, T5CKR, 13),
0418             PIC32_PINCTRL_FUNCTION(T7CK, T7CKR, 13),
0419             PIC32_PINCTRL_FUNCTION(IC4, IC4R, 13),
0420             PIC32_PINCTRL_FUNCTION(IC8, IC8R, 13),
0421             PIC32_PINCTRL_FUNCTION(U3RX, U3RXR, 13),
0422             PIC32_PINCTRL_FUNCTION(U4CTS, U4CTSR, 13),
0423             PIC32_PINCTRL_FUNCTION(SDI2, SDI2R, 13),
0424             PIC32_PINCTRL_FUNCTION(SDI4, SDI4R, 13),
0425             PIC32_PINCTRL_FUNCTION(C1RX, C1RXR, 13),
0426             PIC32_PINCTRL_FUNCTION(REFCLKI4, REFCLKI4R, 13),
0427             PIC32_PINCTRL_FUNCTION(U1TX, RPA15R, 1),
0428             PIC32_PINCTRL_FUNCTION(U2RTS, RPA15R, 2),
0429             PIC32_PINCTRL_FUNCTION(U5TX, RPA15R, 3),
0430             PIC32_PINCTRL_FUNCTION(U6RTS, RPA15R, 4),
0431             PIC32_PINCTRL_FUNCTION(SDO1, RPA15R, 5),
0432             PIC32_PINCTRL_FUNCTION(SDO2, RPA15R, 6),
0433             PIC32_PINCTRL_FUNCTION(SDO3, RPA15R, 7),
0434             PIC32_PINCTRL_FUNCTION(SDO4, RPA15R, 8),
0435             PIC32_PINCTRL_FUNCTION(SDO5, RPA15R, 9),
0436             PIC32_PINCTRL_FUNCTION(OC4, RPA15R, 11),
0437             PIC32_PINCTRL_FUNCTION(OC7, RPA15R, 12),
0438             PIC32_PINCTRL_FUNCTION(REFCLKO1, RPA15R, 15)),
0439     PIC32_PINCTRL_GROUP(16, B0,
0440             PIC32_PINCTRL_FUNCTION(INT2, INT2R, 5),
0441             PIC32_PINCTRL_FUNCTION(T3CK, T3CKR, 5),
0442             PIC32_PINCTRL_FUNCTION(T8CK, T8CKR, 5),
0443             PIC32_PINCTRL_FUNCTION(IC2, IC2R, 5),
0444             PIC32_PINCTRL_FUNCTION(IC5, IC5R, 5),
0445             PIC32_PINCTRL_FUNCTION(IC9, IC9R, 5),
0446             PIC32_PINCTRL_FUNCTION(U1CTS, U1CTSR, 5),
0447             PIC32_PINCTRL_FUNCTION(U2RX, U2RXR, 5),
0448             PIC32_PINCTRL_FUNCTION(U5CTS, U5CTSR, 5),
0449             PIC32_PINCTRL_FUNCTION(SS1IN, SS1INR, 5),
0450             PIC32_PINCTRL_FUNCTION(SS3IN, SS3INR, 5),
0451             PIC32_PINCTRL_FUNCTION(SS4IN, SS4INR, 5),
0452             PIC32_PINCTRL_FUNCTION(SS5IN, SS5INR, 5),
0453             PIC32_PINCTRL_FUNCTION(C2RX, C2RXR, 5),
0454             PIC32_PINCTRL_FUNCTION(U3RTS, RPB0R, 1),
0455             PIC32_PINCTRL_FUNCTION(U4TX, RPB0R, 2),
0456             PIC32_PINCTRL_FUNCTION(U6TX, RPB0R, 4),
0457             PIC32_PINCTRL_FUNCTION(SS1OUT, RPB0R, 5),
0458             PIC32_PINCTRL_FUNCTION(SS3OUT, RPB0R, 7),
0459             PIC32_PINCTRL_FUNCTION(SS4OUT, RPB0R, 8),
0460             PIC32_PINCTRL_FUNCTION(SS5OUT, RPB0R, 9),
0461             PIC32_PINCTRL_FUNCTION(SDO6, RPB0R, 10),
0462             PIC32_PINCTRL_FUNCTION(OC5, RPB0R, 11),
0463             PIC32_PINCTRL_FUNCTION(OC8, RPB0R, 12),
0464             PIC32_PINCTRL_FUNCTION(C1OUT, RPB0R, 14),
0465             PIC32_PINCTRL_FUNCTION(REFCLKO3, RPB0R, 15)),
0466     PIC32_PINCTRL_GROUP(17, B1,
0467             PIC32_PINCTRL_FUNCTION(INT4, INT4R, 5),
0468             PIC32_PINCTRL_FUNCTION(T5CK, T5CKR, 5),
0469             PIC32_PINCTRL_FUNCTION(T7CK, T7CKR, 5),
0470             PIC32_PINCTRL_FUNCTION(IC4, IC4R, 5),
0471             PIC32_PINCTRL_FUNCTION(IC8, IC8R, 5),
0472             PIC32_PINCTRL_FUNCTION(U3RX, U3RXR, 5),
0473             PIC32_PINCTRL_FUNCTION(U4CTS, U4CTSR, 5),
0474             PIC32_PINCTRL_FUNCTION(SDI2, SDI2R, 5),
0475             PIC32_PINCTRL_FUNCTION(SDI4, SDI4R, 5),
0476             PIC32_PINCTRL_FUNCTION(C1RX, C1RXR, 5),
0477             PIC32_PINCTRL_FUNCTION(REFCLKI4, REFCLKI4R, 5),
0478             PIC32_PINCTRL_FUNCTION(U1TX, RPB1R, 1),
0479             PIC32_PINCTRL_FUNCTION(U2RTS, RPB1R, 2),
0480             PIC32_PINCTRL_FUNCTION(U5TX, RPB1R, 3),
0481             PIC32_PINCTRL_FUNCTION(U6RTS, RPB1R, 4),
0482             PIC32_PINCTRL_FUNCTION(SDO1, RPB1R, 5),
0483             PIC32_PINCTRL_FUNCTION(SDO2, RPB1R, 6),
0484             PIC32_PINCTRL_FUNCTION(SDO3, RPB1R, 7),
0485             PIC32_PINCTRL_FUNCTION(SDO4, RPB1R, 8),
0486             PIC32_PINCTRL_FUNCTION(SDO5, RPB1R, 9),
0487             PIC32_PINCTRL_FUNCTION(OC4, RPB1R, 11),
0488             PIC32_PINCTRL_FUNCTION(OC7, RPB1R, 12),
0489             PIC32_PINCTRL_FUNCTION(REFCLKO1, RPB1R, 15)),
0490     PIC32_PINCTRL_GROUP(18, B2,
0491             PIC32_PINCTRL_FUNCTION(INT1, INT1R, 7),
0492             PIC32_PINCTRL_FUNCTION(T4CK, T4CKR, 7),
0493             PIC32_PINCTRL_FUNCTION(T9CK, T9CKR, 7),
0494             PIC32_PINCTRL_FUNCTION(IC1, IC1R, 7),
0495             PIC32_PINCTRL_FUNCTION(IC6, IC6R, 7),
0496             PIC32_PINCTRL_FUNCTION(U3CTS, U3CTSR, 7),
0497             PIC32_PINCTRL_FUNCTION(U4RX, U4RXR, 7),
0498             PIC32_PINCTRL_FUNCTION(U6RX, U6RXR, 7),
0499             PIC32_PINCTRL_FUNCTION(SS2IN, SS2INR, 7),
0500             PIC32_PINCTRL_FUNCTION(SDI6, SDI6R, 7),
0501             PIC32_PINCTRL_FUNCTION(OCFA, OCFAR, 7),
0502             PIC32_PINCTRL_FUNCTION(REFCLKI3, REFCLKI3R, 7),
0503             PIC32_PINCTRL_FUNCTION(U1RTS, RPB2R, 1),
0504             PIC32_PINCTRL_FUNCTION(U2TX, RPB2R, 2),
0505             PIC32_PINCTRL_FUNCTION(U5RTS, RPB2R, 3),
0506             PIC32_PINCTRL_FUNCTION(U6TX, RPB2R, 4),
0507             PIC32_PINCTRL_FUNCTION(SS2OUT, RPB2R, 6),
0508             PIC32_PINCTRL_FUNCTION(SDO4, RPB2R, 8),
0509             PIC32_PINCTRL_FUNCTION(SDO6, RPB2R, 10),
0510             PIC32_PINCTRL_FUNCTION(OC2, RPB2R, 11),
0511             PIC32_PINCTRL_FUNCTION(OC1, RPB2R, 12),
0512             PIC32_PINCTRL_FUNCTION(OC9, RPB2R, 13),
0513             PIC32_PINCTRL_FUNCTION(C2TX, RPB2R, 15)),
0514     PIC32_PINCTRL_GROUP(19, B3,
0515             PIC32_PINCTRL_FUNCTION(INT4, INT4R, 8),
0516             PIC32_PINCTRL_FUNCTION(T5CK, T5CKR, 8),
0517             PIC32_PINCTRL_FUNCTION(T7CK, T7CKR, 8),
0518             PIC32_PINCTRL_FUNCTION(IC4, IC4R, 8),
0519             PIC32_PINCTRL_FUNCTION(IC8, IC8R, 8),
0520             PIC32_PINCTRL_FUNCTION(U3RX, U3RXR, 8),
0521             PIC32_PINCTRL_FUNCTION(U4CTS, U4CTSR, 8),
0522             PIC32_PINCTRL_FUNCTION(SDI2, SDI2R, 8),
0523             PIC32_PINCTRL_FUNCTION(SDI4, SDI4R, 8),
0524             PIC32_PINCTRL_FUNCTION(C1RX, C1RXR, 8),
0525             PIC32_PINCTRL_FUNCTION(REFCLKI4, REFCLKI4R, 8),
0526             PIC32_PINCTRL_FUNCTION(U1TX, RPB3R, 1),
0527             PIC32_PINCTRL_FUNCTION(U2RTS, RPB3R, 2),
0528             PIC32_PINCTRL_FUNCTION(U5TX, RPB3R, 3),
0529             PIC32_PINCTRL_FUNCTION(U6RTS, RPB3R, 4),
0530             PIC32_PINCTRL_FUNCTION(SDO1, RPB3R, 5),
0531             PIC32_PINCTRL_FUNCTION(SDO2, RPB3R, 6),
0532             PIC32_PINCTRL_FUNCTION(SDO3, RPB3R, 7),
0533             PIC32_PINCTRL_FUNCTION(SDO4, RPB3R, 8),
0534             PIC32_PINCTRL_FUNCTION(SDO5, RPB3R, 9),
0535             PIC32_PINCTRL_FUNCTION(OC4, RPB3R, 11),
0536             PIC32_PINCTRL_FUNCTION(OC7, RPB3R, 12),
0537             PIC32_PINCTRL_FUNCTION(REFCLKO1, RPB3R, 15)),
0538     PIC32_PINCTRL_GROUP(21, B5,
0539             PIC32_PINCTRL_FUNCTION(INT3, INT3R, 8),
0540             PIC32_PINCTRL_FUNCTION(T2CK, T2CKR, 8),
0541             PIC32_PINCTRL_FUNCTION(T6CK, T6CKR, 8),
0542             PIC32_PINCTRL_FUNCTION(IC3, IC3R, 8),
0543             PIC32_PINCTRL_FUNCTION(IC7, IC7R, 8),
0544             PIC32_PINCTRL_FUNCTION(U1RX, U1RXR, 8),
0545             PIC32_PINCTRL_FUNCTION(U2CTS, U2CTSR, 8),
0546             PIC32_PINCTRL_FUNCTION(U5RX, U5RXR, 8),
0547             PIC32_PINCTRL_FUNCTION(U6CTS, U6CTSR, 8),
0548             PIC32_PINCTRL_FUNCTION(SDI1, SDI1R, 8),
0549             PIC32_PINCTRL_FUNCTION(SDI3, SDI3R, 8),
0550             PIC32_PINCTRL_FUNCTION(SDI5, SDI5R, 8),
0551             PIC32_PINCTRL_FUNCTION(SS6IN, SS6INR, 8),
0552             PIC32_PINCTRL_FUNCTION(REFCLKI1, REFCLKI1R, 8),
0553             PIC32_PINCTRL_FUNCTION(U3TX, RPB5R, 1),
0554             PIC32_PINCTRL_FUNCTION(U4RTS, RPB5R, 2),
0555             PIC32_PINCTRL_FUNCTION(SDO1, RPB5R, 5),
0556             PIC32_PINCTRL_FUNCTION(SDO2, RPB5R, 6),
0557             PIC32_PINCTRL_FUNCTION(SDO3, RPB5R, 7),
0558             PIC32_PINCTRL_FUNCTION(SDO5, RPB5R, 9),
0559             PIC32_PINCTRL_FUNCTION(SS6OUT, RPB5R, 10),
0560             PIC32_PINCTRL_FUNCTION(OC3, RPB5R, 11),
0561             PIC32_PINCTRL_FUNCTION(OC6, RPB5R, 12),
0562             PIC32_PINCTRL_FUNCTION(REFCLKO4, RPB5R, 13),
0563             PIC32_PINCTRL_FUNCTION(C2OUT, RPB5R, 14),
0564             PIC32_PINCTRL_FUNCTION(C1TX, RPB5R, 15)),
0565     PIC32_PINCTRL_GROUP(22, B6,
0566             PIC32_PINCTRL_FUNCTION(INT1, INT1R, 4),
0567             PIC32_PINCTRL_FUNCTION(T4CK, T4CKR, 4),
0568             PIC32_PINCTRL_FUNCTION(T9CK, T9CKR, 4),
0569             PIC32_PINCTRL_FUNCTION(IC1, IC1R, 4),
0570             PIC32_PINCTRL_FUNCTION(IC6, IC6R, 4),
0571             PIC32_PINCTRL_FUNCTION(U3CTS, U3CTSR, 4),
0572             PIC32_PINCTRL_FUNCTION(U4RX, U4RXR, 4),
0573             PIC32_PINCTRL_FUNCTION(U6RX, U6RXR, 4),
0574             PIC32_PINCTRL_FUNCTION(SS2IN, SS2INR, 4),
0575             PIC32_PINCTRL_FUNCTION(SDI6, SDI6R, 4),
0576             PIC32_PINCTRL_FUNCTION(OCFA, OCFAR, 4),
0577             PIC32_PINCTRL_FUNCTION(REFCLKI3, REFCLKI3R, 4),
0578             PIC32_PINCTRL_FUNCTION(U1RTS, RPB6R, 1),
0579             PIC32_PINCTRL_FUNCTION(U2TX, RPB6R, 2),
0580             PIC32_PINCTRL_FUNCTION(U5RTS, RPB6R, 3),
0581             PIC32_PINCTRL_FUNCTION(U6TX, RPB6R, 4),
0582             PIC32_PINCTRL_FUNCTION(SS2OUT, RPB6R, 6),
0583             PIC32_PINCTRL_FUNCTION(SDO4, RPB6R, 8),
0584             PIC32_PINCTRL_FUNCTION(SDO6, RPB6R, 10),
0585             PIC32_PINCTRL_FUNCTION(OC2, RPB6R, 11),
0586             PIC32_PINCTRL_FUNCTION(OC1, RPB6R, 12),
0587             PIC32_PINCTRL_FUNCTION(OC9, RPB6R, 13),
0588             PIC32_PINCTRL_FUNCTION(C2TX, RPB6R, 15)),
0589     PIC32_PINCTRL_GROUP(23, B7,
0590             PIC32_PINCTRL_FUNCTION(INT2, INT2R, 7),
0591             PIC32_PINCTRL_FUNCTION(T3CK, T3CKR, 7),
0592             PIC32_PINCTRL_FUNCTION(T8CK, T8CKR, 7),
0593             PIC32_PINCTRL_FUNCTION(IC2, IC2R, 7),
0594             PIC32_PINCTRL_FUNCTION(IC5, IC5R, 7),
0595             PIC32_PINCTRL_FUNCTION(IC9, IC9R, 7),
0596             PIC32_PINCTRL_FUNCTION(U1CTS, U1CTSR, 7),
0597             PIC32_PINCTRL_FUNCTION(U2RX, U2RXR, 7),
0598             PIC32_PINCTRL_FUNCTION(U5CTS, U5CTSR, 7),
0599             PIC32_PINCTRL_FUNCTION(SS1IN, SS1INR, 7),
0600             PIC32_PINCTRL_FUNCTION(SS3IN, SS3INR, 7),
0601             PIC32_PINCTRL_FUNCTION(SS4IN, SS4INR, 7),
0602             PIC32_PINCTRL_FUNCTION(SS5IN, SS5INR, 7),
0603             PIC32_PINCTRL_FUNCTION(C2RX, C2RXR, 7),
0604             PIC32_PINCTRL_FUNCTION(U3RTS, RPB7R, 1),
0605             PIC32_PINCTRL_FUNCTION(U4TX, RPB7R, 2),
0606             PIC32_PINCTRL_FUNCTION(U6TX, RPB7R, 4),
0607             PIC32_PINCTRL_FUNCTION(SS1OUT, RPB7R, 5),
0608             PIC32_PINCTRL_FUNCTION(SS3OUT, RPB7R, 7),
0609             PIC32_PINCTRL_FUNCTION(SS4OUT, RPB7R, 8),
0610             PIC32_PINCTRL_FUNCTION(SS5OUT, RPB7R, 9),
0611             PIC32_PINCTRL_FUNCTION(SDO6, RPB7R, 10),
0612             PIC32_PINCTRL_FUNCTION(OC5, RPB7R, 11),
0613             PIC32_PINCTRL_FUNCTION(OC8, RPB7R, 12),
0614             PIC32_PINCTRL_FUNCTION(C1OUT, RPB7R, 14),
0615             PIC32_PINCTRL_FUNCTION(REFCLKO3, RPB7R, 15)),
0616     PIC32_PINCTRL_GROUP(24, B8,
0617             PIC32_PINCTRL_FUNCTION(INT2, INT2R, 2),
0618             PIC32_PINCTRL_FUNCTION(T3CK, T3CKR, 2),
0619             PIC32_PINCTRL_FUNCTION(T8CK, T8CKR, 2),
0620             PIC32_PINCTRL_FUNCTION(IC2, IC2R, 2),
0621             PIC32_PINCTRL_FUNCTION(IC5, IC5R, 2),
0622             PIC32_PINCTRL_FUNCTION(IC9, IC9R, 2),
0623             PIC32_PINCTRL_FUNCTION(U1CTS, U1CTSR, 2),
0624             PIC32_PINCTRL_FUNCTION(U2RX, U2RXR, 2),
0625             PIC32_PINCTRL_FUNCTION(U5CTS, U5CTSR, 2),
0626             PIC32_PINCTRL_FUNCTION(SS1IN, SS1INR, 2),
0627             PIC32_PINCTRL_FUNCTION(SS3IN, SS3INR, 2),
0628             PIC32_PINCTRL_FUNCTION(SS4IN, SS4INR, 2),
0629             PIC32_PINCTRL_FUNCTION(SS5IN, SS5INR, 2),
0630             PIC32_PINCTRL_FUNCTION(C2RX, C2RXR, 2),
0631             PIC32_PINCTRL_FUNCTION(U3RTS, RPB8R, 1),
0632             PIC32_PINCTRL_FUNCTION(U4TX, RPB8R, 2),
0633             PIC32_PINCTRL_FUNCTION(U6TX, RPB8R, 4),
0634             PIC32_PINCTRL_FUNCTION(SS1OUT, RPB8R, 5),
0635             PIC32_PINCTRL_FUNCTION(SS3OUT, RPB8R, 7),
0636             PIC32_PINCTRL_FUNCTION(SS4OUT, RPB8R, 8),
0637             PIC32_PINCTRL_FUNCTION(SS5OUT, RPB8R, 9),
0638             PIC32_PINCTRL_FUNCTION(SDO6, RPB8R, 10),
0639             PIC32_PINCTRL_FUNCTION(OC5, RPB8R, 11),
0640             PIC32_PINCTRL_FUNCTION(OC8, RPB8R, 12),
0641             PIC32_PINCTRL_FUNCTION(C1OUT, RPB8R, 14),
0642             PIC32_PINCTRL_FUNCTION(REFCLKO3, RPB8R, 15)),
0643     PIC32_PINCTRL_GROUP(25, B9,
0644             PIC32_PINCTRL_FUNCTION(INT3, INT3R, 5),
0645             PIC32_PINCTRL_FUNCTION(T2CK, T2CKR, 5),
0646             PIC32_PINCTRL_FUNCTION(T6CK, T6CKR, 5),
0647             PIC32_PINCTRL_FUNCTION(IC3, IC3R, 5),
0648             PIC32_PINCTRL_FUNCTION(IC7, IC7R, 5),
0649             PIC32_PINCTRL_FUNCTION(U1RX, U1RXR, 5),
0650             PIC32_PINCTRL_FUNCTION(U2CTS, U2CTSR, 5),
0651             PIC32_PINCTRL_FUNCTION(U5RX, U5RXR, 5),
0652             PIC32_PINCTRL_FUNCTION(U6CTS, U6CTSR, 5),
0653             PIC32_PINCTRL_FUNCTION(SDI1, SDI1R, 5),
0654             PIC32_PINCTRL_FUNCTION(SDI3, SDI3R, 5),
0655             PIC32_PINCTRL_FUNCTION(SDI5, SDI5R, 5),
0656             PIC32_PINCTRL_FUNCTION(SS6IN, SS6INR, 5),
0657             PIC32_PINCTRL_FUNCTION(REFCLKI1, REFCLKI1R, 5),
0658             PIC32_PINCTRL_FUNCTION(U3TX, RPB9R, 1),
0659             PIC32_PINCTRL_FUNCTION(U4RTS, RPB9R, 2),
0660             PIC32_PINCTRL_FUNCTION(SDO1, RPB9R, 5),
0661             PIC32_PINCTRL_FUNCTION(SDO2, RPB9R, 6),
0662             PIC32_PINCTRL_FUNCTION(SDO3, RPB9R, 7),
0663             PIC32_PINCTRL_FUNCTION(SDO5, RPB9R, 9),
0664             PIC32_PINCTRL_FUNCTION(SS6OUT, RPB9R, 10),
0665             PIC32_PINCTRL_FUNCTION(OC3, RPB9R, 11),
0666             PIC32_PINCTRL_FUNCTION(OC6, RPB9R, 12),
0667             PIC32_PINCTRL_FUNCTION(REFCLKO4, RPB9R, 13),
0668             PIC32_PINCTRL_FUNCTION(C2OUT, RPB9R, 14),
0669             PIC32_PINCTRL_FUNCTION(C1TX, RPB9R, 15)),
0670     PIC32_PINCTRL_GROUP(26, B10,
0671             PIC32_PINCTRL_FUNCTION(INT3, INT3R, 6),
0672             PIC32_PINCTRL_FUNCTION(T2CK, T2CKR, 6),
0673             PIC32_PINCTRL_FUNCTION(T6CK, T6CKR, 6),
0674             PIC32_PINCTRL_FUNCTION(IC3, IC3R, 6),
0675             PIC32_PINCTRL_FUNCTION(IC7, IC7R, 6),
0676             PIC32_PINCTRL_FUNCTION(U1RX, U1RXR, 6),
0677             PIC32_PINCTRL_FUNCTION(U2CTS, U2CTSR, 6),
0678             PIC32_PINCTRL_FUNCTION(U5RX, U5RXR, 6),
0679             PIC32_PINCTRL_FUNCTION(U6CTS, U6CTSR, 6),
0680             PIC32_PINCTRL_FUNCTION(SDI1, SDI1R, 6),
0681             PIC32_PINCTRL_FUNCTION(SDI3, SDI3R, 6),
0682             PIC32_PINCTRL_FUNCTION(SDI5, SDI5R, 6),
0683             PIC32_PINCTRL_FUNCTION(SS6IN, SS6INR, 6),
0684             PIC32_PINCTRL_FUNCTION(REFCLKI1, REFCLKI1R, 6),
0685             PIC32_PINCTRL_FUNCTION(U3TX, RPB10R, 1),
0686             PIC32_PINCTRL_FUNCTION(U4RTS, RPB10R, 2),
0687             PIC32_PINCTRL_FUNCTION(SDO1, RPB10R, 5),
0688             PIC32_PINCTRL_FUNCTION(SDO2, RPB10R, 6),
0689             PIC32_PINCTRL_FUNCTION(SDO3, RPB10R, 7),
0690             PIC32_PINCTRL_FUNCTION(SDO5, RPB10R, 9),
0691             PIC32_PINCTRL_FUNCTION(SS6OUT, RPB10R, 10),
0692             PIC32_PINCTRL_FUNCTION(OC3, RPB10R, 11),
0693             PIC32_PINCTRL_FUNCTION(OC6, RPB10R, 12),
0694             PIC32_PINCTRL_FUNCTION(REFCLKO4, RPB10R, 13),
0695             PIC32_PINCTRL_FUNCTION(C2OUT, RPB10R, 14),
0696             PIC32_PINCTRL_FUNCTION(C1TX, RPB10R, 15)),
0697     PIC32_PINCTRL_GROUP(30, B14,
0698             PIC32_PINCTRL_FUNCTION(INT1, INT1R, 2),
0699             PIC32_PINCTRL_FUNCTION(T4CK, T4CKR, 2),
0700             PIC32_PINCTRL_FUNCTION(T9CK, T9CKR, 2),
0701             PIC32_PINCTRL_FUNCTION(IC1, IC1R, 2),
0702             PIC32_PINCTRL_FUNCTION(IC6, IC6R, 2),
0703             PIC32_PINCTRL_FUNCTION(U3CTS, U3CTSR, 2),
0704             PIC32_PINCTRL_FUNCTION(U4RX, U4RXR, 2),
0705             PIC32_PINCTRL_FUNCTION(U6RX, U6RXR, 2),
0706             PIC32_PINCTRL_FUNCTION(SS2IN, SS2INR, 2),
0707             PIC32_PINCTRL_FUNCTION(SDI6, SDI6R, 2),
0708             PIC32_PINCTRL_FUNCTION(OCFA, OCFAR, 2),
0709             PIC32_PINCTRL_FUNCTION(REFCLKI3, REFCLKI3R, 2),
0710             PIC32_PINCTRL_FUNCTION(U1RTS, RPB14R, 1),
0711             PIC32_PINCTRL_FUNCTION(U2TX, RPB14R, 2),
0712             PIC32_PINCTRL_FUNCTION(U5RTS, RPB14R, 3),
0713             PIC32_PINCTRL_FUNCTION(U6TX, RPB14R, 4),
0714             PIC32_PINCTRL_FUNCTION(SS2OUT, RPB14R, 6),
0715             PIC32_PINCTRL_FUNCTION(SDO4, RPB14R, 8),
0716             PIC32_PINCTRL_FUNCTION(SDO6, RPB14R, 10),
0717             PIC32_PINCTRL_FUNCTION(OC2, RPB14R, 11),
0718             PIC32_PINCTRL_FUNCTION(OC1, RPB14R, 12),
0719             PIC32_PINCTRL_FUNCTION(OC9, RPB14R, 13),
0720             PIC32_PINCTRL_FUNCTION(C2TX, RPB14R, 15)),
0721     PIC32_PINCTRL_GROUP(31, B15,
0722             PIC32_PINCTRL_FUNCTION(INT2, INT2R, 3),
0723             PIC32_PINCTRL_FUNCTION(T3CK, T3CKR, 3),
0724             PIC32_PINCTRL_FUNCTION(T8CK, T8CKR, 3),
0725             PIC32_PINCTRL_FUNCTION(IC2, IC2R, 3),
0726             PIC32_PINCTRL_FUNCTION(IC5, IC5R, 3),
0727             PIC32_PINCTRL_FUNCTION(IC9, IC9R, 3),
0728             PIC32_PINCTRL_FUNCTION(U1CTS, U1CTSR, 3),
0729             PIC32_PINCTRL_FUNCTION(U2RX, U2RXR, 3),
0730             PIC32_PINCTRL_FUNCTION(U5CTS, U5CTSR, 3),
0731             PIC32_PINCTRL_FUNCTION(SS1IN, SS1INR, 3),
0732             PIC32_PINCTRL_FUNCTION(SS3IN, SS3INR, 3),
0733             PIC32_PINCTRL_FUNCTION(SS4IN, SS4INR, 3),
0734             PIC32_PINCTRL_FUNCTION(SS5IN, SS5INR, 3),
0735             PIC32_PINCTRL_FUNCTION(C2RX, C2RXR, 3),
0736             PIC32_PINCTRL_FUNCTION(U3RTS, RPB15R, 1),
0737             PIC32_PINCTRL_FUNCTION(U4TX, RPB15R, 2),
0738             PIC32_PINCTRL_FUNCTION(U6TX, RPB15R, 4),
0739             PIC32_PINCTRL_FUNCTION(SS1OUT, RPB15R, 5),
0740             PIC32_PINCTRL_FUNCTION(SS3OUT, RPB15R, 7),
0741             PIC32_PINCTRL_FUNCTION(SS4OUT, RPB15R, 8),
0742             PIC32_PINCTRL_FUNCTION(SS5OUT, RPB15R, 9),
0743             PIC32_PINCTRL_FUNCTION(SDO6, RPB15R, 10),
0744             PIC32_PINCTRL_FUNCTION(OC5, RPB15R, 11),
0745             PIC32_PINCTRL_FUNCTION(OC8, RPB15R, 12),
0746             PIC32_PINCTRL_FUNCTION(C1OUT, RPB15R, 14),
0747             PIC32_PINCTRL_FUNCTION(REFCLKO3, RPB15R, 15)),
0748     PIC32_PINCTRL_GROUP(33, C1,
0749             PIC32_PINCTRL_FUNCTION(INT3, INT3R, 10),
0750             PIC32_PINCTRL_FUNCTION(T2CK, T2CKR, 10),
0751             PIC32_PINCTRL_FUNCTION(T6CK, T6CKR, 10),
0752             PIC32_PINCTRL_FUNCTION(IC3, IC3R, 10),
0753             PIC32_PINCTRL_FUNCTION(IC7, IC7R, 10),
0754             PIC32_PINCTRL_FUNCTION(U1RX, U1RXR, 10),
0755             PIC32_PINCTRL_FUNCTION(U2CTS, U2CTSR, 10),
0756             PIC32_PINCTRL_FUNCTION(U5RX, U5RXR, 10),
0757             PIC32_PINCTRL_FUNCTION(U6CTS, U6CTSR, 10),
0758             PIC32_PINCTRL_FUNCTION(SDI1, SDI1R, 10),
0759             PIC32_PINCTRL_FUNCTION(SDI3, SDI3R, 10),
0760             PIC32_PINCTRL_FUNCTION(SDI5, SDI5R, 10),
0761             PIC32_PINCTRL_FUNCTION(SS6IN, SS6INR, 10),
0762             PIC32_PINCTRL_FUNCTION(REFCLKI1, REFCLKI1R, 10),
0763             PIC32_PINCTRL_FUNCTION(U3TX, RPC1R, 1),
0764             PIC32_PINCTRL_FUNCTION(U4RTS, RPC1R, 2),
0765             PIC32_PINCTRL_FUNCTION(SDO1, RPC1R, 5),
0766             PIC32_PINCTRL_FUNCTION(SDO2, RPC1R, 6),
0767             PIC32_PINCTRL_FUNCTION(SDO3, RPC1R, 7),
0768             PIC32_PINCTRL_FUNCTION(SDO5, RPC1R, 9),
0769             PIC32_PINCTRL_FUNCTION(SS6OUT, RPC1R, 10),
0770             PIC32_PINCTRL_FUNCTION(OC3, RPC1R, 11),
0771             PIC32_PINCTRL_FUNCTION(OC6, RPC1R, 12),
0772             PIC32_PINCTRL_FUNCTION(REFCLKO4, RPC1R, 13),
0773             PIC32_PINCTRL_FUNCTION(C2OUT, RPC1R, 14),
0774             PIC32_PINCTRL_FUNCTION(C1TX, RPC1R, 15)),
0775     PIC32_PINCTRL_GROUP(34, C2,
0776             PIC32_PINCTRL_FUNCTION(INT1, INT1R, 12),
0777             PIC32_PINCTRL_FUNCTION(T4CK, T4CKR, 12),
0778             PIC32_PINCTRL_FUNCTION(T9CK, T9CKR, 12),
0779             PIC32_PINCTRL_FUNCTION(IC1, IC1R, 12),
0780             PIC32_PINCTRL_FUNCTION(IC6, IC6R, 12),
0781             PIC32_PINCTRL_FUNCTION(U3CTS, U3CTSR, 12),
0782             PIC32_PINCTRL_FUNCTION(U4RX, U4RXR, 12),
0783             PIC32_PINCTRL_FUNCTION(U6RX, U6RXR, 12),
0784             PIC32_PINCTRL_FUNCTION(SS2IN, SS2INR, 12),
0785             PIC32_PINCTRL_FUNCTION(SDI6, SDI6R, 12),
0786             PIC32_PINCTRL_FUNCTION(OCFA, OCFAR, 12),
0787             PIC32_PINCTRL_FUNCTION(REFCLKI3, REFCLKI3R, 12),
0788             PIC32_PINCTRL_FUNCTION(U1RTS, RPC2R, 1),
0789             PIC32_PINCTRL_FUNCTION(U2TX, RPC2R, 2),
0790             PIC32_PINCTRL_FUNCTION(U5RTS, RPC2R, 3),
0791             PIC32_PINCTRL_FUNCTION(U6TX, RPC2R, 4),
0792             PIC32_PINCTRL_FUNCTION(SS2OUT, RPC2R, 6),
0793             PIC32_PINCTRL_FUNCTION(SDO4, RPC2R, 8),
0794             PIC32_PINCTRL_FUNCTION(SDO6, RPC2R, 10),
0795             PIC32_PINCTRL_FUNCTION(OC2, RPC2R, 11),
0796             PIC32_PINCTRL_FUNCTION(OC1, RPC2R, 12),
0797             PIC32_PINCTRL_FUNCTION(OC9, RPC2R, 13),
0798             PIC32_PINCTRL_FUNCTION(C2TX, RPC2R, 15)),
0799     PIC32_PINCTRL_GROUP(35, C3,
0800             PIC32_PINCTRL_FUNCTION(INT2, INT2R, 12),
0801             PIC32_PINCTRL_FUNCTION(T3CK, T3CKR, 12),
0802             PIC32_PINCTRL_FUNCTION(T8CK, T8CKR, 12),
0803             PIC32_PINCTRL_FUNCTION(IC2, IC2R, 12),
0804             PIC32_PINCTRL_FUNCTION(IC5, IC5R, 12),
0805             PIC32_PINCTRL_FUNCTION(IC9, IC9R, 12),
0806             PIC32_PINCTRL_FUNCTION(U1CTS, U1CTSR, 12),
0807             PIC32_PINCTRL_FUNCTION(U2RX, U2RXR, 12),
0808             PIC32_PINCTRL_FUNCTION(U5CTS, U5CTSR, 12),
0809             PIC32_PINCTRL_FUNCTION(SS1IN, SS1INR, 12),
0810             PIC32_PINCTRL_FUNCTION(SS3IN, SS3INR, 12),
0811             PIC32_PINCTRL_FUNCTION(SS4IN, SS4INR, 12),
0812             PIC32_PINCTRL_FUNCTION(SS5IN, SS5INR, 12),
0813             PIC32_PINCTRL_FUNCTION(C2RX, C2RXR, 12),
0814             PIC32_PINCTRL_FUNCTION(U3RTS, RPC3R, 1),
0815             PIC32_PINCTRL_FUNCTION(U4TX, RPC3R, 2),
0816             PIC32_PINCTRL_FUNCTION(U6TX, RPC3R, 4),
0817             PIC32_PINCTRL_FUNCTION(SS1OUT, RPC3R, 5),
0818             PIC32_PINCTRL_FUNCTION(SS3OUT, RPC3R, 7),
0819             PIC32_PINCTRL_FUNCTION(SS4OUT, RPC3R, 8),
0820             PIC32_PINCTRL_FUNCTION(SS5OUT, RPC3R, 9),
0821             PIC32_PINCTRL_FUNCTION(SDO6, RPC3R, 10),
0822             PIC32_PINCTRL_FUNCTION(OC5, RPC3R, 11),
0823             PIC32_PINCTRL_FUNCTION(OC8, RPC3R, 12),
0824             PIC32_PINCTRL_FUNCTION(C1OUT, RPC3R, 14),
0825             PIC32_PINCTRL_FUNCTION(REFCLKO3, RPC3R, 15)),
0826     PIC32_PINCTRL_GROUP(36, C4,
0827             PIC32_PINCTRL_FUNCTION(INT4, INT4R, 10),
0828             PIC32_PINCTRL_FUNCTION(T5CK, T5CKR, 10),
0829             PIC32_PINCTRL_FUNCTION(T7CK, T7CKR, 10),
0830             PIC32_PINCTRL_FUNCTION(IC4, IC4R, 10),
0831             PIC32_PINCTRL_FUNCTION(IC8, IC8R, 10),
0832             PIC32_PINCTRL_FUNCTION(U3RX, U3RXR, 10),
0833             PIC32_PINCTRL_FUNCTION(U4CTS, U4CTSR, 10),
0834             PIC32_PINCTRL_FUNCTION(SDI2, SDI2R, 10),
0835             PIC32_PINCTRL_FUNCTION(SDI4, SDI4R, 10),
0836             PIC32_PINCTRL_FUNCTION(C1RX, C1RXR, 10),
0837             PIC32_PINCTRL_FUNCTION(REFCLKI4, REFCLKI4R, 10),
0838             PIC32_PINCTRL_FUNCTION(U1TX, RPC4R, 1),
0839             PIC32_PINCTRL_FUNCTION(U2RTS, RPC4R, 2),
0840             PIC32_PINCTRL_FUNCTION(U5TX, RPC4R, 3),
0841             PIC32_PINCTRL_FUNCTION(U6RTS, RPC4R, 4),
0842             PIC32_PINCTRL_FUNCTION(SDO1, RPC4R, 5),
0843             PIC32_PINCTRL_FUNCTION(SDO2, RPC4R, 6),
0844             PIC32_PINCTRL_FUNCTION(SDO3, RPC4R, 7),
0845             PIC32_PINCTRL_FUNCTION(SDO4, RPC4R, 8),
0846             PIC32_PINCTRL_FUNCTION(SDO5, RPC4R, 9),
0847             PIC32_PINCTRL_FUNCTION(OC4, RPC4R, 11),
0848             PIC32_PINCTRL_FUNCTION(OC7, RPC4R, 12),
0849             PIC32_PINCTRL_FUNCTION(REFCLKO1, RPC4R, 15)),
0850     PIC32_PINCTRL_GROUP(45, C13,
0851             PIC32_PINCTRL_FUNCTION(INT4, INT4R, 7),
0852             PIC32_PINCTRL_FUNCTION(T5CK, T5CKR, 7),
0853             PIC32_PINCTRL_FUNCTION(T7CK, T7CKR, 7),
0854             PIC32_PINCTRL_FUNCTION(IC4, IC4R, 7),
0855             PIC32_PINCTRL_FUNCTION(IC8, IC8R, 7),
0856             PIC32_PINCTRL_FUNCTION(U3RX, U3RXR, 7),
0857             PIC32_PINCTRL_FUNCTION(U4CTS, U4CTSR, 7),
0858             PIC32_PINCTRL_FUNCTION(SDI2, SDI2R, 7),
0859             PIC32_PINCTRL_FUNCTION(SDI4, SDI4R, 7),
0860             PIC32_PINCTRL_FUNCTION(C1RX, C1RXR, 7),
0861             PIC32_PINCTRL_FUNCTION(REFCLKI4, REFCLKI4R, 7),
0862             PIC32_PINCTRL_FUNCTION(U1TX, RPC13R, 1),
0863             PIC32_PINCTRL_FUNCTION(U2RTS, RPC13R, 2),
0864             PIC32_PINCTRL_FUNCTION(U5TX, RPC13R, 3),
0865             PIC32_PINCTRL_FUNCTION(U6RTS, RPC13R, 4),
0866             PIC32_PINCTRL_FUNCTION(SDO1, RPC13R, 5),
0867             PIC32_PINCTRL_FUNCTION(SDO2, RPC13R, 6),
0868             PIC32_PINCTRL_FUNCTION(SDO3, RPC13R, 7),
0869             PIC32_PINCTRL_FUNCTION(SDO4, RPC13R, 8),
0870             PIC32_PINCTRL_FUNCTION(SDO5, RPC13R, 9),
0871             PIC32_PINCTRL_FUNCTION(OC4, RPC13R, 11),
0872             PIC32_PINCTRL_FUNCTION(OC7, RPC13R, 12),
0873             PIC32_PINCTRL_FUNCTION(REFCLKO1, RPC13R, 15)),
0874     PIC32_PINCTRL_GROUP(46, C14,
0875             PIC32_PINCTRL_FUNCTION(INT3, INT3R, 7),
0876             PIC32_PINCTRL_FUNCTION(T2CK, T2CKR, 7),
0877             PIC32_PINCTRL_FUNCTION(T6CK, T6CKR, 7),
0878             PIC32_PINCTRL_FUNCTION(IC3, IC3R, 7),
0879             PIC32_PINCTRL_FUNCTION(IC7, IC7R, 7),
0880             PIC32_PINCTRL_FUNCTION(U1RX, U1RXR, 7),
0881             PIC32_PINCTRL_FUNCTION(U2CTS, U2CTSR, 7),
0882             PIC32_PINCTRL_FUNCTION(U5RX, U5RXR, 7),
0883             PIC32_PINCTRL_FUNCTION(U6CTS, U6CTSR, 7),
0884             PIC32_PINCTRL_FUNCTION(SDI1, SDI1R, 7),
0885             PIC32_PINCTRL_FUNCTION(SDI3, SDI3R, 7),
0886             PIC32_PINCTRL_FUNCTION(SDI5, SDI5R, 7),
0887             PIC32_PINCTRL_FUNCTION(SS6IN, SS6INR, 7),
0888             PIC32_PINCTRL_FUNCTION(REFCLKI1, REFCLKI1R, 7),
0889             PIC32_PINCTRL_FUNCTION(U3TX, RPC14R, 1),
0890             PIC32_PINCTRL_FUNCTION(U4RTS, RPC14R, 2),
0891             PIC32_PINCTRL_FUNCTION(SDO1, RPC14R, 5),
0892             PIC32_PINCTRL_FUNCTION(SDO2, RPC14R, 6),
0893             PIC32_PINCTRL_FUNCTION(SDO3, RPC14R, 7),
0894             PIC32_PINCTRL_FUNCTION(SDO5, RPC14R, 9),
0895             PIC32_PINCTRL_FUNCTION(SS6OUT, RPC14R, 10),
0896             PIC32_PINCTRL_FUNCTION(OC3, RPC14R, 11),
0897             PIC32_PINCTRL_FUNCTION(OC6, RPC14R, 12),
0898             PIC32_PINCTRL_FUNCTION(REFCLKO4, RPC14R, 13),
0899             PIC32_PINCTRL_FUNCTION(C2OUT, RPC14R, 14),
0900             PIC32_PINCTRL_FUNCTION(C1TX, RPC14R, 15)),
0901     PIC32_PINCTRL_GROUP(48, D0,
0902             PIC32_PINCTRL_FUNCTION(INT1, INT1R, 3),
0903             PIC32_PINCTRL_FUNCTION(T4CK, T4CKR, 3),
0904             PIC32_PINCTRL_FUNCTION(T9CK, T9CKR, 3),
0905             PIC32_PINCTRL_FUNCTION(IC1, IC1R, 3),
0906             PIC32_PINCTRL_FUNCTION(IC6, IC6R, 3),
0907             PIC32_PINCTRL_FUNCTION(U3CTS, U3CTSR, 3),
0908             PIC32_PINCTRL_FUNCTION(U4RX, U4RXR, 3),
0909             PIC32_PINCTRL_FUNCTION(U6RX, U6RXR, 3),
0910             PIC32_PINCTRL_FUNCTION(SS2IN, SS2INR, 3),
0911             PIC32_PINCTRL_FUNCTION(SDI6, SDI6R, 3),
0912             PIC32_PINCTRL_FUNCTION(OCFA, OCFAR, 3),
0913             PIC32_PINCTRL_FUNCTION(REFCLKI3, REFCLKI3R, 3),
0914             PIC32_PINCTRL_FUNCTION(U1RTS, RPD0R, 1),
0915             PIC32_PINCTRL_FUNCTION(U2TX, RPD0R, 2),
0916             PIC32_PINCTRL_FUNCTION(U5RTS, RPD0R, 3),
0917             PIC32_PINCTRL_FUNCTION(U6TX, RPD0R, 4),
0918             PIC32_PINCTRL_FUNCTION(SS2OUT, RPD0R, 6),
0919             PIC32_PINCTRL_FUNCTION(SDO4, RPD0R, 8),
0920             PIC32_PINCTRL_FUNCTION(SDO6, RPD0R, 10),
0921             PIC32_PINCTRL_FUNCTION(OC2, RPD0R, 11),
0922             PIC32_PINCTRL_FUNCTION(OC1, RPD0R, 12),
0923             PIC32_PINCTRL_FUNCTION(OC9, RPD0R, 13),
0924             PIC32_PINCTRL_FUNCTION(C2TX, RPD0R, 15)),
0925     PIC32_PINCTRL_GROUP(50, D2,
0926             PIC32_PINCTRL_FUNCTION(INT3, INT3R, 0),
0927             PIC32_PINCTRL_FUNCTION(T2CK, T2CKR, 0),
0928             PIC32_PINCTRL_FUNCTION(T6CK, T6CKR, 0),
0929             PIC32_PINCTRL_FUNCTION(IC3, IC3R, 0),
0930             PIC32_PINCTRL_FUNCTION(IC7, IC7R, 0),
0931             PIC32_PINCTRL_FUNCTION(U1RX, U1RXR, 0),
0932             PIC32_PINCTRL_FUNCTION(U2CTS, U2CTSR, 0),
0933             PIC32_PINCTRL_FUNCTION(U5RX, U5RXR, 0),
0934             PIC32_PINCTRL_FUNCTION(U6CTS, U6CTSR, 0),
0935             PIC32_PINCTRL_FUNCTION(SDI1, SDI1R, 0),
0936             PIC32_PINCTRL_FUNCTION(SDI3, SDI3R, 0),
0937             PIC32_PINCTRL_FUNCTION(SDI5, SDI5R, 0),
0938             PIC32_PINCTRL_FUNCTION(SS6IN, SS6INR, 0),
0939             PIC32_PINCTRL_FUNCTION(REFCLKI1, REFCLKI1R, 0),
0940             PIC32_PINCTRL_FUNCTION(U3TX, RPD2R, 1),
0941             PIC32_PINCTRL_FUNCTION(U4RTS, RPD2R, 2),
0942             PIC32_PINCTRL_FUNCTION(SDO1, RPD2R, 5),
0943             PIC32_PINCTRL_FUNCTION(SDO2, RPD2R, 6),
0944             PIC32_PINCTRL_FUNCTION(SDO3, RPD2R, 7),
0945             PIC32_PINCTRL_FUNCTION(SDO5, RPD2R, 9),
0946             PIC32_PINCTRL_FUNCTION(SS6OUT, RPD2R, 10),
0947             PIC32_PINCTRL_FUNCTION(OC3, RPD2R, 11),
0948             PIC32_PINCTRL_FUNCTION(OC6, RPD2R, 12),
0949             PIC32_PINCTRL_FUNCTION(REFCLKO4, RPD2R, 13),
0950             PIC32_PINCTRL_FUNCTION(C2OUT, RPD2R, 14),
0951             PIC32_PINCTRL_FUNCTION(C1TX, RPD2R, 15)),
0952     PIC32_PINCTRL_GROUP(51, D3,
0953             PIC32_PINCTRL_FUNCTION(INT4, INT4R, 0),
0954             PIC32_PINCTRL_FUNCTION(T5CK, T5CKR, 0),
0955             PIC32_PINCTRL_FUNCTION(T7CK, T7CKR, 0),
0956             PIC32_PINCTRL_FUNCTION(IC4, IC4R, 0),
0957             PIC32_PINCTRL_FUNCTION(IC8, IC8R, 0),
0958             PIC32_PINCTRL_FUNCTION(U3RX, U3RXR, 0),
0959             PIC32_PINCTRL_FUNCTION(U4CTS, U4CTSR, 0),
0960             PIC32_PINCTRL_FUNCTION(SDI2, SDI2R, 0),
0961             PIC32_PINCTRL_FUNCTION(SDI4, SDI4R, 0),
0962             PIC32_PINCTRL_FUNCTION(C1RX, C1RXR, 0),
0963             PIC32_PINCTRL_FUNCTION(REFCLKI4, REFCLKI4R, 0),
0964             PIC32_PINCTRL_FUNCTION(U1TX, RPD3R, 1),
0965             PIC32_PINCTRL_FUNCTION(U2RTS, RPD3R, 2),
0966             PIC32_PINCTRL_FUNCTION(U5TX, RPD3R, 3),
0967             PIC32_PINCTRL_FUNCTION(U6RTS, RPD3R, 4),
0968             PIC32_PINCTRL_FUNCTION(SDO1, RPD3R, 5),
0969             PIC32_PINCTRL_FUNCTION(SDO2, RPD3R, 6),
0970             PIC32_PINCTRL_FUNCTION(SDO3, RPD3R, 7),
0971             PIC32_PINCTRL_FUNCTION(SDO4, RPD3R, 8),
0972             PIC32_PINCTRL_FUNCTION(SDO5, RPD3R, 9),
0973             PIC32_PINCTRL_FUNCTION(OC4, RPD3R, 11),
0974             PIC32_PINCTRL_FUNCTION(OC7, RPD3R, 12),
0975             PIC32_PINCTRL_FUNCTION(REFCLKO1, RPD3R, 15)),
0976     PIC32_PINCTRL_GROUP(52, D4,
0977             PIC32_PINCTRL_FUNCTION(INT2, INT2R, 4),
0978             PIC32_PINCTRL_FUNCTION(T3CK, T3CKR, 4),
0979             PIC32_PINCTRL_FUNCTION(T8CK, T8CKR, 4),
0980             PIC32_PINCTRL_FUNCTION(IC2, IC2R, 4),
0981             PIC32_PINCTRL_FUNCTION(IC5, IC5R, 4),
0982             PIC32_PINCTRL_FUNCTION(IC9, IC9R, 4),
0983             PIC32_PINCTRL_FUNCTION(U1CTS, U1CTSR, 4),
0984             PIC32_PINCTRL_FUNCTION(U2RX, U2RXR, 4),
0985             PIC32_PINCTRL_FUNCTION(U5CTS, U5CTSR, 4),
0986             PIC32_PINCTRL_FUNCTION(SS1IN, SS1INR, 4),
0987             PIC32_PINCTRL_FUNCTION(SS3IN, SS3INR, 4),
0988             PIC32_PINCTRL_FUNCTION(SS4IN, SS4INR, 4),
0989             PIC32_PINCTRL_FUNCTION(SS5IN, SS5INR, 4),
0990             PIC32_PINCTRL_FUNCTION(C2RX, C2RXR, 4),
0991             PIC32_PINCTRL_FUNCTION(U3RTS, RPD4R, 1),
0992             PIC32_PINCTRL_FUNCTION(U4TX, RPD4R, 2),
0993             PIC32_PINCTRL_FUNCTION(U6TX, RPD4R, 4),
0994             PIC32_PINCTRL_FUNCTION(SS1OUT, RPD4R, 5),
0995             PIC32_PINCTRL_FUNCTION(SS3OUT, RPD4R, 7),
0996             PIC32_PINCTRL_FUNCTION(SS4OUT, RPD4R, 8),
0997             PIC32_PINCTRL_FUNCTION(SS5OUT, RPD4R, 9),
0998             PIC32_PINCTRL_FUNCTION(SDO6, RPD4R, 10),
0999             PIC32_PINCTRL_FUNCTION(OC5, RPD4R, 11),
1000             PIC32_PINCTRL_FUNCTION(OC8, RPD4R, 12),
1001             PIC32_PINCTRL_FUNCTION(C1OUT, RPD4R, 14),
1002             PIC32_PINCTRL_FUNCTION(REFCLKO3, RPD4R, 15)),
1003     PIC32_PINCTRL_GROUP(53, D5,
1004             PIC32_PINCTRL_FUNCTION(INT1, INT1R, 6),
1005             PIC32_PINCTRL_FUNCTION(T4CK, T4CKR, 6),
1006             PIC32_PINCTRL_FUNCTION(T9CK, T9CKR, 6),
1007             PIC32_PINCTRL_FUNCTION(IC1, IC1R, 6),
1008             PIC32_PINCTRL_FUNCTION(IC6, IC6R, 6),
1009             PIC32_PINCTRL_FUNCTION(U3CTS, U3CTSR, 6),
1010             PIC32_PINCTRL_FUNCTION(U4RX, U4RXR, 6),
1011             PIC32_PINCTRL_FUNCTION(U6RX, U6RXR, 6),
1012             PIC32_PINCTRL_FUNCTION(SS2IN, SS2INR, 6),
1013             PIC32_PINCTRL_FUNCTION(SDI6, SDI6R, 6),
1014             PIC32_PINCTRL_FUNCTION(OCFA, OCFAR, 6),
1015             PIC32_PINCTRL_FUNCTION(REFCLKI3, REFCLKI3R, 6),
1016             PIC32_PINCTRL_FUNCTION(U1RTS, RPD5R, 1),
1017             PIC32_PINCTRL_FUNCTION(U2TX, RPD5R, 2),
1018             PIC32_PINCTRL_FUNCTION(U5RTS, RPD5R, 3),
1019             PIC32_PINCTRL_FUNCTION(U6TX, RPD5R, 4),
1020             PIC32_PINCTRL_FUNCTION(SS2OUT, RPD5R, 6),
1021             PIC32_PINCTRL_FUNCTION(SDO4, RPD5R, 8),
1022             PIC32_PINCTRL_FUNCTION(SDO6, RPD5R, 10),
1023             PIC32_PINCTRL_FUNCTION(OC2, RPD5R, 11),
1024             PIC32_PINCTRL_FUNCTION(OC1, RPD5R, 12),
1025             PIC32_PINCTRL_FUNCTION(OC9, RPD5R, 13),
1026             PIC32_PINCTRL_FUNCTION(C2TX, RPD5R, 15)),
1027     PIC32_PINCTRL_GROUP(54, D6,
1028             PIC32_PINCTRL_FUNCTION(INT3, INT3R, 14),
1029             PIC32_PINCTRL_FUNCTION(T2CK, T2CKR, 14),
1030             PIC32_PINCTRL_FUNCTION(T6CK, T6CKR, 14),
1031             PIC32_PINCTRL_FUNCTION(IC3, IC3R, 14),
1032             PIC32_PINCTRL_FUNCTION(IC7, IC7R, 14),
1033             PIC32_PINCTRL_FUNCTION(U1RX, U1RXR, 14),
1034             PIC32_PINCTRL_FUNCTION(U2CTS, U2CTSR, 14),
1035             PIC32_PINCTRL_FUNCTION(U5RX, U5RXR, 14),
1036             PIC32_PINCTRL_FUNCTION(U6CTS, U6CTSR, 14),
1037             PIC32_PINCTRL_FUNCTION(SDI1, SDI1R, 14),
1038             PIC32_PINCTRL_FUNCTION(SDI3, SDI3R, 14),
1039             PIC32_PINCTRL_FUNCTION(SDI5, SDI5R, 14),
1040             PIC32_PINCTRL_FUNCTION(SS6IN, SS6INR, 14),
1041             PIC32_PINCTRL_FUNCTION(REFCLKI1, REFCLKI1R, 14),
1042             PIC32_PINCTRL_FUNCTION(U3TX, RPD6R, 1),
1043             PIC32_PINCTRL_FUNCTION(U4RTS, RPD6R, 2),
1044             PIC32_PINCTRL_FUNCTION(SDO1, RPD6R, 5),
1045             PIC32_PINCTRL_FUNCTION(SDO2, RPD6R, 6),
1046             PIC32_PINCTRL_FUNCTION(SDO3, RPD6R, 7),
1047             PIC32_PINCTRL_FUNCTION(SDO5, RPD6R, 9),
1048             PIC32_PINCTRL_FUNCTION(SS6OUT, RPD6R, 10),
1049             PIC32_PINCTRL_FUNCTION(OC3, RPD6R, 11),
1050             PIC32_PINCTRL_FUNCTION(OC6, RPD6R, 12),
1051             PIC32_PINCTRL_FUNCTION(REFCLKO4, RPD6R, 13),
1052             PIC32_PINCTRL_FUNCTION(C2OUT, RPD6R, 14),
1053             PIC32_PINCTRL_FUNCTION(C1TX, RPD6R, 15)),
1054     PIC32_PINCTRL_GROUP(55, D7,
1055             PIC32_PINCTRL_FUNCTION(INT4, INT4R, 14),
1056             PIC32_PINCTRL_FUNCTION(T5CK, T5CKR, 14),
1057             PIC32_PINCTRL_FUNCTION(T7CK, T7CKR, 14),
1058             PIC32_PINCTRL_FUNCTION(IC4, IC4R, 14),
1059             PIC32_PINCTRL_FUNCTION(IC8, IC8R, 14),
1060             PIC32_PINCTRL_FUNCTION(U3RX, U3RXR, 14),
1061             PIC32_PINCTRL_FUNCTION(U4CTS, U4CTSR, 14),
1062             PIC32_PINCTRL_FUNCTION(SDI2, SDI2R, 14),
1063             PIC32_PINCTRL_FUNCTION(SDI4, SDI4R, 14),
1064             PIC32_PINCTRL_FUNCTION(C1RX, C1RXR, 14),
1065             PIC32_PINCTRL_FUNCTION(REFCLKI4, REFCLKI4R, 14),
1066             PIC32_PINCTRL_FUNCTION(U1TX, RPD7R, 1),
1067             PIC32_PINCTRL_FUNCTION(U2RTS, RPD7R, 2),
1068             PIC32_PINCTRL_FUNCTION(U5TX, RPD7R, 3),
1069             PIC32_PINCTRL_FUNCTION(U6RTS, RPD7R, 4),
1070             PIC32_PINCTRL_FUNCTION(SDO1, RPD7R, 5),
1071             PIC32_PINCTRL_FUNCTION(SDO2, RPD7R, 6),
1072             PIC32_PINCTRL_FUNCTION(SDO3, RPD7R, 7),
1073             PIC32_PINCTRL_FUNCTION(SDO4, RPD7R, 8),
1074             PIC32_PINCTRL_FUNCTION(SDO5, RPD7R, 9),
1075             PIC32_PINCTRL_FUNCTION(OC4, RPD7R, 11),
1076             PIC32_PINCTRL_FUNCTION(OC7, RPD7R, 12),
1077             PIC32_PINCTRL_FUNCTION(REFCLKO1, RPD7R, 15)),
1078     PIC32_PINCTRL_GROUP(57, D9,
1079             PIC32_PINCTRL_FUNCTION(INT2, INT2R, 0),
1080             PIC32_PINCTRL_FUNCTION(T3CK, T3CKR, 0),
1081             PIC32_PINCTRL_FUNCTION(T8CK, T8CKR, 0),
1082             PIC32_PINCTRL_FUNCTION(IC2, IC2R, 0),
1083             PIC32_PINCTRL_FUNCTION(IC5, IC5R, 0),
1084             PIC32_PINCTRL_FUNCTION(IC9, IC9R, 0),
1085             PIC32_PINCTRL_FUNCTION(U1CTS, U1CTSR, 0),
1086             PIC32_PINCTRL_FUNCTION(U2RX, U2RXR, 0),
1087             PIC32_PINCTRL_FUNCTION(U5CTS, U5CTSR, 0),
1088             PIC32_PINCTRL_FUNCTION(SS1IN, SS1INR, 0),
1089             PIC32_PINCTRL_FUNCTION(SS3IN, SS3INR, 0),
1090             PIC32_PINCTRL_FUNCTION(SS4IN, SS4INR, 0),
1091             PIC32_PINCTRL_FUNCTION(SS5IN, SS5INR, 0),
1092             PIC32_PINCTRL_FUNCTION(C2RX, C2RXR, 0),
1093             PIC32_PINCTRL_FUNCTION(U3RTS, RPD9R, 1),
1094             PIC32_PINCTRL_FUNCTION(U4TX, RPD9R, 2),
1095             PIC32_PINCTRL_FUNCTION(U6TX, RPD9R, 4),
1096             PIC32_PINCTRL_FUNCTION(SS1OUT, RPD9R, 5),
1097             PIC32_PINCTRL_FUNCTION(SS3OUT, RPD9R, 7),
1098             PIC32_PINCTRL_FUNCTION(SS4OUT, RPD9R, 8),
1099             PIC32_PINCTRL_FUNCTION(SS5OUT, RPD9R, 9),
1100             PIC32_PINCTRL_FUNCTION(SDO6, RPD9R, 10),
1101             PIC32_PINCTRL_FUNCTION(OC5, RPD9R, 11),
1102             PIC32_PINCTRL_FUNCTION(OC8, RPD9R, 12),
1103             PIC32_PINCTRL_FUNCTION(C1OUT, RPD9R, 14),
1104             PIC32_PINCTRL_FUNCTION(REFCLKO3, RPD9R, 15)),
1105     PIC32_PINCTRL_GROUP(58, D10,
1106             PIC32_PINCTRL_FUNCTION(U3TX, RPD10R, 1),
1107             PIC32_PINCTRL_FUNCTION(U4RTS, RPD10R, 2),
1108             PIC32_PINCTRL_FUNCTION(SDO1, RPD10R, 5),
1109             PIC32_PINCTRL_FUNCTION(SDO2, RPD10R, 6),
1110             PIC32_PINCTRL_FUNCTION(SDO3, RPD10R, 7),
1111             PIC32_PINCTRL_FUNCTION(SDO5, RPD10R, 9),
1112             PIC32_PINCTRL_FUNCTION(SS6OUT, RPD10R, 10),
1113             PIC32_PINCTRL_FUNCTION(OC3, RPD10R, 11),
1114             PIC32_PINCTRL_FUNCTION(OC6, RPD10R, 12),
1115             PIC32_PINCTRL_FUNCTION(REFCLKO4, RPD10R, 13),
1116             PIC32_PINCTRL_FUNCTION(C2OUT, RPD10R, 14),
1117             PIC32_PINCTRL_FUNCTION(C1TX, RPD10R, 15)),
1118     PIC32_PINCTRL_GROUP(59, D11,
1119             PIC32_PINCTRL_FUNCTION(INT4, INT4R, 3),
1120             PIC32_PINCTRL_FUNCTION(T5CK, T5CKR, 3),
1121             PIC32_PINCTRL_FUNCTION(T7CK, T7CKR, 3),
1122             PIC32_PINCTRL_FUNCTION(IC4, IC4R, 3),
1123             PIC32_PINCTRL_FUNCTION(IC8, IC8R, 3),
1124             PIC32_PINCTRL_FUNCTION(U3RX, U3RXR, 3),
1125             PIC32_PINCTRL_FUNCTION(U4CTS, U4CTSR, 3),
1126             PIC32_PINCTRL_FUNCTION(SDI2, SDI2R, 3),
1127             PIC32_PINCTRL_FUNCTION(SDI4, SDI4R, 3),
1128             PIC32_PINCTRL_FUNCTION(C1RX, C1RXR, 3),
1129             PIC32_PINCTRL_FUNCTION(REFCLKI4, REFCLKI4R, 3),
1130             PIC32_PINCTRL_FUNCTION(U1TX, RPD11R, 1),
1131             PIC32_PINCTRL_FUNCTION(U2RTS, RPD11R, 2),
1132             PIC32_PINCTRL_FUNCTION(U5TX, RPD11R, 3),
1133             PIC32_PINCTRL_FUNCTION(U6RTS, RPD11R, 4),
1134             PIC32_PINCTRL_FUNCTION(SDO1, RPD11R, 5),
1135             PIC32_PINCTRL_FUNCTION(SDO2, RPD11R, 6),
1136             PIC32_PINCTRL_FUNCTION(SDO3, RPD11R, 7),
1137             PIC32_PINCTRL_FUNCTION(SDO4, RPD11R, 8),
1138             PIC32_PINCTRL_FUNCTION(SDO5, RPD11R, 9),
1139             PIC32_PINCTRL_FUNCTION(OC4, RPD11R, 11),
1140             PIC32_PINCTRL_FUNCTION(OC7, RPD11R, 12),
1141             PIC32_PINCTRL_FUNCTION(REFCLKO1, RPD11R, 15)),
1142     PIC32_PINCTRL_GROUP(60, D12,
1143             PIC32_PINCTRL_FUNCTION(INT2, INT2R, 10),
1144             PIC32_PINCTRL_FUNCTION(T3CK, T3CKR, 10),
1145             PIC32_PINCTRL_FUNCTION(T8CK, T8CKR, 10),
1146             PIC32_PINCTRL_FUNCTION(IC2, IC2R, 10),
1147             PIC32_PINCTRL_FUNCTION(IC5, IC5R, 10),
1148             PIC32_PINCTRL_FUNCTION(IC9, IC9R, 10),
1149             PIC32_PINCTRL_FUNCTION(U1CTS, U1CTSR, 10),
1150             PIC32_PINCTRL_FUNCTION(U2RX, U2RXR, 10),
1151             PIC32_PINCTRL_FUNCTION(U5CTS, U5CTSR, 10),
1152             PIC32_PINCTRL_FUNCTION(SS1IN, SS1INR, 10),
1153             PIC32_PINCTRL_FUNCTION(SS3IN, SS3INR, 10),
1154             PIC32_PINCTRL_FUNCTION(SS4IN, SS4INR, 10),
1155             PIC32_PINCTRL_FUNCTION(SS5IN, SS5INR, 10),
1156             PIC32_PINCTRL_FUNCTION(C2RX, C2RXR, 10),
1157             PIC32_PINCTRL_FUNCTION(U3RTS, RPD12R, 1),
1158             PIC32_PINCTRL_FUNCTION(U4TX, RPD12R, 2),
1159             PIC32_PINCTRL_FUNCTION(U6TX, RPD12R, 4),
1160             PIC32_PINCTRL_FUNCTION(SS1OUT, RPD12R, 5),
1161             PIC32_PINCTRL_FUNCTION(SS3OUT, RPD12R, 7),
1162             PIC32_PINCTRL_FUNCTION(SS4OUT, RPD12R, 8),
1163             PIC32_PINCTRL_FUNCTION(SS5OUT, RPD12R, 9),
1164             PIC32_PINCTRL_FUNCTION(SDO6, RPD12R, 10),
1165             PIC32_PINCTRL_FUNCTION(OC5, RPD12R, 11),
1166             PIC32_PINCTRL_FUNCTION(OC8, RPD12R, 12),
1167             PIC32_PINCTRL_FUNCTION(C1OUT, RPD12R, 14),
1168             PIC32_PINCTRL_FUNCTION(REFCLKO3, RPD12R, 15)),
1169     PIC32_PINCTRL_GROUP(62, D14,
1170             PIC32_PINCTRL_FUNCTION(INT3, INT3R, 11),
1171             PIC32_PINCTRL_FUNCTION(T2CK, T2CKR, 11),
1172             PIC32_PINCTRL_FUNCTION(T6CK, T6CKR, 11),
1173             PIC32_PINCTRL_FUNCTION(IC3, IC3R, 11),
1174             PIC32_PINCTRL_FUNCTION(IC7, IC7R, 11),
1175             PIC32_PINCTRL_FUNCTION(U1RX, U1RXR, 11),
1176             PIC32_PINCTRL_FUNCTION(U2CTS, U2CTSR, 11),
1177             PIC32_PINCTRL_FUNCTION(U5RX, U5RXR, 11),
1178             PIC32_PINCTRL_FUNCTION(U6CTS, U6CTSR, 11),
1179             PIC32_PINCTRL_FUNCTION(SDI1, SDI1R, 11),
1180             PIC32_PINCTRL_FUNCTION(SDI3, SDI3R, 11),
1181             PIC32_PINCTRL_FUNCTION(SDI5, SDI5R, 11),
1182             PIC32_PINCTRL_FUNCTION(SS6IN, SS6INR, 11),
1183             PIC32_PINCTRL_FUNCTION(REFCLKI1, REFCLKI1R, 11),
1184             PIC32_PINCTRL_FUNCTION(U3TX, RPD14R, 1),
1185             PIC32_PINCTRL_FUNCTION(U4RTS, RPD14R, 2),
1186             PIC32_PINCTRL_FUNCTION(SDO1, RPD14R, 5),
1187             PIC32_PINCTRL_FUNCTION(SDO2, RPD14R, 6),
1188             PIC32_PINCTRL_FUNCTION(SDO3, RPD14R, 7),
1189             PIC32_PINCTRL_FUNCTION(SDO5, RPD14R, 9),
1190             PIC32_PINCTRL_FUNCTION(SS6OUT, RPD14R, 10),
1191             PIC32_PINCTRL_FUNCTION(OC3, RPD14R, 11),
1192             PIC32_PINCTRL_FUNCTION(OC6, RPD14R, 12),
1193             PIC32_PINCTRL_FUNCTION(REFCLKO4, RPD14R, 13),
1194             PIC32_PINCTRL_FUNCTION(C2OUT, RPD14R, 14),
1195             PIC32_PINCTRL_FUNCTION(C1TX, RPD14R, 15)),
1196     PIC32_PINCTRL_GROUP(63, D15,
1197             PIC32_PINCTRL_FUNCTION(U1TX, RPD15R, 1),
1198             PIC32_PINCTRL_FUNCTION(U2RTS, RPD15R, 2),
1199             PIC32_PINCTRL_FUNCTION(U5TX, RPD15R, 3),
1200             PIC32_PINCTRL_FUNCTION(U6RTS, RPD15R, 4),
1201             PIC32_PINCTRL_FUNCTION(SDO1, RPD15R, 5),
1202             PIC32_PINCTRL_FUNCTION(SDO2, RPD15R, 6),
1203             PIC32_PINCTRL_FUNCTION(SDO3, RPD15R, 7),
1204             PIC32_PINCTRL_FUNCTION(SDO4, RPD15R, 8),
1205             PIC32_PINCTRL_FUNCTION(SDO5, RPD15R, 9),
1206             PIC32_PINCTRL_FUNCTION(OC4, RPD15R, 11),
1207             PIC32_PINCTRL_FUNCTION(OC7, RPD15R, 12),
1208             PIC32_PINCTRL_FUNCTION(REFCLKO1, RPD15R, 15)),
1209     PIC32_PINCTRL_GROUP(67, E3,
1210             PIC32_PINCTRL_FUNCTION(INT2, INT2R, 6),
1211             PIC32_PINCTRL_FUNCTION(T3CK, T3CKR, 6),
1212             PIC32_PINCTRL_FUNCTION(T8CK, T8CKR, 6),
1213             PIC32_PINCTRL_FUNCTION(IC2, IC2R, 6),
1214             PIC32_PINCTRL_FUNCTION(IC5, IC5R, 6),
1215             PIC32_PINCTRL_FUNCTION(IC9, IC9R, 6),
1216             PIC32_PINCTRL_FUNCTION(U1CTS, U1CTSR, 6),
1217             PIC32_PINCTRL_FUNCTION(U2RX, U2RXR, 6),
1218             PIC32_PINCTRL_FUNCTION(U5CTS, U5CTSR, 6),
1219             PIC32_PINCTRL_FUNCTION(SS1IN, SS1INR, 6),
1220             PIC32_PINCTRL_FUNCTION(SS3IN, SS3INR, 6),
1221             PIC32_PINCTRL_FUNCTION(SS4IN, SS4INR, 6),
1222             PIC32_PINCTRL_FUNCTION(SS5IN, SS5INR, 6),
1223             PIC32_PINCTRL_FUNCTION(C2RX, C2RXR, 6),
1224             PIC32_PINCTRL_FUNCTION(U3RTS, RPE3R, 1),
1225             PIC32_PINCTRL_FUNCTION(U4TX, RPE3R, 2),
1226             PIC32_PINCTRL_FUNCTION(U6TX, RPE3R, 4),
1227             PIC32_PINCTRL_FUNCTION(SS1OUT, RPE3R, 5),
1228             PIC32_PINCTRL_FUNCTION(SS3OUT, RPE3R, 7),
1229             PIC32_PINCTRL_FUNCTION(SS4OUT, RPE3R, 8),
1230             PIC32_PINCTRL_FUNCTION(SS5OUT, RPE3R, 9),
1231             PIC32_PINCTRL_FUNCTION(SDO6, RPE3R, 10),
1232             PIC32_PINCTRL_FUNCTION(OC5, RPE3R, 11),
1233             PIC32_PINCTRL_FUNCTION(OC8, RPE3R, 12),
1234             PIC32_PINCTRL_FUNCTION(C1OUT, RPE3R, 14),
1235             PIC32_PINCTRL_FUNCTION(REFCLKO3, RPE3R, 15)),
1236     PIC32_PINCTRL_GROUP(69, E5,
1237             PIC32_PINCTRL_FUNCTION(INT4, INT4R, 6),
1238             PIC32_PINCTRL_FUNCTION(T5CK, T5CKR, 6),
1239             PIC32_PINCTRL_FUNCTION(T7CK, T7CKR, 6),
1240             PIC32_PINCTRL_FUNCTION(IC4, IC4R, 6),
1241             PIC32_PINCTRL_FUNCTION(IC8, IC8R, 6),
1242             PIC32_PINCTRL_FUNCTION(U3RX, U3RXR, 6),
1243             PIC32_PINCTRL_FUNCTION(U4CTS, U4CTSR, 6),
1244             PIC32_PINCTRL_FUNCTION(SDI2, SDI2R, 6),
1245             PIC32_PINCTRL_FUNCTION(SDI4, SDI4R, 6),
1246             PIC32_PINCTRL_FUNCTION(C1RX, C1RXR, 6),
1247             PIC32_PINCTRL_FUNCTION(REFCLKI4, REFCLKI4R, 6),
1248             PIC32_PINCTRL_FUNCTION(U1TX, RPE5R, 1),
1249             PIC32_PINCTRL_FUNCTION(U2RTS, RPE5R, 2),
1250             PIC32_PINCTRL_FUNCTION(U5TX, RPE5R, 3),
1251             PIC32_PINCTRL_FUNCTION(U6RTS, RPE5R, 4),
1252             PIC32_PINCTRL_FUNCTION(SDO1, RPE5R, 5),
1253             PIC32_PINCTRL_FUNCTION(SDO2, RPE5R, 6),
1254             PIC32_PINCTRL_FUNCTION(SDO3, RPE5R, 7),
1255             PIC32_PINCTRL_FUNCTION(SDO4, RPE5R, 8),
1256             PIC32_PINCTRL_FUNCTION(SDO5, RPE5R, 9),
1257             PIC32_PINCTRL_FUNCTION(OC4, RPE5R, 11),
1258             PIC32_PINCTRL_FUNCTION(OC7, RPE5R, 12),
1259             PIC32_PINCTRL_FUNCTION(REFCLKO1, RPE5R, 15)),
1260     PIC32_PINCTRL_GROUP(72, E8,
1261             PIC32_PINCTRL_FUNCTION(INT1, INT1R, 13),
1262             PIC32_PINCTRL_FUNCTION(T4CK, T4CKR, 13),
1263             PIC32_PINCTRL_FUNCTION(T9CK, T9CKR, 13),
1264             PIC32_PINCTRL_FUNCTION(IC1, IC1R, 13),
1265             PIC32_PINCTRL_FUNCTION(IC6, IC6R, 13),
1266             PIC32_PINCTRL_FUNCTION(U3CTS, U3CTSR, 13),
1267             PIC32_PINCTRL_FUNCTION(U4RX, U4RXR, 13),
1268             PIC32_PINCTRL_FUNCTION(U6RX, U6RXR, 13),
1269             PIC32_PINCTRL_FUNCTION(SS2IN, SS2INR, 13),
1270             PIC32_PINCTRL_FUNCTION(SDI6, SDI6R, 13),
1271             PIC32_PINCTRL_FUNCTION(OCFA, OCFAR, 13),
1272             PIC32_PINCTRL_FUNCTION(REFCLKI3, REFCLKI3R, 13),
1273             PIC32_PINCTRL_FUNCTION(U1RTS, RPE8R, 1),
1274             PIC32_PINCTRL_FUNCTION(U2TX, RPE8R, 2),
1275             PIC32_PINCTRL_FUNCTION(U5RTS, RPE8R, 3),
1276             PIC32_PINCTRL_FUNCTION(U6TX, RPE8R, 4),
1277             PIC32_PINCTRL_FUNCTION(SS2OUT, RPE8R, 6),
1278             PIC32_PINCTRL_FUNCTION(SDO4, RPE8R, 8),
1279             PIC32_PINCTRL_FUNCTION(SDO6, RPE8R, 10),
1280             PIC32_PINCTRL_FUNCTION(OC2, RPE8R, 11),
1281             PIC32_PINCTRL_FUNCTION(OC1, RPE8R, 12),
1282             PIC32_PINCTRL_FUNCTION(OC9, RPE8R, 13),
1283             PIC32_PINCTRL_FUNCTION(C2TX, RPE8R, 15)),
1284     PIC32_PINCTRL_GROUP(73, E9,
1285             PIC32_PINCTRL_FUNCTION(INT2, INT2R, 13),
1286             PIC32_PINCTRL_FUNCTION(T3CK, T3CKR, 13),
1287             PIC32_PINCTRL_FUNCTION(T8CK, T8CKR, 13),
1288             PIC32_PINCTRL_FUNCTION(IC2, IC2R, 13),
1289             PIC32_PINCTRL_FUNCTION(IC5, IC5R, 13),
1290             PIC32_PINCTRL_FUNCTION(IC9, IC9R, 13),
1291             PIC32_PINCTRL_FUNCTION(U1CTS, U1CTSR, 13),
1292             PIC32_PINCTRL_FUNCTION(U2RX, U2RXR, 13),
1293             PIC32_PINCTRL_FUNCTION(U5CTS, U5CTSR, 13),
1294             PIC32_PINCTRL_FUNCTION(SS1IN, SS1INR, 13),
1295             PIC32_PINCTRL_FUNCTION(SS3IN, SS3INR, 13),
1296             PIC32_PINCTRL_FUNCTION(SS4IN, SS4INR, 13),
1297             PIC32_PINCTRL_FUNCTION(SS5IN, SS5INR, 13),
1298             PIC32_PINCTRL_FUNCTION(C2RX, C2RXR, 13),
1299             PIC32_PINCTRL_FUNCTION(U3RTS, RPE9R, 1),
1300             PIC32_PINCTRL_FUNCTION(U4TX, RPE9R, 2),
1301             PIC32_PINCTRL_FUNCTION(U6TX, RPE9R, 4),
1302             PIC32_PINCTRL_FUNCTION(SS1OUT, RPE9R, 5),
1303             PIC32_PINCTRL_FUNCTION(SS3OUT, RPE9R, 7),
1304             PIC32_PINCTRL_FUNCTION(SS4OUT, RPE9R, 8),
1305             PIC32_PINCTRL_FUNCTION(SS5OUT, RPE9R, 9),
1306             PIC32_PINCTRL_FUNCTION(SDO6, RPE9R, 10),
1307             PIC32_PINCTRL_FUNCTION(OC5, RPE9R, 11),
1308             PIC32_PINCTRL_FUNCTION(OC8, RPE9R, 12),
1309             PIC32_PINCTRL_FUNCTION(C1OUT, RPE9R, 14),
1310             PIC32_PINCTRL_FUNCTION(REFCLKO3, RPE9R, 15)),
1311     PIC32_PINCTRL_GROUP(80, F0,
1312             PIC32_PINCTRL_FUNCTION(INT4, INT4R, 4),
1313             PIC32_PINCTRL_FUNCTION(T5CK, T5CKR, 4),
1314             PIC32_PINCTRL_FUNCTION(T7CK, T7CKR, 4),
1315             PIC32_PINCTRL_FUNCTION(IC4, IC4R, 4),
1316             PIC32_PINCTRL_FUNCTION(IC8, IC8R, 4),
1317             PIC32_PINCTRL_FUNCTION(U3RX, U3RXR, 4),
1318             PIC32_PINCTRL_FUNCTION(U4CTS, U4CTSR, 4),
1319             PIC32_PINCTRL_FUNCTION(SDI2, SDI2R, 4),
1320             PIC32_PINCTRL_FUNCTION(SDI4, SDI4R, 4),
1321             PIC32_PINCTRL_FUNCTION(C1RX, C1RXR, 4),
1322             PIC32_PINCTRL_FUNCTION(REFCLKI4, REFCLKI4R, 4),
1323             PIC32_PINCTRL_FUNCTION(U1TX, RPF0R, 1),
1324             PIC32_PINCTRL_FUNCTION(U2RTS, RPF0R, 2),
1325             PIC32_PINCTRL_FUNCTION(U5TX, RPF0R, 3),
1326             PIC32_PINCTRL_FUNCTION(U6RTS, RPF0R, 4),
1327             PIC32_PINCTRL_FUNCTION(SDO1, RPF0R, 5),
1328             PIC32_PINCTRL_FUNCTION(SDO2, RPF0R, 6),
1329             PIC32_PINCTRL_FUNCTION(SDO3, RPF0R, 7),
1330             PIC32_PINCTRL_FUNCTION(SDO4, RPF0R, 8),
1331             PIC32_PINCTRL_FUNCTION(SDO5, RPF0R, 9),
1332             PIC32_PINCTRL_FUNCTION(OC4, RPF0R, 11),
1333             PIC32_PINCTRL_FUNCTION(OC7, RPF0R, 12),
1334             PIC32_PINCTRL_FUNCTION(REFCLKO1, RPF0R, 15)),
1335     PIC32_PINCTRL_GROUP(81, F1,
1336             PIC32_PINCTRL_FUNCTION(INT3, INT3R, 4),
1337             PIC32_PINCTRL_FUNCTION(T2CK, T2CKR, 4),
1338             PIC32_PINCTRL_FUNCTION(T6CK, T6CKR, 4),
1339             PIC32_PINCTRL_FUNCTION(IC3, IC3R, 4),
1340             PIC32_PINCTRL_FUNCTION(IC7, IC7R, 4),
1341             PIC32_PINCTRL_FUNCTION(U1RX, U1RXR, 4),
1342             PIC32_PINCTRL_FUNCTION(U2CTS, U2CTSR, 4),
1343             PIC32_PINCTRL_FUNCTION(U5RX, U5RXR, 4),
1344             PIC32_PINCTRL_FUNCTION(U6CTS, U6CTSR, 4),
1345             PIC32_PINCTRL_FUNCTION(SDI1, SDI1R, 4),
1346             PIC32_PINCTRL_FUNCTION(SDI3, SDI3R, 4),
1347             PIC32_PINCTRL_FUNCTION(SDI5, SDI5R, 4),
1348             PIC32_PINCTRL_FUNCTION(SS6IN, SS6INR, 4),
1349             PIC32_PINCTRL_FUNCTION(REFCLKI1, REFCLKI1R, 4),
1350             PIC32_PINCTRL_FUNCTION(U3TX, RPF1R, 1),
1351             PIC32_PINCTRL_FUNCTION(U4RTS, RPF1R, 2),
1352             PIC32_PINCTRL_FUNCTION(SDO1, RPF1R, 5),
1353             PIC32_PINCTRL_FUNCTION(SDO2, RPF1R, 6),
1354             PIC32_PINCTRL_FUNCTION(SDO3, RPF1R, 7),
1355             PIC32_PINCTRL_FUNCTION(SDO5, RPF1R, 9),
1356             PIC32_PINCTRL_FUNCTION(SS6OUT, RPF1R, 10),
1357             PIC32_PINCTRL_FUNCTION(OC3, RPF1R, 11),
1358             PIC32_PINCTRL_FUNCTION(OC6, RPF1R, 12),
1359             PIC32_PINCTRL_FUNCTION(REFCLKO4, RPF1R, 13),
1360             PIC32_PINCTRL_FUNCTION(C2OUT, RPF1R, 14),
1361             PIC32_PINCTRL_FUNCTION(C1TX, RPF1R, 15)),
1362     PIC32_PINCTRL_GROUP(82, F2,
1363             PIC32_PINCTRL_FUNCTION(INT1, INT1R, 11),
1364             PIC32_PINCTRL_FUNCTION(T4CK, T4CKR, 11),
1365             PIC32_PINCTRL_FUNCTION(T9CK, T9CKR, 11),
1366             PIC32_PINCTRL_FUNCTION(IC1, IC1R, 11),
1367             PIC32_PINCTRL_FUNCTION(IC6, IC6R, 11),
1368             PIC32_PINCTRL_FUNCTION(U3CTS, U3CTSR, 11),
1369             PIC32_PINCTRL_FUNCTION(U4RX, U4RXR, 11),
1370             PIC32_PINCTRL_FUNCTION(U6RX, U6RXR, 11),
1371             PIC32_PINCTRL_FUNCTION(SS2IN, SS2INR, 11),
1372             PIC32_PINCTRL_FUNCTION(SDI6, SDI6R, 11),
1373             PIC32_PINCTRL_FUNCTION(OCFA, OCFAR, 11),
1374             PIC32_PINCTRL_FUNCTION(REFCLKI3, REFCLKI3R, 11),
1375             PIC32_PINCTRL_FUNCTION(U1RTS, RPF2R, 1),
1376             PIC32_PINCTRL_FUNCTION(U2TX, RPF2R, 2),
1377             PIC32_PINCTRL_FUNCTION(U5RTS, RPF2R, 3),
1378             PIC32_PINCTRL_FUNCTION(U6TX, RPF2R, 4),
1379             PIC32_PINCTRL_FUNCTION(SS2OUT, RPF2R, 6),
1380             PIC32_PINCTRL_FUNCTION(SDO4, RPF2R, 8),
1381             PIC32_PINCTRL_FUNCTION(SDO6, RPF2R, 10),
1382             PIC32_PINCTRL_FUNCTION(OC2, RPF2R, 11),
1383             PIC32_PINCTRL_FUNCTION(OC1, RPF2R, 12),
1384             PIC32_PINCTRL_FUNCTION(OC9, RPF2R, 13),
1385             PIC32_PINCTRL_FUNCTION(C2TX, RPF2R, 15)),
1386     PIC32_PINCTRL_GROUP(83, F3,
1387             PIC32_PINCTRL_FUNCTION(INT1, INT1R, 8),
1388             PIC32_PINCTRL_FUNCTION(T4CK, T4CKR, 8),
1389             PIC32_PINCTRL_FUNCTION(T9CK, T9CKR, 8),
1390             PIC32_PINCTRL_FUNCTION(IC1, IC1R, 8),
1391             PIC32_PINCTRL_FUNCTION(IC6, IC6R, 8),
1392             PIC32_PINCTRL_FUNCTION(U3CTS, U3CTSR, 8),
1393             PIC32_PINCTRL_FUNCTION(U4RX, U4RXR, 8),
1394             PIC32_PINCTRL_FUNCTION(U6RX, U6RXR, 8),
1395             PIC32_PINCTRL_FUNCTION(SS2IN, SS2INR, 8),
1396             PIC32_PINCTRL_FUNCTION(SDI6, SDI6R, 8),
1397             PIC32_PINCTRL_FUNCTION(OCFA, OCFAR, 8),
1398             PIC32_PINCTRL_FUNCTION(REFCLKI3, REFCLKI3R, 8),
1399             PIC32_PINCTRL_FUNCTION(U1RTS, RPF3R, 1),
1400             PIC32_PINCTRL_FUNCTION(U2TX, RPF3R, 2),
1401             PIC32_PINCTRL_FUNCTION(U5RTS, RPF3R, 3),
1402             PIC32_PINCTRL_FUNCTION(U6TX, RPF3R, 4),
1403             PIC32_PINCTRL_FUNCTION(SS2OUT, RPF3R, 6),
1404             PIC32_PINCTRL_FUNCTION(SDO4, RPF3R, 8),
1405             PIC32_PINCTRL_FUNCTION(SDO6, RPF3R, 10),
1406             PIC32_PINCTRL_FUNCTION(OC2, RPF3R, 11),
1407             PIC32_PINCTRL_FUNCTION(OC1, RPF3R, 12),
1408             PIC32_PINCTRL_FUNCTION(OC9, RPF3R, 13),
1409             PIC32_PINCTRL_FUNCTION(C2TX, RPF3R, 15)),
1410     PIC32_PINCTRL_GROUP(84, F4,
1411             PIC32_PINCTRL_FUNCTION(INT3, INT3R, 2),
1412             PIC32_PINCTRL_FUNCTION(T2CK, T2CKR, 2),
1413             PIC32_PINCTRL_FUNCTION(T6CK, T6CKR, 2),
1414             PIC32_PINCTRL_FUNCTION(IC3, IC3R, 2),
1415             PIC32_PINCTRL_FUNCTION(IC7, IC7R, 2),
1416             PIC32_PINCTRL_FUNCTION(U1RX, U1RXR, 2),
1417             PIC32_PINCTRL_FUNCTION(U2CTS, U2CTSR, 2),
1418             PIC32_PINCTRL_FUNCTION(U5RX, U5RXR, 2),
1419             PIC32_PINCTRL_FUNCTION(U6CTS, U6CTSR, 2),
1420             PIC32_PINCTRL_FUNCTION(SDI1, SDI1R, 2),
1421             PIC32_PINCTRL_FUNCTION(SDI3, SDI3R, 2),
1422             PIC32_PINCTRL_FUNCTION(SDI5, SDI5R, 2),
1423             PIC32_PINCTRL_FUNCTION(SS6IN, SS6INR, 2),
1424             PIC32_PINCTRL_FUNCTION(REFCLKI1, REFCLKI1R, 2),
1425             PIC32_PINCTRL_FUNCTION(U3TX, RPF4R, 1),
1426             PIC32_PINCTRL_FUNCTION(U4RTS, RPF4R, 2),
1427             PIC32_PINCTRL_FUNCTION(SDO1, RPF4R, 5),
1428             PIC32_PINCTRL_FUNCTION(SDO2, RPF4R, 6),
1429             PIC32_PINCTRL_FUNCTION(SDO3, RPF4R, 7),
1430             PIC32_PINCTRL_FUNCTION(SDO5, RPF4R, 9),
1431             PIC32_PINCTRL_FUNCTION(SS6OUT, RPF4R, 10),
1432             PIC32_PINCTRL_FUNCTION(OC3, RPF4R, 11),
1433             PIC32_PINCTRL_FUNCTION(OC6, RPF4R, 12),
1434             PIC32_PINCTRL_FUNCTION(REFCLKO4, RPF4R, 13),
1435             PIC32_PINCTRL_FUNCTION(C2OUT, RPF4R, 14),
1436             PIC32_PINCTRL_FUNCTION(C1TX, RPF4R, 15)),
1437     PIC32_PINCTRL_GROUP(85, F5,
1438             PIC32_PINCTRL_FUNCTION(INT4, INT4R, 2),
1439             PIC32_PINCTRL_FUNCTION(T5CK, T5CKR, 2),
1440             PIC32_PINCTRL_FUNCTION(T7CK, T7CKR, 2),
1441             PIC32_PINCTRL_FUNCTION(IC4, IC4R, 2),
1442             PIC32_PINCTRL_FUNCTION(IC8, IC8R, 2),
1443             PIC32_PINCTRL_FUNCTION(U3RX, U3RXR, 2),
1444             PIC32_PINCTRL_FUNCTION(U4CTS, U4CTSR, 2),
1445             PIC32_PINCTRL_FUNCTION(SDI2, SDI2R, 2),
1446             PIC32_PINCTRL_FUNCTION(SDI4, SDI4R, 2),
1447             PIC32_PINCTRL_FUNCTION(C1RX, C1RXR, 2),
1448             PIC32_PINCTRL_FUNCTION(REFCLKI4, REFCLKI4R, 2),
1449             PIC32_PINCTRL_FUNCTION(U1TX, RPF5R, 1),
1450             PIC32_PINCTRL_FUNCTION(U2RTS, RPF5R, 2),
1451             PIC32_PINCTRL_FUNCTION(U5TX, RPF5R, 3),
1452             PIC32_PINCTRL_FUNCTION(U6RTS, RPF5R, 4),
1453             PIC32_PINCTRL_FUNCTION(SDO1, RPF5R, 5),
1454             PIC32_PINCTRL_FUNCTION(SDO2, RPF5R, 6),
1455             PIC32_PINCTRL_FUNCTION(SDO3, RPF5R, 7),
1456             PIC32_PINCTRL_FUNCTION(SDO4, RPF5R, 8),
1457             PIC32_PINCTRL_FUNCTION(SDO5, RPF5R, 9),
1458             PIC32_PINCTRL_FUNCTION(OC4, RPF5R, 11),
1459             PIC32_PINCTRL_FUNCTION(OC7, RPF5R, 12),
1460             PIC32_PINCTRL_FUNCTION(REFCLKO1, RPF5R, 15)),
1461     PIC32_PINCTRL_GROUP(88, F8,
1462             PIC32_PINCTRL_FUNCTION(INT2, INT2R, 11),
1463             PIC32_PINCTRL_FUNCTION(T3CK, T3CKR, 11),
1464             PIC32_PINCTRL_FUNCTION(T8CK, T8CKR, 11),
1465             PIC32_PINCTRL_FUNCTION(IC2, IC2R, 11),
1466             PIC32_PINCTRL_FUNCTION(IC5, IC5R, 11),
1467             PIC32_PINCTRL_FUNCTION(IC9, IC9R, 11),
1468             PIC32_PINCTRL_FUNCTION(U1CTS, U1CTSR, 11),
1469             PIC32_PINCTRL_FUNCTION(U2RX, U2RXR, 11),
1470             PIC32_PINCTRL_FUNCTION(U5CTS, U5CTSR, 11),
1471             PIC32_PINCTRL_FUNCTION(SS1IN, SS1INR, 11),
1472             PIC32_PINCTRL_FUNCTION(SS3IN, SS3INR, 11),
1473             PIC32_PINCTRL_FUNCTION(SS4IN, SS4INR, 11),
1474             PIC32_PINCTRL_FUNCTION(SS5IN, SS5INR, 11),
1475             PIC32_PINCTRL_FUNCTION(C2RX, C2RXR, 11),
1476             PIC32_PINCTRL_FUNCTION(U3RTS, RPF8R, 1),
1477             PIC32_PINCTRL_FUNCTION(U4TX, RPF8R, 2),
1478             PIC32_PINCTRL_FUNCTION(U6TX, RPF8R, 4),
1479             PIC32_PINCTRL_FUNCTION(SS1OUT, RPF8R, 5),
1480             PIC32_PINCTRL_FUNCTION(SS3OUT, RPF8R, 7),
1481             PIC32_PINCTRL_FUNCTION(SS4OUT, RPF8R, 8),
1482             PIC32_PINCTRL_FUNCTION(SS5OUT, RPF8R, 9),
1483             PIC32_PINCTRL_FUNCTION(SDO6, RPF8R, 10),
1484             PIC32_PINCTRL_FUNCTION(OC5, RPF8R, 11),
1485             PIC32_PINCTRL_FUNCTION(OC8, RPF8R, 12),
1486             PIC32_PINCTRL_FUNCTION(C1OUT, RPF8R, 14),
1487             PIC32_PINCTRL_FUNCTION(REFCLKO3, RPF8R, 15)),
1488     PIC32_PINCTRL_GROUP(92, F12,
1489             PIC32_PINCTRL_FUNCTION(INT2, INT2R, 9),
1490             PIC32_PINCTRL_FUNCTION(T3CK, T3CKR, 9),
1491             PIC32_PINCTRL_FUNCTION(T8CK, T8CKR, 9),
1492             PIC32_PINCTRL_FUNCTION(IC2, IC2R, 9),
1493             PIC32_PINCTRL_FUNCTION(IC5, IC5R, 9),
1494             PIC32_PINCTRL_FUNCTION(IC9, IC9R, 9),
1495             PIC32_PINCTRL_FUNCTION(U1CTS, U1CTSR, 9),
1496             PIC32_PINCTRL_FUNCTION(U2RX, U2RXR, 9),
1497             PIC32_PINCTRL_FUNCTION(U5CTS, U5CTSR, 9),
1498             PIC32_PINCTRL_FUNCTION(SS1IN, SS1INR, 9),
1499             PIC32_PINCTRL_FUNCTION(SS3IN, SS3INR, 9),
1500             PIC32_PINCTRL_FUNCTION(SS4IN, SS4INR, 9),
1501             PIC32_PINCTRL_FUNCTION(SS5IN, SS5INR, 9),
1502             PIC32_PINCTRL_FUNCTION(C2RX, C2RXR, 9),
1503             PIC32_PINCTRL_FUNCTION(U3RTS, RPF12R, 1),
1504             PIC32_PINCTRL_FUNCTION(U4TX, RPF12R, 2),
1505             PIC32_PINCTRL_FUNCTION(U6TX, RPF12R, 4),
1506             PIC32_PINCTRL_FUNCTION(SS1OUT, RPF12R, 5),
1507             PIC32_PINCTRL_FUNCTION(SS3OUT, RPF12R, 7),
1508             PIC32_PINCTRL_FUNCTION(SS4OUT, RPF12R, 8),
1509             PIC32_PINCTRL_FUNCTION(SS5OUT, RPF12R, 9),
1510             PIC32_PINCTRL_FUNCTION(SDO6, RPF12R, 10),
1511             PIC32_PINCTRL_FUNCTION(OC5, RPF12R, 11),
1512             PIC32_PINCTRL_FUNCTION(OC8, RPF12R, 12),
1513             PIC32_PINCTRL_FUNCTION(C1OUT, RPF12R, 14),
1514             PIC32_PINCTRL_FUNCTION(REFCLKO3, RPF12R, 15)),
1515     PIC32_PINCTRL_GROUP(93, F13,
1516             PIC32_PINCTRL_FUNCTION(INT1, INT1R, 9),
1517             PIC32_PINCTRL_FUNCTION(T4CK, T4CKR, 9),
1518             PIC32_PINCTRL_FUNCTION(T9CK, T9CKR, 9),
1519             PIC32_PINCTRL_FUNCTION(IC1, IC1R, 9),
1520             PIC32_PINCTRL_FUNCTION(IC6, IC6R, 9),
1521             PIC32_PINCTRL_FUNCTION(U3CTS, U3CTSR, 9),
1522             PIC32_PINCTRL_FUNCTION(U4RX, U4RXR, 9),
1523             PIC32_PINCTRL_FUNCTION(U6RX, U6RXR, 9),
1524             PIC32_PINCTRL_FUNCTION(SS2IN, SS2INR, 9),
1525             PIC32_PINCTRL_FUNCTION(SDI6, SDI6R, 9),
1526             PIC32_PINCTRL_FUNCTION(OCFA, OCFAR, 9),
1527             PIC32_PINCTRL_FUNCTION(REFCLKI3, REFCLKI3R, 9),
1528             PIC32_PINCTRL_FUNCTION(U1RTS, RPF13R, 1),
1529             PIC32_PINCTRL_FUNCTION(U2TX, RPF13R, 2),
1530             PIC32_PINCTRL_FUNCTION(U5RTS, RPF13R, 3),
1531             PIC32_PINCTRL_FUNCTION(U6TX, RPF13R, 4),
1532             PIC32_PINCTRL_FUNCTION(SS2OUT, RPF13R, 6),
1533             PIC32_PINCTRL_FUNCTION(SDO4, RPF13R, 8),
1534             PIC32_PINCTRL_FUNCTION(SDO6, RPF13R, 10),
1535             PIC32_PINCTRL_FUNCTION(OC2, RPF13R, 11),
1536             PIC32_PINCTRL_FUNCTION(OC1, RPF13R, 12),
1537             PIC32_PINCTRL_FUNCTION(OC9, RPF13R, 13),
1538             PIC32_PINCTRL_FUNCTION(C2TX, RPF13R, 15)),
1539     PIC32_PINCTRL_GROUP(96, G0,
1540             PIC32_PINCTRL_FUNCTION(INT4, INT4R, 12),
1541             PIC32_PINCTRL_FUNCTION(T5CK, T5CKR, 12),
1542             PIC32_PINCTRL_FUNCTION(T7CK, T7CKR, 12),
1543             PIC32_PINCTRL_FUNCTION(IC4, IC4R, 12),
1544             PIC32_PINCTRL_FUNCTION(IC8, IC8R, 12),
1545             PIC32_PINCTRL_FUNCTION(U3RX, U3RXR, 12),
1546             PIC32_PINCTRL_FUNCTION(U4CTS, U4CTSR, 12),
1547             PIC32_PINCTRL_FUNCTION(SDI2, SDI2R, 12),
1548             PIC32_PINCTRL_FUNCTION(SDI4, SDI4R, 12),
1549             PIC32_PINCTRL_FUNCTION(C1RX, C1RXR, 12),
1550             PIC32_PINCTRL_FUNCTION(REFCLKI4, REFCLKI4R, 12),
1551             PIC32_PINCTRL_FUNCTION(U1TX, RPG0R, 1),
1552             PIC32_PINCTRL_FUNCTION(U2RTS, RPG0R, 2),
1553             PIC32_PINCTRL_FUNCTION(U5TX, RPG0R, 3),
1554             PIC32_PINCTRL_FUNCTION(U6RTS, RPG0R, 4),
1555             PIC32_PINCTRL_FUNCTION(SDO1, RPG0R, 5),
1556             PIC32_PINCTRL_FUNCTION(SDO2, RPG0R, 6),
1557             PIC32_PINCTRL_FUNCTION(SDO3, RPG0R, 7),
1558             PIC32_PINCTRL_FUNCTION(SDO4, RPG0R, 8),
1559             PIC32_PINCTRL_FUNCTION(SDO5, RPG0R, 9),
1560             PIC32_PINCTRL_FUNCTION(OC4, RPG0R, 11),
1561             PIC32_PINCTRL_FUNCTION(OC7, RPG0R, 12),
1562             PIC32_PINCTRL_FUNCTION(REFCLKO1, RPG0R, 15)),
1563     PIC32_PINCTRL_GROUP(97, G1,
1564             PIC32_PINCTRL_FUNCTION(INT3, INT3R, 12),
1565             PIC32_PINCTRL_FUNCTION(T2CK, T2CKR, 12),
1566             PIC32_PINCTRL_FUNCTION(T6CK, T6CKR, 12),
1567             PIC32_PINCTRL_FUNCTION(IC3, IC3R, 12),
1568             PIC32_PINCTRL_FUNCTION(IC7, IC7R, 12),
1569             PIC32_PINCTRL_FUNCTION(U1RX, U1RXR, 12),
1570             PIC32_PINCTRL_FUNCTION(U2CTS, U2CTSR, 12),
1571             PIC32_PINCTRL_FUNCTION(U5RX, U5RXR, 12),
1572             PIC32_PINCTRL_FUNCTION(U6CTS, U6CTSR, 12),
1573             PIC32_PINCTRL_FUNCTION(SDI1, SDI1R, 12),
1574             PIC32_PINCTRL_FUNCTION(SDI3, SDI3R, 12),
1575             PIC32_PINCTRL_FUNCTION(SDI5, SDI5R, 12),
1576             PIC32_PINCTRL_FUNCTION(SS6IN, SS6INR, 12),
1577             PIC32_PINCTRL_FUNCTION(REFCLKI1, REFCLKI1R, 12),
1578             PIC32_PINCTRL_FUNCTION(U3TX, RPG1R, 1),
1579             PIC32_PINCTRL_FUNCTION(U4RTS, RPG1R, 2),
1580             PIC32_PINCTRL_FUNCTION(SDO1, RPG1R, 5),
1581             PIC32_PINCTRL_FUNCTION(SDO2, RPG1R, 6),
1582             PIC32_PINCTRL_FUNCTION(SDO3, RPG1R, 7),
1583             PIC32_PINCTRL_FUNCTION(SDO5, RPG1R, 9),
1584             PIC32_PINCTRL_FUNCTION(SS6OUT, RPG1R, 10),
1585             PIC32_PINCTRL_FUNCTION(OC3, RPG1R, 11),
1586             PIC32_PINCTRL_FUNCTION(OC6, RPG1R, 12),
1587             PIC32_PINCTRL_FUNCTION(REFCLKO4, RPG1R, 13),
1588             PIC32_PINCTRL_FUNCTION(C2OUT, RPG1R, 14),
1589             PIC32_PINCTRL_FUNCTION(C1TX, RPG1R, 15)),
1590     PIC32_PINCTRL_GROUP(102, G6,
1591             PIC32_PINCTRL_FUNCTION(INT2, INT2R, 1),
1592             PIC32_PINCTRL_FUNCTION(T3CK, T3CKR, 1),
1593             PIC32_PINCTRL_FUNCTION(T8CK, T8CKR, 1),
1594             PIC32_PINCTRL_FUNCTION(IC2, IC2R, 1),
1595             PIC32_PINCTRL_FUNCTION(IC5, IC5R, 1),
1596             PIC32_PINCTRL_FUNCTION(IC9, IC9R, 1),
1597             PIC32_PINCTRL_FUNCTION(U1CTS, U1CTSR, 1),
1598             PIC32_PINCTRL_FUNCTION(U2RX, U2RXR, 1),
1599             PIC32_PINCTRL_FUNCTION(U5CTS, U5CTSR, 1),
1600             PIC32_PINCTRL_FUNCTION(SS1IN, SS1INR, 1),
1601             PIC32_PINCTRL_FUNCTION(SS3IN, SS3INR, 1),
1602             PIC32_PINCTRL_FUNCTION(SS4IN, SS4INR, 1),
1603             PIC32_PINCTRL_FUNCTION(SS5IN, SS5INR, 1),
1604             PIC32_PINCTRL_FUNCTION(C2RX, C2RXR, 1),
1605             PIC32_PINCTRL_FUNCTION(U3RTS, RPG6R, 1),
1606             PIC32_PINCTRL_FUNCTION(U4TX, RPG6R, 2),
1607             PIC32_PINCTRL_FUNCTION(U6TX, RPG6R, 4),
1608             PIC32_PINCTRL_FUNCTION(SS1OUT, RPG6R, 5),
1609             PIC32_PINCTRL_FUNCTION(SS3OUT, RPG6R, 7),
1610             PIC32_PINCTRL_FUNCTION(SS4OUT, RPG6R, 8),
1611             PIC32_PINCTRL_FUNCTION(SS5OUT, RPG6R, 9),
1612             PIC32_PINCTRL_FUNCTION(SDO6, RPG6R, 10),
1613             PIC32_PINCTRL_FUNCTION(OC5, RPG6R, 11),
1614             PIC32_PINCTRL_FUNCTION(OC8, RPG6R, 12),
1615             PIC32_PINCTRL_FUNCTION(C1OUT, RPG6R, 14),
1616             PIC32_PINCTRL_FUNCTION(REFCLKO3, RPG6R, 15)),
1617     PIC32_PINCTRL_GROUP(103, G7,
1618             PIC32_PINCTRL_FUNCTION(INT4, INT4R, 1),
1619             PIC32_PINCTRL_FUNCTION(T5CK, T5CKR, 1),
1620             PIC32_PINCTRL_FUNCTION(T7CK, T7CKR, 1),
1621             PIC32_PINCTRL_FUNCTION(IC4, IC4R, 1),
1622             PIC32_PINCTRL_FUNCTION(IC8, IC8R, 1),
1623             PIC32_PINCTRL_FUNCTION(U3RX, U3RXR, 1),
1624             PIC32_PINCTRL_FUNCTION(U4CTS, U4CTSR, 1),
1625             PIC32_PINCTRL_FUNCTION(SDI2, SDI2R, 1),
1626             PIC32_PINCTRL_FUNCTION(SDI4, SDI4R, 1),
1627             PIC32_PINCTRL_FUNCTION(C1RX, C1RXR, 1),
1628             PIC32_PINCTRL_FUNCTION(REFCLKI4, REFCLKI4R, 1),
1629             PIC32_PINCTRL_FUNCTION(U1TX, RPG7R, 1),
1630             PIC32_PINCTRL_FUNCTION(U2RTS, RPG7R, 2),
1631             PIC32_PINCTRL_FUNCTION(U5TX, RPG7R, 3),
1632             PIC32_PINCTRL_FUNCTION(U6RTS, RPG7R, 4),
1633             PIC32_PINCTRL_FUNCTION(SDO1, RPG7R, 5),
1634             PIC32_PINCTRL_FUNCTION(SDO2, RPG7R, 6),
1635             PIC32_PINCTRL_FUNCTION(SDO3, RPG7R, 7),
1636             PIC32_PINCTRL_FUNCTION(SDO4, RPG7R, 8),
1637             PIC32_PINCTRL_FUNCTION(SDO5, RPG7R, 9),
1638             PIC32_PINCTRL_FUNCTION(OC4, RPG7R, 11),
1639             PIC32_PINCTRL_FUNCTION(OC7, RPG7R, 12),
1640             PIC32_PINCTRL_FUNCTION(REFCLKO1, RPG7R, 15)),
1641     PIC32_PINCTRL_GROUP(104, G8,
1642             PIC32_PINCTRL_FUNCTION(INT3, INT3R, 1),
1643             PIC32_PINCTRL_FUNCTION(T2CK, T2CKR, 1),
1644             PIC32_PINCTRL_FUNCTION(T6CK, T6CKR, 1),
1645             PIC32_PINCTRL_FUNCTION(IC3, IC3R, 1),
1646             PIC32_PINCTRL_FUNCTION(IC7, IC7R, 1),
1647             PIC32_PINCTRL_FUNCTION(U1RX, U1RXR, 1),
1648             PIC32_PINCTRL_FUNCTION(U2CTS, U2CTSR, 1),
1649             PIC32_PINCTRL_FUNCTION(U5RX, U5RXR, 1),
1650             PIC32_PINCTRL_FUNCTION(U6CTS, U6CTSR, 1),
1651             PIC32_PINCTRL_FUNCTION(SDI1, SDI1R, 1),
1652             PIC32_PINCTRL_FUNCTION(SDI3, SDI3R, 1),
1653             PIC32_PINCTRL_FUNCTION(SDI5, SDI5R, 1),
1654             PIC32_PINCTRL_FUNCTION(SS6IN, SS6INR, 1),
1655             PIC32_PINCTRL_FUNCTION(REFCLKI1, REFCLKI1R, 1),
1656             PIC32_PINCTRL_FUNCTION(U3TX, RPG8R, 1),
1657             PIC32_PINCTRL_FUNCTION(U4RTS, RPG8R, 2),
1658             PIC32_PINCTRL_FUNCTION(SDO1, RPG8R, 5),
1659             PIC32_PINCTRL_FUNCTION(SDO2, RPG8R, 6),
1660             PIC32_PINCTRL_FUNCTION(SDO3, RPG8R, 7),
1661             PIC32_PINCTRL_FUNCTION(SDO5, RPG8R, 9),
1662             PIC32_PINCTRL_FUNCTION(SS6OUT, RPG8R, 10),
1663             PIC32_PINCTRL_FUNCTION(OC3, RPG8R, 11),
1664             PIC32_PINCTRL_FUNCTION(OC6, RPG8R, 12),
1665             PIC32_PINCTRL_FUNCTION(REFCLKO4, RPG8R, 13),
1666             PIC32_PINCTRL_FUNCTION(C2OUT, RPG8R, 14),
1667             PIC32_PINCTRL_FUNCTION(C1TX, RPG8R, 15)),
1668     PIC32_PINCTRL_GROUP(105, G9,
1669             PIC32_PINCTRL_FUNCTION(INT1, INT1R, 1),
1670             PIC32_PINCTRL_FUNCTION(T4CK, T4CKR, 1),
1671             PIC32_PINCTRL_FUNCTION(T9CK, T9CKR, 1),
1672             PIC32_PINCTRL_FUNCTION(IC1, IC1R, 1),
1673             PIC32_PINCTRL_FUNCTION(IC6, IC6R, 1),
1674             PIC32_PINCTRL_FUNCTION(U3CTS, U3CTSR, 1),
1675             PIC32_PINCTRL_FUNCTION(U4RX, U4RXR, 1),
1676             PIC32_PINCTRL_FUNCTION(U6RX, U6RXR, 1),
1677             PIC32_PINCTRL_FUNCTION(SS2IN, SS2INR, 1),
1678             PIC32_PINCTRL_FUNCTION(SDI6, SDI6R, 1),
1679             PIC32_PINCTRL_FUNCTION(OCFA, OCFAR, 1),
1680             PIC32_PINCTRL_FUNCTION(REFCLKI3, REFCLKI3R, 1),
1681             PIC32_PINCTRL_FUNCTION(U1RTS, RPG9R, 1),
1682             PIC32_PINCTRL_FUNCTION(U2TX, RPG9R, 2),
1683             PIC32_PINCTRL_FUNCTION(U5RTS, RPG9R, 3),
1684             PIC32_PINCTRL_FUNCTION(U6TX, RPG9R, 4),
1685             PIC32_PINCTRL_FUNCTION(SS2OUT, RPG9R, 6),
1686             PIC32_PINCTRL_FUNCTION(SDO4, RPG9R, 8),
1687             PIC32_PINCTRL_FUNCTION(SDO6, RPG9R, 10),
1688             PIC32_PINCTRL_FUNCTION(OC2, RPG9R, 11),
1689             PIC32_PINCTRL_FUNCTION(OC1, RPG9R, 12),
1690             PIC32_PINCTRL_FUNCTION(OC9, RPG9R, 13),
1691             PIC32_PINCTRL_FUNCTION(C2TX, RPG9R, 15)),
1692 };
1693
1694 static inline struct pic32_gpio_bank *irqd_to_bank(struct irq_data *d)
1695 {
1696     return gpiochip_get_data(irq_data_get_irq_chip_data(d));
1697 }
1698
1699 static inline struct pic32_gpio_bank *pctl_to_bank(struct pic32_pinctrl *pctl,
1700                         unsigned pin)
1701 {
1702     return &pctl->gpio_banks[pin / PINS_PER_BANK];
1703 }
1704
1705 static int pic32_pinctrl_get_groups_count(struct pinctrl_dev *pctldev)
1706 {
1707     struct pic32_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
1708
1709     return pctl->ngroups;
1710 }
1711
1712 static const char *pic32_pinctrl_get_group_name(struct pinctrl_dev *pctldev,
1713                             unsigned group)
1714 {
1715     struct pic32_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
1716
1717     return pctl->groups[group].name;
1718 }
1719
1720 static int pic32_pinctrl_get_group_pins(struct pinctrl_dev *pctldev,
1721                         unsigned group,
1722                         const unsigned **pins,
1723                         unsigned *num_pins)
1724 {
1725     struct pic32_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
1726
1727     *pins = &pctl->groups[group].pin;
1728     *num_pins = 1;
1729
1730     return 0;
1731 }
1732
1733 static const struct pinctrl_ops pic32_pinctrl_ops = {
1734     .get_groups_count = pic32_pinctrl_get_groups_count,
1735     .get_group_name = pic32_pinctrl_get_group_name,
1736     .get_group_pins = pic32_pinctrl_get_group_pins,
1737     .dt_node_to_map = pinconf_generic_dt_node_to_map_pin,
1738     .dt_free_map = pinctrl_utils_free_map,
1739 };
1740
1741 static int pic32_pinmux_get_functions_count(struct pinctrl_dev *pctldev)
1742 {
1743     struct pic32_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
1744
1745     return pctl->nfunctions;
1746 }
1747
1748 static const char *
1749 pic32_pinmux_get_function_name(struct pinctrl_dev *pctldev, unsigned func)
1750 {
1751     struct pic32_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
1752
1753     return pctl->functions[func].name;
1754 }
1755
1756 static int pic32_pinmux_get_function_groups(struct pinctrl_dev *pctldev,
1757                         unsigned func,
1758                         const char * const **groups,
1759                         unsigned * const num_groups)
1760 {
1761     struct pic32_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
1762
1763     *groups = pctl->functions[func].groups;
1764     *num_groups = pctl->functions[func].ngroups;
1765
1766     return 0;
1767 }
1768
1769 static int pic32_pinmux_enable(struct pinctrl_dev *pctldev,
1770                    unsigned func, unsigned group)
1771 {
1772     struct pic32_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
1773     const struct pic32_pin_group *pg = &pctl->groups[group];
1774     const struct pic32_function *pf = &pctl->functions[func];
1775     const char *fname = pf->name;
1776     struct pic32_desc_function *functions = pg->functions;
1777
1778     while (functions->name) {
1779         if (!strcmp(functions->name, fname)) {
1780             dev_dbg(pctl->dev,
1781                 "setting function %s reg 0x%x = %d\n",
1782                 fname, functions->muxreg, functions->muxval);
1783
1784             writel(functions->muxval, pctl->reg_base + functions->muxreg);
1785
1786             return 0;
1787         }
1788
1789         functions++;
1790     }
1791
1792     dev_err(pctl->dev, "cannot mux pin %u to function %u\n", group, func);
1793
1794     return -EINVAL;
1795 }
1796
1797 static int pic32_gpio_request_enable(struct pinctrl_dev *pctldev,
1798                      struct pinctrl_gpio_range *range,
1799                      unsigned offset)
1800 {
1801     struct pic32_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
1802     struct pic32_gpio_bank *bank = gpiochip_get_data(range->gc);
1803     u32 mask = BIT(offset - bank->gpio_chip.base);
1804
1805     dev_dbg(pctl->dev, "requesting gpio %d in bank %d with mask 0x%x\n",
1806         offset, bank->gpio_chip.base, mask);
1807
1808     writel(mask, bank->reg_base + PIC32_CLR(ANSEL_REG));
1809
1810     return 0;
1811 }
1812
1813 static int pic32_gpio_direction_input(struct gpio_chip *chip,
1814                       unsigned offset)
1815 {
1816     struct pic32_gpio_bank *bank = gpiochip_get_data(chip);
1817     u32 mask = BIT(offset);
1818
1819     writel(mask, bank->reg_base + PIC32_SET(TRIS_REG));
1820
1821     return 0;
1822 }
1823
1824 static int pic32_gpio_get(struct gpio_chip *chip, unsigned offset)
1825 {
1826     struct pic32_gpio_bank *bank = gpiochip_get_data(chip);
1827
1828     return !!(readl(bank->reg_base + PORT_REG) & BIT(offset));
1829 }
1830
1831 static void pic32_gpio_set(struct gpio_chip *chip, unsigned offset,
1832                    int value)
1833 {
1834     struct pic32_gpio_bank *bank = gpiochip_get_data(chip);
1835     u32 mask = BIT(offset);
1836
1837     if (value)
1838         writel(mask, bank->reg_base + PIC32_SET(PORT_REG));
1839     else
1840         writel(mask, bank->reg_base + PIC32_CLR(PORT_REG));
1841 }
1842
1843 static int pic32_gpio_direction_output(struct gpio_chip *chip,
1844                        unsigned offset, int value)
1845 {
1846     struct pic32_gpio_bank *bank = gpiochip_get_data(chip);
1847     u32 mask = BIT(offset);
1848
1849     pic32_gpio_set(chip, offset, value);
1850     writel(mask, bank->reg_base + PIC32_CLR(TRIS_REG));
1851
1852     return 0;
1853 }
1854
1855 static int pic32_gpio_set_direction(struct pinctrl_dev *pctldev,
1856                           struct pinctrl_gpio_range *range,
1857                           unsigned offset, bool input)
1858 {
1859     struct gpio_chip *chip = range->gc;
1860
1861     if (input)
1862         pic32_gpio_direction_input(chip, offset);
1863     else
1864         pic32_gpio_direction_output(chip, offset, 0);
1865
1866     return 0;
1867 }
1868
1869 static const struct pinmux_ops pic32_pinmux_ops = {
1870     .get_functions_count = pic32_pinmux_get_functions_count,
1871     .get_function_name = pic32_pinmux_get_function_name,
1872     .get_function_groups = pic32_pinmux_get_function_groups,
1873     .set_mux = pic32_pinmux_enable,
1874     .gpio_request_enable = pic32_gpio_request_enable,
1875     .gpio_set_direction = pic32_gpio_set_direction,
1876 };
1877
1878 static int pic32_pinconf_get(struct pinctrl_dev *pctldev, unsigned pin,
1879                  unsigned long *config)
1880 {
1881     struct pic32_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
1882     struct pic32_gpio_bank *bank = pctl_to_bank(pctl, pin);
1883     unsigned param = pinconf_to_config_param(*config);
1884     u32 mask = BIT(pin - bank->gpio_chip.base);
1885     u32 arg;
1886
1887     switch (param) {
1888     case PIN_CONFIG_BIAS_PULL_UP:
1889         arg = !!(readl(bank->reg_base + CNPU_REG) & mask);
1890         break;
1891     case PIN_CONFIG_BIAS_PULL_DOWN:
1892         arg = !!(readl(bank->reg_base + CNPD_REG) & mask);
1893         break;
1894     case PIN_CONFIG_MICROCHIP_DIGITAL:
1895         arg = !(readl(bank->reg_base + ANSEL_REG) & mask);
1896         break;
1897     case PIN_CONFIG_MICROCHIP_ANALOG:
1898         arg = !!(readl(bank->reg_base + ANSEL_REG) & mask);
1899         break;
1900     case PIN_CONFIG_DRIVE_OPEN_DRAIN:
1901         arg = !!(readl(bank->reg_base + ODCU_REG) & mask);
1902         break;
1903     case PIN_CONFIG_INPUT_ENABLE:
1904         arg = !!(readl(bank->reg_base + TRIS_REG) & mask);
1905         break;
1906     case PIN_CONFIG_OUTPUT:
1907         arg = !(readl(bank->reg_base + TRIS_REG) & mask);
1908         break;
1909     default:
1910         dev_err(pctl->dev, "Property %u not supported\n", param);
1911         return -ENOTSUPP;
1912     }
1913
1914     *config = pinconf_to_config_packed(param, arg);
1915
1916     return 0;
1917 }
1918
1919 static int pic32_pinconf_set(struct pinctrl_dev *pctldev, unsigned pin,
1920                  unsigned long *configs, unsigned num_configs)
1921 {
1922     struct pic32_pinctrl *pctl = pinctrl_dev_get_drvdata(pctldev);
1923     struct pic32_gpio_bank *bank = pctl_to_bank(pctl, pin);
1924     unsigned param;
1925     u32 arg;
1926     unsigned int i;
1927     u32 offset = pin - bank->gpio_chip.base;
1928     u32 mask = BIT(offset);
1929
1930     dev_dbg(pctl->dev, "setting pin %d bank %d mask 0x%x\n",
1931         pin, bank->gpio_chip.base, mask);
1932
1933     for (i = 0; i < num_configs; i++) {
1934         param = pinconf_to_config_param(configs[i]);
1935         arg = pinconf_to_config_argument(configs[i]);
1936
1937         switch (param) {
1938         case PIN_CONFIG_BIAS_PULL_UP:
1939             dev_dbg(pctl->dev, "   pullup\n");
1940             writel(mask, bank->reg_base +PIC32_SET(CNPU_REG));
1941             break;
1942         case PIN_CONFIG_BIAS_PULL_DOWN:
1943             dev_dbg(pctl->dev, "   pulldown\n");
1944             writel(mask, bank->reg_base + PIC32_SET(CNPD_REG));
1945             break;
1946         case PIN_CONFIG_MICROCHIP_DIGITAL:
1947             dev_dbg(pctl->dev, "   digital\n");
1948             writel(mask, bank->reg_base + PIC32_CLR(ANSEL_REG));
1949             break;
1950         case PIN_CONFIG_MICROCHIP_ANALOG:
1951             dev_dbg(pctl->dev, "   analog\n");
1952             writel(mask, bank->reg_base + PIC32_SET(ANSEL_REG));
1953             break;
1954         case PIN_CONFIG_DRIVE_OPEN_DRAIN:
1955             dev_dbg(pctl->dev, "   opendrain\n");
1956             writel(mask, bank->reg_base + PIC32_SET(ODCU_REG));
1957             break;
1958         case PIN_CONFIG_INPUT_ENABLE:
1959             pic32_gpio_direction_input(&bank->gpio_chip, offset);
1960             break;
1961         case PIN_CONFIG_OUTPUT:
1962             pic32_gpio_direction_output(&bank->gpio_chip,
1963                             offset, arg);
1964             break;
1965         default:
1966             dev_err(pctl->dev, "Property %u not supported\n",
1967                 param);
1968             return -ENOTSUPP;
1969         }
1970     }
1971
1972     return 0;
1973 }
1974
1975 static const struct pinconf_ops pic32_pinconf_ops = {
1976     .pin_config_get = pic32_pinconf_get,
1977     .pin_config_set = pic32_pinconf_set,
1978     .is_generic = true,
1979 };
1980
1981 static struct pinctrl_desc pic32_pinctrl_desc = {
1982     .name = "pic32-pinctrl",
1983     .pctlops = &pic32_pinctrl_ops,
1984     .pmxops = &pic32_pinmux_ops,
1985     .confops = &pic32_pinconf_ops,
1986     .owner = THIS_MODULE,
1987 };
1988
1989 static int pic32_gpio_get_direction(struct gpio_chip *chip, unsigned offset)
1990 {
1991     struct pic32_gpio_bank *bank = gpiochip_get_data(chip);
1992
1993     if (readl(bank->reg_base + TRIS_REG) & BIT(offset))
1994         return GPIO_LINE_DIRECTION_IN;
1995
1996     return GPIO_LINE_DIRECTION_OUT;
1997 }
1998
1999 static void pic32_gpio_irq_ack(struct irq_data *data)
2000 {
2001     struct pic32_gpio_bank *bank = irqd_to_bank(data);
2002
2003     writel(0, bank->reg_base + CNF_REG);
2004 }
2005
2006 static void pic32_gpio_irq_mask(struct irq_data *data)
2007 {
2008     struct pic32_gpio_bank *bank = irqd_to_bank(data);
2009
2010     writel(BIT(PIC32_CNCON_ON), bank->reg_base + PIC32_CLR(CNCON_REG));
2011 }
2012
2013 static void pic32_gpio_irq_unmask(struct irq_data *data)
2014 {
2015     struct pic32_gpio_bank *bank = irqd_to_bank(data);
2016
2017     writel(BIT(PIC32_CNCON_ON), bank->reg_base + PIC32_SET(CNCON_REG));
2018 }
2019
2020 static unsigned int pic32_gpio_irq_startup(struct irq_data *data)
2021 {
2022     struct gpio_chip *chip = irq_data_get_irq_chip_data(data);
2023
2024     pic32_gpio_direction_input(chip, data->hwirq);
2025     pic32_gpio_irq_unmask(data);
2026
2027     return 0;
2028 }
2029
2030 static int pic32_gpio_irq_set_type(struct irq_data *data, unsigned int type)
2031 {
2032     struct pic32_gpio_bank *bank = irqd_to_bank(data);
2033     u32 mask = BIT(data->hwirq);
2034
2035     switch (type & IRQ_TYPE_SENSE_MASK) {
2036     case IRQ_TYPE_EDGE_RISING:
2037         /* enable RISE */
2038         writel(mask, bank->reg_base + PIC32_SET(CNEN_REG));
2039         /* disable FALL */
2040         writel(mask, bank->reg_base + PIC32_CLR(CNNE_REG));
2041         /* enable EDGE */
2042         writel(BIT(PIC32_CNCON_EDGE), bank->reg_base + PIC32_SET(CNCON_REG));
2043         break;
2044     case IRQ_TYPE_EDGE_FALLING:
2045         /* disable RISE */
2046         writel(mask, bank->reg_base + PIC32_CLR(CNEN_REG));
2047         /* enable FALL */
2048         writel(mask, bank->reg_base + PIC32_SET(CNNE_REG));
2049         /* enable EDGE */
2050         writel(BIT(PIC32_CNCON_EDGE), bank->reg_base + PIC32_SET(CNCON_REG));
2051         break;
2052     case IRQ_TYPE_EDGE_BOTH:
2053         /* enable RISE */
2054         writel(mask, bank->reg_base + PIC32_SET(CNEN_REG));
2055         /* enable FALL */
2056         writel(mask, bank->reg_base + PIC32_SET(CNNE_REG));
2057         /* enable EDGE */
2058         writel(BIT(PIC32_CNCON_EDGE), bank->reg_base + PIC32_SET(CNCON_REG));
2059         break;
2060     default:
2061         return -EINVAL;
2062     }
2063
2064     irq_set_handler_locked(data, handle_edge_irq);
2065
2066     return 0;
2067 }
2068
2069 static u32 pic32_gpio_get_pending(struct gpio_chip *gc, unsigned long status)
2070 {
2071     struct pic32_gpio_bank *bank = gpiochip_get_data(gc);
2072     u32 pending = 0;
2073     u32 cnen_rise, cnne_fall;
2074     u32 pin;
2075
2076     cnen_rise = readl(bank->reg_base + CNEN_REG);
2077     cnne_fall = readl(bank->reg_base + CNNE_REG);
2078
2079     for_each_set_bit(pin, &status, BITS_PER_LONG) {
2080         u32 mask = BIT(pin);
2081
2082         if ((mask & cnen_rise) || (mask && cnne_fall))
2083             pending |= mask;
2084     }
2085
2086     return pending;
2087 }
2088
2089 static void pic32_gpio_irq_handler(struct irq_desc *desc)
2090 {
2091     struct gpio_chip *gc = irq_desc_get_handler_data(desc);
2092     struct pic32_gpio_bank *bank = gpiochip_get_data(gc);
2093     struct irq_chip *chip = irq_desc_get_chip(desc);
2094     unsigned long pending;
2095     unsigned int pin;
2096     u32 stat;
2097
2098     chained_irq_enter(chip, desc);
2099
2100     stat = readl(bank->reg_base + CNF_REG);
2101     pending = pic32_gpio_get_pending(gc, stat);
2102
2103     for_each_set_bit(pin, &pending, BITS_PER_LONG)
2104         generic_handle_domain_irq(gc->irq.domain, pin);
2105
2106     chained_irq_exit(chip, desc);
2107 }
2108
2109 #define GPIO_BANK(_bank, _npins)                    \
2110     {                               \
2111         .gpio_chip = {                      \
2112             .label = "GPIO" #_bank,             \
2113             .request = gpiochip_generic_request,        \
2114             .free = gpiochip_generic_free,          \
2115             .get_direction = pic32_gpio_get_direction,  \
2116             .direction_input = pic32_gpio_direction_input,  \
2117             .direction_output = pic32_gpio_direction_output, \
2118             .get = pic32_gpio_get,              \
2119             .set = pic32_gpio_set,              \
2120             .ngpio = _npins,                \
2121             .base = GPIO_BANK_START(_bank),         \
2122             .owner = THIS_MODULE,               \
2123             .can_sleep = 0,                 \
2124         },                          \
2125         .irq_chip = {                       \
2126             .name = "GPIO" #_bank,              \
2127             .irq_startup = pic32_gpio_irq_startup,  \
2128             .irq_ack = pic32_gpio_irq_ack,      \
2129             .irq_mask = pic32_gpio_irq_mask,        \
2130             .irq_unmask = pic32_gpio_irq_unmask,        \
2131             .irq_set_type = pic32_gpio_irq_set_type,    \
2132         },                          \
2133     }
2134
2135 static struct pic32_gpio_bank pic32_gpio_banks[] = {
2136     GPIO_BANK(0, PINS_PER_BANK),
2137     GPIO_BANK(1, PINS_PER_BANK),
2138     GPIO_BANK(2, PINS_PER_BANK),
2139     GPIO_BANK(3, PINS_PER_BANK),
2140     GPIO_BANK(4, PINS_PER_BANK),
2141     GPIO_BANK(5, PINS_PER_BANK),
2142     GPIO_BANK(6, PINS_PER_BANK),
2143     GPIO_BANK(7, PINS_PER_BANK),
2144     GPIO_BANK(8, PINS_PER_BANK),
2145     GPIO_BANK(9, PINS_PER_BANK),
2146 };
2147
2148 static int pic32_pinctrl_probe(struct platform_device *pdev)
2149 {
2150     struct pic32_pinctrl *pctl;
2151     struct resource *res;
2152     int ret;
2153
2154     pctl = devm_kzalloc(&pdev->dev, sizeof(*pctl), GFP_KERNEL);
2155     if (!pctl)
2156         return -ENOMEM;
2157     pctl->dev = &pdev->dev;
2158     dev_set_drvdata(&pdev->dev, pctl);
2159
2160     res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2161     pctl->reg_base = devm_ioremap_resource(&pdev->dev, res);
2162     if (IS_ERR(pctl->reg_base))
2163         return PTR_ERR(pctl->reg_base);
2164
2165     pctl->clk = devm_clk_get(&pdev->dev, NULL);
2166     if (IS_ERR(pctl->clk)) {
2167         ret = PTR_ERR(pctl->clk);
2168         dev_err(&pdev->dev, "clk get failed\n");
2169         return ret;
2170     }
2171
2172     ret = clk_prepare_enable(pctl->clk);
2173     if (ret) {
2174         dev_err(&pdev->dev, "clk enable failed\n");
2175         return ret;
2176     }
2177
2178     pctl->pins = pic32_pins;
2179     pctl->npins = ARRAY_SIZE(pic32_pins);
2180     pctl->functions = pic32_functions;
2181     pctl->nfunctions = ARRAY_SIZE(pic32_functions);
2182     pctl->groups = pic32_groups;
2183     pctl->ngroups = ARRAY_SIZE(pic32_groups);
2184     pctl->gpio_banks = pic32_gpio_banks;
2185     pctl->nbanks = ARRAY_SIZE(pic32_gpio_banks);
2186
2187     pic32_pinctrl_desc.pins = pctl->pins;
2188     pic32_pinctrl_desc.npins = pctl->npins;
2189     pic32_pinctrl_desc.custom_params = pic32_mpp_bindings;
2190     pic32_pinctrl_desc.num_custom_params = ARRAY_SIZE(pic32_mpp_bindings);
2191
2192     pctl->pctldev = devm_pinctrl_register(&pdev->dev, &pic32_pinctrl_desc,
2193                           pctl);
2194     if (IS_ERR(pctl->pctldev)) {
2195         dev_err(&pdev->dev, "Failed to register pinctrl device\n");
2196         return PTR_ERR(pctl->pctldev);
2197     }
2198
2199     return 0;
2200 }
2201
2202 static int pic32_gpio_probe(struct platform_device *pdev)
2203 {
2204     struct device_node *np = pdev->dev.of_node;
2205     struct pic32_gpio_bank *bank;
2206     u32 id;
2207     int irq, ret;
2208     struct gpio_irq_chip *girq;
2209
2210     if (of_property_read_u32(np, "microchip,gpio-bank", &id)) {
2211         dev_err(&pdev->dev, "microchip,gpio-bank property not found\n");
2212         return -EINVAL;
2213     }
2214
2215     if (id >= ARRAY_SIZE(pic32_gpio_banks)) {
2216         dev_err(&pdev->dev, "invalid microchip,gpio-bank property\n");
2217         return -EINVAL;
2218     }
2219
2220     bank = &pic32_gpio_banks[id];
2221
2222     bank->reg_base = devm_platform_ioremap_resource(pdev, 0);
2223     if (IS_ERR(bank->reg_base))
2224         return PTR_ERR(bank->reg_base);
2225
2226     irq = platform_get_irq(pdev, 0);
2227     if (irq < 0)
2228         return irq;
2229
2230     bank->clk = devm_clk_get(&pdev->dev, NULL);
2231     if (IS_ERR(bank->clk)) {
2232         ret = PTR_ERR(bank->clk);
2233         dev_err(&pdev->dev, "clk get failed\n");
2234         return ret;
2235     }
2236
2237     ret = clk_prepare_enable(bank->clk);
2238     if (ret) {
2239         dev_err(&pdev->dev, "clk enable failed\n");
2240         return ret;
2241     }
2242
2243     bank->gpio_chip.parent = &pdev->dev;
2244
2245     girq = &bank->gpio_chip.irq;
2246     girq->chip = &bank->irq_chip;
2247     girq->parent_handler = pic32_gpio_irq_handler;
2248     girq->num_parents = 1;
2249     girq->parents = devm_kcalloc(&pdev->dev, 1, sizeof(*girq->parents),
2250                      GFP_KERNEL);
2251     if (!girq->parents)
2252         return -ENOMEM;
2253     girq->default_type = IRQ_TYPE_NONE;
2254     girq->handler = handle_level_irq;
2255     girq->parents[0] = irq;
2256     ret = gpiochip_add_data(&bank->gpio_chip, bank);
2257     if (ret < 0) {
2258         dev_err(&pdev->dev, "Failed to add GPIO chip %u: %d\n",
2259             id, ret);
2260         return ret;
2261     }
2262     return 0;
2263 }
2264
2265 static const struct of_device_id pic32_pinctrl_of_match[] = {
2266     { .compatible = "microchip,pic32mzda-pinctrl", },
2267     { },
2268 };
2269
2270 static struct platform_driver pic32_pinctrl_driver = {
2271     .driver = {
2272         .name = "pic32-pinctrl",
2273         .of_match_table = pic32_pinctrl_of_match,
2274         .suppress_bind_attrs = true,
2275     },
2276     .probe = pic32_pinctrl_probe,
2277 };
2278
2279 static const struct of_device_id pic32_gpio_of_match[] = {
2280     { .compatible = "microchip,pic32mzda-gpio", },
2281     { },
2282 };
2283
2284 static struct platform_driver pic32_gpio_driver = {
2285     .driver = {
2286         .name = "pic32-gpio",
2287         .of_match_table = pic32_gpio_of_match,
2288         .suppress_bind_attrs = true,
2289     },
2290     .probe = pic32_gpio_probe,
2291 };
2292
2293 static int __init pic32_gpio_register(void)
2294 {
2295     return platform_driver_register(&pic32_gpio_driver);
2296 }
2297 arch_initcall(pic32_gpio_register);
2298
2299 static int __init pic32_pinctrl_register(void)
2300 {
2301     return platform_driver_register(&pic32_pinctrl_driver);
2302 }
2303 arch_initcall(pic32_pinctrl_register);