usbtransunitmisc.c

This the compressed USB driver source code for vxworks5.6. It has device controller driver and other

/* usbTransUnitMisc.c - translation unit miscellaneous functions */

/* Copyright 2003 Wind River Systems, Inc. */

/* 
Modification History
--------------------
01d,15oct04,ami  Apigen Changes
01e,28sep04,hch  Fix gnu compiler warning with usbdHcdAttach and usbdHcdDetach
01d,03aug04,hch  Fix compiler warning
01c,03aug04,mta  coverity error fixes
01b,03aug04,ami  Warning Messages Removed
01a,19sep03,mta  First
*/

/*
DESCRIPTION

Implements the Translation Unit Miscellaneous Interfaces.
These interfaces are used only by UsbTool and not by Class Drivers.
They interfaces are provided to Integrate Translation Unit with UsbTool

INCLUDE FILES: drv/usb/usbTransUnit.h, usb/pciConstants.h, usb2/usbHubMisc.h,
usb2/usbdMisc.h
*/

/* includes */

#include "drv/usb/usbTransUnit.h"
#include "usb/pciConstants.h"
#include "usb2/usbHubMisc.h"
#include "usb2/usbdMisc.h"

/* defines */

#define USBTUMISC_USBD_VERSION	0x0200		      /* USBD version in BCD */
#define USBTUMISC_USBD_MFG	  "Wind River Systems, Inc."  /* USBD Mfg */

/* Add these in compiler options
#define INCLUDE_OHCD
#define INCLUDE_UHCD
#define INCLUDE_EHCD*/


/* To hold the class code for UHCI Complaint USB Host Controllers */
#define USB_UHCI_HOST_CONTROLLER                            0x000C0300

/* To hold the class code for OHCI Complaint USB Host Controllers */
#define USB_OHCI_HOST_CONTROLLER                            0x000C0310

/* To hold the class code for EHCI Complaint USB Host Controllers */
#define USB_EHCI_HOST_CONTROLLER                            0x000C0320


#define MAX_NO_OF_OHCI_CONTROLLERS	5
#define MAX_NO_OF_UHCI_CONTROLLERS	5
#define MAX_NO_OF_EHCI_CONTROLLERS	5

#define TOKEN_FOR_OHCI	0x4
#define TOKEN_FOR_UHCI	0x5
#define TOKEN_FOR_EHCI	0x6

/* Defines for the return types for detected devices */

#define USBHUB_NODETYPE_HUB      (0x02)
#define USBHUB_NODETYPE_DEVICE   (0x01)
#define USBHUB_NODETYPE_NONE     (0x00)



/***************************************************************************
*
* usbdHcdAttach - attaches an HCD to the USBD
*
* The <hcdExecFunc> passed by the caller must point to an HCD抯 primary
* entry point as defined below:
*
* \cs
* typedef UINT16 (*HCD_EXEC_FUNC) (pHRB_HEADER pHrb);
* \ce
*
* RETURNS: OK
*
* ERRNO: none
*/


STATUS usbdHcdAttach
    (
    HCD_EXEC_FUNC hcdExecFunc,		/* Ptr to HCD抯 primary entry point */
    void * hcdPciCfgHdr,			/* HCD-specific parameter */
    pGENERIC_HANDLE pAttachToken	/* Token to identify HCD in future */
    )
    {
    UINT32 HCD_ID;
    PCI_CFG_HEADER *pciCfgHdr = (PCI_CFG_HEADER *)hcdPciCfgHdr;

    HCD_ID = ( (pciCfgHdr->pciClass << 16) | (pciCfgHdr->subClass << 8) | pciCfgHdr->pgmIf );

    switch(HCD_ID)
        {

#ifdef INCLUDE_EHCD
        case USB_EHCI_HOST_CONTROLLER :
            if(TRUE == usbEhcdInit())
                *pAttachToken = TOKEN_FOR_EHCI ;
            break;
#endif

#ifdef INCLUDE_OHCD
        case USB_OHCI_HOST_CONTROLLER :
            if(TRUE == usbOhciInit())
                *pAttachToken = TOKEN_FOR_OHCI;
            break;
#endif

#ifdef INCLUDE_UHCD
        case USB_UHCI_HOST_CONTROLLER :
            if(USBHST_SUCCESS == usbUhcdInit())
                *pAttachToken = TOKEN_FOR_UHCI;
            break;
#endif

        default:
            break;
        }

    return OK;
    }



