开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
usbTargPhilipsD12EvalLib.c
资源名称：ixp425BSP.rar　[点击查看]
上传用户：luoyougen
上传日期：2008-05-12
资源大小：23136k
文件大小：19k
源码类别：

VxWorks

开发平台：

C/C++

usbTargPhilipsD12EvalLib.c：源码内容
  1. /* usbTargPhilipsD12EvalLib.c - emulates Philips PDIUSBD12 eval firmware */
  3. /* Copyright 2000 Wind River Systems, Inc. */
  5. /*
  6. Modification history
  7. --------------------
  8. 01d,19mar00,rcb  Add handling for CLEAR_FEATURE...Newer Philips test
  9.  program now invokes this function.
  10. 01c,23nov99,rcb  Change #include ../xxx references to lower case.
  11. 01b,12nov99,rcb  Shorted path names...affects "#include" directives.
  12. 01a,03sep99,rcb  First.
  13. */
  15. /*
  16. DESCRIPTION
  18. The Philips PDIUSBD12 evaluation kit is shipped with sample firmware.  The
  19. "firmware" is a program which runs under MS-DOS and responds to certain standard
  20. and "vendor specific" USB requests.  A custom Windows application - also provided
  21. by Philips - can be used to exercise this "firmware".
  23. In order to provide a different example of working target behavoir, this module
  24. emulates the behavoir of the Philips evaluation firmware, allowing this target
  25. module to work with the Philips Windows-based exerciser program.  The "scan",
  26. "print", and "loopback" portions of that test work correctly.  The "LED buttons"
  27. supported by the Philips firmware are not emulated, and do nothing.
  29. It is the caller's responsibility to initialize usbTargLib and attach a USB TCD 
  30. to it. When attaching a TCD to usbTargLib, the caller must pass a pointer to a
  31. table of callbacks required by usbTargLib.  The address of this table and the
  32. "callback parameter" required by these callbacks may be obtained by calling
  33. usbTargPhilipsD12EvalCallbackInfo().  It is not necessary to initialize the 
  34. usbTartPhilipsD12EvalLib or to shut it down.  It performs all of its operations
  35. in response to callbacks from usbTargLib.
  36. */
  39. /* includes */
  41. #include "usb/usbPlatform.h"
  43. #include "string.h"
  45. #include "usb/usb.h"
  46. #include "usb/usbDescrCopyLib.h"     /* USB utility functions */
  47. #include "usb/target/usbTargLib.h" /* USB target functions */
  49. #include "drv/usb/target/usbPdiusbd12.h" /* Philips definitions */
  50. #include "drv/usb/target/usbTargPhilipsD12EvalLib.h" /* our API */
  55. /* defines */
  57. #define BULK_BFR_LEN     64000     /* size used by Philips */
  60. /* string identifiers */
  62. #define UNICODE_ENGLISH     0x409
  64. #define ID_STR_MFG     1
  65. #define ID_STR_MFG_VAL     "Wind River Systems"
  67. #define ID_STR_PROD     2
  68. #define ID_STR_PROD_VAL     "Philips firmware emulator"
  71. /* descriptor constants */
  73. #define CONFIG_VAL 1
  75. #define NUM_ENDPOINTS 4
  77. #define CONFIG_DESCRIPTOR_LENGTH    
  78.     USB_CONFIG_DESCR_LEN + USB_INTERFACE_DESCR_LEN + 
  79.     (NUM_ENDPOINTS * USB_ENDPOINT_DESCR_LEN)
  82. /* vendor specific commands */
  84. #define READ_WRITE_REGISTER 12
  87. /* wIndex parameters to the vendor specific READ_WRITE_REGISTER cmd */
  89. #define SETUP_DMA_REQUEST 0x0471
  90. #define GET_FIRMWARE_VERSION 0x0472
  91. #define GET_SET_TWAIN_REQUEST 0x0473
  94. /* typedefs */
  96. /* IO_REQUEST is the parameter to the SETUP_DMA_REQUEST vendor-specific
  97.  * command.
  98.  */
  100. #define IO_REQUEST_LEN 6
  102. typedef struct io_request {
  103.     UINT8 bytes [IO_REQUEST_LEN];
  104. } IO_REQUEST, *pIO_REQUEST;
  107. /* forward declarations */
  109. LOCAL STATUS mngmtFunc
  110.     (
  111.     pVOID param,
  112.     USB_TARG_CHANNEL targChannel,
  113.     UINT16 mngmtCode
  114.     );
  116. LOCAL STATUS featureClear
  117.     (
  118.     pVOID param,
  119.     USB_TARG_CHANNEL targChannel,
  120.     UINT8 requestType,
  121.     UINT16 feature,
  122.     UINT16 index
  123.     );
  125. LOCAL STATUS configurationGet
  126.     (
  127.     pVOID param,
  128.     USB_TARG_CHANNEL targChannel,
  129.     pUINT8 pConfiguration
  130.     );
  132. LOCAL STATUS configurationSet
  133.     (
  134.     pVOID param,
  135.     USB_TARG_CHANNEL targChannel,
  136.     UINT8 configuration
  137.     );
  139. LOCAL STATUS descriptorGet
  140.     (
  141.     pVOID param,
  142.     USB_TARG_CHANNEL targChannel,
  143.     UINT8 requestType,
  144.     UINT8 descriptorType,
  145.     UINT8 descriptorIndex,
  146.     UINT16 languageId,
  147.     UINT16 length,
  148.     pUINT8 pBfr,
  149.     pUINT16 pActLen
  150.     );
  152. LOCAL STATUS interfaceGet
  153.     (
  154.     pVOID param,
  155.     USB_TARG_CHANNEL targChannel,
  156.     UINT16 interfaceIndex,
  157.     pUINT8 pAlternateSetting
  158.     );
  160. LOCAL STATUS interfaceSet
  161.     (
  162.     pVOID param,
  163.     USB_TARG_CHANNEL targChannel,
  164.     UINT16 interfaceIndex,
  165.     UINT8 alternateSetting
  166.     );
  169. LOCAL STATUS vendorSpecific
  170.     (
  171.     pVOID param,
  172.     USB_TARG_CHANNEL targChannel,
  173.     UINT8 requestType,
  174.     UINT8 request,
  175.     UINT16 value,
  176.     UINT16 index,
  177.     UINT16 length
  178.     );
  181. LOCAL STATUS initBulkErp 
  182.     (
  183.     USB_TARG_PIPE pipeHandle,
  184.     UINT16 pid,
  185.     UINT16 bfrOffset,
  186.     UINT16 length
  187.     );
  190. /* locals */
  192. LOCAL USB_TARG_CALLBACK_TABLE usbTargPrnCallbackTable =
  193.     {
  194.     mngmtFunc, /* mngmtFunc */
  195.     featureClear, /* featureClear */
  196.     NULL, /* featureSet */
  197.     configurationGet, /* configurationGet */
  198.     configurationSet, /* configurationSet */
  199.     descriptorGet, /* descriptorGet */
  200.     NULL, /* descriptorSet */
  201.     interfaceGet, /* interfaceGet */
  202.     interfaceSet, /* interfaceSet */
  203.     NULL, /* statusGet */
  204.     NULL, /* addressSet */
  205.     NULL, /* synchFrameGet */
  206.     vendorSpecific, /* vendorSpecific */
  207.     };
  210. LOCAL USB_TARG_CHANNEL channel;
  211. LOCAL UINT16 numEndpoints;
  212. LOCAL pUSB_TARG_ENDPOINT_INFO pEndpoints;
  214. LOCAL UINT16 curConfiguration;
  215. LOCAL UINT16 curAlternateSetting;
  217. LOCAL USB_TARG_PIPE bulkOutPipeHandle;
  218. LOCAL USB_TARG_PIPE bulkInPipeHandle;
  220. LOCAL USB_ERP payloadErp;
  221. LOCAL IO_REQUEST ioRequest;
  223. LOCAL USB_ERP bulkErp;
  224. LOCAL pUINT8 bulkBfr;
  225. LOCAL BOOL bulkInUse;
  227. LOCAL UINT32 bulkCanceled;
  228. LOCAL UINT32 bulkErrors;
  230. LOCAL UINT8 fwVersion = 0x01;     /* version for PDIUSBD12 PC kit */
  233. /* descriptors */
  235. LOCAL USB_LANGUAGE_DESCR langDescr =
  236.     {sizeof (USB_LANGUAGE_DESCR), USB_DESCR_STRING, 
  237. {TO_LITTLEW (UNICODE_ENGLISH)}};
  239. LOCAL char *pStrMfg = ID_STR_MFG_VAL;
  240. LOCAL char *pStrProd = ID_STR_PROD_VAL;
  243. LOCAL USB_DEVICE_DESCR devDescr =
  244.     {
  245.     USB_DEVICE_DESCR_LEN,     /* bLength */
  246.     USB_DESCR_DEVICE,     /* bDescriptorType */
  247.     TO_LITTLEW (0x0100),     /* bcdUsb */
  248.     0xdc, /* test class */     /* bDeviceClass */
  249.     0,     /* bDeviceSubclass */
  250.     0,     /* bDeviceProtocol */
  251.     USB_MIN_CTRL_PACKET_SIZE,     /* maxPacketSize0 */
  252.     TO_LITTLEW (0x0471),     /* idVendor */
  253.     TO_LITTLEW (0x0222),     /* idProduct */
  254.     TO_LITTLEW (0x0100),     /* bcdDevice */
  255.     ID_STR_MFG,      /* iManufacturer */
  256.     ID_STR_PROD,     /* iProduct */
  257.     0,     /* iSerialNumber */
  258.     1     /* bNumConfigurations */
  259.     };
  261. LOCAL USB_CONFIG_DESCR configDescr =
  262.     {
  263.     USB_CONFIG_DESCR_LEN,     /* bLength */
  264.     USB_DESCR_CONFIGURATION,     /* bDescriptorType */
  265.     TO_LITTLEW (CONFIG_DESCRIPTOR_LENGTH), /* wTotalLength */
  266.     1,     /* bNumInterfaces */
  267.     CONFIG_VAL,      /* bConfigurationValue */
  268.     0,     /* iConfiguration */
  269.     USB_ATTR_SELF_POWERED,     /* bmAttributes */
  270.     0     /* MaxPower */
  271.     };
  273. LOCAL USB_INTERFACE_DESCR ifDescr =
  274.     {
  275.     USB_INTERFACE_DESCR_LEN,     /* bLength */
  276.     USB_DESCR_INTERFACE,     /* bDescriptorType */
  277.     0,     /* bInterfaceNumber */
  278.     0,     /* bAlternateSetting */
  279.     NUM_ENDPOINTS,     /* bNumEndpoints */
  280.     0xdc, /* test class */     /* bInterfaceClass */
  281.     0xa0,     /* bInterfaceSubClass */
  282.     0xb0,     /* bInterfaceProtocol */
  283.     0     /* iInterface */
  284.     };
  286. LOCAL USB_ENDPOINT_DESCR epDescr1 =
  287.     {
  288.     USB_ENDPOINT_DESCR_LEN,     /* bLength */
  289.     USB_DESCR_ENDPOINT,      /* bDescriptorType */
  290.     0x81,     /* bEndpointAddress */
  291.     USB_ATTR_INTERRUPT,      /* bmAttributes */
  292.     USB_MIN_CTRL_PACKET_SIZE,     /* maxPacketSize */
  293.     10     /* bInterval */
  294.     };
  296. LOCAL USB_ENDPOINT_DESCR epDescr2 =
  297.     {
  298.     USB_ENDPOINT_DESCR_LEN,     /* bLength */
  299.     USB_DESCR_ENDPOINT,      /* bDescriptorType */
  300.     0x01,     /* bEndpointAddress */
  301.     USB_ATTR_INTERRUPT,      /* bmAttributes */
  302.     USB_MIN_CTRL_PACKET_SIZE,     /* maxPacketSize */
  303.     10     /* bInterval */
  304.     };
  306. LOCAL USB_ENDPOINT_DESCR epDescr3 =
  307.     {
  308.     USB_ENDPOINT_DESCR_LEN,     /* bLength */
  309.     USB_DESCR_ENDPOINT,      /* bDescriptorType */
  310.     0x82,     /* bEndpointAddress */
  311.     USB_ATTR_BULK,     /* bmAttributes */
  312.     USB_MIN_CTRL_PACKET_SIZE,     /* maxPacketSize */
  313.     0     /* bInterval */
  314.     };
  316. LOCAL USB_ENDPOINT_DESCR epDescr4 =
  317.     {
  318.     USB_ENDPOINT_DESCR_LEN,     /* bLength */
  319.     USB_DESCR_ENDPOINT,      /* bDescriptorType */
  320.     0x02,     /* bEndpointAddress */
  321.     USB_ATTR_BULK,     /* bmAttributes */
  322.     USB_MIN_CTRL_PACKET_SIZE,     /* maxPacketSize */
  323.     0     /* bInterval */
  324.     };
  327. /* functions */
  329. /***************************************************************************
  330. *
  331. * usbTargPhilipsD12EvalCallbackInfo - returns callback table
  332. *
  333. * RETURNS: N/A
  334. */
  336. VOID usbTargPhilipsD12EvalCallbackInfo
  337.     (
  338.     pUSB_TARG_CALLBACK_TABLE *ppCallbacks,
  339.     pVOID *pCallbackParam
  340.     )
  342.     {
  343.     if (ppCallbacks != NULL)
  344. *ppCallbacks = &usbTargPrnCallbackTable;
  346.     if (pCallbackParam != NULL)
  347. *pCallbackParam = NULL;
  348.     }
  351. /***************************************************************************
  352. *
  353. * mngmtFunc - invoked by usbTargLib for connection management events
  354. *
  355. * RETURNS: OK if able to handle event, or ERROR if unable to handle event
  356. */
  358. LOCAL STATUS mngmtFunc
  359.     (
  360.     pVOID param,
  361.     USB_TARG_CHANNEL targChannel,
  362.     UINT16 mngmtCode     /* management code */
  363.     )
  365.     {
  366.     switch (mngmtCode)
  367. {
  368. case TCD_MNGMT_ATTACH:
  370.     /* Initialize global data */
  372.     channel = targChannel;
  373.     usbTargEndpointInfoGet (targChannel, &numEndpoints, &pEndpoints);
  375.     curConfiguration = 0;
  376.     curAlternateSetting = 0;
  377.     bulkInPipeHandle = NULL;
  378.     bulkOutPipeHandle = NULL;
  379.     bulkCanceled = 0;
  380.     bulkErrors = 0;
  382.     /* Initialize control pipe maxPacketSize. */
  384.     devDescr.maxPacketSize0 = pEndpoints [0].maxPacketSize;
  386.     /* Initialize bulk endpoint max packet size. */
  388.     epDescr1.maxPacketSize = 
  389. pEndpoints [D12_ENDPOINT_1_IN].intInMaxPacketSize;
  391.     epDescr2.maxPacketSize =
  392. pEndpoints [D12_ENDPOINT_1_OUT].intOutMaxPacketSize;
  394.     epDescr3.maxPacketSize =
  395. pEndpoints [D12_ENDPOINT_2_IN].bulkInMaxPacketSize;
  397.     epDescr4.maxPacketSize =
  398. pEndpoints [D12_ENDPOINT_2_OUT].bulkOutMaxPacketSize;
  399.     
  401.     /* Allocate buffer */
  403.     if ((bulkBfr = OSS_MALLOC (BULK_BFR_LEN)) == NULL)
  404. return ERROR;
  406.     break;
  408. case TCD_MNGMT_DETACH:
  410.     /* De-allocate buffer */
  412.     if (bulkBfr != NULL)
  413. {
  414. OSS_FREE (bulkBfr);
  415. bulkBfr = NULL;
  416. }
  418.     break;
  420. case TCD_MNGMT_BUS_RESET:
  421. case TCD_MNGMT_VBUS_LOST:
  423.     /* revert to power-ON configuration */
  425.     configurationSet (param, targChannel, 0);
  426.     break;     
  428. default:
  429.     break;
  430. }
  432.     return OK;
  433.     }
  436. /***************************************************************************
  437. *
  438. * featureClear - invoked by usbTargLib for CLEAR_FEATURE request
  439. *
  440. * RETURNS: OK, or ERROR if unable to clear requested feature
  441. */
  443. LOCAL STATUS featureClear
  444.     (
  445.     pVOID param,
  446.     USB_TARG_CHANNEL targChannel,
  447.     UINT8 requestType,
  448.     UINT16 feature,
  449.     UINT16 index
  450.     )
  452.     {
  453.     return OK;
  454.     }
  457. /***************************************************************************
  458. *
  459. * configurationGet - invoked by usbTargLib for GET_CONFIGURATION request
  460. *
  461. * RETURNS: OK, or ERROR if unable to return configuration setting
  462. */
  464. LOCAL STATUS configurationGet
  465.     (
  466.     pVOID param,
  467.     USB_TARG_CHANNEL targChannel,
  468.     pUINT8 pConfiguration
  469.     )
  471.     {
  472.     *pConfiguration = curConfiguration;
  473.     return OK;
  474.     }
  477. /***************************************************************************
  478. *
  479. * configurationSet - invoked by usbTargLib for SET_CONFIGURATION request
  480. *
  481. * RETURNS: OK, or ERROR if unable to set specified configuration
  482. */
  484. LOCAL STATUS configurationSet
  485.     (
  486.     pVOID param,
  487.     USB_TARG_CHANNEL targChannel,
  488.     UINT8 configuration
  489.     )
  491.     {
  492.     if (configuration > CONFIG_VAL)
  493. return ERROR;
  495.     if ((curConfiguration = configuration) == CONFIG_VAL)
  496. {
  497. /* Enable the pipes if not already enabled. */
  499. if (bulkOutPipeHandle == NULL)
  500.     {
  501.     /* Create a pipe */
  503.     if (usbTargPipeCreate (targChannel, D12_ENDPOINT_2_OUT, 0,
  504. 2, configuration, 0, USB_XFRTYPE_BULK, USB_DIR_OUT, 
  505. &bulkOutPipeHandle) != OK)
  506. return ERROR;
  507.     }
  510. if (bulkInPipeHandle == NULL)
  511.     {
  512.     if (usbTargPipeCreate (targChannel, D12_ENDPOINT_2_IN, 0,
  513. 2, configuration, 0, USB_XFRTYPE_BULK, USB_DIR_IN,
  514. &bulkInPipeHandle) != OK)
  515. return ERROR;
  516.     }
  517. }
  518.     else
  519. {
  520. /* Disable the pipes */
  522. if (bulkOutPipeHandle != NULL)
  523.     {
  524.     usbTargPipeDestroy (bulkOutPipeHandle);
  525.     bulkOutPipeHandle = NULL;
  526.     }
  528. if (bulkInPipeHandle != NULL)
  529.     {
  530.     usbTargPipeDestroy (bulkInPipeHandle);
  531.     bulkInPipeHandle = NULL;
  532.     }
  533. }
  536.     return OK;
  537.     }
  540. /***************************************************************************
  541. *
  542. * descriptorGet - invoked by usbTargLib for GET_DESCRIPTOR request
  543. *
  544. * RETURNS: OK, or ERROR if unable to return requested descriptor
  545. */
  547. LOCAL STATUS descriptorGet
  548.     (
  549.     pVOID param,
  550.     USB_TARG_CHANNEL targChannel,
  551.     UINT8 requestType,
  552.     UINT8 descriptorType,
  553.     UINT8 descriptorIndex,
  554.     UINT16 languageId,
  555.     UINT16 length,
  556.     pUINT8 pBfr,
  557.     pUINT16 pActLen
  558.     )
  560.     {
  561.     UINT8 bfr [USB_MAX_DESCR_LEN];
  562.     UINT16 actLen;
  565.     /* Determine type of descriptor being requested. */
  567.     if (requestType == (USB_RT_DEV_TO_HOST | USB_RT_STANDARD | USB_RT_DEVICE))
  568. {
  569. switch (descriptorType)
  570.     {
  571.     case USB_DESCR_DEVICE:  
  572. usbDescrCopy (pBfr, &devDescr, length, pActLen);
  573. break;
  575.     case USB_DESCR_CONFIGURATION:
  576. memcpy (bfr, &configDescr, USB_CONFIG_DESCR_LEN);
  577. memcpy (&bfr [USB_CONFIG_DESCR_LEN], &ifDescr,
  578.     USB_INTERFACE_DESCR_LEN);
  580. memcpy (&bfr [USB_CONFIG_DESCR_LEN + USB_INTERFACE_DESCR_LEN],
  581.     &epDescr1, USB_ENDPOINT_DESCR_LEN);
  583. memcpy (&bfr [USB_CONFIG_DESCR_LEN + USB_INTERFACE_DESCR_LEN +
  584.     USB_ENDPOINT_DESCR_LEN], &epDescr2, USB_ENDPOINT_DESCR_LEN);
  585. memcpy (&bfr [USB_CONFIG_DESCR_LEN + USB_INTERFACE_DESCR_LEN +
  586.     USB_ENDPOINT_DESCR_LEN * 2], &epDescr3, USB_ENDPOINT_DESCR_LEN);
  587. memcpy (&bfr [USB_CONFIG_DESCR_LEN + USB_INTERFACE_DESCR_LEN +
  588.     USB_ENDPOINT_DESCR_LEN * 3], &epDescr4, USB_ENDPOINT_DESCR_LEN);
  590. actLen = min (length, CONFIG_DESCRIPTOR_LENGTH);
  592. memcpy (pBfr, bfr, actLen);
  593. *pActLen = actLen;
  594. break;
  596.     case USB_DESCR_INTERFACE:
  597. usbDescrCopy (pBfr, &ifDescr, length, pActLen);
  598. break;
  600.     case USB_DESCR_ENDPOINT:
  601. switch (descriptorIndex)
  602.     {
  603.     case 0: usbDescrCopy (pBfr, &epDescr1, length, pActLen); break;
  604.     case 1: usbDescrCopy (pBfr, &epDescr2, length, pActLen); break;
  605.     case 2: usbDescrCopy (pBfr, &epDescr3, length, pActLen); break;
  606.     case 3: usbDescrCopy (pBfr, &epDescr4, length, pActLen); break;
  607.     }
  608. break;
  609.     
  610.     case USB_DESCR_STRING:
  611. switch (descriptorIndex)
  612.     {
  613.     case 0: /* language descriptor */
  614. usbDescrCopy (pBfr, &langDescr, length, pActLen);
  615. break;
  617.     case ID_STR_MFG:
  618. usbDescrStrCopy (pBfr, pStrMfg, length, pActLen);
  619. break;
  621.     case ID_STR_PROD:
  622. usbDescrStrCopy (pBfr, pStrProd, length, pActLen);
  623. break;
  625.     default:
  626. return ERROR;
  627.     }
  628. break;
  630.     default:
  631. return ERROR;
  632.     }
  633. }
  634.     else
  635. {
  636. return ERROR;
  637. }
  639.     return OK;
  640.     }
  643. /***************************************************************************
  644. *
  645. * interfaceGet - invoked by usbTargLib for GET_INTERFACE request
  646. *
  647. * RETURNS: OK, or ERROR if unable to return interface setting
  648. */
  650. LOCAL STATUS interfaceGet
  651.     (
  652.     pVOID param,
  653.     USB_TARG_CHANNEL targChannel,
  654.     UINT16 interfaceIndex,
  655.     pUINT8 pAlternateSetting
  656.     )
  658.     {
  659.     *pAlternateSetting = curAlternateSetting;
  660.     return OK;
  661.     }
  664. /***************************************************************************
  665. *
  666. * interfaceSet - invoked by usbTargLib for SET_INTERFACE request
  667. *
  668. * RETURNS: OK, or ERROR if unable to set specified interface
  669. */
  671. LOCAL STATUS interfaceSet
  672.     (
  673.     pVOID param,
  674.     USB_TARG_CHANNEL targChannel,
  675.     UINT16 interfaceIndex,
  676.     UINT8 alternateSetting
  677.     )
  679.     {
  680.     curAlternateSetting = alternateSetting;
  681.     return OK;
  682.     }
  685. /***************************************************************************
  686. *
  687. * bulkErpCallback - called when report ERP terminates
  688. *
  689. * RETURNS: N/A
  690. */
  692. LOCAL VOID bulkErpCallback
  693.     (
  694.     pVOID p /* pointer to ERP */
  695.     )
  697.     {
  698.     pUSB_ERP pErp = (pUSB_ERP) p;
  700.     if (pErp->result == S_usbTcdLib_ERP_CANCELED)
  701. bulkCanceled++;
  702.     else if (pErp->result != OK)
  703. bulkErrors++;
  705.     bulkInUse = FALSE;
  706.     }
  709. /***************************************************************************
  710. *
  711. * initBulkErp - listen for output printer data
  712. *
  713. * RETURNS: OK, or ERROR if unable to submit ERP.
  714. */
  716. LOCAL STATUS initBulkErp 
  717.     (
  718.     USB_TARG_PIPE pipeHandle,
  719.     UINT16 pid,
  720.     UINT16 bfrOffset,
  721.     UINT16 length
  722.     )
  724.     {
  725.     if (bulkBfr == NULL)
  726. return ERROR;
  728.     if (bulkInUse)
  729. return ERROR;
  731.     /* Initialize bulk ERP */
  733.     memset (&bulkErp, 0, sizeof (bulkErp));
  735.     bulkErp.erpLen = sizeof (bulkErp);
  736.     bulkErp.userCallback = bulkErpCallback;
  737.     bulkErp.bfrCount = 1;
  739.     bulkErp.bfrList [0].pid = pid;
  740.     bulkErp.bfrList [0].pBfr = bulkBfr + bfrOffset;
  741.     bulkErp.bfrList [0].bfrLen = length;
  743.     bulkInUse = TRUE;
  745.     if (usbTargTransfer (pipeHandle, &bulkErp) != OK)
  746. {
  747. bulkInUse = FALSE;
  748. return ERROR;
  749. }
  751.     return OK;
  752.     }
  755. /***************************************************************************
  756. *
  757. * setupDmaRequestCallback - called when payload received
  758. *
  759. * RETURNS: N/A
  760. */
  762. LOCAL VOID setupDmaRequestCallback
  763.     (
  764.     pVOID p
  765.     )
  767.     {
  768.     pUSB_ERP pErp = (pUSB_ERP) p;
  769.     UINT16 bfrOffset;
  770.     UINT16 length;
  771.     UINT8 command;
  773.     if (pErp->result == OK)
  774. {
  775. /* Examine the IO_REQUEST passed in the payload. */
  777. bfrOffset = ioRequest.bytes [0] | (ioRequest.bytes [1] << 8);
  778. length = ioRequest.bytes [3] | (ioRequest.bytes [4] << 8);
  779. command = ioRequest.bytes [5];
  781. if ((command & 0x1) != 0)
  782.     {
  783.     /* read request */
  785.     initBulkErp (bulkInPipeHandle, USB_PID_IN, bfrOffset, length);
  786.     }
  787. else
  788.     {
  789.     /* write request */
  791.     initBulkErp (bulkOutPipeHandle, USB_PID_OUT, bfrOffset, length);
  792.     }
  795. /* Send an acknowledgement of the command. */
  797. usbTargControlResponseSend (channel, NULL, 0);
  798. }
  799.     }
  802. /***************************************************************************
  803. *
  804. * vendorSpecific - invoked by usbTargLib for VENDOR_SPECIFIC request
  805. *
  806. * RETURNS: OK, or ERROR if unable to process vendor-specific request
  807. */
  809. LOCAL STATUS vendorSpecific
  810.     (
  811.     pVOID param,
  812.     USB_TARG_CHANNEL targChannel,
  813.     UINT8 requestType,
  814.     UINT8 request,
  815.     UINT16 value,
  816.     UINT16 index,
  817.     UINT16 length
  818.     )
  820.     {
  821.     if ((requestType & (USB_RT_CATEGORY_MASK | USB_RT_RECIPIENT_MASK)) 
  822. == (USB_RT_VENDOR | USB_RT_DEVICE))
  823. {
  824. switch (request)
  825.     {
  826.     case READ_WRITE_REGISTER:
  828. if ((requestType & USB_RT_DIRECTION_MASK) != 0 &&
  829.     value == 0 && length == sizeof (fwVersion) &&
  830.     index == GET_FIRMWARE_VERSION)
  831.     {
  832.     /* Send firmware version back to host. */
  834.     return usbTargControlResponseSend (targChannel,
  835. sizeof (fwVersion), &fwVersion);
  836.     }
  838. else if ((requestType & USB_RT_DIRECTION_MASK) == 0 &&
  839.     value == 0 && length == IO_REQUEST_LEN && 
  840.     index == SETUP_DMA_REQUEST)
  841.     {
  842.     /* Fetch the payload for the command. */
  844.     memset (&payloadErp, 0, sizeof (payloadErp));
  845.     payloadErp.erpLen = sizeof (payloadErp);
  846.     payloadErp.userCallback = setupDmaRequestCallback;
  847.     payloadErp.dataToggle = USB_DATA1;
  848.     payloadErp.bfrCount = 1;
  849.     payloadErp.bfrList [0].pid = USB_PID_OUT;
  850.     payloadErp.bfrList [0].pBfr = (pUINT8) &ioRequest;
  851.     payloadErp.bfrList [0].bfrLen = IO_REQUEST_LEN;
  853.     return usbTargControlPayloadRcv (targChannel,
  854. &payloadErp);
  855.     }
  857. break;
  859.     default:
  860. break;
  861.     }
  862. }
  864.     return ERROR;
  865.     }
  870. /* End of file. */