// SPDX-License-Identifier: GPL-2.0

#include <linux/bitops.h>
#include <linux/bits.h>
#include <linux/mfd/syscon.h>
#include <linux/of.h>
#include <linux/pinctrl/pinconf-generic.h>
#include <linux/pinctrl/pinconf.h>
#include <linux/pinctrl/pinctrl.h>
#include <linux/pinctrl/pinmux.h>
#include <linux/platform_device.h>
#include <linux/regmap.h>

#include "pinctrl-aspeed.h"
#include "pinmux-aspeed.h"
#include "../pinctrl-utils.h"

#define SCU200 0x200 /* System Reset Control #1  */

#define SCU010 0x010 /* Hardware Strap Register */
#define SCU400 0x400 /* Multi-function Pin Control #1  */
#define SCU404 0x404 /* Multi-function Pin Control #2  */
#define SCU408 0x408 /* Multi-function Pin Control #3  */
#define SCU40C 0x40C /* Multi-function Pin Control #3  */
#define SCU410 0x410 /* USB Multi-function Control Register  */
#define SCU414 0x414 /* VGA Function Control Register  */

#define SCU480 0x480 /* GPIO18A0 IO Control Register */
#define SCU484 0x484 /* GPIO18A1 IO Control Register */
#define SCU488 0x488 /* GPIO18A2 IO Control Register */
#define SCU48C 0x48c /* GPIO18A3 IO Control Register */
#define SCU490 0x490 /* GPIO18A4 IO Control Register */
#define SCU494 0x494 /* GPIO18A5 IO Control Register */
#define SCU498 0x498 /* GPIO18A6 IO Control Register */
#define SCU49C 0x49c /* GPIO18A7 IO Control Register */
#define SCU4A0 0x4A0 /* GPIO18B0 IO Control Register */
#define SCU4A4 0x4A4 /* GPIO18B1 IO Control Register */
#define SCU4A8 0x4A8 /* GPIO18B2 IO Control Register */
#define SCU4AC 0x4AC /* GPIO18B3 IO Control Register */

enum {
        AC14,
        AE15,
        AD14,
        AE14,
        AF14,
        AB13,
        AB14,
        AF15,
        AF13,
        AC13,
        AD13,
        AE13,
        JTAG_PORT,
        PCIERC0_PERST,
        PCIERC1_PERST,
        PORTA_MODE,
        PORTA_U2,
        PORTB_MODE,
        PORTB_U2,
        PORTA_U2_PHY,
        PORTB_U2_PHY,
        PORTA_U3,
        PORTB_U3,
        PORTA_U3_PHY,
        PORTB_U3_PHY,
};

SIG_EXPR_LIST_DECL_SEMG(AC14, EMMCCLK, EMMCG1, EMMC, SIG_DESC_SET(SCU400, 0));
SIG_EXPR_LIST_DECL_SEMG(AC14, VB1CS, VB1, VB, SIG_DESC_SET(SCU404, 0));
PIN_DECL_2(AC14, GPIO18A0, EMMCCLK, VB1CS);

SIG_EXPR_LIST_DECL_SEMG(AE15, EMMCCMD, EMMCG1, EMMC, SIG_DESC_SET(SCU400, 1));
SIG_EXPR_LIST_DECL_SEMG(AE15, VB1CK, VB1, VB, SIG_DESC_SET(SCU404, 1));
PIN_DECL_2(AE15, GPIO18A1, EMMCCMD, VB1CK);

SIG_EXPR_LIST_DECL_SEMG(AD14, EMMCDAT0, EMMCG1, EMMC, SIG_DESC_SET(SCU400, 2));
SIG_EXPR_LIST_DECL_SEMG(AD14, VB1MOSI, VB1, VB, SIG_DESC_SET(SCU404, 2));
PIN_DECL_2(AD14, GPIO18A2, EMMCDAT0, VB1MOSI);

SIG_EXPR_LIST_DECL_SEMG(AE14, EMMCDAT1, EMMCG4, EMMC, SIG_DESC_SET(SCU400, 3));
SIG_EXPR_LIST_DECL_SEMG(AE14, VB1MISO, VB1, VB, SIG_DESC_SET(SCU404, 3));
PIN_DECL_2(AE14, GPIO18A3, EMMCDAT1, VB1MISO);

SIG_EXPR_LIST_DECL_SEMG(AF14, EMMCDAT2, EMMCG4, EMMC, SIG_DESC_SET(SCU400, 4));
PIN_DECL_1(AF14, GPIO18A4, EMMCDAT2);

SIG_EXPR_LIST_DECL_SEMG(AB13, EMMCDAT3, EMMCG4, EMMC, SIG_DESC_SET(SCU400, 5));
PIN_DECL_1(AB13, GPIO18A5, EMMCDAT3);

SIG_EXPR_LIST_DECL_SEMG(AB14, EMMCCDN, EMMCG1, EMMC, SIG_DESC_SET(SCU400, 6));
SIG_EXPR_LIST_DECL_SEMG(AB14, VB0CS, VB0, VB, SIG_DESC_SET(SCU010, 17));
PIN_DECL_2(AB14, GPIO18A6, EMMCCDN, VB0CS);

SIG_EXPR_LIST_DECL_SEMG(AF15, EMMCWPN, EMMCG1, EMMC, SIG_DESC_SET(SCU400, 7));
SIG_EXPR_LIST_DECL_SEMG(AF15, VB0CK, VB0, VB, SIG_DESC_SET(SCU010, 17));
PIN_DECL_2(AF15, GPIO18A7, EMMCWPN, VB0CK);

SIG_EXPR_LIST_DECL_SESG(AF13, TSPRSTN, TSPRSTN, SIG_DESC_SET(SCU010, 9));
SIG_EXPR_LIST_DECL_SEMG(AF13, EMMCDAT4, EMMCG8, EMMC, SIG_DESC_SET(SCU400, 8));
SIG_EXPR_LIST_DECL_SEMG(AF13, VB0MOSI, VB0, VB, SIG_DESC_SET(SCU010, 17));
PIN_DECL_3(AF13, GPIO18B0, TSPRSTN, EMMCDAT4, VB0MOSI);

SIG_EXPR_LIST_DECL_SESG(AC13, UFSCLKI, UFSCLKI, SIG_DESC_SET(SCU010, 19));
SIG_EXPR_LIST_DECL_SEMG(AC13, EMMCDAT5, EMMCG8, EMMC, SIG_DESC_SET(SCU400, 9));
SIG_EXPR_LIST_DECL_SEMG(AC13, VB0MISO, VB0, VB, SIG_DESC_SET(SCU010, 17));
PIN_DECL_3(AC13, GPIO18B1, UFSCLKI, EMMCDAT5, VB0MISO);

SIG_EXPR_LIST_DECL_SEMG(AD13, EMMCDAT6, EMMCG8, EMMC, SIG_DESC_SET(SCU400, 10));
SIG_EXPR_LIST_DECL_SESG(AD13, DDCCLK, VGADDC, SIG_DESC_SET(SCU404, 10));
PIN_DECL_2(AD13, GPIO18B2, EMMCDAT6, DDCCLK);

SIG_EXPR_LIST_DECL_SEMG(AE13, EMMCDAT7, EMMCG8, EMMC, SIG_DESC_SET(SCU400, 11));
SIG_EXPR_LIST_DECL_SESG(AE13, DDCDAT, VGADDC, SIG_DESC_SET(SCU404, 11));
PIN_DECL_2(AE13, GPIO18B3, EMMCDAT7, DDCDAT);

