/* Name: usbdrv.c 
 * Project: AVR USB driver 
 * Author: Christian Starkjohann 
 * Creation Date: 2004-12-29 
 * Tabsize: 4 
 * Copyright: (c) 2005 by OBJECTIVE DEVELOPMENT Software GmbH 
 * License: GNU GPL v2 (see License.txt) or proprietary (CommercialLicense.txt) 
 * This Revision: $Id: usbdrv.c 350 2007-06-13 11:43:16Z cs $ 
 */  
  
#include "iarcompat.h"   
#ifndef __IAR_SYSTEMS_ICC__   
#   include <AVR io.h>   
#   include <AVR pgmspace.h>   
#endif   
#include "usbdrv.h"   
#include "oddebug.h"   
  
/* 
General Description: 
This module implements the C-part of the USB driver. See usbdrv.h for a 
documentation of the entire driver. 
*/  
  
#ifndef IAR_SECTION   
#define IAR_SECTION(arg)   
#define __no_init   
#endif   
/* The macro IAR_SECTION is a hack to allow IAR-cc compatibility. On gcc, it 
 * is defined to nothing. __no_init is required on IAR. 
 */  
  
/* ------------------------------------------------------------------------- */  
  
/* raw USB registers / interface to assembler code: */  
uchar usbRxBuf[2*USB_BUFSIZE];  /* raw RX buffer: PID, 8 bytes data, 2 bytes CRC */  
uchar       usbInputBufOffset;  /* offset in usbRxBuf used for low level receiving */  
uchar       usbDeviceAddr;      /* assigned during enumeration, defaults to 0 */  
uchar       usbNewDeviceAddr;   /* device ID which should be set after status phase */  
uchar       usbConfiguration;   /* currently selected configuration. Administered by driver, but not used */  
volatile schar usbRxLen;        /* = 0; number of bytes in usbRxBuf; 0 means free, -1 for flow control */  
uchar       usbCurrentTok;      /* last token received, if more than 1 rx endpoint: MSb=endpoint */  
uchar       usbRxToken;         /* token for data we received; if more than 1 rx endpoint: MSb=endpoint */  
uchar       usbMsgLen = 0xff;   /* remaining number of bytes, no msg to send if -1 (see usbMsgPtr) */  
volatile uchar usbTxLen = USBPID_NAK;   /* number of bytes to transmit with next IN token or handshake token */  
uchar       usbTxBuf[USB_BUFSIZE];/* data to transmit with next IN, free if usbTxLen contains handshake token */  
#if USB_CFG_HAVE_INTRIN_ENDPOINT   
volatile uchar usbTxLen1 = USBPID_NAK;  /* TX count for endpoint 1 */  
uchar       usbTxBuf1[USB_BUFSIZE];     /* TX data for endpoint 1 */  
#if USB_CFG_HAVE_INTRIN_ENDPOINT3   
volatile uchar usbTxLen3 = USBPID_NAK;  /* TX count for endpoint 1 */  
uchar       usbTxBuf3[USB_BUFSIZE];     /* TX data for endpoint 1 */  
#endif   
#endif   
  
/* USB status registers / not shared with asm code */  
uchar           *usbMsgPtr;     /* data to transmit next -- ROM or RAM address */  
static uchar    usbMsgFlags;    /* flag values see below */  
  
#define USB_FLG_TX_PACKET       (1<<0)   
/* Leave free 6 bits after TX_PACKET. This way we can increment usbMsgFlags to toggle TX_PACKET */  
#define USB_FLG_MSGPTR_IS_ROM   (1<<6)   
#define USB_FLG_USE_DEFAULT_RW  (1<<7)   
  
/* 
optimizing hints: 
- do not post/pre inc/dec integer values in operations 
- assign value of PRG_RDB() to register variables and don't use side effects in arg 
- use narrow scope for variables which should be in X/Y/Z register 
- assign char sized expressions to variables to force 8 bit arithmetics 
*/  
  
/* ------------------------------------------------------------------------- */  
  
#if USB_CFG_DESCR_PROPS_STRINGS == 0   
  
#if USB_CFG_DESCR_PROPS_STRING_0 == 0   
#undef USB_CFG_DESCR_PROPS_STRING_0   
#define USB_CFG_DESCR_PROPS_STRING_0    sizeof(usbDescriptorString0)   
PROGMEM char usbDescriptorString0[] = { /* language descriptor */  
    4,          /* sizeof(usbDescriptorString0): length of descriptor in bytes */  
    3,          /* descriptor type */  
    0x09, 0x04, /* language index (0x0409 = US-English) */  
};  
#endif   
  
