static int
PS2Mouse_Read(MWCOORD* dx_arg, MWCOORD* dy_arg, MWCOORD* dz_arg, int* bp_arg)
{
int result = 0;
MWCOORD dx = 0;
MWCOORD dy = 0;
int buttons = 0;
cyg_drv_isr_lock();
if (ps2mou_changed) {
dx = ps2mou_dx;
dy = 0 - ps2mou_dy; // microwindows directions are the opposite from the hardware
buttons = ps2mou_buttons;
ps2mou_dx = 0;
ps2mou_dy = 0;
ps2mou_changed = 0;
result = 1;
}
cyg_drv_isr_unlock();
if (result) {
if (NULL != dx_arg) {
*dx_arg = dx;
}
if (NULL != dy_arg) {
*dy_arg = dy;
}
if (NULL != dz_arg) {
*dz_arg = 0;
}
if (NULL != bp_arg) {
*bp_arg = buttons;
}
}
return result;
}
// ISR for DSPI without DMA
// Disable DSPI IRQ and schedule DSR.
static cyg_uint32 dspi_nodma_ISR(cyg_vector_t vector, cyg_addrword_t data)
{
cyg_spi_freescale_dspi_bus_t* dspi_bus_p =
(cyg_spi_freescale_dspi_bus_t*) data;
cyghwr_devs_freescale_dspi_t* dspi_p = dspi_bus_p->setup_p->dspi_p;
cyg_drv_isr_lock();
// Disable the DSPI IRQ.
DSPI_IRQ_DISABLE(dspi_p);
cyg_drv_interrupt_acknowledge(vector);
cyg_drv_isr_unlock();
return (CYG_ISR_CALL_DSR | CYG_ISR_HANDLED);
}
// ISR for DSPI with DMA
// Disable DSPI IRQ and Tx DMA channel and schedule DSR.
static cyg_uint32 dspi_dma_ISR(cyg_vector_t vector, cyg_addrword_t data)
{
cyg_spi_freescale_dspi_bus_t* dspi_bus_p =
(cyg_spi_freescale_dspi_bus_t*) data;
cyghwr_devs_freescale_dspi_t* dspi_p = dspi_bus_p->setup_p->dspi_p;
cyghwr_hal_freescale_dma_set_t *dma_set_p = dspi_bus_p->setup_p->dma_set_p;
cyghwr_hal_freescale_edma_t *edma_p;
edma_p = dma_set_p->edma_p;
cyg_drv_isr_lock();
// Disable the Tx DMA channel and DSPI IRQ.
hal_freescale_edma_erq_disable(edma_p, SPI_DMA_CHAN_I(dma_set_p, TX));
DSPI_IRQ_DISABLE(dspi_p);
cyg_drv_interrupt_acknowledge(vector);
cyg_drv_isr_unlock();
return (CYG_ISR_CALL_DSR | CYG_ISR_HANDLED);
}
static Cyg_ErrNo
serial_read(cyg_io_handle_t handle, void *_buf, cyg_uint32 *len)
{
cyg_devtab_entry_t *t = (cyg_devtab_entry_t *)handle;
serial_channel *chan = (serial_channel *)t->priv;
serial_funs *funs = chan->funs;
cyg_uint8 *buf = (cyg_uint8 *)_buf;
cyg_int32 size = 0;
cbuf_t *cbuf = &chan->in_cbuf;
Cyg_ErrNo res = ENOERR;
#ifdef XX_CYGDBG_DIAG_BUF
extern int enable_diag_uart;
int _enable = enable_diag_uart;
int _time, _stime;
externC cyg_tick_count_t cyg_current_time(void);
#endif // CYGDBG_DIAG_BUF
cyg_drv_mutex_lock(&cbuf->lock);
cbuf->abort = false;
if (cbuf->len == 0) {
// Non interrupt driven (i.e. polled) operation
while (size++ < *len) {
cyg_uint8 c = (funs->getc)(chan);
#ifdef CYGOPT_IO_SERIAL_FLOW_CONTROL_SOFTWARE
// for software flow control, if the driver returns one of the
// characters we act on it and then drop it (the app must not
// see it)
if ( chan->config.flags & CYGNUM_SERIAL_FLOW_XONXOFF_TX ) {
if ( c == CYGDAT_IO_SERIAL_FLOW_CONTROL_XOFF_CHAR ) {
throttle_tx( chan );
} else if ( c == CYGDAT_IO_SERIAL_FLOW_CONTROL_XON_CHAR ) {
restart_tx( chan );
}
else
*buf++ = c;
}
else
*buf++ = c;
#else
*buf++ = c;
#endif
}
} else {
cyg_drv_dsr_lock(); // Avoid races
while (size < *len) {
if (cbuf->nb > 0) {
#ifdef CYGPKG_IO_SERIAL_FLOW_CONTROL
if ( (cbuf->nb <= cbuf->low_water) &&
(chan->flow_desc.flags & CYG_SERIAL_FLOW_IN_THROTTLED) )
restart_rx( chan, false );
#endif
*buf++ = cbuf->data[cbuf->get];
if (++cbuf->get == cbuf->len) cbuf->get = 0;
cbuf->nb--;
size++;
} else {
#ifdef CYGOPT_IO_SERIAL_SUPPORT_NONBLOCKING
if (!cbuf->blocking) {
*len = size; // characters actually read
res = -EAGAIN;
break;
}
#endif // CYGOPT_IO_SERIAL_SUPPORT_NONBLOCKING
cbuf->waiting = true;
#ifdef XX_CYGDBG_DIAG_BUF
enable_diag_uart = 0;
HAL_CLOCK_READ(&_time);
_stime = (int)cyg_current_time();
diag_printf("READ wait - get: %d, put: %d, time: %x.%x\n", cbuf->get, cbuf->put, _stime, _time);
enable_diag_uart = _enable;
#endif // CYGDBG_DIAG_BUF
if( !cyg_drv_cond_wait(&cbuf->wait) )
cbuf->abort = true;
#ifdef XX_CYGDBG_DIAG_BUF
enable_diag_uart = 0;
HAL_CLOCK_READ(&_time);
_stime = (int)cyg_current_time();
diag_printf("READ continue - get: %d, put: %d, time: %x.%x\n", cbuf->get, cbuf->put, _stime, _time);
enable_diag_uart = _enable;
#endif // CYGDBG_DIAG_BUF
if (cbuf->abort) {
// Give up!
*len = size; // characters actually read
cbuf->abort = false;
cbuf->waiting = false;
res = -EINTR;
break;
}
}
}
cyg_drv_dsr_unlock();
}
#ifdef XX_CYGDBG_DIAG_BUF
cyg_drv_isr_lock();
enable_diag_uart = 0;
HAL_CLOCK_READ(&_time);
_stime = (int)cyg_current_time();
diag_printf("READ done - size: %d, len: %d, time: %x.%x\n", size, *len, _stime, _time);
enable_diag_uart = _enable;
cyg_drv_isr_unlock();
#endif // CYGDBG_DIAG_BUF
cyg_drv_mutex_unlock(&cbuf->lock);
return res;
}
static void
ps2kbd_process_scancodes(void)
{
static int e0_seen = 0;
static MWKEY pending_up = MWKEY_UNKNOWN;
static int pending_scancode = 0;
static int discard = 0;
int scancode;
int i;
CYG_PRECONDITION(MWKEY_UNKNOWN == ps2kbd_current_key, "There should be no pending key");
if (MWKEY_UNKNOWN != pending_up) {
ps2kbd_current_key = pending_up;
ps2kbd_current_scancode = pending_scancode;
ps2kbd_current_keydown = 0;
pending_up = MWKEY_UNKNOWN;
return;
}
while (MWKEY_UNKNOWN == ps2kbd_current_key) {
// The ISR will manipulate the scancode buffer directly, so
// interrupts have to be disabled temporarily.
scancode = -1;
cyg_drv_isr_lock();
if (ps2kbd_scancode_buffer_head != ps2kbd_scancode_buffer_tail) {
scancode = ps2kbd_scancode_buffer[ps2kbd_scancode_buffer_tail];
ps2kbd_scancode_buffer_tail = (ps2kbd_scancode_buffer_tail + 1) % PS2KBD_SCANCODE_BUFSIZE;
}
cyg_drv_isr_unlock();
if (scancode == -1) {
// No more data to be processed.
break;
}
// Are we in one of the special sequences, where bytes should be
// discarded?
if (discard > 0) {
discard -= 1;
continue;
}
// A real scancode has been extracted. Are we in an E0 sequence?
if (e0_seen) {
e0_seen = 0;
ps2kbd_current_keydown = (0 == (scancode & 0x0080));
scancode &= 0x007F;
if ((scancode >= PS2KBD_E0_MIN) && (scancode <= PS2KBD_E0_MAX)) {
ps2kbd_current_key = ps2kbd_e0_map[scancode - PS2KBD_E0_MIN];
ps2kbd_current_scancode = 0x80 + scancode - PS2KBD_E0_MIN; // Invent a key scancode
}
// We may or may not have a valid keycode at this time, so go
// around the loop again to check for MWKEY_UNKNOWN
continue;
}
// Is this the start of an E0 sequence?
if (0x00E0 == scancode) {
e0_seen = 1;
continue;
}
// How about E1?
if (0x00E1 == scancode) {
// For now there is only one key which generates E1 sequences
ps2kbd_current_key = MWKEY_BREAK;
ps2kbd_current_keydown = 1;
ps2kbd_current_scancode = 0x00E1; // Invent another key scancode
pending_up = MWKEY_BREAK;
pending_scancode = 0x00E1;
discard = 5;
return;
}
// Must be an ordinary key.
ps2kbd_current_keydown = (0 == (scancode & 0x0080));
scancode &= 0x007F;
ps2kbd_current_scancode = scancode;
ps2kbd_current_key = ps2kbd_keymap[scancode].normal;
// Detect the modifier keys.
for (i = 0; MWKEY_UNKNOWN != ps2kbd_modifier_map[i].key; i++) {
if (ps2kbd_current_key == ps2kbd_modifier_map[i].key) {
// capslock etc. behave differently. Toggle the current
// status on the keyup event, ignore key down (because
// of hardware autorepeat).
if (ps2kbd_modifier_map[i].toggle) {
if (!ps2kbd_current_keydown) {
ps2kbd_current_modifiers ^= ps2kbd_modifier_map[i].modifier;
}
} else if (ps2kbd_current_keydown) {
ps2kbd_current_modifiers |= ps2kbd_modifier_map[i].modifier;
} else {
ps2kbd_current_modifiers &= ~ps2kbd_modifier_map[i].modifier;
}
break;
}
}
// Cope with some of the modifiers.
if (0 != (ps2kbd_current_modifiers & (MWKMOD_LCTRL | MWKMOD_RCTRL))) {
// Control key. a-z and A-Z go to ctrl-A - ctrl-Z, i.e. 1 to 26
// Other characters in the range 64 to 96, e.g. [ and ], also
// get translated. This includes the A-Z range.
if ((64 <= ps2kbd_current_key) && (ps2kbd_current_key < 96)) {
ps2kbd_current_key -= 64;
} else if (('a' <= ps2kbd_current_key) && (ps2kbd_current_key <= 'z')) {
ps2kbd_current_key -= 96;
}
} else if (ps2kbd_current_modifiers & (MWKMOD_LSHIFT | MWKMOD_RSHIFT)) {
// Pick up the shift entry from the keymap
ps2kbd_current_key = ps2kbd_keymap[scancode].shifted;
}
if (ps2kbd_current_modifiers & MWKMOD_CAPS) {
// Capslock only affects a-z and A-z
if ( ('a' <= ps2kbd_current_key) && (ps2kbd_current_key <= 'z')) {
ps2kbd_current_key = (ps2kbd_current_key -'a') + 'A';
} else if (('A' <= ps2kbd_current_key) && (ps2kbd_current_key <= 'Z')) {
ps2kbd_current_key = (ps2kbd_current_key -'A') + 'a';
}
}
// If we have found a real key, the loop will exit.
// Otherwise try again.
}
}
