usb_ethernet.c revision 213438
1/* $FreeBSD: head/sys/dev/usb/net/usb_ethernet.c 213438 2010-10-04 23:25:38Z yongari $ */ 2/*- 3 * Copyright (c) 2009 Andrew Thompson (thompsa@FreeBSD.org) 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27#include <sys/stdint.h> 28#include <sys/stddef.h> 29#include <sys/param.h> 30#include <sys/queue.h> 31#include <sys/types.h> 32#include <sys/systm.h> 33#include <sys/kernel.h> 34#include <sys/bus.h> 35#include <sys/linker_set.h> 36#include <sys/module.h> 37#include <sys/lock.h> 38#include <sys/mutex.h> 39#include <sys/condvar.h> 40#include <sys/sysctl.h> 41#include <sys/sx.h> 42#include <sys/unistd.h> 43#include <sys/callout.h> 44#include <sys/malloc.h> 45#include <sys/priv.h> 46 47#include <dev/usb/usb.h> 48#include <dev/usb/usbdi.h> 49 50#include <dev/usb/usb_process.h> 51#include <dev/usb/net/usb_ethernet.h> 52 53SYSCTL_NODE(_net, OID_AUTO, ue, CTLFLAG_RD, 0, "USB Ethernet parameters"); 54 55#define UE_LOCK(_ue) mtx_lock((_ue)->ue_mtx) 56#define UE_UNLOCK(_ue) mtx_unlock((_ue)->ue_mtx) 57#define UE_LOCK_ASSERT(_ue, t) mtx_assert((_ue)->ue_mtx, t) 58 59MODULE_DEPEND(uether, usb, 1, 1, 1); 60MODULE_DEPEND(uether, miibus, 1, 1, 1); 61 62static struct unrhdr *ueunit; 63 64static usb_proc_callback_t ue_attach_post_task; 65static usb_proc_callback_t ue_promisc_task; 66static usb_proc_callback_t ue_setmulti_task; 67static usb_proc_callback_t ue_ifmedia_task; 68static usb_proc_callback_t ue_tick_task; 69static usb_proc_callback_t ue_start_task; 70static usb_proc_callback_t ue_stop_task; 71 72static void ue_init(void *); 73static void ue_start(struct ifnet *); 74static int ue_ifmedia_upd(struct ifnet *); 75static void ue_watchdog(void *); 76 77/* 78 * Return values: 79 * 0: success 80 * Else: device has been detached 81 */ 82uint8_t 83uether_pause(struct usb_ether *ue, unsigned int _ticks) 84{ 85 if (usb_proc_is_gone(&ue->ue_tq)) { 86 /* nothing to do */ 87 return (1); 88 } 89 usb_pause_mtx(ue->ue_mtx, _ticks); 90 return (0); 91} 92 93static void 94ue_queue_command(struct usb_ether *ue, 95 usb_proc_callback_t *fn, 96 struct usb_proc_msg *t0, struct usb_proc_msg *t1) 97{ 98 struct usb_ether_cfg_task *task; 99 100 UE_LOCK_ASSERT(ue, MA_OWNED); 101 102 if (usb_proc_is_gone(&ue->ue_tq)) { 103 return; /* nothing to do */ 104 } 105 /* 106 * NOTE: The task cannot get executed before we drop the 107 * "sc_mtx" mutex. It is safe to update fields in the message 108 * structure after that the message got queued. 109 */ 110 task = (struct usb_ether_cfg_task *) 111 usb_proc_msignal(&ue->ue_tq, t0, t1); 112 113 /* Setup callback and self pointers */ 114 task->hdr.pm_callback = fn; 115 task->ue = ue; 116 117 /* 118 * Start and stop must be synchronous! 119 */ 120 if ((fn == ue_start_task) || (fn == ue_stop_task)) 121 usb_proc_mwait(&ue->ue_tq, t0, t1); 122} 123 124struct ifnet * 125uether_getifp(struct usb_ether *ue) 126{ 127 return (ue->ue_ifp); 128} 129 130struct mii_data * 131uether_getmii(struct usb_ether *ue) 132{ 133 return (device_get_softc(ue->ue_miibus)); 134} 135 136void * 137uether_getsc(struct usb_ether *ue) 138{ 139 return (ue->ue_sc); 140} 141 142static int 143ue_sysctl_parent(SYSCTL_HANDLER_ARGS) 144{ 145 struct usb_ether *ue = arg1; 146 const char *name; 147 148 name = device_get_nameunit(ue->ue_dev); 149 return SYSCTL_OUT(req, name, strlen(name)); 150} 151 152int 153uether_ifattach(struct usb_ether *ue) 154{ 155 int error; 156 157 /* check some critical parameters */ 158 if ((ue->ue_dev == NULL) || 159 (ue->ue_udev == NULL) || 160 (ue->ue_mtx == NULL) || 161 (ue->ue_methods == NULL)) 162 return (EINVAL); 163 164 error = usb_proc_create(&ue->ue_tq, ue->ue_mtx, 165 device_get_nameunit(ue->ue_dev), USB_PRI_MED); 166 if (error) { 167 device_printf(ue->ue_dev, "could not setup taskqueue\n"); 168 goto error; 169 } 170 171 /* fork rest of the attach code */ 172 UE_LOCK(ue); 173 ue_queue_command(ue, ue_attach_post_task, 174 &ue->ue_sync_task[0].hdr, 175 &ue->ue_sync_task[1].hdr); 176 UE_UNLOCK(ue); 177 178error: 179 return (error); 180} 181 182static void 183ue_attach_post_task(struct usb_proc_msg *_task) 184{ 185 struct usb_ether_cfg_task *task = 186 (struct usb_ether_cfg_task *)_task; 187 struct usb_ether *ue = task->ue; 188 struct ifnet *ifp; 189 int error; 190 char num[14]; /* sufficient for 32 bits */ 191 192 /* first call driver's post attach routine */ 193 ue->ue_methods->ue_attach_post(ue); 194 195 UE_UNLOCK(ue); 196 197 ue->ue_unit = alloc_unr(ueunit); 198 usb_callout_init_mtx(&ue->ue_watchdog, ue->ue_mtx, 0); 199 sysctl_ctx_init(&ue->ue_sysctl_ctx); 200 201 ifp = if_alloc(IFT_ETHER); 202 if (ifp == NULL) { 203 device_printf(ue->ue_dev, "could not allocate ifnet\n"); 204 goto error; 205 } 206 207 ifp->if_softc = ue; 208 if_initname(ifp, "ue", ue->ue_unit); 209 ifp->if_mtu = ETHERMTU; 210 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 211 if (ue->ue_methods->ue_ioctl != NULL) 212 ifp->if_ioctl = ue->ue_methods->ue_ioctl; 213 else 214 ifp->if_ioctl = uether_ioctl; 215 ifp->if_start = ue_start; 216 ifp->if_init = ue_init; 217 IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen); 218 ifp->if_snd.ifq_drv_maxlen = ifqmaxlen; 219 IFQ_SET_READY(&ifp->if_snd); 220 ue->ue_ifp = ifp; 221 222 if (ue->ue_methods->ue_mii_upd != NULL && 223 ue->ue_methods->ue_mii_sts != NULL) { 224 mtx_lock(&Giant); /* device_xxx() depends on this */ 225 error = mii_phy_probe(ue->ue_dev, &ue->ue_miibus, 226 ue_ifmedia_upd, ue->ue_methods->ue_mii_sts); 227 mtx_unlock(&Giant); 228 if (error) { 229 device_printf(ue->ue_dev, "MII without any PHY\n"); 230 goto error; 231 } 232 } 233 234 if_printf(ifp, "<USB Ethernet> on %s\n", device_get_nameunit(ue->ue_dev)); 235 ether_ifattach(ifp, ue->ue_eaddr); 236 237 snprintf(num, sizeof(num), "%u", ue->ue_unit); 238 ue->ue_sysctl_oid = SYSCTL_ADD_NODE(&ue->ue_sysctl_ctx, 239 &SYSCTL_NODE_CHILDREN(_net, ue), 240 OID_AUTO, num, CTLFLAG_RD, NULL, ""); 241 SYSCTL_ADD_PROC(&ue->ue_sysctl_ctx, 242 SYSCTL_CHILDREN(ue->ue_sysctl_oid), OID_AUTO, 243 "%parent", CTLFLAG_RD, ue, 0, 244 ue_sysctl_parent, "A", "parent device"); 245 246 UE_LOCK(ue); 247 return; 248 249error: 250 free_unr(ueunit, ue->ue_unit); 251 if (ue->ue_ifp != NULL) { 252 if_free(ue->ue_ifp); 253 ue->ue_ifp = NULL; 254 } 255 UE_LOCK(ue); 256 return; 257} 258 259void 260uether_ifdetach(struct usb_ether *ue) 261{ 262 struct ifnet *ifp; 263 264 /* wait for any post attach or other command to complete */ 265 usb_proc_drain(&ue->ue_tq); 266 267 /* read "ifnet" pointer after taskqueue drain */ 268 ifp = ue->ue_ifp; 269 270 if (ifp != NULL) { 271 272 /* we are not running any more */ 273 UE_LOCK(ue); 274 ifp->if_drv_flags &= ~IFF_DRV_RUNNING; 275 UE_UNLOCK(ue); 276 277 /* drain any callouts */ 278 usb_callout_drain(&ue->ue_watchdog); 279 280 /* detach miibus */ 281 if (ue->ue_miibus != NULL) { 282 mtx_lock(&Giant); /* device_xxx() depends on this */ 283 device_delete_child(ue->ue_dev, ue->ue_miibus); 284 mtx_unlock(&Giant); 285 } 286 287 /* detach ethernet */ 288 ether_ifdetach(ifp); 289 290 /* free interface instance */ 291 if_free(ifp); 292 293 /* free sysctl */ 294 sysctl_ctx_free(&ue->ue_sysctl_ctx); 295 296 /* free unit */ 297 free_unr(ueunit, ue->ue_unit); 298 } 299 300 /* free taskqueue, if any */ 301 usb_proc_free(&ue->ue_tq); 302} 303 304uint8_t 305uether_is_gone(struct usb_ether *ue) 306{ 307 return (usb_proc_is_gone(&ue->ue_tq)); 308} 309 310static void 311ue_init(void *arg) 312{ 313 struct usb_ether *ue = arg; 314 315 UE_LOCK(ue); 316 ue_queue_command(ue, ue_start_task, 317 &ue->ue_sync_task[0].hdr, 318 &ue->ue_sync_task[1].hdr); 319 UE_UNLOCK(ue); 320} 321 322static void 323ue_start_task(struct usb_proc_msg *_task) 324{ 325 struct usb_ether_cfg_task *task = 326 (struct usb_ether_cfg_task *)_task; 327 struct usb_ether *ue = task->ue; 328 struct ifnet *ifp = ue->ue_ifp; 329 330 UE_LOCK_ASSERT(ue, MA_OWNED); 331 332 ue->ue_methods->ue_init(ue); 333 334 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) 335 return; 336 337 if (ue->ue_methods->ue_tick != NULL) 338 usb_callout_reset(&ue->ue_watchdog, hz, ue_watchdog, ue); 339} 340 341static void 342ue_stop_task(struct usb_proc_msg *_task) 343{ 344 struct usb_ether_cfg_task *task = 345 (struct usb_ether_cfg_task *)_task; 346 struct usb_ether *ue = task->ue; 347 348 UE_LOCK_ASSERT(ue, MA_OWNED); 349 350 usb_callout_stop(&ue->ue_watchdog); 351 352 ue->ue_methods->ue_stop(ue); 353} 354 355static void 356ue_start(struct ifnet *ifp) 357{ 358 struct usb_ether *ue = ifp->if_softc; 359 360 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) 361 return; 362 363 UE_LOCK(ue); 364 ue->ue_methods->ue_start(ue); 365 UE_UNLOCK(ue); 366} 367 368static void 369ue_promisc_task(struct usb_proc_msg *_task) 370{ 371 struct usb_ether_cfg_task *task = 372 (struct usb_ether_cfg_task *)_task; 373 struct usb_ether *ue = task->ue; 374 375 ue->ue_methods->ue_setpromisc(ue); 376} 377 378static void 379ue_setmulti_task(struct usb_proc_msg *_task) 380{ 381 struct usb_ether_cfg_task *task = 382 (struct usb_ether_cfg_task *)_task; 383 struct usb_ether *ue = task->ue; 384 385 ue->ue_methods->ue_setmulti(ue); 386} 387 388static int 389ue_ifmedia_upd(struct ifnet *ifp) 390{ 391 struct usb_ether *ue = ifp->if_softc; 392 393 /* Defer to process context */ 394 UE_LOCK(ue); 395 ue_queue_command(ue, ue_ifmedia_task, 396 &ue->ue_media_task[0].hdr, 397 &ue->ue_media_task[1].hdr); 398 UE_UNLOCK(ue); 399 400 return (0); 401} 402 403static void 404ue_ifmedia_task(struct usb_proc_msg *_task) 405{ 406 struct usb_ether_cfg_task *task = 407 (struct usb_ether_cfg_task *)_task; 408 struct usb_ether *ue = task->ue; 409 struct ifnet *ifp = ue->ue_ifp; 410 411 ue->ue_methods->ue_mii_upd(ifp); 412} 413 414static void 415ue_watchdog(void *arg) 416{ 417 struct usb_ether *ue = arg; 418 struct ifnet *ifp = ue->ue_ifp; 419 420 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) 421 return; 422 423 ue_queue_command(ue, ue_tick_task, 424 &ue->ue_tick_task[0].hdr, 425 &ue->ue_tick_task[1].hdr); 426 427 usb_callout_reset(&ue->ue_watchdog, hz, ue_watchdog, ue); 428} 429 430static void 431ue_tick_task(struct usb_proc_msg *_task) 432{ 433 struct usb_ether_cfg_task *task = 434 (struct usb_ether_cfg_task *)_task; 435 struct usb_ether *ue = task->ue; 436 struct ifnet *ifp = ue->ue_ifp; 437 438 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) 439 return; 440 441 ue->ue_methods->ue_tick(ue); 442} 443 444int 445uether_ioctl(struct ifnet *ifp, u_long command, caddr_t data) 446{ 447 struct usb_ether *ue = ifp->if_softc; 448 struct ifreq *ifr = (struct ifreq *)data; 449 struct mii_data *mii; 450 int error = 0; 451 452 switch (command) { 453 case SIOCSIFFLAGS: 454 UE_LOCK(ue); 455 if (ifp->if_flags & IFF_UP) { 456 if (ifp->if_drv_flags & IFF_DRV_RUNNING) 457 ue_queue_command(ue, ue_promisc_task, 458 &ue->ue_promisc_task[0].hdr, 459 &ue->ue_promisc_task[1].hdr); 460 else 461 ue_queue_command(ue, ue_start_task, 462 &ue->ue_sync_task[0].hdr, 463 &ue->ue_sync_task[1].hdr); 464 } else { 465 ue_queue_command(ue, ue_stop_task, 466 &ue->ue_sync_task[0].hdr, 467 &ue->ue_sync_task[1].hdr); 468 } 469 UE_UNLOCK(ue); 470 break; 471 case SIOCADDMULTI: 472 case SIOCDELMULTI: 473 UE_LOCK(ue); 474 ue_queue_command(ue, ue_setmulti_task, 475 &ue->ue_multi_task[0].hdr, 476 &ue->ue_multi_task[1].hdr); 477 UE_UNLOCK(ue); 478 break; 479 case SIOCGIFMEDIA: 480 case SIOCSIFMEDIA: 481 if (ue->ue_miibus != NULL) { 482 mii = device_get_softc(ue->ue_miibus); 483 error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, command); 484 } else 485 error = ether_ioctl(ifp, command, data); 486 break; 487 default: 488 error = ether_ioctl(ifp, command, data); 489 break; 490 } 491 return (error); 492} 493 494static int 495uether_modevent(module_t mod, int type, void *data) 496{ 497 498 switch (type) { 499 case MOD_LOAD: 500 ueunit = new_unrhdr(0, INT_MAX, NULL); 501 break; 502 case MOD_UNLOAD: 503 break; 504 default: 505 return (EOPNOTSUPP); 506 } 507 return (0); 508} 509static moduledata_t uether_mod = { 510 "uether", 511 uether_modevent, 512 0 513}; 514 515struct mbuf * 516uether_newbuf(void) 517{ 518 struct mbuf *m_new; 519 520 m_new = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR); 521 if (m_new == NULL) 522 return (NULL); 523 m_new->m_len = m_new->m_pkthdr.len = MCLBYTES; 524 525 m_adj(m_new, ETHER_ALIGN); 526 return (m_new); 527} 528 529int 530uether_rxmbuf(struct usb_ether *ue, struct mbuf *m, 531 unsigned int len) 532{ 533 struct ifnet *ifp = ue->ue_ifp; 534 535 UE_LOCK_ASSERT(ue, MA_OWNED); 536 537 /* finalize mbuf */ 538 ifp->if_ipackets++; 539 m->m_pkthdr.rcvif = ifp; 540 m->m_pkthdr.len = m->m_len = len; 541 542 /* enqueue for later when the lock can be released */ 543 _IF_ENQUEUE(&ue->ue_rxq, m); 544 return (0); 545} 546 547int 548uether_rxbuf(struct usb_ether *ue, struct usb_page_cache *pc, 549 unsigned int offset, unsigned int len) 550{ 551 struct ifnet *ifp = ue->ue_ifp; 552 struct mbuf *m; 553 554 UE_LOCK_ASSERT(ue, MA_OWNED); 555 556 if (len < ETHER_HDR_LEN || len > MCLBYTES - ETHER_ALIGN) 557 return (1); 558 559 m = uether_newbuf(); 560 if (m == NULL) { 561 ifp->if_iqdrops++; 562 return (ENOMEM); 563 } 564 565 usbd_copy_out(pc, offset, mtod(m, uint8_t *), len); 566 567 /* finalize mbuf */ 568 ifp->if_ipackets++; 569 m->m_pkthdr.rcvif = ifp; 570 m->m_pkthdr.len = m->m_len = len; 571 572 /* enqueue for later when the lock can be released */ 573 _IF_ENQUEUE(&ue->ue_rxq, m); 574 return (0); 575} 576 577void 578uether_rxflush(struct usb_ether *ue) 579{ 580 struct ifnet *ifp = ue->ue_ifp; 581 struct mbuf *m; 582 583 UE_LOCK_ASSERT(ue, MA_OWNED); 584 585 for (;;) { 586 _IF_DEQUEUE(&ue->ue_rxq, m); 587 if (m == NULL) 588 break; 589 590 /* 591 * The USB xfer has been resubmitted so its safe to unlock now. 592 */ 593 UE_UNLOCK(ue); 594 ifp->if_input(ifp, m); 595 UE_LOCK(ue); 596 } 597} 598 599DECLARE_MODULE(uether, uether_mod, SI_SUB_PSEUDO, SI_ORDER_ANY); 600MODULE_VERSION(uether, 1); 601