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