Coerced into compiling
[people/xl0/gpxe.git] / src / drivers / net / epic100.c
1
2 /* epic100.c: A SMC 83c170 EPIC/100 fast ethernet driver for Etherboot */
3
4 /* 05/06/2003   timlegge        Fixed relocation and implemented Multicast */
5 #define LINUX_OUT_MACROS
6
7 #include "etherboot.h"
8 #include "pci.h"
9 #include "nic.h"
10 #include "timer.h"
11 #include "console.h"
12 #include "epic100.h"
13
14 /* Condensed operations for readability */
15 #define virt_to_le32desc(addr)  cpu_to_le32(virt_to_bus(addr))
16 #define le32desc_to_virt(addr)  bus_to_virt(le32_to_cpu(addr))
17
18 #define TX_RING_SIZE    2       /* use at least 2 buffers for TX */
19 #define RX_RING_SIZE    2
20
21 #define PKT_BUF_SZ      1536    /* Size of each temporary Tx/Rx buffer.*/
22
23 /*
24 #define DEBUG_RX
25 #define DEBUG_TX
26 #define DEBUG_EEPROM
27 */
28
29 #define EPIC_DEBUG 0    /* debug level */
30
31 /* The EPIC100 Rx and Tx buffer descriptors. */
32 struct epic_rx_desc {
33     unsigned long status;
34     unsigned long bufaddr;
35     unsigned long buflength;
36     unsigned long next;
37 };
38 /* description of the tx descriptors control bits commonly used */
39 #define TD_STDFLAGS     TD_LASTDESC
40
41 struct epic_tx_desc {
42     unsigned long status;
43     unsigned long bufaddr;
44     unsigned long buflength;
45     unsigned long  next;
46 };
47
48 #define delay(nanosec)   do { int _i = 3; while (--_i > 0) \
49                                      { __SLOW_DOWN_IO; }} while (0)
50
51 static void     epic100_open(void);
52 static void     epic100_init_ring(void);
53 static void     epic100_disable(struct nic *nic, struct pci_device *pci);
54 static int      epic100_poll(struct nic *nic, int retrieve);
55 static void     epic100_transmit(struct nic *nic, const char *destaddr,
56                                  unsigned int type, unsigned int len, const char *data);
57 #ifdef  DEBUG_EEPROM
58 static int      read_eeprom(int location);
59 #endif
60 static int      mii_read(int phy_id, int location);
61 static void     epic100_irq(struct nic *nic, irq_action_t action);
62
63 static struct nic_operations epic100_operations;
64 static struct pci_driver epic100_driver;
65
66 static int      ioaddr;
67
68 static int      command;
69 static int      intstat;
70 static int      intmask;
71 static int      genctl ;
72 static int      eectl  ;
73 static int      test   ;
74 static int      mmctl  ;
75 static int      mmdata ;
76 static int      lan0   ;
77 static int      mc0    ;
78 static int      rxcon  ;
79 static int      txcon  ;
80 static int      prcdar ;
81 static int      ptcdar ;
82 static int      eththr ;
83
84 static unsigned int     cur_rx, cur_tx;         /* The next free ring entry */
85 #ifdef  DEBUG_EEPROM
86 static unsigned short   eeprom[64];
87 #endif
88 static signed char      phys[4];                /* MII device addresses. */
89 static struct epic_rx_desc      rx_ring[RX_RING_SIZE]
90         __attribute__ ((aligned(4)));
91 static struct epic_tx_desc      tx_ring[TX_RING_SIZE]
92         __attribute__ ((aligned(4)));
93 static unsigned char            rx_packet[PKT_BUF_SZ * RX_RING_SIZE];
94 static unsigned char            tx_packet[PKT_BUF_SZ * TX_RING_SIZE];
95
96 /***********************************************************************/
97 /*                    Externally visible functions                     */
98 /***********************************************************************/
99
100
101 static int
102 epic100_probe ( struct nic *nic, struct pci_device *pci ) {
103
104     int i;
105     unsigned short* ap;
106     unsigned int phy, phy_idx;
107
108     if (pci->ioaddr == 0)
109         return 0;
110
111     /* Ideally we would detect all network cards in slot order.  That would
112        be best done a central PCI probe dispatch, which wouldn't work
113        well with the current structure.  So instead we detect just the
114        Epic cards in slot order. */
115
116     ioaddr = pci->ioaddr;
117     nic->irqno  = 0;
118     pci_fill_nic ( nic, pci );
119     nic->ioaddr = pci->ioaddr & ~3;
120
121     /* compute all used static epic100 registers address */
122     command = ioaddr + COMMAND;         /* Control Register */
123     intstat = ioaddr + INTSTAT;         /* Interrupt Status */
124     intmask = ioaddr + INTMASK;         /* Interrupt Mask */
125     genctl  = ioaddr + GENCTL;          /* General Control */
126     eectl   = ioaddr + EECTL;           /* EEPROM Control  */
127     test    = ioaddr + TEST;            /* Test register (clocks) */
128     mmctl   = ioaddr + MMCTL;           /* MII Management Interface Control */
129     mmdata  = ioaddr + MMDATA;          /* MII Management Interface Data */
130     lan0    = ioaddr + LAN0;            /* MAC address. (0x40-0x48) */
131     mc0     = ioaddr + MC0;             /* Multicast Control */
132     rxcon   = ioaddr + RXCON;           /* Receive Control */
133     txcon   = ioaddr + TXCON;           /* Transmit Control */
134     prcdar  = ioaddr + PRCDAR;          /* PCI Receive Current Descr Address */
135     ptcdar  = ioaddr + PTCDAR;          /* PCI Transmit Current Descr Address */
136     eththr  = ioaddr + ETHTHR;          /* Early Transmit Threshold */
137
138     /* Reset the chip & bring it out of low-power mode. */
139     outl(GC_SOFT_RESET, genctl);
140
141     /* Disable ALL interrupts by setting the interrupt mask. */
142     outl(INTR_DISABLE, intmask);
143
144     /*
145      * set the internal clocks:
146      * Application Note 7.15 says:
147      *    In order to set the CLOCK TEST bit in the TEST register,
148      *    perform the following:
149      *
150      *        Write 0x0008 to the test register at least sixteen
151      *        consecutive times.
152      *
153      * The CLOCK TEST bit is Write-Only. Writing it several times
154      * consecutively insures a successful write to the bit...
155      */
156
157     for (i = 0; i < 16; i++) {
158         outl(0x00000008, test);
159     }
160
161 #ifdef  DEBUG_EEPROM
162 {
163     unsigned short sum = 0;
164     unsigned short value;
165     for (i = 0; i < 64; i++) {
166         value = read_eeprom(i);
167         eeprom[i] = value;
168         sum += value;
169     }
170 }
171
172 #if     (EPIC_DEBUG > 1)
173     printf("EEPROM contents\n");
174     for (i = 0; i < 64; i++) {
175         printf(" %hhX%s", eeprom[i], i % 16 == 15 ? "\n" : "");
176     }
177 #endif
178 #endif
179
180     /* This could also be read from the EEPROM. */
181     ap = (unsigned short*)nic->node_addr;
182     for (i = 0; i < 3; i++)
183         *ap++ = inw(lan0 + i*4);
184
185     printf(" I/O %#hX %! ", ioaddr, nic->node_addr);
186
187     /* Find the connected MII xcvrs. */
188     for (phy = 0, phy_idx = 0; phy < 32 && phy_idx < sizeof(phys); phy++) {
189         int mii_status = mii_read(phy, 0);
190
191         if (mii_status != 0xffff  && mii_status != 0x0000) {
192             phys[phy_idx++] = phy;
193 #if     (EPIC_DEBUG > 1)
194             printf("MII transceiver found at address %d.\n", phy);
195 #endif
196         }
197     }
198     if (phy_idx == 0) {
199 #if     (EPIC_DEBUG > 1)
200         printf("***WARNING***: No MII transceiver found!\n");
201 #endif
202         /* Use the known PHY address of the EPII. */
203         phys[0] = 3;
204     }
205
206     epic100_open();
207     nic->nic_op = &epic100_operations;
208
209     return 1;
210 }
211
212 static void set_rx_mode(void)
213 {
214         unsigned char mc_filter[8];
215         int i;
216         memset(mc_filter, 0xff, sizeof(mc_filter));
217         outl(0x0C, rxcon);
218         for(i = 0; i < 4; i++)
219                 outw(((unsigned short *)mc_filter)[i], mc0 + i*4);
220         return;
221 }
222         
223    static void
224 epic100_open(void)
225 {
226     int mii_reg5;
227     int full_duplex = 0;
228     unsigned long tmp;
229
230     epic100_init_ring();
231
232     /* Pull the chip out of low-power mode, and set for PCI read multiple. */
233     outl(GC_RX_FIFO_THR_64 | GC_MRC_READ_MULT | GC_ONE_COPY, genctl);
234
235     outl(TX_FIFO_THRESH, eththr);
236
237     tmp = TC_EARLY_TX_ENABLE | TX_SLOT_TIME;
238
239     mii_reg5 = mii_read(phys[0], 5);
240     if (mii_reg5 != 0xffff && (mii_reg5 & 0x0100)) {
241         full_duplex = 1;
242         printf(" full-duplex mode");
243         tmp |= TC_LM_FULL_DPX;
244     } else
245         tmp |= TC_LM_NORMAL;
246
247     outl(tmp, txcon);
248
249     /* Give adress of RX and TX ring to the chip */
250     outl(virt_to_le32desc(&rx_ring), prcdar);
251     outl(virt_to_le32desc(&tx_ring), ptcdar);
252
253     /* Start the chip's Rx process: receive unicast and broadcast */
254     set_rx_mode();
255     outl(CR_START_RX | CR_QUEUE_RX, command);
256
257     putchar('\n');
258 }
259
260 /* Initialize the Rx and Tx rings. */
261     static void
262 epic100_init_ring(void)
263 {
264     int i;
265
266     cur_rx = cur_tx = 0;
267
268     for (i = 0; i < RX_RING_SIZE; i++) {
269         rx_ring[i].status    = cpu_to_le32(RRING_OWN);  /* Owned by Epic chip */
270         rx_ring[i].buflength = cpu_to_le32(PKT_BUF_SZ);
271         rx_ring[i].bufaddr   = virt_to_bus(&rx_packet[i * PKT_BUF_SZ]);
272         rx_ring[i].next      = virt_to_le32desc(&rx_ring[i + 1]) ;
273     }
274     /* Mark the last entry as wrapping the ring. */
275     rx_ring[i-1].next = virt_to_le32desc(&rx_ring[0]);
276
277     /*
278      *The Tx buffer descriptor is filled in as needed,
279      * but we do need to clear the ownership bit.
280      */
281
282     for (i = 0; i < TX_RING_SIZE; i++) {
283         tx_ring[i].status  = 0x0000;                    /* Owned by CPU */
284         tx_ring[i].buflength = 0x0000 | cpu_to_le32(TD_STDFLAGS << 16);
285         tx_ring[i].bufaddr = virt_to_bus(&tx_packet[i * PKT_BUF_SZ]);
286         tx_ring[i].next    = virt_to_le32desc(&tx_ring[i + 1]);
287     }
288         tx_ring[i-1].next    = virt_to_le32desc(&tx_ring[0]);
289 }
290
291 /* function: epic100_transmit
292  * This transmits a packet.
293  *
294  * Arguments: char d[6]:          destination ethernet address.
295  *            unsigned short t:   ethernet protocol type.
296  *            unsigned short s:   size of the data-part of the packet.
297  *            char *p:            the data for the packet.
298  * returns:   void.
299  */
300     static void
301 epic100_transmit(struct nic *nic, const char *destaddr, unsigned int type,
302                  unsigned int len, const char *data)
303 {
304     unsigned short nstype;
305     unsigned char *txp;
306     int entry;
307
308     /* Calculate the next Tx descriptor entry. */
309     entry = cur_tx % TX_RING_SIZE;
310
311     if ((tx_ring[entry].status & TRING_OWN) == TRING_OWN) {
312         printf("eth_transmit: Unable to transmit. status=%hX. Resetting...\n",
313                tx_ring[entry].status);
314
315         epic100_open();
316         return;
317     }
318
319     txp = tx_packet + (entry * PKT_BUF_SZ);
320
321     memcpy(txp, destaddr, ETH_ALEN);
322     memcpy(txp + ETH_ALEN, nic->node_addr, ETH_ALEN);
323     nstype = htons(type);
324     memcpy(txp + 12, (char*)&nstype, 2);
325     memcpy(txp + ETH_HLEN, data, len);
326
327     len += ETH_HLEN;
328         len &= 0x0FFF;
329         while(len < ETH_ZLEN)
330                 txp[len++] = '\0';
331     /*
332      * Caution: the write order is important here,
333      * set the base address with the "ownership"
334      * bits last.
335      */
336     
337     tx_ring[entry].buflength |= cpu_to_le32(len);
338     tx_ring[entry].status = cpu_to_le32(len << 16) | 
339             cpu_to_le32(TRING_OWN);     /* Pass ownership to the chip. */
340
341     cur_tx++;
342
343     /* Trigger an immediate transmit demand. */
344     outl(CR_QUEUE_TX, command); 
345     
346     load_timer2(10*TICKS_PER_MS);         /* timeout 10 ms for transmit */
347     while ((le32_to_cpu(tx_ring[entry].status) & (TRING_OWN)) && timer2_running())
348         /* Wait */;
349
350     if ((le32_to_cpu(tx_ring[entry].status) & TRING_OWN) != 0)
351         printf("Oops, transmitter timeout, status=%hX\n",
352             tx_ring[entry].status);
353 }
354
355 /* function: epic100_poll / eth_poll
356  * This receives a packet from the network.
357  *
358  * Arguments: none
359  *
360  * returns:   1 if a packet was received.
361  *            0 if no pacet was received.
362  * side effects:
363  *            returns the packet in the array nic->packet.
364  *            returns the length of the packet in nic->packetlen.
365  */
366
367     static int
368 epic100_poll(struct nic *nic, int retrieve)
369 {
370     int entry;
371     int retcode;
372     int status;
373     entry = cur_rx % RX_RING_SIZE;
374
375     if ((rx_ring[entry].status & cpu_to_le32(RRING_OWN)) == RRING_OWN)
376         return (0);
377
378     if ( ! retrieve ) return 1;
379
380     status = le32_to_cpu(rx_ring[entry].status);
381     /* We own the next entry, it's a new packet. Send it up. */
382
383 #if     (EPIC_DEBUG > 4)
384     printf("epic_poll: entry %d status %hX\n", entry, status);
385 #endif
386
387     cur_rx++;
388     if (status & 0x2000) {
389         printf("epic_poll: Giant packet\n");
390         retcode = 0;
391     } else if (status & 0x0006) {
392         /* Rx Frame errors are counted in hardware. */
393         printf("epic_poll: Frame received with errors\n");
394         retcode = 0;
395     } else {
396         /* Omit the four octet CRC from the length. */
397         nic->packetlen = le32_to_cpu((rx_ring[entry].buflength))- 4;
398         memcpy(nic->packet, &rx_packet[entry * PKT_BUF_SZ], nic->packetlen);
399         retcode = 1;
400     }
401
402     /* Clear all error sources. */
403     outl(status & INTR_CLEARERRS, intstat);
404
405     /* Give the descriptor back to the chip */
406     rx_ring[entry].status = RRING_OWN;
407
408     /* Restart Receiver */
409     outl(CR_START_RX | CR_QUEUE_RX, command); 
410
411     return retcode;
412 }
413
414
415 static void epic100_disable ( struct nic *nic __unused,
416                               struct pci_device *pci __unused ) {
417         /* Soft reset the chip. */
418         outl(GC_SOFT_RESET, genctl);
419 }
420
421 static void epic100_irq(struct nic *nic __unused, irq_action_t action __unused)
422 {
423   switch ( action ) {
424   case DISABLE :
425     break;
426   case ENABLE :
427     break;
428   case FORCE :
429     break;
430   }
431 }
432
433 #ifdef  DEBUG_EEPROM
434 /* Serial EEPROM section. */
435
436 /*  EEPROM_Ctrl bits. */
437 #define EE_SHIFT_CLK    0x04    /* EEPROM shift clock. */
438 #define EE_CS           0x02    /* EEPROM chip select. */
439 #define EE_DATA_WRITE   0x08    /* EEPROM chip data in. */
440 #define EE_WRITE_0      0x01
441 #define EE_WRITE_1      0x09
442 #define EE_DATA_READ    0x10    /* EEPROM chip data out. */
443 #define EE_ENB          (0x0001 | EE_CS)
444
445 /* The EEPROM commands include the alway-set leading bit. */
446 #define EE_WRITE_CMD    (5 << 6)
447 #define EE_READ_CMD     (6 << 6)
448 #define EE_ERASE_CMD    (7 << 6)
449
450 #define eeprom_delay(n) delay(n)
451
452     static int
453 read_eeprom(int location)
454 {
455     int i;
456     int retval = 0;
457     int read_cmd = location | EE_READ_CMD;
458
459     outl(EE_ENB & ~EE_CS, eectl);
460     outl(EE_ENB, eectl);
461
462     /* Shift the read command bits out. */
463     for (i = 10; i >= 0; i--) {
464         short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
465         outl(EE_ENB | dataval, eectl);
466         eeprom_delay(100);
467         outl(EE_ENB | dataval | EE_SHIFT_CLK, eectl);
468         eeprom_delay(150);
469         outl(EE_ENB | dataval, eectl);  /* Finish EEPROM a clock tick. */
470         eeprom_delay(250);
471     }
472     outl(EE_ENB, eectl);
473
474     for (i = 16; i > 0; i--) {
475         outl(EE_ENB | EE_SHIFT_CLK, eectl);
476         eeprom_delay(100);
477         retval = (retval << 1) | ((inl(eectl) & EE_DATA_READ) ? 1 : 0);
478         outl(EE_ENB, eectl);
479         eeprom_delay(100);
480     }
481
482     /* Terminate the EEPROM access. */
483     outl(EE_ENB & ~EE_CS, eectl);
484     return retval;
485 }
486 #endif
487
488
489 #define MII_READOP      1
490 #define MII_WRITEOP     2
491
492     static int
493 mii_read(int phy_id, int location)
494 {
495     int i;
496
497     outl((phy_id << 9) | (location << 4) | MII_READOP, mmctl);
498     /* Typical operation takes < 50 ticks. */
499
500     for (i = 4000; i > 0; i--)
501         if ((inl(mmctl) & MII_READOP) == 0)
502             break;
503     return inw(mmdata);
504 }
505
506 static struct nic_operations epic100_operations = {
507         .connect        = dummy_connect,
508         .poll           = epic100_poll,
509         .transmit       = epic100_transmit,
510         .irq            = epic100_irq,
511
512 };
513
514 static struct pci_id epic100_nics[] = {
515 PCI_ROM(0x10b8, 0x0005, "epic100",    "SMC EtherPowerII"),              /* SMC 83c170 EPIC/100 */
516 PCI_ROM(0x10b8, 0x0006, "smc-83c175", "SMC EPIC/C 83c175"),
517 };
518
519 static struct pci_driver epic100_driver =
520         PCI_DRIVER ( epic100_nics, PCI_NO_CLASS );
521
522 DRIVER ( "EPIC100", nic_driver, pci_driver, epic100_driver,
523          epic100_probe, epic100_disable );