← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise-security

« back to all changes in this revision

Viewing changes to drivers/net/skfp/smt.c

  • Committer: Package Import Robot
  • Author(s): Paolo Pisati, Paolo Pisati
  • Date: 2011-12-06 15:56:07 UTC
  • Revision ID: package-import@ubuntu.com-20111206155607-pcf44kv5fmhk564f
Tags: 3.2.0-1401.1
[ Paolo Pisati ]

* Rebased on top of Ubuntu-3.2.0-3.8
* Tilt-tracking @ ef2487af4bb15bdd0689631774b5a5e3a59f74e2
* Delete debian.ti-omap4/control, it shoudln't be tracked
* Fix architecture spelling (s/armel/armhf/)
* [Config] Update configs following 3.2 import
* [Config] Fix compilation: disable CODA and ARCH_OMAP3
* [Config] Fix compilation: disable Ethernet Faraday
* Update series to precise

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/net/skfp/smt.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
 
#include "h/types.h"
18
 
#include "h/fddi.h"
19
 
#include "h/smc.h"
20
 
#include "h/smt_p.h"
21
 
#include <linux/bitrev.h>
22
 
#include <linux/kernel.h>
23
 
 
24
 
#define KERNEL
25
 
#include "h/smtstate.h"
26
 
 
27
 
#ifndef lint
28
 
static const char ID_sccs[] = "@(#)smt.c        2.43 98/11/23 (C) SK " ;
29
 
#endif
30
 
 
31
 
/*
32
 
 * FC in SMbuf
33
 
 */
34
 
#define m_fc(mb)        ((mb)->sm_data[0])
35
 
 
36
 
#define SMT_TID_MAGIC   0x1f0a7b3c
37
 
 
38
 
#ifdef  DEBUG
39
 
static const char *const smt_type_name[] = {
40
 
        "SMT_00??", "SMT_INFO", "SMT_02??", "SMT_03??",
41
 
        "SMT_04??", "SMT_05??", "SMT_06??", "SMT_07??",
42
 
        "SMT_08??", "SMT_09??", "SMT_0A??", "SMT_0B??",
43
 
        "SMT_0C??", "SMT_0D??", "SMT_0E??", "SMT_NSA"
44
 
} ;
45
 
 
46
 
static const char *const smt_class_name[] = {
47
 
        "UNKNOWN","NIF","SIF_CONFIG","SIF_OPER","ECF","RAF","RDF",
48
 
        "SRF","PMF_GET","PMF_SET","ESF"
49
 
} ;
50
 
#endif
51
 
#define LAST_CLASS      (SMT_PMF_SET)
52
 
 
53
 
static const struct fddi_addr SMT_Unknown = {
54
 
        { 0,0,0x1f,0,0,0 }
55
 
} ;
56
 
 
57
 
/*
58
 
 * function prototypes
59
 
 */
60
 
#ifdef  LITTLE_ENDIAN
61
 
static int smt_swap_short(u_short s);
62
 
#endif
63
 
static int mac_index(struct s_smc *smc, int mac);
64
 
static int phy_index(struct s_smc *smc, int phy);
65
 
static int mac_con_resource_index(struct s_smc *smc, int mac);
66
 
static int phy_con_resource_index(struct s_smc *smc, int phy);
67
 
static void smt_send_rdf(struct s_smc *smc, SMbuf *rej, int fc, int reason,
68
 
                         int local);
69
 
static void smt_send_nif(struct s_smc *smc, const struct fddi_addr *dest, 
70
 
                         int fc, u_long tid, int type, int local);
71
 
static void smt_send_ecf(struct s_smc *smc, struct fddi_addr *dest, int fc,
72
 
                         u_long tid, int type, int len);
73
 
static void smt_echo_test(struct s_smc *smc, int dna);
74
 
static void smt_send_sif_config(struct s_smc *smc, struct fddi_addr *dest,
75
 
                                u_long tid, int local);
76
 
static void smt_send_sif_operation(struct s_smc *smc, struct fddi_addr *dest,
77
 
                                   u_long tid, int local);
78
 
#ifdef LITTLE_ENDIAN
79
 
static void smt_string_swap(char *data, const char *format, int len);
80
 
#endif
81
 
static void smt_add_frame_len(SMbuf *mb, int len);
82
 
static void smt_fill_una(struct s_smc *smc, struct smt_p_una *una);
83
 
static void smt_fill_sde(struct s_smc *smc, struct smt_p_sde *sde);
84
 
static void smt_fill_state(struct s_smc *smc, struct smt_p_state *state);
85
 
static void smt_fill_timestamp(struct s_smc *smc, struct smt_p_timestamp *ts);
86
 
static void smt_fill_policy(struct s_smc *smc, struct smt_p_policy *policy);
87
 
static void smt_fill_latency(struct s_smc *smc, struct smt_p_latency *latency);
88
 
static void smt_fill_neighbor(struct s_smc *smc, struct smt_p_neighbor *neighbor);
89
 
static int smt_fill_path(struct s_smc *smc, struct smt_p_path *path);
90
 
static void smt_fill_mac_status(struct s_smc *smc, struct smt_p_mac_status *st);
91
 
static void smt_fill_lem(struct s_smc *smc, struct smt_p_lem *lem, int phy);
92
 
static void smt_fill_version(struct s_smc *smc, struct smt_p_version *vers);
93
 
static void smt_fill_fsc(struct s_smc *smc, struct smt_p_fsc *fsc);
94
 
static void smt_fill_mac_counter(struct s_smc *smc, struct smt_p_mac_counter *mc);
95
 
static void smt_fill_mac_fnc(struct s_smc *smc, struct smt_p_mac_fnc *fnc);
96
 
static void smt_fill_manufacturer(struct s_smc *smc, 
97
 
                                  struct smp_p_manufacturer *man);
98
 
static void smt_fill_user(struct s_smc *smc, struct smp_p_user *user);
99
 
static void smt_fill_setcount(struct s_smc *smc, struct smt_p_setcount *setcount);
100
 
static void smt_fill_echo(struct s_smc *smc, struct smt_p_echo *echo, u_long seed,
101
 
                          int len);
102
 
 
103
 
static void smt_clear_una_dna(struct s_smc *smc);
104
 
static void smt_clear_old_una_dna(struct s_smc *smc);
105
 
#ifdef  CONCENTRATOR
106
 
static int entity_to_index(void);
107
 
#endif
108
 
static void update_dac(struct s_smc *smc, int report);
109
 
static int div_ratio(u_long upper, u_long lower);
110
 
#ifdef  USE_CAN_ADDR
111
 
static void     hwm_conv_can(struct s_smc *smc, char *data, int len);
112
 
#else
113
 
#define         hwm_conv_can(smc,data,len)
114
 
#endif
115
 
 
116
 
 
117
 
static inline int is_my_addr(const struct s_smc *smc, 
118
 
                             const struct fddi_addr *addr)
119
 
{
120
 
        return(*(short *)(&addr->a[0]) ==
121
 
                *(short *)(&smc->mib.m[MAC0].fddiMACSMTAddress.a[0])
122
 
          && *(short *)(&addr->a[2]) ==
123
 
                *(short *)(&smc->mib.m[MAC0].fddiMACSMTAddress.a[2])
124
 
          && *(short *)(&addr->a[4]) ==
125
 
                *(short *)(&smc->mib.m[MAC0].fddiMACSMTAddress.a[4])) ;
126
 
}
127
 
 
128
 
static inline int is_broadcast(const struct fddi_addr *addr)
129
 
{
130
 
        return *(u_short *)(&addr->a[0]) == 0xffff &&
131
 
               *(u_short *)(&addr->a[2]) == 0xffff &&
132
 
               *(u_short *)(&addr->a[4]) == 0xffff;
133
 
}
134
 
 
135
 
static inline int is_individual(const struct fddi_addr *addr)
136
 
{
137
 
        return !(addr->a[0] & GROUP_ADDR);
138
 
}
139
 
 
140
 
static inline int is_equal(const struct fddi_addr *addr1, 
141
 
                           const struct fddi_addr *addr2)
142
 
{
143
 
        return *(u_short *)(&addr1->a[0]) == *(u_short *)(&addr2->a[0]) &&
144
 
               *(u_short *)(&addr1->a[2]) == *(u_short *)(&addr2->a[2]) &&
145
 
               *(u_short *)(&addr1->a[4]) == *(u_short *)(&addr2->a[4]);
146
 
}
147
 
 
148
 
/*
149
 
 * list of mandatory paras in frames
150
 
 */
151
 
static const u_short plist_nif[] = { SMT_P_UNA,SMT_P_SDE,SMT_P_STATE,0 } ;
152
 
 
153
 
/*
154
 
 * init SMT agent
155
 
 */
156
 
void smt_agent_init(struct s_smc *smc)
157
 
{
158
 
        int             i ;
159
 
 
160
 
        /*
161
 
         * get MAC address
162
 
         */
163
 
        smc->mib.m[MAC0].fddiMACSMTAddress = smc->hw.fddi_home_addr ;
164
 
 
165
 
        /*
166
 
         * get OUI address from driver (bia == built-in-address)
167
 
         */
168
 
        smc->mib.fddiSMTStationId.sid_oem[0] = 0 ;
169
 
        smc->mib.fddiSMTStationId.sid_oem[1] = 0 ;
170
 
        driver_get_bia(smc,&smc->mib.fddiSMTStationId.sid_node) ;
171
 
        for (i = 0 ; i < 6 ; i ++) {
172
 
                smc->mib.fddiSMTStationId.sid_node.a[i] =
173
 
                        bitrev8(smc->mib.fddiSMTStationId.sid_node.a[i]);
174
 
        }
175
 
        smc->mib.fddiSMTManufacturerData[0] =
176
 
                smc->mib.fddiSMTStationId.sid_node.a[0] ;
177
 
        smc->mib.fddiSMTManufacturerData[1] =
178
 
                smc->mib.fddiSMTStationId.sid_node.a[1] ;
179
 
        smc->mib.fddiSMTManufacturerData[2] =
180
 
                smc->mib.fddiSMTStationId.sid_node.a[2] ;
181
 
        smc->sm.smt_tid = 0 ;
182
 
        smc->mib.m[MAC0].fddiMACDupAddressTest = DA_NONE ;
183
 
        smc->mib.m[MAC0].fddiMACUNDA_Flag = FALSE ;
184
 
#ifndef SLIM_SMT
185
 
        smt_clear_una_dna(smc) ;
186
 
        smt_clear_old_una_dna(smc) ;
187
 
#endif
188
 
        for (i = 0 ; i < SMT_MAX_TEST ; i++)
189
 
                smc->sm.pend[i] = 0 ;
190
 
        smc->sm.please_reconnect = 0 ;
191
 
        smc->sm.uniq_ticks = 0 ;
192
 
}
193
 
 
194
 
/*
195
 
 * SMT task
196
 
 * forever
197
 
 *      delay 30 seconds
198
 
 *      send NIF
199
 
 *      check tvu & tvd
200
 
 * end
201
 
 */
202
 
void smt_agent_task(struct s_smc *smc)
203
 
{
204
 
        smt_timer_start(smc,&smc->sm.smt_timer, (u_long)1000000L,
205
 
                EV_TOKEN(EVENT_SMT,SM_TIMER)) ;
206
 
        DB_SMT("SMT agent task\n",0,0) ;
207
 
}
208
 
 
209
 
#ifndef SMT_REAL_TOKEN_CT
210
 
void smt_emulate_token_ct(struct s_smc *smc, int mac_index)
211
 
{
212
 
        u_long  count;
213
 
        u_long  time;
214
 
 
215
 
 
216
 
        time = smt_get_time();
217
 
        count = ((time - smc->sm.last_tok_time[mac_index]) *
218
 
                                        100)/TICKS_PER_SECOND;
219
 
 
220
 
        /*
221
 
         * Only when ring is up we will have a token count. The
222
 
         * flag is unfortunately a single instance value. This
223
 
         * doesn't matter now, because we currently have only
224
 
         * one MAC instance.
225
 
         */
226
 
        if (smc->hw.mac_ring_is_up){
227
 
                smc->mib.m[mac_index].fddiMACToken_Ct += count;
228
 
        }
229
 
 
230
 
        /* Remember current time */
231
 
        smc->sm.last_tok_time[mac_index] = time;
232
 
 
233
 
}
234
 
#endif
235
 
 
236
 
/*ARGSUSED1*/
237
 
void smt_event(struct s_smc *smc, int event)
238
 
