[netdrvr] skfp: remove a bunch of dead code
[linux-2.6.git] / 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
47 /*
48  *      xPOS_ID:xxxx
49  *      |       \  /
50  *      |        \/
51  *      |         --------------------- the patched POS_ID of the Adapter
52  *      |                               xxxx = (Vendor ID low byte,
53  *      |                                       Vendor ID high byte,
54  *      |                                       Device ID low byte,
55  *      |                                       Device ID high byte)
56  *      +------------------------------ the patched oem_id must be
57  *                                      'S' for SK or 'I' for IBM
58  *                                      this is a short id for the driver.
59  */
60 #ifndef MULT_OEM
61 #ifndef OEM_CONCEPT
62 const u_char oem_id[] = "xPOS_ID:xxxx" ;
63 #else   /* OEM_CONCEPT */
64 const u_char oem_id[] = OEM_ID ;
65 #endif  /* OEM_CONCEPT */
66 #define ID_BYTE0        8
67 #define OEMID(smc,i)    oem_id[ID_BYTE0 + i]
68 #else   /* MULT_OEM */
69 const struct s_oem_ids oem_ids[] = {
70 #include "oemids.h"
71 {0}
72 };
73 #define OEMID(smc,i)    smc->hw.oem_id->oi_id[i]
74 #endif  /* MULT_OEM */
75
76 /* Prototypes of external functions */
77 #ifdef AIX
78 extern int AIX_vpdReadByte() ;
79 #endif
80
81
82 /* Prototype of a local function. */
83 static void smt_stop_watchdog(struct s_smc *smc);
84
85 /*
86  * FDDI card reset
87  */
88 static void card_start(struct s_smc *smc)
89 {
90         int i ;
91 #ifdef  PCI
92         u_char  rev_id ;
93         u_short word;
94 #endif
95
96         smt_stop_watchdog(smc) ;
97
98 #ifdef  PCI
99         /*
100          * make sure no transfer activity is pending
101          */
102         outpw(FM_A(FM_MDREG1),FM_MINIT) ;
103         outp(ADDR(B0_CTRL), CTRL_HPI_SET) ;
104         hwt_wait_time(smc,hwt_quick_read(smc),MS2BCLK(10)) ;
105         /*
106          * now reset everything
107          */
108         outp(ADDR(B0_CTRL),CTRL_RST_SET) ;      /* reset for all chips */
109         i = (int) inp(ADDR(B0_CTRL)) ;          /* do dummy read */
110         SK_UNUSED(i) ;                          /* Make LINT happy. */
111         outp(ADDR(B0_CTRL), CTRL_RST_CLR) ;
112
113         /*
114          * Reset all bits in the PCI STATUS register
115          */
116         outp(ADDR(B0_TST_CTRL), TST_CFG_WRITE_ON) ;     /* enable for writes */
117         word = inpw(PCI_C(PCI_STATUS)) ;
118         outpw(PCI_C(PCI_STATUS), word | PCI_ERRBITS) ;
119         outp(ADDR(B0_TST_CTRL), TST_CFG_WRITE_OFF) ;    /* disable writes */
120
121         /*
122          * Release the reset of all the State machines
123          * Release Master_Reset
124          * Release HPI_SM_Reset
125          */
126         outp(ADDR(B0_CTRL), CTRL_MRST_CLR|CTRL_HPI_CLR) ;
127
128         /*
129          * determine the adapter type
130          * Note: Do it here, because some drivers may call card_start() once
131          *       at very first before any other initialization functions is
132          *       executed.
133          */
134         rev_id = inp(PCI_C(PCI_REV_ID)) ;
135         if ((rev_id & 0xf0) == SK_ML_ID_1 || (rev_id & 0xf0) == SK_ML_ID_2) {
136                 smc->hw.hw_is_64bit = TRUE ;
137         } else {
138                 smc->hw.hw_is_64bit = FALSE ;
139         }
140
141         /*
142          * Watermark initialization
143          */
144         if (!smc->hw.hw_is_64bit) {
145                 outpd(ADDR(B4_R1_F), RX_WATERMARK) ;
146                 outpd(ADDR(B5_XA_F), TX_WATERMARK) ;
147                 outpd(ADDR(B5_XS_F), TX_WATERMARK) ;
148         }
149
150         outp(ADDR(B0_CTRL),CTRL_RST_CLR) ;      /* clear the reset chips */
151         outp(ADDR(B0_LED),LED_GA_OFF|LED_MY_ON|LED_GB_OFF) ; /* ye LED on */
152
153         /* init the timer value for the watch dog 2,5 minutes */
154         outpd(ADDR(B2_WDOG_INI),0x6FC23AC0) ;
155
156         /* initialize the ISR mask */
157         smc->hw.is_imask = ISR_MASK ;
158         smc->hw.hw_state = STOPPED ;
159 #endif
160         GET_PAGE(0) ;           /* necessary for BOOT */
161 }
162
163 void card_stop(struct s_smc *smc)
164 {
165         smt_stop_watchdog(smc) ;
166         smc->hw.mac_ring_is_up = 0 ;            /* ring down */
167
168 #ifdef  PCI
169         /*
170          * make sure no transfer activity is pending
171          */
172         outpw(FM_A(FM_MDREG1),FM_MINIT) ;
173         outp(ADDR(B0_CTRL), CTRL_HPI_SET) ;
174         hwt_wait_time(smc,hwt_quick_read(smc),MS2BCLK(10)) ;
175         /*
176          * now reset everything
177          */
178         outp(ADDR(B0_CTRL),CTRL_RST_SET) ;      /* reset for all chips */
179         outp(ADDR(B0_CTRL),CTRL_RST_CLR) ;      /* reset for all chips */
180         outp(ADDR(B0_LED),LED_GA_OFF|LED_MY_OFF|LED_GB_OFF) ; /* all LEDs off */
181         smc->hw.hw_state = STOPPED ;
182 #endif
183 }
184 /*--------------------------- ISR handling ----------------------------------*/
185
186 void mac1_irq(struct s_smc *smc, u_short stu, u_short stl)
187 {
188         int     restart_tx = 0 ;
189 again:
190
191         /*
192          * parity error: note encoding error is not possible in tag mode
193          */
194         if (stl & (FM_SPCEPDS  |        /* parity err. syn.q.*/
195                    FM_SPCEPDA0 |        /* parity err. a.q.0 */
196                    FM_SPCEPDA1)) {      /* parity err. a.q.1 */
197                 SMT_PANIC(smc,SMT_E0134, SMT_E0134_MSG) ;
198         }
199         /*
200          * buffer underrun: can only occur if a tx threshold is specified
201          */
202         if (stl & (FM_STBURS  |         /* tx buffer underrun syn.q.*/
203                    FM_STBURA0 |         /* tx buffer underrun a.q.0 */
204                    FM_STBURA1)) {       /* tx buffer underrun a.q.2 */
205                 SMT_PANIC(smc,SMT_E0133, SMT_E0133_MSG) ;
206         }
207
208         if ( (stu & (FM_SXMTABT |               /* transmit abort */
209                      FM_STXABRS |               /* syn. tx abort */
210                      FM_STXABRA0)) ||           /* asyn. tx abort */
211              (stl & (FM_SQLCKS |                /* lock for syn. q. */
212                      FM_SQLCKA0)) ) {           /* lock for asyn. q. */
213                 formac_tx_restart(smc) ;        /* init tx */
214                 restart_tx = 1 ;
215                 stu = inpw(FM_A(FM_ST1U)) ;
216                 stl = inpw(FM_A(FM_ST1L)) ;
217                 stu &= ~ (FM_STECFRMA0 | FM_STEFRMA0 | FM_STEFRMS) ;
218                 if (stu || stl)
219                         goto again ;
220         }
221
222         if (stu & (FM_STEFRMA0 |        /* end of asyn tx */
223                     FM_STEFRMS)) {      /* end of sync tx */
224                 restart_tx = 1 ;
225         }
226
227         if (restart_tx)
228                 llc_restart_tx(smc) ;
229 }
230
231 /*
232  * interrupt source= plc1
233  * this function is called in nwfbisr.asm
234  */
235 void plc1_irq(struct s_smc *smc)
236 {
237         u_short st = inpw(PLC(PB,PL_INTR_EVENT)) ;
238
239         plc_irq(smc,PB,st) ;
240 }
241
242 /*
243  * interrupt source= plc2
244  * this function is called in nwfbisr.asm
245  */
246 void plc2_irq(struct s_smc *smc)
247 {
248         u_short st = inpw(PLC(PA,PL_INTR_EVENT)) ;
249
250         plc_irq(smc,PA,st) ;
251 }
252
253
254 /*
255  * interrupt source= timer
256  */
257 void timer_irq(struct s_smc *smc)
258 {
259         hwt_restart(smc);
260         smc->hw.t_stop = smc->hw.t_start;
261         smt_timer_done(smc) ;
262 }
263
264 /*
265  * return S-port (PA or PB)
266  */
267 int pcm_get_s_port(struct s_smc *smc)
268 {
269         SK_UNUSED(smc) ;
270         return(PS) ;
271 }
272
273 /*
274  * Station Label = "FDDI-XYZ" where
275  *
276  *      X = connector type
277  *      Y = PMD type
278  *      Z = port type
279  */
280 #define STATION_LABEL_CONNECTOR_OFFSET  5
281 #define STATION_LABEL_PMD_OFFSET        6
282 #define STATION_LABEL_PORT_OFFSET       7
283
284 void read_address(struct s_smc *smc, u_char *mac_addr)
285 {
286         char ConnectorType ;
287         char PmdType ;
288         int     i ;
289
290 #ifdef  PCI
291         for (i = 0; i < 6; i++) {       /* read mac address from board */
292                 smc->hw.fddi_phys_addr.a[i] =
293                         bitrev8(inp(ADDR(B2_MAC_0+i)));
294         }
295 #endif
296
297         ConnectorType = inp(ADDR(B2_CONN_TYP)) ;
298         PmdType = inp(ADDR(B2_PMD_TYP)) ;
299
300         smc->y[PA].pmd_type[PMD_SK_CONN] =
301         smc->y[PB].pmd_type[PMD_SK_CONN] = ConnectorType ;
302         smc->y[PA].pmd_type[PMD_SK_PMD ] =
303         smc->y[PB].pmd_type[PMD_SK_PMD ] = PmdType ;
304
305         if (mac_addr) {
306                 for (i = 0; i < 6 ;i++) {
307                         smc->hw.fddi_canon_addr.a[i] = mac_addr[i] ;
308                         smc->hw.fddi_home_addr.a[i] = bitrev8(mac_addr[i]);
309                 }
310                 return ;
311         }
312         smc->hw.fddi_home_addr = smc->hw.fddi_phys_addr ;
313
314         for (i = 0; i < 6 ;i++) {
315                 smc->hw.fddi_canon_addr.a[i] =
316                         bitrev8(smc->hw.fddi_phys_addr.a[i]);
317         }
318 }
319
320 /*
321  * FDDI card soft reset
322  */
323 void init_board(struct s_smc *smc, u_char *mac_addr)
324 {
325         card_start(smc) ;
326         read_address(smc,mac_addr) ;
327
328         if (!(inp(ADDR(B0_DAS)) & DAS_AVAIL))
329                 smc->s.sas = SMT_SAS ;  /* Single att. station */
330         else
331                 smc->s.sas = SMT_DAS ;  /* Dual att. station */
332
333         if (!(inp(ADDR(B0_DAS)) & DAS_BYP_ST))
334                 smc->mib.fddiSMTBypassPresent = 0 ;
335                 /* without opt. bypass */
336         else
337                 smc->mib.fddiSMTBypassPresent = 1 ;
338                 /* with opt. bypass */
339 }
340
341 /*
342  * insert or deinsert optical bypass (called by ECM)
343  */
344 void sm_pm_bypass_req(struct s_smc *smc, int mode)
345 {
346         DB_ECMN(1,"ECM : sm_pm_bypass_req(%s)\n",(mode == BP_INSERT) ?
347                                         "BP_INSERT" : "BP_DEINSERT",0) ;
348
349         if (smc->s.sas != SMT_DAS)
350                 return ;
351
352 #ifdef  PCI
353         switch(mode) {
354         case BP_INSERT :
355                 outp(ADDR(B0_DAS),DAS_BYP_INS) ;        /* insert station */
356                 break ;
357         case BP_DEINSERT :
358                 outp(ADDR(B0_DAS),DAS_BYP_RMV) ;        /* bypass station */
359                 break ;
360         }
361 #endif
362 }
363
364 /*
365  * check if bypass connected
366  */
367 int sm_pm_bypass_present(struct s_smc *smc)
368 {
369         return( (inp(ADDR(B0_DAS)) & DAS_BYP_ST) ? TRUE: FALSE) ;
370 }
371
372 void plc_clear_irq(struct s_smc *smc, int p)
373 {
374         SK_UNUSED(p) ;
375
376         SK_UNUSED(smc) ;
377 }
378
379
380 /*
381  * led_indication called by rmt_indication() and
382  * pcm_state_change()
383  *
384  * Input:
385  *      smc:    SMT context
386  *      led_event:
387  *      0       Only switch green LEDs according to their respective PCM state
388  *      LED_Y_OFF       just switch yellow LED off
389  *      LED_Y_ON        just switch yello LED on
390  */
391 static void led_indication(struct s_smc *smc, int led_event)
392 {
393         /* use smc->hw.mac_ring_is_up == TRUE 
394          * as indication for Ring Operational
395          */
396         u_short                 led_state ;
397         struct s_phy            *phy ;
398         struct fddi_mib_p       *mib_a ;
399         struct fddi_mib_p       *mib_b ;
400
401         phy = &smc->y[PA] ;
402         mib_a = phy->mib ;
403         phy = &smc->y[PB] ;
404         mib_b = phy->mib ;
405
406 #ifdef  PCI
407         led_state = 0 ;
408         
409         /* Ring up = yellow led OFF*/
410         if (led_event == LED_Y_ON) {
411                 led_state |= LED_MY_ON ;
412         }
413         else if (led_event == LED_Y_OFF) {
414                 led_state |= LED_MY_OFF ;
415         }
416         else {  /* PCM state changed */
417                 /* Link at Port A/S = green led A ON */
418                 if (mib_a->fddiPORTPCMState == PC8_ACTIVE) {    
419                         led_state |= LED_GA_ON ;
420                 }
421                 else {
422                         led_state |= LED_GA_OFF ;
423                 }
424                 
425                 /* Link at Port B = green led B ON */
426                 if (mib_b->fddiPORTPCMState == PC8_ACTIVE) {
427                         led_state |= LED_GB_ON ;
428                 }
429                 else {
430                         led_state |= LED_GB_OFF ;
431                 }
432         }
433
434         outp(ADDR(B0_LED), led_state) ;
435 #endif  /* PCI */
436
437 }
438
439
440 void pcm_state_change(struct s_smc *smc, int plc, int p_state)
441 {
442         /*
443          * the current implementation of pcm_state_change() in the driver
444          * parts must be renamed to drv_pcm_state_change() which will be called
445          * now after led_indication.
446          */
447         DRV_PCM_STATE_CHANGE(smc,plc,p_state) ;
448         
449         led_indication(smc,0) ;
450 }
451
452
453 void rmt_indication(struct s_smc *smc, int i)
454 {
455         /* Call a driver special function if defined */
456         DRV_RMT_INDICATION(smc,i) ;
457
458         led_indication(smc, i ? LED_Y_OFF : LED_Y_ON) ;
459 }
460
461
462 /*
463  * llc_recover_tx called by init_tx (fplus.c)
464  */
465 void llc_recover_tx(struct s_smc *smc)
466 {
467 #ifdef  LOAD_GEN
468         extern  int load_gen_flag ;
469
470         load_gen_flag = 0 ;
471 #endif
472 #ifndef SYNC
473         smc->hw.n_a_send= 0 ;
474 #else
475         SK_UNUSED(smc) ;
476 #endif
477 }
478
479 #ifdef MULT_OEM
480 static int is_equal_num(char comp1[], char comp2[], int num)
481 {
482         int i ;
483
484         for (i = 0 ; i < num ; i++) {
485                 if (comp1[i] != comp2[i])
486                         return (0) ;
487         }
488                 return (1) ;
489 }       /* is_equal_num */
490
491
492 /*
493  * set the OEM ID defaults, and test the contents of the OEM data base
494  * The default OEM is the first ACTIVE entry in the OEM data base 
495  *
496  * returns:     0       success
497  *              1       error in data base
498  *              2       data base empty
499  *              3       no active entry 
500  */
501 int set_oi_id_def(struct s_smc *smc)
502 {
503         int sel_id ;
504         int i ;
505         int act_entries ;
506
507         i = 0 ;
508         sel_id = -1 ;
509         act_entries = FALSE ;
510         smc->hw.oem_id = 0 ;
511         smc->hw.oem_min_status = OI_STAT_ACTIVE ;
512         
513         /* check OEM data base */
514         while (oem_ids[i].oi_status) {
515                 switch (oem_ids[i].oi_status) {
516                 case OI_STAT_ACTIVE:
517                         act_entries = TRUE ;    /* we have active IDs */
518                         if (sel_id == -1)
519                                 sel_id = i ;    /* save the first active ID */
520                 case OI_STAT_VALID:
521                 case OI_STAT_PRESENT:
522                         i++ ;
523                         break ;                 /* entry ok */
524                 default:
525                         return (1) ;            /* invalid oi_status */
526                 }
527         }
528
529         if (i == 0)
530                 return (2) ;
531         if (!act_entries)
532                 return (3) ;
533
534         /* ok, we have a valid OEM data base with an active entry */
535         smc->hw.oem_id = (struct s_oem_ids *)  &oem_ids[sel_id] ;
536         return (0) ;
537 }
538 #endif  /* MULT_OEM */
539
540 #ifdef PCI
541 #ifdef USE_BIOS_FUN
542 int exist_board(struct s_smc *smc, int slot)
543 {
544         u_short dev_id ;
545         u_short ven_id ;
546         int found ; 
547         int i ;
548
549         found = FALSE ;         /* make sure we returned with adatper not found*/
550                                 /* if an empty oemids.h was included */
551
552 #ifdef MULT_OEM
553         smc->hw.oem_id = (struct s_oem_ids *) &oem_ids[0] ;
554         for (; smc->hw.oem_id->oi_status != OI_STAT_LAST; smc->hw.oem_id++) {
555                 if (smc->hw.oem_id->oi_status < smc->hw.oem_min_status)
556                         continue ;
557 #endif
558                 ven_id = OEMID(smc,0) + (OEMID(smc,1) << 8) ; 
559                 dev_id = OEMID(smc,2) + (OEMID(smc,3) << 8) ; 
560                 for (i = 0; i < slot; i++) {
561                         if (pci_find_device(i,&smc->hw.pci_handle,
562                                 dev_id,ven_id) != 0) {
563
564                                 found = FALSE ;
565                         } else {
566                                 found = TRUE ;
567                         }
568                 }
569                 if (found) {
570                         return(1) ;     /* adapter was found */
571                 }
572 #ifdef MULT_OEM
573         }
574 #endif
575         return(0) ;     /* adapter was not found */
576 }
577 #endif  /* PCI */
578 #endif  /* USE_BIOS_FUNC */
579
580 void driver_get_bia(struct s_smc *smc, struct fddi_addr *bia_addr)
581 {
582         int i ;
583
584         for (i = 0 ; i < 6 ; i++)
585                 bia_addr->a[i] = bitrev8(smc->hw.fddi_phys_addr.a[i]);
586 }
587
588 void smt_start_watchdog(struct s_smc *smc)
589 {
590         SK_UNUSED(smc) ;        /* Make LINT happy. */
591
592 #ifndef DEBUG
593
594 #ifdef  PCI
595         if (smc->hw.wdog_used) {
596                 outpw(ADDR(B2_WDOG_CRTL),TIM_START) ;   /* Start timer. */
597         }
598 #endif
599
600 #endif  /* DEBUG */
601 }
602
603 static void smt_stop_watchdog(struct s_smc *smc)
604 {
605         SK_UNUSED(smc) ;        /* Make LINT happy. */
606 #ifndef DEBUG
607
608 #ifdef  PCI
609         if (smc->hw.wdog_used) {
610                 outpw(ADDR(B2_WDOG_CRTL),TIM_STOP) ;    /* Stop timer. */
611         }
612 #endif
613
614 #endif  /* DEBUG */
615 }
616
617 #ifdef  PCI
618
619 void mac_do_pci_fix(struct s_smc *smc)
620 {
621         SK_UNUSED(smc) ;
622 }
623 #endif  /* PCI */
624