/** Find the SERCOM peripheral of given pin
*
* Find and return the SERCOM peripheral of input pin, either from default pads, or from extended pads
* @param[in] pin1 First pin
* @param[in] pad_select to select which pad is to be used first to find
* @return SERCOM peripheral if found, else, NC
*/
uint32_t pinmap_find_peripheral_from_pad(PinName pin, enum sercom_pad_selection pad_select)
{
uint32_t pin_sercom = NC;
if (pin == NC) return NC;
if (pad_select == SERCOM_USE_EXTENDED_PAD) {
pin_sercom = pinmap_find_peripheral(pin, PinMap_SERCOM_PADEx);
}
if (pin_sercom == (uint32_t)NC) {
pin_sercom = pinmap_find_peripheral(pin, PinMap_SERCOM_PAD);
}
return pin_sercom;
}
void analogout_init(dac_t *obj, PinName pin)
{
MBED_ASSERT(obj);
if (g_sys_init == 0) {
system_init();
g_sys_init = 1;
}
struct dac_config config_dac;
struct dac_chan_config config_dac_chan;
uint32_t pos_input;
pos_input = pinmap_find_peripheral(pin, PinMap_DAC);
MBED_ASSERT(pos_input != NC);
obj->dac = DAC_0;
dac_get_config_defaults(&config_dac);
dac_init(&dac_instance, (Dac *)DAC_0, &config_dac);
dac_chan_get_config_defaults(&config_dac_chan);
dac_chan_set_config(&dac_instance, DAC_CHANNEL_0, &config_dac_chan);
dac_chan_enable(&dac_instance, DAC_CHANNEL_0);
dac_enable(&dac_instance);
}
void analogout_init(dac_t *obj, PinName pin)
{
MBED_ASSERT(obj);
if (g_sys_init == 0) {
system_init();
g_sys_init = 1;
}
struct dac_config config_dac;
struct dac_chan_config config_dac_chan;
uint32_t dacperipheral;
uint32_t ch_index;
dacperipheral = pinmap_find_peripheral(pin, PinMap_DAC);
MBED_ASSERT(dacperipheral != NC);
obj->pin = pin;
obj->dac = dacperipheral;
if (pin == PA02) {
ch_index = 0;
} else if (pin == PA05) {
ch_index = 1;
} else { /*Only 2 pins for DAC*/
return 0;
}
obj->channel = ch_index;
dac_get_config_defaults(&config_dac);
dac_init(&(obj->dac_instance), (Dac *)dacperipheral, &config_dac);
dac_chan_get_config_defaults(&config_dac_chan);
dac_chan_set_config(&(obj->dac_instance), ch_index, &config_dac_chan);
dac_chan_enable(&(obj->dac_instance), ch_index);
dac_enable(&(obj->dac_instance));
}
uint32_t pinmap_peripheral(PinName pin, const PinMap* map) {
uint32_t peripheral = (uint32_t)NC;
if (pin == (PinName)NC)
return (uint32_t)NC;
peripheral = pinmap_find_peripheral(pin, map);
if ((uint32_t)NC == peripheral) // no mapping available
error("pinmap not found for peripheral");
return peripheral;
}
/** Find the common SERCOM shared by two pins
*
* Finds the common SERCOM index of two input pins.
* If swapping the input argument gives different result, it means, two SERCOMs share both pins
* @param[in] pin1 First pin
* @param[in] pin2 Second pin
* @return SERCOM index if found, else, NC
*/
uint32_t pinmap_merge_sercom(PinName pin1, PinName pin2)
{
int i, j;
uint32_t pin1_sercom[2];
uint32_t pin2_sercom[2];
uint32_t sercom_index[4];
uint32_t pin_com = NC;
uint32_t pin_alt = NC;
uint32_t count_com = 0;
uint32_t count_alt = 0;
/* Adding a condition check just in case we need a different result when swapping arguments */
if (pin1 >= pin2) {
pin1_sercom[0] = pinmap_find_peripheral(pin1, PinMap_SERCOM_PAD);
pin1_sercom[1] = pinmap_find_peripheral(pin1, PinMap_SERCOM_PADEx);
} else {
pin1_sercom[0] = pinmap_find_peripheral(pin1, PinMap_SERCOM_PADEx);
pin1_sercom[1] = pinmap_find_peripheral(pin1, PinMap_SERCOM_PAD);
}
pin2_sercom[0] = pinmap_find_peripheral(pin2, PinMap_SERCOM_PAD);
pin2_sercom[1] = pinmap_find_peripheral(pin2, PinMap_SERCOM_PADEx);
for (i=0; i<2; i++) {
if (pin1_sercom[i] != NC) {
pin1_sercom[i] &= 0x0F;
}
for (j=0; j<2; j++) {
if (pin2_sercom[i] != NC) {
pin2_sercom[i] &= 0x0F;
}
sercom_index[(i*2) + j] = pinmap_merge_pins(pin1_sercom[i], pin2_sercom[j]);
}
}
for (i=0; i<4; i++) {
if (sercom_index[i] != NC) {
if (pin_com == NC) {
pin_com = sercom_index[i];
count_com++;
} else if (pin_com == sercom_index[i]) {
count_com++;
} else if (pin_alt == NC) {
pin_alt = sercom_index[i];
count_alt++;
} else if (pin_alt == sercom_index[i]) {
count_alt++;
} else {}
}
}
return ((count_com >= count_alt) ? pin_com : pin_alt);
}
int gpio_irq_init(gpio_irq_t *obj, PinName pin, gpio_irq_handler handler, uint32_t id)
{
MBED_ASSERT(obj);
if (pin == NC)
return -1;
IRQn_Type irq_n = (IRQn_Type)0;
uint32_t vector = 0;
int int_channel = 0;
irq_handler = handler; // assuming the usage of these apis in mbed layer only
obj->pin = pin;
extint_chan_get_config_defaults(&pEXT_CONF(obj));
pEXT_CONF(obj).gpio_pin = (uint32_t)pin;
pEXT_CONF(obj).gpio_pin_mux = 0; // mux setting for ext int is 0
pEXT_CONF(obj).gpio_pin_pull = EXTINT_PULL_UP;
pEXT_CONF(obj).detection_criteria = EXTINT_DETECT_NONE;
int_channel = pinmap_find_peripheral(pin, PinMap_EXTINT);
if (int_channel == NC) {
return -1;
}
extint_chan_set_config(int_channel, &pEXT_CONF(obj));
ext_int_pins[int_channel] = pin;
irq_n = EIC_IRQn;
vector = (uint32_t)gpio_irq;
NVIC_SetVector(irq_n, vector);
NVIC_EnableIRQ(irq_n);
obj->ch = int_channel;
channel_ids[int_channel] = id;
obj->irqmask = 0;
return 0;
}
