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, write to the Free Software Foundation, Inc., 59 Temple 16 * Place - Suite 330, Boston, MA 02111-1307 USA. 17 * 18 * Authors: 19 * Haiyang Zhang <haiyangz@microsoft.com> 20 * Hank Janssen <hjanssen@microsoft.com> 21 * K. Y. Srinivasan <kys@microsoft.com> 22 * 23 */ 24 25 #ifndef _HYPERV_NET_H 26 #define _HYPERV_NET_H 27 28 #include <linux/list.h> 29 #include <linux/hyperv.h> 30 #include <linux/rndis.h> 31 32 /* Fwd declaration */ 33 struct hv_netvsc_packet; 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 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 51 struct hv_device *device; 52 bool is_data_pkt; 53 u16 vlan_tci; 54 55 /* 56 * Valid only for receives when we break a xfer page packet 57 * into multiple netvsc packets 58 */ 59 struct xferpage_packet *xfer_page_pkt; 60 61 union { 62 struct { 63 u64 recv_completion_tid; 64 void *recv_completion_ctx; 65 void (*recv_completion)(void *context); 66 } recv; 67 struct { 68 u64 send_completion_tid; 69 void *send_completion_ctx; 70 void (*send_completion)(void *context); 71 } send; 72 } completion; 73 74 /* This points to the memory after page_buf */ 75 void *extension; 76 77 u32 total_data_buflen; 78 /* Points to the send/receive buffer where the ethernet frame is */ 79 void *data; 80 u32 page_buf_cnt; 81 struct hv_page_buffer page_buf[0]; 82 }; 83 84 struct netvsc_device_info { 85 unsigned char mac_adr[6]; 86 bool link_state; /* 0 - link up, 1 - link down */ 87 int ring_size; 88 }; 89 90 enum rndis_device_state { 91 RNDIS_DEV_UNINITIALIZED = 0, 92 RNDIS_DEV_INITIALIZING, 93 RNDIS_DEV_INITIALIZED, 94 RNDIS_DEV_DATAINITIALIZED, 95 }; 96 97 struct rndis_device { 98 struct netvsc_device *net_dev; 99 100 enum rndis_device_state state; 101 bool link_state; 102 atomic_t new_req_id; 103 104 spinlock_t request_lock; 105 struct list_head req_list; 106 107 unsigned char hw_mac_adr[ETH_ALEN]; 108 }; 109 110 111 /* Interface */ 112 int netvsc_device_add(struct hv_device *device, void *additional_info); 113 int netvsc_device_remove(struct hv_device *device); 114 int netvsc_send(struct hv_device *device, 115 struct hv_netvsc_packet *packet); 116 void netvsc_linkstatus_callback(struct hv_device *device_obj, 117 unsigned int status); 118 int netvsc_recv_callback(struct hv_device *device_obj, 119 struct hv_netvsc_packet *packet); 120 int rndis_filter_open(struct hv_device *dev); 121 int rndis_filter_close(struct hv_device *dev); 122 int rndis_filter_device_add(struct hv_device *dev, 123 void *additional_info); 124 void rndis_filter_device_remove(struct hv_device *dev); 125 int rndis_filter_receive(struct hv_device *dev, 126 struct hv_netvsc_packet *pkt); 127 128 129 130 int rndis_filter_send(struct hv_device *dev, 131 struct hv_netvsc_packet *pkt); 132 133 int rndis_filter_set_packet_filter(struct rndis_device *dev, u32 new_filter); 134 135 136 #define NVSP_INVALID_PROTOCOL_VERSION ((u32)0xFFFFFFFF) 137 138 #define NVSP_PROTOCOL_VERSION_1 2 139 #define NVSP_PROTOCOL_VERSION_2 0x30002 140 141 enum { 142 NVSP_MSG_TYPE_NONE = 0, 143 144 /* Init Messages */ 145 NVSP_MSG_TYPE_INIT = 1, 146 NVSP_MSG_TYPE_INIT_COMPLETE = 2, 147 148 NVSP_VERSION_MSG_START = 100, 149 150 /* Version 1 Messages */ 151 NVSP_MSG1_TYPE_SEND_NDIS_VER = NVSP_VERSION_MSG_START, 152 153 NVSP_MSG1_TYPE_SEND_RECV_BUF, 154 NVSP_MSG1_TYPE_SEND_RECV_BUF_COMPLETE, 155 NVSP_MSG1_TYPE_REVOKE_RECV_BUF, 156 157 NVSP_MSG1_TYPE_SEND_SEND_BUF, 158 NVSP_MSG1_TYPE_SEND_SEND_BUF_COMPLETE, 159 NVSP_MSG1_TYPE_REVOKE_SEND_BUF, 160 161 NVSP_MSG1_TYPE_SEND_RNDIS_PKT, 162 NVSP_MSG1_TYPE_SEND_RNDIS_PKT_COMPLETE, 163 164 /* Version 2 messages */ 165 NVSP_MSG2_TYPE_SEND_CHIMNEY_DELEGATED_BUF, 166 NVSP_MSG2_TYPE_SEND_CHIMNEY_DELEGATED_BUF_COMP, 167 NVSP_MSG2_TYPE_REVOKE_CHIMNEY_DELEGATED_BUF, 168 169 NVSP_MSG2_TYPE_RESUME_CHIMNEY_RX_INDICATION, 170 171 NVSP_MSG2_TYPE_TERMINATE_CHIMNEY, 172 NVSP_MSG2_TYPE_TERMINATE_CHIMNEY_COMP, 173 174 NVSP_MSG2_TYPE_INDICATE_CHIMNEY_EVENT, 175 176 NVSP_MSG2_TYPE_SEND_CHIMNEY_PKT, 177 NVSP_MSG2_TYPE_SEND_CHIMNEY_PKT_COMP, 178 179 NVSP_MSG2_TYPE_POST_CHIMNEY_RECV_REQ, 180 NVSP_MSG2_TYPE_POST_CHIMNEY_RECV_REQ_COMP, 181 182 NVSP_MSG2_TYPE_ALLOC_RXBUF, 183 NVSP_MSG2_TYPE_ALLOC_RXBUF_COMP, 184 185 NVSP_MSG2_TYPE_FREE_RXBUF, 186 187 NVSP_MSG2_TYPE_SEND_VMQ_RNDIS_PKT, 188 NVSP_MSG2_TYPE_SEND_VMQ_RNDIS_PKT_COMP, 189 190 NVSP_MSG2_TYPE_SEND_NDIS_CONFIG, 191 192 NVSP_MSG2_TYPE_ALLOC_CHIMNEY_HANDLE, 193 NVSP_MSG2_TYPE_ALLOC_CHIMNEY_HANDLE_COMP, 194 }; 195 196 enum { 197 NVSP_STAT_NONE = 0, 198 NVSP_STAT_SUCCESS, 199 NVSP_STAT_FAIL, 200 NVSP_STAT_PROTOCOL_TOO_NEW, 201 NVSP_STAT_PROTOCOL_TOO_OLD, 202 NVSP_STAT_INVALID_RNDIS_PKT, 203 NVSP_STAT_BUSY, 204 NVSP_STAT_PROTOCOL_UNSUPPORTED, 205 NVSP_STAT_MAX, 206 }; 207 208 struct nvsp_message_header { 209 u32 msg_type; 210 }; 211 212 /* Init Messages */ 213 214 /* 215 * This message is used by the VSC to initialize the channel after the channels 216 * has been opened. This message should never include anything other then 217 * versioning (i.e. this message will be the same for ever). 218 */ 219 struct nvsp_message_init { 220 u32 min_protocol_ver; 221 u32 max_protocol_ver; 222 } __packed; 223 224 /* 225 * This message is used by the VSP to complete the initialization of the 226 * channel. This message should never include anything other then versioning 227 * (i.e. this message will be the same for ever). 228 */ 229 struct nvsp_message_init_complete { 230 u32 negotiated_protocol_ver; 231 u32 max_mdl_chain_len; 232 u32 status; 233 } __packed; 234 235 union nvsp_message_init_uber { 236 struct nvsp_message_init init; 237 struct nvsp_message_init_complete init_complete; 238 } __packed; 239 240 /* Version 1 Messages */ 241 242 /* 243 * This message is used by the VSC to send the NDIS version to the VSP. The VSP 244 * can use this information when handling OIDs sent by the VSC. 245 */ 246 struct nvsp_1_message_send_ndis_version { 247 u32 ndis_major_ver; 248 u32 ndis_minor_ver; 249 } __packed; 250 251 /* 252 * This message is used by the VSC to send a receive buffer to the VSP. The VSP 253 * can then use the receive buffer to send data to the VSC. 254 */ 255 struct nvsp_1_message_send_receive_buffer { 256 u32 gpadl_handle; 257 u16 id; 258 } __packed; 259 260 struct nvsp_1_receive_buffer_section { 261 u32 offset; 262 u32 sub_alloc_size; 263 u32 num_sub_allocs; 264 u32 end_offset; 265 } __packed; 266 267 /* 268 * This message is used by the VSP to acknowledge a receive buffer send by the 269 * VSC. This message must be sent by the VSP before the VSP uses the receive 270 * buffer. 271 */ 272 struct nvsp_1_message_send_receive_buffer_complete { 273 u32 status; 274 u32 num_sections; 275 276 /* 277 * The receive buffer is split into two parts, a large suballocation 278 * section and a small suballocation section. These sections are then 279 * suballocated by a certain size. 280 */ 281 282 /* 283 * For example, the following break up of the receive buffer has 6 284 * large suballocations and 10 small suballocations. 285 */ 286 287 /* 288 * | Large Section | | Small Section | 289 * ------------------------------------------------------------ 290 * | | | | | | | | | | | | | | | | | | 291 * | | 292 * LargeOffset SmallOffset 293 */ 294 295 struct nvsp_1_receive_buffer_section sections[1]; 296 } __packed; 297 298 /* 299 * This message is sent by the VSC to revoke the receive buffer. After the VSP 300 * completes this transaction, the vsp should never use the receive buffer 301 * again. 302 */ 303 struct nvsp_1_message_revoke_receive_buffer { 304 u16 id; 305 }; 306 307 /* 308 * This message is used by the VSC to send a send buffer to the VSP. The VSC 309 * can then use the send buffer to send data to the VSP. 310 */ 311 struct nvsp_1_message_send_send_buffer { 312 u32 gpadl_handle; 313 u16 id; 314 } __packed; 315 316 /* 317 * This message is used by the VSP to acknowledge a send buffer sent by the 318 * VSC. This message must be sent by the VSP before the VSP uses the sent 319 * buffer. 320 */ 321 struct nvsp_1_message_send_send_buffer_complete { 322 u32 status; 323 324 /* 325 * The VSC gets to choose the size of the send buffer and the VSP gets 326 * to choose the sections size of the buffer. This was done to enable 327 * dynamic reconfigurations when the cost of GPA-direct buffers 328 * decreases. 329 */ 330 u32 section_size; 331 } __packed; 332 333 /* 334 * This message is sent by the VSC to revoke the send buffer. After the VSP 335 * completes this transaction, the vsp should never use the send buffer again. 336 */ 337 struct nvsp_1_message_revoke_send_buffer { 338 u16 id; 339 }; 340 341 /* 342 * This message is used by both the VSP and the VSC to send a RNDIS message to 343 * the opposite channel endpoint. 344 */ 345 struct nvsp_1_message_send_rndis_packet { 346 /* 347 * This field is specified by RNIDS. They assume there's two different 348 * channels of communication. However, the Network VSP only has one. 349 * Therefore, the channel travels with the RNDIS packet. 350 */ 351 u32 channel_type; 352 353 /* 354 * This field is used to send part or all of the data through a send 355 * buffer. This values specifies an index into the send buffer. If the 356 * index is 0xFFFFFFFF, then the send buffer is not being used and all 357 * of the data was sent through other VMBus mechanisms. 358 */ 359 u32 send_buf_section_index; 360 u32 send_buf_section_size; 361 } __packed; 362 363 /* 364 * This message is used by both the VSP and the VSC to complete a RNDIS message 365 * to the opposite channel endpoint. At this point, the initiator of this 366 * message cannot use any resources associated with the original RNDIS packet. 367 */ 368 struct nvsp_1_message_send_rndis_packet_complete { 369 u32 status; 370 }; 371 372 union nvsp_1_message_uber { 373 struct nvsp_1_message_send_ndis_version send_ndis_ver; 374 375 struct nvsp_1_message_send_receive_buffer send_recv_buf; 376 struct nvsp_1_message_send_receive_buffer_complete 377 send_recv_buf_complete; 378 struct nvsp_1_message_revoke_receive_buffer revoke_recv_buf; 379 380 struct nvsp_1_message_send_send_buffer send_send_buf; 381 struct nvsp_1_message_send_send_buffer_complete send_send_buf_complete; 382 struct nvsp_1_message_revoke_send_buffer revoke_send_buf; 383 384 struct nvsp_1_message_send_rndis_packet send_rndis_pkt; 385 struct nvsp_1_message_send_rndis_packet_complete 386 send_rndis_pkt_complete; 387 } __packed; 388 389 390 /* 391 * Network VSP protocol version 2 messages: 392 */ 393 struct nvsp_2_vsc_capability { 394 union { 395 u64 data; 396 struct { 397 u64 vmq:1; 398 u64 chimney:1; 399 u64 sriov:1; 400 u64 ieee8021q:1; 401 u64 correlation_id:1; 402 }; 403 }; 404 } __packed; 405 406 struct nvsp_2_send_ndis_config { 407 u32 mtu; 408 u32 reserved; 409 struct nvsp_2_vsc_capability capability; 410 } __packed; 411 412 /* Allocate receive buffer */ 413 struct nvsp_2_alloc_rxbuf { 414 /* Allocation ID to match the allocation request and response */ 415 u32 alloc_id; 416 417 /* Length of the VM shared memory receive buffer that needs to 418 * be allocated 419 */ 420 u32 len; 421 } __packed; 422 423 /* Allocate receive buffer complete */ 424 struct nvsp_2_alloc_rxbuf_comp { 425 /* The NDIS_STATUS code for buffer allocation */ 426 u32 status; 427 428 u32 alloc_id; 429 430 /* GPADL handle for the allocated receive buffer */ 431 u32 gpadl_handle; 432 433 /* Receive buffer ID */ 434 u64 recv_buf_id; 435 } __packed; 436 437 struct nvsp_2_free_rxbuf { 438 u64 recv_buf_id; 439 } __packed; 440 441 union nvsp_2_message_uber { 442 struct nvsp_2_send_ndis_config send_ndis_config; 443 struct nvsp_2_alloc_rxbuf alloc_rxbuf; 444 struct nvsp_2_alloc_rxbuf_comp alloc_rxbuf_comp; 445 struct nvsp_2_free_rxbuf free_rxbuf; 446 } __packed; 447 448 union nvsp_all_messages { 449 union nvsp_message_init_uber init_msg; 450 union nvsp_1_message_uber v1_msg; 451 union nvsp_2_message_uber v2_msg; 452 } __packed; 453 454 /* ALL Messages */ 455 struct nvsp_message { 456 struct nvsp_message_header hdr; 457 union nvsp_all_messages msg; 458 } __packed; 459 460 461 #define NETVSC_MTU 65536 462 463 #define NETVSC_RECEIVE_BUFFER_SIZE (1024*1024*2) /* 2MB */ 464 465 #define NETVSC_RECEIVE_BUFFER_ID 0xcafe 466 467 #define NETVSC_RECEIVE_SG_COUNT 1 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