1/* File veth.c created by Kyle A. Lucke on Mon Aug 7 2000. */ 2/* 3 * IBM eServer iSeries Virtual Ethernet Device Driver 4 * Copyright (C) 2001 Kyle A. Lucke (klucke@us.ibm.com), IBM Corp. 5 * Substantially cleaned up by: 6 * Copyright (C) 2003 David Gibson <dwg@au1.ibm.com>, IBM Corporation. 7 * Copyright (C) 2004-2005 Michael Ellerman, IBM Corporation. 8 * 9 * This program is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU General Public License as 11 * published by the Free Software Foundation; either version 2 of the 12 * License, or (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, but 15 * WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 * General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 22 * USA 23 * 24 * 25 * This module implements the virtual ethernet device for iSeries LPAR 26 * Linux. It uses hypervisor message passing to implement an 27 * ethernet-like network device communicating between partitions on 28 * the iSeries. 29 * 30 * The iSeries LPAR hypervisor currently allows for up to 16 different 31 * virtual ethernets. These are all dynamically configurable on 32 * OS/400 partitions, but dynamic configuration is not supported under 33 * Linux yet. An ethXX network device will be created for each 34 * virtual ethernet this partition is connected to. 35 * 36 * - This driver is responsible for routing packets to and from other 37 * partitions. The MAC addresses used by the virtual ethernets 38 * contains meaning and must not be modified. 39 * 40 * - Having 2 virtual ethernets to the same remote partition DOES NOT 41 * double the available bandwidth. The 2 devices will share the 42 * available hypervisor bandwidth. 43 * 44 * - If you send a packet to your own mac address, it will just be 45 * dropped, you won't get it on the receive side. 46 * 47 * - Multicast is implemented by sending the frame frame to every 48 * other partition. It is the responsibility of the receiving 49 * partition to filter the addresses desired. 50 * 51 * Tunable parameters: 52 * 53 * VETH_NUMBUFFERS: This compile time option defaults to 120. It 54 * controls how much memory Linux will allocate per remote partition 55 * it is communicating with. It can be thought of as the maximum 56 * number of packets outstanding to a remote partition at a time. 57 */ 58 59#include <linux/module.h> 60#include <linux/types.h> 61#include <linux/errno.h> 62#include <linux/ioport.h> 63#include <linux/kernel.h> 64#include <linux/netdevice.h> 65#include <linux/etherdevice.h> 66#include <linux/skbuff.h> 67#include <linux/init.h> 68#include <linux/delay.h> 69#include <linux/mm.h> 70#include <linux/ethtool.h> 71#include <linux/if_ether.h> 72 73#include <asm/abs_addr.h> 74#include <asm/iseries/mf.h> 75#include <asm/uaccess.h> 76#include <asm/firmware.h> 77#include <asm/iseries/hv_lp_config.h> 78#include <asm/iseries/hv_types.h> 79#include <asm/iseries/hv_lp_event.h> 80#include <asm/iommu.h> 81#include <asm/vio.h> 82 83#undef DEBUG 84 85MODULE_AUTHOR("Kyle Lucke <klucke@us.ibm.com>"); 86MODULE_DESCRIPTION("iSeries Virtual ethernet driver"); 87MODULE_LICENSE("GPL"); 88 89#define VETH_EVENT_CAP (0) 90#define VETH_EVENT_FRAMES (1) 91#define VETH_EVENT_MONITOR (2) 92#define VETH_EVENT_FRAMES_ACK (3) 93 94#define VETH_MAX_ACKS_PER_MSG (20) 95#define VETH_MAX_FRAMES_PER_MSG (6) 96 97struct veth_frames_data { 98 u32 addr[VETH_MAX_FRAMES_PER_MSG]; 99 u16 len[VETH_MAX_FRAMES_PER_MSG]; 100 u32 eofmask; 101}; 102#define VETH_EOF_SHIFT (32-VETH_MAX_FRAMES_PER_MSG) 103 104struct veth_frames_ack_data { 105 u16 token[VETH_MAX_ACKS_PER_MSG]; 106}; 107 108struct veth_cap_data { 109 u8 caps_version; 110 u8 rsvd1; 111 u16 num_buffers; 112 u16 ack_threshold; 113 u16 rsvd2; 114 u32 ack_timeout; 115 u32 rsvd3; 116 u64 rsvd4[3]; 117}; 118 119struct veth_lpevent { 120 struct HvLpEvent base_event; 121 union { 122 struct veth_cap_data caps_data; 123 struct veth_frames_data frames_data; 124 struct veth_frames_ack_data frames_ack_data; 125 } u; 126 127}; 128 129#define DRV_NAME "iseries_veth" 130#define DRV_VERSION "2.0" 131 132#define VETH_NUMBUFFERS (120) 133#define VETH_ACKTIMEOUT (1000000) /* microseconds */ 134#define VETH_MAX_MCAST (12) 135 136#define VETH_MAX_MTU (9000) 137 138#if VETH_NUMBUFFERS < 10 139#define ACK_THRESHOLD (1) 140#elif VETH_NUMBUFFERS < 20 141#define ACK_THRESHOLD (4) 142#elif VETH_NUMBUFFERS < 40 143#define ACK_THRESHOLD (10) 144#else 145#define ACK_THRESHOLD (20) 146#endif 147 148#define VETH_STATE_SHUTDOWN (0x0001) 149#define VETH_STATE_OPEN (0x0002) 150#define VETH_STATE_RESET (0x0004) 151#define VETH_STATE_SENTMON (0x0008) 152#define VETH_STATE_SENTCAPS (0x0010) 153#define VETH_STATE_GOTCAPACK (0x0020) 154#define VETH_STATE_GOTCAPS (0x0040) 155#define VETH_STATE_SENTCAPACK (0x0080) 156#define VETH_STATE_READY (0x0100) 157 158struct veth_msg { 159 struct veth_msg *next; 160 struct veth_frames_data data; 161 int token; 162 int in_use; 163 struct sk_buff *skb; 164 struct device *dev; 165}; 166 167struct veth_lpar_connection { 168 HvLpIndex remote_lp; 169 struct delayed_work statemachine_wq; 170 struct veth_msg *msgs; 171 int num_events; 172 struct veth_cap_data local_caps; 173 174 struct kobject kobject; 175 struct timer_list ack_timer; 176 177 struct timer_list reset_timer; 178 unsigned int reset_timeout; 179 unsigned long last_contact; 180 int outstanding_tx; 181 182 spinlock_t lock; 183 unsigned long state; 184 HvLpInstanceId src_inst; 185 HvLpInstanceId dst_inst; 186 struct veth_lpevent cap_event, cap_ack_event; 187 u16 pending_acks[VETH_MAX_ACKS_PER_MSG]; 188 u32 num_pending_acks; 189 190 int num_ack_events; 191 struct veth_cap_data remote_caps; 192 u32 ack_timeout; 193 194 struct veth_msg *msg_stack_head; 195}; 196 197struct veth_port { 198 struct device *dev; 199 struct net_device_stats stats; 200 u64 mac_addr; 201 HvLpIndexMap lpar_map; 202 203 /* queue_lock protects the stopped_map and dev's queue. */ 204 spinlock_t queue_lock; 205 HvLpIndexMap stopped_map; 206 207 /* mcast_gate protects promiscuous, num_mcast & mcast_addr. */ 208 rwlock_t mcast_gate; 209 int promiscuous; 210 int num_mcast; 211 u64 mcast_addr[VETH_MAX_MCAST]; 212 213 struct kobject kobject; 214}; 215 216static HvLpIndex this_lp; 217static struct veth_lpar_connection *veth_cnx[HVMAXARCHITECTEDLPS]; /* = 0 */ 218static struct net_device *veth_dev[HVMAXARCHITECTEDVIRTUALLANS]; /* = 0 */ 219 220static int veth_start_xmit(struct sk_buff *skb, struct net_device *dev); 221static void veth_recycle_msg(struct veth_lpar_connection *, struct veth_msg *); 222static void veth_wake_queues(struct veth_lpar_connection *cnx); 223static void veth_stop_queues(struct veth_lpar_connection *cnx); 224static void veth_receive(struct veth_lpar_connection *, struct veth_lpevent *); 225static void veth_release_connection(struct kobject *kobject); 226static void veth_timed_ack(unsigned long ptr); 227static void veth_timed_reset(unsigned long ptr); 228 229/* 230 * Utility functions 231 */ 232 233#define veth_info(fmt, args...) \ 234 printk(KERN_INFO DRV_NAME ": " fmt, ## args) 235 236#define veth_error(fmt, args...) \ 237 printk(KERN_ERR DRV_NAME ": Error: " fmt, ## args) 238 239#ifdef DEBUG 240#define veth_debug(fmt, args...) \ 241 printk(KERN_DEBUG DRV_NAME ": " fmt, ## args) 242#else 243#define veth_debug(fmt, args...) do {} while (0) 244#endif 245 246/* You must hold the connection's lock when you call this function. */ 247static inline void veth_stack_push(struct veth_lpar_connection *cnx, 248 struct veth_msg *msg) 249{ 250 msg->next = cnx->msg_stack_head; 251 cnx->msg_stack_head = msg; 252} 253 254/* You must hold the connection's lock when you call this function. */ 255static inline struct veth_msg *veth_stack_pop(struct veth_lpar_connection *cnx) 256{ 257 struct veth_msg *msg; 258 259 msg = cnx->msg_stack_head; 260 if (msg) 261 cnx->msg_stack_head = cnx->msg_stack_head->next; 262 263 return msg; 264} 265 266/* You must hold the connection's lock when you call this function. */ 267static inline int veth_stack_is_empty(struct veth_lpar_connection *cnx) 268{ 269 return cnx->msg_stack_head == NULL; 270} 271 272static inline HvLpEvent_Rc 273veth_signalevent(struct veth_lpar_connection *cnx, u16 subtype, 274 HvLpEvent_AckInd ackind, HvLpEvent_AckType acktype, 275 u64 token, 276 u64 data1, u64 data2, u64 data3, u64 data4, u64 data5) 277{ 278 return HvCallEvent_signalLpEventFast(cnx->remote_lp, 279 HvLpEvent_Type_VirtualLan, 280 subtype, ackind, acktype, 281 cnx->src_inst, 282 cnx->dst_inst, 283 token, data1, data2, data3, 284 data4, data5); 285} 286 287static inline HvLpEvent_Rc veth_signaldata(struct veth_lpar_connection *cnx, 288 u16 subtype, u64 token, void *data) 289{ 290 u64 *p = (u64 *) data; 291 292 return veth_signalevent(cnx, subtype, HvLpEvent_AckInd_NoAck, 293 HvLpEvent_AckType_ImmediateAck, 294 token, p[0], p[1], p[2], p[3], p[4]); 295} 296 297struct veth_allocation { 298 struct completion c; 299 int num; 300}; 301 302static void veth_complete_allocation(void *parm, int number) 303{ 304 struct veth_allocation *vc = (struct veth_allocation *)parm; 305 306 vc->num = number; 307 complete(&vc->c); 308} 309 310static int veth_allocate_events(HvLpIndex rlp, int number) 311{ 312 struct veth_allocation vc = { COMPLETION_INITIALIZER(vc.c), 0 }; 313 314 mf_allocate_lp_events(rlp, HvLpEvent_Type_VirtualLan, 315 sizeof(struct veth_lpevent), number, 316 &veth_complete_allocation, &vc); 317 wait_for_completion(&vc.c); 318 319 return vc.num; 320} 321 322/* 323 * sysfs support 324 */ 325 326struct veth_cnx_attribute { 327 struct attribute attr; 328 ssize_t (*show)(struct veth_lpar_connection *, char *buf); 329 ssize_t (*store)(struct veth_lpar_connection *, const char *buf); 330}; 331 332static ssize_t veth_cnx_attribute_show(struct kobject *kobj, 333 struct attribute *attr, char *buf) 334{ 335 struct veth_cnx_attribute *cnx_attr; 336 struct veth_lpar_connection *cnx; 337 338 cnx_attr = container_of(attr, struct veth_cnx_attribute, attr); 339 cnx = container_of(kobj, struct veth_lpar_connection, kobject); 340 341 if (!cnx_attr->show) 342 return -EIO; 343 344 return cnx_attr->show(cnx, buf); 345} 346 347#define CUSTOM_CNX_ATTR(_name, _format, _expression) \ 348static ssize_t _name##_show(struct veth_lpar_connection *cnx, char *buf)\ 349{ \ 350 return sprintf(buf, _format, _expression); \ 351} \ 352struct veth_cnx_attribute veth_cnx_attr_##_name = __ATTR_RO(_name) 353 354#define SIMPLE_CNX_ATTR(_name) \ 355 CUSTOM_CNX_ATTR(_name, "%lu\n", (unsigned long)cnx->_name) 356 357SIMPLE_CNX_ATTR(outstanding_tx); 358SIMPLE_CNX_ATTR(remote_lp); 359SIMPLE_CNX_ATTR(num_events); 360SIMPLE_CNX_ATTR(src_inst); 361SIMPLE_CNX_ATTR(dst_inst); 362SIMPLE_CNX_ATTR(num_pending_acks); 363SIMPLE_CNX_ATTR(num_ack_events); 364CUSTOM_CNX_ATTR(ack_timeout, "%d\n", jiffies_to_msecs(cnx->ack_timeout)); 365CUSTOM_CNX_ATTR(reset_timeout, "%d\n", jiffies_to_msecs(cnx->reset_timeout)); 366CUSTOM_CNX_ATTR(state, "0x%.4lX\n", cnx->state); 367CUSTOM_CNX_ATTR(last_contact, "%d\n", cnx->last_contact ? 368 jiffies_to_msecs(jiffies - cnx->last_contact) : 0); 369 370#define GET_CNX_ATTR(_name) (&veth_cnx_attr_##_name.attr) 371 372static struct attribute *veth_cnx_default_attrs[] = { 373 GET_CNX_ATTR(outstanding_tx), 374 GET_CNX_ATTR(remote_lp), 375 GET_CNX_ATTR(num_events), 376 GET_CNX_ATTR(reset_timeout), 377 GET_CNX_ATTR(last_contact), 378 GET_CNX_ATTR(state), 379 GET_CNX_ATTR(src_inst), 380 GET_CNX_ATTR(dst_inst), 381 GET_CNX_ATTR(num_pending_acks), 382 GET_CNX_ATTR(num_ack_events), 383 GET_CNX_ATTR(ack_timeout), 384 NULL 385}; 386 387static struct sysfs_ops veth_cnx_sysfs_ops = { 388 .show = veth_cnx_attribute_show 389}; 390 391static struct kobj_type veth_lpar_connection_ktype = { 392 .release = veth_release_connection, 393 .sysfs_ops = &veth_cnx_sysfs_ops, 394 .default_attrs = veth_cnx_default_attrs 395}; 396 397struct veth_port_attribute { 398 struct attribute attr; 399 ssize_t (*show)(struct veth_port *, char *buf); 400 ssize_t (*store)(struct veth_port *, const char *buf); 401}; 402 403static ssize_t veth_port_attribute_show(struct kobject *kobj, 404 struct attribute *attr, char *buf) 405{ 406 struct veth_port_attribute *port_attr; 407 struct veth_port *port; 408 409 port_attr = container_of(attr, struct veth_port_attribute, attr); 410 port = container_of(kobj, struct veth_port, kobject); 411 412 if (!port_attr->show) 413 return -EIO; 414 415 return port_attr->show(port, buf); 416} 417 418#define CUSTOM_PORT_ATTR(_name, _format, _expression) \ 419static ssize_t _name##_show(struct veth_port *port, char *buf) \ 420{ \ 421 return sprintf(buf, _format, _expression); \ 422} \ 423struct veth_port_attribute veth_port_attr_##_name = __ATTR_RO(_name) 424 425#define SIMPLE_PORT_ATTR(_name) \ 426 CUSTOM_PORT_ATTR(_name, "%lu\n", (unsigned long)port->_name) 427 428SIMPLE_PORT_ATTR(promiscuous); 429SIMPLE_PORT_ATTR(num_mcast); 430CUSTOM_PORT_ATTR(lpar_map, "0x%X\n", port->lpar_map); 431CUSTOM_PORT_ATTR(stopped_map, "0x%X\n", port->stopped_map); 432CUSTOM_PORT_ATTR(mac_addr, "0x%lX\n", port->mac_addr); 433 434#define GET_PORT_ATTR(_name) (&veth_port_attr_##_name.attr) 435static struct attribute *veth_port_default_attrs[] = { 436 GET_PORT_ATTR(mac_addr), 437 GET_PORT_ATTR(lpar_map), 438 GET_PORT_ATTR(stopped_map), 439 GET_PORT_ATTR(promiscuous), 440 GET_PORT_ATTR(num_mcast), 441 NULL 442}; 443 444static struct sysfs_ops veth_port_sysfs_ops = { 445 .show = veth_port_attribute_show 446}; 447 448static struct kobj_type veth_port_ktype = { 449 .sysfs_ops = &veth_port_sysfs_ops, 450 .default_attrs = veth_port_default_attrs 451}; 452 453/* 454 * LPAR connection code 455 */ 456 457static inline void veth_kick_statemachine(struct veth_lpar_connection *cnx) 458{ 459 schedule_delayed_work(&cnx->statemachine_wq, 0); 460} 461 462static void veth_take_cap(struct veth_lpar_connection *cnx, 463 struct veth_lpevent *event) 464{ 465 unsigned long flags; 466 467 spin_lock_irqsave(&cnx->lock, flags); 468 /* Receiving caps may mean the other end has just come up, so 469 * we need to reload the instance ID of the far end */ 470 cnx->dst_inst = 471 HvCallEvent_getTargetLpInstanceId(cnx->remote_lp, 472 HvLpEvent_Type_VirtualLan); 473 474 if (cnx->state & VETH_STATE_GOTCAPS) { 475 veth_error("Received a second capabilities from LPAR %d.\n", 476 cnx->remote_lp); 477 event->base_event.xRc = HvLpEvent_Rc_BufferNotAvailable; 478 HvCallEvent_ackLpEvent((struct HvLpEvent *) event); 479 } else { 480 memcpy(&cnx->cap_event, event, sizeof(cnx->cap_event)); 481 cnx->state |= VETH_STATE_GOTCAPS; 482 veth_kick_statemachine(cnx); 483 } 484 spin_unlock_irqrestore(&cnx->lock, flags); 485} 486 487static void veth_take_cap_ack(struct veth_lpar_connection *cnx, 488 struct veth_lpevent *event) 489{ 490 unsigned long flags; 491 492 spin_lock_irqsave(&cnx->lock, flags); 493 if (cnx->state & VETH_STATE_GOTCAPACK) { 494 veth_error("Received a second capabilities ack from LPAR %d.\n", 495 cnx->remote_lp); 496 } else { 497 memcpy(&cnx->cap_ack_event, event, 498 sizeof(&cnx->cap_ack_event)); 499 cnx->state |= VETH_STATE_GOTCAPACK; 500 veth_kick_statemachine(cnx); 501 } 502 spin_unlock_irqrestore(&cnx->lock, flags); 503} 504 505static void veth_take_monitor_ack(struct veth_lpar_connection *cnx, 506 struct veth_lpevent *event) 507{ 508 unsigned long flags; 509 510 spin_lock_irqsave(&cnx->lock, flags); 511 veth_debug("cnx %d: lost connection.\n", cnx->remote_lp); 512 513 /* Avoid kicking the statemachine once we're shutdown. 514 * It's unnecessary and it could break veth_stop_connection(). */ 515 516 if (! (cnx->state & VETH_STATE_SHUTDOWN)) { 517 cnx->state |= VETH_STATE_RESET; 518 veth_kick_statemachine(cnx); 519 } 520 spin_unlock_irqrestore(&cnx->lock, flags); 521} 522 523static void veth_handle_ack(struct veth_lpevent *event) 524{ 525 HvLpIndex rlp = event->base_event.xTargetLp; 526 struct veth_lpar_connection *cnx = veth_cnx[rlp]; 527 528 BUG_ON(! cnx); 529 530 switch (event->base_event.xSubtype) { 531 case VETH_EVENT_CAP: 532 veth_take_cap_ack(cnx, event); 533 break; 534 case VETH_EVENT_MONITOR: 535 veth_take_monitor_ack(cnx, event); 536 break; 537 default: 538 veth_error("Unknown ack type %d from LPAR %d.\n", 539 event->base_event.xSubtype, rlp); 540 }; 541} 542 543static void veth_handle_int(struct veth_lpevent *event) 544{ 545 HvLpIndex rlp = event->base_event.xSourceLp; 546 struct veth_lpar_connection *cnx = veth_cnx[rlp]; 547 unsigned long flags; 548 int i, acked = 0; 549 550 BUG_ON(! cnx); 551 552 switch (event->base_event.xSubtype) { 553 case VETH_EVENT_CAP: 554 veth_take_cap(cnx, event); 555 break; 556 case VETH_EVENT_MONITOR: 557 /* do nothing... this'll hang out here til we're dead, 558 * and the hypervisor will return it for us. */ 559 break; 560 case VETH_EVENT_FRAMES_ACK: 561 spin_lock_irqsave(&cnx->lock, flags); 562 563 for (i = 0; i < VETH_MAX_ACKS_PER_MSG; ++i) { 564 u16 msgnum = event->u.frames_ack_data.token[i]; 565 566 if (msgnum < VETH_NUMBUFFERS) { 567 veth_recycle_msg(cnx, cnx->msgs + msgnum); 568 cnx->outstanding_tx--; 569 acked++; 570 } 571 } 572 573 if (acked > 0) { 574 cnx->last_contact = jiffies; 575 veth_wake_queues(cnx); 576 } 577 578 spin_unlock_irqrestore(&cnx->lock, flags); 579 break; 580 case VETH_EVENT_FRAMES: 581 veth_receive(cnx, event); 582 break; 583 default: 584 veth_error("Unknown interrupt type %d from LPAR %d.\n", 585 event->base_event.xSubtype, rlp); 586 }; 587} 588 589static void veth_handle_event(struct HvLpEvent *event) 590{ 591 struct veth_lpevent *veth_event = (struct veth_lpevent *)event; 592 593 if (hvlpevent_is_ack(event)) 594 veth_handle_ack(veth_event); 595 else 596 veth_handle_int(veth_event); 597} 598 599static int veth_process_caps(struct veth_lpar_connection *cnx) 600{ 601 struct veth_cap_data *remote_caps = &cnx->remote_caps; 602 int num_acks_needed; 603 604 /* Convert timer to jiffies */ 605 cnx->ack_timeout = remote_caps->ack_timeout * HZ / 1000000; 606 607 if ( (remote_caps->num_buffers == 0) 608 || (remote_caps->ack_threshold > VETH_MAX_ACKS_PER_MSG) 609 || (remote_caps->ack_threshold == 0) 610 || (cnx->ack_timeout == 0) ) { 611 veth_error("Received incompatible capabilities from LPAR %d.\n", 612 cnx->remote_lp); 613 return HvLpEvent_Rc_InvalidSubtypeData; 614 } 615 616 num_acks_needed = (remote_caps->num_buffers 617 / remote_caps->ack_threshold) + 1; 618 619 if (cnx->num_ack_events < num_acks_needed) { 620 int num; 621 622 num = veth_allocate_events(cnx->remote_lp, 623 num_acks_needed-cnx->num_ack_events); 624 if (num > 0) 625 cnx->num_ack_events += num; 626 627 if (cnx->num_ack_events < num_acks_needed) { 628 veth_error("Couldn't allocate enough ack events " 629 "for LPAR %d.\n", cnx->remote_lp); 630 631 return HvLpEvent_Rc_BufferNotAvailable; 632 } 633 } 634 635 636 return HvLpEvent_Rc_Good; 637} 638 639static void veth_statemachine(struct work_struct *work) 640{ 641 struct veth_lpar_connection *cnx = 642 container_of(work, struct veth_lpar_connection, 643 statemachine_wq.work); 644 int rlp = cnx->remote_lp; 645 int rc; 646 647 spin_lock_irq(&cnx->lock); 648 649 restart: 650 if (cnx->state & VETH_STATE_RESET) { 651 if (cnx->state & VETH_STATE_OPEN) 652 HvCallEvent_closeLpEventPath(cnx->remote_lp, 653 HvLpEvent_Type_VirtualLan); 654 655 /* 656 * Reset ack data. This prevents the ack_timer actually 657 * doing anything, even if it runs one more time when 658 * we drop the lock below. 659 */ 660 memset(&cnx->pending_acks, 0xff, sizeof (cnx->pending_acks)); 661 cnx->num_pending_acks = 0; 662 663 cnx->state &= ~(VETH_STATE_RESET | VETH_STATE_SENTMON 664 | VETH_STATE_OPEN | VETH_STATE_SENTCAPS 665 | VETH_STATE_GOTCAPACK | VETH_STATE_GOTCAPS 666 | VETH_STATE_SENTCAPACK | VETH_STATE_READY); 667 668 /* Clean up any leftover messages */ 669 if (cnx->msgs) { 670 int i; 671 for (i = 0; i < VETH_NUMBUFFERS; ++i) 672 veth_recycle_msg(cnx, cnx->msgs + i); 673 } 674 675 cnx->outstanding_tx = 0; 676 veth_wake_queues(cnx); 677 678 /* Drop the lock so we can do stuff that might sleep or 679 * take other locks. */ 680 spin_unlock_irq(&cnx->lock); 681 682 del_timer_sync(&cnx->ack_timer); 683 del_timer_sync(&cnx->reset_timer); 684 685 spin_lock_irq(&cnx->lock); 686 687 if (cnx->state & VETH_STATE_RESET) 688 goto restart; 689 690 /* Hack, wait for the other end to reset itself. */ 691 if (! (cnx->state & VETH_STATE_SHUTDOWN)) { 692 schedule_delayed_work(&cnx->statemachine_wq, 5 * HZ); 693 goto out; 694 } 695 } 696 697 if (cnx->state & VETH_STATE_SHUTDOWN) 698 /* It's all over, do nothing */ 699 goto out; 700 701 if ( !(cnx->state & VETH_STATE_OPEN) ) { 702 if (! cnx->msgs || (cnx->num_events < (2 + VETH_NUMBUFFERS)) ) 703 goto cant_cope; 704 705 HvCallEvent_openLpEventPath(rlp, HvLpEvent_Type_VirtualLan); 706 cnx->src_inst = 707 HvCallEvent_getSourceLpInstanceId(rlp, 708 HvLpEvent_Type_VirtualLan); 709 cnx->dst_inst = 710 HvCallEvent_getTargetLpInstanceId(rlp, 711 HvLpEvent_Type_VirtualLan); 712 cnx->state |= VETH_STATE_OPEN; 713 } 714 715 if ( (cnx->state & VETH_STATE_OPEN) 716 && !(cnx->state & VETH_STATE_SENTMON) ) { 717 rc = veth_signalevent(cnx, VETH_EVENT_MONITOR, 718 HvLpEvent_AckInd_DoAck, 719 HvLpEvent_AckType_DeferredAck, 720 0, 0, 0, 0, 0, 0); 721 722 if (rc == HvLpEvent_Rc_Good) { 723 cnx->state |= VETH_STATE_SENTMON; 724 } else { 725 if ( (rc != HvLpEvent_Rc_PartitionDead) 726 && (rc != HvLpEvent_Rc_PathClosed) ) 727 veth_error("Error sending monitor to LPAR %d, " 728 "rc = %d\n", rlp, rc); 729 730 /* Oh well, hope we get a cap from the other 731 * end and do better when that kicks us */ 732 goto out; 733 } 734 } 735 736 if ( (cnx->state & VETH_STATE_OPEN) 737 && !(cnx->state & VETH_STATE_SENTCAPS)) { 738 u64 *rawcap = (u64 *)&cnx->local_caps; 739 740 rc = veth_signalevent(cnx, VETH_EVENT_CAP, 741 HvLpEvent_AckInd_DoAck, 742 HvLpEvent_AckType_ImmediateAck, 743 0, rawcap[0], rawcap[1], rawcap[2], 744 rawcap[3], rawcap[4]); 745 746 if (rc == HvLpEvent_Rc_Good) { 747 cnx->state |= VETH_STATE_SENTCAPS; 748 } else { 749 if ( (rc != HvLpEvent_Rc_PartitionDead) 750 && (rc != HvLpEvent_Rc_PathClosed) ) 751 veth_error("Error sending caps to LPAR %d, " 752 "rc = %d\n", rlp, rc); 753 754 /* Oh well, hope we get a cap from the other 755 * end and do better when that kicks us */ 756 goto out; 757 } 758 } 759 760 if ((cnx->state & VETH_STATE_GOTCAPS) 761 && !(cnx->state & VETH_STATE_SENTCAPACK)) { 762 struct veth_cap_data *remote_caps = &cnx->remote_caps; 763 764 memcpy(remote_caps, &cnx->cap_event.u.caps_data, 765 sizeof(*remote_caps)); 766 767 spin_unlock_irq(&cnx->lock); 768 rc = veth_process_caps(cnx); 769 spin_lock_irq(&cnx->lock); 770 771 /* We dropped the lock, so recheck for anything which 772 * might mess us up */ 773 if (cnx->state & (VETH_STATE_RESET|VETH_STATE_SHUTDOWN)) 774 goto restart; 775 776 cnx->cap_event.base_event.xRc = rc; 777 HvCallEvent_ackLpEvent((struct HvLpEvent *)&cnx->cap_event); 778 if (rc == HvLpEvent_Rc_Good) 779 cnx->state |= VETH_STATE_SENTCAPACK; 780 else 781 goto cant_cope; 782 } 783 784 if ((cnx->state & VETH_STATE_GOTCAPACK) 785 && (cnx->state & VETH_STATE_GOTCAPS) 786 && !(cnx->state & VETH_STATE_READY)) { 787 if (cnx->cap_ack_event.base_event.xRc == HvLpEvent_Rc_Good) { 788 /* Start the ACK timer */ 789 cnx->ack_timer.expires = jiffies + cnx->ack_timeout; 790 add_timer(&cnx->ack_timer); 791 cnx->state |= VETH_STATE_READY; 792 } else { 793 veth_error("Caps rejected by LPAR %d, rc = %d\n", 794 rlp, cnx->cap_ack_event.base_event.xRc); 795 goto cant_cope; 796 } 797 } 798 799 out: 800 spin_unlock_irq(&cnx->lock); 801 return; 802 803 cant_cope: 804 veth_error("Unrecoverable error on connection to LPAR %d, shutting down" 805 " (state = 0x%04lx)\n", rlp, cnx->state); 806 cnx->state |= VETH_STATE_SHUTDOWN; 807 spin_unlock_irq(&cnx->lock); 808} 809 810static int veth_init_connection(u8 rlp) 811{ 812 struct veth_lpar_connection *cnx; 813 struct veth_msg *msgs; 814 int i, rc; 815 816 if ( (rlp == this_lp) 817 || ! HvLpConfig_doLpsCommunicateOnVirtualLan(this_lp, rlp) ) 818 return 0; 819 820 cnx = kmalloc(sizeof(*cnx), GFP_KERNEL); 821 if (! cnx) 822 return -ENOMEM; 823 memset(cnx, 0, sizeof(*cnx)); 824 825 cnx->remote_lp = rlp; 826 spin_lock_init(&cnx->lock); 827 INIT_DELAYED_WORK(&cnx->statemachine_wq, veth_statemachine); 828 829 init_timer(&cnx->ack_timer); 830 cnx->ack_timer.function = veth_timed_ack; 831 cnx->ack_timer.data = (unsigned long) cnx; 832 833 init_timer(&cnx->reset_timer); 834 cnx->reset_timer.function = veth_timed_reset; 835 cnx->reset_timer.data = (unsigned long) cnx; 836 cnx->reset_timeout = 5 * HZ * (VETH_ACKTIMEOUT / 1000000); 837 838 memset(&cnx->pending_acks, 0xff, sizeof (cnx->pending_acks)); 839 840 veth_cnx[rlp] = cnx; 841 842 /* This gets us 1 reference, which is held on behalf of the driver 843 * infrastructure. It's released at module unload. */ 844 kobject_init(&cnx->kobject); 845 cnx->kobject.ktype = &veth_lpar_connection_ktype; 846 rc = kobject_set_name(&cnx->kobject, "cnx%.2d", rlp); 847 if (rc != 0) 848 return rc; 849 850 msgs = kmalloc(VETH_NUMBUFFERS * sizeof(struct veth_msg), GFP_KERNEL); 851 if (! msgs) { 852 veth_error("Can't allocate buffers for LPAR %d.\n", rlp); 853 return -ENOMEM; 854 } 855 856 cnx->msgs = msgs; 857 memset(msgs, 0, VETH_NUMBUFFERS * sizeof(struct veth_msg)); 858 859 for (i = 0; i < VETH_NUMBUFFERS; i++) { 860 msgs[i].token = i; 861 veth_stack_push(cnx, msgs + i); 862 } 863 864 cnx->num_events = veth_allocate_events(rlp, 2 + VETH_NUMBUFFERS); 865 866 if (cnx->num_events < (2 + VETH_NUMBUFFERS)) { 867 veth_error("Can't allocate enough events for LPAR %d.\n", rlp); 868 return -ENOMEM; 869 } 870 871 cnx->local_caps.num_buffers = VETH_NUMBUFFERS; 872 cnx->local_caps.ack_threshold = ACK_THRESHOLD; 873 cnx->local_caps.ack_timeout = VETH_ACKTIMEOUT; 874 875 return 0; 876} 877 878static void veth_stop_connection(struct veth_lpar_connection *cnx) 879{ 880 if (!cnx) 881 return; 882 883 spin_lock_irq(&cnx->lock); 884 cnx->state |= VETH_STATE_RESET | VETH_STATE_SHUTDOWN; 885 veth_kick_statemachine(cnx); 886 spin_unlock_irq(&cnx->lock); 887 888 /* There's a slim chance the reset code has just queued the 889 * statemachine to run in five seconds. If so we need to cancel 890 * that and requeue the work to run now. */ 891 if (cancel_delayed_work(&cnx->statemachine_wq)) { 892 spin_lock_irq(&cnx->lock); 893 veth_kick_statemachine(cnx); 894 spin_unlock_irq(&cnx->lock); 895 } 896 897 /* Wait for the state machine to run. */ 898 flush_scheduled_work(); 899} 900 901static void veth_destroy_connection(struct veth_lpar_connection *cnx) 902{ 903 if (!cnx) 904 return; 905 906 if (cnx->num_events > 0) 907 mf_deallocate_lp_events(cnx->remote_lp, 908 HvLpEvent_Type_VirtualLan, 909 cnx->num_events, 910 NULL, NULL); 911 if (cnx->num_ack_events > 0) 912 mf_deallocate_lp_events(cnx->remote_lp, 913 HvLpEvent_Type_VirtualLan, 914 cnx->num_ack_events, 915 NULL, NULL); 916 917 kfree(cnx->msgs); 918 veth_cnx[cnx->remote_lp] = NULL; 919 kfree(cnx); 920} 921 922static void veth_release_connection(struct kobject *kobj) 923{ 924 struct veth_lpar_connection *cnx; 925 cnx = container_of(kobj, struct veth_lpar_connection, kobject); 926 veth_stop_connection(cnx); 927 veth_destroy_connection(cnx); 928} 929 930/* 931 * net_device code 932 */ 933 934static int veth_open(struct net_device *dev) 935{ 936 struct veth_port *port = (struct veth_port *) dev->priv; 937 938 memset(&port->stats, 0, sizeof (port->stats)); 939 netif_start_queue(dev); 940 return 0; 941} 942 943static int veth_close(struct net_device *dev) 944{ 945 netif_stop_queue(dev); 946 return 0; 947} 948 949static struct net_device_stats *veth_get_stats(struct net_device *dev) 950{ 951 struct veth_port *port = (struct veth_port *) dev->priv; 952 953 return &port->stats; 954} 955 956static int veth_change_mtu(struct net_device *dev, int new_mtu) 957{ 958 if ((new_mtu < 68) || (new_mtu > VETH_MAX_MTU)) 959 return -EINVAL; 960 dev->mtu = new_mtu; 961 return 0; 962} 963 964static void veth_set_multicast_list(struct net_device *dev) 965{ 966 struct veth_port *port = (struct veth_port *) dev->priv; 967 unsigned long flags; 968 969 write_lock_irqsave(&port->mcast_gate, flags); 970 971 if ((dev->flags & IFF_PROMISC) || (dev->flags & IFF_ALLMULTI) || 972 (dev->mc_count > VETH_MAX_MCAST)) { 973 port->promiscuous = 1; 974 } else { 975 struct dev_mc_list *dmi = dev->mc_list; 976 int i; 977 978 port->promiscuous = 0; 979 980 /* Update table */ 981 port->num_mcast = 0; 982 983 for (i = 0; i < dev->mc_count; i++) { 984 u8 *addr = dmi->dmi_addr; 985 u64 xaddr = 0; 986 987 if (addr[0] & 0x01) {/* multicast address? */ 988 memcpy(&xaddr, addr, ETH_ALEN); 989 port->mcast_addr[port->num_mcast] = xaddr; 990 port->num_mcast++; 991 } 992 dmi = dmi->next; 993 } 994 } 995 996 write_unlock_irqrestore(&port->mcast_gate, flags); 997} 998 999static void veth_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info) 1000{ 1001 strncpy(info->driver, DRV_NAME, sizeof(info->driver) - 1); 1002 info->driver[sizeof(info->driver) - 1] = '\0'; 1003 strncpy(info->version, DRV_VERSION, sizeof(info->version) - 1); 1004 info->version[sizeof(info->version) - 1] = '\0'; 1005} 1006 1007static int veth_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd) 1008{ 1009 ecmd->supported = (SUPPORTED_1000baseT_Full 1010 | SUPPORTED_Autoneg | SUPPORTED_FIBRE); 1011 ecmd->advertising = (SUPPORTED_1000baseT_Full 1012 | SUPPORTED_Autoneg | SUPPORTED_FIBRE); 1013 ecmd->port = PORT_FIBRE; 1014 ecmd->transceiver = XCVR_INTERNAL; 1015 ecmd->phy_address = 0; 1016 ecmd->speed = SPEED_1000; 1017 ecmd->duplex = DUPLEX_FULL; 1018 ecmd->autoneg = AUTONEG_ENABLE; 1019 ecmd->maxtxpkt = 120; 1020 ecmd->maxrxpkt = 120; 1021 return 0; 1022} 1023 1024static u32 veth_get_link(struct net_device *dev) 1025{ 1026 return 1; 1027} 1028 1029static const struct ethtool_ops ops = { 1030 .get_drvinfo = veth_get_drvinfo, 1031 .get_settings = veth_get_settings, 1032 .get_link = veth_get_link, 1033}; 1034 1035static struct net_device * __init veth_probe_one(int vlan, 1036 struct vio_dev *vio_dev) 1037{ 1038 struct net_device *dev; 1039 struct veth_port *port; 1040 struct device *vdev = &vio_dev->dev; 1041 int i, rc; 1042 const unsigned char *mac_addr; 1043 1044 mac_addr = vio_get_attribute(vio_dev, "local-mac-address", NULL); 1045 if (mac_addr == NULL) 1046 mac_addr = vio_get_attribute(vio_dev, "mac-address", NULL); 1047 if (mac_addr == NULL) { 1048 veth_error("Unable to fetch MAC address from device tree.\n"); 1049 return NULL; 1050 } 1051 1052 dev = alloc_etherdev(sizeof (struct veth_port)); 1053 if (! dev) { 1054 veth_error("Unable to allocate net_device structure!\n"); 1055 return NULL; 1056 } 1057 1058 port = (struct veth_port *) dev->priv; 1059 1060 spin_lock_init(&port->queue_lock); 1061 rwlock_init(&port->mcast_gate); 1062 port->stopped_map = 0; 1063 1064 for (i = 0; i < HVMAXARCHITECTEDLPS; i++) { 1065 HvLpVirtualLanIndexMap map; 1066 1067 if (i == this_lp) 1068 continue; 1069 map = HvLpConfig_getVirtualLanIndexMapForLp(i); 1070 if (map & (0x8000 >> vlan)) 1071 port->lpar_map |= (1 << i); 1072 } 1073 port->dev = vdev; 1074 1075 memcpy(dev->dev_addr, mac_addr, ETH_ALEN); 1076 1077 dev->mtu = VETH_MAX_MTU; 1078 1079 memcpy(&port->mac_addr, mac_addr, ETH_ALEN); 1080 1081 dev->open = veth_open; 1082 dev->hard_start_xmit = veth_start_xmit; 1083 dev->stop = veth_close; 1084 dev->get_stats = veth_get_stats; 1085 dev->change_mtu = veth_change_mtu; 1086 dev->set_mac_address = NULL; 1087 dev->set_multicast_list = veth_set_multicast_list; 1088 SET_ETHTOOL_OPS(dev, &ops); 1089 1090 SET_NETDEV_DEV(dev, vdev); 1091 1092 rc = register_netdev(dev); 1093 if (rc != 0) { 1094 veth_error("Failed registering net device for vlan%d.\n", vlan); 1095 free_netdev(dev); 1096 return NULL; 1097 } 1098 1099 kobject_init(&port->kobject); 1100 port->kobject.parent = &dev->dev.kobj; 1101 port->kobject.ktype = &veth_port_ktype; 1102 kobject_set_name(&port->kobject, "veth_port"); 1103 if (0 != kobject_add(&port->kobject)) 1104 veth_error("Failed adding port for %s to sysfs.\n", dev->name); 1105 1106 veth_info("%s attached to iSeries vlan %d (LPAR map = 0x%.4X)\n", 1107 dev->name, vlan, port->lpar_map); 1108 1109 return dev; 1110} 1111 1112/* 1113 * Tx path 1114 */ 1115 1116static int veth_transmit_to_one(struct sk_buff *skb, HvLpIndex rlp, 1117 struct net_device *dev) 1118{ 1119 struct veth_lpar_connection *cnx = veth_cnx[rlp]; 1120 struct veth_port *port = (struct veth_port *) dev->priv; 1121 HvLpEvent_Rc rc; 1122 struct veth_msg *msg = NULL; 1123 unsigned long flags; 1124 1125 if (! cnx) 1126 return 0; 1127 1128 spin_lock_irqsave(&cnx->lock, flags); 1129 1130 if (! (cnx->state & VETH_STATE_READY)) 1131 goto no_error; 1132 1133 if ((skb->len - ETH_HLEN) > VETH_MAX_MTU) 1134 goto drop; 1135 1136 msg = veth_stack_pop(cnx); 1137 if (! msg) 1138 goto drop; 1139 1140 msg->in_use = 1; 1141 msg->skb = skb_get(skb); 1142 1143 msg->data.addr[0] = dma_map_single(port->dev, skb->data, 1144 skb->len, DMA_TO_DEVICE); 1145 1146 if (dma_mapping_error(msg->data.addr[0])) 1147 goto recycle_and_drop; 1148 1149 msg->dev = port->dev; 1150 msg->data.len[0] = skb->len; 1151 msg->data.eofmask = 1 << VETH_EOF_SHIFT; 1152 1153 rc = veth_signaldata(cnx, VETH_EVENT_FRAMES, msg->token, &msg->data); 1154 1155 if (rc != HvLpEvent_Rc_Good) 1156 goto recycle_and_drop; 1157 1158 /* If the timer's not already running, start it now. */ 1159 if (0 == cnx->outstanding_tx) 1160 mod_timer(&cnx->reset_timer, jiffies + cnx->reset_timeout); 1161 1162 cnx->last_contact = jiffies; 1163 cnx->outstanding_tx++; 1164 1165 if (veth_stack_is_empty(cnx)) 1166 veth_stop_queues(cnx); 1167 1168 no_error: 1169 spin_unlock_irqrestore(&cnx->lock, flags); 1170 return 0; 1171 1172 recycle_and_drop: 1173 veth_recycle_msg(cnx, msg); 1174 drop: 1175 spin_unlock_irqrestore(&cnx->lock, flags); 1176 return 1; 1177} 1178 1179static void veth_transmit_to_many(struct sk_buff *skb, 1180 HvLpIndexMap lpmask, 1181 struct net_device *dev) 1182{ 1183 struct veth_port *port = (struct veth_port *) dev->priv; 1184 int i, success, error; 1185 1186 success = error = 0; 1187 1188 for (i = 0; i < HVMAXARCHITECTEDLPS; i++) { 1189 if ((lpmask & (1 << i)) == 0) 1190 continue; 1191 1192 if (veth_transmit_to_one(skb, i, dev)) 1193 error = 1; 1194 else 1195 success = 1; 1196 } 1197 1198 if (error) 1199 port->stats.tx_errors++; 1200 1201 if (success) { 1202 port->stats.tx_packets++; 1203 port->stats.tx_bytes += skb->len; 1204 } 1205} 1206 1207static int veth_start_xmit(struct sk_buff *skb, struct net_device *dev) 1208{ 1209 unsigned char *frame = skb->data; 1210 struct veth_port *port = (struct veth_port *) dev->priv; 1211 HvLpIndexMap lpmask; 1212 1213 if (! (frame[0] & 0x01)) { 1214 /* unicast packet */ 1215 HvLpIndex rlp = frame[5]; 1216 1217 if ( ! ((1 << rlp) & port->lpar_map) ) { 1218 dev_kfree_skb(skb); 1219 return 0; 1220 } 1221 1222 lpmask = 1 << rlp; 1223 } else { 1224 lpmask = port->lpar_map; 1225 } 1226 1227 veth_transmit_to_many(skb, lpmask, dev); 1228 1229 dev_kfree_skb(skb); 1230 1231 return 0; 1232} 1233 1234/* You must hold the connection's lock when you call this function. */ 1235static void veth_recycle_msg(struct veth_lpar_connection *cnx, 1236 struct veth_msg *msg) 1237{ 1238 u32 dma_address, dma_length; 1239 1240 if (msg->in_use) { 1241 msg->in_use = 0; 1242 dma_address = msg->data.addr[0]; 1243 dma_length = msg->data.len[0]; 1244 1245 if (!dma_mapping_error(dma_address)) 1246 dma_unmap_single(msg->dev, dma_address, dma_length, 1247 DMA_TO_DEVICE); 1248 1249 if (msg->skb) { 1250 dev_kfree_skb_any(msg->skb); 1251 msg->skb = NULL; 1252 } 1253 1254 memset(&msg->data, 0, sizeof(msg->data)); 1255 veth_stack_push(cnx, msg); 1256 } else if (cnx->state & VETH_STATE_OPEN) { 1257 veth_error("Non-pending frame (# %d) acked by LPAR %d.\n", 1258 cnx->remote_lp, msg->token); 1259 } 1260} 1261 1262static void veth_wake_queues(struct veth_lpar_connection *cnx) 1263{ 1264 int i; 1265 1266 for (i = 0; i < HVMAXARCHITECTEDVIRTUALLANS; i++) { 1267 struct net_device *dev = veth_dev[i]; 1268 struct veth_port *port; 1269 unsigned long flags; 1270 1271 if (! dev) 1272 continue; 1273 1274 port = (struct veth_port *)dev->priv; 1275 1276 if (! (port->lpar_map & (1<<cnx->remote_lp))) 1277 continue; 1278 1279 spin_lock_irqsave(&port->queue_lock, flags); 1280 1281 port->stopped_map &= ~(1 << cnx->remote_lp); 1282 1283 if (0 == port->stopped_map && netif_queue_stopped(dev)) { 1284 veth_debug("cnx %d: woke queue for %s.\n", 1285 cnx->remote_lp, dev->name); 1286 netif_wake_queue(dev); 1287 } 1288 spin_unlock_irqrestore(&port->queue_lock, flags); 1289 } 1290} 1291 1292static void veth_stop_queues(struct veth_lpar_connection *cnx) 1293{ 1294 int i; 1295 1296 for (i = 0; i < HVMAXARCHITECTEDVIRTUALLANS; i++) { 1297 struct net_device *dev = veth_dev[i]; 1298 struct veth_port *port; 1299 1300 if (! dev) 1301 continue; 1302 1303 port = (struct veth_port *)dev->priv; 1304 1305 /* If this cnx is not on the vlan for this port, continue */ 1306 if (! (port->lpar_map & (1 << cnx->remote_lp))) 1307 continue; 1308 1309 spin_lock(&port->queue_lock); 1310 1311 netif_stop_queue(dev); 1312 port->stopped_map |= (1 << cnx->remote_lp); 1313 1314 veth_debug("cnx %d: stopped queue for %s, map = 0x%x.\n", 1315 cnx->remote_lp, dev->name, port->stopped_map); 1316 1317 spin_unlock(&port->queue_lock); 1318 } 1319} 1320 1321static void veth_timed_reset(unsigned long ptr) 1322{ 1323 struct veth_lpar_connection *cnx = (struct veth_lpar_connection *)ptr; 1324 unsigned long trigger_time, flags; 1325 1326 1327 spin_lock_irqsave(&cnx->lock, flags); 1328 1329 if (cnx->outstanding_tx > 0) { 1330 trigger_time = cnx->last_contact + cnx->reset_timeout; 1331 1332 if (trigger_time < jiffies) { 1333 cnx->state |= VETH_STATE_RESET; 1334 veth_kick_statemachine(cnx); 1335 veth_error("%d packets not acked by LPAR %d within %d " 1336 "seconds, resetting.\n", 1337 cnx->outstanding_tx, cnx->remote_lp, 1338 cnx->reset_timeout / HZ); 1339 } else { 1340 /* Reschedule the timer */ 1341 trigger_time = jiffies + cnx->reset_timeout; 1342 mod_timer(&cnx->reset_timer, trigger_time); 1343 } 1344 } 1345 1346 spin_unlock_irqrestore(&cnx->lock, flags); 1347} 1348 1349/* 1350 * Rx path 1351 */ 1352 1353static inline int veth_frame_wanted(struct veth_port *port, u64 mac_addr) 1354{ 1355 int wanted = 0; 1356 int i; 1357 unsigned long flags; 1358 1359 if ( (mac_addr == port->mac_addr) || (mac_addr == 0xffffffffffff0000) ) 1360 return 1; 1361 1362 read_lock_irqsave(&port->mcast_gate, flags); 1363 1364 if (port->promiscuous) { 1365 wanted = 1; 1366 goto out; 1367 } 1368 1369 for (i = 0; i < port->num_mcast; ++i) { 1370 if (port->mcast_addr[i] == mac_addr) { 1371 wanted = 1; 1372 break; 1373 } 1374 } 1375 1376 out: 1377 read_unlock_irqrestore(&port->mcast_gate, flags); 1378 1379 return wanted; 1380} 1381 1382struct dma_chunk { 1383 u64 addr; 1384 u64 size; 1385}; 1386 1387#define VETH_MAX_PAGES_PER_FRAME ( (VETH_MAX_MTU+PAGE_SIZE-2)/PAGE_SIZE + 1 ) 1388 1389static inline void veth_build_dma_list(struct dma_chunk *list, 1390 unsigned char *p, unsigned long length) 1391{ 1392 unsigned long done; 1393 int i = 1; 1394 1395 list[0].addr = iseries_hv_addr(p); 1396 list[0].size = min(length, 1397 PAGE_SIZE - ((unsigned long)p & ~PAGE_MASK)); 1398 1399 done = list[0].size; 1400 while (done < length) { 1401 list[i].addr = iseries_hv_addr(p + done); 1402 list[i].size = min(length-done, PAGE_SIZE); 1403 done += list[i].size; 1404 i++; 1405 } 1406} 1407 1408static void veth_flush_acks(struct veth_lpar_connection *cnx) 1409{ 1410 HvLpEvent_Rc rc; 1411 1412 rc = veth_signaldata(cnx, VETH_EVENT_FRAMES_ACK, 1413 0, &cnx->pending_acks); 1414 1415 if (rc != HvLpEvent_Rc_Good) 1416 veth_error("Failed acking frames from LPAR %d, rc = %d\n", 1417 cnx->remote_lp, (int)rc); 1418 1419 cnx->num_pending_acks = 0; 1420 memset(&cnx->pending_acks, 0xff, sizeof(cnx->pending_acks)); 1421} 1422 1423static void veth_receive(struct veth_lpar_connection *cnx, 1424 struct veth_lpevent *event) 1425{ 1426 struct veth_frames_data *senddata = &event->u.frames_data; 1427 int startchunk = 0; 1428 int nchunks; 1429 unsigned long flags; 1430 HvLpDma_Rc rc; 1431 1432 do { 1433 u16 length = 0; 1434 struct sk_buff *skb; 1435 struct dma_chunk local_list[VETH_MAX_PAGES_PER_FRAME]; 1436 struct dma_chunk remote_list[VETH_MAX_FRAMES_PER_MSG]; 1437 u64 dest; 1438 HvLpVirtualLanIndex vlan; 1439 struct net_device *dev; 1440 struct veth_port *port; 1441 1442 memset(local_list, 0, sizeof(local_list)); 1443 memset(remote_list, 0, sizeof(VETH_MAX_FRAMES_PER_MSG)); 1444 1445 /* a 0 address marks the end of the valid entries */ 1446 if (senddata->addr[startchunk] == 0) 1447 break; 1448 1449 /* make sure that we have at least 1 EOF entry in the 1450 * remaining entries */ 1451 if (! (senddata->eofmask >> (startchunk + VETH_EOF_SHIFT))) { 1452 veth_error("Missing EOF fragment in event " 1453 "eofmask = 0x%x startchunk = %d\n", 1454 (unsigned)senddata->eofmask, 1455 startchunk); 1456 break; 1457 } 1458 1459 /* build list of chunks in this frame */ 1460 nchunks = 0; 1461 do { 1462 remote_list[nchunks].addr = 1463 (u64) senddata->addr[startchunk+nchunks] << 32; 1464 remote_list[nchunks].size = 1465 senddata->len[startchunk+nchunks]; 1466 length += remote_list[nchunks].size; 1467 } while (! (senddata->eofmask & 1468 (1 << (VETH_EOF_SHIFT + startchunk + nchunks++)))); 1469 1470 /* length == total length of all chunks */ 1471 /* nchunks == # of chunks in this frame */ 1472 1473 if ((length - ETH_HLEN) > VETH_MAX_MTU) { 1474 veth_error("Received oversize frame from LPAR %d " 1475 "(length = %d)\n", 1476 cnx->remote_lp, length); 1477 continue; 1478 } 1479 1480 skb = alloc_skb(length, GFP_ATOMIC); 1481 if (!skb) 1482 continue; 1483 1484 veth_build_dma_list(local_list, skb->data, length); 1485 1486 rc = HvCallEvent_dmaBufList(HvLpEvent_Type_VirtualLan, 1487 event->base_event.xSourceLp, 1488 HvLpDma_Direction_RemoteToLocal, 1489 cnx->src_inst, 1490 cnx->dst_inst, 1491 HvLpDma_AddressType_RealAddress, 1492 HvLpDma_AddressType_TceIndex, 1493 iseries_hv_addr(&local_list), 1494 iseries_hv_addr(&remote_list), 1495 length); 1496 if (rc != HvLpDma_Rc_Good) { 1497 dev_kfree_skb_irq(skb); 1498 continue; 1499 } 1500 1501 vlan = skb->data[9]; 1502 dev = veth_dev[vlan]; 1503 if (! dev) { 1504 /* 1505 * Some earlier versions of the driver sent 1506 * broadcasts down all connections, even to lpars 1507 * that weren't on the relevant vlan. So ignore 1508 * packets belonging to a vlan we're not on. 1509 * We can also be here if we receive packets while 1510 * the driver is going down, because then dev is NULL. 1511 */ 1512 dev_kfree_skb_irq(skb); 1513 continue; 1514 } 1515 1516 port = (struct veth_port *)dev->priv; 1517 dest = *((u64 *) skb->data) & 0xFFFFFFFFFFFF0000; 1518 1519 if ((vlan > HVMAXARCHITECTEDVIRTUALLANS) || !port) { 1520 dev_kfree_skb_irq(skb); 1521 continue; 1522 } 1523 if (! veth_frame_wanted(port, dest)) { 1524 dev_kfree_skb_irq(skb); 1525 continue; 1526 } 1527 1528 skb_put(skb, length); 1529 skb->protocol = eth_type_trans(skb, dev); 1530 skb->ip_summed = CHECKSUM_NONE; 1531 netif_rx(skb); /* send it up */ 1532 port->stats.rx_packets++; 1533 port->stats.rx_bytes += length; 1534 } while (startchunk += nchunks, startchunk < VETH_MAX_FRAMES_PER_MSG); 1535 1536 /* Ack it */ 1537 spin_lock_irqsave(&cnx->lock, flags); 1538 BUG_ON(cnx->num_pending_acks > VETH_MAX_ACKS_PER_MSG); 1539 1540 cnx->pending_acks[cnx->num_pending_acks++] = 1541 event->base_event.xCorrelationToken; 1542 1543 if ( (cnx->num_pending_acks >= cnx->remote_caps.ack_threshold) 1544 || (cnx->num_pending_acks >= VETH_MAX_ACKS_PER_MSG) ) 1545 veth_flush_acks(cnx); 1546 1547 spin_unlock_irqrestore(&cnx->lock, flags); 1548} 1549 1550static void veth_timed_ack(unsigned long ptr) 1551{ 1552 struct veth_lpar_connection *cnx = (struct veth_lpar_connection *) ptr; 1553 unsigned long flags; 1554 1555 /* Ack all the events */ 1556 spin_lock_irqsave(&cnx->lock, flags); 1557 if (cnx->num_pending_acks > 0) 1558 veth_flush_acks(cnx); 1559 1560 /* Reschedule the timer */ 1561 cnx->ack_timer.expires = jiffies + cnx->ack_timeout; 1562 add_timer(&cnx->ack_timer); 1563 spin_unlock_irqrestore(&cnx->lock, flags); 1564} 1565 1566static int veth_remove(struct vio_dev *vdev) 1567{ 1568 struct veth_lpar_connection *cnx; 1569 struct net_device *dev; 1570 struct veth_port *port; 1571 int i; 1572 1573 dev = veth_dev[vdev->unit_address]; 1574 1575 if (! dev) 1576 return 0; 1577 1578 port = netdev_priv(dev); 1579 1580 for (i = 0; i < HVMAXARCHITECTEDLPS; i++) { 1581 cnx = veth_cnx[i]; 1582 1583 if (cnx && (port->lpar_map & (1 << i))) { 1584 /* Drop our reference to connections on our VLAN */ 1585 kobject_put(&cnx->kobject); 1586 } 1587 } 1588 1589 veth_dev[vdev->unit_address] = NULL; 1590 kobject_del(&port->kobject); 1591 kobject_put(&port->kobject); 1592 unregister_netdev(dev); 1593 free_netdev(dev); 1594 1595 return 0; 1596} 1597 1598static int veth_probe(struct vio_dev *vdev, const struct vio_device_id *id) 1599{ 1600 int i = vdev->unit_address; 1601 struct net_device *dev; 1602 struct veth_port *port; 1603 1604 dev = veth_probe_one(i, vdev); 1605 if (dev == NULL) { 1606 veth_remove(vdev); 1607 return 1; 1608 } 1609 veth_dev[i] = dev; 1610 1611 port = (struct veth_port*)netdev_priv(dev); 1612 1613 /* Start the state machine on each connection on this vlan. If we're 1614 * the first dev to do so this will commence link negotiation */ 1615 for (i = 0; i < HVMAXARCHITECTEDLPS; i++) { 1616 struct veth_lpar_connection *cnx; 1617 1618 if (! (port->lpar_map & (1 << i))) 1619 continue; 1620 1621 cnx = veth_cnx[i]; 1622 if (!cnx) 1623 continue; 1624 1625 kobject_get(&cnx->kobject); 1626 veth_kick_statemachine(cnx); 1627 } 1628 1629 return 0; 1630} 1631 1632/** 1633 * veth_device_table: Used by vio.c to match devices that we 1634 * support. 1635 */ 1636static struct vio_device_id veth_device_table[] __devinitdata = { 1637 { "network", "IBM,iSeries-l-lan" }, 1638 { "", "" } 1639}; 1640MODULE_DEVICE_TABLE(vio, veth_device_table); 1641 1642static struct vio_driver veth_driver = { 1643 .id_table = veth_device_table, 1644 .probe = veth_probe, 1645 .remove = veth_remove, 1646 .driver = { 1647 .name = DRV_NAME, 1648 .owner = THIS_MODULE, 1649 } 1650}; 1651 1652/* 1653 * Module initialization/cleanup 1654 */ 1655 1656static void __exit veth_module_cleanup(void) 1657{ 1658 int i; 1659 struct veth_lpar_connection *cnx; 1660 1661 /* Disconnect our "irq" to stop events coming from the Hypervisor. */ 1662 HvLpEvent_unregisterHandler(HvLpEvent_Type_VirtualLan); 1663 1664 /* Make sure any work queued from Hypervisor callbacks is finished. */ 1665 flush_scheduled_work(); 1666 1667 for (i = 0; i < HVMAXARCHITECTEDLPS; ++i) { 1668 cnx = veth_cnx[i]; 1669 1670 if (!cnx) 1671 continue; 1672 1673 /* Remove the connection from sysfs */ 1674 kobject_del(&cnx->kobject); 1675 /* Drop the driver's reference to the connection */ 1676 kobject_put(&cnx->kobject); 1677 } 1678 1679 /* Unregister the driver, which will close all the netdevs and stop 1680 * the connections when they're no longer referenced. */ 1681 vio_unregister_driver(&veth_driver); 1682} 1683module_exit(veth_module_cleanup); 1684 1685static int __init veth_module_init(void) 1686{ 1687 int i; 1688 int rc; 1689 1690 if (!firmware_has_feature(FW_FEATURE_ISERIES)) 1691 return -ENODEV; 1692 1693 this_lp = HvLpConfig_getLpIndex_outline(); 1694 1695 for (i = 0; i < HVMAXARCHITECTEDLPS; ++i) { 1696 rc = veth_init_connection(i); 1697 if (rc != 0) 1698 goto error; 1699 } 1700 1701 HvLpEvent_registerHandler(HvLpEvent_Type_VirtualLan, 1702 &veth_handle_event); 1703 1704 rc = vio_register_driver(&veth_driver); 1705 if (rc != 0) 1706 goto error; 1707 1708 for (i = 0; i < HVMAXARCHITECTEDLPS; ++i) { 1709 struct kobject *kobj; 1710 1711 if (!veth_cnx[i]) 1712 continue; 1713 1714 kobj = &veth_cnx[i]->kobject; 1715 kobj->parent = &veth_driver.driver.kobj; 1716 /* If the add failes, complain but otherwise continue */ 1717 if (0 != kobject_add(kobj)) 1718 veth_error("cnx %d: Failed adding to sysfs.\n", i); 1719 } 1720 1721 return 0; 1722 1723error: 1724 for (i = 0; i < HVMAXARCHITECTEDLPS; ++i) { 1725 veth_destroy_connection(veth_cnx[i]); 1726 } 1727 1728 return rc; 1729} 1730module_init(veth_module_init); 1731