/* Synchronousinterrupt handler, this handler kicks off all interrupt processing.*/ A_STATUS DevDsrHandler(void *context) { AR6K_DEVICE *pDev = (AR6K_DEVICE *)context; A_STATUS status = A_OK; A_BOOL done = FALSE; A_BOOL asyncProc = FALSE; AR_DEBUG_PRINTF(ATH_DEBUG_IRQ,("+DevDsrHandler: (dev: 0x%X)\n", (A_UINT32)pDev)); while (!done) { status = ProcessPendingIRQs(pDev, &done, &asyncProc); if (A_FAILED(status)) { break; } if (HIF_DEVICE_IRQ_SYNC_ONLY == pDev->HifIRQProcessingMode) { /* the HIF layer does not allow async IRQ processing, override the asyncProc flag */ asyncProc = FALSE; /* this will cause us to re-enter ProcessPendingIRQ() and re-read interrupt status registers. * this has a nice side effect of blocking us until all async read requests are completed. * This behavior is required on some HIF implementations that do not allow ASYNC * processing in interrupt handlers (like Windows CE) */ } if (asyncProc) { /* the function performed some async I/O for performance, we need to exit the ISR immediately, the check below will prevent the interrupt from being Ack'd while we handle it asynchronously */ break; } } if (A_SUCCESS(status) && !asyncProc) { /* Ack the interrupt only if : * 1. we did not get any errors in processing interrupts * 2. there are no outstanding async processing requests */ AR_DEBUG_PRINTF(ATH_DEBUG_IRQ,(" Acking interrupt from DevDsrHandler \n")); HIFAckInterrupt(pDev->HIFDevice); } AR_DEBUG_PRINTF(ATH_DEBUG_IRQ,("-DevDsrHandler \n")); return status; }
/* Synchronousinterrupt handler, this handler kicks off all interrupt processing.*/ int DevDsrHandler(void *context) { AR6K_DEVICE *pDev = (AR6K_DEVICE *)context; int status = 0; bool done = false; bool asyncProc = false; AR_DEBUG_PRINTF(ATH_DEBUG_IRQ,("+DevDsrHandler: (dev: 0x%lX)\n", (unsigned long)pDev)); /* reset the recv counter that tracks when we need to yield from the DSR */ pDev->CurrentDSRRecvCount = 0; /* reset counter used to flag a re-scan of IRQ status registers on the target */ pDev->RecheckIRQStatusCnt = 0; while (!done) { status = ProcessPendingIRQs(pDev, &done, &asyncProc); if (status) { break; } if (HIF_DEVICE_IRQ_SYNC_ONLY == pDev->HifIRQProcessingMode) { /* the HIF layer does not allow async IRQ processing, override the asyncProc flag */ asyncProc = false; /* this will cause us to re-enter ProcessPendingIRQ() and re-read interrupt status registers. * this has a nice side effect of blocking us until all async read requests are completed. * This behavior is required on some HIF implementations that do not allow ASYNC * processing in interrupt handlers (like Windows CE) */ if (pDev->DSRCanYield && DEV_CHECK_RECV_YIELD(pDev)) { /* ProcessPendingIRQs() pulled enough recv messages to satisfy the yield count, stop * checking for more messages and return */ break; } } if (asyncProc) { /* the function performed some async I/O for performance, we need to exit the ISR immediately, the check below will prevent the interrupt from being Ack'd while we handle it asynchronously */ break; } } if (!status && !asyncProc) { /* Ack the interrupt only if : * 1. we did not get any errors in processing interrupts * 2. there are no outstanding async processing requests */ if (pDev->DSRCanYield) { /* if the DSR can yield do not ACK the interrupt, there could be more pending messages. * The HIF layer must ACK the interrupt on behalf of HTC */ AR_DEBUG_PRINTF(ATH_DEBUG_IRQ,(" Yield in effect (cur RX count: %d) \n", pDev->CurrentDSRRecvCount)); } else { AR_DEBUG_PRINTF(ATH_DEBUG_IRQ,(" Acking interrupt from DevDsrHandler \n")); HIFAckInterrupt(pDev->HIFDevice); } } AR_DEBUG_PRINTF(ATH_DEBUG_IRQ,("-DevDsrHandler \n")); return status; }