usb.c

// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
/* Copyright(c) 2018-2019  Realtek Corporation
 */

#include <linux/module.h>
#include <linux/usb.h>
#include <linux/mutex.h>
#include "debug.h"
#include "reg.h"
#include "fw.h"
#include "txrx.h"
#include "usb.h"

#define RTW_USB_CONTROL_MSG_TIMEOUT	30000 /* (us) */
#define RTW_USB_MSG_TIMEOUT	30000 /* (ms) */
#define RTW_USB_MAX_RXQ_LEN	128

struct rtw89_usb_txcb_t {
	struct rtw89_dev *rtwdev;
	struct sk_buff_head tx_ack_queue;
};

struct rtw89_usb_ctrlcb_t {
	atomic_t done;
	__u8 req_type;
	int status;
};

static void rtw_usb_read_port(struct rtw89_dev *rtwdev, u8 addr,
			      struct rx_usb_ctrl_block *rxcb);

/*
 * usb read/write register functions
 */

static void rtw_usb_ctrl_atomic_cb(struct urb *urb)
{
	struct rtw89_usb_ctrlcb_t *ctx;

	if (unlikely(!urb))
		return;

	ctx = (struct rtw89_usb_ctrlcb_t *)urb->context;
	if (likely(ctx)) {
		atomic_set(&ctx->done, 1);
		ctx->status = urb->status;
	}

	/* free dr */
	kfree(urb->setup_packet);
}

static int rtw_usb_ctrl_atomic(struct rtw89_dev *rtwdev,
			       struct usb_device *dev, unsigned int pipe,
			       __u8 req_type, __u16 value, __u16 index,
			       void *databuf, __u16 size)
{
	struct usb_ctrlrequest *dr = NULL;
	struct rtw89_usb_ctrlcb_t *ctx = NULL;
	struct urb *urb = NULL;
	bool done;
	int ret = -ENOMEM;

	ctx = kmalloc(sizeof(*ctx), GFP_ATOMIC);
	if (!ctx)
		goto out;

	dr = kmalloc(sizeof(*dr), GFP_ATOMIC);
	if (!dr)
		goto err_free_ctx;

	dr->bRequestType = req_type;
	dr->bRequest = RTW_USB_CMD_REQ;
	dr->wValue = cpu_to_le16(value);
	dr->wIndex = cpu_to_le16(index);
	dr->wLength = cpu_to_le16(size);

	urb = usb_alloc_urb(0, GFP_ATOMIC);
	if (!urb)
		goto err_free_dr;

	atomic_set(&ctx->done, 0);
	ctx->req_type = req_type;
	usb_fill_control_urb(urb, dev, pipe, (unsigned char *)dr, databuf, size,
			     rtw_usb_ctrl_atomic_cb, ctx);
	ret = usb_submit_urb(urb, GFP_ATOMIC);
	if (unlikely(ret)) {
		rtw89_err(rtwdev, "failed to submit urb, ret=%d\n", ret);
		goto err_free_urb;
	}

	done = false;
	read_poll_timeout_atomic(atomic_read, done, done, 100,
				 RTW_USB_CONTROL_MSG_TIMEOUT, false,
				 &ctx->done);
	if (!done) {
		usb_kill_urb(urb);
		rtw89_err(rtwdev, "failed to wait usb ctrl req:%u\n", req_type);
		ret = (ctx->status == -ENOENT ? -ETIMEDOUT : ctx->status);
	} else {
		ret = 0;
	}

	kfree(ctx);
	usb_free_urb(urb);
	return ret;

err_free_urb:
	usb_free_urb(urb);
err_free_dr:
	kfree(dr);
err_free_ctx:
	kfree(ctx);
out:
	return ret;
}

static u8 rtw_usb_read8_atomic(struct rtw89_dev *rtwdev, u32 addr)
{
	struct rtw89_usb *rtwusb = (struct rtw89_usb *)rtwdev->priv;
	struct usb_device *udev = rtwusb->udev;
	u8 *buf = NULL, data;

	buf = kmalloc(sizeof(*buf), GFP_ATOMIC);
	if (!buf)
		return 0;

	rtw_usb_ctrl_atomic(rtwdev, udev, usb_rcvctrlpipe(udev, 0),
			    RTW_USB_CMD_READ, addr, 0, buf, sizeof(*buf));
	data = *buf;
	kfree(buf);

	return data;
}

static u16 rtw_usb_read16_atomic(struct rtw89_dev *rtwdev, u32 addr)
{
	struct rtw89_usb *rtwusb = (struct rtw89_usb *)rtwdev->priv;
	struct usb_device *udev = rtwusb->udev;
	__le16 *buf = NULL;
	u16 data;

	buf = kmalloc(sizeof(*buf), GFP_ATOMIC);
	if (!buf)
		return 0;

	rtw_usb_ctrl_atomic(rtwdev, udev, usb_rcvctrlpipe(udev, 0),
			    RTW_USB_CMD_READ, addr, 0, buf, sizeof(*buf));
	data = *buf;
	kfree(buf);

	return data;
}

