qemu/roms/ipxe/src/drivers/net/cs89x0.c

   1 #ifdef ALLMULTI
   2 #error multicast support is not yet implemented
   3 #endif
   4
   5 /**
   6    Per an email message from Russ Nelson <nelson@crynwr.com> on
   7    18 March 2008 this file is now licensed under GPL Version 2.
   8
   9    From: Russ Nelson <nelson@crynwr.com>
  10    Date: Tue, 18 Mar 2008 12:42:00 -0400
  11    Subject: Re: [Etherboot-developers] cs89x0 driver in etherboot
  12    -- quote from email
  13    As copyright holder, if I say it doesn't conflict with the GPL,
  14    then it doesn't conflict with the GPL.
  15
  16    However, there's no point in causing people's brains to overheat,
  17    so yes, I grant permission for the code to be relicensed under the
  18    GPLv2.  Please make sure that this change in licensing makes its
  19    way upstream.  -russ
  20    -- quote from email
  21 **/
  22
  23 FILE_LICENCE ( GPL2_ONLY );
  24
  25 /* cs89x0.c: A Crystal Semiconductor CS89[02]0 driver for etherboot. */
  26 /*
  27   Permission is granted to distribute the enclosed cs89x0.[ch] driver
  28   only in conjunction with the Etherboot package.  The code is
  29   ordinarily distributed under the GPL.
  30
  31   Russ Nelson, January 2000
  32
  33   ChangeLog:
  34
  35   Thu Dec 6 22:40:00 1996  Markus Gutschke  <gutschk@math.uni-muenster.de>
  36
  37   * disabled all "advanced" features; this should make the code more reliable
  38
  39   * reorganized the reset function
  40
  41   * always reset the address port, so that autoprobing will continue working
  42
  43   * some cosmetic changes
  44
  45   * 2.5
  46
  47   Thu Dec 5 21:00:00 1996  Markus Gutschke  <gutschk@math.uni-muenster.de>
  48
  49   * tested the code against a CS8900 card
  50
  51   * lots of minor bug fixes and adjustments
  52
  53   * this is the first release, that actually works! it still requires some
  54     changes in order to be more tolerant to different environments
  55
  56   * 4
  57
  58   Fri Nov 22 23:00:00 1996  Markus Gutschke  <gutschk@math.uni-muenster.de>
  59
  60   * read the manuals for the CS89x0 chipsets and took note of all the
  61     changes that will be necessary in order to adapt Russel Nelson's code
  62     to the requirements of a BOOT-Prom
  63
  64   * 6
  65
  66   Thu Nov 19 22:00:00 1996  Markus Gutschke  <gutschk@math.uni-muenster.de>
  67
  68   * Synched with Russel Nelson's current code (v1.00)
  69
  70   * 2
  71
  72   Thu Nov 12 18:00:00 1996  Markus Gutschke  <gutschk@math.uni-muenster.de>
  73
  74   * Cleaned up some of the code and tried to optimize the code size.
  75
  76   * 1.5
  77
  78   Sun Nov 10 16:30:00 1996  Markus Gutschke  <gutschk@math.uni-muenster.de>
  79
  80   * First experimental release. This code compiles fine, but I
  81   have no way of testing whether it actually works.
  82
  83   * I did not (yet) bother to make the code 16bit aware, so for
  84   the time being, it will only work for Etherboot/32.
  85
  86   * 12
  87
  88   */
  89
  90 #include <errno.h>
  91 #include <ipxe/ethernet.h>
  92 #include "etherboot.h"
  93 #include "nic.h"
  94 #include <ipxe/isa.h>
  95 #include "cs89x0.h"
  96
  97 static unsigned short   eth_nic_base;
  98 static unsigned long    eth_mem_start;
  99 static unsigned short   eth_irqno;
 100 static unsigned short   eth_cs_type;    /* one of: CS8900, CS8920, CS8920M  */
 101 static unsigned short   eth_auto_neg_cnf;
 102 static unsigned short   eth_adapter_cnf;
 103 static unsigned short   eth_linectl;
 104
 105 /*************************************************************************
 106         CS89x0 - specific routines
 107 **************************************************************************/
 108
 109 static inline int readreg(int portno)
 110 {
 111         outw(portno, eth_nic_base + ADD_PORT);
 112         return inw(eth_nic_base + DATA_PORT);
 113 }
 114
 115 static inline void writereg(int portno, int value)
 116 {
 117         outw(portno, eth_nic_base + ADD_PORT);
 118         outw(value, eth_nic_base + DATA_PORT);
 119         return;
 120 }
 121
 122 /*************************************************************************
 123 EEPROM access
 124 **************************************************************************/
 125
 126 static int wait_eeprom_ready(void)
 127 {
 128         unsigned long tmo = currticks() + 4*TICKS_PER_SEC;
 129
 130         /* check to see if the EEPROM is ready, a timeout is used -
 131            just in case EEPROM is ready when SI_BUSY in the
 132            PP_SelfST is clear */
 133         while(readreg(PP_SelfST) & SI_BUSY) {
 134                 if (currticks() >= tmo)
 135                         return -1; }
 136         return 0;
 137 }
 138
 139 static int get_eeprom_data(int off, int len, unsigned short *buffer)
 140 {
 141         int i;
 142
 143 #ifdef  EDEBUG
 144         printf("\ncs: EEPROM data from %hX for %hX:",off,len);
 145 #endif
 146         for (i = 0; i < len; i++) {
 147                 if (wait_eeprom_ready() < 0)
 148                         return -1;
 149                 /* Now send the EEPROM read command and EEPROM location
 150                    to read */
 151                 writereg(PP_EECMD, (off + i) | EEPROM_READ_CMD);
 152                 if (wait_eeprom_ready() < 0)
 153                         return -1;
 154                 buffer[i] = readreg(PP_EEData);
 155 #ifdef  EDEBUG
 156                 if (!(i%10))
 157                         printf("\ncs: ");
 158                 printf("%hX ", buffer[i]);
 159 #endif
 160         }
 161 #ifdef  EDEBUG
 162         putchar('\n');
 163 #endif
 164
 165         return(0);
 166 }
 167
 168 static int get_eeprom_chksum(int off __unused, int len, unsigned short *buffer)
 169 {
 170         int  i, cksum;
 171
 172         cksum = 0;
 173         for (i = 0; i < len; i++)
 174                 cksum += buffer[i];
 175         cksum &= 0xffff;
 176         if (cksum == 0)
 177                 return 0;
 178         return -1;
 179 }
 180
 181 /*************************************************************************
 182 Activate all of the available media and probe for network
 183 **************************************************************************/
 184
 185 static void clrline(void)
 186 {
 187         int i;
 188
 189         putchar('\r');
 190         for (i = 79; i--; ) putchar(' ');
 191         printf("\rcs: ");
 192         return;
 193 }
 194
 195 static void control_dc_dc(int on_not_off)
 196 {
 197         unsigned int selfcontrol;
 198         unsigned long tmo = currticks() + TICKS_PER_SEC;
 199
 200         /* control the DC to DC convertor in the SelfControl register.  */
 201         selfcontrol = HCB1_ENBL; /* Enable the HCB1 bit as an output */
 202         if (((eth_adapter_cnf & A_CNF_DC_DC_POLARITY) != 0) ^ on_not_off)
 203                 selfcontrol |= HCB1;
 204         else
 205                 selfcontrol &= ~HCB1;
 206         writereg(PP_SelfCTL, selfcontrol);
 207
 208         /* Wait for the DC/DC converter to power up - 1000ms */
 209         while (currticks() < tmo);
 210
 211         return;
 212 }
 213
 214 static int detect_tp(void)
 215 {
 216         unsigned long tmo;
 217
 218         /* Turn on the chip auto detection of 10BT/ AUI */
 219
 220         clrline(); printf("attempting %s:","TP");
 221
 222         /* If connected to another full duplex capable 10-Base-T card
 223            the link pulses seem to be lost when the auto detect bit in
 224            the LineCTL is set.  To overcome this the auto detect bit
 225            will be cleared whilst testing the 10-Base-T interface.
 226            This would not be necessary for the sparrow chip but is
 227            simpler to do it anyway. */
 228         writereg(PP_LineCTL, eth_linectl &~ AUI_ONLY);
 229         control_dc_dc(0);
 230
 231         /* Delay for the hardware to work out if the TP cable is
 232            present - 150ms */
 233         for (tmo = currticks() + 4; currticks() < tmo; );
 234
 235         if ((readreg(PP_LineST) & LINK_OK) == 0)
 236                 return 0;
 237
 238         if (eth_cs_type != CS8900) {
 239
 240                 writereg(PP_AutoNegCTL, eth_auto_neg_cnf & AUTO_NEG_MASK);
 241
 242                 if ((eth_auto_neg_cnf & AUTO_NEG_BITS) == AUTO_NEG_ENABLE) {
 243                         printf(" negotiating duplex... ");
 244                         while (readreg(PP_AutoNegST) & AUTO_NEG_BUSY) {
 245                                 if (currticks() - tmo > 40*TICKS_PER_SEC) {
 246                                         printf("time out ");
 247                                         break;
 248                                 }
 249                         }
 250                 }
 251                 if (readreg(PP_AutoNegST) & FDX_ACTIVE)
 252                         printf("using full duplex");
 253                 else
 254                         printf("using half duplex");
 255         }
 256
 257         return A_CNF_MEDIA_10B_T;
 258 }
 259
 260 /* send a test packet - return true if carrier bits are ok */
 261 static int send_test_pkt(struct nic *nic)
 262 {
 263         static unsigned char testpacket[] = { 0,0,0,0,0,0, 0,0,0,0,0,0,
 264                                      0, 46, /*A 46 in network order       */
 265                                      0, 0,  /*DSAP=0 & SSAP=0 fields      */
 266                                      0xf3,0 /*Control (Test Req+P bit set)*/ };
 267         unsigned long tmo;
 268
 269         writereg(PP_LineCTL, readreg(PP_LineCTL) | SERIAL_TX_ON);
 270
 271         memcpy(testpacket, nic->node_addr, ETH_ALEN);
 272         memcpy(testpacket+ETH_ALEN, nic->node_addr, ETH_ALEN);
 273
 274         outw(TX_AFTER_ALL, eth_nic_base + TX_CMD_PORT);
 275         outw(ETH_ZLEN, eth_nic_base + TX_LEN_PORT);
 276
 277         /* Test to see if the chip has allocated memory for the packet */
 278         for (tmo = currticks() + 2;
 279              (readreg(PP_BusST) & READY_FOR_TX_NOW) == 0; )
 280                 if (currticks() >= tmo)
 281                         return(0);
 282
 283         /* Write the contents of the packet */
 284         outsw(eth_nic_base + TX_FRAME_PORT, testpacket,
 285               (ETH_ZLEN+1)>>1);
 286
 287         printf(" sending test packet ");
 288         /* wait a couple of timer ticks for packet to be received */
 289         for (tmo = currticks() + 2; currticks() < tmo; );
 290
 291         if ((readreg(PP_TxEvent) & TX_SEND_OK_BITS) == TX_OK) {
 292                         printf("succeeded");
 293                         return 1;
 294         }
 295         printf("failed");
 296         return 0;
 297 }
 298
 299
 300 static int detect_aui(struct nic *nic)
 301 {
 302         clrline(); printf("attempting %s:","AUI");
 303         control_dc_dc(0);
 304
 305         writereg(PP_LineCTL, (eth_linectl & ~AUTO_AUI_10BASET) | AUI_ONLY);
 306
 307         if (send_test_pkt(nic)) {
 308                 return A_CNF_MEDIA_AUI; }
 309         else
 310                 return 0;
 311 }
 312
 313 static int detect_bnc(struct nic *nic)
 314 {
 315         clrline(); printf("attempting %s:","BNC");
 316         control_dc_dc(1);
 317
 318         writereg(PP_LineCTL, (eth_linectl & ~AUTO_AUI_10BASET) | AUI_ONLY);
 319
 320         if (send_test_pkt(nic)) {
 321                 return A_CNF_MEDIA_10B_2; }
 322         else
 323                 return 0;
 324 }
 325
 326 /**************************************************************************
 327 ETH_RESET - Reset adapter
 328 ***************************************************************************/
 329
 330 static void cs89x0_reset(struct nic *nic)
 331 {
 332         int  i;
 333         unsigned long reset_tmo;
 334
 335         writereg(PP_SelfCTL, readreg(PP_SelfCTL) | POWER_ON_RESET);
 336
 337         /* wait for two ticks; that is 2*55ms */
 338         for (reset_tmo = currticks() + 2; currticks() < reset_tmo; );
 339
 340         if (eth_cs_type != CS8900) {
 341                 /* Hardware problem requires PNP registers to be reconfigured
 342                    after a reset */
 343                 if (eth_irqno != 0xFFFF) {
 344                         outw(PP_CS8920_ISAINT, eth_nic_base + ADD_PORT);
 345                         outb(eth_irqno, eth_nic_base + DATA_PORT);
 346                         outb(0, eth_nic_base + DATA_PORT + 1); }
 347
 348                 if (eth_mem_start) {
 349                         outw(PP_CS8920_ISAMemB, eth_nic_base + ADD_PORT);
 350                         outb((eth_mem_start >> 8) & 0xff, eth_nic_base + DATA_PORT);
 351                         outb((eth_mem_start >> 24) & 0xff, eth_nic_base + DATA_PORT + 1); } }
 352
 353         /* Wait until the chip is reset */
 354         for (reset_tmo = currticks() + 2;
 355              (readreg(PP_SelfST) & INIT_DONE) == 0 &&
 356                      currticks() < reset_tmo; );
 357
 358         /* disable interrupts and memory accesses */
 359         writereg(PP_BusCTL, 0);
 360
 361         /* set the ethernet address */
 362         for (i=0; i < ETH_ALEN/2; i++)
 363                 writereg(PP_IA+i*2,
 364                          nic->node_addr[i*2] |
 365                          (nic->node_addr[i*2+1] << 8));
 366
 367         /* receive only error free packets addressed to this card */
 368         writereg(PP_RxCTL, DEF_RX_ACCEPT);
 369
 370         /* do not generate any interrupts on receive operations */
 371         writereg(PP_RxCFG, 0);
 372
 373         /* do not generate any interrupts on transmit operations */
 374         writereg(PP_TxCFG, 0);
 375
 376         /* do not generate any interrupts on buffer operations */
 377         writereg(PP_BufCFG, 0);
 378
 379         /* reset address port, so that autoprobing will keep working */
 380         outw(PP_ChipID, eth_nic_base + ADD_PORT);
 381
 382         return;
 383 }
 384
 385 /**************************************************************************
 386 ETH_TRANSMIT - Transmit a frame
 387 ***************************************************************************/
 388
 389 static void cs89x0_transmit(
 390         struct nic *nic,
 391         const char *d,                  /* Destination */
 392         unsigned int t,                 /* Type */
 393         unsigned int s,                 /* size */
 394         const char *p)                  /* Packet */
 395 {
 396         unsigned long tmo;
 397         int           sr;
 398
 399         /* does this size have to be rounded??? please,
 400            somebody have a look in the specs */
 401         if ((sr = ((s + ETH_HLEN + 1)&~1)) < ETH_ZLEN)
 402                 sr = ETH_ZLEN;
 403
 404 retry:
 405         /* initiate a transmit sequence */
 406         outw(TX_AFTER_ALL, eth_nic_base + TX_CMD_PORT);
 407         outw(sr, eth_nic_base + TX_LEN_PORT);
 408
 409         /* Test to see if the chip has allocated memory for the packet */
 410         if ((readreg(PP_BusST) & READY_FOR_TX_NOW) == 0) {
 411                 /* Oops... this should not happen! */
 412                 printf("cs: unable to send packet; retrying...\n");
 413                 for (tmo = currticks() + 5*TICKS_PER_SEC; currticks() < tmo; );
 414                 cs89x0_reset(nic);
 415                 goto retry; }
 416
 417         /* Write the contents of the packet */
 418         outsw(eth_nic_base + TX_FRAME_PORT, d, ETH_ALEN/2);
 419         outsw(eth_nic_base + TX_FRAME_PORT, nic->node_addr,
 420               ETH_ALEN/2);
 421         outw(((t >> 8)&0xFF)|(t << 8), eth_nic_base + TX_FRAME_PORT);
 422         outsw(eth_nic_base + TX_FRAME_PORT, p, (s+1)/2);
 423         for (sr = sr/2 - (s+1)/2 - ETH_ALEN - 1; sr > 0; sr--)
 424                 outw(0, eth_nic_base + TX_FRAME_PORT);
 425
 426         /* wait for transfer to succeed */
 427         for (tmo = currticks()+5*TICKS_PER_SEC;
 428              (s = readreg(PP_TxEvent)&~0x1F) == 0 && currticks() < tmo;)
 429                 /* nothing */ ;
 430         if ((s & TX_SEND_OK_BITS) != TX_OK) {
 431                 printf("\ntransmission error %#hX\n", s);
 432         }
 433
 434         return;
 435 }
 436
 437 /**************************************************************************
 438 ETH_POLL - Wait for a frame
 439 ***************************************************************************/
 440
 441 static int cs89x0_poll(struct nic *nic, int retrieve)
 442 {
 443         int status;
 444
 445         status = readreg(PP_RxEvent);
 446
 447         if ((status & RX_OK) == 0)
 448                 return(0);
 449
 450         if ( ! retrieve ) return 1;
 451
 452         status = inw(eth_nic_base + RX_FRAME_PORT);
 453         nic->packetlen = inw(eth_nic_base + RX_FRAME_PORT);
 454         insw(eth_nic_base + RX_FRAME_PORT, nic->packet, nic->packetlen >> 1);
 455         if (nic->packetlen & 1)
 456                 nic->packet[nic->packetlen-1] = inw(eth_nic_base + RX_FRAME_PORT);
 457         return 1;
 458 }
 459
 460 static void cs89x0_irq(struct nic *nic __unused, irq_action_t action __unused)
 461 {
 462   switch ( action ) {
 463   case DISABLE :
 464     break;
 465   case ENABLE :
 466     break;
 467   case FORCE :
 468     break;
 469   }
 470 }
 471
 472 static struct nic_operations cs89x0_operations = {
 473         .connect        = dummy_connect,
 474         .poll           = cs89x0_poll,
 475         .transmit       = cs89x0_transmit,
 476         .irq            = cs89x0_irq,
 477 };
 478
 479 /**************************************************************************
 480 ETH_PROBE - Look for an adapter
 481 ***************************************************************************/
 482
 483 static int cs89x0_probe_addr ( isa_probe_addr_t ioaddr ) {
 484         /* if they give us an odd I/O address, then do ONE write to
 485            the address port, to get it back to address zero, where we
 486            expect to find the EISA signature word. */
 487         if (ioaddr & 1) {
 488                 ioaddr &= ~1;
 489                 if ((inw(ioaddr + ADD_PORT) & ADD_MASK) != ADD_SIG)
 490                         return 0;
 491                 outw(PP_ChipID, ioaddr + ADD_PORT);
 492         }
 493
 494         if (inw(ioaddr + DATA_PORT) != CHIP_EISA_ID_SIG)
 495                 return 0;
 496
 497         return 1;
 498 }
 499
 500 static int cs89x0_probe ( struct nic *nic, struct isa_device *isa __unused ) {
 501         int      i, result = -1;
 502         unsigned rev_type = 0, isa_cnf, cs_revision;
 503         unsigned short eeprom_buff[CHKSUM_LEN];
 504
 505         nic->ioaddr &= ~1; /* LSB = 1 indicates a more aggressive probe */
 506         eth_nic_base = nic->ioaddr;
 507
 508         /* get the chip type */
 509         rev_type = readreg(PRODUCT_ID_ADD);
 510         eth_cs_type = rev_type &~ REVISON_BITS;
 511         cs_revision = ((rev_type & REVISON_BITS) >> 8) + 'A';
 512
 513         printf("\ncs: cs89%c0%s rev %c, base %#hX",
 514                eth_cs_type==CS8900?'0':'2',
 515                eth_cs_type==CS8920M?"M":"",
 516                cs_revision,
 517                eth_nic_base);
 518 #ifndef EMBEDDED
 519         /* First check to see if an EEPROM is attached*/
 520         if ((readreg(PP_SelfST) & EEPROM_PRESENT) == 0) {
 521                 printf("\ncs: no EEPROM...\n");
 522                 outw(PP_ChipID, eth_nic_base + ADD_PORT);
 523                 return 0;
 524         } else if (get_eeprom_data(START_EEPROM_DATA,CHKSUM_LEN,
 525                                    eeprom_buff) < 0) {
 526                 printf("\ncs: EEPROM read failed...\n");
 527                 outw(PP_ChipID, eth_nic_base + ADD_PORT);
 528                 return 0;
 529         } else if (get_eeprom_chksum(START_EEPROM_DATA,CHKSUM_LEN,
 530                                      eeprom_buff) < 0) {
 531                 printf("\ncs: EEPROM checksum bad...\n");
 532                 outw(PP_ChipID, eth_nic_base + ADD_PORT);
 533                 return 0;
 534         }
 535
 536         /* get transmission control word but keep the
 537            autonegotiation bits */
 538         eth_auto_neg_cnf = eeprom_buff[AUTO_NEG_CNF_OFFSET/2];
 539         /* Store adapter configuration */
 540         eth_adapter_cnf = eeprom_buff[ADAPTER_CNF_OFFSET/2];
 541         /* Store ISA configuration */
 542         isa_cnf = eeprom_buff[ISA_CNF_OFFSET/2];
 543
 544         /* store the initial memory base address */
 545         eth_mem_start = eeprom_buff[PACKET_PAGE_OFFSET/2] << 8;
 546
 547         printf("%s%s%s, addr ",
 548                (eth_adapter_cnf & A_CNF_10B_T)?", RJ-45":"",
 549                (eth_adapter_cnf & A_CNF_AUI)?", AUI":"",
 550                (eth_adapter_cnf & A_CNF_10B_2)?", BNC":"");
 551
 552         /* If this is a CS8900 then no pnp soft */
 553         if (eth_cs_type != CS8900 &&
 554             /* Check if the ISA IRQ has been set  */
 555             (i = readreg(PP_CS8920_ISAINT) & 0xff,
 556              (i != 0 && i < CS8920_NO_INTS)))
 557                 eth_irqno = i;
 558         else {
 559                 i = isa_cnf & INT_NO_MASK;
 560                 if (eth_cs_type == CS8900) {
 561                         /* the table that follows is dependent
 562                            upon how you wired up your cs8900
 563                            in your system.  The table is the
 564                            same as the cs8900 engineering demo
 565                            board.  irq_map also depends on the
 566                            contents of the table.  Also see
 567                            write_irq, which is the reverse
 568                            mapping of the table below. */
 569                         if (i < 4) i = "\012\013\014\005"[i];
 570                         else printf("\ncs: BUG: isa_config is %d\n", i); }
 571                 eth_irqno = i; }
 572
 573         nic->irqno = eth_irqno;
 574
 575         /* Retrieve and print the ethernet address. */
 576         for (i=0; i<ETH_ALEN; i++) {
 577                 nic->node_addr[i] = ((unsigned char *)eeprom_buff)[i];
 578         }
 579
 580         DBG ( "%s\n", eth_ntoa ( nic->node_addr ) );
 581
 582 #endif
 583 #ifdef EMBEDDED
 584         /* Retrieve and print the ethernet address. */
 585         {
 586                 unsigned char MAC_HW_ADDR[6]={MAC_HW_ADDR_DRV};
 587                 memcpy(nic->node_addr, MAC_HW_ADDR, 6);
 588         }
 589
 590         DBG ( "%s\n", eth_ntoa ( nic->node_addr ) );
 591
 592         eth_adapter_cnf = A_CNF_10B_T | A_CNF_MEDIA_10B_T;
 593         eth_auto_neg_cnf = EE_AUTO_NEG_ENABLE | IMM_BIT;
 594 #endif
 595 #ifndef EMBEDDED
 596         /* Set the LineCTL quintuplet based on adapter
 597            configuration read from EEPROM */
 598         if ((eth_adapter_cnf & A_CNF_EXTND_10B_2) &&
 599             (eth_adapter_cnf & A_CNF_LOW_RX_SQUELCH))
 600                 eth_linectl = LOW_RX_SQUELCH;
 601         else
 602                 eth_linectl = 0;
 603
 604         /* check to make sure that they have the "right"
 605            hardware available */
 606         switch(eth_adapter_cnf & A_CNF_MEDIA_TYPE) {
 607         case A_CNF_MEDIA_10B_T: result = eth_adapter_cnf & A_CNF_10B_T;
 608                 break;
 609         case A_CNF_MEDIA_AUI:   result = eth_adapter_cnf & A_CNF_AUI;
 610                 break;
 611         case A_CNF_MEDIA_10B_2: result = eth_adapter_cnf & A_CNF_10B_2;
 612                 break;
 613         default: result = eth_adapter_cnf & (A_CNF_10B_T | A_CNF_AUI |
 614                                              A_CNF_10B_2);
 615         }
 616         if (!result) {
 617                 printf("cs: EEPROM is configured for unavailable media\n");
 618         error:
 619                 writereg(PP_LineCTL, readreg(PP_LineCTL) &
 620                          ~(SERIAL_TX_ON | SERIAL_RX_ON));
 621                 outw(PP_ChipID, eth_nic_base + ADD_PORT);
 622                 return 0;
 623         }
 624 #endif
 625         /* Initialize the card for probing of the attached media */
 626         cs89x0_reset(nic);
 627
 628         /* set the hardware to the configured choice */
 629         switch(eth_adapter_cnf & A_CNF_MEDIA_TYPE) {
 630         case A_CNF_MEDIA_10B_T:
 631                 result = detect_tp();
 632                 if (!result) {
 633                         clrline();
 634                         printf("10Base-T (RJ-45%s",
 635                                ") has no cable\n"); }
 636                 /* check "ignore missing media" bit */
 637                 if (eth_auto_neg_cnf & IMM_BIT)
 638                         /* Yes! I don't care if I see a link pulse */
 639                         result = A_CNF_MEDIA_10B_T;
 640                 break;
 641         case A_CNF_MEDIA_AUI:
 642                 result = detect_aui(nic);
 643                 if (!result) {
 644                         clrline();
 645                         printf("10Base-5 (AUI%s",
 646                                ") has no cable\n"); }
 647                 /* check "ignore missing media" bit */
 648                 if (eth_auto_neg_cnf & IMM_BIT)
 649                         /* Yes! I don't care if I see a carrrier */
 650                         result = A_CNF_MEDIA_AUI;
 651                 break;
 652         case A_CNF_MEDIA_10B_2:
 653                 result = detect_bnc(nic);
 654                 if (!result) {
 655                         clrline();
 656                         printf("10Base-2 (BNC%s",
 657                                ") has no cable\n"); }
 658                 /* check "ignore missing media" bit */
 659                 if (eth_auto_neg_cnf & IMM_BIT)
 660                         /* Yes! I don't care if I can xmit a packet */
 661                         result = A_CNF_MEDIA_10B_2;
 662                 break;
 663         case A_CNF_MEDIA_AUTO:
 664                 writereg(PP_LineCTL, eth_linectl | AUTO_AUI_10BASET);
 665                 if (eth_adapter_cnf & A_CNF_10B_T)
 666                         if ((result = detect_tp()) != 0)
 667                                 break;
 668                 if (eth_adapter_cnf & A_CNF_AUI)
 669                         if ((result = detect_aui(nic)) != 0)
 670                                 break;
 671                 if (eth_adapter_cnf & A_CNF_10B_2)
 672                         if ((result = detect_bnc(nic)) != 0)
 673                                 break;
 674                 clrline(); printf("no media detected\n");
 675                 goto error;
 676         }
 677         clrline();
 678         switch(result) {
 679         case 0:                 printf("no network cable attached to configured media\n");
 680                 goto error;
 681         case A_CNF_MEDIA_10B_T: printf("using 10Base-T (RJ-45)\n");
 682                 break;
 683         case A_CNF_MEDIA_AUI:   printf("using 10Base-5 (AUI)\n");
 684                 break;
 685         case A_CNF_MEDIA_10B_2: printf("using 10Base-2 (BNC)\n");
 686                 break;
 687         }
 688
 689         /* Turn on both receive and transmit operations */
 690         writereg(PP_LineCTL, readreg(PP_LineCTL) | SERIAL_RX_ON |
 691                  SERIAL_TX_ON);
 692
 693         return 0;
 694 #ifdef EMBEDDED
 695  error:
 696         writereg(PP_LineCTL, readreg(PP_LineCTL) &
 697                  ~(SERIAL_TX_ON | SERIAL_RX_ON));
 698         outw(PP_ChipID, eth_nic_base + ADD_PORT);
 699         return 0;
 700 #endif
 701
 702         nic->nic_op   = &cs89x0_operations;
 703         return 1;
 704 }
 705
 706 static void cs89x0_disable ( struct nic *nic,
 707                              struct isa_device *isa __unused ) {
 708         cs89x0_reset(nic);
 709 }
 710
 711 static isa_probe_addr_t cs89x0_probe_addrs[] = {
 712 #ifndef EMBEDDED
 713         /* use "conservative" default values for autoprobing */
 714         0x300, 0x320, 0x340, 0x200, 0x220, 0x240,
 715         0x260, 0x280, 0x2a0, 0x2c0, 0x2e0,
 716         /* if that did not work, then be more aggressive */
 717         0x301, 0x321, 0x341, 0x201, 0x221, 0x241,
 718         0x261, 0x281, 0x2a1, 0x2c1, 0x2e1,
 719 #else
 720         0x01000300,
 721 #endif
 722 };
 723
 724 ISA_DRIVER ( cs89x0_driver, cs89x0_probe_addrs, cs89x0_probe_addr,
 725              ISAPNP_VENDOR('C','S','C'), 0x0007 );
 726
 727 DRIVER ( "cs89x0", nic_driver, isa_driver, cs89x0_driver,
 728          cs89x0_probe, cs89x0_disable );
 729
 730 ISA_ROM ( "cs89x0", "Crystal Semiconductor CS89x0" );
 731
 732 /*
 733  * Local variables:
 734  *  c-basic-offset: 8
 735  *  c-indent-level: 8
 736  *  tab-width: 8
 737  * End:
 738  */