⭐ 欢迎来到虫虫下载站! | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站

📄 isr.lst

📁 philiphs D12 firmware驱动程序
💻 LST
字号:
C51 COMPILER V7.06   ISR                                                                   08/06/2006 09:11:06 PAGE 1   


C51 COMPILER V7.06, COMPILATION OF MODULE ISR
OBJECT MODULE PLACED IN ISR.OBJ
COMPILER INVOKED BY: D:\Keil\C51\BIN\C51.EXE ISR.C BROWSE DEBUG OBJECTEXTEND

stmt level    source

   1          /*
   2             //*************************************************************************
   3             //
   4             //                  P H I L I P S   P R O P R I E T A R Y
   5             //
   6             //           COPYRIGHT (c)   1997 BY PHILIPS SINGAPORE.
   7             //                     --  ALL RIGHTS RESERVED  --
   8             //
   9             // File Name:        ISR.C
  10             // Author:           Wenkai Du
  11             // Created:          19 Dec 97
  12             // Modified:
  13             // Revision:         3.0
  14             //
  15             //*************************************************************************
  16             //
  17             // 98/11/25          Added I/O mode Main endpoints access. (WK)
  18             //*************************************************************************
  19             */
  20          #include <stdio.h>
  21          #include <string.h>
  22          
  23          #include <reg51.h>                /* special function register declarations   */
  24          
  25          #include "epphal.h"
  26          #include "d12ci.h"
  27          #include "mainloop.h"
  28          #include "usb100.h"
  29          
  30          extern void bus_reset(void);
  31          
  32          extern void ep0_txdone(void);
  33          extern void ep0_rxdone(void);
  34          
  35          extern void ep1_txdone(void);
  36          extern void ep1_rxdone(void);
  37          
  38          extern void main_txdone(void);
  39          extern void main_rxdone(void);
  40          
  41          extern void dma_eot(void);
  42          
  43          /*
  44          //*************************************************************************
  45          //  Public static data
  46          //*************************************************************************
  47          */
  48          
  49          EPPFLAGS bEPPflags;
  50          
  51          /* Control endpoint TX/RX buffers */
  52          extern CONTROL_XFER ControlData;
  53          
  54          /* ISR static vars */
  55          unsigned char idata GenEpBuf[EP1_PACKET_SIZE];
C51 COMPILER V7.06   ISR                                                                   08/06/2006 09:11:06 PAGE 2   

  56          unsigned char idata EpBuf[EP2_PACKET_SIZE];
  57          IO_REQUEST idata ioRequest;
  58          unsigned char ioSize, ioCount;
  59          
  60          unsigned long ClockTicks = 0;
  61          unsigned char xdata MainEpBuf[256];
  62          
  63          extern BOOL bNoRAM;
  64          
  65          timer_isr() interrupt 1
  66          {
  67   1              DISABLE;
  68   1              ClockTicks++;
  69   1              bEPPflags.bits.timer = 1;
  70   1              ENABLE;
  71   1      }
  72          
  73          
  74          usb_isr() interrupt 0
  75          {
  76   1              DISABLE;
  77   1              fn_usb_isr();
  78   1              ENABLE;
  79   1      }
  80          
  81          void fn_usb_isr()
  82          {
  83   1              unsigned int i_st;
  84   1      
  85   1              bEPPflags.bits.in_isr = 1;
  86   1      
  87   1              i_st = D12_ReadInterruptRegister();
  88   1      
  89   1              if(i_st != 0) {
  90   2                      if(i_st & D12_INT_BUSRESET) {
  91   3                              bus_reset();
  92   3                              bEPPflags.bits.bus_reset = 1;
  93   3                      }
  94   2      
  95   2                      if(i_st & D12_INT_EOT)
  96   2                              dma_eot();
  97   2      
  98   2                      if(i_st & D12_INT_SUSPENDCHANGE)
  99   2                              bEPPflags.bits.suspend = 1;
 100   2      
 101   2                      if(i_st & D12_INT_ENDP0IN)
 102   2                              ep0_txdone();
 103   2                      if(i_st & D12_INT_ENDP0OUT)
 104   2                              ep0_rxdone();
 105   2                      if(i_st & D12_INT_ENDP1IN)
 106   2                              ep1_txdone();
 107   2                      if(i_st & D12_INT_ENDP1OUT)
 108   2                              ep1_rxdone();
 109   2                      if(i_st & D12_INT_ENDP2IN)
 110   2                              main_txdone();
 111   2                      if(i_st & D12_INT_ENDP2OUT)
 112   2                              main_rxdone();
 113   2              }
 114   1      
 115   1              bEPPflags.bits.in_isr = 0;
 116   1      }
 117          
