drivers/console/serial.c

Go to the documentation of this file.

#include <assert.h>
#include <interrupt.h>
#include <status-codes.h>
#include <util.h>

#include <chip/clk.h>
#include <console/core.h>
#include <console/driver.h>
#include <console/serial.h>
#include <hardware/usart.h>

struct usart_port {
        void                    *regs;
        unsigned long           pclk_hz;
        struct console_driver   drv;
};

static inline struct usart_port *usart_port_of(struct console_driver *drv)
{
        return container_of(drv, struct usart_port, drv);
}

static void usart_tx_commit(struct console_driver *drv)
{
        struct usart_port       *usart = usart_port_of(drv);
        void                    *regs = usart->regs;
        unsigned long           nchars;
        unsigned long           iflags;
        char                    c;

        iflags = cpu_irq_save();
        while (true) {
                nchars = console_buf_used(&drv->tx_buf);
                assert(nchars <= CONSOLE_BUF_SIZE);
                if (nchars == 0)
                        break;

                c = console_buf_extract_char(&drv->tx_buf);
                cpu_irq_restore(iflags);

                while (!(usart_read(regs, CSR) & USART_BIT(TXRDY)))
                        barrier();

                usart_write(regs, THR, c);
                iflags = cpu_irq_save();
        }
        cpu_irq_restore(iflags);
}

static void usart_tx_make_room(struct console_driver *drv, size_t goal)
{
        /* Keep it simple for now */
        usart_tx_commit(drv);
}

/* FIXME: Support multiple ports */
static struct usart_port the_usart_port = {
        .drv.tx_commit = usart_tx_commit,
        .drv.tx_make_room = usart_tx_make_room,
};

static uint32_t usart_calc_brgr(unsigned long base_hz, unsigned long baud)
{
        unsigned long div;
        unsigned long cd;
        unsigned long fp;

        div = (base_hz + baud / 2) / baud;
        cd = div / 8;
        fp = div % 8;

        if (cd < 2 || (cd & ((1 << USART_CD_SIZE) - 1)) != cd)
                return 0;

        return USART_BF(CD, cd) | USART_BF(FP, fp);
}

int __serial_console_init(struct console *con, unsigned int port, void *regs,
                unsigned long baud_rate, unsigned long flags)
{
        struct usart_port       *usart = &the_usart_port;
        unsigned long           pclk_hz;
        uint32_t                cr_flags = 0;

        if (flags & SERIAL_ENABLE_TX)
                cr_flags |= USART_BIT(TXEN);

        /* We don't actually support RX yet... */
        if (flags & SERIAL_ENABLE_RX)
                cr_flags |= USART_BIT(RXEN);

        pclk_hz = get_usart_pclk_rate(port);
        usart->pclk_hz = pclk_hz;
        usart->regs = regs;

        /* If the USART has already been initialized, don't touch anything */
        if (!usart_read(regs, BRGR)) {
                uint32_t        brgr;
                uint32_t        mr;

                mr = USART_BF(MODE, USART_MODE_NORMAL)
                        | USART_BF(USCLKS, USART_USCLKS_MCK)
                        | USART_BF(CHRL, USART_CHRL_8)
                        | USART_BF(PAR, USART_PAR_NONE)
                        | USART_BF(NBSTOP, USART_NBSTOP_1);

                brgr = usart_calc_brgr((pclk_hz + 1) / 2, baud_rate);
                if (!brgr) {
                        brgr = usart_calc_brgr(pclk_hz, baud_rate);
                        if (!brgr)
                                return -STATUS_INVALID_PARAM;
                        mr |= USART_BIT(OVER);
                }

                usart_write(regs, CR, USART_BIT(RSTRX) | USART_BIT(RSTTX));
                usart_write(regs, BRGR, brgr);
                usart_write(regs, MR, mr);
        }

        usart_write(regs, CR, cr_flags);

        con->drv = &usart->drv;

        return 0;
}

---