Pileus Git - ~andy/linux/blob - drivers/staging/hv/netvsc.c

   1 /*
   2  * 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:
  18  *   Haiyang Zhang <haiyangz@microsoft.com>
  19  *   Hank Janssen  <hjanssen@microsoft.com>
  20  */
  21 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  22
  23 #include <linux/kernel.h>
  24 #include <linux/sched.h>
  25 #include <linux/wait.h>
  26 #include <linux/mm.h>
  27 #include <linux/delay.h>
  28 #include <linux/io.h>
  29 #include <linux/slab.h>
  30
  31 #include "hyperv.h"
  32 #include "hyperv_net.h"
  33
  34
  35 static struct netvsc_device *alloc_net_device(struct hv_device *device)
  36 {
  37         struct netvsc_device *net_device;
  38
  39         net_device = kzalloc(sizeof(struct netvsc_device), GFP_KERNEL);
  40         if (!net_device)
  41                 return NULL;
  42
  43
  44         net_device->destroy = false;
  45         net_device->dev = device;
  46         device->ext = net_device;
  47
  48         return net_device;
  49 }
  50
  51 static struct netvsc_device *get_outbound_net_device(struct hv_device *device)
  52 {
  53         struct netvsc_device *net_device;
  54
  55         net_device = device->ext;
  56         if (net_device && net_device->destroy)
  57                 net_device = NULL;
  58
  59         return net_device;
  60 }
  61
  62 static struct netvsc_device *get_inbound_net_device(struct hv_device *device)
  63 {
  64         struct netvsc_device *net_device;
  65
  66         net_device = device->ext;
  67
  68         if (!net_device)
  69                 goto get_in_err;
  70
  71         if (net_device->destroy &&
  72                 atomic_read(&net_device->num_outstanding_sends) == 0)
  73                 net_device = NULL;
  74
  75 get_in_err:
  76         return net_device;
  77 }
  78
  79
  80 static int netvsc_destroy_recv_buf(struct netvsc_device *net_device)
  81 {
  82         struct nvsp_message *revoke_packet;
  83         int ret = 0;
  84
  85         /*
  86          * If we got a section count, it means we received a
  87          * SendReceiveBufferComplete msg (ie sent
  88          * NvspMessage1TypeSendReceiveBuffer msg) therefore, we need
  89          * to send a revoke msg here
  90          */
  91         if (net_device->recv_section_cnt) {
  92                 /* Send the revoke receive buffer */
  93                 revoke_packet = &net_device->revoke_packet;
  94                 memset(revoke_packet, 0, sizeof(struct nvsp_message));
  95
  96                 revoke_packet->hdr.msg_type =
  97                         NVSP_MSG1_TYPE_REVOKE_RECV_BUF;
  98                 revoke_packet->msg.v1_msg.
  99                 revoke_recv_buf.id = NETVSC_RECEIVE_BUFFER_ID;
 100
 101                 ret = vmbus_sendpacket(net_device->dev->channel,
 102                                        revoke_packet,
 103                                        sizeof(struct nvsp_message),
 104                                        (unsigned long)revoke_packet,
 105                                        VM_PKT_DATA_INBAND, 0);
 106                 /*
 107                  * If we failed here, we might as well return and
 108                  * have a leak rather than continue and a bugchk
 109                  */
 110                 if (ret != 0) {
 111                         dev_err(&net_device->dev->device, "unable to send "
 112                                 "revoke receive buffer to netvsp");
 113                         return ret;
 114                 }
 115         }
 116
 117         /* Teardown the gpadl on the vsp end */
 118         if (net_device->recv_buf_gpadl_handle) {
 119                 ret = vmbus_teardown_gpadl(net_device->dev->channel,
 120                            net_device->recv_buf_gpadl_handle);
 121
 122                 /* If we failed here, we might as well return and have a leak
 123                  * rather than continue and a bugchk
 124                  */
 125                 if (ret != 0) {
 126                         dev_err(&net_device->dev->device,
 127                                    "unable to teardown receive buffer's gpadl");
 128                         return -ret;
 129                 }
 130                 net_device->recv_buf_gpadl_handle = 0;
 131         }
 132
 133         if (net_device->recv_buf) {
 134                 /* Free up the receive buffer */
 135                 free_pages((unsigned long)net_device->recv_buf,
 136                         get_order(net_device->recv_buf_size));
 137                 net_device->recv_buf = NULL;
 138         }
 139
 140         if (net_device->recv_section) {
 141                 net_device->recv_section_cnt = 0;
 142                 kfree(net_device->recv_section);
 143                 net_device->recv_section = NULL;
 144         }
 145
 146         return ret;
 147 }
 148
 149 static int netvsc_init_recv_buf(struct hv_device *device)
 150 {
 151         int ret = 0;
 152         int t;
 153         struct netvsc_device *net_device;
 154         struct nvsp_message *init_packet;
 155
 156         net_device = get_outbound_net_device(device);
 157         if (!net_device) {
 158                 dev_err(&device->device, "unable to get net device..."
 159                            "device being destroyed?");
 160                 return -ENODEV;
 161         }
 162
 163         net_device->recv_buf =
 164                 (void *)__get_free_pages(GFP_KERNEL|__GFP_ZERO,
 165                                 get_order(net_device->recv_buf_size));
 166         if (!net_device->recv_buf) {
 167                 dev_err(&device->device, "unable to allocate receive "
 168                         "buffer of size %d", net_device->recv_buf_size);
 169                 ret = -ENOMEM;
 170                 goto cleanup;
 171         }
 172
 173         /*
 174          * Establish the gpadl handle for this buffer on this
 175          * channel.  Note: This call uses the vmbus connection rather
 176          * than the channel to establish the gpadl handle.
 177          */
 178         ret = vmbus_establish_gpadl(device->channel, net_device->recv_buf,
 179                                     net_device->recv_buf_size,
 180                                     &net_device->recv_buf_gpadl_handle);
 181         if (ret != 0) {
 182                 dev_err(&device->device,
 183                         "unable to establish receive buffer's gpadl");
 184                 goto cleanup;
 185         }
 186
 187
 188         /* Notify the NetVsp of the gpadl handle */
 189         init_packet = &net_device->channel_init_pkt;
 190
 191         memset(init_packet, 0, sizeof(struct nvsp_message));
 192
 193         init_packet->hdr.msg_type = NVSP_MSG1_TYPE_SEND_RECV_BUF;
 194         init_packet->msg.v1_msg.send_recv_buf.
 195                 gpadl_handle = net_device->recv_buf_gpadl_handle;
 196         init_packet->msg.v1_msg.
 197                 send_recv_buf.id = NETVSC_RECEIVE_BUFFER_ID;
 198
 199         /* Send the gpadl notification request */
 200         ret = vmbus_sendpacket(device->channel, init_packet,
 201                                sizeof(struct nvsp_message),
 202                                (unsigned long)init_packet,
 203                                VM_PKT_DATA_INBAND,
 204                                VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
 205         if (ret != 0) {
 206                 dev_err(&device->device,
 207                         "unable to send receive buffer's gpadl to netvsp");
 208                 goto cleanup;
 209         }
 210
 211         t = wait_for_completion_timeout(&net_device->channel_init_wait, 5*HZ);
 212         BUG_ON(t == 0);
 213
 214
 215         /* Check the response */
 216         if (init_packet->msg.v1_msg.
 217             send_recv_buf_complete.status != NVSP_STAT_SUCCESS) {
 218                 dev_err(&device->device, "Unable to complete receive buffer "
 219                            "initialzation with NetVsp - status %d",
 220                            init_packet->msg.v1_msg.
 221                            send_recv_buf_complete.status);
 222                 ret = -EINVAL;
 223                 goto cleanup;
 224         }
 225
 226         /* Parse the response */
 227
 228         net_device->recv_section_cnt = init_packet->msg.
 229                 v1_msg.send_recv_buf_complete.num_sections;
 230
 231         net_device->recv_section = kmalloc(net_device->recv_section_cnt
 232                 * sizeof(struct nvsp_1_receive_buffer_section), GFP_KERNEL);
 233         if (net_device->recv_section == NULL) {
 234                 ret = -EINVAL;
 235                 goto cleanup;
 236         }
 237
 238         memcpy(net_device->recv_section,
 239                 init_packet->msg.v1_msg.
 240                send_recv_buf_complete.sections,
 241                 net_device->recv_section_cnt *
 242                sizeof(struct nvsp_1_receive_buffer_section));
 243
 244         /*
 245          * For 1st release, there should only be 1 section that represents the
 246          * entire receive buffer
 247          */
 248         if (net_device->recv_section_cnt != 1 ||
 249             net_device->recv_section->offset != 0) {
 250                 ret = -EINVAL;
 251                 goto cleanup;
 252         }
 253
 254         goto exit;
 255
 256 cleanup:
 257         netvsc_destroy_recv_buf(net_device);
 258
 259 exit:
 260         return ret;
 261 }
 262
 263
 264 static int netvsc_connect_vsp(struct hv_device *device)
 265 {
 266         int ret, t;
 267         struct netvsc_device *net_device;
 268         struct nvsp_message *init_packet;
 269         int ndis_version;
 270
 271         net_device = get_outbound_net_device(device);
 272         if (!net_device) {
 273                 dev_err(&device->device, "unable to get net device..."
 274                            "device being destroyed?");
 275                 return -ENODEV;
 276         }
 277
 278         init_packet = &net_device->channel_init_pkt;
 279
 280         memset(init_packet, 0, sizeof(struct nvsp_message));
 281         init_packet->hdr.msg_type = NVSP_MSG_TYPE_INIT;
 282         init_packet->msg.init_msg.init.min_protocol_ver =
 283                 NVSP_MIN_PROTOCOL_VERSION;
 284         init_packet->msg.init_msg.init.max_protocol_ver =
 285                 NVSP_MAX_PROTOCOL_VERSION;
 286
 287         /* Send the init request */
 288         ret = vmbus_sendpacket(device->channel, init_packet,
 289                                sizeof(struct nvsp_message),
 290                                (unsigned long)init_packet,
 291                                VM_PKT_DATA_INBAND,
 292                                VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
 293
 294         if (ret != 0)
 295                 goto cleanup;
 296
 297         t = wait_for_completion_timeout(&net_device->channel_init_wait, 5*HZ);
 298
 299         if (t == 0) {
 300                 ret = -ETIMEDOUT;
 301                 goto cleanup;
 302         }
 303
 304         if (init_packet->msg.init_msg.init_complete.status !=
 305             NVSP_STAT_SUCCESS) {
 306                 ret = -EINVAL;
 307                 goto cleanup;
 308         }
 309
 310         if (init_packet->msg.init_msg.init_complete.
 311             negotiated_protocol_ver != NVSP_PROTOCOL_VERSION_1) {
 312                 ret = -EPROTO;
 313                 goto cleanup;
 314         }
 315         /* Send the ndis version */
 316         memset(init_packet, 0, sizeof(struct nvsp_message));
 317
 318         ndis_version = 0x00050000;
 319
 320         init_packet->hdr.msg_type = NVSP_MSG1_TYPE_SEND_NDIS_VER;
 321         init_packet->msg.v1_msg.
 322                 send_ndis_ver.ndis_major_ver =
 323                                 (ndis_version & 0xFFFF0000) >> 16;
 324         init_packet->msg.v1_msg.
 325                 send_ndis_ver.ndis_minor_ver =
 326                                 ndis_version & 0xFFFF;
 327
 328         /* Send the init request */
 329         ret = vmbus_sendpacket(device->channel, init_packet,
 330                                 sizeof(struct nvsp_message),
 331                                 (unsigned long)init_packet,
 332                                 VM_PKT_DATA_INBAND, 0);
 333         if (ret != 0)
 334                 goto cleanup;
 335
 336         /* Post the big receive buffer to NetVSP */
 337         ret = netvsc_init_recv_buf(device);
 338
 339 cleanup:
 340         return ret;
 341 }
 342
 343 static void netvsc_disconnect_vsp(struct netvsc_device *net_device)
 344 {
 345         netvsc_destroy_recv_buf(net_device);
 346 }
 347
 348 /*
 349  * netvsc_device_remove - Callback when the root bus device is removed
 350  */
 351 int netvsc_device_remove(struct hv_device *device)
 352 {
 353         struct netvsc_device *net_device;
 354         struct hv_netvsc_packet *netvsc_packet, *pos;
 355         unsigned long flags;
 356
 357         net_device = (struct netvsc_device *)device->ext;
 358         spin_lock_irqsave(&device->channel->inbound_lock, flags);
 359         net_device->destroy = true;
 360         spin_unlock_irqrestore(&device->channel->inbound_lock, flags);
 361
 362         /* Wait for all send completions */
 363         while (atomic_read(&net_device->num_outstanding_sends)) {
 364                 dev_err(&device->device,
 365                         "waiting for %d requests to complete...",
 366                         atomic_read(&net_device->num_outstanding_sends));
 367                 udelay(100);
 368         }
 369
 370         netvsc_disconnect_vsp(net_device);
 371
 372         /*
 373          * Since we have already drained, we don't need to busy wait
 374          * as was done in final_release_stor_device()
 375          * Note that we cannot set the ext pointer to NULL until
 376          * we have drained - to drain the outgoing packets, we need to
 377          * allow incoming packets.
 378          */
 379
 380         spin_lock_irqsave(&device->channel->inbound_lock, flags);
 381         device->ext = NULL;
 382         spin_unlock_irqrestore(&device->channel->inbound_lock, flags);
 383
 384         /* At this point, no one should be accessing netDevice except in here */
 385         dev_notice(&device->device, "net device safe to remove");
 386
 387         /* Now, we can close the channel safely */
 388         vmbus_close(device->channel);
 389
 390         /* Release all resources */
 391         list_for_each_entry_safe(netvsc_packet, pos,
 392                                  &net_device->recv_pkt_list, list_ent) {
 393                 list_del(&netvsc_packet->list_ent);
 394                 kfree(netvsc_packet);
 395         }
 396
 397         kfree(net_device);
 398         return 0;
 399 }
 400
 401 static void netvsc_send_completion(struct hv_device *device,
 402                                    struct vmpacket_descriptor *packet)
 403 {
 404         struct netvsc_device *net_device;
 405         struct nvsp_message *nvsp_packet;
 406         struct hv_netvsc_packet *nvsc_packet;
 407
 408         net_device = get_inbound_net_device(device);
 409         if (!net_device) {
 410                 dev_err(&device->device, "unable to get net device..."
 411                            "device being destroyed?");
 412                 return;
 413         }
 414
 415         nvsp_packet = (struct nvsp_message *)((unsigned long)packet +
 416                         (packet->offset8 << 3));
 417
 418         if ((nvsp_packet->hdr.msg_type == NVSP_MSG_TYPE_INIT_COMPLETE) ||
 419             (nvsp_packet->hdr.msg_type ==
 420              NVSP_MSG1_TYPE_SEND_RECV_BUF_COMPLETE) ||
 421             (nvsp_packet->hdr.msg_type ==
 422              NVSP_MSG1_TYPE_SEND_SEND_BUF_COMPLETE)) {
 423                 /* Copy the response back */
 424                 memcpy(&net_device->channel_init_pkt, nvsp_packet,
 425                        sizeof(struct nvsp_message));
 426                 complete(&net_device->channel_init_wait);
 427         } else if (nvsp_packet->hdr.msg_type ==
 428                    NVSP_MSG1_TYPE_SEND_RNDIS_PKT_COMPLETE) {
 429                 /* Get the send context */
 430                 nvsc_packet = (struct hv_netvsc_packet *)(unsigned long)
 431                         packet->trans_id;
 432
 433                 /* Notify the layer above us */
 434                 nvsc_packet->completion.send.send_completion(
 435                         nvsc_packet->completion.send.send_completion_ctx);
 436
 437                 atomic_dec(&net_device->num_outstanding_sends);
 438         } else {
 439                 dev_err(&device->device, "Unknown send completion packet type- "
 440                            "%d received!!", nvsp_packet->hdr.msg_type);
 441         }
 442
 443 }
 444
 445 int netvsc_send(struct hv_device *device,
 446                         struct hv_netvsc_packet *packet)
 447 {
 448         struct netvsc_device *net_device;
 449         int ret = 0;
 450
 451         struct nvsp_message sendMessage;
 452
 453         net_device = get_outbound_net_device(device);
 454         if (!net_device) {
 455                 dev_err(&device->device, "net device (%p) shutting down..."
 456                            "ignoring outbound packets", net_device);
 457                 return -ENODEV;
 458         }
 459
 460         sendMessage.hdr.msg_type = NVSP_MSG1_TYPE_SEND_RNDIS_PKT;
 461         if (packet->is_data_pkt) {
 462                 /* 0 is RMC_DATA; */
 463                 sendMessage.msg.v1_msg.send_rndis_pkt.channel_type = 0;
 464         } else {
 465                 /* 1 is RMC_CONTROL; */
 466                 sendMessage.msg.v1_msg.send_rndis_pkt.channel_type = 1;
 467         }
 468
 469         /* Not using send buffer section */
 470         sendMessage.msg.v1_msg.send_rndis_pkt.send_buf_section_index =
 471                 0xFFFFFFFF;
 472         sendMessage.msg.v1_msg.send_rndis_pkt.send_buf_section_size = 0;
 473
 474         if (packet->page_buf_cnt) {
 475                 ret = vmbus_sendpacket_pagebuffer(device->channel,
 476                                                   packet->page_buf,
 477                                                   packet->page_buf_cnt,
 478                                                   &sendMessage,
 479                                                   sizeof(struct nvsp_message),
 480                                                   (unsigned long)packet);
 481         } else {
 482                 ret = vmbus_sendpacket(device->channel, &sendMessage,
 483                                 sizeof(struct nvsp_message),
 484                                 (unsigned long)packet,
 485                                 VM_PKT_DATA_INBAND,
 486                                 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
 487
 488         }
 489
 490         if (ret != 0)
 491                 dev_err(&device->device, "Unable to send packet %p ret %d",
 492                            packet, ret);
 493
 494         atomic_inc(&net_device->num_outstanding_sends);
 495         return ret;
 496 }
 497
 498 static void netvsc_send_recv_completion(struct hv_device *device,
 499                                         u64 transaction_id)
 500 {
 501         struct nvsp_message recvcompMessage;
 502         int retries = 0;
 503         int ret;
 504
 505         recvcompMessage.hdr.msg_type =
 506                                 NVSP_MSG1_TYPE_SEND_RNDIS_PKT_COMPLETE;
 507
 508         /* FIXME: Pass in the status */
 509         recvcompMessage.msg.v1_msg.send_rndis_pkt_complete.status =
 510                 NVSP_STAT_SUCCESS;
 511
 512 retry_send_cmplt:
 513         /* Send the completion */
 514         ret = vmbus_sendpacket(device->channel, &recvcompMessage,
 515                                sizeof(struct nvsp_message), transaction_id,
 516                                VM_PKT_COMP, 0);
 517         if (ret == 0) {
 518                 /* success */
 519                 /* no-op */
 520         } else if (ret == -EAGAIN) {
 521                 /* no more room...wait a bit and attempt to retry 3 times */
 522                 retries++;
 523                 dev_err(&device->device, "unable to send receive completion pkt"
 524                         " (tid %llx)...retrying %d", transaction_id, retries);
 525
 526                 if (retries < 4) {
 527                         udelay(100);
 528                         goto retry_send_cmplt;
 529                 } else {
 530                         dev_err(&device->device, "unable to send receive "
 531                                 "completion pkt (tid %llx)...give up retrying",
 532                                 transaction_id);
 533                 }
 534         } else {
 535                 dev_err(&device->device, "unable to send receive "
 536                         "completion pkt - %llx", transaction_id);
 537         }
 538 }
 539
 540 /* Send a receive completion packet to RNDIS device (ie NetVsp) */
 541 static void netvsc_receive_completion(void *context)
 542 {
 543         struct hv_netvsc_packet *packet = context;
 544         struct hv_device *device = (struct hv_device *)packet->device;
 545         struct netvsc_device *net_device;
 546         u64 transaction_id = 0;
 547         bool fsend_receive_comp = false;
 548         unsigned long flags;
 549
 550         /*
 551          * Even though it seems logical to do a GetOutboundNetDevice() here to
 552          * send out receive completion, we are using GetInboundNetDevice()
 553          * since we may have disable outbound traffic already.
 554          */
 555         net_device = get_inbound_net_device(device);
 556         if (!net_device) {
 557                 dev_err(&device->device, "unable to get net device..."
 558                            "device being destroyed?");
 559                 return;
 560         }
 561
 562         /* Overloading use of the lock. */
 563         spin_lock_irqsave(&net_device->recv_pkt_list_lock, flags);
 564
 565         packet->xfer_page_pkt->count--;
 566
 567         /*
 568          * Last one in the line that represent 1 xfer page packet.
 569          * Return the xfer page packet itself to the freelist
 570          */
 571         if (packet->xfer_page_pkt->count == 0) {
 572                 fsend_receive_comp = true;
 573                 transaction_id = packet->completion.recv.recv_completion_tid;
 574                 list_add_tail(&packet->xfer_page_pkt->list_ent,
 575                               &net_device->recv_pkt_list);
 576
 577         }
 578
 579         /* Put the packet back */
 580         list_add_tail(&packet->list_ent, &net_device->recv_pkt_list);
 581         spin_unlock_irqrestore(&net_device->recv_pkt_list_lock, flags);
 582
 583         /* Send a receive completion for the xfer page packet */
 584         if (fsend_receive_comp)
 585                 netvsc_send_recv_completion(device, transaction_id);
 586
 587 }
 588
 589 static void netvsc_receive(struct hv_device *device,
 590                             struct vmpacket_descriptor *packet)
 591 {
 592         struct netvsc_device *net_device;
 593         struct vmtransfer_page_packet_header *vmxferpage_packet;
 594         struct nvsp_message *nvsp_packet;
 595         struct hv_netvsc_packet *netvsc_packet = NULL;
 596         unsigned long start;
 597         unsigned long end, end_virtual;
 598         /* struct netvsc_driver *netvscDriver; */
 599         struct xferpage_packet *xferpage_packet = NULL;
 600         int i, j;
 601         int count = 0, bytes_remain = 0;
 602         unsigned long flags;
 603
 604         LIST_HEAD(listHead);
 605
 606         net_device = get_inbound_net_device(device);
 607         if (!net_device) {
 608                 dev_err(&device->device, "unable to get net device..."
 609                            "device being destroyed?");
 610                 return;
 611         }
 612
 613         /*
 614          * All inbound packets other than send completion should be xfer page
 615          * packet
 616          */
 617         if (packet->type != VM_PKT_DATA_USING_XFER_PAGES) {
 618                 dev_err(&device->device, "Unknown packet type received - %d",
 619                            packet->type);
 620                 return;
 621         }
 622
 623         nvsp_packet = (struct nvsp_message *)((unsigned long)packet +
 624                         (packet->offset8 << 3));
 625
 626         /* Make sure this is a valid nvsp packet */
 627         if (nvsp_packet->hdr.msg_type !=
 628             NVSP_MSG1_TYPE_SEND_RNDIS_PKT) {
 629                 dev_err(&device->device, "Unknown nvsp packet type received-"
 630                         " %d", nvsp_packet->hdr.msg_type);
 631                 return;
 632         }
 633
 634         vmxferpage_packet = (struct vmtransfer_page_packet_header *)packet;
 635
 636         if (vmxferpage_packet->xfer_pageset_id != NETVSC_RECEIVE_BUFFER_ID) {
 637                 dev_err(&device->device, "Invalid xfer page set id - "
 638                            "expecting %x got %x", NETVSC_RECEIVE_BUFFER_ID,
 639                            vmxferpage_packet->xfer_pageset_id);
 640                 return;
 641         }
 642
 643         /*
 644          * Grab free packets (range count + 1) to represent this xfer
 645          * page packet. +1 to represent the xfer page packet itself.
 646          * We grab it here so that we know exactly how many we can
 647          * fulfil
 648          */
 649         spin_lock_irqsave(&net_device->recv_pkt_list_lock, flags);
 650         while (!list_empty(&net_device->recv_pkt_list)) {
 651                 list_move_tail(net_device->recv_pkt_list.next, &listHead);
 652                 if (++count == vmxferpage_packet->range_cnt + 1)
 653                         break;
 654         }
 655         spin_unlock_irqrestore(&net_device->recv_pkt_list_lock, flags);
 656
 657         /*
 658          * We need at least 2 netvsc pkts (1 to represent the xfer
 659          * page and at least 1 for the range) i.e. we can handled
 660          * some of the xfer page packet ranges...
 661          */
 662         if (count < 2) {
 663                 dev_err(&device->device, "Got only %d netvsc pkt...needed "
 664                         "%d pkts. Dropping this xfer page packet completely!",
 665                         count, vmxferpage_packet->range_cnt + 1);
 666
 667                 /* Return it to the freelist */
 668                 spin_lock_irqsave(&net_device->recv_pkt_list_lock, flags);
 669                 for (i = count; i != 0; i--) {
 670                         list_move_tail(listHead.next,
 671                                        &net_device->recv_pkt_list);
 672                 }
 673                 spin_unlock_irqrestore(&net_device->recv_pkt_list_lock,
 674                                        flags);
 675
 676                 netvsc_send_recv_completion(device,
 677                                             vmxferpage_packet->d.trans_id);
 678
 679                 return;
 680         }
 681
 682         /* Remove the 1st packet to represent the xfer page packet itself */
 683         xferpage_packet = (struct xferpage_packet *)listHead.next;
 684         list_del(&xferpage_packet->list_ent);
 685
 686         /* This is how much we can satisfy */
 687         xferpage_packet->count = count - 1;
 688
 689         if (xferpage_packet->count != vmxferpage_packet->range_cnt) {
 690                 dev_err(&device->device, "Needed %d netvsc pkts to satisy "
 691                         "this xfer page...got %d",
 692                         vmxferpage_packet->range_cnt, xferpage_packet->count);
 693         }
 694
 695         /* Each range represents 1 RNDIS pkt that contains 1 ethernet frame */
 696         for (i = 0; i < (count - 1); i++) {
 697                 netvsc_packet = (struct hv_netvsc_packet *)listHead.next;
 698                 list_del(&netvsc_packet->list_ent);
 699
 700                 /* Initialize the netvsc packet */
 701                 netvsc_packet->xfer_page_pkt = xferpage_packet;
 702                 netvsc_packet->completion.recv.recv_completion =
 703                                         netvsc_receive_completion;
 704                 netvsc_packet->completion.recv.recv_completion_ctx =
 705                                         netvsc_packet;
 706                 netvsc_packet->device = device;
 707                 /* Save this so that we can send it back */
 708                 netvsc_packet->completion.recv.recv_completion_tid =
 709                                         vmxferpage_packet->d.trans_id;
 710
 711                 netvsc_packet->total_data_buflen =
 712                                         vmxferpage_packet->ranges[i].byte_count;
 713                 netvsc_packet->page_buf_cnt = 1;
 714
 715                 netvsc_packet->page_buf[0].len =
 716                                         vmxferpage_packet->ranges[i].byte_count;
 717
 718                 start = virt_to_phys((void *)((unsigned long)net_device->
 719                 recv_buf + vmxferpage_packet->ranges[i].byte_offset));
 720
 721                 netvsc_packet->page_buf[0].pfn = start >> PAGE_SHIFT;
 722                 end_virtual = (unsigned long)net_device->recv_buf
 723                     + vmxferpage_packet->ranges[i].byte_offset
 724                     + vmxferpage_packet->ranges[i].byte_count - 1;
 725                 end = virt_to_phys((void *)end_virtual);
 726
 727                 /* Calculate the page relative offset */
 728                 netvsc_packet->page_buf[0].offset =
 729                         vmxferpage_packet->ranges[i].byte_offset &
 730                         (PAGE_SIZE - 1);
 731                 if ((end >> PAGE_SHIFT) != (start >> PAGE_SHIFT)) {
 732                         /* Handle frame across multiple pages: */
 733                         netvsc_packet->page_buf[0].len =
 734                                 (netvsc_packet->page_buf[0].pfn <<
 735                                  PAGE_SHIFT)
 736                                 + PAGE_SIZE - start;
 737                         bytes_remain = netvsc_packet->total_data_buflen -
 738                                         netvsc_packet->page_buf[0].len;
 739                         for (j = 1; j < NETVSC_PACKET_MAXPAGE; j++) {
 740                                 netvsc_packet->page_buf[j].offset = 0;
 741                                 if (bytes_remain <= PAGE_SIZE) {
 742                                         netvsc_packet->page_buf[j].len =
 743                                                 bytes_remain;
 744                                         bytes_remain = 0;
 745                                 } else {
 746                                         netvsc_packet->page_buf[j].len =
 747                                                 PAGE_SIZE;
 748                                         bytes_remain -= PAGE_SIZE;
 749                                 }
 750                                 netvsc_packet->page_buf[j].pfn =
 751                                     virt_to_phys((void *)(end_virtual -
 752                                                 bytes_remain)) >> PAGE_SHIFT;
 753                                 netvsc_packet->page_buf_cnt++;
 754                                 if (bytes_remain == 0)
 755                                         break;
 756                         }
 757                 }
 758
 759                 /* Pass it to the upper layer */
 760                 rndis_filter_receive(device, netvsc_packet);
 761
 762                 netvsc_receive_completion(netvsc_packet->
 763                                 completion.recv.recv_completion_ctx);
 764         }
 765
 766 }
 767
 768 static void netvsc_channel_cb(void *context)
 769 {
 770         int ret;
 771         struct hv_device *device = context;
 772         struct netvsc_device *net_device;
 773         u32 bytes_recvd;
 774         u64 request_id;
 775         unsigned char *packet;
 776         struct vmpacket_descriptor *desc;
 777         unsigned char *buffer;
 778         int bufferlen = NETVSC_PACKET_SIZE;
 779
 780         packet = kzalloc(NETVSC_PACKET_SIZE * sizeof(unsigned char),
 781                          GFP_ATOMIC);
 782         if (!packet)
 783                 return;
 784         buffer = packet;
 785
 786         net_device = get_inbound_net_device(device);
 787         if (!net_device) {
 788                 dev_err(&device->device, "net device (%p) shutting down..."
 789                            "ignoring inbound packets", net_device);
 790                 goto out;
 791         }
 792
 793         do {
 794                 ret = vmbus_recvpacket_raw(device->channel, buffer, bufferlen,
 795                                            &bytes_recvd, &request_id);
 796                 if (ret == 0) {
 797                         if (bytes_recvd > 0) {
 798                                 desc = (struct vmpacket_descriptor *)buffer;
 799                                 switch (desc->type) {
 800                                 case VM_PKT_COMP:
 801                                         netvsc_send_completion(device, desc);
 802                                         break;
 803
 804                                 case VM_PKT_DATA_USING_XFER_PAGES:
 805                                         netvsc_receive(device, desc);
 806                                         break;
 807
 808                                 default:
 809                                         dev_err(&device->device,
 810                                                    "unhandled packet type %d, "
 811                                                    "tid %llx len %d\n",
 812                                                    desc->type, request_id,
 813                                                    bytes_recvd);
 814                                         break;
 815                                 }
 816
 817                                 /* reset */
 818                                 if (bufferlen > NETVSC_PACKET_SIZE) {
 819                                         kfree(buffer);
 820                                         buffer = packet;
 821                                         bufferlen = NETVSC_PACKET_SIZE;
 822                                 }
 823                         } else {
 824                                 /* reset */
 825                                 if (bufferlen > NETVSC_PACKET_SIZE) {
 826                                         kfree(buffer);
 827                                         buffer = packet;
 828                                         bufferlen = NETVSC_PACKET_SIZE;
 829                                 }
 830
 831                                 break;
 832                         }
 833                 } else if (ret == -ENOBUFS) {
 834                         /* Handle large packet */
 835                         buffer = kmalloc(bytes_recvd, GFP_ATOMIC);
 836                         if (buffer == NULL) {
 837                                 /* Try again next time around */
 838                                 dev_err(&device->device,
 839                                            "unable to allocate buffer of size "
 840                                            "(%d)!!", bytes_recvd);
 841                                 break;
 842                         }
 843
 844                         bufferlen = bytes_recvd;
 845                 }
 846         } while (1);
 847
 848 out:
 849         kfree(buffer);
 850         return;
 851 }
 852
 853 /*
 854  * netvsc_device_add - Callback when the device belonging to this
 855  * driver is added
 856  */
 857 int netvsc_device_add(struct hv_device *device, void *additional_info)
 858 {
 859         int ret = 0;
 860         int i;
 861         int ring_size =
 862         ((struct netvsc_device_info *)additional_info)->ring_size;
 863         struct netvsc_device *net_device;
 864         struct hv_netvsc_packet *packet, *pos;
 865
 866         net_device = alloc_net_device(device);
 867         if (!net_device) {
 868                 ret = -ENOMEM;
 869                 goto cleanup;
 870         }
 871
 872         /* Initialize the NetVSC channel extension */
 873         net_device->recv_buf_size = NETVSC_RECEIVE_BUFFER_SIZE;
 874         spin_lock_init(&net_device->recv_pkt_list_lock);
 875
 876         INIT_LIST_HEAD(&net_device->recv_pkt_list);
 877
 878         for (i = 0; i < NETVSC_RECEIVE_PACKETLIST_COUNT; i++) {
 879                 packet = kzalloc(sizeof(struct hv_netvsc_packet) +
 880                                  (NETVSC_RECEIVE_SG_COUNT *
 881                                   sizeof(struct hv_page_buffer)), GFP_KERNEL);
 882                 if (!packet)
 883                         break;
 884
 885                 list_add_tail(&packet->list_ent,
 886                               &net_device->recv_pkt_list);
 887         }
 888         init_completion(&net_device->channel_init_wait);
 889
 890         /* Open the channel */
 891         ret = vmbus_open(device->channel, ring_size * PAGE_SIZE,
 892                          ring_size * PAGE_SIZE, NULL, 0,
 893                          netvsc_channel_cb, device);
 894
 895         if (ret != 0) {
 896                 dev_err(&device->device, "unable to open channel: %d", ret);
 897                 goto cleanup;
 898         }
 899
 900         /* Channel is opened */
 901         pr_info("hv_netvsc channel opened successfully");
 902
 903         /* Connect with the NetVsp */
 904         ret = netvsc_connect_vsp(device);
 905         if (ret != 0) {
 906                 dev_err(&device->device,
 907                         "unable to connect to NetVSP - %d", ret);
 908                 goto close;
 909         }
 910
 911         return ret;
 912
 913 close:
 914         /* Now, we can close the channel safely */
 915         vmbus_close(device->channel);
 916
 917 cleanup:
 918
 919         if (net_device) {
 920                 list_for_each_entry_safe(packet, pos,
 921                                          &net_device->recv_pkt_list,
 922                                          list_ent) {
 923                         list_del(&packet->list_ent);
 924                         kfree(packet);
 925                 }
 926
 927                 kfree(net_device);
 928         }
 929
 930         return ret;
 931 }