C51 COMPILER V7.06   ISR                                                                   08/06/2006 09:11:06 PAGE 3   

 118          void bus_reset(void)
 119          {
 120   1      }
 121          
 122          void ep0_rxdone(void)
 123          {
 124   1              unsigned char ep_last, i;
 125   1      
 126   1              ep_last = D12_ReadLastTransactionStatus(0); // Clear interrupt flag
 127   1      
 128   1              if (ep_last & D12_SETUPPACKET) {
 129   2      
 130   2                      ControlData.wLength = 0;
 131   2                      ControlData.wCount = 0;
 132   2      
 133   2                      if( D12_ReadEndpoint(0, sizeof(ControlData.DeviceRequest),
 134   2                              (unsigned char *)(&(ControlData.DeviceRequest))) != sizeof(DEVICE_REQUEST) ) {
 135   3      
 136   3                              D12_SetEndpointStatus(0, 1);
 137   3                              D12_SetEndpointStatus(1, 1);
 138   3                              bEPPflags.bits.control_state = USB_IDLE;
 139   3                              
 140   3                              return;
 141   3                      }
 142   2      
 143   2                      ControlData.DeviceRequest.wValue = SWAP(ControlData.DeviceRequest.wValue);
 144   2                      ControlData.DeviceRequest.wIndex = SWAP(ControlData.DeviceRequest.wIndex);
 145   2                      ControlData.DeviceRequest.wLength = SWAP(ControlData.DeviceRequest.wLength);
 146   2      
 147   2                      // Acknowledge setup here to unlock in/out endp
 148   2                      D12_AcknowledgeEndpoint(0);
 149   2                      D12_AcknowledgeEndpoint(1);
 150   2      
 151   2                      ControlData.wLength = ControlData.DeviceRequest.wLength;
 152   2                      ControlData.wCount = 0;
 153   2      
 154   2                      if (ControlData.DeviceRequest.bmRequestType & (unsigned char)USB_ENDPOINT_DIRECTION_MASK) {
 155   3                              bEPPflags.bits.setup_packet = 1;
 156   3                              bEPPflags.bits.control_state = USB_IDLE;                /* get command */
 157   3                      }
 158   2                      else {
 159   3                              if (ControlData.DeviceRequest.wLength == 0) {
 160   4                                      bEPPflags.bits.setup_packet = 1;
 161   4                                      bEPPflags.bits.control_state = USB_IDLE;                /* set command */
 162   4                              }
 163   3                              else {
 164   4                                      if(ControlData.DeviceRequest.wLength > MAX_CONTROLDATA_SIZE) {
 165   5                                              bEPPflags.bits.control_state = USB_IDLE;
 166   5                                              D12_SetEndpointStatus(0, 1);
 167   5                                              D12_SetEndpointStatus(1, 1);
 168   5                                      }
 169   4                                      else {
 170   5                                              bEPPflags.bits.control_state = USB_RECEIVE;     /* set command with OUT token */
 171   5                                      }
 172   4                              } // set command with data
 173   3                      } // else set command
 174   2              } // if setup packet
 175   1      
 176   1              else if (bEPPflags.bits.control_state == USB_RECEIVE) {
 177   2                      i =     D12_ReadEndpoint(0, EP0_PACKET_SIZE,
 178   2                              ControlData.dataBuffer + ControlData.wCount);
 179   2      
C51 COMPILER V7.06   ISR                                                                   08/06/2006 09:11:06 PAGE 4   

 180   2                      ControlData.wCount += i;
 181   2                      if( i != EP0_PACKET_SIZE || ControlData.wCount >= ControlData.wLength) {
 182   3                              bEPPflags.bits.setup_packet = 1;
 183   3                              bEPPflags.bits.control_state = USB_IDLE;
 184   3                      }
 185   2              }
 186   1      
 187   1              else {
 188   2                      bEPPflags.bits.control_state = USB_IDLE;
 189   2              }
 190   1      }
 191          
 192          void ep0_txdone(void)
 193          {
 194   1              short i = ControlData.wLength - ControlData.wCount;
 195   1      
 196   1              D12_ReadLastTransactionStatus(1); // Clear interrupt flag
 197   1      
 198   1              if (bEPPflags.bits.control_state != USB_TRANSMIT) 
 199   1                      return;
 200   1      
 201   1              if( i >= EP0_PACKET_SIZE) {
 202   2                      D12_WriteEndpoint(1, EP0_PACKET_SIZE, ControlData.pData + ControlData.wCount);
 203   2                      ControlData.wCount += EP0_PACKET_SIZE;
 204   2      
 205   2                      bEPPflags.bits.control_state = USB_TRANSMIT;
 206   2              }
 207   1              else if( i != 0) {
 208   2                      D12_WriteEndpoint(1, i, ControlData.pData + ControlData.wCount);
 209   2                      ControlData.wCount += i;
 210   2      
 211   2                      bEPPflags.bits.control_state = USB_IDLE;
 212   2              }
 213   1              else if (i == 0){
 214   2                      D12_WriteEndpoint(1, 0, 0); // Send zero packet at the end ???
 215   2      
 216   2                      bEPPflags.bits.control_state = USB_IDLE;
 217   2              }
 218   1      }
 219          
 220          void dma_eot(void)
 221          {
 222   1      }
 223          
 224          void ep1_txdone(void)
 225          {
 226   1              D12_ReadLastTransactionStatus(3); /* Clear interrupt flag */
 227   1      }
 228          
 229          void ep1_rxdone(void)
 230          {
 231   1              unsigned char len;
 232   1      
 233   1              D12_ReadLastTransactionStatus(2); /* Clear interrupt flag */
 234   1      
 235   1              len = D12_ReadEndpoint(2, sizeof(GenEpBuf), GenEpBuf);
 236   1      
 237   1              if(len != 0)
 238   1                      bEPPflags.bits.ep1_rxdone = 1;
 239   1      }
 240          
 241          void main_txdone(void)
