/*
 * Copyright 2007 Oliver Ruiz Dorantes, oliver.ruiz.dorantes_at_gmail.com
 * Copyright 2008 Mika Lindqvist, monni1995_at_gmail.com
 * All rights reserved. Distributed under the terms of the MIT License.
 */


#include "h2transactions.h"

#include <bluetooth/HCI/btHCI.h>
#include <bluetooth/HCI/btHCI_event.h>
#include <bluetooth/HCI/btHCI_acl.h>

#include <ByteOrder.h>
#include <kernel.h>
#include <string.h>

#include "h2debug.h"
#include "h2generic.h"
#include "h2upper.h"
#include "h2util.h"


//#define DUMP_BUFFERS

/* Forward declaration */

void acl_tx_complete(void* cookie, status_t status, void* data, size_t actual_len);
void acl_rx_complete(void* cookie, status_t status, void* data, size_t actual_len);
void command_complete(void* cookie, status_t status, void* data, size_t actual_len);
void event_complete(void* cookie, status_t status, void* data, size_t actual_len);


static status_t
assembly_rx(bt_usb_dev* bdev, bt_packet_t type, void* data, int count)
{
        bdev->stat.bytesRX += count;

        return btDevices->PostTransportPacket(bdev->hdev, type, data, count);

}


#if 0
#pragma mark --- RX Complete ---
#endif

void
event_complete(void* cookie, status_t status, void* data, size_t actual_len)
{
        bt_usb_dev* bdev = (bt_usb_dev*)cookie;
        // bt_usb_dev* bdev = fetch_device(cookie, 0); -> safer / slower option
        status_t error;

        TRACE("%s: cookie@%p status=%s len=%" B_PRIuSIZE "\n", __func__, cookie,
                strerror(status), actual_len);

        if (bdev == NULL)
                return;

        if (status == B_CANCELED || status == B_DEV_CRC_ERROR)
                return; // or not running anymore...

        if (status != B_OK || actual_len == 0)
                goto resubmit;

        if (assembly_rx(bdev, BT_EVENT, data, actual_len) == B_OK) {
                bdev->stat.successfulTX++;
        } else {
                bdev->stat.errorRX++;
        }

resubmit:

        error = usb->queue_interrupt(bdev->intr_in_ep->handle, data,
                max_c(HCI_MAX_EVENT_SIZE, bdev->max_packet_size_intr_in),
                event_complete, bdev);

        if (error != B_OK) {
                reuse_room(&bdev->eventRoom, data);
                bdev->stat.rejectedRX++;
                ERROR("%s: RX event resubmittion failed %s\n", __func__,
                        strerror(error));
        } else {
                bdev->stat.acceptedRX++;
        }
}


void
acl_rx_complete(void* cookie, status_t status, void* data, size_t actual_len)
{
        bt_usb_dev* bdev = (bt_usb_dev*)cookie;
        // bt_usb_dev* bdev = fetch_device(cookie, 0); -> safer / slower option
        status_t error;

        if (bdev == NULL)
                return;

        if (status == B_CANCELED || status == B_DEV_CRC_ERROR)
                return; // or not running anymore...

        if (status != B_OK || actual_len == 0)
                goto resubmit;

        if (assembly_rx(bdev, BT_ACL, data, actual_len) == B_OK) {
                bdev->stat.successfulRX++;
        } else {
                bdev->stat.errorRX++;
        }

resubmit:

        error = usb->queue_bulk(bdev->bulk_in_ep->handle, data,
                max_c(HCI_MAX_FRAME_SIZE, bdev->max_packet_size_bulk_in),
                acl_rx_complete, (void*) bdev);

        if (error != B_OK) {
                reuse_room(&bdev->aclRoom, data);
                bdev->stat.rejectedRX++;
                ERROR("%s: RX acl resubmittion failed %s\n", __func__, strerror(error));
        } else {
                bdev->stat.acceptedRX++;
        }
}


#if 0
#pragma mark --- RX ---
#endif

status_t
submit_rx_event(bt_usb_dev* bdev)
{
        size_t size = max_c(HCI_MAX_EVENT_SIZE, bdev->max_packet_size_intr_in);
        void* buf = alloc_room(&bdev->eventRoom, size);
        status_t status;

        if (buf == NULL)
                return ENOMEM;

        status = usb->queue_interrupt(bdev->intr_in_ep->handle, buf, size,
                event_complete, (void*)bdev);

        if (status != B_OK) {
                reuse_room(&bdev->eventRoom, buf); // reuse allocated one
                bdev->stat.rejectedRX++;
        } else {
                bdev->stat.acceptedRX++;
                TRACE("%s: Accepted RX Event %d\n", __func__, bdev->stat.acceptedRX);
        }

        return status;
}


