Comments.
[pintos-anon] / src / devices / serial.c
1 #include "devices/serial.h"
2 #include <debug.h>
3 #include "devices/intq.h"
4 #include "devices/timer.h"
5 #include "threads/io.h"
6 #include "threads/interrupt.h"
7 #include "threads/synch.h"
8 #include "threads/thread.h"
9 \f
10 /* Register definitions for the 16550A UART used in PCs.
11    The 16550A has a lot more going on than shown here, but this
12    is all we need.
13
14    Refer to [PC16650D] for hardware information. */
15
16 /* I/O port base address for the first serial port. */
17 #define IO_BASE 0x3f8
18
19 /* DLAB=0 registers. */
20 #define RBR_REG (IO_BASE + 0)   /* Receiver Buffer Reg. (read-only). */
21 #define THR_REG (IO_BASE + 0)   /* Transmitter Holding Reg. (write-only). */
22 #define IER_REG (IO_BASE + 1)   /* Interrupt Enable Reg. (read-only). */
23 #define FCR_REG (IO_BASE + 2)   /* FIFO Control Reg. (write-only). */
24 #define LCR_REG (IO_BASE + 3)   /* Line Control Register. */
25 #define MCR_REG (IO_BASE + 4)   /* MODEM Control Register. */
26 #define LSR_REG (IO_BASE + 5)   /* Line Status Register (read-only). */
27
28 /* DLAB=1 registers. */
29 #define LS_REG (IO_BASE + 0)    /* Divisor Latch (LSB). */
30 #define MS_REG (IO_BASE + 1)    /* Divisor Latch (MSB). */
31
32 /* Interrupt Enable Register bits. */
33 #define IER_XMIT 0x02           /* Interrupt when transmit finishes. */
34
35 /* Line Control Register bits. */
36 #define LCR_N81 0x03            /* No parity, 8 data bits, 1 stop bit. */
37 #define LCR_DLAB 0x80           /* Divisor Latch Access Bit (DLAB). */
38
39 /* MODEM Control Register. */
40 #define MCR_OUT2 0x08           /* Output line 2. */
41
42 /* Line Status Register. */
43 #define LSR_THRE 0x20           /* THR Empty. */
44 \f
45 /* Transmission mode. */
46 static enum { UNINIT, POLL, QUEUE } mode;
47
48 /* Data to be transmitted. */
49 static struct intq txq;
50
51 static void set_serial (int bps);
52 static void putc_poll (uint8_t);
53 static void write_ier (void);
54 static intr_handler_func serial_interrupt;
55
56 /* Initializes the serial port device for polling mode.
57    Polling mode busy-waits for the serial port to become free
58    before writing to it.  It's slow, but until interrupts have
59    been initialized it's all we can do. */
60 void
61 serial_init_poll (void) 
62 {
63   ASSERT (mode == UNINIT);
64   outb (IER_REG, 0);                    /* Turn off all interrupts. */
65   outb (FCR_REG, 0);                    /* Disable FIFO. */
66   set_serial (9600);                    /* 9600 bps, N-8-1. */
67   outb (MCR_REG, MCR_OUT2);             /* Turn on OUT2 output line. */
68   intq_init (&txq, "serial xmit");
69   mode = POLL;
70
71
72 /* Initializes the serial port device for queued interrupt-driven
73    I/O.  With interrupt-driven I/O we don't waste CPU time
74    waiting for the serial device to become ready. */
75 void
76 serial_init_queue (void) 
77 {
78   ASSERT (mode == POLL);
79   intr_register (0x20 + 4, 0, INTR_OFF, serial_interrupt, "serial");
80   mode = QUEUE;
81 }
82
83 /* Sends BYTE to the serial port. */
84 void
85 serial_putc (uint8_t byte) 
86 {
87   enum intr_level old_level = intr_disable ();
88
89   if (mode == POLL)
90     {
91       /* If we're not set up for interrupt-driven I/O yet,
92          use dumb polling to transmit a byte. */
93       putc_poll (byte); 
94     }
95   else 
96     {
97       /* Otherwise, queue a byte and update the interrupt enable
98          register. */
99       if (old_level == INTR_OFF && intq_full (&txq)) 
100         {
101           /* Interrupts are off and the transmit queue is full.
102              If we wanted to wait for the queue to empty,
103              we'd have to reenable interrupts.
104              That's impolite, so we'll send a character via
105              polling instead. */
106           putc_poll (intq_getc (&txq)); 
107         }
108
109       intq_putc (&txq, byte); 
110       write_ier ();
111     }
112   
113   intr_set_level (old_level);
114 }
115
116 /* Flushes anything in the serial buffer out the port in polling
117    mode. */
118 void
119 serial_flush (void) 
120 {
121   enum intr_level old_level = intr_disable ();
122   while (!intq_empty (&txq))
123     putc_poll (intq_getc (&txq));
124   intr_set_level (old_level);
125 }
126 \f
127 /* Configures the serial port for BPS bits per second. */
128 static void
129 set_serial (int bps)
130 {
131   int baud_base = 1843200 / 16;         /* Base rate of 16550A. */
132   uint16_t divisor = baud_base / bps;   /* Clock rate divisor. */
133
134   /* Enable DLAB. */
135   outb (LCR_REG, LCR_N81 | LCR_DLAB);
136
137   /* Set baud rate. */
138   outb (LS_REG, divisor & 0xff);
139   outb (MS_REG, divisor >> 8);
140   
141   /* Reset DLAB. */
142   outb (LCR_REG, LCR_N81);
143 }
144
145 /* Update interrupt enable register.
146    If our transmit queue is empty, turn off transmit interrupt. */
147 static void
148 write_ier (void) 
149 {
150   outb (IER_REG, intq_empty (&txq) ? 0 : IER_XMIT);
151 }
152
153 /* Polls the serial port until it's ready,
154    and then transmits BYTE. */
155 static void
156 putc_poll (uint8_t byte) 
157 {
158   ASSERT (intr_get_level () == INTR_OFF);
159
160   while ((inb (LSR_REG) & LSR_THRE) == 0)
161     continue;
162   outb (THR_REG, byte);
163 }
164
165 /* Serial interrupt handler.
166    As long as we have a byte to transmit,
167    and the hardware is ready to accept a byte for transmission,
168    transmit a byte.
169    Then update interrupt enable register based on queue
170    status. */
171 static void
172 serial_interrupt (struct intr_frame *f UNUSED) 
173 {
174   while (!intq_empty (&txq) && (inb (LSR_REG) & LSR_THRE) != 0) 
175     outb (THR_REG, intq_getc (&txq));
176   write_ier ();
177 }