Statistics
| Branch: | Tag: | Revision:

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

History | View | Annotate | Download (5.41 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
#define  __INCLUDE_FROM_USB_CONTROLLER_C
33
#include "../USBController.h"
34

    
35
#if (!defined(USB_HOST_ONLY) && !defined(USB_DEVICE_ONLY))
36
volatile uint8_t USB_CurrentMode = USB_MODE_None;
37
#endif
38

    
39
#if !defined(USE_STATIC_OPTIONS)
40
volatile uint8_t USB_Options;
41
#endif
42

    
43
void USB_Init(
44
               #if defined(USB_CAN_BE_BOTH)
45
               const uint8_t Mode
46
               #endif
47

    
48
               #if (defined(USB_CAN_BE_BOTH) && !defined(USE_STATIC_OPTIONS))
49
               ,
50
               #elif (!defined(USB_CAN_BE_BOTH) && defined(USE_STATIC_OPTIONS))
51
               void
52
               #endif
53

    
54
               #if !defined(USE_STATIC_OPTIONS)
55
               const uint8_t Options
56
               #endif
57
               )
58
{
59
        #if !defined(USE_STATIC_OPTIONS)
60
        USB_Options = Options;
61
        #endif
62
        
63
        #if defined(USB_CAN_BE_BOTH)
64
        if (Mode == USB_MODE_UID)
65
        {
66
                AVR32_USBB.USBCON.uide = true;
67
                USB_INT_Enable(USB_INT_IDTI);
68
                USB_CurrentMode = USB_GetUSBModeFromUID();
69
        }
70
        else
71
        {
72
                AVR32_USBB.USBCON.uide = false;
73
                USB_CurrentMode = Mode;
74
        }
75
        #else
76
        AVR32_USBB.USBCON.uide = false;        
77
        #endif
78

    
79
        USB_IsInitialized = true;
80

    
81
        USB_ResetInterface();
82
}
83

    
84
void USB_Disable(void)
85
{
86
        USB_INT_DisableAllInterrupts();
87
        USB_INT_ClearAllInterrupts();
88

    
89
        USB_Detach();
90
        USB_Controller_Disable();
91

    
92
        USB_OTGPAD_Off();
93

    
94
        #if defined(USB_CAN_BE_BOTH)
95
        USB_CurrentMode = USB_MODE_None;
96
        #endif
97

    
98
        AVR32_PM.GCCTRL[3].cen = false;
99

    
100
        USB_IsInitialized = false;
101
}
102

    
103
void USB_ResetInterface(void)
104
{
105
        #if defined(USB_CAN_BE_BOTH)
106
        bool UIDModeSelectEnabled = AVR32_USBB.USBCON.uide;
107
        #endif
108

    
109
        AVR32_PM.GCCTRL[AVR32_PM_GCLK_USBB].pllsel = !(USB_Options & USB_OPT_GCLK_SRC_OSC);
110
        AVR32_PM.GCCTRL[AVR32_PM_GCLK_USBB].oscsel = !(USB_Options & USB_OPT_GCLK_CHANNEL_0);
111
        AVR32_PM.GCCTRL[AVR32_PM_GCLK_USBB].diven  = (F_USB != USB_CLOCK_REQUIRED_FREQ);
112
        AVR32_PM.GCCTRL[AVR32_PM_GCLK_USBB].div    = (F_USB == USB_CLOCK_REQUIRED_FREQ) ? 0 : (uint32_t)(((F_USB / USB_CLOCK_REQUIRED_FREQ) - 1) / 2);
113
        AVR32_PM.GCCTRL[AVR32_PM_GCLK_USBB].cen    = true;
114

    
115
        USB_INT_DisableAllInterrupts();
116
        USB_INT_ClearAllInterrupts();
117

    
118
        USB_Controller_Reset();
119

    
120
        #if defined(USB_CAN_BE_BOTH)
121
        if (UIDModeSelectEnabled)
122
          USB_INT_Enable(USB_INT_IDTI);
123
        #endif
124

    
125
        USB_CLK_Unfreeze();
126

    
127
        if (USB_CurrentMode == USB_MODE_Device)
128
        {
129
                #if defined(USB_CAN_BE_DEVICE)
130
                AVR32_USBB.USBCON.uimod = true;
131

    
132
                USB_Init_Device();
133
                #endif
134
        }
135
        else if (USB_CurrentMode == USB_MODE_Host)
136
        {
137
                #if defined(USB_CAN_BE_HOST)
138
                AVR32_USBB.USBCON.uimod = false;
139

    
140
                USB_Init_Host();
141
                #endif
142
        }
143

    
144
        USB_OTGPAD_On();
145
}
146

    
147
#if defined(USB_CAN_BE_DEVICE)
148
static void USB_Init_Device(void)
149
{
150
        USB_DeviceState                 = DEVICE_STATE_Unattached;
151
        USB_Device_ConfigurationNumber  = 0;
152

    
153
        #if !defined(NO_DEVICE_REMOTE_WAKEUP)
154
        USB_Device_RemoteWakeupEnabled  = false;
155
        #endif
156

    
157
        #if !defined(NO_DEVICE_SELF_POWER)
158
        USB_Device_CurrentlySelfPowered = false;
159
        #endif
160

    
161
        #if !defined(FIXED_CONTROL_ENDPOINT_SIZE)
162
        USB_Descriptor_Device_t* DeviceDescriptorPtr;
163

    
164
        if (CALLBACK_USB_GetDescriptor((DTYPE_Device << 8), 0, (void*)&DeviceDescriptorPtr) != NO_DESCRIPTOR)
165
          USB_Device_ControlEndpointSize = DeviceDescriptorPtr->Endpoint0Size;
166
        #endif
167

    
168
        if (USB_Options & USB_DEVICE_OPT_LOWSPEED)
169
        {
170
                USB_Device_SetLowSpeed();
171
        }
172
        else
173
        {
174
                #if defined(USB_DEVICE_OPT_HIGHSPEED)
175
                if (USB_Options & USB_DEVICE_OPT_HIGHSPEED)        
176
                  USB_Device_SetHighSpeed();
177
                else
178
                  USB_Device_SetFullSpeed();
179
                #else
180
                USB_Device_SetFullSpeed();
181
                #endif                
182
        }
183

    
184
        USB_INT_Enable(USB_INT_VBUSTI);
185

    
186
        Endpoint_ConfigureEndpoint(ENDPOINT_CONTROLEP, EP_TYPE_CONTROL,
187
                                                           ENDPOINT_DIR_OUT, USB_Device_ControlEndpointSize,
188
                                                           ENDPOINT_BANK_SINGLE);
189

    
190
        USB_INT_Clear(USB_INT_SUSPI);
191
        USB_INT_Enable(USB_INT_SUSPI);
192
        USB_INT_Enable(USB_INT_EORSTI);
193

    
194
        USB_Attach();
195
}
196
#endif
197

    
198
#if defined(USB_CAN_BE_HOST)
199
static void USB_Init_Host(void)
200
{
201
        USB_HostState                = HOST_STATE_Unattached;
202
        USB_Host_ConfigurationNumber = 0;
203
        USB_Host_ControlPipeSize     = PIPE_CONTROLPIPE_DEFAULT_SIZE;
204

    
205
        USB_Host_HostMode_On();
206

    
207
        USB_Host_VBUS_Auto_On();
208

    
209
        USB_INT_Enable(USB_INT_DCONNI);
210
        USB_INT_Enable(USB_INT_BCERRI);
211

    
212
        USB_Attach();
213
}
214
#endif
215