1 /* $FreeBSD$ */ 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/param.h> 28 #include <sys/systm.h> 29 #include <sys/bus.h> 30 #include <sys/condvar.h> 31 #include <sys/kernel.h> 32 #include <sys/lock.h> 33 #include <sys/malloc.h> 34 #include <sys/mbuf.h> 35 #include <sys/module.h> 36 #include <sys/socket.h> 37 #include <sys/sockio.h> 38 #include <sys/sysctl.h> 39 40 #include <net/if.h> 41 #include <net/ifq_var.h> 42 #include <net/ethernet.h> 43 #include <net/if_types.h> 44 #include <net/if_media.h> 45 #include <net/vlan/if_vlan_var.h> 46 47 #include <sys/devfs.h> 48 49 #include <dev/netif/mii_layer/mii.h> 50 #include <dev/netif/mii_layer/miivar.h> 51 52 #include <bus/u4b/usb.h> 53 #include <bus/u4b/usbdi.h> 54 55 #include <bus/u4b/usb_process.h> 56 #include <bus/u4b/net/usb_ethernet.h> 57 58 static SYSCTL_NODE(_net, OID_AUTO, ue, CTLFLAG_RD, 0, 59 "USB Ethernet parameters"); 60 61 #define UE_LOCK(_ue) lockmgr((_ue)->ue_lock, LK_EXCLUSIVE) 62 #define UE_UNLOCK(_ue) lockmgr((_ue)->ue_lock, LK_RELEASE) 63 #define UE_LOCK_ASSERT(_ue) KKASSERT(lockowned((_ue)->ue_lock)) 64 65 MODULE_DEPEND(uether, usb, 1, 1, 1); 66 MODULE_DEPEND(uether, miibus, 1, 1, 1); 67 68 /* 69 static struct unrhdr *ueunit; 70 */ 71 DEVFS_DECLARE_CLONE_BITMAP(ue); 72 73 static usb_proc_callback_t ue_attach_post_task; 74 static usb_proc_callback_t ue_promisc_task; 75 static usb_proc_callback_t ue_setmulti_task; 76 static usb_proc_callback_t ue_ifmedia_task; 77 static usb_proc_callback_t ue_tick_task; 78 static usb_proc_callback_t ue_start_task; 79 static usb_proc_callback_t ue_stop_task; 80 81 static void ue_init(void *); 82 static void ue_start(struct ifnet *, struct ifaltq_subque *); 83 static int ue_ifmedia_upd(struct ifnet *); 84 static void ue_watchdog(void *); 85 86 /* 87 * Return values: 88 * 0: success 89 * Else: device has been detached 90 */ 91 uint8_t 92 uether_pause(struct usb_ether *ue, unsigned int _ticks) 93 { 94 if (usb_proc_is_gone(&ue->ue_tq)) { 95 /* nothing to do */ 96 return (1); 97 } 98 usb_pause_mtx(ue->ue_lock, _ticks); 99 return (0); 100 } 101 102 static void 103 ue_queue_command(struct usb_ether *ue, 104 usb_proc_callback_t *fn, 105 struct usb_proc_msg *t0, struct usb_proc_msg *t1) 106 { 107 struct usb_ether_cfg_task *task; 108 109 UE_LOCK_ASSERT(ue); 110 111 if (usb_proc_is_gone(&ue->ue_tq)) { 112 return; /* nothing to do */ 113 } 114 /* 115 * NOTE: The task cannot get executed before we drop the 116 * "sc_mtx" mutex. It is safe to update fields in the message 117 * structure after that the message got queued. 118 */ 119 task = (struct usb_ether_cfg_task *) 120 usb_proc_msignal(&ue->ue_tq, t0, t1); 121 122 /* Setup callback and self pointers */ 123 task->hdr.pm_callback = fn; 124 task->ue = ue; 125 126 /* 127 * Start and stop must be synchronous! 128 */ 129 if ((fn == ue_start_task) || (fn == ue_stop_task)) 130 usb_proc_mwait(&ue->ue_tq, t0, t1); 131 } 132 133 struct ifnet * 134 uether_getifp(struct usb_ether *ue) 135 { 136 return &(ue->ue_arpcom.ac_if); 137 } 138 139 struct mii_data * 140 uether_getmii(struct usb_ether *ue) 141 { 142 return (device_get_softc(ue->ue_miibus)); 143 } 144 145 void * 146 uether_getsc(struct usb_ether *ue) 147 { 148 return (ue->ue_sc); 149 } 150 151 static int 152 ue_sysctl_parent(SYSCTL_HANDLER_ARGS) 153 { 154 struct usb_ether *ue = arg1; 155 const char *name; 156 157 name = device_get_nameunit(ue->ue_dev); 158 return SYSCTL_OUT(req, name, strlen(name)); 159 } 160 161 int 162 uether_ifattach(struct usb_ether *ue) 163 { 164 int error; 165 166 /* check some critical parameters */ 167 if ((ue->ue_dev == NULL) || 168 (ue->ue_udev == NULL) || 169 (ue->ue_lock == NULL) || 170 (ue->ue_methods == NULL)) 171 return (EINVAL); 172 173 error = usb_proc_create(&ue->ue_tq, ue->ue_lock, 174 device_get_nameunit(ue->ue_dev), USB_PRI_MED); 175 if (error) { 176 device_printf(ue->ue_dev, "could not setup taskqueue\n"); 177 goto error; 178 } 179 180 /* fork rest of the attach code */ 181 UE_LOCK(ue); 182 ue_queue_command(ue, ue_attach_post_task, 183 &ue->ue_sync_task[0].hdr, 184 &ue->ue_sync_task[1].hdr); 185 UE_UNLOCK(ue); 186 187 error: 188 return (error); 189 } 190 191 static void 192 ue_attach_post_task(struct usb_proc_msg *_task) 193 { 194 struct usb_ether_cfg_task *task = 195 (struct usb_ether_cfg_task *)_task; 196 struct usb_ether *ue = task->ue; 197 struct ifnet *ifp = uether_getifp(ue); 198 int error; 199 char num[14]; /* sufficient for 32 bits */ 200 201 /* first call driver's post attach routine */ 202 ue->ue_methods->ue_attach_post(ue); 203 204 UE_UNLOCK(ue); 205 206 KKASSERT(!lockowned(ue->ue_lock)); 207 ue->ue_unit = devfs_clone_bitmap_get(&DEVFS_CLONE_BITMAP(ue), 0); 208 usb_callout_init_mtx(&ue->ue_watchdog, ue->ue_lock, 0); 209 sysctl_ctx_init(&ue->ue_sysctl_ctx); 210 211 KKASSERT(!lockowned(ue->ue_lock)); 212 error = 0; 213 214 KKASSERT(!lockowned(ue->ue_lock)); 215 ifp->if_softc = ue; 216 if_initname(ifp, "ue", ue->ue_unit); 217 if (ue->ue_methods->ue_attach_post_sub != NULL) { 218 error = ue->ue_methods->ue_attach_post_sub(ue); 219 KKASSERT(!lockowned(ue->ue_lock)); 220 } else { 221 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 222 if (ue->ue_methods->ue_ioctl != NULL) 223 ifp->if_ioctl = ue->ue_methods->ue_ioctl; 224 else 225 ifp->if_ioctl = uether_ioctl; 226 ifp->if_start = ue_start; 227 ifp->if_init = ue_init; 228 ifq_set_maxlen(&ifp->if_snd, ifqmaxlen); 229 ifq_set_ready(&ifp->if_snd); 230 231 if (ue->ue_methods->ue_mii_upd != NULL && 232 ue->ue_methods->ue_mii_sts != NULL) { 233 error = mii_phy_probe(ue->ue_dev, &ue->ue_miibus, 234 ue_ifmedia_upd, ue->ue_methods->ue_mii_sts); 235 } 236 } 237 238 if (error) { 239 device_printf(ue->ue_dev, "attaching PHYs failed\n"); 240 goto fail; 241 } 242 243 if_printf(ifp, "<USB Ethernet> on %s\n", device_get_nameunit(ue->ue_dev)); 244 ether_ifattach(ifp, ue->ue_eaddr, NULL); 245 /* Tell upper layer we support VLAN oversized frames. */ 246 if (ifp->if_capabilities & IFCAP_VLAN_MTU) 247 ifp->if_hdrlen = sizeof(struct ether_vlan_header); 248 249 ksnprintf(num, sizeof(num), "%u", ue->ue_unit); 250 ue->ue_sysctl_oid = SYSCTL_ADD_NODE(&ue->ue_sysctl_ctx, 251 &SYSCTL_NODE_CHILDREN(_net, ue), 252 OID_AUTO, num, CTLFLAG_RD, NULL, ""); 253 SYSCTL_ADD_PROC(&ue->ue_sysctl_ctx, 254 SYSCTL_CHILDREN(ue->ue_sysctl_oid), OID_AUTO, 255 "%parent", CTLTYPE_STRING | CTLFLAG_RD, ue, 0, 256 ue_sysctl_parent, "A", "parent device"); 257 258 KKASSERT(!lockowned(ue->ue_lock)); 259 UE_LOCK(ue); 260 return; 261 262 fail: 263 devfs_clone_bitmap_put(&DEVFS_CLONE_BITMAP(ue), ue->ue_unit); 264 UE_LOCK(ue); 265 return; 266 } 267 268 void 269 uether_ifdetach(struct usb_ether *ue) 270 { 271 struct ifnet *ifp; 272 273 /* wait for any post attach or other command to complete */ 274 usb_proc_drain(&ue->ue_tq); 275 276 /* read "ifnet" pointer after taskqueue drain */ 277 ifp = uether_getifp(ue); 278 279 if (ifp != NULL) { 280 281 /* we are not running any more */ 282 UE_LOCK(ue); 283 ifp->if_flags &= ~IFF_RUNNING; 284 UE_UNLOCK(ue); 285 286 /* drain any callouts */ 287 usb_callout_drain(&ue->ue_watchdog); 288 289 /* detach miibus */ 290 if (ue->ue_miibus != NULL) { 291 device_delete_child(ue->ue_dev, ue->ue_miibus); 292 } 293 294 /* detach ethernet */ 295 ether_ifdetach(ifp); 296 297 /* free sysctl */ 298 sysctl_ctx_free(&ue->ue_sysctl_ctx); 299 300 /* free unit */ 301 devfs_clone_bitmap_put(&DEVFS_CLONE_BITMAP(ue), ue->ue_unit); 302 } 303 304 /* free taskqueue, if any */ 305 usb_proc_free(&ue->ue_tq); 306 } 307 308 uint8_t 309 uether_is_gone(struct usb_ether *ue) 310 { 311 return (usb_proc_is_gone(&ue->ue_tq)); 312 } 313 314 void 315 uether_init(void *arg) 316 { 317 ue_init(arg); 318 } 319 320 static void 321 ue_init(void *arg) 322 { 323 struct usb_ether *ue = arg; 324 325 UE_LOCK(ue); 326 ue_queue_command(ue, ue_start_task, 327 &ue->ue_sync_task[0].hdr, 328 &ue->ue_sync_task[1].hdr); 329 UE_UNLOCK(ue); 330 } 331 332 static void 333 ue_start_task(struct usb_proc_msg *_task) 334 { 335 struct usb_ether_cfg_task *task = 336 (struct usb_ether_cfg_task *)_task; 337 struct usb_ether *ue = task->ue; 338 struct ifnet *ifp = uether_getifp(ue); 339 340 UE_LOCK_ASSERT(ue); 341 342 ue->ue_methods->ue_init(ue); 343 344 if ((ifp->if_flags & IFF_RUNNING) == 0) 345 return; 346 if (ue->ue_methods->ue_tick != NULL) 347 usb_callout_reset(&ue->ue_watchdog, hz, ue_watchdog, ue); 348 } 349 350 static void 351 ue_stop_task(struct usb_proc_msg *_task) 352 { 353 struct usb_ether_cfg_task *task = 354 (struct usb_ether_cfg_task *)_task; 355 struct usb_ether *ue = task->ue; 356 357 UE_LOCK_ASSERT(ue); 358 359 usb_callout_stop(&ue->ue_watchdog); 360 361 ue->ue_methods->ue_stop(ue); 362 } 363 364 void 365 uether_start(struct ifnet *ifp, struct ifaltq_subque *ifsq) 366 { 367 368 ue_start(ifp, ifsq); 369 } 370 371 static void 372 ue_start(struct ifnet *ifp, struct ifaltq_subque *ifsq) 373 { 374 struct usb_ether *ue = ifp->if_softc; 375 376 ASSERT_ALTQ_SQ_DEFAULT(ifp, ifsq); 377 378 if ((ifp->if_flags & IFF_RUNNING) == 0) 379 return; 380 UE_LOCK(ue); 381 ue->ue_methods->ue_start(ue); 382 UE_UNLOCK(ue); 383 } 384 385 static void 386 ue_promisc_task(struct usb_proc_msg *_task) 387 { 388 struct usb_ether_cfg_task *task = 389 (struct usb_ether_cfg_task *)_task; 390 struct usb_ether *ue = task->ue; 391 392 ue->ue_methods->ue_setpromisc(ue); 393 } 394 395 static void 396 ue_setmulti_task(struct usb_proc_msg *_task) 397 { 398 struct usb_ether_cfg_task *task = 399 (struct usb_ether_cfg_task *)_task; 400 struct usb_ether *ue = task->ue; 401 402 ue->ue_methods->ue_setmulti(ue); 403 } 404 405 int 406 uether_ifmedia_upd(struct ifnet *ifp) 407 { 408 409 return (ue_ifmedia_upd(ifp)); 410 } 411 412 static int 413 ue_ifmedia_upd(struct ifnet *ifp) 414 { 415 struct usb_ether *ue = ifp->if_softc; 416 417 /* Defer to process context */ 418 UE_LOCK(ue); 419 ue_queue_command(ue, ue_ifmedia_task, 420 &ue->ue_media_task[0].hdr, 421 &ue->ue_media_task[1].hdr); 422 UE_UNLOCK(ue); 423 424 return (0); 425 } 426 427 static void 428 ue_ifmedia_task(struct usb_proc_msg *_task) 429 { 430 struct usb_ether_cfg_task *task = 431 (struct usb_ether_cfg_task *)_task; 432 struct usb_ether *ue = task->ue; 433 struct ifnet *ifp = uether_getifp(ue); 434 435 ue->ue_methods->ue_mii_upd(ifp); 436 } 437 438 static void 439 ue_watchdog(void *arg) 440 { 441 struct usb_ether *ue = arg; 442 struct ifnet *ifp = uether_getifp(ue); 443 444 if ((ifp->if_flags & IFF_RUNNING) == 0) 445 return; 446 447 ue_queue_command(ue, ue_tick_task, 448 &ue->ue_tick_task[0].hdr, 449 &ue->ue_tick_task[1].hdr); 450 451 usb_callout_reset(&ue->ue_watchdog, hz, ue_watchdog, ue); 452 } 453 454 static void 455 ue_tick_task(struct usb_proc_msg *_task) 456 { 457 struct usb_ether_cfg_task *task = 458 (struct usb_ether_cfg_task *)_task; 459 struct usb_ether *ue = task->ue; 460 struct ifnet *ifp = uether_getifp(ue); 461 462 if ((ifp->if_flags & IFF_RUNNING) == 0) 463 return; 464 465 ue->ue_methods->ue_tick(ue); 466 } 467 468 int 469 uether_ioctl(struct ifnet *ifp, u_long command, caddr_t data, struct ucred* uc) 470 { 471 struct usb_ether *ue = ifp->if_softc; 472 struct ifreq *ifr = (struct ifreq *)data; 473 struct mii_data *mii; 474 int error = 0; 475 476 switch (command) { 477 case SIOCSIFFLAGS: 478 UE_LOCK(ue); 479 if (ifp->if_flags & IFF_UP) { 480 if (ifp->if_flags & IFF_RUNNING) 481 ue_queue_command(ue, ue_promisc_task, 482 &ue->ue_promisc_task[0].hdr, 483 &ue->ue_promisc_task[1].hdr); 484 else 485 ue_queue_command(ue, ue_start_task, 486 &ue->ue_sync_task[0].hdr, 487 &ue->ue_sync_task[1].hdr); 488 } else { 489 ue_queue_command(ue, ue_stop_task, 490 &ue->ue_sync_task[0].hdr, 491 &ue->ue_sync_task[1].hdr); 492 } 493 UE_UNLOCK(ue); 494 break; 495 case SIOCADDMULTI: 496 case SIOCDELMULTI: 497 UE_LOCK(ue); 498 ue_queue_command(ue, ue_setmulti_task, 499 &ue->ue_multi_task[0].hdr, 500 &ue->ue_multi_task[1].hdr); 501 UE_UNLOCK(ue); 502 break; 503 case SIOCGIFMEDIA: 504 case SIOCSIFMEDIA: 505 if (ue->ue_miibus != NULL) { 506 mii = device_get_softc(ue->ue_miibus); 507 error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, command); 508 } else 509 error = ether_ioctl(ifp, command, data); 510 break; 511 default: 512 error = ether_ioctl(ifp, command, data); 513 break; 514 } 515 return (error); 516 } 517 518 static int 519 uether_modevent(module_t mod, int type, void *data) 520 { 521 static int attached = 0; 522 523 switch (type) { 524 case MOD_LOAD: 525 if (attached) 526 return (EEXIST); 527 528 devfs_clone_bitmap_init(&DEVFS_CLONE_BITMAP(ue)); 529 530 attached = 1; 531 break; 532 case MOD_UNLOAD: 533 devfs_clone_bitmap_uninit(&DEVFS_CLONE_BITMAP(ue)); 534 break; 535 default: 536 return (EOPNOTSUPP); 537 } 538 return (0); 539 } 540 static moduledata_t uether_mod = { 541 "uether", 542 uether_modevent, 543 0 544 }; 545 546 struct mbuf * 547 uether_newbuf(void) 548 { 549 struct mbuf *m_new; 550 551 m_new = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR); 552 if (m_new == NULL) 553 return (NULL); 554 m_new->m_len = m_new->m_pkthdr.len = MCLBYTES; 555 556 m_adj(m_new, ETHER_ALIGN); 557 return (m_new); 558 } 559 560 int 561 uether_rxmbuf(struct usb_ether *ue, struct mbuf *m, 562 unsigned int len) 563 { 564 struct ifnet *ifp = uether_getifp(ue); 565 566 UE_LOCK_ASSERT(ue); 567 568 /* finalize mbuf */ 569 IFNET_STAT_INC(ifp, ipackets, 1); 570 m->m_pkthdr.rcvif = ifp; 571 m->m_pkthdr.len = m->m_len = len; 572 573 /* enqueue for later when the lock can be released */ 574 IF_ENQUEUE(&ue->ue_rxq, m); 575 return (0); 576 } 577 578 int 579 uether_rxbuf(struct usb_ether *ue, struct usb_page_cache *pc, 580 unsigned int offset, unsigned int len) 581 { 582 struct ifnet *ifp = uether_getifp(ue); 583 struct mbuf *m; 584 585 UE_LOCK_ASSERT(ue); 586 587 if (len < ETHER_HDR_LEN || len > MCLBYTES - ETHER_ALIGN) 588 return (1); 589 590 m = uether_newbuf(); 591 if (m == NULL) { 592 IFNET_STAT_INC(ifp, iqdrops, 1); 593 return (ENOMEM); 594 } 595 596 usbd_copy_out(pc, offset, mtod(m, uint8_t *), len); 597 598 /* finalize mbuf */ 599 IFNET_STAT_INC(ifp, ipackets, 1); 600 m->m_pkthdr.rcvif = ifp; 601 m->m_pkthdr.len = m->m_len = len; 602 603 /* enqueue for later when the lock can be released */ 604 IF_ENQUEUE(&ue->ue_rxq, m); 605 return (0); 606 } 607 608 void 609 uether_rxflush(struct usb_ether *ue) 610 { 611 struct ifnet *ifp = uether_getifp(ue); 612 struct mbuf *m; 613 614 UE_LOCK_ASSERT(ue); 615 616 for (;;) { 617 IF_DEQUEUE(&ue->ue_rxq, m); 618 if (m == NULL) 619 break; 620 621 /* 622 * The USB xfer has been resubmitted so its safe to unlock now. 623 */ 624 UE_UNLOCK(ue); 625 ifp->if_input(ifp, m, NULL, -1); 626 UE_LOCK(ue); 627 } 628 } 629 630 DECLARE_MODULE(uether, uether_mod, SI_SUB_PSEUDO, SI_ORDER_ANY); 631 MODULE_VERSION(uether, 1); 632