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_FULL_CONTROLLER)
  36         USBCON &= ~((1 << VBUSTE) | (1 << IDTE));
  37         #elif defined(USB_MODIFIED_FULL_CONTROLLER)
  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_FULL_CONTROLLER) || defined(USB_MODIFIED_FULL_CONTROLLER)
  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_FULL_CONTROLLER) || defined(USB_MODIFIED_FULL_CONTROLLER)
  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_IsConnected)
  82                           EVENT_USB_Disconnect();
  83
  84                         USB_ResetInterface();
  85
  86                         USB_IsConnected = true;
  87
  88                         EVENT_USB_Connect();
  89                 }
  90                 else
  91                 {
  92                         USB_IsConnected = false;
  93
  94                         EVENT_USB_Disconnect();
  95
  96                         USB_Detach();
  97                         USB_CLK_Freeze();
  98                         USB_PLL_Off();
  99                         USB_REG_Off();
 100
 101                         EVENT_USB_VBUSDisconnect();
 102
 103                         USB_INT_Clear(USB_INT_VBUS);
 104                 }
 105         }
 106         #endif
 107
 108         if (USB_INT_HasOccurred(USB_INT_SUSPEND) && USB_INT_IsEnabled(USB_INT_SUSPEND))
 109         {
 110                 USB_INT_Clear(USB_INT_SUSPEND);
 111
 112                 USB_INT_Disable(USB_INT_SUSPEND);
 113                 USB_INT_Enable(USB_INT_WAKEUP);
 114
 115                 USB_CLK_Freeze();
 116
 117                 if (!(USB_Options & USB_OPT_MANUAL_PLL))
 118                   USB_PLL_Off();
 119
 120                 USB_IsSuspended = true;
 121
 122                 EVENT_USB_Suspend();
 123
 124                 #if defined(USB_LIMITED_CONTROLLER) && !defined(NO_LIMITED_CONTROLLER_CONNECT)
 125                 if (USB_IsConnected)
 126                 {
 127                         USB_IsConnected = false;
 128                         EVENT_USB_Disconnect();
 129                 }
 130                 #endif
 131         }
 132
 133         if (USB_INT_HasOccurred(USB_INT_WAKEUP) && USB_INT_IsEnabled(USB_INT_WAKEUP))
 134         {
 135                 if (!(USB_Options & USB_OPT_MANUAL_PLL))
 136                 {
 137                         USB_PLL_On();
 138                         while (!(USB_PLL_IsReady()));
 139                 }
 140
 141                 USB_CLK_Unfreeze();
 142
 143                 USB_INT_Clear(USB_INT_WAKEUP);
 144
 145                 USB_INT_Disable(USB_INT_WAKEUP);
 146                 USB_INT_Enable(USB_INT_SUSPEND);
 147
 148                 #if defined(USB_LIMITED_CONTROLLER) && !defined(NO_LIMITED_CONTROLLER_CONNECT)
 149                 if (!(USB_IsConnected))
 150                 {
 151                         USB_IsConnected = true;
 152                         EVENT_USB_Connect();
 153                 }
 154                 #endif
 155
 156                 USB_IsSuspended = false;
 157
 158                 EVENT_USB_WakeUp();
 159         }
 160
 161         if (USB_INT_HasOccurred(USB_INT_EORSTI) && USB_INT_IsEnabled(USB_INT_EORSTI))
 162         {
 163                 USB_INT_Clear(USB_INT_EORSTI);
 164
 165                 USB_ConfigurationNumber = 0;
 166
 167                 USB_INT_Clear(USB_INT_SUSPEND);
 168                 USB_INT_Disable(USB_INT_SUSPEND);
 169                 USB_INT_Enable(USB_INT_WAKEUP);
 170
 171                 Endpoint_ClearEndpoints();
 172
 173                 Endpoint_ConfigureEndpoint(ENDPOINT_CONTROLEP, EP_TYPE_CONTROL,
 174                                            ENDPOINT_DIR_OUT, USB_ControlEndpointSize,
 175                                            ENDPOINT_BANK_SINGLE);
 176
 177                 #if defined(INTERRUPT_CONTROL_ENDPOINT)
 178                 USB_INT_Enable(USB_INT_ENDPOINT_SETUP);
 179                 #endif
 180
 181                 EVENT_USB_Reset();
 182         }
 183
 184         if (USB_INT_HasOccurred(USB_INT_SOFI) && USB_INT_IsEnabled(USB_INT_SOFI))
 185         {
 186                 USB_INT_Clear(USB_INT_SOFI);
 187
 188                 FrameElapsed = true;
 189
 190                 EVENT_USB_StartOfFrame();
 191         }
 192         #endif
 193
 194         #if defined(USB_CAN_BE_HOST)
 195         if (USB_INT_HasOccurred(USB_INT_DDISCI) && USB_INT_IsEnabled(USB_INT_DDISCI))
 196         {
 197                 USB_INT_Clear(USB_INT_DDISCI);
 198                 USB_INT_Clear(USB_INT_DCONNI);
 199                 USB_INT_Disable(USB_INT_DDISCI);
 200
 201                 EVENT_USB_DeviceUnattached();
 202                 EVENT_USB_Disconnect();
 203
 204                 USB_ResetInterface();
 205         }
 206
 207         if (USB_INT_HasOccurred(USB_INT_VBERRI) && USB_INT_IsEnabled(USB_INT_VBERRI))
 208         {
 209                 USB_INT_Clear(USB_INT_VBERRI);
 210
 211                 USB_Host_VBUS_Manual_Off();
 212                 USB_Host_VBUS_Auto_Off();
 213
 214                 EVENT_USB_HostError(HOST_ERROR_VBusVoltageDip);
 215                 EVENT_USB_DeviceUnattached();
 216
 217                 USB_HostState = HOST_STATE_Unattached;
 218         }
 219
 220         if (USB_INT_HasOccurred(USB_INT_SRPI) && USB_INT_IsEnabled(USB_INT_SRPI))
 221         {
 222                 USB_INT_Clear(USB_INT_SRPI);
 223                 USB_INT_Disable(USB_INT_SRPI);
 224
 225                 EVENT_USB_DeviceAttached();
 226
 227                 USB_INT_Enable(USB_INT_DDISCI);
 228
 229                 USB_HostState = HOST_STATE_Attached;
 230         }
 231
 232         if (USB_INT_HasOccurred(USB_INT_BCERRI) && USB_INT_IsEnabled(USB_INT_BCERRI))
 233         {
 234                 USB_INT_Clear(USB_INT_BCERRI);
 235
 236                 EVENT_USB_DeviceEnumerationFailed(HOST_ENUMERROR_NoDeviceDetected, 0);
 237                 EVENT_USB_DeviceUnattached();
 238
 239                 if (USB_IsConnected)
 240                   EVENT_USB_Disconnect();
 241
 242                 USB_ResetInterface();
 243         }
 244
 245         if (USB_INT_HasOccurred(USB_INT_HSOFI) && USB_INT_IsEnabled(USB_INT_HSOFI))
 246         {
 247                 USB_INT_Clear(USB_INT_HSOFI);
 248
 249                 FrameElapsed = true;
 250
 251                 EVENT_USB_StartOfFrame();
 252         }
 253         #endif
 254
 255         #if defined(USB_CAN_BE_BOTH)
 256         if (USB_INT_HasOccurred(USB_INT_IDTI) && USB_INT_IsEnabled(USB_INT_IDTI))
 257         {
 258                 USB_INT_Clear(USB_INT_IDTI);
 259
 260                 if (USB_IsConnected)
 261                 {
 262                         if (USB_CurrentMode == USB_MODE_HOST)
 263                           EVENT_USB_DeviceUnattached();
 264                         else
 265                           EVENT_USB_Disconnect();
 266                 }
 267
 268                 EVENT_USB_UIDChange();
 269
 270                 USB_ResetInterface();
 271         }
 272         #endif
 273 }
 274
 275 #if defined(INTERRUPT_CONTROL_ENDPOINT)
 276 ISR(USB_COM_vect, ISR_BLOCK)
 277 {
 278         uint8_t PrevSelectedEndpoint = Endpoint_GetCurrentEndpoint();
 279
 280         USB_USBTask();
 281
 282         USB_INT_Clear(USB_INT_ENDPOINT_SETUP);
 283
 284         Endpoint_SelectEndpoint(PrevSelectedEndpoint);
 285 }
 286 #endif