/* SPDX-License-Identifier: GPL-2.0 */
/**
 * xhci-dbgcap.h - xHCI debug capability support
 *
 * Copyright (C) 2017 Intel Corporation
 *
 * Author: Lu Baolu <baolu.lu@linux.intel.com>
 */
#ifndef __LINUX_XHCI_DBGCAP_H
#define __LINUX_XHCI_DBGCAP_H

#include <linux/tty.h>
#include <linux/kfifo.h>

struct dbc_regs {
        __le32  capability;
        __le32  doorbell;
        __le32  ersts;          /* Event Ring Segment Table Size*/
        __le32  __reserved_0;   /* 0c~0f reserved bits */
        __le64  erstba;         /* Event Ring Segment Table Base Address */
        __le64  erdp;           /* Event Ring Dequeue Pointer */
        __le32  control;
        __le32  status;
        __le32  portsc;         /* Port status and control */
        __le32  __reserved_1;   /* 2b~28 reserved bits */
        __le64  dccp;           /* Debug Capability Context Pointer */
        __le32  devinfo1;       /* Device Descriptor Info Register 1 */
        __le32  devinfo2;       /* Device Descriptor Info Register 2 */
};

struct dbc_info_context {
        __le64  string0;
        __le64  manufacturer;
        __le64  product;
        __le64  serial;
        __le32  length;
        __le32  __reserved_0[7];
};

#define DBC_CTRL_DBC_RUN                BIT(0)
#define DBC_CTRL_PORT_ENABLE            BIT(1)
#define DBC_CTRL_HALT_OUT_TR            BIT(2)
#define DBC_CTRL_HALT_IN_TR             BIT(3)
#define DBC_CTRL_DBC_RUN_CHANGE         BIT(4)
#define DBC_CTRL_DBC_ENABLE             BIT(31)
#define DBC_CTRL_MAXBURST(p)            (((p) >> 16) & 0xff)
#define DBC_DOOR_BELL_TARGET(p)         (((p) & 0xff) << 8)

#define DBC_MAX_PACKET                  1024
#define DBC_CONTEXT_SIZE                64

/*
 * Port status:
 */
#define DBC_PORTSC_CONN_STATUS          BIT(0)
#define DBC_PORTSC_PORT_ENABLED         BIT(1)
#define DBC_PORTSC_CONN_CHANGE          BIT(17)
#define DBC_PORTSC_RESET_CHANGE         BIT(21)
#define DBC_PORTSC_LINK_CHANGE          BIT(22)
#define DBC_PORTSC_CONFIG_CHANGE        BIT(23)

/*
 * The maximum length of a string descriptor is 255, because the bLength
 * field in the usb_string_descriptor struct is __u8.  In practice the
 * maximum length is 254, because a string descriptor consists of a 2 byte
 * header followed by UTF-16 characters (2 bytes each). This allows for
 * only 126 characters (code points) in the string, which is where
 * USB_MAX_STRING_LEN comes from.
 */
#define USB_MAX_STRING_DESC_LEN         254

struct dbc_str_descs {
        char    string0[USB_MAX_STRING_DESC_LEN];
        char    manufacturer[USB_MAX_STRING_DESC_LEN];
        char    product[USB_MAX_STRING_DESC_LEN];
        char    serial[USB_MAX_STRING_DESC_LEN];
};

/*
 * NULL terminated UTF-8 strings used to create UTF-16 strings
 * (with maxiumum USB_MAX_STRING_LEN 2 byte characters).
 */
struct dbc_str {
        char    manufacturer[USB_MAX_STRING_LEN+1];
        char    product[USB_MAX_STRING_LEN+1];
        char    serial[USB_MAX_STRING_LEN+1];
};

#define DBC_PROTOCOL                    1       /* GNU Remote Debug Command */
#define DBC_VENDOR_ID                   0x1d6b  /* Linux Foundation 0x1d6b */
#define DBC_PRODUCT_ID                  0x0010  /* device 0010 */
#define DBC_DEVICE_REV                  0x0010  /* 0.10 */

enum dbc_state {
        DS_DISABLED = 0,
        DS_INITIALIZED,
        DS_ENABLED,
        DS_CONNECTED,
        DS_CONFIGURED,
        DS_MAX
};

struct dbc_ep {
        struct xhci_dbc                 *dbc;
        struct list_head                list_pending;
        struct xhci_ring                *ring;
        unsigned int                    direction:1;
        unsigned int                    halted:1;
};

#define DBC_QUEUE_SIZE                  16
#define DBC_WRITE_BUF_SIZE              8192
#define DBC_POLL_INTERVAL_DEFAULT       64      /* milliseconds */
#define DBC_POLL_INTERVAL_MAX           5000    /* milliseconds */
#define DBC_XFER_INACTIVITY_TIMEOUT     10      /* milliseconds */
/*
 * Private structure for DbC hardware state:
 */
struct dbc_port {
        struct tty_port                 port;
        spinlock_t                      port_lock;      /* port access */
        int                             minor;

        struct list_head                read_pool;
        struct list_head                read_queue;
        unsigned int                    n_read;
        struct tasklet_struct           push;