#if USB_CFG_DESCR_PROPS_STRING_VENDOR == 0 && USB_CFG_VENDOR_NAME_LEN   
#undef USB_CFG_DESCR_PROPS_STRING_VENDOR   
#define USB_CFG_DESCR_PROPS_STRING_VENDOR   sizeof(usbDescriptorStringVendor)   
PROGMEM int  usbDescriptorStringVendor[] = {  
    USB_STRING_DESCRIPTOR_HEADER(USB_CFG_VENDOR_NAME_LEN),  
    USB_CFG_VENDOR_NAME  
};  
#endif   
  
#if USB_CFG_DESCR_PROPS_STRING_PRODUCT == 0 && USB_CFG_DEVICE_NAME_LEN   
#undef USB_CFG_DESCR_PROPS_STRING_PRODUCT   
#define USB_CFG_DESCR_PROPS_STRING_PRODUCT   sizeof(usbDescriptorStringDevice)   
PROGMEM int  usbDescriptorStringDevice[] = {  
    USB_STRING_DESCRIPTOR_HEADER(USB_CFG_DEVICE_NAME_LEN),  
    USB_CFG_DEVICE_NAME  
};  
#endif   
  
#if USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER == 0 && USB_CFG_SERIAL_NUMBER_LEN   
#undef USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER   
#define USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER    sizeof(usbDescriptorStringSerialNumber)   
PROGMEM int usbDescriptorStringSerialNumber[] = {  
    USB_STRING_DESCRIPTOR_HEADER(USB_CFG_SERIAL_NUMBER_LEN),  
    USB_CFG_SERIAL_NUMBER  
};  
#endif   
  
#endif  /* USB_CFG_DESCR_PROPS_STRINGS == 0 */   
  
#if USB_CFG_DESCR_PROPS_DEVICE == 0   
#undef USB_CFG_DESCR_PROPS_DEVICE   
#define USB_CFG_DESCR_PROPS_DEVICE  sizeof(usbDescriptorDevice)   
PROGMEM char usbDescriptorDevice[] = {    /* USB device descriptor */  
    18,         /* sizeof(usbDescriptorDevice): length of descriptor in bytes */  
    USBDESCR_DEVICE,        /* descriptor type */  
    0x10, 0x01,             /* USB version supported */  
    USB_CFG_DEVICE_CLASS,  
    USB_CFG_DEVICE_SUBCLASS,  
    0,                      /* protocol */  
    8,                      /* max packet size */  
    USB_CFG_VENDOR_ID,      /* 2 bytes */  
    USB_CFG_DEVICE_ID,      /* 2 bytes */  
    USB_CFG_DEVICE_VERSION, /* 2 bytes */  
    USB_CFG_DESCR_PROPS_STRING_VENDOR != 0 ? 1 : 0,         /* manufacturer string index */  
    USB_CFG_DESCR_PROPS_STRING_PRODUCT != 0 ? 2 : 0,        /* product string index */  
    USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER != 0 ? 3 : 0,  /* serial number string index */  
    1,          /* number of configurations */  
};  
#endif   
  
#if USB_CFG_DESCR_PROPS_HID_REPORT != 0 && USB_CFG_DESCR_PROPS_HID == 0   
#undef USB_CFG_DESCR_PROPS_HID   
#define USB_CFG_DESCR_PROPS_HID     9   /* length of HID descriptor in config descriptor below */   
#endif   
  
#if USB_CFG_DESCR_PROPS_CONFIGURATION == 0   
#undef USB_CFG_DESCR_PROPS_CONFIGURATION   
#define USB_CFG_DESCR_PROPS_CONFIGURATION   sizeof(usbDescriptorConfiguration)   
PROGMEM char usbDescriptorConfiguration[] = {    /* USB configuration descriptor */  
    9,          /* sizeof(usbDescriptorConfiguration): length of descriptor in bytes */  
    USBDESCR_CONFIG,    /* descriptor type */  
    18 + 7 * USB_CFG_HAVE_INTRIN_ENDPOINT + (USB_CFG_DESCR_PROPS_HID & 0xff), 0,  
                /* total length of data returned (including inlined descriptors) */  
    1,          /* number of interfaces in this configuration */  
    1,          /* index of this configuration */  
    0,          /* configuration name string index */  
#if USB_CFG_IS_SELF_POWERED   
    USBATTR_SELFPOWER,  /* attributes */  
#else   
    USBATTR_BUSPOWER,   /* attributes */  
#endif   
    USB_CFG_MAX_BUS_POWER/2,            /* max USB current in 2mA units */  
/* interface descriptor follows inline: */  
    9,          /* sizeof(usbDescrInterface): length of descriptor in bytes */  
    USBDESCR_INTERFACE, /* descriptor type */  
    0,          /* index of this interface */  
    0,          /* alternate setting for this interface */  
    USB_CFG_HAVE_INTRIN_ENDPOINT,   /* endpoints excl 0: number of endpoint descriptors to follow */  
    USB_CFG_INTERFACE_CLASS,  
    USB_CFG_INTERFACE_SUBCLASS,  
    USB_CFG_INTERFACE_PROTOCOL,  
    0,          /* string index for interface */  
#if (USB_CFG_DESCR_PROPS_HID & 0xff)    /* HID descriptor */   
    9,          /* sizeof(usbDescrHID): length of descriptor in bytes */  
    USBDESCR_HID,   /* descriptor type: HID */  
    0x01, 0x01, /* BCD representation of HID version */  
    0x00,       /* target country code */  
    0x01,       /* number of HID Report (or other HID class) Descriptor infos to follow */  
    0x22,       /* descriptor type: report */  
    USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH, 0,  /* total length of report descriptor */  
#endif   
#if USB_CFG_HAVE_INTRIN_ENDPOINT    /* endpoint descriptor for endpoint 1 */   
    7,          /* sizeof(usbDescrEndpoint) */  
    USBDESCR_ENDPOINT,  /* descriptor type = endpoint */  
    0x81,       /* IN endpoint number 1 */  
    0x03,       /* attrib: Interrupt endpoint */  
    8, 0,       /* maximum packet size */  
    USB_CFG_INTR_POLL_INTERVAL, /* in ms */  
#endif   
};  
#endif   
  
