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 34 /* Represent the xfer page packet which contains 1 or more netvsc packet */ 35 struct xferpage_packet { 36 struct list_head list_ent; 37 u32 status; 38 39 /* # of netvsc packets this xfer packet contains */ 40 u32 count; 41 }; 42 43 /* 44 * Represent netvsc packet which contains 1 RNDIS and 1 ethernet frame 45 * within the RNDIS 46 */ 47 struct hv_netvsc_packet { 48 /* Bookkeeping stuff */ 49 struct list_head list_ent; 50 u32 status; 51 52 struct hv_device *device; 53 bool is_data_pkt; 54 u16 vlan_tci; 55 56 /* 57 * Valid only for receives when we break a xfer page packet 58 * into multiple netvsc packets 59 */ 60 struct xferpage_packet *xfer_page_pkt; 61 62 union { 63 struct { 64 u64 recv_completion_tid; 65 void *recv_completion_ctx; 66 void (*recv_completion)(void *context); 67 } recv; 68 struct { 69 u64 send_completion_tid; 70 void *send_completion_ctx; 71 void (*send_completion)(void *context); 72 } send; 73 } completion; 74 75 /* This points to the memory after page_buf */ 76 void *extension; 77 78 u32 total_data_buflen; 79 /* Points to the send/receive buffer where the ethernet frame is */ 80 void *data; 81 u32 page_buf_cnt; 82 struct hv_page_buffer page_buf[0]; 83 }; 84 85 struct netvsc_device_info { 86 unsigned char mac_adr[ETH_ALEN]; 87 bool link_state; /* 0 - link up, 1 - link down */ 88 int ring_size; 89 }; 90 91 enum rndis_device_state { 92 RNDIS_DEV_UNINITIALIZED = 0, 93 RNDIS_DEV_INITIALIZING, 94 RNDIS_DEV_INITIALIZED, 95 RNDIS_DEV_DATAINITIALIZED, 96 }; 97 98 struct rndis_device { 99 struct netvsc_device *net_dev; 100 101 enum rndis_device_state state; 102 bool link_state; 103 atomic_t new_req_id; 104 105 spinlock_t request_lock; 106 struct list_head req_list; 107 108 unsigned char hw_mac_adr[ETH_ALEN]; 109 }; 110 111 112 /* Interface */ 113 int netvsc_device_add(struct hv_device *device, void *additional_info); 114 int netvsc_device_remove(struct hv_device *device); 115 int netvsc_send(struct hv_device *device, 116 struct hv_netvsc_packet *packet); 117 void netvsc_linkstatus_callback(struct hv_device *device_obj, 118 unsigned int status); 119 int netvsc_recv_callback(struct hv_device *device_obj, 120 struct hv_netvsc_packet *packet); 121 int rndis_filter_open(struct hv_device *dev); 122 int rndis_filter_close(struct hv_device *dev); 123 int rndis_filter_device_add(struct hv_device *dev, 124 void *additional_info); 125 void rndis_filter_device_remove(struct hv_device *dev); 126 int rndis_filter_receive(struct hv_device *dev, 127 struct hv_netvsc_packet *pkt); 128 129 130 131 int rndis_filter_send(struct hv_device *dev, 132 struct hv_netvsc_packet *pkt); 133 134 int rndis_filter_set_packet_filter(struct rndis_device *dev, u32 new_filter); 135 int rndis_filter_set_device_mac(struct hv_device *hdev, char *mac); 136 137 138 #define NVSP_INVALID_PROTOCOL_VERSION ((u32)0xFFFFFFFF) 139 140 #define NVSP_PROTOCOL_VERSION_1 2 141 #define NVSP_PROTOCOL_VERSION_2 0x30002 142 143 enum { 144 NVSP_MSG_TYPE_NONE = 0, 145 146 /* Init Messages */ 147 NVSP_MSG_TYPE_INIT = 1, 148 NVSP_MSG_TYPE_INIT_COMPLETE = 2, 149 150 NVSP_VERSION_MSG_START = 100, 151 152 /* Version 1 Messages */ 153 NVSP_MSG1_TYPE_SEND_NDIS_VER = NVSP_VERSION_MSG_START, 154 155 NVSP_MSG1_TYPE_SEND_RECV_BUF, 156 NVSP_MSG1_TYPE_SEND_RECV_BUF_COMPLETE, 157 NVSP_MSG1_TYPE_REVOKE_RECV_BUF, 158 159 NVSP_MSG1_TYPE_SEND_SEND_BUF, 160 NVSP_MSG1_TYPE_SEND_SEND_BUF_COMPLETE, 161 NVSP_MSG1_TYPE_REVOKE_SEND_BUF, 162 163 NVSP_MSG1_TYPE_SEND_RNDIS_PKT, 164 NVSP_MSG1_TYPE_SEND_RNDIS_PKT_COMPLETE, 165 166 /* Version 2 messages */ 167 NVSP_MSG2_TYPE_SEND_CHIMNEY_DELEGATED_BUF, 168 NVSP_MSG2_TYPE_SEND_CHIMNEY_DELEGATED_BUF_COMP, 169 NVSP_MSG2_TYPE_REVOKE_CHIMNEY_DELEGATED_BUF, 170 171 NVSP_MSG2_TYPE_RESUME_CHIMNEY_RX_INDICATION, 172 173 NVSP_MSG2_TYPE_TERMINATE_CHIMNEY, 174 NVSP_MSG2_TYPE_TERMINATE_CHIMNEY_COMP, 175 176 NVSP_MSG2_TYPE_INDICATE_CHIMNEY_EVENT, 177 178 NVSP_MSG2_TYPE_SEND_CHIMNEY_PKT, 179 NVSP_MSG2_TYPE_SEND_CHIMNEY_PKT_COMP, 180 181 NVSP_MSG2_TYPE_POST_CHIMNEY_RECV_REQ, 182 NVSP_MSG2_TYPE_POST_CHIMNEY_RECV_REQ_COMP, 183 184 NVSP_MSG2_TYPE_ALLOC_RXBUF, 185 NVSP_MSG2_TYPE_ALLOC_RXBUF_COMP, 186 187 NVSP_MSG2_TYPE_FREE_RXBUF, 188 189 NVSP_MSG2_TYPE_SEND_VMQ_RNDIS_PKT, 190 NVSP_MSG2_TYPE_SEND_VMQ_RNDIS_PKT_COMP, 191 192 NVSP_MSG2_TYPE_SEND_NDIS_CONFIG, 193 194 NVSP_MSG2_TYPE_ALLOC_CHIMNEY_HANDLE, 195 NVSP_MSG2_TYPE_ALLOC_CHIMNEY_HANDLE_COMP, 196 }; 197 198 enum { 199 NVSP_STAT_NONE = 0, 200 NVSP_STAT_SUCCESS, 201 NVSP_STAT_FAIL, 202 NVSP_STAT_PROTOCOL_TOO_NEW, 203 NVSP_STAT_PROTOCOL_TOO_OLD, 204 NVSP_STAT_INVALID_RNDIS_PKT, 205 NVSP_STAT_BUSY, 206 NVSP_STAT_PROTOCOL_UNSUPPORTED, 207 NVSP_STAT_MAX, 208 }; 209 210 struct nvsp_message_header { 211 u32 msg_type; 212 }; 213 214 /* Init Messages */ 215 216 /* 217 * This message is used by the VSC to initialize the channel after the channels 218 * has been opened. This message should never include anything other then 219 * versioning (i.e. this message will be the same for ever). 220 */ 221 struct nvsp_message_init { 222 u32 min_protocol_ver; 223 u32 max_protocol_ver; 224 } __packed; 225 226 /* 227 * This message is used by the VSP to complete the initialization of the 228 * channel. This message should never include anything other then versioning 229 * (i.e. this message will be the same for ever). 230 */ 231 struct nvsp_message_init_complete { 232 u32 negotiated_protocol_ver; 233 u32 max_mdl_chain_len; 234 u32 status; 235 } __packed; 236 237 union nvsp_message_init_uber { 238 struct nvsp_message_init init; 239 struct nvsp_message_init_complete init_complete; 240 } __packed; 241 242 /* Version 1 Messages */ 243 244 /* 245 * This message is used by the VSC to send the NDIS version to the VSP. The VSP 246 * can use this information when handling OIDs sent by the VSC. 247 */ 248 struct nvsp_1_message_send_ndis_version { 249 u32 ndis_major_ver; 250 u32 ndis_minor_ver; 251 } __packed; 252 253 /* 254 * This message is used by the VSC to send a receive buffer to the VSP. The VSP 255 * can then use the receive buffer to send data to the VSC. 256 */ 257 struct nvsp_1_message_send_receive_buffer { 258 u32 gpadl_handle; 259 u16 id; 260 } __packed; 261 262 struct nvsp_1_receive_buffer_section { 263 u32 offset; 264 u32 sub_alloc_size; 265 u32 num_sub_allocs; 266 u32 end_offset; 267 } __packed; 268 269 /* 270 * This message is used by the VSP to acknowledge a receive buffer send by the 271 * VSC. This message must be sent by the VSP before the VSP uses the receive 272 * buffer. 273 */ 274 struct nvsp_1_message_send_receive_buffer_complete { 275 u32 status; 276 u32 num_sections; 277 278 /* 279 * The receive buffer is split into two parts, a large suballocation 280 * section and a small suballocation section. These sections are then 281 * suballocated by a certain size. 282 */ 283 284 /* 285 * For example, the following break up of the receive buffer has 6 286 * large suballocations and 10 small suballocations. 287 */ 288 289 /* 290 * | Large Section | | Small Section | 291 * ------------------------------------------------------------ 292 * | | | | | | | | | | | | | | | | | | 293 * | | 294 * LargeOffset SmallOffset 295 */ 296 297 struct nvsp_1_receive_buffer_section sections[1]; 298 } __packed; 299 300 /* 301 * This message is sent by the VSC to revoke the receive buffer. After the VSP 302 * completes this transaction, the vsp should never use the receive buffer 303 * again. 304 */ 305 struct nvsp_1_message_revoke_receive_buffer { 306 u16 id; 307 }; 308 309 /* 310 * This message is used by the VSC to send a send buffer to the VSP. The VSC 311 * can then use the send buffer to send data to the VSP. 312 */ 313 struct nvsp_1_message_send_send_buffer { 314 u32 gpadl_handle; 315 u16 id; 316 } __packed; 317 318 /* 319 * This message is used by the VSP to acknowledge a send buffer sent by the 320 * VSC. This message must be sent by the VSP before the VSP uses the sent 321 * buffer. 322 */ 323 struct nvsp_1_message_send_send_buffer_complete { 324 u32 status; 325 326 /* 327 * The VSC gets to choose the size of the send buffer and the VSP gets 328 * to choose the sections size of the buffer. This was done to enable 329 * dynamic reconfigurations when the cost of GPA-direct buffers 330 * decreases. 331 */ 332 u32 section_size; 333 } __packed; 334 335 /* 336 * This message is sent by the VSC to revoke the send buffer. After the VSP 337 * completes this transaction, the vsp should never use the send buffer again. 338 */ 339 struct nvsp_1_message_revoke_send_buffer { 340 u16 id; 341 }; 342 343 /* 344 * This message is used by both the VSP and the VSC to send a RNDIS message to 345 * the opposite channel endpoint. 346 */ 347 struct nvsp_1_message_send_rndis_packet { 348 /* 349 * This field is specified by RNIDS. They assume there's two different 350 * channels of communication. However, the Network VSP only has one. 351 * Therefore, the channel travels with the RNDIS packet. 352 */ 353 u32 channel_type; 354 355 /* 356 * This field is used to send part or all of the data through a send 357 * buffer. This values specifies an index into the send buffer. If the 358 * index is 0xFFFFFFFF, then the send buffer is not being used and all 359 * of the data was sent through other VMBus mechanisms. 360 */ 361 u32 send_buf_section_index; 362 u32 send_buf_section_size; 363 } __packed; 364 365 /* 366 * This message is used by both the VSP and the VSC to complete a RNDIS message 367 * to the opposite channel endpoint. At this point, the initiator of this 368 * message cannot use any resources associated with the original RNDIS packet. 369 */ 370 struct nvsp_1_message_send_rndis_packet_complete { 371 u32 status; 372 }; 373 374 union nvsp_1_message_uber { 375 struct nvsp_1_message_send_ndis_version send_ndis_ver; 376 377 struct nvsp_1_message_send_receive_buffer send_recv_buf; 378 struct nvsp_1_message_send_receive_buffer_complete 379 send_recv_buf_complete; 380 struct nvsp_1_message_revoke_receive_buffer revoke_recv_buf; 381 382 struct nvsp_1_message_send_send_buffer send_send_buf; 383 struct nvsp_1_message_send_send_buffer_complete send_send_buf_complete; 384 struct nvsp_1_message_revoke_send_buffer revoke_send_buf; 385 386 struct nvsp_1_message_send_rndis_packet send_rndis_pkt; 387 struct nvsp_1_message_send_rndis_packet_complete 388 send_rndis_pkt_complete; 389 } __packed; 390 391 392 /* 393 * Network VSP protocol version 2 messages: 394 */ 395 struct nvsp_2_vsc_capability { 396 union { 397 u64 data; 398 struct { 399 u64 vmq:1; 400 u64 chimney:1; 401 u64 sriov:1; 402 u64 ieee8021q:1; 403 u64 correlation_id:1; 404 }; 405 }; 406 } __packed; 407 408 struct nvsp_2_send_ndis_config { 409 u32 mtu; 410 u32 reserved; 411 struct nvsp_2_vsc_capability capability; 412 } __packed; 413 414 /* Allocate receive buffer */ 415 struct nvsp_2_alloc_rxbuf { 416 /* Allocation ID to match the allocation request and response */ 417 u32 alloc_id; 418 419 /* Length of the VM shared memory receive buffer that needs to 420 * be allocated 421 */ 422 u32 len; 423 } __packed; 424 425 /* Allocate receive buffer complete */ 426 struct nvsp_2_alloc_rxbuf_comp { 427 /* The NDIS_STATUS code for buffer allocation */ 428 u32 status; 429 430 u32 alloc_id; 431 432 /* GPADL handle for the allocated receive buffer */ 433 u32 gpadl_handle; 434 435 /* Receive buffer ID */ 436 u64 recv_buf_id; 437 } __packed; 438 439 struct nvsp_2_free_rxbuf { 440 u64 recv_buf_id; 441 } __packed; 442 443 union nvsp_2_message_uber { 444 struct nvsp_2_send_ndis_config send_ndis_config; 445 struct nvsp_2_alloc_rxbuf alloc_rxbuf; 446 struct nvsp_2_alloc_rxbuf_comp alloc_rxbuf_comp; 447 struct nvsp_2_free_rxbuf free_rxbuf; 448 } __packed; 449 450 union nvsp_all_messages { 451 union nvsp_message_init_uber init_msg; 452 union nvsp_1_message_uber v1_msg; 453 union nvsp_2_message_uber v2_msg; 454 } __packed; 455 456 /* ALL Messages */ 457 struct nvsp_message { 458 struct nvsp_message_header hdr; 459 union nvsp_all_messages msg; 460 } __packed; 461 462 463 #define NETVSC_MTU 65536 464 465 #define NETVSC_RECEIVE_BUFFER_SIZE (1024*1024*16) /* 16MB */ 466 467 #define NETVSC_RECEIVE_BUFFER_ID 0xcafe 468 469 /* Preallocated receive packets */ 470 #define NETVSC_RECEIVE_PACKETLIST_COUNT 256 471 472 #define NETVSC_PACKET_SIZE 2048 473 474 /* Per netvsc channel-specific */ 475 struct netvsc_device { 476 struct hv_device *dev; 477 478 u32 nvsp_version; 479 480 atomic_t num_outstanding_sends; 481 wait_queue_head_t wait_drain; 482 bool start_remove; 483 bool destroy; 484 /* 485 * List of free preallocated hv_netvsc_packet to represent receive 486 * packet 487 */ 488 struct list_head recv_pkt_list; 489 spinlock_t recv_pkt_list_lock; 490 491 /* Receive buffer allocated by us but manages by NetVSP */ 492 void *recv_buf; 493 u32 recv_buf_size; 494 u32 recv_buf_gpadl_handle; 495 u32 recv_section_cnt; 496 struct nvsp_1_receive_buffer_section *recv_section; 497 498 /* Used for NetVSP initialization protocol */ 499 struct completion channel_init_wait; 500 struct nvsp_message channel_init_pkt; 501 502 struct nvsp_message revoke_packet; 503 /* unsigned char HwMacAddr[HW_MACADDR_LEN]; */ 504 505 struct net_device *ndev; 506 507 /* Holds rndis device info */ 508 void *extension; 509 }; 510 511 /* NdisInitialize message */ 512 struct rndis_initialize_request { 513 u32 req_id; 514 u32 major_ver; 515 u32 minor_ver; 516 u32 max_xfer_size; 517 }; 518 519 /* Response to NdisInitialize */ 520 struct rndis_initialize_complete { 521 u32 req_id; 522 u32 status; 523 u32 major_ver; 524 u32 minor_ver; 525 u32 dev_flags; 526 u32 medium; 527 u32 max_pkt_per_msg; 528 u32 max_xfer_size; 529 u32 pkt_alignment_factor; 530 u32 af_list_offset; 531 u32 af_list_size; 532 }; 533 534 /* Call manager devices only: Information about an address family */ 535 /* supported by the device is appended to the response to NdisInitialize. */ 536 struct rndis_co_address_family { 537 u32 address_family; 538 u32 major_ver; 539 u32 minor_ver; 540 }; 541 542 /* NdisHalt message */ 543 struct rndis_halt_request { 544 u32 req_id; 545 }; 546 547 /* NdisQueryRequest message */ 548 struct rndis_query_request { 549 u32 req_id; 550 u32 oid; 551 u32 info_buflen; 552 u32 info_buf_offset; 553 u32 dev_vc_handle; 554 }; 555 556 /* Response to NdisQueryRequest */ 557 struct rndis_query_complete { 558 u32 req_id; 559 u32 status; 560 u32 info_buflen; 561 u32 info_buf_offset; 562 }; 563 564 /* NdisSetRequest message */ 565 struct rndis_set_request { 566 u32 req_id; 567 u32 oid; 568 u32 info_buflen; 569 u32 info_buf_offset; 570 u32 dev_vc_handle; 571 }; 572 573 /* Response to NdisSetRequest */ 574 struct rndis_set_complete { 575 u32 req_id; 576 u32 status; 577 }; 578 579 /* NdisReset message */ 580 struct rndis_reset_request { 581 u32 reserved; 582 }; 583 584 /* Response to NdisReset */ 585 struct rndis_reset_complete { 586 u32 status; 587 u32 addressing_reset; 588 }; 589 590 /* NdisMIndicateStatus message */ 591 struct rndis_indicate_status { 592 u32 status; 593 u32 status_buflen; 594 u32 status_buf_offset; 595 }; 596 597 /* Diagnostic information passed as the status buffer in */ 598 /* struct rndis_indicate_status messages signifying error conditions. */ 599 struct rndis_diagnostic_info { 600 u32 diag_status; 601 u32 error_offset; 602 }; 603 604 /* NdisKeepAlive message */ 605 struct rndis_keepalive_request { 606 u32 req_id; 607 }; 608 609 /* Response to NdisKeepAlive */ 610 struct rndis_keepalive_complete { 611 u32 req_id; 612 u32 status; 613 }; 614 615 /* 616 * Data message. All Offset fields contain byte offsets from the beginning of 617 * struct rndis_packet. All Length fields are in bytes. VcHandle is set 618 * to 0 for connectionless data, otherwise it contains the VC handle. 619 */ 620 struct rndis_packet { 621 u32 data_offset; 622 u32 data_len; 623 u32 oob_data_offset; 624 u32 oob_data_len; 625 u32 num_oob_data_elements; 626 u32 per_pkt_info_offset; 627 u32 per_pkt_info_len; 628 u32 vc_handle; 629 u32 reserved; 630 }; 631 632 /* Optional Out of Band data associated with a Data message. */ 633 struct rndis_oobd { 634 u32 size; 635 u32 type; 636 u32 class_info_offset; 637 }; 638 639 /* Packet extension field contents associated with a Data message. */ 640 struct rndis_per_packet_info { 641 u32 size; 642 u32 type; 643 u32 ppi_offset; 644 }; 645 646 enum ndis_per_pkt_info_type { 647 TCPIP_CHKSUM_PKTINFO, 648 IPSEC_PKTINFO, 649 TCP_LARGESEND_PKTINFO, 650 CLASSIFICATION_HANDLE_PKTINFO, 651 NDIS_RESERVED, 652 SG_LIST_PKTINFO, 653 IEEE_8021Q_INFO, 654 ORIGINAL_PKTINFO, 655 PACKET_CANCEL_ID, 656 ORIGINAL_NET_BUFLIST, 657 CACHED_NET_BUFLIST, 658 SHORT_PKT_PADINFO, 659 MAX_PER_PKT_INFO 660 }; 661 662 struct ndis_pkt_8021q_info { 663 union { 664 struct { 665 u32 pri:3; /* User Priority */ 666 u32 cfi:1; /* Canonical Format ID */ 667 u32 vlanid:12; /* VLAN ID */ 668 u32 reserved:16; 669 }; 670 u32 value; 671 }; 672 }; 673 674 #define NDIS_VLAN_PPI_SIZE (sizeof(struct rndis_per_packet_info) + \ 675 sizeof(struct ndis_pkt_8021q_info)) 676 677 /* Format of Information buffer passed in a SetRequest for the OID */ 678 /* OID_GEN_RNDIS_CONFIG_PARAMETER. */ 679 struct rndis_config_parameter_info { 680 u32 parameter_name_offset; 681 u32 parameter_name_length; 682 u32 parameter_type; 683 u32 parameter_value_offset; 684 u32 parameter_value_length; 685 }; 686 687 /* Values for ParameterType in struct rndis_config_parameter_info */ 688 #define RNDIS_CONFIG_PARAM_TYPE_INTEGER 0 689 #define RNDIS_CONFIG_PARAM_TYPE_STRING 2 690 691 /* CONDIS Miniport messages for connection oriented devices */ 692 /* that do not implement a call manager. */ 693 694 /* CoNdisMiniportCreateVc message */ 695 struct rcondis_mp_create_vc { 696 u32 req_id; 697 u32 ndis_vc_handle; 698 }; 699 700 /* Response to CoNdisMiniportCreateVc */ 701 struct rcondis_mp_create_vc_complete { 702 u32 req_id; 703 u32 dev_vc_handle; 704 u32 status; 705 }; 706 707 /* CoNdisMiniportDeleteVc message */ 708 struct rcondis_mp_delete_vc { 709 u32 req_id; 710 u32 dev_vc_handle; 711 }; 712 713 /* Response to CoNdisMiniportDeleteVc */ 714 struct rcondis_mp_delete_vc_complete { 715 u32 req_id; 716 u32 status; 717 }; 718 719 /* CoNdisMiniportQueryRequest message */ 720 struct rcondis_mp_query_request { 721 u32 req_id; 722 u32 request_type; 723 u32 oid; 724 u32 dev_vc_handle; 725 u32 info_buflen; 726 u32 info_buf_offset; 727 }; 728 729 /* CoNdisMiniportSetRequest message */ 730 struct rcondis_mp_set_request { 731 u32 req_id; 732 u32 request_type; 733 u32 oid; 734 u32 dev_vc_handle; 735 u32 info_buflen; 736 u32 info_buf_offset; 737 }; 738 739 /* CoNdisIndicateStatus message */ 740 struct rcondis_indicate_status { 741 u32 ndis_vc_handle; 742 u32 status; 743 u32 status_buflen; 744 u32 status_buf_offset; 745 }; 746 747 /* CONDIS Call/VC parameters */ 748 struct rcondis_specific_parameters { 749 u32 parameter_type; 750 u32 parameter_length; 751 u32 parameter_lffset; 752 }; 753 754 struct rcondis_media_parameters { 755 u32 flags; 756 u32 reserved1; 757 u32 reserved2; 758 struct rcondis_specific_parameters media_specific; 759 }; 760 761 struct rndis_flowspec { 762 u32 token_rate; 763 u32 token_bucket_size; 764 u32 peak_bandwidth; 765 u32 latency; 766 u32 delay_variation; 767 u32 service_type; 768 u32 max_sdu_size; 769 u32 minimum_policed_size; 770 }; 771 772 struct rcondis_call_manager_parameters { 773 struct rndis_flowspec transmit; 774 struct rndis_flowspec receive; 775 struct rcondis_specific_parameters call_mgr_specific; 776 }; 777 778 /* CoNdisMiniportActivateVc message */ 779 struct rcondis_mp_activate_vc_request { 780 u32 req_id; 781 u32 flags; 782 u32 dev_vc_handle; 783 u32 media_params_offset; 784 u32 media_params_length; 785 u32 call_mgr_params_offset; 786 u32 call_mgr_params_length; 787 }; 788 789 /* Response to CoNdisMiniportActivateVc */ 790 struct rcondis_mp_activate_vc_complete { 791 u32 req_id; 792 u32 status; 793 }; 794 795 /* CoNdisMiniportDeactivateVc message */ 796 struct rcondis_mp_deactivate_vc_request { 797 u32 req_id; 798 u32 flags; 799 u32 dev_vc_handle; 800 }; 801 802 /* Response to CoNdisMiniportDeactivateVc */ 803 struct rcondis_mp_deactivate_vc_complete { 804 u32 req_id; 805 u32 status; 806 }; 807 808 809 /* union with all of the RNDIS messages */ 810 union rndis_message_container { 811 struct rndis_packet pkt; 812 struct rndis_initialize_request init_req; 813 struct rndis_halt_request halt_req; 814 struct rndis_query_request query_req; 815 struct rndis_set_request set_req; 816 struct rndis_reset_request reset_req; 817 struct rndis_keepalive_request keep_alive_req; 818 struct rndis_indicate_status indicate_status; 819 struct rndis_initialize_complete init_complete; 820 struct rndis_query_complete query_complete; 821 struct rndis_set_complete set_complete; 822 struct rndis_reset_complete reset_complete; 823 struct rndis_keepalive_complete keep_alive_complete; 824 struct rcondis_mp_create_vc co_miniport_create_vc; 825 struct rcondis_mp_delete_vc co_miniport_delete_vc; 826 struct rcondis_indicate_status co_indicate_status; 827 struct rcondis_mp_activate_vc_request co_miniport_activate_vc; 828 struct rcondis_mp_deactivate_vc_request co_miniport_deactivate_vc; 829 struct rcondis_mp_create_vc_complete co_miniport_create_vc_complete; 830 struct rcondis_mp_delete_vc_complete co_miniport_delete_vc_complete; 831 struct rcondis_mp_activate_vc_complete co_miniport_activate_vc_complete; 832 struct rcondis_mp_deactivate_vc_complete 833 co_miniport_deactivate_vc_complete; 834 }; 835 836 /* Remote NDIS message format */ 837 struct rndis_message { 838 u32 ndis_msg_type; 839 840 /* Total length of this message, from the beginning */ 841 /* of the sruct rndis_message, in bytes. */ 842 u32 msg_len; 843 844 /* Actual message */ 845 union rndis_message_container msg; 846 }; 847 848 849 struct rndis_filter_packet { 850 void *completion_ctx; 851 void (*completion)(void *context); 852 struct rndis_message msg; 853 }; 854 855 /* Handy macros */ 856 857 /* get the size of an RNDIS message. Pass in the message type, */ 858 /* struct rndis_set_request, struct rndis_packet for example */ 859 #define RNDIS_MESSAGE_SIZE(msg) \ 860 (sizeof(msg) + (sizeof(struct rndis_message) - \ 861 sizeof(union rndis_message_container))) 862 863 /* get pointer to info buffer with message pointer */ 864 #define MESSAGE_TO_INFO_BUFFER(msg) \ 865 (((unsigned char *)(msg)) + msg->info_buf_offset) 866 867 /* get pointer to status buffer with message pointer */ 868 #define MESSAGE_TO_STATUS_BUFFER(msg) \ 869 (((unsigned char *)(msg)) + msg->status_buf_offset) 870 871 /* get pointer to OOBD buffer with message pointer */ 872 #define MESSAGE_TO_OOBD_BUFFER(msg) \ 873 (((unsigned char *)(msg)) + msg->oob_data_offset) 874 875 /* get pointer to data buffer with message pointer */ 876 #define MESSAGE_TO_DATA_BUFFER(msg) \ 877 (((unsigned char *)(msg)) + msg->per_pkt_info_offset) 878 879 /* get pointer to contained message from NDIS_MESSAGE pointer */ 880 #define RNDIS_MESSAGE_PTR_TO_MESSAGE_PTR(rndis_msg) \ 881 ((void *) &rndis_msg->msg) 882 883 /* get pointer to contained message from NDIS_MESSAGE pointer */ 884 #define RNDIS_MESSAGE_RAW_PTR_TO_MESSAGE_PTR(rndis_msg) \ 885 ((void *) rndis_msg) 886 887 888 #define __struct_bcount(x) 889 890 891 892 #define RNDIS_HEADER_SIZE (sizeof(struct rndis_message) - \ 893 sizeof(union rndis_message_container)) 894 895 #define NDIS_PACKET_TYPE_DIRECTED 0x00000001 896 #define NDIS_PACKET_TYPE_MULTICAST 0x00000002 897 #define NDIS_PACKET_TYPE_ALL_MULTICAST 0x00000004 898 #define NDIS_PACKET_TYPE_BROADCAST 0x00000008 899 #define NDIS_PACKET_TYPE_SOURCE_ROUTING 0x00000010 900 #define NDIS_PACKET_TYPE_PROMISCUOUS 0x00000020 901 #define NDIS_PACKET_TYPE_SMT 0x00000040 902 #define NDIS_PACKET_TYPE_ALL_LOCAL 0x00000080 903 #define NDIS_PACKET_TYPE_GROUP 0x00000100 904 #define NDIS_PACKET_TYPE_ALL_FUNCTIONAL 0x00000200 905 #define NDIS_PACKET_TYPE_FUNCTIONAL 0x00000400 906 #define NDIS_PACKET_TYPE_MAC_FRAME 0x00000800 907 908 909 910 #endif /* _HYPERV_NET_H */ 911