static u32 rtw_usb_read32_atomic(struct rtw89_dev *rtwdev, u32 addr)
{
	struct rtw89_usb *rtwusb = (struct rtw89_usb *)rtwdev->priv;
	struct usb_device *udev = rtwusb->udev;
	__le32 *buf;
	u32 data;

	buf = kmalloc(sizeof(*buf), GFP_ATOMIC);
	if (!buf)
		return 0;

	rtw_usb_ctrl_atomic(rtwdev, udev, usb_rcvctrlpipe(udev, 0),
			    RTW_USB_CMD_READ, addr, 0, buf, sizeof(*buf));
	data = *buf;
	kfree(buf);

	return data;
}

static void rtw_usb_write8_atomic(struct rtw89_dev *rtwdev, u32 addr, u8 val)
{
	struct rtw89_usb *rtwusb = (struct rtw89_usb *)rtwdev->priv;
	struct usb_device *udev = rtwusb->udev;
	u8 *buf;

	buf = kmalloc(sizeof(*buf), GFP_ATOMIC);
	if (!buf)
		return;

	*buf = val;
	rtw_usb_ctrl_atomic(rtwdev, udev, usb_sndctrlpipe(udev, 0),
			    RTW_USB_CMD_WRITE, addr, 0, buf, sizeof(*buf));
	kfree(buf);
}

static void rtw_usb_write16_atomic(struct rtw89_dev *rtwdev, u32 addr, u16 val)
{
	struct rtw89_usb *rtwusb = (struct rtw89_usb *)rtwdev->priv;
	struct usb_device *udev = rtwusb->udev;
	__le16 *buf;

	buf = kmalloc(sizeof(*buf), GFP_ATOMIC);
	if (!buf)
		return;

	*buf = cpu_to_le16(val);
	rtw_usb_ctrl_atomic(rtwdev, udev, usb_sndctrlpipe(udev, 0),
			    RTW_USB_CMD_WRITE, addr, 0, buf, sizeof(*buf));
	kfree(buf);
}

static void rtw_usb_write32_atomic(struct rtw89_dev *rtwdev, u32 addr, u32 val)
{
	struct rtw89_usb *rtwusb = (struct rtw89_usb *)rtwdev->priv;
	struct usb_device *udev = rtwusb->udev;
	__le32 *buf;

	buf = kmalloc(sizeof(*buf), GFP_ATOMIC);
	if (!buf)
		return;

	*buf = cpu_to_le32(val);
	rtw_usb_ctrl_atomic(rtwdev, udev, usb_sndctrlpipe(udev, 0),
			    RTW_USB_CMD_WRITE, addr, 0, buf, sizeof(*buf));
	kfree(buf);
}

static int rtw_usb_parse(struct rtw89_dev *rtwdev,
			 struct usb_interface *interface)
{
	struct rtw89_usb *rtwusb;
	struct usb_interface_descriptor *interface_desc;
	struct usb_host_interface *host_interface;
	struct usb_endpoint_descriptor *endpoint;
	struct device *dev;
	struct usb_device *usbd;
	int i, endpoints;
	u8 dir, xtype, num;
	int ret = 0;

	rtwusb = rtw_get_usb_priv(rtwdev);

	dev = &rtwusb->udev->dev;

	usbd = interface_to_usbdev(interface);
	host_interface = &interface->altsetting[0];
	interface_desc = &host_interface->desc;
	endpoints = interface_desc->bNumEndpoints;

	rtwusb->pipe_in = 0;
	rtwusb->num_in_pipes = 0;
	rtwusb->num_out_pipes = 0;
	for (i = 0; i < endpoints; i++) {
		endpoint = &host_interface->endpoint[i].desc;
		dir = endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK;
		num = usb_endpoint_num(endpoint);
		xtype = usb_endpoint_type(endpoint);
		rtw89_info(rtwdev, "\nusb endpoint descriptor (%i):\n", i);
		rtw89_info(rtwdev, "bLength=%x\n", endpoint->bLength);
		rtw89_info(rtwdev, "bDescriptorType=%x\n",
			 endpoint->bDescriptorType);
		rtw89_info(rtwdev, "bEndpointAddress=%x\n",
			 endpoint->bEndpointAddress);
		rtw89_info(rtwdev, "wMaxPacketSize=%d\n",
			 le16_to_cpu(endpoint->wMaxPacketSize));
		rtw89_info(rtwdev, "bInterval=%x\n", endpoint->bInterval);

		if (usb_endpoint_dir_in(endpoint) &&
		    usb_endpoint_xfer_bulk(endpoint)) {
			rtw89_info(rtwdev, "USB: dir in endpoint num %i\n", num);

			if (rtwusb->pipe_in) {
				rtw89_err(rtwdev,
					"failed to get many IN pipes\n");
				ret = -EINVAL;
				goto exit;
			}

			rtwusb->pipe_in = num;
			rtwusb->num_in_pipes++;
		}

		if (usb_endpoint_dir_in(endpoint) &&
		    usb_endpoint_xfer_int(endpoint)) {
			rtw89_info(rtwdev, "USB: interrupt endpoint num %i\n",
				 num);

			if (rtwusb->pipe_interrupt) {
				rtw89_err(rtwdev,
					"failed to get many INTERRUPT pipes\n");
				ret = -EINVAL;
				goto exit;
			}

			rtwusb->pipe_interrupt = num;
		}

		if (usb_endpoint_dir_out(endpoint) &&
		    usb_endpoint_xfer_bulk(endpoint)) {
			rtw89_info(rtwdev, "USB: out endpoint num %i\n", num);
			if (rtwusb->num_out_pipes >= 8) {
				rtw89_err(rtwdev,
					"failed to get many OUT pipes\n");
				ret = -EINVAL;
				goto exit;
			}

			/* for out enpoint, address == number */
			rtwusb->out_ep[rtwusb->num_out_pipes] = num;
			rtwusb->num_out_pipes++;
		}
	}

