hardware_divider

Functions

static void hw_divider_divmod_s32_start (int32_t a, int32_t b)
 Start a signed asynchronous divideStart a divide of the specified signed parameters. You should wait for 8 cycles (__div_pause()) or wait for the ready bit to be set (hw_divider_wait_ready()) prior to reading the results. More...
 
static void hw_divider_divmod_u32_start (uint32_t a, uint32_t b)
 Start an unsigned asynchronous divideStart a divide of the specified unsigned parameters. You should wait for 8 cycles (__div_pause()) or wait for the ready bit to be set (hw_divider_wait_ready()) prior to reading the results. More...
 
static void hw_divider_wait_ready (void)
 Wait for a divide to completeWait for a divide to complete.
 
static divmod_result_t hw_divider_result_nowait (void)
 Return result of HW divide, nowait. More...
 
static divmod_result_t hw_divider_result_wait (void)
 Return result of last asynchronous HW divideThis function waits for the result to be ready by calling hw_divider_wait_ready(). More...
 
static uint32_t hw_divider_u32_quotient_wait (void)
 Return result of last asynchronous HW divide, unsigned quotient onlyThis function waits for the result to be ready by calling hw_divider_wait_ready(). More...
 
static int32_t hw_divider_s32_quotient_wait (void)
 Return result of last asynchronous HW divide, signed quotient onlyThis function waits for the result to be ready by calling hw_divider_wait_ready(). More...
 
static uint32_t hw_divider_u32_remainder_wait (void)
 Return result of last asynchronous HW divide, unsigned remainder onlyThis function waits for the result to be ready by calling hw_divider_wait_ready(). More...
 
static int32_t hw_divider_s32_remainder_wait (void)
 Return result of last asynchronous HW divide, signed remainder onlyThis function waits for the result to be ready by calling hw_divider_wait_ready(). More...
 
divmod_result_t hw_divider_divmod_s32 (int32_t a, int32_t b)
 Do a signed HW divide and wait for resultDivide a by b, wait for calculation to complete, return result as a fixed point 32p32 value. More...
 
divmod_result_t hw_divider_divmod_u32 (uint32_t a, uint32_t b)
 Do an unsigned HW divide and wait for resultDivide a by b, wait for calculation to complete, return result as a fixed point 32p32 value. More...
 
static uint32_t to_quotient_u32 (divmod_result_t r)
 Efficient extraction of unsigned quotient from 32p32 fixed point. More...
 
static int32_t to_quotient_s32 (divmod_result_t r)
 Efficient extraction of signed quotient from 32p32 fixed point. More...
 
static uint32_t to_remainder_u32 (divmod_result_t r)
 Efficient extraction of unsigned remainder from 32p32 fixed point. More...
 
static int32_t to_remainder_s32 (divmod_result_t r)
 Efficient extraction of signed remainder from 32p32 fixed point. More...
 
static uint32_t hw_divider_u32_quotient (uint32_t a, uint32_t b)
 Do an unsigned HW divide, wait for result, return quotientDivide a by b, wait for calculation to complete, return quotient. More...
 
static uint32_t hw_divider_u32_remainder (uint32_t a, uint32_t b)
 Do an unsigned HW divide, wait for result, return remainderDivide a by b, wait for calculation to complete, return remainder. More...
 
static int32_t hw_divider_quotient_s32 (int32_t a, int32_t b)
 Do a signed HW divide, wait for result, return quotientDivide a by b, wait for calculation to complete, return quotient. More...
 
static int32_t hw_divider_remainder_s32 (int32_t a, int32_t b)
 Do a signed HW divide, wait for result, return remainderDivide a by b, wait for calculation to complete, return remainder. More...
 
static void hw_divider_pause (void)
 Pause for exact amount of time needed for a asynchronous divide to complete.
 
static uint32_t hw_divider_u32_quotient_inlined (uint32_t a, uint32_t b)
 Do a hardware unsigned HW divide, wait for result, return quotientDivide a by b, wait for calculation to complete, return quotient. More...
 
static uint32_t hw_divider_u32_remainder_inlined (uint32_t a, uint32_t b)
 Do a hardware unsigned HW divide, wait for result, return remainderDivide a by b, wait for calculation to complete, return remainder. More...
 
static int32_t hw_divider_s32_quotient_inlined (int32_t a, int32_t b)
 Do a hardware signed HW divide, wait for result, return quotientDivide a by b, wait for calculation to complete, return quotient. More...
 
static int32_t hw_divider_s32_remainder_inlined (int32_t a, int32_t b)
 Do a hardware signed HW divide, wait for result, return remainderDivide a by b, wait for calculation to complete, return remainder. More...
 
void hw_divider_save_state (hw_divider_state_t *dest)
 Save the calling cores hardware divider stateCopy the current core's hardware divider state into the provided structure. This method waits for the divider results to be stable, then copies them to memory. They can be restored via hw_divider_restore_state() More...
 
void hw_divider_restore_state (hw_divider_state_t *src)
 Load a saved hardware divider state into the current core's hardware dividerCopy the passed hardware divider state into the hardware divider. More...
 

Detailed Description

Low-level hardware-divider access

The SIO contains an 8-cycle signed/unsigned divide/modulo circuit, per core. Calculation is started by writing a dividend and divisor to the two argument registers, DIVIDEND and DIVISOR. The divider calculates the quotient / and remainder % of this division over the next 8 cycles, and on the 9th cycle the results can be read from the two result registers DIV_QUOTIENT and DIV_REMAINDER. A 'ready' bit in register DIV_CSR can be polled to wait for the calculation to complete, or software can insert a fixed 8-cycle delay

This header provides low level macros and inline functions for accessing the hardware dividers directly, and perhaps most usefully performing asynchronous divides. These functions however do not follow the regular SDK conventions for saving/restoring the divider state, so are not generally safe to call from interrupt handlers

The pico_divider library provides a more user friendly set of APIs over the divider (and support for 64 bit divides), and of course by default regular C language integer divisions are redirected through that library, meaning you can just use C level / and % operators and gain the benefits of the fast hardware divider.

See also
pico_divider

Function Documentation

◆ hw_divider_divmod_s32()

divmod_result_t hw_divider_divmod_s32 ( int32_t  a,
int32_t  b 
)

Do a signed HW divide and wait for resultDivide a by b, wait for calculation to complete, return result as a fixed point 32p32 value.

Parameters
aThe dividend
bThe divisor
Returns
Results of divide as a 32p32 fixed point value.

◆ hw_divider_divmod_s32_start()

static void hw_divider_divmod_s32_start ( int32_t  a,
int32_t  b 
)
inlinestatic

Start a signed asynchronous divideStart a divide of the specified signed parameters. You should wait for 8 cycles (__div_pause()) or wait for the ready bit to be set (hw_divider_wait_ready()) prior to reading the results.

Parameters
aThe dividend
bThe divisor

◆ hw_divider_divmod_u32()

divmod_result_t hw_divider_divmod_u32 ( uint32_t  a,
uint32_t  b 
)

Do an unsigned HW divide and wait for resultDivide a by b, wait for calculation to complete, return result as a fixed point 32p32 value.

Parameters
aThe dividend
bThe divisor
Returns
Results of divide as a 32p32 fixed point value.

◆ hw_divider_divmod_u32_start()

static void hw_divider_divmod_u32_start ( uint32_t  a,
uint32_t  b 
)
inlinestatic

Start an unsigned asynchronous divideStart a divide of the specified unsigned parameters. You should wait for 8 cycles (__div_pause()) or wait for the ready bit to be set (hw_divider_wait_ready()) prior to reading the results.

Parameters
aThe dividend
bThe divisor

◆ hw_divider_quotient_s32()

static int32_t hw_divider_quotient_s32 ( int32_t  a,
int32_t  b 
)
inlinestatic

Do a signed HW divide, wait for result, return quotientDivide a by b, wait for calculation to complete, return quotient.

Parameters
aThe dividend
bThe divisor
Returns
Quotient results of the divide

◆ hw_divider_remainder_s32()

static int32_t hw_divider_remainder_s32 ( int32_t  a,
int32_t  b 
)
inlinestatic

Do a signed HW divide, wait for result, return remainderDivide a by b, wait for calculation to complete, return remainder.

Parameters
aThe dividend
bThe divisor
Returns
Remainder results of the divide

◆ hw_divider_restore_state()

void hw_divider_restore_state ( hw_divider_state_t src)

Load a saved hardware divider state into the current core's hardware dividerCopy the passed hardware divider state into the hardware divider.

Parameters
srcthe location to load the divider state from

◆ hw_divider_result_nowait()

static divmod_result_t hw_divider_result_nowait ( void  )
inlinestatic

Return result of HW divide, nowait.

Note
This is UNSAFE in that the calculation may not have been completed.
Returns
Current result. Most significant 32 bits are the remainder, lower 32 bits are the quotient.

◆ hw_divider_result_wait()

static divmod_result_t hw_divider_result_wait ( void  )
inlinestatic

Return result of last asynchronous HW divideThis function waits for the result to be ready by calling hw_divider_wait_ready().

Returns
Current result. Most significant 32 bits are the remainder, lower 32 bits are the quotient.

◆ hw_divider_s32_quotient_inlined()

static int32_t hw_divider_s32_quotient_inlined ( int32_t  a,
int32_t  b 
)
inlinestatic

