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     // Set remote DMA start address registers to indicate where to load packet.
 251     write_reg(RSAR0, 0u);
 252     write_reg(RSAR1, TX_PAGE_START);
 253 }
 254
 255 /** Finaliza el envío del frame
 256  * @precond netdev_send_start() debe haber sido ejecutada
 257  * @precond se copiaron datos al dispositivo para enviar
 258  * @param len Cantidad de bytes a transmitir
 259  */
 260 void netdev_send_end(byte len)
 261 {
 262     // Set transmit page start to indicate packet start.
 263     write_reg(TPSR, TX_PAGE_START);
 264
 265     // Ethernet packets must be > 60 bytes, otherwise are rejected as runts.
 266     if (len < MIN_PACKET_LEN)
 267         len = MIN_PACKET_LEN;
 268
 269     // Set transmit byte count registers to indicate packet length.
 270     write_reg(TBCR0, len);
 271     write_reg(TBCR1, 0u);
 272
 273     // Issue command for RTL8019AS to transmit packet from it's local buffer.
 274     write_reg(CR, START | TXP);
 275
 276     // Wait until pending transmit operation completes.
 277     while(read_reg(CR) & TXP) continue;
 278 }
 279
 280 void netdev_write_start(byte len)
 281 {
 282     // Set remote DMA byte count registers to indicate length of packet load.
 283     write_reg(RBCR0, len); // Tamaño máximo en principio
 284     write_reg(RBCR1, 0u);
 285
 286     // Initiate DMA transfer of uip_buf & uip_appdata buffers to RTL8019AS.
 287     write_reg(CR, WRITE);
 288 }
 289
 290 /** Escribe un byte al buffer de la placa de red para ser enviado
 291  * @precond netdev_send_start() debe haber sido ejecutada
 292  * @param b Byte a enviar
 293  */
 294 void netdev_write_byte(byte b)
 295 {
 296     write_reg(RDMA, b);
 297 }
 298
 299 /** Escribe un word al buffer de la placa de red para ser enviado
 300  * @precond netdev_send_start() debe haber sido ejecutada
 301  * @param w Word a enviar
 302  */
 303 void netdev_write_word(uint16 w)
 304 {
 305     write_reg(RDMA, HIGH(w));
 306     write_reg(RDMA, LOW(w));
 307 }
 308
 309 void netdev_write_end()
 310 {
 311     // Abort/ complete DMA operation.
 312     ABORT_DMA(START);
 313 }
 314
 315 /** Comienza la lectura de un nuevo frame
 316  * @return Cantidad de bytes a recibir
 317  */
 318 byte netdev_recv_start()
 319 {
 320     // Check if the rx buffer has overflowed.
 321     if (read_reg(ISR) & OVW)
 322     {
 323         byte current;
 324
 325         SELECT_REG_PAGE(1);
 326         current = read_reg(CURR);
 327         SELECT_REG_PAGE(0);
 328
 329         // Hack: a veces reporta mal el flag de OVW, así que verificamos que
 330         // relamente haya habido overflow.
 331         if (read_reg(BNRY) == current)
 332         {
 333             printb(read_reg(ISR), 0x01);
 334             printb(read_reg(BNRY), 0x02);
 335             printb(current, 0x04);
 336             ledsb(0x00, 0x00);
 337             reset();
 338         }
 339         return 0;
 340     }
 341     // Check if there is a packet in the rx buffer.
 342     else if (read_reg(ISR) & PRX)
 343     {
 344         byte status;
 345         byte len;
 346         byte current;
 347
 348         // Retrieve packet header. (status, next_ptr, length_l, length_h)
 349
 350         // Obtiene el buffer a leer actualmente
 351         recv_state.curr_buf = read_reg(BNRY) + 1;
 352         if (recv_state.curr_buf >= RX_PAGE_STOP)
 353             recv_state.curr_buf = RX_PAGE_START;
 354
 355         // Select RTL8019AS register page 1.
 356         SELECT_REG_PAGE(1);
 357
 358         // Retrieve current receive buffer page
 359         current = read_reg(CURR);
 360
 361         // Select RTL8019AS register page 1.
 362         SELECT_REG_PAGE(0);
 363
 364         // Check if last packet has been removed from rx buffer.
 365         if(recv_state.curr_buf == current)
 366         {
 367             // Clear packet received interrupt flag.
 368             write_reg(ISR, PRX | RXE);
 369             return 0;
 370         }
 371
 372         // Set remote DMA byte count registers to packet header length.
 373         recv_state.curr_off = 0;
 374         netdev_read_start(BUF_HDR_SIZE);
 375
 376         // Packet status.
 377         status = netdev_read_byte();
 378
 379         // Save next packet pointer.
 380         recv_state.next_buf = netdev_read_byte() - 1;
 381
 382         // Retrieve packet data length and subtract CRC bytes.
 383         len = netdev_read_byte() - BUF_HDR_SIZE;
 384
 385         // Si es muy grande, muy chico o hubo error, lo descartamos
 386         if ((len < MIN_PACKET_LEN) || (len > MAX_PACKET_LEN)
 387                 || ((status & 0x0F) != RXSOK)
 388                 || netdev_read_byte()) // Parte alta del tamaño
 389         {
 390             // Terminamos DMA y pasamos al próximo frame
 391             netdev_read_end();
 392             write_reg(BNRY, recv_state.next_buf);
 393             return 0;
 394         }
 395
 396         // Abort/ complete DMA operation.
 397         netdev_read_end();
 398
 399         return len;
 400     }
 401
 402     return 0;
 403 }
 404
 405 /** Finaliza la recepción del frame
 406  * @precond netdev_recv_start() debe haber sido ejecutada
 407  */
 408 void netdev_recv_end()
 409 {
 410     // Pasa el próximo frame
 411     write_reg(BNRY, recv_state.next_buf);
 412 }
 413
 414 void netdev_read_start(byte len)
 415 {
 416     // Set remote DMA start address registers to packet data.
 417     write_reg(RSAR0, recv_state.curr_off);
 418     write_reg(RSAR1, recv_state.curr_buf);
 419     recv_state.curr_off += len;
 420
 421     // Set remote DMA byte count registers to packet data length.
 422     write_reg(RBCR0, len);
 423     write_reg(RBCR1, 0);
 424
 425     // Initiate DMA transfer of packet data.
 426     write_reg(CR, READ);
 427 }
 428
 429 /** Lee un byte del buffer de la placa de red
 430  * @precond netdev_recv_start() debe haber sido ejecutada
 431  */
 432 byte netdev_read_byte()
 433 {
 434     return read_reg(RDMA);
 435 }
 436
 437 /** Lee un word del buffer de la placa de red
 438  * @precond netdev_recv_start() debe haber sido ejecutada
 439  */
 440 uint16 netdev_read_word()
 441 {
 442     uint16 w = read_reg(RDMA) << 8;
 443     return w + read_reg(RDMA);
 444 }
 445
 446 /** Finaliza la lectura del frame
 447  * @precond netdev_recv_start() debe haber sido ejecutada
 448  */
 449 void netdev_read_end()
 450 {
 451     // Completa DMA
 452     ABORT_DMA(START);
 453 }
 454