usbtargkbdlib.c

T2.0 USB driver.rar T2.0 USB driver.rar

LOCAL STATUS mngmtFunc
    (
    pVOID param,
    USB_TARG_CHANNEL targChannel,
    UINT16 mngmtCode			    /* management code */
    )

    {
    switch (mngmtCode)
	{
	case TCD_MNGMT_ATTACH:

	    /* Initialize global data */

	    channel = targChannel;
	    usbTargEndpointInfoGet (targChannel, &numEndpoints, &pEndpoints);

	    curConfiguration = 0;
	    curAlternateSetting = 0;
	    intPipeHandle = NULL;

	    /* Initialize control pipe maxPacketSize. */

	    devDescr.maxPacketSize0 = pEndpoints [0].maxPacketSize;
	    break;

	case TCD_MNGMT_DETACH:
	    break;

	case TCD_MNGMT_BUS_RESET:
	case TCD_MNGMT_VBUS_LOST:

	    /* revert to power-ON configuration */

	    configurationSet (param, targChannel, 0);
	    break;	    

	default:
	    break;
	}

    return OK;
    }


/***************************************************************************
*
* featureClear - invoked by usbTargLib for CLEAR_FEATURE request
*
* RETURNS: OK, or ERROR if unable to clear requested feature
*/

LOCAL STATUS featureClear
    (
    pVOID param,
    USB_TARG_CHANNEL targChannel,
    UINT8 requestType,
    UINT16 feature,
    UINT16 index
    )

    {
    return OK;
    }


/***************************************************************************
*
* featureSet - invoked by usbTargLib for SET_FEATURE request
*
* RETURNS: OK, or ERROR if unable to set requested feature
*/

LOCAL STATUS featureSet
    (
    pVOID param,
    USB_TARG_CHANNEL targChannel,
    UINT8 requestType,
    UINT16 feature,
    UINT16 index
    )

    {
    return OK;
    }


/***************************************************************************
*
* configurationGet - invoked by usbTargLib for GET_CONFIGURATION request
*
* RETURNS: OK, or ERROR if unable to return configuration setting
*/

LOCAL STATUS configurationGet
    (
    pVOID param,
    USB_TARG_CHANNEL targChannel,
    pUINT8 pConfiguration
    )

    {
    *pConfiguration = curConfiguration;
    return OK;
    }


/***************************************************************************
*
* configurationSet - invoked by usbTargLib for SET_CONFIGURATION request
*
* RETURNS: OK, or ERROR if unable to set specified configuration
*/

LOCAL STATUS configurationSet
    (
    pVOID param,
    USB_TARG_CHANNEL targChannel,
    UINT8 configuration
    )

    {
    UINT16 i;


    if (configuration > KBD_CONFIG_VALUE)
	return ERROR;

    if ((curConfiguration = configuration) == KBD_CONFIG_VALUE)
	{
	/* Enable the interrupt status pipe if not already enabled. */

	if (intPipeHandle == NULL)
	    {
	    /* Find a suitable endpoint */

	    for (i = 2; i < numEndpoints; i++)
		if ((pEndpoints [i].flags & TCD_ENDPOINT_INT_OK) != 0 &&
		    (pEndpoints [i].flags & TCD_ENDPOINT_IN_OK) != 0)
		    break;

	    if (i == numEndpoints)
		return ERROR;

	    /* Create a pipe */

	    if (usbTargPipeCreate (targChannel, pEndpoints [i].endpointId, 0,
		KBD_INTERRUPT_ENDPOINT_NUM, configuration, KBD_INTERFACE_NUM, 
		USB_XFRTYPE_INTERRUPT, USB_DIR_IN, &intPipeHandle) != OK)
		return ERROR;

	    reportInUse = FALSE;
	    }
	}
    else
	{
	/* Disable the interrupt status pipe if it's enabled */

	if (intPipeHandle != NULL)
	    {
	    usbTargPipeDestroy (intPipeHandle);
	    intPipeHandle = NULL;
	    }
	}


    return OK;
    }


/***************************************************************************
*
* descriptorGet - invoked by usbTargLib for GET_DESCRIPTOR request
*
* RETURNS: OK, or ERROR if unable to return requested descriptor
*/

