src/dp8390.c

   1 // vim: set et sw=4 sts=4 :
   2
   3 #include "debug.h"
   4 #include "eth.h"
   5 #include "dp8390.h"
   6
   7 /** Tamaño del frame */
   8 byte netdev_len;
   9
  10 // Próximo frame a obtener
  11 static struct
  12 {
  13     byte next_buf;
  14     byte curr_buf;
  15     byte curr_off;
  16 }
  17 recv_state;
  18
  19 /// Tamaño de la cabecera de los buffers de la placa de red
  20 #define BUF_HDR_SIZE 4
  21
  22 /// Cambia de página sin modificar los demás bits del CR
  23 #define SELECT_REG_PAGE(page)                         \
  24     do                                                \
  25     {                                                 \
  26         write_reg(CR, read_reg(CR) & ~(PS1 | PS0));   \
  27         write_reg(CR, read_reg(CR) | (page << 6));    \
  28     }                                                 \
  29     while (0)
  30
  31 /// Aborta (o completa) el DMA limpiando el ISR
  32 #define ABORT_DMA(flags)        \
  33     do                          \
  34     {                           \
  35         write_reg(CR, flags);   \
  36         write_reg(ISR, RDC);    \
  37     }                           \
  38     while (0)
  39
  40
  41 static void write_reg(unsigned char reg, unsigned char wr_data)
  42 {
  43     // Select register address.
  44     ADDR_PORT &= ~ADDR_PORT_MASK;
  45     ADDR_PORT |= reg;
  46
  47     // Output register data to port.
  48     DATA_PORT = wr_data;
  49
  50     // Clock register data into RTL8019AS.
  51     // IOR & IOW are both active low.
  52     NICE = 0;
  53     IOW = 0;
  54     IOW = 1;
  55     NICE = 1;
  56
  57     // Set register data port as input again.
  58     DATA_PORT = DATA_PORT_MASK;
  59 }
  60
  61
  62 static unsigned char read_reg(unsigned char reg)
  63 {
  64     // Select register address.
  65     ADDR_PORT &= ~ADDR_PORT_MASK;
  66     ADDR_PORT |= reg;
  67
  68     // Enable register data output from RTL8019AS.
  69     NICE = 0;
  70     IOR = 0;
  71
  72     // Read register data from port.
  73     reg = DATA_PORT;
  74
  75     // Disable register data output from RTL8019AS.
  76     IOR = 1;
  77     NICE = 1;
  78
  79     return reg;
  80 }
  81
  82 /** Resetea placa de red en caso de buffer overflow */
  83 static void reset()
  84 {
  85     bit retransmit = read_reg(CR) & TXP;
  86
  87     // If the receive buffer ring has overflowed we dump the whole
  88     // thing and start over. There is no way of knowing whether the
  89     // data it contains is uncorrupted, or will cause us grief.
  90
  91     // Stop RTL8019AS and abort DMA operation.
  92     write_reg(CR, STOP);
  93
  94     // Wait for controller to halt after any current tx completes.
  95     while(!(read_reg(ISR) & RST)) continue;
  96
  97     // Reset remote byte count registers.
  98     write_reg(RBCR0, 0x00);
  99     write_reg(RBCR1, 0x00);
 100
 101     // Check whether currently transmitting a packet.
 102     if(retransmit)
 103     {
 104         // If neither a successful transmission nor a tx abort error
 105         // has occured, then flag current tx packet for resend.
 106         if(read_reg(ISR) & (PTX | TXE))
 107         {
 108             retransmit = 0;
 109         }
 110     }
 111
 112     // Set transmit configuration register to loopback internally.
 113     write_reg(TCR, MODE1);
 114
 115     // Restart the RTL8019AS.
 116     write_reg(CR, START);
 117
 118     // Re-initialise last receive buffer read pointer.
 119     write_reg(BNRY, RX_PAGE_START);
 120
 121     // Select RTL8019AS register page 1.
 122     SELECT_REG_PAGE(1);
 123
 124     // Re-initialise current packet receive buffer page pointer.
 125     write_reg(CURR, RX_PAGE_START + 1);
 126
 127     // Select RTL8019AS register page 0.
 128     SELECT_REG_PAGE(0);
 129
 130     // Clear rx buffer overflow & packet received interrupt flags.
 131     write_reg(ISR, PRX | OVW);
 132
 133     // Re-itialise transmit configuration reg for normal operation.
 134     write_reg(TCR, MODE0);
 135
 136     if(retransmit)
 137     {
 138         // Retransmit packet in RTL8019AS local tx buffer.
 139         write_reg(CR, START | TXP);
 140     }
 141 }
 142
 143
 144 /** Inicializa dispositivo de red
 145  * @return true si se inicializó correctamente, false si no
 146  */
 147 bool netdev_init()
 148 {
 149     byte i;
 150
 151     // Set IOR & IOW as they're active low.
 152     IOR = 1;
 153     IOW = 1;
 154     NICE = 1;
 155
 156     // Set register data port as input.
 157     DATA_PORT = DATA_PORT_MASK;
 158
 159     // Configure RTL8019AS ethernet controller.
 160
 161     // Keil startup code takes 4ms to execute (18.432MHz, X1 mode).
 162     // That leaves plenty of time for the RTL8019AS to read it's
 163     // configuration in from the 9346 EEPROM before we get here.
 164
 165     // Select RTL8019AS register page 0.
 166     SELECT_REG_PAGE(0);
 167
 168     // Check if RTL8019AS fully reset.
 169     if(!(read_reg(ISR) & RST))
 170     {
 171         return 0;
 172     }
 173
 174     // Stop RTL8019AS, select page 0 and abort DMA operation.
 175     write_reg(CR, STOP);
 176
 177     // Initialise data configuration register.
 178     // FIFO threshold 8 bytes, no loopback, don't use auto send packet.
 179     write_reg(DCR, FT1 | LS);
 180
 181     // Reset remote byte count registers.
 182     write_reg(RBCR0, 0u);
 183     write_reg(RBCR1, 0u);
 184
 185     // Receive configuration register to monitor mode.
 186     write_reg(RCR, MON);
 187
 188     // Initialise transmit configuration register to loopback internally.
 189     write_reg(TCR, MODE1);
 190
 191     // Clear interrupt status register bits by writing 1 to each.
 192     write_reg(ISR, ALL);
 193
 194     // Mask all interrupts in mask register.
 195     write_reg(IMR, NONE);
 196
 197     // Obtengo MAC de la placa
 198     write_reg(RBCR0, 12u); // Vamos a leer 12 bytes (2 x 6)
 199     write_reg(RBCR1, 0u);
 200     write_reg(RSAR0, 0u); // En la dirección 0x0000
 201     write_reg(RSAR1, 0u);
 202     write_reg(CR, READ); // Comienza lectura
 203     for (i = 0; i < ETH_ADDR_SIZE; ++i)
 204     {
 205         eth_addr_local[i] = read_reg(RDMA);
 206         read_reg(RDMA); // Ignoramos porque viene como un word
 207     }
 208
 209     // Abort/ complete DMA operation.
 210     ABORT_DMA(STOP);
 211
 212     // Set transmit page start.
 213     write_reg(TPSR, TX_PAGE_START);
 214
 215     // Set receive buffer page start.
 216     write_reg(PSTART, RX_PAGE_START);
 217
 218     // Initialise last receive buffer read pointer.
 219     write_reg(BNRY, RX_PAGE_START);
 220
 221     // Set receive buffer page stop.
 222     write_reg(PSTOP, RX_PAGE_STOP);
 223
 224     // Select RTL8019AS register page 1.
 225     SELECT_REG_PAGE(1);
 226
 227     // Initialise current packet receive buffer page pointer
 228     write_reg(CURR, RX_PAGE_START + 1);
 229
 230     // Set physical address
 231     for (i = 0; i < ETH_ADDR_SIZE; ++i)
 232         write_reg(PAR_BASE + i, eth_addr_local[i]);
 233
 234     // Restart RTL8019AS.
 235     write_reg(CR, START);
 236
 237     // Initialise transmit configuration register for normal operation.
 238     write_reg(TCR, MODE0);
 239
 240     // Receive configuration register to accept broadcast packets.
 241     write_reg(RCR, AB);
 242
 243     return 1;
 244 }
 245
 246
 247 /** Comienza el envío de un nuevo frame */
 248 void netdev_send_start()
 249 {
 250     // Wait until pending transmit operation completes.
 251     while (read_reg(CR) & TXP) continue;
 252     write_reg(ISR, PTX); // Limpio bit de interrupción
 253
 254     // Set remote DMA start address registers to indicate where to load packet.
 255     write_reg(RSAR0, 0u);
 256     write_reg(RSAR1, TX_PAGE_START);
 257 }
 258
 259 /** Finaliza el envío del frame
 260  * @precond netdev_send_start() debe haber sido ejecutada
 261  * @precond se copiaron datos al dispositivo para enviar
 262  * @param len Cantidad de bytes a transmitir
 263  */
 264 void netdev_send_end(byte len)
 265 {
 266     // Set transmit page start to indicate packet start.
 267     write_reg(TPSR, TX_PAGE_START);
 268
 269     // Ethernet packets must be > 60 bytes, otherwise are rejected as runts.
 270     if (len < MIN_PACKET_LEN)
 271         len = MIN_PACKET_LEN;
 272
 273     // Set transmit byte count registers to indicate packet length.
 274     write_reg(TBCR0, len);
 275     write_reg(TBCR1, 0u);
 276
 277     // Issue command for RTL8019AS to transmit packet from it's local buffer.
 278     write_reg(CR, START | TXP);
 279 }
 280
 281 void netdev_write_start(byte len)
 282 {
 283     // Set remote DMA byte count registers to indicate length of packet load.
 284     write_reg(RBCR0, len);
 285     write_reg(RBCR1, 0u);
 286
 287     // Initiate DMA transfer of uip_buf & uip_appdata buffers to RTL8019AS.
 288     write_reg(CR, WRITE);
 289 }
 290
 291 void netdev_write_start_at(byte offset, byte len)
 292 {
 293     // Set remote DMA start address registers to packet data.
 294     write_reg(RSAR0, offset);
 295     write_reg(RSAR1, TX_PAGE_START);
 296
 297     // Set remote DMA byte count registers to indicate length of packet load.
 298     write_reg(RBCR0, len);
 299     write_reg(RBCR1, 0u);
 300
 301     // Initiate DMA transfer of uip_buf & uip_appdata buffers to RTL8019AS.
 302     write_reg(CR, WRITE);
 303 }
 304
 305 /** Escribe un byte al buffer de la placa de red para ser enviado
 306  * @precond netdev_send_start() debe haber sido ejecutada
 307  * @param b Byte a enviar
 308  */
 309 void netdev_write_byte(byte b)
 310 {
 311     write_reg(RDMA, b);
 312 }
 313
 314 /** Escribe un word al buffer de la placa de red para ser enviado
 315  * @precond netdev_send_start() debe haber sido ejecutada
 316  * @param w Word a enviar
 317  */
 318 void netdev_write_word(uint16 w)
 319 {
 320     write_reg(RDMA, HIGH(w));
 321     write_reg(RDMA, LOW(w));
 322 }
 323
 324 void netdev_write_end()
 325 {
 326     // Abort/ complete DMA operation.
 327     ABORT_DMA(START);
 328 }
 329
 330 /** Comienza la lectura de un nuevo frame
 331  * @return Cantidad de bytes a recibir
 332  */
 333 byte netdev_recv_start()
 334 {
 335     // Check if the rx buffer has overflowed.
 336     if (read_reg(ISR) & OVW)
 337     {
 338         byte current;
 339
 340         SELECT_REG_PAGE(1);
 341         current = read_reg(CURR);
 342         SELECT_REG_PAGE(0);
 343
 344         // Hack: a veces reporta mal el flag de OVW, así que verificamos que
 345         // relamente haya habido overflow.
 346         if (read_reg(BNRY) == current)
 347         {
 348             printb(read_reg(ISR), 0x01);
 349             printb(read_reg(BNRY), 0x02);
 350             printb(current, 0x04);
 351             printb(0x00, 0x00);
 352             reset();
 353         }
 354         return 0;
 355     }
 356     // Check if there is a packet in the rx buffer.
 357     else if (read_reg(ISR) & PRX)
 358     {
 359         byte status;
 360         byte len;
 361         byte current;
 362
 363         // Retrieve packet header. (status, next_ptr, length_l, length_h)
 364
 365         // Obtiene el buffer a leer actualmente
 366         recv_state.curr_buf = read_reg(BNRY) + 1;
 367         if (recv_state.curr_buf >= RX_PAGE_STOP)
 368             recv_state.curr_buf = RX_PAGE_START;
 369
 370         // Select RTL8019AS register page 1.
 371         SELECT_REG_PAGE(1);
 372
 373         // Retrieve current receive buffer page
 374         current = read_reg(CURR);
 375
 376         // Select RTL8019AS register page 1.
 377         SELECT_REG_PAGE(0);
 378
 379         // Check if last packet has been removed from rx buffer.
 380         if(recv_state.curr_buf == current)
 381         {
 382             // Clear packet received interrupt flag.
 383             write_reg(ISR, PRX | RXE);
 384             return 0;
 385         }
 386
 387         // Set remote DMA byte count registers to packet header length.
 388         recv_state.curr_off = 0;
 389         netdev_read_start(BUF_HDR_SIZE);
 390
 391         // Packet status.
 392         status = netdev_read_byte();
 393
 394         // Save next packet pointer.
 395         recv_state.next_buf = netdev_read_byte() - 1;
 396
 397         // Retrieve packet data length and subtract CRC bytes.
 398         len = netdev_read_byte() - BUF_HDR_SIZE;
 399
 400         // Si es muy grande, muy chico o hubo error, lo descartamos
 401         if ((len < MIN_PACKET_LEN) || (len > MAX_PACKET_LEN)
 402                 || ((status & 0x0F) != RXSOK)
 403                 || netdev_read_byte()) // Parte alta del tamaño
 404         {
 405             // Terminamos DMA y pasamos al próximo frame
 406             netdev_read_end();
 407             write_reg(BNRY, recv_state.next_buf);
 408             return 0;
 409         }
 410
 411         // Abort/ complete DMA operation.
 412         netdev_read_end();
 413
 414         return len;
 415     }
 416
 417     return 0;
 418 }
 419
 420 /** Finaliza la recepción del frame
 421  * @precond netdev_recv_start() debe haber sido ejecutada
 422  */
 423 void netdev_recv_end()
 424 {
 425     // Pasa el próximo frame
 426     write_reg(BNRY, recv_state.next_buf);
 427 }
 428
 429 void netdev_read_start(byte len)
 430 {
 431     // Set remote DMA start address registers to packet data.
 432     write_reg(RSAR0, recv_state.curr_off);
 433     write_reg(RSAR1, recv_state.curr_buf);
 434     recv_state.curr_off += len;
 435
 436     // Set remote DMA byte count registers to packet data length.
 437     write_reg(RBCR0, len);
 438     write_reg(RBCR1, 0);
 439
 440     // Initiate DMA transfer of packet data.
 441     write_reg(CR, READ);
 442 }
 443
 444 /** Lee un byte del buffer de la placa de red
 445  * @precond netdev_recv_start() debe haber sido ejecutada
 446  */
 447 byte netdev_read_byte()
 448 {
 449     return read_reg(RDMA);
 450 }
 451
 452 /** Lee un word del buffer de la placa de red
 453  * @precond netdev_recv_start() debe haber sido ejecutada
 454  */
 455 uint16 netdev_read_word()
 456 {
 457     uint16 w = read_reg(RDMA) << 8;
 458     return w + read_reg(RDMA);
 459 }
 460
 461 /** Finaliza la lectura del frame
 462  * @precond netdev_recv_start() debe haber sido ejecutada
 463  */
 464 void netdev_read_end()
 465 {
 466     // Completa DMA
 467     ABORT_DMA(START);
 468 }
 469