sys/dev/hyperv/netvsc/hv_netvsc_drv_freebsd.c

   1 /*-
   2  * Copyright (c) 2010-2012 Citrix Inc.
   3  * Copyright (c) 2009-2012 Microsoft Corp.
   4  * Copyright (c) 2012 NetApp Inc.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice unmodified, this list of conditions, and the following
  12  *    disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 /*-
  30  * Copyright (c) 2004-2006 Kip Macy
  31  * All rights reserved.
  32  *
  33  * Redistribution and use in source and binary forms, with or without
  34  * modification, are permitted provided that the following conditions
  35  * are met:
  36  * 1. Redistributions of source code must retain the above copyright
  37  *    notice, this list of conditions and the following disclaimer.
  38  * 2. Redistributions in binary form must reproduce the above copyright
  39  *    notice, this list of conditions and the following disclaimer in the
  40  *    documentation and/or other materials provided with the distribution.
  41  *
  42  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  43  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  44  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  45  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  46  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  47  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  48  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  49  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  50  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  51  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  52  * SUCH DAMAGE.
  53  */
  54
  55 #include <sys/cdefs.h>
  56 __FBSDID("$FreeBSD$");
  57
  58 #include "opt_inet6.h"
  59 #include "opt_inet.h"
  60
  61 #include <sys/param.h>
  62 #include <sys/systm.h>
  63 #include <sys/sockio.h>
  64 #include <sys/mbuf.h>
  65 #include <sys/malloc.h>
  66 #include <sys/module.h>
  67 #include <sys/kernel.h>
  68 #include <sys/socket.h>
  69 #include <sys/queue.h>
  70 #include <sys/lock.h>
  71 #include <sys/sx.h>
  72
  73 #include <net/if.h>
  74 #include <net/if_arp.h>
  75 #include <net/ethernet.h>
  76 #include <net/if_dl.h>
  77 #include <net/if_media.h>
  78
  79 #include <net/bpf.h>
  80
  81 #include <net/if_types.h>
  82 #include <net/if_vlan_var.h>
  83 #include <net/if.h>
  84
  85 #include <netinet/in_systm.h>
  86 #include <netinet/in.h>
  87 #include <netinet/ip.h>
  88 #include <netinet/if_ether.h>
  89 #include <netinet/tcp.h>
  90 #include <netinet/udp.h>
  91 #include <netinet/ip6.h>
  92
  93 #include <vm/vm.h>
  94 #include <vm/vm_param.h>
  95 #include <vm/vm_kern.h>
  96 #include <vm/pmap.h>
  97
  98 #include <machine/bus.h>
  99 #include <machine/resource.h>
 100 #include <machine/frame.h>
 101 #include <machine/vmparam.h>
 102
 103 #include <sys/bus.h>
 104 #include <sys/rman.h>
 105 #include <sys/mutex.h>
 106 #include <sys/errno.h>
 107 #include <sys/types.h>
 108 #include <machine/atomic.h>
 109
 110 #include <machine/intr_machdep.h>
 111
 112 #include <machine/in_cksum.h>
 113
 114 #include <dev/hyperv/include/hyperv.h>
 115 #include "hv_net_vsc.h"
 116 #include "hv_rndis.h"
 117 #include "hv_rndis_filter.h"
 118
 119
 120 /* Short for Hyper-V network interface */
 121 #define NETVSC_DEVNAME    "hn"
 122
 123 /*
 124  * It looks like offset 0 of buf is reserved to hold the softc pointer.
 125  * The sc pointer evidently not needed, and is not presently populated.
 126  * The packet offset is where the netvsc_packet starts in the buffer.
 127  */
 128 #define HV_NV_SC_PTR_OFFSET_IN_BUF         0
 129 #define HV_NV_PACKET_OFFSET_IN_BUF         16
 130
 131
 132 /*
 133  * Data types
 134  */
 135
 136 struct hv_netvsc_driver_context {
 137         uint32_t                drv_inited;
 138 };
 139
 140 /*
 141  * Be aware that this sleepable mutex will exhibit WITNESS errors when
 142  * certain TCP and ARP code paths are taken.  This appears to be a
 143  * well-known condition, as all other drivers checked use a sleeping
 144  * mutex to protect their transmit paths.
 145  * Also Be aware that mutexes do not play well with semaphores, and there
 146  * is a conflicting semaphore in a certain channel code path.
 147  */
 148 #define NV_LOCK_INIT(_sc, _name) \
 149             mtx_init(&(_sc)->hn_lock, _name, MTX_NETWORK_LOCK, MTX_DEF)
 150 #define NV_LOCK(_sc)            mtx_lock(&(_sc)->hn_lock)
 151 #define NV_LOCK_ASSERT(_sc)     mtx_assert(&(_sc)->hn_lock, MA_OWNED)
 152 #define NV_UNLOCK(_sc)          mtx_unlock(&(_sc)->hn_lock)
 153 #define NV_LOCK_DESTROY(_sc)    mtx_destroy(&(_sc)->hn_lock)
 154
 155
 156 /*
 157  * Globals
 158  */
 159
 160 int hv_promisc_mode = 0;    /* normal mode by default */
 161
 162 /* The one and only one */
 163 static struct hv_netvsc_driver_context g_netvsc_drv;
 164
 165
 166 /*
 167  * Forward declarations
 168  */
 169 static void hn_stop(hn_softc_t *sc);
 170 static void hn_ifinit_locked(hn_softc_t *sc);
 171 static void hn_ifinit(void *xsc);
 172 static int  hn_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data);
 173 static int  hn_start_locked(struct ifnet *ifp);
 174 static void hn_start(struct ifnet *ifp);
 175
 176 /*
 177  * NetVsc get message transport protocol type
 178  */
 179 static uint32_t get_transport_proto_type(struct mbuf *m_head)
 180 {
 181         uint32_t ret_val = TRANSPORT_TYPE_NOT_IP;
 182         uint16_t ether_type = 0;
 183         int ether_len = 0;
 184         struct ether_vlan_header *eh;
 185 #ifdef INET
 186         struct ip *iph;
 187 #endif
 188 #ifdef INET6
 189         struct ip6_hdr *ip6;
 190 #endif
 191
 192         eh = mtod(m_head, struct ether_vlan_header*);
 193         if (eh->evl_encap_proto == htons(ETHERTYPE_VLAN)) {
 194                 ether_len = ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN;
 195                 ether_type = eh->evl_proto;
 196         } else {
 197                 ether_len = ETHER_HDR_LEN;
 198                 ether_type = eh->evl_encap_proto;
 199         }
 200
 201         switch (ntohs(ether_type)) {
 202 #ifdef INET6
 203         case ETHERTYPE_IPV6:
 204                 ip6 = (struct ip6_hdr *)(m_head->m_data + ether_len);
 205
 206                 if (IPPROTO_TCP == ip6->ip6_nxt) {
 207                         ret_val = TRANSPORT_TYPE_IPV6_TCP;
 208                 } else if (IPPROTO_UDP == ip6->ip6_nxt) {
 209                         ret_val = TRANSPORT_TYPE_IPV6_UDP;
 210                 }
 211                 break;
 212 #endif
 213 #ifdef INET
 214         case ETHERTYPE_IP:
 215                 iph = (struct ip *)(m_head->m_data + ether_len);
 216
 217                 if (IPPROTO_TCP == iph->ip_p) {
 218                         ret_val = TRANSPORT_TYPE_IPV4_TCP;
 219                 } else if (IPPROTO_UDP == iph->ip_p) {
 220                         ret_val = TRANSPORT_TYPE_IPV4_UDP;
 221                 }
 222                 break;
 223 #endif
 224         default:
 225                 ret_val = TRANSPORT_TYPE_NOT_IP;
 226                 break;
 227         }
 228
 229         return (ret_val);
 230 }
 231
 232 /*
 233  * NetVsc driver initialization
 234  * Note:  Filter init is no longer required
 235  */
 236 static int
 237 netvsc_drv_init(void)
 238 {
 239         return (0);
 240 }
 241
 242 /*
 243  * NetVsc global initialization entry point
 244  */
 245 static void
 246 netvsc_init(void)
 247 {
 248         if (bootverbose)
 249                 printf("Netvsc initializing... ");
 250
 251         /*
 252          * XXXKYS: cleanup initialization
 253          */
 254         if (!cold && !g_netvsc_drv.drv_inited) {
 255                 g_netvsc_drv.drv_inited = 1;
 256                 netvsc_drv_init();
 257                 if (bootverbose)
 258                         printf("done!\n");
 259         } else if (bootverbose)
 260                 printf("Already initialized!\n");
 261 }
 262
 263 /* {F8615163-DF3E-46c5-913F-F2D2F965ED0E} */
 264 static const hv_guid g_net_vsc_device_type = {
 265         .data = {0x63, 0x51, 0x61, 0xF8, 0x3E, 0xDF, 0xc5, 0x46,
 266                 0x91, 0x3F, 0xF2, 0xD2, 0xF9, 0x65, 0xED, 0x0E}
 267 };
 268
 269 /*
 270  * Standard probe entry point.
 271  *
 272  */
 273 static int
 274 netvsc_probe(device_t dev)
 275 {
 276         const char *p;
 277
 278         p = vmbus_get_type(dev);
 279         if (!memcmp(p, &g_net_vsc_device_type.data, sizeof(hv_guid))) {
 280                 device_set_desc(dev, "Synthetic Network Interface");
 281                 if (bootverbose)
 282                         printf("Netvsc probe... DONE \n");
 283
 284                 return (BUS_PROBE_DEFAULT);
 285         }
 286
 287         return (ENXIO);
 288 }
 289
 290 /*
 291  * Standard attach entry point.
 292  *
 293  * Called when the driver is loaded.  It allocates needed resources,
 294  * and initializes the "hardware" and software.
 295  */
 296 static int
 297 netvsc_attach(device_t dev)
 298 {
 299         struct hv_device *device_ctx = vmbus_get_devctx(dev);
 300         netvsc_device_info device_info;
 301         hn_softc_t *sc;
 302         int unit = device_get_unit(dev);
 303         struct ifnet *ifp;
 304         int ret;
 305
 306         netvsc_init();
 307
 308         sc = device_get_softc(dev);
 309         if (sc == NULL) {
 310                 return (ENOMEM);
 311         }
 312
 313         bzero(sc, sizeof(hn_softc_t));
 314         sc->hn_unit = unit;
 315         sc->hn_dev = dev;
 316
 317         NV_LOCK_INIT(sc, "NetVSCLock");
 318
 319         sc->hn_dev_obj = device_ctx;
 320
 321         ifp = sc->hn_ifp = sc->arpcom.ac_ifp = if_alloc(IFT_ETHER);
 322         ifp->if_softc = sc;
 323
 324         if_initname(ifp, device_get_name(dev), device_get_unit(dev));
 325         ifp->if_dunit = unit;
 326         ifp->if_dname = NETVSC_DEVNAME;
 327
 328         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
 329         ifp->if_ioctl = hn_ioctl;
 330         ifp->if_start = hn_start;
 331         ifp->if_init = hn_ifinit;
 332         /* needed by hv_rf_on_device_add() code */
 333         ifp->if_mtu = ETHERMTU;
 334         IFQ_SET_MAXLEN(&ifp->if_snd, 512);
 335         ifp->if_snd.ifq_drv_maxlen = 511;
 336         IFQ_SET_READY(&ifp->if_snd);
 337
 338         /*
 339          * Tell upper layers that we support full VLAN capability.
 340          */
 341         ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header);
 342         ifp->if_capabilities |=
 343             IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_MTU | IFCAP_HWCSUM | IFCAP_TSO;
 344         ifp->if_capenable |=
 345             IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_MTU | IFCAP_HWCSUM | IFCAP_TSO;
 346         ifp->if_hwassist = CSUM_TCP | CSUM_UDP | CSUM_TSO;
 347
 348         ret = hv_rf_on_device_add(device_ctx, &device_info);
 349         if (ret != 0) {
 350                 if_free(ifp);
 351
 352                 return (ret);
 353         }
 354         if (device_info.link_state == 0) {
 355                 sc->hn_carrier = 1;
 356         }
 357
 358         ether_ifattach(ifp, device_info.mac_addr);
 359
 360         return (0);
 361 }
 362
 363 /*
 364  * Standard detach entry point
 365  */
 366 static int
 367 netvsc_detach(device_t dev)
 368 {
 369         struct hv_device *hv_device = vmbus_get_devctx(dev);
 370
 371         if (bootverbose)
 372                 printf("netvsc_detach\n");
 373
 374         /*
 375          * XXXKYS:  Need to clean up all our
 376          * driver state; this is the driver
 377          * unloading.
 378          */
 379
 380         /*
 381          * XXXKYS:  Need to stop outgoing traffic and unregister
 382          * the netdevice.
 383          */
 384
 385         hv_rf_on_device_remove(hv_device, HV_RF_NV_DESTROY_CHANNEL);
 386
 387         return (0);
 388 }
 389
 390 /*
 391  * Standard shutdown entry point
 392  */
 393 static int
 394 netvsc_shutdown(device_t dev)
 395 {
 396         return (0);
 397 }
 398
 399 /*
 400  * Send completion processing
 401  *
 402  * Note:  It looks like offset 0 of buf is reserved to hold the softc
 403  * pointer.  The sc pointer is not currently needed in this function, and
 404  * it is not presently populated by the TX function.
 405  */
 406 void
 407 netvsc_xmit_completion(void *context)
 408 {
 409         netvsc_packet *packet = (netvsc_packet *)context;
 410         struct mbuf *mb;
 411         uint8_t *buf;
 412
 413         mb = (struct mbuf *)(uintptr_t)packet->compl.send.send_completion_tid;
 414         buf = ((uint8_t *)packet) - HV_NV_PACKET_OFFSET_IN_BUF;
 415
 416         free(buf, M_NETVSC);
 417
 418         if (mb != NULL) {
 419                 m_freem(mb);
 420         }
 421 }
 422
 423 /*
 424  * Start a transmit of one or more packets
 425  */
 426 static int
 427 hn_start_locked(struct ifnet *ifp)
 428 {
 429         hn_softc_t *sc = ifp->if_softc;
 430         struct hv_device *device_ctx = vmbus_get_devctx(sc->hn_dev);
 431         netvsc_dev *net_dev = sc->net_dev;
 432         device_t dev = device_ctx->device;
 433         uint8_t *buf;
 434         netvsc_packet *packet;
 435         struct mbuf *m_head, *m;
 436         struct mbuf *mc_head = NULL;
 437         struct ether_vlan_header *eh;
 438         rndis_msg *rndis_mesg;
 439         rndis_packet *rndis_pkt;
 440         rndis_per_packet_info *rppi;
 441         ndis_8021q_info *rppi_vlan_info;
 442         rndis_tcp_ip_csum_info *csum_info;
 443         rndis_tcp_tso_info *tso_info;
 444         int ether_len;
 445         int i;
 446         int num_frags;
 447         int len;
 448         int retries = 0;
 449         int ret = 0;
 450         uint32_t rndis_msg_size = 0;
 451         uint32_t trans_proto_type;
 452         uint32_t send_buf_section_idx =
 453             NVSP_1_CHIMNEY_SEND_INVALID_SECTION_INDEX;
 454
 455         while (!IFQ_DRV_IS_EMPTY(&sc->hn_ifp->if_snd)) {
 456                 IFQ_DRV_DEQUEUE(&sc->hn_ifp->if_snd, m_head);
 457                 if (m_head == NULL) {
 458                         break;
 459                 }
 460
 461                 len = 0;
 462                 num_frags = 0;
 463
 464                 /* Walk the mbuf list computing total length and num frags */
 465                 for (m = m_head; m != NULL; m = m->m_next) {
 466                         if (m->m_len != 0) {
 467                                 num_frags++;
 468                                 len += m->m_len;
 469                         }
 470                 }
 471
 472                 /*
 473                  * Reserve the number of pages requested.  Currently,
 474                  * one page is reserved for the message in the RNDIS
 475                  * filter packet
 476                  */
 477                 num_frags += HV_RF_NUM_TX_RESERVED_PAGE_BUFS;
 478
 479                 /* If exceeds # page_buffers in netvsc_packet */
 480                 if (num_frags > NETVSC_PACKET_MAXPAGE) {
 481                         device_printf(dev, "exceed max page buffers,%d,%d\n",
 482                             num_frags, NETVSC_PACKET_MAXPAGE);
 483                         m_freem(m_head);
 484                         if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
 485                         return (EINVAL);
 486                 }
 487
 488                 /*
 489                  * Allocate a buffer with space for a netvsc packet plus a
 490                  * number of reserved areas.  First comes a (currently 16
 491                  * bytes, currently unused) reserved data area.  Second is
 492                  * the netvsc_packet. Third is an area reserved for an
 493                  * rndis_filter_packet struct. Fourth (optional) is a
 494                  * rndis_per_packet_info struct.
 495                  * Changed malloc to M_NOWAIT to avoid sleep under spin lock.
 496                  * No longer reserving extra space for page buffers, as they
 497                  * are already part of the netvsc_packet.
 498                  */
 499                 buf = malloc(HV_NV_PACKET_OFFSET_IN_BUF +
 500                         sizeof(netvsc_packet) +
 501                         sizeof(rndis_msg) +
 502                         RNDIS_VLAN_PPI_SIZE +
 503                         RNDIS_TSO_PPI_SIZE +
 504                         RNDIS_CSUM_PPI_SIZE,
 505                         M_NETVSC, M_ZERO | M_NOWAIT);
 506                 if (buf == NULL) {
 507                         device_printf(dev, "hn:malloc packet failed\n");
 508                         m_freem(m_head);
 509                         if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
 510                         return (ENOMEM);
 511                 }
 512
 513                 packet = (netvsc_packet *)(buf + HV_NV_PACKET_OFFSET_IN_BUF);
 514                 *(vm_offset_t *)buf = HV_NV_SC_PTR_OFFSET_IN_BUF;
 515
 516                 packet->is_data_pkt = TRUE;
 517
 518                 /* Set up the rndis header */
 519                 packet->page_buf_count = num_frags;
 520
 521                 /* Initialize it from the mbuf */
 522                 packet->tot_data_buf_len = len;
 523
 524                 /*
 525                  * extension points to the area reserved for the
 526                  * rndis_filter_packet, which is placed just after
 527                  * the netvsc_packet (and rppi struct, if present;
 528                  * length is updated later).
 529                  */
 530                 packet->rndis_mesg = packet + 1;
 531                 rndis_mesg = (rndis_msg *)packet->rndis_mesg;
 532                 rndis_mesg->ndis_msg_type = REMOTE_NDIS_PACKET_MSG;
 533
 534                 rndis_pkt = &rndis_mesg->msg.packet;
 535                 rndis_pkt->data_offset = sizeof(rndis_packet);
 536                 rndis_pkt->data_length = packet->tot_data_buf_len;
 537                 rndis_pkt->per_pkt_info_offset = sizeof(rndis_packet);
 538
 539                 rndis_msg_size = RNDIS_MESSAGE_SIZE(rndis_packet);
 540
 541                 /*
 542                  * If the Hyper-V infrastructure needs to embed a VLAN tag,
 543                  * initialize netvsc_packet and rppi struct values as needed.
 544                  */
 545                 if (m_head->m_flags & M_VLANTAG) {
 546                         /*
 547                          * set up some additional fields so the Hyper-V infrastructure will stuff the VLAN tag
 548                          * into the frame.
 549                          */
 550                         packet->vlan_tci = m_head->m_pkthdr.ether_vtag;
 551
 552                         rndis_msg_size += RNDIS_VLAN_PPI_SIZE;
 553
 554                         rppi = hv_set_rppi_data(rndis_mesg, RNDIS_VLAN_PPI_SIZE,
 555                             ieee_8021q_info);
 556
 557                         /* VLAN info immediately follows rppi struct */
 558                         rppi_vlan_info = (ndis_8021q_info *)((char*)rppi +
 559                             rppi->per_packet_info_offset);
 560                         /* FreeBSD does not support CFI or priority */
 561                         rppi_vlan_info->u1.s1.vlan_id =
 562                             packet->vlan_tci & 0xfff;
 563                 }
 564
 565                 if (0 == m_head->m_pkthdr.csum_flags) {
 566                         goto pre_send;
 567                 }
 568
 569                 eh = mtod(m_head, struct ether_vlan_header*);
 570                 if (eh->evl_encap_proto == htons(ETHERTYPE_VLAN)) {
 571                         ether_len = ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN;
 572                 } else {
 573                         ether_len = ETHER_HDR_LEN;
 574                 }
 575
 576                 trans_proto_type = get_transport_proto_type(m_head);
 577                 if (TRANSPORT_TYPE_NOT_IP == trans_proto_type) {
 578                         goto pre_send;
 579                 }
 580
 581                 /*
 582                  * TSO packet needless to setup the send side checksum
 583                  * offload.
 584                  */
 585                 if (m_head->m_pkthdr.csum_flags & CSUM_TSO) {
 586                         goto do_tso;
 587                 }
 588
 589                 /* setup checksum offload */
 590                 rndis_msg_size += RNDIS_CSUM_PPI_SIZE;
 591                 rppi = hv_set_rppi_data(rndis_mesg, RNDIS_CSUM_PPI_SIZE,
 592                     tcpip_chksum_info);
 593                 csum_info = (rndis_tcp_ip_csum_info *)((char*)rppi +
 594                     rppi->per_packet_info_offset);
 595
 596                 if (trans_proto_type & (TYPE_IPV4 << 16)) {
 597                         csum_info->xmit.is_ipv4 = 1;
 598                 } else {
 599                         csum_info->xmit.is_ipv6 = 1;
 600                 }
 601
 602                 if (trans_proto_type & TYPE_TCP) {
 603                         csum_info->xmit.tcp_csum = 1;
 604                         csum_info->xmit.tcp_header_offset = 0;
 605                 } else if (trans_proto_type & TYPE_UDP) {
 606                         csum_info->xmit.udp_csum = 1;
 607                 }
 608
 609                 goto pre_send;
 610
 611 do_tso:
 612                 /* setup TCP segmentation offload */
 613                 rndis_msg_size += RNDIS_TSO_PPI_SIZE;
 614                 rppi = hv_set_rppi_data(rndis_mesg, RNDIS_TSO_PPI_SIZE,
 615                     tcp_large_send_info);
 616
 617                 tso_info = (rndis_tcp_tso_info *)((char *)rppi +
 618                     rppi->per_packet_info_offset);
 619                 tso_info->lso_v2_xmit.type =
 620                     RNDIS_TCP_LARGE_SEND_OFFLOAD_V2_TYPE;
 621
 622 #ifdef INET
 623                 if (trans_proto_type & (TYPE_IPV4 << 16)) {
 624                         struct ip *ip =
 625                             (struct ip *)(m_head->m_data + ether_len);
 626                         unsigned long iph_len = ip->ip_hl << 2;
 627                         struct tcphdr *th =
 628                             (struct tcphdr *)((caddr_t)ip + iph_len);
 629
 630                         tso_info->lso_v2_xmit.ip_version =
 631                             RNDIS_TCP_LARGE_SEND_OFFLOAD_IPV4;
 632                         ip->ip_len = 0;
 633                         ip->ip_sum = 0;
 634
 635                         th->th_sum = in_pseudo(ip->ip_src.s_addr,
 636                             ip->ip_dst.s_addr,
 637                             htons(IPPROTO_TCP));
 638                 }
 639 #endif
 640 #if defined(INET6) && defined(INET)
 641                 else
 642 #endif
 643 #ifdef INET6
 644                 {
 645                         struct ip6_hdr *ip6 =
 646                             (struct ip6_hdr *)(m_head->m_data + ether_len);
 647                         struct tcphdr *th = (struct tcphdr *)(ip6 + 1);
 648
 649                         tso_info->lso_v2_xmit.ip_version =
 650                             RNDIS_TCP_LARGE_SEND_OFFLOAD_IPV6;
 651                         ip6->ip6_plen = 0;
 652                         th->th_sum = in6_cksum_pseudo(ip6, 0, IPPROTO_TCP, 0);
 653                 }
 654 #endif
 655                 tso_info->lso_v2_xmit.tcp_header_offset = 0;
 656                 tso_info->lso_v2_xmit.mss = m_head->m_pkthdr.tso_segsz;
 657
 658 pre_send:
 659                 rndis_mesg->msg_len = packet->tot_data_buf_len + rndis_msg_size;
 660                 packet->tot_data_buf_len = rndis_mesg->msg_len;
 661
 662                 /* send packet with send buffer */
 663                 if (packet->tot_data_buf_len < net_dev->send_section_size) {
 664                         send_buf_section_idx =
 665                             hv_nv_get_next_send_section(net_dev);
 666                         if (send_buf_section_idx !=
 667                             NVSP_1_CHIMNEY_SEND_INVALID_SECTION_INDEX) {
 668                                 char *dest = ((char *)net_dev->send_buf +
 669                                     send_buf_section_idx *
 670                                     net_dev->send_section_size);
 671
 672                                 memcpy(dest, rndis_mesg, rndis_msg_size);
 673                                 dest += rndis_msg_size;
 674                                 for (m = m_head; m != NULL; m = m->m_next) {
 675                                         if (m->m_len) {
 676                                                 memcpy(dest,
 677                                                     (void *)mtod(m, vm_offset_t),
 678                                                     m->m_len);
 679                                                 dest += m->m_len;
 680                                         }
 681                                 }
 682
 683                                 packet->send_buf_section_idx =
 684                                     send_buf_section_idx;
 685                                 packet->send_buf_section_size =
 686                                     packet->tot_data_buf_len;
 687                                 packet->page_buf_count = 0;
 688                                 goto do_send;
 689                         }
 690                 }
 691
 692                 /* send packet with page buffer */
 693                 packet->page_buffers[0].pfn =
 694                     atop(hv_get_phys_addr(rndis_mesg));
 695                 packet->page_buffers[0].offset =
 696                     (unsigned long)rndis_mesg & PAGE_MASK;
 697                 packet->page_buffers[0].length = rndis_msg_size;
 698
 699                 /*
 700                  * Fill the page buffers with mbuf info starting at index
 701                  * HV_RF_NUM_TX_RESERVED_PAGE_BUFS.
 702                  */
 703                 i = HV_RF_NUM_TX_RESERVED_PAGE_BUFS;
 704                 for (m = m_head; m != NULL; m = m->m_next) {
 705                         if (m->m_len) {
 706                                 vm_offset_t paddr =
 707                                     vtophys(mtod(m, vm_offset_t));
 708                                 packet->page_buffers[i].pfn =
 709                                     paddr >> PAGE_SHIFT;
 710                                 packet->page_buffers[i].offset =
 711                                     paddr & (PAGE_SIZE - 1);
 712                                 packet->page_buffers[i].length = m->m_len;
 713                                 i++;
 714                         }
 715                 }
 716
 717                 packet->send_buf_section_idx =
 718                     NVSP_1_CHIMNEY_SEND_INVALID_SECTION_INDEX;
 719                 packet->send_buf_section_size = 0;
 720
 721 do_send:
 722
 723                 /*
 724                  * If bpf, copy the mbuf chain.  This is less expensive than
 725                  * it appears; the mbuf clusters are not copied, only their
 726                  * reference counts are incremented.
 727                  * Needed to avoid a race condition where the completion
 728                  * callback is invoked, freeing the mbuf chain, before the
 729                  * bpf_mtap code has a chance to run.
 730                  */
 731                 if (ifp->if_bpf) {
 732                         mc_head = m_copypacket(m_head, M_DONTWAIT);
 733                 }
 734 retry_send:
 735                 /* Set the completion routine */
 736                 packet->compl.send.on_send_completion = netvsc_xmit_completion;
 737                 packet->compl.send.send_completion_context = packet;
 738                 packet->compl.send.send_completion_tid = (uint64_t)(uintptr_t)m_head;
 739
 740                 /* Removed critical_enter(), does not appear necessary */
 741                 ret = hv_nv_on_send(device_ctx, packet);
 742                 if (ret == 0) {
 743                         ifp->if_opackets++;
 744                         /* if bpf && mc_head, call bpf_mtap code */
 745                         if (mc_head) {
 746                                 ETHER_BPF_MTAP(ifp, mc_head);
 747                         }
 748                 } else {
 749                         retries++;
 750                         if (retries < 4) {
 751                                 goto retry_send;
 752                         }
 753
 754                         IF_PREPEND(&ifp->if_snd, m_head);
 755                         ifp->if_drv_flags |= IFF_DRV_OACTIVE;
 756
 757                         /*
 758                          * Null the mbuf pointer so the completion function
 759                          * does not free the mbuf chain.  We just pushed the
 760                          * mbuf chain back on the if_snd queue.
 761                          */
 762                         packet->compl.send.send_completion_tid = 0;
 763
 764                         /*
 765                          * Release the resources since we will not get any
 766                          * send completion
 767                          */
 768                         netvsc_xmit_completion(packet);
 769                         if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
 770                 }
 771
 772                 /* if bpf && mc_head, free the mbuf chain copy */
 773                 if (mc_head) {
 774                         m_freem(mc_head);
 775                 }
 776         }
 777
 778         return (ret);
 779 }
 780
 781 /*
 782  * Link up/down notification
 783  */
 784 void
 785 netvsc_linkstatus_callback(struct hv_device *device_obj, uint32_t status)
 786 {
 787         hn_softc_t *sc = device_get_softc(device_obj->device);
 788
 789         if (sc == NULL) {
 790                 return;
 791         }
 792
 793         if (status == 1) {
 794                 sc->hn_carrier = 1;
 795         } else {
 796                 sc->hn_carrier = 0;
 797         }
 798 }
 799
 800 /*
 801  * Append the specified data to the indicated mbuf chain,
 802  * Extend the mbuf chain if the new data does not fit in
 803  * existing space.
 804  *
 805  * This is a minor rewrite of m_append() from sys/kern/uipc_mbuf.c.
 806  * There should be an equivalent in the kernel mbuf code,
 807  * but there does not appear to be one yet.
 808  *
 809  * Differs from m_append() in that additional mbufs are
 810  * allocated with cluster size MJUMPAGESIZE, and filled
 811  * accordingly.
 812  *
 813  * Return 1 if able to complete the job; otherwise 0.
 814  */
 815 static int
 816 hv_m_append(struct mbuf *m0, int len, c_caddr_t cp)
 817 {
 818         struct mbuf *m, *n;
 819         int remainder, space;
 820
 821         for (m = m0; m->m_next != NULL; m = m->m_next)
 822                 ;
 823         remainder = len;
 824         space = M_TRAILINGSPACE(m);
 825         if (space > 0) {
 826                 /*
 827                  * Copy into available space.
 828                  */
 829                 if (space > remainder)
 830                         space = remainder;
 831                 bcopy(cp, mtod(m, caddr_t) + m->m_len, space);
 832                 m->m_len += space;
 833                 cp += space;
 834                 remainder -= space;
 835         }
 836         while (remainder > 0) {
 837                 /*
 838                  * Allocate a new mbuf; could check space
 839                  * and allocate a cluster instead.
 840                  */
 841                 n = m_getjcl(M_DONTWAIT, m->m_type, 0, MJUMPAGESIZE);
 842                 if (n == NULL)
 843                         break;
 844                 n->m_len = min(MJUMPAGESIZE, remainder);
 845                 bcopy(cp, mtod(n, caddr_t), n->m_len);
 846                 cp += n->m_len;
 847                 remainder -= n->m_len;
 848                 m->m_next = n;
 849                 m = n;
 850         }
 851         if (m0->m_flags & M_PKTHDR)
 852                 m0->m_pkthdr.len += len - remainder;
 853
 854         return (remainder == 0);
 855 }
 856
 857
 858 /*
 859  * Called when we receive a data packet from the "wire" on the
 860  * specified device
 861  *
 862  * Note:  This is no longer used as a callback
 863  */
 864 int
 865 netvsc_recv(struct hv_device *device_ctx, netvsc_packet *packet,
 866     rndis_tcp_ip_csum_info *csum_info)
 867 {
 868         hn_softc_t *sc = (hn_softc_t *)device_get_softc(device_ctx->device);
 869         struct mbuf *m_new;
 870         struct ifnet *ifp;
 871         device_t dev = device_ctx->device;
 872         int size;
 873
 874         if (sc == NULL) {
 875                 return (0); /* TODO: KYS how can this be! */
 876         }
 877
 878         ifp = sc->hn_ifp;
 879
 880         ifp = sc->arpcom.ac_ifp;
 881
 882         if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) {
 883                 return (0);
 884         }
 885
 886         /*
 887          * Bail out if packet contains more data than configured MTU.
 888          */
 889         if (packet->tot_data_buf_len > (ifp->if_mtu + ETHER_HDR_LEN)) {
 890                 return (0);
 891         }
 892
 893         /*
 894          * Get an mbuf with a cluster.  For packets 2K or less,
 895          * get a standard 2K cluster.  For anything larger, get a
 896          * 4K cluster.  Any buffers larger than 4K can cause problems
 897          * if looped around to the Hyper-V TX channel, so avoid them.
 898          */
 899         size = MCLBYTES;
 900
 901         if (packet->tot_data_buf_len > MCLBYTES) {
 902                 /* 4096 */
 903                 size = MJUMPAGESIZE;
 904         }
 905
 906         m_new = m_getjcl(M_DONTWAIT, MT_DATA, M_PKTHDR, size);
 907
 908         if (m_new == NULL) {
 909                 device_printf(dev, "alloc mbuf failed.\n");
 910                 return (0);
 911         }
 912
 913         hv_m_append(m_new, packet->tot_data_buf_len,
 914                         packet->data);
 915
 916         m_new->m_pkthdr.rcvif = ifp;
 917
 918         /* receive side checksum offload */
 919         m_new->m_pkthdr.csum_flags = 0;
 920         if (NULL != csum_info) {
 921                 /* IP csum offload */
 922                 if (csum_info->receive.ip_csum_succeeded) {
 923                         m_new->m_pkthdr.csum_flags |=
 924                             (CSUM_IP_CHECKED | CSUM_IP_VALID);
 925                 }
 926
 927                 /* TCP csum offload */
 928                 if (csum_info->receive.tcp_csum_succeeded) {
 929                         m_new->m_pkthdr.csum_flags |=
 930                             (CSUM_DATA_VALID | CSUM_PSEUDO_HDR);
 931                         m_new->m_pkthdr.csum_data = 0xffff;
 932                 }
 933         }
 934
 935         if ((packet->vlan_tci != 0) &&
 936             (ifp->if_capenable & IFCAP_VLAN_HWTAGGING) != 0) {
 937                 m_new->m_pkthdr.ether_vtag = packet->vlan_tci;
 938                 m_new->m_flags |= M_VLANTAG;
 939         }
 940
 941         /*
 942          * Note:  Moved RX completion back to hv_nv_on_receive() so all
 943          * messages (not just data messages) will trigger a response.
 944          */
 945
 946         ifp->if_ipackets++;
 947
 948         /* We're not holding the lock here, so don't release it */
 949         (*ifp->if_input)(ifp, m_new);
 950
 951         return (0);
 952 }
 953
 954 /*
 955  * Rules for using sc->temp_unusable:
 956  * 1.  sc->temp_unusable can only be read or written while holding NV_LOCK()
 957  * 2.  code reading sc->temp_unusable under NV_LOCK(), and finding
 958  *     sc->temp_unusable set, must release NV_LOCK() and exit
 959  * 3.  to retain exclusive control of the interface,
 960  *     sc->temp_unusable must be set by code before releasing NV_LOCK()
 961  * 4.  only code setting sc->temp_unusable can clear sc->temp_unusable
 962  * 5.  code setting sc->temp_unusable must eventually clear sc->temp_unusable
 963  */
 964
 965 /*
 966  * Standard ioctl entry point.  Called when the user wants to configure
 967  * the interface.
 968  */
 969 static int
 970 hn_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
 971 {
 972         hn_softc_t *sc = ifp->if_softc;
 973         struct ifreq *ifr = (struct ifreq *)data;
 974 #ifdef INET
 975         struct ifaddr *ifa = (struct ifaddr *)data;
 976 #endif
 977         netvsc_device_info device_info;
 978         struct hv_device *hn_dev;
 979         int mask, error = 0;
 980         int retry_cnt = 500;
 981
 982         switch(cmd) {
 983
 984         case SIOCSIFADDR:
 985 #ifdef INET
 986                 if (ifa->ifa_addr->sa_family == AF_INET) {
 987                         ifp->if_flags |= IFF_UP;
 988                         if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
 989                                 hn_ifinit(sc);
 990                         arp_ifinit(ifp, ifa);
 991                 } else
 992 #endif
 993                 error = ether_ioctl(ifp, cmd, data);
 994                 break;
 995         case SIOCSIFMTU:
 996                 hn_dev = vmbus_get_devctx(sc->hn_dev);
 997
 998                 /* Check MTU value change */
 999                 if (ifp->if_mtu == ifr->ifr_mtu)
1000                         break;
1001
1002                 if (ifr->ifr_mtu > NETVSC_MAX_CONFIGURABLE_MTU) {
1003                         error = EINVAL;
1004                         break;
1005                 }
1006
1007                 /* Obtain and record requested MTU */
1008                 ifp->if_mtu = ifr->ifr_mtu;
1009
1010                 do {
1011                         NV_LOCK(sc);
1012                         if (!sc->temp_unusable) {
1013                                 sc->temp_unusable = TRUE;
1014                                 retry_cnt = -1;
1015                         }
1016                         NV_UNLOCK(sc);
1017                         if (retry_cnt > 0) {
1018                                 retry_cnt--;
1019                                 DELAY(5 * 1000);
1020                         }
1021                 } while (retry_cnt > 0);
1022
1023                 if (retry_cnt == 0) {
1024                         error = EINVAL;
1025                         break;
1026                 }
1027
1028                 /* We must remove and add back the device to cause the new
1029                  * MTU to take effect.  This includes tearing down, but not
1030                  * deleting the channel, then bringing it back up.
1031                  */
1032                 error = hv_rf_on_device_remove(hn_dev, HV_RF_NV_RETAIN_CHANNEL);
1033                 if (error) {
1034                         NV_LOCK(sc);
1035                         sc->temp_unusable = FALSE;
1036                         NV_UNLOCK(sc);
1037                         break;
1038                 }
1039                 error = hv_rf_on_device_add(hn_dev, &device_info);
1040                 if (error) {
1041                         NV_LOCK(sc);
1042                         sc->temp_unusable = FALSE;
1043                         NV_UNLOCK(sc);
1044                         break;
1045                 }
1046
1047                 hn_ifinit_locked(sc);
1048
1049                 NV_LOCK(sc);
1050                 sc->temp_unusable = FALSE;
1051                 NV_UNLOCK(sc);
1052                 break;
1053         case SIOCSIFFLAGS:
1054                 do {
1055                        NV_LOCK(sc);
1056                        if (!sc->temp_unusable) {
1057                                sc->temp_unusable = TRUE;
1058                                retry_cnt = -1;
1059                        }
1060                        NV_UNLOCK(sc);
1061                        if (retry_cnt > 0) {
1062                                 retry_cnt--;
1063                                 DELAY(5 * 1000);
1064                        }
1065                 } while (retry_cnt > 0);
1066
1067                 if (retry_cnt == 0) {
1068                        error = EINVAL;
1069                        break;
1070                 }
1071
1072                 if (ifp->if_flags & IFF_UP) {
1073                         /*
1074                          * If only the state of the PROMISC flag changed,
1075                          * then just use the 'set promisc mode' command
1076                          * instead of reinitializing the entire NIC. Doing
1077                          * a full re-init means reloading the firmware and
1078                          * waiting for it to start up, which may take a
1079                          * second or two.
1080                          */
1081 #ifdef notyet
1082                         /* Fixme:  Promiscuous mode? */
1083                         if (ifp->if_drv_flags & IFF_DRV_RUNNING &&
1084                             ifp->if_flags & IFF_PROMISC &&
1085                             !(sc->hn_if_flags & IFF_PROMISC)) {
1086                                 /* do something here for Hyper-V */
1087                         } else if (ifp->if_drv_flags & IFF_DRV_RUNNING &&
1088                             !(ifp->if_flags & IFF_PROMISC) &&
1089                             sc->hn_if_flags & IFF_PROMISC) {
1090                                 /* do something here for Hyper-V */
1091                         } else
1092 #endif
1093                                 hn_ifinit_locked(sc);
1094                 } else {
1095                         if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
1096                                 hn_stop(sc);
1097                         }
1098                 }
1099                 NV_LOCK(sc);
1100                 sc->temp_unusable = FALSE;
1101                 NV_UNLOCK(sc);
1102                 sc->hn_if_flags = ifp->if_flags;
1103                 error = 0;
1104                 break;
1105         case SIOCSIFCAP:
1106                 mask = ifr->ifr_reqcap ^ ifp->if_capenable;
1107                 if (mask & IFCAP_TXCSUM) {
1108                         if (IFCAP_TXCSUM & ifp->if_capenable) {
1109                                 ifp->if_capenable &= ~IFCAP_TXCSUM;
1110                                 ifp->if_hwassist &= ~(CSUM_TCP | CSUM_UDP);
1111                         } else {
1112                                 ifp->if_capenable |= IFCAP_TXCSUM;
1113                                 ifp->if_hwassist |= (CSUM_TCP | CSUM_UDP);
1114                         }
1115                 }
1116
1117                 if (mask & IFCAP_RXCSUM) {
1118                         if (IFCAP_RXCSUM & ifp->if_capenable) {
1119                                 ifp->if_capenable &= ~IFCAP_RXCSUM;
1120                         } else {
1121                                 ifp->if_capenable |= IFCAP_RXCSUM;
1122                         }
1123                 }
1124
1125                 if (mask & IFCAP_TSO4) {
1126                         ifp->if_capenable ^= IFCAP_TSO4;
1127                         ifp->if_hwassist ^= CSUM_IP_TSO;
1128                 }
1129
1130                 if (mask & IFCAP_TSO6) {
1131                         ifp->if_capenable ^= IFCAP_TSO6;
1132                         ifp->if_hwassist ^= CSUM_IP6_TSO;
1133                 }
1134
1135                 error = 0;
1136                 break;
1137         case SIOCADDMULTI:
1138         case SIOCDELMULTI:
1139 #ifdef notyet
1140                 /* Fixme:  Multicast mode? */
1141                 if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
1142                         NV_LOCK(sc);
1143                         netvsc_setmulti(sc);
1144                         NV_UNLOCK(sc);
1145                         error = 0;
1146                 }
1147 #endif
1148                 /* FALLTHROUGH */
1149         case SIOCSIFMEDIA:
1150         case SIOCGIFMEDIA:
1151                 error = EINVAL;
1152                 break;
1153         default:
1154                 error = ether_ioctl(ifp, cmd, data);
1155                 break;
1156         }
1157
1158         return (error);
1159 }
1160
1161 /*
1162  *
1163  */
1164 static void
1165 hn_stop(hn_softc_t *sc)
1166 {
1167         struct ifnet *ifp;
1168         int ret;
1169         struct hv_device *device_ctx = vmbus_get_devctx(sc->hn_dev);
1170
1171         ifp = sc->hn_ifp;
1172
1173         if (bootverbose)
1174                 printf(" Closing Device ...\n");
1175
1176         ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
1177         if_link_state_change(ifp, LINK_STATE_DOWN);
1178         sc->hn_initdone = 0;
1179
1180         ret = hv_rf_on_close(device_ctx);
1181 }
1182
1183 /*
1184  * FreeBSD transmit entry point
1185  */
1186 static void
1187 hn_start(struct ifnet *ifp)
1188 {
1189         hn_softc_t *sc;
1190
1191         sc = ifp->if_softc;
1192         NV_LOCK(sc);
1193         if (sc->temp_unusable) {
1194                 NV_UNLOCK(sc);
1195                 return;
1196         }
1197         hn_start_locked(ifp);
1198         NV_UNLOCK(sc);
1199 }
1200
1201 /*
1202  *
1203  */
1204 static void
1205 hn_ifinit_locked(hn_softc_t *sc)
1206 {
1207         struct ifnet *ifp;
1208         struct hv_device *device_ctx = vmbus_get_devctx(sc->hn_dev);
1209         int ret;
1210
1211         ifp = sc->hn_ifp;
1212
1213         if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
1214                 return;
1215         }
1216
1217         hv_promisc_mode = 1;
1218
1219         ret = hv_rf_on_open(device_ctx);
1220         if (ret != 0) {
1221                 return;
1222         } else {
1223                 sc->hn_initdone = 1;
1224         }
1225         ifp->if_drv_flags |= IFF_DRV_RUNNING;
1226         ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
1227         if_link_state_change(ifp, LINK_STATE_UP);
1228 }
1229
1230 /*
1231  *
1232  */
1233 static void
1234 hn_ifinit(void *xsc)
1235 {
1236         hn_softc_t *sc = xsc;
1237
1238         NV_LOCK(sc);
1239         if (sc->temp_unusable) {
1240                 NV_UNLOCK(sc);
1241                 return;
1242         }
1243         sc->temp_unusable = TRUE;
1244         NV_UNLOCK(sc);
1245
1246         hn_ifinit_locked(sc);
1247
1248         NV_LOCK(sc);
1249         sc->temp_unusable = FALSE;
1250         NV_UNLOCK(sc);
1251 }
1252
1253 #ifdef LATER
1254 /*
1255  *
1256  */
1257 static void
1258 hn_watchdog(struct ifnet *ifp)
1259 {
1260         hn_softc_t *sc;
1261         sc = ifp->if_softc;
1262
1263         printf("hn%d: watchdog timeout -- resetting\n", sc->hn_unit);
1264         hn_ifinit(sc);    /*???*/
1265         ifp->if_oerrors++;
1266 }
1267 #endif
1268
1269 static device_method_t netvsc_methods[] = {
1270         /* Device interface */
1271         DEVMETHOD(device_probe,         netvsc_probe),
1272         DEVMETHOD(device_attach,        netvsc_attach),
1273         DEVMETHOD(device_detach,        netvsc_detach),
1274         DEVMETHOD(device_shutdown,      netvsc_shutdown),
1275
1276         { 0, 0 }
1277 };
1278
1279 static driver_t netvsc_driver = {
1280         NETVSC_DEVNAME,
1281         netvsc_methods,
1282         sizeof(hn_softc_t)
1283 };
1284
1285 static devclass_t netvsc_devclass;
1286
1287 DRIVER_MODULE(hn, vmbus, netvsc_driver, netvsc_devclass, 0, 0);
1288 MODULE_VERSION(hn, 1);
1289 MODULE_DEPEND(hn, vmbus, 1, 1, 1);
1290 SYSINIT(netvsc_initx, SI_SUB_KTHREAD_IDLE, SI_ORDER_MIDDLE + 1, netvsc_init,
1291      NULL);
1292