/***************************************************************************
*
* usbdHcdDetach - Detaches an HCD from the USBD
*
* The <attachToken> must be the attach token originally returned by
* usbdHcdAttach() when it first attached to the HCD.
*
* RETURNS: OK
*
* ERRNO: none
*/

STATUS usbdHcdDetach
    (
    GENERIC_HANDLE attachToken		/* AttachToken returned */
    )
    {

UINT32 token = (UINT32)attachToken;

switch ( token )
	{

#ifdef INCLUDE_EHCD
	case TOKEN_FOR_EHCI:
        usbEhcdExit();
		break;
#endif

#ifdef INCLUDE_OHCD
	case TOKEN_FOR_OHCI:
		usbOhciExit();
		break;
#endif

#ifdef INCLUDE_UHCD
	case TOKEN_FOR_UHCI:
		usbUhcdExit();
		break;
#endif

	default:
            break;
	}
    return OK;
    }

/***************************************************************************
*
* usbdBusCountGet - get number of USBs attached to the host.
*
* This function returns the total number of USB host controllers in the
* system.  Each host controller has its own root hub as required by the USB
* specification; and clients planning to enumerate USB devices using the Bus
* Enumeration Functions need to know the total number of host controllers in
* order to retrieve the Node Ids for each root hub.
*
* <pBusCount> must point to a UINT16 variable in which the total number of 
* USB host controllers will be stored.
*
* Note: The number of USB host controllers is not constant.  Bus controllers 
* can be added by calling usbdHcdAttach() and removed by calling 
* usbdHcdDetach().  Again, the Dynamic Attach Functions deal with these 
* situations automatically, and are the preferred mechanism by which most 
* clients should be informed of device attachment and removal.
*
* RETURNS: OK, or ERROR if unable to retrieve bus count
*
* ERRNO: none
*/

STATUS usbdBusCountGet
    (
    USBD_CLIENT_HANDLE clientHandle,	/* Client handle */
    pUINT16 pBusCount			/* Word bfr to receive bus count */
    )

    {
     
    if (pBusCount == NULL)
        return ERROR;
    *pBusCount = usbdBusCntGet();

    return OK;
    }


/***************************************************************************
*
* usbdRootNodeIdGet - returns root node for a specific USB
*
* This function returns the Node Id for the root hub for the specified 
* USB host controller.	<busIndex> is the index of the desired USB host 
* controller.  The first host controller is index 0 and the last host 
* controller's index is the total number of USB host controllers - as 
* returned by usbdBusCountGet() - minus 1. < pRootId> must point to a 
* USBD_NODE_ID variable in which the Node Id of the root hub will be stored.
* 
* RETURNS: OK, or ERROR if unable to get root node ID.
*
* ERRNO: none
*/

STATUS usbdRootNodeIdGet
    (
    USBD_CLIENT_HANDLE clientHandle,	/* Client handle */
    UINT16 busIndex,			/* Bus index */
    pUSBD_NODE_ID pRootId		/* bfr to receive Root Id */
    )

    {
    UINT32 rootId;

    if (pRootId == NULL)
        return ERROR;
        
    usbdRootNodeIDGet(busIndex,&rootId);

    *pRootId = (USBD_NODE_ID)rootId;

    return OK;

    }



