reqcode.LST
上传用户:ids068
上传日期:2013-04-04
资源大小:639k
文件大小:39k
源码类别:

USB编程

开发平台:

C/C++

  1. C51 COMPILER V7.06   REQCODE                                                               07/02/2003 10:27:49 PAGE 1   
  2. C51 COMPILER V7.06, COMPILATION OF MODULE REQCODE
  3. OBJECT MODULE PLACED IN reqcode.OBJ
  4. COMPILER INVOKED BY: C:KEILC51BINC51.EXE reqcode.c OPTIMIZE(2,SPEED) BROWSE DEBUG OBJECTEXTEND
  5. stmt level    source
  6.    1          /****************************************Copyright (c)**************************************************
  7.    2          **                               广州周立功单片机发展有限公司
  8.    3          **                                     研    究    所
  9.    4          **                                 http://www.zlgmcu.com
  10.    5          **--------------当前版本修订------------------------------------------------------------------------------
  11.    6          ** 修改人: 刘英斌
  12.    7          ** 日 期:2003-03-13
  13.    8          ** 描 述:ISP1581 V1.0
  14.    9          **------------------------------------------------------------------------------------------------------
  15.   10          ********************************************************************************************************/
  16.   11          
  17.   12          #include "standard.h"
  18.   13          #include "Usb.h"
  19.   14          #include "kernel.h"
  20.   15          
  21.   16          //***********************************************************************
  22.   17          //*                                                                                                                                                            *
  23.   18          //*                          Variable Definition                                                              *
  24.   19          //*                                                                                                                                                            *
  25.   20          //***********************************************************************
  26.   21          
  27.   22          
  28.   23          //***********************************************************************
  29.   24          //*                                                                                                                                                            *
  30.   25          //*                          Routine Definition                                                            *
  31.   26          //*                                                                                                                                                            *
  32.   27          //***********************************************************************
  33.   28          
  34.   29          
  35.   30          //***********************************************************************
  36.   31          //*                                                                                                                                                    *
  37.   32          //*     Routine         :  Standard Device Descriptor                                   *
  38.   33          //*     Input           :  None                                                                                          *
  39.   34          //*     Output   :  None                                                                           *
  40.   35          //*     Function        :  None                                                            *
  41.   36          //*                                                                                                                                                            *
  42.   37          //***********************************************************************
  43.   38          
  44.   39          
  45.   40          
  46.   41          DEVICE_DESCRIPTOR                               code    Standard_Device_Descriptor[] =
  47.   42          {
  48.   43              
  49.   44              sizeof(DEVICE_DESCRIPTOR),          /*        length         */
  50.   45                          0x01,                                                   /*  1.    bDescriptorType            */
  51.   46                          SWAP(0x0110),                                   /*  2.-3. Version 1.1 USB spec Word  */
  52.   47                          0x00,                                                   /*  4.    Class                      */
  53.   48                          0x00,                                                   /*  5.    bDeviceSubClass            */
  54.   49                          0x00,                                                   /*  6.    bDeviceProtocol            */
  55.   50                          0x40,                                                   /*  7.    bMaxPacketSize0            */
  56.   51                          SWAP(0x04CC),                                   /* 8.-9.  idVendor                   */
  57.   52                          SWAP(0x1B49),                                   /* a.-b.  idProduct for no Filter Driver      */        
  58.   53                          SWAP(0x0000),                                   /* c.-d.  bcdDevice                  */
  59.   54                          0x01,                                                   /* e.      iManufacturer             */
  60.   55                          0x02,                                                   /* f.      iProduct                                  */
  61. C51 COMPILER V7.06   REQCODE                                                               07/02/2003 10:27:49 PAGE 2   
  62.   56                          0x00,                                                   /* 10.    iSerialNumber              */
  63.   57                          0x01                                                    /* 11.    bNumConfigurations             */
  64.   58                          
  65.   59          };
  66.   60          
  67.   61          
  68.   62          DEVICE_DESCRIPTOR       code    HS_Device_Descriptor[] =
  69.   63          {
  70.   64              
  71.   65              sizeof(DEVICE_DESCRIPTOR),          /*        length         */
  72.   66                          0x01,                                                   /*  1.    bDescriptorType            */
  73.   67                          SWAP(0x0200),                                   /*  2.-3. Version 2.0 USB spec Word  */
  74.   68                          0x00,                                                   /*  4.    Class                      */
  75.   69                          0x00,                                                   /*  5.    bDeviceSubClass            */
  76.   70                          0x00,                                                   /*  6.    bDeviceProtocol            */
  77.   71                          0x40,                                                   /*  7.    bMaxPacketSize0            */
  78.   72                          SWAP(0x04CC),                                   /* 8.-9.  idVendor                   */
  79.   73                          SWAP(0x1B49),                                   /* a.-b.  idProduct                  */ 
  80.   74                          SWAP(0x0000),                                   /* c.-d.  bcdDevice                  */
  81.   75                          0x01,                                                   /* e.      iManufacturer             */
  82.   76                          0x02,                                                   /* f.      iProduct                                  */
  83.   77                          0x00,                                                   /* 10.    iSerialNumber              */
  84.   78                          0x01                                                    /* 11.    bNumConfigurations             */
  85.   79                          
  86.   80          };
  87.   81          
  88.   82          //***********************************************************************
  89.   83          //*                                                                                                                                                    *
  90.   84          //*     Routine  :  HS Device Qualifier                                         *
  91.   85          //*     Input           :  None                                                                                          *
  92.   86          //*     Output  :  None                                                                    *
  93.   87          //*     Function        :  None                                                            *
  94.   88          //*                                                                                                                                                            *
  95.   89          //***********************************************************************
  96.   90          
  97.   91          
  98.   92          HS_DEVICE_QUALIFIER     code HS_Device_Qualifier[] =
  99.   93          {
  100.   94                  
  101.   95                  sizeof(HS_DEVICE_QUALIFIER),    //length of HS Device Descriptor
  102.   96                          0x06,                                                   //HS Device Qualifier Type
  103.   97                          SWAP(0x0200),                                   // USB 2.0 version
  104.   98                          0x00,                                                   //Device class
  105.   99                          0x00,                                                   //Device SubClass
  106.  100                          0x00,                                                   //Device Protocol Code
  107.  101                          0x40,                                                   //Maximum Packet SIze for other speed
  108.  102                          0x01,                                                   //Number of Other speed configurations
  109.  103                          0x00                                                    //Reserved
  110.  104                          
  111.  105          };
  112.  106          
  113.  107          
  114.  108          //***********************************************************************
  115.  109          //*                                                                                                                                                    *
  116.  110          //*     Routine         :  Standard Configuration Descriptor                            *
  117.  111          //*     Input           :  None                                                                                          *
  118.  112          //*     Output   :  None                                                                           *
  119.  113          //*     Function        :  None                                                            *
  120.  114          //*                                                                                                                                                            *
  121.  115          //***********************************************************************
  122.  116          
  123.  117          CONFIGURATION_DESCRIPTOR        code    Standard_Config_Descriptor[] =
  124. C51 COMPILER V7.06   REQCODE                                                               07/02/2003 10:27:49 PAGE 3   
  125.  118          {
  126.  119                  
  127.  120                  sizeof(CONFIGURATION_DESCRIPTOR),       //Length of the configuration Descriptor
  128.  121                          0x02,                                                           //Configuration Descriptor
  129.  122                          SWAP(CONFIG_LENGTH),                            //Total length of the configurations,interface and class/endpoint
  130.  123                          0x01,                                                           //No. of interface supported
  131.  124                          0x01,                                                           //Configuration Value
  132.  125                          0x00,                                                           //Index of string descriptor
  133.  126                          0xC0,                                                           //Configurations Characteristic
  134.  127                          0x32                                                            //Maximun Power
  135.  128                          
  136.  129          };
  137.  130          
  138.  131          
  139.  132          //***********************************************************************
  140.  133          //*                                                                                                                                                    *
  141.  134          //*     Routine         :  Other speed Configuration Descriptor                         *
  142.  135          //*     Input           :  None                                                                                          *
  143.  136          //*     Output  :  None                                                                    *
  144.  137          //*     Function        :  None                                                            *
  145.  138          //*                                                                                                                                                            *
  146.  139          //***********************************************************************
  147.  140          
  148.  141          OTHER_SPEED_CONFIG_DESCRIPTOR   code    Other_Speed_Config_Descriptor[] =
  149.  142          {
  150.  143                  
  151.  144                  sizeof(OTHER_SPEED_CONFIG_DESCRIPTOR),  //length of other speed configuration descriptor
  152.  145                          0x07,                                                                   //Other speed configuration Type
  153.  146                          SWAP(CONFIG_LENGTH),                            //Total length
  154.  147                          0x01,                                                                   //No of interface supported
  155.  148                          0x01,                                                                   //Configuration Value
  156.  149                          0x00,                                                                   //Index of string descriptor
  157.  150                          0xC0,                                                                   //Configurations Characteristic
  158.  151                          0x32                                                                    //Maximun Power
  159.  152                          
  160.  153          };
  161.  154          
  162.  155          
  163.  156          
  164.  157          //***********************************************************************
  165.  158          //*                                                                                                                                                    *
  166.  159          //*     Routine         :  Standard Interface Descriptor                                *
  167.  160          //*     Input           :  None                                                                                          *
  168.  161          //*     Output  :  None                                                                    *
  169.  162          //*     Function        :  None                                                            *
  170.  163          //*                                                                                                                                                            *
  171.  164          //***********************************************************************
  172.  165          
  173.  166          INTERFACE_DESCRIPTOR    code    Bulk_Interface_Descriptor[] =
  174.  167          {
  175.  168                  
  176.  169                  sizeof(INTERFACE_DESCRIPTOR),   //Length of standard interface descriptor
  177.  170                          0x04,                                                           //Standard Interface Type
  178.  171                          0x00,                                                           //No of Interface
  179.  172                          0x00,                                                           //Alternate Setting Selector
  180.  173                          0x04,                                                           //No of Endpoints
  181.  174                          0x00,                                                           //Interface Class
  182.  175                          0x00,                                                           //ATAPI Interface Sub Class
  183.  176                          0x00,                                                           //Bulk Only Interface Protocol
  184.  177                          0x00                                                            //Index of interface string desriptor
  185.  178          };
  186.  179          
  187. C51 COMPILER V7.06   REQCODE                                                               07/02/2003 10:27:49 PAGE 4   
  188.  180          INTERFACE_DESCRIPTOR    code    HS_Bulk_Interface_Descriptor[] =
  189.  181          {
  190.  182                  sizeof(INTERFACE_DESCRIPTOR),   //Length of standard interface descriptor
  191.  183                          0x04,                                                           //Standard Interface Type
  192.  184                          0x00,                                                           //No of Interface
  193.  185                          0x00,                                                           //Alternate Setting Selector
  194.  186                          0x04,                                                           //No of Endpoints
  195.  187                          0x00,                                                           //Interface Class
  196.  188                          0x00,                                                           //ATAPI Interface Sub Class
  197.  189                          0x00,                                                           //Bulk Only Interface Protocol
  198.  190                          0x00                                                            //Index of interface string desriptor
  199.  191          };
  200.  192          
  201.  193          
  202.  194          //***********************************************************************
  203.  195          //*                                                                                                                                                    *
  204.  196          //*     Routine         :  Standard Endpoint Descriptor                                 *
  205.  197          //*     Input           :  None                                                                                          *
  206.  198          //*     Output  :  None                                                                    *
  207.  199          //*     Function        :  None                                                            *
  208.  200          //*                                                                                                                                                            *
  209.  201          //***********************************************************************
  210.  202          
  211.  203          ENDPOINT_DESCRIPTOR     code    Bulk_Out_Descriptor[] =
  212.  204          {
  213.  205                  
  214.  206                  sizeof(ENDPOINT_DESCRIPTOR),    //Length of Standard Endpoint Descriptor
  215.  207                          0x05,                                                           //Standard Endpoint Type
  216.  208                          0x02,                                                           //Set Bulk endpoint to 1 for ATAPI mode
  217.  209                          0x02,                                                           //Endpoint Characteristic
  218.  210                          SWAP(0x0040),                                           //Endpoint Max Packet Size
  219.  211                          0x00                                                            //Interval for Polling Endpoint for data transfer
  220.  212                          
  221.  213          };
  222.  214          
  223.  215          ENDPOINT_DESCRIPTOR     code    Bulk_In_Descriptor[] =
  224.  216          {
  225.  217                  sizeof(ENDPOINT_DESCRIPTOR),    //Length of Standard Endpoint Descriptor
  226.  218                          0x05,                                                           //Standard Endpoint Type
  227.  219                          0x82,                                                           //Set Bulk endpoint to 1 for ATAPI mode
  228.  220                          0x02,                                                           //Endpoint Characteristic
  229.  221                          SWAP(0x0040),                                           //Endpoint Max Packet Size
  230.  222                          0x00                                                            //Interval for Polling Endpoint for data transfer
  231.  223                          
  232.  224          };
  233.  225          
  234.  226          
  235.  227          ENDPOINT_DESCRIPTOR     code    HS_Bulk_Out_Descriptor[] =
  236.  228          {
  237.  229                  
  238.  230                  sizeof(ENDPOINT_DESCRIPTOR),    //Length of Standard Endpoint Descriptor
  239.  231                          0x05,                                                           //Standard Endpoint Type
  240.  232                          0x02,                                                           //Set Bulk endpoint to 1 for ATAPI mode
  241.  233                          0x02,                                                           //Endpoint Characteristic
  242.  234                          SWAP(0x0200),                                           //Endpoint Max Packet Size
  243.  235                          0x00                                                            //Interval for Polling Endpoint for data transfer
  244.  236                          
  245.  237          };
  246.  238          
  247.  239          ENDPOINT_DESCRIPTOR     code    HS_Bulk_In_Descriptor[] =
  248.  240          {
  249.  241                  sizeof(ENDPOINT_DESCRIPTOR),    //Length of Standard Endpoint Descriptor
  250. C51 COMPILER V7.06   REQCODE                                                               07/02/2003 10:27:49 PAGE 5   
  251.  242                          0x05,                                                           //Standard Endpoint Type
  252.  243                          0x82,                                                           //Set Bulk endpoint to 1 for ATAPI mode
  253.  244                          0x02,                                                           //Endpoint Characteristic
  254.  245                          SWAP(0x0200),                                           //Endpoint Max Packet Size
  255.  246                          0x00                                                            //Interval for Polling Endpoint for data transfer
  256.  247                          
  257.  248          };
  258.  249          
  259.  250          
  260.  251          ENDPOINT_DESCRIPTOR     code    Int_Out_Descriptor[] =
  261.  252          {
  262.  253                  
  263.  254                  sizeof(ENDPOINT_DESCRIPTOR),    //Length of Standard Endpoint Descriptor
  264.  255                          0x05,                                                           //Standard Endpoint Type
  265.  256                          0x01,                                                           //Set Int endpoint to 2 for ATAPI mode
  266.  257                          0x03,                                                           //Endpoint Characteristic
  267.  258                          SWAP(0x0040),                                           //Endpoint Max Packet Size
  268.  259                          0x01                                                            //Interval for Polling Endpoint for data transfer
  269.  260                          
  270.  261          };
  271.  262          
  272.  263          ENDPOINT_DESCRIPTOR     code    Int_In_Descriptor[] =
  273.  264          {
  274.  265                  sizeof(ENDPOINT_DESCRIPTOR),    //Length of Standard Endpoint Descriptor
  275.  266                          0x05,                                                           //Standard Endpoint Type
  276.  267                          0x81,                                                           //Set Int endpoint to 2 for ATAPI mode
  277.  268                          0x03,                                                           //Endpoint Characteristic
  278.  269                          SWAP(0x0040),                                           //Endpoint Max Packet Size
  279.  270                          0x01                                                            //Interval for Polling Endpoint for data transfer
  280.  271                          
  281.  272          };
  282.  273          
  283.  274          ENDPOINT_DESCRIPTOR     code    HS_Int_Out_Descriptor[] =
  284.  275          {
  285.  276                  
  286.  277                  sizeof(ENDPOINT_DESCRIPTOR),    //Length of Standard Endpoint Descriptor
  287.  278                          0x05,                                                           //Standard Endpoint Type
  288.  279                          0x01,                                                           //Set Int endpoint to 2 for ATAPI mode
  289.  280                          0x03,                                                           //Endpoint Characteristic
  290.  281                          SWAP(0x0040),                                           //Endpoint Max Packet Size
  291.  282                          0x01                                                            //Interval for Polling Endpoint for data transfer
  292.  283                          
  293.  284          };
  294.  285          
  295.  286          ENDPOINT_DESCRIPTOR     code    HS_Int_In_Descriptor[] =
  296.  287          {
  297.  288                  sizeof(ENDPOINT_DESCRIPTOR),    //Length of Standard Endpoint Descriptor
  298.  289                          0x05,                                                           //Standard Endpoint Type
  299.  290                          0x81,                                                           //Set Int endpoint to 2 for ATAPI mode
  300.  291                          0x03,                                                           //Endpoint Characteristic
  301.  292                          SWAP(0x0040),                                           //Endpoint Max Packet Size
  302.  293                          0x01                                                            //Interval for Polling Endpoint for data transfer
  303.  294                          
  304.  295          };
  305.  296          
  306.  297          //***********************************************************************
  307.  298          //*                                                                                                                                                    *
  308.  299          //*     Routine         :  Standard Interface Descriptor                                *
  309.  300          //*     Input           :  None                                                                                          *
  310.  301          //*     Output  :  None                                                                    *
  311.  302          //*     Function        :  None                                                            *
  312.  303          //*                                                                                                                                                            *
  313. C51 COMPILER V7.06   REQCODE                                                               07/02/2003 10:27:49 PAGE 6   
  314.  304          //***********************************************************************
  315.  305          
  316.  306          INTERFACE_DESCRIPTOR    code    Iso_Interface_Descriptor[] =
  317.  307          {
  318.  308                  
  319.  309                  sizeof(INTERFACE_DESCRIPTOR),   //Length of standard interface descriptor
  320.  310                          0x04,                                                           //Standard Interface Type
  321.  311                          0x00,                                                           //No of Interface
  322.  312                          0x01,                                                           //Alternate Setting Selector
  323.  313                          0x02,                                                           //No of Endpoints
  324.  314                          0x00,                                                           //Interface Class
  325.  315                          0x00,                                                           //Interface Sub Class
  326.  316                          0x00,                                                           //Interface Protocol
  327.  317                          0x00                                                            //Index of interface string desriptor
  328.  318                          
  329.  319          };
  330.  320          
  331.  321          
  332.  322          ENDPOINT_DESCRIPTOR     code    Iso_Out_Descriptor[] =
  333.  323          {
  334.  324                  
  335.  325                  sizeof(ENDPOINT_DESCRIPTOR),    //Length of Standard Endpoint Descriptor
  336.  326                          0x05,                                                           //Standard Endpoint Type
  337.  327                          0x03,                                                           //Enndpoint Address
  338.  328                          0x01,                                                           //Endpoint Characteristic
  339.  329                          SWAP(0x0040),                                           //Endpoint Max Packet Size
  340.  330                          0x01                                                            //Interval for Polling Endpoint for data transfer
  341.  331                          
  342.  332          };
  343.  333          
  344.  334          ENDPOINT_DESCRIPTOR     code    Iso_In_Descriptor[] =
  345.  335          {
  346.  336                  
  347.  337                  sizeof(ENDPOINT_DESCRIPTOR),    //Length of Standard Endpoint Descriptor
  348.  338                          0x05,                                                           //Standard Endpoint Type
  349.  339                          0x83,                                                           //Enndpoint Address
  350.  340                          0x01,                                                           //Endpoint Characteristic
  351.  341                          SWAP(0x0040),                                           //Endpoint Max Packet Size
  352.  342                          0x01                                                            //Interval for Polling Endpoint for data transfer
  353.  343                          
  354.  344          };
  355.  345          
  356.  346          ENDPOINT_DESCRIPTOR     code    Iso_Out_Zero_Descriptor[] =
  357.  347          {
  358.  348                  
  359.  349                  sizeof(ENDPOINT_DESCRIPTOR),    //Length of Standard Endpoint Descriptor
  360.  350                          0x05,                                                           //Standard Endpoint Type
  361.  351                          0x03,                                                           //Enndpoint Address
  362.  352                          0x01,                                                           //Endpoint Characteristic
  363.  353                          SWAP(0x0000),                                           //Endpoint Max Packet Size
  364.  354                          0x01                                                            //Interval for Polling Endpoint for data transfer
  365.  355                          
  366.  356          };
  367.  357          
  368.  358          ENDPOINT_DESCRIPTOR     code    Iso_In_Zero_Descriptor[] =
  369.  359          {
  370.  360                  
  371.  361                  sizeof(ENDPOINT_DESCRIPTOR),    //Length of Standard Endpoint Descriptor
  372.  362                          0x05,                                                           //Standard Endpoint Type
  373.  363                          0x83,                                                           //Enndpoint Address
  374.  364                          0x01,                                                           //Endpoint Characteristic
  375.  365                          SWAP(0x0000),                                           //Endpoint Max Packet Size
  376. C51 COMPILER V7.06   REQCODE                                                               07/02/2003 10:27:49 PAGE 7   
  377.  366                          0x01                                                            //Interval for Polling Endpoint for data transfer
  378.  367                          
  379.  368          };
  380.  369          
  381.  370          //***********************************************************************
  382.  371          //*                                                                                                                                                    *
  383.  372          //*     Routine         :  Standard String Descriptor                                      *
  384.  373          //*     Input           :  None                                                                                          *
  385.  374          //*     Output  :  None                                                                    *
  386.  375          //*     Function        :  None                                                            *
  387.  376          //*                                                                                                                                                            *
  388.  377          //***********************************************************************
  389.  378          
  390.  379          STRING_DESCRIPTOR       code    Standard_Product_String[] =          
  391.  380          
  392.  381          {        0x30,     /* length                   */
  393.  382          0x03,      /* descriptor type = string */
  394.  383          'P' , 0x00,
  395.  384          'h' , 0x00,
  396.  385          'i' , 0x00,
  397.  386          'l' , 0x00,
  398.  387          'i' , 0x00,
  399.  388          'p' , 0x00,
  400.  389          's' , 0x00,
  401.  390          ' ' , 0x00,
  402.  391          'I' , 0x00,
  403.  392          'S' , 0x00,
  404.  393          'P' , 0x00,
  405.  394          '1' , 0x00,
  406.  395          '5' , 0x00,
  407.  396          '8' , 0x00,
  408.  397          '1' , 0x00,
  409.  398          ' ' , 0x00,
  410.  399          'V' , 0x00,
  411.  400          'e' , 0x00,
  412.  401          'r' , 0x00,
  413.  402          ' ' , 0x00,
  414.  403          '1' , 0x00,
  415.  404          '.' , 0x00,
  416.  405          '0' , 0x00
  417.  406          };
  418.  407          
  419.  408          //***********************************************************************
  420.  409          //*                                                                                                                                                    *
  421.  410          //*     Routine         :  Standard String Descriptor                                      *
  422.  411          //*     Input           :  None                                                                                          *
  423.  412          //*     Output  :  None                                                                    *
  424.  413          //*     Function        :  None                                                            *
  425.  414          //*                                                                                                                                                            *
  426.  415          //***********************************************************************
  427.  416          
  428.  417          STRING_DESCRIPTOR       code    Standard_Manufacturer_String[] =             
  429.  418          
  430.  419          {        0x1C,     /* length                   */
  431.  420          0x03,      /* descriptor type = string */
  432.  421          'P' , 0x00,
  433.  422          'h' , 0x00,
  434.  423          'i' , 0x00,
  435.  424          'l' , 0x00,
  436.  425          'i' , 0x00,
  437.  426          'p' , 0x00,
  438.  427          ' ' , 0x00,
  439. C51 COMPILER V7.06   REQCODE                                                               07/02/2003 10:27:49 PAGE 8   
  440.  428          '-' , 0x00,
  441.  429          ' ' , 0x00,
  442.  430          'A' , 0x00,
  443.  431          'P' , 0x00,
  444.  432          'I' , 0x00,
  445.  433          'C' , 0x00
  446.  434          };
  447.  435          
  448.  436          
  449.  437          
  450.  438          //***********************************************************************
  451.  439          //*                                                                                                                                                    *
  452.  440          //*     Routine         :  Standard String Identifications                              *
  453.  441          //*     Input           :  None                                                                                          *
  454.  442          //*     Output  :  None                                                                    *
  455.  443          //*     Function        :  None                                                            *
  456.  444          //*                                                                                                                                                            *
  457.  445          //***********************************************************************
  458.  446          
  459.  447          STRING_ID       code    Standard_String_ID[] = 
  460.  448          {
  461.  449                  
  462.  450                  0x04,
  463.  451                          0x03,
  464.  452                          0x09,
  465.  453                          0x04
  466.  454                          
  467.  455          };                                                                                                                               
  468.  456          
  469.  457          
  470.  458          
  471.  459          //***********************************************************************
  472.  460          //*                                                                                                                                                    *
  473.  461          //*     Routine         :  Standard Mass Storage Identifications                 *
  474.  462          //*     Input           :  None                                                                                          *
  475.  463          //*     Output  :  None                                                                    *
  476.  464          //*     Function        :  None                                                            *
  477.  465          //*                                                                                                                                                            *
  478.  466          //***********************************************************************
  479.  467          UC code  Test_Packet[] =
  480.  468          {
  481.  469                  //      0x00, 0x00,
  482.  470                  //      0x00, 0x80, // syn pattern
  483.  471                  0xc3,
  484.  472                          0x00, 0x00,
  485.  473                          0x00, 0x00,
  486.  474                          0x00, 0x00,
  487.  475                          0x00, 0x00,
  488.  476                          0x00, 0xaa,
  489.  477                          0xaa, 0xaa,
  490.  478                          0xaa, 0xaa,
  491.  479                          0xaa, 0xaa,
  492.  480                          0xaa, 0xee,  //aa*4
  493.  481                          0xee, 0xee,
  494.  482                          0xee, 0xee,
  495.  483                          0xee, 0xee,
  496.  484                          0xee, 0xfe,  //ee*4
  497.  485                          0xff, 0xff,
  498.  486                          0xff, 0xff,
  499.  487                          0xff, 0xff,
  500.  488                          0xff, 0xff,
  501.  489                          0xff, 0xff,  //FF*6
  502. C51 COMPILER V7.06   REQCODE                                                               07/02/2003 10:27:49 PAGE 9   
  503.  490                          0xff, 0x7f,
  504.  491                          0xbf, 0xdf,
  505.  492                          0xef, 0xf7,
  506.  493                          0xfb, 0xfd,
  507.  494                          0xfc, 0x7e,
  508.  495                          0xbf, 0xdf,
  509.  496                          0xef, 0xf7,
  510.  497                          0xfb, 0xfd,
  511.  498                          0x7e,
  512.  499                          0xb6, 0xce  // crc
  513.  500                          //      0xff, 0xf7
  514.  501          };
  515. MODULE INFORMATION:   STATIC OVERLAYABLE
  516.    CODE SIZE        =   ----    ----
  517.    CONSTANT SIZE    =    331    ----
  518.    XDATA SIZE       =   ----    ----
  519.    PDATA SIZE       =   ----    ----
  520.    DATA SIZE        =   ----    ----
  521.    IDATA SIZE       =   ----    ----
  522.    BIT SIZE         =   ----    ----
  523. END OF MODULE INFORMATION.
  524. C51 COMPILATION COMPLETE.  0 WARNING(S),  0 ERROR(S)