blob: 7d76c9523395e5b5137784189d902d9cb1ecaed5 [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
Jeff Kirsheradf8d3f2013-12-06 06:28:47 -080014 * this program; if not, see <http://www.gnu.org/licenses/>.
Hank Janssenfceaf242009-07-13 15:34:54 -070015 *
16 * Authors:
Haiyang Zhangd0e94d12009-11-23 17:00:22 +000017 * Haiyang Zhang <haiyangz@microsoft.com>
Hank Janssenfceaf242009-07-13 15:34:54 -070018 * Hank Janssen <hjanssen@microsoft.com>
Hank Janssenfceaf242009-07-13 15:34:54 -070019 */
Hank Jansseneb335bc2011-03-29 13:58:48 -070020#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
21
Greg Kroah-Hartman5654e932009-07-14 15:08:20 -070022#include <linux/kernel.h>
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -080023#include <linux/sched.h>
24#include <linux/wait.h>
Greg Kroah-Hartman0ffa63b2009-07-15 11:06:01 -070025#include <linux/mm.h>
Greg Kroah-Hartmanb4362c92009-07-16 11:50:41 -070026#include <linux/delay.h>
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -070027#include <linux/io.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090028#include <linux/slab.h>
Haiyang Zhangd9871152011-09-01 12:19:41 -070029#include <linux/netdevice.h>
Haiyang Zhangf157e782011-12-15 13:45:16 -080030#include <linux/if_ether.h>
KY Srinivasanc25aaf82014-04-30 10:14:31 -070031#include <asm/sync_bitops.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 Zhangf90251c2014-08-15 19:18:19 +000045 net_device->cb_buffer = kzalloc(NETVSC_PACKET_SIZE, GFP_KERNEL);
46 if (!net_device->cb_buffer) {
47 kfree(net_device);
48 return NULL;
49 }
50
Haiyang Zhangdc5cd892012-06-04 06:42:38 +000051 init_waitqueue_head(&net_device->wait_drain);
Haiyang Zhang4d447c92011-12-15 13:45:17 -080052 net_device->start_remove = false;
K. Y. Srinivasanc38b9c72011-08-27 11:31:12 -070053 net_device->destroy = false;
Haiyang Zhang53d21fd2010-12-10 12:03:59 -080054 net_device->dev = device;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -070055 net_device->ndev = ndev;
Hank Janssenfceaf242009-07-13 15:34:54 -070056
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -070057 hv_set_drvdata(device, net_device);
Haiyang Zhang85799a32010-12-10 12:03:54 -080058 return net_device;
Hank Janssenfceaf242009-07-13 15:34:54 -070059}
60
Haiyang Zhangf90251c2014-08-15 19:18:19 +000061static void free_netvsc_device(struct netvsc_device *nvdev)
62{
63 kfree(nvdev->cb_buffer);
64 kfree(nvdev);
65}
66
Haiyang Zhang5a71ae32010-12-10 12:03:55 -080067static struct netvsc_device *get_outbound_net_device(struct hv_device *device)
Hank Janssenfceaf242009-07-13 15:34:54 -070068{
Haiyang Zhang85799a32010-12-10 12:03:54 -080069 struct netvsc_device *net_device;
Hank Janssenfceaf242009-07-13 15:34:54 -070070
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -070071 net_device = hv_get_drvdata(device);
K. Y. Srinivasan9d88f332011-08-27 11:31:16 -070072 if (net_device && net_device->destroy)
Haiyang Zhang85799a32010-12-10 12:03:54 -080073 net_device = NULL;
Hank Janssenfceaf242009-07-13 15:34:54 -070074
Haiyang Zhang85799a32010-12-10 12:03:54 -080075 return net_device;
Hank Janssenfceaf242009-07-13 15:34:54 -070076}
77
Haiyang Zhang5a71ae32010-12-10 12:03:55 -080078static struct netvsc_device *get_inbound_net_device(struct hv_device *device)
Hank Janssenfceaf242009-07-13 15:34:54 -070079{
Haiyang Zhang85799a32010-12-10 12:03:54 -080080 struct netvsc_device *net_device;
Hank Janssenfceaf242009-07-13 15:34:54 -070081
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -070082 net_device = hv_get_drvdata(device);
K. Y. Srinivasan9d88f332011-08-27 11:31:16 -070083
84 if (!net_device)
85 goto get_in_err;
86
87 if (net_device->destroy &&
88 atomic_read(&net_device->num_outstanding_sends) == 0)
Haiyang Zhang85799a32010-12-10 12:03:54 -080089 net_device = NULL;
Hank Janssenfceaf242009-07-13 15:34:54 -070090
K. Y. Srinivasan9d88f332011-08-27 11:31:16 -070091get_in_err:
Haiyang Zhang85799a32010-12-10 12:03:54 -080092 return net_device;
Hank Janssenfceaf242009-07-13 15:34:54 -070093}
94
Hank Janssenfceaf242009-07-13 15:34:54 -070095
KY Srinivasanc25aaf82014-04-30 10:14:31 -070096static int netvsc_destroy_buf(struct netvsc_device *net_device)
Haiyang Zhangec91cd02011-04-21 12:30:43 -070097{
98 struct nvsp_message *revoke_packet;
99 int ret = 0;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700100 struct net_device *ndev = net_device->ndev;
Haiyang Zhangec91cd02011-04-21 12:30:43 -0700101
102 /*
103 * If we got a section count, it means we received a
104 * SendReceiveBufferComplete msg (ie sent
105 * NvspMessage1TypeSendReceiveBuffer msg) therefore, we need
106 * to send a revoke msg here
107 */
108 if (net_device->recv_section_cnt) {
109 /* Send the revoke receive buffer */
110 revoke_packet = &net_device->revoke_packet;
111 memset(revoke_packet, 0, sizeof(struct nvsp_message));
112
113 revoke_packet->hdr.msg_type =
114 NVSP_MSG1_TYPE_REVOKE_RECV_BUF;
115 revoke_packet->msg.v1_msg.
116 revoke_recv_buf.id = NETVSC_RECEIVE_BUFFER_ID;
117
118 ret = vmbus_sendpacket(net_device->dev->channel,
119 revoke_packet,
120 sizeof(struct nvsp_message),
121 (unsigned long)revoke_packet,
122 VM_PKT_DATA_INBAND, 0);
123 /*
124 * If we failed here, we might as well return and
125 * have a leak rather than continue and a bugchk
126 */
127 if (ret != 0) {
Haiyang Zhangd9871152011-09-01 12:19:41 -0700128 netdev_err(ndev, "unable to send "
Haiyang Zhangc909ebb2011-09-01 12:19:40 -0700129 "revoke receive buffer to netvsp\n");
K. Y. Srinivasana3e00532011-08-25 09:49:12 -0700130 return ret;
Haiyang Zhangec91cd02011-04-21 12:30:43 -0700131 }
132 }
133
134 /* Teardown the gpadl on the vsp end */
135 if (net_device->recv_buf_gpadl_handle) {
136 ret = vmbus_teardown_gpadl(net_device->dev->channel,
137 net_device->recv_buf_gpadl_handle);
138
139 /* If we failed here, we might as well return and have a leak
140 * rather than continue and a bugchk
141 */
142 if (ret != 0) {
Haiyang Zhangd9871152011-09-01 12:19:41 -0700143 netdev_err(ndev,
Haiyang Zhangc909ebb2011-09-01 12:19:40 -0700144 "unable to teardown receive buffer's gpadl\n");
Dan Carpenter7f9615e2011-08-27 14:06:07 +0300145 return ret;
Haiyang Zhangec91cd02011-04-21 12:30:43 -0700146 }
147 net_device->recv_buf_gpadl_handle = 0;
148 }
149
150 if (net_device->recv_buf) {
151 /* Free up the receive buffer */
Haiyang Zhangb679ef72014-01-27 15:03:42 -0800152 vfree(net_device->recv_buf);
Haiyang Zhangec91cd02011-04-21 12:30:43 -0700153 net_device->recv_buf = NULL;
154 }
155
156 if (net_device->recv_section) {
157 net_device->recv_section_cnt = 0;
158 kfree(net_device->recv_section);
159 net_device->recv_section = NULL;
160 }
161
KY Srinivasanc25aaf82014-04-30 10:14:31 -0700162 /* Deal with the send buffer we may have setup.
163 * If we got a send section size, it means we received a
164 * SendsendBufferComplete msg (ie sent
165 * NvspMessage1TypeSendReceiveBuffer msg) therefore, we need
166 * to send a revoke msg here
167 */
168 if (net_device->send_section_size) {
169 /* Send the revoke receive buffer */
170 revoke_packet = &net_device->revoke_packet;
171 memset(revoke_packet, 0, sizeof(struct nvsp_message));
172
173 revoke_packet->hdr.msg_type =
174 NVSP_MSG1_TYPE_REVOKE_SEND_BUF;
175 revoke_packet->msg.v1_msg.revoke_recv_buf.id = 0;
176
177 ret = vmbus_sendpacket(net_device->dev->channel,
178 revoke_packet,
179 sizeof(struct nvsp_message),
180 (unsigned long)revoke_packet,
181 VM_PKT_DATA_INBAND, 0);
182 /* If we failed here, we might as well return and
183 * have a leak rather than continue and a bugchk
184 */
185 if (ret != 0) {
186 netdev_err(ndev, "unable to send "
187 "revoke send buffer to netvsp\n");
188 return ret;
189 }
190 }
191 /* Teardown the gpadl on the vsp end */
192 if (net_device->send_buf_gpadl_handle) {
193 ret = vmbus_teardown_gpadl(net_device->dev->channel,
194 net_device->send_buf_gpadl_handle);
195
196 /* If we failed here, we might as well return and have a leak
197 * rather than continue and a bugchk
198 */
199 if (ret != 0) {
200 netdev_err(ndev,
201 "unable to teardown send buffer's gpadl\n");
202 return ret;
203 }
Dave Jones2f184232014-06-16 16:59:02 -0400204 net_device->send_buf_gpadl_handle = 0;
KY Srinivasanc25aaf82014-04-30 10:14:31 -0700205 }
206 if (net_device->send_buf) {
207 /* Free up the receive buffer */
KY Srinivasan06b47aa2014-08-02 10:42:02 -0700208 vfree(net_device->send_buf);
KY Srinivasanc25aaf82014-04-30 10:14:31 -0700209 net_device->send_buf = NULL;
210 }
211 kfree(net_device->send_section_map);
212
Haiyang Zhangec91cd02011-04-21 12:30:43 -0700213 return ret;
214}
215
KY Srinivasanc25aaf82014-04-30 10:14:31 -0700216static int netvsc_init_buf(struct hv_device *device)
Hank Janssenfceaf242009-07-13 15:34:54 -0700217{
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700218 int ret = 0;
K. Y. Srinivasan35abb212011-05-10 07:55:41 -0700219 int t;
Haiyang Zhang85799a32010-12-10 12:03:54 -0800220 struct netvsc_device *net_device;
221 struct nvsp_message *init_packet;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700222 struct net_device *ndev;
Hank Janssenfceaf242009-07-13 15:34:54 -0700223
Haiyang Zhang5a71ae32010-12-10 12:03:55 -0800224 net_device = get_outbound_net_device(device);
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700225 if (!net_device)
K. Y. Srinivasan927bc332011-08-25 09:49:13 -0700226 return -ENODEV;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700227 ndev = net_device->ndev;
Hank Janssenfceaf242009-07-13 15:34:54 -0700228
Haiyang Zhangb679ef72014-01-27 15:03:42 -0800229 net_device->recv_buf = vzalloc(net_device->recv_buf_size);
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800230 if (!net_device->recv_buf) {
Haiyang Zhangd9871152011-09-01 12:19:41 -0700231 netdev_err(ndev, "unable to allocate receive "
Haiyang Zhangc909ebb2011-09-01 12:19:40 -0700232 "buffer of size %d\n", net_device->recv_buf_size);
K. Y. Srinivasan927bc332011-08-25 09:49:13 -0700233 ret = -ENOMEM;
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -0800234 goto cleanup;
Hank Janssenfceaf242009-07-13 15:34:54 -0700235 }
Hank Janssenfceaf242009-07-13 15:34:54 -0700236
Bill Pemberton454f18a2009-07-27 16:47:24 -0400237 /*
238 * Establish the gpadl handle for this buffer on this
239 * channel. Note: This call uses the vmbus connection rather
240 * than the channel to establish the gpadl handle.
241 */
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800242 ret = vmbus_establish_gpadl(device->channel, net_device->recv_buf,
243 net_device->recv_buf_size,
244 &net_device->recv_buf_gpadl_handle);
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700245 if (ret != 0) {
Haiyang Zhangd9871152011-09-01 12:19:41 -0700246 netdev_err(ndev,
Haiyang Zhangc909ebb2011-09-01 12:19:40 -0700247 "unable to establish receive buffer's gpadl\n");
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -0800248 goto cleanup;
Hank Janssenfceaf242009-07-13 15:34:54 -0700249 }
250
Hank Janssenfceaf242009-07-13 15:34:54 -0700251
Bill Pemberton454f18a2009-07-27 16:47:24 -0400252 /* Notify the NetVsp of the gpadl handle */
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800253 init_packet = &net_device->channel_init_pkt;
Hank Janssenfceaf242009-07-13 15:34:54 -0700254
Haiyang Zhang85799a32010-12-10 12:03:54 -0800255 memset(init_packet, 0, sizeof(struct nvsp_message));
Hank Janssenfceaf242009-07-13 15:34:54 -0700256
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800257 init_packet->hdr.msg_type = NVSP_MSG1_TYPE_SEND_RECV_BUF;
258 init_packet->msg.v1_msg.send_recv_buf.
259 gpadl_handle = net_device->recv_buf_gpadl_handle;
260 init_packet->msg.v1_msg.
261 send_recv_buf.id = NETVSC_RECEIVE_BUFFER_ID;
Hank Janssenfceaf242009-07-13 15:34:54 -0700262
Bill Pemberton454f18a2009-07-27 16:47:24 -0400263 /* Send the gpadl notification request */
Haiyang Zhang85799a32010-12-10 12:03:54 -0800264 ret = vmbus_sendpacket(device->channel, init_packet,
Greg Kroah-Hartman5a4df292010-10-21 09:43:24 -0700265 sizeof(struct nvsp_message),
Haiyang Zhang85799a32010-12-10 12:03:54 -0800266 (unsigned long)init_packet,
Haiyang Zhang415f2282011-01-26 12:12:13 -0800267 VM_PKT_DATA_INBAND,
Greg Kroah-Hartman5a4df292010-10-21 09:43:24 -0700268 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700269 if (ret != 0) {
Haiyang Zhangd9871152011-09-01 12:19:41 -0700270 netdev_err(ndev,
Haiyang Zhangc909ebb2011-09-01 12:19:40 -0700271 "unable to send receive buffer's gpadl to netvsp\n");
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -0800272 goto cleanup;
Hank Janssenfceaf242009-07-13 15:34:54 -0700273 }
274
K. Y. Srinivasan5c5781b32011-06-16 13:16:35 -0700275 t = wait_for_completion_timeout(&net_device->channel_init_wait, 5*HZ);
K. Y. Srinivasan35abb212011-05-10 07:55:41 -0700276 BUG_ON(t == 0);
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -0800277
Hank Janssenfceaf242009-07-13 15:34:54 -0700278
Bill Pemberton454f18a2009-07-27 16:47:24 -0400279 /* Check the response */
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800280 if (init_packet->msg.v1_msg.
281 send_recv_buf_complete.status != NVSP_STAT_SUCCESS) {
Haiyang Zhangd9871152011-09-01 12:19:41 -0700282 netdev_err(ndev, "Unable to complete receive buffer "
Haiyang Zhang8bff33a2011-09-01 12:19:48 -0700283 "initialization with NetVsp - status %d\n",
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800284 init_packet->msg.v1_msg.
285 send_recv_buf_complete.status);
K. Y. Srinivasan927bc332011-08-25 09:49:13 -0700286 ret = -EINVAL;
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -0800287 goto cleanup;
Hank Janssenfceaf242009-07-13 15:34:54 -0700288 }
289
Bill Pemberton454f18a2009-07-27 16:47:24 -0400290 /* Parse the response */
Hank Janssenfceaf242009-07-13 15:34:54 -0700291
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800292 net_device->recv_section_cnt = init_packet->msg.
293 v1_msg.send_recv_buf_complete.num_sections;
Hank Janssenfceaf242009-07-13 15:34:54 -0700294
Haiyang Zhangc1813202011-11-30 07:19:07 -0800295 net_device->recv_section = kmemdup(
296 init_packet->msg.v1_msg.send_recv_buf_complete.sections,
297 net_device->recv_section_cnt *
298 sizeof(struct nvsp_1_receive_buffer_section),
299 GFP_KERNEL);
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800300 if (net_device->recv_section == NULL) {
K. Y. Srinivasan927bc332011-08-25 09:49:13 -0700301 ret = -EINVAL;
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -0800302 goto cleanup;
Hank Janssenfceaf242009-07-13 15:34:54 -0700303 }
304
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700305 /*
306 * For 1st release, there should only be 1 section that represents the
307 * entire receive buffer
308 */
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800309 if (net_device->recv_section_cnt != 1 ||
310 net_device->recv_section->offset != 0) {
K. Y. Srinivasan927bc332011-08-25 09:49:13 -0700311 ret = -EINVAL;
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -0800312 goto cleanup;
Hank Janssenfceaf242009-07-13 15:34:54 -0700313 }
314
KY Srinivasanc25aaf82014-04-30 10:14:31 -0700315 /* Now setup the send buffer.
316 */
KY Srinivasan06b47aa2014-08-02 10:42:02 -0700317 net_device->send_buf = vzalloc(net_device->send_buf_size);
KY Srinivasanc25aaf82014-04-30 10:14:31 -0700318 if (!net_device->send_buf) {
319 netdev_err(ndev, "unable to allocate send "
320 "buffer of size %d\n", net_device->send_buf_size);
321 ret = -ENOMEM;
322 goto cleanup;
323 }
324
325 /* Establish the gpadl handle for this buffer on this
326 * channel. Note: This call uses the vmbus connection rather
327 * than the channel to establish the gpadl handle.
328 */
329 ret = vmbus_establish_gpadl(device->channel, net_device->send_buf,
330 net_device->send_buf_size,
331 &net_device->send_buf_gpadl_handle);
332 if (ret != 0) {
333 netdev_err(ndev,
334 "unable to establish send buffer's gpadl\n");
335 goto cleanup;
336 }
337
338 /* Notify the NetVsp of the gpadl handle */
339 init_packet = &net_device->channel_init_pkt;
340 memset(init_packet, 0, sizeof(struct nvsp_message));
341 init_packet->hdr.msg_type = NVSP_MSG1_TYPE_SEND_SEND_BUF;
342 init_packet->msg.v1_msg.send_recv_buf.gpadl_handle =
343 net_device->send_buf_gpadl_handle;
344 init_packet->msg.v1_msg.send_recv_buf.id = 0;
345
346 /* Send the gpadl notification request */
347 ret = vmbus_sendpacket(device->channel, init_packet,
348 sizeof(struct nvsp_message),
349 (unsigned long)init_packet,
350 VM_PKT_DATA_INBAND,
351 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
352 if (ret != 0) {
353 netdev_err(ndev,
354 "unable to send send buffer's gpadl to netvsp\n");
355 goto cleanup;
356 }
357
358 t = wait_for_completion_timeout(&net_device->channel_init_wait, 5*HZ);
359 BUG_ON(t == 0);
360
361 /* Check the response */
362 if (init_packet->msg.v1_msg.
363 send_send_buf_complete.status != NVSP_STAT_SUCCESS) {
364 netdev_err(ndev, "Unable to complete send buffer "
365 "initialization with NetVsp - status %d\n",
366 init_packet->msg.v1_msg.
367 send_recv_buf_complete.status);
368 ret = -EINVAL;
369 goto cleanup;
370 }
371
372 /* Parse the response */
373 net_device->send_section_size = init_packet->msg.
374 v1_msg.send_send_buf_complete.section_size;
375
376 /* Section count is simply the size divided by the section size.
377 */
378 net_device->send_section_cnt =
379 net_device->send_buf_size/net_device->send_section_size;
380
381 dev_info(&device->device, "Send section size: %d, Section count:%d\n",
382 net_device->send_section_size, net_device->send_section_cnt);
383
384 /* Setup state for managing the send buffer. */
385 net_device->map_words = DIV_ROUND_UP(net_device->send_section_cnt,
386 BITS_PER_LONG);
387
388 net_device->send_section_map =
389 kzalloc(net_device->map_words * sizeof(ulong), GFP_KERNEL);
Wei Yongjundd1d3f82014-07-23 09:00:35 +0800390 if (net_device->send_section_map == NULL) {
391 ret = -ENOMEM;
KY Srinivasanc25aaf82014-04-30 10:14:31 -0700392 goto cleanup;
Wei Yongjundd1d3f82014-07-23 09:00:35 +0800393 }
KY Srinivasanc25aaf82014-04-30 10:14:31 -0700394
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -0800395 goto exit;
Hank Janssenfceaf242009-07-13 15:34:54 -0700396
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -0800397cleanup:
KY Srinivasanc25aaf82014-04-30 10:14:31 -0700398 netvsc_destroy_buf(net_device);
Hank Janssenfceaf242009-07-13 15:34:54 -0700399
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -0800400exit:
Hank Janssenfceaf242009-07-13 15:34:54 -0700401 return ret;
402}
403
Hank Janssenfceaf242009-07-13 15:34:54 -0700404
Haiyang Zhangf157e782011-12-15 13:45:16 -0800405/* Negotiate NVSP protocol version */
406static int negotiate_nvsp_ver(struct hv_device *device,
407 struct netvsc_device *net_device,
408 struct nvsp_message *init_packet,
409 u32 nvsp_ver)
Hank Janssenfceaf242009-07-13 15:34:54 -0700410{
K. Y. Srinivasan35abb212011-05-10 07:55:41 -0700411 int ret, t;
Haiyang Zhangf157e782011-12-15 13:45:16 -0800412
413 memset(init_packet, 0, sizeof(struct nvsp_message));
414 init_packet->hdr.msg_type = NVSP_MSG_TYPE_INIT;
415 init_packet->msg.init_msg.init.min_protocol_ver = nvsp_ver;
416 init_packet->msg.init_msg.init.max_protocol_ver = nvsp_ver;
417
418 /* Send the init request */
419 ret = vmbus_sendpacket(device->channel, init_packet,
420 sizeof(struct nvsp_message),
421 (unsigned long)init_packet,
422 VM_PKT_DATA_INBAND,
423 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
424
425 if (ret != 0)
426 return ret;
427
428 t = wait_for_completion_timeout(&net_device->channel_init_wait, 5*HZ);
429
430 if (t == 0)
431 return -ETIMEDOUT;
432
433 if (init_packet->msg.init_msg.init_complete.status !=
434 NVSP_STAT_SUCCESS)
435 return -EINVAL;
436
Haiyang Zhanga1eabb02014-02-19 15:49:45 -0800437 if (nvsp_ver == NVSP_PROTOCOL_VERSION_1)
Haiyang Zhangf157e782011-12-15 13:45:16 -0800438 return 0;
439
440 /* NVSPv2 only: Send NDIS config */
441 memset(init_packet, 0, sizeof(struct nvsp_message));
442 init_packet->hdr.msg_type = NVSP_MSG2_TYPE_SEND_NDIS_CONFIG;
Haiyang Zhang4d447c92011-12-15 13:45:17 -0800443 init_packet->msg.v2_msg.send_ndis_config.mtu = net_device->ndev->mtu;
Haiyang Zhang1f5f3a72012-03-12 10:20:50 +0000444 init_packet->msg.v2_msg.send_ndis_config.capability.ieee8021q = 1;
Haiyang Zhangf157e782011-12-15 13:45:16 -0800445
446 ret = vmbus_sendpacket(device->channel, init_packet,
447 sizeof(struct nvsp_message),
448 (unsigned long)init_packet,
449 VM_PKT_DATA_INBAND, 0);
450
451 return ret;
452}
453
454static int netvsc_connect_vsp(struct hv_device *device)
455{
456 int ret;
Haiyang Zhang85799a32010-12-10 12:03:54 -0800457 struct netvsc_device *net_device;
458 struct nvsp_message *init_packet;
459 int ndis_version;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700460 struct net_device *ndev;
Haiyang Zhanga1eabb02014-02-19 15:49:45 -0800461 u32 ver_list[] = { NVSP_PROTOCOL_VERSION_1, NVSP_PROTOCOL_VERSION_2,
462 NVSP_PROTOCOL_VERSION_4, NVSP_PROTOCOL_VERSION_5 };
463 int i, num_ver = 4; /* number of different NVSP versions */
Hank Janssenfceaf242009-07-13 15:34:54 -0700464
Haiyang Zhang5a71ae32010-12-10 12:03:55 -0800465 net_device = get_outbound_net_device(device);
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700466 if (!net_device)
K. Y. Srinivasan0f48c722011-08-25 09:49:14 -0700467 return -ENODEV;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700468 ndev = net_device->ndev;
Hank Janssenfceaf242009-07-13 15:34:54 -0700469
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800470 init_packet = &net_device->channel_init_pkt;
Hank Janssenfceaf242009-07-13 15:34:54 -0700471
Haiyang Zhangf157e782011-12-15 13:45:16 -0800472 /* Negotiate the latest NVSP protocol supported */
Haiyang Zhanga1eabb02014-02-19 15:49:45 -0800473 for (i = num_ver - 1; i >= 0; i--)
474 if (negotiate_nvsp_ver(device, net_device, init_packet,
475 ver_list[i]) == 0) {
476 net_device->nvsp_version = ver_list[i];
477 break;
478 }
479
480 if (i < 0) {
K. Y. Srinivasan0f48c722011-08-25 09:49:14 -0700481 ret = -EPROTO;
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -0800482 goto cleanup;
Hank Janssenfceaf242009-07-13 15:34:54 -0700483 }
Haiyang Zhangf157e782011-12-15 13:45:16 -0800484
485 pr_debug("Negotiated NVSP version:%x\n", net_device->nvsp_version);
486
Bill Pemberton454f18a2009-07-27 16:47:24 -0400487 /* Send the ndis version */
Haiyang Zhang85799a32010-12-10 12:03:54 -0800488 memset(init_packet, 0, sizeof(struct nvsp_message));
Hank Janssenfceaf242009-07-13 15:34:54 -0700489
Haiyang Zhanga1eabb02014-02-19 15:49:45 -0800490 if (net_device->nvsp_version <= NVSP_PROTOCOL_VERSION_4)
KY Srinivasan1f73db42014-04-09 15:00:46 -0700491 ndis_version = 0x00060001;
Haiyang Zhanga1eabb02014-02-19 15:49:45 -0800492 else
493 ndis_version = 0x0006001e;
Hank Janssenfceaf242009-07-13 15:34:54 -0700494
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800495 init_packet->hdr.msg_type = NVSP_MSG1_TYPE_SEND_NDIS_VER;
496 init_packet->msg.v1_msg.
497 send_ndis_ver.ndis_major_ver =
Haiyang Zhang85799a32010-12-10 12:03:54 -0800498 (ndis_version & 0xFFFF0000) >> 16;
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800499 init_packet->msg.v1_msg.
500 send_ndis_ver.ndis_minor_ver =
Haiyang Zhang85799a32010-12-10 12:03:54 -0800501 ndis_version & 0xFFFF;
Hank Janssenfceaf242009-07-13 15:34:54 -0700502
Bill Pemberton454f18a2009-07-27 16:47:24 -0400503 /* Send the init request */
Haiyang Zhang85799a32010-12-10 12:03:54 -0800504 ret = vmbus_sendpacket(device->channel, init_packet,
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -0800505 sizeof(struct nvsp_message),
506 (unsigned long)init_packet,
507 VM_PKT_DATA_INBAND, 0);
K. Y. Srinivasan0f48c722011-08-25 09:49:14 -0700508 if (ret != 0)
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -0800509 goto cleanup;
Hank Janssenfceaf242009-07-13 15:34:54 -0700510
Bill Pemberton454f18a2009-07-27 16:47:24 -0400511 /* Post the big receive buffer to NetVSP */
Haiyang Zhang99d30162014-03-09 16:10:59 -0700512 if (net_device->nvsp_version <= NVSP_PROTOCOL_VERSION_2)
513 net_device->recv_buf_size = NETVSC_RECEIVE_BUFFER_SIZE_LEGACY;
514 else
515 net_device->recv_buf_size = NETVSC_RECEIVE_BUFFER_SIZE;
KY Srinivasanc25aaf82014-04-30 10:14:31 -0700516 net_device->send_buf_size = NETVSC_SEND_BUFFER_SIZE;
Haiyang Zhang99d30162014-03-09 16:10:59 -0700517
KY Srinivasanc25aaf82014-04-30 10:14:31 -0700518 ret = netvsc_init_buf(device);
Hank Janssenfceaf242009-07-13 15:34:54 -0700519
K. Y. Srinivasan0c3b7b22011-02-11 09:59:43 -0800520cleanup:
Hank Janssenfceaf242009-07-13 15:34:54 -0700521 return ret;
522}
523
Haiyang Zhang648dc592011-04-21 12:30:47 -0700524static void netvsc_disconnect_vsp(struct netvsc_device *net_device)
Hank Janssenfceaf242009-07-13 15:34:54 -0700525{
KY Srinivasanc25aaf82014-04-30 10:14:31 -0700526 netvsc_destroy_buf(net_device);
Hank Janssenfceaf242009-07-13 15:34:54 -0700527}
528
Hank Janssen3e189512010-03-04 22:11:00 +0000529/*
Haiyang Zhang5a71ae32010-12-10 12:03:55 -0800530 * netvsc_device_remove - Callback when the root bus device is removed
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700531 */
K. Y. Srinivasan905620d2011-05-10 07:54:54 -0700532int netvsc_device_remove(struct hv_device *device)
Hank Janssenfceaf242009-07-13 15:34:54 -0700533{
Haiyang Zhang85799a32010-12-10 12:03:54 -0800534 struct netvsc_device *net_device;
K. Y. Srinivasanc38b9c72011-08-27 11:31:12 -0700535 unsigned long flags;
Hank Janssenfceaf242009-07-13 15:34:54 -0700536
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700537 net_device = hv_get_drvdata(device);
Hank Janssenfceaf242009-07-13 15:34:54 -0700538
Haiyang Zhang648dc592011-04-21 12:30:47 -0700539 netvsc_disconnect_vsp(net_device);
Hank Janssenfceaf242009-07-13 15:34:54 -0700540
K. Y. Srinivasan38524092011-08-27 11:31:14 -0700541 /*
K. Y. Srinivasan9d88f332011-08-27 11:31:16 -0700542 * Since we have already drained, we don't need to busy wait
543 * as was done in final_release_stor_device()
544 * Note that we cannot set the ext pointer to NULL until
545 * we have drained - to drain the outgoing packets, we need to
546 * allow incoming packets.
K. Y. Srinivasan38524092011-08-27 11:31:14 -0700547 */
K. Y. Srinivasan9d88f332011-08-27 11:31:16 -0700548
549 spin_lock_irqsave(&device->channel->inbound_lock, flags);
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700550 hv_set_drvdata(device, NULL);
K. Y. Srinivasan9d88f332011-08-27 11:31:16 -0700551 spin_unlock_irqrestore(&device->channel->inbound_lock, flags);
K. Y. Srinivasan38524092011-08-27 11:31:14 -0700552
K. Y. Srinivasan86c921a2011-09-13 10:59:54 -0700553 /*
554 * At this point, no one should be accessing net_device
555 * except in here
556 */
Haiyang Zhangc909ebb2011-09-01 12:19:40 -0700557 dev_notice(&device->device, "net device safe to remove\n");
Hank Janssenfceaf242009-07-13 15:34:54 -0700558
Bill Pemberton454f18a2009-07-27 16:47:24 -0400559 /* Now, we can close the channel safely */
Haiyang Zhang85799a32010-12-10 12:03:54 -0800560 vmbus_close(device->channel);
Hank Janssenfceaf242009-07-13 15:34:54 -0700561
Bill Pemberton454f18a2009-07-27 16:47:24 -0400562 /* Release all resources */
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700563 if (net_device->sub_cb_buf)
564 vfree(net_device->sub_cb_buf);
565
Haiyang Zhangf90251c2014-08-15 19:18:19 +0000566 free_netvsc_device(net_device);
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700567 return 0;
Hank Janssenfceaf242009-07-13 15:34:54 -0700568}
569
Haiyang Zhang33be96e2012-03-27 13:20:45 +0000570
571#define RING_AVAIL_PERCENT_HIWATER 20
572#define RING_AVAIL_PERCENT_LOWATER 10
573
574/*
575 * Get the percentage of available bytes to write in the ring.
576 * The return value is in range from 0 to 100.
577 */
578static inline u32 hv_ringbuf_avail_percent(
579 struct hv_ring_buffer_info *ring_info)
580{
581 u32 avail_read, avail_write;
582
583 hv_get_ringbuffer_availbytes(ring_info, &avail_read, &avail_write);
584
585 return avail_write * 100 / ring_info->ring_datasize;
586}
587
KY Srinivasanc25aaf82014-04-30 10:14:31 -0700588static inline void netvsc_free_send_slot(struct netvsc_device *net_device,
589 u32 index)
590{
591 sync_change_bit(index, net_device->send_section_map);
592}
593
KY Srinivasan97c17232014-02-16 16:38:44 -0800594static void netvsc_send_completion(struct netvsc_device *net_device,
595 struct hv_device *device,
Haiyang Zhang85799a32010-12-10 12:03:54 -0800596 struct vmpacket_descriptor *packet)
Hank Janssenfceaf242009-07-13 15:34:54 -0700597{
Haiyang Zhang85799a32010-12-10 12:03:54 -0800598 struct nvsp_message *nvsp_packet;
599 struct hv_netvsc_packet *nvsc_packet;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700600 struct net_device *ndev;
KY Srinivasanc25aaf82014-04-30 10:14:31 -0700601 u32 send_index;
Hank Janssenfceaf242009-07-13 15:34:54 -0700602
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700603 ndev = net_device->ndev;
Hank Janssenfceaf242009-07-13 15:34:54 -0700604
Haiyang Zhang85799a32010-12-10 12:03:54 -0800605 nvsp_packet = (struct nvsp_message *)((unsigned long)packet +
Haiyang Zhang415f2282011-01-26 12:12:13 -0800606 (packet->offset8 << 3));
Hank Janssenfceaf242009-07-13 15:34:54 -0700607
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800608 if ((nvsp_packet->hdr.msg_type == NVSP_MSG_TYPE_INIT_COMPLETE) ||
609 (nvsp_packet->hdr.msg_type ==
610 NVSP_MSG1_TYPE_SEND_RECV_BUF_COMPLETE) ||
611 (nvsp_packet->hdr.msg_type ==
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700612 NVSP_MSG1_TYPE_SEND_SEND_BUF_COMPLETE) ||
613 (nvsp_packet->hdr.msg_type ==
614 NVSP_MSG5_TYPE_SUBCHANNEL)) {
Bill Pemberton454f18a2009-07-27 16:47:24 -0400615 /* Copy the response back */
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800616 memcpy(&net_device->channel_init_pkt, nvsp_packet,
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700617 sizeof(struct nvsp_message));
K. Y. Srinivasan35abb212011-05-10 07:55:41 -0700618 complete(&net_device->channel_init_wait);
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800619 } else if (nvsp_packet->hdr.msg_type ==
620 NVSP_MSG1_TYPE_SEND_RNDIS_PKT_COMPLETE) {
Haiyang Zhang33be96e2012-03-27 13:20:45 +0000621 int num_outstanding_sends;
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700622 u16 q_idx = 0;
623 struct vmbus_channel *channel = device->channel;
624 int queue_sends;
Haiyang Zhang33be96e2012-03-27 13:20:45 +0000625
Bill Pemberton454f18a2009-07-27 16:47:24 -0400626 /* Get the send context */
Haiyang Zhang85799a32010-12-10 12:03:54 -0800627 nvsc_packet = (struct hv_netvsc_packet *)(unsigned long)
Haiyang Zhang415f2282011-01-26 12:12:13 -0800628 packet->trans_id;
Hank Janssenfceaf242009-07-13 15:34:54 -0700629
Bill Pemberton454f18a2009-07-27 16:47:24 -0400630 /* Notify the layer above us */
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700631 if (nvsc_packet) {
KY Srinivasanc25aaf82014-04-30 10:14:31 -0700632 send_index = nvsc_packet->send_buf_index;
633 if (send_index != NETVSC_INVALID_INDEX)
634 netvsc_free_send_slot(net_device, send_index);
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700635 q_idx = nvsc_packet->q_idx;
636 channel = nvsc_packet->channel;
Haiyang Zhang893f6622014-04-21 14:54:44 -0700637 nvsc_packet->send_completion(nvsc_packet->
638 send_completion_ctx);
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700639 }
Hank Janssenfceaf242009-07-13 15:34:54 -0700640
Haiyang Zhang33be96e2012-03-27 13:20:45 +0000641 num_outstanding_sends =
642 atomic_dec_return(&net_device->num_outstanding_sends);
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700643 queue_sends = atomic_dec_return(&net_device->
644 queue_sends[q_idx]);
Haiyang Zhang1d068252011-12-02 11:56:25 -0800645
Haiyang Zhangdc5cd892012-06-04 06:42:38 +0000646 if (net_device->destroy && num_outstanding_sends == 0)
647 wake_up(&net_device->wait_drain);
648
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700649 if (netif_tx_queue_stopped(netdev_get_tx_queue(ndev, q_idx)) &&
650 !net_device->start_remove &&
651 (hv_ringbuf_avail_percent(&channel->outbound) >
652 RING_AVAIL_PERCENT_HIWATER || queue_sends < 1))
653 netif_tx_wake_queue(netdev_get_tx_queue(
654 ndev, q_idx));
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700655 } else {
Haiyang Zhangd9871152011-09-01 12:19:41 -0700656 netdev_err(ndev, "Unknown send completion packet type- "
Haiyang Zhangc909ebb2011-09-01 12:19:40 -0700657 "%d received!!\n", nvsp_packet->hdr.msg_type);
Hank Janssenfceaf242009-07-13 15:34:54 -0700658 }
659
Hank Janssenfceaf242009-07-13 15:34:54 -0700660}
661
KY Srinivasanc25aaf82014-04-30 10:14:31 -0700662static u32 netvsc_get_next_send_section(struct netvsc_device *net_device)
663{
664 unsigned long index;
665 u32 max_words = net_device->map_words;
666 unsigned long *map_addr = (unsigned long *)net_device->send_section_map;
667 u32 section_cnt = net_device->send_section_cnt;
668 int ret_val = NETVSC_INVALID_INDEX;
669 int i;
670 int prev_val;
671
672 for (i = 0; i < max_words; i++) {
673 if (!~(map_addr[i]))
674 continue;
675 index = ffz(map_addr[i]);
676 prev_val = sync_test_and_set_bit(index, &map_addr[i]);
677 if (prev_val)
678 continue;
679 if ((index + (i * BITS_PER_LONG)) >= section_cnt)
680 break;
681 ret_val = (index + (i * BITS_PER_LONG));
682 break;
683 }
684 return ret_val;
685}
686
687u32 netvsc_copy_to_send_buf(struct netvsc_device *net_device,
688 unsigned int section_index,
689 struct hv_netvsc_packet *packet)
690{
691 char *start = net_device->send_buf;
692 char *dest = (start + (section_index * net_device->send_section_size));
693 int i;
694 u32 msg_size = 0;
695
696 for (i = 0; i < packet->page_buf_cnt; i++) {
697 char *src = phys_to_virt(packet->page_buf[i].pfn << PAGE_SHIFT);
698 u32 offset = packet->page_buf[i].offset;
699 u32 len = packet->page_buf[i].len;
700
701 memcpy(dest, (src + offset), len);
702 msg_size += len;
703 dest += len;
704 }
705 return msg_size;
706}
707
K. Y. Srinivasanf9819f02011-05-12 19:34:49 -0700708int netvsc_send(struct hv_device *device,
Haiyang Zhang85799a32010-12-10 12:03:54 -0800709 struct hv_netvsc_packet *packet)
Hank Janssenfceaf242009-07-13 15:34:54 -0700710{
Haiyang Zhang85799a32010-12-10 12:03:54 -0800711 struct netvsc_device *net_device;
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700712 int ret = 0;
Greg Kroah-Hartman223c1aa2009-08-28 16:20:53 -0700713 struct nvsp_message sendMessage;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700714 struct net_device *ndev;
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700715 struct vmbus_channel *out_channel = NULL;
Haiyang Zhangf1ea3cd2013-04-05 11:44:40 +0000716 u64 req_id;
KY Srinivasanc25aaf82014-04-30 10:14:31 -0700717 unsigned int section_index = NETVSC_INVALID_INDEX;
718 u32 msg_size = 0;
719 struct sk_buff *skb;
KY Srinivasan3a67c9c2014-10-05 10:42:51 -0700720 u16 q_idx = packet->q_idx;
KY Srinivasanc25aaf82014-04-30 10:14:31 -0700721
Hank Janssenfceaf242009-07-13 15:34:54 -0700722
Haiyang Zhang5a71ae32010-12-10 12:03:55 -0800723 net_device = get_outbound_net_device(device);
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700724 if (!net_device)
K. Y. Srinivasanff2bd692011-08-25 09:49:15 -0700725 return -ENODEV;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700726 ndev = net_device->ndev;
Hank Janssenfceaf242009-07-13 15:34:54 -0700727
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800728 sendMessage.hdr.msg_type = NVSP_MSG1_TYPE_SEND_RNDIS_PKT;
Haiyang Zhang72a2f5b2010-12-10 12:03:58 -0800729 if (packet->is_data_pkt) {
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700730 /* 0 is RMC_DATA; */
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800731 sendMessage.msg.v1_msg.send_rndis_pkt.channel_type = 0;
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700732 } else {
733 /* 1 is RMC_CONTROL; */
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800734 sendMessage.msg.v1_msg.send_rndis_pkt.channel_type = 1;
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700735 }
Hank Janssenfceaf242009-07-13 15:34:54 -0700736
KY Srinivasanc25aaf82014-04-30 10:14:31 -0700737 /* Attempt to send via sendbuf */
738 if (packet->total_data_buflen < net_device->send_section_size) {
739 section_index = netvsc_get_next_send_section(net_device);
740 if (section_index != NETVSC_INVALID_INDEX) {
741 msg_size = netvsc_copy_to_send_buf(net_device,
742 section_index,
743 packet);
744 skb = (struct sk_buff *)
745 (unsigned long)packet->send_completion_tid;
746 if (skb)
747 dev_kfree_skb_any(skb);
748 packet->page_buf_cnt = 0;
749 }
750 }
751 packet->send_buf_index = section_index;
752
753
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800754 sendMessage.msg.v1_msg.send_rndis_pkt.send_buf_section_index =
KY Srinivasanc25aaf82014-04-30 10:14:31 -0700755 section_index;
756 sendMessage.msg.v1_msg.send_rndis_pkt.send_buf_section_size = msg_size;
Hank Janssenfceaf242009-07-13 15:34:54 -0700757
Haiyang Zhang893f6622014-04-21 14:54:44 -0700758 if (packet->send_completion)
Haiyang Zhang00ca8f02013-04-26 08:25:55 +0000759 req_id = (ulong)packet;
Haiyang Zhangf1ea3cd2013-04-05 11:44:40 +0000760 else
761 req_id = 0;
762
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700763 out_channel = net_device->chn_table[packet->q_idx];
764 if (out_channel == NULL)
765 out_channel = device->channel;
766 packet->channel = out_channel;
767
Haiyang Zhang72a2f5b2010-12-10 12:03:58 -0800768 if (packet->page_buf_cnt) {
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700769 ret = vmbus_sendpacket_pagebuffer(out_channel,
Haiyang Zhang72a2f5b2010-12-10 12:03:58 -0800770 packet->page_buf,
771 packet->page_buf_cnt,
Greg Kroah-Hartmanff3f8ee2010-10-21 09:32:46 -0700772 &sendMessage,
773 sizeof(struct nvsp_message),
Haiyang Zhangf1ea3cd2013-04-05 11:44:40 +0000774 req_id);
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700775 } else {
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700776 ret = vmbus_sendpacket(out_channel, &sendMessage,
Haiyang Zhange4d59ac2011-06-17 07:58:04 -0700777 sizeof(struct nvsp_message),
Haiyang Zhangf1ea3cd2013-04-05 11:44:40 +0000778 req_id,
Haiyang Zhange4d59ac2011-06-17 07:58:04 -0700779 VM_PKT_DATA_INBAND,
780 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
Hank Janssenfceaf242009-07-13 15:34:54 -0700781 }
782
Haiyang Zhang1d068252011-12-02 11:56:25 -0800783 if (ret == 0) {
784 atomic_inc(&net_device->num_outstanding_sends);
KY Srinivasan3a67c9c2014-10-05 10:42:51 -0700785 atomic_inc(&net_device->queue_sends[q_idx]);
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700786
787 if (hv_ringbuf_avail_percent(&out_channel->outbound) <
Haiyang Zhang33be96e2012-03-27 13:20:45 +0000788 RING_AVAIL_PERCENT_LOWATER) {
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700789 netif_tx_stop_queue(netdev_get_tx_queue(
KY Srinivasan3a67c9c2014-10-05 10:42:51 -0700790 ndev, q_idx));
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700791
Haiyang Zhang33be96e2012-03-27 13:20:45 +0000792 if (atomic_read(&net_device->
KY Srinivasan3a67c9c2014-10-05 10:42:51 -0700793 queue_sends[q_idx]) < 1)
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700794 netif_tx_wake_queue(netdev_get_tx_queue(
KY Srinivasan3a67c9c2014-10-05 10:42:51 -0700795 ndev, q_idx));
Haiyang Zhang33be96e2012-03-27 13:20:45 +0000796 }
Haiyang Zhang1d068252011-12-02 11:56:25 -0800797 } else if (ret == -EAGAIN) {
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700798 netif_tx_stop_queue(netdev_get_tx_queue(
KY Srinivasan3a67c9c2014-10-05 10:42:51 -0700799 ndev, q_idx));
800 if (atomic_read(&net_device->queue_sends[q_idx]) < 1) {
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700801 netif_tx_wake_queue(netdev_get_tx_queue(
KY Srinivasan3a67c9c2014-10-05 10:42:51 -0700802 ndev, q_idx));
Haiyang Zhang33be96e2012-03-27 13:20:45 +0000803 ret = -ENOSPC;
804 }
Haiyang Zhang1d068252011-12-02 11:56:25 -0800805 } else {
Haiyang Zhangd9871152011-09-01 12:19:41 -0700806 netdev_err(ndev, "Unable to send packet %p ret %d\n",
Haiyang Zhang85799a32010-12-10 12:03:54 -0800807 packet, ret);
Haiyang Zhang1d068252011-12-02 11:56:25 -0800808 }
Hank Janssenfceaf242009-07-13 15:34:54 -0700809
Hank Janssenfceaf242009-07-13 15:34:54 -0700810 return ret;
811}
812
Haiyang Zhang5fa9d3c2011-04-21 12:30:42 -0700813static void netvsc_send_recv_completion(struct hv_device *device,
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700814 struct vmbus_channel *channel,
KY Srinivasan97c17232014-02-16 16:38:44 -0800815 struct netvsc_device *net_device,
Haiyang Zhang63f69212012-10-02 05:30:23 +0000816 u64 transaction_id, u32 status)
Haiyang Zhang5fa9d3c2011-04-21 12:30:42 -0700817{
818 struct nvsp_message recvcompMessage;
819 int retries = 0;
820 int ret;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700821 struct net_device *ndev;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700822
823 ndev = net_device->ndev;
Haiyang Zhang5fa9d3c2011-04-21 12:30:42 -0700824
825 recvcompMessage.hdr.msg_type =
826 NVSP_MSG1_TYPE_SEND_RNDIS_PKT_COMPLETE;
827
Haiyang Zhang63f69212012-10-02 05:30:23 +0000828 recvcompMessage.msg.v1_msg.send_rndis_pkt_complete.status = status;
Haiyang Zhang5fa9d3c2011-04-21 12:30:42 -0700829
830retry_send_cmplt:
831 /* Send the completion */
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700832 ret = vmbus_sendpacket(channel, &recvcompMessage,
Haiyang Zhang5fa9d3c2011-04-21 12:30:42 -0700833 sizeof(struct nvsp_message), transaction_id,
834 VM_PKT_COMP, 0);
835 if (ret == 0) {
836 /* success */
837 /* no-op */
K. Y. Srinivasand2598f02011-08-25 09:48:58 -0700838 } else if (ret == -EAGAIN) {
Haiyang Zhang5fa9d3c2011-04-21 12:30:42 -0700839 /* no more room...wait a bit and attempt to retry 3 times */
840 retries++;
Haiyang Zhangd9871152011-09-01 12:19:41 -0700841 netdev_err(ndev, "unable to send receive completion pkt"
Haiyang Zhangc909ebb2011-09-01 12:19:40 -0700842 " (tid %llx)...retrying %d\n", transaction_id, retries);
Haiyang Zhang5fa9d3c2011-04-21 12:30:42 -0700843
844 if (retries < 4) {
845 udelay(100);
846 goto retry_send_cmplt;
847 } else {
Haiyang Zhangd9871152011-09-01 12:19:41 -0700848 netdev_err(ndev, "unable to send receive "
Haiyang Zhangc909ebb2011-09-01 12:19:40 -0700849 "completion pkt (tid %llx)...give up retrying\n",
Haiyang Zhang5fa9d3c2011-04-21 12:30:42 -0700850 transaction_id);
851 }
852 } else {
Haiyang Zhangd9871152011-09-01 12:19:41 -0700853 netdev_err(ndev, "unable to send receive "
Haiyang Zhangc909ebb2011-09-01 12:19:40 -0700854 "completion pkt - %llx\n", transaction_id);
Haiyang Zhang5fa9d3c2011-04-21 12:30:42 -0700855 }
856}
857
KY Srinivasan97c17232014-02-16 16:38:44 -0800858static void netvsc_receive(struct netvsc_device *net_device,
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700859 struct vmbus_channel *channel,
KY Srinivasan97c17232014-02-16 16:38:44 -0800860 struct hv_device *device,
861 struct vmpacket_descriptor *packet)
Hank Janssenfceaf242009-07-13 15:34:54 -0700862{
Haiyang Zhang85799a32010-12-10 12:03:54 -0800863 struct vmtransfer_page_packet_header *vmxferpage_packet;
864 struct nvsp_message *nvsp_packet;
Haiyang Zhang4baab262014-04-21 14:54:43 -0700865 struct hv_netvsc_packet nv_pkt;
866 struct hv_netvsc_packet *netvsc_packet = &nv_pkt;
867 u32 status = NVSP_STAT_SUCCESS;
Haiyang Zhang45326342011-12-15 13:45:15 -0800868 int i;
869 int count = 0;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700870 struct net_device *ndev;
K. Y. Srinivasan779b4d12011-04-26 09:20:22 -0700871
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700872 ndev = net_device->ndev;
Hank Janssenfceaf242009-07-13 15:34:54 -0700873
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700874 /*
875 * All inbound packets other than send completion should be xfer page
876 * packet
877 */
Haiyang Zhang415f2282011-01-26 12:12:13 -0800878 if (packet->type != VM_PKT_DATA_USING_XFER_PAGES) {
Haiyang Zhangd9871152011-09-01 12:19:41 -0700879 netdev_err(ndev, "Unknown packet type received - %d\n",
Haiyang Zhang415f2282011-01-26 12:12:13 -0800880 packet->type);
Hank Janssenfceaf242009-07-13 15:34:54 -0700881 return;
882 }
883
Haiyang Zhang85799a32010-12-10 12:03:54 -0800884 nvsp_packet = (struct nvsp_message *)((unsigned long)packet +
Haiyang Zhang415f2282011-01-26 12:12:13 -0800885 (packet->offset8 << 3));
Hank Janssenfceaf242009-07-13 15:34:54 -0700886
Bill Pemberton454f18a2009-07-27 16:47:24 -0400887 /* Make sure this is a valid nvsp packet */
Haiyang Zhang53d21fd2010-12-10 12:03:59 -0800888 if (nvsp_packet->hdr.msg_type !=
889 NVSP_MSG1_TYPE_SEND_RNDIS_PKT) {
Haiyang Zhangd9871152011-09-01 12:19:41 -0700890 netdev_err(ndev, "Unknown nvsp packet type received-"
Haiyang Zhangc909ebb2011-09-01 12:19:40 -0700891 " %d\n", nvsp_packet->hdr.msg_type);
Hank Janssenfceaf242009-07-13 15:34:54 -0700892 return;
893 }
894
Haiyang Zhang85799a32010-12-10 12:03:54 -0800895 vmxferpage_packet = (struct vmtransfer_page_packet_header *)packet;
Hank Janssenfceaf242009-07-13 15:34:54 -0700896
Haiyang Zhang415f2282011-01-26 12:12:13 -0800897 if (vmxferpage_packet->xfer_pageset_id != NETVSC_RECEIVE_BUFFER_ID) {
Haiyang Zhangd9871152011-09-01 12:19:41 -0700898 netdev_err(ndev, "Invalid xfer page set id - "
Haiyang Zhangc909ebb2011-09-01 12:19:40 -0700899 "expecting %x got %x\n", NETVSC_RECEIVE_BUFFER_ID,
Haiyang Zhang415f2282011-01-26 12:12:13 -0800900 vmxferpage_packet->xfer_pageset_id);
Hank Janssenfceaf242009-07-13 15:34:54 -0700901 return;
902 }
903
Haiyang Zhang4baab262014-04-21 14:54:43 -0700904 count = vmxferpage_packet->range_cnt;
905 netvsc_packet->device = device;
906 netvsc_packet->channel = channel;
Hank Janssenfceaf242009-07-13 15:34:54 -0700907
Bill Pemberton454f18a2009-07-27 16:47:24 -0400908 /* Each range represents 1 RNDIS pkt that contains 1 ethernet frame */
Haiyang Zhang4baab262014-04-21 14:54:43 -0700909 for (i = 0; i < count; i++) {
Bill Pemberton454f18a2009-07-27 16:47:24 -0400910 /* Initialize the netvsc packet */
Haiyang Zhang63f69212012-10-02 05:30:23 +0000911 netvsc_packet->status = NVSP_STAT_SUCCESS;
Haiyang Zhang45326342011-12-15 13:45:15 -0800912 netvsc_packet->data = (void *)((unsigned long)net_device->
913 recv_buf + vmxferpage_packet->ranges[i].byte_offset);
Haiyang Zhang72a2f5b2010-12-10 12:03:58 -0800914 netvsc_packet->total_data_buflen =
Haiyang Zhang415f2282011-01-26 12:12:13 -0800915 vmxferpage_packet->ranges[i].byte_count;
Hank Janssenfceaf242009-07-13 15:34:54 -0700916
Bill Pemberton454f18a2009-07-27 16:47:24 -0400917 /* Pass it to the upper layer */
K. Y. Srinivasanac6f7852011-05-12 19:34:58 -0700918 rndis_filter_receive(device, netvsc_packet);
Hank Janssenfceaf242009-07-13 15:34:54 -0700919
Haiyang Zhang4baab262014-04-21 14:54:43 -0700920 if (netvsc_packet->status != NVSP_STAT_SUCCESS)
921 status = NVSP_STAT_FAIL;
Hank Janssenfceaf242009-07-13 15:34:54 -0700922 }
923
Haiyang Zhang4baab262014-04-21 14:54:43 -0700924 netvsc_send_recv_completion(device, channel, net_device,
925 vmxferpage_packet->d.trans_id, status);
Hank Janssenfceaf242009-07-13 15:34:54 -0700926}
927
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700928
929static void netvsc_send_table(struct hv_device *hdev,
930 struct vmpacket_descriptor *vmpkt)
931{
932 struct netvsc_device *nvscdev;
933 struct net_device *ndev;
934 struct nvsp_message *nvmsg;
935 int i;
936 u32 count, *tab;
937
938 nvscdev = get_outbound_net_device(hdev);
939 if (!nvscdev)
940 return;
941 ndev = nvscdev->ndev;
942
943 nvmsg = (struct nvsp_message *)((unsigned long)vmpkt +
944 (vmpkt->offset8 << 3));
945
946 if (nvmsg->hdr.msg_type != NVSP_MSG5_TYPE_SEND_INDIRECTION_TABLE)
947 return;
948
949 count = nvmsg->msg.v5_msg.send_table.count;
950 if (count != VRSS_SEND_TAB_SIZE) {
951 netdev_err(ndev, "Received wrong send-table size:%u\n", count);
952 return;
953 }
954
955 tab = (u32 *)((unsigned long)&nvmsg->msg.v5_msg.send_table +
956 nvmsg->msg.v5_msg.send_table.offset);
957
958 for (i = 0; i < count; i++)
959 nvscdev->send_table[i] = tab[i];
960}
961
962void netvsc_channel_cb(void *context)
Hank Janssenfceaf242009-07-13 15:34:54 -0700963{
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700964 int ret;
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700965 struct vmbus_channel *channel = (struct vmbus_channel *)context;
966 struct hv_device *device;
Haiyang Zhang85799a32010-12-10 12:03:54 -0800967 struct netvsc_device *net_device;
968 u32 bytes_recvd;
969 u64 request_id;
Greg Kroah-Hartman8dc0a062009-08-27 16:02:36 -0700970 struct vmpacket_descriptor *desc;
Bill Pembertonc6fcf0b2010-04-27 16:23:47 -0400971 unsigned char *buffer;
972 int bufferlen = NETVSC_PACKET_SIZE;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700973 struct net_device *ndev;
Hank Janssenfceaf242009-07-13 15:34:54 -0700974
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700975 if (channel->primary_channel != NULL)
976 device = channel->primary_channel->device_obj;
977 else
978 device = channel->device_obj;
979
Haiyang Zhang5a71ae32010-12-10 12:03:55 -0800980 net_device = get_inbound_net_device(device);
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700981 if (!net_device)
KY Srinivasanee0c4c32014-02-16 16:38:45 -0800982 return;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -0700983 ndev = net_device->ndev;
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700984 buffer = get_per_channel_state(channel);
Hank Janssenfceaf242009-07-13 15:34:54 -0700985
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700986 do {
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700987 ret = vmbus_recvpacket_raw(channel, buffer, bufferlen,
Haiyang Zhang85799a32010-12-10 12:03:54 -0800988 &bytes_recvd, &request_id);
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700989 if (ret == 0) {
Haiyang Zhang85799a32010-12-10 12:03:54 -0800990 if (bytes_recvd > 0) {
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700991 desc = (struct vmpacket_descriptor *)buffer;
Haiyang Zhang415f2282011-01-26 12:12:13 -0800992 switch (desc->type) {
993 case VM_PKT_COMP:
KY Srinivasan97c17232014-02-16 16:38:44 -0800994 netvsc_send_completion(net_device,
995 device, desc);
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -0700996 break;
Hank Janssenfceaf242009-07-13 15:34:54 -0700997
Haiyang Zhang415f2282011-01-26 12:12:13 -0800998 case VM_PKT_DATA_USING_XFER_PAGES:
Haiyang Zhang5b54dac2014-04-21 10:20:28 -0700999 netvsc_receive(net_device, channel,
1000 device, desc);
1001 break;
1002
1003 case VM_PKT_DATA_INBAND:
1004 netvsc_send_table(device, desc);
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -07001005 break;
Hank Janssenfceaf242009-07-13 15:34:54 -07001006
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -07001007 default:
Haiyang Zhangd9871152011-09-01 12:19:41 -07001008 netdev_err(ndev,
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -07001009 "unhandled packet type %d, "
1010 "tid %llx len %d\n",
Haiyang Zhang415f2282011-01-26 12:12:13 -08001011 desc->type, request_id,
Haiyang Zhang85799a32010-12-10 12:03:54 -08001012 bytes_recvd);
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -07001013 break;
Hank Janssenfceaf242009-07-13 15:34:54 -07001014 }
1015
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -07001016 } else {
KY Srinivasanee0c4c32014-02-16 16:38:45 -08001017 /*
1018 * We are done for this pass.
1019 */
Hank Janssenfceaf242009-07-13 15:34:54 -07001020 break;
1021 }
KY Srinivasanee0c4c32014-02-16 16:38:45 -08001022
K. Y. Srinivasan3d5cad92011-08-25 09:48:59 -07001023 } else if (ret == -ENOBUFS) {
KY Srinivasanee0c4c32014-02-16 16:38:45 -08001024 if (bufferlen > NETVSC_PACKET_SIZE)
1025 kfree(buffer);
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -07001026 /* Handle large packet */
Haiyang Zhang85799a32010-12-10 12:03:54 -08001027 buffer = kmalloc(bytes_recvd, GFP_ATOMIC);
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -07001028 if (buffer == NULL) {
Bill Pemberton454f18a2009-07-27 16:47:24 -04001029 /* Try again next time around */
Haiyang Zhangd9871152011-09-01 12:19:41 -07001030 netdev_err(ndev,
Greg Kroah-Hartman21a808202009-09-02 10:33:05 -07001031 "unable to allocate buffer of size "
Haiyang Zhangc909ebb2011-09-01 12:19:40 -07001032 "(%d)!!\n", bytes_recvd);
Hank Janssenfceaf242009-07-13 15:34:54 -07001033 break;
1034 }
1035
Haiyang Zhang85799a32010-12-10 12:03:54 -08001036 bufferlen = bytes_recvd;
Hank Janssenfceaf242009-07-13 15:34:54 -07001037 }
1038 } while (1);
1039
KY Srinivasanee0c4c32014-02-16 16:38:45 -08001040 if (bufferlen > NETVSC_PACKET_SIZE)
1041 kfree(buffer);
Hank Janssenfceaf242009-07-13 15:34:54 -07001042 return;
1043}
Haiyang Zhangaf24ce42011-04-21 12:30:40 -07001044
1045/*
Haiyang Zhangb637e022011-04-21 12:30:45 -07001046 * netvsc_device_add - Callback when the device belonging to this
1047 * driver is added
1048 */
K. Y. Srinivasan7bd23a42011-05-10 07:54:53 -07001049int netvsc_device_add(struct hv_device *device, void *additional_info)
Haiyang Zhangb637e022011-04-21 12:30:45 -07001050{
1051 int ret = 0;
K. Y. Srinivasanaae23982011-05-12 19:35:05 -07001052 int ring_size =
1053 ((struct netvsc_device_info *)additional_info)->ring_size;
Haiyang Zhangb637e022011-04-21 12:30:45 -07001054 struct netvsc_device *net_device;
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -07001055 struct net_device *ndev;
Haiyang Zhangb637e022011-04-21 12:30:45 -07001056
1057 net_device = alloc_net_device(device);
Dan Carpenterb1c84922014-09-04 14:11:23 +03001058 if (!net_device)
1059 return -ENOMEM;
Haiyang Zhangb637e022011-04-21 12:30:45 -07001060
Haiyang Zhang5b54dac2014-04-21 10:20:28 -07001061 net_device->ring_size = ring_size;
1062
K. Y. Srinivasan2ddd5e52011-09-13 10:59:49 -07001063 /*
1064 * Coming into this function, struct net_device * is
1065 * registered as the driver private data.
1066 * In alloc_net_device(), we register struct netvsc_device *
1067 * as the driver private data and stash away struct net_device *
1068 * in struct netvsc_device *.
1069 */
1070 ndev = net_device->ndev;
1071
Haiyang Zhangb637e022011-04-21 12:30:45 -07001072 /* Initialize the NetVSC channel extension */
K. Y. Srinivasan35abb212011-05-10 07:55:41 -07001073 init_completion(&net_device->channel_init_wait);
Haiyang Zhangb637e022011-04-21 12:30:45 -07001074
Haiyang Zhang5b54dac2014-04-21 10:20:28 -07001075 set_per_channel_state(device->channel, net_device->cb_buffer);
1076
Haiyang Zhangb637e022011-04-21 12:30:45 -07001077 /* Open the channel */
K. Y. Srinivasanaae23982011-05-12 19:35:05 -07001078 ret = vmbus_open(device->channel, ring_size * PAGE_SIZE,
1079 ring_size * PAGE_SIZE, NULL, 0,
Haiyang Zhang5b54dac2014-04-21 10:20:28 -07001080 netvsc_channel_cb, device->channel);
Haiyang Zhangb637e022011-04-21 12:30:45 -07001081
1082 if (ret != 0) {
Haiyang Zhangd9871152011-09-01 12:19:41 -07001083 netdev_err(ndev, "unable to open channel: %d\n", ret);
Haiyang Zhangb637e022011-04-21 12:30:45 -07001084 goto cleanup;
1085 }
1086
1087 /* Channel is opened */
Haiyang Zhangc909ebb2011-09-01 12:19:40 -07001088 pr_info("hv_netvsc channel opened successfully\n");
Haiyang Zhangb637e022011-04-21 12:30:45 -07001089
Haiyang Zhang5b54dac2014-04-21 10:20:28 -07001090 net_device->chn_table[0] = device->channel;
1091
Haiyang Zhangb637e022011-04-21 12:30:45 -07001092 /* Connect with the NetVsp */
1093 ret = netvsc_connect_vsp(device);
1094 if (ret != 0) {
Haiyang Zhangd9871152011-09-01 12:19:41 -07001095 netdev_err(ndev,
Haiyang Zhangc909ebb2011-09-01 12:19:40 -07001096 "unable to connect to NetVSP - %d\n", ret);
Haiyang Zhangb637e022011-04-21 12:30:45 -07001097 goto close;
1098 }
1099
1100 return ret;
1101
1102close:
1103 /* Now, we can close the channel safely */
1104 vmbus_close(device->channel);
1105
1106cleanup:
Haiyang Zhangf90251c2014-08-15 19:18:19 +00001107 free_netvsc_device(net_device);
Haiyang Zhangb637e022011-04-21 12:30:45 -07001108
1109 return ret;
1110}