	switch (usbd->speed) {
	case USB_SPEED_LOW:
		rtw89_info(rtwdev, "USB_SPEED_LOW\n");
		rtwusb->usb_speed = RTW_USB_SPEED_1_1;
		break;
	case USB_SPEED_FULL:
		rtw89_info(rtwdev, "USB_SPEED_FULL\n");
		rtwusb->usb_speed = RTW_USB_SPEED_1_1;
		break;
	case USB_SPEED_HIGH:
		rtw89_info(rtwdev, "USB_SPEED_HIGH\n");
		rtwusb->usb_speed = RTW_USB_SPEED_2;
		break;
	case USB_SPEED_SUPER:
		rtw89_info(rtwdev, "USB_SPEED_SUPER\n");
		rtwusb->usb_speed = RTW_USB_SPEED_3;
		break;
	default:
		rtw89_err(rtwdev, "failed to get USB speed\n");
		break;
	}

exit:
	return ret;
}

static unsigned int rtw_usb_get_pipe(struct rtw89_dev *rtwdev, u8 addr, bool is_bulkout)
{
	struct rtw89_usb *rtwusb = rtw_get_usb_priv(rtwdev);
	struct usb_device *usbd = rtwusb->udev;
	unsigned int pipe = 0, ep_num = 0;

	if (!is_bulkout) {
		pr_info("%s pipe_in : 0x%x\n", __func__, rtwusb->pipe_in);
		pipe = usb_rcvbulkpipe(usbd, rtwusb->pipe_in);
	} else if (addr < RTW89_BULKOUT_NUM) {
		pipe = usb_sndbulkpipe(usbd, rtwusb->out_ep[addr]);
	} else {
		rtw89_err(rtwdev, "failed to get pipe, addr error: %d\n", addr);
	}

	return pipe;
}

static void rtw_usb_write_port_complete(struct urb *urb)
{
	struct sk_buff *skb;

	skb = (struct sk_buff *)urb->context;
	dev_kfree_skb_any(skb);
}

static int rtw_usb_write_port(struct rtw89_dev *rtwdev, u8 addr, u32 cnt,
			      struct sk_buff *skb,
			      usb_complete_t cb, void *context)
{
	struct rtw89_usb *rtwusb = rtw_get_usb_priv(rtwdev);
	struct usb_device *usbd = rtwusb->udev;
	struct urb *urb;
	unsigned int pipe;
	bool is_bulkout = true;
	int ret;

	pipe = rtw_usb_get_pipe(rtwdev, addr, is_bulkout);
	urb = usb_alloc_urb(0, GFP_ATOMIC);
	if (!urb)
		return -ENOMEM;

	usb_fill_bulk_urb(urb, usbd, pipe, skb->data, (int)cnt,
			  cb, context);
	urb->transfer_flags |= URB_ZERO_PACKET;
	ret = usb_submit_urb(urb, GFP_ATOMIC);
	if (unlikely(ret))
		rtw89_err(rtwdev, "failed to submit write urb, ret=%d\n", ret);
	usb_free_urb(urb);

	return ret;
}

/*
 * driver status relative functions
 */
static
bool rtw_usb_is_bus_ready(struct rtw89_dev *rtwdev)
{
	struct rtw89_usb *rtwusb = rtw_get_usb_priv(rtwdev);

	return (atomic_read(&rtwusb->is_bus_drv_ready) == true);
}

static
void rtw_usb_set_bus_ready(struct rtw89_dev *rtwdev, bool ready)
{
	struct rtw89_usb *rtwusb = rtw_get_usb_priv(rtwdev);

	atomic_set(&rtwusb->is_bus_drv_ready, ready);
}

static void rtw_usb_tx_queue_init(struct rtw89_usb *rtwusb)
{
	int i;

	for (i = 0; i < RTW89_BULKOUT_NUM; i++)
		skb_queue_head_init(&rtwusb->tx_queue[i]);
}

static void rtw_usb_tx_queue_purge(struct rtw89_usb *rtwusb)
{
	int i;

	for (i = 0; i < RTW89_BULKOUT_NUM; i++)
		skb_queue_purge(&rtwusb->tx_queue[i]);
}

static void rtw_usb_rx_queue_purge(struct rtw89_usb *rtwusb)
{
	skb_queue_purge(&rtwusb->rx_queue);
}

