qemu/roms/ipxe/src/net/fcoe.c

   1 /*
   2  * Copyright (C) 2010 Michael Brown <mbrown@fensystems.co.uk>.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * 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., 51 Franklin Street, Fifth Floor, Boston, MA
  17  * 02110-1301, USA.
  18  */
  19
  20 FILE_LICENCE ( GPL2_OR_LATER );
  21
  22 #include <stddef.h>
  23 #include <stdlib.h>
  24 #include <errno.h>
  25 #include <byteswap.h>
  26 #include <ipxe/if_ether.h>
  27 #include <ipxe/if_arp.h>
  28 #include <ipxe/iobuf.h>
  29 #include <ipxe/interface.h>
  30 #include <ipxe/xfer.h>
  31 #include <ipxe/netdevice.h>
  32 #include <ipxe/ethernet.h>
  33 #include <ipxe/vlan.h>
  34 #include <ipxe/features.h>
  35 #include <ipxe/errortab.h>
  36 #include <ipxe/device.h>
  37 #include <ipxe/crc32.h>
  38 #include <ipxe/retry.h>
  39 #include <ipxe/timer.h>
  40 #include <ipxe/fc.h>
  41 #include <ipxe/fip.h>
  42 #include <ipxe/fcoe.h>
  43
  44 /** @file
  45  *
  46  * FCoE protocol
  47  *
  48  */
  49
  50 FEATURE ( FEATURE_PROTOCOL, "FCoE", DHCP_EB_FEATURE_FCOE, 1 );
  51
  52 /* Disambiguate the various error causes */
  53 #define EINVAL_UNDERLENGTH __einfo_error ( EINFO_EINVAL_UNDERLENGTH )
  54 #define EINFO_EINVAL_UNDERLENGTH \
  55         __einfo_uniqify ( EINFO_EINVAL, 0x01, "Underlength packet" )
  56 #define EINVAL_SOF __einfo_error ( EINFO_EINVAL_SOF )
  57 #define EINFO_EINVAL_SOF \
  58         __einfo_uniqify ( EINFO_EINVAL, 0x02, "Invalid SoF delimiter" )
  59 #define EINVAL_CRC __einfo_error ( EINFO_EINVAL_CRC )
  60 #define EINFO_EINVAL_CRC \
  61         __einfo_uniqify ( EINFO_EINVAL, 0x03, "Invalid CRC (not stripped?)" )
  62 #define EINVAL_EOF __einfo_error ( EINFO_EINVAL_EOF )
  63 #define EINFO_EINVAL_EOF \
  64         __einfo_uniqify ( EINFO_EINVAL, 0x04, "Invalid EoF delimiter" )
  65
  66 /** An FCoE port */
  67 struct fcoe_port {
  68         /** Reference count */
  69         struct refcnt refcnt;
  70         /** List of FCoE ports */
  71         struct list_head list;
  72         /** Transport interface */
  73         struct interface transport;
  74         /** Network device */
  75         struct net_device *netdev;
  76
  77         /** Node WWN */
  78         union fcoe_name node_wwn;
  79         /** Port WWN */
  80         union fcoe_name port_wwn;
  81
  82         /** FIP retransmission timer */
  83         struct retry_timer timer;
  84         /** FIP timeout counter */
  85         unsigned int timeouts;
  86         /** Flags */
  87         unsigned int flags;
  88         /** FCoE forwarder priority */
  89         unsigned int priority;
  90         /** Keepalive delay (in ms) */
  91         unsigned int keepalive;
  92         /** FCoE forwarder MAC address */
  93         uint8_t fcf_mac[ETH_ALEN];
  94         /** Local MAC address */
  95         uint8_t local_mac[ETH_ALEN];
  96 };
  97
  98 /** FCoE flags */
  99 enum fcoe_flags {
 100         /** Underlying network device is available */
 101         FCOE_HAVE_NETWORK = 0x0001,
 102         /** We have selected an FCoE forwarder to use */
 103         FCOE_HAVE_FCF = 0x0002,
 104         /** We have a FIP-capable FCoE forwarder available to be used */
 105         FCOE_HAVE_FIP_FCF = 0x0004,
 106         /** FCoE forwarder supports server-provided MAC addresses */
 107         FCOE_FCF_ALLOWS_SPMA = 0x0008,
 108         /** An alternative VLAN has been found */
 109         FCOE_VLAN_FOUND = 0x0010,
 110         /** VLAN discovery has timed out */
 111         FCOE_VLAN_TIMED_OUT = 0x0020,
 112 };
 113
 114 struct net_protocol fcoe_protocol __net_protocol;
 115 struct net_protocol fip_protocol __net_protocol;
 116
 117 /** FCoE All-FCoE-MACs address */
 118 static uint8_t all_fcoe_macs[ETH_ALEN] =
 119         { 0x01, 0x10, 0x18, 0x01, 0x00, 0x00 };
 120
 121 /** FCoE All-ENode-MACs address */
 122 static uint8_t all_enode_macs[ETH_ALEN] =
 123         { 0x01, 0x10, 0x18, 0x01, 0x00, 0x01 };
 124
 125 /** FCoE All-FCF-MACs address */
 126 static uint8_t all_fcf_macs[ETH_ALEN] =
 127         { 0x01, 0x10, 0x18, 0x01, 0x00, 0x02 };
 128
 129 /** Default FCoE forwarded MAC address */
 130 static uint8_t default_fcf_mac[ETH_ALEN] =
 131         { 0x0e, 0xfc, 0x00, 0xff, 0xff, 0xfe };
 132
 133 /** Maximum number of VLAN requests before giving up on VLAN discovery */
 134 #define FCOE_MAX_VLAN_REQUESTS 2
 135
 136 /** Delay between retrying VLAN requests */
 137 #define FCOE_VLAN_RETRY_DELAY ( TICKS_PER_SEC )
 138
 139 /** Delay between retrying polling VLAN requests */
 140 #define FCOE_VLAN_POLL_DELAY ( 30 * TICKS_PER_SEC )
 141
 142 /** Maximum number of FIP solicitations before giving up on FIP */
 143 #define FCOE_MAX_FIP_SOLICITATIONS 2
 144
 145 /** Delay between retrying FIP solicitations */
 146 #define FCOE_FIP_RETRY_DELAY ( TICKS_PER_SEC )
 147
 148 /** Maximum number of missing discovery advertisements */
 149 #define FCOE_MAX_FIP_MISSING_KEEPALIVES 4
 150
 151 /** List of FCoE ports */
 152 static LIST_HEAD ( fcoe_ports );
 153
 154 /******************************************************************************
 155  *
 156  * FCoE protocol
 157  *
 158  ******************************************************************************
 159  */
 160
 161 /**
 162  * Identify FCoE port by network device
 163  *
 164  * @v netdev            Network device
 165  * @ret fcoe            FCoE port, or NULL
 166  */
 167 static struct fcoe_port * fcoe_demux ( struct net_device *netdev ) {
 168         struct fcoe_port *fcoe;
 169
 170         list_for_each_entry ( fcoe, &fcoe_ports, list ) {
 171                 if ( fcoe->netdev == netdev )
 172                         return fcoe;
 173         }
 174         return NULL;
 175 }
 176
 177 /**
 178  * Reset FCoE port
 179  *
 180  * @v fcoe              FCoE port
 181  */
 182 static void fcoe_reset ( struct fcoe_port *fcoe ) {
 183
 184         /* Detach FC port, if any */
 185         intf_restart ( &fcoe->transport, -ECANCELED );
 186
 187         /* Reset any FIP state */
 188         stop_timer ( &fcoe->timer );
 189         fcoe->timeouts = 0;
 190         fcoe->flags = 0;
 191         fcoe->priority = ( FIP_LOWEST_PRIORITY + 1 );
 192         fcoe->keepalive = 0;
 193         memcpy ( fcoe->fcf_mac, default_fcf_mac,
 194                  sizeof ( fcoe->fcf_mac ) );
 195         memcpy ( fcoe->local_mac, fcoe->netdev->ll_addr,
 196                  sizeof ( fcoe->local_mac ) );
 197
 198         /* Start FIP solicitation if network is available */
 199         if ( netdev_is_open ( fcoe->netdev ) &&
 200              netdev_link_ok ( fcoe->netdev ) ) {
 201                 fcoe->flags |= FCOE_HAVE_NETWORK;
 202                 start_timer_nodelay ( &fcoe->timer );
 203                 DBGC ( fcoe, "FCoE %s starting %s\n", fcoe->netdev->name,
 204                        ( vlan_can_be_trunk ( fcoe->netdev ) ?
 205                          "VLAN discovery" : "FIP solicitation" ) );
 206         }
 207
 208         /* Send notification of window change */
 209         xfer_window_changed ( &fcoe->transport );
 210 }
 211
 212 /**
 213  * Transmit FCoE packet
 214  *
 215  * @v fcoe              FCoE port
 216  * @v iobuf             I/O buffer
 217  * @v meta              Data transfer metadata
 218  * @ret rc              Return status code
 219  */
 220 static int fcoe_deliver ( struct fcoe_port *fcoe,
 221                           struct io_buffer *iobuf,
 222                           struct xfer_metadata *meta __unused ) {
 223         struct fc_frame_header *fchdr = iobuf->data;
 224         struct fc_els_frame_common *els = ( iobuf->data + sizeof ( *fchdr ) );
 225         struct fcoe_header *fcoehdr;
 226         struct fcoe_footer *fcoeftr;
 227         struct fip_header *fiphdr;
 228         struct fip_login *fipflogi;
 229         struct fip_mac_address *fipmac;
 230         uint32_t crc;
 231         struct net_protocol *net_protocol;
 232         void *ll_source;
 233         int rc;
 234
 235         /* Send as FIP or FCoE as appropriate */
 236         if ( ( fchdr->r_ctl == ( FC_R_CTL_ELS | FC_R_CTL_UNSOL_CTRL ) ) &&
 237              ( els->command == FC_ELS_FLOGI ) &&
 238              ( fcoe->flags & FCOE_HAVE_FIP_FCF ) ) {
 239
 240                 /* Create FIP FLOGI descriptor */
 241                 fipflogi = iob_push ( iobuf,
 242                                       offsetof ( typeof ( *fipflogi ), fc ) );
 243                 memset ( fipflogi, 0, offsetof ( typeof ( *fipflogi ), fc ) );
 244                 fipflogi->type = FIP_FLOGI;
 245                 fipflogi->len = ( iob_len ( iobuf ) / 4 );
 246
 247                 /* Create FIP MAC address descriptor */
 248                 fipmac = iob_put ( iobuf, sizeof ( *fipmac ) );
 249                 memset ( fipmac, 0, sizeof ( *fipmac ) );
 250                 fipmac->type = FIP_MAC_ADDRESS;
 251                 fipmac->len = ( sizeof ( *fipmac ) / 4 );
 252                 if ( fcoe->flags & FCOE_FCF_ALLOWS_SPMA ) {
 253                         memcpy ( fipmac->mac, fcoe->netdev->ll_addr,
 254                                  sizeof ( fipmac->mac ) );
 255                 }
 256
 257                 /* Create FIP header */
 258                 fiphdr = iob_push ( iobuf, sizeof ( *fiphdr ) );
 259                 memset ( fiphdr, 0, sizeof ( *fiphdr ) );
 260                 fiphdr->version = FIP_VERSION;
 261                 fiphdr->code = htons ( FIP_CODE_ELS );
 262                 fiphdr->subcode = FIP_ELS_REQUEST;
 263                 fiphdr->len =
 264                         htons ( ( iob_len ( iobuf ) - sizeof ( *fiphdr ) ) / 4);
 265                 fiphdr->flags = ( ( fcoe->flags & FCOE_FCF_ALLOWS_SPMA ) ?
 266                                   htons ( FIP_SP ) : htons ( FIP_FP ) );
 267
 268                 /* Send as FIP packet from netdev's own MAC address */
 269                 net_protocol = &fip_protocol;
 270                 ll_source = fcoe->netdev->ll_addr;
 271
 272         } else {
 273
 274                 /* Calculate CRC */
 275                 crc = crc32_le ( ~((uint32_t)0), iobuf->data,
 276                                  iob_len ( iobuf ) );
 277
 278                 /* Create FCoE header */
 279                 fcoehdr = iob_push ( iobuf, sizeof ( *fcoehdr ) );
 280                 memset ( fcoehdr, 0, sizeof ( *fcoehdr ) );
 281                 fcoehdr->sof = ( ( fchdr->seq_cnt == ntohs ( 0 ) ) ?
 282                                  FCOE_SOF_I3 : FCOE_SOF_N3 );
 283
 284                 /* Create FCoE footer */
 285                 fcoeftr = iob_put ( iobuf, sizeof ( *fcoeftr ) );
 286                 memset ( fcoeftr, 0, sizeof ( *fcoeftr ) );
 287                 fcoeftr->crc = cpu_to_le32 ( crc ^ ~((uint32_t)0) );
 288                 fcoeftr->eof = ( ( fchdr->f_ctl_es & FC_F_CTL_ES_END ) ?
 289                                  FCOE_EOF_T : FCOE_EOF_N );
 290
 291                 /* Send as FCoE packet from FCoE MAC address */
 292                 net_protocol = &fcoe_protocol;
 293                 ll_source = fcoe->local_mac;
 294         }
 295
 296         /* Transmit packet */
 297         if ( ( rc = net_tx ( iob_disown ( iobuf ), fcoe->netdev, net_protocol,
 298                              fcoe->fcf_mac, ll_source ) ) != 0 ) {
 299                 DBGC ( fcoe, "FCoE %s could not transmit: %s\n",
 300                        fcoe->netdev->name, strerror ( rc ) );
 301                 goto done;
 302         }
 303
 304  done:
 305         free_iob ( iobuf );
 306         return rc;
 307 }
 308
 309 /**
 310  * Allocate FCoE I/O buffer
 311  *
 312  * @v len               Payload length
 313  * @ret iobuf           I/O buffer, or NULL
 314  */
 315 static struct io_buffer * fcoe_alloc_iob ( struct fcoe_port *fcoe __unused,
 316                                            size_t len ) {
 317         struct io_buffer *iobuf;
 318
 319         iobuf = alloc_iob ( MAX_LL_HEADER_LEN + sizeof ( struct fcoe_header ) +
 320                             len + sizeof ( struct fcoe_footer ) );
 321         if ( iobuf ) {
 322                 iob_reserve ( iobuf, ( MAX_LL_HEADER_LEN +
 323                                        sizeof ( struct fcoe_header ) ) );
 324         }
 325         return iobuf;
 326 }
 327
 328 /**
 329  * Process incoming FCoE packets
 330  *
 331  * @v iobuf             I/O buffer
 332  * @v netdev            Network device
 333  * @v ll_dest           Link-layer destination address
 334  * @v ll_source         Link-layer source address
 335  * @v flags             Packet flags
 336  * @ret rc              Return status code
 337  */
 338 static int fcoe_rx ( struct io_buffer *iobuf, struct net_device *netdev,
 339                      const void *ll_dest, const void *ll_source,
 340                      unsigned int flags __unused ) {
 341         struct fcoe_header *fcoehdr;
 342         struct fcoe_footer *fcoeftr;
 343         struct fcoe_port *fcoe;
 344         int rc;
 345
 346         /* Identify FCoE port */
 347         if ( ( fcoe = fcoe_demux ( netdev ) ) == NULL ) {
 348                 DBG ( "FCoE received frame for net device %s missing FCoE "
 349                       "port\n", netdev->name );
 350                 rc = -ENOTCONN;
 351                 goto done;
 352         }
 353
 354         /* Discard packets not destined for us */
 355         if ( ( memcmp ( fcoe->local_mac, ll_dest,
 356                         sizeof ( fcoe->local_mac ) ) != 0 ) &&
 357              ( memcmp ( default_fcf_mac, ll_dest,
 358                         sizeof ( default_fcf_mac ) ) != 0 ) ) {
 359                 DBGC2 ( fcoe, "FCoE %s ignoring packet for %s\n",
 360                         fcoe->netdev->name, eth_ntoa ( ll_dest ) );
 361                 rc = -ENOTCONN;
 362                 goto done;
 363         }
 364
 365         /* Sanity check */
 366         if ( iob_len ( iobuf ) < ( sizeof ( *fcoehdr ) + sizeof ( *fcoeftr ) )){
 367                 DBGC ( fcoe, "FCoE %s received under-length frame (%zd "
 368                        "bytes)\n", fcoe->netdev->name, iob_len ( iobuf ) );
 369                 rc = -EINVAL_UNDERLENGTH;
 370                 goto done;
 371         }
 372
 373         /* Strip header and footer */
 374         fcoehdr = iobuf->data;
 375         iob_pull ( iobuf, sizeof ( *fcoehdr ) );
 376         fcoeftr = ( iobuf->data + iob_len ( iobuf ) - sizeof ( *fcoeftr ) );
 377         iob_unput ( iobuf, sizeof ( *fcoeftr ) );
 378
 379         /* Validity checks */
 380         if ( fcoehdr->version != FCOE_FRAME_VER ) {
 381                 DBGC ( fcoe, "FCoE %s received unsupported frame version "
 382                        "%02x\n", fcoe->netdev->name, fcoehdr->version );
 383                 rc = -EPROTONOSUPPORT;
 384                 goto done;
 385         }
 386         if ( ! ( ( fcoehdr->sof == FCOE_SOF_I3 ) ||
 387                  ( fcoehdr->sof == FCOE_SOF_N3 ) ) ) {
 388                 DBGC ( fcoe, "FCoE %s received unsupported start-of-frame "
 389                        "delimiter %02x\n", fcoe->netdev->name, fcoehdr->sof );
 390                 rc = -EINVAL_SOF;
 391                 goto done;
 392         }
 393         if ( ( le32_to_cpu ( fcoeftr->crc ) ^ ~((uint32_t)0) ) !=
 394              crc32_le ( ~((uint32_t)0), iobuf->data, iob_len ( iobuf ) ) ) {
 395                 DBGC ( fcoe, "FCoE %s received invalid CRC\n",
 396                        fcoe->netdev->name );
 397                 rc = -EINVAL_CRC;
 398                 goto done;
 399         }
 400         if ( ! ( ( fcoeftr->eof == FCOE_EOF_N ) ||
 401                  ( fcoeftr->eof == FCOE_EOF_T ) ) ) {
 402                 DBGC ( fcoe, "FCoE %s received unsupported end-of-frame "
 403                        "delimiter %02x\n", fcoe->netdev->name, fcoeftr->eof );
 404                 rc = -EINVAL_EOF;
 405                 goto done;
 406         }
 407
 408         /* Record FCF address if applicable */
 409         if ( ( fcoe->flags & FCOE_HAVE_FCF ) &&
 410              ( ! ( fcoe->flags & FCOE_HAVE_FIP_FCF ) ) ) {
 411                 memcpy ( &fcoe->fcf_mac, ll_source, sizeof ( fcoe->fcf_mac ) );
 412         }
 413
 414         /* Hand off via transport interface */
 415         if ( ( rc = xfer_deliver_iob ( &fcoe->transport,
 416                                        iob_disown ( iobuf ) ) ) != 0 ) {
 417                 DBGC ( fcoe, "FCoE %s could not deliver frame: %s\n",
 418                        fcoe->netdev->name, strerror ( rc ) );
 419                 goto done;
 420         }
 421
 422  done:
 423         free_iob ( iobuf );
 424         return rc;
 425 }
 426
 427 /**
 428  * Check FCoE flow control window
 429  *
 430  * @v fcoe              FCoE port
 431  * @ret len             Length of window
 432  */
 433 static size_t fcoe_window ( struct fcoe_port *fcoe ) {
 434         return ( ( fcoe->flags & FCOE_HAVE_FCF ) ? ~( ( size_t ) 0 ) : 0 );
 435 }
 436
 437 /**
 438  * Close FCoE port
 439  *
 440  * @v fcoe              FCoE port
 441  * @v rc                Reason for close
 442  */
 443 static void fcoe_close ( struct fcoe_port *fcoe, int rc ) {
 444
 445         stop_timer ( &fcoe->timer );
 446         intf_shutdown ( &fcoe->transport, rc );
 447         netdev_put ( fcoe->netdev );
 448         list_del ( &fcoe->list );
 449         ref_put ( &fcoe->refcnt );
 450 }
 451
 452 /**
 453  * Identify device underlying FCoE port
 454  *
 455  * @v fcoe              FCoE port
 456  * @ret device          Underlying device
 457  */
 458 static struct device * fcoe_identify_device ( struct fcoe_port *fcoe ) {
 459         return fcoe->netdev->dev;
 460 }
 461
 462 /** FCoE transport interface operations */
 463 static struct interface_operation fcoe_transport_op[] = {
 464         INTF_OP ( xfer_deliver, struct fcoe_port *, fcoe_deliver ),
 465         INTF_OP ( xfer_alloc_iob, struct fcoe_port *, fcoe_alloc_iob ),
 466         INTF_OP ( xfer_window, struct fcoe_port *, fcoe_window ),
 467         INTF_OP ( intf_close, struct fcoe_port *, fcoe_close ),
 468         INTF_OP ( identify_device, struct fcoe_port *,
 469                   fcoe_identify_device ),
 470 };
 471
 472 /** FCoE transport interface descriptor */
 473 static struct interface_descriptor fcoe_transport_desc =
 474         INTF_DESC ( struct fcoe_port, transport, fcoe_transport_op );
 475
 476 /******************************************************************************
 477  *
 478  * FIP protocol
 479  *
 480  ******************************************************************************
 481  */
 482
 483 /**
 484  * Parse FIP packet into descriptor set
 485  *
 486  * @v fcoe              FCoE port
 487  * @v fiphdr            FIP header
 488  * @v len               Length of FIP packet
 489  * @v descs             Descriptor set to fill in
 490  * @ret rc              Return status code
 491  */
 492 static int fcoe_fip_parse ( struct fcoe_port *fcoe, struct fip_header *fiphdr,
 493                             size_t len, struct fip_descriptors *descs ) {
 494         union fip_descriptor *desc;
 495         size_t descs_len;
 496         size_t desc_len;
 497         size_t desc_offset;
 498         unsigned int desc_type;
 499
 500         /* Check FIP version */
 501         if ( fiphdr->version != FIP_VERSION ) {
 502                 DBGC ( fcoe, "FCoE %s received unsupported FIP version %02x\n",
 503                        fcoe->netdev->name, fiphdr->version );
 504                 return -EINVAL;
 505         }
 506
 507         /* Check length */
 508         descs_len = ( ntohs ( fiphdr->len ) * 4 );
 509         if ( ( sizeof ( *fiphdr ) + descs_len ) > len ) {
 510                 DBGC ( fcoe, "FCoE %s received bad descriptor list length\n",
 511                        fcoe->netdev->name );
 512                 return -EINVAL;
 513         }
 514
 515         /* Parse descriptor list */
 516         memset ( descs, 0, sizeof ( *descs ) );
 517         for ( desc_offset = 0 ;
 518               desc_offset <= ( descs_len - sizeof ( desc->common ) ) ;
 519               desc_offset += desc_len ) {
 520
 521                 /* Find descriptor and validate length */
 522                 desc = ( ( ( void * ) ( fiphdr + 1 ) ) + desc_offset );
 523                 desc_type = desc->common.type;
 524                 desc_len = ( desc->common.len * 4 );
 525                 if ( desc_len == 0 ) {
 526                         DBGC ( fcoe, "FCoE %s received zero-length "
 527                                "descriptor\n", fcoe->netdev->name );
 528                         return -EINVAL;
 529                 }
 530                 if ( ( desc_offset + desc_len ) > descs_len ) {
 531                         DBGC ( fcoe, "FCoE %s descriptor overrun\n",
 532                                fcoe->netdev->name );
 533                         return -EINVAL;
 534                 }
 535
 536                 /* Handle descriptors that we understand */
 537                 if ( ( desc_type > FIP_RESERVED ) &&
 538                      ( desc_type < FIP_NUM_DESCRIPTOR_TYPES ) ) {
 539                         /* Use only the first instance of a descriptor */
 540                         if ( descs->desc[desc_type] == NULL )
 541                                 descs->desc[desc_type] = desc;
 542                         continue;
 543                 }
 544
 545                 /* Abort if we cannot understand a critical descriptor */
 546                 if ( FIP_IS_CRITICAL ( desc_type ) ) {
 547                         DBGC ( fcoe, "FCoE %s cannot understand critical "
 548                                "descriptor type %02x\n",
 549                                fcoe->netdev->name, desc_type );
 550                         return -ENOTSUP;
 551                 }
 552
 553                 /* Ignore non-critical descriptors that we cannot understand */
 554         }
 555
 556         return 0;
 557 }
 558
 559 /**
 560  * Send FIP VLAN request
 561  *
 562  * @v fcoe              FCoE port
 563  * @ret rc              Return status code
 564  */
 565 static int fcoe_fip_tx_vlan ( struct fcoe_port *fcoe ) {
 566         struct io_buffer *iobuf;
 567         struct {
 568                 struct fip_header hdr;
 569                 struct fip_mac_address mac_address;
 570         } __attribute__ (( packed )) *request;
 571         int rc;
 572
 573         /* Allocate I/O buffer */
 574         iobuf = alloc_iob ( MAX_LL_HEADER_LEN + sizeof ( *request ) );
 575         if ( ! iobuf )
 576                 return -ENOMEM;
 577         iob_reserve ( iobuf, MAX_LL_HEADER_LEN );
 578
 579         /* Construct VLAN request */
 580         request = iob_put ( iobuf, sizeof ( *request ) );
 581         memset ( request, 0, sizeof ( *request ) );
 582         request->hdr.version = FIP_VERSION;
 583         request->hdr.code = htons ( FIP_CODE_VLAN );
 584         request->hdr.subcode = FIP_VLAN_REQUEST;
 585         request->hdr.len = htons ( ( sizeof ( *request ) -
 586                                      sizeof ( request->hdr ) ) / 4 );
 587         request->mac_address.type = FIP_MAC_ADDRESS;
 588         request->mac_address.len =
 589                 ( sizeof ( request->mac_address ) / 4 );
 590         memcpy ( request->mac_address.mac, fcoe->netdev->ll_addr,
 591                  sizeof ( request->mac_address.mac ) );
 592
 593         /* Send VLAN request */
 594         if ( ( rc = net_tx ( iob_disown ( iobuf ), fcoe->netdev,
 595                              &fip_protocol, all_fcf_macs,
 596                              fcoe->netdev->ll_addr ) ) != 0 ) {
 597                 DBGC ( fcoe, "FCoE %s could not send VLAN request: "
 598                        "%s\n", fcoe->netdev->name, strerror ( rc ) );
 599                 return rc;
 600         }
 601
 602         return 0;
 603 }
 604
 605 /**
 606  * Handle received FIP VLAN notification
 607  *
 608  * @v fcoe              FCoE port
 609  * @v descs             Descriptor list
 610  * @v flags             Flags
 611  * @ret rc              Return status code
 612  */
 613 static int fcoe_fip_rx_vlan ( struct fcoe_port *fcoe,
 614                               struct fip_descriptors *descs,
 615                               unsigned int flags __unused ) {
 616         struct fip_mac_address *mac_address = fip_mac_address ( descs );
 617         struct fip_vlan *vlan = fip_vlan ( descs );
 618         unsigned int tag;
 619         int rc;
 620
 621         /* Sanity checks */
 622         if ( ! mac_address ) {
 623                 DBGC ( fcoe, "FCoE %s received VLAN notification missing MAC "
 624                        "address\n", fcoe->netdev->name );
 625                 return -EINVAL;
 626         }
 627         if ( ! vlan ) {
 628                 DBGC ( fcoe, "FCoE %s received VLAN notification missing VLAN "
 629                        "tag\n", fcoe->netdev->name );
 630                 return -EINVAL;
 631         }
 632
 633         /* Create VLAN */
 634         tag = ntohs ( vlan->vlan );
 635         DBGC ( fcoe, "FCoE %s creating VLAN %d for FCF %s\n",
 636                fcoe->netdev->name, tag, eth_ntoa ( mac_address->mac ) );
 637         if ( ( rc = vlan_create ( fcoe->netdev, tag,
 638                                   FCOE_VLAN_PRIORITY ) ) != 0 ) {
 639                 DBGC ( fcoe, "FCoE %s could not create VLAN %d: %s\n",
 640                        fcoe->netdev->name, tag, strerror ( rc ) );
 641                 return rc;
 642         }
 643
 644         /* Record that a VLAN was found.  This FCoE port will play no
 645          * further active role; the real FCoE traffic will use the
 646          * port automatically created for the new VLAN device.
 647          */
 648         fcoe->flags |= FCOE_VLAN_FOUND;
 649
 650         return 0;
 651 }
 652
 653 /**
 654  * Send FIP discovery solicitation
 655  *
 656  * @v fcoe              FCoE port
 657  * @ret rc              Return status code
 658  */
 659 static int fcoe_fip_tx_solicitation ( struct fcoe_port *fcoe ) {
 660         struct io_buffer *iobuf;
 661         struct {
 662                 struct fip_header hdr;
 663                 struct fip_mac_address mac_address;
 664                 struct fip_name_id name_id;
 665                 struct fip_max_fcoe_size max_fcoe_size;
 666         } __attribute__ (( packed )) *solicitation;
 667         int rc;
 668
 669         /* Allocate I/O buffer */
 670         iobuf = alloc_iob ( MAX_LL_HEADER_LEN + sizeof ( *solicitation ) );
 671         if ( ! iobuf )
 672                 return -ENOMEM;
 673         iob_reserve ( iobuf, MAX_LL_HEADER_LEN );
 674
 675         /* Construct discovery solicitation */
 676         solicitation = iob_put ( iobuf, sizeof ( *solicitation ) );
 677         memset ( solicitation, 0, sizeof ( *solicitation ) );
 678         solicitation->hdr.version = FIP_VERSION;
 679         solicitation->hdr.code = htons ( FIP_CODE_DISCOVERY );
 680         solicitation->hdr.subcode = FIP_DISCOVERY_SOLICIT;
 681         solicitation->hdr.len = htons ( ( sizeof ( *solicitation ) -
 682                                           sizeof ( solicitation->hdr ) ) / 4 );
 683         solicitation->hdr.flags = htons ( FIP_FP | FIP_SP );
 684         solicitation->mac_address.type = FIP_MAC_ADDRESS;
 685         solicitation->mac_address.len =
 686                 ( sizeof ( solicitation->mac_address ) / 4 );
 687         memcpy ( solicitation->mac_address.mac, fcoe->netdev->ll_addr,
 688                  sizeof ( solicitation->mac_address.mac ) );
 689         solicitation->name_id.type = FIP_NAME_ID;
 690         solicitation->name_id.len = ( sizeof ( solicitation->name_id ) / 4 );
 691         memcpy ( &solicitation->name_id.name, &fcoe->node_wwn.fc,
 692                  sizeof ( solicitation->name_id.name ) );
 693         solicitation->max_fcoe_size.type = FIP_MAX_FCOE_SIZE;
 694         solicitation->max_fcoe_size.len =
 695                 ( sizeof ( solicitation->max_fcoe_size ) / 4 );
 696         solicitation->max_fcoe_size.mtu =
 697                 htons ( ETH_MAX_MTU - sizeof ( struct fcoe_header ) -
 698                         sizeof ( struct fcoe_footer ) );
 699
 700         /* Send discovery solicitation */
 701         if ( ( rc = net_tx ( iob_disown ( iobuf ), fcoe->netdev,
 702                              &fip_protocol, all_fcf_macs,
 703                              fcoe->netdev->ll_addr ) ) != 0 ) {
 704                 DBGC ( fcoe, "FCoE %s could not send discovery solicitation: "
 705                        "%s\n", fcoe->netdev->name, strerror ( rc ) );
 706                 return rc;
 707         }
 708
 709         return 0;
 710 }
 711
 712 /**
 713  * Handle received FIP discovery advertisement
 714  *
 715  * @v fcoe              FCoE port
 716  * @v descs             Descriptor list
 717  * @v flags             Flags
 718  * @ret rc              Return status code
 719  */
 720 static int fcoe_fip_rx_advertisement ( struct fcoe_port *fcoe,
 721                                        struct fip_descriptors *descs,
 722                                        unsigned int flags ) {
 723         struct fip_priority *priority = fip_priority ( descs );
 724         struct fip_mac_address *mac_address = fip_mac_address ( descs );
 725         struct fip_fka_adv_p *fka_adv_p = fip_fka_adv_p ( descs );
 726
 727         /* Sanity checks */
 728         if ( ! priority ) {
 729                 DBGC ( fcoe, "FCoE %s received advertisement missing "
 730                        "priority\n", fcoe->netdev->name );
 731                 return -EINVAL;
 732         }
 733         if ( ! mac_address ) {
 734                 DBGC ( fcoe, "FCoE %s received advertisement missing MAC "
 735                        "address\n", fcoe->netdev->name );
 736                 return -EINVAL;
 737         }
 738         if ( ! fka_adv_p ) {
 739                 DBGC ( fcoe, "FCoE %s received advertisement missing FKA ADV "
 740                        "period\n", fcoe->netdev->name );
 741                 return -EINVAL;
 742         }
 743
 744         if ( ! ( fcoe->flags & FCOE_HAVE_FCF ) ) {
 745
 746                 /* We are soliciting for an FCF.  Store the highest
 747                  * (i.e. lowest-valued) priority solicited
 748                  * advertisement that we receive.
 749                  */
 750                 if ( ( ( flags & ( FIP_A | FIP_S | FIP_F ) ) ==
 751                        ( FIP_A | FIP_S | FIP_F ) ) &&
 752                      ( priority->priority < fcoe->priority ) ) {
 753
 754                         fcoe->flags |= FCOE_HAVE_FIP_FCF;
 755                         fcoe->priority = priority->priority;
 756                         if ( fka_adv_p->flags & FIP_NO_KEEPALIVE ) {
 757                                 fcoe->keepalive = 0;
 758                         } else {
 759                                 fcoe->keepalive = ntohl ( fka_adv_p->period );
 760                         }
 761                         fcoe->flags &= ~FCOE_FCF_ALLOWS_SPMA;
 762                         if ( flags & FIP_SP )
 763                                 fcoe->flags |= FCOE_FCF_ALLOWS_SPMA;
 764                         memcpy ( fcoe->fcf_mac, mac_address->mac,
 765                                  sizeof ( fcoe->fcf_mac ) );
 766                         DBGC ( fcoe, "FCoE %s selected FCF %s (pri %d",
 767                                fcoe->netdev->name, eth_ntoa ( fcoe->fcf_mac ),
 768                                fcoe->priority );
 769                         if ( fcoe->keepalive ) {
 770                                 DBGC ( fcoe, ", FKA ADV %dms",
 771                                        fcoe->keepalive );
 772                         }
 773                         DBGC ( fcoe, ", %cPMA)\n",
 774                                ( ( fcoe->flags & FCOE_FCF_ALLOWS_SPMA ) ?
 775                                  'S' : 'F' ) );
 776                 }
 777
 778         } else if ( fcoe->flags & FCOE_HAVE_FIP_FCF ) {
 779
 780                 /* We are checking that the FCF remains alive.  Reset
 781                  * the timeout counter if this is an advertisement
 782                  * from our forwarder.
 783                  */
 784                 if ( memcmp ( fcoe->fcf_mac, mac_address->mac,
 785                               sizeof ( fcoe->fcf_mac ) ) == 0 ) {
 786                         fcoe->timeouts = 0;
 787                 }
 788
 789         } else {
 790
 791                 /* We are operating in non-FIP mode and have received
 792                  * a FIP advertisement.  Reset the link in order to
 793                  * attempt FIP.
 794                  */
 795                 fcoe_reset ( fcoe );
 796
 797         }
 798
 799         return 0;
 800 }
 801
 802 /**
 803  * Handle received FIP ELS response
 804  *
 805  * @v fcoe              FCoE port
 806  * @v descs             Descriptor list
 807  * @v flags             Flags
 808  * @ret rc              Return status code
 809  */
 810 static int fcoe_fip_rx_els_response ( struct fcoe_port *fcoe,
 811                                       struct fip_descriptors *descs,
 812                                       unsigned int flags __unused ) {
 813         struct fip_els *flogi = fip_flogi ( descs );
 814         struct fip_mac_address *mac_address = fip_mac_address ( descs );
 815         void *frame;
 816         size_t frame_len;
 817         int rc;
 818
 819         /* Sanity checks */
 820         if ( ! flogi ) {
 821                 DBGC ( fcoe, "FCoE %s received ELS response missing FLOGI\n",
 822                        fcoe->netdev->name );
 823                 return -EINVAL;
 824         }
 825         if ( ! mac_address ) {
 826                 DBGC ( fcoe, "FCoE %s received ELS response missing MAC "
 827                        "address\n", fcoe->netdev->name );
 828                 return -EINVAL;
 829         }
 830
 831         /* Record local MAC address */
 832         memcpy ( fcoe->local_mac, mac_address->mac, sizeof ( fcoe->local_mac ));
 833         DBGC ( fcoe, "FCoE %s using local MAC %s\n",
 834                fcoe->netdev->name, eth_ntoa ( fcoe->local_mac ) );
 835
 836         /* Hand off via transport interface */
 837         frame = &flogi->fc;
 838         frame_len = ( ( flogi->len * 4 ) - offsetof ( typeof ( *flogi ), fc ) );
 839         if ( ( rc = xfer_deliver_raw ( &fcoe->transport, frame,
 840                                        frame_len ) ) != 0 ) {
 841                 DBGC ( fcoe, "FCoE %s could not deliver FIP FLOGI frame: %s\n",
 842                        fcoe->netdev->name, strerror ( rc ) );
 843                 return rc;
 844         }
 845
 846         return 0;
 847 }
 848
 849 /**
 850  * Send FIP keepalive
 851  *
 852  * @v fcoe              FCoE port
 853  * @ret rc              Return status code
 854  */
 855 static int fcoe_fip_tx_keepalive ( struct fcoe_port *fcoe ) {
 856         struct io_buffer *iobuf;
 857         struct {
 858                 struct fip_header hdr;
 859                 struct fip_mac_address mac_address;
 860         } __attribute__ (( packed )) *keepalive;
 861         int rc;
 862
 863         /* Allocate I/O buffer */
 864         iobuf = alloc_iob ( MAX_LL_HEADER_LEN + sizeof ( *keepalive ) );
 865         if ( ! iobuf )
 866                 return -ENOMEM;
 867         iob_reserve ( iobuf, MAX_LL_HEADER_LEN );
 868
 869         /* Construct keepalive */
 870         keepalive = iob_put ( iobuf, sizeof ( *keepalive ) );
 871         memset ( keepalive, 0, sizeof ( *keepalive ) );
 872         keepalive->hdr.version = FIP_VERSION;
 873         keepalive->hdr.code = htons ( FIP_CODE_MAINTAIN );
 874         keepalive->hdr.subcode = FIP_MAINTAIN_KEEP_ALIVE;
 875         keepalive->hdr.len =    htons ( ( sizeof ( *keepalive ) -
 876                                           sizeof ( keepalive->hdr ) ) / 4 );
 877         keepalive->mac_address.type = FIP_MAC_ADDRESS;
 878         keepalive->mac_address.len =
 879                 ( sizeof ( keepalive->mac_address ) / 4 );
 880         memcpy ( keepalive->mac_address.mac, fcoe->netdev->ll_addr,
 881                  sizeof ( keepalive->mac_address.mac ) );
 882
 883         /* Send keepalive */
 884         if ( ( rc = net_tx ( iob_disown ( iobuf ), fcoe->netdev,
 885                              &fip_protocol, fcoe->fcf_mac,
 886                              fcoe->netdev->ll_addr ) ) != 0 ) {
 887                 DBGC ( fcoe, "FCoE %s could not send keepalive: %s\n",
 888                        fcoe->netdev->name, strerror ( rc ) );
 889                 return rc;
 890         }
 891
 892         return 0;
 893 }
 894
 895 /** A FIP handler */
 896 struct fip_handler {
 897         /** Protocol code */
 898         uint16_t code;
 899         /** Protocol subcode */
 900         uint8_t subcode;
 901         /**
 902          * Receive FIP packet
 903          *
 904          * @v fcoe              FCoE port
 905          * @v descs             Descriptor list
 906          * @v flags             Flags
 907          * @ret rc              Return status code
 908          */
 909         int ( * rx ) ( struct fcoe_port *fcoe, struct fip_descriptors *descs,
 910                        unsigned int flags );
 911 };
 912
 913 /** FIP handlers */
 914 static struct fip_handler fip_handlers[] = {
 915         { FIP_CODE_VLAN, FIP_VLAN_NOTIFY,
 916           fcoe_fip_rx_vlan },
 917         { FIP_CODE_DISCOVERY, FIP_DISCOVERY_ADVERTISE,
 918           fcoe_fip_rx_advertisement },
 919         { FIP_CODE_ELS, FIP_ELS_RESPONSE,
 920           fcoe_fip_rx_els_response },
 921 };
 922
 923 /**
 924  * Process incoming FIP packets
 925  *
 926  * @v iobuf             I/O buffer
 927  * @v netdev            Network device
 928  * @v ll_dest           Link-layer destination address
 929  * @v ll_source         Link-layer source address
 930  * @v flags             Packet flags
 931  * @ret rc              Return status code
 932  */
 933 static int fcoe_fip_rx ( struct io_buffer *iobuf,
 934                          struct net_device *netdev,
 935                          const void *ll_dest,
 936                          const void *ll_source __unused,
 937                          unsigned int flags __unused ) {
 938         struct fip_header *fiphdr = iobuf->data;
 939         struct fip_descriptors descs;
 940         struct fip_handler *handler;
 941         struct fcoe_port *fcoe;
 942         unsigned int i;
 943         int rc;
 944
 945         /* Identify FCoE port */
 946         if ( ( fcoe = fcoe_demux ( netdev ) ) == NULL ) {
 947                 DBG ( "FCoE received FIP frame for net device %s missing FCoE "
 948                       "port\n", netdev->name );
 949                 rc = -ENOTCONN;
 950                 goto done;
 951         }
 952
 953         /* Discard packets not destined for us */
 954         if ( ( memcmp ( fcoe->netdev->ll_addr, ll_dest, ETH_ALEN ) != 0 ) &&
 955              ( memcmp ( all_fcoe_macs, ll_dest,
 956                         sizeof ( all_fcoe_macs ) ) != 0 ) &&
 957              ( memcmp ( all_enode_macs, ll_dest,
 958                         sizeof ( all_enode_macs ) ) != 0 ) ) {
 959                 DBGC2 ( fcoe, "FCoE %s ignoring FIP packet for %s\n",
 960                         fcoe->netdev->name, eth_ntoa ( ll_dest ) );
 961                 rc = -ENOTCONN;
 962                 goto done;
 963         }
 964
 965         /* Parse FIP packet */
 966         if ( ( rc = fcoe_fip_parse ( fcoe, fiphdr, iob_len ( iobuf ),
 967                                      &descs ) ) != 0 )
 968                 goto done;
 969
 970         /* Find a suitable handler */
 971         for ( i = 0 ; i < ( sizeof ( fip_handlers ) /
 972                             sizeof ( fip_handlers[0] ) ) ; i++ ) {
 973                 handler = &fip_handlers[i];
 974                 if ( ( handler->code == ntohs ( fiphdr->code ) ) &&
 975                      ( handler->subcode == fiphdr->subcode ) ) {
 976                         rc = handler->rx ( fcoe, &descs,
 977                                            ntohs ( fiphdr->flags ) );
 978                         goto done;
 979                 }
 980         }
 981         DBGC ( fcoe, "FCoE %s received unsupported FIP code %04x.%02x\n",
 982                fcoe->netdev->name, ntohs ( fiphdr->code ), fiphdr->subcode );
 983         rc = -ENOTSUP;
 984
 985  done:
 986         free_iob ( iobuf );
 987         return rc;
 988 }
 989
 990 /******************************************************************************
 991  *
 992  * FCoE ports
 993  *
 994  ******************************************************************************
 995  */
 996
 997 /**
 998  * Handle FCoE timer expiry
 999  *
1000  * @v timer             FIP timer
1001  * @v over              Timer expired
1002  */
1003 static void fcoe_expired ( struct retry_timer *timer, int over __unused ) {
1004         struct fcoe_port *fcoe =
1005                 container_of ( timer, struct fcoe_port, timer );
1006         int rc;
1007
1008         /* Sanity check */
1009         assert ( fcoe->flags & FCOE_HAVE_NETWORK );
1010
1011         /* Increment the timeout counter */
1012         fcoe->timeouts++;
1013
1014         if ( vlan_can_be_trunk ( fcoe->netdev ) &&
1015              ! ( fcoe->flags & FCOE_VLAN_TIMED_OUT ) ) {
1016
1017                 /* If we have already found a VLAN, send infrequent
1018                  * VLAN requests, in case VLAN information changes.
1019                  */
1020                 if ( fcoe->flags & FCOE_VLAN_FOUND ) {
1021                         fcoe->flags &= ~FCOE_VLAN_FOUND;
1022                         fcoe->timeouts = 0;
1023                         start_timer_fixed ( &fcoe->timer,
1024                                             FCOE_VLAN_POLL_DELAY );
1025                         fcoe_fip_tx_vlan ( fcoe );
1026                         return;
1027                 }
1028
1029                 /* If we have not yet found a VLAN, and we have not
1030                  * yet timed out and given up on finding one, then
1031                  * send a VLAN request and wait.
1032                  */
1033                 if ( fcoe->timeouts <= FCOE_MAX_VLAN_REQUESTS ) {
1034                         start_timer_fixed ( &fcoe->timer,
1035                                             FCOE_VLAN_RETRY_DELAY );
1036                         fcoe_fip_tx_vlan ( fcoe );
1037                         return;
1038                 }
1039
1040                 /* We have timed out waiting for a VLAN; proceed to
1041                  * FIP discovery.
1042                  */
1043                 fcoe->flags |= FCOE_VLAN_TIMED_OUT;
1044                 fcoe->timeouts = 0;
1045                 DBGC ( fcoe, "FCoE %s giving up on VLAN discovery\n",
1046                        fcoe->netdev->name );
1047                 start_timer_nodelay ( &fcoe->timer );
1048
1049         } else if ( ! ( fcoe->flags & FCOE_HAVE_FCF ) ) {
1050
1051                 /* If we have not yet found a FIP-capable forwarder,
1052                  * and we have not yet timed out and given up on
1053                  * finding one, then send a FIP solicitation and wait.
1054                  */
1055                 start_timer_fixed ( &fcoe->timer, FCOE_FIP_RETRY_DELAY );
1056                 if ( ( ! ( fcoe->flags & FCOE_HAVE_FIP_FCF ) ) &&
1057                      ( fcoe->timeouts <= FCOE_MAX_FIP_SOLICITATIONS ) ) {
1058                         fcoe_fip_tx_solicitation ( fcoe );
1059                         return;
1060                 }
1061
1062                 /* Attach Fibre Channel port */
1063                 if ( ( rc = fc_port_open ( &fcoe->transport, &fcoe->node_wwn.fc,
1064                                            &fcoe->port_wwn.fc,
1065                                            fcoe->netdev->name ) ) != 0 ) {
1066                         DBGC ( fcoe, "FCoE %s could not create FC port: %s\n",
1067                                fcoe->netdev->name, strerror ( rc ) );
1068                         /* We will try again on the next timer expiry */
1069                         return;
1070                 }
1071                 stop_timer ( &fcoe->timer );
1072
1073                 /* Either we have found a FIP-capable forwarder, or we
1074                  * have timed out and will fall back to pre-FIP mode.
1075                  */
1076                 fcoe->flags |= FCOE_HAVE_FCF;
1077                 fcoe->timeouts = 0;
1078                 DBGC ( fcoe, "FCoE %s using %sFIP FCF %s\n", fcoe->netdev->name,
1079                        ( ( fcoe->flags & FCOE_HAVE_FIP_FCF ) ? "" : "non-" ),
1080                        eth_ntoa ( fcoe->fcf_mac ) );
1081
1082                 /* Start sending keepalives if applicable */
1083                 if ( fcoe->keepalive )
1084                         start_timer_nodelay ( &fcoe->timer );
1085
1086                 /* Send notification of window change */
1087                 xfer_window_changed ( &fcoe->transport );
1088
1089         } else {
1090
1091                 /* Send keepalive */
1092                 start_timer_fixed ( &fcoe->timer,
1093                               ( ( fcoe->keepalive * TICKS_PER_SEC ) / 1000 ) );
1094                 fcoe_fip_tx_keepalive ( fcoe );
1095
1096                 /* Abandon FCF if we have not seen its advertisements */
1097                 if ( fcoe->timeouts > FCOE_MAX_FIP_MISSING_KEEPALIVES ) {
1098                         DBGC ( fcoe, "FCoE %s abandoning FCF %s\n",
1099                                fcoe->netdev->name, eth_ntoa ( fcoe->fcf_mac ));
1100                         fcoe_reset ( fcoe );
1101                 }
1102         }
1103 }
1104
1105 /**
1106  * Create FCoE port
1107  *
1108  * @v netdev            Network device
1109  * @ret rc              Return status code
1110  */
1111 static int fcoe_probe ( struct net_device *netdev ) {
1112         struct ll_protocol *ll_protocol = netdev->ll_protocol;
1113         struct fcoe_port *fcoe;
1114         int rc;
1115
1116         /* Sanity check */
1117         if ( ll_protocol->ll_proto != htons ( ARPHRD_ETHER ) ) {
1118                 /* Not an error; simply skip this net device */
1119                 DBG ( "FCoE skipping non-Ethernet device %s\n", netdev->name );
1120                 rc = 0;
1121                 goto err_non_ethernet;
1122         }
1123
1124         /* Allocate and initialise structure */
1125         fcoe = zalloc ( sizeof ( *fcoe ) );
1126         if ( ! fcoe ) {
1127                 rc = -ENOMEM;
1128                 goto err_zalloc;
1129         }
1130         ref_init ( &fcoe->refcnt, NULL );
1131         intf_init ( &fcoe->transport, &fcoe_transport_desc, &fcoe->refcnt );
1132         timer_init ( &fcoe->timer, fcoe_expired, &fcoe->refcnt );
1133         fcoe->netdev = netdev_get ( netdev );
1134
1135         /* Construct node and port names */
1136         fcoe->node_wwn.fcoe.authority = htons ( FCOE_AUTHORITY_IEEE );
1137         memcpy ( &fcoe->node_wwn.fcoe.mac, netdev->ll_addr,
1138                  sizeof ( fcoe->node_wwn.fcoe.mac ) );
1139         fcoe->port_wwn.fcoe.authority = htons ( FCOE_AUTHORITY_IEEE_EXTENDED );
1140         memcpy ( &fcoe->port_wwn.fcoe.mac, netdev->ll_addr,
1141                  sizeof ( fcoe->port_wwn.fcoe.mac ) );
1142
1143         DBGC ( fcoe, "FCoE %s is %s", fcoe->netdev->name,
1144                fc_ntoa ( &fcoe->node_wwn.fc ) );
1145         DBGC ( fcoe, " port %s\n", fc_ntoa ( &fcoe->port_wwn.fc ) );
1146
1147         /* Transfer reference to port list */
1148         list_add ( &fcoe->list, &fcoe_ports );
1149         return 0;
1150
1151         netdev_put ( fcoe->netdev );
1152  err_zalloc:
1153  err_non_ethernet:
1154         return rc;
1155 }
1156
1157 /**
1158  * Handle FCoE port device or link state change
1159  *
1160  * @v netdev            Network device
1161  */
1162 static void fcoe_notify ( struct net_device *netdev ) {
1163         struct fcoe_port *fcoe;
1164
1165         /* Sanity check */
1166         if ( ( fcoe = fcoe_demux ( netdev ) ) == NULL ) {
1167                 DBG ( "FCoE notification for net device %s missing FCoE "
1168                       "port\n", netdev->name );
1169                 return;
1170         }
1171
1172         /* Reset the FCoE link if necessary */
1173         if ( ! ( netdev_is_open ( netdev ) &&
1174                  netdev_link_ok ( netdev ) &&
1175                  ( fcoe->flags & FCOE_HAVE_NETWORK ) ) ) {
1176                 fcoe_reset ( fcoe );
1177         }
1178 }
1179
1180 /**
1181  * Destroy FCoE port
1182  *
1183  * @v netdev            Network device
1184  */
1185 static void fcoe_remove ( struct net_device *netdev ) {
1186         struct fcoe_port *fcoe;
1187
1188         /* Sanity check */
1189         if ( ( fcoe = fcoe_demux ( netdev ) ) == NULL ) {
1190                 DBG ( "FCoE removal of net device %s missing FCoE port\n",
1191                       netdev->name );
1192                 return;
1193         }
1194
1195         /* Close FCoE device */
1196         fcoe_close ( fcoe, 0 );
1197 }
1198
1199 /** FCoE driver */
1200 struct net_driver fcoe_driver __net_driver = {
1201         .name = "FCoE",
1202         .probe = fcoe_probe,
1203         .notify = fcoe_notify,
1204         .remove = fcoe_remove,
1205 };
1206
1207 /** FCoE protocol */
1208 struct net_protocol fcoe_protocol __net_protocol = {
1209         .name = "FCoE",
1210         .net_proto = htons ( ETH_P_FCOE ),
1211         .rx = fcoe_rx,
1212 };
1213
1214 /** FIP protocol */
1215 struct net_protocol fip_protocol __net_protocol = {
1216         .name = "FIP",
1217         .net_proto = htons ( ETH_P_FIP ),
1218         .rx = fcoe_fip_rx,
1219 };
1220
1221 /** Human-readable message for CRC errors
1222  *
1223  * It seems as though several drivers neglect to strip the Ethernet
1224  * CRC, which will cause the FCoE footer to be misplaced and result
1225  * (coincidentally) in an "invalid CRC" error from FCoE.
1226  */
1227 struct errortab fcoe_errors[] __errortab = {
1228         __einfo_errortab ( EINFO_EINVAL_CRC ),
1229 };