src/drivers/net/phantom/phantom.c

   1 /*
   2  * Copyright (C) 2008 Michael Brown <mbrown@fensystems.co.uk>.
   3  * Copyright (C) 2008 NetXen, Inc.
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation; either version 2 of the
   8  * License, or any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19
  20 #include <stdint.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <unistd.h>
  24 #include <errno.h>
  25 #include <assert.h>
  26 #include <byteswap.h>
  27 #include <gpxe/pci.h>
  28 #include <gpxe/io.h>
  29 #include <gpxe/malloc.h>
  30 #include <gpxe/iobuf.h>
  31 #include <gpxe/netdevice.h>
  32 #include <gpxe/if_ether.h>
  33 #include <gpxe/ethernet.h>
  34 #include <gpxe/spi.h>
  35 #include <gpxe/settings.h>
  36 #include "phantom.h"
  37
  38 /**
  39  * @file
  40  *
  41  * NetXen Phantom NICs
  42  *
  43  */
  44
  45 /** Maximum time to wait for SPI lock */
  46 #define PHN_SPI_LOCK_TIMEOUT_MS 100
  47
  48 /** Maximum time to wait for SPI command to be issued */
  49 #define PHN_SPI_CMD_TIMEOUT_MS 100
  50
  51 /** Maximum time to wait for command PEG to initialise
  52  *
  53  * BUGxxxx
  54  *
  55  * The command PEG will currently report initialisation complete only
  56  * when at least one PHY has detected a link (so that the global PHY
  57  * clock can be set to 10G/1G as appropriate).  This can take a very,
  58  * very long time.
  59  *
  60  * A future firmware revision should decouple PHY initialisation from
  61  * firmware initialisation, at which point the command PEG will report
  62  * initialisation complete much earlier, and this timeout can be
  63  * reduced.
  64  */
  65 #define PHN_CMDPEG_INIT_TIMEOUT_SEC 50
  66
  67 /** Maximum time to wait for receive PEG to initialise */
  68 #define PHN_RCVPEG_INIT_TIMEOUT_SEC 2
  69
  70 /** Maximum time to wait for firmware to accept a command */
  71 #define PHN_ISSUE_CMD_TIMEOUT_MS 2000
  72
  73 /** Maximum time to wait for test memory */
  74 #define PHN_TEST_MEM_TIMEOUT_MS 100
  75
  76 /** Maximum time to wait for CLP command to be issued */
  77 #define PHN_CLP_CMD_TIMEOUT_MS 500
  78
  79 /** Link state poll frequency
  80  *
  81  * The link state will be checked once in every N calls to poll().
  82  */
  83 #define PHN_LINK_POLL_FREQUENCY 4096
  84
  85 /** Number of RX descriptors */
  86 #define PHN_NUM_RDS 32
  87
  88 /** RX maximum fill level.  Must be strictly less than PHN_NUM_RDS. */
  89 #define PHN_RDS_MAX_FILL 16
  90
  91 /** RX buffer size */
  92 #define PHN_RX_BUFSIZE ( 32 /* max LL padding added by card */ + \
  93                          ETH_FRAME_LEN )
  94
  95 /** Number of RX status descriptors */
  96 #define PHN_NUM_SDS 32
  97
  98 /** Number of TX descriptors */
  99 #define PHN_NUM_CDS 8
 100
 101 /** A Phantom descriptor ring set */
 102 struct phantom_descriptor_rings {
 103         /** RX descriptors */
 104         struct phantom_rds rds[PHN_NUM_RDS];
 105         /** RX status descriptors */
 106         struct phantom_sds sds[PHN_NUM_SDS];
 107         /** TX descriptors */
 108         union phantom_cds cds[PHN_NUM_CDS];
 109         /** TX consumer index */
 110         volatile uint32_t cmd_cons;
 111 };
 112
 113 /** A Phantom NIC port */
 114 struct phantom_nic_port {
 115         /** Phantom NIC containing this port */
 116         struct phantom_nic *phantom;
 117         /** Port number */
 118         unsigned int port;
 119
 120
 121         /** RX context ID */
 122         uint16_t rx_context_id;
 123         /** RX descriptor producer CRB offset */
 124         unsigned long rds_producer_crb;
 125         /** RX status descriptor consumer CRB offset */
 126         unsigned long sds_consumer_crb;
 127
 128         /** RX producer index */
 129         unsigned int rds_producer_idx;
 130         /** RX consumer index */
 131         unsigned int rds_consumer_idx;
 132         /** RX status consumer index */
 133         unsigned int sds_consumer_idx;
 134         /** RX I/O buffers */
 135         struct io_buffer *rds_iobuf[PHN_RDS_MAX_FILL];
 136
 137
 138         /** TX context ID */
 139         uint16_t tx_context_id;
 140         /** TX descriptor producer CRB offset */
 141         unsigned long cds_producer_crb;
 142
 143         /** TX producer index */
 144         unsigned int cds_producer_idx;
 145         /** TX consumer index */
 146         unsigned int cds_consumer_idx;
 147         /** TX I/O buffers */
 148         struct io_buffer *cds_iobuf[PHN_NUM_CDS];
 149
 150
 151         /** Link state poll timer */
 152         unsigned long link_poll_timer;
 153
 154
 155         /** Descriptor rings */
 156         struct phantom_descriptor_rings *desc;
 157
 158         /** Non-volatile settings */
 159         struct settings settings;
 160 };
 161
 162 /** RX context creation request and response buffers */
 163 struct phantom_create_rx_ctx_rqrsp {
 164         struct {
 165                 struct nx_hostrq_rx_ctx_s rx_ctx;
 166                 struct nx_hostrq_rds_ring_s rds;
 167                 struct nx_hostrq_sds_ring_s sds;
 168         } __unm_dma_aligned hostrq;
 169         struct {
 170                 struct nx_cardrsp_rx_ctx_s rx_ctx;
 171                 struct nx_cardrsp_rds_ring_s rds;
 172                 struct nx_cardrsp_sds_ring_s sds;
 173         } __unm_dma_aligned cardrsp;
 174 };
 175
 176 /** TX context creation request and response buffers */
 177 struct phantom_create_tx_ctx_rqrsp {
 178         struct {
 179                 struct nx_hostrq_tx_ctx_s tx_ctx;
 180         } __unm_dma_aligned hostrq;
 181         struct {
 182                 struct nx_cardrsp_tx_ctx_s tx_ctx;
 183         } __unm_dma_aligned cardrsp;
 184 };
 185
 186 /** A Phantom DMA buffer area */
 187 union phantom_dma_buffer {
 188         /** Dummy area required for (read-only) self-tests */
 189         uint8_t dummy_dma[UNM_DUMMY_DMA_SIZE];
 190         /** RX context creation request and response buffers */
 191         struct phantom_create_rx_ctx_rqrsp create_rx_ctx;
 192         /** TX context creation request and response buffers */
 193         struct phantom_create_tx_ctx_rqrsp create_tx_ctx;
 194 };
 195
 196 /** A Phantom NIC */
 197 struct phantom_nic {
 198         /** BAR 0 */
 199         void *bar0;
 200         /** Current CRB window */
 201         unsigned long crb_window;
 202         /** CRB window access method */
 203         unsigned long ( *crb_access ) ( struct phantom_nic *phantom,
 204                                         unsigned long reg );
 205
 206         /** Number of ports */
 207         int num_ports;
 208         /** Per-port network devices */
 209         struct net_device *netdev[UNM_FLASH_NUM_PORTS];
 210
 211         /** DMA buffers */
 212         union phantom_dma_buffer *dma_buf;
 213
 214         /** Flash memory SPI bus */
 215         struct spi_bus spi_bus;
 216         /** Flash memory SPI device */
 217         struct spi_device flash;
 218
 219         /** Last known link state */
 220         uint32_t link_state;
 221 };
 222
 223 /***************************************************************************
 224  *
 225  * CRB register access
 226  *
 227  */
 228
 229 /**
 230  * Prepare for access to CRB register via 128MB BAR
 231  *
 232  * @v phantom           Phantom NIC
 233  * @v reg               Register offset within abstract address space
 234  * @ret offset          Register offset within PCI BAR0
 235  */
 236 static unsigned long phantom_crb_access_128m ( struct phantom_nic *phantom,
 237                                                unsigned long reg ) {
 238         unsigned long offset = ( 0x6000000 + ( reg & 0x1ffffff ) );
 239         uint32_t window = ( reg & 0x2000000 );
 240         uint32_t verify_window;
 241
 242         if ( phantom->crb_window != window ) {
 243
 244                 /* Write to the CRB window register */
 245                 writel ( window, phantom->bar0 + UNM_128M_CRB_WINDOW );
 246
 247                 /* Ensure that the write has reached the card */
 248                 verify_window = readl ( phantom->bar0 + UNM_128M_CRB_WINDOW );
 249                 assert ( verify_window == window );
 250
 251                 /* Record new window */
 252                 phantom->crb_window = window;
 253         }
 254
 255         return offset;
 256 }
 257
 258 /**
 259  * Prepare for access to CRB register via 32MB BAR
 260  *
 261  * @v phantom           Phantom NIC
 262  * @v reg               Register offset within abstract address space
 263  * @ret offset          Register offset within PCI BAR0
 264  */
 265 static unsigned long phantom_crb_access_32m ( struct phantom_nic *phantom,
 266                                               unsigned long reg ) {
 267         unsigned long offset = ( reg & 0x1ffffff );
 268         uint32_t window = ( reg & 0x2000000 );
 269         uint32_t verify_window;
 270
 271         if ( phantom->crb_window != window ) {
 272
 273                 /* Write to the CRB window register */
 274                 writel ( window, phantom->bar0 + UNM_32M_CRB_WINDOW );
 275
 276                 /* Ensure that the write has reached the card */
 277                 verify_window = readl ( phantom->bar0 + UNM_32M_CRB_WINDOW );
 278                 assert ( verify_window == window );
 279
 280                 /* Record new window */
 281                 phantom->crb_window = window;
 282         }
 283
 284         return offset;
 285 }
 286
 287 /**
 288  * Prepare for access to CRB register via 2MB BAR
 289  *
 290  * @v phantom           Phantom NIC
 291  * @v reg               Register offset within abstract address space
 292  * @ret offset          Register offset within PCI BAR0
 293  */
 294 static unsigned long phantom_crb_access_2m ( struct phantom_nic *phantom,
 295                                              unsigned long reg ) {
 296         static const struct {
 297                 uint8_t block;
 298                 uint16_t window_hi;
 299         } reg_window_hi[] = {
 300                 { UNM_CRB_BLK_PCIE,     0x773 },
 301                 { UNM_CRB_BLK_CAM,      0x416 },
 302                 { UNM_CRB_BLK_ROMUSB,   0x421 },
 303                 { UNM_CRB_BLK_TEST,     0x295 },
 304                 { UNM_CRB_BLK_PEG_0,    0x340 },
 305                 { UNM_CRB_BLK_PEG_1,    0x341 },
 306                 { UNM_CRB_BLK_PEG_2,    0x342 },
 307                 { UNM_CRB_BLK_PEG_3,    0x343 },
 308                 { UNM_CRB_BLK_PEG_4,    0x34b },
 309         };
 310         unsigned int block = UNM_CRB_BLK ( reg );
 311         unsigned long offset = UNM_CRB_OFFSET ( reg );
 312         uint32_t window;
 313         uint32_t verify_window;
 314         unsigned int i;
 315
 316         for ( i = 0 ; i < ( sizeof ( reg_window_hi ) /
 317                             sizeof ( reg_window_hi[0] ) ) ; i++ ) {
 318
 319                 if ( reg_window_hi[i].block != block )
 320                         continue;
 321
 322                 window = ( ( reg_window_hi[i].window_hi << 20 ) |
 323                            ( offset & 0x000f0000 ) );
 324
 325                 if ( phantom->crb_window != window ) {
 326
 327                         /* Write to the CRB window register */
 328                         writel ( window, phantom->bar0 + UNM_2M_CRB_WINDOW );
 329
 330                         /* Ensure that the write has reached the card */
 331                         verify_window = readl ( phantom->bar0 +
 332                                                 UNM_2M_CRB_WINDOW );
 333                         assert ( verify_window == window );
 334
 335                         /* Record new window */
 336                         phantom->crb_window = window;
 337                 }
 338
 339                 return ( 0x1e0000 + ( offset & 0xffff ) );
 340         }
 341
 342         assert ( 0 );
 343         return 0;
 344 }
 345
 346 /**
 347  * Read from Phantom CRB register
 348  *
 349  * @v phantom           Phantom NIC
 350  * @v reg               Register offset within abstract address space
 351  * @ret value           Register value
 352  */
 353 static uint32_t phantom_readl ( struct phantom_nic *phantom,
 354                                 unsigned long reg ) {
 355         unsigned long offset;
 356
 357         offset = phantom->crb_access ( phantom, reg );
 358         return readl ( phantom->bar0 + offset );
 359 }
 360
 361 /**
 362  * Write to Phantom CRB register
 363  *
 364  * @v phantom           Phantom NIC
 365  * @v value             Register value
 366  * @v reg               Register offset within abstract address space
 367  */
 368 static void phantom_writel ( struct phantom_nic *phantom, uint32_t value,
 369                              unsigned long reg ) {
 370         unsigned long offset;
 371
 372         offset = phantom->crb_access ( phantom, reg );
 373         writel ( value, phantom->bar0 + offset );
 374 }
 375
 376 /**
 377  * Write to Phantom CRB HI/LO register pair
 378  *
 379  * @v phantom           Phantom NIC
 380  * @v value             Register value
 381  * @v lo_offset         LO register offset within CRB
 382  * @v hi_offset         HI register offset within CRB
 383  */
 384 static inline void phantom_write_hilo ( struct phantom_nic *phantom,
 385                                         uint64_t value,
 386                                         unsigned long lo_offset,
 387                                         unsigned long hi_offset ) {
 388         uint32_t lo = ( value & 0xffffffffUL );
 389         uint32_t hi = ( value >> 32 );
 390
 391         phantom_writel ( phantom, lo, lo_offset );
 392         phantom_writel ( phantom, hi, hi_offset );
 393 }
 394
 395 /***************************************************************************
 396  *
 397  * Firmware message buffer access (for debug)
 398  *
 399  */
 400
 401 /**
 402  * Read from Phantom test memory
 403  *
 404  * @v phantom           Phantom NIC
 405  * @v offset            Offset within test memory
 406  * @v buf               8-byte buffer to fill
 407  * @ret rc              Return status code
 408  */
 409 static int phantom_read_test_mem_block ( struct phantom_nic *phantom,
 410                                          unsigned long offset,
 411                                          uint32_t buf[2] ) {
 412         unsigned int retries;
 413         uint32_t test_control;
 414
 415         phantom_write_hilo ( phantom, offset, UNM_TEST_ADDR_LO,
 416                              UNM_TEST_ADDR_HI );
 417         phantom_writel ( phantom, UNM_TEST_CONTROL_ENABLE, UNM_TEST_CONTROL );
 418         phantom_writel ( phantom,
 419                          ( UNM_TEST_CONTROL_ENABLE | UNM_TEST_CONTROL_START ),
 420                          UNM_TEST_CONTROL );
 421
 422         for ( retries = 0 ; retries < PHN_TEST_MEM_TIMEOUT_MS ; retries++ ) {
 423                 test_control = phantom_readl ( phantom, UNM_TEST_CONTROL );
 424                 if ( ( test_control & UNM_TEST_CONTROL_BUSY ) == 0 ) {
 425                         buf[0] = phantom_readl ( phantom, UNM_TEST_RDDATA_LO );
 426                         buf[1] = phantom_readl ( phantom, UNM_TEST_RDDATA_HI );
 427                         return 0;
 428                 }
 429                 mdelay ( 1 );
 430         }
 431
 432         DBGC ( phantom, "Phantom %p timed out waiting for test memory\n",
 433                phantom );
 434         return -ETIMEDOUT;
 435 }
 436
 437 /**
 438  * Read single byte from Phantom test memory
 439  *
 440  * @v phantom           Phantom NIC
 441  * @v offset            Offset within test memory
 442  * @ret byte            Byte read, or negative error
 443  */
 444 static int phantom_read_test_mem ( struct phantom_nic *phantom,
 445                                    unsigned long offset ) {
 446         static union {
 447                 uint8_t bytes[8];
 448                 uint32_t dwords[2];
 449         } cache;
 450         static unsigned long cache_offset = -1UL;
 451         unsigned long sub_offset;
 452         int rc;
 453
 454         sub_offset = ( offset & ( sizeof ( cache ) - 1 ) );
 455         offset = ( offset & ~( sizeof ( cache ) - 1 ) );
 456
 457         if ( cache_offset != offset ) {
 458                 if ( ( rc = phantom_read_test_mem_block ( phantom, offset,
 459                                                           cache.dwords )) !=0 )
 460                         return rc;
 461                 cache_offset = offset;
 462         }
 463
 464         return cache.bytes[sub_offset];
 465 }
 466
 467 /**
 468  * Dump Phantom firmware dmesg log
 469  *
 470  * @v phantom           Phantom NIC
 471  * @v log               Log number
 472  * @v max_lines         Maximum number of lines to show, or -1 to show all
 473  * @ret rc              Return status code
 474  */
 475 static int phantom_dmesg ( struct phantom_nic *phantom, unsigned int log,
 476                             unsigned int max_lines ) {
 477         uint32_t head;
 478         uint32_t tail;
 479         uint32_t len;
 480         uint32_t sig;
 481         uint32_t offset;
 482         int byte;
 483
 484         /* Optimise out for non-debug builds */
 485         if ( ! DBG_LOG )
 486                 return 0;
 487
 488         /* Locate log */
 489         head = phantom_readl ( phantom, UNM_CAM_RAM_DMESG_HEAD ( log ) );
 490         len = phantom_readl ( phantom, UNM_CAM_RAM_DMESG_LEN ( log ) );
 491         tail = phantom_readl ( phantom, UNM_CAM_RAM_DMESG_TAIL ( log ) );
 492         sig = phantom_readl ( phantom, UNM_CAM_RAM_DMESG_SIG ( log ) );
 493         DBGC ( phantom, "Phantom %p firmware dmesg buffer %d (%08lx-%08lx)\n",
 494                phantom, log, head, tail );
 495         assert ( ( head & 0x07 ) == 0 );
 496         if ( sig != UNM_CAM_RAM_DMESG_SIG_MAGIC ) {
 497                 DBGC ( phantom, "Warning: bad signature %08lx (want %08lx)\n",
 498                        sig, UNM_CAM_RAM_DMESG_SIG_MAGIC );
 499         }
 500
 501         /* Locate start of last (max_lines) lines */
 502         for ( offset = tail ; offset > head ; offset-- ) {
 503                 if ( ( byte = phantom_read_test_mem ( phantom,
 504                                                       ( offset - 1 ) ) ) < 0 )
 505                         return byte;
 506                 if ( ( byte == '\n' ) && ( max_lines-- == 0 ) )
 507                         break;
 508         }
 509
 510         /* Print lines */
 511         for ( ; offset < tail ; offset++ ) {
 512                 if ( ( byte = phantom_read_test_mem ( phantom, offset ) ) < 0 )
 513                         return byte;
 514                 DBG ( "%c", byte );
 515         }
 516         DBG ( "\n" );
 517         return 0;
 518 }
 519
 520 /**
 521  * Dump Phantom firmware dmesg logs
 522  *
 523  * @v phantom           Phantom NIC
 524  * @v max_lines         Maximum number of lines to show, or -1 to show all
 525  */
 526 static void __attribute__ (( unused ))
 527 phantom_dmesg_all ( struct phantom_nic *phantom, unsigned int max_lines ) {
 528         unsigned int i;
 529
 530         for ( i = 0 ; i < UNM_CAM_RAM_NUM_DMESG_BUFFERS ; i++ )
 531                 phantom_dmesg ( phantom, i, max_lines );
 532 }
 533
 534 /***************************************************************************
 535  *
 536  * SPI bus access (for flash memory)
 537  *
 538  */
 539
 540 /**
 541  * Acquire Phantom SPI lock
 542  *
 543  * @v phantom           Phantom NIC
 544  * @ret rc              Return status code
 545  */
 546 static int phantom_spi_lock ( struct phantom_nic *phantom ) {
 547         unsigned int retries;
 548         uint32_t pcie_sem2_lock;
 549
 550         for ( retries = 0 ; retries < PHN_SPI_LOCK_TIMEOUT_MS ; retries++ ) {
 551                 pcie_sem2_lock = phantom_readl ( phantom, UNM_PCIE_SEM2_LOCK );
 552                 if ( pcie_sem2_lock != 0 )
 553                         return 0;
 554                 mdelay ( 1 );
 555         }
 556
 557         DBGC ( phantom, "Phantom %p timed out waiting for SPI lock\n",
 558                phantom );
 559         return -ETIMEDOUT;
 560 }
 561
 562 /**
 563  * Wait for Phantom SPI command to complete
 564  *
 565  * @v phantom           Phantom NIC
 566  * @ret rc              Return status code
 567  */
 568 static int phantom_spi_wait ( struct phantom_nic *phantom ) {
 569         unsigned int retries;
 570         uint32_t glb_status;
 571
 572         for ( retries = 0 ; retries < PHN_SPI_CMD_TIMEOUT_MS ; retries++ ) {
 573                 glb_status = phantom_readl ( phantom, UNM_ROMUSB_GLB_STATUS );
 574                 if ( glb_status & UNM_ROMUSB_GLB_STATUS_ROM_DONE )
 575                         return 0;
 576                 mdelay ( 1 );
 577         }
 578
 579         DBGC ( phantom, "Phantom %p timed out waiting for SPI command\n",
 580                phantom );
 581         return -ETIMEDOUT;
 582 }
 583
 584 /**
 585  * Release Phantom SPI lock
 586  *
 587  * @v phantom           Phantom NIC
 588  */
 589 static void phantom_spi_unlock ( struct phantom_nic *phantom ) {
 590         phantom_readl ( phantom, UNM_PCIE_SEM2_UNLOCK );
 591 }
 592
 593 /**
 594  * Read/write data via Phantom SPI bus
 595  *
 596  * @v bus               SPI bus
 597  * @v device            SPI device
 598  * @v command           Command
 599  * @v address           Address to read/write (<0 for no address)
 600  * @v data_out          TX data buffer (or NULL)
 601  * @v data_in           RX data buffer (or NULL)
 602  * @v len               Length of data buffer(s)
 603  * @ret rc              Return status code
 604  */
 605 static int phantom_spi_rw ( struct spi_bus *bus,
 606                             struct spi_device *device,
 607                             unsigned int command, int address,
 608                             const void *data_out, void *data_in,
 609                             size_t len ) {
 610         struct phantom_nic *phantom =
 611                 container_of ( bus, struct phantom_nic, spi_bus );
 612         uint32_t data;
 613         int rc;
 614
 615         DBGCP ( phantom, "Phantom %p SPI command %x at %x+%zx\n",
 616                 phantom, command, address, len );
 617         if ( data_out )
 618                 DBGCP_HDA ( phantom, address, data_out, len );
 619
 620         /* We support only exactly 4-byte reads */
 621         if ( len != UNM_SPI_BLKSIZE ) {
 622                 DBGC ( phantom, "Phantom %p invalid SPI length %zx\n",
 623                        phantom, len );
 624                 return -EINVAL;
 625         }
 626
 627         /* Acquire SPI lock */
 628         if ( ( rc = phantom_spi_lock ( phantom ) ) != 0 )
 629                 goto err_lock;
 630
 631         /* Issue SPI command as per the PRM */
 632         if ( data_out ) {
 633                 memcpy ( &data, data_out, sizeof ( data ) );
 634                 phantom_writel ( phantom, data, UNM_ROMUSB_ROM_WDATA );
 635         }
 636         phantom_writel ( phantom, address, UNM_ROMUSB_ROM_ADDRESS );
 637         phantom_writel ( phantom, ( device->address_len / 8 ),
 638                          UNM_ROMUSB_ROM_ABYTE_CNT );
 639         udelay ( 100 ); /* according to PRM */
 640         phantom_writel ( phantom, 0, UNM_ROMUSB_ROM_DUMMY_BYTE_CNT );
 641         phantom_writel ( phantom, command, UNM_ROMUSB_ROM_INSTR_OPCODE );
 642
 643         /* Wait for SPI command to complete */
 644         if ( ( rc = phantom_spi_wait ( phantom ) ) != 0 )
 645                 goto err_wait;
 646
 647         /* Reset address byte count and dummy byte count, because the
 648          * PRM asks us to.
 649          */
 650         phantom_writel ( phantom, 0, UNM_ROMUSB_ROM_ABYTE_CNT );
 651         udelay ( 100 ); /* according to PRM */
 652         phantom_writel ( phantom, 0, UNM_ROMUSB_ROM_DUMMY_BYTE_CNT );
 653
 654         /* Read data, if applicable */
 655         if ( data_in ) {
 656                 data = phantom_readl ( phantom, UNM_ROMUSB_ROM_RDATA );
 657                 memcpy ( data_in, &data, sizeof ( data ) );
 658                 DBGCP_HDA ( phantom, address, data_in, len );
 659         }
 660
 661  err_wait:
 662         phantom_spi_unlock ( phantom );
 663  err_lock:
 664         return rc;
 665 }
 666
 667 /***************************************************************************
 668  *
 669  * Firmware interface
 670  *
 671  */
 672
 673 /**
 674  * Wait for firmware to accept command
 675  *
 676  * @v phantom           Phantom NIC
 677  * @ret rc              Return status code
 678  */
 679 static int phantom_wait_for_cmd ( struct phantom_nic *phantom ) {
 680         unsigned int retries;
 681         uint32_t cdrp;
 682
 683         for ( retries = 0 ; retries < PHN_ISSUE_CMD_TIMEOUT_MS ; retries++ ) {
 684                 mdelay ( 1 );
 685                 cdrp = phantom_readl ( phantom, UNM_NIC_REG_NX_CDRP );
 686                 if ( NX_CDRP_IS_RSP ( cdrp ) ) {
 687                         switch ( NX_CDRP_FORM_RSP ( cdrp ) ) {
 688                         case NX_CDRP_RSP_OK:
 689                                 return 0;
 690                         case NX_CDRP_RSP_FAIL:
 691                                 return -EIO;
 692                         case NX_CDRP_RSP_TIMEOUT:
 693                                 return -ETIMEDOUT;
 694                         default:
 695                                 return -EPROTO;
 696                         }
 697                 }
 698         }
 699
 700         DBGC ( phantom, "Phantom %p timed out waiting for firmware to accept "
 701                "command\n", phantom );
 702         return -ETIMEDOUT;
 703 }
 704
 705 /**
 706  * Issue command to firmware
 707  *
 708  * @v phantom_port      Phantom NIC port
 709  * @v command           Firmware command
 710  * @v arg1              Argument 1
 711  * @v arg2              Argument 2
 712  * @v arg3              Argument 3
 713  * @ret rc              Return status code
 714  */
 715 static int phantom_issue_cmd ( struct phantom_nic_port *phantom_port,
 716                                uint32_t command, uint32_t arg1, uint32_t arg2,
 717                                uint32_t arg3 ) {
 718         struct phantom_nic *phantom = phantom_port->phantom;
 719         uint32_t signature;
 720         int rc;
 721
 722         /* Issue command */
 723         signature = NX_CDRP_SIGNATURE_MAKE ( phantom_port->port,
 724                                              NXHAL_VERSION );
 725         DBGC2 ( phantom, "Phantom %p port %d issuing command %08lx (%08lx, "
 726                 "%08lx, %08lx)\n", phantom, phantom_port->port,
 727                 command, arg1, arg2, arg3 );
 728         phantom_writel ( phantom, signature, UNM_NIC_REG_NX_SIGN );
 729         phantom_writel ( phantom, arg1, UNM_NIC_REG_NX_ARG1 );
 730         phantom_writel ( phantom, arg2, UNM_NIC_REG_NX_ARG2 );
 731         phantom_writel ( phantom, arg3, UNM_NIC_REG_NX_ARG3 );
 732         phantom_writel ( phantom, NX_CDRP_FORM_CMD ( command ),
 733                          UNM_NIC_REG_NX_CDRP );
 734
 735         /* Wait for command to be accepted */
 736         if ( ( rc = phantom_wait_for_cmd ( phantom ) ) != 0 ) {
 737                 DBGC ( phantom, "Phantom %p could not issue command: %s\n",
 738                        phantom, strerror ( rc ) );
 739                 return rc;
 740         }
 741
 742         return 0;
 743 }
 744
 745 /**
 746  * Issue buffer-format command to firmware
 747  *
 748  * @v phantom_port      Phantom NIC port
 749  * @v command           Firmware command
 750  * @v buffer            Buffer to pass to firmware
 751  * @v len               Length of buffer
 752  * @ret rc              Return status code
 753  */
 754 static int phantom_issue_buf_cmd ( struct phantom_nic_port *phantom_port,
 755                                    uint32_t command, void *buffer,
 756                                    size_t len ) {
 757         uint64_t physaddr;
 758
 759         physaddr = virt_to_bus ( buffer );
 760         return phantom_issue_cmd ( phantom_port, command, ( physaddr >> 32 ),
 761                                    ( physaddr & 0xffffffffUL ), len );
 762 }
 763
 764 /**
 765  * Create Phantom RX context
 766  *
 767  * @v phantom_port      Phantom NIC port
 768  * @ret rc              Return status code
 769  */
 770 static int phantom_create_rx_ctx ( struct phantom_nic_port *phantom_port ) {
 771         struct phantom_nic *phantom = phantom_port->phantom;
 772         struct phantom_create_rx_ctx_rqrsp *buf;
 773         int rc;
 774
 775         /* Prepare request */
 776         buf = &phantom->dma_buf->create_rx_ctx;
 777         memset ( buf, 0, sizeof ( *buf ) );
 778         buf->hostrq.rx_ctx.host_rsp_dma_addr =
 779                 cpu_to_le64 ( virt_to_bus ( &buf->cardrsp ) );
 780         buf->hostrq.rx_ctx.capabilities[0] =
 781                 cpu_to_le32 ( NX_CAP0_LEGACY_CONTEXT | NX_CAP0_LEGACY_MN );
 782         buf->hostrq.rx_ctx.host_int_crb_mode =
 783                 cpu_to_le32 ( NX_HOST_INT_CRB_MODE_SHARED );
 784         buf->hostrq.rx_ctx.host_rds_crb_mode =
 785                 cpu_to_le32 ( NX_HOST_RDS_CRB_MODE_UNIQUE );
 786         buf->hostrq.rx_ctx.rds_ring_offset = cpu_to_le32 ( 0 );
 787         buf->hostrq.rx_ctx.sds_ring_offset =
 788                 cpu_to_le32 ( sizeof ( buf->hostrq.rds ) );
 789         buf->hostrq.rx_ctx.num_rds_rings = cpu_to_le16 ( 1 );
 790         buf->hostrq.rx_ctx.num_sds_rings = cpu_to_le16 ( 1 );
 791         buf->hostrq.rds.host_phys_addr =
 792                 cpu_to_le64 ( virt_to_bus ( phantom_port->desc->rds ) );
 793         buf->hostrq.rds.buff_size = cpu_to_le64 ( PHN_RX_BUFSIZE );
 794         buf->hostrq.rds.ring_size = cpu_to_le32 ( PHN_NUM_RDS );
 795         buf->hostrq.rds.ring_kind = cpu_to_le32 ( NX_RDS_RING_TYPE_NORMAL );
 796         buf->hostrq.sds.host_phys_addr =
 797                 cpu_to_le64 ( virt_to_bus ( phantom_port->desc->sds ) );
 798         buf->hostrq.sds.ring_size = cpu_to_le32 ( PHN_NUM_SDS );
 799
 800         DBGC ( phantom, "Phantom %p port %d creating RX context\n",
 801                phantom, phantom_port->port );
 802         DBGC2_HDA ( phantom, virt_to_bus ( &buf->hostrq ),
 803                     &buf->hostrq, sizeof ( buf->hostrq ) );
 804
 805         /* Issue request */
 806         if ( ( rc = phantom_issue_buf_cmd ( phantom_port,
 807                                             NX_CDRP_CMD_CREATE_RX_CTX,
 808                                             &buf->hostrq,
 809                                             sizeof ( buf->hostrq ) ) ) != 0 ) {
 810                 DBGC ( phantom, "Phantom %p port %d could not create RX "
 811                        "context: %s\n",
 812                        phantom, phantom_port->port, strerror ( rc ) );
 813                 DBGC ( phantom, "Request:\n" );
 814                 DBGC_HDA ( phantom, virt_to_bus ( &buf->hostrq ),
 815                            &buf->hostrq, sizeof ( buf->hostrq ) );
 816                 DBGC ( phantom, "Response:\n" );
 817                 DBGC_HDA ( phantom, virt_to_bus ( &buf->cardrsp ),
 818                            &buf->cardrsp, sizeof ( buf->cardrsp ) );
 819                 return rc;
 820         }
 821
 822         /* Retrieve context parameters */
 823         phantom_port->rx_context_id =
 824                 le16_to_cpu ( buf->cardrsp.rx_ctx.context_id );
 825         phantom_port->rds_producer_crb =
 826                 ( UNM_CAM_RAM +
 827                   le32_to_cpu ( buf->cardrsp.rds.host_producer_crb ));
 828         phantom_port->sds_consumer_crb =
 829                 ( UNM_CAM_RAM +
 830                   le32_to_cpu ( buf->cardrsp.sds.host_consumer_crb ));
 831
 832         DBGC ( phantom, "Phantom %p port %d created RX context (id %04x, "
 833                "port phys %02x virt %02x)\n", phantom, phantom_port->port,
 834                phantom_port->rx_context_id, buf->cardrsp.rx_ctx.phys_port,
 835                buf->cardrsp.rx_ctx.virt_port );
 836         DBGC2_HDA ( phantom, virt_to_bus ( &buf->cardrsp ),
 837                     &buf->cardrsp, sizeof ( buf->cardrsp ) );
 838         DBGC ( phantom, "Phantom %p port %d RDS producer CRB is %08lx\n",
 839                phantom, phantom_port->port, phantom_port->rds_producer_crb );
 840         DBGC ( phantom, "Phantom %p port %d SDS consumer CRB is %08lx\n",
 841                phantom, phantom_port->port, phantom_port->sds_consumer_crb );
 842
 843         return 0;
 844 }
 845
 846 /**
 847  * Destroy Phantom RX context
 848  *
 849  * @v phantom_port      Phantom NIC port
 850  * @ret rc              Return status code
 851  */
 852 static void phantom_destroy_rx_ctx ( struct phantom_nic_port *phantom_port ) {
 853         struct phantom_nic *phantom = phantom_port->phantom;
 854         int rc;
 855
 856         DBGC ( phantom, "Phantom %p port %d destroying RX context (id %04x)\n",
 857                phantom, phantom_port->port, phantom_port->rx_context_id );
 858
 859         /* Issue request */
 860         if ( ( rc = phantom_issue_cmd ( phantom_port,
 861                                         NX_CDRP_CMD_DESTROY_RX_CTX,
 862                                         phantom_port->rx_context_id,
 863                                         NX_DESTROY_CTX_RESET, 0 ) ) != 0 ) {
 864                 DBGC ( phantom, "Phantom %p port %d could not destroy RX "
 865                        "context: %s\n",
 866                        phantom, phantom_port->port, strerror ( rc ) );
 867                 /* We're probably screwed */
 868                 return;
 869         }
 870
 871         /* Clear context parameters */
 872         phantom_port->rx_context_id = 0;
 873         phantom_port->rds_producer_crb = 0;
 874         phantom_port->sds_consumer_crb = 0;
 875
 876         /* Reset software counters */
 877         phantom_port->rds_producer_idx = 0;
 878         phantom_port->rds_consumer_idx = 0;
 879         phantom_port->sds_consumer_idx = 0;
 880 }
 881
 882 /**
 883  * Create Phantom TX context
 884  *
 885  * @v phantom_port      Phantom NIC port
 886  * @ret rc              Return status code
 887  */
 888 static int phantom_create_tx_ctx ( struct phantom_nic_port *phantom_port ) {
 889         struct phantom_nic *phantom = phantom_port->phantom;
 890         struct phantom_create_tx_ctx_rqrsp *buf;
 891         int rc;
 892
 893         /* Prepare request */
 894         buf = &phantom->dma_buf->create_tx_ctx;
 895         memset ( buf, 0, sizeof ( *buf ) );
 896         buf->hostrq.tx_ctx.host_rsp_dma_addr =
 897                 cpu_to_le64 ( virt_to_bus ( &buf->cardrsp ) );
 898         buf->hostrq.tx_ctx.cmd_cons_dma_addr =
 899                 cpu_to_le64 ( virt_to_bus ( &phantom_port->desc->cmd_cons ) );
 900         buf->hostrq.tx_ctx.dummy_dma_addr =
 901                 cpu_to_le64 ( virt_to_bus ( phantom->dma_buf->dummy_dma ) );
 902         buf->hostrq.tx_ctx.capabilities[0] =
 903                 cpu_to_le32 ( NX_CAP0_LEGACY_CONTEXT | NX_CAP0_LEGACY_MN );
 904         buf->hostrq.tx_ctx.host_int_crb_mode =
 905                 cpu_to_le32 ( NX_HOST_INT_CRB_MODE_SHARED );
 906         buf->hostrq.tx_ctx.cds_ring.host_phys_addr =
 907                 cpu_to_le64 ( virt_to_bus ( phantom_port->desc->cds ) );
 908         buf->hostrq.tx_ctx.cds_ring.ring_size = cpu_to_le32 ( PHN_NUM_CDS );
 909
 910         DBGC ( phantom, "Phantom %p port %d creating TX context\n",
 911                phantom, phantom_port->port );
 912         DBGC2_HDA ( phantom, virt_to_bus ( &buf->hostrq ),
 913                     &buf->hostrq, sizeof ( buf->hostrq ) );
 914
 915         /* Issue request */
 916         if ( ( rc = phantom_issue_buf_cmd ( phantom_port,
 917                                             NX_CDRP_CMD_CREATE_TX_CTX,
 918                                             &buf->hostrq,
 919                                             sizeof ( buf->hostrq ) ) ) != 0 ) {
 920                 DBGC ( phantom, "Phantom %p port %d could not create TX "
 921                        "context: %s\n",
 922                        phantom, phantom_port->port, strerror ( rc ) );
 923                 DBGC ( phantom, "Request:\n" );
 924                 DBGC_HDA ( phantom, virt_to_bus ( &buf->hostrq ),
 925                            &buf->hostrq, sizeof ( buf->hostrq ) );
 926                 DBGC ( phantom, "Response:\n" );
 927                 DBGC_HDA ( phantom, virt_to_bus ( &buf->cardrsp ),
 928                            &buf->cardrsp, sizeof ( buf->cardrsp ) );
 929                 return rc;
 930         }
 931
 932         /* Retrieve context parameters */
 933         phantom_port->tx_context_id =
 934                 le16_to_cpu ( buf->cardrsp.tx_ctx.context_id );
 935         phantom_port->cds_producer_crb =
 936                 ( UNM_CAM_RAM +
 937                   le32_to_cpu(buf->cardrsp.tx_ctx.cds_ring.host_producer_crb));
 938
 939         DBGC ( phantom, "Phantom %p port %d created TX context (id %04x, "
 940                "port phys %02x virt %02x)\n", phantom, phantom_port->port,
 941                phantom_port->tx_context_id, buf->cardrsp.tx_ctx.phys_port,
 942                buf->cardrsp.tx_ctx.virt_port );
 943         DBGC2_HDA ( phantom, virt_to_bus ( &buf->cardrsp ),
 944                     &buf->cardrsp, sizeof ( buf->cardrsp ) );
 945         DBGC ( phantom, "Phantom %p port %d CDS producer CRB is %08lx\n",
 946                phantom, phantom_port->port, phantom_port->cds_producer_crb );
 947
 948         return 0;
 949 }
 950
 951 /**
 952  * Destroy Phantom TX context
 953  *
 954  * @v phantom_port      Phantom NIC port
 955  * @ret rc              Return status code
 956  */
 957 static void phantom_destroy_tx_ctx ( struct phantom_nic_port *phantom_port ) {
 958         struct phantom_nic *phantom = phantom_port->phantom;
 959         int rc;
 960
 961         DBGC ( phantom, "Phantom %p port %d destroying TX context (id %04x)\n",
 962                phantom, phantom_port->port, phantom_port->tx_context_id );
 963
 964         /* Issue request */
 965         if ( ( rc = phantom_issue_cmd ( phantom_port,
 966                                         NX_CDRP_CMD_DESTROY_TX_CTX,
 967                                         phantom_port->tx_context_id,
 968                                         NX_DESTROY_CTX_RESET, 0 ) ) != 0 ) {
 969                 DBGC ( phantom, "Phantom %p port %d could not destroy TX "
 970                        "context: %s\n",
 971                        phantom, phantom_port->port, strerror ( rc ) );
 972                 /* We're probably screwed */
 973                 return;
 974         }
 975
 976         /* Clear context parameters */
 977         phantom_port->tx_context_id = 0;
 978         phantom_port->cds_producer_crb = 0;
 979
 980         /* Reset software counters */
 981         phantom_port->cds_producer_idx = 0;
 982         phantom_port->cds_consumer_idx = 0;
 983 }
 984
 985 /***************************************************************************
 986  *
 987  * Descriptor ring management
 988  *
 989  */
 990
 991 /**
 992  * Allocate Phantom RX descriptor
 993  *
 994  * @v phantom_port      Phantom NIC port
 995  * @ret index           RX descriptor index, or negative error
 996  */
 997 static int phantom_alloc_rds ( struct phantom_nic_port *phantom_port ) {
 998         struct phantom_nic *phantom = phantom_port->phantom;
 999         unsigned int rds_producer_idx;
1000         unsigned int next_rds_producer_idx;
1001
1002         /* Check for space in the ring.  RX descriptors are consumed
1003          * out of order, but they are *read* by the hardware in strict
1004          * order.  We maintain a pessimistic consumer index, which is
1005          * guaranteed never to be an overestimate of the number of
1006          * descriptors read by the hardware.
1007          */
1008         rds_producer_idx = phantom_port->rds_producer_idx;
1009         next_rds_producer_idx = ( ( rds_producer_idx + 1 ) % PHN_NUM_RDS );
1010         if ( next_rds_producer_idx == phantom_port->rds_consumer_idx ) {
1011                 DBGC ( phantom, "Phantom %p port %d RDS ring full (index %d "
1012                        "not consumed)\n", phantom, phantom_port->port,
1013                        next_rds_producer_idx );
1014                 return -ENOBUFS;
1015         }
1016
1017         return rds_producer_idx;
1018 }
1019
1020 /**
1021  * Post Phantom RX descriptor
1022  *
1023  * @v phantom_port      Phantom NIC port
1024  * @v rds               RX descriptor
1025  */
1026 static void phantom_post_rds ( struct phantom_nic_port *phantom_port,
1027                                struct phantom_rds *rds ) {
1028         struct phantom_nic *phantom = phantom_port->phantom;
1029         unsigned int rds_producer_idx;
1030         unsigned int next_rds_producer_idx;
1031         struct phantom_rds *entry;
1032
1033         /* Copy descriptor to ring */
1034         rds_producer_idx = phantom_port->rds_producer_idx;
1035         entry = &phantom_port->desc->rds[rds_producer_idx];
1036         memcpy ( entry, rds, sizeof ( *entry ) );
1037         DBGC2 ( phantom, "Phantom %p port %d posting RDS %ld (slot %d):\n",
1038                 phantom, phantom_port->port, NX_GET ( rds, handle ),
1039                 rds_producer_idx );
1040         DBGC2_HDA ( phantom, virt_to_bus ( entry ), entry, sizeof ( *entry ) );
1041
1042         /* Update producer index */
1043         next_rds_producer_idx = ( ( rds_producer_idx + 1 ) % PHN_NUM_RDS );
1044         phantom_port->rds_producer_idx = next_rds_producer_idx;
1045         wmb();
1046         phantom_writel ( phantom, phantom_port->rds_producer_idx,
1047                          phantom_port->rds_producer_crb );
1048 }
1049
1050 /**
1051  * Allocate Phantom TX descriptor
1052  *
1053  * @v phantom_port      Phantom NIC port
1054  * @ret index           TX descriptor index, or negative error
1055  */
1056 static int phantom_alloc_cds ( struct phantom_nic_port *phantom_port ) {
1057         struct phantom_nic *phantom = phantom_port->phantom;
1058         unsigned int cds_producer_idx;
1059         unsigned int next_cds_producer_idx;
1060
1061         /* Check for space in the ring.  TX descriptors are consumed
1062          * in strict order, so we just check for a collision against
1063          * the consumer index.
1064          */
1065         cds_producer_idx = phantom_port->cds_producer_idx;
1066         next_cds_producer_idx = ( ( cds_producer_idx + 1 ) % PHN_NUM_CDS );
1067         if ( next_cds_producer_idx == phantom_port->cds_consumer_idx ) {
1068                 DBGC ( phantom, "Phantom %p port %d CDS ring full (index %d "
1069                        "not consumed)\n", phantom, phantom_port->port,
1070                        next_cds_producer_idx );
1071                 return -ENOBUFS;
1072         }
1073
1074         return cds_producer_idx;
1075 }
1076
1077 /**
1078  * Post Phantom TX descriptor
1079  *
1080  * @v phantom_port      Phantom NIC port
1081  * @v cds               TX descriptor
1082  */
1083 static void phantom_post_cds ( struct phantom_nic_port *phantom_port,
1084                                union phantom_cds *cds ) {
1085         struct phantom_nic *phantom = phantom_port->phantom;
1086         unsigned int cds_producer_idx;
1087         unsigned int next_cds_producer_idx;
1088         union phantom_cds *entry;
1089
1090         /* Copy descriptor to ring */
1091         cds_producer_idx = phantom_port->cds_producer_idx;
1092         entry = &phantom_port->desc->cds[cds_producer_idx];
1093         memcpy ( entry, cds, sizeof ( *entry ) );
1094         DBGC2 ( phantom, "Phantom %p port %d posting CDS %d:\n",
1095                 phantom, phantom_port->port, cds_producer_idx );
1096         DBGC2_HDA ( phantom, virt_to_bus ( entry ), entry, sizeof ( *entry ) );
1097
1098         /* Update producer index */
1099         next_cds_producer_idx = ( ( cds_producer_idx + 1 ) % PHN_NUM_CDS );
1100         phantom_port->cds_producer_idx = next_cds_producer_idx;
1101         wmb();
1102         phantom_writel ( phantom, phantom_port->cds_producer_idx,
1103                          phantom_port->cds_producer_crb );
1104 }
1105
1106 /***************************************************************************
1107  *
1108  * MAC address management
1109  *
1110  */
1111
1112 /**
1113  * Add/remove MAC address
1114  *
1115  * @v phantom_port      Phantom NIC port
1116  * @v ll_addr           MAC address to add or remove
1117  * @v opcode            MAC request opcode
1118  * @ret rc              Return status code
1119  */
1120 static int phantom_update_macaddr ( struct phantom_nic_port *phantom_port,
1121                                     const uint8_t *ll_addr,
1122                                     unsigned int opcode ) {
1123         union phantom_cds cds;
1124         int index;
1125
1126         /* Get descriptor ring entry */
1127         index = phantom_alloc_cds ( phantom_port );
1128         if ( index < 0 )
1129                 return index;
1130
1131         /* Fill descriptor ring entry */
1132         memset ( &cds, 0, sizeof ( cds ) );
1133         NX_FILL_1 ( &cds, 0,
1134                     nic_request.common.opcode, UNM_NIC_REQUEST );
1135         NX_FILL_2 ( &cds, 1,
1136                     nic_request.header.opcode, UNM_MAC_EVENT,
1137                     nic_request.header.context_id, phantom_port->port );
1138         NX_FILL_7 ( &cds, 2,
1139                     nic_request.body.mac_request.opcode, opcode,
1140                     nic_request.body.mac_request.mac_addr_0, ll_addr[0],
1141                     nic_request.body.mac_request.mac_addr_1, ll_addr[1],
1142                     nic_request.body.mac_request.mac_addr_2, ll_addr[2],
1143                     nic_request.body.mac_request.mac_addr_3, ll_addr[3],
1144                     nic_request.body.mac_request.mac_addr_4, ll_addr[4],
1145                     nic_request.body.mac_request.mac_addr_5, ll_addr[5] );
1146
1147         /* Post descriptor */
1148         phantom_post_cds ( phantom_port, &cds );
1149
1150         return 0;
1151 }
1152
1153 /**
1154  * Add MAC address
1155  *
1156  * @v phantom_port      Phantom NIC port
1157  * @v ll_addr           MAC address to add or remove
1158  * @ret rc              Return status code
1159  */
1160 static inline int phantom_add_macaddr ( struct phantom_nic_port *phantom_port,
1161                                         const uint8_t *ll_addr ) {
1162         struct phantom_nic *phantom = phantom_port->phantom;
1163
1164         DBGC ( phantom, "Phantom %p port %d adding MAC address %s\n",
1165                phantom, phantom_port->port, eth_ntoa ( ll_addr ) );
1166
1167         return phantom_update_macaddr ( phantom_port, ll_addr, UNM_MAC_ADD );
1168 }
1169
1170 /**
1171  * Remove MAC address
1172  *
1173  * @v phantom_port      Phantom NIC port
1174  * @v ll_addr           MAC address to add or remove
1175  * @ret rc              Return status code
1176  */
1177 static inline int phantom_del_macaddr ( struct phantom_nic_port *phantom_port,
1178                                         const uint8_t *ll_addr ) {
1179         struct phantom_nic *phantom = phantom_port->phantom;
1180
1181         DBGC ( phantom, "Phantom %p port %d removing MAC address %s\n",
1182                phantom, phantom_port->port, eth_ntoa ( ll_addr ) );
1183
1184         return phantom_update_macaddr ( phantom_port, ll_addr, UNM_MAC_DEL );
1185 }
1186
1187 /***************************************************************************
1188  *
1189  * Link state detection
1190  *
1191  */
1192
1193 /**
1194  * Poll link state
1195  *
1196  * @v phantom           Phantom NIC
1197  */
1198 static void phantom_poll_link_state ( struct phantom_nic *phantom ) {
1199         struct net_device *netdev;
1200         struct phantom_nic_port *phantom_port;
1201         uint32_t xg_state_p3;
1202         unsigned int link;
1203         int i;
1204
1205         /* Read link state */
1206         xg_state_p3 = phantom_readl ( phantom, UNM_NIC_REG_XG_STATE_P3 );
1207
1208         /* If there is no change, do nothing */
1209         if ( phantom->link_state == xg_state_p3 )
1210                 return;
1211
1212         /* Record new link state */
1213         DBGC ( phantom, "Phantom %p new link state %08lx (was %08lx)\n",
1214                phantom, xg_state_p3, phantom->link_state );
1215         phantom->link_state = xg_state_p3;
1216
1217         /* Indicate per-port link state to gPXE */
1218         for ( i = 0 ; i < phantom->num_ports ; i++ ) {
1219                 netdev = phantom->netdev[i];
1220                 phantom_port = netdev_priv ( netdev );
1221                 link = UNM_NIC_REG_XG_STATE_P3_LINK ( phantom_port->port,
1222                                                       phantom->link_state );
1223                 switch ( link ) {
1224                 case UNM_NIC_REG_XG_STATE_P3_LINK_UP:
1225                         DBGC ( phantom, "Phantom %p port %d link is up\n",
1226                                phantom, phantom_port->port );
1227                         netdev_link_up ( netdev );
1228                         break;
1229                 case UNM_NIC_REG_XG_STATE_P3_LINK_DOWN:
1230                         DBGC ( phantom, "Phantom %p port %d link is down\n",
1231                                phantom, phantom_port->port );
1232                         netdev_link_down ( netdev );
1233                         break;
1234                 default:
1235                         DBGC ( phantom, "Phantom %p port %d bad link state "
1236                                "%d\n", phantom, phantom_port->port, link );
1237                         break;
1238                 }
1239         }
1240 }
1241
1242 /***************************************************************************
1243  *
1244  * Main driver body
1245  *
1246  */
1247
1248 /**
1249  * Refill descriptor ring
1250  *
1251  * @v netdev            Net device
1252  */
1253 static void phantom_refill_rx_ring ( struct net_device *netdev ) {
1254         struct phantom_nic_port *phantom_port = netdev_priv ( netdev );
1255         struct io_buffer *iobuf;
1256         struct phantom_rds rds;
1257         unsigned int handle;
1258         int index;
1259
1260         for ( handle = 0 ; handle < PHN_RDS_MAX_FILL ; handle++ ) {
1261
1262                 /* Skip this index if the descriptor has not yet been
1263                  * consumed.
1264                  */
1265                 if ( phantom_port->rds_iobuf[handle] != NULL )
1266                         continue;
1267
1268                 /* Allocate descriptor ring entry */
1269                 index = phantom_alloc_rds ( phantom_port );
1270                 assert ( PHN_RDS_MAX_FILL < PHN_NUM_RDS );
1271                 assert ( index >= 0 ); /* Guaranteed by MAX_FILL < NUM_RDS ) */
1272
1273                 /* Try to allocate an I/O buffer */
1274                 iobuf = alloc_iob ( PHN_RX_BUFSIZE );
1275                 if ( ! iobuf ) {
1276                         /* Failure is non-fatal; we will retry later */
1277                         netdev_rx_err ( netdev, NULL, -ENOMEM );
1278                         break;
1279                 }
1280
1281                 /* Fill descriptor ring entry */
1282                 memset ( &rds, 0, sizeof ( rds ) );
1283                 NX_FILL_2 ( &rds, 0,
1284                             handle, handle,
1285                             length, iob_len ( iobuf ) );
1286                 NX_FILL_1 ( &rds, 1,
1287                             dma_addr, virt_to_bus ( iobuf->data ) );
1288
1289                 /* Record I/O buffer */
1290                 assert ( phantom_port->rds_iobuf[handle] == NULL );
1291                 phantom_port->rds_iobuf[handle] = iobuf;
1292
1293                 /* Post descriptor */
1294                 phantom_post_rds ( phantom_port, &rds );
1295         }
1296 }
1297
1298 /**
1299  * Open NIC
1300  *
1301  * @v netdev            Net device
1302  * @ret rc              Return status code
1303  */
1304 static int phantom_open ( struct net_device *netdev ) {
1305         struct phantom_nic_port *phantom_port = netdev_priv ( netdev );
1306         int rc;
1307
1308         /* Allocate and zero descriptor rings */
1309         phantom_port->desc = malloc_dma ( sizeof ( *(phantom_port->desc) ),
1310                                           UNM_DMA_BUFFER_ALIGN );
1311         if ( ! phantom_port->desc ) {
1312                 rc = -ENOMEM;
1313                 goto err_alloc_desc;
1314         }
1315         memset ( phantom_port->desc, 0, sizeof ( *(phantom_port->desc) ) );
1316
1317         /* Create RX context */
1318         if ( ( rc = phantom_create_rx_ctx ( phantom_port ) ) != 0 )
1319                 goto err_create_rx_ctx;
1320
1321         /* Create TX context */
1322         if ( ( rc = phantom_create_tx_ctx ( phantom_port ) ) != 0 )
1323                 goto err_create_tx_ctx;
1324
1325         /* Fill the RX descriptor ring */
1326         phantom_refill_rx_ring ( netdev );
1327
1328         /* Add MAC addresses
1329          *
1330          * BUG5583
1331          *
1332          * We would like to be able to enable receiving all multicast
1333          * packets (or, failing that, promiscuous mode), but the
1334          * firmware doesn't currently support this.
1335          */
1336         if ( ( rc = phantom_add_macaddr ( phantom_port,
1337                                    netdev->ll_protocol->ll_broadcast ) ) != 0 )
1338                 goto err_add_macaddr_broadcast;
1339         if ( ( rc = phantom_add_macaddr ( phantom_port,
1340                                           netdev->ll_addr ) ) != 0 )
1341                 goto err_add_macaddr_unicast;
1342
1343         return 0;
1344
1345         phantom_del_macaddr ( phantom_port, netdev->ll_addr );
1346  err_add_macaddr_unicast:
1347         phantom_del_macaddr ( phantom_port,
1348                               netdev->ll_protocol->ll_broadcast );
1349  err_add_macaddr_broadcast:
1350         phantom_destroy_tx_ctx ( phantom_port );
1351  err_create_tx_ctx:
1352         phantom_destroy_rx_ctx ( phantom_port );
1353  err_create_rx_ctx:
1354         free_dma ( phantom_port->desc, sizeof ( *(phantom_port->desc) ) );
1355         phantom_port->desc = NULL;
1356  err_alloc_desc:
1357         return rc;
1358 }
1359
1360 /**
1361  * Close NIC
1362  *
1363  * @v netdev            Net device
1364  */
1365 static void phantom_close ( struct net_device *netdev ) {
1366         struct phantom_nic_port *phantom_port = netdev_priv ( netdev );
1367         struct io_buffer *iobuf;
1368         unsigned int i;
1369
1370         /* Shut down the port */
1371         phantom_del_macaddr ( phantom_port, netdev->ll_addr );
1372         phantom_del_macaddr ( phantom_port,
1373                               netdev->ll_protocol->ll_broadcast );
1374         phantom_destroy_tx_ctx ( phantom_port );
1375         phantom_destroy_rx_ctx ( phantom_port );
1376         free_dma ( phantom_port->desc, sizeof ( *(phantom_port->desc) ) );
1377         phantom_port->desc = NULL;
1378
1379         /* Flush any uncompleted descriptors */
1380         for ( i = 0 ; i < PHN_RDS_MAX_FILL ; i++ ) {
1381                 iobuf = phantom_port->rds_iobuf[i];
1382                 if ( iobuf ) {
1383                         free_iob ( iobuf );
1384                         phantom_port->rds_iobuf[i] = NULL;
1385                 }
1386         }
1387         for ( i = 0 ; i < PHN_NUM_CDS ; i++ ) {
1388                 iobuf = phantom_port->cds_iobuf[i];
1389                 if ( iobuf ) {
1390                         netdev_tx_complete_err ( netdev, iobuf, -ECANCELED );
1391                         phantom_port->cds_iobuf[i] = NULL;
1392                 }
1393         }
1394 }
1395
1396 /**
1397  * Transmit packet
1398  *
1399  * @v netdev    Network device
1400  * @v iobuf     I/O buffer
1401  * @ret rc      Return status code
1402  */
1403 static int phantom_transmit ( struct net_device *netdev,
1404                               struct io_buffer *iobuf ) {
1405         struct phantom_nic_port *phantom_port = netdev_priv ( netdev );
1406         union phantom_cds cds;
1407         int index;
1408
1409         /* Get descriptor ring entry */
1410         index = phantom_alloc_cds ( phantom_port );
1411         if ( index < 0 )
1412                 return index;
1413
1414         /* Fill descriptor ring entry */
1415         memset ( &cds, 0, sizeof ( cds ) );
1416         NX_FILL_3 ( &cds, 0,
1417                     tx.opcode, UNM_TX_ETHER_PKT,
1418                     tx.num_buffers, 1,
1419                     tx.length, iob_len ( iobuf ) );
1420         NX_FILL_2 ( &cds, 2,
1421                     tx.port, phantom_port->port,
1422                     tx.context_id, phantom_port->port );
1423         NX_FILL_1 ( &cds, 4,
1424                     tx.buffer1_dma_addr, virt_to_bus ( iobuf->data ) );
1425         NX_FILL_1 ( &cds, 5,
1426                     tx.buffer1_length, iob_len ( iobuf ) );
1427
1428         /* Record I/O buffer */
1429         assert ( phantom_port->cds_iobuf[index] == NULL );
1430         phantom_port->cds_iobuf[index] = iobuf;
1431
1432         /* Post descriptor */
1433         phantom_post_cds ( phantom_port, &cds );
1434
1435         return 0;
1436 }
1437
1438 /**
1439  * Poll for received packets
1440  *
1441  * @v netdev    Network device
1442  */
1443 static void phantom_poll ( struct net_device *netdev ) {
1444         struct phantom_nic_port *phantom_port = netdev_priv ( netdev );
1445         struct phantom_nic *phantom = phantom_port->phantom;
1446         struct io_buffer *iobuf;
1447         unsigned int cds_consumer_idx;
1448         unsigned int raw_new_cds_consumer_idx;
1449         unsigned int new_cds_consumer_idx;
1450         unsigned int rds_consumer_idx;
1451         unsigned int sds_consumer_idx;
1452         struct phantom_sds *sds;
1453         unsigned int sds_handle;
1454         unsigned int sds_opcode;
1455
1456         /* Check for TX completions */
1457         cds_consumer_idx = phantom_port->cds_consumer_idx;
1458         raw_new_cds_consumer_idx = phantom_port->desc->cmd_cons;
1459         new_cds_consumer_idx = le32_to_cpu ( raw_new_cds_consumer_idx );
1460         while ( cds_consumer_idx != new_cds_consumer_idx ) {
1461                 DBGC2 ( phantom, "Phantom %p port %d CDS %d complete\n",
1462                         phantom, phantom_port->port, cds_consumer_idx );
1463                 /* Completions may be for commands other than TX, so
1464                  * there may not always be an associated I/O buffer.
1465                  */
1466                 if ( ( iobuf = phantom_port->cds_iobuf[cds_consumer_idx] ) ) {
1467                         netdev_tx_complete ( netdev, iobuf );
1468                         phantom_port->cds_iobuf[cds_consumer_idx] = NULL;
1469                 }
1470                 cds_consumer_idx = ( ( cds_consumer_idx + 1 ) % PHN_NUM_CDS );
1471                 phantom_port->cds_consumer_idx = cds_consumer_idx;
1472         }
1473
1474         /* Check for received packets */
1475         rds_consumer_idx = phantom_port->rds_consumer_idx;
1476         sds_consumer_idx = phantom_port->sds_consumer_idx;
1477         while ( 1 ) {
1478                 sds = &phantom_port->desc->sds[sds_consumer_idx];
1479                 if ( NX_GET ( sds, owner ) == 0 )
1480                         break;
1481
1482                 DBGC2 ( phantom, "Phantom %p port %d SDS %d status:\n",
1483                         phantom, phantom_port->port, sds_consumer_idx );
1484                 DBGC2_HDA ( phantom, virt_to_bus ( sds ), sds, sizeof (*sds) );
1485
1486                 /* Check received opcode */
1487                 sds_opcode = NX_GET ( sds, opcode );
1488                 if ( ( sds_opcode == UNM_RXPKT_DESC ) ||
1489                      ( sds_opcode == UNM_SYN_OFFLOAD ) ) {
1490
1491                         /* Sanity check: ensure that all of the SDS
1492                          * descriptor has been written.
1493                          */
1494                         if ( NX_GET ( sds, total_length ) == 0 ) {
1495                                 DBGC ( phantom, "Phantom %p port %d SDS %d "
1496                                        "incomplete; deferring\n", phantom,
1497                                        phantom_port->port, sds_consumer_idx );
1498                                 /* Leave for next poll() */
1499                                 break;
1500                         }
1501
1502                         /* Process received packet */
1503                         sds_handle = NX_GET ( sds, handle );
1504                         iobuf = phantom_port->rds_iobuf[sds_handle];
1505                         assert ( iobuf != NULL );
1506                         iob_put ( iobuf, NX_GET ( sds, total_length ) );
1507                         iob_pull ( iobuf, NX_GET ( sds, pkt_offset ) );
1508                         DBGC2 ( phantom, "Phantom %p port %d RDS %d "
1509                                 "complete\n",
1510                                 phantom, phantom_port->port, sds_handle );
1511                         netdev_rx ( netdev, iobuf );
1512                         phantom_port->rds_iobuf[sds_handle] = NULL;
1513
1514                         /* Update RDS consumer counter.  This is a
1515                          * lower bound for the number of descriptors
1516                          * that have been read by the hardware, since
1517                          * the hardware must have read at least one
1518                          * descriptor for each completion that we
1519                          * receive.
1520                          */
1521                         rds_consumer_idx =
1522                                 ( ( rds_consumer_idx + 1 ) % PHN_NUM_RDS );
1523                         phantom_port->rds_consumer_idx = rds_consumer_idx;
1524
1525                 } else {
1526
1527                         DBGC ( phantom, "Phantom %p port %d unexpected SDS "
1528                                "opcode %02x\n",
1529                                phantom, phantom_port->port, sds_opcode );
1530                         DBGC_HDA ( phantom, virt_to_bus ( sds ),
1531                                    sds, sizeof ( *sds ) );
1532                 }
1533
1534                 /* Clear status descriptor */
1535                 memset ( sds, 0, sizeof ( *sds ) );
1536
1537                 /* Update SDS consumer index */
1538                 sds_consumer_idx = ( ( sds_consumer_idx + 1 ) % PHN_NUM_SDS );
1539                 phantom_port->sds_consumer_idx = sds_consumer_idx;
1540                 wmb();
1541                 phantom_writel ( phantom, phantom_port->sds_consumer_idx,
1542                                  phantom_port->sds_consumer_crb );
1543         }
1544
1545         /* Refill the RX descriptor ring */
1546         phantom_refill_rx_ring ( netdev );
1547
1548         /* Occasionally poll the link state */
1549         if ( phantom_port->link_poll_timer-- == 0 ) {
1550                 phantom_poll_link_state ( phantom );
1551                 /* Reset the link poll timer */
1552                 phantom_port->link_poll_timer = PHN_LINK_POLL_FREQUENCY;
1553         }
1554 }
1555
1556 /**
1557  * Enable/disable interrupts
1558  *
1559  * @v netdev    Network device
1560  * @v enable    Interrupts should be enabled
1561  */
1562 static void phantom_irq ( struct net_device *netdev, int enable ) {
1563         struct phantom_nic_port *phantom_port = netdev_priv ( netdev );
1564         struct phantom_nic *phantom = phantom_port->phantom;
1565         static const unsigned long sw_int_mask_reg[UNM_FLASH_NUM_PORTS] = {
1566                 UNM_NIC_REG_SW_INT_MASK_0,
1567                 UNM_NIC_REG_SW_INT_MASK_1,
1568                 UNM_NIC_REG_SW_INT_MASK_2,
1569                 UNM_NIC_REG_SW_INT_MASK_3
1570         };
1571
1572         phantom_writel ( phantom,
1573                          ( enable ? 1 : 0 ),
1574                          sw_int_mask_reg[phantom_port->port] );
1575 }
1576
1577 /** Phantom net device operations */
1578 static struct net_device_operations phantom_operations = {
1579         .open           = phantom_open,
1580         .close          = phantom_close,
1581         .transmit       = phantom_transmit,
1582         .poll           = phantom_poll,
1583         .irq            = phantom_irq,
1584 };
1585
1586 /***************************************************************************
1587  *
1588  * CLP settings
1589  *
1590  */
1591
1592 /** Phantom CLP data
1593  *
1594  */
1595 union phantom_clp_data {
1596         /** Data bytes
1597          *
1598          * This field is right-aligned; if only N bytes are present
1599          * then bytes[0]..bytes[7-N] should be zero, and the data
1600          * should be in bytes[7-N+1] to bytes[7];
1601          */
1602         uint8_t bytes[8];
1603         /** Dwords for the CLP interface */
1604         struct {
1605                 /** High dword, in network byte order */
1606                 uint32_t hi;
1607                 /** Low dword, in network byte order */
1608                 uint32_t lo;
1609         } dwords;
1610 };
1611 #define PHN_CLP_BLKSIZE ( sizeof ( union phantom_clp_data ) )
1612
1613 /**
1614  * Wait for Phantom CLP command to complete
1615  *
1616  * @v phantom           Phantom NIC
1617  * @ret rc              Return status code
1618  */
1619 static int phantom_clp_wait ( struct phantom_nic *phantom ) {
1620         unsigned int retries;
1621         uint32_t status;
1622
1623         for ( retries = 0 ; retries < PHN_CLP_CMD_TIMEOUT_MS ; retries++ ) {
1624                 status = phantom_readl ( phantom, UNM_CAM_RAM_CLP_STATUS );
1625                 if ( status & UNM_CAM_RAM_CLP_STATUS_DONE )
1626                         return 0;
1627                 mdelay ( 1 );
1628         }
1629
1630         DBGC ( phantom, "Phantom %p timed out waiting for CLP command\n",
1631                phantom );
1632         return -ETIMEDOUT;
1633 }
1634
1635 /**
1636  * Issue Phantom CLP command
1637  *
1638  * @v phantom           Phantom NIC
1639  * @v port              Virtual port number
1640  * @v opcode            Opcode
1641  * @v data_in           Data in, or NULL
1642  * @v data_out          Data out, or NULL
1643  * @v offset            Offset within data
1644  * @v len               Data buffer length
1645  * @ret len             Total transfer length (for reads), or negative error
1646  */
1647 static int phantom_clp_cmd ( struct phantom_nic *phantom, unsigned int port,
1648                              unsigned int opcode, const void *data_in,
1649                              void *data_out, size_t offset, size_t len ) {
1650         union phantom_clp_data data;
1651         unsigned int index = ( offset / sizeof ( data ) );
1652         unsigned int last = 0;
1653         size_t in_frag_len;
1654         uint8_t *in_frag;
1655         uint32_t command;
1656         uint32_t status;
1657         size_t read_len;
1658         unsigned int error;
1659         size_t out_frag_len;
1660         uint8_t *out_frag;
1661         int rc;
1662
1663         /* Sanity checks */
1664         assert ( ( offset % sizeof ( data ) ) == 0 );
1665         if ( len > 255 ) {
1666                 DBGC ( phantom, "Phantom %p invalid CLP length %zd\n",
1667                        phantom, len );
1668                 return -EINVAL;
1669         }
1670
1671         /* Check that CLP interface is ready */
1672         if ( ( rc = phantom_clp_wait ( phantom ) ) != 0 )
1673                 return rc;
1674
1675         /* Copy data in */
1676         memset ( &data, 0, sizeof ( data ) );
1677         if ( data_in ) {
1678                 assert ( offset < len );
1679                 in_frag_len = ( len - offset );
1680                 if ( in_frag_len > sizeof ( data ) ) {
1681                         in_frag_len = sizeof ( data );
1682                 } else {
1683                         last = 1;
1684                 }
1685                 in_frag = &data.bytes[ sizeof ( data ) - in_frag_len ];
1686                 memcpy ( in_frag, ( data_in + offset ), in_frag_len );
1687                 phantom_writel ( phantom, be32_to_cpu ( data.dwords.lo ),
1688                                  UNM_CAM_RAM_CLP_DATA_LO );
1689                 phantom_writel ( phantom, be32_to_cpu ( data.dwords.hi ),
1690                                  UNM_CAM_RAM_CLP_DATA_HI );
1691         }
1692
1693         /* Issue CLP command */
1694         command = ( ( index << 24 ) | ( ( data_in ? len : 0 ) << 16 ) |
1695                     ( port << 8 ) | ( last << 7 ) | ( opcode << 0 ) );
1696         phantom_writel ( phantom, command, UNM_CAM_RAM_CLP_COMMAND );
1697         mb();
1698         phantom_writel ( phantom, UNM_CAM_RAM_CLP_STATUS_START,
1699                          UNM_CAM_RAM_CLP_STATUS );
1700
1701         /* Wait for command to complete */
1702         if ( ( rc = phantom_clp_wait ( phantom ) ) != 0 )
1703                 return rc;
1704
1705         /* Get command status */
1706         status = phantom_readl ( phantom, UNM_CAM_RAM_CLP_STATUS );
1707         read_len = ( ( status >> 16 ) & 0xff );
1708         error = ( ( status >> 8 ) & 0xff );
1709         if ( error ) {
1710                 DBGC ( phantom, "Phantom %p CLP command error %02x\n",
1711                        phantom, error );
1712                 return -EIO;
1713         }
1714
1715         /* Copy data out */
1716         if ( data_out ) {
1717                 data.dwords.lo = cpu_to_be32 ( phantom_readl ( phantom,
1718                                                   UNM_CAM_RAM_CLP_DATA_LO ) );
1719                 data.dwords.hi = cpu_to_be32 ( phantom_readl ( phantom,
1720                                                   UNM_CAM_RAM_CLP_DATA_HI ) );
1721                 out_frag_len = ( read_len - offset );
1722                 if ( out_frag_len > sizeof ( data ) )
1723                         out_frag_len = sizeof ( data );
1724                 out_frag = &data.bytes[ sizeof ( data ) - out_frag_len ];
1725                 if ( out_frag_len > ( len - offset ) )
1726                         out_frag_len = ( len - offset );
1727                 memcpy ( ( data_out + offset ), out_frag, out_frag_len );
1728         }
1729
1730         return read_len;
1731 }
1732
1733 /**
1734  * Store Phantom CLP setting
1735  *
1736  * @v phantom           Phantom NIC
1737  * @v port              Virtual port number
1738  * @v setting           Setting number
1739  * @v data              Data buffer
1740  * @v len               Length of data buffer
1741  * @ret rc              Return status code
1742  */
1743 static int phantom_clp_store ( struct phantom_nic *phantom, unsigned int port,
1744                                unsigned int setting, const void *data,
1745                                size_t len ) {
1746         unsigned int opcode = setting;
1747         size_t offset;
1748         int rc;
1749
1750         for ( offset = 0 ; offset < len ; offset += PHN_CLP_BLKSIZE ) {
1751                 if ( ( rc = phantom_clp_cmd ( phantom, port, opcode, data,
1752                                               NULL, offset, len ) ) < 0 )
1753                         return rc;
1754         }
1755         return 0;
1756 }
1757
1758 /**
1759  * Fetch Phantom CLP setting
1760  *
1761  * @v phantom           Phantom NIC
1762  * @v port              Virtual port number
1763  * @v setting           Setting number
1764  * @v data              Data buffer
1765  * @v len               Length of data buffer
1766  * @ret len             Length of setting, or negative error
1767  */
1768 static int phantom_clp_fetch ( struct phantom_nic *phantom, unsigned int port,
1769                                unsigned int setting, void *data, size_t len ) {
1770         unsigned int opcode = ( setting + 1 );
1771         size_t offset = 0;
1772         int read_len;
1773
1774         while ( 1 ) {
1775                 read_len = phantom_clp_cmd ( phantom, port, opcode, NULL,
1776                                              data, offset, len );
1777                 if ( read_len < 0 )
1778                         return read_len;
1779                 offset += PHN_CLP_BLKSIZE;
1780                 if ( offset >= ( unsigned ) read_len )
1781                         break;
1782                 if ( offset >= len )
1783                         break;
1784         }
1785         return read_len;
1786 }
1787
1788 /** A Phantom CLP setting */
1789 struct phantom_clp_setting {
1790         /** gPXE setting */
1791         struct setting *setting;
1792         /** Setting number */
1793         unsigned int number;
1794 };
1795
1796 /** Phantom CLP settings */
1797 static struct phantom_clp_setting clp_settings[] = {
1798         { &mac_setting, 0x01 },
1799 };
1800
1801 /**
1802  * Find Phantom CLP setting
1803  *
1804  * @v setting           gPXE setting
1805  * @v clp_setting       Equivalent Phantom CLP setting, or NULL
1806  */
1807 static struct phantom_clp_setting *
1808 phantom_find_clp_setting ( struct phantom_nic *phantom,
1809                            struct setting *setting ) {
1810         struct phantom_clp_setting *clp_setting;
1811         unsigned int i;
1812
1813         for ( i = 0 ; i < ( sizeof ( clp_settings ) /
1814                             sizeof ( clp_settings[0] ) ) ; i++ ) {
1815                 clp_setting = &clp_settings[i];
1816                 if ( setting_cmp ( setting, clp_setting->setting ) == 0 )
1817                         return clp_setting;
1818         }
1819
1820         DBGC2 ( phantom, "Phantom %p has no \"%s\" setting\n",
1821                 phantom, setting->name );
1822
1823         return NULL;
1824 }
1825
1826 /**
1827  * Store Phantom CLP setting
1828  *
1829  * @v settings          Settings block
1830  * @v setting           Setting to store
1831  * @v data              Setting data, or NULL to clear setting
1832  * @v len               Length of setting data
1833  * @ret rc              Return status code
1834  */
1835 static int phantom_store_setting ( struct settings *settings,
1836                                    struct setting *setting,
1837                                    const void *data, size_t len ) {
1838         struct phantom_nic_port *phantom_port =
1839                 container_of ( settings, struct phantom_nic_port, settings );
1840         struct phantom_nic *phantom = phantom_port->phantom;
1841         struct phantom_clp_setting *clp_setting;
1842         int rc;
1843
1844         /* Find Phantom setting equivalent to gPXE setting */
1845         clp_setting = phantom_find_clp_setting ( phantom, setting );
1846         if ( ! clp_setting )
1847                 return -ENOTSUP;
1848
1849         /* Store setting */
1850         if ( ( rc = phantom_clp_store ( phantom, phantom_port->port,
1851                                         clp_setting->number,
1852                                         data, len ) ) != 0 ) {
1853                 DBGC ( phantom, "Phantom %p could not store setting \"%s\": "
1854                        "%s\n", phantom, setting->name, strerror ( rc ) );
1855                 return rc;
1856         }
1857
1858         return 0;
1859 }
1860
1861 /**
1862  * Fetch Phantom CLP setting
1863  *
1864  * @v settings          Settings block
1865  * @v setting           Setting to fetch
1866  * @v data              Buffer to fill with setting data
1867  * @v len               Length of buffer
1868  * @ret len             Length of setting data, or negative error
1869  */
1870 static int phantom_fetch_setting ( struct settings *settings,
1871                                    struct setting *setting,
1872                                    void *data, size_t len ) {
1873         struct phantom_nic_port *phantom_port =
1874                 container_of ( settings, struct phantom_nic_port, settings );
1875         struct phantom_nic *phantom = phantom_port->phantom;
1876         struct phantom_clp_setting *clp_setting;
1877         int read_len;
1878         int rc;
1879
1880         /* Find Phantom setting equivalent to gPXE setting */
1881         clp_setting = phantom_find_clp_setting ( phantom, setting );
1882         if ( ! clp_setting )
1883                 return -ENOTSUP;
1884
1885         /* Fetch setting */
1886         if ( ( read_len = phantom_clp_fetch ( phantom, phantom_port->port,
1887                                               clp_setting->number,
1888                                               data, len ) ) < 0 ) {
1889                 rc = read_len;
1890                 DBGC ( phantom, "Phantom %p could not fetch setting \"%s\": "
1891                        "%s\n", phantom, setting->name, strerror ( rc ) );
1892                 return rc;
1893         }
1894
1895         return read_len;
1896 }
1897
1898 /** Phantom CLP settings operations */
1899 static struct settings_operations phantom_settings_operations = {
1900         .store          = phantom_store_setting,
1901         .fetch          = phantom_fetch_setting,
1902 };
1903
1904 /***************************************************************************
1905  *
1906  * Initialisation
1907  *
1908  */
1909
1910 /**
1911  * Map Phantom CRB window
1912  *
1913  * @v phantom           Phantom NIC
1914  * @ret rc              Return status code
1915  */
1916 static int phantom_map_crb ( struct phantom_nic *phantom,
1917                              struct pci_device *pci ) {
1918         unsigned long bar0_start;
1919         unsigned long bar0_size;
1920
1921         bar0_start = pci_bar_start ( pci, PCI_BASE_ADDRESS_0 );
1922         bar0_size = pci_bar_size ( pci, PCI_BASE_ADDRESS_0 );
1923         DBGC ( phantom, "Phantom %p BAR0 is %08lx+%lx\n",
1924                phantom, bar0_start, bar0_size );
1925
1926         switch ( bar0_size ) {
1927         case ( 128 * 1024 * 1024 ) :
1928                 DBGC ( phantom, "Phantom %p has 128MB BAR\n", phantom );
1929                 phantom->crb_access = phantom_crb_access_128m;
1930                 break;
1931         case ( 32 * 1024 * 1024 ) :
1932                 DBGC ( phantom, "Phantom %p has 32MB BAR\n", phantom );
1933                 phantom->crb_access = phantom_crb_access_32m;
1934                 break;
1935         case ( 2 * 1024 * 1024 ) :
1936                 DBGC ( phantom, "Phantom %p has 2MB BAR\n", phantom );
1937                 phantom->crb_access = phantom_crb_access_2m;
1938                 break;
1939         default:
1940                 DBGC ( phantom, "Phantom %p has bad BAR size\n", phantom );
1941                 return -EINVAL;
1942         }
1943
1944         phantom->bar0 = ioremap ( bar0_start, bar0_size );
1945         if ( ! phantom->bar0 ) {
1946                 DBGC ( phantom, "Phantom %p could not map BAR0\n", phantom );
1947                 return -EIO;
1948         }
1949
1950         /* Mark current CRB window as invalid, so that the first
1951          * read/write will set the current window.
1952          */
1953         phantom->crb_window = -1UL;
1954
1955         return 0;
1956 }
1957
1958 /**
1959  * Read Phantom flash contents
1960  *
1961  * @v phantom           Phantom NIC
1962  * @ret rc              Return status code
1963  */
1964 static int phantom_read_flash ( struct phantom_nic *phantom ) {
1965         struct unm_board_info board_info;
1966         int rc;
1967
1968         /* Initialise flash access */
1969         phantom->spi_bus.rw = phantom_spi_rw;
1970         phantom->flash.bus = &phantom->spi_bus;
1971         init_m25p32 ( &phantom->flash );
1972         /* Phantom doesn't support greater than 4-byte block sizes */
1973         phantom->flash.nvs.block_size = UNM_SPI_BLKSIZE;
1974
1975         /* Read and verify board information */
1976         if ( ( rc = nvs_read ( &phantom->flash.nvs, UNM_BRDCFG_START,
1977                                &board_info, sizeof ( board_info ) ) ) != 0 ) {
1978                 DBGC ( phantom, "Phantom %p could not read board info: %s\n",
1979                        phantom, strerror ( rc ) );
1980                 return rc;
1981         }
1982         if ( board_info.magic != UNM_BDINFO_MAGIC ) {
1983                 DBGC ( phantom, "Phantom %p has bad board info magic %lx\n",
1984                        phantom, board_info.magic );
1985                 DBGC_HD ( phantom, &board_info, sizeof ( board_info ) );
1986                 return -EINVAL;
1987         }
1988         if ( board_info.header_version != UNM_BDINFO_VERSION ) {
1989                 DBGC ( phantom, "Phantom %p has bad board info version %lx\n",
1990                        phantom, board_info.header_version );
1991                 DBGC_HD ( phantom, &board_info, sizeof ( board_info ) );
1992                 return -EINVAL;
1993         }
1994
1995         /* Identify board type and number of ports */
1996         switch ( board_info.board_type ) {
1997         case UNM_BRDTYPE_P3_4_GB:
1998         case UNM_BRDTYPE_P3_4_GB_MM:
1999                 phantom->num_ports = 4;
2000                 break;
2001         case UNM_BRDTYPE_P3_HMEZ:
2002         case UNM_BRDTYPE_P3_IMEZ:
2003         case UNM_BRDTYPE_P3_10G_CX4:
2004         case UNM_BRDTYPE_P3_10G_CX4_LP:
2005         case UNM_BRDTYPE_P3_10G_SFP_PLUS:
2006         case UNM_BRDTYPE_P3_XG_LOM:
2007                 phantom->num_ports = 2;
2008                 break;
2009         case UNM_BRDTYPE_P3_10000_BASE_T:
2010         case UNM_BRDTYPE_P3_10G_XFP:
2011                 phantom->num_ports = 1;
2012                 break;
2013         default:
2014                 DBGC ( phantom, "Phantom %p unrecognised board type %#lx; "
2015                        "assuming single-port\n",
2016                        phantom, board_info.board_type );
2017                 phantom->num_ports = 1;
2018                 break;
2019         }
2020         DBGC ( phantom, "Phantom %p board type is %#lx (%d ports)\n",
2021                phantom, board_info.board_type, phantom->num_ports );
2022
2023         return 0;
2024 }
2025
2026 /**
2027  * Halt all PEGs
2028  *
2029  * @v phantom           Phantom NIC
2030  */
2031 static void phantom_halt_pegs ( struct phantom_nic *phantom ) {
2032         phantom_writel ( phantom, 1, UNM_PEG_0_HALT );
2033         phantom_writel ( phantom, 1, UNM_PEG_1_HALT );
2034         phantom_writel ( phantom, 1, UNM_PEG_2_HALT );
2035         phantom_writel ( phantom, 1, UNM_PEG_3_HALT );
2036         phantom_writel ( phantom, 1, UNM_PEG_4_HALT );
2037 }
2038
2039 /**
2040  * Unhalt all PEGs
2041  *
2042  * @v phantom           Phantom NIC
2043  */
2044 static void phantom_unhalt_pegs ( struct phantom_nic *phantom ) {
2045         uint32_t halt_status;
2046
2047         halt_status = phantom_readl ( phantom, UNM_PEG_0_HALT_STATUS );
2048         phantom_writel ( phantom, halt_status, UNM_PEG_0_HALT_STATUS );
2049         halt_status = phantom_readl ( phantom, UNM_PEG_1_HALT_STATUS );
2050         phantom_writel ( phantom, halt_status, UNM_PEG_1_HALT_STATUS );
2051         halt_status = phantom_readl ( phantom, UNM_PEG_2_HALT_STATUS );
2052         phantom_writel ( phantom, halt_status, UNM_PEG_2_HALT_STATUS );
2053         halt_status = phantom_readl ( phantom, UNM_PEG_3_HALT_STATUS );
2054         phantom_writel ( phantom, halt_status, UNM_PEG_3_HALT_STATUS );
2055         halt_status = phantom_readl ( phantom, UNM_PEG_4_HALT_STATUS );
2056         phantom_writel ( phantom, halt_status, UNM_PEG_4_HALT_STATUS );
2057 }
2058
2059 /**
2060  * Initialise the Phantom command PEG
2061  *
2062  * @v phantom           Phantom NIC
2063  * @ret rc              Return status code
2064  */
2065 static int phantom_init_cmdpeg ( struct phantom_nic *phantom ) {
2066         uint32_t cold_boot;
2067         uint32_t sw_reset;
2068         physaddr_t dummy_dma_phys;
2069         unsigned int retries;
2070         uint32_t cmdpeg_state;
2071         uint32_t last_cmdpeg_state = 0;
2072
2073         /* Check for a previous initialisation.  This could have
2074          * happened if, for example, the BIOS used the UNDI API to
2075          * drive the NIC prior to a full PXE boot.
2076          */
2077         cmdpeg_state = phantom_readl ( phantom, UNM_NIC_REG_CMDPEG_STATE );
2078         if ( cmdpeg_state == UNM_NIC_REG_CMDPEG_STATE_INITIALIZE_ACK ) {
2079                 DBGC ( phantom, "Phantom %p command PEG already initialized\n",
2080                        phantom );
2081                 /* Unhalt the PEGs.  Previous firmware (e.g. BOFM) may
2082                  * have halted the PEGs to prevent internal bus
2083                  * collisions when the BIOS re-reads the expansion ROM.
2084                  */
2085                 phantom_unhalt_pegs ( phantom );
2086                 return 0;
2087         }
2088
2089         /* If this was a cold boot, check that the hardware came up ok */
2090         cold_boot = phantom_readl ( phantom, UNM_CAM_RAM_COLD_BOOT );
2091         if ( cold_boot == UNM_CAM_RAM_COLD_BOOT_MAGIC ) {
2092                 DBGC ( phantom, "Phantom %p coming up from cold boot\n",
2093                        phantom );
2094                 sw_reset = phantom_readl ( phantom, UNM_ROMUSB_GLB_SW_RESET );
2095                 if ( sw_reset != UNM_ROMUSB_GLB_SW_RESET_MAGIC ) {
2096                         DBGC ( phantom, "Phantom %p reset failed: %08lx\n",
2097                                phantom, sw_reset );
2098                         return -EIO;
2099                 }
2100         } else {
2101                 DBGC ( phantom, "Phantom %p coming up from warm boot "
2102                        "(%08lx)\n", phantom, cold_boot );
2103         }
2104         /* Clear cold-boot flag */
2105         phantom_writel ( phantom, 0, UNM_CAM_RAM_COLD_BOOT );
2106
2107         /* Set port modes */
2108         phantom_writel ( phantom, UNM_CAM_RAM_PORT_MODE_AUTO_NEG_1G,
2109                          UNM_CAM_RAM_WOL_PORT_MODE );
2110
2111         /* Pass dummy DMA area to card */
2112         dummy_dma_phys = virt_to_bus ( phantom->dma_buf->dummy_dma );
2113         DBGC ( phantom, "Phantom %p dummy DMA at %08lx\n",
2114                phantom, dummy_dma_phys );
2115         phantom_write_hilo ( phantom, dummy_dma_phys,
2116                              UNM_NIC_REG_DUMMY_BUF_ADDR_LO,
2117                              UNM_NIC_REG_DUMMY_BUF_ADDR_HI );
2118         phantom_writel ( phantom, UNM_NIC_REG_DUMMY_BUF_INIT,
2119                          UNM_NIC_REG_DUMMY_BUF );
2120
2121         /* Tell the hardware that tuning is complete */
2122         phantom_writel ( phantom, UNM_ROMUSB_GLB_PEGTUNE_DONE_MAGIC,
2123                          UNM_ROMUSB_GLB_PEGTUNE_DONE );
2124
2125         /* Wait for command PEG to finish initialising */
2126         DBGC ( phantom, "Phantom %p initialising command PEG (will take up to "
2127                "%d seconds)...\n", phantom, PHN_CMDPEG_INIT_TIMEOUT_SEC );
2128         for ( retries = 0; retries < PHN_CMDPEG_INIT_TIMEOUT_SEC; retries++ ) {
2129                 cmdpeg_state = phantom_readl ( phantom,
2130                                                UNM_NIC_REG_CMDPEG_STATE );
2131                 if ( cmdpeg_state != last_cmdpeg_state ) {
2132                         DBGC ( phantom, "Phantom %p command PEG state is "
2133                                "%08lx after %d seconds...\n",
2134                                phantom, cmdpeg_state, retries );
2135                         last_cmdpeg_state = cmdpeg_state;
2136                 }
2137                 if ( cmdpeg_state == UNM_NIC_REG_CMDPEG_STATE_INITIALIZED ) {
2138                         /* Acknowledge the PEG initialisation */
2139                         phantom_writel ( phantom,
2140                                        UNM_NIC_REG_CMDPEG_STATE_INITIALIZE_ACK,
2141                                        UNM_NIC_REG_CMDPEG_STATE );
2142                         return 0;
2143                 }
2144                 mdelay ( 1000 );
2145         }
2146
2147         DBGC ( phantom, "Phantom %p timed out waiting for command PEG to "
2148                "initialise (status %08lx)\n", phantom, cmdpeg_state );
2149         return -ETIMEDOUT;
2150 }
2151
2152 /**
2153  * Read Phantom MAC address
2154  *
2155  * @v phanton_port      Phantom NIC port
2156  * @v ll_addr           Buffer to fill with MAC address
2157  */
2158 static void phantom_get_macaddr ( struct phantom_nic_port *phantom_port,
2159                                   uint8_t *ll_addr ) {
2160         struct phantom_nic *phantom = phantom_port->phantom;
2161         union {
2162                 uint8_t mac_addr[2][ETH_ALEN];
2163                 uint32_t dwords[3];
2164         } u;
2165         unsigned long offset;
2166         int i;
2167
2168         /* Read the three dwords that include this MAC address and one other */
2169         offset = ( UNM_CAM_RAM_MAC_ADDRS +
2170                    ( 12 * ( phantom_port->port / 2 ) ) );
2171         for ( i = 0 ; i < 3 ; i++, offset += 4 ) {
2172                 u.dwords[i] = phantom_readl ( phantom, offset );
2173         }
2174
2175         /* Copy out the relevant MAC address */
2176         for ( i = 0 ; i < ETH_ALEN ; i++ ) {
2177                 ll_addr[ ETH_ALEN - i - 1 ] =
2178                         u.mac_addr[ phantom_port->port & 1 ][i];
2179         }
2180         DBGC ( phantom, "Phantom %p port %d MAC address is %s\n",
2181                phantom, phantom_port->port, eth_ntoa ( ll_addr ) );
2182 }
2183
2184 /**
2185  * Initialise Phantom receive PEG
2186  *
2187  * @v phantom           Phantom NIC
2188  * @ret rc              Return status code
2189  */
2190 static int phantom_init_rcvpeg ( struct phantom_nic *phantom ) {
2191         unsigned int retries;
2192         uint32_t rcvpeg_state;
2193         uint32_t last_rcvpeg_state = 0;
2194
2195         DBGC ( phantom, "Phantom %p initialising receive PEG (will take up to "
2196                "%d seconds)...\n", phantom, PHN_RCVPEG_INIT_TIMEOUT_SEC );
2197         for ( retries = 0; retries < PHN_RCVPEG_INIT_TIMEOUT_SEC; retries++ ) {
2198                 rcvpeg_state = phantom_readl ( phantom,
2199                                                UNM_NIC_REG_RCVPEG_STATE );
2200                 if ( rcvpeg_state != last_rcvpeg_state ) {
2201                         DBGC ( phantom, "Phantom %p receive PEG state is "
2202                                "%08lx after %d seconds...\n",
2203                                phantom, rcvpeg_state, retries );
2204                         last_rcvpeg_state = rcvpeg_state;
2205                 }
2206                 if ( rcvpeg_state == UNM_NIC_REG_RCVPEG_STATE_INITIALIZED )
2207                         return 0;
2208                 mdelay ( 1000 );
2209         }
2210
2211         DBGC ( phantom, "Phantom %p timed out waiting for receive PEG to "
2212                "initialise (status %08lx)\n", phantom, rcvpeg_state );
2213         return -ETIMEDOUT;
2214 }
2215
2216 /**
2217  * Probe PCI device
2218  *
2219  * @v pci               PCI device
2220  * @v id                PCI ID
2221  * @ret rc              Return status code
2222  */
2223 static int phantom_probe ( struct pci_device *pci,
2224                            const struct pci_device_id *id __unused ) {
2225         struct phantom_nic *phantom;
2226         struct net_device *netdev;
2227         struct phantom_nic_port *phantom_port;
2228         struct settings *parent_settings;
2229         int i;
2230         int rc;
2231
2232         /* Phantom NICs expose multiple PCI functions, used for
2233          * virtualisation.  Ignore everything except function 0.
2234          */
2235         if ( PCI_FUNC ( pci->devfn ) != 0 )
2236           return -ENODEV;
2237
2238         /* Allocate Phantom device */
2239         phantom = zalloc ( sizeof ( *phantom ) );
2240         if ( ! phantom ) {
2241                 rc = -ENOMEM;
2242                 goto err_alloc_phantom;
2243         }
2244         pci_set_drvdata ( pci, phantom );
2245
2246         /* Fix up PCI device */
2247         adjust_pci_device ( pci );
2248
2249         /* Map CRB */
2250         if ( ( rc = phantom_map_crb ( phantom, pci ) ) != 0 )
2251                 goto err_map_crb;
2252
2253         /* Read flash information */
2254         if ( ( rc = phantom_read_flash ( phantom ) ) != 0 )
2255                 goto err_read_flash;
2256
2257         /* Allocate net devices for each port */
2258         for ( i = 0 ; i < phantom->num_ports ; i++ ) {
2259                 netdev = alloc_etherdev ( sizeof ( *phantom_port ) );
2260                 if ( ! netdev ) {
2261                         rc = -ENOMEM;
2262                         goto err_alloc_etherdev;
2263                 }
2264                 phantom->netdev[i] = netdev;
2265                 netdev_init ( netdev, &phantom_operations );
2266                 phantom_port = netdev_priv ( netdev );
2267                 netdev->dev = &pci->dev;
2268                 phantom_port->phantom = phantom;
2269                 phantom_port->port = i;
2270                 settings_init ( &phantom_port->settings,
2271                                 &phantom_settings_operations,
2272                                 &netdev->refcnt, "clp" );
2273         }
2274
2275         /* BUG5945 - need to hack PCI config space on P3 B1 silicon.
2276          * B2 will have this fixed; remove this hack when B1 is no
2277          * longer in use.
2278          */
2279         for ( i = 0 ; i < 8 ; i++ ) {
2280                 uint32_t temp;
2281                 pci->devfn = PCI_DEVFN ( PCI_SLOT ( pci->devfn ), i );
2282                 pci_read_config_dword ( pci, 0xc8, &temp );
2283                 pci_read_config_dword ( pci, 0xc8, &temp );
2284                 pci_write_config_dword ( pci, 0xc8, 0xf1000 );
2285         }
2286         pci->devfn = PCI_DEVFN ( PCI_SLOT ( pci->devfn ), 0 );
2287
2288         /* Allocate dummy DMA buffer and perform initial hardware handshake */
2289         phantom->dma_buf = malloc_dma ( sizeof ( *(phantom->dma_buf) ),
2290                                         UNM_DMA_BUFFER_ALIGN );
2291         if ( ! phantom->dma_buf )
2292                 goto err_dma_buf;
2293         if ( ( rc = phantom_init_cmdpeg ( phantom ) ) != 0 )
2294                 goto err_init_cmdpeg;
2295
2296         /* Initialise the receive firmware */
2297         if ( ( rc = phantom_init_rcvpeg ( phantom ) ) != 0 )
2298                 goto err_init_rcvpeg;
2299
2300         /* Read MAC addresses */
2301         for ( i = 0 ; i < phantom->num_ports ; i++ ) {
2302                 phantom_port = netdev_priv ( phantom->netdev[i] );
2303                 phantom_get_macaddr ( phantom_port,
2304                                       phantom->netdev[i]->ll_addr );
2305         }
2306
2307         /* Register network devices */
2308         for ( i = 0 ; i < phantom->num_ports ; i++ ) {
2309                 if ( ( rc = register_netdev ( phantom->netdev[i] ) ) != 0 ) {
2310                         DBGC ( phantom, "Phantom %p could not register port "
2311                                "%d: %s\n", phantom, i, strerror ( rc ) );
2312                         goto err_register_netdev;
2313                 }
2314         }
2315
2316         /* Register settings blocks */
2317         for ( i = 0 ; i < phantom->num_ports ; i++ ) {
2318                 phantom_port = netdev_priv ( phantom->netdev[i] );
2319                 parent_settings = netdev_settings ( phantom->netdev[i] );
2320                 if ( ( rc = register_settings ( &phantom_port->settings,
2321                                                 parent_settings ) ) != 0 ) {
2322                         DBGC ( phantom, "Phantom %p could not register port "
2323                                "%d settings: %s\n",
2324                                phantom, i, strerror ( rc ) );
2325                         goto err_register_settings;
2326                 }
2327         }
2328
2329         return 0;
2330
2331         i = ( phantom->num_ports - 1 );
2332  err_register_settings:
2333         for ( ; i >= 0 ; i-- ) {
2334                 phantom_port = netdev_priv ( phantom->netdev[i] );
2335                 unregister_settings ( &phantom_port->settings );
2336         }
2337         i = ( phantom->num_ports - 1 );
2338  err_register_netdev:
2339         for ( ; i >= 0 ; i-- )
2340                 unregister_netdev ( phantom->netdev[i] );
2341  err_init_rcvpeg:
2342         phantom_halt_pegs ( phantom );
2343  err_init_cmdpeg:
2344         free_dma ( phantom->dma_buf, sizeof ( *(phantom->dma_buf) ) );
2345         phantom->dma_buf = NULL;
2346  err_dma_buf:
2347         i = ( phantom->num_ports - 1 );
2348  err_alloc_etherdev:
2349         for ( ; i >= 0 ; i-- ) {
2350                 netdev_nullify ( phantom->netdev[i] );
2351                 netdev_put ( phantom->netdev[i] );
2352         }
2353  err_read_flash:
2354  err_map_crb:
2355         free ( phantom );
2356  err_alloc_phantom:
2357         return rc;
2358 }
2359
2360 /**
2361  * Remove PCI device
2362  *
2363  * @v pci               PCI device
2364  */
2365 static void phantom_remove ( struct pci_device *pci ) {
2366         struct phantom_nic *phantom = pci_get_drvdata ( pci );
2367         struct phantom_nic_port *phantom_port;
2368         int i;
2369
2370         for ( i = ( phantom->num_ports - 1 ) ; i >= 0 ; i-- ) {
2371                 phantom_port = netdev_priv ( phantom->netdev[i] );
2372                 unregister_settings ( &phantom_port->settings );
2373         }
2374         for ( i = ( phantom->num_ports - 1 ) ; i >= 0 ; i-- )
2375                 unregister_netdev ( phantom->netdev[i] );
2376         phantom_halt_pegs ( phantom );
2377         free_dma ( phantom->dma_buf, sizeof ( *(phantom->dma_buf) ) );
2378         phantom->dma_buf = NULL;
2379         for ( i = ( phantom->num_ports - 1 ) ; i >= 0 ; i-- ) {
2380                 netdev_nullify ( phantom->netdev[i] );
2381                 netdev_put ( phantom->netdev[i] );
2382         }
2383         free ( phantom );
2384 }
2385
2386 /** Phantom PCI IDs */
2387 static struct pci_device_id phantom_nics[] = {
2388         PCI_ROM ( 0x4040, 0x0100, "nx", "NX" ),
2389 };
2390
2391 /** Phantom PCI driver */
2392 struct pci_driver phantom_driver __pci_driver = {
2393         .ids = phantom_nics,
2394         .id_count = ( sizeof ( phantom_nics ) / sizeof ( phantom_nics[0] ) ),
2395         .probe = phantom_probe,
2396         .remove = phantom_remove,
2397 };