static int rtw89_usb_tx_write(struct rtw89_dev *rtwdev, struct rtw89_core_tx_request *tx_req,
			      u8 txch)
{
	struct rtw89_usb *rtwusb = rtw_get_usb_priv(rtwdev);
	const struct rtw89_chip_info *chip = rtwdev->chip;
	struct rtw89_tx_desc_info *desc_info = &tx_req->desc_info;
	struct rtw89_txwd_body *txwd_body;
	struct sk_buff *skb = tx_req->skb;
	u8 bulkout_id;
	int ret;

	if ((txch == RTW89_TXCH_CH12 ||
	     tx_req->tx_type == RTW89_CORE_TX_TYPE_FWCMD) &&
	    (txch != RTW89_TXCH_CH12 ||
	     tx_req->tx_type != RTW89_CORE_TX_TYPE_FWCMD)) {
		rtw89_err(rtwdev, "only fw cmd uses dma channel 12\n");
		return -EINVAL;
	}

	txwd_body = (struct rtw89_txwd_body *)skb_push(skb, sizeof(*txwd_body));
	memset(txwd_body, 0, sizeof(*txwd_body));
	rtw89_core_fill_txdesc(rtwdev, desc_info, txwd_body);

	bulkout_id = chip->ops->get_bulkout_id(rtwdev, txch);
	if (txch == RTW89_TXCH_CH12 ||
	    tx_req->tx_type == RTW89_CORE_TX_TYPE_FWCMD) {
		ret = rtw_usb_write_port(rtwdev, bulkout_id, skb->len, skb,
					 rtw_usb_write_port_complete, skb);

		if (unlikely(ret))
			rtw89_err(rtwdev, "failed to do USB write, ret=%d\n", ret);
	} else {
		skb_queue_tail(&rtwusb->tx_queue[bulkout_id], skb);
	}

	return 0;
}

static void rtw_usb_read_port_complete(struct urb *urb)
{
	struct rx_usb_ctrl_block *rxcb = urb->context;
	struct rtw89_dev *rtwdev = (struct rtw89_dev *)rxcb->data;
	struct rtw89_usb *rtwusb = (struct rtw89_usb *)rtwdev->priv;
	struct sk_buff *skb = rxcb->rx_skb;

	rxcb->rx_urb = NULL;

	if (urb->status == 0) {
		if (urb->actual_length >= RTW_USB_MAX_RECVBUF_SZ ||
		    urb->actual_length < 24) {
			rtw89_err(rtwdev, "failed to get urb length: %d\n",
				  urb->actual_length);
			if (skb)
				dev_kfree_skb_any(skb);
		} else {
			print_hex_dump(KERN_INFO, "read_port: ", DUMP_PREFIX_OFFSET, 16, 1,
				       skb->data, skb->len, 1);
#if 0 //NEO
			skb_queue_tail(&rtwusb->rx_queue, skb);
			queue_work(rtwusb->rxwq,
				   &rtwusb->rx_handler_data->work);
#endif //NEO
		}

		rtw_usb_read_port(rtwdev, RTW_USB_BULK_IN_ADDR, rxcb);
	} else {
		switch (urb->status) {
		case -EINVAL:
		case -EPIPE:
		case -ENODEV:
		case -ESHUTDOWN:
		case -ENOENT:
		     /* USB HW may not be available, e.g. unplugged */
		     rtw_usb_set_bus_ready(rtwdev, false);
		     break;
		case -EPROTO:
		case -EILSEQ:
		case -ETIME:
		case -ECOMM:
		case -EOVERFLOW:
		     rtw89_err(rtwdev, "failed to read at USB, SW\n");
		     break;
		case -EINPROGRESS:
		     rtw89_err(rtwdev, "failed to read at USB, in process\n");
		     break;
		default:
		     rtw89_err(rtwdev, "failed to read at USB, unknown: %d\n",
			       urb->status);
		     break;
		}
		if (skb)
		     dev_kfree_skb_any(skb);
	}
}

static void rtw_usb_read_port(struct rtw89_dev *rtwdev, u8 addr,
			      struct rx_usb_ctrl_block *rxcb)
{
	struct urb *urb = NULL;
	struct rtw89_usb *rtwusb = rtw_get_usb_priv(rtwdev);
	struct usb_device *usbd = rtwusb->udev;
	struct sk_buff *skb;
	unsigned int pipe;
	size_t alignment;
	bool is_bulkout = false;
	u32 len;
	int ret;

	urb = usb_alloc_urb(0, GFP_ATOMIC);
	if (!urb)
		return;

	rxcb->data = (void *)rtwdev;
	pipe = rtw_usb_get_pipe(rtwdev, addr, is_bulkout);
	len = RTW_USB_MAX_RECVBUF_SZ;
	skb = dev_alloc_skb(len);
	if (!skb) {
		usb_free_urb(urb);
		return;
	}

	urb->transfer_buffer = skb->data;
	rxcb->rx_urb = urb;
	rxcb->rx_skb = skb;
	usb_fill_bulk_urb(urb, usbd, pipe,
			  urb->transfer_buffer,
			  RTW_USB_MAX_RECVBUF_SZ,
			  rtw_usb_read_port_complete,
			  rxcb);
	ret = usb_submit_urb(urb, GFP_ATOMIC);
	if (ret)
		rtw89_err(rtwdev, "failed to submit USB urb, ret=%d\n", ret);

	usb_free_urb(urb);
}

