Annotation of sys/net/if_media.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: if_media.c,v 1.16 2005/07/28 02:15:15 brad Exp $ */
2: /* $NetBSD: if_media.c,v 1.10 2000/03/13 23:52:39 soren Exp $ */
3:
4: /*-
5: * Copyright (c) 1998 The NetBSD Foundation, Inc.
6: * All rights reserved.
7: *
8: * This code is derived from software contributed to The NetBSD Foundation
9: * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
10: * NASA Ames Research Center.
11: *
12: * Redistribution and use in source and binary forms, with or without
13: * modification, are permitted provided that the following conditions
14: * are met:
15: * 1. Redistributions of source code must retain the above copyright
16: * notice, this list of conditions and the following disclaimer.
17: * 2. Redistributions in binary form must reproduce the above copyright
18: * notice, this list of conditions and the following disclaimer in the
19: * documentation and/or other materials provided with the distribution.
20: * 3. All advertising materials mentioning features or use of this software
21: * must display the following acknowledgement:
22: * This product includes software developed by the NetBSD
23: * Foundation, Inc. and its contributors.
24: * 4. Neither the name of The NetBSD Foundation nor the names of its
25: * contributors may be used to endorse or promote products derived
26: * from this software without specific prior written permission.
27: *
28: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
29: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
30: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
31: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
32: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
33: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
34: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
35: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
36: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
37: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
38: * POSSIBILITY OF SUCH DAMAGE.
39: */
40:
41: /*
42: * Copyright (c) 1997
43: * Jonathan Stone and Jason R. Thorpe. All rights reserved.
44: *
45: * This software is derived from information provided by Matt Thomas.
46: *
47: * Redistribution and use in source and binary forms, with or without
48: * modification, are permitted provided that the following conditions
49: * are met:
50: * 1. Redistributions of source code must retain the above copyright
51: * notice, this list of conditions and the following disclaimer.
52: * 2. Redistributions in binary form must reproduce the above copyright
53: * notice, this list of conditions and the following disclaimer in the
54: * documentation and/or other materials provided with the distribution.
55: * 3. All advertising materials mentioning features or use of this software
56: * must display the following acknowledgement:
57: * This product includes software developed by Jonathan Stone
58: * and Jason R. Thorpe for the NetBSD Project.
59: * 4. The names of the authors may not be used to endorse or promote products
60: * derived from this software without specific prior written permission.
61: *
62: * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
63: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
64: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
65: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
66: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
67: * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
68: * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
69: * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
70: * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
71: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
72: * SUCH DAMAGE.
73: */
74:
75: /*
76: * BSD/OS-compatible network interface media selection.
77: *
78: * Where it is safe to do so, this code strays slightly from the BSD/OS
79: * design. Software which uses the API (device drivers, basically)
80: * shouldn't notice any difference.
81: *
82: * Many thanks to Matt Thomas for providing the information necessary
83: * to implement this interface.
84: */
85:
86: #include <sys/param.h>
87: #include <sys/systm.h>
88: #include <sys/errno.h>
89: #include <sys/ioctl.h>
90: #include <sys/socket.h>
91: #include <sys/malloc.h>
92:
93: #include <net/if.h>
94: #include <net/if_media.h>
95: #include <net/netisr.h>
96:
97: /*
98: * Compile-time options:
99: * IFMEDIA_DEBUG:
100: * turn on implementation-level debug printfs.
101: * Useful for debugging newly-ported drivers.
102: */
103:
104: #ifdef IFMEDIA_DEBUG
105: int ifmedia_debug = 0;
106: static void ifmedia_printword(int);
107: #endif
108:
109: /*
110: * Initialize if_media struct for a specific interface instance.
111: */
112: void
113: ifmedia_init(struct ifmedia *ifm, int dontcare_mask,
114: ifm_change_cb_t change_callback, ifm_stat_cb_t status_callback)
115: {
116: TAILQ_INIT(&ifm->ifm_list);
117: ifm->ifm_cur = NULL;
118: ifm->ifm_media = 0;
119: ifm->ifm_mask = dontcare_mask; /* IF don't-care bits */
120: ifm->ifm_change = change_callback;
121: ifm->ifm_status = status_callback;
122: }
123:
124: /*
125: * Add a media configuration to the list of supported media
126: * for a specific interface instance.
127: */
128: void
129: ifmedia_add(struct ifmedia *ifm, int mword, int data, void *aux)
130: {
131: struct ifmedia_entry *entry;
132:
133: #ifdef IFMEDIA_DEBUG
134: if (ifmedia_debug) {
135: if (ifm == NULL) {
136: printf("ifmedia_add: null ifm\n");
137: return;
138: }
139: printf("Adding entry for ");
140: ifmedia_printword(mword);
141: }
142: #endif
143:
144: entry = malloc(sizeof(*entry), M_IFADDR, M_NOWAIT);
145: if (entry == NULL)
146: panic("ifmedia_add: can't malloc entry");
147:
148: entry->ifm_media = mword;
149: entry->ifm_data = data;
150: entry->ifm_aux = aux;
151:
152: TAILQ_INSERT_TAIL(&ifm->ifm_list, entry, ifm_list);
153: }
154:
155: /*
156: * Add an array of media configurations to the list of
157: * supported media for a specific interface instance.
158: */
159: void
160: ifmedia_list_add(struct ifmedia *ifm, struct ifmedia_entry *lp, int count)
161: {
162: int i;
163:
164: for (i = 0; i < count; i++)
165: ifmedia_add(ifm, lp[i].ifm_media, lp[i].ifm_data,
166: lp[i].ifm_aux);
167: }
168:
169: /*
170: * Set the default active media.
171: *
172: * Called by device-specific code which is assumed to have already
173: * selected the default media in hardware. We do _not_ call the
174: * media-change callback.
175: */
176: void
177: ifmedia_set(struct ifmedia *ifm, int target)
178: {
179: struct ifmedia_entry *match;
180:
181: match = ifmedia_match(ifm, target, ifm->ifm_mask);
182:
183: /*
184: * If we didn't find the requested media, then we try to fall
185: * back to target-type (IFM_ETHER, e.g.) | IFM_NONE. If that's
186: * not on the list, then we add it and set the media to it.
187: *
188: * Since ifmedia_set is almost always called with IFM_AUTO or
189: * with a known-good media, this really should only occur if we:
190: *
191: * a) didn't find any PHYs, or
192: * b) didn't find an autoselect option on the PHY when the
193: * parent ethernet driver expected to.
194: *
195: * In either case, it makes sense to select no media.
196: */
197: if (match == NULL) {
198: printf("ifmedia_set: no match for 0x%x/0x%x\n",
199: target, ~ifm->ifm_mask);
200: target = (target & IFM_NMASK) | IFM_NONE;
201: match = ifmedia_match(ifm, target, ifm->ifm_mask);
202: if (match == NULL) {
203: ifmedia_add(ifm, target, 0, NULL);
204: match = ifmedia_match(ifm, target, ifm->ifm_mask);
205: if (match == NULL) {
206: panic("ifmedia_set failed");
207: }
208: }
209: }
210: ifm->ifm_cur = match;
211:
212: #ifdef IFMEDIA_DEBUG
213: if (ifmedia_debug) {
214: printf("ifmedia_set: target ");
215: ifmedia_printword(target);
216: printf("ifmedia_set: setting to ");
217: ifmedia_printword(ifm->ifm_cur->ifm_media);
218: }
219: #endif
220: }
221:
222: /*
223: * Device-independent media ioctl support function.
224: */
225: int
226: ifmedia_ioctl(struct ifnet *ifp, struct ifreq *ifr, struct ifmedia *ifm,
227: u_long cmd)
228: {
229: struct ifmedia_entry *match;
230: struct ifmediareq *ifmr = (struct ifmediareq *) ifr;
231: int error = 0;
232:
233: if (ifp == NULL || ifr == NULL || ifm == NULL)
234: return (EINVAL);
235:
236: switch (cmd) {
237:
238: /*
239: * Set the current media.
240: */
241: case SIOCSIFMEDIA:
242: {
243: struct ifmedia_entry *oldentry;
244: u_int oldmedia;
245: u_int newmedia = ifr->ifr_media;
246:
247: match = ifmedia_match(ifm, newmedia, ifm->ifm_mask);
248: if (match == NULL) {
249: #ifdef IFMEDIA_DEBUG
250: if (ifmedia_debug) {
251: printf(
252: "ifmedia_ioctl: no media found for 0x%x\n",
253: newmedia);
254: }
255: #endif
256: return (EINVAL);
257: }
258:
259: /*
260: * If no change, we're done.
261: * XXX Automedia may involve software intervention.
262: * Keep going in case the connected media changed.
263: * Similarly, if best match changed (kernel debugger?).
264: */
265: if ((IFM_SUBTYPE(newmedia) != IFM_AUTO) &&
266: (newmedia == ifm->ifm_media) &&
267: (match == ifm->ifm_cur))
268: return 0;
269:
270: /*
271: * We found a match, now make the driver switch to it.
272: * Make sure to preserve our old media type in case the
273: * driver can't switch.
274: */
275: #ifdef IFMEDIA_DEBUG
276: if (ifmedia_debug) {
277: printf("ifmedia_ioctl: switching %s to ",
278: ifp->if_xname);
279: ifmedia_printword(match->ifm_media);
280: }
281: #endif
282: oldentry = ifm->ifm_cur;
283: oldmedia = ifm->ifm_media;
284: ifm->ifm_cur = match;
285: ifm->ifm_media = newmedia;
286: error = (*ifm->ifm_change)(ifp);
287: if (error) {
288: ifm->ifm_cur = oldentry;
289: ifm->ifm_media = oldmedia;
290: }
291: break;
292: }
293:
294: /*
295: * Get list of available media and current media on interface.
296: */
297: case SIOCGIFMEDIA:
298: {
299: struct ifmedia_entry *ep;
300: size_t nwords;
301:
302: if(ifmr->ifm_count < 0)
303: return (EINVAL);
304:
305: ifmr->ifm_active = ifmr->ifm_current = ifm->ifm_cur ?
306: ifm->ifm_cur->ifm_media : IFM_NONE;
307: ifmr->ifm_mask = ifm->ifm_mask;
308: ifmr->ifm_status = 0;
309: (*ifm->ifm_status)(ifp, ifmr);
310:
311: /*
312: * Count them so we know a-priori how much is the max we'll
313: * need.
314: */
315: ep = TAILQ_FIRST(&ifm->ifm_list);
316: for (nwords = 0; ep != NULL; ep = TAILQ_NEXT(ep, ifm_list))
317: nwords++;
318:
319: if (ifmr->ifm_count != 0) {
320: size_t count;
321: size_t minwords = nwords > (size_t)ifmr->ifm_count
322: ? (size_t)ifmr->ifm_count
323: : nwords;
324: int *kptr = (int *)malloc(minwords * sizeof(int),
325: M_TEMP, M_WAITOK);
326: /*
327: * Get the media words from the interface's list.
328: */
329: ep = TAILQ_FIRST(&ifm->ifm_list);
330: for (count = 0; ep != NULL && count < minwords;
331: ep = TAILQ_NEXT(ep, ifm_list), count++)
332: kptr[count] = ep->ifm_media;
333:
334: error = copyout(kptr, ifmr->ifm_ulist,
335: minwords * sizeof(int));
336: if (error == 0 && ep != NULL)
337: error = E2BIG; /* oops! */
338: free(kptr, M_TEMP);
339: }
340: ifmr->ifm_count = nwords;
341: break;
342: }
343:
344: default:
345: return (EINVAL);
346: }
347:
348: return (error);
349: }
350:
351: /*
352: * Find media entry matching a given ifm word.
353: */
354: struct ifmedia_entry *
355: ifmedia_match(struct ifmedia *ifm, u_int target, u_int mask)
356: {
357: struct ifmedia_entry *match, *next;
358:
359: match = NULL;
360: mask = ~mask;
361:
362: for (next = TAILQ_FIRST(&ifm->ifm_list); next != NULL;
363: next = TAILQ_NEXT(next, ifm_list)) {
364: if ((next->ifm_media & mask) == (target & mask)) {
365: if (match) {
366: #if defined(IFMEDIA_DEBUG) || defined(DIAGNOSTIC)
367: printf("ifmedia_match: multiple match for "
368: "0x%x/0x%x, selected instance %d\n",
369: target, mask, IFM_INST(match->ifm_media));
370: #endif
371: break;
372: }
373: match = next;
374: }
375: }
376:
377: return match;
378: }
379:
380: /*
381: * Delete all media for a given instance.
382: */
383: void
384: ifmedia_delete_instance(struct ifmedia *ifm, u_int inst)
385: {
386: struct ifmedia_entry *ife, *nife;
387:
388: for (ife = TAILQ_FIRST(&ifm->ifm_list); ife != NULL;
389: ife = nife) {
390: nife = TAILQ_NEXT(ife, ifm_list);
391: if (inst == IFM_INST_ANY ||
392: inst == IFM_INST(ife->ifm_media)) {
393: TAILQ_REMOVE(&ifm->ifm_list, ife, ifm_list);
394: free(ife, M_IFADDR);
395: }
396: }
397: }
398:
399: /*
400: * Compute the interface `baudrate' from the media, for the interface
401: * metrics (used by routing daemons).
402: */
403: struct ifmedia_baudrate ifmedia_baudrate_descriptions[] =
404: IFM_BAUDRATE_DESCRIPTIONS;
405:
406: int
407: ifmedia_baudrate(int mword)
408: {
409: int i;
410:
411: for (i = 0; ifmedia_baudrate_descriptions[i].ifmb_word != 0; i++) {
412: if ((mword & (IFM_NMASK|IFM_TMASK)) ==
413: ifmedia_baudrate_descriptions[i].ifmb_word)
414: return (ifmedia_baudrate_descriptions[i].ifmb_baudrate);
415: }
416:
417: /* Not known. */
418: return (0);
419: }
420:
421: #ifdef IFMEDIA_DEBUG
422:
423: struct ifmedia_description ifm_type_descriptions[] =
424: IFM_TYPE_DESCRIPTIONS;
425:
426: struct ifmedia_description ifm_subtype_descriptions[] =
427: IFM_SUBTYPE_DESCRIPTIONS;
428:
429: struct ifmedia_description ifm_option_descriptions[] =
430: IFM_OPTION_DESCRIPTIONS;
431:
432: /*
433: * print a media word.
434: */
435: static void
436: ifmedia_printword(int ifmw)
437: {
438: struct ifmedia_description *desc;
439: int seen_option = 0;
440:
441: /* Print the top-level interface type. */
442: for (desc = ifm_type_descriptions; desc->ifmt_string != NULL;
443: desc++) {
444: if (IFM_TYPE(ifmw) == desc->ifmt_word)
445: break;
446: }
447: if (desc->ifmt_string == NULL)
448: printf("<unknown type> ");
449: else
450: printf("%s ", desc->ifmt_string);
451:
452: /* Print the subtype. */
453: for (desc = ifm_subtype_descriptions; desc->ifmt_string != NULL;
454: desc++) {
455: if (IFM_TYPE_MATCH(desc->ifmt_word, ifmw) &&
456: IFM_SUBTYPE(desc->ifmt_word) == IFM_SUBTYPE(ifmw))
457: break;
458: }
459: if (desc->ifmt_string == NULL)
460: printf("<unknown subtype>");
461: else
462: printf("%s", desc->ifmt_string);
463:
464: /* Print any options. */
465: for (desc = ifm_option_descriptions; desc->ifmt_string != NULL;
466: desc++) {
467: if (IFM_TYPE_MATCH(desc->ifmt_word, ifmw) &&
468: (ifmw & desc->ifmt_word) != 0 &&
469: (seen_option & IFM_OPTIONS(desc->ifmt_word)) == 0) {
470: if (seen_option == 0)
471: printf(" <");
472: printf("%s%s", seen_option ? "," : "",
473: desc->ifmt_string);
474: seen_option |= IFM_OPTIONS(desc->ifmt_word);
475: }
476: }
477: printf("%s\n", seen_option ? ">" : "");
478: }
479:
480: #endif /* IFMEDIA_DEBUG */
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to if_media.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / net