1#[doc = r"Register block"]
2#[repr(C)]
3pub struct RegisterBlock {
4 _reserved_0_p000: [u8; 0x04],
5 _reserved_1_p001: [u8; 0x04],
6 _reserved_2_p002: [u8; 0x04],
7 _reserved_3_p003: [u8; 0x04],
8 _reserved4: [u8; 0x20],
9 _reserved_4_p012: [u8; 0x04],
10 _reserved_5_p013: [u8; 0x04],
11 _reserved_6_p014: [u8; 0x04],
12 _reserved_7_p015: [u8; 0x04],
13 _reserved_8_p100: [u8; 0x04],
14 _reserved_9_p101: [u8; 0x04],
15 _reserved_10_p102: [u8; 0x04],
16 _reserved_11_p103: [u8; 0x04],
17 _reserved_12_p104: [u8; 0x04],
18 _reserved_13_p105: [u8; 0x04],
19 _reserved_14_p106: [u8; 0x04],
20 _reserved_15_p107: [u8; 0x04],
21 _reserved_16_p108: [u8; 0x04],
22 _reserved_17_p109: [u8; 0x04],
23 _reserved_18_p110: [u8; 0x04],
24 _reserved_19_p111: [u8; 0x04],
25 _reserved_20_p112: [u8; 0x04],
26 _reserved21: [u8; 0x0c],
27 _reserved_21_p200: [u8; 0x04],
28 _reserved_22_p201: [u8; 0x04],
29 _reserved23: [u8; 0x08],
30 _reserved_23_p204: [u8; 0x04],
31 _reserved_24_p205: [u8; 0x04],
32 _reserved_25_p206: [u8; 0x04],
33 _reserved26: [u8; 0x14],
34 _reserved_26_p212: [u8; 0x04],
35 _reserved_27_p213: [u8; 0x04],
36 _reserved_28_p214: [u8; 0x04],
37 _reserved_29_p215: [u8; 0x04],
38 _reserved_30_p300: [u8; 0x04],
39 _reserved_31_p301: [u8; 0x04],
40 _reserved_32_p302: [u8; 0x04],
41 _reserved_33_p303: [u8; 0x04],
42 _reserved_34_p304: [u8; 0x04],
43 _reserved35: [u8; 0x2c],
44 _reserved_35_p40: [u8; 0x10],
45 _reserved36: [u8; 0x0c],
46 _reserved_36_p407: [u8; 0x04],
47 _reserved_37_p408: [u8; 0x04],
48 _reserved_38_p409: [u8; 0x04],
49 _reserved_39_p410: [u8; 0x04],
50 _reserved_40_p411: [u8; 0x04],
51 _reserved41: [u8; 0x10],
52 _reserved_41_p50: [u8; 0x0c],
53 _reserved42: [u8; 0x012c],
54 _reserved_42_p914: [u8; 0x04],
55 _reserved_43_p915: [u8; 0x04],
56}
57impl RegisterBlock {
58 #[doc = "0x00 - P000 Pin Function Control Register"]
59 #[inline(always)]
60 pub const fn p000pfs(&self) -> &P000PFS {
61 unsafe { &*(self as *const Self).cast::<u8>().add(0usize).cast() }
62 }
63 #[doc = "0x02 - P000 Pin Function Control Register"]
64 #[inline(always)]
65 pub const fn p000pfs_ha(&self) -> &P000PFS_HA {
66 unsafe { &*(self as *const Self).cast::<u8>().add(2usize).cast() }
67 }
68 #[doc = "0x03 - P000 Pin Function Control Register"]
69 #[inline(always)]
70 pub const fn p000pfs_by(&self) -> &P000PFS_BY {
71 unsafe { &*(self as *const Self).cast::<u8>().add(3usize).cast() }
72 }
73 #[doc = "0x04 - P00%s Pin Function Control Register"]
74 #[inline(always)]
75 pub const fn p001pfs(&self) -> &P001PFS {
76 unsafe { &*(self as *const Self).cast::<u8>().add(4usize).cast() }
77 }
78 #[doc = "0x06 - P00%s Pin Function Control Register"]
79 #[inline(always)]
80 pub const fn p001pfs_ha(&self) -> &P001PFS_HA {
81 unsafe { &*(self as *const Self).cast::<u8>().add(6usize).cast() }
82 }
83 #[doc = "0x07 - P00%s Pin Function Control Register"]
84 #[inline(always)]
85 pub const fn p001pfs_by(&self) -> &P001PFS_BY {
86 unsafe { &*(self as *const Self).cast::<u8>().add(7usize).cast() }
87 }
88 #[doc = "0x08 - P00%s Pin Function Control Register"]
89 #[inline(always)]
90 pub const fn p002pfs(&self) -> &P001PFS {
91 unsafe { &*(self as *const Self).cast::<u8>().add(8usize).cast() }
92 }
93 #[doc = "0x0a - P00%s Pin Function Control Register"]
94 #[inline(always)]
95 pub const fn p002pfs_ha(&self) -> &P001PFS_HA {
96 unsafe { &*(self as *const Self).cast::<u8>().add(10usize).cast() }
97 }
98 #[doc = "0x0b - P00%s Pin Function Control Register"]
99 #[inline(always)]
100 pub const fn p002pfs_by(&self) -> &P001PFS_BY {
101 unsafe { &*(self as *const Self).cast::<u8>().add(11usize).cast() }
102 }
103 #[doc = "0x0c - P00%s Pin Function Control Register"]
104 #[inline(always)]
105 pub const fn p003pfs(&self) -> &P001PFS {
106 unsafe { &*(self as *const Self).cast::<u8>().add(12usize).cast() }
107 }
108 #[doc = "0x0e - P00%s Pin Function Control Register"]
109 #[inline(always)]
110 pub const fn p003pfs_ha(&self) -> &P001PFS_HA {
111 unsafe { &*(self as *const Self).cast::<u8>().add(14usize).cast() }
112 }
113 #[doc = "0x0f - P00%s Pin Function Control Register"]
114 #[inline(always)]
115 pub const fn p003pfs_by(&self) -> &P001PFS_BY {
116 unsafe { &*(self as *const Self).cast::<u8>().add(15usize).cast() }
117 }
118 #[doc = "0x30 - P0%s Pin Function Control Register"]
119 #[inline(always)]
120 pub const fn p012pfs(&self) -> &P012PFS {
121 unsafe { &*(self as *const Self).cast::<u8>().add(48usize).cast() }
122 }
123 #[doc = "0x32 - P0%s Pin Function Control Register"]
124 #[inline(always)]
125 pub const fn p012pfs_ha(&self) -> &P012PFS_HA {
126 unsafe { &*(self as *const Self).cast::<u8>().add(50usize).cast() }
127 }
128 #[doc = "0x33 - P0%s Pin Function Control Register"]
129 #[inline(always)]
130 pub const fn p012pfs_by(&self) -> &P012PFS_BY {
131 unsafe { &*(self as *const Self).cast::<u8>().add(51usize).cast() }
132 }
133 #[doc = "0x34 - P0%s Pin Function Control Register"]
134 #[inline(always)]
135 pub const fn p013pfs(&self) -> &P012PFS {
136 unsafe { &*(self as *const Self).cast::<u8>().add(52usize).cast() }
137 }
138 #[doc = "0x36 - P0%s Pin Function Control Register"]
139 #[inline(always)]
140 pub const fn p013pfs_ha(&self) -> &P012PFS_HA {
141 unsafe { &*(self as *const Self).cast::<u8>().add(54usize).cast() }
142 }
143 #[doc = "0x37 - P0%s Pin Function Control Register"]
144 #[inline(always)]
145 pub const fn p013pfs_by(&self) -> &P012PFS_BY {
146 unsafe { &*(self as *const Self).cast::<u8>().add(55usize).cast() }
147 }
148 #[doc = "0x38 - P0%s Pin Function Control Register"]
149 #[inline(always)]
150 pub const fn p014pfs(&self) -> &P012PFS {
151 unsafe { &*(self as *const Self).cast::<u8>().add(56usize).cast() }
152 }
153 #[doc = "0x3a - P0%s Pin Function Control Register"]
154 #[inline(always)]
155 pub const fn p014pfs_ha(&self) -> &P012PFS_HA {
156 unsafe { &*(self as *const Self).cast::<u8>().add(58usize).cast() }
157 }
158 #[doc = "0x3b - P0%s Pin Function Control Register"]
159 #[inline(always)]
160 pub const fn p014pfs_by(&self) -> &P012PFS_BY {
161 unsafe { &*(self as *const Self).cast::<u8>().add(59usize).cast() }
162 }
163 #[doc = "0x3c - P0%s Pin Function Control Register"]
164 #[inline(always)]
165 pub const fn p015pfs(&self) -> &P012PFS {
166 unsafe { &*(self as *const Self).cast::<u8>().add(60usize).cast() }
167 }
168 #[doc = "0x3e - P0%s Pin Function Control Register"]
169 #[inline(always)]
170 pub const fn p015pfs_ha(&self) -> &P012PFS_HA {
171 unsafe { &*(self as *const Self).cast::<u8>().add(62usize).cast() }
172 }
173 #[doc = "0x3f - P0%s Pin Function Control Register"]
174 #[inline(always)]
175 pub const fn p015pfs_by(&self) -> &P012PFS_BY {
176 unsafe { &*(self as *const Self).cast::<u8>().add(63usize).cast() }
177 }
178 #[doc = "0x40 - P100 Pin Function Control Register"]
179 #[inline(always)]
180 pub const fn p100pfs(&self) -> &P100PFS {
181 unsafe { &*(self as *const Self).cast::<u8>().add(64usize).cast() }
182 }
183 #[doc = "0x42 - P100 Pin Function Control Register"]
184 #[inline(always)]
185 pub const fn p100pfs_ha(&self) -> &P100PFS_HA {
186 unsafe { &*(self as *const Self).cast::<u8>().add(66usize).cast() }
187 }
188 #[doc = "0x43 - P100 Pin Function Control Register"]
189 #[inline(always)]
190 pub const fn p100pfs_by(&self) -> &P100PFS_BY {
191 unsafe { &*(self as *const Self).cast::<u8>().add(67usize).cast() }
192 }
193 #[doc = "0x44 - P10%s Pin Function Control Register"]
194 #[inline(always)]
195 pub const fn p101pfs(&self) -> &P101PFS {
196 unsafe { &*(self as *const Self).cast::<u8>().add(68usize).cast() }
197 }
198 #[doc = "0x46 - P10%s Pin Function Control Register"]
199 #[inline(always)]
200 pub const fn p101pfs_ha(&self) -> &P101PFS_HA {
201 unsafe { &*(self as *const Self).cast::<u8>().add(70usize).cast() }
202 }
203 #[doc = "0x47 - P10%s Pin Function Control Register"]
204 #[inline(always)]
205 pub const fn p101pfs_by(&self) -> &P101PFS_BY {
206 unsafe { &*(self as *const Self).cast::<u8>().add(71usize).cast() }
207 }
208 #[doc = "0x48 - P10%s Pin Function Control Register"]
209 #[inline(always)]
210 pub const fn p102pfs(&self) -> &P101PFS {
211 unsafe { &*(self as *const Self).cast::<u8>().add(72usize).cast() }
212 }
213 #[doc = "0x4a - P10%s Pin Function Control Register"]
214 #[inline(always)]
215 pub const fn p102pfs_ha(&self) -> &P101PFS_HA {
216 unsafe { &*(self as *const Self).cast::<u8>().add(74usize).cast() }
217 }
218 #[doc = "0x4b - P10%s Pin Function Control Register"]
219 #[inline(always)]
220 pub const fn p102pfs_by(&self) -> &P101PFS_BY {
221 unsafe { &*(self as *const Self).cast::<u8>().add(75usize).cast() }
222 }
223 #[doc = "0x4c - P10%s Pin Function Control Register"]
224 #[inline(always)]
225 pub const fn p103pfs(&self) -> &P101PFS {
226 unsafe { &*(self as *const Self).cast::<u8>().add(76usize).cast() }
227 }
228 #[doc = "0x4e - P10%s Pin Function Control Register"]
229 #[inline(always)]
230 pub const fn p103pfs_ha(&self) -> &P101PFS_HA {
231 unsafe { &*(self as *const Self).cast::<u8>().add(78usize).cast() }
232 }
233 #[doc = "0x4f - P10%s Pin Function Control Register"]
234 #[inline(always)]
235 pub const fn p103pfs_by(&self) -> &P101PFS_BY {
236 unsafe { &*(self as *const Self).cast::<u8>().add(79usize).cast() }
237 }
238 #[doc = "0x50 - P10%s Pin Function Control Register"]
239 #[inline(always)]
240 pub const fn p104pfs(&self) -> &P101PFS {
241 unsafe { &*(self as *const Self).cast::<u8>().add(80usize).cast() }
242 }
243 #[doc = "0x52 - P10%s Pin Function Control Register"]
244 #[inline(always)]
245 pub const fn p104pfs_ha(&self) -> &P101PFS_HA {
246 unsafe { &*(self as *const Self).cast::<u8>().add(82usize).cast() }
247 }
248 #[doc = "0x53 - P10%s Pin Function Control Register"]
249 #[inline(always)]
250 pub const fn p104pfs_by(&self) -> &P101PFS_BY {
251 unsafe { &*(self as *const Self).cast::<u8>().add(83usize).cast() }
252 }
253 #[doc = "0x54 - P10%s Pin Function Control Register"]
254 #[inline(always)]
255 pub const fn p105pfs(&self) -> &P101PFS {
256 unsafe { &*(self as *const Self).cast::<u8>().add(84usize).cast() }
257 }
258 #[doc = "0x56 - P10%s Pin Function Control Register"]
259 #[inline(always)]
260 pub const fn p105pfs_ha(&self) -> &P101PFS_HA {
261 unsafe { &*(self as *const Self).cast::<u8>().add(86usize).cast() }
262 }
263 #[doc = "0x57 - P10%s Pin Function Control Register"]
264 #[inline(always)]
265 pub const fn p105pfs_by(&self) -> &P101PFS_BY {
266 unsafe { &*(self as *const Self).cast::<u8>().add(87usize).cast() }
267 }
268 #[doc = "0x58 - P10%s Pin Function Control Register"]
269 #[inline(always)]
270 pub const fn p106pfs(&self) -> &P101PFS {
271 unsafe { &*(self as *const Self).cast::<u8>().add(88usize).cast() }
272 }
273 #[doc = "0x5a - P10%s Pin Function Control Register"]
274 #[inline(always)]
275 pub const fn p106pfs_ha(&self) -> &P101PFS_HA {
276 unsafe { &*(self as *const Self).cast::<u8>().add(90usize).cast() }
277 }
278 #[doc = "0x5b - P10%s Pin Function Control Register"]
279 #[inline(always)]
280 pub const fn p106pfs_by(&self) -> &P101PFS_BY {
281 unsafe { &*(self as *const Self).cast::<u8>().add(91usize).cast() }
282 }
283 #[doc = "0x5c - P10%s Pin Function Control Register"]
284 #[inline(always)]
285 pub const fn p107pfs(&self) -> &P101PFS {
286 unsafe { &*(self as *const Self).cast::<u8>().add(92usize).cast() }
287 }
288 #[doc = "0x5e - P10%s Pin Function Control Register"]
289 #[inline(always)]
290 pub const fn p107pfs_ha(&self) -> &P101PFS_HA {
291 unsafe { &*(self as *const Self).cast::<u8>().add(94usize).cast() }
292 }
293 #[doc = "0x5f - P10%s Pin Function Control Register"]
294 #[inline(always)]
295 pub const fn p107pfs_by(&self) -> &P101PFS_BY {
296 unsafe { &*(self as *const Self).cast::<u8>().add(95usize).cast() }
297 }
298 #[doc = "0x60 - P108 Pin Function Control Register"]
299 #[inline(always)]
300 pub const fn p108pfs(&self) -> &P108PFS {
301 unsafe { &*(self as *const Self).cast::<u8>().add(96usize).cast() }
302 }
303 #[doc = "0x62 - P108 Pin Function Control Register"]
304 #[inline(always)]
305 pub const fn p108pfs_ha(&self) -> &P108PFS_HA {
306 unsafe { &*(self as *const Self).cast::<u8>().add(98usize).cast() }
307 }
308 #[doc = "0x63 - P108 Pin Function Control Register"]
309 #[inline(always)]
310 pub const fn p108pfs_by(&self) -> &P108PFS_BY {
311 unsafe { &*(self as *const Self).cast::<u8>().add(99usize).cast() }
312 }
313 #[doc = "0x64 - P109 Pin Function Control Register"]
314 #[inline(always)]
315 pub const fn p109pfs(&self) -> &P109PFS {
316 unsafe { &*(self as *const Self).cast::<u8>().add(100usize).cast() }
317 }
318 #[doc = "0x66 - P109 Pin Function Control Register"]
319 #[inline(always)]
320 pub const fn p109pfs_ha(&self) -> &P109PFS_HA {
321 unsafe { &*(self as *const Self).cast::<u8>().add(102usize).cast() }
322 }
323 #[doc = "0x67 - P109 Pin Function Control Register"]
324 #[inline(always)]
325 pub const fn p109pfs_by(&self) -> &P109PFS_BY {
326 unsafe { &*(self as *const Self).cast::<u8>().add(103usize).cast() }
327 }
328 #[doc = "0x68 - P1%s Pin Function Control Register"]
329 #[inline(always)]
330 pub const fn p110pfs(&self) -> &P110PFS {
331 unsafe { &*(self as *const Self).cast::<u8>().add(104usize).cast() }
332 }
333 #[doc = "0x6a - P1%s Pin Function Control Register"]
334 #[inline(always)]
335 pub const fn p110pfs_ha(&self) -> &P110PFS_HA {
336 unsafe { &*(self as *const Self).cast::<u8>().add(106usize).cast() }
337 }
338 #[doc = "0x6b - P1%s Pin Function Control Register"]
339 #[inline(always)]
340 pub const fn p110pfs_by(&self) -> &P110PFS_BY {
341 unsafe { &*(self as *const Self).cast::<u8>().add(107usize).cast() }
342 }
343 #[doc = "0x6c - P1%s Pin Function Control Register"]
344 #[inline(always)]
345 pub const fn p111pfs(&self) -> &P110PFS {
346 unsafe { &*(self as *const Self).cast::<u8>().add(108usize).cast() }
347 }
348 #[doc = "0x6e - P1%s Pin Function Control Register"]
349 #[inline(always)]
350 pub const fn p111pfs_ha(&self) -> &P110PFS_HA {
351 unsafe { &*(self as *const Self).cast::<u8>().add(110usize).cast() }
352 }
353 #[doc = "0x6f - P1%s Pin Function Control Register"]
354 #[inline(always)]
355 pub const fn p111pfs_by(&self) -> &P110PFS_BY {
356 unsafe { &*(self as *const Self).cast::<u8>().add(111usize).cast() }
357 }
358 #[doc = "0x70 - P1%s Pin Function Control Register"]
359 #[inline(always)]
360 pub const fn p112pfs(&self) -> &P110PFS {
361 unsafe { &*(self as *const Self).cast::<u8>().add(112usize).cast() }
362 }
363 #[doc = "0x72 - P1%s Pin Function Control Register"]
364 #[inline(always)]
365 pub const fn p112pfs_ha(&self) -> &P110PFS_HA {
366 unsafe { &*(self as *const Self).cast::<u8>().add(114usize).cast() }
367 }
368 #[doc = "0x73 - P1%s Pin Function Control Register"]
369 #[inline(always)]
370 pub const fn p112pfs_by(&self) -> &P110PFS_BY {
371 unsafe { &*(self as *const Self).cast::<u8>().add(115usize).cast() }
372 }
373 #[doc = "0x80 - P200 Pin Function Control Register"]
374 #[inline(always)]
375 pub const fn p200pfs(&self) -> &P200PFS {
376 unsafe { &*(self as *const Self).cast::<u8>().add(128usize).cast() }
377 }
378 #[doc = "0x82 - P200 Pin Function Control Register"]
379 #[inline(always)]
380 pub const fn p200pfs_ha(&self) -> &P200PFS_HA {
381 unsafe { &*(self as *const Self).cast::<u8>().add(130usize).cast() }
382 }
383 #[doc = "0x83 - P200 Pin Function Control Register"]
384 #[inline(always)]
385 pub const fn p200pfs_by(&self) -> &P200PFS_BY {
386 unsafe { &*(self as *const Self).cast::<u8>().add(131usize).cast() }
387 }
388 #[doc = "0x84 - P201 Pin Function Control Register"]
389 #[inline(always)]
390 pub const fn p201pfs(&self) -> &P201PFS {
391 unsafe { &*(self as *const Self).cast::<u8>().add(132usize).cast() }
392 }
393 #[doc = "0x86 - P201 Pin Function Control Register"]
394 #[inline(always)]
395 pub const fn p201pfs_ha(&self) -> &P201PFS_HA {
396 unsafe { &*(self as *const Self).cast::<u8>().add(134usize).cast() }
397 }
398 #[doc = "0x87 - P201 Pin Function Control Register"]
399 #[inline(always)]
400 pub const fn p201pfs_by(&self) -> &P201PFS_BY {
401 unsafe { &*(self as *const Self).cast::<u8>().add(135usize).cast() }
402 }
403 #[doc = "0x90 - P20%s Pin Function Control Register"]
404 #[inline(always)]
405 pub const fn p204pfs(&self) -> &P204PFS {
406 unsafe { &*(self as *const Self).cast::<u8>().add(144usize).cast() }
407 }
408 #[doc = "0x92 - P20%s Pin Function Control Register"]
409 #[inline(always)]
410 pub const fn p204pfs_ha(&self) -> &P204PFS_HA {
411 unsafe { &*(self as *const Self).cast::<u8>().add(146usize).cast() }
412 }
413 #[doc = "0x93 - P20%s Pin Function Control Register"]
414 #[inline(always)]
415 pub const fn p204pfs_by(&self) -> &P204PFS_BY {
416 unsafe { &*(self as *const Self).cast::<u8>().add(147usize).cast() }
417 }
418 #[doc = "0x94 - P20%s Pin Function Control Register"]
419 #[inline(always)]
420 pub const fn p205pfs(&self) -> &P204PFS {
421 unsafe { &*(self as *const Self).cast::<u8>().add(148usize).cast() }
422 }
423 #[doc = "0x96 - P20%s Pin Function Control Register"]
424 #[inline(always)]
425 pub const fn p205pfs_ha(&self) -> &P204PFS_HA {
426 unsafe { &*(self as *const Self).cast::<u8>().add(150usize).cast() }
427 }
428 #[doc = "0x97 - P20%s Pin Function Control Register"]
429 #[inline(always)]
430 pub const fn p205pfs_by(&self) -> &P204PFS_BY {
431 unsafe { &*(self as *const Self).cast::<u8>().add(151usize).cast() }
432 }
433 #[doc = "0x98 - P20%s Pin Function Control Register"]
434 #[inline(always)]
435 pub const fn p206pfs(&self) -> &P204PFS {
436 unsafe { &*(self as *const Self).cast::<u8>().add(152usize).cast() }
437 }
438 #[doc = "0x9a - P20%s Pin Function Control Register"]
439 #[inline(always)]
440 pub const fn p206pfs_ha(&self) -> &P204PFS_HA {
441 unsafe { &*(self as *const Self).cast::<u8>().add(154usize).cast() }
442 }
443 #[doc = "0x9b - P20%s Pin Function Control Register"]
444 #[inline(always)]
445 pub const fn p206pfs_by(&self) -> &P204PFS_BY {
446 unsafe { &*(self as *const Self).cast::<u8>().add(155usize).cast() }
447 }
448 #[doc = "0xb0 - P2%s Pin Function Control Register"]
449 #[inline(always)]
450 pub const fn p212pfs(&self) -> &P212PFS {
451 unsafe { &*(self as *const Self).cast::<u8>().add(176usize).cast() }
452 }
453 #[doc = "0xb2 - P2%s Pin Function Control Register"]
454 #[inline(always)]
455 pub const fn p212pfs_ha(&self) -> &P212PFS_HA {
456 unsafe { &*(self as *const Self).cast::<u8>().add(178usize).cast() }
457 }
458 #[doc = "0xb3 - P2%s Pin Function Control Register"]
459 #[inline(always)]
460 pub const fn p212pfs_by(&self) -> &P212PFS_BY {
461 unsafe { &*(self as *const Self).cast::<u8>().add(179usize).cast() }
462 }
463 #[doc = "0xb4 - P2%s Pin Function Control Register"]
464 #[inline(always)]
465 pub const fn p213pfs(&self) -> &P212PFS {
466 unsafe { &*(self as *const Self).cast::<u8>().add(180usize).cast() }
467 }
468 #[doc = "0xb6 - P2%s Pin Function Control Register"]
469 #[inline(always)]
470 pub const fn p213pfs_ha(&self) -> &P212PFS_HA {
471 unsafe { &*(self as *const Self).cast::<u8>().add(182usize).cast() }
472 }
473 #[doc = "0xb7 - P2%s Pin Function Control Register"]
474 #[inline(always)]
475 pub const fn p213pfs_by(&self) -> &P212PFS_BY {
476 unsafe { &*(self as *const Self).cast::<u8>().add(183usize).cast() }
477 }
478 #[doc = "0xb8 - P2%s Pin Function Control Register"]
479 #[inline(always)]
480 pub const fn p214pfs(&self) -> &P212PFS {
481 unsafe { &*(self as *const Self).cast::<u8>().add(184usize).cast() }
482 }
483 #[doc = "0xba - P2%s Pin Function Control Register"]
484 #[inline(always)]
485 pub const fn p214pfs_ha(&self) -> &P212PFS_HA {
486 unsafe { &*(self as *const Self).cast::<u8>().add(186usize).cast() }
487 }
488 #[doc = "0xbb - P2%s Pin Function Control Register"]
489 #[inline(always)]
490 pub const fn p214pfs_by(&self) -> &P212PFS_BY {
491 unsafe { &*(self as *const Self).cast::<u8>().add(187usize).cast() }
492 }
493 #[doc = "0xbc - P2%s Pin Function Control Register"]
494 #[inline(always)]
495 pub const fn p215pfs(&self) -> &P212PFS {
496 unsafe { &*(self as *const Self).cast::<u8>().add(188usize).cast() }
497 }
498 #[doc = "0xbe - P2%s Pin Function Control Register"]
499 #[inline(always)]
500 pub const fn p215pfs_ha(&self) -> &P212PFS_HA {
501 unsafe { &*(self as *const Self).cast::<u8>().add(190usize).cast() }
502 }
503 #[doc = "0xbf - P2%s Pin Function Control Register"]
504 #[inline(always)]
505 pub const fn p215pfs_by(&self) -> &P212PFS_BY {
506 unsafe { &*(self as *const Self).cast::<u8>().add(191usize).cast() }
507 }
508 #[doc = "0xc0 - P300 Pin Function Control Register"]
509 #[inline(always)]
510 pub const fn p300pfs(&self) -> &P300PFS {
511 unsafe { &*(self as *const Self).cast::<u8>().add(192usize).cast() }
512 }
513 #[doc = "0xc2 - P300 Pin Function Control Register"]
514 #[inline(always)]
515 pub const fn p300pfs_ha(&self) -> &P300PFS_HA {
516 unsafe { &*(self as *const Self).cast::<u8>().add(194usize).cast() }
517 }
518 #[doc = "0xc3 - P300 Pin Function Control Register"]
519 #[inline(always)]
520 pub const fn p300pfs_by(&self) -> &P300PFS_BY {
521 unsafe { &*(self as *const Self).cast::<u8>().add(195usize).cast() }
522 }
523 #[doc = "0xc4 - P30%s Pin Function Control Register"]
524 #[inline(always)]
525 pub const fn p301pfs(&self) -> &P301PFS {
526 unsafe { &*(self as *const Self).cast::<u8>().add(196usize).cast() }
527 }
528 #[doc = "0xc6 - P30%s Pin Function Control Register"]
529 #[inline(always)]
530 pub const fn p301pfs_ha(&self) -> &P301PFS_HA {
531 unsafe { &*(self as *const Self).cast::<u8>().add(198usize).cast() }
532 }
533 #[doc = "0xc7 - P30%s Pin Function Control Register"]
534 #[inline(always)]
535 pub const fn p301pfs_by(&self) -> &P301PFS_BY {
536 unsafe { &*(self as *const Self).cast::<u8>().add(199usize).cast() }
537 }
538 #[doc = "0xc8 - P30%s Pin Function Control Register"]
539 #[inline(always)]
540 pub const fn p302pfs(&self) -> &P301PFS {
541 unsafe { &*(self as *const Self).cast::<u8>().add(200usize).cast() }
542 }
543 #[doc = "0xca - P30%s Pin Function Control Register"]
544 #[inline(always)]
545 pub const fn p302pfs_ha(&self) -> &P301PFS_HA {
546 unsafe { &*(self as *const Self).cast::<u8>().add(202usize).cast() }
547 }
548 #[doc = "0xcb - P30%s Pin Function Control Register"]
549 #[inline(always)]
550 pub const fn p302pfs_by(&self) -> &P301PFS_BY {
551 unsafe { &*(self as *const Self).cast::<u8>().add(203usize).cast() }
552 }
553 #[doc = "0xcc - P30%s Pin Function Control Register"]
554 #[inline(always)]
555 pub const fn p303pfs(&self) -> &P301PFS {
556 unsafe { &*(self as *const Self).cast::<u8>().add(204usize).cast() }
557 }
558 #[doc = "0xce - P30%s Pin Function Control Register"]
559 #[inline(always)]
560 pub const fn p303pfs_ha(&self) -> &P301PFS_HA {
561 unsafe { &*(self as *const Self).cast::<u8>().add(206usize).cast() }
562 }
563 #[doc = "0xcf - P30%s Pin Function Control Register"]
564 #[inline(always)]
565 pub const fn p303pfs_by(&self) -> &P301PFS_BY {
566 unsafe { &*(self as *const Self).cast::<u8>().add(207usize).cast() }
567 }
568 #[doc = "0xd0 - P30%s Pin Function Control Register"]
569 #[inline(always)]
570 pub const fn p304pfs(&self) -> &P301PFS {
571 unsafe { &*(self as *const Self).cast::<u8>().add(208usize).cast() }
572 }
573 #[doc = "0xd2 - P30%s Pin Function Control Register"]
574 #[inline(always)]
575 pub const fn p304pfs_ha(&self) -> &P301PFS_HA {
576 unsafe { &*(self as *const Self).cast::<u8>().add(210usize).cast() }
577 }
578 #[doc = "0xd3 - P30%s Pin Function Control Register"]
579 #[inline(always)]
580 pub const fn p304pfs_by(&self) -> &P301PFS_BY {
581 unsafe { &*(self as *const Self).cast::<u8>().add(211usize).cast() }
582 }
583 #[doc = "0x100..0x110 - P40%s Pin Function Control Register"]
584 #[inline(always)]
585 pub const fn p400pfs(&self) -> &[P400PFS; 4] {
586 unsafe { &*(self as *const Self).cast::<u8>().add(256usize).cast() }
587 }
588 #[doc = "0x102 - P40%s Pin Function Control Register"]
589 #[inline(always)]
590 pub const fn p400pfs_ha(&self) -> &P400PFS_HA {
591 unsafe { &*(self as *const Self).cast::<u8>().add(258usize).cast() }
592 }
593 #[doc = "0x103 - P40%s Pin Function Control Register"]
594 #[inline(always)]
595 pub const fn p400pfs_by(&self) -> &P400PFS_BY {
596 unsafe { &*(self as *const Self).cast::<u8>().add(259usize).cast() }
597 }
598 #[doc = "0x106 - P40%s Pin Function Control Register"]
599 #[inline(always)]
600 pub const fn p401pfs_ha(&self) -> &P400PFS_HA {
601 unsafe { &*(self as *const Self).cast::<u8>().add(262usize).cast() }
602 }
603 #[doc = "0x107 - P40%s Pin Function Control Register"]
604 #[inline(always)]
605 pub const fn p401pfs_by(&self) -> &P400PFS_BY {
606 unsafe { &*(self as *const Self).cast::<u8>().add(263usize).cast() }
607 }
608 #[doc = "0x10a - P40%s Pin Function Control Register"]
609 #[inline(always)]
610 pub const fn p402pfs_ha(&self) -> &P400PFS_HA {
611 unsafe { &*(self as *const Self).cast::<u8>().add(266usize).cast() }
612 }
613 #[doc = "0x10b - P40%s Pin Function Control Register"]
614 #[inline(always)]
615 pub const fn p402pfs_by(&self) -> &P400PFS_BY {
616 unsafe { &*(self as *const Self).cast::<u8>().add(267usize).cast() }
617 }
618 #[doc = "0x10e - P40%s Pin Function Control Register"]
619 #[inline(always)]
620 pub const fn p403pfs_ha(&self) -> &P400PFS_HA {
621 unsafe { &*(self as *const Self).cast::<u8>().add(270usize).cast() }
622 }
623 #[doc = "0x10f - P40%s Pin Function Control Register"]
624 #[inline(always)]
625 pub const fn p403pfs_by(&self) -> &P400PFS_BY {
626 unsafe { &*(self as *const Self).cast::<u8>().add(271usize).cast() }
627 }
628 #[doc = "0x11c - P407 Pin Function Control Register"]
629 #[inline(always)]
630 pub const fn p407pfs(&self) -> &P407PFS {
631 unsafe { &*(self as *const Self).cast::<u8>().add(284usize).cast() }
632 }
633 #[doc = "0x11e - P407 Pin Function Control Register"]
634 #[inline(always)]
635 pub const fn p407pfs_ha(&self) -> &P407PFS_HA {
636 unsafe { &*(self as *const Self).cast::<u8>().add(286usize).cast() }
637 }
638 #[doc = "0x11f - P407 Pin Function Control Register"]
639 #[inline(always)]
640 pub const fn p407pfs_by(&self) -> &P407PFS_BY {
641 unsafe { &*(self as *const Self).cast::<u8>().add(287usize).cast() }
642 }
643 #[doc = "0x120 - P40%s Pin Function Control Register"]
644 #[inline(always)]
645 pub const fn p408pfs(&self) -> &P408PFS {
646 unsafe { &*(self as *const Self).cast::<u8>().add(288usize).cast() }
647 }
648 #[doc = "0x122 - P40%s Pin Function Control Register"]
649 #[inline(always)]
650 pub const fn p408pfs_ha(&self) -> &P408PFS_HA {
651 unsafe { &*(self as *const Self).cast::<u8>().add(290usize).cast() }
652 }
653 #[doc = "0x123 - P40%s Pin Function Control Register"]
654 #[inline(always)]
655 pub const fn p408pfs_by(&self) -> &P408PFS_BY {
656 unsafe { &*(self as *const Self).cast::<u8>().add(291usize).cast() }
657 }
658 #[doc = "0x124 - P40%s Pin Function Control Register"]
659 #[inline(always)]
660 pub const fn p409pfs(&self) -> &P408PFS {
661 unsafe { &*(self as *const Self).cast::<u8>().add(292usize).cast() }
662 }
663 #[doc = "0x126 - P40%s Pin Function Control Register"]
664 #[inline(always)]
665 pub const fn p409pfs_ha(&self) -> &P408PFS_HA {
666 unsafe { &*(self as *const Self).cast::<u8>().add(294usize).cast() }
667 }
668 #[doc = "0x127 - P40%s Pin Function Control Register"]
669 #[inline(always)]
670 pub const fn p409pfs_by(&self) -> &P408PFS_BY {
671 unsafe { &*(self as *const Self).cast::<u8>().add(295usize).cast() }
672 }
673 #[doc = "0x128 - P4%s Pin Function Control Register"]
674 #[inline(always)]
675 pub const fn p410pfs(&self) -> &P410PFS {
676 unsafe { &*(self as *const Self).cast::<u8>().add(296usize).cast() }
677 }
678 #[doc = "0x12a - P4%s Pin Function Control Register"]
679 #[inline(always)]
680 pub const fn p410pfs_ha(&self) -> &P410PFS_HA {
681 unsafe { &*(self as *const Self).cast::<u8>().add(298usize).cast() }
682 }
683 #[doc = "0x12b - P4%s Pin Function Control Register"]
684 #[inline(always)]
685 pub const fn p410pfs_by(&self) -> &P410PFS_BY {
686 unsafe { &*(self as *const Self).cast::<u8>().add(299usize).cast() }
687 }
688 #[doc = "0x12c - P4%s Pin Function Control Register"]
689 #[inline(always)]
690 pub const fn p411pfs(&self) -> &P410PFS {
691 unsafe { &*(self as *const Self).cast::<u8>().add(300usize).cast() }
692 }
693 #[doc = "0x12e - P4%s Pin Function Control Register"]
694 #[inline(always)]
695 pub const fn p411pfs_ha(&self) -> &P410PFS_HA {
696 unsafe { &*(self as *const Self).cast::<u8>().add(302usize).cast() }
697 }
698 #[doc = "0x12f - P4%s Pin Function Control Register"]
699 #[inline(always)]
700 pub const fn p411pfs_by(&self) -> &P410PFS_BY {
701 unsafe { &*(self as *const Self).cast::<u8>().add(303usize).cast() }
702 }
703 #[doc = "0x140..0x14c - P50%s Pin Function Control Register"]
704 #[inline(always)]
705 pub const fn p500pfs(&self) -> &[P500PFS; 3] {
706 unsafe { &*(self as *const Self).cast::<u8>().add(320usize).cast() }
707 }
708 #[doc = "0x142 - P50%s Pin Function Control Register"]
709 #[inline(always)]
710 pub const fn p500pfs_ha(&self) -> &P500PFS_HA {
711 unsafe { &*(self as *const Self).cast::<u8>().add(322usize).cast() }
712 }
713 #[doc = "0x143 - P50%s Pin Function Control Register"]
714 #[inline(always)]
715 pub const fn p500pfs_by(&self) -> &P500PFS_BY {
716 unsafe { &*(self as *const Self).cast::<u8>().add(323usize).cast() }
717 }
718 #[doc = "0x146 - P50%s Pin Function Control Register"]
719 #[inline(always)]
720 pub const fn p501pfs_ha(&self) -> &P500PFS_HA {
721 unsafe { &*(self as *const Self).cast::<u8>().add(326usize).cast() }
722 }
723 #[doc = "0x147 - P50%s Pin Function Control Register"]
724 #[inline(always)]
725 pub const fn p501pfs_by(&self) -> &P500PFS_BY {
726 unsafe { &*(self as *const Self).cast::<u8>().add(327usize).cast() }
727 }
728 #[doc = "0x14a - P50%s Pin Function Control Register"]
729 #[inline(always)]
730 pub const fn p502pfs_ha(&self) -> &P500PFS_HA {
731 unsafe { &*(self as *const Self).cast::<u8>().add(330usize).cast() }
732 }
733 #[doc = "0x14b - P50%s Pin Function Control Register"]
734 #[inline(always)]
735 pub const fn p502pfs_by(&self) -> &P500PFS_BY {
736 unsafe { &*(self as *const Self).cast::<u8>().add(331usize).cast() }
737 }
738 #[doc = "0x278 - P914 Pin Function Control Register"]
739 #[inline(always)]
740 pub const fn p914pfs(&self) -> &P914PFS {
741 unsafe { &*(self as *const Self).cast::<u8>().add(632usize).cast() }
742 }
743 #[doc = "0x27a - P914 Pin Function Control Register"]
744 #[inline(always)]
745 pub const fn p914pfs_ha(&self) -> &P914PFS_HA {
746 unsafe { &*(self as *const Self).cast::<u8>().add(634usize).cast() }
747 }
748 #[doc = "0x27b - P914 Pin Function Control Register"]
749 #[inline(always)]
750 pub const fn p914pfs_by(&self) -> &P914PFS_BY {
751 unsafe { &*(self as *const Self).cast::<u8>().add(635usize).cast() }
752 }
753 #[doc = "0x27c - P915 Pin Function Control Register"]
754 #[inline(always)]
755 pub const fn p915pfs(&self) -> &P915PFS {
756 unsafe { &*(self as *const Self).cast::<u8>().add(636usize).cast() }
757 }
758 #[doc = "0x27e - P915 Pin Function Control Register"]
759 #[inline(always)]
760 pub const fn p915pfs_ha(&self) -> &P915PFS_HA {
761 unsafe { &*(self as *const Self).cast::<u8>().add(638usize).cast() }
762 }
763 #[doc = "0x27f - P915 Pin Function Control Register"]
764 #[inline(always)]
765 pub const fn p915pfs_by(&self) -> &P915PFS_BY {
766 unsafe { &*(self as *const Self).cast::<u8>().add(639usize).cast() }
767 }
768}
769#[doc = "P000PFS (rw) register accessor: an alias for `Reg<P000PFS_SPEC>`"]
770pub type P000PFS = crate::Reg<p000pfs::P000PFS_SPEC>;
771#[doc = "P000 Pin Function Control Register"]
772pub mod p000pfs;
773#[doc = "P000PFS_HA (rw) register accessor: an alias for `Reg<P000PFS_HA_SPEC>`"]
774pub type P000PFS_HA = crate::Reg<p000pfs_ha::P000PFS_HA_SPEC>;
775#[doc = "P000 Pin Function Control Register"]
776pub mod p000pfs_ha;
777#[doc = "P000PFS_BY (rw) register accessor: an alias for `Reg<P000PFS_BY_SPEC>`"]
778pub type P000PFS_BY = crate::Reg<p000pfs_by::P000PFS_BY_SPEC>;
779#[doc = "P000 Pin Function Control Register"]
780pub mod p000pfs_by;
781pub use p000pfs as p001pfs;
782pub use p000pfs as p012pfs;
783pub use p000pfs_by as p001pfs_by;
784pub use p000pfs_by as p012pfs_by;
785pub use p000pfs_ha as p001pfs_ha;
786pub use p000pfs_ha as p012pfs_ha;
787pub use P000PFS as P001PFS;
788pub use P000PFS as P012PFS;
789pub use P000PFS_BY as P001PFS_BY;
790pub use P000PFS_BY as P012PFS_BY;
791pub use P000PFS_HA as P001PFS_HA;
792pub use P000PFS_HA as P012PFS_HA;
793#[doc = "P100PFS (rw) register accessor: an alias for `Reg<P100PFS_SPEC>`"]
794pub type P100PFS = crate::Reg<p100pfs::P100PFS_SPEC>;
795#[doc = "P100 Pin Function Control Register"]
796pub mod p100pfs;
797#[doc = "P100PFS_HA (rw) register accessor: an alias for `Reg<P100PFS_HA_SPEC>`"]
798pub type P100PFS_HA = crate::Reg<p100pfs_ha::P100PFS_HA_SPEC>;
799#[doc = "P100 Pin Function Control Register"]
800pub mod p100pfs_ha;
801#[doc = "P100PFS_BY (rw) register accessor: an alias for `Reg<P100PFS_BY_SPEC>`"]
802pub type P100PFS_BY = crate::Reg<p100pfs_by::P100PFS_BY_SPEC>;
803#[doc = "P100 Pin Function Control Register"]
804pub mod p100pfs_by;
805pub use p000pfs as p300pfs;
806pub use p000pfs as p301pfs;
807pub use p000pfs as p400pfs;
808pub use p000pfs_by as p300pfs_by;
809pub use p000pfs_by as p301pfs_by;
810pub use p000pfs_by as p400pfs_by;
811pub use p000pfs_ha as p300pfs_ha;
812pub use p000pfs_ha as p301pfs_ha;
813pub use p000pfs_ha as p400pfs_ha;
814pub use p100pfs as p101pfs;
815pub use p100pfs as p108pfs;
816pub use p100pfs as p109pfs;
817pub use p100pfs as p110pfs;
818pub use p100pfs as p200pfs;
819pub use p100pfs as p201pfs;
820pub use p100pfs as p204pfs;
821pub use p100pfs as p212pfs;
822pub use p100pfs_by as p101pfs_by;
823pub use p100pfs_by as p108pfs_by;
824pub use p100pfs_by as p109pfs_by;
825pub use p100pfs_by as p110pfs_by;
826pub use p100pfs_by as p200pfs_by;
827pub use p100pfs_by as p201pfs_by;
828pub use p100pfs_by as p204pfs_by;
829pub use p100pfs_by as p212pfs_by;
830pub use p100pfs_ha as p101pfs_ha;
831pub use p100pfs_ha as p108pfs_ha;
832pub use p100pfs_ha as p109pfs_ha;
833pub use p100pfs_ha as p110pfs_ha;
834pub use p100pfs_ha as p200pfs_ha;
835pub use p100pfs_ha as p201pfs_ha;
836pub use p100pfs_ha as p204pfs_ha;
837pub use p100pfs_ha as p212pfs_ha;
838pub use P000PFS as P300PFS;
839pub use P000PFS as P301PFS;
840pub use P000PFS as P400PFS;
841pub use P000PFS_BY as P300PFS_BY;
842pub use P000PFS_BY as P301PFS_BY;
843pub use P000PFS_BY as P400PFS_BY;
844pub use P000PFS_HA as P300PFS_HA;
845pub use P000PFS_HA as P301PFS_HA;
846pub use P000PFS_HA as P400PFS_HA;
847pub use P100PFS as P101PFS;
848pub use P100PFS as P108PFS;
849pub use P100PFS as P109PFS;
850pub use P100PFS as P110PFS;
851pub use P100PFS as P200PFS;
852pub use P100PFS as P201PFS;
853pub use P100PFS as P204PFS;
854pub use P100PFS as P212PFS;
855pub use P100PFS_BY as P101PFS_BY;
856pub use P100PFS_BY as P108PFS_BY;
857pub use P100PFS_BY as P109PFS_BY;
858pub use P100PFS_BY as P110PFS_BY;
859pub use P100PFS_BY as P200PFS_BY;
860pub use P100PFS_BY as P201PFS_BY;
861pub use P100PFS_BY as P204PFS_BY;
862pub use P100PFS_BY as P212PFS_BY;
863pub use P100PFS_HA as P101PFS_HA;
864pub use P100PFS_HA as P108PFS_HA;
865pub use P100PFS_HA as P109PFS_HA;
866pub use P100PFS_HA as P110PFS_HA;
867pub use P100PFS_HA as P200PFS_HA;
868pub use P100PFS_HA as P201PFS_HA;
869pub use P100PFS_HA as P204PFS_HA;
870pub use P100PFS_HA as P212PFS_HA;
871#[doc = "P407PFS (rw) register accessor: an alias for `Reg<P407PFS_SPEC>`"]
872pub type P407PFS = crate::Reg<p407pfs::P407PFS_SPEC>;
873#[doc = "P407 Pin Function Control Register"]
874pub mod p407pfs;
875#[doc = "P407PFS_HA (rw) register accessor: an alias for `Reg<P407PFS_HA_SPEC>`"]
876pub type P407PFS_HA = crate::Reg<p407pfs_ha::P407PFS_HA_SPEC>;
877#[doc = "P407 Pin Function Control Register"]
878pub mod p407pfs_ha;
879#[doc = "P407PFS_BY (rw) register accessor: an alias for `Reg<P407PFS_BY_SPEC>`"]
880pub type P407PFS_BY = crate::Reg<p407pfs_by::P407PFS_BY_SPEC>;
881#[doc = "P407 Pin Function Control Register"]
882pub mod p407pfs_by;
883pub use p000pfs as p410pfs;
884pub use p000pfs as p500pfs;
885pub use p000pfs as p914pfs;
886pub use p000pfs as p915pfs;
887pub use p000pfs_by as p410pfs_by;
888pub use p000pfs_by as p500pfs_by;
889pub use p000pfs_by as p914pfs_by;
890pub use p000pfs_by as p915pfs_by;
891pub use p000pfs_ha as p410pfs_ha;
892pub use p000pfs_ha as p500pfs_ha;
893pub use p000pfs_ha as p914pfs_ha;
894pub use p000pfs_ha as p915pfs_ha;
895pub use p407pfs as p408pfs;
896pub use p407pfs_by as p408pfs_by;
897pub use p407pfs_ha as p408pfs_ha;
898pub use P000PFS as P410PFS;
899pub use P000PFS as P500PFS;
900pub use P000PFS as P914PFS;
901pub use P000PFS as P915PFS;
902pub use P000PFS_BY as P410PFS_BY;
903pub use P000PFS_BY as P500PFS_BY;
904pub use P000PFS_BY as P914PFS_BY;
905pub use P000PFS_BY as P915PFS_BY;
906pub use P000PFS_HA as P410PFS_HA;
907pub use P000PFS_HA as P500PFS_HA;
908pub use P000PFS_HA as P914PFS_HA;
909pub use P000PFS_HA as P915PFS_HA;
910pub use P407PFS as P408PFS;
911pub use P407PFS_BY as P408PFS_BY;
912pub use P407PFS_HA as P408PFS_HA;