LUFA/Drivers/USB/HighLevel/USBInterrupt.c

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