{
239
 
        u_long          time ;
240
 
#ifndef SMT_REAL_TOKEN_CT
241
 
        int             i ;
242
 
#endif
243
 
 
244
 
 
245
 
        if (smc->sm.please_reconnect) {
246
 
                smc->sm.please_reconnect -- ;
247
 
                if (smc->sm.please_reconnect == 0) {
248
 
                        /* Counted down */
249
 
                        queue_event(smc,EVENT_ECM,EC_CONNECT) ;
250
 
                }
251
 
        }
252
 
 
253
 
        if (event == SM_FAST)
254
 
                return ;
255
 
 
256
 
        /*
257
 
         * timer for periodic cleanup in driver
258
 
         * reset and start the watchdog (FM2)
259
 
         * ESS timer
260
 
         * SBA timer
261
 
         */
262
 
        smt_timer_poll(smc) ;
263
 
        smt_start_watchdog(smc) ;
264
 
#ifndef SLIM_SMT
265
 
#ifndef BOOT
266
 
#ifdef  ESS
267
 
        ess_timer_poll(smc) ;
268
 
#endif
269
 
#endif
270
 
#ifdef  SBA
271
 
        sba_timer_poll(smc) ;
272
 
#endif
273
 
 
274
 
        smt_srf_event(smc,0,0,0) ;
275
 
 
276
 
#endif  /* no SLIM_SMT */
277
 
 
278
 
        time = smt_get_time() ;
279
 
 
280
 
        if (time - smc->sm.smt_last_lem >= TICKS_PER_SECOND*8) {
281
 
                /*
282
 
                 * Use 8 sec. for the time intervall, it simplifies the
283
 
                 * LER estimation.
284
 
                 */
285
 
                struct fddi_mib_m       *mib ;
286
 
                u_long                  upper ;
287
 
                u_long                  lower ;
288
 
                int                     cond ;
289
 
                int                     port;
290
 
                struct s_phy            *phy ;
291
 
                /*
292
 
                 * calculate LEM bit error rate
293
 
                 */
294
 
                sm_lem_evaluate(smc) ;
295
 
                smc->sm.smt_last_lem = time ;
296
 
 
297
 
                /*
298
 
                 * check conditions
299
 
                 */
300
 
#ifndef SLIM_SMT
301
 
                mac_update_counter(smc) ;
302
 
                mib = smc->mib.m ;
303
 
                upper =
304
 
                (mib->fddiMACLost_Ct - mib->fddiMACOld_Lost_Ct) +
305
 
                (mib->fddiMACError_Ct - mib->fddiMACOld_Error_Ct) ;
306
 
                lower =
307
 
                (mib->fddiMACFrame_Ct - mib->fddiMACOld_Frame_Ct) +
308
 
                (mib->fddiMACLost_Ct - mib->fddiMACOld_Lost_Ct) ;
309
 
                mib->fddiMACFrameErrorRatio = div_ratio(upper,lower) ;
310
 
 
311
 
                cond =
312
 
                        ((!mib->fddiMACFrameErrorThreshold &&
313
 
                        mib->fddiMACError_Ct != mib->fddiMACOld_Error_Ct) ||
314
 
                        (mib->fddiMACFrameErrorRatio >
315
 
                        mib->fddiMACFrameErrorThreshold)) ;
316
 
 
317
 
                if (cond != mib->fddiMACFrameErrorFlag)
318
 
                        smt_srf_event(smc,SMT_COND_MAC_FRAME_ERROR,
319
 
                                INDEX_MAC,cond) ;
320
 
 
321
 
                upper =
322
 
                (mib->fddiMACNotCopied_Ct - mib->fddiMACOld_NotCopied_Ct) ;
323
 
                lower =
324
 
                upper +
325
 
                (mib->fddiMACCopied_Ct - mib->fddiMACOld_Copied_Ct) ;
326
 
                mib->fddiMACNotCopiedRatio = div_ratio(upper,lower) ;
327
 
 
328
 
                cond =
329
 
                        ((!mib->fddiMACNotCopiedThreshold &&
330
 
                        mib->fddiMACNotCopied_Ct !=
331
 
                                mib->fddiMACOld_NotCopied_Ct)||
332
 
                        (mib->fddiMACNotCopiedRatio >
333
 
                        mib->fddiMACNotCopiedThreshold)) ;
334
 
 
335
 
                if (cond != mib->fddiMACNotCopiedFlag)
336
 
                        smt_srf_event(smc,SMT_COND_MAC_NOT_COPIED,
337
 
                                INDEX_MAC,cond) ;
338
 
 
339
 
                /*
340
 
                 * set old values
341
 
                 */
342
 
                mib->fddiMACOld_Frame_Ct = mib->fddiMACFrame_Ct ;
343
 
                mib->fddiMACOld_Copied_Ct = mib->fddiMACCopied_Ct ;
344
 
                mib->fddiMACOld_Error_Ct = mib->fddiMACError_Ct ;
345
 
                mib->fddiMACOld_Lost_Ct = mib->fddiMACLost_Ct ;
346
 
                mib->fddiMACOld_NotCopied_Ct = mib->fddiMACNotCopied_Ct ;
347
 
 
348
 
                /*
349
 
                 * Check port EBError Condition
350
 
                 */
351
 
                for (port = 0; port < NUMPHYS; port ++) {
352
 
                        phy = &smc->y[port] ;
353
 
 
354
 
                        if (!phy->mib->fddiPORTHardwarePresent) {
355
 
                                continue;
356
 
                        }
357
 
 
358
 
                        cond = (phy->mib->fddiPORTEBError_Ct -
359
 
                                phy->mib->fddiPORTOldEBError_Ct > 5) ;
360
 
 
361
 
                        /* If ratio is more than 5 in 8 seconds
362
 
                         * Set the condition.
363
 
                         */
364
 
                        smt_srf_event(smc,SMT_COND_PORT_EB_ERROR,
365
 
                                (int) (INDEX_PORT+ phy->np) ,cond) ;
366
 
 
367
 
                        /*
368
 
                         * set old values
369
 
                         */
370
 
                        phy->mib->fddiPORTOldEBError_Ct =
371
 
                                phy->mib->fddiPORTEBError_Ct ;
372
 
                }
373
 
 
374
 
#endif  /* no SLIM_SMT */
375
 
        }
376
 
 
377
 
#ifndef SLIM_SMT
378
 
 
379
 
        if (time - smc->sm.smt_last_notify >= (u_long)
380
 
                (smc->mib.fddiSMTTT_Notify * TICKS_PER_SECOND) ) {
381
 
                /*
382
 
                 * we can either send an announcement or a request
383
 
                 * a request will trigger a reply so that we can update
384
 
                 * our dna
385
 
                 * note: same tid must be used until reply is received
386
 
                 */
387
 
                if (!smc->sm.pend[SMT_TID_NIF])
388
 
                        smc->sm.pend[SMT_TID_NIF] = smt_get_tid(smc) ;
389
 
                smt_send_nif(smc,&fddi_broadcast, FC_SMT_NSA,
390
 
                        smc->sm.pend[SMT_TID_NIF], SMT_REQUEST,0) ;
391
 
                smc->sm.smt_last_notify = time ;
392
 
        }
393
 
 
394
 
        /*
395
 
         * check timer
396
 
         */
397
 
        if (smc->sm.smt_tvu &&
398
 
            time - smc->sm.smt_tvu > 228*TICKS_PER_SECOND) {
399
 
                DB_SMT("SMT : UNA expired\n",0,0) ;
400
 
                smc->sm.smt_tvu = 0 ;
401
 
 
402
 
                if (!is_equal(&smc->mib.m[MAC0].fddiMACUpstreamNbr,
403
 
                        &SMT_Unknown)){
404
 
                        /* Do not update unknown address */
405
 
                        smc->mib.m[MAC0].fddiMACOldUpstreamNbr=
406
 
                                smc->mib.m[MAC0].fddiMACUpstreamNbr ;
407
 
                }
408
 
                smc->mib.m[MAC0].fddiMACUpstreamNbr = SMT_Unknown ;
409
 
                smc->mib.m[MAC0].fddiMACUNDA_Flag = FALSE ;
410
 
                /*
411
 
                 * Make sure the fddiMACUNDA_Flag = FALSE is
412
 
                 * included in the SRF so we don't generate
413
 
                 * a separate SRF for the deassertion of this
414
 
                 * condition
415
 
                 */
416
 
                update_dac(smc,0) ;
417
 
                smt_srf_event(smc, SMT_EVENT_MAC_NEIGHBOR_CHANGE,
418
 
                        INDEX_MAC,0) ;
419
 
        }
420
 
        if (smc->sm.smt_tvd &&
421
 
            time - smc->sm.smt_tvd > 228*TICKS_PER_SECOND) {
422
 
                DB_SMT("SMT : DNA expired\n",0,0) ;
423
 
                smc->sm.smt_tvd = 0 ;
424
 
                if (!is_equal(&smc->mib.m[MAC0].fddiMACDownstreamNbr,
425
 
                        &SMT_Unknown)){
426
 
                        /* Do not update unknown address */
427
 
                        smc->mib.m[MAC0].fddiMACOldDownstreamNbr=
428
 
                                smc->mib.m[MAC0].fddiMACDownstreamNbr ;
429
 
                }
430
 
                smc->mib.m[MAC0].fddiMACDownstreamNbr = SMT_Unknown ;
431
 
                smt_srf_event(smc, SMT_EVENT_MAC_NEIGHBOR_CHANGE,
432
 
                        INDEX_MAC,0) ;
433
 
        }
434
 
 
435
 
#endif  /* no SLIM_SMT */
436
 
 
437
 
#ifndef SMT_REAL_TOKEN_CT
438
 
        /*
439
 
         * Token counter emulation section. If hardware supports the token
440
 
         * count, the token counter will be updated in mac_update_counter.
441
 
         */
442
 
        for (i = MAC0; i < NUMMACS; i++ ){
443
 
                if (time - smc->sm.last_tok_time[i] > 2*TICKS_PER_SECOND ){
444
 
                        smt_emulate_token_ct( smc, i );
445
 
                }
446
 
        }
447
 
#endif
448
 
 
449
 
        smt_timer_start(smc,&smc->sm.smt_timer, (u_long)1000000L,
450
 
                EV_TOKEN(EVENT_SMT,SM_TIMER)) ;
451
 
}
452
 
 
453
 
static int div_ratio(u_long upper, u_long lower)
454
 
{
455
 
        if ((upper<<16L) < upper)
456
 
                upper = 0xffff0000L ;
457
 
        else
458
 
                upper <<= 16L ;
459
 
        if (!lower)
460
 
                return 0;
461
 
        return (int)(upper/lower) ;
462
 
}
463
 
 
464
 
#ifndef SLIM_SMT
465
 
 
466
 
/*
467
 
 * receive packet handler
468
 
 */
469
 
void smt_received_pack(struct s_smc *smc, SMbuf *mb, int fs)
470
 
/* int fs;  frame status */
471
 
