LUFA/Drivers/USB/LowLevel/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(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR)
  55         USBINT  = 0;
  56         #endif
  57
  58         #if defined(USB_CAN_BE_HOST)
  59         UHINT   = 0;
  60         OTGINT  = 0;
  61         #endif
  62
  63         #if defined(USB_CAN_BE_DEVICE)
  64         UDINT   = 0;
  65         #endif
  66 }
  67
  68 ISR(USB_GEN_vect, ISR_BLOCK)
  69 {
  70         #if defined(USB_CAN_BE_DEVICE)
  71         #if defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR)
  72         if (USB_INT_HasOccurred(USB_INT_VBUS) && USB_INT_IsEnabled(USB_INT_VBUS))
  73         {
  74                 USB_INT_Clear(USB_INT_VBUS);
  75
  76                 if (USB_VBUS_GetStatus())
  77                 {
  78                         USB_DeviceState = DEVICE_STATE_Powered;
  79                         EVENT_USB_Device_Connect();
  80                 }
  81                 else
  82                 {
  83                         USB_DeviceState = DEVICE_STATE_Unattached;
  84                         EVENT_USB_Device_Disconnect();
  85                 }
  86         }
  87         #endif
  88
  89         if (USB_INT_HasOccurred(USB_INT_SUSPEND) && USB_INT_IsEnabled(USB_INT_SUSPEND))
  90         {
  91                 USB_INT_Clear(USB_INT_SUSPEND);
  92
  93                 USB_INT_Disable(USB_INT_SUSPEND);
  94                 USB_INT_Enable(USB_INT_WAKEUP);
  95
  96                 USB_CLK_Freeze();
  97
  98                 if (!(USB_Options & USB_OPT_MANUAL_PLL))
  99                   USB_PLL_Off();
 100
 101                 #if defined(USB_SERIES_2_AVR) && !defined(NO_LIMITED_CONTROLLER_CONNECT)
 102                 USB_DeviceState = DEVICE_STATE_Unattached;
 103                 EVENT_USB_Device_Disconnect();
 104                 #else
 105                 USB_DeviceState = DEVICE_STATE_Suspended;
 106                 EVENT_USB_Device_Suspend();
 107                 #endif
 108         }
 109
 110         if (USB_INT_HasOccurred(USB_INT_WAKEUP) && USB_INT_IsEnabled(USB_INT_WAKEUP))
 111         {
 112                 if (!(USB_Options & USB_OPT_MANUAL_PLL))
 113                 {
 114                         USB_PLL_On();
 115                         while (!(USB_PLL_IsReady()));
 116                 }
 117
 118                 USB_CLK_Unfreeze();
 119
 120                 USB_INT_Clear(USB_INT_WAKEUP);
 121
 122                 USB_INT_Disable(USB_INT_WAKEUP);
 123                 USB_INT_Enable(USB_INT_SUSPEND);
 124
 125                 #if defined(USB_SERIES_2_AVR) && !defined(NO_LIMITED_CONTROLLER_CONNECT)
 126                 USB_DeviceState = (USB_ConfigurationNumber) ? DEVICE_STATE_Configured : DEVICE_STATE_Powered;
 127                 EVENT_USB_Device_Connect();
 128                 #else
 129                 USB_DeviceState = (USB_ConfigurationNumber) ? DEVICE_STATE_Configured : DEVICE_STATE_Addressed;
 130                 EVENT_USB_Device_WakeUp();
 131                 #endif
 132         }
 133
 134         if (USB_INT_HasOccurred(USB_INT_EORSTI) && USB_INT_IsEnabled(USB_INT_EORSTI))
 135         {
 136                 USB_INT_Clear(USB_INT_EORSTI);
 137
 138                 USB_DeviceState         = DEVICE_STATE_Default;
 139                 USB_ConfigurationNumber = 0;
 140
 141                 USB_INT_Clear(USB_INT_SUSPEND);
 142                 USB_INT_Disable(USB_INT_SUSPEND);
 143                 USB_INT_Enable(USB_INT_WAKEUP);
 144
 145                 Endpoint_ConfigureEndpoint(ENDPOINT_CONTROLEP, EP_TYPE_CONTROL,
 146                                            ENDPOINT_DIR_OUT, USB_ControlEndpointSize,
 147                                            ENDPOINT_BANK_SINGLE);
 148
 149                 #if defined(INTERRUPT_CONTROL_ENDPOINT)
 150                 USB_INT_Enable(USB_INT_RXSTPI);
 151                 #endif
 152
 153                 EVENT_USB_Device_Reset();
 154         }
 155
 156         if (USB_INT_HasOccurred(USB_INT_SOFI) && USB_INT_IsEnabled(USB_INT_SOFI))
 157         {
 158                 USB_INT_Clear(USB_INT_SOFI);
 159
 160                 EVENT_USB_Device_StartOfFrame();
 161         }
 162         #endif
 163
 164         #if defined(USB_CAN_BE_HOST)
 165         if (USB_INT_HasOccurred(USB_INT_DDISCI) && USB_INT_IsEnabled(USB_INT_DDISCI))
 166         {
 167                 USB_INT_Clear(USB_INT_DDISCI);
 168                 USB_INT_Clear(USB_INT_DCONNI);
 169                 USB_INT_Disable(USB_INT_DDISCI);
 170
 171                 EVENT_USB_Host_DeviceUnattached();
 172
 173                 USB_ResetInterface();
 174         }
 175
 176         if (USB_INT_HasOccurred(USB_INT_VBERRI) && USB_INT_IsEnabled(USB_INT_VBERRI))
 177         {
 178                 USB_INT_Clear(USB_INT_VBERRI);
 179
 180                 USB_Host_VBUS_Manual_Off();
 181                 USB_Host_VBUS_Auto_Off();
 182
 183                 EVENT_USB_Host_HostError(HOST_ERROR_VBusVoltageDip);
 184                 EVENT_USB_Host_DeviceUnattached();
 185
 186                 USB_HostState = HOST_STATE_Unattached;
 187         }
 188
 189         if (USB_INT_HasOccurred(USB_INT_SRPI) && USB_INT_IsEnabled(USB_INT_SRPI))
 190         {
 191                 USB_INT_Clear(USB_INT_SRPI);
 192                 USB_INT_Disable(USB_INT_SRPI);
 193
 194                 EVENT_USB_Host_DeviceAttached();
 195
 196                 USB_INT_Enable(USB_INT_DDISCI);
 197
 198                 USB_HostState = HOST_STATE_Powered;
 199         }
 200
 201         if (USB_INT_HasOccurred(USB_INT_BCERRI) && USB_INT_IsEnabled(USB_INT_BCERRI))
 202         {
 203                 USB_INT_Clear(USB_INT_BCERRI);
 204
 205                 EVENT_USB_Host_DeviceEnumerationFailed(HOST_ENUMERROR_NoDeviceDetected, 0);
 206                 EVENT_USB_Host_DeviceUnattached();
 207
 208                 USB_ResetInterface();
 209         }
 210
 211         if (USB_INT_HasOccurred(USB_INT_HSOFI) && USB_INT_IsEnabled(USB_INT_HSOFI))
 212         {
 213                 USB_INT_Clear(USB_INT_HSOFI);
 214
 215                 EVENT_USB_Host_StartOfFrame();
 216         }
 217         #endif
 218
 219         #if defined(USB_CAN_BE_BOTH)
 220         if (USB_INT_HasOccurred(USB_INT_IDTI) && USB_INT_IsEnabled(USB_INT_IDTI))
 221         {
 222                 USB_INT_Clear(USB_INT_IDTI);
 223
 224                 if (USB_DeviceState != DEVICE_STATE_Unattached)
 225                   EVENT_USB_Device_Disconnect();
 226
 227                 if (USB_HostState != HOST_STATE_Unattached)
 228                   EVENT_USB_Host_DeviceUnattached();
 229
 230                 USB_CurrentMode = USB_GetUSBModeFromUID();
 231                 EVENT_USB_UIDChange();
 232
 233                 USB_ResetInterface();
 234         }
 235         #endif
 236 }
 237
 238 #if defined(INTERRUPT_CONTROL_ENDPOINT) && defined(USB_CAN_BE_DEVICE)
 239 ISR(USB_COM_vect, ISR_BLOCK)
 240 {
 241         uint8_t PrevSelectedEndpoint = Endpoint_GetCurrentEndpoint();
 242
 243         Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
 244         USB_INT_Disable(USB_INT_RXSTPI);
 245
 246         NONATOMIC_BLOCK(NONATOMIC_FORCEOFF)
 247         {
 248                 USB_Device_ProcessControlRequest();
 249         }
 250
 251         Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
 252         USB_INT_Enable(USB_INT_RXSTPI);
 253         Endpoint_SelectEndpoint(PrevSelectedEndpoint);
 254 }
 255 #endif