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

4.104.114.84.95
Last change on this file since 81291a0 was 81291a0, checked in by Eric Norum <WENorum@…>, on 06/29/05 at 20:09:14

Add duplex negotation support.

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