GROUP_DECL(EMMCG1, AC14, AE15, AD14);
GROUP_DECL(EMMCG4, AC14, AE15, AD14, AE14, AF14, AB13);
GROUP_DECL(EMMCG8, AC14, AE15, AD14, AE14, AF14, AB13, AF13, AC13, AD13, AE13);
GROUP_DECL(EMMCWPN, AF15);
GROUP_DECL(EMMCCDN, AB14);
FUNC_DECL_(EMMC, "EMMCG1", "EMMCG4", "EMMCG8", "EMMCWPN", "EMMCCDN");

GROUP_DECL(VB1, AC14, AE15, AD14, AE14);
GROUP_DECL(VB0, AF15, AB14, AF13, AC13);
FUNC_DECL_2(VB, VB1, VB0);

FUNC_GROUP_DECL(TSPRSTN, AF13);

FUNC_GROUP_DECL(UFSCLKI, AC13);

FUNC_GROUP_DECL(VGADDC, AD13, AE13);

/* JTAG Port Selection */
#define JTAG_PORT_PSP_DESC   { ASPEED_IP_SCU, SCU408, GENMASK(12, 5), 0x0, 0 }
#define JTAG_PORT_SSP_DESC   { ASPEED_IP_SCU, SCU408, GENMASK(12, 5), 0x41, 0 }
#define JTAG_PORT_TSP_DESC   { ASPEED_IP_SCU, SCU408, GENMASK(12, 5), 0x42, 0 }
#define JTAG_PORT_DDR_DESC   { ASPEED_IP_SCU, SCU408, GENMASK(12, 5), 0x43, 0 }
#define JTAG_PORT_USB3A_DESC { ASPEED_IP_SCU, SCU408, GENMASK(12, 5), 0x44, 0 }
#define JTAG_PORT_USB3B_DESC { ASPEED_IP_SCU, SCU408, GENMASK(12, 5), 0x45, 0 }
#define JTAG_PORT_PCIEA_DESC { ASPEED_IP_SCU, SCU408, GENMASK(12, 5), 0x46, 0 }
#define JTAG_PORT_PCIEB_DESC { ASPEED_IP_SCU, SCU408, GENMASK(12, 5), 0x47, 0 }
#define JTAG_PORT_JTAGM0_DESC { ASPEED_IP_SCU, SCU408, GENMASK(12, 5), 0x8, 0 }

SIG_EXPR_LIST_DECL_SEMG(JTAG_PORT, JTAGPSP, JTAG0, JTAGPSP, JTAG_PORT_PSP_DESC);
SIG_EXPR_LIST_DECL_SEMG(JTAG_PORT, JTAGSSP, JTAG0, JTAGSSP, JTAG_PORT_SSP_DESC);
SIG_EXPR_LIST_DECL_SEMG(JTAG_PORT, JTAGTSP, JTAG0, JTAGTSP, JTAG_PORT_TSP_DESC);
SIG_EXPR_LIST_DECL_SEMG(JTAG_PORT, JTAGDDR, JTAG0, JTAGDDR, JTAG_PORT_DDR_DESC);
SIG_EXPR_LIST_DECL_SEMG(JTAG_PORT, JTAGUSB3A, JTAG0, JTAGUSB3A, JTAG_PORT_USB3A_DESC);
SIG_EXPR_LIST_DECL_SEMG(JTAG_PORT, JTAGUSB3B, JTAG0, JTAGUSB3B, JTAG_PORT_USB3B_DESC);
SIG_EXPR_LIST_DECL_SEMG(JTAG_PORT, JTAGPCIEA, JTAG0, JTAGPCIEA, JTAG_PORT_PCIEA_DESC);
SIG_EXPR_LIST_DECL_SEMG(JTAG_PORT, JTAGPCIEB, JTAG0, JTAGPCIEB, JTAG_PORT_PCIEB_DESC);
SIG_EXPR_LIST_DECL_SEMG(JTAG_PORT, JTAGM0, JTAG0, JTAGM0, JTAG_PORT_JTAGM0_DESC);
PIN_DECL_(JTAG_PORT, SIG_EXPR_LIST_PTR(JTAG_PORT, JTAGPSP), SIG_EXPR_LIST_PTR(JTAG_PORT, JTAGSSP),
          SIG_EXPR_LIST_PTR(JTAG_PORT, JTAGTSP), SIG_EXPR_LIST_PTR(JTAG_PORT, JTAGDDR),
          SIG_EXPR_LIST_PTR(JTAG_PORT, JTAGUSB3A), SIG_EXPR_LIST_PTR(JTAG_PORT, JTAGUSB3B),
          SIG_EXPR_LIST_PTR(JTAG_PORT, JTAGPCIEA), SIG_EXPR_LIST_PTR(JTAG_PORT, JTAGPCIEB),
          SIG_EXPR_LIST_PTR(JTAG_PORT, JTAGM0));

GROUP_DECL(JTAG0, JTAG_PORT);

FUNC_DECL_1(JTAGPSP, JTAG0);
FUNC_DECL_1(JTAGSSP, JTAG0);
FUNC_DECL_1(JTAGTSP, JTAG0);
FUNC_DECL_1(JTAGDDR, JTAG0);
FUNC_DECL_1(JTAGUSB3A, JTAG0);
FUNC_DECL_1(JTAGUSB3B, JTAG0);
FUNC_DECL_1(JTAGPCIEA, JTAG0);
FUNC_DECL_1(JTAGPCIEB, JTAG0);
FUNC_DECL_1(JTAGM0, JTAG0);

/* PCIe Reset Control */
SIG_EXPR_LIST_DECL_SESG(PCIERC0_PERST, PCIERC0PERST, PCIERC0PERST, SIG_DESC_SET(SCU200, 21));
PIN_DECL_(PCIERC0_PERST, SIG_EXPR_LIST_PTR(PCIERC0_PERST, PCIERC0PERST));
FUNC_GROUP_DECL(PCIERC0PERST, PCIERC0_PERST);

SIG_EXPR_LIST_DECL_SESG(PCIERC1_PERST, PCIERC1PERST, PCIERC1PERST, SIG_DESC_SET(SCU200, 19));
PIN_DECL_(PCIERC1_PERST, SIG_EXPR_LIST_PTR(PCIERC1_PERST, PCIERC1PERST));
FUNC_GROUP_DECL(PCIERC1PERST, PCIERC1_PERST);

#define PORTA_MODE_HPD0_DESC { ASPEED_IP_SCU, SCU410, GENMASK(25, 24), 0, 0 }
#define PORTA_MODE_D0_DESC   { ASPEED_IP_SCU, SCU410, GENMASK(25, 24), 1, 0 }
#define PORTA_MODE_H_DESC    { ASPEED_IP_SCU, SCU410, GENMASK(25, 24), 2, 0 }
#define PORTA_MODE_HP_DESC    { ASPEED_IP_SCU, SCU410, GENMASK(25, 24), 3, 0 }