status_t
submit_rx_acl(bt_usb_dev* bdev)
{
        size_t size = max_c(HCI_MAX_FRAME_SIZE, bdev->max_packet_size_bulk_in);
        void* buf = alloc_room(&bdev->aclRoom, size);
        status_t status;

        if (buf == NULL)
                return ENOMEM;

        status = usb->queue_bulk(bdev->bulk_in_ep->handle, buf, size,
                acl_rx_complete, bdev);

        if (status != B_OK) {
                reuse_room(&bdev->aclRoom, buf); // reuse allocated
                bdev->stat.rejectedRX++;
        } else {
                bdev->stat.acceptedRX++;
        }

        return status;
}


status_t
submit_rx_sco(bt_usb_dev* bdev)
{
        // not yet implemented
        return B_ERROR;
}


#if 0
#pragma mark --- TX Complete ---
#endif

void
command_complete(void* cookie, status_t status, void* data, size_t actual_len)
{
        snet_buffer* snbuf = (snet_buffer*)cookie;
        bt_usb_dev* bdev = (bt_usb_dev*)snb_cookie(snbuf);

        TRACE("%s: len = %" B_PRIuSIZE " @%p\n", __func__, actual_len, data);

        if (status == B_OK) {
                bdev->stat.successfulTX++;
                bdev->stat.bytesTX += actual_len;
        } else {
                bdev->stat.errorTX++;
                // the packet has been lost, too late to requeue it
        }

        snb_park(&bdev->snetBufferRecycleTrash, snbuf);

#ifdef BT_RESCHEDULING_AFTER_COMPLETITIONS
        // TODO: check just the empty queues
        schedTxProcessing(bdev);
#endif
}


void
acl_tx_complete(void* cookie, status_t status, void* data, size_t actual_len)
{
        net_buffer* nbuf = (net_buffer*)cookie;
        bt_usb_dev* bdev = GET_DEVICE(nbuf);

        //debugf("fetched=%p type %lx %p\n", bdev, nbuf->type, data);

        if (status == B_OK) {
                bdev->stat.successfulTX++;
                bdev->stat.bytesTX += actual_len;
        } else {
                bdev->stat.errorTX++;
                // the packet has been lost, too late to requeue it
        }

        nb_destroy(nbuf);

#ifdef BT_RESCHEDULING_AFTER_COMPLETITIONS
        schedTxProcessing(bdev);
#endif
}


#if 0
#pragma mark --- TX ---
#endif

status_t
submit_tx_command(bt_usb_dev* bdev, snet_buffer* snbuf)
{
        uint8 bRequestType = bdev->ctrl_req;
        uint8 bRequest = 0;
        uint16 wIndex = 0;
        uint16 value = 0;
        uint16 wLength = B_HOST_TO_LENDIAN_INT16(snb_size(snbuf));
        status_t error;

        if (!GET_BIT(bdev->state, RUNNING)) {
                return B_DEV_NOT_READY;
        }

        // set cookie
        snb_set_cookie(snbuf, bdev);

        TRACE("%s: @%p\n", __func__, snb_get(snbuf));

        error = usb->queue_request(bdev->dev, bRequestType, bRequest,
                value, wIndex, wLength, snb_get(snbuf),
                command_complete, (void*) snbuf);

        if (error != B_OK) {
                bdev->stat.rejectedTX++;
        } else {
                bdev->stat.acceptedTX++;
        }

        return error;
}


status_t
submit_tx_acl(bt_usb_dev* bdev, net_buffer* nbuf)
{
        status_t error;

        // set cookie
        SET_DEVICE(nbuf, bdev->hdev);

        if (!GET_BIT(bdev->state, RUNNING)) {
                return B_DEV_NOT_READY;
        }
        /*
        debugf("### Outgoing ACL: len = %ld\n", nbuf->size);
        for (uint32 index = 0 ; index < nbuf->size; index++ ) {
                dprintf("%x:",((uint8*)nb_get_whole_buffer(nbuf))[index]);
        }
        */

        error = usb->queue_bulk(bdev->bulk_out_ep->handle, nb_get_whole_buffer(nbuf),
                nbuf->size, acl_tx_complete, (void*)nbuf);

        if (error != B_OK) {
                bdev->stat.rejectedTX++;
        } else {
                bdev->stat.acceptedTX++;
        }

        return error;
}


status_t
submit_tx_sco(bt_usb_dev* bdev)
{

        if (!GET_BIT(bdev->state, RUNNING)) {
                return B_DEV_NOT_READY;
        }

        // not yet implemented
        return B_ERROR;
}