tx_empty

This function tests whether the transmitter fifo and shifter for the port is empty. If it is empty, this function should return TIOCSER_TEMT, otherwise return 0. If the port does not support this operation, then it should return TIOCSER_TEMT.

 1static unsigned int mserial_tx_empty(struct uart_port *port)
 2{
 3	unsigned long flags;
 4	unsigned int ret;
 5
 6	spin_lock_irqsave(&port->lock, flags);
 7	ret = ioread32(port->membase + MSERIAL_CONSTAT);
 8	spin_unlock_irqrestore(&port->lock, flags);
 9
10	return (ret & MSERIAL_CONSTAT_TXC) ? TIOCSER_TEMT : 0;
11}

set_mctrl

This function sets the modem control lines for port to the state described by mctrl. The relevant bits of mctrl are:

• TIOCM_RTS RTS signal.
• TIOCM_DTR DTR signal.
• TIOCM_OUT1 OUT1 signal.
• TIOCM_OUT2 OUT2 signal.
• TIOCM_LOOP Set the port into loopback mode.

If the appropriate bit is set, the signal should be driven active. If the bit is clear, the signal should be driven inactive.

This driver does not implement the feature to set these control lines, so the implementation is simply:

1static void mserial_set_mctrl(struct uart_port *port, unsigned int mctrl)
2{
3	/* N/A */
4}

get_mctrl

Returns the current state of modem control inputs of @port. The state of the outputs should not be returned, since the core keeps track of their state. The state information should include:

• TIOCM_CAR state of DCD signal
• TIOCM_CTS state of CTS signal
• TIOCM_DSR state of DSR signal
• TIOCM_RI state of RI signal

The bit is set if the signal is currently driven active. If the port does not support CTS, DCD or DSR, the driver should indicate that the signal is permanently active. If RI is not available, the signal should not be indicated as active.

1static unsigned int mserial_get_mctrl(struct uart_port *port)
2{
3	return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR;
4}

stop_tx

Stop transmitting characters. This might be due to the CTS line becoming inactive or the tty layer indicating we want to stop transmission due to an XOFF character.

The driver should stop transmitting characters as soon as possible.

We don't need to do any special for stop transmitting characters:

1static void mserial_stop_tx(struct uart_port *port)
2{
3}

start_tx

Start transmitting characters.

This function only calls mserial_transmit():

1static void mserial_start_tx(struct uart_port *port)
2{
3	mserial_transmit(port, ioread32(port->membase + MSERIAL_CONSTAT));
4}

For handling the transmitting of bytes from the circular buffer.

 1static int mserial_transmit(struct uart_port *port, int stat)
 2{
 3	struct circ_buf *xmit  = &port->state->xmit;
 4
 5	if (stat & MSERIAL_CONSTAT_TXFULL)
 6		return 0;
 7
 8
 9	if (port->x_char) {
10		iowrite8(port->x_char, port->membase + MSERIAL_TXDATA);
11		port->x_char = 0;
12		port->icount.tx++;
13		return 1;
14	}
15
16	if (uart_circ_empty(xmit) || uart_tx_stopped(port))
17		return 0;
18
19	iowrite8(xmit->buf[xmit->tail], port->membase + MSERIAL_TXDATA);
20	xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE-1);
21	port->icount.tx++;
22
23	/* wake up */
24	if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
25		uart_write_wakeup(port);
26
27	return 1;
28}

The uart_write_wakeup() routine is used by the interrupt handler to schedule processing in the software interrupt portion of the driver. The driver should call the function when the number of charactes in the transmit buffer have dropped below a threshold.

stop_rx

Stop receiving characters; the port is in the process of being closed.

1static void mserial_stop_rx(struct uart_port *port)
2{
3	/* don't forward any more data (like !CREAD) */
4	port->ignore_status_mask = MSERIAL_CONSTAT_ERRMASK;
5}

break_ctl

Control the transmission of a break signal. If ctl is nonzero, the break signal should be transmitted. The signal should be terminated when another call is made with a zero ctl.

1static void mserial_break_ctl(struct uart_port *port, int ctl)
2{
3	/* N/A */
4}

startup

Grab any interrupt resources and initialise any low level driver state. Enable the port for reception. This method will only be called when the port is initially opened.

As we are using a hrtimer to poll for rx data, it is not time to start the timer.

 1static int mserial_startup(struct uart_port *port)
 2{
 3	struct mserial_data *pdata = port->private_data;
 4
 5	hrtimer_start(&pdata->timer, pdata->pollrate, HRTIMER_MODE_REL);
 6
 7	iowrite32(ioread32(port->membase + MSERIAL_CONSTAT) | MSERIAL_CONSTAT_ENUART,
 8			port->membase + MSERIAL_CONSTAT);
 9	return 0;
10}

