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_ClearEndpoints();
 146
 147                 Endpoint_ConfigureEndpoint(ENDPOINT_CONTROLEP, EP_TYPE_CONTROL,
 148                                            ENDPOINT_DIR_OUT, USB_ControlEndpointSize,
 149                                            ENDPOINT_BANK_SINGLE);
 150
 151                 #if defined(INTERRUPT_CONTROL_ENDPOINT)
 152                 USB_INT_Enable(USB_INT_RXSTPI);
 153                 #endif
 154
 155                 EVENT_USB_Device_Reset();
 156         }
 157
 158         if (USB_INT_HasOccurred(USB_INT_SOFI) && USB_INT_IsEnabled(USB_INT_SOFI))
 159         {
 160                 USB_INT_Clear(USB_INT_SOFI);
 161
 162                 EVENT_USB_Device_StartOfFrame();
 163         }
 164         #endif
 165
 166         #if defined(USB_CAN_BE_HOST)
 167         if (USB_INT_HasOccurred(USB_INT_DDISCI) && USB_INT_IsEnabled(USB_INT_DDISCI))
 168         {
 169                 USB_INT_Clear(USB_INT_DDISCI);
 170                 USB_INT_Clear(USB_INT_DCONNI);
 171                 USB_INT_Disable(USB_INT_DDISCI);
 172
 173                 EVENT_USB_Host_DeviceUnattached();
 174
 175                 USB_ResetInterface();
 176         }
 177
 178         if (USB_INT_HasOccurred(USB_INT_VBERRI) && USB_INT_IsEnabled(USB_INT_VBERRI))
 179         {
 180                 USB_INT_Clear(USB_INT_VBERRI);
 181
 182                 USB_Host_VBUS_Manual_Off();
 183                 USB_Host_VBUS_Auto_Off();
 184
 185                 EVENT_USB_Host_HostError(HOST_ERROR_VBusVoltageDip);
 186                 EVENT_USB_Host_DeviceUnattached();
 187
 188                 USB_HostState = HOST_STATE_Unattached;
 189         }
 190
 191         if (USB_INT_HasOccurred(USB_INT_SRPI) && USB_INT_IsEnabled(USB_INT_SRPI))
 192         {
 193                 USB_INT_Clear(USB_INT_SRPI);
 194                 USB_INT_Disable(USB_INT_SRPI);
 195
 196                 EVENT_USB_Host_DeviceAttached();
 197
 198                 USB_INT_Enable(USB_INT_DDISCI);
 199
 200                 USB_HostState = HOST_STATE_Powered;
 201         }
 202
 203         if (USB_INT_HasOccurred(USB_INT_BCERRI) && USB_INT_IsEnabled(USB_INT_BCERRI))
 204         {
 205                 USB_INT_Clear(USB_INT_BCERRI);
 206
 207                 EVENT_USB_Host_DeviceEnumerationFailed(HOST_ENUMERROR_NoDeviceDetected, 0);
 208                 EVENT_USB_Host_DeviceUnattached();
 209
 210                 USB_ResetInterface();
 211         }
 212         #endif
 213
 214         #if defined(USB_CAN_BE_BOTH)
 215         if (USB_INT_HasOccurred(USB_INT_IDTI) && USB_INT_IsEnabled(USB_INT_IDTI))
 216         {
 217                 USB_INT_Clear(USB_INT_IDTI);
 218
 219                 if (USB_DeviceState != DEVICE_STATE_Unattached)
 220                   EVENT_USB_Device_Disconnect();
 221
 222                 if (USB_HostState != HOST_STATE_Unattached)
 223                   EVENT_USB_Host_DeviceUnattached();
 224
 225                 USB_CurrentMode = USB_GetUSBModeFromUID();
 226                 EVENT_USB_UIDChange();
 227
 228                 USB_ResetInterface();
 229         }
 230         #endif
 231 }
 232
 233 #if defined(INTERRUPT_CONTROL_ENDPOINT) && defined(USB_CAN_BE_DEVICE)
 234 ISR(USB_COM_vect, ISR_BLOCK)
 235 {
 236         uint8_t PrevSelectedEndpoint = Endpoint_GetCurrentEndpoint();
 237
 238         Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
 239         USB_INT_Disable(USB_INT_RXSTPI);
 240
 241         NONATOMIC_BLOCK(NONATOMIC_FORCEOFF)
 242         {
 243                 USB_Device_ProcessControlRequest();
 244         }
 245
 246         Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
 247         USB_INT_Enable(USB_INT_RXSTPI);
 248         Endpoint_SelectEndpoint(PrevSelectedEndpoint);
 249 }
 250 #endif