SIG_EXPR_LIST_DECL_SEMG(PORTA_MODE, USB2AHPD0, USB2AH, USB2AHPD0, PORTA_MODE_HPD0_DESC);
SIG_EXPR_LIST_DECL_SEMG(PORTA_MODE, USB2AH, USB2AHAP, USB2AH, PORTA_MODE_H_DESC);
SIG_EXPR_LIST_DECL_SEMG(PORTA_MODE, USB2AHP, USB2AHAP, USB2AHP, PORTA_MODE_HP_DESC);
SIG_EXPR_LIST_DECL_SEMG(PORTA_MODE, USB2AD0, USB2AHAP, USB2AD0, PORTA_MODE_D0_DESC);
PIN_DECL_(PORTA_MODE, SIG_EXPR_LIST_PTR(PORTA_MODE, USB2AHPD0),
          SIG_EXPR_LIST_PTR(PORTA_MODE, USB2AH), SIG_EXPR_LIST_PTR(PORTA_MODE, USB2AHP),
          SIG_EXPR_LIST_PTR(PORTA_MODE, USB2AD0));

#define PORTA_U2_XHD_DESC   { ASPEED_IP_SCU, SCU410, GENMASK(3, 2), 0, 0 }
#define PORTA_U2_D1_DESC    { ASPEED_IP_SCU, SCU410, GENMASK(3, 2), 1, 0 }
#define PORTA_U2_XH_DESC    { ASPEED_IP_SCU, SCU410, GENMASK(3, 2), 2, 0 }
#define PORTA_U2_XH2E_DESC   { ASPEED_IP_SCU, SCU410, GENMASK(3, 2), 3, 0 }

SIG_EXPR_LIST_DECL_SEMG(PORTA_U2, USB2AXHD1, USB2A, USB2AXHD1, PORTA_U2_XHD_DESC,
                        SIG_DESC_SET(SCU410, 9));
SIG_EXPR_LIST_DECL_SEMG(PORTA_U2, USB2AXHPD1, USB2A, USB2AXHPD1, PORTA_U2_XHD_DESC,
                        SIG_DESC_CLEAR(SCU410, 9));
SIG_EXPR_LIST_DECL_SEMG(PORTA_U2, USB2AXH, USB2AAP, USB2AXH, PORTA_U2_XH_DESC,
                        SIG_DESC_SET(SCU410, 9));
SIG_EXPR_LIST_DECL_SEMG(PORTA_U2, USB2AXHP, USB2AAP, USB2AXHP, PORTA_U2_XH_DESC,
                        SIG_DESC_CLEAR(SCU410, 9));
SIG_EXPR_LIST_DECL_SEMG(PORTA_U2, USB2AXH2B, USB2ABP, USB2AXH2B, PORTA_U2_XH2E_DESC,
                        SIG_DESC_SET(SCU410, 9));
SIG_EXPR_LIST_DECL_SEMG(PORTA_U2, USB2AXHP2B, USB2ABP, USB2AXHP2B, PORTA_U2_XH2E_DESC,
                        SIG_DESC_CLEAR(SCU410, 9));
SIG_EXPR_LIST_DECL_SEMG(PORTA_U2, USB2AD1, USB2ADAP, USB2AD1, PORTA_U2_D1_DESC);
PIN_DECL_(PORTA_U2, SIG_EXPR_LIST_PTR(PORTA_U2, USB2AXHD1), SIG_EXPR_LIST_PTR(PORTA_U2, USB2AXHPD1),
          SIG_EXPR_LIST_PTR(PORTA_U2, USB2AXH), SIG_EXPR_LIST_PTR(PORTA_U2, USB2AXHP),
          SIG_EXPR_LIST_PTR(PORTA_U2, USB2AXH2B), SIG_EXPR_LIST_PTR(PORTA_U2, USB2AXHP2B),
          SIG_EXPR_LIST_PTR(PORTA_U2, USB2AD1));

#define PORTB_MODE_HPD0_DESC { ASPEED_IP_SCU, SCU410, GENMASK(29, 28), 0, 0 }
#define PORTB_MODE_D0_DESC   { ASPEED_IP_SCU, SCU410, GENMASK(29, 28), 1, 0 }
#define PORTB_MODE_H_DESC    { ASPEED_IP_SCU, SCU410, GENMASK(29, 28), 2, 0 }
#define PORTB_MODE_HP_DESC    { ASPEED_IP_SCU, SCU410, GENMASK(29, 28), 3, 0 }

SIG_EXPR_LIST_DECL_SEMG(PORTB_MODE, USB2BHPD0, USB2BH, USB2BHPD0, PORTB_MODE_HPD0_DESC);
SIG_EXPR_LIST_DECL_SEMG(PORTB_MODE, USB2BH, USB2BHBP, USB2BH, PORTB_MODE_H_DESC);
SIG_EXPR_LIST_DECL_SEMG(PORTB_MODE, USB2BHP, USB2BHBP, USB2BHP, PORTB_MODE_HP_DESC);
SIG_EXPR_LIST_DECL_SEMG(PORTB_MODE, USB2BD0, USB2BHBP, USB2BD0, PORTB_MODE_D0_DESC);
PIN_DECL_(PORTB_MODE, SIG_EXPR_LIST_PTR(PORTB_MODE, USB2BHPD0),
          SIG_EXPR_LIST_PTR(PORTB_MODE, USB2BH), SIG_EXPR_LIST_PTR(PORTB_MODE, USB2BHP),
          SIG_EXPR_LIST_PTR(PORTB_MODE, USB2BD0));

#define PORTB_U2_XHD_DESC   { ASPEED_IP_SCU, SCU410, GENMASK(7, 6), 0, 0 }
#define PORTB_U2_D1_DESC    { ASPEED_IP_SCU, SCU410, GENMASK(7, 6), 1, 0 }
#define PORTB_U2_XH_DESC    { ASPEED_IP_SCU, SCU410, GENMASK(7, 6), 2, 0 }
#define PORTB_U2_XH2E_DESC   { ASPEED_IP_SCU, SCU410, GENMASK(7, 6), 3, 0 }

SIG_EXPR_LIST_DECL_SEMG(PORTB_U2, USB2BXHD1, USB2B, USB2BXHD1, PORTB_U2_XHD_DESC,
                        SIG_DESC_SET(SCU410, 10));
SIG_EXPR_LIST_DECL_SEMG(PORTB_U2, USB2BXHPD1, USB2B, USB2BXHPD1, PORTB_U2_XHD_DESC,
                        SIG_DESC_CLEAR(SCU410, 10));
SIG_EXPR_LIST_DECL_SEMG(PORTB_U2, USB2BXH, USB2BBP, USB2BXH, PORTB_U2_XH_DESC,
                        SIG_DESC_SET(SCU410, 10));
SIG_EXPR_LIST_DECL_SEMG(PORTB_U2, USB2BXHP, USB2BBP, USB2BXHP, PORTB_U2_XH_DESC,
                        SIG_DESC_CLEAR(SCU410, 10));
SIG_EXPR_LIST_DECL_SEMG(PORTB_U2, USB2BXH2A, USB2BAP, USB2BXH2A, PORTB_U2_XH2E_DESC,
                        SIG_DESC_SET(SCU410, 10));
SIG_EXPR_LIST_DECL_SEMG(PORTB_U2, USB2BXHP2A, USB2BAP, USB2BXHP2A, PORTB_U2_XH2E_DESC,
                        SIG_DESC_CLEAR(SCU410, 10));
SIG_EXPR_LIST_DECL_SEMG(PORTB_U2, USB2BD1, USB2BDBP, USB2BD1, PORTB_U2_D1_DESC);
PIN_DECL_(PORTB_U2, SIG_EXPR_LIST_PTR(PORTB_U2, USB2BXHD1), SIG_EXPR_LIST_PTR(PORTB_U2, USB2BXHPD1),
          SIG_EXPR_LIST_PTR(PORTB_U2, USB2BXH), SIG_EXPR_LIST_PTR(PORTB_U2, USB2BXHP),
          SIG_EXPR_LIST_PTR(PORTB_U2, USB2BXH2A), SIG_EXPR_LIST_PTR(PORTB_U2, USB2BXHP2A),
          SIG_EXPR_LIST_PTR(PORTB_U2, USB2BD1));
