1 /* 2 * 3 * Copyright (c) 2011, Microsoft Corporation. 4 * 5 * This program is free software; you can redistribute it and/or modify it 6 * under the terms and conditions of the GNU General Public License, 7 * version 2, as published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 12 * more details. 13 * 14 * You should have received a copy of the GNU General Public License along with 15 * this program; if not, see <http://www.gnu.org/licenses/>. 16 * 17 * Authors: 18 * Haiyang Zhang <haiyangz@microsoft.com> 19 * Hank Janssen <hjanssen@microsoft.com> 20 * K. Y. Srinivasan <kys@microsoft.com> 21 * 22 */ 23 24 #ifndef _HYPERV_NET_H 25 #define _HYPERV_NET_H 26 27 #include <linux/list.h> 28 #include <linux/hyperv.h> 29 #include <linux/rndis.h> 30 31 /* Fwd declaration */ 32 struct hv_netvsc_packet; 33 struct ndis_tcp_ip_checksum_info; 34 35 /* Represent the xfer page packet which contains 1 or more netvsc packet */ 36 struct xferpage_packet { 37 struct list_head list_ent; 38 u32 status; 39 40 /* # of netvsc packets this xfer packet contains */ 41 u32 count; 42 }; 43 44 /* 45 * Represent netvsc packet which contains 1 RNDIS and 1 ethernet frame 46 * within the RNDIS 47 */ 48 struct hv_netvsc_packet { 49 /* Bookkeeping stuff */ 50 struct list_head list_ent; 51 u32 status; 52 53 struct hv_device *device; 54 bool is_data_pkt; 55 u16 vlan_tci; 56 57 /* 58 * Valid only for receives when we break a xfer page packet 59 * into multiple netvsc packets 60 */ 61 struct xferpage_packet *xfer_page_pkt; 62 63 union { 64 struct { 65 u64 recv_completion_tid; 66 void *recv_completion_ctx; 67 void (*recv_completion)(void *context); 68 } recv; 69 struct { 70 u64 send_completion_tid; 71 void *send_completion_ctx; 72 void (*send_completion)(void *context); 73 } send; 74 } completion; 75 76 /* This points to the memory after page_buf */ 77 struct rndis_message *rndis_msg; 78 79 u32 total_data_buflen; 80 /* Points to the send/receive buffer where the ethernet frame is */ 81 void *data; 82 u32 page_buf_cnt; 83 struct hv_page_buffer page_buf[0]; 84 }; 85 86 struct netvsc_device_info { 87 unsigned char mac_adr[ETH_ALEN]; 88 bool link_state; /* 0 - link up, 1 - link down */ 89 int ring_size; 90 }; 91 92 enum rndis_device_state { 93 RNDIS_DEV_UNINITIALIZED = 0, 94 RNDIS_DEV_INITIALIZING, 95 RNDIS_DEV_INITIALIZED, 96 RNDIS_DEV_DATAINITIALIZED, 97 }; 98 99 struct rndis_device { 100 struct netvsc_device *net_dev; 101 102 enum rndis_device_state state; 103 bool link_state; 104 atomic_t new_req_id; 105 106 spinlock_t request_lock; 107 struct list_head req_list; 108 109 unsigned char hw_mac_adr[ETH_ALEN]; 110 }; 111 112 113 /* Interface */ 114 int netvsc_device_add(struct hv_device *device, void *additional_info); 115 int netvsc_device_remove(struct hv_device *device); 116 int netvsc_send(struct hv_device *device, 117 struct hv_netvsc_packet *packet); 118 void netvsc_linkstatus_callback(struct hv_device *device_obj, 119 unsigned int status); 120 int netvsc_recv_callback(struct hv_device *device_obj, 121 struct hv_netvsc_packet *packet, 122 struct ndis_tcp_ip_checksum_info *csum_info); 123 int rndis_filter_open(struct hv_device *dev); 124 int rndis_filter_close(struct hv_device *dev); 125 int rndis_filter_device_add(struct hv_device *dev, 126 void *additional_info); 127 void rndis_filter_device_remove(struct hv_device *dev); 128 int rndis_filter_receive(struct hv_device *dev, 129 struct hv_netvsc_packet *pkt); 130 131 int rndis_filter_set_packet_filter(struct rndis_device *dev, u32 new_filter); 132 int rndis_filter_set_device_mac(struct hv_device *hdev, char *mac); 133 134 135 #define NVSP_INVALID_PROTOCOL_VERSION ((u32)0xFFFFFFFF) 136 137 #define NVSP_PROTOCOL_VERSION_1 2 138 #define NVSP_PROTOCOL_VERSION_2 0x30002 139 #define NVSP_PROTOCOL_VERSION_4 0x40000 140 #define NVSP_PROTOCOL_VERSION_5 0x50000 141 142 enum { 143 NVSP_MSG_TYPE_NONE = 0, 144 145 /* Init Messages */ 146 NVSP_MSG_TYPE_INIT = 1, 147 NVSP_MSG_TYPE_INIT_COMPLETE = 2, 148 149 NVSP_VERSION_MSG_START = 100, 150 151 /* Version 1 Messages */ 152 NVSP_MSG1_TYPE_SEND_NDIS_VER = NVSP_VERSION_MSG_START, 153 154 NVSP_MSG1_TYPE_SEND_RECV_BUF, 155 NVSP_MSG1_TYPE_SEND_RECV_BUF_COMPLETE, 156 NVSP_MSG1_TYPE_REVOKE_RECV_BUF, 157 158 NVSP_MSG1_TYPE_SEND_SEND_BUF, 159 NVSP_MSG1_TYPE_SEND_SEND_BUF_COMPLETE, 160 NVSP_MSG1_TYPE_REVOKE_SEND_BUF, 161 162 NVSP_MSG1_TYPE_SEND_RNDIS_PKT, 163 NVSP_MSG1_TYPE_SEND_RNDIS_PKT_COMPLETE, 164 165 /* Version 2 messages */ 166 NVSP_MSG2_TYPE_SEND_CHIMNEY_DELEGATED_BUF, 167 NVSP_MSG2_TYPE_SEND_CHIMNEY_DELEGATED_BUF_COMP, 168 NVSP_MSG2_TYPE_REVOKE_CHIMNEY_DELEGATED_BUF, 169 170 NVSP_MSG2_TYPE_RESUME_CHIMNEY_RX_INDICATION, 171 172 NVSP_MSG2_TYPE_TERMINATE_CHIMNEY, 173 NVSP_MSG2_TYPE_TERMINATE_CHIMNEY_COMP, 174 175 NVSP_MSG2_TYPE_INDICATE_CHIMNEY_EVENT, 176 177 NVSP_MSG2_TYPE_SEND_CHIMNEY_PKT, 178 NVSP_MSG2_TYPE_SEND_CHIMNEY_PKT_COMP, 179 180 NVSP_MSG2_TYPE_POST_CHIMNEY_RECV_REQ, 181 NVSP_MSG2_TYPE_POST_CHIMNEY_RECV_REQ_COMP, 182 183 NVSP_MSG2_TYPE_ALLOC_RXBUF, 184 NVSP_MSG2_TYPE_ALLOC_RXBUF_COMP, 185 186 NVSP_MSG2_TYPE_FREE_RXBUF, 187 188 NVSP_MSG2_TYPE_SEND_VMQ_RNDIS_PKT, 189 NVSP_MSG2_TYPE_SEND_VMQ_RNDIS_PKT_COMP, 190 191 NVSP_MSG2_TYPE_SEND_NDIS_CONFIG, 192 193 NVSP_MSG2_TYPE_ALLOC_CHIMNEY_HANDLE, 194 NVSP_MSG2_TYPE_ALLOC_CHIMNEY_HANDLE_COMP, 195 196 NVSP_MSG2_MAX = NVSP_MSG2_TYPE_ALLOC_CHIMNEY_HANDLE_COMP, 197 198 /* Version 4 messages */ 199 NVSP_MSG4_TYPE_SEND_VF_ASSOCIATION, 200 NVSP_MSG4_TYPE_SWITCH_DATA_PATH, 201 NVSP_MSG4_TYPE_UPLINK_CONNECT_STATE_DEPRECATED, 202 203 NVSP_MSG4_MAX = NVSP_MSG4_TYPE_UPLINK_CONNECT_STATE_DEPRECATED, 204 205 /* Version 5 messages */ 206 NVSP_MSG5_TYPE_OID_QUERY_EX, 207 NVSP_MSG5_TYPE_OID_QUERY_EX_COMP, 208 NVSP_MSG5_TYPE_SUBCHANNEL, 209 NVSP_MSG5_TYPE_SEND_INDIRECTION_TABLE, 210 211 NVSP_MSG5_MAX = NVSP_MSG5_TYPE_SEND_INDIRECTION_TABLE, 212 }; 213 214 enum { 215 NVSP_STAT_NONE = 0, 216 NVSP_STAT_SUCCESS, 217 NVSP_STAT_FAIL, 218 NVSP_STAT_PROTOCOL_TOO_NEW, 219 NVSP_STAT_PROTOCOL_TOO_OLD, 220 NVSP_STAT_INVALID_RNDIS_PKT, 221 NVSP_STAT_BUSY, 222 NVSP_STAT_PROTOCOL_UNSUPPORTED, 223 NVSP_STAT_MAX, 224 }; 225 226 struct nvsp_message_header { 227 u32 msg_type; 228 }; 229 230 /* Init Messages */ 231 232 /* 233 * This message is used by the VSC to initialize the channel after the channels 234 * has been opened. This message should never include anything other then 235 * versioning (i.e. this message will be the same for ever). 236 */ 237 struct nvsp_message_init { 238 u32 min_protocol_ver; 239 u32 max_protocol_ver; 240 } __packed; 241 242 /* 243 * This message is used by the VSP to complete the initialization of the 244 * channel. This message should never include anything other then versioning 245 * (i.e. this message will be the same for ever). 246 */ 247 struct nvsp_message_init_complete { 248 u32 negotiated_protocol_ver; 249 u32 max_mdl_chain_len; 250 u32 status; 251 } __packed; 252 253 union nvsp_message_init_uber { 254 struct nvsp_message_init init; 255 struct nvsp_message_init_complete init_complete; 256 } __packed; 257 258 /* Version 1 Messages */ 259 260 /* 261 * This message is used by the VSC to send the NDIS version to the VSP. The VSP 262 * can use this information when handling OIDs sent by the VSC. 263 */ 264 struct nvsp_1_message_send_ndis_version { 265 u32 ndis_major_ver; 266 u32 ndis_minor_ver; 267 } __packed; 268 269 /* 270 * This message is used by the VSC to send a receive buffer to the VSP. The VSP 271 * can then use the receive buffer to send data to the VSC. 272 */ 273 struct nvsp_1_message_send_receive_buffer { 274 u32 gpadl_handle; 275 u16 id; 276 } __packed; 277 278 struct nvsp_1_receive_buffer_section { 279 u32 offset; 280 u32 sub_alloc_size; 281 u32 num_sub_allocs; 282 u32 end_offset; 283 } __packed; 284 285 /* 286 * This message is used by the VSP to acknowledge a receive buffer send by the 287 * VSC. This message must be sent by the VSP before the VSP uses the receive 288 * buffer. 289 */ 290 struct nvsp_1_message_send_receive_buffer_complete { 291 u32 status; 292 u32 num_sections; 293 294 /* 295 * The receive buffer is split into two parts, a large suballocation 296 * section and a small suballocation section. These sections are then 297 * suballocated by a certain size. 298 */ 299 300 /* 301 * For example, the following break up of the receive buffer has 6 302 * large suballocations and 10 small suballocations. 303 */ 304 305 /* 306 * | Large Section | | Small Section | 307 * ------------------------------------------------------------ 308 * | | | | | | | | | | | | | | | | | | 309 * | | 310 * LargeOffset SmallOffset 311 */ 312 313 struct nvsp_1_receive_buffer_section sections[1]; 314 } __packed; 315 316 /* 317 * This message is sent by the VSC to revoke the receive buffer. After the VSP 318 * completes this transaction, the vsp should never use the receive buffer 319 * again. 320 */ 321 struct nvsp_1_message_revoke_receive_buffer { 322 u16 id; 323 }; 324 325 /* 326 * This message is used by the VSC to send a send buffer to the VSP. The VSC 327 * can then use the send buffer to send data to the VSP. 328 */ 329 struct nvsp_1_message_send_send_buffer { 330 u32 gpadl_handle; 331 u16 id; 332 } __packed; 333 334 /* 335 * This message is used by the VSP to acknowledge a send buffer sent by the 336 * VSC. This message must be sent by the VSP before the VSP uses the sent 337 * buffer. 338 */ 339 struct nvsp_1_message_send_send_buffer_complete { 340 u32 status; 341 342 /* 343 * The VSC gets to choose the size of the send buffer and the VSP gets 344 * to choose the sections size of the buffer. This was done to enable 345 * dynamic reconfigurations when the cost of GPA-direct buffers 346 * decreases. 347 */ 348 u32 section_size; 349 } __packed; 350 351 /* 352 * This message is sent by the VSC to revoke the send buffer. After the VSP 353 * completes this transaction, the vsp should never use the send buffer again. 354 */ 355 struct nvsp_1_message_revoke_send_buffer { 356 u16 id; 357 }; 358 359 /* 360 * This message is used by both the VSP and the VSC to send a RNDIS message to 361 * the opposite channel endpoint. 362 */ 363 struct nvsp_1_message_send_rndis_packet { 364 /* 365 * This field is specified by RNIDS. They assume there's two different 366 * channels of communication. However, the Network VSP only has one. 367 * Therefore, the channel travels with the RNDIS packet. 368 */ 369 u32 channel_type; 370 371 /* 372 * This field is used to send part or all of the data through a send 373 * buffer. This values specifies an index into the send buffer. If the 374 * index is 0xFFFFFFFF, then the send buffer is not being used and all 375 * of the data was sent through other VMBus mechanisms. 376 */ 377 u32 send_buf_section_index; 378 u32 send_buf_section_size; 379 } __packed; 380 381 /* 382 * This message is used by both the VSP and the VSC to complete a RNDIS message 383 * to the opposite channel endpoint. At this point, the initiator of this 384 * message cannot use any resources associated with the original RNDIS packet. 385 */ 386 struct nvsp_1_message_send_rndis_packet_complete { 387 u32 status; 388 }; 389 390 union nvsp_1_message_uber { 391 struct nvsp_1_message_send_ndis_version send_ndis_ver; 392 393 struct nvsp_1_message_send_receive_buffer send_recv_buf; 394 struct nvsp_1_message_send_receive_buffer_complete 395 send_recv_buf_complete; 396 struct nvsp_1_message_revoke_receive_buffer revoke_recv_buf; 397 398 struct nvsp_1_message_send_send_buffer send_send_buf; 399 struct nvsp_1_message_send_send_buffer_complete send_send_buf_complete; 400 struct nvsp_1_message_revoke_send_buffer revoke_send_buf; 401 402 struct nvsp_1_message_send_rndis_packet send_rndis_pkt; 403 struct nvsp_1_message_send_rndis_packet_complete 404 send_rndis_pkt_complete; 405 } __packed; 406 407 408 /* 409 * Network VSP protocol version 2 messages: 410 */ 411 struct nvsp_2_vsc_capability { 412 union { 413 u64 data; 414 struct { 415 u64 vmq:1; 416 u64 chimney:1; 417 u64 sriov:1; 418 u64 ieee8021q:1; 419 u64 correlation_id:1; 420 }; 421 }; 422 } __packed; 423 424 struct nvsp_2_send_ndis_config { 425 u32 mtu; 426 u32 reserved; 427 struct nvsp_2_vsc_capability capability; 428 } __packed; 429 430 /* Allocate receive buffer */ 431 struct nvsp_2_alloc_rxbuf { 432 /* Allocation ID to match the allocation request and response */ 433 u32 alloc_id; 434 435 /* Length of the VM shared memory receive buffer that needs to 436 * be allocated 437 */ 438 u32 len; 439 } __packed; 440 441 /* Allocate receive buffer complete */ 442 struct nvsp_2_alloc_rxbuf_comp { 443 /* The NDIS_STATUS code for buffer allocation */ 444 u32 status; 445 446 u32 alloc_id; 447 448 /* GPADL handle for the allocated receive buffer */ 449 u32 gpadl_handle; 450 451 /* Receive buffer ID */ 452 u64 recv_buf_id; 453 } __packed; 454 455 struct nvsp_2_free_rxbuf { 456 u64 recv_buf_id; 457 } __packed; 458 459 union nvsp_2_message_uber { 460 struct nvsp_2_send_ndis_config send_ndis_config; 461 struct nvsp_2_alloc_rxbuf alloc_rxbuf; 462 struct nvsp_2_alloc_rxbuf_comp alloc_rxbuf_comp; 463 struct nvsp_2_free_rxbuf free_rxbuf; 464 } __packed; 465 466 enum nvsp_subchannel_operation { 467 NVSP_SUBCHANNEL_NONE = 0, 468 NVSP_SUBCHANNEL_ALLOCATE, 469 NVSP_SUBCHANNEL_MAX 470 }; 471 472 struct nvsp_5_subchannel_request { 473 u32 op; 474 u32 num_subchannels; 475 } __packed; 476 477 struct nvsp_5_subchannel_complete { 478 u32 status; 479 u32 num_subchannels; /* Actual number of subchannels allocated */ 480 } __packed; 481 482 struct nvsp_5_send_indirect_table { 483 /* The number of entries in the send indirection table */ 484 u32 count; 485 486 /* The offset of the send indireciton table from top of this struct. 487 * The send indirection table tells which channel to put the send 488 * traffic on. Each entry is a channel number. 489 */ 490 u32 offset; 491 } __packed; 492 493 union nvsp_5_message_uber { 494 struct nvsp_5_subchannel_request subchn_req; 495 struct nvsp_5_subchannel_complete subchn_comp; 496 struct nvsp_5_send_indirect_table send_table; 497 } __packed; 498 499 union nvsp_all_messages { 500 union nvsp_message_init_uber init_msg; 501 union nvsp_1_message_uber v1_msg; 502 union nvsp_2_message_uber v2_msg; 503 union nvsp_5_message_uber v5_msg; 504 } __packed; 505 506 /* ALL Messages */ 507 struct nvsp_message { 508 struct nvsp_message_header hdr; 509 union nvsp_all_messages msg; 510 } __packed; 511 512 513 #define NETVSC_MTU 65536 514 515 #define NETVSC_RECEIVE_BUFFER_SIZE (1024*1024*16) /* 16MB */ 516 #define NETVSC_RECEIVE_BUFFER_SIZE_LEGACY (1024*1024*15) /* 15MB */ 517 518 #define NETVSC_RECEIVE_BUFFER_ID 0xcafe 519 520 /* Preallocated receive packets */ 521 #define NETVSC_RECEIVE_PACKETLIST_COUNT 256 522 523 #define NETVSC_PACKET_SIZE 2048 524 525 /* Per netvsc channel-specific */ 526 struct netvsc_device { 527 struct hv_device *dev; 528 529 u32 nvsp_version; 530 531 atomic_t num_outstanding_sends; 532 wait_queue_head_t wait_drain; 533 bool start_remove; 534 bool destroy; 535 /* 536 * List of free preallocated hv_netvsc_packet to represent receive 537 * packet 538 */ 539 struct list_head recv_pkt_list; 540 spinlock_t recv_pkt_list_lock; 541 542 /* Receive buffer allocated by us but manages by NetVSP */ 543 void *recv_buf; 544 u32 recv_buf_size; 545 u32 recv_buf_gpadl_handle; 546 u32 recv_section_cnt; 547 struct nvsp_1_receive_buffer_section *recv_section; 548 549 /* Used for NetVSP initialization protocol */ 550 struct completion channel_init_wait; 551 struct nvsp_message channel_init_pkt; 552 553 struct nvsp_message revoke_packet; 554 /* unsigned char HwMacAddr[HW_MACADDR_LEN]; */ 555 556 struct net_device *ndev; 557 558 /* Holds rndis device info */ 559 void *extension; 560 /* The recive buffer for this device */ 561 unsigned char cb_buffer[NETVSC_PACKET_SIZE]; 562 }; 563 564 /* NdisInitialize message */ 565 struct rndis_initialize_request { 566 u32 req_id; 567 u32 major_ver; 568 u32 minor_ver; 569 u32 max_xfer_size; 570 }; 571 572 /* Response to NdisInitialize */ 573 struct rndis_initialize_complete { 574 u32 req_id; 575 u32 status; 576 u32 major_ver; 577 u32 minor_ver; 578 u32 dev_flags; 579 u32 medium; 580 u32 max_pkt_per_msg; 581 u32 max_xfer_size; 582 u32 pkt_alignment_factor; 583 u32 af_list_offset; 584 u32 af_list_size; 585 }; 586 587 /* Call manager devices only: Information about an address family */ 588 /* supported by the device is appended to the response to NdisInitialize. */ 589 struct rndis_co_address_family { 590 u32 address_family; 591 u32 major_ver; 592 u32 minor_ver; 593 }; 594 595 /* NdisHalt message */ 596 struct rndis_halt_request { 597 u32 req_id; 598 }; 599 600 /* NdisQueryRequest message */ 601 struct rndis_query_request { 602 u32 req_id; 603 u32 oid; 604 u32 info_buflen; 605 u32 info_buf_offset; 606 u32 dev_vc_handle; 607 }; 608 609 /* Response to NdisQueryRequest */ 610 struct rndis_query_complete { 611 u32 req_id; 612 u32 status; 613 u32 info_buflen; 614 u32 info_buf_offset; 615 }; 616 617 /* NdisSetRequest message */ 618 struct rndis_set_request { 619 u32 req_id; 620 u32 oid; 621 u32 info_buflen; 622 u32 info_buf_offset; 623 u32 dev_vc_handle; 624 }; 625 626 /* Response to NdisSetRequest */ 627 struct rndis_set_complete { 628 u32 req_id; 629 u32 status; 630 }; 631 632 /* NdisReset message */ 633 struct rndis_reset_request { 634 u32 reserved; 635 }; 636 637 /* Response to NdisReset */ 638 struct rndis_reset_complete { 639 u32 status; 640 u32 addressing_reset; 641 }; 642 643 /* NdisMIndicateStatus message */ 644 struct rndis_indicate_status { 645 u32 status; 646 u32 status_buflen; 647 u32 status_buf_offset; 648 }; 649 650 /* Diagnostic information passed as the status buffer in */ 651 /* struct rndis_indicate_status messages signifying error conditions. */ 652 struct rndis_diagnostic_info { 653 u32 diag_status; 654 u32 error_offset; 655 }; 656 657 /* NdisKeepAlive message */ 658 struct rndis_keepalive_request { 659 u32 req_id; 660 }; 661 662 /* Response to NdisKeepAlive */ 663 struct rndis_keepalive_complete { 664 u32 req_id; 665 u32 status; 666 }; 667 668 /* 669 * Data message. All Offset fields contain byte offsets from the beginning of 670 * struct rndis_packet. All Length fields are in bytes. VcHandle is set 671 * to 0 for connectionless data, otherwise it contains the VC handle. 672 */ 673 struct rndis_packet { 674 u32 data_offset; 675 u32 data_len; 676 u32 oob_data_offset; 677 u32 oob_data_len; 678 u32 num_oob_data_elements; 679 u32 per_pkt_info_offset; 680 u32 per_pkt_info_len; 681 u32 vc_handle; 682 u32 reserved; 683 }; 684 685 /* Optional Out of Band data associated with a Data message. */ 686 struct rndis_oobd { 687 u32 size; 688 u32 type; 689 u32 class_info_offset; 690 }; 691 692 /* Packet extension field contents associated with a Data message. */ 693 struct rndis_per_packet_info { 694 u32 size; 695 u32 type; 696 u32 ppi_offset; 697 }; 698 699 enum ndis_per_pkt_info_type { 700 TCPIP_CHKSUM_PKTINFO, 701 IPSEC_PKTINFO, 702 TCP_LARGESEND_PKTINFO, 703 CLASSIFICATION_HANDLE_PKTINFO, 704 NDIS_RESERVED, 705 SG_LIST_PKTINFO, 706 IEEE_8021Q_INFO, 707 ORIGINAL_PKTINFO, 708 PACKET_CANCEL_ID, 709 ORIGINAL_NET_BUFLIST, 710 CACHED_NET_BUFLIST, 711 SHORT_PKT_PADINFO, 712 MAX_PER_PKT_INFO 713 }; 714 715 struct ndis_pkt_8021q_info { 716 union { 717 struct { 718 u32 pri:3; /* User Priority */ 719 u32 cfi:1; /* Canonical Format ID */ 720 u32 vlanid:12; /* VLAN ID */ 721 u32 reserved:16; 722 }; 723 u32 value; 724 }; 725 }; 726 727 struct ndis_oject_header { 728 u8 type; 729 u8 revision; 730 u16 size; 731 }; 732 733 #define NDIS_OBJECT_TYPE_DEFAULT 0x80 734 #define NDIS_OFFLOAD_PARAMETERS_REVISION_3 3 735 #define NDIS_OFFLOAD_PARAMETERS_NO_CHANGE 0 736 #define NDIS_OFFLOAD_PARAMETERS_LSOV2_DISABLED 1 737 #define NDIS_OFFLOAD_PARAMETERS_LSOV2_ENABLED 2 738 #define NDIS_OFFLOAD_PARAMETERS_LSOV1_ENABLED 2 739 #define NDIS_OFFLOAD_PARAMETERS_RSC_DISABLED 1 740 #define NDIS_OFFLOAD_PARAMETERS_RSC_ENABLED 2 741 #define NDIS_OFFLOAD_PARAMETERS_TX_RX_DISABLED 1 742 #define NDIS_OFFLOAD_PARAMETERS_TX_ENABLED_RX_DISABLED 2 743 #define NDIS_OFFLOAD_PARAMETERS_RX_ENABLED_TX_DISABLED 3 744 #define NDIS_OFFLOAD_PARAMETERS_TX_RX_ENABLED 4 745 746 #define NDIS_TCP_LARGE_SEND_OFFLOAD_V2_TYPE 1 747 #define NDIS_TCP_LARGE_SEND_OFFLOAD_IPV4 0 748 #define NDIS_TCP_LARGE_SEND_OFFLOAD_IPV6 1 749 750 #define VERSION_4_OFFLOAD_SIZE 22 751 /* 752 * New offload OIDs for NDIS 6 753 */ 754 #define OID_TCP_OFFLOAD_CURRENT_CONFIG 0xFC01020B /* query only */ 755 #define OID_TCP_OFFLOAD_PARAMETERS 0xFC01020C /* set only */ 756 #define OID_TCP_OFFLOAD_HARDWARE_CAPABILITIES 0xFC01020D/* query only */ 757 #define OID_TCP_CONNECTION_OFFLOAD_CURRENT_CONFIG 0xFC01020E /* query only */ 758 #define OID_TCP_CONNECTION_OFFLOAD_HARDWARE_CAPABILITIES 0xFC01020F /* query */ 759 #define OID_OFFLOAD_ENCAPSULATION 0x0101010A /* set/query */ 760 761 struct ndis_offload_params { 762 struct ndis_oject_header header; 763 u8 ip_v4_csum; 764 u8 tcp_ip_v4_csum; 765 u8 udp_ip_v4_csum; 766 u8 tcp_ip_v6_csum; 767 u8 udp_ip_v6_csum; 768 u8 lso_v1; 769 u8 ip_sec_v1; 770 u8 lso_v2_ipv4; 771 u8 lso_v2_ipv6; 772 u8 tcp_connection_ip_v4; 773 u8 tcp_connection_ip_v6; 774 u32 flags; 775 u8 ip_sec_v2; 776 u8 ip_sec_v2_ip_v4; 777 struct { 778 u8 rsc_ip_v4; 779 u8 rsc_ip_v6; 780 }; 781 struct { 782 u8 encapsulated_packet_task_offload; 783 u8 encapsulation_types; 784 }; 785 }; 786 787 struct ndis_tcp_ip_checksum_info { 788 union { 789 struct { 790 u32 is_ipv4:1; 791 u32 is_ipv6:1; 792 u32 tcp_checksum:1; 793 u32 udp_checksum:1; 794 u32 ip_header_checksum:1; 795 u32 reserved:11; 796 u32 tcp_header_offset:10; 797 } transmit; 798 struct { 799 u32 tcp_checksum_failed:1; 800 u32 udp_checksum_failed:1; 801 u32 ip_checksum_failed:1; 802 u32 tcp_checksum_succeeded:1; 803 u32 udp_checksum_succeeded:1; 804 u32 ip_checksum_succeeded:1; 805 u32 loopback:1; 806 u32 tcp_checksum_value_invalid:1; 807 u32 ip_checksum_value_invalid:1; 808 } receive; 809 u32 value; 810 }; 811 }; 812 813 struct ndis_tcp_lso_info { 814 union { 815 struct { 816 u32 unused:30; 817 u32 type:1; 818 u32 reserved2:1; 819 } transmit; 820 struct { 821 u32 mss:20; 822 u32 tcp_header_offset:10; 823 u32 type:1; 824 u32 reserved2:1; 825 } lso_v1_transmit; 826 struct { 827 u32 tcp_payload:30; 828 u32 type:1; 829 u32 reserved2:1; 830 } lso_v1_transmit_complete; 831 struct { 832 u32 mss:20; 833 u32 tcp_header_offset:10; 834 u32 type:1; 835 u32 ip_version:1; 836 } lso_v2_transmit; 837 struct { 838 u32 reserved:30; 839 u32 type:1; 840 u32 reserved2:1; 841 } lso_v2_transmit_complete; 842 u32 value; 843 }; 844 }; 845 846 #define NDIS_VLAN_PPI_SIZE (sizeof(struct rndis_per_packet_info) + \ 847 sizeof(struct ndis_pkt_8021q_info)) 848 849 #define NDIS_CSUM_PPI_SIZE (sizeof(struct rndis_per_packet_info) + \ 850 sizeof(struct ndis_tcp_ip_checksum_info)) 851 852 #define NDIS_LSO_PPI_SIZE (sizeof(struct rndis_per_packet_info) + \ 853 sizeof(struct ndis_tcp_lso_info)) 854 855 /* Format of Information buffer passed in a SetRequest for the OID */ 856 /* OID_GEN_RNDIS_CONFIG_PARAMETER. */ 857 struct rndis_config_parameter_info { 858 u32 parameter_name_offset; 859 u32 parameter_name_length; 860 u32 parameter_type; 861 u32 parameter_value_offset; 862 u32 parameter_value_length; 863 }; 864 865 /* Values for ParameterType in struct rndis_config_parameter_info */ 866 #define RNDIS_CONFIG_PARAM_TYPE_INTEGER 0 867 #define RNDIS_CONFIG_PARAM_TYPE_STRING 2 868 869 /* CONDIS Miniport messages for connection oriented devices */ 870 /* that do not implement a call manager. */ 871 872 /* CoNdisMiniportCreateVc message */ 873 struct rcondis_mp_create_vc { 874 u32 req_id; 875 u32 ndis_vc_handle; 876 }; 877 878 /* Response to CoNdisMiniportCreateVc */ 879 struct rcondis_mp_create_vc_complete { 880 u32 req_id; 881 u32 dev_vc_handle; 882 u32 status; 883 }; 884 885 /* CoNdisMiniportDeleteVc message */ 886 struct rcondis_mp_delete_vc { 887 u32 req_id; 888 u32 dev_vc_handle; 889 }; 890 891 /* Response to CoNdisMiniportDeleteVc */ 892 struct rcondis_mp_delete_vc_complete { 893 u32 req_id; 894 u32 status; 895 }; 896 897 /* CoNdisMiniportQueryRequest message */ 898 struct rcondis_mp_query_request { 899 u32 req_id; 900 u32 request_type; 901 u32 oid; 902 u32 dev_vc_handle; 903 u32 info_buflen; 904 u32 info_buf_offset; 905 }; 906 907 /* CoNdisMiniportSetRequest message */ 908 struct rcondis_mp_set_request { 909 u32 req_id; 910 u32 request_type; 911 u32 oid; 912 u32 dev_vc_handle; 913 u32 info_buflen; 914 u32 info_buf_offset; 915 }; 916 917 /* CoNdisIndicateStatus message */ 918 struct rcondis_indicate_status { 919 u32 ndis_vc_handle; 920 u32 status; 921 u32 status_buflen; 922 u32 status_buf_offset; 923 }; 924 925 /* CONDIS Call/VC parameters */ 926 struct rcondis_specific_parameters { 927 u32 parameter_type; 928 u32 parameter_length; 929 u32 parameter_lffset; 930 }; 931 932 struct rcondis_media_parameters { 933 u32 flags; 934 u32 reserved1; 935 u32 reserved2; 936 struct rcondis_specific_parameters media_specific; 937 }; 938 939 struct rndis_flowspec { 940 u32 token_rate; 941 u32 token_bucket_size; 942 u32 peak_bandwidth; 943 u32 latency; 944 u32 delay_variation; 945 u32 service_type; 946 u32 max_sdu_size; 947 u32 minimum_policed_size; 948 }; 949 950 struct rcondis_call_manager_parameters { 951 struct rndis_flowspec transmit; 952 struct rndis_flowspec receive; 953 struct rcondis_specific_parameters call_mgr_specific; 954 }; 955 956 /* CoNdisMiniportActivateVc message */ 957 struct rcondis_mp_activate_vc_request { 958 u32 req_id; 959 u32 flags; 960 u32 dev_vc_handle; 961 u32 media_params_offset; 962 u32 media_params_length; 963 u32 call_mgr_params_offset; 964 u32 call_mgr_params_length; 965 }; 966 967 /* Response to CoNdisMiniportActivateVc */ 968 struct rcondis_mp_activate_vc_complete { 969 u32 req_id; 970 u32 status; 971 }; 972 973 /* CoNdisMiniportDeactivateVc message */ 974 struct rcondis_mp_deactivate_vc_request { 975 u32 req_id; 976 u32 flags; 977 u32 dev_vc_handle; 978 }; 979 980 /* Response to CoNdisMiniportDeactivateVc */ 981 struct rcondis_mp_deactivate_vc_complete { 982 u32 req_id; 983 u32 status; 984 }; 985 986 987 /* union with all of the RNDIS messages */ 988 union rndis_message_container { 989 struct rndis_packet pkt; 990 struct rndis_initialize_request init_req; 991 struct rndis_halt_request halt_req; 992 struct rndis_query_request query_req; 993 struct rndis_set_request set_req; 994 struct rndis_reset_request reset_req; 995 struct rndis_keepalive_request keep_alive_req; 996 struct rndis_indicate_status indicate_status; 997 struct rndis_initialize_complete init_complete; 998 struct rndis_query_complete query_complete; 999 struct rndis_set_complete set_complete; 1000 struct rndis_reset_complete reset_complete; 1001 struct rndis_keepalive_complete keep_alive_complete; 1002 struct rcondis_mp_create_vc co_miniport_create_vc; 1003 struct rcondis_mp_delete_vc co_miniport_delete_vc; 1004 struct rcondis_indicate_status co_indicate_status; 1005 struct rcondis_mp_activate_vc_request co_miniport_activate_vc; 1006 struct rcondis_mp_deactivate_vc_request co_miniport_deactivate_vc; 1007 struct rcondis_mp_create_vc_complete co_miniport_create_vc_complete; 1008 struct rcondis_mp_delete_vc_complete co_miniport_delete_vc_complete; 1009 struct rcondis_mp_activate_vc_complete co_miniport_activate_vc_complete; 1010 struct rcondis_mp_deactivate_vc_complete 1011 co_miniport_deactivate_vc_complete; 1012 }; 1013 1014 /* Remote NDIS message format */ 1015 struct rndis_message { 1016 u32 ndis_msg_type; 1017 1018 /* Total length of this message, from the beginning */ 1019 /* of the sruct rndis_message, in bytes. */ 1020 u32 msg_len; 1021 1022 /* Actual message */ 1023 union rndis_message_container msg; 1024 }; 1025 1026 1027 /* Handy macros */ 1028 1029 /* get the size of an RNDIS message. Pass in the message type, */ 1030 /* struct rndis_set_request, struct rndis_packet for example */ 1031 #define RNDIS_MESSAGE_SIZE(msg) \ 1032 (sizeof(msg) + (sizeof(struct rndis_message) - \ 1033 sizeof(union rndis_message_container))) 1034 1035 /* get pointer to info buffer with message pointer */ 1036 #define MESSAGE_TO_INFO_BUFFER(msg) \ 1037 (((unsigned char *)(msg)) + msg->info_buf_offset) 1038 1039 /* get pointer to status buffer with message pointer */ 1040 #define MESSAGE_TO_STATUS_BUFFER(msg) \ 1041 (((unsigned char *)(msg)) + msg->status_buf_offset) 1042 1043 /* get pointer to OOBD buffer with message pointer */ 1044 #define MESSAGE_TO_OOBD_BUFFER(msg) \ 1045 (((unsigned char *)(msg)) + msg->oob_data_offset) 1046 1047 /* get pointer to data buffer with message pointer */ 1048 #define MESSAGE_TO_DATA_BUFFER(msg) \ 1049 (((unsigned char *)(msg)) + msg->per_pkt_info_offset) 1050 1051 /* get pointer to contained message from NDIS_MESSAGE pointer */ 1052 #define RNDIS_MESSAGE_PTR_TO_MESSAGE_PTR(rndis_msg) \ 1053 ((void *) &rndis_msg->msg) 1054 1055 /* get pointer to contained message from NDIS_MESSAGE pointer */ 1056 #define RNDIS_MESSAGE_RAW_PTR_TO_MESSAGE_PTR(rndis_msg) \ 1057 ((void *) rndis_msg) 1058 1059 1060 #define __struct_bcount(x) 1061 1062 1063 1064 #define RNDIS_HEADER_SIZE (sizeof(struct rndis_message) - \ 1065 sizeof(union rndis_message_container)) 1066 1067 #define NDIS_PACKET_TYPE_DIRECTED 0x00000001 1068 #define NDIS_PACKET_TYPE_MULTICAST 0x00000002 1069 #define NDIS_PACKET_TYPE_ALL_MULTICAST 0x00000004 1070 #define NDIS_PACKET_TYPE_BROADCAST 0x00000008 1071 #define NDIS_PACKET_TYPE_SOURCE_ROUTING 0x00000010 1072 #define NDIS_PACKET_TYPE_PROMISCUOUS 0x00000020 1073 #define NDIS_PACKET_TYPE_SMT 0x00000040 1074 #define NDIS_PACKET_TYPE_ALL_LOCAL 0x00000080 1075 #define NDIS_PACKET_TYPE_GROUP 0x00000100 1076 #define NDIS_PACKET_TYPE_ALL_FUNCTIONAL 0x00000200 1077 #define NDIS_PACKET_TYPE_FUNCTIONAL 0x00000400 1078 #define NDIS_PACKET_TYPE_MAC_FRAME 0x00000800 1079 1080 #define INFO_IPV4 2 1081 #define INFO_IPV6 4 1082 #define INFO_TCP 2 1083 #define INFO_UDP 4 1084 1085 #define TRANSPORT_INFO_NOT_IP 0 1086 #define TRANSPORT_INFO_IPV4_TCP ((INFO_IPV4 << 16) | INFO_TCP) 1087 #define TRANSPORT_INFO_IPV4_UDP ((INFO_IPV4 << 16) | INFO_UDP) 1088 #define TRANSPORT_INFO_IPV6_TCP ((INFO_IPV6 << 16) | INFO_TCP) 1089 #define TRANSPORT_INFO_IPV6_UDP ((INFO_IPV6 << 16) | INFO_UDP) 1090 1091 1092 #endif /* _HYPERV_NET_H */ 1093