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 bool start_remove; 482 bool destroy; 483 /* 484 * List of free preallocated hv_netvsc_packet to represent receive 485 * packet 486 */ 487 struct list_head recv_pkt_list; 488 spinlock_t recv_pkt_list_lock; 489 490 /* Receive buffer allocated by us but manages by NetVSP */ 491 void *recv_buf; 492 u32 recv_buf_size; 493 u32 recv_buf_gpadl_handle; 494 u32 recv_section_cnt; 495 struct nvsp_1_receive_buffer_section *recv_section; 496 497 /* Used for NetVSP initialization protocol */ 498 struct completion channel_init_wait; 499 struct nvsp_message channel_init_pkt; 500 501 struct nvsp_message revoke_packet; 502 /* unsigned char HwMacAddr[HW_MACADDR_LEN]; */ 503 504 struct net_device *ndev; 505 506 /* Holds rndis device info */ 507 void *extension; 508 }; 509 510 /* NdisInitialize message */ 511 struct rndis_initialize_request { 512 u32 req_id; 513 u32 major_ver; 514 u32 minor_ver; 515 u32 max_xfer_size; 516 }; 517 518 /* Response to NdisInitialize */ 519 struct rndis_initialize_complete { 520 u32 req_id; 521 u32 status; 522 u32 major_ver; 523 u32 minor_ver; 524 u32 dev_flags; 525 u32 medium; 526 u32 max_pkt_per_msg; 527 u32 max_xfer_size; 528 u32 pkt_alignment_factor; 529 u32 af_list_offset; 530 u32 af_list_size; 531 }; 532 533 /* Call manager devices only: Information about an address family */ 534 /* supported by the device is appended to the response to NdisInitialize. */ 535 struct rndis_co_address_family { 536 u32 address_family; 537 u32 major_ver; 538 u32 minor_ver; 539 }; 540 541 /* NdisHalt message */ 542 struct rndis_halt_request { 543 u32 req_id; 544 }; 545 546 /* NdisQueryRequest message */ 547 struct rndis_query_request { 548 u32 req_id; 549 u32 oid; 550 u32 info_buflen; 551 u32 info_buf_offset; 552 u32 dev_vc_handle; 553 }; 554 555 /* Response to NdisQueryRequest */ 556 struct rndis_query_complete { 557 u32 req_id; 558 u32 status; 559 u32 info_buflen; 560 u32 info_buf_offset; 561 }; 562 563 /* NdisSetRequest message */ 564 struct rndis_set_request { 565 u32 req_id; 566 u32 oid; 567 u32 info_buflen; 568 u32 info_buf_offset; 569 u32 dev_vc_handle; 570 }; 571 572 /* Response to NdisSetRequest */ 573 struct rndis_set_complete { 574 u32 req_id; 575 u32 status; 576 }; 577 578 /* NdisReset message */ 579 struct rndis_reset_request { 580 u32 reserved; 581 }; 582 583 /* Response to NdisReset */ 584 struct rndis_reset_complete { 585 u32 status; 586 u32 addressing_reset; 587 }; 588 589 /* NdisMIndicateStatus message */ 590 struct rndis_indicate_status { 591 u32 status; 592 u32 status_buflen; 593 u32 status_buf_offset; 594 }; 595 596 /* Diagnostic information passed as the status buffer in */ 597 /* struct rndis_indicate_status messages signifying error conditions. */ 598 struct rndis_diagnostic_info { 599 u32 diag_status; 600 u32 error_offset; 601 }; 602 603 /* NdisKeepAlive message */ 604 struct rndis_keepalive_request { 605 u32 req_id; 606 }; 607 608 /* Response to NdisKeepAlive */ 609 struct rndis_keepalive_complete { 610 u32 req_id; 611 u32 status; 612 }; 613 614 /* 615 * Data message. All Offset fields contain byte offsets from the beginning of 616 * struct rndis_packet. All Length fields are in bytes. VcHandle is set 617 * to 0 for connectionless data, otherwise it contains the VC handle. 618 */ 619 struct rndis_packet { 620 u32 data_offset; 621 u32 data_len; 622 u32 oob_data_offset; 623 u32 oob_data_len; 624 u32 num_oob_data_elements; 625 u32 per_pkt_info_offset; 626 u32 per_pkt_info_len; 627 u32 vc_handle; 628 u32 reserved; 629 }; 630 631 /* Optional Out of Band data associated with a Data message. */ 632 struct rndis_oobd { 633 u32 size; 634 u32 type; 635 u32 class_info_offset; 636 }; 637 638 /* Packet extension field contents associated with a Data message. */ 639 struct rndis_per_packet_info { 640 u32 size; 641 u32 type; 642 u32 ppi_offset; 643 }; 644 645 enum ndis_per_pkt_info_type { 646 TCPIP_CHKSUM_PKTINFO, 647 IPSEC_PKTINFO, 648 TCP_LARGESEND_PKTINFO, 649 CLASSIFICATION_HANDLE_PKTINFO, 650 NDIS_RESERVED, 651 SG_LIST_PKTINFO, 652 IEEE_8021Q_INFO, 653 ORIGINAL_PKTINFO, 654 PACKET_CANCEL_ID, 655 ORIGINAL_NET_BUFLIST, 656 CACHED_NET_BUFLIST, 657 SHORT_PKT_PADINFO, 658 MAX_PER_PKT_INFO 659 }; 660 661 struct ndis_pkt_8021q_info { 662 union { 663 struct { 664 u32 pri:3; /* User Priority */ 665 u32 cfi:1; /* Canonical Format ID */ 666 u32 vlanid:12; /* VLAN ID */ 667 u32 reserved:16; 668 }; 669 u32 value; 670 }; 671 }; 672 673 #define NDIS_VLAN_PPI_SIZE (sizeof(struct rndis_per_packet_info) + \ 674 sizeof(struct ndis_pkt_8021q_info)) 675 676 /* Format of Information buffer passed in a SetRequest for the OID */ 677 /* OID_GEN_RNDIS_CONFIG_PARAMETER. */ 678 struct rndis_config_parameter_info { 679 u32 parameter_name_offset; 680 u32 parameter_name_length; 681 u32 parameter_type; 682 u32 parameter_value_offset; 683 u32 parameter_value_length; 684 }; 685 686 /* Values for ParameterType in struct rndis_config_parameter_info */ 687 #define RNDIS_CONFIG_PARAM_TYPE_INTEGER 0 688 #define RNDIS_CONFIG_PARAM_TYPE_STRING 2 689 690 /* CONDIS Miniport messages for connection oriented devices */ 691 /* that do not implement a call manager. */ 692 693 /* CoNdisMiniportCreateVc message */ 694 struct rcondis_mp_create_vc { 695 u32 req_id; 696 u32 ndis_vc_handle; 697 }; 698 699 /* Response to CoNdisMiniportCreateVc */ 700 struct rcondis_mp_create_vc_complete { 701 u32 req_id; 702 u32 dev_vc_handle; 703 u32 status; 704 }; 705 706 /* CoNdisMiniportDeleteVc message */ 707 struct rcondis_mp_delete_vc { 708 u32 req_id; 709 u32 dev_vc_handle; 710 }; 711 712 /* Response to CoNdisMiniportDeleteVc */ 713 struct rcondis_mp_delete_vc_complete { 714 u32 req_id; 715 u32 status; 716 }; 717 718 /* CoNdisMiniportQueryRequest message */ 719 struct rcondis_mp_query_request { 720 u32 req_id; 721 u32 request_type; 722 u32 oid; 723 u32 dev_vc_handle; 724 u32 info_buflen; 725 u32 info_buf_offset; 726 }; 727 728 /* CoNdisMiniportSetRequest message */ 729 struct rcondis_mp_set_request { 730 u32 req_id; 731 u32 request_type; 732 u32 oid; 733 u32 dev_vc_handle; 734 u32 info_buflen; 735 u32 info_buf_offset; 736 }; 737 738 /* CoNdisIndicateStatus message */ 739 struct rcondis_indicate_status { 740 u32 ndis_vc_handle; 741 u32 status; 742 u32 status_buflen; 743 u32 status_buf_offset; 744 }; 745 746 /* CONDIS Call/VC parameters */ 747 struct rcondis_specific_parameters { 748 u32 parameter_type; 749 u32 parameter_length; 750 u32 parameter_lffset; 751 }; 752 753 struct rcondis_media_parameters { 754 u32 flags; 755 u32 reserved1; 756 u32 reserved2; 757 struct rcondis_specific_parameters media_specific; 758 }; 759 760 struct rndis_flowspec { 761 u32 token_rate; 762 u32 token_bucket_size; 763 u32 peak_bandwidth; 764 u32 latency; 765 u32 delay_variation; 766 u32 service_type; 767 u32 max_sdu_size; 768 u32 minimum_policed_size; 769 }; 770 771 struct rcondis_call_manager_parameters { 772 struct rndis_flowspec transmit; 773 struct rndis_flowspec receive; 774 struct rcondis_specific_parameters call_mgr_specific; 775 }; 776 777 /* CoNdisMiniportActivateVc message */ 778 struct rcondis_mp_activate_vc_request { 779 u32 req_id; 780 u32 flags; 781 u32 dev_vc_handle; 782 u32 media_params_offset; 783 u32 media_params_length; 784 u32 call_mgr_params_offset; 785 u32 call_mgr_params_length; 786 }; 787 788 /* Response to CoNdisMiniportActivateVc */ 789 struct rcondis_mp_activate_vc_complete { 790 u32 req_id; 791 u32 status; 792 }; 793 794 /* CoNdisMiniportDeactivateVc message */ 795 struct rcondis_mp_deactivate_vc_request { 796 u32 req_id; 797 u32 flags; 798 u32 dev_vc_handle; 799 }; 800 801 /* Response to CoNdisMiniportDeactivateVc */ 802 struct rcondis_mp_deactivate_vc_complete { 803 u32 req_id; 804 u32 status; 805 }; 806 807 808 /* union with all of the RNDIS messages */ 809 union rndis_message_container { 810 struct rndis_packet pkt; 811 struct rndis_initialize_request init_req; 812 struct rndis_halt_request halt_req; 813 struct rndis_query_request query_req; 814 struct rndis_set_request set_req; 815 struct rndis_reset_request reset_req; 816 struct rndis_keepalive_request keep_alive_req; 817 struct rndis_indicate_status indicate_status; 818 struct rndis_initialize_complete init_complete; 819 struct rndis_query_complete query_complete; 820 struct rndis_set_complete set_complete; 821 struct rndis_reset_complete reset_complete; 822 struct rndis_keepalive_complete keep_alive_complete; 823 struct rcondis_mp_create_vc co_miniport_create_vc; 824 struct rcondis_mp_delete_vc co_miniport_delete_vc; 825 struct rcondis_indicate_status co_indicate_status; 826 struct rcondis_mp_activate_vc_request co_miniport_activate_vc; 827 struct rcondis_mp_deactivate_vc_request co_miniport_deactivate_vc; 828 struct rcondis_mp_create_vc_complete co_miniport_create_vc_complete; 829 struct rcondis_mp_delete_vc_complete co_miniport_delete_vc_complete; 830 struct rcondis_mp_activate_vc_complete co_miniport_activate_vc_complete; 831 struct rcondis_mp_deactivate_vc_complete 832 co_miniport_deactivate_vc_complete; 833 }; 834 835 /* Remote NDIS message format */ 836 struct rndis_message { 837 u32 ndis_msg_type; 838 839 /* Total length of this message, from the beginning */ 840 /* of the sruct rndis_message, in bytes. */ 841 u32 msg_len; 842 843 /* Actual message */ 844 union rndis_message_container msg; 845 }; 846 847 848 struct rndis_filter_packet { 849 void *completion_ctx; 850 void (*completion)(void *context); 851 struct rndis_message msg; 852 }; 853 854 /* Handy macros */ 855 856 /* get the size of an RNDIS message. Pass in the message type, */ 857 /* struct rndis_set_request, struct rndis_packet for example */ 858 #define RNDIS_MESSAGE_SIZE(msg) \ 859 (sizeof(msg) + (sizeof(struct rndis_message) - \ 860 sizeof(union rndis_message_container))) 861 862 /* get pointer to info buffer with message pointer */ 863 #define MESSAGE_TO_INFO_BUFFER(msg) \ 864 (((unsigned char *)(msg)) + msg->info_buf_offset) 865 866 /* get pointer to status buffer with message pointer */ 867 #define MESSAGE_TO_STATUS_BUFFER(msg) \ 868 (((unsigned char *)(msg)) + msg->status_buf_offset) 869 870 /* get pointer to OOBD buffer with message pointer */ 871 #define MESSAGE_TO_OOBD_BUFFER(msg) \ 872 (((unsigned char *)(msg)) + msg->oob_data_offset) 873 874 /* get pointer to data buffer with message pointer */ 875 #define MESSAGE_TO_DATA_BUFFER(msg) \ 876 (((unsigned char *)(msg)) + msg->per_pkt_info_offset) 877 878 /* get pointer to contained message from NDIS_MESSAGE pointer */ 879 #define RNDIS_MESSAGE_PTR_TO_MESSAGE_PTR(rndis_msg) \ 880 ((void *) &rndis_msg->msg) 881 882 /* get pointer to contained message from NDIS_MESSAGE pointer */ 883 #define RNDIS_MESSAGE_RAW_PTR_TO_MESSAGE_PTR(rndis_msg) \ 884 ((void *) rndis_msg) 885 886 887 #define __struct_bcount(x) 888 889 890 891 #define RNDIS_HEADER_SIZE (sizeof(struct rndis_message) - \ 892 sizeof(union rndis_message_container)) 893 894 #define NDIS_PACKET_TYPE_DIRECTED 0x00000001 895 #define NDIS_PACKET_TYPE_MULTICAST 0x00000002 896 #define NDIS_PACKET_TYPE_ALL_MULTICAST 0x00000004 897 #define NDIS_PACKET_TYPE_BROADCAST 0x00000008 898 #define NDIS_PACKET_TYPE_SOURCE_ROUTING 0x00000010 899 #define NDIS_PACKET_TYPE_PROMISCUOUS 0x00000020 900 #define NDIS_PACKET_TYPE_SMT 0x00000040 901 #define NDIS_PACKET_TYPE_ALL_LOCAL 0x00000080 902 #define NDIS_PACKET_TYPE_GROUP 0x00000100 903 #define NDIS_PACKET_TYPE_ALL_FUNCTIONAL 0x00000200 904 #define NDIS_PACKET_TYPE_FUNCTIONAL 0x00000400 905 #define NDIS_PACKET_TYPE_MAC_FRAME 0x00000800 906 907 908 909 #endif /* _HYPERV_NET_H */ 910