-
Notifications
You must be signed in to change notification settings - Fork 1
/
usb_device.c
2471 lines (2218 loc) · 97.2 KB
/
usb_device.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/** INCLUDES *******************************************************/
#include "usb.h"
#include "usb_device_local.h"
/** DEFINITIONS ****************************************************/
#define USB_BUS_SENSE 1
#define _DTS_CHECKING_ENABLED _DTSEN
#define BDT_NUM_ENTRIES ((USB_MAX_EP_NUMBER + 1) * 4)
/** VARIABLES ******************************************************/
USB_VOLATILE USB_DEVICE_STATE USBDeviceState;
USB_VOLATILE BYTE USBActiveConfiguration;
USB_VOLATILE BYTE USBAlternateInterface[USB_MAX_NUM_INT];
volatile BDT_ENTRY *pBDTEntryEP0OutCurrent;
volatile BDT_ENTRY *pBDTEntryEP0OutNext;
volatile BDT_ENTRY *pBDTEntryOut[USB_MAX_EP_NUMBER + 1];
volatile BDT_ENTRY *pBDTEntryIn[USB_MAX_EP_NUMBER + 1];
USB_VOLATILE BYTE shortPacketStatus;
USB_VOLATILE BYTE controlTransferState;
USB_VOLATILE IN_PIPE inPipes[1];
USB_VOLATILE OUT_PIPE outPipes[1];
USB_VOLATILE BYTE *pDst;
USB_VOLATILE BOOL RemoteWakeup;
USB_VOLATILE BOOL USBBusIsSuspended;
USB_VOLATILE USTAT_FIELDS USTATcopy;
USB_VOLATILE BYTE endpoint_number;
USB_VOLATILE BOOL BothEP0OutUOWNsSet;
USB_VOLATILE EP_STATUS ep_data_in[USB_MAX_EP_NUMBER + 1];
USB_VOLATILE EP_STATUS ep_data_out[USB_MAX_EP_NUMBER + 1];
USB_VOLATILE BYTE USBStatusStageTimeoutCounter;
volatile BOOL USBDeferStatusStagePacket;
volatile BOOL USBStatusStageEnabledFlag1;
volatile BOOL USBStatusStageEnabledFlag2;
volatile BOOL USBDeferINDataStagePackets;
volatile BOOL USBDeferOUTDataStagePackets;
volatile BDT_ENTRY BDT[BDT_NUM_ENTRIES] BDT_BASE_ADDR_TAG;
/********************************************************************
* Section B: EP0 Buffer Space
*******************************************************************/
volatile CTRL_TRF_SETUP SetupPkt CTRL_TRF_SETUP_ADDR_TAG;
volatile BYTE CtrlTrfData[USB_EP0_BUFF_SIZE] CTRL_TRF_DATA_ADDR_TAG;
//Device descriptor
extern ROM USB_DEVICE_DESCRIPTOR device_dsc;
//Microsoft OS descriptor
extern ROM BYTE ROM USB_SD_OS;
extern ROM BYTE ROM Ext_CID_OS_FD;
extern ROM BYTE ROM Ext_P_OS_FD;
//Array of configuration descriptors
extern ROM BYTE *ROM USB_CD_Ptr[];
extern ROM BYTE *ROM USB_SD_Ptr[];
extern volatile float voltage;
/** DECLARATIONS ***************************************************/
/** Macros *********************************************************/
/** Function Prototypes ********************************************/
//External
//This is the prototype for the required user event handler
BOOL USER_USB_CALLBACK_EVENT_HANDLER(USB_EVENT event, void *pdata, WORD size);
//Internal Functions
static void USBCtrlEPService(void);
static void USBCtrlTrfSetupHandler(void);
static void USBCtrlTrfInHandler(void);
static void USBCheckStdRequest(void);
static void USBStdGetDscHandler(void);
static void USBCtrlEPServiceComplete(void);
static void USBCtrlTrfTxService(void);
static void USBCtrlTrfRxService(void);
static void USBStdSetCfgHandler(void);
static void USBStdGetStatusHandler(void);
static void USBStdFeatureReqHandler(void);
static void USBCtrlTrfOutHandler(void);
static void USBConfigureEndpoint(BYTE EPNum, BYTE direction);
static void USBWakeFromSuspend(void);
static void USBSuspend(void);
static void USBStallHandler(void);
static void USBCheckVendorRequest(void);
static void USBVendorGetOSHandler(void);
void USBCBInitEP(void);
void USBCBStdSetDscHandler(void);
void USBCBCheckOtherReq(void);
void USBCB_SOF_Handler(void);
void USBCBSuspend(void);
void USBCBWakeFromSuspend(void);
void USBCBErrorHandler(void);
/******************************************************************************/
/** Function Implementations *************************************************/
/******************************************************************************/
/******************************************************************************/
/** Internal Macros *********************************************************/
/******************************************************************************/
/****************************************************************************
Function:
void USBAdvancePingPongBuffer(BDT_ENTRY** buffer)
Description:
This function will advance the passed pointer to the next buffer based on
the ping pong option setting. This function should be used for EP1-EP15
only. This function is not valid for EP0.
Precondition:
None
Parameters:
BDT_ENTRY** - pointer to the BDT_ENTRY pointer that you want to be advanced
to the next buffer state
Return Values:
None
Remarks:
None
***************************************************************************/
#define USBAdvancePingPongBuffer(buffer) ((BYTE_VAL *)buffer)->Val ^= USB_NEXT_PING_PONG;
#define USBHALPingPongSetToOdd(buffer) \
{ \
((BYTE_VAL *)buffer)->Val |= USB_NEXT_PING_PONG; \
}
#define USBHALPingPongSetToEven(buffer) \
{ \
((BYTE_VAL *)buffer)->Val &= ~USB_NEXT_PING_PONG; \
}
/******************************************************************************/
/** External API Functions ****************************************************/
/******************************************************************************/
/**************************************************************************
Function:
void USBDeviceInit(void)
Description:
This function initializes the device stack it in the default state. The
USB module will be completely reset including all of the internal
variables, registers, and interrupt flags.
Precondition:
This function must be called before any of the other USB Device
functions can be called, including USBDeviceTasks().
Parameters:
None
Return Values:
None
Remarks:
None
***************************************************************************/
void USBDeviceInit(void)
{
BYTE i;
USBDisableInterrupts();
// Clear all USB error flags
USBClearInterruptRegister(U1EIR);
// Clears all USB interrupts
USBClearInterruptRegister(U1IR);
//Clear all of the endpoint control registers
U1EP0 = 0;
DisableNonZeroEndpoints(USB_MAX_EP_NUMBER);
SetConfigurationOptions();
//power up the module (if not already powered)
USBPowerModule();
//set the address of the BDT (if applicable)
USBSetBDTAddress(BDT);
//Clear all of the BDT entries
for (i = 0; i < (sizeof(BDT) / sizeof(BDT_ENTRY)); i++)
{
BDT[i].Val = 0x00;
}
// Assert reset request to all of the Ping Pong buffer pointers
USBPingPongBufferReset = 1;
// Reset to default address
U1ADDR = 0x00;
// Make sure packet processing is enabled
USBPacketDisable = 0;
//Stop trying to reset ping pong buffer pointers
USBPingPongBufferReset = 0;
// Flush any pending transactions
while (USBTransactionCompleteIF == 1)
{
USBClearInterruptFlag(USBTransactionCompleteIFReg, USBTransactionCompleteIFBitNum);
//Initialize USB stack software state variables
inPipes[0].info.Val = 0;
outPipes[0].info.Val = 0;
outPipes[0].wCount.Val = 0;
}
//Set flags to TRUE, so the USBCtrlEPAllowStatusStage() function knows not to
//try and arm a status stage, even before the first control transfer starts.
USBStatusStageEnabledFlag1 = TRUE;
USBStatusStageEnabledFlag2 = TRUE;
//Initialize other flags
USBDeferINDataStagePackets = FALSE;
USBDeferOUTDataStagePackets = FALSE;
USBBusIsSuspended = FALSE;
//Initialize all pBDTEntryIn[] and pBDTEntryOut[]
//pointers to NULL, so they don't get used inadvertently.
for (i = 0; i < (BYTE)(USB_MAX_EP_NUMBER + 1u); i++)
{
pBDTEntryIn[i] = 0u;
pBDTEntryOut[i] = 0u;
ep_data_in[i].Val = 0u;
ep_data_out[i].Val = 0u;
}
//Get ready for the first packet
pBDTEntryIn[0] = (volatile BDT_ENTRY *)&BDT[EP0_IN_EVEN];
// Initialize EP0 as a Ctrl EP
U1EP0 = EP_CTRL | USB_HANDSHAKE_ENABLED;
//Prepare for the first SETUP on EP0 OUT
BDT[EP0_OUT_EVEN].ADR = ConvertToPhysicalAddress(&SetupPkt);
BDT[EP0_OUT_EVEN].CNT = USB_EP0_BUFF_SIZE;
BDT[EP0_OUT_EVEN].STAT.Val = _USIE | _DAT0 | _BSTALL;
// Clear active configuration
USBActiveConfiguration = 0;
//Indicate that we are now in the detached state
USBDeviceState = DETACHED_STATE;
}
/**************************************************************************
Function:
void USBDeviceTasks(void)
Summary:
This function is the main state machine/transaction handler of the USB
device side stack. When the USB stack is operated in "USB_POLLING" mode
(usb_config.h user option) the USBDeviceTasks() function should be called
periodically to receive and transmit packets through the stack. This
function also takes care of control transfers associated with the USB
enumeration process, and detecting various USB events (such as suspend).
This function should be called at least once every 1.8ms during the USB
enumeration process. After the enumeration process is complete (which can
be determined when USBGetDeviceState() returns CONFIGURED_STATE), the
USBDeviceTasks() handler may be called the faster of: either once
every 9.8ms, or as often as needed to make sure that the hardware USTAT
FIFO never gets full. A good rule of thumb is to call USBDeviceTasks() at
a minimum rate of either the frequency that USBTransferOnePacket() gets
called, or, once/1.8ms, whichever is faster. See the inline code comments
near the top of usb_device.c for more details about minimum timing
requirements when calling USBDeviceTasks().
When the USB stack is operated in "USB_INTERRUPT" mode, it is not necessary
to call USBDeviceTasks() from the main loop context. In the USB_INTERRUPT
mode, the USBDeviceTasks() handler only needs to execute when a USB
interrupt occurs, and therefore only needs to be called from the interrupt
context.
Description:
This function is the main state machine/transaction handler of the USB
device side stack. When the USB stack is operated in "USB_POLLING" mode
(usb_config.h user option) the USBDeviceTasks() function should be called
periodically to receive and transmit packets through the stack. This
function also takes care of control transfers associated with the USB
enumeration process, and detecting various USB events (such as suspend).
This function should be called at least once every 1.8ms during the USB
enumeration process. After the enumeration process is complete (which can
be determined when USBGetDeviceState() returns CONFIGURED_STATE), the
USBDeviceTasks() handler may be called the faster of: either once
every 9.8ms, or as often as needed to make sure that the hardware USTAT
FIFO never gets full. A good rule of thumb is to call USBDeviceTasks() at
a minimum rate of either the frequency that USBTransferOnePacket() gets
called, or, once/1.8ms, whichever is faster. See the inline code comments
near the top of usb_device.c for more details about minimum timing
requirements when calling USBDeviceTasks().
When the USB stack is operated in "USB_INTERRUPT" mode, it is not necessary
to call USBDeviceTasks() from the main loop context. In the USB_INTERRUPT
mode, the USBDeviceTasks() handler only needs to execute when a USB
interrupt occurs, and therefore only needs to be called from the interrupt
context.
Typical usage:
<code>
void main(void)
{
USBDeviceInit();
while(1)
{
USBDeviceTasks(); //Takes care of enumeration and other USB events
if((USBGetDeviceState() \< CONFIGURED_STATE) ||
(USBIsDeviceSuspended() == TRUE))
{
//Either the device is not configured or we are suspended,
// so we don't want to execute any USB related application code
continue; //go back to the top of the while loop
}
else
{
//Otherwise we are free to run USB and non-USB related user
//application code.
UserApplication();
}
}
}
</code>
Precondition:
Make sure the USBDeviceInit() function has been called prior to calling
USBDeviceTasks() for the first time.
Remarks:
USBDeviceTasks() does not need to be called while in the USB suspend mode,
if the user application firmware in the USBCBSuspend() callback function
enables the ACTVIF USB interrupt source and put the microcontroller into
sleep mode. If the application firmware decides not to sleep the
microcontroller core during USB suspend (ex: continues running at full
frequency, or clock switches to a lower frequency), then the USBDeviceTasks()
function must still be called periodically, at a rate frequent enough to
ensure the 10ms resume recovery interval USB specification is met. Assuming
a worst case primary oscillator and PLL start up time of <5ms, then
USBDeviceTasks() should be called once every 5ms in this scenario.
When the USB cable is detached, or the USB host is not actively powering
the VBUS line to +5V nominal, the application firmware does not always have
to call USBDeviceTasks() frequently, as no USB activity will be taking
place. However, if USBDeviceTasks() is not called regularly, some
alternative means of promptly detecting when VBUS is powered (indicating
host attachment), or not powered (host powered down or USB cable unplugged)
is still needed. For self or dual self/bus powered USB applications, see
the USBDeviceAttach() and USBDeviceDetach() API documentation for additional
considerations.
**************************************************************************/
void __attribute__((interrupt(), vector(_USB_1_VECTOR))) _USB1Interrupt(void)
{
BYTE i;
if (USBDeviceState == ATTACHED_STATE)
{
/*
* After enabling the USB module, it takes some time for the
* voltage on the D+ or D- line to rise high enough to get out
* of the SE0 condition. The USB Reset interrupt should not be
* unmasked until the SE0 condition is cleared. This helps
* prevent the firmware from misinterpreting this unique event
* as a USB bus reset from the USB host.
*/
if (!USBSE0Event)
{
USBClearInterruptRegister(U1IR); // Clear all USB interrupts
USBResetIE = 1; // Unmask RESET interrupt
USBIdleIE = 1; // Unmask IDLE interrupt
USBDeviceState = POWERED_STATE;
}
}
/*
* Task A: Service USB Activity Interrupt
*/
if (USBActivityIF && USBActivityIE)
{
USBClearInterruptFlag(USBActivityIFReg, USBActivityIFBitNum);
USBWakeFromSuspend();
}
/*
* Pointless to continue servicing if the device is in suspend mode.
*/
if (USBSuspendControl == 1)
{
USBClearUSBInterrupt();
return;
}
/*
* Task B: Service USB Bus Reset Interrupt.
* When bus reset is received during suspend, ACTVIF will be set first,
* once the UCONbits.SUSPND is clear, then the URSTIF bit will be asserted.
* This is why URSTIF is checked after ACTVIF.
*
* The USB reset flag is masked when the USB state is in
* DETACHED_STATE or ATTACHED_STATE, and therefore cannot
* cause a USB reset event during these two states.
*/
if (USBResetIF && USBResetIE)
{
USBDeviceInit();
//Re-enable the interrupts since the USBDeviceInit() function will
// disable them. This will do nothing in a polling setup
USBUnmaskInterrupts();
USBDeviceState = DEFAULT_STATE;
USBClearInterruptFlag(USBResetIFReg, USBResetIFBitNum);
}
/*
* Task C: Service other USB interrupts
*/
if (USBIdleIF && USBIdleIE)
{
USBSuspend();
USBClearInterruptFlag(USBIdleIFReg, USBIdleIFBitNum);
}
if (USBSOFIF)
{
if (USBSOFIE)
{
USB_SOF_HANDLER(EVENT_SOF, 0, 1);
}
USBClearInterruptFlag(USBSOFIFReg, USBSOFIFBitNum);
}
if (USBStallIF && USBStallIE)
{
USBStallHandler();
}
if (USBErrorIF && USBErrorIE)
{
USB_ERROR_HANDLER(EVENT_BUS_ERROR, 0, 1);
USBClearInterruptRegister(U1EIR); // This clears UERRIF
USBClearInterruptFlag(USBErrorIFReg, USBErrorIFBitNum);
}
/*
* Pointless to continue servicing if the host has not sent a bus reset.
* Once bus reset is received, the device transitions into the DEFAULT
* state and is ready for communication.
*/
if (USBDeviceState < DEFAULT_STATE)
{
USBClearUSBInterrupt();
return;
}
/*
* Task D: Servicing USB Transaction Complete Interrupt
*/
if (USBTransactionCompleteIE)
{
for (i = 0; i < 4u; i++) //Drain or deplete the USAT FIFO entries. If the USB FIFO ever gets full, USB bandwidth
{ //utilization can be compromised, and the device won't be able to receive SETUP packets.
if (USBTransactionCompleteIF)
{
//Save and extract USTAT register info. Will use this info later.
USTATcopy.Val = U1STAT;
endpoint_number = USBHALGetLastEndpoint(USTATcopy);
USBClearInterruptFlag(USBTransactionCompleteIFReg, USBTransactionCompleteIFBitNum);
if (USBHALGetLastDirection(USTATcopy) == OUT_FROM_HOST)
{
ep_data_out[endpoint_number].bits.ping_pong_state ^= 1;
}
else
{
ep_data_in[endpoint_number].bits.ping_pong_state ^= 1;
}
//USBCtrlEPService only services transactions over EP0.
//It ignores all other EP transactions.
if (endpoint_number == 0)
{
USBCtrlEPService();
}
else
{
USB_TRANSFER_COMPLETE_HANDLER(EVENT_TRANSFER, (BYTE *)&USTATcopy.Val, 0);
}
} //end if(USBTransactionCompleteIF)
else
break; //USTAT FIFO must be empty.
} //end for()
} //end if(USBTransactionCompleteIE)
USBClearUSBInterrupt();
} //end of USBDeviceTasks()
/*******************************************************************************
Function:
void USBEnableEndpoint(BYTE ep, BYTE options)
Summary:
This function will enable the specified endpoint with the specified
options
Description:
This function will enable the specified endpoint with the specified
options.
Typical Usage:
<code>
void USBCBInitEP(void)
{
USBEnableEndpoint(MSD_DATA_IN_EP,USB_IN_ENABLED|USB_OUT_ENABLED|USB_HANDSHAKE_ENABLED|USB_DISALLOW_SETUP);
USBMSDInit();
}
</code>
In the above example endpoint number MSD_DATA_IN_EP is being configured
for both IN and OUT traffic with handshaking enabled. Also since
MSD_DATA_IN_EP is not endpoint 0 (MSD does not allow this), then we can
explicitly disable SETUP packets on this endpoint.
Conditions:
None
Input:
BYTE ep - the endpoint to be configured
BYTE options - optional settings for the endpoint. The options should
be ORed together to form a single options string. The
available optional settings for the endpoint. The
options should be ORed together to form a single options
string. The available options are the following\:
* USB_HANDSHAKE_ENABLED enables USB handshaking (ACK,
NAK)
* USB_HANDSHAKE_DISABLED disables USB handshaking (ACK,
NAK)
* USB_OUT_ENABLED enables the out direction
* USB_OUT_DISABLED disables the out direction
* USB_IN_ENABLED enables the in direction
* USB_IN_DISABLED disables the in direction
* USB_ALLOW_SETUP enables control transfers
* USB_DISALLOW_SETUP disables control transfers
* USB_STALL_ENDPOINT STALLs this endpoint
Return:
None
Remarks:
None
*****************************************************************************/
void USBEnableEndpoint(BYTE ep, BYTE options)
{
unsigned char *p;
//Use USBConfigureEndpoint() to set up the pBDTEntryIn/Out[ep] pointer and
//starting DTS state in the BDT entry.
if (options & USB_OUT_ENABLED)
{
USBConfigureEndpoint(ep, OUT_FROM_HOST);
}
if (options & USB_IN_ENABLED)
{
USBConfigureEndpoint(ep, IN_TO_HOST);
}
//Update the relevant UEPx register to actually enable the endpoint with
//the specified options (ex: handshaking enabled, control transfers allowed,
//etc.)
p = (unsigned char *)(&U1EP0 + (4 * ep));
*p = options;
}
/*************************************************************************
Function:
USB_HANDLE USBTransferOnePacket(BYTE ep, BYTE dir, BYTE* data, BYTE len)
Summary:
Transfers a single packet (one transaction) of data on the USB bus.
Description:
The USBTransferOnePacket() function prepares a USB endpoint
so that it may send data to the host (an IN transaction), or
receive data from the host (an OUT transaction). The
USBTransferOnePacket() function can be used both to receive and
send data to the host. This function is the primary API function
provided by the USB stack firmware for sending or receiving application
data over the USB port.
The USBTransferOnePacket() is intended for use with all application
endpoints. It is not used for sending or receiving applicaiton data
through endpoint 0 by using control transfers. Separate API
functions, such as USBEP0Receive(), USBEP0SendRAMPtr(), and
USBEP0SendROMPtr() are provided for this purpose.
The USBTransferOnePacket() writes to the Buffer Descriptor Table (BDT)
entry associated with an endpoint buffer, and sets the UOWN bit, which
prepares the USB hardware to allow the transaction to complete. The
application firmware can use the USBHandleBusy() macro to check the
status of the transaction, to see if the data has been successfully
transmitted yet.
Typical Usage
<code>
//make sure that the we are in the configured state
if(USBGetDeviceState() == CONFIGURED_STATE)
{
//make sure that the last transaction isn't busy by checking the handle
if(!USBHandleBusy(USBInHandle))
{
//Write the new data that we wish to send to the host to the INPacket[] array
INPacket[0] = USEFUL_APPLICATION_VALUE1;
INPacket[1] = USEFUL_APPLICATION_VALUE2;
//INPacket[2] = ... (fill in the rest of the packet data)
//Send the data contained in the INPacket[] array through endpoint "EP_NUM"
USBInHandle = USBTransferOnePacket(EP_NUM,IN_TO_HOST,(BYTE*)&INPacket[0],sizeof(INPacket));
}
}
</code>
Conditions:
Before calling USBTransferOnePacket(), the following should be true.
1. The USB stack has already been initialized (USBDeviceInit() was called).
2. A transaction is not already pending on the specified endpoint. This
is done by checking the previous request using the USBHandleBusy()
macro (see the typical usage example).
3. The host has already sent a set configuration request and the
enumeration process is complete.
This can be checked by verifying that the USBGetDeviceState()
macro returns "CONFIGURED_STATE", prior to calling
USBTransferOnePacket().
Input:
BYTE ep - The endpoint number that the data will be transmitted or
received on
BYTE dir - The direction of the transfer
This value is either OUT_FROM_HOST or IN_TO_HOST
BYTE* data - For IN transactions: pointer to the RAM buffer containing
the data to be sent to the host. For OUT transactions: pointer
to the RAM buffer that the received data should get written to.
BYTE len - Length of the data needing to be sent (for IN transactions).
For OUT transactions, the len parameter should normally be set
to the endpoint size specified in the endpoint descriptor.
Return Values:
USB_HANDLE - handle to the transfer. The handle is a pointer to
the BDT entry associated with this transaction. The
status of the transaction (ex: if it is complete or still
pending) can be checked using the USBHandleBusy() macro
and supplying the USB_HANDLE provided by
USBTransferOnePacket().
Remarks:
If calling the USBTransferOnePacket() function from within the USBCBInitEP()
callback function, the set configuration is still being processed and the
USBDeviceState may not be == CONFIGURED_STATE yet. In this special case,
the USBTransferOnePacket() may still be called, but make sure that the
endpoint has been enabled and initialized by the USBEnableEndpoint()
function first.
*************************************************************************/
USB_HANDLE USBTransferOnePacket(BYTE ep, BYTE dir, BYTE *data, BYTE len)
{
volatile BDT_ENTRY *handle;
//If the direction is IN
if (dir != 0)
{
//point to the IN BDT of the specified endpoint
handle = pBDTEntryIn[ep];
}
else
{
//else point to the OUT BDT of the specified endpoint
handle = pBDTEntryOut[ep];
}
//Error checking code. Make sure the handle (pBDTEntryIn[ep] or
//pBDTEntryOut[ep]) is initialized before using it.
if (handle == 0)
{
return 0;
}
//Set the data pointer, data length, and enable the endpoint
handle->ADR = ConvertToPhysicalAddress(data);
handle->CNT = len;
handle->STAT.Val &= _DTSMASK;
handle->STAT.Val |= _USIE | (_DTSEN & _DTS_CHECKING_ENABLED);
//Point to the next buffer for ping pong purposes.
if (dir != OUT_FROM_HOST)
{
//toggle over the to the next buffer for an IN endpoint
USBAdvancePingPongBuffer(&pBDTEntryIn[ep]);
}
else
{
//toggle over the to the next buffer for an OUT endpoint
USBAdvancePingPongBuffer(&pBDTEntryOut[ep]);
}
return (USB_HANDLE)handle;
}
/********************************************************************
Function:
void USBStallEndpoint(BYTE ep, BYTE dir)
Summary:
Configures the specified endpoint to send STALL to the host, the next
time the host tries to access the endpoint.
PreCondition:
None
Parameters:
BYTE ep - The endpoint number that should be configured to send STALL.
BYTE dir - The direction of the endpoint to STALL, either
IN_TO_HOST or OUT_FROM_HOST.
Return Values:
None
Remarks:
None
*******************************************************************/
void USBStallEndpoint(BYTE ep, BYTE dir)
{
BDT_ENTRY *p;
if (ep == 0)
{
//For control endpoints (ex: EP0), we need to STALL both IN and OUT
//endpoints. EP0 OUT must also be prepared to receive the next SETUP
//packet that will arrrive.
pBDTEntryEP0OutNext->CNT = USB_EP0_BUFF_SIZE;
pBDTEntryEP0OutNext->ADR = ConvertToPhysicalAddress(&SetupPkt);
pBDTEntryEP0OutNext->STAT.Val = _USIE | _DAT0 | (_DTSEN & _DTS_CHECKING_ENABLED) | _BSTALL;
pBDTEntryIn[0]->STAT.Val = _USIE | _BSTALL;
}
else
{
p = (BDT_ENTRY *)(&BDT[EP(ep, dir, 0)]);
p->STAT.Val |= _BSTALL | _USIE;
//If the device is in FULL or ALL_BUT_EP0 ping pong modes
//then stall that entry as well
p = (BDT_ENTRY *)(&BDT[EP(ep, dir, 1)]);
p->STAT.Val |= _BSTALL | _USIE;
}
}
/**************************************************************************
Function:
void USBCancelIO(BYTE endpoint)
Description:
This function cancels the transfers pending on the specified endpoint.
This function can only be used after a SETUP packet is received and
before that setup packet is handled. This is the time period in which
the EVENT_EP0_REQUEST is thrown, before the event handler function
returns to the stack.
Precondition:
Parameters:
BYTE endpoint - the endpoint number you wish to cancel the transfers for
Return Values:
None
Remarks:
None
**************************************************************************/
void USBCancelIO(BYTE endpoint)
{
if (USBPacketDisable == 1)
{
//The PKTDIS bit is currently set right now. It is therefore "safe"
//to mess with the BDT right now.
pBDTEntryIn[endpoint]->Val &= _DTSMASK; //Makes UOWN = 0 (_UCPU mode). Deactivates endpoint. Only sends NAKs.
pBDTEntryIn[endpoint]->Val ^= _DTSMASK; //Toggle the DTS bit. This packet didn't get sent yet, and the next call to USBTransferOnePacket() will re-toggle the DTS bit back to the original (correct) value.
//Need to do additional handling if ping-pong buffering is being used
//Point to the next buffer for ping pong purposes. UOWN getting cleared
//(either due to SIE clearing it after a transaction, or the firmware
//clearing it) makes hardware ping pong pointer advance.
USBAdvancePingPongBuffer(&pBDTEntryIn[endpoint]);
pBDTEntryIn[endpoint]->STAT.Val &= _DTSMASK;
pBDTEntryIn[endpoint]->STAT.Val ^= _DTSMASK;
}
}
/**************************************************************************
Function:
void USBDeviceDetach(void)
Summary:
This function configures the USB module to "soft detach" itself from
the USB host.
Description:
This function configures the USB module to perform a "soft detach"
operation, by disabling the D+ (or D-) ~1.5k pull up resistor, which
lets the host know the device is present and attached. This will make
the host think that the device has been unplugged. This is potentially
useful, as it allows the USB device to force the host to re-enumerate
the device (on the firmware has re-enabled the USB module/pull up, by
calling USBDeviceAttach(), to "soft re-attach" to the host).
Precondition:
Should only be called when USB_INTERRUPT is defined. See remarks
section if USB_POLLING mode option is being used (usb_config.h option).
Additionally, this function should only be called from the main() loop
context. Do not call this function from within an interrupt handler, as
this function may modify global interrupt enable bits and settings.
Parameters:
None
Return Values:
None
Remarks:
If the application firmware calls USBDeviceDetach(), it is strongly
recommended that the firmware wait at least >= 80ms before calling
USBDeviceAttach(). If the firmeware performs a soft detach, and then
re-attaches too soon (ex: after a few micro seconds for instance), some
hosts may interpret this as an unexpected "glitch" rather than as a
physical removal/re-attachment of the USB device. In this case the host
may simply ignore the event without re-enumerating the device. To
ensure that the host properly detects and processes the device soft
detach/re-attach, it is recommended to make sure the device remains
detached long enough to mimic a real human controlled USB
unplug/re-attach event (ex: after calling USBDeviceDetach(), do not
call USBDeviceAttach() for at least 80+ms, preferrably longer.
Neither the USBDeviceDetach() or USBDeviceAttach() functions are blocking
or take long to execute. It is the application firmware's
responsibility for adding the 80+ms delay, when using these API
functions.
Note: The Windows plug and play event handler processing is fairly
slow, especially in certain versions of Windows, and for certain USB
device classes. It has been observed that some device classes need to
provide even more USB detach dwell interval (before calling
USBDeviceAttach()), in order to work correctly after re-enumeration.
If the USB device is a CDC class device, it is recommended to wait
at least 1.5 seconds or longer, before soft re-attaching to the host,
to provide the plug and play event handler enough time to finish
processing the removal event, before the re-attach occurs.
If the application is using the USB_POLLING mode option, then the
USBDeviceDetach() and USBDeviceAttach() functions are not available.
In this mode, the USB stack relies on the "#define USE_USB_BUS_SENSE_IO"
and "#define USB_BUS_SENSE" options in the
HardwareProfile – [platform name].h file.
When using the USB_POLLING mode option, and the
"#define USE_USB_BUS_SENSE_IO" definition has been commented out, then
the USB stack assumes that it should always enable the USB module at
pretty much all times. Basically, anytime the application firmware
calls USBDeviceTasks(), the firmware will automatically enable the USB
module. This mode would typically be selected if the application was
designed to be a purely bus powered device. In this case, the
application is powered from the +5V VBUS supply from the USB port, so
it is correct and sensible in this type of application to power up and
turn on the USB module, at anytime that the microcontroller is
powered (which implies the USB cable is attached and the host is also
powered).
In a self powered application, the USB stack is designed with the
intention that the user will enable the "#define USE_USB_BUS_SENSE_IO"
option in the HardwareProfile – [platform name].h file. When this
option is defined, then the USBDeviceTasks() function will automatically
check the I/O pin port value of the designated pin (based on the
#define USB_BUS_SENSE option in the HardwareProfile – [platform name].h
file), every time the application calls USBDeviceTasks(). If the
USBDeviceTasks() function is executed and finds that the pin defined by
the #define USB_BUS_SENSE is in a logic low state, then it will
automatically disable the USB module and tri-state the D+ and D- pins.
If however the USBDeviceTasks() function is executed and finds the pin
defined by the #define USB_BUS_SENSE is in a logic high state, then it
will automatically enable the USB module, if it has not already been
enabled.
**************************************************************************/
void USBDeviceDetach(void)
{
//If the interrupt option is selected then the customer is required
// to notify the stack when the device is attached or removed from the
// bus by calling the USBDeviceAttach() and USBDeviceDetach() functions.
// Disable module & detach from bus
U1CON = 0;
// Mask all USB interrupts
U1IE = 0;
//Move to the detached state
USBDeviceState = DETACHED_STATE;
return;
}
/**************************************************************************
Function:
void USBDeviceAttach(void)
Summary:
Checks if VBUS is present, and that the USB module is not already
initalized, and if so, enables the USB module so as to signal device
attachment to the USB host.
Description:
This function indicates to the USB host that the USB device has been
attached to the bus. This function needs to be called in order for the
device to start to enumerate on the bus.
Precondition:
Should only be called when USB_INTERRUPT is defined. Also, should only
be called from the main() loop context. Do not call USBDeviceAttach()
from within an interrupt handler, as the USBDeviceAttach() function
may modify global interrupt enable bits and settings.
For normal USB devices:
Make sure that if the module was previously on, that it has been turned off
for a long time (ex: 100ms+) before calling this function to re-enable the module.
If the device turns off the D+ (for full speed) or D- (for low speed) ~1.5k ohm
pull up resistor, and then turns it back on very quickly, common hosts will sometimes
reject this event, since no human could ever unplug and reattach a USB device in a
microseconds (or nanoseconds) timescale. The host could simply treat this as some kind
of glitch and ignore the event altogether.
Parameters:
None
Return Values:
None
Remarks:
See also the USBDeviceDetach() API function documentation.
****************************************************************************/
void USBDeviceAttach(void)
{
//if we are in the detached state
if (USBDeviceState == DETACHED_STATE)
{
if (USB_BUS_SENSE == 1)
{
//Initialize registers to known states.
U1CON = 0;
// Mask all USB interrupts
U1IE = 0;
//Configure things like: pull ups, full/low-speed mode,
//set the ping pong mode, and set internal transceiver
SetConfigurationOptions();
USBEnableInterrupts(); //Modifies global interrupt settings
// Enable module & attach to bus
while (!U1CONbits.USBEN)
{
U1CONbits.USBEN = 1;
}
//moved to the attached state
USBDeviceState = ATTACHED_STATE;
}
}
}
/*******************************************************************************
Function: void USBCtrlEPAllowStatusStage(void);
Summary: This function prepares the proper endpoint 0 IN or endpoint 0 OUT
(based on the controlTransferState) to allow the status stage packet
of a control transfer to complete. This function gets used
internally by the USB stack itself, but it may also be called from
the application firmware, IF the application firmware called
the USBDeferStatusStage() function during the initial processing
of the control transfer request. In this case, the application
must call the USBCtrlEPAllowStatusStage() once, after it has fully
completed processing and handling the data stage portion of the
request.
If the application firmware has no need for delaying control
transfers, and therefore never calls USBDeferStatusStage(), then the
application firmware should not call USBCtrlEPAllowStatusStage().
Description:
Conditions:
None
Input:
Return:
Remarks:
None
*****************************************************************************/
void USBCtrlEPAllowStatusStage(void)
{