/*
 * USB2 virtual PHY pins.
 *
 * PORTA_U2_PHY and PORTB_U2_PHY are logical endpoints, not package pins.
 * They alias existing USB2 expressions so pin groups can model direct and
 * cross-coupled routing for host and mode paths.
 *
 * - USB2AAP/USB2ADAP/USB2AHAP: use PORTA_U2_PHY
 * - USB2ABP                  : use PORTB_U2_PHY
 * - USB2BBP/USB2BDBP/USB2BHBP: use PORTB_U2_PHY
 * - USB2BAP                  : use PORTA_U2_PHY
 *
 * They do not have any registers to configure this behaviour; the goal is
 * simply for the driver to prevent conflicting selections. For example,
 * selecting group USB2ABP and USB2BBP at the same time should not be
 * allowed.
 */
SIG_EXPR_LIST_ALIAS(PORTA_U2_PHY, USB2AXH, USB2AAP);
SIG_EXPR_LIST_ALIAS(PORTA_U2_PHY, USB2AXHP, USB2AAP);
SIG_EXPR_LIST_ALIAS(PORTA_U2_PHY, USB2BXH2A, USB2BAP);
SIG_EXPR_LIST_ALIAS(PORTA_U2_PHY, USB2BXHP2A, USB2BAP);
SIG_EXPR_LIST_ALIAS(PORTA_U2_PHY, USB2AD1, USB2ADAP);
SIG_EXPR_LIST_ALIAS(PORTA_U2_PHY, USB2AH, USB2AHAP);
SIG_EXPR_LIST_ALIAS(PORTA_U2_PHY, USB2AHP, USB2AHAP);
SIG_EXPR_LIST_ALIAS(PORTA_U2_PHY, USB2AD0, USB2AHAP);
PIN_DECL_(PORTA_U2_PHY, SIG_EXPR_LIST_PTR(PORTA_U2_PHY, USB2AXH),
          SIG_EXPR_LIST_PTR(PORTA_U2_PHY, USB2AXHP), SIG_EXPR_LIST_PTR(PORTA_U2_PHY, USB2BXH2A),
          SIG_EXPR_LIST_PTR(PORTA_U2_PHY, USB2BXHP2A), SIG_EXPR_LIST_PTR(PORTA_U2_PHY, USB2AD1),
          SIG_EXPR_LIST_PTR(PORTA_U2_PHY, USB2AH), SIG_EXPR_LIST_PTR(PORTA_U2_PHY, USB2AHP),
          SIG_EXPR_LIST_PTR(PORTA_U2_PHY, USB2AD0));

SIG_EXPR_LIST_ALIAS(PORTB_U2_PHY, USB2AXH2B, USB2ABP);
SIG_EXPR_LIST_ALIAS(PORTB_U2_PHY, USB2AXHP2B, USB2ABP);
SIG_EXPR_LIST_ALIAS(PORTB_U2_PHY, USB2BXH, USB2BBP);
SIG_EXPR_LIST_ALIAS(PORTB_U2_PHY, USB2BXHP, USB2BBP);
SIG_EXPR_LIST_ALIAS(PORTB_U2_PHY, USB2BD1, USB2BDBP);
SIG_EXPR_LIST_ALIAS(PORTB_U2_PHY, USB2BH, USB2BHBP);
SIG_EXPR_LIST_ALIAS(PORTB_U2_PHY, USB2BHP, USB2BHBP);
SIG_EXPR_LIST_ALIAS(PORTB_U2_PHY, USB2BD0, USB2BHBP);
PIN_DECL_(PORTB_U2_PHY, SIG_EXPR_LIST_PTR(PORTB_U2_PHY, USB2AXH2B),
          SIG_EXPR_LIST_PTR(PORTB_U2_PHY, USB2AXHP2B), SIG_EXPR_LIST_PTR(PORTB_U2_PHY, USB2BXH),
          SIG_EXPR_LIST_PTR(PORTB_U2_PHY, USB2BXHP), SIG_EXPR_LIST_PTR(PORTB_U2_PHY, USB2BD1),
          SIG_EXPR_LIST_PTR(PORTB_U2_PHY, USB2BH), SIG_EXPR_LIST_PTR(PORTB_U2_PHY, USB2BHP),
          SIG_EXPR_LIST_PTR(PORTB_U2_PHY, USB2BD0));

GROUP_DECL(USB2A, PORTA_U2);
GROUP_DECL(USB2AAP, PORTA_U2, PORTA_U2_PHY);
GROUP_DECL(USB2ABP, PORTA_U2, PORTB_U2_PHY);
GROUP_DECL(USB2ADAP, PORTA_U2, PORTA_U2_PHY);
GROUP_DECL(USB2AH, PORTA_MODE);
GROUP_DECL(USB2AHAP, PORTA_MODE, PORTA_U2_PHY);

FUNC_DECL_1(USB2AXHD1, USB2A);
FUNC_DECL_1(USB2AXHPD1, USB2A);
FUNC_DECL_1(USB2AXH, USB2AAP);
FUNC_DECL_1(USB2AXHP, USB2AAP);
FUNC_DECL_1(USB2AXH2B, USB2ABP);
FUNC_DECL_1(USB2AXHP2B, USB2ABP);
FUNC_DECL_1(USB2AD1, USB2ADAP);
FUNC_DECL_1(USB2AHPD0, USB2AH);
FUNC_DECL_1(USB2AH, USB2AHAP);
FUNC_DECL_1(USB2AHP, USB2AHAP);
FUNC_DECL_1(USB2AD0, USB2AHAP);

GROUP_DECL(USB2B, PORTB_U2);
GROUP_DECL(USB2BBP, PORTB_U2, PORTB_U2_PHY);
GROUP_DECL(USB2BAP, PORTB_U2, PORTA_U2_PHY);
GROUP_DECL(USB2BDBP, PORTB_U2, PORTB_U2_PHY);
GROUP_DECL(USB2BH, PORTB_MODE);
GROUP_DECL(USB2BHBP, PORTB_MODE, PORTB_U2_PHY);

FUNC_DECL_1(USB2BXHD1, USB2B);
FUNC_DECL_1(USB2BXHPD1, USB2B);
FUNC_DECL_1(USB2BXH, USB2BBP);
FUNC_DECL_1(USB2BXHP, USB2BBP);
FUNC_DECL_1(USB2BXH2A, USB2BAP);
FUNC_DECL_1(USB2BXHP2A, USB2BAP);
FUNC_DECL_1(USB2BD1, USB2BDBP);
FUNC_DECL_1(USB2BHPD0, USB2BH);
FUNC_DECL_1(USB2BH, USB2BHBP);
FUNC_DECL_1(USB2BHP, USB2BHBP);
FUNC_DECL_1(USB2BD0, USB2BHBP);

#define PORTA_U3_XHD_DESC   { ASPEED_IP_SCU, SCU410, GENMASK(1, 0), 0, 0 }
#define PORTA_U3_XH_DESC    { ASPEED_IP_SCU, SCU410, GENMASK(1, 0), 2, 0 }
#define PORTA_U3_XH2E_DESC   { ASPEED_IP_SCU, SCU410, GENMASK(1, 0), 3, 0 }