static void rtw_usb_inirp_init(struct rtw89_dev *rtwdev)
{
	struct rtw89_usb *rtwusb = rtw_get_usb_priv(rtwdev);
	struct rx_usb_ctrl_block *rxcb;
	int i;

	if (rtw_usb_is_bus_ready(rtwdev)) {
		rtw89_err(rtwdev, "fail to do USB inirp init, bus is set\n");
		return;
	}

	for (i = 0; i < RTW_USB_RXCB_NUM; i++) {
		rxcb = &rtwusb->rx_cb[i];
		rxcb->rx_urb = NULL;
	}

	for (i = 0; i < RTW_USB_RXCB_NUM; i++) {
		rxcb = &rtwusb->rx_cb[i];
		rtw_usb_read_port(rtwdev, RTW_USB_BULK_IN_ADDR, rxcb);
	}

	rtw_usb_set_bus_ready(rtwdev, true);
}

static void rtw_usb_inirp_deinit(struct rtw89_dev *rtwdev)
{
	struct rtw89_usb *rtwusb = rtw_get_usb_priv(rtwdev);
	struct rx_usb_ctrl_block *rxcb;
	int i;

	rtw_usb_set_bus_ready(rtwdev, false);

	for (i = 0; i < RTW_USB_RXCB_NUM; i++) {
		rxcb = &rtwusb->rx_cb[i];
		if (rxcb->rx_urb) {
			usb_kill_urb(rxcb->rx_urb);
			usb_free_urb(rxcb->rx_urb);
		}
	}
}

static int rtw89_usb_ops_tx_write(struct rtw89_dev *rtwdev, struct rtw89_core_tx_request *tx_req)
{
	struct rtw89_tx_desc_info *desc_info = &tx_req->desc_info;
	int ret;

	ret = rtw89_usb_tx_write(rtwdev, tx_req, desc_info->ch_dma);
	if (ret) {
		rtw89_err(rtwdev, "failed to TX Queue %d\n", desc_info->ch_dma);
		return ret;
	}

	return 0;
}

static void rtw89_usb_ops_tx_kick_off(struct rtw89_dev *rtwdev, u8 txch)
{
	//pr_info("%s NEO TODO\n", __func__);
}

static void rtw89_usb_ops_flush_queues(struct rtw89_dev *rtwdev, u32 queues, bool drop)
{
	pr_info("%s NEO TODO\n", __func__);
}

static void rtw89_usb_ops_reset(struct rtw89_dev *rtwdev)
{
	pr_info("%s NEO TODO\n", __func__);
}

static int rtw89_usb_ops_start(struct rtw89_dev *rtwdev)
{
	pr_info("%s \n", __func__);
	rtw_usb_inirp_init(rtwdev);
	return 0;
}

static void rtw89_usb_ops_stop(struct rtw89_dev *rtwdev)
{
	pr_info("%s \n", __func__);
	rtw_usb_inirp_deinit(rtwdev);
}

static void rtw89_usb_link_ps(struct rtw89_dev *rtwdev, bool enter)
{
	pr_info("%s NEO TODO\n", __func__);
}

static int rtw89_usb_ops_mac_pre_init(struct rtw89_dev *rtwdev)
{
	/* G6: usb_pre_init_8852a */
	u32 val;

	pr_info("%s NEO enter\n", __func__);

	rtw89_write32_set(rtwdev, R_AX_USB_HOST_REQUEST_2, B_AX_R_USBIO_MODE);
	rtw89_write32_clr(rtwdev, R_AX_HCI_FUNC_EN, B_AX_HCI_RXDMA_EN | B_AX_HCI_TXDMA_EN);
	rtw89_write32_set(rtwdev, R_AX_HCI_FUNC_EN, B_AX_HCI_RXDMA_EN | B_AX_HCI_TXDMA_EN);

	val = rtw89_read32(rtwdev, R_AX_USB_ENDPOINT_3);
	pr_info("%s USB endpoint : 0x%x\n", __func__, val);

	return 0;
}

