[settings] Add the notion of a "tag magic" to numbered settings
[people/sha0/gpxe.git] / 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 settings tag magic */
1593 #define PHN_CLP_TAG_MAGIC 0xc19c1900UL
1594
1595 /** Phantom CLP settings tag magic mask */
1596 #define PHN_CLP_TAG_MAGIC_MASK 0xffffff00UL
1597
1598 /** Phantom CLP data
1599  *
1600  */
1601 union phantom_clp_data {
1602         /** Data bytes
1603          *
1604          * This field is right-aligned; if only N bytes are present
1605          * then bytes[0]..bytes[7-N] should be zero, and the data
1606          * should be in bytes[7-N+1] to bytes[7];
1607          */
1608         uint8_t bytes[8];
1609         /** Dwords for the CLP interface */
1610         struct {
1611                 /** High dword, in network byte order */
1612                 uint32_t hi;
1613                 /** Low dword, in network byte order */
1614                 uint32_t lo;
1615         } dwords;
1616 };
1617 #define PHN_CLP_BLKSIZE ( sizeof ( union phantom_clp_data ) )
1618
1619 /**
1620  * Wait for Phantom CLP command to complete
1621  *
1622  * @v phantom           Phantom NIC
1623  * @ret rc              Return status code
1624  */
1625 static int phantom_clp_wait ( struct phantom_nic *phantom ) {
1626         unsigned int retries;
1627         uint32_t status;
1628
1629         for ( retries = 0 ; retries < PHN_CLP_CMD_TIMEOUT_MS ; retries++ ) {
1630                 status = phantom_readl ( phantom, UNM_CAM_RAM_CLP_STATUS );
1631                 if ( status & UNM_CAM_RAM_CLP_STATUS_DONE )
1632                         return 0;
1633                 mdelay ( 1 );
1634         }
1635
1636         DBGC ( phantom, "Phantom %p timed out waiting for CLP command\n",
1637                phantom );
1638         return -ETIMEDOUT;
1639 }
1640
1641 /**
1642  * Issue Phantom CLP command
1643  *
1644  * @v phantom           Phantom NIC
1645  * @v port              Virtual port number
1646  * @v opcode            Opcode
1647  * @v data_in           Data in, or NULL
1648  * @v data_out          Data out, or NULL
1649  * @v offset            Offset within data
1650  * @v len               Data buffer length
1651  * @ret len             Total transfer length (for reads), or negative error
1652  */
1653 static int phantom_clp_cmd ( struct phantom_nic *phantom, unsigned int port,
1654                              unsigned int opcode, const void *data_in,
1655                              void *data_out, size_t offset, size_t len ) {
1656         union phantom_clp_data data;
1657         unsigned int index = ( offset / sizeof ( data ) );
1658         unsigned int last = 0;
1659         size_t in_frag_len;
1660         uint8_t *in_frag;
1661         uint32_t command;
1662         uint32_t status;
1663         size_t read_len;
1664         unsigned int error;
1665         size_t out_frag_len;
1666         uint8_t *out_frag;
1667         int rc;
1668
1669         /* Sanity checks */
1670         assert ( ( offset % sizeof ( data ) ) == 0 );
1671         if ( len > 255 ) {
1672                 DBGC ( phantom, "Phantom %p invalid CLP length %zd\n",
1673                        phantom, len );
1674                 return -EINVAL;
1675         }
1676
1677         /* Check that CLP interface is ready */
1678         if ( ( rc = phantom_clp_wait ( phantom ) ) != 0 )
1679                 return rc;
1680
1681         /* Copy data in */
1682         memset ( &data, 0, sizeof ( data ) );
1683         if ( data_in ) {
1684                 assert ( offset < len );
1685                 in_frag_len = ( len - offset );
1686                 if ( in_frag_len > sizeof ( data ) ) {
1687                         in_frag_len = sizeof ( data );
1688                 } else {
1689                         last = 1;
1690                 }
1691                 in_frag = &data.bytes[ sizeof ( data ) - in_frag_len ];
1692                 memcpy ( in_frag, ( data_in + offset ), in_frag_len );
1693                 phantom_writel ( phantom, be32_to_cpu ( data.dwords.lo ),
1694                                  UNM_CAM_RAM_CLP_DATA_LO );
1695                 phantom_writel ( phantom, be32_to_cpu ( data.dwords.hi ),
1696                                  UNM_CAM_RAM_CLP_DATA_HI );
1697         }
1698
1699         /* Issue CLP command */
1700         command = ( ( index << 24 ) | ( ( data_in ? len : 0 ) << 16 ) |
1701                     ( port << 8 ) | ( last << 7 ) | ( opcode << 0 ) );
1702         phantom_writel ( phantom, command, UNM_CAM_RAM_CLP_COMMAND );
1703         mb();
1704         phantom_writel ( phantom, UNM_CAM_RAM_CLP_STATUS_START,
1705                          UNM_CAM_RAM_CLP_STATUS );
1706
1707         /* Wait for command to complete */
1708         if ( ( rc = phantom_clp_wait ( phantom ) ) != 0 )
1709                 return rc;
1710
1711         /* Get command status */
1712         status = phantom_readl ( phantom, UNM_CAM_RAM_CLP_STATUS );
1713         read_len = ( ( status >> 16 ) & 0xff );
1714         error = ( ( status >> 8 ) & 0xff );
1715         if ( error ) {
1716                 DBGC ( phantom, "Phantom %p CLP command error %02x\n",
1717                        phantom, error );
1718                 return -EIO;
1719         }
1720
1721         /* Copy data out */
1722         if ( data_out ) {
1723                 data.dwords.lo = cpu_to_be32 ( phantom_readl ( phantom,
1724                                                   UNM_CAM_RAM_CLP_DATA_LO ) );
1725                 data.dwords.hi = cpu_to_be32 ( phantom_readl ( phantom,
1726                                                   UNM_CAM_RAM_CLP_DATA_HI ) );
1727                 out_frag_len = ( read_len - offset );
1728                 if ( out_frag_len > sizeof ( data ) )
1729                         out_frag_len = sizeof ( data );
1730                 out_frag = &data.bytes[ sizeof ( data ) - out_frag_len ];
1731                 if ( out_frag_len > ( len - offset ) )
1732                         out_frag_len = ( len - offset );
1733                 memcpy ( ( data_out + offset ), out_frag, out_frag_len );
1734         }
1735
1736         return read_len;
1737 }
1738
1739 /**
1740  * Store Phantom CLP setting
1741  *
1742  * @v phantom           Phantom NIC
1743  * @v port              Virtual port number
1744  * @v setting           Setting number
1745  * @v data              Data buffer
1746  * @v len               Length of data buffer
1747  * @ret rc              Return status code
1748  */
1749 static int phantom_clp_store ( struct phantom_nic *phantom, unsigned int port,
1750                                unsigned int setting, const void *data,
1751                                size_t len ) {
1752         unsigned int opcode = setting;
1753         size_t offset;
1754         int rc;
1755
1756         for ( offset = 0 ; offset < len ; offset += PHN_CLP_BLKSIZE ) {
1757                 if ( ( rc = phantom_clp_cmd ( phantom, port, opcode, data,
1758                                               NULL, offset, len ) ) < 0 )
1759                         return rc;
1760         }
1761         return 0;
1762 }
1763
1764 /**
1765  * Fetch Phantom CLP setting
1766  *
1767  * @v phantom           Phantom NIC
1768  * @v port              Virtual port number
1769  * @v setting           Setting number
1770  * @v data              Data buffer
1771  * @v len               Length of data buffer
1772  * @ret len             Length of setting, or negative error
1773  */
1774 static int phantom_clp_fetch ( struct phantom_nic *phantom, unsigned int port,
1775                                unsigned int setting, void *data, size_t len ) {
1776         unsigned int opcode = ( setting + 1 );
1777         size_t offset = 0;
1778         int read_len;
1779
1780         while ( 1 ) {
1781                 read_len = phantom_clp_cmd ( phantom, port, opcode, NULL,
1782                                              data, offset, len );
1783                 if ( read_len < 0 )
1784                         return read_len;
1785                 offset += PHN_CLP_BLKSIZE;
1786                 if ( offset >= ( unsigned ) read_len )
1787                         break;
1788                 if ( offset >= len )
1789                         break;
1790         }
1791         return read_len;
1792 }
1793
1794 /** A Phantom CLP setting */
1795 struct phantom_clp_setting {
1796         /** gPXE setting */
1797         struct setting *setting;
1798         /** Setting number */
1799         unsigned int clp_setting;
1800 };
1801
1802 /** Phantom CLP settings */
1803 static struct phantom_clp_setting clp_settings[] = {
1804         { &mac_setting, 0x01 },
1805 };
1806
1807 /**
1808  * Find Phantom CLP setting
1809  *
1810  * @v setting           gPXE setting
1811  * @v clp_setting       Setting number, or 0 if not found
1812  */
1813 static unsigned int
1814 phantom_clp_setting ( struct phantom_nic *phantom, struct setting *setting ) {
1815         struct phantom_clp_setting *clp_setting;
1816         unsigned int i;
1817
1818         /* Search the list of explicitly-defined settings */
1819         for ( i = 0 ; i < ( sizeof ( clp_settings ) /
1820                             sizeof ( clp_settings[0] ) ) ; i++ ) {
1821                 clp_setting = &clp_settings[i];
1822                 if ( setting_cmp ( setting, clp_setting->setting ) == 0 )
1823                         return clp_setting->clp_setting;
1824         }
1825
1826         /* Allow for use of numbered settings */
1827         if ( ( setting->tag & PHN_CLP_TAG_MAGIC_MASK ) == PHN_CLP_TAG_MAGIC )
1828                 return ( setting->tag & ~PHN_CLP_TAG_MAGIC_MASK );
1829
1830         DBGC2 ( phantom, "Phantom %p has no \"%s\" setting\n",
1831                 phantom, setting->name );
1832
1833         return 0;
1834 }
1835
1836 /**
1837  * Store Phantom CLP setting
1838  *
1839  * @v settings          Settings block
1840  * @v setting           Setting to store
1841  * @v data              Setting data, or NULL to clear setting
1842  * @v len               Length of setting data
1843  * @ret rc              Return status code
1844  */
1845 static int phantom_store_setting ( struct settings *settings,
1846                                    struct setting *setting,
1847                                    const void *data, size_t len ) {
1848         struct phantom_nic_port *phantom_port =
1849                 container_of ( settings, struct phantom_nic_port, settings );
1850         struct phantom_nic *phantom = phantom_port->phantom;
1851         unsigned int clp_setting;
1852         int rc;
1853
1854         /* Find Phantom setting equivalent to gPXE setting */
1855         clp_setting = phantom_clp_setting ( phantom, setting );
1856         if ( ! clp_setting )
1857                 return -ENOTSUP;
1858
1859         /* Store setting */
1860         if ( ( rc = phantom_clp_store ( phantom, phantom_port->port,
1861                                         clp_setting, data, len ) ) != 0 ) {
1862                 DBGC ( phantom, "Phantom %p could not store setting \"%s\": "
1863                        "%s\n", phantom, setting->name, strerror ( rc ) );
1864                 return rc;
1865         }
1866
1867         return 0;
1868 }
1869
1870 /**
1871  * Fetch Phantom CLP setting
1872  *
1873  * @v settings          Settings block
1874  * @v setting           Setting to fetch
1875  * @v data              Buffer to fill with setting data
1876  * @v len               Length of buffer
1877  * @ret len             Length of setting data, or negative error
1878  */
1879 static int phantom_fetch_setting ( struct settings *settings,
1880                                    struct setting *setting,
1881                                    void *data, size_t len ) {
1882         struct phantom_nic_port *phantom_port =
1883                 container_of ( settings, struct phantom_nic_port, settings );
1884         struct phantom_nic *phantom = phantom_port->phantom;
1885         unsigned int clp_setting;
1886         int read_len;
1887         int rc;
1888
1889         /* Find Phantom setting equivalent to gPXE setting */
1890         clp_setting = phantom_clp_setting ( phantom, setting );
1891         if ( ! clp_setting )
1892                 return -ENOTSUP;
1893
1894         /* Fetch setting */
1895         if ( ( read_len = phantom_clp_fetch ( phantom, phantom_port->port,
1896                                               clp_setting, data, len ) ) < 0 ){
1897                 rc = read_len;
1898                 DBGC ( phantom, "Phantom %p could not fetch setting \"%s\": "
1899                        "%s\n", phantom, setting->name, strerror ( rc ) );
1900                 return rc;
1901         }
1902
1903         return read_len;
1904 }
1905
1906 /** Phantom CLP settings operations */
1907 static struct settings_operations phantom_settings_operations = {
1908         .store          = phantom_store_setting,
1909         .fetch          = phantom_fetch_setting,
1910 };
1911
1912 /***************************************************************************
1913  *
1914  * Initialisation
1915  *
1916  */
1917
1918 /**
1919  * Map Phantom CRB window
1920  *
1921  * @v phantom           Phantom NIC
1922  * @ret rc              Return status code
1923  */
1924 static int phantom_map_crb ( struct phantom_nic *phantom,
1925                              struct pci_device *pci ) {
1926         unsigned long bar0_start;
1927         unsigned long bar0_size;
1928
1929         bar0_start = pci_bar_start ( pci, PCI_BASE_ADDRESS_0 );
1930         bar0_size = pci_bar_size ( pci, PCI_BASE_ADDRESS_0 );
1931         DBGC ( phantom, "Phantom %p BAR0 is %08lx+%lx\n",
1932                phantom, bar0_start, bar0_size );
1933
1934         switch ( bar0_size ) {
1935         case ( 128 * 1024 * 1024 ) :
1936                 DBGC ( phantom, "Phantom %p has 128MB BAR\n", phantom );
1937                 phantom->crb_access = phantom_crb_access_128m;
1938                 break;
1939         case ( 32 * 1024 * 1024 ) :
1940                 DBGC ( phantom, "Phantom %p has 32MB BAR\n", phantom );
1941                 phantom->crb_access = phantom_crb_access_32m;
1942                 break;
1943         case ( 2 * 1024 * 1024 ) :
1944                 DBGC ( phantom, "Phantom %p has 2MB BAR\n", phantom );
1945                 phantom->crb_access = phantom_crb_access_2m;
1946                 break;
1947         default:
1948                 DBGC ( phantom, "Phantom %p has bad BAR size\n", phantom );
1949                 return -EINVAL;
1950         }
1951
1952         phantom->bar0 = ioremap ( bar0_start, bar0_size );
1953         if ( ! phantom->bar0 ) {
1954                 DBGC ( phantom, "Phantom %p could not map BAR0\n", phantom );
1955                 return -EIO;
1956         }
1957
1958         /* Mark current CRB window as invalid, so that the first
1959          * read/write will set the current window.
1960          */
1961         phantom->crb_window = -1UL;
1962
1963         return 0;
1964 }
1965
1966 /**
1967  * Read Phantom flash contents
1968  *
1969  * @v phantom           Phantom NIC
1970  * @ret rc              Return status code
1971  */
1972 static int phantom_read_flash ( struct phantom_nic *phantom ) {
1973         struct unm_board_info board_info;
1974         int rc;
1975
1976         /* Initialise flash access */
1977         phantom->spi_bus.rw = phantom_spi_rw;
1978         phantom->flash.bus = &phantom->spi_bus;
1979         init_m25p32 ( &phantom->flash );
1980         /* Phantom doesn't support greater than 4-byte block sizes */
1981         phantom->flash.nvs.block_size = UNM_SPI_BLKSIZE;
1982
1983         /* Read and verify board information */
1984         if ( ( rc = nvs_read ( &phantom->flash.nvs, UNM_BRDCFG_START,
1985                                &board_info, sizeof ( board_info ) ) ) != 0 ) {
1986                 DBGC ( phantom, "Phantom %p could not read board info: %s\n",
1987                        phantom, strerror ( rc ) );
1988                 return rc;
1989         }
1990         if ( board_info.magic != UNM_BDINFO_MAGIC ) {
1991                 DBGC ( phantom, "Phantom %p has bad board info magic %lx\n",
1992                        phantom, board_info.magic );
1993                 DBGC_HD ( phantom, &board_info, sizeof ( board_info ) );
1994                 return -EINVAL;
1995         }
1996         if ( board_info.header_version != UNM_BDINFO_VERSION ) {
1997                 DBGC ( phantom, "Phantom %p has bad board info version %lx\n",
1998                        phantom, board_info.header_version );
1999                 DBGC_HD ( phantom, &board_info, sizeof ( board_info ) );
2000                 return -EINVAL;
2001         }
2002
2003         /* Identify board type and number of ports */
2004         switch ( board_info.board_type ) {
2005         case UNM_BRDTYPE_P3_4_GB:
2006         case UNM_BRDTYPE_P3_4_GB_MM:
2007                 phantom->num_ports = 4;
2008                 break;
2009         case UNM_BRDTYPE_P3_HMEZ:
2010         case UNM_BRDTYPE_P3_IMEZ:
2011         case UNM_BRDTYPE_P3_10G_CX4:
2012         case UNM_BRDTYPE_P3_10G_CX4_LP:
2013         case UNM_BRDTYPE_P3_10G_SFP_PLUS:
2014         case UNM_BRDTYPE_P3_XG_LOM:
2015                 phantom->num_ports = 2;
2016                 break;
2017         case UNM_BRDTYPE_P3_10000_BASE_T:
2018         case UNM_BRDTYPE_P3_10G_XFP:
2019                 phantom->num_ports = 1;
2020                 break;
2021         default:
2022                 DBGC ( phantom, "Phantom %p unrecognised board type %#lx; "
2023                        "assuming single-port\n",
2024                        phantom, board_info.board_type );
2025                 phantom->num_ports = 1;
2026                 break;
2027         }
2028         DBGC ( phantom, "Phantom %p board type is %#lx (%d ports)\n",
2029                phantom, board_info.board_type, phantom->num_ports );
2030
2031         return 0;
2032 }
2033
2034 /**
2035  * Halt all PEGs
2036  *
2037  * @v phantom           Phantom NIC
2038  */
2039 static void phantom_halt_pegs ( struct phantom_nic *phantom ) {
2040         phantom_writel ( phantom, 1, UNM_PEG_0_HALT );
2041         phantom_writel ( phantom, 1, UNM_PEG_1_HALT );
2042         phantom_writel ( phantom, 1, UNM_PEG_2_HALT );
2043         phantom_writel ( phantom, 1, UNM_PEG_3_HALT );
2044         phantom_writel ( phantom, 1, UNM_PEG_4_HALT );
2045 }
2046
2047 /**
2048  * Unhalt all PEGs
2049  *
2050  * @v phantom           Phantom NIC
2051  */
2052 static void phantom_unhalt_pegs ( struct phantom_nic *phantom ) {
2053         uint32_t halt_status;
2054
2055         halt_status = phantom_readl ( phantom, UNM_PEG_0_HALT_STATUS );
2056         phantom_writel ( phantom, halt_status, UNM_PEG_0_HALT_STATUS );
2057         halt_status = phantom_readl ( phantom, UNM_PEG_1_HALT_STATUS );
2058         phantom_writel ( phantom, halt_status, UNM_PEG_1_HALT_STATUS );
2059         halt_status = phantom_readl ( phantom, UNM_PEG_2_HALT_STATUS );
2060         phantom_writel ( phantom, halt_status, UNM_PEG_2_HALT_STATUS );
2061         halt_status = phantom_readl ( phantom, UNM_PEG_3_HALT_STATUS );
2062         phantom_writel ( phantom, halt_status, UNM_PEG_3_HALT_STATUS );
2063         halt_status = phantom_readl ( phantom, UNM_PEG_4_HALT_STATUS );
2064         phantom_writel ( phantom, halt_status, UNM_PEG_4_HALT_STATUS );
2065 }
2066
2067 /**
2068  * Initialise the Phantom command PEG
2069  *
2070  * @v phantom           Phantom NIC
2071  * @ret rc              Return status code
2072  */
2073 static int phantom_init_cmdpeg ( struct phantom_nic *phantom ) {
2074         uint32_t cold_boot;
2075         uint32_t sw_reset;
2076         physaddr_t dummy_dma_phys;
2077         unsigned int retries;
2078         uint32_t cmdpeg_state;
2079         uint32_t last_cmdpeg_state = 0;
2080
2081         /* Check for a previous initialisation.  This could have
2082          * happened if, for example, the BIOS used the UNDI API to
2083          * drive the NIC prior to a full PXE boot.
2084          */
2085         cmdpeg_state = phantom_readl ( phantom, UNM_NIC_REG_CMDPEG_STATE );
2086         if ( cmdpeg_state == UNM_NIC_REG_CMDPEG_STATE_INITIALIZE_ACK ) {
2087                 DBGC ( phantom, "Phantom %p command PEG already initialized\n",
2088                        phantom );
2089                 /* Unhalt the PEGs.  Previous firmware (e.g. BOFM) may
2090                  * have halted the PEGs to prevent internal bus
2091                  * collisions when the BIOS re-reads the expansion ROM.
2092                  */
2093                 phantom_unhalt_pegs ( phantom );
2094                 return 0;
2095         }
2096
2097         /* If this was a cold boot, check that the hardware came up ok */
2098         cold_boot = phantom_readl ( phantom, UNM_CAM_RAM_COLD_BOOT );
2099         if ( cold_boot == UNM_CAM_RAM_COLD_BOOT_MAGIC ) {
2100                 DBGC ( phantom, "Phantom %p coming up from cold boot\n",
2101                        phantom );
2102                 sw_reset = phantom_readl ( phantom, UNM_ROMUSB_GLB_SW_RESET );
2103                 if ( sw_reset != UNM_ROMUSB_GLB_SW_RESET_MAGIC ) {
2104                         DBGC ( phantom, "Phantom %p reset failed: %08lx\n",
2105                                phantom, sw_reset );
2106                         return -EIO;
2107                 }
2108         } else {
2109                 DBGC ( phantom, "Phantom %p coming up from warm boot "
2110                        "(%08lx)\n", phantom, cold_boot );
2111         }
2112         /* Clear cold-boot flag */
2113         phantom_writel ( phantom, 0, UNM_CAM_RAM_COLD_BOOT );
2114
2115         /* Set port modes */
2116         phantom_writel ( phantom, UNM_CAM_RAM_PORT_MODE_AUTO_NEG_1G,
2117                          UNM_CAM_RAM_WOL_PORT_MODE );
2118
2119         /* Pass dummy DMA area to card */
2120         dummy_dma_phys = virt_to_bus ( phantom->dma_buf->dummy_dma );
2121         DBGC ( phantom, "Phantom %p dummy DMA at %08lx\n",
2122                phantom, dummy_dma_phys );
2123         phantom_write_hilo ( phantom, dummy_dma_phys,
2124                              UNM_NIC_REG_DUMMY_BUF_ADDR_LO,
2125                              UNM_NIC_REG_DUMMY_BUF_ADDR_HI );
2126         phantom_writel ( phantom, UNM_NIC_REG_DUMMY_BUF_INIT,
2127                          UNM_NIC_REG_DUMMY_BUF );
2128
2129         /* Tell the hardware that tuning is complete */
2130         phantom_writel ( phantom, UNM_ROMUSB_GLB_PEGTUNE_DONE_MAGIC,
2131                          UNM_ROMUSB_GLB_PEGTUNE_DONE );
2132
2133         /* Wait for command PEG to finish initialising */
2134         DBGC ( phantom, "Phantom %p initialising command PEG (will take up to "
2135                "%d seconds)...\n", phantom, PHN_CMDPEG_INIT_TIMEOUT_SEC );
2136         for ( retries = 0; retries < PHN_CMDPEG_INIT_TIMEOUT_SEC; retries++ ) {
2137                 cmdpeg_state = phantom_readl ( phantom,
2138                                                UNM_NIC_REG_CMDPEG_STATE );
2139                 if ( cmdpeg_state != last_cmdpeg_state ) {
2140                         DBGC ( phantom, "Phantom %p command PEG state is "
2141                                "%08lx after %d seconds...\n",
2142                                phantom, cmdpeg_state, retries );
2143                         last_cmdpeg_state = cmdpeg_state;
2144                 }
2145                 if ( cmdpeg_state == UNM_NIC_REG_CMDPEG_STATE_INITIALIZED ) {
2146                         /* Acknowledge the PEG initialisation */
2147                         phantom_writel ( phantom,
2148                                        UNM_NIC_REG_CMDPEG_STATE_INITIALIZE_ACK,
2149                                        UNM_NIC_REG_CMDPEG_STATE );
2150                         return 0;
2151                 }
2152                 mdelay ( 1000 );
2153         }
2154
2155         DBGC ( phantom, "Phantom %p timed out waiting for command PEG to "
2156                "initialise (status %08lx)\n", phantom, cmdpeg_state );
2157         return -ETIMEDOUT;
2158 }
2159
2160 /**
2161  * Read Phantom MAC address
2162  *
2163  * @v phanton_port      Phantom NIC port
2164  * @v ll_addr           Buffer to fill with MAC address
2165  */
2166 static void phantom_get_macaddr ( struct phantom_nic_port *phantom_port,
2167                                   uint8_t *ll_addr ) {
2168         struct phantom_nic *phantom = phantom_port->phantom;
2169         union {
2170                 uint8_t mac_addr[2][ETH_ALEN];
2171                 uint32_t dwords[3];
2172         } u;
2173         unsigned long offset;
2174         int i;
2175
2176         /* Read the three dwords that include this MAC address and one other */
2177         offset = ( UNM_CAM_RAM_MAC_ADDRS +
2178                    ( 12 * ( phantom_port->port / 2 ) ) );
2179         for ( i = 0 ; i < 3 ; i++, offset += 4 ) {
2180                 u.dwords[i] = phantom_readl ( phantom, offset );
2181         }
2182
2183         /* Copy out the relevant MAC address */
2184         for ( i = 0 ; i < ETH_ALEN ; i++ ) {
2185                 ll_addr[ ETH_ALEN - i - 1 ] =
2186                         u.mac_addr[ phantom_port->port & 1 ][i];
2187         }
2188         DBGC ( phantom, "Phantom %p port %d MAC address is %s\n",
2189                phantom, phantom_port->port, eth_ntoa ( ll_addr ) );
2190 }
2191
2192 /**
2193  * Initialise Phantom receive PEG
2194  *
2195  * @v phantom           Phantom NIC
2196  * @ret rc              Return status code
2197  */
2198 static int phantom_init_rcvpeg ( struct phantom_nic *phantom ) {
2199         unsigned int retries;
2200         uint32_t rcvpeg_state;
2201         uint32_t last_rcvpeg_state = 0;
2202
2203         DBGC ( phantom, "Phantom %p initialising receive PEG (will take up to "
2204                "%d seconds)...\n", phantom, PHN_RCVPEG_INIT_TIMEOUT_SEC );
2205         for ( retries = 0; retries < PHN_RCVPEG_INIT_TIMEOUT_SEC; retries++ ) {
2206                 rcvpeg_state = phantom_readl ( phantom,
2207                                                UNM_NIC_REG_RCVPEG_STATE );
2208                 if ( rcvpeg_state != last_rcvpeg_state ) {
2209                         DBGC ( phantom, "Phantom %p receive PEG state is "
2210                                "%08lx after %d seconds...\n",
2211                                phantom, rcvpeg_state, retries );
2212                         last_rcvpeg_state = rcvpeg_state;
2213                 }
2214                 if ( rcvpeg_state == UNM_NIC_REG_RCVPEG_STATE_INITIALIZED )
2215                         return 0;
2216                 mdelay ( 1000 );
2217         }
2218
2219         DBGC ( phantom, "Phantom %p timed out waiting for receive PEG to "
2220                "initialise (status %08lx)\n", phantom, rcvpeg_state );
2221         return -ETIMEDOUT;
2222 }
2223
2224 /**
2225  * Probe PCI device
2226  *
2227  * @v pci               PCI device
2228  * @v id                PCI ID
2229  * @ret rc              Return status code
2230  */
2231 static int phantom_probe ( struct pci_device *pci,
2232                            const struct pci_device_id *id __unused ) {
2233         struct phantom_nic *phantom;
2234         struct net_device *netdev;
2235         struct phantom_nic_port *phantom_port;
2236         struct settings *parent_settings;
2237         int i;
2238         int rc;
2239
2240         /* Phantom NICs expose multiple PCI functions, used for
2241          * virtualisation.  Ignore everything except function 0.
2242          */
2243         if ( PCI_FUNC ( pci->devfn ) != 0 )
2244           return -ENODEV;
2245
2246         /* Allocate Phantom device */
2247         phantom = zalloc ( sizeof ( *phantom ) );
2248         if ( ! phantom ) {
2249                 rc = -ENOMEM;
2250                 goto err_alloc_phantom;
2251         }
2252         pci_set_drvdata ( pci, phantom );
2253
2254         /* Fix up PCI device */
2255         adjust_pci_device ( pci );
2256
2257         /* Map CRB */
2258         if ( ( rc = phantom_map_crb ( phantom, pci ) ) != 0 )
2259                 goto err_map_crb;
2260
2261         /* Read flash information */
2262         if ( ( rc = phantom_read_flash ( phantom ) ) != 0 )
2263                 goto err_read_flash;
2264
2265         /* Allocate net devices for each port */
2266         for ( i = 0 ; i < phantom->num_ports ; i++ ) {
2267                 netdev = alloc_etherdev ( sizeof ( *phantom_port ) );
2268                 if ( ! netdev ) {
2269                         rc = -ENOMEM;
2270                         goto err_alloc_etherdev;
2271                 }
2272                 phantom->netdev[i] = netdev;
2273                 netdev_init ( netdev, &phantom_operations );
2274                 phantom_port = netdev_priv ( netdev );
2275                 netdev->dev = &pci->dev;
2276                 phantom_port->phantom = phantom;
2277                 phantom_port->port = i;
2278                 settings_init ( &phantom_port->settings,
2279                                 &phantom_settings_operations,
2280                                 &netdev->refcnt, "clp", PHN_CLP_TAG_MAGIC );
2281         }
2282
2283         /* BUG5945 - need to hack PCI config space on P3 B1 silicon.
2284          * B2 will have this fixed; remove this hack when B1 is no
2285          * longer in use.
2286          */
2287         for ( i = 0 ; i < 8 ; i++ ) {
2288                 uint32_t temp;
2289                 pci->devfn = PCI_DEVFN ( PCI_SLOT ( pci->devfn ), i );
2290                 pci_read_config_dword ( pci, 0xc8, &temp );
2291                 pci_read_config_dword ( pci, 0xc8, &temp );
2292                 pci_write_config_dword ( pci, 0xc8, 0xf1000 );
2293         }
2294         pci->devfn = PCI_DEVFN ( PCI_SLOT ( pci->devfn ), 0 );
2295
2296         /* Allocate dummy DMA buffer and perform initial hardware handshake */
2297         phantom->dma_buf = malloc_dma ( sizeof ( *(phantom->dma_buf) ),
2298                                         UNM_DMA_BUFFER_ALIGN );
2299         if ( ! phantom->dma_buf )
2300                 goto err_dma_buf;
2301         if ( ( rc = phantom_init_cmdpeg ( phantom ) ) != 0 )
2302                 goto err_init_cmdpeg;
2303
2304         /* Initialise the receive firmware */
2305         if ( ( rc = phantom_init_rcvpeg ( phantom ) ) != 0 )
2306                 goto err_init_rcvpeg;
2307
2308         /* Read MAC addresses */
2309         for ( i = 0 ; i < phantom->num_ports ; i++ ) {
2310                 phantom_port = netdev_priv ( phantom->netdev[i] );
2311                 phantom_get_macaddr ( phantom_port,
2312                                       phantom->netdev[i]->ll_addr );
2313         }
2314
2315         /* Register network devices */
2316         for ( i = 0 ; i < phantom->num_ports ; i++ ) {
2317                 if ( ( rc = register_netdev ( phantom->netdev[i] ) ) != 0 ) {
2318                         DBGC ( phantom, "Phantom %p could not register port "
2319                                "%d: %s\n", phantom, i, strerror ( rc ) );
2320                         goto err_register_netdev;
2321                 }
2322         }
2323
2324         /* Register settings blocks */
2325         for ( i = 0 ; i < phantom->num_ports ; i++ ) {
2326                 phantom_port = netdev_priv ( phantom->netdev[i] );
2327                 parent_settings = netdev_settings ( phantom->netdev[i] );
2328                 if ( ( rc = register_settings ( &phantom_port->settings,
2329                                                 parent_settings ) ) != 0 ) {
2330                         DBGC ( phantom, "Phantom %p could not register port "
2331                                "%d settings: %s\n",
2332                                phantom, i, strerror ( rc ) );
2333                         goto err_register_settings;
2334                 }
2335         }
2336
2337         return 0;
2338
2339         i = ( phantom->num_ports - 1 );
2340  err_register_settings:
2341         for ( ; i >= 0 ; i-- ) {
2342                 phantom_port = netdev_priv ( phantom->netdev[i] );
2343                 unregister_settings ( &phantom_port->settings );
2344         }
2345         i = ( phantom->num_ports - 1 );
2346  err_register_netdev:
2347         for ( ; i >= 0 ; i-- )
2348                 unregister_netdev ( phantom->netdev[i] );
2349  err_init_rcvpeg:
2350         phantom_halt_pegs ( phantom );
2351  err_init_cmdpeg:
2352         free_dma ( phantom->dma_buf, sizeof ( *(phantom->dma_buf) ) );
2353         phantom->dma_buf = NULL;
2354  err_dma_buf:
2355         i = ( phantom->num_ports - 1 );
2356  err_alloc_etherdev:
2357         for ( ; i >= 0 ; i-- ) {
2358                 netdev_nullify ( phantom->netdev[i] );
2359                 netdev_put ( phantom->netdev[i] );
2360         }
2361  err_read_flash:
2362  err_map_crb:
2363         free ( phantom );
2364  err_alloc_phantom:
2365         return rc;
2366 }
2367
2368 /**
2369  * Remove PCI device
2370  *
2371  * @v pci               PCI device
2372  */
2373 static void phantom_remove ( struct pci_device *pci ) {
2374         struct phantom_nic *phantom = pci_get_drvdata ( pci );
2375         struct phantom_nic_port *phantom_port;
2376         int i;
2377
2378         for ( i = ( phantom->num_ports - 1 ) ; i >= 0 ; i-- ) {
2379                 phantom_port = netdev_priv ( phantom->netdev[i] );
2380                 unregister_settings ( &phantom_port->settings );
2381         }
2382         for ( i = ( phantom->num_ports - 1 ) ; i >= 0 ; i-- )
2383                 unregister_netdev ( phantom->netdev[i] );
2384         phantom_halt_pegs ( phantom );
2385         free_dma ( phantom->dma_buf, sizeof ( *(phantom->dma_buf) ) );
2386         phantom->dma_buf = NULL;
2387         for ( i = ( phantom->num_ports - 1 ) ; i >= 0 ; i-- ) {
2388                 netdev_nullify ( phantom->netdev[i] );
2389                 netdev_put ( phantom->netdev[i] );
2390         }
2391         free ( phantom );
2392 }
2393
2394 /** Phantom PCI IDs */
2395 static struct pci_device_id phantom_nics[] = {
2396         PCI_ROM ( 0x4040, 0x0100, "nx", "NX" ),
2397 };
2398
2399 /** Phantom PCI driver */
2400 struct pci_driver phantom_driver __pci_driver = {
2401         .ids = phantom_nics,
2402         .id_count = ( sizeof ( phantom_nics ) / sizeof ( phantom_nics[0] ) ),
2403         .probe = phantom_probe,
2404         .remove = phantom_remove,
2405 };