{
472
 
        struct smt_header       *sm ;
473
 
        int                     local ;
474
 
 
475
 
        int                     illegal = 0 ;
476
 
 
477
 
        switch (m_fc(mb)) {
478
 
        case FC_SMT_INFO :
479
 
        case FC_SMT_LAN_LOC :
480
 
        case FC_SMT_LOC :
481
 
        case FC_SMT_NSA :
482
 
                break ;
483
 
        default :
484
 
                smt_free_mbuf(smc,mb) ;
485
 
                return ;
486
 
        }
487
 
 
488
 
        smc->mib.m[MAC0].fddiMACSMTCopied_Ct++ ;
489
 
        sm = smtod(mb,struct smt_header *) ;
490
 
        local = ((fs & L_INDICATOR) != 0) ;
491
 
        hwm_conv_can(smc,(char *)sm,12) ;
492
 
 
493
 
        /* check destination address */
494
 
        if (is_individual(&sm->smt_dest) && !is_my_addr(smc,&sm->smt_dest)) {
495
 
                smt_free_mbuf(smc,mb) ;
496
 
                return ;
497
 
        }
498
 
#if     0               /* for DUP recognition, do NOT filter them */
499
 
        /* ignore loop back packets */
500
 
        if (is_my_addr(smc,&sm->smt_source) && !local) {
501
 
                smt_free_mbuf(smc,mb) ;
502
 
                return ;
503
 
        }
504
 
#endif
505
 
 
506
 
        smt_swap_para(sm,(int) mb->sm_len,1) ;
507
 
        DB_SMT("SMT : received packet [%s] at 0x%x\n",
508
 
                smt_type_name[m_fc(mb) & 0xf],sm) ;
509
 
        DB_SMT("SMT : version %d, class %s\n",sm->smt_version,
510
 
                smt_class_name[(sm->smt_class>LAST_CLASS)?0 : sm->smt_class]) ;
511
 
 
512
 
#ifdef  SBA
513
 
        /*
514
 
         * check if NSA frame
515
 
         */
516
 
        if (m_fc(mb) == FC_SMT_NSA && sm->smt_class == SMT_NIF &&
517
 
                (sm->smt_type == SMT_ANNOUNCE || sm->smt_type == SMT_REQUEST)) {
518
 
                        smc->sba.sm = sm ;
519
 
                        sba(smc,NIF) ;
520
 
        }
521
 
#endif
522
 
 
523
 
        /*
524
 
         * ignore any packet with NSA and A-indicator set
525
 
         */
526
 
        if ( (fs & A_INDICATOR) && m_fc(mb) == FC_SMT_NSA) {
527
 
                DB_SMT("SMT : ignoring NSA with A-indicator set from %s\n",
528
 
                        addr_to_string(&sm->smt_source),0) ;
529
 
                smt_free_mbuf(smc,mb) ;
530
 
                return ;
531
 
        }
532
 
 
533
 
        /*
534
 
         * ignore frames with illegal length
535
 
         */
536
 
        if (((sm->smt_class == SMT_ECF) && (sm->smt_len > SMT_MAX_ECHO_LEN)) ||
537
 
            ((sm->smt_class != SMT_ECF) && (sm->smt_len > SMT_MAX_INFO_LEN))) {
538
 
                smt_free_mbuf(smc,mb) ;
539
 
                return ;
540
 
        }
541
 
 
542
 
        /*
543
 
         * check SMT version
544
 
         */
545
 
        switch (sm->smt_class) {
546
 
        case SMT_NIF :
547
 
        case SMT_SIF_CONFIG :
548
 
        case SMT_SIF_OPER :
549
 
        case SMT_ECF :
550
 
                if (sm->smt_version != SMT_VID)
551
 
                        illegal = 1;
552
 
                break ;
553
 
        default :
554
 
                if (sm->smt_version != SMT_VID_2)
555
 
                        illegal = 1;
556
 
                break ;
557
 
        }
558
 
        if (illegal) {
559
 
                DB_SMT("SMT : version = %d, dest = %s\n",
560
 
                        sm->smt_version,addr_to_string(&sm->smt_source)) ;
561
 
                smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_VERSION,local) ;
562
 
                smt_free_mbuf(smc,mb) ;
563
 
                return ;
564
 
        }
565
 
        if ((sm->smt_len > mb->sm_len - sizeof(struct smt_header)) ||
566
 
            ((sm->smt_len & 3) && (sm->smt_class != SMT_ECF))) {
567
 
                DB_SMT("SMT: info length error, len = %d\n",sm->smt_len,0) ;
568
 
                smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_LENGTH,local) ;
569
 
                smt_free_mbuf(smc,mb) ;
570
 
                return ;
571
 
        }
572
 
        switch (sm->smt_class) {
573
 
        case SMT_NIF :
574
 
                if (smt_check_para(smc,sm,plist_nif)) {
575
 
                        DB_SMT("SMT: NIF with para problem, ignoring\n",0,0) ;
576
 
                        break ;
577
 
                }
578
 
                switch (sm->smt_type) {
579
 
                case SMT_ANNOUNCE :
580
 
                case SMT_REQUEST :
581
 
                        if (!(fs & C_INDICATOR) && m_fc(mb) == FC_SMT_NSA
582
 
                                && is_broadcast(&sm->smt_dest)) {
583
 
                                struct smt_p_state      *st ;
584
 
 
585
 
                                /* set my UNA */
586
 
                                if (!is_equal(
587
 
                                        &smc->mib.m[MAC0].fddiMACUpstreamNbr,
588
 
                                        &sm->smt_source)) {
589
 
                                        DB_SMT("SMT : updated my UNA = %s\n",
590
 
                                        addr_to_string(&sm->smt_source),0) ;
591
 
                                        if (!is_equal(&smc->mib.m[MAC0].
592
 
                                            fddiMACUpstreamNbr,&SMT_Unknown)){
593
 
                                         /* Do not update unknown address */
594
 
                                         smc->mib.m[MAC0].fddiMACOldUpstreamNbr=
595
 
                                         smc->mib.m[MAC0].fddiMACUpstreamNbr ;
596
 
                                        }
597
 
 
598
 
                                        smc->mib.m[MAC0].fddiMACUpstreamNbr =
599
 
                                                sm->smt_source ;
600
 
                                        smt_srf_event(smc,
601
 
                                                SMT_EVENT_MAC_NEIGHBOR_CHANGE,
602
 
                                                INDEX_MAC,0) ;
603
 
                                        smt_echo_test(smc,0) ;
604
 
                                }
605
 
                                smc->sm.smt_tvu = smt_get_time() ;
606
 
                                st = (struct smt_p_state *)
607
 
                                        sm_to_para(smc,sm,SMT_P_STATE) ;
608
 
                                if (st) {
609
 
                                        smc->mib.m[MAC0].fddiMACUNDA_Flag =
610
 
                                        (st->st_dupl_addr & SMT_ST_MY_DUPA) ?
611
 
                                        TRUE : FALSE ;
612
 
                                        update_dac(smc,1) ;
613
 
                                }
614
 
                        }
615
 
                        if ((sm->smt_type == SMT_REQUEST) &&
616
 
                            is_individual(&sm->smt_source) &&
617
 
                            ((!(fs & A_INDICATOR) && m_fc(mb) == FC_SMT_NSA) ||
618
 
                             (m_fc(mb) != FC_SMT_NSA))) {
619
 
                                DB_SMT("SMT : replying to NIF request %s\n",
620
 
                                        addr_to_string(&sm->smt_source),0) ;
621
 
                                smt_send_nif(smc,&sm->smt_source,
622
 
                                        FC_SMT_INFO,
623
 
                                        sm->smt_tid,
624
 
                                        SMT_REPLY,local) ;
625
 
                        }
626
 
                        break ;
627
 
                case SMT_REPLY :
628
 
                        DB_SMT("SMT : received NIF response from %s\n",
629
 
                                addr_to_string(&sm->smt_source),0) ;
630
 
                        if (fs & A_INDICATOR) {
631
 
                                smc->sm.pend[SMT_TID_NIF] = 0 ;
632
 
                                DB_SMT("SMT : duplicate address\n",0,0) ;
633
 
                                smc->mib.m[MAC0].fddiMACDupAddressTest =
634
 
                                        DA_FAILED ;
635
 
                                smc->r.dup_addr_test = DA_FAILED ;
636
 
                                queue_event(smc,EVENT_RMT,RM_DUP_ADDR) ;
637
 
                                smc->mib.m[MAC0].fddiMACDA_Flag = TRUE ;
638
 
                                update_dac(smc,1) ;
639
 
                                break ;
640
 
                        }
641
 
                        if (sm->smt_tid == smc->sm.pend[SMT_TID_NIF]) {
642
 
                                smc->sm.pend[SMT_TID_NIF] = 0 ;
643
 
                                /* set my DNA */
644
 
                                if (!is_equal(
645
 
                                        &smc->mib.m[MAC0].fddiMACDownstreamNbr,
646
 
                                        &sm->smt_source)) {
647
 
                                        DB_SMT("SMT : updated my DNA\n",0,0) ;
648
 
                                        if (!is_equal(&smc->mib.m[MAC0].
649
 
                                         fddiMACDownstreamNbr, &SMT_Unknown)){
650
 
                                         /* Do not update unknown address */
651
 
                                smc->mib.m[MAC0].fddiMACOldDownstreamNbr =
652
 
                                         smc->mib.m[MAC0].fddiMACDownstreamNbr ;
653
 
                                        }
654
 
 
655
 
                                        smc->mib.m[MAC0].fddiMACDownstreamNbr =
656
 
                                                sm->smt_source ;
657
 
                                        smt_srf_event(smc,
658
 
                                                SMT_EVENT_MAC_NEIGHBOR_CHANGE,
659
 
                                                INDEX_MAC,0) ;
660
 
                                        smt_echo_test(smc,1) ;
661
 
                                }
662
 
                                smc->mib.m[MAC0].fddiMACDA_Flag = FALSE ;
663
 
                                update_dac(smc,1) ;
664
 
                                smc->sm.smt_tvd = smt_get_time() ;
665
 
                                smc->mib.m[MAC0].fddiMACDupAddressTest =
666
 
                                        DA_PASSED ;
667
 
                                if (smc->r.dup_addr_test != DA_PASSED) {
668
 
                                        smc->r.dup_addr_test = DA_PASSED ;
669
 
                                        queue_event(smc,EVENT_RMT,RM_DUP_ADDR) ;
670
 
                                }
671
 
                        }
672
 
                        else if (sm->smt_tid ==
673
 
                                smc->sm.pend[SMT_TID_NIF_TEST]) {
674
 
                                DB_SMT("SMT : NIF test TID ok\n",0,0) ;
675
 
                        }
676
 
                        else {
677
 
                                DB_SMT("SMT : expected TID %lx, got %lx\n",
678
 
                                smc->sm.pend[SMT_TID_NIF],sm->smt_tid) ;
679
 
                        }
680
 
                        break ;
681
 
                default :
682
 
                        illegal = 2 ;
683
 
                        break ;
684
 
                }
685
 
                break ;
686
 
        case SMT_SIF_CONFIG :   /* station information */
687
 
                if (sm->smt_type != SMT_REQUEST)
688
 
                        break ;
689
 
                DB_SMT("SMT : replying to SIF Config request from %s\n",
690
 
                        addr_to_string(&sm->smt_source),0) ;
691
 
                smt_send_sif_config(smc,&sm->smt_source,sm->smt_tid,local) ;
692
 
                break ;
693
 
        case SMT_SIF_OPER :     /* station information */
694
 
                if (sm->smt_type != SMT_REQUEST)
695
 
                        break ;
696
 
                DB_SMT("SMT : replying to SIF Operation request from %s\n",
697
 
                        addr_to_string(&sm->smt_source),0) ;
698
 
                smt_send_sif_operation(smc,&sm->smt_source,sm->smt_tid,local) ;
699
 
                break ;
700
 
        case SMT_ECF :          /* echo frame */
701
 
                switch (sm->smt_type) {
702
 
                case SMT_REPLY :
703
 
                        smc->mib.priv.fddiPRIVECF_Reply_Rx++ ;
704
 
                        DB_SMT("SMT: received ECF reply from %s\n",
705
 
                                addr_to_string(&sm->smt_source),0) ;
706
 
                        if (sm_to_para(smc,sm,SMT_P_ECHODATA) == NULL) {
707
 
                                DB_SMT("SMT: ECHODATA missing\n",0,0) ;
708
 
                                break ;
709
 
                        }
710
 
                        if (sm->smt_tid == smc->sm.pend[SMT_TID_ECF]) {
711
 
                                DB_SMT("SMT : ECF test TID ok\n",0,0) ;
712
 
                        }
713
 
                        else if (sm->smt_tid == smc->sm.pend[SMT_TID_ECF_UNA]) {
714
 
                                DB_SMT("SMT : ECF test UNA ok\n",0,0) ;
715
 
                        }
716
 
                        else if (sm->smt_tid == smc->sm.pend[SMT_TID_ECF_DNA]) {
717
 
                                DB_SMT("SMT : ECF test DNA ok\n",0,0) ;
718
 
                        }
719
 
                        else {
720
 
                                DB_SMT("SMT : expected TID %lx, got %lx\n",
721
 
                                        smc->sm.pend[SMT_TID_ECF],
722
 
                                        sm->smt_tid) ;
723
 
                        }
724
 
                        break ;
725
 
                case SMT_REQUEST :
726
 
                        smc->mib.priv.fddiPRIVECF_Req_Rx++ ;
727
 
                        {
728
 
                        if (sm->smt_len && !sm_to_para(smc,sm,SMT_P_ECHODATA)) {
729
 
                        DB_SMT("SMT: ECF with para problem,sending RDF\n",0,0) ;
730
 
                                smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_LENGTH,
731
 
                                        local) ;
732
 
                                break ;
733
 
                        }
734
 
                        DB_SMT("SMT - sending ECF reply to %s\n",
735
 
                                addr_to_string(&sm->smt_source),0) ;
736
 
 
737
 
                        /* set destination addr.  & reply */
738
 
                        sm->smt_dest = sm->smt_source ;
739
 
                        sm->smt_type = SMT_REPLY ;
740
 
                        dump_smt(smc,sm,"ECF REPLY") ;
741
 
                        smc->mib.priv.fddiPRIVECF_Reply_Tx++ ;
742
 
                        smt_send_frame(smc,mb,FC_SMT_INFO,local) ;
743
 
                        return ;                /* DON'T free mbuf */
744
 
                        }
745
 
                default :
746
 
                        illegal = 1 ;
747
 
                        break ;
748
 
                }
749
 
                break ;
750
 
#ifndef BOOT
751
 
        case SMT_RAF :          /* resource allocation */
