new maxusb library
[goodfet] / client / GoodFETMAXUSB.py
1 #!/usr/bin/env python
2 # GoodFET Client Library for Maxim USB Chips.
3
4 # (C) 2012 Travis Goodspeed <travis at radiantmachines.com>
5 #
6 # This code is being rewritten and refactored.  You've been warned!
7
8
9 import sys, time, string, cStringIO, struct, glob, os;
10 import warnings
11
12 from GoodFET import GoodFET;
13
14 warnings.warn(
15 """This library will soon be deprecated in favor of the USB*.py libraries."""
16 )
17
18 #Handy registers.
19 rEP0FIFO=0
20 rEP1OUTFIFO=1
21 rEP2INFIFO=2
22 rEP3INFIFO=3
23 rSUDFIFO=4
24 rEP0BC=5
25 rEP1OUTBC=6
26 rEP2INBC=7
27 rEP3INBC=8
28 rEPSTALLS=9
29 rCLRTOGS=10
30 rEPIRQ=11
31 rEPIEN=12
32 rUSBIRQ=13
33 rUSBIEN=14
34 rUSBCTL=15
35 rCPUCTL=16
36 rPINCTL=17
37 rREVISION=18
38 rFNADDR=19
39 rIOPINS=20
40 rIOPINS1=20  #Same as rIOPINS
41 rIOPINS2=21
42 rHIRQ=25
43 rHIEN=26
44 rMODE=27
45 rPERADDR=28
46 rHCTL=29
47 rHXFR=30
48 rHRSL=31
49
50 #Host mode registers.
51 rRCVFIFO =1
52 rSNDFIFO =2
53 rRCVBC   =6
54 rSNDBC   =7
55 rHIRQ    =25
56
57
58 # R11 EPIRQ register bits
59 bmSUDAVIRQ =0x20
60 bmIN3BAVIRQ =0x10
61 bmIN2BAVIRQ =0x08
62 bmOUT1DAVIRQ= 0x04
63 bmOUT0DAVIRQ= 0x02
64 bmIN0BAVIRQ =0x01
65
66 # R12 EPIEN register bits
67 bmSUDAVIE   =0x20
68 bmIN3BAVIE  =0x10
69 bmIN2BAVIE  =0x08
70 bmOUT1DAVIE =0x04
71 bmOUT0DAVIE =0x02
72 bmIN0BAVIE  =0x01
73
74
75
76
77 # ************************
78 # Standard USB Requests
79 SR_GET_STATUS           =0x00   # Get Status
80 SR_CLEAR_FEATURE        =0x01   # Clear Feature
81 SR_RESERVED             =0x02   # Reserved
82 SR_SET_FEATURE          =0x03   # Set Feature
83 SR_SET_ADDRESS          =0x05   # Set Address
84 SR_GET_DESCRIPTOR       =0x06   # Get Descriptor
85 SR_SET_DESCRIPTOR       =0x07   # Set Descriptor
86 SR_GET_CONFIGURATION    =0x08   # Get Configuration
87 SR_SET_CONFIGURATION    =0x09   # Set Configuration
88 SR_GET_INTERFACE        =0x0a   # Get Interface
89 SR_SET_INTERFACE        =0x0b   # Set Interface
90
91 # Get Descriptor codes  
92 GD_DEVICE               =0x01   # Get device descriptor: Device
93 GD_CONFIGURATION        =0x02   # Get device descriptor: Configuration
94 GD_STRING               =0x03   # Get device descriptor: String
95 GD_HID                  =0x21   # Get descriptor: HID
96 GD_REPORT               =0x22   # Get descriptor: Report
97
98 # SETUP packet header offsets
99 bmRequestType           =0
100 bRequest                =1
101 wValueL                 =2
102 wValueH                 =3
103 wIndexL                 =4
104 wIndexH                 =5
105 wLengthL                =6
106 wLengthH                =7
107
108 # HID bRequest values
109 GET_REPORT              =1
110 GET_IDLE                =2
111 GET_PROTOCOL            =3
112 SET_REPORT              =9
113 SET_IDLE                =0x0A
114 SET_PROTOCOL            =0x0B
115 INPUT_REPORT            =1
116
117 # PINCTL bits
118 bmEP3INAK   =0x80
119 bmEP2INAK   =0x40
120 bmEP1INAK   =0x20
121 bmFDUPSPI   =0x10
122 bmINTLEVEL  =0x08
123 bmPOSINT    =0x04
124 bmGPXB      =0x02
125 bmGPXA      =0x01
126
127 # rUSBCTL bits
128 bmHOSCSTEN  =0x80
129 bmVBGATE    =0x40
130 bmCHIPRES   =0x20
131 bmPWRDOWN   =0x10
132 bmCONNECT   =0x08
133 bmSIGRWU    =0x04
134
135 # USBIRQ bits
136 bmURESDNIRQ =0x80
137 bmVBUSIRQ   =0x40
138 bmNOVBUSIRQ =0x20
139 bmSUSPIRQ   =0x10
140 bmURESIRQ   =0x08
141 bmBUSACTIRQ =0x04
142 bmRWUDNIRQ  =0x02
143 bmOSCOKIRQ  =0x01
144
145 # MODE bits
146 bmHOST          =0x01
147 bmLOWSPEED      =0x02
148 bmHUBPRE        =0x04
149 bmSOFKAENAB     =0x08
150 bmSEPIRQ        =0x10
151 bmDELAYISO      =0x20
152 bmDMPULLDN      =0x40
153 bmDPPULLDN      =0x80
154
155 # PERADDR/HCTL bits
156 bmBUSRST        =0x01
157 bmFRMRST        =0x02
158 bmSAMPLEBUS     =0x04
159 bmSIGRSM        =0x08
160 bmRCVTOG0       =0x10
161 bmRCVTOG1       =0x20
162 bmSNDTOG0       =0x40
163 bmSNDTOG1       =0x80
164
165 # rHXFR bits
166 # Host XFR token values for writing the HXFR register (R30).
167 # OR this bit field with the endpoint number in bits 3:0
168 tokSETUP  =0x10  # HS=0, ISO=0, OUTNIN=0, SETUP=1
169 tokIN     =0x00  # HS=0, ISO=0, OUTNIN=0, SETUP=0
170 tokOUT    =0x20  # HS=0, ISO=0, OUTNIN=1, SETUP=0
171 tokINHS   =0x80  # HS=1, ISO=0, OUTNIN=0, SETUP=0
172 tokOUTHS  =0xA0  # HS=1, ISO=0, OUTNIN=1, SETUP=0 
173 tokISOIN  =0x40  # HS=0, ISO=1, OUTNIN=0, SETUP=0
174 tokISOOUT =0x60  # HS=0, ISO=1, OUTNIN=1, SETUP=0
175
176 # rRSL bits
177 bmRCVTOGRD   =0x10
178 bmSNDTOGRD   =0x20
179 bmKSTATUS    =0x40
180 bmJSTATUS    =0x80
181 # Host error result codes, the 4 LSB's in the HRSL register.
182 hrSUCCESS   =0x00
183 hrBUSY      =0x01
184 hrBADREQ    =0x02
185 hrUNDEF     =0x03
186 hrNAK       =0x04
187 hrSTALL     =0x05
188 hrTOGERR    =0x06
189 hrWRONGPID  =0x07
190 hrBADBC     =0x08
191 hrPIDERR    =0x09
192 hrPKTERR    =0x0A
193 hrCRCERR    =0x0B
194 hrKERR      =0x0C
195 hrJERR      =0x0D
196 hrTIMEOUT   =0x0E
197 hrBABBLE    =0x0F
198
199 # HIRQ bits
200 bmBUSEVENTIRQ   =0x01   # indicates BUS Reset Done or BUS Resume     
201 bmRWUIRQ        =0x02
202 bmRCVDAVIRQ     =0x04
203 bmSNDBAVIRQ     =0x08
204 bmSUSDNIRQ      =0x10
205 bmCONDETIRQ     =0x20
206 bmFRAMEIRQ      =0x40
207 bmHXFRDNIRQ     =0x80
208
209 class GoodFETMAXUSB(GoodFET):
210     MAXUSBAPP=0x40;
211     usbverbose=False;
212     
213     def service_irqs(self):
214         """Handle USB interrupt events."""
215         epirq=self.rreg(rEPIRQ);
216         usbirq=self.rreg(rUSBIRQ);
217         
218         
219         #Are we being asked for setup data?
220         if(epirq&bmSUDAVIRQ): #Setup Data Requested
221             self.wreg(rEPIRQ,bmSUDAVIRQ); #Clear the bit
222             self.do_SETUP();
223         if(epirq&bmOUT1DAVIRQ): #OUT1-OUT packet
224             self.do_OUT1();
225             self.wreg(rEPIRQ,bmOUT1DAVIRQ); #Clear the bit *AFTER* servicing.
226         if(epirq&bmIN3BAVIRQ): #IN3-IN packet
227             self.do_IN3();
228             #self.wreg(rEPIRQ,bmIN3BAVIRQ); #Clear the bit
229         if(epirq&bmIN2BAVIRQ): #IN2 packet
230             self.do_IN2();
231             #self.wreg(rEPIRQ,bmIN2BAVIRQ); #Clear the bit
232         #else:
233         #    print "No idea how to service this IRQ: %02x" % epirq;
234     def do_IN2(self):
235         """Overload this."""
236     def do_IN3(self):
237         """Overload this."""
238     def do_OUT1(self):
239         """Overload this."""
240         if self.usbverbose: print "Ignoring an OUT1 interrupt.";
241     def setup2str(self,SUD):
242         """Converts the header of a setup packet to a string."""
243         return "bmRequestType=0x%02x, bRequest=0x%02x, wValue=0x%04x, wIndex=0x%04x, wLength=0x%04x" % (
244                 ord(SUD[0]), ord(SUD[1]),
245                 ord(SUD[2])+(ord(SUD[3])<<8),
246                 ord(SUD[4])+(ord(SUD[5])<<8),
247                 ord(SUD[6])+(ord(SUD[7])<<8)
248                 );
249     
250     def MAXUSBsetup(self):
251         """Move the FET into the MAXUSB application."""
252         self.writecmd(self.MAXUSBAPP,0x10,0,self.data); #MAXUSB/SETUP
253         self.writecmd(self.MAXUSBAPP,0x10,0,self.data); #MAXUSB/SETUP
254         self.writecmd(self.MAXUSBAPP,0x10,0,self.data); #MAXUSB/SETUP
255         print "Connected to MAX342x Rev. %x" % (self.rreg(rREVISION));
256         self.wreg(rPINCTL,0x18); #Set duplex and negative INT level.
257         
258     def MAXUSBtrans8(self,byte):
259         """Read and write 8 bits by MAXUSB."""
260         data=self.MAXUSBtrans([byte]);
261         return ord(data[0]);
262     
263     def MAXUSBtrans(self,data):
264         """Exchange data by MAXUSB."""
265         self.data=data;
266         self.writecmd(self.MAXUSBAPP,0x00,len(data),data);
267         return self.data;
268
269     def rreg(self,reg):
270         """Peek 8 bits from a register."""
271         data=[reg<<3,0];
272         self.writecmd(self.MAXUSBAPP,0x00,len(data),data);
273         return ord(self.data[1]);
274     def rregAS(self,reg):
275         """Peek 8 bits from a register, setting AS."""
276         data=[(reg<<3)|1,0];
277         self.writecmd(self.MAXUSBAPP,0x00,len(data),data);
278         return ord(self.data[1]);
279     def wreg(self,reg,value):
280         """Poke 8 bits into a register."""
281         data=[(reg<<3)|2,value];
282         self.writecmd(self.MAXUSBAPP,0x00,len(data),data);        
283         return value;
284     def wregAS(self,reg,value):
285         """Poke 8 bits into a register, setting AS."""
286         data=[(reg<<3)|3,value];
287         self.writecmd(self.MAXUSBAPP,0x00,len(data),data);        
288         return value;
289     def readbytes(self,reg,length):
290         """Peek some bytes from a register."""
291         data=[(reg<<3)]+range(0,length);
292         self.writecmd(self.MAXUSBAPP,0x00,len(data),data);
293         toret=self.data[1:len(self.data)];
294         ashex="";
295         for foo in toret:
296             ashex=ashex+(" %02x"%ord(foo));
297         if self.usbverbose: print "GET   %02x==%s" % (reg,ashex);
298         return toret;
299     def readbytesAS(self,reg,length):
300         """Peek some bytes from a register, acking prior transfer."""
301         data=[(reg<<3)|1]+range(0,length);
302         self.writecmd(self.MAXUSBAPP,0x00,len(data),data);
303         toret=self.data[1:len(self.data)];
304         ashex="";
305         for foo in toret:
306             ashex=ashex+(" %02x"%ord(foo));
307         if self.usbverbose: print "GETAS %02x==%s" % (reg,ashex);
308         return toret;
309     def fifo_ep3in_tx(self,data):
310         """Sends the data out of EP3 in 64-byte chunks."""
311         #Wait for the buffer to be free before starting.
312         while not(self.rreg(rEPIRQ)&bmIN3BAVIRQ): pass;
313         
314         count=len(data);
315         pos=0;
316         while count>0:
317             #Send 64-byte chunks or the remainder.
318             c=min(count,64);
319             self.writebytes(rEP3INFIFO,
320                             data[pos:pos+c]);
321             self.wregAS(rEP3INBC,c);
322             count=count-c;
323             pos=pos+c;
324             
325             #Wait for the buffer to be free before continuing.
326             while not(self.rreg(rEPIRQ)&bmIN3BAVIRQ): pass;
327             
328         return;
329         
330     def ctl_write_nd(self,request):
331         """Control Write with no data stage.  Assumes PERADDR is set
332         and the SUDFIFO contains the 8 setup bytes.  Returns with
333         result code = HRSLT[3:0] (HRSL register).  If there is an
334         error, the 4MSBits of the returned value indicate the stage 1
335         or 2."""
336         
337         # 1. Send the SETUP token and 8 setup bytes. 
338         # Should ACK immediately.
339         self.writebytes(rSUDFIFO,request);
340         resultcode=self.send_packet(tokSETUP,0); #SETUP packet to EP0.
341         if resultcode: return resultcode;
342         
343         # 2. No data stage, so the last operation is to send an IN
344         # token to the peripheral as the STATUS (handhsake) stage of
345         # this control transfer.  We should get NAK or the DATA1 PID.
346         # When we get back to the DATA1 PID the 3421 automatically
347         # sends the closing NAK.
348         resultcode=self.send_packet(tokINHS,0); #Function takes care of retries.
349         if resultcode: return resultcode;
350         
351         return 0;
352         
353         
354     def ctl_read(self,request):
355         """Control read transfer, used in Host mode."""
356         resultcode=0;
357         bytes_to_read=request[6]+256*request[7];
358         
359         ##SETUP packet
360         self.writebytes(rSUDFIFO,request);     #Load the FIFO
361         resultcode=self.send_packet(tokSETUP,0); #SETUP packet to EP0
362         if resultcode:
363             print "Failed to get ACK on SETUP request in ctl_read()."
364             return resultcode;
365         
366         self.wreg(rHCTL,bmRCVTOG1);              #FIRST data packet in CTL transfer uses DATA1 toggle.
367         resultcode=self.IN_Transfer(0,bytes_to_read);
368         if resultcode:
369             print "Failed on IN Transfer in ctl_read()";
370             return resultcode;
371         
372         self.IN_nak_count=self.nak_count;
373         
374         #The OUT status stage.
375         resultcode=self.send_packet(tokOUTHS,0);
376         if resultcode:
377             print "Failed on OUT Status stage in ctl_read()";
378             return resultcode;
379         
380         return 0; #Success
381     
382     xfrdata=[]; #Ugly variable used only by a few functions.  FIXME
383     def IN_Transfer(self,endpoint,INbytes):
384         """Does an IN transfer to an endpoint, used for Host mode."""
385         xfrsize=INbytes;
386         xfrlen=0;
387         self.xfrdata=[];
388         
389         while 1:
390             resultcode=self.send_packet(tokIN,endpoint); #IN packet to EP. NAKS taken care of.
391             if resultcode: return resultcode;
392             
393             pktsize=self.rreg(rRCVBC); #Numer of RXed bytes.
394             
395             #Very innefficient, move this to C if performance is needed.
396             for j in range(0,pktsize):
397                 self.xfrdata=self.xfrdata+[self.rreg(rRCVFIFO)];
398             xfrsize=self.xfrdata[0];
399             self.wreg(rHIRQ,bmRCVDAVIRQ); #Clear IRQ
400             xfrlen=xfrlen+pktsize; #Add byte count to total transfer length.
401             
402             #print "%i / %i" % (xfrlen,xfrsize)
403             
404             #Packet is complete if:
405             # 1. The device sent a short packet, <maxPacketSize
406             # 2. INbytes have been transfered.
407             if (pktsize<self.maxPacketSize) or (xfrlen>=xfrsize):
408                 self.last_transfer_size=xfrlen;
409                 ashex="";
410                 for foo in self.xfrdata:
411                     ashex=ashex+(" %02x"%foo);
412                 #print "INPACKET EP%i==%s (0x%02x bytes remain)" % (endpoint,ashex,xfrsize);
413                 return resultcode;
414
415     RETRY_LIMIT=3;
416     NAK_LIMIT=300;
417     def send_packet(self,token,endpoint):
418         """Send a packet to an endpoint as the Host, taking care of NAKs.
419         Don't use this for device code."""
420         self.retry_count=0;
421         self.nak_count=0;
422         
423         #Repeat until NAK_LIMIT or RETRY_LIMIT is reached.
424         while self.nak_count<self.NAK_LIMIT and self.retry_count<self.RETRY_LIMIT:
425             self.wreg(rHXFR,(token|endpoint)); #launch the transfer
426             while not (self.rreg(rHIRQ) & bmHXFRDNIRQ):
427                 # wait for the completion IRQ
428                 pass;
429             self.wreg(rHIRQ,bmHXFRDNIRQ);           #Clear IRQ
430             resultcode = (self.rreg(rHRSL) & 0x0F); # get the result
431             if (resultcode==hrNAK):
432                 self.nak_count=self.nak_count+1;
433             elif (resultcode==hrTIMEOUT):
434                 self.retry_count=self.retry_count+1;
435             else:
436                 #Success!
437                 return resultcode;
438         return resultcode;
439             
440     def writebytes(self,reg,tosend):
441         """Poke some bytes into a register."""
442         data="";
443         if type(tosend)==str:
444             data=chr((reg<<3)|3)+tosend;
445             if self.usbverbose: print "PUT %02x:=%s (0x%02x bytes)" % (reg,tosend,len(data))
446         else:
447             data=[(reg<<3)|3]+tosend;
448             ashex="";
449             for foo in tosend:
450                 ashex=ashex+(" %02x"%foo);
451             if self.usbverbose: print "PUT %02x:=%s (0x%02x bytes)" % (reg,ashex,len(data))
452         self.writecmd(self.MAXUSBAPP,0x00,len(data),data);
453     def usb_connect(self):
454         """Connect the USB port."""
455         
456         #disconnect D+ pullup if host turns off VBUS
457         self.wreg(rUSBCTL,bmVBGATE|bmCONNECT);
458     def usb_disconnect(self):
459         """Disconnect the USB port."""
460         self.wreg(rUSBCTL,bmVBGATE);
461     def STALL_EP0(self,SUD=None):
462         """Stall for an unknown SETUP event."""
463         if SUD==None:
464             print "Stalling EP0.";
465         else:
466             print "Stalling EPO for %s" % self.setup2str(SUD);
467         self.wreg(rEPSTALLS,0x23); #All three stall bits.
468     def SETBIT(self,reg,val):
469         """Set a bit in a register."""
470         self.wreg(reg,self.rreg(reg)|val);
471     def vbus_on(self):
472         """Turn on the target device."""
473         self.wreg(rIOPINS2,(self.rreg(rIOPINS2)|0x08));
474     def vbus_off(self):
475         """Turn off the target device's power."""
476         self.wreg(rIOPINS2,0x00);
477     def reset_host(self):
478         """Resets the chip into host mode."""
479         self.wreg(rUSBCTL,bmCHIPRES); #Stop the oscillator.
480         self.wreg(rUSBCTL,0x00);      #restart it.
481         
482         #FIXME: Why does the OSC line never settle?
483         #Code works without it.
484         
485         #print "Waiting for PLL to sabilize.";
486         #while self.rreg(rUSBIRQ)&bmOSCOKIRQ:
487         #    #Hang until the PLL stabilizes.
488         #    pass;
489         #print "Stable.";
490
491 class GoodFETMAXUSBHost(GoodFETMAXUSB):
492     """This is a class for implemented a minimal USB host.
493     It's intended for fuzzing, rather than for daily use."""
494     def hostinit(self):
495         """Initialize the MAX3421 as a USB Host."""
496         self.usb_connect();
497         print "Enabling host mode.";
498         self.wreg(rPINCTL,(bmFDUPSPI|bmPOSINT));
499         print "Resetting host.";
500         self.reset_host();
501         self.vbus_off();
502         time.sleep(0.2);
503         print "Powering host.";
504         self.vbus_on();
505         
506         #self.hostrun();
507     def hostrun(self):
508         """Run as a minimal host and dump the config tables."""
509         while 1:
510             self.detect_device();
511             time.sleep(0.2);
512             self.enumerate_device();
513             self.wait_for_disconnect();
514     def detect_device(self):
515         """Waits for a device to be inserted and then returns."""
516         busstate=0;
517         
518         #Activate host mode and turn on 15K pulldown resistors on D+ and D-.
519         self.wreg(rMODE,(bmDPPULLDN|bmDMPULLDN|bmHOST));
520         #Clear connection detect IRQ.
521         self.wreg(rHIRQ,bmCONDETIRQ);
522         
523         print "Waiting for a device connection.";
524         while busstate==0:
525             self.wreg(rHCTL,bmSAMPLEBUS); #Update JSTATUS and KSTATUS bits.
526             busstate=self.rreg(rHRSL) & (bmJSTATUS|bmKSTATUS);
527             
528         if busstate==bmJSTATUS:
529             print "Detected Full-Speed Device.";
530             self.wreg(rMODE,(bmDPPULLDN|bmDMPULLDN|bmHOST|bmSOFKAENAB));
531         elif busstate==bmKSTATUS:
532             print "Detected Low-Speed Device.";
533             self.wreg(rMODE,(bmDPPULLDN|bmDMPULLDN|bmHOST|bmLOWSPEED|bmSOFKAENAB));
534         else:
535             print "Not sure whether this is Full-Speed or Low-Speed.  Please investigate.";
536     def wait_for_disconnect(self):
537         """Wait for a device to be disconnected."""
538         print "Waiting for a device disconnect.";
539         
540         self.wreg(rHIRQ,bmCONDETIRQ); #Clear disconnect IRQ
541         while not (self.rreg(rHIRQ) & bmCONDETIRQ):
542             #Wait for IRQ to change.
543             pass;
544         
545         #Turn off markers.
546         self.wreg(rMODE,bmDPPULLDN|bmDMPULLDN|bmHOST);
547         print "Device disconnected.";
548         self.wreg(rIOPINS2,(self.rreg(rIOPINS2) & ~0x04)); #HL1_OFF
549         self.wreg(rIOPINS1,(self.rreg(rIOPINS1) & ~0x02)); #HL4_OFF
550
551     def enumerate_device(self):
552         """Enumerates a device on the present port."""
553         
554         Set_Address_to_7 = [0x00,0x05,0x07,0x00,0x00,0x00,0x00,0x00];
555         Get_Descriptor_Device = [0x80,0x06,0x00,0x01,0x00,0x00,0x00,0x00]; #len filled in
556         Get_Descriptor_Config = [0x80,0x06,0x00,0x02,0x00,0x00,0x00,0x00];
557         
558         
559         print "Issuing USB bus reset.";
560         self.wreg(rHCTL,bmBUSRST);
561         while self.rreg(rHCTL) & bmBUSRST:
562             #Wait for reset to complete.
563             pass;
564         
565         time.sleep(0.2);
566         
567         #Get the device descriptor.
568         self.wreg(rPERADDR,0); #First request to address 0.
569         self.maxPacketSize=8; #Only safe value for first check.
570         Get_Descriptor_Device[6]=8; # wLengthL
571         Get_Descriptor_Device[7]=0; # wLengthH
572         
573         print "Fetching 8 bytes of Device Descriptor.";
574         self.ctl_read(Get_Descriptor_Device); # Get device descriptor into self.xfrdata;
575         self.maxPacketSize=self.xfrdata[7];
576         print "EP0 maxPacketSize is %02i bytes." % self.maxPacketSize;
577         
578         # Issue another USB bus reset
579         print "Resetting the bus again."
580         self.wreg(rHCTL,bmBUSRST);
581         while self.rreg(rHCTL) & bmBUSRST:
582             #Wait for reset to complete.
583             pass;
584         time.sleep(0.2);
585         
586         # Set_Address to 7 (Note: this request goes to address 0, already set in PERADDR register).
587         print "Setting address to 0x07";
588         HR = self.ctl_write_nd(Set_Address_to_7);   # CTL-Write, no data stage
589         #if(print_error(HR)) return;
590         
591         time.sleep(0.002);           # Device gets 2 msec recovery time
592         self.wreg(rPERADDR,7);       # now all transfers go to addr 7
593         
594         
595         #Get the device descriptor at the assigned address.
596         Get_Descriptor_Device[6]=0x12; #Fill in real descriptor length.
597         print "Fetching Device Descriptor."
598         self.ctl_read(Get_Descriptor_Device); #Result in self.xfrdata;
599         
600         self.descriptor=self.xfrdata;
601         self.VID        = self.xfrdata[8] + 256*self.xfrdata[9];
602         self.PID        = self.xfrdata[10]+ 256*self.xfrdata[11];
603         iMFG    = self.xfrdata[14];
604         iPROD   = self.xfrdata[15];
605         iSERIAL = self.xfrdata[16];
606         
607         self.manufacturer=self.getDescriptorString(iMFG);
608         self.product=self.getDescriptorString(iPROD);
609         self.serial=self.getDescriptorString(iSERIAL);
610         
611         self.printstrings();
612         
613     def printstrings(self):
614         print "Vendor  ID is %04x." % self.VID;
615         print "Product ID is %04x." % self.PID;
616         print "Manufacturer: %s" % self.manufacturer;
617         print "Product:      %s" % self.product;
618         print "Serial:       %s" % self.serial;
619         
620     def getDescriptorString(self, index):
621         """Grabs a string from the descriptor string table."""
622         # Get_Descriptor-String template. Code fills in idx at str[2].
623         Get_Descriptor_String = [0x80,0x06,index,0x03,0x00,0x00,0x40,0x00];
624         
625         if index==0: return "MISSING STRING";
626         
627         status=self.ctl_read(Get_Descriptor_String);
628         if status: return None;
629         
630         #Since we've got a string
631         toret="";
632         for c in self.xfrdata[2:len(self.xfrdata)]:
633             if c>0: toret=toret+chr(c);
634         return toret;
635 class GoodFETMAXUSBDevice(GoodFETMAXUSB):
636     
637     def send_descriptor(self,SUD):
638         """Send the USB descriptors based upon the setup data."""
639         desclen=0;
640         reqlen=ord(SUD[wLengthL])+256*ord(SUD[wLengthH]); #16-bit length
641         desctype=ord(SUD[wValueH]);
642         
643         if desctype==GD_DEVICE:
644             desclen=self.DD[0];
645             ddata=self.DD;
646         elif desctype==GD_CONFIGURATION:
647             desclen=self.CD[2];
648             ddata=self.CD;
649         elif desctype==GD_STRING:
650             desclen=ord(self.strDesc[ord(SUD[wValueL])][0]);
651             ddata=self.strDesc[ord(SUD[wValueL])];
652         elif desctype==GD_HID:
653             #Don't know how to do this yet.
654             pass;
655         elif desctype==GD_REPORT:
656             desclen=self.CD[25];
657             ddata=self.RepD;
658         #TODO Configuration, String, Hid, and Report
659         
660         if desclen>0:
661             #Reduce desclen if asked for fewer bytes.
662             desclen=min(reqlen,desclen);
663             #Send those bytes.
664             self.writebytes(rEP0FIFO,ddata[0:desclen]);
665             self.wregAS(rEP0BC,desclen);
666         else:
667             print "Stalling in send_descriptor() for lack of handler for %02x." % desctype;
668             self.STALL_EP0(SUD);
669     def set_configuration(self,SUD):
670         """Set the configuration."""
671         bmSUSPIE=0x10;
672         configval=ord(SUD[wValueL]);
673         if(configval>0):
674             self.SETBIT(rUSBIEN,bmSUSPIE);
675         self.rregAS(rFNADDR);
676 class GoodFETMAXUSBHID(GoodFETMAXUSBDevice):
677     """This is an example HID keyboard driver, loosely based on the
678     MAX3420 examples."""
679     def hidinit(self):
680         """Initialize a USB HID device."""
681         self.usb_disconnect();
682         self.usb_connect();
683         
684         self.hidrun();
685         
686     def hidrun(self):
687         """Main loop of the USB HID emulator."""
688         print "Starting a HID device.  This won't return.";
689         while 1:
690             self.service_irqs();
691     def do_SETUP(self):
692         """Handle USB Enumeration"""
693         
694         #Grab the SETUP packet from the buffer.
695         SUD=self.readbytes(rSUDFIFO,8);
696         
697         #Parse the SETUP packet
698         print "Handling a setup packet of %s" % self.setup2str(SUD);
699         
700         self.OsLastConfigType=ord(SUD[bmRequestType]);
701         self.typepos=0;
702         setuptype=(ord(SUD[bmRequestType])&0x60);
703         if setuptype==0x00:
704             self.std_request(SUD);
705         elif setuptype==0x20:
706             self.class_request(SUD);
707         elif setuptype==0x40:
708             self.vendor_request(SUD);
709         else:
710             print "Unknown request type 0x%02x." % ord(SUD[bmRequestType])
711             self.STALL_EP0(SUD);
712     def class_request(self,SUD):
713         """Handle a class request."""
714         print "Stalling a class request.";
715         self.STALL_EP0(SUD);
716     def vendor_request(self,SUD):
717         print "Stalling a vendor request.";
718         self.STALL_EP0(SUD);
719     def std_request(self,SUD):
720         """Handles a standard setup request."""
721         setuptype=ord(SUD[bRequest]);
722         if setuptype==SR_GET_DESCRIPTOR: self.send_descriptor(SUD);
723         #elif setuptype==SR_SET_FEATURE:
724         #    self.rregAS(rFNADDR);
725         #    # self.feature(1);
726         elif setuptype==SR_SET_CONFIGURATION: self.set_configuration(SUD);
727         elif setuptype==SR_GET_STATUS: self.get_status(SUD);
728         elif setuptype==SR_SET_ADDRESS: self.rregAS(rFNADDR);
729         elif setuptype==SR_GET_INTERFACE: self.get_interface(SUD);
730         else:
731             print "Stalling Unknown standard setup request type %02x" % setuptype;
732             self.STALL_EP0(SUD);
733     
734     def get_interface(self,SUD):
735         """Handles a setup request for SR_GET_INTERFACE."""
736         if ord(SUD[wIndexL]==0):
737             self.wreg(rEP0FIFO,0);
738             self.wregAS(rEP0BC,1);
739         else:
740             self.STALL_EP0(SUD);
741     
742     OsLastConfigType=-1;
743 #Device Descriptor
744     DD=[0x12,                   # bLength = 18d
745         0x01,                   # bDescriptorType = Device (1)
746         0x00,0x01,              # bcdUSB(L/H) USB spec rev (BCD)
747         0x00,0x00,0x00,         # bDeviceClass, bDeviceSubClass, bDeviceProtocol
748         0x40,                   # bMaxPacketSize0 EP0 is 64 bytes
749         0x6A,0x0B,              # idVendor(L/H)--Maxim is 0B6A
750         0x46,0x53,              # idProduct(L/H)--5346
751         0x34,0x12,              # bcdDevice--1234
752         1,2,3,                  # iManufacturer, iProduct, iSerialNumber
753         1];
754 #Configuration Descriptor
755     CD=[0x09,                   # bLength
756         0x02,                   # bDescriptorType = Config
757         0x22,0x00,              # wTotalLength(L/H) = 34 bytes
758         0x01,                   # bNumInterfaces
759         0x01,                   # bConfigValue
760         0x00,                   # iConfiguration
761         0xE0,                   # bmAttributes. b7=1 b6=self-powered b5=RWU supported
762         0x01,                   # MaxPower is 2 ma
763 # INTERFACE Descriptor
764         0x09,                   # length = 9
765         0x04,                   # type = IF
766         0x00,                   # IF #0
767         0x00,                   # bAlternate Setting
768         0x01,                   # bNum Endpoints
769         0x03,                   # bInterfaceClass = HID
770         0x00,0x00,              # bInterfaceSubClass, bInterfaceProtocol
771         0x00,                   # iInterface
772 # HID Descriptor--It's at CD[18]
773         0x09,                   # bLength
774         0x21,                   # bDescriptorType = HID
775         0x10,0x01,              # bcdHID(L/H) Rev 1.1
776         0x00,                   # bCountryCode (none)
777         0x01,                   # bNumDescriptors (one report descriptor)
778         0x22,                   # bDescriptorType       (report)
779         43,0,                   # CD[25]: wDescriptorLength(L/H) (report descriptor size is 43 bytes)
780 # Endpoint Descriptor
781         0x07,                   # bLength
782         0x05,                   # bDescriptorType (Endpoint)
783         0x83,                   # bEndpointAddress (EP3-IN)             
784         0x03,                   # bmAttributes  (interrupt)
785         64,0,                   # wMaxPacketSize (64)
786         10];
787     strDesc=[
788 # STRING descriptor 0--Language string
789 "\x04\x03\x09\x04",
790 # [
791 #         0x04,                 # bLength
792 #       0x03,                   # bDescriptorType = string
793 #       0x09,0x04               # wLANGID(L/H) = English-United Sates
794 # ],
795 # STRING descriptor 1--Manufacturer ID
796 "\x0c\x03M\x00a\x00x\x00i\x00m\x00",
797 # [
798 #         12,                   # bLength
799 #       0x03,                   # bDescriptorType = string
800 #       'M',0,'a',0,'x',0,'i',0,'m',0 # text in Unicode
801 # ], 
802 # STRING descriptor 2 - Product ID
803 "\x18\x03M\x00A\x00X\x003\x004\x002\x000\x00E\x00 \x00E\x00n\x00u\x00m\x00 \x00C\x00o\x00d\x00e\x00",
804 # [     24,                     # bLength
805 #       0x03,                   # bDescriptorType = string
806 #       'M',0,'A',0,'X',0,'3',0,'4',0,'2',0,'0',0,'E',0,' ',0,
807 #         'E',0,'n',0,'u',0,'m',0,' ',0,'C',0,'o',0,'d',0,'e',0
808 # ],
809
810
811 # STRING descriptor 3 - Serial Number ID
812 "\x14\x03S\x00/\x00N\x00 \x003\x004\x002\x000\x00E\x00"
813 # [       20,                   # bLength
814 #       0x03,                   # bDescriptorType = string
815 #       'S',0,                          
816 #       '/',0,
817 #       'N',0,
818 #       ' ',0,
819 #       '3',0,
820 #       '4',0,
821 #       '2',0,
822 #       '0',0,
823 #         'E',0,
824 # ]
825 ];
826     RepD=[
827         0x05,0x01,              # Usage Page (generic desktop)
828         0x09,0x06,              # Usage (keyboard)
829         0xA1,0x01,              # Collection
830         0x05,0x07,              #   Usage Page 7 (keyboard/keypad)
831         0x19,0xE0,              #   Usage Minimum = 224
832         0x29,0xE7,              #   Usage Maximum = 231
833         0x15,0x00,              #   Logical Minimum = 0
834         0x25,0x01,              #   Logical Maximum = 1
835         0x75,0x01,              #   Report Size = 1
836         0x95,0x08,              #   Report Count = 8
837         0x81,0x02,              #  Input(Data,Variable,Absolute)
838         0x95,0x01,              #   Report Count = 1
839         0x75,0x08,              #   Report Size = 8
840         0x81,0x01,              #  Input(Constant)
841         0x19,0x00,              #   Usage Minimum = 0
842         0x29,0x65,              #   Usage Maximum = 101
843         0x15,0x00,              #   Logical Minimum = 0,
844         0x25,0x65,              #   Logical Maximum = 101
845         0x75,0x08,              #   Report Size = 8
846         0x95,0x01,              #   Report Count = 1
847         0x81,0x00,              #  Input(Data,Variable,Array)
848         0xC0]
849
850     def get_status(self,SUD):
851         """Get the USB Setup Status."""
852         testbyte=ord(SUD[bmRequestType])
853         
854         #Toward Device
855         if testbyte==0x80:
856             self.wreg(rEP0FIFO,0x03); #Enable RWU and self-powered
857             self.wreg(rEP0FIFO,0x00); #Second byte is always zero.
858             self.wregAS(rEP0BC,2);    #Load byte count, arm transfer, and ack CTL.
859         #Toward Interface
860         elif testbyte==0x81:
861             self.wreg(rEP0FIFO,0x00);
862             self.wreg(rEP0FIFO,0x00); #Second byte is always zero.
863             self.wregAS(rEP0BC,2);
864         #Toward Endpoint
865         elif testbyte==0x82:
866             if(ord(SUD[wIndexL])==0x83):
867                 self.wreg(rEP0FIFO,0x01); #Stall EP3
868                 self.wreg(rEP0FIFO,0x00); #Second byte is always zero.
869                 self.wregAS(rEP0BC,2);
870             else:
871                 self.STALL_EP0(SUD);
872         else:
873             self.STALL_EP0(SUD);
874
875     typepos=0;
876     typestrings={
877         -1   : "Python does USB HID!\n",                # Unidentified OS.  This is the default typestring.
878         0x00 : "OSX Hosts don't recognize Maxim keyboards.\n",  # We have to identify as an Apple keyboard to get arround the unknown keyboard error.
879         0xA1 : "Python does USB HID on Linux!\n",
880         0x81 : "                                                                                             Python does USB HID on Windows!\n",        # Windows requires a bit of a delay.  Maybe we can watch for a keyboard reset command?
881     }
882     def typestring(self):
883         if self.typestrings.has_key(self.OsLastConfigType):
884             return self.typestrings[self.OsLastConfigType];
885         else:
886             return self.typestrings[-1];
887     # http://www.win.tue.nl/~aeb/linux/kbd/scancodes-14.html
888     # Escape=0x29 Backsp=0x2A Space=0x2C CapsLock=0x39 Menu=0x65
889     keymaps={
890         'en_US'  :[ '    abcdefghijklmnopqrstuvwxyz1234567890\n\e\7f\t -=[]\\\\;\'`,./',
891                     '''    \ 1\ 2\ 3\ 4\ 5\ 6\a\b  \v\f\r\ e\ f\10 \12 \14\15\16\17\18\19\1a''',        # LeftCtrl
892                     '    ABCDEFGHIJKLMNOPQRSTUVWXYZ!@#$%^&*()     {}?+||:"~<>?', # LeftShift
893                     '', # LeftCtrl & LeftShift
894                     '    \ea\eb\ec'], # LeftAlt
895         'Dvorak' :[ '    axje.uidchtnmbrl\'poygk,qf;1234567890\n\e\7f\t []/=\\\\s-`wvz',
896                     '''    \ 1\18 \ 5 \15 \ 4\ 3\b\14\ e\r\ 2\12\f \10\ f\19\a\v  \ 6                         \17\16\1a''',     # LeftCtrl
897                     '    AXJE UIDCHTNMBRL"POYGK<QF:!@#$%^&*()     {}?+||S_~WVZ', # LeftShift
898                     '', # LeftCtrl & LeftShift
899                     '    \ea\ex\ej'], # LeftAlt
900     }
901     layout='en_US';
902     def keymap(self):
903         return self.keymaps[self.layout];
904     modifiers={
905         'None':         0b00000000,
906         'LeftCtrl':     0b00000001,
907         'LeftShift':    0b00000010,
908         'LeftAlt':      0b00000100,
909         'LeftGUI':      0b00001000,
910         'RightCtrl':    0b00010000,
911         'RightShift':   0b00100000,
912         'RightAlt':     0b01000000,
913         'RightGUI':     0b10000000
914     }
915
916     def asc2hid(self,ascii):
917         """Translate ASCII to an USB keycode."""
918         if type(ascii)!=str:
919             return (0,0);               # Send NoEvent if not passed a character
920         if ascii==' ':
921             return (0,0x2C);            # space
922         for modset in self.keymap():
923             keycode=modset.find(ascii);
924             if keycode != -1:
925                 modifier = self.keymap().index(modset)
926                 return (modifier, keycode);
927         return (0,0);
928     def type_IN3(self):
929         """Type next letter in buffer."""
930         string=self.typestring();
931         if self.typepos>=len(string):
932             self.typeletter(0);         # Send NoEvent to indicate key-up
933             exit(0);
934             self.typepos=0;             # Repeat typestring forever!
935             # This would be a great place to enable a typethrough mode so the host operator can control the target
936         else:
937             if self.usbverbose:
938                 sys.stdout.write(string[self.typepos]);
939                 sys.stdout.flush();
940             self.typeletter(string[self.typepos]);
941             self.typepos+=1;
942         return;
943     def typeletter(self,key):
944         """Type a letter on IN3.  Zero for keyup."""
945         mod=0;
946         if type(key)==str:
947             (mod, key) = self.asc2hid(key);
948         self.wreg(rEP3INFIFO,mod);
949         self.wreg(rEP3INFIFO,0);
950         self.wreg(rEP3INFIFO,key);
951         self.wreg(rEP3INBC,3);
952     def do_IN3(self):
953         """Handle IN3 event."""
954         #Don't bother clearing interrupt flag, that's done by sending the reply.
955         if self.OsLastConfigType != -1: # Wait for some configuration before stuffing keycodes down the pipe
956             self.type_IN3();
957