![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_media.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / net|
Return to if_media.c CVS log | Up to [Apple XNU] / XNU / bsd / net |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /* $NetBSD: if_media.c,v 1.1 1997/03/17 02:55:15 thorpej Exp $ */
23:
24: /*
25: * Copyright (c) 1997
26: * Jonathan Stone and Jason R. Thorpe. All rights reserved.
27: *
28: * This software is derived from information provided by Matt Thomas.
29: *
30: * Redistribution and use in source and binary forms, with or without
31: * modification, are permitted provided that the following conditions
32: * are met:
33: * 1. Redistributions of source code must retain the above copyright
34: * notice, this list of conditions and the following disclaimer.
35: * 2. Redistributions in binary form must reproduce the above copyright
36: * notice, this list of conditions and the following disclaimer in the
37: * documentation and/or other materials provided with the distribution.
38: * 3. All advertising materials mentioning features or use of this software
39: * must display the following acknowledgement:
40: * This product includes software developed by Jonathan Stone
41: * and Jason R. Thorpe for the NetBSD Project.
42: * 4. The names of the authors may not be used to endorse or promote products
43: * derived from this software without specific prior written permission.
44: *
45: * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
46: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
47: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
48: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
49: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
50: * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
51: * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
52: * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
53: * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
54: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
55: * SUCH DAMAGE.
56: */
57:
58: /*
59: * BSD/OS-compatible network interface media selection.
60: *
61: * Where it is safe to do so, this code strays slightly from the BSD/OS
62: * design. Software which uses the API (device drivers, basically)
63: * shouldn't notice any difference.
64: *
65: * Many thanks to Matt Thomas for providing the information necessary
66: * to implement this interface.
67: */
68:
69: #include <sys/param.h>
70: #include <sys/systm.h>
71: #include <sys/socket.h>
72: #include <sys/sockio.h>
73: #include <sys/malloc.h>
74:
75: #include <net/if.h>
76: #include <net/if_media.h>
77:
78: /*
79: * Compile-time options:
80: * IFMEDIA_DEBUG:
81: * turn on implementation-level debug printfs.
82: * Useful for debugging newly-ported drivers.
83: */
84:
85: static struct ifmedia_entry *ifmedia_match __P((struct ifmedia *ifm,
86: int flags, int mask));
87:
88: #ifdef IFMEDIA_DEBUG
89: int ifmedia_debug = 0;
90: static void ifmedia_printword __P((int));
91: #endif
92:
93: /*
94: * Initialize if_media struct for a specific interface instance.
95: */
96: void
97: ifmedia_init(ifm, dontcare_mask, change_callback, status_callback)
98: struct ifmedia *ifm;
99: int dontcare_mask;
100: ifm_change_cb_t change_callback;
101: ifm_stat_cb_t status_callback;
102: {
103:
104: LIST_INIT(&ifm->ifm_list);
105: ifm->ifm_cur = NULL;
106: ifm->ifm_media = 0;
107: ifm->ifm_mask = dontcare_mask; /* IF don't-care bits */
108: ifm->ifm_change = change_callback;
109: ifm->ifm_status = status_callback;
110: }
111:
112: /*
113: * Add a media configuration to the list of supported media
114: * for a specific interface instance.
115: */
116: void
117: ifmedia_add(ifm, mword, data, aux)
118: struct ifmedia *ifm;
119: int mword;
120: int data;
121: void *aux;
122: {
123: register struct ifmedia_entry *entry;
124:
125: #ifdef IFMEDIA_DEBUG
126: if (ifmedia_debug) {
127: if (ifm == NULL) {
128: printf("ifmedia_add: null ifm\n");
129: return;
130: }
131: printf("Adding entry for ");
132: ifmedia_printword(mword);
133: }
134: #endif
135:
136: entry = _MALLOC(sizeof(*entry), M_IFADDR, M_NOWAIT);
137: if (entry == NULL)
138: panic("ifmedia_add: can't malloc entry");
139:
140: entry->ifm_media = mword;
141: entry->ifm_data = data;
142: entry->ifm_aux = aux;
143:
144: LIST_INSERT_HEAD(&ifm->ifm_list, entry, ifm_list);
145: }
146:
147: /*
148: * Add an array of media configurations to the list of
149: * supported media for a specific interface instance.
150: */
151: void
152: ifmedia_list_add(ifm, lp, count)
153: struct ifmedia *ifm;
154: struct ifmedia_entry *lp;
155: int count;
156: {
157: int i;
158:
159: for (i = 0; i < count; i++)
160: ifmedia_add(ifm, lp[i].ifm_media, lp[i].ifm_data,
161: lp[i].ifm_aux);
162: }
163:
164: /*
165: * Set the default active media.
166: *
167: * Called by device-specific code which is assumed to have already
168: * selected the default media in hardware. We do _not_ call the
169: * media-change callback.
170: */
171: void
172: ifmedia_set(ifm, target)
173: struct ifmedia *ifm;
174: int target;
175:
176: {
177: struct ifmedia_entry *match;
178:
179: match = ifmedia_match(ifm, target, ifm->ifm_mask);
180:
181: if (match == NULL) {
182: printf("ifmedia_set: no match for 0x%x/0x%x\n",
183: target, ~ifm->ifm_mask);
184: panic("ifmedia_set");
185: }
186: ifm->ifm_cur = match;
187:
188: #ifdef IFMEDIA_DEBUG
189: if (ifmedia_debug) {
190: printf("ifmedia_set: target ");
191: ifmedia_printword(target);
192: printf("ifmedia_set: setting to ");
193: ifmedia_printword(ifm->ifm_cur->ifm_media);
194: }
195: #endif
196: }
197:
198: /*
199: * Device-independent media ioctl support function.
200: */
201: int
202: ifmedia_ioctl(ifp, ifr, ifm, cmd)
203: struct ifnet *ifp;
204: struct ifreq *ifr;
205: struct ifmedia *ifm;
206: u_long cmd;
207: {
208: struct ifmedia_entry *match;
209: struct ifmediareq *ifmr = (struct ifmediareq *) ifr;
210: int error = 0, sticky;
211:
212: if (ifp == NULL || ifr == NULL || ifm == NULL)
213: return(EINVAL);
214:
215: switch (cmd) {
216:
217: /*
218: * Set the current media.
219: */
220: case SIOCSIFMEDIA:
221: {
222: struct ifmedia_entry *oldentry;
223: int oldmedia;
224: int newmedia = ifr->ifr_media;
225:
226: match = ifmedia_match(ifm, newmedia, ifm->ifm_mask);
227: if (match == NULL) {
228: #ifdef IFMEDIA_DEBUG
229: if (ifmedia_debug) {
230: printf(
231: "ifmedia_ioctl: no media found for 0x%x\n",
232: newmedia);
233: }
234: #endif
235: return (ENXIO);
236: }
237:
238: /*
239: * If no change, we're done.
240: * XXX Automedia may invole software intervention.
241: * Keep going in case the the connected media changed.
242: * Similarly, if best match changed (kernel debugger?).
243: */
244: if ((IFM_SUBTYPE(newmedia) != IFM_AUTO) &&
245: (newmedia == ifm->ifm_media) &&
246: (match == ifm->ifm_cur))
247: return 0;
248:
249: /*
250: * We found a match, now make the driver switch to it.
251: * Make sure to preserve our old media type in case the
252: * driver can't switch.
253: */
254: #ifdef IFMEDIA_DEBUG
255: if (ifmedia_debug) {
256: printf("ifmedia_ioctl: switching %s to ",
257: ifp->if_xname);
258: ifmedia_printword(match->ifm_media);
259: }
260: #endif
261: oldentry = ifm->ifm_cur;
262: oldmedia = ifm->ifm_media;
263: ifm->ifm_cur = match;
264: ifm->ifm_media = newmedia;
265: error = (*ifm->ifm_change)(ifp);
266: if (error) {
267: ifm->ifm_cur = oldentry;
268: ifm->ifm_media = oldmedia;
269: }
270: break;
271: }
272:
273: /*
274: * Get list of available media and current media on interface.
275: */
276: case SIOCGIFMEDIA:
277: {
278: struct ifmedia_entry *ep;
279: int *kptr, count;
280:
281: kptr = NULL; /* XXX gcc */
282:
283: ifmr->ifm_active = ifmr->ifm_current = ifm->ifm_cur ?
284: ifm->ifm_cur->ifm_media : IFM_NONE;
285: ifmr->ifm_mask = ifm->ifm_mask;
286: ifmr->ifm_status = 0;
287: (*ifm->ifm_status)(ifp, ifmr);
288:
289: count = 0;
290: ep = ifm->ifm_list.lh_first;
291:
292: if (ifmr->ifm_count != 0) {
293: kptr = (int *) _MALLOC(ifmr->ifm_count * sizeof(int),
294: M_TEMP, M_WAITOK);
295:
296: /*
297: * Get the media words from the interface's list.
298: */
299: for (; ep != NULL && count < ifmr->ifm_count;
300: ep = ep->ifm_list.le_next, count++)
301: kptr[count] = ep->ifm_media;
302:
303: if (ep != NULL)
304: error = E2BIG; /* oops! */
305: }
306:
307: /*
308: * If there are more interfaces on the list, count
309: * them. This allows the caller to set ifmr->ifm_count
310: * to 0 on the first call to know how much space to
311: * callocate.
312: */
313: for (; ep != NULL; ep = ep->ifm_list.le_next)
314: count++;
315:
316: /*
317: * We do the copyout on E2BIG, because that's
318: * just our way of telling userland that there
319: * are more. This is the behavior I've observed
320: * under BSD/OS 3.0
321: */
322: sticky = error;
323: if ((error == 0 || error == E2BIG) && ifmr->ifm_count != 0) {
324: error = copyout((caddr_t)kptr,
325: (caddr_t)ifmr->ifm_ulist,
326: ifmr->ifm_count * sizeof(int));
327: }
328:
329: if (error == 0)
330: error = sticky;
331:
332: if (ifmr->ifm_count != 0)
333: FREE(kptr, M_TEMP);
334:
335: ifmr->ifm_count = count;
336: break;
337: }
338:
339: default:
340: return (EINVAL);
341: }
342:
343: return (error);
344: }
345:
346: /*
347: * Find media entry matching a given ifm word.
348: *
349: */
350: static struct ifmedia_entry *
351: ifmedia_match(ifm, target, mask)
352: struct ifmedia *ifm;
353: int target;
354: int mask;
355: {
356: struct ifmedia_entry *match, *next;
357:
358: match = NULL;
359: mask = ~mask;
360:
361: for (next = ifm->ifm_list.lh_first; next != NULL;
362: next = next->ifm_list.le_next) {
363: if ((next->ifm_media & mask) == (target & mask)) {
364: #if defined(IFMEDIA_DEBUG) || defined(DIAGNOSTIC)
365: if (match) {
366: printf("ifmedia_match: multiple match for "
367: "0x%x/0x%x\n", target, mask);
368: }
369: #endif
370: match = next;
371: }
372: }
373:
374: return match;
375: }
376:
377: #ifdef IFMEDIA_DEBUG
378: struct ifmedia_description ifm_type_descriptions[] =
379: IFM_TYPE_DESCRIPTIONS;
380:
381: struct ifmedia_description ifm_subtype_ethernet_descriptions[] =
382: IFM_SUBTYPE_ETHERNET_DESCRIPTIONS;
383:
384: struct ifmedia_description ifm_subtype_ethernet_option_descriptions[] =
385: IFM_SUBTYPE_ETHERNET_OPTION_DESCRIPTIONS;
386:
387: struct ifmedia_description ifm_subtype_tokenring_descriptions[] =
388: IFM_SUBTYPE_TOKENRING_DESCRIPTIONS;
389:
390: struct ifmedia_description ifm_subtype_tokenring_option_descriptions[] =
391: IFM_SUBTYPE_TOKENRING_OPTION_DESCRIPTIONS;
392:
393: struct ifmedia_description ifm_subtype_fddi_descriptions[] =
394: IFM_SUBTYPE_FDDI_DESCRIPTIONS;
395:
396: struct ifmedia_description ifm_subtype_fddi_option_descriptions[] =
397: IFM_SUBTYPE_FDDI_OPTION_DESCRIPTIONS;
398:
399: struct ifmedia_description ifm_subtype_shared_descriptions[] =
400: IFM_SUBTYPE_SHARED_DESCRIPTIONS;
401:
402: struct ifmedia_description ifm_shared_option_descriptions[] =
403: IFM_SHARED_OPTION_DESCRIPTIONS;
404:
405: struct ifmedia_type_to_subtype {
406: struct ifmedia_description *subtypes;
407: struct ifmedia_description *options;
408: };
409:
410: /* must be in the same order as IFM_TYPE_DESCRIPTIONS */
411: struct ifmedia_type_to_subtype ifmedia_types_to_subtypes[] = {
412: {
413: &ifm_subtype_ethernet_descriptions[0],
414: &ifm_subtype_ethernet_option_descriptions[0]
415: },
416: {
417: &ifm_subtype_tokenring_descriptions[0],
418: &ifm_subtype_tokenring_option_descriptions[0]
419: },
420: {
421: &ifm_subtype_fddi_descriptions[0],
422: &ifm_subtype_fddi_option_descriptions[0]
423: },
424: };
425:
426: /*
427: * print a media word.
428: */
429: static void
430: ifmedia_printword(ifmw)
431: int ifmw;
432: {
433: struct ifmedia_description *desc;
434: struct ifmedia_type_to_subtype *ttos;
435: int seen_option = 0;
436:
437: /* Find the top-level interface type. */
438: for (desc = ifm_type_descriptions, ttos = ifmedia_types_to_subtypes;
439: desc->ifmt_string != NULL; desc++, ttos++)
440: if (IFM_TYPE(ifmw) == desc->ifmt_word)
441: break;
442: if (desc->ifmt_string == NULL) {
443: printf("<unknown type>\n");
444: return;
445: }
446: printf(desc->ifmt_string);
447:
448: /*
449: * Check for the shared subtype descriptions first, then the
450: * type-specific ones.
451: */
452: for (desc = ifm_subtype_shared_descriptions;
453: desc->ifmt_string != NULL; desc++)
454: if (IFM_SUBTYPE(ifmw) == desc->ifmt_word)
455: goto got_subtype;
456:
457: for (desc = ttos->subtypes; desc->ifmt_string != NULL; desc++)
458: if (IFM_SUBTYPE(ifmw) == desc->ifmt_word)
459: break;
460: if (desc->ifmt_string == NULL) {
461: printf(" <unknown subtype>\n");
462: return;
463: }
464:
465: got_subtype:
466: printf(" %s", desc->ifmt_string);
467:
468: /*
469: * Look for shared options.
470: */
471: for (desc = ifm_shared_option_descriptions;
472: desc->ifmt_string != NULL; desc++) {
473: if (ifmw & desc->ifmt_word) {
474: if (seen_option == 0)
475: printf(" <");
476: printf("%s%s", seen_option++ ? "," : "",
477: desc->ifmt_string);
478: }
479: }
480:
481: /*
482: * Look for subtype-specific options.
483: */
484: for (desc = ttos->options; desc->ifmt_string != NULL; desc++) {
485: if (ifmw & desc->ifmt_word) {
486: if (seen_option == 0)
487: printf(" <");
488: printf("%s%s", seen_option++ ? "," : "",
489: desc->ifmt_string);
490: }
491: }
492: printf("%s\n", seen_option ? ">" : "");
493: }
494: #endif /* IFMEDIA_DEBUG */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.