source: rtems/c/src/lib/libbsp/m68k/mcf5235/network/network.c @ 721fe34

4.11
Last change on this file since 721fe34 was 721fe34, checked in by Joel Sherrill <joel.sherrill@…>, on May 31, 2012 at 8:34:36 PM

Fix C files which had two semi-colons at EOL

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