1 /*- 2 * Copyright (c) 2009-2012,2016 Microsoft Corp. 3 * Copyright (c) 2010-2012 Citrix Inc. 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 #include <sys/cdefs.h> 30 __FBSDID("$FreeBSD$"); 31 32 #include "opt_inet6.h" 33 #include "opt_inet.h" 34 35 #include <sys/param.h> 36 #include <sys/socket.h> 37 #include <sys/systm.h> 38 #include <sys/taskqueue.h> 39 40 #include <machine/atomic.h> 41 42 #include <net/ethernet.h> 43 #include <net/if.h> 44 #include <net/if_var.h> 45 #include <net/if_media.h> 46 #include <net/rndis.h> 47 48 #include <netinet/in.h> 49 #include <netinet/ip.h> 50 #include <netinet/tcp_lro.h> 51 52 #include <dev/hyperv/include/hyperv.h> 53 #include <dev/hyperv/include/hyperv_busdma.h> 54 #include <dev/hyperv/include/vmbus.h> 55 #include <dev/hyperv/include/vmbus_xact.h> 56 57 #include <dev/hyperv/netvsc/ndis.h> 58 #include <dev/hyperv/netvsc/if_hnreg.h> 59 #include <dev/hyperv/netvsc/if_hnvar.h> 60 #include <dev/hyperv/netvsc/hn_nvs.h> 61 #include <dev/hyperv/netvsc/hn_rndis.h> 62 63 #define HN_RNDIS_RID_COMPAT_MASK 0xffff 64 #define HN_RNDIS_RID_COMPAT_MAX HN_RNDIS_RID_COMPAT_MASK 65 66 #define HN_RNDIS_XFER_SIZE 2048 67 68 #define HN_NDIS_TXCSUM_CAP_IP4 \ 69 (NDIS_TXCSUM_CAP_IP4 | NDIS_TXCSUM_CAP_IP4OPT) 70 #define HN_NDIS_TXCSUM_CAP_TCP4 \ 71 (NDIS_TXCSUM_CAP_TCP4 | NDIS_TXCSUM_CAP_TCP4OPT) 72 #define HN_NDIS_TXCSUM_CAP_TCP6 \ 73 (NDIS_TXCSUM_CAP_TCP6 | NDIS_TXCSUM_CAP_TCP6OPT | \ 74 NDIS_TXCSUM_CAP_IP6EXT) 75 #define HN_NDIS_TXCSUM_CAP_UDP6 \ 76 (NDIS_TXCSUM_CAP_UDP6 | NDIS_TXCSUM_CAP_IP6EXT) 77 #define HN_NDIS_LSOV2_CAP_IP6 \ 78 (NDIS_LSOV2_CAP_IP6EXT | NDIS_LSOV2_CAP_TCP6OPT) 79 80 static const void *hn_rndis_xact_exec1(struct hn_softc *, 81 struct vmbus_xact *, size_t, 82 struct hn_nvs_sendctx *, size_t *); 83 static const void *hn_rndis_xact_execute(struct hn_softc *, 84 struct vmbus_xact *, uint32_t, size_t, size_t *, 85 uint32_t); 86 static int hn_rndis_query(struct hn_softc *, uint32_t, 87 const void *, size_t, void *, size_t *); 88 static int hn_rndis_query2(struct hn_softc *, uint32_t, 89 const void *, size_t, void *, size_t *, size_t); 90 static int hn_rndis_set(struct hn_softc *, uint32_t, 91 const void *, size_t); 92 static int hn_rndis_init(struct hn_softc *); 93 static int hn_rndis_halt(struct hn_softc *); 94 static int hn_rndis_conf_offload(struct hn_softc *, int); 95 static int hn_rndis_query_hwcaps(struct hn_softc *, 96 struct ndis_offload *); 97 98 static __inline uint32_t 99 hn_rndis_rid(struct hn_softc *sc) 100 { 101 uint32_t rid; 102 103 again: 104 rid = atomic_fetchadd_int(&sc->hn_rndis_rid, 1); 105 if (rid == 0) 106 goto again; 107 108 /* Use upper 16 bits for non-compat RNDIS messages. */ 109 return ((rid & 0xffff) << 16); 110 } 111 112 void 113 hn_rndis_rx_ctrl(struct hn_softc *sc, const void *data, int dlen) 114 { 115 const struct rndis_comp_hdr *comp; 116 const struct rndis_msghdr *hdr; 117 118 KASSERT(dlen >= sizeof(*hdr), ("invalid RNDIS msg\n")); 119 hdr = data; 120 121 switch (hdr->rm_type) { 122 case REMOTE_NDIS_INITIALIZE_CMPLT: 123 case REMOTE_NDIS_QUERY_CMPLT: 124 case REMOTE_NDIS_SET_CMPLT: 125 case REMOTE_NDIS_KEEPALIVE_CMPLT: /* unused */ 126 if (dlen < sizeof(*comp)) { 127 if_printf(sc->hn_ifp, "invalid RNDIS cmplt\n"); 128 return; 129 } 130 comp = data; 131 132 KASSERT(comp->rm_rid > HN_RNDIS_RID_COMPAT_MAX, 133 ("invalid RNDIS rid 0x%08x\n", comp->rm_rid)); 134 vmbus_xact_ctx_wakeup(sc->hn_xact, comp, dlen); 135 break; 136 137 case REMOTE_NDIS_RESET_CMPLT: 138 /* 139 * Reset completed, no rid. 140 * 141 * NOTE: 142 * RESET is not issued by hn(4), so this message should 143 * _not_ be observed. 144 */ 145 if_printf(sc->hn_ifp, "RESET cmplt received\n"); 146 break; 147 148 default: 149 if_printf(sc->hn_ifp, "unknown RNDIS msg 0x%x\n", 150 hdr->rm_type); 151 break; 152 } 153 } 154 155 int 156 hn_rndis_get_eaddr(struct hn_softc *sc, uint8_t *eaddr) 157 { 158 size_t eaddr_len; 159 int error; 160 161 eaddr_len = ETHER_ADDR_LEN; 162 error = hn_rndis_query(sc, OID_802_3_PERMANENT_ADDRESS, NULL, 0, 163 eaddr, &eaddr_len); 164 if (error) 165 return (error); 166 if (eaddr_len != ETHER_ADDR_LEN) { 167 if_printf(sc->hn_ifp, "invalid eaddr len %zu\n", eaddr_len); 168 return (EINVAL); 169 } 170 return (0); 171 } 172 173 int 174 hn_rndis_get_linkstatus(struct hn_softc *sc, uint32_t *link_status) 175 { 176 size_t size; 177 int error; 178 179 size = sizeof(*link_status); 180 error = hn_rndis_query(sc, OID_GEN_MEDIA_CONNECT_STATUS, NULL, 0, 181 link_status, &size); 182 if (error) 183 return (error); 184 if (size != sizeof(uint32_t)) { 185 if_printf(sc->hn_ifp, "invalid link status len %zu\n", size); 186 return (EINVAL); 187 } 188 return (0); 189 } 190 191 static const void * 192 hn_rndis_xact_exec1(struct hn_softc *sc, struct vmbus_xact *xact, size_t reqlen, 193 struct hn_nvs_sendctx *sndc, size_t *comp_len) 194 { 195 struct vmbus_gpa gpa[HN_XACT_REQ_PGCNT]; 196 int gpa_cnt, error; 197 bus_addr_t paddr; 198 199 KASSERT(reqlen <= HN_XACT_REQ_SIZE && reqlen > 0, 200 ("invalid request length %zu", reqlen)); 201 202 /* 203 * Setup the SG list. 204 */ 205 paddr = vmbus_xact_req_paddr(xact); 206 KASSERT((paddr & PAGE_MASK) == 0, 207 ("vmbus xact request is not page aligned 0x%jx", (uintmax_t)paddr)); 208 for (gpa_cnt = 0; gpa_cnt < HN_XACT_REQ_PGCNT; ++gpa_cnt) { 209 int len = PAGE_SIZE; 210 211 if (reqlen == 0) 212 break; 213 if (reqlen < len) 214 len = reqlen; 215 216 gpa[gpa_cnt].gpa_page = atop(paddr) + gpa_cnt; 217 gpa[gpa_cnt].gpa_len = len; 218 gpa[gpa_cnt].gpa_ofs = 0; 219 220 reqlen -= len; 221 } 222 KASSERT(reqlen == 0, ("still have %zu request data left", reqlen)); 223 224 /* 225 * Send this RNDIS control message and wait for its completion 226 * message. 227 */ 228 vmbus_xact_activate(xact); 229 error = hn_nvs_send_rndis_ctrl(sc->hn_prichan, sndc, gpa, gpa_cnt); 230 if (error) { 231 vmbus_xact_deactivate(xact); 232 if_printf(sc->hn_ifp, "RNDIS ctrl send failed: %d\n", error); 233 return (NULL); 234 } 235 return (vmbus_chan_xact_wait(sc->hn_prichan, xact, comp_len, 236 HN_CAN_SLEEP(sc))); 237 } 238 239 static const void * 240 hn_rndis_xact_execute(struct hn_softc *sc, struct vmbus_xact *xact, uint32_t rid, 241 size_t reqlen, size_t *comp_len0, uint32_t comp_type) 242 { 243 const struct rndis_comp_hdr *comp; 244 size_t comp_len, min_complen = *comp_len0; 245 246 KASSERT(rid > HN_RNDIS_RID_COMPAT_MAX, ("invalid rid %u\n", rid)); 247 KASSERT(min_complen >= sizeof(*comp), 248 ("invalid minimum complete len %zu", min_complen)); 249 250 /* 251 * Execute the xact setup by the caller. 252 */ 253 comp = hn_rndis_xact_exec1(sc, xact, reqlen, &hn_nvs_sendctx_none, 254 &comp_len); 255 if (comp == NULL) 256 return (NULL); 257 258 /* 259 * Check this RNDIS complete message. 260 */ 261 if (comp_len < min_complen) { 262 if (comp_len >= sizeof(*comp)) { 263 /* rm_status field is valid */ 264 if_printf(sc->hn_ifp, "invalid RNDIS comp len %zu, " 265 "status 0x%08x\n", comp_len, comp->rm_status); 266 } else { 267 if_printf(sc->hn_ifp, "invalid RNDIS comp len %zu\n", 268 comp_len); 269 } 270 return (NULL); 271 } 272 if (comp->rm_len < min_complen) { 273 if_printf(sc->hn_ifp, "invalid RNDIS comp msglen %u\n", 274 comp->rm_len); 275 return (NULL); 276 } 277 if (comp->rm_type != comp_type) { 278 if_printf(sc->hn_ifp, "unexpected RNDIS comp 0x%08x, " 279 "expect 0x%08x\n", comp->rm_type, comp_type); 280 return (NULL); 281 } 282 if (comp->rm_rid != rid) { 283 if_printf(sc->hn_ifp, "RNDIS comp rid mismatch %u, " 284 "expect %u\n", comp->rm_rid, rid); 285 return (NULL); 286 } 287 /* All pass! */ 288 *comp_len0 = comp_len; 289 return (comp); 290 } 291 292 static int 293 hn_rndis_query(struct hn_softc *sc, uint32_t oid, 294 const void *idata, size_t idlen, void *odata, size_t *odlen0) 295 { 296 297 return (hn_rndis_query2(sc, oid, idata, idlen, odata, odlen0, *odlen0)); 298 } 299 300 static int 301 hn_rndis_query2(struct hn_softc *sc, uint32_t oid, 302 const void *idata, size_t idlen, void *odata, size_t *odlen0, 303 size_t min_odlen) 304 { 305 struct rndis_query_req *req; 306 const struct rndis_query_comp *comp; 307 struct vmbus_xact *xact; 308 size_t reqlen, odlen = *odlen0, comp_len; 309 int error, ofs; 310 uint32_t rid; 311 312 reqlen = sizeof(*req) + idlen; 313 xact = vmbus_xact_get(sc->hn_xact, reqlen); 314 if (xact == NULL) { 315 if_printf(sc->hn_ifp, "no xact for RNDIS query 0x%08x\n", oid); 316 return (ENXIO); 317 } 318 rid = hn_rndis_rid(sc); 319 req = vmbus_xact_req_data(xact); 320 req->rm_type = REMOTE_NDIS_QUERY_MSG; 321 req->rm_len = reqlen; 322 req->rm_rid = rid; 323 req->rm_oid = oid; 324 /* 325 * XXX 326 * This is _not_ RNDIS Spec conforming: 327 * "This MUST be set to 0 when there is no input data 328 * associated with the OID." 329 * 330 * If this field was set to 0 according to the RNDIS Spec, 331 * Hyper-V would set non-SUCCESS status in the query 332 * completion. 333 */ 334 req->rm_infobufoffset = RNDIS_QUERY_REQ_INFOBUFOFFSET; 335 336 if (idlen > 0) { 337 req->rm_infobuflen = idlen; 338 /* Input data immediately follows RNDIS query. */ 339 memcpy(req + 1, idata, idlen); 340 } 341 342 comp_len = sizeof(*comp) + min_odlen; 343 comp = hn_rndis_xact_execute(sc, xact, rid, reqlen, &comp_len, 344 REMOTE_NDIS_QUERY_CMPLT); 345 if (comp == NULL) { 346 if_printf(sc->hn_ifp, "exec RNDIS query 0x%08x failed\n", oid); 347 error = EIO; 348 goto done; 349 } 350 351 if (comp->rm_status != RNDIS_STATUS_SUCCESS) { 352 if_printf(sc->hn_ifp, "RNDIS query 0x%08x failed: " 353 "status 0x%08x\n", oid, comp->rm_status); 354 error = EIO; 355 goto done; 356 } 357 if (comp->rm_infobuflen == 0 || comp->rm_infobufoffset == 0) { 358 /* No output data! */ 359 if_printf(sc->hn_ifp, "RNDIS query 0x%08x, no data\n", oid); 360 *odlen0 = 0; 361 error = 0; 362 goto done; 363 } 364 365 /* 366 * Check output data length and offset. 367 */ 368 /* ofs is the offset from the beginning of comp. */ 369 ofs = RNDIS_QUERY_COMP_INFOBUFOFFSET_ABS(comp->rm_infobufoffset); 370 if (ofs < sizeof(*comp) || ofs + comp->rm_infobuflen > comp_len) { 371 if_printf(sc->hn_ifp, "RNDIS query invalid comp ib off/len, " 372 "%u/%u\n", comp->rm_infobufoffset, comp->rm_infobuflen); 373 error = EINVAL; 374 goto done; 375 } 376 377 /* 378 * Save output data. 379 */ 380 if (comp->rm_infobuflen < odlen) 381 odlen = comp->rm_infobuflen; 382 memcpy(odata, ((const uint8_t *)comp) + ofs, odlen); 383 *odlen0 = odlen; 384 385 error = 0; 386 done: 387 vmbus_xact_put(xact); 388 return (error); 389 } 390 391 int 392 hn_rndis_query_rsscaps(struct hn_softc *sc, int *rxr_cnt0) 393 { 394 struct ndis_rss_caps in, caps; 395 size_t caps_len; 396 int error, indsz, rxr_cnt, hash_fnidx; 397 uint32_t hash_func = 0, hash_types = 0; 398 399 *rxr_cnt0 = 0; 400 401 if (sc->hn_ndis_ver < HN_NDIS_VERSION_6_20) 402 return (EOPNOTSUPP); 403 404 memset(&in, 0, sizeof(in)); 405 in.ndis_hdr.ndis_type = NDIS_OBJTYPE_RSS_CAPS; 406 in.ndis_hdr.ndis_rev = NDIS_RSS_CAPS_REV_2; 407 in.ndis_hdr.ndis_size = NDIS_RSS_CAPS_SIZE; 408 409 caps_len = NDIS_RSS_CAPS_SIZE; 410 error = hn_rndis_query2(sc, OID_GEN_RECEIVE_SCALE_CAPABILITIES, 411 &in, NDIS_RSS_CAPS_SIZE, &caps, &caps_len, NDIS_RSS_CAPS_SIZE_6_0); 412 if (error) 413 return (error); 414 415 /* 416 * Preliminary verification. 417 */ 418 if (caps.ndis_hdr.ndis_type != NDIS_OBJTYPE_RSS_CAPS) { 419 if_printf(sc->hn_ifp, "invalid NDIS objtype 0x%02x\n", 420 caps.ndis_hdr.ndis_type); 421 return (EINVAL); 422 } 423 if (caps.ndis_hdr.ndis_rev < NDIS_RSS_CAPS_REV_1) { 424 if_printf(sc->hn_ifp, "invalid NDIS objrev 0x%02x\n", 425 caps.ndis_hdr.ndis_rev); 426 return (EINVAL); 427 } 428 if (caps.ndis_hdr.ndis_size > caps_len) { 429 if_printf(sc->hn_ifp, "invalid NDIS objsize %u, " 430 "data size %zu\n", caps.ndis_hdr.ndis_size, caps_len); 431 return (EINVAL); 432 } else if (caps.ndis_hdr.ndis_size < NDIS_RSS_CAPS_SIZE_6_0) { 433 if_printf(sc->hn_ifp, "invalid NDIS objsize %u\n", 434 caps.ndis_hdr.ndis_size); 435 return (EINVAL); 436 } 437 438 /* 439 * Save information for later RSS configuration. 440 */ 441 if (caps.ndis_nrxr == 0) { 442 if_printf(sc->hn_ifp, "0 RX rings!?\n"); 443 return (EINVAL); 444 } 445 if (bootverbose) 446 if_printf(sc->hn_ifp, "%u RX rings\n", caps.ndis_nrxr); 447 rxr_cnt = caps.ndis_nrxr; 448 449 if (caps.ndis_hdr.ndis_size == NDIS_RSS_CAPS_SIZE && 450 caps.ndis_hdr.ndis_rev >= NDIS_RSS_CAPS_REV_2) { 451 if (caps.ndis_nind > NDIS_HASH_INDCNT) { 452 if_printf(sc->hn_ifp, 453 "too many RSS indirect table entries %u\n", 454 caps.ndis_nind); 455 return (EOPNOTSUPP); 456 } 457 if (!powerof2(caps.ndis_nind)) { 458 if_printf(sc->hn_ifp, "RSS indirect table size is not " 459 "power-of-2 %u\n", caps.ndis_nind); 460 } 461 462 if (bootverbose) { 463 if_printf(sc->hn_ifp, "RSS indirect table size %u\n", 464 caps.ndis_nind); 465 } 466 indsz = caps.ndis_nind; 467 } else { 468 indsz = NDIS_HASH_INDCNT; 469 } 470 if (indsz < rxr_cnt) { 471 if_printf(sc->hn_ifp, "# of RX rings (%d) > " 472 "RSS indirect table size %d\n", rxr_cnt, indsz); 473 rxr_cnt = indsz; 474 } 475 476 /* 477 * NOTE: 478 * Toeplitz is at the lowest bit, and it is prefered; so ffs(), 479 * instead of fls(), is used here. 480 */ 481 hash_fnidx = ffs(caps.ndis_caps & NDIS_RSS_CAP_HASHFUNC_MASK); 482 if (hash_fnidx == 0) { 483 if_printf(sc->hn_ifp, "no hash functions, caps 0x%08x\n", 484 caps.ndis_caps); 485 return (EOPNOTSUPP); 486 } 487 hash_func = 1 << (hash_fnidx - 1); /* ffs is 1-based */ 488 489 if (caps.ndis_caps & NDIS_RSS_CAP_IPV4) 490 hash_types |= NDIS_HASH_IPV4 | NDIS_HASH_TCP_IPV4; 491 if (caps.ndis_caps & NDIS_RSS_CAP_IPV6) 492 hash_types |= NDIS_HASH_IPV6 | NDIS_HASH_TCP_IPV6; 493 if (caps.ndis_caps & NDIS_RSS_CAP_IPV6_EX) 494 hash_types |= NDIS_HASH_IPV6_EX | NDIS_HASH_TCP_IPV6_EX; 495 if (hash_types == 0) { 496 if_printf(sc->hn_ifp, "no hash types, caps 0x%08x\n", 497 caps.ndis_caps); 498 return (EOPNOTSUPP); 499 } 500 501 /* Commit! */ 502 sc->hn_rss_ind_size = indsz; 503 sc->hn_rss_hash = hash_func | hash_types; 504 *rxr_cnt0 = rxr_cnt; 505 return (0); 506 } 507 508 static int 509 hn_rndis_set(struct hn_softc *sc, uint32_t oid, const void *data, size_t dlen) 510 { 511 struct rndis_set_req *req; 512 const struct rndis_set_comp *comp; 513 struct vmbus_xact *xact; 514 size_t reqlen, comp_len; 515 uint32_t rid; 516 int error; 517 518 KASSERT(dlen > 0, ("invalid dlen %zu", dlen)); 519 520 reqlen = sizeof(*req) + dlen; 521 xact = vmbus_xact_get(sc->hn_xact, reqlen); 522 if (xact == NULL) { 523 if_printf(sc->hn_ifp, "no xact for RNDIS set 0x%08x\n", oid); 524 return (ENXIO); 525 } 526 rid = hn_rndis_rid(sc); 527 req = vmbus_xact_req_data(xact); 528 req->rm_type = REMOTE_NDIS_SET_MSG; 529 req->rm_len = reqlen; 530 req->rm_rid = rid; 531 req->rm_oid = oid; 532 req->rm_infobuflen = dlen; 533 req->rm_infobufoffset = RNDIS_SET_REQ_INFOBUFOFFSET; 534 /* Data immediately follows RNDIS set. */ 535 memcpy(req + 1, data, dlen); 536 537 comp_len = sizeof(*comp); 538 comp = hn_rndis_xact_execute(sc, xact, rid, reqlen, &comp_len, 539 REMOTE_NDIS_SET_CMPLT); 540 if (comp == NULL) { 541 if_printf(sc->hn_ifp, "exec RNDIS set 0x%08x failed\n", oid); 542 error = EIO; 543 goto done; 544 } 545 546 if (comp->rm_status != RNDIS_STATUS_SUCCESS) { 547 if_printf(sc->hn_ifp, "RNDIS set 0x%08x failed: " 548 "status 0x%08x\n", oid, comp->rm_status); 549 error = EIO; 550 goto done; 551 } 552 error = 0; 553 done: 554 vmbus_xact_put(xact); 555 return (error); 556 } 557 558 static int 559 hn_rndis_conf_offload(struct hn_softc *sc, int mtu) 560 { 561 struct ndis_offload hwcaps; 562 struct ndis_offload_params params; 563 uint32_t caps = 0; 564 size_t paramsz; 565 int error, tso_maxsz, tso_minsg; 566 567 error = hn_rndis_query_hwcaps(sc, &hwcaps); 568 if (error) { 569 if_printf(sc->hn_ifp, "hwcaps query failed: %d\n", error); 570 return (error); 571 } 572 573 /* NOTE: 0 means "no change" */ 574 memset(¶ms, 0, sizeof(params)); 575 576 params.ndis_hdr.ndis_type = NDIS_OBJTYPE_DEFAULT; 577 if (sc->hn_ndis_ver < HN_NDIS_VERSION_6_30) { 578 params.ndis_hdr.ndis_rev = NDIS_OFFLOAD_PARAMS_REV_2; 579 paramsz = NDIS_OFFLOAD_PARAMS_SIZE_6_1; 580 } else { 581 params.ndis_hdr.ndis_rev = NDIS_OFFLOAD_PARAMS_REV_3; 582 paramsz = NDIS_OFFLOAD_PARAMS_SIZE; 583 } 584 params.ndis_hdr.ndis_size = paramsz; 585 586 /* 587 * TSO4/TSO6 setup. 588 */ 589 tso_maxsz = IP_MAXPACKET; 590 tso_minsg = 2; 591 if (hwcaps.ndis_lsov2.ndis_ip4_encap & NDIS_OFFLOAD_ENCAP_8023) { 592 caps |= HN_CAP_TSO4; 593 params.ndis_lsov2_ip4 = NDIS_OFFLOAD_LSOV2_ON; 594 595 if (hwcaps.ndis_lsov2.ndis_ip4_maxsz < tso_maxsz) 596 tso_maxsz = hwcaps.ndis_lsov2.ndis_ip4_maxsz; 597 if (hwcaps.ndis_lsov2.ndis_ip4_minsg > tso_minsg) 598 tso_minsg = hwcaps.ndis_lsov2.ndis_ip4_minsg; 599 } 600 if ((hwcaps.ndis_lsov2.ndis_ip6_encap & NDIS_OFFLOAD_ENCAP_8023) && 601 (hwcaps.ndis_lsov2.ndis_ip6_opts & HN_NDIS_LSOV2_CAP_IP6) == 602 HN_NDIS_LSOV2_CAP_IP6) { 603 caps |= HN_CAP_TSO6; 604 params.ndis_lsov2_ip6 = NDIS_OFFLOAD_LSOV2_ON; 605 606 if (hwcaps.ndis_lsov2.ndis_ip6_maxsz < tso_maxsz) 607 tso_maxsz = hwcaps.ndis_lsov2.ndis_ip6_maxsz; 608 if (hwcaps.ndis_lsov2.ndis_ip6_minsg > tso_minsg) 609 tso_minsg = hwcaps.ndis_lsov2.ndis_ip6_minsg; 610 } 611 sc->hn_ndis_tso_szmax = 0; 612 sc->hn_ndis_tso_sgmin = 0; 613 if (caps & (HN_CAP_TSO4 | HN_CAP_TSO6)) { 614 KASSERT(tso_maxsz <= IP_MAXPACKET, 615 ("invalid NDIS TSO maxsz %d", tso_maxsz)); 616 KASSERT(tso_minsg >= 2, 617 ("invalid NDIS TSO minsg %d", tso_minsg)); 618 if (tso_maxsz < tso_minsg * mtu) { 619 if_printf(sc->hn_ifp, "invalid NDIS TSO config: " 620 "maxsz %d, minsg %d, mtu %d; " 621 "disable TSO4 and TSO6\n", 622 tso_maxsz, tso_minsg, mtu); 623 caps &= ~(HN_CAP_TSO4 | HN_CAP_TSO6); 624 params.ndis_lsov2_ip4 = NDIS_OFFLOAD_LSOV2_OFF; 625 params.ndis_lsov2_ip6 = NDIS_OFFLOAD_LSOV2_OFF; 626 } else { 627 sc->hn_ndis_tso_szmax = tso_maxsz; 628 sc->hn_ndis_tso_sgmin = tso_minsg; 629 if (bootverbose) { 630 if_printf(sc->hn_ifp, "NDIS TSO " 631 "szmax %d sgmin %d\n", 632 sc->hn_ndis_tso_szmax, 633 sc->hn_ndis_tso_sgmin); 634 } 635 } 636 } 637 638 /* IPv4 checksum */ 639 if ((hwcaps.ndis_csum.ndis_ip4_txcsum & HN_NDIS_TXCSUM_CAP_IP4) == 640 HN_NDIS_TXCSUM_CAP_IP4) { 641 caps |= HN_CAP_IPCS; 642 params.ndis_ip4csum = NDIS_OFFLOAD_PARAM_TX; 643 } 644 if (hwcaps.ndis_csum.ndis_ip4_rxcsum & NDIS_RXCSUM_CAP_IP4) { 645 if (params.ndis_ip4csum == NDIS_OFFLOAD_PARAM_TX) 646 params.ndis_ip4csum = NDIS_OFFLOAD_PARAM_TXRX; 647 else 648 params.ndis_ip4csum = NDIS_OFFLOAD_PARAM_RX; 649 } 650 651 /* TCP4 checksum */ 652 if ((hwcaps.ndis_csum.ndis_ip4_txcsum & HN_NDIS_TXCSUM_CAP_TCP4) == 653 HN_NDIS_TXCSUM_CAP_TCP4) { 654 caps |= HN_CAP_TCP4CS; 655 params.ndis_tcp4csum = NDIS_OFFLOAD_PARAM_TX; 656 } 657 if (hwcaps.ndis_csum.ndis_ip4_rxcsum & NDIS_RXCSUM_CAP_TCP4) { 658 if (params.ndis_tcp4csum == NDIS_OFFLOAD_PARAM_TX) 659 params.ndis_tcp4csum = NDIS_OFFLOAD_PARAM_TXRX; 660 else 661 params.ndis_tcp4csum = NDIS_OFFLOAD_PARAM_RX; 662 } 663 664 /* UDP4 checksum */ 665 if (hwcaps.ndis_csum.ndis_ip4_txcsum & NDIS_TXCSUM_CAP_UDP4) { 666 caps |= HN_CAP_UDP4CS; 667 params.ndis_udp4csum = NDIS_OFFLOAD_PARAM_TX; 668 } 669 if (hwcaps.ndis_csum.ndis_ip4_rxcsum & NDIS_RXCSUM_CAP_UDP4) { 670 if (params.ndis_udp4csum == NDIS_OFFLOAD_PARAM_TX) 671 params.ndis_udp4csum = NDIS_OFFLOAD_PARAM_TXRX; 672 else 673 params.ndis_udp4csum = NDIS_OFFLOAD_PARAM_RX; 674 } 675 676 /* TCP6 checksum */ 677 if ((hwcaps.ndis_csum.ndis_ip6_txcsum & HN_NDIS_TXCSUM_CAP_TCP6) == 678 HN_NDIS_TXCSUM_CAP_TCP6) { 679 caps |= HN_CAP_TCP6CS; 680 params.ndis_tcp6csum = NDIS_OFFLOAD_PARAM_TX; 681 } 682 if (hwcaps.ndis_csum.ndis_ip6_rxcsum & NDIS_RXCSUM_CAP_TCP6) { 683 if (params.ndis_tcp6csum == NDIS_OFFLOAD_PARAM_TX) 684 params.ndis_tcp6csum = NDIS_OFFLOAD_PARAM_TXRX; 685 else 686 params.ndis_tcp6csum = NDIS_OFFLOAD_PARAM_RX; 687 } 688 689 /* UDP6 checksum */ 690 if ((hwcaps.ndis_csum.ndis_ip6_txcsum & HN_NDIS_TXCSUM_CAP_UDP6) == 691 HN_NDIS_TXCSUM_CAP_UDP6) { 692 caps |= HN_CAP_UDP6CS; 693 params.ndis_udp6csum = NDIS_OFFLOAD_PARAM_TX; 694 } 695 if (hwcaps.ndis_csum.ndis_ip6_rxcsum & NDIS_RXCSUM_CAP_UDP6) { 696 if (params.ndis_udp6csum == NDIS_OFFLOAD_PARAM_TX) 697 params.ndis_udp6csum = NDIS_OFFLOAD_PARAM_TXRX; 698 else 699 params.ndis_udp6csum = NDIS_OFFLOAD_PARAM_RX; 700 } 701 702 if (bootverbose) { 703 if_printf(sc->hn_ifp, "offload csum: " 704 "ip4 %u, tcp4 %u, udp4 %u, tcp6 %u, udp6 %u\n", 705 params.ndis_ip4csum, 706 params.ndis_tcp4csum, 707 params.ndis_udp4csum, 708 params.ndis_tcp6csum, 709 params.ndis_udp6csum); 710 if_printf(sc->hn_ifp, "offload lsov2: ip4 %u, ip6 %u\n", 711 params.ndis_lsov2_ip4, 712 params.ndis_lsov2_ip6); 713 } 714 715 error = hn_rndis_set(sc, OID_TCP_OFFLOAD_PARAMETERS, ¶ms, paramsz); 716 if (error) { 717 if_printf(sc->hn_ifp, "offload config failed: %d\n", error); 718 return (error); 719 } 720 721 if (bootverbose) 722 if_printf(sc->hn_ifp, "offload config done\n"); 723 sc->hn_caps |= caps; 724 return (0); 725 } 726 727 int 728 hn_rndis_conf_rss(struct hn_softc *sc, uint16_t flags) 729 { 730 struct ndis_rssprm_toeplitz *rss = &sc->hn_rss; 731 struct ndis_rss_params *prm = &rss->rss_params; 732 int error, rss_size; 733 734 /* 735 * Only NDIS 6.20+ is supported: 736 * We only support 4bytes element in indirect table, which has been 737 * adopted since NDIS 6.20. 738 */ 739 KASSERT(sc->hn_ndis_ver >= HN_NDIS_VERSION_6_20, 740 ("NDIS 6.20+ is required, NDIS version 0x%08x", sc->hn_ndis_ver)); 741 742 /* XXX only one can be specified through, popcnt? */ 743 KASSERT((sc->hn_rss_hash & NDIS_HASH_FUNCTION_MASK), ("no hash func")); 744 KASSERT((sc->hn_rss_hash & NDIS_HASH_TYPE_MASK), ("no hash types")); 745 KASSERT(sc->hn_rss_ind_size > 0, ("no indirect table size")); 746 747 if (bootverbose) { 748 if_printf(sc->hn_ifp, "RSS indirect table size %d, " 749 "hash 0x%08x\n", sc->hn_rss_ind_size, sc->hn_rss_hash); 750 } 751 752 /* 753 * NOTE: 754 * DO NOT whack rss_key and rss_ind, which are setup by the caller. 755 */ 756 memset(prm, 0, sizeof(*prm)); 757 rss_size = NDIS_RSSPRM_TOEPLITZ_SIZE(sc->hn_rss_ind_size); 758 759 prm->ndis_hdr.ndis_type = NDIS_OBJTYPE_RSS_PARAMS; 760 prm->ndis_hdr.ndis_rev = NDIS_RSS_PARAMS_REV_2; 761 prm->ndis_hdr.ndis_size = rss_size; 762 prm->ndis_flags = flags; 763 prm->ndis_hash = sc->hn_rss_hash; 764 prm->ndis_indsize = sizeof(rss->rss_ind[0]) * sc->hn_rss_ind_size; 765 prm->ndis_indoffset = 766 __offsetof(struct ndis_rssprm_toeplitz, rss_ind[0]); 767 prm->ndis_keysize = sizeof(rss->rss_key); 768 prm->ndis_keyoffset = 769 __offsetof(struct ndis_rssprm_toeplitz, rss_key[0]); 770 771 error = hn_rndis_set(sc, OID_GEN_RECEIVE_SCALE_PARAMETERS, 772 rss, rss_size); 773 if (error) { 774 if_printf(sc->hn_ifp, "RSS config failed: %d\n", error); 775 } else { 776 if (bootverbose) 777 if_printf(sc->hn_ifp, "RSS config done\n"); 778 } 779 return (error); 780 } 781 782 int 783 hn_rndis_set_rxfilter(struct hn_softc *sc, uint32_t filter) 784 { 785 int error; 786 787 error = hn_rndis_set(sc, OID_GEN_CURRENT_PACKET_FILTER, 788 &filter, sizeof(filter)); 789 if (error) { 790 if_printf(sc->hn_ifp, "set RX filter 0x%08x failed: %d\n", 791 filter, error); 792 } else { 793 if (bootverbose) { 794 if_printf(sc->hn_ifp, "set RX filter 0x%08x done\n", 795 filter); 796 } 797 } 798 return (error); 799 } 800 801 static int 802 hn_rndis_init(struct hn_softc *sc) 803 { 804 struct rndis_init_req *req; 805 const struct rndis_init_comp *comp; 806 struct vmbus_xact *xact; 807 size_t comp_len; 808 uint32_t rid; 809 int error; 810 811 xact = vmbus_xact_get(sc->hn_xact, sizeof(*req)); 812 if (xact == NULL) { 813 if_printf(sc->hn_ifp, "no xact for RNDIS init\n"); 814 return (ENXIO); 815 } 816 rid = hn_rndis_rid(sc); 817 req = vmbus_xact_req_data(xact); 818 req->rm_type = REMOTE_NDIS_INITIALIZE_MSG; 819 req->rm_len = sizeof(*req); 820 req->rm_rid = rid; 821 req->rm_ver_major = RNDIS_VERSION_MAJOR; 822 req->rm_ver_minor = RNDIS_VERSION_MINOR; 823 req->rm_max_xfersz = HN_RNDIS_XFER_SIZE; 824 825 comp_len = RNDIS_INIT_COMP_SIZE_MIN; 826 comp = hn_rndis_xact_execute(sc, xact, rid, sizeof(*req), &comp_len, 827 REMOTE_NDIS_INITIALIZE_CMPLT); 828 if (comp == NULL) { 829 if_printf(sc->hn_ifp, "exec RNDIS init failed\n"); 830 error = EIO; 831 goto done; 832 } 833 834 if (comp->rm_status != RNDIS_STATUS_SUCCESS) { 835 if_printf(sc->hn_ifp, "RNDIS init failed: status 0x%08x\n", 836 comp->rm_status); 837 error = EIO; 838 goto done; 839 } 840 sc->hn_rndis_agg_size = comp->rm_pktmaxsz; 841 sc->hn_rndis_agg_pkts = comp->rm_pktmaxcnt; 842 sc->hn_rndis_agg_align = 1U << comp->rm_align; 843 844 if (sc->hn_rndis_agg_align < sizeof(uint32_t)) { 845 /* 846 * The RNDIS packet messsage encap assumes that the RNDIS 847 * packet message is at least 4 bytes aligned. Fix up the 848 * alignment here, if the remote side sets the alignment 849 * too low. 850 */ 851 if_printf(sc->hn_ifp, "fixup RNDIS aggpkt align: %u -> %zu\n", 852 sc->hn_rndis_agg_align, sizeof(uint32_t)); 853 sc->hn_rndis_agg_align = sizeof(uint32_t); 854 } 855 856 if (bootverbose) { 857 if_printf(sc->hn_ifp, "RNDIS ver %u.%u, " 858 "aggpkt size %u, aggpkt cnt %u, aggpkt align %u\n", 859 comp->rm_ver_major, comp->rm_ver_minor, 860 sc->hn_rndis_agg_size, sc->hn_rndis_agg_pkts, 861 sc->hn_rndis_agg_align); 862 } 863 error = 0; 864 done: 865 vmbus_xact_put(xact); 866 return (error); 867 } 868 869 static int 870 hn_rndis_halt(struct hn_softc *sc) 871 { 872 struct vmbus_xact *xact; 873 struct rndis_halt_req *halt; 874 struct hn_nvs_sendctx sndc; 875 size_t comp_len; 876 877 xact = vmbus_xact_get(sc->hn_xact, sizeof(*halt)); 878 if (xact == NULL) { 879 if_printf(sc->hn_ifp, "no xact for RNDIS halt\n"); 880 return (ENXIO); 881 } 882 halt = vmbus_xact_req_data(xact); 883 halt->rm_type = REMOTE_NDIS_HALT_MSG; 884 halt->rm_len = sizeof(*halt); 885 halt->rm_rid = hn_rndis_rid(sc); 886 887 /* No RNDIS completion; rely on NVS message send completion */ 888 hn_nvs_sendctx_init(&sndc, hn_nvs_sent_xact, xact); 889 hn_rndis_xact_exec1(sc, xact, sizeof(*halt), &sndc, &comp_len); 890 891 vmbus_xact_put(xact); 892 if (bootverbose) 893 if_printf(sc->hn_ifp, "RNDIS halt done\n"); 894 return (0); 895 } 896 897 static int 898 hn_rndis_query_hwcaps(struct hn_softc *sc, struct ndis_offload *caps) 899 { 900 struct ndis_offload in; 901 size_t caps_len, size; 902 int error; 903 904 memset(&in, 0, sizeof(in)); 905 in.ndis_hdr.ndis_type = NDIS_OBJTYPE_OFFLOAD; 906 if (sc->hn_ndis_ver >= HN_NDIS_VERSION_6_30) { 907 in.ndis_hdr.ndis_rev = NDIS_OFFLOAD_REV_3; 908 size = NDIS_OFFLOAD_SIZE; 909 } else if (sc->hn_ndis_ver >= HN_NDIS_VERSION_6_1) { 910 in.ndis_hdr.ndis_rev = NDIS_OFFLOAD_REV_2; 911 size = NDIS_OFFLOAD_SIZE_6_1; 912 } else { 913 in.ndis_hdr.ndis_rev = NDIS_OFFLOAD_REV_1; 914 size = NDIS_OFFLOAD_SIZE_6_0; 915 } 916 in.ndis_hdr.ndis_size = size; 917 918 caps_len = NDIS_OFFLOAD_SIZE; 919 error = hn_rndis_query2(sc, OID_TCP_OFFLOAD_HARDWARE_CAPABILITIES, 920 &in, size, caps, &caps_len, NDIS_OFFLOAD_SIZE_6_0); 921 if (error) 922 return (error); 923 924 /* 925 * Preliminary verification. 926 */ 927 if (caps->ndis_hdr.ndis_type != NDIS_OBJTYPE_OFFLOAD) { 928 if_printf(sc->hn_ifp, "invalid NDIS objtype 0x%02x\n", 929 caps->ndis_hdr.ndis_type); 930 return (EINVAL); 931 } 932 if (caps->ndis_hdr.ndis_rev < NDIS_OFFLOAD_REV_1) { 933 if_printf(sc->hn_ifp, "invalid NDIS objrev 0x%02x\n", 934 caps->ndis_hdr.ndis_rev); 935 return (EINVAL); 936 } 937 if (caps->ndis_hdr.ndis_size > caps_len) { 938 if_printf(sc->hn_ifp, "invalid NDIS objsize %u, " 939 "data size %zu\n", caps->ndis_hdr.ndis_size, caps_len); 940 return (EINVAL); 941 } else if (caps->ndis_hdr.ndis_size < NDIS_OFFLOAD_SIZE_6_0) { 942 if_printf(sc->hn_ifp, "invalid NDIS objsize %u\n", 943 caps->ndis_hdr.ndis_size); 944 return (EINVAL); 945 } 946 947 if (bootverbose) { 948 /* 949 * NOTE: 950 * caps->ndis_hdr.ndis_size MUST be checked before accessing 951 * NDIS 6.1+ specific fields. 952 */ 953 if_printf(sc->hn_ifp, "hwcaps rev %u\n", 954 caps->ndis_hdr.ndis_rev); 955 956 if_printf(sc->hn_ifp, "hwcaps csum: " 957 "ip4 tx 0x%x/0x%x rx 0x%x/0x%x, " 958 "ip6 tx 0x%x/0x%x rx 0x%x/0x%x\n", 959 caps->ndis_csum.ndis_ip4_txcsum, 960 caps->ndis_csum.ndis_ip4_txenc, 961 caps->ndis_csum.ndis_ip4_rxcsum, 962 caps->ndis_csum.ndis_ip4_rxenc, 963 caps->ndis_csum.ndis_ip6_txcsum, 964 caps->ndis_csum.ndis_ip6_txenc, 965 caps->ndis_csum.ndis_ip6_rxcsum, 966 caps->ndis_csum.ndis_ip6_rxenc); 967 if_printf(sc->hn_ifp, "hwcaps lsov2: " 968 "ip4 maxsz %u minsg %u encap 0x%x, " 969 "ip6 maxsz %u minsg %u encap 0x%x opts 0x%x\n", 970 caps->ndis_lsov2.ndis_ip4_maxsz, 971 caps->ndis_lsov2.ndis_ip4_minsg, 972 caps->ndis_lsov2.ndis_ip4_encap, 973 caps->ndis_lsov2.ndis_ip6_maxsz, 974 caps->ndis_lsov2.ndis_ip6_minsg, 975 caps->ndis_lsov2.ndis_ip6_encap, 976 caps->ndis_lsov2.ndis_ip6_opts); 977 } 978 return (0); 979 } 980 981 int 982 hn_rndis_attach(struct hn_softc *sc, int mtu, int *init_done) 983 { 984 int error; 985 986 *init_done = 0; 987 988 /* 989 * Initialize RNDIS. 990 */ 991 error = hn_rndis_init(sc); 992 if (error) 993 return (error); 994 *init_done = 1; 995 996 /* 997 * Configure NDIS offload settings. 998 */ 999 hn_rndis_conf_offload(sc, mtu); 1000 return (0); 1001 } 1002 1003 void 1004 hn_rndis_detach(struct hn_softc *sc) 1005 { 1006 1007 /* Halt the RNDIS. */ 1008 hn_rndis_halt(sc); 1009 } 1010