// SPDX-License-Identifier: GPL-2.0-or-later /****************************************************************************** * * (C)Copyright 1998,1999 SysKonnect, * a business unit of Schneider & Koch & Co. Datensysteme GmbH. * * See the file "skfddi.c" for further information. * * The information in this file is provided "AS IS" without warranty. * ******************************************************************************/ /* * FORMAC+ Driver for tag mode */ #include "h/types.h" #include "h/fddi.h" #include "h/smc.h" #include "h/supern_2.h" #include <linux/bitrev.h> #include <linux/etherdevice.h> #ifndef UNUSED #ifdef lint #define UNUSED … #else #define UNUSED(x) … #endif #endif #define FM_ADDRX … #define MS2BCLK(x) … #define US2BCLK(x) … /* * prototypes for static function */ static void build_claim_beacon(struct s_smc *smc, u_long t_request); static int init_mac(struct s_smc *smc, int all); static void rtm_init(struct s_smc *smc); static void smt_split_up_fifo(struct s_smc *smc); #if (!defined(NO_SMT_PANIC) || defined(DEBUG)) static char write_mdr_warning [] = …; static char cam_warning [] = …; #endif #define DUMMY_READ() … #define CHECK_NPP() … #define CHECK_CAM() … const struct fddi_addr fddi_broadcast = …; static const struct fddi_addr null_addr = …; static const struct fddi_addr dbeacon_multi = …; static const u_short my_said = … ; /* short address (n.u.) */ static const u_short my_sagp = … ; /* short group address (n.u.) */ /* * define my address */ #ifdef USE_CAN_ADDR #define MA … #else #define MA … #endif /* * useful interrupt bits */ static const int mac_imsk1u = … ; static const int mac_imsk1l = … ; /* delete FM_SRBFL after tests */ static const int mac_imsk2u = … ; static const int mac_imsk2l = … ; static const int mac_imsk3u = … ; static const int mac_imsk3l = … ; static const int mac_beacon_imsk2u = … ; static u_long mac_get_tneg(struct s_smc *smc) { … } void mac_update_counter(struct s_smc *smc) { … } /* * write long value into buffer memory over memory data register (MDR), */ static void write_mdr(struct s_smc *smc, u_long val) { … } #if 0 /* * read long value from buffer memory over memory data register (MDR), */ static u_long read_mdr(struct s_smc *smc, unsigned int addr) { long p ; CHECK_NPP() ; MARR(addr) ; outpw(FM_A(FM_CMDREG1),FM_IRMEMWO) ; CHECK_NPP() ; /* needed for PCI to prevent from timeing violations */ /* p = MDRR() ; */ /* bad read values if the workaround */ /* smc->hw.mc_dummy = *((short volatile far *)(addr)))*/ /* is used */ p = (u_long)inpw(FM_A(FM_MDRU))<<16 ; p += (u_long)inpw(FM_A(FM_MDRL)) ; return p; } #endif /* * clear buffer memory */ static void init_ram(struct s_smc *smc) { … } /* * set receive FIFO pointer */ static void set_recvptr(struct s_smc *smc) { … } /* * set transmit FIFO pointer */ static void set_txptr(struct s_smc *smc) { … } /* * init memory buffer management registers */ static void init_rbc(struct s_smc *smc) { … } /* * init rx pointer */ static void init_rx(struct s_smc *smc) { … } /* * set the TSYNC register of the FORMAC to regulate synchronous transmission */ void set_formac_tsync(struct s_smc *smc, long sync_bw) { … } /* * init all tx data structures */ static void init_tx(struct s_smc *smc) { … } static void mac_counter_init(struct s_smc *smc) { … } /* * set FORMAC address, and t_request */ static void set_formac_addr(struct s_smc *smc) { … } static void set_int(char *p, int l) { … } /* * copy TX descriptor to buffer mem * append FC field and MAC frame * if more bit is set in descr * append pointer to descriptor (endless loop) * else * append 'end of chain' pointer */ static void copy_tx_mac(struct s_smc *smc, u_long td, struct fddi_mac *mac, unsigned int off, int len) /* u_long td; transmit descriptor */ /* struct fddi_mac *mac; mac frame pointer */ /* unsigned int off; start address within buffer memory */ /* int len ; length of the frame including the FC */ { … } /* BEGIN_MANUAL_ENTRY(module;tests;3) How to test directed beacon frames ---------------------------------------------------------------- o Insert a break point in the function build_claim_beacon() before calling copy_tx_mac() for building the claim frame. o Modify the RM3_DETECT case so that the RM6_DETECT state will always entered from the RM3_DETECT state (function rmt_fsm(), rmt.c) o Compile the driver. o Set the parameter TREQ in the protocol.ini or net.cfg to a small value to make sure your station will win the claim process. o Start the driver. o When you reach the break point, modify the SA and DA address of the claim frame (e.g. SA = DA = 10005affffff). o When you see RM3_DETECT and RM6_DETECT, observe the direct beacon frames on the UPPSLANA. END_MANUAL_ENTRY */ static void directed_beacon(struct s_smc *smc) { … } /* setup claim & beacon pointer NOTE : special frame packets end with a pointer to their own descriptor, and the MORE bit is set in the descriptor */ static void build_claim_beacon(struct s_smc *smc, u_long t_request) { … } static void formac_rcv_restart(struct s_smc *smc) { … } void formac_tx_restart(struct s_smc *smc) { … } static void enable_formac(struct s_smc *smc) { … } #if 0 /* Removed because the driver should use the ASICs TX complete IRQ. */ /* The FORMACs tx complete IRQ should be used any longer */ /* BEGIN_MANUAL_ENTRY(if,func;others;4) void enable_tx_irq(smc, queue) struct s_smc *smc ; u_short queue ; Function DOWNCALL (SMT, fplustm.c) enable_tx_irq() enables the FORMACs transmit complete interrupt of the queue. Para queue = QUEUE_S: synchronous queue = QUEUE_A0: asynchronous queue Note After any ring operational change the transmit complete interrupts are disabled. The operating system dependent module must enable the transmit complete interrupt of a queue, - when it queues the first frame, because of no transmit resources are beeing available and - when it escapes from the function llc_restart_tx while some frames are still queued. END_MANUAL_ENTRY */ void enable_tx_irq(struct s_smc *smc, u_short queue) /* u_short queue; 0 = synchronous queue, 1 = asynchronous queue 0 */ { u_short imask ; imask = ~(inpw(FM_A(FM_IMSK1U))) ; if (queue == 0) { outpw(FM_A(FM_IMSK1U),~(imask|FM_STEFRMS)) ; } if (queue == 1) { outpw(FM_A(FM_IMSK1U),~(imask|FM_STEFRMA0)) ; } } /* BEGIN_MANUAL_ENTRY(if,func;others;4) void disable_tx_irq(smc, queue) struct s_smc *smc ; u_short queue ; Function DOWNCALL (SMT, fplustm.c) disable_tx_irq disables the FORMACs transmit complete interrupt of the queue Para queue = QUEUE_S: synchronous queue = QUEUE_A0: asynchronous queue Note The operating system dependent module should disable the transmit complete interrupts if it escapes from the function llc_restart_tx and no frames are queued. END_MANUAL_ENTRY */ void disable_tx_irq(struct s_smc *smc, u_short queue) /* u_short queue; 0 = synchronous queue, 1 = asynchronous queue 0 */ { u_short imask ; imask = ~(inpw(FM_A(FM_IMSK1U))) ; if (queue == 0) { outpw(FM_A(FM_IMSK1U),~(imask&~FM_STEFRMS)) ; } if (queue == 1) { outpw(FM_A(FM_IMSK1U),~(imask&~FM_STEFRMA0)) ; } } #endif static void disable_formac(struct s_smc *smc) { … } static void mac_ring_up(struct s_smc *smc, int up) { … } /*--------------------------- ISR handling ----------------------------------*/ /* * mac1_irq is in drvfbi.c */ /* * mac2_irq: status bits for the receive queue 1, and ring status * ring status indication bits */ void mac2_irq(struct s_smc *smc, u_short code_s2u, u_short code_s2l) { … } /* * mac3_irq: receive queue 2 bits and address detection bits */ void mac3_irq(struct s_smc *smc, u_short code_s3u, u_short code_s3l) { … } /* * take formac offline */ static void formac_offline(struct s_smc *smc) { … } /* * bring formac online */ static void formac_online(struct s_smc *smc) { … } /* * FORMAC+ full init. (tx, rx, timer, counter, claim & beacon) */ int init_fplus(struct s_smc *smc) { … } static int init_mac(struct s_smc *smc, int all) { … } /* * called by CFM */ void config_mux(struct s_smc *smc, int mux) { … } /* * called by RMT * enable CLAIM/BEACON interrupts * (only called if these events are of interest, e.g. in DETECT state * the interrupt must not be permanently enabled * RMT calls this function periodically (timer driven polling) */ void sm_mac_check_beacon_claim(struct s_smc *smc) { … } /*-------------------------- interface functions ----------------------------*/ /* * control MAC layer (called by RMT) */ void sm_ma_control(struct s_smc *smc, int mode) { … } int sm_mac_get_tx_state(struct s_smc *smc) { … } /* * multicast functions */ static struct s_fpmc* mac_get_mc_table(struct s_smc *smc, struct fddi_addr *user, struct fddi_addr *own, int del, int can) { … } /* BEGIN_MANUAL_ENTRY(if,func;others;2) void mac_clear_multicast(smc) struct s_smc *smc ; Function DOWNCALL (SMT, fplustm.c) Clear all multicast entries END_MANUAL_ENTRY() */ void mac_clear_multicast(struct s_smc *smc) { … } /* BEGIN_MANUAL_ENTRY(if,func;others;2) int mac_add_multicast(smc,addr,can) struct s_smc *smc ; struct fddi_addr *addr ; int can ; Function DOWNCALL (SMC, fplustm.c) Add an entry to the multicast table Para addr pointer to a multicast address can = 0: the multicast address has the physical format = 1: the multicast address has the canonical format | 0x80 permanent Returns 0: success 1: address table full Note After a 'driver reset' or a 'station set address' all entries of the multicast table are cleared. In this case the driver has to fill the multicast table again. After the operating system dependent module filled the multicast table it must call mac_update_multicast to activate the new multicast addresses! END_MANUAL_ENTRY() */ int mac_add_multicast(struct s_smc *smc, struct fddi_addr *addr, int can) { … } /* * mode */ #define RX_MODE_PROM … #define RX_MODE_ALL_MULTI … /* BEGIN_MANUAL_ENTRY(if,func;others;2) void mac_update_multicast(smc) struct s_smc *smc ; Function DOWNCALL (SMT, fplustm.c) Update FORMAC multicast registers END_MANUAL_ENTRY() */ void mac_update_multicast(struct s_smc *smc) { … } /* BEGIN_MANUAL_ENTRY(if,func;others;3) void mac_set_rx_mode(smc,mode) struct s_smc *smc ; int mode ; Function DOWNCALL/INTERN (SMT, fplustm.c) This function enables / disables the selected receive. Don't call this function if the hardware module is used -- use mac_drv_rx_mode() instead of. Para mode = 1 RX_ENABLE_ALLMULTI enable all multicasts 2 RX_DISABLE_ALLMULTI disable "enable all multicasts" 3 RX_ENABLE_PROMISC enable promiscuous 4 RX_DISABLE_PROMISC disable promiscuous 5 RX_ENABLE_NSA enable reception of NSA frames 6 RX_DISABLE_NSA disable reception of NSA frames Note The selected receive modes will be lost after 'driver reset' or 'set station address' END_MANUAL_ENTRY */ void mac_set_rx_mode(struct s_smc *smc, int mode) { … } /* BEGIN_MANUAL_ENTRY(module;tests;3) How to test the Restricted Token Monitor ---------------------------------------------------------------- o Insert a break point in the function rtm_irq() o Remove all stations with a restricted token monitor from the network. o Connect a UPPS ISA or EISA station to the network. o Give the FORMAC of UPPS station the command to send restricted tokens until the ring becomes instable. o Now connect your test client. o The restricted token monitor should detect the restricted token, and your break point will be reached. o You can ovserve how the station will clean the ring. END_MANUAL_ENTRY */ void rtm_irq(struct s_smc *smc) { … } static void rtm_init(struct s_smc *smc) { … } void rtm_set_timer(struct s_smc *smc) { … } static void smt_split_up_fifo(struct s_smc *smc) { … } void formac_reinit_tx(struct s_smc *smc) { … }
Codebase Browser
linux