1. This forum section is a read-only archive which contains old newsgroup posts. If you wish to post a query, please do so in one of our main forum sections (here). This way you will get a faster, better response from the members on Motherboard Point.

USB-Communication Device Class-Virtual Com Port

Discussion in 'Embedded' started by igelegin, Jul 19, 2012.

  1. igelegin

    igelegin Guest

    Hi all,
    I wrote an enumeration and soruce codes as you can see below for makin
    communicated Max3420e USB with PC via terminals . When I plugged in th
    USB, PC said "USB Device not recognized".
    I don't understand where my fault:(
    I only want to make communicated Max USB with PC terminals(TeraTerm,Hype
    Terminal etc.)
    Please help me,please...

    Note:I attached one c file and two header file to my message.
    Abraham.

    //****************************************************************************
    //max_usb_driver_enum.c
    //****************************************************************************
    #include <soc.h>
    #include <csl_mcbsp.h>
    #include <csl_tmr.h>
    #include <csl_gpio.h>
    #include <csl_pllc.h>
    #include <stdio.h>
    #include "max3420e_usb.h"
    #include "max_usb_driver_enum_data.h"
    #include "spi_usb_comm.h"


    #define ENABLE_IRQ
    usb_write_config(rEPIEN,(bmSUDAVIE+bmIN3BAVIE+bmIN0BAVIE+bmOUT0DAVIE))
    usb_write_config(rUSBIEN,(bmURESIE+bmURESDNIE+bmBUSACTIE));
    #define TWENTY_MSEC 14200 // adjust this constant for 20 mse
    button checks
    #define BLINKTIME 25 // blink every 500 msec


    //Global variables
    Uint8 SUD[8];
    Uint8 configval; // Set/Get_Configuration value
    Uint8 ep3stall; // Flag for EP3 Stall, set by Set_Feature
    reported back in Get_Status
    Uint8 interfacenum; // Set/Get interface value
    Uint8 RWU_enabled; // Set by Set/Clear_Feature RWU request
    sent back for Get_Status-RWU
    Uint8 Suspended; // Tells the main loop to look for hos
    resume and RWU pushbutton
    Uint16 msec_timer; // Count off time in the main loop
    Uint16 blinktimer; // Count milliseconds to blink the "loo
    active" light
    Uint8 test_1,test_2,test_3;
    int i;
    Uint8 msgidx,msglen; // Text string in EnumApp_enum_data.h--inde
    and length
    Uint8 inhibit_send; // Flag for the keyboard character sen
    routine
    Uint8 send3zeros; // EP3-IN function uses this to send HI
    (key up) codes between keystrokes
    Uint8 test_4[64];
    int PC_DTR=0;


    // USB functions
    void std_request(void);
    void class_request(void);
    void vendor_request(void);
    void send_descriptor(void);
    void feature(Uint8);
    void get_status(void);
    void set_interface(void);
    void get_interface(void);
    void set_configuration(void);
    void get_configuration(void);


    // Application code
    void do_SETUP(void);
    void do_IN3(void); // Handle a USB SETUP transfer
    void check_for_resume(void);
    void service_irqs(void);
    void usb_main_exec(void);


    //********main
    void usb_main_exec(void)
    {
    test_1 = usb_read_config(rFNADDR);
    test_2 = usb_read_config(rEPIRQ);
    test_3 = usb_read_config(rUSBIRQ);

    if(Suspended)
    {
    check_for_resume();
    }
    service_irqs(); //burada if içinde "max_int_pending" diye bi
    fonk vardı
    msec_timer++;
    if(msec_timer==TWENTY_MSEC)
    {
    msec_timer=0;
    }
    blinktimer++; // blink the loop active light ever
    half second
    if(blinktimer==BLINKTIME)
    {
    blinktimer=0;
    } // msec_timer==ONE_MSEC
    }


    void check_for_resume(void)
    {
    if(usb_read_config(rUSBIRQ) & bmBUSACTIRQ) // THE HOST RESUME
    BUS TRAFFIC
    {
    Suspended=0; // no longer suspended
    }
    }

    void service_irqs(void)
    {
    Uint8 itest1,itest2;
    itest1 = usb_read_config(rEPIRQ); // Check the EPIRQ bits
    itest2 = usb_read_config(rUSBIRQ); // Check the USBIRQ bits
    if(itest1 & bmSUDAVIRQ)
    {
    usb_write_config(rEPIRQ,bmSUDAVIRQ); // clear the SUDAV IRQ
    do_SETUP();
    }
    if(itest1 & bmIN3BAVIRQ) // Was an EP3-IN packet jus
    dispatched to the host?
    {
    //do_IN3();
    }
    if((configval != 0) && (itest2&bmSUSPIRQ)) // HOST suspended bus fo
    3 msec
    {
    usb_write_config(rUSBIRQ,(bmSUSPIRQ+bmBUSACTIRQ)); // clear the IR
    and bus activity IRQ
    Suspended=1; // signal the main loop
    }
    if(usb_read_config(rUSBIRQ)& bmURESIRQ)
    {
    usb_write_config(rUSBIRQ,bmURESIRQ); // clear the IRQ
    }
    if(usb_read_config(rUSBIRQ) & bmURESDNIRQ)
    {
    usb_write_config(rUSBIRQ,bmURESDNIRQ); // clear the IRQ bit
    Suspended=0; // in case we were suspended
    ENABLE_IRQS // ...because a bus reset clears
    the IE bits
    }
    }


    void do_SETUP(void)
    {
    int i;
    for (i=0;i<8;i++)
    {
    SUD=usb_read_config(rSUDFIFO); // got a SETUP packet. Read 8
    SETUP bytes
    }
    switch(SUD[bmRequestType]&0x60) // Parse the SETUP packet.For
    request type,look only at b6&b5
    {
    case 0x00: std_request(); break;
    case 0x20: class_request(); break; // just a stub in this program
    case 0x40: vendor_request(); break; // just a stub in this
    program
    default: STALL_EP0 // unrecognized request type
    }
    }

    /*void do_IN3(void)
    {
    usb_write_config(rEP3INFIFO,Message[msgidx++]); // load the keystroke
    (3 bytes)
    usb_write_config(rEP3INFIFO,Message[msgidx++]);
    usb_write_config(rEP3INFIFO,Message[msgidx++]);
    if(msgidx >= msglen) // check for message wrap
    {
    msgidx=0;
    }
    usb_write_configAS(rEP3INBC,3); // arm it
    }*/


    void std_request(void)
    {
    switch(SUD[bRequest])
    {
    case SR_GET_DESCRIPTOR: send_descriptor(); break;
    //case SR_SET_FEATURE: feature(1); break;
    //case SR_CLEAR_FEATURE: feature(0); break;
    //case SR_GET_STATUS: get_status(); break;
    case SR_SET_INTERFACE: set_interface(); break;
    case SR_GET_INTERFACE: get_interface(); break;
    case SR_GET_CONFIGURATION: get_configuration(); break;
    case SR_SET_CONFIGURATION: set_configuration(); break;
    case SR_SET_ADDRESS: usb_read_configAS(rFNADDR); break; //
    discard return value
    default:STALL_EP0
    }
    }


    void set_configuration(void)
    {
    configval=wValueL; // Store the config value
    if(configval != 0) // If we are configured,
    SETBIT(rUSBIEN,bmSUSPIE); // start looking for SUSPEND
    interrupts
    usb_read_configAS(rFNADDR); // dummy read to set the
    ACKSTAT bit
    }

    void get_configuration(void)
    {
    usb_write_config(rEP0FIFO,configval); // Send the config value
    usb_write_configAS(rEP0BC,1);
    }


    void set_interface(void) // All we accept are Interface=0 and
    AlternateSetting=0, otherwise send STALL
    {
    Uint8 dumval;
    if((SUD[wValueL]==0) // wValueL=Alternate Setting index
    &&(SUD[wIndexL]==0)) // wIndexL=Interface index
    dumval=usb_read_configAS(rFNADDR); // dummy read to set the ACKSTAT
    bit
    else STALL_EP0
    }


    void get_interface(void) // Check for Interface=0, always report
    AlternateSetting=0
    {
    if(SUD[wIndexL]==0) // wIndexL=Interface index
    {
    usb_write_config(rEP0FIFO,0); // AS=0
    usb_write_configAS(rEP0BC,1); // send one byte, ACKSTAT
    }
    else STALL_EP0
    }


    void get_status(void)
    {
    Uint8 testbyte;
    testbyte=SUD[bmRequestType];
    switch(testbyte)
    {
    case 0x80: // directed to DEVICE
    usb_write_config(rEP0FIFO,(RWU_enabled+1)); // first byte is 000000rs
    where r=enabled for RWU and s=self-powered.
    usb_write_config(rEP0FIFO,0x00); // second byte is always 0
    usb_write_configAS(rEP0BC,2); // load byte count, arm the IN
    transfer, ACK the status stage of the CTL transfer
    break;
    case 0x81: // directed to INTERFACE
    usb_write_config(rEP0FIFO,0x00); // this one is easy--two zero bytes
    usb_write_config(rEP0FIFO,0x00);
    usb_write_configAS(rEP0BC,2); // load byte count, arm the IN
    transfer, ACK the status stage of the CTL transfer
    break;
    case 0x82: // directed to ENDPOINT
    if(SUD[wIndexL]==0x83) // We only reported ep3, so it's the only
    one the host can stall IN3=83
    {
    usb_write_config(rEP0FIFO,ep3stall); // first byte is 0000000h where h
    is the halt (stall) bit
    usb_write_config(rEP0FIFO,0x00); // second byte is always 0
    usb_write_configAS(rEP0BC,2); // load byte count, arm the IN
    transfer, ACK the status stage of the CTL transfer
    break;
    }
    else STALL_EP0 // Host tried to stall an invalid endpoint (not
    3)
    default: STALL_EP0 // don't recognize the request
    }
    }


    // FUNCTION: Set/Get_Feature. Call as feature(1) for Set_Feature or
    feature(0) for Clear_Feature.
    // There are two set/clear feature requests:
    // To a DEVICE: Remote Wakeup (RWU).
    // To an ENDPOINT: Stall (EP3 only for this app)
    //

    void feature(Uint8 sc)
    {
    Uint8 mask;
    if((SUD[bmRequestType]==0x02) // dir=h->p, recipient = ENDPOINT
    && (SUD[wValueL]==0x00) // wValueL is feature selector, 00 is EP
    Halt
    && (SUD[wIndexL]==0x83)) // wIndexL is endpoint number IN3=83
    {
    mask=usb_read_config(rEPSTALLS); // read existing bits
    if(sc==1) // set_feature
    {
    mask += bmSTLEP3IN; // Halt EP3IN
    ep3stall=1;
    }
    else // clear_feature
    {
    mask &= ~bmSTLEP3IN; // UnHalt EP3IN
    ep3stall=0;
    usb_write_config(rCLRTOGS,bmCTGEP3IN); // clear the EP3 data
    toggle
    }
    usb_write_config(rEPSTALLS,(mask|bmACKSTAT)); // Don't use
    usb_write_configAS for this--directly writing the ACKSTAT bit
    }
    else if ((SUD[bmRequestType]==0x00) // dir=h->p, recipient = DEVICE
    && (SUD[wValueL]==0x01)) // wValueL is feature selector, 01
    is Device_Remote_Wakeup
    {
    RWU_enabled = sc<<1; // =2 for set, =0 for clear feature.
    The shift puts it in the get_status bit position.
    usb_read_configAS(rFNADDR); // dummy read to set ACKSTAT
    }
    else STALL_EP0
    }


    void send_descriptor(void)
    {
    Uint16 reqlen,sendlen,desclen;
    Uint8 *pDdata; // pointer to ROM Descriptor data to send

    // NOTE This function assumes all descriptors are 64 or fewer bytes and can
    be sent in a single packet

    desclen = 0; // check for zero as error condition (no case
    statements satisfied)
    reqlen = SUD[wLengthL] + 256*SUD[wLengthH]; // 16-bit
    switch (SUD[wValueH]) // wValueH is descriptor type
    {
    case GD_DEVICE:
    desclen = device_descriptor[0]; // descriptor length
    pDdata = device_descriptor;
    break;
    case GD_CONFIGURATION:
    desclen = configuration_descriptor[2]; // Config descriptor
    includes interface, HID, report and ep descriptors
    pDdata = configuration_descriptor;
    break;
    case GD_STRING:
    desclen = string_descriptor[SUD[wValueL]][0]; // wValueL=string
    index, array[0] is the length
    pDdata = string_descriptor[SUD[wValueL]]; // point to first
    array element
    break;
    case CS_INTERFACE:
    if(SUD[wIndexL]==0) // Interface Number=0. Del EndPoint 2
    (interrupción), Communication
    {

    //if(SUD[wLengthL]>configuration_descriptor[9])
    desclen = configuration_descriptor[9];
    //else desclen = SUD[wLengthL];
    pDdata = (Uint8 *)
    &configuration_descriptor[9];
    }
    else if (SUD[wIndexL]==1) // Interface
    Number=1. Del EndPoint 1 (bulk), Datos
    {

    //if(SUD[wLengthL]>configuration_descriptor[44])
    desclen = configuration_descriptor[44];
    //else desclen = SUD[wLengthL];
    pDdata = (Uint8 *)
    &configuration_descriptor[44];
    }
    break;
    /* case GD_REPORT:
    desclen = configuration_descriptor[25];
    pDdata = report_descriptor;
    break;*/
    } // end switch on descriptor type

    if (desclen!=0)
    {
    sendlen = (reqlen <= desclen) ? reqlen : desclen;
    if(sendlen<=64) //if just one frame
    {
    usb_write_bytes(rEP0FIFO,sendlen,pDdata);
    usb_write_configAS(rEP0BC,sendlen);
    }
    else //if sendlen > 64, like your configuration descriptor,
    67 byte require 2 frame
    {
    do
    {

    sendlen = 64; //first time i send 64 bytes, because 67 = 64+ 3
    usb_write_bytes(rEP0FIFO,sendlen,pDdata);
    usb_write_config(rEP0BC,sendlen);
    desclen=desclen-sendlen;
    pDdata=pDdata+sendlen;

    } while(desclen>64);

    sendlen = desclen;
    while(!usb_read_config(rEPIRQ& bmIN0BAVIRQ));
    if(sendlen>0) usb_write_bytes(rEP0FIFO,sendlen,pDdata); //3 bytes
    more
    usb_write_configAS(rEP0BC,sendlen);
    }
    }

    else STALL_EP0 // none of the descriptor types match
    }



    void class_request(void)
    {
    switch (SUD[bRequest])
    {
    case SEND_ENCAPSULATED_COMMAND: usb_write_configAS(rEP0BC, 0);
    break; // send_encapsulated_command(); break;
    case GET_ENCAPSULATED_RESPONSE: usb_write_configAS(rEP0BC, 0);
    break; // send_encapsulated_command(); break; //
    get_encapsulated_response(); break;

    case SET_COMM_FEATURE: break;
    case GET_COMM_FEATURE: break;
    case CLEAR_COMM_FEATURE:break;
    case SET_LINE_CODING:
    {
    usb_write_configAS(rEP0BC, 0);

    if(SUD[wLengthL]>0)
    {
    while(!(usb_read_config(rEPIRQ) & bmOUT0DAVIRQ) &
    SUD[7]<=5) SUD[7]++;
    for(i=0;i<=SUD[wLengthL];)
    usb_read_bytes(rEP0FIFO,SUD[wLengthL],(unsigned char *)&SUD[0]);

    }
    } break;
    case GET_LINE_CODING:
    {
    usb_write_configAS(rEP0BC, 0);

    usb_write_bytes(rEP0FIFO,SUD[wLengthL],(unsigned cha
    *)&SerialConf[0]);
    usb_write_config(rEP0BC, SUD[wLengthL]);
    } break;
    case SET_CONTROL_LINE_STATE:
    {
    if(configval)
    {
    spi_max3420_init();

    if((SUD[wValueL]&0x01)==0x01)
    PC_DTR=1;
    if(SUD[wValueL]==0x00)
    PC_DTR=0;
    }
    usb_write_configAS(rEP3INBC, 0);
    } break;
    case SEND_BREAK: break;
    default: STALL_EP0;
    }
    }

    void vendor_request(void)
    {
    STALL_EP0
    }
    // ******************** END of ENUMERATION CODE ********************


    //****************************************************************************
    //max_usb_driver_enum_data.h
    //****************************************************************************



    // Enumeration tables

    Uint8 device_descriptor[]= // DEVICE Descriptor
    { 0x12, // bLength = 18d
    0x01, // bDescriptorType = Device (1)
    0x00,0x02, // bcdUSB(L/H) USB spec rev (BCD)
    0x02,0x00,0x00, // bDeviceClass, bDeviceSubClass
    bDeviceProtocol
    0x40, // bMaxPacketSize0 EP0 is 64 bytes
    0x6A,0x0B, // idVendor(L/H)--Maxim is 0B6A
    0x46,0x53, // idProduct(L/H)--5346
    0x00,0x10, // bcdDevice--1234
    1,2,0, // iManufacturer, iProduct, iSerialNumber
    0x01 // bNumConfigurations
    };

    Uint8 configuration_descriptor[]= // CONFIGURATION Descriptor
    { 0x09, // bLength
    0x02, // bDescriptorType = Config
    0x43,0x00, // wTotalLength(L/H) = 67 bytes
    0x02, // bNumInterfaces
    0x01, // bConfigValue
    0x00, // iConfiguration
    0xE0, // bmAttributes. b7=1 b6=self-powered b5=RWU supported
    0x01, // MaxPower is 2 ma
    // INTERFACE Descriptor
    0x09, // length = 9
    0x04, // type = IF
    0x00, // IF #0, Number of the interface -> defaul
    first interface is 0
    0x00, // bAlternate Setting
    0x01, // bNum Endpoints
    0x02, // bInterfaceClass = CDC
    0x02,0x01, // bInterfaceSubClass, bInterfaceProtocol
    0x00, // iInterface
    // Header Functional Descriptor (marks beginning of th
    concatenated set of Functional Descriptors)
    0x05, // bFunctionLength, Descriptor size in bytes --[18
    --[48]
    0x24, // bDescriptorType, CS_INTERFACE
    0x00, // bDescriptorSubtype, Header Functional Descriptor
    0x10,0x01, // bcdCDC, CDC specification release number in BC
    format ([0x10, 0x01])

    // Call Management Functional Descriptor
    0x05, // bFunctionLength, Descriptor size in bytes
    0x24, // bDescriptorType, CS_INTERFACE
    0x01, // bDescriptorSubtype, Call Management Functiona
    Descriptor
    0x03, // bmCapabilities, Device doesn't call management itsel
    (0->3)
    0x01, // bDataInterface, Interface used for call management
    // Abstract Control Management Functional Descriptor
    0x04, // bDescriptorLength, Descriptor size in bytes
    0x24, // bDescriptorType, CS_INTERFACE
    0x02, // bDescriptorSubtype, Abstract Control Management
    Functional Descriptor
    0x06, // bmCapabilities, Support for the GET/SET_LINE_CODING,
    BREAK & SET_CONTROL_LINE_STATE

    // Union Functional Descriptor
    0x05, // bFunctionLength, Descriptor size in bytes
    0x24, // bDescriptorType, CS_INTERFACE
    0x06, // bDescriptorSubtype, Union Functional Descriptor
    0x00, // bMasterInterface, The controlling interface for the
    union (bInterfaceNumber of a Communication or Data Class interface in this
    configuration)
    0x01, // bSlaveInterface0, The controlled interace in the union
    (bInterfaceNumber of an interface in this configuration)
    // Endpoint Descriptor 3 --> Data from USB-Maxim-Chip to the
    Host-PC
    0x07, // bLength
    0x05, // bDescriptorType (Endpoint)
    0x83, // bEndpointAddress (EP2-IN)
    0x03, // bmAttributes (bulk = 2)
    0x40,0x00, // wMaxPacketSize (64[0x40])
    0x00, // bInterval (0x00)
    // INTERFACE Descriptor
    0x09, // length = 9 --[44]
    0x04, // type = IF
    0x01, // InterFace Number = 1
    0x00, // bAlternate Setting
    0x02, // bNum Endpoints = 2 (IN&OUT)
    0x0A, // bInterfaceClass = A (Data)
    0x00,0x00, // bInterfaceSubClass, bInterfaceProtocol
    (SubClass ACM=Abstract Control Mode, InterfaceProtocol=V.25ter, common AT
    commands)
    0x00, // iInterface

    // Endpoint Descriptor 1-OUT --> Data from the Host-PC to
    USB-Maxim-Chip
    0x07, // bLength
    0x05, // bDescriptorType (Endpoint)
    0x01, // bEndpointAddress (EP1-OUT) (Adress ranges -->
    out: 0x01..0x0F in: 0x81..0x8F
    0x02, // bNum Endpoints = 2 (IN&OUT)
    0x40,0x00, // wMaxPacketSize (64)
    00, // bInterval

    // Endpoint Descriptor EP2-IN
    0x07, // bLength
    0x05, // bDescriptorType (Endpoint)
    0x82, // bEndpointAddress (EP2-IN) (Adress ranges -->
    out: 0x01..0x0F in: 0x81..0x8F
    0x02, // bmAttributes (interrupt)
    0x40,0x00, // wMaxPacketSize (64)
    0x02, // bInterval (poll every 2 msec)
    };



    // STRING descriptors. An array of string arrays

    Uint8 string_descriptor[][64]=
    {
    // STRING descriptor 0--Language string
    {
    0x04, // bLength
    0x03, // bDescriptorType = string
    0x09,0x04 // wLANGID(L/H) = English-United Sates
    },
    // STRING descriptor 1--Manufacturer ID
    {
    12, // bLength
    0x03, // bDescriptorType = string
    'M',0,'a',0,'x',0,'i',0,'m',0 // text in Unicode
    },
    // STRING descriptor 2 - Product ID
    {
    24, // bLength
    0x03, // bDescriptorType = string
    'M',0,'A',0,'X',0,'3',0,'4',0,'2',0,'0',0,'E',0,' ',0,
    'E',0,'n',0,'u',0,'m',0,' ',0,'C',0,'o',0,'d',0,'e',0
    },

    // STRING descriptor 3 - Serial Number ID
    {
    20, // bLength
    0x03, // bDescriptorType = string
    'S',0,
    '/',0,
    'N',0,
    ' ',0,
    '3',0,
    '4',0,
    '2',0,
    '0',0,
    'E',0,
    }
    };

    const unsigned char SerialConf[]=
    { 0x80,0x25,0x00,0x00, // dwDTFRate. Baudrate (2580ex->9600 baud)
    0, // bCharFormat. 1 Stop bit
    0, // bParityType: none
    8, // Number of data bits: 8
    };

    //****************************************************************************
    //max3420e_usb.h
    //****************************************************************************


    #ifndef MAX3420E_H_
    #define MAX3420E_H_

    #define SETBIT(reg,val) usb_write_config(reg,(usb_read_config(reg)|val));
    #define CLRBIT(reg,val) usb_write_config(reg,(usb_read_config(reg)&~val));

    // ************ BUG FIX ************
    //#define STALL_EP0 usb_write_config(9,0x23); // Set all three EP0 stall
    bits--data stage IN/OUT and status stage
    // BUG FIX 2-9-06. The above statement hard-codes the register number to 9,
    ignoring the fact that
    // the usb_write_config function expects the register numbers to be
    pre-shifted 3 bits to put them into the 5 MSB's of
    // the SPI command byte. Here is the correction:

    #define STALL_EP0 usb_write_config(rEPSTALLS,0x23); // Set all three EP0
    stall bits--data stage IN/OUT and status stage

    // ******** END OF BUG FIX**********

    #define MSB(word) (BYTE)(((WORD)(word) >> 8) & 0xff)
    #define LSB(word) (BYTE)((WORD)(word) & 0xff)

    // MAX3420E Registers
    #define rEP0FIFO 0x00
    #define rEP1OUTFIFO 0x08
    #define rEP2INFIFO 0x10
    #define rEP3INFIFO 0x18
    #define rSUDFIFO 0x20
    #define rEP0BC 0x28
    #define rEP1OUTBC 0x30
    #define rEP2INBC 0x38
    #define rEP3INBC 0x40
    #define rEPSTALLS 0x48
    #define rCLRTOGS 0x50
    #define rEPIRQ 0x58
    #define rEPIEN 0x60
    #define rUSBIRQ 0x68
    #define rUSBIEN 0x70
    #define rUSBCTL 0x78
    #define rCPUCTL 0x80
    #define rPINCTL 0x88
    #define rRevision 0x90
    #define rFNADDR 0x98
    #define rGPIO 0xA0

    // MAX3420E bit masks for register bits
    // R9 EPSTALLS Register
    #define bmACKSTAT 0x40
    #define bmSTLSTAT 0x20
    #define bmSTLEP3IN 0x10
    #define bmSTLEP2IN 0x08
    #define bmSTLEP1OUT 0x04
    #define bmSTLEP0OUT 0x02
    #define bmSTLEP0IN 0x01

    // R10 CLRTOGS Register
    #define bmEP3DISAB 0x80
    #define bmEP2DISAB 0x40
    #define bmEP1DISAB 0x20
    #define bmCTGEP3IN 0x10
    #define bmCTGEP2IN 0x08
    #define bmCTGEP1OUT 0x04

    // R11 EPIRQ register bits
    #define bmSUDAVIRQ 0x20
    #define bmIN3BAVIRQ 0x10
    #define bmIN2BAVIRQ 0x08
    #define bmOUT1DAVIRQ 0x04
    #define bmOUT0DAVIRQ 0x02
    #define bmIN0BAVIRQ 0x01

    // R12 EPIEN register bits
    #define bmSUDAVIE 0x20
    #define bmIN3BAVIE 0x10
    #define bmIN2BAVIE 0x08
    #define bmOUT1DAVIE 0x04
    #define bmOUT0DAVIE 0x02
    #define bmIN0BAVIE 0x01

    // R13 USBIRQ register bits
    #define bmURESDNIRQ 0x80
    #define bmVBUSIRQ 0x40
    #define bmNOVBUSIRQ 0x20
    #define bmSUSPIRQ 0x10
    #define bmURESIRQ 0x08
    #define bmBUSACTIRQ 0x04
    #define bmRWUDNIRQ 0x02
    #define bmOSCOKIRQ 0x01

    // R14 USBIEN register bits
    #define bmURESDNIE 0x80
    #define bmVBUSIE 0x40
    #define bmNOVBUSIE 0x20
    #define bmSUSPIE 0x10
    #define bmURESIE 0x08
    #define bmBUSACTIE 0x04
    #define bmRWUDNIE 0x02
    #define bmOSCOKIE 0x01

    // R15 USBCTL Register
    #define bmHOSCSTEN 0x80
    #define bmVBGATE 0x40
    #define bmCHIPRES 0x20
    #define bmPWRDOWN 0x10
    #define bmCONNECT 0x08
    #define bmSIGRWU 0x04

    // R16 CPUCTL Register
    #define bmIE 0x01

    // R17 PINCTL Register
    #define bmFDUPSPI 0x10
    #define bmINTLEVEL 0x08
    #define bmPOSINT 0x04
    #define bmGPOB 0x02
    #define bmGPOA 0x01

    //
    // GPX[B:A] settings (PINCTL register)
    #define gpxOPERATE 0x00
    #define gpxVBDETECT 0x01
    #define gpxBUSACT 0x02
    #define gpxSOF 0x03

    // ************************
    // Standard USB Requests
    #define SR_GET_STATUS 0x00 // Get Status
    #define SR_CLEAR_FEATURE 0x01 // Clear Feature
    #define SR_RESERVED 0x02 // Reserved
    #define SR_SET_FEATURE 0x03 // Set Feature
    #define SR_SET_ADDRESS 0x05 // Set Address
    #define SR_GET_DESCRIPTOR 0x06 // Get Descriptor
    #define SR_SET_DESCRIPTOR 0x07 // Set Descriptor
    #define SR_GET_CONFIGURATION 0x08 // Get Configuration
    #define SR_SET_CONFIGURATION 0x09 // Set Configuration
    #define SR_GET_INTERFACE 0x0a // Get Interface
    #define SR_SET_INTERFACE 0x0b // Set Interface

    // Get Descriptor codes
    #define GD_DEVICE 0x01 // Get device descriptor: Device
    #define GD_CONFIGURATION 0x02 // Get device descriptor: Configuration
    #define GD_STRING 0x03 // Get device descriptor: String
    #define GD_REPORT 0x22 // Get descriptor: Report
    #define CS_INTERFACE 0x24 // Get descriptor: Interface
    #define CS_ENDPOINT 0x25 // Get descriptor: Endpoint

    // SETUP packet offsets
    #define bmRequestType 0
    #define bRequest 1
    #define wValueL 2
    #define wValueH 3
    #define wIndexL 4
    #define wIndexH 5
    #define wLengthL 6
    #define wLengthH 7

    // CDC bRequest values
    #define SEND_ENCAPSULATED_COMMAND 0x00
    #define GET_ENCAPSULATED_RESPONSE 0x01
    #define SET_COMM_FEATURE 0x02
    #define GET_COMM_FEATURE 0x03
    #define CLEAR_COMM_FEATURE 0x04
    #define SET_LINE_CODING 0x20
    #define GET_LINE_CODING 0x21
    #define SET_CONTROL_LINE_STATE 0x22
    #define SEND_BREAK 0x23

    #endif /* MAX3420E_H_ */

    //***************************************************************************
    //***************************************************************************



    ---------------------------------------
    Posted through http://www.EmbeddedRelated.com
    igelegin, Jul 19, 2012
    #1
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. dch
    Replies:
    5
    Views:
    348
    Ulf Samuelsson
    Feb 4, 2005
  2. Jung-Woo Park
    Replies:
    0
    Views:
    295
    Jung-Woo Park
    Jun 28, 2005
  3. Mingyi
    Replies:
    2
    Views:
    268
    Mingyi
    Feb 2, 2006
  4. MeNotHome
    Replies:
    6
    Views:
    398
  5. Hannes Schachtner
    Replies:
    0
    Views:
    422
    Hannes Schachtner
    Aug 23, 2004
Loading...

Share This Page