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

📄 mscuser.lst

📁 将LPC2148通过自带的USB口配置为USB存储设备.
💻 LST
📖 第 1 页 / 共 5 页
字号:
ARM COMPILER V2.50a,  mscuser                                                              04/04/06  11:13:57  PAGE 1   


ARM COMPILER V2.50a, COMPILATION OF MODULE mscuser
OBJECT MODULE PLACED IN .\Obj\mscuser.obj
COMPILER INVOKED BY: C:\Keil\ARM\BIN\CA.exe mscuser.c THUMB DEBUG PRINT(.\LST\MSCUSER.LST) TABS(4) OBJECT(.\Obj\mscuser.
                    -obj) 

stmt  level    source

    1          /*----------------------------------------------------------------------------
    2           *      U S B  -  K e r n e l
    3           *----------------------------------------------------------------------------
    4           *      Name:    MSCUSER.C
    5           *      Purpose: Mass Storage Class Custom User Module
    6           *      Version: V1.05
    7           *---------------------------------------------------------------------------*/
    8          
    9          #include <LPC214X.H>                        /* LPC214x definitions */
   10          
   11          #include "type.h"
   12          
   13          #include "usb.h"
   14          #include "msc.h"
   15          #include "usbcfg.h"
   16          #include "usbhw.h"
   17          #include "usbcore.h"
   18          #include "mscuser.h"
   19          
   20          #include "memory.h"
   21          
   22          
   23          BYTE  Memory[MSC_MemorySize] __at MSC_MemoryStart;   /* MSC RAM */
   24          
   25          BOOL  MemOK;                   /* Memory OK */
   26          
   27          DWORD Offset;                  /* R/W Offset */
   28          DWORD Length;                  /* R/W Length */
   29          
   30          BYTE  BulkStage;               /* Bulk Stage */
   31          
   32          BYTE  BulkBuf[MSC_MAX_PACKET]; /* Bulk In/Out Buffer */
   33          BYTE  BulkLen;                 /* Bulk In/Out Length */
   34          
   35          MSC_CBW CBW;                   /* Command Block Wrapper */
   36          MSC_CSW CSW;                   /* Command Status Wrapper */
   37          
   38          
   39          /*
   40           *  MSC Mass Storage Reset Request Callback
   41           *   Called automatically on Mass Storage Reset Request
   42           *    Parameters:      None (global SetupPacket and EP0Buf)
   43           *    Return Value:    TRUE - Success, FALSE - Error
   44           */
   45          
   46          BOOL MSC_Reset (void) {
   47   1      
   48   1        IOCLR1 = (LED_RD | LED_WR);  /* Turn Off R/W LED */
   49   1        BulkStage = MSC_BS_CBW;
   50   1        return (TRUE);
   51   1      }
   52          
   53          
   54          /*
   55           *  MSC Get Max LUN Request Callback
   56           *   Called automatically on Get Max LUN Request
   57           *    Parameters:      None (global SetupPacket and EP0Buf)
   58           *    Return Value:    TRUE - Success, FALSE - Error
ARM COMPILER V2.50a,  mscuser                                                              04/04/06  11:13:57  PAGE 2   

   59           */
   60          
   61          BOOL MSC_GetMaxLUN (void) {
   62   1      
   63   1        EP0Buf[0] = 0;               /* No LUN associated with this device */
   64   1        return (TRUE);
   65   1      }
   66          
   67          
   68          /*
   69           *  MSC Memory Read Callback
   70           *   Called automatically on Memory Read Event
   71           *    Parameters:      None (global variables)
   72           *    Return Value:    None
   73           */
   74          
   75          void MSC_MemoryRead (void) {
   76   1        DWORD n;
   77   1      
   78   1        if (Length > MSC_MAX_PACKET) {
   79   2          n = MSC_MAX_PACKET;
   80   2        } else {
   81   2          n = Length;
   82   2        }
   83   1      
   84   1        if ((Offset + n) > MSC_MemorySize) {
   85   2          n = MSC_MemorySize - Offset;
   86   2          BulkStage = MSC_BS_DATA_IN_LAST_STALL;
   87   2        }
   88   1      
   89   1        USB_WriteEP(MSC_EP_IN, (BYTE *)(MSC_MemoryStart + Offset), n);
   90   1        Offset += n;
   91   1        Length -= n;
   92   1      
   93   1        CSW.dDataResidue -= n;
   94   1      
   95   1        if (Length == 0) {
   96   2          BulkStage = MSC_BS_DATA_IN_LAST;
   97   2        }
   98   1      
   99   1        if (BulkStage != MSC_BS_DATA_IN) {
  100   2          IOCLR1 = LED_RD;            /* Turn Off Read LED */
  101   2          CSW.bStatus = CSW_CMD_PASSED;
  102   2        }
  103   1      }
  104          
  105          
  106          /*
  107           *  MSC Memory Write Callback
  108           *   Called automatically on Memory Write Event
  109           *    Parameters:      None (global variables)
  110           *    Return Value:    None
  111           */
  112          
  113          void MSC_MemoryWrite (void) {
  114   1        DWORD n;
  115   1      
  116   1        if ((Offset + BulkLen) > MSC_MemorySize) {
  117   2          BulkLen = MSC_MemorySize - Offset;
  118   2          BulkStage = MSC_BS_CSW;
  119   2          USB_SetStallEP(MSC_EP_OUT);
  120   2        }
  121   1      
  122   1        for (n = 0; n < BulkLen; n++) {
  123   2          Memory[Offset + n] = BulkBuf[n];
  124   2        }
ARM COMPILER V2.50a,  mscuser                                                              04/04/06  11:13:57  PAGE 3   

  125   1      
  126   1        Offset += BulkLen;
  127   1        Length -= BulkLen;
  128   1      
  129   1        CSW.dDataResidue -= BulkLen;
  130   1      
  131   1        if ((Length == 0) || (BulkStage == MSC_BS_CSW)) {
  132   2          IOCLR1 = LED_WR;            /* Turn Off Write LED */
  133   2          CSW.bStatus = CSW_CMD_PASSED;
  134   2          MSC_SetCSW();
  135   2        }
  136   1      }
  137          
  138          
  139          /*
  140           *  MSC Memory Verify Callback
  141           *   Called automatically on Memory Verify Event
  142           *    Parameters:      None (global variables)
  143           *    Return Value:    None
  144           */
  145          
  146          void MSC_MemoryVerify (void) {
  147   1        DWORD n;
  148   1      
  149   1        if ((Offset + BulkLen) > MSC_MemorySize) {
  150   2          BulkLen = MSC_MemorySize - Offset;
  151   2          BulkStage = MSC_BS_CSW;
  152   2          USB_SetStallEP(MSC_EP_OUT);
  153   2        }
  154   1      
  155   1        for (n = 0; n < BulkLen; n++) {
  156   2          if (Memory[Offset + n] != BulkBuf[n]) {
  157   3            MemOK = FALSE;
  158   3            break;
  159   3          }
  160   2        }
  161   1      
  162   1        Offset += BulkLen;
  163   1        Length -= BulkLen;
  164   1      
  165   1        CSW.dDataResidue -= BulkLen;
  166   1      
  167   1        if ((Length == 0) || (BulkStage == MSC_BS_CSW)) {
  168   2          CSW.bStatus = (MemOK) ? CSW_CMD_PASSED : CSW_CMD_FAILED;
  169   2          MSC_SetCSW();
  170   2        }
  171   1      }
  172          
  173          
  174          /*
  175           *  MSC SCSI Read/Write Setup Callback
  176           *    Parameters:      None (global variables)
  177           *    Return Value:    TRUE - Success, FALSE - Error
  178           */
  179          
  180          BOOL MSC_RWSetup (void) {
  181   1        DWORD n;
  182   1      
  183   1        /* Logical Block Address of First Block */
  184   1        n = (CBW.CB[2] << 24) |
  185   1            (CBW.CB[3] << 16) |
  186   1            (CBW.CB[4] <<  8) |
  187   1            (CBW.CB[5] <<  0);
  188   1      
  189   1        Offset = n * MSC_BlockSize;
  190   1      
ARM COMPILER V2.50a,  mscuser                                                              04/04/06  11:13:57  PAGE 4   

  191   1        /* Number of Blocks to transfer */
  192   1        n = (CBW.CB[7] <<  8) |
  193   1            (CBW.CB[8] <<  0);
  194   1      
  195   1        Length = n * MSC_BlockSize;
  196   1      
  197   1        if (CBW.dDataLength != Length) {
  198   2          USB_SetStallEP(MSC_EP_IN);
  199   2          USB_SetStallEP(MSC_EP_OUT);
  200   2          CSW.bStatus = CSW_PHASE_ERROR;
  201   2          MSC_SetCSW();
  202   2          return (FALSE);
  203   2        }
  204   1      
  205   1        return (TRUE);
  206   1      }
  207          
  208          
  209          /*
  210           *  Check Data IN Format
  211           *    Parameters:      None (global variables)
  212           *    Return Value:    TRUE - Success, FALSE - Error
  213           */
  214          
  215          BOOL DataInFormat (void) {
  216   1      
  217   1        if (CBW.dDataLength == 0) {
  218   2          CSW.bStatus = CSW_PHASE_ERROR;
  219   2          MSC_SetCSW();
  220   2          return (FALSE);
  221   2        }
  222   1        if ((CBW.bmFlags & 0x80) == 0) {
  223   2          USB_SetStallEP(MSC_EP_OUT);
  224   2          CSW.bStatus = CSW_PHASE_ERROR;
  225   2          MSC_SetCSW();
  226   2          return (FALSE);
  227   2        }
  228   1        return (TRUE);
  229   1      }
  230          
  231          
  232          /*
  233           *  Perform Data IN Transfer
  234           *    Parameters:      None (global variables)
  235           *    Return Value:    TRUE - Success, FALSE - Error
  236           */
  237          
  238          void DataInTransfer (void) {
  239   1      
  240   1        if (BulkLen > CBW.dDataLength) {
  241   2          BulkLen = CBW.dDataLength;
  242   2        }
  243   1      
  244   1        USB_WriteEP(MSC_EP_IN, BulkBuf, BulkLen);
  245   1        BulkStage = MSC_BS_DATA_IN_LAST;
  246   1      
  247   1        CSW.dDataResidue -= BulkLen;
  248   1        CSW.bStatus = CSW_CMD_PASSED;
  249   1      }
  250          
  251          
  252          /*
  253           *  MSC SCSI Test Unit Ready Callback
  254           *    Parameters:      None (global variables)
  255           *    Return Value:    None
  256           */