752
 
#ifdef  ESS
753
 
                DB_ESSN(2,"ESS: RAF frame received\n",0,0) ;
754
 
                fs = ess_raf_received_pack(smc,mb,sm,fs) ;
755
 
#endif
756
 
 
757
 
#ifdef  SBA
758
 
                DB_SBAN(2,"SBA: RAF frame received\n",0,0) ;
759
 
                sba_raf_received_pack(smc,sm,fs) ;
760
 
#endif
761
 
                break ;
762
 
        case SMT_RDF :          /* request denied */
763
 
                smc->mib.priv.fddiPRIVRDF_Rx++ ;
764
 
                break ;
765
 
        case SMT_ESF :          /* extended service - not supported */
766
 
                if (sm->smt_type == SMT_REQUEST) {
767
 
                        DB_SMT("SMT - received ESF, sending RDF\n",0,0) ;
768
 
                        smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_CLASS,local) ;
769
 
                }
770
 
                break ;
771
 
        case SMT_PMF_GET :
772
 
        case SMT_PMF_SET :
773
 
                if (sm->smt_type != SMT_REQUEST)
774
 
                        break ;
775
 
                /* update statistics */
776
 
                if (sm->smt_class == SMT_PMF_GET)
777
 
                        smc->mib.priv.fddiPRIVPMF_Get_Rx++ ;
778
 
                else
779
 
                        smc->mib.priv.fddiPRIVPMF_Set_Rx++ ;
780
 
                /*
781
 
                 * ignore PMF SET with I/G set
782
 
                 */
783
 
                if ((sm->smt_class == SMT_PMF_SET) &&
784
 
                        !is_individual(&sm->smt_dest)) {
785
 
                        DB_SMT("SMT: ignoring PMF-SET with I/G set\n",0,0) ;
786
 
                        break ;
787
 
                }
788
 
                smt_pmf_received_pack(smc,mb, local) ;
789
 
                break ;
790
 
        case SMT_SRF :
791
 
                dump_smt(smc,sm,"SRF received") ;
792
 
                break ;
793
 
        default :
794
 
                if (sm->smt_type != SMT_REQUEST)
795
 
                        break ;
796
 
                /*
797
 
                 * For frames with unknown class:
798
 
                 * we need to send a RDF frame according to 8.1.3.1.1,
799
 
                 * only if it is a REQUEST.
800
 
                 */
801
 
                DB_SMT("SMT : class = %d, send RDF to %s\n",
802
 
                        sm->smt_class, addr_to_string(&sm->smt_source)) ;
803
 
 
804
 
                smt_send_rdf(smc,mb,m_fc(mb),SMT_RDF_CLASS,local) ;
805
 
                break ;
806
 
#endif
807
 
        }
808
 
        if (illegal) {
809
 
                DB_SMT("SMT: discarding invalid frame, reason = %d\n",
810
 
                        illegal,0) ;
811
 
        }
812
 
        smt_free_mbuf(smc,mb) ;
813
 
}
814
 
 
815
 
static void update_dac(struct s_smc *smc, int report)
816
 
{
817
 
        int     cond ;
818
 
 
819
 
        cond = ( smc->mib.m[MAC0].fddiMACUNDA_Flag |
820
 
                smc->mib.m[MAC0].fddiMACDA_Flag) != 0 ;
821
 
        if (report && (cond != smc->mib.m[MAC0].fddiMACDuplicateAddressCond))
822
 
                smt_srf_event(smc, SMT_COND_MAC_DUP_ADDR,INDEX_MAC,cond) ;
823
 
        else
824
 
                smc->mib.m[MAC0].fddiMACDuplicateAddressCond = cond ;
825
 
}
826
 
 
827
 
/*
828
 
 * send SMT frame
829
 
 *      set source address
830
 
 *      set station ID
831
 
 *      send frame
832
 
 */
833
 
void smt_send_frame(struct s_smc *smc, SMbuf *mb, int fc, int local)
834
 
/* SMbuf *mb;   buffer to send */
835
 
/* int fc;      FC value */
836
 
{
837
 
        struct smt_header       *sm ;
838
 
 
839
 
        if (!smc->r.sm_ma_avail && !local) {
840
 
                smt_free_mbuf(smc,mb) ;
841
 
                return ;
842
 
        }
843
 
        sm = smtod(mb,struct smt_header *) ;
844
 
        sm->smt_source = smc->mib.m[MAC0].fddiMACSMTAddress ;
845
 
        sm->smt_sid = smc->mib.fddiSMTStationId ;
846
 
 
847
 
        smt_swap_para(sm,(int) mb->sm_len,0) ;          /* swap para & header */
848
 
        hwm_conv_can(smc,(char *)sm,12) ;               /* convert SA and DA */
849
 
        smc->mib.m[MAC0].fddiMACSMTTransmit_Ct++ ;
850
 
        smt_send_mbuf(smc,mb,local ? FC_SMT_LOC : fc) ;
851
 
}
852
 
 
853
 
/*
854
 
 * generate and send RDF
855
 
 */
856
 
static void smt_send_rdf(struct s_smc *smc, SMbuf *rej, int fc, int reason,
857
 
                         int local)
858
 
/* SMbuf *rej;  mbuf of offending frame */
859
 
/* int fc;      FC of denied frame */
860
 
/* int reason;  reason code */
861
 
{
862
 
        SMbuf   *mb ;
863
 
        struct smt_header       *sm ;   /* header of offending frame */
864
 
        struct smt_rdf  *rdf ;
865
 
        int             len ;
866
 
        int             frame_len ;
867
 
 
868
 
        sm = smtod(rej,struct smt_header *) ;
869
 
        if (sm->smt_type != SMT_REQUEST)
870
 
                return ;
871
 
 
872
 
        DB_SMT("SMT: sending RDF to %s,reason = 0x%x\n",
873
 
                addr_to_string(&sm->smt_source),reason) ;
874
 
 
875
 
 
876
 
        /*
877
 
         * note: get framelength from MAC length, NOT from SMT header
878
 
         * smt header length is included in sm_len
879
 
         */
880
 
        frame_len = rej->sm_len ;
881
 
 
882
 
        if (!(mb=smt_build_frame(smc,SMT_RDF,SMT_REPLY,sizeof(struct smt_rdf))))
883
 
                return ;
884
 
        rdf = smtod(mb,struct smt_rdf *) ;
885
 
        rdf->smt.smt_tid = sm->smt_tid ;                /* use TID from sm */
886
 
        rdf->smt.smt_dest = sm->smt_source ;            /* set dest = source */
887
 
 
888
 
        /* set P12 */
889
 
        rdf->reason.para.p_type = SMT_P_REASON ;
890
 
        rdf->reason.para.p_len = sizeof(struct smt_p_reason) - PARA_LEN ;
891
 
        rdf->reason.rdf_reason = reason ;
892
 
 
893
 
        /* set P14 */
894
 
        rdf->version.para.p_type = SMT_P_VERSION ;
895
 
        rdf->version.para.p_len = sizeof(struct smt_p_version) - PARA_LEN ;
896
 
        rdf->version.v_pad = 0 ;
897
 
        rdf->version.v_n = 1 ;
898
 
        rdf->version.v_index = 1 ;
899
 
        rdf->version.v_version[0] = SMT_VID_2 ;
900
 
        rdf->version.v_pad2 = 0 ;
901
 
 
902
 
        /* set P13 */
903
 
        if ((unsigned) frame_len <= SMT_MAX_INFO_LEN - sizeof(*rdf) +
904
 
                2*sizeof(struct smt_header))
905
 
                len = frame_len ;
906
 
        else
907
 
                len = SMT_MAX_INFO_LEN - sizeof(*rdf) +
908
 
                        2*sizeof(struct smt_header) ;
909
 
        /* make length multiple of 4 */
910
 
        len &= ~3 ;
911
 
        rdf->refused.para.p_type = SMT_P_REFUSED ;
912
 
        /* length of para is smt_frame + ref_fc */
913
 
        rdf->refused.para.p_len = len + 4 ;
914
 
        rdf->refused.ref_fc = fc ;
915
 
 
916
 
        /* swap it back */
917
 
        smt_swap_para(sm,frame_len,0) ;
918
 
 
919
 
        memcpy((char *) &rdf->refused.ref_header,(char *) sm,len) ;
920
 
 
921
 
        len -= sizeof(struct smt_header) ;
922
 
        mb->sm_len += len ;
923
 
        rdf->smt.smt_len += len ;
924
 
 
925
 
        dump_smt(smc,(struct smt_header *)rdf,"RDF") ;
926
 
        smc->mib.priv.fddiPRIVRDF_Tx++ ;
927
 
        smt_send_frame(smc,mb,FC_SMT_INFO,local) ;
928
 
}
929
 
 
930
 
/*
931
 
 * generate and send NIF
932
 
 */
933
 
static void smt_send_nif(struct s_smc *smc, const struct fddi_addr *dest, 
934
 
                         int fc, u_long tid, int type, int local)
935
 
/* struct fddi_addr *dest;      dest address */
936
 
/* int fc;                      frame control */
937
 
/* u_long tid;                  transaction id */
938
 
/* int type;                    frame type */
939
 
{
940
 
        struct smt_nif  *nif ;
941
 
        SMbuf           *mb ;
942
 
 
943
 
        if (!(mb = smt_build_frame(smc,SMT_NIF,type,sizeof(struct smt_nif))))
944
 
                return ;
945
 
        nif = smtod(mb, struct smt_nif *) ;
946
 
        smt_fill_una(smc,&nif->una) ;   /* set UNA */
947
 
        smt_fill_sde(smc,&nif->sde) ;   /* set station descriptor */
948
 
        smt_fill_state(smc,&nif->state) ;       /* set state information */
949
 
#ifdef  SMT6_10
950
 
        smt_fill_fsc(smc,&nif->fsc) ;   /* set frame status cap. */
951
 
#endif
952
 
        nif->smt.smt_dest = *dest ;     /* destination address */
953
 
        nif->smt.smt_tid = tid ;        /* transaction ID */
954
 
        dump_smt(smc,(struct smt_header *)nif,"NIF") ;
955
 
        smt_send_frame(smc,mb,fc,local) ;
956
 
}
957
 
 
958
 
#ifdef  DEBUG
959
 
/*
960
 
 * send NIF request (test purpose)
961
 
 */
962
 
static void smt_send_nif_request(struct s_smc *smc, struct fddi_addr *dest)
963
 
{
964
 
        smc->sm.pend[SMT_TID_NIF_TEST] = smt_get_tid(smc) ;
965
 
        smt_send_nif(smc,dest, FC_SMT_INFO, smc->sm.pend[SMT_TID_NIF_TEST],
966
 
                SMT_REQUEST,0) ;
967
 
}
968
 
 
969
 
/*
970
 
 * send ECF request (test purpose)
971
 
 */
972
 
static void smt_send_ecf_request(struct s_smc *smc, struct fddi_addr *dest,
973
 
                                 int len)
974
 
{
975
 
        smc->sm.pend[SMT_TID_ECF] = smt_get_tid(smc) ;
976
 
        smt_send_ecf(smc,dest, FC_SMT_INFO, smc->sm.pend[SMT_TID_ECF],
977
 
                SMT_REQUEST,len) ;
978
 
}
979
 
#endif
980
 
 
981
 
/*
982
 
 * echo test
983
 
 */
984
 
static void smt_echo_test(struct s_smc *smc, int dna)
985
 
{
986
 
        u_long  tid ;
987
 
 
988
 
        smc->sm.pend[dna ? SMT_TID_ECF_DNA : SMT_TID_ECF_UNA] =
989
 
                tid = smt_get_tid(smc) ;
990
 
        smt_send_ecf(smc, dna ?
991
 
                &smc->mib.m[MAC0].fddiMACDownstreamNbr :
992
 
                &smc->mib.m[MAC0].fddiMACUpstreamNbr,
993
 
                FC_SMT_INFO,tid, SMT_REQUEST, (SMT_TEST_ECHO_LEN & ~3)-8) ;
994
 
}
995
 
 
996
 
/*
997
 
 * generate and send ECF
998
 
 */
999
 
static void smt_send_ecf(struct s_smc *smc, struct fddi_addr *dest, int fc,
1000
 
                         u_long tid, int type, int len)
1001
 
/* struct fddi_addr *dest;      dest address */
1002
 
/* int fc;                      frame control */
1003
 
/* u_long tid;                  transaction id */
1004
 
/* int type;                    frame type */
1005
 
/* int len;                     frame length */
1006
 
