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                 RAISE_EVENT(USB_VBUSChange);
  76
  77                 if (USB_VBUS_GetStatus())
  78                 {
  79                         RAISE_EVENT(USB_VBUSConnect);
  80
  81                         if (USB_IsConnected)
  82                           RAISE_EVENT(USB_Disconnect);
  83
  84                         USB_ResetInterface();
  85
  86                         USB_IsConnected = true;
  87
  88                         RAISE_EVENT(USB_Connect);
  89                 }
  90                 else
  91                 {
  92                         RAISE_EVENT(USB_Disconnect);
  93
  94                         USB_Detach();
  95                         USB_CLK_Freeze();
  96                         USB_PLL_Off();
  97                         USB_REG_Off();
  98
  99                         USB_IsConnected = false;
 100
 101                         RAISE_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                 RAISE_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                         RAISE_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                         RAISE_EVENT(USB_Connect);
 153                 }
 154                 #endif
 155
 156                 USB_IsSuspended = false;
 157
 158                 RAISE_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                 RAISE_EVENT(USB_Reset);
 182         }
 183         #endif
 184
 185         #if defined(USB_CAN_BE_HOST)
 186         if (USB_INT_HasOccurred(USB_INT_DDISCI) && USB_INT_IsEnabled(USB_INT_DDISCI))
 187         {
 188                 USB_INT_Clear(USB_INT_DDISCI);
 189                 USB_INT_Clear(USB_INT_DCONNI);
 190                 USB_INT_Disable(USB_INT_DDISCI);
 191
 192                 RAISE_EVENT(USB_DeviceUnattached);
 193                 RAISE_EVENT(USB_Disconnect);
 194
 195                 USB_ResetInterface();
 196         }
 197
 198         if (USB_INT_HasOccurred(USB_INT_VBERRI) && USB_INT_IsEnabled(USB_INT_VBERRI))
 199         {
 200                 USB_INT_Clear(USB_INT_VBERRI);
 201
 202                 USB_Host_VBUS_Manual_Off();
 203                 USB_Host_VBUS_Auto_Off();
 204
 205                 RAISE_EVENT(USB_HostError, HOST_ERROR_VBusVoltageDip);
 206                 RAISE_EVENT(USB_DeviceUnattached);
 207
 208                 USB_HostState = HOST_STATE_Unattached;
 209         }
 210
 211         if (USB_INT_HasOccurred(USB_INT_SRPI) && USB_INT_IsEnabled(USB_INT_SRPI))
 212         {
 213                 USB_INT_Clear(USB_INT_SRPI);
 214                 USB_INT_Disable(USB_INT_SRPI);
 215
 216                 RAISE_EVENT(USB_DeviceAttached);
 217
 218                 USB_INT_Enable(USB_INT_DDISCI);
 219
 220                 USB_HostState = HOST_STATE_Attached;
 221         }
 222
 223         if (USB_INT_HasOccurred(USB_INT_BCERRI) && USB_INT_IsEnabled(USB_INT_BCERRI))
 224         {
 225                 USB_INT_Clear(USB_INT_BCERRI);
 226
 227                 RAISE_EVENT(USB_DeviceEnumerationFailed, HOST_ENUMERROR_NoDeviceDetected, 0);
 228                 RAISE_EVENT(USB_DeviceUnattached);
 229
 230                 if (USB_IsConnected)
 231                   RAISE_EVENT(USB_Disconnect);
 232
 233                 USB_ResetInterface();
 234         }
 235         #endif
 236
 237         #if defined(USB_CAN_BE_BOTH)
 238         if (USB_INT_HasOccurred(USB_INT_IDTI) && USB_INT_IsEnabled(USB_INT_IDTI))
 239         {
 240                 USB_INT_Clear(USB_INT_IDTI);
 241
 242                 if (USB_IsConnected)
 243                 {
 244                         if (USB_CurrentMode == USB_MODE_HOST)
 245                           RAISE_EVENT(USB_DeviceUnattached);
 246                         else
 247                           RAISE_EVENT(USB_Disconnect);
 248                 }
 249
 250                 RAISE_EVENT(USB_UIDChange);
 251
 252                 USB_ResetInterface();
 253         }
 254         #endif
 255 }
 256
 257 #if defined(INTERRUPT_CONTROL_ENDPOINT)
 258 ISR(USB_COM_vect, ISR_BLOCK)
 259 {
 260         uint8_t PrevSelectedEndpoint = Endpoint_GetCurrentEndpoint();
 261
 262         USB_USBTask();
 263
 264         USB_INT_Clear(USB_INT_ENDPOINT_SETUP);
 265
 266         Endpoint_SelectEndpoint(PrevSelectedEndpoint);
 267 }
 268 #endif