/******************************************************************************
|
*
|
* Copyright (C) 2019-2021 Aicsemi Corporation.
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at:
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*
|
******************************************************************************/
|
/******************************************************************************
|
*
|
* Module Name:
|
* bt_skbuff.c
|
*
|
* Abstract:
|
* Data buffer managerment through whole bluetooth stack.
|
*
|
* Notes:
|
* To reduce memory copy when pass data buffer to other layers,
|
* AIC_BUFFER is designed referring to linux socket buffer.
|
* But I still wonder its effect, since AIC_BUFFER is much bigger
|
* than original data buffer.AIC_BUFFER will reduce its member if
|
* it would not reach what i had expected.
|
*
|
******************************************************************************/
|
|
|
#define LOG_TAG "bt_h5"
|
#undef NDEBUG
|
#include <utils/Log.h>
|
#include <stdlib.h>
|
#include <fcntl.h>
|
|
#include <termios.h>
|
#include <errno.h>
|
#include <pthread.h>
|
|
|
#include "bt_list.h"
|
#include "bt_skbuff.h"
|
#include "string.h"
|
#include "hci_h5_int.h"
|
#define IN
|
#define OUT
|
|
//****************************************************************************
|
// CONSTANT DEFINITION
|
//****************************************************************************
|
///default header size
|
///l2cap header(8)+hci acl(4)
|
#define DEFAULT_HEADER_SIZE (8+4)
|
|
//AIC_BUFFER data buffer alignment
|
#define RTB_ALIGN 4
|
|
//do alignment with RTB_ALIGN
|
#define RTB_DATA_ALIGN(_Length) ((_Length + (RTB_ALIGN - 1)) & (~(RTB_ALIGN - 1)))
|
|
//****************************************************************************
|
// STRUCTURE DEFINITION
|
//****************************************************************************
|
typedef struct _RTB_QUEUE_HEAD {
|
RT_LIST_HEAD List;
|
uint32_t QueueLen;
|
pthread_mutex_t Lock;
|
uint8_t Id[RTB_QUEUE_ID_LENGTH];
|
} *PRTB_QUEUE_HEAD;
|
|
//****************************************************************************
|
// FUNCTION
|
//****************************************************************************
|
/**
|
check whether queue is empty
|
\return : FALSE Queue is not empty
|
TRU Queue is empty
|
*/
|
bool RtbQueueIsEmpty(IN RTB_QUEUE_HEAD* AicQueueHead)
|
{
|
//return ListIsEmpty(&AicQueueHead->List);
|
return AicQueueHead->QueueLen > 0 ? false : true;
|
}
|
|
/**
|
Allocate a AIC_BUFFER with specified data length and reserved headroom.
|
If caller does not know actual headroom to reserve for further usage, specify it to zero to use default value.
|
\param [IN] Length <uint32_t> : current data buffer length to allcated
|
\param [IN] HeadRoom <uint32_t> : if caller knows reserved head space, set it; otherwise set 0 to use default value
|
\return pointer to AIC_BUFFER if succeed, null otherwise
|
*/
|
AIC_BUFFER *RtbAllocate(uint32_t Length, uint32_t HeadRoom)
|
{
|
AIC_BUFFER* Rtb = NULL;
|
///Rtb buffer length:
|
/// AIC_BUFFER 48
|
/// HeadRoom HeadRomm or 12
|
/// Length
|
///memory size: 48 + Length + 12(default) + 8*2(header for each memory) ---> a multiple of 8
|
///example: (48 + 8)+ (300 + 12 + 8) = 372
|
Rtb = malloc( sizeof(AIC_BUFFER) );
|
if (Rtb) {
|
uint32_t BufferLen = HeadRoom ? (Length + HeadRoom) : (Length + DEFAULT_HEADER_SIZE);
|
BufferLen = RTB_DATA_ALIGN(BufferLen);
|
Rtb->Head = malloc(BufferLen);
|
if (Rtb->Head) {
|
Rtb->HeadRoom = HeadRoom ? HeadRoom : DEFAULT_HEADER_SIZE;
|
Rtb->Data = Rtb->Head + Rtb->HeadRoom;
|
Rtb->End = Rtb->Data;
|
Rtb->Tail = Rtb->End + Length;
|
Rtb->Length = 0;
|
ListInitializeHeader(&Rtb->List);
|
Rtb->RefCount = 1;
|
return Rtb;
|
}
|
}
|
|
if (Rtb) {
|
if (Rtb->Head)
|
free(Rtb->Head);
|
|
free(Rtb);
|
}
|
return NULL;
|
}
|
|
/**
|
Free specified Aic_buffer
|
\param [IN] AicBuffer <AIC_BUFFER*> : buffer to free
|
*/
|
void RtbFree(AIC_BUFFER *AicBuffer)
|
{
|
if (AicBuffer) {
|
free(AicBuffer->Head);
|
free(AicBuffer);
|
}
|
return;
|
}
|
|
/**
|
Add a specified length protocal header to the start of data buffer hold by specified aic_buffer.
|
This function extends used data area of the buffer at the buffer start.
|
\param [IN OUT] AicBuffer <AIC_BUFFER*> : data buffer to add
|
\param [IN] Length <uint32_t> : header length
|
\return Pointer to the first byte of the extra data is returned
|
*/
|
uint8_t *RtbAddHead(AIC_BUFFER *AicBuffer, uint32_t Length)
|
{
|
|
if ((uint32_t)(AicBuffer->Data - AicBuffer->Head) >= Length) {
|
AicBuffer->Data -= Length;
|
AicBuffer->Length += Length;
|
AicBuffer->HeadRoom -= Length;
|
return AicBuffer->Data;
|
}
|
|
return NULL;
|
}
|
|
/**
|
Remove a specified length data from the start of data buffer hold by specified aic_buffer.
|
This function returns the memory to the headroom.
|
\param [IN OUT] AicBuffer <AIC_BUFFER*> : data buffer to remove
|
\param [IN] Length <uint32_t> : header length
|
\return Pointer to the next data in the buffer is returned, usually useless
|
*/
|
unsigned char RtbRemoveHead(AIC_BUFFER *AicBuffer, uint32_t Length)
|
{
|
|
if (AicBuffer->Length >= Length) {
|
AicBuffer->Data += Length;
|
AicBuffer->Length -= Length;
|
AicBuffer->HeadRoom += Length;
|
return true;
|
}
|
|
return false;
|
}
|
|
/**
|
Add a specified length protocal header to the end of data buffer hold by specified aic_buffer.
|
This function extends used data area of the buffer at the buffer end.
|
\param [IN OUT] AicBuffer <AIC_BUFFER*> : data buffer to add
|
\param [IN] Length <uint32_t> : header length
|
\return Pointer to the first byte of the extra data is returned
|
*/
|
uint8_t *RtbAddTail(AIC_BUFFER *AicBuffer, uint32_t Length)
|
{
|
|
if ((uint32_t)(AicBuffer->Tail - AicBuffer->End) >= Length) {
|
uint8_t* Tmp = AicBuffer->End;
|
AicBuffer->End += Length;
|
AicBuffer->Length += Length;
|
return Tmp;
|
}
|
|
return NULL;
|
}
|
|
unsigned char RtbRemoveTail(IN OUT AIC_BUFFER *AicBuffer, IN uint32_t Length)
|
{
|
|
if ((uint32_t)(AicBuffer->End - AicBuffer->Data) >= Length) {
|
AicBuffer->End -= Length;
|
AicBuffer->Length -= Length;
|
return true;
|
}
|
|
return false;
|
}
|
|
//****************************************************************************
|
// RTB list manipulation
|
//****************************************************************************
|
/**
|
Initialize a rtb queue.
|
\return Initilized rtb queue if succeed, otherwise NULL
|
*/
|
RTB_QUEUE_HEAD *RtbQueueInit(void)
|
{
|
RTB_QUEUE_HEAD *RtbQueue = NULL;
|
int ret = 0;
|
RtbQueue = malloc(sizeof(RTB_QUEUE_HEAD));
|
if (RtbQueue) {
|
ret = pthread_mutex_init(&RtbQueue->Lock, NULL);
|
if (!ret) {
|
ListInitializeHeader(&RtbQueue->List);
|
RtbQueue->QueueLen = 0;
|
return RtbQueue;
|
}
|
}
|
|
//error code comes here
|
if (RtbQueue)
|
free(RtbQueue);
|
|
return NULL;
|
|
}
|
|
/**
|
Free a rtb queue.
|
\param [IN] AicQueueHead <RTB_QUEUE_HEAD*> : Aic Queue
|
*/
|
void RtbQueueFree(RTB_QUEUE_HEAD *AicQueueHead)
|
{
|
if (AicQueueHead) {
|
RtbEmptyQueue(AicQueueHead);
|
pthread_mutex_destroy(&AicQueueHead->Lock);
|
free(AicQueueHead);
|
}
|
}
|
|
/**
|
Queue specified AicBuffer into a AicQueue at list tail.
|
\param [IN OUT] AicQueueHead <RTB_QUEUE_HEAD*> : Aic Queue
|
\param [IN] AicBuffer <AIC_BUFFER*> : Aic buffer to add
|
*/
|
void RtbQueueTail(IN OUT RTB_QUEUE_HEAD *AicQueueHead, IN AIC_BUFFER *AicBuffer)
|
{
|
pthread_mutex_lock(&AicQueueHead->Lock);
|
ListAddToTail(&AicBuffer->List, &AicQueueHead->List);
|
AicQueueHead->QueueLen++;
|
pthread_mutex_unlock(&AicQueueHead->Lock);
|
}
|
|
/**
|
Queue specified AicBuffer into a AicQueue at list Head.
|
\param [IN OUT] AicQueueHead <RTB_QUEUE_HEAD*> : Aic Queue
|
\param [IN] AicBuffer <AIC_BUFFER*> : Aic buffer to add
|
*/
|
void RtbQueueHead(IN OUT RTB_QUEUE_HEAD *AicQueueHead, IN AIC_BUFFER *AicBuffer)
|
{
|
pthread_mutex_lock(&AicQueueHead->Lock);
|
ListAddToHead(&AicBuffer->List, &AicQueueHead->List);
|
AicQueueHead->QueueLen++;
|
pthread_mutex_unlock(&AicQueueHead->Lock);
|
}
|
|
/**
|
Insert new Aicbuffer in the old buffer
|
\param [IN OUT] AicQueueHead <RTB_QUEUE_HEAD*> : Aic Queue
|
\param [IN] OldAicBuffer <AIC_BUFFER*> : old aic buffer
|
\param [IN] NewAicBuffer <AIC_BUFFER*> : Aic buffer to add
|
*/
|
void RtbInsertBefore(IN OUT RTB_QUEUE_HEAD *AicQueueHead, IN AIC_BUFFER *pOldAicBuffer, IN AIC_BUFFER *pNewAicBuffer)
|
{
|
pthread_mutex_lock(&AicQueueHead->Lock);
|
ListAdd(&pNewAicBuffer->List, pOldAicBuffer->List.Prev, &pOldAicBuffer->List);
|
AicQueueHead->QueueLen++;
|
pthread_mutex_unlock(&AicQueueHead->Lock);
|
}
|
|
/**
|
check whether the buffer is the last node in the queue
|
*/
|
unsigned char RtbNodeIsLast(IN RTB_QUEUE_HEAD* AicQueueHead, IN AIC_BUFFER *pAicBuffer)
|
{
|
AIC_BUFFER* pBuf;
|
pthread_mutex_lock(&AicQueueHead->Lock);
|
|
pBuf = (AIC_BUFFER*)AicQueueHead->List.Prev;
|
if (pBuf == pAicBuffer) {
|
pthread_mutex_unlock(&AicQueueHead->Lock);
|
return true;
|
}
|
pthread_mutex_unlock(&AicQueueHead->Lock);
|
return false;
|
}
|
|
/**
|
get the next buffer node after the specified buffer in the queue
|
if the specified buffer is the last node in the queue , return NULL
|
\param [IN] AicBuffer <AIC_BUFFER*> : Aic Queue
|
\param [IN] AicBuffer <AIC_BUFFER*> : Aic buffer
|
\return node after the specified buffer
|
*/
|
AIC_BUFFER *RtbQueueNextNode(IN RTB_QUEUE_HEAD *AicQueueHead, IN AIC_BUFFER *pAicBuffer)
|
{
|
AIC_BUFFER* pBuf;
|
pthread_mutex_lock(&AicQueueHead->Lock);
|
pBuf = (AIC_BUFFER*)AicQueueHead->List.Prev;
|
if (pBuf == pAicBuffer) {
|
pthread_mutex_unlock(&AicQueueHead->Lock);
|
return NULL; ///< if it is already the last node in the queue , return NULL
|
}
|
pBuf = (AIC_BUFFER*)pAicBuffer->List.Next;
|
pthread_mutex_unlock(&AicQueueHead->Lock);
|
return pBuf; ///< return next node after this node
|
}
|
|
/**
|
Delete specified AicBuffer from a AicQueue.
|
It don't hold spinlock itself, so caller must hold it at someplace.
|
\param [IN OUT] AicQueueHead <RTB_QUEUE_HEAD*> : Aic Queue
|
\param [IN] AicBuffer <AIC_BUFFER*> : Aic buffer to Remove
|
*/
|
void RtbRemoveNode(IN OUT RTB_QUEUE_HEAD *AicQueueHead, IN AIC_BUFFER *AicBuffer)
|
{
|
AicQueueHead->QueueLen--;
|
ListDeleteNode(&AicBuffer->List);
|
}
|
|
/**
|
Get the AicBuffer which is the head of a AicQueue
|
\param [IN OUT] AicQueueHead <RTB_QUEUE_HEAD*> : Aic Queue
|
\return head of the AicQueue , otherwise NULL
|
*/
|
AIC_BUFFER *RtbTopQueue(IN RTB_QUEUE_HEAD *AicQueueHead)
|
{
|
AIC_BUFFER* Rtb = NULL;
|
pthread_mutex_lock(&AicQueueHead->Lock);
|
|
if (RtbQueueIsEmpty(AicQueueHead)) {
|
pthread_mutex_unlock(&AicQueueHead->Lock);
|
return NULL;
|
}
|
|
Rtb = (AIC_BUFFER*)AicQueueHead->List.Next;
|
pthread_mutex_unlock(&AicQueueHead->Lock);
|
|
return Rtb;
|
}
|
|
/**
|
Remove a AicBuffer from specified aicqueue at list tail.
|
\param [IN OUT] AicQueueHead <RTB_QUEUE_HEAD*> : Aic Queue
|
\return removed aicbuffer if succeed, otherwise NULL
|
*/
|
AIC_BUFFER *RtbDequeueTail(IN OUT RTB_QUEUE_HEAD *AicQueueHead)
|
{
|
AIC_BUFFER* Rtb = NULL;
|
|
pthread_mutex_lock(&AicQueueHead->Lock);
|
if (RtbQueueIsEmpty(AicQueueHead)) {
|
pthread_mutex_unlock(&AicQueueHead->Lock);
|
return NULL;
|
}
|
Rtb = (AIC_BUFFER*)AicQueueHead->List.Prev;
|
RtbRemoveNode(AicQueueHead, Rtb);
|
pthread_mutex_unlock(&AicQueueHead->Lock);
|
|
return Rtb;
|
}
|
|
/**
|
Remove a AicBuffer from specified aicqueue at list head.
|
\param [IN OUT] AicQueueHead <RTB_QUEUE_HEAD*> : Aic Queue
|
\return removed aicbuffer if succeed, otherwise NULL
|
*/
|
AIC_BUFFER *RtbDequeueHead(IN OUT RTB_QUEUE_HEAD* AicQueueHead)
|
{
|
AIC_BUFFER* Rtb = NULL;
|
pthread_mutex_lock(&AicQueueHead->Lock);
|
|
if (RtbQueueIsEmpty(AicQueueHead)) {
|
pthread_mutex_unlock(&AicQueueHead->Lock);
|
return NULL;
|
}
|
Rtb = (AIC_BUFFER*)AicQueueHead->List.Next;
|
RtbRemoveNode(AicQueueHead, Rtb);
|
pthread_mutex_unlock(&AicQueueHead->Lock);
|
return Rtb;
|
}
|
|
/**
|
Get current rtb queue's length.
|
\param [IN] AicQueueHead <RTB_QUEUE_HEAD*> : Aic Queue
|
\return current queue's length
|
*/
|
signed long RtbGetQueueLen(IN RTB_QUEUE_HEAD *AicQueueHead)
|
{
|
return AicQueueHead->QueueLen;
|
}
|
|
/**
|
Empty the aicqueue.
|
\param [IN OUT] AicQueueHead <RTB_QUEUE_HEAD*> : Aic Queue
|
*/
|
void RtbEmptyQueue(IN OUT RTB_QUEUE_HEAD *AicQueueHead)
|
{
|
AIC_BUFFER* Rtb = NULL;
|
pthread_mutex_lock(&AicQueueHead->Lock);
|
|
while (!RtbQueueIsEmpty(AicQueueHead)) {
|
Rtb = (AIC_BUFFER*)AicQueueHead->List.Next;
|
RtbRemoveNode(AicQueueHead, Rtb);
|
RtbFree(Rtb);
|
}
|
|
pthread_mutex_unlock(&AicQueueHead->Lock);
|
return;
|
}
|
|
|
///Annie_tmp
|
unsigned char RtbCheckQueueLen(IN RTB_QUEUE_HEAD* AicQueueHead, IN uint8_t Len)
|
{
|
return AicQueueHead->QueueLen < Len ? true : false;
|
}
|
|
/**
|
clone buffer for upper or lower layer, because original buffer should be stored in l2cap
|
\param <AIC_BUFFER* pDataBuffer: original buffer
|
\return cloned buffer
|
*/
|
AIC_BUFFER* RtbCloneBuffer(IN AIC_BUFFER *pDataBuffer)
|
{
|
AIC_BUFFER* pNewBuffer = NULL;
|
if (pDataBuffer) {
|
pNewBuffer = RtbAllocate(pDataBuffer->Length,0);
|
if (!pNewBuffer) {
|
return NULL;
|
}
|
|
if (pDataBuffer && pDataBuffer->Data)
|
memcpy(pNewBuffer->Data, pDataBuffer->Data, pDataBuffer->Length);
|
else {
|
RtbFree(pNewBuffer);
|
return NULL;
|
}
|
|
pNewBuffer->Length = pDataBuffer->Length;
|
}
|
return pNewBuffer;
|
}
|
