Statistics
| Branch: | Tag: | Revision:

root / LUFA / Drivers / USB / Core / AVR8 / USBController_AVR8.c @ 978b99e5

History | View | Annotate | Download (6.73 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 (!(USB_Options & USB_OPT_REG_DISABLED))
64
          USB_REG_On();
65
        else
66
          USB_REG_Off();
67

    
68
        if (!(USB_Options & USB_OPT_MANUAL_PLL))
69
        {
70
                #if defined(USB_SERIES_4_AVR)
71
                PLLFRQ = ((1 << PLLUSB) | (1 << PDIV3) | (1 << PDIV1));
72
                #endif
73
        }
74

    
75
        #if defined(USB_CAN_BE_BOTH)
76
        if (Mode == USB_MODE_UID)
77
        {
78
                UHWCON |=  (1 << UIDE);
79
                USB_INT_Enable(USB_INT_IDTI);
80
                USB_CurrentMode = USB_GetUSBModeFromUID();
81
        }
82
        else
83
        {
84
                UHWCON &= ~(1 << UIDE);
85
                USB_CurrentMode = Mode;
86
        }
87
        #endif
88

    
89
        USB_IsInitialized = true;
90

    
91
        USB_ResetInterface();
92
}
93

    
94
void USB_Disable(void)
95
{
96
        USB_INT_DisableAllInterrupts();
97
        USB_INT_ClearAllInterrupts();
98

    
99
        USB_Detach();
100
        USB_Controller_Disable();
101

    
102
        if (!(USB_Options & USB_OPT_MANUAL_PLL))
103
          USB_PLL_Off();
104

    
105
        USB_REG_Off();
106

    
107
        #if defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR)
108
        USB_OTGPAD_Off();
109
        #endif
110

    
111
        #if defined(USB_CAN_BE_BOTH)
112
        USB_CurrentMode = USB_MODE_None;
113
        #endif
114

    
115
        USB_IsInitialized = false;
116
}
117

    
118
void USB_ResetInterface(void)
119
{
120
        #if defined(USB_CAN_BE_BOTH)
121
        bool UIDModeSelectEnabled = ((UHWCON & (1 << UIDE)) != 0);
122
        #endif
123

    
124
        USB_INT_DisableAllInterrupts();
125
        USB_INT_ClearAllInterrupts();
126

    
127
        USB_Controller_Reset();
128

    
129
        #if defined(USB_CAN_BE_BOTH)
130
        if (UIDModeSelectEnabled)
131
          USB_INT_Enable(USB_INT_IDTI);
132
        #endif
133

    
134
        USB_CLK_Unfreeze();
135

    
136
        if (USB_CurrentMode == USB_MODE_Device)
137
        {
138
                #if defined(USB_CAN_BE_DEVICE)
139
                #if (defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR))
140
                UHWCON |=  (1 << UIMOD);
141
                #endif
142

    
143
                if (!(USB_Options & USB_OPT_MANUAL_PLL))
144
                {
145
                        #if defined(USB_SERIES_2_AVR)
146
                        USB_PLL_On();
147
                        while (!(USB_PLL_IsReady()));
148
                        #else
149
                        USB_PLL_Off();
150
                        #endif
151
                }
152

    
153
                USB_Init_Device();
154
                #endif
155
        }
156
        else if (USB_CurrentMode == USB_MODE_Host)
157
        {
158
                #if defined(USB_CAN_BE_HOST)
159
                UHWCON &= ~(1 << UIMOD);
160

    
161
                if (!(USB_Options & USB_OPT_MANUAL_PLL))
162
                {
163
                        #if defined(USB_CAN_BE_HOST)
164
                        USB_PLL_On();
165
                        while (!(USB_PLL_IsReady()));                
166
                        #endif
167
                }
168

    
169
                USB_Init_Host();
170
                #endif
171
        }
172

    
173
        #if (defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR))
174
        USB_OTGPAD_On();
175
        #endif
176
}
177

    
178
#if defined(USB_CAN_BE_DEVICE)
179
static void USB_Init_Device(void)
180
{
181
        USB_DeviceState                 = DEVICE_STATE_Unattached;
182
        USB_Device_ConfigurationNumber  = 0;
183

    
184
        #if !defined(NO_DEVICE_REMOTE_WAKEUP)
185
        USB_Device_RemoteWakeupEnabled  = false;
186
        #endif
187

    
188
        #if !defined(NO_DEVICE_SELF_POWER)
189
        USB_Device_CurrentlySelfPowered = false;
190
        #endif
191

    
192
        #if !defined(FIXED_CONTROL_ENDPOINT_SIZE)
193
        USB_Descriptor_Device_t* DeviceDescriptorPtr;
194
        
195
        #if defined(ARCH_HAS_MULTI_ADDRESS_SPACE) && \
196
            !(defined(USE_FLASH_DESCRIPTORS) || defined(USE_EEPROM_DESCRIPTORS) || defined(USE_RAM_DESCRIPTORS))
197
        uint8_t DescriptorAddressSpace;
198

    
199
        if (CALLBACK_USB_GetDescriptor((DTYPE_Device << 8), 0, (void*)&DeviceDescriptorPtr, &DescriptorAddressSpace) != NO_DESCRIPTOR)
200
        {
201
                if (DescriptorAddressSpace == MEMSPACE_FLASH)
202
                  USB_Device_ControlEndpointSize = pgm_read_byte(&DeviceDescriptorPtr->Endpoint0Size);
203
                else if (DescriptorAddressSpace == MEMSPACE_EEPROM)
204
                  USB_Device_ControlEndpointSize = eeprom_read_byte(&DeviceDescriptorPtr->Endpoint0Size);
205
                else
206
                  USB_Device_ControlEndpointSize = DeviceDescriptorPtr->Endpoint0Size;
207
        }
208
        #else
209
        if (CALLBACK_USB_GetDescriptor((DTYPE_Device << 8), 0, (void*)&DeviceDescriptorPtr) != NO_DESCRIPTOR)
210
        {
211
                #if defined(USE_RAM_DESCRIPTORS)
212
                USB_Device_ControlEndpointSize = DeviceDescriptorPtr->Endpoint0Size;
213
                #elif defined(USE_EEPROM_DESCRIPTORS)
214
                USB_Device_ControlEndpointSize = eeprom_read_byte(&DeviceDescriptorPtr->Endpoint0Size);
215
                #else
216
                USB_Device_ControlEndpointSize = pgm_read_byte(&DeviceDescriptorPtr->Endpoint0Size);
217
                #endif
218
        }        
219
        #endif
220
        #endif
221

    
222
        #if (defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR))
223
        if (USB_Options & USB_DEVICE_OPT_LOWSPEED)
224
          USB_Device_SetLowSpeed();
225
        else
226
          USB_Device_SetFullSpeed();
227

    
228
        USB_INT_Enable(USB_INT_VBUSTI);
229
        #endif
230

    
231
        Endpoint_ConfigureEndpoint(ENDPOINT_CONTROLEP, EP_TYPE_CONTROL,
232
                                                           ENDPOINT_DIR_OUT, USB_Device_ControlEndpointSize,
233
                                                           ENDPOINT_BANK_SINGLE);
234

    
235
        USB_INT_Clear(USB_INT_SUSPI);
236
        USB_INT_Enable(USB_INT_SUSPI);
237
        USB_INT_Enable(USB_INT_EORSTI);
238

    
239
        USB_Attach();
240
}
241
#endif
242

    
243
#if defined(USB_CAN_BE_HOST)
244
static void USB_Init_Host(void)
245
{
246
        USB_HostState                = HOST_STATE_Unattached;
247
        USB_Host_ConfigurationNumber = 0;
248
        USB_Host_ControlPipeSize     = PIPE_CONTROLPIPE_DEFAULT_SIZE;
249

    
250
        USB_Host_HostMode_On();
251

    
252
        USB_Host_VBUS_Auto_Off();
253
        USB_Host_VBUS_Manual_Enable();
254
        USB_Host_VBUS_Manual_On();
255

    
256
        USB_INT_Enable(USB_INT_SRPI);
257
        USB_INT_Enable(USB_INT_BCERRI);
258
        
259
        USB_Attach();
260
}
261
#endif
262