void
apic_bcast_sipi (struct apic_dev * apic, uint8_t target)
{
uint8_t flags = irq_disable_save();
apic_write(apic, APIC_REG_ICR, APIC_IPI_OTHERS | ICR_DEL_MODE_STARTUP | target);
irq_enable_restore(flags);
}
/** \brief Erkennungsgeschwindigkeit setzen.
*
* \param wpm Erkennungsgeschwindigkeit in "Words per minute".
* Ein Wort is definiert als 5 Morsezeichen.
*/
static void set_words_per_minute(uint8_t wpm)
{
uint32_t dit_len;
uint8_t dit_ticks, sreg;
/* WpM Bereich eingrenzen. */
wpm = clamp(wpm, MIN_WPM, MAX_WPM);
/* Laenge eines "dit" Tones in Mikrosekunden berechnen. */
dit_len = (uint32_t)DIT_LENGTH_1WPM_MS * 1000;
dit_len /= wpm;
/* Laenge eines "dit" Tones in "Ticks" umrechnen.
* Rundungsfehler werden ignoriert. */
dit_ticks = dit_len / US_PER_TICK;
/* Wenn der WpM Wert vom aktuellen abweicht,
* Symbolzeiten neu setzen. */
sreg = irq_disable_save();
if (wpm != capture.wpm) {
capture.wpm = wpm;
set_timings(dit_ticks);
machine.async_lcd_update = 1;
}
irq_restore(sreg);
}
void
apic_self_ipi (struct apic_dev * apic, uint_t vector)
{
uint8_t flags = irq_disable_save();
apic_write(apic, APIC_IPI_SELF, vector);
irq_enable_restore(flags);
}
void
apic_bcast_deinit_iipi (struct apic_dev * apic)
{
uint8_t flags = irq_disable_save();
apic_write(apic, APIC_REG_ICR, APIC_IPI_OTHERS | ICR_TRIG_MODE_LEVEL | ICR_DEL_MODE_INIT);
irq_enable_restore(flags);
}
void
apic_send_sipi (struct apic_dev * apic, uint32_t remote_id, uint8_t target)
{
uint8_t flags = irq_disable_save();
apic_write(apic, APIC_REG_ICR2, remote_id << APIC_ICR2_DST_SHIFT);
apic_write(apic, APIC_REG_ICR, ICR_DEL_MODE_STARTUP | target);
irq_enable_restore(flags);
}
void
apic_deinit_iipi (struct apic_dev * apic, uint32_t remote_id)
{
uint8_t flags = irq_disable_save();
apic_write(apic, APIC_REG_ICR2, remote_id << APIC_ICR2_DST_SHIFT);
apic_write(apic, APIC_REG_ICR, ICR_TRIG_MODE_LEVEL| ICR_DEL_MODE_INIT);
irq_enable_restore(flags);
}
static void
apic_sw_disable (struct apic_dev * apic)
{
uint32_t val;
uint8_t flags = irq_disable_save();
val = apic_read(apic, APIC_REG_SPIV);
apic_write(apic, APIC_REG_SPIV, val & ~APIC_SPIV_SW_ENABLE);
irq_enable_restore(flags);
}
void twi_transfer_cancel(struct twi_transfer *xfer)
{
uint8_t sreg;
#ifdef TWI_SYNC
return;
#endif
sreg = irq_disable_save();
if (transfer_get_status(xfer) == TWI_STAT_INPROGRESS)
stop_transfer(xfer, TWI_STAT_CANCELLED);
irq_restore(sreg);
}
void twi_transfer(struct twi_transfer *xfer)
{
#ifdef TWI_SYNC
twi_size_t i;
uint8_t *buffer = xfer->buffer;
if (xfer->write_size) {
i2c_start(xfer->address << 1);
for (i = 0; i < xfer->write_size; i++)
i2c_write(buffer[i]);
if (!xfer->read_size)
i2c_stop();
}
if (xfer->read_size) {
i2c_start((xfer->address << 1) | 1);
for (i = 0; i < xfer->read_size; i++) {
if (i + 1 == xfer->read_size)
buffer[i] = i2c_readNak();
else
buffer[i] = i2c_readAck();
}
i2c_stop();
}
if (xfer->callback)
xfer->callback(xfer, TWI_STAT_FINISHED);
#else /* TWI_SYNC */
uint8_t sreg;
xfer->offset = 0;
xfer->next = NULL;
xfer->status = 0;
if (!xfer->write_size)
xfer->status |= TWI_XFER_READ;
transfer_set_status(xfer, TWI_STAT_INPROGRESS);
sreg = irq_disable_save();
if (twi.last_xfer)
twi.last_xfer->next = xfer;
twi.last_xfer = xfer;
if (!twi.first_xfer) {
twi.first_xfer = xfer;
send_start_condition();
}
irq_restore(sreg);
#endif
}
/** \brief Symbolerkennungscontext ruecksetzen. */
static void reset_capture_context(void)
{
uint8_t sreg;
sreg = irq_disable_save();
capture.in_mark = 0;
capture.cur_mark_nr = 0;
capture.cur_symbol = 0;
capture.nr_captured = 0;
capture.capture_error = 0;
capture.ticks = 0;
irq_restore(sreg);
}
enum twi_status twi_transfer_get_status(const struct twi_transfer *xfer)
{
enum twi_status status;
uint8_t sreg;
#ifdef TWI_SYNC
return TWI_STAT_FINISHED;
#endif
sreg = irq_disable_save();
status = transfer_get_status(xfer);
irq_restore(sreg);
return status;
}
/*
* nk_join
*
* join (wait) on the given thread
*
* t: the thread to wait on
* retval: where the waited-on thread should
* put its output
*
* returns -EINVAL on error, 0 on success
*
*/
int
nk_join (nk_thread_id_t t, void ** retval)
#ifndef NAUT_CONFIG_USE_RT_SCHEDULER
{
nk_thread_t *thethread = (nk_thread_t*)t;
uint8_t flags;
ASSERT(thethread->parent == get_cur_thread());
flags = irq_disable_save();
while (__sync_lock_test_and_set(&thethread->lock, 1));
if (thethread->status == NK_THR_EXITED) {
if (thethread->output) {
*retval = thethread->output;
}
goto out;
} else {
while (*(volatile int*)&thethread->status != NK_THR_EXITED) {
__sync_lock_release(&thethread->lock);
cli();
nk_wait(t);
sti();
while (__sync_lock_test_and_set(&thethread->lock, 1));
}
}
if (retval) {
*retval = thethread->output;
}
out:
__sync_lock_release(&thethread->lock);
thread_detach(thethread);
irq_enable_restore(flags);
return 0;
}