SIG_EXPR_LIST_DECL_SEMG(PORTA_U3, USB3AXHD, USB3A, USB3AXHD, PORTA_U3_XHD_DESC,
                        SIG_DESC_SET(SCU410, 9));
SIG_EXPR_LIST_DECL_SEMG(PORTA_U3, USB3AXHPD, USB3A, USB3AXHPD, PORTA_U3_XHD_DESC,
                        SIG_DESC_CLEAR(SCU410, 9));
SIG_EXPR_LIST_DECL_SEMG(PORTA_U3, USB3AXH, USB3AAP, USB3AXH, PORTA_U3_XH_DESC,
                        SIG_DESC_SET(SCU410, 9));
SIG_EXPR_LIST_DECL_SEMG(PORTA_U3, USB3AXHP, USB3AAP, USB3AXHP, PORTA_U3_XH_DESC,
                        SIG_DESC_CLEAR(SCU410, 9));
SIG_EXPR_LIST_DECL_SEMG(PORTA_U3, USB3AXH2B, USB3ABP, USB3AXH2B, PORTA_U3_XH2E_DESC,
                        SIG_DESC_SET(SCU410, 9));
SIG_EXPR_LIST_DECL_SEMG(PORTA_U3, USB3AXHP2B, USB3ABP, USB3AXHP2B, PORTA_U3_XH2E_DESC,
                        SIG_DESC_CLEAR(SCU410, 9));
PIN_DECL_(PORTA_U3, SIG_EXPR_LIST_PTR(PORTA_U3, USB3AXHD), SIG_EXPR_LIST_PTR(PORTA_U3, USB3AXHPD),
          SIG_EXPR_LIST_PTR(PORTA_U3, USB3AXH), SIG_EXPR_LIST_PTR(PORTA_U3, USB3AXHP),
          SIG_EXPR_LIST_PTR(PORTA_U3, USB3AXH2B), SIG_EXPR_LIST_PTR(PORTA_U3, USB3AXHP2B));

#define PORTB_U3_XHD_DESC   { ASPEED_IP_SCU, SCU410, GENMASK(5, 4), 0, 0 }
#define PORTB_U3_XH_DESC    { ASPEED_IP_SCU, SCU410, GENMASK(5, 4), 2, 0 }
#define PORTB_U3_XH2E_DESC   { ASPEED_IP_SCU, SCU410, GENMASK(5, 4), 3, 0 }

SIG_EXPR_LIST_DECL_SEMG(PORTB_U3, USB3BXHD, USB3B, USB3BXHD, PORTB_U3_XHD_DESC,
                        SIG_DESC_SET(SCU410, 10));
SIG_EXPR_LIST_DECL_SEMG(PORTB_U3, USB3BXHPD, USB3B, USB3BXHPD, PORTB_U3_XHD_DESC,
                        SIG_DESC_CLEAR(SCU410, 10));
SIG_EXPR_LIST_DECL_SEMG(PORTB_U3, USB3BXH, USB3BBP, USB3BXH, PORTB_U3_XH_DESC,
                        SIG_DESC_SET(SCU410, 10));
SIG_EXPR_LIST_DECL_SEMG(PORTB_U3, USB3BXHP, USB3BBP, USB3BXHP, PORTB_U3_XH_DESC,
                        SIG_DESC_CLEAR(SCU410, 10));
SIG_EXPR_LIST_DECL_SEMG(PORTB_U3, USB3BXH2A, USB3BAP, USB3BXH2A, PORTB_U3_XH2E_DESC,
                        SIG_DESC_SET(SCU410, 10));
SIG_EXPR_LIST_DECL_SEMG(PORTB_U3, USB3BXHP2A, USB3BAP, USB3BXHP2A, PORTB_U3_XH2E_DESC,
                        SIG_DESC_CLEAR(SCU410, 10));
PIN_DECL_(PORTB_U3, SIG_EXPR_LIST_PTR(PORTB_U3, USB3BXHD), SIG_EXPR_LIST_PTR(PORTB_U3, USB3BXHPD),
          SIG_EXPR_LIST_PTR(PORTB_U3, USB3BXH), SIG_EXPR_LIST_PTR(PORTB_U3, USB3BXHP),
          SIG_EXPR_LIST_PTR(PORTB_U3, USB3BXH2A), SIG_EXPR_LIST_PTR(PORTB_U3, USB3BXHP2A));

/*
 * USB3 virtual PHY pins.
 *
 * PORTA_U3_PHY and PORTB_U3_PHY are logical endpoints, not package pins.
 * They alias existing USB3 expressions so pin groups can model both direct and
 * cross-coupled routing to PHY A/B.
 *
 * - USB3AAP: PORTA_U3 + PORTA_U3_PHY   (A -> PHY A)
 * - USB3ABP: PORTA_U3 + PORTB_U3_PHY   (A -> PHY B)
 * - USB3BBP: PORTB_U3 + PORTB_U3_PHY   (B -> PHY B)
 * - USB3BAP: PORTB_U3 + PORTA_U3_PHY   (B -> PHY A)
 *
 * They do not have any registers to configure this behavior; the goal is
 * simply for the driver to prevent conflicting selections. For example,
 * selecting group USB3ABP and USB3BBP at the same time should not be
 * allowed.
 */
SIG_EXPR_LIST_ALIAS(PORTA_U3_PHY, USB3AXH, USB3AAP);
SIG_EXPR_LIST_ALIAS(PORTA_U3_PHY, USB3AXHP, USB3AAP);
SIG_EXPR_LIST_ALIAS(PORTA_U3_PHY, USB3BXH2A, USB3BAP);
SIG_EXPR_LIST_ALIAS(PORTA_U3_PHY, USB3BXHP2A, USB3BAP);
PIN_DECL_(PORTA_U3_PHY, SIG_EXPR_LIST_PTR(PORTA_U3_PHY, USB3AXH),
          SIG_EXPR_LIST_PTR(PORTA_U3_PHY, USB3AXHP), SIG_EXPR_LIST_PTR(PORTA_U3_PHY, USB3BXH2A),
          SIG_EXPR_LIST_PTR(PORTA_U3_PHY, USB3BXHP2A));

SIG_EXPR_LIST_ALIAS(PORTB_U3_PHY, USB3AXH2B, USB3ABP);
SIG_EXPR_LIST_ALIAS(PORTB_U3_PHY, USB3AXHP2B, USB3ABP);
SIG_EXPR_LIST_ALIAS(PORTB_U3_PHY, USB3BXH, USB3BBP);
SIG_EXPR_LIST_ALIAS(PORTB_U3_PHY, USB3BXHP, USB3BBP);
PIN_DECL_(PORTB_U3_PHY, SIG_EXPR_LIST_PTR(PORTB_U3_PHY, USB3AXH2B),
          SIG_EXPR_LIST_PTR(PORTB_U3_PHY, USB3AXHP2B), SIG_EXPR_LIST_PTR(PORTB_U3_PHY, USB3BXH),
          SIG_EXPR_LIST_PTR(PORTB_U3_PHY, USB3BXHP));

/* USB3A xHCI to vHUB */
GROUP_DECL(USB3A, PORTA_U3);
/* USB3A xHCI to USB3A PHY */
GROUP_DECL(USB3AAP, PORTA_U3, PORTA_U3_PHY);
/* USB3A xHCI to USB3B PHY */
GROUP_DECL(USB3ABP, PORTA_U3, PORTB_U3_PHY);

