h8s_sci.c File Reference

---

Detailed Description

Simple driver for the H8S Serial Communication Interface.

Author:

Yoshinori Sato, Uwe Kindler

Date:

2003-12-06

The SCI is the same for all H8S variants so we place it into architecture hal.

Definition in file h8s_sci.c.

Go to the source code of this file.

Functions
void	hal_sci_init_channel (void *chan)
	Initializes one SCI channel.
cyg_bool	hal_sci_getc_nonblock (void *__ch_data, cyg_uint8 *ch)
	Checks if character is available for reception.
cyg_uint8	hal_sci_getc (void *__ch_data)
	Polls the device until reception of a character.
void	hal_sci_putc (void *__ch_data, cyg_uint8 c)
	Send a character to the sci device.
void	hal_sci_write (void *__ch_data, const cyg_uint8 *__buf, cyg_uint32 __len)
	Send content of buffer through serial channel.
void	hal_sci_read (void *__ch_data, cyg_uint8 *__buf, cyg_uint32 __len)
	Read a number of chars from serial channel.
cyg_bool	hal_sci_getc_timeout (void *__ch_data, cyg_uint8 *ch)
	Reads a character from serial channel with timeout.
int	hal_sci_control (void *__ch_data, __comm_control_cmd_t __func,...)
	IOCTL-like function for controlling serial device.
int	hal_sci_isr (void *__ch_data, int *__ctrlc, CYG_ADDRWORD __vector, CYG_ADDRWORD __data)
	Interrupt service routine for serial channel.

---

Function Documentation

int hal_sci_control (  void *  __ch_data, __comm_control_cmd_t  __func, ...  )

