/*
**********************************************************************************************
* Project:	TK7821
* File:		Descriptor.c
* Contents: 
*           
*
* $Date: 02/25/05    Jason    v0.1
*        05/12/05    Mingo    v0.2   www.fameg.com
*        12/08/05    Jason    v0.3   Modify the PID and VID
*
* Copyright (c) 2005 Fameg, Inc. All rights reserved
***********************************************************************************************
*/

#include <reg51.h>
#include <stdio.h>
#include <string.h>
#include "sotatype.h"
#include "usbdisk.h"
#include "device.h"
#include "ScsiCmd.h"
#include "Descriptor.h"

xdata UINT16 CtrlXferLen = 0;

#define DESC_BASE 0x7f00

code BYTE DeviceDesc[] //_at_ DESC_BASE
    = { 0x12,          // Size of this descriptor in bytes
        0x01,          // DEVICE descriptor type
        0x00, 0x02,    // USB Version 2.00
        0x00,          // Class is specified in the interface desc.
        0x00,          // Subclass is specified in the interface desc.
        0x00,          // Protocol is specified in the interface desc.
        CTRL_PKT_SIZE, // Max packet size for endpoint 0
        0x21, 0x51,    // Vendor ID (5121h)
        0x03, 0x10,    // Device ID (1003h)
        0x00, 0x01,    // Device release number (1000h)
        STR_DESC_VENDOR_INDEX,    // string index = 1
        STR_DESC_PRODUCT_INDEX,   // string index = 2
        STR_DESC_SERIALNUM_INDEX, // string index = 3
        0x01           // Number of possible configurations
      };

code BYTE ConfigDesc[] //_at_ DESC_BASE + 0x20
    = { // Configuration Descriptor 
    	0x09,          // Size of this descriptor in bytes
        0x02,          // CONFIGURATION descriptor type
        0x20, 0x00,    // Total data length for this config. (0020h)
        0x01,          // Number of interface supported
        0x01,          // bConfigurationValue
        0x00,          // string index = 0
        0x80,          // No self-powerd, and no Remote Wakeup
        0x32,          // Max power = 100mA
        // Interface Descriptor
        0x09,          // Size of this descriptor in bytes
        0x04,          // INTERFACE descriptor type
        0x00,          // bInterfaceNumber
        0x00,          // bAlternateSetting
        0x02,          // bNumEndpoints (excluding endpoint 0)
        0x08,          // MASS STORAGE Class
        0x06,          // SCSI transparent command set
        0x50,          // BULK-ONLY TRANSPORT
        0x00,          // string index = 0
        // Endpoint Descriptor for EP1
        0x07,          // Size of this descriptor in bytes
        0x05,          // ENDPOINT descriptor type
        EP1IN_NUMBER,  // IN, endpoint num = 1
        0x02,          // Bulk endpoint
        0x40, 0x00,    // max packet size (64 bytes)
        0x00,
        // Endpoint Descriptor for EP2
        0x07,          // Size of this descriptor in bytes
        0x05,          // ENDPOINT descriptor type
        EP2OUT_NUMBER, // OUT, endpoint num = 1
        0x02,          // Bulk endpoint
        0x40, 0x00,    // max packet size (64 bytes)
        0x00 };

code BYTE Str0Desc[] //_at_ DESC_BASE + 0x40 
    = { 0x04,          // Size of this descriptor in bytes
        0x03,          // STRING+ descriptor type
        0x09, 
        0x04 };

code BYTE Str1Desc[] //_at_ DESC_BASE + 0x50 
    = { 0x04, 
        0x03, 
        ' ', 0x00 };
      
code BYTE Str2Desc[] //_at_ DESC_BASE + 0x60
    = { 0x1a, 
        0x03, 
        'U', 0x00, 
        'S', 0x00, 
        'B', 0x00, 
        ' ', 0x00, 
        '2', 0x00, 
        '.', 0x00, 
        '0', 0x00, 
        ' ', 0x00,
        'D', 0x00, 
        'i', 0x00, 
        's', 0x00, 
        'k', 0x00 };
        
code BYTE Str3Desc[] //_at_ DESC_BASE + 0x80
     = { 0x16, 
         0x03, 
         '0', 0x00, 
         '0', 0x00, 
         '0', 0x00, 
         '0', 0x00, 
         '0', 0x00,
         '0', 0x00, 
         '0', 0x00, 
         '0', 0x00, 
         '0', 0x00, 
         '1', 0x00 };
         
code BYTE DeviceQualifierDesc[] //_at_ DESC_BASE + 0xa0
    = { 0x0a,          // Size of this descriptor in bytes
        0x06,          // Device Qualifier descriptor type
        0x00, 0x02,    // USB version
        0x08,          // MASS STORAGE Class
        0x06,          // SCSI transparent command set
        0x50,          // BULK-ONLY TRANSPORT
        0x40,          // Max packet size for other speed
        0x01,          // Number of Other-speed Configuration
        0x00 };
        
code PBYTE StrDescPtr[4] = { Str0Desc, 
                             Str1Desc, 
                             Str2Desc, 
                             Str3Desc };
code BYTE StrCtrlXferLen[4] = { sizeof(Str0Desc), 
                                sizeof(Str1Desc), 
                                sizeof(Str2Desc), 
                                sizeof(Str3Desc) };
code BYTE DeviceDescLen = sizeof(DeviceDesc);
code BYTE ConfigDescLen = sizeof(ConfigDesc);
code BYTE DeviceQualifierDescLen = sizeof(DeviceQualifierDesc);