#define USB2_BULKSIZE	0x1
#define NUMP 0x1
#define EP5 0x5
#define EP6 0x6
#define EP7 0x7
#define EP8 0x8
#define EP9 0x9
#define EP10 0xA
#define EP11 0xB
#define EP12 0xC
static int rtw89_usb_ops_mac_post_init(struct rtw89_dev *rtwdev)
{
	u32 val32;
	u8 val8;
	int ret = 0;

	val32 = rtw89_read32(rtwdev, R_AX_USB3_MAC_NPI_CONFIG_INTF_0);
	val32 &= ~B_AX_SSPHY_LFPS_FILTER;
	rtw89_write32(rtwdev, R_AX_USB3_MAC_NPI_CONFIG_INTF_0, val32);

	rtw89_write8(rtwdev, R_AX_RXDMA_SETTING, USB2_BULKSIZE);

	rtw89_write8_clr(rtwdev, R_AX_USB_ENDPOINT_0, 0xf);
	rtw89_write8_set(rtwdev, R_AX_USB_ENDPOINT_0, EP5);
	rtw89_write8(rtwdev, R_AX_USB_ENDPOINT_2 +1, NUMP);

	rtw89_write8_clr(rtwdev, R_AX_USB_ENDPOINT_0, 0xf);
	rtw89_write8_set(rtwdev, R_AX_USB_ENDPOINT_0, EP6);
	rtw89_write8(rtwdev, R_AX_USB_ENDPOINT_2 +1, NUMP);

	rtw89_write8_clr(rtwdev, R_AX_USB_ENDPOINT_0, 0xf);
	rtw89_write8_set(rtwdev, R_AX_USB_ENDPOINT_0, EP7);
	rtw89_write8(rtwdev, R_AX_USB_ENDPOINT_2 +1, NUMP);

	rtw89_write8_clr(rtwdev, R_AX_USB_ENDPOINT_0, 0xf);
	rtw89_write8_set(rtwdev, R_AX_USB_ENDPOINT_0, EP9);
	rtw89_write8(rtwdev, R_AX_USB_ENDPOINT_2 +1, NUMP);

	rtw89_write8_clr(rtwdev, R_AX_USB_ENDPOINT_0, 0xf);
	rtw89_write8_set(rtwdev, R_AX_USB_ENDPOINT_0, EP10);
	rtw89_write8(rtwdev, R_AX_USB_ENDPOINT_2 +1, NUMP);

	rtw89_write8_clr(rtwdev, R_AX_USB_ENDPOINT_0, 0xf);
	rtw89_write8_set(rtwdev, R_AX_USB_ENDPOINT_0, EP11);
	rtw89_write8(rtwdev, R_AX_USB_ENDPOINT_2 +1, NUMP);

	rtw89_write8_clr(rtwdev, R_AX_USB_ENDPOINT_0, 0xf);
	rtw89_write8_set(rtwdev, R_AX_USB_ENDPOINT_0, EP12);
	rtw89_write8(rtwdev, R_AX_USB_ENDPOINT_2 +1, NUMP);

	return ret;
}

static int rtw89_usb_ops_deinit(struct rtw89_dev *rtwdev)
{
	pr_info("%s NEO TODO\n", __func__);
	return 0;
}

static u32 rtw89_usb_check_and_reclaim_tx_resource(struct rtw89_dev *rtwdev, u8 txch)
{
	pr_info("%s NEO TODO\n", __func__);
	return 0;
}

static int rtw89_usb_ops_mac_lv1_recovery(struct rtw89_dev *rtwdev,
					  enum rtw89_lv1_rcvy_step step)
{
	pr_info("%s NEO TODO\n", __func__);
	return 0;
}

static void rtw89_usb_ops_dump_err_status(struct rtw89_dev *rtwdev)
{
	pr_info("%s NEO TODO\n", __func__);
}

static int rtw89_usb_napi_poll(struct napi_struct *napi, int budget)
{
	pr_info("%s NEO TODO\n", __func__);
	return 0;
}

static struct rtw89_hci_ops rtw89_usb_ops = {
	.tx_write = rtw89_usb_ops_tx_write,
	.tx_kick_off = rtw89_usb_ops_tx_kick_off,
	.flush_queues = rtw89_usb_ops_flush_queues,
	.reset = rtw89_usb_ops_reset,
	.start = rtw89_usb_ops_start,
	.stop = rtw89_usb_ops_stop,

	.read8 = rtw_usb_read8_atomic,
	.read16 = rtw_usb_read16_atomic,
	.read32 = rtw_usb_read32_atomic,
	.write8 = rtw_usb_write8_atomic,
	.write16 = rtw_usb_write16_atomic,
	.write32 = rtw_usb_write32_atomic,

	.mac_pre_init = rtw89_usb_ops_mac_pre_init,
	.mac_post_init = rtw89_usb_ops_mac_post_init,
	.deinit = rtw89_usb_ops_deinit,

	.check_and_reclaim_tx_resource = rtw89_usb_check_and_reclaim_tx_resource,
	.mac_lv1_rcvy = rtw89_usb_ops_mac_lv1_recovery,
	.dump_err_status = rtw89_usb_ops_dump_err_status,
	.napi_poll = rtw89_usb_napi_poll,
};

static void rtw_usb_rx_handler(struct work_struct *work)
{
	struct rtw89_usb_work_data *work_data = container_of(work,
						struct rtw89_usb_work_data,
						work);
	struct rtw89_dev *rtwdev = work_data->rtwdev;
	struct rtw89_usb *rtwusb = rtw_get_usb_priv(rtwdev);
	const struct rtw89_chip_info *chip = rtwdev->chip;
	//struct rtw_rx_pkt_stat pkt_stat;
	struct ieee80211_rx_status rx_status;
	struct sk_buff *skb;
	//u32 pkt_desc_sz = chip->rx_pkt_desc_sz;
	u32 pkt_offset;
	u8 *rx_desc;

	while ((skb = skb_dequeue(&rtwusb->rx_queue)) != NULL) {
		pr_info("%s skb=%p\n", __func__, skb);
#if 0 //NEO : mark off first
		rx_desc = skb->data;
		chip->ops->query_rx_desc(rtwdev, rx_desc, &pkt_stat,
					 &rx_status);
		pkt_offset = pkt_desc_sz + pkt_stat.drv_info_sz +
			     pkt_stat.shift;

		if (pkt_stat.is_c2h) {
			skb_put(skb, pkt_stat.pkt_len + pkt_offset);
			*((u32 *)skb->cb) = pkt_offset;
			rtw_fw_c2h_cmd_handle(rtwdev, skb);
			dev_kfree_skb(skb);
			continue;
		}

		if (skb_queue_len(&rtwusb->rx_queue) >= RTW_USB_MAX_RXQ_LEN) {
			rtw_err(rtwdev, "failed to get rx_queue, overflow\n");
			dev_kfree_skb(skb);
			continue;
		}

		skb_put(skb, pkt_stat.pkt_len);
		skb_reserve(skb, pkt_offset);

		memcpy(skb->cb, &rx_status, sizeof(rx_status));
		ieee80211_rx_irqsafe(rtwdev->hw, skb);
#endif //NEO
	}
}

static void rtw_usb_tx_handler(struct work_struct *work)
{
	struct rtw89_usb_work_data *work_data = container_of(work,
					struct rtw89_usb_work_data,
					work);
	struct rtw89_dev *rtwdev = work_data->rtwdev;
	struct rtw89_usb *rtwusb = rtw_get_usb_priv(rtwdev);
	struct sk_buff *skb;
	bool is_empty = true;
	int index;

	/* should use bucket share algorithm for each queue */
	index = RTW89_BULKOUT_NUM - 1;
	while (index >= 0) {
		skb = skb_dequeue(&rtwusb->tx_queue[index]);
		if (skb) {
			print_hex_dump(KERN_INFO, "tx: ", DUMP_PREFIX_OFFSET, 16, 1,
				       skb->data, skb->len, 1);

			is_empty = false;
		} else {
			index--;
		}

		if (index < 0 && !is_empty) {
			index = RTW89_BULKOUT_NUM - 1;
			is_empty = true;
		}
	}
}

static int rtw_usb_init_rx(struct rtw89_dev *rtwdev)
{
	struct rtw89_usb *rtwusb = rtw_get_usb_priv(rtwdev);

	rtwusb->rxwq = create_singlethread_workqueue("rtw89_usb: rx wq");
	if (!rtwusb->rxwq) {
		rtw89_err(rtwdev, "failed to create RX work queue\n");
		return -ENOMEM;
	}

	skb_queue_head_init(&rtwusb->rx_queue);
	rtwusb->rx_handler_data = kmalloc(sizeof(*rtwusb->rx_handler_data),
					  GFP_KERNEL);
	if (!rtwusb->rx_handler_data)
		goto err_destroy_wq;

	rtwusb->rx_handler_data->rtwdev = rtwdev;
	INIT_WORK(&rtwusb->rx_handler_data->work, rtw_usb_rx_handler);
	return 0;

err_destroy_wq:
	destroy_workqueue(rtwusb->rxwq);
	return -ENOMEM;
}

static void rtw_usb_deinit_rx(struct rtw89_dev *rtwdev)
{
	struct rtw89_usb *rtwusb = rtw_get_usb_priv(rtwdev);

	rtw_usb_rx_queue_purge(rtwusb);
	flush_workqueue(rtwusb->rxwq);
	destroy_workqueue(rtwusb->rxwq);
	kfree(rtwusb->rx_handler_data);
}

static int rtw_usb_init_tx(struct rtw89_dev *rtwdev)
{
	struct rtw89_usb *rtwusb = rtw_get_usb_priv(rtwdev);

	rtwusb->txwq = create_singlethread_workqueue("rtw89_usb: tx wq");
	if (!rtwusb->txwq) {
		rtw89_err(rtwdev, "failed to create TX work queue\n");
		return -ENOMEM;
	}

	rtw_usb_tx_queue_init(rtwusb);
	rtwusb->tx_handler_data = kmalloc(sizeof(*rtwusb->tx_handler_data),
					  GFP_KERNEL);
	if (!rtwusb->tx_handler_data)
		goto err_destroy_wq;

	rtwusb->tx_handler_data->rtwdev = rtwdev;
	INIT_WORK(&rtwusb->tx_handler_data->work, rtw_usb_tx_handler);
	return 0;

err_destroy_wq:
	destroy_workqueue(rtwusb->txwq);
	return -ENOMEM;
}

static void rtw_usb_deinit_tx(struct rtw89_dev *rtwdev)
{
	struct rtw89_usb *rtwusb = rtw_get_usb_priv(rtwdev);

	rtw_usb_tx_queue_purge(rtwusb);
	flush_workqueue(rtwusb->txwq);
	destroy_workqueue(rtwusb->txwq);
	kfree(rtwusb->tx_handler_data);
}

static void rtw_usb_interface_configure(struct rtw89_dev *rtwdev)
{
	struct rtw89_usb *rtwusb = rtw_get_usb_priv(rtwdev);

	if (RTW_USB_IS_SUPER_SPEED(rtwusb))
		rtwusb->bulkout_size = RTW_USB_SUPER_SPEED_BULK_SIZE;
	else if (RTW_USB_IS_HIGH_SPEED(rtwusb))
		rtwusb->bulkout_size = RTW_USB_HIGH_SPEED_BULK_SIZE;
	else
		rtwusb->bulkout_size = RTW_USB_FULL_SPEED_BULK_SIZE;
	rtw89_info(rtwdev, "USB: bulkout_size: %d\n", rtwusb->bulkout_size);
}