        struct list_head                write_pool;
        unsigned int                    tx_boundary;

        bool                            registered;
        bool                            tx_running;
};

struct dbc_driver {
        int (*configure)(struct xhci_dbc *dbc);
        void (*disconnect)(struct xhci_dbc *dbc);
};

struct xhci_dbc {
        spinlock_t                      lock;           /* device access */
        struct device                   *dev;
        struct xhci_hcd                 *xhci;
        struct dbc_regs __iomem         *regs;
        struct xhci_ring                *ring_evt;
        struct xhci_ring                *ring_in;
        struct xhci_ring                *ring_out;
        struct xhci_erst                erst;
        struct xhci_container_ctx       *ctx;

        struct dbc_str_descs            *str_descs;
        dma_addr_t                      str_descs_dma;
        size_t                          str_descs_size;
        struct dbc_str                  str;
        u16                             idVendor;
        u16                             idProduct;
        u16                             bcdDevice;
        u8                              bInterfaceProtocol;

        enum dbc_state                  state;
        struct delayed_work             event_work;
        unsigned int                    poll_interval;  /* ms */
        unsigned long                   xfer_timestamp;
        unsigned                        resume_required:1;
        struct dbc_ep                   eps[2];

        const struct dbc_driver         *driver;
        void                            *priv;
};

struct dbc_request {
        void                            *buf;
        unsigned int                    length;
        dma_addr_t                      dma;
        void                            (*complete)(struct xhci_dbc *dbc,
                                                    struct dbc_request *req);
        struct list_head                list_pool;
        int                             status;
        unsigned int                    actual;

        struct xhci_dbc                 *dbc;
        struct list_head                list_pending;
        dma_addr_t                      trb_dma;
        union xhci_trb                  *trb;
        unsigned                        direction:1;
};

#define dbc_bulkout_ctx(d)              \
        ((struct xhci_ep_ctx *)((d)->ctx->bytes + DBC_CONTEXT_SIZE))
#define dbc_bulkin_ctx(d)               \
        ((struct xhci_ep_ctx *)((d)->ctx->bytes + DBC_CONTEXT_SIZE * 2))
#define dbc_bulkout_enq(d)              \
        xhci_trb_virt_to_dma((d)->ring_out->enq_seg, (d)->ring_out->enqueue)
#define dbc_bulkin_enq(d)               \
        xhci_trb_virt_to_dma((d)->ring_in->enq_seg, (d)->ring_in->enqueue)
#define dbc_epctx_info2(t, p, b)        \
        cpu_to_le32(EP_TYPE(t) | MAX_PACKET(p) | MAX_BURST(b))
#define dbc_ep_dma_direction(d)         \
        ((d)->direction ? DMA_FROM_DEVICE : DMA_TO_DEVICE)

#define BULK_OUT                        0
#define BULK_IN                         1
#define EPID_OUT                        2
#define EPID_IN                         3

enum evtreturn {
        EVT_ERR = -1,
        EVT_DONE,
        EVT_XFER_DONE,
        EVT_GSER,
        EVT_DISC,
};

static inline struct dbc_ep *get_in_ep(struct xhci_dbc *dbc)
{
        return &dbc->eps[BULK_IN];
}

static inline struct dbc_ep *get_out_ep(struct xhci_dbc *dbc)
{
        return &dbc->eps[BULK_OUT];
}

#ifdef CONFIG_USB_XHCI_DBGCAP
int xhci_create_dbc_dev(struct xhci_hcd *xhci);
void xhci_remove_dbc_dev(struct xhci_hcd *xhci);
int xhci_dbc_init(void);
void xhci_dbc_exit(void);
int dbc_tty_init(void);
void dbc_tty_exit(void);
int xhci_dbc_tty_probe(struct device *dev, void __iomem *res, struct xhci_hcd *xhci);
void xhci_dbc_tty_remove(struct xhci_dbc *dbc);
struct xhci_dbc *xhci_alloc_dbc(struct device *dev, void __iomem *res,
                                 const struct dbc_driver *driver);
void xhci_dbc_remove(struct xhci_dbc *dbc);
struct dbc_request *dbc_alloc_request(struct xhci_dbc *dbc,
                                      unsigned int direction,
                                      gfp_t flags);
void dbc_free_request(struct dbc_request *req);
int dbc_ep_queue(struct dbc_request *req);
#ifdef CONFIG_PM
int xhci_dbc_suspend(struct xhci_hcd *xhci);
int xhci_dbc_resume(struct xhci_hcd *xhci);
#endif /* CONFIG_PM */
#else
static inline int xhci_create_dbc_dev(struct xhci_hcd *xhci)
{
        return 0;
}

static inline void xhci_remove_dbc_dev(struct xhci_hcd *xhci)
{
}
static inline int xhci_dbc_init(void)
{
        return 0;
}
static inline void xhci_dbc_exit(void)
{
}
static inline int xhci_dbc_suspend(struct xhci_hcd *xhci)
{
        return 0;
}

static inline int xhci_dbc_resume(struct xhci_hcd *xhci)
{
        return 0;
}
#endif /* CONFIG_USB_XHCI_DBGCAP */
#endif /* __LINUX_XHCI_DBGCAP_H */