{
1007
 
        struct smt_ecf  *ecf ;
1008
 
        SMbuf           *mb ;
1009
 
 
1010
 
        if (!(mb = smt_build_frame(smc,SMT_ECF,type,SMT_ECF_LEN + len)))
1011
 
                return ;
1012
 
        ecf = smtod(mb, struct smt_ecf *) ;
1013
 
 
1014
 
        smt_fill_echo(smc,&ecf->ec_echo,tid,len) ;      /* set ECHO */
1015
 
        ecf->smt.smt_dest = *dest ;     /* destination address */
1016
 
        ecf->smt.smt_tid = tid ;        /* transaction ID */
1017
 
        smc->mib.priv.fddiPRIVECF_Req_Tx++ ;
1018
 
        smt_send_frame(smc,mb,fc,0) ;
1019
 
}
1020
 
 
1021
 
/*
1022
 
 * generate and send SIF config response
1023
 
 */
1024
 
 
1025
 
static void smt_send_sif_config(struct s_smc *smc, struct fddi_addr *dest,
1026
 
                                u_long tid, int local)
1027
 
/* struct fddi_addr *dest;      dest address */
1028
 
/* u_long tid;                  transaction id */
1029
 
{
1030
 
        struct smt_sif_config   *sif ;
1031
 
        SMbuf                   *mb ;
1032
 
        int                     len ;
1033
 
        if (!(mb = smt_build_frame(smc,SMT_SIF_CONFIG,SMT_REPLY,
1034
 
                SIZEOF_SMT_SIF_CONFIG)))
1035
 
                return ;
1036
 
 
1037
 
        sif = smtod(mb, struct smt_sif_config *) ;
1038
 
        smt_fill_timestamp(smc,&sif->ts) ;      /* set time stamp */
1039
 
        smt_fill_sde(smc,&sif->sde) ;           /* set station descriptor */
1040
 
        smt_fill_version(smc,&sif->version) ;   /* set version information */
1041
 
        smt_fill_state(smc,&sif->state) ;       /* set state information */
1042
 
        smt_fill_policy(smc,&sif->policy) ;     /* set station policy */
1043
 
        smt_fill_latency(smc,&sif->latency);    /* set station latency */
1044
 
        smt_fill_neighbor(smc,&sif->neighbor);  /* set station neighbor */
1045
 
        smt_fill_setcount(smc,&sif->setcount) ; /* set count */
1046
 
        len = smt_fill_path(smc,&sif->path);    /* set station path descriptor*/
1047
 
        sif->smt.smt_dest = *dest ;             /* destination address */
1048
 
        sif->smt.smt_tid = tid ;                /* transaction ID */
1049
 
        smt_add_frame_len(mb,len) ;             /* adjust length fields */
1050
 
        dump_smt(smc,(struct smt_header *)sif,"SIF Configuration Reply") ;
1051
 
        smt_send_frame(smc,mb,FC_SMT_INFO,local) ;
1052
 
}
1053
 
 
1054
 
/*
1055
 
 * generate and send SIF operation response
1056
 
 */
1057
 
 
1058
 
static void smt_send_sif_operation(struct s_smc *smc, struct fddi_addr *dest,
1059
 
                                   u_long tid, int local)
1060
 
/* struct fddi_addr *dest;      dest address */
1061
 
/* u_long tid;                  transaction id */
1062
 
{
1063
 
        struct smt_sif_operation *sif ;
1064
 
        SMbuf                   *mb ;
1065
 
        int                     ports ;
1066
 
        int                     i ;
1067
 
 
1068
 
        ports = NUMPHYS ;
1069
 
#ifndef CONCENTRATOR
1070
 
        if (smc->s.sas == SMT_SAS)
1071
 
                ports = 1 ;
1072
 
#endif
1073
 
 
1074
 
        if (!(mb = smt_build_frame(smc,SMT_SIF_OPER,SMT_REPLY,
1075
 
                SIZEOF_SMT_SIF_OPERATION+ports*sizeof(struct smt_p_lem))))
1076
 
                return ;
1077
 
        sif = smtod(mb, struct smt_sif_operation *) ;
1078
 
        smt_fill_timestamp(smc,&sif->ts) ;      /* set time stamp */
1079
 
        smt_fill_mac_status(smc,&sif->status) ; /* set mac status */
1080
 
        smt_fill_mac_counter(smc,&sif->mc) ; /* set mac counter field */
1081
 
        smt_fill_mac_fnc(smc,&sif->fnc) ; /* set frame not copied counter */
1082
 
        smt_fill_manufacturer(smc,&sif->man) ; /* set manufacturer field */
1083
 
        smt_fill_user(smc,&sif->user) ;         /* set user field */
1084
 
        smt_fill_setcount(smc,&sif->setcount) ; /* set count */
1085
 
        /*
1086
 
         * set link error mon information
1087
 
         */
1088
 
        if (ports == 1) {
1089
 
                smt_fill_lem(smc,sif->lem,PS) ;
1090
 
        }
1091
 
        else {
1092
 
                for (i = 0 ; i < ports ; i++) {
1093
 
                        smt_fill_lem(smc,&sif->lem[i],i) ;
1094
 
                }
1095
 
        }
1096
 
 
1097
 
        sif->smt.smt_dest = *dest ;     /* destination address */
1098
 
        sif->smt.smt_tid = tid ;        /* transaction ID */
1099
 
        dump_smt(smc,(struct smt_header *)sif,"SIF Operation Reply") ;
1100
 
        smt_send_frame(smc,mb,FC_SMT_INFO,local) ;
1101
 
}
1102
 
 
1103
 
/*
1104
 
 * get and initialize SMT frame
1105
 
 */
1106
 
SMbuf *smt_build_frame(struct s_smc *smc, int class, int type,
1107
 
                                  int length)
1108
 
{
1109
 
        SMbuf                   *mb ;
1110
 
        struct smt_header       *smt ;
1111
 
 
1112
 
#if     0
1113
 
        if (!smc->r.sm_ma_avail) {
1114
 
                return 0;
1115
 
        }
1116
 
#endif
1117
 
        if (!(mb = smt_get_mbuf(smc)))
1118
 
                return mb;
1119
 
 
1120
 
        mb->sm_len = length ;
1121
 
        smt = smtod(mb, struct smt_header *) ;
1122
 
        smt->smt_dest = fddi_broadcast ; /* set dest = broadcast */
1123
 
        smt->smt_class = class ;
1124
 
        smt->smt_type = type ;
1125
 
        switch (class) {
1126
 
        case SMT_NIF :
1127
 
        case SMT_SIF_CONFIG :
1128
 
        case SMT_SIF_OPER :
1129
 
        case SMT_ECF :
1130
 
                smt->smt_version = SMT_VID ;
1131
 
                break ;
1132
 
        default :
1133
 
                smt->smt_version = SMT_VID_2 ;
1134
 
                break ;
1135
 
        }
1136
 
        smt->smt_tid = smt_get_tid(smc) ;       /* set transaction ID */
1137
 
        smt->smt_pad = 0 ;
1138
 
        smt->smt_len = length - sizeof(struct smt_header) ;
1139
 
        return mb;
1140
 
}
1141
 
 
1142
 
static void smt_add_frame_len(SMbuf *mb, int len)
1143
 
{
1144
 
        struct smt_header       *smt ;
1145
 
 
1146
 
        smt = smtod(mb, struct smt_header *) ;
1147
 
        smt->smt_len += len ;
1148
 
        mb->sm_len += len ;
1149
 
}
1150
 
 
1151
 
 
1152
 
 
1153
 
/*
1154
 
 * fill values in UNA parameter
1155
 
 */
1156
 
static void smt_fill_una(struct s_smc *smc, struct smt_p_una *una)
1157
 
{
1158
 
        SMTSETPARA(una,SMT_P_UNA) ;
1159
 
        una->una_pad = 0 ;
1160
 
        una->una_node = smc->mib.m[MAC0].fddiMACUpstreamNbr ;
1161
 
}
1162
 
 
1163
 
/*
1164
 
 * fill values in SDE parameter
1165
 
 */
1166
 
static void smt_fill_sde(struct s_smc *smc, struct smt_p_sde *sde)
1167
 
{
1168
 
        SMTSETPARA(sde,SMT_P_SDE) ;
1169
 
        sde->sde_non_master = smc->mib.fddiSMTNonMaster_Ct ;
1170
 
        sde->sde_master = smc->mib.fddiSMTMaster_Ct ;
1171
 
        sde->sde_mac_count = NUMMACS ;          /* only 1 MAC */
1172
 
#ifdef  CONCENTRATOR
1173
 
        sde->sde_type = SMT_SDE_CONCENTRATOR ;
1174
 
#else
1175
 
        sde->sde_type = SMT_SDE_STATION ;
1176
 
#endif
1177
 
}
1178
 
 
1179
 
/*
1180
 
 * fill in values in station state parameter
1181
 
 */
1182
 
static void smt_fill_state(struct s_smc *smc, struct smt_p_state *state)
1183
 
{
1184
 
        int     top ;
1185
 
        int     twist ;
1186
 
 
1187
 
        SMTSETPARA(state,SMT_P_STATE) ;
1188
 
        state->st_pad = 0 ;
1189
 
 
1190
 
        /* determine topology */
1191
 
        top = 0 ;
1192
 
        if (smc->mib.fddiSMTPeerWrapFlag) {
1193
 
                top |= SMT_ST_WRAPPED ;         /* state wrapped */
1194
 
        }
1195
 
#ifdef  CONCENTRATOR
1196
 
        if (cfm_status_unattached(smc)) {
1197
 
                top |= SMT_ST_UNATTACHED ;      /* unattached concentrator */
1198
 
        }
1199
 
#endif
1200
 
        if ((twist = pcm_status_twisted(smc)) & 1) {
1201
 
                top |= SMT_ST_TWISTED_A ;       /* twisted cable */
1202
 
        }
1203
 
        if (twist & 2) {
1204
 
                top |= SMT_ST_TWISTED_B ;       /* twisted cable */
1205
 
        }
1206
 
#ifdef  OPT_SRF
1207
 
        top |= SMT_ST_SRF ;
1208
 
#endif
1209
 
        if (pcm_rooted_station(smc))
1210
 
                top |= SMT_ST_ROOTED_S ;
1211
 
        if (smc->mib.a[0].fddiPATHSbaPayload != 0)
1212
 
                top |= SMT_ST_SYNC_SERVICE ;
1213
 
        state->st_topology = top ;
1214
 
        state->st_dupl_addr =
1215
 
                ((smc->mib.m[MAC0].fddiMACDA_Flag ? SMT_ST_MY_DUPA : 0 ) |
1216
 
                 (smc->mib.m[MAC0].fddiMACUNDA_Flag ? SMT_ST_UNA_DUPA : 0)) ;
1217
 
}
1218
 
 
1219
 
/*
1220
 
 * fill values in timestamp parameter
1221
 
 */
1222
 
static void smt_fill_timestamp(struct s_smc *smc, struct smt_p_timestamp *ts)
1223
 
{
1224
 
 
1225
 
        SMTSETPARA(ts,SMT_P_TIMESTAMP) ;
1226
 
        smt_set_timestamp(smc,ts->ts_time) ;
1227
 
}
1228
 
 
1229
 
void smt_set_timestamp(struct s_smc *smc, u_char *p)
1230
 
{
1231
 
        u_long  time ;
1232
 
        u_long  utime ;
1233
 
 
1234
 
        /*
1235
 
         * timestamp is 64 bits long ; resolution is 80 nS
1236
 
         * our clock resolution is 10mS
1237
 
         * 10mS/80ns = 125000 ~ 2^17 = 131072
1238
 
         */
1239
 
        utime = smt_get_time() ;
1240
 
        time = utime * 100 ;
1241
 
        time /= TICKS_PER_SECOND ;
1242
 
        p[0] = 0 ;
1243
 
        p[1] = (u_char)((time>>(8+8+8+8-1)) & 1) ;
1244
 
        p[2] = (u_char)(time>>(8+8+8-1)) ;
1245
 
        p[3] = (u_char)(time>>(8+8-1)) ;
1246
 
        p[4] = (u_char)(time>>(8-1)) ;
1247
 
        p[5] = (u_char)(time<<1) ;
1248
 
        p[6] = (u_char)(smc->sm.uniq_ticks>>8) ;
1249
 
        p[7] = (u_char)smc->sm.uniq_ticks ;
1250
 
        /*
1251
 
         * make sure we don't wrap: restart whenever the upper digits change
1252
 
         */
1253
 
        if (utime != smc->sm.uniq_time) {
1254
 
                smc->sm.uniq_ticks = 0 ;
1255
 
        }
1256
 
        smc->sm.uniq_ticks++ ;
1257
 
        smc->sm.uniq_time = utime ;
1258
 
}
1259
 
 
1260
 
/*
1261
 
 * fill values in station policy parameter
1262
 
 */
1263
 
