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. } }