static void radio_setup()
{
// Update RF231 config if board is patched
if (al04_has_slptr_on_timer)
{
_rf231_config.slp_tr_gpio = GPIO_C;
_rf231_config.slp_tr_pin = GPIO_PIN_6;
_rf231_config.slp_tr_af = GPIO_AF_2;
}
// Configure the radio chips
// Set IRQ as input IRQ
syscfg_select_exti_pin(EXTI_LINE_Px0, SYSCFG_PORT_B);
nvic_enable_interrupt_line(NVIC_IRQ_LINE_EXTI0);
// Set DIG2 as Timer input capture
gpio_set_alternate_function(GPIO_A, GPIO_PIN_6, GPIO_AF_3);
// Initialize the radio to put it in Sleep State
rf2xx_init(rf231);
// Set IRQ as input IRQ
syscfg_select_exti_pin(EXTI_LINE_Px1, SYSCFG_PORT_B);
nvic_enable_interrupt_line(NVIC_IRQ_LINE_EXTI1);
// Set DIG2 as Timer input capture
gpio_set_alternate_function(GPIO_A, GPIO_PIN_7, GPIO_AF_3);
// Initialize the radio to put it in Sleep State
rf2xx_init(rf212);
}
void gpio_pre_init(void)
{
int i;
int flags;
int is_warm = system_is_reboot_warm();
const struct gpio_info *g = gpio_list;
for (i = 0; i < GPIO_COUNT; i++, g++) {
flags = g->flags;
if (flags & GPIO_DEFAULT)
continue;
/*
* If this is a warm reboot, don't set the output levels or
* we'll shut off the AP.
*/
if (is_warm)
flags &= ~(GPIO_LOW | GPIO_HIGH);
gpio_set_flags_by_mask(g->port, g->mask, flags);
/* Use as GPIO, not alternate function */
gpio_set_alternate_function(g->port, g->mask, -1);
}
}
static int command_gpio_set(int argc, char **argv)
{
#ifdef CONFIG_CMD_GPIO_EXTENDED
int gpio;
int flags = 0;
int af = -1;
char *e;
if (argc < 3)
return EC_ERROR_PARAM_COUNT;
gpio = find_signal_by_name(argv[1]);
if (gpio == GPIO_COUNT)
return EC_ERROR_PARAM1;
if (strcasecmp(argv[2], "IN") == 0)
flags = GPIO_INPUT;
else if (strcasecmp(argv[2], "1") == 0)
flags = GPIO_OUT_HIGH;
else if (strcasecmp(argv[2], "0") == 0)
flags = GPIO_OUT_LOW;
else if (strcasecmp(argv[2], "A") == 0)
flags = GPIO_ANALOG;
else if (strcasecmp(argv[2], "ALT") == 0) {
if (argc >= 4) {
af = strtoi(argv[3], &e, 0);
if (*e || af < 0 || af > 5)
return EC_ERROR_PARAM2;
}
flags = GPIO_ALTERNATE;
} else
return EC_ERROR_PARAM2;
/* Update alt function if requested. */
if (af >= 0) {
const struct gpio_info *g = gpio_list + gpio;
gpio_set_alternate_function(g->port, g->mask, af);
}
/* Update GPIO flags. */
gpio_set_flags(gpio, flags);
#else
char *e;
int v;
if (argc < 3)
return EC_ERROR_PARAM_COUNT;
v = strtoi(argv[2], &e, 0);
if (*e)
return EC_ERROR_PARAM2;
if (set(argv[1], v) != EC_SUCCESS)
return EC_ERROR_PARAM1;
#endif
return EC_SUCCESS;
}
void gpio_pre_init(void)
{
const struct gpio_info *g = gpio_list;
int is_warm = 0;
int i;
if (LM4_SYSTEM_RCGCGPIO == 0x7fff) {
/* This is a warm reboot */
is_warm = 1;
} else {
/*
* Enable clocks to all the GPIO blocks since we use all of
* them as GPIOs in run and sleep modes.
*/
clock_enable_peripheral(CGC_OFFSET_GPIO, 0x7fff,
CGC_MODE_RUN | CGC_MODE_SLEEP);
}
/*
* Disable GPIO commit control for PD7 and PF0, since we don't use the
* NMI pin function.
*/
LM4_GPIO_LOCK(LM4_GPIO_D) = LM4_GPIO_LOCK_UNLOCK;
LM4_GPIO_CR(LM4_GPIO_D) |= 0x80;
LM4_GPIO_LOCK(LM4_GPIO_D) = 0;
LM4_GPIO_LOCK(LM4_GPIO_F) = LM4_GPIO_LOCK_UNLOCK;
LM4_GPIO_CR(LM4_GPIO_F) |= 0x01;
LM4_GPIO_LOCK(LM4_GPIO_F) = 0;
/* Clear SSI0 alternate function on PA2:5 */
LM4_GPIO_AFSEL(LM4_GPIO_A) &= ~0x3c;
/* Mask all GPIO interrupts */
for (i = 0; gpio_bases[i]; i++)
LM4_GPIO_IM(gpio_bases[i]) = 0;
/* Set all GPIOs to defaults */
for (i = 0; i < GPIO_COUNT; i++, g++) {
int flags = g->flags;
if (flags & GPIO_DEFAULT)
continue;
#ifdef CONFIG_LOW_POWER_IDLE
/*
* Enable board specific GPIO ports to interrupt deep sleep by
* providing a clock to that port in deep sleep mode.
*/
if (flags & GPIO_INT_DSLEEP) {
clock_enable_peripheral(CGC_OFFSET_GPIO,
gpio_port_to_clock_gate_mask(g->port),
CGC_MODE_ALL);
}
#endif
/*
* If this is a warm reboot, don't set the output levels or
* we'll shut off the main chipset.
*/
if (is_warm)
flags &= ~(GPIO_LOW | GPIO_HIGH);
/* Set up GPIO based on flags */
gpio_set_flags_by_mask(g->port, g->mask, flags);
/* Use as GPIO, not alternate function */
gpio_set_alternate_function(g->port, g->mask, -1);
}
#ifdef CONFIG_LOW_POWER_IDLE
/*
* Enable KB scan row to interrupt deep sleep by providing a clock
* signal to that port in deep sleep mode.
*/
clock_enable_peripheral(CGC_OFFSET_GPIO,
gpio_port_to_clock_gate_mask(KB_SCAN_ROW_GPIO),
CGC_MODE_ALL);
#endif
}
/* Run keyboard factory testing, scan out KSO/KSI if any shorted. */
int keyboard_factory_test_scan(void)
{
int i, j;
uint16_t shorted = 0;
uint32_t port, id, val;
/* Disable keyboard scan while testing */
keyboard_scan_enable(0, KB_SCAN_DISABLE_LID_CLOSED);
/* Set all of KSO/KSI pins to internal pull-up and input */
for (i = 0; i < keyboard_factory_scan_pins_used; i++) {
if (keyboard_factory_scan_pins[i][0] < 0)
continue;
port = keyboard_factory_scan_pins[i][0];
id = keyboard_factory_scan_pins[i][1];
gpio_set_alternate_function(port, 1 << id, -1);
gpio_set_flags_by_mask(port, 1 << id,
GPIO_INPUT | GPIO_PULL_UP);
}
/*
* Set start pin to output low, then check other pins
* going to low level, it indicate the two pins are shorted.
*/
for (i = 0; i < keyboard_factory_scan_pins_used; i++) {
if (keyboard_factory_scan_pins[i][0] < 0)
continue;
port = keyboard_factory_scan_pins[i][0];
id = keyboard_factory_scan_pins[i][1];
gpio_set_flags_by_mask(port, 1 << id, GPIO_OUT_LOW);
for (j = 0; j < i; j++) {
if (keyboard_factory_scan_pins[j][0] < 0)
continue;
/*
* Get gpio pin control register,
* bit 24 indicate GPIO input from the pad.
*/
val = MEC1322_GPIO_CTL(keyboard_factory_scan_pins[j][0],
keyboard_factory_scan_pins[j][1]);
if ((val & (1 << 24)) == 0) {
shorted = i << 8 | j;
goto done;
}
}
gpio_set_flags_by_mask(port, 1 << id,
GPIO_INPUT | GPIO_PULL_UP);
}
done:
gpio_config_module(MODULE_KEYBOARD_SCAN, 1);
keyboard_scan_enable(1, KB_SCAN_DISABLE_LID_CLOSED);
return shorted;
}