Motherboard Forums


Reply
Thread Tools Display Modes

USB-Communication Device Class-Virtual Com Port

 
 
igelegin
Guest
Posts: n/a
 
      07-19-2012, 01:00 PM
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+bmIN 0BAVIE+bmOUT0DAVIE))
usb_write_config(rUSBIEN,(bmURESIE+bmURESDNIE+bmBU SACTIE));
#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[i]=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
 
Reply With Quote
 
 
 
Reply

Thread Tools
Display Modes

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
Need uC (ARM preferably) with USB device port, internal FLASH and USB device. dch Embedded 5 02-04-2005 07:41 PM
problem with LPT Device (none printing) on virtual usb parallel port via port replicator Hannes Schachtner Hardware 0 08-23-2004 11:57 AM
Device manager Unknown Device & PCI Device (yellow warning) Alora Duncan Intel 1 02-02-2004 05:52 PM
Latitude C/Port Advanced Port Replicator (C/Port APR) work with Inspiron 8200 Thomas M. Goethe Dell 0 01-28-2004 02:47 PM
Re: unknown device in device manager Alan Asus 1 07-31-2003 07:50 AM


All times are GMT. The time now is 02:42 PM.


Welcome!
Welcome to Motherboard Point
 

Advertisment