AVR Freaks

Why only one handler is what I'm asking. You have this function to add more I guess (just from google search, I did not try it):
 

/**
 * \brief Set an interrupt handler for the provided pins.
 * The provided handler will be called with the triggering pin as its parameter
 * as soon as an interrupt is detected.
 *
 * \param p_pio PIO controller base address.
 * \param ul_id PIO ID.
 * \param ul_mask Pins (bit mask) to configure.
 * \param ul_attr Pins attribute to configure.
 * \param p_handler Interrupt handler function pointer.
 *
 * \return 0 if successful, 1 if the maximum number of sources has been defined.
 */
uint32_t pio_handler_set(Pio *p_pio, uint32_t ul_id, uint32_t ul_mask,
		uint32_t ul_attr, void (*p_handler) (uint32_t, uint32_t))

/Lars

it appears that the library is already reading the interrupt status register. And that's why status register is cleared

Does reading the ISR clear the bits?  I thought most of the SAM GPIO peripherals needed explicit clearing...

I'm not sure that the code you're looking at goes with the SAML10 chips.  From the datasheet, it looks like pin interrupts go through the EIC peripheral rather than the PORT peripheral.

I'll assume that this is an ASF4 ("Start") based project?  (ASF3 doesn't seem to have support for SAML.)

I created a sample Start Project for SAML10 and found the actual ISR code used:

/**
 * \brief Inter EIC interrupt handler
 */
static void _ext_irq_handler(void)
{
	volatile uint32_t flags = hri_eic_read_INTFLAG_reg(EIC);
	int8_t            pos;
	uint32_t          pin = INVALID_PIN_NUMBER;

	hri_eic_clear_INTFLAG_reg(EIC, flags);

	ASSERT(callback);

	while (flags) {
		pos = ffs(flags) - 1;
		while (-1 != pos) {
			uint8_t lower = 0, middle, upper = EXT_IRQ_AMOUNT;

			while (upper >= lower) {
				middle = (upper + lower) >> 1;
				if (_map[middle].extint == pos) {
					pin = _map[middle].pin;
					break;
				}
				if (_map[middle].extint < pos) {
					lower = middle + 1;
				} else {
					upper = middle - 1;
				}
			}

			if (INVALID_PIN_NUMBER != pin) {
				callback(pin);
			}
			flags &= ~(1ul << pos);
			pos = ffs(flags) - 1;
		}
		flags = hri_eic_read_INTFLAG_reg(EIC);
		hri_eic_clear_INTFLAG_reg(EIC, flags);
	}
}

There are a couple of interesting things I noticed there:

1. Definitely not the same as the SAM4/3 code.
2. The interrupts are handled in hpl/hpl_eic.c - the "external interrupt handler driver", rather than in the Port driver.
3. The handler DOES clear the INTFLAGS.  Repeatedly.
4. The pin number IS passed to the callback function as an argument (the only argument), so you don't need to re-examine INTFLAGS.
5. I'm not sure what those nested while loops are doing.  Maybe checking all the pins that a particular interrupt might occur on?  (I was pretty sure than one SAMD, only one pin can have the interrupt enabled at a time.)
6. (Seems potentially slow :-( )