| 1 | /* |
| 2 | * |
| 3 | * Copyright (c) 2007 Atheros Communications Inc. |
| 4 | * All rights reserved. |
| 5 | * |
| 6 | * |
| 7 | * This program is free software; you can redistribute it and/or modify |
| 8 | * it under the terms of the GNU General Public License version 2 as |
| 9 | * published by the Free Software Foundation; |
| 10 | * |
| 11 | * Software distributed under the License is distributed on an "AS |
| 12 | * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or |
| 13 | * implied. See the License for the specific language governing |
| 14 | * rights and limitations under the License. |
| 15 | * |
| 16 | * |
| 17 | * |
| 18 | */ |
| 19 | |
| 20 | #include "htc_internal.h" |
| 21 | |
| 22 | #define HTCIssueRecv(t, p) \ |
| 23 | DevRecvPacket(&(t)->Device, \ |
| 24 | (p), \ |
| 25 | (p)->ActualLength) |
| 26 | |
| 27 | #define DO_RCV_COMPLETION(t,p,e) \ |
| 28 | { \ |
| 29 | if ((p)->ActualLength > 0) { \ |
| 30 | AR_DEBUG_PRINTF(ATH_DEBUG_RECV, (" completing packet 0x%X (%d bytes) on ep : %d \n", \ |
| 31 | (A_UINT32)(p), (p)->ActualLength, (p)->Endpoint)); \ |
| 32 | (e)->EpCallBacks.EpRecv((e)->EpCallBacks.pContext, \ |
| 33 | (p)); \ |
| 34 | } else { \ |
| 35 | AR_DEBUG_PRINTF(ATH_DEBUG_RECV, (" recycling empty packet \n")); \ |
| 36 | HTC_RECYCLE_RX_PKT((t), (p)); \ |
| 37 | } \ |
| 38 | } |
| 39 | |
| 40 | #ifdef HTC_EP_STAT_PROFILING |
| 41 | #define HTC_RX_STAT_PROFILE(t,ep,lookAhead) \ |
| 42 | { \ |
| 43 | LOCK_HTC_RX((t)); \ |
| 44 | INC_HTC_EP_STAT((ep), RxReceived, 1); \ |
| 45 | if ((lookAhead) != 0) { \ |
| 46 | INC_HTC_EP_STAT((ep), RxLookAheads, 1); \ |
| 47 | } \ |
| 48 | UNLOCK_HTC_RX((t)); \ |
| 49 | } |
| 50 | #else |
| 51 | #define HTC_RX_STAT_PROFILE(t,ep,lookAhead) |
| 52 | #endif |
| 53 | |
| 54 | static INLINE A_STATUS HTCProcessTrailer(HTC_TARGET *target, |
| 55 | A_UINT8 *pBuffer, |
| 56 | int Length, |
| 57 | A_UINT32 *pNextLookAhead, |
| 58 | HTC_ENDPOINT_ID FromEndpoint) |
| 59 | { |
| 60 | HTC_RECORD_HDR *pRecord; |
| 61 | A_UINT8 *pRecordBuf; |
| 62 | HTC_LOOKAHEAD_REPORT *pLookAhead; |
| 63 | A_UINT8 *pOrigBuffer; |
| 64 | int origLength; |
| 65 | A_STATUS status; |
| 66 | |
| 67 | AR_DEBUG_PRINTF(ATH_DEBUG_RECV, ("+HTCProcessTrailer (length:%d) \n", Length)); |
| 68 | |
| 69 | if (AR_DEBUG_LVL_CHECK(ATH_DEBUG_RECV)) { |
| 70 | AR_DEBUG_PRINTBUF(pBuffer,Length,"Recv Trailer"); |
| 71 | } |
| 72 | |
| 73 | pOrigBuffer = pBuffer; |
| 74 | origLength = Length; |
| 75 | status = A_OK; |
| 76 | |
| 77 | while (Length > 0) { |
| 78 | |
| 79 | if (Length < sizeof(HTC_RECORD_HDR)) { |
| 80 | status = A_EPROTO; |
| 81 | break; |
| 82 | } |
| 83 | /* these are byte aligned structs */ |
| 84 | pRecord = (HTC_RECORD_HDR *)pBuffer; |
| 85 | Length -= sizeof(HTC_RECORD_HDR); |
| 86 | pBuffer += sizeof(HTC_RECORD_HDR); |
| 87 | |
| 88 | if (pRecord->Length > Length) { |
| 89 | /* no room left in buffer for record */ |
| 90 | AR_DEBUG_PRINTF(ATH_DEBUG_ERR, |
| 91 | (" invalid record length: %d (id:%d) buffer has: %d bytes left \n", |
| 92 | pRecord->Length, pRecord->RecordID, Length)); |
| 93 | status = A_EPROTO; |
| 94 | break; |
| 95 | } |
| 96 | /* start of record follows the header */ |
| 97 | pRecordBuf = pBuffer; |
| 98 | |
| 99 | switch (pRecord->RecordID) { |
| 100 | case HTC_RECORD_CREDITS: |
| 101 | AR_DEBUG_ASSERT(pRecord->Length >= sizeof(HTC_CREDIT_REPORT)); |
| 102 | HTCProcessCreditRpt(target, |
| 103 | (HTC_CREDIT_REPORT *)pRecordBuf, |
| 104 | pRecord->Length / (sizeof(HTC_CREDIT_REPORT)), |
| 105 | FromEndpoint); |
| 106 | break; |
| 107 | case HTC_RECORD_LOOKAHEAD: |
| 108 | AR_DEBUG_ASSERT(pRecord->Length >= sizeof(HTC_LOOKAHEAD_REPORT)); |
| 109 | pLookAhead = (HTC_LOOKAHEAD_REPORT *)pRecordBuf; |
| 110 | if ((pLookAhead->PreValid == ((~pLookAhead->PostValid) & 0xFF)) && |
| 111 | (pNextLookAhead != NULL)) { |
| 112 | |
| 113 | AR_DEBUG_PRINTF(ATH_DEBUG_RECV, |
| 114 | (" LookAhead Report Found (pre valid:0x%X, post valid:0x%X) \n", |
| 115 | pLookAhead->PreValid, |
| 116 | pLookAhead->PostValid)); |
| 117 | |
| 118 | /* look ahead bytes are valid, copy them over */ |
| 119 | ((A_UINT8 *)pNextLookAhead)[0] = pLookAhead->LookAhead[0]; |
| 120 | ((A_UINT8 *)pNextLookAhead)[1] = pLookAhead->LookAhead[1]; |
| 121 | ((A_UINT8 *)pNextLookAhead)[2] = pLookAhead->LookAhead[2]; |
| 122 | ((A_UINT8 *)pNextLookAhead)[3] = pLookAhead->LookAhead[3]; |
| 123 | |
| 124 | if (AR_DEBUG_LVL_CHECK(ATH_DEBUG_RECV)) { |
| 125 | DebugDumpBytes((A_UINT8 *)pNextLookAhead,4,"Next Look Ahead"); |
| 126 | } |
| 127 | } |
| 128 | break; |
| 129 | default: |
| 130 | AR_DEBUG_PRINTF(ATH_DEBUG_ERR, (" unhandled record: id:%d length:%d \n", |
| 131 | pRecord->RecordID, pRecord->Length)); |
| 132 | break; |
| 133 | } |
| 134 | |
| 135 | if (A_FAILED(status)) { |
| 136 | break; |
| 137 | } |
| 138 | |
| 139 | /* advance buffer past this record for next time around */ |
| 140 | pBuffer += pRecord->Length; |
| 141 | Length -= pRecord->Length; |
| 142 | } |
| 143 | |
| 144 | if (A_FAILED(status)) { |
| 145 | DebugDumpBytes(pOrigBuffer,origLength,"BAD Recv Trailer"); |
| 146 | } |
| 147 | |
| 148 | AR_DEBUG_PRINTF(ATH_DEBUG_RECV, ("-HTCProcessTrailer \n")); |
| 149 | return status; |
| 150 | |
| 151 | } |
| 152 | |
| 153 | /* process a received message (i.e. strip off header, process any trailer data) |
| 154 | * note : locks must be released when this function is called */ |
| 155 | static A_STATUS HTCProcessRecvHeader(HTC_TARGET *target, HTC_PACKET *pPacket, A_UINT32 *pNextLookAhead) |
| 156 | { |
| 157 | A_UINT8 temp; |
| 158 | A_UINT8 *pBuf; |
| 159 | A_STATUS status = A_OK; |
| 160 | A_UINT16 payloadLen; |
| 161 | A_UINT32 lookAhead; |
| 162 | |
| 163 | pBuf = pPacket->pBuffer; |
| 164 | |
| 165 | AR_DEBUG_PRINTF(ATH_DEBUG_RECV, ("+HTCProcessRecvHeader \n")); |
| 166 | |
| 167 | if (AR_DEBUG_LVL_CHECK(ATH_DEBUG_RECV)) { |
| 168 | AR_DEBUG_PRINTBUF(pBuf,pPacket->ActualLength,"HTC Recv PKT"); |
| 169 | } |
| 170 | |
| 171 | do { |
| 172 | /* note, we cannot assume the alignment of pBuffer, so we use the safe macros to |
| 173 | * retrieve 16 bit fields */ |
| 174 | payloadLen = A_GET_UINT16_FIELD(pBuf, HTC_FRAME_HDR, PayloadLen); |
| 175 | |
| 176 | ((A_UINT8 *)&lookAhead)[0] = pBuf[0]; |
| 177 | ((A_UINT8 *)&lookAhead)[1] = pBuf[1]; |
| 178 | ((A_UINT8 *)&lookAhead)[2] = pBuf[2]; |
| 179 | ((A_UINT8 *)&lookAhead)[3] = pBuf[3]; |
| 180 | |
| 181 | if (lookAhead != pPacket->HTCReserved) { |
| 182 | /* somehow the lookahead that gave us the full read length did not |
| 183 | * reflect the actual header in the pending message */ |
| 184 | AR_DEBUG_PRINTF(ATH_DEBUG_ERR, |
| 185 | ("HTCProcessRecvHeader, lookahead mismatch! \n")); |
| 186 | DebugDumpBytes((A_UINT8 *)&pPacket->HTCReserved,4,"Expected Message LookAhead"); |
| 187 | DebugDumpBytes(pBuf,sizeof(HTC_FRAME_HDR),"Current Frame Header"); |
| 188 | #ifdef HTC_CAPTURE_LAST_FRAME |
| 189 | DebugDumpBytes((A_UINT8 *)&target->LastFrameHdr,sizeof(HTC_FRAME_HDR),"Last Frame Header"); |
| 190 | if (target->LastTrailerLength != 0) { |
| 191 | DebugDumpBytes(target->LastTrailer, |
| 192 | target->LastTrailerLength, |
| 193 | "Last trailer"); |
| 194 | } |
| 195 | #endif |
| 196 | status = A_EPROTO; |
| 197 | break; |
| 198 | } |
| 199 | |
| 200 | /* get flags */ |
| 201 | temp = A_GET_UINT8_FIELD(pBuf, HTC_FRAME_HDR, Flags); |
| 202 | |
| 203 | if (temp & HTC_FLAGS_RECV_TRAILER) { |
| 204 | /* this packet has a trailer */ |
| 205 | |
| 206 | /* extract the trailer length in control byte 0 */ |
| 207 | temp = A_GET_UINT8_FIELD(pBuf, HTC_FRAME_HDR, ControlBytes[0]); |
| 208 | |
| 209 | if ((temp < sizeof(HTC_RECORD_HDR)) || (temp > payloadLen)) { |
| 210 | AR_DEBUG_PRINTF(ATH_DEBUG_ERR, |
| 211 | ("HTCProcessRecvHeader, invalid header (payloadlength should be :%d, CB[0] is:%d) \n", |
| 212 | payloadLen, temp)); |
| 213 | status = A_EPROTO; |
| 214 | break; |
| 215 | } |
| 216 | |
| 217 | /* process trailer data that follows HDR + application payload */ |
| 218 | status = HTCProcessTrailer(target, |
| 219 | (pBuf + HTC_HDR_LENGTH + payloadLen - temp), |
| 220 | temp, |
| 221 | pNextLookAhead, |
| 222 | pPacket->Endpoint); |
| 223 | |
| 224 | if (A_FAILED(status)) { |
| 225 | break; |
| 226 | } |
| 227 | |
| 228 | #ifdef HTC_CAPTURE_LAST_FRAME |
| 229 | A_MEMCPY(target->LastTrailer, (pBuf + HTC_HDR_LENGTH + payloadLen - temp), temp); |
| 230 | target->LastTrailerLength = temp; |
| 231 | #endif |
| 232 | /* trim length by trailer bytes */ |
| 233 | pPacket->ActualLength -= temp; |
| 234 | } |
| 235 | #ifdef HTC_CAPTURE_LAST_FRAME |
| 236 | else { |
| 237 | target->LastTrailerLength = 0; |
| 238 | } |
| 239 | #endif |
| 240 | |
| 241 | /* if we get to this point, the packet is good */ |
| 242 | /* remove header and adjust length */ |
| 243 | pPacket->pBuffer += HTC_HDR_LENGTH; |
| 244 | pPacket->ActualLength -= HTC_HDR_LENGTH; |
| 245 | |
| 246 | } while (FALSE); |
| 247 | |
| 248 | if (A_FAILED(status)) { |
| 249 | /* dump the whole packet */ |
| 250 | DebugDumpBytes(pBuf,pPacket->ActualLength,"BAD HTC Recv PKT"); |
| 251 | } else { |
| 252 | #ifdef HTC_CAPTURE_LAST_FRAME |
| 253 | A_MEMCPY(&target->LastFrameHdr,pBuf,sizeof(HTC_FRAME_HDR)); |
| 254 | #endif |
| 255 | if (AR_DEBUG_LVL_CHECK(ATH_DEBUG_RECV)) { |
| 256 | if (pPacket->ActualLength > 0) { |
| 257 | AR_DEBUG_PRINTBUF(pPacket->pBuffer,pPacket->ActualLength,"HTC - Application Msg"); |
| 258 | } |
| 259 | } |
| 260 | } |
| 261 | |
| 262 | AR_DEBUG_PRINTF(ATH_DEBUG_RECV, ("-HTCProcessRecvHeader \n")); |
| 263 | return status; |
| 264 | } |
| 265 | |
| 266 | /* asynchronous completion handler for recv packet fetching, when the device layer |
| 267 | * completes a read request, it will call this completion handler */ |
| 268 | void HTCRecvCompleteHandler(void *Context, HTC_PACKET *pPacket) |
| 269 | { |
| 270 | HTC_TARGET *target = (HTC_TARGET *)Context; |
| 271 | HTC_ENDPOINT *pEndpoint; |
| 272 | A_UINT32 nextLookAhead = 0; |
| 273 | A_STATUS status; |
| 274 | |
| 275 | AR_DEBUG_PRINTF(ATH_DEBUG_RECV, ("+HTCRecvCompleteHandler (status:%d, ep:%d) \n", |
| 276 | pPacket->Status, pPacket->Endpoint)); |
| 277 | |
| 278 | AR_DEBUG_ASSERT(pPacket->Endpoint < ENDPOINT_MAX); |
| 279 | pEndpoint = &target->EndPoint[pPacket->Endpoint]; |
| 280 | pPacket->Completion = NULL; |
| 281 | |
| 282 | /* get completion status */ |
| 283 | status = pPacket->Status; |
| 284 | |
| 285 | do { |
| 286 | if (A_FAILED(status)) { |
| 287 | AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("HTCRecvCompleteHandler: request failed (status:%d, ep:%d) \n", |
| 288 | pPacket->Status, pPacket->Endpoint)); |
| 289 | break; |
| 290 | } |
| 291 | /* process the header for any trailer data */ |
| 292 | status = HTCProcessRecvHeader(target,pPacket,&nextLookAhead); |
| 293 | |
| 294 | if (A_FAILED(status)) { |
| 295 | break; |
| 296 | } |
| 297 | /* was there a lookahead for the next packet? */ |
| 298 | if (nextLookAhead != 0) { |
| 299 | A_STATUS nextStatus; |
| 300 | AR_DEBUG_PRINTF(ATH_DEBUG_RECV, |
| 301 | ("HTCRecvCompleteHandler - next look ahead was non-zero : 0x%X \n", |
| 302 | nextLookAhead)); |
| 303 | /* we have another packet, get the next packet fetch started (pipelined) before |
| 304 | * we call into the endpoint's callback, this will start another async request */ |
| 305 | nextStatus = HTCRecvMessagePendingHandler(target,nextLookAhead,NULL); |
| 306 | if (A_EPROTO == nextStatus) { |
| 307 | AR_DEBUG_PRINTF(ATH_DEBUG_ERR, |
| 308 | ("Next look ahead from recv header was INVALID\n")); |
| 309 | DebugDumpBytes((A_UINT8 *)&nextLookAhead, |
| 310 | 4, |
| 311 | "BAD lookahead from lookahead report"); |
| 312 | } |
| 313 | } else { |
| 314 | AR_DEBUG_PRINTF(ATH_DEBUG_RECV, |
| 315 | ("HTCRecvCompleteHandler - rechecking for more messages...\n")); |
| 316 | /* if we did not get anything on the look-ahead, |
| 317 | * call device layer to asynchronously re-check for messages. If we can keep the async |
| 318 | * processing going we get better performance. If there is a pending message we will keep processing |
| 319 | * messages asynchronously which should pipeline things nicely */ |
| 320 | DevCheckPendingRecvMsgsAsync(&target->Device); |
| 321 | } |
| 322 | |
| 323 | HTC_RX_STAT_PROFILE(target,pEndpoint,nextLookAhead); |
| 324 | DO_RCV_COMPLETION(target,pPacket,pEndpoint); |
| 325 | |
| 326 | } while (FALSE); |
| 327 | |
| 328 | if (A_FAILED(status)) { |
| 329 | AR_DEBUG_PRINTF(ATH_DEBUG_ERR, |
| 330 | ("HTCRecvCompleteHandler , message fetch failed (status = %d) \n", |
| 331 | status)); |
| 332 | /* recyle this packet */ |
| 333 | HTC_RECYCLE_RX_PKT(target, pPacket); |
| 334 | } |
| 335 | |
| 336 | AR_DEBUG_PRINTF(ATH_DEBUG_RECV, ("-HTCRecvCompleteHandler\n")); |
| 337 | } |
| 338 | |
| 339 | /* synchronously wait for a control message from the target, |
| 340 | * This function is used at initialization time ONLY. At init messages |
| 341 | * on ENDPOINT 0 are expected. */ |
| 342 | A_STATUS HTCWaitforControlMessage(HTC_TARGET *target, HTC_PACKET **ppControlPacket) |
| 343 | { |
| 344 | A_STATUS status; |
| 345 | A_UINT32 lookAhead; |
| 346 | HTC_PACKET *pPacket = NULL; |
| 347 | HTC_FRAME_HDR *pHdr; |
| 348 | |
| 349 | AR_DEBUG_PRINTF(ATH_DEBUG_RECV,("+HTCWaitforControlMessage \n")); |
| 350 | |
| 351 | do { |
| 352 | |
| 353 | *ppControlPacket = NULL; |
| 354 | |
| 355 | /* call the polling function to see if we have a message */ |
| 356 | status = DevPollMboxMsgRecv(&target->Device, |
| 357 | &lookAhead, |
| 358 | HTC_TARGET_RESPONSE_TIMEOUT); |
| 359 | |
| 360 | if (A_FAILED(status)) { |
| 361 | break; |
| 362 | } |
| 363 | |
| 364 | AR_DEBUG_PRINTF(ATH_DEBUG_RECV, |
| 365 | ("HTCWaitforControlMessage : lookAhead : 0x%X \n", lookAhead)); |
| 366 | |
| 367 | /* check the lookahead */ |
| 368 | pHdr = (HTC_FRAME_HDR *)&lookAhead; |
| 369 | |
| 370 | if (pHdr->EndpointID != ENDPOINT_0) { |
| 371 | /* unexpected endpoint number, should be zero */ |
| 372 | AR_DEBUG_ASSERT(FALSE); |
| 373 | status = A_EPROTO; |
| 374 | break; |
| 375 | } |
| 376 | |
| 377 | if (A_FAILED(status)) { |
| 378 | /* bad message */ |
| 379 | AR_DEBUG_ASSERT(FALSE); |
| 380 | status = A_EPROTO; |
| 381 | break; |
| 382 | } |
| 383 | |
| 384 | pPacket = HTC_ALLOC_CONTROL_RX(target); |
| 385 | |
| 386 | if (pPacket == NULL) { |
| 387 | AR_DEBUG_ASSERT(FALSE); |
| 388 | status = A_NO_MEMORY; |
| 389 | break; |
| 390 | } |
| 391 | |
| 392 | pPacket->HTCReserved = lookAhead; |
| 393 | pPacket->ActualLength = pHdr->PayloadLen + HTC_HDR_LENGTH; |
| 394 | |
| 395 | if (pPacket->ActualLength > pPacket->BufferLength) { |
| 396 | AR_DEBUG_ASSERT(FALSE); |
| 397 | status = A_EPROTO; |
| 398 | break; |
| 399 | } |
| 400 | |
| 401 | /* we want synchronous operation */ |
| 402 | pPacket->Completion = NULL; |
| 403 | |
| 404 | /* get the message from the device, this will block */ |
| 405 | status = HTCIssueRecv(target, pPacket); |
| 406 | |
| 407 | if (A_FAILED(status)) { |
| 408 | break; |
| 409 | } |
| 410 | |
| 411 | /* process receive header */ |
| 412 | status = HTCProcessRecvHeader(target,pPacket,NULL); |
| 413 | |
| 414 | pPacket->Status = status; |
| 415 | |
| 416 | if (A_FAILED(status)) { |
| 417 | AR_DEBUG_PRINTF(ATH_DEBUG_ERR, |
| 418 | ("HTCWaitforControlMessage, HTCProcessRecvHeader failed (status = %d) \n", |
| 419 | status)); |
| 420 | break; |
| 421 | } |
| 422 | |
| 423 | /* give the caller this control message packet, they are responsible to free */ |
| 424 | *ppControlPacket = pPacket; |
| 425 | |
| 426 | } while (FALSE); |
| 427 | |
| 428 | if (A_FAILED(status)) { |
| 429 | if (pPacket != NULL) { |
| 430 | /* cleanup buffer on error */ |
| 431 | HTC_FREE_CONTROL_RX(target,pPacket); |
| 432 | } |
| 433 | } |
| 434 | |
| 435 | AR_DEBUG_PRINTF(ATH_DEBUG_RECV,("-HTCWaitforControlMessage \n")); |
| 436 | |
| 437 | return status; |
| 438 | } |
| 439 | |
| 440 | /* callback when device layer or lookahead report parsing detects a pending message */ |
| 441 | A_STATUS HTCRecvMessagePendingHandler(void *Context, A_UINT32 LookAhead, A_BOOL *pAsyncProc) |
| 442 | { |
| 443 | HTC_TARGET *target = (HTC_TARGET *)Context; |
| 444 | A_STATUS status = A_OK; |
| 445 | HTC_PACKET *pPacket = NULL; |
| 446 | HTC_FRAME_HDR *pHdr; |
| 447 | HTC_ENDPOINT *pEndpoint; |
| 448 | A_BOOL asyncProc = FALSE; |
| 449 | |
| 450 | AR_DEBUG_PRINTF(ATH_DEBUG_RECV,("+HTCRecvMessagePendingHandler LookAhead:0x%X \n",LookAhead)); |
| 451 | |
| 452 | if (IS_DEV_IRQ_PROCESSING_ASYNC_ALLOWED(&target->Device)) { |
| 453 | /* We use async mode to get the packets if the device layer supports it. |
| 454 | * The device layer interfaces with HIF in which HIF may have restrictions on |
| 455 | * how interrupts are processed */ |
| 456 | asyncProc = TRUE; |
| 457 | } |
| 458 | |
| 459 | if (pAsyncProc != NULL) { |
| 460 | /* indicate to caller how we decided to process this */ |
| 461 | *pAsyncProc = asyncProc; |
| 462 | } |
| 463 | |
| 464 | while (TRUE) { |
| 465 | |
| 466 | pHdr = (HTC_FRAME_HDR *)&LookAhead; |
| 467 | |
| 468 | if (pHdr->EndpointID >= ENDPOINT_MAX) { |
| 469 | AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Invalid Endpoint in look-ahead: %d \n",pHdr->EndpointID)); |
| 470 | /* invalid endpoint */ |
| 471 | status = A_EPROTO; |
| 472 | break; |
| 473 | } |
| 474 | |
| 475 | if (pHdr->PayloadLen > HTC_MAX_PAYLOAD_LENGTH) { |
| 476 | AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Payload length %d exceeds max HTC : %d !\n", |
| 477 | pHdr->PayloadLen, HTC_MAX_PAYLOAD_LENGTH)); |
| 478 | status = A_EPROTO; |
| 479 | break; |
| 480 | } |
| 481 | |
| 482 | pEndpoint = &target->EndPoint[pHdr->EndpointID]; |
| 483 | |
| 484 | if (0 == pEndpoint->ServiceID) { |
| 485 | AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Endpoint %d is not connected !\n",pHdr->EndpointID)); |
| 486 | /* endpoint isn't even connected */ |
| 487 | status = A_EPROTO; |
| 488 | break; |
| 489 | } |
| 490 | |
| 491 | /* lock RX to get a buffer */ |
| 492 | LOCK_HTC_RX(target); |
| 493 | |
| 494 | /* get a packet from the endpoint recv queue */ |
| 495 | pPacket = HTC_PACKET_DEQUEUE(&pEndpoint->RxBuffers); |
| 496 | |
| 497 | if (NULL == pPacket) { |
| 498 | /* check for refill handler */ |
| 499 | if (pEndpoint->EpCallBacks.EpRecvRefill != NULL) { |
| 500 | UNLOCK_HTC_RX(target); |
| 501 | /* call the re-fill handler */ |
| 502 | pEndpoint->EpCallBacks.EpRecvRefill(pEndpoint->EpCallBacks.pContext, |
| 503 | pHdr->EndpointID); |
| 504 | LOCK_HTC_RX(target); |
| 505 | /* check if we have more buffers */ |
| 506 | pPacket = HTC_PACKET_DEQUEUE(&pEndpoint->RxBuffers); |
| 507 | /* fall through */ |
| 508 | } |
| 509 | } |
| 510 | |
| 511 | if (NULL == pPacket) { |
| 512 | /* this is not an error, we simply need to mark that we are waiting for buffers.*/ |
| 513 | target->HTCStateFlags |= HTC_STATE_WAIT_BUFFERS; |
| 514 | target->EpWaitingForBuffers = pHdr->EndpointID; |
| 515 | status = A_NO_MEMORY; |
| 516 | } |
| 517 | |
| 518 | UNLOCK_HTC_RX(target); |
| 519 | |
| 520 | if (A_FAILED(status)) { |
| 521 | /* no buffers */ |
| 522 | break; |
| 523 | } |
| 524 | |
| 525 | AR_DEBUG_ASSERT(pPacket->Endpoint == pHdr->EndpointID); |
| 526 | |
| 527 | /* make sure this message can fit in the endpoint buffer */ |
| 528 | if ((pHdr->PayloadLen + HTC_HDR_LENGTH) > pPacket->BufferLength) { |
| 529 | AR_DEBUG_PRINTF(ATH_DEBUG_ERR, |
| 530 | ("Payload Length Error : header reports payload of: %d, endpoint buffer size: %d \n", |
| 531 | pHdr->PayloadLen, pPacket->BufferLength)); |
| 532 | status = A_EPROTO; |
| 533 | break; |
| 534 | } |
| 535 | |
| 536 | pPacket->HTCReserved = LookAhead; /* set expected look ahead */ |
| 537 | /* set the amount of data to fetch */ |
| 538 | pPacket->ActualLength = pHdr->PayloadLen + HTC_HDR_LENGTH; |
| 539 | |
| 540 | if (asyncProc) { |
| 541 | /* we use async mode to get the packet if the device layer supports it |
| 542 | * set our callback and context */ |
| 543 | pPacket->Completion = HTCRecvCompleteHandler; |
| 544 | pPacket->pContext = target; |
| 545 | } else { |
| 546 | /* fully synchronous */ |
| 547 | pPacket->Completion = NULL; |
| 548 | } |
| 549 | |
| 550 | /* go fetch the packet */ |
| 551 | status = HTCIssueRecv(target, pPacket); |
| 552 | |
| 553 | if (A_FAILED(status)) { |
| 554 | break; |
| 555 | } |
| 556 | |
| 557 | if (asyncProc) { |
| 558 | /* we did this asynchronously so we can get out of the loop, the asynch processing |
| 559 | * creates a chain of requests to continue processing pending messages in the |
| 560 | * context of callbacks */ |
| 561 | break; |
| 562 | } |
| 563 | |
| 564 | /* in the sync case, we process the packet, check lookaheads and then repeat */ |
| 565 | |
| 566 | LookAhead = 0; |
| 567 | status = HTCProcessRecvHeader(target,pPacket,&LookAhead); |
| 568 | |
| 569 | if (A_FAILED(status)) { |
| 570 | break; |
| 571 | } |
| 572 | |
| 573 | HTC_RX_STAT_PROFILE(target,pEndpoint,LookAhead); |
| 574 | DO_RCV_COMPLETION(target,pPacket,pEndpoint); |
| 575 | |
| 576 | pPacket = NULL; |
| 577 | |
| 578 | if (0 == LookAhead) { |
| 579 | break; |
| 580 | } |
| 581 | |
| 582 | } |
| 583 | |
| 584 | if (A_NO_MEMORY == status) { |
| 585 | AR_DEBUG_PRINTF(ATH_DEBUG_ERR, |
| 586 | (" Endpoint :%d has no buffers, blocking receiver to prevent overrun.. \n", |
| 587 | pHdr->EndpointID)); |
| 588 | /* try to stop receive at the device layer */ |
| 589 | DevStopRecv(&target->Device, asyncProc ? DEV_STOP_RECV_ASYNC : DEV_STOP_RECV_SYNC); |
| 590 | status = A_OK; |
| 591 | } else if (A_FAILED(status)) { |
| 592 | AR_DEBUG_PRINTF(ATH_DEBUG_ERR, |
| 593 | ("Failed to get pending message : LookAhead Value: 0x%X (status = %d) \n", |
| 594 | LookAhead, status)); |
| 595 | if (pPacket != NULL) { |
| 596 | /* clean up packet on error */ |
| 597 | HTC_RECYCLE_RX_PKT(target, pPacket); |
| 598 | } |
| 599 | } |
| 600 | |
| 601 | AR_DEBUG_PRINTF(ATH_DEBUG_RECV,("-HTCRecvMessagePendingHandler \n")); |
| 602 | |
| 603 | return status; |
| 604 | } |
| 605 | |
| 606 | /* Makes a buffer available to the HTC module */ |
| 607 | A_STATUS HTCAddReceivePkt(HTC_HANDLE HTCHandle, HTC_PACKET *pPacket) |
| 608 | { |
| 609 | HTC_TARGET *target = GET_HTC_TARGET_FROM_HANDLE(HTCHandle); |
| 610 | HTC_ENDPOINT *pEndpoint; |
| 611 | A_BOOL unblockRecv = FALSE; |
| 612 | A_STATUS status = A_OK; |
| 613 | |
| 614 | AR_DEBUG_PRINTF(ATH_DEBUG_SEND, |
| 615 | ("+- HTCAddReceivePkt: endPointId: %d, buffer: 0x%X, length: %d\n", |
| 616 | pPacket->Endpoint, (A_UINT32)pPacket->pBuffer, pPacket->BufferLength)); |
| 617 | |
| 618 | do { |
| 619 | |
| 620 | if (HTC_STOPPING(target)) { |
| 621 | status = A_ECANCELED; |
| 622 | break; |
| 623 | } |
| 624 | |
| 625 | AR_DEBUG_ASSERT(pPacket->Endpoint < ENDPOINT_MAX); |
| 626 | |
| 627 | pEndpoint = &target->EndPoint[pPacket->Endpoint]; |
| 628 | |
| 629 | LOCK_HTC_RX(target); |
| 630 | |
| 631 | /* store receive packet */ |
| 632 | HTC_PACKET_ENQUEUE(&pEndpoint->RxBuffers, pPacket); |
| 633 | |
| 634 | /* check if we are blocked waiting for a new buffer */ |
| 635 | if (target->HTCStateFlags & HTC_STATE_WAIT_BUFFERS) { |
| 636 | if (target->EpWaitingForBuffers == pPacket->Endpoint) { |
| 637 | AR_DEBUG_PRINTF(ATH_DEBUG_RECV,(" receiver was blocked on ep:%d, unblocking.. \n", |
| 638 | target->EpWaitingForBuffers)); |
| 639 | target->HTCStateFlags &= ~HTC_STATE_WAIT_BUFFERS; |
| 640 | target->EpWaitingForBuffers = ENDPOINT_MAX; |
| 641 | unblockRecv = TRUE; |
| 642 | } |
| 643 | } |
| 644 | |
| 645 | UNLOCK_HTC_RX(target); |
| 646 | |
| 647 | if (unblockRecv && !HTC_STOPPING(target)) { |
| 648 | /* TODO : implement a buffer threshold count? */ |
| 649 | DevEnableRecv(&target->Device,DEV_ENABLE_RECV_SYNC); |
| 650 | } |
| 651 | |
| 652 | } while (FALSE); |
| 653 | |
| 654 | return status; |
| 655 | } |
| 656 | |
| 657 | static void HTCFlushEndpointRX(HTC_TARGET *target, HTC_ENDPOINT *pEndpoint) |
| 658 | { |
| 659 | HTC_PACKET *pPacket; |
| 660 | |
| 661 | LOCK_HTC_RX(target); |
| 662 | |
| 663 | while (1) { |
| 664 | pPacket = HTC_PACKET_DEQUEUE(&pEndpoint->RxBuffers); |
| 665 | if (NULL == pPacket) { |
| 666 | break; |
| 667 | } |
| 668 | UNLOCK_HTC_RX(target); |
| 669 | pPacket->Status = A_ECANCELED; |
| 670 | pPacket->ActualLength = 0; |
| 671 | AR_DEBUG_PRINTF(ATH_DEBUG_RECV, (" Flushing RX packet:0x%X, length:%d, ep:%d \n", |
| 672 | (A_UINT32)pPacket, pPacket->BufferLength, pPacket->Endpoint)); |
| 673 | /* give the packet back */ |
| 674 | pEndpoint->EpCallBacks.EpRecv(pEndpoint->EpCallBacks.pContext, |
| 675 | pPacket); |
| 676 | LOCK_HTC_RX(target); |
| 677 | } |
| 678 | |
| 679 | UNLOCK_HTC_RX(target); |
| 680 | |
| 681 | |
| 682 | } |
| 683 | |
| 684 | void HTCFlushRecvBuffers(HTC_TARGET *target) |
| 685 | { |
| 686 | HTC_ENDPOINT *pEndpoint; |
| 687 | int i; |
| 688 | |
| 689 | /* NOTE: no need to flush endpoint 0, these buffers were |
| 690 | * allocated as part of the HTC struct */ |
| 691 | for (i = ENDPOINT_1; i < ENDPOINT_MAX; i++) { |
| 692 | pEndpoint = &target->EndPoint[i]; |
| 693 | if (pEndpoint->ServiceID == 0) { |
| 694 | /* not in use.. */ |
| 695 | continue; |
| 696 | } |
| 697 | HTCFlushEndpointRX(target,pEndpoint); |
| 698 | } |
| 699 | |
| 700 | |
| 701 | } |
| 702 | |
| 703 | |
| 704 | |
