usb.c

有关ARM开发板上的IXP400网络驱动程序的源码以。

                           USBEventCallback eventCallback, 
                           USBEventMap eventMap)
{
    USBEventProcessor *events;
    UDCRegisters *registers;

    CHECK_DEVICE(device);

    CHECK_EVENT_MASK(device, eventMap);

    events    = EVENTS(device);
    registers = REGISTERS(device);

    if (eventCallback != NULL)
    {
        UINT32 UFNHR = REG_GET(&registers->UFNHR);

        BOOL sofMaskSet     = (UFNHR & UDC_UFNHR_SIM) != 0;
        BOOL sofMaskDesired = (eventMap & USB_SOF) == 0;

        events->eventCallback = eventCallback;
        events->eventMap      = eventMap;

        /* check if we need to switch the SOF mask */
        if (sofMaskSet != sofMaskDesired)
        {
            if (sofMaskDesired)
            {
                /* set mask */
                UFNHR = UDC_UFNHR_SIM;
            }
            else
            {
                /* unset mask (this will enable SOF interrupts) */
                UFNHR = UFNHR & ~UDC_UFNHR_SIM;
            }

            REG_SET(&registers->UFNHR, UFNHR);
        }
    }
    else
    {
        events->eventCallback = ixUSBNullEventCallback;
        events->eventMap      = USB_DEVICE_EVENTS;

        /* mask start of frame interrupts */
        REG_SET(&registers->UFNHR, UDC_UFNHR_SIM);
    }

    RETURN_OK(device);
}

#ifdef IX_USB_HAS_STATISTICS_SHOW

PUBLIC IX_STATUS 
ixUSBStatisticsShow(USBDevice *device)
{
    USBDeviceCounters *devCounters;
    BOOL deviceEnabled;
    UDCRegisters *registers;

#ifdef IX_USB_STATS_SHOW_PER_ENDPOINT_INFO

    UINT16 epIndex;

#endif /* IX_USB_STATS_SHOW_PER_ENDPOINT_INFO */

    CHECK_DEVICE(device);

    devCounters   = COUNTERS(device);
    deviceEnabled = CONTEXT(device)->enabled;
    registers     = REGISTERS(device);

    /* device info */
    printf("USB controller %d (I/O %x, IRQ %d) - %s, %s, %d irqs, %d frames\n",
            device->deviceIndex,
            device->baseIOAddress,
            device->interruptLevel,
            deviceEnabled ? "enabled" : "disabled",
            (REG_GET(&registers->UDCCR) & UDC_UDCCR_UDA) ? "active" : "inactive",
            devCounters->irqCount,
            devCounters->frames);

    /* device stats */
    printf("packets Tx %d, Rx %d, dropped Tx %d, Rx %d - bytes Tx %d, Rx %d - setup %d\n",
            devCounters->Tx,
            devCounters->Rx,
            devCounters->DTx,
            devCounters->DRx,
            devCounters->bytesTx,
            devCounters->bytesRx,
            devCounters->setup);

#ifdef IX_USB_STATS_SHOW_PER_ENDPOINT_INFO

    printf("\n");

    /* endpoint stats - table header */
    printf("ep |   packets |   dropped |     bytes | irqs | flags   | FIFO o/u\n");
    printf("   |  Tx    Rx |  Tx    Rx |   Tx   Rx |      |         |\n");

    /* endpoint info */
    for (epIndex = ENDPOINT_0 ; epIndex < NUM_ENDPOINTS ; epIndex++)
    {
        USBEndpointCounters *epCounters = EPCOUNTERS(device, epIndex);
        BOOL stallState;

        ixUSBIsEndpointStalled(device, epIndex, &stallState);

        printf("%2d | %3d%s %3d%s | %3d%s %3d%s | %3d%s %3d%s | %4d | %s | %3d%s %3d%s\n",
                epIndex,
                SHOW_NUMBER(epCounters->Tx), SHOW_METRIC(epCounters->Tx),
                SHOW_NUMBER(epCounters->Rx), SHOW_METRIC(epCounters->Rx),
                SHOW_NUMBER(epCounters->DTx), SHOW_METRIC(epCounters->DTx),
                SHOW_NUMBER(epCounters->DRx), SHOW_METRIC(epCounters->DRx),
                SHOW_NUMBER(epCounters->bytesTx), SHOW_METRIC(epCounters->bytesTx),
                SHOW_NUMBER(epCounters->bytesRx),  SHOW_METRIC(epCounters->bytesRx),
                epCounters->irqCount,
                EP_TYPE(EPDescriptorTable[epIndex]) == USB_ISOCHRONOUS ? "    N/A" : stallState ? "stalled" : " active",
                SHOW_NUMBER(epCounters->fifoOverflows), SHOW_METRIC(epCounters->fifoOverflows),
                SHOW_NUMBER(epCounters->fifoUnderruns), SHOW_METRIC(epCounters->fifoUnderruns));
    }

#endif /* IX_USB_STATS_SHOW_PER_ENDPOINT_INFO */

    RETURN_OK(device);
}

