source: rtems/c/src/lib/libbsp/m68k/uC5282/network/network.c @ b6cfe2f6

4.104.114.84.95
Last change on this file since b6cfe2f6 was b6cfe2f6, checked in by Eric Norum <WENorum@…>, on 05/10/05 at 23:24:23

Poke RDAR/TDAR every time. Add more diagnostic printout.

  • Property mode set to 100644
File size: 27.7 KB
Line 
1/*
2 * RTEMS/TCPIP driver for MCF5282 Fast Ethernet Controller
3 *
4 * TO DO: Check network stack code -- Is it possible force longword alignment
5 *                                    of all tx mbufs?  If so, the stupid
6 *                                    realignment code in the output routine
7 *                                    could be removed.
8 */
9
10#include <bsp.h>
11#include <stdio.h>
12#include <errno.h>
13#include <stdarg.h>
14#include <string.h>
15#include <rtems.h>
16#include <rtems/error.h>
17#include <rtems/rtems_bsdnet.h>
18
19#include <sys/param.h>
20#include <sys/mbuf.h>
21#include <sys/socket.h>
22#include <sys/sockio.h>
23
24#include <net/ethernet.h>
25#include <net/if.h>
26
27#include <netinet/in.h>
28#include <netinet/if_ether.h>
29
30
31/*
32 * Number of interfaces supported by this driver
33 */
34#define NIFACES 1
35
36#define FEC_INTC0_TX_VECTOR (64+23)
37#define FEC_INTC0_RX_VECTOR (64+27)
38
39/*
40 * Default number of buffer descriptors set aside for this driver.
41 * The number of transmit buffer descriptors has to be quite large
42 * since a single frame often uses three or more buffer descriptors.
43 */
44#define RX_BUF_COUNT     32
45#define TX_BUF_COUNT     20
46#define TX_BD_PER_BUF    3
47
48#define INET_ADDR_MAX_BUF_SIZE (sizeof "255.255.255.255")
49
50/*
51 * RTEMS event used by interrupt handler to signal daemons.
52 * This must *not* be the same event used by the TCP/IP task synchronization.
53 */
54#define TX_INTERRUPT_EVENT RTEMS_EVENT_1
55#define RX_INTERRUPT_EVENT RTEMS_EVENT_1
56
57/*
58 * RTEMS event used to start transmit daemon.
59 * This must not be the same as INTERRUPT_EVENT.
60 */
61#define START_TRANSMIT_EVENT RTEMS_EVENT_2
62
63/*
64 * Receive buffer size -- Allow for a full ethernet packet plus CRC (1518).
65 * Round off to nearest multiple of RBUF_ALIGN.
66 */
67#define MAX_MTU_SIZE    1518
68#define RBUF_ALIGN      4
69#define RBUF_SIZE       ((MAX_MTU_SIZE + RBUF_ALIGN) & ~RBUF_ALIGN)
70
71#if (MCLBYTES < RBUF_SIZE)
72    #error "Driver must have MCLBYTES > RBUF_SIZE"
73#endif
74
75typedef struct mcf5282BufferDescriptor_ {
76    volatile uint16_t   status;
77    uint16_t                    length;
78    volatile void      *buffer;
79} mcf5282BufferDescriptor_t;
80
81/*
82 * Per-device data
83 */
84struct mcf5282_enet_struct {
85    struct arpcom               arpcom;
86    struct mbuf                 **rxMbuf;
87    struct mbuf                 **txMbuf;
88    int                         acceptBroadcast;
89    int                         rxBdCount;
90    int                         txBdCount;
91    int                         txBdHead;
92    int                         txBdTail;
93    int                         txBdActiveCount;
94    mcf5282BufferDescriptor_t  *rxBdBase;
95    mcf5282BufferDescriptor_t  *txBdBase;
96    rtems_id                    rxDaemonTid;
97    rtems_id                    txDaemonTid;
98
99    /*
100     * Statistics
101     */
102    unsigned long   rxInterrupts;
103    unsigned long   txInterrupts;
104    unsigned long   txRawWait;
105    unsigned long   txRealign;
106    unsigned long   txRealignBytes;
107};
108static struct mcf5282_enet_struct enet_driver[NIFACES];
109
110static rtems_isr
111mcf5282_fec_rx_interrupt_handler( rtems_vector_number v )
112{
113    MCF5282_FEC_EIR = MCF5282_FEC_EIR_RXF;
114    MCF5282_FEC_EIMR &= ~MCF5282_FEC_EIMR_RXF;   
115    enet_driver[0].rxInterrupts++;
116    rtems_event_send(enet_driver[0].rxDaemonTid, RX_INTERRUPT_EVENT);
117}
118
119static rtems_isr
120mcf5282_fec_tx_interrupt_handler( rtems_vector_number v )
121{
122    MCF5282_FEC_EIR = MCF5282_FEC_EIR_TXF;
123    MCF5282_FEC_EIMR &= ~MCF5282_FEC_EIMR_TXF;   
124    enet_driver[0].txInterrupts++;
125    rtems_event_send(enet_driver[0].txDaemonTid, TX_INTERRUPT_EVENT);
126}
127
128/*
129 * Allocate buffer descriptors from (non-cached) on-chip static RAM
130 * Ensure 128-bit (16-byte) alignment
131 */
132static mcf5282BufferDescriptor_t *
133mcf5282_bd_allocate(unsigned int count)
134{
135    extern char __SRAMBASE[];
136    static mcf5282BufferDescriptor_t *bdp = (mcf5282BufferDescriptor_t *)__SRAMBASE;
137    mcf5282BufferDescriptor_t *p = bdp;
138
139    bdp += count;
140    if ((int)bdp & 0xF)
141        bdp = (mcf5282BufferDescriptor_t *)((char *)bdp + (16 - ((int)bdp & 0xF)));
142    return p;
143}
144
145#if UNUSED
146/*
147 * Read MII register
148 * Busy-waits, but transfer time should be short!
149 */
150static int
151getMII(int phyNumber, int regNumber)
152{
153    MCF5282_FEC_MMFR = (0x1 << 30)       |
154                       (0x2 << 28)       |
155                       (phyNumber << 23) |
156                       (regNumber << 18) |
157                       (0x2 << 16);
158    while ((MCF5282_FEC_EIR & MCF5282_FEC_EIR_MII) == 0);
159    MCF5282_FEC_EIR = MCF5282_FEC_EIR_MII;
160    return MCF5282_FEC_MMFR & 0xFFFF;
161}
162#endif
163
164/*
165 * Write MII register
166 * Busy-waits, but transfer time should be short!
167 */
168static void
169setMII(int phyNumber, int regNumber, int value)
170{
171    MCF5282_FEC_MMFR = (0x1 << 30)       |
172                       (0x1 << 28)       |
173                       (phyNumber << 23) |
174                       (regNumber << 18) |
175                       (0x2 << 16)       |
176                       (value & 0xFFFF);
177    while ((MCF5282_FEC_EIR & MCF5282_FEC_EIR_MII) == 0);
178    MCF5282_FEC_EIR = MCF5282_FEC_EIR_MII;
179}
180
181static void
182mcf5282_fec_initialize_hardware(struct mcf5282_enet_struct *sc)
183{
184    int i;
185    const unsigned char *hwaddr;
186    rtems_status_code status;
187    rtems_isr_entry old_handler;
188        uint32_t clock_speed = bsp_get_CPU_clock_speed();
189
190    /*
191     * Issue reset to FEC
192     */
193    MCF5282_FEC_ECR = MCF5282_FEC_ECR_RESET;
194    rtems_task_wake_after(1);
195    MCF5282_FEC_ECR = 0;
196
197    /*
198     * Configuration of I/O ports is done outside of this function
199     */
200#if 0
201    imm->gpio.pbcnt |= MCF5282_GPIO_PBCNT_SET_FEC;        /* Set up port b FEC pins */
202#endif
203
204    /*
205     * Set our physical address
206     */
207    hwaddr = sc->arpcom.ac_enaddr;
208    MCF5282_FEC_PALR = (hwaddr[0] << 24) | (hwaddr[1] << 16) |
209                       (hwaddr[2] << 8)  | (hwaddr[3] << 0);
210    MCF5282_FEC_PAUR = (hwaddr[4] << 24) | (hwaddr[5] << 16);
211
212
213    /*
214     * Clear the hash table
215     */
216    MCF5282_FEC_GAUR = 0;
217    MCF5282_FEC_GALR = 0;
218
219    /*
220     * Set up receive buffer size
221     */
222    MCF5282_FEC_EMRBR = 1520; /* Standard Ethernet */
223
224    /*
225     * Allocate mbuf pointers
226     */
227    sc->rxMbuf = malloc(sc->rxBdCount * sizeof *sc->rxMbuf, M_MBUF, M_NOWAIT);
228    sc->txMbuf = malloc(sc->txBdCount * sizeof *sc->txMbuf, M_MBUF, M_NOWAIT);
229    if (!sc->rxMbuf || !sc->txMbuf)
230        rtems_panic("No memory for mbuf pointers");
231
232    /*
233     * Set receiver and transmitter buffer descriptor bases
234     */
235    sc->rxBdBase = mcf5282_bd_allocate(sc->rxBdCount);
236    sc->txBdBase = mcf5282_bd_allocate(sc->txBdCount);
237    MCF5282_FEC_ERDSR = (int)sc->rxBdBase;
238    MCF5282_FEC_ETDSR = (int)sc->txBdBase;
239
240    /*
241     * Set up Receive Control Register:
242     *   Not promiscuous
243     *   MII mode
244     *   Full duplex
245     *   No loopback
246     */
247    MCF5282_FEC_RCR = MCF5282_FEC_RCR_MAX_FL(MAX_MTU_SIZE) |
248                      MCF5282_FEC_RCR_MII_MODE;
249
250    /*
251     * Set up Transmit Control Register:
252     *   Full duplex
253     *   No heartbeat
254     */
255    MCF5282_FEC_TCR = MCF5282_FEC_TCR_FDEN;
256
257    /*
258     * Initialize statistic counters
259     */
260    MCF5282_FEC_MIBC = MCF5282_FEC_MIBC_MIB_DISABLE;
261    {
262    vuint32 *vuip = &MCF5282_FEC_RMON_T_DROP;
263    while (vuip <= &MCF5282_FEC_IEEE_R_OCTETS_OK)
264        *vuip++ = 0;
265    }
266    MCF5282_FEC_MIBC = 0;
267
268    /*
269     * Set MII speed to <= 2.5 MHz
270     */
271    i = (clock_speed + 5000000 - 1) / 5000000;
272    MCF5282_FEC_MSCR = MCF5282_FEC_MSCR_MII_SPEED(i);
273
274    /*
275     * Set PHYS to 100 Mb/s, full duplex
276     */
277    setMII(1, 0, 0x2100);
278
279    /*
280     * Set up receive buffer descriptors
281     */
282    for (i = 0 ; i < sc->rxBdCount ; i++)
283        (sc->rxBdBase + i)->status = 0;
284
285    /*
286     * Set up transmit buffer descriptors
287     */
288    for (i = 0 ; i < sc->txBdCount ; i++) {
289        sc->txBdBase[i].status = 0;
290        sc->txMbuf[i] = NULL;
291    }
292    sc->txBdHead = sc->txBdTail = 0;
293    sc->txBdActiveCount = 0;
294
295    /*
296     * Set up interrupts
297     */
298    status = rtems_interrupt_catch( mcf5282_fec_tx_interrupt_handler, FEC_INTC0_TX_VECTOR, &old_handler );
299    if (status != RTEMS_SUCCESSFUL)
300        rtems_panic ("Can't attach MCF5282 FEC TX interrupt handler: %s\n",
301                     rtems_status_text(status));
302    status = rtems_interrupt_catch(mcf5282_fec_rx_interrupt_handler, FEC_INTC0_RX_VECTOR, &old_handler);
303    if (status != RTEMS_SUCCESSFUL)
304        rtems_panic ("Can't attach MCF5282 FEC RX interrupt handler: %s\n",
305                     rtems_status_text(status));
306    bsp_allocate_interrupt(FEC_IRQ_LEVEL, FEC_IRQ_TX_PRIORITY);
307    MCF5282_INTC0_ICR23 = MCF5282_INTC_ICR_IL(FEC_IRQ_LEVEL) |
308                          MCF5282_INTC_ICR_IP(FEC_IRQ_TX_PRIORITY);
309    MCF5282_INTC0_IMRL &= ~(MCF5282_INTC_IMRL_INT23 | MCF5282_INTC_IMRL_MASKALL);
310    bsp_allocate_interrupt(FEC_IRQ_LEVEL, FEC_IRQ_RX_PRIORITY);
311    MCF5282_INTC0_ICR27 = MCF5282_INTC_ICR_IL(FEC_IRQ_LEVEL) |
312                          MCF5282_INTC_ICR_IP(FEC_IRQ_RX_PRIORITY);
313    MCF5282_INTC0_IMRL &= ~(MCF5282_INTC_IMRL_INT27 | MCF5282_INTC_IMRL_MASKALL);
314}
315
316/*
317 * Soak up buffer descriptors that have been sent.
318 */
319static void
320fec_retire_tx_bd(volatile struct mcf5282_enet_struct *sc )
321{
322    struct mbuf *m, *n;
323
324    while ((sc->txBdActiveCount != 0)
325        && ((sc->txBdBase[sc->txBdTail].status & MCF5282_FEC_TxBD_R) == 0)) {
326        m = sc->txMbuf[sc->txBdTail];
327        MFREE(m, n);
328        if (++sc->txBdTail == sc->txBdCount)
329            sc->txBdTail = 0;
330        sc->txBdActiveCount--;
331    }
332}
333
334static void
335fec_rxDaemon (void *arg)
336{
337    volatile struct mcf5282_enet_struct *sc = (volatile struct mcf5282_enet_struct *)arg;
338    struct ifnet *ifp = (struct ifnet* )&sc->arpcom.ac_if;
339    struct mbuf *m;
340    volatile uint16_t status;
341    volatile mcf5282BufferDescriptor_t *rxBd;
342    int rxBdIndex;
343
344    /*
345     * Allocate space for incoming packets and start reception
346     */
347    for (rxBdIndex = 0 ; ;) {
348        rxBd = sc->rxBdBase + rxBdIndex;
349        MGETHDR(m, M_WAIT, MT_DATA);
350        MCLGET(m, M_WAIT);
351        m->m_pkthdr.rcvif = ifp;
352        sc->rxMbuf[rxBdIndex] = m;
353        rxBd->buffer = mtod(m, void *);
354        rxBd->status = MCF5282_FEC_RxBD_E;
355        if (++rxBdIndex == sc->rxBdCount) {
356            rxBd->status |= MCF5282_FEC_RxBD_W;
357            break;
358        }
359    }
360
361    /*
362     * Input packet handling loop
363     */
364    MCF5282_FEC_RDAR = 0;
365
366    rxBdIndex = 0;
367    for (;;) {
368        rxBd = sc->rxBdBase + rxBdIndex;
369
370        /*
371         * Wait for packet if there's not one ready
372         */
373        if ((status = rxBd->status) & MCF5282_FEC_RxBD_E) {
374            /*
375             * Clear old events.
376             */
377            MCF5282_FEC_EIR = MCF5282_FEC_EIR_RXF;
378
379            /*
380             * Wait for packet to arrive.
381             * Check the buffer descriptor before waiting for the event.
382             * This catches the case when a packet arrives between the
383             * `if' above, and the clearing of the RXF bit in the EIR.
384             */
385            while ((status = rxBd->status) & MCF5282_FEC_RxBD_E) {
386                rtems_event_set events;
387                int level;
388
389                rtems_interrupt_disable(level);
390                MCF5282_FEC_EIMR |= MCF5282_FEC_EIMR_RXF;
391                rtems_interrupt_enable(level);
392                rtems_bsdnet_event_receive (RX_INTERRUPT_EVENT,
393                                            RTEMS_WAIT|RTEMS_EVENT_ANY,
394                                            RTEMS_NO_TIMEOUT,
395                                            &events);
396            }
397        }
398
399        /*
400         * Check that packet is valid
401         */
402        if (status & MCF5282_FEC_RxBD_L) {
403            /*
404             * Pass the packet up the chain.
405             * FIXME: Packet filtering hook could be done here.
406             */
407            struct ether_header *eh;
408            int len = rxBd->length - sizeof(uint32_t);;
409
410            m = sc->rxMbuf[rxBdIndex];
411#ifdef RTEMS_MCF5282_BSP_ENABLE_DATA_CACHE
412            /*
413             * Invalidate the cache.  The cache is so small that it's
414             * more efficient to just invalidate the whole thing unless
415             * the packet is very small.
416             */
417            if (len < 128)
418                rtems_cache_invalidate_multiple_data_lines(m->m_data, len);
419            else
420                rtems_cache_invalidate_entire_data();
421#endif
422            m->m_len = m->m_pkthdr.len = len - sizeof(struct ether_header);
423            eh = mtod(m, struct ether_header *);
424            m->m_data += sizeof(struct ether_header);
425            ether_input(ifp, eh, m);
426
427            /*
428             * Allocate a new mbuf
429             */
430            MGETHDR(m, M_WAIT, MT_DATA);
431            MCLGET(m, M_WAIT);
432            m->m_pkthdr.rcvif = ifp;
433            sc->rxMbuf[rxBdIndex] = m;
434            rxBd->buffer = mtod(m, void *);
435        }
436
437        /*
438         * Reenable the buffer descriptor
439         */
440        rxBd->status = (status & MCF5282_FEC_RxBD_W) | MCF5282_FEC_RxBD_E;
441        MCF5282_FEC_RDAR = 0;
442
443        /*
444         * Move to next buffer descriptor
445         */
446        if (++rxBdIndex == sc->rxBdCount)
447            rxBdIndex = 0;
448    }
449}
450
451static void
452fec_sendpacket(struct ifnet *ifp, struct mbuf *m)
453{
454    struct mcf5282_enet_struct *sc = ifp->if_softc;
455    volatile mcf5282BufferDescriptor_t *firstTxBd, *txBd;
456    uint16_t status;
457    int nAdded;
458
459   /*
460     * Free up buffer descriptors
461     */
462    fec_retire_tx_bd(sc);
463
464    /*
465     * Set up the transmit buffer descriptors.
466     * No need to pad out short packets since the
467     * hardware takes care of that automatically.
468     * No need to copy the packet to a contiguous buffer
469     * since the hardware is capable of scatter/gather DMA.
470     */
471    nAdded = 0;
472    firstTxBd = sc->txBdBase + sc->txBdHead;
473   
474    for (;;) {
475        /*
476         * Wait for buffer descriptor to become available
477         */
478        if ((sc->txBdActiveCount + nAdded)  == sc->txBdCount) {
479            /*
480             * Clear old events.
481             */
482            MCF5282_FEC_EIR = MCF5282_FEC_EIR_TXF;
483
484            /*
485             * Wait for buffer descriptor to become available.
486             * Check for buffer descriptors before waiting for the event.
487             * This catches the case when a buffer became available between
488             * the `if' above, and the clearing of the TXF bit in the EIR.
489             */
490            fec_retire_tx_bd(sc);
491            while ((sc->txBdActiveCount + nAdded) == sc->txBdCount) {
492                rtems_event_set events;
493                int level;
494
495                rtems_interrupt_disable(level);
496                MCF5282_FEC_EIMR |= MCF5282_FEC_EIMR_TXF;   
497                rtems_interrupt_enable(level);
498                sc->txRawWait++;
499                rtems_bsdnet_event_receive(TX_INTERRUPT_EVENT,
500                                           RTEMS_WAIT|RTEMS_EVENT_ANY,
501                                           RTEMS_NO_TIMEOUT,
502                                           &events);
503                fec_retire_tx_bd(sc);
504            }
505        }
506   
507        /*
508         * Don't set the READY flag on the first fragment
509         * until the whole packet has been readied.
510         */
511        status = nAdded ? MCF5282_FEC_TxBD_R : 0;
512   
513        /*
514         * The IP fragmentation routine in ip_output
515         * can produce fragments with zero length.
516         */
517        txBd = sc->txBdBase + sc->txBdHead;
518        if (m->m_len) {
519            char *p = mtod(m, char *);
520            /*
521             * Stupid FEC can't handle misaligned data!
522             * Given the way that mbuf's are layed out it should be
523             * safe to shuffle the data down like this.....
524             * Perhaps this code could be improved with a "Duff's Device".
525             */
526            if ((int)p & 0x3) {
527                int l = m->m_len;
528                char *dest = p - ((int)p & 0x3);
529                uint16_t *o = (uint16_t *)dest, *i = (uint16_t *)p;
530                while (l > 0) {
531                    *o++ = *i++;
532                    l -= sizeof(uint16_t);
533                }
534                p = dest;
535                sc->txRealign++;
536                sc->txRealignBytes += m->m_len;
537            }
538            txBd->buffer = p;
539            txBd->length = m->m_len;
540            sc->txMbuf[sc->txBdHead] = m;
541            nAdded++;
542            if (++sc->txBdHead == sc->txBdCount) {
543                status |= MCF5282_FEC_TxBD_W;
544                sc->txBdHead = 0;
545            }
546            m = m->m_next;
547        }
548        else {
549            /*
550             * Just toss empty mbufs
551             */
552            struct mbuf *n;
553            MFREE(m, n);
554            m = n;
555        }
556        if (m == NULL) {
557          if (nAdded) {
558            txBd->status = status | MCF5282_FEC_TxBD_R
559                                  | MCF5282_FEC_TxBD_L
560                                  | MCF5282_FEC_TxBD_TC;
561            if (nAdded > 1)
562                firstTxBd->status |= MCF5282_FEC_TxBD_R;
563            MCF5282_FEC_TDAR = 0;
564            sc->txBdActiveCount += nAdded;
565          }
566          break;
567        }
568        txBd->status = status;
569    }
570}
571
572void
573fec_txDaemon(void *arg)
574{
575    struct mcf5282_enet_struct *sc = (struct mcf5282_enet_struct *)arg;
576    struct ifnet *ifp = &sc->arpcom.ac_if;
577    struct mbuf *m;
578    rtems_event_set events;
579
580    for (;;) {
581        /*
582         * Wait for packet
583         */
584        rtems_bsdnet_event_receive(START_TRANSMIT_EVENT,
585                                    RTEMS_EVENT_ANY | RTEMS_WAIT,
586                                    RTEMS_NO_TIMEOUT,
587                                    &events);
588
589        /*
590         * Send packets till queue is empty
591         */
592        for (;;) {
593            /*
594             * Get the next mbuf chain to transmit.
595             */
596            IF_DEQUEUE(&ifp->if_snd, m);
597            if (!m)
598                break;
599            fec_sendpacket(ifp, m);
600        }
601        ifp->if_flags &= ~IFF_OACTIVE;
602    }
603}
604
605
606/*
607 * Send packet (caller provides header).
608 */
609static void
610mcf5282_enet_start(struct ifnet *ifp)
611{
612    struct mcf5282_enet_struct *sc = ifp->if_softc;
613
614    rtems_event_send(sc->txDaemonTid, START_TRANSMIT_EVENT);
615    ifp->if_flags |= IFF_OACTIVE;
616}
617
618static void
619fec_init(void *arg)
620{
621    struct mcf5282_enet_struct *sc = arg;
622    struct ifnet *ifp = &sc->arpcom.ac_if;
623
624    if (sc->txDaemonTid == 0) {
625        /*
626         * Set up hardware
627         */
628        mcf5282_fec_initialize_hardware(sc);
629
630        /*
631         * Start driver tasks
632         */
633        sc->txDaemonTid = rtems_bsdnet_newproc("FECtx", 4096, fec_txDaemon, sc);
634        sc->rxDaemonTid = rtems_bsdnet_newproc("FECrx", 4096, fec_rxDaemon, sc);
635    }
636
637    /*
638     * Set flags appropriately
639     */
640    if (ifp->if_flags & IFF_PROMISC)
641        MCF5282_FEC_RCR |= MCF5282_FEC_RCR_PROM;
642    else
643        MCF5282_FEC_RCR &= ~MCF5282_FEC_RCR_PROM;
644
645    /*
646     * Tell the world that we're running.
647     */
648    ifp->if_flags |= IFF_RUNNING;
649
650    /*
651     * Enable receiver and transmitter
652     */
653    MCF5282_FEC_ECR = MCF5282_FEC_ECR_ETHER_EN;
654}
655
656
657static void
658fec_stop(struct mcf5282_enet_struct *sc)
659{
660    struct ifnet *ifp = &sc->arpcom.ac_if;
661
662    ifp->if_flags &= ~IFF_RUNNING;
663
664    /*
665     * Shut down receiver and transmitter
666     */
667    MCF5282_FEC_ECR = 0x0;
668}
669
670/*
671 * Show interface statistics
672 */
673static void
674enet_stats(struct mcf5282_enet_struct *sc)
675{
676    printf("  Rx Interrupts:%-10lu",   sc->rxInterrupts);
677    printf("Rx Packet Count:%-10lu",   MCF5282_FEC_RMON_R_PACKETS);
678    printf("   Rx Broadcast:%-10lu\n", MCF5282_FEC_RMON_R_BC_PKT);
679    printf("   Rx Multicast:%-10lu",   MCF5282_FEC_RMON_R_MC_PKT);
680    printf("CRC/Align error:%-10lu",   MCF5282_FEC_RMON_R_CRC_ALIGN);
681    printf("   Rx Undersize:%-10lu\n", MCF5282_FEC_RMON_R_UNDERSIZE);
682    printf("    Rx Oversize:%-10lu",   MCF5282_FEC_RMON_R_OVERSIZE);
683    printf("    Rx Fragment:%-10lu",   MCF5282_FEC_RMON_R_FRAG);
684    printf("      Rx Jabber:%-10lu\n", MCF5282_FEC_RMON_R_JAB);
685    printf("          Rx 64:%-10lu",   MCF5282_FEC_RMON_R_P64);
686    printf("      Rx 65-127:%-10lu",   MCF5282_FEC_RMON_R_P65T0127);
687    printf("     Rx 128-255:%-10lu\n", MCF5282_FEC_RMON_R_P128TO255);
688    printf("     Rx 256-511:%-10lu",   MCF5282_FEC_RMON_R_P256TO511);
689    printf("    Rx 511-1023:%-10lu",   MCF5282_FEC_RMON_R_P512TO1023);
690    printf("   Rx 1024-2047:%-10lu\n", MCF5282_FEC_RMON_R_P1024TO2047);
691    printf("      Rx >=2048:%-10lu",   MCF5282_FEC_RMON_R_GTE2048);
692    printf("      Rx Octets:%-10lu",   MCF5282_FEC_RMON_R_OCTETS);
693    printf("     Rx Dropped:%-10lu\n", MCF5282_FEC_IEEE_R_DROP);
694    printf("    Rx frame OK:%-10lu",   MCF5282_FEC_IEEE_R_FRAME_OK);
695    printf("   Rx CRC error:%-10lu",   MCF5282_FEC_IEEE_R_CRC);
696    printf(" Rx Align error:%-10lu\n", MCF5282_FEC_IEEE_R_ALIGN);
697    printf("  FIFO Overflow:%-10lu",   MCF5282_FEC_IEEE_R_MACERR);
698    printf("Rx Pause Frames:%-10lu",   MCF5282_FEC_IEEE_R_FDXFC);
699    printf("   Rx Octets OK:%-10lu\n", MCF5282_FEC_IEEE_R_OCTETS_OK);
700    printf("  Tx Interrupts:%-10lu",   sc->txInterrupts);
701    printf("Tx Output Waits:%-10lu",   sc->txRawWait);
702    printf("Tx Realignments:%-10lu\n",   sc->txRealign);
703    printf(" Tx RealignByte:%-10lu", sc->txRealignBytes);
704    printf(" Tx Unaccounted:%-10lu", MCF5282_FEC_RMON_T_DROP);
705    printf("Tx Packet Count:%-10lu\n",   MCF5282_FEC_RMON_T_PACKETS);
706    printf("   Tx Broadcast:%-10lu",   MCF5282_FEC_RMON_T_BC_PKT);
707    printf("   Tx Multicast:%-10lu", MCF5282_FEC_RMON_T_MC_PKT);
708    printf("CRC/Align error:%-10lu\n",   MCF5282_FEC_RMON_T_CRC_ALIGN);
709    printf("   Tx Undersize:%-10lu",   MCF5282_FEC_RMON_T_UNDERSIZE);
710    printf("    Tx Oversize:%-10lu", MCF5282_FEC_RMON_T_OVERSIZE);
711    printf("    Tx Fragment:%-10lu\n",   MCF5282_FEC_RMON_T_FRAG);
712    printf("      Tx Jabber:%-10lu",   MCF5282_FEC_RMON_T_JAB);
713    printf("  Tx Collisions:%-10lu", MCF5282_FEC_RMON_T_COL);
714    printf("          Tx 64:%-10lu\n",   MCF5282_FEC_RMON_T_P64);
715    printf("      Tx 65-127:%-10lu",   MCF5282_FEC_RMON_T_P65TO127);
716    printf("     Tx 128-255:%-10lu", MCF5282_FEC_RMON_T_P128TO255);
717    printf("     Tx 256-511:%-10lu\n",   MCF5282_FEC_RMON_T_P256TO511);
718    printf("    Tx 511-1023:%-10lu",   MCF5282_FEC_RMON_T_P512TO1023);
719    printf("   Tx 1024-2047:%-10lu", MCF5282_FEC_RMON_T_P1024TO2047);
720    printf("      Tx >=2048:%-10lu\n",   MCF5282_FEC_RMON_T_P_GTE2048);
721    printf("      Tx Octets:%-10lu",   MCF5282_FEC_RMON_T_OCTETS);
722    printf("     Tx Dropped:%-10lu", MCF5282_FEC_IEEE_T_DROP);
723    printf("    Tx Frame OK:%-10lu\n",   MCF5282_FEC_IEEE_T_FRAME_OK);
724    printf(" Tx 1 Collision:%-10lu",   MCF5282_FEC_IEEE_T_1COL);
725    printf("Tx >1 Collision:%-10lu", MCF5282_FEC_IEEE_T_MCOL);
726    printf("    Tx Deferred:%-10lu\n",   MCF5282_FEC_IEEE_T_DEF);
727    printf(" Late Collision:%-10lu",   MCF5282_FEC_IEEE_T_LCOL);
728    printf(" Excessive Coll:%-10lu", MCF5282_FEC_IEEE_T_EXCOL);
729    printf("  FIFO Underrun:%-10lu\n",   MCF5282_FEC_IEEE_T_MACERR);
730    printf("  Carrier Error:%-10lu",   MCF5282_FEC_IEEE_T_CSERR);
731    printf("   Tx SQE Error:%-10lu", MCF5282_FEC_IEEE_T_SQE);
732    printf("Tx Pause Frames:%-10lu\n",   MCF5282_FEC_IEEE_T_FDXFC);
733    printf("   Tx Octets OK:%-10lu\n", MCF5282_FEC_IEEE_T_OCTETS_OK);
734    printf(" EIR:%8.8lx  ",  MCF5282_FEC_EIR);
735    printf("EIMR:%8.8lx  ",  MCF5282_FEC_EIMR);
736    printf("RDAR:%8.8lx  ",  MCF5282_FEC_RDAR);
737    printf("TDAR:%8.8lx\n",  MCF5282_FEC_TDAR);
738    printf(" ECR:%8.8lx  ",  MCF5282_FEC_ECR);
739    printf(" RCR:%8.8lx  ",  MCF5282_FEC_RCR);
740    printf(" TCR:%8.8lx\n",  MCF5282_FEC_TCR);
741    printf("FRBR:%8.8lx  ",  MCF5282_FEC_FRBR);
742    printf("FRSR:%8.8lx\n",  MCF5282_FEC_FRSR);
743    if (sc->txBdActiveCount != 0) {
744        int i, n;
745        /*
746         * Yes, there are races here with adding and retiring descriptors,
747         * but this diagnostic is more for when things have backed up.
748         */
749        printf("Transmit Buffer Descriptors (Tail %d, Head %d, Active %d):\n",
750                                                    sc->txBdTail,
751                                                    sc->txBdHead,
752                                                    sc->txBdActiveCount);
753        i = sc->txBdTail;
754        for (n = 0 ; n < sc->txBdCount ; n++) {
755            if ((sc->txBdBase[i].status & MCF5282_FEC_TxBD_R) != 0)
756                printf("  %3d: status:%4.4x  length:%-4d  buffer:%p\n",
757                                                    i,
758                                                    sc->txBdBase[i].status,
759                                                    sc->txBdBase[i].length,
760                                                    sc->txBdBase[i].buffer);
761            if (++i == sc->txBdCount)
762                i = 0;
763        }
764    }
765}
766
767static int
768fec_ioctl(struct ifnet *ifp, int command, caddr_t data)
769{
770    struct mcf5282_enet_struct *sc = ifp->if_softc;
771    int error = 0;
772
773    switch (command) {
774        case SIOCGIFADDR:
775        case SIOCSIFADDR:
776            ether_ioctl(ifp, command, data);
777            break;
778
779        case SIOCSIFFLAGS:
780            switch (ifp->if_flags & (IFF_UP | IFF_RUNNING)) {
781                case IFF_RUNNING:
782                    fec_stop(sc);
783                    break;
784
785                case IFF_UP:
786                    fec_init(sc);
787                    break;
788
789                case IFF_UP | IFF_RUNNING:
790                    fec_stop(sc);
791                    fec_init(sc);
792                    break;
793
794                default:
795                    break;
796            }
797            break;
798
799        case SIO_RTEMS_SHOW_STATS:
800            enet_stats(sc);
801            break;
802
803            /*
804             * FIXME: All sorts of multicast commands need to be added here!
805             */
806        default:
807            error = EINVAL;
808            break;
809    }
810    return error;
811}
812
813int
814rtems_fec_driver_attach(struct rtems_bsdnet_ifconfig *config, int attaching )
815{
816    struct mcf5282_enet_struct *sc;
817    struct ifnet *ifp;
818    int mtu;
819    int unitNumber;
820    char *unitName;
821    unsigned char *hwaddr;
822
823    /*
824     * Parse driver name
825     */
826    if ((unitNumber = rtems_bsdnet_parse_driver_name (config, &unitName)) < 0)
827        return 0;
828
829    /*
830     * Is driver free?
831     */
832    if ((unitNumber <= 0) || (unitNumber > NIFACES)) {
833        printf("Bad FEC unit number.\n");
834        return 0;
835    }
836    sc = &enet_driver[unitNumber - 1];
837    ifp = &sc->arpcom.ac_if;
838    if (ifp->if_softc != NULL) {
839        printf("Driver already in use.\n");
840        return 0;
841    }
842
843    /*
844     * Process options
845     */
846    if (config->hardware_address) {
847        hwaddr = config->hardware_address;
848    } else if ((hwaddr = bsp_gethwaddr(unitNumber - 1)) == NULL) {
849        /* Locally-administered address */
850        static const unsigned char defaultAddress[ETHER_ADDR_LEN] = {
851                                        0x06, 'R', 'T', 'E', 'M', 'S'};
852        printf ("WARNING -- No %s%d Ethernet address specified "
853                "-- Using default address.\n", unitName, unitNumber);
854        hwaddr = defaultAddress;
855    }
856    printf("%s%d: Ethernet address: %02x:%02x:%02x:%02x:%02x:%02x\n",
857                                            unitName, unitNumber,
858                                            hwaddr[0], hwaddr[1], hwaddr[2],
859                                            hwaddr[3], hwaddr[4], hwaddr[5]);
860    memcpy(sc->arpcom.ac_enaddr, hwaddr, ETHER_ADDR_LEN);
861
862    if (config->mtu)
863        mtu = config->mtu;
864    else
865        mtu = ETHERMTU;
866    if (config->rbuf_count)
867        sc->rxBdCount = config->rbuf_count;
868    else
869        sc->rxBdCount = RX_BUF_COUNT;
870    if (config->xbuf_count)
871        sc->txBdCount = config->xbuf_count;
872    else
873        sc->txBdCount = TX_BUF_COUNT * TX_BD_PER_BUF;
874
875    sc->acceptBroadcast = !config->ignore_broadcast;
876
877    /*
878     * Set up network interface values
879     */
880    ifp->if_softc = sc;
881    ifp->if_unit = unitNumber;
882    ifp->if_name = unitName;
883    ifp->if_mtu = mtu;
884    ifp->if_init = fec_init;
885    ifp->if_ioctl = fec_ioctl;
886    ifp->if_start = mcf5282_enet_start;
887    ifp->if_output = ether_output;
888    ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX;
889    if (ifp->if_snd.ifq_maxlen == 0)
890        ifp->if_snd.ifq_maxlen = ifqmaxlen;
891
892    /*
893     * Attach the interface
894     */
895    if_attach(ifp);
896    ether_ifattach(ifp);
897    return 1;
898};
899
Note: See TracBrowser for help on using the repository browser.