/* SPDX-License-Identifier: GPL-2.0+ */
#ifndef __ASPEED_VHUB_H
#define __ASPEED_VHUB_H

#include <linux/usb.h>
#include <linux/usb/ch11.h>

/*****************************
 *                           *
 * VHUB register definitions *
 *                           *
 *****************************/

#define AST_VHUB_CTRL           0x00    /* Root Function Control & Status Register */
#define AST_VHUB_CONF           0x04    /* Root Configuration Setting Register */
#define AST_VHUB_IER            0x08    /* Interrupt Ctrl Register */
#define AST_VHUB_ISR            0x0C    /* Interrupt Status Register */
#define AST_VHUB_EP_ACK_IER     0x10    /* Programmable Endpoint Pool ACK Interrupt Enable Register */
#define AST_VHUB_EP_NACK_IER    0x14    /* Programmable Endpoint Pool NACK Interrupt Enable Register  */
#define AST_VHUB_EP_ACK_ISR     0x18    /* Programmable Endpoint Pool ACK Interrupt Status Register  */
#define AST_VHUB_EP_NACK_ISR    0x1C    /* Programmable Endpoint Pool NACK Interrupt Status Register  */
#define AST_VHUB_SW_RESET       0x20    /* Device Controller Soft Reset Enable Register */
#define AST_VHUB_USBSTS         0x24    /* USB Status Register */
#define AST_VHUB_EP_TOGGLE      0x28    /* Programmable Endpoint Pool Data Toggle Value Set */
#define AST_VHUB_ISO_FAIL_ACC   0x2C    /* Isochronous Transaction Fail Accumulator */
#define AST_VHUB_EP0_CTRL       0x30    /* Endpoint 0 Contrl/Status Register */
#define AST_VHUB_EP0_DATA       0x34    /* Base Address of Endpoint 0 In/OUT Data Buffer Register */
#define AST_VHUB_EP1_CTRL       0x38    /* Endpoint 1 Contrl/Status Register */
#define AST_VHUB_EP1_STS_CHG    0x3C    /* Endpoint 1 Status Change Bitmap Data */
#define AST_VHUB_SETUP0         0x80    /* Root Device Setup Data Buffer0 */
#define AST_VHUB_SETUP1         0x84    /* Root Device Setup Data Buffer1 */

/* Main control reg */
#define VHUB_CTRL_PHY_CLK                       (1 << 31)
#define VHUB_CTRL_PHY_LOOP_TEST                 (1 << 25)
#define VHUB_CTRL_DN_PWN                        (1 << 24)
#define VHUB_CTRL_DP_PWN                        (1 << 23)
#define VHUB_CTRL_LONG_DESC                     (1 << 18)
#define VHUB_CTRL_ISO_RSP_CTRL                  (1 << 17)
#define VHUB_CTRL_SPLIT_IN                      (1 << 16)
#define VHUB_CTRL_LOOP_T_RESULT                 (1 << 15)
#define VHUB_CTRL_LOOP_T_STS                    (1 << 14)
#define VHUB_CTRL_PHY_BIST_RESULT               (1 << 13)
#define VHUB_CTRL_PHY_BIST_CTRL                 (1 << 12)
#define VHUB_CTRL_PHY_RESET_DIS                 (1 << 11)
#define VHUB_CTRL_SET_TEST_MODE(x)              ((x) << 8)
#define VHUB_CTRL_MANUAL_REMOTE_WAKEUP          (1 << 4)
#define VHUB_CTRL_AUTO_REMOTE_WAKEUP            (1 << 3)
#define VHUB_CTRL_CLK_STOP_SUSPEND              (1 << 2)
#define VHUB_CTRL_FULL_SPEED_ONLY               (1 << 1)
#define VHUB_CTRL_UPSTREAM_CONNECT              (1 << 0)