Speaking of the timer. The timer function that kicks in is mserial_poll():

 1static enum hrtimer_restart mserial_poll(struct hrtimer *timer)
 2{
 3	struct mserial_data *ss = container_of(timer, struct mserial_data, timer);
 4	struct uart_port *port = ss->port;
 5	int rx_or_tx, n = 0;
 6	u16 cs;
 7
 8	do {
 9		cs = ioread32(port->membase + MSERIAL_CONSTAT);
10		iowrite32(cs & ~MSERIAL_CONSTAT_ERRMASK, port->membase + MSERIAL_CONSTAT);
11
12		rx_or_tx  = mserial_receive(port, cs);
13		rx_or_tx |= mserial_transmit(port, cs);
14		n++;
15	} while (rx_or_tx);
16
17	if (n > 1)
18		tty_flip_buffer_push(&port->state->port);
19
20	hrtimer_start(&ss->timer, ss->pollrate, HRTIMER_MODE_REL);
21	return HRTIMER_NORESTART;
22}

tty_flip_buffer_push() queues a push of the terminal flip buffer to the line current line discipline.

shutdown

Disable the port, disable any break condition that may be in effect, and free any interrupt resources.

Disable the UART and cancel the timer.

 1static int mserial_startup(struct uart_port *port)
 2{
 3	struct mserial_data *pdata = port->private_data;
 4
 5	hrtimer_start(&pdata->timer, pdata->pollrate, HRTIMER_MODE_REL);
 6
 7	iowrite32(ioread32(port->membase + MSERIAL_CONSTAT) | MSERIAL_CONSTAT_ENUART,
 8			port->membase + MSERIAL_CONSTAT);
 9	return 0;
10}

set_termios

Change the port parameters, including word length, parity, stop bits. Update port->read_status_mask and port->ignore_status_mask to indicate the types of events we are interested in receiving.

The UART implementation in the FPGA is rather simple and does not allow any port parameters except baudrate.

 1static void mserial_set_termios(struct uart_port *port,
 2			      struct ktermios *termios,
 3			      const struct ktermios *old)
 4{
 5	unsigned long flags;
 6	unsigned int baud = 0;
 7	u16 div;
 8
 9	spin_lock_irqsave(&port->lock, flags);
10
11	baud = uart_get_baud_rate(
12			port, termios, old, MSERIAL_BR_MIN, MSERIAL_BR_MAX);
13
14	if (baud)	{
15		div = MSERIAL_CLOCK / (8 * baud);
16		iowrite32(div, port->membase + MSERIAL_BR);
17		uart_update_timeout(port, termios->c_cflag, baud);
18	}
19	spin_unlock_irqrestore(&port->lock, flags);
20
21}

type

Return a pointer to a string constant describing the specified port, or return NULL, in which case the string 'unknown' is substituted.

1static const char *mserial_type(struct uart_port *port)
2{
3	return port->type == PORT_MFOCSERIAL ? "mfocserial" : NULL;
4}

release_port

Release any memory and IO region resources currently in use by the port.

In our case we only have the memory region to release.

1static void mserial_release_port(struct uart_port *port)
2{
3	release_mem_region(port->mapbase, MSERIAL_REGION);
4	iounmap(port->membase);
5	port->membase = NULL;
6}

request_port

Request any memory and IO region resources required by the port. If any fail, no resources should be registered when this function returns, and it should return -EBUSY on failure.

 1static int mserial_request_port(struct uart_port *port)
 2{
 3	pr_debug("mserial console: port=%p; port->mapbase=%llx\n",
 4		 port, (unsigned long long) port->mapbase);
 5
 6	if (!request_mem_region(port->mapbase, MSERIAL_REGION, "mserial")) {
 7		dev_err(port->dev, "Memory region busy\n");
 8		return -EBUSY;
 9	}
10
11	port->membase = ioremap(port->mapbase, MSERIAL_REGION);
12	if (!port->membase) {
13		dev_err(port->dev, "Unable to map registers\n");
14		release_mem_region(port->mapbase, MSERIAL_REGION);
15		return -EBUSY;
16	}
17	return 0;
18}

config_port

Perform any autoconfiguration steps required for the port. type contains a bit mask of the required configuration. port->type should be set to the type found, or PORT_UNKNOWN if no port was detected.

1static void mserial_config_port(struct uart_port *port, int flags)
2{
3	if (!mserial_request_port(port))
4		port->type = PORT_MFOCSERIAL;
5}