/*
 * Copyright (c) 2007-2008 by Michael Lotz
 * Heavily based on the original usb_serial driver which is:
 *
 * Copyright (c) 2003 by Siarzhuk Zharski <imker@gmx.li>
 * Distributed under the terms of the MIT License.
 */
#include "KLSI.h"
#include <ByteOrder.h>

KLSIDevice::KLSIDevice(usb_device device, uint16 vendorID, uint16 productID,
	const char *description)
	:	SerialDevice(device, vendorID, productID, description)
{
}


status_t
KLSIDevice::AddDevice(const usb_configuration_info *config)
{
	TRACE_FUNCALLS("> KLSIDevice::AddDevice(%08x, %08x)\n", this, config);

	int32 pipesSet = 0;
	status_t status = ENODEV;
	if (config->interface_count > 0) {
		usb_interface_info *interface = config->interface[0].active;
		for (size_t i = 0; i < interface->endpoint_count; i++) {
			usb_endpoint_info *endpoint = &interface->endpoint[i];
			if (endpoint->descr->attributes == USB_ENDPOINT_ATTR_INTERRUPT) {
				if (endpoint->descr->endpoint_address & USB_ENDPOINT_ADDR_DIR_IN) {
					SetControlPipe(endpoint->handle);
					SetInterruptBufferSize(endpoint->descr->max_packet_size);
				}
			} else if (endpoint->descr->attributes == USB_ENDPOINT_ATTR_BULK) {
				if (endpoint->descr->endpoint_address & USB_ENDPOINT_ADDR_DIR_IN) {
					SetReadBufferSize(ROUNDUP(endpoint->descr->max_packet_size, 16));
					SetReadPipe(endpoint->handle);
				} else {
					SetWriteBufferSize(ROUNDUP(endpoint->descr->max_packet_size, 16));
					SetWritePipe(endpoint->handle);
				}
			}
			if (++pipesSet >= 3)
				break;
		}
	}

	if (pipesSet >= 3)
		status = B_OK;

	TRACE_FUNCRET("< KLSIDevice::AddDevice() returns: 0x%08x\n", status);
	return status;
}


status_t
KLSIDevice::ResetDevice()
{
	TRACE_FUNCALLS("> KLSIDevice::ResetDevice(%08x)\n", this);

	size_t length = 0;
	status_t status;
	usb_cdc_line_coding lineCoding = { 9600, 1, 0, 8 };
	uint8 linestate[2];

	status = SetLineCoding(&lineCoding);
	status = gUSBModule->send_request(Device(),
		USB_REQTYPE_VENDOR | USB_REQTYPE_DEVICE_OUT,
		KLSI_CONF_REQUEST,
		KLSI_CONF_REQUEST_READ_ON, 0, 0, NULL, &length);
	TRACE("= KLSIDevice::ResetDevice(): set conf read_on returns: 0x%08x\n",
		status);

	linestate[0] = 0xff;
	linestate[1] = 0xff;
	length = 0;
	status = gUSBModule->send_request(Device(),
		USB_REQTYPE_VENDOR | USB_REQTYPE_DEVICE_IN,
		KLSI_POLL_REQUEST,
		0, 0, 2, linestate, &length);

	TRACE_FUNCRET("< KLSIDevice::ResetDevice() returns: 0x%08x\n", status);
	return status;
}


status_t
KLSIDevice::SetLineCoding(usb_cdc_line_coding *lineCoding)
{
	TRACE_FUNCALLS("> KLSIDevice::SetLineCoding(0x%08x, {%d, 0x%02x, 0x%02x, 0x%02x})\n",
		this, lineCoding->speed, lineCoding->stopbits, lineCoding->parity,
		lineCoding->databits);

	uint8 rate;
	switch (lineCoding->speed) {
		case 300: rate = klsi_sio_b300; break;
		case 600: rate = klsi_sio_b600; break;
		case 1200: rate = klsi_sio_b1200; break;
		case 2400: rate = klsi_sio_b2400; break;
		case 4800: rate = klsi_sio_b4800; break;
		case 9600: rate = klsi_sio_b9600; break;
		case 19200: rate = klsi_sio_b19200; break;
		case 38400: rate = klsi_sio_b38400; break;
		case 57600: rate = klsi_sio_b57600; break;
		case 115200: rate = klsi_sio_b115200; break;
		default:
			rate = klsi_sio_b19200;
			TRACE_ALWAYS("= KLSIDevice::SetLineCoding(): Datarate: %d is not "
				"supported by this hardware. Defaulted to %d\n",
				lineCoding->speed, rate);
		break;
	}

	uint8 codingPacket[5];
	codingPacket[0] = 5; /* size */
	codingPacket[1] = rate;
	codingPacket[2] = lineCoding->databits; /* only 7,8 */
	codingPacket[3] = 0; /* unknown */
	codingPacket[4] = 1; /* unknown */

	size_t length = 0;
	status_t status = gUSBModule->send_request(Device(),
		USB_REQTYPE_VENDOR | USB_REQTYPE_DEVICE_OUT,
		KLSI_SET_REQUEST, 0, 0,
		sizeof(codingPacket), codingPacket, &length);

	if (status != B_OK)
		TRACE_ALWAYS("= KLSIDevice::SetLineCoding(): datarate set request failed: 0x%08x\n", status);

	TRACE_FUNCRET("< KLSIDevice::SetLineCoding() returns: 0x%08x\n", status);
	return status;
}


void
KLSIDevice::OnRead(char **buffer, size_t *numBytes)
{
	if (*numBytes <= 2) {
		*numBytes = 0;
		return;
	}

	size_t bytes = B_LENDIAN_TO_HOST_INT16(*(uint16 *)(*buffer));
	*numBytes = MIN(bytes, *numBytes - 2);
	*buffer += 2;
}


void
KLSIDevice::OnWrite(const char *buffer, size_t *numBytes, size_t *packetBytes)
{
	if (*numBytes > KLSI_BUFFER_SIZE)
		*numBytes = *packetBytes = KLSI_BUFFER_SIZE;

	if (*numBytes > WriteBufferSize() - 2)
		*numBytes = *packetBytes = WriteBufferSize() - 2;

	char *writeBuffer = WriteBuffer();
	*((uint16 *)writeBuffer) = B_HOST_TO_LENDIAN_INT16(*numBytes);
	memcpy(writeBuffer + 2, buffer, *packetBytes);
	*packetBytes += 2;
}


void
KLSIDevice::OnClose()
{
	TRACE_FUNCALLS("> KLSIDevice::OnClose(%08x)\n", this);

	size_t length = 0;
	status_t status = gUSBModule->send_request(Device(),
		USB_REQTYPE_VENDOR | USB_REQTYPE_DEVICE_OUT,
		KLSI_CONF_REQUEST,
		KLSI_CONF_REQUEST_READ_OFF, 0, 0,
		NULL, &length);

	TRACE_FUNCRET("< KLSIDevice::OnClose() returns: 0x%08x\n", status);
}