/*******************************************************************************
*
* usbdHubPortCountGet - returns number of ports connected to a hub
*
* usbdHubPortCountGet() provides clients with a convenient mechanism to
* retrieve the number of downstream ports provided by the specified hub.
* Clients can also retrieve this information by retrieving configuration
* descriptors from the hub using the Configuration Functions describe in
* a following section.
*
* <hubId> must be the Node Id for the desired USB hub.	An error will be
* returned if <hubId> does not refer to a hub.	<pPortCount> must point to
* a UINT16 variable in which the total number of ports on the specified
* hub will be stored.
*
* RETURNS: OK, or ERROR if unable to get hub port count.
*
* ERRNO: none
*/

STATUS usbdHubPortCountGet
    (
    USBD_CLIENT_HANDLE clientHandle,	/* Client handle */
    USBD_NODE_ID hubId, 		/* Node Id for desired hub */
    pUINT16 pPortCount			/* bfr to receive port count */
    )

    {

    /* Support is required from USBD to retrieve actual data.
     * This is currently a stub.The count that is returned is equal to the
     * number of USB devices already attached to USB or 2 which ever is higher
     */

    USBHST_STATUS status;

    if(pPortCount == NULL)
        return ERROR;

    status = usbHubPortCntGet((UINT32)hubId,pPortCount);

    if (status != USBHST_SUCCESS)
        return ERROR;
    else
        return OK;

    }

/*******************************************************************************
*
* usbdNodeIdGet - gets the id of the node connected to a hub port
*
* Clients use this function to retrieve the Node Id for devices attached to
* each of a hub抯 ports.  <hubId> and <portIndex> identify the hub and port
* to which a device may be attached.  <pNodeType> must point to a UINT16
* variable to receive a type code as follows:
*
* \is
* \i 'USB_NODETYPE_NONE'
* No device is attached to the specified port.
*
* \i 'USB_NODETYPE_HUB'
* A hub is attached to the specified port.
*
* \i 'USB_NODETYPE_DEVICE'
* A device (non-hub) is attached to the specified port.
* \ie
*
* If the node type is returned as USBD_NODE_TYPE_NONE, then a Node Id is
* not returned and the value returned in <pNodeId> is undefined.  If the
* node type indicates a hub or device is attached to the port, then
* <pNodeId> will contain that hub or device抯 nodeId upon return.
*
* RETURNS: OK, or ERROR if unable to get node ID.
* 
* ERRNO: none
*/

STATUS usbdNodeIdGet
    (
    USBD_CLIENT_HANDLE clientHandle,	/* Client handle */
    USBD_NODE_ID hubId, 		/* Node Id for desired hub */
    UINT16 portIndex,			/* Port index */
    pUINT16 pNodeType,			/* bfr to receive node type */
    pUSBD_NODE_ID pNodeId		/* bfr to receive Node Id */
    )

    {

    /* Support is required from USBD to retrieve actual data.
     * This is a currently a stub. The portIndex is used to chain through
     * the global device list to get to the appropriate device.
     */

    UINT16 nodeType;
    UINT32 nodeId; 
    USBHST_STATUS status;
    
    if ( pNodeType == NULL ||  pNodeId == NULL)
        return ERROR;


    status  = usbHubNodeIDGet((UINT32)hubId, portIndex, &nodeType, &nodeId);

    switch( nodeType)
        {
        case  USBHUB_NODETYPE_HUB :
                 *pNodeType = USB_NODETYPE_HUB;
                 *pNodeId = (USBD_NODE_ID) nodeId;
                 break;
        case  USBHUB_NODETYPE_DEVICE :
                *pNodeType = USB_NODETYPE_DEVICE;
                *pNodeId = (USBD_NODE_ID) nodeId;
                 break;
        case  USBHUB_NODETYPE_NONE :
                *pNodeType = USB_NODETYPE_NONE;
                *pNodeId = (USBD_NODE_ID) nodeId;
                 break;
        }