/*
 * Copyright 2017, Data61
 * Commonwealth Scientific and Industrial Research Organisation (CSIRO)
 * ABN 41 687 119 230.
 *
 * This software may be distributed and modified according to the terms of
 * the BSD 2-Clause license. Note that NO WARRANTY is provided.
 * See "LICENSE_BSD2.txt" for details.
 *
 * @TAG(DATA61_BSD)
 */

/**
 * @brief Prolific PL2303 USB to Serial adaptor
 * @see http://www.prolific.com.tw/US/ShowProduct.aspx?p_id=232&pcid=41
 */
#include <stdio.h>
#include <string.h>

#include <usb/drivers/pl2303.h>
#include "../services.h"

#define PL2303_VENDOR_REQ  0x01
#define PL2303_READ_TYPE   (USB_DIR_IN | USB_TYPE_VEN | USB_RCPT_DEVICE)
#define PL2303_WRITE_TYPE  (USB_DIR_OUT | USB_TYPE_VEN | USB_RCPT_DEVICE)

#define PL2303_SET_LINE_REQ 0x20
#define PL2303_SET_CTRL_REQ 0x22
#define PL2303_SET_REQ_TYPE 0x21

#define PL2303_GET_LINE_REQ 0x21
#define PL2303_GET_REQ_TYEP 0xA1

#define PL2303_CTRL_DTR     0x01
#define PL2303_CTRL_RTS     0x01

/* PL2303 USB to Serial Converter */
struct pl2303_device {
	struct usb_dev *udev;	 //The handle to the underlying USB device
	uint8_t config;          //Active configuration
	struct endpoint *ep_int; //Interrupt endpoint
	struct endpoint *ep_in;	 //BULK in endpoint
	struct endpoint *ep_out; //BULK out endpoint
	struct xact int_xact;    //Interrupt xact
};

static int
pl2303_config_cb(void *token, int cfg, int iface, struct anon_desc *desc)
{
	struct pl2303_device *dev;
	struct config_desc *cdesc;

	if (!desc) {
		return 0;
	}

	dev = (struct pl2303_device*)token;

	switch (desc->bDescriptorType) {
	case CONFIGURATION:
		cdesc = (struct config_desc*)desc;
		dev->config = cdesc->bConfigurationValue;
		break;
	default:
		break;
	}

	return 0;
}

static int
pl2303_interrupt_cb(void* token, enum usb_xact_status stat, int rbytes)
{
	int err;
	struct pl2303_device *dev;
	struct usb_dev *udev;

	udev = (struct usb_dev*)token;
	dev = (struct pl2303_device*)udev->dev_data;

	/* Queue another request */
	err = usbdev_schedule_xact(udev, dev->ep_int, &dev->int_xact, 1,
			pl2303_interrupt_cb, udev);
	if (err) {
		ZF_LOGF("Transaction error\n");
	}

	return err;
}

static void
pl2303_startup_magic(struct usb_dev *udev)
{
	int err;
	struct xact xact[2];
	struct usbreq *req;

	if (!udev) {
		ZF_LOGF("Invalid device\n");
	}

	xact[0].len = sizeof(struct usbreq);
	xact[1].len = 1;
	err = usb_alloc_xact(udev->dman, xact, 2);
	if (err) {
		ZF_LOGF("Out of DMA memory\n");
	}

	/* Fill in the request */
	xact[0].type = PID_SETUP;
	xact[1].type = PID_IN;
	req = xact_get_vaddr(&xact[0]);

	/*
	 * Send Prolific private initial data.
	 *
	 * It is found by sniffing the official windows driver.
	 */
	req->bRequest = PL2303_VENDOR_REQ;

#define magic_request(typ, idx, val) \
	req->bmRequestType = typ; \
	req->wIndex = idx; \
	req->wValue = val; \
	req->wLength = (typ == PL2303_READ_TYPE) ? 1 : 0; \
	err = usbdev_schedule_xact(udev, udev->ep_ctrl, xact, \
			req->wLength + 1, NULL, NULL); \

	magic_request(PL2303_READ_TYPE, 0, 0x8484);
	magic_request(PL2303_WRITE_TYPE, 0, 0x0404);
	magic_request(PL2303_READ_TYPE, 0, 0x8484);
	magic_request(PL2303_READ_TYPE, 0, 0x8383);
	magic_request(PL2303_READ_TYPE, 0, 0x8484);
	magic_request(PL2303_WRITE_TYPE, 1, 0x0404);
	magic_request(PL2303_READ_TYPE, 0, 0x8484);
	magic_request(PL2303_READ_TYPE, 0, 0x8383);
	magic_request(PL2303_WRITE_TYPE, 1, 0);
	magic_request(PL2303_WRITE_TYPE, 0, 1);
	magic_request(PL2303_WRITE_TYPE, 0x44, 2);

	usb_destroy_xact(udev->dman, xact, 2);
}

