/*
 * 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 "ACM.h"
#include "Driver.h"


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


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

        status_t status = ENODEV;
        uint8 masterIndex = 0;
        uint8 slaveIndex = 0;
        usb_cdc_cm_functional_descriptor* cmDesc = NULL;
        usb_cdc_union_functional_descriptor* unionDesc = NULL;

        // Search ACM Communication Interface
        for (size_t i = 0; i < config->interface_count && status < B_OK; i++) {
                usb_interface_info *interface = config->interface[i].active;
                if (interface == NULL)
                        continue;
                usb_interface_descriptor *descriptor = interface->descr;
                if (descriptor == NULL)
                        continue;
                if (descriptor->interface_class != USB_CDC_COMMUNICATION_INTERFACE_CLASS
                        || descriptor->interface_subclass != USB_CDC_COMMUNICATION_INTERFACE_ACM_SUBCLASS)
                        continue;

                // Found ACM Communication Interface!
                // Get functional descriptors of some interest, if any
                for (size_t j = 0; j < interface->generic_count; j++) {
                        usb_generic_descriptor *generic = &interface->generic[j]->generic;
                        switch (generic->data[0]) {
                                case USB_CDC_CM_FUNCTIONAL_DESCRIPTOR:
                                        cmDesc = (usb_cdc_cm_functional_descriptor*)generic;
                                        break;

                                case USB_CDC_ACM_FUNCTIONAL_DESCRIPTOR:
                                        break;

                                case USB_CDC_UNION_FUNCTIONAL_DESCRIPTOR:
                                        unionDesc = (usb_cdc_union_functional_descriptor*)generic;
                                        break;
                        }
                }

                masterIndex = unionDesc ? unionDesc->master_interface : i;
                slaveIndex = cmDesc ? cmDesc->data_interface
                        : unionDesc ? unionDesc->slave_interfaces[0] : 0;

                TRACE("ACM device found on configuration #%d: master itf: %d, "
                                "slave/data itf: %d\n", config->descr->configuration,
                                masterIndex, slaveIndex);

                // Some ACM USB devices report the wrong unions which rightfully
                // breaks probing. Some drivers keep a list of these devices,
                // for now we just assume identical indexes are wrong.
                if (masterIndex == slaveIndex) {
                        TRACE_ALWAYS("Command interface matches data interface, "
                                "assuming broken union quirk!\n");
                        masterIndex = 0;
                        slaveIndex = 1;
                }

                status = B_OK;
                break;
        }

        if (status == B_OK && masterIndex < config->interface_count) {
                // check that the indicated master interface fits our need
                usb_interface_info *interface = config->interface[masterIndex].active;
                usb_interface_descriptor *descriptor = interface->descr;
                if ((descriptor->interface_class == USB_CDC_COMMUNICATION_INTERFACE_CLASS
                        || descriptor->interface_class == USB_CDC_DATA_INTERFACE_CLASS)
                        && interface->endpoint_count >= 1) {
                        SetControlPipe(interface->endpoint[0].handle);
                        SetInterruptBufferSize(interface->endpoint[0].descr->max_packet_size);
                } else {
                        TRACE("Indicated command interface doesn't fit our needs!\n");
                        status = ENODEV;
                }
        }

        if (status == B_OK && slaveIndex < config->interface_count) {
                // check that the indicated slave interface fits our need
                usb_interface_info *interface = config->interface[slaveIndex].active;
                usb_interface_descriptor *descriptor = interface->descr;
                if (descriptor->interface_class == USB_CDC_DATA_INTERFACE_CLASS
                        && interface->endpoint_count >= 2) {
                        if (!(interface->endpoint[0].descr->endpoint_address & USB_ENDPOINT_ADDR_DIR_IN)) {
                                SetWriteBufferSize(ROUNDUP(interface->endpoint[0].descr->max_packet_size, 16));
                                SetWritePipe(interface->endpoint[0].handle);
                        } else {
                                SetReadBufferSize(ROUNDUP(interface->endpoint[0].descr->max_packet_size, 16));
                                SetReadPipe(interface->endpoint[0].handle);
                        }

                        if (interface->endpoint[1].descr->endpoint_address & USB_ENDPOINT_ADDR_DIR_IN) {
                                SetReadBufferSize(ROUNDUP(interface->endpoint[1].descr->max_packet_size, 16));
                                SetReadPipe(interface->endpoint[1].handle);
                        } else {
                                SetWriteBufferSize(ROUNDUP(interface->endpoint[1].descr->max_packet_size, 16));
                                SetWritePipe(interface->endpoint[1].handle);
                        }
                } else {
                        TRACE("Indicated data interface doesn't fit our needs!\n");
                        status = ENODEV;
                }
        }

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


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

        size_t length = 0;
        status_t status = gUSBModule->send_request(Device(),
                USB_REQTYPE_CLASS | USB_REQTYPE_INTERFACE_OUT,
                USB_CDC_SET_LINE_CODING, 0, 0,
                sizeof(usb_cdc_line_coding),
                lineCoding, &length);

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


status_t
ACMDevice::SetControlLineState(uint16 state)
{
        TRACE_FUNCALLS("> ACMDevice::SetControlLineState(0x%08x, 0x%04x)\n", this, state);

        size_t length = 0;
        status_t status = gUSBModule->send_request(Device(),
                USB_REQTYPE_CLASS | USB_REQTYPE_INTERFACE_OUT,
                USB_CDC_SET_CONTROL_LINE_STATE, state, 0, 0, NULL, &length);

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