LOCAL STATUS descriptorGet
    (
    pVOID param,
    USB_TARG_CHANNEL targChannel,
    UINT8 requestType,
    UINT8 descriptorType,
    UINT8 descriptorIndex,
    UINT16 languageId,
    UINT16 length,
    pUINT8 pBfr,
    pUINT16 pActLen
    )

    {
    UINT8 bfr [USB_MAX_DESCR_LEN];
    UINT16 actLen;


    /* Determine type of descriptor being requested. */

    if (requestType == (USB_RT_DEV_TO_HOST | USB_RT_STANDARD | USB_RT_DEVICE))
	{
	switch (descriptorType)
	    {
	    case USB_DESCR_DEVICE:  
		usbDescrCopy (pBfr, &devDescr, length, pActLen);
		break;

	    case USB_DESCR_CONFIGURATION:
		memcpy (bfr, &configDescr, USB_CONFIG_DESCR_LEN);
		memcpy (&bfr [USB_CONFIG_DESCR_LEN], &ifDescr,
		    USB_INTERFACE_DESCR_LEN);
		memcpy (&bfr [USB_CONFIG_DESCR_LEN + USB_INTERFACE_DESCR_LEN],
		    &epDescr, USB_ENDPOINT_DESCR_LEN);

		actLen = min (length, USB_CONFIG_DESCR_LEN +
		    USB_INTERFACE_DESCR_LEN + USB_ENDPOINT_DESCR_LEN);

		memcpy (pBfr, bfr, actLen);
		*pActLen = actLen;
		break;

	    case USB_DESCR_INTERFACE:
		usbDescrCopy (pBfr, &ifDescr, length, pActLen);
		break;

	    case USB_DESCR_ENDPOINT:
		usbDescrCopy (pBfr, &epDescr, length, pActLen);
		break;
		    
	    case USB_DESCR_STRING:
		switch (descriptorIndex)
		    {
		    case 0: /* language descriptor */
			usbDescrCopy (pBfr, &langDescr, length, pActLen);
			break;

		    case ID_STR_MFG:
			usbDescrStrCopy (pBfr, pStrMfg, length, pActLen);
			break;

		    case ID_STR_PROD:
			usbDescrStrCopy (pBfr, pStrProd, length, pActLen);
			break;

		    default:
			return ERROR;
		    }
		break;

	    default:
		return ERROR;
	    }
	}
    else
	{
	return ERROR;
	}

    return OK;
    }


/***************************************************************************
*
* interfaceGet - invoked by usbTargLib for GET_INTERFACE request
*
* RETURNS: OK, or ERROR if unable to return interface setting
*/

LOCAL STATUS interfaceGet
    (
    pVOID param,
    USB_TARG_CHANNEL targChannel,
    UINT16 interfaceIndex,
    pUINT8 pAlternateSetting
    )

    {
    *pAlternateSetting = curAlternateSetting;
    return OK;
    }


/***************************************************************************
*
* interfaceSet - invoked by usbTargLib for SET_INTERFACE request
*
* RETURNS: OK, or ERROR if unable to set specified interface
*/

LOCAL STATUS interfaceSet
    (
    pVOID param,
    USB_TARG_CHANNEL targChannel,
    UINT16 interfaceIndex,
    UINT8 alternateSetting
    )

    {
    curAlternateSetting = alternateSetting;
    return OK;
    }


/***************************************************************************
*
* vendorSpecific - invoked by usbTargLib for VENDOR_SPECIFIC request
*
* RETURNS: OK, or ERROR if unable to process vendor-specific request
*/

LOCAL STATUS vendorSpecific
    (
    pVOID param,
    USB_TARG_CHANNEL targChannel,
    UINT8 requestType,
    UINT8 request,
    UINT16 value,
    UINT16 index,
    UINT16 length
    )

    {
    if (requestType == (USB_RT_HOST_TO_DEV | USB_RT_CLASS | USB_RT_INTERFACE))
	{
	switch (request)
	    {
	    case USB_REQ_HID_SET_PROTOCOL:
	    case USB_REQ_HID_SET_IDLE:

		/* This emulator simply acknowledges these HID requests...no
		 * processing is required. 
		 */

		usbTargControlResponseSend (targChannel, 0, NULL);
		return OK;

	    case USB_REQ_HID_SET_REPORT:

		/* This eumulator does not support LED settings.  However, this
		 * does give us an opportunity to test usbTargPipeStatusSet().
		 */

		usbTargPipeStatusSet (targChannel, NULL, TCD_ENDPOINT_STALL);
		return ERROR;

	    default:
		break;
	    }
	}

    return ERROR;
    }




/* End of file. */