Outline ![]()
Files ![]()
loading...
SourceVu![]()
Raspberry Pi Pico SDK and Examples![]()
PicoSDK![]()
src/rp2_common/hardware_gpio/include/hardware/gpio_coproc.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
/*
* Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
*
* SPDX-License-Identifier: BSD-3-Clause
*/
#ifndef _HARDWARE_GPIO_COPROC_H
#define _HARDWARE_GPIO_COPROC_H
#ifdef __riscv
#error "GPIO coprocessor port is not available on RISC-V"
#endif
#if PICO_RP2040
#error "GPIO coprocessor is not available on RP2040"
#endif
#if !HAS_GPIO_COPROCESSOR
#error "GPIO coprocessor is not available"
#endif
#include "pico.h"
// ----------------------------------------------------------------------------
// OUT mask write instructions
// Equivalent to sio_hw->gpio_out = x;
__force_inline static void gpioc_lo_out_put(uint32_t x) {
pico_default_asm_volatile ("mcr p0, #0, %0, c0, c0" : : "r" (x));
}
// Equivalent to sio_hw->gpio_togl = x;
__force_inline static void gpioc_lo_out_xor(uint32_t x) {
pico_default_asm_volatile ("mcr p0, #1, %0, c0, c0" : : "r" (x));
}
// Equivalent to sio_hw->gpio_set = x;
__force_inline static void gpioc_lo_out_set(uint32_t x) {
pico_default_asm_volatile ("mcr p0, #2, %0, c0, c0" : : "r" (x));
}
// Equivalent to sio_hw->gpio_clr = x;
__force_inline static void gpioc_lo_out_clr(uint32_t x) {
pico_default_asm_volatile ("mcr p0, #3, %0, c0, c0" : : "r" (x));
}
// Equivalent to sio_hw->gpio_hi_out = x;
__force_inline static void gpioc_hi_out_put(uint32_t x) {
pico_default_asm_volatile ("mcr p0, #0, %0, c0, c1" : : "r" (x));
}
// Equivalent to sio_hw->gpio_hi_togl = x;
__force_inline static void gpioc_hi_out_xor(uint32_t x) {
pico_default_asm_volatile ("mcr p0, #1, %0, c0, c1" : : "r" (x));
}
// Equivalent to sio_hw->gpio_hi_set = x;
__force_inline static void gpioc_hi_out_set(uint32_t x) {
pico_default_asm_volatile ("mcr p0, #2, %0, c0, c1" : : "r" (x));
}
// Equivalent to sio_hw->gpio_hi_clr = x;
__force_inline static void gpioc_hi_out_clr(uint32_t x) {
pico_default_asm_volatile ("mcr p0, #3, %0, c0, c1" : : "r" (x));
}
// Equivalent to these two operations performed on the same cycle:
// - sio_hw->gpio_out = x & 0xffffffff;
// - sio_hw->gpio_hi_out = x >> 32;
__force_inline static void gpioc_hilo_out_put(uint64_t x) {
pico_default_asm_volatile ("mcrr p0, #0, %0, %1, c0" : : "r" (x & 0xffffffffu), "r" (x >> 32));
}
// Equivalent to these two operations performed on the same cycle:
// - sio_hw->gpio_togl = x & 0xffffffff;
// - sio_hw->gpio_hi_togl = x >> 32;
__force_inline static void gpioc_hilo_out_xor(uint64_t x) {
pico_default_asm_volatile ("mcrr p0, #1, %0, %1, c0" : : "r" (x & 0xffffffffu), "r" (x >> 32));
}
// Equivalent to these two operations performed on the same cycle:
// - sio_hw->gpio_set = x & 0xffffffff;
// - sio_hw->gpio_hi_set = x >> 32;
__force_inline static void gpioc_hilo_out_set(uint64_t x) {
pico_default_asm_volatile ("mcrr p0, #2, %0, %1, c0" : : "r" (x & 0xffffffffu), "r" (x >> 32));
}
// Equivalent to these two operations performed on the same cycle:
// - sio_hw->gpio_clr = x & 0xffffffff;
// - sio_hw->gpio_hi_clr = x >> 32;
__force_inline static void gpioc_hilo_out_clr(uint64_t x) {
pico_default_asm_volatile ("mcrr p0, #3, %0, %1, c0" : : "r" (x & 0xffffffffu), "r" (x >> 32));
}
// ----------------------------------------------------------------------------
// OE mask write instructions
// Equivalent to sio_hw->gpio_oe = x;
__force_inline static void gpioc_lo_oe_put(uint32_t x) {
pico_default_asm_volatile ("mcr p0, #0, %0, c0, c4" : : "r" (x));
}
// Equivalent to sio_hw->gpio_oe_togl = x;
__force_inline static void gpioc_lo_oe_xor(uint32_t x) {
pico_default_asm_volatile ("mcr p0, #1, %0, c0, c4" : : "r" (x));
}
// Equivalent to sio_hw->gpio_oe_set = x;
__force_inline static void gpioc_lo_oe_set(uint32_t x) {
pico_default_asm_volatile ("mcr p0, #2, %0, c0, c4" : : "r" (x));
}
// Equivalent to sio_hw->gpio_oe_clr = x;
__force_inline static void gpioc_lo_oe_clr(uint32_t x) {
pico_default_asm_volatile ("mcr p0, #3, %0, c0, c4" : : "r" (x));
}
// Equivalent to sio_hw->gpio_hi_oe = x;
__force_inline static void gpioc_hi_oe_put(uint32_t x) {
pico_default_asm_volatile ("mcr p0, #0, %0, c0, c5" : : "r" (x));
}
// Equivalent to sio_hw->gpio_hi_oe_togl = x;
__force_inline static void gpioc_hi_oe_xor(uint32_t x) {
pico_default_asm_volatile ("mcr p0, #1, %0, c0, c5" : : "r" (x));
}
// Equivalent to sio_hw->gpio_hi_oe_set = x;
__force_inline static void gpioc_hi_oe_set(uint32_t x) {
pico_default_asm_volatile ("mcr p0, #2, %0, c0, c5" : : "r" (x));
}
// Equivalent to sio_hw->gpio_hi_oe_clr = x;
__force_inline static void gpioc_hi_oe_clr(uint32_t x) {
pico_default_asm_volatile ("mcr p0, #3, %0, c0, c5" : : "r" (x));
}
// Equivalent to these two operations performed on the same cycle:
// - sio_hw->gpio_oe = x & 0xffffffff;
// - sio_hw->gpio_hi_oe = x >> 32;
__force_inline static void gpioc_hilo_oe_put(uint64_t x) {
pico_default_asm_volatile ("mcrr p0, #0, %0, %1, c4" : : "r" (x & 0xffffffffu), "r" (x >> 32));
}
// Equivalent to these two operations performed on the same cycle:
// - sio_hw->gpio_oe_togl = x & 0xffffffff;
// - sio_hw->gpio_hi_oe_togl = x >> 32;
__force_inline static void gpioc_hilo_oe_xor(uint64_t x) {
pico_default_asm_volatile ("mcrr p0, #1, %0, %1, c4" : : "r" (x & 0xffffffffu), "r" (x >> 32));
}
// Equivalent to these two operations performed on the same cycle:
// - sio_hw->gpio_oe_set = x & 0xffffffff;
// - sio_hw->gpio_hi_oe_set = x >> 32;
__force_inline static void gpioc_hilo_oe_set(uint64_t x) {
pico_default_asm_volatile ("mcrr p0, #2, %0, %1, c4" : : "r" (x & 0xffffffffu), "r" (x >> 32));
}
// Equivalent to these two operations performed on the same cycle:
// - sio_hw->gpio_oe_clr = x & 0xffffffff;
// - sio_hw->gpio_hi_oe_clr = x >> 32;
__force_inline static void gpioc_hilo_oe_clr(uint64_t x) {
pico_default_asm_volatile ("mcrr p0, #3, %0, %1, c4" : : "r" (x & 0xffffffffu), "r" (x >> 32));
}
// ----------------------------------------------------------------------------
// Single-bit write instructions
// Write a 1-bit value to any output. Equivalent to:
//
// if (val)
// gpioc_hilo_out_set(1ull << pin);
// else
// gpioc_hilo_out_clr(1ull << pin);
__force_inline static void gpioc_bit_out_put(uint pin, bool val) {
pico_default_asm_volatile ("mcrr p0, #4, %0, %1, c0" : : "r" (pin), "r" (val));
}
// Unconditionally toggle any single output. Equivalent to:
//
// gpioc_hilo_out_xor(1ull << pin);
__force_inline static void gpioc_bit_out_xor(uint pin) {
pico_default_asm_volatile ("mcr p0, #5, %0, c0, c0" : : "r" (pin));
}
// Unconditionally set any single output. Equivalent to:
//
// gpioc_hilo_out_set(1ull << pin);
__force_inline static void gpioc_bit_out_set(uint pin) {
pico_default_asm_volatile ("mcr p0, #6, %0, c0, c0" : : "r" (pin));
}
// Unconditionally clear any single output. Equivalent to:
//
// gpioc_hilo_out_clr(1ull << pin);
__force_inline static void gpioc_bit_out_clr(uint pin) {
pico_default_asm_volatile ("mcr p0, #7, %0, c0, c0" : : "r" (pin));
}
// Conditionally toggle any single output. Equivalent to:
//
// gpioc_hilo_out_xor((uint64_t)val << pin);
__force_inline static void gpioc_bit_out_xor2(uint pin, bool val) {
pico_default_asm_volatile ("mcrr p0, #5, %0, %1, c0" : : "r" (pin), "r" (val));
}
// Conditionally set any single output. Equivalent to:
//
// gpioc_hilo_out_set((uint64_t)val << pin);
__force_inline static void gpioc_bit_out_set2(uint pin, bool val) {
pico_default_asm_volatile ("mcrr p0, #6, %0, %1, c0" : : "r" (pin), "r" (val));
}
// Conditionally clear any single output. Equivalent to:
//
// gpioc_hilo_out_clr((uint64_t)val << pin);
__force_inline static void gpioc_bit_out_clr2(uint pin, bool val) {
pico_default_asm_volatile ("mcrr p0, #7, %0, %1, c0" : : "r" (pin), "r" (val));
}
// Write a 1-bit value to any output enable. Equivalent to:
//
// if (val)
// gpioc_hilo_oe_set(1ull << pin);
// else
// gpioc_hilo_oe_clr(1ull << pin);
__force_inline static void gpioc_bit_oe_put(uint pin, bool val) {
pico_default_asm_volatile ("mcrr p0, #4, %0, %1, c4" : : "r" (pin), "r" (val));
}
// Unconditionally toggle any output enable. Equivalent to:
//
// gpioc_hilo_oe_xor(1ull << pin);
__force_inline static void gpioc_bit_oe_xor(uint pin) {
pico_default_asm_volatile ("mcr p0, #5, %0, c0, c4" : : "r" (pin));
}
// Unconditionally set any output enable (set to output). Equivalent to:
//
// gpioc_hilo_oe_set(1ull << pin);
__force_inline static void gpioc_bit_oe_set(uint pin) {
pico_default_asm_volatile ("mcr p0, #6, %0, c0, c4" : : "r" (pin));
}
// Unconditionally clear any output enable (set to input). Equivalent to:
//
// gpioc_hilo_oe_clr(1ull << pin);
__force_inline static void gpioc_bit_oe_clr(uint pin) {
pico_default_asm_volatile ("mcr p0, #7, %0, c0, c4" : : "r" (pin));
}
// Conditionally toggle any output enable. Equivalent to:
//
// gpioc_hilo_oe_xor((uint64_t)val << pin);
__force_inline static void gpioc_bit_oe_xor2(uint pin, bool val) {
pico_default_asm_volatile ("mcrr p0, #5, %0, %1, c4" : : "r" (pin), "r" (val));
}
// Conditionally set any output enable (set to output). Equivalent to:
//
// gpioc_hilo_oe_set((uint64_t)val << pin);
__force_inline static void gpioc_bit_oe_set2(uint pin, bool val) {
pico_default_asm_volatile ("mcrr p0, #6, %0, %1, c4" : : "r" (pin), "r" (val));
}
// Conditionally clear any output enable (set to input). Equivalent to:
//
// gpioc_hilo_oe_clr((uint64_t)val << pin);
__force_inline static void gpioc_bit_oe_clr2(uint pin, bool val) {
pico_default_asm_volatile ("mcrr p0, #7, %0, %1, c4" : : "r" (pin), "r" (val));
}
// ----------------------------------------------------------------------------
// Indexed mask write instructions -- write to a dynamically selected 32-bit
// GPIO register
// Write to a selected GPIO output register. Equivalent to:
//
// if (reg_index == 0) {
// gpioc_lo_out_put(val);
// } else if (reg_index == 1) {
// gpioc_hi_out_put(val);
// } else {
// // undefined
// }
__force_inline static void gpioc_index_out_put(uint reg_index, uint32_t val) {
pico_default_asm_volatile ("mcrr p0, #8, %1, %0, c0" : : "r" (reg_index), "r" (val));
}
// Toggle bits in a selected GPIO output register. Equivalent to:
//
// if (reg_index == 0) {
// gpioc_lo_out_xor(val);
// } else if (reg_index == 1) {
// gpioc_hi_out_xor(val);
// } else {
// // undefined
// }
__force_inline static void gpioc_index_out_xor(uint reg_index, uint32_t mask) {
pico_default_asm_volatile ("mcrr p0, #9, %1, %0, c0" : : "r" (reg_index), "r" (mask));
}
// Set bits in a selected GPIO output register. Equivalent to:
//
// if (reg_index == 0) {
// gpioc_lo_out_set(val);
// } else if (reg_index == 1) {
// gpioc_hi_out_set(val);
// } else {
// // undefined
// }
__force_inline static void gpioc_index_out_set(uint reg_index, uint32_t mask) {
pico_default_asm_volatile ("mcrr p0, #10, %1, %0, c0" : : "r" (reg_index), "r" (mask));
}
// Clear bits in a selected GPIO output register. Equivalent to:
//
// if (reg_index == 0) {
// gpioc_lo_out_clr(val);
// } else if (reg_index == 1) {
// gpioc_hi_out_clr(val);
// } else {
// // undefined
// }
__force_inline static void gpioc_index_out_clr(uint reg_index, uint32_t mask) {
pico_default_asm_volatile ("mcrr p0, #11, %1, %0, c0" : : "r" (reg_index), "r" (mask));
}
// Write to a selected GPIO output enable register. Equivalent to:
//
// if (reg_index == 0) {
// gpioc_lo_oe_put(val);
// } else if (reg_index == 1) {
// gpioc_hi_oe_put(val);
// } else {
// // undefined
// }
__force_inline static void gpioc_index_oe_put(uint reg_index, uint32_t val) {
pico_default_asm_volatile ("mcrr p0, #8, %1, %0, c4" : : "r" (reg_index), "r" (val));
}
// Toggle bits in a selected GPIO output enable register. Equivalent to:
//
// if (reg_index == 0) {
// gpioc_lo_oe_xor(val);
// } else if (reg_index == 1) {
// gpioc_hi_oe_xor(val);
// } else {
// // undefined
// }
__force_inline static void gpioc_index_oe_xor(uint reg_index, uint32_t mask) {
pico_default_asm_volatile ("mcrr p0, #9, %1, %0, c4" : : "r" (reg_index), "r" (mask));
}
// Set bits in a selected GPIO output enable register (set to output). Equivalent to:
//
// if (reg_index == 0) {
// gpioc_lo_oe_set(val);
// } else if (reg_index == 1) {
// gpioc_hi_oe_set(val);
// } else {
// // undefined
// }
__force_inline static void gpioc_index_oe_set(uint reg_index, uint32_t mask) {
pico_default_asm_volatile ("mcrr p0, #10, %1, %0, c4" : : "r" (reg_index), "r" (mask));
}
// Clear bits in a selected GPIO output enable register (set to input). Equivalent to:
//
// if (reg_index == 0) {
// gpioc_lo_oe_clr(val);
// } else if (reg_index == 1) {
// gpioc_hi_oe_clr(val);
// } else {
// // undefined
// }
__force_inline static void gpioc_index_oe_clr(uint reg_index, uint32_t mask) {
pico_default_asm_volatile ("mcrr p0, #11, %1, %0, c4" : : "r" (reg_index), "r" (mask));
}
// ----------------------------------------------------------------------------
// Read instructions
// Read back the lower 32-bit output register. Equivalent to:
//
// return sio_hw->gpio_out;
__force_inline static uint32_t gpioc_lo_out_get(void) {
uint32_t lo;
pico_default_asm_volatile ("mrc p0, #0, %0, c0, c0" : "=r" (lo));
return lo;
}
// Read back the upper 32-bit output register. Equivalent to:
//
// return sio_hw->gpio_hi_out;
__force_inline static uint32_t gpioc_hi_out_get(void) {
uint32_t hi;
pico_default_asm_volatile ("mrc p0, #0, %0, c0, c1" : "=r" (hi));
return hi;
}
// Read back two 32-bit output registers in a single operation. Equivalent to:
//
// return sio_hw->gpio_out | ((uint64_t)sio_hw->gpio_hi_out << 32);
__force_inline static uint64_t gpioc_hilo_out_get(void) {
uint32_t hi, lo;
pico_default_asm_volatile ("mrrc p0, #0, %0, %1, c0" : "=r" (lo), "=r" (hi));
return ((uint64_t)hi << 32) | lo;
}
// Read back the lower 32-bit output enable register. Equivalent to:
//
// return sio_hw->gpio_oe;
__force_inline static uint32_t gpioc_lo_oe_get(void) {
uint32_t lo;
pico_default_asm_volatile ("mrc p0, #0, %0, c0, c4" : "=r" (lo));
return lo;
}
// Read back the upper 32-bit output enable register. Equivalent to:
//
// return sio_hw->gpio_hi_oe;
__force_inline static uint32_t gpioc_hi_oe_get(void) {
uint32_t hi;
pico_default_asm_volatile ("mrc p0, #0, %0, c0, c5" : "=r" (hi));
return hi;
}
// Read back two 32-bit output enable registers in a single operation. Equivalent to:
//
// return sio_hw->gpio_oe | ((uint64_t)sio_hw->gpio_hi_oe << 32);
__force_inline static uint64_t gpioc_hilo_oe_get(void) {
uint32_t hi, lo;
pico_default_asm_volatile ("mrrc p0, #0, %0, %1, c4" : "=r" (lo), "=r" (hi));
return ((uint64_t)hi << 32) | lo;
}
// Sample the lower 32 GPIOs. Equivalent to:
//
// return sio_hw->gpio_in;
__force_inline static uint32_t gpioc_lo_in_get(void) {
uint32_t lo;
pico_default_asm_volatile ("mrc p0, #0, %0, c0, c8" : "=r" (lo));
return lo;
}
// Sample the upper 32 GPIOs. Equivalent to:
//
// return sio_hw->gpio_hi_in;
__force_inline static uint32_t gpioc_hi_in_get(void) {
uint32_t hi;
pico_default_asm_volatile ("mrc p0, #0, %0, c0, c9" : "=r" (hi));
return hi;
}
// Sample 64 GPIOs on the same cycle. Equivalent to:
//
// return sio_hw->gpio_in | ((uint64_t)sio_hw->gpio_hi_in << 32);
__force_inline static uint64_t gpioc_hilo_in_get(void) {
uint32_t hi, lo;
pico_default_asm_volatile ("mrrc p0, #0, %0, %1, c8" : "=r" (lo), "=r" (hi));
return ((uint64_t)hi << 32) | lo;
}
#endif
Details ![]()
Show: from Types: Columns: ![]( "Show Project Names")
![]( "Show Locations")
![]( "Show Referring Symbols")
![]( "Show Scope")
This file uses the notable symbols shown below. Click anywhere in the file to view more details.