/*--------------------------------------------------------------------
code BYTE OtherSpeedConfigDesc[] _at_ DESC_BASE + 0xb0
    = { 0x09, // Size of this descriptor in bytes
        0x07, // Other_Speed_Configuration descriptor type
              // The rest is identical to Configuration Desc.
        0x20, 0x00, 0x01, 0x01, 0x00, 0x80, 0x32 };

code BYTE OtherSpeedConfigDescLen = sizeof(OtherSpeedConfigDesc);
--------------------------------------------------------------------*/

//--------------------------------------------------------------------
// Prepare Descriptor
//--------------------------------------------------------------------
void CtrlDescPrepare()
{
    xdata PUSB_REQUEST pReq = &(pSotaUsbRequest->Request);
    xdata BYTE DescType, DescIndex;

    DescType  = ((TDataCast *)&(pReq->wValue))->ucByte[1];
    DescIndex = ((TDataCast *)&(pReq->wValue))->ucByte[0];
  
    switch (DescType)
    {
        case DEVICE_DESC_TYPE:

            CtrlXferLen = DeviceDescLen;
            memcpy((BYTE xdata *)UsbBuf, 
                   (BYTE code *)DeviceDesc,
                   CtrlXferLen);
            break;
      
        case STRING_DESC_TYPE:

            if((DescIndex >= 0)&&(DescIndex <= 3))
            {
                CtrlXferLen = StrCtrlXferLen[DescIndex];
                memcpy((BYTE xdata *)UsbBuf,
                       (BYTE code *)StrDescPtr[DescIndex],
                       CtrlXferLen);
            }
            else
                CtrlXferLen = 0;
            break;
  
        case DEVICE_QUALIFIER_DESC_TYPE:
        
            CtrlXferLen = DeviceQualifierDescLen;
            memcpy((BYTE xdata *)UsbBuf, 
                   (BYTE code *)DeviceQualifierDesc,
                   CtrlXferLen);
            break;
       
        case CONFIGURATION_DESC_TYPE:

            CtrlXferLen = ConfigDescLen;
            memcpy((BYTE xdata *)UsbBuf, 
                   (BYTE code *)ConfigDesc,
                   CtrlXferLen);
            if(CSRRead(USB_BASE + USB_SPEED) & SPEED) // High Speed
            {
                UsbBuf[22] = (BYTE)(USB20_MAX_PKT_SIZE);
                UsbBuf[23] = (BYTE)(USB20_MAX_PKT_SIZE >> 8); 
                UsbBuf[29] = (BYTE)(USB20_MAX_PKT_SIZE);
                UsbBuf[30] = (BYTE)(USB20_MAX_PKT_SIZE >> 8); 
            }
            break;

        case OTHER_SPEED_CONFIG_DESC_TYPE:

            CtrlXferLen = ConfigDescLen;
            memcpy((BYTE xdata *)UsbBuf, 
                   (BYTE code *)ConfigDesc,
                   CtrlXferLen);
            UsbBuf[1] = OTHER_SPEED_CONFIG_DESC_TYPE;
            if(CSRRead(USB_BASE + USB_SPEED) & SPEED) // High Speed
            {
                UsbBuf[22] = (BYTE)(USB20_MAX_PKT_SIZE);
                UsbBuf[23] = (BYTE)(USB20_MAX_PKT_SIZE >> 8); 
                UsbBuf[29] = (BYTE)(USB20_MAX_PKT_SIZE);
                UsbBuf[30] = (BYTE)(USB20_MAX_PKT_SIZE >> 8); 
            }
            break;


        default:  
            // Error Condition, Stall transactions.
            pSotaUsbRequest->InProgress = false;
            CSRWrite(USB_BASE + EP0_RXCSR, EN_RX0_STL);    
            CSRWrite(USB_BASE + EP0_TXCSR, EN_TX0_STL);  
    }
  
    if(pReq->wLength < CtrlXferLen)
        CtrlXferLen = pReq->wLength;
}  

//----------------------------------------------------------------------------
// Get Descriptor Request 
//----------------------------------------------------------------------------
void CtrlReqGetDescriptor()
{
  BYTE Token = pSotaUsbRequest->Token;
    
  switch(Token)
  {
    case SETUP_TOKEN:
         Fifo2ClkCpu(); // need ?
         CtrlDescPrepare();
         Fifo2ClkUsb(); // need ?
         pSotaUsbRequest->LoadInDataOk = true;
         CSRWrite(USB_BASE + EP0_RXCSR, EN_RX0_STL);
         break;

    case IN_TOKEN:
         {
           BYTE i;
          
           if (pSotaUsbRequest->LoadInDataOk)
           { 
             for(i = 0; i < CtrlXferLen; i++)
                 CSRWrite(USB_BASE + EP0_TXDATA, UsbBuf[i]);
             CSRWrite(USB_BASE + EP0_TXCNT, CtrlXferLen);
             CSRWrite(USB_BASE + EP0_TXCSR, EN_TX0);
             CSRWrite(USB_BASE + EP0_RXCSR, EN_RX0);
             pSotaUsbRequest->FinishedDataLen += CtrlXferLen;
             pSotaUsbRequest->LoadInDataOk = false;
           }
           break;   
         }

    case IN_OK_TOKEN:
         CSRWrite(USB_BASE + EP0_RXCSR, EN_RX0);    
         if (pSotaUsbRequest->FinishedDataLen <= (BYTE)CtrlXferLen)  // Keep sending descriptor data.
           pSotaUsbRequest->LoadInDataOk = true;	
         else 
           CSRWrite(USB_BASE + EP0_TXCSR, EN_TX0_STL); 
         break;
          
    case OUT_TOKEN:
    default:
         // Ctrl Read End
         pSotaUsbRequest->InProgress = false;
         break;          
  }  
}