evie/android_kernel_oneplus_msm8998
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

ath6kl: remove-typedef HTC_PACKET_QUEUE

Browse source 
remove-typedef -s HTC_PACKET_QUEUE \
	"struct htc_packet_queue" drivers/staging/ath6kl/

Tested-by: Naveen Singh <nsingh@atheros.com>
Signed-off-by: Luis R. Rodriguez <lrodriguez@atheros.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
This commit is contained in:
Luis R. Rodriguez 2011-03-14 10:58:58 -07:00 • committed by Greg Kroah-Hartman
parent c6528e2f0d
commit 6ca0f664e1
14 changed files with 65 additions and 65 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
drivers/staging/ath6kl/htc2/AR6000/ar6k.h
View file

@ -118,7 +118,7 @@ struct ar6k_device {
struct hif_device_mbox_info MailBoxInfo; struct hif_device_mbox_info MailBoxInfo;
HIF_PENDING_EVENTS_FUNC GetPendingEventsFunc; HIF_PENDING_EVENTS_FUNC GetPendingEventsFunc;
void *HTCContext; void *HTCContext;
HTC_PACKET_QUEUE RegisterIOList; struct htc_packet_queue RegisterIOList;
struct ar6k_async_reg_io_buffer RegIOBuffers[AR6K_MAX_REG_IO_BUFFERS]; struct ar6k_async_reg_io_buffer RegIOBuffers[AR6K_MAX_REG_IO_BUFFERS];
void (*TargetFailureCallback)(void *Context); void (*TargetFailureCallback)(void *Context);
int (*MessagePendingCallback)(void *Context, int (*MessagePendingCallback)(void *Context,

18
drivers/staging/ath6kl/htc2/AR6000/ar6k_gmbox_hciuart.c
View file

@ -63,9 +63,9 @@ struct gmbox_proto_hci_uart {
u32 RecvStateFlags; u32 RecvStateFlags;
u32 SendStateFlags; u32 SendStateFlags;
HCI_TRANSPORT_PACKET_TYPE WaitBufferType; HCI_TRANSPORT_PACKET_TYPE WaitBufferType;
HTC_PACKET_QUEUE SendQueue; /* write queue holding HCI Command and ACL packets */ struct htc_packet_queue SendQueue; /* write queue holding HCI Command and ACL packets */
HTC_PACKET_QUEUE HCIACLRecvBuffers; /* recv queue holding buffers for incomming ACL packets */ struct htc_packet_queue HCIACLRecvBuffers; /* recv queue holding buffers for incomming ACL packets */
HTC_PACKET_QUEUE HCIEventBuffers; /* recv queue holding buffers for incomming event packets */ struct htc_packet_queue HCIEventBuffers; /* recv queue holding buffers for incomming event packets */
struct ar6k_device *pDev; struct ar6k_device *pDev;
A_MUTEX_T HCIRxLock; A_MUTEX_T HCIRxLock;
A_MUTEX_T HCITxLock; A_MUTEX_T HCITxLock;
@ -366,7 +366,7 @@ static int HCIUartMessagePending(void *pContext, u8 LookAheadBytes[], int ValidB
LOCK_HCI_RX(pProt); LOCK_HCI_RX(pProt);
} else { } else {
HTC_PACKET_QUEUE *pQueue; struct htc_packet_queue *pQueue;
/* user is using a refill handler that can refill multiple HTC buffers */ /* user is using a refill handler that can refill multiple HTC buffers */
/* select buffer queue */ /* select buffer queue */
@ -483,7 +483,7 @@ static int HCIUartMessagePending(void *pContext, u8 LookAheadBytes[], int ValidB
/* check if we need to refill recv buffers */ /* check if we need to refill recv buffers */
if ((pProt->HCIConfig.pHCIPktRecvRefill != NULL) && !recvRefillCalled) { if ((pProt->HCIConfig.pHCIPktRecvRefill != NULL) && !recvRefillCalled) {
HTC_PACKET_QUEUE *pQueue; struct htc_packet_queue *pQueue;
int watermark; int watermark;
if (pktType == HCI_ACL_TYPE) { if (pktType == HCI_ACL_TYPE) {
@ -514,7 +514,7 @@ static int HCIUartMessagePending(void *pContext, u8 LookAheadBytes[], int ValidB
/* see if we need to recycle the recv buffer */ /* see if we need to recycle the recv buffer */
if (status && (pPacket != NULL)) { if (status && (pPacket != NULL)) {
HTC_PACKET_QUEUE queue; struct htc_packet_queue queue;
if (A_EPROTO == status) { if (A_EPROTO == status) {
DebugDumpBytes(pPacket->pBuffer, totalRecvLength, "Bad HCI-UART Recv packet"); DebugDumpBytes(pPacket->pBuffer, totalRecvLength, "Bad HCI-UART Recv packet");
@ -797,7 +797,7 @@ static int HCITrySend(struct gmbox_proto_hci_uart *pProt, struct htc_packet *pPa
static void FlushSendQueue(struct gmbox_proto_hci_uart *pProt) static void FlushSendQueue(struct gmbox_proto_hci_uart *pProt)
{ {
struct htc_packet *pPacket; struct htc_packet *pPacket;
HTC_PACKET_QUEUE discardQueue; struct htc_packet_queue discardQueue;
INIT_HTC_PACKET_QUEUE(&discardQueue); INIT_HTC_PACKET_QUEUE(&discardQueue);
@ -820,7 +820,7 @@ static void FlushSendQueue(struct gmbox_proto_hci_uart *pProt)
static void FlushRecvBuffers(struct gmbox_proto_hci_uart *pProt) static void FlushRecvBuffers(struct gmbox_proto_hci_uart *pProt)
{ {
HTC_PACKET_QUEUE discardQueue; struct htc_packet_queue discardQueue;
struct htc_packet *pPacket; struct htc_packet *pPacket;
INIT_HTC_PACKET_QUEUE(&discardQueue); INIT_HTC_PACKET_QUEUE(&discardQueue);
@ -1001,7 +1001,7 @@ void HCI_TransportDetach(HCI_TRANSPORT_HANDLE HciTrans)
AR_DEBUG_PRINTF(ATH_DEBUG_TRC,("-HCI_TransportAttach \n")); AR_DEBUG_PRINTF(ATH_DEBUG_TRC,("-HCI_TransportAttach \n"));
} }
int HCI_TransportAddReceivePkts(HCI_TRANSPORT_HANDLE HciTrans, HTC_PACKET_QUEUE *pQueue) int HCI_TransportAddReceivePkts(HCI_TRANSPORT_HANDLE HciTrans, struct htc_packet_queue *pQueue)
{ {
struct gmbox_proto_hci_uart *pProt = (struct gmbox_proto_hci_uart *)HciTrans; struct gmbox_proto_hci_uart *pProt = (struct gmbox_proto_hci_uart *)HciTrans;
int status = 0; int status = 0;

4
drivers/staging/ath6kl/htc2/htc.c
View file

@ -43,14 +43,14 @@ ATH_DEBUG_INSTANTIATE_MODULE_VAR(htc,
static void HTCReportFailure(void *Context); static void HTCReportFailure(void *Context);
static void ResetEndpointStates(HTC_TARGET *target); static void ResetEndpointStates(HTC_TARGET *target);
void HTCFreeControlBuffer(HTC_TARGET *target, struct htc_packet *pPacket, HTC_PACKET_QUEUE *pList) void HTCFreeControlBuffer(HTC_TARGET *target, struct htc_packet *pPacket, struct htc_packet_queue *pList)
{ {
LOCK_HTC(target); LOCK_HTC(target);
HTC_PACKET_ENQUEUE(pList,pPacket); HTC_PACKET_ENQUEUE(pList,pPacket);
UNLOCK_HTC(target); UNLOCK_HTC(target);
} }
struct htc_packet *HTCAllocControlBuffer(HTC_TARGET *target, HTC_PACKET_QUEUE *pList) struct htc_packet *HTCAllocControlBuffer(HTC_TARGET *target, struct htc_packet_queue *pList)
{ {
struct htc_packet *pPacket; struct htc_packet *pPacket;

14
drivers/staging/ath6kl/htc2/htc_internal.h
View file

@ -69,15 +69,15 @@ struct htc_endpoint {
HTC_ENDPOINT_ID Id; HTC_ENDPOINT_ID Id;
HTC_SERVICE_ID ServiceID; /* service ID this endpoint is bound to HTC_SERVICE_ID ServiceID; /* service ID this endpoint is bound to
non-zero value means this endpoint is in use */ non-zero value means this endpoint is in use */
HTC_PACKET_QUEUE TxQueue; /* HTC frame buffer TX queue */ struct htc_packet_queue TxQueue; /* HTC frame buffer TX queue */
HTC_PACKET_QUEUE RxBuffers; /* HTC frame buffer RX list */ struct htc_packet_queue RxBuffers; /* HTC frame buffer RX list */
struct htc_endpoint_credit_dist CreditDist; /* credit distribution structure (exposed to driver layer) */ struct htc_endpoint_credit_dist CreditDist; /* credit distribution structure (exposed to driver layer) */
struct htc_ep_callbacks EpCallBacks; /* callbacks associated with this endpoint */ struct htc_ep_callbacks EpCallBacks; /* callbacks associated with this endpoint */
int MaxTxQueueDepth; /* max depth of the TX queue before we need to int MaxTxQueueDepth; /* max depth of the TX queue before we need to
call driver's full handler */ call driver's full handler */
int MaxMsgLength; /* max length of endpoint message */ int MaxMsgLength; /* max length of endpoint message */
int TxProcessCount; /* reference count to continue tx processing */ int TxProcessCount; /* reference count to continue tx processing */
HTC_PACKET_QUEUE RecvIndicationQueue; /* recv packets ready to be indicated */ struct htc_packet_queue RecvIndicationQueue; /* recv packets ready to be indicated */
int RxProcessCount; /* reference count to allow single processing context */ int RxProcessCount; /* reference count to allow single processing context */
struct _HTC_TARGET *target; /* back pointer to target */ struct _HTC_TARGET *target; /* back pointer to target */
u8 SeqNo; /* TX seq no (helpful) for debugging */ u8 SeqNo; /* TX seq no (helpful) for debugging */
@ -112,8 +112,8 @@ typedef struct _HTC_TARGET {
struct htc_endpoint EndPoint[ENDPOINT_MAX]; struct htc_endpoint EndPoint[ENDPOINT_MAX];
struct htc_control_buffer HTCControlBuffers[NUM_CONTROL_BUFFERS]; struct htc_control_buffer HTCControlBuffers[NUM_CONTROL_BUFFERS];
struct htc_endpoint_credit_dist *EpCreditDistributionListHead; struct htc_endpoint_credit_dist *EpCreditDistributionListHead;
HTC_PACKET_QUEUE ControlBufferTXFreeList; struct htc_packet_queue ControlBufferTXFreeList;
HTC_PACKET_QUEUE ControlBufferRXFreeList; struct htc_packet_queue ControlBufferRXFreeList;
HTC_CREDIT_DIST_CALLBACK DistributeCredits; HTC_CREDIT_DIST_CALLBACK DistributeCredits;
HTC_CREDIT_INIT_CALLBACK InitCredits; HTC_CREDIT_INIT_CALLBACK InitCredits;
void *pCredDistContext; void *pCredDistContext;
@ -165,8 +165,8 @@ typedef struct _HTC_TARGET {
void HTCControlTxComplete(void *Context, struct htc_packet *pPacket); void HTCControlTxComplete(void *Context, struct htc_packet *pPacket);
void HTCControlRecv(void *Context, struct htc_packet *pPacket); void HTCControlRecv(void *Context, struct htc_packet *pPacket);
int HTCWaitforControlMessage(HTC_TARGET *target, struct htc_packet **ppControlPacket); int HTCWaitforControlMessage(HTC_TARGET *target, struct htc_packet **ppControlPacket);
struct htc_packet *HTCAllocControlBuffer(HTC_TARGET *target, HTC_PACKET_QUEUE *pList); struct htc_packet *HTCAllocControlBuffer(HTC_TARGET *target, struct htc_packet_queue *pList);
void HTCFreeControlBuffer(HTC_TARGET *target, struct htc_packet *pPacket, HTC_PACKET_QUEUE *pList); void HTCFreeControlBuffer(HTC_TARGET *target, struct htc_packet *pPacket, struct htc_packet_queue *pList);
int HTCIssueSend(HTC_TARGET *target, struct htc_packet *pPacket); int HTCIssueSend(HTC_TARGET *target, struct htc_packet *pPacket);
void HTCRecvCompleteHandler(void *Context, struct htc_packet *pPacket); void HTCRecvCompleteHandler(void *Context, struct htc_packet *pPacket);
int HTCRecvMessagePendingHandler(void *Context, u32 MsgLookAheads[], int NumLookAheads, bool *pAsyncProc, int *pNumPktsFetched); int HTCRecvMessagePendingHandler(void *Context, u32 MsgLookAheads[], int NumLookAheads, bool *pAsyncProc, int *pNumPktsFetched);

24
drivers/staging/ath6kl/htc2/htc_recv.c
View file

@ -51,7 +51,7 @@
#endif #endif
static void DoRecvCompletion(struct htc_endpoint *pEndpoint, static void DoRecvCompletion(struct htc_endpoint *pEndpoint,
HTC_PACKET_QUEUE *pQueueToIndicate) struct htc_packet_queue *pQueueToIndicate)
{ {
do { do {
@ -434,7 +434,7 @@ static INLINE void HTCAsyncRecvCheckMorePackets(HTC_TARGET *target,
/* unload the recv completion queue */ /* unload the recv completion queue */
static INLINE void DrainRecvIndicationQueue(HTC_TARGET *target, struct htc_endpoint *pEndpoint) static INLINE void DrainRecvIndicationQueue(HTC_TARGET *target, struct htc_endpoint *pEndpoint)
{ {
HTC_PACKET_QUEUE recvCompletions; struct htc_packet_queue recvCompletions;
AR_DEBUG_PRINTF(ATH_DEBUG_RECV, ("+DrainRecvIndicationQueue \n")); AR_DEBUG_PRINTF(ATH_DEBUG_RECV, ("+DrainRecvIndicationQueue \n"));
@ -690,7 +690,7 @@ static int AllocAndPrepareRxPackets(HTC_TARGET *target,
u32 LookAheads[], u32 LookAheads[],
int Messages, int Messages,
struct htc_endpoint *pEndpoint, struct htc_endpoint *pEndpoint,
HTC_PACKET_QUEUE *pQueue) struct htc_packet_queue *pQueue)
{ {
int status = 0; int status = 0;
struct htc_packet *pPacket; struct htc_packet *pPacket;
@ -889,7 +889,7 @@ static void HTCAsyncRecvScatterCompletion(struct hif_scatter_req *pScatterReq)
HTC_TARGET *target = (HTC_TARGET *)pScatterReq->Context; HTC_TARGET *target = (HTC_TARGET *)pScatterReq->Context;
int status; int status;
bool partialBundle = false; bool partialBundle = false;
HTC_PACKET_QUEUE localRecvQueue; struct htc_packet_queue localRecvQueue;
bool procError = false; bool procError = false;
AR_DEBUG_PRINTF(ATH_DEBUG_RECV,("+HTCAsyncRecvScatterCompletion TotLen: %d Entries: %d\n", AR_DEBUG_PRINTF(ATH_DEBUG_RECV,("+HTCAsyncRecvScatterCompletion TotLen: %d Entries: %d\n",
@ -985,8 +985,8 @@ static void HTCAsyncRecvScatterCompletion(struct hif_scatter_req *pScatterReq)
} }
static int HTCIssueRecvPacketBundle(HTC_TARGET *target, static int HTCIssueRecvPacketBundle(HTC_TARGET *target,
HTC_PACKET_QUEUE *pRecvPktQueue, struct htc_packet_queue *pRecvPktQueue,
HTC_PACKET_QUEUE *pSyncCompletionQueue, struct htc_packet_queue *pSyncCompletionQueue,
int *pNumPacketsFetched, int *pNumPacketsFetched,
bool PartialBundle) bool PartialBundle)
{ {
@ -1126,7 +1126,7 @@ int HTCRecvMessagePendingHandler(void *Context, u32 MsgLookAheads[], int NumLook
bool asyncProc = false; bool asyncProc = false;
u32 lookAheads[HTC_HOST_MAX_MSG_PER_BUNDLE]; u32 lookAheads[HTC_HOST_MAX_MSG_PER_BUNDLE];
int pktsFetched; int pktsFetched;
HTC_PACKET_QUEUE recvPktQueue, syncCompletedPktsQueue; struct htc_packet_queue recvPktQueue, syncCompletedPktsQueue;
bool partialBundle; bool partialBundle;
HTC_ENDPOINT_ID id; HTC_ENDPOINT_ID id;
int totalFetched = 0; int totalFetched = 0;
@ -1283,7 +1283,7 @@ int HTCRecvMessagePendingHandler(void *Context, u32 MsgLookAheads[], int NumLook
/* unload sync completion queue */ /* unload sync completion queue */
while (!HTC_QUEUE_EMPTY(&syncCompletedPktsQueue)) { while (!HTC_QUEUE_EMPTY(&syncCompletedPktsQueue)) {
HTC_PACKET_QUEUE container; struct htc_packet_queue container;
pPacket = HTC_PACKET_DEQUEUE(&syncCompletedPktsQueue); pPacket = HTC_PACKET_DEQUEUE(&syncCompletedPktsQueue);
A_ASSERT(pPacket != NULL); A_ASSERT(pPacket != NULL);
@ -1385,7 +1385,7 @@ int HTCRecvMessagePendingHandler(void *Context, u32 MsgLookAheads[], int NumLook
return status; return status;
} }
int HTCAddReceivePktMultiple(HTC_HANDLE HTCHandle, HTC_PACKET_QUEUE *pPktQueue) int HTCAddReceivePktMultiple(HTC_HANDLE HTCHandle, struct htc_packet_queue *pPktQueue)
{ {
HTC_TARGET *target = GET_HTC_TARGET_FROM_HANDLE(HTCHandle); HTC_TARGET *target = GET_HTC_TARGET_FROM_HANDLE(HTCHandle);
struct htc_endpoint *pEndpoint; struct htc_endpoint *pEndpoint;
@ -1457,7 +1457,7 @@ int HTCAddReceivePktMultiple(HTC_HANDLE HTCHandle, HTC_PACKET_QUEUE *pPktQueue)
/* Makes a buffer available to the HTC module */ /* Makes a buffer available to the HTC module */
int HTCAddReceivePkt(HTC_HANDLE HTCHandle, struct htc_packet *pPacket) int HTCAddReceivePkt(HTC_HANDLE HTCHandle, struct htc_packet *pPacket)
{ {
HTC_PACKET_QUEUE queue; struct htc_packet_queue queue;
INIT_HTC_PACKET_QUEUE_AND_ADD(&queue,pPacket); INIT_HTC_PACKET_QUEUE_AND_ADD(&queue,pPacket);
return HTCAddReceivePktMultiple(HTCHandle, &queue); return HTCAddReceivePktMultiple(HTCHandle, &queue);
} }
@ -1486,10 +1486,10 @@ void HTCUnblockRecv(HTC_HANDLE HTCHandle)
} }
} }
static void HTCFlushRxQueue(HTC_TARGET *target, struct htc_endpoint *pEndpoint, HTC_PACKET_QUEUE *pQueue) static void HTCFlushRxQueue(HTC_TARGET *target, struct htc_endpoint *pEndpoint, struct htc_packet_queue *pQueue)
{ {
struct htc_packet *pPacket; struct htc_packet *pPacket;
HTC_PACKET_QUEUE container; struct htc_packet_queue container;
LOCK_HTC_RX(target); LOCK_HTC_RX(target);

22
drivers/staging/ath6kl/htc2/htc_send.c
View file

@ -44,7 +44,7 @@ typedef enum _HTC_SEND_QUEUE_RESULT {
} }
static void DoSendCompletion(struct htc_endpoint *pEndpoint, static void DoSendCompletion(struct htc_endpoint *pEndpoint,
HTC_PACKET_QUEUE *pQueueToIndicate) struct htc_packet_queue *pQueueToIndicate)
{ {
do { do {
@ -105,7 +105,7 @@ static void HTCSendPktCompletionHandler(void *Context, struct htc_packet *pPacke
{ {
HTC_TARGET *target = (HTC_TARGET *)Context; HTC_TARGET *target = (HTC_TARGET *)Context;
struct htc_endpoint *pEndpoint = &target->EndPoint[pPacket->Endpoint]; struct htc_endpoint *pEndpoint = &target->EndPoint[pPacket->Endpoint];
HTC_PACKET_QUEUE container; struct htc_packet_queue container;
CompleteSentPacket(target,pEndpoint,pPacket); CompleteSentPacket(target,pEndpoint,pPacket);
INIT_HTC_PACKET_QUEUE_AND_ADD(&container,pPacket); INIT_HTC_PACKET_QUEUE_AND_ADD(&container,pPacket);
@ -148,7 +148,7 @@ int HTCIssueSend(HTC_TARGET *target, struct htc_packet *pPacket)
/* get HTC send packets from the TX queue on an endpoint */ /* get HTC send packets from the TX queue on an endpoint */
static INLINE void GetHTCSendPackets(HTC_TARGET *target, static INLINE void GetHTCSendPackets(HTC_TARGET *target,
struct htc_endpoint *pEndpoint, struct htc_endpoint *pEndpoint,
HTC_PACKET_QUEUE *pQueue) struct htc_packet_queue *pQueue)
{ {
int creditsRequired; int creditsRequired;
int remainder; int remainder;
@ -271,7 +271,7 @@ static void HTCAsyncSendScatterCompletion(struct hif_scatter_req *pScatterReq)
struct htc_endpoint *pEndpoint = (struct htc_endpoint *)pScatterReq->Context; struct htc_endpoint *pEndpoint = (struct htc_endpoint *)pScatterReq->Context;
HTC_TARGET *target = (HTC_TARGET *)pEndpoint->target; HTC_TARGET *target = (HTC_TARGET *)pEndpoint->target;
int status = 0; int status = 0;
HTC_PACKET_QUEUE sendCompletes; struct htc_packet_queue sendCompletes;
INIT_HTC_PACKET_QUEUE(&sendCompletes); INIT_HTC_PACKET_QUEUE(&sendCompletes);
@ -310,7 +310,7 @@ static void HTCAsyncSendScatterCompletion(struct hif_scatter_req *pScatterReq)
* - we drop below the minimum number of messages for a bundle * - we drop below the minimum number of messages for a bundle
* */ * */
static void HTCIssueSendBundle(struct htc_endpoint *pEndpoint, static void HTCIssueSendBundle(struct htc_endpoint *pEndpoint,
HTC_PACKET_QUEUE *pQueue, struct htc_packet_queue *pQueue,
int *pBundlesSent, int *pBundlesSent,
int *pTotalBundlesPkts) int *pTotalBundlesPkts)
{ {
@ -479,9 +479,9 @@ static void HTCIssueSendBundle(struct htc_endpoint *pEndpoint,
* this function returns the result of the attempt to send a queue of HTC packets */ * this function returns the result of the attempt to send a queue of HTC packets */
static HTC_SEND_QUEUE_RESULT HTCTrySend(HTC_TARGET *target, static HTC_SEND_QUEUE_RESULT HTCTrySend(HTC_TARGET *target,
struct htc_endpoint *pEndpoint, struct htc_endpoint *pEndpoint,
HTC_PACKET_QUEUE *pCallersSendQueue) struct htc_packet_queue *pCallersSendQueue)
{ {
HTC_PACKET_QUEUE sendQueue; /* temp queue to hold packets at various stages */ struct htc_packet_queue sendQueue; /* temp queue to hold packets at various stages */
struct htc_packet *pPacket; struct htc_packet *pPacket;
int bundlesSent; int bundlesSent;
int pktsInBundles; int pktsInBundles;
@ -668,7 +668,7 @@ static HTC_SEND_QUEUE_RESULT HTCTrySend(HTC_TARGET *target,
return HTC_SEND_QUEUE_OK; return HTC_SEND_QUEUE_OK;
} }
int HTCSendPktsMultiple(HTC_HANDLE HTCHandle, HTC_PACKET_QUEUE *pPktQueue) int HTCSendPktsMultiple(HTC_HANDLE HTCHandle, struct htc_packet_queue *pPktQueue)
{ {
HTC_TARGET *target = GET_HTC_TARGET_FROM_HANDLE(HTCHandle); HTC_TARGET *target = GET_HTC_TARGET_FROM_HANDLE(HTCHandle);
struct htc_endpoint *pEndpoint; struct htc_endpoint *pEndpoint;
@ -711,7 +711,7 @@ int HTCSendPktsMultiple(HTC_HANDLE HTCHandle, HTC_PACKET_QUEUE *pPktQueue)
/* HTC API - HTCSendPkt */ /* HTC API - HTCSendPkt */
int HTCSendPkt(HTC_HANDLE HTCHandle, struct htc_packet *pPacket) int HTCSendPkt(HTC_HANDLE HTCHandle, struct htc_packet *pPacket)
{ {
HTC_PACKET_QUEUE queue; struct htc_packet_queue queue;
AR_DEBUG_PRINTF(ATH_DEBUG_SEND, AR_DEBUG_PRINTF(ATH_DEBUG_SEND,
("+-HTCSendPkt: Enter endPointId: %d, buffer: 0x%lX, length: %d \n", ("+-HTCSendPkt: Enter endPointId: %d, buffer: 0x%lX, length: %d \n",
@ -841,8 +841,8 @@ void HTCProcessCreditRpt(HTC_TARGET *target, HTC_CREDIT_REPORT *pRpt, int NumEnt
static void HTCFlushEndpointTX(HTC_TARGET *target, struct htc_endpoint *pEndpoint, HTC_TX_TAG Tag) static void HTCFlushEndpointTX(HTC_TARGET *target, struct htc_endpoint *pEndpoint, HTC_TX_TAG Tag)
{ {
struct htc_packet *pPacket; struct htc_packet *pPacket;
HTC_PACKET_QUEUE discardQueue; struct htc_packet_queue discardQueue;
HTC_PACKET_QUEUE container; struct htc_packet_queue container;
/* initialize the discard queue */ /* initialize the discard queue */
INIT_HTC_PACKET_QUEUE(&discardQueue); INIT_HTC_PACKET_QUEUE(&discardQueue);

2
drivers/staging/ath6kl/include/hci_transport_api.h
View file

@ -141,7 +141,7 @@ void HCI_TransportDetach(HCI_TRANSPORT_HANDLE HciTrans);
@example: @example:
@see also: @see also:
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
int HCI_TransportAddReceivePkts(HCI_TRANSPORT_HANDLE HciTrans, HTC_PACKET_QUEUE *pQueue); int HCI_TransportAddReceivePkts(HCI_TRANSPORT_HANDLE HciTrans, struct htc_packet_queue *pQueue);
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
@desc: Send an HCI packet packet @desc: Send an HCI packet packet

16
drivers/staging/ath6kl/include/htc_api.h
View file

@ -51,21 +51,21 @@ struct htc_init_info {
/* per service connection send completion */ /* per service connection send completion */
typedef void (*HTC_EP_SEND_PKT_COMPLETE)(void *,struct htc_packet *); typedef void (*HTC_EP_SEND_PKT_COMPLETE)(void *,struct htc_packet *);
/* per service connection callback when a plurality of packets have been sent /* per service connection callback when a plurality of packets have been sent
* The HTC_PACKET_QUEUE is a temporary queue object (e.g. freed on return from the callback) * The struct htc_packet_queue is a temporary queue object (e.g. freed on return from the callback)
* to hold a list of completed send packets. * to hold a list of completed send packets.
* If the handler cannot fully traverse the packet queue before returning, it should * If the handler cannot fully traverse the packet queue before returning, it should
* transfer the items of the queue into the caller's private queue using: * transfer the items of the queue into the caller's private queue using:
* HTC_PACKET_ENQUEUE() */ * HTC_PACKET_ENQUEUE() */
typedef void (*HTC_EP_SEND_PKT_COMP_MULTIPLE)(void *,HTC_PACKET_QUEUE *); typedef void (*HTC_EP_SEND_PKT_COMP_MULTIPLE)(void *,struct htc_packet_queue *);
/* per service connection pkt received */ /* per service connection pkt received */
typedef void (*HTC_EP_RECV_PKT)(void *,struct htc_packet *); typedef void (*HTC_EP_RECV_PKT)(void *,struct htc_packet *);
/* per service connection callback when a plurality of packets are received /* per service connection callback when a plurality of packets are received
* The HTC_PACKET_QUEUE is a temporary queue object (e.g. freed on return from the callback) * The struct htc_packet_queue is a temporary queue object (e.g. freed on return from the callback)
* to hold a list of recv packets. * to hold a list of recv packets.
* If the handler cannot fully traverse the packet queue before returning, it should * If the handler cannot fully traverse the packet queue before returning, it should
* transfer the items of the queue into the caller's private queue using: * transfer the items of the queue into the caller's private queue using:
* HTC_PACKET_ENQUEUE() */ * HTC_PACKET_ENQUEUE() */
typedef void (*HTC_EP_RECV_PKT_MULTIPLE)(void *,HTC_PACKET_QUEUE *); typedef void (*HTC_EP_RECV_PKT_MULTIPLE)(void *,struct htc_packet_queue *);
/* Optional per service connection receive buffer re-fill callback, /* Optional per service connection receive buffer re-fill callback,
* On some OSes (like Linux) packets are allocated from a global pool and indicated up * On some OSes (like Linux) packets are allocated from a global pool and indicated up
@ -502,7 +502,7 @@ void HTCUnblockRecv(HTC_HANDLE HTCHandle);
@return: 0 @return: 0
@notes: Caller must initialize each packet using SET_HTC_PACKET_INFO_TX() macro. @notes: Caller must initialize each packet using SET_HTC_PACKET_INFO_TX() macro.
The queue must only contain packets directed at the same endpoint. The queue must only contain packets directed at the same endpoint.
Caller supplies a pointer to an HTC_PACKET_QUEUE structure holding the TX packets in FIFO order. Caller supplies a pointer to an struct htc_packet_queue structure holding the TX packets in FIFO order.
This API will remove the packets from the pkt queue and place them into the HTC Tx Queue This API will remove the packets from the pkt queue and place them into the HTC Tx Queue
and bundle messages where possible. and bundle messages where possible.
The caller may allocate the pkt queue on the stack to hold the packets. The caller may allocate the pkt queue on the stack to hold the packets.
@ -511,7 +511,7 @@ void HTCUnblockRecv(HTC_HANDLE HTCHandle);
@example: @example:
@see also: HTCFlushEndpoint @see also: HTCFlushEndpoint
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
int HTCSendPktsMultiple(HTC_HANDLE HTCHandle, HTC_PACKET_QUEUE *pPktQueue); int HTCSendPktsMultiple(HTC_HANDLE HTCHandle, struct htc_packet_queue *pPktQueue);
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
@desc: Add multiple receive packets to HTC @desc: Add multiple receive packets to HTC
@ -523,14 +523,14 @@ int HTCSendPktsMultiple(HTC_HANDLE HTCHandle, HTC_PACKET_QUEUE *pPktQueue);
@notes: user must supply HTC packets for capturing incomming HTC frames. The caller @notes: user must supply HTC packets for capturing incomming HTC frames. The caller
must initialize each HTC packet using the SET_HTC_PACKET_INFO_RX_REFILL() must initialize each HTC packet using the SET_HTC_PACKET_INFO_RX_REFILL()
macro. The queue must only contain recv packets for the same endpoint. macro. The queue must only contain recv packets for the same endpoint.
Caller supplies a pointer to an HTC_PACKET_QUEUE structure holding the recv packet. Caller supplies a pointer to an struct htc_packet_queue structure holding the recv packet.
This API will remove the packets from the pkt queue and place them into internal This API will remove the packets from the pkt queue and place them into internal
recv packet list. recv packet list.
The caller may allocate the pkt queue on the stack to hold the packets. The caller may allocate the pkt queue on the stack to hold the packets.
@example: @example:
@see also: @see also:
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
int HTCAddReceivePktMultiple(HTC_HANDLE HTCHandle, HTC_PACKET_QUEUE *pPktQueue); int HTCAddReceivePktMultiple(HTC_HANDLE HTCHandle, struct htc_packet_queue *pPktQueue);
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
@desc: Check if an endpoint is marked active @desc: Check if an endpoint is marked active

10
drivers/staging/ath6kl/include/htc_packet.h
View file

@ -139,10 +139,10 @@ struct htc_packet {
} }
/* HTC Packet Queueing Macros */ /* HTC Packet Queueing Macros */
typedef struct _HTC_PACKET_QUEUE { struct htc_packet_queue {
struct dl_list QueueHead; struct dl_list QueueHead;
int Depth; int Depth;
} HTC_PACKET_QUEUE; };
/* initialize queue */ /* initialize queue */
#define INIT_HTC_PACKET_QUEUE(pQ) \ #define INIT_HTC_PACKET_QUEUE(pQ) \
@ -165,7 +165,7 @@ typedef struct _HTC_PACKET_QUEUE {
/* test if a queue is empty */ /* test if a queue is empty */
#define HTC_QUEUE_EMPTY(pQ) ((pQ)->Depth == 0) #define HTC_QUEUE_EMPTY(pQ) ((pQ)->Depth == 0)
/* get packet at head without removing it */ /* get packet at head without removing it */
static INLINE struct htc_packet *HTC_GET_PKT_AT_HEAD(HTC_PACKET_QUEUE *queue) { static INLINE struct htc_packet *HTC_GET_PKT_AT_HEAD(struct htc_packet_queue *queue) {
if (queue->Depth == 0) { if (queue->Depth == 0) {
return NULL; return NULL;
} }
@ -179,7 +179,7 @@ static INLINE struct htc_packet *HTC_GET_PKT_AT_HEAD(HTC_PACKET_QUEUE *queue)
} }
/* dequeue an HTC packet from the head of the queue */ /* dequeue an HTC packet from the head of the queue */
static INLINE struct htc_packet *HTC_PACKET_DEQUEUE(HTC_PACKET_QUEUE *queue) { static INLINE struct htc_packet *HTC_PACKET_DEQUEUE(struct htc_packet_queue *queue) {
struct dl_list *pItem = DL_ListRemoveItemFromHead(&queue->QueueHead); struct dl_list *pItem = DL_ListRemoveItemFromHead(&queue->QueueHead);
if (pItem != NULL) { if (pItem != NULL) {
queue->Depth--; queue->Depth--;
@ -189,7 +189,7 @@ static INLINE struct htc_packet *HTC_PACKET_DEQUEUE(HTC_PACKET_QUEUE *queue) {
} }
/* dequeue an HTC packet from the tail of the queue */ /* dequeue an HTC packet from the tail of the queue */
static INLINE struct htc_packet *HTC_PACKET_DEQUEUE_TAIL(HTC_PACKET_QUEUE *queue) { static INLINE struct htc_packet *HTC_PACKET_DEQUEUE_TAIL(struct htc_packet_queue *queue) {
struct dl_list *pItem = DL_ListRemoveItemFromTail(&queue->QueueHead); struct dl_list *pItem = DL_ListRemoveItemFromTail(&queue->QueueHead);
if (pItem != NULL) { if (pItem != NULL) {
queue->Depth--; queue->Depth--;

8
drivers/staging/ath6kl/os/linux/ar6000_drv.c
View file

@ -317,7 +317,7 @@ static void ar6000_rx(void *Context, struct htc_packet *pPacket);
static void ar6000_rx_refill(void *Context,HTC_ENDPOINT_ID Endpoint); static void ar6000_rx_refill(void *Context,HTC_ENDPOINT_ID Endpoint);
static void ar6000_tx_complete(void *Context, HTC_PACKET_QUEUE *pPackets); static void ar6000_tx_complete(void *Context, struct htc_packet_queue *pPackets);
static HTC_SEND_FULL_ACTION ar6000_tx_queue_full(void *Context, struct htc_packet *pPacket); static HTC_SEND_FULL_ACTION ar6000_tx_queue_full(void *Context, struct htc_packet *pPacket);
@ -3461,7 +3461,7 @@ static HTC_SEND_FULL_ACTION ar6000_tx_queue_full(void *Context, struct htc_packe
static void static void
ar6000_tx_complete(void *Context, HTC_PACKET_QUEUE *pPacketQueue) ar6000_tx_complete(void *Context, struct htc_packet_queue *pPacketQueue)
{ {
AR_SOFTC_T *ar = (AR_SOFTC_T *)Context; AR_SOFTC_T *ar = (AR_SOFTC_T *)Context;
u32 mapNo = 0; u32 mapNo = 0;
@ -3992,7 +3992,7 @@ ar6000_rx_refill(void *Context, HTC_ENDPOINT_ID Endpoint)
int RxBuffers; int RxBuffers;
int buffersToRefill; int buffersToRefill;
struct htc_packet *pPacket; struct htc_packet *pPacket;
HTC_PACKET_QUEUE queue; struct htc_packet_queue queue;
buffersToRefill = (int)AR6000_MAX_RX_BUFFERS - buffersToRefill = (int)AR6000_MAX_RX_BUFFERS -
HTCGetNumRecvBuffers(ar->arHtcTarget, Endpoint); HTCGetNumRecvBuffers(ar->arHtcTarget, Endpoint);
@ -6323,7 +6323,7 @@ static void DoHTCSendPktsTest(AR_SOFTC_T *ar, int MapNo, HTC_ENDPOINT_ID eid, st
struct sk_buff *new_skb; struct sk_buff *new_skb;
int i; int i;
int pkts = 0; int pkts = 0;
HTC_PACKET_QUEUE pktQueue; struct htc_packet_queue pktQueue;
EPPING_HEADER *eppingHdr; EPPING_HEADER *eppingHdr;
eppingHdr = A_NETBUF_DATA(dupskb); eppingHdr = A_NETBUF_DATA(dupskb);

2
drivers/staging/ath6kl/os/linux/export_hci_transport.c
View file

@ -38,7 +38,7 @@
HCI_TRANSPORT_HANDLE (*_HCI_TransportAttach)(void *HTCHandle, struct hci_transport_config_info *pInfo); HCI_TRANSPORT_HANDLE (*_HCI_TransportAttach)(void *HTCHandle, struct hci_transport_config_info *pInfo);
void (*_HCI_TransportDetach)(HCI_TRANSPORT_HANDLE HciTrans); void (*_HCI_TransportDetach)(HCI_TRANSPORT_HANDLE HciTrans);
int (*_HCI_TransportAddReceivePkts)(HCI_TRANSPORT_HANDLE HciTrans, HTC_PACKET_QUEUE *pQueue); int (*_HCI_TransportAddReceivePkts)(HCI_TRANSPORT_HANDLE HciTrans, struct htc_packet_queue *pQueue);
int (*_HCI_TransportSendPkt)(HCI_TRANSPORT_HANDLE HciTrans, struct htc_packet *pPacket, bool Synchronous); int (*_HCI_TransportSendPkt)(HCI_TRANSPORT_HANDLE HciTrans, struct htc_packet *pPacket, bool Synchronous);
void (*_HCI_TransportStop)(HCI_TRANSPORT_HANDLE HciTrans); void (*_HCI_TransportStop)(HCI_TRANSPORT_HANDLE HciTrans);
int (*_HCI_TransportStart)(HCI_TRANSPORT_HANDLE HciTrans); int (*_HCI_TransportStart)(HCI_TRANSPORT_HANDLE HciTrans);

4
drivers/staging/ath6kl/os/linux/hci_bridge.c
View file

@ -79,7 +79,7 @@ struct ar6k_hci_bridge_info {
struct hci_dev *pBtStackHCIDev; /* BT Stack HCI dev */ struct hci_dev *pBtStackHCIDev; /* BT Stack HCI dev */
bool HciNormalMode; /* Actual HCI mode enabled (non-TEST)*/ bool HciNormalMode; /* Actual HCI mode enabled (non-TEST)*/
bool HciRegistered; /* HCI device registered with stack */ bool HciRegistered; /* HCI device registered with stack */
HTC_PACKET_QUEUE HTCPacketStructHead; struct htc_packet_queue HTCPacketStructHead;
u8 *pHTCStructAlloc; u8 *pHTCStructAlloc;
spinlock_t BridgeLock; spinlock_t BridgeLock;
#ifdef EXPORT_HCI_BRIDGE_INTERFACE #ifdef EXPORT_HCI_BRIDGE_INTERFACE
@ -163,7 +163,7 @@ static void RefillRecvBuffers(struct ar6k_hci_bridge_info *pHcidevInfo,
{ {
int length, i; int length, i;
void *osBuf = NULL; void *osBuf = NULL;
HTC_PACKET_QUEUE queue; struct htc_packet_queue queue;
struct htc_packet *pPacket; struct htc_packet *pPacket;
INIT_HTC_PACKET_QUEUE(&queue); INIT_HTC_PACKET_QUEUE(&queue);

2
drivers/staging/ath6kl/os/linux/include/ar6000_drv.h
View file

@ -586,7 +586,7 @@ typedef struct ar6_softc {
u16 ap_beacon_interval; u16 ap_beacon_interval;
u16 arRTS; u16 arRTS;
u16 arACS; /* AP mode - Auto Channel Selection */ u16 arACS; /* AP mode - Auto Channel Selection */
HTC_PACKET_QUEUE amsdu_rx_buffer_queue; struct htc_packet_queue amsdu_rx_buffer_queue;
bool bIsDestroyProgress; /* flag to indicate ar6k destroy is in progress */ bool bIsDestroyProgress; /* flag to indicate ar6k destroy is in progress */
A_TIMER disconnect_timer; A_TIMER disconnect_timer;
u8 rxMetaVersion; u8 rxMetaVersion;

2
drivers/staging/ath6kl/os/linux/include/export_hci_transport.h
View file

@ -27,7 +27,7 @@
extern HCI_TRANSPORT_HANDLE (*_HCI_TransportAttach)(void *HTCHandle, struct hci_transport_config_info *pInfo); extern HCI_TRANSPORT_HANDLE (*_HCI_TransportAttach)(void *HTCHandle, struct hci_transport_config_info *pInfo);
extern void (*_HCI_TransportDetach)(HCI_TRANSPORT_HANDLE HciTrans); extern void (*_HCI_TransportDetach)(HCI_TRANSPORT_HANDLE HciTrans);
extern int (*_HCI_TransportAddReceivePkts)(HCI_TRANSPORT_HANDLE HciTrans, HTC_PACKET_QUEUE *pQueue); extern int (*_HCI_TransportAddReceivePkts)(HCI_TRANSPORT_HANDLE HciTrans, struct htc_packet_queue *pQueue);
extern int (*_HCI_TransportSendPkt)(HCI_TRANSPORT_HANDLE HciTrans, struct htc_packet *pPacket, bool Synchronous); extern int (*_HCI_TransportSendPkt)(HCI_TRANSPORT_HANDLE HciTrans, struct htc_packet *pPacket, bool Synchronous);
extern void (*_HCI_TransportStop)(HCI_TRANSPORT_HANDLE HciTrans); extern void (*_HCI_TransportStop)(HCI_TRANSPORT_HANDLE HciTrans);
extern int (*_HCI_TransportStart)(HCI_TRANSPORT_HANDLE HciTrans); extern int (*_HCI_TransportStart)(HCI_TRANSPORT_HANDLE HciTrans);