int usb_pl2303_bind(usb_dev_t *udev)
{
	int err;
	struct pl2303_device *dev;
	struct xact xact;
	struct usbreq *req;

	if (!udev) {
		ZF_LOGF("Invalid device\n");
	}

	dev = usb_malloc(sizeof(struct pl2303_device));
	if (!dev) {
		ZF_LOGD("Not enough memory!\n");
		return -1;
	}

	dev->udev = udev;
	udev->dev_data = (struct udev_priv*)dev;

	/* Parse the descriptors */
	err = usbdev_parse_config(udev, pl2303_config_cb, dev);
	if (err) {
		ZF_LOGF("Invalid descriptors\n");
	}

	/* Find endpoints */
	for (int i = 0; udev->ep[i] != NULL; i++) {
		if (udev->ep[i]->type == EP_BULK) {
			if (udev->ep[i]->dir == EP_DIR_OUT) {
				dev->ep_out = udev->ep[i];
			} else {
				dev->ep_in = udev->ep[i];
			}
		} else if (udev->ep[i]->type == EP_INTERRUPT) {
			dev->ep_int = udev->ep[i];
		} else {
			continue;
		}
	}

	if (udev->vend_id != 0x067b || udev->prod_id != 0x2303) {
		ZF_LOGD("Not a PL2303 device(%u:%u)\n",
				udev->vend_id, udev->prod_id);
		return -1;
	}

	ZF_LOGD("Found PL2303 USB to serial converter!\n");

	/* Activate configuration */
	xact.len = sizeof(struct usbreq);
	err = usb_alloc_xact(udev->dman, &xact, 1);
	if (err) {
		ZF_LOGF("Out of DMA memory\n");
	}

	/* Fill in the request */
	xact.type = PID_SETUP;
	req = xact_get_vaddr(&xact);
	*req = __set_configuration_req(dev->config);

	/* Send the request to the host */
	err = usbdev_schedule_xact(udev, udev->ep_ctrl, &xact, 1, NULL, NULL);
	if (err) {
		ZF_LOGF("Transaction error\n");
	}
	usb_destroy_xact(udev->dman, &xact, 1);

	pl2303_startup_magic(udev);

	/* Allocate interrupt xact */
	dev->int_xact.type = PID_IN;
	dev->int_xact.len = dev->ep_int->max_pkt;
	err = usb_alloc_xact(udev->dman, &dev->int_xact, 1);
	if (err) {
		ZF_LOGF("Out of DMA memory\n");
	}

	/* Schedule a interrupt request */
	err = usbdev_schedule_xact(udev, dev->ep_int, &dev->int_xact, 1,
			pl2303_interrupt_cb, udev);
	if (err) {
		ZF_LOGF("Transaction error\n");
	}

	return 0;
}

int usb_pl2303_configure(usb_dev_t *udev, uint32_t bps, uint8_t char_size,
		enum serial_parity parity, uint8_t stop)
{
	int err;
	struct xact xact[2];
	struct usbreq *req;
	char *buf;

