1 /* $NetBSD: if_media.c,v 1.1 1997/03/17 02:55:15 thorpej Exp $ */ 2 /* $FreeBSD: src/sys/net/if_media.c,v 1.9.2.4 2001/07/04 00:12:38 brooks Exp $ */ 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 <sys/param.h> 50 #include <sys/systm.h> 51 #include <sys/socket.h> 52 #include <sys/sockio.h> 53 #include <sys/malloc.h> 54 55 #include <net/if.h> 56 #include <net/if_var.h> 57 #include <net/if_media.h> 58 59 /* 60 * Compile-time options: 61 * IFMEDIA_DEBUG: 62 * turn on implementation-level debug kprintfs. 63 * Useful for debugging newly-ported drivers. 64 */ 65 66 static struct ifmedia_entry *ifmedia_match(struct ifmedia *ifm, 67 int flags, int mask); 68 69 #ifdef IFMEDIA_DEBUG 70 int ifmedia_debug = 0; 71 static void ifmedia_printword (int); 72 #endif 73 74 /* 75 * Initialize if_media struct for a specific interface instance. 76 */ 77 void 78 ifmedia_init(struct ifmedia *ifm, int dontcare_mask, 79 ifm_change_cb_t change_callback, ifm_stat_cb_t status_callback) 80 { 81 82 LIST_INIT(&ifm->ifm_list); 83 ifm->ifm_cur = NULL; 84 ifm->ifm_media = IFM_NONE; 85 ifm->ifm_mask = dontcare_mask; /* IF don't-care bits */ 86 ifm->ifm_change = change_callback; 87 ifm->ifm_status = status_callback; 88 } 89 90 void 91 ifmedia_removeall(struct ifmedia *ifm) 92 { 93 struct ifmedia_entry *entry; 94 95 while ((entry = LIST_FIRST(&ifm->ifm_list)) != NULL) { 96 LIST_REMOVE(entry, ifm_list); 97 kfree(entry, M_IFADDR); 98 } 99 ifm->ifm_cur = NULL; 100 ifm->ifm_media = IFM_NONE; 101 } 102 103 /* 104 * Add a media configuration to the list of supported media 105 * for a specific interface instance. 106 */ 107 void 108 ifmedia_add(struct ifmedia *ifm, int mword, int data, void *aux) 109 { 110 struct ifmedia_entry *entry; 111 112 #ifdef IFMEDIA_DEBUG 113 if (ifmedia_debug) { 114 if (ifm == NULL) { 115 kprintf("ifmedia_add: null ifm\n"); 116 return; 117 } 118 kprintf("Adding entry for "); 119 ifmedia_printword(mword); 120 } 121 #endif 122 123 entry = kmalloc(sizeof(*entry), M_IFADDR, M_INTWAIT); 124 entry->ifm_media = mword; 125 entry->ifm_data = data; 126 entry->ifm_aux = aux; 127 128 LIST_INSERT_HEAD(&ifm->ifm_list, entry, ifm_list); 129 } 130 131 int 132 ifmedia_add_nodup(struct ifmedia *ifm, int mword, int data, void *aux) 133 { 134 struct ifmedia_entry *match; 135 136 match = ifmedia_match(ifm, mword, ifm->ifm_mask); 137 if (match != NULL) 138 return EEXIST; 139 ifmedia_add(ifm, mword, data, aux); 140 return 0; 141 } 142 143 /* 144 * Add an array of media configurations to the list of 145 * supported media for a specific interface instance. 146 */ 147 void 148 ifmedia_list_add(struct ifmedia *ifm, struct ifmedia_entry *lp, 149 int count) 150 { 151 int i; 152 153 for (i = 0; i < count; i++) 154 ifmedia_add(ifm, lp[i].ifm_media, lp[i].ifm_data, 155 lp[i].ifm_aux); 156 } 157 158 /* 159 * Set the default active media. 160 * 161 * Called by device-specific code which is assumed to have already 162 * selected the default media in hardware. We do _not_ call the 163 * media-change callback. 164 */ 165 void 166 ifmedia_set(struct ifmedia *ifm, int target) 167 { 168 struct ifmedia_entry *match; 169 170 match = ifmedia_match(ifm, target, ifm->ifm_mask); 171 if (match == NULL) { 172 kprintf("ifmedia_set: no match for 0x%x/0x%x\n", 173 target, ~ifm->ifm_mask); 174 panic("ifmedia_set"); 175 } 176 ifm->ifm_cur = match; 177 ifm->ifm_media = target; 178 179 #ifdef IFMEDIA_DEBUG 180 if (ifmedia_debug) { 181 kprintf("ifmedia_set: target "); 182 ifmedia_printword(target); 183 kprintf("ifmedia_set: setting to "); 184 ifmedia_printword(ifm->ifm_cur->ifm_media); 185 } 186 #endif 187 } 188 189 int 190 ifmedia_tryset(struct ifmedia *ifm, int target) 191 { 192 struct ifmedia_entry *match; 193 194 match = ifmedia_match(ifm, target, ifm->ifm_mask); 195 if (match == NULL) 196 return ENOENT; 197 ifmedia_set(ifm, target); 198 return 0; 199 } 200 201 /* 202 * Given a media word, return one suitable for an application 203 * using the original encoding. 204 */ 205 static int 206 compat_media(int media) 207 { 208 209 if (IFM_TYPE(media) == IFM_ETHER && IFM_SUBTYPE(media) > IFM_OTHER) { 210 media &= ~(IFM_ETH_XTYPE|IFM_TMASK); 211 media |= IFM_OTHER; 212 } 213 return (media); 214 } 215 216 /* 217 * Device-independent media ioctl support function, typically called 218 * from the device network ioctl procedure. 219 */ 220 int 221 ifmedia_ioctl(struct ifnet *ifp, struct ifreq *ifr, 222 struct ifmedia *ifm, u_long cmd) 223 { 224 struct ifmedia_entry *match; 225 struct ifmediareq *ifmr = (struct ifmediareq *) ifr; 226 int error = 0, sticky; 227 228 if (ifp == NULL || ifr == NULL || ifm == NULL) 229 return (EINVAL); 230 231 ASSERT_IFNET_SERIALIZED_ALL(ifp); 232 233 switch (cmd) { 234 /* 235 * Set the current media. 236 */ 237 case SIOCSIFMEDIA: 238 { 239 struct ifmedia_entry *oldentry; 240 int oldmedia; 241 int newmedia = ifr->ifr_media; 242 243 match = ifmedia_match(ifm, newmedia, ifm->ifm_mask); 244 if (match == NULL) { 245 #ifdef IFMEDIA_DEBUG 246 if (ifmedia_debug) { 247 kprintf( 248 "ifmedia_ioctl: no media found for 0x%x\n", 249 newmedia); 250 } 251 #endif 252 return (ENXIO); 253 } 254 255 /* 256 * If no change, we're done. 257 * XXX Automedia may invole software intervention. 258 * Keep going in case the the connected media changed. 259 * Similarly, if best match changed (kernel debugger?). 260 */ 261 if ((IFM_SUBTYPE(newmedia) != IFM_AUTO) && 262 (newmedia == ifm->ifm_media) && 263 (match == ifm->ifm_cur)) 264 return 0; 265 266 /* 267 * We found a match, now make the driver switch to it. 268 * Make sure to preserve our old media type in case the 269 * driver can't switch. 270 */ 271 #ifdef IFMEDIA_DEBUG 272 if (ifmedia_debug) { 273 kprintf("ifmedia_ioctl: switching %s to ", 274 ifp->if_xname); 275 ifmedia_printword(match->ifm_media); 276 } 277 #endif 278 oldentry = ifm->ifm_cur; 279 oldmedia = ifm->ifm_media; 280 ifm->ifm_cur = match; 281 ifm->ifm_media = newmedia; 282 error = (*ifm->ifm_change)(ifp); 283 if (error) { 284 ifm->ifm_cur = oldentry; 285 ifm->ifm_media = oldmedia; 286 } 287 break; 288 } 289 290 /* 291 * Get list of available media and current media on interface. 292 */ 293 case SIOCGIFMEDIA: 294 case SIOCGIFXMEDIA: 295 { 296 struct ifmedia_entry *ep; 297 int *kptr, count; 298 int usermax; /* user requested max */ 299 300 kptr = NULL; /* XXX gcc */ 301 302 /* 303 * NOTE: 304 * ifm_cur may not contain certain media options, e.g. 305 * flow control options, so ifm_media should be used 306 * instead. 307 */ 308 if (cmd == SIOCGIFMEDIA) { 309 ifmr->ifm_active = ifmr->ifm_current = ifm->ifm_cur ? 310 compat_media(ifm->ifm_cur->ifm_media) : IFM_NONE; 311 } else { 312 ifmr->ifm_active = ifmr->ifm_current = ifm->ifm_cur ? 313 ifm->ifm_cur->ifm_media : IFM_NONE; 314 } 315 ifmr->ifm_mask = ifm->ifm_mask; 316 ifmr->ifm_status = 0; 317 (*ifm->ifm_status)(ifp, ifmr); 318 319 count = 0; 320 usermax = 0; 321 322 /* 323 * If there are more interfaces on the list, count 324 * them. This allows the caller to set ifmr->ifm_count 325 * to 0 on the first call to know how much space to 326 * allocate. 327 */ 328 LIST_FOREACH(ep, &ifm->ifm_list, ifm_list) 329 usermax++; 330 331 /* 332 * Don't allow the user to ask for too many 333 * or a negative number. 334 */ 335 if (ifmr->ifm_count > usermax) 336 ifmr->ifm_count = usermax; 337 else if (ifmr->ifm_count < 0) 338 return (EINVAL); 339 340 if (ifmr->ifm_count != 0) { 341 kptr = (int *)kmalloc(ifmr->ifm_count * sizeof(int), 342 M_TEMP, M_WAITOK); 343 344 /* 345 * Get the media words from the interface's list. 346 */ 347 ep = LIST_FIRST(&ifm->ifm_list); 348 for (; ep != NULL && count < ifmr->ifm_count; 349 ep = LIST_NEXT(ep, ifm_list), count++) 350 kptr[count] = ep->ifm_media; 351 352 if (ep != NULL) 353 error = E2BIG; /* oops! */ 354 } else { 355 count = usermax; 356 } 357 358 /* 359 * We do the copyout on E2BIG, because that's 360 * just our way of telling userland that there 361 * are more. This is the behavior I've observed 362 * under BSD/OS 3.0 363 */ 364 sticky = error; 365 if ((error == 0 || error == E2BIG) && ifmr->ifm_count != 0) { 366 error = copyout((caddr_t)kptr, 367 (caddr_t)ifmr->ifm_ulist, 368 ifmr->ifm_count * sizeof(int)); 369 } 370 371 if (error == 0) 372 error = sticky; 373 374 if (ifmr->ifm_count != 0) 375 kfree(kptr, M_TEMP); 376 377 ifmr->ifm_count = count; 378 break; 379 } 380 381 default: 382 return (EINVAL); 383 } 384 385 return (error); 386 } 387 388 /* 389 * Find media entry matching a given ifm word. 390 * 391 */ 392 static struct ifmedia_entry * 393 ifmedia_match(struct ifmedia *ifm, int target, int mask) 394 { 395 struct ifmedia_entry *match, *next; 396 397 match = NULL; 398 mask = ~mask; 399 400 LIST_FOREACH(next, &ifm->ifm_list, ifm_list) { 401 if ((next->ifm_media & mask) == (target & mask)) { 402 #if defined(IFMEDIA_DEBUG) || defined(DIAGNOSTIC) 403 if (match) { 404 kprintf("ifmedia_match: multiple match for " 405 "0x%x/0x%x\n", target, mask); 406 } 407 #endif 408 match = next; 409 } 410 } 411 412 return match; 413 } 414 415 struct ifmedia_baudrate ifmedia_baudrate_descriptions[] = 416 IFM_BAUDRATE_DESCRIPTIONS; 417 418 uint64_t 419 ifmedia_baudrate(int mword) 420 { 421 int i; 422 423 for (i = 0; ifmedia_baudrate_descriptions[i].ifmb_word != 0; i++) { 424 if (IFM_TYPE_MATCH(mword, ifmedia_baudrate_descriptions[i].ifmb_word)) 425 return (ifmedia_baudrate_descriptions[i].ifmb_baudrate); 426 } 427 428 /* Not known. */ 429 return (0); 430 } 431 432 int 433 ifmedia_str2ethfc(const char *str) 434 { 435 if (strcmp(str, IFM_ETH_FC_FULL) == 0) 436 return (IFM_ETH_RXPAUSE | IFM_ETH_TXPAUSE); 437 if (strcmp(str, IFM_ETH_FC_RXPAUSE) == 0) 438 return IFM_ETH_RXPAUSE; 439 if (strcmp(str, IFM_ETH_FC_TXPAUSE) == 0) 440 return IFM_ETH_TXPAUSE; 441 442 if (strcmp(str, IFM_ETH_FC_FORCE_FULL) == 0) 443 return (IFM_ETH_RXPAUSE | IFM_ETH_TXPAUSE | IFM_ETH_FORCEPAUSE); 444 if (strcmp(str, IFM_ETH_FC_FORCE_RXPAUSE) == 0) 445 return (IFM_ETH_RXPAUSE | IFM_ETH_FORCEPAUSE); 446 if (strcmp(str, IFM_ETH_FC_FORCE_TXPAUSE) == 0) 447 return (IFM_ETH_TXPAUSE | IFM_ETH_FORCEPAUSE); 448 if (strcmp(str, IFM_ETH_FC_FORCE_NONE) == 0) 449 return IFM_ETH_FORCEPAUSE; 450 451 return 0; 452 } 453 454 #ifdef IFMEDIA_DEBUG 455 struct ifmedia_description ifm_type_descriptions[] = 456 IFM_TYPE_DESCRIPTIONS; 457 458 struct ifmedia_description ifm_subtype_ethernet_descriptions[] = 459 IFM_SUBTYPE_ETHERNET_DESCRIPTIONS; 460 461 struct ifmedia_description ifm_subtype_ethernet_option_descriptions[] = 462 IFM_SUBTYPE_ETHERNET_OPTION_DESCRIPTIONS; 463 464 struct ifmedia_description ifm_subtype_ieee80211_descriptions[] = 465 IFM_SUBTYPE_IEEE80211_DESCRIPTIONS; 466 467 struct ifmedia_description ifm_subtype_ieee80211_option_descriptions[] = 468 IFM_SUBTYPE_IEEE80211_OPTION_DESCRIPTIONS; 469 470 struct ifmedia_description ifm_subtype_shared_descriptions[] = 471 IFM_SUBTYPE_SHARED_DESCRIPTIONS; 472 473 struct ifmedia_description ifm_shared_option_descriptions[] = 474 IFM_SHARED_OPTION_DESCRIPTIONS; 475 476 struct ifmedia_type_to_subtype { 477 struct ifmedia_description *subtypes; 478 struct ifmedia_description *options; 479 }; 480 481 /* must be in the same order as IFM_TYPE_DESCRIPTIONS */ 482 struct ifmedia_type_to_subtype ifmedia_types_to_subtypes[] = { 483 { 484 &ifm_subtype_ethernet_descriptions[0], 485 &ifm_subtype_ethernet_option_descriptions[0] 486 }, 487 { 488 &ifm_subtype_ieee80211_descriptions[0], 489 &ifm_subtype_ieee80211_option_descriptions[0] 490 }, 491 }; 492 493 /* 494 * print a media word. 495 */ 496 static void 497 ifmedia_printword(int ifmw) 498 { 499 struct ifmedia_description *desc; 500 struct ifmedia_type_to_subtype *ttos; 501 int seen_option = 0; 502 503 /* Find the top-level interface type. */ 504 for (desc = ifm_type_descriptions, ttos = ifmedia_types_to_subtypes; 505 desc->ifmt_string != NULL; desc++, ttos++) 506 if (IFM_TYPE(ifmw) == desc->ifmt_word) 507 break; 508 if (desc->ifmt_string == NULL) { 509 kprintf("<unknown type>\n"); 510 return; 511 } 512 kprintf("%s", desc->ifmt_string); 513 514 /* 515 * Check for the shared subtype descriptions first, then the 516 * type-specific ones. 517 */ 518 for (desc = ifm_subtype_shared_descriptions; 519 desc->ifmt_string != NULL; desc++) 520 if (IFM_SUBTYPE(ifmw) == desc->ifmt_word) 521 goto got_subtype; 522 523 for (desc = ttos->subtypes; desc->ifmt_string != NULL; desc++) 524 if (IFM_SUBTYPE(ifmw) == desc->ifmt_word) 525 break; 526 if (desc->ifmt_string == NULL) { 527 kprintf(" <unknown subtype>\n"); 528 return; 529 } 530 531 got_subtype: 532 kprintf(" %s", desc->ifmt_string); 533 534 /* 535 * Look for shared options. 536 */ 537 for (desc = ifm_shared_option_descriptions; 538 desc->ifmt_string != NULL; desc++) { 539 if (ifmw & desc->ifmt_word) { 540 if (seen_option == 0) 541 kprintf(" <"); 542 kprintf("%s%s", seen_option++ ? "," : "", 543 desc->ifmt_string); 544 } 545 } 546 547 /* 548 * Look for subtype-specific options. 549 */ 550 for (desc = ttos->options; desc->ifmt_string != NULL; desc++) { 551 if (ifmw & desc->ifmt_word) { 552 if (seen_option == 0) 553 kprintf(" <"); 554 kprintf("%s%s", seen_option++ ? "," : "", 555 desc->ifmt_string); 556 } 557 } 558 kprintf("%s\n", seen_option ? ">" : ""); 559 } 560 #endif /* IFMEDIA_DEBUG */ 561