/*
 * Copyright (C) 2016 Spreadtrum Communications Inc.
 *
 * This software is licensed under the terms of the GNU General Public
 * License version 2, as published by the Free Software Foundation, and
 * may be copied, distributed, and modified under those terms.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

#include <linux/slab.h>
#include <linux/kfifo.h>

#include "include/sitm.h"


static const uint8_t preamble_sizes[] =
{
    HCI_COMMAND_PREAMBLE_SIZE,
    HCI_ACL_PREAMBLE_SIZE,
    HCI_SCO_PREAMBLE_SIZE,
    HCI_EVENT_PREAMBLE_SIZE
};

static struct packet_receive_data_t *rd;

int sitm_init(void)
{
    rd = kmalloc(sizeof(struct packet_receive_data_t),
                 GFP_KERNEL);
    memset(rd, 0, sizeof(struct packet_receive_data_t));

    if (kfifo_alloc(&rd->fifo,
                    HCI_HAL_SERIAL_BUFFER_SIZE, GFP_KERNEL))
    {
        pr_err("no memory for sitm ring buf");
    }

    return 0;
}

int sitm_cleanup(void)
{
    if (rd == NULL)
    {
        pr_err("bt sitm_cleanup fail: rd NULL");
        return -1;
    }

    kfifo_free(&rd->fifo);
    kfree(rd);
    rd = NULL;
    return 0;
}



static int data_ready(uint8_t *buf, uint32_t count)
{
    int ret = kfifo_out(&rd->fifo, buf, count);
    return ret;
}

void parse_frame(data_ready_cb data_ready, frame_complete_cb frame_complete)
{
    uint8_t byte;
    size_t buffer_size, bytes_read;

    while (data_ready(&byte, 1) == 1)
    {
        switch (rd->state)
        {
        case BRAND_NEW:
            if (byte > DATA_TYPE_EVENT
                    || byte < DATA_TYPE_COMMAND)
            {
                pr_err("unknown head: 0x%02x\n", byte);
                break;
            }

            rd->type = byte;
            rd->bytes_remaining =
                preamble_sizes[PACKET_TYPE_TO_INDEX(rd->type)]
                + 1;
            memset(rd->preamble, 0, PREAMBLE_BUFFER_SIZE);
            rd->index = 0;
            rd->state = PREAMBLE;

        case PREAMBLE:
            rd->preamble[rd->index] = byte;
            rd->index++;
            rd->bytes_remaining--;

            if (rd->bytes_remaining == 0)
            {
                rd->bytes_remaining =
                    (rd->type == DATA_TYPE_ACL) ?
                    RETRIEVE_ACL_LENGTH(rd->preamble)
                    : byte;
                buffer_size = rd->index
                              + rd->bytes_remaining;
                memcpy(rd->buffer,
                       rd->preamble,
                       rd->index);
                rd->state =
                    rd->bytes_remaining > 0 ?
                    BODY : FINISHED;
            }

            break;

        case BODY:
            rd->buffer[rd->index] = byte;
            rd->index++;
            rd->bytes_remaining--;
            bytes_read = data_ready((rd->buffer
                                     + rd->index),
                                    rd->bytes_remaining);
            rd->index += bytes_read;
            rd->bytes_remaining -= bytes_read;
            rd->state =
                rd->bytes_remaining == 0 ?
                FINISHED : rd->state;
            break;

        case IGNORE:
            pr_err("PARSE IGNORE\n");
            rd->bytes_remaining--;

            if (rd->bytes_remaining == 0)
            {
                rd->state = BRAND_NEW;
                return;
            }

            break;

        case FINISHED:
            pr_err("%s state.\n", __func__);
            break;

        default:
            pr_err("PARSE DEFAULT\n");
            break;
        }

        if (rd->state == FINISHED)
        {
            if (rd->type == DATA_TYPE_COMMAND
                    || rd->type == DATA_TYPE_ACL)
            {
                uint32_t tail = BYTE_ALIGNMENT
                                - ((rd->index
                                    + BYTE_ALIGNMENT)
                                   % BYTE_ALIGNMENT);

                while (tail--)
                {
                    rd->buffer[rd->index++] = 0;
                }
            }

            frame_complete(rd->buffer,
                           rd->index);
            rd->state = BRAND_NEW;
        }
    }
}

int sitm_write(const uint8_t *buf, int count, frame_complete_cb frame_complete)
{
    int ret;

    if (!rd)
    {
        pr_err("hci fifo no memory\n");
        return count;
    }

    ret = kfifo_avail(&rd->fifo);

    if (ret == 0)
    {
        pr_err("hci fifo no memory\n");
        return ret;
    }
    else if (ret < count)
    {
        pr_err("hci fifo low memory\n");
        count = ret;
    }

    kfifo_in(&rd->fifo, buf, count);
    parse_frame(data_ready, frame_complete);
    return count;
}