6189d69823e74a326f966226e376d7765e8b8cc1
[etherboot.git] / src / drivers / net / etherfabric.c
1 /**************************************************************************
2  *
3  * Etherboot driver for Level 5 Etherfabric network cards
4  *
5  * Written by Michael Brown <mbrown@fensystems.co.uk>
6  *
7  * Copyright Fen Systems Ltd. 2005
8  * Copyright Level 5 Networks Inc. 2005
9  *
10  * This software may be used and distributed according to the terms of
11  * the GNU General Public License (GPL), incorporated herein by
12  * reference.  Drivers based on or derived from this code fall under
13  * the GPL and must retain the authorship, copyright and license
14  * notice.
15  *
16  **************************************************************************
17  */
18
19 #include "etherboot.h"
20 #include "nic.h"
21 #include "pci.h"
22 #include "timer.h"
23 #define dma_addr_t unsigned long
24 #include "etherfabric.h"
25
26 /**************************************************************************
27  *
28  * Constants and macros
29  *
30  **************************************************************************
31  */
32
33 #define DBG(...)
34
35 #define EFAB_ASSERT(x)                                                        \
36         do {                                                                  \
37                 if ( ! (x) ) {                                                \
38                         DBG ( "ASSERT(%s) failed at %s line %d [%s]\n", #x,   \
39                               __FILE__, __LINE__, __FUNCTION__ );             \
40                 }                                                             \
41         } while (0)
42
43 #define EFAB_TRACE(...)
44
45 #define EFAB_REGDUMP(...)
46
47 #define FALCON_USE_IO_BAR 1
48
49 /*
50  * EtherFabric constants 
51  *
52  */
53
54 /* PCI Definitions */
55 #define EFAB_VENDID_LEVEL5      0x1924
56 #define FALCON_P_DEVID          0x0703  /* Temporary PCI ID */
57 #define EF1002_DEVID            0xC101
58
59 /**************************************************************************
60  *
61  * Data structures
62  *
63  **************************************************************************
64  */
65
66 /*
67  * Buffers used for TX, RX and event queue
68  *
69  */
70 #define EFAB_BUF_ALIGN          4096
71 #define EFAB_DATA_BUF_SIZE      2048
72 #define EFAB_RX_BUFS            16
73 #define EFAB_RXD_SIZE           512
74 #define EFAB_TXD_SIZE           512
75 #define EFAB_EVQ_SIZE           512
76 struct efab_buffers {
77         uint8_t eventq[4096];
78         uint8_t rxd[4096];
79         uint8_t txd[4096];
80         uint8_t tx_buf[EFAB_DATA_BUF_SIZE];
81         uint8_t rx_buf[EFAB_RX_BUFS][EFAB_DATA_BUF_SIZE];
82         uint8_t padding[EFAB_BUF_ALIGN-1];
83 };
84 static struct efab_buffers efab_buffers;
85
86 /** An RX buffer */
87 struct efab_rx_buf {
88         uint8_t *addr;
89         unsigned int len;
90         int id;
91 };
92
93 /** A TX buffer */
94 struct efab_tx_buf {
95         uint8_t *addr;
96         unsigned int len;
97         int id;
98 };
99
100 /** Etherfabric event type */
101 enum efab_event_type {
102         EFAB_EV_NONE = 0,
103         EFAB_EV_TX,
104         EFAB_EV_RX,
105 };
106
107 /** Etherfabric event */
108 struct efab_event {
109         /** Event type */
110         enum efab_event_type type;
111         /** RX buffer ID */
112         int rx_id;
113         /** RX length */
114         unsigned int rx_len;
115 };
116
117 /*
118  * Etherfabric abstraction layer
119  *
120  */
121 struct efab_nic;
122 struct efab_operations {
123         void ( * get_membase ) ( struct efab_nic *efab );
124         int ( * reset ) ( struct efab_nic *efab );
125         int ( * init_nic ) ( struct efab_nic *efab );
126         int ( * read_eeprom ) ( struct efab_nic *efab );
127         void ( * build_rx_desc ) ( struct efab_nic *efab,
128                                    struct efab_rx_buf *rx_buf );
129         void ( * notify_rx_desc ) ( struct efab_nic *efab );
130         void ( * build_tx_desc ) ( struct efab_nic *efab,
131                                    struct efab_tx_buf *tx_buf );
132         void ( * notify_tx_desc ) ( struct efab_nic *efab );
133         int ( * fetch_event ) ( struct efab_nic *efab,
134                                 struct efab_event *event );
135         void ( * mask_irq ) ( struct efab_nic *efab, int enabled );
136         void ( * generate_irq ) ( struct efab_nic *efab );
137         void ( * mac_writel ) ( struct efab_nic *efab, efab_dword_t *value,
138                                 unsigned int mac_reg );
139         void ( * mac_readl ) ( struct efab_nic *efab, efab_dword_t *value,
140                                unsigned int mac_reg );
141         int ( * init_mac ) ( struct efab_nic *efab );
142         void ( * mdio_write ) ( struct efab_nic *efab, int location,
143                                 int value );
144         int ( * mdio_read ) ( struct efab_nic *efab, int location );
145 };
146
147 /*
148  * Driver private data structure
149  *
150  */
151 struct efab_nic {
152
153         /** PCI device */
154         struct pci_device *pci;
155
156         /** Operations table */
157         struct efab_operations *op;
158
159         /** Memory base */
160         void *membase;
161
162         /** I/O base */
163         unsigned int iobase;
164
165         /** Buffers */
166         uint8_t *eventq;                /* Falcon only */
167         uint8_t *txd;                   /* Falcon only */
168         uint8_t *rxd;                   /* Falcon only */
169         struct efab_tx_buf tx_buf;
170         struct efab_rx_buf rx_bufs[EFAB_RX_BUFS];
171
172         /** Buffer pointers */
173         unsigned int eventq_read_ptr;   /* Falcon only */
174         unsigned int tx_write_ptr;
175         unsigned int rx_write_ptr;
176         int tx_in_progress;
177
178         /** Port 0/1 on the NIC */
179         int port;
180
181         /** MAC address */
182         uint8_t mac_addr[ETH_ALEN];
183         /** GMII link options */
184         unsigned int link_options;
185         /** Link status */
186         int link_up;
187
188         /** INT_REG_KER for Falcon */
189         efab_oword_t int_ker __attribute__ (( aligned ( 16 ) ));
190 };
191
192 /**************************************************************************
193  *
194  * i2c EEPROM access
195  *
196  **************************************************************************
197  */
198
199 struct efab_i2c_interface;
200
201 /** i2c bus direct control methods */
202 struct efab_i2c_bit_operations {
203         /** Set state of SDA line */
204         void ( * setsda ) ( struct efab_i2c_interface *i2c );
205         /** Set state of SCL line */
206         void ( * setscl ) ( struct efab_i2c_interface *i2c );
207         /** Get state of SDA line */
208         int ( * getsda ) ( struct efab_i2c_interface *i2c );
209         /** Get state of SCL line */
210         int ( * getscl ) ( struct efab_i2c_interface *i2c );
211         /** Delay between each bit operation */
212         unsigned int udelay;
213         /** Delay between each byte write */
214         unsigned int mdelay;
215 };
216
217 /** An i2c interface */
218 struct efab_i2c_interface {
219         /** Attached Etherfabric NIC */
220         struct efab_nic *efab;
221         /** I2C bus control methods */
222         struct efab_i2c_bit_operations *op;
223         /** Current output state of SDA line */
224         unsigned int sda : 1;
225         /** Current output state of SCL line */
226         unsigned int scl : 1;
227 };
228
229 /*
230  * SDA and SCL line read/writes
231  *
232  */
233
234 static inline void setsda ( struct efab_i2c_interface *i2c, int state ) {
235         udelay ( i2c->op->udelay );
236         i2c->sda = state;
237         i2c->op->setsda ( i2c );
238         udelay ( i2c->op->udelay );
239 }
240
241 static inline void setscl ( struct efab_i2c_interface *i2c, int state ) {
242         udelay ( i2c->op->udelay );
243         i2c->scl = state;
244         i2c->op->setscl ( i2c );
245         udelay ( i2c->op->udelay );
246 }
247
248 static inline int getsda ( struct efab_i2c_interface *i2c ) {
249         int sda;
250
251         udelay ( i2c->op->udelay );
252         sda = i2c->op->getsda ( i2c );
253         udelay ( i2c->op->udelay );
254         return sda;
255 }
256
257 static inline int getscl ( struct efab_i2c_interface *i2c ) {
258         int scl;
259
260         udelay ( i2c->op->udelay );
261         scl = i2c->op->getscl ( i2c );
262         udelay ( i2c->op->udelay );
263         return scl;
264 }
265
266 /*
267  * i2c low-level protocol operations
268  *
269  */
270
271 static inline void i2c_release ( struct efab_i2c_interface *i2c ) {
272         EFAB_ASSERT ( i2c->scl );
273         EFAB_ASSERT ( i2c->sda );
274         /* Just in case */
275         setscl ( i2c, 1 );
276         setsda ( i2c, 1 );
277         EFAB_ASSERT ( getsda ( i2c ) == 1 );
278         EFAB_ASSERT ( getscl ( i2c ) == 1 );
279 }
280
281 static inline void i2c_start ( struct efab_i2c_interface *i2c ) {
282         /* We may be restarting immediately after a {send,recv}_bit,
283          * so SCL will not necessarily already be high.
284          */
285         EFAB_ASSERT ( i2c->sda );
286         setscl ( i2c, 1 );
287         setsda ( i2c, 0 );
288         setscl ( i2c, 0 );
289         setsda ( i2c, 1 );
290 }
291
292 static inline void i2c_send_bit ( struct efab_i2c_interface *i2c, int bit ) {
293         EFAB_ASSERT ( ! i2c->scl );
294         setsda ( i2c, bit );
295         setscl ( i2c, 1 );
296         setscl ( i2c, 0 );
297         setsda ( i2c, 1 );
298 }
299
300 static inline int i2c_recv_bit ( struct efab_i2c_interface *i2c ) {
301         int bit;
302
303         EFAB_ASSERT ( ! i2c->scl );
304         EFAB_ASSERT ( i2c->sda );
305         setscl ( i2c, 1 );
306         bit = getsda ( i2c );
307         setscl ( i2c, 0 );
308         return bit;
309 }
310
311 static inline void i2c_stop ( struct efab_i2c_interface *i2c ) {
312         EFAB_ASSERT ( ! i2c->scl );
313         setsda ( i2c, 0 );
314         setscl ( i2c, 1 );
315         setsda ( i2c, 1 );
316 }
317
318 /*
319  * i2c mid-level protocol operations
320  *
321  */
322
323 static int i2c_send_byte ( struct efab_i2c_interface *i2c, uint8_t byte ) {
324         int i;
325         
326         /* Send byte */
327         for ( i = 0 ; i < 8 ; i++ ) {
328                 i2c_send_bit ( i2c, !! ( byte & 0x80 ) );
329                 byte <<= 1;
330         }
331
332         /* Check for acknowledgement from slave */
333         return ( i2c_recv_bit ( i2c ) == 0 ? 1 : 0 );
334 }
335
336 static uint8_t i2c_recv_byte ( struct efab_i2c_interface *i2c, int ack ) {
337         uint8_t value = 0;
338         int i;
339
340         /* Receive byte */
341         for ( i = 0 ; i < 8 ; i++ ) {
342                 value = ( value << 1 ) | i2c_recv_bit ( i2c );
343         }
344
345         /* Send ACK/NACK */
346         i2c_send_bit ( i2c, ( ack ? 0 : 1 )  );
347
348         return value;
349 }
350
351 static inline uint8_t i2c_read_cmd ( uint8_t device_id ) {
352         return ( ( device_id << 1 ) | 1 );
353 }
354
355 static inline uint8_t i2c_write_cmd ( uint8_t device_id ) {
356         return ( ( device_id << 1 ) | 0 );
357 }
358
359 static int efab_i2c_fast_read ( struct efab_i2c_interface *i2c,
360                                 uint8_t device_id, uint8_t offset,
361                                 uint8_t *data, unsigned int len ) {
362         unsigned int i;
363         int rc = 0;
364
365         EFAB_ASSERT ( getsda ( i2c ) == 1 );
366         EFAB_ASSERT ( getscl ( i2c ) == 1 );
367         EFAB_ASSERT ( data != NULL );
368         EFAB_ASSERT ( len >= 1 );
369
370         /* Select device and starting offset */
371         i2c_start ( i2c );
372         if ( ! i2c_send_byte ( i2c, i2c_write_cmd ( device_id ) ) )
373                 goto out;
374         if ( ! i2c_send_byte ( i2c, offset ) )
375                 goto out;
376
377         /* Read data from device */
378         i2c_start ( i2c );
379         if ( ! i2c_send_byte ( i2c, i2c_read_cmd ( device_id ) ) )
380                 goto out;
381         for ( i = 0 ; i < ( len - 1 ); i++ ) {
382                 /* Read and acknowledge all but the last byte */
383                 data[i] = i2c_recv_byte ( i2c, 1 );
384         }
385         /* Read last byte with no acknowledgement */
386         data[i] = i2c_recv_byte ( i2c, 0 );
387         
388         rc = 1;
389  out:
390         i2c_stop ( i2c );
391         i2c_release ( i2c );
392
393         return rc;
394 }
395
396 /**************************************************************************
397  *
398  * GMII routines
399  *
400  **************************************************************************
401  */
402
403 /* GMII registers */
404 #define MII_BMSR                0x01    /* Basic mode status register  */
405 #define MII_ADVERTISE           0x04    /* Advertisement control register */
406 #define MII_LPA                 0x05    /* Link partner ability register*/
407 #define GMII_GTCR               0x09    /* 1000BASE-T control register */
408 #define GMII_GTSR               0x0a    /* 1000BASE-T status register */
409 #define GMII_PSSR               0x11    /* PHY-specific status register */
410
411 /* Basic mode status register. */
412 #define BMSR_LSTATUS            0x0004  /* Link status                 */
413
414 /* Link partner ability register. */
415 #define LPA_10HALF              0x0020  /* Can do 10mbps half-duplex   */
416 #define LPA_10FULL              0x0040  /* Can do 10mbps full-duplex   */
417 #define LPA_100HALF             0x0080  /* Can do 100mbps half-duplex  */
418 #define LPA_100FULL             0x0100  /* Can do 100mbps full-duplex  */
419 #define LPA_100BASE4            0x0200  /* Can do 100mbps 4k packets   */
420 #define LPA_PAUSE               0x0400  /* Bit 10 - MAC pause */
421
422 /* Pseudo extensions to the link partner ability register */
423 #define LPA_1000FULL            0x00020000
424 #define LPA_1000HALF            0x00010000
425
426 #define LPA_100                 (LPA_100FULL | LPA_100HALF | LPA_100BASE4)
427 #define LPA_1000                ( LPA_1000FULL | LPA_1000HALF )
428 #define LPA_DUPLEX              ( LPA_10FULL | LPA_100FULL | LPA_1000FULL )
429
430 /* Mask of bits not associated with speed or duplexity. */
431 #define LPA_OTHER               ~( LPA_10FULL | LPA_10HALF | LPA_100FULL | \
432                                    LPA_100HALF | LPA_1000FULL | LPA_1000HALF )
433
434 /* PHY-specific status register */
435 #define PSSR_LSTATUS            0x0400  /* Bit 10 - link status */
436
437 /**
438  * Retrieve GMII autonegotiation advertised abilities
439  *
440  */
441 static unsigned int gmii_autoneg_advertised ( struct efab_nic *efab ) {
442         unsigned int mii_advertise;
443         unsigned int gmii_advertise;
444         
445         /* Extended bits are in bits 8 and 9 of GMII_GTCR */
446         mii_advertise = efab->op->mdio_read ( efab, MII_ADVERTISE );
447         gmii_advertise = ( ( efab->op->mdio_read ( efab, GMII_GTCR ) >> 8 )
448                            & 0x03 );
449         return ( ( gmii_advertise << 16 ) | mii_advertise );
450 }
451
452 /**
453  * Retrieve GMII autonegotiation link partner abilities
454  *
455  */
456 static unsigned int gmii_autoneg_lpa ( struct efab_nic *efab ) {
457         unsigned int mii_lpa;
458         unsigned int gmii_lpa;
459         
460         /* Extended bits are in bits 10 and 11 of GMII_GTSR */
461         mii_lpa = efab->op->mdio_read ( efab, MII_LPA );
462         gmii_lpa = ( efab->op->mdio_read ( efab, GMII_GTSR ) >> 10 ) & 0x03;
463         return ( ( gmii_lpa << 16 ) | mii_lpa );
464 }
465
466 /**
467  * Calculate GMII autonegotiated link technology
468  *
469  */
470 static unsigned int gmii_nway_result ( unsigned int negotiated ) {
471         unsigned int other_bits;
472
473         /* Mask out the speed and duplexity bits */
474         other_bits = negotiated & LPA_OTHER;
475
476         if ( negotiated & LPA_1000FULL )
477                 return ( other_bits | LPA_1000FULL );
478         else if ( negotiated & LPA_1000HALF )
479                 return ( other_bits | LPA_1000HALF );
480         else if ( negotiated & LPA_100FULL )
481                 return ( other_bits | LPA_100FULL );
482         else if ( negotiated & LPA_100BASE4 )
483                 return ( other_bits | LPA_100BASE4 );
484         else if ( negotiated & LPA_100HALF )
485                 return ( other_bits | LPA_100HALF );
486         else if ( negotiated & LPA_10FULL )
487                 return ( other_bits | LPA_10FULL );
488         else return ( other_bits | LPA_10HALF );
489 }
490
491 /**
492  * Check GMII PHY link status
493  *
494  */
495 static int gmii_link_ok ( struct efab_nic *efab ) {
496         int status;
497         int phy_status;
498         
499         /* BMSR is latching - it returns "link down" if the link has
500          * been down at any point since the last read.  To get a
501          * real-time status, we therefore read the register twice and
502          * use the result of the second read.
503          */
504         efab->op->mdio_read ( efab, MII_BMSR );
505         status = efab->op->mdio_read ( efab, MII_BMSR );
506
507         /* Read the PHY-specific Status Register.  This is
508          * non-latching, so we need do only a single read.
509          */
510         phy_status = efab->op->mdio_read ( efab, GMII_PSSR );
511
512         return ( ( status & BMSR_LSTATUS ) && ( phy_status & PSSR_LSTATUS ) );
513 }
514
515 /**************************************************************************
516  *
517  * Alaska PHY
518  *
519  **************************************************************************
520  */
521
522 /**
523  * Initialise Alaska PHY
524  *
525  */
526 static void alaska_init ( struct efab_nic *efab ) {
527         unsigned int advertised, lpa;
528
529         /* Read link up status */
530         efab->link_up = gmii_link_ok ( efab );
531
532         if ( ! efab->link_up )
533                 return;
534
535         /* Determine link options from PHY. */
536         advertised = gmii_autoneg_advertised ( efab );
537         lpa = gmii_autoneg_lpa ( efab );
538         efab->link_options = gmii_nway_result ( advertised & lpa );
539
540         printf ( "%dMbps %s-duplex (%04x,%04x)\n",
541                  ( efab->link_options & LPA_1000 ? 1000 :
542                    ( efab->link_options & LPA_100 ? 100 : 10 ) ),
543                  ( efab->link_options & LPA_DUPLEX ? "full" : "half" ),
544                  advertised, lpa );
545 }
546
547 /**************************************************************************
548  *
549  * Mentor MAC
550  *
551  **************************************************************************
552  */
553
554 /* GMAC configuration register 1 */
555 #define GM_CFG1_REG_MAC 0x00
556 #define GM_SW_RST_LBN 31
557 #define GM_SW_RST_WIDTH 1
558 #define GM_RX_FC_EN_LBN 5
559 #define GM_RX_FC_EN_WIDTH 1
560 #define GM_TX_FC_EN_LBN 4
561 #define GM_TX_FC_EN_WIDTH 1
562 #define GM_RX_EN_LBN 2
563 #define GM_RX_EN_WIDTH 1
564 #define GM_TX_EN_LBN 0
565 #define GM_TX_EN_WIDTH 1
566
567 /* GMAC configuration register 2 */
568 #define GM_CFG2_REG_MAC 0x01
569 #define GM_PAMBL_LEN_LBN 12
570 #define GM_PAMBL_LEN_WIDTH 4
571 #define GM_IF_MODE_LBN 8
572 #define GM_IF_MODE_WIDTH 2
573 #define GM_PAD_CRC_EN_LBN 2
574 #define GM_PAD_CRC_EN_WIDTH 1
575 #define GM_FD_LBN 0
576 #define GM_FD_WIDTH 1
577
578 /* GMAC maximum frame length register */
579 #define GM_MAX_FLEN_REG_MAC 0x04
580 #define GM_MAX_FLEN_LBN 0
581 #define GM_MAX_FLEN_WIDTH 16
582
583 /* GMAC MII management configuration register */
584 #define GM_MII_MGMT_CFG_REG_MAC 0x08
585 #define GM_MGMT_CLK_SEL_LBN 0
586 #define GM_MGMT_CLK_SEL_WIDTH 3
587
588 /* GMAC MII management command register */
589 #define GM_MII_MGMT_CMD_REG_MAC 0x09
590 #define GM_MGMT_SCAN_CYC_LBN 1
591 #define GM_MGMT_SCAN_CYC_WIDTH 1
592 #define GM_MGMT_RD_CYC_LBN 0
593 #define GM_MGMT_RD_CYC_WIDTH 1
594
595 /* GMAC MII management address register */
596 #define GM_MII_MGMT_ADR_REG_MAC 0x0a
597 #define GM_MGMT_PHY_ADDR_LBN 8
598 #define GM_MGMT_PHY_ADDR_WIDTH 5
599 #define GM_MGMT_REG_ADDR_LBN 0
600 #define GM_MGMT_REG_ADDR_WIDTH 5
601
602 /* GMAC MII management control register */
603 #define GM_MII_MGMT_CTL_REG_MAC 0x0b
604 #define GM_MGMT_CTL_LBN 0
605 #define GM_MGMT_CTL_WIDTH 16
606
607 /* GMAC MII management status register */
608 #define GM_MII_MGMT_STAT_REG_MAC 0x0c
609 #define GM_MGMT_STAT_LBN 0
610 #define GM_MGMT_STAT_WIDTH 16
611
612 /* GMAC MII management indicators register */
613 #define GM_MII_MGMT_IND_REG_MAC 0x0d
614 #define GM_MGMT_BUSY_LBN 0
615 #define GM_MGMT_BUSY_WIDTH 1
616
617 /* GMAC station address register 1 */
618 #define GM_ADR1_REG_MAC 0x10
619 #define GM_HWADDR_5_LBN 24
620 #define GM_HWADDR_5_WIDTH 8
621 #define GM_HWADDR_4_LBN 16
622 #define GM_HWADDR_4_WIDTH 8
623 #define GM_HWADDR_3_LBN 8
624 #define GM_HWADDR_3_WIDTH 8
625 #define GM_HWADDR_2_LBN 0
626 #define GM_HWADDR_2_WIDTH 8
627
628 /* GMAC station address register 2 */
629 #define GM_ADR2_REG_MAC 0x11
630 #define GM_HWADDR_1_LBN 24
631 #define GM_HWADDR_1_WIDTH 8
632 #define GM_HWADDR_0_LBN 16
633 #define GM_HWADDR_0_WIDTH 8
634
635 /* GMAC FIFO configuration register 0 */
636 #define GMF_CFG0_REG_MAC 0x12
637 #define GMF_FTFENREQ_LBN 12
638 #define GMF_FTFENREQ_WIDTH 1
639 #define GMF_STFENREQ_LBN 11
640 #define GMF_STFENREQ_WIDTH 1
641 #define GMF_FRFENREQ_LBN 10
642 #define GMF_FRFENREQ_WIDTH 1
643 #define GMF_SRFENREQ_LBN 9
644 #define GMF_SRFENREQ_WIDTH 1
645 #define GMF_WTMENREQ_LBN 8
646 #define GMF_WTMENREQ_WIDTH 1
647
648 /* GMAC FIFO configuration register 1 */
649 #define GMF_CFG1_REG_MAC 0x13
650 #define GMF_CFGFRTH_LBN 16
651 #define GMF_CFGFRTH_WIDTH 5
652 #define GMF_CFGXOFFRTX_LBN 0
653 #define GMF_CFGXOFFRTX_WIDTH 16
654
655 /* GMAC FIFO configuration register 2 */
656 #define GMF_CFG2_REG_MAC 0x14
657 #define GMF_CFGHWM_LBN 16
658 #define GMF_CFGHWM_WIDTH 6
659 #define GMF_CFGLWM_LBN 0
660 #define GMF_CFGLWM_WIDTH 6
661
662 /* GMAC FIFO configuration register 3 */
663 #define GMF_CFG3_REG_MAC 0x15
664 #define GMF_CFGHWMFT_LBN 16
665 #define GMF_CFGHWMFT_WIDTH 6
666 #define GMF_CFGFTTH_LBN 0
667 #define GMF_CFGFTTH_WIDTH 6
668
669 /* GMAC FIFO configuration register 4 */
670 #define GMF_CFG4_REG_MAC 0x16
671 #define GMF_HSTFLTRFRM_PAUSE_LBN 12
672 #define GMF_HSTFLTRFRM_PAUSE_WIDTH 12
673
674 /* GMAC FIFO configuration register 5 */
675 #define GMF_CFG5_REG_MAC 0x17
676 #define GMF_CFGHDPLX_LBN 22
677 #define GMF_CFGHDPLX_WIDTH 1
678 #define GMF_CFGBYTMODE_LBN 19
679 #define GMF_CFGBYTMODE_WIDTH 1
680 #define GMF_HSTDRPLT64_LBN 18
681 #define GMF_HSTDRPLT64_WIDTH 1
682 #define GMF_HSTFLTRFRMDC_PAUSE_LBN 12
683 #define GMF_HSTFLTRFRMDC_PAUSE_WIDTH 1
684
685 struct efab_mentormac_parameters {
686         int gmf_cfgfrth;
687         int gmf_cfgftth;
688         int gmf_cfghwmft;
689         int gmf_cfghwm;
690         int gmf_cfglwm;
691 };
692
693 /**
694  * Reset Mentor MAC
695  *
696  */
697 static void mentormac_reset ( struct efab_nic *efab ) {
698         efab_dword_t reg;
699         int save_port;
700
701         /* Take into reset */
702         EFAB_POPULATE_DWORD_1 ( reg, GM_SW_RST, 1 );
703         efab->op->mac_writel ( efab, &reg, GM_CFG1_REG_MAC );
704         udelay ( 1000 );
705
706         /* Take out of reset */
707         EFAB_POPULATE_DWORD_1 ( reg, GM_SW_RST, 0 );
708         efab->op->mac_writel ( efab, &reg, GM_CFG1_REG_MAC );
709         udelay ( 1000 );
710
711         /* Mentor MAC connects both PHYs to MAC 0 */
712         save_port = efab->port;
713         efab->port = 0;
714         /* Configure GMII interface so PHY is accessible.  Note that
715          * GMII interface is connected only to port 0, and that on
716          * Falcon this is a no-op.
717          */
718         EFAB_POPULATE_DWORD_1 ( reg, GM_MGMT_CLK_SEL, 0x4 );
719         efab->op->mac_writel ( efab, &reg, GM_MII_MGMT_CFG_REG_MAC );
720         udelay ( 10 );
721         efab->port = save_port;
722 }
723
724 /**
725  * Initialise Mentor MAC
726  *
727  */
728 static void mentormac_init ( struct efab_nic *efab,
729                              struct efab_mentormac_parameters *params ) {
730         int pause, if_mode, full_duplex, bytemode, half_duplex;
731         efab_dword_t reg;
732
733         /* Configuration register 1 */
734         pause = ( efab->link_options & LPA_PAUSE ) ? 1 : 0;
735         if ( ! ( efab->link_options & LPA_DUPLEX ) ) {
736                 /* Half-duplex operation requires TX flow control */
737                 pause = 1;
738         }
739         EFAB_POPULATE_DWORD_4 ( reg,
740                                 GM_TX_EN, 1,
741                                 GM_TX_FC_EN, pause,
742                                 GM_RX_EN, 1,
743                                 GM_RX_FC_EN, 1 );
744         efab->op->mac_writel ( efab, &reg, GM_CFG1_REG_MAC );
745         udelay ( 10 );
746
747         /* Configuration register 2 */
748         if_mode = ( efab->link_options & LPA_1000 ) ? 2 : 1;
749         full_duplex = ( efab->link_options & LPA_DUPLEX ) ? 1 : 0;
750         EFAB_POPULATE_DWORD_4 ( reg,
751                                 GM_IF_MODE, if_mode,
752                                 GM_PAD_CRC_EN, 1,
753                                 GM_FD, full_duplex,
754                                 GM_PAMBL_LEN, 0x7 /* ? */ );
755         efab->op->mac_writel ( efab, &reg, GM_CFG2_REG_MAC );
756         udelay ( 10 );
757
758         /* Max frame len register */
759         EFAB_POPULATE_DWORD_1 ( reg, GM_MAX_FLEN, ETH_FRAME_LEN );
760         efab->op->mac_writel ( efab, &reg, GM_MAX_FLEN_REG_MAC );
761         udelay ( 10 );
762
763         /* FIFO configuration register 0 */
764         EFAB_POPULATE_DWORD_5 ( reg,
765                                 GMF_FTFENREQ, 1,
766                                 GMF_STFENREQ, 1,
767                                 GMF_FRFENREQ, 1,
768                                 GMF_SRFENREQ, 1,
769                                 GMF_WTMENREQ, 1 );
770         efab->op->mac_writel ( efab, &reg, GMF_CFG0_REG_MAC );
771         udelay ( 10 );
772
773         /* FIFO configuration register 1 */
774         EFAB_POPULATE_DWORD_2 ( reg,
775                                 GMF_CFGFRTH, params->gmf_cfgfrth,
776                                 GMF_CFGXOFFRTX, 0xffff );
777         efab->op->mac_writel ( efab, &reg, GMF_CFG1_REG_MAC );
778         udelay ( 10 );
779
780         /* FIFO configuration register 2 */
781         EFAB_POPULATE_DWORD_2 ( reg,
782                                 GMF_CFGHWM, params->gmf_cfghwm,
783                                 GMF_CFGLWM, params->gmf_cfglwm );
784         efab->op->mac_writel ( efab, &reg, GMF_CFG2_REG_MAC );
785         udelay ( 10 );
786
787         /* FIFO configuration register 3 */
788         EFAB_POPULATE_DWORD_2 ( reg,
789                                 GMF_CFGHWMFT, params->gmf_cfghwmft,
790                                 GMF_CFGFTTH, params->gmf_cfgftth );
791         efab->op->mac_writel ( efab, &reg, GMF_CFG3_REG_MAC );
792         udelay ( 10 );
793
794         /* FIFO configuration register 4 */
795         EFAB_POPULATE_DWORD_1 ( reg, GMF_HSTFLTRFRM_PAUSE, 1 );
796         efab->op->mac_writel ( efab, &reg, GMF_CFG4_REG_MAC );
797         udelay ( 10 );
798         
799         /* FIFO configuration register 5 */
800         bytemode = ( efab->link_options & LPA_1000 ) ? 1 : 0;
801         half_duplex = ( efab->link_options & LPA_DUPLEX ) ? 0 : 1;
802         efab->op->mac_readl ( efab, &reg, GMF_CFG5_REG_MAC );
803         EFAB_SET_DWORD_FIELD ( reg, GMF_CFGBYTMODE, bytemode );
804         EFAB_SET_DWORD_FIELD ( reg, GMF_CFGHDPLX, half_duplex );
805         EFAB_SET_DWORD_FIELD ( reg, GMF_HSTDRPLT64, half_duplex );
806         EFAB_SET_DWORD_FIELD ( reg, GMF_HSTFLTRFRMDC_PAUSE, 0 );
807         efab->op->mac_writel ( efab, &reg, GMF_CFG5_REG_MAC );
808         udelay ( 10 );
809         
810         /* MAC address */
811         EFAB_POPULATE_DWORD_4 ( reg,
812                                 GM_HWADDR_5, efab->mac_addr[5],
813                                 GM_HWADDR_4, efab->mac_addr[4],
814                                 GM_HWADDR_3, efab->mac_addr[3],
815                                 GM_HWADDR_2, efab->mac_addr[2] );
816         efab->op->mac_writel ( efab, &reg, GM_ADR1_REG_MAC );
817         udelay ( 10 );
818         EFAB_POPULATE_DWORD_2 ( reg,
819                                 GM_HWADDR_1, efab->mac_addr[1],
820                                 GM_HWADDR_0, efab->mac_addr[0] );
821         efab->op->mac_writel ( efab, &reg, GM_ADR2_REG_MAC );
822         udelay ( 10 );
823 }
824
825 /**
826  * Wait for GMII access to complete
827  *
828  */
829 static int mentormac_gmii_wait ( struct efab_nic *efab ) {
830         int count;
831         efab_dword_t indicator;
832
833         for ( count = 0 ; count < 1000 ; count++ ) {
834                 udelay ( 10 );
835                 efab->op->mac_readl ( efab, &indicator,
836                                       GM_MII_MGMT_IND_REG_MAC );
837                 if ( EFAB_DWORD_FIELD ( indicator, GM_MGMT_BUSY ) == 0 )
838                         return 1;
839         }
840         printf ( "Timed out waiting for GMII\n" );
841         return 0;
842 }
843
844 /**
845  * Write a GMII register
846  *
847  */
848 static void mentormac_mdio_write ( struct efab_nic *efab, int phy_id,
849                                    int location, int value ) {
850         efab_dword_t reg;
851         int save_port;
852
853         EFAB_TRACE ( "Writing GMII %d register %02x with %04x\n", phy_id,
854                      location, value );
855
856         /* Mentor MAC connects both PHYs to MAC 0 */
857         save_port = efab->port;
858         efab->port = 0;
859
860         /* Check MII not currently being accessed */
861         if ( ! mentormac_gmii_wait ( efab ) )
862                 goto out;
863
864         /* Write the address register */
865         EFAB_POPULATE_DWORD_2 ( reg,
866                                 GM_MGMT_PHY_ADDR, phy_id,
867                                 GM_MGMT_REG_ADDR, location );
868         efab->op->mac_writel ( efab, &reg, GM_MII_MGMT_ADR_REG_MAC );
869         udelay ( 10 );
870
871         /* Write data */
872         EFAB_POPULATE_DWORD_1 ( reg, GM_MGMT_CTL, value );
873         efab->op->mac_writel ( efab, &reg, GM_MII_MGMT_CTL_REG_MAC );
874
875         /* Wait for data to be written */
876         mentormac_gmii_wait ( efab );
877
878  out:
879         /* Restore efab->port */
880         efab->port = save_port;
881 }
882
883 /**
884  * Read a GMII register
885  *
886  */
887 static int mentormac_mdio_read ( struct efab_nic *efab, int phy_id,
888                                  int location ) {
889         efab_dword_t reg;
890         int value = 0xffff;
891         int save_port;
892
893         /* Mentor MAC connects both PHYs to MAC 0 */
894         save_port = efab->port;
895         efab->port = 0;
896
897         /* Check MII not currently being accessed */
898         if ( ! mentormac_gmii_wait ( efab ) )
899                 goto out;
900
901         /* Write the address register */
902         EFAB_POPULATE_DWORD_2 ( reg,
903                                 GM_MGMT_PHY_ADDR, phy_id,
904                                 GM_MGMT_REG_ADDR, location );
905         efab->op->mac_writel ( efab, &reg, GM_MII_MGMT_ADR_REG_MAC );
906         udelay ( 10 );
907
908         /* Request data to be read */
909         EFAB_POPULATE_DWORD_1 ( reg, GM_MGMT_RD_CYC, 1 );
910         efab->op->mac_writel ( efab, &reg, GM_MII_MGMT_CMD_REG_MAC );
911
912         /* Wait for data to be become available */
913         if ( mentormac_gmii_wait ( efab ) ) {
914                 /* Read data */
915                 efab->op->mac_readl ( efab, &reg, GM_MII_MGMT_STAT_REG_MAC );
916                 value = EFAB_DWORD_FIELD ( reg, GM_MGMT_STAT );
917                 EFAB_TRACE ( "Read from GMII %d register %02x, got %04x\n",
918                              phy_id, location, value );
919         }
920
921         /* Signal completion */
922         EFAB_ZERO_DWORD ( reg );
923         efab->op->mac_writel ( efab, &reg, GM_MII_MGMT_CMD_REG_MAC );
924         udelay ( 10 );
925
926  out:
927         /* Restore efab->port */
928         efab->port = save_port;
929
930         return value;
931 }
932
933 /**************************************************************************
934  *
935  * EF1002 routines
936  *
937  **************************************************************************
938  */
939
940 /** Control and General Status */
941 #define EF1_CTR_GEN_STATUS0_REG 0x0
942 #define EF1_MASTER_EVENTS_LBN 12
943 #define EF1_MASTER_EVENTS_WIDTH 1
944 #define EF1_TX_ENGINE_EN_LBN 19
945 #define EF1_TX_ENGINE_EN_WIDTH 1
946 #define EF1_RX_ENGINE_EN_LBN 18
947 #define EF1_RX_ENGINE_EN_WIDTH 1
948 #define EF1_LB_RESET_LBN 3
949 #define EF1_LB_RESET_WIDTH 1
950 #define EF1_MAC_RESET_LBN 2
951 #define EF1_MAC_RESET_WIDTH 1
952 #define EF1_CAM_ENABLE_LBN 1
953 #define EF1_CAM_ENABLE_WIDTH 1
954
955 /** IRQ sources */
956 #define EF1_IRQ_SRC_REG 0x0008
957
958 /** IRQ mask */
959 #define EF1_IRQ_MASK_REG 0x000c
960 #define EF1_IRQ_PHY1_LBN 11
961 #define EF1_IRQ_PHY1_WIDTH 1
962 #define EF1_IRQ_PHY0_LBN 10
963 #define EF1_IRQ_PHY0_WIDTH 1
964 #define EF1_IRQ_SERR_LBN 7
965 #define EF1_IRQ_SERR_WIDTH 1
966 #define EF1_IRQ_EVQ_LBN 3
967 #define EF1_IRQ_EVQ_WIDTH 1
968
969 /** Event generation */
970 #define EF1_EVT3_REG 0x38
971
972 /** EEPROM access */
973 #define EF1_EEPROM_REG 0x40
974 #define EF1_EEPROM_SDA_LBN 31
975 #define EF1_EEPROM_SDA_WIDTH 1
976 #define EF1_EEPROM_SCL_LBN 30
977 #define EF1_EEPROM_SCL_WIDTH 1
978 #define EF1_JTAG_DISCONNECT_LBN 17
979 #define EF1_JTAG_DISCONNECT_WIDTH 1
980
981 /** Control register 2 */
982 #define EF1_CTL2_REG 0x4c
983 #define EF1_PLL_TRAP_LBN 31
984 #define EF1_PLL_TRAP_WIDTH 1
985 #define EF1_MEM_MAP_4MB_LBN 11
986 #define EF1_MEM_MAP_4MB_WIDTH 1
987 #define EF1_EV_INTR_CLR_WRITE_LBN 6
988 #define EF1_EV_INTR_CLR_WRITE_WIDTH 1
989 #define EF1_BURST_MERGE_LBN 5
990 #define EF1_BURST_MERGE_WIDTH 1
991 #define EF1_CLEAR_NULL_PAD_LBN 4
992 #define EF1_CLEAR_NULL_PAD_WIDTH 1
993 #define EF1_SW_RESET_LBN 2
994 #define EF1_SW_RESET_WIDTH 1
995 #define EF1_INTR_AFTER_EVENT_LBN 1
996 #define EF1_INTR_AFTER_EVENT_WIDTH 1
997
998 /** Event FIFO */
999 #define EF1_EVENT_FIFO_REG 0x50
1000
1001 /** Event FIFO count */
1002 #define EF1_EVENT_FIFO_COUNT_REG 0x5c
1003 #define EF1_EV_COUNT_LBN 0
1004 #define EF1_EV_COUNT_WIDTH 16
1005
1006 /** TX DMA control and status */
1007 #define EF1_DMA_TX_CSR_REG 0x80
1008 #define EF1_DMA_TX_CSR_CHAIN_EN_LBN 8
1009 #define EF1_DMA_TX_CSR_CHAIN_EN_WIDTH 1
1010 #define EF1_DMA_TX_CSR_ENABLE_LBN 4
1011 #define EF1_DMA_TX_CSR_ENABLE_WIDTH 1
1012 #define EF1_DMA_TX_CSR_INT_EN_LBN 0
1013 #define EF1_DMA_TX_CSR_INT_EN_WIDTH 1
1014
1015 /** RX DMA control and status */
1016 #define EF1_DMA_RX_CSR_REG 0xa0
1017 #define EF1_DMA_RX_ABOVE_1GB_EN_LBN 6
1018 #define EF1_DMA_RX_ABOVE_1GB_EN_WIDTH 1
1019 #define EF1_DMA_RX_BELOW_1MB_EN_LBN 5
1020 #define EF1_DMA_RX_BELOW_1MB_EN_WIDTH 1 
1021 #define EF1_DMA_RX_CSR_ENABLE_LBN 0
1022 #define EF1_DMA_RX_CSR_ENABLE_WIDTH 1
1023
1024 /** Level 5 watermark register (in MAC space) */
1025 #define EF1_GMF_L5WM_REG_MAC 0x20
1026 #define EF1_L5WM_LBN 0
1027 #define EF1_L5WM_WIDTH 32
1028
1029 /** MAC clock */
1030 #define EF1_GM_MAC_CLK_REG 0x112000
1031 #define EF1_GM_PORT0_MAC_CLK_LBN 0
1032 #define EF1_GM_PORT0_MAC_CLK_WIDTH 1
1033 #define EF1_GM_PORT1_MAC_CLK_LBN 1
1034 #define EF1_GM_PORT1_MAC_CLK_WIDTH 1
1035
1036 /** TX descriptor FIFO */
1037 #define EF1_TX_DESC_FIFO 0x141000
1038 #define EF1_TX_KER_EVQ_LBN 80
1039 #define EF1_TX_KER_EVQ_WIDTH 12
1040 #define EF1_TX_KER_IDX_LBN 64
1041 #define EF1_TX_KER_IDX_WIDTH 16
1042 #define EF1_TX_KER_MODE_LBN 63
1043 #define EF1_TX_KER_MODE_WIDTH 1
1044 #define EF1_TX_KER_PORT_LBN 60
1045 #define EF1_TX_KER_PORT_WIDTH 1
1046 #define EF1_TX_KER_CONT_LBN 56
1047 #define EF1_TX_KER_CONT_WIDTH 1
1048 #define EF1_TX_KER_BYTE_CNT_LBN 32
1049 #define EF1_TX_KER_BYTE_CNT_WIDTH 24
1050 #define EF1_TX_KER_BUF_ADR_LBN 0
1051 #define EF1_TX_KER_BUF_ADR_WIDTH 32
1052
1053 /** TX descriptor FIFO flush */
1054 #define EF1_TX_DESC_FIFO_FLUSH 0x141ffc
1055
1056 /** RX descriptor FIFO */
1057 #define EF1_RX_DESC_FIFO 0x145000
1058 #define EF1_RX_KER_EVQ_LBN 48
1059 #define EF1_RX_KER_EVQ_WIDTH 12
1060 #define EF1_RX_KER_IDX_LBN 32
1061 #define EF1_RX_KER_IDX_WIDTH 16
1062 #define EF1_RX_KER_BUF_ADR_LBN 0
1063 #define EF1_RX_KER_BUF_ADR_WIDTH 32
1064
1065 /** RX descriptor FIFO flush */
1066 #define EF1_RX_DESC_FIFO_FLUSH 0x145ffc 
1067
1068 /** CAM */
1069 #define EF1_CAM_BASE 0x1c0000
1070 #define EF1_CAM_WTF_DOES_THIS_DO_LBN 0
1071 #define EF1_CAM_WTF_DOES_THIS_DO_WIDTH 32
1072
1073 /** Event queue pointers */
1074 #define EF1_EVQ_PTR_BASE 0x260000
1075 #define EF1_EVQ_SIZE_LBN 29
1076 #define EF1_EVQ_SIZE_WIDTH 2
1077 #define EF1_EVQ_SIZE_4K 3
1078 #define EF1_EVQ_SIZE_2K 2
1079 #define EF1_EVQ_SIZE_1K 1
1080 #define EF1_EVQ_SIZE_512 0
1081 #define EF1_EVQ_BUF_BASE_ID_LBN 0
1082 #define EF1_EVQ_BUF_BASE_ID_WIDTH 29
1083
1084 /* MAC registers */
1085 #define EF1002_MAC_REGBANK 0x110000
1086 #define EF1002_MAC_REGBANK_SIZE 0x1000
1087 #define EF1002_MAC_REG_SIZE 0x08
1088
1089 /** Offset of a MAC register within EF1002 */
1090 #define EF1002_MAC_REG( efab, mac_reg )                         \
1091         ( EF1002_MAC_REGBANK +                                  \
1092           ( (efab)->port * EF1002_MAC_REGBANK_SIZE ) +          \
1093           ( (mac_reg) * EF1002_MAC_REG_SIZE ) )
1094
1095 /* Event queue entries */
1096 #define EF1_EV_CODE_LBN 20
1097 #define EF1_EV_CODE_WIDTH 8
1098 #define EF1_RX_EV_DECODE 0x01
1099 #define EF1_TX_EV_DECODE 0x02
1100 #define EF1_DRV_GEN_EV_DECODE 0x0f
1101
1102 /* Receive events */
1103 #define EF1_RX_EV_LEN_LBN 48
1104 #define EF1_RX_EV_LEN_WIDTH 16
1105 #define EF1_RX_EV_PORT_LBN 17
1106 #define EF1_RX_EV_PORT_WIDTH 3
1107 #define EF1_RX_EV_OK_LBN 16
1108 #define EF1_RX_EV_OK_WIDTH 1
1109 #define EF1_RX_EV_IDX_LBN 0
1110 #define EF1_RX_EV_IDX_WIDTH 16
1111
1112 /* Transmit events */
1113 #define EF1_TX_EV_PORT_LBN 17
1114 #define EF1_TX_EV_PORT_WIDTH 3
1115 #define EF1_TX_EV_OK_LBN 16
1116 #define EF1_TX_EV_OK_WIDTH 1
1117 #define EF1_TX_EV_IDX_LBN 0
1118 #define EF1_TX_EV_IDX_WIDTH 16
1119
1120 /**
1121  * Write dword to EF1002 register
1122  *
1123  */
1124 static inline void ef1002_writel ( struct efab_nic *efab, efab_dword_t *value,
1125                                    unsigned int reg ) {
1126         EFAB_REGDUMP ( "Writing register %x with " EFAB_DWORD_FMT "\n",
1127                        reg, EFAB_DWORD_VAL ( *value ) );
1128         writel ( value->u32[0], efab->membase + reg );
1129 }
1130
1131 /**
1132  * Read dword from an EF1002 register
1133  *
1134  */
1135 static inline void ef1002_readl ( struct efab_nic *efab, efab_dword_t *value,
1136                                   unsigned int reg ) {
1137         value->u32[0] = readl ( efab->membase + reg );
1138         EFAB_REGDUMP ( "Read from register %x, got " EFAB_DWORD_FMT "\n",
1139                        reg, EFAB_DWORD_VAL ( *value ) );
1140 }
1141
1142 /**
1143  * Read dword from an EF1002 register, silently
1144  *
1145  */
1146 static inline void ef1002_readl_silent ( struct efab_nic *efab,
1147                                          efab_dword_t *value,
1148                                          unsigned int reg ) {
1149         value->u32[0] = readl ( efab->membase + reg );
1150 }
1151
1152 /**
1153  * Get memory base
1154  *
1155  */
1156 static void ef1002_get_membase ( struct efab_nic *efab ) {
1157         unsigned long membase_phys;
1158
1159         membase_phys = pci_bar_start ( efab->pci, PCI_BASE_ADDRESS_0 );
1160         efab->membase = ioremap ( membase_phys, 0x800000 );
1161 }
1162
1163 /** PCI registers to backup/restore over a device reset */
1164 static const unsigned int efab_pci_reg_addr[] = {
1165         PCI_COMMAND, 0x0c /* PCI_CACHE_LINE_SIZE */,
1166         PCI_BASE_ADDRESS_0, PCI_BASE_ADDRESS_1, PCI_BASE_ADDRESS_2,
1167         PCI_BASE_ADDRESS_3, PCI_ROM_ADDRESS, PCI_INTERRUPT_LINE,
1168 };
1169 /** Number of registers in efab_pci_reg_addr */
1170 #define EFAB_NUM_PCI_REG \
1171         ( sizeof ( efab_pci_reg_addr ) / sizeof ( efab_pci_reg_addr[0] ) )
1172 /** PCI configuration space backup */
1173 struct efab_pci_reg {
1174         uint32_t reg[EFAB_NUM_PCI_REG];
1175 };
1176
1177 /**
1178  * Reset device
1179  *
1180  */
1181 static int ef1002_reset ( struct efab_nic *efab ) {
1182         struct efab_pci_reg pci_reg;
1183         struct pci_device *pci_dev = efab->pci;
1184         efab_dword_t reg;
1185         unsigned int i;
1186         uint32_t tmp;
1187
1188         /* Back up PCI configuration registers */
1189         for ( i = 0 ; i < EFAB_NUM_PCI_REG ; i++ ) {
1190                 pci_read_config_dword ( pci_dev, efab_pci_reg_addr[i],
1191                                         &pci_reg.reg[i] );
1192         }
1193
1194         /* Reset the whole device. */
1195         EFAB_POPULATE_DWORD_1 ( reg, EF1_SW_RESET, 1 );
1196         ef1002_writel ( efab, &reg, EF1_CTL2_REG );
1197         mdelay ( 200 );
1198         
1199         /* Restore PCI configuration space */
1200         for ( i = 0 ; i < EFAB_NUM_PCI_REG ; i++ ) {
1201                 pci_write_config_dword ( pci_dev, efab_pci_reg_addr[i],
1202                                          pci_reg.reg[i] );
1203         }
1204
1205         /* Verify PCI configuration space */
1206         for ( i = 0 ; i < EFAB_NUM_PCI_REG ; i++ ) {
1207                 pci_read_config_dword ( pci_dev, efab_pci_reg_addr[i], &tmp );
1208                 if ( tmp != pci_reg.reg[i] ) {
1209                         printf ( "PCI restore failed on register %02x "
1210                                  "(is %08x, should be %08x); reboot\n",
1211                                  i, tmp, pci_reg.reg[i] );
1212                         return 0;
1213                 }
1214         }
1215
1216         /* Verify device reset complete */
1217         ef1002_readl ( efab, &reg, EF1_CTR_GEN_STATUS0_REG );
1218         if ( EFAB_DWORD_IS_ALL_ONES ( reg ) ) {
1219                 printf ( "Reset failed\n" );
1220                 return 0;
1221         }
1222
1223         return 1;
1224 }
1225
1226 /**
1227  * Initialise NIC
1228  *
1229  */
1230 static int ef1002_init_nic ( struct efab_nic *efab ) {
1231         efab_dword_t reg;
1232
1233         /* No idea what CAM is, but the 'datasheet' says that we have
1234          * to write these values in at start of day
1235          */
1236         EFAB_POPULATE_DWORD_1 ( reg, EF1_CAM_WTF_DOES_THIS_DO, 0x6 );
1237         ef1002_writel ( efab, &reg, EF1_CAM_BASE + 0x20018 );
1238         udelay ( 1000 );
1239         EFAB_POPULATE_DWORD_1 ( reg, EF1_CAM_WTF_DOES_THIS_DO, 0x01000000 );
1240         ef1002_writel ( efab, &reg, EF1_CAM_BASE + 0x00018 );
1241         udelay ( 1000 );
1242
1243         /* General control register 0 */
1244         ef1002_readl ( efab, &reg, EF1_CTR_GEN_STATUS0_REG );
1245         EFAB_SET_DWORD_FIELD ( reg, EF1_MASTER_EVENTS, 0 );
1246         EFAB_SET_DWORD_FIELD ( reg, EF1_TX_ENGINE_EN, 0 );
1247         EFAB_SET_DWORD_FIELD ( reg, EF1_RX_ENGINE_EN, 0 );
1248         EFAB_SET_DWORD_FIELD ( reg, EF1_CAM_ENABLE, 1 );
1249         ef1002_writel ( efab, &reg, EF1_CTR_GEN_STATUS0_REG );
1250         udelay ( 1000 );
1251
1252         /* General control register 2 */
1253         ef1002_readl ( efab, &reg, EF1_CTL2_REG );
1254         EFAB_SET_DWORD_FIELD ( reg, EF1_PLL_TRAP, 1 );
1255         EFAB_SET_DWORD_FIELD ( reg, EF1_MEM_MAP_4MB, 0 );
1256         EFAB_SET_DWORD_FIELD ( reg, EF1_EV_INTR_CLR_WRITE, 0 );
1257         EFAB_SET_DWORD_FIELD ( reg, EF1_BURST_MERGE, 0 );
1258         EFAB_SET_DWORD_FIELD ( reg, EF1_CLEAR_NULL_PAD, 1 );
1259         EFAB_SET_DWORD_FIELD ( reg, EF1_INTR_AFTER_EVENT, 1 );
1260         ef1002_writel ( efab, &reg, EF1_CTL2_REG );
1261         udelay ( 1000 );
1262
1263         /* Enable RX DMA */
1264         ef1002_readl ( efab, &reg, EF1_DMA_RX_CSR_REG );
1265         EFAB_SET_DWORD_FIELD ( reg, EF1_DMA_RX_CSR_ENABLE, 1 );
1266         EFAB_SET_DWORD_FIELD ( reg, EF1_DMA_RX_BELOW_1MB_EN, 1 );
1267         EFAB_SET_DWORD_FIELD ( reg, EF1_DMA_RX_ABOVE_1GB_EN, 1 );
1268         ef1002_writel ( efab, &reg, EF1_DMA_RX_CSR_REG );
1269         udelay ( 1000 );
1270
1271         /* Enable TX DMA */
1272         ef1002_readl ( efab, &reg, EF1_DMA_TX_CSR_REG );
1273         EFAB_SET_DWORD_FIELD ( reg, EF1_DMA_TX_CSR_CHAIN_EN, 1 );
1274         EFAB_SET_DWORD_FIELD ( reg, EF1_DMA_TX_CSR_ENABLE, 0 /* ?? */ );
1275         EFAB_SET_DWORD_FIELD ( reg, EF1_DMA_TX_CSR_INT_EN, 0 /* ?? */ );
1276         ef1002_writel ( efab, &reg, EF1_DMA_TX_CSR_REG );
1277         udelay ( 1000 );
1278
1279         /* Disconnect the JTAG chain.  Read-modify-write is impossible
1280          * on the I2C control bits, since reading gives the state of
1281          * the line inputs rather than the last written state.
1282          */
1283         ef1002_readl ( efab, &reg, EF1_EEPROM_REG );
1284         EFAB_SET_DWORD_FIELD ( reg, EF1_EEPROM_SDA, 1 );
1285         EFAB_SET_DWORD_FIELD ( reg, EF1_EEPROM_SCL, 1 );
1286         EFAB_SET_DWORD_FIELD ( reg, EF1_JTAG_DISCONNECT, 1 );
1287         ef1002_writel ( efab, &reg, EF1_EEPROM_REG );
1288         udelay ( 10 );
1289
1290         /* Flush descriptor queues */
1291         EFAB_ZERO_DWORD ( reg );
1292         ef1002_writel ( efab, &reg, EF1_RX_DESC_FIFO_FLUSH );
1293         ef1002_writel ( efab, &reg, EF1_TX_DESC_FIFO_FLUSH );
1294         wmb();
1295         udelay ( 10000 );
1296
1297         /* Reset MAC */
1298         mentormac_reset ( efab );
1299
1300         return 1;
1301 }
1302
1303 /** I2C ID of the EEPROM */
1304 #define EF1002_EEPROM_I2C_ID 0x50
1305
1306 /** Offset of MAC address within EEPROM */
1307 #define EF1002_EEPROM_HWADDR_OFFSET 0x0
1308
1309 /** Set status of i2c outputs */
1310 static void ef1002_setsdascl ( struct efab_i2c_interface *i2c ) {
1311         efab_dword_t eeprom_reg;
1312
1313         EFAB_POPULATE_DWORD_2 ( eeprom_reg,
1314                                 EF1_EEPROM_SDA, i2c->sda,
1315                                 EF1_EEPROM_SCL, i2c->scl );
1316         ef1002_writel ( i2c->efab, &eeprom_reg, EF1_EEPROM_REG );
1317 }
1318
1319 /** Get status of i2c SDA line */
1320 static int ef1002_getsda ( struct efab_i2c_interface *i2c ) {
1321         efab_dword_t eeprom_reg;
1322
1323         ef1002_readl ( i2c->efab, &eeprom_reg, EF1_EEPROM_REG );
1324         return EFAB_DWORD_FIELD ( eeprom_reg, EF1_EEPROM_SDA );
1325 }
1326
1327 /** Get status of i2c SCL line */
1328 static int ef1002_getscl ( struct efab_i2c_interface *i2c ) {
1329         efab_dword_t eeprom_reg;
1330
1331         ef1002_readl ( i2c->efab, &eeprom_reg, EF1_EEPROM_REG );
1332         return EFAB_DWORD_FIELD ( eeprom_reg, EF1_EEPROM_SCL );
1333 }
1334
1335 /** i2c bit-bashing data structure template */
1336 static struct efab_i2c_bit_operations ef1002_i2c_bit_operations = {
1337         .setsda         = ef1002_setsdascl,
1338         .setscl         = ef1002_setsdascl,
1339         .getsda         = ef1002_getsda,
1340         .getscl         = ef1002_getscl,
1341         .udelay         = 20,
1342         .mdelay         = 10,
1343 };
1344
1345 /**
1346  * Read MAC address from EEPROM
1347  *
1348  */
1349 static int ef1002_read_eeprom ( struct efab_nic *efab ) {
1350         struct efab_i2c_interface i2c = {
1351                 .efab = efab,
1352                 .op = &ef1002_i2c_bit_operations,
1353                 .sda = 1,
1354                 .scl = 1,
1355         };
1356
1357         if ( ! efab_i2c_fast_read ( &i2c, EF1002_EEPROM_I2C_ID,
1358                                     EF1002_EEPROM_HWADDR_OFFSET,
1359                                     efab->mac_addr, ETH_ALEN ) )
1360                 return 0;
1361         efab->mac_addr[ETH_ALEN-1] += efab->port;
1362         return 1;
1363 }
1364
1365 /** RX descriptor */
1366 typedef efab_qword_t ef1002_rx_desc_t;
1367
1368 /**
1369  * Build RX descriptor
1370  *
1371  */
1372 static void ef1002_build_rx_desc ( struct efab_nic *efab,
1373                                    struct efab_rx_buf *rx_buf ) {
1374         ef1002_rx_desc_t rxd;
1375
1376         EFAB_POPULATE_QWORD_3 ( rxd,
1377                                 EF1_RX_KER_EVQ, 0,
1378                                 EF1_RX_KER_IDX, rx_buf->id,
1379                                 EF1_RX_KER_BUF_ADR,
1380                                 virt_to_bus ( rx_buf->addr ) );
1381         ef1002_writel ( efab, &rxd.dword[0], EF1_RX_DESC_FIFO + 0 );
1382         ef1002_writel ( efab, &rxd.dword[1], EF1_RX_DESC_FIFO + 4 );
1383         udelay ( 10 );
1384 }
1385
1386 /**
1387  * Update RX descriptor write pointer
1388  *
1389  */
1390 static void ef1002_notify_rx_desc ( struct efab_nic *efab __unused ) {
1391         /* Nothing to do */
1392 }
1393
1394 /** TX descriptor */
1395 typedef efab_oword_t ef1002_tx_desc_t;
1396
1397 /**
1398  * Build TX descriptor
1399  *
1400  */
1401 static void ef1002_build_tx_desc ( struct efab_nic *efab,
1402                                    struct efab_tx_buf *tx_buf ) {
1403         ef1002_tx_desc_t txd;
1404
1405         EFAB_POPULATE_OWORD_7 ( txd,
1406                                 EF1_TX_KER_EVQ, 0,
1407                                 EF1_TX_KER_IDX, tx_buf->id,
1408                                 EF1_TX_KER_MODE, 0 /* IP mode */,
1409                                 EF1_TX_KER_PORT, efab->port,
1410                                 EF1_TX_KER_CONT, 0,
1411                                 EF1_TX_KER_BYTE_CNT, tx_buf->len,
1412                                 EF1_TX_KER_BUF_ADR,
1413                                 virt_to_bus ( tx_buf->addr ) );
1414
1415         ef1002_writel ( efab, &txd.dword[0], EF1_TX_DESC_FIFO + 0 );
1416         ef1002_writel ( efab, &txd.dword[1], EF1_TX_DESC_FIFO + 4 );
1417         ef1002_writel ( efab, &txd.dword[2], EF1_TX_DESC_FIFO + 8 );
1418         udelay ( 10 );
1419 }
1420
1421 /**
1422  * Update TX descriptor write pointer
1423  *
1424  */
1425 static void ef1002_notify_tx_desc ( struct efab_nic *efab __unused ) {
1426         /* Nothing to do */
1427 }
1428
1429 /** An event */
1430 typedef efab_qword_t ef1002_event_t;
1431
1432 /**
1433  * Retrieve event from event queue
1434  *
1435  */
1436 static int ef1002_fetch_event ( struct efab_nic *efab,
1437                                 struct efab_event *event ) {
1438         efab_dword_t reg;
1439         int ev_code;
1440         int words;
1441
1442         /* Check event FIFO depth */
1443         ef1002_readl_silent ( efab, &reg, EF1_EVENT_FIFO_COUNT_REG );
1444         words = EFAB_DWORD_FIELD ( reg, EF1_EV_COUNT );
1445         if ( ! words )
1446                 return 0;
1447
1448         /* Read event data */
1449         ef1002_readl ( efab, &reg, EF1_EVENT_FIFO_REG );
1450         DBG ( "Event is " EFAB_DWORD_FMT "\n", EFAB_DWORD_VAL ( reg ) );
1451
1452         /* Decode event */
1453         ev_code = EFAB_DWORD_FIELD ( reg, EF1_EV_CODE );
1454         switch ( ev_code ) {
1455         case EF1_TX_EV_DECODE:
1456                 event->type = EFAB_EV_TX;
1457                 break;
1458         case EF1_RX_EV_DECODE:
1459                 event->type = EFAB_EV_RX;
1460                 event->rx_id = EFAB_DWORD_FIELD ( reg, EF1_RX_EV_IDX );
1461                 /* RX len not available via event FIFO */
1462                 event->rx_len = ETH_FRAME_LEN;
1463                 break;
1464         default:
1465                 printf ( "Unknown event type %d\n", ev_code );
1466                 event->type = EFAB_EV_NONE;
1467         }
1468
1469         /* Clear any pending interrupts */
1470         ef1002_readl ( efab, &reg, EF1_IRQ_SRC_REG );
1471
1472         return 1;
1473 }
1474
1475 /**
1476  * Enable/disable interrupts
1477  *
1478  */
1479 static void ef1002_mask_irq ( struct efab_nic *efab, int enabled ) {
1480         efab_dword_t irq_mask;
1481
1482         EFAB_POPULATE_DWORD_2 ( irq_mask,
1483                                 EF1_IRQ_SERR, enabled,
1484                                 EF1_IRQ_EVQ, enabled );
1485         ef1002_writel ( efab, &irq_mask, EF1_IRQ_MASK_REG );
1486 }
1487
1488 /**
1489  * Generate interrupt
1490  *
1491  */
1492 static void ef1002_generate_irq ( struct efab_nic *efab ) {
1493         ef1002_event_t test_event;
1494
1495         EFAB_POPULATE_QWORD_1 ( test_event,
1496                                 EF1_EV_CODE, EF1_DRV_GEN_EV_DECODE );
1497         ef1002_writel ( efab, &test_event.dword[0], EF1_EVT3_REG );
1498 }
1499
1500 /**
1501  * Write dword to an EF1002 MAC register
1502  *
1503  */
1504 static void ef1002_mac_writel ( struct efab_nic *efab,
1505                                 efab_dword_t *value, unsigned int mac_reg ) {
1506         ef1002_writel ( efab, value, EF1002_MAC_REG ( efab, mac_reg ) );
1507 }
1508
1509 /**
1510  * Read dword from an EF1002 MAC register
1511  *
1512  */
1513 static void ef1002_mac_readl ( struct efab_nic *efab,
1514                                efab_dword_t *value, unsigned int mac_reg ) {
1515         ef1002_readl ( efab, value, EF1002_MAC_REG ( efab, mac_reg ) );
1516 }
1517
1518 /**
1519  * Initialise MAC
1520  *
1521  */
1522 static int ef1002_init_mac ( struct efab_nic *efab ) {
1523         static struct efab_mentormac_parameters ef1002_mentormac_params = {
1524                 .gmf_cfgfrth = 0x13,
1525                 .gmf_cfgftth = 0x10,
1526                 .gmf_cfghwmft = 0x555,
1527                 .gmf_cfghwm = 0x2a,
1528                 .gmf_cfglwm = 0x15,
1529         };
1530         efab_dword_t reg;
1531         unsigned int mac_clk;
1532
1533         /* Initialise PHY */
1534         alaska_init ( efab );
1535
1536         /* Initialise MAC */
1537         mentormac_init ( efab, &ef1002_mentormac_params );
1538
1539         /* Write Level 5 watermark register */
1540         EFAB_POPULATE_DWORD_1 ( reg, EF1_L5WM, 0x10040000 );
1541         efab->op->mac_writel ( efab, &reg, EF1_GMF_L5WM_REG_MAC );
1542         udelay ( 10 );
1543
1544         /* Set MAC clock speed */
1545         ef1002_readl ( efab, &reg, EF1_GM_MAC_CLK_REG );
1546         mac_clk = ( efab->link_options & LPA_1000 ) ? 0 : 1;
1547         if ( efab->port == 0 ) {
1548                 EFAB_SET_DWORD_FIELD ( reg, EF1_GM_PORT0_MAC_CLK, mac_clk );
1549         } else {
1550                 EFAB_SET_DWORD_FIELD ( reg, EF1_GM_PORT1_MAC_CLK, mac_clk );
1551         }
1552         ef1002_writel ( efab, &reg, EF1_GM_MAC_CLK_REG );
1553         udelay ( 10 );
1554
1555         return 1;
1556 }
1557
1558 /** MDIO write */
1559 static void ef1002_mdio_write ( struct efab_nic *efab, int location,
1560                                 int value ) {
1561         mentormac_mdio_write ( efab, efab->port + 2, location, value );
1562 }
1563
1564 /** MDIO read */
1565 static int ef1002_mdio_read ( struct efab_nic *efab, int location ) {
1566         return mentormac_mdio_read ( efab, efab->port + 2, location );
1567 }
1568
1569 static struct efab_operations ef1002_operations = {
1570         .get_membase            = ef1002_get_membase,
1571         .reset                  = ef1002_reset,
1572         .init_nic               = ef1002_init_nic,
1573         .read_eeprom            = ef1002_read_eeprom,
1574         .build_rx_desc          = ef1002_build_rx_desc,
1575         .notify_rx_desc         = ef1002_notify_rx_desc,
1576         .build_tx_desc          = ef1002_build_tx_desc,
1577         .notify_tx_desc         = ef1002_notify_tx_desc,
1578         .fetch_event            = ef1002_fetch_event,
1579         .mask_irq               = ef1002_mask_irq,
1580         .generate_irq           = ef1002_generate_irq,
1581         .mac_writel             = ef1002_mac_writel,
1582         .mac_readl              = ef1002_mac_readl,
1583         .init_mac               = ef1002_init_mac,
1584         .mdio_write             = ef1002_mdio_write,
1585         .mdio_read              = ef1002_mdio_read,
1586 };
1587
1588 /**************************************************************************
1589  *
1590  * Falcon routines
1591  *
1592  **************************************************************************
1593  */
1594
1595 /* I/O BAR address register */
1596 #define FCN_IOM_IND_ADR_REG 0x0
1597
1598 /* I/O BAR data register */
1599 #define FCN_IOM_IND_DAT_REG 0x4
1600
1601 /* Interrupt enable register */
1602 #define FCN_INT_EN_REG_KER 0x0010
1603 #define FCN_MEM_PERR_INT_EN_KER_LBN 5
1604 #define FCN_MEM_PERR_INT_EN_KER_WIDTH 1
1605 #define FCN_KER_INT_CHAR_LBN 4
1606 #define FCN_KER_INT_CHAR_WIDTH 1
1607 #define FCN_KER_INT_KER_LBN 3
1608 #define FCN_KER_INT_KER_WIDTH 1
1609 #define FCN_ILL_ADR_ERR_INT_EN_KER_LBN 2
1610 #define FCN_ILL_ADR_ERR_INT_EN_KER_WIDTH 1
1611 #define FCN_SRM_PERR_INT_EN_KER_LBN 1
1612 #define FCN_SRM_PERR_INT_EN_KER_WIDTH 1
1613 #define FCN_DRV_INT_EN_KER_LBN 0
1614 #define FCN_DRV_INT_EN_KER_WIDTH 1
1615
1616 /* Interrupt status register */
1617 #define FCN_INT_ADR_REG_KER     0x0030
1618 #define FCN_INT_ADR_KER_LBN 0
1619 #define FCN_INT_ADR_KER_WIDTH EFAB_DMA_TYPE_WIDTH ( 64 )
1620
1621 /* Interrupt acknowledge register */
1622 #define FCN_INT_ACK_KER_REG 0x0050
1623
1624 /* SPI host command register */
1625 #define FCN_EE_SPI_HCMD_REG_KER 0x0100
1626 #define FCN_EE_SPI_HCMD_CMD_EN_LBN 31
1627 #define FCN_EE_SPI_HCMD_CMD_EN_WIDTH 1
1628 #define FCN_EE_WR_TIMER_ACTIVE_LBN 28
1629 #define FCN_EE_WR_TIMER_ACTIVE_WIDTH 1
1630 #define FCN_EE_SPI_HCMD_SF_SEL_LBN 24
1631 #define FCN_EE_SPI_HCMD_SF_SEL_WIDTH 1
1632 #define FCN_EE_SPI_EEPROM 0
1633 #define FCN_EE_SPI_FLASH 1
1634 #define FCN_EE_SPI_HCMD_DABCNT_LBN 16
1635 #define FCN_EE_SPI_HCMD_DABCNT_WIDTH 5
1636 #define FCN_EE_SPI_HCMD_READ_LBN 15
1637 #define FCN_EE_SPI_HCMD_READ_WIDTH 1
1638 #define FCN_EE_SPI_READ 1
1639 #define FCN_EE_SPI_WRITE 0
1640 #define FCN_EE_SPI_HCMD_DUBCNT_LBN 12
1641 #define FCN_EE_SPI_HCMD_DUBCNT_WIDTH 2
1642 #define FCN_EE_SPI_HCMD_ADBCNT_LBN 8
1643 #define FCN_EE_SPI_HCMD_ADBCNT_WIDTH 2
1644 #define FCN_EE_SPI_HCMD_ENC_LBN 0
1645 #define FCN_EE_SPI_HCMD_ENC_WIDTH 8
1646
1647 /* SPI host address register */
1648 #define FCN_EE_SPI_HADR_REG_KER 0x0110
1649 #define FCN_EE_SPI_HADR_DUBYTE_LBN 24
1650 #define FCN_EE_SPI_HADR_DUBYTE_WIDTH 8
1651 #define FCN_EE_SPI_HADR_ADR_LBN 0
1652 #define FCN_EE_SPI_HADR_ADR_WIDTH 24
1653
1654 /* SPI host data register */
1655 #define FCN_EE_SPI_HDATA_REG_KER 0x0120
1656 #define FCN_EE_SPI_HDATA3_LBN 96
1657 #define FCN_EE_SPI_HDATA3_WIDTH 32
1658 #define FCN_EE_SPI_HDATA2_LBN 64
1659 #define FCN_EE_SPI_HDATA2_WIDTH 32
1660 #define FCN_EE_SPI_HDATA1_LBN 32
1661 #define FCN_EE_SPI_HDATA1_WIDTH 32
1662 #define FCN_EE_SPI_HDATA0_LBN 0
1663 #define FCN_EE_SPI_HDATA0_WIDTH 32
1664
1665 /* GPIO control register */
1666 #define FCN_GPIO_CTL_REG_KER 0x0210
1667 #define FCN_FLASH_PRESENT_LBN 7
1668 #define FCN_FLASH_PRESENT_WIDTH 1
1669 #define FCN_EEPROM_PRESENT_LBN 6
1670 #define FCN_EEPROM_PRESENT_WIDTH 1
1671
1672 /* Global control register */
1673 #define FCN_GLB_CTL_REG_KER     0x0220
1674 #define FCN_EXT_PHY_RST_CTL_LBN 63
1675 #define FCN_EXT_PHY_RST_CTL_WIDTH 1
1676 #define FCN_PCIE_SD_RST_CTL_LBN 61
1677 #define FCN_PCIE_SD_RST_CTL_WIDTH 1
1678 #define FCN_PCIX_RST_CTL_LBN 60
1679 #define FCN_PCIX_RST_CTL_WIDTH 1
1680 #define FCN_RST_EXT_PHY_LBN 31
1681 #define FCN_RST_EXT_PHY_WIDTH 1
1682 #define FCN_INT_RST_DUR_LBN 4
1683 #define FCN_INT_RST_DUR_WIDTH 3
1684 #define FCN_EXT_PHY_RST_DUR_LBN 1
1685 #define FCN_EXT_PHY_RST_DUR_WIDTH 3
1686 #define FCN_SWRST_LBN 0
1687 #define FCN_SWRST_WIDTH 1
1688 #define FCN_INCLUDE_IN_RESET 0
1689 #define FCN_EXCLUDE_FROM_RESET 1
1690
1691 /* Timer table for kernel access */
1692 #define FCN_TIMER_CMD_REG_KER 0x420
1693 #define FCN_TIMER_MODE_LBN 12
1694 #define FCN_TIMER_MODE_WIDTH 2
1695 #define FCN_TIMER_MODE_DIS 0
1696 #define FCN_TIMER_MODE_INT_HLDOFF 1
1697 #define FCN_TIMER_VAL_LBN 0
1698 #define FCN_TIMER_VAL_WIDTH 12
1699
1700 /* SRAM receive descriptor cache configuration register */
1701 #define FCN_SRM_RX_DC_CFG_REG_KER 0x610
1702 #define FCN_SRM_RX_DC_BASE_ADR_LBN 0
1703 #define FCN_SRM_RX_DC_BASE_ADR_WIDTH 21
1704
1705 /* SRAM transmit descriptor cache configuration register */
1706 #define FCN_SRM_TX_DC_CFG_REG_KER 0x620
1707 #define FCN_SRM_TX_DC_BASE_ADR_LBN 0
1708 #define FCN_SRM_TX_DC_BASE_ADR_WIDTH 21
1709
1710 /* Receive filter control register */
1711 #define FCN_RX_FILTER_CTL_REG_KER 0x810
1712 #define FCN_NUM_KER_LBN 24
1713 #define FCN_NUM_KER_WIDTH 2
1714
1715 /* Receive descriptor update register */
1716 #define FCN_RX_DESC_UPD_REG_KER 0x0830
1717 #define FCN_RX_DESC_WPTR_LBN 96
1718 #define FCN_RX_DESC_WPTR_WIDTH 12
1719 #define FCN_RX_DESC_UPD_REG_KER_DWORD ( FCN_RX_DESC_UPD_REG_KER + 12 )
1720 #define FCN_RX_DESC_WPTR_DWORD_LBN 0
1721 #define FCN_RX_DESC_WPTR_DWORD_WIDTH 12
1722
1723 /* Receive descriptor cache configuration register */
1724 #define FCN_RX_DC_CFG_REG_KER 0x840
1725 #define FCN_RX_DC_SIZE_LBN 0
1726 #define FCN_RX_DC_SIZE_WIDTH 2
1727
1728 /* Transmit descriptor update register */
1729 #define FCN_TX_DESC_UPD_REG_KER 0x0a10
1730 #define FCN_TX_DESC_WPTR_LBN 96
1731 #define FCN_TX_DESC_WPTR_WIDTH 12
1732 #define FCN_TX_DESC_UPD_REG_KER_DWORD ( FCN_TX_DESC_UPD_REG_KER + 12 )
1733 #define FCN_TX_DESC_WPTR_DWORD_LBN 0
1734 #define FCN_TX_DESC_WPTR_DWORD_WIDTH 12
1735
1736 /* Transmit descriptor cache configuration register */
1737 #define FCN_TX_DC_CFG_REG_KER 0xa20
1738 #define FCN_TX_DC_SIZE_LBN 0
1739 #define FCN_TX_DC_SIZE_WIDTH 2
1740
1741 /* PHY management transmit data register */
1742 #define FCN_MD_TXD_REG_KER 0xc00
1743 #define FCN_MD_TXD_LBN 0
1744 #define FCN_MD_TXD_WIDTH 16
1745
1746 /* PHY management receive data register */
1747 #define FCN_MD_RXD_REG_KER 0xc10
1748 #define FCN_MD_RXD_LBN 0
1749 #define FCN_MD_RXD_WIDTH 16
1750
1751 /* PHY management configuration & status register */
1752 #define FCN_MD_CS_REG_KER 0xc20
1753 #define FCN_MD_GC_LBN 4
1754 #define FCN_MD_GC_WIDTH 1
1755 #define FCN_MD_RIC_LBN 2
1756 #define FCN_MD_RIC_WIDTH 1
1757 #define FCN_MD_WRC_LBN 0
1758 #define FCN_MD_WRC_WIDTH 1
1759
1760 /* PHY management PHY address register */
1761 #define FCN_MD_PHY_ADR_REG_KER 0xc30
1762 #define FCN_MD_PHY_ADR_LBN 0
1763 #define FCN_MD_PHY_ADR_WIDTH 16
1764
1765 /* PHY management ID register */
1766 #define FCN_MD_ID_REG_KER 0xc40
1767 #define FCN_MD_PRT_ADR_LBN 11
1768 #define FCN_MD_PRT_ADR_WIDTH 5
1769 #define FCN_MD_DEV_ADR_LBN 6
1770 #define FCN_MD_DEV_ADR_WIDTH 5
1771
1772 /* PHY management status & mask register */
1773 #define FCN_MD_STAT_REG_KER 0xc50
1774 #define FCN_MD_BSY_LBN 0
1775 #define FCN_MD_BSY_WIDTH 1
1776
1777 /* Port 0 and 1 MAC control registers */
1778 #define FCN_MAC0_CTRL_REG_KER 0xc80
1779 #define FCN_MAC1_CTRL_REG_KER 0xc90
1780 #define FCN_MAC_XOFF_VAL_LBN 16
1781 #define FCN_MAC_XOFF_VAL_WIDTH 16
1782 #define FCN_MAC_BCAD_ACPT_LBN 4
1783 #define FCN_MAC_BCAD_ACPT_WIDTH 1
1784 #define FCN_MAC_UC_PROM_LBN 3
1785 #define FCN_MAC_UC_PROM_WIDTH 1
1786 #define FCN_MAC_LINK_STATUS_LBN 2
1787 #define FCN_MAC_LINK_STATUS_WIDTH 1
1788 #define FCN_MAC_SPEED_LBN 0
1789 #define FCN_MAC_SPEED_WIDTH 2
1790
1791 /* XGMAC global configuration - port 0*/
1792 #define FCN_XM_GLB_CFG_REG_P0_KER 0x1220
1793 #define FCN_XM_RX_STAT_EN_LBN 11
1794 #define FCN_XM_RX_STAT_EN_WIDTH 1
1795 #define FCN_XM_TX_STAT_EN_LBN 10
1796 #define FCN_XM_TX_STAT_EN_WIDTH 1
1797 #define FCN_XM_CUT_THRU_MODE_LBN 7
1798 #define FCN_XM_CUT_THRU_MODE_WIDTH 1
1799 #define FCN_XM_RX_JUMBO_MODE_LBN 6
1800 #define FCN_XM_RX_JUMBO_MODE_WIDTH 1
1801
1802 /* XGMAC transmit configuration - port 0 */
1803 #define FCN_XM_TX_CFG_REG_P0_KER 0x1230
1804 #define FCN_XM_IPG_LBN 16
1805 #define FCN_XM_IPG_WIDTH 4
1806 #define FCN_XM_WTF_DOES_THIS_DO_LBN 9
1807 #define FCN_XM_WTF_DOES_THIS_DO_WIDTH 1
1808 #define FCN_XM_TXCRC_LBN 8
1809 #define FCN_XM_TXCRC_WIDTH 1
1810 #define FCN_XM_AUTO_PAD_LBN 5
1811 #define FCN_XM_AUTO_PAD_WIDTH 1
1812 #define FCN_XM_TX_PRMBL_LBN 2
1813 #define FCN_XM_TX_PRMBL_WIDTH 1
1814 #define FCN_XM_TXEN_LBN 1
1815 #define FCN_XM_TXEN_WIDTH 1
1816
1817 /* XGMAC receive configuration - port 0 */
1818 #define FCN_XM_RX_CFG_REG_P0_KER 0x1240
1819 #define FCN_XM_PASS_CRC_ERR_LBN 25
1820 #define FCN_XM_PASS_CRC_ERR_WIDTH 1
1821 #define FCN_XM_AUTO_DEPAD_LBN 8
1822 #define FCN_XM_AUTO_DEPAD_WIDTH 1
1823 #define FCN_XM_RXEN_LBN 1
1824 #define FCN_XM_RXEN_WIDTH 1
1825
1826 /* Receive descriptor pointer table */
1827 #define FCN_RX_DESC_PTR_TBL_KER 0x11800
1828 #define FCN_RX_DESCQ_BUF_BASE_ID_LBN 36
1829 #define FCN_RX_DESCQ_BUF_BASE_ID_WIDTH 20
1830 #define FCN_RX_DESCQ_EVQ_ID_LBN 24
1831 #define FCN_RX_DESCQ_EVQ_ID_WIDTH 12
1832 #define FCN_RX_DESCQ_OWNER_ID_LBN 10
1833 #define FCN_RX_DESCQ_OWNER_ID_WIDTH 14
1834 #define FCN_RX_DESCQ_SIZE_LBN 3
1835 #define FCN_RX_DESCQ_SIZE_WIDTH 2
1836 #define FCN_RX_DESCQ_SIZE_4K 3
1837 #define FCN_RX_DESCQ_SIZE_2K 2
1838 #define FCN_RX_DESCQ_SIZE_1K 1
1839 #define FCN_RX_DESCQ_SIZE_512 0
1840 #define FCN_RX_DESCQ_TYPE_LBN 2
1841 #define FCN_RX_DESCQ_TYPE_WIDTH 1
1842 #define FCN_RX_DESCQ_JUMBO_LBN 1
1843 #define FCN_RX_DESCQ_JUMBO_WIDTH 1
1844 #define FCN_RX_DESCQ_EN_LBN 0
1845 #define FCN_RX_DESCQ_EN_WIDTH 1
1846
1847 /* Transmit descriptor pointer table */
1848 #define FCN_TX_DESC_PTR_TBL_KER 0x11900
1849 #define FCN_TX_DESCQ_EN_LBN 88
1850 #define FCN_TX_DESCQ_EN_WIDTH 1
1851 #define FCN_TX_DESCQ_BUF_BASE_ID_LBN 36
1852 #define FCN_TX_DESCQ_BUF_BASE_ID_WIDTH 20
1853 #define FCN_TX_DESCQ_EVQ_ID_LBN 24
1854 #define FCN_TX_DESCQ_EVQ_ID_WIDTH 12
1855 #define FCN_TX_DESCQ_OWNER_ID_LBN 10
1856 #define FCN_TX_DESCQ_OWNER_ID_WIDTH 14
1857 #define FCN_TX_DESCQ_SIZE_LBN 3
1858 #define FCN_TX_DESCQ_SIZE_WIDTH 2
1859 #define FCN_TX_DESCQ_SIZE_4K 3
1860 #define FCN_TX_DESCQ_SIZE_2K 2
1861 #define FCN_TX_DESCQ_SIZE_1K 1
1862 #define FCN_TX_DESCQ_SIZE_512 0
1863 #define FCN_TX_DESCQ_TYPE_LBN 1
1864 #define FCN_TX_DESCQ_TYPE_WIDTH 2
1865 #define FCN_TX_DESCQ_FLUSH_LBN 0
1866 #define FCN_TX_DESCQ_FLUSH_WIDTH 1
1867
1868 /* Event queue pointer */
1869 #define FCN_EVQ_PTR_TBL_KER 0x11a00
1870 #define FCN_EVQ_EN_LBN 23
1871 #define FCN_EVQ_EN_WIDTH 1
1872 #define FCN_EVQ_SIZE_LBN 20
1873 #define FCN_EVQ_SIZE_WIDTH 3
1874 #define FCN_EVQ_SIZE_32K 6
1875 #define FCN_EVQ_SIZE_16K 5
1876 #define FCN_EVQ_SIZE_8K 4
1877 #define FCN_EVQ_SIZE_4K 3
1878 #define FCN_EVQ_SIZE_2K 2
1879 #define FCN_EVQ_SIZE_1K 1
1880 #define FCN_EVQ_SIZE_512 0
1881 #define FCN_EVQ_BUF_BASE_ID_LBN 0
1882 #define FCN_EVQ_BUF_BASE_ID_WIDTH 20
1883
1884 /* Event queue read pointer */
1885 #define FCN_EVQ_RPTR_REG_KER 0x11b00
1886 #define FCN_EVQ_RPTR_LBN 0
1887 #define FCN_EVQ_RPTR_WIDTH 14
1888 #define FCN_EVQ_RPTR_REG_KER_DWORD ( FCN_EVQ_RPTR_REG_KER + 0 )
1889 #define FCN_EVQ_RPTR_DWORD_LBN 0
1890 #define FCN_EVQ_RPTR_DWORD_WIDTH 14
1891
1892 /* Special buffer descriptors */
1893 #define FCN_BUF_FULL_TBL_KER 0x18000
1894 #define FCN_IP_DAT_BUF_SIZE_LBN 50
1895 #define FCN_IP_DAT_BUF_SIZE_WIDTH 1
1896 #define FCN_IP_DAT_BUF_SIZE_8K 1
1897 #define FCN_IP_DAT_BUF_SIZE_4K 0
1898 #define FCN_BUF_ADR_FBUF_LBN 14
1899 #define FCN_BUF_ADR_FBUF_WIDTH 34
1900 #define FCN_BUF_OWNER_ID_FBUF_LBN 0
1901 #define FCN_BUF_OWNER_ID_FBUF_WIDTH 14
1902
1903 /* MAC registers */
1904 #define FALCON_MAC_REGBANK 0xe00
1905 #define FALCON_MAC_REGBANK_SIZE 0x200
1906 #define FALCON_MAC_REG_SIZE 0x10
1907
1908 /** Offset of a MAC register within Falcon */
1909 #define FALCON_MAC_REG( efab, mac_reg )                         \
1910         ( FALCON_MAC_REGBANK +                                  \
1911           ( (efab)->port * FALCON_MAC_REGBANK_SIZE ) +          \
1912           ( (mac_reg) * FALCON_MAC_REG_SIZE ) )
1913 #define FCN_MAC_DATA_LBN 0
1914 #define FCN_MAC_DATA_WIDTH 32
1915
1916 /* Transmit descriptor */
1917 #define FCN_TX_KER_PORT_LBN 63
1918 #define FCN_TX_KER_PORT_WIDTH 1
1919 #define FCN_TX_KER_BYTE_CNT_LBN 48
1920 #define FCN_TX_KER_BYTE_CNT_WIDTH 14
1921 #define FCN_TX_KER_BUF_ADR_LBN 0
1922 #define FCN_TX_KER_BUF_ADR_WIDTH EFAB_DMA_TYPE_WIDTH ( 46 )
1923
1924 /* Receive descriptor */
1925 #define FCN_RX_KER_BUF_SIZE_LBN 48
1926 #define FCN_RX_KER_BUF_SIZE_WIDTH 14
1927 #define FCN_RX_KER_BUF_ADR_LBN 0
1928 #define FCN_RX_KER_BUF_ADR_WIDTH EFAB_DMA_TYPE_WIDTH ( 46 )
1929
1930 /* Event queue entries */
1931 #define FCN_EV_CODE_LBN 60
1932 #define FCN_EV_CODE_WIDTH 4
1933 #define FCN_RX_IP_EV_DECODE 0
1934 #define FCN_TX_IP_EV_DECODE 2
1935 #define FCN_DRIVER_EV_DECODE 5
1936
1937 /* Receive events */
1938 #define FCN_RX_PORT_LBN 30
1939 #define FCN_RX_PORT_WIDTH 1
1940 #define FCN_RX_EV_BYTE_CNT_LBN 16
1941 #define FCN_RX_EV_BYTE_CNT_WIDTH 14
1942 #define FCN_RX_EV_DESC_PTR_LBN 0
1943 #define FCN_RX_EV_DESC_PTR_WIDTH 12
1944
1945 /* Transmit events */
1946 #define FCN_TX_EV_DESC_PTR_LBN 0
1947 #define FCN_TX_EV_DESC_PTR_WIDTH 12
1948
1949 /* Fixed special buffer numbers to use */
1950 #define FALCON_EVQ_ID 0
1951 #define FALCON_TXD_ID 1
1952 #define FALCON_RXD_ID 2
1953
1954 #if FALCON_USE_IO_BAR
1955
1956 /* Write dword via the I/O BAR */
1957 static inline void _falcon_writel ( struct efab_nic *efab, uint32_t value,
1958                                     unsigned int reg ) {
1959         outl ( reg, efab->iobase + FCN_IOM_IND_ADR_REG );
1960         outl ( value, efab->iobase + FCN_IOM_IND_DAT_REG );
1961 }
1962
1963 /* Read dword via the I/O BAR */
1964 static inline uint32_t _falcon_readl ( struct efab_nic *efab,
1965                                        unsigned int reg ) {
1966         outl ( reg, efab->iobase + FCN_IOM_IND_ADR_REG );
1967         return inl ( efab->iobase + FCN_IOM_IND_DAT_REG );
1968 }
1969
1970 #else /* FALCON_USE_IO_BAR */
1971
1972 #define _falcon_writel( efab, value, reg ) \
1973         writel ( (value), (efab)->membase + (reg) )
1974 #define _falcon_readl( efab, reg ) readl ( (efab)->membase + (reg) )
1975
1976 #endif /* FALCON_USE_IO_BAR */
1977
1978 /**
1979  * Write to a Falcon register
1980  *
1981  */
1982 static inline void falcon_write ( struct efab_nic *efab, efab_oword_t *value,
1983                                   unsigned int reg ) {
1984
1985         EFAB_REGDUMP ( "Writing register %x with " EFAB_OWORD_FMT "\n",
1986                        reg, EFAB_OWORD_VAL ( *value ) );
1987
1988         _falcon_writel ( efab, value->u32[0], reg + 0  );
1989         _falcon_writel ( efab, value->u32[1], reg + 4  );
1990         _falcon_writel ( efab, value->u32[2], reg + 8  );
1991         _falcon_writel ( efab, value->u32[3], reg + 12 );
1992         wmb();
1993 }
1994
1995 /**
1996  * Write to Falcon SRAM
1997  *
1998  */
1999 static inline void falcon_write_sram ( struct efab_nic *efab,
2000                                        efab_qword_t *value,
2001                                        unsigned int index ) {
2002         unsigned int reg = ( FCN_BUF_FULL_TBL_KER +
2003                              ( index * sizeof ( *value ) ) );
2004
2005         EFAB_REGDUMP ( "Writing SRAM register %x with " EFAB_QWORD_FMT "\n",
2006                        reg, EFAB_QWORD_VAL ( *value ) );
2007
2008         _falcon_writel ( efab, value->u32[0], reg + 0  );
2009         _falcon_writel ( efab, value->u32[1], reg + 4  );
2010         wmb();
2011 }
2012
2013 /**
2014  * Write dword to Falcon register that allows partial writes
2015  *
2016  */
2017 static inline void falcon_writel ( struct efab_nic *efab, efab_dword_t *value,
2018                                    unsigned int reg ) {
2019         EFAB_REGDUMP ( "Writing partial register %x with " EFAB_DWORD_FMT "\n",
2020                        reg, EFAB_DWORD_VAL ( *value ) );
2021         _falcon_writel ( efab, value->u32[0], reg );
2022 }
2023
2024 /**
2025  * Read from a Falcon register
2026  *
2027  */
2028 static inline void falcon_read ( struct efab_nic *efab, efab_oword_t *value,
2029                                  unsigned int reg ) {
2030         value->u32[0] = _falcon_readl ( efab, reg + 0  );
2031         value->u32[1] = _falcon_readl ( efab, reg + 4  );
2032         value->u32[2] = _falcon_readl ( efab, reg + 8  );
2033         value->u32[3] = _falcon_readl ( efab, reg + 12 );
2034
2035         EFAB_REGDUMP ( "Read from register %x, got " EFAB_OWORD_FMT "\n",
2036                        reg, EFAB_OWORD_VAL ( *value ) );
2037 }
2038
2039 /** 
2040  * Read from Falcon SRAM
2041  *
2042  */
2043 static inline void falcon_read_sram ( struct efab_nic *efab,
2044                                       efab_qword_t *value,
2045                                       unsigned int index ) {
2046         unsigned int reg = ( FCN_BUF_FULL_TBL_KER +
2047                              ( index * sizeof ( *value ) ) );
2048
2049         value->u32[0] = _falcon_readl ( efab, reg + 0 );
2050         value->u32[1] = _falcon_readl ( efab, reg + 4 );
2051         EFAB_REGDUMP ( "Read from SRAM register %x, got " EFAB_QWORD_FMT "\n",
2052                        reg, EFAB_QWORD_VAL ( *value ) );
2053 }
2054
2055 /**
2056  * Read dword from a portion of a Falcon register
2057  *
2058  */
2059 static inline void falcon_readl ( struct efab_nic *efab, efab_dword_t *value,
2060                                   unsigned int reg ) {
2061         value->u32[0] = _falcon_readl ( efab, reg );
2062         EFAB_REGDUMP ( "Read from register %x, got " EFAB_DWORD_FMT "\n",
2063                        reg, EFAB_DWORD_VAL ( *value ) );
2064 }
2065
2066 /**
2067  * Verified write to Falcon SRAM
2068  *
2069  */
2070 static inline void falcon_write_sram_verify ( struct efab_nic *efab,
2071                                              efab_qword_t *value,
2072                                              unsigned int index ) {
2073         efab_qword_t verify;
2074         
2075         falcon_write_sram ( efab, value, index );
2076         udelay ( 1000 );
2077         falcon_read_sram ( efab, &verify, index );
2078         if ( memcmp ( &verify, value, sizeof ( verify ) ) != 0 ) {
2079                 printf ( "SRAM index %x failure: wrote " EFAB_QWORD_FMT
2080                          " got " EFAB_QWORD_FMT "\n", index,
2081                          EFAB_QWORD_VAL ( *value ),
2082                          EFAB_QWORD_VAL ( verify ) );
2083         }
2084 }
2085
2086 /**
2087  * Get memory base
2088  *
2089  */
2090 static void falcon_get_membase ( struct efab_nic *efab ) {
2091         unsigned long membase_phys;
2092
2093         membase_phys = pci_bar_start ( efab->pci, PCI_BASE_ADDRESS_2 );
2094         efab->membase = ioremap ( membase_phys, 0x20000 );
2095 }
2096
2097 #define FCN_DUMP_REG( efab, _reg ) do {                         \
2098                 efab_oword_t reg;                               \
2099                 falcon_read ( efab, &reg, _reg );               \
2100                 printf ( #_reg " = " EFAB_OWORD_FMT "\n",       \
2101                          EFAB_OWORD_VAL ( reg ) );              \
2102         } while ( 0 );
2103
2104 #define FCN_DUMP_MAC_REG( efab, _mac_reg ) do {                 \
2105                 efab_dword_t reg;                               \
2106                 efab->op->mac_readl ( efab, &reg, _mac_reg );   \
2107                 printf ( #_mac_reg " = " EFAB_DWORD_FMT "\n",   \
2108                          EFAB_DWORD_VAL ( reg ) );              \
2109         } while ( 0 );
2110
2111 /**
2112  * Dump register contents (for debugging)
2113  *
2114  * Marked as static inline so that it will not be compiled in if not
2115  * used.
2116  */
2117 static inline void falcon_dump_regs ( struct efab_nic *efab ) {
2118         FCN_DUMP_REG ( efab, FCN_INT_EN_REG_KER );
2119         FCN_DUMP_REG ( efab, FCN_INT_ADR_REG_KER );
2120         FCN_DUMP_REG ( efab, FCN_GLB_CTL_REG_KER );
2121         FCN_DUMP_REG ( efab, FCN_TIMER_CMD_REG_KER );
2122         FCN_DUMP_REG ( efab, FCN_SRM_RX_DC_CFG_REG_KER );
2123         FCN_DUMP_REG ( efab, FCN_SRM_TX_DC_CFG_REG_KER );
2124         FCN_DUMP_REG ( efab, FCN_RX_FILTER_CTL_REG_KER );
2125         FCN_DUMP_REG ( efab, FCN_RX_DC_CFG_REG_KER );
2126         FCN_DUMP_REG ( efab, FCN_TX_DC_CFG_REG_KER );
2127         FCN_DUMP_REG ( efab, FCN_MAC0_CTRL_REG_KER );
2128         FCN_DUMP_REG ( efab, FCN_MAC1_CTRL_REG_KER );
2129         FCN_DUMP_REG ( efab, FCN_XM_GLB_CFG_REG_P0_KER );
2130         FCN_DUMP_REG ( efab, FCN_XM_TX_CFG_REG_P0_KER );
2131         FCN_DUMP_REG ( efab, FCN_XM_RX_CFG_REG_P0_KER );
2132         FCN_DUMP_REG ( efab, FCN_RX_DESC_PTR_TBL_KER );
2133         FCN_DUMP_REG ( efab, FCN_TX_DESC_PTR_TBL_KER );
2134         FCN_DUMP_REG ( efab, FCN_EVQ_PTR_TBL_KER );
2135         FCN_DUMP_MAC_REG ( efab, GM_CFG1_REG_MAC );
2136         FCN_DUMP_MAC_REG ( efab, GM_CFG2_REG_MAC );
2137         FCN_DUMP_MAC_REG ( efab, GM_MAX_FLEN_REG_MAC );
2138         FCN_DUMP_MAC_REG ( efab, GM_MII_MGMT_CFG_REG_MAC );
2139         FCN_DUMP_MAC_REG ( efab, GM_ADR1_REG_MAC );
2140         FCN_DUMP_MAC_REG ( efab, GM_ADR2_REG_MAC );
2141         FCN_DUMP_MAC_REG ( efab, GMF_CFG0_REG_MAC );
2142         FCN_DUMP_MAC_REG ( efab, GMF_CFG1_REG_MAC );
2143         FCN_DUMP_MAC_REG ( efab, GMF_CFG2_REG_MAC );
2144         FCN_DUMP_MAC_REG ( efab, GMF_CFG3_REG_MAC );
2145         FCN_DUMP_MAC_REG ( efab, GMF_CFG4_REG_MAC );
2146         FCN_DUMP_MAC_REG ( efab, GMF_CFG5_REG_MAC );
2147 }
2148
2149 /**
2150  * Create special buffer
2151  *
2152  */
2153 static void falcon_create_special_buffer ( struct efab_nic *efab,
2154                                            void *addr, unsigned int index ) {
2155         efab_qword_t buf_desc;
2156         unsigned long dma_addr;
2157
2158         memset ( addr, 0, 4096 );
2159         dma_addr = virt_to_bus ( addr );
2160         EFAB_ASSERT ( ( dma_addr & ( EFAB_BUF_ALIGN - 1 ) ) == 0 );
2161         EFAB_POPULATE_QWORD_3 ( buf_desc,
2162                                 FCN_IP_DAT_BUF_SIZE, FCN_IP_DAT_BUF_SIZE_4K,
2163                                 FCN_BUF_ADR_FBUF, ( dma_addr >> 12 ),
2164                                 FCN_BUF_OWNER_ID_FBUF, 0 );
2165         falcon_write_sram_verify ( efab, &buf_desc, index );
2166 }
2167
2168 /**
2169  * Update event queue read pointer
2170  *
2171  */
2172 static void falcon_eventq_read_ack ( struct efab_nic *efab ) {
2173         efab_dword_t reg;
2174
2175         EFAB_ASSERT ( efab->eventq_read_ptr < EFAB_EVQ_SIZE );
2176
2177         EFAB_POPULATE_DWORD_1 ( reg, FCN_EVQ_RPTR_DWORD,
2178                                 efab->eventq_read_ptr );
2179         falcon_writel ( efab, &reg, FCN_EVQ_RPTR_REG_KER_DWORD );
2180 }
2181
2182 /**
2183  * Reset device
2184  *
2185  */
2186 static int falcon_reset ( struct efab_nic *efab ) {
2187         efab_oword_t glb_ctl_reg_ker;
2188
2189         /* Initiate software reset */
2190         EFAB_POPULATE_OWORD_5 ( glb_ctl_reg_ker,
2191                                 FCN_EXT_PHY_RST_CTL, FCN_EXCLUDE_FROM_RESET,
2192                                 FCN_PCIE_SD_RST_CTL, FCN_EXCLUDE_FROM_RESET,
2193                                 FCN_PCIX_RST_CTL, FCN_EXCLUDE_FROM_RESET,
2194                                 FCN_INT_RST_DUR, 0x7 /* datasheet */,
2195                                 FCN_SWRST, 1 );
2196         falcon_write ( efab, &glb_ctl_reg_ker, FCN_GLB_CTL_REG_KER );
2197
2198         /* Allow 20ms for reset */
2199         mdelay ( 20 );
2200
2201         /* Check for device reset complete */
2202         falcon_read ( efab, &glb_ctl_reg_ker, FCN_GLB_CTL_REG_KER );
2203         if ( EFAB_OWORD_FIELD ( glb_ctl_reg_ker, FCN_SWRST ) != 0 ) {
2204                 printf ( "Reset failed\n" );
2205                 return 0;
2206         }
2207
2208         return 1;
2209 }
2210
2211 /**
2212  * Initialise NIC
2213  *
2214  */
2215 static int falcon_init_nic ( struct efab_nic *efab ) {
2216         efab_oword_t reg;
2217         efab_dword_t timer_cmd;
2218
2219         /* Set up TX and RX descriptor caches in SRAM */
2220         EFAB_POPULATE_OWORD_1 ( reg, FCN_SRM_TX_DC_BASE_ADR,
2221                                 0x130000 /* recommended in datasheet */ );
2222         falcon_write ( efab, &reg, FCN_SRM_TX_DC_CFG_REG_KER );
2223         EFAB_POPULATE_OWORD_1 ( reg, FCN_TX_DC_SIZE, 2 /* 32 descriptors */ );
2224         falcon_write ( efab, &reg, FCN_TX_DC_CFG_REG_KER );
2225         EFAB_POPULATE_OWORD_1 ( reg, FCN_SRM_RX_DC_BASE_ADR,
2226                                 0x100000 /* recommended in datasheet */ );
2227         falcon_write ( efab, &reg, FCN_SRM_RX_DC_CFG_REG_KER );
2228         EFAB_POPULATE_OWORD_1 ( reg, FCN_RX_DC_SIZE, 2 /* 32 descriptors */ );
2229         falcon_write ( efab, &reg, FCN_RX_DC_CFG_REG_KER );
2230         
2231         /* Set number of RSS CPUs */
2232         EFAB_POPULATE_OWORD_1 ( reg, FCN_NUM_KER, 0 );
2233         falcon_write ( efab, &reg, FCN_RX_FILTER_CTL_REG_KER );
2234         udelay ( 1000 );
2235         
2236         /* Reset the MAC */
2237         mentormac_reset ( efab );
2238
2239         /* Set up event queue */
2240         falcon_create_special_buffer ( efab, efab->eventq, FALCON_EVQ_ID );
2241         EFAB_POPULATE_OWORD_3 ( reg,
2242                                 FCN_EVQ_EN, 1,
2243                                 FCN_EVQ_SIZE, FCN_EVQ_SIZE_512,
2244                                 FCN_EVQ_BUF_BASE_ID, FALCON_EVQ_ID );
2245         falcon_write ( efab, &reg, FCN_EVQ_PTR_TBL_KER );
2246         udelay ( 1000 );
2247
2248         /* Set timer register */
2249         EFAB_POPULATE_DWORD_2 ( timer_cmd,
2250                                 FCN_TIMER_MODE, FCN_TIMER_MODE_DIS,
2251                                 FCN_TIMER_VAL, 0 );
2252         falcon_writel ( efab, &timer_cmd, FCN_TIMER_CMD_REG_KER );
2253         udelay ( 1000 );
2254
2255         /* Initialise event queue read pointer */
2256         falcon_eventq_read_ack ( efab );
2257         
2258         /* Set up TX descriptor ring */
2259         falcon_create_special_buffer ( efab, efab->txd, FALCON_TXD_ID );
2260         EFAB_POPULATE_OWORD_5 ( reg,
2261                                 FCN_TX_DESCQ_EN, 1,
2262                                 FCN_TX_DESCQ_BUF_BASE_ID, FALCON_TXD_ID,
2263                                 FCN_TX_DESCQ_EVQ_ID, 0,
2264                                 FCN_TX_DESCQ_SIZE, FCN_TX_DESCQ_SIZE_512,
2265                                 FCN_TX_DESCQ_TYPE, 0 /* kernel queue */ );
2266         falcon_write ( efab, &reg, FCN_TX_DESC_PTR_TBL_KER );
2267
2268         /* Set up RX descriptor ring */
2269         falcon_create_special_buffer ( efab, efab->rxd, FALCON_RXD_ID );
2270         EFAB_POPULATE_OWORD_6 ( reg,
2271                                 FCN_RX_DESCQ_BUF_BASE_ID, FALCON_RXD_ID,
2272                                 FCN_RX_DESCQ_EVQ_ID, 0,
2273                                 FCN_RX_DESCQ_SIZE, FCN_RX_DESCQ_SIZE_512,
2274                                 FCN_RX_DESCQ_TYPE, 0 /* kernel queue */,
2275                                 FCN_RX_DESCQ_JUMBO, 1,
2276                                 FCN_RX_DESCQ_EN, 1 );
2277         falcon_write ( efab, &reg, FCN_RX_DESC_PTR_TBL_KER );
2278
2279         /* Program INT_ADR_REG_KER */
2280         EFAB_POPULATE_OWORD_1 ( reg,
2281                                 FCN_INT_ADR_KER,
2282                                 virt_to_bus ( &efab->int_ker ) );
2283         falcon_write ( efab, &reg, FCN_INT_ADR_REG_KER );
2284         udelay ( 1000 );
2285
2286         return 1;
2287 }
2288
2289 /** SPI device */
2290 struct efab_spi_device {
2291         /** Device ID */
2292         unsigned int device_id;
2293         /** Address length (in bytes) */
2294         unsigned int addr_len;
2295         /** Read command */
2296         unsigned int read_command;
2297 };
2298
2299 /**
2300  * Wait for SPI command completion
2301  *
2302  */
2303 static int falcon_spi_wait ( struct efab_nic *efab ) {
2304         efab_oword_t reg;
2305         int count;
2306
2307         count = 0;
2308         do {
2309                 udelay ( 100 );
2310                 falcon_read ( efab, &reg, FCN_EE_SPI_HCMD_REG_KER );
2311                 if ( EFAB_OWORD_FIELD ( reg, FCN_EE_SPI_HCMD_CMD_EN ) == 0 )
2312                         return 1;
2313         } while ( ++count < 1000 );
2314         printf ( "Timed out waiting for SPI\n" );
2315         return 0;
2316 }
2317
2318 /**
2319  * Perform SPI read
2320  *
2321  */
2322 static int falcon_spi_read ( struct efab_nic *efab,
2323                              struct efab_spi_device *spi,
2324                              int address, void *data, unsigned int len ) {
2325         efab_oword_t reg;
2326
2327         /* Program address register */
2328         EFAB_POPULATE_OWORD_1 ( reg, FCN_EE_SPI_HADR_ADR, address );
2329         falcon_write ( efab, &reg, FCN_EE_SPI_HADR_REG_KER );
2330         
2331         /* Issue read command */
2332         EFAB_POPULATE_OWORD_7 ( reg,
2333                                 FCN_EE_SPI_HCMD_CMD_EN, 1, 
2334                                 FCN_EE_SPI_HCMD_SF_SEL, spi->device_id,
2335                                 FCN_EE_SPI_HCMD_DABCNT, len,
2336                                 FCN_EE_SPI_HCMD_READ, FCN_EE_SPI_READ,
2337                                 FCN_EE_SPI_HCMD_DUBCNT, 0,
2338                                 FCN_EE_SPI_HCMD_ADBCNT, spi->addr_len,
2339                                 FCN_EE_SPI_HCMD_ENC, spi->read_command );
2340         falcon_write ( efab, &reg, FCN_EE_SPI_HCMD_REG_KER );
2341         
2342         /* Wait for read to complete */
2343         if ( ! falcon_spi_wait ( efab ) )
2344                 return 0;
2345         
2346         /* Read data */
2347         falcon_read ( efab, &reg, FCN_EE_SPI_HDATA_REG_KER );
2348         memcpy ( data, &reg, len );
2349
2350         return 1;
2351 }
2352
2353 #define SPI_READ_CMD 0x03
2354 #define AT25F1024_ADDR_LEN 3
2355 #define AT25F1024_READ_CMD SPI_READ_CMD
2356 #define MC25XX640_ADDR_LEN 2
2357 #define MC25XX640_READ_CMD SPI_READ_CMD
2358
2359 /** Falcon Flash SPI device */
2360 static struct efab_spi_device falcon_spi_flash = {
2361         .device_id      = FCN_EE_SPI_FLASH,
2362         .addr_len       = AT25F1024_ADDR_LEN,
2363         .read_command   = AT25F1024_READ_CMD,
2364 };
2365
2366 /** Falcon EEPROM SPI device */
2367 static struct efab_spi_device falcon_spi_large_eeprom = {
2368         .device_id      = FCN_EE_SPI_EEPROM,
2369         .addr_len       = MC25XX640_ADDR_LEN,
2370         .read_command   = MC25XX640_READ_CMD,
2371 };
2372
2373 /** Offset of MAC address within EEPROM or Flash */
2374 #define FALCON_MAC_ADDRESS_OFFSET(port) ( 0x310 + 0x08 * (port) )
2375
2376 /**
2377  * Read MAC address from EEPROM
2378  *
2379  */
2380 static int falcon_read_eeprom ( struct efab_nic *efab ) {
2381         efab_oword_t reg;
2382         int has_flash;
2383         struct efab_spi_device *spi;
2384
2385         /* Determine the SPI device containing the MAC address */
2386         falcon_read ( efab, &reg, FCN_GPIO_CTL_REG_KER );
2387         has_flash = EFAB_OWORD_FIELD ( reg, FCN_FLASH_PRESENT );
2388         spi = has_flash ? &falcon_spi_flash : &falcon_spi_large_eeprom;
2389
2390         return falcon_spi_read ( efab, spi,
2391                                  FALCON_MAC_ADDRESS_OFFSET ( efab->port ),
2392                                  efab->mac_addr, sizeof ( efab->mac_addr ) );
2393 }
2394
2395 /** RX descriptor */
2396 typedef efab_qword_t falcon_rx_desc_t;
2397
2398 /**
2399  * Build RX descriptor
2400  *
2401  */
2402 static void falcon_build_rx_desc ( struct efab_nic *efab,
2403                                    struct efab_rx_buf *rx_buf ) {
2404         falcon_rx_desc_t *rxd;
2405
2406         rxd = ( ( falcon_rx_desc_t * ) efab->rxd ) + rx_buf->id;
2407         EFAB_POPULATE_QWORD_2 ( *rxd,
2408                                 FCN_RX_KER_BUF_SIZE, EFAB_DATA_BUF_SIZE,
2409                                 FCN_RX_KER_BUF_ADR,
2410                                 virt_to_bus ( rx_buf->addr ) );
2411 }
2412
2413 /**
2414  * Update RX descriptor write pointer
2415  *
2416  */
2417 static void falcon_notify_rx_desc ( struct efab_nic *efab ) {
2418         efab_dword_t reg;
2419
2420         EFAB_POPULATE_DWORD_1 ( reg, FCN_RX_DESC_WPTR_DWORD,
2421                                 efab->rx_write_ptr );
2422         falcon_writel ( efab, &reg, FCN_RX_DESC_UPD_REG_KER_DWORD );
2423 }
2424
2425 /** TX descriptor */
2426 typedef efab_qword_t falcon_tx_desc_t;
2427
2428 /**
2429  * Build TX descriptor
2430  *
2431  */
2432 static void falcon_build_tx_desc ( struct efab_nic *efab,
2433                                    struct efab_tx_buf *tx_buf ) {
2434         falcon_rx_desc_t *txd;
2435
2436         txd = ( ( falcon_rx_desc_t * ) efab->txd ) + tx_buf->id;
2437         EFAB_POPULATE_QWORD_3 ( *txd,
2438                                 FCN_TX_KER_PORT, efab->port,
2439                                 FCN_TX_KER_BYTE_CNT, tx_buf->len,
2440                                 FCN_TX_KER_BUF_ADR,
2441                                 virt_to_bus ( tx_buf->addr ) );
2442 }
2443
2444 /**
2445  * Update TX descriptor write pointer
2446  *
2447  */
2448 static void falcon_notify_tx_desc ( struct efab_nic *efab ) {
2449         efab_dword_t reg;
2450
2451         EFAB_POPULATE_DWORD_1 ( reg, FCN_TX_DESC_WPTR_DWORD,
2452                                 efab->tx_write_ptr );
2453         falcon_writel ( efab, &reg, FCN_TX_DESC_UPD_REG_KER_DWORD );
2454 }
2455
2456 /** An event */
2457 typedef efab_qword_t falcon_event_t;
2458
2459 /**
2460  * Retrieve event from event queue
2461  *
2462  */
2463 static int falcon_fetch_event ( struct efab_nic *efab,
2464                                 struct efab_event *event ) {
2465         falcon_event_t *evt;
2466         int ev_code;
2467         int rx_port;
2468
2469         /* Check for event */
2470         evt = ( ( falcon_event_t * ) efab->eventq ) + efab->eventq_read_ptr;
2471         if ( EFAB_QWORD_IS_ZERO ( *evt ) ) {
2472                 /* No event */
2473                 return 0;
2474         }
2475         
2476         DBG ( "Event is " EFAB_QWORD_FMT "\n", EFAB_QWORD_VAL ( *evt ) );
2477
2478         /* Decode event */
2479         ev_code = EFAB_QWORD_FIELD ( *evt, FCN_EV_CODE );
2480         switch ( ev_code ) {
2481         case FCN_TX_IP_EV_DECODE:
2482                 event->type = EFAB_EV_TX;
2483                 break;
2484         case FCN_RX_IP_EV_DECODE:
2485                 event->type = EFAB_EV_RX;
2486                 event->rx_id = EFAB_QWORD_FIELD ( *evt, FCN_RX_EV_DESC_PTR );
2487                 event->rx_len = EFAB_QWORD_FIELD ( *evt, FCN_RX_EV_BYTE_CNT );
2488                 rx_port = EFAB_QWORD_FIELD ( *evt, FCN_RX_PORT );
2489                 if ( rx_port != efab->port ) {
2490                         /* Ignore packets on the wrong port.  We can't
2491                          * just set event->type = EFAB_EV_NONE,
2492                          * because then the descriptor ring won't get
2493                          * refilled.
2494                          */
2495                         event->rx_len = 0;
2496                 }
2497                 break;
2498         case FCN_DRIVER_EV_DECODE:
2499                 /* Ignore start-of-day events */
2500                 event->type = EFAB_EV_NONE;
2501                 break;
2502         default:
2503                 printf ( "Unknown event type %d\n", ev_code );
2504                 event->type = EFAB_EV_NONE;
2505         }
2506
2507         /* Clear event and any pending interrupts */
2508         EFAB_ZERO_QWORD ( *evt );
2509         falcon_writel ( efab, 0, FCN_INT_ACK_KER_REG );
2510         udelay ( 10 );
2511
2512         /* Increment and update event queue read pointer */
2513         efab->eventq_read_ptr = ( ( efab->eventq_read_ptr + 1 )
2514                                   % EFAB_EVQ_SIZE );
2515         falcon_eventq_read_ack ( efab );
2516
2517         return 1;
2518 }
2519
2520 /**
2521  * Enable/disable/generate interrupt
2522  *
2523  */
2524 static inline void falcon_interrupts ( struct efab_nic *efab, int enabled,
2525                                        int force ) {
2526         efab_oword_t int_en_reg_ker;
2527
2528         EFAB_POPULATE_OWORD_2 ( int_en_reg_ker,
2529                                 FCN_KER_INT_KER, force,
2530                                 FCN_DRV_INT_EN_KER, enabled );
2531         falcon_write ( efab, &int_en_reg_ker, FCN_INT_EN_REG_KER );     
2532 }
2533
2534 /**
2535  * Enable/disable interrupts
2536  *
2537  */
2538 static void falcon_mask_irq ( struct efab_nic *efab, int enabled ) {
2539         falcon_interrupts ( efab, enabled, 0 );
2540         if ( enabled ) {
2541                 /* Events won't trigger interrupts until we do this */
2542                 falcon_eventq_read_ack ( efab );
2543         }
2544 }
2545
2546 /**
2547  * Generate interrupt
2548  *
2549  */
2550 static void falcon_generate_irq ( struct efab_nic *efab ) {
2551         falcon_interrupts ( efab, 1, 1 );
2552 }
2553
2554 /**
2555  * Write dword to a Falcon MAC register
2556  *
2557  */
2558 static void falcon_mac_writel ( struct efab_nic *efab,
2559                                 efab_dword_t *value, unsigned int mac_reg ) {
2560         efab_oword_t temp;
2561
2562         EFAB_POPULATE_OWORD_1 ( temp, FCN_MAC_DATA,
2563                                 EFAB_DWORD_FIELD ( *value, FCN_MAC_DATA ) );
2564         falcon_write ( efab, &temp, FALCON_MAC_REG ( efab, mac_reg ) );
2565 }
2566
2567 /**
2568  * Read dword from a Falcon MAC register
2569  *
2570  */
2571 static void falcon_mac_readl ( struct efab_nic *efab, efab_dword_t *value,
2572                                unsigned int mac_reg ) {
2573         efab_oword_t temp;
2574
2575         falcon_read ( efab, &temp, FALCON_MAC_REG ( efab, mac_reg ) );
2576         EFAB_POPULATE_DWORD_1 ( *value, FCN_MAC_DATA,
2577                                 EFAB_OWORD_FIELD ( temp, FCN_MAC_DATA ) );
2578 }
2579
2580 /**
2581  * Initialise MAC
2582  *
2583  */
2584 static int falcon_init_mac ( struct efab_nic *efab ) {
2585         static struct efab_mentormac_parameters falcon_mentormac_params = {
2586                 .gmf_cfgfrth = 0x12,
2587                 .gmf_cfgftth = 0x08,
2588                 .gmf_cfghwmft = 0x1c,
2589                 .gmf_cfghwm = 0x3f,
2590                 .gmf_cfglwm = 0xa,
2591         };
2592         efab_oword_t reg;
2593         int link_speed;
2594
2595         /* Initialise PHY */
2596         alaska_init ( efab );
2597
2598         /* Initialise MAC */
2599         mentormac_init ( efab, &falcon_mentormac_params );
2600
2601         /* Configure the Falcon MAC wrapper */
2602         EFAB_POPULATE_OWORD_4 ( reg,
2603                                 FCN_XM_RX_JUMBO_MODE, 0,
2604                                 FCN_XM_CUT_THRU_MODE, 0,
2605                                 FCN_XM_TX_STAT_EN, 1,
2606                                 FCN_XM_RX_STAT_EN, 1);
2607         falcon_write ( efab, &reg, FCN_XM_GLB_CFG_REG_P0_KER );
2608
2609         EFAB_POPULATE_OWORD_6 ( reg, 
2610                                 FCN_XM_TXEN, 1,
2611                                 FCN_XM_TX_PRMBL, 1,
2612                                 FCN_XM_AUTO_PAD, 1,
2613                                 FCN_XM_TXCRC, 1,
2614                                 FCN_XM_WTF_DOES_THIS_DO, 1,
2615                                 FCN_XM_IPG, 0x3 );
2616         falcon_write ( efab, &reg, FCN_XM_TX_CFG_REG_P0_KER );
2617
2618         EFAB_POPULATE_OWORD_3 ( reg,
2619                                 FCN_XM_RXEN, 1,
2620                                 FCN_XM_AUTO_DEPAD, 1,
2621                                 FCN_XM_PASS_CRC_ERR, 1 );
2622         falcon_write ( efab, &reg, FCN_XM_RX_CFG_REG_P0_KER );
2623
2624 #warning "10G support not yet present"
2625 #define LPA_10000 0
2626         if ( efab->link_options & LPA_10000 ) {
2627                 link_speed = 0x3;
2628         } else if ( efab->link_options & LPA_1000 ) {
2629                 link_speed = 0x2;
2630         } else if ( efab->link_options & LPA_100 ) {
2631                 link_speed = 0x1;
2632         } else {
2633                 link_speed = 0x0;
2634         }
2635         EFAB_POPULATE_OWORD_5 ( reg,
2636                                 FCN_MAC_XOFF_VAL, 0xffff /* datasheet */,
2637                                 FCN_MAC_BCAD_ACPT, 1,
2638                                 FCN_MAC_UC_PROM, 0,
2639                                 FCN_MAC_LINK_STATUS, 1,
2640                                 FCN_MAC_SPEED, link_speed );
2641         falcon_write ( efab, &reg, ( efab->port == 0 ?
2642                              FCN_MAC0_CTRL_REG_KER : FCN_MAC1_CTRL_REG_KER ) );
2643
2644         return 1;
2645 }
2646
2647 /**
2648  * Wait for GMII access to complete
2649  *
2650  */
2651 static int falcon_gmii_wait ( struct efab_nic *efab ) {
2652         efab_oword_t md_stat;
2653         int count;
2654
2655         for ( count = 0 ; count < 1000 ; count++ ) {
2656                 udelay ( 10 );
2657                 falcon_read ( efab, &md_stat, FCN_MD_STAT_REG_KER );
2658                 if ( EFAB_OWORD_FIELD ( md_stat, FCN_MD_BSY ) == 0 )
2659                         return 1;
2660         }
2661         printf ( "Timed out waiting for GMII\n" );
2662         return 0;
2663 }
2664
2665 /** MDIO write */
2666 static void falcon_mdio_write ( struct efab_nic *efab, int location,
2667                                 int value ) {
2668         int phy_id = efab->port + 2;
2669         efab_oword_t reg;
2670
2671 #warning "10G PHY access not yet in place"
2672
2673         EFAB_TRACE ( "Writing GMII %d register %02x with %04x\n",
2674                      phy_id, location, value );
2675
2676         /* Check MII not currently being accessed */
2677         if ( ! falcon_gmii_wait ( efab ) )
2678                 return;
2679
2680         /* Write the address registers */
2681         EFAB_POPULATE_OWORD_1 ( reg, FCN_MD_PHY_ADR, 0 /* phy_id ? */ );
2682         falcon_write ( efab, &reg, FCN_MD_PHY_ADR_REG_KER );
2683         udelay ( 10 );
2684         EFAB_POPULATE_OWORD_2 ( reg,
2685                                 FCN_MD_PRT_ADR, phy_id,
2686                                 FCN_MD_DEV_ADR, location );
2687         falcon_write ( efab, &reg, FCN_MD_ID_REG_KER );
2688         udelay ( 10 );
2689
2690         /* Write data */
2691         EFAB_POPULATE_OWORD_1 ( reg, FCN_MD_TXD, value );
2692         falcon_write ( efab, &reg, FCN_MD_TXD_REG_KER );
2693         udelay ( 10 );
2694         EFAB_POPULATE_OWORD_2 ( reg,
2695                                 FCN_MD_WRC, 1,
2696                                 FCN_MD_GC, 1 );
2697         falcon_write ( efab, &reg, FCN_MD_CS_REG_KER );
2698         udelay ( 10 );
2699         
2700         /* Wait for data to be written */
2701         falcon_gmii_wait ( efab );
2702 }
2703
2704 /** MDIO read */
2705 static int falcon_mdio_read ( struct efab_nic *efab, int location ) {
2706         int phy_id = efab->port + 2;
2707         efab_oword_t reg;
2708         int value;
2709
2710         /* Check MII not currently being accessed */
2711         if ( ! falcon_gmii_wait ( efab ) )
2712                 return 0xffff;
2713
2714         /* Write the address registers */
2715         EFAB_POPULATE_OWORD_1 ( reg, FCN_MD_PHY_ADR, 0 /* phy_id ? */ );
2716         falcon_write ( efab, &reg, FCN_MD_PHY_ADR_REG_KER );
2717         udelay ( 10 );
2718         EFAB_POPULATE_OWORD_2 ( reg,
2719                                 FCN_MD_PRT_ADR, phy_id,
2720                                 FCN_MD_DEV_ADR, location );
2721         falcon_write ( efab, &reg, FCN_MD_ID_REG_KER );
2722         udelay ( 10 );
2723
2724         /* Request data to be read */
2725         EFAB_POPULATE_OWORD_2 ( reg,
2726                                 FCN_MD_RIC, 1,
2727                                 FCN_MD_GC, 1 );
2728         falcon_write ( efab, &reg, FCN_MD_CS_REG_KER );
2729         udelay ( 10 );
2730         
2731         /* Wait for data to become available */
2732         falcon_gmii_wait ( efab );
2733
2734         /* Read the data */
2735         falcon_read ( efab, &reg, FCN_MD_RXD_REG_KER );
2736         value = EFAB_OWORD_FIELD ( reg, FCN_MD_RXD );
2737
2738         EFAB_TRACE ( "Read from GMII %d register %02x, got %04x\n",
2739                      phy_id, location, value );
2740
2741         return value;
2742 }
2743
2744 static struct efab_operations falcon_operations = {
2745         .get_membase            = falcon_get_membase,
2746         .reset                  = falcon_reset,
2747         .init_nic               = falcon_init_nic,
2748         .read_eeprom            = falcon_read_eeprom,
2749         .build_rx_desc          = falcon_build_rx_desc,
2750         .notify_rx_desc         = falcon_notify_rx_desc,
2751         .build_tx_desc          = falcon_build_tx_desc,
2752         .notify_tx_desc         = falcon_notify_tx_desc,
2753         .fetch_event            = falcon_fetch_event,
2754         .mask_irq               = falcon_mask_irq,
2755         .generate_irq           = falcon_generate_irq,
2756         .mac_writel             = falcon_mac_writel,
2757         .mac_readl              = falcon_mac_readl,
2758         .init_mac               = falcon_init_mac,
2759         .mdio_write             = falcon_mdio_write,
2760         .mdio_read              = falcon_mdio_read,
2761 };
2762
2763 /**************************************************************************
2764  *
2765  * Etherfabric abstraction layer
2766  *
2767  **************************************************************************
2768  */
2769
2770 /**
2771  * Push RX buffer to RXD ring
2772  *
2773  */
2774 static inline void efab_push_rx_buffer ( struct efab_nic *efab,
2775                                          struct efab_rx_buf *rx_buf ) {
2776         /* Create RX descriptor */
2777         rx_buf->id = efab->rx_write_ptr;
2778         efab->op->build_rx_desc ( efab, rx_buf );
2779
2780         /* Update RX write pointer */
2781         efab->rx_write_ptr = ( efab->rx_write_ptr + 1 ) % EFAB_RXD_SIZE;
2782         efab->op->notify_rx_desc ( efab );
2783
2784         DBG ( "Added RX id %x\n", rx_buf->id );
2785 }
2786
2787 /**
2788  * Push TX buffer to TXD ring
2789  *
2790  */
2791 static inline void efab_push_tx_buffer ( struct efab_nic *efab,
2792                                          struct efab_tx_buf *tx_buf ) {
2793         /* Create TX descriptor */
2794         tx_buf->id = efab->tx_write_ptr;
2795         efab->op->build_tx_desc ( efab, tx_buf );
2796
2797         /* Update TX write pointer */
2798         efab->tx_write_ptr = ( efab->tx_write_ptr + 1 ) % EFAB_TXD_SIZE;
2799         efab->op->notify_tx_desc ( efab );
2800
2801         DBG ( "Added TX id %x\n", tx_buf->id );
2802 }
2803
2804 /**
2805  * Initialise MAC and wait for link up
2806  *
2807  */
2808 static int efab_init_mac ( struct efab_nic *efab ) {
2809         int count;
2810
2811         /* This can take several seconds */
2812         printf ( "Waiting for link.." );
2813         count = 0;
2814         do {
2815                 putchar ( '.' );
2816                 if ( ! efab->op->init_mac ( efab ) ) {
2817                         printf ( "failed\n" );
2818                         return 0;
2819                 }
2820                 if ( efab->link_up ) {
2821                         /* PHY init printed the message for us */
2822                         return 1;
2823                 }
2824                 sleep ( 1 );
2825         } while ( ++count < 5 );
2826         printf ( "timed out\n" );
2827
2828         return 0;
2829 }
2830
2831 /**
2832  * Initialise NIC
2833  *
2834  */
2835 static int efab_init_nic ( struct efab_nic *efab ) {
2836         int i;
2837
2838         /* Initialise NIC */
2839         if ( ! efab->op->init_nic ( efab ) )
2840                 return 0;
2841
2842         /* Push RX descriptors */
2843         for ( i = 0 ; i < EFAB_RX_BUFS ; i++ ) {
2844                 efab_push_rx_buffer ( efab, &efab->rx_bufs[i] );
2845         }
2846
2847         /* Read MAC address from EEPROM */
2848         if ( ! efab->op->read_eeprom ( efab ) )
2849                 return 0;
2850
2851         /* Initialise MAC and wait for link up */
2852         if ( ! efab_init_mac ( efab ) )
2853                 return 0;
2854
2855         return 1;
2856 }
2857
2858 /**************************************************************************
2859  *
2860  * Etherboot interface
2861  *
2862  **************************************************************************
2863  */
2864
2865 /**************************************************************************
2866 POLL - Wait for a frame
2867 ***************************************************************************/
2868 static int etherfabric_poll ( struct nic *nic, int retrieve ) {
2869         struct efab_nic *efab = nic->priv_data;
2870         struct efab_event event;
2871         static struct efab_rx_buf *rx_buf = NULL;
2872         int i;
2873
2874         /* Process the event queue until we hit either a packet
2875          * received event or an empty event slot.
2876          */
2877         while ( ( rx_buf == NULL ) &&
2878                 efab->op->fetch_event ( efab, &event ) ) {
2879                 if ( event.type == EFAB_EV_TX ) {
2880                         /* TX completed - mark as done */
2881                         DBG ( "TX id %x complete\n",
2882                               efab->tx_buf.id );
2883                         efab->tx_in_progress = 0;
2884                 } else if ( event.type == EFAB_EV_RX ) {
2885                         /* RX - find corresponding buffer */
2886                         for ( i = 0 ; i < EFAB_RX_BUFS ; i++ ) {
2887                                 if ( efab->rx_bufs[i].id == event.rx_id ) {
2888                                         rx_buf = &efab->rx_bufs[i];
2889                                         rx_buf->len = event.rx_len;
2890                                         DBG ( "RX id %x (len %x) received\n",
2891                                               rx_buf->id, rx_buf->len );
2892                                         break;
2893                                 }
2894                         }
2895                         if ( ! rx_buf ) {
2896                                 printf ( "Invalid RX ID %x\n", event.rx_id );
2897                         }
2898                 } else if ( event.type == EFAB_EV_NONE ) {
2899                         DBG ( "Ignorable event\n" );
2900                 } else {
2901                         DBG ( "Unknown event\n" );
2902                 }
2903         }
2904
2905         /* If there is no packet, return 0 */
2906         if ( ! rx_buf )
2907                 return 0;
2908
2909         /* If we don't want to retrieve it just yet, return 1 */
2910         if ( ! retrieve )
2911                 return 1;
2912
2913         /* Copy packet contents */
2914         nic->packetlen = rx_buf->len;
2915         memcpy ( nic->packet, rx_buf->addr, nic->packetlen );
2916
2917         /* Give this buffer back to the NIC */
2918         efab_push_rx_buffer ( efab, rx_buf );
2919
2920         /* Prepare to receive next packet */
2921         rx_buf = NULL;
2922
2923         return 1;
2924 }
2925
2926 /**************************************************************************
2927 TRANSMIT - Transmit a frame
2928 ***************************************************************************/
2929 static void etherfabric_transmit ( struct nic *nic, const char *dest,
2930                                    unsigned int type, unsigned int size,
2931                                    const char *data ) {
2932         struct efab_nic *efab = nic->priv_data;
2933         unsigned int nstype = htons ( type );
2934
2935         /* We can only transmit one packet at a time; a TX completion
2936          * event must be received before we can transmit the next
2937          * packet.  Since there is only one static TX buffer, we don't
2938          * worry unduly about overflow, but we report it anyway.
2939          */
2940         if ( efab->tx_in_progress ) {
2941                 printf ( "TX overflow!\n" );
2942         }
2943
2944         /* Fill TX buffer, pad to ETH_ZLEN */
2945         memcpy ( efab->tx_buf.addr, dest, ETH_ALEN );
2946         memcpy ( efab->tx_buf.addr + ETH_ALEN, nic->node_addr, ETH_ALEN );
2947         memcpy ( efab->tx_buf.addr + 2 * ETH_ALEN, &nstype, 2 );
2948         memcpy ( efab->tx_buf.addr + ETH_HLEN, data, size );
2949         size += ETH_HLEN;
2950         while ( size < ETH_ZLEN ) {
2951                 efab->tx_buf.addr[size++] = '\0';
2952         }
2953         efab->tx_buf.len = size;
2954
2955         /* Push TX descriptor */
2956         efab_push_tx_buffer ( efab, &efab->tx_buf );
2957
2958         /* There is no way to wait for TX complete (i.e. TX buffer
2959          * available to re-use for the next transmit) without reading
2960          * from the event queue.  We therefore simply leave the TX
2961          * buffer marked as "in use" until a TX completion event
2962          * happens to be picked up by a call to etherfabric_poll().
2963          */
2964         efab->tx_in_progress = 1;
2965
2966         return;
2967 }
2968
2969 /**************************************************************************
2970 DISABLE - Turn off ethernet interface
2971 ***************************************************************************/
2972 static void etherfabric_disable ( struct dev *dev ) {
2973         struct nic *nic = ( struct nic * ) dev;
2974         struct efab_nic *efab = nic->priv_data;
2975
2976         efab->op->reset ( efab );
2977         if ( efab->membase )
2978                 iounmap ( efab->membase );
2979 }
2980
2981 /**************************************************************************
2982 IRQ - handle interrupts
2983 ***************************************************************************/
2984 static void etherfabric_irq ( struct nic *nic, irq_action_t action ) {
2985         struct efab_nic *efab = nic->priv_data;
2986        
2987         switch ( action ) {
2988         case DISABLE :
2989                 efab->op->mask_irq ( efab, 1 );
2990                 break;
2991         case ENABLE :
2992                 efab->op->mask_irq ( efab, 0 );
2993                 break;
2994         case FORCE :
2995                 /* Force NIC to generate a receive interrupt */
2996                 efab->op->generate_irq ( efab );
2997                 break;
2998         }
2999         
3000         return;
3001 }
3002
3003 /**************************************************************************
3004 PROBE - Look for an adapter, this routine's visible to the outside
3005 ***************************************************************************/
3006 static int etherfabric_probe ( struct dev *dev, struct pci_device *pci ) {
3007         struct nic *nic = ( struct nic * ) dev;
3008         static struct efab_nic efab;
3009         static int nic_port = 1;
3010         struct efab_buffers *buffers;
3011         int i;
3012
3013         /* Set up our private data structure */
3014         nic->priv_data = &efab;
3015         memset ( &efab, 0, sizeof ( efab ) );
3016         memset ( &efab_buffers, 0, sizeof ( efab_buffers ) );
3017
3018         /* Hook in appropriate operations table.  Do this early. */
3019         if ( pci->dev_id == EF1002_DEVID ) {
3020                 efab.op = &ef1002_operations;
3021         } else {
3022                 efab.op = &falcon_operations;
3023         }
3024
3025         /* Initialise efab data structure */
3026         efab.pci = pci;
3027         buffers = ( ( struct efab_buffers * )
3028                     ( ( ( void * ) &efab_buffers ) +
3029                       ( - virt_to_bus ( &efab_buffers ) ) % EFAB_BUF_ALIGN ) );
3030         efab.eventq = buffers->eventq;
3031         efab.txd = buffers->txd;
3032         efab.rxd = buffers->rxd;
3033         efab.tx_buf.addr = buffers->tx_buf;
3034         for ( i = 0 ; i < EFAB_RX_BUFS ; i++ ) {
3035                 efab.rx_bufs[i].addr = buffers->rx_buf[i];
3036         }
3037
3038         /* Enable the PCI device */
3039         adjust_pci_device ( pci );
3040         nic->ioaddr = pci->ioaddr & ~3;
3041         nic->irqno = pci->irq;
3042
3043         /* Get iobase/membase */
3044         efab.iobase = nic->ioaddr;
3045         efab.op->get_membase ( &efab );
3046
3047         /* Switch NIC ports (i.e. try different ports on each probe) */
3048         nic_port = 1 - nic_port;
3049         efab.port = nic_port;
3050
3051         /* Initialise hardware */
3052         if ( ! efab_init_nic ( &efab ) )
3053                 return 0;
3054         memcpy ( nic->node_addr, efab.mac_addr, ETH_ALEN );
3055
3056         /* hello world */
3057         printf ( "Found EtherFabric %s NIC %!\n", pci->name, nic->node_addr );
3058
3059         /* point to NIC specific routines */
3060         dev->disable  = etherfabric_disable;
3061         nic->poll     = etherfabric_poll;
3062         nic->transmit = etherfabric_transmit;
3063         nic->irq      = etherfabric_irq;
3064
3065         return 1;
3066 }
3067
3068 static struct pci_id etherfabric_nics[] = {
3069 PCI_ROM(0x1924, 0xC101, "ef1002", "EtherFabric EF1002"),
3070 PCI_ROM(0x1924, 0x0703, "falcon", "EtherFabric Falcon"),
3071 };
3072
3073 static struct pci_driver etherfabric_driver __pci_driver = {
3074         .type     = NIC_DRIVER,
3075         .name     = "EFAB",
3076         .probe    = etherfabric_probe,
3077         .ids      = etherfabric_nics,
3078         .id_count = sizeof(etherfabric_nics)/sizeof(etherfabric_nics[0]),
3079         .class    = 0,
3080 };
3081
3082 /*
3083  * Local variables:
3084  *  c-basic-offset: 8
3085  *  c-indent-level: 8
3086  *  tab-width: 8
3087  * End:
3088  */