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