Changeset f6fdf2e in rtems


Ignore:
Timestamp:
Jul 25, 2016, 1:11:07 PM (3 years ago)
Author:
Alexander Krutwig <alexander.krutwig@…>
Branches:
master
Children:
39d97ab
Parents:
c51e6d91
git-author:
Alexander Krutwig <alexander.krutwig@…> (07/25/16 13:11:07)
git-committer:
Sebastian Huber <sebastian.huber@…> (07/26/16 12:18:19)
Message:

atsam: Add user defined RX/TX descriptor counts

File:
1 edited

Legend:

Unmodified
Added
Removed
  • c/src/lib/libbsp/arm/atsam/network/if_atsam.c

    rc51e6d91 rf6fdf2e  
    102102
    103103/** RX Defines */
    104 #define GMAC_RX_BD_COUNT                        8
    105104#define GMAC_RX_BUFFER_SIZE                     1536
    106105#define GMAC_RX_BUF_DESC_ADDR_MASK              0xFFFFFFFC
     
    110109#define GMAC_RX_SET_USED                        (1u << 0)
    111110/** TX Defines */
    112 #define GMAC_TX_BD_COUNT                        128
    113111#define GMAC_TX_SET_EOF                         (1u << 15)
    114112#define GMAC_TX_SET_WRAP                        (1u << 30)
     
    118116
    119117/** Events */
    120 #define ATSAMV7_ETH_EVENT_INTERRUPT             RTEMS_EVENT_1
    121 #define ATSAMV7_ETH_START_TRANSMIT_EVENT        RTEMS_EVENT_2
     118#define ATSAMV7_ETH_RX_EVENT_INTERRUPT          RTEMS_EVENT_1
     119#define ATSAMV7_ETH_TX_EVENT_INTERRUPT          RTEMS_EVENT_2
     120#define ATSAMV7_ETH_START_TRANSMIT_EVENT        RTEMS_EVENT_3
    122121
    123122#define ATSAMV7_ETH_RX_DATA_OFFSET              2
     
    136135        uint8_t phy_address;
    137136} if_atsam_gmac;
     137
     138typedef struct ring_buffer {
     139        unsigned tx_bd_used;
     140        unsigned tx_bd_free;
     141        size_t length;
     142} ring_buffer;
    138143
    139144/*
     
    153158        struct mbuf **rx_mbuf;
    154159        struct mbuf **tx_mbuf;
    155         unsigned tx_bd_remove;
    156         unsigned tx_bd_insert;
    157160        volatile sGmacTxDescriptor *tx_bd_base;
    158161        uint32_t anlpar;
    159162        size_t rx_bd_fill_idx;
     163        size_t amount_rx_buf;
     164        size_t amount_tx_buf;
     165        ring_buffer tx_ring;
    160166
    161167        /*
     
    164170        unsigned rx_overrun_errors;
    165171        unsigned rx_interrupts;
     172        unsigned tx_complete_int;
    166173        unsigned tx_tur_errors;
    167174        unsigned tx_rlex_errors;
     
    183190                        m->m_pkthdr.rcvif = ifp;
    184191                        m->m_data = mtod(m, char *);
     192                        rtems_cache_invalidate_multiple_data_lines(mtod(m, void *),
     193                            GMAC_RX_BUFFER_SIZE);
    185194                } else {
    186195                        m_free(m);
    187196                        m = NULL;
    188197                }
    189 
    190                 rtems_cache_invalidate_multiple_data_lines(mtod(m, void *),
    191                     GMAC_RX_BUFFER_SIZE);
    192198        }
    193199        return (m);
     
    220226{
    221227        GMAC_PHYMaintain(pHw, PhyAddress, Address, 0, (uint16_t)Value);
    222         TRACE_DEBUG(" Write Access\n\r");
    223228        if (if_atsam_wait_phy(pHw, retry) == 1) {
    224                 TRACE_ERROR("TimeOut WritePhy\n\r");
    225229                return (1);
    226230        }
     
    233237    uint8_t PhyAddress, uint8_t Address, uint32_t *pvalue, uint32_t retry)
    234238{
    235         TRACE_DEBUG(" Read Access\n\r");
    236239        GMAC_PHYMaintain(pHw, PhyAddress, Address, 1, 0);
    237240        if (if_atsam_wait_phy(pHw, retry) == 1) {
    238                 TRACE_ERROR("TimeOut ReadPhy\n\r");
    239241                return (1);
    240242        }
     
    253255        uint8_t phy_address;
    254256
    255         TRACE_DEBUG("GMACB_FindValidPhy\n\r");
    256 
    257257        phy_address = gmac_inst->phy_address;
    258258        retry_max = gmac_inst->retries;
     
    271271                    &value, retry_max);
    272272                if (rv == 0 && value != 0 && value >= 0xffff) {
    273                         TRACE_DEBUG("_PHYID1  : 0x%X, addr: %d\n\r", value,
    274                             phy_address);
    275273                        rc = phy_address;
    276274                        break;
    277                 } else {
    278                         TRACE_ERROR("MACB PROBLEM\n\r");
    279275                }
    280276        }
    281277
    282278        if (rc != 0xFF) {
    283                 TRACE_DEBUG("** Valid PHY Found: %d\n\r", rc);
    284279                if_atsam_read_phy(pHw, phy_address, MII_PHYIDR1, &value,
    285280                    retry_max);
    286                 TRACE_DEBUG("_PHYID1R  : 0x%X, addr: %d\n\r", value,
    287                     phy_address);
    288281                if_atsam_read_phy(pHw, phy_address, MII_PHYIDR2, &value,
    289282                    retry_max);
    290                 TRACE_DEBUG("_EMSR  : 0x%X, addr: %d\n\r", value, phy_address);
    291283                gmac_inst->phy_address = phy_address;
    292284        }
     
    303295
    304296        Gmac *pHw = gmac_inst->gGmacd.pHw;
    305 
    306         TRACE_DEBUG(" GMACB_ResetPhy\n\r");
    307297
    308298        phy_address = gmac_inst->phy_address;
     
    333323
    334324        /* Perform RESET */
    335         TRACE_DEBUG("RESET PHY\n\r");
    336 
    337325        if (pResetPins) {
    338326                /* Configure PINS */
    339327                PIO_Configure(pResetPins, nbResetPins);
    340                 TRACE_DEBUG(" Hard Reset of GMACD Phy\n\r");
    341328                PIO_Clear(pResetPins);
    342329                rtems_task_wake_after(1);
     
    349336
    350337                if (!rc) {
    351                         TRACE_ERROR("No Valid MDC clock\n\r");
    352338                        return (0);
    353339                }
    354340                if_atsam_reset_phy(gmac_inst);
    355         } else {
    356                 TRACE_ERROR("PHY Reset Timeout\n\r");
    357         }
    358 
     341        }
    359342        return (rc);
    360343}
     
    369352        if_atsam_softc *sc = (if_atsam_softc *)arg;
    370353
    371         TRACE_DEBUG("Mdio read\n\r");
    372         TRACE_DEBUG("%i\n", phy);
    373 
    374354        if (!if_atsam_is_valid_phy(phy)) {
    375                 TRACE_ERROR("Mdio read invalid phy\n\r");
    376355                return (EINVAL);
    377356        }
     
    386365        if_atsam_softc *sc = (if_atsam_softc *)arg;
    387366
    388         TRACE_DEBUG("Mdio write\n\r");
    389 
    390367        if (!if_atsam_is_valid_phy(phy)) {
    391                 TRACE_ERROR("Mdio write invalid phy\n\r");
    392368                return (EINVAL);
    393369        }
     
    415391        if ((irq_status_val & GMAC_IER_ROVR) != 0) {
    416392                ++sc->rx_overrun_errors;
    417                 rx_event = ATSAMV7_ETH_EVENT_INTERRUPT;
     393                rx_event = ATSAMV7_ETH_RX_EVENT_INTERRUPT;
    418394        }
    419395        if ((irq_status_val & GMAC_IER_RCOMP) != 0) {
    420                 rx_event = ATSAMV7_ETH_EVENT_INTERRUPT;
     396                rx_event = ATSAMV7_ETH_RX_EVENT_INTERRUPT;
    421397        }
    422398        /* Send events to receive task and switch off rx interrupts */
     
    429405        if ((irq_status_val & GMAC_IER_TUR) != 0) {
    430406                ++sc->tx_tur_errors;
    431                 tx_event = ATSAMV7_ETH_EVENT_INTERRUPT;
     407                tx_event = ATSAMV7_ETH_TX_EVENT_INTERRUPT;
    432408        }
    433409        if ((irq_status_val & GMAC_IER_RLEX) != 0) {
    434410                ++sc->tx_rlex_errors;
    435                 tx_event = ATSAMV7_ETH_EVENT_INTERRUPT;
     411                tx_event = ATSAMV7_ETH_TX_EVENT_INTERRUPT;
    436412        }
    437413        if ((irq_status_val & GMAC_IER_TFC) != 0) {
    438414                ++sc->tx_tfc_errors;
    439                 tx_event = ATSAMV7_ETH_EVENT_INTERRUPT;
     415                tx_event = ATSAMV7_ETH_TX_EVENT_INTERRUPT;
    440416        }
    441417        if ((irq_status_val & GMAC_IER_HRESP) != 0) {
    442                 TRACE_DEBUG("Tx interrupts: %u\n", sc->tx_interrupts);
    443418                ++sc->tx_hresp_errors;
    444                 tx_event = ATSAMV7_ETH_EVENT_INTERRUPT;
     419                tx_event = ATSAMV7_ETH_TX_EVENT_INTERRUPT;
    445420        }
    446421        if ((irq_status_val & GMAC_IER_TCOMP) != 0) {
    447                 tx_event = ATSAMV7_ETH_EVENT_INTERRUPT;
     422                ++sc->tx_complete_int;
     423                tx_event = ATSAMV7_ETH_TX_EVENT_INTERRUPT;
    448424        }
    449425        /* Send events to transmit task and switch off tx interrupts */
     
    455431        }
    456432}
    457 
    458 
    459433/*
    460434 * Receive daemon
     
    462436static void if_atsam_rx_daemon(void *arg)
    463437{
    464         TRACE_DEBUG(" rx daemon\n\r");
    465438        if_atsam_softc *sc = (if_atsam_softc *)arg;
    466439        rtems_event_set events = 0;
     
    489462        /* Allocate memory space for buffer descriptor list */
    490463        rx_bd_base = rtems_cache_coherent_allocate(
    491                 GMAC_RX_BD_COUNT * sizeof(sGmacRxDescriptor),
     464                sc->amount_rx_buf * sizeof(sGmacRxDescriptor),
    492465                GMAC_DESCRIPTOR_ALIGNMENT, 0);
    493466        assert(rx_bd_base != NULL);
     
    495468
    496469        /* Create descriptor list and mark as empty */
    497         for (sc->rx_bd_fill_idx = 0; sc->rx_bd_fill_idx < GMAC_RX_BD_COUNT;
     470        for (sc->rx_bd_fill_idx = 0; sc->rx_bd_fill_idx < sc->amount_rx_buf;
    498471            ++sc->rx_bd_fill_idx) {
    499472                m = if_atsam_new_mbuf(&sc->arpcom.ac_if);
     
    503476                    GMAC_RX_BUF_DESC_ADDR_MASK;
    504477                buffer_desc->status.val = 0;
    505                 if (sc->rx_bd_fill_idx == (GMAC_RX_BD_COUNT - 1)) {
     478                if (sc->rx_bd_fill_idx == (sc->amount_rx_buf - 1)) {
    506479                        buffer_desc->addr.bm.bWrap = 1;
    507480                } else {
     
    519492
    520493        /* Set address for address matching */
    521         TRACE_DEBUG("Connect the board to a host PC via an ethernet cable\n\r");
    522494        GMAC_SetAddress(pHw, 0, sc->GMacAddress);
    523         TRACE_DEBUG("-- MAC %x:%x:%x:%x:%x:%x\n\r",
    524             sc->GMacAddress[0], sc->GMacAddress[1], sc->GMacAddress[2],
    525             sc->GMacAddress[3], sc->GMacAddress[4], sc->GMacAddress[5]);
    526495
    527496        /* Enable Receiving of data */
     
    534503
    535504        while (true) {
    536                 TRACE_DEBUG("Wait for receive event\n");
    537505                /* Wait for events */
    538                 rtems_bsdnet_event_receive(ATSAMV7_ETH_EVENT_INTERRUPT,
     506                rtems_bsdnet_event_receive(ATSAMV7_ETH_RX_EVENT_INTERRUPT,
    539507                    RTEMS_EVENT_ANY | RTEMS_WAIT,
    540508                    RTEMS_NO_TIMEOUT, &events);
    541                 TRACE_DEBUG("Receive event received\n");
    542509
    543510                /*
     
    546513                while (buffer_desc->addr.bm.bOwnership == 1) {
    547514                        if (buffer_desc->status.bm.bEof == 1) {
    548                                 TRACE_DEBUG("Buffer Descriptor %i\n",
    549                                     sc->rx_bd_fill_idx);
    550 
    551515                                m = sc->rx_mbuf[sc->rx_bd_fill_idx];
    552516
     
    568532                                        ether_input(&sc->arpcom.ac_if, eh, m);
    569533                                        m = n;
     534                                } else {
     535                                        (void)rtems_bsdnet_event_send(
     536                                            sc->tx_daemon_tid, ATSAMV7_ETH_START_TRANSMIT_EVENT);
    570537                                }
    571538                                sc->rx_mbuf[sc->rx_bd_fill_idx] = m;
     
    575542                                /* Switch pointer to next buffer descriptor */
    576543                                if (sc->rx_bd_fill_idx ==
    577                                     (GMAC_RX_BD_COUNT - 1)) {
     544                                    (sc->amount_rx_buf - 1)) {
    578545                                        tmp_rx_bd_address |= GMAC_RX_SET_WRAP;
    579546                                        sc->rx_bd_fill_idx = 0;
     
    598565}
    599566
    600 
    601567/*
    602568 * Update of current transmit buffer position.
    603569 */
    604 static void if_atsam_tx_bd_pos_update(size_t *pos)
    605 {
    606         *pos = (*pos + 1) % GMAC_TX_BD_COUNT;
    607 }
    608 
     570static void if_atsam_tx_bd_pos_update(size_t *pos, size_t amount_tx_buf)
     571{
     572        *pos = (*pos + 1) % amount_tx_buf;
     573}
     574
     575/*
     576 * Is RingBuffer empty
     577 */
     578static bool if_atsam_ring_buffer_empty(ring_buffer *ring_buffer)
     579{
     580        return (ring_buffer->tx_bd_used == ring_buffer->tx_bd_free);
     581}
     582
     583/*
     584 * Is RingBuffer full
     585 */
     586static bool if_atsam_ring_buffer_full(ring_buffer *ring_buffer)
     587{
     588        size_t tx_bd_used_next = ring_buffer->tx_bd_used;
     589
     590        if_atsam_tx_bd_pos_update(&tx_bd_used_next, ring_buffer->length);
     591        return (tx_bd_used_next == ring_buffer->tx_bd_free);
     592}
    609593
    610594/*
     
    618602        bool eof_needed = false;
    619603
    620         while (sc->tx_bd_remove != sc->tx_bd_insert) {
    621                 cur = sc->tx_bd_base + sc->tx_bd_remove;
    622                 if (((cur->status.bm.bUsed == 1) &&
    623                     !eof_needed) || eof_needed) {
     604        while (!if_atsam_ring_buffer_empty(&sc->tx_ring)){
     605                cur = sc->tx_bd_base + sc->tx_ring.tx_bd_free;
     606                if (((cur->status.bm.bUsed == 1) && !eof_needed) || eof_needed) {
    624607                        eof_needed = true;
    625608                        cur->status.val |= GMAC_TX_SET_USED;
    626                         m = sc->tx_mbuf[sc->tx_bd_remove];
     609                        m = sc->tx_mbuf[sc->tx_ring.tx_bd_free];
    627610                        m_free(m);
    628                         if_atsam_tx_bd_pos_update(&sc->tx_bd_remove);
     611                        sc->tx_mbuf[sc->tx_ring.tx_bd_free] = 0;
     612                        if_atsam_tx_bd_pos_update(&sc->tx_ring.tx_bd_free,
     613                            sc->tx_ring.length);
    629614                        if (cur->status.bm.bLastBuffer) {
    630                                 break;
     615                                eof_needed = false;
    631616                        }
    632617                } else {
     
    636621}
    637622
    638 
    639623/*
    640624 * Prepare Ethernet frame to start transmission.
    641625 */
    642 static void if_atsam_send_packet(if_atsam_softc *sc, struct mbuf *m)
    643 {
    644         rtems_event_set events = 0;
     626static bool if_atsam_send_packet(if_atsam_softc *sc, struct mbuf *m)
     627{
    645628        volatile sGmacTxDescriptor *cur;
    646629        volatile sGmacTxDescriptor *start_packet_tx_bd = 0;
    647630        int pos = 0;
    648         unsigned insert_next_pos;
    649631        uint32_t tmp_val = 0;
    650632        Gmac *pHw = sc->Gmac_inst.gGmacd.pHw;
    651 
    652         TRACE_DEBUG("TX Send Packet\n");
     633        bool success;
    653634
    654635        if_atsam_tx_bd_cleanup(sc);
     
    656637        /* Wait for events */
    657638        while (true) {
    658                 insert_next_pos = sc->tx_bd_insert;
    659                 if_atsam_tx_bd_pos_update(&insert_next_pos);
    660                 if (sc->tx_bd_remove == insert_next_pos) {
     639                if (if_atsam_ring_buffer_full(&sc->tx_ring)) {
    661640                        /* Setup the interrupts for TX completion and errors */
    662641                        GMAC_EnableIt(pHw, GMAC_INT_TX_BITS, 0);
    663                         rtems_bsdnet_event_receive(ATSAMV7_ETH_EVENT_INTERRUPT,
    664                             RTEMS_EVENT_ANY | RTEMS_WAIT,
    665                             RTEMS_NO_TIMEOUT, &events);
    666                         if_atsam_tx_bd_cleanup(sc);
     642                        success = false;
     643                        break;
    667644                }
    668645
     
    670647                 * Get current mbuf for data fill
    671648                 */
    672                 cur = &sc->tx_bd_base[sc->tx_bd_insert];
     649                cur = &sc->tx_bd_base[sc->tx_ring.tx_bd_used];
    673650                /* Set the transfer data */
    674651                rtems_cache_flush_multiple_data_lines(mtod(m, const void *),
     
    677654                        cur->addr = (uint32_t)(mtod(m, void *));
    678655                        tmp_val = (uint32_t)m->m_len | GMAC_TX_SET_USED;
    679                         if (sc->tx_bd_insert == (GMAC_TX_BD_COUNT - 1)) {
     656                        if (sc->tx_ring.tx_bd_used == (sc->tx_ring.length - 1)) {
    680657                                tmp_val |= GMAC_TX_SET_WRAP;
    681658                        }
     
    683660                                start_packet_tx_bd = cur;
    684661                        }
    685                         sc->tx_mbuf[sc->tx_bd_insert] = m;
     662                        sc->tx_mbuf[sc->tx_ring.tx_bd_used] = m;
    686663                        m = m->m_next;
    687                         if_atsam_tx_bd_pos_update(&sc->tx_bd_insert);
     664                        if_atsam_tx_bd_pos_update(&sc->tx_ring.tx_bd_used,
     665                            sc->tx_ring.length);
    688666                } else {
    689667                        /* Discard empty mbufs */
     
    701679                        cur->status.val = tmp_val;
    702680                        start_packet_tx_bd->status.val &= ~GMAC_TX_SET_USED;
     681                        _ARM_Data_synchronization_barrier();
     682                        GMAC_TransmissionStart(pHw);
     683                        success = true;
    703684                        break;
    704685                } else {
     
    710691                }
    711692        }
     693        return success;
    712694}
    713695
     
    718700static void if_atsam_tx_daemon(void *arg)
    719701{
    720         TRACE_DEBUG(" tx daemon\n\r");
    721702        if_atsam_softc *sc = (if_atsam_softc *)arg;
    722703        rtems_event_set events = 0;
     
    725706        void *tx_bd_base;
    726707        struct mbuf *m;
     708        bool success;
    727709
    728710        Gmac *pHw = sc->Gmac_inst.gGmacd.pHw;
     
    745727        /* Allocate memory space for buffer descriptor list */
    746728        tx_bd_base = rtems_cache_coherent_allocate(
    747                 GMAC_TX_BD_COUNT * sizeof(sGmacTxDescriptor),
     729                sc->amount_tx_buf * sizeof(sGmacTxDescriptor),
    748730                GMAC_DESCRIPTOR_ALIGNMENT, 0);
    749731        assert(tx_bd_base != NULL);
     
    751733
    752734        /* Create descriptor list and mark as empty */
    753         for (bd_number = 0; bd_number < GMAC_TX_BD_COUNT; bd_number++) {
     735        for (bd_number = 0; bd_number < sc->amount_tx_buf; bd_number++) {
    754736                buffer_desc->addr = 0;
    755737                buffer_desc->status.val = GMAC_TX_SET_USED;
    756                 if (bd_number == (GMAC_TX_BD_COUNT - 1)) {
     738                if (bd_number == (sc->amount_tx_buf - 1)) {
    757739                        buffer_desc->status.bm.bWrap = 1;
    758740                } else {
     
    769751
    770752        /* Set variables in context */
    771         sc->tx_bd_remove = 0;
    772         sc->tx_bd_insert = 0;
    773753        sc->tx_bd_base = tx_bd_base;
    774754
    775755        while (true) {
    776                 TRACE_DEBUG("Wait for TX Transmit Start Event\n");
    777756                /* Wait for events */
    778                 rtems_bsdnet_event_receive(ATSAMV7_ETH_START_TRANSMIT_EVENT,
     757                rtems_bsdnet_event_receive(ATSAMV7_ETH_START_TRANSMIT_EVENT | ATSAMV7_ETH_TX_EVENT_INTERRUPT,
    779758                    RTEMS_EVENT_ANY | RTEMS_WAIT,
    780759                    RTEMS_NO_TIMEOUT, &events);
    781                 TRACE_DEBUG("TX Transmit Event received\n");
     760                //printf("TX Transmit Event received\n");
    782761
    783762                /*
     
    788767                         * Get the mbuf chain to transmit
    789768                         */
     769                        if_atsam_tx_bd_cleanup(sc);
    790770                        IF_DEQUEUE(&sc->arpcom.ac_if.if_snd, m);
    791771                        if (!m) {
     772                                ifp->if_flags &= ~IFF_OACTIVE;
    792773                                break;
    793774                        }
    794                         if_atsam_send_packet(sc, m);
    795                         _ARM_Data_synchronization_barrier();
    796                         GMAC_TransmissionStart(pHw);
    797                 }
    798                 ifp->if_flags &= ~IFF_OACTIVE;
     775                        success = if_atsam_send_packet(sc, m);
     776                        if (!success){
     777                                break;
     778                        }
     779                }
    799780        }
    800781}
     
    807788{
    808789        if_atsam_softc *sc = (if_atsam_softc *)ifp->if_softc;
    809 
    810         TRACE_DEBUG(" in start\n\r");
    811790
    812791        ifp->if_flags |= IFF_OACTIVE;
     
    830809        uint32_t retries = sc->Gmac_inst.retries;
    831810
    832         TRACE_DEBUG("Entered Watchdog\n\r");
    833 
    834811        if (if_atsam_read_phy(pHw, phy, MII_ANLPAR, &anlpar, retries)) {
    835812                anlpar = 0;
    836813        }
    837814        if (sc->anlpar != anlpar) {
    838                 TRACE_DEBUG("Entered Watchdog Loop\n\r");
    839815                /* Set up the GMAC link speed */
    840816                if (anlpar & ANLPAR_TX_FD) {
     
    873849        rtems_status_code status;
    874850
    875         TRACE_DEBUG(" in setup hardware\n\r");
    876851        if_atsam_softc *sc = (if_atsam_softc *)arg;
    877852        struct ifnet *ifp = &sc->arpcom.ac_if;
     
    903878
    904879        /* PHY initialize */
    905         if (!if_atsam_init_phy(&sc->Gmac_inst, BOARD_MCK, &gmacResetPin, 1,
    906             gmacPins, PIO_LISTSIZE(gmacPins))) {
    907                 TRACE_ERROR("PHY Initialize ERROR!\n\r");
    908         }
     880        if_atsam_init_phy(&sc->Gmac_inst, BOARD_MCK, &gmacResetPin, 1,
     881            gmacPins, PIO_LISTSIZE(gmacPins));
    909882        /* Find valid Phy */
    910883        atsamv7_find_valid_phy(&sc->Gmac_inst);
     
    934907         * Allocate mbuf pointers
    935908         */
    936         sc->rx_mbuf = malloc(GMAC_RX_BD_COUNT * sizeof *sc->rx_mbuf,
     909        sc->rx_mbuf = malloc(sc->amount_rx_buf * sizeof *sc->rx_mbuf,
    937910                M_MBUF, M_NOWAIT);
    938         sc->tx_mbuf = malloc(GMAC_TX_BD_COUNT * sizeof *sc->rx_mbuf,
     911        sc->tx_mbuf = malloc(sc->amount_tx_buf * sizeof *sc->tx_mbuf,
    939912                M_MBUF, M_NOWAIT);
    940913
     
    968941        Gmac *pHw = sc->Gmac_inst.gGmacd.pHw;
    969942
    970         TRACE_DEBUG(" in stop\n\r");
    971 
    972943        ifp->if_flags &= ~IFF_RUNNING;
    973944
     
    987958        Gmac *pHw;
    988959
    989         TRACE_DEBUG(" in stats\n\r");
    990 
    991960        media = (int)IFM_MAKEWORD(0, 0, 0, sc->Gmac_inst.phy_address);
    992961        eno = rtems_mii_ioctl(&sc->mdio, sc, SIOCGIFMEDIA, &media);
     
    1002971        printf("\n** Context Statistics **\n");
    1003972        printf("Rx interrupts: %u\n", sc->rx_interrupts);
    1004         printf("Tx interrupts: %u\n\n", sc->tx_interrupts);
     973        printf("Tx interrupts: %u\n", sc->tx_interrupts);
     974        printf("Error Tur Tx interrupts: %u\n\n", sc->tx_tur_errors);
     975        printf("Error Rlex Tx interrupts: %u\n\n", sc->tx_rlex_errors);
     976        printf("Error Tfc Tx interrupts: %u\n\n", sc->tx_tfc_errors);
     977        printf("Error Hresp Tx interrupts: %u\n\n", sc->tx_hresp_errors);
     978        printf("Tx complete interrupts: %u\n\n", sc->tx_complete_int);
    1005979        printf("\n** Statistics **\n");
    1006980        printf("Octets Transmitted Low: %lu\n", pHw->GMAC_OTLO);
     
    11651139        bool prom_enable;
    11661140
    1167         TRACE_DEBUG(" in ioctl\n\r");
    1168 
    11691141        switch (command) {
    11701142        case SIOCGIFMEDIA:
    11711143        case SIOCSIFMEDIA:
    1172                 TRACE_DEBUG("MEDIA\n");
    11731144                rtems_mii_ioctl(&sc->mdio, sc, command, &ifr->ifr_media);
    11741145                break;
    11751146        case SIOCGIFADDR:
    11761147        case SIOCSIFADDR:
    1177                 TRACE_DEBUG("Address\n");
    11781148                ether_ioctl(ifp, command, data);
    11791149                break;
     
    11971167                if_atsam_multicast_control(command == SIOCADDMULTI, ifr, sc);
    11981168        case SIO_RTEMS_SHOW_STATS:
    1199                 TRACE_DEBUG("SHOW STATS\n");
    12001169                if_atsam_stats(sc);
    12011170                break;
     
    12431212        sc->mdio.mdio_w = if_atsam_mdio_write;
    12441213        sc->mdio.has_gmii = 1;
     1214
     1215        sc->amount_rx_buf = config->rbuf_count;
     1216        sc->amount_tx_buf = config->xbuf_count;
     1217
     1218        sc->tx_ring.tx_bd_used = 0;
     1219        sc->tx_ring.tx_bd_free = 0;
     1220        sc->tx_ring.length = sc->amount_tx_buf;
    12451221
    12461222        /*
Note: See TracChangeset for help on using the changeset viewer.