usbtargphilipsd12evallib.c

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

*
* 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;
    }


/***************************************************************************
*
* 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
    )

    {
    if (configuration > CONFIG_VAL)
	return ERROR;

    if ((curConfiguration = configuration) == CONFIG_VAL)
	{
	/* Enable the pipes if not already enabled. */

	if (bulkOutPipeHandle == NULL)
	    {
	    /* Create a pipe */

	    if (usbTargPipeCreate (targChannel, D12_ENDPOINT_2_OUT, 0,
		2, configuration, 0, USB_XFRTYPE_BULK, USB_DIR_OUT, 
		&bulkOutPipeHandle) != OK)
		return ERROR;
	    }


	if (bulkInPipeHandle == NULL)
	    {
	    if (usbTargPipeCreate (targChannel, D12_ENDPOINT_2_IN, 0,
		2, configuration, 0, USB_XFRTYPE_BULK, USB_DIR_IN,
		&bulkInPipeHandle) != OK)
		return ERROR;
	    }
	}
    else
	{
	/* Disable the pipes */

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

	if (bulkInPipeHandle != NULL)
	    {
	    usbTargPipeDestroy (bulkInPipeHandle);
	    bulkInPipeHandle = 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],
		    &epDescr1, USB_ENDPOINT_DESCR_LEN);

		memcpy (&bfr [USB_CONFIG_DESCR_LEN + USB_INTERFACE_DESCR_LEN +
		    USB_ENDPOINT_DESCR_LEN], &epDescr2, USB_ENDPOINT_DESCR_LEN);
		memcpy (&bfr [USB_CONFIG_DESCR_LEN + USB_INTERFACE_DESCR_LEN +
		    USB_ENDPOINT_DESCR_LEN * 2], &epDescr3, USB_ENDPOINT_DESCR_LEN);
		memcpy (&bfr [USB_CONFIG_DESCR_LEN + USB_INTERFACE_DESCR_LEN +
		    USB_ENDPOINT_DESCR_LEN * 3], &epDescr4, USB_ENDPOINT_DESCR_LEN);

		actLen = min (length, CONFIG_DESCRIPTOR_LENGTH);

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

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

	    case USB_DESCR_ENDPOINT:
		switch (descriptorIndex)
		    {
		    case 0: usbDescrCopy (pBfr, &epDescr1, length, pActLen); break;
		    case 1: usbDescrCopy (pBfr, &epDescr2, length, pActLen); break;
		    case 2: usbDescrCopy (pBfr, &epDescr3, length, pActLen); break;
		    case 3: usbDescrCopy (pBfr, &epDescr4, length, pActLen); break;
		    }
		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;
    }


/***************************************************************************
*
* bulkErpCallback - called when report ERP terminates
*
* RETURNS: N/A
*/

LOCAL VOID bulkErpCallback
    (
    pVOID p			/* pointer to ERP */
    )

    {
    pUSB_ERP pErp = (pUSB_ERP) p;

    if (pErp->result == S_usbTcdLib_ERP_CANCELED)
	bulkCanceled++;
    else if (pErp->result != OK)
	bulkErrors++;

    bulkInUse = FALSE;
    }


/***************************************************************************
*
* initBulkErp - listen for output printer data
*
* RETURNS: OK, or ERROR if unable to submit ERP.
*/

LOCAL STATUS initBulkErp 
    (
    USB_TARG_PIPE pipeHandle,
    UINT16 pid,
    UINT16 bfrOffset,
    UINT16 length
    )

    {
    if (bulkBfr == NULL)
	return ERROR;

    if (bulkInUse)
	return ERROR;

    /* Initialize bulk ERP */

    memset (&bulkErp, 0, sizeof (bulkErp));

    bulkErp.erpLen = sizeof (bulkErp);
    bulkErp.userCallback = bulkErpCallback;
    bulkErp.bfrCount = 1;

    bulkErp.bfrList [0].pid = pid;
    bulkErp.bfrList [0].pBfr = bulkBfr + bfrOffset;
    bulkErp.bfrList [0].bfrLen = length;

    bulkInUse = TRUE;

    if (usbTargTransfer (pipeHandle, &bulkErp) != OK)
	{
	bulkInUse = FALSE;
	return ERROR;
	}

    return OK;
    }


/***************************************************************************
*
* setupDmaRequestCallback - called when payload received
*
* RETURNS: N/A
*/

LOCAL VOID setupDmaRequestCallback
    (
    pVOID p
    )

    {
    pUSB_ERP pErp = (pUSB_ERP) p;
    UINT16 bfrOffset;
    UINT16 length;
    UINT8 command;

    if (pErp->result == OK)
	{
	/* Examine the IO_REQUEST passed in the payload. */

	bfrOffset = ioRequest.bytes [0] | (ioRequest.bytes [1] << 8);
	length = ioRequest.bytes [3] | (ioRequest.bytes [4] << 8);
	command = ioRequest.bytes [5];

	if ((command & 0x1) != 0)
	    {
	    /* read request */

	    initBulkErp (bulkInPipeHandle, USB_PID_IN, bfrOffset, length);
	    }
	else
	    {
	    /* write request */

	    initBulkErp (bulkOutPipeHandle, USB_PID_OUT, bfrOffset, length);
	    }


	/* Send an acknowledgement of the command. */

	usbTargControlResponseSend (channel, NULL, 0);
	}
    }


/***************************************************************************
*
* 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_CATEGORY_MASK | USB_RT_RECIPIENT_MASK)) 
	== (USB_RT_VENDOR | USB_RT_DEVICE))
	{
	switch (request)
	    {
	    case READ_WRITE_REGISTER:

		if ((requestType & USB_RT_DIRECTION_MASK) != 0 &&
		    value == 0 && length == sizeof (fwVersion) &&
		    index == GET_FIRMWARE_VERSION)
		    {
		    /* Send firmware version back to host. */

		    return usbTargControlResponseSend (targChannel,
			sizeof (fwVersion), &fwVersion);
		    }

		else if ((requestType & USB_RT_DIRECTION_MASK) == 0 &&
		    value == 0 && length == IO_REQUEST_LEN && 
		    index == SETUP_DMA_REQUEST)
		    {
		    /* Fetch the payload for the command. */

		    memset (&payloadErp, 0, sizeof (payloadErp));
		    payloadErp.erpLen = sizeof (payloadErp);
		    payloadErp.userCallback = setupDmaRequestCallback;
		    payloadErp.dataToggle = USB_DATA1;
		    payloadErp.bfrCount = 1;
		    payloadErp.bfrList [0].pid = USB_PID_OUT;
		    payloadErp.bfrList [0].pBfr = (pUINT8) &ioRequest;
		    payloadErp.bfrList [0].bfrLen = IO_REQUEST_LEN;

		    return usbTargControlPayloadRcv (targChannel,
			&payloadErp);
		    }

		break;

	    default:
		break;
	    }
	}

    return ERROR;
    }




/* End of file. */