xref: /titanic_41/usr/src/uts/common/sys/gldpriv.h (revision 605445d5657096e69d948ccb554c9ff024fa34df)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 /*
27  * gldpriv.h - Private interfaces/structures needed by gld.c
28  *
29  * The definitions in this file are private to GLD and may change at any time.
30  * They must not be used by any driver.
31  */
32 
33 #ifndef	_SYS_GLDPRIV_H
34 #define	_SYS_GLDPRIV_H
35 
36 #pragma ident	"%Z%%M%	%I%	%E% SMI"
37 
38 #ifdef	__cplusplus
39 extern "C" {
40 #endif
41 
42 #ifdef	DEBUG
43 #define	GLD_DEBUG 1
44 #endif
45 
46 /*
47  * The version number should not be changed.
48  */
49 #define	GLD_VERSION_200		0x200			/* version 2.0 */
50 #define	GLD_VERSION		GLD_VERSION_200		/* current version */
51 #define	GLD_VERSION_STRING	"v2"			/* in modinfo string */
52 
53 /* gld_global_options bits */
54 #define	GLD_OPT_NO_IPQ		0x00000001	/* don't use IP shortcut */
55 #define	GLD_OPT_NO_FASTPATH	0x00000002	/* don't implement fastpath */
56 #define	GLD_OPT_NO_ETHRXSNAP	0x00000008	/* don't interp SNAP on ether */
57 
58 /* gld per instance options */
59 #define	GLDOPT_FAST_RECV	0x40
60 #define	GLDOPT_CANONICAL_ADDR	0x08
61 #define	GLDOPT_MDT		0x100
62 
63 /*
64  * This version of GLD allows a "Virtual-LAN-PPA" to be specified in
65  * the same manner as Cassini: the virtual PPA number is composed of
66  * the VLAN tag number (1-4094), multiplied by 1000(!), plus the real
67  * (hardware) PPA.  Thus "bge23001" refers to the "device" which
68  * transports packets with tag VLAN "23" over the hardware of "bge1".
69  *
70  * This scheme limits the number of physical devices of a single type to
71  * 1000 e.g. bge0 .. bge999 (since bge1000 would instead be interpreted
72  * as VLAN1 over bge0).
73  */
74 #define	GLD_VLAN_SCALE		1000
75 #define	GLD_MAX_PPA		(GLD_VLAN_SCALE-1)
76 
77 /*
78  * Minor numbers:
79  *
80  * For each device type, GLD creates a single "style 2" node with minor 0.
81  * For each instance of that device type, GLD also creates a "style 1"
82  * node with minor number one greater than the PPA.  Thus, nodes with
83  * minor numbers 0..1000 may exist in the /dev* filesystem.
84  *
85  * So, on open:
86  *
87  * Minor 0 implies DLPI "style 2": the STREAM is not intrinsically
88  * associated with any particular device/PPA.  The association is set
89  * (and may be changed) dynamically, by DLPI_ATTACH/DETACH messages.
90  *
91  * Minors 1..1000 are "style 1", where the PPA is entirely defined by
92  * the minor; GLD defines the mapping as PPA=minor-1 (minor=PPA+1).
93  * Note that the upper bound of 1000 is (now) limited by the VLAN
94  * mapping scheme set out above.
95  *
96  * GLD devices are "self-cloning": each new open will cause a new minor
97  * number to be allocated; these are selected from the range 1001..0x3ffff.
98  * This minor number is only associated with the open stream and doesn't
99  * appear in the /dev* filesystem; manually created nodes with minors in
100  * this range will be rejected by gld_open().
101  */
102 #define	GLD_USE_STYLE2		0
103 
104 #define	GLD_MIN_STYLE1_MINOR	1
105 #define	GLD_MAX_STYLE1_MINOR	(GLD_MAX_PPA+1)
106 
107 #define	GLD_STYLE1_MINOR_TO_PPA(minor)	(minor - 1)
108 #define	GLD_STYLE1_PPA_TO_MINOR(ppa)	(ppa + 1)
109 
110 #define	GLD_MIN_CLONE_MINOR	(GLD_MAX_STYLE1_MINOR+1)
111 #define	GLD_MAX_CLONE_MINOR	0x3ffff
112 
113 /* gldm_GLD_flags */
114 #define	GLD_MAC_READY 0x0001	/* this mac has succeeded gld_register */
115 #define	GLD_INTR_READY 0x0001	/* v0 compat name */
116 #define	GLD_INTR_WAIT 0x0002	/* v1: waiting for interrupt to do scheduling */
117 #define	GLD_LOCK_INITED 0x0004	/* maclock is currently initialized */
118 #define	GLD_UNREGISTERED 0x0008	/* this mac has succeeded gld_unregister */
119 
120 /* This is the largest macaddr currently supported by GLD */
121 #define	GLD_MAX_ADDRLEN		32	/* Largest mac addr in all media  */
122 
123 #define	GLD_MAX_MULTICAST	64	/* default multicast table size */
124 
125 /* multicast structures */
126 typedef struct gld_multicast_addr {
127 	int		gldm_refcnt;	/* number of streams referring */
128 					/* to this per-mac entry */
129 	unsigned char	gldm_addr[GLD_MAX_ADDRLEN];
130 } gld_mcast_t;
131 
132 /* gld_flag bits -- GLD PRIVATE */
133 #define	GLD_RAW		0x0001	/* lower stream is in RAW mode */
134 #define	GLD_FAST	0x0002	/* use "fast" path */
135 #define	GLD_PROM_PHYS	0x0004	/* stream is in physical promiscuous mode */
136 #define	GLD_PROM_SAP	0x0008
137 #define	GLD_PROM_MULT	0x0010
138 #define	GLD_STR_CLOSING	0x0020	/* stream is closing; don't putnext */
139 
140 /*
141  * gld structure.  Used to define the per-stream information required to
142  * implement DLPI.
143  */
144 typedef struct gld {
145 	struct gld	*gld_next, *gld_prev;
146 	caddr_t		gld_dummy1;
147 	int32_t		gld_state;	/* DL_UNATTACHED, DL_UNBOUND, DL_IDLE */
148 	int32_t		gld_style;	/* open style 1 or style 2 */
149 	int32_t		gld_minor;	/* cloned minor number */
150 	int32_t		gld_type;	/* DL_ETHER, DL_TPR, DL_FDDI, etc */
151 	int32_t		gld_sap;	/* Bound SAP */
152 	int32_t		gld_flags;	/* flags defined in gldpriv.h */
153 	int32_t		gld_multicnt;	/* # of stream multicast addresses */
154 	gld_mcast_t	**gld_mcast;	/* multicast table or NULL */
155 	queue_t		*gld_qptr;	/* pointer to streams queue */
156 	caddr_t		gld_dummy2;
157 	caddr_t		gld_dummy3;
158 	struct gld_mac_info *gld_mac_info;	/* if not DL_UNATTACHED */
159 	caddr_t		gld_dummy4;
160 	struct glddevice *gld_device;	/* per-major structure */
161 
162 	volatile boolean_t gld_xwait;		/* want an xmit qenable */
163 	volatile boolean_t gld_sched_ran;	/* gld_sched examined this Q */
164 	volatile boolean_t gld_in_unbind;	/* DL_UNBIND in progress */
165 	volatile uint32_t gld_wput_count; /* number of threads in wput=>start */
166 	volatile boolean_t gld_in_wsrv;	/* Q thread currently running in wsrv */
167 
168 	boolean_t	gld_ethertype;	/* ethertype/LLC stream */
169 	uint32_t	gld_notifications;
170 	uint32_t	gld_upri;	/* user priority */
171 	void		*gld_vlan;
172 	int (*gld_send)();
173 } gld_t;
174 
175 /*
176  * definitions for the per driver class structure
177  */
178 typedef struct glddevice {
179 	struct glddevice *gld_next, *gld_prev;
180 	int		gld_ndevice;	/* number of mac devices linked */
181 	gld_mac_info_t	*gld_mac_next, *gld_mac_prev;	/* the various macs */
182 	gld_t		*gld_str_next, *gld_str_prev;	/* open, unattached, */
183 							/* style 2 streams */
184 	char		gld_name[16];	/* name of device */
185 	kmutex_t	gld_devlock;	/* used to serialize read/write locks */
186 	int		gld_nextminor;	/* next unused minor number for clone */
187 	int		gld_major;	/* device's major number */
188 	int		gld_multisize;	/* # of multicast entries to alloc */
189 	int		gld_type;	/* for use before attach */
190 	int		gld_minsdu;
191 	int		gld_maxsdu;
192 	int		gld_addrlen;	/* physical address length */
193 	int		gld_saplen;	/* sap length, neg appends */
194 	unsigned char	*gld_broadcast;	/* pointer to broadcast address */
195 	int		gld_styles;	/* provider styles */
196 } glddev_t;
197 
198 typedef struct pktinfo {
199 	uint_t		isBroadcast:1;
200 	uint_t		isMulticast:1;
201 	uint_t		isLooped:1;
202 	uint_t		isForMe:1;
203 	uint_t		isLLC:1;
204 	uint_t		user_pri:3;
205 	uint_t		cfi:1;
206 	uint_t		vid:12;
207 	uint_t		wasAccepted:1;
208 	uint_t		nosource:1;
209 	uint_t		isTagged:1;
210 	uint_t		macLen;
211 	uint_t		hdrLen;
212 	uint_t		pktLen;
213 	uchar_t		dhost[GLD_MAX_ADDRLEN];
214 	uchar_t		shost[GLD_MAX_ADDRLEN];
215 	uint_t		ethertype;
216 } pktinfo_t;
217 
218 /*
219  * Flags input to the gld_interpret_*() interpreter routines.
220  */
221 typedef enum packet_flag {
222 	GLD_RXQUICK,
223 	GLD_RXLOOP,
224 	GLD_RX,
225 	GLD_TX
226 } packet_flag_t;
227 
228 /*
229  * Flags input to the gld_interpret_mdt_*() interpreter routines.
230  */
231 typedef enum mdt_packet_flag {
232 	GLD_MDT_TX,
233 	GLD_MDT_TXPKT,
234 	GLD_MDT_RXLOOP
235 } mdt_packet_flag_t;
236 
237 /*
238  * Describes characteristics of the Media Access Layer.
239  * The mac_type is one of the supported DLPI media types (see <sys/dlpi.h>).
240  * The mtu_size is the size of the largest frame.
241  * The interpreter is the function that "knows" how to interpret the frame.
242  * The interpreter_mdt routine knows how to interpret/format MDT packets.
243  * Other routines create and/or add headers to packets.
244  */
245 typedef struct {
246 	uint_t	mac_type;
247 	uint_t	mtu_size;
248 	int	hdr_size;
249 	int	(*interpreter)(gld_mac_info_t *, mblk_t *, pktinfo_t *,
250 		    packet_flag_t);
251 	void	(*interpreter_mdt)(gld_mac_info_t *, mblk_t *,
252 		    struct pdescinfo_s *, pktinfo_t *, mdt_packet_flag_t);
253 	mblk_t	*(*mkfastpath)(gld_t *, mblk_t *);
254 	mblk_t	*(*mkunitdata)(gld_t *, mblk_t *);
255 	void	(*init)(gld_mac_info_t *);
256 	void	(*uninit)(gld_mac_info_t *);
257 	char	*mac_string;
258 } gld_interface_t;
259 
260 /*
261  * structure for names stat structure usage as required by "netstat"
262  */
263 typedef union media_kstats {
264 	struct dot3kstat {
265 		kstat_named_t	first_coll;
266 		kstat_named_t	multi_coll;
267 		kstat_named_t	sqe_error;
268 		kstat_named_t	mac_xmt_error;
269 		kstat_named_t	frame_too_long;
270 		kstat_named_t	mac_rcv_error;
271 	} dot3;
272 	struct dot5kstat {
273 		kstat_named_t	ace_error;
274 		kstat_named_t	internal_error;
275 		kstat_named_t	lost_frame_error;
276 		kstat_named_t	frame_copied_error;
277 		kstat_named_t	token_error;
278 		kstat_named_t	freq_error;
279 	} dot5;
280 	struct fddikstat {
281 		kstat_named_t	mac_error;
282 		kstat_named_t	mac_lost;
283 		kstat_named_t	mac_token;
284 		kstat_named_t	mac_tvx_expired;
285 		kstat_named_t	mac_late;
286 		kstat_named_t	mac_ring_op;
287 	} fddi;
288 } media_kstats_t;
289 
290 struct gldkstats {
291 	kstat_named_t	glds_pktxmt;
292 	kstat_named_t	glds_pktrcv;
293 	kstat_named_t	glds_errxmt;
294 	kstat_named_t	glds_errrcv;
295 	kstat_named_t	glds_collisions;
296 	kstat_named_t	glds_bytexmt;
297 	kstat_named_t	glds_bytercv;
298 	kstat_named_t	glds_multixmt;
299 	kstat_named_t	glds_multircv;	/* multicast but not broadcast */
300 	kstat_named_t	glds_brdcstxmt;
301 	kstat_named_t	glds_brdcstrcv;
302 	kstat_named_t	glds_unknowns;
303 	kstat_named_t	glds_blocked;	/* discard due to upstream flow */
304 					/* control */
305 	kstat_named_t	glds_excoll;
306 	kstat_named_t	glds_defer;
307 	kstat_named_t	glds_frame;
308 	kstat_named_t	glds_crc;
309 	kstat_named_t	glds_overflow;
310 	kstat_named_t	glds_underflow;
311 	kstat_named_t	glds_short;
312 	kstat_named_t	glds_missed;
313 	kstat_named_t	glds_xmtlatecoll;
314 	kstat_named_t	glds_nocarrier;
315 	kstat_named_t	glds_noxmtbuf;
316 	kstat_named_t	glds_norcvbuf;
317 	kstat_named_t	glds_xmtbadinterp;
318 	kstat_named_t	glds_rcvbadinterp;
319 	kstat_named_t	glds_intr;
320 	kstat_named_t	glds_xmtretry;
321 	kstat_named_t	glds_pktxmt64;
322 	kstat_named_t	glds_pktrcv64;
323 	kstat_named_t	glds_bytexmt64;
324 	kstat_named_t	glds_bytercv64;
325 	kstat_named_t	glds_speed;
326 	kstat_named_t	glds_duplex;
327 	kstat_named_t	glds_media;
328 	kstat_named_t	glds_prom;
329 	media_kstats_t	glds_media_specific;
330 };
331 
332 typedef struct gld_mac_pvt gld_mac_pvt_t;
333 
334 typedef struct gld_vlan {
335 	struct gld_vlan *gldv_next, *gldv_prev;
336 	uint32_t		gldv_id;
337 	uint32_t		gldv_ptag;
338 	int			gldv_nstreams;
339 	gld_mac_info_t		*gldv_mac;
340 	queue_t			*gldv_ipq;
341 	queue_t			*gldv_ipv6q;
342 	struct gld		*gldv_str_next;	/* list of attached streams */
343 	struct gld		*gldv_str_prev;
344 	kstat_t			*gldv_kstatp;
345 	struct gld_stats	*gldv_stats;
346 	/* The number of streams that are in promiscous mode */
347 	uint_t			gldv_nprom;
348 	/* The number of streams that are interested in VLAN tagged packets. */
349 	uint_t			gldv_nvlan_sap;
350 } gld_vlan_t;
351 
352 #define	VLAN_HASHSZ	23
353 
354 /* Per-mac info used by GLD */
355 struct gld_mac_pvt {
356 	gld_interface_t	*interfacep;
357 	kmutex_t	datalock;	/* data lock for "data" */
358 	caddr_t		data;		/* media specific private data */
359 	gld_vlan_t	*vlan_hash[VLAN_HASHSZ];
360 	struct gld	*last_sched;	/* last scheduled stream */
361 	struct glddevice *major_dev;	/* per-major device struct */
362 	int		nvlan;		/* VLANs in use on this mac */
363 	int		nprom;		/* num streams in promiscuous mode */
364 	int		nprom_multi;	/* streams in promiscuous multicast */
365 	gld_mcast_t	*mcast_table;	/* per device multicast table */
366 	unsigned char	*curr_macaddr;	/* Currently programmed mac address */
367 	kstat_t		*kstatp;
368 	struct gld_stats *statistics;	/* The ones the driver updates */
369 	int		rde_enabled;	/* RDE (Source Routing) Enabled */
370 	int		rde_str_indicator_ste;	/* use STE when no SR info */
371 	int		rde_timeout;	/* route link inactivity timeout */
372 	uint32_t	notifications;	/* DL_NOTE options supported */
373 	boolean_t	started;	/* Has the MAC been started? */
374 };
375 
376 /* return values from gld_cmds */
377 #define	GLDE_OK		(-1)	/* internal procedure status is OK */
378 #define	GLDE_RETRY	0x1002	/* want to retry later */
379 
380 /* caller argument to gld_start */
381 #define	GLD_WPUT	0
382 #define	GLD_WSRV	1
383 
384 #define	GLD_MAX_802_SAP	0xff
385 
386 /*
387  * definitions for debug tracing
388  */
389 #define	GLDTRACE	0x0001	/* basic procedure level tracing */
390 #define	GLDERRS		0x0002	/* trace errors */
391 #define	GLDRECV		0x0004	/* trace receive path */
392 #define	GLDSEND		0x0008	/* trace send path */
393 #define	GLDPROT		0x0010	/* trace DLPI protocol */
394 #define	GLDNOBR		0x0020	/* do not show broadcast messages */
395 #define	GLDETRACE	0x0040	/* trace "normal case" errors */
396 #define	GLDRDE		0x0080	/* netstat -k dump routing table */
397 
398 /*
399  * Lock manipulation macros for GLDM_LOCK. Conceptually, the
400  * GLD layer treats the lock as a rw lock; for v0 binary and
401  * semantic compatibility, the underlying implementation still
402  * uses a mutex, whereas for v2 drivers, the more scalable rwlock
403  * is used instead. See notes in gld.h.
404  */
405 #define	GLDM_LOCK_INIT(macinfo)						\
406 	rw_init(&(macinfo)->gldm_lock.gldl_rw_lock, NULL,		\
407 	    RW_DRIVER, (macinfo)->gldm_cookie);				\
408 	(macinfo)->gldm_GLD_flags |= GLD_LOCK_INITED
409 
410 #define	GLDM_LOCK_INITED(macinfo)					\
411 	((macinfo)->gldm_GLD_flags & GLD_LOCK_INITED)
412 
413 #define	GLDM_LOCK_DESTROY(macinfo)					\
414 	if ((macinfo)->gldm_GLD_flags & GLD_LOCK_INITED) {		\
415 		rw_destroy(&(macinfo)->gldm_lock.gldl_rw_lock);		\
416 		(macinfo)->gldm_GLD_flags &= ~GLD_LOCK_INITED;		\
417 	}
418 
419 #define	GLDM_LOCK(macinfo, rw)						\
420 	rw_enter(&(macinfo)->gldm_lock.gldl_rw_lock, (rw))
421 
422 #define	GLDM_UNLOCK(macinfo)						\
423 	rw_exit(&(macinfo)->gldm_lock.gldl_rw_lock)
424 
425 #define	GLDM_TRYLOCK(macinfo, rw)					\
426 	rw_tryenter(&(macinfo)->gldm_lock.gldl_rw_lock, (rw))
427 
428 /* lock held in read or write mode? */
429 #define	GLDM_LOCK_HELD(macinfo)						\
430 	rw_lock_held(&(macinfo)->gldm_lock.gldl_rw_lock)
431 
432 /* lock held in write mode? */
433 #define	GLDM_LOCK_HELD_WRITE(macinfo)					\
434 	rw_write_held(&(macinfo)->gldm_lock.gldl_rw_lock)
435 
436 /*
437  * Compare/copy two MAC addresses.
438  * Note that unlike bcmp, we return zero if they are different.
439  */
440 #define	mac_eq(a, b, l) (bcmp((caddr_t)(a), (caddr_t)(b), (l)) == 0)
441 #define	mac_copy(a, b, l) (bcopy((caddr_t)(a), (caddr_t)(b), (l)))
442 /* copy a mac address to/from canonical form */
443 #define	cmac_copy(a, b, l, macinfo) {					\
444 	    if ((macinfo)->gldm_options & GLDOPT_CANONICAL_ADDR)	\
445 		gld_bitrevcopy((caddr_t)(a), (caddr_t)(b), (l));	\
446 	    else							\
447 		mac_copy((a), (b), (l));				\
448 	}
449 
450 /*
451  * Macros to access possibly-unaligned variables
452  */
453 
454 #if	(_ALIGNMENT_REQUIRED == 0)
455 
456 #define	REF_HOST_USHORT(lvalue) (lvalue)
457 #define	REF_NET_USHORT(lvalue) (ntohs(lvalue))
458 #define	SET_NET_USHORT(lvalue, val) ((lvalue) = htons(val))
459 
460 #else	/* ALIGNMENT_REQUIRED */
461 
462 #define	REF_NET_USHORT(lvalue) \
463 	((ushort_t)((((uchar_t *)(&(lvalue)))[0]<<8) | \
464 	((uchar_t *)(&(lvalue)))[1]))
465 
466 #define	SET_NET_USHORT(lvalue, val) { \
467 	((uchar_t *)(&(lvalue)))[0] = (uchar_t)((val)>>8); \
468 	((uchar_t *)(&(lvalue)))[1] = (uchar_t)(val); \
469 }
470 
471 #if defined(_LITTLE_ENDIAN)
472 
473 #define	REF_HOST_USHORT(lvalue) \
474 	((ushort_t)((((uchar_t *)(&(lvalue)))[1]<<8) | \
475 	((uchar_t *)(&(lvalue)))[0]))
476 
477 #elif defined(_BIG_ENDIAN)
478 
479 #define	REF_HOST_USHORT(lvalue) \
480 	((ushort_t)((((uchar_t *)(&(lvalue)))[0]<<8) | \
481 	((uchar_t *)(&(lvalue)))[1]))
482 
483 #else	/* unknown endian */
484 #error	"what endian is this machine?"
485 #endif	/* endian */
486 
487 #endif	/* ALIGNMENT_REQUIRED */
488 
489 /* ================================================================ */
490 /* Route Determination Entity definitions (IEEE 802.2 1994 edition) */
491 /* ================================================================ */
492 
493 struct rde_pdu {
494 	uchar_t	rde_ver;
495 	uchar_t	rde_ptype;
496 	uchar_t	rde_target_mac[6];
497 	uchar_t	rde_orig_mac[6];
498 	uchar_t	rde_target_sap;
499 	uchar_t	rde_orig_sap;
500 };
501 
502 #define	LSAP_RDE	0xa6	/* IEEE 802.2 section 3.3.1.2 */
503 #define	RDE_RQC		0x01	/* Route Query Command */
504 #define	RDE_RQR		0x02	/* Route Query Response */
505 #define	RDE_RS		0x03	/* Route Selected */
506 
507 /* ============================================================= */
508 /* Source Routing fields and definitions (IEEE 802.2 and 802.1D) */
509 /* ============================================================= */
510 
511 #define	MAX_RDFLDS	14	/* changed to 14 from 8 as per IEEE */
512 
513 /*
514  * Source Routing Route Information field.
515  */
516 struct gld_ri {
517 #if defined(_BIT_FIELDS_LTOH)
518 	uchar_t len:5;			/* length */
519 	uchar_t rt:3;			/* routing type */
520 	uchar_t res:4;			/* reserved */
521 	uchar_t mtu:3;			/* largest frame */
522 	uchar_t dir:1;			/* direction bit */
523 	struct tr_rd {			/* route designator fields */
524 		ushort_t bridge:4;	/* Note: assumes network order... */
525 		ushort_t ring:12;	/* ...(Big Endian) -- needs ntohs() */
526 	} rd[MAX_RDFLDS];
527 #elif defined(_BIT_FIELDS_HTOL)
528 	uchar_t rt:3;			/* routing type */
529 	uchar_t len:5;			/* length */
530 	uchar_t dir:1;			/* direction bit */
531 	uchar_t mtu:3;			/* largest frame */
532 	uchar_t res:4;			/* reserved */
533 	struct tr_rd {			/* route designator fields */
534 		ushort_t ring:12;
535 		ushort_t bridge:4;
536 	} rd[MAX_RDFLDS];
537 #else
538 #error	"which way do bit fields get allocated?"
539 #endif
540 };
541 
542 #define	RT_SRF		0x0		/* 0xx: specifically routed frame */
543 #define	RT_ARE		0x4		/* 10x: all routes explorer frame */
544 #define	RT_STE		0x6		/* 11x: spanning tree explorer frame */
545 
546 #define	RT_MTU_MAX	0x7		/* Max MTU field (base only) */
547 
548 /*
549  * Source route table info
550  */
551 struct srtab {
552 	struct srtab	*sr_next;		/* next in linked list */
553 	uchar_t		sr_mac[6];		/* MAC address */
554 	struct		gld_ri sr_ri;		/* routing information */
555 	clock_t		sr_timer;
556 };
557 
558 #define	SR_HASH_SIZE	256		/* Number of bins */
559 
560 /* ================================================================= */
561 /* Media dependent defines for media dependent routines in gldutil.c */
562 /* ================================================================= */
563 
564 /*
565  * Some "semi-generic" defines used by ether, token, and fddi,
566  * and probably anything else with addrlen == 6 && saplen == -2.
567  */
568 
569 struct gld_dlsap {
570 	unsigned char   glda_addr[ETHERADDRL];
571 	unsigned short  glda_sap;
572 };
573 
574 #define	DLSAP(p, offset) ((struct gld_dlsap *)((caddr_t)(p)+offset))
575 
576 typedef uchar_t mac_addr_t[ETHERADDRL];
577 
578 struct llc_snap_hdr {
579 	uchar_t  d_lsap;		/* destination service access point */
580 	uchar_t  s_lsap;		/* source link service access point */
581 	uchar_t  control;		/* short control field */
582 	uchar_t  org[3];		/* Ethernet style organization field */
583 	ushort_t type;			/* Ethernet style type field */
584 };
585 
586 #define	LLC_HDR1_LEN		3	/* Length of the LLC1 header */
587 #define	LLC_SNAP_HDR_LEN	8	/* Full length of SNAP header */
588 #define	LSAP_SNAP		0xaa	/* SAP for SubNet Access Protocol */
589 #define	CNTL_LLC_UI		0x03	/* un-numbered information packet */
590 
591 /* ======================== */
592 /* FDDI related definitions */
593 /* ======================== */
594 
595 struct	fddi_mac_frm {
596 	uchar_t		fddi_fc;
597 	mac_addr_t	fddi_dhost;
598 	mac_addr_t	fddi_shost;
599 };
600 
601 /* ============================== */
602 /* Token Ring related definitions */
603 /* ============================== */
604 
605 struct tr_mac_frm_nori {
606 	uchar_t		tr_ac;
607 	uchar_t		tr_fc;
608 	mac_addr_t	tr_dhost;
609 	mac_addr_t	tr_shost;
610 };
611 
612 struct tr_mac_frm {
613 	uchar_t		tr_ac;
614 	uchar_t		tr_fc;
615 	mac_addr_t	tr_dhost;
616 	mac_addr_t	tr_shost;
617 	struct gld_ri	tr_ri;		/* Routing Information Field */
618 };
619 
620 /*
621  * Note that the pad field is used to save the value of tci.
622  */
623 #define	GLD_SAVE_MBLK_VTAG(mp, vtag)	(DB_TCI(mp) = GLD_VTAG_TCI(vtag))
624 #define	GLD_CLEAR_MBLK_VTAG(mp)		GLD_SAVE_MBLK_VTAG(mp, 0)
625 #define	GLD_GET_MBLK_VTAG(mp)		GLD_TCI2VTAG(DB_TCI(mp))
626 
627 int gld_interpret_ether(gld_mac_info_t *, mblk_t *, pktinfo_t *, packet_flag_t);
628 int gld_interpret_fddi(gld_mac_info_t *, mblk_t *, pktinfo_t *, packet_flag_t);
629 int gld_interpret_tr(gld_mac_info_t *, mblk_t *, pktinfo_t *, packet_flag_t);
630 int gld_interpret_ib(gld_mac_info_t *, mblk_t *, pktinfo_t *, packet_flag_t);
631 void gld_interpret_mdt_ib(gld_mac_info_t *, mblk_t *, pdescinfo_t *,
632     pktinfo_t *, mdt_packet_flag_t);
633 
634 mblk_t *gld_fastpath_ether(gld_t *, mblk_t *);
635 mblk_t *gld_fastpath_fddi(gld_t *, mblk_t *);
636 mblk_t *gld_fastpath_tr(gld_t *, mblk_t *);
637 mblk_t *gld_fastpath_ib(gld_t *, mblk_t *);
638 
639 mblk_t *gld_insert_vtag_ether(mblk_t *, uint32_t);
640 
641 mblk_t *gld_unitdata_ether(gld_t *, mblk_t *);
642 mblk_t *gld_unitdata_fddi(gld_t *, mblk_t *);
643 mblk_t *gld_unitdata_tr(gld_t *, mblk_t *);
644 mblk_t *gld_unitdata_ib(gld_t *, mblk_t *);
645 
646 void gld_init_ether(gld_mac_info_t *);
647 void gld_init_fddi(gld_mac_info_t *);
648 void gld_init_tr(gld_mac_info_t *);
649 void gld_init_ib(gld_mac_info_t *);
650 
651 void gld_uninit_ether(gld_mac_info_t *);
652 void gld_uninit_fddi(gld_mac_info_t *);
653 void gld_uninit_tr(gld_mac_info_t *);
654 void gld_uninit_ib(gld_mac_info_t *);
655 
656 #ifdef	__cplusplus
657 }
658 #endif
659 
660 #endif /* _SYS_GLDPRIV_H */
661