Changeset a35b458 in mainline for uspace/drv/nic/e1k/e1k.c


Ignore:
Timestamp:
2018-03-02T20:10:49Z (7 years ago)
Author:
Jiří Zárevúcky <zarevucky.jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f1380b7
Parents:
3061bc1
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:38:31)
git-committer:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:10:49)
Message:

style: Remove trailing whitespace on _all_ lines, including empty ones, for particular file types.

Command used: tools/srepl '\s\+$' '' -- *.c *.h *.py *.sh *.s *.S *.ag

Currently, whitespace on empty lines is very inconsistent.
There are two basic choices: Either remove the whitespace, or keep empty lines
indented to the level of surrounding code. The former is AFAICT more common,
and also much easier to do automatically.

Alternatively, we could write script for automatic indentation, and use that
instead. However, if such a script exists, it's possible to use the indented
style locally, by having the editor apply relevant conversions on load/save,
without affecting remote repository. IMO, it makes more sense to adopt
the simpler rule.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/nic/e1k/e1k.c

    r3061bc1 ra35b458  
    122122        /** Device configuration */
    123123        e1000_info_t info;
    124        
     124
    125125        /** Physical registers base address */
    126126        void *reg_base_phys;
    127127        /** Virtual registers base address */
    128128        void *reg_base_virt;
    129        
     129
    130130        /** Physical tx ring address */
    131131        uintptr_t tx_ring_phys;
    132132        /** Virtual tx ring address */
    133133        void *tx_ring_virt;
    134        
     134
    135135        /** Ring of TX frames, physical address */
    136136        uintptr_t *tx_frame_phys;
    137137        /** Ring of TX frames, virtual address */
    138138        void **tx_frame_virt;
    139        
     139
    140140        /** Physical rx ring address */
    141141        uintptr_t rx_ring_phys;
    142142        /** Virtual rx ring address */
    143143        void *rx_ring_virt;
    144        
     144
    145145        /** Ring of RX frames, physical address */
    146146        uintptr_t *rx_frame_phys;
    147147        /** Ring of RX frames, virtual address */
    148148        void **rx_frame_virt;
    149        
     149
    150150        /** VLAN tag */
    151151        uint16_t vlan_tag;
    152        
     152
    153153        /** Add VLAN tag to frame */
    154154        bool vlan_tag_add;
    155        
     155
    156156        /** Used unicast Receive Address count */
    157157        unsigned int unicast_ra_count;
    158        
     158
    159159        /** Used milticast Receive addrress count */
    160160        unsigned int multicast_ra_count;
    161        
     161
    162162        /** The irq assigned */
    163163        int irq;
    164        
     164
    165165        /** Lock for CTRL register */
    166166        fibril_mutex_t ctrl_lock;
    167        
     167
    168168        /** Lock for receiver */
    169169        fibril_mutex_t rx_lock;
    170        
     170
    171171        /** Lock for transmitter */
    172172        fibril_mutex_t tx_lock;
    173        
     173
    174174        /** Lock for EEPROM access */
    175175        fibril_mutex_t eeprom_lock;
    … …  
    292292        assert(dev);
    293293        assert(info);
    294        
     294
    295295        memset(info, 0, sizeof(nic_device_info_t));
    296        
     296
    297297        info->vendor_id = 0x8086;
    298298        str_cpy(info->vendor_name, NIC_VENDOR_MAX_LENGTH,
    … …  
    300300        str_cpy(info->model_name, NIC_MODEL_MAX_LENGTH,
    301301            "Intel Pro");
    302        
     302
    303303        info->ethernet_support[ETH_10M] = ETH_10BASE_T;
    304304        info->ethernet_support[ETH_100M] = ETH_100BASE_TX;
    305305        info->ethernet_support[ETH_1000M] = ETH_1000BASE_T;
    306        
     306
    307307        return EOK;
    308308}
    … …  
    323323        else
    324324                *state = NIC_CS_UNPLUGGED;
    325        
     325
    326326        return EOK;
    327327}
    … …  
    340340        e1000_t *e1000 = DRIVER_DATA_FUN(fun);
    341341        uint32_t status = E1000_REG_READ(e1000, E1000_STATUS);
    342        
     342
    343343        if (status & STATUS_FD)
    344344                *duplex = NIC_CM_FULL_DUPLEX;
    345345        else
    346346                *duplex = NIC_CM_HALF_DUPLEX;
    347        
     347
    348348        uint32_t speed_bits =
    349349            (status >> STATUS_SPEED_SHIFT) & STATUS_SPEED_ALL;
    350        
     350
    351351        if (speed_bits == STATUS_SPEED_10)
    352352                *speed = 10;
    … …  
    356356            (speed_bits == STATUS_SPEED_1000B))
    357357                *speed = 1000;
    358        
     358
    359359        *role = NIC_ROLE_UNKNOWN;
    360360        return EOK;
    … …  
    364364{
    365365        fibril_mutex_lock(&e1000->ctrl_lock);
    366        
     366
    367367        uint32_t ctrl = E1000_REG_READ(e1000, E1000_CTRL);
    368        
     368
    369369        if (ctrl & CTRL_SLU) {
    370370                ctrl &= ~(CTRL_SLU);
    371371                E1000_REG_WRITE(e1000, E1000_CTRL, ctrl);
    372372                fibril_mutex_unlock(&e1000->ctrl_lock);
    373                
     373
    374374                async_usleep(10);
    375                
     375
    376376                fibril_mutex_lock(&e1000->ctrl_lock);
    377377                ctrl = E1000_REG_READ(e1000, E1000_CTRL);
    … …  
    379379                E1000_REG_WRITE(e1000, E1000_CTRL, ctrl);
    380380        }
    381        
     381
    382382        fibril_mutex_unlock(&e1000->ctrl_lock);
    383383}
    … …  
    391391        if ((speed != 10) && (speed != 100) && (speed != 1000))
    392392                return EINVAL;
    393        
     393
    394394        if ((duplex != NIC_CM_HALF_DUPLEX) && (duplex != NIC_CM_FULL_DUPLEX))
    395395                return EINVAL;
    396        
     396
    397397        e1000_t *e1000 = DRIVER_DATA_FUN(fun);
    398        
     398
    399399        fibril_mutex_lock(&e1000->ctrl_lock);
    400400        uint32_t ctrl = E1000_REG_READ(e1000, E1000_CTRL);
    401        
     401
    402402        ctrl |= CTRL_FRCSPD;
    403403        ctrl |= CTRL_FRCDPLX;
    404404        ctrl &= ~(CTRL_ASDE);
    405        
     405
    406406        if (duplex == NIC_CM_FULL_DUPLEX)
    407407                ctrl |= CTRL_FD;
    408408        else
    409409                ctrl &= ~(CTRL_FD);
    410        
     410
    411411        ctrl &= ~(CTRL_SPEED_MASK);
    412412        if (speed == 1000)
    … …  
    416416        else
    417417                ctrl |= CTRL_SPEED_10 << CTRL_SPEED_SHIFT;
    418        
     418
    419419        E1000_REG_WRITE(e1000, E1000_CTRL, ctrl);
    420        
     420
    421421        fibril_mutex_unlock(&e1000->ctrl_lock);
    422        
     422
    423423        e1000_link_restart(e1000);
    424        
     424
    425425        return EOK;
    426426}
    … …  
    437437{
    438438        e1000_t *e1000 = DRIVER_DATA_FUN(fun);
    439        
     439
    440440        fibril_mutex_lock(&e1000->ctrl_lock);
    441        
     441
    442442        uint32_t ctrl = E1000_REG_READ(e1000, E1000_CTRL);
    443        
     443
    444444        ctrl &= ~(CTRL_FRCSPD);
    445445        ctrl &= ~(CTRL_FRCDPLX);
    446446        ctrl |= CTRL_ASDE;
    447        
     447
    448448        E1000_REG_WRITE(e1000, E1000_CTRL, ctrl);
    449        
     449
    450450        fibril_mutex_unlock(&e1000->ctrl_lock);
    451        
     451
    452452        e1000_link_restart(e1000);
    453        
     453
    454454        return EOK;
    455455}
    … …  
    465465{
    466466        e1000_t *e1000 = DRIVER_DATA_FUN(fun);
    467        
     467
    468468        fibril_mutex_lock(&e1000->ctrl_lock);
    469        
     469
    470470        uint32_t ctrl = E1000_REG_READ(e1000, E1000_CTRL);
    471        
     471
    472472        ctrl |= CTRL_FRCSPD;
    473473        ctrl |= CTRL_FRCDPLX;
    474474        ctrl &= ~(CTRL_ASDE);
    475        
     475
    476476        E1000_REG_WRITE(e1000, E1000_CTRL, ctrl);
    477        
     477
    478478        fibril_mutex_unlock(&e1000->ctrl_lock);
    479        
     479
    480480        e1000_link_restart(e1000);
    481        
     481
    482482        return EOK;
    483483}
    … …  
    504504{
    505505        e1000_t *e1000 = DRIVER_DATA_FUN(fun);
    506        
     506
    507507        *mode = 0;
    508508        uint32_t rctl = E1000_REG_READ(e1000, E1000_RCTL);
    509509        if (rctl & RCTL_SBP)
    510510                *mode = NIC_DEFECTIVE_BAD_CRC | NIC_DEFECTIVE_SHORT;
    511        
     511
    512512        return EOK;
    513513};
    … …  
    526526        e1000_t *e1000 = DRIVER_DATA_FUN(fun);
    527527        errno_t rc = EOK;
    528        
     528
    529529        fibril_mutex_lock(&e1000->rx_lock);
    530        
     530
    531531        uint32_t rctl = E1000_REG_READ(e1000, E1000_RCTL);
    532532        bool short_mode = (mode & NIC_DEFECTIVE_SHORT ? true : false);
    533533        bool bad_mode = (mode & NIC_DEFECTIVE_BAD_CRC ? true : false);
    534        
     534
    535535        if (short_mode && bad_mode)
    536536                rctl |= RCTL_SBP;
    … …  
    539539        else
    540540                rc = ENOTSUP;
    541        
     541
    542542        E1000_REG_WRITE(e1000, E1000_RCTL, rctl);
    543        
     543
    544544        fibril_mutex_unlock(&e1000->rx_lock);
    545545        return rc;
    … …  
    563563        uint8_t *mac4 = (uint8_t *) address->address + 4;
    564564        uint8_t *mac5 = (uint8_t *) address->address + 5;
    565        
     565
    566566        uint32_t rah;
    567567        uint32_t ral;
    568        
     568
    569569        ral = ((*mac3) << 24) | ((*mac2) << 16) | ((*mac1) << 8) | (*mac0);
    570570        rah = ((*mac5) << 8) | ((*mac4));
    571        
     571
    572572        if (set_av_bit)
    573573                rah |= RAH_AV;
    574574        else
    575575                rah |= E1000_REG_READ(e1000, E1000_RAH_ARRAY(position)) & RAH_AV;
    576        
     576
    577577        E1000_REG_WRITE(e1000, E1000_RAH_ARRAY(position), rah);
    578578        E1000_REG_WRITE(e1000, E1000_RAL_ARRAY(position), ral);
    … …  
    605605            ra_num++)
    606606                e1000_disable_receive_address(e1000, ra_num);
    607        
     607
    608608        e1000->unicast_ra_count = 0;
    609609}
    … …  
    618618        unsigned int first_multicast_ra_num =
    619619            E1000_RECEIVE_ADDRESS - e1000->multicast_ra_count;
    620        
     620
    621621        for (unsigned int ra_num = E1000_RECEIVE_ADDRESS - 1;
    622622            ra_num >= first_multicast_ra_num;
    623623            ra_num--)
    624624                e1000_disable_receive_address(e1000, ra_num);
    625        
     625
    626626        e1000->multicast_ra_count = 0;
    627627}
    … …  
    662662{
    663663        assert(addr_cnt <= get_free_unicast_address_count(e1000));
    664        
     664
    665665        nic_address_t *addr_iterator = (nic_address_t *) addr;
    666        
     666
    667667        /* ra_num = 0 is primary address */
    668668        for (unsigned int ra_num = 1;
    … …  
    685685{
    686686        assert(addr_cnt <= get_free_multicast_address_count(e1000));
    687        
     687
    688688        nic_address_t *addr_iterator = (nic_address_t *) addr;
    689        
     689
    690690        unsigned int first_multicast_ra_num = E1000_RECEIVE_ADDRESS - addr_cnt;
    691691        for (unsigned int ra_num = E1000_RECEIVE_ADDRESS - 1;
    … …  
    832832        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    833833        errno_t rc = EOK;
    834        
     834
    835835        fibril_mutex_lock(&e1000->rx_lock);
    836        
     836
    837837        switch (mode) {
    838838        case NIC_MULTICAST_BLOCKED:
    … …  
    866866                break;
    867867        }
    868        
     868
    869869        fibril_mutex_unlock(&e1000->rx_lock);
    870870        return rc;
    … …  
    886886        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    887887        errno_t rc = EOK;
    888        
     888
    889889        fibril_mutex_lock(&e1000->rx_lock);
    890        
     890
    891891        switch (mode) {
    892892        case NIC_UNICAST_BLOCKED:
    … …  
    924924                break;
    925925        }
    926        
     926
    927927        fibril_mutex_unlock(&e1000->rx_lock);
    928928        return rc;
    … …  
    941941        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    942942        errno_t rc = EOK;
    943        
     943
    944944        fibril_mutex_lock(&e1000->rx_lock);
    945        
     945
    946946        switch (mode) {
    947947        case NIC_BROADCAST_BLOCKED:
    … …  
    955955                break;
    956956        }
    957        
     957
    958958        fibril_mutex_unlock(&e1000->rx_lock);
    959959        return rc;
    … …  
    971971        if (E1000_REG_READ(e1000, E1000_RCTL) & (RCTL_EN))
    972972                return true;
    973        
     973
    974974        return false;
    975975}
    … …  
    10091009{
    10101010        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    1011        
     1011
    10121012        fibril_mutex_lock(&e1000->rx_lock);
    1013        
     1013
    10141014        if (vlan_mask) {
    10151015                /*
    … …  
    10201020                if (rx_enabled)
    10211021                        e1000_disable_rx(e1000);
    1022                
     1022
    10231023                for (unsigned int i = 0; i < NIC_VLAN_BITMAP_SIZE; i += 4) {
    10241024                        uint32_t bitmap_part =
    … …  
    10291029                        E1000_REG_WRITE(e1000, E1000_VFTA_ARRAY(i / 4), bitmap_part);
    10301030                }
    1031                
     1031
    10321032                e1000_enable_vlan_filter(e1000);
    10331033                if (rx_enabled)
    … …  
    10351035        } else
    10361036                e1000_disable_vlan_filter(e1000);
    1037        
     1037
    10381038        fibril_mutex_unlock(&e1000->rx_lock);
    10391039}
    … …  
    10541054        if (tag & VLANTAG_CFI)
    10551055                return ENOTSUP;
    1056        
     1056
    10571057        /*
    10581058         * CTRL.VME is neccessary for both strip and add
    … …  
    10611061        if (!strip && add)
    10621062                return ENOTSUP;
    1063        
     1063
    10641064        e1000_t *e1000 = DRIVER_DATA_FUN(fun);
    1065        
     1065
    10661066        e1000->vlan_tag = tag;
    10671067        e1000->vlan_tag_add = add;
    1068        
     1068
    10691069        fibril_mutex_lock(&e1000->ctrl_lock);
    1070        
     1070
    10711071        uint32_t ctrl = E1000_REG_READ(e1000, E1000_CTRL);
    10721072        if (strip)
    … …  
    10741074        else
    10751075                ctrl &= ~CTRL_VME;
    1076        
     1076
    10771077        E1000_REG_WRITE(e1000, E1000_CTRL, ctrl);
    1078        
     1078
    10791079        fibril_mutex_unlock(&e1000->ctrl_lock);
    10801080        return EOK;
    … …  
    10921092{
    10931093        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    1094        
     1094
    10951095        e1000_rx_descriptor_t *rx_descriptor = (e1000_rx_descriptor_t *)
    10961096            (e1000->rx_ring_virt + offset * sizeof(e1000_rx_descriptor_t));
    1097        
     1097
    10981098        rx_descriptor->phys_addr = PTR_TO_U64(e1000->rx_frame_phys[offset]);
    10991099        rx_descriptor->length = 0;
    … …  
    11141114        e1000_rx_descriptor_t *rx_descriptor = (e1000_rx_descriptor_t *)
    11151115            (e1000->rx_ring_virt + offset * sizeof(e1000_rx_descriptor_t));
    1116        
     1116
    11171117        rx_descriptor->length = 0;
    11181118        rx_descriptor->checksum = 0;
    … …  
    11311131{
    11321132        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    1133        
     1133
    11341134        e1000_tx_descriptor_t *tx_descriptor = (e1000_tx_descriptor_t *)
    11351135            (e1000->tx_ring_virt + offset * sizeof(e1000_tx_descriptor_t));
    1136        
     1136
    11371137        tx_descriptor->phys_addr = 0;
    11381138        tx_descriptor->length = 0;
    … …  
    11681168{
    11691169        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    1170        
     1170
    11711171        fibril_mutex_lock(&e1000->rx_lock);
    1172        
     1172
    11731173        uint32_t *tail_addr = E1000_REG_ADDR(e1000, E1000_RDT);
    11741174        uint32_t next_tail = e1000_inc_tail(*tail_addr, E1000_RX_FRAME_COUNT);
    1175        
     1175
    11761176        e1000_rx_descriptor_t *rx_descriptor = (e1000_rx_descriptor_t *)
    11771177            (e1000->rx_ring_virt + next_tail * sizeof(e1000_rx_descriptor_t));
    1178        
     1178
    11791179        while (rx_descriptor->status & 0x01) {
    11801180                uint32_t frame_size = rx_descriptor->length - E1000_CRC_SIZE;
    1181                
     1181
    11821182                nic_frame_t *frame = nic_alloc_frame(nic, frame_size);
    11831183                if (frame != NULL) {
    … …  
    11871187                        ddf_msg(LVL_ERROR, "Memory allocation failed. Frame dropped.");
    11881188                }
    1189                
     1189
    11901190                e1000_fill_new_rx_descriptor(nic, next_tail);
    1191                
     1191
    11921192                *tail_addr = e1000_inc_tail(*tail_addr, E1000_RX_FRAME_COUNT);
    11931193                next_tail = e1000_inc_tail(*tail_addr, E1000_RX_FRAME_COUNT);
    1194                
     1194
    11951195                rx_descriptor = (e1000_rx_descriptor_t *)
    11961196                    (e1000->rx_ring_virt + next_tail * sizeof(e1000_rx_descriptor_t));
    11971197        }
    1198        
     1198
    11991199        fibril_mutex_unlock(&e1000->rx_lock);
    12001200}
    … …  
    12471247        nic_t *nic = NIC_DATA_DEV(dev);
    12481248        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    1249        
     1249
    12501250        e1000_interrupt_handler_impl(nic, icr);
    12511251        e1000_enable_interrupts(e1000);
    … …  
    12671267{
    12681268        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    1269        
     1269
    12701270        /* Lock the mutex in whole driver while working with global structure */
    12711271        fibril_mutex_lock(&irq_reg_mutex);
    1272        
     1272
    12731273        e1000_irq_code.ranges[0].base = (uintptr_t) e1000->reg_base_phys;
    12741274        e1000_irq_code.cmds[0].addr = e1000->reg_base_phys + E1000_ICR;
    12751275        e1000_irq_code.cmds[2].addr = e1000->reg_base_phys + E1000_IMC;
    1276        
     1276
    12771277        errno_t rc = register_interrupt_handler(nic_get_ddf_dev(nic), e1000->irq,
    12781278            e1000_interrupt_handler, &e1000_irq_code, handle);
    1279        
     1279
    12801280        fibril_mutex_unlock(&irq_reg_mutex);
    12811281        return rc;
    … …  
    12901290{
    12911291        assert(nic);
    1292        
     1292
    12931293        e1000_t *e1000 = nic_get_specific(nic);
    12941294        assert(e1000);
    1295        
     1295
    12961296        uint32_t icr = E1000_REG_READ(e1000, E1000_ICR);
    12971297        e1000_interrupt_handler_impl(nic, icr);
    … …  
    13231323{
    13241324        assert(nic);
    1325        
     1325
    13261326        e1000_t *e1000 = nic_get_specific(nic);
    13271327        assert(e1000);
    1328        
     1328
    13291329        switch (mode) {
    13301330        case NIC_POLL_IMMEDIATE:
    … …  
    13441344                return ENOTSUP;
    13451345        }
    1346        
     1346
    13471347        return EOK;
    13481348}
    … …  
    13571357        E1000_REG_WRITE(e1000, E1000_RDLEN, E1000_RX_FRAME_COUNT * 16);
    13581358        E1000_REG_WRITE(e1000, E1000_RDH, 0);
    1359        
     1359
    13601360        /* It is not posible to let HW use all descriptors */
    13611361        E1000_REG_WRITE(e1000, E1000_RDT, E1000_RX_FRAME_COUNT - 1);
    1362        
     1362
    13631363        /* Set Broadcast Enable Bit */
    13641364        E1000_REG_WRITE(e1000, E1000_RCTL, RCTL_BAM);
    … …  
    13771377        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    13781378        fibril_mutex_lock(&e1000->rx_lock);
    1379        
     1379
    13801380        e1000->rx_ring_virt = AS_AREA_ANY;
    13811381        errno_t rc = dmamem_map_anonymous(
    … …  
    13851385        if (rc != EOK)
    13861386                return rc;
    1387        
     1387
    13881388        E1000_REG_WRITE(e1000, E1000_RDBAH,
    13891389            (uint32_t) (PTR_TO_U64(e1000->rx_ring_phys) >> 32));
    13901390        E1000_REG_WRITE(e1000, E1000_RDBAL,
    13911391            (uint32_t) PTR_TO_U64(e1000->rx_ring_phys));
    1392        
     1392
    13931393        e1000->rx_frame_phys = (uintptr_t *)
    13941394            calloc(E1000_RX_FRAME_COUNT, sizeof(uintptr_t));
    … …  
    13991399                goto error;
    14001400        }
    1401        
     1401
    14021402        for (size_t i = 0; i < E1000_RX_FRAME_COUNT; i++) {
    14031403                uintptr_t frame_phys;
    14041404                void *frame_virt = AS_AREA_ANY;
    1405                
     1405
    14061406                rc = dmamem_map_anonymous(E1000_MAX_SEND_FRAME_SIZE,
    14071407                    DMAMEM_4GiB, AS_AREA_READ | AS_AREA_WRITE, 0,
    … …  
    14091409                if (rc != EOK)
    14101410                        goto error;
    1411                
     1411
    14121412                e1000->rx_frame_phys[i] = frame_phys;
    14131413                e1000->rx_frame_virt[i] = frame_virt;
    14141414        }
    1415        
     1415
    14161416        /* Write descriptor */
    14171417        for (size_t i = 0; i < E1000_RX_FRAME_COUNT; i++)
    14181418                e1000_fill_new_rx_descriptor(nic, i);
    1419        
     1419
    14201420        e1000_initialize_rx_registers(e1000);
    1421        
     1421
    14221422        fibril_mutex_unlock(&e1000->rx_lock);
    14231423        return EOK;
    1424        
     1424
    14251425error:
    14261426        for (size_t i = 0; i < E1000_RX_FRAME_COUNT; i++) {
    … …  
    14311431                }
    14321432        }
    1433        
     1433
    14341434        if (e1000->rx_frame_phys != NULL) {
    14351435                free(e1000->rx_frame_phys);
    14361436                e1000->rx_frame_phys = NULL;
    14371437        }
    1438        
     1438
    14391439        if (e1000->rx_frame_virt != NULL) {
    14401440                free(e1000->rx_frame_virt);
    14411441                e1000->rx_frame_virt = NULL;
    14421442        }
    1443        
     1443
    14441444        return rc;
    14451445}
    … …  
    14531453{
    14541454        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    1455        
     1455
    14561456        /* Write descriptor */
    14571457        for (unsigned int offset = 0; offset < E1000_RX_FRAME_COUNT; offset++) {
    … …  
    14601460                e1000->rx_frame_virt[offset] = NULL;
    14611461        }
    1462        
     1462
    14631463        free(e1000->rx_frame_virt);
    1464        
     1464
    14651465        e1000->rx_frame_phys = NULL;
    14661466        e1000->rx_frame_virt = NULL;
    1467        
     1467
    14681468        dmamem_unmap_anonymous(e1000->rx_ring_virt);
    14691469}
    … …  
    15501550        E1000_REG_WRITE(e1000, E1000_TDH, 0);
    15511551        E1000_REG_WRITE(e1000, E1000_TDT, 0);
    1552        
     1552
    15531553        E1000_REG_WRITE(e1000, E1000_TIPG,
    15541554            10 << TIPG_IPGT_SHIFT |
    15551555            8 << TIPG_IPGR1_SHIFT |
    15561556            6 << TIPG_IPGR2_SHIFT);
    1557        
     1557
    15581558        E1000_REG_WRITE(e1000, E1000_TCTL,
    15591559            0x0F << TCTL_CT_SHIFT /* Collision Threshold */ |
    … …  
    15701570{
    15711571        size_t i;
    1572        
     1572
    15731573        fibril_mutex_lock(&e1000->tx_lock);
    1574        
     1574
    15751575        e1000->tx_ring_phys = 0;
    15761576        e1000->tx_ring_virt = AS_AREA_ANY;
    1577        
     1577
    15781578        e1000->tx_frame_phys = NULL;
    15791579        e1000->tx_frame_virt = NULL;
    1580        
     1580
    15811581        errno_t rc = dmamem_map_anonymous(
    15821582            E1000_TX_FRAME_COUNT * sizeof(e1000_tx_descriptor_t),
    … …  
    15851585        if (rc != EOK)
    15861586                goto error;
    1587        
     1587
    15881588        memset(e1000->tx_ring_virt, 0,
    15891589            E1000_TX_FRAME_COUNT * sizeof(e1000_tx_descriptor_t));
    1590        
     1590
    15911591        e1000->tx_frame_phys = (uintptr_t *)
    15921592            calloc(E1000_TX_FRAME_COUNT, sizeof(uintptr_t));
    … …  
    15981598                goto error;
    15991599        }
    1600        
     1600
    16011601        for (i = 0; i < E1000_TX_FRAME_COUNT; i++) {
    16021602                e1000->tx_frame_virt[i] = AS_AREA_ANY;
    … …  
    16071607                        goto error;
    16081608        }
    1609        
     1609
    16101610        E1000_REG_WRITE(e1000, E1000_TDBAH,
    16111611            (uint32_t) (PTR_TO_U64(e1000->tx_ring_phys) >> 32));
    16121612        E1000_REG_WRITE(e1000, E1000_TDBAL,
    16131613            (uint32_t) PTR_TO_U64(e1000->tx_ring_phys));
    1614        
     1614
    16151615        e1000_initialize_tx_registers(e1000);
    1616        
     1616
    16171617        fibril_mutex_unlock(&e1000->tx_lock);
    16181618        return EOK;
    1619        
     1619
    16201620error:
    16211621        if (e1000->tx_ring_virt != NULL) {
    … …  
    16231623                e1000->tx_ring_virt = NULL;
    16241624        }
    1625        
     1625
    16261626        if ((e1000->tx_frame_phys != NULL) && (e1000->tx_frame_virt != NULL)) {
    16271627                for (i = 0; i < E1000_TX_FRAME_COUNT; i++) {
    … …  
    16331633                }
    16341634        }
    1635        
     1635
    16361636        if (e1000->tx_frame_phys != NULL) {
    16371637                free(e1000->tx_frame_phys);
    16381638                e1000->tx_frame_phys = NULL;
    16391639        }
    1640        
     1640
    16411641        if (e1000->tx_frame_virt != NULL) {
    16421642                free(e1000->tx_frame_virt);
    16431643                e1000->tx_frame_virt = NULL;
    16441644        }
    1645        
     1645
    16461646        return rc;
    16471647}
    … …  
    16551655{
    16561656        size_t i;
    1657        
     1657
    16581658        for (i = 0; i < E1000_TX_FRAME_COUNT; i++) {
    16591659                dmamem_unmap_anonymous(e1000->tx_frame_virt[i]);
    … …  
    16611661                e1000->tx_frame_virt[i] = NULL;
    16621662        }
    1663        
     1663
    16641664        if (e1000->tx_frame_phys != NULL) {
    16651665                free(e1000->tx_frame_phys);
    16661666                e1000->tx_frame_phys = NULL;
    16671667        }
    1668        
     1668
    16691669        if (e1000->tx_frame_virt != NULL) {
    16701670                free(e1000->tx_frame_virt);
    16711671                e1000->tx_frame_virt = NULL;
    16721672        }
    1673        
     1673
    16741674        dmamem_unmap_anonymous(e1000->tx_ring_virt);
    16751675}
    … …  
    17211721{
    17221722        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    1723        
     1723
    17241724        E1000_REG_WRITE(e1000, E1000_CTRL, CTRL_RST);
    1725        
     1725
    17261726        /* Wait for the reset */
    17271727        async_usleep(20);
    1728        
     1728
    17291729        /* check if RST_BIT cleared */
    17301730        if (E1000_REG_READ(e1000, E1000_CTRL) & (CTRL_RST))
    17311731                return EINVAL;
    1732        
     1732
    17331733        e1000_initialize_registers(e1000);
    17341734        e1000_initialize_rx_registers(e1000);
    … …  
    17371737        e1000_initialize_filters(e1000);
    17381738        e1000_initialize_vlan(e1000);
    1739        
     1739
    17401740        return EOK;
    17411741}
    … …  
    17521752{
    17531753        assert(nic);
    1754        
     1754
    17551755        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    1756        
     1756
    17571757        fibril_mutex_lock(&e1000->rx_lock);
    17581758        fibril_mutex_lock(&e1000->tx_lock);
    17591759        fibril_mutex_lock(&e1000->ctrl_lock);
    1760        
     1760
    17611761        e1000_enable_interrupts(e1000);
    1762        
     1762
    17631763        errno_t rc = hw_res_enable_interrupt(e1000->parent_sess, e1000->irq);
    17641764        if (rc != EOK) {
    … …  
    17691769                return rc;
    17701770        }
    1771        
     1771
    17721772        e1000_clear_rx_ring(e1000);
    17731773        e1000_enable_rx(e1000);
    1774        
     1774
    17751775        e1000_clear_tx_ring(nic);
    17761776        e1000_enable_tx(e1000);
    1777        
     1777
    17781778        uint32_t ctrl = E1000_REG_READ(e1000, E1000_CTRL);
    17791779        ctrl |= CTRL_SLU;
    17801780        E1000_REG_WRITE(e1000, E1000_CTRL, ctrl);
    1781        
     1781
    17821782        fibril_mutex_unlock(&e1000->ctrl_lock);
    17831783        fibril_mutex_unlock(&e1000->tx_lock);
    17841784        fibril_mutex_unlock(&e1000->rx_lock);
    1785        
     1785
    17861786        return EOK;
    17871787}
    … …  
    17981798{
    17991799        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    1800        
     1800
    18011801        uint32_t ctrl = E1000_REG_READ(e1000, E1000_CTRL);
    18021802        ctrl &= ~CTRL_SLU;
    18031803        E1000_REG_WRITE(e1000, E1000_CTRL, ctrl);
    1804        
     1804
    18051805        e1000_disable_tx(e1000);
    18061806        e1000_disable_rx(e1000);
    1807        
     1807
    18081808        hw_res_disable_interrupt(e1000->parent_sess, e1000->irq);
    18091809        e1000_disable_interrupts(e1000);
    1810        
     1810
    18111811        /*
    18121812         * Wait for the for the end of all data
    … …  
    18141814         */
    18151815        async_usleep(100);
    1816        
     1816
    18171817        return EOK;
    18181818}
    … …  
    18291829{
    18301830        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    1831        
     1831
    18321832        fibril_mutex_lock(&e1000->rx_lock);
    18331833        fibril_mutex_lock(&e1000->tx_lock);
    18341834        fibril_mutex_lock(&e1000->ctrl_lock);
    1835        
     1835
    18361836        errno_t rc = e1000_on_down_unlocked(nic);
    1837        
     1837
    18381838        fibril_mutex_unlock(&e1000->ctrl_lock);
    18391839        fibril_mutex_unlock(&e1000->tx_lock);
    18401840        fibril_mutex_unlock(&e1000->rx_lock);
    1841        
     1841
    18421842        return rc;
    18431843}
    … …  
    18541854{
    18551855        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    1856        
     1856
    18571857        fibril_mutex_lock(&e1000->rx_lock);
    18581858        fibril_mutex_lock(&e1000->tx_lock);
    18591859        fibril_mutex_lock(&e1000->ctrl_lock);
    1860        
     1860
    18611861        errno_t rc = e1000_on_down_unlocked(nic);
    18621862        if (rc == EOK)
    18631863                rc = e1000_reset(nic);
    1864        
     1864
    18651865        fibril_mutex_unlock(&e1000->ctrl_lock);
    18661866        fibril_mutex_unlock(&e1000->tx_lock);
    18671867        fibril_mutex_unlock(&e1000->rx_lock);
    1868        
     1868
    18691869        return rc;
    18701870}
    … …  
    18801880        if (!nic)
    18811881                return NULL;
    1882        
     1882
    18831883        e1000_t *e1000 = malloc(sizeof(e1000_t));
    18841884        if (!e1000) {
    … …  
    18861886                return NULL;
    18871887        }
    1888        
     1888
    18891889        memset(e1000, 0, sizeof(e1000_t));
    18901890        e1000->dev = dev;
    1891        
     1891
    18921892        nic_set_specific(nic, e1000);
    18931893        nic_set_send_frame_handler(nic, e1000_send_frame);
    … …  
    18981898            e1000_on_broadcast_mode_change, NULL, e1000_on_vlan_mask_change);
    18991899        nic_set_poll_handlers(nic, e1000_poll_mode_change, e1000_poll);
    1900        
     1900
    19011901        fibril_mutex_initialize(&e1000->ctrl_lock);
    19021902        fibril_mutex_initialize(&e1000->rx_lock);
    19031903        fibril_mutex_initialize(&e1000->tx_lock);
    19041904        fibril_mutex_initialize(&e1000->eeprom_lock);
    1905        
     1905
    19061906        return e1000;
    19071907}
    … …  
    19151915{
    19161916        assert(dev);
    1917        
     1917
    19181918        if (ddf_dev_data_get(dev) != NULL)
    19191919                nic_unbind_and_destroy(dev);
    … …  
    19281928{
    19291929        assert(dev);
    1930        
     1930
    19311931        e1000_delete_dev_data(dev);
    19321932}
    … …  
    19471947{
    19481948        e1000_t *e1000 = DRIVER_DATA_DEV(dev);
    1949        
     1949
    19501950        if (hw_resources->irqs.count != 1)
    19511951                return EINVAL;
    1952        
     1952
    19531953        e1000->irq = hw_resources->irqs.irqs[0];
    19541954        e1000->reg_base_phys =
    19551955            MEMADDR_TO_PTR(RNGABS(hw_resources->mem_ranges.ranges[0]));
    1956        
     1956
    19571957        return EOK;
    19581958}
    … …  
    19721972        assert(dev != NULL);
    19731973        assert(NIC_DATA_DEV(dev) != NULL);
    1974        
     1974
    19751975        hw_res_list_parsed_t hw_res_parsed;
    19761976        hw_res_list_parsed_init(&hw_res_parsed);
    1977        
     1977
    19781978        /* Get hw resources form parent driver */
    19791979        errno_t rc = nic_get_resources(NIC_DATA_DEV(dev), &hw_res_parsed);
    19801980        if (rc != EOK)
    19811981                return rc;
    1982        
     1982
    19831983        /* Fill resources information to the device */
    19841984        rc = e1000_fill_resource_info(dev, &hw_res_parsed);
    19851985        hw_res_list_parsed_clean(&hw_res_parsed);
    1986        
     1986
    19871987        return rc;
    19881988}
    … …  
    20042004                return ENOMEM;
    20052005        }
    2006        
     2006
    20072007        e1000->parent_sess = ddf_dev_parent_sess_get(dev);
    20082008        if (e1000->parent_sess == NULL) {
    … …  
    20102010                return EIO;
    20112011        }
    2012        
     2012
    20132013        /* Obtain and fill hardware resources info */
    20142014        errno_t rc = e1000_get_resource_info(dev);
    … …  
    20182018                return rc;
    20192019        }
    2020        
     2020
    20212021        uint16_t device_id;
    20222022        rc = pci_config_space_read_16(ddf_dev_parent_sess_get(dev), PCI_DEVICE_ID,
    … …  
    20272027                return rc;
    20282028        }
    2029        
     2029
    20302030        e1000_board_t board;
    20312031        switch (device_id) {
    … …  
    20772077                return ENOTSUP;
    20782078        }
    2079        
     2079
    20802080        switch (board) {
    20812081        case E1000_82540:
    … …  
    20982098                break;
    20992099        }
    2100        
     2100
    21012101        return EOK;
    21022102}
    … …  
    21132113{
    21142114        e1000_t *e1000 = DRIVER_DATA_DEV(dev);
    2115        
     2115
    21162116        errno_t rc = pio_enable(e1000->reg_base_phys, 8 * PAGE_SIZE,
    21172117            &e1000->reg_base_virt);
    21182118        if (rc != EOK)
    21192119                return EADDRNOTAVAIL;
    2120        
     2120
    21212121        return EOK;
    21222122}
    … …  
    21302130{
    21312131        ddf_fun_t *fun;
    2132        
     2132
    21332133        /* Initialize device structure for E1000 */
    21342134        errno_t rc = e1000_device_initialize(dev);
    21352135        if (rc != EOK)
    21362136                return rc;
    2137        
     2137
    21382138        /* Device initialization */
    21392139        nic_t *nic = ddf_dev_data_get(dev);
    21402140        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    2141        
     2141
    21422142        /* Map registers */
    21432143        rc = e1000_pio_enable(dev);
    21442144        if (rc != EOK)
    21452145                goto err_destroy;
    2146        
     2146
    21472147        e1000_initialize_registers(e1000);
    21482148        rc = e1000_initialize_tx_structure(e1000);
    21492149        if (rc != EOK)
    21502150                goto err_pio;
    2151        
     2151
    21522152        fibril_mutex_lock(&e1000->rx_lock);
    2153        
     2153
    21542154        e1000_fill_mac_from_eeprom(e1000);
    21552155        e1000_initialize_filters(e1000);
    2156        
     2156
    21572157        fibril_mutex_unlock(&e1000->rx_lock);
    2158        
     2158
    21592159        e1000_initialize_vlan(e1000);
    2160        
     2160
    21612161        fun = ddf_fun_create(nic_get_ddf_dev(nic), fun_exposed, "port0");
    21622162        if (fun == NULL)
    … …  
    21642164        nic_set_ddf_fun(nic, fun);
    21652165        ddf_fun_set_ops(fun, &e1000_dev_ops);
    2166        
     2166
    21672167        int irq_cap;
    21682168        rc = e1000_register_int_handler(nic, &irq_cap);
    … …  
    21702170                goto err_fun_create;
    21712171        }
    2172        
     2172
    21732173        rc = e1000_initialize_rx_structure(nic);
    21742174        if (rc != EOK)
    21752175                goto err_irq;
    2176        
     2176
    21772177        nic_address_t e1000_address;
    21782178        e1000_get_address(e1000, &e1000_address);
    … …  
    21802180        if (rc != EOK)
    21812181                goto err_rx_structure;
    2182        
     2182
    21832183        struct timeval period;
    21842184        period.tv_sec = 0;
    … …  
    21872187        if (rc != EOK)
    21882188                goto err_rx_structure;
    2189        
     2189
    21902190        rc = ddf_fun_bind(fun);
    21912191        if (rc != EOK)
    21922192                goto err_fun_bind;
    2193        
     2193
    21942194        rc = ddf_fun_add_to_category(fun, DEVICE_CATEGORY_NIC);
    21952195        if (rc != EOK)
    21962196                goto err_add_to_cat;
    2197        
     2197
    21982198        return EOK;
    2199        
     2199
    22002200err_add_to_cat:
    22012201        ddf_fun_unbind(fun);
    … …  
    22302230{
    22312231        fibril_mutex_lock(&e1000->eeprom_lock);
    2232        
     2232
    22332233        /* Write address and START bit to EERD register */
    22342234        uint32_t write_data = e1000->info.eerd_start |
    … …  
    22362236            e1000->info.eerd_address_offset);
    22372237        E1000_REG_WRITE(e1000, E1000_EERD, write_data);
    2238        
     2238
    22392239        uint32_t eerd = E1000_REG_READ(e1000, E1000_EERD);
    22402240        while ((eerd & e1000->info.eerd_done) == 0) {
    … …  
    22422242                eerd = E1000_REG_READ(e1000, E1000_EERD);
    22432243        }
    2244        
     2244
    22452245        fibril_mutex_unlock(&e1000->eeprom_lock);
    2246        
     2246
    22472247        return (uint16_t) (eerd >> e1000->info.eerd_data_offset);
    22482248}
    … …  
    22612261{
    22622262        fibril_mutex_lock(&e1000->rx_lock);
    2263        
     2263
    22642264        uint8_t *mac0_dest = (uint8_t *) address->address;
    22652265        uint8_t *mac1_dest = (uint8_t *) address->address + 1;
    … …  
    22682268        uint8_t *mac4_dest = (uint8_t *) address->address + 4;
    22692269        uint8_t *mac5_dest = (uint8_t *) address->address + 5;
    2270        
     2270
    22712271        uint32_t rah = E1000_REG_READ(e1000, E1000_RAH_ARRAY(0));
    22722272        uint32_t ral = E1000_REG_READ(e1000, E1000_RAL_ARRAY(0));
    2273        
     2273
    22742274        *mac0_dest = (uint8_t) ral;
    22752275        *mac1_dest = (uint8_t) (ral >> 8);
    … …  
    22782278        *mac4_dest = (uint8_t) rah;
    22792279        *mac5_dest = (uint8_t) (rah >> 8);
    2280        
     2280
    22812281        fibril_mutex_unlock(&e1000->rx_lock);
    22822282        return EOK;
    … …  
    22952295        nic_t *nic = NIC_DATA_FUN(fun);
    22962296        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    2297        
     2297
    22982298        fibril_mutex_lock(&e1000->rx_lock);
    22992299        fibril_mutex_lock(&e1000->tx_lock);
    2300        
     2300
    23012301        errno_t rc = nic_report_address(nic, addr);
    23022302        if (rc == EOK)
    23032303                e1000_write_receive_address(e1000, 0, addr, false);
    2304        
     2304
    23052305        fibril_mutex_unlock(&e1000->tx_lock);
    23062306        fibril_mutex_unlock(&e1000->rx_lock);
    2307        
     2307
    23082308        return rc;
    23092309}
    … …  
    23152315        uint16_t *mac2_dest = (uint16_t *) (address->address + 2);
    23162316        uint16_t *mac4_dest = (uint16_t *) (address->address + 4);
    2317        
     2317
    23182318        *mac0_dest = e1000_eeprom_read(e1000, 0);
    23192319        *mac2_dest = e1000_eeprom_read(e1000, 1);
    … …  
    23342334{
    23352335        assert(nic);
    2336        
     2336
    23372337        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    23382338        fibril_mutex_lock(&e1000->tx_lock);
    2339        
     2339
    23402340        uint32_t tdt = E1000_REG_READ(e1000, E1000_TDT);
    23412341        e1000_tx_descriptor_t *tx_descriptor_addr = (e1000_tx_descriptor_t *)
    23422342            (e1000->tx_ring_virt + tdt * sizeof(e1000_tx_descriptor_t));
    2343        
     2343
    23442344        bool descriptor_available = false;
    2345        
     2345
    23462346        /* Descriptor never used */
    23472347        if (tx_descriptor_addr->length == 0)
    23482348                descriptor_available = true;
    2349        
     2349
    23502350        /* Descriptor done */
    23512351        if (tx_descriptor_addr->status & TXDESCRIPTOR_STATUS_DD)
    23522352                descriptor_available = true;
    2353        
     2353
    23542354        if (!descriptor_available) {
    23552355                /* Frame lost */
    … …  
    23572357                return;
    23582358        }
    2359        
     2359
    23602360        memcpy(e1000->tx_frame_virt[tdt], data, size);
    2361        
     2361
    23622362        tx_descriptor_addr->phys_addr = PTR_TO_U64(e1000->tx_frame_phys[tdt]);
    23632363        tx_descriptor_addr->length = size;
    2364        
     2364
    23652365        /*
    23662366         * Report status to STATUS.DD (descriptor done),
    … …  
    23702370            TXDESCRIPTOR_COMMAND_IFCS |
    23712371            TXDESCRIPTOR_COMMAND_EOP;
    2372        
     2372
    23732373        tx_descriptor_addr->checksum_offset = 0;
    23742374        tx_descriptor_addr->status = 0;
    … …  
    23782378        } else
    23792379                tx_descriptor_addr->special = 0;
    2380        
     2380
    23812381        tx_descriptor_addr->checksum_start_field = 0;
    2382        
     2382
    23832383        tdt++;
    23842384        if (tdt == E1000_TX_FRAME_COUNT)
    23852385                tdt = 0;
    2386        
     2386
    23872387        E1000_REG_WRITE(e1000, E1000_TDT, tdt);
    2388        
     2388
    23892389        fibril_mutex_unlock(&e1000->tx_lock);
    23902390}
    … …  
    23932393{
    23942394        printf("%s: HelenOS E1000 network adapter driver\n", NAME);
    2395        
     2395
    23962396        if (nic_driver_init(NAME) != EOK)
    23972397                return 1;
    2398        
     2398
    23992399        nic_driver_implement(&e1000_driver_ops, &e1000_dev_ops,
    24002400            &e1000_nic_iface);
    2401        
     2401
    24022402        ddf_log_init(NAME);
    24032403        return ddf_driver_main(&e1000_driver);
Note: See TracChangeset for help on using the changeset viewer.