LUFA/Drivers/USB/HighLevel/USBInterrupt.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2010.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6       www.fourwalledcubicle.com
   7 */
   8
   9 /*
  10   Copyright 2010  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 "USBInterrupt.h"
  33
  34 void USB_INT_DisableAllInterrupts(void)
  35 {
  36         #if defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR)
  37         USBCON &= ~((1 << VBUSTE) | (1 << IDTE));
  38         #elif defined(USB_SERIES_4_AVR)
  39         USBCON &= ~(1 << VBUSTE);
  40         #endif
  41
  42         #if defined(USB_CAN_BE_HOST)
  43         UHIEN   = 0;
  44         OTGIEN  = 0;
  45         #endif
  46
  47         #if defined(USB_CAN_BE_DEVICE)
  48         UDIEN   = 0;
  49         #endif
  50 }
  51
  52 void USB_INT_ClearAllInterrupts(void)
  53 {
  54         #if defined(__AVR32__)
  55                 AVR32_USBB.USBSTACLR = 0xFFFFFF;
  56                 AVR32_USBB.UHINTCLR = 0xFFFFFF;
  57                 AVR32_USBB.UECONX =
  58                 AVR32_USBB.UDINTCLR = 0xFFFFFF;
  59         #elif defined(__AVR__)
  60                 #if defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR)
  61                 USBINT  = 0;
  62                 #endif
  63
  64                 #if defined(USB_CAN_BE_HOST)
  65                 UHINT   = 0;
  66                 OTGINT  = 0;
  67                 #endif
  68
  69                 #if defined(USB_CAN_BE_DEVICE)
  70                 UDINT   = 0;
  71                 #endif
  72         #endif
  73 }
  74
  75 ISR(USB_GEN_vect, ISR_BLOCK)
  76 {
  77         #if defined(USB_CAN_BE_DEVICE)
  78         #if defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR)
  79         if (USB_INT_HasOccurred(USB_INT_VBUS) && USB_INT_IsEnabled(USB_INT_VBUS))
  80         {
  81                 USB_INT_Clear(USB_INT_VBUS);
  82
  83                 if (USB_VBUS_GetStatus())
  84                 {
  85                         USB_DeviceState = DEVICE_STATE_Powered;
  86                         EVENT_USB_Device_Connect();
  87                 }
  88                 else
  89                 {
  90                         USB_DeviceState = DEVICE_STATE_Unattached;
  91                         EVENT_USB_Device_Disconnect();
  92                 }
  93         }
  94         #endif
  95
  96         if (USB_INT_HasOccurred(USB_INT_SUSPEND) && USB_INT_IsEnabled(USB_INT_SUSPEND))
  97         {
  98                 USB_INT_Clear(USB_INT_SUSPEND);
  99
 100                 USB_INT_Disable(USB_INT_SUSPEND);
 101                 USB_INT_Enable(USB_INT_WAKEUP);
 102
 103                 USB_CLK_Freeze();
 104
 105                 if (!(USB_Options & USB_OPT_MANUAL_PLL))
 106                   USB_PLL_Off();
 107
 108                 #if defined(USB_SERIES_2_AVR) && !defined(NO_LIMITED_CONTROLLER_CONNECT)
 109                 USB_DeviceState = DEVICE_STATE_Unattached;
 110                 EVENT_USB_Device_Disconnect();
 111                 #else
 112                 USB_DeviceState = DEVICE_STATE_Suspended;
 113                 EVENT_USB_Device_Suspend();
 114                 #endif
 115         }
 116
 117         if (USB_INT_HasOccurred(USB_INT_WAKEUP) && USB_INT_IsEnabled(USB_INT_WAKEUP))
 118         {
 119                 if (!(USB_Options & USB_OPT_MANUAL_PLL))
 120                 {
 121                         USB_PLL_On();
 122                         while (!(USB_PLL_IsReady()));
 123                 }
 124
 125                 USB_CLK_Unfreeze();
 126
 127                 USB_INT_Clear(USB_INT_WAKEUP);
 128
 129                 USB_INT_Disable(USB_INT_WAKEUP);
 130                 USB_INT_Enable(USB_INT_SUSPEND);
 131
 132                 #if defined(USB_SERIES_2_AVR) && !defined(NO_LIMITED_CONTROLLER_CONNECT)
 133                 USB_DeviceState = (USB_ConfigurationNumber) ? DEVICE_STATE_Configured : DEVICE_STATE_Powered;
 134                 EVENT_USB_Device_Connect();
 135                 #else
 136                 USB_DeviceState = (USB_ConfigurationNumber) ? DEVICE_STATE_Configured : DEVICE_STATE_Addressed;
 137                 EVENT_USB_Device_WakeUp();
 138                 #endif
 139         }
 140
 141         if (USB_INT_HasOccurred(USB_INT_EORSTI) && USB_INT_IsEnabled(USB_INT_EORSTI))
 142         {
 143                 USB_INT_Clear(USB_INT_EORSTI);
 144
 145                 USB_DeviceState         = DEVICE_STATE_Default;
 146                 USB_ConfigurationNumber = 0;
 147
 148                 USB_INT_Clear(USB_INT_SUSPEND);
 149                 USB_INT_Disable(USB_INT_SUSPEND);
 150                 USB_INT_Enable(USB_INT_WAKEUP);
 151
 152                 Endpoint_ClearEndpoints();
 153
 154                 Endpoint_ConfigureEndpoint(ENDPOINT_CONTROLEP, EP_TYPE_CONTROL,
 155                                            ENDPOINT_DIR_OUT, USB_ControlEndpointSize,
 156                                            ENDPOINT_BANK_SINGLE);
 157
 158                 #if defined(INTERRUPT_CONTROL_ENDPOINT)
 159                 USB_INT_Enable(USB_INT_RXSTPI);
 160                 #endif
 161
 162                 EVENT_USB_Device_Reset();
 163         }
 164
 165         if (USB_INT_HasOccurred(USB_INT_SOFI) && USB_INT_IsEnabled(USB_INT_SOFI))
 166         {
 167                 USB_INT_Clear(USB_INT_SOFI);
 168
 169                 EVENT_USB_Device_StartOfFrame();
 170         }
 171         #endif
 172
 173         #if defined(USB_CAN_BE_HOST)
 174         if (USB_INT_HasOccurred(USB_INT_DDISCI) && USB_INT_IsEnabled(USB_INT_DDISCI))
 175         {
 176                 USB_INT_Clear(USB_INT_DDISCI);
 177                 USB_INT_Clear(USB_INT_DCONNI);
 178                 USB_INT_Disable(USB_INT_DDISCI);
 179
 180                 EVENT_USB_Host_DeviceUnattached();
 181
 182                 USB_ResetInterface();
 183         }
 184
 185         if (USB_INT_HasOccurred(USB_INT_VBERRI) && USB_INT_IsEnabled(USB_INT_VBERRI))
 186         {
 187                 USB_INT_Clear(USB_INT_VBERRI);
 188
 189                 USB_Host_VBUS_Manual_Off();
 190                 USB_Host_VBUS_Auto_Off();
 191
 192                 EVENT_USB_Host_HostError(HOST_ERROR_VBusVoltageDip);
 193                 EVENT_USB_Host_DeviceUnattached();
 194
 195                 USB_HostState = HOST_STATE_Unattached;
 196         }
 197
 198         if (USB_INT_HasOccurred(USB_INT_SRPI) && USB_INT_IsEnabled(USB_INT_SRPI))
 199         {
 200                 USB_INT_Clear(USB_INT_SRPI);
 201                 USB_INT_Disable(USB_INT_SRPI);
 202
 203                 EVENT_USB_Host_DeviceAttached();
 204
 205                 USB_INT_Enable(USB_INT_DDISCI);
 206
 207                 USB_HostState = HOST_STATE_Powered;
 208         }
 209
 210         if (USB_INT_HasOccurred(USB_INT_BCERRI) && USB_INT_IsEnabled(USB_INT_BCERRI))
 211         {
 212                 USB_INT_Clear(USB_INT_BCERRI);
 213
 214                 EVENT_USB_Host_DeviceEnumerationFailed(HOST_ENUMERROR_NoDeviceDetected, 0);
 215                 EVENT_USB_Host_DeviceUnattached();
 216
 217                 USB_ResetInterface();
 218         }
 219         #endif
 220
 221         #if defined(USB_CAN_BE_BOTH)
 222         if (USB_INT_HasOccurred(USB_INT_IDTI) && USB_INT_IsEnabled(USB_INT_IDTI))
 223         {
 224                 USB_INT_Clear(USB_INT_IDTI);
 225
 226                 if (USB_DeviceState != DEVICE_STATE_Unattached)
 227                   EVENT_USB_Device_Disconnect();
 228
 229                 if (USB_HostState != HOST_STATE_Unattached)
 230                   EVENT_USB_Host_DeviceUnattached();
 231
 232                 USB_CurrentMode = USB_GetUSBModeFromUID();
 233                 EVENT_USB_UIDChange();
 234
 235                 USB_ResetInterface();
 236         }
 237         #endif
 238 }
 239
 240 #if defined(INTERRUPT_CONTROL_ENDPOINT) && defined(USB_CAN_BE_DEVICE)
 241 ISR(USB_COM_vect, ISR_BLOCK)
 242 {
 243         uint8_t PrevSelectedEndpoint = Endpoint_GetCurrentEndpoint();
 244
 245         USB_USBTask();
 246
 247         USB_INT_Clear(USB_INT_RXSTPI);
 248
 249         Endpoint_SelectEndpoint(PrevSelectedEndpoint);
 250 }
 251 #endif