/*
 * Copyright 2007-2008, Haiku Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Michael Lotz <mmlr@mlotz.ch>
 *		Salvatore Benedetto <salvatore.benedetto@gmail.com>
 */

#include <USBKit.h>
#include <usb_raw.h>

#include <new>
#include <string.h>
#include <unistd.h>


BUSBInterface::BUSBInterface(BUSBConfiguration *config, uint32 index,
	uint32 alternate, int rawFD)
	:	fConfiguration(config),
		fIndex(index),
		fAlternate(alternate),
		fRawFD(rawFD),
		fEndpoints(NULL),
		fAlternateCount(0),
		fAlternates(NULL),
		fInterfaceString(NULL)
{
	_UpdateDescriptorAndEndpoints();
}


BUSBInterface::~BUSBInterface()
{
	delete[] fInterfaceString;

	if (fEndpoints != NULL) {
		for (int32 i = 0; i < fDescriptor.num_endpoints; i++)
			delete fEndpoints[i];
		delete[] fEndpoints;
	}

	if (fAlternates != NULL) {
		for (uint32 i = 0; i < fAlternateCount; i++)
			delete fAlternates[i];
		delete[] fAlternates;
	}
}


uint32
BUSBInterface::Index() const
{
	return fIndex;
}


uint32
BUSBInterface::AlternateIndex() const
{
	if (fAlternate == B_USB_RAW_ACTIVE_ALTERNATE)
		return ActiveAlternateIndex();
	return fAlternate;
}


const BUSBConfiguration *
BUSBInterface::Configuration() const
{
	return fConfiguration;
}


const BUSBDevice *
BUSBInterface::Device() const
{
	return fConfiguration->Device();
}


uint8
BUSBInterface::Class() const
{
	return fDescriptor.interface_class;
}


uint8
BUSBInterface::Subclass() const
{
	return fDescriptor.interface_subclass;
}


uint8
BUSBInterface::Protocol() const
{
	return fDescriptor.interface_protocol;
}


const char *
BUSBInterface::InterfaceString() const
{
	if (fDescriptor.interface == 0)
		return "";

	if (fInterfaceString)
		return fInterfaceString;

	fInterfaceString = Device()->DecodeStringDescriptor(fDescriptor.interface);
	if (fInterfaceString == NULL)
		return "";

	return fInterfaceString;
}


const usb_interface_descriptor *
BUSBInterface::Descriptor() const
{
	return &fDescriptor;
}


status_t
BUSBInterface::OtherDescriptorAt(uint32 index, usb_descriptor *descriptor,
	size_t length) const
{
	if (length <= 0 || descriptor == NULL)
		return B_BAD_VALUE;

	usb_raw_command command;
	command.generic_etc.descriptor = descriptor;
	command.generic_etc.config_index = fConfiguration->Index();
	command.generic_etc.interface_index = fIndex;
	command.generic_etc.alternate_index = fAlternate;
	command.generic_etc.generic_index = index;
	command.generic_etc.length = length;
	if (ioctl(fRawFD, B_USB_RAW_COMMAND_GET_GENERIC_DESCRIPTOR_ETC, &command,
		sizeof(command)) || command.generic.status != B_USB_RAW_STATUS_SUCCESS)
		return B_ERROR;

	return B_OK;
}


uint32
BUSBInterface::CountEndpoints() const
{
	return fDescriptor.num_endpoints;
}


const BUSBEndpoint *
BUSBInterface::EndpointAt(uint32 index) const
{
	if (index >= fDescriptor.num_endpoints || fEndpoints == NULL)
		return NULL;

	return fEndpoints[index];
}


uint32
BUSBInterface::CountAlternates() const
{
	usb_raw_command command;
	command.alternate.config_index = fConfiguration->Index();
	command.alternate.interface_index = fIndex;
	if (ioctl(fRawFD, B_USB_RAW_COMMAND_GET_ALT_INTERFACE_COUNT, &command,
		sizeof(command)) || command.alternate.status != B_USB_RAW_STATUS_SUCCESS)
		return 1;

	return command.alternate.alternate_info;
}


const BUSBInterface *
BUSBInterface::AlternateAt(uint32 alternateIndex) const
{
	if (fAlternateCount > 0 && fAlternates != NULL) {
		if (alternateIndex >= fAlternateCount)
			return NULL;

		return fAlternates[alternateIndex];
	}

	if (fAlternateCount == 0)
		fAlternateCount = CountAlternates();
	if (alternateIndex >= fAlternateCount)
		return NULL;

	fAlternates = new(std::nothrow) BUSBInterface *[fAlternateCount];
	if (fAlternates == NULL)
		return NULL;

	for (uint32 i = 0; i < fAlternateCount; i++) {
		fAlternates[i] = new(std::nothrow) BUSBInterface(fConfiguration, fIndex,
			i, fRawFD);
	}

	return fAlternates[alternateIndex];
}


uint32
BUSBInterface::ActiveAlternateIndex() const
{
	usb_raw_command command;
	command.alternate.config_index = fConfiguration->Index();
	command.alternate.interface_index = fIndex;
	if (ioctl(fRawFD, B_USB_RAW_COMMAND_GET_ACTIVE_ALT_INTERFACE_INDEX, &command,
		sizeof(command)) || command.alternate.status != B_USB_RAW_STATUS_SUCCESS)
		return 0;

	return command.alternate.alternate_info;
}


status_t
BUSBInterface::SetAlternate(uint32 alternateIndex)
{
	usb_raw_command command;
	command.alternate.alternate_info = alternateIndex;
	command.alternate.config_index = fConfiguration->Index();
	command.alternate.interface_index = fIndex;
	if (ioctl(fRawFD, B_USB_RAW_COMMAND_SET_ALT_INTERFACE, &command,
		sizeof(command)) || command.alternate.status != B_USB_RAW_STATUS_SUCCESS)
		return B_ERROR;

	_UpdateDescriptorAndEndpoints();
	return B_OK;
}


void
BUSBInterface::_UpdateDescriptorAndEndpoints()
{
	usb_raw_command command;
	command.interface_etc.descriptor = &fDescriptor;
	command.interface_etc.config_index = fConfiguration->Index();
	command.interface_etc.interface_index = fIndex;
	command.interface_etc.alternate_index = fAlternate;
	if (ioctl(fRawFD, B_USB_RAW_COMMAND_GET_INTERFACE_DESCRIPTOR_ETC, &command,
		sizeof(command)) || command.interface.status != B_USB_RAW_STATUS_SUCCESS)
		memset(&fDescriptor, 0, sizeof(fDescriptor));

	if (fEndpoints != NULL) {
		// Delete old endpoints
		for (int32 i = 0; i < fDescriptor.num_endpoints; i++)
			delete fEndpoints[i];
		delete fEndpoints;
	}

	fEndpoints = new(std::nothrow) BUSBEndpoint *[fDescriptor.num_endpoints];
	if (fEndpoints == NULL)
		return;

	for (int32 i = 0; i < fDescriptor.num_endpoints; i++)
		fEndpoints[i] = new(std::nothrow) BUSBEndpoint(this, i, fRawFD);
}