libusbdrivers/src/drivers/pl2303.c - 3p/sel4proj/projects_libs - Git at Google

 /*
  * 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;
 }
	/*
	* 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;
	}