Changeset 2a2b206 in rtems


Ignore:
Timestamp:
Sep 12, 2007, 3:41:43 PM (12 years ago)
Author:
Joel Sherrill <joel.sherrill@…>
Branches:
4.10, 4.11, 4.8, 4.9, master
Children:
98f890b
Parents:
47b29ac
Message:

2007-09-12 Daniel Hellstrom <daniel@…>

  • libchip/network/smc91111.c, libchip/network/smc91111.h: Multiple fixes.
    • Odd bit bug in some chips taken care of.
    • Buggy ASSERT removed, it seem to be inserted to detect if MBUF data alignment but failing to do so must have made the driver writer to make some incorrect assumptions about MBUFs.
    • Fixed MBUF handling to handle mbuf chains better. The Data length of MBUFs in middle of the mbuf chain are now checked for odd number of bytes.
    • Made while loop responsible for copying data to fifo port copy 16 shorts per loop instead of 1 short, increasing the copying process.
Location:
c/src
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • c/src/ChangeLog

    r47b29ac r2a2b206  
     12007-09-12      Daniel Hellstrom <daniel@gaisler.com>
     2
     3        * libchip/network/smc91111.c, libchip/network/smc91111.h: Multiple fixes.
     4          - Odd bit bug in some chips taken care of.
     5          - Buggy ASSERT removed, it seem to be inserted to detect if MBUF data
     6            alignment but failing to do so must have made the driver writer to make
     7            some incorrect assumptions about MBUFs.
     8          - Fixed MBUF handling to handle mbuf chains better. The Data length of
     9            MBUFs in middle of the mbuf chain are now checked for odd number of bytes.
     10          - Made while loop responsible for copying data to fifo port copy 16 shorts
     11            per loop instead of 1 short, increasing the copying process.
     12
    1132007-09-07      Daniel Hellstrom <daniel@gaisler.com>
    214
  • c/src/libchip/network/smc91111.c

    r47b29ac r2a2b206  
    182182#endif
    183183
    184         if (LAN91CXX_RX_STATUS_IS_ODD(cpd, val))
     184        if ( cpd->c111_reva || LAN91CXX_RX_STATUS_IS_ODD(cpd, val) ) /* RevA Odd-bit BUG */
    185185                plen++;
    186186
     
    258258#ifdef LAN91CXX_32BIT_RX
    259259        if (plen & 2) {
    260                 if (data) {
     260                if (data && (mlen>1) ) {
    261261                        *(unsigned short *)data = (val >> 16) & 0xffff;
    262             data = (rxd_t *)((unsigned short *)data + 1);
     262                        data = (rxd_t *)((unsigned short *)data + 1);
    263263                        val <<= 16;
    264                 }
    265         }
    266         if (plen & 1)
     264                        mlen-=2;
     265                }
     266        }
     267        if ( (plen & 1) && data && (mlen>0) )
    267268                *(unsigned char *)data = val >> 24;
    268269#else
     
    422423                /* Then it's OK */
    423424
    424                 if (LAN91CXX_RX_STATUS_IS_ODD(cpd, stat))
     425                if (cpd->c111_reva || LAN91CXX_RX_STATUS_IS_ODD(cpd, stat)) /* RevA Odd-bit BUG */
    425426                        complen++;
    426427
     
    492493{
    493494        struct lan91cxx_priv_data *cpd = ifp->if_softc;
    494         int i, len, plen, tcr;
     495        int i, len, plen, tcr, odd;
    495496        struct mbuf *n = m;
    496497        unsigned short *sdata = NULL;
     
    563564
    564565        /* Put data into buffer */
     566        odd = 0;
    565567        n = m;
    566568        while (n) {
     
    568570                len = n->m_len;
    569571
    570                 CYG_ASSERT((0 == (len & 1)
    571                             || !(n->m_next)), "!odd length");
    572572                CYG_ASSERT(sdata, "!No sg data pointer here");
    573573
    574                 while (len >= sizeof(*sdata)) {
     574                /* start on an odd offset?
     575                 * If last byte also (1byte mbuf with different pointer should not occur)
     576                 * let following code handle it
     577                 */
     578                if ( ((unsigned int)sdata & 1) && (len>1) ){
     579                        put_data8(cpd,*(unsigned char *)sdata);
     580                        sdata = (unsigned short *)((unsigned int)sdata + 1);
     581                        odd = ~odd;
     582                        len--;
     583                }
     584               
     585                /* speed up copying a bit, never copy last word */
     586                while(len >= 17){
     587                        put_data(cpd, *(sdata));
     588                        put_data(cpd, *(sdata+1));
     589                        put_data(cpd, *(sdata+2));
     590                        put_data(cpd, *(sdata+3));
     591                        put_data(cpd, *(sdata+4));
     592                        put_data(cpd, *(sdata+5));
     593                        put_data(cpd, *(sdata+6));
     594                        put_data(cpd, *(sdata+7));
     595                        sdata += 8;
     596                        len -= 16;
     597                }
     598               
     599                /* copy word wise, skip last word */
     600                while (len >= 3) {
    575601                        put_data(cpd, *sdata++);
    576602                        len -= sizeof(*sdata);
    577603                }
     604               
     605                /* one or two bytes left to put into fifo */
     606                if ( len > 1 ){
     607                        /* the last 2bytes */
     608                        if ( !odd || n->m_next ){
     609                                put_data(cpd, *sdata++);
     610                                len -= sizeof(*sdata);
     611                        }else{
     612                                /* write next byte, mark that we are not at an odd offset any more,
     613                                 * remaining byte will be written outside while together with control byte.
     614                                 */
     615                                put_data8(cpd,*(unsigned char *)sdata);
     616                                sdata = (unsigned short *)((unsigned int)sdata + 1);
     617                                odd = 0;
     618                                len--;
     619                                /*break;*/
     620                        }
     621                }else if ( (len>0) && (n->m_next) ){
     622                        /* one byte left to write, and more bytes is comming in next mbuf */
     623                        put_data8(cpd,*(unsigned char *)sdata);
     624                        odd = ~odd;
     625                }
     626
    578627                n = n->m_next;
    579628        }
    580 #if DEBUG & 64
    581         n = m;
    582         while (n) {
    583                 int lp = 0;
    584                 unsigned char *start = (unsigned char *)n->m_data;
    585                 len = n->m_len;
    586                 while (len > 0) {
    587                         unsigned char a = *(start++);
    588                         unsigned char b = *(start++);
    589                         db64_printf("%02x %02x ", a, b);
    590                         lp += 2;
    591                         if (lp >= 16) {
    592                                 db64_printf("\n");
    593                                 lp = 0;
    594                         }
    595                         len -= 2;
    596                 }
    597                 n = n->m_next;
    598         }
    599         db64_printf(" \n");
    600 #endif
    601 
    602         m_freem(m);
    603         CYG_ASSERT(sdata, "!No sg data pointer outside");
    604629
    605630        /* Lay down the control short unconditionally at the end. */
    606631        /* (or it might use random memory contents) */
    607632        control = 0;
    608         if (1 & plen) {
    609                 /* Need to set ODD flag and insert the data */
    610                 unsigned char onebyte = *(unsigned char *)sdata;
    611                 control = onebyte;
    612                 control |= LAN91CXX_CONTROLBYTE_ODD;
     633        if ( len > 0 ){
     634                if ( !odd ) {
     635                        /* Need to set ODD flag and insert the data */
     636                        unsigned char onebyte = *(unsigned char *)sdata;
     637                        control = onebyte;
     638                        control |= LAN91CXX_CONTROLBYTE_ODD;
     639                }else{
     640                        put_data8(cpd,*(unsigned char *)sdata);
     641                }
    613642        }
    614643        control |= LAN91CXX_CONTROLBYTE_CRC;    /* Just in case... */
    615644        put_data(cpd, CYG_CPU_TO_LE16(control));
     645
     646        m_freem(m);
     647        CYG_ASSERT(sdata, "!No sg data pointer outside");
    616648
    617649        /* ############ start transmit ############ */
     
    10581090
    10591091        /* Set RevA flag for LAN91C111 so we can cope with the odd-bit bug. */
    1060         cpd->c111_reva = (val == 0x3390);
     1092        cpd->c111_reva = (val == 0x3390); /* 90=A, 91=B, 92=C */
    10611093
    10621094        /* The controller may provide a function used to set up the ESA */
     
    15961628
    15971629#endif
     1630
     1631#if 0
     1632void lan91cxx_print_bank(int bank){
     1633        struct lan91cxx_priv_data *cpd = &smc91111;
     1634        int regno;
     1635        unsigned short regval[8];
     1636        int i;
     1637
     1638        if ( bank >= 4 )
     1639                return;
     1640        for(i=0; i<8; i++){
     1641                regno=i+bank<<3;
     1642                regval[i] = get_reg(cpd, regno);
     1643        }
     1644        printk("---- BANK %d ----\n\r",bank);   
     1645        for(i=0; i<8; i++){
     1646                printk("0x%x: 0x%x\n\r",i,regval[i]);
     1647        }
     1648
     1649}
     1650#endif
  • c/src/libchip/network/smc91111.h

    r47b29ac r2a2b206  
    461461      dbg++;
    462462    }
    463 #else   
     463#else
    464464    db2_printf("%sread  reg %d:%x -> 0x%04x\n", dbg_prefix, regno>>3,(regno&0x7)*2, val);
    465465#endif
     
    484484      dbg++;
    485485    }
    486 #else   
     486#else
    487487    db2_printf("%swrite reg %d:%x <- 0x%04x\n", dbg_prefix, regno>>3,(regno&0x7)*2, val);
    488488#endif
     
    509509
    510510}
     511
     512/* Assumes bank2 has been selected*/
     513static __inline__ void
     514put_data8(struct lan91cxx_priv_data *cpd, unsigned char val)
     515{
     516    db2_printf("%s[bdata] <- 0x%02x\n", dbg_prefix, val);
     517   
     518    HAL_WRITE_UINT8(((unsigned char *)(cpd->base+((LAN91CXX_DATA & 0x7))))+1, val);
     519
     520}
     521
    511522#endif /* SMSC_PLATFORM_DEFINED_PUT_DATA*/
    512523
Note: See TracChangeset for help on using the changeset viewer.