/avr/avr_lib/at90usb82/avr-at90usb82.ads

http://github.com/tkoskine/avr-ada · Ada · 3235 lines · 2477 code · 179 blank · 579 comment · 337 complexity · 45ce7b17d8820a3017c7cdc78c46bf12 MD5 · raw file

Large files are truncated click here to view the full file

    

  1. ---------------------------------------------------------------------------
    2. 

  2. -- The AVR-Ada Library is free software;  you can redistribute it and/or --
    3. 

  3. -- modify it under terms of the  GNU General Public License as published --
    4. 

  4. -- by  the  Free Software  Foundation;  either  version 2, or  (at  your --
    5. 

  5. -- option) any later version.  The AVR-Ada Library is distributed in the --
    6. 

  6. -- hope that it will be useful, but  WITHOUT ANY WARRANTY;  without even --
    7. 

  7. -- the  implied warranty of MERCHANTABILITY or FITNESS FOR A  PARTICULAR --
    8. 

  8. -- PURPOSE. See the GNU General Public License for more details.         --
    9. 

  9. --                                                                       --
    10. 

  10. -- As a special exception, if other files instantiate generics from this --
    11. 

  11. -- unit,  or  you  link  this  unit  with  other  files  to  produce  an --
    12. 

  12. -- executable   this  unit  does  not  by  itself  cause  the  resulting --
    13. 

  13. -- executable to  be  covered by the  GNU General  Public License.  This --
    14. 

  14. -- exception does  not  however  invalidate  any  other reasons why  the --
    15. 

  15. -- executable file might be covered by the GNU Public License.           --
    16. 

  16. ---------------------------------------------------------------------------
    17. 

  17. 

  18. with System;                   use System;  --   make Address visible
    19. 

  19. with Interfaces;               use Interfaces;
    20. 

  20. 

  21. package AVR.AT90USB82 is
    22. 

  22.    pragma Preelaborate;
    23. 

  23. 

  24.    CVS_Version : constant String := "$Id$";
    25. 

  25. 

  26. 

  27.    --
    28. 

  28.    --  memory sizes
    29. 

  29.    --
    30. 

  30.    Flash_Size               : constant := 16#2000#;
    31. 

  31.    Flash_End                : constant := 16#1fff#;
    32. 

  32.    EEprom_Size              : constant := 16#0200#;
    33. 

  33.    E2end                    : constant := 16#01ff#;
    34. 

  34.    Int_SRAM_Start_Addr      : constant := 16#100#;
    35. 

  35.    Int_SRAM_Size            : constant := 16#200#;
    36. 

  36. 

  37.    --
    38. 

  38.    --  interrupts
    39. 

  39.    --
    40. 

  40.    Number_Of_Interrupts     : constant := 38;
    41. 

  41. 

  42.    --  External Pin,Power-on Reset,Brown-out Reset,Watchdog Reset,and JTAG
    43. 

  43.    --    AVR Reset. See Datasheet.
    44. 

  44.    Sig_RESET                : constant        :=  0;
    45. 

  45.    Sig_RESET_String         : constant String := "__vector_0";
    46. 

  46.    --  External Interrupt Request 0
    47. 

  47.    Sig_INT0                 : constant        :=  1;
    48. 

  48.    Sig_INT0_String          : constant String := "__vector_1";
    49. 

  49.    --  External Interrupt Request 1
    50. 

  50.    Sig_INT1                 : constant        :=  2;
    51. 

  51.    Sig_INT1_String          : constant String := "__vector_2";
    52. 

  52.    --  External Interrupt Request 2
    53. 

  53.    Sig_INT2                 : constant        :=  3;
    54. 

  54.    Sig_INT2_String          : constant String := "__vector_3";
    55. 

  55.    --  External Interrupt Request 3
    56. 

  56.    Sig_INT3                 : constant        :=  4;
    57. 

  57.    Sig_INT3_String          : constant String := "__vector_4";
    58. 

  58.    --  External Interrupt Request 4
    59. 

  59.    Sig_INT4                 : constant        :=  5;
    60. 

  60.    Sig_INT4_String          : constant String := "__vector_5";
    61. 

  61.    --  External Interrupt Request 5
    62. 

  62.    Sig_INT5                 : constant        :=  6;
    63. 

  63.    Sig_INT5_String          : constant String := "__vector_6";
    64. 

  64.    --  External Interrupt Request 6
    65. 

  65.    Sig_INT6                 : constant        :=  7;
    66. 

  66.    Sig_INT6_String          : constant String := "__vector_7";
    67. 

  67.    --  External Interrupt Request 7
    68. 

  68.    Sig_INT7                 : constant        :=  8;
    69. 

  69.    Sig_INT7_String          : constant String := "__vector_8";
    70. 

  70.    --  Pin Change Interrupt Request 0
    71. 

  71.    Sig_PCINT0               : constant        :=  9;
    72. 

  72.    Sig_PCINT0_String        : constant String := "__vector_9";
    73. 

  73.    --  Pin Change Interrupt Request 1
    74. 

  74.    Sig_PCINT1               : constant        := 10;
    75. 

  75.    Sig_PCINT1_String        : constant String := "__vector_10";
    76. 

  76.    --  USB General Interrupt Request
    77. 

  77.    Sig_USB_GEN              : constant        := 11;
    78. 

  78.    Sig_USB_GEN_String       : constant String := "__vector_11";
    79. 

  79.    --  USB Endpoint/Pipe Interrupt Communication Request
    80. 

  80.    Sig_USB_COM              : constant        := 12;
    81. 

  81.    Sig_USB_COM_String       : constant String := "__vector_12";
    82. 

  82.    --  Watchdog Time-out Interrupt
    83. 

  83.    Sig_WDT                  : constant        := 13;
    84. 

  84.    Sig_WDT_String           : constant String := "__vector_13";
    85. 

  85.    --  Timer/Counter2 Capture Event
    86. 

  86.    Sig_TIMER1_CAPT          : constant        := 14;
    87. 

  87.    Sig_TIMER1_CAPT_String   : constant String := "__vector_14";
    88. 

  88.    --  Timer/Counter2 Compare Match B
    89. 

  89.    Sig_TIMER1_COMPA         : constant        := 15;
    90. 

  90.    Sig_TIMER1_COMPA_String  : constant String := "__vector_15";
    91. 

  91.    --  Timer/Counter2 Compare Match B
    92. 

  92.    Sig_TIMER1_COMPB         : constant        := 16;
    93. 

  93.    Sig_TIMER1_COMPB_String  : constant String := "__vector_16";
    94. 

  94.    --  Timer/Counter2 Compare Match C
    95. 

  95.    Sig_TIMER1_COMPC         : constant        := 17;
    96. 

  96.    Sig_TIMER1_COMPC_String  : constant String := "__vector_17";
    97. 

  97.    --  Timer/Counter1 Overflow
    98. 

  98.    Sig_TIMER1_OVF           : constant        := 18;
    99. 

  99.    Sig_TIMER1_OVF_String    : constant String := "__vector_18";
    100. 

  100.    --  Timer/Counter0 Compare Match A
    101. 

  101.    Sig_TIMER0_COMPA         : constant        := 19;
    102. 

  102.    Sig_TIMER0_COMPA_String  : constant String := "__vector_19";
    103. 

  103.    --  Timer/Counter0 Compare Match B
    104. 

  104.    Sig_TIMER0_COMPB         : constant        := 20;
    105. 

  105.    Sig_TIMER0_COMPB_String  : constant String := "__vector_20";
    106. 

  106.    --  Timer/Counter0 Overflow
    107. 

  107.    Sig_TIMER0_OVF           : constant        := 21;
    108. 

  108.    Sig_TIMER0_OVF_String    : constant String := "__vector_21";
    109. 

  109.    --  SPI Serial Transfer Complete
    110. 

  110.    Sig_SPI_STC              : constant        := 22;
    111. 

  111.    Sig_SPI_STC_String       : constant String := "__vector_22";
    112. 

  112.    --  USART1, Rx Complete
    113. 

  113.    Sig_USART1_RX            : constant        := 23;
    114. 

  114.    Sig_USART1_RX_String     : constant String := "__vector_23";
    115. 

  115.    --  USART1 Data register Empty
    116. 

  116.    Sig_USART1_UDRE          : constant        := 24;
    117. 

  117.    Sig_USART1_UDRE_String   : constant String := "__vector_24";
    118. 

  118.    --  USART1, Tx Complete
    119. 

  119.    Sig_USART1_TX            : constant        := 25;
    120. 

  120.    Sig_USART1_TX_String     : constant String := "__vector_25";
    121. 

  121.    --  Analog Comparator
    122. 

  122.    Sig_ANALOG_COMP          : constant        := 26;
    123. 

  123.    Sig_ANALOG_COMP_String   : constant String := "__vector_26";
    124. 

  124.    --  EEPROM Ready
    125. 

  125.    Sig_EE_READY             : constant        := 27;
    126. 

  126.    Sig_EE_READY_String      : constant String := "__vector_27";
    127. 

  127.    --  Store Program Memory Read
    128. 

  128.    Sig_SPM_READY            : constant        := 28;
    129. 

  129.    Sig_SPM_READY_String     : constant String := "__vector_28";
    130. 

  130. 

  131. 

  132.    --
    133. 

  133.    --  I/O registers
    134. 

  134.    --
    135. 

  135. 

  136.    CLKSTA_Addr              : constant Address    := 16#d2#;
    137. 

  137.    CLKSTA                   : Unsigned_8 ;
    138. 

  138.    for CLKSTA'Address use CLKSTA_Addr;
    139. 

  139.    pragma Volatile (CLKSTA);
    140. 

  140.    CLKSTA_Bits              : Bits_In_Byte;
    141. 

  141.    for CLKSTA_Bits'Address use CLKSTA_Addr;
    142. 

  142.    pragma Volatile (CLKSTA_Bits);
    143. 

  143.    EXTON_Bit                : constant Bit_Number := 0;
    144. 

  144.    EXTON_Mask               : constant Unsigned_8 := 16#01#;
    145. 

  145.    RCON_Bit                 : constant Bit_Number := 1;
    146. 

  146.    RCON_Mask                : constant Unsigned_8 := 16#02#;
    147. 

  147. 

  148.    CLKSEL1_Addr             : constant Address    := 16#d1#;
    149. 

  149.    CLKSEL1                  : Unsigned_8 ;
    150. 

  150.    for CLKSEL1'Address use CLKSEL1_Addr;
    151. 

  151.    pragma Volatile (CLKSEL1);
    152. 

  152.    CLKSEL1_Bits             : Bits_In_Byte;
    153. 

  153.    for CLKSEL1_Bits'Address use CLKSEL1_Addr;
    154. 

  154.    pragma Volatile (CLKSEL1_Bits);
    155. 

  155.    EXCKSEL0_Bit             : constant Bit_Number := 0;
    156. 

  156.    EXCKSEL0_Mask            : constant Unsigned_8 := 16#01#;
    157. 

  157.    EXCKSEL1_Bit             : constant Bit_Number := 1;
    158. 

  158.    EXCKSEL1_Mask            : constant Unsigned_8 := 16#02#;
    159. 

  159.    EXCKSEL2_Bit             : constant Bit_Number := 2;
    160. 

  160.    EXCKSEL2_Mask            : constant Unsigned_8 := 16#04#;
    161. 

  161.    EXCKSEL3_Bit             : constant Bit_Number := 3;
    162. 

  162.    EXCKSEL3_Mask            : constant Unsigned_8 := 16#08#;
    163. 

  163.    RCCKSEL0_Bit             : constant Bit_Number := 4;
    164. 

  164.    RCCKSEL0_Mask            : constant Unsigned_8 := 16#10#;
    165. 

  165.    RCCKSEL1_Bit             : constant Bit_Number := 5;
    166. 

  166.    RCCKSEL1_Mask            : constant Unsigned_8 := 16#20#;
    167. 

  167.    RCCKSEL2_Bit             : constant Bit_Number := 6;
    168. 

  168.    RCCKSEL2_Mask            : constant Unsigned_8 := 16#40#;
    169. 

  169.    RCCKSEL3_Bit             : constant Bit_Number := 7;
    170. 

  170.    RCCKSEL3_Mask            : constant Unsigned_8 := 16#80#;
    171. 

  171. 

  172.    CLKSEL0_Addr             : constant Address    := 16#d0#;
    173. 

  173.    CLKSEL0                  : Unsigned_8 ;
    174. 

  174.    for CLKSEL0'Address use CLKSEL0_Addr;
    175. 

  175.    pragma Volatile (CLKSEL0);
    176. 

  176.    CLKSEL0_Bits             : Bits_In_Byte;
    177. 

  177.    for CLKSEL0_Bits'Address use CLKSEL0_Addr;
    178. 

  178.    pragma Volatile (CLKSEL0_Bits);
    179. 

  179.    CLKS_Bit                 : constant Bit_Number := 0;
    180. 

  180.    CLKS_Mask                : constant Unsigned_8 := 16#01#;
    181. 

  181.    EXTE_Bit                 : constant Bit_Number := 2;
    182. 

  182.    EXTE_Mask                : constant Unsigned_8 := 16#04#;
    183. 

  183.    RCE_Bit                  : constant Bit_Number := 3;
    184. 

  184.    RCE_Mask                 : constant Unsigned_8 := 16#08#;
    185. 

  185.    EXSUT0_Bit               : constant Bit_Number := 4;
    186. 

  186.    EXSUT0_Mask              : constant Unsigned_8 := 16#10#;
    187. 

  187.    EXSUT1_Bit               : constant Bit_Number := 5;
    188. 

  188.    EXSUT1_Mask              : constant Unsigned_8 := 16#20#;
    189. 

  189.    RCSUT0_Bit               : constant Bit_Number := 6;
    190. 

  190.    RCSUT0_Mask              : constant Unsigned_8 := 16#40#;
    191. 

  191.    RCSUT1_Bit               : constant Bit_Number := 7;
    192. 

  192.    RCSUT1_Mask              : constant Unsigned_8 := 16#80#;
    193. 

  193. 

  194.    --  PLL Status and Control register
    195. 

  195.    PLLCSR_Addr              : constant Address    := 16#49#;
    196. 

  196.    PLLCSR                   : Unsigned_8 ;
    197. 

  197.    for PLLCSR'Address use PLLCSR_Addr;
    198. 

  198.    pragma Volatile (PLLCSR);
    199. 

  199.    PLLCSR_Bits              : Bits_In_Byte;
    200. 

  200.    for PLLCSR_Bits'Address use PLLCSR_Addr;
    201. 

  201.    pragma Volatile (PLLCSR_Bits);
    202. 

  202.    --  PLL Lock Status Bit
    203. 

  203.    PLOCK_Bit                : constant Bit_Number := 0;
    204. 

  204.    PLOCK_Mask               : constant Unsigned_8 := 16#01#;
    205. 

  205.    --  PLL Enable Bit
    206. 

  206.    PLLE_Bit                 : constant Bit_Number := 1;
    207. 

  207.    PLLE_Mask                : constant Unsigned_8 := 16#02#;
    208. 

  208.    --  PLL prescaler Bit 0
    209. 

  209.    PLLP0_Bit                : constant Bit_Number := 2;
    210. 

  210.    PLLP0_Mask               : constant Unsigned_8 := 16#04#;
    211. 

  211.    --  PLL prescaler Bit 1
    212. 

  212.    PLLP1_Bit                : constant Bit_Number := 3;
    213. 

  213.    PLLP1_Mask               : constant Unsigned_8 := 16#08#;
    214. 

  214.    --  PLL prescaler Bit 2
    215. 

  215.    PLLP2_Bit                : constant Bit_Number := 4;
    216. 

  216.    PLLP2_Mask               : constant Unsigned_8 := 16#10#;
    217. 

  217. 

  218.    TESTPADSTATUS_Addr       : constant Address    := 16#fd#;
    219. 

  219.    TESTPADSTATUS            : Unsigned_8 ;
    220. 

  220.    for TESTPADSTATUS'Address use TESTPADSTATUS_Addr;
    221. 

  221.    pragma Volatile (TESTPADSTATUS);
    222. 

  222.    TESTPADSTATUS_Bits       : Bits_In_Byte;
    223. 

  223.    for TESTPADSTATUS_Bits'Address use TESTPADSTATUS_Addr;
    224. 

  224.    pragma Volatile (TESTPADSTATUS_Bits);
    225. 

  225. 

  226.    TESTPADPULL_Addr         : constant Address    := 16#fe#;
    227. 

  227.    TESTPADPULL              : Unsigned_8 ;
    228. 

  228.    for TESTPADPULL'Address use TESTPADPULL_Addr;
    229. 

  229.    pragma Volatile (TESTPADPULL);
    230. 

  230.    TESTPADPULL_Bits         : Bits_In_Byte;
    231. 

  231.    for TESTPADPULL_Bits'Address use TESTPADPULL_Addr;
    232. 

  232.    pragma Volatile (TESTPADPULL_Bits);
    233. 

  233. 

  234.    TESTPADCTRL_Addr         : constant Address    := 16#ff#;
    235. 

  235.    TESTPADCTRL              : Unsigned_8 ;
    236. 

  236.    for TESTPADCTRL'Address use TESTPADCTRL_Addr;
    237. 

  237.    pragma Volatile (TESTPADCTRL);
    238. 

  238.    TESTPADCTRL_Bits         : Bits_In_Byte;
    239. 

  239.    for TESTPADCTRL_Bits'Address use TESTPADCTRL_Addr;
    240. 

  240.    pragma Volatile (TESTPADCTRL_Bits);
    241. 

  241. 

  242.    --  PS2 Pad Enable register
    243. 

  243.    PS2CON_Addr              : constant Address    := 16#fa#;
    244. 

  244.    PS2CON                   : Unsigned_8 ;
    245. 

  245.    for PS2CON'Address use PS2CON_Addr;
    246. 

  246.    pragma Volatile (PS2CON);
    247. 

  247.    PS2CON_Bits              : Bits_In_Byte;
    248. 

  248.    for PS2CON_Bits'Address use PS2CON_Addr;
    249. 

  249.    pragma Volatile (PS2CON_Bits);
    250. 

  250.    --  Enable
    251. 

  251.    PS2EN_Bit                : constant Bit_Number := 0;
    252. 

  252.    PS2EN_Mask               : constant Unsigned_8 := 16#01#;
    253. 

  253. 

  254.    UPOE_Addr                : constant Address    := 16#fb#;
    255. 

  255.    UPOE                     : Unsigned_8 ;
    256. 

  256.    for UPOE'Address use UPOE_Addr;
    257. 

  257.    pragma Volatile (UPOE);
    258. 

  258.    UPOE_Bits                : Bits_In_Byte;
    259. 

  259.    for UPOE_Bits'Address use UPOE_Addr;
    260. 

  260.    pragma Volatile (UPOE_Bits);
    261. 

  261.    DMI_Bit                  : constant Bit_Number := 0;
    262. 

  262.    DMI_Mask                 : constant Unsigned_8 := 16#01#;
    263. 

  263.    DPI_Bit                  : constant Bit_Number := 1;
    264. 

  264.    DPI_Mask                 : constant Unsigned_8 := 16#02#;
    265. 

  265.    DATAI_Bit                : constant Bit_Number := 2;
    266. 

  266.    DATAI_Mask               : constant Unsigned_8 := 16#04#;
    267. 

  267.    SCKI_Bit                 : constant Bit_Number := 3;
    268. 

  268.    SCKI_Mask                : constant Unsigned_8 := 16#08#;
    269. 

  269.    UPDRV0_Bit               : constant Bit_Number := 4;
    270. 

  270.    UPDRV0_Mask              : constant Unsigned_8 := 16#10#;
    271. 

  271.    UPDRV1_Bit               : constant Bit_Number := 5;
    272. 

  272.    UPDRV1_Mask              : constant Unsigned_8 := 16#20#;
    273. 

  273.    UPWE0_Bit                : constant Bit_Number := 6;
    274. 

  274.    UPWE0_Mask               : constant Unsigned_8 := 16#40#;
    275. 

  275.    UPWE1_Bit                : constant Bit_Number := 7;
    276. 

  276.    UPWE1_Mask               : constant Unsigned_8 := 16#80#;
    277. 

  277. 

  278. 

  279.    UEINT_Addr               : constant Address    := 16#f4#;
    280. 

  280.    UEINT                    : Unsigned_8 ;
    281. 

  281.    for UEINT'Address use UEINT_Addr;
    282. 

  282.    pragma Volatile (UEINT);
    283. 

  283.    UEINT_Bits               : Bits_In_Byte;
    284. 

  284.    for UEINT_Bits'Address use UEINT_Addr;
    285. 

  285.    pragma Volatile (UEINT_Bits);
    286. 

  286.    EPINT0_Bit               : constant Bit_Number := 0;
    287. 

  287.    EPINT0_Mask              : constant Unsigned_8 := 16#01#;
    288. 

  288.    EPINT1_Bit               : constant Bit_Number := 1;
    289. 

  289.    EPINT1_Mask              : constant Unsigned_8 := 16#02#;
    290. 

  290.    EPINT2_Bit               : constant Bit_Number := 2;
    291. 

  291.    EPINT2_Mask              : constant Unsigned_8 := 16#04#;
    292. 

  292.    EPINT3_Bit               : constant Bit_Number := 3;
    293. 

  293.    EPINT3_Mask              : constant Unsigned_8 := 16#08#;
    294. 

  294.    EPINT4_Bit               : constant Bit_Number := 4;
    295. 

  295.    EPINT4_Mask              : constant Unsigned_8 := 16#10#;
    296. 

  296. 

  297.    UPINT_Addr               : constant Address    := 16#f8#;
    298. 

  298.    UPINT                    : Unsigned_8 ;
    299. 

  299.    for UPINT'Address use UPINT_Addr;
    300. 

  300.    pragma Volatile (UPINT);
    301. 

  301.    UPINT_Bits               : Bits_In_Byte;
    302. 

  302.    for UPINT_Bits'Address use UPINT_Addr;
    303. 

  303.    pragma Volatile (UPINT_Bits);
    304. 

  304. 

  305.    UPBCHX_Addr              : constant Address    := 16#f7#;
    306. 

  306.    UPBCHX                   : Unsigned_8 ;
    307. 

  307.    for UPBCHX'Address use UPBCHX_Addr;
    308. 

  308.    pragma Volatile (UPBCHX);
    309. 

  309.    UPBCHX_Bits              : Bits_In_Byte;
    310. 

  310.    for UPBCHX_Bits'Address use UPBCHX_Addr;
    311. 

  311.    pragma Volatile (UPBCHX_Bits);
    312. 

  312. 

  313.    UEBCLX_Addr              : constant Address    := 16#f2#;
    314. 

  314.    UEBCLX                   : Unsigned_8 ;
    315. 

  315.    for UEBCLX'Address use UEBCLX_Addr;
    316. 

  316.    pragma Volatile (UEBCLX);
    317. 

  317.    UEBCLX_Bits              : Bits_In_Byte;
    318. 

  318.    for UEBCLX_Bits'Address use UEBCLX_Addr;
    319. 

  319.    pragma Volatile (UEBCLX_Bits);
    320. 

  320.    BYCT0_Bit                : constant Bit_Number := 0;
    321. 

  321.    BYCT0_Mask               : constant Unsigned_8 := 16#01#;
    322. 

  322.    BYCT1_Bit                : constant Bit_Number := 1;
    323. 

  323.    BYCT1_Mask               : constant Unsigned_8 := 16#02#;
    324. 

  324.    BYCT2_Bit                : constant Bit_Number := 2;
    325. 

  325.    BYCT2_Mask               : constant Unsigned_8 := 16#04#;
    326. 

  326.    BYCT3_Bit                : constant Bit_Number := 3;
    327. 

  327.    BYCT3_Mask               : constant Unsigned_8 := 16#08#;
    328. 

  328.    BYCT4_Bit                : constant Bit_Number := 4;
    329. 

  329.    BYCT4_Mask               : constant Unsigned_8 := 16#10#;
    330. 

  330.    BYCT5_Bit                : constant Bit_Number := 5;
    331. 

  331.    BYCT5_Mask               : constant Unsigned_8 := 16#20#;
    332. 

  332.    BYCT6_Bit                : constant Bit_Number := 6;
    333. 

  333.    BYCT6_Mask               : constant Unsigned_8 := 16#40#;
    334. 

  334.    BYCT7_Bit                : constant Bit_Number := 7;
    335. 

  335.    BYCT7_Mask               : constant Unsigned_8 := 16#80#;
    336. 

  336. 

  337.    UPBCLX_Addr              : constant Address    := 16#f6#;
    338. 

  338.    UPBCLX                   : Unsigned_8 ;
    339. 

  339.    for UPBCLX'Address use UPBCLX_Addr;
    340. 

  340.    pragma Volatile (UPBCLX);
    341. 

  341.    UPBCLX_Bits              : Bits_In_Byte;
    342. 

  342.    for UPBCLX_Bits'Address use UPBCLX_Addr;
    343. 

  343.    pragma Volatile (UPBCLX_Bits);
    344. 

  344. 

  345.    UEDATX_Addr              : constant Address    := 16#f1#;
    346. 

  346.    UEDATX                   : Unsigned_8 ;
    347. 

  347.    for UEDATX'Address use UEDATX_Addr;
    348. 

  348.    pragma Volatile (UEDATX);
    349. 

  349.    UEDATX_Bits              : Bits_In_Byte;
    350. 

  350.    for UEDATX_Bits'Address use UEDATX_Addr;
    351. 

  351.    pragma Volatile (UEDATX_Bits);
    352. 

  352.    DAT0_Bit                 : constant Bit_Number := 0;
    353. 

  353.    DAT0_Mask                : constant Unsigned_8 := 16#01#;
    354. 

  354.    DAT1_Bit                 : constant Bit_Number := 1;
    355. 

  355.    DAT1_Mask                : constant Unsigned_8 := 16#02#;
    356. 

  356.    DAT2_Bit                 : constant Bit_Number := 2;
    357. 

  357.    DAT2_Mask                : constant Unsigned_8 := 16#04#;
    358. 

  358.    DAT3_Bit                 : constant Bit_Number := 3;
    359. 

  359.    DAT3_Mask                : constant Unsigned_8 := 16#08#;
    360. 

  360.    DAT4_Bit                 : constant Bit_Number := 4;
    361. 

  361.    DAT4_Mask                : constant Unsigned_8 := 16#10#;
    362. 

  362.    DAT5_Bit                 : constant Bit_Number := 5;
    363. 

  363.    DAT5_Mask                : constant Unsigned_8 := 16#20#;
    364. 

  364.    DAT6_Bit                 : constant Bit_Number := 6;
    365. 

  365.    DAT6_Mask                : constant Unsigned_8 := 16#40#;
    366. 

  366.    DAT7_Bit                 : constant Bit_Number := 7;
    367. 

  367.    DAT7_Mask                : constant Unsigned_8 := 16#80#;
    368. 

  368. 

  369.    UPDATX_Addr              : constant Address    := 16#af#;
    370. 

  370.    UPDATX                   : Unsigned_8 ;
    371. 

  371.    for UPDATX'Address use UPDATX_Addr;
    372. 

  372.    pragma Volatile (UPDATX);
    373. 

  373.    UPDATX_Bits              : Bits_In_Byte;
    374. 

  374.    for UPDATX_Bits'Address use UPDATX_Addr;
    375. 

  375.    pragma Volatile (UPDATX_Bits);
    376. 

  376. 

  377.    UEIENX_Addr              : constant Address    := 16#f0#;
    378. 

  378.    UEIENX                   : Unsigned_8 ;
    379. 

  379.    for UEIENX'Address use UEIENX_Addr;
    380. 

  380.    pragma Volatile (UEIENX);
    381. 

  381.    UEIENX_Bits              : Bits_In_Byte;
    382. 

  382.    for UEIENX_Bits'Address use UEIENX_Addr;
    383. 

  383.    pragma Volatile (UEIENX_Bits);
    384. 

  384.    TXINE_Bit                : constant Bit_Number := 0;
    385. 

  385.    TXINE_Mask               : constant Unsigned_8 := 16#01#;
    386. 

  386.    STALLEDE_Bit             : constant Bit_Number := 1;
    387. 

  387.    STALLEDE_Mask            : constant Unsigned_8 := 16#02#;
    388. 

  388.    RXOUTE_Bit               : constant Bit_Number := 2;
    389. 

  389.    RXOUTE_Mask              : constant Unsigned_8 := 16#04#;
    390. 

  390.    RXSTPE_Bit               : constant Bit_Number := 3;
    391. 

  391.    RXSTPE_Mask              : constant Unsigned_8 := 16#08#;
    392. 

  392.    NAKOUTE_Bit              : constant Bit_Number := 4;
    393. 

  393.    NAKOUTE_Mask             : constant Unsigned_8 := 16#10#;
    394. 

  394.    NAKINE_Bit               : constant Bit_Number := 6;
    395. 

  395.    NAKINE_Mask              : constant Unsigned_8 := 16#40#;
    396. 

  396.    FLERRE_Bit               : constant Bit_Number := 7;
    397. 

  397.    FLERRE_Mask              : constant Unsigned_8 := 16#80#;
    398. 

  398. 

  399.    UPIENX_Addr              : constant Address    := 16#ae#;
    400. 

  400.    UPIENX                   : Unsigned_8 ;
    401. 

  401.    for UPIENX'Address use UPIENX_Addr;
    402. 

  402.    pragma Volatile (UPIENX);
    403. 

  403.    UPIENX_Bits              : Bits_In_Byte;
    404. 

  404.    for UPIENX_Bits'Address use UPIENX_Addr;
    405. 

  405.    pragma Volatile (UPIENX_Bits);
    406. 

  406. 

  407.    UESTA1X_Addr             : constant Address    := 16#ef#;
    408. 

  408.    UESTA1X                  : Unsigned_8 ;
    409. 

  409.    for UESTA1X'Address use UESTA1X_Addr;
    410. 

  410.    pragma Volatile (UESTA1X);
    411. 

  411.    UESTA1X_Bits             : Bits_In_Byte;
    412. 

  412.    for UESTA1X_Bits'Address use UESTA1X_Addr;
    413. 

  413.    pragma Volatile (UESTA1X_Bits);
    414. 

  414.    CURRBK0_Bit              : constant Bit_Number := 0;
    415. 

  415.    CURRBK0_Mask             : constant Unsigned_8 := 16#01#;
    416. 

  416.    CURRBK1_Bit              : constant Bit_Number := 1;
    417. 

  417.    CURRBK1_Mask             : constant Unsigned_8 := 16#02#;
    418. 

  418.    CTRLDIR_Bit              : constant Bit_Number := 2;
    419. 

  419.    CTRLDIR_Mask             : constant Unsigned_8 := 16#04#;
    420. 

  420. 

  421.    UPCFG2X_Addr             : constant Address    := 16#ad#;
    422. 

  422.    UPCFG2X                  : Unsigned_8 ;
    423. 

  423.    for UPCFG2X'Address use UPCFG2X_Addr;
    424. 

  424.    pragma Volatile (UPCFG2X);
    425. 

  425.    UPCFG2X_Bits             : Bits_In_Byte;
    426. 

  426.    for UPCFG2X_Bits'Address use UPCFG2X_Addr;
    427. 

  427.    pragma Volatile (UPCFG2X_Bits);
    428. 

  428. 

  429.    UESTA0X_Addr             : constant Address    := 16#ee#;
    430. 

  430.    UESTA0X                  : Unsigned_8 ;
    431. 

  431.    for UESTA0X'Address use UESTA0X_Addr;
    432. 

  432.    pragma Volatile (UESTA0X);
    433. 

  433.    UESTA0X_Bits             : Bits_In_Byte;
    434. 

  434.    for UESTA0X_Bits'Address use UESTA0X_Addr;
    435. 

  435.    pragma Volatile (UESTA0X_Bits);
    436. 

  436.    NBUSYBK0_Bit             : constant Bit_Number := 0;
    437. 

  437.    NBUSYBK0_Mask            : constant Unsigned_8 := 16#01#;
    438. 

  438.    NBUSYBK1_Bit             : constant Bit_Number := 1;
    439. 

  439.    NBUSYBK1_Mask            : constant Unsigned_8 := 16#02#;
    440. 

  440.    DTSEQ0_Bit               : constant Bit_Number := 2;
    441. 

  441.    DTSEQ0_Mask              : constant Unsigned_8 := 16#04#;
    442. 

  442.    DTSEQ1_Bit               : constant Bit_Number := 3;
    443. 

  443.    DTSEQ1_Mask              : constant Unsigned_8 := 16#08#;
    444. 

  444.    UNDERFI_Bit              : constant Bit_Number := 5;
    445. 

  445.    UNDERFI_Mask             : constant Unsigned_8 := 16#20#;
    446. 

  446.    OVERFI_Bit               : constant Bit_Number := 6;
    447. 

  447.    OVERFI_Mask              : constant Unsigned_8 := 16#40#;
    448. 

  448.    CFGOK_Bit                : constant Bit_Number := 7;
    449. 

  449.    CFGOK_Mask               : constant Unsigned_8 := 16#80#;
    450. 

  450. 

  451.    UPSTAX_Addr              : constant Address    := 16#ac#;
    452. 

  452.    UPSTAX                   : Unsigned_8 ;
    453. 

  453.    for UPSTAX'Address use UPSTAX_Addr;
    454. 

  454.    pragma Volatile (UPSTAX);
    455. 

  455.    UPSTAX_Bits              : Bits_In_Byte;
    456. 

  456.    for UPSTAX_Bits'Address use UPSTAX_Addr;
    457. 

  457.    pragma Volatile (UPSTAX_Bits);
    458. 

  458. 

  459.    UECFG1X_Addr             : constant Address    := 16#ed#;
    460. 

  460.    UECFG1X                  : Unsigned_8 ;
    461. 

  461.    for UECFG1X'Address use UECFG1X_Addr;
    462. 

  462.    pragma Volatile (UECFG1X);
    463. 

  463.    UECFG1X_Bits             : Bits_In_Byte;
    464. 

  464.    for UECFG1X_Bits'Address use UECFG1X_Addr;
    465. 

  465.    pragma Volatile (UECFG1X_Bits);
    466. 

  466.    ALLOC_Bit                : constant Bit_Number := 1;
    467. 

  467.    ALLOC_Mask               : constant Unsigned_8 := 16#02#;
    468. 

  468.    EPBK0_Bit                : constant Bit_Number := 2;
    469. 

  469.    EPBK0_Mask               : constant Unsigned_8 := 16#04#;
    470. 

  470.    EPBK1_Bit                : constant Bit_Number := 3;
    471. 

  471.    EPBK1_Mask               : constant Unsigned_8 := 16#08#;
    472. 

  472.    EPSIZE0_Bit              : constant Bit_Number := 4;
    473. 

  473.    EPSIZE0_Mask             : constant Unsigned_8 := 16#10#;
    474. 

  474.    EPSIZE1_Bit              : constant Bit_Number := 5;
    475. 

  475.    EPSIZE1_Mask             : constant Unsigned_8 := 16#20#;
    476. 

  476.    EPSIZE2_Bit              : constant Bit_Number := 6;
    477. 

  477.    EPSIZE2_Mask             : constant Unsigned_8 := 16#40#;
    478. 

  478. 

  479.    UPCFG1X_Addr             : constant Address    := 16#ab#;
    480. 

  480.    UPCFG1X                  : Unsigned_8 ;
    481. 

  481.    for UPCFG1X'Address use UPCFG1X_Addr;
    482. 

  482.    pragma Volatile (UPCFG1X);
    483. 

  483.    UPCFG1X_Bits             : Bits_In_Byte;
    484. 

  484.    for UPCFG1X_Bits'Address use UPCFG1X_Addr;
    485. 

  485.    pragma Volatile (UPCFG1X_Bits);
    486. 

  486. 

  487.    UECFG0X_Addr             : constant Address    := 16#ec#;
    488. 

  488.    UECFG0X                  : Unsigned_8 ;
    489. 

  489.    for UECFG0X'Address use UECFG0X_Addr;
    490. 

  490.    pragma Volatile (UECFG0X);
    491. 

  491.    UECFG0X_Bits             : Bits_In_Byte;
    492. 

  492.    for UECFG0X_Bits'Address use UECFG0X_Addr;
    493. 

  493.    pragma Volatile (UECFG0X_Bits);
    494. 

  494.    EPDIR_Bit                : constant Bit_Number := 0;
    495. 

  495.    EPDIR_Mask               : constant Unsigned_8 := 16#01#;
    496. 

  496.    EPTYPE0_Bit              : constant Bit_Number := 6;
    497. 

  497.    EPTYPE0_Mask             : constant Unsigned_8 := 16#40#;
    498. 

  498.    EPTYPE1_Bit              : constant Bit_Number := 7;
    499. 

  499.    EPTYPE1_Mask             : constant Unsigned_8 := 16#80#;
    500. 

  500. 

  501.    UPCFG0X_Addr             : constant Address    := 16#aa#;
    502. 

  502.    UPCFG0X                  : Unsigned_8 ;
    503. 

  503.    for UPCFG0X'Address use UPCFG0X_Addr;
    504. 

  504.    pragma Volatile (UPCFG0X);
    505. 

  505.    UPCFG0X_Bits             : Bits_In_Byte;
    506. 

  506.    for UPCFG0X_Bits'Address use UPCFG0X_Addr;
    507. 

  507.    pragma Volatile (UPCFG0X_Bits);
    508. 

  508. 

  509.    UECONX_Addr              : constant Address    := 16#eb#;
    510. 

  510.    UECONX                   : Unsigned_8 ;
    511. 

  511.    for UECONX'Address use UECONX_Addr;
    512. 

  512.    pragma Volatile (UECONX);
    513. 

  513.    UECONX_Bits              : Bits_In_Byte;
    514. 

  514.    for UECONX_Bits'Address use UECONX_Addr;
    515. 

  515.    pragma Volatile (UECONX_Bits);
    516. 

  516.    EPEN_Bit                 : constant Bit_Number := 0;
    517. 

  517.    EPEN_Mask                : constant Unsigned_8 := 16#01#;
    518. 

  518.    RSTDT_Bit                : constant Bit_Number := 3;
    519. 

  519.    RSTDT_Mask               : constant Unsigned_8 := 16#08#;
    520. 

  520.    STALLRQC_Bit             : constant Bit_Number := 4;
    521. 

  521.    STALLRQC_Mask            : constant Unsigned_8 := 16#10#;
    522. 

  522.    STALLRQ_Bit              : constant Bit_Number := 5;
    523. 

  523.    STALLRQ_Mask             : constant Unsigned_8 := 16#20#;
    524. 

  524. 

  525.    UPCONX_Addr              : constant Address    := 16#a9#;
    526. 

  526.    UPCONX                   : Unsigned_8 ;
    527. 

  527.    for UPCONX'Address use UPCONX_Addr;
    528. 

  528.    pragma Volatile (UPCONX);
    529. 

  529.    UPCONX_Bits              : Bits_In_Byte;
    530. 

  530.    for UPCONX_Bits'Address use UPCONX_Addr;
    531. 

  531.    pragma Volatile (UPCONX_Bits);
    532. 

  532. 

  533.    UERST_Addr               : constant Address    := 16#ea#;
    534. 

  534.    UERST                    : Unsigned_8 ;
    535. 

  535.    for UERST'Address use UERST_Addr;
    536. 

  536.    pragma Volatile (UERST);
    537. 

  537.    UERST_Bits               : Bits_In_Byte;
    538. 

  538.    for UERST_Bits'Address use UERST_Addr;
    539. 

  539.    pragma Volatile (UERST_Bits);
    540. 

  540.    EPRST0_Bit               : constant Bit_Number := 0;
    541. 

  541.    EPRST0_Mask              : constant Unsigned_8 := 16#01#;
    542. 

  542.    EPRST1_Bit               : constant Bit_Number := 1;
    543. 

  543.    EPRST1_Mask              : constant Unsigned_8 := 16#02#;
    544. 

  544.    EPRST2_Bit               : constant Bit_Number := 2;
    545. 

  545.    EPRST2_Mask              : constant Unsigned_8 := 16#04#;
    546. 

  546.    EPRST3_Bit               : constant Bit_Number := 3;
    547. 

  547.    EPRST3_Mask              : constant Unsigned_8 := 16#08#;
    548. 

  548.    EPRST4_Bit               : constant Bit_Number := 4;
    549. 

  549.    EPRST4_Mask              : constant Unsigned_8 := 16#10#;
    550. 

  550. 

  551.    UPRST_Addr               : constant Address    := 16#a8#;
    552. 

  552.    UPRST                    : Unsigned_8 ;
    553. 

  553.    for UPRST'Address use UPRST_Addr;
    554. 

  554.    pragma Volatile (UPRST);
    555. 

  555.    UPRST_Bits               : Bits_In_Byte;
    556. 

  556.    for UPRST_Bits'Address use UPRST_Addr;
    557. 

  557.    pragma Volatile (UPRST_Bits);
    558. 

  558. 

  559.    UENUM_Addr               : constant Address    := 16#e9#;
    560. 

  560.    UENUM                    : Unsigned_8 ;
    561. 

  561.    for UENUM'Address use UENUM_Addr;
    562. 

  562.    pragma Volatile (UENUM);
    563. 

  563.    UENUM_Bits               : Bits_In_Byte;
    564. 

  564.    for UENUM_Bits'Address use UENUM_Addr;
    565. 

  565.    pragma Volatile (UENUM_Bits);
    566. 

  566.    EPNUM0_Bit               : constant Bit_Number := 0;
    567. 

  567.    EPNUM0_Mask              : constant Unsigned_8 := 16#01#;
    568. 

  568.    EPNUM1_Bit               : constant Bit_Number := 1;
    569. 

  569.    EPNUM1_Mask              : constant Unsigned_8 := 16#02#;
    570. 

  570.    EPNUM2_Bit               : constant Bit_Number := 2;
    571. 

  571.    EPNUM2_Mask              : constant Unsigned_8 := 16#04#;
    572. 

  572. 

  573.    UPNUM_Addr               : constant Address    := 16#a7#;
    574. 

  574.    UPNUM                    : Unsigned_8 ;
    575. 

  575.    for UPNUM'Address use UPNUM_Addr;
    576. 

  576.    pragma Volatile (UPNUM);
    577. 

  577.    UPNUM_Bits               : Bits_In_Byte;
    578. 

  578.    for UPNUM_Bits'Address use UPNUM_Addr;
    579. 

  579.    pragma Volatile (UPNUM_Bits);
    580. 

  580. 

  581.    UEINTX_Addr              : constant Address    := 16#e8#;
    582. 

  582.    UEINTX                   : Unsigned_8 ;
    583. 

  583.    for UEINTX'Address use UEINTX_Addr;
    584. 

  584.    pragma Volatile (UEINTX);
    585. 

  585.    UEINTX_Bits              : Bits_In_Byte;
    586. 

  586.    for UEINTX_Bits'Address use UEINTX_Addr;
    587. 

  587.    pragma Volatile (UEINTX_Bits);
    588. 

  588.    TXINI_Bit                : constant Bit_Number := 0;
    589. 

  589.    TXINI_Mask               : constant Unsigned_8 := 16#01#;
    590. 

  590.    STALLEDI_Bit             : constant Bit_Number := 1;
    591. 

  591.    STALLEDI_Mask            : constant Unsigned_8 := 16#02#;
    592. 

  592.    RXOUTI_Bit               : constant Bit_Number := 2;
    593. 

  593.    RXOUTI_Mask              : constant Unsigned_8 := 16#04#;
    594. 

  594.    RXSTPI_Bit               : constant Bit_Number := 3;
    595. 

  595.    RXSTPI_Mask              : constant Unsigned_8 := 16#08#;
    596. 

  596.    NAKOUTI_Bit              : constant Bit_Number := 4;
    597. 

  597.    NAKOUTI_Mask             : constant Unsigned_8 := 16#10#;
    598. 

  598.    RWAL_Bit                 : constant Bit_Number := 5;
    599. 

  599.    RWAL_Mask                : constant Unsigned_8 := 16#20#;
    600. 

  600.    NAKINI_Bit               : constant Bit_Number := 6;
    601. 

  601.    NAKINI_Mask              : constant Unsigned_8 := 16#40#;
    602. 

  602.    FIFOCON_Bit              : constant Bit_Number := 7;
    603. 

  603.    FIFOCON_Mask             : constant Unsigned_8 := 16#80#;
    604. 

  604. 

  605.    UPINTX_Addr              : constant Address    := 16#a6#;
    606. 

  606.    UPINTX                   : Unsigned_8 ;
    607. 

  607.    for UPINTX'Address use UPINTX_Addr;
    608. 

  608.    pragma Volatile (UPINTX);
    609. 

  609.    UPINTX_Bits              : Bits_In_Byte;
    610. 

  610.    for UPINTX_Bits'Address use UPINTX_Addr;
    611. 

  611.    pragma Volatile (UPINTX_Bits);
    612. 

  612. 

  613.    UDTST_Addr               : constant Address    := 16#e7#;
    614. 

  614.    UDTST                    : Unsigned_8 ;
    615. 

  615.    for UDTST'Address use UDTST_Addr;
    616. 

  616.    pragma Volatile (UDTST);
    617. 

  617.    UDTST_Bits               : Bits_In_Byte;
    618. 

  618.    for UDTST_Bits'Address use UDTST_Addr;
    619. 

  619.    pragma Volatile (UDTST_Bits);
    620. 

  620. 

  621.    UPINRQX_Addr             : constant Address    := 16#a5#;
    622. 

  622.    UPINRQX                  : Unsigned_8 ;
    623. 

  623.    for UPINRQX'Address use UPINRQX_Addr;
    624. 

  624.    pragma Volatile (UPINRQX);
    625. 

  625.    UPINRQX_Bits             : Bits_In_Byte;
    626. 

  626.    for UPINRQX_Bits'Address use UPINRQX_Addr;
    627. 

  627.    pragma Volatile (UPINRQX_Bits);
    628. 

  628. 

  629.    UDMFN_Addr               : constant Address    := 16#e6#;
    630. 

  630.    UDMFN                    : Unsigned_8 ;
    631. 

  631.    for UDMFN'Address use UDMFN_Addr;
    632. 

  632.    pragma Volatile (UDMFN);
    633. 

  633.    UDMFN_Bits               : Bits_In_Byte;
    634. 

  634.    for UDMFN_Bits'Address use UDMFN_Addr;
    635. 

  635.    pragma Volatile (UDMFN_Bits);
    636. 

  636.    FNCERR_Bit               : constant Bit_Number := 4;
    637. 

  637.    FNCERR_Mask              : constant Unsigned_8 := 16#10#;
    638. 

  638. 

  639.    UHFLEN_Addr              : constant Address    := 16#a4#;
    640. 

  640.    UHFLEN                   : Unsigned_8 ;
    641. 

  641.    for UHFLEN'Address use UHFLEN_Addr;
    642. 

  642.    pragma Volatile (UHFLEN);
    643. 

  643.    UHFLEN_Bits              : Bits_In_Byte;
    644. 

  644.    for UHFLEN_Bits'Address use UHFLEN_Addr;
    645. 

  645.    pragma Volatile (UHFLEN_Bits);
    646. 

  646. 

  647.    UDFNUMH_Addr             : constant Address    := 16#e5#;
    648. 

  648.    UDFNUMH                  : Unsigned_8 ;
    649. 

  649.    for UDFNUMH'Address use UDFNUMH_Addr;
    650. 

  650.    pragma Volatile (UDFNUMH);
    651. 

  651.    UDFNUMH_Bits             : Bits_In_Byte;
    652. 

  652.    for UDFNUMH_Bits'Address use UDFNUMH_Addr;
    653. 

  653.    pragma Volatile (UDFNUMH_Bits);
    654. 

  654.    FNUM8_Bit                : constant Bit_Number := 0;
    655. 

  655.    FNUM8_Mask               : constant Unsigned_8 := 16#01#;
    656. 

  656.    FNUM9_Bit                : constant Bit_Number := 1;
    657. 

  657.    FNUM9_Mask               : constant Unsigned_8 := 16#02#;
    658. 

  658.    FNUM10_Bit               : constant Bit_Number := 2;
    659. 

  659.    FNUM10_Mask              : constant Unsigned_8 := 16#04#;
    660. 

  660. 

  661.    UHFNUMH_Addr             : constant Address    := 16#a3#;
    662. 

  662.    UHFNUMH                  : Unsigned_8 ;
    663. 

  663.    for UHFNUMH'Address use UHFNUMH_Addr;
    664. 

  664.    pragma Volatile (UHFNUMH);
    665. 

  665.    UHFNUMH_Bits             : Bits_In_Byte;
    666. 

  666.    for UHFNUMH_Bits'Address use UHFNUMH_Addr;
    667. 

  667.    pragma Volatile (UHFNUMH_Bits);
    668. 

  668. 

  669.    UDFNUML_Addr             : constant Address    := 16#e4#;
    670. 

  670.    UDFNUM                   : Unsigned_16;
    671. 

  671.    for UDFNUM'Address use UDFNUML_Addr;
    672. 

  672.    pragma Volatile (UDFNUM);
    673. 

  673.    UDFNUML                  : Unsigned_8 ;
    674. 

  674.    for UDFNUML'Address use UDFNUML_Addr;
    675. 

  675.    pragma Volatile (UDFNUML);
    676. 

  676.    UDFNUML_Bits             : Bits_In_Byte;
    677. 

  677.    for UDFNUML_Bits'Address use UDFNUML_Addr;
    678. 

  678.    pragma Volatile (UDFNUML_Bits);
    679. 

  679.    FNUM0_Bit                : constant Bit_Number := 0;
    680. 

  680.    FNUM0_Mask               : constant Unsigned_8 := 16#01#;
    681. 

  681.    FNUM1_Bit                : constant Bit_Number := 1;
    682. 

  682.    FNUM1_Mask               : constant Unsigned_8 := 16#02#;
    683. 

  683.    FNUM2_Bit                : constant Bit_Number := 2;
    684. 

  684.    FNUM2_Mask               : constant Unsigned_8 := 16#04#;
    685. 

  685.    FNUM3_Bit                : constant Bit_Number := 3;
    686. 

  686.    FNUM3_Mask               : constant Unsigned_8 := 16#08#;
    687. 

  687.    FNUM4_Bit                : constant Bit_Number := 4;
    688. 

  688.    FNUM4_Mask               : constant Unsigned_8 := 16#10#;
    689. 

  689.    FNUM5_Bit                : constant Bit_Number := 5;
    690. 

  690.    FNUM5_Mask               : constant Unsigned_8 := 16#20#;
    691. 

  691.    FNUM6_Bit                : constant Bit_Number := 6;
    692. 

  692.    FNUM6_Mask               : constant Unsigned_8 := 16#40#;
    693. 

  693.    FNUM7_Bit                : constant Bit_Number := 7;
    694. 

  694.    FNUM7_Mask               : constant Unsigned_8 := 16#80#;
    695. 

  695. 

  696.    UHFNUML_Addr             : constant Address    := 16#a2#;
    697. 

  697.    UHFNUML                  : Unsigned_8 ;
    698. 

  698.    for UHFNUML'Address use UHFNUML_Addr;
    699. 

  699.    pragma Volatile (UHFNUML);
    700. 

  700.    UHFNUML_Bits             : Bits_In_Byte;
    701. 

  701.    for UHFNUML_Bits'Address use UHFNUML_Addr;
    702. 

  702.    pragma Volatile (UHFNUML_Bits);
    703. 

  703. 

  704.    UDADDR_Addr              : constant Address    := 16#e3#;
    705. 

  705.    UDADDR                   : Unsigned_8 ;
    706. 

  706.    for UDADDR'Address use UDADDR_Addr;
    707. 

  707.    pragma Volatile (UDADDR);
    708. 

  708.    UDADDR_Bits              : Bits_In_Byte;
    709. 

  709.    for UDADDR_Bits'Address use UDADDR_Addr;
    710. 

  710.    pragma Volatile (UDADDR_Bits);
    711. 

  711.    UADD0_Bit                : constant Bit_Number := 0;
    712. 

  712.    UADD0_Mask               : constant Unsigned_8 := 16#01#;
    713. 

  713.    UADD1_Bit                : constant Bit_Number := 1;
    714. 

  714.    UADD1_Mask               : constant Unsigned_8 := 16#02#;
    715. 

  715.    UADD2_Bit                : constant Bit_Number := 2;
    716. 

  716.    UADD2_Mask               : constant Unsigned_8 := 16#04#;
    717. 

  717.    UADD3_Bit                : constant Bit_Number := 3;
    718. 

  718.    UADD3_Mask               : constant Unsigned_8 := 16#08#;
    719. 

  719.    UADD4_Bit                : constant Bit_Number := 4;
    720. 

  720.    UADD4_Mask               : constant Unsigned_8 := 16#10#;
    721. 

  721.    UADD5_Bit                : constant Bit_Number := 5;
    722. 

  722.    UADD5_Mask               : constant Unsigned_8 := 16#20#;
    723. 

  723.    UADD6_Bit                : constant Bit_Number := 6;
    724. 

  724.    UADD6_Mask               : constant Unsigned_8 := 16#40#;
    725. 

  725.    ADDEN_Bit                : constant Bit_Number := 7;
    726. 

  726.    ADDEN_Mask               : constant Unsigned_8 := 16#80#;
    727. 

  727. 

  728.    UHADDR_Addr              : constant Address    := 16#a1#;
    729. 

  729.    UHADDR                   : Unsigned_8 ;
    730. 

  730.    for UHADDR'Address use UHADDR_Addr;
    731. 

  731.    pragma Volatile (UHADDR);
    732. 

  732.    UHADDR_Bits              : Bits_In_Byte;
    733. 

  733.    for UHADDR_Bits'Address use UHADDR_Addr;
    734. 

  734.    pragma Volatile (UHADDR_Bits);
    735. 

  735. 

  736.    UDIEN_Addr               : constant Address    := 16#e2#;
    737. 

  737.    UDIEN                    : Unsigned_8 ;
    738. 

  738.    for UDIEN'Address use UDIEN_Addr;
    739. 

  739.    pragma Volatile (UDIEN);
    740. 

  740.    UDIEN_Bits               : Bits_In_Byte;
    741. 

  741.    for UDIEN_Bits'Address use UDIEN_Addr;
    742. 

  742.    pragma Volatile (UDIEN_Bits);
    743. 

  743.    SUSPE_Bit                : constant Bit_Number := 0;
    744. 

  744.    SUSPE_Mask               : constant Unsigned_8 := 16#01#;
    745. 

  745.    SOFE_Bit                 : constant Bit_Number := 2;
    746. 

  746.    SOFE_Mask                : constant Unsigned_8 := 16#04#;
    747. 

  747.    EORSTE_Bit               : constant Bit_Number := 3;
    748. 

  748.    EORSTE_Mask              : constant Unsigned_8 := 16#08#;
    749. 

  749.    WAKEUPE_Bit              : constant Bit_Number := 4;
    750. 

  750.    WAKEUPE_Mask             : constant Unsigned_8 := 16#10#;
    751. 

  751.    EORSME_Bit               : constant Bit_Number := 5;
    752. 

  752.    EORSME_Mask              : constant Unsigned_8 := 16#20#;
    753. 

  753.    UPRSME_Bit               : constant Bit_Number := 6;
    754. 

  754.    UPRSME_Mask              : constant Unsigned_8 := 16#40#;
    755. 

  755. 

  756.    UHIEN_Addr               : constant Address    := 16#a0#;
    757. 

  757.    UHIEN                    : Unsigned_8 ;
    758. 

  758.    for UHIEN'Address use UHIEN_Addr;
    759. 

  759.    pragma Volatile (UHIEN);
    760. 

  760.    UHIEN_Bits               : Bits_In_Byte;
    761. 

  761.    for UHIEN_Bits'Address use UHIEN_Addr;
    762. 

  762.    pragma Volatile (UHIEN_Bits);
    763. 

  763. 

  764.    UDINT_Addr               : constant Address    := 16#e1#;
    765. 

  765.    UDINT                    : Unsigned_8 ;
    766. 

  766.    for UDINT'Address use UDINT_Addr;
    767. 

  767.    pragma Volatile (UDINT);
    768. 

  768.    UDINT_Bits               : Bits_In_Byte;
    769. 

  769.    for UDINT_Bits'Address use UDINT_Addr;
    770. 

  770.    pragma Volatile (UDINT_Bits);
    771. 

  771.    SUSPI_Bit                : constant Bit_Number := 0;
    772. 

  772.    SUSPI_Mask               : constant Unsigned_8 := 16#01#;
    773. 

  773.    SOFI_Bit                 : constant Bit_Number := 2;
    774. 

  774.    SOFI_Mask                : constant Unsigned_8 := 16#04#;
    775. 

  775.    EORSTI_Bit               : constant Bit_Number := 3;
    776. 

  776.    EORSTI_Mask              : constant Unsigned_8 := 16#08#;
    777. 

  777.    WAKEUPI_Bit              : constant Bit_Number := 4;
    778. 

  778.    WAKEUPI_Mask             : constant Unsigned_8 := 16#10#;
    779. 

  779.    EORSMI_Bit               : constant Bit_Number := 5;
    780. 

  780.    EORSMI_Mask              : constant Unsigned_8 := 16#20#;
    781. 

  781.    UPRSMI_Bit               : constant Bit_Number := 6;
    782. 

  782.    UPRSMI_Mask              : constant Unsigned_8 := 16#40#;
    783. 

  783. 

  784.    UHINT_Addr               : constant Address    := 16#9f#;
    785. 

  785.    UHINT                    : Unsigned_8 ;
    786. 

  786.    for UHINT'Address use UHINT_Addr;
    787. 

  787.    pragma Volatile (UHINT);
    788. 

  788.    UHINT_Bits               : Bits_In_Byte;
    789. 

  789.    for UHINT_Bits'Address use UHINT_Addr;
    790. 

  790.    pragma Volatile (UHINT_Bits);
    791. 

  791. 

  792.    UDCON_Addr               : constant Address    := 16#e0#;
    793. 

  793.    UDCON                    : Unsigned_8 ;
    794. 

  794.    for UDCON'Address use UDCON_Addr;
    795. 

  795.    pragma Volatile (UDCON);
    796. 

  796.    UDCON_Bits               : Bits_In_Byte;
    797. 

  797.    for UDCON_Bits'Address use UDCON_Addr;
    798. 

  798.    pragma Volatile (UDCON_Bits);
    799. 

  799.    DETACH_Bit               : constant Bit_Number := 0;
    800. 

  800.    DETACH_Mask              : constant Unsigned_8 := 16#01#;
    801. 

  801.    RMWKUP_Bit               : constant Bit_Number := 1;
    802. 

  802.    RMWKUP_Mask              : constant Unsigned_8 := 16#02#;
    803. 

  803.    RSTCPU_Bit               : constant Bit_Number := 2;
    804. 

  804.    RSTCPU_Mask              : constant Unsigned_8 := 16#04#;
    805. 

  805. 

  806.    UHCON_Addr               : constant Address    := 16#9e#;
    807. 

  807.    UHCON                    : Unsigned_8 ;
    808. 

  808.    for UHCON'Address use UHCON_Addr;
    809. 

  809.    pragma Volatile (UHCON);
    810. 

  810.    UHCON_Bits               : Bits_In_Byte;
    811. 

  811.    for UHCON_Bits'Address use UHCON_Addr;
    812. 

  812.    pragma Volatile (UHCON_Bits);
    813. 

  813. 

  814.    USBINT_Addr              : constant Address    := 16#da#;
    815. 

  815.    USBINT                   : Unsigned_8 ;
    816. 

  816.    for USBINT'Address use USBINT_Addr;
    817. 

  817.    pragma Volatile (USBINT);
    818. 

  818.    USBINT_Bits              : Bits_In_Byte;
    819. 

  819.    for USBINT_Bits'Address use USBINT_Addr;
    820. 

  820.    pragma Volatile (USBINT_Bits);
    821. 

  821. 

  822.    --  USB General Control Register
    823. 

  823.    USBCON_Addr              : constant Address    := 16#d8#;
    824. 

  824.    USBCON                   : Unsigned_8 ;
    825. 

  825.    for USBCON'Address use USBCON_Addr;
    826. 

  826.    pragma Volatile (USBCON);
    827. 

  827.    USBCON_Bits              : Bits_In_Byte;
    828. 

  828.    for USBCON_Bits'Address use USBCON_Addr;
    829. 

  829.    pragma Volatile (USBCON_Bits);
    830. 

  830.    FRZCLK_Bit               : constant Bit_Number := 5;
    831. 

  831.    FRZCLK_Mask              : constant Unsigned_8 := 16#20#;
    832. 

  832.    USBE_Bit                 : constant Bit_Number := 7;
    833. 

  833.    USBE_Mask                : constant Unsigned_8 := 16#80#;
    834. 

  834. 

  835.    --  Regulator Control Register
    836. 

  836.    REGCR_Addr               : constant Address    := 16#63#;
    837. 

  837.    REGCR                    : Unsigned_8 ;
    838. 

  838.    for REGCR'Address use REGCR_Addr;
    839. 

  839.    pragma Volatile (REGCR);
    840. 

  840.    REGCR_Bits               : Bits_In_Byte;
    841. 

  841.    for REGCR_Bits'Address use REGCR_Addr;
    842. 

  842.    pragma Volatile (REGCR_Bits);
    843. 

  843.    REGDIS_Bit               : constant Bit_Number := 0;
    844. 

  844.    REGDIS_Mask              : constant Unsigned_8 := 16#01#;
    845. 

  845. 

  846.    --  USART I/O Data Register
    847. 

  847.    UDR1_Addr                : constant Address    := 16#ce#;
    848. 

  848.    UDR1                     : Unsigned_8 ;
    849. 

  849.    for UDR1'Address use UDR1_Addr;
    850. 

  850.    pragma Volatile (UDR1);
    851. 

  851.    UDR1_Bits                : Bits_In_Byte;
    852. 

  852.    for UDR1_Bits'Address use UDR1_Addr;
    853. 

  853.    pragma Volatile (UDR1_Bits);
    854. 

  854.    --  USART I/O Data Register bit 0
    855. 

  855.    UDR1_0_Bit               : constant Bit_Number := 0;
    856. 

  856.    UDR1_0_Mask              : constant Unsigned_8 := 16#01#;
    857. 

  857.    --  USART I/O Data Register bit 1
    858. 

  858.    UDR1_1_Bit               : constant Bit_Number := 1;
    859. 

  859.    UDR1_1_Mask              : constant Unsigned_8 := 16#02#;
    860. 

  860.    --  USART I/O Data Register bit 2
    861. 

  861.    UDR1_2_Bit               : constant Bit_Number := 2;
    862. 

  862.    UDR1_2_Mask              : constant Unsigned_8 := 16#04#;
    863. 

  863.    --  USART I/O Data Register bit 3
    864. 

  864.    UDR1_3_Bit               : constant Bit_Number := 3;
    865. 

  865.    UDR1_3_Mask              : constant Unsigned_8 := 16#08#;
    866. 

  866.    --  USART I/O Data Register bit 4
    867. 

  867.    UDR1_4_Bit               : constant Bit_Number := 4;
    868. 

  868.    UDR1_4_Mask              : constant Unsigned_8 := 16#10#;
    869. 

  869.    --  USART I/O Data Register bit 5
    870. 

  870.    UDR1_5_Bit               : constant Bit_Number := 5;
    871. 

  871.    UDR1_5_Mask              : constant Unsigned_8 := 16#20#;
    872. 

  872.    --  USART I/O Data Register bit 6
    873. 

  873.    UDR1_6_Bit               : constant Bit_Number := 6;
    874. 

  874.    UDR1_6_Mask              : constant Unsigned_8 := 16#40#;
    875. 

  875.    --  USART I/O Data Register bit 7
    876. 

  876.    UDR1_7_Bit               : constant Bit_Number := 7;
    877. 

  877.    UDR1_7_Mask              : constant Unsigned_8 := 16#80#;
    878. 

  878. 

  879.    --  USART Baud Rate Register High Byte
    880. 

  880.    UBRR1H_Addr              : constant Address    := 16#cd#;
    881. 

  881.    UBRR1H                   : Unsigned_8 ;
    882. 

  882.    for UBRR1H'Address use UBRR1H_Addr;
    883. 

  883.    pragma Volatile (UBRR1H);
    884. 

  884.    UBRR1H_Bits              : Bits_In_Byte;
    885. 

  885.    for UBRR1H_Bits'Address use UBRR1H_Addr;
    886. 

  886.    pragma Volatile (UBRR1H_Bits);
    887. 

  887.    --  USART Baud Rate Register bit 8
    888. 

  888.    UBRR8_Bit                : constant Bit_Number := 0;
    889. 

  889.    UBRR8_Mask               : constant Unsigned_8 := 16#01#;
    890. 

  890.    --  USART Baud Rate Register bit 9
    891. 

  891.    UBRR9_Bit                : constant Bit_Number := 1;
    892. 

  892.    UBRR9_Mask               : constant Unsigned_8 := 16#02#;
    893. 

  893.    --  USART Baud Rate Register bit 10
    894. 

  894.    UBRR10_Bit               : constant Bit_Number := 2;
    895. 

  895.    UBRR10_Mask              : constant Unsigned_8 := 16#04#;
    896. 

  896.    --  USART Baud Rate Register bit 11
    897. 

  897.    UBRR11_Bit               : constant Bit_Number := 3;
    898. 

  898.    UBRR11_Mask              : constant Unsigned_8 := 16#08#;
    899. 

  899. 

  900.    --  USART Baud Rate Register Low Byte
    901. 

  901.    UBRR1L_Addr              : constant Address    := 16#cc#;
    902. 

  902.    UBRR1                    : Unsigned_16;
    903. 

  903.    for UBRR1'Address use UBRR1L_Addr;
    904. 

  904.    pragma Volatile (UBRR1);
    905. 

  905.    UBRR1L                   : Unsigned_8 ;
    906. 

  906.    for UBRR1L'Address use UBRR1L_Addr;
    907. 

  907.    pragma Volatile (UBRR1L);
    908. 

  908.    UBRR1L_Bits              : Bits_In_Byte;
    909. 

  909.    for UBRR1L_Bits'Address use UBRR1L_Addr;
    910. 

  910.    pragma Volatile (UBRR1L_Bits);
    911. 

  911.    --  USART Baud Rate Register bit 0
    912. 

  912.    UBRR0_Bit                : constant Bit_Number := 0;
    913. 

  913.    UBRR0_Mask               : constant Unsigned_8 := 16#01#;
    914. 

  914.    --  USART Baud Rate Register bit 1
    915. 

  915. --    UBRR1_Bit                : constant Bit_Number := 1;
    916. 

  916. --    UBRR1_Mask               : constant Unsigned_8 := 16#02#;
    917. 

  917.    --  USART Baud Rate Register bit 2
    918. 

  918.    UBRR2_Bit                : constant Bit_Number := 2;
    919. 

  919.    UBRR2_Mask               : constant Unsigned_8 := 16#04#;
    920. 

  920.    --  USART Baud Rate Register bit 3
    921. 

  921.    UBRR3_Bit                : constant Bit_Number := 3;
    922. 

  922.    UBRR3_Mask               : constant Unsigned_8 := 16#08#;
    923. 

  923.    --  USART Baud Rate Register bit 4
    924. 

  924.    UBRR4_Bit                : constant Bit_Number := 4;
    925. 

  925.    UBRR4_Mask               : constant Unsigned_8 := 16#10#;
    926. 

  926.    --  USART Baud Rate Register bit 5
    927. 

  927.    UBRR5_Bit                : constant Bit_Number := 5;
    928. 

  928.    UBRR5_Mask               : constant Unsigned_8 := 16#20#;
    929. 

  929.    --  USART Baud Rate Register bit 6
    930. 

  930.    UBRR6_Bit                : constant Bit_Number := 6;
    931. 

  931.    UBRR6_Mask               : constant Unsigned_8 := 16#40#;
    932. 

  932.    --  USART Baud Rate Register bit 7
    933. 

  933.    UBRR7_Bit                : constant Bit_Number := 7;
    934. 

  934.    UBRR7_Mask               : constant Unsigned_8 := 16#80#;
    935. 

  935. 

  936.    --  USART Control and Status Register D
    937. 

  937.    UCSR1D_Addr              : constant Address    := 16#cb#;
    938. 

  938.    UCSR1D                   : Unsigned_8 ;
    939. 

  939.    for UCSR1D'Address use UCSR1D_Addr;
    940. 

  940.    pragma Volatile (UCSR1D);
    941. 

  941.    UCSR1D_Bits              : Bits_In_Byte;
    942. 

  942.    for UCSR1D_Bits'Address use UCSR1D_Addr;
    943. 

  943.    pragma Volatile (UCSR1D_Bits);
    944. 

  944.    --  RTS Enable
    945. 

  945.    RTSEN_Bit                : constant Bit_Number := 0;
    946. 

  946.    RTSEN_Mask               : constant Unsigned_8 := 16#01#;
    947. 

  947.    --  CTS Enable
    948. 

  948.    CTSEN_Bit                : constant Bit_Number := 1;
    949. 

  949.    CTSEN_Mask               : constant Unsigned_8 := 16#02#;
    950. 

  950. 

  951.    --  USART Control and Status Register C
    952. 

  952.    UCSR1C_Addr              : constant Address    := 16#ca#;
    953. 

  953.    UCSR1C                   : Unsigned_8 ;
    954. 

  954.    for UCSR1C'Address use UCSR1C_Addr;
    955. 

  955.    pragma Volatile (UCSR1C);
    956. 

  956.    UCSR1C_Bits              : Bits_In_Byte;
    957. 

  957.    for UCSR1C_Bits'Address use UCSR1C_Addr;
    958. 

  958.    pragma Volatile (UCSR1C_Bits);
    959. 

  959.    --  Clock Polarity
    960. 

  960.    UCPOL1_Bit               : constant Bit_Number := 0;
    961. 

  961.    UCPOL1_Mask              : constant Unsigned_8 := 16#01#;
    962. 

  962.    --  Character Size
    963. 

  963.    UCSZ10_Bit               : constant Bit_Number := 1;
    964. 

  964.    UCSZ10_Mask              : constant Unsigned_8 := 16#02#;
    965. 

  965.    --  Character Size
    966. 

  966.    UCSZ11_Bit               : constant Bit_Number := 2;
    967. 

  967.    UCSZ11_Mask              : constant Unsigned_8 := 16#04#;
    968. 

  968.    --  Stop Bit Select
    969. 

  969.    USBS1_Bit                : constant Bit_Number := 3;
    970. 

  970.    USBS1_Mask               : constant Unsigned_8 := 16#08#;
    971. 

  971.    --  Parity Mode Bit 0
    972. 

  972.    UPM10_Bit                : constant Bit_Number := 4;
    973. 

  973.    UPM10_Mask               : constant Unsigned_8 := 16#10#;
    974. 

  974.    --  Parity Mode Bit 1
    975. 

  975.    UPM11_Bit                : constant Bit_Number := 5;
    976. 

  976.    UPM11_Mask               : constant Unsigned_8 := 16#20#;
    977. 

  977.    --  USART Mode Select
    978. 

  978.    UMSEL10_Bit              : constant Bit_Number := 6;
    979. 

  979.    UMSEL10_Mask             : constant Unsigned_8 := 16#40#;
    980. 

  980.    --  USART Mode Select
    981. 

  981.    UMSEL11_Bit              : constant Bit_Number := 7;
    982. 

  982.    UMSEL11_Mask             : constant Unsigned_8 := 16#80#;
    983. 

  983. 

  984.    --  USART Control and Status Register B
    985. 

  985.    UCSR1B_Addr              : constant Address    := 16#c9#;
    986. 

  986.    UCSR1B                   : Unsigned_8 ;
    987. 

  987.    for UCSR1B'Address use UCSR1B_Addr;
    988. 

  988.    pragma Volatile (UCSR1B);
    989. 

  989.    UCSR1B_Bits              : Bits_In_Byte;
    990. 

  990.    for UCSR1B_Bits'Address use UCSR1B_Addr;
    991. 

  991.    pragma Volatile (UCSR1B_Bits);
    992. 

  992.    --  Transmit Data Bit 8
    993. 

  993.    TXB81_Bit                : constant Bit_Number := 0;
    994. 

  994.    TXB81_Mask               : constant Unsigned_8 := 16#01#;
    995. 

  995.    --  Receive Data Bit 8
    996. 

  996.    RXB81_Bit                : constant Bit_Number := 1;
    997. 

  997.    RXB81_Mask               : constant Unsigned_8 := 16#02#;
    998. 

  998.    --  Character Size
    999. 

  999.    UCSZ12_Bit               : constant Bit_Number := 2;
    1000. 

  1000.    UCSZ12_Mask              : constant Unsigned_8 := 16#04#;
    1001. 

  1001.    --  Transmitter Enable
    1002. 

  1002.    TXEN1_Bit                : constant Bit_Number := 3;
    1003. 

  1003.    TXEN1_Mask               : constant Unsigned_8 := 16#08#;
    1004. 

  1004.    --  Receiver Enable
    1005. 

  1005.    RXEN1_Bit                : constant Bit_Number := 4;
    1006. 

  1006.    RXEN1_Mask               : constant Unsigned_8 := 16#10#;
    1007. 

  1007.    --  USART Data register Empty Interrupt Enable
    1008. 

  1008.    UDRIE1_Bit               : constant Bit_Number := 5;
    1009. 

  1009.    UDRIE1_Mask              : constant Unsigned_8 := 16#20#;
    1010. 

  1010.    --  TX Complete Interrupt Enable
    1011. 

  1011.    TXCIE1_Bit               : constant Bit_Number := 6;
    1012. 

  1012.    TXCIE1_Mask              : constant Unsigned_8 := 16#40#;
    1013. 

  1013.    --  RX Complete Interrupt Enable
    1014. 

  1014.    RXCIE1_Bit               : constant Bit_Number := 7;
    1015. 

  1015.    RXCIE1_Mask              : constant Unsigned_8 := 16#80#;
    1016. 

  1016. 

  1017.    --  USART Control and Status Register A
    1018. 

  1018.    UCSR1A_Addr              : constant Address    := 16#c8#;
    1019. 

  1019.    UCSR1A                   : Unsigned_8 ;
    1020. 

  1020.    for UCSR1A'Address use UCSR1A_Addr;
    1021. 

  1021.    pragma Volatile (UCSR1A);
    1022. 

  1022.    UCSR1A_Bits              : Bits_In_Byte;
    1023. 

  1023.    for UCSR1A_Bits'Address use UCSR1A_Addr;
    1024. 

  1024.    pragma Volatile (UCSR1A_Bits);
    1025. 

  1025.    --  Multi-processor Communication Mode
    1026. 

  1026.    MPCM1_Bit                : constant Bit_Number := 0;
    1027. 

  1027.    MPCM1_Mask               : constant Unsigned_8 := 16#01#;
    1028. 

  1028.    --  Double the USART transmission speed
    1029. 

  1029.    U2X1_Bit                 : constant Bit_Number := 1;
    1030. 

  1030.    U2X1_Mask                : constant Unsigned_8 := 16#02#;
    1031. 

  1031.    --  Parity Error
    1032. 

  1032.    UPE1_Bit                 : constant Bit_Number := 2;
    1033. 

  1033.    UPE1_Mask                : constant Unsigned_8 := 16#04#;
    1034. 

  1034.    --  Data overRun
    1035. 

  1035.    DOR1_Bit                 : constant Bit_Number := 3;
    1036. 

  1036.    DOR1_Mask                : constant Unsigned_8 := 16#08#;
    1037. 

  1037.    --  Framing Error
    1038. 

  1038.    FE1_Bit                  : constant Bit_Number := 4;
    1039. 

  1039.    FE1_Mask                 : constant Unsigned_8 := 16#10#;
    1040. 

  1040.    --  USART Data Register Empty
    1041. 

  1041.    UDRE1_Bit                : constant Bit_Number := 5;
    1042. 

  1042.    UDRE1_Mask               : constant Unsigned_8 := 16#20#;
    1043. 

  1043.    --  USART Transmitt Complete
    1044. 

  1044.    TXC1_Bit                 : constant Bit_Number := 6;
    1045. 

  1045.    TXC1_Mask                : constant Unsigned_8 := 16#40#;
    1046. 

  1046.    --  USART Receive Complete
    1047. 

  1047.    RXC1_Bit                 : constant Bit_Number := 7;
    1048. 

  1048.    RXC1_Mask                : constant Unsigned_8 := 16#80#;
    1049. 

  1049. 

  1050.    ASSR_Addr                : constant Address    := 16#b6#;
    1051. 

  1051.    ASSR                     : Unsigned_8 ;
    1052. 

  1052.    for ASSR'Address use ASSR_Addr;
    1053. 

  1053.    pragma Volatile (ASSR);
    1054. 

  1054.    ASSR_Bits                : Bits_In_Byte;
    1055. 

  1055.    for ASSR_Bits'Address use ASSR_Addr;
    1056. 

  1056.    pragma Volatile (ASSR_Bits);
    1057. 

  1057. 

  1058.    OCR2B_Addr               : constant Address    := 16#b4#;
    1059. 

  1059.    OCR2B                    : Unsigned_8 ;
    1060. 

  1060.    for OCR2B'Address use OCR2B_Addr;
    1061. 

  1061.    pragma Volatile (OCR2B);
    1062. 

  1062.    OCR2B_Bits               : Bits_In_Byte;
    1063. 

  1063.    for OCR2B_Bits'Address use OCR2B_Addr;
    1064. 

  1064.    pragma Volatile (OCR2B_Bits);
    1065. 

  1065. 

  1066.    OCR2A_Addr               : constant Address    := 16#b3#;
    1067. 

  1067.    OCR2A                    : Unsigned_8 ;
    1068. 

  1068.    for OCR2A'Address use OCR2A_Addr;
    1069. 

  1069.    pragma Volatile (OCR2A);
    1070. 

  1070.    OCR2A_Bits               : Bits_In_Byte;
    1071. 

  1071.    for OCR2A_Bits'Address use OCR2A_Addr;
    1072. 

  1072.    pragma Volatile (OCR2A_Bits);
    1073. 

  1073. 

  1074.    TCNT2_Addr               : constant Address    := 16#b2#;
    1075. 

  1075.    TCNT2                    : Unsigned_8 ;
    1076. 

  1076.    for TCNT2'Address use TCNT2_Addr;
    1077. 

  1077.    pragma Volatile (TCNT2);
    1078. 

  1078.    TCNT2_Bits               : Bits_In_Byte;
    1079. 

  1079.    for TCNT2_Bits'Address use TCNT2_Addr;
    1080. 

  1080.    pragma Volatile (TCNT2_Bits);
    1081. 

  1081. 

  1082.    TCCR2B_Addr              : constant Address    := 16#b1#;
    1083. 

  1083.    TCCR2B                   : Unsigned_8 ;
    1084. 

  1084.    for TCCR2B'Address use TCCR2B_Addr;
    1085. 

  1085.    pragma Volatile (TCCR2B);
    1086. 

  1086.    TCCR2B_Bits              : Bits_In_Byte;
    1087. 

  1087.    for TCCR2B_Bits'Address use TCCR2B_Addr;
    1088. 

  1088.    pragma Volatile (TCCR2B_Bits);
    1089. 

  1089. 

  1090.    TCCR2A_Addr              : constant Address    := 16#b0#;
    1091. 

  1091.    TCCR2A                   : Unsigned_8 ;
    1092. 

  1092.    for TCCR2A'Address use TCCR2A_Addr;
    1093. 

  1093.    pragma Volatile (TCCR2A);
    1094. 

  1094.    TCCR2A_Bits              : Bits_In_Byte;
    1095. 

  1095.    for TCCR2A_Bits'Address use TCCR2A_Addr;
    1096. 

  1096.    pragma Volatile (TCCR2A_Bits);
    1097. 

  1097. 

  1098.    OCR3CH_Addr              : constant Address    := 16#9d#;
    1099. 

  1099.    OCR3CH                   : Unsigned_8 ;
    1100. 

  1100.    for OCR3CH'Address use OCR3CH_Addr;
    1101. 

  1101.    pragma Volatile (OCR3CH);
    1102. 

  1102.    OCR3CH_Bits              : Bits_In_Byte;
    1103. 

  1103.    for OCR3CH_Bits'Address use OCR3CH_Addr;
    1104. 

  1104.    pragma Volatile (OCR3CH_Bits);
    1105. 

  1105. 

  1106.    OCR3CL_Addr              : constant Address    := 16#9c#;
    1107. 

  1107.    OCR3CL                   : Unsigned_8 ;
    1108. 

  1108.    for OCR3CL'Address use OCR3CL_Addr;
    1109. 

  1109.    pragma Volatile (OCR3CL);
    1110. 

  1110.    OCR3CL_Bits              : Bits_In_Byte;
    1111. 

  1111.    for OCR3CL_Bits'Address use OCR3CL_Addr;
    1112. 

  1112.    pragma Vo…
    1113.