static void smt_fill_policy(struct s_smc *smc, struct smt_p_policy *policy)
1264
 
{
1265
 
        int     i ;
1266
 
        const u_char *map ;
1267
 
        u_short in ;
1268
 
        u_short out ;
1269
 
 
1270
 
        /*
1271
 
         * MIB para 101b (fddiSMTConnectionPolicy) coding
1272
 
         * is different from 0005 coding
1273
 
         */
1274
 
        static const u_char ansi_weirdness[16] = {
1275
 
                0,7,5,3,8,1,6,4,9,10,2,11,12,13,14,15
1276
 
        } ;
1277
 
        SMTSETPARA(policy,SMT_P_POLICY) ;
1278
 
 
1279
 
        out = 0 ;
1280
 
        in = smc->mib.fddiSMTConnectionPolicy ;
1281
 
        for (i = 0, map = ansi_weirdness ; i < 16 ; i++) {
1282
 
                if (in & 1)
1283
 
                        out |= (1<<*map) ;
1284
 
                in >>= 1 ;
1285
 
                map++ ;
1286
 
        }
1287
 
        policy->pl_config = smc->mib.fddiSMTConfigPolicy ;
1288
 
        policy->pl_connect = out ;
1289
 
}
1290
 
 
1291
 
/*
1292
 
 * fill values in latency equivalent parameter
1293
 
 */
1294
 
static void smt_fill_latency(struct s_smc *smc, struct smt_p_latency *latency)
1295
 
{
1296
 
        SMTSETPARA(latency,SMT_P_LATENCY) ;
1297
 
 
1298
 
        latency->lt_phyout_idx1 = phy_index(smc,0) ;
1299
 
        latency->lt_latency1 = 10 ;     /* in octets (byte clock) */
1300
 
        /*
1301
 
         * note: latency has two phy entries by definition
1302
 
         * for a SAS, the 2nd one is null
1303
 
         */
1304
 
        if (smc->s.sas == SMT_DAS) {
1305
 
                latency->lt_phyout_idx2 = phy_index(smc,1) ;
1306
 
                latency->lt_latency2 = 10 ;     /* in octets (byte clock) */
1307
 
        }
1308
 
        else {
1309
 
                latency->lt_phyout_idx2 = 0 ;
1310
 
                latency->lt_latency2 = 0 ;
1311
 
        }
1312
 
}
1313
 
 
1314
 
/*
1315
 
 * fill values in MAC neighbors parameter
1316
 
 */
1317
 
static void smt_fill_neighbor(struct s_smc *smc, struct smt_p_neighbor *neighbor)
1318
 
{
1319
 
        SMTSETPARA(neighbor,SMT_P_NEIGHBORS) ;
1320
 
 
1321
 
        neighbor->nb_mib_index = INDEX_MAC ;
1322
 
        neighbor->nb_mac_index = mac_index(smc,1) ;
1323
 
        neighbor->nb_una = smc->mib.m[MAC0].fddiMACUpstreamNbr ;
1324
 
        neighbor->nb_dna = smc->mib.m[MAC0].fddiMACDownstreamNbr ;
1325
 
}
1326
 
 
1327
 
/*
1328
 
 * fill values in path descriptor
1329
 
 */
1330
 
#ifdef  CONCENTRATOR
1331
 
#define ALLPHYS NUMPHYS
1332
 
#else
1333
 
#define ALLPHYS ((smc->s.sas == SMT_SAS) ? 1 : 2)
1334
 
#endif
1335
 
 
1336
 
static int smt_fill_path(struct s_smc *smc, struct smt_p_path *path)
1337
 
{
1338
 
        SK_LOC_DECL(int,type) ;
1339
 
        SK_LOC_DECL(int,state) ;
1340
 
        SK_LOC_DECL(int,remote) ;
1341
 
        SK_LOC_DECL(int,mac) ;
1342
 
        int     len ;
1343
 
        int     p ;
1344
 
        int     physp ;
1345
 
        struct smt_phy_rec      *phy ;
1346
 
        struct smt_mac_rec      *pd_mac ;
1347
 
 
1348
 
        len =   PARA_LEN +
1349
 
                sizeof(struct smt_mac_rec) * NUMMACS +
1350
 
                sizeof(struct smt_phy_rec) * ALLPHYS ;
1351
 
        path->para.p_type = SMT_P_PATH ;
1352
 
        path->para.p_len = len - PARA_LEN ;
1353
 
 
1354
 
        /* PHYs */
1355
 
        for (p = 0,phy = path->pd_phy ; p < ALLPHYS ; p++, phy++) {
1356
 
                physp = p ;
1357
 
#ifndef CONCENTRATOR
1358
 
                if (smc->s.sas == SMT_SAS)
1359
 
                        physp = PS ;
1360
 
#endif
1361
 
                pcm_status_state(smc,physp,&type,&state,&remote,&mac) ;
1362
 
#ifdef  LITTLE_ENDIAN
1363
 
                phy->phy_mib_index = smt_swap_short((u_short)p+INDEX_PORT) ;
1364
 
#else
1365
 
                phy->phy_mib_index = p+INDEX_PORT ;
1366
 
#endif
1367
 
                phy->phy_type = type ;
1368
 
                phy->phy_connect_state = state ;
1369
 
                phy->phy_remote_type = remote ;
1370
 
                phy->phy_remote_mac = mac ;
1371
 
                phy->phy_resource_idx = phy_con_resource_index(smc,p) ;
1372
 
        }
1373
 
 
1374
 
        /* MAC */
1375
 
        pd_mac = (struct smt_mac_rec *) phy ;
1376
 
        pd_mac->mac_addr = smc->mib.m[MAC0].fddiMACSMTAddress ;
1377
 
        pd_mac->mac_resource_idx = mac_con_resource_index(smc,1) ;
1378
 
        return len;
1379
 
}
1380
 
 
1381
 
/*
1382
 
 * fill values in mac status
1383
 
 */
1384
 
static void smt_fill_mac_status(struct s_smc *smc, struct smt_p_mac_status *st)
1385
 
{
1386
 
        SMTSETPARA(st,SMT_P_MAC_STATUS) ;
1387
 
 
1388
 
        st->st_mib_index = INDEX_MAC ;
1389
 
        st->st_mac_index = mac_index(smc,1) ;
1390
 
 
1391
 
        mac_update_counter(smc) ;
1392
 
        /*
1393
 
         * timer values are represented in SMT as 2's complement numbers
1394
 
         * units :      internal :  2's complement BCLK
1395
 
         */
1396
 
        st->st_t_req = smc->mib.m[MAC0].fddiMACT_Req ;
1397
 
        st->st_t_neg = smc->mib.m[MAC0].fddiMACT_Neg ;
1398
 
        st->st_t_max = smc->mib.m[MAC0].fddiMACT_Max ;
1399
 
        st->st_tvx_value = smc->mib.m[MAC0].fddiMACTvxValue ;
1400
 
        st->st_t_min = smc->mib.m[MAC0].fddiMACT_Min ;
1401
 
 
1402
 
        st->st_sba = smc->mib.a[PATH0].fddiPATHSbaPayload ;
1403
 
        st->st_frame_ct = smc->mib.m[MAC0].fddiMACFrame_Ct ;
1404
 
        st->st_error_ct = smc->mib.m[MAC0].fddiMACError_Ct ;
1405
 
        st->st_lost_ct = smc->mib.m[MAC0].fddiMACLost_Ct ;
1406
 
}
1407
 
 
1408
 
/*
1409
 
 * fill values in LEM status
1410
 
 */
1411
 
static void smt_fill_lem(struct s_smc *smc, struct smt_p_lem *lem, int phy)
1412
 
{
1413
 
        struct fddi_mib_p       *mib ;
1414
 
 
1415
 
        mib = smc->y[phy].mib ;
1416
 
 
1417
 
        SMTSETPARA(lem,SMT_P_LEM) ;
1418
 
        lem->lem_mib_index = phy+INDEX_PORT ;
1419
 
        lem->lem_phy_index = phy_index(smc,phy) ;
1420
 
        lem->lem_pad2 = 0 ;
1421
 
        lem->lem_cutoff = mib->fddiPORTLer_Cutoff ;
1422
 
        lem->lem_alarm = mib->fddiPORTLer_Alarm ;
1423
 
        /* long term bit error rate */
1424
 
        lem->lem_estimate = mib->fddiPORTLer_Estimate ;
1425
 
        /* # of rejected connections */
1426
 
        lem->lem_reject_ct = mib->fddiPORTLem_Reject_Ct ;
1427
 
        lem->lem_ct = mib->fddiPORTLem_Ct ;     /* total number of errors */
1428
 
}
1429
 
 
1430
 
/*
1431
 
 * fill version parameter
1432
 
 */
1433
 
static void smt_fill_version(struct s_smc *smc, struct smt_p_version *vers)
1434
 
{
1435
 
        SK_UNUSED(smc) ;
1436
 
        SMTSETPARA(vers,SMT_P_VERSION) ;
1437
 
        vers->v_pad = 0 ;
1438
 
        vers->v_n = 1 ;                         /* one version is enough .. */
1439
 
        vers->v_index = 1 ;
1440
 
        vers->v_version[0] = SMT_VID_2 ;
1441
 
        vers->v_pad2 = 0 ;
1442
 
}
1443
 
 
1444
 
#ifdef  SMT6_10
1445
 
/*
1446
 
 * fill frame status capabilities
1447
 
 */
1448
 
/*
1449
 
 * note: this para 200B is NOT in swap table, because it's also set in
1450
 
 * PMF add_para
1451
 
 */
1452
 
static void smt_fill_fsc(struct s_smc *smc, struct smt_p_fsc *fsc)
1453
 
{
1454
 
        SK_UNUSED(smc) ;
1455
 
        SMTSETPARA(fsc,SMT_P_FSC) ;
1456
 
        fsc->fsc_pad0 = 0 ;
1457
 
        fsc->fsc_mac_index = INDEX_MAC ;        /* this is MIB ; MIB is NOT
1458
 
                                                 * mac_index ()i !
1459
 
                                                 */
1460
 
        fsc->fsc_pad1 = 0 ;
1461
 
        fsc->fsc_value = FSC_TYPE0 ;            /* "normal" node */
1462
 
#ifdef  LITTLE_ENDIAN
1463
 
        fsc->fsc_mac_index = smt_swap_short(INDEX_MAC) ;
1464
 
        fsc->fsc_value = smt_swap_short(FSC_TYPE0) ;
1465
 
#endif
1466
 
}
1467
 
#endif
1468
 
 
1469
 
/*
1470
 
 * fill mac counter field
1471
 
 */
1472
 
static void smt_fill_mac_counter(struct s_smc *smc, struct smt_p_mac_counter *mc)
1473
 
{
1474
 
        SMTSETPARA(mc,SMT_P_MAC_COUNTER) ;
1475
 
        mc->mc_mib_index = INDEX_MAC ;
1476
 
        mc->mc_index = mac_index(smc,1) ;
1477
 
        mc->mc_receive_ct = smc->mib.m[MAC0].fddiMACCopied_Ct ;
1478
 
        mc->mc_transmit_ct =  smc->mib.m[MAC0].fddiMACTransmit_Ct ;
1479
 
}
1480
 
 
1481
 
/*
1482
 
 * fill mac frame not copied counter
1483
 
 */
1484
 
static void smt_fill_mac_fnc(struct s_smc *smc, struct smt_p_mac_fnc *fnc)
1485
 
{
1486
 
        SMTSETPARA(fnc,SMT_P_MAC_FNC) ;
1487
 
        fnc->nc_mib_index = INDEX_MAC ;
1488
 
        fnc->nc_index = mac_index(smc,1) ;
1489
 
        fnc->nc_counter = smc->mib.m[MAC0].fddiMACNotCopied_Ct ;
1490
 
}
1491
 
 
1492
 
 
1493
 
/*
1494
 
 * fill manufacturer field
1495
 
 */
1496
 
static void smt_fill_manufacturer(struct s_smc *smc, 
1497
 
                                  struct smp_p_manufacturer *man)
1498
 
{
1499
 
        SMTSETPARA(man,SMT_P_MANUFACTURER) ;
1500
 
        memcpy((char *) man->mf_data,
1501
 
                (char *) smc->mib.fddiSMTManufacturerData,
1502
 
                sizeof(man->mf_data)) ;
1503
 
}
1504
 
 
1505
 
/*
1506
 
 * fill user field
1507
 
 */
1508
 
static void smt_fill_user(struct s_smc *smc, struct smp_p_user *user)
1509
 
{
1510
 
        SMTSETPARA(user,SMT_P_USER) ;
1511
 
        memcpy((char *) user->us_data,
1512
 
                (char *) smc->mib.fddiSMTUserData,
1513
 
                sizeof(user->us_data)) ;
1514
 
}
1515
 
 
1516
 
