URL
https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk
Subversion Repositories openrisc_2011-10-31
[/] [openrisc/] [tags/] [or1ksim/] [or1ksim-0.4.0rc2/] [peripheral/] [16450.c] - Rev 196
Go to most recent revision | Compare with Previous | Blame | View Log
/* 16450.c -- Simulation of 8250/16450 serial UART Copyright (C) 1999 Damjan Lampret, lampret@opencores.org Copyright (C) 2008 Embecosm Limited Contributor Jeremy Bennett <jeremy.bennett@embecosm.com> This file is part of Or1ksim, the OpenRISC 1000 Architectural Simulator. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see <http://www.gnu.org/licenses/>. */ /* This program is commented throughout in a fashion suitable for processing with Doxygen. */ /* This is functional simulation of 8250/16450/16550 UARTs. Since we RX/TX data via file streams, we can't simulate modem control lines coming from the DCE and similar details of communication with the DCE. This simulated UART device is intended for basic UART device driver verification. From device driver perspective this device looks like a regular UART but never reports any modem control lines changes (the only DCE responses are incoming characters from the file stream). */ /* Autoconf and/or portability configuration */ #include "config.h" #include "port.h" /* System includes */ #include <stdlib.h> /* Package includes */ #include "sim-config.h" #include "arch.h" #include "pic.h" #include "sched.h" #include "vapi.h" #include "channel.h" #include "abstract.h" #include "toplevel-support.h" #include "sim-cmd.h" #define MIN(a,b) ((a) < (b) ? (a) : (b)) /* Definitions */ #define UART_ADDR_SPACE 8 /*!< UART addr space size in bytes */ #define UART_MAX_FIFO_LEN 16 /*!< rx FIFO for uart 16550 */ #define MAX_SKEW 1 /*!< max. clock skew in subclocks */ #define UART_VAPI_BUF_LEN 128 /*!< Size of VAPI command buffer */ #define UART_CLOCK_DIVIDER 16 /*!< UART clock divider */ #define UART_FGETC_SLOWDOWN 100 /*!< fgetc() slowdown factor */ /* * Addresses of visible registers * */ #define UART_RXBUF 0 /* R: Rx buffer, DLAB=0 */ #define UART_TXBUF 0 /* W: Tx buffer, DLAB=0 */ #define UART_DLL 0 /* R/W: Divisor Latch Low, DLAB=1 */ #define UART_DLH 1 /* R/W: Divisor Latch High, DLAB=1 */ #define UART_IER 1 /* R/W: Interrupt Enable Register */ #define UART_IIR 2 /* R: Interrupt ID Register */ #define UART_FCR 2 /* W: FIFO Control Register */ #define UART_LCR 3 /* R/W: Line Control Register */ #define UART_MCR 4 /* W: Modem Control Register */ #define UART_LSR 5 /* R: Line Status Register */ #define UART_MSR 6 /* R: Modem Status Register */ #define UART_SCR 7 /* R/W: Scratch Register */ /* * R/W masks for valid bits in 8250/16450 (mask out 16550 and later bits) * */ #define UART_VALID_LCR 0xff #define UART_VALID_LSR 0xff #define UART_VALID_IIR 0x0f #define UART_VALID_FCR 0xc0 #define UART_VALID_IER 0x0f #define UART_VALID_MCR 0x1f #define UART_VALID_MSR 0xff /* * Bit definitions for the Line Control Register * */ #define UART_LCR_DLAB 0x80 /* Divisor latch access bit */ #define UART_LCR_SBC 0x40 /* Set break control */ #define UART_LCR_SPAR 0x20 /* Stick parity (?) */ #define UART_LCR_EPAR 0x10 /* Even parity select */ #define UART_LCR_PARITY 0x08 /* Parity Enable */ #define UART_LCR_STOP 0x04 /* Stop bits: 0=1 stop bit, 1= 2 stop bits */ #define UART_LCR_WLEN5 0x00 /* Wordlength: 5 bits */ #define UART_LCR_WLEN6 0x01 /* Wordlength: 6 bits */ #define UART_LCR_WLEN7 0x02 /* Wordlength: 7 bits */ #define UART_LCR_WLEN8 0x03 /* Wordlength: 8 bits */ #define UART_LCR_RESET 0x03 /* * Bit definitions for the Line Status Register */ #define UART_LSR_RXERR 0x80 /* Error in rx fifo */ #define UART_LSR_TXSERE 0x40 /* Transmitter serial register empty */ #define UART_LSR_TXBUFE 0x20 /* Transmitter buffer register empty */ #define UART_LSR_BREAK 0x10 /* Break interrupt indicator */ #define UART_LSR_FRAME 0x08 /* Frame error indicator */ #define UART_LSR_PARITY 0x04 /* Parity error indicator */ #define UART_LSR_OVRRUN 0x02 /* Overrun error indicator */ #define UART_LSR_RDRDY 0x01 /* Receiver data ready */ /* * Bit definitions for the Interrupt Identification Register */ #define UART_IIR_NO_INT 0x01 /* No interrupts pending */ #define UART_IIR_ID 0x06 /* Mask for the interrupt ID */ #define UART_IIR_MSI 0x00 /* Modem status interrupt (Low priority) */ #define UART_IIR_THRI 0x02 /* Transmitter holding register empty */ #define UART_IIR_RDI 0x04 /* Receiver data interrupt */ #define UART_IIR_RLSI 0x06 /* Receiver line status interrupt (High p.) */ #define UART_IIR_CTI 0x0c /* Character timeout */ /* * Bit Definitions for the FIFO Control Register */ #define UART_FCR_FIE 0x01 /* FIFO enable */ #define UART_FCR_RRXFI 0x02 /* Reset rx FIFO */ #define UART_FCR_RTXFI 0x04 /* Reset tx FIFO */ #define UART_FIFO_TRIGGER(x) /* Trigger values for indexes 0..3 */\ ((x) == 0 ? 1\ :(x) == 1 ? 4\ :(x) == 2 ? 8\ :(x) == 3 ? 14 : 0) /* * Bit definitions for the Interrupt Enable Register */ #define UART_IER_MSI 0x08 /* Enable Modem status interrupt */ #define UART_IER_RLSI 0x04 /* Enable receiver line status interrupt */ #define UART_IER_THRI 0x02 /* Enable Transmitter holding register int. */ #define UART_IER_RDI 0x01 /* Enable receiver data interrupt */ /* * Bit definitions for the Modem Control Register */ #define UART_MCR_LOOP 0x10 /* Enable loopback mode */ #define UART_MCR_AUX2 0x08 /* Auxilary 2 */ #define UART_MCR_AUX1 0x04 /* Auxilary 1 */ #define UART_MCR_RTS 0x02 /* Force RTS */ #define UART_MCR_DTR 0x01 /* Force DTR */ /* * Bit definitions for the Modem Status Register */ #define UART_MSR_DCD 0x80 /* Data Carrier Detect */ #define UART_MSR_RI 0x40 /* Ring Indicator */ #define UART_MSR_DSR 0x20 /* Data Set Ready */ #define UART_MSR_CTS 0x10 /* Clear to Send */ #define UART_MSR_DDCD 0x08 /* Delta DCD */ #define UART_MSR_TERI 0x04 /* Trailing edge ring indicator */ #define UART_MSR_DDSR 0x02 /* Delta DSR */ #define UART_MSR_DCTS 0x01 /* Delta CTS */ /* * Various definitions */ #define UART_BREAK_COUNT 1 /* # of chars to count when doing break */ #define UART_CHAR_TIMEOUT 4 /* # of chars to count when doing timeout int */ /* Registers */ struct dev_16450 { struct { uint8_t txbuf[UART_MAX_FIFO_LEN]; uint16_t rxbuf[UART_MAX_FIFO_LEN]; /* Upper 8-bits is the LCR modifier */ uint8_t dll; uint8_t dlh; uint8_t ier; uint8_t iir; uint8_t fcr; uint8_t lcr; uint8_t mcr; uint8_t lsr; uint8_t msr; uint8_t scr; } regs; /* Visible registers */ struct { uint8_t txser; /* Character just sending */ uint16_t rxser; /* Character just receiving */ uint8_t loopback; } iregs; /* Internal registers */ struct { int txbuf_head; int txbuf_tail; int rxbuf_head; int rxbuf_tail; unsigned int txbuf_full; unsigned int rxbuf_full; int receiveing; /* Receiving a char */ int recv_break; /* Receiving a break */ int ints; /* Which interrupts are pending */ } istat; /* Internal status */ /* Clocks per char */ unsigned long char_clks; /* VAPI internal registers */ struct { unsigned long char_clks; uint8_t dll; uint8_t dlh; uint8_t lcr; int skew; } vapi; /* Required by VAPI - circular buffer to store incoming chars, since we cannothandle them so fast - we are serial. */ unsigned long vapi_buf[UART_VAPI_BUF_LEN]; /* Buffer */ int vapi_buf_head_ptr; /* Where we write to */ int vapi_buf_tail_ptr; /* Where we read from */ /* Length of FIFO, 16 for 16550, 1 for 16450 */ int fifo_len; struct channel *channel; /* Configuration */ int enabled; int jitter; oraddr_t baseaddr; int irq; unsigned long vapi_id; int uart16550; char *channel_str; }; /* Forward declarations of static functions */ static void uart_recv_break (void *dat); static void uart_recv_char (void *dat); static void uart_check_char (void *dat); static void uart_sched_recv_check (struct dev_16450 *uart); static void uart_vapi_cmd (void *dat); static void uart_clear_int (struct dev_16450 *uart, int intr); static void uart_tx_send (void *dat); /* Number of clock cycles (one clock cycle is when UART_CLOCK_DIVIDER simulator * cycles have elapsed) before a single character is transmitted or received. */ static unsigned long char_clks (int dll, int dlh, int lcr) { unsigned int bauds_per_char = 2; unsigned long char_clks = ((dlh << 8) + dll); if (lcr & UART_LCR_PARITY) bauds_per_char += 2; /* stop bits 1 or two */ if (lcr & UART_LCR_STOP) bauds_per_char += 4; else if ((lcr & 0x3) != 0) bauds_per_char += 2; else bauds_per_char += 3; bauds_per_char += 10 + ((lcr & 0x3) << 1); return (char_clks * bauds_per_char) >> 1; } /*---------------------------------------------------[ Interrupt handling ]---*/ /* Signals the specified interrupt. If a higher priority interrupt is already * pending, do nothing */ static void uart_int_msi (void *dat) { struct dev_16450 *uart = dat; uart->istat.ints |= 1 << UART_IIR_MSI; if (!(uart->regs.ier & UART_IER_MSI)) return; if ((uart->regs.iir & UART_IIR_NO_INT) || (uart->regs.iir == UART_IIR_MSI)) { uart->regs.iir = UART_IIR_MSI; report_interrupt (uart->irq); } } static void uart_int_thri (void *dat) { struct dev_16450 *uart = dat; uart->istat.ints |= 1 << UART_IIR_THRI; if (!(uart->regs.ier & UART_IER_THRI)) return; if ((uart->regs.iir & UART_IIR_NO_INT) || (uart->regs.iir == UART_IIR_MSI) || (uart->regs.iir == UART_IIR_THRI)) { uart->regs.iir = UART_IIR_THRI; report_interrupt (uart->irq); } } static void uart_int_cti (void *dat) { struct dev_16450 *uart = dat; uart->istat.ints |= 1 << UART_IIR_CTI; if (!(uart->regs.ier & UART_IER_RDI)) return; if ((uart->regs.iir != UART_IIR_RLSI) && (uart->regs.iir != UART_IIR_RDI)) { uart->regs.iir = UART_IIR_CTI; report_interrupt (uart->irq); } } static void uart_int_rdi (void *dat) { struct dev_16450 *uart = dat; uart->istat.ints |= 1 << UART_IIR_RDI; if (!(uart->regs.ier & UART_IER_RDI)) return; if (uart->regs.iir != UART_IIR_RLSI) { uart->regs.iir = UART_IIR_RDI; report_interrupt (uart->irq); } } static void uart_int_rlsi (void *dat) { struct dev_16450 *uart = dat; uart->istat.ints |= 1 << UART_IIR_RLSI; if (!(uart->regs.ier & UART_IER_RLSI)) return; /* Highest priority interrupt */ uart->regs.iir = UART_IIR_RLSI; report_interrupt (uart->irq); } /* Checks to see if an RLSI interrupt is due and schedules one if need be */ static void uart_check_rlsi (void *dat) { struct dev_16450 *uart = dat; if (uart->regs.lsr & (UART_LSR_OVRRUN | UART_LSR_PARITY | UART_LSR_FRAME | UART_LSR_BREAK)) uart_int_rlsi (uart); } /* Checks to see if an RDI interrupt is due and schedules one if need be */ static void uart_check_rdi (void *dat) { struct dev_16450 *uart = dat; if (uart->istat.rxbuf_full >= UART_FIFO_TRIGGER (uart->regs.fcr >> 6)) { uart_int_rdi (uart); } } /* Raises the next highest priority interrupt */ static void uart_next_int (struct dev_16450 *uart) { /* Interrupt detection in proper priority order. */ if ((uart->istat.ints & (1 << UART_IIR_RLSI)) && (uart->regs.ier & UART_IER_RLSI)) uart_int_rlsi (uart); else if ((uart->istat.ints & (1 << UART_IIR_RDI)) && (uart->regs.ier & UART_IER_RDI)) uart_int_rdi (uart); else if ((uart->istat.ints & (1 << UART_IIR_CTI)) && (uart->regs.ier & UART_IER_RDI)) uart_int_cti (uart); else if ((uart->istat.ints & (1 << UART_IIR_THRI)) && (uart->regs.ier & UART_IER_THRI)) uart_int_thri (uart); else if ((uart->istat.ints & (1 << UART_IIR_MSI)) && (uart->regs.ier & UART_IER_MSI)) uart_int_msi (uart); else { clear_interrupt (uart->irq); uart->regs.iir = UART_IIR_NO_INT; } } /* Clears potentially pending interrupts */ static void uart_clear_int (struct dev_16450 *uart, int intr) { uart->istat.ints &= ~(1 << intr); /* Some stuff schedule uart_int_cti, therefore remove it here */ if (intr == UART_IIR_CTI) SCHED_FIND_REMOVE (uart_int_cti, uart); if (intr != uart->regs.iir) return; uart_next_int (uart); } /*----------------------------------------------------[ Loopback handling ]---*/ static void uart_loopback (struct dev_16450 *uart) { if (!(uart->regs.mcr & UART_MCR_LOOP)) return; if ((uart->regs.mcr & UART_MCR_AUX2) != ((uart->regs.msr & UART_MSR_DCD) >> 4)) uart->regs.msr |= UART_MSR_DDCD; if ((uart->regs.mcr & UART_MCR_AUX1) < ((uart->regs.msr & UART_MSR_RI) >> 4)) uart->regs.msr |= UART_MSR_TERI; if ((uart->regs.mcr & UART_MCR_RTS) != ((uart->regs.msr & UART_MSR_CTS) >> 3)) uart->regs.msr |= UART_MSR_DCTS; if ((uart->regs.mcr & UART_MCR_DTR) != ((uart->regs.msr & UART_MSR_DSR) >> 5)) uart->regs.msr |= UART_MSR_DDSR; uart->regs.msr &= ~(UART_MSR_DCD | UART_MSR_RI | UART_MSR_DSR | UART_MSR_CTS); uart->regs.msr |= ((uart->regs.mcr & UART_MCR_AUX2) << 4); uart->regs.msr |= ((uart->regs.mcr & UART_MCR_AUX1) << 4); uart->regs.msr |= ((uart->regs.mcr & UART_MCR_RTS) << 3); uart->regs.msr |= ((uart->regs.mcr & UART_MCR_DTR) << 5); if (uart->regs.msr & (UART_MSR_DCTS | UART_MSR_DDSR | UART_MSR_TERI | UART_MSR_DDCD)) uart_int_msi (uart); } /*----------------------------------------------------[ Transmitter logic ]---*/ /* Sends the data in the shift register to the outside world */ static void send_char (struct dev_16450 *uart, int bits_send) { PRINTF ("%c", (char) uart->iregs.txser); if (uart->regs.mcr & UART_MCR_LOOP) uart->iregs.loopback = uart->iregs.txser; else { /* Send to either VAPI or to file */ if (uart->vapi_id) { int par, pe, fe, nbits; int j, data; unsigned long packet = 0; nbits = MIN (bits_send, (uart->regs.lcr & UART_LCR_WLEN8) + 5); /* Encode a packet */ packet = uart->iregs.txser & ((1 << nbits) - 1); /* Calculate parity */ for (j = 0, par = 0; j < nbits; j++) par ^= (packet >> j) & 1; if (uart->regs.lcr & UART_LCR_PARITY) { if (uart->regs.lcr & UART_LCR_SPAR) { packet |= 1 << nbits; } else { if (uart->regs.lcr & UART_LCR_EPAR) packet |= par << nbits; else packet |= (par ^ 1) << nbits; } nbits++; } packet |= 1 << (nbits++); if (uart->regs.lcr & UART_LCR_STOP) packet |= 1 << (nbits++); /* Decode a packet */ nbits = (uart->vapi.lcr & UART_LCR_WLEN8) + 5; data = packet & ((1 << nbits) - 1); /* Calculate parity, including parity bit */ for (j = 0, par = 0; j < nbits + 1; j++) par ^= (packet >> j) & 1; if (uart->vapi.lcr & UART_LCR_PARITY) { if (uart->vapi.lcr & UART_LCR_SPAR) { pe = !((packet >> nbits) & 1); } else { if (uart->vapi.lcr & UART_LCR_EPAR) pe = par != 0; else pe = par != 1; } nbits++; } else pe = 0; fe = ((packet >> (nbits++)) & 1) ^ 1; if (uart->vapi.lcr & UART_LCR_STOP) fe |= ((packet >> (nbits++)) & 1) ^ 1; data |= (uart->vapi.lcr << 8) | (pe << 16) | (fe << 17) | (uart->vapi. lcr << 8); vapi_send (uart->vapi_id, data); } else { char buffer[1] = { uart->iregs.txser & 0xFF }; channel_write (uart->channel, buffer, 1); } } } /* Called when all the bits have been shifted out of the shift register */ void uart_char_clock (void *dat) { struct dev_16450 *uart = dat; /* We've sent all bits */ send_char (uart, (uart->regs.lcr & UART_LCR_WLEN8) + 5); if (!uart->istat.txbuf_full) uart->regs.lsr |= UART_LSR_TXSERE; else uart_tx_send (uart); } /* Called when a break has been shifted out of the shift register */ void uart_send_break (void *dat) { struct dev_16450 *uart = dat; /* Send one break signal */ vapi_send (uart->vapi_id, UART_LCR_SBC << 8); /* Send the next char (if there is one) */ if (!uart->istat.txbuf_full) uart->regs.lsr |= UART_LSR_TXSERE; else uart_tx_send (uart); } /* Scheduled whenever the TX buffer has characters in it and we aren't sending * a character. */ void uart_tx_send (void *dat) { struct dev_16450 *uart = dat; uart->iregs.txser = uart->regs.txbuf[uart->istat.txbuf_tail]; uart->istat.txbuf_tail = (uart->istat.txbuf_tail + 1) % uart->fifo_len; uart->istat.txbuf_full--; uart->regs.lsr &= ~UART_LSR_TXSERE; /* Schedules a char_clock to run in the correct amount of time */ if (!(uart->regs.lcr & UART_LCR_SBC)) { SCHED_ADD (uart_char_clock, uart, uart->char_clks * UART_CLOCK_DIVIDER); } else { SCHED_ADD (uart_send_break, uart, 0); } /* When UART is in either character mode, i.e. 16450 emulation mode, or FIFO * mode, the THRE interrupt is raised when THR transitions from full to empty. */ if (!uart->istat.txbuf_full) { uart->regs.lsr |= UART_LSR_TXBUFE; uart_int_thri (uart); } } /*-------------------------------------------------------[ Receiver logic ]---*/ /* Adds a character to the RX FIFO */ static void uart_add_char (struct dev_16450 *uart, int ch) { uart->regs.lsr |= UART_LSR_RDRDY; uart_clear_int (uart, UART_IIR_CTI); SCHED_ADD (uart_int_cti, uart, uart->char_clks * UART_CHAR_TIMEOUT * UART_CLOCK_DIVIDER); if (uart->istat.rxbuf_full + 1 > uart->fifo_len) { uart->regs.lsr |= UART_LSR_OVRRUN | UART_LSR_RXERR; uart_int_rlsi (uart); } else { uart->regs.rxbuf[uart->istat.rxbuf_head] = ch; uart->istat.rxbuf_head = (uart->istat.rxbuf_head + 1) % uart->fifo_len; if (!uart->istat.rxbuf_full++) { uart->regs.lsr |= ch >> 8; uart_check_rlsi (uart); } } uart_check_rdi (uart); } /* Called when a break sequence is about to start. It stops receiveing * characters and schedules the uart_recv_break to send the break */ static void uart_recv_break_start (void *dat) { struct dev_16450 *uart = dat; uart->istat.receiveing = 0; uart->istat.recv_break = 1; SCHED_FIND_REMOVE (uart_recv_char, uart); if (uart->vapi_id && (uart->vapi_buf_head_ptr != uart->vapi_buf_tail_ptr)) uart_vapi_cmd (uart); SCHED_ADD (uart_recv_break, uart, UART_BREAK_COUNT * uart->vapi.char_clks * UART_CLOCK_DIVIDER); } /* Stops sending breaks and starts receiveing characters */ static void uart_recv_break_stop (void *dat) { struct dev_16450 *uart = dat; uart->istat.recv_break = 0; SCHED_FIND_REMOVE (uart_recv_break, dat); } /* Receives a break */ static void uart_recv_break (void *dat) { struct dev_16450 *uart = dat; unsigned lsr = UART_LSR_BREAK | UART_LSR_RXERR | UART_LSR_RDRDY; uart_add_char (uart, lsr << 8); } /* Moves a character from the serial register to the RX FIFO */ static void uart_recv_char (void *dat) { struct dev_16450 *uart = dat; uint16_t char_to_add; /* Set unused character bits to zero and allow lsr register in fifo */ char_to_add = uart->iregs.rxser & (((1 << ((uart->regs.lcr & 3) + 5)) - 1) | 0xff00); PRINTF ("%c", (char) char_to_add); if (uart->regs.mcr & UART_MCR_LOOP) { uart->iregs.rxser = uart->iregs.loopback; uart->istat.receiveing = 1; SCHED_ADD (uart_recv_char, uart, uart->char_clks * UART_CLOCK_DIVIDER); } else { uart->istat.receiveing = 0; uart_sched_recv_check (uart); if (uart->vapi_id && (uart->vapi_buf_head_ptr != uart->vapi_buf_tail_ptr)) SCHED_ADD (uart_vapi_cmd, uart, 0); } uart_add_char (uart, char_to_add); } /* Checks if there is a character waiting to be received */ static void uart_check_char (void *dat) { struct dev_16450 *uart = dat; uint8_t buffer; int retval; /* Check if there is something waiting, and put it into rxser */ retval = channel_read (uart->channel, (char *) &buffer, 1); if (retval > 0) { uart->iregs.rxser = buffer; uart->istat.receiveing = 1; SCHED_ADD (uart_recv_char, uart, uart->char_clks * UART_CLOCK_DIVIDER); return; } if (!retval) { SCHED_ADD (uart_check_char, uart, UART_FGETC_SLOWDOWN * UART_CLOCK_DIVIDER); return; } if (retval < 0) perror (uart->channel_str); } static void uart_sched_recv_check (struct dev_16450 *uart) { if (!uart->vapi_id) SCHED_ADD (uart_check_char, uart, UART_FGETC_SLOWDOWN * UART_CLOCK_DIVIDER); } /*----------------------------------------------------[ UART I/O handling ]---*/ /* Set a specific UART register with value. */ static void uart_write_byte (oraddr_t addr, uint8_t value, void *dat) { struct dev_16450 *uart = dat; if (uart->regs.lcr & UART_LCR_DLAB) { switch (addr) { case UART_DLL: uart->regs.dll = value; uart->char_clks = char_clks (uart->regs.dll, uart->regs.dlh, uart->regs.lcr); return; case UART_DLH: uart->regs.dlh = value; return; } } switch (addr) { case UART_TXBUF: uart->regs.lsr &= ~UART_LSR_TXBUFE; if (uart->istat.txbuf_full < uart->fifo_len) { uart->regs.txbuf[uart->istat.txbuf_head] = value; uart->istat.txbuf_head = (uart->istat.txbuf_head + 1) % uart->fifo_len; if (!uart->istat.txbuf_full++ && (uart->regs.lsr & UART_LSR_TXSERE)) SCHED_ADD (uart_tx_send, uart, 0); } else uart->regs.txbuf[uart->istat.txbuf_head] = value; uart_clear_int (uart, UART_IIR_THRI); break; case UART_FCR: uart->regs.fcr = value & UART_VALID_FCR; if ((uart->fifo_len == 1 && (value & UART_FCR_FIE)) || (uart->fifo_len != 1 && !(value & UART_FCR_FIE))) value |= UART_FCR_RRXFI | UART_FCR_RTXFI; uart->fifo_len = (value & UART_FCR_FIE) ? 16 : 1; if (value & UART_FCR_RTXFI) { uart->istat.txbuf_head = uart->istat.txbuf_tail = 0; uart->istat.txbuf_full = 0; uart->regs.lsr |= UART_LSR_TXBUFE; /* For FIFO-mode only, THRE interrupt is set when THR and FIFO are empty */ if (uart->fifo_len == 16) uart_int_thri (uart); SCHED_FIND_REMOVE (uart_tx_send, uart); } if (value & UART_FCR_RRXFI) { uart->istat.rxbuf_head = uart->istat.rxbuf_tail = 0; uart->istat.rxbuf_full = 0; uart->regs.lsr &= ~UART_LSR_RDRDY; uart_clear_int (uart, UART_IIR_RDI); uart_clear_int (uart, UART_IIR_CTI); } break; case UART_IER: uart->regs.ier = value & UART_VALID_IER; uart_next_int (uart); break; case UART_LCR: if ((uart->regs.lcr & UART_LCR_SBC) != (value & UART_LCR_SBC)) { if ((value & UART_LCR_SBC) && !(uart->regs.lsr & UART_LSR_TXSERE)) { /* Schedule a job to send the break char */ SCHED_FIND_REMOVE (uart_char_clock, uart); SCHED_ADD (uart_send_break, uart, 0); } if (!(value & UART_LCR_SBC) && !(uart->regs.lsr & UART_LSR_TXSERE)) { /* Schedule a job to start sending characters */ SCHED_ADD (uart_tx_send, uart, 0); /* Remove the uart_send_break job just in case it has not run yet */ SCHED_FIND_REMOVE (uart_char_clock, uart); } } uart->regs.lcr = value & UART_VALID_LCR; uart->char_clks = char_clks (uart->regs.dll, uart->regs.dlh, uart->regs.lcr); break; case UART_MCR: uart->regs.mcr = value & UART_VALID_MCR; uart_loopback (uart); break; case UART_SCR: uart->regs.scr = value; break; } } /* Read a specific UART register. */ static uint8_t uart_read_byte (oraddr_t addr, void *dat) { struct dev_16450 *uart = dat; uint8_t value = 0; if (uart->regs.lcr & UART_LCR_DLAB) { switch (addr) { case UART_DLL: value = uart->regs.dll; return value; case UART_DLH: value = uart->regs.dlh; return value; } } switch (addr) { case UART_RXBUF: if (uart->istat.rxbuf_full) { value = uart->regs.rxbuf[uart->istat.rxbuf_tail]; uart->istat.rxbuf_tail = (uart->istat.rxbuf_tail + 1) % uart->fifo_len; uart->istat.rxbuf_full--; } uart_clear_int (uart, UART_IIR_RDI); uart_clear_int (uart, UART_IIR_CTI); if (uart->istat.rxbuf_full) { uart->regs.lsr |= UART_LSR_RDRDY | uart->regs.rxbuf[uart->istat.rxbuf_tail] >> 8; SCHED_ADD (uart_int_cti, uart, uart->char_clks * UART_CHAR_TIMEOUT * UART_CLOCK_DIVIDER); uart_check_rlsi (uart); uart_check_rdi (uart); } else { uart->regs.lsr &= ~UART_LSR_RDRDY; } break; case UART_IER: value = uart->regs.ier & UART_VALID_IER; break; case UART_IIR: value = (uart->regs.iir & UART_VALID_IIR) | 0xc0; /* Only clear the thri interrupt if it is the one we are repporting */ if (uart->regs.iir == UART_IIR_THRI) uart_clear_int (uart, UART_IIR_THRI); break; case UART_LCR: value = uart->regs.lcr & UART_VALID_LCR; break; case UART_MCR: value = 0; break; case UART_LSR: value = uart->regs.lsr & UART_VALID_LSR; uart->regs.lsr &= ~(UART_LSR_OVRRUN | UART_LSR_BREAK | UART_LSR_PARITY | UART_LSR_FRAME | UART_LSR_RXERR); /* Clear potentially pending RLSI interrupt */ uart_clear_int (uart, UART_IIR_RLSI); break; case UART_MSR: value = uart->regs.msr & UART_VALID_MSR; uart->regs.msr = 0; uart_clear_int (uart, UART_IIR_MSI); uart_loopback (uart); break; case UART_SCR: value = uart->regs.scr; break; } return value; } /*--------------------------------------------------------[ VAPI handling ]---*/ /* Decodes the read vapi command */ static void uart_vapi_cmd (void *dat) { struct dev_16450 *uart = dat; int received = 0; while (!received) { if (uart->vapi_buf_head_ptr != uart->vapi_buf_tail_ptr) { unsigned long data = uart->vapi_buf[uart->vapi_buf_tail_ptr]; uart->vapi_buf_tail_ptr = (uart->vapi_buf_tail_ptr + 1) % UART_VAPI_BUF_LEN; switch (data >> 24) { case 0x00: uart->vapi.lcr = (data >> 8) & 0xff; /* Put data into rx fifo */ uart->iregs.rxser = data & 0xff; uart->vapi.char_clks = char_clks (uart->vapi.dll, uart->vapi.dlh, uart->vapi.lcr); if ((uart->vapi.lcr & ~UART_LCR_SBC) != (uart->regs.lcr & ~UART_LCR_SBC) || uart->vapi.char_clks != uart->char_clks || uart->vapi.skew < -MAX_SKEW || uart->vapi.skew > MAX_SKEW) { if ((uart->vapi.lcr & ~UART_LCR_SBC) != (uart->regs.lcr & ~UART_LCR_SBC)) fprintf (stderr, "Warning: Unmatched VAPI (%02" PRIx8 ") and uart (%02" PRIx8 ") modes.\n", uart->vapi.lcr & ~UART_LCR_SBC, uart->regs.lcr & ~UART_LCR_SBC); if (uart->vapi.char_clks != uart->char_clks) { fprintf (stderr, "Warning: Unmatched VAPI (%li) and " "UART (%li) char clocks.\n", uart->vapi.char_clks, uart->char_clks); fprintf (stderr, "VAPI: lcr: %02" PRIx8 ", dll: %02" PRIx8 ", dlh: %02" PRIx8 "\n", uart->vapi.lcr, uart->vapi.dll, uart->vapi.dlh); fprintf (stderr, "UART: lcr: %02" PRIx8 ", dll: %02" PRIx8 ", dlh: %02" PRIx8 "\n", uart->regs.lcr, uart->regs.dll, uart->vapi.dlh); } if (uart->vapi.skew < -MAX_SKEW || uart->vapi.skew > MAX_SKEW) { fprintf(stderr, "VAPI skew is beyond max: %i\n", uart->vapi.skew); } /* Set error bits */ uart->iregs.rxser |= (UART_LSR_FRAME | UART_LSR_RXERR) << 8; if (uart->regs.lcr & UART_LCR_PARITY) uart->iregs.rxser |= UART_LSR_PARITY << 8; } if (!uart->istat.recv_break) { uart->istat.receiveing = 1; SCHED_ADD (uart_recv_char, uart, uart->char_clks * UART_CLOCK_DIVIDER); } received = 1; break; case 0x01: uart->vapi.dll = (data >> 0) & 0xff; uart->vapi.dlh = (data >> 8) & 0xff; break; case 0x02: uart->vapi.lcr = (data >> 8) & 0xff; break; case 0x03: uart->vapi.skew = (signed short) (data & 0xffff); break; case 0x04: if ((data >> 16) & 1) { /* If data & 0xffff is 0 then set the break imediatly and handle the * following commands as appropriate */ if (!(data & 0xffff)) uart_recv_break_start (uart); else /* Schedule a job to start sending breaks */ SCHED_ADD (uart_recv_break_start, uart, (data & 0xffff) * UART_CLOCK_DIVIDER); } else { /* If data & 0xffff is 0 then release the break imediatly and handle * the following commands as appropriate */ if (!(data & 0xffff)) uart_recv_break_stop (uart); else /* Schedule a job to stop sending breaks */ SCHED_ADD (uart_recv_break_stop, uart, (data & 0xffff) * UART_CLOCK_DIVIDER); } break; default: fprintf (stderr, "WARNING: Invalid vapi command %02lx\n", data >> 24); break; } } else break; } } /* Function that handles incoming VAPI data. */ static void uart_vapi_read (unsigned long id, unsigned long data, void *dat) { struct dev_16450 *uart = dat; uart->vapi_buf[uart->vapi_buf_head_ptr] = data; uart->vapi_buf_head_ptr = (uart->vapi_buf_head_ptr + 1) % UART_VAPI_BUF_LEN; if (uart->vapi_buf_tail_ptr == uart->vapi_buf_head_ptr) { fprintf (stderr, "FATAL: uart VAPI buffer to small.\n"); exit (1); } if (!uart->istat.receiveing) uart_vapi_cmd (uart); } /*--------------------------------------------------------[ Sim callbacks ]---*/ /* Reset. It initializes all registers of all UART devices to zero values, * (re)opens all RX/TX file streams and places devices in memory address * space. */ void uart_reset (void *dat) { struct dev_16450 *uart = dat; if (uart->vapi_id) { vapi_install_handler (uart->vapi_id, uart_vapi_read, dat); } else if (uart->channel_str && uart->channel_str[0]) { /* Try to create stream. */ if (uart->channel) channel_close (uart->channel); else uart->channel = channel_init (uart->channel_str); if (channel_open (uart->channel) < 0) { fprintf (stderr, "Warning: problem with channel \"%s\" detected.\n", uart->channel_str); } else if (config.sim.verbose) PRINTF ("UART at 0x%" PRIxADDR "\n", uart->baseaddr); } else { fprintf (stderr, "Warning: UART at %" PRIxADDR " has no vapi nor channel specified\n", uart->baseaddr); } if (uart->uart16550) uart->fifo_len = 16; else uart->fifo_len = 1; uart->istat.rxbuf_head = uart->istat.rxbuf_tail = 0; uart->istat.txbuf_head = uart->istat.txbuf_tail = 0; uart->istat.txbuf_full = uart->istat.rxbuf_full = 0; uart->char_clks = 0; uart->iregs.txser = 0; uart->iregs.rxser = 0; uart->iregs.loopback = 0; uart->istat.receiveing = 0; uart->istat.recv_break = 0; uart->istat.ints = 0; memset (uart->regs.txbuf, 0, sizeof (uart->regs.txbuf)); memset (uart->regs.rxbuf, 0, sizeof (uart->regs.rxbuf)); uart->regs.dll = 0; uart->regs.dlh = 0; uart->regs.ier = 0; uart->regs.iir = UART_IIR_NO_INT; uart->regs.fcr = 0; uart->regs.lcr = UART_LCR_RESET; uart->regs.mcr = 0; uart->regs.lsr = UART_LSR_TXBUFE | UART_LSR_TXSERE; uart->regs.msr = 0; uart->regs.scr = 0; uart->vapi.skew = 0; uart->vapi.lcr = 0; uart->vapi.dll = 0; uart->vapi.char_clks = 0; uart->vapi_buf_head_ptr = 0; uart->vapi_buf_tail_ptr = 0; memset (uart->vapi_buf, 0, sizeof (uart->vapi_buf)); uart_sched_recv_check (uart); } /* Print register values on stdout. */ void uart_status (void *dat) { struct dev_16450 *uart = dat; int i; PRINTF ("\nUART visible registers at 0x%" PRIxADDR ":\n", uart->baseaddr); PRINTF ("RXBUF: "); for (i = uart->istat.rxbuf_head; i != uart->istat.rxbuf_tail; i = (i + 1) % uart->fifo_len) PRINTF (" %.2x", uart->regs.rxbuf[i]); PRINTF ("TXBUF: "); for (i = uart->istat.txbuf_head; i != uart->istat.txbuf_tail; i = (i + 1) % uart->fifo_len) PRINTF (" %.2x", uart->regs.txbuf[i]); PRINTF ("\n"); PRINTF ("DLL : %.2x DLH : %.2x\n", uart->regs.dll, uart->regs.dlh); PRINTF ("IER : %.2x IIR : %.2x\n", uart->regs.ier, uart->regs.iir); PRINTF ("LCR : %.2x MCR : %.2x\n", uart->regs.lcr, uart->regs.mcr); PRINTF ("LSR : %.2x MSR : %.2x\n", uart->regs.lsr, uart->regs.msr); PRINTF ("SCR : %.2x\n", uart->regs.scr); PRINTF ("\nInternal registers (sim debug):\n"); PRINTF ("RXSER: %.2" PRIx16 " TXSER: %.2" PRIx8 "\n", uart->iregs.rxser, uart->iregs.txser); PRINTF ("\nInternal status (sim debug):\n"); PRINTF ("char_clks: %ld\n", uart->char_clks); PRINTF ("rxbuf_full: %d txbuf_full: %d\n", uart->istat.rxbuf_full, uart->istat.txbuf_full); PRINTF ("Using IRQ%i\n", uart->irq); if (uart->vapi_id) PRINTF ("Connected to vapi ID=%lx\n\n", uart->vapi_id); /* TODO: replace by a channel_status else PRINTF("RX fs: %p TX fs: %p\n\n", uart->rxfs, uart->txfs); */ } /*---------------------------------------------------[ UART configuration ]---*/ static void uart_baseaddr (union param_val val, void *dat) { struct dev_16450 *uart = dat; uart->baseaddr = val.addr_val; } static void uart_jitter (union param_val val, void *dat) { struct dev_16450 *uart = dat; uart->jitter = val.int_val; } static void uart_irq (union param_val val, void *dat) { struct dev_16450 *uart = dat; uart->irq = val.int_val; } static void uart_16550 (union param_val val, void *dat) { struct dev_16450 *uart = dat; uart->uart16550 = val.int_val; } /*---------------------------------------------------------------------------*/ /*!Set the channel description Free any existing string. @param[in] val The value to use @param[in] dat The config data structure */ /*---------------------------------------------------------------------------*/ static void uart_channel (union param_val val, void *dat) { struct dev_16450 *uart = dat; if (NULL != uart->channel_str) { free (uart->channel_str); uart->channel_str = NULL; } if (!(uart->channel_str = strdup (val.str_val))) { fprintf (stderr, "Peripheral 16450: Run out of memory\n"); exit (-1); } } /* uart_channel() */ static void uart_newway (union param_val val, void *dat) { fprintf (stderr, "Warning: txfile and rxfile now obsolete and ignored. " "Use 'channel = \"file:rxfile,txfile\"'."); } static void uart_vapi_id (union param_val val, void *dat) { struct dev_16450 *uart = dat; uart->vapi_id = val.int_val; } static void uart_enabled (union param_val val, void *dat) { struct dev_16450 *uart = dat; uart->enabled = val.int_val; } /*---------------------------------------------------------------------------*/ /*!Initialize a new UART configuration ALL parameters are set explicitly to default values. */ /*---------------------------------------------------------------------------*/ static void * uart_sec_start () { struct dev_16450 *new = malloc (sizeof (struct dev_16450)); if (!new) { fprintf (stderr, "Peripheral 16450: Run out of memory\n"); exit (-1); } new->enabled = 1; new->baseaddr = 0; new->irq = 0; new->uart16550 = 0; new->jitter = 0; new->channel_str = strdup ("xterm:"); new->vapi_id = 0; new->channel = NULL; return new; } /* uart_sec_start() */ static void uart_sec_end (void *dat) { struct dev_16450 *uart = dat; struct mem_ops ops; if (!uart->enabled) { free (dat); return; } memset (&ops, 0, sizeof (struct mem_ops)); ops.readfunc8 = uart_read_byte; ops.writefunc8 = uart_write_byte; ops.read_dat8 = dat; ops.write_dat8 = dat; /* FIXME: What should these be? */ ops.delayr = 2; ops.delayw = 2; reg_mem_area (uart->baseaddr, UART_ADDR_SPACE, 0, &ops); reg_sim_reset (uart_reset, dat); reg_sim_stat (uart_status, dat); } void reg_uart_sec (void) { struct config_section *sec = reg_config_sec ("uart", uart_sec_start, uart_sec_end); reg_config_param (sec, "enabled", paramt_int, uart_enabled); reg_config_param (sec, "baseaddr", paramt_addr, uart_baseaddr); reg_config_param (sec, "irq", paramt_int, uart_irq); reg_config_param (sec, "16550", paramt_int, uart_16550); reg_config_param (sec, "jitter", paramt_int, uart_jitter); reg_config_param (sec, "channel", paramt_str, uart_channel); reg_config_param (sec, "txfile", paramt_str, uart_newway); reg_config_param (sec, "rxfile", paramt_str, uart_newway); reg_config_param (sec, "vapi_id", paramt_int, uart_vapi_id); }
Go to most recent revision | Compare with Previous | Blame | View Log