195fa0405SHaiyang Zhang /* 295fa0405SHaiyang Zhang * Copyright (c) 2009, Microsoft Corporation. 395fa0405SHaiyang Zhang * 495fa0405SHaiyang Zhang * This program is free software; you can redistribute it and/or modify it 595fa0405SHaiyang Zhang * under the terms and conditions of the GNU General Public License, 695fa0405SHaiyang Zhang * version 2, as published by the Free Software Foundation. 795fa0405SHaiyang Zhang * 895fa0405SHaiyang Zhang * This program is distributed in the hope it will be useful, but WITHOUT 995fa0405SHaiyang Zhang * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 1095fa0405SHaiyang Zhang * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 1195fa0405SHaiyang Zhang * more details. 1295fa0405SHaiyang Zhang * 1395fa0405SHaiyang Zhang * You should have received a copy of the GNU General Public License along with 14adf8d3ffSJeff Kirsher * this program; if not, see <http://www.gnu.org/licenses/>. 1595fa0405SHaiyang Zhang * 1695fa0405SHaiyang Zhang * Authors: 1795fa0405SHaiyang Zhang * Haiyang Zhang <haiyangz@microsoft.com> 1895fa0405SHaiyang Zhang * Hank Janssen <hjanssen@microsoft.com> 1995fa0405SHaiyang Zhang */ 2095fa0405SHaiyang Zhang #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 2195fa0405SHaiyang Zhang 2295fa0405SHaiyang Zhang #include <linux/kernel.h> 2395fa0405SHaiyang Zhang #include <linux/sched.h> 2495fa0405SHaiyang Zhang #include <linux/wait.h> 2595fa0405SHaiyang Zhang #include <linux/mm.h> 2695fa0405SHaiyang Zhang #include <linux/delay.h> 2795fa0405SHaiyang Zhang #include <linux/io.h> 2895fa0405SHaiyang Zhang #include <linux/slab.h> 2995fa0405SHaiyang Zhang #include <linux/netdevice.h> 30f157e78dSHaiyang Zhang #include <linux/if_ether.h> 31d6472302SStephen Rothwell #include <linux/vmalloc.h> 32c25aaf81SKY Srinivasan #include <asm/sync_bitops.h> 3395fa0405SHaiyang Zhang 3495fa0405SHaiyang Zhang #include "hyperv_net.h" 3595fa0405SHaiyang Zhang 3695fa0405SHaiyang Zhang 3795fa0405SHaiyang Zhang static struct netvsc_device *alloc_net_device(struct hv_device *device) 3895fa0405SHaiyang Zhang { 3995fa0405SHaiyang Zhang struct netvsc_device *net_device; 4095fa0405SHaiyang Zhang struct net_device *ndev = hv_get_drvdata(device); 417c3877f2SHaiyang Zhang int i; 4295fa0405SHaiyang Zhang 4395fa0405SHaiyang Zhang net_device = kzalloc(sizeof(struct netvsc_device), GFP_KERNEL); 4495fa0405SHaiyang Zhang if (!net_device) 4595fa0405SHaiyang Zhang return NULL; 4695fa0405SHaiyang Zhang 47f90251c8SHaiyang Zhang net_device->cb_buffer = kzalloc(NETVSC_PACKET_SIZE, GFP_KERNEL); 48f90251c8SHaiyang Zhang if (!net_device->cb_buffer) { 49f90251c8SHaiyang Zhang kfree(net_device); 50f90251c8SHaiyang Zhang return NULL; 51f90251c8SHaiyang Zhang } 52f90251c8SHaiyang Zhang 53dc5cd894SHaiyang Zhang init_waitqueue_head(&net_device->wait_drain); 544d447c9aSHaiyang Zhang net_device->start_remove = false; 5595fa0405SHaiyang Zhang net_device->destroy = false; 5695fa0405SHaiyang Zhang net_device->dev = device; 5795fa0405SHaiyang Zhang net_device->ndev = ndev; 587c3877f2SHaiyang Zhang net_device->max_pkt = RNDIS_MAX_PKT_DEFAULT; 597c3877f2SHaiyang Zhang net_device->pkt_align = RNDIS_PKT_ALIGN_DEFAULT; 607c3877f2SHaiyang Zhang 617c3877f2SHaiyang Zhang for (i = 0; i < num_online_cpus(); i++) 627c3877f2SHaiyang Zhang spin_lock_init(&net_device->msd[i].lock); 6395fa0405SHaiyang Zhang 6495fa0405SHaiyang Zhang hv_set_drvdata(device, net_device); 6595fa0405SHaiyang Zhang return net_device; 6695fa0405SHaiyang Zhang } 6795fa0405SHaiyang Zhang 68f90251c8SHaiyang Zhang static void free_netvsc_device(struct netvsc_device *nvdev) 69f90251c8SHaiyang Zhang { 70f90251c8SHaiyang Zhang kfree(nvdev->cb_buffer); 71f90251c8SHaiyang Zhang kfree(nvdev); 72f90251c8SHaiyang Zhang } 73f90251c8SHaiyang Zhang 7495fa0405SHaiyang Zhang static struct netvsc_device *get_outbound_net_device(struct hv_device *device) 7595fa0405SHaiyang Zhang { 7695fa0405SHaiyang Zhang struct netvsc_device *net_device; 7795fa0405SHaiyang Zhang 7895fa0405SHaiyang Zhang net_device = hv_get_drvdata(device); 7995fa0405SHaiyang Zhang if (net_device && net_device->destroy) 8095fa0405SHaiyang Zhang net_device = NULL; 8195fa0405SHaiyang Zhang 8295fa0405SHaiyang Zhang return net_device; 8395fa0405SHaiyang Zhang } 8495fa0405SHaiyang Zhang 8595fa0405SHaiyang Zhang static struct netvsc_device *get_inbound_net_device(struct hv_device *device) 8695fa0405SHaiyang Zhang { 8795fa0405SHaiyang Zhang struct netvsc_device *net_device; 8895fa0405SHaiyang Zhang 8995fa0405SHaiyang Zhang net_device = hv_get_drvdata(device); 9095fa0405SHaiyang Zhang 9195fa0405SHaiyang Zhang if (!net_device) 9295fa0405SHaiyang Zhang goto get_in_err; 9395fa0405SHaiyang Zhang 9495fa0405SHaiyang Zhang if (net_device->destroy && 9595fa0405SHaiyang Zhang atomic_read(&net_device->num_outstanding_sends) == 0) 9695fa0405SHaiyang Zhang net_device = NULL; 9795fa0405SHaiyang Zhang 9895fa0405SHaiyang Zhang get_in_err: 9995fa0405SHaiyang Zhang return net_device; 10095fa0405SHaiyang Zhang } 10195fa0405SHaiyang Zhang 10295fa0405SHaiyang Zhang 103c25aaf81SKY Srinivasan static int netvsc_destroy_buf(struct netvsc_device *net_device) 10495fa0405SHaiyang Zhang { 10595fa0405SHaiyang Zhang struct nvsp_message *revoke_packet; 10695fa0405SHaiyang Zhang int ret = 0; 10795fa0405SHaiyang Zhang struct net_device *ndev = net_device->ndev; 10895fa0405SHaiyang Zhang 10995fa0405SHaiyang Zhang /* 11095fa0405SHaiyang Zhang * If we got a section count, it means we received a 11195fa0405SHaiyang Zhang * SendReceiveBufferComplete msg (ie sent 11295fa0405SHaiyang Zhang * NvspMessage1TypeSendReceiveBuffer msg) therefore, we need 11395fa0405SHaiyang Zhang * to send a revoke msg here 11495fa0405SHaiyang Zhang */ 11595fa0405SHaiyang Zhang if (net_device->recv_section_cnt) { 11695fa0405SHaiyang Zhang /* Send the revoke receive buffer */ 11795fa0405SHaiyang Zhang revoke_packet = &net_device->revoke_packet; 11895fa0405SHaiyang Zhang memset(revoke_packet, 0, sizeof(struct nvsp_message)); 11995fa0405SHaiyang Zhang 12095fa0405SHaiyang Zhang revoke_packet->hdr.msg_type = 12195fa0405SHaiyang Zhang NVSP_MSG1_TYPE_REVOKE_RECV_BUF; 12295fa0405SHaiyang Zhang revoke_packet->msg.v1_msg. 12395fa0405SHaiyang Zhang revoke_recv_buf.id = NETVSC_RECEIVE_BUFFER_ID; 12495fa0405SHaiyang Zhang 12595fa0405SHaiyang Zhang ret = vmbus_sendpacket(net_device->dev->channel, 12695fa0405SHaiyang Zhang revoke_packet, 12795fa0405SHaiyang Zhang sizeof(struct nvsp_message), 12895fa0405SHaiyang Zhang (unsigned long)revoke_packet, 12995fa0405SHaiyang Zhang VM_PKT_DATA_INBAND, 0); 13095fa0405SHaiyang Zhang /* 13195fa0405SHaiyang Zhang * If we failed here, we might as well return and 13295fa0405SHaiyang Zhang * have a leak rather than continue and a bugchk 13395fa0405SHaiyang Zhang */ 13495fa0405SHaiyang Zhang if (ret != 0) { 13595fa0405SHaiyang Zhang netdev_err(ndev, "unable to send " 13695fa0405SHaiyang Zhang "revoke receive buffer to netvsp\n"); 13795fa0405SHaiyang Zhang return ret; 13895fa0405SHaiyang Zhang } 13995fa0405SHaiyang Zhang } 14095fa0405SHaiyang Zhang 14195fa0405SHaiyang Zhang /* Teardown the gpadl on the vsp end */ 14295fa0405SHaiyang Zhang if (net_device->recv_buf_gpadl_handle) { 14395fa0405SHaiyang Zhang ret = vmbus_teardown_gpadl(net_device->dev->channel, 14495fa0405SHaiyang Zhang net_device->recv_buf_gpadl_handle); 14595fa0405SHaiyang Zhang 14695fa0405SHaiyang Zhang /* If we failed here, we might as well return and have a leak 14795fa0405SHaiyang Zhang * rather than continue and a bugchk 14895fa0405SHaiyang Zhang */ 14995fa0405SHaiyang Zhang if (ret != 0) { 15095fa0405SHaiyang Zhang netdev_err(ndev, 15195fa0405SHaiyang Zhang "unable to teardown receive buffer's gpadl\n"); 15295fa0405SHaiyang Zhang return ret; 15395fa0405SHaiyang Zhang } 15495fa0405SHaiyang Zhang net_device->recv_buf_gpadl_handle = 0; 15595fa0405SHaiyang Zhang } 15695fa0405SHaiyang Zhang 15795fa0405SHaiyang Zhang if (net_device->recv_buf) { 15895fa0405SHaiyang Zhang /* Free up the receive buffer */ 159b679ef73SHaiyang Zhang vfree(net_device->recv_buf); 16095fa0405SHaiyang Zhang net_device->recv_buf = NULL; 16195fa0405SHaiyang Zhang } 16295fa0405SHaiyang Zhang 16395fa0405SHaiyang Zhang if (net_device->recv_section) { 16495fa0405SHaiyang Zhang net_device->recv_section_cnt = 0; 16595fa0405SHaiyang Zhang kfree(net_device->recv_section); 16695fa0405SHaiyang Zhang net_device->recv_section = NULL; 16795fa0405SHaiyang Zhang } 16895fa0405SHaiyang Zhang 169c25aaf81SKY Srinivasan /* Deal with the send buffer we may have setup. 170c25aaf81SKY Srinivasan * If we got a send section size, it means we received a 171c51ed182SHaiyang Zhang * NVSP_MSG1_TYPE_SEND_SEND_BUF_COMPLETE msg (ie sent 172c51ed182SHaiyang Zhang * NVSP_MSG1_TYPE_SEND_SEND_BUF msg) therefore, we need 173c25aaf81SKY Srinivasan * to send a revoke msg here 174c25aaf81SKY Srinivasan */ 175c25aaf81SKY Srinivasan if (net_device->send_section_size) { 176c25aaf81SKY Srinivasan /* Send the revoke receive buffer */ 177c25aaf81SKY Srinivasan revoke_packet = &net_device->revoke_packet; 178c25aaf81SKY Srinivasan memset(revoke_packet, 0, sizeof(struct nvsp_message)); 179c25aaf81SKY Srinivasan 180c25aaf81SKY Srinivasan revoke_packet->hdr.msg_type = 181c25aaf81SKY Srinivasan NVSP_MSG1_TYPE_REVOKE_SEND_BUF; 182c51ed182SHaiyang Zhang revoke_packet->msg.v1_msg.revoke_send_buf.id = 183c51ed182SHaiyang Zhang NETVSC_SEND_BUFFER_ID; 184c25aaf81SKY Srinivasan 185c25aaf81SKY Srinivasan ret = vmbus_sendpacket(net_device->dev->channel, 186c25aaf81SKY Srinivasan revoke_packet, 187c25aaf81SKY Srinivasan sizeof(struct nvsp_message), 188c25aaf81SKY Srinivasan (unsigned long)revoke_packet, 189c25aaf81SKY Srinivasan VM_PKT_DATA_INBAND, 0); 190c25aaf81SKY Srinivasan /* If we failed here, we might as well return and 191c25aaf81SKY Srinivasan * have a leak rather than continue and a bugchk 192c25aaf81SKY Srinivasan */ 193c25aaf81SKY Srinivasan if (ret != 0) { 194c25aaf81SKY Srinivasan netdev_err(ndev, "unable to send " 195c25aaf81SKY Srinivasan "revoke send buffer to netvsp\n"); 196c25aaf81SKY Srinivasan return ret; 197c25aaf81SKY Srinivasan } 198c25aaf81SKY Srinivasan } 199c25aaf81SKY Srinivasan /* Teardown the gpadl on the vsp end */ 200c25aaf81SKY Srinivasan if (net_device->send_buf_gpadl_handle) { 201c25aaf81SKY Srinivasan ret = vmbus_teardown_gpadl(net_device->dev->channel, 202c25aaf81SKY Srinivasan net_device->send_buf_gpadl_handle); 203c25aaf81SKY Srinivasan 204c25aaf81SKY Srinivasan /* If we failed here, we might as well return and have a leak 205c25aaf81SKY Srinivasan * rather than continue and a bugchk 206c25aaf81SKY Srinivasan */ 207c25aaf81SKY Srinivasan if (ret != 0) { 208c25aaf81SKY Srinivasan netdev_err(ndev, 209c25aaf81SKY Srinivasan "unable to teardown send buffer's gpadl\n"); 210c25aaf81SKY Srinivasan return ret; 211c25aaf81SKY Srinivasan } 2122f18423dSDave Jones net_device->send_buf_gpadl_handle = 0; 213c25aaf81SKY Srinivasan } 214c25aaf81SKY Srinivasan if (net_device->send_buf) { 215c51ed182SHaiyang Zhang /* Free up the send buffer */ 21606b47aacSKY Srinivasan vfree(net_device->send_buf); 217c25aaf81SKY Srinivasan net_device->send_buf = NULL; 218c25aaf81SKY Srinivasan } 219c25aaf81SKY Srinivasan kfree(net_device->send_section_map); 220c25aaf81SKY Srinivasan 22195fa0405SHaiyang Zhang return ret; 22295fa0405SHaiyang Zhang } 22395fa0405SHaiyang Zhang 224c25aaf81SKY Srinivasan static int netvsc_init_buf(struct hv_device *device) 22595fa0405SHaiyang Zhang { 22695fa0405SHaiyang Zhang int ret = 0; 2277390fe9cSNicholas Mc Guire unsigned long t; 22895fa0405SHaiyang Zhang struct netvsc_device *net_device; 22995fa0405SHaiyang Zhang struct nvsp_message *init_packet; 23095fa0405SHaiyang Zhang struct net_device *ndev; 2310a726c2bSK. Y. Srinivasan int node; 23295fa0405SHaiyang Zhang 23395fa0405SHaiyang Zhang net_device = get_outbound_net_device(device); 23495fa0405SHaiyang Zhang if (!net_device) 23595fa0405SHaiyang Zhang return -ENODEV; 23695fa0405SHaiyang Zhang ndev = net_device->ndev; 23795fa0405SHaiyang Zhang 2380a726c2bSK. Y. Srinivasan node = cpu_to_node(device->channel->target_cpu); 2390a726c2bSK. Y. Srinivasan net_device->recv_buf = vzalloc_node(net_device->recv_buf_size, node); 2400a726c2bSK. Y. Srinivasan if (!net_device->recv_buf) 241b679ef73SHaiyang Zhang net_device->recv_buf = vzalloc(net_device->recv_buf_size); 2420a726c2bSK. Y. Srinivasan 24395fa0405SHaiyang Zhang if (!net_device->recv_buf) { 24495fa0405SHaiyang Zhang netdev_err(ndev, "unable to allocate receive " 24595fa0405SHaiyang Zhang "buffer of size %d\n", net_device->recv_buf_size); 24695fa0405SHaiyang Zhang ret = -ENOMEM; 24795fa0405SHaiyang Zhang goto cleanup; 24895fa0405SHaiyang Zhang } 24995fa0405SHaiyang Zhang 25095fa0405SHaiyang Zhang /* 25195fa0405SHaiyang Zhang * Establish the gpadl handle for this buffer on this 25295fa0405SHaiyang Zhang * channel. Note: This call uses the vmbus connection rather 25395fa0405SHaiyang Zhang * than the channel to establish the gpadl handle. 25495fa0405SHaiyang Zhang */ 25595fa0405SHaiyang Zhang ret = vmbus_establish_gpadl(device->channel, net_device->recv_buf, 25695fa0405SHaiyang Zhang net_device->recv_buf_size, 25795fa0405SHaiyang Zhang &net_device->recv_buf_gpadl_handle); 25895fa0405SHaiyang Zhang if (ret != 0) { 25995fa0405SHaiyang Zhang netdev_err(ndev, 26095fa0405SHaiyang Zhang "unable to establish receive buffer's gpadl\n"); 26195fa0405SHaiyang Zhang goto cleanup; 26295fa0405SHaiyang Zhang } 26395fa0405SHaiyang Zhang 26495fa0405SHaiyang Zhang 26595fa0405SHaiyang Zhang /* Notify the NetVsp of the gpadl handle */ 26695fa0405SHaiyang Zhang init_packet = &net_device->channel_init_pkt; 26795fa0405SHaiyang Zhang 26895fa0405SHaiyang Zhang memset(init_packet, 0, sizeof(struct nvsp_message)); 26995fa0405SHaiyang Zhang 27095fa0405SHaiyang Zhang init_packet->hdr.msg_type = NVSP_MSG1_TYPE_SEND_RECV_BUF; 27195fa0405SHaiyang Zhang init_packet->msg.v1_msg.send_recv_buf. 27295fa0405SHaiyang Zhang gpadl_handle = net_device->recv_buf_gpadl_handle; 27395fa0405SHaiyang Zhang init_packet->msg.v1_msg. 27495fa0405SHaiyang Zhang send_recv_buf.id = NETVSC_RECEIVE_BUFFER_ID; 27595fa0405SHaiyang Zhang 27695fa0405SHaiyang Zhang /* Send the gpadl notification request */ 27795fa0405SHaiyang Zhang ret = vmbus_sendpacket(device->channel, init_packet, 27895fa0405SHaiyang Zhang sizeof(struct nvsp_message), 27995fa0405SHaiyang Zhang (unsigned long)init_packet, 28095fa0405SHaiyang Zhang VM_PKT_DATA_INBAND, 28195fa0405SHaiyang Zhang VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED); 28295fa0405SHaiyang Zhang if (ret != 0) { 28395fa0405SHaiyang Zhang netdev_err(ndev, 28495fa0405SHaiyang Zhang "unable to send receive buffer's gpadl to netvsp\n"); 28595fa0405SHaiyang Zhang goto cleanup; 28695fa0405SHaiyang Zhang } 28795fa0405SHaiyang Zhang 28895fa0405SHaiyang Zhang t = wait_for_completion_timeout(&net_device->channel_init_wait, 5*HZ); 28995fa0405SHaiyang Zhang BUG_ON(t == 0); 29095fa0405SHaiyang Zhang 29195fa0405SHaiyang Zhang 29295fa0405SHaiyang Zhang /* Check the response */ 29395fa0405SHaiyang Zhang if (init_packet->msg.v1_msg. 29495fa0405SHaiyang Zhang send_recv_buf_complete.status != NVSP_STAT_SUCCESS) { 29595fa0405SHaiyang Zhang netdev_err(ndev, "Unable to complete receive buffer " 29695fa0405SHaiyang Zhang "initialization with NetVsp - status %d\n", 29795fa0405SHaiyang Zhang init_packet->msg.v1_msg. 29895fa0405SHaiyang Zhang send_recv_buf_complete.status); 29995fa0405SHaiyang Zhang ret = -EINVAL; 30095fa0405SHaiyang Zhang goto cleanup; 30195fa0405SHaiyang Zhang } 30295fa0405SHaiyang Zhang 30395fa0405SHaiyang Zhang /* Parse the response */ 30495fa0405SHaiyang Zhang 30595fa0405SHaiyang Zhang net_device->recv_section_cnt = init_packet->msg. 30695fa0405SHaiyang Zhang v1_msg.send_recv_buf_complete.num_sections; 30795fa0405SHaiyang Zhang 308c1813200SHaiyang Zhang net_device->recv_section = kmemdup( 309c1813200SHaiyang Zhang init_packet->msg.v1_msg.send_recv_buf_complete.sections, 310c1813200SHaiyang Zhang net_device->recv_section_cnt * 311c1813200SHaiyang Zhang sizeof(struct nvsp_1_receive_buffer_section), 31295fa0405SHaiyang Zhang GFP_KERNEL); 31395fa0405SHaiyang Zhang if (net_device->recv_section == NULL) { 31495fa0405SHaiyang Zhang ret = -EINVAL; 31595fa0405SHaiyang Zhang goto cleanup; 31695fa0405SHaiyang Zhang } 31795fa0405SHaiyang Zhang 31895fa0405SHaiyang Zhang /* 31995fa0405SHaiyang Zhang * For 1st release, there should only be 1 section that represents the 32095fa0405SHaiyang Zhang * entire receive buffer 32195fa0405SHaiyang Zhang */ 32295fa0405SHaiyang Zhang if (net_device->recv_section_cnt != 1 || 32395fa0405SHaiyang Zhang net_device->recv_section->offset != 0) { 32495fa0405SHaiyang Zhang ret = -EINVAL; 32595fa0405SHaiyang Zhang goto cleanup; 32695fa0405SHaiyang Zhang } 32795fa0405SHaiyang Zhang 328c25aaf81SKY Srinivasan /* Now setup the send buffer. 329c25aaf81SKY Srinivasan */ 3305defde59SK. Y. Srinivasan net_device->send_buf = vzalloc_node(net_device->send_buf_size, node); 3315defde59SK. Y. Srinivasan if (!net_device->send_buf) 33206b47aacSKY Srinivasan net_device->send_buf = vzalloc(net_device->send_buf_size); 333c25aaf81SKY Srinivasan if (!net_device->send_buf) { 334c25aaf81SKY Srinivasan netdev_err(ndev, "unable to allocate send " 335c25aaf81SKY Srinivasan "buffer of size %d\n", net_device->send_buf_size); 336c25aaf81SKY Srinivasan ret = -ENOMEM; 337c25aaf81SKY Srinivasan goto cleanup; 338c25aaf81SKY Srinivasan } 339c25aaf81SKY Srinivasan 340c25aaf81SKY Srinivasan /* Establish the gpadl handle for this buffer on this 341c25aaf81SKY Srinivasan * channel. Note: This call uses the vmbus connection rather 342c25aaf81SKY Srinivasan * than the channel to establish the gpadl handle. 343c25aaf81SKY Srinivasan */ 344c25aaf81SKY Srinivasan ret = vmbus_establish_gpadl(device->channel, net_device->send_buf, 345c25aaf81SKY Srinivasan net_device->send_buf_size, 346c25aaf81SKY Srinivasan &net_device->send_buf_gpadl_handle); 347c25aaf81SKY Srinivasan if (ret != 0) { 348c25aaf81SKY Srinivasan netdev_err(ndev, 349c25aaf81SKY Srinivasan "unable to establish send buffer's gpadl\n"); 350c25aaf81SKY Srinivasan goto cleanup; 351c25aaf81SKY Srinivasan } 352c25aaf81SKY Srinivasan 353c25aaf81SKY Srinivasan /* Notify the NetVsp of the gpadl handle */ 354c25aaf81SKY Srinivasan init_packet = &net_device->channel_init_pkt; 355c25aaf81SKY Srinivasan memset(init_packet, 0, sizeof(struct nvsp_message)); 356c25aaf81SKY Srinivasan init_packet->hdr.msg_type = NVSP_MSG1_TYPE_SEND_SEND_BUF; 357c51ed182SHaiyang Zhang init_packet->msg.v1_msg.send_send_buf.gpadl_handle = 358c25aaf81SKY Srinivasan net_device->send_buf_gpadl_handle; 359c51ed182SHaiyang Zhang init_packet->msg.v1_msg.send_send_buf.id = NETVSC_SEND_BUFFER_ID; 360c25aaf81SKY Srinivasan 361c25aaf81SKY Srinivasan /* Send the gpadl notification request */ 362c25aaf81SKY Srinivasan ret = vmbus_sendpacket(device->channel, init_packet, 363c25aaf81SKY Srinivasan sizeof(struct nvsp_message), 364c25aaf81SKY Srinivasan (unsigned long)init_packet, 365c25aaf81SKY Srinivasan VM_PKT_DATA_INBAND, 366c25aaf81SKY Srinivasan VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED); 367c25aaf81SKY Srinivasan if (ret != 0) { 368c25aaf81SKY Srinivasan netdev_err(ndev, 369c25aaf81SKY Srinivasan "unable to send send buffer's gpadl to netvsp\n"); 370c25aaf81SKY Srinivasan goto cleanup; 371c25aaf81SKY Srinivasan } 372c25aaf81SKY Srinivasan 373c25aaf81SKY Srinivasan t = wait_for_completion_timeout(&net_device->channel_init_wait, 5*HZ); 374c25aaf81SKY Srinivasan BUG_ON(t == 0); 375c25aaf81SKY Srinivasan 376c25aaf81SKY Srinivasan /* Check the response */ 377c25aaf81SKY Srinivasan if (init_packet->msg.v1_msg. 378c25aaf81SKY Srinivasan send_send_buf_complete.status != NVSP_STAT_SUCCESS) { 379c25aaf81SKY Srinivasan netdev_err(ndev, "Unable to complete send buffer " 380c25aaf81SKY Srinivasan "initialization with NetVsp - status %d\n", 381c25aaf81SKY Srinivasan init_packet->msg.v1_msg. 382c51ed182SHaiyang Zhang send_send_buf_complete.status); 383c25aaf81SKY Srinivasan ret = -EINVAL; 384c25aaf81SKY Srinivasan goto cleanup; 385c25aaf81SKY Srinivasan } 386c25aaf81SKY Srinivasan 387c25aaf81SKY Srinivasan /* Parse the response */ 388c25aaf81SKY Srinivasan net_device->send_section_size = init_packet->msg. 389c25aaf81SKY Srinivasan v1_msg.send_send_buf_complete.section_size; 390c25aaf81SKY Srinivasan 391c25aaf81SKY Srinivasan /* Section count is simply the size divided by the section size. 392c25aaf81SKY Srinivasan */ 393c25aaf81SKY Srinivasan net_device->send_section_cnt = 394c25aaf81SKY Srinivasan net_device->send_buf_size/net_device->send_section_size; 395c25aaf81SKY Srinivasan 396c25aaf81SKY Srinivasan dev_info(&device->device, "Send section size: %d, Section count:%d\n", 397c25aaf81SKY Srinivasan net_device->send_section_size, net_device->send_section_cnt); 398c25aaf81SKY Srinivasan 399c25aaf81SKY Srinivasan /* Setup state for managing the send buffer. */ 400c25aaf81SKY Srinivasan net_device->map_words = DIV_ROUND_UP(net_device->send_section_cnt, 401c25aaf81SKY Srinivasan BITS_PER_LONG); 402c25aaf81SKY Srinivasan 403c25aaf81SKY Srinivasan net_device->send_section_map = 404c25aaf81SKY Srinivasan kzalloc(net_device->map_words * sizeof(ulong), GFP_KERNEL); 405dd1d3f8fSWei Yongjun if (net_device->send_section_map == NULL) { 406dd1d3f8fSWei Yongjun ret = -ENOMEM; 407c25aaf81SKY Srinivasan goto cleanup; 408dd1d3f8fSWei Yongjun } 409c25aaf81SKY Srinivasan 41095fa0405SHaiyang Zhang goto exit; 41195fa0405SHaiyang Zhang 41295fa0405SHaiyang Zhang cleanup: 413c25aaf81SKY Srinivasan netvsc_destroy_buf(net_device); 41495fa0405SHaiyang Zhang 41595fa0405SHaiyang Zhang exit: 41695fa0405SHaiyang Zhang return ret; 41795fa0405SHaiyang Zhang } 41895fa0405SHaiyang Zhang 41995fa0405SHaiyang Zhang 420f157e78dSHaiyang Zhang /* Negotiate NVSP protocol version */ 421f157e78dSHaiyang Zhang static int negotiate_nvsp_ver(struct hv_device *device, 422f157e78dSHaiyang Zhang struct netvsc_device *net_device, 423f157e78dSHaiyang Zhang struct nvsp_message *init_packet, 424f157e78dSHaiyang Zhang u32 nvsp_ver) 42595fa0405SHaiyang Zhang { 4267390fe9cSNicholas Mc Guire int ret; 4277390fe9cSNicholas Mc Guire unsigned long t; 428f157e78dSHaiyang Zhang 429f157e78dSHaiyang Zhang memset(init_packet, 0, sizeof(struct nvsp_message)); 430f157e78dSHaiyang Zhang init_packet->hdr.msg_type = NVSP_MSG_TYPE_INIT; 431f157e78dSHaiyang Zhang init_packet->msg.init_msg.init.min_protocol_ver = nvsp_ver; 432f157e78dSHaiyang Zhang init_packet->msg.init_msg.init.max_protocol_ver = nvsp_ver; 433f157e78dSHaiyang Zhang 434f157e78dSHaiyang Zhang /* Send the init request */ 435f157e78dSHaiyang Zhang ret = vmbus_sendpacket(device->channel, init_packet, 436f157e78dSHaiyang Zhang sizeof(struct nvsp_message), 437f157e78dSHaiyang Zhang (unsigned long)init_packet, 438f157e78dSHaiyang Zhang VM_PKT_DATA_INBAND, 439f157e78dSHaiyang Zhang VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED); 440f157e78dSHaiyang Zhang 441f157e78dSHaiyang Zhang if (ret != 0) 442f157e78dSHaiyang Zhang return ret; 443f157e78dSHaiyang Zhang 444f157e78dSHaiyang Zhang t = wait_for_completion_timeout(&net_device->channel_init_wait, 5*HZ); 445f157e78dSHaiyang Zhang 446f157e78dSHaiyang Zhang if (t == 0) 447f157e78dSHaiyang Zhang return -ETIMEDOUT; 448f157e78dSHaiyang Zhang 449f157e78dSHaiyang Zhang if (init_packet->msg.init_msg.init_complete.status != 450f157e78dSHaiyang Zhang NVSP_STAT_SUCCESS) 451f157e78dSHaiyang Zhang return -EINVAL; 452f157e78dSHaiyang Zhang 453a1eabb01SHaiyang Zhang if (nvsp_ver == NVSP_PROTOCOL_VERSION_1) 454f157e78dSHaiyang Zhang return 0; 455f157e78dSHaiyang Zhang 45671790a27SHaiyang Zhang /* NVSPv2 or later: Send NDIS config */ 457f157e78dSHaiyang Zhang memset(init_packet, 0, sizeof(struct nvsp_message)); 458f157e78dSHaiyang Zhang init_packet->hdr.msg_type = NVSP_MSG2_TYPE_SEND_NDIS_CONFIG; 4594d3c9d37SHaiyang Zhang init_packet->msg.v2_msg.send_ndis_config.mtu = net_device->ndev->mtu + 4604d3c9d37SHaiyang Zhang ETH_HLEN; 4611f5f3a75SHaiyang Zhang init_packet->msg.v2_msg.send_ndis_config.capability.ieee8021q = 1; 462f157e78dSHaiyang Zhang 46371790a27SHaiyang Zhang if (nvsp_ver >= NVSP_PROTOCOL_VERSION_5) 46471790a27SHaiyang Zhang init_packet->msg.v2_msg.send_ndis_config.capability.sriov = 1; 46571790a27SHaiyang Zhang 466f157e78dSHaiyang Zhang ret = vmbus_sendpacket(device->channel, init_packet, 467f157e78dSHaiyang Zhang sizeof(struct nvsp_message), 468f157e78dSHaiyang Zhang (unsigned long)init_packet, 469f157e78dSHaiyang Zhang VM_PKT_DATA_INBAND, 0); 470f157e78dSHaiyang Zhang 471f157e78dSHaiyang Zhang return ret; 472f157e78dSHaiyang Zhang } 473f157e78dSHaiyang Zhang 474f157e78dSHaiyang Zhang static int netvsc_connect_vsp(struct hv_device *device) 475f157e78dSHaiyang Zhang { 476f157e78dSHaiyang Zhang int ret; 47795fa0405SHaiyang Zhang struct netvsc_device *net_device; 47895fa0405SHaiyang Zhang struct nvsp_message *init_packet; 47995fa0405SHaiyang Zhang int ndis_version; 48095fa0405SHaiyang Zhang struct net_device *ndev; 481a1eabb01SHaiyang Zhang u32 ver_list[] = { NVSP_PROTOCOL_VERSION_1, NVSP_PROTOCOL_VERSION_2, 482a1eabb01SHaiyang Zhang NVSP_PROTOCOL_VERSION_4, NVSP_PROTOCOL_VERSION_5 }; 483a1eabb01SHaiyang Zhang int i, num_ver = 4; /* number of different NVSP versions */ 48495fa0405SHaiyang Zhang 48595fa0405SHaiyang Zhang net_device = get_outbound_net_device(device); 48695fa0405SHaiyang Zhang if (!net_device) 48795fa0405SHaiyang Zhang return -ENODEV; 48895fa0405SHaiyang Zhang ndev = net_device->ndev; 48995fa0405SHaiyang Zhang 49095fa0405SHaiyang Zhang init_packet = &net_device->channel_init_pkt; 49195fa0405SHaiyang Zhang 492f157e78dSHaiyang Zhang /* Negotiate the latest NVSP protocol supported */ 493a1eabb01SHaiyang Zhang for (i = num_ver - 1; i >= 0; i--) 494f157e78dSHaiyang Zhang if (negotiate_nvsp_ver(device, net_device, init_packet, 495a1eabb01SHaiyang Zhang ver_list[i]) == 0) { 496a1eabb01SHaiyang Zhang net_device->nvsp_version = ver_list[i]; 497a1eabb01SHaiyang Zhang break; 498a1eabb01SHaiyang Zhang } 499a1eabb01SHaiyang Zhang 500a1eabb01SHaiyang Zhang if (i < 0) { 50195fa0405SHaiyang Zhang ret = -EPROTO; 50295fa0405SHaiyang Zhang goto cleanup; 50395fa0405SHaiyang Zhang } 504f157e78dSHaiyang Zhang 505f157e78dSHaiyang Zhang pr_debug("Negotiated NVSP version:%x\n", net_device->nvsp_version); 506f157e78dSHaiyang Zhang 50795fa0405SHaiyang Zhang /* Send the ndis version */ 50895fa0405SHaiyang Zhang memset(init_packet, 0, sizeof(struct nvsp_message)); 50995fa0405SHaiyang Zhang 510a1eabb01SHaiyang Zhang if (net_device->nvsp_version <= NVSP_PROTOCOL_VERSION_4) 5111f73db49SKY Srinivasan ndis_version = 0x00060001; 512a1eabb01SHaiyang Zhang else 513a1eabb01SHaiyang Zhang ndis_version = 0x0006001e; 51495fa0405SHaiyang Zhang 51595fa0405SHaiyang Zhang init_packet->hdr.msg_type = NVSP_MSG1_TYPE_SEND_NDIS_VER; 51695fa0405SHaiyang Zhang init_packet->msg.v1_msg. 51795fa0405SHaiyang Zhang send_ndis_ver.ndis_major_ver = 51895fa0405SHaiyang Zhang (ndis_version & 0xFFFF0000) >> 16; 51995fa0405SHaiyang Zhang init_packet->msg.v1_msg. 52095fa0405SHaiyang Zhang send_ndis_ver.ndis_minor_ver = 52195fa0405SHaiyang Zhang ndis_version & 0xFFFF; 52295fa0405SHaiyang Zhang 52395fa0405SHaiyang Zhang /* Send the init request */ 52495fa0405SHaiyang Zhang ret = vmbus_sendpacket(device->channel, init_packet, 52595fa0405SHaiyang Zhang sizeof(struct nvsp_message), 52695fa0405SHaiyang Zhang (unsigned long)init_packet, 52795fa0405SHaiyang Zhang VM_PKT_DATA_INBAND, 0); 52895fa0405SHaiyang Zhang if (ret != 0) 52995fa0405SHaiyang Zhang goto cleanup; 53095fa0405SHaiyang Zhang 53195fa0405SHaiyang Zhang /* Post the big receive buffer to NetVSP */ 53299d3016dSHaiyang Zhang if (net_device->nvsp_version <= NVSP_PROTOCOL_VERSION_2) 53399d3016dSHaiyang Zhang net_device->recv_buf_size = NETVSC_RECEIVE_BUFFER_SIZE_LEGACY; 53499d3016dSHaiyang Zhang else 53599d3016dSHaiyang Zhang net_device->recv_buf_size = NETVSC_RECEIVE_BUFFER_SIZE; 536c25aaf81SKY Srinivasan net_device->send_buf_size = NETVSC_SEND_BUFFER_SIZE; 53799d3016dSHaiyang Zhang 538c25aaf81SKY Srinivasan ret = netvsc_init_buf(device); 53995fa0405SHaiyang Zhang 54095fa0405SHaiyang Zhang cleanup: 54195fa0405SHaiyang Zhang return ret; 54295fa0405SHaiyang Zhang } 54395fa0405SHaiyang Zhang 54495fa0405SHaiyang Zhang static void netvsc_disconnect_vsp(struct netvsc_device *net_device) 54595fa0405SHaiyang Zhang { 546c25aaf81SKY Srinivasan netvsc_destroy_buf(net_device); 54795fa0405SHaiyang Zhang } 54895fa0405SHaiyang Zhang 54995fa0405SHaiyang Zhang /* 55095fa0405SHaiyang Zhang * netvsc_device_remove - Callback when the root bus device is removed 55195fa0405SHaiyang Zhang */ 55295fa0405SHaiyang Zhang int netvsc_device_remove(struct hv_device *device) 55395fa0405SHaiyang Zhang { 55495fa0405SHaiyang Zhang struct netvsc_device *net_device; 55595fa0405SHaiyang Zhang unsigned long flags; 55695fa0405SHaiyang Zhang 55795fa0405SHaiyang Zhang net_device = hv_get_drvdata(device); 55895fa0405SHaiyang Zhang 55995fa0405SHaiyang Zhang netvsc_disconnect_vsp(net_device); 56095fa0405SHaiyang Zhang 56195fa0405SHaiyang Zhang /* 56295fa0405SHaiyang Zhang * Since we have already drained, we don't need to busy wait 56395fa0405SHaiyang Zhang * as was done in final_release_stor_device() 56495fa0405SHaiyang Zhang * Note that we cannot set the ext pointer to NULL until 56595fa0405SHaiyang Zhang * we have drained - to drain the outgoing packets, we need to 56695fa0405SHaiyang Zhang * allow incoming packets. 56795fa0405SHaiyang Zhang */ 56895fa0405SHaiyang Zhang 56995fa0405SHaiyang Zhang spin_lock_irqsave(&device->channel->inbound_lock, flags); 57095fa0405SHaiyang Zhang hv_set_drvdata(device, NULL); 57195fa0405SHaiyang Zhang spin_unlock_irqrestore(&device->channel->inbound_lock, flags); 57295fa0405SHaiyang Zhang 57395fa0405SHaiyang Zhang /* 57495fa0405SHaiyang Zhang * At this point, no one should be accessing net_device 57595fa0405SHaiyang Zhang * except in here 57695fa0405SHaiyang Zhang */ 57795fa0405SHaiyang Zhang dev_notice(&device->device, "net device safe to remove\n"); 57895fa0405SHaiyang Zhang 57995fa0405SHaiyang Zhang /* Now, we can close the channel safely */ 58095fa0405SHaiyang Zhang vmbus_close(device->channel); 58195fa0405SHaiyang Zhang 58295fa0405SHaiyang Zhang /* Release all resources */ 5835b54dac8SHaiyang Zhang vfree(net_device->sub_cb_buf); 584f90251c8SHaiyang Zhang free_netvsc_device(net_device); 58595fa0405SHaiyang Zhang return 0; 58695fa0405SHaiyang Zhang } 58795fa0405SHaiyang Zhang 58833be96e4SHaiyang Zhang 58933be96e4SHaiyang Zhang #define RING_AVAIL_PERCENT_HIWATER 20 59033be96e4SHaiyang Zhang #define RING_AVAIL_PERCENT_LOWATER 10 59133be96e4SHaiyang Zhang 59233be96e4SHaiyang Zhang /* 59333be96e4SHaiyang Zhang * Get the percentage of available bytes to write in the ring. 59433be96e4SHaiyang Zhang * The return value is in range from 0 to 100. 59533be96e4SHaiyang Zhang */ 59633be96e4SHaiyang Zhang static inline u32 hv_ringbuf_avail_percent( 59733be96e4SHaiyang Zhang struct hv_ring_buffer_info *ring_info) 59833be96e4SHaiyang Zhang { 59933be96e4SHaiyang Zhang u32 avail_read, avail_write; 60033be96e4SHaiyang Zhang 60133be96e4SHaiyang Zhang hv_get_ringbuffer_availbytes(ring_info, &avail_read, &avail_write); 60233be96e4SHaiyang Zhang 60333be96e4SHaiyang Zhang return avail_write * 100 / ring_info->ring_datasize; 60433be96e4SHaiyang Zhang } 60533be96e4SHaiyang Zhang 606c25aaf81SKY Srinivasan static inline void netvsc_free_send_slot(struct netvsc_device *net_device, 607c25aaf81SKY Srinivasan u32 index) 608c25aaf81SKY Srinivasan { 609c25aaf81SKY Srinivasan sync_change_bit(index, net_device->send_section_map); 610c25aaf81SKY Srinivasan } 611c25aaf81SKY Srinivasan 61297c1723aSKY Srinivasan static void netvsc_send_completion(struct netvsc_device *net_device, 61325b85ee8SKY Srinivasan struct vmbus_channel *incoming_channel, 61497c1723aSKY Srinivasan struct hv_device *device, 61595fa0405SHaiyang Zhang struct vmpacket_descriptor *packet) 61695fa0405SHaiyang Zhang { 61795fa0405SHaiyang Zhang struct nvsp_message *nvsp_packet; 61895fa0405SHaiyang Zhang struct hv_netvsc_packet *nvsc_packet; 61995fa0405SHaiyang Zhang struct net_device *ndev; 620c25aaf81SKY Srinivasan u32 send_index; 62195fa0405SHaiyang Zhang 62295fa0405SHaiyang Zhang ndev = net_device->ndev; 62395fa0405SHaiyang Zhang 62495fa0405SHaiyang Zhang nvsp_packet = (struct nvsp_message *)((unsigned long)packet + 62595fa0405SHaiyang Zhang (packet->offset8 << 3)); 62695fa0405SHaiyang Zhang 62795fa0405SHaiyang Zhang if ((nvsp_packet->hdr.msg_type == NVSP_MSG_TYPE_INIT_COMPLETE) || 62895fa0405SHaiyang Zhang (nvsp_packet->hdr.msg_type == 62995fa0405SHaiyang Zhang NVSP_MSG1_TYPE_SEND_RECV_BUF_COMPLETE) || 63095fa0405SHaiyang Zhang (nvsp_packet->hdr.msg_type == 6315b54dac8SHaiyang Zhang NVSP_MSG1_TYPE_SEND_SEND_BUF_COMPLETE) || 6325b54dac8SHaiyang Zhang (nvsp_packet->hdr.msg_type == 6335b54dac8SHaiyang Zhang NVSP_MSG5_TYPE_SUBCHANNEL)) { 63495fa0405SHaiyang Zhang /* Copy the response back */ 63595fa0405SHaiyang Zhang memcpy(&net_device->channel_init_pkt, nvsp_packet, 63695fa0405SHaiyang Zhang sizeof(struct nvsp_message)); 63795fa0405SHaiyang Zhang complete(&net_device->channel_init_wait); 63895fa0405SHaiyang Zhang } else if (nvsp_packet->hdr.msg_type == 63995fa0405SHaiyang Zhang NVSP_MSG1_TYPE_SEND_RNDIS_PKT_COMPLETE) { 64033be96e4SHaiyang Zhang int num_outstanding_sends; 6415b54dac8SHaiyang Zhang u16 q_idx = 0; 6425b54dac8SHaiyang Zhang struct vmbus_channel *channel = device->channel; 6435b54dac8SHaiyang Zhang int queue_sends; 64433be96e4SHaiyang Zhang 64595fa0405SHaiyang Zhang /* Get the send context */ 64695fa0405SHaiyang Zhang nvsc_packet = (struct hv_netvsc_packet *)(unsigned long) 64795fa0405SHaiyang Zhang packet->trans_id; 64895fa0405SHaiyang Zhang 64995fa0405SHaiyang Zhang /* Notify the layer above us */ 6505b54dac8SHaiyang Zhang if (nvsc_packet) { 651c25aaf81SKY Srinivasan send_index = nvsc_packet->send_buf_index; 652c25aaf81SKY Srinivasan if (send_index != NETVSC_INVALID_INDEX) 653c25aaf81SKY Srinivasan netvsc_free_send_slot(net_device, send_index); 6545b54dac8SHaiyang Zhang q_idx = nvsc_packet->q_idx; 65525b85ee8SKY Srinivasan channel = incoming_channel; 656893f6627SHaiyang Zhang nvsc_packet->send_completion(nvsc_packet-> 657f1ea3cd7SHaiyang Zhang send_completion_ctx); 6585b54dac8SHaiyang Zhang } 65995fa0405SHaiyang Zhang 66033be96e4SHaiyang Zhang num_outstanding_sends = 66133be96e4SHaiyang Zhang atomic_dec_return(&net_device->num_outstanding_sends); 6625b54dac8SHaiyang Zhang queue_sends = atomic_dec_return(&net_device-> 6635b54dac8SHaiyang Zhang queue_sends[q_idx]); 6641d06825bSHaiyang Zhang 665dc5cd894SHaiyang Zhang if (net_device->destroy && num_outstanding_sends == 0) 666dc5cd894SHaiyang Zhang wake_up(&net_device->wait_drain); 667dc5cd894SHaiyang Zhang 6685b54dac8SHaiyang Zhang if (netif_tx_queue_stopped(netdev_get_tx_queue(ndev, q_idx)) && 6695b54dac8SHaiyang Zhang !net_device->start_remove && 6705b54dac8SHaiyang Zhang (hv_ringbuf_avail_percent(&channel->outbound) > 6715b54dac8SHaiyang Zhang RING_AVAIL_PERCENT_HIWATER || queue_sends < 1)) 6725b54dac8SHaiyang Zhang netif_tx_wake_queue(netdev_get_tx_queue( 6735b54dac8SHaiyang Zhang ndev, q_idx)); 67495fa0405SHaiyang Zhang } else { 67595fa0405SHaiyang Zhang netdev_err(ndev, "Unknown send completion packet type- " 67695fa0405SHaiyang Zhang "%d received!!\n", nvsp_packet->hdr.msg_type); 67795fa0405SHaiyang Zhang } 67895fa0405SHaiyang Zhang 67995fa0405SHaiyang Zhang } 68095fa0405SHaiyang Zhang 681c25aaf81SKY Srinivasan static u32 netvsc_get_next_send_section(struct netvsc_device *net_device) 682c25aaf81SKY Srinivasan { 683c25aaf81SKY Srinivasan unsigned long index; 684c25aaf81SKY Srinivasan u32 max_words = net_device->map_words; 685c25aaf81SKY Srinivasan unsigned long *map_addr = (unsigned long *)net_device->send_section_map; 686c25aaf81SKY Srinivasan u32 section_cnt = net_device->send_section_cnt; 687c25aaf81SKY Srinivasan int ret_val = NETVSC_INVALID_INDEX; 688c25aaf81SKY Srinivasan int i; 689c25aaf81SKY Srinivasan int prev_val; 690c25aaf81SKY Srinivasan 691c25aaf81SKY Srinivasan for (i = 0; i < max_words; i++) { 692c25aaf81SKY Srinivasan if (!~(map_addr[i])) 693c25aaf81SKY Srinivasan continue; 694c25aaf81SKY Srinivasan index = ffz(map_addr[i]); 695c25aaf81SKY Srinivasan prev_val = sync_test_and_set_bit(index, &map_addr[i]); 696c25aaf81SKY Srinivasan if (prev_val) 697c25aaf81SKY Srinivasan continue; 698c25aaf81SKY Srinivasan if ((index + (i * BITS_PER_LONG)) >= section_cnt) 699c25aaf81SKY Srinivasan break; 700c25aaf81SKY Srinivasan ret_val = (index + (i * BITS_PER_LONG)); 701c25aaf81SKY Srinivasan break; 702c25aaf81SKY Srinivasan } 703c25aaf81SKY Srinivasan return ret_val; 704c25aaf81SKY Srinivasan } 705c25aaf81SKY Srinivasan 706da19fcd0SLad, Prabhakar static u32 netvsc_copy_to_send_buf(struct netvsc_device *net_device, 707c25aaf81SKY Srinivasan unsigned int section_index, 7087c3877f2SHaiyang Zhang u32 pend_size, 70924476760SKY Srinivasan struct hv_netvsc_packet *packet, 71024476760SKY Srinivasan struct rndis_message *rndis_msg) 711c25aaf81SKY Srinivasan { 712c25aaf81SKY Srinivasan char *start = net_device->send_buf; 7137c3877f2SHaiyang Zhang char *dest = start + (section_index * net_device->send_section_size) 7147c3877f2SHaiyang Zhang + pend_size; 715c25aaf81SKY Srinivasan int i; 716c25aaf81SKY Srinivasan u32 msg_size = 0; 7177c3877f2SHaiyang Zhang u32 padding = 0; 7187c3877f2SHaiyang Zhang u32 remain = packet->total_data_buflen % net_device->pkt_align; 719aa0a34beSHaiyang Zhang u32 page_count = packet->cp_partial ? packet->rmsg_pgcnt : 720aa0a34beSHaiyang Zhang packet->page_buf_cnt; 7217c3877f2SHaiyang Zhang 7227c3877f2SHaiyang Zhang /* Add padding */ 723aa0a34beSHaiyang Zhang if (packet->is_data_pkt && packet->xmit_more && remain && 724aa0a34beSHaiyang Zhang !packet->cp_partial) { 7257c3877f2SHaiyang Zhang padding = net_device->pkt_align - remain; 72624476760SKY Srinivasan rndis_msg->msg_len += padding; 7277c3877f2SHaiyang Zhang packet->total_data_buflen += padding; 7287c3877f2SHaiyang Zhang } 729c25aaf81SKY Srinivasan 730aa0a34beSHaiyang Zhang for (i = 0; i < page_count; i++) { 731c25aaf81SKY Srinivasan char *src = phys_to_virt(packet->page_buf[i].pfn << PAGE_SHIFT); 732c25aaf81SKY Srinivasan u32 offset = packet->page_buf[i].offset; 733c25aaf81SKY Srinivasan u32 len = packet->page_buf[i].len; 734c25aaf81SKY Srinivasan 735c25aaf81SKY Srinivasan memcpy(dest, (src + offset), len); 736c25aaf81SKY Srinivasan msg_size += len; 737c25aaf81SKY Srinivasan dest += len; 738c25aaf81SKY Srinivasan } 7397c3877f2SHaiyang Zhang 7407c3877f2SHaiyang Zhang if (padding) { 7417c3877f2SHaiyang Zhang memset(dest, 0, padding); 7427c3877f2SHaiyang Zhang msg_size += padding; 7437c3877f2SHaiyang Zhang } 7447c3877f2SHaiyang Zhang 745c25aaf81SKY Srinivasan return msg_size; 746c25aaf81SKY Srinivasan } 747c25aaf81SKY Srinivasan 7487c3877f2SHaiyang Zhang static inline int netvsc_send_pkt( 7497c3877f2SHaiyang Zhang struct hv_netvsc_packet *packet, 7507c3877f2SHaiyang Zhang struct netvsc_device *net_device) 75195fa0405SHaiyang Zhang { 7527c3877f2SHaiyang Zhang struct nvsp_message nvmsg; 75325b85ee8SKY Srinivasan struct vmbus_channel *out_channel = get_channel(packet, net_device); 7543a67c9ccSKY Srinivasan u16 q_idx = packet->q_idx; 7557c3877f2SHaiyang Zhang struct net_device *ndev = net_device->ndev; 7567c3877f2SHaiyang Zhang u64 req_id; 7577c3877f2SHaiyang Zhang int ret; 758aa0a34beSHaiyang Zhang struct hv_page_buffer *pgbuf; 75982fa3c77SKY Srinivasan u32 ring_avail = hv_ringbuf_avail_percent(&out_channel->outbound); 760c25aaf81SKY Srinivasan 7617c3877f2SHaiyang Zhang nvmsg.hdr.msg_type = NVSP_MSG1_TYPE_SEND_RNDIS_PKT; 76295fa0405SHaiyang Zhang if (packet->is_data_pkt) { 76395fa0405SHaiyang Zhang /* 0 is RMC_DATA; */ 7647c3877f2SHaiyang Zhang nvmsg.msg.v1_msg.send_rndis_pkt.channel_type = 0; 76595fa0405SHaiyang Zhang } else { 76695fa0405SHaiyang Zhang /* 1 is RMC_CONTROL; */ 7677c3877f2SHaiyang Zhang nvmsg.msg.v1_msg.send_rndis_pkt.channel_type = 1; 76895fa0405SHaiyang Zhang } 76995fa0405SHaiyang Zhang 7707c3877f2SHaiyang Zhang nvmsg.msg.v1_msg.send_rndis_pkt.send_buf_section_index = 7717c3877f2SHaiyang Zhang packet->send_buf_index; 7727c3877f2SHaiyang Zhang if (packet->send_buf_index == NETVSC_INVALID_INDEX) 7737c3877f2SHaiyang Zhang nvmsg.msg.v1_msg.send_rndis_pkt.send_buf_section_size = 0; 7747c3877f2SHaiyang Zhang else 7757c3877f2SHaiyang Zhang nvmsg.msg.v1_msg.send_rndis_pkt.send_buf_section_size = 7767c3877f2SHaiyang Zhang packet->total_data_buflen; 77795fa0405SHaiyang Zhang 778893f6627SHaiyang Zhang if (packet->send_completion) 77900ca8f0cSHaiyang Zhang req_id = (ulong)packet; 780f1ea3cd7SHaiyang Zhang else 781f1ea3cd7SHaiyang Zhang req_id = 0; 782f1ea3cd7SHaiyang Zhang 783c3582a2cSHaiyang Zhang if (out_channel->rescind) 784c3582a2cSHaiyang Zhang return -ENODEV; 785c3582a2cSHaiyang Zhang 78682fa3c77SKY Srinivasan /* 78782fa3c77SKY Srinivasan * It is possible that once we successfully place this packet 78882fa3c77SKY Srinivasan * on the ringbuffer, we may stop the queue. In that case, we want 78982fa3c77SKY Srinivasan * to notify the host independent of the xmit_more flag. We don't 79082fa3c77SKY Srinivasan * need to be precise here; in the worst case we may signal the host 79182fa3c77SKY Srinivasan * unnecessarily. 79282fa3c77SKY Srinivasan */ 79382fa3c77SKY Srinivasan if (ring_avail < (RING_AVAIL_PERCENT_LOWATER + 1)) 79482fa3c77SKY Srinivasan packet->xmit_more = false; 79582fa3c77SKY Srinivasan 79695fa0405SHaiyang Zhang if (packet->page_buf_cnt) { 797aa0a34beSHaiyang Zhang pgbuf = packet->cp_partial ? packet->page_buf + 798aa0a34beSHaiyang Zhang packet->rmsg_pgcnt : packet->page_buf; 79982fa3c77SKY Srinivasan ret = vmbus_sendpacket_pagebuffer_ctl(out_channel, 800aa0a34beSHaiyang Zhang pgbuf, 80195fa0405SHaiyang Zhang packet->page_buf_cnt, 8027c3877f2SHaiyang Zhang &nvmsg, 80395fa0405SHaiyang Zhang sizeof(struct nvsp_message), 80482fa3c77SKY Srinivasan req_id, 80582fa3c77SKY Srinivasan VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED, 80682fa3c77SKY Srinivasan !packet->xmit_more); 80795fa0405SHaiyang Zhang } else { 80882fa3c77SKY Srinivasan ret = vmbus_sendpacket_ctl(out_channel, &nvmsg, 80995fa0405SHaiyang Zhang sizeof(struct nvsp_message), 810f1ea3cd7SHaiyang Zhang req_id, 81195fa0405SHaiyang Zhang VM_PKT_DATA_INBAND, 81282fa3c77SKY Srinivasan VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED, 81382fa3c77SKY Srinivasan !packet->xmit_more); 81495fa0405SHaiyang Zhang } 81595fa0405SHaiyang Zhang 8161d06825bSHaiyang Zhang if (ret == 0) { 8171d06825bSHaiyang Zhang atomic_inc(&net_device->num_outstanding_sends); 8183a67c9ccSKY Srinivasan atomic_inc(&net_device->queue_sends[q_idx]); 8195b54dac8SHaiyang Zhang 82082fa3c77SKY Srinivasan if (ring_avail < RING_AVAIL_PERCENT_LOWATER) { 82182fa3c77SKY Srinivasan netif_tx_stop_queue(netdev_get_tx_queue(ndev, q_idx)); 8225b54dac8SHaiyang Zhang 82333be96e4SHaiyang Zhang if (atomic_read(&net_device-> 8243a67c9ccSKY Srinivasan queue_sends[q_idx]) < 1) 8255b54dac8SHaiyang Zhang netif_tx_wake_queue(netdev_get_tx_queue( 8263a67c9ccSKY Srinivasan ndev, q_idx)); 82733be96e4SHaiyang Zhang } 8281d06825bSHaiyang Zhang } else if (ret == -EAGAIN) { 8295b54dac8SHaiyang Zhang netif_tx_stop_queue(netdev_get_tx_queue( 8303a67c9ccSKY Srinivasan ndev, q_idx)); 8313a67c9ccSKY Srinivasan if (atomic_read(&net_device->queue_sends[q_idx]) < 1) { 8325b54dac8SHaiyang Zhang netif_tx_wake_queue(netdev_get_tx_queue( 8333a67c9ccSKY Srinivasan ndev, q_idx)); 83433be96e4SHaiyang Zhang ret = -ENOSPC; 83533be96e4SHaiyang Zhang } 8361d06825bSHaiyang Zhang } else { 83795fa0405SHaiyang Zhang netdev_err(ndev, "Unable to send packet %p ret %d\n", 83895fa0405SHaiyang Zhang packet, ret); 8391d06825bSHaiyang Zhang } 84095fa0405SHaiyang Zhang 8417c3877f2SHaiyang Zhang return ret; 8427c3877f2SHaiyang Zhang } 8437c3877f2SHaiyang Zhang 8447c3877f2SHaiyang Zhang int netvsc_send(struct hv_device *device, 84524476760SKY Srinivasan struct hv_netvsc_packet *packet, 84624476760SKY Srinivasan struct rndis_message *rndis_msg) 8477c3877f2SHaiyang Zhang { 8487c3877f2SHaiyang Zhang struct netvsc_device *net_device; 8497c3877f2SHaiyang Zhang int ret = 0, m_ret = 0; 8507c3877f2SHaiyang Zhang struct vmbus_channel *out_channel; 8517c3877f2SHaiyang Zhang u16 q_idx = packet->q_idx; 8527c3877f2SHaiyang Zhang u32 pktlen = packet->total_data_buflen, msd_len = 0; 8537c3877f2SHaiyang Zhang unsigned int section_index = NETVSC_INVALID_INDEX; 8547c3877f2SHaiyang Zhang unsigned long flag; 8557c3877f2SHaiyang Zhang struct multi_send_data *msdp; 8567c3877f2SHaiyang Zhang struct hv_netvsc_packet *msd_send = NULL, *cur_send = NULL; 857aa0a34beSHaiyang Zhang bool try_batch; 8587c3877f2SHaiyang Zhang 8597c3877f2SHaiyang Zhang net_device = get_outbound_net_device(device); 8607c3877f2SHaiyang Zhang if (!net_device) 8617c3877f2SHaiyang Zhang return -ENODEV; 8627c3877f2SHaiyang Zhang 86325b85ee8SKY Srinivasan out_channel = get_channel(packet, net_device); 86425b85ee8SKY Srinivasan q_idx = packet->q_idx; 86525b85ee8SKY Srinivasan 8667c3877f2SHaiyang Zhang packet->send_buf_index = NETVSC_INVALID_INDEX; 867aa0a34beSHaiyang Zhang packet->cp_partial = false; 8687c3877f2SHaiyang Zhang 8697c3877f2SHaiyang Zhang msdp = &net_device->msd[q_idx]; 8707c3877f2SHaiyang Zhang 8717c3877f2SHaiyang Zhang /* batch packets in send buffer if possible */ 8727c3877f2SHaiyang Zhang spin_lock_irqsave(&msdp->lock, flag); 8737c3877f2SHaiyang Zhang if (msdp->pkt) 8747c3877f2SHaiyang Zhang msd_len = msdp->pkt->total_data_buflen; 8757c3877f2SHaiyang Zhang 876aa0a34beSHaiyang Zhang try_batch = packet->is_data_pkt && msd_len > 0 && msdp->count < 877aa0a34beSHaiyang Zhang net_device->max_pkt; 878aa0a34beSHaiyang Zhang 879aa0a34beSHaiyang Zhang if (try_batch && msd_len + pktlen + net_device->pkt_align < 8807c3877f2SHaiyang Zhang net_device->send_section_size) { 8817c3877f2SHaiyang Zhang section_index = msdp->pkt->send_buf_index; 8827c3877f2SHaiyang Zhang 883aa0a34beSHaiyang Zhang } else if (try_batch && msd_len + packet->rmsg_size < 884aa0a34beSHaiyang Zhang net_device->send_section_size) { 885aa0a34beSHaiyang Zhang section_index = msdp->pkt->send_buf_index; 886aa0a34beSHaiyang Zhang packet->cp_partial = true; 887aa0a34beSHaiyang Zhang 8887c3877f2SHaiyang Zhang } else if (packet->is_data_pkt && pktlen + net_device->pkt_align < 8897c3877f2SHaiyang Zhang net_device->send_section_size) { 8907c3877f2SHaiyang Zhang section_index = netvsc_get_next_send_section(net_device); 8917c3877f2SHaiyang Zhang if (section_index != NETVSC_INVALID_INDEX) { 8927c3877f2SHaiyang Zhang msd_send = msdp->pkt; 8937c3877f2SHaiyang Zhang msdp->pkt = NULL; 8947c3877f2SHaiyang Zhang msdp->count = 0; 8957c3877f2SHaiyang Zhang msd_len = 0; 8967c3877f2SHaiyang Zhang } 8977c3877f2SHaiyang Zhang } 8987c3877f2SHaiyang Zhang 8997c3877f2SHaiyang Zhang if (section_index != NETVSC_INVALID_INDEX) { 9007c3877f2SHaiyang Zhang netvsc_copy_to_send_buf(net_device, 9017c3877f2SHaiyang Zhang section_index, msd_len, 90224476760SKY Srinivasan packet, rndis_msg); 903b08cc791SKY Srinivasan 904aa0a34beSHaiyang Zhang packet->send_buf_index = section_index; 905aa0a34beSHaiyang Zhang 906aa0a34beSHaiyang Zhang if (packet->cp_partial) { 907aa0a34beSHaiyang Zhang packet->page_buf_cnt -= packet->rmsg_pgcnt; 908aa0a34beSHaiyang Zhang packet->total_data_buflen = msd_len + packet->rmsg_size; 909aa0a34beSHaiyang Zhang } else { 910aa0a34beSHaiyang Zhang packet->page_buf_cnt = 0; 911aa0a34beSHaiyang Zhang packet->total_data_buflen += msd_len; 912aa0a34beSHaiyang Zhang } 9137c3877f2SHaiyang Zhang 914ee90b812SHaiyang Zhang if (msdp->pkt) 915ee90b812SHaiyang Zhang netvsc_xmit_completion(msdp->pkt); 916ee90b812SHaiyang Zhang 917aa0a34beSHaiyang Zhang if (packet->xmit_more && !packet->cp_partial) { 9187c3877f2SHaiyang Zhang msdp->pkt = packet; 9197c3877f2SHaiyang Zhang msdp->count++; 9207c3877f2SHaiyang Zhang } else { 9217c3877f2SHaiyang Zhang cur_send = packet; 9227c3877f2SHaiyang Zhang msdp->pkt = NULL; 9237c3877f2SHaiyang Zhang msdp->count = 0; 9247c3877f2SHaiyang Zhang } 9257c3877f2SHaiyang Zhang } else { 9267c3877f2SHaiyang Zhang msd_send = msdp->pkt; 9277c3877f2SHaiyang Zhang msdp->pkt = NULL; 9287c3877f2SHaiyang Zhang msdp->count = 0; 9297c3877f2SHaiyang Zhang cur_send = packet; 9307c3877f2SHaiyang Zhang } 9317c3877f2SHaiyang Zhang 9327c3877f2SHaiyang Zhang spin_unlock_irqrestore(&msdp->lock, flag); 9337c3877f2SHaiyang Zhang 9347c3877f2SHaiyang Zhang if (msd_send) { 9357c3877f2SHaiyang Zhang m_ret = netvsc_send_pkt(msd_send, net_device); 9367c3877f2SHaiyang Zhang 9377c3877f2SHaiyang Zhang if (m_ret != 0) { 9387c3877f2SHaiyang Zhang netvsc_free_send_slot(net_device, 9397c3877f2SHaiyang Zhang msd_send->send_buf_index); 940ee90b812SHaiyang Zhang netvsc_xmit_completion(msd_send); 9417c3877f2SHaiyang Zhang } 9427c3877f2SHaiyang Zhang } 9437c3877f2SHaiyang Zhang 9447c3877f2SHaiyang Zhang if (cur_send) 9457c3877f2SHaiyang Zhang ret = netvsc_send_pkt(cur_send, net_device); 9467c3877f2SHaiyang Zhang 9477aab5159SJerry Snitselaar if (ret != 0 && section_index != NETVSC_INVALID_INDEX) 948d953ca4dSHaiyang Zhang netvsc_free_send_slot(net_device, section_index); 949d953ca4dSHaiyang Zhang 95095fa0405SHaiyang Zhang return ret; 95195fa0405SHaiyang Zhang } 95295fa0405SHaiyang Zhang 95395fa0405SHaiyang Zhang static void netvsc_send_recv_completion(struct hv_device *device, 9545b54dac8SHaiyang Zhang struct vmbus_channel *channel, 95597c1723aSKY Srinivasan struct netvsc_device *net_device, 95663f6921dSHaiyang Zhang u64 transaction_id, u32 status) 95795fa0405SHaiyang Zhang { 95895fa0405SHaiyang Zhang struct nvsp_message recvcompMessage; 95995fa0405SHaiyang Zhang int retries = 0; 96095fa0405SHaiyang Zhang int ret; 96195fa0405SHaiyang Zhang struct net_device *ndev; 96295fa0405SHaiyang Zhang 96395fa0405SHaiyang Zhang ndev = net_device->ndev; 96495fa0405SHaiyang Zhang 96595fa0405SHaiyang Zhang recvcompMessage.hdr.msg_type = 96695fa0405SHaiyang Zhang NVSP_MSG1_TYPE_SEND_RNDIS_PKT_COMPLETE; 96795fa0405SHaiyang Zhang 96863f6921dSHaiyang Zhang recvcompMessage.msg.v1_msg.send_rndis_pkt_complete.status = status; 96995fa0405SHaiyang Zhang 97095fa0405SHaiyang Zhang retry_send_cmplt: 97195fa0405SHaiyang Zhang /* Send the completion */ 9725b54dac8SHaiyang Zhang ret = vmbus_sendpacket(channel, &recvcompMessage, 97395fa0405SHaiyang Zhang sizeof(struct nvsp_message), transaction_id, 97495fa0405SHaiyang Zhang VM_PKT_COMP, 0); 97595fa0405SHaiyang Zhang if (ret == 0) { 97695fa0405SHaiyang Zhang /* success */ 97795fa0405SHaiyang Zhang /* no-op */ 97895fa0405SHaiyang Zhang } else if (ret == -EAGAIN) { 97995fa0405SHaiyang Zhang /* no more room...wait a bit and attempt to retry 3 times */ 98095fa0405SHaiyang Zhang retries++; 98195fa0405SHaiyang Zhang netdev_err(ndev, "unable to send receive completion pkt" 98295fa0405SHaiyang Zhang " (tid %llx)...retrying %d\n", transaction_id, retries); 98395fa0405SHaiyang Zhang 98495fa0405SHaiyang Zhang if (retries < 4) { 98595fa0405SHaiyang Zhang udelay(100); 98695fa0405SHaiyang Zhang goto retry_send_cmplt; 98795fa0405SHaiyang Zhang } else { 98895fa0405SHaiyang Zhang netdev_err(ndev, "unable to send receive " 98995fa0405SHaiyang Zhang "completion pkt (tid %llx)...give up retrying\n", 99095fa0405SHaiyang Zhang transaction_id); 99195fa0405SHaiyang Zhang } 99295fa0405SHaiyang Zhang } else { 99395fa0405SHaiyang Zhang netdev_err(ndev, "unable to send receive " 99495fa0405SHaiyang Zhang "completion pkt - %llx\n", transaction_id); 99595fa0405SHaiyang Zhang } 99695fa0405SHaiyang Zhang } 99795fa0405SHaiyang Zhang 99897c1723aSKY Srinivasan static void netvsc_receive(struct netvsc_device *net_device, 9995b54dac8SHaiyang Zhang struct vmbus_channel *channel, 100097c1723aSKY Srinivasan struct hv_device *device, 100195fa0405SHaiyang Zhang struct vmpacket_descriptor *packet) 100295fa0405SHaiyang Zhang { 100395fa0405SHaiyang Zhang struct vmtransfer_page_packet_header *vmxferpage_packet; 100495fa0405SHaiyang Zhang struct nvsp_message *nvsp_packet; 10054baab261SHaiyang Zhang struct hv_netvsc_packet nv_pkt; 10064baab261SHaiyang Zhang struct hv_netvsc_packet *netvsc_packet = &nv_pkt; 10074baab261SHaiyang Zhang u32 status = NVSP_STAT_SUCCESS; 100845326342SHaiyang Zhang int i; 100945326342SHaiyang Zhang int count = 0; 101095fa0405SHaiyang Zhang struct net_device *ndev; 1011c4b20c63SKY Srinivasan void *data; 101295fa0405SHaiyang Zhang 101395fa0405SHaiyang Zhang ndev = net_device->ndev; 101495fa0405SHaiyang Zhang 101595fa0405SHaiyang Zhang /* 101695fa0405SHaiyang Zhang * All inbound packets other than send completion should be xfer page 101795fa0405SHaiyang Zhang * packet 101895fa0405SHaiyang Zhang */ 101995fa0405SHaiyang Zhang if (packet->type != VM_PKT_DATA_USING_XFER_PAGES) { 102095fa0405SHaiyang Zhang netdev_err(ndev, "Unknown packet type received - %d\n", 102195fa0405SHaiyang Zhang packet->type); 102295fa0405SHaiyang Zhang return; 102395fa0405SHaiyang Zhang } 102495fa0405SHaiyang Zhang 102595fa0405SHaiyang Zhang nvsp_packet = (struct nvsp_message *)((unsigned long)packet + 102695fa0405SHaiyang Zhang (packet->offset8 << 3)); 102795fa0405SHaiyang Zhang 102895fa0405SHaiyang Zhang /* Make sure this is a valid nvsp packet */ 102995fa0405SHaiyang Zhang if (nvsp_packet->hdr.msg_type != 103095fa0405SHaiyang Zhang NVSP_MSG1_TYPE_SEND_RNDIS_PKT) { 103195fa0405SHaiyang Zhang netdev_err(ndev, "Unknown nvsp packet type received-" 103295fa0405SHaiyang Zhang " %d\n", nvsp_packet->hdr.msg_type); 103395fa0405SHaiyang Zhang return; 103495fa0405SHaiyang Zhang } 103595fa0405SHaiyang Zhang 103695fa0405SHaiyang Zhang vmxferpage_packet = (struct vmtransfer_page_packet_header *)packet; 103795fa0405SHaiyang Zhang 103895fa0405SHaiyang Zhang if (vmxferpage_packet->xfer_pageset_id != NETVSC_RECEIVE_BUFFER_ID) { 103995fa0405SHaiyang Zhang netdev_err(ndev, "Invalid xfer page set id - " 104095fa0405SHaiyang Zhang "expecting %x got %x\n", NETVSC_RECEIVE_BUFFER_ID, 104195fa0405SHaiyang Zhang vmxferpage_packet->xfer_pageset_id); 104295fa0405SHaiyang Zhang return; 104395fa0405SHaiyang Zhang } 104495fa0405SHaiyang Zhang 10454baab261SHaiyang Zhang count = vmxferpage_packet->range_cnt; 104695fa0405SHaiyang Zhang 104795fa0405SHaiyang Zhang /* Each range represents 1 RNDIS pkt that contains 1 ethernet frame */ 10484baab261SHaiyang Zhang for (i = 0; i < count; i++) { 104995fa0405SHaiyang Zhang /* Initialize the netvsc packet */ 105063f6921dSHaiyang Zhang netvsc_packet->status = NVSP_STAT_SUCCESS; 1051c4b20c63SKY Srinivasan data = (void *)((unsigned long)net_device-> 105245326342SHaiyang Zhang recv_buf + vmxferpage_packet->ranges[i].byte_offset); 105395fa0405SHaiyang Zhang netvsc_packet->total_data_buflen = 105495fa0405SHaiyang Zhang vmxferpage_packet->ranges[i].byte_count; 105595fa0405SHaiyang Zhang 105695fa0405SHaiyang Zhang /* Pass it to the upper layer */ 1057c4b20c63SKY Srinivasan rndis_filter_receive(device, netvsc_packet, &data, channel); 105895fa0405SHaiyang Zhang 10594baab261SHaiyang Zhang if (netvsc_packet->status != NVSP_STAT_SUCCESS) 10604baab261SHaiyang Zhang status = NVSP_STAT_FAIL; 106195fa0405SHaiyang Zhang } 106295fa0405SHaiyang Zhang 10634baab261SHaiyang Zhang netvsc_send_recv_completion(device, channel, net_device, 10644baab261SHaiyang Zhang vmxferpage_packet->d.trans_id, status); 106595fa0405SHaiyang Zhang } 106695fa0405SHaiyang Zhang 10675b54dac8SHaiyang Zhang 10685b54dac8SHaiyang Zhang static void netvsc_send_table(struct hv_device *hdev, 106971790a27SHaiyang Zhang struct nvsp_message *nvmsg) 10705b54dac8SHaiyang Zhang { 10715b54dac8SHaiyang Zhang struct netvsc_device *nvscdev; 10725b54dac8SHaiyang Zhang struct net_device *ndev; 10735b54dac8SHaiyang Zhang int i; 10745b54dac8SHaiyang Zhang u32 count, *tab; 10755b54dac8SHaiyang Zhang 10765b54dac8SHaiyang Zhang nvscdev = get_outbound_net_device(hdev); 10775b54dac8SHaiyang Zhang if (!nvscdev) 10785b54dac8SHaiyang Zhang return; 10795b54dac8SHaiyang Zhang ndev = nvscdev->ndev; 10805b54dac8SHaiyang Zhang 10815b54dac8SHaiyang Zhang count = nvmsg->msg.v5_msg.send_table.count; 10825b54dac8SHaiyang Zhang if (count != VRSS_SEND_TAB_SIZE) { 10835b54dac8SHaiyang Zhang netdev_err(ndev, "Received wrong send-table size:%u\n", count); 10845b54dac8SHaiyang Zhang return; 10855b54dac8SHaiyang Zhang } 10865b54dac8SHaiyang Zhang 10875b54dac8SHaiyang Zhang tab = (u32 *)((unsigned long)&nvmsg->msg.v5_msg.send_table + 10885b54dac8SHaiyang Zhang nvmsg->msg.v5_msg.send_table.offset); 10895b54dac8SHaiyang Zhang 10905b54dac8SHaiyang Zhang for (i = 0; i < count; i++) 10915b54dac8SHaiyang Zhang nvscdev->send_table[i] = tab[i]; 10925b54dac8SHaiyang Zhang } 10935b54dac8SHaiyang Zhang 109471790a27SHaiyang Zhang static void netvsc_send_vf(struct netvsc_device *nvdev, 109571790a27SHaiyang Zhang struct nvsp_message *nvmsg) 109671790a27SHaiyang Zhang { 109771790a27SHaiyang Zhang nvdev->vf_alloc = nvmsg->msg.v4_msg.vf_assoc.allocated; 109871790a27SHaiyang Zhang nvdev->vf_serial = nvmsg->msg.v4_msg.vf_assoc.serial; 109971790a27SHaiyang Zhang } 110071790a27SHaiyang Zhang 110171790a27SHaiyang Zhang static inline void netvsc_receive_inband(struct hv_device *hdev, 110271790a27SHaiyang Zhang struct netvsc_device *nvdev, 110371790a27SHaiyang Zhang struct nvsp_message *nvmsg) 110471790a27SHaiyang Zhang { 110571790a27SHaiyang Zhang switch (nvmsg->hdr.msg_type) { 110671790a27SHaiyang Zhang case NVSP_MSG5_TYPE_SEND_INDIRECTION_TABLE: 110771790a27SHaiyang Zhang netvsc_send_table(hdev, nvmsg); 110871790a27SHaiyang Zhang break; 110971790a27SHaiyang Zhang 111071790a27SHaiyang Zhang case NVSP_MSG4_TYPE_SEND_VF_ASSOCIATION: 111171790a27SHaiyang Zhang netvsc_send_vf(nvdev, nvmsg); 111271790a27SHaiyang Zhang break; 111371790a27SHaiyang Zhang } 111471790a27SHaiyang Zhang } 111571790a27SHaiyang Zhang 11165b54dac8SHaiyang Zhang void netvsc_channel_cb(void *context) 111795fa0405SHaiyang Zhang { 111895fa0405SHaiyang Zhang int ret; 11195b54dac8SHaiyang Zhang struct vmbus_channel *channel = (struct vmbus_channel *)context; 11205b54dac8SHaiyang Zhang struct hv_device *device; 112195fa0405SHaiyang Zhang struct netvsc_device *net_device; 112295fa0405SHaiyang Zhang u32 bytes_recvd; 112395fa0405SHaiyang Zhang u64 request_id; 112495fa0405SHaiyang Zhang struct vmpacket_descriptor *desc; 112595fa0405SHaiyang Zhang unsigned char *buffer; 112695fa0405SHaiyang Zhang int bufferlen = NETVSC_PACKET_SIZE; 112795fa0405SHaiyang Zhang struct net_device *ndev; 112871790a27SHaiyang Zhang struct nvsp_message *nvmsg; 112995fa0405SHaiyang Zhang 11305b54dac8SHaiyang Zhang if (channel->primary_channel != NULL) 11315b54dac8SHaiyang Zhang device = channel->primary_channel->device_obj; 11325b54dac8SHaiyang Zhang else 11335b54dac8SHaiyang Zhang device = channel->device_obj; 11345b54dac8SHaiyang Zhang 113595fa0405SHaiyang Zhang net_device = get_inbound_net_device(device); 113695fa0405SHaiyang Zhang if (!net_device) 1137ee0c4c39SKY Srinivasan return; 113895fa0405SHaiyang Zhang ndev = net_device->ndev; 11395b54dac8SHaiyang Zhang buffer = get_per_channel_state(channel); 114095fa0405SHaiyang Zhang 114195fa0405SHaiyang Zhang do { 11425b54dac8SHaiyang Zhang ret = vmbus_recvpacket_raw(channel, buffer, bufferlen, 114395fa0405SHaiyang Zhang &bytes_recvd, &request_id); 114495fa0405SHaiyang Zhang if (ret == 0) { 114595fa0405SHaiyang Zhang if (bytes_recvd > 0) { 114695fa0405SHaiyang Zhang desc = (struct vmpacket_descriptor *)buffer; 114771790a27SHaiyang Zhang nvmsg = (struct nvsp_message *)((unsigned long) 114871790a27SHaiyang Zhang desc + (desc->offset8 << 3)); 114995fa0405SHaiyang Zhang switch (desc->type) { 115095fa0405SHaiyang Zhang case VM_PKT_COMP: 115197c1723aSKY Srinivasan netvsc_send_completion(net_device, 115225b85ee8SKY Srinivasan channel, 115397c1723aSKY Srinivasan device, desc); 115495fa0405SHaiyang Zhang break; 115595fa0405SHaiyang Zhang 115695fa0405SHaiyang Zhang case VM_PKT_DATA_USING_XFER_PAGES: 11575b54dac8SHaiyang Zhang netvsc_receive(net_device, channel, 115897c1723aSKY Srinivasan device, desc); 115995fa0405SHaiyang Zhang break; 116095fa0405SHaiyang Zhang 11615b54dac8SHaiyang Zhang case VM_PKT_DATA_INBAND: 116271790a27SHaiyang Zhang netvsc_receive_inband(device, 116371790a27SHaiyang Zhang net_device, 116471790a27SHaiyang Zhang nvmsg); 11655b54dac8SHaiyang Zhang break; 11665b54dac8SHaiyang Zhang 116795fa0405SHaiyang Zhang default: 116895fa0405SHaiyang Zhang netdev_err(ndev, 116995fa0405SHaiyang Zhang "unhandled packet type %d, " 117095fa0405SHaiyang Zhang "tid %llx len %d\n", 117195fa0405SHaiyang Zhang desc->type, request_id, 117295fa0405SHaiyang Zhang bytes_recvd); 117395fa0405SHaiyang Zhang break; 117495fa0405SHaiyang Zhang } 117595fa0405SHaiyang Zhang 117695fa0405SHaiyang Zhang } else { 1177ee0c4c39SKY Srinivasan /* 1178ee0c4c39SKY Srinivasan * We are done for this pass. 1179ee0c4c39SKY Srinivasan */ 118095fa0405SHaiyang Zhang break; 118195fa0405SHaiyang Zhang } 1182ee0c4c39SKY Srinivasan 118395fa0405SHaiyang Zhang } else if (ret == -ENOBUFS) { 1184ee0c4c39SKY Srinivasan if (bufferlen > NETVSC_PACKET_SIZE) 1185ee0c4c39SKY Srinivasan kfree(buffer); 118695fa0405SHaiyang Zhang /* Handle large packet */ 118795fa0405SHaiyang Zhang buffer = kmalloc(bytes_recvd, GFP_ATOMIC); 118895fa0405SHaiyang Zhang if (buffer == NULL) { 118995fa0405SHaiyang Zhang /* Try again next time around */ 119095fa0405SHaiyang Zhang netdev_err(ndev, 119195fa0405SHaiyang Zhang "unable to allocate buffer of size " 119295fa0405SHaiyang Zhang "(%d)!!\n", bytes_recvd); 119395fa0405SHaiyang Zhang break; 119495fa0405SHaiyang Zhang } 119595fa0405SHaiyang Zhang 119695fa0405SHaiyang Zhang bufferlen = bytes_recvd; 119795fa0405SHaiyang Zhang } 119895fa0405SHaiyang Zhang } while (1); 119995fa0405SHaiyang Zhang 1200ee0c4c39SKY Srinivasan if (bufferlen > NETVSC_PACKET_SIZE) 120195fa0405SHaiyang Zhang kfree(buffer); 120295fa0405SHaiyang Zhang return; 120395fa0405SHaiyang Zhang } 120495fa0405SHaiyang Zhang 120595fa0405SHaiyang Zhang /* 120695fa0405SHaiyang Zhang * netvsc_device_add - Callback when the device belonging to this 120795fa0405SHaiyang Zhang * driver is added 120895fa0405SHaiyang Zhang */ 120995fa0405SHaiyang Zhang int netvsc_device_add(struct hv_device *device, void *additional_info) 121095fa0405SHaiyang Zhang { 121195fa0405SHaiyang Zhang int ret = 0; 121295fa0405SHaiyang Zhang int ring_size = 121395fa0405SHaiyang Zhang ((struct netvsc_device_info *)additional_info)->ring_size; 121495fa0405SHaiyang Zhang struct netvsc_device *net_device; 121595fa0405SHaiyang Zhang struct net_device *ndev; 121695fa0405SHaiyang Zhang 121795fa0405SHaiyang Zhang net_device = alloc_net_device(device); 1218b1c84927SDan Carpenter if (!net_device) 1219b1c84927SDan Carpenter return -ENOMEM; 122095fa0405SHaiyang Zhang 12215b54dac8SHaiyang Zhang net_device->ring_size = ring_size; 12225b54dac8SHaiyang Zhang 122395fa0405SHaiyang Zhang /* 122495fa0405SHaiyang Zhang * Coming into this function, struct net_device * is 122595fa0405SHaiyang Zhang * registered as the driver private data. 122695fa0405SHaiyang Zhang * In alloc_net_device(), we register struct netvsc_device * 122795fa0405SHaiyang Zhang * as the driver private data and stash away struct net_device * 122895fa0405SHaiyang Zhang * in struct netvsc_device *. 122995fa0405SHaiyang Zhang */ 123095fa0405SHaiyang Zhang ndev = net_device->ndev; 123195fa0405SHaiyang Zhang 12323f300ff4SSimon Xiao /* Add netvsc_device context to netvsc_device */ 12333f300ff4SSimon Xiao net_device->nd_ctx = netdev_priv(ndev); 12343f300ff4SSimon Xiao 123595fa0405SHaiyang Zhang /* Initialize the NetVSC channel extension */ 123695fa0405SHaiyang Zhang init_completion(&net_device->channel_init_wait); 123795fa0405SHaiyang Zhang 12385b54dac8SHaiyang Zhang set_per_channel_state(device->channel, net_device->cb_buffer); 12395b54dac8SHaiyang Zhang 124095fa0405SHaiyang Zhang /* Open the channel */ 124195fa0405SHaiyang Zhang ret = vmbus_open(device->channel, ring_size * PAGE_SIZE, 124295fa0405SHaiyang Zhang ring_size * PAGE_SIZE, NULL, 0, 12435b54dac8SHaiyang Zhang netvsc_channel_cb, device->channel); 124495fa0405SHaiyang Zhang 124595fa0405SHaiyang Zhang if (ret != 0) { 124695fa0405SHaiyang Zhang netdev_err(ndev, "unable to open channel: %d\n", ret); 124795fa0405SHaiyang Zhang goto cleanup; 124895fa0405SHaiyang Zhang } 124995fa0405SHaiyang Zhang 125095fa0405SHaiyang Zhang /* Channel is opened */ 125195fa0405SHaiyang Zhang pr_info("hv_netvsc channel opened successfully\n"); 125295fa0405SHaiyang Zhang 12535b54dac8SHaiyang Zhang net_device->chn_table[0] = device->channel; 12545b54dac8SHaiyang Zhang 125595fa0405SHaiyang Zhang /* Connect with the NetVsp */ 125695fa0405SHaiyang Zhang ret = netvsc_connect_vsp(device); 125795fa0405SHaiyang Zhang if (ret != 0) { 125895fa0405SHaiyang Zhang netdev_err(ndev, 125995fa0405SHaiyang Zhang "unable to connect to NetVSP - %d\n", ret); 126095fa0405SHaiyang Zhang goto close; 126195fa0405SHaiyang Zhang } 126295fa0405SHaiyang Zhang 126395fa0405SHaiyang Zhang return ret; 126495fa0405SHaiyang Zhang 126595fa0405SHaiyang Zhang close: 126695fa0405SHaiyang Zhang /* Now, we can close the channel safely */ 126795fa0405SHaiyang Zhang vmbus_close(device->channel); 126895fa0405SHaiyang Zhang 126995fa0405SHaiyang Zhang cleanup: 1270f90251c8SHaiyang Zhang free_netvsc_device(net_device); 127195fa0405SHaiyang Zhang 127295fa0405SHaiyang Zhang return ret; 127395fa0405SHaiyang Zhang } 1274