USBController_UC3B.c 5.16 KB
Newer Older
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
/*
             LUFA Library
     Copyright (C) Dean Camera, 2011.

  dean [at] fourwalledcubicle [dot] com
           www.lufa-lib.org
*/

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

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

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

#define  __INCLUDE_FROM_USB_DRIVER
#define  __INCLUDE_FROM_USB_CONTROLLER_C
#include "../USBController.h"

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

#if !defined(USE_STATIC_OPTIONS)
volatile uint8_t USB_Options;
#endif

void USB_Init(
               #if defined(USB_CAN_BE_BOTH)
               const uint8_t Mode
               #endif

               #if (defined(USB_CAN_BE_BOTH) && !defined(USE_STATIC_OPTIONS))
               ,
               #elif (!defined(USB_CAN_BE_BOTH) && defined(USE_STATIC_OPTIONS))
               void
               #endif

               #if !defined(USE_STATIC_OPTIONS)
               const uint8_t Options
               #endif
               )
{
	#if !defined(USE_STATIC_OPTIONS)
	USB_Options = Options;
	#endif
62
	
63 64 65
	#if defined(USB_CAN_BE_BOTH)
	if (Mode == USB_MODE_UID)
	{
66
		AVR32_USBB.USBCON.uide = true;
67 68 69 70 71
		USB_INT_Enable(USB_INT_IDTI);
		USB_CurrentMode = USB_GetUSBModeFromUID();
	}
	else
	{
72
		AVR32_USBB.USBCON.uide = false;
73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
		USB_CurrentMode = Mode;
	}
	#endif

	USB_IsInitialized = true;

	USB_ResetInterface();
}

void USB_Disable(void)
{
	USB_INT_DisableAllInterrupts();
	USB_INT_ClearAllInterrupts();

	USB_Detach();
	USB_Controller_Disable();

	USB_OTGPAD_Off();

	#if defined(USB_CAN_BE_BOTH)
	USB_CurrentMode = USB_MODE_None;
	#endif

96 97
	AVR32_PM.GCCTRL[3].cen = false;

98 99 100 101 102 103
	USB_IsInitialized = false;
}

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

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

113 114 115 116 117
	USB_INT_DisableAllInterrupts();
	USB_INT_ClearAllInterrupts();

	USB_Controller_Reset();

118 119 120
	#if defined(USB_CAN_BE_BOTH)
	if (UIDModeSelectEnabled)
	{
121
		AVR32_USBB.USBCON.uide = true;
122 123 124 125 126 127 128 129 130
		USB_INT_Enable(USB_INT_IDTI);
	}
	#endif

	USB_CLK_Unfreeze();

	if (USB_CurrentMode == USB_MODE_Device)
	{
		#if defined(USB_CAN_BE_DEVICE)
131
		AVR32_USBB.USBCON.uimod = true;
132 133 134 135 136 137
		USB_Init_Device();
		#endif
	}
	else if (USB_CurrentMode == USB_MODE_Host)
	{
		#if defined(USB_CAN_BE_HOST)
138
		AVR32_USBB.USBCON.uimod = false;
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
		USB_Init_Host();
		#endif
	}

	USB_OTGPAD_On();
}

#if defined(USB_CAN_BE_DEVICE)
static void USB_Init_Device(void)
{
	USB_DeviceState          = DEVICE_STATE_Unattached;
	USB_ConfigurationNumber  = 0;

	#if !defined(NO_DEVICE_REMOTE_WAKEUP)
	USB_RemoteWakeupEnabled  = false;
	#endif

	#if !defined(NO_DEVICE_SELF_POWER)
	USB_CurrentlySelfPowered = false;
	#endif

	#if !defined(FIXED_CONTROL_ENDPOINT_SIZE)
	USB_Descriptor_Device_t* DeviceDescriptorPtr;

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

	if (USB_Options & USB_DEVICE_OPT_LOWSPEED)
	  USB_Device_SetLowSpeed();
	else
	  USB_Device_SetFullSpeed();

172
	USB_INT_Enable(USB_INT_VBUSTI);
173 174 175 176 177 178 179 180 181 182

	Endpoint_ConfigureEndpoint(ENDPOINT_CONTROLEP, EP_TYPE_CONTROL,
							   ENDPOINT_DIR_OUT, USB_ControlEndpointSize,
							   ENDPOINT_BANK_SINGLE);

	USB_INT_Clear(USB_INT_SUSPI);
	USB_INT_Enable(USB_INT_SUSPI);
	USB_INT_Enable(USB_INT_EORSTI);

	USB_Attach();
183
	USB_Device_SetDeviceAddress(0);
184 185 186 187 188 189 190 191 192 193 194
}
#endif

#if defined(USB_CAN_BE_HOST)
static void USB_Init_Host(void)
{
	USB_HostState       = HOST_STATE_Unattached;
	USB_ControlPipeSize = PIPE_CONTROLPIPE_DEFAULT_SIZE;

	USB_Host_HostMode_On();

195
	USB_Host_VBUS_Auto_On();
196

197
	USB_INT_Enable(USB_INT_DCONNI);
198 199 200 201 202 203
	USB_INT_Enable(USB_INT_BCERRI);

	USB_Attach();
}
#endif