1/* 2 * IBM Power Virtual Ethernet Device Driver 3 * 4 * This program is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU General Public License as published by 6 * the Free Software Foundation; either version 2 of the License, or 7 * (at your option) any later version. 8 * 9 * This program is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 * 14 * You should have received a copy of the GNU General Public License 15 * along with this program; if not, write to the Free Software 16 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 17 * 18 * Copyright (C) IBM Corporation, 2003, 2010 19 * 20 * Authors: Dave Larson <larson1@us.ibm.com> 21 * Santiago Leon <santil@linux.vnet.ibm.com> 22 * Brian King <brking@linux.vnet.ibm.com> 23 * Robert Jennings <rcj@linux.vnet.ibm.com> 24 * Anton Blanchard <anton@au.ibm.com> 25 */ 26 27#include <linux/module.h> 28#include <linux/moduleparam.h> 29#include <linux/types.h> 30#include <linux/errno.h> 31#include <linux/dma-mapping.h> 32#include <linux/kernel.h> 33#include <linux/netdevice.h> 34#include <linux/etherdevice.h> 35#include <linux/skbuff.h> 36#include <linux/init.h> 37#include <linux/interrupt.h> 38#include <linux/mm.h> 39#include <linux/pm.h> 40#include <linux/ethtool.h> 41#include <linux/in.h> 42#include <linux/ip.h> 43#include <linux/ipv6.h> 44#include <linux/slab.h> 45#include <asm/hvcall.h> 46#include <linux/atomic.h> 47#include <asm/vio.h> 48#include <asm/iommu.h> 49#include <asm/firmware.h> 50 51#include "ibmveth.h" 52 53static irqreturn_t ibmveth_interrupt(int irq, void *dev_instance); 54static void ibmveth_rxq_harvest_buffer(struct ibmveth_adapter *adapter); 55static unsigned long ibmveth_get_desired_dma(struct vio_dev *vdev); 56 57static struct kobj_type ktype_veth_pool; 58 59 60static const char ibmveth_driver_name[] = "ibmveth"; 61static const char ibmveth_driver_string[] = "IBM Power Virtual Ethernet Driver"; 62#define ibmveth_driver_version "1.04" 63 64MODULE_AUTHOR("Santiago Leon <santil@linux.vnet.ibm.com>"); 65MODULE_DESCRIPTION("IBM Power Virtual Ethernet Driver"); 66MODULE_LICENSE("GPL"); 67MODULE_VERSION(ibmveth_driver_version); 68 69static unsigned int tx_copybreak __read_mostly = 128; 70module_param(tx_copybreak, uint, 0644); 71MODULE_PARM_DESC(tx_copybreak, 72 "Maximum size of packet that is copied to a new buffer on transmit"); 73 74static unsigned int rx_copybreak __read_mostly = 128; 75module_param(rx_copybreak, uint, 0644); 76MODULE_PARM_DESC(rx_copybreak, 77 "Maximum size of packet that is copied to a new buffer on receive"); 78 79static unsigned int rx_flush __read_mostly = 0; 80module_param(rx_flush, uint, 0644); 81MODULE_PARM_DESC(rx_flush, "Flush receive buffers before use"); 82 83struct ibmveth_stat { 84 char name[ETH_GSTRING_LEN]; 85 int offset; 86}; 87 88#define IBMVETH_STAT_OFF(stat) offsetof(struct ibmveth_adapter, stat) 89#define IBMVETH_GET_STAT(a, off) *((u64 *)(((unsigned long)(a)) + off)) 90 91struct ibmveth_stat ibmveth_stats[] = { 92 { "replenish_task_cycles", IBMVETH_STAT_OFF(replenish_task_cycles) }, 93 { "replenish_no_mem", IBMVETH_STAT_OFF(replenish_no_mem) }, 94 { "replenish_add_buff_failure", 95 IBMVETH_STAT_OFF(replenish_add_buff_failure) }, 96 { "replenish_add_buff_success", 97 IBMVETH_STAT_OFF(replenish_add_buff_success) }, 98 { "rx_invalid_buffer", IBMVETH_STAT_OFF(rx_invalid_buffer) }, 99 { "rx_no_buffer", IBMVETH_STAT_OFF(rx_no_buffer) }, 100 { "tx_map_failed", IBMVETH_STAT_OFF(tx_map_failed) }, 101 { "tx_send_failed", IBMVETH_STAT_OFF(tx_send_failed) }, 102 { "fw_enabled_ipv4_csum", IBMVETH_STAT_OFF(fw_ipv4_csum_support) }, 103 { "fw_enabled_ipv6_csum", IBMVETH_STAT_OFF(fw_ipv6_csum_support) }, 104}; 105 106/* simple methods of getting data from the current rxq entry */ 107static inline u32 ibmveth_rxq_flags(struct ibmveth_adapter *adapter) 108{ 109 return adapter->rx_queue.queue_addr[adapter->rx_queue.index].flags_off; 110} 111 112static inline int ibmveth_rxq_toggle(struct ibmveth_adapter *adapter) 113{ 114 return (ibmveth_rxq_flags(adapter) & IBMVETH_RXQ_TOGGLE) >> 115 IBMVETH_RXQ_TOGGLE_SHIFT; 116} 117 118static inline int ibmveth_rxq_pending_buffer(struct ibmveth_adapter *adapter) 119{ 120 return ibmveth_rxq_toggle(adapter) == adapter->rx_queue.toggle; 121} 122 123static inline int ibmveth_rxq_buffer_valid(struct ibmveth_adapter *adapter) 124{ 125 return ibmveth_rxq_flags(adapter) & IBMVETH_RXQ_VALID; 126} 127 128static inline int ibmveth_rxq_frame_offset(struct ibmveth_adapter *adapter) 129{ 130 return ibmveth_rxq_flags(adapter) & IBMVETH_RXQ_OFF_MASK; 131} 132 133static inline int ibmveth_rxq_frame_length(struct ibmveth_adapter *adapter) 134{ 135 return adapter->rx_queue.queue_addr[adapter->rx_queue.index].length; 136} 137 138static inline int ibmveth_rxq_csum_good(struct ibmveth_adapter *adapter) 139{ 140 return ibmveth_rxq_flags(adapter) & IBMVETH_RXQ_CSUM_GOOD; 141} 142 143/* setup the initial settings for a buffer pool */ 144static void ibmveth_init_buffer_pool(struct ibmveth_buff_pool *pool, 145 u32 pool_index, u32 pool_size, 146 u32 buff_size, u32 pool_active) 147{ 148 pool->size = pool_size; 149 pool->index = pool_index; 150 pool->buff_size = buff_size; 151 pool->threshold = pool_size * 7 / 8; 152 pool->active = pool_active; 153} 154 155/* allocate and setup an buffer pool - called during open */ 156static int ibmveth_alloc_buffer_pool(struct ibmveth_buff_pool *pool) 157{ 158 int i; 159 160 pool->free_map = kmalloc(sizeof(u16) * pool->size, GFP_KERNEL); 161 162 if (!pool->free_map) 163 return -1; 164 165 pool->dma_addr = kmalloc(sizeof(dma_addr_t) * pool->size, GFP_KERNEL); 166 if (!pool->dma_addr) { 167 kfree(pool->free_map); 168 pool->free_map = NULL; 169 return -1; 170 } 171 172 pool->skbuff = kcalloc(pool->size, sizeof(void *), GFP_KERNEL); 173 174 if (!pool->skbuff) { 175 kfree(pool->dma_addr); 176 pool->dma_addr = NULL; 177 178 kfree(pool->free_map); 179 pool->free_map = NULL; 180 return -1; 181 } 182 183 memset(pool->dma_addr, 0, sizeof(dma_addr_t) * pool->size); 184 185 for (i = 0; i < pool->size; ++i) 186 pool->free_map[i] = i; 187 188 atomic_set(&pool->available, 0); 189 pool->producer_index = 0; 190 pool->consumer_index = 0; 191 192 return 0; 193} 194 195static inline void ibmveth_flush_buffer(void *addr, unsigned long length) 196{ 197 unsigned long offset; 198 199 for (offset = 0; offset < length; offset += SMP_CACHE_BYTES) 200 asm("dcbfl %0,%1" :: "b" (addr), "r" (offset)); 201} 202 203/* replenish the buffers for a pool. note that we don't need to 204 * skb_reserve these since they are used for incoming... 205 */ 206static void ibmveth_replenish_buffer_pool(struct ibmveth_adapter *adapter, 207 struct ibmveth_buff_pool *pool) 208{ 209 u32 i; 210 u32 count = pool->size - atomic_read(&pool->available); 211 u32 buffers_added = 0; 212 struct sk_buff *skb; 213 unsigned int free_index, index; 214 u64 correlator; 215 unsigned long lpar_rc; 216 dma_addr_t dma_addr; 217 218 mb(); 219 220 for (i = 0; i < count; ++i) { 221 union ibmveth_buf_desc desc; 222 223 skb = netdev_alloc_skb(adapter->netdev, pool->buff_size); 224 225 if (!skb) { 226 netdev_dbg(adapter->netdev, 227 "replenish: unable to allocate skb\n"); 228 adapter->replenish_no_mem++; 229 break; 230 } 231 232 free_index = pool->consumer_index; 233 pool->consumer_index++; 234 if (pool->consumer_index >= pool->size) 235 pool->consumer_index = 0; 236 index = pool->free_map[free_index]; 237 238 BUG_ON(index == IBM_VETH_INVALID_MAP); 239 BUG_ON(pool->skbuff[index] != NULL); 240 241 dma_addr = dma_map_single(&adapter->vdev->dev, skb->data, 242 pool->buff_size, DMA_FROM_DEVICE); 243 244 if (dma_mapping_error(&adapter->vdev->dev, dma_addr)) 245 goto failure; 246 247 pool->free_map[free_index] = IBM_VETH_INVALID_MAP; 248 pool->dma_addr[index] = dma_addr; 249 pool->skbuff[index] = skb; 250 251 correlator = ((u64)pool->index << 32) | index; 252 *(u64 *)skb->data = correlator; 253 254 desc.fields.flags_len = IBMVETH_BUF_VALID | pool->buff_size; 255 desc.fields.address = dma_addr; 256 257 if (rx_flush) { 258 unsigned int len = min(pool->buff_size, 259 adapter->netdev->mtu + 260 IBMVETH_BUFF_OH); 261 ibmveth_flush_buffer(skb->data, len); 262 } 263 lpar_rc = h_add_logical_lan_buffer(adapter->vdev->unit_address, 264 desc.desc); 265 266 if (lpar_rc != H_SUCCESS) { 267 goto failure; 268 } else { 269 buffers_added++; 270 adapter->replenish_add_buff_success++; 271 } 272 } 273 274 mb(); 275 atomic_add(buffers_added, &(pool->available)); 276 return; 277 278failure: 279 pool->free_map[free_index] = index; 280 pool->skbuff[index] = NULL; 281 if (pool->consumer_index == 0) 282 pool->consumer_index = pool->size - 1; 283 else 284 pool->consumer_index--; 285 if (!dma_mapping_error(&adapter->vdev->dev, dma_addr)) 286 dma_unmap_single(&adapter->vdev->dev, 287 pool->dma_addr[index], pool->buff_size, 288 DMA_FROM_DEVICE); 289 dev_kfree_skb_any(skb); 290 adapter->replenish_add_buff_failure++; 291 292 mb(); 293 atomic_add(buffers_added, &(pool->available)); 294} 295 296/* replenish routine */ 297static void ibmveth_replenish_task(struct ibmveth_adapter *adapter) 298{ 299 int i; 300 301 adapter->replenish_task_cycles++; 302 303 for (i = (IBMVETH_NUM_BUFF_POOLS - 1); i >= 0; i--) { 304 struct ibmveth_buff_pool *pool = &adapter->rx_buff_pool[i]; 305 306 if (pool->active && 307 (atomic_read(&pool->available) < pool->threshold)) 308 ibmveth_replenish_buffer_pool(adapter, pool); 309 } 310 311 adapter->rx_no_buffer = *(u64 *)(((char*)adapter->buffer_list_addr) + 312 4096 - 8); 313} 314 315/* empty and free ana buffer pool - also used to do cleanup in error paths */ 316static void ibmveth_free_buffer_pool(struct ibmveth_adapter *adapter, 317 struct ibmveth_buff_pool *pool) 318{ 319 int i; 320 321 kfree(pool->free_map); 322 pool->free_map = NULL; 323 324 if (pool->skbuff && pool->dma_addr) { 325 for (i = 0; i < pool->size; ++i) { 326 struct sk_buff *skb = pool->skbuff[i]; 327 if (skb) { 328 dma_unmap_single(&adapter->vdev->dev, 329 pool->dma_addr[i], 330 pool->buff_size, 331 DMA_FROM_DEVICE); 332 dev_kfree_skb_any(skb); 333 pool->skbuff[i] = NULL; 334 } 335 } 336 } 337 338 if (pool->dma_addr) { 339 kfree(pool->dma_addr); 340 pool->dma_addr = NULL; 341 } 342 343 if (pool->skbuff) { 344 kfree(pool->skbuff); 345 pool->skbuff = NULL; 346 } 347} 348 349/* remove a buffer from a pool */ 350static void ibmveth_remove_buffer_from_pool(struct ibmveth_adapter *adapter, 351 u64 correlator) 352{ 353 unsigned int pool = correlator >> 32; 354 unsigned int index = correlator & 0xffffffffUL; 355 unsigned int free_index; 356 struct sk_buff *skb; 357 358 BUG_ON(pool >= IBMVETH_NUM_BUFF_POOLS); 359 BUG_ON(index >= adapter->rx_buff_pool[pool].size); 360 361 skb = adapter->rx_buff_pool[pool].skbuff[index]; 362 363 BUG_ON(skb == NULL); 364 365 adapter->rx_buff_pool[pool].skbuff[index] = NULL; 366 367 dma_unmap_single(&adapter->vdev->dev, 368 adapter->rx_buff_pool[pool].dma_addr[index], 369 adapter->rx_buff_pool[pool].buff_size, 370 DMA_FROM_DEVICE); 371 372 free_index = adapter->rx_buff_pool[pool].producer_index; 373 adapter->rx_buff_pool[pool].producer_index++; 374 if (adapter->rx_buff_pool[pool].producer_index >= 375 adapter->rx_buff_pool[pool].size) 376 adapter->rx_buff_pool[pool].producer_index = 0; 377 adapter->rx_buff_pool[pool].free_map[free_index] = index; 378 379 mb(); 380 381 atomic_dec(&(adapter->rx_buff_pool[pool].available)); 382} 383 384/* get the current buffer on the rx queue */ 385static inline struct sk_buff *ibmveth_rxq_get_buffer(struct ibmveth_adapter *adapter) 386{ 387 u64 correlator = adapter->rx_queue.queue_addr[adapter->rx_queue.index].correlator; 388 unsigned int pool = correlator >> 32; 389 unsigned int index = correlator & 0xffffffffUL; 390 391 BUG_ON(pool >= IBMVETH_NUM_BUFF_POOLS); 392 BUG_ON(index >= adapter->rx_buff_pool[pool].size); 393 394 return adapter->rx_buff_pool[pool].skbuff[index]; 395} 396 397/* recycle the current buffer on the rx queue */ 398static int ibmveth_rxq_recycle_buffer(struct ibmveth_adapter *adapter) 399{ 400 u32 q_index = adapter->rx_queue.index; 401 u64 correlator = adapter->rx_queue.queue_addr[q_index].correlator; 402 unsigned int pool = correlator >> 32; 403 unsigned int index = correlator & 0xffffffffUL; 404 union ibmveth_buf_desc desc; 405 unsigned long lpar_rc; 406 int ret = 1; 407 408 BUG_ON(pool >= IBMVETH_NUM_BUFF_POOLS); 409 BUG_ON(index >= adapter->rx_buff_pool[pool].size); 410 411 if (!adapter->rx_buff_pool[pool].active) { 412 ibmveth_rxq_harvest_buffer(adapter); 413 ibmveth_free_buffer_pool(adapter, &adapter->rx_buff_pool[pool]); 414 goto out; 415 } 416 417 desc.fields.flags_len = IBMVETH_BUF_VALID | 418 adapter->rx_buff_pool[pool].buff_size; 419 desc.fields.address = adapter->rx_buff_pool[pool].dma_addr[index]; 420 421 lpar_rc = h_add_logical_lan_buffer(adapter->vdev->unit_address, desc.desc); 422 423 if (lpar_rc != H_SUCCESS) { 424 netdev_dbg(adapter->netdev, "h_add_logical_lan_buffer failed " 425 "during recycle rc=%ld", lpar_rc); 426 ibmveth_remove_buffer_from_pool(adapter, adapter->rx_queue.queue_addr[adapter->rx_queue.index].correlator); 427 ret = 0; 428 } 429 430 if (++adapter->rx_queue.index == adapter->rx_queue.num_slots) { 431 adapter->rx_queue.index = 0; 432 adapter->rx_queue.toggle = !adapter->rx_queue.toggle; 433 } 434 435out: 436 return ret; 437} 438 439static void ibmveth_rxq_harvest_buffer(struct ibmveth_adapter *adapter) 440{ 441 ibmveth_remove_buffer_from_pool(adapter, adapter->rx_queue.queue_addr[adapter->rx_queue.index].correlator); 442 443 if (++adapter->rx_queue.index == adapter->rx_queue.num_slots) { 444 adapter->rx_queue.index = 0; 445 adapter->rx_queue.toggle = !adapter->rx_queue.toggle; 446 } 447} 448 449static void ibmveth_cleanup(struct ibmveth_adapter *adapter) 450{ 451 int i; 452 struct device *dev = &adapter->vdev->dev; 453 454 if (adapter->buffer_list_addr != NULL) { 455 if (!dma_mapping_error(dev, adapter->buffer_list_dma)) { 456 dma_unmap_single(dev, adapter->buffer_list_dma, 4096, 457 DMA_BIDIRECTIONAL); 458 adapter->buffer_list_dma = DMA_ERROR_CODE; 459 } 460 free_page((unsigned long)adapter->buffer_list_addr); 461 adapter->buffer_list_addr = NULL; 462 } 463 464 if (adapter->filter_list_addr != NULL) { 465 if (!dma_mapping_error(dev, adapter->filter_list_dma)) { 466 dma_unmap_single(dev, adapter->filter_list_dma, 4096, 467 DMA_BIDIRECTIONAL); 468 adapter->filter_list_dma = DMA_ERROR_CODE; 469 } 470 free_page((unsigned long)adapter->filter_list_addr); 471 adapter->filter_list_addr = NULL; 472 } 473 474 if (adapter->rx_queue.queue_addr != NULL) { 475 if (!dma_mapping_error(dev, adapter->rx_queue.queue_dma)) { 476 dma_unmap_single(dev, 477 adapter->rx_queue.queue_dma, 478 adapter->rx_queue.queue_len, 479 DMA_BIDIRECTIONAL); 480 adapter->rx_queue.queue_dma = DMA_ERROR_CODE; 481 } 482 kfree(adapter->rx_queue.queue_addr); 483 adapter->rx_queue.queue_addr = NULL; 484 } 485 486 for (i = 0; i < IBMVETH_NUM_BUFF_POOLS; i++) 487 if (adapter->rx_buff_pool[i].active) 488 ibmveth_free_buffer_pool(adapter, 489 &adapter->rx_buff_pool[i]); 490 491 if (adapter->bounce_buffer != NULL) { 492 if (!dma_mapping_error(dev, adapter->bounce_buffer_dma)) { 493 dma_unmap_single(&adapter->vdev->dev, 494 adapter->bounce_buffer_dma, 495 adapter->netdev->mtu + IBMVETH_BUFF_OH, 496 DMA_BIDIRECTIONAL); 497 adapter->bounce_buffer_dma = DMA_ERROR_CODE; 498 } 499 kfree(adapter->bounce_buffer); 500 adapter->bounce_buffer = NULL; 501 } 502} 503 504static int ibmveth_register_logical_lan(struct ibmveth_adapter *adapter, 505 union ibmveth_buf_desc rxq_desc, u64 mac_address) 506{ 507 int rc, try_again = 1; 508 509 /* 510 * After a kexec the adapter will still be open, so our attempt to 511 * open it will fail. So if we get a failure we free the adapter and 512 * try again, but only once. 513 */ 514retry: 515 rc = h_register_logical_lan(adapter->vdev->unit_address, 516 adapter->buffer_list_dma, rxq_desc.desc, 517 adapter->filter_list_dma, mac_address); 518 519 if (rc != H_SUCCESS && try_again) { 520 do { 521 rc = h_free_logical_lan(adapter->vdev->unit_address); 522 } while (H_IS_LONG_BUSY(rc) || (rc == H_BUSY)); 523 524 try_again = 0; 525 goto retry; 526 } 527 528 return rc; 529} 530 531static int ibmveth_open(struct net_device *netdev) 532{ 533 struct ibmveth_adapter *adapter = netdev_priv(netdev); 534 u64 mac_address = 0; 535 int rxq_entries = 1; 536 unsigned long lpar_rc; 537 int rc; 538 union ibmveth_buf_desc rxq_desc; 539 int i; 540 struct device *dev; 541 542 netdev_dbg(netdev, "open starting\n"); 543 544 napi_enable(&adapter->napi); 545 546 for(i = 0; i < IBMVETH_NUM_BUFF_POOLS; i++) 547 rxq_entries += adapter->rx_buff_pool[i].size; 548 549 adapter->buffer_list_addr = (void*) get_zeroed_page(GFP_KERNEL); 550 adapter->filter_list_addr = (void*) get_zeroed_page(GFP_KERNEL); 551 552 if (!adapter->buffer_list_addr || !adapter->filter_list_addr) { 553 netdev_err(netdev, "unable to allocate filter or buffer list " 554 "pages\n"); 555 rc = -ENOMEM; 556 goto err_out; 557 } 558 559 adapter->rx_queue.queue_len = sizeof(struct ibmveth_rx_q_entry) * 560 rxq_entries; 561 adapter->rx_queue.queue_addr = kmalloc(adapter->rx_queue.queue_len, 562 GFP_KERNEL); 563 564 if (!adapter->rx_queue.queue_addr) { 565 netdev_err(netdev, "unable to allocate rx queue pages\n"); 566 rc = -ENOMEM; 567 goto err_out; 568 } 569 570 dev = &adapter->vdev->dev; 571 572 adapter->buffer_list_dma = dma_map_single(dev, 573 adapter->buffer_list_addr, 4096, DMA_BIDIRECTIONAL); 574 adapter->filter_list_dma = dma_map_single(dev, 575 adapter->filter_list_addr, 4096, DMA_BIDIRECTIONAL); 576 adapter->rx_queue.queue_dma = dma_map_single(dev, 577 adapter->rx_queue.queue_addr, 578 adapter->rx_queue.queue_len, DMA_BIDIRECTIONAL); 579 580 if ((dma_mapping_error(dev, adapter->buffer_list_dma)) || 581 (dma_mapping_error(dev, adapter->filter_list_dma)) || 582 (dma_mapping_error(dev, adapter->rx_queue.queue_dma))) { 583 netdev_err(netdev, "unable to map filter or buffer list " 584 "pages\n"); 585 rc = -ENOMEM; 586 goto err_out; 587 } 588 589 adapter->rx_queue.index = 0; 590 adapter->rx_queue.num_slots = rxq_entries; 591 adapter->rx_queue.toggle = 1; 592 593 memcpy(&mac_address, netdev->dev_addr, netdev->addr_len); 594 mac_address = mac_address >> 16; 595 596 rxq_desc.fields.flags_len = IBMVETH_BUF_VALID | 597 adapter->rx_queue.queue_len; 598 rxq_desc.fields.address = adapter->rx_queue.queue_dma; 599 600 netdev_dbg(netdev, "buffer list @ 0x%p\n", adapter->buffer_list_addr); 601 netdev_dbg(netdev, "filter list @ 0x%p\n", adapter->filter_list_addr); 602 netdev_dbg(netdev, "receive q @ 0x%p\n", adapter->rx_queue.queue_addr); 603 604 h_vio_signal(adapter->vdev->unit_address, VIO_IRQ_DISABLE); 605 606 lpar_rc = ibmveth_register_logical_lan(adapter, rxq_desc, mac_address); 607 608 if (lpar_rc != H_SUCCESS) { 609 netdev_err(netdev, "h_register_logical_lan failed with %ld\n", 610 lpar_rc); 611 netdev_err(netdev, "buffer TCE:0x%llx filter TCE:0x%llx rxq " 612 "desc:0x%llx MAC:0x%llx\n", 613 adapter->buffer_list_dma, 614 adapter->filter_list_dma, 615 rxq_desc.desc, 616 mac_address); 617 rc = -ENONET; 618 goto err_out; 619 } 620 621 for (i = 0; i < IBMVETH_NUM_BUFF_POOLS; i++) { 622 if (!adapter->rx_buff_pool[i].active) 623 continue; 624 if (ibmveth_alloc_buffer_pool(&adapter->rx_buff_pool[i])) { 625 netdev_err(netdev, "unable to alloc pool\n"); 626 adapter->rx_buff_pool[i].active = 0; 627 rc = -ENOMEM; 628 goto err_out; 629 } 630 } 631 632 netdev_dbg(netdev, "registering irq 0x%x\n", netdev->irq); 633 rc = request_irq(netdev->irq, ibmveth_interrupt, 0, netdev->name, 634 netdev); 635 if (rc != 0) { 636 netdev_err(netdev, "unable to request irq 0x%x, rc %d\n", 637 netdev->irq, rc); 638 do { 639 lpar_rc = h_free_logical_lan(adapter->vdev->unit_address); 640 } while (H_IS_LONG_BUSY(lpar_rc) || (lpar_rc == H_BUSY)); 641 642 goto err_out; 643 } 644 645 adapter->bounce_buffer = 646 kmalloc(netdev->mtu + IBMVETH_BUFF_OH, GFP_KERNEL); 647 if (!adapter->bounce_buffer) { 648 netdev_err(netdev, "unable to allocate bounce buffer\n"); 649 rc = -ENOMEM; 650 goto err_out_free_irq; 651 } 652 adapter->bounce_buffer_dma = 653 dma_map_single(&adapter->vdev->dev, adapter->bounce_buffer, 654 netdev->mtu + IBMVETH_BUFF_OH, DMA_BIDIRECTIONAL); 655 if (dma_mapping_error(dev, adapter->bounce_buffer_dma)) { 656 netdev_err(netdev, "unable to map bounce buffer\n"); 657 rc = -ENOMEM; 658 goto err_out_free_irq; 659 } 660 661 netdev_dbg(netdev, "initial replenish cycle\n"); 662 ibmveth_interrupt(netdev->irq, netdev); 663 664 netif_start_queue(netdev); 665 666 netdev_dbg(netdev, "open complete\n"); 667 668 return 0; 669 670err_out_free_irq: 671 free_irq(netdev->irq, netdev); 672err_out: 673 ibmveth_cleanup(adapter); 674 napi_disable(&adapter->napi); 675 return rc; 676} 677 678static int ibmveth_close(struct net_device *netdev) 679{ 680 struct ibmveth_adapter *adapter = netdev_priv(netdev); 681 long lpar_rc; 682 683 netdev_dbg(netdev, "close starting\n"); 684 685 napi_disable(&adapter->napi); 686 687 if (!adapter->pool_config) 688 netif_stop_queue(netdev); 689 690 h_vio_signal(adapter->vdev->unit_address, VIO_IRQ_DISABLE); 691 692 do { 693 lpar_rc = h_free_logical_lan(adapter->vdev->unit_address); 694 } while (H_IS_LONG_BUSY(lpar_rc) || (lpar_rc == H_BUSY)); 695 696 if (lpar_rc != H_SUCCESS) { 697 netdev_err(netdev, "h_free_logical_lan failed with %lx, " 698 "continuing with close\n", lpar_rc); 699 } 700 701 free_irq(netdev->irq, netdev); 702 703 adapter->rx_no_buffer = *(u64 *)(((char *)adapter->buffer_list_addr) + 704 4096 - 8); 705 706 ibmveth_cleanup(adapter); 707 708 netdev_dbg(netdev, "close complete\n"); 709 710 return 0; 711} 712 713static int netdev_get_settings(struct net_device *dev, struct ethtool_cmd *cmd) 714{ 715 cmd->supported = (SUPPORTED_1000baseT_Full | SUPPORTED_Autoneg | 716 SUPPORTED_FIBRE); 717 cmd->advertising = (ADVERTISED_1000baseT_Full | ADVERTISED_Autoneg | 718 ADVERTISED_FIBRE); 719 ethtool_cmd_speed_set(cmd, SPEED_1000); 720 cmd->duplex = DUPLEX_FULL; 721 cmd->port = PORT_FIBRE; 722 cmd->phy_address = 0; 723 cmd->transceiver = XCVR_INTERNAL; 724 cmd->autoneg = AUTONEG_ENABLE; 725 cmd->maxtxpkt = 0; 726 cmd->maxrxpkt = 1; 727 return 0; 728} 729 730static void netdev_get_drvinfo(struct net_device *dev, 731 struct ethtool_drvinfo *info) 732{ 733 strncpy(info->driver, ibmveth_driver_name, sizeof(info->driver) - 1); 734 strncpy(info->version, ibmveth_driver_version, 735 sizeof(info->version) - 1); 736} 737 738static netdev_features_t ibmveth_fix_features(struct net_device *dev, 739 netdev_features_t features) 740{ 741 /* 742 * Since the ibmveth firmware interface does not have the 743 * concept of separate tx/rx checksum offload enable, if rx 744 * checksum is disabled we also have to disable tx checksum 745 * offload. Once we disable rx checksum offload, we are no 746 * longer allowed to send tx buffers that are not properly 747 * checksummed. 748 */ 749 750 if (!(features & NETIF_F_RXCSUM)) 751 features &= ~NETIF_F_ALL_CSUM; 752 753 return features; 754} 755 756static int ibmveth_set_csum_offload(struct net_device *dev, u32 data) 757{ 758 struct ibmveth_adapter *adapter = netdev_priv(dev); 759 unsigned long set_attr, clr_attr, ret_attr; 760 unsigned long set_attr6, clr_attr6; 761 long ret, ret4, ret6; 762 int rc1 = 0, rc2 = 0; 763 int restart = 0; 764 765 if (netif_running(dev)) { 766 restart = 1; 767 adapter->pool_config = 1; 768 ibmveth_close(dev); 769 adapter->pool_config = 0; 770 } 771 772 set_attr = 0; 773 clr_attr = 0; 774 set_attr6 = 0; 775 clr_attr6 = 0; 776 777 if (data) { 778 set_attr = IBMVETH_ILLAN_IPV4_TCP_CSUM; 779 set_attr6 = IBMVETH_ILLAN_IPV6_TCP_CSUM; 780 } else { 781 clr_attr = IBMVETH_ILLAN_IPV4_TCP_CSUM; 782 clr_attr6 = IBMVETH_ILLAN_IPV6_TCP_CSUM; 783 } 784 785 ret = h_illan_attributes(adapter->vdev->unit_address, 0, 0, &ret_attr); 786 787 if (ret == H_SUCCESS && !(ret_attr & IBMVETH_ILLAN_ACTIVE_TRUNK) && 788 !(ret_attr & IBMVETH_ILLAN_TRUNK_PRI_MASK) && 789 (ret_attr & IBMVETH_ILLAN_PADDED_PKT_CSUM)) { 790 ret4 = h_illan_attributes(adapter->vdev->unit_address, clr_attr, 791 set_attr, &ret_attr); 792 793 if (ret4 != H_SUCCESS) { 794 netdev_err(dev, "unable to change IPv4 checksum " 795 "offload settings. %d rc=%ld\n", 796 data, ret4); 797 798 h_illan_attributes(adapter->vdev->unit_address, 799 set_attr, clr_attr, &ret_attr); 800 801 if (data == 1) 802 dev->features &= ~NETIF_F_IP_CSUM; 803 804 } else { 805 adapter->fw_ipv4_csum_support = data; 806 } 807 808 ret6 = h_illan_attributes(adapter->vdev->unit_address, 809 clr_attr6, set_attr6, &ret_attr); 810 811 if (ret6 != H_SUCCESS) { 812 netdev_err(dev, "unable to change IPv6 checksum " 813 "offload settings. %d rc=%ld\n", 814 data, ret6); 815 816 h_illan_attributes(adapter->vdev->unit_address, 817 set_attr6, clr_attr6, &ret_attr); 818 819 if (data == 1) 820 dev->features &= ~NETIF_F_IPV6_CSUM; 821 822 } else 823 adapter->fw_ipv6_csum_support = data; 824 825 if (ret4 == H_SUCCESS || ret6 == H_SUCCESS) 826 adapter->rx_csum = data; 827 else 828 rc1 = -EIO; 829 } else { 830 rc1 = -EIO; 831 netdev_err(dev, "unable to change checksum offload settings." 832 " %d rc=%ld ret_attr=%lx\n", data, ret, 833 ret_attr); 834 } 835 836 if (restart) 837 rc2 = ibmveth_open(dev); 838 839 return rc1 ? rc1 : rc2; 840} 841 842static int ibmveth_set_features(struct net_device *dev, 843 netdev_features_t features) 844{ 845 struct ibmveth_adapter *adapter = netdev_priv(dev); 846 int rx_csum = !!(features & NETIF_F_RXCSUM); 847 int rc; 848 849 if (rx_csum == adapter->rx_csum) 850 return 0; 851 852 rc = ibmveth_set_csum_offload(dev, rx_csum); 853 if (rc && !adapter->rx_csum) 854 dev->features = features & ~(NETIF_F_ALL_CSUM | NETIF_F_RXCSUM); 855 856 return rc; 857} 858 859static void ibmveth_get_strings(struct net_device *dev, u32 stringset, u8 *data) 860{ 861 int i; 862 863 if (stringset != ETH_SS_STATS) 864 return; 865 866 for (i = 0; i < ARRAY_SIZE(ibmveth_stats); i++, data += ETH_GSTRING_LEN) 867 memcpy(data, ibmveth_stats[i].name, ETH_GSTRING_LEN); 868} 869 870static int ibmveth_get_sset_count(struct net_device *dev, int sset) 871{ 872 switch (sset) { 873 case ETH_SS_STATS: 874 return ARRAY_SIZE(ibmveth_stats); 875 default: 876 return -EOPNOTSUPP; 877 } 878} 879 880static void ibmveth_get_ethtool_stats(struct net_device *dev, 881 struct ethtool_stats *stats, u64 *data) 882{ 883 int i; 884 struct ibmveth_adapter *adapter = netdev_priv(dev); 885 886 for (i = 0; i < ARRAY_SIZE(ibmveth_stats); i++) 887 data[i] = IBMVETH_GET_STAT(adapter, ibmveth_stats[i].offset); 888} 889 890static const struct ethtool_ops netdev_ethtool_ops = { 891 .get_drvinfo = netdev_get_drvinfo, 892 .get_settings = netdev_get_settings, 893 .get_link = ethtool_op_get_link, 894 .get_strings = ibmveth_get_strings, 895 .get_sset_count = ibmveth_get_sset_count, 896 .get_ethtool_stats = ibmveth_get_ethtool_stats, 897}; 898 899static int ibmveth_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) 900{ 901 return -EOPNOTSUPP; 902} 903 904#define page_offset(v) ((unsigned long)(v) & ((1 << 12) - 1)) 905 906static int ibmveth_send(struct ibmveth_adapter *adapter, 907 union ibmveth_buf_desc *descs) 908{ 909 unsigned long correlator; 910 unsigned int retry_count; 911 unsigned long ret; 912 913 /* 914 * The retry count sets a maximum for the number of broadcast and 915 * multicast destinations within the system. 916 */ 917 retry_count = 1024; 918 correlator = 0; 919 do { 920 ret = h_send_logical_lan(adapter->vdev->unit_address, 921 descs[0].desc, descs[1].desc, 922 descs[2].desc, descs[3].desc, 923 descs[4].desc, descs[5].desc, 924 correlator, &correlator); 925 } while ((ret == H_BUSY) && (retry_count--)); 926 927 if (ret != H_SUCCESS && ret != H_DROPPED) { 928 netdev_err(adapter->netdev, "tx: h_send_logical_lan failed " 929 "with rc=%ld\n", ret); 930 return 1; 931 } 932 933 return 0; 934} 935 936static netdev_tx_t ibmveth_start_xmit(struct sk_buff *skb, 937 struct net_device *netdev) 938{ 939 struct ibmveth_adapter *adapter = netdev_priv(netdev); 940 unsigned int desc_flags; 941 union ibmveth_buf_desc descs[6]; 942 int last, i; 943 int force_bounce = 0; 944 dma_addr_t dma_addr; 945 946 /* 947 * veth handles a maximum of 6 segments including the header, so 948 * we have to linearize the skb if there are more than this. 949 */ 950 if (skb_shinfo(skb)->nr_frags > 5 && __skb_linearize(skb)) { 951 netdev->stats.tx_dropped++; 952 goto out; 953 } 954 955 /* veth can't checksum offload UDP */ 956 if (skb->ip_summed == CHECKSUM_PARTIAL && 957 ((skb->protocol == htons(ETH_P_IP) && 958 ip_hdr(skb)->protocol != IPPROTO_TCP) || 959 (skb->protocol == htons(ETH_P_IPV6) && 960 ipv6_hdr(skb)->nexthdr != IPPROTO_TCP)) && 961 skb_checksum_help(skb)) { 962 963 netdev_err(netdev, "tx: failed to checksum packet\n"); 964 netdev->stats.tx_dropped++; 965 goto out; 966 } 967 968 desc_flags = IBMVETH_BUF_VALID; 969 970 if (skb->ip_summed == CHECKSUM_PARTIAL) { 971 unsigned char *buf = skb_transport_header(skb) + 972 skb->csum_offset; 973 974 desc_flags |= (IBMVETH_BUF_NO_CSUM | IBMVETH_BUF_CSUM_GOOD); 975 976 /* Need to zero out the checksum */ 977 buf[0] = 0; 978 buf[1] = 0; 979 } 980 981retry_bounce: 982 memset(descs, 0, sizeof(descs)); 983 984 /* 985 * If a linear packet is below the rx threshold then 986 * copy it into the static bounce buffer. This avoids the 987 * cost of a TCE insert and remove. 988 */ 989 if (force_bounce || (!skb_is_nonlinear(skb) && 990 (skb->len < tx_copybreak))) { 991 skb_copy_from_linear_data(skb, adapter->bounce_buffer, 992 skb->len); 993 994 descs[0].fields.flags_len = desc_flags | skb->len; 995 descs[0].fields.address = adapter->bounce_buffer_dma; 996 997 if (ibmveth_send(adapter, descs)) { 998 adapter->tx_send_failed++; 999 netdev->stats.tx_dropped++; 1000 } else { 1001 netdev->stats.tx_packets++; 1002 netdev->stats.tx_bytes += skb->len; 1003 } 1004 1005 goto out; 1006 } 1007 1008 /* Map the header */ 1009 dma_addr = dma_map_single(&adapter->vdev->dev, skb->data, 1010 skb_headlen(skb), DMA_TO_DEVICE); 1011 if (dma_mapping_error(&adapter->vdev->dev, dma_addr)) 1012 goto map_failed; 1013 1014 descs[0].fields.flags_len = desc_flags | skb_headlen(skb); 1015 descs[0].fields.address = dma_addr; 1016 1017 /* Map the frags */ 1018 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) { 1019 const skb_frag_t *frag = &skb_shinfo(skb)->frags[i]; 1020 1021 dma_addr = skb_frag_dma_map(&adapter->vdev->dev, frag, 0, 1022 skb_frag_size(frag), DMA_TO_DEVICE); 1023 1024 if (dma_mapping_error(&adapter->vdev->dev, dma_addr)) 1025 goto map_failed_frags; 1026 1027 descs[i+1].fields.flags_len = desc_flags | skb_frag_size(frag); 1028 descs[i+1].fields.address = dma_addr; 1029 } 1030 1031 if (ibmveth_send(adapter, descs)) { 1032 adapter->tx_send_failed++; 1033 netdev->stats.tx_dropped++; 1034 } else { 1035 netdev->stats.tx_packets++; 1036 netdev->stats.tx_bytes += skb->len; 1037 } 1038 1039 dma_unmap_single(&adapter->vdev->dev, 1040 descs[0].fields.address, 1041 descs[0].fields.flags_len & IBMVETH_BUF_LEN_MASK, 1042 DMA_TO_DEVICE); 1043 1044 for (i = 1; i < skb_shinfo(skb)->nr_frags + 1; i++) 1045 dma_unmap_page(&adapter->vdev->dev, descs[i].fields.address, 1046 descs[i].fields.flags_len & IBMVETH_BUF_LEN_MASK, 1047 DMA_TO_DEVICE); 1048 1049out: 1050 dev_kfree_skb(skb); 1051 return NETDEV_TX_OK; 1052 1053map_failed_frags: 1054 last = i+1; 1055 for (i = 0; i < last; i++) 1056 dma_unmap_page(&adapter->vdev->dev, descs[i].fields.address, 1057 descs[i].fields.flags_len & IBMVETH_BUF_LEN_MASK, 1058 DMA_TO_DEVICE); 1059 1060map_failed: 1061 if (!firmware_has_feature(FW_FEATURE_CMO)) 1062 netdev_err(netdev, "tx: unable to map xmit buffer\n"); 1063 adapter->tx_map_failed++; 1064 skb_linearize(skb); 1065 force_bounce = 1; 1066 goto retry_bounce; 1067} 1068 1069static int ibmveth_poll(struct napi_struct *napi, int budget) 1070{ 1071 struct ibmveth_adapter *adapter = 1072 container_of(napi, struct ibmveth_adapter, napi); 1073 struct net_device *netdev = adapter->netdev; 1074 int frames_processed = 0; 1075 unsigned long lpar_rc; 1076 1077restart_poll: 1078 do { 1079 if (!ibmveth_rxq_pending_buffer(adapter)) 1080 break; 1081 1082 smp_rmb(); 1083 if (!ibmveth_rxq_buffer_valid(adapter)) { 1084 wmb(); /* suggested by larson1 */ 1085 adapter->rx_invalid_buffer++; 1086 netdev_dbg(netdev, "recycling invalid buffer\n"); 1087 ibmveth_rxq_recycle_buffer(adapter); 1088 } else { 1089 struct sk_buff *skb, *new_skb; 1090 int length = ibmveth_rxq_frame_length(adapter); 1091 int offset = ibmveth_rxq_frame_offset(adapter); 1092 int csum_good = ibmveth_rxq_csum_good(adapter); 1093 1094 skb = ibmveth_rxq_get_buffer(adapter); 1095 1096 new_skb = NULL; 1097 if (length < rx_copybreak) 1098 new_skb = netdev_alloc_skb(netdev, length); 1099 1100 if (new_skb) { 1101 skb_copy_to_linear_data(new_skb, 1102 skb->data + offset, 1103 length); 1104 if (rx_flush) 1105 ibmveth_flush_buffer(skb->data, 1106 length + offset); 1107 if (!ibmveth_rxq_recycle_buffer(adapter)) 1108 kfree_skb(skb); 1109 skb = new_skb; 1110 } else { 1111 ibmveth_rxq_harvest_buffer(adapter); 1112 skb_reserve(skb, offset); 1113 } 1114 1115 skb_put(skb, length); 1116 skb->protocol = eth_type_trans(skb, netdev); 1117 1118 if (csum_good) 1119 skb->ip_summed = CHECKSUM_UNNECESSARY; 1120 1121 netif_receive_skb(skb); /* send it up */ 1122 1123 netdev->stats.rx_packets++; 1124 netdev->stats.rx_bytes += length; 1125 frames_processed++; 1126 } 1127 } while (frames_processed < budget); 1128 1129 ibmveth_replenish_task(adapter); 1130 1131 if (frames_processed < budget) { 1132 /* We think we are done - reenable interrupts, 1133 * then check once more to make sure we are done. 1134 */ 1135 lpar_rc = h_vio_signal(adapter->vdev->unit_address, 1136 VIO_IRQ_ENABLE); 1137 1138 BUG_ON(lpar_rc != H_SUCCESS); 1139 1140 napi_complete(napi); 1141 1142 if (ibmveth_rxq_pending_buffer(adapter) && 1143 napi_reschedule(napi)) { 1144 lpar_rc = h_vio_signal(adapter->vdev->unit_address, 1145 VIO_IRQ_DISABLE); 1146 goto restart_poll; 1147 } 1148 } 1149 1150 return frames_processed; 1151} 1152 1153static irqreturn_t ibmveth_interrupt(int irq, void *dev_instance) 1154{ 1155 struct net_device *netdev = dev_instance; 1156 struct ibmveth_adapter *adapter = netdev_priv(netdev); 1157 unsigned long lpar_rc; 1158 1159 if (napi_schedule_prep(&adapter->napi)) { 1160 lpar_rc = h_vio_signal(adapter->vdev->unit_address, 1161 VIO_IRQ_DISABLE); 1162 BUG_ON(lpar_rc != H_SUCCESS); 1163 __napi_schedule(&adapter->napi); 1164 } 1165 return IRQ_HANDLED; 1166} 1167 1168static void ibmveth_set_multicast_list(struct net_device *netdev) 1169{ 1170 struct ibmveth_adapter *adapter = netdev_priv(netdev); 1171 unsigned long lpar_rc; 1172 1173 if ((netdev->flags & IFF_PROMISC) || 1174 (netdev_mc_count(netdev) > adapter->mcastFilterSize)) { 1175 lpar_rc = h_multicast_ctrl(adapter->vdev->unit_address, 1176 IbmVethMcastEnableRecv | 1177 IbmVethMcastDisableFiltering, 1178 0); 1179 if (lpar_rc != H_SUCCESS) { 1180 netdev_err(netdev, "h_multicast_ctrl rc=%ld when " 1181 "entering promisc mode\n", lpar_rc); 1182 } 1183 } else { 1184 struct netdev_hw_addr *ha; 1185 /* clear the filter table & disable filtering */ 1186 lpar_rc = h_multicast_ctrl(adapter->vdev->unit_address, 1187 IbmVethMcastEnableRecv | 1188 IbmVethMcastDisableFiltering | 1189 IbmVethMcastClearFilterTable, 1190 0); 1191 if (lpar_rc != H_SUCCESS) { 1192 netdev_err(netdev, "h_multicast_ctrl rc=%ld when " 1193 "attempting to clear filter table\n", 1194 lpar_rc); 1195 } 1196 /* add the addresses to the filter table */ 1197 netdev_for_each_mc_addr(ha, netdev) { 1198 /* add the multicast address to the filter table */ 1199 unsigned long mcast_addr = 0; 1200 memcpy(((char *)&mcast_addr)+2, ha->addr, 6); 1201 lpar_rc = h_multicast_ctrl(adapter->vdev->unit_address, 1202 IbmVethMcastAddFilter, 1203 mcast_addr); 1204 if (lpar_rc != H_SUCCESS) { 1205 netdev_err(netdev, "h_multicast_ctrl rc=%ld " 1206 "when adding an entry to the filter " 1207 "table\n", lpar_rc); 1208 } 1209 } 1210 1211 /* re-enable filtering */ 1212 lpar_rc = h_multicast_ctrl(adapter->vdev->unit_address, 1213 IbmVethMcastEnableFiltering, 1214 0); 1215 if (lpar_rc != H_SUCCESS) { 1216 netdev_err(netdev, "h_multicast_ctrl rc=%ld when " 1217 "enabling filtering\n", lpar_rc); 1218 } 1219 } 1220} 1221 1222static int ibmveth_change_mtu(struct net_device *dev, int new_mtu) 1223{ 1224 struct ibmveth_adapter *adapter = netdev_priv(dev); 1225 struct vio_dev *viodev = adapter->vdev; 1226 int new_mtu_oh = new_mtu + IBMVETH_BUFF_OH; 1227 int i, rc; 1228 int need_restart = 0; 1229 1230 if (new_mtu < IBMVETH_MIN_MTU) 1231 return -EINVAL; 1232 1233 for (i = 0; i < IBMVETH_NUM_BUFF_POOLS; i++) 1234 if (new_mtu_oh < adapter->rx_buff_pool[i].buff_size) 1235 break; 1236 1237 if (i == IBMVETH_NUM_BUFF_POOLS) 1238 return -EINVAL; 1239 1240 /* Deactivate all the buffer pools so that the next loop can activate 1241 only the buffer pools necessary to hold the new MTU */ 1242 if (netif_running(adapter->netdev)) { 1243 need_restart = 1; 1244 adapter->pool_config = 1; 1245 ibmveth_close(adapter->netdev); 1246 adapter->pool_config = 0; 1247 } 1248 1249 /* Look for an active buffer pool that can hold the new MTU */ 1250 for (i = 0; i < IBMVETH_NUM_BUFF_POOLS; i++) { 1251 adapter->rx_buff_pool[i].active = 1; 1252 1253 if (new_mtu_oh < adapter->rx_buff_pool[i].buff_size) { 1254 dev->mtu = new_mtu; 1255 vio_cmo_set_dev_desired(viodev, 1256 ibmveth_get_desired_dma 1257 (viodev)); 1258 if (need_restart) { 1259 return ibmveth_open(adapter->netdev); 1260 } 1261 return 0; 1262 } 1263 } 1264 1265 if (need_restart && (rc = ibmveth_open(adapter->netdev))) 1266 return rc; 1267 1268 return -EINVAL; 1269} 1270 1271#ifdef CONFIG_NET_POLL_CONTROLLER 1272static void ibmveth_poll_controller(struct net_device *dev) 1273{ 1274 ibmveth_replenish_task(netdev_priv(dev)); 1275 ibmveth_interrupt(dev->irq, dev); 1276} 1277#endif 1278 1279/** 1280 * ibmveth_get_desired_dma - Calculate IO memory desired by the driver 1281 * 1282 * @vdev: struct vio_dev for the device whose desired IO mem is to be returned 1283 * 1284 * Return value: 1285 * Number of bytes of IO data the driver will need to perform well. 1286 */ 1287static unsigned long ibmveth_get_desired_dma(struct vio_dev *vdev) 1288{ 1289 struct net_device *netdev = dev_get_drvdata(&vdev->dev); 1290 struct ibmveth_adapter *adapter; 1291 unsigned long ret; 1292 int i; 1293 int rxqentries = 1; 1294 1295 /* netdev inits at probe time along with the structures we need below*/ 1296 if (netdev == NULL) 1297 return IOMMU_PAGE_ALIGN(IBMVETH_IO_ENTITLEMENT_DEFAULT); 1298 1299 adapter = netdev_priv(netdev); 1300 1301 ret = IBMVETH_BUFF_LIST_SIZE + IBMVETH_FILT_LIST_SIZE; 1302 ret += IOMMU_PAGE_ALIGN(netdev->mtu); 1303 1304 for (i = 0; i < IBMVETH_NUM_BUFF_POOLS; i++) { 1305 /* add the size of the active receive buffers */ 1306 if (adapter->rx_buff_pool[i].active) 1307 ret += 1308 adapter->rx_buff_pool[i].size * 1309 IOMMU_PAGE_ALIGN(adapter->rx_buff_pool[i]. 1310 buff_size); 1311 rxqentries += adapter->rx_buff_pool[i].size; 1312 } 1313 /* add the size of the receive queue entries */ 1314 ret += IOMMU_PAGE_ALIGN(rxqentries * sizeof(struct ibmveth_rx_q_entry)); 1315 1316 return ret; 1317} 1318 1319static const struct net_device_ops ibmveth_netdev_ops = { 1320 .ndo_open = ibmveth_open, 1321 .ndo_stop = ibmveth_close, 1322 .ndo_start_xmit = ibmveth_start_xmit, 1323 .ndo_set_rx_mode = ibmveth_set_multicast_list, 1324 .ndo_do_ioctl = ibmveth_ioctl, 1325 .ndo_change_mtu = ibmveth_change_mtu, 1326 .ndo_fix_features = ibmveth_fix_features, 1327 .ndo_set_features = ibmveth_set_features, 1328 .ndo_validate_addr = eth_validate_addr, 1329 .ndo_set_mac_address = eth_mac_addr, 1330#ifdef CONFIG_NET_POLL_CONTROLLER 1331 .ndo_poll_controller = ibmveth_poll_controller, 1332#endif 1333}; 1334 1335static int __devinit ibmveth_probe(struct vio_dev *dev, 1336 const struct vio_device_id *id) 1337{ 1338 int rc, i; 1339 struct net_device *netdev; 1340 struct ibmveth_adapter *adapter; 1341 unsigned char *mac_addr_p; 1342 unsigned int *mcastFilterSize_p; 1343 1344 dev_dbg(&dev->dev, "entering ibmveth_probe for UA 0x%x\n", 1345 dev->unit_address); 1346 1347 mac_addr_p = (unsigned char *)vio_get_attribute(dev, VETH_MAC_ADDR, 1348 NULL); 1349 if (!mac_addr_p) { 1350 dev_err(&dev->dev, "Can't find VETH_MAC_ADDR attribute\n"); 1351 return -EINVAL; 1352 } 1353 1354 mcastFilterSize_p = (unsigned int *)vio_get_attribute(dev, 1355 VETH_MCAST_FILTER_SIZE, NULL); 1356 if (!mcastFilterSize_p) { 1357 dev_err(&dev->dev, "Can't find VETH_MCAST_FILTER_SIZE " 1358 "attribute\n"); 1359 return -EINVAL; 1360 } 1361 1362 netdev = alloc_etherdev(sizeof(struct ibmveth_adapter)); 1363 1364 if (!netdev) 1365 return -ENOMEM; 1366 1367 adapter = netdev_priv(netdev); 1368 dev_set_drvdata(&dev->dev, netdev); 1369 1370 adapter->vdev = dev; 1371 adapter->netdev = netdev; 1372 adapter->mcastFilterSize = *mcastFilterSize_p; 1373 adapter->pool_config = 0; 1374 1375 netif_napi_add(netdev, &adapter->napi, ibmveth_poll, 16); 1376 1377 /* 1378 * Some older boxes running PHYP non-natively have an OF that returns 1379 * a 8-byte local-mac-address field (and the first 2 bytes have to be 1380 * ignored) while newer boxes' OF return a 6-byte field. Note that 1381 * IEEE 1275 specifies that local-mac-address must be a 6-byte field. 1382 * The RPA doc specifies that the first byte must be 10b, so we'll 1383 * just look for it to solve this 8 vs. 6 byte field issue 1384 */ 1385 if ((*mac_addr_p & 0x3) != 0x02) 1386 mac_addr_p += 2; 1387 1388 adapter->mac_addr = 0; 1389 memcpy(&adapter->mac_addr, mac_addr_p, 6); 1390 1391 netdev->irq = dev->irq; 1392 netdev->netdev_ops = &ibmveth_netdev_ops; 1393 netdev->ethtool_ops = &netdev_ethtool_ops; 1394 SET_NETDEV_DEV(netdev, &dev->dev); 1395 netdev->hw_features = NETIF_F_SG | NETIF_F_RXCSUM | 1396 NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM; 1397 netdev->features |= netdev->hw_features; 1398 1399 memcpy(netdev->dev_addr, &adapter->mac_addr, netdev->addr_len); 1400 1401 for (i = 0; i < IBMVETH_NUM_BUFF_POOLS; i++) { 1402 struct kobject *kobj = &adapter->rx_buff_pool[i].kobj; 1403 int error; 1404 1405 ibmveth_init_buffer_pool(&adapter->rx_buff_pool[i], i, 1406 pool_count[i], pool_size[i], 1407 pool_active[i]); 1408 error = kobject_init_and_add(kobj, &ktype_veth_pool, 1409 &dev->dev.kobj, "pool%d", i); 1410 if (!error) 1411 kobject_uevent(kobj, KOBJ_ADD); 1412 } 1413 1414 netdev_dbg(netdev, "adapter @ 0x%p\n", adapter); 1415 1416 adapter->buffer_list_dma = DMA_ERROR_CODE; 1417 adapter->filter_list_dma = DMA_ERROR_CODE; 1418 adapter->rx_queue.queue_dma = DMA_ERROR_CODE; 1419 1420 netdev_dbg(netdev, "registering netdev...\n"); 1421 1422 ibmveth_set_features(netdev, netdev->features); 1423 1424 rc = register_netdev(netdev); 1425 1426 if (rc) { 1427 netdev_dbg(netdev, "failed to register netdev rc=%d\n", rc); 1428 free_netdev(netdev); 1429 return rc; 1430 } 1431 1432 netdev_dbg(netdev, "registered\n"); 1433 1434 return 0; 1435} 1436 1437static int __devexit ibmveth_remove(struct vio_dev *dev) 1438{ 1439 struct net_device *netdev = dev_get_drvdata(&dev->dev); 1440 struct ibmveth_adapter *adapter = netdev_priv(netdev); 1441 int i; 1442 1443 for (i = 0; i < IBMVETH_NUM_BUFF_POOLS; i++) 1444 kobject_put(&adapter->rx_buff_pool[i].kobj); 1445 1446 unregister_netdev(netdev); 1447 1448 free_netdev(netdev); 1449 dev_set_drvdata(&dev->dev, NULL); 1450 1451 return 0; 1452} 1453 1454static struct attribute veth_active_attr; 1455static struct attribute veth_num_attr; 1456static struct attribute veth_size_attr; 1457 1458static ssize_t veth_pool_show(struct kobject *kobj, 1459 struct attribute *attr, char *buf) 1460{ 1461 struct ibmveth_buff_pool *pool = container_of(kobj, 1462 struct ibmveth_buff_pool, 1463 kobj); 1464 1465 if (attr == &veth_active_attr) 1466 return sprintf(buf, "%d\n", pool->active); 1467 else if (attr == &veth_num_attr) 1468 return sprintf(buf, "%d\n", pool->size); 1469 else if (attr == &veth_size_attr) 1470 return sprintf(buf, "%d\n", pool->buff_size); 1471 return 0; 1472} 1473 1474static ssize_t veth_pool_store(struct kobject *kobj, struct attribute *attr, 1475 const char *buf, size_t count) 1476{ 1477 struct ibmveth_buff_pool *pool = container_of(kobj, 1478 struct ibmveth_buff_pool, 1479 kobj); 1480 struct net_device *netdev = dev_get_drvdata( 1481 container_of(kobj->parent, struct device, kobj)); 1482 struct ibmveth_adapter *adapter = netdev_priv(netdev); 1483 long value = simple_strtol(buf, NULL, 10); 1484 long rc; 1485 1486 if (attr == &veth_active_attr) { 1487 if (value && !pool->active) { 1488 if (netif_running(netdev)) { 1489 if (ibmveth_alloc_buffer_pool(pool)) { 1490 netdev_err(netdev, 1491 "unable to alloc pool\n"); 1492 return -ENOMEM; 1493 } 1494 pool->active = 1; 1495 adapter->pool_config = 1; 1496 ibmveth_close(netdev); 1497 adapter->pool_config = 0; 1498 if ((rc = ibmveth_open(netdev))) 1499 return rc; 1500 } else { 1501 pool->active = 1; 1502 } 1503 } else if (!value && pool->active) { 1504 int mtu = netdev->mtu + IBMVETH_BUFF_OH; 1505 int i; 1506 /* Make sure there is a buffer pool with buffers that 1507 can hold a packet of the size of the MTU */ 1508 for (i = 0; i < IBMVETH_NUM_BUFF_POOLS; i++) { 1509 if (pool == &adapter->rx_buff_pool[i]) 1510 continue; 1511 if (!adapter->rx_buff_pool[i].active) 1512 continue; 1513 if (mtu <= adapter->rx_buff_pool[i].buff_size) 1514 break; 1515 } 1516 1517 if (i == IBMVETH_NUM_BUFF_POOLS) { 1518 netdev_err(netdev, "no active pool >= MTU\n"); 1519 return -EPERM; 1520 } 1521 1522 if (netif_running(netdev)) { 1523 adapter->pool_config = 1; 1524 ibmveth_close(netdev); 1525 pool->active = 0; 1526 adapter->pool_config = 0; 1527 if ((rc = ibmveth_open(netdev))) 1528 return rc; 1529 } 1530 pool->active = 0; 1531 } 1532 } else if (attr == &veth_num_attr) { 1533 if (value <= 0 || value > IBMVETH_MAX_POOL_COUNT) { 1534 return -EINVAL; 1535 } else { 1536 if (netif_running(netdev)) { 1537 adapter->pool_config = 1; 1538 ibmveth_close(netdev); 1539 adapter->pool_config = 0; 1540 pool->size = value; 1541 if ((rc = ibmveth_open(netdev))) 1542 return rc; 1543 } else { 1544 pool->size = value; 1545 } 1546 } 1547 } else if (attr == &veth_size_attr) { 1548 if (value <= IBMVETH_BUFF_OH || value > IBMVETH_MAX_BUF_SIZE) { 1549 return -EINVAL; 1550 } else { 1551 if (netif_running(netdev)) { 1552 adapter->pool_config = 1; 1553 ibmveth_close(netdev); 1554 adapter->pool_config = 0; 1555 pool->buff_size = value; 1556 if ((rc = ibmveth_open(netdev))) 1557 return rc; 1558 } else { 1559 pool->buff_size = value; 1560 } 1561 } 1562 } 1563 1564 /* kick the interrupt handler to allocate/deallocate pools */ 1565 ibmveth_interrupt(netdev->irq, netdev); 1566 return count; 1567} 1568 1569 1570#define ATTR(_name, _mode) \ 1571 struct attribute veth_##_name##_attr = { \ 1572 .name = __stringify(_name), .mode = _mode, \ 1573 }; 1574 1575static ATTR(active, 0644); 1576static ATTR(num, 0644); 1577static ATTR(size, 0644); 1578 1579static struct attribute *veth_pool_attrs[] = { 1580 &veth_active_attr, 1581 &veth_num_attr, 1582 &veth_size_attr, 1583 NULL, 1584}; 1585 1586static const struct sysfs_ops veth_pool_ops = { 1587 .show = veth_pool_show, 1588 .store = veth_pool_store, 1589}; 1590 1591static struct kobj_type ktype_veth_pool = { 1592 .release = NULL, 1593 .sysfs_ops = &veth_pool_ops, 1594 .default_attrs = veth_pool_attrs, 1595}; 1596 1597static int ibmveth_resume(struct device *dev) 1598{ 1599 struct net_device *netdev = dev_get_drvdata(dev); 1600 ibmveth_interrupt(netdev->irq, netdev); 1601 return 0; 1602} 1603 1604static struct vio_device_id ibmveth_device_table[] __devinitdata = { 1605 { "network", "IBM,l-lan"}, 1606 { "", "" } 1607}; 1608MODULE_DEVICE_TABLE(vio, ibmveth_device_table); 1609 1610static struct dev_pm_ops ibmveth_pm_ops = { 1611 .resume = ibmveth_resume 1612}; 1613 1614static struct vio_driver ibmveth_driver = { 1615 .id_table = ibmveth_device_table, 1616 .probe = ibmveth_probe, 1617 .remove = ibmveth_remove, 1618 .get_desired_dma = ibmveth_get_desired_dma, 1619 .name = ibmveth_driver_name, 1620 .pm = &ibmveth_pm_ops, 1621}; 1622 1623static int __init ibmveth_module_init(void) 1624{ 1625 printk(KERN_DEBUG "%s: %s %s\n", ibmveth_driver_name, 1626 ibmveth_driver_string, ibmveth_driver_version); 1627 1628 return vio_register_driver(&ibmveth_driver); 1629} 1630 1631static void __exit ibmveth_module_exit(void) 1632{ 1633 vio_unregister_driver(&ibmveth_driver); 1634} 1635 1636module_init(ibmveth_module_init); 1637module_exit(ibmveth_module_exit); 1638