Ensured that all drivers call xxx_fill_nic().
[people/xl0/gpxe.git] / src / drivers / net / mtd80x.c
1 /**************************************************************************
2 *
3 *    mtd80x.c: Etherboot device driver for the mtd80x Ethernet chip.
4 *    Written 2004-2004 by Erdem G├╝ven <zuencap@yahoo.com>
5 *
6 *    This program is free software; you can redistribute it and/or modify
7 *    it under the terms of the GNU General Public License as published by
8 *    the Free Software Foundation; either version 2 of the License, or
9 *    (at your option) any later version.
10 *
11 *    This program is distributed in the hope that it will be useful,
12 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
13 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 *    GNU General Public License for more details.
15 *
16 *    You should have received a copy of the GNU General Public License
17 *    along with this program; if not, write to the Free Software
18 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 *
20 *    Portions of this code based on:
21 *               fealnx.c: A Linux device driver for the mtd80x Ethernet chip
22 *               Written 1998-2000 by Donald Becker
23 *
24 ***************************************************************************/
25
26 /* to get some global routines like printf */
27 #include "etherboot.h"
28 /* to get the interface to the body of the program */
29 #include "nic.h"
30 /* to get the PCI support functions, if this is a PCI NIC */
31 #include "pci.h"
32
33 typedef unsigned char u8;
34 typedef signed char s8;
35 typedef unsigned short u16;
36 typedef signed short s16;
37 typedef unsigned int u32;
38 typedef signed int s32;
39
40 /* Condensed operations for readability. */
41 #define virt_to_le32desc(addr)  cpu_to_le32(virt_to_bus(addr))
42 #define le32desc_to_virt(addr)  bus_to_virt(le32_to_cpu(addr))
43 #define get_unaligned(ptr) (*(ptr))
44
45
46 /* Operational parameters that are set at compile time. */
47
48 /* Keep the ring sizes a power of two for compile efficiency.           */
49 /* The compiler will convert <unsigned>'%'<2^N> into a bit mask.        */
50 /* Making the Tx ring too large decreases the effectiveness of channel  */
51 /* bonding and packet priority.                                         */
52 /* There are no ill effects from too-large receive rings.               */
53 #define TX_RING_SIZE 2
54 #define TX_QUEUE_LEN 10 /* Limit ring entries actually used.  */
55 #define RX_RING_SIZE 4
56
57 /* Operational parameters that usually are not changed. */
58 /* Time in jiffies before concluding the transmitter is hung. */
59 #define HZ 100
60 #define TX_TIME_OUT   (6*HZ)
61
62 /* Allocation size of Rx buffers with normal sized Ethernet frames.
63    Do not change this value without good reason.  This is not a limit,
64    but a way to keep a consistent allocation size among drivers.
65  */
66 #define PKT_BUF_SZ 1536
67
68 /* Generic MII registers. */
69
70 #define MII_BMCR            0x00        /* Basic mode control register */
71 #define MII_BMSR            0x01        /* Basic mode status register  */
72 #define MII_PHYSID1         0x02        /* PHYS ID 1                   */
73 #define MII_PHYSID2         0x03        /* PHYS ID 2                   */
74 #define MII_ADVERTISE       0x04        /* Advertisement control reg   */
75 #define MII_LPA             0x05        /* Link partner ability reg    */
76 #define MII_EXPANSION       0x06        /* Expansion register          */
77 #define MII_DCOUNTER        0x12        /* Disconnect counter          */
78 #define MII_FCSCOUNTER      0x13        /* False carrier counter       */
79 #define MII_NWAYTEST        0x14        /* N-way auto-neg test reg     */
80 #define MII_RERRCOUNTER     0x15        /* Receive error counter       */
81 #define MII_SREVISION       0x16        /* Silicon revision            */
82 #define MII_RESV1           0x17        /* Reserved...                 */
83 #define MII_LBRERROR        0x18        /* Lpback, rx, bypass error    */
84 #define MII_PHYADDR         0x19        /* PHY address                 */
85 #define MII_RESV2           0x1a        /* Reserved...                 */
86 #define MII_TPISTATUS       0x1b        /* TPI status for 10mbps       */
87 #define MII_NCONFIG         0x1c        /* Network interface config    */
88
89 /* Basic mode control register. */
90 #define BMCR_RESV               0x007f  /* Unused...                   */
91 #define BMCR_CTST               0x0080  /* Collision test              */
92 #define BMCR_FULLDPLX           0x0100  /* Full duplex                 */
93 #define BMCR_ANRESTART          0x0200  /* Auto negotiation restart    */
94 #define BMCR_ISOLATE            0x0400  /* Disconnect DP83840 from MII */
95 #define BMCR_PDOWN              0x0800  /* Powerdown the DP83840       */
96 #define BMCR_ANENABLE           0x1000  /* Enable auto negotiation     */
97 #define BMCR_SPEED100           0x2000  /* Select 100Mbps              */
98 #define BMCR_LOOPBACK           0x4000  /* TXD loopback bits           */
99 #define BMCR_RESET              0x8000  /* Reset the DP83840           */
100
101 /* Basic mode status register. */
102 #define BMSR_ERCAP              0x0001  /* Ext-reg capability          */
103 #define BMSR_JCD                0x0002  /* Jabber detected             */
104 #define BMSR_LSTATUS            0x0004  /* Link status                 */
105 #define BMSR_ANEGCAPABLE        0x0008  /* Able to do auto-negotiation */
106 #define BMSR_RFAULT             0x0010  /* Remote fault detected       */
107 #define BMSR_ANEGCOMPLETE       0x0020  /* Auto-negotiation complete   */
108 #define BMSR_RESV               0x07c0  /* Unused...                   */
109 #define BMSR_10HALF             0x0800  /* Can do 10mbps, half-duplex  */
110 #define BMSR_10FULL             0x1000  /* Can do 10mbps, full-duplex  */
111 #define BMSR_100HALF            0x2000  /* Can do 100mbps, half-duplex */
112 #define BMSR_100FULL            0x4000  /* Can do 100mbps, full-duplex */
113 #define BMSR_100BASE4           0x8000  /* Can do 100mbps, 4k packets  */
114
115 /* Advertisement control register. */
116 #define ADVERTISE_SLCT          0x001f  /* Selector bits               */
117 #define ADVERTISE_CSMA          0x0001  /* Only selector supported     */
118 #define ADVERTISE_10HALF        0x0020  /* Try for 10mbps half-duplex  */
119 #define ADVERTISE_10FULL        0x0040  /* Try for 10mbps full-duplex  */
120 #define ADVERTISE_100HALF       0x0080  /* Try for 100mbps half-duplex */
121 #define ADVERTISE_100FULL       0x0100  /* Try for 100mbps full-duplex */
122 #define ADVERTISE_100BASE4      0x0200  /* Try for 100mbps 4k packets  */
123 #define ADVERTISE_RESV          0x1c00  /* Unused...                   */
124 #define ADVERTISE_RFAULT        0x2000  /* Say we can detect faults    */
125 #define ADVERTISE_LPACK         0x4000  /* Ack link partners response  */
126 #define ADVERTISE_NPAGE         0x8000  /* Next page bit               */
127
128 #define ADVERTISE_FULL (ADVERTISE_100FULL | ADVERTISE_10FULL | \
129                         ADVERTISE_CSMA)
130 #define ADVERTISE_ALL (ADVERTISE_10HALF | ADVERTISE_10FULL | \
131                        ADVERTISE_100HALF | ADVERTISE_100FULL)
132
133 /* for different PHY */
134 enum phy_type_flags {
135     MysonPHY = 1,
136     AhdocPHY = 2,
137     SeeqPHY = 3,
138     MarvellPHY = 4,
139     Myson981 = 5,
140     LevelOnePHY = 6,
141     OtherPHY = 10,
142 };
143
144 /* A chip capabilities table*/
145 enum chip_capability_flags {
146     HAS_MII_XCVR,
147     HAS_CHIP_XCVR,
148 };
149
150 #if 0 /* not used */
151 static
152 struct chip_info
153 {
154     u16 dev_id;
155     int flag;
156 }
157 mtd80x_chips[] = {
158                      {0x0800, HAS_MII_XCVR},
159                      {0x0803, HAS_CHIP_XCVR},
160                      {0x0891, HAS_MII_XCVR}
161                  };
162 static int chip_cnt = sizeof( mtd80x_chips ) / sizeof( struct chip_info );
163 #endif
164
165 /* Offsets to the Command and Status Registers. */
166 enum mtd_offsets {
167     PAR0 = 0x0,        /* physical address 0-3 */
168     PAR1 = 0x04,        /* physical address 4-5 */
169     MAR0 = 0x08,        /* multicast address 0-3 */
170     MAR1 = 0x0C,        /* multicast address 4-7 */
171     FAR0 = 0x10,        /* flow-control address 0-3 */
172     FAR1 = 0x14,        /* flow-control address 4-5 */
173     TCRRCR = 0x18,        /* receive & transmit configuration */
174     BCR = 0x1C,        /* bus command */
175     TXPDR = 0x20,        /* transmit polling demand */
176     RXPDR = 0x24,        /* receive polling demand */
177     RXCWP = 0x28,        /* receive current word pointer */
178     TXLBA = 0x2C,        /* transmit list base address */
179     RXLBA = 0x30,        /* receive list base address */
180     ISR = 0x34,        /* interrupt status */
181     IMR = 0x38,        /* interrupt mask */
182     FTH = 0x3C,        /* flow control high/low threshold */
183     MANAGEMENT = 0x40,    /* bootrom/eeprom and mii management */
184     TALLY = 0x44,        /* tally counters for crc and mpa */
185     TSR = 0x48,        /* tally counter for transmit status */
186     BMCRSR = 0x4c,        /* basic mode control and status */
187     PHYIDENTIFIER = 0x50,    /* phy identifier */
188     ANARANLPAR = 0x54,    /* auto-negotiation advertisement and link
189                                                        partner ability */
190     ANEROCR = 0x58,        /* auto-negotiation expansion and pci conf. */
191     BPREMRPSR = 0x5c,    /* bypass & receive error mask and phy status */
192 };
193
194 /* Bits in the interrupt status/enable registers. */
195 /* The bits in the Intr Status/Enable registers, mostly interrupt sources. */
196 enum intr_status_bits {
197     RFCON = 0x00020000, /* receive flow control xon packet */
198     RFCOFF = 0x00010000, /* receive flow control xoff packet */
199     LSCStatus = 0x00008000, /* link status change */
200     ANCStatus = 0x00004000, /* autonegotiation completed */
201     FBE = 0x00002000, /* fatal bus error */
202     FBEMask = 0x00001800, /* mask bit12-11 */
203     ParityErr = 0x00000000, /* parity error */
204     TargetErr = 0x00001000, /* target abort */
205     MasterErr = 0x00000800, /* master error */
206     TUNF = 0x00000400, /* transmit underflow */
207     ROVF = 0x00000200, /* receive overflow */
208     ETI = 0x00000100, /* transmit early int */
209     ERI = 0x00000080, /* receive early int */
210     CNTOVF = 0x00000040, /* counter overflow */
211     RBU = 0x00000020, /* receive buffer unavailable */
212     TBU = 0x00000010, /* transmit buffer unavilable */
213     TI = 0x00000008, /* transmit interrupt */
214     RI = 0x00000004, /* receive interrupt */
215     RxErr = 0x00000002, /* receive error */
216 };
217
218 /* Bits in the NetworkConfig register. */
219 enum rx_mode_bits {
220     RxModeMask   = 0xe0,
221     AcceptAllPhys = 0x80,        /* promiscuous mode */
222     AcceptBroadcast = 0x40,        /* accept broadcast */
223     AcceptMulticast = 0x20,        /* accept mutlicast */
224     AcceptRunt   = 0x08,        /* receive runt pkt */
225     ALP          = 0x04,        /* receive long pkt */
226     AcceptErr    = 0x02,        /* receive error pkt */
227
228     AcceptMyPhys = 0x00000000,
229     RxEnable     = 0x00000001,
230     RxFlowCtrl   = 0x00002000,
231     TxEnable     = 0x00040000,
232     TxModeFDX    = 0x00100000,
233     TxThreshold  = 0x00e00000,
234
235     PS1000       = 0x00010000,
236     PS10         = 0x00080000,
237     FD           = 0x00100000,
238 };
239
240 /* Bits in network_desc.status */
241 enum rx_desc_status_bits {
242     RXOWN = 0x80000000, /* own bit */
243     FLNGMASK = 0x0fff0000, /* frame length */
244     FLNGShift = 16,
245     MARSTATUS = 0x00004000, /* multicast address received */
246     BARSTATUS = 0x00002000, /* broadcast address received */
247     PHYSTATUS = 0x00001000, /* physical address received */
248     RXFSD = 0x00000800, /* first descriptor */
249     RXLSD = 0x00000400, /* last descriptor */
250     ErrorSummary = 0x80, /* error summary */
251     RUNT = 0x40,  /* runt packet received */
252     LONG = 0x20,  /* long packet received */
253     FAE = 0x10,  /* frame align error */
254     CRC = 0x08,  /* crc error */
255     RXER = 0x04,  /* receive error */
256 };
257
258 enum rx_desc_control_bits {
259     RXIC = 0x00800000, /* interrupt control */
260     RBSShift = 0,
261 };
262
263 enum tx_desc_status_bits {
264     TXOWN = 0x80000000, /* own bit */
265     JABTO = 0x00004000, /* jabber timeout */
266     CSL = 0x00002000, /* carrier sense lost */
267     LC = 0x00001000, /* late collision */
268     EC = 0x00000800, /* excessive collision */
269     UDF = 0x00000400, /* fifo underflow */
270     DFR = 0x00000200, /* deferred */
271     HF = 0x00000100, /* heartbeat fail */
272     NCRMask = 0x000000ff, /* collision retry count */
273     NCRShift = 0,
274 };
275
276 enum tx_desc_control_bits {
277     TXIC = 0x80000000, /* interrupt control */
278     ETIControl = 0x40000000, /* early transmit interrupt */
279     TXLD = 0x20000000, /* last descriptor */
280     TXFD = 0x10000000, /* first descriptor */
281     CRCEnable = 0x08000000, /* crc control */
282     PADEnable = 0x04000000, /* padding control */
283     RetryTxLC = 0x02000000, /* retry late collision */
284     PKTSMask = 0x3ff800, /* packet size bit21-11 */
285     PKTSShift = 11,
286     TBSMask = 0x000007ff, /* transmit buffer bit 10-0 */
287     TBSShift = 0,
288 };
289
290 /* BootROM/EEPROM/MII Management Register */
291 #define MASK_MIIR_MII_READ       0x00000000
292 #define MASK_MIIR_MII_WRITE      0x00000008
293 #define MASK_MIIR_MII_MDO        0x00000004
294 #define MASK_MIIR_MII_MDI        0x00000002
295 #define MASK_MIIR_MII_MDC        0x00000001
296
297 /* ST+OP+PHYAD+REGAD+TA */
298 #define OP_READ             0x6000 /* ST:01+OP:10+PHYAD+REGAD+TA:Z0 */
299 #define OP_WRITE            0x5002 /* ST:01+OP:01+PHYAD+REGAD+TA:10 */
300
301 /* ------------------------------------------------------------------------- */
302 /*      Constants for Myson PHY                                              */
303 /* ------------------------------------------------------------------------- */
304 #define MysonPHYID      0xd0000302
305 /* 89-7-27 add, (begin) */
306 #define MysonPHYID0     0x0302
307 #define StatusRegister  18
308 #define SPEED100        0x0400 // bit10
309 #define FULLMODE        0x0800 // bit11
310 /* 89-7-27 add, (end) */
311
312 /* ------------------------------------------------------------------------- */
313 /*      Constants for Seeq 80225 PHY                                         */
314 /* ------------------------------------------------------------------------- */
315 #define SeeqPHYID0      0x0016
316
317 #define MIIRegister18   18
318 #define SPD_DET_100     0x80
319 #define DPLX_DET_FULL   0x40
320
321 /* ------------------------------------------------------------------------- */
322 /*      Constants for Ahdoc 101 PHY                                          */
323 /* ------------------------------------------------------------------------- */
324 #define AhdocPHYID0     0x0022
325
326 #define DiagnosticReg   18
327 #define DPLX_FULL       0x0800
328 #define Speed_100       0x0400
329
330 /* 89/6/13 add, */
331 /* -------------------------------------------------------------------------- */
332 /*      Constants                                                             */
333 /* -------------------------------------------------------------------------- */
334 #define MarvellPHYID0           0x0141
335 #define LevelOnePHYID0  0x0013
336
337 #define MII1000BaseTControlReg  9
338 #define MII1000BaseTStatusReg   10
339 #define SpecificReg  17
340
341 /* for 1000BaseT Control Register */
342 #define PHYAbletoPerform1000FullDuplex  0x0200
343 #define PHYAbletoPerform1000HalfDuplex  0x0100
344 #define PHY1000AbilityMask              0x300
345
346 // for phy specific status register, marvell phy.
347 #define SpeedMask       0x0c000
348 #define Speed_1000M     0x08000
349 #define Speed_100M      0x4000
350 #define Speed_10M       0
351 #define Full_Duplex     0x2000
352
353 // 89/12/29 add, for phy specific status register, levelone phy, (begin)
354 #define LXT1000_100M    0x08000
355 #define LXT1000_1000M   0x0c000
356 #define LXT1000_Full    0x200
357 // 89/12/29 add, for phy specific status register, levelone phy, (end)
358
359 #if 0
360 /* for 3-in-1 case */
361 #define PS10            0x00080000
362 #define FD              0x00100000
363 #define PS1000          0x00010000
364 #endif
365
366 /* for PHY */
367 #define LinkIsUp        0x0004
368 #define LinkIsUp2 0x00040000
369
370 /* Create a static buffer of size PKT_BUF_SZ for each
371 TX Descriptor.  All descriptors point to a
372 part of this buffer */
373 static u8 txb[PKT_BUF_SZ * TX_RING_SIZE]
374 __attribute__ ((aligned(8)));
375
376 /* Create a static buffer of size PKT_BUF_SZ for each
377 RX Descriptor   All descriptors point to a
378 part of this buffer */
379 static u8 rxb[PKT_BUF_SZ * RX_RING_SIZE]
380 __attribute__ ((aligned(8)));
381
382 /* The Tulip Rx and Tx buffer descriptors. */
383 struct mtd_desc
384 {
385     s32 status;
386     s32 control;
387     u32 buffer;
388     u32 next_desc;
389     struct mtd_desc *next_desc_logical;
390     u8* skbuff;
391     u32 reserved1;
392     u32 reserved2;
393 };
394
395 struct mtd_private
396 {
397     struct mtd_desc rx_ring[RX_RING_SIZE];
398     struct mtd_desc tx_ring[TX_RING_SIZE];
399
400     /* Frequently used values: keep some adjacent for cache effect. */
401     int flags;
402     struct pci_dev *pci_dev;
403     unsigned long crvalue;
404     unsigned long bcrvalue;
405     /*unsigned long imrvalue;*/
406     struct mtd_desc *cur_rx;
407     struct mtd_desc *lack_rxbuf;
408     int really_rx_count;
409     struct mtd_desc *cur_tx;
410     struct mtd_desc *cur_tx_copy;
411     int really_tx_count;
412     int free_tx_count;
413     unsigned int rx_buf_sz; /* Based on MTU+slack. */
414
415     /* These values are keep track of the transceiver/media in use. */
416     unsigned int linkok;
417     unsigned int line_speed;
418     unsigned int duplexmode;
419     unsigned int default_port:
420     4; /* Last dev->if_port value. */
421     unsigned int PHYType;
422
423     /* MII transceiver section. */
424     int mii_cnt;  /* MII device addresses. */
425     unsigned char phys[1]; /* MII device addresses. */
426
427     /*other*/
428     const char *nic_name;
429     int ioaddr;
430     u16 dev_id;
431 };
432
433 static struct mtd_private mtdx;
434
435 static int mdio_read(struct nic * , int phy_id, int location);
436 static void getlinktype(struct nic * );
437 static void getlinkstatus(struct nic * );
438 static void set_rx_mode(struct nic *);
439
440 /**************************************************************************
441  *  init_ring - setup the tx and rx descriptors
442  *************************************************************************/
443 static void init_ring(struct nic *nic __unused)
444 {
445     int i;
446
447     mtdx.cur_rx = &mtdx.rx_ring[0];
448
449     mtdx.rx_buf_sz = PKT_BUF_SZ;
450     /*mtdx.rx_head_desc = &mtdx.rx_ring[0];*/
451
452     /* Initialize all Rx descriptors. */
453     /* Fill in the Rx buffers.  Handle allocation failure gracefully. */
454     for (i = 0; i < RX_RING_SIZE; i++)
455     {
456         mtdx.rx_ring[i].status = RXOWN;
457         mtdx.rx_ring[i].control = mtdx.rx_buf_sz << RBSShift;
458         mtdx.rx_ring[i].next_desc = virt_to_le32desc(&mtdx.rx_ring[i+1]);
459         mtdx.rx_ring[i].next_desc_logical = &mtdx.rx_ring[i+1];
460         mtdx.rx_ring[i].buffer = virt_to_le32desc(&rxb[i * PKT_BUF_SZ]);
461         mtdx.rx_ring[i].skbuff = &rxb[i * PKT_BUF_SZ];
462     }
463     /* Mark the last entry as wrapping the ring. */
464     mtdx.rx_ring[i-1].next_desc = virt_to_le32desc(&mtdx.rx_ring[0]);
465     mtdx.rx_ring[i-1].next_desc_logical = &mtdx.rx_ring[0];
466
467     /* We only use one transmit buffer, but two
468      * descriptors so transmit engines have somewhere
469      * to point should they feel the need */
470     mtdx.tx_ring[0].status = 0x00000000;
471     mtdx.tx_ring[0].buffer = virt_to_bus(&txb[0]);
472     mtdx.tx_ring[0].next_desc = virt_to_le32desc(&mtdx.tx_ring[1]);
473
474     /* This descriptor is never used */
475     mtdx.tx_ring[1].status = 0x00000000;
476     mtdx.tx_ring[1].buffer = 0; /*virt_to_bus(&txb[1]); */
477     mtdx.tx_ring[1].next_desc = virt_to_le32desc(&mtdx.tx_ring[0]);
478
479     return;
480 }
481
482 /**************************************************************************
483 RESET - Reset Adapter
484 ***************************************************************************/
485 static void mtd_reset(struct nic *nic)
486 {
487     /* Reset the chip to erase previous misconfiguration. */
488     outl(0x00000001, mtdx.ioaddr + BCR);
489
490     init_ring(nic);
491
492     outl(virt_to_bus(mtdx.rx_ring), mtdx.ioaddr + RXLBA);
493     outl(virt_to_bus(mtdx.tx_ring), mtdx.ioaddr + TXLBA);
494
495     /* Initialize other registers. */
496     /* Configure the PCI bus bursts and FIFO thresholds. */
497     mtdx.bcrvalue = 0x10; /* little-endian, 8 burst length */
498     mtdx.crvalue = 0xa00; /* rx 128 burst length */
499
500         if ( mtdx.dev_id == 0x891 ) {
501                 mtdx.bcrvalue |= 0x200; /* set PROG bit */
502                 mtdx.crvalue |= 0x02000000;     /* set enhanced bit */
503         }
504
505     outl( mtdx.bcrvalue, mtdx.ioaddr + BCR);
506
507     /* Restart Rx engine if stopped. */
508     outl(0, mtdx.ioaddr + RXPDR);
509
510     getlinkstatus(nic);
511     if (mtdx.linkok)
512     {
513         char* texts[]={"half","full","10","100","1000"};
514         getlinktype(nic);
515         DBG(("Link is OK : %s %s\n", texts[mtdx.duplexmode-1], texts[mtdx.line_speed+1] ));
516     } else
517     {
518         DBG(("No link!!!\n"));
519     }
520
521     mtdx.crvalue |= /*TxEnable |*/ RxEnable | TxThreshold;
522     set_rx_mode(nic);
523
524     /* Clear interrupts by setting the interrupt mask. */
525     outl(FBE | TUNF | CNTOVF | RBU | TI | RI, mtdx.ioaddr + ISR);
526     outl( 0, mtdx.ioaddr + IMR);
527 }
528
529 /**************************************************************************
530 POLL - Wait for a frame
531 ***************************************************************************/
532 static int mtd_poll(struct nic *nic, int retrieve)
533 {
534     s32 rx_status = mtdx.cur_rx->status;
535     int retval = 0;
536
537     if( ( rx_status & RXOWN ) != 0 )
538     {
539         return 0;
540     }
541
542     if (rx_status & ErrorSummary)
543     { /* there was a fatal error */
544         printf( "%s: Receive error, Rx status %8.8x, Error(s) %s%s%s\n",
545                 mtdx.nic_name, rx_status ,
546                 (rx_status & (LONG | RUNT)) ? "length_error ":"",
547                 (rx_status & RXER) ? "frame_error ":"",
548                 (rx_status & CRC) ? "crc_error ":"" );
549         retval = 0;
550     } else if( !((rx_status & RXFSD) && (rx_status & RXLSD)) )
551     {
552         /* this pkt is too long, over one rx buffer */
553         printf("Pkt is too long, over one rx buffer.\n");
554         retval = 0;
555     } else
556     { /* this received pkt is ok */
557         /* Omit the four octet CRC from the length. */
558         short pkt_len = ((rx_status & FLNGMASK) >> FLNGShift) - 4;
559
560         DBG(( "  netdev_rx() normal Rx pkt length %d"
561               " status %x.\n", pkt_len, rx_status));
562
563         nic->packetlen = pkt_len;
564         memcpy(nic->packet, mtdx.cur_rx->skbuff, pkt_len);
565
566         retval = 1;
567     }
568
569     while( ( mtdx.cur_rx->status & RXOWN ) == 0 )
570     {
571         mtdx.cur_rx->status = RXOWN;
572         mtdx.cur_rx = mtdx.cur_rx->next_desc_logical;
573     }
574
575     /* Restart Rx engine if stopped. */
576     outl(0, mtdx.ioaddr + RXPDR);
577
578     return retval;
579 }
580
581 /**************************************************************************
582 TRANSMIT - Transmit a frame
583 ***************************************************************************/
584 static void mtd_transmit(
585     struct nic *nic,
586     const char *dest,            /* Destination */
587     unsigned int type,            /* Type */
588     unsigned int size,            /* size */
589     const char *data)            /* Packet */
590 {
591     u32 to;
592     u32 tx_status;
593     unsigned int nstype = htons ( type );
594
595     memcpy( txb, dest, ETH_ALEN );
596     memcpy( txb + ETH_ALEN, nic->node_addr, ETH_ALEN );
597     memcpy( txb + 2 * ETH_ALEN, &nstype, 2 );
598     memcpy( txb + ETH_HLEN, data, size );
599
600     size += ETH_HLEN;
601     size &= 0x0FFF;
602     while( size < ETH_ZLEN )
603     {
604         txb[size++] = '\0';
605     }
606
607     mtdx.tx_ring[0].control = TXLD | TXFD | CRCEnable | PADEnable;
608     mtdx.tx_ring[0].control |= (size << PKTSShift); /* pkt size */
609     mtdx.tx_ring[0].control |= (size << TBSShift); /* buffer size */
610     mtdx.tx_ring[0].status = TXOWN;
611
612     /* Point to transmit descriptor */
613     outl(virt_to_bus(mtdx.tx_ring), mtdx.ioaddr + TXLBA);
614     /* Enable Tx */
615     outl( mtdx.crvalue | TxEnable, mtdx.ioaddr + TCRRCR);
616     /* Wake the potentially-idle transmit channel. */
617     outl(0, mtdx.ioaddr + TXPDR);
618
619     to = currticks() + TX_TIME_OUT;
620     while(( mtdx.tx_ring[0].status & TXOWN) && (currticks() < to));
621
622     /* Disable Tx */
623     outl( mtdx.crvalue & (~TxEnable), mtdx.ioaddr + TCRRCR);
624
625     tx_status = mtdx.tx_ring[0].status;
626     if (currticks() >= to){
627         DBG(("TX Time Out"));
628     } else if( tx_status & (CSL | LC | EC | UDF | HF)){
629         printf("Transmit error: %s %s %s %s %s.\n",
630                tx_status,
631                tx_status & EC ? "abort" : "",
632                tx_status & CSL ? "carrier" : "",
633                tx_status & LC ? "late" : "",
634                tx_status & UDF ? "fifo" : "",
635                tx_status & HF ? "heartbeat" : "" );
636     }
637
638     /*hex_dump( txb, size );*/
639     /*pause();*/
640
641     DBG(("TRANSMIT\n"));
642 }
643
644 /**************************************************************************
645 DISABLE - Turn off ethernet interface
646 ***************************************************************************/
647 static void mtd_disable ( struct nic *nic, struct pci_device *pci __unused ) {
648     nic_disable ( nic );
649     /* put the card in its initial state */
650     /* Disable Tx Rx*/
651     outl( mtdx.crvalue & (~TxEnable) & (~RxEnable), mtdx.ioaddr + TCRRCR);
652     /* Reset the chip to erase previous misconfiguration. */
653     mtd_reset(nic);
654     DBG(("DISABLE\n"));
655 }
656
657 static struct nic_operations mtd_operations = {
658         .connect        = dummy_connect,
659         .poll           = mtd_poll,
660         .transmit       = mtd_transmit,
661         .irq            = dummy_irq,
662
663 };
664
665 static struct pci_id mtd80x_nics[] = {
666         PCI_ROM(0x1516, 0x0800, "MTD800", "Myson MTD800"),
667         PCI_ROM(0x1516, 0x0803, "MTD803", "Surecom EP-320X"),
668         PCI_ROM(0x1516, 0x0891, "MTD891", "Myson MTD891"),
669 };
670
671 static struct pci_driver mtd80x_driver =
672         PCI_DRIVER ( mtd80x_nics, PCI_NO_CLASS );
673
674 /**************************************************************************
675 PROBE - Look for an adapter, this routine's visible to the outside
676 ***************************************************************************/
677
678 static int mtd_probe ( struct nic *nic, struct pci_device *pci ) {
679
680     int i;
681
682     if (pci->ioaddr == 0)
683             return 0;
684
685     pci_fill_nic ( nic, pci );
686     adjust_pci_device(pci);
687
688     mtdx.nic_name = pci->name;
689     mtdx.dev_id = pci->device_id;
690     mtdx.ioaddr = nic->ioaddr;
691
692     /* read ethernet id */
693     for (i = 0; i < 6; ++i)
694     {
695         nic->node_addr[i] = inb(mtdx.ioaddr + PAR0 + i);
696     }
697
698     if (memcmp(nic->node_addr, "\0\0\0\0\0", 6) == 0)
699     {
700         return 0;
701     }
702
703     DBG(("%s : ioaddr %#hX, addr %!\n",mtdx.nic_name, mtdx.ioaddr, nic->node_addr));
704
705     /* Reset the chip to erase previous misconfiguration. */
706     outl(0x00000001, mtdx.ioaddr + BCR);
707
708     /* find the connected MII xcvrs */
709
710     if( mtdx.dev_id != 0x803 )
711     {
712         int phy, phy_idx = 0;
713
714         for (phy = 1; phy < 32 && phy_idx < 1; phy++) {
715             int mii_status = mdio_read(nic, phy, 1);
716
717             if (mii_status != 0xffff && mii_status != 0x0000) {
718                 mtdx.phys[phy_idx] = phy;
719
720                 DBG(("%s: MII PHY found at address %d, status "
721                      "0x%4.4x.\n", mtdx.nic_name, phy, mii_status));
722                 /* get phy type */
723                 {
724                     unsigned int data;
725
726                     data = mdio_read(nic, mtdx.phys[phy_idx], 2);
727                     if (data == SeeqPHYID0)
728                         mtdx.PHYType = SeeqPHY;
729                     else if (data == AhdocPHYID0)
730                         mtdx.PHYType = AhdocPHY;
731                     else if (data == MarvellPHYID0)
732                         mtdx.PHYType = MarvellPHY;
733                     else if (data == MysonPHYID0)
734                         mtdx.PHYType = Myson981;
735                     else if (data == LevelOnePHYID0)
736                         mtdx.PHYType = LevelOnePHY;
737                     else
738                         mtdx.PHYType = OtherPHY;
739                 }
740                 phy_idx++;
741             }
742         }
743
744         mtdx.mii_cnt = phy_idx;
745         if (phy_idx == 0) {
746             printf("%s: MII PHY not found -- this device may "
747                    "not operate correctly.\n", mtdx.nic_name);
748         }
749     } else {
750         mtdx.phys[0] = 32;
751         /* get phy type */
752         if (inl(mtdx.ioaddr + PHYIDENTIFIER) == MysonPHYID ) {
753             mtdx.PHYType = MysonPHY;
754             DBG(("MysonPHY\n"));
755         } else {
756             mtdx.PHYType = OtherPHY;
757             DBG(("OtherPHY\n"));
758         }
759     }
760
761     getlinkstatus(nic);
762     if( !mtdx.linkok )
763     {
764         printf("No link!!!\n");
765         return 0;
766     }
767
768     mtd_reset( nic );
769
770     /* point to NIC specific routines */
771     nic->nic_op = &mtd_operations;
772     return 1;
773 }
774
775
776 /**************************************************************************/
777 static void set_rx_mode(struct nic *nic __unused)
778 {
779     u32 mc_filter[2];                       /* Multicast hash filter */
780     u32 rx_mode;
781
782     /* Too many to match, or accept all multicasts. */
783     mc_filter[1] = mc_filter[0] = ~0;
784     rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
785
786     outl(mc_filter[0], mtdx.ioaddr + MAR0);
787     outl(mc_filter[1], mtdx.ioaddr + MAR1);
788
789     mtdx.crvalue = ( mtdx.crvalue & ~RxModeMask ) | rx_mode;
790     outb( mtdx.crvalue, mtdx.ioaddr + TCRRCR);
791 }
792 /**************************************************************************/
793 static unsigned int m80x_read_tick(void)
794 /* function: Reads the Timer tick count register which decrements by 2 from  */
795 /*           65536 to 0 every 1/36.414 of a second. Each 2 decrements of the */
796 /*           count represents 838 nsec's.                                    */
797 /* input   : none.                                                           */
798 /* output  : none.                                                           */
799 {
800     unsigned char tmp;
801     int value;
802
803     outb((char) 0x06, 0x43); // Command 8254 to latch T0's count
804
805     // now read the count.
806     tmp = (unsigned char) inb(0x40);
807     value = ((int) tmp) << 8;
808     tmp = (unsigned char) inb(0x40);
809     value |= (((int) tmp) & 0xff);
810     return (value);
811 }
812
813 static void m80x_delay(unsigned int interval)
814 /* function: to wait for a specified time.                                   */
815 /* input   : interval ... the specified time.                                */
816 /* output  : none.                                                           */
817 {
818     unsigned int interval1, interval2, i = 0;
819
820     interval1 = m80x_read_tick(); // get initial value
821     do
822     {
823         interval2 = m80x_read_tick();
824         if (interval1 < interval2)
825             interval1 += 65536;
826         ++i;
827     } while (((interval1 - interval2) < (u16) interval) && (i < 65535));
828 }
829
830
831 static u32 m80x_send_cmd_to_phy(long miiport, int opcode, int phyad, int regad)
832 {
833     u32 miir;
834     int i;
835     unsigned int mask, data;
836
837     /* enable MII output */
838     miir = (u32) inl(miiport);
839     miir &= 0xfffffff0;
840
841     miir |= MASK_MIIR_MII_WRITE + MASK_MIIR_MII_MDO;
842
843     /* send 32 1's preamble */
844     for (i = 0; i < 32; i++) {
845         /* low MDC; MDO is already high (miir) */
846         miir &= ~MASK_MIIR_MII_MDC;
847         outl(miir, miiport);
848
849         /* high MDC */
850         miir |= MASK_MIIR_MII_MDC;
851         outl(miir, miiport);
852     }
853
854     /* calculate ST+OP+PHYAD+REGAD+TA */
855     data = opcode | (phyad << 7) | (regad << 2);
856
857     /* sent out */
858     mask = 0x8000;
859     while (mask) {
860         /* low MDC, prepare MDO */
861         miir &= ~(MASK_MIIR_MII_MDC + MASK_MIIR_MII_MDO);
862         if (mask & data)
863             miir |= MASK_MIIR_MII_MDO;
864
865         outl(miir, miiport);
866         /* high MDC */
867         miir |= MASK_MIIR_MII_MDC;
868         outl(miir, miiport);
869         m80x_delay(30);
870
871         /* next */
872         mask >>= 1;
873         if (mask == 0x2 && opcode == OP_READ)
874             miir &= ~MASK_MIIR_MII_WRITE;
875     }
876     return miir;
877 }
878
879 static int mdio_read(struct nic *nic __unused, int phyad, int regad)
880 {
881     long miiport = mtdx.ioaddr + MANAGEMENT;
882     u32 miir;
883     unsigned int mask, data;
884
885     miir = m80x_send_cmd_to_phy(miiport, OP_READ, phyad, regad);
886
887     /* read data */
888     mask = 0x8000;
889     data = 0;
890     while (mask)
891     {
892         /* low MDC */
893         miir &= ~MASK_MIIR_MII_MDC;
894         outl(miir, miiport);
895
896         /* read MDI */
897         miir = inl(miiport);
898         if (miir & MASK_MIIR_MII_MDI)
899             data |= mask;
900
901         /* high MDC, and wait */
902         miir |= MASK_MIIR_MII_MDC;
903         outl(miir, miiport);
904         m80x_delay((int) 30);
905
906         /* next */
907         mask >>= 1;
908     }
909
910     /* low MDC */
911     miir &= ~MASK_MIIR_MII_MDC;
912     outl(miir, miiport);
913
914     return data & 0xffff;
915 }
916
917 #if 0 /* not used */
918 static void mdio_write(struct nic *nic __unused, int phyad, int regad,
919                        int data)
920 {
921     long miiport = mtdx.ioaddr + MANAGEMENT;
922     u32 miir;
923     unsigned int mask;
924
925     miir = m80x_send_cmd_to_phy(miiport, OP_WRITE, phyad, regad);
926
927     /* write data */
928     mask = 0x8000;
929     while (mask)
930     {
931         /* low MDC, prepare MDO */
932         miir &= ~(MASK_MIIR_MII_MDC + MASK_MIIR_MII_MDO);
933         if (mask & data)
934             miir |= MASK_MIIR_MII_MDO;
935         outl(miir, miiport);
936
937         /* high MDC */
938         miir |= MASK_MIIR_MII_MDC;
939         outl(miir, miiport);
940
941         /* next */
942         mask >>= 1;
943     }
944
945     /* low MDC */
946     miir &= ~MASK_MIIR_MII_MDC;
947     outl(miir, miiport);
948
949     return;
950 }
951 #endif
952
953 static void getlinkstatus(struct nic *nic)
954 /* function: Routine will read MII Status Register to get link status.       */
955 /* input   : dev... pointer to the adapter block.                            */
956 /* output  : none.                                                           */
957 {
958     unsigned int i, DelayTime = 0x1000;
959
960     mtdx.linkok = 0;
961
962     if (mtdx.PHYType == MysonPHY)
963     {
964         for (i = 0; i < DelayTime; ++i) {
965             if (inl(mtdx.ioaddr + BMCRSR) & LinkIsUp2) {
966                 mtdx.linkok = 1;
967                 return;
968             }
969             // delay
970             m80x_delay(100);
971         }
972     } else
973     {
974         for (i = 0; i < DelayTime; ++i) {
975             if (mdio_read(nic, mtdx.phys[0], MII_BMSR) & BMSR_LSTATUS) {
976                 mtdx.linkok = 1;
977                 return;
978             }
979             // delay
980             m80x_delay(100);
981         }
982     }
983 }
984
985
986 static void getlinktype(struct nic *dev)
987 {
988     if (mtdx.PHYType == MysonPHY)
989     { /* 3-in-1 case */
990         if (inl(mtdx.ioaddr + TCRRCR) & FD)
991             mtdx.duplexmode = 2; /* full duplex */
992         else
993             mtdx.duplexmode = 1; /* half duplex */
994         if (inl(mtdx.ioaddr + TCRRCR) & PS10)
995             mtdx.line_speed = 1; /* 10M */
996         else
997             mtdx.line_speed = 2; /* 100M */
998     } else
999     {
1000         if (mtdx.PHYType == SeeqPHY) { /* this PHY is SEEQ 80225 */
1001             unsigned int data;
1002
1003             data = mdio_read(dev, mtdx.phys[0], MIIRegister18);
1004             if (data & SPD_DET_100)
1005                 mtdx.line_speed = 2; /* 100M */
1006             else
1007                 mtdx.line_speed = 1; /* 10M */
1008             if (data & DPLX_DET_FULL)
1009                 mtdx.duplexmode = 2; /* full duplex mode */
1010             else
1011                 mtdx.duplexmode = 1; /* half duplex mode */
1012         } else if (mtdx.PHYType == AhdocPHY) {
1013             unsigned int data;
1014
1015             data = mdio_read(dev, mtdx.phys[0], DiagnosticReg);
1016             if (data & Speed_100)
1017                 mtdx.line_speed = 2; /* 100M */
1018             else
1019                 mtdx.line_speed = 1; /* 10M */
1020             if (data & DPLX_FULL)
1021                 mtdx.duplexmode = 2; /* full duplex mode */
1022             else
1023                 mtdx.duplexmode = 1; /* half duplex mode */
1024         }
1025         /* 89/6/13 add, (begin) */
1026         else if (mtdx.PHYType == MarvellPHY) {
1027             unsigned int data;
1028
1029             data = mdio_read(dev, mtdx.phys[0], SpecificReg);
1030             if (data & Full_Duplex)
1031                 mtdx.duplexmode = 2; /* full duplex mode */
1032             else
1033                 mtdx.duplexmode = 1; /* half duplex mode */
1034             data &= SpeedMask;
1035             if (data == Speed_1000M)
1036                 mtdx.line_speed = 3; /* 1000M */
1037             else if (data == Speed_100M)
1038                 mtdx.line_speed = 2; /* 100M */
1039             else
1040                 mtdx.line_speed = 1; /* 10M */
1041         }
1042         /* 89/6/13 add, (end) */
1043         /* 89/7/27 add, (begin) */
1044         else if (mtdx.PHYType == Myson981) {
1045             unsigned int data;
1046
1047             data = mdio_read(dev, mtdx.phys[0], StatusRegister);
1048
1049             if (data & SPEED100)
1050                 mtdx.line_speed = 2;
1051             else
1052                 mtdx.line_speed = 1;
1053
1054             if (data & FULLMODE)
1055                 mtdx.duplexmode = 2;
1056             else
1057                 mtdx.duplexmode = 1;
1058         }
1059         /* 89/7/27 add, (end) */
1060         /* 89/12/29 add */
1061         else if (mtdx.PHYType == LevelOnePHY) {
1062             unsigned int data;
1063
1064             data = mdio_read(dev, mtdx.phys[0], SpecificReg);
1065             if (data & LXT1000_Full)
1066                 mtdx.duplexmode = 2; /* full duplex mode */
1067             else
1068                 mtdx.duplexmode = 1; /* half duplex mode */
1069             data &= SpeedMask;
1070             if (data == LXT1000_1000M)
1071                 mtdx.line_speed = 3; /* 1000M */
1072             else if (data == LXT1000_100M)
1073                 mtdx.line_speed = 2; /* 100M */
1074             else
1075                 mtdx.line_speed = 1; /* 10M */
1076         }
1077         // chage crvalue
1078         // mtdx.crvalue&=(~PS10)&(~FD);
1079         mtdx.crvalue &= (~PS10) & (~FD) & (~PS1000);
1080         if (mtdx.line_speed == 1)
1081             mtdx.crvalue |= PS10;
1082         else if (mtdx.line_speed == 3)
1083             mtdx.crvalue |= PS1000;
1084         if (mtdx.duplexmode == 2)
1085             mtdx.crvalue |= FD;
1086     }
1087 }
1088
1089 DRIVER ( "MTD80X", nic_driver, pci_driver, mtd80x_driver,
1090          mtd_probe, mtd_disable );