drivers/staging/hv/netvsc.h

   1 /*
   2  *
   3  * Copyright (c) 2009, 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  *
  22  */
  23
  24
  25 #ifndef _NETVSC_H_
  26 #define _NETVSC_H_
  27
  28 #include <linux/list.h>
  29 #include "vmbus_packet_format.h"
  30 #include "vmbus_channel_interface.h"
  31 #include "netvsc_api.h"
  32
  33
  34 #define NVSP_INVALID_PROTOCOL_VERSION   ((u32)0xFFFFFFFF)
  35
  36 #define NVSP_PROTOCOL_VERSION_1         2
  37 #define NVSP_MIN_PROTOCOL_VERSION       NVSP_PROTOCOL_VERSION_1
  38 #define NVSP_MAX_PROTOCOL_VERSION       NVSP_PROTOCOL_VERSION_1
  39
  40 enum {
  41         NVSP_MSG_TYPE_NONE = 0,
  42
  43         /* Init Messages */
  44         NVSP_MSG_TYPE_INIT                      = 1,
  45         NVSP_MSG_TYPE_INIT_COMPLETE             = 2,
  46
  47         NVSP_VERSION_MSG_START                  = 100,
  48
  49         /* Version 1 Messages */
  50         NVSP_MSG1_TYPE_SEND_NDIS_VER            = NVSP_VERSION_MSG_START,
  51
  52         NVSP_MSG1_TYPE_SEND_RECV_BUF,
  53         NVSP_MSG1_TYPE_SEND_RECV_BUF_COMPLETE,
  54         NVSP_MSG1_TYPE_REVOKE_RECV_BUF,
  55
  56         NVSP_MSG1_TYPE_SEND_SEND_BUF,
  57         NVSP_MSG1_TYPE_SEND_SEND_BUF_COMPLETE,
  58         NVSP_MSG1_TYPE_REVOKE_SEND_BUF,
  59
  60         NVSP_MSG1_TYPE_SEND_RNDIS_PKT,
  61         NVSP_MSG1_TYPE_SEND_RNDIS_PKT_COMPLETE,
  62
  63         /*
  64          * This should be set to the number of messages for the version with
  65          * the maximum number of messages.
  66          */
  67         NVSP_NUM_MSG_PER_VERSION                = 9,
  68 };
  69
  70 enum {
  71         NVSP_STAT_NONE = 0,
  72         NVSP_STAT_SUCCESS,
  73         NVSP_STAT_FAIL,
  74         NVSP_STAT_PROTOCOL_TOO_NEW,
  75         NVSP_STAT_PROTOCOL_TOO_OLD,
  76         NVSP_STAT_INVALID_RNDIS_PKT,
  77         NVSP_STAT_BUSY,
  78         NVSP_STAT_MAX,
  79 };
  80
  81 struct nvsp_message_header {
  82         u32 msg_type;
  83 };
  84
  85 /* Init Messages */
  86
  87 /*
  88  * This message is used by the VSC to initialize the channel after the channels
  89  * has been opened. This message should never include anything other then
  90  * versioning (i.e. this message will be the same for ever).
  91  */
  92 struct nvsp_message_init {
  93         u32 min_protocol_ver;
  94         u32 max_protocol_ver;
  95 } __packed;
  96
  97 /*
  98  * This message is used by the VSP to complete the initialization of the
  99  * channel. This message should never include anything other then versioning
 100  * (i.e. this message will be the same for ever).
 101  */
 102 struct nvsp_message_init_complete {
 103         u32 negotiated_protocol_ver;
 104         u32 max_mdl_chain_len;
 105         u32 status;
 106 } __packed;
 107
 108 union nvsp_message_init_uber {
 109         struct nvsp_message_init init;
 110         struct nvsp_message_init_complete init_complete;
 111 } __packed;
 112
 113 /* Version 1 Messages */
 114
 115 /*
 116  * This message is used by the VSC to send the NDIS version to the VSP. The VSP
 117  * can use this information when handling OIDs sent by the VSC.
 118  */
 119 struct nvsp_1_message_send_ndis_version {
 120         u32 ndis_major_ver;
 121         u32 ndis_minor_ver;
 122 } __packed;
 123
 124 /*
 125  * This message is used by the VSC to send a receive buffer to the VSP. The VSP
 126  * can then use the receive buffer to send data to the VSC.
 127  */
 128 struct nvsp_1_message_send_receive_buffer {
 129         u32 gpadl_handle;
 130         u16 id;
 131 } __packed;
 132
 133 struct nvsp_1_receive_buffer_section {
 134         u32 offset;
 135         u32 sub_alloc_size;
 136         u32 num_sub_allocs;
 137         u32 end_offset;
 138 } __packed;
 139
 140 /*
 141  * This message is used by the VSP to acknowledge a receive buffer send by the
 142  * VSC. This message must be sent by the VSP before the VSP uses the receive
 143  * buffer.
 144  */
 145 struct nvsp_1_message_send_receive_buffer_complete {
 146         u32 status;
 147         u32 num_sections;
 148
 149         /*
 150          * The receive buffer is split into two parts, a large suballocation
 151          * section and a small suballocation section. These sections are then
 152          * suballocated by a certain size.
 153          */
 154
 155         /*
 156          * For example, the following break up of the receive buffer has 6
 157          * large suballocations and 10 small suballocations.
 158          */
 159
 160         /*
 161          * |            Large Section          |  |   Small Section   |
 162          * ------------------------------------------------------------
 163          * |     |     |     |     |     |     |  | | | | | | | | | | |
 164          * |                                      |
 165          *  LargeOffset                            SmallOffset
 166          */
 167
 168         struct nvsp_1_receive_buffer_section sections[1];
 169 } __packed;
 170
 171 /*
 172  * This message is sent by the VSC to revoke the receive buffer.  After the VSP
 173  * completes this transaction, the vsp should never use the receive buffer
 174  * again.
 175  */
 176 struct nvsp_1_message_revoke_receive_buffer {
 177         u16 id;
 178 };
 179
 180 /*
 181  * This message is used by the VSC to send a send buffer to the VSP. The VSC
 182  * can then use the send buffer to send data to the VSP.
 183  */
 184 struct nvsp_1_message_send_send_buffer {
 185         u32 gpadl_handle;
 186         u16 id;
 187 } __packed;
 188
 189 /*
 190  * This message is used by the VSP to acknowledge a send buffer sent by the
 191  * VSC. This message must be sent by the VSP before the VSP uses the sent
 192  * buffer.
 193  */
 194 struct nvsp_1_message_send_send_buffer_complete {
 195         u32 status;
 196
 197         /*
 198          * The VSC gets to choose the size of the send buffer and the VSP gets
 199          * to choose the sections size of the buffer.  This was done to enable
 200          * dynamic reconfigurations when the cost of GPA-direct buffers
 201          * decreases.
 202          */
 203         u32 section_size;
 204 } __packed;
 205
 206 /*
 207  * This message is sent by the VSC to revoke the send buffer.  After the VSP
 208  * completes this transaction, the vsp should never use the send buffer again.
 209  */
 210 struct nvsp_1_message_revoke_send_buffer {
 211         u16 id;
 212 };
 213
 214 /*
 215  * This message is used by both the VSP and the VSC to send a RNDIS message to
 216  * the opposite channel endpoint.
 217  */
 218 struct nvsp_1_message_send_rndis_packet {
 219         /*
 220          * This field is specified by RNIDS. They assume there's two different
 221          * channels of communication. However, the Network VSP only has one.
 222          * Therefore, the channel travels with the RNDIS packet.
 223          */
 224         u32 channel_type;
 225
 226         /*
 227          * This field is used to send part or all of the data through a send
 228          * buffer. This values specifies an index into the send buffer. If the
 229          * index is 0xFFFFFFFF, then the send buffer is not being used and all
 230          * of the data was sent through other VMBus mechanisms.
 231          */
 232         u32 send_buf_section_index;
 233         u32 send_buf_section_size;
 234 } __packed;
 235
 236 /*
 237  * This message is used by both the VSP and the VSC to complete a RNDIS message
 238  * to the opposite channel endpoint. At this point, the initiator of this
 239  * message cannot use any resources associated with the original RNDIS packet.
 240  */
 241 struct nvsp_1_message_send_rndis_packet_complete {
 242         u32 status;
 243 };
 244
 245 union nvsp_1_message_uber {
 246         struct nvsp_1_message_send_ndis_version send_ndis_ver;
 247
 248         struct nvsp_1_message_send_receive_buffer send_recv_buf;
 249         struct nvsp_1_message_send_receive_buffer_complete
 250                                                 send_recv_buf_complete;
 251         struct nvsp_1_message_revoke_receive_buffer revoke_recv_buf;
 252
 253         struct nvsp_1_message_send_send_buffer send_send_buf;
 254         struct nvsp_1_message_send_send_buffer_complete send_send_buf_complete;
 255         struct nvsp_1_message_revoke_send_buffer revoke_send_buf;
 256
 257         struct nvsp_1_message_send_rndis_packet send_rndis_pkt;
 258         struct nvsp_1_message_send_rndis_packet_complete
 259                                                 send_rndis_pkt_complete;
 260 } __packed;
 261
 262 union nvsp_all_messages {
 263         union nvsp_message_init_uber init_msg;
 264         union nvsp_1_message_uber v1_msg;
 265 } __packed;
 266
 267 /* ALL Messages */
 268 struct nvsp_message {
 269         struct nvsp_message_header hdr;
 270         union nvsp_all_messages msg;
 271 } __packed;
 272
 273
 274
 275
 276 /* #define NVSC_MIN_PROTOCOL_VERSION            1 */
 277 /* #define NVSC_MAX_PROTOCOL_VERSION            1 */
 278
 279 #define NETVSC_SEND_BUFFER_SIZE                 (64*1024)       /* 64K */
 280 #define NETVSC_SEND_BUFFER_ID                   0xface
 281
 282
 283 #define NETVSC_RECEIVE_BUFFER_SIZE              (1024*1024)     /* 1MB */
 284
 285 #define NETVSC_RECEIVE_BUFFER_ID                0xcafe
 286
 287 #define NETVSC_RECEIVE_SG_COUNT                 1
 288
 289 /* Preallocated receive packets */
 290 #define NETVSC_RECEIVE_PACKETLIST_COUNT         256
 291
 292 #define NETVSC_PACKET_SIZE                      2048
 293
 294 /* Per netvsc channel-specific */
 295 struct netvsc_device {
 296         struct hv_device *dev;
 297
 298         atomic_t refcnt;
 299         atomic_t num_outstanding_sends;
 300         /*
 301          * List of free preallocated hv_netvsc_packet to represent receive
 302          * packet
 303          */
 304         struct list_head recv_pkt_list;
 305         spinlock_t recv_pkt_list_lock;
 306
 307         /* Send buffer allocated by us but manages by NetVSP */
 308         void *send_buf;
 309         u32 send_buf_size;
 310         u32 send_buf_gpadl_handle;
 311         u32 send_section_size;
 312
 313         /* Receive buffer allocated by us but manages by NetVSP */
 314         void *recv_buf;
 315         u32 recv_buf_size;
 316         u32 recv_buf_gpadl_handle;
 317         u32 recv_section_cnt;
 318         struct nvsp_1_receive_buffer_section *recv_section;
 319
 320         /* Used for NetVSP initialization protocol */
 321         int wait_condition;
 322         wait_queue_head_t channel_init_wait;
 323         struct nvsp_message channel_init_pkt;
 324
 325         struct nvsp_message revoke_packet;
 326         /* unsigned char HwMacAddr[HW_MACADDR_LEN]; */
 327
 328         /* Holds rndis device info */
 329         void *extension;
 330 };
 331
 332 #endif /* _NETVSC_H_ */