#endif /* IX_USB_HAS_STATISTICS_SHOW */


PRIVATE UINT32 
ixUSBIrqRead(void)
{
    UINT32 intPending;

    if(ixUSBIrqCtrlRegVirtAddr == 0)
    {
        ixOsalLog(IX_OSAL_LOG_LVL_ERROR,
                  IX_OSAL_LOG_DEV_STDERR,
                  "Irq Control Registers is not mem map\n",
                  0, 0, 0 ,0 ,0 ,0);
        return 0;
    }
    
    /**
     * Get the interrupt control register content. 
     * The register is mem map in ixUSBDriverInit. 
     */
    intPending = IX_OSAL_READ_LONG(ixUSBIrqCtrlRegVirtAddr);
    return intPending;
}

/**
 * @} addtogroup USBDriver
 */

/**
 * @addtogroup SupportAPI
 * @{
 */
PRIVATE void 
ixUSBInterruptHandlerWrapper(USBDevice *device)
{
    UINT32 intPend     = 0;
    UINT32 maxCount    = 0xFF;
    UINT32 ep0Activity = 0;

    intPend = ixUSBIrqRead();
    if (! (intPend & (1 << IX_OSAL_IXP400_INT_LVL_USB)))
    {
        IX_USB_VERBOSE_WARN_TRACE("Arrived in ixUSBInterruptHandlerWrapper but no interrupt\n",
   		  0, 0, 0, 0, 0, 0);
        return;
    }

    while ((intPend & (1 << IX_OSAL_IXP400_INT_LVL_USB)) && maxCount)
    {
        ep0Activity = ixUSBInterruptHandler(device);

        --maxCount;
        intPend = ixUSBIrqRead();
        intPend = ixUSBIrqRead();
        intPend = ixUSBIrqRead();
    }

    if (maxCount == 0)
    {
        IX_USB_VERBOSE2_TRACE("Leaving ixUSBInterruptHandlerWrapper after 0xffff iterations\n",
 	             0, 0, 0, 0, 0, 0);
    }
}

/**
 * @fn PRIVATE UINT32 ixUSBInterruptHandler(USBDevice *device)
 *
 * @brief Main interrupt handler
 *
 * @param device USBDevice * (in) - structure identifying the device
 *
 * Takes a snapshot of the USB status registers and analyzes the
 * source of the interrupt, calling the appropriate handler.
 * Depending on the event that caused the interrupt this can be
 * the endpoint 0 interrupt handler, USB_IN/USB_OUT interrupt handlers
 * or the client event callback.<br>
 * UDC interrupts are disabled during the execution of this function
 * as the handler and its support functions are not reentrant.
 *
 * @return none
 *
 * @internal
 */
 
/*
Note:     

    UDCCR     - UDC Control Register
    USIR0     - UDC Interrupt and Status Register 0
    USIR1     - UDC Interrupt and Status Register 1
    UFNHR     - UDC Frame Number High Register
 */

static INT32 ixUSBIPRset = 0;

