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