usb: Add MediaTek USB3 DRD driver

endif

source "drivers/usb/mtu3/Kconfig"

source "drivers/usb/musb/Kconfig"

source "drivers/usb/dwc3/Kconfig"

obj-$(CONFIG_USB_ISP1760)	+= isp1760/

obj-$(CONFIG_USB_MON)		+= mon/

obj-$(CONFIG_USB_MTU3)		+= mtu3/

obj-$(CONFIG_PCI)		+= host/

obj-$(CONFIG_USB_EHCI_HCD)	+= host/

# For MTK USB3.0 IP

config USB_MTU3

	tristate "MediaTek USB3 Dual Role controller"

	depends on (USB || USB_GADGET) && HAS_DMA

	depends on ARCH_MEDIATEK || COMPILE_TEST

	help

	  Say Y or M here if your system runs on MediaTek SoCs with

	  Dual Role SuperSpeed USB controller. You can select usb

	  mode as peripheral role or host role, or both.

	  If you don't know what this is, please say N.

	  Choose M here to compile this driver as a module, and it

	  will be called mtu3.ko.

if USB_MTU3

choice

	bool "MTU3 Mode Selection"

	default USB_MTU3_GADGET if (!USB && USB_GADGET)

config USB_MTU3_GADGET

	bool "Gadget only mode"

	depends on USB_GADGET=y || USB_GADGET=USB_MTU3

	help

	  Select this when you want to use MTU3 in gadget mode only,

	  thereby the host feature will be regressed.

endchoice

endif

obj-$(CONFIG_USB_MTU3)	+= mtu3.o

mtu3-y	:= mtu3_plat.o mtu3_core.o mtu3_gadget_ep0.o mtu3_gadget.o mtu3_qmu.o

/*

 * mtu3.h - MediaTek USB3 DRD header

 *

 * Copyright (C) 2016 MediaTek Inc.

 *

 * Author: Chunfeng Yun <chunfeng.yun@mediatek.com>

 *

 * This software is licensed under the terms of the GNU General Public

 * License version 2, as published by the Free Software Foundation, and

 * may be copied, distributed, and modified under those terms.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 */

#ifndef __MTU3_H__

#define __MTU3_H__

#include <linux/device.h>

#include <linux/dmapool.h>

#include <linux/interrupt.h>

#include <linux/list.h>

#include <linux/phy/phy.h>

#include <linux/regulator/consumer.h>

#include <linux/usb.h>

#include <linux/usb/ch9.h>

#include <linux/usb/gadget.h>

#include <linux/usb/otg.h>

struct mtu3;

struct mtu3_ep;

struct mtu3_request;

#include "mtu3_hw_regs.h"

#include "mtu3_qmu.h"

#define	MU3D_EP_TXCR0(epnum)	(U3D_TX1CSR0 + (((epnum) - 1) * 0x10))

#define	MU3D_EP_TXCR1(epnum)	(U3D_TX1CSR1 + (((epnum) - 1) * 0x10))

#define	MU3D_EP_TXCR2(epnum)	(U3D_TX1CSR2 + (((epnum) - 1) * 0x10))

#define	MU3D_EP_RXCR0(epnum)	(U3D_RX1CSR0 + (((epnum) - 1) * 0x10))

#define	MU3D_EP_RXCR1(epnum)	(U3D_RX1CSR1 + (((epnum) - 1) * 0x10))

#define	MU3D_EP_RXCR2(epnum)	(U3D_RX1CSR2 + (((epnum) - 1) * 0x10))

#define USB_QMU_RQCSR(epnum)	(U3D_RXQCSR1 + (((epnum) - 1) * 0x10))

#define USB_QMU_RQSAR(epnum)	(U3D_RXQSAR1 + (((epnum) - 1) * 0x10))

#define USB_QMU_RQCPR(epnum)	(U3D_RXQCPR1 + (((epnum) - 1) * 0x10))

#define USB_QMU_TQCSR(epnum)	(U3D_TXQCSR1 + (((epnum) - 1) * 0x10))

#define USB_QMU_TQSAR(epnum)	(U3D_TXQSAR1 + (((epnum) - 1) * 0x10))

#define USB_QMU_TQCPR(epnum)	(U3D_TXQCPR1 + (((epnum) - 1) * 0x10))

#define SSUSB_U2_CTRL(p)	(U3D_SSUSB_U2_CTRL_0P + ((p) * 0x08))

#define MTU3_DRIVER_NAME	"mtu3"

#define	DMA_ADDR_INVALID	(~(dma_addr_t)0)

#define MTU3_EP_ENABLED		BIT(0)

#define MTU3_EP_STALL		BIT(1)

#define MTU3_EP_WEDGE		BIT(2)

#define MTU3_EP_BUSY		BIT(3)

#define MTU3_U2_IP_SLOT_DEFAULT 1

