Changeset 59c31da for lib/dagapi.c


Ignore:
Timestamp:
10/26/04 07:57:30 (17 years ago)
Author:
Daniel Lawson <dlawson@…>
Branches:
4.0.1-hotfixes, cachetimestamps, develop, dpdk-ndag, etsilive, getfragoff, help, libtrace4, master, ndag_format, pfring, rc-4.0.1, rc-4.0.2, rc-4.0.3, rc-4.0.4, ringdecrementfix, ringperformance, ringtimestampfixes
Children:
a22c979
Parents:
7e55902
Message:

fixes in trace.c for DAG support.
New dagapi / dagopts.c. Still need to find way to build these outside the source

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/dagapi.c

    rb36a3b7 r59c31da  
    4444# define        IOM(OFF)        (*(volatile unsigned *)(herd[dagfd].iom+(OFF)))
    4545# define        ARMOFFSET(FD)   ({ int _off = ToHM4 - dag_info(FD)->phy_addr; \
    46                                         (_off == dag_info(FD)->buf_size) ? 0 : _off; })
     46                                        (_off == herd[FD].rx_memsize) ? 0 : _off; })
    4747
    4848# define        CUROFFSET(FD)   ({ int _off = pbm->curaddr - dag_info(FD)->phy_addr; \
    49                                         (_off == dag_info(FD)->buf_size) ? 0 : _off; })
     49                                        (_off == herd[FD].rx_memsize) ? 0 : _off; })
    5050# define        SEGOFFSET(FD)   ({ int _off = pbm->segaddr - dag_info(FD)->phy_addr; \
    51                                         (_off == dag_info(FD)->buf_size) ? 0 : _off; })
     51                                        (_off == herd[FD].rx_memsize) ? 0 : _off; })
    5252# define        PBMOFFSET(FD)   (herd[FD].brokencuraddr ? \
    5353                                        SEGOFFSET(FD) : CUROFFSET(FD))
     
    6161 * the reliable path to address the problem, for the moment.
    6262 */
    63 # define        WRSAFE(FD,X)    (((X)<8) ? ((X)+dag_info(FD)->buf_size-8) : ((X)-8))
     63# define        WRSAFE(FD,X)    (((X)<8) ? ((X)+herd[FD].rx_memsize-8) : ((X)-8))
    6464
    6565/*
     
    7373        daginf_t        daginf;
    7474        unsigned        brokencuraddr;  /* fix for ECMs and Dag4.1s */
    75         unsigned        byteswap;       /* endinness for 3.4/3.51ecm */
     75        unsigned        byteswap;       /* endinness for 3.4/3.51ecm */
     76        unsigned        rx_memaddr;     /* cached rx hole base */
     77        unsigned        rx_memsize;     /* cached rx hole size */
    7678} sheep_t;
    7779
     
    7981
    8082static void     panic(char *fmt, ...) __attribute__((noreturn, format (printf, 1, 2)));
     83static void     dagpbmcheck(int dagfd);
    8184
    8285char *dagpath(char *path, char *temp, int tempsize) {
     
    116119                panic("dag_open dag_clone dagfd for dagiom: %s\n", strerror(errno));
    117120
    118         if((herd[dagfd].iom = mmap(NULL, 2*PAGE_SIZE, PROT_READ | PROT_WRITE,
     121        if((herd[dagfd].iom = mmap(NULL, 16*PAGE_SIZE, PROT_READ | PROT_WRITE,
    119122                                        MAP_SHARED, herd[dagfd].dagiom, 0)) == MAP_FAILED)
    120123                return -1;      /* errno set appropriately */
     
    126129dag_close(int dagfd)
    127130{
     131        if (herd[dagfd].buf != NULL) {
     132                int             buf_size=0;
     133
     134                if(dag_info(dagfd)->soft_caps.pbm) {
     135                        buf_size = ((dagpbm_t *)(herd[dagfd].iom +
     136                                        dag_info(dagfd)->pbm_base))->memsize;
     137                } else {
     138                        buf_size = dag_info(dagfd)->buf_size;
     139                }
     140                munmap(herd[dagfd].buf, 2*buf_size);
     141                herd[dagfd].buf = NULL;
     142        }
    128143        (void)close(herd[dagfd].dagiom);
     144        if (herd[dagfd].iom != NULL) {
     145                munmap(herd[dagfd].iom, 16*PAGE_SIZE);
     146                herd[dagfd].iom = NULL;
     147        }
    129148        memset(&herd[dagfd], 0, sizeof(herd[dagfd]));
    130149        herd[dagfd].dagiom = -1;
     
    171190dag_configure(int dagfd, char *params)
    172191{
    173         int     lock, tok, setatm;
     192        int     lock, tok, setatm, dagarm, val;
    174193        char    temp1[80], temp2[80];
    175194        daggpp_t        *gpp = (daggpp_t *)(herd[dagfd].iom +
     
    244263          case 0x3200:
    245264                if(armcode(dagfd)) {
    246                         if(spawn(dagpath("tools/dagrun", temp1, 80), "-d",
    247                                         herd[dagfd].dagname,
    248                                         dagpath("arm/dag3atm-hash.b",
    249                                         temp2, 80), NULL) < 0)
    250                                 return -1;                             
     265                        dagarm=dag_clone(dagfd, DAGMINOR_ARM);
     266                        if(lseek(dagarm, (off_t)(dag_info(dagfd)->phy_base+(0x5c<<2)), SEEK_SET) < 0)
     267                                panic("dagioread lseek register 0x%x: %s\n", 0x5c, strerror(errno));
     268                        if(read(dagarm, &val, sizeof(val)) != sizeof(val))
     269                                panic("read /dev/dagarmN register 0x%x: %s\n", 0x5c, strerror(errno));
     270                        close(dagarm);
     271                        if (val & 0x80) {
     272                                if(spawn(dagpath("tools/dagrun", temp1, 80), "-d",
     273                                         herd[dagfd].dagname,
     274                                         dagpath("arm/dag3pos-full.b",
     275                                                 temp2, 80), NULL) < 0)
     276                                        return -1;                             
     277                        } else {
     278                                if(spawn(dagpath("tools/dagrun", temp1, 80), "-d",
     279                                         herd[dagfd].dagname,
     280                                         dagpath("arm/dag3atm-hash.b",
     281                                                 temp2, 80), NULL) < 0)
     282                                        return -1;                             
     283                        }
    251284                }
    252285                break;
     
    278311          case 0x350e:
    279312          case 0x360d:
     313          case 0x360e:
     314          case 0x368e:
    280315                break;
    281316                /* byteswapped */
     
    299334          case 0x423e:
    300335          case 0x4230:
     336          case 0x4300:
     337          case 0x430e:
    301338          case 0x6000:
    302339          case 0x6100:
     
    371408                return -1;      /* errno set */
    372409
    373         memset(herd[dagfd].buf, 0, dag_info(dagfd)->buf_size);
     410        memset(herd[dagfd].buf, 0, herd[dagfd].rx_memsize);
    374411
    375412        switch(dag_info(dagfd)->device_code) {
     
    384421          case 0x351c:
    385422          case 0x350e:
     423          case 0x360e:
     424          case 0x368e:
    386425          case 0x3800:
    387426          case 0x4100:
     
    391430          case 0x423e:
    392431          case 0x4230:
     432          case 0x4300:
     433          case 0x430e:
    393434          case 0x6000:
    394435          case 0x6100:
     
    419460          case 0x351c:
    420461          case 0x350e:
     462          case 0x360e:
     463          case 0x368e:
    421464          case 0x3800:
    422465          case 0x4100:
     
    426469          case 0x423e:
    427470          case 0x4230:
     471          case 0x4300:
     472          case 0x430e:
    428473          case 0x6000:
    429474          case 0x6100:
     
    446491        void            *sp, *p, *ep;
    447492        daginf_t        *dip;
     493        int             buf_size=0;
     494
     495        dagpbm_t        *pbm = (dagpbm_t *)(herd[dagfd].iom +
     496                                        dag_info(dagfd)->pbm_base);
    448497
    449498        dip = dag_info(dagfd);
     499
     500        /* check pbm space is configured */
     501        dagpbmcheck(dagfd);
     502
     503        /*
     504         * Get the buffer size from the card if possible, since
     505         * if rx/tx is configured only part of the memory space
     506         * is used for rx.
     507         * XXX There is currently no way to tell dag_mmap which
     508         * half you want, always supplies first rx region.
     509         */
     510        if(dag_info(dagfd)->soft_caps.pbm) {
     511                buf_size = pbm->memsize;
     512        } else {
     513                buf_size = dip->buf_size;
     514        }
     515
    450516        /*
    451517         * Start off with a fake mapping to allocate contiguous virtual
     
    456522         * problem.
    457523         */
    458         if((sp = mmap(NULL, 2*dip->buf_size, PROT_READ | PROT_WRITE,
     524        if((sp = mmap(NULL, 2*buf_size, PROT_READ | PROT_WRITE,
    459525                        MAP_ANON|MAP_SHARED, -1, 0)) == MAP_FAILED)
    460526                return MAP_FAILED;
     
    462528         * Now map the real buffer, 1st round.
    463529         */
    464         if((p = mmap(sp, dip->buf_size, PROT_READ | PROT_WRITE,
     530        if((p = mmap(sp, buf_size, PROT_READ | PROT_WRITE,
    465531                        MAP_FIXED|MAP_SHARED, dagfd, 0)) == MAP_FAILED)
    466532                return MAP_FAILED;
     
    470536         * top of the memory buffer.
    471537         */
    472         if((ep = mmap(sp+dip->buf_size, dip->buf_size, PROT_READ|PROT_WRITE,
     538        if((ep = mmap(sp+buf_size, buf_size, PROT_READ|PROT_WRITE,
    473539                        MAP_FIXED|MAP_SHARED, dagfd, 0)) == MAP_FAILED)
    474540                return MAP_FAILED;
     
    494560         * zero.
    495561         */
    496         if(*oldoffset >= dag_info(dagfd)->buf_size)
    497                 *oldoffset -= dag_info(dagfd)->buf_size;
     562        if(*oldoffset >= herd[dagfd].rx_memsize)
     563                *oldoffset -= herd[dagfd].rx_memsize;
    498564
    499565        if(dag_info(dagfd)->soft_caps.pbm) {
     
    527593        }
    528594
    529         if(offset > dag_info(dagfd)->buf_size)
     595        if(offset > herd[dagfd].rx_memsize)
    530596                panic("dagapi: dag_offset internal error offset=0x%x\n", offset);
    531597
    532598        if(offset < *oldoffset)
    533                 offset += dag_info(dagfd)->buf_size;
     599                offset += herd[dagfd].rx_memsize;
    534600
    535601        return offset;
     
    602668
    603669                pbm->bursttmo = 0xffff;
    604                 pbm->memaddr = dag_info(dagfd)->phy_addr; /* XXX curaddr bugfix */
    605                 pbm->memsize = dag_info(dagfd)->buf_size;
    606670                pbm->segsize = (1024*1024);     /* paranoia, not that it matters */
    607                 pbm->wrsafe = dag_info(dagfd)->phy_addr + WRSAFE(dagfd, dag_info(dagfd)->buf_size);
     671                pbm->wrsafe = dag_info(dagfd)->phy_addr + WRSAFE(dagfd, herd[dagfd].rx_memsize);
    608672                pbm->cs = (DAGPBM_SYNCL2R|DAGPBM_AUTOWRAP|herd[dagfd].byteswap);
    609673
     
    613677
    614678        if(armcode(dagfd)) {
    615                 usleep(1); /* seems necessary to let pbm settle? */
    616                 IOM(0x404) |=  (1<<23);         /* framer now held in reset */
    617679                IOM(0x88)  |= (1<<31);          /* L2RESET, will auto deassert */
    618680
     
    629691                while(ToHM2 != 2)
    630692                        usleep(1);
    631                 IOM(0x404) &= ~(1<<23);         /* deassert framer reset */
    632693        }
    633694
     
    678739
    679740        pbm->bursttmo = 0xffff;
    680         pbm->memaddr = dag_info(dagfd)->phy_addr; /* XXX curaddr bugfix */
    681         pbm->memsize = dag_info(dagfd)->buf_size;
    682741        pbm->segsize = (1024*1024);     /* paranoia, not that it matters */
    683         pbm->wrsafe = dag_info(dagfd)->phy_addr + WRSAFE(dagfd, dag_info(dagfd)->buf_size);
     742        pbm->wrsafe = dag_info(dagfd)->phy_addr + WRSAFE(dagfd, herd[dagfd].rx_memsize);
    684743        pbm->cs = (DAGPBM_SYNCL2R|DAGPBM_AUTOWRAP|herd[dagfd].byteswap);
    685744
     
    705764
    706765        return 0;
     766}
     767
     768static void
     769dagpbmcheck(int dagfd)
     770{
     771        dagpbm_t        *pbm = (dagpbm_t *)(herd[dagfd].iom +
     772                                        dag_info(dagfd)->pbm_base);
     773       
     774        if(dag_info(dagfd)->soft_caps.pbm) {
     775                if((pbm->memaddr & 0xfffffff8) == 0xfffffff8) {
     776                        /* pbm unconfigured*/
     777                        pbm->memaddr = dag_info(dagfd)->phy_addr; /* XXX curaddr bugfix */
     778                        pbm->memsize = dag_info(dagfd)->buf_size;
     779                }
     780                /* XXX cache actual hole location for dag_offset etc*/
     781                herd[dagfd].rx_memaddr = pbm->memaddr;
     782                herd[dagfd].rx_memsize = pbm->memsize;
     783        } else {
     784                /* XXX cache actual hole location for dag_offset etc*/
     785                herd[dagfd].rx_memaddr = dag_info(dagfd)->phy_addr;
     786                herd[dagfd].rx_memsize = dag_info(dagfd)->buf_size;
     787        }
    707788}
    708789
Note: See TracChangeset for help on using the changeset viewer.