IOCTL-like function for controlling serial device. Its possible to enable, disable interrupts here, change the baudrate set the timeout value and query the interrup vector Parameters: __ch_data  Points to channel configuratin data. The following symbolic constants should be used __COMMCTL_IRQ_ENABLE __COMMCTL_IRQ_DISABLE __COMMCTL_DBG_ISR_VECTOR __COMMCTL_SET_TIMEOUT __COMMCTL_SETBAUD __COMMCTL_GETBAUD __func  I/O control code Returns: Control code dependent value Definition at line 356 of file h8s_sci.c. References channel_data_t::base, channel_data_t::isr_vector, and channel_data_t::msec_timeout. Referenced by hal_console_comm_init(). { channel_data_t *chan = (channel_data_t*)__ch_data; cyg_uint8 scr; int ret = 0; CYGARC_HAL_SAVE_GP(); // // decide what we have to do according to the control command // switch (__func) { // // Enable receive interrupts // case __COMMCTL_IRQ_ENABLE: HAL_READ_UINT8(chan->base+_REG_SCSCR, scr); scr |= CYGARC_REG_SCSCR_RIE; HAL_WRITE_UINT8(chan->base+_REG_SCSCR, scr); break; // // disable receive interrupts // case __COMMCTL_IRQ_DISABLE: HAL_READ_UINT8(chan->base+_REG_SCSCR, scr); scr &= ~CYGARC_REG_SCSCR_RIE; HAL_WRITE_UINT8(chan->base+_REG_SCSCR, scr); break; // // query isr vector of channel // case __COMMCTL_DBG_ISR_VECTOR: ret = chan->isr_vector; break; // // set new timeout and return the old one // case __COMMCTL_SET_TIMEOUT: { va_list ap; va_start(ap, __func); ret = chan->msec_timeout; chan->msec_timeout = va_arg(ap, cyg_uint32); va_end(ap); } break; // // set new baudrate for comm channel // case __COMMCTL_SETBAUD: { cyg_uint32 baud_rate; cyg_uint8 tmp; va_list ap; // // get baud rate from variable argument list // va_start(ap, __func); baud_rate = va_arg(ap, cyg_uint32); va_end(ap); // // disable sci interrupts while changing the hardware // HAL_READ_UINT8(chan->base + _REG_SCSCR, scr); tmp = scr; tmp = scr & ~(CYGARC_REG_SCSCR_TIE | CYGARC_REG_SCSCR_RIE | CYGARC_REG_SCSCR_MPIE | CYGARC_REG_SCSCR_TEIE); HAL_WRITE_UINT8(chan->base + _REG_SCSCR, tmp); // // Now set new baud rate - we have to set BRR and CKS in SCSMR // HAL_READ_UINT8(chan->base + _REG_SCSMR, tmp); tmp &= ~CYGARC_REG_SCSMR_CKSx_MASK; tmp |= CYGARC_SCBRR_CKSx(baud_rate); HAL_WRITE_UINT8(chan->base + _REG_SCSMR, tmp); HAL_WRITE_UINT8(chan->base + _REG_SCBRR, CYGARC_SCBRR_N(baud_rate)); // // now restore old scr register settings before disabling interrupts // HAL_WRITE_UINT8(chan->base + _REG_SCSCR, scr); } break; // End of case __COMMCTL_SETBAUD: // // Query baud rate // case __COMMCTL_GETBAUD: break; // // // default: ; // do nothing } // End of switch (__func) CYGARC_HAL_RESTORE_GP(); return ret; }

cyg_uint8 hal_sci_getc (  void *  __ch_data  )

Polls the device until reception of a character. Parameters: __ch_data  Pointer to channel configuration buffer Returns: Received character Definition at line 176 of file h8s_sci.c. References hal_sci_getc_nonblock(). Referenced by hal_console_comm_init(), hal_diag_read_char(), and hal_sci_read(). { cyg_uint8 ch; CYGARC_HAL_SAVE_GP(); while(!hal_sci_getc_nonblock(__ch_data, &ch)) { // do nothing } CYGARC_HAL_RESTORE_GP(); return ch; }

Here is the call graph for this function:

cyg_bool hal_sci_getc_nonblock (  void *  __ch_data, cyg_uint8 *  ch )  [static]

Checks if character is available for reception. This function tests the device and if a character is available, places it in *ch and returns TRUE. If no character is available, then the function returns FALSE immediately Parameters: __ch_data  Points to buffer with configuration data ch  Stores received character Return values: TRUE  if a character received sucessfully Definition at line 133 of file h8s_sci.c. Referenced by hal_sci_getc(), and hal_sci_getc_timeout(). { cyg_uint8 *base = ((channel_data_t*)__ch_data)->base; cyg_uint8 sr; HAL_READ_UINT8(base+ _REG_SCSSR, sr); // // check if we have an RX overrun // if (sr & CYGARC_REG_SCSSR_ORER) { // // Serial RX overrun. Clear error and let caller try again. // HAL_WRITE_UINT8(base + _REG_SCSSR, CYGARC_REG_SCSSR_CLEARMASK & ~CYGARC_REG_SCSSR_ORER); return false; } // // if no char arrived leave immediatelly with false // if ((sr & CYGARC_REG_SCSSR_RDRF) == 0) { return false; } // // read the received char and clear buffer full flag // HAL_READ_UINT8(base+_REG_SCRDR, *ch); HAL_WRITE_UINT8(base+_REG_SCSSR, sr & ~CYGARC_REG_SCSSR_RDRF); // Clear buffer full flag return true; }

cyg_bool hal_sci_getc_timeout (  void *  __ch_data, cyg_uint8 *  ch )

Reads a character from serial channel with timeout. Parameters: __ch_data  Pointer to channel configuration data ch  Stores received character Return values: TRUE  if character was received successfully Definition at line 308 of file h8s_sci.c. References hal_sci_getc_nonblock(), and channel_data_t::msec_timeout. Referenced by hal_console_comm_init(). { channel_data_t *chan = (channel_data_t*)__ch_data; int delay_count; cyg_bool res; CYGARC_HAL_SAVE_GP(); delay_count = chan->msec_timeout * 20; // delay in .1 ms steps // // Loop until we received a char or until time is over // while (1) { res = hal_sci_getc_nonblock(__ch_data, ch); if (res || (0 == delay_count--)) { break; } CYGACC_CALL_IF_DELAY_US(50); } CYGARC_HAL_RESTORE_GP(); return res; }

Here is the call graph for this function:

void hal_sci_init_channel (  void *  chan  )

Initializes one SCI channel. The parameter is actually a pointer to a channel_data_t and should be cast back to this type before use. This function should use the CDL definition for the baud rate for the channel it is initializing. Parameters: chan  Pointer to a channel_data_t type Definition at line 101 of file h8s_sci.c. Referenced by hal_console_comm_init(), and hal_diag_init(). { cyg_uint8 tmp; cyg_uint8 *base = ((channel_data_t *)chan)->base; // // Disable Tx/Rx interrupts, but enable Tx/Rx. Set 8-1-no parity an // Set speed to value stored in chan->baud_rate // HAL_WRITE_UINT8(base + _REG_SCSCR, CYGARC_REG_SCSCR_TE | CYGARC_REG_SCSCR_RE); HAL_WRITE_UINT8(base + _REG_SCSMR, 0); // 8-1-no parity. HAL_READ_UINT8(base + _REG_SCSMR, tmp); // now set baud rate tmp &= ~CYGARC_REG_SCSMR_CKSx_MASK; tmp |= CYGARC_SCBRR_CKSx(((channel_data_t *)chan)->baud_rate); HAL_WRITE_UINT8(base + _REG_SCSMR, tmp); HAL_WRITE_UINT8(base + _REG_SCBRR, CYGARC_SCBRR_N(((channel_data_t *)chan)->baud_rate)); }

int hal_sci_isr (  void *  __ch_data, int *  __ctrlc, CYG_ADDRWORD  __vector, CYG_ADDRWORD  __data )

Interrupt service routine for serial channel. This interrupt handler, called from the spurious interrupt vector, is specifically for dealing with Ctrl-C interrupts from GDB. When called this function does the following: Check for an incoming character. The code here is very similar to that in cyg_hal_plf_sci_getc_nonblock(). Read the character and call cyg_hal_is_break(). if result is true, set *__ctrlc to 1. Return CYG_ISR_HANDLED. Parameters: __ch_data  Points to channel configuration data __ctrlc  Stores CTRL C information __vector  Interrupt vector number of interrupt wich called this ISR __data  Interrupt data passed to ISR from kernel Return values: CYG_ISR_HANDLED  Definition at line 481 of file h8s_sci.c. References CYG_ISR_HANDLED. Referenced by hal_console_comm_init(). { cyg_uint8 c; cyg_uint8 sr; cyg_uint8 *base = ((channel_data_t*)__ch_data)->base; int res = 0; CYGARC_HAL_SAVE_GP(); *__ctrlc = 0; HAL_READ_UINT8(base + _REG_SCSSR, sr); if (sr & CYGARC_REG_SCSSR_ORER) { // // Serial RX overrun. Clear error and hope protocol recovers. // HAL_WRITE_UINT8(base+_REG_SCSSR, CYGARC_REG_SCSSR_CLEARMASK & ~CYGARC_REG_SCSSR_ORER); res = CYG_ISR_HANDLED; } else if (sr & CYGARC_REG_SCSSR_RDRF) { HAL_READ_UINT8(base+_REG_SCRDR, c); // Received character HAL_WRITE_UINT8(base+_REG_SCSSR, // Clear buffer full flag. CYGARC_REG_SCSSR_CLEARMASK & ~CYGARC_REG_SCSSR_RDRF); if(cyg_hal_is_break(&c, 1 )) { *__ctrlc = 1; } res = CYG_ISR_HANDLED; } CYGARC_HAL_RESTORE_GP(); return res; }

void hal_sci_putc (  void *  __ch_data, cyg_uint8  c )

Send a character to the sci device. This function polls for the device being ready to send and then writes the character. Since this is intended to be a diagnostic/debug channel, it is polled for end of transmission too. This ensures that as much data gets out of the system as possible Parameters: __ch_data  Points to buffer holding channel configuration data c  Character to be send Definition at line 203 of file h8s_sci.c. Referenced by hal_console_comm_init(), hal_diag_write_char(), and hal_sci_write(). { cyg_uint8 *base = ((channel_data_t*)__ch_data)->base; cyg_uint8 sr; CYGARC_HAL_SAVE_GP(); // // wait until send register is empty // do { HAL_READ_UINT8(base + _REG_SCSSR, sr); } while ((sr & CYGARC_REG_SCSSR_TDRE) == 0); // // Write char into send register and clear the empty flag // HAL_WRITE_UINT8(base + _REG_SCTDR, c); HAL_WRITE_UINT8(base + _REG_SCSSR, sr & ~CYGARC_REG_SCSSR_TDRE); // Clear empty flag. // // Hang around until the character has been safely sent. // do { HAL_READ_UINT8(base + _REG_SCSSR, sr); } while ((sr & CYGARC_REG_SCSSR_TDRE) == 0); CYGARC_HAL_RESTORE_GP(); }

void hal_sci_read (  void *  __ch_data, cyg_uint8 *  __buf, cyg_uint32  __len )

Read a number of chars from serial channel. Reads __len number of charaters from serail channel and stores them into the buffer __buf. Parameters: __ch_data  Pointer to channel configuration data __buf  Receive buffer __len  Number of chars to be received. Definition at line 280 of file h8s_sci.c. References hal_sci_getc(). Referenced by hal_console_comm_init(). { CYGARC_HAL_SAVE_GP(); // // Read a number of chars from SCI until __len ist counted down // to zero // while(__len-- > 0) { *__buf++ = hal_sci_getc(__ch_data); } CYGARC_HAL_RESTORE_GP(); }

Here is the call graph for this function:

void hal_sci_write (  void *  __ch_data, const cyg_uint8 *  __buf, cyg_uint32  __len )

Send content of buffer through serial channel. Sends __len characters to device taken from buffer __buf. Parameters: __ch_data  Pointer to a channel_data_t __buf  Buffer containing the data to be sent __len  Length of data to be send Definition at line 251 of file h8s_sci.c. References hal_sci_putc(). Referenced by hal_console_comm_init(). { CYGARC_HAL_SAVE_GP(); // // Send buffer until detection of terminating zero // while(__len-- > 0) { hal_sci_putc(__ch_data, *__buf++); } CYGARC_HAL_RESTORE_GP(); }

Here is the call graph for this function:

---