protocol/lufa/LUFA-120730/LUFA/Drivers/USB/Core/AVR8/USBInterrupt_AVR8.h

   1 /*\r
   2              LUFA Library\r
   3      Copyright (C) Dean Camera, 2012.\r
   4 \r
   5   dean [at] fourwalledcubicle [dot] com\r
   6            www.lufa-lib.org\r
   7 */\r
   8 \r
   9 /*\r
  10   Copyright 2012  Dean Camera (dean [at] fourwalledcubicle [dot] com)\r
  11 \r
  12   Permission to use, copy, modify, distribute, and sell this\r
  13   software and its documentation for any purpose is hereby granted\r
  14   without fee, provided that the above copyright notice appear in\r
  15   all copies and that both that the copyright notice and this\r
  16   permission notice and warranty disclaimer appear in supporting\r
  17   documentation, and that the name of the author not be used in\r
  18   advertising or publicity pertaining to distribution of the\r
  19   software without specific, written prior permission.\r
  20 \r
  21   The author disclaim all warranties with regard to this\r
  22   software, including all implied warranties of merchantability\r
  23   and fitness.  In no event shall the author be liable for any\r
  24   special, indirect or consequential damages or any damages\r
  25   whatsoever resulting from loss of use, data or profits, whether\r
  26   in an action of contract, negligence or other tortious action,\r
  27   arising out of or in connection with the use or performance of\r
  28   this software.\r
  29 */\r
  30 \r
  31 /** \file\r
  32  *  \brief USB Controller Interrupt definitions for the AVR8 microcontrollers.\r
  33  *\r
  34  *  This file contains definitions required for the correct handling of low level USB service routine interrupts\r
  35  *  from the USB controller.\r
  36  *\r
  37  *  \note This file should not be included directly. It is automatically included as needed by the USB driver\r
  38  *        dispatch header located in LUFA/Drivers/USB/USB.h.\r
  39  */\r
  40 \r
  41 #ifndef __USBINTERRUPT_AVR8_H__\r
  42 #define __USBINTERRUPT_AVR8_H__\r
  43 \r
  44         /* Includes: */\r
  45                 #include "../../../../Common/Common.h"\r
  46 \r
  47         /* Enable C linkage for C++ Compilers: */\r
  48                 #if defined(__cplusplus)\r
  49                         extern "C" {\r
  50                 #endif\r
  51 \r
  52         /* Preprocessor Checks: */\r
  53                 #if !defined(__INCLUDE_FROM_USB_DRIVER)\r
  54                         #error Do not include this file directly. Include LUFA/Drivers/USB/USB.h instead.\r
  55                 #endif\r
  56 \r
  57         /* Private Interface - For use in library only: */\r
  58         #if !defined(__DOXYGEN__)\r
  59                 /* Enums: */\r
  60                         enum USB_Interrupts_t\r
  61                         {\r
  62                                 #if (defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR) || defined(__DOXYGEN__))\r
  63                                 USB_INT_VBUSTI  = 0,\r
  64                                 #endif\r
  65                                 #if (defined(USB_CAN_BE_BOTH) || defined(__DOXYGEN__))\r
  66                                 USB_INT_IDTI    = 1,\r
  67                                 #endif\r
  68                                 #if (defined(USB_CAN_BE_DEVICE) || defined(__DOXYGEN__))\r
  69                                 USB_INT_WAKEUPI = 2,\r
  70                                 USB_INT_SUSPI   = 3,\r
  71                                 USB_INT_EORSTI  = 4,\r
  72                                 USB_INT_SOFI    = 5,\r
  73                                 USB_INT_RXSTPI  = 6,\r
  74                                 #endif\r
  75                                 #if (defined(USB_CAN_BE_HOST) || defined(__DOXYGEN__))\r
  76                                 USB_INT_HSOFI   = 7,\r
  77                                 USB_INT_DCONNI  = 8,\r
  78                                 USB_INT_DDISCI  = 9,\r
  79                                 USB_INT_RSTI    = 10,\r
  80                                 USB_INT_BCERRI  = 11,\r
  81                                 USB_INT_VBERRI  = 12,\r
  82                                 USB_INT_SRPI    = 13,\r
  83                                 #endif\r
  84                         };\r
  85 \r
  86                 /* Inline Functions: */\r
  87                         static inline void USB_INT_Enable(const uint8_t Interrupt) ATTR_ALWAYS_INLINE;\r
  88                         static inline void USB_INT_Enable(const uint8_t Interrupt)\r
  89                         {\r
  90                                 switch (Interrupt)\r
  91                                 {\r
  92                                         #if (defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR))\r
  93                                         case USB_INT_VBUSTI:\r
  94                                                 USBCON |= (1 << VBUSTE);\r
  95                                                 break;\r
  96                                         #endif\r
  97                                         #if defined(USB_CAN_BE_BOTH)\r
  98                                         case USB_INT_IDTI:\r
  99                                                 USBCON |= (1 << IDTE);\r
 100                                                 break;\r
 101                                         #endif\r
 102                                         #if defined(USB_CAN_BE_DEVICE)\r
 103                                         case USB_INT_WAKEUPI:\r
 104                                                 UDIEN  |= (1 << WAKEUPE);\r
 105                                                 break;\r
 106                                         case USB_INT_SUSPI:\r
 107                                                 UDIEN  |= (1 << SUSPE);\r
 108                                                 break;\r
 109                                         case USB_INT_EORSTI:\r
 110                                                 UDIEN  |= (1 << EORSTE);\r
 111                                                 break;\r
 112                                         case USB_INT_SOFI:\r
 113                                                 UDIEN  |= (1 << SOFE);\r
 114                                                 break;\r
 115                                         case USB_INT_RXSTPI:\r
 116                                                 UEIENX |= (1 << RXSTPE);\r
 117                                                 break;\r
 118                                         #endif\r
 119                                         #if defined(USB_CAN_BE_HOST)\r
 120                                         case USB_INT_HSOFI:\r
 121                                                 UHIEN  |= (1 << HSOFE);\r
 122                                                 break;\r
 123                                         case USB_INT_DCONNI:\r
 124                                                 UHIEN  |= (1 << DCONNE);\r
 125                                                 break;\r
 126                                         case USB_INT_DDISCI:\r
 127                                                 UHIEN  |= (1 << DDISCE);\r
 128                                                 break;\r
 129                                         case USB_INT_RSTI:\r
 130                                                 UHIEN  |= (1 << RSTE);\r
 131                                                 break;\r
 132                                         case USB_INT_BCERRI:\r
 133                                                 OTGIEN |= (1 << BCERRE);\r
 134                                                 break;\r
 135                                         case USB_INT_VBERRI:\r
 136                                                 OTGIEN |= (1 << VBERRE);\r
 137                                                 break;\r
 138                                         case USB_INT_SRPI:\r
 139                                                 OTGIEN |= (1 << SRPE);\r
 140                                                 break;\r
 141                                         #endif\r
 142                                 }\r
 143                         }\r
 144 \r
 145                         static inline void USB_INT_Disable(const uint8_t Interrupt) ATTR_ALWAYS_INLINE;\r
 146                         static inline void USB_INT_Disable(const uint8_t Interrupt)\r
 147                         {\r
 148                                 switch (Interrupt)\r
 149                                 {\r
 150                                         #if (defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR))\r
 151                                         case USB_INT_VBUSTI:\r
 152                                                 USBCON &= ~(1 << VBUSTE);\r
 153                                                 break;\r
 154                                         #endif\r
 155                                         #if defined(USB_CAN_BE_BOTH)\r
 156                                         case USB_INT_IDTI:\r
 157                                                 USBCON &= ~(1 << IDTE);\r
 158                                                 break;\r
 159                                         #endif\r
 160                                         #if defined(USB_CAN_BE_DEVICE)\r
 161                                         case USB_INT_WAKEUPI:\r
 162                                                 UDIEN  &= ~(1 << WAKEUPE);\r
 163                                                 break;\r
 164                                         case USB_INT_SUSPI:\r
 165                                                 UDIEN  &= ~(1 << SUSPE);\r
 166                                                 break;\r
 167                                         case USB_INT_EORSTI:\r
 168                                                 UDIEN  &= ~(1 << EORSTE);\r
 169                                                 break;\r
 170                                         case USB_INT_SOFI:\r
 171                                                 UDIEN  &= ~(1 << SOFE);\r
 172                                                 break;\r
 173                                         case USB_INT_RXSTPI:\r
 174                                                 UEIENX &= ~(1 << RXSTPE);\r
 175                                                 break;\r
 176                                         #endif\r
 177                                         #if defined(USB_CAN_BE_HOST)\r
 178                                         case USB_INT_HSOFI:\r
 179                                                 UHIEN  &= ~(1 << HSOFE);\r
 180                                                 break;\r
 181                                         case USB_INT_DCONNI:\r
 182                                                 UHIEN  &= ~(1 << DCONNE);\r
 183                                                 break;\r
 184                                         case USB_INT_DDISCI:\r
 185                                                 UHIEN  &= ~(1 << DDISCE);\r
 186                                                 break;\r
 187                                         case USB_INT_RSTI:\r
 188                                                 UHIEN  &= ~(1 << RSTE);\r
 189                                                 break;\r
 190                                         case USB_INT_BCERRI:\r
 191                                                 OTGIEN &= ~(1 << BCERRE);\r
 192                                                 break;\r
 193                                         case USB_INT_VBERRI:\r
 194                                                 OTGIEN &= ~(1 << VBERRE);\r
 195                                                 break;\r
 196                                         case USB_INT_SRPI:\r
 197                                                 OTGIEN &= ~(1 << SRPE);\r
 198                                                 break;\r
 199                                         #endif\r
 200                                 }\r
 201                         }\r
 202 \r
 203                         static inline void USB_INT_Clear(const uint8_t Interrupt) ATTR_ALWAYS_INLINE;\r
 204                         static inline void USB_INT_Clear(const uint8_t Interrupt)\r
 205                         {\r
 206                                 switch (Interrupt)\r
 207                                 {\r
 208                                         #if (defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR))\r
 209                                         case USB_INT_VBUSTI:\r
 210                                                 USBINT &= ~(1 << VBUSTI);\r
 211                                                 break;\r
 212                                         #endif\r
 213                                         #if defined(USB_CAN_BE_BOTH)\r
 214                                         case USB_INT_IDTI:\r
 215                                                 USBINT &= ~(1 << IDTI);\r
 216                                                 break;\r
 217                                         #endif\r
 218                                         #if defined(USB_CAN_BE_DEVICE)\r
 219                                         case USB_INT_WAKEUPI:\r
 220                                                 UDINT  &= ~(1 << WAKEUPI);\r
 221                                                 break;\r
 222                                         case USB_INT_SUSPI:\r
 223                                                 UDINT  &= ~(1 << SUSPI);\r
 224                                                 break;\r
 225                                         case USB_INT_EORSTI:\r
 226                                                 UDINT  &= ~(1 << EORSTI);\r
 227                                                 break;\r
 228                                         case USB_INT_SOFI:\r
 229                                                 UDINT  &= ~(1 << SOFI);\r
 230                                                 break;\r
 231                                         case USB_INT_RXSTPI:\r
 232                                                 UEINTX &= ~(1 << RXSTPI);\r
 233                                                 break;\r
 234                                         #endif\r
 235                                         #if defined(USB_CAN_BE_HOST)\r
 236                                         case USB_INT_HSOFI:\r
 237                                                 UHINT  &= ~(1 << HSOFI);\r
 238                                                 break;\r
 239                                         case USB_INT_DCONNI:\r
 240                                                 UHINT  &= ~(1 << DCONNI);\r
 241                                                 break;\r
 242                                         case USB_INT_DDISCI:\r
 243                                                 UHINT  &= ~(1 << DDISCI);\r
 244                                                 break;\r
 245                                         case USB_INT_RSTI:\r
 246                                                 UHINT  &= ~(1 << RSTI);\r
 247                                                 break;\r
 248                                         case USB_INT_BCERRI:\r
 249                                                 OTGINT &= ~(1 << BCERRI);\r
 250                                                 break;\r
 251                                         case USB_INT_VBERRI:\r
 252                                                 OTGINT &= ~(1 << VBERRI);\r
 253                                                 break;\r
 254                                         case USB_INT_SRPI:\r
 255                                                 OTGINT &= ~(1 << SRPI);\r
 256                                                 break;\r
 257                                         #endif\r
 258                                 }\r
 259                         }\r
 260 \r
 261                         static inline bool USB_INT_IsEnabled(const uint8_t Interrupt) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;\r
 262                         static inline bool USB_INT_IsEnabled(const uint8_t Interrupt)\r
 263                         {\r
 264                                 switch (Interrupt)\r
 265                                 {\r
 266                                         #if (defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR))\r
 267                                         case USB_INT_VBUSTI:\r
 268                                                 return (USBCON & (1 << VBUSTE));\r
 269                                         #endif\r
 270                                         #if defined(USB_CAN_BE_BOTH)\r
 271                                         case USB_INT_IDTI:\r
 272                                                 return (USBCON & (1 << IDTE));\r
 273                                         #endif\r
 274                                         #if defined(USB_CAN_BE_DEVICE)\r
 275                                         case USB_INT_WAKEUPI:\r
 276                                                 return (UDIEN  & (1 << WAKEUPE));\r
 277                                         case USB_INT_SUSPI:\r
 278                                                 return (UDIEN  & (1 << SUSPE));\r
 279                                         case USB_INT_EORSTI:\r
 280                                                 return (UDIEN  & (1 << EORSTE));\r
 281                                         case USB_INT_SOFI:\r
 282                                                 return (UDIEN  & (1 << SOFE));\r
 283                                         case USB_INT_RXSTPI:\r
 284                                                 return (UEIENX & (1 << RXSTPE));\r
 285                                         #endif\r
 286                                         #if defined(USB_CAN_BE_HOST)\r
 287                                         case USB_INT_HSOFI:\r
 288                                                 return (UHIEN  & (1 << HSOFE));\r
 289                                         case USB_INT_DCONNI:\r
 290                                                 return (UHIEN  & (1 << DCONNE));\r
 291                                         case USB_INT_DDISCI:\r
 292                                                 return (UHIEN  & (1 << DDISCE));\r
 293                                         case USB_INT_RSTI:\r
 294                                                 return (UHIEN  & (1 << RSTE));\r
 295                                         case USB_INT_BCERRI:\r
 296                                                 return (OTGIEN & (1 << BCERRE));\r
 297                                         case USB_INT_VBERRI:\r
 298                                                 return (OTGIEN & (1 << VBERRE));\r
 299                                         case USB_INT_SRPI:\r
 300                                                 return (OTGIEN & (1 << SRPE));\r
 301                                         #endif\r
 302                                 }\r
 303 \r
 304                                 return false;\r
 305                         }\r
 306 \r
 307                         static inline bool USB_INT_HasOccurred(const uint8_t Interrupt) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;\r
 308                         static inline bool USB_INT_HasOccurred(const uint8_t Interrupt)\r
 309                         {\r
 310                                 switch (Interrupt)\r
 311                                 {\r
 312                                         #if (defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR))\r
 313                                         case USB_INT_VBUSTI:\r
 314                                                 return (USBINT & (1 << VBUSTI));\r
 315                                         #endif\r
 316                                         #if defined(USB_CAN_BE_BOTH)\r
 317                                         case USB_INT_IDTI:\r
 318                                                 return (USBINT & (1 << IDTI));\r
 319                                         #endif\r
 320                                         #if defined(USB_CAN_BE_DEVICE)\r
 321                                         case USB_INT_WAKEUPI:\r
 322                                                 return (UDINT  & (1 << WAKEUPI));\r
 323                                         case USB_INT_SUSPI:\r
 324                                                 return (UDINT  & (1 << SUSPI));\r
 325                                         case USB_INT_EORSTI:\r
 326                                                 return (UDINT  & (1 << EORSTI));\r
 327                                         case USB_INT_SOFI:\r
 328                                                 return (UDINT  & (1 << SOFI));\r
 329                                         case USB_INT_RXSTPI:\r
 330                                                 return (UEINTX & (1 << RXSTPI));\r
 331                                         #endif\r
 332                                         #if defined(USB_CAN_BE_HOST)\r
 333                                         case USB_INT_HSOFI:\r
 334                                                 return (UHINT  & (1 << HSOFI));\r
 335                                         case USB_INT_DCONNI:\r
 336                                                 return (UHINT  & (1 << DCONNI));\r
 337                                         case USB_INT_DDISCI:\r
 338                                                 return (UHINT  & (1 << DDISCI));\r
 339                                         case USB_INT_RSTI:\r
 340                                                 return (UHINT  & (1 << RSTI));\r
 341                                         case USB_INT_BCERRI:\r
 342                                                 return (OTGINT & (1 << BCERRI));\r
 343                                         case USB_INT_VBERRI:\r
 344                                                 return (OTGINT & (1 << VBERRI));\r
 345                                         case USB_INT_SRPI:\r
 346                                                 return (OTGINT & (1 << SRPI));\r
 347                                         #endif\r
 348                                 }\r
 349 \r
 350                                 return false;\r
 351                         }\r
 352 \r
 353                 /* Includes: */\r
 354                         #include "../USBMode.h"\r
 355                         #include "../Events.h"\r
 356                         #include "../USBController.h"\r
 357 \r
 358                 /* Function Prototypes: */\r
 359                         void USB_INT_ClearAllInterrupts(void);\r
 360                         void USB_INT_DisableAllInterrupts(void);\r
 361         #endif\r
 362 \r
 363         /* Disable C linkage for C++ Compilers: */\r
 364                 #if defined(__cplusplus)\r
 365                         }\r
 366                 #endif\r
 367 \r
 368 #endif\r
 369 \r