/* We don't use prog_int or prog_int16_t for compatibility with various libc 
 * versions. Here's an other compatibility hack: 
 */  
#ifndef PRG_RDB   
#define PRG_RDB(addr)   pgm_read_byte(addr)   
#endif   
  
typedef union{  
    unsigned    word;  
    uchar       *ptr;  
    uchar       bytes[2];  
}converter_t;  
/* We use this union to do type conversions. This is better optimized than 
 * type casts in gcc 3.4.3 and much better than using bit shifts to build 
 * ints from chars. Byte ordering is not a problem on an 8 bit platform. 
 */  
  
/* ------------------------------------------------------------------------- */  
  
#if USB_CFG_HAVE_INTRIN_ENDPOINT   
USB_PUBLIC void usbSetInterrupt(uchar *data, uchar len)  
{  
uchar       *p, i;  
  
#if USB_CFG_IMPLEMENT_HALT   
    if(usbTxLen1 == USBPID_STALL)  
        return;  
#endif   
#if 0   /* No runtime checks! Caller is responsible for valid data! */   
    if(len > 8) /* interrupt transfers are limited to 8 bytes */  
        len = 8;  
#endif   
    if(usbTxLen1 & 0x10){   /* packet buffer was empty */  
        usbTxBuf1[0] ^= USBPID_DATA0 ^ USBPID_DATA1;    /* toggle token */  
    }else{  
        usbTxLen1 = USBPID_NAK; /* avoid sending outdated (overwritten) interrupt data */  
    }  
    p = usbTxBuf1 + 1;  
    for(i=len;i--;)  
        *p++ = *data++;  
    usbCrc16Append(&usbTxBuf1[1], len);  
    usbTxLen1 = len + 4;    /* len must be given including sync byte */  
    DBG2(0x21, usbTxBuf1, len + 3);  
}  
#endif   
  
#if USB_CFG_HAVE_INTRIN_ENDPOINT3   
USB_PUBLIC void usbSetInterrupt3(uchar *data, uchar len)  
{  
uchar       *p, i;  
  
    if(usbTxLen3 & 0x10){   /* packet buffer was empty */  
        usbTxBuf3[0] ^= USBPID_DATA0 ^ USBPID_DATA1;    /* toggle token */  
    }else{  
        usbTxLen3 = USBPID_NAK; /* avoid sending outdated (overwritten) interrupt data */  
    }  
    p = usbTxBuf3 + 1;  
    for(i=len;i--;)  
        *p++ = *data++;  
    usbCrc16Append(&usbTxBuf3[1], len);  
    usbTxLen3 = len + 4;    /* len must be given including sync byte */  
    DBG2(0x23, usbTxBuf3, len + 3);  
}  
#endif   
  
  
static uchar usbRead(uchar *data, uchar len)  
{  
#if USB_CFG_IMPLEMENT_FN_READ   
    if(usbMsgFlags & USB_FLG_USE_DEFAULT_RW){  
#endif   
        uchar i = len, *r = usbMsgPtr;  
        if(usbMsgFlags & USB_FLG_MSGPTR_IS_ROM){    /* ROM data */  
            while(i--){  
                uchar c = PRG_RDB(r);    /* assign to char size variable to enforce byte ops */  
                *data++ = c;  
                r++;  
            }  
        }else{                  /* RAM data */  
            while(i--)  
                *data++ = *r++;  
        }  
        usbMsgPtr = r;  
        return len;  
#if USB_CFG_IMPLEMENT_FN_READ   
    }else{  
        if(len != 0)    /* don't bother app with 0 sized reads */  
            return usbFunctionRead(data, len);  
        return 0;