ARM COMPILER V2.50a,  mscuser                                                              04/04/06  11:13:57  PAGE 5   

  257          
  258          void MSC_TestUnitReady (void) {
  259   1      
  260   1        if (CBW.dDataLength != 0) {
  261   2          if ((CBW.bmFlags & 0x80) != 0) {
  262   3            USB_SetStallEP(MSC_EP_IN);
  263   3          } else {
  264   3            USB_SetStallEP(MSC_EP_OUT);
  265   3          }
  266   2        }
  267   1      
  268   1        CSW.bStatus = CSW_CMD_PASSED;
  269   1        MSC_SetCSW();
  270   1      }
  271          
  272          
  273          /*
  274           *  MSC SCSI Request Sense Callback
  275           *    Parameters:      None (global variables)
  276           *    Return Value:    None
  277           */
  278          
  279          void MSC_RequestSense (void) {
  280   1      
  281   1        if (!DataInFormat()) return;
  282   1      
  283   1        BulkBuf[ 0] = 0x70;          /* Response Code */
  284   1        BulkBuf[ 1] = 0x00;
  285   1        BulkBuf[ 2] = 0x02;          /* Sense Key */
  286   1        BulkBuf[ 3] = 0x00;
  287   1        BulkBuf[ 4] = 0x00;
  288   1        BulkBuf[ 5] = 0x00;
  289   1        BulkBuf[ 6] = 0x00;
  290   1        BulkBuf[ 7] = 0x0A;          /* Additional Length */
  291   1        BulkBuf[ 8] = 0x00;
  292   1        BulkBuf[ 9] = 0x00;
  293   1        BulkBuf[10] = 0x00;
  294   1        BulkBuf[11] = 0x00;

⌨️ 快捷键说明

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