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