int uart_read_char(void)
{
char ret;
ASSERT(in_interrupt_context());
queue_remove_unit(&cached_char, &ret);
--char_available;
return ret;
}
void my_isr(void)
{
int i = main_count;
udelay(3 * PERIOD_US(prng_no_seed()));
if (i != main_count || !in_interrupt_context())
has_error = 1;
interrupt_count++;
}
/*
* Interrupt handler.
*/
void cts_irq1(enum gpio_signal signal)
{
state[state_index++] = 'B';
got_interrupt = in_interrupt_context();
/* Wake up the CTS task */
if (wake_me_up)
task_wake(TASK_ID_CTS);
busy_loop();
state[state_index++] = 'C';
}
test_mockable void host_send_response(struct host_cmd_handler_args *args)
{
#ifdef CONFIG_HOST_COMMAND_STATUS
/*
*
* If we are in interrupt context, then we are handling a get_status
* response or an immediate error which prevented us from processing
* the command. Note we can't check for the GET_COMMS_STATUS command in
* args->command because the original command value has now been
* overwritten.
*
* When a EC_CMD_RESEND_RESPONSE arrives we will supply this response
* to that command.
*/
if (!in_interrupt_context()) {
if (command_pending) {
/*
* We previously got EC_RES_IN_PROGRESS. This must be
* the completion of that command, so stash the result
* code.
*/
CPRINTS("HC pending done, size=%d, result=%d",
args->response_size, args->result);
/*
* We don't support stashing response data, so mark the
* response as unavailable in that case.
*/
if (args->response_size != 0)
saved_result = EC_RES_UNAVAILABLE;
else
saved_result = args->result;
/*
* We can't send the response back to the host now
* since we already sent the in-progress response and
* the host is on to other things now.
*/
command_pending = 0;
return;
} else if (args->result == EC_RES_IN_PROGRESS) {
command_pending = 1;
CPRINTS("HC pending");
}
}
#endif
args->send_response(args);
}
static int interrupt_test(void)
{
timestamp_t deadline = get_time();
deadline.val += SECOND / 2;
while (!timestamp_expired(deadline, NULL))
++main_count;
ccprintf("Interrupt count: %d\n", interrupt_count);
ccprintf("Main thread tick: %d\n", main_count);
TEST_ASSERT(!has_error);
TEST_ASSERT(!in_interrupt_context());
return EC_SUCCESS;
}
static int i2c_write_raw_slave(int port, void *buf, int len)
{
stm32_dma_chan_t *chan;
int rv;
/* we don't want to race with TxE interrupt event */
disable_i2c_interrupt(port);
/* Configuring DMA1 channel DMAC_SLAVE_TX */
enable_ack(port);
chan = dma_get_channel(DMAC_SLAVE_TX);
dma_prepare_tx(dma_tx_option + port, len, buf);
/* Start the DMA */
dma_go(chan);
/* Configuring i2c to use DMA */
STM32_I2C_CR2(port) |= (1 << 11);
if (in_interrupt_context()) {
/* Poll for the transmission complete flag */
dma_wait(DMAC_SLAVE_TX);
dma_clear_isr(DMAC_SLAVE_TX);
} else {
/* Wait for the transmission complete Interrupt */
dma_enable_tc_interrupt(DMAC_SLAVE_TX);
rv = task_wait_event(DMA_TRANSFER_TIMEOUT_US);
dma_disable_tc_interrupt(DMAC_SLAVE_TX);
if (!(rv & TASK_EVENT_WAKE)) {
CPRINTS("Slave timeout, resetting i2c");
i2c_init_port(port);
}
}
dma_disable(DMAC_SLAVE_TX);
STM32_I2C_CR2(port) &= ~(1 << 11);
enable_i2c_interrupt(port);
return len;
}
static int usb_wait_console(void)
{
timestamp_t deadline = get_time();
int wait_time_us = 1;
if (!is_enabled || !tx_fifo_is_ready())
return EC_SUCCESS;
deadline.val += USB_CONSOLE_TIMEOUT_US;
/*
* If the USB console is not used, Tx buffer would never free up.
* In this case, let's drop characters immediately instead of sitting
* for some time just to time out. On the other hand, if the last
* Tx is good, it's likely the host is there to receive data, and
* we should wait so that we don't clobber the buffer.
*/
if (last_tx_ok) {
while (queue_space(&tx_q) < USB_MAX_PACKET_SIZE || !is_reset) {
if (timestamp_expired(deadline, NULL) ||
in_interrupt_context()) {
last_tx_ok = 0;
return EC_ERROR_TIMEOUT;
}
if (wait_time_us < MSEC)
udelay(wait_time_us);
else
usleep(wait_time_us);
wait_time_us *= 2;
}
return EC_SUCCESS;
}
last_tx_ok = queue_space(&tx_q);
return EC_SUCCESS;
}
static void __attribute__((noinline)) _task_dump_trace_dispatch(int sig)
{
int need_dispatch = 1;
task_id_t running = task_get_running();
if (!pthread_equal(pthread_self(), main_thread)) {
need_dispatch = 0;
} else if (!task_start_called()) {
fprintf(stderr, "Stack trace of main thread:\n");
need_dispatch = 0;
} else if (in_interrupt_context()) {
fprintf(stderr, "Stack trace of ISR:\n");
} else {
fprintf(stderr, "Stack trace of task %d (%s):\n",
running, task_get_name(running));
}
if (need_dispatch) {
pthread_kill(task_get_thread(running), SIGNAL_TRACE_DUMP);
} else {
_task_dump_trace_impl(SIGNAL_TRACE_OFFSET);
exit(1);
}
}
