Statistics
| Branch: | Tag: | Revision:

root / LUFA / Drivers / USB / Core / UC3 / Pipe_UC3.c @ 978b99e5

History | View | Annotate | Download (4.84 KB)

1
/*
2
             LUFA Library
3
     Copyright (C) Dean Camera, 2011.
4

5
  dean [at] fourwalledcubicle [dot] com
6
           www.lufa-lib.org
7
*/
8

    
9
/*
10
  Copyright 2011  Dean Camera (dean [at] fourwalledcubicle [dot] com)
11

12
  Permission to use, copy, modify, distribute, and sell this
13
  software and its documentation for any purpose is hereby granted
14
  without fee, provided that the above copyright notice appear in
15
  all copies and that both that the copyright notice and this
16
  permission notice and warranty disclaimer appear in supporting
17
  documentation, and that the name of the author not be used in
18
  advertising or publicity pertaining to distribution of the
19
  software without specific, written prior permission.
20

21
  The author disclaim all warranties with regard to this
22
  software, including all implied warranties of merchantability
23
  and fitness.  In no event shall the author be liable for any
24
  special, indirect or consequential damages or any damages
25
  whatsoever resulting from loss of use, data or profits, whether
26
  in an action of contract, negligence or other tortious action,
27
  arising out of or in connection with the use or performance of
28
  this software.
29
*/
30

    
31
#define  __INCLUDE_FROM_USB_DRIVER
32
#include "../USBMode.h"
33

    
34
#if defined(USB_CAN_BE_HOST)
35

    
36
#include "../Pipe.h"
37

    
38
uint8_t USB_Host_ControlPipeSize = PIPE_CONTROLPIPE_DEFAULT_SIZE;
39

    
40
volatile uint32_t USB_SelectedPipe = PIPE_CONTROLPIPE;
41
volatile uint8_t* USB_PipeFIFOPos[PIPE_TOTAL_PIPES];
42

    
43
bool Pipe_ConfigurePipe(const uint8_t Number,
44
                        const uint8_t Type,
45
                        const uint8_t Token,
46
                        const uint8_t EndpointNumber,
47
                        const uint16_t Size,
48
                        const uint8_t Banks)
49
{
50
#if defined(ORDERED_EP_CONFIG)
51
        Pipe_SelectPipe(Number);
52
        Pipe_EnablePipe();
53

    
54
        (&AVR32_USBB.upcfg0)[Number] = 0;
55
        (&AVR32_USBB.upcfg0)[Number] = (AVR32_USBB_ALLOC_MASK |
56
                                        ((uint32_t)Type  << AVR32_USBB_PTYPE_OFFSET)  |
57
                                        ((uint32_t)Token << AVR32_USBB_PTOKEN_OFFSET) |
58
                                        ((uint32_t)Banks << AVR32_USBB_PBK_OFFSET)    |
59
                                        ((EndpointNumber & PIPE_EPNUM_MASK) << AVR32_USBB_PEPNUM_OFFSET));
60
        USB_PipeFIFOPos[Number]      = &AVR32_USBB_SLAVE[Number * 0x10000];
61

    
62
        Pipe_SetInfiniteINRequests();
63

    
64
        return Pipe_IsConfigured();
65
#else
66
        for (uint8_t PNum = Number; PNum < PIPE_TOTAL_PIPES; PNum++)
67
        {
68
                uint8_t UPCFG0Temp;
69

    
70
                Pipe_SelectPipe(PNum);
71
                
72
                if (PNum == Number)
73
                {
74
                        UPCFG0Temp = (AVR32_USBB_ALLOC_MASK |
75
                                      ((uint32_t)Type  << AVR32_USBB_PTYPE_OFFSET)  |
76
                                      ((uint32_t)Token << AVR32_USBB_PTOKEN_OFFSET) |
77
                                      ((uint32_t)Banks << AVR32_USBB_PBK_OFFSET)    |
78
                                      ((EndpointNumber & PIPE_EPNUM_MASK) << AVR32_USBB_PEPNUM_OFFSET));
79
                }
80
                else
81
                {
82
                        UPCFG0Temp = (&AVR32_USBB.upcfg0)[PNum]
83
                }
84

    
85
                if (!(UPCFG0Temp & AVR32_USBB_ALLOC_MASK))
86
                  continue;
87
                  
88
                Pipe_DisablePipe();
89
                (&AVR32_USBB.upcfg0)[PNum] &= ~AVR32_USBB_ALLOC_MASK;
90

    
91
                Pipe_EnablePipe();
92
                (&AVR32_USBB.upcfg0)[PNum] = UPCFG0Temp;
93

    
94
                Pipe_SetInfiniteINRequests();
95
        
96
                if (!(Pipe_IsConfigured()))
97
                  return false;                
98
        }
99
                
100
        Pipe_SelectPipe(Number);        
101
        return true;
102
#endif
103
}
104

    
105
void Pipe_ClearPipes(void)
106
{
107
        for (uint8_t PNum = 0; PNum < PIPE_TOTAL_PIPES; PNum++)
108
        {
109
                Pipe_SelectPipe(PNum);
110
                (&AVR32_USBB.upcfg0)[PNum]    = 0;
111
                (&AVR32_USBB.upcon0clr)[PNum] = -1;
112
                USB_PipeFIFOPos[PNum]         = &AVR32_USBB_SLAVE[PNum * 0x10000];
113
                Pipe_DisablePipe();
114
        }
115
}
116

    
117
bool Pipe_IsEndpointBound(const uint8_t EndpointAddress)
118
{
119
        uint8_t PrevPipeNumber = Pipe_GetCurrentPipe();
120

    
121
        for (uint8_t PNum = 0; PNum < PIPE_TOTAL_PIPES; PNum++)
122
        {
123
                Pipe_SelectPipe(PNum);
124

    
125
                if (!(Pipe_IsConfigured()))
126
                  continue;
127

    
128
                if (Pipe_GetBoundEndpointAddress() == EndpointAddress)
129
                  return true;
130
        }
131

    
132
        Pipe_SelectPipe(PrevPipeNumber);
133
        return false;
134
}
135

    
136
uint8_t Pipe_WaitUntilReady(void)
137
{
138
        #if (USB_STREAM_TIMEOUT_MS < 0xFF)
139
        uint8_t  TimeoutMSRem = USB_STREAM_TIMEOUT_MS;
140
        #else
141
        uint16_t TimeoutMSRem = USB_STREAM_TIMEOUT_MS;
142
        #endif
143

    
144
        uint16_t PreviousFrameNumber = USB_Host_GetFrameNumber();
145

    
146
        for (;;)
147
        {
148
                if (Pipe_GetPipeToken() == PIPE_TOKEN_IN)
149
                {
150
                        if (Pipe_IsINReceived())
151
                          return PIPE_READYWAIT_NoError;
152
                }
153
                else
154
                {
155
                        if (Pipe_IsOUTReady())
156
                          return PIPE_READYWAIT_NoError;
157
                }
158

    
159
                if (Pipe_IsStalled())
160
                  return PIPE_READYWAIT_PipeStalled;
161
                else if (USB_HostState == HOST_STATE_Unattached)
162
                  return PIPE_READYWAIT_DeviceDisconnected;
163

    
164
                uint16_t CurrentFrameNumber = USB_Host_GetFrameNumber();
165

    
166
                if (CurrentFrameNumber != PreviousFrameNumber)
167
                {
168
                        PreviousFrameNumber = CurrentFrameNumber;
169

    
170
                        if (!(TimeoutMSRem--))
171
                          return PIPE_READYWAIT_Timeout;
172
                }
173
        }
174
}
175

    
176
#endif
177