Changeset d3a0af7 in mainline


Ignore:
Timestamp:
2011-01-06T17:18:40Z (14 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
122b753
Parents:
b590c21
Message:

declutter

Location:
uspace/srv/hw/netif/dp8390
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/hw/netif/dp8390/dp8390.c

    rb590c21 rd3a0af7  
    5454static void dp_pio16_getblock(dpeth_t *dep, int page, size_t offset, size_t size, void *dst);
    5555static int dp_pkt2user(dpeth_t *dep, int page, int length);
    56 static void dp_pio8_user2nic(dpeth_t *dep, iovec_dat_t *iovp, vir_bytes offset, int nic_addr, vir_bytes count);
    57 static void dp_pio16_user2nic(dpeth_t *dep, iovec_dat_t *iovp, vir_bytes offset, int nic_addr, vir_bytes count);
    58 static void dp_pio8_nic2user(dpeth_t *dep, int nic_addr, iovec_dat_t *iovp, vir_bytes offset, vir_bytes count);
    59 static void dp_pio16_nic2user(dpeth_t *dep, int nic_addr, iovec_dat_t *iovp, vir_bytes offset, vir_bytes count);
     56static void dp_pio8_user2nic(dpeth_t *dep, iovec_dat_t *iovp, size_t offset, int nic_addr, size_t count);
     57static void dp_pio16_user2nic(dpeth_t *dep, iovec_dat_t *iovp, size_t offset, int nic_addr, size_t count);
     58static void dp_pio8_nic2user(dpeth_t *dep, int nic_addr, iovec_dat_t *iovp, size_t offset, size_t count);
     59static void dp_pio16_nic2user(dpeth_t *dep, int nic_addr, iovec_dat_t *iovp, size_t offset, size_t count);
    6060static void dp_next_iovec(iovec_dat_t *iovp);
    6161static void conf_hw(dpeth_t *dep);
    6262static void reply(dpeth_t *dep, int err, int may_block);
    63 static void get_userdata(int user_proc, vir_bytes user_addr, vir_bytes count, void *loc_addr);
    6463static void insb(port_t port, void *buf, size_t size);
    6564static void insw(port_t port, void *buf, size_t size);
    … …  
    205204                        sizeof(iovec_t), dep->de_write_iovec.iod_iovec);
    206205                dep->de_write_iovec.iod_iovec_s = count;
    207                 dep->de_write_iovec.iod_proc_nr = mp->DL_PROC;
    208206                dep->de_write_iovec.iod_iovec_addr = (vir_bytes) mp->DL_ADDR;
    209207               
    … …  
    216214                        mp->DL_COUNT;
    217215                dep->de_write_iovec.iod_iovec_s = 1;
    218                 dep->de_write_iovec.iod_proc_nr = mp->DL_PROC;
    219216                dep->de_write_iovec.iod_iovec_addr = 0;
    220217                size= mp->DL_COUNT;
    … …  
    222219*/
    223220        size = packet_get_data_length(packet);
    224         dep->de_write_iovec.iod_iovec[0].iov_addr = (vir_bytes) packet_get_data(packet);
     221        dep->de_write_iovec.iod_iovec[0].iov_addr = (void *) packet_get_data(packet);
    225222        dep->de_write_iovec.iod_iovec[0].iov_size = size;
    226223        dep->de_write_iovec.iod_iovec_s = 1;
    227         dep->de_write_iovec.iod_iovec_addr = (uintptr_t) NULL;
     224        dep->de_write_iovec.iod_iovec_addr = NULL;
    228225       
    229226        if (size < ETH_MIN_PACK_SIZE || size > ETH_MAX_PACK_SIZE_TAGGED) {
    … …  
    556553        //unsigned pageno, curr, next;
    557554        int pageno, curr, next;
    558         vir_bytes length;
     555        size_t length;
    559556        int packet_processed, r;
    560557        uint16_t eth_type;
    … …  
    683680                return ENOMEM;
    684681       
    685         dep->de_read_iovec.iod_iovec[0].iov_addr = (vir_bytes) packet_suffix(packet, length);
     682        dep->de_read_iovec.iod_iovec[0].iov_addr = (void *) packet_suffix(packet, length);
    686683        dep->de_read_iovec.iod_iovec[0].iov_size = length;
    687684        dep->de_read_iovec.iod_iovec_s = 1;
    688         dep->de_read_iovec.iod_iovec_addr = (uintptr_t) NULL;
     685        dep->de_read_iovec.iod_iovec_addr = NULL;
    689686       
    690687        last = page + (length - 1) / DP_PAGESIZE;
    … …  
    720717}
    721718
    722 static void dp_pio8_user2nic(dpeth_t *dep, iovec_dat_t *iovp, vir_bytes offset, int nic_addr, vir_bytes count)
     719static void dp_pio8_user2nic(dpeth_t *dep, iovec_dat_t *iovp, size_t offset, int nic_addr, size_t count)
    723720{
    724721//      phys_bytes phys_user;
    725722        int i;
    726         vir_bytes bytes;
    727 
     723        size_t bytes;
     724       
    728725        outb_reg0(dep, DP_ISR, ISR_RDC);
    729 
    730         outb_reg0(dep, DP_RBCR0, count &0xFF);
     726       
     727        outb_reg0(dep, DP_RBCR0, count & 0xFF);
    731728        outb_reg0(dep, DP_RBCR1, count >> 8);
    732         outb_reg0(dep, DP_RSAR0, nic_addr &0xFF);
     729        outb_reg0(dep, DP_RSAR0, nic_addr & 0xFF);
    733730        outb_reg0(dep, DP_RSAR1, nic_addr >> 8);
    734731        outb_reg0(dep, DP_CR, CR_DM_RW | CR_PS_P0 | CR_STA);
    735 
    736         i= 0;
    737         while (count > 0)
    738         {
    739                 if (i >= IOVEC_NR)
    740                 {
     732       
     733        i = 0;
     734        while (count > 0) {
     735                if (i >= IOVEC_NR) {
    741736                        dp_next_iovec(iovp);
    742                         i= 0;
     737                        i = 0;
    743738                        continue;
    744739                }
     740               
    745741                assert(i < iovp->iod_iovec_s);
    746                 if (offset >= iovp->iod_iovec[i].iov_size)
    747                 {
     742               
     743                if (offset >= iovp->iod_iovec[i].iov_size) {
    748744                        offset -= iovp->iod_iovec[i].iov_size;
    749745                        i++;
    750746                        continue;
    751747                }
     748               
    752749                bytes = iovp->iod_iovec[i].iov_size - offset;
    753750                if (bytes > count)
    754751                        bytes = count;
    755 
    756                 do_vir_outsb(dep->de_data_port, iovp->iod_proc_nr,
    757                         iovp->iod_iovec[i].iov_addr + offset, bytes);
     752               
     753                do_vir_outsb(dep->de_data_port, iovp->iod_iovec[i].iov_addr + offset, bytes);
    758754                count -= bytes;
    759755                offset += bytes;
    760756        }
     757       
    761758        assert(count == 0);
    762 
    763         for (i= 0; i<100; i++)
    764         {
    765                 if (inb_reg0(dep, DP_ISR) &ISR_RDC)
     759       
     760        for (i = 0; i < 100; i++) {
     761                if (inb_reg0(dep, DP_ISR) & ISR_RDC)
    766762                        break;
    767763        }
     764       
    768765        if (i == 100)
    769766                fprintf(stderr, "dp8390: remote dma failed to complete\n");
    770767}
    771768
    772 /*===========================================================================*
    773  *                              dp_pio16_user2nic                            *
    774  *===========================================================================*/
    775 static void dp_pio16_user2nic(dep, iovp, offset, nic_addr, count)
    776 dpeth_t *dep;
    777 iovec_dat_t *iovp;
    778 vir_bytes offset;
    779 int nic_addr;
    780 vir_bytes count;
    781 {
    782         vir_bytes vir_user;
    783         vir_bytes ecount;
    784         int i, r, user_proc;
    785         vir_bytes bytes;
     769static void dp_pio16_user2nic(dpeth_t *dep, iovec_dat_t *iovp, size_t offset, int nic_addr, size_t count)
     770{
     771        void *vir_user;
     772        size_t ecount;
     773        int i, r;
     774        size_t bytes;
    786775        //uint8_t two_bytes[2];
    787776        uint16_t two_bytes;
    788777        int odd_byte;
    789 
    790         ecount= (count+1) &~1;
    791         odd_byte= 0;
    792 
     778       
     779        ecount = (count + 1) & ~1;
     780        odd_byte = 0;
     781       
    793782        outb_reg0(dep, DP_ISR, ISR_RDC);
    794         outb_reg0(dep, DP_RBCR0, ecount &0xFF);
     783        outb_reg0(dep, DP_RBCR0, ecount & 0xFF);
    795784        outb_reg0(dep, DP_RBCR1, ecount >> 8);
    796         outb_reg0(dep, DP_RSAR0, nic_addr &0xFF);
     785        outb_reg0(dep, DP_RSAR0, nic_addr & 0xFF);
    797786        outb_reg0(dep, DP_RSAR1, nic_addr >> 8);
    798787        outb_reg0(dep, DP_CR, CR_DM_RW | CR_PS_P0 | CR_STA);
    799 
    800         i= 0;
    801         while (count > 0)
    802         {
    803                 if (i >= IOVEC_NR)
    804                 {
     788       
     789        i = 0;
     790        while (count > 0) {
     791                if (i >= IOVEC_NR) {
    805792                        dp_next_iovec(iovp);
    806                         i= 0;
     793                        i = 0;
    807794                        continue;
    808795                }
     796               
    809797                assert(i < iovp->iod_iovec_s);
    810                 if (offset >= iovp->iod_iovec[i].iov_size)
    811                 {
     798               
     799                if (offset >= iovp->iod_iovec[i].iov_size) {
    812800                        offset -= iovp->iod_iovec[i].iov_size;
    813801                        i++;
    814802                        continue;
    815803                }
     804               
    816805                bytes = iovp->iod_iovec[i].iov_size - offset;
    817806                if (bytes > count)
    818807                        bytes = count;
    819 
    820                 user_proc= iovp->iod_proc_nr;
    821                 vir_user= iovp->iod_iovec[i].iov_addr + offset;
    822                 if (odd_byte)
    823                 {
    824                         r= sys_vircopy(user_proc, D, vir_user,
    825                         //      SELF, D, (vir_bytes)&two_bytes[1], 1);
    826                                 SELF, D, (vir_bytes)&(((uint8_t *)&two_bytes)[1]), 1);
     808               
     809                vir_user = iovp->iod_iovec[i].iov_addr + offset;
     810               
     811                if (odd_byte) {
     812                        r = sys_vircopy(user_proc, D, vir_user,
     813                        //      SELF, D, (vir_bytes) &two_bytes[1], 1);
     814                                SELF, D, &(((uint8_t *) &two_bytes)[1]), 1);
     815                       
    827816                        if (r != EOK)
    828817                                fprintf(stderr, "DP8390: dp_pio16_user2nic: sys_vircopy failed\n");
    829818                       
    830                         //outw(dep->de_data_port, *(uint16_t *)two_bytes);
     819                        //outw(dep->de_data_port, *(uint16_t *) two_bytes);
    831820                        outw(dep->de_data_port, two_bytes);
    832821                        count--;
    … …  
    835824                        vir_user++;
    836825                        odd_byte= 0;
     826                       
    837827                        if (!bytes)
    838828                                continue;
    839829                }
    840                 ecount= bytes &~1;
    841                 if (ecount != 0)
    842                 {
    843                         do_vir_outsw(dep->de_data_port, user_proc, vir_user,
    844                                 ecount);
     830               
     831                ecount= bytes & ~1;
     832                if (ecount != 0) {
     833                        do_vir_outsw(dep->de_data_port, vir_user, ecount);
    845834                        count -= ecount;
    846835                        offset += ecount;
    … …  
    848837                        vir_user += ecount;
    849838                }
    850                 if (bytes)
    851                 {
     839               
     840                if (bytes) {
    852841                        assert(bytes == 1);
    853                         r= sys_vircopy(user_proc, D, vir_user,
    854                         //      SELF, D, (vir_bytes)&two_bytes[0], 1);
    855                                 SELF, D, (vir_bytes)&(((uint8_t *)&two_bytes)[0]), 1);
     842                       
     843                        r = sys_vircopy(user_proc, D, vir_user,
     844                        //      SELF, D, (vir_bytes) &two_bytes[0], 1);
     845                                SELF, D, &(((uint8_t *) &two_bytes)[0]), 1);
     846                       
    856847                        if (r != EOK)
    857848                                fprintf(stderr, "DP8390: dp_pio16_user2nic: sys_vircopy failed\n");
    … …  
    864855                }
    865856        }
     857       
    866858        assert(count == 0);
    867 
     859       
    868860        if (odd_byte)
    869                 //outw(dep->de_data_port, *(uint16_t *)two_bytes);
     861                //outw(dep->de_data_port, *(uint16_t *) two_bytes);
    870862                outw(dep->de_data_port, two_bytes);
    871 
    872         for (i= 0; i<100; i++)
    873         {
     863       
     864        for (i = 0; i < 100; i++) {
    874865                if (inb_reg0(dep, DP_ISR) &ISR_RDC)
    875866                        break;
    876867        }
     868       
    877869        if (i == 100)
    878870                fprintf(stderr, "dp8390: remote dma failed to complete\n");
    879871}
    880872
    881 /*===========================================================================*
    882  *                              dp_pio8_nic2user                             *
    883  *===========================================================================*/
    884 static void dp_pio8_nic2user(dep, nic_addr, iovp, offset, count)
    885 dpeth_t *dep;
    886 int nic_addr;
    887 iovec_dat_t *iovp;
    888 vir_bytes offset;
    889 vir_bytes count;
     873static void dp_pio8_nic2user(dpeth_t *dep, int nic_addr, iovec_dat_t *iovp, size_t offset, size_t count)
    890874{
    891875//      phys_bytes phys_user;
    892876        int i;
    893         vir_bytes bytes;
    894 
    895         outb_reg0(dep, DP_RBCR0, count &0xFF);
     877        size_t bytes;
     878       
     879        outb_reg0(dep, DP_RBCR0, count & 0xFF);
    896880        outb_reg0(dep, DP_RBCR1, count >> 8);
    897         outb_reg0(dep, DP_RSAR0, nic_addr &0xFF);
     881        outb_reg0(dep, DP_RSAR0, nic_addr & 0xFF);
    898882        outb_reg0(dep, DP_RSAR1, nic_addr >> 8);
    899883        outb_reg0(dep, DP_CR, CR_DM_RR | CR_PS_P0 | CR_STA);
    900 
    901         i= 0;
    902         while (count > 0)
    903         {
    904                 if (i >= IOVEC_NR)
    905                 {
     884       
     885        i = 0;
     886        while (count > 0) {
     887                if (i >= IOVEC_NR) {
    906888                        dp_next_iovec(iovp);
    907889                        i= 0;
    908890                        continue;
    909891                }
     892               
    910893                assert(i < iovp->iod_iovec_s);
    911                 if (offset >= iovp->iod_iovec[i].iov_size)
    912                 {
     894               
     895                if (offset >= iovp->iod_iovec[i].iov_size) {
    913896                        offset -= iovp->iod_iovec[i].iov_size;
    914897                        i++;
    915898                        continue;
    916899                }
     900               
    917901                bytes = iovp->iod_iovec[i].iov_size - offset;
    918902                if (bytes > count)
    919903                        bytes = count;
    920 
    921                 do_vir_insb(dep->de_data_port, iovp->iod_proc_nr,
    922                         iovp->iod_iovec[i].iov_addr + offset, bytes);
     904               
     905                do_vir_insb(dep->de_data_port, iovp->iod_iovec[i].iov_addr + offset, bytes);
    923906                count -= bytes;
    924907                offset += bytes;
    925908        }
     909       
    926910        assert(count == 0);
    927911}
    928912
    929 /*===========================================================================*
    930  *                              dp_pio16_nic2user                            *
    931  *===========================================================================*/
    932 static void dp_pio16_nic2user(dep, nic_addr, iovp, offset, count)
    933 dpeth_t *dep;
    934 int nic_addr;
    935 iovec_dat_t *iovp;
    936 vir_bytes offset;
    937 vir_bytes count;
    938 {
    939         vir_bytes vir_user;
    940         vir_bytes ecount;
    941         int i, r, user_proc;
    942         vir_bytes bytes;
     913static void dp_pio16_nic2user(dpeth_t *dep, int nic_addr, iovec_dat_t *iovp, size_t offset, size_t count)
     914{
     915        void *vir_user;
     916        size_t ecount;
     917        int i, r;
     918        size_t bytes;
    943919        //uint8_t two_bytes[2];
    944920        uint16_t two_bytes;
    945921        int odd_byte;
    946 
    947         ecount= (count+1) &~1;
    948         odd_byte= 0;
    949 
    950         outb_reg0(dep, DP_RBCR0, ecount &0xFF);
     922       
     923        ecount = (count + 1) & ~1;
     924        odd_byte = 0;
     925       
     926        outb_reg0(dep, DP_RBCR0, ecount & 0xFF);
    951927        outb_reg0(dep, DP_RBCR1, ecount >> 8);
    952         outb_reg0(dep, DP_RSAR0, nic_addr &0xFF);
     928        outb_reg0(dep, DP_RSAR0, nic_addr & 0xFF);
    953929        outb_reg0(dep, DP_RSAR1, nic_addr >> 8);
    954930        outb_reg0(dep, DP_CR, CR_DM_RR | CR_PS_P0 | CR_STA);
    955 
    956         i= 0;
    957         while (count > 0)
    958         {
    959                 if (i >= IOVEC_NR)
    960                 {
     931       
     932        i = 0;
     933        while (count > 0) {
     934                if (i >= IOVEC_NR) {
    961935                        dp_next_iovec(iovp);
    962                         i= 0;
     936                        i = 0;
    963937                        continue;
    964938                }
     939               
    965940                assert(i < iovp->iod_iovec_s);
    966                 if (offset >= iovp->iod_iovec[i].iov_size)
    967                 {
     941               
     942                if (offset >= iovp->iod_iovec[i].iov_size) {
    968943                        offset -= iovp->iod_iovec[i].iov_size;
    969944                        i++;
    970945                        continue;
    971946                }
     947               
    972948                bytes = iovp->iod_iovec[i].iov_size - offset;
    973949                if (bytes > count)
    974950                        bytes = count;
    975 
    976                 user_proc= iovp->iod_proc_nr;
    977                 vir_user= iovp->iod_iovec[i].iov_addr + offset;
    978                 if (odd_byte)
    979                 {
     951               
     952                vir_user = iovp->iod_iovec[i].iov_addr + offset;
     953               
     954                if (odd_byte) {
    980955                        //r= sys_vircopy(SELF, D, (vir_bytes)&two_bytes[1],
    981                         r= sys_vircopy(SELF, D, (vir_bytes)&(((uint8_t *)&two_bytes)[1]),
    982                                 user_proc, D, vir_user, 1);
     956                        r= sys_vircopy(SELF, D, &(((uint8_t *) &two_bytes)[1]),
     957                            user_proc, D, vir_user, 1);
    983958                        if (r != EOK)
    984959                                fprintf(stderr, "DP8390: dp_pio16_nic2user: sys_vircopy failed\n");
    … …  
    989964                        vir_user++;
    990965                        odd_byte= 0;
     966                       
    991967                        if (!bytes)
    992968                                continue;
    993969                }
    994                 ecount= bytes &~1;
    995                 if (ecount != 0)
    996                 {
    997                         do_vir_insw(dep->de_data_port, user_proc, vir_user,
    998                                 ecount);
     970               
     971                ecount= bytes & ~1;
     972                if (ecount != 0) {
     973                        do_vir_insw(dep->de_data_port, vir_user, ecount);
    999974                        count -= ecount;
    1000975                        offset += ecount;
    … …  
    1002977                        vir_user += ecount;
    1003978                }
    1004                 if (bytes)
    1005                 {
     979               
     980                if (bytes) {
    1006981                        assert(bytes == 1);
    1007                         //*(uint16_t *)two_bytes= inw(dep->de_data_port);
    1008                         two_bytes= inw(dep->de_data_port);
    1009                         //r= sys_vircopy(SELF, D, (vir_bytes)&two_bytes[0],
    1010                         r= sys_vircopy(SELF, D, (vir_bytes)&(((uint8_t *)&two_bytes)[0]),
    1011                                 user_proc, D, vir_user,  1);
     982                       
     983                        //*(uint16_t *) two_bytes= inw(dep->de_data_port);
     984                        two_bytes = inw(dep->de_data_port);
     985                        //r= sys_vircopy(SELF, D, (vir_bytes) &two_bytes[0],
     986                        r = sys_vircopy(SELF, D, &(((uint8_t *) &two_bytes)[0]),
     987                            user_proc, D, vir_user,  1);
    1012988                        if (r != EOK)
    1013989                                fprintf(stderr, "DP8390: dp_pio16_nic2user: sys_vircopy failed\n");
    … …  
    1020996                }
    1021997        }
     998       
    1022999        assert(count == 0);
    10231000}
    10241001
    1025 /*===========================================================================*
    1026  *                              dp_next_iovec                                *
    1027  *===========================================================================*/
    1028 static void dp_next_iovec(iovp)
    1029 iovec_dat_t *iovp;
     1002static void dp_next_iovec(iovec_dat_t *iovp)
    10301003{
    10311004        assert(iovp->iod_iovec_s > IOVEC_NR);
    1032 
     1005       
    10331006        iovp->iod_iovec_s -= IOVEC_NR;
    1034 
    10351007        iovp->iod_iovec_addr += IOVEC_NR * sizeof(iovec_t);
    1036 
    1037         get_userdata(iovp->iod_proc_nr, iovp->iod_iovec_addr,
    1038                 (iovp->iod_iovec_s > IOVEC_NR ? IOVEC_NR : iovp->iod_iovec_s) *
    1039                 sizeof(iovec_t), iovp->iod_iovec);
    1040 }
    1041 
    1042 /*===========================================================================*
    1043  *                              conf_hw                                      *
    1044  *===========================================================================*/
    1045 static void conf_hw(dep)
    1046 dpeth_t *dep;
     1008       
     1009        memcpy(iovp->iod_iovec, iovp->iod_iovec_addr,
     1010            (iovp->iod_iovec_s > IOVEC_NR ? IOVEC_NR : iovp->iod_iovec_s) *
     1011            sizeof(iovec_t));
     1012}
     1013
     1014static void conf_hw(dpeth_t *dep)
    10471015{
    10481016//      static eth_stat_t empty_stat = {0, 0, 0, 0, 0, 0        /* ,... */};
    1049 
     1017       
    10501018//      int ifnr;
    10511019//      dp_conf_t *dcp;
    1052 
     1020       
    10531021//      dep->de_mode= DEM_DISABLED;     /* Superfluous */
    10541022//      ifnr= dep-de_table;
    1055 
     1023       
    10561024//      dcp= &dp_conf[ifnr];
    10571025//      update_conf(dep, dcp);
    10581026//      if (dep->de_mode != DEM_ENABLED)
    10591027//              return;
     1028       
    10601029        if (!ne_probe(dep)) {
    10611030                printf("%s: No ethernet card found at %#lx\n",
    … …  
    10641033                return;
    10651034        }
    1066 
    1067 /* XXX */ if (dep->de_linmem == 0) dep->de_linmem= 0xFFFF0000;
    1068 
     1035       
    10691036        dep->de_mode = DEM_ENABLED;
    1070 
    10711037        dep->de_flags = DEF_EMPTY;
    10721038//      dep->de_stat = empty_stat;
    10731039}
    10741040
    1075 /*===========================================================================*
    1076  *                              reply                                        *
    1077  *===========================================================================*/
    1078 static void reply(dep, err, may_block)
    1079 dpeth_t *dep;
    1080 int err;
    1081 int may_block;
     1041static void reply(dpeth_t *dep, int err, int may_block)
    10821042{
    10831043/*      message reply;
    10841044        int status;
    10851045        int r;
    1086 
     1046       
    10871047        status = 0;
    10881048        if (dep->de_flags &DEF_PACK_SEND)
    10891049                status |= DL_PACK_SEND;
     1050       
    10901051        if (dep->de_flags &DEF_PACK_RECV)
    10911052                status |= DL_PACK_RECV;
    1092 
     1053       
    10931054        reply.m_type = DL_TASK_REPLY;
    10941055        reply.DL_PORT = dep - de_table;
    … …  
    10961057        reply.DL_STAT = status | ((u32_t) err << 16);
    10971058        reply.DL_COUNT = dep->de_read_s;
    1098         reply.DL_CLCK = 0;      *//* Don't know */
    1099 /*      r= send(dep->de_client, &reply);
    1100 
    1101         if (r == ELOCKED && may_block)
    1102         {
    1103 #if 0
     1059        reply.DL_CLCK = 0;  *//* Don't know */
     1060       
     1061/*      r = send(dep->de_client, &reply);
     1062        if (r == ELOCKED && may_block) {
    11041063                printf("send locked\n");
    1105 #endif
    11061064                return;
    11071065        }
    1108 
     1066       
    11091067        if (r < 0)
    11101068                fprintf(stderr, "dp8390: send failed\n");
    … …  
    11141072}
    11151073
    1116 /*===========================================================================*
    1117  *                              get_userdata                                 *
    1118  *===========================================================================*/
    1119 static void get_userdata(user_proc, user_addr, count, loc_addr)
    1120 int user_proc;
    1121 vir_bytes user_addr;
    1122 vir_bytes count;
    1123 void *loc_addr;
    1124 {
    1125         int r;
    1126 
    1127         r= sys_vircopy(user_proc, D, user_addr,
    1128                 SELF, D, (vir_bytes)loc_addr, count);
    1129         if (r != EOK)
    1130                 fprintf(stderr, "DP8390: get_userdata: sys_vircopy failed\n");
    1131 }
    1132 
    11331074static void insb(port_t port, void *buf, size_t size)
    11341075{
    11351076        size_t i;
    1136 
    1137         for(i = 0; i < size; ++ i){
     1077       
     1078        for (i = 0; i < size; i++)
    11381079                *((uint8_t *) buf + i) = inb(port);
    1139         }
    11401080}
    11411081
    … …  
    11431083{
    11441084        size_t i;
    1145 
    1146         for(i = 0; i * 2 < size; ++ i){
     1085       
     1086        for (i = 0; i * 2 < size; i++)
    11471087                *((uint16_t *) buf + i) = inw(port);
    1148         }
    11491088}
    11501089
    … …  
    11521091{
    11531092        size_t i;
    1154 
    1155         for(i = 0; i < size; ++ i){
     1093       
     1094        for (i = 0; i < size; i++)
    11561095                outb(port, *((uint8_t *) buf + i));
    1157         }
    11581096}
    11591097
    … …  
    11611099{
    11621100        size_t i;
    1163 
    1164         for(i = 0; i * 2 < size; ++ i){
     1101       
     1102        for (i = 0; i * 2 < size; i++)
    11651103                outw(port, *((uint16_t *) buf + i));
    1166         }
    11671104}
    11681105

  • uspace/srv/hw/netif/dp8390/dp8390.h

    rb590c21 rd3a0af7  
    219219typedef void (*dp_initf_t)(struct dpeth *dep);
    220220typedef void (*dp_stopf_t)(struct dpeth *dep);
    221 typedef void (*dp_user2nicf_t)(struct dpeth *dep, struct iovec_dat *iovp, vir_bytes offset, int nic_addr, vir_bytes count);
    222 typedef void (*dp_nic2userf_t)(struct dpeth *dep, int nic_addr, struct iovec_dat *iovp, vir_bytes offset, vir_bytes count);
     221typedef void (*dp_user2nicf_t)(struct dpeth *dep, struct iovec_dat *iovp, size_t offset, int nic_addr, size_t count);
     222typedef void (*dp_nic2userf_t)(struct dpeth *dep, int nic_addr, struct iovec_dat *iovp, size_t offset, size_t count);
    223223typedef void (*dp_getblock_t)(struct dpeth *dep, int page, size_t offset, size_t size, void *dst);
    224224
    … …  
    228228  iovec_t iod_iovec[IOVEC_NR];
    229229  int iod_iovec_s;
    230   int iod_proc_nr;
    231   vir_bytes iod_iovec_addr;
     230  void *iod_iovec_addr;
    232231} iovec_dat_t;
    233232
    … …  
    254253        /*
    255254         * The de_base_port field is the starting point of the probe.
    256          * The conf routine also fills de_linmem and de_irq. If the probe
     255         * The conf routine also fills de_irq. If the probe
    257256         * routine knows the irq and/or memory address because they are
    258257         * hardwired in the board, the probe should modify these fields.
    … …  
    261260         */
    262261        port_t de_base_port;
    263         phys_bytes de_linmem;
    264262        int de_irq;
    265263        dp_initf_t de_initf;
    … …  
    300298        iovec_dat_t de_write_iovec;
    301299        iovec_dat_t de_tmp_iovec;
    302         vir_bytes de_read_s;
     300        size_t de_read_s;
    303301//      int de_client;
    304302//      message de_sendmsg;

  • uspace/srv/hw/netif/dp8390/dp8390_port.h

    rb590c21 rd3a0af7  
    9292/** Reads a memory block byte by byte.
    9393 *  @param[in] port The address to be written.
    94  *  @param proc The source process. Ignored parameter.
    9594 *  @param[in] dst The destination address.
    9695 *  @param[in] bytes The block size in bytes.
    9796 */
    98 #define do_vir_insb(port, proc, dst, bytes)     insb((port), (void *)(dst), (bytes))
     97#define do_vir_insb(port, dst, bytes)  insb((port), (void *)(dst), (bytes))
    9998
    10099/** Reads a memory block word by word (2 bytes).
    101100 *  @param[in] port The address to be written.
    102  *  @param proc The source process. Ignored parameter.
    103101 *  @param[in] dst The destination address.
    104102 *  @param[in] bytes The block size in bytes.
    105103 */
    106 #define do_vir_insw(port, proc, dst, bytes)     insw((port), (void *)(dst), (bytes))
     104#define do_vir_insw(port, dst, bytes)  insw((port), (void *)(dst), (bytes))
    107105
    108106/** Writes a memory block byte by byte.
    109107 *  @param[in] port The address to be written.
    110  *  @param proc The source process. Ignored parameter.
    111108 *  @param[in] src The source address.
    112109 *  @param[in] bytes The block size in bytes.
    113110 */
    114 #define do_vir_outsb(port, proc, src, bytes)    outsb((port), (void *)(src), (bytes))
     111#define do_vir_outsb(port, src, bytes)  outsb((port), (void *)(src), (bytes))
    115112
    116113/** Writes a memory block word by word (2 bytes).
    117114 *  @param[in] port The address to be written.
    118  *  @param proc The source process. Ignored parameter.
    119115 *  @param[in] src The source address.
    120116 *  @param[in] bytes The block size in bytes.
    121117 */
    122 #define do_vir_outsw(port, proc, src, bytes)    outsw((port), (void *)(src), (bytes))
     118#define do_vir_outsw(port, src, bytes)  outsw((port), (void *)(src), (bytes))
    123119
    124120/* Bits in 'DL_MODE' field of DL requests. */
    … …  
    208204} ether_addr_t;
    209205
    210 /* type.h */
    211 /** Type definition of the physical addresses and lengths in bytes.
    212  */
    213 typedef unsigned long phys_bytes;
    214 
    215 /** Type definition of the virtual addresses and lengths in bytes.
    216  */
    217 typedef unsigned long vir_bytes;
    218 
    219206/** Type definition of the input/output vector.
    220207 */
    … …  
    222209        /** Address of an I/O buffer.
    223210         */
    224         vir_bytes iov_addr;
    225         /** Sizeof an I/O buffer.
    226          */
    227         vir_bytes iov_size;
     211        void *iov_addr;
     212       
     213        /** Size of an I/O buffer.
     214         */
     215        size_t iov_size;
    228216} iovec_t;
    229217

  • uspace/srv/hw/netif/dp8390/ne2000.c

    rb590c21 rd3a0af7  
    110110                    f(dep, loc2, pat0) && f(dep, loc2, pat1) &&
    111111                    f(dep, loc2, pat2) && f(dep, loc2, pat3)) {
    112                         /* We don't need a memory segment */
    113                         dep->de_linmem = 0;
    114112                        dep->de_initf = ne_init;
    115113                        dep->de_stopf = ne_stop;
Note: See TracChangeset for help on using the changeset viewer.