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