/* IER & ISR */
#define VHUB_IRQ_DEV1_BIT                       9
#define VHUB_IRQ_USB_CMD_DEADLOCK               (1 << 18)
#define VHUB_IRQ_EP_POOL_NAK                    (1 << 17)
#define VHUB_IRQ_EP_POOL_ACK_STALL              (1 << 16)
#define VHUB_IRQ_DEVICE1                        (1 << (VHUB_IRQ_DEV1_BIT))
#define VHUB_IRQ_BUS_RESUME                     (1 << 8)
#define VHUB_IRQ_BUS_SUSPEND                    (1 << 7)
#define VHUB_IRQ_BUS_RESET                      (1 << 6)
#define VHUB_IRQ_HUB_EP1_IN_DATA_ACK            (1 << 5)
#define VHUB_IRQ_HUB_EP0_IN_DATA_NAK            (1 << 4)
#define VHUB_IRQ_HUB_EP0_IN_ACK_STALL           (1 << 3)
#define VHUB_IRQ_HUB_EP0_OUT_NAK                (1 << 2)
#define VHUB_IRQ_HUB_EP0_OUT_ACK_STALL          (1 << 1)
#define VHUB_IRQ_HUB_EP0_SETUP                  (1 << 0)
#define VHUB_IRQ_ACK_ALL                        0x1ff

/* Downstream device IRQ mask. */
#define VHUB_DEV_IRQ(n)                         (VHUB_IRQ_DEVICE1 << (n))

/* SW reset reg */
#define VHUB_SW_RESET_EP_POOL                   (1 << 9)
#define VHUB_SW_RESET_DMA_CONTROLLER            (1 << 8)
#define VHUB_SW_RESET_DEVICE5                   (1 << 5)
#define VHUB_SW_RESET_DEVICE4                   (1 << 4)
#define VHUB_SW_RESET_DEVICE3                   (1 << 3)
#define VHUB_SW_RESET_DEVICE2                   (1 << 2)
#define VHUB_SW_RESET_DEVICE1                   (1 << 1)
#define VHUB_SW_RESET_ROOT_HUB                  (1 << 0)

/* EP ACK/NACK IRQ masks */
#define VHUB_EP_IRQ(n)                          (1 << (n))

/* USB status reg */
#define VHUB_USBSTS_HISPEED                     (1 << 27)

/* EP toggle */
#define VHUB_EP_TOGGLE_VALUE                    (1 << 8)
#define VHUB_EP_TOGGLE_SET_EPNUM(x)             ((x) & 0x1f)

/* HUB EP0 control */
#define VHUB_EP0_CTRL_STALL                     (1 << 0)
#define VHUB_EP0_TX_BUFF_RDY                    (1 << 1)
#define VHUB_EP0_RX_BUFF_RDY                    (1 << 2)
#define VHUB_EP0_RX_LEN(x)                      (((x) >> 16) & 0x7f)
#define VHUB_EP0_SET_TX_LEN(x)                  (((x) & 0x7f) << 8)

/* HUB EP1 control */
#define VHUB_EP1_CTRL_RESET_TOGGLE              (1 << 2)
#define VHUB_EP1_CTRL_STALL                     (1 << 1)
#define VHUB_EP1_CTRL_ENABLE                    (1 << 0)

/***********************************
 *                                 *
 * per-device register definitions *
 *                                 *
 ***********************************/
#define AST_VHUB_DEV_EN_CTRL            0x00
#define AST_VHUB_DEV_ISR                0x04
#define AST_VHUB_DEV_EP0_CTRL           0x08
#define AST_VHUB_DEV_EP0_DATA           0x0c

/* Device enable control */
#define VHUB_DEV_EN_SET_ADDR(x)                 ((x) << 8)
#define VHUB_DEV_EN_ADDR_MASK                   ((0xff) << 8)
#define VHUB_DEV_EN_EP0_NAK_IRQEN               (1 << 6)
#define VHUB_DEV_EN_EP0_IN_ACK_IRQEN            (1 << 5)
#define VHUB_DEV_EN_EP0_OUT_NAK_IRQEN           (1 << 4)
#define VHUB_DEV_EN_EP0_OUT_ACK_IRQEN           (1 << 3)
#define VHUB_DEV_EN_EP0_SETUP_IRQEN             (1 << 2)
#define VHUB_DEV_EN_SPEED_SEL_HIGH              (1 << 1)
#define VHUB_DEV_EN_ENABLE_PORT                 (1 << 0)

/* Interrupt status */
#define VHUV_DEV_IRQ_EP0_IN_DATA_NACK           (1 << 4)
#define VHUV_DEV_IRQ_EP0_IN_ACK_STALL           (1 << 3)
#define VHUV_DEV_IRQ_EP0_OUT_DATA_NACK          (1 << 2)
#define VHUV_DEV_IRQ_EP0_OUT_ACK_STALL          (1 << 1)
#define VHUV_DEV_IRQ_EP0_SETUP                  (1 << 0)

