]> git.llucax.com Git - z.facultad/66.09/etherled.git/blob - src/dp8390.c
Bugfixes:
[z.facultad/66.09/etherled.git] / 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     byte i;
143
144     // Set IOR & IOW as they're active low.
145     IOR = 1;
146     IOW = 1;
147     NICE = 1;
148
149     // Set register data port as input.
150     DATA_PORT = DATA_PORT_MASK;
151
152     // Configure RTL8019AS ethernet controller.
153
154     // Keil startup code takes 4ms to execute (18.432MHz, X1 mode).
155     // That leaves plenty of time for the RTL8019AS to read it's
156     // configuration in from the 9346 EEPROM before we get here.
157
158     // Select RTL8019AS register page 0.
159     SELECT_REG_PAGE(0);
160
161     // Check if RTL8019AS fully reset.
162     if(!(read_reg(ISR) & RST))
163     {
164         return 0;
165     }
166
167     // Stop RTL8019AS, select page 0 and abort DMA operation.
168     write_reg(CR, STOP);
169
170     // Initialise data configuration register. 
171     // FIFO threshold 8 bytes, no loopback, don't use auto send packet.
172     write_reg(DCR, FT1 | LS);
173
174     // Reset remote byte count registers.
175     write_reg(RBCR0, 0u);
176     write_reg(RBCR1, 0u);
177
178     // Receive configuration register to monitor mode.
179     write_reg(RCR, MON);
180
181     // Initialise transmit configuration register to loopback internally.
182     write_reg(TCR, MODE1);
183
184     // Clear interrupt status register bits by writing 1 to each.
185     write_reg(ISR, ALL);
186
187     // Mask all interrupts in mask register.
188     write_reg(IMR, NONE);
189
190     // Obtengo MAC de la placa
191     write_reg(RBCR0, 12u); // Vamos a leer 12 bytes (2 x 6)
192     write_reg(RBCR1, 0u); 
193     write_reg(RSAR0, 0u); // En la dirección 0x0000
194     write_reg(RSAR1, 0u);
195     write_reg(CR, READ); // Comienza lectura
196     for (i = 0; i < ETH_ADDR_SIZE; ++i)
197     {
198         eth_addr_local[i] = read_reg(RDMA);
199         read_reg(RDMA); // Ignoramos porque viene como un word
200     }
201
202     // Abort/ complete DMA operation.
203     ABORT_DMA(STOP);
204
205     // Set transmit page start.
206     write_reg(TPSR, TX_PAGE_START);
207
208     // Set receive buffer page start.
209     write_reg(PSTART, RX_PAGE_START);
210
211     // Initialise last receive buffer read pointer.
212     write_reg(BNRY, RX_PAGE_START);
213
214     // Set receive buffer page stop.
215     write_reg(PSTOP, RX_PAGE_STOP);
216
217     // Select RTL8019AS register page 1.
218     SELECT_REG_PAGE(1);
219
220     // Initialise current packet receive buffer page pointer
221     write_reg(CURR, RX_PAGE_START + 1);
222
223     // Set physical address
224     for (i = 0; i < ETH_ADDR_SIZE; ++i)
225         write_reg(PAR_BASE + i, eth_addr_local[i]);
226
227     // Restart RTL8019AS. 
228     write_reg(CR, START);
229
230     // Initialise transmit configuration register for normal operation.
231     write_reg(TCR, MODE0);
232
233     // Receive configuration register to accept broadcast packets.
234     write_reg(RCR, AB);
235
236     return 1;
237 }
238
239
240 /** Comienza el envío de un nuevo frame
241  * @param len Tamaño del frame a enviar
242  */
243 void netdev_send_start()
244 {
245     persistent.send_len = 0;
246     // Wait until pending transmit operation completes.
247     while(read_reg(CR) & TXP) continue;
248
249     // Set remote DMA start address registers to indicate where to load packet.
250     write_reg(RSAR0, 0u);
251     write_reg(RSAR1, TX_PAGE_START);
252
253     // Set remote DMA byte count registers to indicate length of packet load.
254     write_reg(RBCR0, MAX_PACKET_LEN); // Tamaño máximo en principio
255     write_reg(RBCR1, 0u);
256
257     // Initiate DMA transfer of uip_buf & uip_appdata buffers to RTL8019AS.
258     write_reg(CR, WRITE);
259 }
260
261 /** Escribe un byte al buffer de la placa de red para ser enviado
262  * @precond netdev_send_start() debe haber sido ejecutada
263  * @param b Byte a enviar
264  */
265 void netdev_send_byte(byte b)
266 {
267     persistent.send_len++;
268     write_reg(RDMA, b);
269 }
270
271 /** Escribe un word al buffer de la placa de red para ser enviado
272  * @precond netdev_send_start() debe haber sido ejecutada
273  * @param w Word a enviar
274  */
275 void netdev_send_word(uint16 w)
276 {
277     persistent.send_len += 2;
278     write_reg(RDMA, HIGH(w));
279     write_reg(RDMA, LOW(w));
280 }
281
282 /** Finaliza el envío del frame
283  * @precond netdev_send_start() debe haber sido ejecutada
284  */
285 void netdev_send_end()
286 {
287     // Abort/ complete DMA operation.
288     ABORT_DMA(START);
289
290     // Set transmit page start to indicate packet start.
291     write_reg(TPSR, TX_PAGE_START);
292
293     // Ethernet packets must be > 60 bytes, otherwise are rejected as runts.
294     if (persistent.send_len < MIN_PACKET_LEN)
295     {
296         persistent.send_len = MIN_PACKET_LEN;
297     }
298
299     // Set transmit byte count registers to indicate packet length.
300     write_reg(TBCR0, LOW(persistent.send_len));
301     write_reg(TBCR1, 0u);
302
303     // Issue command for RTL8019AS to transmit packet from it's local buffer.
304     write_reg(CR, START | TXP);
305 }
306
307 /** Comienza la lectura de un nuevo frame
308  * @return Cantidad de bytes del frame leído
309  */
310 byte netdev_recv_start()
311 {
312     // Check if the rx buffer has overflowed.
313     if (read_reg(ISR) & OVW)
314     {
315         byte current;
316
317         // Select RTL8019AS register page 1.
318         SELECT_REG_PAGE(1);
319
320         // Retrieve current receive buffer page
321         current = read_reg(CURR);
322
323         // Select RTL8019AS register page 1.
324         SELECT_REG_PAGE(0);
325
326         if (read_reg(BNRY) == current)
327         {
328             printb(read_reg(ISR), 0x01);
329             printb(read_reg(BNRY), 0x02);
330             printb(current, 0x04);
331             reset();
332         }
333         return 0u;
334     }
335     // Check if there is a packet in the rx buffer.
336     else if (read_reg(ISR) & PRX)
337     {
338         struct buf_hdr_t
339         {
340             byte status;    // Estado del frame recibido
341             byte next;      // Offset del próximo frame
342             uint16 len;     // Tamaño del frame
343         }
344         buf_hdr;
345         byte current;
346         byte bnry;
347
348         // Retrieve packet header. (status, next_ptr, length_l, length_h)
349
350         // Set remote DMA start address registers to packet header.
351         bnry = read_reg(BNRY) + 1;
352         if (bnry >= RX_PAGE_STOP)
353             bnry = RX_PAGE_START;
354         write_reg(RSAR0, 0u);
355         write_reg(RSAR1, bnry);
356
357         // Select RTL8019AS register page 1.
358         SELECT_REG_PAGE(1);
359
360         // Retrieve current receive buffer page
361         current = read_reg(CURR);
362
363         // Select RTL8019AS register page 1.
364         SELECT_REG_PAGE(0);
365
366         // Check if last packet has been removed from rx buffer.
367         if(bnry == current)
368         {
369             // Clear packet received interrupt flag.
370             write_reg(ISR, PRX | RXE);
371             return 0u;
372         }
373
374         // Set remote DMA byte count registers to packet header length.
375         write_reg(RBCR0, sizeof(struct buf_hdr_t));
376         write_reg(RBCR1, 0x00);
377
378         // Clear remote DMA complete interrupt status register bit.
379         write_reg(ISR, RDC);
380
381         // Initiate DMA transfer of packet header.
382         write_reg(CR, READ);
383
384         // Packet status.
385         buf_hdr.status = read_reg(RDMA);
386
387         // Save next packet pointer.
388         buf_hdr.next = read_reg(RDMA);
389
390         // Indicamos cual es el próximo paquete para cuando termine
391         // FIXME poner más lindo para que consuma menos memoria
392         persistent.next_pkt = buf_hdr.next - 1;
393
394         // Retrieve packet data length and subtract CRC bytes.
395         buf_hdr.len = read_reg(RDMA) - sizeof(struct buf_hdr_t);
396
397         // Si es muy grande, muy chico o hubo error, lo descartamos
398         if ((buf_hdr.len < MIN_PACKET_LEN) || (buf_hdr.len > MAX_PACKET_LEN)
399                 || ((buf_hdr.status & 0x0F) != RXSOK)
400                 || read_reg(RDMA)) // Parte alta del tamaño
401         {
402             // Abort/ complete DMA operation.
403             ABORT_DMA(START);
404
405             // Advance boundary pointer to next packet start.
406             write_reg(BNRY, persistent.next_pkt);
407
408             return 0;
409         }
410
411         // Set remote DMA start address registers to packet data.
412         write_reg(RSAR0, sizeof(struct buf_hdr_t));
413         write_reg(RSAR1, bnry);
414
415         // Set remote DMA byte count registers to packet data length.
416         write_reg(RBCR0, buf_hdr.len);
417         write_reg(RBCR1, 0u);
418
419         // Initiate DMA transfer of packet data.
420         write_reg(CR, READ);
421     
422         return buf_hdr.len;
423     }
424     return 0;
425 }
426
427 /** Lee un byte del buffer de la placa de red
428  * @precond netdev_recv_start() debe haber sido ejecutada
429  */
430 byte netdev_recv_byte()
431 {
432     return read_reg(RDMA);
433 }
434
435 /** Lee un word del buffer de la placa de red
436  * @precond netdev_recv_start() debe haber sido ejecutada
437  */
438 uint16 netdev_recv_word()
439 {
440     uint16 w = netdev_recv_byte() << 8;
441     return w + netdev_recv_byte();
442 }
443
444 /** Finaliza la lectura del frame
445  * @precond netdev_recv_start() debe haber sido ejecutada
446  */
447 void netdev_recv_end()
448 {
449     // Abort/ complete DMA operation.
450     ABORT_DMA(START);
451
452     // Advance boundary pointer to next packet start.
453     write_reg(BNRY, persistent.next_pkt);
454 }
455