Do a hardware signed HW divide, wait for result, return quotientDivide a by b, wait for calculation to complete, return quotient.

Parameters
aThe dividend
bThe divisor
Returns
Quotient result of the divide

◆ hw_divider_s32_quotient_wait()

static int32_t hw_divider_s32_quotient_wait ( void  )
inlinestatic

Return result of last asynchronous HW divide, signed quotient onlyThis function waits for the result to be ready by calling hw_divider_wait_ready().

Returns
Current signed quotient result.

◆ hw_divider_s32_remainder_inlined()

static int32_t hw_divider_s32_remainder_inlined ( int32_t  a,
int32_t  b 
)
inlinestatic

Do a hardware signed HW divide, wait for result, return remainderDivide a by b, wait for calculation to complete, return remainder.

Parameters
aThe dividend
bThe divisor
Returns
Remainder result of the divide

◆ hw_divider_s32_remainder_wait()

static int32_t hw_divider_s32_remainder_wait ( void  )
inlinestatic

Return result of last asynchronous HW divide, signed remainder onlyThis function waits for the result to be ready by calling hw_divider_wait_ready().

Returns
Current remainder results.

◆ hw_divider_save_state()

void hw_divider_save_state ( hw_divider_state_t dest)

Save the calling cores hardware divider stateCopy the current core's hardware divider state into the provided structure. This method waits for the divider results to be stable, then copies them to memory. They can be restored via hw_divider_restore_state()

Parameters
destthe location to store the divider state

◆ hw_divider_u32_quotient()

static uint32_t hw_divider_u32_quotient ( uint32_t  a,
uint32_t  b 
)
inlinestatic

Do an unsigned HW divide, wait for result, return quotientDivide a by b, wait for calculation to complete, return quotient.

Parameters
aThe dividend
bThe divisor
Returns
Quotient results of the divide

◆ hw_divider_u32_quotient_inlined()

static uint32_t hw_divider_u32_quotient_inlined ( uint32_t  a,
uint32_t  b 
)
inlinestatic

Do a hardware unsigned HW divide, wait for result, return quotientDivide a by b, wait for calculation to complete, return quotient.

Parameters
aThe dividend
bThe divisor
Returns
Quotient result of the divide

◆ hw_divider_u32_quotient_wait()

static uint32_t hw_divider_u32_quotient_wait ( void  )
inlinestatic

Return result of last asynchronous HW divide, unsigned quotient onlyThis function waits for the result to be ready by calling hw_divider_wait_ready().

Returns
Current unsigned quotient result.

◆ hw_divider_u32_remainder()

static uint32_t hw_divider_u32_remainder ( uint32_t  a,
uint32_t  b 
)
inlinestatic

Do an unsigned HW divide, wait for result, return remainderDivide a by b, wait for calculation to complete, return remainder.

Parameters
aThe dividend
bThe divisor
Returns
Remainder results of the divide

◆ hw_divider_u32_remainder_inlined()

static uint32_t hw_divider_u32_remainder_inlined ( uint32_t  a,
uint32_t  b 
)
inlinestatic

Do a hardware unsigned HW divide, wait for result, return remainderDivide a by b, wait for calculation to complete, return remainder.

Parameters
aThe dividend
bThe divisor
Returns
Remainder result of the divide

◆ hw_divider_u32_remainder_wait()

static uint32_t hw_divider_u32_remainder_wait ( void  )
inlinestatic

Return result of last asynchronous HW divide, unsigned remainder onlyThis function waits for the result to be ready by calling hw_divider_wait_ready().

Returns
Current unsigned remainder result.

◆ to_quotient_s32()

static int32_t to_quotient_s32 ( divmod_result_t  r)
inlinestatic

Efficient extraction of signed quotient from 32p32 fixed point.

Parameters
r32p32 fixed point value.
Returns
Unsigned quotient

◆ to_quotient_u32()

static uint32_t to_quotient_u32 ( divmod_result_t  r)
inlinestatic

Efficient extraction of unsigned quotient from 32p32 fixed point.

Parameters
r32p32 fixed point value.
Returns
Unsigned quotient

◆ to_remainder_s32()

static int32_t to_remainder_s32 ( divmod_result_t  r)
inlinestatic

Efficient extraction of signed remainder from 32p32 fixed point.

Parameters
r32p32 fixed point value.
Returns
Signed remainder
Note
On arm this is just a 32 bit register move or a nop

◆ to_remainder_u32()

static uint32_t to_remainder_u32 ( divmod_result_t  r)
inlinestatic

Efficient extraction of unsigned remainder from 32p32 fixed point.

Parameters
r32p32 fixed point value.
Returns
Unsigned remainder
Note
On Arm this is just a 32 bit register move or a nop