/* Control bits.
 *
 * Note: The driver relies on the bulk of those bits
 *       matching corresponding vHub EP0 control bits
 */
#define VHUB_DEV_EP0_CTRL_STALL                 VHUB_EP0_CTRL_STALL
#define VHUB_DEV_EP0_TX_BUFF_RDY                VHUB_EP0_TX_BUFF_RDY
#define VHUB_DEV_EP0_RX_BUFF_RDY                VHUB_EP0_RX_BUFF_RDY
#define VHUB_DEV_EP0_RX_LEN(x)                  VHUB_EP0_RX_LEN(x)
#define VHUB_DEV_EP0_SET_TX_LEN(x)              VHUB_EP0_SET_TX_LEN(x)

/*************************************
 *                                   *
 * per-endpoint register definitions *
 *                                   *
 *************************************/

#define AST_VHUB_EP_CONFIG              0x00
#define AST_VHUB_EP_DMA_CTLSTAT         0x04
#define AST_VHUB_EP_DESC_BASE           0x08
#define AST_VHUB_EP_DESC_STATUS         0x0C

/* EP config reg */
#define VHUB_EP_CFG_SET_MAX_PKT(x)      (((x) & 0x3ff) << 16)
#define VHUB_EP_CFG_AUTO_DATA_DISABLE   (1 << 13)
#define VHUB_EP_CFG_STALL_CTRL          (1 << 12)
#define VHUB_EP_CFG_SET_EP_NUM(x)       (((x) & 0xf) << 8)
#define VHUB_EP_CFG_SET_TYPE(x)         ((x) << 5)
#define   EP_TYPE_OFF                   0
#define   EP_TYPE_BULK                  1
#define   EP_TYPE_INT                   2
#define   EP_TYPE_ISO                   3
#define VHUB_EP_CFG_DIR_OUT             (1 << 4)
#define VHUB_EP_CFG_SET_DEV(x)          ((x) << 1)
#define VHUB_EP_CFG_ENABLE              (1 << 0)

/* EP DMA control */
#define VHUB_EP_DMA_PROC_STATUS(x)      (((x) >> 4) & 0xf)
#define   EP_DMA_PROC_RX_IDLE           0
#define   EP_DMA_PROC_TX_IDLE           8
#define VHUB_EP_DMA_IN_LONG_MODE        (1 << 3)
#define VHUB_EP_DMA_OUT_CONTIG_MODE     (1 << 3)
#define VHUB_EP_DMA_CTRL_RESET          (1 << 2)
#define VHUB_EP_DMA_SINGLE_STAGE        (1 << 1)
#define VHUB_EP_DMA_DESC_MODE           (1 << 0)

/* EP DMA status */
#define VHUB_EP_DMA_SET_TX_SIZE(x)      ((x) << 16)
#define VHUB_EP_DMA_TX_SIZE(x)          (((x) >> 16) & 0x7ff)
#define VHUB_EP_DMA_RPTR(x)             (((x) >> 8) & 0xff)
#define VHUB_EP_DMA_SET_RPTR(x)         (((x) & 0xff) << 8)
#define VHUB_EP_DMA_SET_CPU_WPTR(x)     (x)
#define VHUB_EP_DMA_SINGLE_KICK         (1 << 0) /* WPTR = 1 for single mode */

/*******************************
 *                             *
 * DMA descriptors definitions *
 *                             *
 *******************************/

/* Desc W1 IN */
#define VHUB_DSC1_IN_INTERRUPT          (1 << 31)
#define VHUB_DSC1_IN_SPID_DATA0         (0 << 14)
#define VHUB_DSC1_IN_SPID_DATA2         (1 << 14)
#define VHUB_DSC1_IN_SPID_DATA1         (2 << 14)
#define VHUB_DSC1_IN_SPID_MDATA         (3 << 14)
#define VHUB_DSC1_IN_SET_LEN(x)         ((x) & 0xfff)
#define VHUB_DSC1_IN_LEN(x)             ((x) & 0xfff)

/****************************************
 *                                      *
 * Data structures and misc definitions *
 *                                      *
 ****************************************/

