Statistics
| Branch: | Tag: | Revision:

root / LUFA / Drivers / USB / Core / XMEGA / USBController_XMEGA.c @ 978b99e5

History | View | Annotate | Download (5.35 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
USB_EP_TABLE_t USB_EndpointTable ATTR_ALIGNED(4);
44

    
45
void USB_Init(
46
               #if defined(USB_CAN_BE_BOTH)
47
               const uint8_t Mode
48
               #endif
49

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

    
56
               #if !defined(USE_STATIC_OPTIONS)
57
               const uint8_t Options
58
               #endif
59
               )
60
{
61
        #if !defined(USE_STATIC_OPTIONS)
62
        USB_Options = Options;
63
        #endif
64
        
65
        USB_IsInitialized = true;
66
        
67
        uint_reg_t CurrentGlobalInt = GetGlobalInterruptMask();
68
        GlobalInterruptDisable();
69

    
70
        NVM.CMD  = NVM_CMD_READ_CALIB_ROW_gc;
71
        USB.CAL0 = pgm_read_byte(offsetof(NVM_PROD_SIGNATURES_t, USBCAL0));
72
        NVM.CMD  = NVM_CMD_READ_CALIB_ROW_gc;
73
        USB.CAL1 = pgm_read_byte(offsetof(NVM_PROD_SIGNATURES_t, USBCAL1));
74
        
75
        USB.EPPTR = (intptr_t)&USB_EndpointTable;
76

    
77
        if ((USB_Options & USB_OPT_BUSEVENT_PRIHIGH) == USB_OPT_BUSEVENT_PRIHIGH)
78
          USB.INTCTRLA = (3 << USB_INTLVL_gp);
79
        else if ((USB_Options & USB_OPT_BUSEVENT_PRIMED) == USB_OPT_BUSEVENT_PRIMED)
80
          USB.INTCTRLA = (2 << USB_INTLVL_gp);
81
        else
82
          USB.INTCTRLA = (1 << USB_INTLVL_gp);
83

    
84
        SetGlobalInterruptMask(CurrentGlobalInt);
85

    
86
        USB_ResetInterface();
87
}
88

    
89
void USB_Disable(void)
90
{
91
        USB_INT_DisableAllInterrupts();
92
        USB_INT_ClearAllInterrupts();
93

    
94
        USB_Detach();
95
        USB_Controller_Disable();
96

    
97
        USB_IsInitialized = false;        
98
}
99

    
100
void USB_ResetInterface(void)
101
{
102
        if (USB_Options & USB_DEVICE_OPT_LOWSPEED)
103
          CLK.USBCTRL = ((((F_USB / 6000000) - 1) << CLK_USBPSDIV_gp) | CLK_USBSRC_PLL_gc | CLK_USBSEN_bm);
104
        else
105
          CLK.USBCTRL = ((((F_USB / 48000000) - 1) << CLK_USBPSDIV_gp) | CLK_USBSRC_PLL_gc | CLK_USBSEN_bm);
106
        
107
        USB_Device_SetDeviceAddress(0);
108
        
109
        USB_INT_DisableAllInterrupts();
110
        USB_INT_ClearAllInterrupts();
111

    
112
        USB_Controller_Reset();
113
        USB_Init_Device();
114
}
115

    
116
#if defined(USB_CAN_BE_DEVICE)
117
static void USB_Init_Device(void)
118
{
119
        USB_DeviceState                 = DEVICE_STATE_Unattached;
120
        USB_Device_ConfigurationNumber  = 0;
121

    
122
        #if !defined(NO_DEVICE_REMOTE_WAKEUP)
123
        USB_Device_RemoteWakeupEnabled  = false;
124
        #endif
125

    
126
        #if !defined(NO_DEVICE_SELF_POWER)
127
        USB_Device_CurrentlySelfPowered = false;
128
        #endif
129

    
130
        #if !defined(FIXED_CONTROL_ENDPOINT_SIZE)
131
        USB_Descriptor_Device_t* DeviceDescriptorPtr;
132
        
133
        #if defined(ARCH_HAS_MULTI_ADDRESS_SPACE) && \
134
            !(defined(USE_FLASH_DESCRIPTORS) || defined(USE_EEPROM_DESCRIPTORS) || defined(USE_RAM_DESCRIPTORS))
135
        uint8_t DescriptorAddressSpace;
136

    
137
        if (CALLBACK_USB_GetDescriptor((DTYPE_Device << 8), 0, (void*)&DeviceDescriptorPtr, &DescriptorAddressSpace) != NO_DESCRIPTOR)
138
        {
139
                if (DescriptorAddressSpace == MEMSPACE_FLASH)
140
                  USB_Device_ControlEndpointSize = pgm_read_byte(&DeviceDescriptorPtr->Endpoint0Size);
141
                else if (DescriptorAddressSpace == MEMSPACE_EEPROM)
142
                  USB_Device_ControlEndpointSize = eeprom_read_byte(&DeviceDescriptorPtr->Endpoint0Size);
143
                else
144
                  USB_Device_ControlEndpointSize = DeviceDescriptorPtr->Endpoint0Size;
145
        }
146
        #else
147
        if (CALLBACK_USB_GetDescriptor((DTYPE_Device << 8), 0, (void*)&DeviceDescriptorPtr) != NO_DESCRIPTOR)
148
        {
149
                #if defined(USE_RAM_DESCRIPTORS)
150
                USB_Device_ControlEndpointSize = DeviceDescriptorPtr->Endpoint0Size;
151
                #elif defined(USE_EEPROM_DESCRIPTORS)
152
                USB_Device_ControlEndpointSize = eeprom_read_byte(&DeviceDescriptorPtr->Endpoint0Size);
153
                #else
154
                USB_Device_ControlEndpointSize = pgm_read_byte(&DeviceDescriptorPtr->Endpoint0Size);
155
                #endif
156
        }        
157
        #endif
158
        #endif
159

    
160
        if (USB_Options & USB_DEVICE_OPT_LOWSPEED)
161
          USB_Device_SetLowSpeed();
162
        else
163
          USB_Device_SetFullSpeed();
164

    
165
        Endpoint_ConfigureEndpoint(ENDPOINT_CONTROLEP, EP_TYPE_CONTROL,
166
                                                           ENDPOINT_DIR_OUT, USB_Device_ControlEndpointSize,
167
                                                           ENDPOINT_BANK_SINGLE);
168

    
169
        USB_INT_Enable(USB_INT_BUSEVENTI);
170

    
171
        USB_Attach();
172
}
173
#endif