LUFA/Drivers/USB/Core/UC3/USBInterrupt_UC3.h

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2012.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2012  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 /** \file
  32  *  \brief USB Controller Interrupt definitions for the AVR32 UC3 microcontrollers.
  33  *
  34  *  This file contains definitions required for the correct handling of low level USB service routine interrupts
  35  *  from the USB controller.
  36  *
  37  *  \note This file should not be included directly. It is automatically included as needed by the USB driver
  38  *        dispatch header located in LUFA/Drivers/USB/USB.h.
  39  */
  40
  41 #ifndef __USBINTERRUPT_UC3_H__
  42 #define __USBINTERRUPT_UC3_H__
  43
  44         /* Includes: */
  45                 #include "../../../../Common/Common.h"
  46
  47         /* Enable C linkage for C++ Compilers: */
  48                 #if defined(__cplusplus)
  49                         extern "C" {
  50                 #endif
  51
  52         /* Preprocessor Checks: */
  53                 #if !defined(__INCLUDE_FROM_USB_DRIVER)
  54                         #error Do not include this file directly. Include LUFA/Drivers/USB/USB.h instead.
  55                 #endif
  56
  57         /* Private Interface - For use in library only: */
  58         #if !defined(__DOXYGEN__)
  59                 /* External Variables: */
  60                         extern volatile uint32_t USB_Endpoint_SelectedEndpoint;
  61
  62                 /* Enums: */
  63                         enum USB_Interrupts_t
  64                         {
  65                                 USB_INT_VBUSTI  = 0,
  66                                 #if (defined(USB_CAN_BE_BOTH) || defined(__DOXYGEN__))
  67                                 USB_INT_IDTI    = 1,
  68                                 #endif
  69                                 #if (defined(USB_CAN_BE_DEVICE) || defined(__DOXYGEN__))
  70                                 USB_INT_WAKEUPI = 2,
  71                                 USB_INT_SUSPI   = 3,
  72                                 USB_INT_EORSTI  = 4,
  73                                 USB_INT_SOFI    = 5,
  74                                 USB_INT_RXSTPI  = 6,
  75                                 #endif
  76                                 #if (defined(USB_CAN_BE_HOST) || defined(__DOXYGEN__))
  77                                 USB_INT_HSOFI   = 7,
  78                                 USB_INT_DCONNI  = 8,
  79                                 USB_INT_DDISCI  = 9,
  80                                 USB_INT_RSTI    = 10,
  81                                 USB_INT_BCERRI  = 11,
  82                                 USB_INT_VBERRI  = 12,
  83                                 #endif
  84                         };
  85
  86                 /* Inline Functions: */
  87                         static inline void USB_INT_Enable(const uint8_t Interrupt) ATTR_ALWAYS_INLINE;
  88                         static inline void USB_INT_Enable(const uint8_t Interrupt)
  89                         {
  90                                 switch (Interrupt)
  91                                 {
  92                                         case USB_INT_VBUSTI:
  93                                                 AVR32_USBB.USBCON.vbuste      = true;
  94                                                 break;
  95                                         #if defined(USB_CAN_BE_BOTH)
  96                                         case USB_INT_IDTI:
  97                                                 AVR32_USBB.USBCON.idte        = true;
  98                                                 break;
  99                                         #endif
 100                                         #if defined(USB_CAN_BE_DEVICE)
 101                                         case USB_INT_WAKEUPI:
 102                                                 AVR32_USBB.UDINTESET.wakeupes = true;
 103                                                 break;
 104                                         case USB_INT_SUSPI:
 105                                                 AVR32_USBB.UDINTESET.suspes   = true;
 106                                                 break;
 107                                         case USB_INT_EORSTI:
 108                                                 AVR32_USBB.UDINTESET.eorstes  = true;
 109                                                 break;
 110                                         case USB_INT_SOFI:
 111                                                 AVR32_USBB.UDINTESET.sofes    = true;
 112                                                 break;
 113                                         case USB_INT_RXSTPI:
 114                                                 (&AVR32_USBB.UECON0SET)[USB_Endpoint_SelectedEndpoint].rxstpes = true;
 115                                                 break;
 116                                         #endif
 117                                         #if defined(USB_CAN_BE_HOST)
 118                                         case USB_INT_HSOFI:
 119                                                 AVR32_USBB.UHINTESET.hsofies  = true;
 120                                                 break;
 121                                         case USB_INT_DCONNI:
 122                                                 AVR32_USBB.UHINTESET.dconnies = true;
 123                                                 break;
 124                                         case USB_INT_DDISCI:
 125                                                 AVR32_USBB.UHINTESET.ddiscies = true;
 126                                                 break;
 127                                         case USB_INT_RSTI:
 128                                                 AVR32_USBB.UHINTESET.rsties   = true;
 129                                                 break;
 130                                         case USB_INT_BCERRI:
 131                                                 AVR32_USBB.USBCON.bcerre      = true;
 132                                                 break;
 133                                         case USB_INT_VBERRI:
 134                                                 AVR32_USBB.USBCON.vberre      = true;
 135                                                 break;
 136                                         #endif
 137                                 }
 138                         }
 139
 140                         static inline void USB_INT_Disable(const uint8_t Interrupt) ATTR_ALWAYS_INLINE;
 141                         static inline void USB_INT_Disable(const uint8_t Interrupt)
 142                         {
 143                                 switch (Interrupt)
 144                                 {
 145                                         case USB_INT_VBUSTI:
 146                                                 AVR32_USBB.USBCON.vbuste      = false;
 147                                                 break;
 148                                         #if defined(USB_CAN_BE_BOTH)
 149                                         case USB_INT_IDTI:
 150                                                 AVR32_USBB.USBCON.idte        = false;
 151                                                 break;
 152                                         #endif
 153                                         #if defined(USB_CAN_BE_DEVICE)
 154                                         case USB_INT_WAKEUPI:
 155                                                 AVR32_USBB.UDINTECLR.wakeupec = true;
 156                                                 break;
 157                                         case USB_INT_SUSPI:
 158                                                 AVR32_USBB.UDINTECLR.suspec   = true;
 159                                                 break;
 160                                         case USB_INT_EORSTI:
 161                                                 AVR32_USBB.UDINTECLR.eorstec  = true;
 162                                                 break;
 163                                         case USB_INT_SOFI:
 164                                                 AVR32_USBB.UDINTECLR.sofec    = true;
 165                                                 break;
 166                                         case USB_INT_RXSTPI:
 167                                                 (&AVR32_USBB.UECON0CLR)[USB_Endpoint_SelectedEndpoint].rxstpec = true;
 168                                                 break;
 169                                         #endif
 170                                         #if defined(USB_CAN_BE_HOST)
 171                                         case USB_INT_HSOFI:
 172                                                 AVR32_USBB.UHINTECLR.hsofiec  = true;
 173                                                 break;
 174                                         case USB_INT_DCONNI:
 175                                                 AVR32_USBB.UHINTECLR.dconniec = true;
 176                                                 break;
 177                                         case USB_INT_DDISCI:
 178                                                 AVR32_USBB.UHINTECLR.ddisciec = true;
 179                                                 break;
 180                                         case USB_INT_RSTI:
 181                                                 AVR32_USBB.UHINTECLR.rstiec   = true;
 182                                                 break;
 183                                         case USB_INT_BCERRI:
 184                                                 AVR32_USBB.USBCON.bcerre      = false;
 185                                                 break;
 186                                         case USB_INT_VBERRI:
 187                                                 AVR32_USBB.USBCON.vberre      = false;
 188                                                 break;
 189                                         #endif
 190                                 }
 191                         }
 192
 193                         static inline void USB_INT_Clear(const uint8_t Interrupt) ATTR_ALWAYS_INLINE;
 194                         static inline void USB_INT_Clear(const uint8_t Interrupt)
 195                         {
 196                                 switch (Interrupt)
 197                                 {
 198                                         case USB_INT_VBUSTI:
 199                                                 AVR32_USBB.USBSTACLR.vbustic = true;
 200                                                 (void)AVR32_USBB.USBSTACLR;
 201                                                 break;
 202                                         #if defined(USB_CAN_BE_BOTH)
 203                                         case USB_INT_IDTI:
 204                                                 AVR32_USBB.USBSTACLR.idtic   = true;
 205                                                 (void)AVR32_USBB.USBSTACLR;
 206                                                 break;
 207                                         #endif
 208                                         #if defined(USB_CAN_BE_DEVICE)
 209                                         case USB_INT_WAKEUPI:
 210                                                 AVR32_USBB.UDINTCLR.wakeupc  = true;
 211                                                 (void)AVR32_USBB.UDINTCLR;
 212                                                 break;
 213                                         case USB_INT_SUSPI:
 214                                                 AVR32_USBB.UDINTCLR.suspc    = true;
 215                                                 (void)AVR32_USBB.UDINTCLR;
 216                                                 break;
 217                                         case USB_INT_EORSTI:
 218                                                 AVR32_USBB.UDINTCLR.eorstc   = true;
 219                                                 (void)AVR32_USBB.UDINTCLR;
 220                                                 break;
 221                                         case USB_INT_SOFI:
 222                                                 AVR32_USBB.UDINTCLR.sofc     = true;
 223                                                 (void)AVR32_USBB.UDINTCLR;
 224                                                 break;
 225                                         case USB_INT_RXSTPI:
 226                                                 (&AVR32_USBB.UESTA0CLR)[USB_Endpoint_SelectedEndpoint].rxstpic = true;
 227                                                 break;
 228                                         #endif
 229                                         #if defined(USB_CAN_BE_HOST)
 230                                         case USB_INT_HSOFI:
 231                                                 AVR32_USBB.UHINTCLR.hsofic   = true;
 232                                                 (void)AVR32_USBB.UHINTCLR;
 233                                                 break;
 234                                         case USB_INT_DCONNI:
 235                                                 AVR32_USBB.UHINTCLR.dconnic  = true;
 236                                                 (void)AVR32_USBB.UHINTCLR;
 237                                                 break;
 238                                         case USB_INT_DDISCI:
 239                                                 AVR32_USBB.UHINTCLR.ddiscic  = true;
 240                                                 (void)AVR32_USBB.UHINTCLR;
 241                                                 break;
 242                                         case USB_INT_RSTI:
 243                                                 AVR32_USBB.UHINTCLR.rstic    = true;
 244                                                 (void)AVR32_USBB.UHINTCLR;
 245                                                 break;
 246                                         case USB_INT_BCERRI:
 247                                                 AVR32_USBB.USBSTACLR.bcerric = true;
 248                                                 (void)AVR32_USBB.USBSTACLR;
 249                                                 break;
 250                                         case USB_INT_VBERRI:
 251                                                 AVR32_USBB.USBSTACLR.vberric = true;
 252                                                 (void)AVR32_USBB.USBSTACLR;
 253                                                 break;
 254                                         #endif
 255                                 }
 256                         }
 257
 258                         static inline bool USB_INT_IsEnabled(const uint8_t Interrupt) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;
 259                         static inline bool USB_INT_IsEnabled(const uint8_t Interrupt)
 260                         {
 261                                 switch (Interrupt)
 262                                 {
 263                                         case USB_INT_VBUSTI:
 264                                                 return AVR32_USBB.USBCON.vbuste;
 265                                         #if defined(USB_CAN_BE_BOTH)
 266                                         case USB_INT_IDTI:
 267                                                 return AVR32_USBB.USBCON.idte;
 268                                         #endif
 269                                         #if defined(USB_CAN_BE_DEVICE)
 270                                         case USB_INT_WAKEUPI:
 271                                                 return AVR32_USBB.UDINTE.wakeupe;
 272                                         case USB_INT_SUSPI:
 273                                                 return AVR32_USBB.UDINTE.suspe;
 274                                         case USB_INT_EORSTI:
 275                                                 return AVR32_USBB.UDINTE.eorste;
 276                                         case USB_INT_SOFI:
 277                                                 return AVR32_USBB.UDINTE.sofe;
 278                                         case USB_INT_RXSTPI:
 279                                                 return (&AVR32_USBB.UECON0)[USB_Endpoint_SelectedEndpoint].rxstpe;
 280                                         #endif
 281                                         #if defined(USB_CAN_BE_HOST)
 282                                         case USB_INT_HSOFI:
 283                                                 return AVR32_USBB.UHINTE.hsofie;
 284                                         case USB_INT_DCONNI:
 285                                                 return AVR32_USBB.UHINTE.dconnie;
 286                                         case USB_INT_DDISCI:
 287                                                 return AVR32_USBB.UHINTE.ddiscie;
 288                                         case USB_INT_RSTI:
 289                                                 return AVR32_USBB.UHINTE.rstie;
 290                                         case USB_INT_BCERRI:
 291                                                 return AVR32_USBB.USBCON.bcerre;
 292                                         case USB_INT_VBERRI:
 293                                                 return AVR32_USBB.USBCON.vberre;
 294                                         #endif
 295                                 }
 296
 297                                 return false;
 298                         }
 299
 300                         static inline bool USB_INT_HasOccurred(const uint8_t Interrupt) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;
 301                         static inline bool USB_INT_HasOccurred(const uint8_t Interrupt)
 302                         {
 303                                 switch (Interrupt)
 304                                 {
 305                                         case USB_INT_VBUSTI:
 306                                                 return AVR32_USBB.USBSTA.vbusti;
 307                                         #if defined(USB_CAN_BE_BOTH)
 308                                         case USB_INT_IDTI:
 309                                                 return AVR32_USBB.USBSTA.idti;
 310                                         #endif
 311                                         #if defined(USB_CAN_BE_DEVICE)
 312                                         case USB_INT_WAKEUPI:
 313                                                 return AVR32_USBB.UDINT.wakeup;
 314                                         case USB_INT_SUSPI:
 315                                                 return AVR32_USBB.UDINT.susp;
 316                                         case USB_INT_EORSTI:
 317                                                 return AVR32_USBB.UDINT.eorst;
 318                                         case USB_INT_SOFI:
 319                                                 return AVR32_USBB.UDINT.sof;
 320                                         case USB_INT_RXSTPI:
 321                                                 return (&AVR32_USBB.UESTA0)[USB_Endpoint_SelectedEndpoint].rxstpi;
 322                                         #endif
 323                                         #if defined(USB_CAN_BE_HOST)
 324                                         case USB_INT_HSOFI:
 325                                                 return AVR32_USBB.UHINT.hsofi;
 326                                         case USB_INT_DCONNI:
 327                                                 return AVR32_USBB.UHINT.dconni;
 328                                         case USB_INT_DDISCI:
 329                                                 return AVR32_USBB.UHINT.ddisci;
 330                                         case USB_INT_RSTI:
 331                                                 return AVR32_USBB.UHINT.rsti;
 332                                         case USB_INT_BCERRI:
 333                                                 return AVR32_USBB.USBSTA.bcerri;
 334                                         case USB_INT_VBERRI:
 335                                                 return AVR32_USBB.USBSTA.vberri;
 336                                         #endif
 337                                 }
 338
 339                                 return false;
 340                         }
 341
 342                 /* Includes: */
 343                         #include "../USBMode.h"
 344                         #include "../Events.h"
 345                         #include "../USBController.h"
 346
 347                 /* Function Prototypes: */
 348                         void USB_INT_ClearAllInterrupts(void);
 349                         void USB_INT_DisableAllInterrupts(void);
 350         #endif
 351
 352         /* Public Interface - May be used in end-application: */
 353                 /* Function Prototypes: */
 354                         #if defined(__DOXYGEN__)
 355                                 /** Interrupt service routine handler for the USB controller ISR group. This interrupt routine <b>must</b> be
 356                                  *  linked to the entire USB controller ISR vector group inside the AVR32's interrupt controller peripheral,
 357                                  *  using the user application's preferred USB controller driver.
 358                                  */
 359                                 void USB_GEN_vect(void);
 360                         #else
 361                                 ISR(USB_GEN_vect);
 362                         #endif
 363
 364         /* Disable C linkage for C++ Compilers: */
 365                 #if defined(__cplusplus)
 366                         }
 367                 #endif
 368
 369 #endif
 370