/*
 * AST_VHUB_NUM_GEN_EPs and AST_VHUB_NUM_PORTS are kept to avoid breaking
 * existing AST2400/AST2500 platforms. AST2600 and future vhub revisions
 * should define number of downstream ports and endpoints in device tree.
 */
#define AST_VHUB_NUM_GEN_EPs    15      /* Generic non-0 EPs */
#define AST_VHUB_NUM_PORTS      5       /* vHub ports */
#define AST_VHUB_EP0_MAX_PACKET 64      /* EP0's max packet size */
#define AST_VHUB_EPn_MAX_PACKET 1024    /* Generic EPs max packet size */
#define AST_VHUB_DESCS_COUNT    256     /* Use 256 descriptor mode (valid
                                         * values are 256 and 32)
                                         */

struct ast_vhub;
struct ast_vhub_dev;

/*
 * DMA descriptor (generic EPs only, currently only used
 * for IN endpoints
 */
struct ast_vhub_desc {
        __le32  w0;
        __le32  w1;
};

/* A transfer request, either core-originated or internal */
struct ast_vhub_req {
        struct usb_request      req;
        struct list_head        queue;

        /* Actual count written to descriptors (desc mode only) */
        unsigned int            act_count;

        /*
         * Desc number of the final packet or -1. For non-desc
         * mode (or ep0), any >= 0 value means "last packet"
         */
        int                     last_desc;

        /* Request active (pending DMAs) */
        bool                    active  : 1;

        /* Internal request (don't call back core) */
        bool                    internal : 1;
};
#define to_ast_req(__ureq) container_of(__ureq, struct ast_vhub_req, req)

/* Current state of an EP0 */
enum ep0_state {
        ep0_state_token,
        ep0_state_data,
        ep0_state_status,
        ep0_state_stall,
};

/*
 * An endpoint, either generic, ep0, actual gadget EP
 * or internal use vhub EP0. vhub EP1 doesn't have an
 * associated structure as it's mostly HW managed.
 */
struct ast_vhub_ep {
        struct usb_ep           ep;

        /* Request queue */
        struct list_head        queue;

        /* EP index in the device, 0 means this is an EP0 */
        unsigned int            d_idx;

        /* Dev pointer or NULL for vHub EP0 */
        struct ast_vhub_dev     *dev;

        /* vHub itself */
        struct ast_vhub         *vhub;

        /*
         * DMA buffer for EP0, fallback DMA buffer for misaligned
         * OUT transfers for generic EPs
         */
        void                    *buf;
        dma_addr_t              buf_dma;

        /* The rest depends on the EP type */
        union {
                /* EP0 (either device or vhub) */
                struct {
                        /*
                         * EP0 registers are "similar" for
                         * vHub and devices but located in
                         * different places.
                         */
                        void __iomem            *ctlstat;
                        void __iomem            *setup;

                        /* Current state & direction */
                        enum ep0_state          state;
                        bool                    dir_in;

                        /* Internal use request */
                        struct ast_vhub_req     req;
                } ep0;

                /* Generic endpoint (aka EPn) */
                struct {
                        /* Registers */
                        void __iomem            *regs;

                        /* Index in global pool (zero-based) */
                        unsigned int            g_idx;

                        /* DMA Descriptors */
                        struct ast_vhub_desc    *descs;
                        dma_addr_t              descs_dma;
                        unsigned int            d_next;
                        unsigned int            d_last;
                        unsigned int            dma_conf;

                        /* Max chunk size for IN EPs */
                        unsigned int            chunk_max;

                        /* State flags */
                        bool                    is_in :  1;
                        bool                    is_iso : 1;
                        bool                    stalled : 1;
                        bool                    wedged : 1;
                        bool                    enabled : 1;
                        bool                    desc_mode : 1;
                } epn;
        };
};
#define to_ast_ep(__uep) container_of(__uep, struct ast_vhub_ep, ep)

/* A device attached to a vHub port */
struct ast_vhub_dev {
        struct ast_vhub                 *vhub;
        void __iomem                    *regs;

        /* Device index (zero-based) and name string */
        unsigned int                    index;
        const char                      *name;

        /* sysfs enclosure for the gadget gunk */
        struct device                   *port_dev;

        /* Link to gadget core */
        struct usb_gadget               gadget;
        struct usb_gadget_driver        *driver;
        bool                            registered : 1;
        bool                            wakeup_en : 1;
        bool                            enabled : 1;

