drivers/net/skfp/drvfbi.c

   1 /******************************************************************************
   2  *
   3  *      (C)Copyright 1998,1999 SysKonnect,
   4  *      a business unit of Schneider & Koch & Co. Datensysteme GmbH.
   5  *
   6  *      See the file "skfddi.c" for further information.
   7  *
   8  *      This program is free software; you can redistribute it and/or modify
   9  *      it under the terms of the GNU General Public License as published by
  10  *      the Free Software Foundation; either version 2 of the License, or
  11  *      (at your option) any later version.
  12  *
  13  *      The information in this file is provided "AS IS" without warranty.
  14  *
  15  ******************************************************************************/
  16
  17 /*
  18  * FBI board dependent Driver for SMT and LLC
  19  */
  20
  21 #include "h/types.h"
  22 #include "h/fddi.h"
  23 #include "h/smc.h"
  24 #include "h/supern_2.h"
  25 #include "h/skfbiinc.h"
  26 #include <linux/bitrev.h>
  27
  28 #ifndef lint
  29 static const char ID_sccs[] = "@(#)drvfbi.c     1.63 99/02/11 (C) SK " ;
  30 #endif
  31
  32 /*
  33  * PCM active state
  34  */
  35 #define PC8_ACTIVE      8
  36
  37 #define LED_Y_ON        0x11    /* Used for ring up/down indication */
  38 #define LED_Y_OFF       0x10
  39
  40
  41 #define MS2BCLK(x)      ((x)*12500L)
  42
  43 /*
  44  * valid configuration values are:
  45  */
  46 #ifdef  ISA
  47 const int opt_ints[] = {8,      3, 4, 5, 9, 10, 11, 12, 15} ;
  48 const int opt_iops[] = {8,
  49         0x100, 0x120, 0x180, 0x1a0, 0x220, 0x240, 0x320, 0x340};
  50 const int opt_dmas[] = {4,      3, 5, 6, 7} ;
  51 const int opt_eproms[] = {15,   0xc0, 0xc2, 0xc4, 0xc6, 0xc8, 0xca, 0xcc, 0xce,
  52                         0xd0, 0xd2, 0xd4, 0xd6, 0xd8, 0xda, 0xdc} ;
  53 #endif
  54 #ifdef  EISA
  55 const int opt_ints[] = {5, 9, 10, 11} ;
  56 const int opt_dmas[] = {0, 5, 6, 7} ;
  57 const int opt_eproms[] = {0xc0, 0xc2, 0xc4, 0xc6, 0xc8, 0xca, 0xcc, 0xce,
  58                                 0xd0, 0xd2, 0xd4, 0xd6, 0xd8, 0xda, 0xdc} ;
  59 #endif
  60
  61 #ifdef  MCA
  62 int     opt_ints[] = {3, 11, 10, 9} ;                   /* FM1 */
  63 int     opt_eproms[] = {0, 0xc4, 0xc8, 0xcc, 0xd0, 0xd4, 0xd8, 0xdc} ;
  64 #endif  /* MCA */
  65
  66 /*
  67  *      xPOS_ID:xxxx
  68  *      |       \  /
  69  *      |        \/
  70  *      |         --------------------- the patched POS_ID of the Adapter
  71  *      |                               xxxx = (Vendor ID low byte,
  72  *      |                                       Vendor ID high byte,
  73  *      |                                       Device ID low byte,
  74  *      |                                       Device ID high byte)
  75  *      +------------------------------ the patched oem_id must be
  76  *                                      'S' for SK or 'I' for IBM
  77  *                                      this is a short id for the driver.
  78  */
  79 #ifndef MULT_OEM
  80 #ifndef OEM_CONCEPT
  81 #ifndef MCA
  82 const u_char oem_id[] = "xPOS_ID:xxxx" ;
  83 #else
  84 const u_char oem_id[] = "xPOSID1:xxxx" ;        /* FM1 card id. */
  85 #endif
  86 #else   /* OEM_CONCEPT */
  87 #ifndef MCA
  88 const u_char oem_id[] = OEM_ID ;
  89 #else
  90 const u_char oem_id[] = OEM_ID1 ;       /* FM1 card id. */
  91 #endif  /* MCA */
  92 #endif  /* OEM_CONCEPT */
  93 #define ID_BYTE0        8
  94 #define OEMID(smc,i)    oem_id[ID_BYTE0 + i]
  95 #else   /* MULT_OEM */
  96 const struct s_oem_ids oem_ids[] = {
  97 #include "oemids.h"
  98 {0}
  99 };
 100 #define OEMID(smc,i)    smc->hw.oem_id->oi_id[i]
 101 #endif  /* MULT_OEM */
 102
 103 /* Prototypes of external functions */
 104 #ifdef AIX
 105 extern int AIX_vpdReadByte() ;
 106 #endif
 107
 108
 109 /* Prototype of a local function. */
 110 static void smt_stop_watchdog(struct s_smc *smc);
 111
 112 #ifdef MCA
 113 static int read_card_id() ;
 114 static void DisableSlotAccess() ;
 115 static void EnableSlotAccess() ;
 116 #ifdef AIX
 117 extern int attach_POS_addr() ;
 118 extern int detach_POS_addr() ;
 119 extern u_char read_POS() ;
 120 extern void write_POS() ;
 121 extern int AIX_vpdReadByte() ;
 122 #else
 123 #define read_POS(smc,a1,a2)     ((u_char) inp(a1))
 124 #define write_POS(smc,a1,a2,a3) outp((a1),(a3))
 125 #endif
 126 #endif  /* MCA */
 127
 128
 129 /*
 130  * FDDI card reset
 131  */
 132 static void card_start(struct s_smc *smc)
 133 {
 134         int i ;
 135 #ifdef  PCI
 136         u_char  rev_id ;
 137         u_short word;
 138 #endif
 139
 140         smt_stop_watchdog(smc) ;
 141
 142 #ifdef  ISA
 143         outpw(CSR_A,0) ;                        /* reset for all chips */
 144         for (i = 10 ; i ; i--)                  /* delay for PLC's */
 145                 (void)inpw(ISR_A) ;
 146         OUT_82c54_TIMER(3,COUNT(2) | RW_OP(3) | TMODE(2)) ;
 147                                         /* counter 2, mode 2 */
 148         OUT_82c54_TIMER(2,97) ;         /* LSB */
 149         OUT_82c54_TIMER(2,0) ;          /* MSB ( 15.6 us ) */
 150         outpw(CSR_A,CS_CRESET) ;
 151 #endif
 152 #ifdef  EISA
 153         outpw(CSR_A,0) ;                        /* reset for all chips */
 154         for (i = 10 ; i ; i--)                  /* delay for PLC's */
 155                 (void)inpw(ISR_A) ;
 156         outpw(CSR_A,CS_CRESET) ;
 157         smc->hw.led = (2<<6) ;
 158         outpw(CSR_A,CS_CRESET | smc->hw.led) ;
 159 #endif
 160 #ifdef  MCA
 161         outp(ADDR(CARD_DIS),0) ;                /* reset for all chips */
 162         for (i = 10 ; i ; i--)                  /* delay for PLC's */
 163                 (void)inpw(ISR_A) ;
 164         outp(ADDR(CARD_EN),0) ;
 165         /* first I/O after reset must not be a access to FORMAC or PLC */
 166
 167         /*
 168          * bus timeout (MCA)
 169          */
 170         OUT_82c54_TIMER(3,COUNT(2) | RW_OP(3) | TMODE(3)) ;
 171                                         /* counter 2, mode 3 */
 172         OUT_82c54_TIMER(2,(2*24)) ;     /* 3.9 us * 2 square wave */
 173         OUT_82c54_TIMER(2,0) ;          /* MSB */
 174
 175         /* POS 102 indicated an activ Check Line or Buss Error monitoring */
 176         if (inpw(CSA_A) & (POS_EN_CHKINT | POS_EN_BUS_ERR)) {
 177                 outp(ADDR(IRQ_CHCK_EN),0) ;
 178         }
 179
 180         if (!((i = inpw(CSR_A)) & CS_SAS)) {
 181                 if (!(i & CS_BYSTAT)) {
 182                         outp(ADDR(BYPASS(STAT_INS)),0) ;/* insert station */
 183                 }
 184         }
 185         outpw(LEDR_A,LED_1) ;   /* yellow */
 186 #endif  /* MCA */
 187 #ifdef  PCI
 188         /*
 189          * make sure no transfer activity is pending
 190          */
 191         outpw(FM_A(FM_MDREG1),FM_MINIT) ;
 192         outp(ADDR(B0_CTRL), CTRL_HPI_SET) ;
 193         hwt_wait_time(smc,hwt_quick_read(smc),MS2BCLK(10)) ;
 194         /*
 195          * now reset everything
 196          */
 197         outp(ADDR(B0_CTRL),CTRL_RST_SET) ;      /* reset for all chips */
 198         i = (int) inp(ADDR(B0_CTRL)) ;          /* do dummy read */
 199         SK_UNUSED(i) ;                          /* Make LINT happy. */
 200         outp(ADDR(B0_CTRL), CTRL_RST_CLR) ;
 201
 202         /*
 203          * Reset all bits in the PCI STATUS register
 204          */
 205         outp(ADDR(B0_TST_CTRL), TST_CFG_WRITE_ON) ;     /* enable for writes */
 206         word = inpw(PCI_C(PCI_STATUS)) ;
 207         outpw(PCI_C(PCI_STATUS), word | PCI_ERRBITS) ;
 208         outp(ADDR(B0_TST_CTRL), TST_CFG_WRITE_OFF) ;    /* disable writes */
 209
 210         /*
 211          * Release the reset of all the State machines
 212          * Release Master_Reset
 213          * Release HPI_SM_Reset
 214          */
 215         outp(ADDR(B0_CTRL), CTRL_MRST_CLR|CTRL_HPI_CLR) ;
 216
 217         /*
 218          * determine the adapter type
 219          * Note: Do it here, because some drivers may call card_start() once
 220          *       at very first before any other initialization functions is
 221          *       executed.
 222          */
 223         rev_id = inp(PCI_C(PCI_REV_ID)) ;
 224         if ((rev_id & 0xf0) == SK_ML_ID_1 || (rev_id & 0xf0) == SK_ML_ID_2) {
 225                 smc->hw.hw_is_64bit = TRUE ;
 226         } else {
 227                 smc->hw.hw_is_64bit = FALSE ;
 228         }
 229
 230         /*
 231          * Watermark initialization
 232          */
 233         if (!smc->hw.hw_is_64bit) {
 234                 outpd(ADDR(B4_R1_F), RX_WATERMARK) ;
 235                 outpd(ADDR(B5_XA_F), TX_WATERMARK) ;
 236                 outpd(ADDR(B5_XS_F), TX_WATERMARK) ;
 237         }
 238
 239         outp(ADDR(B0_CTRL),CTRL_RST_CLR) ;      /* clear the reset chips */
 240         outp(ADDR(B0_LED),LED_GA_OFF|LED_MY_ON|LED_GB_OFF) ; /* ye LED on */
 241
 242         /* init the timer value for the watch dog 2,5 minutes */
 243         outpd(ADDR(B2_WDOG_INI),0x6FC23AC0) ;
 244
 245         /* initialize the ISR mask */
 246         smc->hw.is_imask = ISR_MASK ;
 247         smc->hw.hw_state = STOPPED ;
 248 #endif
 249         GET_PAGE(0) ;           /* necessary for BOOT */
 250 }
 251
 252 void card_stop(struct s_smc *smc)
 253 {
 254         smt_stop_watchdog(smc) ;
 255         smc->hw.mac_ring_is_up = 0 ;            /* ring down */
 256 #ifdef  ISA
 257         outpw(CSR_A,0) ;                        /* reset for all chips */
 258 #endif
 259 #ifdef  EISA
 260         outpw(CSR_A,0) ;                        /* reset for all chips */
 261 #endif
 262 #ifdef  MCA
 263         outp(ADDR(CARD_DIS),0) ;                /* reset for all chips */
 264 #endif
 265 #ifdef  PCI
 266         /*
 267          * make sure no transfer activity is pending
 268          */
 269         outpw(FM_A(FM_MDREG1),FM_MINIT) ;
 270         outp(ADDR(B0_CTRL), CTRL_HPI_SET) ;
 271         hwt_wait_time(smc,hwt_quick_read(smc),MS2BCLK(10)) ;
 272         /*
 273          * now reset everything
 274          */
 275         outp(ADDR(B0_CTRL),CTRL_RST_SET) ;      /* reset for all chips */
 276         outp(ADDR(B0_CTRL),CTRL_RST_CLR) ;      /* reset for all chips */
 277         outp(ADDR(B0_LED),LED_GA_OFF|LED_MY_OFF|LED_GB_OFF) ; /* all LEDs off */
 278         smc->hw.hw_state = STOPPED ;
 279 #endif
 280 }
 281 /*--------------------------- ISR handling ----------------------------------*/
 282
 283 void mac1_irq(struct s_smc *smc, u_short stu, u_short stl)
 284 {
 285         int     restart_tx = 0 ;
 286 again:
 287 #ifndef PCI
 288 #ifndef ISA
 289 /*
 290  * FORMAC+ bug modified the queue pointer if many read/write accesses happens!?
 291  */
 292         if (stl & (FM_SPCEPDS  |        /* parit/coding err. syn.q.*/
 293                    FM_SPCEPDA0 |        /* parit/coding err. a.q.0 */
 294                    FM_SPCEPDA1 |        /* parit/coding err. a.q.1 */
 295                    FM_SPCEPDA2)) {      /* parit/coding err. a.q.2 */
 296                 SMT_PANIC(smc,SMT_E0132, SMT_E0132_MSG) ;
 297         }
 298         if (stl & (FM_STBURS  | /* tx buffer underrun syn.q.*/
 299                    FM_STBURA0 | /* tx buffer underrun a.q.0 */
 300                    FM_STBURA1 | /* tx buffer underrun a.q.1 */
 301                    FM_STBURA2)) {       /* tx buffer underrun a.q.2 */
 302                 SMT_PANIC(smc,SMT_E0133, SMT_E0133_MSG) ;
 303         }
 304 #endif
 305         if ( (stu & (FM_SXMTABT |               /* transmit abort */
 306 #ifdef  SYNC
 307                      FM_STXABRS |       /* syn. tx abort */
 308 #endif  /* SYNC */
 309                      FM_STXABRA0)) ||   /* asyn. tx abort */
 310              (stl & (FM_SQLCKS |                /* lock for syn. q. */
 311                      FM_SQLCKA0)) ) {   /* lock for asyn. q. */
 312                 formac_tx_restart(smc) ;                /* init tx */
 313                 restart_tx = 1 ;
 314                 stu = inpw(FM_A(FM_ST1U)) ;
 315                 stl = inpw(FM_A(FM_ST1L)) ;
 316                 stu &= ~ (FM_STECFRMA0 | FM_STEFRMA0 | FM_STEFRMS) ;
 317                 if (stu || stl)
 318                         goto again ;
 319         }
 320
 321 #ifndef SYNC
 322         if (stu & (FM_STECFRMA0 | /* end of chain asyn tx */
 323                    FM_STEFRMA0)) { /* end of frame asyn tx */
 324                 /* free tx_queue */
 325                 smc->hw.n_a_send = 0 ;
 326                 if (++smc->hw.fp.tx_free < smc->hw.fp.tx_max) {
 327                         start_next_send(smc);
 328                 }
 329                 restart_tx = 1 ;
 330         }
 331 #else   /* SYNC */
 332         if (stu & (FM_STEFRMA0 |        /* end of asyn tx */
 333                     FM_STEFRMS)) {      /* end of sync tx */
 334                 restart_tx = 1 ;
 335         }
 336 #endif  /* SYNC */
 337         if (restart_tx)
 338                 llc_restart_tx(smc) ;
 339 }
 340 #else   /* PCI */
 341
 342         /*
 343          * parity error: note encoding error is not possible in tag mode
 344          */
 345         if (stl & (FM_SPCEPDS  |        /* parity err. syn.q.*/
 346                    FM_SPCEPDA0 |        /* parity err. a.q.0 */
 347                    FM_SPCEPDA1)) {      /* parity err. a.q.1 */
 348                 SMT_PANIC(smc,SMT_E0134, SMT_E0134_MSG) ;
 349         }
 350         /*
 351          * buffer underrun: can only occur if a tx threshold is specified
 352          */
 353         if (stl & (FM_STBURS  |         /* tx buffer underrun syn.q.*/
 354                    FM_STBURA0 |         /* tx buffer underrun a.q.0 */
 355                    FM_STBURA1)) {       /* tx buffer underrun a.q.2 */
 356                 SMT_PANIC(smc,SMT_E0133, SMT_E0133_MSG) ;
 357         }
 358
 359         if ( (stu & (FM_SXMTABT |               /* transmit abort */
 360                      FM_STXABRS |               /* syn. tx abort */
 361                      FM_STXABRA0)) ||           /* asyn. tx abort */
 362              (stl & (FM_SQLCKS |                /* lock for syn. q. */
 363                      FM_SQLCKA0)) ) {           /* lock for asyn. q. */
 364                 formac_tx_restart(smc) ;        /* init tx */
 365                 restart_tx = 1 ;
 366                 stu = inpw(FM_A(FM_ST1U)) ;
 367                 stl = inpw(FM_A(FM_ST1L)) ;
 368                 stu &= ~ (FM_STECFRMA0 | FM_STEFRMA0 | FM_STEFRMS) ;
 369                 if (stu || stl)
 370                         goto again ;
 371         }
 372
 373         if (stu & (FM_STEFRMA0 |        /* end of asyn tx */
 374                     FM_STEFRMS)) {      /* end of sync tx */
 375                 restart_tx = 1 ;
 376         }
 377
 378         if (restart_tx)
 379                 llc_restart_tx(smc) ;
 380 }
 381 #endif  /* PCI */
 382 /*
 383  * interrupt source= plc1
 384  * this function is called in nwfbisr.asm
 385  */
 386 void plc1_irq(struct s_smc *smc)
 387 {
 388         u_short st = inpw(PLC(PB,PL_INTR_EVENT)) ;
 389
 390 #if     (defined(ISA) || defined(EISA))
 391         /* reset PLC Int. bits */
 392         outpw(PLC1_I,inpw(PLC1_I)) ;
 393 #endif
 394         plc_irq(smc,PB,st) ;
 395 }
 396
 397 /*
 398  * interrupt source= plc2
 399  * this function is called in nwfbisr.asm
 400  */
 401 void plc2_irq(struct s_smc *smc)
 402 {
 403         u_short st = inpw(PLC(PA,PL_INTR_EVENT)) ;
 404
 405 #if     (defined(ISA) || defined(EISA))
 406         /* reset PLC Int. bits */
 407         outpw(PLC2_I,inpw(PLC2_I)) ;
 408 #endif
 409         plc_irq(smc,PA,st) ;
 410 }
 411
 412
 413 /*
 414  * interrupt source= timer
 415  */
 416 void timer_irq(struct s_smc *smc)
 417 {
 418         hwt_restart(smc);
 419         smc->hw.t_stop = smc->hw.t_start;
 420         smt_timer_done(smc) ;
 421 }
 422
 423 /*
 424  * return S-port (PA or PB)
 425  */
 426 int pcm_get_s_port(struct s_smc *smc)
 427 {
 428         SK_UNUSED(smc) ;
 429         return(PS) ;
 430 }
 431
 432 /*
 433  * Station Label = "FDDI-XYZ" where
 434  *
 435  *      X = connector type
 436  *      Y = PMD type
 437  *      Z = port type
 438  */
 439 #define STATION_LABEL_CONNECTOR_OFFSET  5
 440 #define STATION_LABEL_PMD_OFFSET        6
 441 #define STATION_LABEL_PORT_OFFSET       7
 442
 443 void read_address(struct s_smc *smc, u_char *mac_addr)
 444 {
 445         char ConnectorType ;
 446         char PmdType ;
 447         int     i ;
 448
 449 #if     (defined(ISA) || defined(MCA))
 450         for (i = 0; i < 4 ;i++) {       /* read mac address from board */
 451                 smc->hw.fddi_phys_addr.a[i] =
 452                         bitrev8(inpw(PR_A(i+SA_MAC)));
 453         }
 454         for (i = 4; i < 6; i++) {
 455                 smc->hw.fddi_phys_addr.a[i] =
 456                         bitrev8(inpw(PR_A(i+SA_MAC+PRA_OFF)));
 457         }
 458 #endif
 459 #ifdef  EISA
 460         /*
 461          * Note: We get trouble on an Alpha machine if we make a inpw()
 462          * instead of inp()
 463          */
 464         for (i = 0; i < 4 ;i++) {       /* read mac address from board */
 465                 smc->hw.fddi_phys_addr.a[i] =
 466                         bitrev8(inp(PR_A(i+SA_MAC)));
 467         }
 468         for (i = 4; i < 6; i++) {
 469                 smc->hw.fddi_phys_addr.a[i] =
 470                         bitrev8(inp(PR_A(i+SA_MAC+PRA_OFF)));
 471         }
 472 #endif
 473 #ifdef  PCI
 474         for (i = 0; i < 6; i++) {       /* read mac address from board */
 475                 smc->hw.fddi_phys_addr.a[i] =
 476                         bitrev8(inp(ADDR(B2_MAC_0+i)));
 477         }
 478 #endif
 479 #ifndef PCI
 480         ConnectorType = inpw(PR_A(SA_PMD_TYPE)) & 0xff ;
 481         PmdType = inpw(PR_A(SA_PMD_TYPE+1)) & 0xff ;
 482 #else
 483         ConnectorType = inp(ADDR(B2_CONN_TYP)) ;
 484         PmdType = inp(ADDR(B2_PMD_TYP)) ;
 485 #endif
 486
 487         smc->y[PA].pmd_type[PMD_SK_CONN] =
 488         smc->y[PB].pmd_type[PMD_SK_CONN] = ConnectorType ;
 489         smc->y[PA].pmd_type[PMD_SK_PMD ] =
 490         smc->y[PB].pmd_type[PMD_SK_PMD ] = PmdType ;
 491
 492         if (mac_addr) {
 493                 for (i = 0; i < 6 ;i++) {
 494                         smc->hw.fddi_canon_addr.a[i] = mac_addr[i] ;
 495                         smc->hw.fddi_home_addr.a[i] = bitrev8(mac_addr[i]);
 496                 }
 497                 return ;
 498         }
 499         smc->hw.fddi_home_addr = smc->hw.fddi_phys_addr ;
 500
 501         for (i = 0; i < 6 ;i++) {
 502                 smc->hw.fddi_canon_addr.a[i] =
 503                         bitrev8(smc->hw.fddi_phys_addr.a[i]);
 504         }
 505 }
 506
 507 /*
 508  * FDDI card soft reset
 509  */
 510 void init_board(struct s_smc *smc, u_char *mac_addr)
 511 {
 512         card_start(smc) ;
 513         read_address(smc,mac_addr) ;
 514
 515 #ifndef PCI
 516         if (inpw(CSR_A) & CS_SAS)
 517 #else
 518         if (!(inp(ADDR(B0_DAS)) & DAS_AVAIL))
 519 #endif
 520                 smc->s.sas = SMT_SAS ;  /* Single att. station */
 521         else
 522                 smc->s.sas = SMT_DAS ;  /* Dual att. station */
 523
 524 #ifndef PCI
 525         if (inpw(CSR_A) & CS_BYSTAT)
 526 #else
 527         if (!(inp(ADDR(B0_DAS)) & DAS_BYP_ST))
 528 #endif
 529                 smc->mib.fddiSMTBypassPresent = 0 ;
 530                 /* without opt. bypass */
 531         else
 532                 smc->mib.fddiSMTBypassPresent = 1 ;
 533                 /* with opt. bypass */
 534 }
 535
 536 /*
 537  * insert or deinsert optical bypass (called by ECM)
 538  */
 539 void sm_pm_bypass_req(struct s_smc *smc, int mode)
 540 {
 541 #if     (defined(ISA) || defined(EISA))
 542         int csra_v ;
 543 #endif
 544
 545         DB_ECMN(1,"ECM : sm_pm_bypass_req(%s)\n",(mode == BP_INSERT) ?
 546                                         "BP_INSERT" : "BP_DEINSERT",0) ;
 547
 548         if (smc->s.sas != SMT_DAS)
 549                 return ;
 550
 551 #if     (defined(ISA) || defined(EISA))
 552
 553         csra_v = inpw(CSR_A) & ~CS_BYPASS ;
 554 #ifdef  EISA
 555         csra_v |= smc->hw.led ;
 556 #endif
 557
 558         switch(mode) {
 559         case BP_INSERT :
 560                 outpw(CSR_A,csra_v | CS_BYPASS) ;
 561                 break ;
 562         case BP_DEINSERT :
 563                 outpw(CSR_A,csra_v) ;
 564                 break ;
 565         }
 566 #endif  /* ISA / EISA */
 567 #ifdef  MCA
 568         switch(mode) {
 569         case BP_INSERT :
 570                 outp(ADDR(BYPASS(STAT_INS)),0) ;/* insert station */
 571                 break ;
 572         case BP_DEINSERT :
 573                 outp(ADDR(BYPASS(STAT_BYP)),0) ;        /* bypass station */
 574                 break ;
 575         }
 576 #endif
 577 #ifdef  PCI
 578         switch(mode) {
 579         case BP_INSERT :
 580                 outp(ADDR(B0_DAS),DAS_BYP_INS) ;        /* insert station */
 581                 break ;
 582         case BP_DEINSERT :
 583                 outp(ADDR(B0_DAS),DAS_BYP_RMV) ;        /* bypass station */
 584                 break ;
 585         }
 586 #endif
 587 }
 588
 589 /*
 590  * check if bypass connected
 591  */
 592 int sm_pm_bypass_present(struct s_smc *smc)
 593 {
 594 #ifndef PCI
 595         return( (inpw(CSR_A) & CS_BYSTAT) ? FALSE : TRUE ) ;
 596 #else
 597         return( (inp(ADDR(B0_DAS)) & DAS_BYP_ST) ? TRUE: FALSE) ;
 598 #endif
 599 }
 600
 601 void plc_clear_irq(struct s_smc *smc, int p)
 602 {
 603         SK_UNUSED(p) ;
 604
 605 #if     (defined(ISA) || defined(EISA))
 606         switch (p) {
 607         case PA :
 608                 /* reset PLC Int. bits */
 609                 outpw(PLC2_I,inpw(PLC2_I)) ;
 610                 break ;
 611         case PB :
 612                 /* reset PLC Int. bits */
 613                 outpw(PLC1_I,inpw(PLC1_I)) ;
 614                 break ;
 615         }
 616 #else
 617         SK_UNUSED(smc) ;
 618 #endif
 619 }
 620
 621
 622 /*
 623  * led_indication called by rmt_indication() and
 624  * pcm_state_change()
 625  *
 626  * Input:
 627  *      smc:    SMT context
 628  *      led_event:
 629  *      0       Only switch green LEDs according to their respective PCM state
 630  *      LED_Y_OFF       just switch yellow LED off
 631  *      LED_Y_ON        just switch yello LED on
 632  */
 633 static void led_indication(struct s_smc *smc, int led_event)
 634 {
 635         /* use smc->hw.mac_ring_is_up == TRUE
 636          * as indication for Ring Operational
 637          */
 638         u_short                 led_state ;
 639         struct s_phy            *phy ;
 640         struct fddi_mib_p       *mib_a ;
 641         struct fddi_mib_p       *mib_b ;
 642
 643         phy = &smc->y[PA] ;
 644         mib_a = phy->mib ;
 645         phy = &smc->y[PB] ;
 646         mib_b = phy->mib ;
 647
 648 #ifdef  EISA
 649         /* Ring up = yellow led OFF*/
 650         if (led_event == LED_Y_ON) {
 651                 smc->hw.led |= CS_LED_1 ;
 652         }
 653         else if (led_event == LED_Y_OFF) {
 654                 smc->hw.led &= ~CS_LED_1 ;
 655         }
 656         else {
 657                 /* Link at Port A or B = green led ON */
 658                 if (mib_a->fddiPORTPCMState == PC8_ACTIVE ||
 659                     mib_b->fddiPORTPCMState == PC8_ACTIVE) {
 660                         smc->hw.led |= CS_LED_0 ;
 661                 }
 662                 else {
 663                         smc->hw.led &= ~CS_LED_0 ;
 664                 }
 665         }
 666 #endif
 667 #ifdef  MCA
 668         led_state = inpw(LEDR_A) ;
 669
 670         /* Ring up = yellow led OFF*/
 671         if (led_event == LED_Y_ON) {
 672                 led_state |= LED_1 ;
 673         }
 674         else if (led_event == LED_Y_OFF) {
 675                 led_state &= ~LED_1 ;
 676         }
 677         else {
 678                 led_state &= ~(LED_2|LED_0) ;
 679
 680                 /* Link at Port A = green led A ON */
 681                 if (mib_a->fddiPORTPCMState == PC8_ACTIVE) {
 682                         led_state |= LED_2 ;
 683                 }
 684
 685                 /* Link at Port B/S = green led B ON */
 686                 if (mib_b->fddiPORTPCMState == PC8_ACTIVE) {
 687                         led_state |= LED_0 ;
 688                 }
 689         }
 690
 691         outpw(LEDR_A, led_state) ;
 692 #endif  /* MCA */
 693 #ifdef  PCI
 694         led_state = 0 ;
 695
 696         /* Ring up = yellow led OFF*/
 697         if (led_event == LED_Y_ON) {
 698                 led_state |= LED_MY_ON ;
 699         }
 700         else if (led_event == LED_Y_OFF) {
 701                 led_state |= LED_MY_OFF ;
 702         }
 703         else {  /* PCM state changed */
 704                 /* Link at Port A/S = green led A ON */
 705                 if (mib_a->fddiPORTPCMState == PC8_ACTIVE) {
 706                         led_state |= LED_GA_ON ;
 707                 }
 708                 else {
 709                         led_state |= LED_GA_OFF ;
 710                 }
 711
 712                 /* Link at Port B = green led B ON */
 713                 if (mib_b->fddiPORTPCMState == PC8_ACTIVE) {
 714                         led_state |= LED_GB_ON ;
 715                 }
 716                 else {
 717                         led_state |= LED_GB_OFF ;
 718                 }
 719         }
 720
 721         outp(ADDR(B0_LED), led_state) ;
 722 #endif  /* PCI */
 723
 724 }
 725
 726
 727 void pcm_state_change(struct s_smc *smc, int plc, int p_state)
 728 {
 729         /*
 730          * the current implementation of pcm_state_change() in the driver
 731          * parts must be renamed to drv_pcm_state_change() which will be called
 732          * now after led_indication.
 733          */
 734         DRV_PCM_STATE_CHANGE(smc,plc,p_state) ;
 735
 736         led_indication(smc,0) ;
 737 }
 738
 739
 740 void rmt_indication(struct s_smc *smc, int i)
 741 {
 742         /* Call a driver special function if defined */
 743         DRV_RMT_INDICATION(smc,i) ;
 744
 745         led_indication(smc, i ? LED_Y_OFF : LED_Y_ON) ;
 746 }
 747
 748
 749 /*
 750  * llc_recover_tx called by init_tx (fplus.c)
 751  */
 752 void llc_recover_tx(struct s_smc *smc)
 753 {
 754 #ifdef  LOAD_GEN
 755         extern  int load_gen_flag ;
 756
 757         load_gen_flag = 0 ;
 758 #endif
 759 #ifndef SYNC
 760         smc->hw.n_a_send= 0 ;
 761 #else
 762         SK_UNUSED(smc) ;
 763 #endif
 764 }
 765
 766 #ifdef MULT_OEM
 767 static int is_equal_num(char comp1[], char comp2[], int num)
 768 {
 769         int i ;
 770
 771         for (i = 0 ; i < num ; i++) {
 772                 if (comp1[i] != comp2[i])
 773                         return (0) ;
 774         }
 775                 return (1) ;
 776 }       /* is_equal_num */
 777
 778
 779 /*
 780  * set the OEM ID defaults, and test the contents of the OEM data base
 781  * The default OEM is the first ACTIVE entry in the OEM data base
 782  *
 783  * returns:     0       success
 784  *              1       error in data base
 785  *              2       data base empty
 786  *              3       no active entry
 787  */
 788 int set_oi_id_def(struct s_smc *smc)
 789 {
 790         int sel_id ;
 791         int i ;
 792         int act_entries ;
 793
 794         i = 0 ;
 795         sel_id = -1 ;
 796         act_entries = FALSE ;
 797         smc->hw.oem_id = 0 ;
 798         smc->hw.oem_min_status = OI_STAT_ACTIVE ;
 799
 800         /* check OEM data base */
 801         while (oem_ids[i].oi_status) {
 802                 switch (oem_ids[i].oi_status) {
 803                 case OI_STAT_ACTIVE:
 804                         act_entries = TRUE ;    /* we have active IDs */
 805                         if (sel_id == -1)
 806                                 sel_id = i ;    /* save the first active ID */
 807                 case OI_STAT_VALID:
 808                 case OI_STAT_PRESENT:
 809                         i++ ;
 810                         break ;                 /* entry ok */
 811                 default:
 812                         return (1) ;            /* invalid oi_status */
 813                 }
 814         }
 815
 816         if (i == 0)
 817                 return (2) ;
 818         if (!act_entries)
 819                 return (3) ;
 820
 821         /* ok, we have a valid OEM data base with an active entry */
 822         smc->hw.oem_id = (struct s_oem_ids *)  &oem_ids[sel_id] ;
 823         return (0) ;
 824 }
 825 #endif  /* MULT_OEM */
 826
 827
 828 #ifdef  MCA
 829 /************************
 830  *
 831  * BEGIN_MANUAL_ENTRY()
 832  *
 833  *      exist_board
 834  *
 835  *      Check if an MCA board is present in the specified slot.
 836  *
 837  *      int exist_board(
 838  *              struct s_smc *smc,
 839  *              int slot) ;
 840  * In
 841  *      smc - A pointer to the SMT Context struct.
 842  *
 843  *      slot - The number of the slot to inspect.
 844  * Out
 845  *      0 = No adapter present.
 846  *      1 = Found FM1 adapter.
 847  *
 848  * Pseudo
 849  *      Read MCA ID
 850  *      for all valid OEM_IDs
 851  *              compare with ID read
 852  *              if equal, return 1
 853  *      return(0
 854  *
 855  * Note
 856  *      The smc pointer must be valid now.
 857  *
 858  * END_MANUAL_ENTRY()
 859  *
 860  ************************/
 861 #define LONG_CARD_ID(lo, hi)    ((((hi) & 0xff) << 8) | ((lo) & 0xff))
 862 int exist_board(struct s_smc *smc, int slot)
 863 {
 864 #ifdef MULT_OEM
 865         SK_LOC_DECL(u_char,id[2]) ;
 866         int idi ;
 867 #endif  /* MULT_OEM */
 868
 869         /* No longer valid. */
 870         if (smc == NULL)
 871                 return(0) ;
 872
 873 #ifndef MULT_OEM
 874         if (read_card_id(smc, slot)
 875                 == LONG_CARD_ID(OEMID(smc,0), OEMID(smc,1)))
 876                 return (1) ;    /* Found FM adapter. */
 877
 878 #else   /* MULT_OEM */
 879         idi = read_card_id(smc, slot) ;
 880         id[0] = idi & 0xff ;
 881         id[1] = idi >> 8 ;
 882
 883         smc->hw.oem_id = (struct s_oem_ids *) &oem_ids[0] ;
 884         for (; smc->hw.oem_id->oi_status != OI_STAT_LAST; smc->hw.oem_id++) {
 885                 if (smc->hw.oem_id->oi_status < smc->hw.oem_min_status)
 886                         continue ;
 887
 888                 if (is_equal_num(&id[0],&OEMID(smc,0),2))
 889                         return (1) ;
 890         }
 891 #endif  /* MULT_OEM */
 892         return (0) ;    /* No adapter found. */
 893 }
 894
 895 /************************
 896  *
 897  *      read_card_id
 898  *
 899  *      Read the MCA card id from the specified slot.
 900  * In
 901  *      smc - A pointer to the SMT Context struct.
 902  *      CAVEAT: This pointer may be NULL and *must not* be used within this
 903  *      function. It's only purpose is for drivers that need some information
 904  *      for the inp() and outp() macros.
 905  *
 906  *      slot - The number of the slot for which the card id is returned.
 907  * Out
 908  *      Returns the card id read from the specified slot. If an illegal slot
 909  *      number is specified, the function returns zero.
 910  *
 911  ************************/
 912 static int read_card_id(struct s_smc *smc, int slot)
 913 /* struct s_smc *smc ;  Do not use. */
 914 {
 915         int card_id ;
 916
 917         SK_UNUSED(smc) ;        /* Make LINT happy. */
 918         if ((slot < 1) || (slot > 15))  /* max 16 slots, 0 = motherboard */
 919                 return (0) ;    /* Illegal slot number specified. */
 920
 921         EnableSlotAccess(smc, slot) ;
 922
 923         card_id = ((read_POS(smc,POS_ID_HIGH,slot - 1) & 0xff) << 8) |
 924                                 (read_POS(smc,POS_ID_LOW,slot - 1) & 0xff) ;
 925
 926         DisableSlotAccess(smc) ;
 927
 928         return (card_id) ;
 929 }
 930
 931 /************************
 932  *
 933  * BEGIN_MANUAL_ENTRY()
 934  *
 935  *      get_board_para
 936  *
 937  *      Get adapter configuration information. Fill all board specific
 938  *      parameters within the 'smc' structure.
 939  *
 940  *      int get_board_para(
 941  *              struct s_smc *smc,
 942  *              int slot) ;
 943  * In
 944  *      smc - A pointer to the SMT Context struct, to which this function will
 945  *      write some adapter configuration data.
 946  *
 947  *      slot - The number of the slot, in which the adapter is installed.
 948  * Out
 949  *      0 = No adapter present.
 950  *      1 = Ok.
 951  *      2 = Adapter present, but card enable bit not set.
 952  *
 953  * END_MANUAL_ENTRY()
 954  *
 955  ************************/
 956 int get_board_para(struct s_smc *smc, int slot)
 957 {
 958         int val ;
 959         int i ;
 960
 961         /* Check if adapter present & get type of adapter. */
 962         switch (exist_board(smc, slot)) {
 963         case 0: /* Adapter not present. */
 964                 return (0) ;
 965         case 1: /* FM Rev. 1 */
 966                 smc->hw.rev = FM1_REV ;
 967                 smc->hw.VFullRead = 0x0a ;
 968                 smc->hw.VFullWrite = 0x05 ;
 969                 smc->hw.DmaWriteExtraBytes = 8 ;        /* 2 extra words. */
 970                 break ;
 971         }
 972         smc->hw.slot = slot ;
 973
 974         EnableSlotAccess(smc, slot) ;
 975
 976         if (!(read_POS(smc,POS_102, slot - 1) & POS_CARD_EN)) {
 977                 DisableSlotAccess(smc) ;
 978                 return (2) ;    /* Card enable bit not set. */
 979         }
 980
 981         val = read_POS(smc,POS_104, slot - 1) ; /* I/O, IRQ */
 982
 983 #ifndef MEM_MAPPED_IO   /* is defined by the operating system */
 984         i = val & POS_IOSEL ;   /* I/O base addr. (0x0200 .. 0xfe00) */
 985         smc->hw.iop = (i + 1) * 0x0400 - 0x200 ;
 986 #endif
 987         i = ((val & POS_IRQSEL) >> 6) & 0x03 ;  /* IRQ <0, 1> */
 988         smc->hw.irq = opt_ints[i] ;
 989
 990         /* FPROM base addr. */
 991         i = ((read_POS(smc,POS_103, slot - 1) & POS_MSEL) >> 4) & 0x07 ;
 992         smc->hw.eprom = opt_eproms[i] ;
 993
 994         DisableSlotAccess(smc) ;
 995
 996         /* before this, the smc->hw.iop must be set !!! */
 997         smc->hw.slot_32 = inpw(CSF_A) & SLOT_32 ;
 998
 999         return (1) ;
1000 }
1001
1002 /* Enable access to specified MCA slot. */
1003 static void EnableSlotAccess(struct s_smc *smc, int slot)
1004 {
1005         SK_UNUSED(slot) ;
1006
1007 #ifndef AIX
1008         SK_UNUSED(smc) ;
1009
1010         /* System mode. */
1011         outp(POS_SYS_SETUP, POS_SYSTEM) ;
1012
1013         /* Select slot. */
1014         outp(POS_CHANNEL_POS, POS_CHANNEL_BIT | (slot-1)) ;
1015 #else
1016         attach_POS_addr (smc) ;
1017 #endif
1018 }
1019
1020 /* Disable access to MCA slot formerly enabled via EnableSlotAccess(). */
1021 static void DisableSlotAccess(struct s_smc *smc)
1022 {
1023 #ifndef AIX
1024         SK_UNUSED(smc) ;
1025
1026         outp(POS_CHANNEL_POS, 0) ;
1027 #else
1028         detach_POS_addr (smc) ;
1029 #endif
1030 }
1031 #endif  /* MCA */
1032
1033 #ifdef  EISA
1034 #ifndef MEM_MAPPED_IO
1035 #define SADDR(slot)     (((slot)<<12)&0xf000)
1036 #else   /* MEM_MAPPED_IO */
1037 #define SADDR(slot)     (smc->hw.iop)
1038 #endif  /* MEM_MAPPED_IO */
1039
1040 /************************
1041  *
1042  * BEGIN_MANUAL_ENTRY()
1043  *
1044  *      exist_board
1045  *
1046  *      Check if an EISA board is present in the specified slot.
1047  *
1048  *      int exist_board(
1049  *              struct s_smc *smc,
1050  *              int slot) ;
1051  * In
1052  *      smc - A pointer to the SMT Context struct.
1053  *
1054  *      slot - The number of the slot to inspect.
1055  * Out
1056  *      0 = No adapter present.
1057  *      1 = Found adapter.
1058  *
1059  * Pseudo
1060  *      Read EISA ID
1061  *      for all valid OEM_IDs
1062  *              compare with ID read
1063  *              if equal, return 1
1064  *      return(0
1065  *
1066  * Note
1067  *      The smc pointer must be valid now.
1068  *
1069  ************************/
1070 int exist_board(struct s_smc *smc, int slot)
1071 {
1072         int i ;
1073 #ifdef MULT_OEM
1074         SK_LOC_DECL(u_char,id[4]) ;
1075 #endif  /* MULT_OEM */
1076
1077         /* No longer valid. */
1078         if (smc == NULL)
1079                 return(0);
1080
1081         SK_UNUSED(slot) ;
1082
1083 #ifndef MULT_OEM
1084         for (i = 0 ; i < 4 ; i++) {
1085                 if (inp(SADDR(slot)+PRA(i)) != OEMID(smc,i))
1086                         return(0) ;
1087         }
1088         return(1) ;
1089 #else   /* MULT_OEM */
1090         for (i = 0 ; i < 4 ; i++)
1091                 id[i] = inp(SADDR(slot)+PRA(i)) ;
1092
1093         smc->hw.oem_id = (struct s_oem_ids *) &oem_ids[0] ;
1094
1095         for (; smc->hw.oem_id->oi_status != OI_STAT_LAST; smc->hw.oem_id++) {
1096                 if (smc->hw.oem_id->oi_status < smc->hw.oem_min_status)
1097                         continue ;
1098
1099                 if (is_equal_num(&id[0],&OEMID(smc,0),4))
1100                         return (1) ;
1101         }
1102         return (0) ;    /* No adapter found. */
1103 #endif  /* MULT_OEM */
1104 }
1105
1106
1107 int get_board_para(struct s_smc *smc, int slot)
1108 {
1109         int     i ;
1110
1111         if (!exist_board(smc,slot))
1112                 return(0) ;
1113
1114         smc->hw.slot = slot ;
1115 #ifndef MEM_MAPPED_IO           /* if defined by the operating system */
1116         smc->hw.iop = SADDR(slot) ;
1117 #endif
1118
1119         if (!(inp(C0_A(0))&CFG_CARD_EN)) {
1120                 return(2) ;                     /* CFG_CARD_EN bit not set! */
1121         }
1122
1123         smc->hw.irq = opt_ints[(inp(C1_A(0)) & CFG_IRQ_SEL)] ;
1124         smc->hw.dma = opt_dmas[((inp(C1_A(0)) & CFG_DRQ_SEL)>>3)] ;
1125
1126         if ((i = inp(C2_A(0)) & CFG_EPROM_SEL) != 0x0f)
1127                 smc->hw.eprom = opt_eproms[i] ;
1128         else
1129                 smc->hw.eprom = 0 ;
1130
1131         smc->hw.DmaWriteExtraBytes = 8 ;
1132
1133         return(1) ;
1134 }
1135 #endif  /* EISA */
1136
1137 #ifdef  ISA
1138 #ifndef MULT_OEM
1139 const u_char sklogo[6] = SKLOGO_STR ;
1140 #define SIZE_SKLOGO(smc)        sizeof(sklogo)
1141 #define SKLOGO(smc,i)           sklogo[i]
1142 #else   /* MULT_OEM */
1143 #define SIZE_SKLOGO(smc)        smc->hw.oem_id->oi_logo_len
1144 #define SKLOGO(smc,i)           smc->hw.oem_id->oi_logo[i]
1145 #endif  /* MULT_OEM */
1146
1147
1148 int exist_board(struct s_smc *smc, HW_PTR port)
1149 {
1150         int     i ;
1151 #ifdef MULT_OEM
1152         int     bytes_read ;
1153         u_char  board_logo[15] ;
1154         SK_LOC_DECL(u_char,id[4]) ;
1155 #endif  /* MULT_OEM */
1156
1157         /* No longer valid. */
1158         if (smc == NULL)
1159                 return(0);
1160
1161         SK_UNUSED(smc) ;
1162 #ifndef MULT_OEM
1163         for (i = SADDRL ; i < (signed) (SADDRL+SIZE_SKLOGO(smc)) ; i++) {
1164                 if ((u_char)inpw((PRA(i)+port)) != SKLOGO(smc,i-SADDRL)) {
1165                         return(0) ;
1166                 }
1167         }
1168
1169         /* check MAC address (S&K or other) */
1170         for (i = 0 ; i < 3 ; i++) {
1171                 if ((u_char)inpw((PRA(i)+port)) != OEMID(smc,i))
1172                         return(0) ;
1173         }
1174         return(1) ;
1175 #else   /* MULT_OEM */
1176         smc->hw.oem_id = (struct s_oem_ids *)  &oem_ids[0] ;
1177         board_logo[0] = (u_char)inpw((PRA(SADDRL)+port)) ;
1178         bytes_read = 1 ;
1179
1180         for (; smc->hw.oem_id->oi_status != OI_STAT_LAST; smc->hw.oem_id++) {
1181                 if (smc->hw.oem_id->oi_status < smc->hw.oem_min_status)
1182                         continue ;
1183
1184                 /* Test all read bytes with current OEM_entry */
1185                 /* for (i=0; (i<bytes_read) && (i < SIZE_SKLOGO(smc)); i++) { */
1186                 for (i = 0; i < bytes_read; i++) {
1187                         if (board_logo[i] != SKLOGO(smc,i))
1188                                 break ;
1189                 }
1190
1191                 /* If mismatch, switch to next OEM entry */
1192                 if ((board_logo[i] != SKLOGO(smc,i)) && (i < bytes_read))
1193                         continue ;
1194
1195                 --i ;
1196                 while (bytes_read < SIZE_SKLOGO(smc)) {
1197                         //   inpw next byte SK_Logo
1198                         i++ ;
1199                         board_logo[i] = (u_char)inpw((PRA(SADDRL+i)+port)) ;
1200                         bytes_read++ ;
1201                         if (board_logo[i] != SKLOGO(smc,i))
1202                                 break ;
1203                 }
1204
1205                 for (i = 0 ; i < 3 ; i++)
1206                         id[i] = (u_char)inpw((PRA(i)+port)) ;
1207
1208                 if ((board_logo[i] == SKLOGO(smc,i))
1209                         && (bytes_read == SIZE_SKLOGO(smc))) {
1210
1211                         if (is_equal_num(&id[0],&OEMID(smc,0),3))
1212                                 return(1);
1213                 }
1214         }       /* for */
1215         return(0) ;
1216 #endif  /* MULT_OEM */
1217 }
1218
1219 int get_board_para(struct s_smc *smc, int slot)
1220 {
1221         SK_UNUSED(smc) ;
1222         SK_UNUSED(slot) ;
1223         return(0) ;     /* for ISA not supported */
1224 }
1225 #endif  /* ISA */
1226
1227 #ifdef PCI
1228 #ifdef USE_BIOS_FUN
1229 int exist_board(struct s_smc *smc, int slot)
1230 {
1231         u_short dev_id ;
1232         u_short ven_id ;
1233         int found ;
1234         int i ;
1235
1236         found = FALSE ;         /* make sure we returned with adatper not found*/
1237                                 /* if an empty oemids.h was included */
1238
1239 #ifdef MULT_OEM
1240         smc->hw.oem_id = (struct s_oem_ids *) &oem_ids[0] ;
1241         for (; smc->hw.oem_id->oi_status != OI_STAT_LAST; smc->hw.oem_id++) {
1242                 if (smc->hw.oem_id->oi_status < smc->hw.oem_min_status)
1243                         continue ;
1244 #endif
1245                 ven_id = OEMID(smc,0) + (OEMID(smc,1) << 8) ;
1246                 dev_id = OEMID(smc,2) + (OEMID(smc,3) << 8) ;
1247                 for (i = 0; i < slot; i++) {
1248                         if (pci_find_device(i,&smc->hw.pci_handle,
1249                                 dev_id,ven_id) != 0) {
1250
1251                                 found = FALSE ;
1252                         } else {
1253                                 found = TRUE ;
1254                         }
1255                 }
1256                 if (found) {
1257                         return(1) ;     /* adapter was found */
1258                 }
1259 #ifdef MULT_OEM
1260         }
1261 #endif
1262         return(0) ;     /* adapter was not found */
1263 }
1264 #endif  /* PCI */
1265 #endif  /* USE_BIOS_FUNC */
1266
1267 void driver_get_bia(struct s_smc *smc, struct fddi_addr *bia_addr)
1268 {
1269         int i ;
1270
1271         for (i = 0 ; i < 6 ; i++)
1272                 bia_addr->a[i] = bitrev8(smc->hw.fddi_phys_addr.a[i]);
1273 }
1274
1275 void smt_start_watchdog(struct s_smc *smc)
1276 {
1277         SK_UNUSED(smc) ;        /* Make LINT happy. */
1278
1279 #ifndef DEBUG
1280
1281 #ifdef  PCI
1282         if (smc->hw.wdog_used) {
1283                 outpw(ADDR(B2_WDOG_CRTL),TIM_START) ;   /* Start timer. */
1284         }
1285 #endif
1286
1287 #endif  /* DEBUG */
1288 }
1289
1290 static void smt_stop_watchdog(struct s_smc *smc)
1291 {
1292         SK_UNUSED(smc) ;        /* Make LINT happy. */
1293 #ifndef DEBUG
1294
1295 #ifdef  PCI
1296         if (smc->hw.wdog_used) {
1297                 outpw(ADDR(B2_WDOG_CRTL),TIM_STOP) ;    /* Stop timer. */
1298         }
1299 #endif
1300
1301 #endif  /* DEBUG */
1302 }
1303
1304 #ifdef  PCI
1305
1306 void mac_do_pci_fix(struct s_smc *smc)
1307 {
1308         SK_UNUSED(smc) ;
1309 }
1310 #endif  /* PCI */
1311