/*
 * 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 "h2upper.h"

#include <string.h>

#include <bluetooth/bluetooth.h>
#include <bluetooth/HCI/btHCI_transport.h>
#include <kernel.h>

#include "h2debug.h"
#include "h2generic.h"
#include "h2transactions.h"
#include "snet_buffer.h"


// TODO: split for commands and comunication (ACL & SCO)
void
sched_tx_processing(bt_usb_dev* bdev)
{
        net_buffer* nbuf;
        snet_buffer* snbuf;
        status_t err;

        TRACE("%s: (%p)\n", __func__, bdev);

        if (!TEST_AND_SET(&bdev->state, PROCESSING)) {
                // We are not processing in another thread so... START!!

                do {
                        /* Do while this bit is on... so someone should set it before we
                         * stop the iterations
                         */
                        bdev->state = CLEAR_BIT(bdev->state, SENDING);
                        // check Commands
        #ifdef EMPTY_COMMAND_QUEUE
                        while (!list_is_empty(&bdev->nbuffersTx[BT_COMMAND])) {
        #else
                        if (!list_is_empty(&bdev->nbuffersTx[BT_COMMAND])) {
        #endif
                                snbuf = (snet_buffer*)
                                        list_remove_head_item(&bdev->nbuffersTx[BT_COMMAND]);
                                err = submit_tx_command(bdev, snbuf);
                                if (err != B_OK) {
                                        // re-head it
                                        list_insert_item_before(&bdev->nbuffersTx[BT_COMMAND],
                                                list_get_first_item(&bdev->nbuffersTx[BT_COMMAND]),
                                                snbuf);
                                }
                        }

                        // check ACl
        #define EMPTY_ACL_QUEUE
        #ifdef EMPTY_ACL_QUEUE
                        while (!list_is_empty(&bdev->nbuffersTx[BT_ACL])) {
        #else
                        if (!list_is_empty(&bdev->nbuffersTx[BT_ACL])) {
        #endif
                                nbuf = (net_buffer*)
                                        list_remove_head_item(&bdev->nbuffersTx[BT_ACL]);
                                err = submit_tx_acl(bdev, nbuf);
                                if (err != B_OK) {
                                        // re-head it
                                        list_insert_item_before(&bdev->nbuffersTx[BT_ACL],
                                                        list_get_first_item(&bdev->nbuffersTx[BT_ACL]),
                                                        nbuf);
                                }
                        }

                        if (!list_is_empty(&bdev->nbuffersTx[BT_SCO])) {
                                // TODO to be implemented
                        }

                } while (GET_BIT(bdev->state, SENDING));

                bdev->state = CLEAR_BIT(bdev->state, PROCESSING);

        } else {
                // We are processing so MARK that we need to still go on with that
                bdev->state = SET_BIT(bdev->state, SENDING);
        }
}


#if 0
// DEPRECATED
status_t
post_packet_up(bt_usb_dev* bdev, bt_packet_t type, void* buf)
{
        status_t err = B_ERROR;

        debugf("Frame up type=%d\n", type);

        if (type == BT_EVENT) {
                snet_buffer* snbuf = (snet_buffer*)buf;
                btCoreData->PostEvent(bdev->ndev, snb_get(snbuf),
                        (size_t)snb_size(snbuf));
                snb_park(&bdev->snetBufferRecycleTrash, snbuf);
                debugf("to btDataCore len=%d\n", snb_size(snbuf));
        } else {
                net_buffer* nbuf = (net_buffer*) buf;
                // No need to free the buffer at allocation is gonna be reused
                btDevices->receive_data(bdev->ndev, &nbuf);
                TRACE("to net_device\n");
        }

        return err;
}
#endif


status_t
send_packet(hci_id hid, bt_packet_t type, net_buffer* nbuf)
{
        bt_usb_dev* bdev = fetch_device(NULL, hid);
        status_t err = B_OK;

        if (bdev == NULL)
                return B_ERROR;

        // TODO: check if device is actually ready for this
        // TODO: Lock Device

        if (nbuf != NULL) {
                if (type != nbuf->protocol) // a bit strict maybe
                        panic("Upper layer has not filled correctly a packet");

                switch (type) {
                        case BT_COMMAND:
                        case BT_ACL:
                        case BT_SCO:
                                list_add_item(&bdev->nbuffersTx[type], nbuf);
                                bdev->nbuffersPendingTx[type]++;
                        break;
                        default:
                                ERROR("%s: Unknown packet type for sending %d\n", __func__,
                                        type);
                                // TODO: free the net_buffer -> no, allow upper layer
                                // handle it with the given error
                                err = B_BAD_VALUE;
                        break;
                }
        } else {
                TRACE("%s: tx sched provoked", __func__);
        }

        // TODO: check if device is actually ready for this
        // TODO: unlock device

        // sched in any case even if nbuf is null (provoke re-scheduling)
        sched_tx_processing(bdev);

        return err;
}


status_t
send_command(hci_id hid, snet_buffer* snbuf)
{
        bt_usb_dev* bdev = fetch_device(NULL, hid);
        status_t err = B_OK;

        if (bdev == NULL)
                return B_ERROR;

        // TODO: check if device is actually ready for this
        // TODO: mutex

        if (snbuf != NULL) {
                list_add_item(&bdev->nbuffersTx[BT_COMMAND], snbuf);
                bdev->nbuffersPendingTx[BT_COMMAND]++;
        } else {
                err = B_BAD_VALUE;
                TRACE("%s: tx sched provoked", __func__);
        }

        // TODO: check if device is actually ready for this
        // TODO: mutex

        /* sched in All cases even if nbuf is null (hidden way to provoke
         * re-scheduling)
         */
        sched_tx_processing(bdev);

        return err;
}