git.rot13.org Git - simavr/blob - simavr/sim/avr_uart.c

   1 /*
   2         avr_uart.c
   3
   4         Handles UART access
   5         Right now just handle "write" to the serial port at any speed
   6         and printf to the console when '\n' is written.
   7
   8         Copyright 2008, 2009 Michel Pollet <buserror@gmail.com>
   9
  10         This file is part of simavr.
  11
  12         simavr is free software: you can redistribute it and/or modify
  13         it under the terms of the GNU General Public License as published by
  14         the Free Software Foundation, either version 3 of the License, or
  15         (at your option) any later version.
  16
  17         simavr is distributed in the hope that it will be useful,
  18         but WITHOUT ANY WARRANTY; without even the implied warranty of
  19         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20         GNU General Public License for more details.
  21
  22         You should have received a copy of the GNU General Public License
  23         along with simavr.  If not, see <http://www.gnu.org/licenses/>.
  24  */
  25
  26 #ifdef NO_COLOR
  27         #define FONT_GREEN
  28         #define FONT_DEFAULT
  29 #else
  30         #define FONT_GREEN              "\e[32m"
  31         #define FONT_DEFAULT    "\e[0m"
  32 #endif
  33
  34 #include <stdio.h>
  35 #include <unistd.h>
  36 #include <stdint.h>
  37 #include "avr_uart.h"
  38 #include "sim_hex.h"
  39
  40 //#define TRACE(_w) _w
  41 #ifndef TRACE
  42 #define TRACE(_w)
  43 #endif
  44
  45 DEFINE_FIFO(uint8_t, uart_fifo);
  46
  47 static avr_cycle_count_t avr_uart_txc_raise(struct avr_t * avr, avr_cycle_count_t when, void * param)
  48 {
  49         avr_uart_t * p = (avr_uart_t *)param;
  50         if (avr_regbit_get(avr, p->txen)) {
  51                 // if the interrupts are not used, still raise the UDRE and TXC flag
  52                 avr_raise_interrupt(avr, &p->udrc);
  53                 avr_raise_interrupt(avr, &p->txc);
  54         }
  55         return 0;
  56 }
  57
  58 static avr_cycle_count_t avr_uart_rxc_raise(struct avr_t * avr, avr_cycle_count_t when, void * param)
  59 {
  60         avr_uart_t * p = (avr_uart_t *)param;
  61         if (avr_regbit_get(avr, p->rxen))
  62                 avr_raise_interrupt(avr, &p->rxc);
  63         return 0;
  64 }
  65
  66 static uint8_t avr_uart_rxc_read(struct avr_t * avr, avr_io_addr_t addr, void * param)
  67 {
  68         avr_uart_t * p = (avr_uart_t *)param;
  69         uint8_t v = avr_core_watch_read(avr, addr);
  70
  71         //static uint8_t old = 0xff; if (v != old) printf("UCSRA read %02x\n", v); old = v;
  72         //
  73         // if RX is enabled, and there is nothing to read, and
  74         // the AVR core is reading this register, it's probably
  75         // to poll the RXC TXC flag and spinloop
  76         // so here we introduce a usleep to make it a bit lighter
  77         // on CPU and let data arrive
  78         //
  79         uint8_t ri = !avr_regbit_get(avr, p->rxen) || !avr_regbit_get(avr, p->rxc.raised);
  80         uint8_t ti = !avr_regbit_get(avr, p->txen) || !avr_regbit_get(avr, p->txc.raised);
  81
  82         if (p->flags & AVR_UART_FLAG_POOL_SLEEP) {
  83
  84                 if (ri && ti)
  85                         usleep(1);
  86         }
  87         // if reception is idle and the fifo is empty, tell whomever there is room
  88         if (avr_regbit_get(avr, p->rxen) && uart_fifo_isempty(&p->input)) {
  89                 avr_raise_irq(p->io.irq + UART_IRQ_OUT_XOFF, 0);
  90                 avr_raise_irq(p->io.irq + UART_IRQ_OUT_XON, 1);
  91         }
  92
  93         return v;
  94 }
  95
  96 static uint8_t avr_uart_read(struct avr_t * avr, avr_io_addr_t addr, void * param)
  97 {
  98         avr_uart_t * p = (avr_uart_t *)param;
  99
 100         // clear the rxc bit in case the code is using polling
 101         avr_regbit_clear(avr, p->rxc.raised);
 102
 103         if (!avr_regbit_get(avr, p->rxen)) {
 104                 avr->data[addr] = 0;
 105                 // made to trigger potential watchpoints
 106                 avr_core_watch_read(avr, addr);
 107                 return 0;
 108         }
 109         uint8_t v = uart_fifo_read(&p->input);
 110
 111 //      TRACE(printf("UART read %02x %s\n", v, uart_fifo_isempty(&p->input) ? "EMPTY!" : "");)
 112         avr->data[addr] = v;
 113         // made to trigger potential watchpoints
 114         v = avr_core_watch_read(avr, addr);
 115
 116         // trigger timer if more characters are pending
 117         if (!uart_fifo_isempty(&p->input))
 118                 avr_cycle_timer_register_usec(avr, p->usec_per_byte, avr_uart_rxc_raise, p);
 119
 120         return v;
 121 }
 122
 123 static void avr_uart_baud_write(struct avr_t * avr, avr_io_addr_t addr, uint8_t v, void * param)
 124 {
 125         avr_uart_t * p = (avr_uart_t *)param;
 126         avr_core_watch_write(avr, addr, v);
 127         uint32_t val = avr->data[p->r_ubrrl] | (avr->data[p->r_ubrrh] << 8);
 128         uint32_t baud = avr->frequency / (val+1);
 129         if (avr_regbit_get(avr, p->u2x))
 130                 baud /= 8;
 131         else
 132                 baud /= 16;
 133
 134         const int databits[] = { 5,6,7,8,  /* 'reserved', assume 8 */8,8,8, 9 };
 135         int db = databits[avr_regbit_get(avr, p->ucsz) | (avr_regbit_get(avr, p->ucsz2) << 2)];
 136         int sb = 1 + avr_regbit_get(avr, p->usbs);
 137         int word_size = 1 /* start */ + db /* data bits */ + 1 /* parity */ + sb /* stops */;
 138
 139         printf("UART-%c configured to %04x = %d bps (x%d), %d data %d stop\n",
 140                         p->name, val, baud, avr_regbit_get(avr, p->u2x)?2:1, db, sb);
 141         // TODO: Use the divider value and calculate the straight number of cycles
 142         p->usec_per_byte = 1000000 / (baud / word_size);
 143         printf("Roughtly %d usec per bytes\n", (int)p->usec_per_byte);
 144 }
 145
 146 static void avr_uart_write(struct avr_t * avr, avr_io_addr_t addr, uint8_t v, void * param)
 147 {
 148         avr_uart_t * p = (avr_uart_t *)param;
 149
 150         if (addr == p->r_udr) {
 151                 avr_core_watch_write(avr, addr, v);
 152
 153                 if ( p->udrc.vector)
 154                         avr_regbit_clear(avr, p->udrc.raised);
 155                 avr_cycle_timer_register_usec(avr,
 156                                 p->usec_per_byte, avr_uart_txc_raise, p); // should be uart speed dependent
 157
 158                 if (p->flags & AVR_UART_FLAG_STDIO) {
 159                         static char buf[128];
 160                         static int l = 0;
 161                         buf[l++] = v < ' ' ? '.' : v;
 162                         buf[l] = 0;
 163                         if (v == '\n' || l == 127) {
 164                                 l = 0;
 165                                 printf( FONT_GREEN "%s\n" FONT_DEFAULT, buf);
 166                         }
 167                 }
 168                 TRACE(printf("UDR%c(%02x) = %02x\n", p->name, addr, v);)
 169                 // tell other modules we are "outputing" a byte
 170                 if (avr_regbit_get(avr, p->txen))
 171                         avr_raise_irq(p->io.irq + UART_IRQ_OUTPUT, v);
 172         }
 173         if (p->udrc.vector && addr == p->udrc.enable.reg) {
 174                 /*
 175                  * If enabling the UDRC interrupt, raise it immediately if FIFO is empty
 176                  */
 177                 uint8_t udrce = avr_regbit_get(avr, p->udrc.enable);
 178                 avr_core_watch_write(avr, addr, v);
 179                 uint8_t nudrce = avr_regbit_get(avr, p->udrc.enable);
 180                 if (!udrce && nudrce) {
 181                         // if the FIDO is not empty (clear timer is flying) we don't
 182                         // need to raise the interrupt, it will happen when the timer
 183                         // is fired.
 184                         if (avr_cycle_timer_status(avr, avr_uart_txc_raise, p) == 0)
 185                                 avr_raise_interrupt(avr, &p->udrc);
 186                 }
 187         }
 188         if (p->udrc.vector && addr == p->udrc.raised.reg) {
 189                 // get the bits before the write
 190                 //uint8_t udre = avr_regbit_get(avr, p->udrc.raised);
 191                 uint8_t txc = avr_regbit_get(avr, p->txc.raised);
 192
 193                 // no need to write this value in here, only the
 194                 // interrupt flags need clearing!
 195                 // avr_core_watch_write(avr, addr, v);
 196
 197                 //avr_clear_interrupt_if(avr, &p->udrc, udre);
 198                 avr_clear_interrupt_if(avr, &p->txc, txc);
 199         }
 200 }
 201
 202 static void avr_uart_irq_input(struct avr_irq_t * irq, uint32_t value, void * param)
 203 {
 204         avr_uart_t * p = (avr_uart_t *)param;
 205         avr_t * avr = p->io.avr;
 206
 207         // check to see fi receiver is enabled
 208         if (!avr_regbit_get(avr, p->rxen))
 209                 return;
 210
 211         if (uart_fifo_isempty(&p->input))
 212                 avr_cycle_timer_register_usec(avr, p->usec_per_byte, avr_uart_rxc_raise, p); // should be uart speed dependent
 213         uart_fifo_write(&p->input, value); // add to fifo
 214
 215         TRACE(printf("UART IRQ in %02x (%d/%d) %s\n", value, p->input.read, p->input.write, uart_fifo_isfull(&p->input) ? "FULL!!" : "");)
 216
 217         if (uart_fifo_isfull(&p->input))
 218                 avr_raise_irq(p->io.irq + UART_IRQ_OUT_XOFF, 1);
 219 }
 220
 221
 222 void avr_uart_reset(struct avr_io_t *io)
 223 {
 224         avr_uart_t * p = (avr_uart_t *)io;
 225         avr_t * avr = p->io.avr;
 226         if (p->udrc.vector)
 227                 avr_regbit_set(avr, p->udrc.raised);
 228         avr_irq_register_notify(p->io.irq + UART_IRQ_INPUT, avr_uart_irq_input, p);
 229         avr_cycle_timer_cancel(avr, avr_uart_rxc_raise, p);
 230         avr_cycle_timer_cancel(avr, avr_uart_txc_raise, p);
 231         uart_fifo_reset(&p->input);
 232
 233         // DEBUG allow printf without fidding with enabling the uart
 234         avr_regbit_set(avr, p->txen);
 235         p->usec_per_byte = 100;
 236 }
 237
 238 static int avr_uart_ioctl(struct avr_io_t * port, uint32_t ctl, void * io_param)
 239 {
 240         avr_uart_t * p = (avr_uart_t *)port;
 241         int res = -1;
 242
 243         if (!io_param)
 244                 return res;
 245
 246         if (ctl == AVR_IOCTL_UART_SET_FLAGS(p->name)) {
 247                 p->flags = *(uint32_t*)io_param;
 248                 res = 0;
 249         }
 250         if (ctl == AVR_IOCTL_UART_GET_FLAGS(p->name)) {
 251                 *(uint32_t*)io_param = p->flags;
 252                 res = 0;
 253         }
 254
 255         return res;
 256 }
 257
 258 static const char * irq_names[UART_IRQ_COUNT] = {
 259         [UART_IRQ_INPUT] = "8<in",
 260         [UART_IRQ_OUTPUT] = "8>out",
 261         [UART_IRQ_OUT_XON] = ">xon",
 262         [UART_IRQ_OUT_XOFF] = ">xoff",
 263 };
 264
 265 static  avr_io_t        _io = {
 266         .kind = "uart",
 267         .reset = avr_uart_reset,
 268         .ioctl = avr_uart_ioctl,
 269         .irq_names = irq_names,
 270 };
 271
 272 void avr_uart_init(avr_t * avr, avr_uart_t * p)
 273 {
 274         p->io = _io;
 275
 276 //      printf("%s UART%c UDR=%02x\n", __FUNCTION__, p->name, p->r_udr);
 277
 278         p->flags = AVR_UART_FLAG_POOL_SLEEP|AVR_UART_FLAG_STDIO;
 279
 280         avr_register_io(avr, &p->io);
 281         avr_register_vector(avr, &p->rxc);
 282         avr_register_vector(avr, &p->txc);
 283         avr_register_vector(avr, &p->udrc);
 284
 285         // allocate this module's IRQ
 286         avr_io_setirqs(&p->io, AVR_IOCTL_UART_GETIRQ(p->name), UART_IRQ_COUNT, NULL);
 287         // Only call callbacks when the value change...
 288         p->io.irq[UART_IRQ_OUT_XOFF].flags |= IRQ_FLAG_FILTERED;
 289
 290         avr_register_io_write(avr, p->r_udr, avr_uart_write, p);
 291         avr_register_io_read(avr, p->r_udr, avr_uart_read, p);
 292         // monitor code that reads the rxc flag, and delay it a bit
 293         avr_register_io_read(avr, p->rxc.raised.reg, avr_uart_rxc_read, p);
 294
 295         if (p->udrc.vector)
 296                 avr_register_io_write(avr, p->udrc.enable.reg, avr_uart_write, p);
 297         if (p->r_ucsra)
 298                 avr_register_io_write(avr, p->r_ucsra, avr_uart_write, p);
 299         if (p->r_ubrrl)
 300                 avr_register_io_write(avr, p->r_ubrrl, avr_uart_baud_write, p);
 301 }
 302