/**

 * Normally the device works on HS or SS, to simplify fifo management,

 * devide fifo into some 512B parts, use bitmap to manage it; And

 * 128 bits size of bitmap is large enough, that means it can manage

 * up to 64KB fifo size.

 * NOTE: MTU3_EP_FIFO_UNIT should be power of two

 */

#define MTU3_EP_FIFO_UNIT		(1 << 9)

#define MTU3_FIFO_BIT_SIZE		128

#define MTU3_U2_IP_EP0_FIFO_SIZE	64

/**

 * Maximum size of ep0 response buffer for ch9 requests,

 * the SET_SEL request uses 6 so far, and GET_STATUS is 2

 */

#define EP0_RESPONSE_BUF  6

/* device operated link and speed got from DEVICE_CONF register */

enum mtu3_speed {

	MTU3_SPEED_INACTIVE = 0,

	MTU3_SPEED_FULL = 1,

	MTU3_SPEED_HIGH = 3,

};

/**

 * @MU3D_EP0_STATE_SETUP: waits for SETUP or received a SETUP

 *		without data stage.

 * @MU3D_EP0_STATE_TX: IN data stage

 * @MU3D_EP0_STATE_RX: OUT data stage

 * @MU3D_EP0_STATE_TX_END: the last IN data is transferred, and

 *		waits for its completion interrupt

 * @MU3D_EP0_STATE_STALL: ep0 is in stall status, will be auto-cleared

 *		after receives a SETUP.

 */

enum mtu3_g_ep0_state {

	MU3D_EP0_STATE_SETUP = 1,

	MU3D_EP0_STATE_TX,

	MU3D_EP0_STATE_RX,

	MU3D_EP0_STATE_TX_END,

	MU3D_EP0_STATE_STALL,

};

/**

 * @base: the base address of fifo

 * @limit: the bitmap size in bits

 * @bitmap: fifo bitmap in unit of @MTU3_EP_FIFO_UNIT

 */

struct mtu3_fifo_info {

	u32 base;

	u32 limit;

	DECLARE_BITMAP(bitmap, MTU3_FIFO_BIT_SIZE);

};

/**

 * General Purpose Descriptor (GPD):

 *	The format of TX GPD is a little different from RX one.

 *	And the size of GPD is 16 bytes.

 *

 * @flag:

 *	bit0: Hardware Own (HWO)

 *	bit1: Buffer Descriptor Present (BDP), always 0, BD is not supported

 *	bit2: Bypass (BPS), 1: HW skips this GPD if HWO = 1

 *	bit7: Interrupt On Completion (IOC)

 * @chksum: This is used to validate the contents of this GPD;

 *	If TXQ_CS_EN / RXQ_CS_EN bit is set, an interrupt is issued

 *	when checksum validation fails;

 *	Checksum value is calculated over the 16 bytes of the GPD by default;

 * @data_buf_len (RX ONLY): This value indicates the length of

 *	the assigned data buffer

 * @next_gpd: Physical address of the next GPD

 * @buffer: Physical address of the data buffer

 * @buf_len:

 *	(TX): This value indicates the length of the assigned data buffer

 *	(RX): The total length of data received

 * @ext_len: reserved

 * @ext_flag:

 *	bit5 (TX ONLY): Zero Length Packet (ZLP),

 */

struct qmu_gpd {

	__u8 flag;

	__u8 chksum;

	__le16 data_buf_len;

	__le32 next_gpd;

	__le32 buffer;

	__le16 buf_len;

	__u8 ext_len;

	__u8 ext_flag;

} __packed;

/**

* dma: physical base address of GPD segment

* start: virtual base address of GPD segment

* end: the last GPD element

* enqueue: the first empty GPD to use

* dequeue: the first completed GPD serviced by ISR

* NOTE: the size of GPD ring should be >= 2

*/

struct mtu3_gpd_ring {

	dma_addr_t dma;

	struct qmu_gpd *start;

	struct qmu_gpd *end;

	struct qmu_gpd *enqueue;

	struct qmu_gpd *dequeue;

};

/**

 * @fifo_size: it is (@slot + 1) * @fifo_seg_size

 * @fifo_seg_size: it is roundup_pow_of_two(@maxp)

 */

struct mtu3_ep {

	struct usb_ep ep;

	char name[12];

	struct mtu3 *mtu;

	u8 epnum;

	u8 type;

	u8 is_in;

	u16 maxp;

	int slot;

	u32 fifo_size;

	u32 fifo_addr;

	u32 fifo_seg_size;

	struct mtu3_fifo_info *fifo;

	struct list_head req_list;

	struct mtu3_gpd_ring gpd_ring;

	const struct usb_endpoint_descriptor *desc;

	int flags;

	u8 wedged;

	u8 busy;

};

struct mtu3_request {

	struct usb_request request;

	struct list_head list;

	struct mtu3_ep *mep;

