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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 传真(Fax)编程 > 查看源码
USB_Standard_Requests.#1
资源名称：TR1000_Old_071130.rar　[点击查看]
上传用户：gxz1972
上传日期：2019-09-13
资源大小：323k
文件大小：14k
源码类别：

传真(Fax)编程

开发平台：

C/C++

USB_Standard_Requests.#1：源码内容
  1. //-----------------------------------------------------------------------------
  2. // USB_Standard_Requests.c
  3. //-----------------------------------------------------------------------------
  4. // Copyright 2007 Vson Technology, Inc.
  5. // http://www.usbmcu.com
  6. //
  7. // Program Description:
  8. //
  9. //
  10. //
  11. //
  12. //
  13. // MCU:            C8051F347
  14. // Tool chain:     Keil C51 7.50 / Keil EVAL C51
  15. //                 Silicon Laboratories IDE version 2.6
  16. // Command Line:   
  17. // Project Name:   TR1000
  18. //
  19. //
  20. // Release 1.0
  21. //    -All changes by Brian Cai
  22. //    -24 JUL 2007
  23. //
  24. //
  26. //-----------------------------------------------------------------------------
  27. // Includes
  28. //-----------------------------------------------------------------------------
  30. #include "Include_H.h"
  32. //-----------------------------------------------------------------------------
  33. // USB_Standard_Requests.c Global Variables
  34. //-----------------------------------------------------------------------------
  36. BYTE        bEpState;
  37. UINT        uNumBytes;
  38. PIF_STATUS  pIfStatus;
  41. //------------------------------------------------------------------------
  42. //  Standard Request Routines
  43. //------------------------------------------------------------------------
  44. //
  45. // These functions should be called when an endpoint0 command has
  46. // been received with a corresponding "bRequest" field.
  47. //
  48. // - Each routine performs all command field checking, and
  49. //   modifies fields of the Ep0Status structure accordingly
  50. //
  51. // After a call to a standard request routine, the calling routine
  52. // should check Ep0Status.bEpState to determine the required action
  53. // (i.e., send a STALL for EP_ERROR, load the FIFO for EP_TX).
  54. // For transmit status, the data pointer (Ep0Status.pData),
  55. // and data length (Ep0Status.uNumBytes) are prepared before the
  56. // standard request routine returns. The calling routine must write
  57. // the data to the FIFO and handle all data transfer
  59. //-----------------------------------------------------------------------------
  60. // SetAddressRequest
  61. //-----------------------------------------------------------------------------
  62. //
  63. // Return Value : None
  64. // Parameters   : None
  65. //
  66. //-----------------------------------------------------------------------------
  67. void SetAddressRequest ()
  68. {
  69.    // Index and Length fields must be zero
  70.    // Device state must be default or addressed
  71.    if ((gEp0Command.wIndex.i) || (gEp0Command.wLength.i) ||
  72.    (gDeviceStatus.bDevState == DEV_CONFIG))
  73.    {
  74.       bEpState = EP_ERROR;
  75.    }
  77.    else
  78.    {
  79.       // Assign new function address
  80.       UWRITE_BYTE(FADDR, gEp0Command.wValue.c[1]);
  81.       if (gDeviceStatus.bDevState == DEV_DEFAULT &&
  82.       gEp0Command.wValue.c[1] != 0)
  83.       {
  84.          gDeviceStatus.bDevState = DEV_ADDRESS;
  85.       }
  86.       if (gDeviceStatus.bDevState == DEV_ADDRESS &&
  87.       gEp0Command.wValue.c[1] == 0)
  88.       {
  89.          gDeviceStatus.bDevState = DEV_ADDRESS;
  90.       }
  91.       bEpState = EP_IDLE;
  92.    }
  93.    gEp0Status.bEpState = bEpState;
  94. }
  96. //-----------------------------------------------------------------------------
  97. // SetFeatureRequest
  98. //-----------------------------------------------------------------------------
  99. //
  100. // Return Value : None
  101. // Parameters   : None
  102. //
  103. //-----------------------------------------------------------------------------
  104. void SetFeatureRequest ()
  105. {
  106.    // Length field must be zero
  107.    // Device state must be configured, or addressed with Command Index
  108.    // field == 0
  109.    if ((gEp0Command.wLength.i != 0) ||
  110.    (gDeviceStatus.bDevState == DEV_DEFAULT) ||
  111.    (gDeviceStatus.bDevState == DEV_ADDRESS && gEp0Command.wIndex.i != 0))
  112.    {
  113.       bEpState = EP_ERROR;
  114.    }
  116.    // Handle based on recipient
  117.    switch(gEp0Command.bmRequestType & CMD_MASK_RECIP)
  118.    {
  119.       // Device Request - Return error as remote wakeup is not supported
  120.       case CMD_RECIP_DEV:
  121.          bEpState = EP_ERROR;
  122.          break;
  124.       // Endpoint Request
  125.       case CMD_RECIP_EP:
  126.          if (gEp0Command.wValue.i == ENDPOINT_HALT)
  127.          {
  128.             bEpState = HaltEndpoint(gEp0Command.wIndex.i);
  129.             break;
  130.          }
  131.          else
  132.          {
  133.             bEpState = EP_ERROR;
  134.             break;
  135.          }
  136.       default:
  137.          bEpState = EP_ERROR;
  138.          break;
  139.    }
  140.    gEp0Status.bEpState = bEpState;
  141. }
  143. //-----------------------------------------------------------------------------
  144. // ClearFeatureRequest
  145. //-----------------------------------------------------------------------------
  146. //
  147. // Return Value : None
  148. // Parameters   : None
  149. //
  150. //-----------------------------------------------------------------------------
  151. void ClearFeatureRequest ()
  152. {
  153.    // Length field must be zero
  154.    // Device state must be configured, or addressed with Command Index
  155.    // field == 0
  156.    if ((gEp0Command.wLength.i != 0) || (gDeviceStatus.bDevState == DEV_DEFAULT) ||
  157.    (gDeviceStatus.bDevState == DEV_ADDRESS && gEp0Command.wIndex.i != 0))
  158.    {
  159.       bEpState = EP_ERROR;
  160.    }
  162.    // Handle based on recipient
  163.    switch(gEp0Command.bmRequestType & CMD_MASK_RECIP)
  164.    {
  165.       // Device Request
  166.       case CMD_RECIP_DEV:
  167.          // Remote wakeup not supported
  168.          bEpState = EP_ERROR;
  169.          break;
  171.       // Endpoint Request
  172.       case CMD_RECIP_EP:
  173.          if (gEp0Command.wValue.i == ENDPOINT_HALT)
  174.          {
  175.             // Enable the selected endpoint.
  176.             bEpState = EnableEndpoint(gEp0Command.wIndex.i);
  177.             break;
  178.          }
  179.          else
  180.          {
  181.            bEpState = EP_ERROR;
  182.            break;
  183.          }
  184.       default:
  185.          bEpState = EP_ERROR;
  186.          break;
  187.    }
  188.    gEp0Status.bEpState = bEpState;
  189. }
  191. //-----------------------------------------------------------------------------
  192. // SetConfigurationRequest
  193. //-----------------------------------------------------------------------------
  194. //
  195. // Return Value : None
  196. // Parameters   : None
  197. //
  198. //-----------------------------------------------------------------------------
  199. void SetConfigurationRequest ()
  200. {
  201.    // Index and Length fields must be zero
  202.    // Device state must be addressed or configured
  203.    if ((gEp0Command.wIndex.i) || (gEp0Command.wLength.i) ||
  204.    (gDeviceStatus.bDevState == DEV_DEFAULT))
  205.    {
  206.       bEpState = EP_ERROR;
  207.    }
  209.    else
  210.    {
  211.       // Make sure assigned configuration exists
  212.       if (gEp0Command.wValue.c[1] >
  213.       gDescriptorMap.bStdDevDsc[std_bNumConfigurations])
  214.       {
  215.          bEpState = EP_ERROR;
  216.       }
  218.       // Handle zero configuration assignment
  219.       else if  (gEp0Command.wValue.c[1] == 0)
  220.          gDeviceStatus.bDevState = DEV_ADDRESS;
  222.       // Select the assigned configuration
  223.       else
  224.          bEpState = SetConfiguration(gEp0Command.wValue.c[1]);
  225.    }
  226.    gEp0Status.bEpState = bEpState; 
  227. }
  230. //-----------------------------------------------------------------------------
  231. // SetInterfaceRequest
  232. //-----------------------------------------------------------------------------
  233. //
  234. // Return Value : None
  235. // Parameters   : None
  236. //
  237. //-----------------------------------------------------------------------------
  238. void SetInterfaceRequest()
  239. {
  240.    /*
  241.    // Length field must be zero
  242.    if ((gEp0Command.wLength.i) || (gDeviceStatus.bDevState != DEV_CONFIG))
  243.       bEpState = EP_ERROR;
  245.    else
  246.    {
  247.       // Check that target interface exists for this configuration
  248.       if(gEp0Command.wIndex.i > gDeviceStatus.bNumInterf - 1)
  249.          bEpState = EP_ERROR;
  251.       else
  252.       {
  253.          // Get pointer to interface status structure
  254.          pIfStatus = (PIF_STATUS)&gDeviceStatus.IfStatus;
  256.          // Check that alternate setting exists for the interface
  257.          if (gEp0Command.wValue.i > pIfStatus->bNumAlts)
  258.             bEpState = EP_ERROR;
  260.          // Assign alternate setting
  261.          else
  262.          {
  263.             pIfStatus->bCurrentAlt = gEp0Command.wValue.i;
  264.             bEpState = SetInterface(pIfStatus);
  265.          }
  266.       }
  267.    }
  268.    gEp0Status.bEpState = bEpState;
  269.    */
  270. }
  272. //-----------------------------------------------------------------------------
  273. // GetStatusRequest
  274. //-----------------------------------------------------------------------------
  275. //
  276. // Return Value : None
  277. // Parameters   : None
  278. //
  279. //-----------------------------------------------------------------------------
  280. void GetStatusRequest ()
  281. {
  282.    // Value field must be zero; Length field must be 2
  283.    if ((gEp0Command.wValue.i != 0) || (gEp0Command.wLength.i != 0x02) ||
  284.    (gDeviceStatus.bDevState == DEV_DEFAULT) ||
  285.    (gDeviceStatus.bDevState == DEV_ADDRESS && gEp0Command.wIndex.i != 0))
  286.    {
  287.       bEpState = EP_ERROR;
  288.    }
  290.    else
  291.    {
  292.       // Check for desired status (device, interface, endpoint)
  293.       switch (gEp0Command.bmRequestType & CMD_MASK_RECIP)
  294.       {
  295.          // Device
  296.          case CMD_RECIP_DEV:
  297.             // Index must be zero for a Device status request
  298.             if (gEp0Command.wIndex.i != 0)
  299.                bEpState = EP_ERROR;
  300.             else
  301.             {
  302.                // Prepare data_out for transmission
  303.                gEp0Status.wData.c[1] = 0;
  304.                gEp0Status.wData.c[0] = gDeviceStatus.bRemoteWakeupStatus;
  305.                gEp0Status.wData.c[0] |= gDeviceStatus.bSelfPoweredStatus;
  306.             }
  307.             break;
  309.          // Interface
  310.          case CMD_RECIP_IF:
  311.             // Prepare data_out for transmission
  312.             gEp0Status.wData.i = 0;
  313.             break;
  315.          // Endpoint
  316.          case CMD_RECIP_EP:
  317.             // Prepare data_out for transmission
  318.             gEp0Status.wData.i = 0;
  319.             if (GetEpStatus(gEp0Command.wIndex.i) == EP_HALTED)
  320.                gEp0Status.wData.c[0] |= 0x01;
  321.             break;
  323.          // Other cases unsupported
  324.          default:
  325.             bEpState = EP_ERROR;
  326.             break;
  327.       }
  329.       // Endpoint0 state assignment
  330.       bEpState = EP_TX;
  332.       // Point ep0 data pointer to transmit data_out
  333.       gEp0Status.pData = (BYTE *)&gEp0Status.wData.i;
  334.       gEp0Status.uNumBytes = 2;
  335.    }
  336.    gEp0Status.bEpState = bEpState;
  337. }
  339. //-----------------------------------------------------------------------------
  340. // GetDescriptorRequest
  341. //-----------------------------------------------------------------------------
  342. //
  343. // Return Value : None
  344. // Parameters   : None
  345. //
  346. //-----------------------------------------------------------------------------
  347. void GetDescriptorRequest ()
  348. {
  349.    WORD wTempInt;
  351.    // This request is valid in all device states
  352.    // Switch on requested descriptor (Value field)
  353.    switch (gEp0Command.wValue.c[0])
  354.    {
  355.       // Device Descriptor Request
  356.       case DSC_DEVICE:
  357.          // Get size of the requested descriptor
  358.          uNumBytes = STD_DSC_SIZE;
  359.          // Prep to send the requested length
  360.          if (uNumBytes > gEp0Command.wLength.i)
  361.          {
  362.             uNumBytes = gEp0Command.wLength.i;
  363.          }
  364.          // Point data pointer to the requested descriptor
  365.          gEp0Status.pData = (void*)&gDescriptorMap.bStdDevDsc;
  366.          bEpState = EP_TX;
  367.          break;
  369.       // Configuration Descriptor Request
  370.       case DSC_CONFIG:
  371.          // Make sure requested descriptor exists
  372.          if (gEp0Command.wValue.c[1] >
  373.          gDescriptorMap.bStdDevDsc[std_bNumConfigurations])
  374.          {
  375.             bEpState = EP_ERROR;
  376.          }
  377.          else
  378.          {
  379.             // Get total length of this configuration descriptor
  380.             // (includes all associated interface and endpoints)
  381.             wTempInt.c[1] = gDescriptorMap.bCfg1[cfg_wTotalLength_lsb];
  382.             wTempInt.c[0] = gDescriptorMap.bCfg1[cfg_wTotalLength_msb];
  383.             uNumBytes = wTempInt.i;
  385.             // Prep to transmit the requested length
  386.             if (uNumBytes > gEp0Command.wLength.i)
  387.             {
  388.                uNumBytes = gEp0Command.wLength.i;
  389.             }
  390.             // Point data pointer to requested descriptor
  391.             gEp0Status.pData = &gDescriptorMap.bCfg1;
  392.             bEpState = EP_TX;
  393.          }
  394.          break;
  395.    }
  396.    gEp0Status.uNumBytes = uNumBytes;
  397.    gEp0Status.bEpState = bEpState;
  398. }
  400. //-----------------------------------------------------------------------------
  401. // GetConfigurationRequest
  402. //-----------------------------------------------------------------------------
  403. //
  404. // Return Value : None
  405. // Parameters   : None
  406. //
  407. //-----------------------------------------------------------------------------
  408. void GetConfigurationRequest ()
  409. {
  410.    // Length field must be 1; Index field must be 0;
  411.    // Value field must be 0
  412.    if ((gEp0Command.wLength.i != 1) || (gEp0Command.wIndex.i) ||
  413.    (gEp0Command.wValue.i) || (gDeviceStatus.bDevState == DEV_DEFAULT))
  414.    {
  415.       bEpState = EP_ERROR;
  416.    }
  418.    else if (gDeviceStatus.bDevState == DEV_ADDRESS)
  419.    {
  420.       // Prepare data_out for transmission
  421.       gEp0Status.wData.i = 0;
  422.       // Point ep0 data pointer to transmit data_out
  423.       gEp0Status.pData = (BYTE *)&gEp0Status.wData.i;
  424.       // ep0 state assignment
  425.       bEpState = EP_TX;
  426.    }
  428.    else
  429.    {
  430.       // Index to desired field
  431.       gEp0Status.pData = (void *)&gDescriptorMap.bCfg1[cfg_bConfigurationValue];
  433.       // ep0 state assignment
  434.       bEpState = EP_TX;
  435.    }
  436.    gEp0Status.uNumBytes = 1;
  437.    gEp0Status.bEpState = bEpState;
  438. }
  440. //-----------------------------------------------------------------------------
  441. // GetInterfaceRequest
  442. //-----------------------------------------------------------------------------
  443. //
  444. // Return Value : None
  445. // Parameters   : None
  446. //
  447. //-----------------------------------------------------------------------------
  448. void GetInterfaceRequest ()
  449. {
  450.    // Value field must be 0; Length field must be 1
  451.    if ((gEp0Command.wValue.i) || (gEp0Command.wLength.i != 1) ||
  452.    (gDeviceStatus.bDevState != DEV_CONFIG))
  453.    {
  454.       bEpState = EP_ERROR;
  455.    }
  457.    else
  458.    {
  459.       // Make sure requested interface exists
  460.       if (gEp0Command.wIndex.i > gDeviceStatus.bNumInterf - 1)
  461.          bEpState = EP_ERROR;
  462.       else
  463.       {
  464.          // Get current interface setting
  465.          gEp0Status.pData = (void *)&gDeviceStatus.IfStatus->bCurrentAlt;
  467.          // Length must be 1
  468.          gEp0Status.uNumBytes = 1;
  469.          bEpState = EP_TX;
  470.       }
  471.    }
  472.    gEp0Status.bEpState = bEpState;
  473. }
  475. //-----------------------------------------------------------------------------
  476. // End Of File
  477. //-----------------------------------------------------------------------------