diff options
Diffstat (limited to 'drivers/net/skfp/drvfbi.c')
-rw-r--r-- | drivers/net/skfp/drvfbi.c | 693 |
1 files changed, 3 insertions, 690 deletions
diff --git a/drivers/net/skfp/drvfbi.c b/drivers/net/skfp/drvfbi.c index 4fe624b0dd25..be2ee6519ef2 100644 --- a/drivers/net/skfp/drvfbi.c +++ b/drivers/net/skfp/drvfbi.c | |||
@@ -43,25 +43,6 @@ static const char ID_sccs[] = "@(#)drvfbi.c 1.63 99/02/11 (C) SK " ; | |||
43 | /* | 43 | /* |
44 | * valid configuration values are: | 44 | * valid configuration values are: |
45 | */ | 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 | 46 | ||
66 | /* | 47 | /* |
67 | * xPOS_ID:xxxx | 48 | * xPOS_ID:xxxx |
@@ -78,17 +59,9 @@ int opt_eproms[] = {0, 0xc4, 0xc8, 0xcc, 0xd0, 0xd4, 0xd8, 0xdc} ; | |||
78 | */ | 59 | */ |
79 | #ifndef MULT_OEM | 60 | #ifndef MULT_OEM |
80 | #ifndef OEM_CONCEPT | 61 | #ifndef OEM_CONCEPT |
81 | #ifndef MCA | ||
82 | const u_char oem_id[] = "xPOS_ID:xxxx" ; | 62 | 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 */ | 63 | #else /* OEM_CONCEPT */ |
87 | #ifndef MCA | ||
88 | const u_char oem_id[] = OEM_ID ; | 64 | 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 */ | 65 | #endif /* OEM_CONCEPT */ |
93 | #define ID_BYTE0 8 | 66 | #define ID_BYTE0 8 |
94 | #define OEMID(smc,i) oem_id[ID_BYTE0 + i] | 67 | #define OEMID(smc,i) oem_id[ID_BYTE0 + i] |
@@ -109,23 +82,6 @@ extern int AIX_vpdReadByte() ; | |||
109 | /* Prototype of a local function. */ | 82 | /* Prototype of a local function. */ |
110 | static void smt_stop_watchdog(struct s_smc *smc); | 83 | static void smt_stop_watchdog(struct s_smc *smc); |
111 | 84 | ||
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 | /* | 85 | /* |
130 | * FDDI card reset | 86 | * FDDI card reset |
131 | */ | 87 | */ |
@@ -139,51 +95,6 @@ static void card_start(struct s_smc *smc) | |||
139 | 95 | ||
140 | smt_stop_watchdog(smc) ; | 96 | smt_stop_watchdog(smc) ; |
141 | 97 | ||
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 | 98 | #ifdef PCI |
188 | /* | 99 | /* |
189 | * make sure no transfer activity is pending | 100 | * make sure no transfer activity is pending |
@@ -253,15 +164,7 @@ void card_stop(struct s_smc *smc) | |||
253 | { | 164 | { |
254 | smt_stop_watchdog(smc) ; | 165 | smt_stop_watchdog(smc) ; |
255 | smc->hw.mac_ring_is_up = 0 ; /* ring down */ | 166 | smc->hw.mac_ring_is_up = 0 ; /* ring down */ |
256 | #ifdef ISA | 167 | |
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 | 168 | #ifdef PCI |
266 | /* | 169 | /* |
267 | * make sure no transfer activity is pending | 170 | * make sure no transfer activity is pending |
@@ -284,60 +187,6 @@ void mac1_irq(struct s_smc *smc, u_short stu, u_short stl) | |||
284 | { | 187 | { |
285 | int restart_tx = 0 ; | 188 | int restart_tx = 0 ; |
286 | again: | 189 | 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 | 190 | ||
342 | /* | 191 | /* |
343 | * parity error: note encoding error is not possible in tag mode | 192 | * parity error: note encoding error is not possible in tag mode |
@@ -378,7 +227,7 @@ again: | |||
378 | if (restart_tx) | 227 | if (restart_tx) |
379 | llc_restart_tx(smc) ; | 228 | llc_restart_tx(smc) ; |
380 | } | 229 | } |
381 | #endif /* PCI */ | 230 | |
382 | /* | 231 | /* |
383 | * interrupt source= plc1 | 232 | * interrupt source= plc1 |
384 | * this function is called in nwfbisr.asm | 233 | * this function is called in nwfbisr.asm |
@@ -387,10 +236,6 @@ void plc1_irq(struct s_smc *smc) | |||
387 | { | 236 | { |
388 | u_short st = inpw(PLC(PB,PL_INTR_EVENT)) ; | 237 | u_short st = inpw(PLC(PB,PL_INTR_EVENT)) ; |
389 | 238 | ||
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) ; | 239 | plc_irq(smc,PB,st) ; |
395 | } | 240 | } |
396 | 241 | ||
@@ -402,10 +247,6 @@ void plc2_irq(struct s_smc *smc) | |||
402 | { | 247 | { |
403 | u_short st = inpw(PLC(PA,PL_INTR_EVENT)) ; | 248 | u_short st = inpw(PLC(PA,PL_INTR_EVENT)) ; |
404 | 249 | ||
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) ; | 250 | plc_irq(smc,PA,st) ; |
410 | } | 251 | } |
411 | 252 | ||
@@ -446,43 +287,15 @@ void read_address(struct s_smc *smc, u_char *mac_addr) | |||
446 | char PmdType ; | 287 | char PmdType ; |
447 | int i ; | 288 | int i ; |
448 | 289 | ||
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 | 290 | #ifdef PCI |
474 | for (i = 0; i < 6; i++) { /* read mac address from board */ | 291 | for (i = 0; i < 6; i++) { /* read mac address from board */ |
475 | smc->hw.fddi_phys_addr.a[i] = | 292 | smc->hw.fddi_phys_addr.a[i] = |
476 | bitrev8(inp(ADDR(B2_MAC_0+i))); | 293 | bitrev8(inp(ADDR(B2_MAC_0+i))); |
477 | } | 294 | } |
478 | #endif | 295 | #endif |
479 | #ifndef PCI | 296 | |
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)) ; | 297 | ConnectorType = inp(ADDR(B2_CONN_TYP)) ; |
484 | PmdType = inp(ADDR(B2_PMD_TYP)) ; | 298 | PmdType = inp(ADDR(B2_PMD_TYP)) ; |
485 | #endif | ||
486 | 299 | ||
487 | smc->y[PA].pmd_type[PMD_SK_CONN] = | 300 | smc->y[PA].pmd_type[PMD_SK_CONN] = |
488 | smc->y[PB].pmd_type[PMD_SK_CONN] = ConnectorType ; | 301 | smc->y[PB].pmd_type[PMD_SK_CONN] = ConnectorType ; |
@@ -512,20 +325,12 @@ void init_board(struct s_smc *smc, u_char *mac_addr) | |||
512 | card_start(smc) ; | 325 | card_start(smc) ; |
513 | read_address(smc,mac_addr) ; | 326 | read_address(smc,mac_addr) ; |
514 | 327 | ||
515 | #ifndef PCI | ||
516 | if (inpw(CSR_A) & CS_SAS) | ||
517 | #else | ||
518 | if (!(inp(ADDR(B0_DAS)) & DAS_AVAIL)) | 328 | if (!(inp(ADDR(B0_DAS)) & DAS_AVAIL)) |
519 | #endif | ||
520 | smc->s.sas = SMT_SAS ; /* Single att. station */ | 329 | smc->s.sas = SMT_SAS ; /* Single att. station */ |
521 | else | 330 | else |
522 | smc->s.sas = SMT_DAS ; /* Dual att. station */ | 331 | smc->s.sas = SMT_DAS ; /* Dual att. station */ |
523 | 332 | ||
524 | #ifndef PCI | ||
525 | if (inpw(CSR_A) & CS_BYSTAT) | ||
526 | #else | ||
527 | if (!(inp(ADDR(B0_DAS)) & DAS_BYP_ST)) | 333 | if (!(inp(ADDR(B0_DAS)) & DAS_BYP_ST)) |
528 | #endif | ||
529 | smc->mib.fddiSMTBypassPresent = 0 ; | 334 | smc->mib.fddiSMTBypassPresent = 0 ; |
530 | /* without opt. bypass */ | 335 | /* without opt. bypass */ |
531 | else | 336 | else |
@@ -538,42 +343,12 @@ void init_board(struct s_smc *smc, u_char *mac_addr) | |||
538 | */ | 343 | */ |
539 | void sm_pm_bypass_req(struct s_smc *smc, int mode) | 344 | void sm_pm_bypass_req(struct s_smc *smc, int mode) |
540 | { | 345 | { |
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) ? | 346 | DB_ECMN(1,"ECM : sm_pm_bypass_req(%s)\n",(mode == BP_INSERT) ? |
546 | "BP_INSERT" : "BP_DEINSERT",0) ; | 347 | "BP_INSERT" : "BP_DEINSERT",0) ; |
547 | 348 | ||
548 | if (smc->s.sas != SMT_DAS) | 349 | if (smc->s.sas != SMT_DAS) |
549 | return ; | 350 | return ; |
550 | 351 | ||
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 | 352 | #ifdef PCI |
578 | switch(mode) { | 353 | switch(mode) { |
579 | case BP_INSERT : | 354 | case BP_INSERT : |
@@ -591,31 +366,14 @@ void sm_pm_bypass_req(struct s_smc *smc, int mode) | |||
591 | */ | 366 | */ |
592 | int sm_pm_bypass_present(struct s_smc *smc) | 367 | int sm_pm_bypass_present(struct s_smc *smc) |
593 | { | 368 | { |
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) ; | 369 | return( (inp(ADDR(B0_DAS)) & DAS_BYP_ST) ? TRUE: FALSE) ; |
598 | #endif | ||
599 | } | 370 | } |
600 | 371 | ||
601 | void plc_clear_irq(struct s_smc *smc, int p) | 372 | void plc_clear_irq(struct s_smc *smc, int p) |
602 | { | 373 | { |
603 | SK_UNUSED(p) ; | 374 | SK_UNUSED(p) ; |
604 | 375 | ||
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) ; | 376 | SK_UNUSED(smc) ; |
618 | #endif | ||
619 | } | 377 | } |
620 | 378 | ||
621 | 379 | ||
@@ -645,51 +403,6 @@ static void led_indication(struct s_smc *smc, int led_event) | |||
645 | phy = &smc->y[PB] ; | 403 | phy = &smc->y[PB] ; |
646 | mib_b = phy->mib ; | 404 | mib_b = phy->mib ; |
647 | 405 | ||
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 | 406 | #ifdef PCI |
694 | led_state = 0 ; | 407 | led_state = 0 ; |
695 | 408 | ||
@@ -824,406 +537,6 @@ int set_oi_id_def(struct s_smc *smc) | |||
824 | } | 537 | } |
825 | #endif /* MULT_OEM */ | 538 | #endif /* MULT_OEM */ |
826 | 539 | ||
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 | 540 | #ifdef PCI |
1228 | #ifdef USE_BIOS_FUN | 541 | #ifdef USE_BIOS_FUN |
1229 | int exist_board(struct s_smc *smc, int slot) | 542 | int exist_board(struct s_smc *smc, int slot) |