        /* Endpoint structures */
        struct ast_vhub_ep              ep0;
        struct ast_vhub_ep              **epns;
        u32                             max_epns;

};
#define to_ast_dev(__g) container_of(__g, struct ast_vhub_dev, gadget)

/* Per vhub port stateinfo structure */
struct ast_vhub_port {
        /* Port status & status change registers */
        u16                     status;
        u16                     change;

        /* Associated device slot */
        struct ast_vhub_dev     dev;
};

struct ast_vhub_full_cdesc {
        struct usb_config_descriptor    cfg;
        struct usb_interface_descriptor intf;
        struct usb_endpoint_descriptor  ep;
} __packed;

/* Global vhub structure */
struct ast_vhub {
        struct platform_device          *pdev;
        void __iomem                    *regs;
        int                             irq;
        spinlock_t                      lock;
        struct work_struct              wake_work;
        struct clk                      *clk;
        struct reset_control            *rst;

        /* EP0 DMA buffers allocated in one chunk */
        void                            *ep0_bufs;
        dma_addr_t                      ep0_bufs_dma;

        /* EP0 of the vhub itself */
        struct ast_vhub_ep              ep0;

        /* State of vhub ep1 */
        bool                            ep1_stalled : 1;

        /* Per-port info */
        struct ast_vhub_port            *ports;
        u32                             max_ports;
        u32                             port_irq_mask;

        /* Generic EP data structures */
        struct ast_vhub_ep              *epns;
        u32                             max_epns;

        /* Upstream bus is suspended ? */
        bool                            suspended : 1;

        /* Hub itself can signal remote wakeup */
        bool                            wakeup_en : 1;

        /* Force full speed only */
        bool                            force_usb1 : 1;

        /* Upstream bus speed captured at bus reset */
        unsigned int                    speed;

        /* Standard USB Descriptors of the vhub. */
        struct usb_device_descriptor    vhub_dev_desc;
        struct ast_vhub_full_cdesc      vhub_conf_desc;
        struct usb_hub_descriptor       vhub_hub_desc;
        struct list_head                vhub_str_desc;
        struct usb_qualifier_descriptor vhub_qual_desc;
};

/* Standard request handlers result codes */
enum std_req_rc {
        std_req_stall = -1,     /* Stall requested */
        std_req_complete = 0,   /* Request completed with no data */
        std_req_data = 1,       /* Request completed with data */
        std_req_driver = 2,     /* Pass to driver pls */
};

#ifdef CONFIG_USB_GADGET_VERBOSE
#define UDCVDBG(u, fmt...)      dev_dbg(&(u)->pdev->dev, fmt)

#define EPVDBG(ep, fmt, ...)    do {                    \
        dev_dbg(&(ep)->vhub->pdev->dev,                 \
                "%s:EP%d " fmt,                         \
                (ep)->dev ? (ep)->dev->name : "hub",    \
                (ep)->d_idx, ##__VA_ARGS__);            \
        } while(0)

#define DVDBG(d, fmt, ...)      do {                    \
        dev_dbg(&(d)->vhub->pdev->dev,                  \
                "%s " fmt, (d)->name,                   \
                ##__VA_ARGS__);                         \
        } while(0)

#else
#define UDCVDBG(u, fmt...)      do { } while(0)
#define EPVDBG(ep, fmt, ...)    do { } while(0)
#define DVDBG(d, fmt, ...)      do { } while(0)
#endif

#ifdef CONFIG_USB_GADGET_DEBUG
#define UDCDBG(u, fmt...)       dev_dbg(&(u)->pdev->dev, fmt)

#define EPDBG(ep, fmt, ...)     do {                    \
        dev_dbg(&(ep)->vhub->pdev->dev,                 \
                "%s:EP%d " fmt,                         \
                (ep)->dev ? (ep)->dev->name : "hub",    \
                (ep)->d_idx, ##__VA_ARGS__);            \
        } while(0)

#define DDBG(d, fmt, ...)       do {                    \
        dev_dbg(&(d)->vhub->pdev->dev,                  \
                "%s " fmt, (d)->name,                   \
                ##__VA_ARGS__);                         \
        } while(0)
#else
#define UDCDBG(u, fmt...)       do { } while(0)
#define EPDBG(ep, fmt, ...)     do { } while(0)
#define DDBG(d, fmt, ...)       do { } while(0)
#endif

