diff options
Diffstat (limited to 'drivers/net/skfp')
-rw-r--r-- | drivers/net/skfp/Makefile | 4 | ||||
-rw-r--r-- | drivers/net/skfp/drvfbi.c | 222 | ||||
-rw-r--r-- | drivers/net/skfp/ess.c | 4 | ||||
-rw-r--r-- | drivers/net/skfp/fplustm.c | 70 | ||||
-rw-r--r-- | drivers/net/skfp/h/cmtdef.h | 7 | ||||
-rw-r--r-- | drivers/net/skfp/h/hwmtm.h | 25 | ||||
-rw-r--r-- | drivers/net/skfp/hwmtm.c | 34 | ||||
-rw-r--r-- | drivers/net/skfp/pcmplc.c | 7 | ||||
-rw-r--r-- | drivers/net/skfp/pmf.c | 11 | ||||
-rw-r--r-- | drivers/net/skfp/skfddi.c | 1 | ||||
-rw-r--r-- | drivers/net/skfp/smt.c | 46 | ||||
-rw-r--r-- | drivers/net/skfp/smtdef.c | 5 | ||||
-rw-r--r-- | drivers/net/skfp/smtparse.c | 467 |
13 files changed, 20 insertions, 883 deletions
diff --git a/drivers/net/skfp/Makefile b/drivers/net/skfp/Makefile index 5f4bb1a67400..cb23580fcffa 100644 --- a/drivers/net/skfp/Makefile +++ b/drivers/net/skfp/Makefile | |||
@@ -6,8 +6,8 @@ obj-$(CONFIG_SKFP) += skfp.o | |||
6 | 6 | ||
7 | skfp-objs := skfddi.o hwmtm.o fplustm.o smt.o cfm.o \ | 7 | skfp-objs := skfddi.o hwmtm.o fplustm.o smt.o cfm.o \ |
8 | ecm.o pcmplc.o pmf.o queue.o rmt.o \ | 8 | ecm.o pcmplc.o pmf.o queue.o rmt.o \ |
9 | smtdef.o smtinit.o smttimer.o srf.o smtparse.o\ | 9 | smtdef.o smtinit.o smttimer.o srf.o hwt.o \ |
10 | hwt.o drvfbi.o ess.o | 10 | drvfbi.o ess.o |
11 | 11 | ||
12 | # NOTE: | 12 | # NOTE: |
13 | # Compiling this driver produces some warnings (and some more are | 13 | # Compiling this driver produces some warnings (and some more are |
diff --git a/drivers/net/skfp/drvfbi.c b/drivers/net/skfp/drvfbi.c index 052e841ba187..5b475833f645 100644 --- a/drivers/net/skfp/drvfbi.c +++ b/drivers/net/skfp/drvfbi.c | |||
@@ -105,8 +105,8 @@ extern int AIX_vpdReadByte() ; | |||
105 | #endif | 105 | #endif |
106 | 106 | ||
107 | 107 | ||
108 | /* Prototypes of local functions. */ | 108 | /* Prototype of a local function. */ |
109 | void smt_stop_watchdog(struct s_smc *smc); | 109 | static void smt_stop_watchdog(struct s_smc *smc); |
110 | 110 | ||
111 | #ifdef MCA | 111 | #ifdef MCA |
112 | static int read_card_id() ; | 112 | static int read_card_id() ; |
@@ -631,7 +631,7 @@ void plc_clear_irq(struct s_smc *smc, int p) | |||
631 | * LED_Y_OFF just switch yellow LED off | 631 | * LED_Y_OFF just switch yellow LED off |
632 | * LED_Y_ON just switch yello LED on | 632 | * LED_Y_ON just switch yello LED on |
633 | */ | 633 | */ |
634 | void led_indication(struct s_smc *smc, int led_event) | 634 | static void led_indication(struct s_smc *smc, int led_event) |
635 | { | 635 | { |
636 | /* use smc->hw.mac_ring_is_up == TRUE | 636 | /* use smc->hw.mac_ring_is_up == TRUE |
637 | * as indication for Ring Operational | 637 | * as indication for Ring Operational |
@@ -764,122 +764,6 @@ void llc_recover_tx(struct s_smc *smc) | |||
764 | #endif | 764 | #endif |
765 | } | 765 | } |
766 | 766 | ||
767 | /*--------------------------- DMA init ----------------------------*/ | ||
768 | #ifdef ISA | ||
769 | |||
770 | /* | ||
771 | * init DMA | ||
772 | */ | ||
773 | void init_dma(struct s_smc *smc, int dma) | ||
774 | { | ||
775 | SK_UNUSED(smc) ; | ||
776 | |||
777 | /* | ||
778 | * set cascade mode, | ||
779 | * clear mask bit (enable DMA cannal) | ||
780 | */ | ||
781 | if (dma > 3) { | ||
782 | outp(0xd6,(dma & 0x03) | 0xc0) ; | ||
783 | outp(0xd4, dma & 0x03) ; | ||
784 | } | ||
785 | else { | ||
786 | outp(0x0b,(dma & 0x03) | 0xc0) ; | ||
787 | outp(0x0a,dma & 0x03) ; | ||
788 | } | ||
789 | } | ||
790 | |||
791 | /* | ||
792 | * disable DMA | ||
793 | */ | ||
794 | void dis_dma(struct s_smc *smc, int dma) | ||
795 | { | ||
796 | SK_UNUSED(smc) ; | ||
797 | |||
798 | /* | ||
799 | * set mask bit (disable DMA cannal) | ||
800 | */ | ||
801 | if (dma > 3) { | ||
802 | outp(0xd4,(dma & 0x03) | 0x04) ; | ||
803 | } | ||
804 | else { | ||
805 | outp(0x0a,(dma & 0x03) | 0x04) ; | ||
806 | } | ||
807 | } | ||
808 | |||
809 | #endif /* ISA */ | ||
810 | |||
811 | #ifdef EISA | ||
812 | |||
813 | /*arrays with io addresses of dma controller length and address registers*/ | ||
814 | static const int cntr[8] = { 0x001,0x003,0x005,0x007,0,0x0c6,0x0ca,0x0ce } ; | ||
815 | static const int base[8] = { 0x000,0x002,0x004,0x006,0,0x0c4,0x0c8,0x0cc } ; | ||
816 | static const int page[8] = { 0x087,0x083,0x081,0x082,0,0x08b,0x089,0x08a } ; | ||
817 | |||
818 | void init_dma(struct s_smc *smc, int dma) | ||
819 | { | ||
820 | /* | ||
821 | * extended mode register | ||
822 | * 32 bit IO | ||
823 | * type c | ||
824 | * TC output | ||
825 | * disable stop | ||
826 | */ | ||
827 | |||
828 | /* mode read (write) demand */ | ||
829 | smc->hw.dma_rmode = (dma & 3) | 0x08 | 0x0 ; | ||
830 | smc->hw.dma_wmode = (dma & 3) | 0x04 | 0x0 ; | ||
831 | |||
832 | /* 32 bit IO's, burst DMA mode (type "C") */ | ||
833 | smc->hw.dma_emode = (dma & 3) | 0x08 | 0x30 ; | ||
834 | |||
835 | outp((dma < 4) ? 0x40b : 0x4d6,smc->hw.dma_emode) ; | ||
836 | |||
837 | /* disable chaining */ | ||
838 | outp((dma < 4) ? 0x40a : 0x4d4,(dma&3)) ; | ||
839 | |||
840 | /*load dma controller addresses for fast access during set dma*/ | ||
841 | smc->hw.dma_base_word_count = cntr[smc->hw.dma]; | ||
842 | smc->hw.dma_base_address = base[smc->hw.dma]; | ||
843 | smc->hw.dma_base_address_page = page[smc->hw.dma]; | ||
844 | |||
845 | } | ||
846 | |||
847 | void dis_dma(struct s_smc *smc, int dma) | ||
848 | { | ||
849 | SK_UNUSED(smc) ; | ||
850 | |||
851 | outp((dma < 4) ? 0x0a : 0xd4,(dma&3)|4) ;/* mask bit */ | ||
852 | } | ||
853 | #endif /* EISA */ | ||
854 | |||
855 | #ifdef MCA | ||
856 | void init_dma(struct s_smc *smc, int dma) | ||
857 | { | ||
858 | SK_UNUSED(smc) ; | ||
859 | SK_UNUSED(dma) ; | ||
860 | } | ||
861 | |||
862 | void dis_dma(struct s_smc *smc, int dma) | ||
863 | { | ||
864 | SK_UNUSED(smc) ; | ||
865 | SK_UNUSED(dma) ; | ||
866 | } | ||
867 | #endif | ||
868 | |||
869 | #ifdef PCI | ||
870 | void init_dma(struct s_smc *smc, int dma) | ||
871 | { | ||
872 | SK_UNUSED(smc) ; | ||
873 | SK_UNUSED(dma) ; | ||
874 | } | ||
875 | |||
876 | void dis_dma(struct s_smc *smc, int dma) | ||
877 | { | ||
878 | SK_UNUSED(smc) ; | ||
879 | SK_UNUSED(dma) ; | ||
880 | } | ||
881 | #endif | ||
882 | |||
883 | #ifdef MULT_OEM | 767 | #ifdef MULT_OEM |
884 | static int is_equal_num(char comp1[], char comp2[], int num) | 768 | static int is_equal_num(char comp1[], char comp2[], int num) |
885 | { | 769 | { |
@@ -1407,7 +1291,7 @@ void smt_start_watchdog(struct s_smc *smc) | |||
1407 | #endif /* DEBUG */ | 1291 | #endif /* DEBUG */ |
1408 | } | 1292 | } |
1409 | 1293 | ||
1410 | void smt_stop_watchdog(struct s_smc *smc) | 1294 | static void smt_stop_watchdog(struct s_smc *smc) |
1411 | { | 1295 | { |
1412 | SK_UNUSED(smc) ; /* Make LINT happy. */ | 1296 | SK_UNUSED(smc) ; /* Make LINT happy. */ |
1413 | #ifndef DEBUG | 1297 | #ifndef DEBUG |
@@ -1422,104 +1306,6 @@ void smt_stop_watchdog(struct s_smc *smc) | |||
1422 | } | 1306 | } |
1423 | 1307 | ||
1424 | #ifdef PCI | 1308 | #ifdef PCI |
1425 | static char get_rom_byte(struct s_smc *smc, u_short addr) | ||
1426 | { | ||
1427 | GET_PAGE(addr) ; | ||
1428 | return (READ_PROM(ADDR(B2_FDP))) ; | ||
1429 | } | ||
1430 | |||
1431 | /* | ||
1432 | * ROM image defines | ||
1433 | */ | ||
1434 | #define ROM_SIG_1 0 | ||
1435 | #define ROM_SIG_2 1 | ||
1436 | #define PCI_DATA_1 0x18 | ||
1437 | #define PCI_DATA_2 0x19 | ||
1438 | |||
1439 | /* | ||
1440 | * PCI data structure defines | ||
1441 | */ | ||
1442 | #define VPD_DATA_1 0x08 | ||
1443 | #define VPD_DATA_2 0x09 | ||
1444 | #define IMAGE_LEN_1 0x10 | ||
1445 | #define IMAGE_LEN_2 0x11 | ||
1446 | #define CODE_TYPE 0x14 | ||
1447 | #define INDICATOR 0x15 | ||
1448 | |||
1449 | /* | ||
1450 | * BEGIN_MANUAL_ENTRY(mac_drv_vpd_read) | ||
1451 | * mac_drv_vpd_read(smc,buf,size,image) | ||
1452 | * | ||
1453 | * function DOWNCALL (FDDIWARE) | ||
1454 | * reads the VPD data of the FPROM and writes it into the | ||
1455 | * buffer | ||
1456 | * | ||
1457 | * para buf points to the buffer for the VPD data | ||
1458 | * size size of the VPD data buffer | ||
1459 | * image boot image; code type of the boot image | ||
1460 | * image = 0 Intel x86, PC-AT compatible | ||
1461 | * 1 OPENBOOT standard for PCI | ||
1462 | * 2-FF reserved | ||
1463 | * | ||
1464 | * returns len number of VPD data bytes read form the FPROM | ||
1465 | * <0 number of read bytes | ||
1466 | * >0 error: data invalid | ||
1467 | * | ||
1468 | * END_MANUAL_ENTRY | ||
1469 | */ | ||
1470 | int mac_drv_vpd_read(struct s_smc *smc, char *buf, int size, char image) | ||
1471 | { | ||
1472 | u_short ibase ; | ||
1473 | u_short pci_base ; | ||
1474 | u_short vpd ; | ||
1475 | int len ; | ||
1476 | |||
1477 | len = 0 ; | ||
1478 | ibase = 0 ; | ||
1479 | /* | ||
1480 | * as long images defined | ||
1481 | */ | ||
1482 | while (get_rom_byte(smc,ibase+ROM_SIG_1) == 0x55 && | ||
1483 | (u_char) get_rom_byte(smc,ibase+ROM_SIG_2) == 0xaa) { | ||
1484 | /* | ||
1485 | * get the pointer to the PCI data structure | ||
1486 | */ | ||
1487 | pci_base = ibase + get_rom_byte(smc,ibase+PCI_DATA_1) + | ||
1488 | (get_rom_byte(smc,ibase+PCI_DATA_2) << 8) ; | ||
1489 | |||
1490 | if (image == get_rom_byte(smc,pci_base+CODE_TYPE)) { | ||
1491 | /* | ||
1492 | * we have the right image, read the VPD data | ||
1493 | */ | ||
1494 | vpd = ibase + get_rom_byte(smc,pci_base+VPD_DATA_1) + | ||
1495 | (get_rom_byte(smc,pci_base+VPD_DATA_2) << 8) ; | ||
1496 | if (vpd == ibase) { | ||
1497 | break ; /* no VPD data */ | ||
1498 | } | ||
1499 | for (len = 0; len < size; len++,buf++,vpd++) { | ||
1500 | *buf = get_rom_byte(smc,vpd) ; | ||
1501 | } | ||
1502 | break ; | ||
1503 | } | ||
1504 | else { | ||
1505 | /* | ||
1506 | * try the next image | ||
1507 | */ | ||
1508 | if (get_rom_byte(smc,pci_base+INDICATOR) & 0x80) { | ||
1509 | break ; /* this was the last image */ | ||
1510 | } | ||
1511 | ibase = ibase + get_rom_byte(smc,ibase+IMAGE_LEN_1) + | ||
1512 | (get_rom_byte(smc,ibase+IMAGE_LEN_2) << 8) ; | ||
1513 | } | ||
1514 | } | ||
1515 | |||
1516 | return(len) ; | ||
1517 | } | ||
1518 | |||
1519 | void mac_drv_pci_fix(struct s_smc *smc, u_long fix_value) | ||
1520 | { | ||
1521 | smc->hw.pci_fix_value = fix_value ; | ||
1522 | } | ||
1523 | 1309 | ||
1524 | void mac_do_pci_fix(struct s_smc *smc) | 1310 | void mac_do_pci_fix(struct s_smc *smc) |
1525 | { | 1311 | { |
diff --git a/drivers/net/skfp/ess.c b/drivers/net/skfp/ess.c index fd39b4b2ef7d..62b01328c496 100644 --- a/drivers/net/skfp/ess.c +++ b/drivers/net/skfp/ess.c | |||
@@ -102,7 +102,7 @@ void ess_timer_poll(struct s_smc *smc); | |||
102 | void ess_para_change(struct s_smc *smc); | 102 | void ess_para_change(struct s_smc *smc); |
103 | int ess_raf_received_pack(struct s_smc *smc, SMbuf *mb, struct smt_header *sm, | 103 | int ess_raf_received_pack(struct s_smc *smc, SMbuf *mb, struct smt_header *sm, |
104 | int fs); | 104 | int fs); |
105 | int process_bw_alloc(struct s_smc *smc, long int payload, long int overhead); | 105 | static int process_bw_alloc(struct s_smc *smc, long int payload, long int overhead); |
106 | 106 | ||
107 | 107 | ||
108 | /* | 108 | /* |
@@ -375,7 +375,7 @@ int ess_raf_received_pack(struct s_smc *smc, SMbuf *mb, struct smt_header *sm, | |||
375 | * determines the synchronous bandwidth, set the TSYNC register and the | 375 | * determines the synchronous bandwidth, set the TSYNC register and the |
376 | * mib variables SBAPayload, SBAOverhead and fddiMACT-NEG. | 376 | * mib variables SBAPayload, SBAOverhead and fddiMACT-NEG. |
377 | */ | 377 | */ |
378 | int process_bw_alloc(struct s_smc *smc, long int payload, long int overhead) | 378 | static int process_bw_alloc(struct s_smc *smc, long int payload, long int overhead) |
379 | { | 379 | { |
380 | /* | 380 | /* |
381 | * determine the synchronous bandwidth (sync_bw) in bytes per T-NEG, | 381 | * determine the synchronous bandwidth (sync_bw) in bytes per T-NEG, |
diff --git a/drivers/net/skfp/fplustm.c b/drivers/net/skfp/fplustm.c index 76e78442fc24..a2ed47f1cc70 100644 --- a/drivers/net/skfp/fplustm.c +++ b/drivers/net/skfp/fplustm.c | |||
@@ -1117,30 +1117,6 @@ void mac_clear_multicast(struct s_smc *smc) | |||
1117 | /* | 1117 | /* |
1118 | BEGIN_MANUAL_ENTRY(if,func;others;2) | 1118 | BEGIN_MANUAL_ENTRY(if,func;others;2) |
1119 | 1119 | ||
1120 | int mac_set_func_addr(smc,f_addr) | ||
1121 | struct s_smc *smc ; | ||
1122 | u_long f_addr ; | ||
1123 | |||
1124 | Function DOWNCALL (SMT, fplustm.c) | ||
1125 | Set a Token-Ring functional address, the address will | ||
1126 | be activated after calling mac_update_multicast() | ||
1127 | |||
1128 | Para f_addr functional bits in non-canonical format | ||
1129 | |||
1130 | Returns 0: always success | ||
1131 | |||
1132 | END_MANUAL_ENTRY() | ||
1133 | */ | ||
1134 | int mac_set_func_addr(struct s_smc *smc, u_long f_addr) | ||
1135 | { | ||
1136 | smc->hw.fp.func_addr = f_addr ; | ||
1137 | return(0) ; | ||
1138 | } | ||
1139 | |||
1140 | |||
1141 | /* | ||
1142 | BEGIN_MANUAL_ENTRY(if,func;others;2) | ||
1143 | |||
1144 | int mac_add_multicast(smc,addr,can) | 1120 | int mac_add_multicast(smc,addr,can) |
1145 | struct s_smc *smc ; | 1121 | struct s_smc *smc ; |
1146 | struct fddi_addr *addr ; | 1122 | struct fddi_addr *addr ; |
@@ -1203,52 +1179,6 @@ int mac_add_multicast(struct s_smc *smc, struct fddi_addr *addr, int can) | |||
1203 | } | 1179 | } |
1204 | 1180 | ||
1205 | /* | 1181 | /* |
1206 | BEGIN_MANUAL_ENTRY(if,func;others;2) | ||
1207 | |||
1208 | void mac_del_multicast(smc,addr,can) | ||
1209 | struct s_smc *smc ; | ||
1210 | struct fddi_addr *addr ; | ||
1211 | int can ; | ||
1212 | |||
1213 | Function DOWNCALL (SMT, fplustm.c) | ||
1214 | Delete an entry from the multicast table | ||
1215 | |||
1216 | Para addr pointer to a multicast address | ||
1217 | can = 0: the multicast address has the physical format | ||
1218 | = 1: the multicast address has the canonical format | ||
1219 | | 0x80 permanent | ||
1220 | |||
1221 | END_MANUAL_ENTRY() | ||
1222 | */ | ||
1223 | void mac_del_multicast(struct s_smc *smc, struct fddi_addr *addr, int can) | ||
1224 | { | ||
1225 | SK_LOC_DECL(struct fddi_addr,own) ; | ||
1226 | struct s_fpmc *tb ; | ||
1227 | |||
1228 | if (!(tb = mac_get_mc_table(smc,addr,&own,1,can & ~0x80))) | ||
1229 | return ; | ||
1230 | /* | ||
1231 | * permanent addresses must be deleted with perm bit | ||
1232 | * and vice versa | ||
1233 | */ | ||
1234 | if (( tb->perm && (can & 0x80)) || | ||
1235 | (!tb->perm && !(can & 0x80))) { | ||
1236 | /* | ||
1237 | * delete it | ||
1238 | */ | ||
1239 | if (tb->n) { | ||
1240 | tb->n-- ; | ||
1241 | if (tb->perm) { | ||
1242 | smc->hw.fp.smt_slots_used-- ; | ||
1243 | } | ||
1244 | else { | ||
1245 | smc->hw.fp.os_slots_used-- ; | ||
1246 | } | ||
1247 | } | ||
1248 | } | ||
1249 | } | ||
1250 | |||
1251 | /* | ||
1252 | * mode | 1182 | * mode |
1253 | */ | 1183 | */ |
1254 | 1184 | ||
diff --git a/drivers/net/skfp/h/cmtdef.h b/drivers/net/skfp/h/cmtdef.h index 603982debc71..f2f771d8be76 100644 --- a/drivers/net/skfp/h/cmtdef.h +++ b/drivers/net/skfp/h/cmtdef.h | |||
@@ -507,7 +507,6 @@ void pcm_status_state(struct s_smc *smc, int np, int *type, int *state, | |||
507 | int *remote, int *mac); | 507 | int *remote, int *mac); |
508 | void plc_config_mux(struct s_smc *smc, int mux); | 508 | void plc_config_mux(struct s_smc *smc, int mux); |
509 | void sm_lem_evaluate(struct s_smc *smc); | 509 | void sm_lem_evaluate(struct s_smc *smc); |
510 | void smt_clear_una_dna(struct s_smc *smc); | ||
511 | void mac_update_counter(struct s_smc *smc); | 510 | void mac_update_counter(struct s_smc *smc); |
512 | void sm_pm_ls_latch(struct s_smc *smc, int phy, int on_off); | 511 | void sm_pm_ls_latch(struct s_smc *smc, int phy, int on_off); |
513 | void sm_ma_control(struct s_smc *smc, int mode); | 512 | void sm_ma_control(struct s_smc *smc, int mode); |
@@ -541,11 +540,9 @@ void smt_timer_poll(struct s_smc *smc); | |||
541 | u_long smt_get_time(void); | 540 | u_long smt_get_time(void); |
542 | u_long smt_get_tid(struct s_smc *smc); | 541 | u_long smt_get_tid(struct s_smc *smc); |
543 | void smt_timer_done(struct s_smc *smc); | 542 | void smt_timer_done(struct s_smc *smc); |
544 | void smt_set_defaults(struct s_smc *smc); | ||
545 | void smt_fixup_mib(struct s_smc *smc); | 543 | void smt_fixup_mib(struct s_smc *smc); |
546 | void smt_reset_defaults(struct s_smc *smc, int level); | 544 | void smt_reset_defaults(struct s_smc *smc, int level); |
547 | void smt_agent_task(struct s_smc *smc); | 545 | void smt_agent_task(struct s_smc *smc); |
548 | void smt_please_reconnect(struct s_smc *smc, int reconn_time); | ||
549 | int smt_check_para(struct s_smc *smc, struct smt_header *sm, | 546 | int smt_check_para(struct s_smc *smc, struct smt_header *sm, |
550 | const u_short list[]); | 547 | const u_short list[]); |
551 | void driver_get_bia(struct s_smc *smc, struct fddi_addr *bia_addr); | 548 | void driver_get_bia(struct s_smc *smc, struct fddi_addr *bia_addr); |
@@ -568,7 +565,6 @@ int pcm_get_s_port(struct s_smc *smc); | |||
568 | int pcm_rooted_station(struct s_smc *smc); | 565 | int pcm_rooted_station(struct s_smc *smc); |
569 | int cfm_get_mac_input(struct s_smc *smc); | 566 | int cfm_get_mac_input(struct s_smc *smc); |
570 | int cfm_get_mac_output(struct s_smc *smc); | 567 | int cfm_get_mac_output(struct s_smc *smc); |
571 | int port_to_mib(struct s_smc *smc, int p); | ||
572 | int cem_build_path(struct s_smc *smc, char *to, int path_index); | 568 | int cem_build_path(struct s_smc *smc, char *to, int path_index); |
573 | int sm_mac_get_tx_state(struct s_smc *smc); | 569 | int sm_mac_get_tx_state(struct s_smc *smc); |
574 | char *get_pcmstate(struct s_smc *smc, int np); | 570 | char *get_pcmstate(struct s_smc *smc, int np); |
@@ -580,8 +576,6 @@ void smt_send_frame(struct s_smc *smc, SMbuf *mb, int fc, int local); | |||
580 | void smt_set_timestamp(struct s_smc *smc, u_char *p); | 576 | void smt_set_timestamp(struct s_smc *smc, u_char *p); |
581 | void mac_set_rx_mode(struct s_smc *smc, int mode); | 577 | void mac_set_rx_mode(struct s_smc *smc, int mode); |
582 | int mac_add_multicast(struct s_smc *smc, struct fddi_addr *addr, int can); | 578 | int mac_add_multicast(struct s_smc *smc, struct fddi_addr *addr, int can); |
583 | int mac_set_func_addr(struct s_smc *smc, u_long f_addr); | ||
584 | void mac_del_multicast(struct s_smc *smc, struct fddi_addr *addr, int can); | ||
585 | void mac_update_multicast(struct s_smc *smc); | 579 | void mac_update_multicast(struct s_smc *smc); |
586 | void mac_clear_multicast(struct s_smc *smc); | 580 | void mac_clear_multicast(struct s_smc *smc); |
587 | void set_formac_tsync(struct s_smc *smc, long sync_bw); | 581 | void set_formac_tsync(struct s_smc *smc, long sync_bw); |
@@ -599,7 +593,6 @@ void plc_irq(struct s_smc *smc, int np, unsigned int cmd); | |||
599 | int smt_set_mac_opvalues(struct s_smc *smc); | 593 | int smt_set_mac_opvalues(struct s_smc *smc); |
600 | 594 | ||
601 | #ifdef TAG_MODE | 595 | #ifdef TAG_MODE |
602 | void mac_drv_pci_fix(struct s_smc *smc, u_long fix_value); | ||
603 | void mac_do_pci_fix(struct s_smc *smc); | 596 | void mac_do_pci_fix(struct s_smc *smc); |
604 | void mac_drv_clear_tx_queue(struct s_smc *smc); | 597 | void mac_drv_clear_tx_queue(struct s_smc *smc); |
605 | void mac_drv_repair_descr(struct s_smc *smc); | 598 | void mac_drv_repair_descr(struct s_smc *smc); |
diff --git a/drivers/net/skfp/h/hwmtm.h b/drivers/net/skfp/h/hwmtm.h index 4e360af07d77..1a606d4bfe5e 100644 --- a/drivers/net/skfp/h/hwmtm.h +++ b/drivers/net/skfp/h/hwmtm.h | |||
@@ -262,31 +262,6 @@ struct os_debug { | |||
262 | (smc)->hw.fp.tx_q[queue].tx_curr_put | 262 | (smc)->hw.fp.tx_q[queue].tx_curr_put |
263 | 263 | ||
264 | /* | 264 | /* |
265 | * BEGIN_MANUAL_ENTRY(HWM_TX_CHECK) | ||
266 | * void HWM_TX_CHECK(smc,frame_status,low_water) | ||
267 | * | ||
268 | * function MACRO (hardware module, hwmtm.h) | ||
269 | * This macro is invoked by the OS-specific before it left it's | ||
270 | * driver_send function. This macro calls mac_drv_clear_txd | ||
271 | * if the free TxDs of the current transmit queue is equal or | ||
272 | * lower than the given low water mark. | ||
273 | * | ||
274 | * para frame_status status of the frame, see design description | ||
275 | * low_water low water mark of free TxD's | ||
276 | * | ||
277 | * END_MANUAL_ENTRY | ||
278 | */ | ||
279 | #ifndef HWM_NO_FLOW_CTL | ||
280 | #define HWM_TX_CHECK(smc,frame_status,low_water) {\ | ||
281 | if ((low_water)>=(smc)->hw.fp.tx_q[(frame_status)&QUEUE_A0].tx_free) {\ | ||
282 | mac_drv_clear_txd(smc) ;\ | ||
283 | }\ | ||
284 | } | ||
285 | #else | ||
286 | #define HWM_TX_CHECK(smc,frame_status,low_water) mac_drv_clear_txd(smc) | ||
287 | #endif | ||
288 | |||
289 | /* | ||
290 | * BEGIN_MANUAL_ENTRY(HWM_GET_RX_FRAG_LEN) | 265 | * BEGIN_MANUAL_ENTRY(HWM_GET_RX_FRAG_LEN) |
291 | * int HWM_GET_RX_FRAG_LEN(rxd) | 266 | * int HWM_GET_RX_FRAG_LEN(rxd) |
292 | * | 267 | * |
diff --git a/drivers/net/skfp/hwmtm.c b/drivers/net/skfp/hwmtm.c index 18d429021edb..438f424e6361 100644 --- a/drivers/net/skfp/hwmtm.c +++ b/drivers/net/skfp/hwmtm.c | |||
@@ -86,6 +86,7 @@ static u_long repair_txd_ring(struct s_smc *smc, struct s_smt_tx_queue *queue); | |||
86 | static u_long repair_rxd_ring(struct s_smc *smc, struct s_smt_rx_queue *queue); | 86 | static u_long repair_rxd_ring(struct s_smc *smc, struct s_smt_rx_queue *queue); |
87 | static SMbuf* get_llc_rx(struct s_smc *smc); | 87 | static SMbuf* get_llc_rx(struct s_smc *smc); |
88 | static SMbuf* get_txd_mb(struct s_smc *smc); | 88 | static SMbuf* get_txd_mb(struct s_smc *smc); |
89 | static void mac_drv_clear_txd(struct s_smc *smc); | ||
89 | 90 | ||
90 | /* | 91 | /* |
91 | ------------------------------------------------------------- | 92 | ------------------------------------------------------------- |
@@ -146,7 +147,6 @@ extern int mac_drv_rx_init(struct s_smc *smc, int len, int fc, char *look_ahead, | |||
146 | */ | 147 | */ |
147 | void process_receive(struct s_smc *smc); | 148 | void process_receive(struct s_smc *smc); |
148 | void fddi_isr(struct s_smc *smc); | 149 | void fddi_isr(struct s_smc *smc); |
149 | void mac_drv_clear_txd(struct s_smc *smc); | ||
150 | void smt_free_mbuf(struct s_smc *smc, SMbuf *mb); | 150 | void smt_free_mbuf(struct s_smc *smc, SMbuf *mb); |
151 | void init_driver_fplus(struct s_smc *smc); | 151 | void init_driver_fplus(struct s_smc *smc); |
152 | void mac_drv_rx_mode(struct s_smc *smc, int mode); | 152 | void mac_drv_rx_mode(struct s_smc *smc, int mode); |
@@ -158,7 +158,6 @@ void hwm_tx_frag(struct s_smc *smc, char far *virt, u_long phys, int len, | |||
158 | void hwm_rx_frag(struct s_smc *smc, char far *virt, u_long phys, int len, | 158 | void hwm_rx_frag(struct s_smc *smc, char far *virt, u_long phys, int len, |
159 | int frame_status); | 159 | int frame_status); |
160 | 160 | ||
161 | int mac_drv_rx_frag(struct s_smc *smc, void far *virt, int len); | ||
162 | int mac_drv_init(struct s_smc *smc); | 161 | int mac_drv_init(struct s_smc *smc); |
163 | int hwm_tx_init(struct s_smc *smc, u_char fc, int frag_count, int frame_len, | 162 | int hwm_tx_init(struct s_smc *smc, u_char fc, int frag_count, int frame_len, |
164 | int frame_status); | 163 | int frame_status); |
@@ -1448,35 +1447,6 @@ void hwm_rx_frag(struct s_smc *smc, char far *virt, u_long phys, int len, | |||
1448 | NDD_TRACE("RHfE",r,AIX_REVERSE(r->rxd_rbadr),0) ; | 1447 | NDD_TRACE("RHfE",r,AIX_REVERSE(r->rxd_rbadr),0) ; |
1449 | } | 1448 | } |
1450 | 1449 | ||
1451 | #ifndef NDIS_OS2 | ||
1452 | /* | ||
1453 | * BEGIN_MANUAL_ENTRY(mac_drv_rx_frag) | ||
1454 | * int mac_drv_rx_frag(smc,virt,len) | ||
1455 | * | ||
1456 | * function DOWNCALL (hwmtm.c) | ||
1457 | * mac_drv_rx_frag fills the fragment with a part of the frame. | ||
1458 | * | ||
1459 | * para virt the virtual address of the fragment | ||
1460 | * len the length in bytes of the fragment | ||
1461 | * | ||
1462 | * return 0: success code, no errors possible | ||
1463 | * | ||
1464 | * END_MANUAL_ENTRY | ||
1465 | */ | ||
1466 | int mac_drv_rx_frag(struct s_smc *smc, void far *virt, int len) | ||
1467 | { | ||
1468 | NDD_TRACE("RHSB",virt,len,smc->os.hwm.r.mb_pos) ; | ||
1469 | |||
1470 | DB_RX("receive from queue: len/virt: = %d/%x",len,virt,4) ; | ||
1471 | memcpy((char far *)virt,smc->os.hwm.r.mb_pos,len) ; | ||
1472 | smc->os.hwm.r.mb_pos += len ; | ||
1473 | |||
1474 | NDD_TRACE("RHSE",smc->os.hwm.r.mb_pos,0,0) ; | ||
1475 | return(0) ; | ||
1476 | } | ||
1477 | #endif | ||
1478 | |||
1479 | |||
1480 | /* | 1450 | /* |
1481 | * BEGINN_MANUAL_ENTRY(mac_drv_clear_rx_queue) | 1451 | * BEGINN_MANUAL_ENTRY(mac_drv_clear_rx_queue) |
1482 | * | 1452 | * |
@@ -1978,7 +1948,7 @@ void smt_send_mbuf(struct s_smc *smc, SMbuf *mb, int fc) | |||
1978 | * | 1948 | * |
1979 | * END_MANUAL_ENTRY | 1949 | * END_MANUAL_ENTRY |
1980 | */ | 1950 | */ |
1981 | void mac_drv_clear_txd(struct s_smc *smc) | 1951 | static void mac_drv_clear_txd(struct s_smc *smc) |
1982 | { | 1952 | { |
1983 | struct s_smt_tx_queue *queue ; | 1953 | struct s_smt_tx_queue *queue ; |
1984 | struct s_smt_fp_txd volatile *t1 ; | 1954 | struct s_smt_fp_txd volatile *t1 ; |
diff --git a/drivers/net/skfp/pcmplc.c b/drivers/net/skfp/pcmplc.c index 571f055c096b..cd0aa4c151b0 100644 --- a/drivers/net/skfp/pcmplc.c +++ b/drivers/net/skfp/pcmplc.c | |||
@@ -1861,13 +1861,6 @@ void plc_irq(struct s_smc *smc, int np, unsigned int cmd) | |||
1861 | #endif | 1861 | #endif |
1862 | } | 1862 | } |
1863 | 1863 | ||
1864 | void pcm_set_lct_short(struct s_smc *smc, int n) | ||
1865 | { | ||
1866 | if (n <= 0 || n > 1000) | ||
1867 | return ; | ||
1868 | smc->s.lct_short = n ; | ||
1869 | } | ||
1870 | |||
1871 | #ifdef DEBUG | 1864 | #ifdef DEBUG |
1872 | /* | 1865 | /* |
1873 | * fill state struct | 1866 | * fill state struct |
diff --git a/drivers/net/skfp/pmf.c b/drivers/net/skfp/pmf.c index f2b446d8b0bf..efc639c013fd 100644 --- a/drivers/net/skfp/pmf.c +++ b/drivers/net/skfp/pmf.c | |||
@@ -36,12 +36,13 @@ static int smt_authorize(struct s_smc *smc, struct smt_header *sm); | |||
36 | static int smt_check_set_count(struct s_smc *smc, struct smt_header *sm); | 36 | static int smt_check_set_count(struct s_smc *smc, struct smt_header *sm); |
37 | static const struct s_p_tab* smt_get_ptab(u_short para); | 37 | static const struct s_p_tab* smt_get_ptab(u_short para); |
38 | static int smt_mib_phys(struct s_smc *smc); | 38 | static int smt_mib_phys(struct s_smc *smc); |
39 | int smt_set_para(struct s_smc *smc, struct smt_para *pa, int index, int local, | 39 | static int smt_set_para(struct s_smc *smc, struct smt_para *pa, int index, |
40 | int set); | 40 | int local, int set); |
41 | void smt_add_para(struct s_smc *smc, struct s_pcon *pcon, u_short para, | 41 | void smt_add_para(struct s_smc *smc, struct s_pcon *pcon, u_short para, |
42 | int index, int local); | 42 | int index, int local); |
43 | static SMbuf *smt_build_pmf_response(struct s_smc *smc, struct smt_header *req, | 43 | static SMbuf *smt_build_pmf_response(struct s_smc *smc, struct smt_header *req, |
44 | int set, int local); | 44 | int set, int local); |
45 | static int port_to_mib(struct s_smc *smc, int p); | ||
45 | 46 | ||
46 | #define MOFFSS(e) ((int)&(((struct fddi_mib *)0)->e)) | 47 | #define MOFFSS(e) ((int)&(((struct fddi_mib *)0)->e)) |
47 | #define MOFFSA(e) ((int) (((struct fddi_mib *)0)->e)) | 48 | #define MOFFSA(e) ((int) (((struct fddi_mib *)0)->e)) |
@@ -1078,8 +1079,8 @@ wrong_error: | |||
1078 | /* | 1079 | /* |
1079 | * set parameter | 1080 | * set parameter |
1080 | */ | 1081 | */ |
1081 | int smt_set_para(struct s_smc *smc, struct smt_para *pa, int index, int local, | 1082 | static int smt_set_para(struct s_smc *smc, struct smt_para *pa, int index, |
1082 | int set) | 1083 | int local, int set) |
1083 | { | 1084 | { |
1084 | #define IFSET(x) if (set) (x) | 1085 | #define IFSET(x) if (set) (x) |
1085 | 1086 | ||
@@ -1549,7 +1550,7 @@ static int smt_mib_phys(struct s_smc *smc) | |||
1549 | #endif | 1550 | #endif |
1550 | } | 1551 | } |
1551 | 1552 | ||
1552 | int port_to_mib(struct s_smc *smc, int p) | 1553 | static int port_to_mib(struct s_smc *smc, int p) |
1553 | { | 1554 | { |
1554 | #ifdef CONCENTRATOR | 1555 | #ifdef CONCENTRATOR |
1555 | SK_UNUSED(smc) ; | 1556 | SK_UNUSED(smc) ; |
diff --git a/drivers/net/skfp/skfddi.c b/drivers/net/skfp/skfddi.c index c88aad6edd74..4b5ed2c63177 100644 --- a/drivers/net/skfp/skfddi.c +++ b/drivers/net/skfp/skfddi.c | |||
@@ -149,7 +149,6 @@ extern void hwm_rx_frag(struct s_smc *smc, char far * virt, u_long phys, | |||
149 | extern void mac_drv_rx_mode(struct s_smc *smc, int mode); | 149 | extern void mac_drv_rx_mode(struct s_smc *smc, int mode); |
150 | extern void mac_drv_clear_rx_queue(struct s_smc *smc); | 150 | extern void mac_drv_clear_rx_queue(struct s_smc *smc); |
151 | extern void enable_tx_irq(struct s_smc *smc, u_short queue); | 151 | extern void enable_tx_irq(struct s_smc *smc, u_short queue); |
152 | extern void mac_drv_clear_txd(struct s_smc *smc); | ||
153 | 152 | ||
154 | static struct pci_device_id skfddi_pci_tbl[] = { | 153 | static struct pci_device_id skfddi_pci_tbl[] = { |
155 | { PCI_VENDOR_ID_SK, PCI_DEVICE_ID_SK_FP, PCI_ANY_ID, PCI_ANY_ID, }, | 154 | { PCI_VENDOR_ID_SK, PCI_DEVICE_ID_SK_FP, PCI_ANY_ID, PCI_ANY_ID, }, |
diff --git a/drivers/net/skfp/smt.c b/drivers/net/skfp/smt.c index c3a0d2f10b2b..f17c05cbe44b 100644 --- a/drivers/net/skfp/smt.c +++ b/drivers/net/skfp/smt.c | |||
@@ -110,7 +110,7 @@ static void smt_fill_setcount(struct s_smc *smc, struct smt_p_setcount *setcount | |||
110 | static void smt_fill_echo(struct s_smc *smc, struct smt_p_echo *echo, u_long seed, | 110 | static void smt_fill_echo(struct s_smc *smc, struct smt_p_echo *echo, u_long seed, |
111 | int len); | 111 | int len); |
112 | 112 | ||
113 | void smt_clear_una_dna(struct s_smc *smc); | 113 | static void smt_clear_una_dna(struct s_smc *smc); |
114 | static void smt_clear_old_una_dna(struct s_smc *smc); | 114 | static void smt_clear_old_una_dna(struct s_smc *smc); |
115 | #ifdef CONCENTRATOR | 115 | #ifdef CONCENTRATOR |
116 | static int entity_to_index(void); | 116 | static int entity_to_index(void); |
@@ -118,7 +118,7 @@ static int entity_to_index(void); | |||
118 | static void update_dac(struct s_smc *smc, int report); | 118 | static void update_dac(struct s_smc *smc, int report); |
119 | static int div_ratio(u_long upper, u_long lower); | 119 | static int div_ratio(u_long upper, u_long lower); |
120 | #ifdef USE_CAN_ADDR | 120 | #ifdef USE_CAN_ADDR |
121 | void hwm_conv_can(struct s_smc *smc, char *data, int len); | 121 | static void hwm_conv_can(struct s_smc *smc, char *data, int len); |
122 | #else | 122 | #else |
123 | #define hwm_conv_can(smc,data,len) | 123 | #define hwm_conv_can(smc,data,len) |
124 | #endif | 124 | #endif |
@@ -216,24 +216,6 @@ void smt_agent_task(struct s_smc *smc) | |||
216 | DB_SMT("SMT agent task\n",0,0) ; | 216 | DB_SMT("SMT agent task\n",0,0) ; |
217 | } | 217 | } |
218 | 218 | ||
219 | void smt_please_reconnect(struct s_smc *smc, int reconn_time) | ||
220 | /* struct s_smc *smc; Pointer to SMT context */ | ||
221 | /* int reconn_time; Wait for reconnect time in seconds */ | ||
222 | { | ||
223 | /* | ||
224 | * The please reconnect variable is used as a timer. | ||
225 | * It is decremented each time smt_event is called. | ||
226 | * This happens every second or when smt_force_irq is called. | ||
227 | * Note: smt_force_irq () is called on some packet receives and | ||
228 | * when a multicast address is changed. Since nothing | ||
229 | * is received during the disconnect and the multicast | ||
230 | * address changes can be viewed as not very often and | ||
231 | * the timer runs out close to its given value | ||
232 | * (reconn_time). | ||
233 | */ | ||
234 | smc->sm.please_reconnect = reconn_time ; | ||
235 | } | ||
236 | |||
237 | #ifndef SMT_REAL_TOKEN_CT | 219 | #ifndef SMT_REAL_TOKEN_CT |
238 | void smt_emulate_token_ct(struct s_smc *smc, int mac_index) | 220 | void smt_emulate_token_ct(struct s_smc *smc, int mac_index) |
239 | { | 221 | { |
@@ -1574,7 +1556,7 @@ static void smt_fill_echo(struct s_smc *smc, struct smt_p_echo *echo, u_long see | |||
1574 | * clear DNA and UNA | 1556 | * clear DNA and UNA |
1575 | * called from CFM if configuration changes | 1557 | * called from CFM if configuration changes |
1576 | */ | 1558 | */ |
1577 | void smt_clear_una_dna(struct s_smc *smc) | 1559 | static void smt_clear_una_dna(struct s_smc *smc) |
1578 | { | 1560 | { |
1579 | smc->mib.m[MAC0].fddiMACUpstreamNbr = SMT_Unknown ; | 1561 | smc->mib.m[MAC0].fddiMACUpstreamNbr = SMT_Unknown ; |
1580 | smc->mib.m[MAC0].fddiMACDownstreamNbr = SMT_Unknown ; | 1562 | smc->mib.m[MAC0].fddiMACDownstreamNbr = SMT_Unknown ; |
@@ -2058,30 +2040,10 @@ int smt_action(struct s_smc *smc, int class, int code, int index) | |||
2058 | } | 2040 | } |
2059 | 2041 | ||
2060 | /* | 2042 | /* |
2061 | * change tneg | ||
2062 | * set T_Req in MIB (Path Attribute) | ||
2063 | * calculate new values for MAC | ||
2064 | * if change required | ||
2065 | * disconnect | ||
2066 | * set reconnect | ||
2067 | * end | ||
2068 | */ | ||
2069 | void smt_change_t_neg(struct s_smc *smc, u_long tneg) | ||
2070 | { | ||
2071 | smc->mib.a[PATH0].fddiPATHMaxT_Req = tneg ; | ||
2072 | |||
2073 | if (smt_set_mac_opvalues(smc)) { | ||
2074 | RS_SET(smc,RS_EVENT) ; | ||
2075 | smc->sm.please_reconnect = 1 ; | ||
2076 | queue_event(smc,EVENT_ECM,EC_DISCONNECT) ; | ||
2077 | } | ||
2078 | } | ||
2079 | |||
2080 | /* | ||
2081 | * canonical conversion of <len> bytes beginning form *data | 2043 | * canonical conversion of <len> bytes beginning form *data |
2082 | */ | 2044 | */ |
2083 | #ifdef USE_CAN_ADDR | 2045 | #ifdef USE_CAN_ADDR |
2084 | void hwm_conv_can(struct s_smc *smc, char *data, int len) | 2046 | static void hwm_conv_can(struct s_smc *smc, char *data, int len) |
2085 | { | 2047 | { |
2086 | int i ; | 2048 | int i ; |
2087 | 2049 | ||
diff --git a/drivers/net/skfp/smtdef.c b/drivers/net/skfp/smtdef.c index 5a0c8db816d8..4e07ff7073f1 100644 --- a/drivers/net/skfp/smtdef.c +++ b/drivers/net/skfp/smtdef.c | |||
@@ -76,11 +76,6 @@ void smt_reset_defaults(struct s_smc *smc, int level); | |||
76 | static void smt_init_mib(struct s_smc *smc, int level); | 76 | static void smt_init_mib(struct s_smc *smc, int level); |
77 | static int set_min_max(int maxflag, u_long mib, u_long limit, u_long *oper); | 77 | static int set_min_max(int maxflag, u_long mib, u_long limit, u_long *oper); |
78 | 78 | ||
79 | void smt_set_defaults(struct s_smc *smc) | ||
80 | { | ||
81 | smt_reset_defaults(smc,0) ; | ||
82 | } | ||
83 | |||
84 | #define MS2BCLK(x) ((x)*12500L) | 79 | #define MS2BCLK(x) ((x)*12500L) |
85 | #define US2BCLK(x) ((x)*1250L) | 80 | #define US2BCLK(x) ((x)*1250L) |
86 | 81 | ||
diff --git a/drivers/net/skfp/smtparse.c b/drivers/net/skfp/smtparse.c deleted file mode 100644 index d5779e414dbe..000000000000 --- a/drivers/net/skfp/smtparse.c +++ /dev/null | |||
@@ -1,467 +0,0 @@ | |||
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 | /* | ||
19 | parser for SMT parameters | ||
20 | */ | ||
21 | |||
22 | #include "h/types.h" | ||
23 | #include "h/fddi.h" | ||
24 | #include "h/smc.h" | ||
25 | #include "h/smt_p.h" | ||
26 | |||
27 | #define KERNEL | ||
28 | #include "h/smtstate.h" | ||
29 | |||
30 | #ifndef lint | ||
31 | static const char ID_sccs[] = "@(#)smtparse.c 1.12 98/10/06 (C) SK " ; | ||
32 | #endif | ||
33 | |||
34 | #ifdef sun | ||
35 | #define _far | ||
36 | #endif | ||
37 | |||
38 | /* | ||
39 | * convert to BCLK units | ||
40 | */ | ||
41 | #define MS2BCLK(x) ((x)*12500L) | ||
42 | #define US2BCLK(x) ((x/10)*125L) | ||
43 | |||
44 | /* | ||
45 | * parameter table | ||
46 | */ | ||
47 | static struct s_ptab { | ||
48 | char *pt_name ; | ||
49 | u_short pt_num ; | ||
50 | u_short pt_type ; | ||
51 | u_long pt_min ; | ||
52 | u_long pt_max ; | ||
53 | } ptab[] = { | ||
54 | { "PMFPASSWD",0, 0 } , | ||
55 | { "USERDATA",1, 0 } , | ||
56 | { "LERCUTOFFA",2, 1, 4, 15 } , | ||
57 | { "LERCUTOFFB",3, 1, 4, 15 } , | ||
58 | { "LERALARMA",4, 1, 4, 15 } , | ||
59 | { "LERALARMB",5, 1, 4, 15 } , | ||
60 | { "TMAX",6, 1, 5, 165 } , | ||
61 | { "TMIN",7, 1, 5, 165 } , | ||
62 | { "TREQ",8, 1, 5, 165 } , | ||
63 | { "TVX",9, 1, 2500, 10000 } , | ||
64 | #ifdef ESS | ||
65 | { "SBAPAYLOAD",10, 1, 0, 1562 } , | ||
66 | { "SBAOVERHEAD",11, 1, 50, 5000 } , | ||
67 | { "MAXTNEG",12, 1, 5, 165 } , | ||
68 | { "MINSEGMENTSIZE",13, 1, 0, 4478 } , | ||
69 | { "SBACATEGORY",14, 1, 0, 0xffff } , | ||
70 | { "SYNCHTXMODE",15, 0 } , | ||
71 | #endif | ||
72 | #ifdef SBA | ||
73 | { "SBACOMMAND",16, 0 } , | ||
74 | { "SBAAVAILABLE",17, 1, 0, 100 } , | ||
75 | #endif | ||
76 | { NULL } | ||
77 | } ; | ||
78 | |||
79 | /* Define maximum string size for values and keybuffer */ | ||
80 | #define MAX_VAL 40 | ||
81 | |||
82 | /* | ||
83 | * local function declarations | ||
84 | */ | ||
85 | static u_long parse_num(int type, char _far *value, char *v, u_long mn, | ||
86 | u_long mx, int scale); | ||
87 | static int parse_word(char *buf, char _far *text); | ||
88 | |||
89 | #ifdef SIM | ||
90 | #define DB_MAIN(a,b,c) printf(a,b,c) | ||
91 | #else | ||
92 | #define DB_MAIN(a,b,c) | ||
93 | #endif | ||
94 | |||
95 | /* | ||
96 | * BEGIN_MANUAL_ENTRY() | ||
97 | * | ||
98 | * int smt_parse_arg(struct s_smc *,char _far *keyword,int type, | ||
99 | char _far *value) | ||
100 | * | ||
101 | * parse SMT parameter | ||
102 | * *keyword | ||
103 | * pointer to keyword, must be \0, \n or \r terminated | ||
104 | * *value pointer to value, either char * or u_long * | ||
105 | * if char * | ||
106 | * pointer to value, must be \0, \n or \r terminated | ||
107 | * if u_long * | ||
108 | * contains binary value | ||
109 | * | ||
110 | * type 0: integer | ||
111 | * 1: string | ||
112 | * return | ||
113 | * 0 parameter parsed ok | ||
114 | * != 0 error | ||
115 | * NOTE: | ||
116 | * function can be called with DS != SS | ||
117 | * | ||
118 | * | ||
119 | * END_MANUAL_ENTRY() | ||
120 | */ | ||
121 | int smt_parse_arg(struct s_smc *smc, char _far *keyword, int type, | ||
122 | char _far *value) | ||
123 | { | ||
124 | char keybuf[MAX_VAL+1]; | ||
125 | char valbuf[MAX_VAL+1]; | ||
126 | char c ; | ||
127 | char *p ; | ||
128 | char *v ; | ||
129 | char *d ; | ||
130 | u_long val = 0 ; | ||
131 | struct s_ptab *pt ; | ||
132 | int st ; | ||
133 | int i ; | ||
134 | |||
135 | /* | ||
136 | * parse keyword | ||
137 | */ | ||
138 | if ((st = parse_word(keybuf,keyword))) | ||
139 | return(st) ; | ||
140 | /* | ||
141 | * parse value if given as string | ||
142 | */ | ||
143 | if (type == 1) { | ||
144 | if ((st = parse_word(valbuf,value))) | ||
145 | return(st) ; | ||
146 | } | ||
147 | /* | ||
148 | * search in table | ||
149 | */ | ||
150 | st = 0 ; | ||
151 | for (pt = ptab ; (v = pt->pt_name) ; pt++) { | ||
152 | for (p = keybuf ; (c = *p) ; p++,v++) { | ||
153 | if (c != *v) | ||
154 | break ; | ||
155 | } | ||
156 | if (!c && !*v) | ||
157 | break ; | ||
158 | } | ||
159 | if (!v) | ||
160 | return(-1) ; | ||
161 | #if 0 | ||
162 | printf("=>%s<==>%s<=\n",pt->pt_name,valbuf) ; | ||
163 | #endif | ||
164 | /* | ||
165 | * set value in MIB | ||
166 | */ | ||
167 | if (pt->pt_type) | ||
168 | val = parse_num(type,value,valbuf,pt->pt_min,pt->pt_max,1) ; | ||
169 | switch (pt->pt_num) { | ||
170 | case 0 : | ||
171 | v = valbuf ; | ||
172 | d = (char *) smc->mib.fddiPRPMFPasswd ; | ||
173 | for (i = 0 ; i < (signed)sizeof(smc->mib.fddiPRPMFPasswd) ; i++) | ||
174 | *d++ = *v++ ; | ||
175 | DB_MAIN("SET %s = %s\n",pt->pt_name,smc->mib.fddiPRPMFPasswd) ; | ||
176 | break ; | ||
177 | case 1 : | ||
178 | v = valbuf ; | ||
179 | d = (char *) smc->mib.fddiSMTUserData ; | ||
180 | for (i = 0 ; i < (signed)sizeof(smc->mib.fddiSMTUserData) ; i++) | ||
181 | *d++ = *v++ ; | ||
182 | DB_MAIN("SET %s = %s\n",pt->pt_name,smc->mib.fddiSMTUserData) ; | ||
183 | break ; | ||
184 | case 2 : | ||
185 | smc->mib.p[PA].fddiPORTLer_Cutoff = (u_char) val ; | ||
186 | DB_MAIN("SET %s = %d\n", | ||
187 | pt->pt_name,smc->mib.p[PA].fddiPORTLer_Cutoff) ; | ||
188 | break ; | ||
189 | case 3 : | ||
190 | smc->mib.p[PB].fddiPORTLer_Cutoff = (u_char) val ; | ||
191 | DB_MAIN("SET %s = %d\n", | ||
192 | pt->pt_name,smc->mib.p[PB].fddiPORTLer_Cutoff) ; | ||
193 | break ; | ||
194 | case 4 : | ||
195 | smc->mib.p[PA].fddiPORTLer_Alarm = (u_char) val ; | ||
196 | DB_MAIN("SET %s = %d\n", | ||
197 | pt->pt_name,smc->mib.p[PA].fddiPORTLer_Alarm) ; | ||
198 | break ; | ||
199 | case 5 : | ||
200 | smc->mib.p[PB].fddiPORTLer_Alarm = (u_char) val ; | ||
201 | DB_MAIN("SET %s = %d\n", | ||
202 | pt->pt_name,smc->mib.p[PB].fddiPORTLer_Alarm) ; | ||
203 | break ; | ||
204 | case 6 : /* TMAX */ | ||
205 | DB_MAIN("SET %s = %d\n",pt->pt_name,val) ; | ||
206 | smc->mib.a[PATH0].fddiPATHT_MaxLowerBound = | ||
207 | (u_long) -MS2BCLK((long)val) ; | ||
208 | break ; | ||
209 | case 7 : /* TMIN */ | ||
210 | DB_MAIN("SET %s = %d\n",pt->pt_name,val) ; | ||
211 | smc->mib.m[MAC0].fddiMACT_Min = | ||
212 | (u_long) -MS2BCLK((long)val) ; | ||
213 | break ; | ||
214 | case 8 : /* TREQ */ | ||
215 | DB_MAIN("SET %s = %d\n",pt->pt_name,val) ; | ||
216 | smc->mib.a[PATH0].fddiPATHMaxT_Req = | ||
217 | (u_long) -MS2BCLK((long)val) ; | ||
218 | break ; | ||
219 | case 9 : /* TVX */ | ||
220 | DB_MAIN("SET %s = %d \n",pt->pt_name,val) ; | ||
221 | smc->mib.a[PATH0].fddiPATHTVXLowerBound = | ||
222 | (u_long) -US2BCLK((long)val) ; | ||
223 | break ; | ||
224 | #ifdef ESS | ||
225 | case 10 : /* SBAPAYLOAD */ | ||
226 | DB_MAIN("SET %s = %d\n",pt->pt_name,val) ; | ||
227 | if (smc->mib.fddiESSPayload != val) { | ||
228 | smc->ess.raf_act_timer_poll = TRUE ; | ||
229 | smc->mib.fddiESSPayload = val ; | ||
230 | } | ||
231 | break ; | ||
232 | case 11 : /* SBAOVERHEAD */ | ||
233 | DB_MAIN("SET %s = %d\n",pt->pt_name,val) ; | ||
234 | smc->mib.fddiESSOverhead = val ; | ||
235 | break ; | ||
236 | case 12 : /* MAXTNEG */ | ||
237 | DB_MAIN("SET %s = %d\n",pt->pt_name,val) ; | ||
238 | smc->mib.fddiESSMaxTNeg = (u_long) -MS2BCLK((long)val) ; | ||
239 | break ; | ||
240 | case 13 : /* MINSEGMENTSIZE */ | ||
241 | DB_MAIN("SET %s = %d\n",pt->pt_name,val) ; | ||
242 | smc->mib.fddiESSMinSegmentSize = val ; | ||
243 | break ; | ||
244 | case 14 : /* SBACATEGORY */ | ||
245 | DB_MAIN("SET %s = %d\n",pt->pt_name,val) ; | ||
246 | smc->mib.fddiESSCategory = | ||
247 | (smc->mib.fddiESSCategory & 0xffff) | | ||
248 | ((u_long)(val << 16)) ; | ||
249 | break ; | ||
250 | case 15 : /* SYNCHTXMODE */ | ||
251 | /* do not use memcmp(valbuf,"ALL",3) because DS != SS */ | ||
252 | if (valbuf[0] == 'A' && valbuf[1] == 'L' && valbuf[2] == 'L') { | ||
253 | smc->mib.fddiESSSynchTxMode = TRUE ; | ||
254 | DB_MAIN("SET %s = %s\n",pt->pt_name,valbuf) ; | ||
255 | } | ||
256 | /* if (!memcmp(valbuf,"SPLIT",5)) { */ | ||
257 | if (valbuf[0] == 'S' && valbuf[1] == 'P' && valbuf[2] == 'L' && | ||
258 | valbuf[3] == 'I' && valbuf[4] == 'T') { | ||
259 | DB_MAIN("SET %s = %s\n",pt->pt_name,valbuf) ; | ||
260 | smc->mib.fddiESSSynchTxMode = FALSE ; | ||
261 | } | ||
262 | break ; | ||
263 | #endif | ||
264 | #ifdef SBA | ||
265 | case 16 : /* SBACOMMAND */ | ||
266 | /* if (!memcmp(valbuf,"START",5)) { */ | ||
267 | if (valbuf[0] == 'S' && valbuf[1] == 'T' && valbuf[2] == 'A' && | ||
268 | valbuf[3] == 'R' && valbuf[4] == 'T') { | ||
269 | DB_MAIN("SET %s = %s\n",pt->pt_name,valbuf) ; | ||
270 | smc->mib.fddiSBACommand = SB_START ; | ||
271 | } | ||
272 | /* if (!memcmp(valbuf,"STOP",4)) { */ | ||
273 | if (valbuf[0] == 'S' && valbuf[1] == 'T' && valbuf[2] == 'O' && | ||
274 | valbuf[3] == 'P') { | ||
275 | DB_MAIN("SET %s = %s\n",pt->pt_name,valbuf) ; | ||
276 | smc->mib.fddiSBACommand = SB_STOP ; | ||
277 | } | ||
278 | break ; | ||
279 | case 17 : /* SBAAVAILABLE */ | ||
280 | DB_MAIN("SET %s = %d\n",pt->pt_name,val) ; | ||
281 | smc->mib.fddiSBAAvailable = (u_char) val ; | ||
282 | break ; | ||
283 | #endif | ||
284 | } | ||
285 | return(0) ; | ||
286 | } | ||
287 | |||
288 | static int parse_word(char *buf, char _far *text) | ||
289 | { | ||
290 | char c ; | ||
291 | char *p ; | ||
292 | int p_len ; | ||
293 | int quote ; | ||
294 | int i ; | ||
295 | int ok ; | ||
296 | |||
297 | /* | ||
298 | * skip leading white space | ||
299 | */ | ||
300 | p = buf ; | ||
301 | for (i = 0 ; i < MAX_VAL ; i++) | ||
302 | *p++ = 0 ; | ||
303 | p = buf ; | ||
304 | p_len = 0 ; | ||
305 | ok = 0 ; | ||
306 | while ( (c = *text++) && (c != '\n') && (c != '\r')) { | ||
307 | if ((c != ' ') && (c != '\t')) { | ||
308 | ok = 1 ; | ||
309 | break ; | ||
310 | } | ||
311 | } | ||
312 | if (!ok) | ||
313 | return(-1) ; | ||
314 | if (c == '"') { | ||
315 | quote = 1 ; | ||
316 | } | ||
317 | else { | ||
318 | quote = 0 ; | ||
319 | text-- ; | ||
320 | } | ||
321 | /* | ||
322 | * parse valbuf | ||
323 | */ | ||
324 | ok = 0 ; | ||
325 | while (!ok && p_len < MAX_VAL-1 && (c = *text++) && (c != '\n') | ||
326 | && (c != '\r')) { | ||
327 | switch (quote) { | ||
328 | case 0 : | ||
329 | if ((c == ' ') || (c == '\t') || (c == '=')) { | ||
330 | ok = 1 ; | ||
331 | break ; | ||
332 | } | ||
333 | *p++ = c ; | ||
334 | p_len++ ; | ||
335 | break ; | ||
336 | case 2 : | ||
337 | *p++ = c ; | ||
338 | p_len++ ; | ||
339 | quote = 1 ; | ||
340 | break ; | ||
341 | case 1 : | ||
342 | switch (c) { | ||
343 | case '"' : | ||
344 | ok = 1 ; | ||
345 | break ; | ||
346 | case '\\' : | ||
347 | quote = 2 ; | ||
348 | break ; | ||
349 | default : | ||
350 | *p++ = c ; | ||
351 | p_len++ ; | ||
352 | } | ||
353 | } | ||
354 | } | ||
355 | *p++ = 0 ; | ||
356 | for (p = buf ; (c = *p) ; p++) { | ||
357 | if (c >= 'a' && c <= 'z') | ||
358 | *p = c + 'A' - 'a' ; | ||
359 | } | ||
360 | return(0) ; | ||
361 | } | ||
362 | |||
363 | static u_long parse_num(int type, char _far *value, char *v, u_long mn, | ||
364 | u_long mx, int scale) | ||
365 | { | ||
366 | u_long x = 0 ; | ||
367 | char c ; | ||
368 | |||
369 | if (type == 0) { /* integer */ | ||
370 | u_long _far *l ; | ||
371 | u_long u1 ; | ||
372 | |||
373 | l = (u_long _far *) value ; | ||
374 | u1 = *l ; | ||
375 | /* | ||
376 | * if the value is negative take the lower limit | ||
377 | */ | ||
378 | if ((long)u1 < 0) { | ||
379 | if (- ((long)u1) > (long) mx) { | ||
380 | u1 = 0 ; | ||
381 | } | ||
382 | else { | ||
383 | u1 = (u_long) - ((long)u1) ; | ||
384 | } | ||
385 | } | ||
386 | x = u1 ; | ||
387 | } | ||
388 | else { /* string */ | ||
389 | int sign = 0 ; | ||
390 | |||
391 | if (*v == '-') { | ||
392 | sign = 1 ; | ||
393 | } | ||
394 | while ((c = *v++) && (c >= '0') && (c <= '9')) { | ||
395 | x = x * 10 + c - '0' ; | ||
396 | } | ||
397 | if (scale == 10) { | ||
398 | x *= 10 ; | ||
399 | if (c == '.') { | ||
400 | if ((c = *v++) && (c >= '0') && (c <= '9')) { | ||
401 | x += c - '0' ; | ||
402 | } | ||
403 | } | ||
404 | } | ||
405 | if (sign) | ||
406 | x = (u_long) - ((long)x) ; | ||
407 | } | ||
408 | /* | ||
409 | * if the value is negative | ||
410 | * and the absolute value is outside the limits | ||
411 | * take the lower limit | ||
412 | * else | ||
413 | * take the absoute value | ||
414 | */ | ||
415 | if ((long)x < 0) { | ||
416 | if (- ((long)x) > (long) mx) { | ||
417 | x = 0 ; | ||
418 | } | ||
419 | else { | ||
420 | x = (u_long) - ((long)x) ; | ||
421 | } | ||
422 | } | ||
423 | if (x < mn) | ||
424 | return(mn) ; | ||
425 | else if (x > mx) | ||
426 | return(mx) ; | ||
427 | return(x) ; | ||
428 | } | ||
429 | |||
430 | #if 0 | ||
431 | struct s_smc SMC ; | ||
432 | main() | ||
433 | { | ||
434 | char *p ; | ||
435 | char *v ; | ||
436 | char buf[100] ; | ||
437 | int toggle = 0 ; | ||
438 | |||
439 | while (gets(buf)) { | ||
440 | p = buf ; | ||
441 | while (*p && ((*p == ' ') || (*p == '\t'))) | ||
442 | p++ ; | ||
443 | |||
444 | while (*p && ((*p != ' ') && (*p != '\t'))) | ||
445 | p++ ; | ||
446 | |||
447 | v = p ; | ||
448 | while (*v && ((*v == ' ') || (*v == '\t'))) | ||
449 | v++ ; | ||
450 | if ((*v >= '0') && (*v <= '9')) { | ||
451 | toggle = !toggle ; | ||
452 | if (toggle) { | ||
453 | u_long l ; | ||
454 | l = atol(v) ; | ||
455 | smt_parse_arg(&SMC,buf,0,(char _far *)&l) ; | ||
456 | } | ||
457 | else | ||
458 | smt_parse_arg(&SMC,buf,1,(char _far *)p) ; | ||
459 | } | ||
460 | else { | ||
461 | smt_parse_arg(&SMC,buf,1,(char _far *)p) ; | ||
462 | } | ||
463 | } | ||
464 | exit(0) ; | ||
465 | } | ||
466 | #endif | ||
467 | |||