24 void pio_sm_claim(PIO pio, uint sm) {  in pio_sm_claim()  argument
26     uint which = pio_get_index(pio);  in pio_sm_claim()
36 void pio_claim_sm_mask(PIO pio, uint sm_mask) {  in pio_claim_sm_mask()  argument
38         if (sm_mask & 1u) pio_sm_claim(pio, i);  in pio_claim_sm_mask()
42 void pio_sm_unclaim(PIO pio, uint sm) {  in pio_sm_unclaim()  argument
44     uint which = pio_get_index(pio);  in pio_sm_unclaim()
48 int pio_claim_unused_sm(PIO pio, bool required) {  in pio_claim_unused_sm()  argument
50     uint which = pio_get_index(pio);  in pio_claim_unused_sm()
57 bool pio_sm_is_claimed(PIO pio, uint sm) {  in pio_sm_is_claimed()  argument
59     uint which = pio_get_index(pio);  in pio_sm_is_claimed()
66 static int find_offset_for_program(PIO pio, const pio_program_t *program) {  in find_offset_for_program()  argument
68     uint32_t used_mask = _used_instruction_space[pio_get_index(pio)];  in find_offset_for_program()
84 static int pio_set_gpio_base_unsafe(PIO pio, uint gpio_base) {  in pio_set_gpio_base_unsafe()  argument
87     uint32_t used_mask = _used_instruction_space[pio_get_index(pio)];  in pio_set_gpio_base_unsafe()
89     pio->gpiobase = gpio_base;  in pio_set_gpio_base_unsafe()
91     ((void)pio);  in pio_set_gpio_base_unsafe()
97 int pio_set_gpio_base(PIO pio, uint gpio_base) {  in pio_set_gpio_base()  argument
101     rc = pio_set_gpio_base_unsafe(pio, gpio_base);  in pio_set_gpio_base()
104     ((void)pio);  in pio_set_gpio_base()
110 static bool is_gpio_compatible(PIO pio, uint32_t used_gpio_ranges) {  in is_gpio_compatible()  argument
112     bool gpio_base = pio_get_gpio_base(pio);  in is_gpio_compatible()
116     ((void)pio);  in is_gpio_compatible()
122 static bool is_program_gpio_compatible(PIO pio, const pio_program_t *program) {  in is_program_gpio_compatible()  argument
124     return is_gpio_compatible(pio, program->used_gpio_ranges);  in is_program_gpio_compatible()
126     ((void)pio);  in is_program_gpio_compatible()
132 static int add_program_at_offset_check(PIO pio, const pio_program_t *program, uint offset) {  in add_program_at_offset_check()  argument
138 …if (!is_program_gpio_compatible(pio, program)) return PICO_ERROR_BAD_ALIGNMENT; // todo better err…  in add_program_at_offset_check()
140     uint32_t used_mask = _used_instruction_space[pio_get_index(pio)];  in add_program_at_offset_check()
145 bool pio_can_add_program(PIO pio, const pio_program_t *program) {  in pio_can_add_program()  argument
147     int rc = find_offset_for_program(pio, program);  in pio_can_add_program()
148     if (rc >= 0) rc = add_program_at_offset_check(pio, program, (uint)rc);  in pio_can_add_program()
153 bool pio_can_add_program_at_offset(PIO pio, const pio_program_t *program, uint offset) {  in pio_can_add_program_at_offset()  argument
155     bool rc = add_program_at_offset_check(pio, program, offset) == 0;  in pio_can_add_program_at_offset()
160 static int add_program_at_offset(PIO pio, const pio_program_t *program, uint offset) {  in add_program_at_offset()  argument
161     int rc = add_program_at_offset_check(pio, program, offset);  in add_program_at_offset()
165 …pio->instr_mem[offset + i] = pio_instr_bits_jmp != _pio_major_instr_bits(instr) ? instr : instr + …  in add_program_at_offset()
168     _used_instruction_space[pio_get_index(pio)] |= program_mask << offset;  in add_program_at_offset()
173 int pio_add_program(PIO pio, const pio_program_t *program) {  in pio_add_program()  argument
175     int offset = find_offset_for_program(pio, program);  in pio_add_program()
177         offset = add_program_at_offset(pio, program, (uint) offset);  in pio_add_program()
183 int pio_add_program_at_offset(PIO pio, const pio_program_t *program, uint offset) {  in pio_add_program_at_offset()  argument
185     int rc = add_program_at_offset(pio, program, offset);  in pio_add_program_at_offset()
190 void pio_remove_program(PIO pio, const pio_program_t *program, uint loaded_offset) {  in pio_remove_program()  argument
194     assert(program_mask == (_used_instruction_space[pio_get_index(pio)] & program_mask));  in pio_remove_program()
195     _used_instruction_space[pio_get_index(pio)] &= ~program_mask;  in pio_remove_program()
199 void pio_clear_instruction_memory(PIO pio) {  in pio_clear_instruction_memory()  argument
201     _used_instruction_space[pio_get_index(pio)] = 0;  in pio_clear_instruction_memory()
203         pio->instr_mem[i] = pio_encode_jmp(i);  in pio_clear_instruction_memory()
221 void pio_sm_set_pins_internal(PIO pio, uint sm, uint32_t pins) {  in pio_sm_set_pins_internal()  argument
222     check_pio_param(pio);  in pio_sm_set_pins_internal()
224     uint32_t pinctrl_saved = pio->sm[sm].pinctrl;  in pio_sm_set_pins_internal()
225     uint32_t execctrl_saved = pio->sm[sm].execctrl;  in pio_sm_set_pins_internal()
226     hw_clear_bits(&pio->sm[sm].execctrl, 1u << PIO_SM0_EXECCTRL_OUT_STICKY_LSB);  in pio_sm_set_pins_internal()
231         pio->sm[sm].pinctrl =  in pio_sm_set_pins_internal()
234         pio_sm_exec(pio, sm, pio_encode_set(pio_pins, pins & 0x1fu));  in pio_sm_set_pins_internal()
239     pio->sm[sm].pinctrl = pinctrl_saved;  in pio_sm_set_pins_internal()
240     pio->sm[sm].execctrl = execctrl_saved;  in pio_sm_set_pins_internal()
244 void pio_sm_set_pins(PIO pio, uint sm, uint32_t pins) {  in pio_sm_set_pins()  argument
246     pins >>= pio_get_gpio_base(pio);  in pio_sm_set_pins()
248     pio_sm_set_pins_internal(pio, sm, pins);  in pio_sm_set_pins()
252 void pio_sm_set_pins64(PIO pio, uint sm, uint64_t pins) {  in pio_sm_set_pins64()  argument
253     check_pio_pin_mask64(pio, sm, pins);  in pio_sm_set_pins64()
255     pins >>= pio_get_gpio_base(pio);  in pio_sm_set_pins64()
257     pio_sm_set_pins_internal(pio, sm, (uint32_t)pins);  in pio_sm_set_pins64()
261 void pio_sm_set_pins_with_mask_internal(PIO pio, uint sm, uint32_t pin_values, uint32_t pin_mask) {  in pio_sm_set_pins_with_mask_internal()  argument
262     check_pio_param(pio);  in pio_sm_set_pins_with_mask_internal()
264     uint32_t pinctrl_saved = pio->sm[sm].pinctrl;  in pio_sm_set_pins_with_mask_internal()
265     uint32_t execctrl_saved = pio->sm[sm].execctrl;  in pio_sm_set_pins_with_mask_internal()
266     hw_clear_bits(&pio->sm[sm].execctrl, 1u << PIO_SM0_EXECCTRL_OUT_STICKY_LSB);  in pio_sm_set_pins_with_mask_internal()
269         pio->sm[sm].pinctrl =  in pio_sm_set_pins_with_mask_internal()
272         pio_sm_exec(pio, sm, pio_encode_set(pio_pins, (pin_values >> base) & 0x1u));  in pio_sm_set_pins_with_mask_internal()
275     pio->sm[sm].pinctrl = pinctrl_saved;  in pio_sm_set_pins_with_mask_internal()
276     pio->sm[sm].execctrl = execctrl_saved;  in pio_sm_set_pins_with_mask_internal()
280 void pio_sm_set_pins_with_mask(PIO pio, uint sm, uint32_t pin_values, uint32_t pin_mask) {  in pio_sm_set_pins_with_mask()  argument
282     pin_values >>= pio_get_gpio_base(pio);  in pio_sm_set_pins_with_mask()
283     pin_mask >>= pio_get_gpio_base(pio);  in pio_sm_set_pins_with_mask()
285     pio_sm_set_pins_with_mask_internal(pio, sm, pin_values, pin_mask);  in pio_sm_set_pins_with_mask()
289 void pio_sm_set_pins_with_mask64(PIO pio, uint sm, uint64_t pin_values, uint64_t pin_mask) {  in pio_sm_set_pins_with_mask64()  argument
290     check_pio_pin_mask64(pio, sm, pin_mask);  in pio_sm_set_pins_with_mask64()
292     pin_values >>= pio_get_gpio_base(pio);  in pio_sm_set_pins_with_mask64()
293     pin_mask >>= pio_get_gpio_base(pio);  in pio_sm_set_pins_with_mask64()
295     pio_sm_set_pins_with_mask_internal(pio, sm, (uint32_t)pin_values, (uint32_t)pin_mask);  in pio_sm_set_pins_with_mask64()
298 void pio_sm_set_pindirs_with_mask_internal(PIO pio, uint sm, uint32_t pindirs, uint32_t pin_mask) {  in pio_sm_set_pindirs_with_mask_internal()  argument
299     check_pio_param(pio);  in pio_sm_set_pindirs_with_mask_internal()
301     uint32_t pinctrl_saved = pio->sm[sm].pinctrl;  in pio_sm_set_pindirs_with_mask_internal()
302     uint32_t execctrl_saved = pio->sm[sm].execctrl;  in pio_sm_set_pindirs_with_mask_internal()
303     hw_clear_bits(&pio->sm[sm].execctrl, 1u << PIO_SM0_EXECCTRL_OUT_STICKY_LSB);  in pio_sm_set_pindirs_with_mask_internal()
306         pio->sm[sm].pinctrl =  in pio_sm_set_pindirs_with_mask_internal()
309         pio_sm_exec(pio, sm, pio_encode_set(pio_pindirs, (pindirs >> base) & 0x1u));  in pio_sm_set_pindirs_with_mask_internal()
312     pio->sm[sm].pinctrl = pinctrl_saved;  in pio_sm_set_pindirs_with_mask_internal()
313     pio->sm[sm].execctrl = execctrl_saved;  in pio_sm_set_pindirs_with_mask_internal()
317 void pio_sm_set_pindirs_with_mask(PIO pio, uint sm, uint32_t pindirs, uint32_t pin_mask) {  in pio_sm_set_pindirs_with_mask()  argument
319     pindirs >>= pio_get_gpio_base(pio);  in pio_sm_set_pindirs_with_mask()
320     pin_mask >>= pio_get_gpio_base(pio);  in pio_sm_set_pindirs_with_mask()
322     pio_sm_set_pindirs_with_mask_internal(pio, sm, pindirs, pin_mask);  in pio_sm_set_pindirs_with_mask()
326 void pio_sm_set_pindirs_with_mask64(PIO pio, uint sm, uint64_t pindirs, uint64_t pin_mask) {  in pio_sm_set_pindirs_with_mask64()  argument
328     pindirs >>= pio_get_gpio_base(pio);  in pio_sm_set_pindirs_with_mask64()
329     pin_mask >>= pio_get_gpio_base(pio);  in pio_sm_set_pindirs_with_mask64()
331     pio_sm_set_pindirs_with_mask_internal(pio, sm, (uint32_t)pindirs, (uint32_t)pin_mask);  in pio_sm_set_pindirs_with_mask64()
334 int pio_sm_set_consecutive_pindirs(PIO pio, uint sm, uint pin, uint count, bool is_out) {  in pio_sm_set_consecutive_pindirs()  argument
335     check_pio_param(pio);  in pio_sm_set_consecutive_pindirs()
337     pin -= pio_get_gpio_base(pio);  in pio_sm_set_consecutive_pindirs()
339     uint32_t pinctrl_saved = pio->sm[sm].pinctrl;  in pio_sm_set_consecutive_pindirs()
340     uint32_t execctrl_saved = pio->sm[sm].execctrl;  in pio_sm_set_consecutive_pindirs()
341     hw_clear_bits(&pio->sm[sm].execctrl, 1u << PIO_SM0_EXECCTRL_OUT_STICKY_LSB);  in pio_sm_set_consecutive_pindirs()
344 …pio->sm[sm].pinctrl = (5u << PIO_SM0_PINCTRL_SET_COUNT_LSB) | (pin << PIO_SM0_PINCTRL_SET_BASE_LSB…  in pio_sm_set_consecutive_pindirs()
345         pio_sm_exec(pio, sm, pio_encode_set(pio_pindirs, pindir_val));  in pio_sm_set_consecutive_pindirs()
349 …pio->sm[sm].pinctrl = (count << PIO_SM0_PINCTRL_SET_COUNT_LSB) | (pin << PIO_SM0_PINCTRL_SET_BASE_…  in pio_sm_set_consecutive_pindirs()
350     pio_sm_exec(pio, sm, pio_encode_set(pio_pindirs, pindir_val));  in pio_sm_set_consecutive_pindirs()
351     pio->sm[sm].pinctrl = pinctrl_saved;  in pio_sm_set_consecutive_pindirs()
352     pio->sm[sm].execctrl = execctrl_saved;  in pio_sm_set_consecutive_pindirs()
356 int pio_sm_init(PIO pio, uint sm, uint initial_pc, const pio_sm_config *config) {  in pio_sm_init()  argument
359     pio_sm_set_enabled(pio, sm, false);  in pio_sm_init()
363         rc = pio_sm_set_config(pio, sm, config);  in pio_sm_init()
366         rc = pio_sm_set_config(pio, sm, &c);  in pio_sm_init()
370     pio_sm_clear_fifos(pio, sm);  in pio_sm_init()
378     pio->fdebug = fdebug_sm_mask << sm;  in pio_sm_init()
381     pio_sm_restart(pio, sm);  in pio_sm_init()
382     pio_sm_clkdiv_restart(pio, sm);  in pio_sm_init()
383     pio_sm_exec(pio, sm, pio_encode_jmp(initial_pc));  in pio_sm_init()
387 void pio_sm_drain_tx_fifo(PIO pio, uint sm) {  in pio_sm_drain_tx_fifo()  argument
388 …uint instr = (pio->sm[sm].shiftctrl & PIO_SM0_SHIFTCTRL_AUTOPULL_BITS) ? pio_encode_out(pio_null, …  in pio_sm_drain_tx_fifo()
390     while (!pio_sm_is_tx_fifo_empty(pio, sm)) {  in pio_sm_drain_tx_fifo()
391         pio_sm_exec(pio, sm, instr);  in pio_sm_drain_tx_fifo()
395 bool pio_claim_free_sm_and_add_program(const pio_program_t *program, PIO *pio, uint *sm, uint *offs…  in pio_claim_free_sm_and_add_program()  argument
396     return pio_claim_free_sm_and_add_program_for_gpio_range(program, pio, sm, offset, 0, 0, false);  in pio_claim_free_sm_and_add_program()
399 bool pio_claim_free_sm_and_add_program_for_gpio_range(const pio_program_t *program, PIO *pio, uint …  in pio_claim_free_sm_and_add_program_for_gpio_range()  argument
418             *pio = pio_get_instance((uint)pio_num);  in pio_claim_free_sm_and_add_program_for_gpio_range()
424                 sm_index[num_claimed] = (int8_t)pio_claim_unused_sm(*pio, false);  in pio_claim_free_sm_and_add_program_for_gpio_range()
430                     pio_set_gpio_base_unsafe(*pio, required_gpio_ranges & 4 ? 16 : 0);  in pio_claim_free_sm_and_add_program_for_gpio_range()
432 …      int rc = is_gpio_compatible(*pio, required_gpio_ranges) ? PICO_OK : PICO_ERROR_BAD_ALIGNMENT;  in pio_claim_free_sm_and_add_program_for_gpio_range()
433                 if (rc == PICO_OK) rc = find_offset_for_program(*pio, program);  in pio_claim_free_sm_and_add_program_for_gpio_range()
434                 if (rc >= 0) rc = add_program_at_offset(*pio, program, (uint)rc);  in pio_claim_free_sm_and_add_program_for_gpio_range()
443                     pio_sm_unclaim(*pio, (uint) sm_index[i]);  in pio_claim_free_sm_and_add_program_for_gpio_range()
451     *pio = NULL;  in pio_claim_free_sm_and_add_program_for_gpio_range()
455 void pio_remove_program_and_unclaim_sm(const pio_program_t *program, PIO pio, uint sm, uint offset)…  in pio_remove_program_and_unclaim_sm()  argument
456     check_pio_param(pio);  in pio_remove_program_and_unclaim_sm()
458     pio_remove_program(pio, program, offset);  in pio_remove_program_and_unclaim_sm()
459     pio_sm_unclaim(pio, sm);  in pio_remove_program_and_unclaim_sm()