	xact[0].len = sizeof(struct usbreq);
	xact[1].len = 7;
	err = usb_alloc_xact(udev->dman, xact, 2);
	if (err) {
		ZF_LOGF("Out of DMA memory\n");
	}

	xact[0].type = PID_SETUP;
	xact[1].type = PID_OUT;
	req = xact_get_vaddr(&xact[0]);
	buf = xact_get_vaddr(&xact[1]);

	/* Data bits */
	buf[6] = char_size;

	/*
	 * Set parity
	 * 0 -- none, 1 -- odd, 2-- even, 3 -- mark, 4 -- space
	 */
	switch (parity) {
		case PARITY_NONE:
			buf[5] = 0;
			break;
		case PARITY_ODD:
			buf[5] = 1;
			break;
		case PARITY_EVEN:
			buf[5] = 2;
			break;
		default:
			ZF_LOGD("Unsupported parity!\n");
			break;
	}

	/* 0 -- 1 stop bits, 1 -- 1.5 stop bits, 2 -- 2 stop bits */
	buf[4] = stop;

	/* Set baudrate */
	buf[3] = bps & 0xFF;
	buf[2] = (bps >> 16) & 0xFF;
	buf[1] = (bps >> 8) & 0xFF;
	buf[0] = bps & 0xFF000000;

	/* Send configuration */
	req->bmRequestType = PL2303_SET_REQ_TYPE;
	req->bRequest = PL2303_SET_LINE_REQ;
	req->wIndex = 0;
	req->wLength = 7;
	req->wValue = 0;

	err = usbdev_schedule_xact(udev, udev->ep_ctrl, xact, 2, NULL, NULL);
	if (err) {
		ZF_LOGF("Transaction error\n");
	}

	/* Activate device */
	req->bmRequestType = PL2303_SET_REQ_TYPE;
	req->bRequest = PL2303_SET_CTRL_REQ;
	req->wIndex = 0;
	req->wLength = 0;
	req->wValue = PL2303_CTRL_DTR | PL2303_CTRL_RTS;

	err = usbdev_schedule_xact(udev, udev->ep_ctrl, xact, 1, NULL, NULL);
	if (err) {
		ZF_LOGF("Transaction error\n");
	}

	usb_destroy_xact(udev->dman, xact, 2);

	return 0;
}

/* TODO: Remove the 20K limitation */
int usb_pl2303_write(usb_dev_t *udev, void *buf, int len)
{
	int err;
	struct pl2303_device *dev;
	struct xact xact;

	dev = (struct pl2303_device*)udev->dev_data;

	xact.type = PID_OUT;
	xact.len = len;
	err = usb_alloc_xact(udev->dman, &xact, 1);
	if (err) {
		ZF_LOGF("Out of DMA memory\n");
	}

	memcpy(xact_get_vaddr(&xact), buf, len);

	err = usbdev_schedule_xact(udev, dev->ep_out, &xact, 1, NULL, NULL);
	if (err) {
		ZF_LOGF("Transaction error\n");
	}

	usb_destroy_xact(udev->dman, &xact, 1);

	return len - err;
}

/* TODO: Remove the 20K limitation and possible babble */
int usb_pl2303_read(usb_dev_t *udev, void *buf, int len)
{
	int err;
	struct pl2303_device *dev;
	struct xact xact;

	dev = (struct pl2303_device*)udev->dev_data;

	xact.type = PID_IN;
	xact.len = len;
	err = usb_alloc_xact(udev->dman, &xact, 1);
	if (err) {
		ZF_LOGF("Out of DMA memory\n");
	}

	err = usbdev_schedule_xact(udev, dev->ep_in, &xact, 1, NULL, NULL);
	if (err) {
		ZF_LOGF("Transaction error\n");
	}

	memcpy(buf, xact_get_vaddr(&xact), len);

	usb_destroy_xact(udev->dman, &xact, 1);

	return len - err;
}