static int rtw_usb_intf_init(struct rtw89_dev *rtwdev,
			     struct usb_interface *intf)
{
	struct rtw89_usb *rtwusb = rtw_get_usb_priv(rtwdev);
	struct usb_device *udev = usb_get_dev(interface_to_usbdev(intf));
	int ret;

	rtwusb->udev = udev;
	rtwusb->rtwdev = rtwdev;
	ret = rtw_usb_parse(rtwdev, intf);
	if (ret) {
		rtw89_err(rtwdev, "failed to check USB configuration, ret=%d\n",
			ret);
		return ret;
	}

	usb_set_intfdata(intf, rtwdev->hw);
	rtw_usb_interface_configure(rtwdev);
	SET_IEEE80211_DEV(rtwdev->hw, &intf->dev);

	return 0;
}

static void rtw_usb_intf_deinit(struct rtw89_dev *rtwdev,
				struct usb_interface *intf)
{
	struct rtw89_usb *rtwusb = rtw_get_usb_priv(rtwdev);

	usb_put_dev(rtwusb->udev);
	usb_set_intfdata(intf, NULL);
}

static int rtw_usb_probe(struct usb_interface *intf,
			 const struct usb_device_id *id)
{
	struct ieee80211_hw *hw;
	struct rtw89_dev *rtwdev;
	int drv_data_size;
	int ret;

	drv_data_size = sizeof(struct rtw89_dev) + sizeof(struct rtw89_usb);
	hw = ieee80211_alloc_hw(drv_data_size, &rtw89_ops);
	if (!hw) {
		dev_err(&intf->dev, "failed to allocate hw\n");
		return -ENOMEM;
	}

	rtwdev = hw->priv;
	rtwdev->hw = hw;
	rtwdev->dev = &intf->dev;
	rtwdev->chip = (const struct rtw89_chip_info *)id->driver_info;
	rtwdev->hci.ops = &rtw89_usb_ops;
	rtwdev->hci.type = RTW89_HCI_TYPE_USB;
	rtwdev->hci.rpwm_addr = R_AX_USB_D2F_F2D_INFO + 2;

	ret = rtw89_core_init(rtwdev);
	if (ret) {
		rtw89_err(rtwdev, "failed to initialise core\n");
		goto err_release_hw;
	}

	ret = rtw_usb_intf_init(rtwdev, intf);
	if (ret) {
		rtw89_err(rtwdev, "failed to init USB interface\n");
		goto err_deinit_core;
	}

	ret = rtw_usb_init_tx(rtwdev);
	if (ret) {
		rtw89_err(rtwdev, "failed to init USB TX\n");
		goto err_destroy_usb;
	}

	ret = rtw_usb_init_rx(rtwdev);
	if (ret) {
		rtw89_err(rtwdev, "failed to init USB RX\n");
		goto err_destroy_txwq;
	}

	ret = rtw89_chip_info_setup(rtwdev);
	if (ret) {
		rtw89_err(rtwdev, "failed to setup chip information\n");
		goto err_destroy_rxwq;
	}

	ret = rtw89_core_register(rtwdev);
	if (ret) {
		rtw89_err(rtwdev, "failed to register core\n");
		goto err_destroy_rxwq;
	}

	return 0;

err_destroy_rxwq:
	rtw_usb_deinit_rx(rtwdev);

err_destroy_txwq:
	rtw_usb_deinit_tx(rtwdev);

err_destroy_usb:
	rtw_usb_intf_deinit(rtwdev, intf);

err_deinit_core:
	rtw89_core_deinit(rtwdev);

err_release_hw:
	ieee80211_free_hw(hw);

	return ret;
}

static void rtw_usb_disconnect(struct usb_interface *intf)
{
	struct ieee80211_hw *hw = usb_get_intfdata(intf);
	struct rtw89_dev *rtwdev;
	struct rtw89_usb *rtwusb;

	if (!hw)
		return;

	rtwdev = hw->priv;
	rtwusb = rtw_get_usb_priv(rtwdev);

	rtw89_core_unregister(rtwdev);
	rtw_usb_deinit_rx(rtwdev);
	rtw_usb_deinit_tx(rtwdev);

	if (rtwusb->udev->state != USB_STATE_NOTATTACHED)
		usb_reset_device(rtwusb->udev);

	rtw_usb_intf_deinit(rtwdev, intf);
	rtw89_core_deinit(rtwdev);
	ieee80211_free_hw(hw);
}

static const struct usb_device_id rtw_usb_id_table[] = {
	{ RTK_USB_DEVICE(RTW_USB_VENDOR_ID_REALTEK,
			 0x885a, rtw8852a_chip_info) },
	{},
};
MODULE_DEVICE_TABLE(usb, rtw_usb_id_table);

static struct usb_driver rtw_usb_driver = {
	.name = "rtwifi_usb",
	.id_table = rtw_usb_id_table,
	.probe = rtw_usb_probe,
	.disconnect = rtw_usb_disconnect,
};

module_usb_driver(rtw_usb_driver);

MODULE_AUTHOR("Realtek Corporation");
MODULE_DESCRIPTION("Realtek 802.11ax wireless USB driver");
MODULE_LICENSE("Dual BSD/GPL");