FUNC_DECL_1(USB3AXHD, USB3A);
FUNC_DECL_1(USB3AXHPD, USB3A);
FUNC_DECL_1(USB3AXH, USB3AAP);
FUNC_DECL_1(USB3AXHP, USB3AAP);
FUNC_DECL_1(USB3AXH2B, USB3ABP);
FUNC_DECL_1(USB3AXHP2B, USB3ABP);

/* USB3B xHCI to vHUB */
GROUP_DECL(USB3B, PORTB_U3);
/* USB3B xHCI to USB3A PHY */
GROUP_DECL(USB3BAP, PORTB_U3, PORTA_U3_PHY);
/* USB3B xHCI to USB3B PHY */
GROUP_DECL(USB3BBP, PORTB_U3, PORTB_U3_PHY);

FUNC_DECL_1(USB3BXHD, USB3B);
FUNC_DECL_1(USB3BXHPD, USB3B);
FUNC_DECL_1(USB3BXH, USB3BBP);
FUNC_DECL_1(USB3BXHP, USB3BBP);
FUNC_DECL_1(USB3BXH2A, USB3BAP);
FUNC_DECL_1(USB3BXHP2A, USB3BAP);

static const struct pinctrl_pin_desc aspeed_g7_soc0_pins[] = {
        ASPEED_PINCTRL_PIN(AC14),
        ASPEED_PINCTRL_PIN(AE15),
        ASPEED_PINCTRL_PIN(AD14),
        ASPEED_PINCTRL_PIN(AE14),
        ASPEED_PINCTRL_PIN(AF14),
        ASPEED_PINCTRL_PIN(AB13),
        ASPEED_PINCTRL_PIN(AB14),
        ASPEED_PINCTRL_PIN(AF15),
        ASPEED_PINCTRL_PIN(AF13),
        ASPEED_PINCTRL_PIN(AC13),
        ASPEED_PINCTRL_PIN(AD13),
        ASPEED_PINCTRL_PIN(AE13),
        ASPEED_PINCTRL_PIN(JTAG_PORT),
        ASPEED_PINCTRL_PIN(PCIERC0_PERST),
        ASPEED_PINCTRL_PIN(PCIERC1_PERST),
        ASPEED_PINCTRL_PIN(PORTA_MODE),
        ASPEED_PINCTRL_PIN(PORTA_U2),
        ASPEED_PINCTRL_PIN(PORTA_U3),
        ASPEED_PINCTRL_PIN(PORTA_U2_PHY),
        ASPEED_PINCTRL_PIN(PORTA_U3_PHY),
        ASPEED_PINCTRL_PIN(PORTB_MODE),
        ASPEED_PINCTRL_PIN(PORTB_U2),
        ASPEED_PINCTRL_PIN(PORTB_U3),
        ASPEED_PINCTRL_PIN(PORTB_U2_PHY),
        ASPEED_PINCTRL_PIN(PORTB_U3_PHY),
};

static const struct aspeed_pin_group aspeed_g7_soc0_groups[] = {
        ASPEED_PINCTRL_GROUP(EMMCCDN),
        ASPEED_PINCTRL_GROUP(EMMCG1),
        ASPEED_PINCTRL_GROUP(EMMCG4),
        ASPEED_PINCTRL_GROUP(EMMCG8),
        ASPEED_PINCTRL_GROUP(EMMCWPN),
        ASPEED_PINCTRL_GROUP(TSPRSTN),
        ASPEED_PINCTRL_GROUP(UFSCLKI),
        ASPEED_PINCTRL_GROUP(VB0),
        ASPEED_PINCTRL_GROUP(VB1),
        ASPEED_PINCTRL_GROUP(VGADDC),
        /* JTAG groups */
        ASPEED_PINCTRL_GROUP(JTAG0),
        /* PCIE RC groups */
        ASPEED_PINCTRL_GROUP(PCIERC0PERST),
        ASPEED_PINCTRL_GROUP(PCIERC1PERST),
        /* USB3A groups */
        ASPEED_PINCTRL_GROUP(USB3A),
        ASPEED_PINCTRL_GROUP(USB3AAP),
        ASPEED_PINCTRL_GROUP(USB3ABP),
        /* USB3B groups */
        ASPEED_PINCTRL_GROUP(USB3B),
        ASPEED_PINCTRL_GROUP(USB3BAP),
        ASPEED_PINCTRL_GROUP(USB3BBP),
        /* USB2A groups */
        ASPEED_PINCTRL_GROUP(USB2A),
        ASPEED_PINCTRL_GROUP(USB2AAP),
        ASPEED_PINCTRL_GROUP(USB2ABP),
        ASPEED_PINCTRL_GROUP(USB2ADAP),
        ASPEED_PINCTRL_GROUP(USB2AH),
        ASPEED_PINCTRL_GROUP(USB2AHAP),
        /* USB2B groups */
        ASPEED_PINCTRL_GROUP(USB2B),
        ASPEED_PINCTRL_GROUP(USB2BAP),
        ASPEED_PINCTRL_GROUP(USB2BBP),
        ASPEED_PINCTRL_GROUP(USB2BDBP),
        ASPEED_PINCTRL_GROUP(USB2BH),
        ASPEED_PINCTRL_GROUP(USB2BHBP),
};

static const struct aspeed_pin_function aspeed_g7_soc0_functions[] = {
        ASPEED_PINCTRL_FUNC(EMMC),
        ASPEED_PINCTRL_FUNC(TSPRSTN),
        ASPEED_PINCTRL_FUNC(UFSCLKI),
        ASPEED_PINCTRL_FUNC(VB),
        ASPEED_PINCTRL_FUNC(VGADDC),
        /* JTAG functions */
        ASPEED_PINCTRL_FUNC(JTAGDDR),
        ASPEED_PINCTRL_FUNC(JTAGM0),
        ASPEED_PINCTRL_FUNC(JTAGPCIEA),
        ASPEED_PINCTRL_FUNC(JTAGPCIEB),
        ASPEED_PINCTRL_FUNC(JTAGPSP),
        ASPEED_PINCTRL_FUNC(JTAGSSP),
        ASPEED_PINCTRL_FUNC(JTAGTSP),
        ASPEED_PINCTRL_FUNC(JTAGUSB3A),
        ASPEED_PINCTRL_FUNC(JTAGUSB3B),
        /* PCIE RC functions */
        ASPEED_PINCTRL_FUNC(PCIERC0PERST),
        ASPEED_PINCTRL_FUNC(PCIERC1PERST),
        /* USB3A functions */
        ASPEED_PINCTRL_FUNC(USB3AXH),
        ASPEED_PINCTRL_FUNC(USB3AXH2B),
        ASPEED_PINCTRL_FUNC(USB3AXHD),
        ASPEED_PINCTRL_FUNC(USB3AXHP),
        ASPEED_PINCTRL_FUNC(USB3AXHP2B),
        ASPEED_PINCTRL_FUNC(USB3AXHPD),
        /* USB3B functions */
        ASPEED_PINCTRL_FUNC(USB3BXH),
        ASPEED_PINCTRL_FUNC(USB3BXH2A),
        ASPEED_PINCTRL_FUNC(USB3BXHD),
        ASPEED_PINCTRL_FUNC(USB3BXHP),
        ASPEED_PINCTRL_FUNC(USB3BXHP2A),
        ASPEED_PINCTRL_FUNC(USB3BXHPD),
        /* USB2A functions */
        ASPEED_PINCTRL_FUNC(USB2AD0),
        ASPEED_PINCTRL_FUNC(USB2AD1),
        ASPEED_PINCTRL_FUNC(USB2AH),
        ASPEED_PINCTRL_FUNC(USB2AHP),
        ASPEED_PINCTRL_FUNC(USB2AHPD0),
        ASPEED_PINCTRL_FUNC(USB2AXH),
        ASPEED_PINCTRL_FUNC(USB2AXH2B),
        ASPEED_PINCTRL_FUNC(USB2AXHD1),
        ASPEED_PINCTRL_FUNC(USB2AXHP),
        ASPEED_PINCTRL_FUNC(USB2AXHP2B),
        ASPEED_PINCTRL_FUNC(USB2AXHPD1),
        /* USB2B functions */
        ASPEED_PINCTRL_FUNC(USB2BD0),
        ASPEED_PINCTRL_FUNC(USB2BD1),
        ASPEED_PINCTRL_FUNC(USB2BH),
        ASPEED_PINCTRL_FUNC(USB2BHP),
        ASPEED_PINCTRL_FUNC(USB2BHPD0),
        ASPEED_PINCTRL_FUNC(USB2BXH),
        ASPEED_PINCTRL_FUNC(USB2BXH2A),
        ASPEED_PINCTRL_FUNC(USB2BXHD1),
        ASPEED_PINCTRL_FUNC(USB2BXHP),
        ASPEED_PINCTRL_FUNC(USB2BXHP2A),
        ASPEED_PINCTRL_FUNC(USB2BXHPD1),
};

