blob: 1cd77483da50114c2c309ab70a69dff134c3a919 [file] [log] [blame]
Hank Janssenfceaf242009-07-13 15:34:54 -07001/*
Hank Janssenfceaf242009-07-13 15:34:54 -07002 * Copyright (c) 2009, Microsoft Corporation.
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms and conditions of the GNU General Public License,
6 * version 2, as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
11 * more details.
12 *
13 * You should have received a copy of the GNU General Public License along with
14 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
15 * Place - Suite 330, Boston, MA 02111-1307 USA.
16 *
17 * Authors:
Haiyang Zhangd0e94d12009-11-23 17:00:22 +000018 * Haiyang Zhang <haiyangz@microsoft.com>
Hank Janssenfceaf242009-07-13 15:34:54 -070019 * Hank Janssen <hjanssen@microsoft.com>
Hank Janssenfceaf242009-07-13 15:34:54 -070020 */
Hank Jansseneb335bc2011-03-29 13:58:48 -070021#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
22
Greg Kroah-Hartman5654e932009-07-14 15:08:20 -070023#include <linux/kernel.h>
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -080024#include <linux/sched.h>
25#include <linux/wait.h>
Greg Kroah-Hartman0ffa63b2009-07-15 11:06:01 -070026#include <linux/mm.h>
Greg Kroah-Hartmanb4362c92009-07-16 11:50:41 -070027#include <linux/delay.h>
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -070028#include <linux/io.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090029#include <linux/slab.h>
Haiyang Zhangd9871152011-09-01 12:19:41 -070030#include <linux/netdevice.h>
Haiyang Zhangf157e782011-12-15 13:45:16 -080031#include <linux/if_ether.h>
K. Y. Srinivasan3f335ea2011-05-12 19:34:15 -070032
K. Y. Srinivasan5ca72522011-05-12 19:34:37 -070033#include "hyperv_net.h"
Hank Janssenfceaf242009-07-13 15:34:54 -070034
35
Haiyang Zhang5a71ae32010-12-10 12:03:55 -080036static struct netvsc_device *alloc_net_device(struct hv_device *device)
Hank Janssenfceaf242009-07-13 15:34:54 -070037{
Haiyang Zhang85799a32010-12-10 12:03:54 -080038 struct netvsc_device *net_device;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -070039 struct net_device *ndev = hv_get_drvdata(device);
Hank Janssenfceaf242009-07-13 15:34:54 -070040
Haiyang Zhang85799a32010-12-10 12:03:54 -080041 net_device = kzalloc(sizeof(struct netvsc_device), GFP_KERNEL);
42 if (!net_device)
Hank Janssenfceaf242009-07-13 15:34:54 -070043 return NULL;
44
Haiyang Zhangdc5cd892012-06-04 06:42:38 +000045 init_waitqueue_head(&net_device->wait_drain);
Haiyang Zhang4d447c92011-12-15 13:45:17 -080046 net_device->start_remove = false;
K. Y. Srinivasanc38b9c72011-08-27 11:31:12 -070047 net_device->destroy = false;
Haiyang Zhang53d21fd2010-12-10 12:03:59 -080048 net_device->dev = device;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -070049 net_device->ndev = ndev;
Hank Janssenfceaf242009-07-13 15:34:54 -070050
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -070051 hv_set_drvdata(device, net_device);
Haiyang Zhang85799a32010-12-10 12:03:54 -080052 return net_device;
Hank Janssenfceaf242009-07-13 15:34:54 -070053}
54
Haiyang Zhang5a71ae32010-12-10 12:03:55 -080055static struct netvsc_device *get_outbound_net_device(struct hv_device *device)
Hank Janssenfceaf242009-07-13 15:34:54 -070056{
Haiyang Zhang85799a32010-12-10 12:03:54 -080057 struct netvsc_device *net_device;
Hank Janssenfceaf242009-07-13 15:34:54 -070058
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -070059 net_device = hv_get_drvdata(device);
K. Y. Srinivasan9d88f332011-08-27 11:31:16 -070060 if (net_device && net_device->destroy)
Haiyang Zhang85799a32010-12-10 12:03:54 -080061 net_device = NULL;
Hank Janssenfceaf242009-07-13 15:34:54 -070062
Haiyang Zhang85799a32010-12-10 12:03:54 -080063 return net_device;
Hank Janssenfceaf242009-07-13 15:34:54 -070064}
65
Haiyang Zhang5a71ae32010-12-10 12:03:55 -080066static struct netvsc_device *get_inbound_net_device(struct hv_device *device)
Hank Janssenfceaf242009-07-13 15:34:54 -070067{
Haiyang Zhang85799a32010-12-10 12:03:54 -080068 struct netvsc_device *net_device;
Hank Janssenfceaf242009-07-13 15:34:54 -070069
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -070070 net_device = hv_get_drvdata(device);
K. Y. Srinivasan9d88f332011-08-27 11:31:16 -070071
72 if (!net_device)
73 goto get_in_err;
74
75 if (net_device->destroy &&
76 atomic_read(&net_device->num_outstanding_sends) == 0)
Haiyang Zhang85799a32010-12-10 12:03:54 -080077 net_device = NULL;
Hank Janssenfceaf242009-07-13 15:34:54 -070078
K. Y. Srinivasan9d88f332011-08-27 11:31:16 -070079get_in_err:
Haiyang Zhang85799a32010-12-10 12:03:54 -080080 return net_device;
Hank Janssenfceaf242009-07-13 15:34:54 -070081}
82
Hank Janssenfceaf242009-07-13 15:34:54 -070083
Haiyang Zhangec91cd02011-04-21 12:30:43 -070084static int netvsc_destroy_recv_buf(struct netvsc_device *net_device)
85{
86 struct nvsp_message *revoke_packet;
87 int ret = 0;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -070088 struct net_device *ndev = net_device->ndev;
Haiyang Zhangec91cd02011-04-21 12:30:43 -070089
90 /*
91 * If we got a section count, it means we received a
92 * SendReceiveBufferComplete msg (ie sent
93 * NvspMessage1TypeSendReceiveBuffer msg) therefore, we need
94 * to send a revoke msg here
95 */
96 if (net_device->recv_section_cnt) {
97 /* Send the revoke receive buffer */
98 revoke_packet = &net_device->revoke_packet;
99 memset(revoke_packet, 0, sizeof(struct nvsp_message));
100
101 revoke_packet->hdr.msg_type =
102 NVSP_MSG1_TYPE_REVOKE_RECV_BUF;
103 revoke_packet->msg.v1_msg.
104 revoke_recv_buf.id = NETVSC_RECEIVE_BUFFER_ID;
105
106 ret = vmbus_sendpacket(net_device->dev->channel,
107 revoke_packet,
108 sizeof(struct nvsp_message),
109 (unsigned long)revoke_packet,
110 VM_PKT_DATA_INBAND, 0);
111 /*
112 * If we failed here, we might as well return and
113 * have a leak rather than continue and a bugchk
114 */
115 if (ret != 0) {
Haiyang Zhangd9871152011-09-01 12:19:41 -0700116 netdev_err(ndev, "unable to send "
Haiyang Zhangc909ebb2011-09-01 12:19:40 -0700117 "revoke receive buffer to netvsp\n");
K. Y. Srinivasana3e00532011-08-25 09:49:12 -0700118 return ret;
Haiyang Zhangec91cd02011-04-21 12:30:43 -0700119 }
120 }
121
122 /* Teardown the gpadl on the vsp end */
123 if (net_device->recv_buf_gpadl_handle) {
124 ret = vmbus_teardown_gpadl(net_device->dev->channel,
125 net_device->recv_buf_gpadl_handle);
126
127 /* If we failed here, we might as well return and have a leak
128 * rather than continue and a bugchk
129 */
130 if (ret != 0) {
Haiyang Zhangd9871152011-09-01 12:19:41 -0700131 netdev_err(ndev,
Haiyang Zhangc909ebb2011-09-01 12:19:40 -0700132 "unable to teardown receive buffer's gpadl\n");
Dan Carpenter7f9615e2011-08-27 14:06:07 +0300133 return ret;
Haiyang Zhangec91cd02011-04-21 12:30:43 -0700134 }
135 net_device->recv_buf_gpadl_handle = 0;
136 }
137
138 if (net_device->recv_buf) {
139 /* Free up the receive buffer */
140 free_pages((unsigned long)net_device->recv_buf,
141 get_order(net_device->recv_buf_size));
142 net_device->recv_buf = NULL;
143 }
144
145 if (net_device->recv_section) {
146 net_device->recv_section_cnt = 0;
147 kfree(net_device->recv_section);
148 net_device->recv_section = NULL;
149 }
150
151 return ret;
152}
153
Haiyang Zhang5a71ae32010-12-10 12:03:55 -0800154static int netvsc_init_recv_buf(struct hv_device *device)
Hank Janssenfceaf242009-07-13 15:34:54 -0700155{
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700156 int ret = 0;
K. Y. Srinivasan35abb212011-05-10 07:55:41 -0700157 int t;
Haiyang Zhang85799a32010-12-10 12:03:54 -0800158 struct netvsc_device *net_device;
159 struct nvsp_message *init_packet;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700160 struct net_device *ndev;
Hank Janssenfceaf242009-07-13 15:34:54 -0700161
Haiyang Zhang5a71ae32010-12-10 12:03:55 -0800162 net_device = get_outbound_net_device(device);
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700163 if (!net_device)
K. Y. Srinivasan927bc332011-08-25 09:49:13 -0700164 return -ENODEV;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700165 ndev = net_device->ndev;
Hank Janssenfceaf242009-07-13 15:34:54 -0700166
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800167 net_device->recv_buf =
K. Y. Srinivasandf3493e2011-02-11 09:59:00 -0800168 (void *)__get_free_pages(GFP_KERNEL|__GFP_ZERO,
169 get_order(net_device->recv_buf_size));
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800170 if (!net_device->recv_buf) {
Haiyang Zhangd9871152011-09-01 12:19:41 -0700171 netdev_err(ndev, "unable to allocate receive "
Haiyang Zhangc909ebb2011-09-01 12:19:40 -0700172 "buffer of size %d\n", net_device->recv_buf_size);
K. Y. Srinivasan927bc332011-08-25 09:49:13 -0700173 ret = -ENOMEM;
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -0800174 goto cleanup;
Hank Janssenfceaf242009-07-13 15:34:54 -0700175 }
Hank Janssenfceaf242009-07-13 15:34:54 -0700176
Bill Pemberton454f18a2009-07-27 16:47:24 -0400177 /*
178 * Establish the gpadl handle for this buffer on this
179 * channel. Note: This call uses the vmbus connection rather
180 * than the channel to establish the gpadl handle.
181 */
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800182 ret = vmbus_establish_gpadl(device->channel, net_device->recv_buf,
183 net_device->recv_buf_size,
184 &net_device->recv_buf_gpadl_handle);
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700185 if (ret != 0) {
Haiyang Zhangd9871152011-09-01 12:19:41 -0700186 netdev_err(ndev,
Haiyang Zhangc909ebb2011-09-01 12:19:40 -0700187 "unable to establish receive buffer's gpadl\n");
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -0800188 goto cleanup;
Hank Janssenfceaf242009-07-13 15:34:54 -0700189 }
190
Hank Janssenfceaf242009-07-13 15:34:54 -0700191
Bill Pemberton454f18a2009-07-27 16:47:24 -0400192 /* Notify the NetVsp of the gpadl handle */
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800193 init_packet = &net_device->channel_init_pkt;
Hank Janssenfceaf242009-07-13 15:34:54 -0700194
Haiyang Zhang85799a32010-12-10 12:03:54 -0800195 memset(init_packet, 0, sizeof(struct nvsp_message));
Hank Janssenfceaf242009-07-13 15:34:54 -0700196
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800197 init_packet->hdr.msg_type = NVSP_MSG1_TYPE_SEND_RECV_BUF;
198 init_packet->msg.v1_msg.send_recv_buf.
199 gpadl_handle = net_device->recv_buf_gpadl_handle;
200 init_packet->msg.v1_msg.
201 send_recv_buf.id = NETVSC_RECEIVE_BUFFER_ID;
Hank Janssenfceaf242009-07-13 15:34:54 -0700202
Bill Pemberton454f18a2009-07-27 16:47:24 -0400203 /* Send the gpadl notification request */
Haiyang Zhang85799a32010-12-10 12:03:54 -0800204 ret = vmbus_sendpacket(device->channel, init_packet,
Greg Kroah-Hartman5a4df292010-10-21 09:43:24 -0700205 sizeof(struct nvsp_message),
Haiyang Zhang85799a32010-12-10 12:03:54 -0800206 (unsigned long)init_packet,
Haiyang Zhang415f2282011-01-26 12:12:13 -0800207 VM_PKT_DATA_INBAND,
Greg Kroah-Hartman5a4df292010-10-21 09:43:24 -0700208 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700209 if (ret != 0) {
Haiyang Zhangd9871152011-09-01 12:19:41 -0700210 netdev_err(ndev,
Haiyang Zhangc909ebb2011-09-01 12:19:40 -0700211 "unable to send receive buffer's gpadl to netvsp\n");
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -0800212 goto cleanup;
Hank Janssenfceaf242009-07-13 15:34:54 -0700213 }
214
K. Y. Srinivasan5c5781b32011-06-16 13:16:35 -0700215 t = wait_for_completion_timeout(&net_device->channel_init_wait, 5*HZ);
K. Y. Srinivasan35abb212011-05-10 07:55:41 -0700216 BUG_ON(t == 0);
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -0800217
Hank Janssenfceaf242009-07-13 15:34:54 -0700218
Bill Pemberton454f18a2009-07-27 16:47:24 -0400219 /* Check the response */
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800220 if (init_packet->msg.v1_msg.
221 send_recv_buf_complete.status != NVSP_STAT_SUCCESS) {
Haiyang Zhangd9871152011-09-01 12:19:41 -0700222 netdev_err(ndev, "Unable to complete receive buffer "
Haiyang Zhang8bff33a2011-09-01 12:19:48 -0700223 "initialization with NetVsp - status %d\n",
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800224 init_packet->msg.v1_msg.
225 send_recv_buf_complete.status);
K. Y. Srinivasan927bc332011-08-25 09:49:13 -0700226 ret = -EINVAL;
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -0800227 goto cleanup;
Hank Janssenfceaf242009-07-13 15:34:54 -0700228 }
229
Bill Pemberton454f18a2009-07-27 16:47:24 -0400230 /* Parse the response */
Hank Janssenfceaf242009-07-13 15:34:54 -0700231
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800232 net_device->recv_section_cnt = init_packet->msg.
233 v1_msg.send_recv_buf_complete.num_sections;
Hank Janssenfceaf242009-07-13 15:34:54 -0700234
Haiyang Zhangc1813202011-11-30 07:19:07 -0800235 net_device->recv_section = kmemdup(
236 init_packet->msg.v1_msg.send_recv_buf_complete.sections,
237 net_device->recv_section_cnt *
238 sizeof(struct nvsp_1_receive_buffer_section),
239 GFP_KERNEL);
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800240 if (net_device->recv_section == NULL) {
K. Y. Srinivasan927bc332011-08-25 09:49:13 -0700241 ret = -EINVAL;
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -0800242 goto cleanup;
Hank Janssenfceaf242009-07-13 15:34:54 -0700243 }
244
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700245 /*
246 * For 1st release, there should only be 1 section that represents the
247 * entire receive buffer
248 */
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800249 if (net_device->recv_section_cnt != 1 ||
250 net_device->recv_section->offset != 0) {
K. Y. Srinivasan927bc332011-08-25 09:49:13 -0700251 ret = -EINVAL;
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -0800252 goto cleanup;
Hank Janssenfceaf242009-07-13 15:34:54 -0700253 }
254
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -0800255 goto exit;
Hank Janssenfceaf242009-07-13 15:34:54 -0700256
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -0800257cleanup:
Haiyang Zhang5a71ae32010-12-10 12:03:55 -0800258 netvsc_destroy_recv_buf(net_device);
Hank Janssenfceaf242009-07-13 15:34:54 -0700259
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -0800260exit:
Hank Janssenfceaf242009-07-13 15:34:54 -0700261 return ret;
262}
263
Hank Janssenfceaf242009-07-13 15:34:54 -0700264
Haiyang Zhangf157e782011-12-15 13:45:16 -0800265/* Negotiate NVSP protocol version */
266static int negotiate_nvsp_ver(struct hv_device *device,
267 struct netvsc_device *net_device,
268 struct nvsp_message *init_packet,
269 u32 nvsp_ver)
Hank Janssenfceaf242009-07-13 15:34:54 -0700270{
K. Y. Srinivasan35abb212011-05-10 07:55:41 -0700271 int ret, t;
Haiyang Zhangf157e782011-12-15 13:45:16 -0800272
273 memset(init_packet, 0, sizeof(struct nvsp_message));
274 init_packet->hdr.msg_type = NVSP_MSG_TYPE_INIT;
275 init_packet->msg.init_msg.init.min_protocol_ver = nvsp_ver;
276 init_packet->msg.init_msg.init.max_protocol_ver = nvsp_ver;
277
278 /* Send the init request */
279 ret = vmbus_sendpacket(device->channel, init_packet,
280 sizeof(struct nvsp_message),
281 (unsigned long)init_packet,
282 VM_PKT_DATA_INBAND,
283 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
284
285 if (ret != 0)
286 return ret;
287
288 t = wait_for_completion_timeout(&net_device->channel_init_wait, 5*HZ);
289
290 if (t == 0)
291 return -ETIMEDOUT;
292
293 if (init_packet->msg.init_msg.init_complete.status !=
294 NVSP_STAT_SUCCESS)
295 return -EINVAL;
296
297 if (nvsp_ver != NVSP_PROTOCOL_VERSION_2)
298 return 0;
299
300 /* NVSPv2 only: Send NDIS config */
301 memset(init_packet, 0, sizeof(struct nvsp_message));
302 init_packet->hdr.msg_type = NVSP_MSG2_TYPE_SEND_NDIS_CONFIG;
Haiyang Zhang4d447c92011-12-15 13:45:17 -0800303 init_packet->msg.v2_msg.send_ndis_config.mtu = net_device->ndev->mtu;
Haiyang Zhang1f5f3a72012-03-12 10:20:50 +0000304 init_packet->msg.v2_msg.send_ndis_config.capability.ieee8021q = 1;
Haiyang Zhangf157e782011-12-15 13:45:16 -0800305
306 ret = vmbus_sendpacket(device->channel, init_packet,
307 sizeof(struct nvsp_message),
308 (unsigned long)init_packet,
309 VM_PKT_DATA_INBAND, 0);
310
311 return ret;
312}
313
314static int netvsc_connect_vsp(struct hv_device *device)
315{
316 int ret;
Haiyang Zhang85799a32010-12-10 12:03:54 -0800317 struct netvsc_device *net_device;
318 struct nvsp_message *init_packet;
319 int ndis_version;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700320 struct net_device *ndev;
Hank Janssenfceaf242009-07-13 15:34:54 -0700321
Haiyang Zhang5a71ae32010-12-10 12:03:55 -0800322 net_device = get_outbound_net_device(device);
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700323 if (!net_device)
K. Y. Srinivasan0f48c722011-08-25 09:49:14 -0700324 return -ENODEV;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700325 ndev = net_device->ndev;
Hank Janssenfceaf242009-07-13 15:34:54 -0700326
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800327 init_packet = &net_device->channel_init_pkt;
Hank Janssenfceaf242009-07-13 15:34:54 -0700328
Haiyang Zhangf157e782011-12-15 13:45:16 -0800329 /* Negotiate the latest NVSP protocol supported */
330 if (negotiate_nvsp_ver(device, net_device, init_packet,
331 NVSP_PROTOCOL_VERSION_2) == 0) {
332 net_device->nvsp_version = NVSP_PROTOCOL_VERSION_2;
333 } else if (negotiate_nvsp_ver(device, net_device, init_packet,
334 NVSP_PROTOCOL_VERSION_1) == 0) {
335 net_device->nvsp_version = NVSP_PROTOCOL_VERSION_1;
336 } else {
K. Y. Srinivasan0f48c722011-08-25 09:49:14 -0700337 ret = -EPROTO;
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -0800338 goto cleanup;
Hank Janssenfceaf242009-07-13 15:34:54 -0700339 }
Haiyang Zhangf157e782011-12-15 13:45:16 -0800340
341 pr_debug("Negotiated NVSP version:%x\n", net_device->nvsp_version);
342
Bill Pemberton454f18a2009-07-27 16:47:24 -0400343 /* Send the ndis version */
Haiyang Zhang85799a32010-12-10 12:03:54 -0800344 memset(init_packet, 0, sizeof(struct nvsp_message));
Hank Janssenfceaf242009-07-13 15:34:54 -0700345
Haiyang Zhang1f5f3a72012-03-12 10:20:50 +0000346 ndis_version = 0x00050001;
Hank Janssenfceaf242009-07-13 15:34:54 -0700347
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800348 init_packet->hdr.msg_type = NVSP_MSG1_TYPE_SEND_NDIS_VER;
349 init_packet->msg.v1_msg.
350 send_ndis_ver.ndis_major_ver =
Haiyang Zhang85799a32010-12-10 12:03:54 -0800351 (ndis_version & 0xFFFF0000) >> 16;
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800352 init_packet->msg.v1_msg.
353 send_ndis_ver.ndis_minor_ver =
Haiyang Zhang85799a32010-12-10 12:03:54 -0800354 ndis_version & 0xFFFF;
Hank Janssenfceaf242009-07-13 15:34:54 -0700355
Bill Pemberton454f18a2009-07-27 16:47:24 -0400356 /* Send the init request */
Haiyang Zhang85799a32010-12-10 12:03:54 -0800357 ret = vmbus_sendpacket(device->channel, init_packet,
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -0800358 sizeof(struct nvsp_message),
359 (unsigned long)init_packet,
360 VM_PKT_DATA_INBAND, 0);
K. Y. Srinivasan0f48c722011-08-25 09:49:14 -0700361 if (ret != 0)
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -0800362 goto cleanup;
Hank Janssenfceaf242009-07-13 15:34:54 -0700363
Bill Pemberton454f18a2009-07-27 16:47:24 -0400364 /* Post the big receive buffer to NetVSP */
Haiyang Zhang5a71ae32010-12-10 12:03:55 -0800365 ret = netvsc_init_recv_buf(device);
Hank Janssenfceaf242009-07-13 15:34:54 -0700366
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -0800367cleanup:
Hank Janssenfceaf242009-07-13 15:34:54 -0700368 return ret;
369}
370
Haiyang Zhang648dc592011-04-21 12:30:47 -0700371static void netvsc_disconnect_vsp(struct netvsc_device *net_device)
Hank Janssenfceaf242009-07-13 15:34:54 -0700372{
Haiyang Zhang5a71ae32010-12-10 12:03:55 -0800373 netvsc_destroy_recv_buf(net_device);
Hank Janssenfceaf242009-07-13 15:34:54 -0700374}
375
Hank Janssen3e189512010-03-04 22:11:00 +0000376/*
Haiyang Zhang5a71ae32010-12-10 12:03:55 -0800377 * netvsc_device_remove - Callback when the root bus device is removed
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700378 */
K. Y. Srinivasan905620d2011-05-10 07:54:54 -0700379int netvsc_device_remove(struct hv_device *device)
Hank Janssenfceaf242009-07-13 15:34:54 -0700380{
Haiyang Zhang85799a32010-12-10 12:03:54 -0800381 struct netvsc_device *net_device;
382 struct hv_netvsc_packet *netvsc_packet, *pos;
K. Y. Srinivasanc38b9c72011-08-27 11:31:12 -0700383 unsigned long flags;
Hank Janssenfceaf242009-07-13 15:34:54 -0700384
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700385 net_device = hv_get_drvdata(device);
Hank Janssenfceaf242009-07-13 15:34:54 -0700386
Haiyang Zhang648dc592011-04-21 12:30:47 -0700387 netvsc_disconnect_vsp(net_device);
Hank Janssenfceaf242009-07-13 15:34:54 -0700388
K. Y. Srinivasan38524092011-08-27 11:31:14 -0700389 /*
K. Y. Srinivasan9d88f332011-08-27 11:31:16 -0700390 * Since we have already drained, we don't need to busy wait
391 * as was done in final_release_stor_device()
392 * Note that we cannot set the ext pointer to NULL until
393 * we have drained - to drain the outgoing packets, we need to
394 * allow incoming packets.
K. Y. Srinivasan38524092011-08-27 11:31:14 -0700395 */
K. Y. Srinivasan9d88f332011-08-27 11:31:16 -0700396
397 spin_lock_irqsave(&device->channel->inbound_lock, flags);
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700398 hv_set_drvdata(device, NULL);
K. Y. Srinivasan9d88f332011-08-27 11:31:16 -0700399 spin_unlock_irqrestore(&device->channel->inbound_lock, flags);
K. Y. Srinivasan38524092011-08-27 11:31:14 -0700400
K. Y. Srinivasan86c921a2011-09-13 10:59:54 -0700401 /*
402 * At this point, no one should be accessing net_device
403 * except in here
404 */
Haiyang Zhangc909ebb2011-09-01 12:19:40 -0700405 dev_notice(&device->device, "net device safe to remove\n");
Hank Janssenfceaf242009-07-13 15:34:54 -0700406
Bill Pemberton454f18a2009-07-27 16:47:24 -0400407 /* Now, we can close the channel safely */
Haiyang Zhang85799a32010-12-10 12:03:54 -0800408 vmbus_close(device->channel);
Hank Janssenfceaf242009-07-13 15:34:54 -0700409
Bill Pemberton454f18a2009-07-27 16:47:24 -0400410 /* Release all resources */
Haiyang Zhang85799a32010-12-10 12:03:54 -0800411 list_for_each_entry_safe(netvsc_packet, pos,
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800412 &net_device->recv_pkt_list, list_ent) {
Haiyang Zhang72a2f5b2010-12-10 12:03:58 -0800413 list_del(&netvsc_packet->list_ent);
Haiyang Zhang85799a32010-12-10 12:03:54 -0800414 kfree(netvsc_packet);
Hank Janssenfceaf242009-07-13 15:34:54 -0700415 }
416
K. Y. Srinivasan356c4652011-08-27 11:31:10 -0700417 kfree(net_device);
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700418 return 0;
Hank Janssenfceaf242009-07-13 15:34:54 -0700419}
420
Haiyang Zhang33be96e2012-03-27 13:20:45 +0000421
422#define RING_AVAIL_PERCENT_HIWATER 20
423#define RING_AVAIL_PERCENT_LOWATER 10
424
425/*
426 * Get the percentage of available bytes to write in the ring.
427 * The return value is in range from 0 to 100.
428 */
429static inline u32 hv_ringbuf_avail_percent(
430 struct hv_ring_buffer_info *ring_info)
431{
432 u32 avail_read, avail_write;
433
434 hv_get_ringbuffer_availbytes(ring_info, &avail_read, &avail_write);
435
436 return avail_write * 100 / ring_info->ring_datasize;
437}
438
Haiyang Zhang5a71ae32010-12-10 12:03:55 -0800439static void netvsc_send_completion(struct hv_device *device,
Haiyang Zhang85799a32010-12-10 12:03:54 -0800440 struct vmpacket_descriptor *packet)
Hank Janssenfceaf242009-07-13 15:34:54 -0700441{
Haiyang Zhang85799a32010-12-10 12:03:54 -0800442 struct netvsc_device *net_device;
443 struct nvsp_message *nvsp_packet;
444 struct hv_netvsc_packet *nvsc_packet;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700445 struct net_device *ndev;
Hank Janssenfceaf242009-07-13 15:34:54 -0700446
Haiyang Zhang5a71ae32010-12-10 12:03:55 -0800447 net_device = get_inbound_net_device(device);
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700448 if (!net_device)
Hank Janssenfceaf242009-07-13 15:34:54 -0700449 return;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700450 ndev = net_device->ndev;
Hank Janssenfceaf242009-07-13 15:34:54 -0700451
Haiyang Zhang85799a32010-12-10 12:03:54 -0800452 nvsp_packet = (struct nvsp_message *)((unsigned long)packet +
Haiyang Zhang415f2282011-01-26 12:12:13 -0800453 (packet->offset8 << 3));
Hank Janssenfceaf242009-07-13 15:34:54 -0700454
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800455 if ((nvsp_packet->hdr.msg_type == NVSP_MSG_TYPE_INIT_COMPLETE) ||
456 (nvsp_packet->hdr.msg_type ==
457 NVSP_MSG1_TYPE_SEND_RECV_BUF_COMPLETE) ||
458 (nvsp_packet->hdr.msg_type ==
459 NVSP_MSG1_TYPE_SEND_SEND_BUF_COMPLETE)) {
Bill Pemberton454f18a2009-07-27 16:47:24 -0400460 /* Copy the response back */
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800461 memcpy(&net_device->channel_init_pkt, nvsp_packet,
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700462 sizeof(struct nvsp_message));
K. Y. Srinivasan35abb212011-05-10 07:55:41 -0700463 complete(&net_device->channel_init_wait);
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800464 } else if (nvsp_packet->hdr.msg_type ==
465 NVSP_MSG1_TYPE_SEND_RNDIS_PKT_COMPLETE) {
Haiyang Zhang33be96e2012-03-27 13:20:45 +0000466 int num_outstanding_sends;
467
Bill Pemberton454f18a2009-07-27 16:47:24 -0400468 /* Get the send context */
Haiyang Zhang85799a32010-12-10 12:03:54 -0800469 nvsc_packet = (struct hv_netvsc_packet *)(unsigned long)
Haiyang Zhang415f2282011-01-26 12:12:13 -0800470 packet->trans_id;
Hank Janssenfceaf242009-07-13 15:34:54 -0700471
Bill Pemberton454f18a2009-07-27 16:47:24 -0400472 /* Notify the layer above us */
Haiyang Zhang72a2f5b2010-12-10 12:03:58 -0800473 nvsc_packet->completion.send.send_completion(
474 nvsc_packet->completion.send.send_completion_ctx);
Hank Janssenfceaf242009-07-13 15:34:54 -0700475
Haiyang Zhang33be96e2012-03-27 13:20:45 +0000476 num_outstanding_sends =
477 atomic_dec_return(&net_device->num_outstanding_sends);
Haiyang Zhang1d068252011-12-02 11:56:25 -0800478
Haiyang Zhangdc5cd892012-06-04 06:42:38 +0000479 if (net_device->destroy && num_outstanding_sends == 0)
480 wake_up(&net_device->wait_drain);
481
Haiyang Zhang33be96e2012-03-27 13:20:45 +0000482 if (netif_queue_stopped(ndev) && !net_device->start_remove &&
483 (hv_ringbuf_avail_percent(&device->channel->outbound)
484 > RING_AVAIL_PERCENT_HIWATER ||
485 num_outstanding_sends < 1))
486 netif_wake_queue(ndev);
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700487 } else {
Haiyang Zhangd9871152011-09-01 12:19:41 -0700488 netdev_err(ndev, "Unknown send completion packet type- "
Haiyang Zhangc909ebb2011-09-01 12:19:40 -0700489 "%d received!!\n", nvsp_packet->hdr.msg_type);
Hank Janssenfceaf242009-07-13 15:34:54 -0700490 }
491
Hank Janssenfceaf242009-07-13 15:34:54 -0700492}
493
K. Y. Srinivasanf9819f02011-05-12 19:34:49 -0700494int netvsc_send(struct hv_device *device,
Haiyang Zhang85799a32010-12-10 12:03:54 -0800495 struct hv_netvsc_packet *packet)
Hank Janssenfceaf242009-07-13 15:34:54 -0700496{
Haiyang Zhang85799a32010-12-10 12:03:54 -0800497 struct netvsc_device *net_device;
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700498 int ret = 0;
Greg Kroah-Hartman223c1aa2009-08-28 16:20:53 -0700499 struct nvsp_message sendMessage;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700500 struct net_device *ndev;
Hank Janssenfceaf242009-07-13 15:34:54 -0700501
Haiyang Zhang5a71ae32010-12-10 12:03:55 -0800502 net_device = get_outbound_net_device(device);
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700503 if (!net_device)
K. Y. Srinivasanff2bd692011-08-25 09:49:15 -0700504 return -ENODEV;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700505 ndev = net_device->ndev;
Hank Janssenfceaf242009-07-13 15:34:54 -0700506
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800507 sendMessage.hdr.msg_type = NVSP_MSG1_TYPE_SEND_RNDIS_PKT;
Haiyang Zhang72a2f5b2010-12-10 12:03:58 -0800508 if (packet->is_data_pkt) {
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700509 /* 0 is RMC_DATA; */
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800510 sendMessage.msg.v1_msg.send_rndis_pkt.channel_type = 0;
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700511 } else {
512 /* 1 is RMC_CONTROL; */
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800513 sendMessage.msg.v1_msg.send_rndis_pkt.channel_type = 1;
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700514 }
Hank Janssenfceaf242009-07-13 15:34:54 -0700515
Bill Pemberton454f18a2009-07-27 16:47:24 -0400516 /* Not using send buffer section */
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800517 sendMessage.msg.v1_msg.send_rndis_pkt.send_buf_section_index =
518 0xFFFFFFFF;
519 sendMessage.msg.v1_msg.send_rndis_pkt.send_buf_section_size = 0;
Hank Janssenfceaf242009-07-13 15:34:54 -0700520
Haiyang Zhang72a2f5b2010-12-10 12:03:58 -0800521 if (packet->page_buf_cnt) {
Haiyang Zhang85799a32010-12-10 12:03:54 -0800522 ret = vmbus_sendpacket_pagebuffer(device->channel,
Haiyang Zhang72a2f5b2010-12-10 12:03:58 -0800523 packet->page_buf,
524 packet->page_buf_cnt,
Greg Kroah-Hartmanff3f8ee2010-10-21 09:32:46 -0700525 &sendMessage,
526 sizeof(struct nvsp_message),
Haiyang Zhang85799a32010-12-10 12:03:54 -0800527 (unsigned long)packet);
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700528 } else {
Haiyang Zhang85799a32010-12-10 12:03:54 -0800529 ret = vmbus_sendpacket(device->channel, &sendMessage,
Haiyang Zhange4d59ac2011-06-17 07:58:04 -0700530 sizeof(struct nvsp_message),
531 (unsigned long)packet,
532 VM_PKT_DATA_INBAND,
533 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
Hank Janssenfceaf242009-07-13 15:34:54 -0700534
535 }
536
Haiyang Zhang1d068252011-12-02 11:56:25 -0800537 if (ret == 0) {
538 atomic_inc(&net_device->num_outstanding_sends);
Haiyang Zhang33be96e2012-03-27 13:20:45 +0000539 if (hv_ringbuf_avail_percent(&device->channel->outbound) <
540 RING_AVAIL_PERCENT_LOWATER) {
541 netif_stop_queue(ndev);
542 if (atomic_read(&net_device->
543 num_outstanding_sends) < 1)
544 netif_wake_queue(ndev);
545 }
Haiyang Zhang1d068252011-12-02 11:56:25 -0800546 } else if (ret == -EAGAIN) {
547 netif_stop_queue(ndev);
Haiyang Zhang33be96e2012-03-27 13:20:45 +0000548 if (atomic_read(&net_device->num_outstanding_sends) < 1) {
Haiyang Zhang1d068252011-12-02 11:56:25 -0800549 netif_wake_queue(ndev);
Haiyang Zhang33be96e2012-03-27 13:20:45 +0000550 ret = -ENOSPC;
551 }
Haiyang Zhang1d068252011-12-02 11:56:25 -0800552 } else {
Haiyang Zhangd9871152011-09-01 12:19:41 -0700553 netdev_err(ndev, "Unable to send packet %p ret %d\n",
Haiyang Zhang85799a32010-12-10 12:03:54 -0800554 packet, ret);
Haiyang Zhang1d068252011-12-02 11:56:25 -0800555 }
Hank Janssenfceaf242009-07-13 15:34:54 -0700556
Hank Janssenfceaf242009-07-13 15:34:54 -0700557 return ret;
558}
559
Haiyang Zhang5fa9d3c2011-04-21 12:30:42 -0700560static void netvsc_send_recv_completion(struct hv_device *device,
Haiyang Zhang63f69212012-10-02 05:30:23 +0000561 u64 transaction_id, u32 status)
Haiyang Zhang5fa9d3c2011-04-21 12:30:42 -0700562{
563 struct nvsp_message recvcompMessage;
564 int retries = 0;
565 int ret;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700566 struct net_device *ndev;
567 struct netvsc_device *net_device = hv_get_drvdata(device);
568
569 ndev = net_device->ndev;
Haiyang Zhang5fa9d3c2011-04-21 12:30:42 -0700570
571 recvcompMessage.hdr.msg_type =
572 NVSP_MSG1_TYPE_SEND_RNDIS_PKT_COMPLETE;
573
Haiyang Zhang63f69212012-10-02 05:30:23 +0000574 recvcompMessage.msg.v1_msg.send_rndis_pkt_complete.status = status;
Haiyang Zhang5fa9d3c2011-04-21 12:30:42 -0700575
576retry_send_cmplt:
577 /* Send the completion */
578 ret = vmbus_sendpacket(device->channel, &recvcompMessage,
579 sizeof(struct nvsp_message), transaction_id,
580 VM_PKT_COMP, 0);
581 if (ret == 0) {
582 /* success */
583 /* no-op */
K. Y. Srinivasand2598f02011-08-25 09:48:58 -0700584 } else if (ret == -EAGAIN) {
Haiyang Zhang5fa9d3c2011-04-21 12:30:42 -0700585 /* no more room...wait a bit and attempt to retry 3 times */
586 retries++;
Haiyang Zhangd9871152011-09-01 12:19:41 -0700587 netdev_err(ndev, "unable to send receive completion pkt"
Haiyang Zhangc909ebb2011-09-01 12:19:40 -0700588 " (tid %llx)...retrying %d\n", transaction_id, retries);
Haiyang Zhang5fa9d3c2011-04-21 12:30:42 -0700589
590 if (retries < 4) {
591 udelay(100);
592 goto retry_send_cmplt;
593 } else {
Haiyang Zhangd9871152011-09-01 12:19:41 -0700594 netdev_err(ndev, "unable to send receive "
Haiyang Zhangc909ebb2011-09-01 12:19:40 -0700595 "completion pkt (tid %llx)...give up retrying\n",
Haiyang Zhang5fa9d3c2011-04-21 12:30:42 -0700596 transaction_id);
597 }
598 } else {
Haiyang Zhangd9871152011-09-01 12:19:41 -0700599 netdev_err(ndev, "unable to send receive "
Haiyang Zhangc909ebb2011-09-01 12:19:40 -0700600 "completion pkt - %llx\n", transaction_id);
Haiyang Zhang5fa9d3c2011-04-21 12:30:42 -0700601 }
602}
603
Haiyang Zhang57991152011-04-21 12:30:41 -0700604/* Send a receive completion packet to RNDIS device (ie NetVsp) */
605static void netvsc_receive_completion(void *context)
606{
607 struct hv_netvsc_packet *packet = context;
Joe Perchesc2fd03a2012-06-04 12:44:18 +0000608 struct hv_device *device = packet->device;
Haiyang Zhang57991152011-04-21 12:30:41 -0700609 struct netvsc_device *net_device;
610 u64 transaction_id = 0;
611 bool fsend_receive_comp = false;
612 unsigned long flags;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700613 struct net_device *ndev;
Haiyang Zhang63f69212012-10-02 05:30:23 +0000614 u32 status = NVSP_STAT_NONE;
Haiyang Zhang57991152011-04-21 12:30:41 -0700615
616 /*
617 * Even though it seems logical to do a GetOutboundNetDevice() here to
618 * send out receive completion, we are using GetInboundNetDevice()
619 * since we may have disable outbound traffic already.
620 */
621 net_device = get_inbound_net_device(device);
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700622 if (!net_device)
Haiyang Zhang57991152011-04-21 12:30:41 -0700623 return;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700624 ndev = net_device->ndev;
Haiyang Zhang57991152011-04-21 12:30:41 -0700625
626 /* Overloading use of the lock. */
627 spin_lock_irqsave(&net_device->recv_pkt_list_lock, flags);
628
Haiyang Zhang63f69212012-10-02 05:30:23 +0000629 if (packet->status != NVSP_STAT_SUCCESS)
630 packet->xfer_page_pkt->status = NVSP_STAT_FAIL;
631
Haiyang Zhang57991152011-04-21 12:30:41 -0700632 packet->xfer_page_pkt->count--;
633
634 /*
635 * Last one in the line that represent 1 xfer page packet.
636 * Return the xfer page packet itself to the freelist
637 */
638 if (packet->xfer_page_pkt->count == 0) {
639 fsend_receive_comp = true;
640 transaction_id = packet->completion.recv.recv_completion_tid;
Haiyang Zhang63f69212012-10-02 05:30:23 +0000641 status = packet->xfer_page_pkt->status;
Haiyang Zhang57991152011-04-21 12:30:41 -0700642 list_add_tail(&packet->xfer_page_pkt->list_ent,
643 &net_device->recv_pkt_list);
644
645 }
646
647 /* Put the packet back */
648 list_add_tail(&packet->list_ent, &net_device->recv_pkt_list);
649 spin_unlock_irqrestore(&net_device->recv_pkt_list_lock, flags);
650
651 /* Send a receive completion for the xfer page packet */
652 if (fsend_receive_comp)
Haiyang Zhang63f69212012-10-02 05:30:23 +0000653 netvsc_send_recv_completion(device, transaction_id, status);
Haiyang Zhang57991152011-04-21 12:30:41 -0700654
Haiyang Zhang57991152011-04-21 12:30:41 -0700655}
656
Haiyang Zhang5a71ae32010-12-10 12:03:55 -0800657static void netvsc_receive(struct hv_device *device,
Haiyang Zhang85799a32010-12-10 12:03:54 -0800658 struct vmpacket_descriptor *packet)
Hank Janssenfceaf242009-07-13 15:34:54 -0700659{
Haiyang Zhang85799a32010-12-10 12:03:54 -0800660 struct netvsc_device *net_device;
661 struct vmtransfer_page_packet_header *vmxferpage_packet;
662 struct nvsp_message *nvsp_packet;
663 struct hv_netvsc_packet *netvsc_packet = NULL;
Greg Kroah-Hartman7e23a6e2009-08-27 15:58:15 -0700664 /* struct netvsc_driver *netvscDriver; */
Haiyang Zhang85799a32010-12-10 12:03:54 -0800665 struct xferpage_packet *xferpage_packet = NULL;
Haiyang Zhang45326342011-12-15 13:45:15 -0800666 int i;
667 int count = 0;
Greg Kroah-Hartman64368732009-07-15 14:56:15 -0700668 unsigned long flags;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700669 struct net_device *ndev;
K. Y. Srinivasan779b4d12011-04-26 09:20:22 -0700670
Bill Pembertond29274e2009-09-11 21:46:43 -0400671 LIST_HEAD(listHead);
Hank Janssenfceaf242009-07-13 15:34:54 -0700672
Haiyang Zhang5a71ae32010-12-10 12:03:55 -0800673 net_device = get_inbound_net_device(device);
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700674 if (!net_device)
Hank Janssenfceaf242009-07-13 15:34:54 -0700675 return;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700676 ndev = net_device->ndev;
Hank Janssenfceaf242009-07-13 15:34:54 -0700677
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700678 /*
679 * All inbound packets other than send completion should be xfer page
680 * packet
681 */
Haiyang Zhang415f2282011-01-26 12:12:13 -0800682 if (packet->type != VM_PKT_DATA_USING_XFER_PAGES) {
Haiyang Zhangd9871152011-09-01 12:19:41 -0700683 netdev_err(ndev, "Unknown packet type received - %d\n",
Haiyang Zhang415f2282011-01-26 12:12:13 -0800684 packet->type);
Hank Janssenfceaf242009-07-13 15:34:54 -0700685 return;
686 }
687
Haiyang Zhang85799a32010-12-10 12:03:54 -0800688 nvsp_packet = (struct nvsp_message *)((unsigned long)packet +
Haiyang Zhang415f2282011-01-26 12:12:13 -0800689 (packet->offset8 << 3));
Hank Janssenfceaf242009-07-13 15:34:54 -0700690
Bill Pemberton454f18a2009-07-27 16:47:24 -0400691 /* Make sure this is a valid nvsp packet */
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800692 if (nvsp_packet->hdr.msg_type !=
693 NVSP_MSG1_TYPE_SEND_RNDIS_PKT) {
Haiyang Zhangd9871152011-09-01 12:19:41 -0700694 netdev_err(ndev, "Unknown nvsp packet type received-"
Haiyang Zhangc909ebb2011-09-01 12:19:40 -0700695 " %d\n", nvsp_packet->hdr.msg_type);
Hank Janssenfceaf242009-07-13 15:34:54 -0700696 return;
697 }
698
Haiyang Zhang85799a32010-12-10 12:03:54 -0800699 vmxferpage_packet = (struct vmtransfer_page_packet_header *)packet;
Hank Janssenfceaf242009-07-13 15:34:54 -0700700
Haiyang Zhang415f2282011-01-26 12:12:13 -0800701 if (vmxferpage_packet->xfer_pageset_id != NETVSC_RECEIVE_BUFFER_ID) {
Haiyang Zhangd9871152011-09-01 12:19:41 -0700702 netdev_err(ndev, "Invalid xfer page set id - "
Haiyang Zhangc909ebb2011-09-01 12:19:40 -0700703 "expecting %x got %x\n", NETVSC_RECEIVE_BUFFER_ID,
Haiyang Zhang415f2282011-01-26 12:12:13 -0800704 vmxferpage_packet->xfer_pageset_id);
Hank Janssenfceaf242009-07-13 15:34:54 -0700705 return;
706 }
707
Bill Pemberton454f18a2009-07-27 16:47:24 -0400708 /*
709 * Grab free packets (range count + 1) to represent this xfer
710 * page packet. +1 to represent the xfer page packet itself.
711 * We grab it here so that we know exactly how many we can
712 * fulfil
713 */
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800714 spin_lock_irqsave(&net_device->recv_pkt_list_lock, flags);
715 while (!list_empty(&net_device->recv_pkt_list)) {
716 list_move_tail(net_device->recv_pkt_list.next, &listHead);
Haiyang Zhang415f2282011-01-26 12:12:13 -0800717 if (++count == vmxferpage_packet->range_cnt + 1)
Hank Janssenfceaf242009-07-13 15:34:54 -0700718 break;
719 }
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800720 spin_unlock_irqrestore(&net_device->recv_pkt_list_lock, flags);
Hank Janssenfceaf242009-07-13 15:34:54 -0700721
Bill Pemberton454f18a2009-07-27 16:47:24 -0400722 /*
723 * We need at least 2 netvsc pkts (1 to represent the xfer
724 * page and at least 1 for the range) i.e. we can handled
725 * some of the xfer page packet ranges...
726 */
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700727 if (count < 2) {
Haiyang Zhangd9871152011-09-01 12:19:41 -0700728 netdev_err(ndev, "Got only %d netvsc pkt...needed "
Haiyang Zhangc909ebb2011-09-01 12:19:40 -0700729 "%d pkts. Dropping this xfer page packet completely!\n",
Hank Jansseneb335bc2011-03-29 13:58:48 -0700730 count, vmxferpage_packet->range_cnt + 1);
Hank Janssenfceaf242009-07-13 15:34:54 -0700731
Bill Pemberton454f18a2009-07-27 16:47:24 -0400732 /* Return it to the freelist */
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800733 spin_lock_irqsave(&net_device->recv_pkt_list_lock, flags);
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700734 for (i = count; i != 0; i--) {
Milan Dadok92ec0892009-10-28 23:23:37 +0100735 list_move_tail(listHead.next,
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800736 &net_device->recv_pkt_list);
Hank Janssenfceaf242009-07-13 15:34:54 -0700737 }
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800738 spin_unlock_irqrestore(&net_device->recv_pkt_list_lock,
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700739 flags);
Hank Janssenfceaf242009-07-13 15:34:54 -0700740
Haiyang Zhang5a71ae32010-12-10 12:03:55 -0800741 netvsc_send_recv_completion(device,
Haiyang Zhang63f69212012-10-02 05:30:23 +0000742 vmxferpage_packet->d.trans_id,
743 NVSP_STAT_FAIL);
Hank Janssenfceaf242009-07-13 15:34:54 -0700744
Hank Janssenfceaf242009-07-13 15:34:54 -0700745 return;
746 }
747
Bill Pemberton454f18a2009-07-27 16:47:24 -0400748 /* Remove the 1st packet to represent the xfer page packet itself */
Haiyang Zhang85799a32010-12-10 12:03:54 -0800749 xferpage_packet = (struct xferpage_packet *)listHead.next;
Haiyang Zhang72a2f5b2010-12-10 12:03:58 -0800750 list_del(&xferpage_packet->list_ent);
Haiyang Zhang63f69212012-10-02 05:30:23 +0000751 xferpage_packet->status = NVSP_STAT_SUCCESS;
Bill Pembertond29274e2009-09-11 21:46:43 -0400752
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700753 /* This is how much we can satisfy */
Haiyang Zhang72a2f5b2010-12-10 12:03:58 -0800754 xferpage_packet->count = count - 1;
Hank Janssenfceaf242009-07-13 15:34:54 -0700755
Haiyang Zhang415f2282011-01-26 12:12:13 -0800756 if (xferpage_packet->count != vmxferpage_packet->range_cnt) {
Haiyang Zhang8bff33a2011-09-01 12:19:48 -0700757 netdev_err(ndev, "Needed %d netvsc pkts to satisfy "
Haiyang Zhangc909ebb2011-09-01 12:19:40 -0700758 "this xfer page...got %d\n",
Hank Jansseneb335bc2011-03-29 13:58:48 -0700759 vmxferpage_packet->range_cnt, xferpage_packet->count);
Hank Janssenfceaf242009-07-13 15:34:54 -0700760 }
761
Bill Pemberton454f18a2009-07-27 16:47:24 -0400762 /* Each range represents 1 RNDIS pkt that contains 1 ethernet frame */
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700763 for (i = 0; i < (count - 1); i++) {
Haiyang Zhang85799a32010-12-10 12:03:54 -0800764 netvsc_packet = (struct hv_netvsc_packet *)listHead.next;
Haiyang Zhang72a2f5b2010-12-10 12:03:58 -0800765 list_del(&netvsc_packet->list_ent);
Hank Janssenfceaf242009-07-13 15:34:54 -0700766
Bill Pemberton454f18a2009-07-27 16:47:24 -0400767 /* Initialize the netvsc packet */
Haiyang Zhang63f69212012-10-02 05:30:23 +0000768 netvsc_packet->status = NVSP_STAT_SUCCESS;
Haiyang Zhang72a2f5b2010-12-10 12:03:58 -0800769 netvsc_packet->xfer_page_pkt = xferpage_packet;
770 netvsc_packet->completion.recv.recv_completion =
Haiyang Zhang5a71ae32010-12-10 12:03:55 -0800771 netvsc_receive_completion;
Haiyang Zhang72a2f5b2010-12-10 12:03:58 -0800772 netvsc_packet->completion.recv.recv_completion_ctx =
Haiyang Zhang85799a32010-12-10 12:03:54 -0800773 netvsc_packet;
Haiyang Zhang72a2f5b2010-12-10 12:03:58 -0800774 netvsc_packet->device = device;
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700775 /* Save this so that we can send it back */
Haiyang Zhang72a2f5b2010-12-10 12:03:58 -0800776 netvsc_packet->completion.recv.recv_completion_tid =
Haiyang Zhang415f2282011-01-26 12:12:13 -0800777 vmxferpage_packet->d.trans_id;
Hank Janssenfceaf242009-07-13 15:34:54 -0700778
Haiyang Zhang45326342011-12-15 13:45:15 -0800779 netvsc_packet->data = (void *)((unsigned long)net_device->
780 recv_buf + vmxferpage_packet->ranges[i].byte_offset);
Haiyang Zhang72a2f5b2010-12-10 12:03:58 -0800781 netvsc_packet->total_data_buflen =
Haiyang Zhang415f2282011-01-26 12:12:13 -0800782 vmxferpage_packet->ranges[i].byte_count;
Hank Janssenfceaf242009-07-13 15:34:54 -0700783
Bill Pemberton454f18a2009-07-27 16:47:24 -0400784 /* Pass it to the upper layer */
K. Y. Srinivasanac6f7852011-05-12 19:34:58 -0700785 rndis_filter_receive(device, netvsc_packet);
Hank Janssenfceaf242009-07-13 15:34:54 -0700786
Haiyang Zhang5a71ae32010-12-10 12:03:55 -0800787 netvsc_receive_completion(netvsc_packet->
Haiyang Zhang72a2f5b2010-12-10 12:03:58 -0800788 completion.recv.recv_completion_ctx);
Hank Janssenfceaf242009-07-13 15:34:54 -0700789 }
790
Hank Janssenfceaf242009-07-13 15:34:54 -0700791}
792
Haiyang Zhang5a71ae32010-12-10 12:03:55 -0800793static void netvsc_channel_cb(void *context)
Hank Janssenfceaf242009-07-13 15:34:54 -0700794{
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700795 int ret;
Haiyang Zhang85799a32010-12-10 12:03:54 -0800796 struct hv_device *device = context;
797 struct netvsc_device *net_device;
798 u32 bytes_recvd;
799 u64 request_id;
Bill Pembertonc6fcf0b2010-04-27 16:23:47 -0400800 unsigned char *packet;
Greg Kroah-Hartman8dc0a062009-08-27 16:02:36 -0700801 struct vmpacket_descriptor *desc;
Bill Pembertonc6fcf0b2010-04-27 16:23:47 -0400802 unsigned char *buffer;
803 int bufferlen = NETVSC_PACKET_SIZE;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700804 struct net_device *ndev;
Hank Janssenfceaf242009-07-13 15:34:54 -0700805
Bill Pembertonc6fcf0b2010-04-27 16:23:47 -0400806 packet = kzalloc(NETVSC_PACKET_SIZE * sizeof(unsigned char),
Timo Teräsd70c6732010-12-17 11:40:24 +0200807 GFP_ATOMIC);
Bill Pembertonc6fcf0b2010-04-27 16:23:47 -0400808 if (!packet)
809 return;
810 buffer = packet;
811
Haiyang Zhang5a71ae32010-12-10 12:03:55 -0800812 net_device = get_inbound_net_device(device);
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700813 if (!net_device)
Bill Pembertonc6fcf0b2010-04-27 16:23:47 -0400814 goto out;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700815 ndev = net_device->ndev;
Hank Janssenfceaf242009-07-13 15:34:54 -0700816
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700817 do {
Greg Kroah-Hartman9f630062010-10-21 09:09:48 -0700818 ret = vmbus_recvpacket_raw(device->channel, buffer, bufferlen,
Haiyang Zhang85799a32010-12-10 12:03:54 -0800819 &bytes_recvd, &request_id);
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700820 if (ret == 0) {
Haiyang Zhang85799a32010-12-10 12:03:54 -0800821 if (bytes_recvd > 0) {
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700822 desc = (struct vmpacket_descriptor *)buffer;
Haiyang Zhang415f2282011-01-26 12:12:13 -0800823 switch (desc->type) {
824 case VM_PKT_COMP:
Haiyang Zhang5a71ae32010-12-10 12:03:55 -0800825 netvsc_send_completion(device, desc);
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700826 break;
Hank Janssenfceaf242009-07-13 15:34:54 -0700827
Haiyang Zhang415f2282011-01-26 12:12:13 -0800828 case VM_PKT_DATA_USING_XFER_PAGES:
Haiyang Zhang5a71ae32010-12-10 12:03:55 -0800829 netvsc_receive(device, desc);
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700830 break;
Hank Janssenfceaf242009-07-13 15:34:54 -0700831
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700832 default:
Haiyang Zhangd9871152011-09-01 12:19:41 -0700833 netdev_err(ndev,
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700834 "unhandled packet type %d, "
835 "tid %llx len %d\n",
Haiyang Zhang415f2282011-01-26 12:12:13 -0800836 desc->type, request_id,
Haiyang Zhang85799a32010-12-10 12:03:54 -0800837 bytes_recvd);
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700838 break;
Hank Janssenfceaf242009-07-13 15:34:54 -0700839 }
840
Bill Pemberton454f18a2009-07-27 16:47:24 -0400841 /* reset */
Bill Pembertonc6fcf0b2010-04-27 16:23:47 -0400842 if (bufferlen > NETVSC_PACKET_SIZE) {
Greg Kroah-Hartman8c69f522009-07-15 12:48:29 -0700843 kfree(buffer);
Hank Janssenfceaf242009-07-13 15:34:54 -0700844 buffer = packet;
Bill Pembertonc6fcf0b2010-04-27 16:23:47 -0400845 bufferlen = NETVSC_PACKET_SIZE;
Hank Janssenfceaf242009-07-13 15:34:54 -0700846 }
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700847 } else {
Bill Pemberton454f18a2009-07-27 16:47:24 -0400848 /* reset */
Bill Pembertonc6fcf0b2010-04-27 16:23:47 -0400849 if (bufferlen > NETVSC_PACKET_SIZE) {
Greg Kroah-Hartman8c69f522009-07-15 12:48:29 -0700850 kfree(buffer);
Hank Janssenfceaf242009-07-13 15:34:54 -0700851 buffer = packet;
Bill Pembertonc6fcf0b2010-04-27 16:23:47 -0400852 bufferlen = NETVSC_PACKET_SIZE;
Hank Janssenfceaf242009-07-13 15:34:54 -0700853 }
854
855 break;
856 }
K. Y. Srinivasan3d5cad92011-08-25 09:48:59 -0700857 } else if (ret == -ENOBUFS) {
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700858 /* Handle large packet */
Haiyang Zhang85799a32010-12-10 12:03:54 -0800859 buffer = kmalloc(bytes_recvd, GFP_ATOMIC);
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700860 if (buffer == NULL) {
Bill Pemberton454f18a2009-07-27 16:47:24 -0400861 /* Try again next time around */
Haiyang Zhangd9871152011-09-01 12:19:41 -0700862 netdev_err(ndev,
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700863 "unable to allocate buffer of size "
Haiyang Zhangc909ebb2011-09-01 12:19:40 -0700864 "(%d)!!\n", bytes_recvd);
Hank Janssenfceaf242009-07-13 15:34:54 -0700865 break;
866 }
867
Haiyang Zhang85799a32010-12-10 12:03:54 -0800868 bufferlen = bytes_recvd;
Hank Janssenfceaf242009-07-13 15:34:54 -0700869 }
870 } while (1);
871
Bill Pembertonc6fcf0b2010-04-27 16:23:47 -0400872out:
873 kfree(buffer);
Hank Janssenfceaf242009-07-13 15:34:54 -0700874 return;
875}
Haiyang Zhangaf24ce42011-04-21 12:30:40 -0700876
877/*
Haiyang Zhangb637e022011-04-21 12:30:45 -0700878 * netvsc_device_add - Callback when the device belonging to this
879 * driver is added
880 */
K. Y. Srinivasan7bd23a42011-05-10 07:54:53 -0700881int netvsc_device_add(struct hv_device *device, void *additional_info)
Haiyang Zhangb637e022011-04-21 12:30:45 -0700882{
883 int ret = 0;
884 int i;
K. Y. Srinivasanaae23982011-05-12 19:35:05 -0700885 int ring_size =
886 ((struct netvsc_device_info *)additional_info)->ring_size;
Haiyang Zhangb637e022011-04-21 12:30:45 -0700887 struct netvsc_device *net_device;
888 struct hv_netvsc_packet *packet, *pos;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700889 struct net_device *ndev;
Haiyang Zhangb637e022011-04-21 12:30:45 -0700890
891 net_device = alloc_net_device(device);
892 if (!net_device) {
K. Y. Srinivasanace163a2011-08-25 09:49:16 -0700893 ret = -ENOMEM;
Haiyang Zhangb637e022011-04-21 12:30:45 -0700894 goto cleanup;
895 }
896
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700897 /*
898 * Coming into this function, struct net_device * is
899 * registered as the driver private data.
900 * In alloc_net_device(), we register struct netvsc_device *
901 * as the driver private data and stash away struct net_device *
902 * in struct netvsc_device *.
903 */
904 ndev = net_device->ndev;
905
Haiyang Zhangb637e022011-04-21 12:30:45 -0700906 /* Initialize the NetVSC channel extension */
907 net_device->recv_buf_size = NETVSC_RECEIVE_BUFFER_SIZE;
908 spin_lock_init(&net_device->recv_pkt_list_lock);
909
Haiyang Zhangb637e022011-04-21 12:30:45 -0700910 INIT_LIST_HEAD(&net_device->recv_pkt_list);
911
912 for (i = 0; i < NETVSC_RECEIVE_PACKETLIST_COUNT; i++) {
Haiyang Zhang65626402012-10-02 05:30:22 +0000913 packet = kzalloc(sizeof(struct hv_netvsc_packet), GFP_KERNEL);
Haiyang Zhangb637e022011-04-21 12:30:45 -0700914 if (!packet)
915 break;
916
917 list_add_tail(&packet->list_ent,
918 &net_device->recv_pkt_list);
919 }
K. Y. Srinivasan35abb212011-05-10 07:55:41 -0700920 init_completion(&net_device->channel_init_wait);
Haiyang Zhangb637e022011-04-21 12:30:45 -0700921
922 /* Open the channel */
K. Y. Srinivasanaae23982011-05-12 19:35:05 -0700923 ret = vmbus_open(device->channel, ring_size * PAGE_SIZE,
924 ring_size * PAGE_SIZE, NULL, 0,
Haiyang Zhangb637e022011-04-21 12:30:45 -0700925 netvsc_channel_cb, device);
926
927 if (ret != 0) {
Haiyang Zhangd9871152011-09-01 12:19:41 -0700928 netdev_err(ndev, "unable to open channel: %d\n", ret);
Haiyang Zhangb637e022011-04-21 12:30:45 -0700929 goto cleanup;
930 }
931
932 /* Channel is opened */
Haiyang Zhangc909ebb2011-09-01 12:19:40 -0700933 pr_info("hv_netvsc channel opened successfully\n");
Haiyang Zhangb637e022011-04-21 12:30:45 -0700934
935 /* Connect with the NetVsp */
936 ret = netvsc_connect_vsp(device);
937 if (ret != 0) {
Haiyang Zhangd9871152011-09-01 12:19:41 -0700938 netdev_err(ndev,
Haiyang Zhangc909ebb2011-09-01 12:19:40 -0700939 "unable to connect to NetVSP - %d\n", ret);
Haiyang Zhangb637e022011-04-21 12:30:45 -0700940 goto close;
941 }
942
943 return ret;
944
945close:
946 /* Now, we can close the channel safely */
947 vmbus_close(device->channel);
948
949cleanup:
950
951 if (net_device) {
952 list_for_each_entry_safe(packet, pos,
953 &net_device->recv_pkt_list,
954 list_ent) {
955 list_del(&packet->list_ent);
956 kfree(packet);
957 }
958
K. Y. Srinivasan356c4652011-08-27 11:31:10 -0700959 kfree(net_device);
Haiyang Zhangb637e022011-04-21 12:30:45 -0700960 }
961
962 return ret;
963}