PRIVATE UINT32 
ixUSBInterruptHandler(USBDevice *device)
{
    UINT16 epIndex;
    UINT32 eventSet    = USB_NO_EVENT;
    UINT32 ep0Activity = 0;

    USBDeviceContext *context      = CONTEXT(device);
    UDCRegisters *registers        = context->registers;
    USBEventCallback eventCallback = context->eventProcessor.eventCallback;
    USBEventMap eventMap           = context->eventProcessor.eventMap;

    UINT32 UDCCR; /* device control/status register */
    UINT32 USIR0; /* endpoints 0..7 interrupt status */
    UINT32 USIR1; /* endpoints 8..15 interrupt status */
    UINT32 UFNHR; /* device frame number high register (contains SOF IRQ) */

#ifdef IX_USB_HAS_CRITICAL_DATA_LOCKS
    /* disable interrupts */
    UINT32 irqStatus;

    irqStatus = IX_USB_IRQ_LOCK;
#endif /* IX_USB_HAS_CRITICAL_DATA_LOCKS */

    /* read UDCCR, UISR0, UISR1, UFNHR */
    UDCCR = REG_GET(&registers->UDCCR);
    USIR0 = REG_GET(&registers->USIR0);
    USIR1 = REG_GET(&registers->USIR1);
    UFNHR = REG_GET(&registers->UFNHR);

    ixUSBIPRset = 0;

    if ((UDCCR | USIR0 | USIR1) == 0)
    {
        IX_USB_VERBOSE2_TRACE("USB: Oops, servicing interrupt with no events\n",
                   0, 0, 0, 0, 0, 0);
    }

    /* debug */
    IX_USB_VERBOSE3_TRACE("Int handler: UDCCR %2X, USIR0 %2X, USIR1 %2X, UFNHR %2X\n", 
                 UDCCR, USIR0, USIR1, UFNHR, 0, 0);

    /* device IRQ counter */
    context->counters.irqCount++;

    /* Reset? */
    if (UDCCR & UDC_UDCCR_RSTIR)
    {
        eventSet |= USB_RESET;

        /* perform driver reset */
        
        /* clear endpoint information */
        for (epIndex = ENDPOINT_0 ; epIndex < NUM_ENDPOINTS ; epIndex++)
        {
            ixUSBEndpointClear(device, epIndex);
        }

        /* reset endpoint 0 state */
        ixUSBEP0StateReset(device);
    }

    /* Suspend? */
    if (UDCCR & UDC_UDCCR_SUSIR)
    {
        eventSet |= USB_SUSPEND;
    }

    /* Resume? */
    if (UDCCR & UDC_UDCCR_RESIR)
    {
        eventSet |= USB_RESUME;
    }

    /* Start of frame? */
    if (UFNHR & UDC_UFNHR_SIR)
    {
        eventSet |= USB_SOF;

        /* device frame counter */
        context->counters.frames++;
    }

    if ((eventCallback != NULL) && ((eventMap & eventSet) != 0))
    {
        eventCallback(device, eventSet);
    }

    /* Endpoint interrupt handling */
    for (epIndex = ENDPOINT_0 ; epIndex < NUM_ENDPOINTS ; epIndex++)
    {
        UINT32 intReg = (epPriority[epIndex] < ENDPOINT_8) ? USIR0 : USIR1;
        
        if (((intReg & UDCEPInterrupt[epPriority[epIndex]]) != 0))
        {
            EPStatusData *epData = &(context->epStatusData[epPriority[epIndex]]);

            ep0Activity = (epPriority[epIndex] == 0);

            /* endpoint IRQ count */
            epData->counters.irqCount++;

            /* debug */
            IX_HWEMU_TRACE("USB::ixUSBInterruptHandler(): servicing endpoint %d\n", 
                  epIndex, 0, 0, 0, 0, 0);

            /* service endpoint */
            EPInterruptHandlerTable[epPriority[epIndex]](epData);

            /* clear endpoint interrupt bit */

            if (epPriority[epIndex] < ENDPOINT_8  )
            {
                if (epPriority[epIndex] != 0 || ixUSBIPRset == 0)
                {
                    REG_SET(&registers->USIR0, UDCEPInterrupt[epPriority[epIndex]]);
                }
            }
            else
            {
                REG_SET(&registers->USIR1, UDCEPInterrupt[epPriority[epIndex]]);
            }

            ixUSBIPRset = 0;
        }
    }

    /* clear serviced interrupts */
    REG_SET(&registers->UDCCR, UDCCR);

    /* REG_SET(&registers->USIR0, USIR0); */
    /* REG_SET(&registers->USIR1, USIR1); */
    REG_SET(&registers->UFNHR, UFNHR);


#ifdef __HWEMU__ /* the emulator allows more time for processing */
    if (USIR0 != 0x01)
#endif /* __HWEMU__ */
    {
        REG_SET(&registers->USIR0, USIR0);
    }

#ifdef __HWEMU__
    if (USIR0 == 0x01) 
    {
        REG_SET(&registers->USIR0, USIR0);
    }
#endif /* __HWEMU__ */

#ifdef IX_USB_HAS_CRITICAL_DATA_LOCKS
    IX_USB_IRQ_UNLOCK(irqStatus);
#endif /* IX_USB_HAS_CRITICAL_DATA_LOCKS */

    return ep0Activity;
}