static inline void vhub_dma_workaround(void *addr)
{
        /*
         * This works around a confirmed HW issue with the Aspeed chip.
         *
         * The core uses a different bus to memory than the AHB going to
         * the USB device controller. Due to the latter having a higher
         * priority than the core for arbitration on that bus, it's
         * possible for an MMIO to the device, followed by a DMA by the
         * device from memory to all be performed and services before
         * a previous store to memory gets completed.
         *
         * This the following scenario can happen:
         *
         *    - Driver writes to a DMA descriptor (Mbus)
         *    - Driver writes to the MMIO register to start the DMA (AHB)
         *    - The gadget sees the second write and sends a read of the
         *      descriptor to the memory controller (Mbus)
         *    - The gadget hits memory before the descriptor write
         *      causing it to read an obsolete value.
         *
         * Thankfully the problem is limited to the USB gadget device, other
         * masters in the SoC all have a lower priority than the core, thus
         * ensuring that the store by the core arrives first.
         *
         * The workaround consists of using a dummy read of the memory before
         * doing the MMIO writes. This will ensure that the previous writes
         * have been "pushed out".
         */
        mb();
        (void)__raw_readl((void __iomem *)addr);
}

/* core.c */
void ast_vhub_done(struct ast_vhub_ep *ep, struct ast_vhub_req *req,
                   int status);
void ast_vhub_nuke(struct ast_vhub_ep *ep, int status);
struct usb_request *ast_vhub_alloc_request(struct usb_ep *u_ep,
                                           gfp_t gfp_flags);
void ast_vhub_free_request(struct usb_ep *u_ep, struct usb_request *u_req);
void ast_vhub_init_hw(struct ast_vhub *vhub);

/* ep0.c */
void ast_vhub_ep0_handle_ack(struct ast_vhub_ep *ep, bool in_ack);
void ast_vhub_ep0_handle_setup(struct ast_vhub_ep *ep);
void ast_vhub_reset_ep0(struct ast_vhub_dev *dev);
void ast_vhub_init_ep0(struct ast_vhub *vhub, struct ast_vhub_ep *ep,
                       struct ast_vhub_dev *dev);
int ast_vhub_reply(struct ast_vhub_ep *ep, char *ptr, int len);
int __ast_vhub_simple_reply(struct ast_vhub_ep *ep, int len, ...);
#define ast_vhub_simple_reply(udc, ...)                                        \
        __ast_vhub_simple_reply((udc),                                         \
                               sizeof((u8[]) { __VA_ARGS__ })/sizeof(u8),      \
                               __VA_ARGS__)

/* hub.c */
int ast_vhub_init_hub(struct ast_vhub *vhub);
enum std_req_rc ast_vhub_std_hub_request(struct ast_vhub_ep *ep,
                                         struct usb_ctrlrequest *crq);
enum std_req_rc ast_vhub_class_hub_request(struct ast_vhub_ep *ep,
                                           struct usb_ctrlrequest *crq);
void ast_vhub_device_connect(struct ast_vhub *vhub, unsigned int port,
                             bool on);
void ast_vhub_hub_suspend(struct ast_vhub *vhub);
void ast_vhub_hub_resume(struct ast_vhub *vhub);
void ast_vhub_hub_reset(struct ast_vhub *vhub);
void ast_vhub_hub_wake_all(struct ast_vhub *vhub);

/* dev.c */
int ast_vhub_init_dev(struct ast_vhub *vhub, unsigned int idx);
void ast_vhub_del_dev(struct ast_vhub_dev *d);
void ast_vhub_dev_irq(struct ast_vhub_dev *d);
int ast_vhub_std_dev_request(struct ast_vhub_ep *ep,
                             struct usb_ctrlrequest *crq);

/* epn.c */
void ast_vhub_epn_ack_irq(struct ast_vhub_ep *ep);
void ast_vhub_update_epn_stall(struct ast_vhub_ep *ep);
struct ast_vhub_ep *ast_vhub_alloc_epn(struct ast_vhub_dev *d, u8 addr);
void ast_vhub_dev_suspend(struct ast_vhub_dev *d);
void ast_vhub_dev_resume(struct ast_vhub_dev *d);
void ast_vhub_dev_reset(struct ast_vhub_dev *d);

#endif /* __ASPEED_VHUB_H */