Jan Kiszka provided a patch for the smc9000 for missing phy-setup
[people/xl0/gpxe-arm.git] / src / drivers / net / smc9000.c
1 #ifdef ALLMULTI
2 #error multicast support is not yet implemented
3 #endif
4  /*------------------------------------------------------------------------
5  * smc9000.c
6  * This is a Etherboot driver for SMC's 9000 series of Ethernet cards.
7  *
8  * Copyright (C) 1998 Daniel Engström <daniel.engstrom@riksnett.no>
9  * Based on the Linux SMC9000 driver, smc9194.c by Eric Stahlman
10  * Copyright (C) 1996 by Erik Stahlman <eric@vt.edu>
11  *
12  * This software may be used and distributed according to the terms
13  * of the GNU Public License, incorporated herein by reference.
14  *
15  * "Features" of the SMC chip:
16  *   4608 byte packet memory. ( for the 91C92/4.  Others have more )
17  *   EEPROM for configuration
18  *   AUI/TP selection
19  *
20  * Authors
21  *      Erik Stahlman                           <erik@vt.edu>
22  *      Daniel Engström                         <daniel.engstrom@riksnett.no>
23  *
24  * History
25  * 98-09-25              Daniel Engström Etherboot driver crated from Eric's
26  *                                       Linux driver.
27  *
28  *---------------------------------------------------------------------------*/
29 #define LINUX_OUT_MACROS 1
30 #define SMC9000_DEBUG    0
31
32 #if SMC9000_DEBUG > 1
33 #define PRINTK2 printf
34 #else
35 #define PRINTK2(args...)
36 #endif
37
38 #include "etherboot.h"
39 #include "nic.h"
40 #include "isa.h"
41 #include "timer.h"
42 #include "smc9000.h"
43
44 # define _outb outb
45 # define _outw outw
46
47 static const char       smc9000_version[] = "Version 0.99 98-09-30";
48 static const char       *interfaces[ 2 ] = { "TP", "AUI" };
49 static const char       *chip_ids[ 15 ] =  {
50    NULL, NULL, NULL,
51    /* 3 */ "SMC91C90/91C92",
52    /* 4 */ "SMC91C94",
53    /* 5 */ "SMC91C95",
54    NULL,
55    /* 7 */ "SMC91C100",
56    /* 8 */ "SMC91C100FD",
57    /* 9 */ "SMC91C11xFD",
58    NULL, NULL,
59    NULL, NULL, NULL
60 };
61 static const char      smc91c96_id[] = "SMC91C96";
62
63 /*------------------------------------------------------------
64  . Reads a register from the MII Management serial interface
65  .-------------------------------------------------------------*/
66 static word smc_read_phy_register(int ioaddr, byte phyaddr, byte phyreg)
67 {
68     int oldBank;
69     unsigned int i;
70     byte mask;
71     word mii_reg;
72     byte bits[64];
73     int clk_idx = 0;
74     int input_idx;
75     word phydata;
76
77     // 32 consecutive ones on MDO to establish sync
78     for (i = 0; i < 32; ++i)
79         bits[clk_idx++] = MII_MDOE | MII_MDO;
80
81     // Start code <01>
82     bits[clk_idx++] = MII_MDOE;
83     bits[clk_idx++] = MII_MDOE | MII_MDO;
84
85     // Read command <10>
86     bits[clk_idx++] = MII_MDOE | MII_MDO;
87     bits[clk_idx++] = MII_MDOE;
88
89     // Output the PHY address, msb first
90     mask = (byte)0x10;
91     for (i = 0; i < 5; ++i)
92     {
93         if (phyaddr & mask)
94             bits[clk_idx++] = MII_MDOE | MII_MDO;
95         else
96             bits[clk_idx++] = MII_MDOE;
97
98         // Shift to next lowest bit
99         mask >>= 1;
100     }
101
102     // Output the phy register number, msb first
103     mask = (byte)0x10;
104     for (i = 0; i < 5; ++i)
105     {
106         if (phyreg & mask)
107             bits[clk_idx++] = MII_MDOE | MII_MDO;
108         else
109             bits[clk_idx++] = MII_MDOE;
110
111         // Shift to next lowest bit
112         mask >>= 1;
113     }
114
115     // Tristate and turnaround (2 bit times)
116     bits[clk_idx++] = 0;
117     //bits[clk_idx++] = 0;
118
119     // Input starts at this bit time
120     input_idx = clk_idx;
121
122     // Will input 16 bits
123     for (i = 0; i < 16; ++i)
124         bits[clk_idx++] = 0;
125
126     // Final clock bit
127     bits[clk_idx++] = 0;
128
129     // Save the current bank
130     oldBank = inw( ioaddr+BANK_SELECT );
131
132     // Select bank 3
133     SMC_SELECT_BANK(ioaddr, 3);
134
135     // Get the current MII register value
136     mii_reg = inw( ioaddr+MII_REG );
137
138     // Turn off all MII Interface bits
139     mii_reg &= ~(MII_MDOE|MII_MCLK|MII_MDI|MII_MDO);
140
141     // Clock all 64 cycles
142     for (i = 0; i < sizeof(bits); ++i)
143     {
144         // Clock Low - output data
145         outw( mii_reg | bits[i], ioaddr+MII_REG );
146         udelay(50);
147
148
149         // Clock Hi - input data
150         outw( mii_reg | bits[i] | MII_MCLK, ioaddr+MII_REG );
151         udelay(50);
152         bits[i] |= inw( ioaddr+MII_REG ) & MII_MDI;
153     }
154
155     // Return to idle state
156     // Set clock to low, data to low, and output tristated
157     outw( mii_reg, ioaddr+MII_REG );
158     udelay(50);
159
160     // Restore original bank select
161     SMC_SELECT_BANK(ioaddr, oldBank);
162
163     // Recover input data
164     phydata = 0;
165     for (i = 0; i < 16; ++i)
166     {
167         phydata <<= 1;
168
169         if (bits[input_idx++] & MII_MDI)
170             phydata |= 0x0001;
171     }
172
173 #if (SMC_DEBUG > 2 )
174         printf("smc_read_phy_register(): phyaddr=%x,phyreg=%x,phydata=%x\n",
175                phyaddr, phyreg, phydata);
176 #endif
177
178         return(phydata);
179 }
180
181
182 /*------------------------------------------------------------
183  . Writes a register to the MII Management serial interface
184  .-------------------------------------------------------------*/
185 static void smc_write_phy_register(int ioaddr,
186                                    byte phyaddr, byte phyreg, word phydata)
187 {
188     int oldBank;
189     unsigned int i;
190     word mask;
191     word mii_reg;
192     byte bits[65];
193     int clk_idx = 0;
194
195     // 32 consecutive ones on MDO to establish sync
196     for (i = 0; i < 32; ++i)
197         bits[clk_idx++] = MII_MDOE | MII_MDO;
198
199     // Start code <01>
200     bits[clk_idx++] = MII_MDOE;
201     bits[clk_idx++] = MII_MDOE | MII_MDO;
202
203     // Write command <01>
204     bits[clk_idx++] = MII_MDOE;
205     bits[clk_idx++] = MII_MDOE | MII_MDO;
206
207     // Output the PHY address, msb first
208     mask = (byte)0x10;
209     for (i = 0; i < 5; ++i)
210     {
211         if (phyaddr & mask)
212             bits[clk_idx++] = MII_MDOE | MII_MDO;
213         else
214             bits[clk_idx++] = MII_MDOE;
215
216                 // Shift to next lowest bit
217         mask >>= 1;
218     }
219
220     // Output the phy register number, msb first
221     mask = (byte)0x10;
222     for (i = 0; i < 5; ++i)
223     {
224         if (phyreg & mask)
225             bits[clk_idx++] = MII_MDOE | MII_MDO;
226         else
227             bits[clk_idx++] = MII_MDOE;
228
229         // Shift to next lowest bit
230         mask >>= 1;
231     }
232
233     // Tristate and turnaround (2 bit times)
234     bits[clk_idx++] = 0;
235     bits[clk_idx++] = 0;
236
237     // Write out 16 bits of data, msb first
238     mask = 0x8000;
239     for (i = 0; i < 16; ++i)
240     {
241         if (phydata & mask)
242             bits[clk_idx++] = MII_MDOE | MII_MDO;
243         else
244             bits[clk_idx++] = MII_MDOE;
245
246         // Shift to next lowest bit
247         mask >>= 1;
248     }
249
250     // Final clock bit (tristate)
251     bits[clk_idx++] = 0;
252
253     // Save the current bank
254     oldBank = inw( ioaddr+BANK_SELECT );
255
256     // Select bank 3
257     SMC_SELECT_BANK(ioaddr, 3);
258
259     // Get the current MII register value
260     mii_reg = inw( ioaddr+MII_REG );
261
262     // Turn off all MII Interface bits
263     mii_reg &= ~(MII_MDOE|MII_MCLK|MII_MDI|MII_MDO);
264
265     // Clock all cycles
266     for (i = 0; i < sizeof(bits); ++i)
267     {
268         // Clock Low - output data
269         outw( mii_reg | bits[i], ioaddr+MII_REG );
270         udelay(50);
271
272
273         // Clock Hi - input data
274         outw( mii_reg | bits[i] | MII_MCLK, ioaddr+MII_REG );
275         udelay(50);
276         bits[i] |= inw( ioaddr+MII_REG ) & MII_MDI;
277     }
278
279     // Return to idle state
280     // Set clock to low, data to low, and output tristated
281     outw( mii_reg, ioaddr+MII_REG );
282     udelay(50);
283
284     // Restore original bank select
285     SMC_SELECT_BANK(ioaddr, oldBank);
286
287 #if (SMC_DEBUG > 2 )
288         printf("smc_write_phy_register(): phyaddr=%x,phyreg=%x,phydata=%x\n",
289                phyaddr, phyreg, phydata);
290 #endif
291 }
292
293
294 /*------------------------------------------------------------
295  . Finds and reports the PHY address
296  .-------------------------------------------------------------*/
297 static int smc_detect_phy(int ioaddr, byte *pphyaddr)
298 {
299     word phy_id1;
300     word phy_id2;
301     int phyaddr;
302     int found = 0;
303
304     // Scan all 32 PHY addresses if necessary
305     for (phyaddr = 0; phyaddr < 32; ++phyaddr)
306     {
307         // Read the PHY identifiers
308         phy_id1  = smc_read_phy_register(ioaddr, phyaddr, PHY_ID1_REG);
309         phy_id2  = smc_read_phy_register(ioaddr, phyaddr, PHY_ID2_REG);
310
311         // Make sure it is a valid identifier
312         if ((phy_id2 > 0x0000) && (phy_id2 < 0xffff) &&
313              (phy_id1 > 0x0000) && (phy_id1 < 0xffff))
314         {
315             if ((phy_id1 != 0x8000) && (phy_id2 != 0x8000))
316             {
317                 // Save the PHY's address
318                 *pphyaddr = phyaddr;
319                 found = 1;
320                 break;
321             }
322         }
323     }
324
325     if (!found)
326     {
327         printf("No PHY found\n");
328         return(0);
329     }
330
331     // Set the PHY type
332     if ( (phy_id1 == 0x0016) && ((phy_id2 & 0xFFF0) == 0xF840 ) )
333     {
334         printf("PHY=LAN83C183 (LAN91C111 Internal)\n");
335     }
336
337     if ( (phy_id1 == 0x0282) && ((phy_id2 & 0xFFF0) == 0x1C50) )
338     {
339         printf("PHY=LAN83C180\n");
340     }
341
342     return(1);
343 }
344
345 /*------------------------------------------------------------
346  . Configures the specified PHY using Autonegotiation. Calls
347  . smc_phy_fixed() if the user has requested a certain config.
348  .-------------------------------------------------------------*/
349 static void smc_phy_configure(int ioaddr)
350 {
351     int timeout;
352     byte phyaddr;
353     word my_phy_caps; // My PHY capabilities
354     word my_ad_caps; // My Advertised capabilities
355     word status;
356     int failed = 0;
357     int rpc_cur_mode = RPC_DEFAULT;
358     int lastPhy18;
359
360     // Find the address and type of our phy
361     if (!smc_detect_phy(ioaddr, &phyaddr))
362     {
363         return;
364     }
365
366     // Reset the PHY, setting all other bits to zero
367     smc_write_phy_register(ioaddr, phyaddr, PHY_CNTL_REG, PHY_CNTL_RST);
368
369     // Wait for the reset to complete, or time out
370     timeout = 6; // Wait up to 3 seconds
371     while (timeout--)
372     {
373         if (!(smc_read_phy_register(ioaddr, phyaddr, PHY_CNTL_REG)
374               & PHY_CNTL_RST))
375         {
376             // reset complete
377             break;
378         }
379
380         mdelay(500); // wait 500 millisecs
381     }
382
383     if (timeout < 1)
384     {
385         PRINTK2("PHY reset timed out\n");
386         return;
387     }
388
389     // Read PHY Register 18, Status Output
390     lastPhy18 = smc_read_phy_register(ioaddr, phyaddr, PHY_INT_REG);
391
392     // Enable PHY Interrupts (for register 18)
393     // Interrupts listed here are disabled
394     smc_write_phy_register(ioaddr, phyaddr, PHY_MASK_REG,
395                            PHY_INT_LOSSSYNC | PHY_INT_CWRD | PHY_INT_SSD |
396                                    PHY_INT_ESD | PHY_INT_RPOL | PHY_INT_JAB |
397                                    PHY_INT_SPDDET | PHY_INT_DPLXDET);
398
399     /* Configure the Receive/Phy Control register */
400     SMC_SELECT_BANK(ioaddr, 0);
401     outw( rpc_cur_mode, ioaddr + RPC_REG );
402
403     // Copy our capabilities from PHY_STAT_REG to PHY_AD_REG
404     my_phy_caps = smc_read_phy_register(ioaddr, phyaddr, PHY_STAT_REG);
405     my_ad_caps  = PHY_AD_CSMA; // I am CSMA capable
406
407     if (my_phy_caps & PHY_STAT_CAP_T4)
408         my_ad_caps |= PHY_AD_T4;
409
410     if (my_phy_caps & PHY_STAT_CAP_TXF)
411         my_ad_caps |= PHY_AD_TX_FDX;
412
413     if (my_phy_caps & PHY_STAT_CAP_TXH)
414         my_ad_caps |= PHY_AD_TX_HDX;
415
416     if (my_phy_caps & PHY_STAT_CAP_TF)
417         my_ad_caps |= PHY_AD_10_FDX;
418
419     if (my_phy_caps & PHY_STAT_CAP_TH)
420         my_ad_caps |= PHY_AD_10_HDX;
421
422     // Update our Auto-Neg Advertisement Register
423     smc_write_phy_register(ioaddr, phyaddr, PHY_AD_REG, my_ad_caps);
424
425     PRINTK2("phy caps=%x\n", my_phy_caps);
426     PRINTK2("phy advertised caps=%x\n", my_ad_caps);
427
428     // Restart auto-negotiation process in order to advertise my caps
429     smc_write_phy_register( ioaddr, phyaddr, PHY_CNTL_REG,
430                             PHY_CNTL_ANEG_EN | PHY_CNTL_ANEG_RST );
431
432     // Wait for the auto-negotiation to complete.  This may take from
433     // 2 to 3 seconds.
434     // Wait for the reset to complete, or time out
435     timeout = 20; // Wait up to 10 seconds
436     while (timeout--)
437     {
438         status = smc_read_phy_register(ioaddr, phyaddr, PHY_STAT_REG);
439         if (status & PHY_STAT_ANEG_ACK)
440         {
441             // auto-negotiate complete
442             break;
443         }
444
445         mdelay(500); // wait 500 millisecs
446
447         // Restart auto-negotiation if remote fault
448         if (status & PHY_STAT_REM_FLT)
449         {
450             PRINTK2("PHY remote fault detected\n");
451
452             // Restart auto-negotiation
453             PRINTK2("PHY restarting auto-negotiation\n");
454             smc_write_phy_register( ioaddr, phyaddr, PHY_CNTL_REG,
455                                     PHY_CNTL_ANEG_EN | PHY_CNTL_ANEG_RST |
456                                     PHY_CNTL_SPEED | PHY_CNTL_DPLX);
457         }
458     }
459
460     if (timeout < 1)
461     {
462         PRINTK2("PHY auto-negotiate timed out\n");
463         failed = 1;
464     }
465
466     // Fail if we detected an auto-negotiate remote fault
467     if (status & PHY_STAT_REM_FLT)
468     {
469         PRINTK2("PHY remote fault detected\n");
470         failed = 1;
471     }
472
473     // Set our sysctl parameters to match auto-negotiation results
474     if ( lastPhy18 & PHY_INT_SPDDET )
475     {
476         PRINTK2("PHY 100BaseT\n");
477         rpc_cur_mode |= RPC_SPEED;
478     }
479     else
480     {
481         PRINTK2("PHY 10BaseT\n");
482         rpc_cur_mode &= ~RPC_SPEED;
483     }
484
485     if ( lastPhy18 & PHY_INT_DPLXDET )
486     {
487         PRINTK2("PHY Full Duplex\n");
488         rpc_cur_mode |= RPC_DPLX;
489     }
490     else
491     {
492         PRINTK2("PHY Half Duplex\n");
493         rpc_cur_mode &= ~RPC_DPLX;
494     }
495
496     // Re-Configure the Receive/Phy Control register
497     outw( rpc_cur_mode, ioaddr + RPC_REG );
498 }
499
500 /*
501  * Function: smc_reset( int ioaddr )
502  * Purpose:
503  *      This sets the SMC91xx chip to its normal state, hopefully from whatever
504  *      mess that any other DOS driver has put it in.
505  *
506  * Maybe I should reset more registers to defaults in here?  SOFTRESET  should
507  * do that for me.
508  *
509  * Method:
510  *      1.  send a SOFT RESET
511  *      2.  wait for it to finish
512  *      3.  reset the memory management unit
513  *      4.  clear all interrupts
514  *
515 */
516 static void smc_reset(int ioaddr)
517 {
518    /* This resets the registers mostly to defaults, but doesn't
519     * affect EEPROM.  That seems unnecessary */
520    SMC_SELECT_BANK(ioaddr, 0);
521    _outw( RCR_SOFTRESET, ioaddr + RCR );
522
523    /* this should pause enough for the chip to be happy */
524    SMC_DELAY(ioaddr);
525
526    /* Set the transmit and receive configuration registers to
527     * default values */
528    _outw(RCR_CLEAR, ioaddr + RCR);
529    _outw(TCR_CLEAR, ioaddr + TCR);
530
531    /* Reset the MMU */
532    SMC_SELECT_BANK(ioaddr, 2);
533    _outw( MC_RESET, ioaddr + MMU_CMD );
534
535    /* Note:  It doesn't seem that waiting for the MMU busy is needed here,
536     * but this is a place where future chipsets _COULD_ break.  Be wary
537     * of issuing another MMU command right after this */
538    _outb(0, ioaddr + INT_MASK);
539 }
540
541
542 /*----------------------------------------------------------------------
543  * Function: smc9000_probe_addr( int ioaddr )
544  *
545  * Purpose:
546  *      Tests to see if a given ioaddr points to an SMC9xxx chip.
547  *      Returns a 1 on success
548  *
549  * Algorithm:
550  *      (1) see if the high byte of BANK_SELECT is 0x33
551  *      (2) compare the ioaddr with the base register's address
552  *      (3) see if I recognize the chip ID in the appropriate register
553  *
554  * ---------------------------------------------------------------------
555  */
556 static int smc9000_probe_addr( isa_probe_addr_t ioaddr )
557 {
558    word bank;
559    word revision_register;
560    word base_address_register;
561
562    /* First, see if the high byte is 0x33 */
563    bank = inw(ioaddr + BANK_SELECT);
564    if ((bank & 0xFF00) != 0x3300) {
565       return 0;
566    }
567    /* The above MIGHT indicate a device, but I need to write to further
568     *   test this.  */
569    _outw(0x0, ioaddr + BANK_SELECT);
570    bank = inw(ioaddr + BANK_SELECT);
571    if ((bank & 0xFF00) != 0x3300) {
572       return 0;
573    }
574
575    /* well, we've already written once, so hopefully another time won't
576     *  hurt.  This time, I need to switch the bank register to bank 1,
577     *  so I can access the base address register */
578    SMC_SELECT_BANK(ioaddr, 1);
579    base_address_register = inw(ioaddr + BASE);
580
581    if (ioaddr != (base_address_register >> 3 & 0x3E0))  {
582       DBG("SMC9000: IOADDR %hX doesn't match configuration (%hX)."
583           "Probably not a SMC chip\n",
584           ioaddr, base_address_register >> 3 & 0x3E0);
585       /* well, the base address register didn't match.  Must not have
586        * been a SMC chip after all. */
587       return 0;
588    }
589
590
591    /* check if the revision register is something that I recognize.
592     * These might need to be added to later, as future revisions
593     * could be added.  */
594    SMC_SELECT_BANK(ioaddr, 3);
595    revision_register  = inw(ioaddr + REVISION);
596    if (!chip_ids[(revision_register >> 4) & 0xF]) {
597       /* I don't recognize this chip, so... */
598       DBG( "SMC9000: IO %hX: Unrecognized revision register:"
599            " %hX, Contact author.\n", ioaddr, revision_register );
600       return 0;
601    }
602
603    /* at this point I'll assume that the chip is an SMC9xxx.
604     * It might be prudent to check a listing of MAC addresses
605     * against the hardware address, or do some other tests. */
606    return 1;
607 }
608
609
610 /**************************************************************************
611  * ETH_TRANSMIT - Transmit a frame
612  ***************************************************************************/
613 static void smc9000_transmit(
614         struct nic *nic,
615         const char *d,                  /* Destination */
616         unsigned int t,                 /* Type */
617         unsigned int s,                 /* size */
618         const char *p)                  /* Packet */
619 {
620    word length; /* real, length incl. header */
621    word numPages;
622    unsigned long time_out;
623    byte packet_no;
624    word status;
625    int i;
626
627    /* We dont pad here since we can have the hardware doing it for us */
628    length = (s + ETH_HLEN + 1)&~1;
629
630    /* convert to MMU pages */
631    numPages = length / 256;
632
633    if (numPages > 7 ) {
634       DBG("SMC9000: Far too big packet error. \n");
635       return;
636    }
637
638    /* dont try more than, say 30 times */
639    for (i=0;i<30;i++) {
640       /* now, try to allocate the memory */
641       SMC_SELECT_BANK(nic->ioaddr, 2);
642       _outw(MC_ALLOC | numPages, nic->ioaddr + MMU_CMD);
643
644       status = 0;
645       /* wait for the memory allocation to finnish */
646       for (time_out = currticks() + 5*TICKS_PER_SEC; currticks() < time_out; ) {
647          status = inb(nic->ioaddr + INTERRUPT);
648          if ( status & IM_ALLOC_INT ) {
649             /* acknowledge the interrupt */
650             _outb(IM_ALLOC_INT, nic->ioaddr + INTERRUPT);
651             break;
652          }
653       }
654
655       if ((status & IM_ALLOC_INT) != 0 ) {
656          /* We've got the memory */
657          break;
658       } else {
659          printf("SMC9000: Memory allocation timed out, resetting MMU.\n");
660          _outw(MC_RESET, nic->ioaddr + MMU_CMD);
661       }
662    }
663
664    /* If I get here, I _know_ there is a packet slot waiting for me */
665    packet_no = inb(nic->ioaddr + PNR_ARR + 1);
666    if (packet_no & 0x80) {
667       /* or isn't there?  BAD CHIP! */
668       printf("SMC9000: Memory allocation failed. \n");
669       return;
670    }
671
672    /* we have a packet address, so tell the card to use it */
673    _outb(packet_no, nic->ioaddr + PNR_ARR);
674
675    /* point to the beginning of the packet */
676    _outw(PTR_AUTOINC, nic->ioaddr + POINTER);
677
678 #if     SMC9000_DEBUG > 2
679    printf("Trying to xmit packet of length %hX\n", length );
680 #endif
681
682    /* send the packet length ( +6 for status, length and ctl byte )
683     * and the status word ( set to zeros ) */
684    _outw(0, nic->ioaddr + DATA_1 );
685
686    /* send the packet length ( +6 for status words, length, and ctl) */
687    _outb((length+6) & 0xFF,  nic->ioaddr + DATA_1);
688    _outb((length+6) >> 8 ,   nic->ioaddr + DATA_1);
689
690    /* Write the contents of the packet */
691
692    /* The ethernet header first... */
693    outsw(nic->ioaddr + DATA_1, d, ETH_ALEN >> 1);
694    outsw(nic->ioaddr + DATA_1, nic->node_addr, ETH_ALEN >> 1);
695    _outw(htons(t), nic->ioaddr + DATA_1);
696
697    /* ... the data ... */
698    outsw(nic->ioaddr + DATA_1 , p, s >> 1);
699
700    /* ... and the last byte, if there is one.   */
701    if ((s & 1) == 0) {
702       _outw(0, nic->ioaddr + DATA_1);
703    } else {
704       _outb(p[s-1], nic->ioaddr + DATA_1);
705       _outb(0x20, nic->ioaddr + DATA_1);
706    }
707
708    /* and let the chipset deal with it */
709    _outw(MC_ENQUEUE , nic->ioaddr + MMU_CMD);
710
711    status = 0; time_out = currticks() + 5*TICKS_PER_SEC;
712    do {
713       status = inb(nic->ioaddr + INTERRUPT);
714
715       if ((status & IM_TX_INT ) != 0) {
716          word tx_status;
717
718          /* ack interrupt */
719          _outb(IM_TX_INT, nic->ioaddr + INTERRUPT);
720
721          packet_no = inw(nic->ioaddr + FIFO_PORTS);
722          packet_no &= 0x7F;
723
724          /* select this as the packet to read from */
725          _outb( packet_no, nic->ioaddr + PNR_ARR );
726
727          /* read the first word from this packet */
728          _outw( PTR_AUTOINC | PTR_READ, nic->ioaddr + POINTER );
729
730          tx_status = inw( nic->ioaddr + DATA_1 );
731
732          if (0 == (tx_status & TS_SUCCESS)) {
733             DBG("SMC9000: TX FAIL STATUS: %hX \n", tx_status);
734             /* re-enable transmit */
735             SMC_SELECT_BANK(nic->ioaddr, 0);
736             _outw(inw(nic->ioaddr + TCR ) | TCR_ENABLE, nic->ioaddr + TCR );
737          }
738
739          /* kill the packet */
740          SMC_SELECT_BANK(nic->ioaddr, 2);
741          _outw(MC_FREEPKT, nic->ioaddr + MMU_CMD);
742
743          return;
744       }
745    }while(currticks() < time_out);
746
747    printf("SMC9000: TX timed out, resetting board\n");
748    smc_reset(nic->ioaddr);
749    return;
750 }
751
752 /**************************************************************************
753  * ETH_POLL - Wait for a frame
754  ***************************************************************************/
755 static int smc9000_poll(struct nic *nic, int retrieve)
756 {
757    SMC_SELECT_BANK(nic->ioaddr, 2);
758    if (inw(nic->ioaddr + FIFO_PORTS) & FP_RXEMPTY)
759      return 0;
760    
761    if ( ! retrieve ) return 1;
762
763    /*  start reading from the start of the packet */
764    _outw(PTR_READ | PTR_RCV | PTR_AUTOINC, nic->ioaddr + POINTER);
765
766    /* First read the status and check that we're ok */
767    if (!(inw(nic->ioaddr + DATA_1) & RS_ERRORS)) {
768       /* Next: read the packet length and mask off the top bits */
769       nic->packetlen = (inw(nic->ioaddr + DATA_1) & 0x07ff);
770
771       /* the packet length includes the 3 extra words */
772       nic->packetlen -= 6;
773 #if     SMC9000_DEBUG > 2
774       printf(" Reading %d words (and %d byte(s))\n",
775                (nic->packetlen >> 1), nic->packetlen & 1);
776 #endif
777       /* read the packet (and the last "extra" word) */
778       insw(nic->ioaddr + DATA_1, nic->packet, (nic->packetlen+2) >> 1);
779       /* is there an odd last byte ? */
780       if (nic->packet[nic->packetlen+1] & 0x20)
781          nic->packetlen++;
782
783       /*  error or good, tell the card to get rid of this packet */
784       _outw(MC_RELEASE, nic->ioaddr + MMU_CMD);
785       return 1;
786    }
787
788    printf("SMC9000: RX error\n");
789    /*  error or good, tell the card to get rid of this packet */
790    _outw(MC_RELEASE, nic->ioaddr + MMU_CMD);
791    return 0;
792 }
793
794 static void smc9000_disable ( struct nic *nic, struct isa_device *isa __unused ) {
795    nic_disable ( nic );
796    smc_reset(nic->ioaddr);
797
798    /* no more interrupts for me */
799    SMC_SELECT_BANK(nic->ioaddr, 2);
800    _outb( 0, nic->ioaddr + INT_MASK);
801
802    /* and tell the card to stay away from that nasty outside world */
803    SMC_SELECT_BANK(nic->ioaddr, 0);
804    _outb( RCR_CLEAR, nic->ioaddr + RCR );
805    _outb( TCR_CLEAR, nic->ioaddr + TCR );
806 }
807
808 static void smc9000_irq(struct nic *nic __unused, irq_action_t action __unused)
809 {
810   switch ( action ) {
811   case DISABLE :
812     break;
813   case ENABLE :
814     break;
815   case FORCE :
816     break;
817   }
818 }
819
820 static struct nic_operations smc9000_operations = {
821         .connect        = dummy_connect,
822         .poll           = smc9000_poll,
823         .transmit       = smc9000_transmit,
824         .irq            = smc9000_irq,
825
826 };
827
828 /**************************************************************************
829  * ETH_PROBE - Look for an adapter
830  ***************************************************************************/
831
832 static int smc9000_probe ( struct nic *nic, struct isa_device *isa ) {
833
834    unsigned short   revision;
835    int              memory;
836    int              media;
837    const char *     version_string;
838    const char *     if_string;
839    int              i;
840
841    nic->irqno  = 0;
842    isa_fill_nic ( nic, isa );
843    nic->ioaddr = isa->ioaddr;
844
845    /*
846     * Get the MAC address ( bank 1, regs 4 - 9 )
847     */
848    SMC_SELECT_BANK(nic->ioaddr, 1);
849    for ( i = 0; i < 6; i += 2 ) {
850       word address;
851
852       address = inw(nic->ioaddr + ADDR0 + i);
853       nic->node_addr[i+1] = address >> 8;
854       nic->node_addr[i] = address & 0xFF;
855    }
856
857    /* get the memory information */
858    SMC_SELECT_BANK(nic->ioaddr, 0);
859    memory = ( inw(nic->ioaddr + MCR) >> 9 )  & 0x7;  /* multiplier */
860    memory *= 256 * (inw(nic->ioaddr + MIR) & 0xFF);
861
862    /*
863     * Now, I want to find out more about the chip.  This is sort of
864     * redundant, but it's cleaner to have it in both, rather than having
865     * one VERY long probe procedure.
866     */
867    SMC_SELECT_BANK(nic->ioaddr, 3);
868    revision  = inw(nic->ioaddr + REVISION);
869    version_string = chip_ids[(revision >> 4) & 0xF];
870
871    if (((revision & 0xF0) >> 4 == CHIP_9196) &&
872        ((revision & 0x0F) >= REV_9196)) {
873       /* This is a 91c96. 'c96 has the same chip id as 'c94 (4) but
874        * a revision starting at 6 */
875       version_string = smc91c96_id;
876    }
877
878    if ( !version_string ) {
879       /* I shouldn't get here because this call was done before.... */
880       return 0;
881    }
882
883    /* is it using AUI or 10BaseT ? */
884    SMC_SELECT_BANK(nic->ioaddr, 1);
885    if (inw(nic->ioaddr + CONFIG) & CFG_AUI_SELECT)
886      media = 2;
887    else
888      media = 1;
889
890    if_string = interfaces[media - 1];
891
892    /* now, reset the chip, and put it into a known state */
893    smc_reset(nic->ioaddr);
894
895    printf("SMC9000 %s\n", smc9000_version);
896    DBG("Copyright (C) 1998 Daniel Engstr\x94m\n");
897    DBG("Copyright (C) 1996 Eric Stahlman\n");
898
899    printf("%s rev:%d I/O port:%hX Interface:%s RAM:%d bytes \n",
900           version_string, revision & 0xF,
901           nic->ioaddr, if_string, memory );
902    /*
903     * Print the Ethernet address
904     */
905    printf("Ethernet MAC address: %!\n", nic->node_addr);
906
907    SMC_SELECT_BANK(nic->ioaddr, 0);
908
909    /* see the header file for options in TCR/RCR NORMAL*/
910    _outw(TCR_NORMAL, nic->ioaddr + TCR);
911    _outw(RCR_NORMAL, nic->ioaddr + RCR);
912
913    /* Select which interface to use */
914    SMC_SELECT_BANK(nic->ioaddr, 1);
915    if ( media == 1 ) {
916       _outw( inw( nic->ioaddr + CONFIG ) & ~CFG_AUI_SELECT,
917            nic->ioaddr + CONFIG );
918    }
919    else if ( media == 2 ) {
920       _outw( inw( nic->ioaddr + CONFIG ) | CFG_AUI_SELECT,
921            nic->ioaddr + CONFIG );
922    }
923
924    smc_phy_configure(nic->ioaddr);
925  
926    nic->nic_op  = &smc9000_operations;
927    return 1;
928 }
929
930 /*
931  * The SMC9000 can be at any of the following port addresses.  To
932  * change for a slightly different card, you can add it to the array.
933  *
934  */
935 static isa_probe_addr_t smc9000_probe_addrs[] = {
936    0x200, 0x220, 0x240, 0x260, 0x280, 0x2A0, 0x2C0, 0x2E0,
937    0x300, 0x320, 0x340, 0x360, 0x380, 0x3A0, 0x3C0, 0x3E0,
938 };
939
940 ISA_DRIVER ( smc9000_driver, smc9000_probe_addrs, smc9000_probe_addr,
941                      GENERIC_ISAPNP_VENDOR, 0x8228 );
942
943 DRIVER ( "SMC9000", nic_driver, isa_driver, smc9000_driver,
944          smc9000_probe, smc9000_disable );
945
946 ISA_ROM ( "smc9000", "SMC9000" );
947
948 /*
949  * Local variables:
950  *  c-basic-offset: 3
951  * End:
952  */