26642237eaf884eb3fe3681bb98eb767ab31afea
[people/pcmattman/gpxe.git] / src / drivers / net / via-rhine.c
1 /* rhine.c:Fast Ethernet driver for Linux. */
2 /*
3         Adapted 09-jan-2000 by Paolo Marini (paolom@prisma-eng.it)
4
5         originally written by Donald Becker.
6
7         This software may be used and distributed according to the terms
8         of the GNU Public License (GPL), incorporated herein by reference.
9         Drivers derived from this code also fall under the GPL and must retain
10         this authorship and copyright notice.
11
12         Under no circumstances are the authors responsible for
13         the proper functioning of this software, nor do the authors assume any
14         responsibility for damages incurred with its use.
15
16         This driver is designed for the VIA VT86C100A Rhine-II PCI Fast Ethernet
17         controller.
18
19 */
20
21 static const char *version = "rhine.c v1.0.2 2004-10-29\n";
22
23 /* A few user-configurable values. */
24
25 // max time out delay time
26 #define W_MAX_TIMEOUT   0x0FFFU
27
28 /* Size of the in-memory receive ring. */
29 #define RX_BUF_LEN_IDX  3       /* 0==8K, 1==16K, 2==32K, 3==64K */
30 #define RX_BUF_LEN (8192 << RX_BUF_LEN_IDX)
31
32 /* Size of the Tx bounce buffers -- must be at least (dev->mtu+14+4). */
33 #define TX_BUF_SIZE     1536
34 #define RX_BUF_SIZE     1536
35
36 /* PCI Tuning Parameters
37    Threshold is bytes transferred to chip before transmission starts. */
38 #define TX_FIFO_THRESH 256      /* In bytes, rounded down to 32 byte units. */
39
40 /* The following settings are log_2(bytes)-4:  0 == 16 bytes .. 6==1024. */
41 #define RX_FIFO_THRESH  4       /* Rx buffer level before first PCI xfer.  */
42 #define RX_DMA_BURST    4       /* Maximum PCI burst, '4' is 256 bytes */
43 #define TX_DMA_BURST    4
44
45 /* Operational parameters that usually are not changed. */
46 /* Time in jiffies before concluding the transmitter is hung. */
47 #define TX_TIMEOUT  ((2000*HZ)/1000)
48
49 #include "etherboot.h"
50 #include "nic.h"
51 #include <gpxe/pci.h>
52 #include "timer.h"
53
54 /* define all ioaddr */
55
56 #define byPAR0                          ioaddr
57 #define byRCR                           ioaddr + 6
58 #define byTCR                           ioaddr + 7
59 #define byCR0                           ioaddr + 8
60 #define byCR1                           ioaddr + 9
61 #define byISR0                          ioaddr + 0x0c
62 #define byISR1                          ioaddr + 0x0d
63 #define byIMR0                          ioaddr + 0x0e
64 #define byIMR1                          ioaddr + 0x0f
65 #define byMAR0                          ioaddr + 0x10
66 #define byMAR1                          ioaddr + 0x11
67 #define byMAR2                          ioaddr + 0x12
68 #define byMAR3                          ioaddr + 0x13
69 #define byMAR4                          ioaddr + 0x14
70 #define byMAR5                          ioaddr + 0x15
71 #define byMAR6                          ioaddr + 0x16
72 #define byMAR7                          ioaddr + 0x17
73 #define dwCurrentRxDescAddr             ioaddr + 0x18
74 #define dwCurrentTxDescAddr             ioaddr + 0x1c
75 #define dwCurrentRDSE0                  ioaddr + 0x20
76 #define dwCurrentRDSE1                  ioaddr + 0x24
77 #define dwCurrentRDSE2                  ioaddr + 0x28
78 #define dwCurrentRDSE3                  ioaddr + 0x2c
79 #define dwNextRDSE0                     ioaddr + 0x30
80 #define dwNextRDSE1                     ioaddr + 0x34
81 #define dwNextRDSE2                     ioaddr + 0x38
82 #define dwNextRDSE3                     ioaddr + 0x3c
83 #define dwCurrentTDSE0                  ioaddr + 0x40
84 #define dwCurrentTDSE1                  ioaddr + 0x44
85 #define dwCurrentTDSE2                  ioaddr + 0x48
86 #define dwCurrentTDSE3                  ioaddr + 0x4c
87 #define dwNextTDSE0                     ioaddr + 0x50
88 #define dwNextTDSE1                     ioaddr + 0x54
89 #define dwNextTDSE2                     ioaddr + 0x58
90 #define dwNextTDSE3                     ioaddr + 0x5c
91 #define dwCurrRxDMAPtr                  ioaddr + 0x60
92 #define dwCurrTxDMAPtr                  ioaddr + 0x64
93 #define byMPHY                          ioaddr + 0x6c
94 #define byMIISR                         ioaddr + 0x6d
95 #define byBCR0                          ioaddr + 0x6e
96 #define byBCR1                          ioaddr + 0x6f
97 #define byMIICR                         ioaddr + 0x70
98 #define byMIIAD                         ioaddr + 0x71
99 #define wMIIDATA                        ioaddr + 0x72
100 #define byEECSR                         ioaddr + 0x74
101 #define byTEST                          ioaddr + 0x75
102 #define byGPIO                          ioaddr + 0x76
103 #define byCFGA                          ioaddr + 0x78
104 #define byCFGB                          ioaddr + 0x79
105 #define byCFGC                          ioaddr + 0x7a
106 #define byCFGD                          ioaddr + 0x7b
107 #define wTallyCntMPA                    ioaddr + 0x7c
108 #define wTallyCntCRC                    ioaddr + 0x7d
109 #define bySTICKHW                       ioaddr + 0x83
110 #define byWOLcrClr                      ioaddr + 0xA4
111 #define byWOLcgClr                      ioaddr + 0xA7
112 #define byPwrcsrClr                     ioaddr + 0xAC
113
114 /*---------------------  Exioaddr Definitions -------------------------*/
115
116 /*
117  * Bits in the RCR register
118  */
119
120 #define RCR_RRFT2               0x80
121 #define RCR_RRFT1               0x40
122 #define RCR_RRFT0               0x20
123 #define RCR_PROM                0x10
124 #define RCR_AB                  0x08
125 #define RCR_AM                  0x04
126 #define RCR_AR                  0x02
127 #define RCR_SEP                 0x01
128
129 /*
130  * Bits in the TCR register
131  */
132
133 #define TCR_RTSF                0x80
134 #define TCR_RTFT1               0x40
135 #define TCR_RTFT0               0x20
136 #define TCR_OFSET               0x08
137 #define TCR_LB1                 0x04    /* loopback[1] */
138 #define TCR_LB0                 0x02    /* loopback[0] */
139
140 /*
141  * Bits in the CR0 register
142  */
143
144 #define CR0_RDMD                0x40    /* rx descriptor polling demand */
145 #define CR0_TDMD                0x20    /* tx descriptor polling demand */
146 #define CR0_TXON                0x10
147 #define CR0_RXON                0x08
148 #define CR0_STOP                0x04    /* stop NIC, default = 1 */
149 #define CR0_STRT                0x02    /* start NIC */
150 #define CR0_INIT                0x01    /* start init process */
151
152
153 /*
154  * Bits in the CR1 register
155  */
156
157 #define CR1_SFRST               0x80    /* software reset */
158 #define CR1_RDMD1               0x40    /* RDMD1 */
159 #define CR1_TDMD1               0x20    /* TDMD1 */
160 #define CR1_KEYPAG              0x10    /* turn on par/key */
161 #define CR1_DPOLL               0x08    /* disable rx/tx auto polling */
162 #define CR1_FDX                 0x04    /* full duplex mode */
163 #define CR1_ETEN                0x02    /* early tx mode */
164 #define CR1_EREN                0x01    /* early rx mode */
165
166 /*
167  * Bits in the CR register
168  */
169
170 #define CR_RDMD                 0x0040  /* rx descriptor polling demand */
171 #define CR_TDMD                 0x0020  /* tx descriptor polling demand */
172 #define CR_TXON                 0x0010
173 #define CR_RXON                 0x0008
174 #define CR_STOP                 0x0004  /* stop NIC, default = 1 */
175 #define CR_STRT                 0x0002  /* start NIC */
176 #define CR_INIT                 0x0001  /* start init process */
177 #define CR_SFRST                0x8000  /* software reset */
178 #define CR_RDMD1                0x4000  /* RDMD1 */
179 #define CR_TDMD1                0x2000  /* TDMD1 */
180 #define CR_KEYPAG               0x1000  /* turn on par/key */
181 #define CR_DPOLL                0x0800  /* disable rx/tx auto polling */
182 #define CR_FDX                  0x0400  /* full duplex mode */
183 #define CR_ETEN                 0x0200  /* early tx mode */
184 #define CR_EREN                 0x0100  /* early rx mode */
185
186 /*
187  * Bits in the IMR0 register
188  */
189
190 #define IMR0_CNTM               0x80
191 #define IMR0_BEM                0x40
192 #define IMR0_RUM                0x20
193 #define IMR0_TUM                0x10
194 #define IMR0_TXEM               0x08
195 #define IMR0_RXEM               0x04
196 #define IMR0_PTXM               0x02
197 #define IMR0_PRXM               0x01
198
199 /* define imrshadow */
200
201 #define IMRShadow               0x5AFF
202
203 /*
204  * Bits in the IMR1 register
205  */
206
207 #define IMR1_INITM              0x80
208 #define IMR1_SRCM               0x40
209 #define IMR1_NBFM               0x10
210 #define IMR1_PRAIM              0x08
211 #define IMR1_RES0M              0x04
212 #define IMR1_ETM                0x02
213 #define IMR1_ERM                0x01
214
215 /*
216  * Bits in the ISR register
217  */
218
219 #define ISR_INITI               0x8000
220 #define ISR_SRCI                0x4000
221 #define ISR_ABTI                0x2000
222 #define ISR_NORBF               0x1000
223 #define ISR_PKTRA               0x0800
224 #define ISR_RES0                0x0400
225 #define ISR_ETI                 0x0200
226 #define ISR_ERI                 0x0100
227 #define ISR_CNT                 0x0080
228 #define ISR_BE                  0x0040
229 #define ISR_RU                  0x0020
230 #define ISR_TU                  0x0010
231 #define ISR_TXE                 0x0008
232 #define ISR_RXE                 0x0004
233 #define ISR_PTX                 0x0002
234 #define ISR_PRX                 0x0001
235
236 /*
237  * Bits in the ISR0 register
238  */
239
240 #define ISR0_CNT                0x80
241 #define ISR0_BE                 0x40
242 #define ISR0_RU                 0x20
243 #define ISR0_TU                 0x10
244 #define ISR0_TXE                0x08
245 #define ISR0_RXE                0x04
246 #define ISR0_PTX                0x02
247 #define ISR0_PRX                0x01
248
249 /*
250  * Bits in the ISR1 register
251  */
252
253 #define ISR1_INITI              0x80
254 #define ISR1_SRCI               0x40
255 #define ISR1_NORBF              0x10
256 #define ISR1_PKTRA              0x08
257 #define ISR1_ETI                0x02
258 #define ISR1_ERI                0x01
259
260 /* ISR ABNORMAL CONDITION */
261
262 #define ISR_ABNORMAL ISR_BE+ISR_RU+ISR_TU+ISR_CNT+ISR_NORBF+ISR_PKTRA
263
264 /*
265  * Bits in the MIISR register
266  */
267
268 #define MIISR_MIIERR            0x08
269 #define MIISR_MRERR             0x04
270 #define MIISR_LNKFL             0x02
271 #define MIISR_SPEED             0x01
272
273 /*
274  * Bits in the MIICR register
275  */
276
277 #define MIICR_MAUTO             0x80
278 #define MIICR_RCMD              0x40
279 #define MIICR_WCMD              0x20
280 #define MIICR_MDPM              0x10
281 #define MIICR_MOUT              0x08
282 #define MIICR_MDO               0x04
283 #define MIICR_MDI               0x02
284 #define MIICR_MDC               0x01
285
286 /*
287  * Bits in the EECSR register
288  */
289
290 #define EECSR_EEPR              0x80    /* eeprom programed status, 73h means programed */
291 #define EECSR_EMBP              0x40    /* eeprom embeded programming */
292 #define EECSR_AUTOLD            0x20    /* eeprom content reload */
293 #define EECSR_DPM               0x10    /* eeprom direct programming */
294 #define EECSR_CS                0x08    /* eeprom CS pin */
295 #define EECSR_SK                0x04    /* eeprom SK pin */
296 #define EECSR_DI                0x02    /* eeprom DI pin */
297 #define EECSR_DO                0x01    /* eeprom DO pin */
298
299 /*
300  * Bits in the BCR0 register
301  */
302
303 #define BCR0_CRFT2              0x20
304 #define BCR0_CRFT1              0x10
305 #define BCR0_CRFT0              0x08
306 #define BCR0_DMAL2              0x04
307 #define BCR0_DMAL1              0x02
308 #define BCR0_DMAL0              0x01
309
310 /*
311  * Bits in the BCR1 register
312  */
313
314 #define BCR1_CTSF               0x20
315 #define BCR1_CTFT1              0x10
316 #define BCR1_CTFT0              0x08
317 #define BCR1_POT2               0x04
318 #define BCR1_POT1               0x02
319 #define BCR1_POT0               0x01
320
321 /*
322  * Bits in the CFGA register
323  */
324
325 #define CFGA_EELOAD             0x80    /* enable eeprom embeded and direct programming */
326 #define CFGA_JUMPER             0x40
327 #define CFGA_MTGPIO             0x08
328 #define CFGA_T10EN              0x02
329 #define CFGA_AUTO               0x01
330
331 /*
332  * Bits in the CFGB register
333  */
334
335 #define CFGB_PD                 0x80
336 #define CFGB_POLEN              0x02
337 #define CFGB_LNKEN              0x01
338
339 /*
340  * Bits in the CFGC register
341  */
342
343 #define CFGC_M10TIO             0x80
344 #define CFGC_M10POL             0x40
345 #define CFGC_PHY1               0x20
346 #define CFGC_PHY0               0x10
347 #define CFGC_BTSEL              0x08
348 #define CFGC_BPS2               0x04    /* bootrom select[2] */
349 #define CFGC_BPS1               0x02    /* bootrom select[1] */
350 #define CFGC_BPS0               0x01    /* bootrom select[0] */
351
352 /*
353  * Bits in the CFGD register
354  */
355
356 #define CFGD_GPIOEN             0x80
357 #define CFGD_DIAG               0x40
358 #define CFGD_MAGIC              0x10
359 #define CFGD_RANDOM             0x08
360 #define CFGD_CFDX               0x04
361 #define CFGD_CEREN              0x02
362 #define CFGD_CETEN              0x01
363
364 /* Bits in RSR */
365 #define RSR_RERR                0x00000001
366 #define RSR_CRC                 0x00000002
367 #define RSR_FAE                 0x00000004
368 #define RSR_FOV                 0x00000008
369 #define RSR_LONG                0x00000010
370 #define RSR_RUNT                0x00000020
371 #define RSR_SERR                0x00000040
372 #define RSR_BUFF                0x00000080
373 #define RSR_EDP                 0x00000100
374 #define RSR_STP                 0x00000200
375 #define RSR_CHN                 0x00000400
376 #define RSR_PHY                 0x00000800
377 #define RSR_BAR                 0x00001000
378 #define RSR_MAR                 0x00002000
379 #define RSR_RXOK                0x00008000
380 #define RSR_ABNORMAL            RSR_RERR+RSR_LONG+RSR_RUNT
381
382 /* Bits in TSR */
383 #define TSR_NCR0                0x00000001
384 #define TSR_NCR1                0x00000002
385 #define TSR_NCR2                0x00000004
386 #define TSR_NCR3                0x00000008
387 #define TSR_COLS                0x00000010
388 #define TSR_CDH                 0x00000080
389 #define TSR_ABT                 0x00000100
390 #define TSR_OWC                 0x00000200
391 #define TSR_CRS                 0x00000400
392 #define TSR_UDF                 0x00000800
393 #define TSR_TBUFF               0x00001000
394 #define TSR_SERR                0x00002000
395 #define TSR_JAB                 0x00004000
396 #define TSR_TERR                0x00008000
397 #define TSR_ABNORMAL            TSR_TERR+TSR_OWC+TSR_ABT+TSR_JAB+TSR_CRS
398 #define TSR_OWN_BIT             0x80000000
399
400 #define CB_DELAY_LOOP_WAIT      10      /* 10ms */
401 /* enabled mask value of irq */
402
403 #define W_IMR_MASK_VALUE        0x1BFF  /* initial value of IMR */
404
405 /* Ethernet address filter type */
406 #define PKT_TYPE_DIRECTED       0x0001  /* obsolete, directed address is always accepted */
407 #define PKT_TYPE_MULTICAST      0x0002
408 #define PKT_TYPE_ALL_MULTICAST  0x0004
409 #define PKT_TYPE_BROADCAST      0x0008
410 #define PKT_TYPE_PROMISCUOUS    0x0020
411 #define PKT_TYPE_LONG           0x2000
412 #define PKT_TYPE_RUNT           0x4000
413 #define PKT_TYPE_ERROR          0x8000  /* accept error packets, e.g. CRC error */
414
415 /* Loopback mode */
416
417 #define NIC_LB_NONE             0x00
418 #define NIC_LB_INTERNAL         0x01
419 #define NIC_LB_PHY              0x02    /* MII or Internal-10BaseT loopback */
420
421 #define TX_RING_SIZE            2
422 #define RX_RING_SIZE            2
423 #define PKT_BUF_SZ              1536    /* Size of each temporary Rx buffer. */
424
425 #define PCI_REG_MODE3           0x53
426 #define MODE3_MIION             0x04    /* in PCI_REG_MOD3 OF PCI space */
427
428 enum rhine_revs {
429     VT86C100A       = 0x00,
430     VTunknown0      = 0x20,
431     VT6102          = 0x40,
432     VT8231          = 0x50, /* Integrated MAC */
433     VT8233          = 0x60, /* Integrated MAC */
434     VT8235          = 0x74, /* Integrated MAC */
435     VT8237          = 0x78, /* Integrated MAC */
436     VTunknown1      = 0x7C,
437     VT6105          = 0x80,
438     VT6105_B0       = 0x83,
439     VT6105L         = 0x8A,
440     VT6107          = 0x8C,
441     VTunknown2      = 0x8E,
442     VT6105M         = 0x90,
443 };
444
445 /* Transmit and receive descriptors definition */
446
447 struct rhine_tx_desc
448 {
449     union VTC_tx_status_tag
450     {
451         struct
452         {
453             unsigned long ncro:1;
454             unsigned long ncr1:1;
455             unsigned long ncr2:1;
456             unsigned long ncr3:1;
457             unsigned long cols:1;
458             unsigned long reserve_1:2;
459             unsigned long cdh:1;
460             unsigned long abt:1;
461             unsigned long owc:1;
462             unsigned long crs:1;
463             unsigned long udf:1;
464             unsigned long tbuff:1;
465             unsigned long serr:1;
466             unsigned long jab:1;
467             unsigned long terr:1;
468             unsigned long reserve_2:15;
469             unsigned long own_bit:1;
470         }
471         bits;
472         unsigned long lw;
473     }
474     tx_status;
475
476     union VTC_tx_ctrl_tag
477     {
478         struct
479         {
480             unsigned long tx_buf_size:11;
481             unsigned long extend_tx_buf_size:4;
482             unsigned long chn:1;
483             unsigned long crc:1;
484             unsigned long reserve_1:4;
485             unsigned long stp:1;
486             unsigned long edp:1;
487             unsigned long ic:1;
488             unsigned long reserve_2:8;
489         }
490         bits;
491         unsigned long lw;
492     }
493     tx_ctrl;
494
495     unsigned long buf_addr_1:32;
496     unsigned long buf_addr_2:32;
497
498 };
499
500 struct rhine_rx_desc
501 {
502     union VTC_rx_status_tag
503     {
504         struct
505         {
506             unsigned long rerr:1;
507             unsigned long crc_error:1;
508             unsigned long fae:1;
509             unsigned long fov:1;
510             unsigned long toolong:1;
511             unsigned long runt:1;
512             unsigned long serr:1;
513             unsigned long buff:1;
514             unsigned long edp:1;
515             unsigned long stp:1;
516             unsigned long chn:1;
517             unsigned long phy:1;
518             unsigned long bar:1;
519             unsigned long mar:1;
520             unsigned long reserve_1:1;
521             unsigned long rxok:1;
522             unsigned long frame_length:11;
523             unsigned long reverve_2:4;
524             unsigned long own_bit:1;
525         }
526         bits;
527         unsigned long lw;
528     }
529     rx_status;
530
531     union VTC_rx_ctrl_tag
532     {
533         struct
534         {
535             unsigned long rx_buf_size:11;
536             unsigned long extend_rx_buf_size:4;
537             unsigned long reserved_1:17;
538         }
539         bits;
540         unsigned long lw;
541     }
542     rx_ctrl;
543
544     unsigned long buf_addr_1:32;
545     unsigned long buf_addr_2:32;
546
547 };
548
549 struct {
550         char txbuf[TX_RING_SIZE * PKT_BUF_SZ + 32];
551         char rxbuf[RX_RING_SIZE * PKT_BUF_SZ + 32];
552         char txdesc[TX_RING_SIZE * sizeof (struct rhine_tx_desc) + 32];
553         char rxdesc[RX_RING_SIZE * sizeof (struct rhine_rx_desc) + 32];
554 } rhine_buffers __shared;
555
556 /* The I/O extent. */
557 #define rhine_TOTAL_SIZE 0x80
558
559 #ifdef  HAVE_DEVLIST
560 struct netdev_entry rhine_drv =
561     { "rhine", rhine_probe, rhine_TOTAL_SIZE, NULL };
562 #endif
563
564 static int rhine_debug = 1;
565
566 /*
567                                 Theory of Operation
568
569 I. Board Compatibility
570
571 This driver is designed for the VIA 86c100A Rhine-II PCI Fast Ethernet
572 controller.
573
574 II. Board-specific settings
575
576 Boards with this chip are functional only in a bus-master PCI slot.
577
578 Many operational settings are loaded from the EEPROM to the Config word at
579 offset 0x78.  This driver assumes that they are correct.
580 If this driver is compiled to use PCI memory space operations the EEPROM
581 must be configured to enable memory ops.
582
583 III. Driver operation
584
585 IIIa. Ring buffers
586
587 This driver uses two statically allocated fixed-size descriptor lists
588 formed into rings by a branch from the final descriptor to the beginning of
589 the list.  The ring sizes are set at compile time by RX/TX_RING_SIZE.
590
591 IIIb/c. Transmit/Receive Structure
592
593 This driver attempts to use a zero-copy receive and transmit scheme.
594
595 Alas, all data buffers are required to start on a 32 bit boundary, so
596 the driver must often copy transmit packets into bounce buffers.
597
598 The driver allocates full frame size skbuffs for the Rx ring buffers at
599 open() time and passes the skb->data field to the chip as receive data
600 buffers.  When an incoming frame is less than RX_COPYBREAK bytes long,
601 a fresh skbuff is allocated and the frame is copied to the new skbuff.
602 When the incoming frame is larger, the skbuff is passed directly up the
603 protocol stack.  Buffers consumed this way are replaced by newly allocated
604 skbuffs in the last phase of netdev_rx().
605
606 The RX_COPYBREAK value is chosen to trade-off the memory wasted by
607 using a full-sized skbuff for small frames vs. the copying costs of larger
608 frames.  New boards are typically used in generously configured machines
609 and the underfilled buffers have negligible impact compared to the benefit of
610 a single allocation size, so the default value of zero results in never
611 copying packets.  When copying is done, the cost is usually mitigated by using
612 a combined copy/checksum routine.  Copying also preloads the cache, which is
613 most useful with small frames.
614
615 Since the VIA chips are only able to transfer data to buffers on 32 bit
616 boundaries, the the IP header at offset 14 in an ethernet frame isn't
617 longword aligned for further processing.  Copying these unaligned buffers
618 has the beneficial effect of 16-byte aligning the IP header.
619
620 IIId. Synchronization
621
622 The driver runs as two independent, single-threaded flows of control.  One
623 is the send-packet routine, which enforces single-threaded use by the
624 dev->tbusy flag.  The other thread is the interrupt handler, which is single
625 threaded by the hardware and interrupt handling software.
626
627 The send packet thread has partial control over the Tx ring and 'dev->tbusy'
628 flag.  It sets the tbusy flag whenever it's queuing a Tx packet. If the next
629 queue slot is empty, it clears the tbusy flag when finished otherwise it sets
630 the 'lp->tx_full' flag.
631
632 The interrupt handler has exclusive control over the Rx ring and records stats
633 from the Tx ring.  After reaping the stats, it marks the Tx queue entry as
634 empty by incrementing the dirty_tx mark. Iff the 'lp->tx_full' flag is set, it
635 clears both the tx_full and tbusy flags.
636
637 IV. Notes
638
639 IVb. References
640
641 Preliminary VT86C100A manual from http://www.via.com.tw/
642 http://cesdis.gsfc.nasa.gov/linux/misc/100mbps.html
643 http://cesdis.gsfc.nasa.gov/linux/misc/NWay.html
644
645 IVc. Errata
646
647 The VT86C100A manual is not reliable information.
648 The chip does not handle unaligned transmit or receive buffers, resulting
649 in significant performance degradation for bounce buffer copies on transmit
650 and unaligned IP headers on receive.
651 The chip does not pad to minimum transmit length.
652
653 */
654
655 /* The rest of these values should never change. */
656 #define NUM_TX_DESC     2       /* Number of Tx descriptor registers. */
657
658 static struct rhine_private
659 {
660     char devname[8];            /* Used only for kernel debugging. */
661     const char *product_name;
662     struct rhine_rx_desc *rx_ring;
663     struct rhine_tx_desc *tx_ring;
664     char *rx_buffs[RX_RING_SIZE];
665     char *tx_buffs[TX_RING_SIZE];
666
667     /* temporary Rx buffers. */
668
669     int chip_id;
670     int chip_revision;
671     unsigned short ioaddr;
672     unsigned int cur_rx, cur_tx;        /* The next free and used entries */
673     unsigned int dirty_rx, dirty_tx;
674     /* The saved address of a sent-in-place packet/buffer, for skfree(). */
675     struct sk_buff *tx_skbuff[TX_RING_SIZE];
676     unsigned char mc_filter[8]; /* Current multicast filter. */
677     char phys[4];               /* MII device addresses. */
678     unsigned int tx_full:1;     /* The Tx queue is full. */
679     unsigned int full_duplex:1; /* Full-duplex operation requested. */
680     unsigned int default_port:4;        /* Last dev->if_port value. */
681     unsigned int media2:4;      /* Secondary monitored media port. */
682     unsigned int medialock:1;   /* Don't sense media type. */
683     unsigned int mediasense:1;  /* Media sensing in progress. */
684 }
685 rhine;
686
687 static void rhine_probe1 (struct nic *nic, struct pci_device *pci, int ioaddr,
688                                  int chip_id, int options);
689 static int QueryAuto (int);
690 static int ReadMII (int byMIIIndex, int);
691 static void WriteMII (char, char, char, int);
692 static void MIIDelay (void);
693 static void rhine_init_ring (struct nic *dev);
694 static void rhine_disable (struct nic *nic, struct pci_device *pci);
695 static void rhine_reset (struct nic *nic);
696 static int rhine_poll (struct nic *nic, int retreive);
697 static void rhine_transmit (struct nic *nic, const char *d, unsigned int t,
698                             unsigned int s, const char *p);
699 static void reload_eeprom(int ioaddr);
700
701
702 static void reload_eeprom(int ioaddr)
703 {
704         int i;
705         outb(0x20, byEECSR);
706         /* Typically 2 cycles to reload. */
707         for (i = 0; i < 150; i++)
708                 if (! (inb(byEECSR) & 0x20))
709                         break;
710 }
711 /* Initialize the Rx and Tx rings, along with various 'dev' bits. */
712 static void
713 rhine_init_ring (struct nic *nic)
714 {
715     struct rhine_private *tp = (struct rhine_private *) nic->priv_data;
716     int i;
717
718     tp->tx_full = 0;
719     tp->cur_rx = tp->cur_tx = 0;
720     tp->dirty_rx = tp->dirty_tx = 0;
721
722     for (i = 0; i < RX_RING_SIZE; i++)
723     {
724
725         tp->rx_ring[i].rx_status.bits.own_bit = 1;
726         tp->rx_ring[i].rx_ctrl.bits.rx_buf_size = 1536;
727
728         tp->rx_ring[i].buf_addr_1 = virt_to_bus (tp->rx_buffs[i]);
729         tp->rx_ring[i].buf_addr_2 = virt_to_bus (&tp->rx_ring[i + 1]);
730         /* printf("[%d]buf1=%hX,buf2=%hX",i,tp->rx_ring[i].buf_addr_1,tp->rx_ring[i].buf_addr_2); */
731     }
732     /* Mark the last entry as wrapping the ring. */
733     /* tp->rx_ring[i-1].rx_ctrl.bits.rx_buf_size =1518; */
734     tp->rx_ring[i - 1].buf_addr_2 = virt_to_bus (&tp->rx_ring[0]);
735     /*printf("[%d]buf1=%hX,buf2=%hX",i-1,tp->rx_ring[i-1].buf_addr_1,tp->rx_ring[i-1].buf_addr_2); */
736
737     /* The Tx buffer descriptor is filled in as needed, but we
738        do need to clear the ownership bit. */
739
740     for (i = 0; i < TX_RING_SIZE; i++)
741     {
742
743         tp->tx_ring[i].tx_status.lw = 0;
744         tp->tx_ring[i].tx_ctrl.lw = 0x00e08000;
745         tp->tx_ring[i].buf_addr_1 = virt_to_bus (tp->tx_buffs[i]);
746         tp->tx_ring[i].buf_addr_2 = virt_to_bus (&tp->tx_ring[i + 1]);
747         /* printf("[%d]buf1=%hX,buf2=%hX",i,tp->tx_ring[i].buf_addr_1,tp->tx_ring[i].buf_addr_2); */
748     }
749
750     tp->tx_ring[i - 1].buf_addr_2 = virt_to_bus (&tp->tx_ring[0]);
751     /* printf("[%d]buf1=%hX,buf2=%hX",i,tp->tx_ring[i-1].buf_addr_1,tp->tx_ring[i-1].buf_addr_2); */
752 }
753
754 int
755 QueryAuto (int ioaddr)
756 {
757     int byMIIIndex;
758     int MIIReturn;
759
760         int advertising,mii_reg5;
761         int negociated;
762
763     byMIIIndex = 0x04;
764     MIIReturn = ReadMII (byMIIIndex, ioaddr);
765         advertising=MIIReturn;
766
767     byMIIIndex = 0x05;
768     MIIReturn = ReadMII (byMIIIndex, ioaddr);
769         mii_reg5=MIIReturn;
770
771         negociated=mii_reg5 & advertising;
772
773         if ( (negociated & 0x100) || (negociated & 0x1C0) == 0x40 )
774                 return 1;
775         else
776                 return 0;
777
778 }
779
780 int
781 ReadMII (int byMIIIndex, int ioaddr)
782 {
783     int ReturnMII;
784     char byMIIAdrbak;
785     char byMIICRbak;
786     char byMIItemp;
787
788     byMIIAdrbak = inb (byMIIAD);
789     byMIICRbak = inb (byMIICR);
790     outb (byMIICRbak & 0x7f, byMIICR);
791     MIIDelay ();
792
793     outb (byMIIIndex, byMIIAD);
794     MIIDelay ();
795
796     outb (inb (byMIICR) | 0x40, byMIICR);
797
798     byMIItemp = inb (byMIICR);
799     byMIItemp = byMIItemp & 0x40;
800
801     load_timer2(2*TICKS_PER_MS);
802     while (byMIItemp != 0 && timer2_running())
803     {
804         byMIItemp = inb (byMIICR);
805         byMIItemp = byMIItemp & 0x40;
806     }
807     MIIDelay ();
808
809     ReturnMII = inw (wMIIDATA);
810
811     outb (byMIIAdrbak, byMIIAD);
812     outb (byMIICRbak, byMIICR);
813     MIIDelay ();
814
815     return (ReturnMII);
816
817 }
818
819 void
820 WriteMII (char byMIISetByte, char byMIISetBit, char byMIIOP, int ioaddr)
821 {
822     int ReadMIItmp;
823     int MIIMask;
824     char byMIIAdrbak;
825     char byMIICRbak;
826     char byMIItemp;
827
828
829     byMIIAdrbak = inb (byMIIAD);
830
831     byMIICRbak = inb (byMIICR);
832     outb (byMIICRbak & 0x7f, byMIICR);
833     MIIDelay ();
834     outb (byMIISetByte, byMIIAD);
835     MIIDelay ();
836
837     outb (inb (byMIICR) | 0x40, byMIICR);
838
839     byMIItemp = inb (byMIICR);
840     byMIItemp = byMIItemp & 0x40;
841
842     load_timer2(2*TICKS_PER_MS);
843     while (byMIItemp != 0 && timer2_running())
844     {
845         byMIItemp = inb (byMIICR);
846         byMIItemp = byMIItemp & 0x40;
847     }
848     MIIDelay ();
849
850     ReadMIItmp = inw (wMIIDATA);
851     MIIMask = 0x0001;
852     MIIMask = MIIMask << byMIISetBit;
853
854
855     if (byMIIOP == 0)
856     {
857         MIIMask = ~MIIMask;
858         ReadMIItmp = ReadMIItmp & MIIMask;
859     }
860     else
861     {
862         ReadMIItmp = ReadMIItmp | MIIMask;
863
864     }
865     outw (ReadMIItmp, wMIIDATA);
866     MIIDelay ();
867
868     outb (inb (byMIICR) | 0x20, byMIICR);
869     byMIItemp = inb (byMIICR);
870     byMIItemp = byMIItemp & 0x20;
871
872     load_timer2(2*TICKS_PER_MS);
873     while (byMIItemp != 0 && timer2_running())
874     {
875         byMIItemp = inb (byMIICR);
876         byMIItemp = byMIItemp & 0x20;
877     }
878     MIIDelay ();
879
880     outb (byMIIAdrbak & 0x7f, byMIIAD);
881     outb (byMIICRbak, byMIICR);
882     MIIDelay ();
883
884 }
885
886 void
887 MIIDelay (void)
888 {
889     int i;
890     for (i = 0; i < 0x7fff; i++)
891     {
892         inb (0x61);
893         inb (0x61);
894         inb (0x61);
895         inb (0x61);
896     }
897 }
898
899 /* Offsets to the device registers. */
900 enum register_offsets {
901         StationAddr=0x00, RxConfig=0x06, TxConfig=0x07, ChipCmd=0x08,
902         IntrStatus=0x0C, IntrEnable=0x0E,
903         MulticastFilter0=0x10, MulticastFilter1=0x14,
904         RxRingPtr=0x18, TxRingPtr=0x1C, GFIFOTest=0x54,
905         MIIPhyAddr=0x6C, MIIStatus=0x6D, PCIBusConfig=0x6E,
906         MIICmd=0x70, MIIRegAddr=0x71, MIIData=0x72, MACRegEEcsr=0x74,
907         ConfigA=0x78, ConfigB=0x79, ConfigC=0x7A, ConfigD=0x7B,
908         RxMissed=0x7C, RxCRCErrs=0x7E, MiscCmd=0x81,
909         StickyHW=0x83, IntrStatus2=0x84, WOLcrClr=0xA4, WOLcgClr=0xA7,
910         PwrcsrClr=0xAC,
911 };
912
913 /* Bits in the interrupt status/mask registers. */
914 enum intr_status_bits {
915         IntrRxDone=0x0001, IntrRxErr=0x0004, IntrRxEmpty=0x0020,
916         IntrTxDone=0x0002, IntrTxError=0x0008, IntrTxUnderrun=0x0210,
917         IntrPCIErr=0x0040,
918         IntrStatsMax=0x0080, IntrRxEarly=0x0100,
919         IntrRxOverflow=0x0400, IntrRxDropped=0x0800, IntrRxNoBuf=0x1000,
920         IntrTxAborted=0x2000, IntrLinkChange=0x4000,
921         IntrRxWakeUp=0x8000,
922         IntrNormalSummary=0x0003, IntrAbnormalSummary=0xC260,
923         IntrTxDescRace=0x080000,        /* mapped from IntrStatus2 */
924         IntrTxErrSummary=0x082218,
925 };
926 #define DEFAULT_INTR (IntrRxDone | IntrRxErr | IntrRxEmpty| IntrRxOverflow | \
927                    IntrRxDropped | IntrRxNoBuf) 
928
929 /***************************************************************************
930  IRQ - PXE IRQ Handler
931 ***************************************************************************/
932 void rhine_irq ( struct nic *nic, irq_action_t action ) {
933     struct rhine_private *tp = (struct rhine_private *) nic->priv_data;
934     /* Enable interrupts by setting the interrupt mask. */
935     unsigned int intr_status;
936
937     switch ( action ) {
938         case DISABLE :
939         case ENABLE :
940             intr_status = inw(nic->ioaddr + IntrStatus);
941             /* On Rhine-II, Bit 3 indicates Tx descriptor write-back race. */
942
943             /* added comment by guard */
944             /* For supporting VT6107, please use revision id to recognize different chips in driver */
945             // if (tp->chip_id == 0x3065)
946             if( tp->chip_revision < 0x80 && tp->chip_revision >=0x40 )
947                 intr_status |= inb(nic->ioaddr + IntrStatus2) << 16;
948                 intr_status = (intr_status & ~DEFAULT_INTR);
949                 if ( action == ENABLE ) 
950                     intr_status = intr_status | DEFAULT_INTR;
951                     outw(intr_status, nic->ioaddr + IntrEnable);
952                 break;
953         case FORCE :
954             outw(0x0010, nic->ioaddr + 0x84);
955            break;
956         }
957 }
958
959 static struct nic_operations rhine_operations;
960
961 static int
962 rhine_probe ( struct nic *nic, struct pci_device *pci ) {
963
964     struct rhine_private *tp = (struct rhine_private *) nic->priv_data;
965
966     if (!pci->ioaddr)
967         return 0;
968     rhine_probe1 (nic, pci, pci->ioaddr, pci->device, -1);
969
970     adjust_pci_device ( pci );
971     rhine_reset (nic);
972     nic->nic_op = &rhine_operations;
973     pci_fill_nic ( nic, pci );
974     nic->irqno    = pci->irq;
975     nic->ioaddr   = tp->ioaddr;
976     return 1;
977 }
978
979 static void set_rx_mode(struct nic *nic __unused) {
980         struct rhine_private *tp = (struct rhine_private *) nic->priv_data;
981         unsigned char rx_mode;
982         int ioaddr = tp->ioaddr;
983
984         /* ! IFF_PROMISC */
985         outl(0xffffffff, byMAR0);
986         outl(0xffffffff, byMAR4);
987         rx_mode = 0x0C;
988
989         outb(0x60 /* thresh */ | rx_mode, byRCR );
990 }
991
992 static void
993 rhine_probe1 (struct nic *nic, struct pci_device *pci, int ioaddr, int chip_id, int options)
994 {
995     struct rhine_private *tp;
996     static int did_version = 0; /* Already printed version info. */
997     unsigned int i, ww;
998     unsigned int timeout;
999     int FDXFlag;
1000     int byMIIvalue, LineSpeed, MIICRbak;
1001     uint8_t revision_id;    
1002     unsigned char mode3_reg;
1003
1004     if (rhine_debug > 0 && did_version++ == 0)
1005         printf (version);
1006
1007     // get revision id.
1008     pci_read_config_byte(pci, PCI_REVISION, &revision_id);
1009
1010     /* D-Link provided reset code (with comment additions) */
1011     if (revision_id >= 0x40) {
1012         unsigned char byOrgValue;
1013         
1014         if(rhine_debug > 0)
1015                 printf("Enabling Sticky Bit Workaround for Chip_id: 0x%hX\n"
1016                                 , chip_id);
1017         /* clear sticky bit before reset & read ethernet address */
1018         byOrgValue = inb(bySTICKHW);
1019         byOrgValue = byOrgValue & 0xFC;
1020         outb(byOrgValue, bySTICKHW);
1021
1022         /* (bits written are cleared?) */
1023         /* disable force PME-enable */
1024         outb(0x80, byWOLcgClr);
1025         /* disable power-event config bit */
1026         outb(0xFF, byWOLcrClr);
1027         /* clear power status (undocumented in vt6102 docs?) */
1028         outb(0xFF, byPwrcsrClr);
1029         
1030     }
1031
1032     /* Reset the chip to erase previous misconfiguration. */
1033     outw(CR_SFRST, byCR0);
1034     // if vt3043 delay after reset
1035     if (revision_id <0x40) {
1036        udelay(10000);
1037     }
1038     // polling till software reset complete
1039     // W_MAX_TIMEOUT is the timeout period
1040     for(ww = 0; ww < W_MAX_TIMEOUT; ww++) {
1041         if ((inw(byCR0) & CR_SFRST) == 0)
1042                 break;
1043         }
1044
1045     // issue AUTOLoad in EECSR to reload eeprom
1046     outb(0x20, byEECSR );
1047
1048     // if vt3065 delay after reset
1049     if (revision_id >=0x40) {
1050         // delay 8ms to let MAC stable
1051         mdelay(8);
1052         /*
1053          * for 3065D, EEPROM reloaded will cause bit 0 in MAC_REG_CFGA
1054          * turned on.  it makes MAC receive magic packet
1055          * automatically. So, we turn it off. (D-Link)
1056          */
1057          outb(inb(byCFGA) & 0xFE, byCFGA);
1058     }
1059
1060     /* turn on bit2 in PCI configuration register 0x53 , only for 3065*/
1061     if (revision_id >= 0x40) {
1062         pci_read_config_byte(pci, PCI_REG_MODE3, &mode3_reg);
1063         pci_write_config_byte(pci, PCI_REG_MODE3, mode3_reg|MODE3_MIION);
1064     }
1065
1066
1067     /* back off algorithm ,disable the right-most 4-bit off CFGD*/
1068     outb(inb(byCFGD) & (~(CFGD_RANDOM | CFGD_CFDX | CFGD_CEREN | CFGD_CETEN)), byCFGD);
1069
1070     /* reload eeprom */
1071     reload_eeprom(ioaddr);
1072
1073     /* Perhaps this should be read from the EEPROM? */
1074     for (i = 0; i < ETH_ALEN; i++)
1075         nic->node_addr[i] = inb (byPAR0 + i);
1076     printf ("IO address %hX Ethernet Address: %!\n", ioaddr, nic->node_addr);
1077
1078     /* restart MII auto-negotiation */
1079     WriteMII (0, 9, 1, ioaddr);
1080     printf ("Analyzing Media type,this will take several seconds........");
1081     for (i = 0; i < 5; i++)
1082     {
1083         /* need to wait 1 millisecond - we will round it up to 50-100ms */
1084         timeout = currticks() + 2;
1085         for (timeout = currticks() + 2; currticks() < timeout;)
1086             /* nothing */;
1087         if (ReadMII (1, ioaddr) & 0x0020)
1088             break;
1089     }
1090     printf ("OK\n");
1091
1092 #if     0
1093         /* JJM : for Debug */
1094         printf("MII : Address %hhX ",inb(ioaddr+0x6c));
1095         {
1096          unsigned char st1,st2,adv1,adv2,l1,l2;
1097         
1098          st1=ReadMII(1,ioaddr)>>8;
1099          st2=ReadMII(1,ioaddr)&0xFF;
1100          adv1=ReadMII(4,ioaddr)>>8;
1101          adv2=ReadMII(4,ioaddr)&0xFF;
1102          l1=ReadMII(5,ioaddr)>>8;
1103          l2=ReadMII(5,ioaddr)&0xFF;
1104          printf(" status 0x%hhX%hhX, advertising 0x%hhX%hhX, link 0x%hhX%hhX\n", st1,st2,adv1,adv2,l1,l2);
1105         }
1106 #endif
1107
1108     
1109     /* query MII to know LineSpeed,duplex mode */
1110     byMIIvalue = inb (ioaddr + 0x6d);
1111     LineSpeed = byMIIvalue & MIISR_SPEED;
1112     if (LineSpeed != 0)                                         //JJM
1113     {
1114         printf ("Linespeed=10Mbs");
1115     }
1116     else
1117     {
1118         printf ("Linespeed=100Mbs");
1119     }
1120         
1121     FDXFlag = QueryAuto (ioaddr);
1122     if (FDXFlag == 1)
1123     {
1124         printf (" Fullduplex\n");
1125         outw (CR_FDX, byCR0);
1126     }
1127     else
1128     {
1129         printf (" Halfduplex\n");
1130     }
1131
1132
1133     /* set MII 10 FULL ON, only apply in vt3043 */
1134     if(chip_id == 0x3043)
1135         WriteMII (0x17, 1, 1, ioaddr);
1136
1137     /* turn on MII link change */
1138     MIICRbak = inb (byMIICR);
1139     outb (MIICRbak & 0x7F, byMIICR);
1140     MIIDelay ();
1141     outb (0x41, byMIIAD);
1142     MIIDelay ();
1143
1144     /* while((inb(byMIIAD)&0x20)==0) ; */
1145     outb (MIICRbak | 0x80, byMIICR);
1146
1147     nic->priv_data = &rhine;
1148     tp = &rhine;
1149     tp->chip_id = chip_id;
1150     tp->ioaddr = ioaddr;
1151     tp->phys[0] = -1;
1152     tp->chip_revision = revision_id;
1153
1154     /* The lower four bits are the media type. */
1155     if (options > 0)
1156     {
1157         tp->full_duplex = (options & 16) ? 1 : 0;
1158         tp->default_port = options & 15;
1159         if (tp->default_port)
1160             tp->medialock = 1;
1161     }
1162     return;
1163 }
1164
1165 static void 
1166 rhine_disable ( struct nic *nic, struct pci_device *pci __unused ) {
1167
1168     struct rhine_private *tp = (struct rhine_private *) nic->priv_data;
1169     int ioaddr = tp->ioaddr;
1170
1171     /* merge reset and disable */
1172     rhine_reset(nic);
1173
1174     printf ("rhine disable\n");
1175     /* Switch to loopback mode to avoid hardware races. */
1176     writeb(0x60 | 0x01, byTCR);
1177     /* Stop the chip's Tx and Rx processes. */
1178     writew(CR_STOP, byCR0);
1179 }
1180
1181 /**************************************************************************
1182 ETH_RESET - Reset adapter
1183 ***************************************************************************/
1184 static void
1185 rhine_reset (struct nic *nic)
1186 {
1187     struct rhine_private *tp = (struct rhine_private *) nic->priv_data;
1188     int ioaddr = tp->ioaddr;
1189     int i, j;
1190     int FDXFlag, CRbak;
1191     int rx_ring_tmp, rx_ring_tmp1;
1192     int tx_ring_tmp, tx_ring_tmp1;
1193     int rx_bufs_tmp, rx_bufs_tmp1;
1194     int tx_bufs_tmp, tx_bufs_tmp1;
1195
1196     /* printf ("rhine_reset\n"); */
1197     /* Soft reset the chip. */
1198     /*outb(CmdReset, ioaddr + ChipCmd); */
1199
1200     tx_bufs_tmp = (int) rhine_buffers.txbuf;
1201     tx_ring_tmp = (int) rhine_buffers.txdesc;
1202     rx_bufs_tmp = (int) rhine_buffers.rxbuf;
1203     rx_ring_tmp = (int) rhine_buffers.rxdesc;
1204
1205     /* tune RD TD 32 byte alignment */
1206     rx_ring_tmp1 = (int) virt_to_bus ((char *) rx_ring_tmp);
1207     j = (rx_ring_tmp1 + 32) & (~0x1f);
1208     /* printf ("txring[%d]", j); */
1209     tp->rx_ring = (struct rhine_rx_desc *) bus_to_virt (j);
1210
1211     tx_ring_tmp1 = (int) virt_to_bus ((char *) tx_ring_tmp);
1212     j = (tx_ring_tmp1 + 32) & (~0x1f);
1213     tp->tx_ring = (struct rhine_tx_desc *) bus_to_virt (j);
1214     /* printf ("rxring[%X]", j); */
1215
1216
1217     tx_bufs_tmp1 = (int) virt_to_bus ((char *) tx_bufs_tmp);
1218     j = (int) (tx_bufs_tmp1 + 32) & (~0x1f);
1219     tx_bufs_tmp = (int) bus_to_virt (j);
1220     /* printf ("txb[%X]", j); */
1221
1222     rx_bufs_tmp1 = (int) virt_to_bus ((char *) rx_bufs_tmp);
1223     j = (int) (rx_bufs_tmp1 + 32) & (~0x1f);
1224     rx_bufs_tmp = (int) bus_to_virt (j);
1225     /* printf ("rxb[%X][%X]", rx_bufs_tmp1, j); */
1226
1227     for (i = 0; i < RX_RING_SIZE; i++)
1228     {
1229         tp->rx_buffs[i] = (char *) rx_bufs_tmp;
1230         /* printf("r[%X]",tp->rx_buffs[i]); */
1231         rx_bufs_tmp += 1536;
1232     }
1233
1234     for (i = 0; i < TX_RING_SIZE; i++)
1235     {
1236         tp->tx_buffs[i] = (char *) tx_bufs_tmp;
1237         /* printf("t[%X]",tp->tx_buffs[i]);  */
1238         tx_bufs_tmp += 1536;
1239     }
1240
1241     /* software reset */
1242     outb (CR1_SFRST, byCR1);
1243     MIIDelay ();
1244
1245     /* printf ("init ring"); */
1246     rhine_init_ring (nic);
1247     /*write TD RD Descriptor to MAC */
1248     outl (virt_to_bus (tp->rx_ring), dwCurrentRxDescAddr);
1249     outl (virt_to_bus (tp->tx_ring), dwCurrentTxDescAddr);
1250
1251     /* Setup Multicast */       
1252     set_rx_mode(nic);
1253
1254     /* set TCR RCR threshold to store and forward*/
1255     outb (0x3e, byBCR0);
1256     outb (0x38, byBCR1);
1257     outb (0x2c, byRCR);
1258     outb (0x60, byTCR);
1259     /* Set Fulldupex */
1260     FDXFlag = QueryAuto (ioaddr);
1261     if (FDXFlag == 1)
1262     {
1263         outb (CFGD_CFDX, byCFGD);
1264         outw (CR_FDX, byCR0);
1265     }
1266
1267     /* KICK NIC to WORK */
1268     CRbak = inw (byCR0);
1269     CRbak = CRbak & 0xFFFB;     /* not CR_STOP */
1270     outw ((CRbak | CR_STRT | CR_TXON | CR_RXON | CR_DPOLL), byCR0);
1271
1272     /* disable all known interrupt */
1273     outw (0, byIMR0);
1274 }
1275 /* Beware of PCI posted writes */
1276 #define IOSYNC  do { readb(nic->ioaddr + StationAddr); } while (0)
1277
1278 static int
1279 rhine_poll (struct nic *nic, int retreive)
1280 {
1281     struct rhine_private *tp = (struct rhine_private *) nic->priv_data;
1282     int rxstatus, good = 0;;
1283
1284     if (tp->rx_ring[tp->cur_rx].rx_status.bits.own_bit == 0)
1285     {
1286         unsigned int intr_status;
1287         /* There is a packet ready */
1288         if(!retreive)
1289             return 1;
1290
1291         intr_status = inw(nic->ioaddr + IntrStatus);
1292         /* On Rhine-II, Bit 3 indicates Tx descriptor write-back race. */
1293 #if 0
1294         if (tp->chip_id == 0x3065)
1295           intr_status |= inb(nic->ioaddr + IntrStatus2) << 16;
1296 #endif
1297         /* Acknowledge all of the current interrupt sources ASAP. */
1298         if (intr_status & IntrTxDescRace)
1299            outb(0x08, nic->ioaddr + IntrStatus2);
1300         outw(intr_status & 0xffff, nic->ioaddr + IntrStatus);
1301         IOSYNC;
1302
1303         rxstatus = tp->rx_ring[tp->cur_rx].rx_status.lw;
1304         if ((rxstatus & 0x0300) != 0x0300)
1305         {
1306             printf("rhine_poll: bad status\n");
1307         }
1308         else if (rxstatus & (RSR_ABNORMAL))
1309         {
1310             printf ("rxerr[%X]\n", rxstatus);
1311         }
1312         else
1313             good = 1;
1314
1315         if (good)
1316         {
1317             nic->packetlen = tp->rx_ring[tp->cur_rx].rx_status.bits.frame_length;
1318             memcpy (nic->packet, tp->rx_buffs[tp->cur_rx], nic->packetlen);
1319             /* printf ("Packet RXed\n"); */
1320         }
1321         tp->rx_ring[tp->cur_rx].rx_status.bits.own_bit = 1;
1322         tp->cur_rx++;
1323         tp->cur_rx = tp->cur_rx % RX_RING_SIZE;
1324     }
1325         /* Acknowledge all of the current interrupt sources ASAP. */
1326         outw(DEFAULT_INTR & ~IntrRxDone, nic->ioaddr + IntrStatus);
1327
1328         IOSYNC;
1329
1330     return good;
1331 }
1332
1333 static void
1334 rhine_transmit (struct nic *nic,
1335                 const char *d, unsigned int t, unsigned int s, const char *p)
1336 {
1337     struct rhine_private *tp = (struct rhine_private *) nic->priv_data;
1338     int ioaddr = tp->ioaddr;
1339     int entry;
1340     unsigned char CR1bak;
1341     unsigned char CR0bak;
1342     unsigned int nstype;
1343
1344
1345     /*printf ("rhine_transmit\n"); */
1346     /* setup ethernet header */
1347
1348
1349     /* Calculate the next Tx descriptor entry. */
1350     entry = tp->cur_tx % TX_RING_SIZE;
1351
1352     memcpy (tp->tx_buffs[entry], d, ETH_ALEN);  /* dst */
1353     memcpy (tp->tx_buffs[entry] + ETH_ALEN, nic->node_addr, ETH_ALEN);  /* src */
1354     
1355     nstype=htons(t);
1356     memcpy(tp->tx_buffs[entry] + 2 * ETH_ALEN, (char*)&nstype, 2);
1357
1358     memcpy (tp->tx_buffs[entry] + ETH_HLEN, p, s);
1359     s += ETH_HLEN;
1360     while (s < ETH_ZLEN)
1361         *((char *) tp->tx_buffs[entry] + (s++)) = 0;
1362
1363     tp->tx_ring[entry].tx_ctrl.bits.tx_buf_size = s;
1364
1365     tp->tx_ring[entry].tx_status.bits.own_bit = 1;
1366
1367
1368     CR1bak = inb (byCR1);
1369
1370     CR1bak = CR1bak | CR1_TDMD1;
1371     /*printf("tdsw=[%X]",tp->tx_ring[entry].tx_status.lw); */
1372     /*printf("tdcw=[%X]",tp->tx_ring[entry].tx_ctrl.lw); */
1373     /*printf("tdbuf1=[%X]",tp->tx_ring[entry].buf_addr_1); */
1374     /*printf("tdbuf2=[%X]",tp->tx_ring[entry].buf_addr_2); */
1375     /*printf("td1=[%X]",inl(dwCurrentTDSE0)); */
1376     /*printf("td2=[%X]",inl(dwCurrentTDSE1)); */
1377     /*printf("td3=[%X]",inl(dwCurrentTDSE2)); */
1378     /*printf("td4=[%X]",inl(dwCurrentTDSE3)); */
1379
1380     outb (CR1bak, byCR1);
1381     do
1382     {
1383         load_timer2(10*TICKS_PER_MS);
1384         /* Wait until transmit is finished or timeout*/
1385         while((tp->tx_ring[entry].tx_status.bits.own_bit !=0) && timer2_running())
1386         ;
1387
1388         if(tp->tx_ring[entry].tx_status.bits.terr == 0)
1389             break;
1390
1391         if(tp->tx_ring[entry].tx_status.bits.abt == 1)
1392         {
1393             // turn on TX
1394             CR0bak = inb(byCR0);
1395             CR0bak = CR0bak|CR_TXON;
1396             outb(CR0bak,byCR0);
1397         }
1398     }while(0);
1399     tp->cur_tx++;
1400
1401     /*outw(IMRShadow,byIMR0); */
1402     /*dev_kfree_skb(tp->tx_skbuff[entry], FREE_WRITE); */
1403     /*tp->tx_skbuff[entry] = 0; */
1404 }
1405
1406 static struct nic_operations rhine_operations = {
1407         .connect        = dummy_connect,
1408         .poll           = rhine_poll,
1409         .transmit       = rhine_transmit,
1410         .irq            = rhine_irq,
1411
1412 };
1413
1414 static struct pci_device_id rhine_nics[] = {
1415 PCI_ROM(0x1106, 0x3065, "dlink-530tx",     "VIA 6102"),
1416 PCI_ROM(0x1106, 0x3106, "via-rhine-6105",  "VIA 6105"),
1417 PCI_ROM(0x1106, 0x3043, "dlink-530tx-old", "VIA 3043"),         /* Rhine-I 86c100a */
1418 PCI_ROM(0x1106, 0x3053, "via6105m",        "VIA 6105M"),        
1419 PCI_ROM(0x1106, 0x6100, "via-rhine-old",   "VIA 86C100A"),      /* Rhine-II */
1420 };
1421
1422 PCI_DRIVER ( rhine_driver, rhine_nics, PCI_NO_CLASS );
1423
1424 DRIVER ( "VIA 86C100", nic_driver, pci_driver, rhine_driver,
1425          rhine_probe, rhine_disable );
1426
1427 /* EOF via-rhine.c */