static const struct pinmux_ops aspeed_g7_soc0_pinmux_ops = {
        .get_functions_count = aspeed_pinmux_get_fn_count,
        .get_function_name = aspeed_pinmux_get_fn_name,
        .get_function_groups = aspeed_pinmux_get_fn_groups,
        .set_mux = aspeed_pinmux_set_mux,
        .gpio_request_enable = aspeed_gpio_request_enable,
        .strict = true,
};

static const struct pinctrl_ops aspeed_g7_soc0_pinctrl_ops = {
        .get_groups_count = aspeed_pinctrl_get_groups_count,
        .get_group_name = aspeed_pinctrl_get_group_name,
        .get_group_pins = aspeed_pinctrl_get_group_pins,
        .pin_dbg_show = aspeed_pinctrl_pin_dbg_show,
        .dt_node_to_map = pinconf_generic_dt_node_to_map_all,
        .dt_free_map = pinctrl_utils_free_map,
};

static const struct pinconf_ops aspeed_g7_soc0_pinconf_ops = {
        .is_generic = true,
        .pin_config_get = aspeed_pin_config_get,
        .pin_config_set = aspeed_pin_config_set,
        .pin_config_group_get = aspeed_pin_config_group_get,
        .pin_config_group_set = aspeed_pin_config_group_set,
};

/* pinctrl_desc */
static const struct pinctrl_desc aspeed_g7_soc0_pinctrl_desc = {
        .name = "aspeed-g7-soc0-pinctrl",
        .pins = aspeed_g7_soc0_pins,
        .npins = ARRAY_SIZE(aspeed_g7_soc0_pins),
        .pctlops = &aspeed_g7_soc0_pinctrl_ops,
        .pmxops = &aspeed_g7_soc0_pinmux_ops,
        .confops = &aspeed_g7_soc0_pinconf_ops,
};

static const struct aspeed_pin_config aspeed_g7_soc0_configs[] = {
        /* GPIO18A */
        { PIN_CONFIG_DRIVE_STRENGTH, { AC14, AC14 }, SCU480, GENMASK(3, 0) },
        { PIN_CONFIG_BIAS_PULL_DOWN, { AC14, AC14 }, SCU480, GENMASK(5, 4) },
        { PIN_CONFIG_BIAS_PULL_UP, { AC14, AC14 }, SCU480, GENMASK(5, 4) },
        { PIN_CONFIG_BIAS_DISABLE, { AC14, AC14 }, SCU480, BIT(5) },
        { PIN_CONFIG_DRIVE_STRENGTH, { AE15, AE15 }, SCU484, GENMASK(3, 0) },
        { PIN_CONFIG_BIAS_PULL_DOWN, { AE15, AE15 }, SCU484, GENMASK(5, 4) },
        { PIN_CONFIG_BIAS_PULL_UP, { AE15, AE15 }, SCU484, GENMASK(5, 4) },
        { PIN_CONFIG_BIAS_DISABLE, { AE15, AE15 }, SCU484, BIT(5) },
        { PIN_CONFIG_DRIVE_STRENGTH, { AD14, AD14 }, SCU488, GENMASK(3, 0) },
        { PIN_CONFIG_BIAS_PULL_DOWN, { AD14, AD14 }, SCU488, GENMASK(5, 4) },
        { PIN_CONFIG_BIAS_PULL_UP, { AD14, AD14 }, SCU488, GENMASK(5, 4) },
        { PIN_CONFIG_BIAS_DISABLE, { AD14, AD14 }, SCU488, BIT(5) },
        { PIN_CONFIG_DRIVE_STRENGTH, { AE14, AE14 }, SCU48C, GENMASK(3, 0) },
        { PIN_CONFIG_BIAS_PULL_DOWN, { AE14, AE14 }, SCU48C, GENMASK(5, 4) },
        { PIN_CONFIG_BIAS_PULL_UP, { AE14, AE14 }, SCU48C, GENMASK(5, 4) },
        { PIN_CONFIG_BIAS_DISABLE, { AE14, AE14 }, SCU48C, BIT(5) },
        { PIN_CONFIG_DRIVE_STRENGTH, { AF14, AF14 }, SCU490, GENMASK(3, 0) },
        { PIN_CONFIG_BIAS_PULL_DOWN, { AF14, AF14 }, SCU490, GENMASK(5, 4) },
        { PIN_CONFIG_BIAS_PULL_UP, { AF14, AF14 }, SCU490, GENMASK(5, 4) },
        { PIN_CONFIG_BIAS_DISABLE, { AF14, AF14 }, SCU490, BIT(5) },
        { PIN_CONFIG_DRIVE_STRENGTH, { AB13, AB13 }, SCU494, GENMASK(3, 0) },
        { PIN_CONFIG_BIAS_PULL_DOWN, { AB13, AB13 }, SCU494, GENMASK(5, 4) },
        { PIN_CONFIG_BIAS_PULL_UP, { AB13, AB13 }, SCU494, GENMASK(5, 4) },
        { PIN_CONFIG_BIAS_DISABLE, { AB13, AB13 }, SCU494, BIT(5) },
        { PIN_CONFIG_DRIVE_STRENGTH, { AB14, AB14 }, SCU498, GENMASK(3, 0) },
        { PIN_CONFIG_BIAS_PULL_DOWN, { AB14, AB14 }, SCU498, GENMASK(5, 4) },
        { PIN_CONFIG_BIAS_PULL_UP, { AB14, AB14 }, SCU498, GENMASK(5, 4) },
        { PIN_CONFIG_BIAS_DISABLE, { AB14, AB14 }, SCU498, BIT(5) },
        { PIN_CONFIG_DRIVE_STRENGTH, { AF15, AF15 }, SCU49C, GENMASK(3, 0) },
        { PIN_CONFIG_BIAS_PULL_DOWN, { AF15, AF15 }, SCU49C, GENMASK(5, 4) },
        { PIN_CONFIG_BIAS_PULL_UP, { AF15, AF15 }, SCU49C, GENMASK(5, 4) },
        { PIN_CONFIG_BIAS_DISABLE, { AF15, AF15 }, SCU49C, BIT(5) },
        /* GPIO18B */
        { PIN_CONFIG_DRIVE_STRENGTH, { AF13, AF13 }, SCU4A0, GENMASK(3, 0) },
        { PIN_CONFIG_BIAS_PULL_DOWN, { AF13, AF13 }, SCU4A0, GENMASK(5, 4) },
        { PIN_CONFIG_BIAS_PULL_UP, { AF13, AF13 }, SCU4A0, GENMASK(5, 4) },
        { PIN_CONFIG_BIAS_DISABLE, { AF13, AF13 }, SCU4A0, BIT(5) },
        { PIN_CONFIG_DRIVE_STRENGTH, { AC13, AC13 }, SCU4A4, GENMASK(3, 0) },
        { PIN_CONFIG_BIAS_PULL_DOWN, { AC13, AC13 }, SCU4A4, GENMASK(5, 4) },
        { PIN_CONFIG_BIAS_PULL_UP, { AC13, AC13 }, SCU4A4, GENMASK(5, 4) },
        { PIN_CONFIG_BIAS_DISABLE, { AC13, AC13 }, SCU4A4, BIT(5) },
        { PIN_CONFIG_DRIVE_STRENGTH, { AD13, AD13 }, SCU4A8, GENMASK(3, 0) },
        { PIN_CONFIG_BIAS_PULL_DOWN, { AD13, AD13 }, SCU4A8, GENMASK(5, 4) },
        { PIN_CONFIG_BIAS_PULL_UP, { AD13, AD13 }, SCU4A8, GENMASK(5, 4) },
        { PIN_CONFIG_BIAS_DISABLE, { AD13, AD13 }, SCU4A8, BIT(5) },
        { PIN_CONFIG_DRIVE_STRENGTH, { AE13, AE13 }, SCU4AC, GENMASK(3, 0) },
        { PIN_CONFIG_BIAS_PULL_DOWN, { AE13, AE13 }, SCU4AC, GENMASK(5, 4) },
        { PIN_CONFIG_BIAS_PULL_UP, { AE13, AE13 }, SCU4AC, GENMASK(5, 4) },
        { PIN_CONFIG_BIAS_DISABLE, { AE13, AE13 }, SCU4AC, BIT(5) },
};

