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