USB_ISR.#3
上传用户:gxz1972
上传日期:2019-09-13
资源大小:323k
文件大小:17k
源码类别:

传真(Fax)编程

开发平台:

C/C++

  1. //-----------------------------------------------------------------------------
  2. // USB_ISR.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 Brin Cai
  22. //    -24 JUL 2007
  23. //
  24. //
  25. //-----------------------------------------------------------------------------
  26. // Includes
  27. //-----------------------------------------------------------------------------
  28. #include "Include_H.h"
  29. typedef struct {            //  Structure definition of a block of data
  30.     BYTE Piece[MAX_BLOCK_SIZE];
  31. }   BLOCK;
  32. typedef struct {            //  Structure definition of a flash memory page
  33.     BYTE FlashPage[FLASH_PAGE_SIZE];
  34. }   PAGE;
  35. //xdata   BLOCK   TempStorage[BLOCKS_PR_PAGE];    // Temporary storage of between 
  36.                                                 // flash writes
  37. xdata   BYTE   TempStorage[MAX_BLOCK_SIZE];    // Temporary storage of between 
  38.                                                 // flash writes
  39. code    BYTE    Pg0 _at_    0x1400;
  40. code    BYTE    Pg1 _at_    0x1600;
  41. code    BYTE    Pg2 _at_    0x1800;
  42. code    BYTE    Pg3 _at_    0x1A00;
  43. code    BYTE    Pg4 _at_    0x1C00;
  44. code    BYTE    Pg5 _at_    0x1E00;
  45. code    BYTE    Pg6 _at_    0x2000;
  46. code    BYTE    Pg7 _at_    0x2200;
  47. code    BYTE    Pg8 _at_    0x2400;
  48. code    BYTE    Pg9 _at_    0x2600;
  49. code    BYTE    Pg10    _at_    0x2800;
  50. code    BYTE    Pg11    _at_    0x2A00;
  51. code    BYTE    Pg12    _at_    0x2C00;
  52. code    BYTE    Pg13    _at_    0x2E00;
  53. code    BYTE    Pg14    _at_    0x3000;
  54. code    BYTE    Pg15    _at_    0x3200;
  55. code    BYTE    Pg16    _at_    0x3400;
  56. code    BYTE    Pg17    _at_    0x3600;
  57. code    BYTE    Pg18    _at_    0x3800;
  58. code    BYTE    Pg19    _at_    0x3A00;
  59. data bit bitInterruptFlag = 0;
  60. //idata unsigned char gaucTxData2HostBuffer[64];
  61. /*
  62. idata   BYTE*   PageIndices[20] =   {&Pg0,  &Pg1,   &Pg2,   &Pg3,   &Pg4,   
  63.                                      &Pg5,  &Pg6,   &Pg7,   &Pg8,   &Pg9,
  64.                                      &Pg10, &Pg11,  &Pg12,  &Pg13,  &Pg14,  
  65.  &Pg15,  &Pg16,  &Pg17,  &Pg18,  &Pg19};
  66. */
  67. data    UINT    BytesToWrite;   //  Total number of bytes to write to the host
  68. //data    UINT    BytesToRead;    //  Total number of bytes to read from host
  69. data    BYTE    Buffer[3];      //  Buffer for Setup messages
  70. data    BYTE    NumBlocks;      //  Number of Blocks for this transfer
  71. //data    BYTE    M_State;        //  Current Machine State
  72. data    BYTE    BlockIndex;     //  Index of Current Block in Page
  73. data    BYTE    PageIndex;      //  Index of Current Page in File
  74. data    BYTE    BlocksRead;     //  Total Number of Blocks Read
  75. data    BYTE    BlocksWrote;    //  Total Number of Blocks Written
  76. data    BYTE*   ReadIndex;
  77. // code const   BYTE    Serial1[0x0A] = {0x0A,0x03,'A',0,'B',0,'C',0,'D',0};
  78. // Serial Number Defintion
  79. code    BYTE    LengthFile[3]   _at_    0x1200;
  80. //  {Length(Low Byte), Length(High Byte), Number of Blocks}
  81.         
  82. //-----------------------------------------------------------------------------
  83. // Interrupt Service Routines
  84. //-----------------------------------------------------------------------------
  85. //-----------------------------------------------------------------------------
  86. // USB_ISR
  87. //-----------------------------------------------------------------------------
  88. //
  89. //
  90. // This is the top level USB ISR. All endpoint interrupt/request
  91. // handlers are called from this function.
  92. //
  93. // Handler routines for any configured interrupts should be
  94. // added in the appropriate endpoint handler call slots.
  95. //
  96. //-----------------------------------------------------------------------------
  97. void USB_ISR () interrupt 8
  98. {
  99.    BYTE bCommonInt, bInInt, bOutInt;
  100.    // Read interrupt registers
  101.    UREAD_BYTE(CMINT, bCommonInt);
  102.    UREAD_BYTE(IN1INT, bInInt);
  103.    UREAD_BYTE(OUT1INT, bOutInt);
  104.    
  105.    // Check for reset interrupt
  106.    if (bCommonInt & rbRSTINT)
  107.    {
  108.       // Call reset handler
  109.       M_State = USB_RESET_STATUS;
  110.   //USBReset();
  111.       //M_State = WAIT_OPEN_DEVICE_STATUS;
  112.       
  113.    }
  114.    // Check for Endpoint0 interrupt
  115.    if (bInInt & rbEP0)
  116.    {
  117.       // Call Endpoint0 handler
  118.   M_State = EP0_HANDLER_STATUS;
  119.       //Endpoint0();
  120.    }
  121.    // Endpoint1 IN
  122.    if (bInInt & rbIN1)
  123.    {
  124.  bitInterruptFlag = 1;
  125.  //sbitLED = 1;
  126.  /*
  127.  switch (M_State)
  128.      {
  129.       case
  130.          TX_CONFIG_RESPONSE_TO_HOST_STATUS:                  // Stay in Wait State
  131.          M_State = TX_KEY_DATA_TO_HOST_STATUS;
  132.  break;
  133.       case
  134.          TX_KEY_DATA_TO_HOST_STATUS:                  // Stay in Idle State
  135.          M_State = TX_TOUCHPAD_DATA_TO_HOST_STATUS;
  136.  break;
  137.       case
  138.          TX_TOUCHPAD_DATA_TO_HOST_STATUS:   // Response Host After receive the Config Data
  139.          M_State = TX_CONFIG_RESPONSE_TO_HOST_STATUS;//ST_TX_KEY_DATA_TO_HOST;
  140.          break;
  141.      
  142.       default:
  143.          M_State = DEVICE_IDLE_STATUS;           // Unknown State, stay in Error State
  144.          break;
  145.       }//switch
  146.   */
  147.    }//if
  148.    // Endpoint2 OUT
  149.    if (bOutInt & rbOUT2)
  150.    {
  151.       bitInterruptFlag = 1;
  152.   M_State = RX_CONFIG_DATA_FROM_HOST_STATUS;
  153.    }
  154.    //State_Machine();
  155. }
  156. //-----------------------------------------------------------------------------
  157. // Support Subroutines
  158. //-----------------------------------------------------------------------------
  159. //-----------------------------------------------------------------------------
  160. // USBReset
  161. //-----------------------------------------------------------------------------
  162. //
  163. // Return Value : None
  164. // Parameters   : None
  165. //
  166. // - Initialize the global Device Status structure (all zeros)
  167. // - Resets all endpoints
  168. //-----------------------------------------------------------------------------
  169. void USBReset ()
  170. {
  171.    BYTE i, bPower = 0;
  172.    BYTE * pDevStatus;
  173.   // Reset device status structure to all zeros (undefined)
  174.    pDevStatus = (BYTE *)&gDeviceStatus;
  175.    for (i=0;i<sizeof(DEVICE_STATUS);i++)
  176.    {
  177.       *pDevStatus++ = 0x00;
  178.    }
  179.    // Set device state to default
  180.    gDeviceStatus.bDevState = DEV_DEFAULT;
  181.    // REMOTE_WAKEUP_SUPPORT and SELF_POWERED_SUPPORT
  182.    // defined in file "usb_desc.h"
  183.    gDeviceStatus.bRemoteWakeupSupport = REMOTE_WAKEUP_SUPPORT;
  184.    gDeviceStatus.bSelfPoweredStatus = SELF_POWERED_SUPPORT;
  185.    // Reset all endpoints
  186.    // Reset Endpoint0
  187.    gEp0Status.bEpState = EP_IDLE;         // Reset Endpoint0 state
  188.    gEp0Status.bEp = 0;                    // Set endpoint number
  189.    gEp0Status.uMaxP = EP0_MAXP;           // Set maximum packet size
  190.    // Reset Endpoint1 IN
  191.    gEp1InStatus.bEpState = EP_HALTED;     // Reset state
  192.    gEp1InStatus.uNumBytes = 0;            // Reset byte counter
  193.    // Reset Endpoint2 OUT
  194.    gEp2OutStatus.bEpState = EP_HALTED;    // Reset state
  195.    gEp2OutStatus.uNumBytes = 0;           // Reset byte counter
  196.    // Get Suspend enable/disable status. If enabled, prepare temporary
  197.    // variable bPower.
  198.    if (SUSPEND_ENABLE)
  199.    {
  200.       bPower = 0x01;                      // Set bit0 (Suspend Enable)
  201.    }
  202.    // Get ISO Update enable/disable status. If enabled, prepare temporary
  203.    // variable bPower.
  204.    if (ISO_UPDATE_ENABLE)
  205.    {
  206.       bPower |= 0x80;                     // Set bit7 (ISO Update Enable)
  207.    }
  208.    UWRITE_BYTE(POWER, bPower);
  209. }
  210. //-----------------------------------------------------------------------------
  211. // Endpoint0
  212. //-----------------------------------------------------------------------------
  213. //
  214. // Return Value : None
  215. // Parameters   : None
  216. //
  217. //-----------------------------------------------------------------------------
  218. void Endpoint0 ()
  219. {
  220.    BYTE bTemp = 0;
  221.    BYTE bCsr1, uTxBytes;
  222.    UWRITE_BYTE(INDEX, 0);                 // Target ep0
  223.    UREAD_BYTE(E0CSR, bCsr1);
  224.    // Handle Setup End
  225.    if (bCsr1 & rbSUEND)                   // Check for setup end
  226.    {                                      // Indicate setup end serviced
  227.       UWRITE_BYTE(E0CSR, rbSSUEND);
  228.       gEp0Status.bEpState = EP_IDLE;      // ep0 state to idle
  229.       M_State = DEVICE_IDLE_STATUS;              // ported from usb_file.c
  230.    }
  231.    // Handle sent stall
  232.    if (bCsr1 & rbSTSTL)                   // If last state requested a stall
  233.    {                                      // Clear Sent Stall bit (STSTL)
  234.       UWRITE_BYTE(E0CSR, 0);
  235.       gEp0Status.bEpState = EP_IDLE;      // ep0 state to idle
  236.       M_State = DEVICE_IDLE_STATUS;              // ported from usb_file.c
  237.    }
  238.    // Handle incoming packet
  239.    if (bCsr1 & rbOPRDY)
  240.    {
  241.       // Read the 8-byte command from Endpoint0 FIFO
  242.       FIFORead(0, 8, (BYTE*)&gEp0Command);
  243.       // Byte-swap the wIndex field
  244.       bTemp = gEp0Command.wIndex.c[1];
  245.       gEp0Command.wIndex.c[1] = gEp0Command.wIndex.c[0];
  246.       gEp0Command.wIndex.c[0] = bTemp;
  247.       // Byte-swap the wValue field
  248.       bTemp = gEp0Command.wValue.c[1];
  249.       gEp0Command.wValue.c[1] = gEp0Command.wValue.c[0];
  250.       gEp0Command.wValue.c[0] = bTemp;
  251.       // Byte-swap the wLength field
  252.       bTemp = gEp0Command.wLength.c[1];
  253.       gEp0Command.wLength.c[1] = gEp0Command.wLength.c[0];
  254.       gEp0Command.wLength.c[0] = bTemp;
  255.       // Decode received command
  256.       switch (gEp0Command.bmRequestType & CMD_MASK_COMMON)
  257.       {
  258.          case  CMD_STD_DEV_OUT:           // Standard device requests
  259.             // Decode standard OUT request
  260.             switch (gEp0Command.bRequest)
  261.             {
  262.                case SET_ADDRESS:
  263.                   SetAddressRequest();
  264.                   break;
  265.                case SET_FEATURE:
  266.                   SetFeatureRequest();
  267.                   break;
  268.                case CLEAR_FEATURE:
  269.                   ClearFeatureRequest();
  270.                   break;
  271.                case SET_CONFIGURATION:
  272.                   SetConfigurationRequest();
  273.                   break;
  274.                case SET_INTERFACE:
  275.                   SetInterfaceRequest();
  276.                   break;
  277.                // All other OUT requests not supported
  278.                case SET_DESCRIPTOR:
  279.                default:
  280.                   gEp0Status.bEpState = EP_ERROR;
  281.                   break;
  282.             }
  283.             break;
  284.          // Decode standard IN request
  285.          case CMD_STD_DEV_IN:
  286.             switch (gEp0Command.bRequest)
  287.             {
  288.                case GET_STATUS:
  289.                   GetStatusRequest();
  290.                   break;
  291.                case GET_DESCRIPTOR:
  292.                   GetDescriptorRequest();
  293.                   break;
  294.                case GET_CONFIGURATION:
  295.                   GetConfigurationRequest();
  296.                   break;
  297.                case GET_INTERFACE:
  298.                   GetInterfaceRequest();
  299.                   break;
  300.                // All other IN requests not supported
  301.                case SYNCH_FRAME:
  302.       break;//add at Aug.3, 2007
  303.                default:
  304.                   gEp0Status.bEpState = EP_ERROR;
  305.                   break;
  306.             }
  307.             break;
  308.          // All other requests not supported
  309.          default:
  310.             gEp0Status.bEpState = EP_ERROR;
  311.       }
  312.       // Write E0CSR according to the result of the serviced out packet
  313.       bTemp = rbSOPRDY;
  314.       if (gEp0Status.bEpState == EP_ERROR)
  315.       {
  316.          bTemp |= rbSDSTL;                // Error condition handled
  317.                                           // with STALL
  318.          gEp0Status.bEpState = EP_IDLE;   // Reset state to idle
  319.       }
  320.       UWRITE_BYTE(E0CSR, bTemp);
  321.    }
  322.    bTemp = 0;                             // Reset temporary variable
  323.    // If state is transmit, call transmit routine
  324.    if (gEp0Status.bEpState == EP_TX)
  325.    {
  326.       // Check the number of bytes ready for transmit
  327.       // If less than the maximum packet size, packet will
  328.       // not be of the maximum size
  329.       if (gEp0Status.uNumBytes <= EP0_MAXP)
  330.       {
  331.          uTxBytes = gEp0Status.uNumBytes;
  332.          gEp0Status.uNumBytes = 0;        // update byte counter
  333.          bTemp |= rbDATAEND;              // This will be the last
  334.                                           // packet for this transfer
  335.          gEp0Status.bEpState = EP_IDLE;   // Reset endpoint state
  336.       }
  337.       // Otherwise, transmit maximum-length packet
  338.       else
  339.       {
  340.          uTxBytes = EP0_MAXP;
  341.          gEp0Status.uNumBytes -= EP0_MAXP;// update byte counter
  342.       }
  343.       // Load FIFO
  344.       FIFOWrite(0, uTxBytes, (BYTE*)gEp0Status.pData);
  345.       // Update data pointer
  346.       gEp0Status.pData = (BYTE*)gEp0Status.pData + uTxBytes;
  347.       // Update Endpoint0 Control/Status register
  348.       bTemp |= rbINPRDY;                  // Always transmit a packet
  349.                                           // when this routine is called
  350.                                           // (may be zero-length)
  351.       UWRITE_BYTE(E0CSR, bTemp);          // Write to Endpoint0 Control/Status
  352.    }
  353. }
  354. //-----------------------------------------------------------------------------
  355. // BulkOrInterruptOut
  356. //-----------------------------------------------------------------------------
  357. //
  358. // Return Value : None
  359. // Parameters   :
  360. // 1) PEP_STATUS pEpOutStatus
  361. //
  362. //-----------------------------------------------------------------------------
  363. void BulkOrInterruptOut(PEP_STATUS pEpOutStatus)
  364. {
  365.    UINT uBytes;
  366.    BYTE bTemp = 0;
  367.    BYTE bCsrL, bCsrH;
  368.    UWRITE_BYTE(INDEX, pEpOutStatus->bEp); // Index to current endpoint
  369.    UREAD_BYTE(EOUTCSRL, bCsrL);
  370.    UREAD_BYTE(EOUTCSRH, bCsrH);
  371.    // Make sure this endpoint is not halted
  372.    if (pEpOutStatus->bEpState != EP_HALTED)
  373.    {
  374.       // Handle STALL condition sent
  375.       if (bCsrL & rbOutSTSTL)
  376.       {
  377.          // Clear Send Stall, Sent Stall, and data toggle
  378.          UWRITE_BYTE(EOUTCSRL, rbOutCLRDT);
  379.       }
  380.       // Read received packet
  381.       if(bCsrL & rbOutOPRDY)
  382.       {
  383.          // Get packet length
  384.          UREAD_BYTE(EOUTCNTL, bTemp);     // Low byte
  385.          uBytes = (UINT)bTemp & 0x00FF;
  386.          UREAD_BYTE(EOUTCNTH, bTemp);     // High byte
  387.          uBytes |= (UINT)bTemp << 8;
  388.          if (M_State == DEVICE_IDLE_STATUS) 
  389.          {
  390.             FIFORead(0x02, uBytes, &Buffer);
  391.          }  
  392.          else
  393.          {
  394.             FIFORead(0x02, uBytes, (BYTE*)(&TempStorage[BlockIndex]));
  395.          }
  396.          // Clear out-packet-ready
  397.          UWRITE_BYTE(INDEX, pEpOutStatus->bEp);
  398.          UWRITE_BYTE(EOUTCSRL, 0);
  399.          // Read updated status register
  400.          //UWRITE_BYTE(INDEX, pEpOutStatus->bEp); // Index to current endpoint
  401.          //UREAD_BYTE(EOUTCSRL, bCsrL);
  402.       }
  403.    }
  404. }
  405. //-----------------------------------------------------------------------------
  406. // BulkOrInterruptIn
  407. //-----------------------------------------------------------------------------
  408. //
  409. // Return Value : None
  410. // Parameters   :
  411. // 1) PEP_STATUS pEpOutStatus
  412. // 2) BYTE * DataToWrite
  413. // 3) UINT NumBytes
  414. //
  415. // - Places DataToWrite on the IN FIFO
  416. // - Sets Packet Ready Bit
  417. //-----------------------------------------------------------------------------
  418. void BulkOrInterruptIn (PEP_STATUS pEpInStatus, BYTE * DataToWrite,
  419.                         UINT NumBytes)
  420. {
  421.    BYTE bCsrL, bCsrH;
  422.    UWRITE_BYTE(INDEX, pEpInStatus->bEp);  // Index to current endpoint
  423.    UREAD_BYTE(EINCSRL, bCsrL);
  424.    UREAD_BYTE(EINCSRH, bCsrH);
  425.    // Make sure this endpoint is not halted
  426.    if (pEpInStatus->bEpState != EP_HALTED)
  427.    {
  428.       // Handle STALL condition sent
  429.       if (bCsrL & rbInSTSTL)
  430.       {
  431.          UWRITE_BYTE(EINCSRL, rbInCLRDT); // Clear Send Stall and Sent Stall,
  432.                                           // and clear data toggle
  433.       }
  434.       // If a FIFO slot is open, write a new packet to the IN FIFO
  435.       if (!(bCsrL & rbInINPRDY))
  436.       {
  437.          pEpInStatus->uNumBytes = NumBytes;
  438.          pEpInStatus->pData = (BYTE*)DataToWrite;
  439.          // Write <uNumBytes> bytes to the <bEp> FIFO
  440.          FIFOWrite(pEpInStatus->bEp, pEpInStatus->uNumBytes,
  441.             (BYTE*)pEpInStatus->pData);
  442.          BytesToWrite -= NumBytes;
  443.          ReadIndex += NumBytes;
  444.          BlocksWrote++;
  445.          // Set Packet Ready bit (INPRDY)
  446.          UWRITE_BYTE(EINCSRL, rbInINPRDY);
  447.          // Check updated endopint status
  448.          //UREAD_BYTE(EINCSRL, bCsrL);
  449.       }
  450.    }
  451. }
  452. //-----------------------------------------------------------------------------
  453. // End Of File
  454. //-----------------------------------------------------------------------------