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#include <linux/init.h> 22#include <linux/module.h> 23#include <linux/highmem.h> 24#include <linux/device.h> 25#include <linux/io.h> 26#include <linux/delay.h> 27#include <linux/netdevice.h> 28#include <linux/inetdevice.h> 29#include <linux/etherdevice.h> 30#include <linux/skbuff.h> 31#include <linux/in.h> 32#include <linux/slab.h> 33#include <linux/dmi.h> 34#include <linux/pci.h> 35#include <net/arp.h> 36#include <net/route.h> 37#include <net/sock.h> 38#include <net/pkt_sched.h> 39#include "osd.h" 40#include "logging.h" 41#include "version_info.h" 42#include "vmbus.h" 43#include "netvsc_api.h" 44 45struct net_device_context { 46 /* point back to our device context */ 47 struct vm_device *device_ctx; 48 unsigned long avail; 49}; 50 51struct netvsc_driver_context { 52 /* !! These must be the first 2 fields !! */ 53 struct driver_context drv_ctx; 54 struct netvsc_driver drv_obj; 55}; 56 57#define PACKET_PAGES_LOWATER 8 58/* Need this many pages to handle worst case fragmented packet */ 59#define PACKET_PAGES_HIWATER (MAX_SKB_FRAGS + 2) 60 61static int ring_size = roundup_pow_of_two(2*MAX_SKB_FRAGS+1); 62module_param(ring_size, int, S_IRUGO); 63MODULE_PARM_DESC(ring_size, "Ring buffer size (# of pages)"); 64 65/* The one and only one */ 66static struct netvsc_driver_context g_netvsc_drv; 67 68static void netvsc_set_multicast_list(struct net_device *net) 69{ 70} 71 72static int netvsc_open(struct net_device *net) 73{ 74 struct net_device_context *net_device_ctx = netdev_priv(net); 75 struct hv_device *device_obj = &net_device_ctx->device_ctx->device_obj; 76 int ret = 0; 77 78 if (netif_carrier_ok(net)) { 79 /* Open up the device */ 80 ret = RndisFilterOnOpen(device_obj); 81 if (ret != 0) { 82 DPRINT_ERR(NETVSC_DRV, 83 "unable to open device (ret %d).", ret); 84 return ret; 85 } 86 87 netif_start_queue(net); 88 } else { 89 DPRINT_ERR(NETVSC_DRV, "unable to open device...link is down."); 90 } 91 92 return ret; 93} 94 95static int netvsc_close(struct net_device *net) 96{ 97 struct net_device_context *net_device_ctx = netdev_priv(net); 98 struct hv_device *device_obj = &net_device_ctx->device_ctx->device_obj; 99 int ret; 100 101 netif_stop_queue(net); 102 103 ret = RndisFilterOnClose(device_obj); 104 if (ret != 0) 105 DPRINT_ERR(NETVSC_DRV, "unable to close device (ret %d).", ret); 106 107 return ret; 108} 109 110static void netvsc_xmit_completion(void *context) 111{ 112 struct hv_netvsc_packet *packet = (struct hv_netvsc_packet *)context; 113 struct sk_buff *skb = (struct sk_buff *) 114 (unsigned long)packet->Completion.Send.SendCompletionTid; 115 116 kfree(packet); 117 118 if (skb) { 119 struct net_device *net = skb->dev; 120 struct net_device_context *net_device_ctx = netdev_priv(net); 121 unsigned int num_pages = skb_shinfo(skb)->nr_frags + 2; 122 123 dev_kfree_skb_any(skb); 124 125 if ((net_device_ctx->avail += num_pages) >= PACKET_PAGES_HIWATER) 126 netif_wake_queue(net); 127 } 128} 129 130static int netvsc_start_xmit(struct sk_buff *skb, struct net_device *net) 131{ 132 struct net_device_context *net_device_ctx = netdev_priv(net); 133 struct driver_context *driver_ctx = 134 driver_to_driver_context(net_device_ctx->device_ctx->device.driver); 135 struct netvsc_driver_context *net_drv_ctx = 136 (struct netvsc_driver_context *)driver_ctx; 137 struct netvsc_driver *net_drv_obj = &net_drv_ctx->drv_obj; 138 struct hv_netvsc_packet *packet; 139 int ret; 140 unsigned int i, num_pages; 141 142 DPRINT_DBG(NETVSC_DRV, "xmit packet - len %d data_len %d", 143 skb->len, skb->data_len); 144 145 /* Add 1 for skb->data and additional one for RNDIS */ 146 num_pages = skb_shinfo(skb)->nr_frags + 1 + 1; 147 if (num_pages > net_device_ctx->avail) 148 return NETDEV_TX_BUSY; 149 150 /* Allocate a netvsc packet based on # of frags. */ 151 packet = kzalloc(sizeof(struct hv_netvsc_packet) + 152 (num_pages * sizeof(struct hv_page_buffer)) + 153 net_drv_obj->RequestExtSize, GFP_ATOMIC); 154 if (!packet) { 155 /* out of memory, silently drop packet */ 156 DPRINT_ERR(NETVSC_DRV, "unable to allocate hv_netvsc_packet"); 157 158 dev_kfree_skb(skb); 159 net->stats.tx_dropped++; 160 return NETDEV_TX_OK; 161 } 162 163 packet->Extension = (void *)(unsigned long)packet + 164 sizeof(struct hv_netvsc_packet) + 165 (num_pages * sizeof(struct hv_page_buffer)); 166 167 /* Setup the rndis header */ 168 packet->PageBufferCount = num_pages; 169 170 /* TODO: Flush all write buffers/ memory fence ??? */ 171 /* wmb(); */ 172 173 /* Initialize it from the skb */ 174 packet->TotalDataBufferLength = skb->len; 175 176 /* Start filling in the page buffers starting after RNDIS buffer. */ 177 packet->PageBuffers[1].Pfn = virt_to_phys(skb->data) >> PAGE_SHIFT; 178 packet->PageBuffers[1].Offset 179 = (unsigned long)skb->data & (PAGE_SIZE - 1); 180 packet->PageBuffers[1].Length = skb_headlen(skb); 181 182 /* Additional fragments are after SKB data */ 183 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) { 184 skb_frag_t *f = &skb_shinfo(skb)->frags[i]; 185 186 packet->PageBuffers[i+2].Pfn = page_to_pfn(f->page); 187 packet->PageBuffers[i+2].Offset = f->page_offset; 188 packet->PageBuffers[i+2].Length = f->size; 189 } 190 191 /* Set the completion routine */ 192 packet->Completion.Send.OnSendCompletion = netvsc_xmit_completion; 193 packet->Completion.Send.SendCompletionContext = packet; 194 packet->Completion.Send.SendCompletionTid = (unsigned long)skb; 195 196 ret = net_drv_obj->OnSend(&net_device_ctx->device_ctx->device_obj, 197 packet); 198 if (ret == 0) { 199 net->stats.tx_bytes += skb->len; 200 net->stats.tx_packets++; 201 202 DPRINT_DBG(NETVSC_DRV, "# of xmits %lu total size %lu", 203 net->stats.tx_packets, 204 net->stats.tx_bytes); 205 206 if ((net_device_ctx->avail -= num_pages) < PACKET_PAGES_LOWATER) 207 netif_stop_queue(net); 208 } else { 209 /* we are shutting down or bus overloaded, just drop packet */ 210 net->stats.tx_dropped++; 211 netvsc_xmit_completion(packet); 212 } 213 214 return NETDEV_TX_OK; 215} 216 217/* 218 * netvsc_linkstatus_callback - Link up/down notification 219 */ 220static void netvsc_linkstatus_callback(struct hv_device *device_obj, 221 unsigned int status) 222{ 223 struct vm_device *device_ctx = to_vm_device(device_obj); 224 struct net_device *net = dev_get_drvdata(&device_ctx->device); 225 226 if (!net) { 227 DPRINT_ERR(NETVSC_DRV, "got link status but net device " 228 "not initialized yet"); 229 return; 230 } 231 232 if (status == 1) { 233 netif_carrier_on(net); 234 netif_wake_queue(net); 235 netif_notify_peers(net); 236 } else { 237 netif_carrier_off(net); 238 netif_stop_queue(net); 239 } 240} 241 242/* 243 * netvsc_recv_callback - Callback when we receive a packet from the 244 * "wire" on the specified device. 245 */ 246static int netvsc_recv_callback(struct hv_device *device_obj, 247 struct hv_netvsc_packet *packet) 248{ 249 struct vm_device *device_ctx = to_vm_device(device_obj); 250 struct net_device *net = dev_get_drvdata(&device_ctx->device); 251 struct sk_buff *skb; 252 void *data; 253 int i; 254 unsigned long flags; 255 256 if (!net) { 257 DPRINT_ERR(NETVSC_DRV, "got receive callback but net device " 258 "not initialized yet"); 259 return 0; 260 } 261 262 /* Allocate a skb - TODO direct I/O to pages? */ 263 skb = netdev_alloc_skb_ip_align(net, packet->TotalDataBufferLength); 264 if (unlikely(!skb)) { 265 ++net->stats.rx_dropped; 266 return 0; 267 } 268 269 /* for kmap_atomic */ 270 local_irq_save(flags); 271 272 /* 273 * Copy to skb. This copy is needed here since the memory pointed by 274 * hv_netvsc_packet cannot be deallocated 275 */ 276 for (i = 0; i < packet->PageBufferCount; i++) { 277 data = kmap_atomic(pfn_to_page(packet->PageBuffers[i].Pfn), 278 KM_IRQ1); 279 data = (void *)(unsigned long)data + 280 packet->PageBuffers[i].Offset; 281 282 memcpy(skb_put(skb, packet->PageBuffers[i].Length), data, 283 packet->PageBuffers[i].Length); 284 285 kunmap_atomic((void *)((unsigned long)data - 286 packet->PageBuffers[i].Offset), KM_IRQ1); 287 } 288 289 local_irq_restore(flags); 290 291 skb->protocol = eth_type_trans(skb, net); 292 skb->ip_summed = CHECKSUM_NONE; 293 294 net->stats.rx_packets++; 295 net->stats.rx_bytes += skb->len; 296 297 /* 298 * Pass the skb back up. Network stack will deallocate the skb when it 299 * is done. 300 * TODO - use NAPI? 301 */ 302 netif_rx(skb); 303 304 DPRINT_DBG(NETVSC_DRV, "# of recvs %lu total size %lu", 305 net->stats.rx_packets, net->stats.rx_bytes); 306 307 return 0; 308} 309 310static void netvsc_get_drvinfo(struct net_device *net, 311 struct ethtool_drvinfo *info) 312{ 313 strcpy(info->driver, "hv_netvsc"); 314 strcpy(info->version, HV_DRV_VERSION); 315 strcpy(info->fw_version, "N/A"); 316} 317 318static const struct ethtool_ops ethtool_ops = { 319 .get_drvinfo = netvsc_get_drvinfo, 320 .get_sg = ethtool_op_get_sg, 321 .set_sg = ethtool_op_set_sg, 322 .get_link = ethtool_op_get_link, 323}; 324 325static const struct net_device_ops device_ops = { 326 .ndo_open = netvsc_open, 327 .ndo_stop = netvsc_close, 328 .ndo_start_xmit = netvsc_start_xmit, 329 .ndo_set_multicast_list = netvsc_set_multicast_list, 330 .ndo_change_mtu = eth_change_mtu, 331 .ndo_validate_addr = eth_validate_addr, 332 .ndo_set_mac_address = eth_mac_addr, 333}; 334 335static int netvsc_probe(struct device *device) 336{ 337 struct driver_context *driver_ctx = 338 driver_to_driver_context(device->driver); 339 struct netvsc_driver_context *net_drv_ctx = 340 (struct netvsc_driver_context *)driver_ctx; 341 struct netvsc_driver *net_drv_obj = &net_drv_ctx->drv_obj; 342 struct vm_device *device_ctx = device_to_vm_device(device); 343 struct hv_device *device_obj = &device_ctx->device_obj; 344 struct net_device *net = NULL; 345 struct net_device_context *net_device_ctx; 346 struct netvsc_device_info device_info; 347 int ret; 348 349 if (!net_drv_obj->Base.OnDeviceAdd) 350 return -1; 351 352 net = alloc_etherdev(sizeof(struct net_device_context)); 353 if (!net) 354 return -1; 355 356 /* Set initial state */ 357 netif_carrier_off(net); 358 netif_stop_queue(net); 359 360 net_device_ctx = netdev_priv(net); 361 net_device_ctx->device_ctx = device_ctx; 362 net_device_ctx->avail = ring_size; 363 dev_set_drvdata(device, net); 364 365 /* Notify the netvsc driver of the new device */ 366 ret = net_drv_obj->Base.OnDeviceAdd(device_obj, &device_info); 367 if (ret != 0) { 368 free_netdev(net); 369 dev_set_drvdata(device, NULL); 370 371 DPRINT_ERR(NETVSC_DRV, "unable to add netvsc device (ret %d)", 372 ret); 373 return ret; 374 } 375 376 /* 377 * If carrier is still off ie we did not get a link status callback, 378 * update it if necessary 379 */ 380 if (!netif_carrier_ok(net)) 381 if (!device_info.LinkState) 382 netif_carrier_on(net); 383 384 memcpy(net->dev_addr, device_info.MacAddr, ETH_ALEN); 385 386 net->netdev_ops = &device_ops; 387 388 /* TODO: Add GSO and Checksum offload */ 389 net->features = NETIF_F_SG; 390 391 SET_ETHTOOL_OPS(net, ðtool_ops); 392 SET_NETDEV_DEV(net, device); 393 394 ret = register_netdev(net); 395 if (ret != 0) { 396 /* Remove the device and release the resource */ 397 net_drv_obj->Base.OnDeviceRemove(device_obj); 398 free_netdev(net); 399 } 400 401 return ret; 402} 403 404static int netvsc_remove(struct device *device) 405{ 406 struct driver_context *driver_ctx = 407 driver_to_driver_context(device->driver); 408 struct netvsc_driver_context *net_drv_ctx = 409 (struct netvsc_driver_context *)driver_ctx; 410 struct netvsc_driver *net_drv_obj = &net_drv_ctx->drv_obj; 411 struct vm_device *device_ctx = device_to_vm_device(device); 412 struct net_device *net = dev_get_drvdata(&device_ctx->device); 413 struct hv_device *device_obj = &device_ctx->device_obj; 414 int ret; 415 416 if (net == NULL) { 417 DPRINT_INFO(NETVSC, "no net device to remove"); 418 return 0; 419 } 420 421 if (!net_drv_obj->Base.OnDeviceRemove) 422 return -1; 423 424 /* Stop outbound asap */ 425 netif_stop_queue(net); 426 /* netif_carrier_off(net); */ 427 428 unregister_netdev(net); 429 430 /* 431 * Call to the vsc driver to let it know that the device is being 432 * removed 433 */ 434 ret = net_drv_obj->Base.OnDeviceRemove(device_obj); 435 if (ret != 0) { 436 /* TODO: */ 437 DPRINT_ERR(NETVSC, "unable to remove vsc device (ret %d)", ret); 438 } 439 440 free_netdev(net); 441 return ret; 442} 443 444static int netvsc_drv_exit_cb(struct device *dev, void *data) 445{ 446 struct device **curr = (struct device **)data; 447 448 *curr = dev; 449 /* stop iterating */ 450 return 1; 451} 452 453static void netvsc_drv_exit(void) 454{ 455 struct netvsc_driver *netvsc_drv_obj = &g_netvsc_drv.drv_obj; 456 struct driver_context *drv_ctx = &g_netvsc_drv.drv_ctx; 457 struct device *current_dev; 458 int ret; 459 460 while (1) { 461 current_dev = NULL; 462 463 /* Get the device */ 464 ret = driver_for_each_device(&drv_ctx->driver, NULL, 465 ¤t_dev, netvsc_drv_exit_cb); 466 if (ret) 467 DPRINT_WARN(NETVSC_DRV, 468 "driver_for_each_device returned %d", ret); 469 470 if (current_dev == NULL) 471 break; 472 473 /* Initiate removal from the top-down */ 474 DPRINT_INFO(NETVSC_DRV, "unregistering device (%p)...", 475 current_dev); 476 477 device_unregister(current_dev); 478 } 479 480 if (netvsc_drv_obj->Base.OnCleanup) 481 netvsc_drv_obj->Base.OnCleanup(&netvsc_drv_obj->Base); 482 483 vmbus_child_driver_unregister(drv_ctx); 484 485 return; 486} 487 488static int netvsc_drv_init(int (*drv_init)(struct hv_driver *drv)) 489{ 490 struct netvsc_driver *net_drv_obj = &g_netvsc_drv.drv_obj; 491 struct driver_context *drv_ctx = &g_netvsc_drv.drv_ctx; 492 int ret; 493 494 vmbus_get_interface(&net_drv_obj->Base.VmbusChannelInterface); 495 496 net_drv_obj->RingBufferSize = ring_size * PAGE_SIZE; 497 net_drv_obj->OnReceiveCallback = netvsc_recv_callback; 498 net_drv_obj->OnLinkStatusChanged = netvsc_linkstatus_callback; 499 500 /* Callback to client driver to complete the initialization */ 501 drv_init(&net_drv_obj->Base); 502 503 drv_ctx->driver.name = net_drv_obj->Base.name; 504 memcpy(&drv_ctx->class_id, &net_drv_obj->Base.deviceType, 505 sizeof(struct hv_guid)); 506 507 drv_ctx->probe = netvsc_probe; 508 drv_ctx->remove = netvsc_remove; 509 510 /* The driver belongs to vmbus */ 511 ret = vmbus_child_driver_register(drv_ctx); 512 513 return ret; 514} 515 516static const struct dmi_system_id __initconst 517hv_netvsc_dmi_table[] __maybe_unused = { 518 { 519 .ident = "Hyper-V", 520 .matches = { 521 DMI_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"), 522 DMI_MATCH(DMI_PRODUCT_NAME, "Virtual Machine"), 523 DMI_MATCH(DMI_BOARD_NAME, "Virtual Machine"), 524 }, 525 }, 526 { }, 527}; 528MODULE_DEVICE_TABLE(dmi, hv_netvsc_dmi_table); 529 530static int __init netvsc_init(void) 531{ 532 DPRINT_INFO(NETVSC_DRV, "Netvsc initializing...."); 533 534 if (!dmi_check_system(hv_netvsc_dmi_table)) 535 return -ENODEV; 536 537 return netvsc_drv_init(NetVscInitialize); 538} 539 540static void __exit netvsc_exit(void) 541{ 542 netvsc_drv_exit(); 543} 544 545static const struct pci_device_id __initconst 546hv_netvsc_pci_table[] __maybe_unused = { 547 { PCI_DEVICE(0x1414, 0x5353) }, /* VGA compatible controller */ 548 { 0 } 549}; 550MODULE_DEVICE_TABLE(pci, hv_netvsc_pci_table); 551 552MODULE_LICENSE("GPL"); 553MODULE_VERSION(HV_DRV_VERSION); 554MODULE_DESCRIPTION("Microsoft Hyper-V network driver"); 555 556module_init(netvsc_init); 557module_exit(netvsc_exit); 558