	struct mtu3 *mtu;

	struct qmu_gpd *gpd;

	int epnum;

};

/**

 * struct mtu3 - device driver instance data.

 * @slot: MTU3_U2_IP_SLOT_DEFAULT for U2 IP

 * @may_wakeup: means device's remote wakeup is enabled

 * @is_self_powered: is reported in device status and the config descriptor

 * @ep0_req: dummy request used while handling standard USB requests

 *		for GET_STATUS and SET_SEL

 * @setup_buf: ep0 response buffer for GET_STATUS and SET_SEL requests

 */

struct mtu3 {

	spinlock_t lock;

	struct device *dev;

	void __iomem *mac_base;

	void __iomem *ippc_base;

	struct phy *phy;

	struct regulator *vusb33;

	struct clk *sys_clk;

	int irq;

	struct mtu3_fifo_info tx_fifo;

	struct mtu3_fifo_info rx_fifo;

	struct mtu3_ep *ep_array;

	struct mtu3_ep *in_eps;

	struct mtu3_ep *out_eps;

	struct mtu3_ep *ep0;

	int num_eps;

	int slot;

	int active_ep;

	struct dma_pool	*qmu_gpd_pool;

	enum mtu3_g_ep0_state ep0_state;

	struct usb_gadget g;	/* the gadget */

	struct usb_gadget_driver *gadget_driver;

	struct mtu3_request ep0_req;

	u8 setup_buf[EP0_RESPONSE_BUF];

	unsigned is_active:1;

	unsigned may_wakeup:1;

	unsigned is_self_powered:1;

	unsigned test_mode:1;

	unsigned softconnect:1;

	u8 address;

	u8 test_mode_nr;

	u32 hw_version;

};

static inline struct mtu3 *gadget_to_mtu3(struct usb_gadget *g)

{

	return container_of(g, struct mtu3, g);

}

static inline int is_first_entry(const struct list_head *list,

	const struct list_head *head)

{

	return list_is_last(head, list);

}

static inline struct mtu3_request *to_mtu3_request(struct usb_request *req)

{

	return req ? container_of(req, struct mtu3_request, request) : NULL;

}

static inline struct mtu3_ep *to_mtu3_ep(struct usb_ep *ep)

{

	return ep ? container_of(ep, struct mtu3_ep, ep) : NULL;

}

static inline struct mtu3_request *next_request(struct mtu3_ep *mep)

{

	struct list_head *queue = &mep->req_list;

	if (list_empty(queue))

		return NULL;

	return list_first_entry(queue, struct mtu3_request, list);

}

static inline void mtu3_writel(void __iomem *base, u32 offset, u32 data)

{

	writel(data, base + offset);

}

static inline u32 mtu3_readl(void __iomem *base, u32 offset)

{

	return readl(base + offset);

}

static inline void mtu3_setbits(void __iomem *base, u32 offset, u32 bits)

{

	void __iomem *addr = base + offset;

	u32 tmp = readl(addr);

	writel((tmp | (bits)), addr);

}

static inline void mtu3_clrbits(void __iomem *base, u32 offset, u32 bits)

{

	void __iomem *addr = base + offset;

	u32 tmp = readl(addr);

	writel((tmp & ~(bits)), addr);

}

int ssusb_check_clocks(struct mtu3 *mtu, u32 ex_clks);

struct usb_request *mtu3_alloc_request(struct usb_ep *ep, gfp_t gfp_flags);

void mtu3_free_request(struct usb_ep *ep, struct usb_request *req);

void mtu3_req_complete(struct mtu3_ep *mep,

		struct usb_request *req, int status);

int mtu3_config_ep(struct mtu3 *mtu, struct mtu3_ep *mep,

		int interval, int burst, int mult);

void mtu3_deconfig_ep(struct mtu3 *mtu, struct mtu3_ep *mep);

void mtu3_ep_stall_set(struct mtu3_ep *mep, bool set);

void mtu3_ep0_setup(struct mtu3 *mtu);

void mtu3_start(struct mtu3 *mtu);

void mtu3_stop(struct mtu3 *mtu);

void mtu3_hs_softconn_set(struct mtu3 *mtu, bool enable);

int mtu3_gadget_setup(struct mtu3 *mtu);

void mtu3_gadget_cleanup(struct mtu3 *mtu);

void mtu3_gadget_reset(struct mtu3 *mtu);

void mtu3_gadget_suspend(struct mtu3 *mtu);

void mtu3_gadget_resume(struct mtu3 *mtu);

void mtu3_gadget_disconnect(struct mtu3 *mtu);

int ssusb_gadget_init(struct mtu3 *mtu);

void ssusb_gadget_exit(struct mtu3 *mtu);

irqreturn_t mtu3_ep0_isr(struct mtu3 *mtu);

extern const struct usb_ep_ops mtu3_ep0_ops;

#endif