static const struct aspeed_pin_config_map aspeed_g7_soc0_pin_config_map[] = {
        { PIN_CONFIG_BIAS_PULL_DOWN, -1, 2, GENMASK(1, 0) },
        { PIN_CONFIG_BIAS_PULL_UP, -1, 3, GENMASK(1, 0) },
        { PIN_CONFIG_BIAS_DISABLE, -1, 0, BIT_MASK(0) },
        { PIN_CONFIG_DRIVE_STRENGTH, 3, 0, GENMASK(3, 0) },
        { PIN_CONFIG_DRIVE_STRENGTH, 6, 1, GENMASK(3, 0) },
        { PIN_CONFIG_DRIVE_STRENGTH, 8, 2, GENMASK(3, 0) },
        { PIN_CONFIG_DRIVE_STRENGTH, 11, 3, GENMASK(3, 0) },
        { PIN_CONFIG_DRIVE_STRENGTH, 16, 4, GENMASK(3, 0) },
        { PIN_CONFIG_DRIVE_STRENGTH, 18, 5, GENMASK(3, 0) },
        { PIN_CONFIG_DRIVE_STRENGTH, 20, 6, GENMASK(3, 0) },
        { PIN_CONFIG_DRIVE_STRENGTH, 23, 7, GENMASK(3, 0) },
        { PIN_CONFIG_DRIVE_STRENGTH, 30, 8, GENMASK(3, 0) },
        { PIN_CONFIG_DRIVE_STRENGTH, 32, 9, GENMASK(3, 0) },
        { PIN_CONFIG_DRIVE_STRENGTH, 33, 10, GENMASK(3, 0) },
        { PIN_CONFIG_DRIVE_STRENGTH, 35, 11, GENMASK(3, 0) },
        { PIN_CONFIG_DRIVE_STRENGTH, 37, 12, GENMASK(3, 0) },
        { PIN_CONFIG_DRIVE_STRENGTH, 38, 13, GENMASK(3, 0) },
        { PIN_CONFIG_DRIVE_STRENGTH, 39, 14, GENMASK(3, 0) },
        { PIN_CONFIG_DRIVE_STRENGTH, 41, 15, GENMASK(3, 0) },

};

static int aspeed_g7_soc0_sig_expr_set(struct aspeed_pinmux_data *ctx,
                                       const struct aspeed_sig_expr *expr, bool enable)
{
        int ret;
        int i;

        for (i = 0; i < expr->ndescs; i++) {
                const struct aspeed_sig_desc *desc = &expr->descs[i];
                u32 pattern = enable ? desc->enable : desc->disable;
                u32 val = (pattern << __ffs(desc->mask));

                if (!ctx->maps[desc->ip])
                        return -ENODEV;

                WARN_ON_ONCE(desc->ip != ASPEED_IP_SCU);

                ret = regmap_update_bits(ctx->maps[desc->ip], desc->reg,
                                         desc->mask, val);
                if (ret)
                        return ret;
        }

        ret = aspeed_sig_expr_eval(ctx, expr, enable);
        if (ret < 0)
                return ret;

        return ret ? 0 : -EPERM;
}

static const struct aspeed_pinmux_ops aspeed_g7_soc0_ops = {
        .set = aspeed_g7_soc0_sig_expr_set,
};

static struct aspeed_pinctrl_data aspeed_g7_soc0_pinctrl_data = {
        .pins = aspeed_g7_soc0_pins,
        .npins = ARRAY_SIZE(aspeed_g7_soc0_pins),
        .pinmux = {
                .ops = &aspeed_g7_soc0_ops,
                .groups = aspeed_g7_soc0_groups,
                .ngroups = ARRAY_SIZE(aspeed_g7_soc0_groups),
                .functions = aspeed_g7_soc0_functions,
                .nfunctions = ARRAY_SIZE(aspeed_g7_soc0_functions),
        },
        .configs = aspeed_g7_soc0_configs,
        .nconfigs = ARRAY_SIZE(aspeed_g7_soc0_configs),
        .confmaps = aspeed_g7_soc0_pin_config_map,
        .nconfmaps = ARRAY_SIZE(aspeed_g7_soc0_pin_config_map),
};

static int aspeed_g7_soc0_pinctrl_probe(struct platform_device *pdev)
{
        return aspeed_pinctrl_probe(pdev, &aspeed_g7_soc0_pinctrl_desc,
                                    &aspeed_g7_soc0_pinctrl_data);
}

static const struct of_device_id aspeed_g7_soc0_pinctrl_match[] = {
        { .compatible = "aspeed,ast2700-soc0-pinctrl" },
        {}
};
MODULE_DEVICE_TABLE(of, aspeed_g7_soc0_pinctrl_match);

static struct platform_driver aspeed_g7_soc0_pinctrl_driver = {
        .probe = aspeed_g7_soc0_pinctrl_probe,
        .driver = {
                .name = "aspeed-g7-soc0-pinctrl",
                .of_match_table = aspeed_g7_soc0_pinctrl_match,
                .suppress_bind_attrs = true,
        },
};

static int __init aspeed_g7_soc0_pinctrl_init(void)
{
        return platform_driver_register(&aspeed_g7_soc0_pinctrl_driver);
}
arch_initcall(aspeed_g7_soc0_pinctrl_init);