/**
 * @fn PRIVATE void ixUSBINInterruptHandler(EPStatusData *epData)
 *
 * @brief Interrupt handler for USB_IN endpoints
 *
 * @param epData EPStatusData * (in) - structure identifying the endpoint
 *
 * Interrupt handler for USB_IN endpoints. Is is called after a packet was
 * sent to the host. Calls ixUSBSendCleanup() to release outgoing
 * buffers and service the next transfer.
 *
 * @return none
 *
 * @internal
 */
PRIVATE void 
ixUSBINInterruptHandler(EPStatusData *epData)
{
    ixUSBSendCleanup(epData);
}

/**
 * @fn PRIVATE void ixUSBOUTInterruptHandler(EPStatusData *epData)
 *
 * @brief Interrupt handler for USB_OUT endpoints
 *
 * @param epData EPStatusData * (in) - structure identifying the endpoint
 *
 * @return none
 *
 * Interrupt handler for USB_OUT endpoints. Services Rx host requests by calling
 * ixUSBReceiveProcess().
 *
 * @internal
 */
PRIVATE void 
ixUSBOUTInterruptHandler(EPStatusData *epData)
{
    ixUSBReceiveProcess(epData);
}

/**
 * @fn PRIVATE void ixUSBEP0InterruptHandler(EPStatusData *epData)
 *
 * @brief Interrupt handler for endpoint 0
 *
 * @param epData EPStatusData * (in) - structure identifying the endpoint
 *
 * @return none
 *
 * The endpoint 0 interrupt handler analyzes and updates the endpoint 0
 * state machine while taking appropriate actions to ensure Tx/Rx
 * on the control endpoint.<br>
 * Interacts with client code by calling the <i>setup receive</i> callback.
 *
 * @internal
 */
PRIVATE void 
ixUSBEP0InterruptHandler(EPStatusData *epData)
{
    USBDevice *device          = epData->device;
    USBDeviceContext *context  = CONTEXT(device);
    UDCRegisters *registers    = context->registers;
    EP0ControlData *ep0Control = &context->ep0ControlData;
    UINT32 UDCCS0              = REG_GET(&registers->UDCCS0);
    static UINT32 controlWriteError = FALSE;

    IX_HWEMU_TRACE("Ep0 handler: UDCCS0 is 0x%08X\n", UDCCS0, 0, 0, 0, 0, 0);

    IX_USB_VERBOSE3_TRACE("::> UDCCS0 is 0x%02X\n", UDCCS0, 0, 0, 0, 0, 0);

    ixOsalMutexLock(&usbBufferSubmitMutex[0], IX_OSAL_WAIT_FOREVER);
    
    /* clear sent stall bit unless endpoint 0 doesn't unstall itself */