C51 COMPILER V7.06   ISR                                                                   08/06/2006 09:11:06 PAGE 5   

 242          {
 243   1              unsigned char len;
 244   1      
 245   1              D12_ReadLastTransactionStatus(5); /* Clear interrupt flag */
 246   1      
 247   1              len = ioSize - ioCount;
 248   1              if(len == 0) {
 249   2                      if(bEPPflags.bits.dma_state == DMA_PENDING)
 250   2                              bEPPflags.bits.setup_dma ++;
 251   2                      else
 252   2                              bEPPflags.bits.dma_state = DMA_IDLE;
 253   2              }
 254   1              else {
 255   2                      if(len > 64)
 256   2                              len = 64;
 257   2                      if(bNoRAM)
 258   2                              len = D12_WriteEndpoint(5, len, EpBuf + ioCount);
 259   2                      else
 260   2                              len = D12_WriteEndpoint(5, len, MainEpBuf + ioCount);
 261   2                      ioCount += len;
 262   2              }
 263   1      }
 264          
 265          void main_rxdone(void)
 266          {
 267   1              unsigned char len;
 268   1      
 269   1              D12_ReadLastTransactionStatus(4); /* Clear interrupt flag */
 270   1      
 271   1              if(bNoRAM)
 272   1                      len = D12_ReadEndpoint(4, 64, EpBuf + ioCount);
 273   1              else
 274   1                      len = D12_ReadEndpoint(4, 64, MainEpBuf + ioCount);
 275   1              ioCount += len;
 276   1              if(bNoRAM)
 277   1                      len = D12_ReadEndpoint(4, 64, EpBuf + ioCount);
 278   1              else
 279   1                      len = D12_ReadEndpoint(4, 64, MainEpBuf + ioCount);
 280   1              ioCount += len;
 281   1              if(ioCount >= ioSize) {
 282   2                      if(bEPPflags.bits.dma_state == DMA_PENDING)
 283   2                              bEPPflags.bits.setup_dma ++;
 284   2                      else
 285   2                              bEPPflags.bits.dma_state = DMA_IDLE;
 286   2              }
 287   1      }
 288          
 289          


MODULE INFORMATION:   STATIC OVERLAYABLE
   CODE SIZE        =    873    ----
   CONSTANT SIZE    =   ----    ----
   XDATA SIZE       =    256    ----
   PDATA SIZE       =   ----    ----
   DATA SIZE        =      8       5
   IDATA SIZE       =     74    ----
   BIT SIZE         =   ----    ----
END OF MODULE INFORMATION.


C51 COMPILATION COMPLETE.  0 WARNING(S),  0 ERROR(S)

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -