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

USB编程

开发平台:

C/C++

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