/*
1517
 
 * fill set count
1518
 
 */
1519
 
static void smt_fill_setcount(struct s_smc *smc, struct smt_p_setcount *setcount)
1520
 
{
1521
 
        SK_UNUSED(smc) ;
1522
 
        SMTSETPARA(setcount,SMT_P_SETCOUNT) ;
1523
 
        setcount->count = smc->mib.fddiSMTSetCount.count ;
1524
 
        memcpy((char *)setcount->timestamp,
1525
 
                (char *)smc->mib.fddiSMTSetCount.timestamp,8) ;
1526
 
}
1527
 
 
1528
 
/*
1529
 
 * fill echo data
1530
 
 */
1531
 
static void smt_fill_echo(struct s_smc *smc, struct smt_p_echo *echo, u_long seed,
1532
 
                          int len)
1533
 
{
1534
 
        u_char  *p ;
1535
 
 
1536
 
        SK_UNUSED(smc) ;
1537
 
        SMTSETPARA(echo,SMT_P_ECHODATA) ;
1538
 
        echo->para.p_len = len ;
1539
 
        for (p = echo->ec_data ; len ; len--) {
1540
 
                *p++ = (u_char) seed ;
1541
 
                seed += 13 ;
1542
 
        }
1543
 
}
1544
 
 
1545
 
/*
1546
 
 * clear DNA and UNA
1547
 
 * called from CFM if configuration changes
1548
 
 */
1549
 
static void smt_clear_una_dna(struct s_smc *smc)
1550
 
{
1551
 
        smc->mib.m[MAC0].fddiMACUpstreamNbr = SMT_Unknown ;
1552
 
        smc->mib.m[MAC0].fddiMACDownstreamNbr = SMT_Unknown ;
1553
 
}
1554
 
 
1555
 
static void smt_clear_old_una_dna(struct s_smc *smc)
1556
 
{
1557
 
        smc->mib.m[MAC0].fddiMACOldUpstreamNbr = SMT_Unknown ;
1558
 
        smc->mib.m[MAC0].fddiMACOldDownstreamNbr = SMT_Unknown ;
1559
 
}
1560
 
 
1561
 
u_long smt_get_tid(struct s_smc *smc)
1562
 
{
1563
 
        u_long  tid ;
1564
 
        while ((tid = ++(smc->sm.smt_tid) ^ SMT_TID_MAGIC) == 0)
1565
 
                ;
1566
 
        return tid & 0x3fffffffL;
1567
 
}
1568
 
 
1569
 
 
1570
 
/*
1571
 
 * table of parameter lengths
1572
 
 */
1573
 
static const struct smt_pdef {
1574
 
        int     ptype ;
1575
 
        int     plen ;
1576
 
        const char      *pswap ;
1577
 
} smt_pdef[] = {
1578
 
        { SMT_P_UNA,    sizeof(struct smt_p_una) ,
1579
 
                SWAP_SMT_P_UNA                                  } ,
1580
 
        { SMT_P_SDE,    sizeof(struct smt_p_sde) ,
1581
 
                SWAP_SMT_P_SDE                                  } ,
1582
 
        { SMT_P_STATE,  sizeof(struct smt_p_state) ,
1583
 
                SWAP_SMT_P_STATE                                } ,
1584
 
        { SMT_P_TIMESTAMP,sizeof(struct smt_p_timestamp) ,
1585
 
                SWAP_SMT_P_TIMESTAMP                            } ,
1586
 
        { SMT_P_POLICY, sizeof(struct smt_p_policy) ,
1587
 
                SWAP_SMT_P_POLICY                               } ,
1588
 
        { SMT_P_LATENCY,        sizeof(struct smt_p_latency) ,
1589
 
                SWAP_SMT_P_LATENCY                              } ,
1590
 
        { SMT_P_NEIGHBORS,sizeof(struct smt_p_neighbor) ,
1591
 
                SWAP_SMT_P_NEIGHBORS                            } ,
1592
 
        { SMT_P_PATH,   sizeof(struct smt_p_path) ,
1593
 
                SWAP_SMT_P_PATH                                 } ,
1594
 
        { SMT_P_MAC_STATUS,sizeof(struct smt_p_mac_status) ,
1595
 
                SWAP_SMT_P_MAC_STATUS                           } ,
1596
 
        { SMT_P_LEM,    sizeof(struct smt_p_lem) ,
1597
 
                SWAP_SMT_P_LEM                                  } ,
1598
 
        { SMT_P_MAC_COUNTER,sizeof(struct smt_p_mac_counter) ,
1599
 
                SWAP_SMT_P_MAC_COUNTER                          } ,
1600
 
        { SMT_P_MAC_FNC,sizeof(struct smt_p_mac_fnc) ,
1601
 
                SWAP_SMT_P_MAC_FNC                              } ,
1602
 
        { SMT_P_PRIORITY,sizeof(struct smt_p_priority) ,
1603
 
                SWAP_SMT_P_PRIORITY                             } ,
1604
 
        { SMT_P_EB,sizeof(struct smt_p_eb) ,
1605
 
                SWAP_SMT_P_EB                                   } ,
1606
 
        { SMT_P_MANUFACTURER,sizeof(struct smp_p_manufacturer) ,
1607
 
                SWAP_SMT_P_MANUFACTURER                         } ,
1608
 
        { SMT_P_REASON, sizeof(struct smt_p_reason) ,
1609
 
                SWAP_SMT_P_REASON                               } ,
1610
 
        { SMT_P_REFUSED, sizeof(struct smt_p_refused) ,
1611
 
                SWAP_SMT_P_REFUSED                              } ,
1612
 
        { SMT_P_VERSION, sizeof(struct smt_p_version) ,
1613
 
                SWAP_SMT_P_VERSION                              } ,
1614
 
#ifdef ESS
1615
 
        { SMT_P0015, sizeof(struct smt_p_0015) , SWAP_SMT_P0015 } ,
1616
 
        { SMT_P0016, sizeof(struct smt_p_0016) , SWAP_SMT_P0016 } ,
1617
 
        { SMT_P0017, sizeof(struct smt_p_0017) , SWAP_SMT_P0017 } ,
1618
 
        { SMT_P0018, sizeof(struct smt_p_0018) , SWAP_SMT_P0018 } ,
1619
 
        { SMT_P0019, sizeof(struct smt_p_0019) , SWAP_SMT_P0019 } ,
1620
 
        { SMT_P001A, sizeof(struct smt_p_001a) , SWAP_SMT_P001A } ,
1621
 
        { SMT_P001B, sizeof(struct smt_p_001b) , SWAP_SMT_P001B } ,
1622
 
        { SMT_P001C, sizeof(struct smt_p_001c) , SWAP_SMT_P001C } ,
1623
 
        { SMT_P001D, sizeof(struct smt_p_001d) , SWAP_SMT_P001D } ,
1624
 
#endif
1625
 
#if     0
1626
 
        { SMT_P_FSC,    sizeof(struct smt_p_fsc) ,
1627
 
                SWAP_SMT_P_FSC                                  } ,
1628
 
#endif
1629
 
 
1630
 
        { SMT_P_SETCOUNT,0,     SWAP_SMT_P_SETCOUNT             } ,
1631
 
        { SMT_P1048,    0,      SWAP_SMT_P1048                  } ,
1632
 
        { SMT_P208C,    0,      SWAP_SMT_P208C                  } ,
1633
 
        { SMT_P208D,    0,      SWAP_SMT_P208D                  } ,
1634
 
        { SMT_P208E,    0,      SWAP_SMT_P208E                  } ,
1635
 
        { SMT_P208F,    0,      SWAP_SMT_P208F                  } ,
1636
 
        { SMT_P2090,    0,      SWAP_SMT_P2090                  } ,
1637
 
#ifdef  ESS
1638
 
        { SMT_P320B, sizeof(struct smt_p_320b) , SWAP_SMT_P320B } ,
1639
 
        { SMT_P320F, sizeof(struct smt_p_320f) , SWAP_SMT_P320F } ,
1640
 
        { SMT_P3210, sizeof(struct smt_p_3210) , SWAP_SMT_P3210 } ,
1641
 
#endif
1642
 
        { SMT_P4050,    0,      SWAP_SMT_P4050                  } ,
1643
 
        { SMT_P4051,    0,      SWAP_SMT_P4051                  } ,
1644
 
        { SMT_P4052,    0,      SWAP_SMT_P4052                  } ,
1645
 
        { SMT_P4053,    0,      SWAP_SMT_P4053                  } ,
1646
 
} ;
1647
 
 
1648
 
#define N_SMT_PLEN      ARRAY_SIZE(smt_pdef)
1649
 
 
1650
 
int smt_check_para(struct s_smc *smc, struct smt_header *sm,
1651
 
                   const u_short list[])
1652
 
{
1653
 
        const u_short           *p = list ;
1654
 
        while (*p) {
1655
 
                if (!sm_to_para(smc,sm,(int) *p)) {
1656
 
                        DB_SMT("SMT: smt_check_para - missing para %x\n",*p,0);
1657
 
                        return -1;
1658
 
                }
1659
 
                p++ ;
1660
 
        }
1661
 
        return 0;
1662
 
}
1663
 
 
1664
 
void *sm_to_para(struct s_smc *smc, struct smt_header *sm, int para)
1665
 
{
1666
 
        char    *p ;
1667
 
        int     len ;
1668
 
        int     plen ;
1669
 
        void    *found = NULL;
1670
 
 
1671
 
        SK_UNUSED(smc) ;
1672
 
 
1673
 
        len = sm->smt_len ;
1674
 
        p = (char *)(sm+1) ;            /* pointer to info */
1675
 
        while (len > 0 ) {
1676
 
                if (((struct smt_para *)p)->p_type == para)
1677
 
                        found = (void *) p ;
1678
 
                plen = ((struct smt_para *)p)->p_len + PARA_LEN ;
1679
 
                p += plen ;
1680
 
                len -= plen ;
1681
 
                if (len < 0) {
1682
 
                        DB_SMT("SMT : sm_to_para - length error %d\n",plen,0) ;
1683
 
                        return NULL;
1684
 
                }
1685
 
                if ((plen & 3) && (para != SMT_P_ECHODATA)) {
1686
 
                        DB_SMT("SMT : sm_to_para - odd length %d\n",plen,0) ;
1687
 
                        return NULL;
1688
 
                }
1689
 
                if (found)
1690
 
                        return found;
1691
 
        }
1692
 
        return NULL;
1693
 
}
1694
 
 
1695
 
#if     0
1696
 
/*
1697
 
 * send ANTC data test frame
1698
 
 */
1699
 
void fddi_send_antc(struct s_smc *smc, struct fddi_addr *dest)
1700
 
{
1701
 
        SK_UNUSED(smc) ;
1702
 
        SK_UNUSED(dest) ;
1703
 
#if     0
1704
 
        SMbuf                   *mb ;
1705
 
        struct smt_header       *smt ;
1706
 
        int                     i ;
1707
 
        char                    *p ;
1708
 
 
1709
 
        mb = smt_get_mbuf() ;
1710
 
        mb->sm_len = 3000+12 ;
1711
 
        p = smtod(mb, char *) + 12 ;
1712
 
        for (i = 0 ; i < 3000 ; i++)
1713
 
                *p++ = 1 << (i&7) ;
1714
 
 
1715
 
        smt = smtod(mb, struct smt_header *) ;
1716
 
        smt->smt_dest = *dest ;
1717
 
        smt->smt_source = smc->mib.m[MAC0].fddiMACSMTAddress ;
1718
 
        smt_send_mbuf(smc,mb,FC_ASYNC_LLC) ;
1719
 
#endif
1720
 
}
1721
 
#endif
1722
 
 
1723
 
#ifdef  DEBUG
1724
 
char *addr_to_string(struct fddi_addr *addr)
1725
 
{
1726
 
        int     i ;
1727
 
        static char     string[6*3] = "****" ;
1728
 
 
1729
 
        for (i = 0 ; i < 6 ; i++) {
1730
 
                string[i * 3] = hex_asc_hi(addr->a[i]);
1731
 
                string[i * 3 + 1] = hex_asc_lo(addr->a[i]);
1732
 
                string[i * 3 + 2] = ':';
1733
 
        }
1734
 
        string[5 * 3 + 2] = 0;
1735
 
        return string;
1736
 
}
1737
 
#endif
1738
 
 
1739
 
#ifdef  AM29K
1740
 
int smt_ifconfig(int argc, char *argv[])
1741
 
{
1742
 
        if (argc >= 2 && !strcmp(argv[0],"opt_bypass") &&
1743
 
            !strcmp(argv[1],"yes")) {
1744
 
                smc->mib.fddiSMTBypassPresent = 1 ;
1745
 
                return 0;
1746
 
        }
1747
 
        return amdfddi_config(0, argc, argv);
1748
 
}
1749
 
#endif
1750
 
 
1751
 
/*
1752
 
 * return static mac index
1753
 
 */
1754
 
static int mac_index(struct s_smc *smc, int mac)
1755
 
{
1756
 
        SK_UNUSED(mac) ;
1757
 
#ifdef  CONCENTRATOR
1758
 
        SK_UNUSED(smc) ;
1759
 
        return NUMPHYS + 1;
1760
 
#else
1761
 
        return (smc->s.sas == SMT_SAS) ? 2 : 3;
1762
 
#endif
1763
 
}
1764
 
 
1765
 
/*
1766
 
 * return static phy index
1767
 
 */
1768
 
static int phy_index(struct s_smc *smc, int phy)
1769
 
{
1770
 
        SK_UNUSED(smc) ;
1771
 
        return phy + 1;
1772
 
}
1773
 
 
1774
 
/*
1775
 
 * return dynamic mac connection resource index
1776
 
 */
1777
 
static int mac_con_resource_index(struct s_smc *smc, int mac)
1778
 
{
1779
 
#ifdef  CONCENTRATOR
1780
 
        SK_UNUSED(smc) ;
1781
 
        SK_UNUSED(mac) ;
1782
 
        return entity_to_index(smc, cem_get_downstream(smc, ENTITY_MAC));
1783
 
#else
1784
 
        SK_UNUSED(mac) ;
1785
 
        switch (smc->mib.fddiSMTCF_State) {
1786
 
        case SC9_C_WRAP_A :
1787
 
        case SC5_THRU_B :
1788
 
        case SC11_C_WRAP_S :
1789
 
                return 1;
1790
 
        case SC10_C_WRAP_B :
1791
 
        case SC4_THRU_A :
1792
 
                return 2;
1793
 
        }
1794
 
        return smc->s.sas == SMT_SAS ? 2 : 3;
1795
 
#endif
1796
 
}
1797
 
 
1798
 
/*
1799
 
 * return dynamic phy connection resource index
1800
 
 */
1801
 
static int phy_con_resource_index(struct s_smc *smc, int phy)
1802
 
{
1803
 
#ifdef  CONCENTRATOR
1804
 
        return entity_to_index(smc, cem_get_downstream(smc, ENTITY_PHY(phy))) ;
1805
 
#else
1806
 
        switch (smc->mib.fddiSMTCF_State) {
1807
 
        case SC9_C_WRAP_A :
1808
 
                return phy == PA ? 3 : 2;
1809
 
        case SC10_C_WRAP_B :
1810
 
                return phy == PA ? 1 : 3;
1811
 
        case SC4_THRU_A :
1812
 
                return phy == PA ? 3 : 1;
1813
 
        case SC5_THRU_B :
1814
 
                return phy == PA ? 2 : 3;
1815
 
        case SC11_C_WRAP_S :
1816
 
                return 2;
1817
 
        }
1818
 
        return phy;
1819
 
#endif
1820
 
}
1821
 
 
1822
 
#ifdef  CONCENTRATOR
1823
 
static int entity_to_index(struct s_smc *smc, int e)
1824
 
{
1825
 
        if (e == ENTITY_MAC)
1826
 
                return mac_index(smc, 1);
1827
 
        else
1828
 
                return phy_index(smc, e - ENTITY_PHY(0));
1829
 
}
1830
 
#endif
1831
 
 
1832
 
#ifdef  LITTLE_ENDIAN
1833
 
static int smt_swap_short(u_short s)
1834
 
{
1835
 
        return ((s>>8)&0xff) | ((s&0xff)<<8);
1836
 
}
1837
 
 
1838
 
void smt_swap_para(struct smt_header *sm, int len, int direction)
1839
 
/* int direction;       0 encode 1 decode */
1840
 
{
1841
 
        struct smt_para *pa ;
1842
 
        const  struct smt_pdef  *pd ;
1843
 
        char    *p ;
1844
 
        int     plen ;
1845
 
        int     type ;
1846
 
        int     i ;
1847
 
 
1848
 
/*      printf("smt_swap_para sm %x len %d dir %d\n",
1849
 
                sm,len,direction) ;
1850
 
 */
1851
 
        smt_string_swap((char *)sm,SWAP_SMTHEADER,len) ;
1852
 
 
1853
 
        /* swap args */
1854
 
        len -= sizeof(struct smt_header) ;
1855
 
 
1856
 
        p = (char *) (sm + 1) ;
1857
 
        while (len > 0) {
1858
 
                pa = (struct smt_para *) p ;
1859
 
                plen = pa->p_len ;
1860
 
                type = pa->p_type ;
1861
 
                pa->p_type = smt_swap_short(pa->p_type) ;
1862
 
                pa->p_len = smt_swap_short(pa->p_len) ;
1863
 
                if (direction) {
1864
 
                        plen = pa->p_len ;
1865
 
                        type = pa->p_type ;
1866
 
                }
1867
 
                /*
1868
 
                 * note: paras can have 0 length !
1869
 
                 */
1870
 
                if (plen < 0)
1871
 
                        break ;
1872
 
                plen += PARA_LEN ;
1873
 
                for (i = N_SMT_PLEN, pd = smt_pdef; i ; i--,pd++) {
1874
 
                        if (pd->ptype == type)
1875
 
                                break ;
1876
 
                }
1877
 
                if (i && pd->pswap) {
1878
 
                        smt_string_swap(p+PARA_LEN,pd->pswap,len) ;
1879
 
                }
1880
 
                len -= plen ;
1881
 
                p += plen ;
1882
 
        }
1883
 
}
1884
 
 
1885
 
static void smt_string_swap(char *data, const char *format, int len)
1886
 
{
1887
 
        const char      *open_paren = NULL ;
1888
 
        int     x ;
1889
 
 
1890
 
        while (len > 0  && *format) {
1891
 
                switch (*format) {
1892
 
                case '[' :
1893
 
                        open_paren = format ;
1894
 
                        break ;
1895
 
                case ']' :
1896
 
                        format = open_paren ;
1897
 
                        break ;
1898
 
                case '1' :
1899
 
                case '2' :
1900
 
                case '3' :
1901
 
                case '4' :
1902
 
                case '5' :
1903
 
                case '6' :
1904
 
                case '7' :
1905
 
                case '8' :
1906
 
                case '9' :
1907
 
                        data  += *format - '0' ;
1908
 
                        len   -= *format - '0' ;
1909
 
                        break ;
1910
 
                case 'c':
1911
 
                        data++ ;
1912
 
                        len-- ;
1913
 
                        break ;
1914
 
                case 's' :
1915
 
                        x = data[0] ;
1916
 
                        data[0] = data[1] ;
1917
 
                        data[1] = x ;
1918
 
                        data += 2 ;
1919
 
                        len -= 2 ;
1920
 
                        break ;
1921
 
                case 'l' :
1922
 
                        x = data[0] ;
1923
 
                        data[0] = data[3] ;
1924
 
                        data[3] = x ;
1925
 
                        x = data[1] ;
1926
 
                        data[1] = data[2] ;
1927
 
                        data[2] = x ;
1928
 
                        data += 4 ;
1929
 
                        len -= 4 ;
1930
 
                        break ;
1931
 
                }
1932
 
                format++ ;
1933
 
        }
1934
 
}
1935
 
#else
1936
 
void smt_swap_para(struct smt_header *sm, int len, int direction)
1937
 
/* int direction;       0 encode 1 decode */
1938
 
{
1939
 
        SK_UNUSED(sm) ;
1940
 
        SK_UNUSED(len) ;
1941
 
        SK_UNUSED(direction) ;
1942
 
}
1943
 
#endif
1944
 
 
1945
 
/*
1946
 
 * PMF actions
1947
 
 */
1948
 
int smt_action(struct s_smc *smc, int class, int code, int index)
1949
 
{
1950
 
        int     event ;
1951
 
        int     port ;
1952
 
        DB_SMT("SMT: action %d code %d\n",class,code) ;
1953
 
        switch(class) {
1954
 
        case SMT_STATION_ACTION :
1955
 
                switch(code) {
1956
 
                case SMT_STATION_ACTION_CONNECT :
1957
 
                        smc->mib.fddiSMTRemoteDisconnectFlag = FALSE ;
1958
 
                        queue_event(smc,EVENT_ECM,EC_CONNECT) ;
1959
 
                        break ;
1960
 
                case SMT_STATION_ACTION_DISCONNECT :
1961
 
                        queue_event(smc,EVENT_ECM,EC_DISCONNECT) ;
1962
 
                        smc->mib.fddiSMTRemoteDisconnectFlag = TRUE ;
1963
 
                        RS_SET(smc,RS_DISCONNECT) ;
1964
 
                        AIX_EVENT(smc, (u_long) FDDI_RING_STATUS, (u_long)
1965
 
                                FDDI_SMT_EVENT, (u_long) FDDI_REMOTE_DISCONNECT,
1966
 
                                smt_get_event_word(smc));
1967
 
                        break ;
1968
 
                case SMT_STATION_ACTION_PATHTEST :
1969
 
                        AIX_EVENT(smc, (u_long) FDDI_RING_STATUS, (u_long)
1970
 
                                FDDI_SMT_EVENT, (u_long) FDDI_PATH_TEST,
1971
 
                                smt_get_event_word(smc));
1972
 
                        break ;
1973
 
                case SMT_STATION_ACTION_SELFTEST :
1974
 
                        AIX_EVENT(smc, (u_long) FDDI_RING_STATUS, (u_long)
1975
 
                                FDDI_SMT_EVENT, (u_long) FDDI_REMOTE_SELF_TEST,
1976
 
                                smt_get_event_word(smc));
1977
 
                        break ;
1978
 
                case SMT_STATION_ACTION_DISABLE_A :
1979
 
                        if (smc->y[PA].pc_mode == PM_PEER) {
1980
 
                                RS_SET(smc,RS_EVENT) ;
1981
 
                                queue_event(smc,EVENT_PCM+PA,PC_DISABLE) ;
1982
 
                        }
1983
 
                        break ;
1984
 
                case SMT_STATION_ACTION_DISABLE_B :
1985
 
                        if (smc->y[PB].pc_mode == PM_PEER) {
1986
 
                                RS_SET(smc,RS_EVENT) ;
1987
 
                                queue_event(smc,EVENT_PCM+PB,PC_DISABLE) ;
1988
 
                        }
1989
 
                        break ;
1990
 
                case SMT_STATION_ACTION_DISABLE_M :
1991
 
                        for (port = 0 ; port <  NUMPHYS ; port++) {
1992
 
                                if (smc->mib.p[port].fddiPORTMy_Type != TM)
1993
 
                                        continue ;
1994
 
                                RS_SET(smc,RS_EVENT) ;
1995
 
                                queue_event(smc,EVENT_PCM+port,PC_DISABLE) ;
1996
 
                        }
1997
 
                        break ;
1998
 
                default :
1999
 
                        return 1;
2000
 
                }
2001
 
                break ;
2002
 
        case SMT_PORT_ACTION :
2003
 
                switch(code) {
2004
 
                case SMT_PORT_ACTION_ENABLE :
2005
 
                        event = PC_ENABLE ;
2006
 
                        break ;
2007
 
                case SMT_PORT_ACTION_DISABLE :
2008
 
                        event = PC_DISABLE ;
2009
 
                        break ;
2010
 
                case SMT_PORT_ACTION_MAINT :
2011
 
                        event = PC_MAINT ;
2012
 
                        break ;
2013
 
                case SMT_PORT_ACTION_START :
2014
 
                        event = PC_START ;
2015
 
                        break ;
2016
 
                case SMT_PORT_ACTION_STOP :
2017
 
                        event = PC_STOP ;
2018
 
                        break ;
2019
 
                default :
2020
 
                        return 1;
2021
 
                }
2022
 
                queue_event(smc,EVENT_PCM+index,event) ;
2023
 
                break ;
2024
 
        default :
2025
 
                return 1;
2026
 
        }
2027
 
        return 0;
2028
 
}
2029
 
 
2030
 
/*
2031
 
 * canonical conversion of <len> bytes beginning form *data
2032
 
 */
2033
 
#ifdef  USE_CAN_ADDR
2034
 
static void hwm_conv_can(struct s_smc *smc, char *data, int len)
2035
 
{
2036
 
        int i ;
2037
 
 
2038
 
        SK_UNUSED(smc) ;
2039
 
 
2040
 
        for (i = len; i ; i--, data++)
2041
 
                *data = bitrev8(*data);
2042
 
}
2043
 
#endif
2044
 
 
2045
 
#endif  /* no SLIM_SMT */
2046