Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    rc4be33a r9916841  
    7070
    7171/** nic_driver_data_t* -> e1000_t* cast */
    72 #define DRIVER_DATA_NIC(nic) \
    73         ((e1000_t *) nic_get_specific(nic))
     72#define DRIVER_DATA_NIC(nic_data) \
     73        ((e1000_t *) nic_get_specific(nic_data))
    7474
    7575/** device_t* -> nic_driver_data_t* cast */
    … …  
    9797#define MEMADDR_TO_PTR(memaddr)  ((void *) ((size_t) (memaddr)))
    9898
    99 #define E1000_REG_BASE(e1000) \
    100         ((e1000)->reg_base_virt)
    101 
    102 #define E1000_REG_ADDR(e1000, reg) \
    103         ((uint32_t *) (E1000_REG_BASE(e1000) + reg))
    104 
    105 #define E1000_REG_READ(e1000, reg) \
    106         (pio_read_32(E1000_REG_ADDR(e1000, reg)))
    107 
    108 #define E1000_REG_WRITE(e1000, reg, value) \
    109         (pio_write_32(E1000_REG_ADDR(e1000, reg), value))
     99#define E1000_REG_BASE(e1000_data) \
     100        ((e1000_data)->virt_reg_base)
     101
     102#define E1000_REG_ADDR(e1000_data, reg) \
     103        ((uint32_t *) (E1000_REG_BASE(e1000_data) + reg))
     104
     105#define E1000_REG_READ(e1000_data, reg) \
     106        (pio_read_32(E1000_REG_ADDR(e1000_data, reg)))
     107
     108#define E1000_REG_WRITE(e1000_data, reg, value) \
     109        (pio_write_32(E1000_REG_ADDR(e1000_data, reg), value))
    110110
    111111/** E1000 device data */
    112 typedef struct {
     112typedef struct e1000_data {
    113113        /** Physical registers base address */
    114         void *reg_base_phys;
     114        void *phys_reg_base;
    115115        /** Virtual registers base address */
    116         void *reg_base_virt;
    117        
    118         /** Physical tx ring address */
    119         void *tx_ring_phys;
    120         /** Virtual tx ring address */
    121         void *tx_ring_virt;
    122        
     116        void *virt_reg_base;
     117        /** Tx ring */
     118        dmamem_t tx_ring;
    123119        /** Packets in tx ring  */
    124120        packet_t **tx_ring_packets;
    125        
    126         /** Physical rx ring address */
    127         void *rx_ring_phys;
    128         /** Virtual rx ring address */
    129         void *rx_ring_virt;
    130        
     121        /** Rx ring */
     122        dmamem_t rx_ring;
    131123        /** Packets in rx ring  */
    132124        packet_t **rx_ring_packets;
    133        
    134125        /** VLAN tag */
    135126        uint16_t vlan_tag;
    136        
    137127        /** Add VLAN tag to packet */
    138128        bool vlan_tag_add;
    139        
    140129        /** Used unicast Receive Address count */
    141130        unsigned int unicast_ra_count;
    142        
    143131        /** Used milticast Receive addrress count */
    144132        unsigned int multicast_ra_count;
    145        
    146133        /** PCI device ID */
    147134        uint16_t device_id;
    148        
    149135        /** The irq assigned */
    150136        int irq;
    151        
    152137        /** Lock for CTRL register */
    153138        fibril_mutex_t ctrl_lock;
    154        
    155139        /** Lock for receiver */
    156140        fibril_mutex_t rx_lock;
    157        
    158141        /** Lock for transmitter */
    159142        fibril_mutex_t tx_lock;
    160        
    161143        /** Lock for EEPROM access */
    162144        fibril_mutex_t eeprom_lock;
    … …  
    243225                .cmd = CMD_PIO_WRITE_32,
    244226                .addr = NULL,
    245                 .value = 0xffffffff
     227                .value = 0xFFFFFFFF
    246228        },
    247229        {
    … …  
    298280        assert(state);
    299281       
    300         e1000_t *e1000 = DRIVER_DATA_DEV(dev);
    301         if (E1000_REG_READ(e1000, E1000_STATUS) & (STATUS_LU))
     282        e1000_t *e1000_data = DRIVER_DATA_DEV(dev);
     283        if (E1000_REG_READ(e1000_data, E1000_STATUS) & (STATUS_LU))
    302284                *state = NIC_CS_PLUGGED;
    303285        else
    … …  
    318300    nic_channel_mode_t *duplex, nic_role_t *role)
    319301{
    320         e1000_t *e1000 = DRIVER_DATA_DEV(dev);
    321         uint32_t status = E1000_REG_READ(e1000, E1000_STATUS);
     302        e1000_t *e1000_data = DRIVER_DATA_DEV(dev);
     303        uint32_t status = E1000_REG_READ(e1000_data, E1000_STATUS);
    322304       
    323305        if (status & STATUS_FD)
    … …  
    341323}
    342324
    343 static void e1000_link_restart(e1000_t *e1000)
    344 {
    345         fibril_mutex_lock(&e1000->ctrl_lock);
    346        
    347         uint32_t ctrl = E1000_REG_READ(e1000, E1000_CTRL);
     325static void e1000_link_restart(e1000_t * e1000_data)
     326{
     327        fibril_mutex_lock(&e1000_data->ctrl_lock);
     328       
     329        uint32_t ctrl = E1000_REG_READ(e1000_data, E1000_CTRL);
    348330       
    349331        if (ctrl & CTRL_SLU) {
    350332                ctrl &= ~(CTRL_SLU);
    351                 fibril_mutex_unlock(&e1000->ctrl_lock);
     333                fibril_mutex_unlock(&e1000_data->ctrl_lock);
    352334                usleep(10);
    353                 fibril_mutex_lock(&e1000->ctrl_lock);
     335                fibril_mutex_lock(&e1000_data->ctrl_lock);
    354336                ctrl |= CTRL_SLU;
    355337        }
    356338       
    357         fibril_mutex_unlock(&e1000->ctrl_lock);
    358        
    359         e1000_link_restart(e1000);
     339        fibril_mutex_unlock(&e1000_data->ctrl_lock);
     340       
     341        e1000_link_restart(e1000_data);
    360342}
    361343
    … …  
    372354                return EINVAL;
    373355       
    374         e1000_t *e1000 = DRIVER_DATA_DEV(dev);
    375        
    376         fibril_mutex_lock(&e1000->ctrl_lock);
    377         uint32_t ctrl = E1000_REG_READ(e1000, E1000_CTRL);
     356        e1000_t *e1000_data = DRIVER_DATA_DEV(dev);
     357       
     358        fibril_mutex_lock(&e1000_data->ctrl_lock);
     359        uint32_t ctrl = E1000_REG_READ(e1000_data, E1000_CTRL);
    378360       
    379361        ctrl |= CTRL_FRCSPD;
    … …  
    394376                ctrl |= CTRL_SPEED_10 << CTRL_SPEED_SHIFT;
    395377       
    396         E1000_REG_WRITE(e1000, E1000_CTRL, ctrl);
    397        
    398         fibril_mutex_unlock(&e1000->ctrl_lock);
    399        
    400         e1000_link_restart(e1000);
     378        E1000_REG_WRITE(e1000_data, E1000_CTRL, ctrl);
     379       
     380        fibril_mutex_unlock(&e1000_data->ctrl_lock);
     381       
     382        e1000_link_restart(e1000_data);
    401383       
    402384        return EOK;
    … …  
    413395static int e1000_autoneg_enable(ddf_fun_t *dev, uint32_t advertisement)
    414396{
    415         e1000_t *e1000 = DRIVER_DATA_DEV(dev);
    416        
    417         fibril_mutex_lock(&e1000->ctrl_lock);
    418        
    419         uint32_t ctrl = E1000_REG_READ(e1000, E1000_CTRL);
     397        e1000_t *e1000_data = DRIVER_DATA_DEV(dev);
     398       
     399        fibril_mutex_lock(&e1000_data->ctrl_lock);
     400       
     401        uint32_t ctrl = E1000_REG_READ(e1000_data, E1000_CTRL);
    420402       
    421403        ctrl &= ~(CTRL_FRCSPD);
    … …  
    423405        ctrl |= CTRL_ASDE;
    424406       
    425         E1000_REG_WRITE(e1000, E1000_CTRL, ctrl);
    426        
    427         fibril_mutex_unlock(&e1000->ctrl_lock);
    428        
    429         e1000_link_restart(e1000);
     407        E1000_REG_WRITE(e1000_data, E1000_CTRL, ctrl);
     408       
     409        fibril_mutex_unlock(&e1000_data->ctrl_lock);
     410       
     411        e1000_link_restart(e1000_data);
    430412       
    431413        return EOK;
    … …  
    441423static int e1000_autoneg_disable(ddf_fun_t *dev)
    442424{
    443         e1000_t *e1000 = DRIVER_DATA_DEV(dev);
    444        
    445         fibril_mutex_lock(&e1000->ctrl_lock);
    446        
    447         uint32_t ctrl = E1000_REG_READ(e1000, E1000_CTRL);
     425        e1000_t *e1000_data = DRIVER_DATA_DEV(dev);
     426       
     427        fibril_mutex_lock(&e1000_data->ctrl_lock);
     428       
     429        uint32_t ctrl = E1000_REG_READ(e1000_data, E1000_CTRL);
    448430       
    449431        ctrl |= CTRL_FRCSPD;
    … …  
    451433        ctrl &= ~(CTRL_ASDE);
    452434       
    453         E1000_REG_WRITE(e1000, E1000_CTRL, ctrl);
    454        
    455         fibril_mutex_unlock(&e1000->ctrl_lock);
    456        
    457         e1000_link_restart(e1000);
     435        E1000_REG_WRITE(e1000_data, E1000_CTRL, ctrl);
     436       
     437        fibril_mutex_unlock(&e1000_data->ctrl_lock);
     438       
     439        e1000_link_restart(e1000_data);
    458440       
    459441        return EOK;
    … …  
    480462static int e1000_defective_get_mode(ddf_fun_t *device, uint32_t *mode)
    481463{
    482         e1000_t *e1000 = DRIVER_DATA_DEV(device);
     464        e1000_t *e1000_data = DRIVER_DATA_DEV(device);
    483465       
    484466        *mode = 0;
    485         uint32_t rctl = E1000_REG_READ(e1000, E1000_RCTL);
     467        uint32_t rctl = E1000_REG_READ(e1000_data, E1000_RCTL);
    486468        if (rctl & RCTL_SBP)
    487469                *mode = NIC_DEFECTIVE_BAD_CRC | NIC_DEFECTIVE_SHORT;
    … …  
    501483static int e1000_defective_set_mode(ddf_fun_t *device, uint32_t mode)
    502484{
    503         e1000_t *e1000 = DRIVER_DATA_DEV(device);
     485        e1000_t *e1000_data = DRIVER_DATA_DEV(device);
    504486        int rc = EOK;
    505487       
    506         fibril_mutex_lock(&e1000->rx_lock);
    507        
    508         uint32_t rctl = E1000_REG_READ(e1000, E1000_RCTL);
     488        fibril_mutex_lock(&e1000_data->rx_lock);
     489       
     490        uint32_t rctl = E1000_REG_READ(e1000_data, E1000_RCTL);
    509491        bool short_mode = (mode & NIC_DEFECTIVE_SHORT ? true : false);
    510492        bool bad_mode = (mode & NIC_DEFECTIVE_BAD_CRC ? true : false);
    … …  
    517499                rc = ENOTSUP;
    518500       
    519         E1000_REG_WRITE(e1000, E1000_RCTL, rctl);
    520        
    521         fibril_mutex_unlock(&e1000->rx_lock);
     501        E1000_REG_WRITE(e1000_data, E1000_RCTL, rctl);
     502       
     503        fibril_mutex_unlock(&e1000_data->rx_lock);
    522504        return rc;
    523505};
    … …  
    525507/** Write receive address to RA registr
    526508 *
    527  * @param e1000      E1000 data structure
     509 * @param e1000_data E1000 data structure
    528510 * @param position   RA register position
    529511 * @param address    Ethernet address
    … …  
    531513 *
    532514 */
    533 static void e1000_write_receive_address(e1000_t *e1000, unsigned int position,
    534     const nic_address_t * address, bool set_av_bit)
     515static void e1000_write_receive_address(e1000_t *e1000_data,
     516    unsigned int position, const nic_address_t * address,
     517    bool set_av_bit)
    535518{
    536519        uint8_t *mac0 = (uint8_t *) address->address;
    … …  
    550533                rah |= RAH_AV;
    551534        else
    552                 rah |= E1000_REG_READ(e1000, E1000_RAH_ARRAY(position)) & RAH_AV;
    553        
    554         E1000_REG_WRITE(e1000, E1000_RAH_ARRAY(position), rah);
    555         E1000_REG_WRITE(e1000, E1000_RAL_ARRAY(position), ral);
     535                rah |= E1000_REG_READ(e1000_data, E1000_RAH_ARRAY(position)) &
     536                    RAH_AV;
     537       
     538        E1000_REG_WRITE(e1000_data, E1000_RAH_ARRAY(position), rah);
     539        E1000_REG_WRITE(e1000_data, E1000_RAL_ARRAY(position), ral);
    556540}
    557541
    … …  
    560544 *  Clear Address Valid bit
    561545 *
    562  * @param e1000    E1000 data structure
    563  * @param position RA register position
    564  *
    565  */
    566 static void e1000_disable_receive_address(e1000_t *e1000, unsigned int position)
    567 {
    568         uint32_t rah = E1000_REG_READ(e1000, E1000_RAH_ARRAY(position));
     546 * @param e1000_data E1000 data structure
     547 * @param position   RA register position
     548 *
     549 */
     550static void e1000_disable_receive_address(e1000_t *e1000_data,
     551    unsigned int position)
     552{
     553        uint32_t rah =
     554            E1000_REG_READ(e1000_data, E1000_RAH_ARRAY(position));
    569555        rah = rah & ~RAH_AV;
    570         E1000_REG_WRITE(e1000, E1000_RAH_ARRAY(position), rah);
     556        E1000_REG_WRITE(e1000_data, E1000_RAH_ARRAY(position), rah);
    571557}
    572558
    573559/** Clear all unicast addresses from RA registers
    574560 *
    575  * @param e1000 E1000 data structure
    576  *
    577  */
    578 static void e1000_clear_unicast_receive_addresses(e1000_t *e1000)
     561 * @param e1000_data E1000 data structure
     562 *
     563 */
     564static void e1000_clear_unicast_receive_addresses(e1000_t *e1000_data)
    579565{
    580566        for (unsigned int ra_num = 1;
    581             ra_num <= e1000->unicast_ra_count;
     567            ra_num <= e1000_data->unicast_ra_count;
    582568            ra_num++)
    583                 e1000_disable_receive_address(e1000, ra_num);
    584        
    585         e1000->unicast_ra_count = 0;
     569                e1000_disable_receive_address(e1000_data, ra_num);
     570       
     571        e1000_data->unicast_ra_count = 0;
    586572}
    587573
    588574/** Clear all multicast addresses from RA registers
    589575 *
    590  * @param e1000 E1000 data structure
    591  *
    592  */
    593 static void e1000_clear_multicast_receive_addresses(e1000_t *e1000)
     576 * @param e1000_data E1000 data structure
     577 *
     578 */
     579static void e1000_clear_multicast_receive_addresses(e1000_t *e1000_data)
    594580{
    595581        unsigned int first_multicast_ra_num =
    596             E1000_RECEIVE_ADDRESS - e1000->multicast_ra_count;
     582            E1000_RECEIVE_ADDRESS - e1000_data->multicast_ra_count;
    597583       
    598584        for (unsigned int ra_num = E1000_RECEIVE_ADDRESS - 1;
    599585            ra_num >= first_multicast_ra_num;
    600586            ra_num--)
    601                 e1000_disable_receive_address(e1000, ra_num);
    602        
    603         e1000->multicast_ra_count = 0;
     587                e1000_disable_receive_address(e1000_data, ra_num);
     588       
     589        e1000_data->multicast_ra_count = 0;
    604590}
    605591
    606592/** Return receive address filter positions count usable for unicast
    607593 *
    608  * @param e1000 E1000 data structure
     594 * @param e1000_data E1000 data structure
    609595 *
    610596 * @return receive address filter positions count usable for unicast
    611597 *
    612598 */
    613 static unsigned int get_free_unicast_address_count(e1000_t *e1000)
    614 {
    615         return E1000_RECEIVE_ADDRESS - 1 - e1000->multicast_ra_count;
     599static unsigned int get_free_unicast_address_count(e1000_t *e1000_data)
     600{
     601        return E1000_RECEIVE_ADDRESS - 1 - e1000_data->multicast_ra_count;
    616602}
    617603
    618604/** Return receive address filter positions count usable for multicast
    619605 *
    620  * @param e1000 E1000 data structure
     606 * @param e1000_data E1000 data structure
    621607 *
    622608 * @return receive address filter positions count usable for multicast
    623609 *
    624610 */
    625 static unsigned int get_free_multicast_address_count(e1000_t *e1000)
    626 {
    627         return E1000_RECEIVE_ADDRESS - 1 - e1000->unicast_ra_count;
     611static unsigned int get_free_multicast_address_count(e1000_t *e1000_data)
     612{
     613        return E1000_RECEIVE_ADDRESS - 1 - e1000_data->unicast_ra_count;
    628614}
    629615
    630616/** Write unicast receive addresses to receive address filter registers
    631617 *
    632  * @param e1000    E1000 data structure
    633  * @param addr     Pointer to address array
    634  * @param addr_cnt Address array count
    635  *
    636  */
    637 static void e1000_add_unicast_receive_addresses(e1000_t *e1000,
     618 * @param e1000_data E1000 data structure
     619 * @param addr       Pointer to address array
     620 * @param addr_cnt   Address array count
     621 *
     622 */
     623static void e1000_add_unicast_receive_addresses(e1000_t *e1000_data,
    638624    const nic_address_t *addr, size_t addr_cnt)
    639625{
    640         assert(addr_cnt <= get_free_unicast_address_count(e1000));
     626        assert(addr_cnt <= get_free_unicast_address_count(e1000_data));
    641627       
    642628        nic_address_t *addr_iterator = (nic_address_t *) addr;
    … …  
    646632            ra_num <= addr_cnt;
    647633            ra_num++) {
    648                 e1000_write_receive_address(e1000, ra_num, addr_iterator, true);
     634                e1000_write_receive_address(e1000_data, ra_num, addr_iterator, true);
    649635                addr_iterator++;
    650636        }
    … …  
    653639/** Write multicast receive addresses to receive address filter registers
    654640 *
    655  * @param e1000    E1000 data structure
    656  * @param addr     Pointer to address array
    657  * @param addr_cnt Address array count
    658  *
    659  */
    660 static void e1000_add_multicast_receive_addresses(e1000_t *e1000,
     641 * @param e1000_data E1000 data structure
     642 * @param addr       Pointer to address array
     643 * @param addr_cnt   Address array count
     644 *
     645 */
     646static void e1000_add_multicast_receive_addresses(e1000_t *e1000_data,
    661647    const nic_address_t *addr, size_t addr_cnt)
    662648{
    663         assert(addr_cnt <= get_free_multicast_address_count(e1000));
     649        assert(addr_cnt <= get_free_multicast_address_count(e1000_data));
    664650       
    665651        nic_address_t *addr_iterator = (nic_address_t *) addr;
    … …  
    669655            ra_num >= first_multicast_ra_num;
    670656            ra_num--) {
    671                 e1000_write_receive_address(e1000, ra_num, addr_iterator, true);
     657                e1000_write_receive_address(e1000_data, ra_num, addr_iterator, true);
    672658                addr_iterator++;
    673659        }
    … …  
    676662/** Disable receiving packets for default address
    677663 *
    678  * @param e1000 E1000 data structure
    679  *
    680  */
    681 static void disable_ra0_address_filter(e1000_t *e1000)
    682 {
    683         uint32_t rah0 = E1000_REG_READ(e1000, E1000_RAH_ARRAY(0));
     664 * @param e1000_data E1000 data structure
     665 *
     666 */
     667static void disable_ra0_address_filter(e1000_t *e1000_data)
     668{
     669        uint32_t rah0 = E1000_REG_READ(e1000_data, E1000_RAH_ARRAY(0));
    684670        rah0 = rah0 & ~RAH_AV;
    685         E1000_REG_WRITE(e1000, E1000_RAH_ARRAY(0), rah0);
     671        E1000_REG_WRITE(e1000_data, E1000_RAH_ARRAY(0), rah0);
    686672}
    687673
    688674/** Enable receiving packets for default address
    689675 *
    690  * @param e1000 E1000 data structure
    691  *
    692  */
    693 static void enable_ra0_address_filter(e1000_t *e1000)
    694 {
    695         uint32_t rah0 = E1000_REG_READ(e1000, E1000_RAH_ARRAY(0));
     676 * @param e1000_data E1000 data structure
     677 *
     678 */
     679static void enable_ra0_address_filter(e1000_t *e1000_data)
     680{
     681        uint32_t rah0 = E1000_REG_READ(e1000_data, E1000_RAH_ARRAY(0));
    696682        rah0 = rah0 | RAH_AV;
    697         E1000_REG_WRITE(e1000, E1000_RAH_ARRAY(0), rah0);
     683        E1000_REG_WRITE(e1000_data, E1000_RAH_ARRAY(0), rah0);
    698684}
    699685
    700686/** Disable unicast promiscuous mode
    701687 *
    702  * @param e1000 E1000 data structure
    703  *
    704  */
    705 static void e1000_disable_unicast_promisc(e1000_t *e1000)
    706 {
    707         uint32_t rctl = E1000_REG_READ(e1000, E1000_RCTL);
     688 * @param e1000_data E1000 data structure
     689 *
     690 */
     691static void e1000_disable_unicast_promisc(e1000_t *e1000_data)
     692{
     693        uint32_t rctl = E1000_REG_READ(e1000_data, E1000_RCTL);
    708694        rctl = rctl & ~RCTL_UPE;
    709         E1000_REG_WRITE(e1000, E1000_RCTL, rctl);
     695        E1000_REG_WRITE(e1000_data, E1000_RCTL, rctl);
    710696}
    711697
    712698/** Enable unicast promiscuous mode
    713699 *
    714  * @param e1000 E1000 data structure
    715  *
    716  */
    717 static void e1000_enable_unicast_promisc(e1000_t *e1000)
    718 {
    719         uint32_t rctl = E1000_REG_READ(e1000, E1000_RCTL);
     700 * @param e1000_data E1000 data structure
     701 *
     702 */
     703static void e1000_enable_unicast_promisc(e1000_t *e1000_data)
     704{
     705        uint32_t rctl = E1000_REG_READ(e1000_data, E1000_RCTL);
    720706        rctl = rctl | RCTL_UPE;
    721         E1000_REG_WRITE(e1000, E1000_RCTL, rctl);
     707        E1000_REG_WRITE(e1000_data, E1000_RCTL, rctl);
    722708}
    723709
    724710/** Disable multicast promiscuous mode
    725711 *
    726  * @param e1000 E1000 data structure
    727  *
    728  */
    729 static void e1000_disable_multicast_promisc(e1000_t *e1000)
    730 {
    731         uint32_t rctl = E1000_REG_READ(e1000, E1000_RCTL);
     712 * @param e1000_data E1000 data structure
     713 *
     714 */
     715static void e1000_disable_multicast_promisc(e1000_t *e1000_data)
     716{
     717        uint32_t rctl = E1000_REG_READ(e1000_data, E1000_RCTL);
    732718        rctl = rctl & ~RCTL_MPE;
    733         E1000_REG_WRITE(e1000, E1000_RCTL, rctl);
     719        E1000_REG_WRITE(e1000_data, E1000_RCTL, rctl);
    734720}
    735721
    736722/** Enable multicast promiscuous mode
    737723 *
    738  * @param e1000 E1000 data structure
    739  *
    740  */
    741 static void e1000_enable_multicast_promisc(e1000_t *e1000)
    742 {
    743         uint32_t rctl = E1000_REG_READ(e1000, E1000_RCTL);
     724 * @param e1000_data E1000 data structure
     725 *
     726 */
     727static void e1000_enable_multicast_promisc(e1000_t *e1000_data)
     728{
     729        uint32_t rctl = E1000_REG_READ(e1000_data, E1000_RCTL);
    744730        rctl = rctl | RCTL_MPE;
    745         E1000_REG_WRITE(e1000, E1000_RCTL, rctl);
     731        E1000_REG_WRITE(e1000_data, E1000_RCTL, rctl);
    746732}
    747733
    748734/** Enable accepting of broadcast packets
    749735 *
    750  * @param e1000 E1000 data structure
    751  *
    752  */
    753 static void e1000_enable_broadcast_accept(e1000_t *e1000)
    754 {
    755         uint32_t rctl = E1000_REG_READ(e1000, E1000_RCTL);
     736 * @param e1000_data E1000 data structure
     737 *
     738 */
     739static void e1000_enable_broadcast_accept(e1000_t *e1000_data)
     740{
     741        uint32_t rctl = E1000_REG_READ(e1000_data, E1000_RCTL);
    756742        rctl = rctl | RCTL_BAM;
    757         E1000_REG_WRITE(e1000, E1000_RCTL, rctl);
     743        E1000_REG_WRITE(e1000_data, E1000_RCTL, rctl);
    758744}
    759745
    760746/** Disable accepting of broadcast packets
    761747 *
    762  * @param e1000 E1000 data structure
    763  *
    764  */
    765 static void e1000_disable_broadcast_accept(e1000_t *e1000)
    766 {
    767         uint32_t rctl = E1000_REG_READ(e1000, E1000_RCTL);
     748 * @param e1000_data E1000 data structure
     749 *
     750 */
     751static void e1000_disable_broadcast_accept(e1000_t *e1000_data)
     752{
     753        uint32_t rctl = E1000_REG_READ(e1000_data, E1000_RCTL);
    768754        rctl = rctl & ~RCTL_BAM;
    769         E1000_REG_WRITE(e1000, E1000_RCTL, rctl);
     755        E1000_REG_WRITE(e1000_data, E1000_RCTL, rctl);
    770756}
    771757
    772758/** Enable VLAN filtering according to VFTA registers
    773759 *
    774  * @param e1000 E1000 data structure
    775  *
    776  */
    777 static void e1000_enable_vlan_filter(e1000_t *e1000)
    778 {
    779         uint32_t rctl = E1000_REG_READ(e1000, E1000_RCTL);
     760 * @param e1000_data E1000 data structure
     761 *
     762 */
     763static void e1000_enable_vlan_filter(e1000_t *e1000_data)
     764{
     765        uint32_t rctl = E1000_REG_READ(e1000_data, E1000_RCTL);
    780766        rctl = rctl | RCTL_VFE;
    781         E1000_REG_WRITE(e1000, E1000_RCTL, rctl);
     767        E1000_REG_WRITE(e1000_data, E1000_RCTL, rctl);
    782768}
    783769
    784770/** Disable VLAN filtering
    785771 *
    786  * @param e1000 E1000 data structure
    787  *
    788  */
    789 static void e1000_disable_vlan_filter(e1000_t *e1000)
    790 {
    791         uint32_t rctl = E1000_REG_READ(e1000, E1000_RCTL);
     772 * @param e1000_data E1000 data structure
     773 *
     774 */
     775static void e1000_disable_vlan_filter(e1000_t *e1000_data)
     776{
     777        uint32_t rctl = E1000_REG_READ(e1000_data, E1000_RCTL);
    792778        rctl = rctl & ~RCTL_VFE;
    793         E1000_REG_WRITE(e1000, E1000_RCTL, rctl);
     779        E1000_REG_WRITE(e1000_data, E1000_RCTL, rctl);
    794780}
    795781
    796782/** Set multicast packets acceptance mode
    797783 *
    798  * @param nic      NIC device to update
     784 * @param nic_data NIC device to update
    799785 * @param mode     Mode to set
    800786 * @param addr     Address list (used in mode = NIC_MULTICAST_LIST)
    … …  
    804790 *
    805791 */
    806 static int e1000_on_multicast_mode_change(nic_t *nic, nic_multicast_mode_t mode,
    807     const nic_address_t *addr, size_t addr_cnt)
    808 {
    809         e1000_t *e1000 = DRIVER_DATA_NIC(nic);
     792static int e1000_on_multicast_mode_change(nic_t *nic_data,
     793    nic_multicast_mode_t mode, const nic_address_t *addr, size_t addr_cnt)
     794{
     795        e1000_t *e1000_data = DRIVER_DATA_NIC(nic_data);
    810796        int rc = EOK;
    811797       
    812         fibril_mutex_lock(&e1000->rx_lock);
     798        fibril_mutex_lock(&e1000_data->rx_lock);
    813799       
    814800        switch (mode) {
    815801        case NIC_MULTICAST_BLOCKED:
    816                 e1000_clear_multicast_receive_addresses(e1000);
    817                 e1000_disable_multicast_promisc(e1000);
    818                 nic_report_hw_filtering(nic, -1, 1, -1);
     802                e1000_clear_multicast_receive_addresses(e1000_data);
     803                e1000_disable_multicast_promisc(e1000_data);
     804                nic_report_hw_filtering(nic_data, -1, 1, -1);
    819805                break;
    820806        case NIC_MULTICAST_LIST:
    821                 e1000_clear_multicast_receive_addresses(e1000);
    822                 if (addr_cnt > get_free_multicast_address_count(e1000)) {
     807                e1000_clear_multicast_receive_addresses(e1000_data);
     808                if (addr_cnt > get_free_multicast_address_count(e1000_data)) {
    823809                        /*
    824810                         * Future work: fill MTA table
    … …  
    826812                         * in the NIC library.
    827813                         */
    828                         e1000_enable_multicast_promisc(e1000);
    829                         nic_report_hw_filtering(nic, -1, 0, -1);
     814                        e1000_enable_multicast_promisc(e1000_data);
     815                        nic_report_hw_filtering(nic_data, -1, 0, -1);
    830816                } else {
    831                         e1000_disable_multicast_promisc(e1000);
    832                         e1000_add_multicast_receive_addresses(e1000, addr, addr_cnt);
    833                         nic_report_hw_filtering(nic, -1, 1, -1);
     817                        e1000_disable_multicast_promisc(e1000_data);
     818                        e1000_add_multicast_receive_addresses(e1000_data, addr, addr_cnt);
     819                        nic_report_hw_filtering(nic_data, -1, 1, -1);
    834820                }
    835821                break;
    836822        case NIC_MULTICAST_PROMISC:
    837                 e1000_enable_multicast_promisc(e1000);
    838                 e1000_clear_multicast_receive_addresses(e1000);
    839                 nic_report_hw_filtering(nic, -1, 1, -1);
     823                e1000_enable_multicast_promisc(e1000_data);
     824                e1000_clear_multicast_receive_addresses(e1000_data);
     825                nic_report_hw_filtering(nic_data, -1, 1, -1);
    840826                break;
    841827        default:
    … …  
    844830        }
    845831       
    846         fibril_mutex_unlock(&e1000->rx_lock);
     832        fibril_mutex_unlock(&e1000_data->rx_lock);
    847833        return rc;
    848834}
    … …  
    850836/** Set unicast packets acceptance mode
    851837 *
    852  * @param nic      NIC device to update
     838 * @param nic_data NIC device to update
    853839 * @param mode     Mode to set
    854840 * @param addr     Address list (used in mode = NIC_MULTICAST_LIST)
    … …  
    858844 *
    859845 */
    860 static int e1000_on_unicast_mode_change(nic_t *nic, nic_unicast_mode_t mode,
    861     const nic_address_t *addr, size_t addr_cnt)
    862 {
    863         e1000_t *e1000 = DRIVER_DATA_NIC(nic);
     846static int e1000_on_unicast_mode_change(nic_t *nic_data,
     847    nic_unicast_mode_t mode, const nic_address_t *addr, size_t addr_cnt)
     848{
     849        e1000_t *e1000_data = DRIVER_DATA_NIC(nic_data);
    864850        int rc = EOK;
    865851       
    866         fibril_mutex_lock(&e1000->rx_lock);
     852        fibril_mutex_lock(&e1000_data->rx_lock);
    867853       
    868854        switch (mode) {
    869855        case NIC_UNICAST_BLOCKED:
    870                 disable_ra0_address_filter(e1000);
    871                 e1000_clear_unicast_receive_addresses(e1000);
    872                 e1000_disable_unicast_promisc(e1000);
    873                 nic_report_hw_filtering(nic, 1, -1, -1);
     856                disable_ra0_address_filter(e1000_data);
     857                e1000_clear_unicast_receive_addresses(e1000_data);
     858                e1000_disable_unicast_promisc(e1000_data);
     859                nic_report_hw_filtering(nic_data, 1, -1, -1);
    874860                break;
    875861        case NIC_UNICAST_DEFAULT:
    876                 enable_ra0_address_filter(e1000);
    877                 e1000_clear_unicast_receive_addresses(e1000);
    878                 e1000_disable_unicast_promisc(e1000);
    879                 nic_report_hw_filtering(nic, 1, -1, -1);
     862                enable_ra0_address_filter(e1000_data);
     863                e1000_clear_unicast_receive_addresses(e1000_data);
     864                e1000_disable_unicast_promisc(e1000_data);
     865                nic_report_hw_filtering(nic_data, 1, -1, -1);
    880866                break;
    881867        case NIC_UNICAST_LIST:
    882                 enable_ra0_address_filter(e1000);
    883                 e1000_clear_unicast_receive_addresses(e1000);
    884                 if (addr_cnt > get_free_unicast_address_count(e1000)) {
    885                         e1000_enable_unicast_promisc(e1000);
    886                         nic_report_hw_filtering(nic, 0, -1, -1);
     868                enable_ra0_address_filter(e1000_data);
     869                e1000_clear_unicast_receive_addresses(e1000_data);
     870                if (addr_cnt > get_free_unicast_address_count(e1000_data)) {
     871                        e1000_enable_unicast_promisc(e1000_data);
     872                        nic_report_hw_filtering(nic_data, 0, -1, -1);
    887873                } else {
    888                         e1000_disable_unicast_promisc(e1000);
    889                         e1000_add_unicast_receive_addresses(e1000, addr, addr_cnt);
    890                         nic_report_hw_filtering(nic, 1, -1, -1);
     874                        e1000_disable_unicast_promisc(e1000_data);
     875                        e1000_add_unicast_receive_addresses(e1000_data, addr, addr_cnt);
     876                        nic_report_hw_filtering(nic_data, 1, -1, -1);
    891877                }
    892878                break;
    893879        case NIC_UNICAST_PROMISC:
    894                 e1000_enable_unicast_promisc(e1000);
    895                 enable_ra0_address_filter(e1000);
    896                 e1000_clear_unicast_receive_addresses(e1000);
    897                 nic_report_hw_filtering(nic, 1, -1, -1);
     880                e1000_enable_unicast_promisc(e1000_data);
     881                enable_ra0_address_filter(e1000_data);
     882                e1000_clear_unicast_receive_addresses(e1000_data);
     883                nic_report_hw_filtering(nic_data, 1, -1, -1);
    898884                break;
    899885        default:
    … …  
    902888        }
    903889       
    904         fibril_mutex_unlock(&e1000->rx_lock);
     890        fibril_mutex_unlock(&e1000_data->rx_lock);
    905891        return rc;
    906892}
    … …  
    908894/** Set broadcast packets acceptance mode
    909895 *
    910  * @param nic  NIC device to update
    911  * @param mode Mode to set
     896 * @param nic_data NIC device to update
     897 * @param mode     Mode to set
    912898 *
    913899 * @return EOK
    914900 *
    915901 */
    916 static int e1000_on_broadcast_mode_change(nic_t *nic, nic_broadcast_mode_t mode)
    917 {
    918         e1000_t *e1000 = DRIVER_DATA_NIC(nic);
     902static int e1000_on_broadcast_mode_change(nic_t *nic_data,
     903    nic_broadcast_mode_t mode)
     904{
     905        e1000_t *e1000_data = DRIVER_DATA_NIC(nic_data);
    919906        int rc = EOK;
    920907       
    921         fibril_mutex_lock(&e1000->rx_lock);
     908        fibril_mutex_lock(&e1000_data->rx_lock);
    922909       
    923910        switch (mode) {
    924911        case NIC_BROADCAST_BLOCKED:
    925                 e1000_disable_broadcast_accept(e1000);
     912                e1000_disable_broadcast_accept(e1000_data);
    926913                break;
    927914        case NIC_BROADCAST_ACCEPTED:
    928                 e1000_enable_broadcast_accept(e1000);
     915                e1000_enable_broadcast_accept(e1000_data);
    929916                break;
    930917        default:
    … …  
    933920        }
    934921       
    935         fibril_mutex_unlock(&e1000->rx_lock);
     922        fibril_mutex_unlock(&e1000_data->rx_lock);
    936923        return rc;
    937924}
    … …  
    939926/** Check if receiving is enabled
    940927 *
    941  * @param e1000 E1000 data structure
     928 * @param e1000_data E1000 data structure
    942929 *
    943930 * @return true if receiving is enabled
    944931 *
    945932 */
    946 static bool e1000_is_rx_enabled(e1000_t *e1000)
    947 {
    948         if (E1000_REG_READ(e1000, E1000_RCTL) & (RCTL_EN))
     933static bool e1000_is_rx_enabled(e1000_t *e1000_data)
     934{
     935        if (E1000_REG_READ(e1000_data, E1000_RCTL) & (RCTL_EN))
    949936                return true;
    950937       
    … …  
    954941/** Enable receiving
    955942 *
    956  * @param e1000 E1000 data structure
    957  *
    958  */
    959 static void e1000_enable_rx(e1000_t *e1000)
     943 * @param e1000_data E1000 data structure
     944 *
     945 */
     946static void e1000_enable_rx(e1000_t *e1000_data)
    960947{
    961948        /* Set Receive Enable Bit */
    962         E1000_REG_WRITE(e1000, E1000_RCTL,
    963             E1000_REG_READ(e1000, E1000_RCTL) | (RCTL_EN));
     949        E1000_REG_WRITE(e1000_data, E1000_RCTL,
     950            E1000_REG_READ(e1000_data, E1000_RCTL) | (RCTL_EN));
    964951}
    965952
    966953/** Disable receiving
    967954 *
    968  * @param e1000 E1000 data structure
    969  *
    970  */
    971 static void e1000_disable_rx(e1000_t *e1000)
     955 * @param e1000_data E1000 data structure
     956 *
     957 */
     958static void e1000_disable_rx(e1000_t *e1000_data)
    972959{
    973960        /* Clear Receive Enable Bit */
    974         E1000_REG_WRITE(e1000, E1000_RCTL,
    975             E1000_REG_READ(e1000, E1000_RCTL) & ~(RCTL_EN));
     961        E1000_REG_WRITE(e1000_data, E1000_RCTL,
     962            E1000_REG_READ(e1000_data, E1000_RCTL) & ~(RCTL_EN));
    976963}
    977964
    978965/** Set VLAN mask
    979966 *
    980  * @param nic       NIC device to update
     967 * @param nic_data  NIC device to update
    981968 * @param vlan_mask VLAN mask
    982969 *
    983970 */
    984 static void e1000_on_vlan_mask_change(nic_t *nic,
    985     const nic_vlan_mask_t *vlan_mask)
    986 {
    987         e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    988        
    989         fibril_mutex_lock(&e1000->rx_lock);
     971static void e1000_on_vlan_mask_change(nic_t *nic_data,
     972   const nic_vlan_mask_t *vlan_mask)
     973{
     974        e1000_t *e1000_data = DRIVER_DATA_NIC(nic_data);
     975       
     976        fibril_mutex_lock(&e1000_data->rx_lock);
    990977       
    991978        if (vlan_mask) {
    … …  
    994981                 * partially written VLAN is not received.
    995982                 */
    996                 bool rx_enabled = e1000_is_rx_enabled(e1000);
     983                bool rx_enabled = e1000_is_rx_enabled(e1000_data);
    997984                if (rx_enabled)
    998                         e1000_disable_rx(e1000);
     985                        e1000_disable_rx(e1000_data);
    999986               
    1000987                for (unsigned int i = 0; i < NIC_VLAN_BITMAP_SIZE; i += 4) {
    … …  
    1004991                            (((uint32_t) vlan_mask->bitmap[i + 2]) << 16) |
    1005992                            (((uint32_t) vlan_mask->bitmap[i + 3]) << 24);
    1006                         E1000_REG_WRITE(e1000, E1000_VFTA_ARRAY(i / 4), bitmap_part);
     993                        E1000_REG_WRITE(e1000_data, E1000_VFTA_ARRAY(i / 4), bitmap_part);
    1007994                }
    1008995               
    1009                 e1000_enable_vlan_filter(e1000);
     996                e1000_enable_vlan_filter(e1000_data);
    1010997                if (rx_enabled)
    1011                         e1000_enable_rx(e1000);
     998                        e1000_enable_rx(e1000_data);
    1012999        } else
    1013                 e1000_disable_vlan_filter(e1000);
    1014        
    1015         fibril_mutex_unlock(&e1000->rx_lock);
     1000                e1000_disable_vlan_filter(e1000_data);
     1001       
     1002        fibril_mutex_unlock(&e1000_data->rx_lock);
    10161003}
    10171004
    … …  
    10391026                return ENOTSUP;
    10401027       
    1041         e1000_t *e1000 = DRIVER_DATA_DEV(device);
    1042        
    1043         e1000->vlan_tag = tag;
    1044         e1000->vlan_tag_add = add;
    1045        
    1046         fibril_mutex_lock(&e1000->ctrl_lock);
    1047        
    1048         uint32_t ctrl = E1000_REG_READ(e1000, E1000_CTRL);
     1028        e1000_t *e1000_data = DRIVER_DATA_DEV(device);
     1029       
     1030        e1000_data->vlan_tag = tag;
     1031        e1000_data->vlan_tag_add = add;
     1032       
     1033        fibril_mutex_lock(&e1000_data->ctrl_lock);
     1034       
     1035        uint32_t ctrl = E1000_REG_READ(e1000_data, E1000_CTRL);
    10491036        if (strip)
    10501037                ctrl |= CTRL_VME;
    … …  
    10521039                ctrl &= ~CTRL_VME;
    10531040       
    1054         E1000_REG_WRITE(e1000, E1000_CTRL, ctrl);
    1055        
    1056         fibril_mutex_unlock(&e1000->ctrl_lock);
     1041        E1000_REG_WRITE(e1000_data, E1000_CTRL, ctrl);
     1042       
     1043        fibril_mutex_unlock(&e1000_data->ctrl_lock);
    10571044        return EOK;
    10581045}
    … …  
    10601047/** Fill receive descriptor with new empty packet
    10611048 *
    1062  * Store packet in e1000->rx_ring_packets
    1063  *
    1064  * @param nic    NIC data stricture
    1065  * @param offset Receive descriptor offset
    1066  *
    1067  */
    1068 static void e1000_fill_new_rx_descriptor(nic_t *nic, size_t offset)
    1069 {
    1070         e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    1071         packet_t *packet =
    1072             nic_alloc_packet(nic, E1000_MAX_RECEIVE_PACKET_SIZE);
     1049 * Store packet in e1000_data->rx_ring_packets
     1050 *
     1051 * @param nic_data NIC data stricture
     1052 * @param offset   Receive descriptor offset
     1053 *
     1054 */
     1055static void e1000_fill_new_rx_descriptor(nic_t *nic_data, unsigned int offset)
     1056{
     1057        e1000_t *e1000_data = DRIVER_DATA_NIC(nic_data);
     1058        packet_t *packet = nic_alloc_packet(nic_data, E1000_MAX_RECEIVE_PACKET_SIZE);
    10731059       
    10741060        assert(packet);
    10751061       
    1076         *(e1000->rx_ring_packets + offset) = packet;
    1077         e1000_rx_descriptor_t *rx_descriptor = (e1000_rx_descriptor_t *)
    1078             (e1000->rx_ring_virt + offset * sizeof(e1000_rx_descriptor_t));
    1079        
    1080         void *phys;
    1081         int rc =
    1082             nic_dma_lock_packet(packet, E1000_MAX_RECEIVE_PACKET_SIZE, &phys);
    1083        
    1084         if (rc == EOK)
    1085                 rx_descriptor->phys_addr = PTR_TO_U64(phys + packet->data_start);
    1086         else
     1062        *(e1000_data->rx_ring_packets + offset) = packet;
     1063        e1000_rx_descriptor_t * rx_descriptor = (e1000_rx_descriptor_t *)
     1064            (e1000_data->rx_ring.virt +
     1065            offset * sizeof(e1000_rx_descriptor_t));
     1066       
     1067        void *phys_addr = nic_dma_lock_packet(packet);
     1068       
     1069        if (phys_addr) {
     1070                rx_descriptor->phys_addr =
     1071                    PTR_TO_U64(phys_addr + packet->data_start);
     1072        } else
    10871073                rx_descriptor->phys_addr = 0;
    10881074       
    … …  
    10961082/** Clear receive descriptor
    10971083 *
    1098  * @param e1000  E1000 data
    1099  * @param offset Receive descriptor offset
    1100  *
    1101  */
    1102 static void e1000_clear_rx_descriptor(e1000_t *e1000, unsigned int offset)
     1084 * @param e1000_data E1000 data
     1085 * @param offset     Receive descriptor offset
     1086 *
     1087 */
     1088static void e1000_clear_rx_descriptor(e1000_t *e1000_data, unsigned int offset)
    11031089{
    11041090        e1000_rx_descriptor_t *rx_descriptor = (e1000_rx_descriptor_t *)
    1105             (e1000->rx_ring_virt + offset * sizeof(e1000_rx_descriptor_t));
     1091            (e1000_data->rx_ring.virt +
     1092            offset * sizeof(e1000_rx_descriptor_t));
    11061093       
    11071094        rx_descriptor->length = 0;
    … …  
    11141101/** Clear receive descriptor
    11151102 *
    1116  * @param nic    NIC data
    1117  * @param offset Receive descriptor offset
    1118  *
    1119  */
    1120 static void e1000_clear_tx_descriptor(nic_t *nic, unsigned int offset)
    1121 {
    1122         e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    1123        
    1124         e1000_tx_descriptor_t *tx_descriptor = (e1000_tx_descriptor_t *)
    1125             (e1000->tx_ring_virt + offset * sizeof(e1000_tx_descriptor_t));
     1103 * @param nic_data NIC data
     1104 * @param offset   Receive descriptor offset
     1105 *
     1106 */
     1107static void e1000_clear_tx_descriptor(nic_t *nic_data, unsigned int offset)
     1108{
     1109        e1000_t *e1000_data = DRIVER_DATA_NIC(nic_data);
     1110       
     1111        e1000_tx_descriptor_t * tx_descriptor = (e1000_tx_descriptor_t *)
     1112            (e1000_data->tx_ring.virt +
     1113            offset * sizeof(e1000_tx_descriptor_t));
    11261114       
    11271115        if (tx_descriptor->length) {
    1128                 packet_t *old_packet = *(e1000->tx_ring_packets + offset);
     1116                packet_t * old_packet = *(e1000_data->tx_ring_packets + offset);
    11291117                if (old_packet)
    1130                         nic_release_packet(nic, old_packet);
     1118                        nic_release_packet(nic_data, old_packet);
    11311119        }
    11321120       
    … …  
    11581146/** Receive packets
    11591147 *
    1160  * @param nic NIC data
    1161  *
    1162  */
    1163 static void e1000_receive_packets(nic_t *nic)
    1164 {
    1165         e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    1166        
    1167         fibril_mutex_lock(&e1000->rx_lock);
    1168        
    1169         uint32_t *tail_addr = E1000_REG_ADDR(e1000, E1000_RDT);
     1148 * @param nic_data NIC data
     1149 *
     1150 */
     1151static void e1000_receive_packets(nic_t *nic_data)
     1152{
     1153        e1000_t *e1000_data = DRIVER_DATA_NIC(nic_data);
     1154       
     1155        fibril_mutex_lock(&e1000_data->rx_lock);
     1156       
     1157        uint32_t *tail_addr = E1000_REG_ADDR(e1000_data, E1000_RDT);
    11701158        uint32_t next_tail = e1000_inc_tail(*tail_addr, E1000_RX_PACKETS_COUNT);
    11711159       
    11721160        e1000_rx_descriptor_t *rx_descriptor = (e1000_rx_descriptor_t *)
    1173             (e1000->rx_ring_virt + next_tail * sizeof(e1000_rx_descriptor_t));
     1161            (e1000_data->rx_ring.virt +
     1162            next_tail * sizeof(e1000_rx_descriptor_t));
    11741163       
    11751164        while (rx_descriptor->status & 0x01) {
    11761165                uint32_t packet_size = rx_descriptor->length - E1000_CRC_SIZE;
    11771166               
    1178                 packet_t *packet = *(e1000->rx_ring_packets + next_tail);
     1167                packet_t *packet = *(e1000_data->rx_ring_packets + next_tail);
    11791168                packet_suffix(packet, packet_size);
    11801169               
    1181                 nic_dma_unlock_packet(packet, E1000_MAX_RECEIVE_PACKET_SIZE);
    1182                 nic_received_packet(nic, packet);
     1170                nic_dma_unlock_packet(packet);
     1171                nic_received_packet(nic_data, packet);
    11831172               
    1184                 e1000_fill_new_rx_descriptor(nic, next_tail);
     1173                e1000_fill_new_rx_descriptor(nic_data, next_tail);
    11851174               
    11861175                *tail_addr = e1000_inc_tail(*tail_addr, E1000_RX_PACKETS_COUNT);
    … …  
    11881177               
    11891178                rx_descriptor = (e1000_rx_descriptor_t *)
    1190                     (e1000->rx_ring_virt + next_tail * sizeof(e1000_rx_descriptor_t));
     1179                    (e1000_data->rx_ring.virt +
     1180                    next_tail * sizeof(e1000_rx_descriptor_t));
    11911181        }
    11921182       
    1193         fibril_mutex_unlock(&e1000->rx_lock);
     1183        fibril_mutex_unlock(&e1000_data->rx_lock);
    11941184}
    11951185
    11961186/** Enable E1000 interupts
    11971187 *
    1198  * @param e1000 E1000 data structure
    1199  *
    1200  */
    1201 static void e1000_enable_interrupts(e1000_t *e1000)
    1202 {
    1203         E1000_REG_WRITE(e1000, E1000_IMS, ICR_RXT0);
     1188 * @param e1000_data E1000 data structure
     1189 *
     1190 */
     1191static void e1000_enable_interrupts(e1000_t *e1000_data)
     1192{
     1193        E1000_REG_WRITE(e1000_data, E1000_IMS, ICR_RXT0);
    12041194}
    12051195
    12061196/** Disable E1000 interupts
    12071197 *
    1208  * @param e1000 E1000 data structure
    1209  *
    1210  */
    1211 static void e1000_disable_interrupts(e1000_t *e1000)
    1212 {
    1213         E1000_REG_WRITE(e1000, E1000_IMS, 0);
     1198 * @param e1000_data E1000 data structure
     1199 *
     1200 */
     1201static void e1000_disable_interrupts(e1000_t *e1000_data)
     1202{
     1203        E1000_REG_WRITE(e1000_data, E1000_IMS, 0);
    12141204}
    12151205
    … …  
    12191209 * and e1000_poll()
    12201210 *
    1221  * @param nic NIC data
    1222  * @param icr ICR register value
    1223  *
    1224  */
    1225 static void e1000_interrupt_handler_impl(nic_t *nic, uint32_t icr)
     1211 * @param nic_data NIC data
     1212 * @param icr      ICR register value
     1213 *
     1214 */
     1215static void e1000_interrupt_handler_impl(nic_t *nic_data, uint32_t icr)
    12261216{
    12271217        if (icr & ICR_RXT0)
    1228                 e1000_receive_packets(nic);
     1218                e1000_receive_packets(nic_data);
    12291219}
    12301220
    … …  
    12401230{
    12411231        uint32_t icr = (uint32_t) IPC_GET_ARG2(*icall);
    1242         nic_t *nic = NIC_DATA_DEV(dev);
    1243         e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    1244        
    1245         e1000_interrupt_handler_impl(nic, icr);
    1246         e1000_enable_interrupts(e1000);
     1232        nic_t *nic_data = NIC_DATA_DEV(dev);
     1233        e1000_t *e1000_data = DRIVER_DATA_NIC(nic_data);
     1234       
     1235        e1000_interrupt_handler_impl(nic_data, icr);
     1236        e1000_enable_interrupts(e1000_data);
    12471237}
    12481238
    … …  
    12521242 * structure.
    12531243 *
    1254  * @param nic Driver data
     1244 * @param nic_data Driver data
    12551245 *
    12561246 * @return EOK if the handler was registered
    … …  
    12581248 *
    12591249 */
    1260 inline static int e1000_register_int_handler(nic_t *nic)
    1261 {
    1262         e1000_t *e1000 = DRIVER_DATA_NIC(nic);
     1250inline static int e1000_register_int_handler(nic_t *nic_data)
     1251{
     1252        e1000_t *e1000_data = DRIVER_DATA_NIC(nic_data);
    12631253       
    12641254        /* Lock the mutex in whole driver while working with global structure */
    12651255        fibril_mutex_lock(&irq_reg_mutex);
    12661256       
    1267         e1000_irq_code.cmds[0].addr = e1000->reg_base_virt + E1000_ICR;
    1268         e1000_irq_code.cmds[2].addr = e1000->reg_base_virt + E1000_IMC;
    1269        
    1270         int rc = register_interrupt_handler(nic_get_ddf_dev(nic),
    1271             e1000->irq, e1000_interrupt_handler, &e1000_irq_code);
     1257        // FIXME: This is not supported in mainline
     1258        e1000_irq_code.cmds[0].addr =
     1259            0xffff800000000000 + e1000_data->phys_reg_base + E1000_ICR;
     1260        e1000_irq_code.cmds[2].addr =
     1261            0xffff800000000000 + e1000_data->phys_reg_base + E1000_IMC;
     1262       
     1263        int rc = register_interrupt_handler(nic_get_ddf_dev(nic_data),
     1264            e1000_data->irq, e1000_interrupt_handler, &e1000_irq_code);
    12721265       
    12731266        fibril_mutex_unlock(&irq_reg_mutex);
    … …  
    12771270/** Force receiving all packets in the receive buffer
    12781271 *
    1279  * @param nic NIC data
    1280  *
    1281  */
    1282 static void e1000_poll(nic_t *nic)
    1283 {
    1284         assert(nic);
    1285        
    1286         e1000_t *e1000 = nic_get_specific(nic);
    1287         assert(e1000);
    1288        
    1289         uint32_t icr = E1000_REG_READ(e1000, E1000_ICR);
    1290         e1000_interrupt_handler_impl(nic, icr);
     1272 * @param nic_data NIC data
     1273 *
     1274 */
     1275static void e1000_poll(nic_t *nic_data)
     1276{
     1277        assert(nic_data);
     1278       
     1279        e1000_t *e1000_data = nic_get_specific(nic_data);
     1280        assert(e1000_data);
     1281       
     1282        uint32_t icr = E1000_REG_READ(e1000_data, E1000_ICR);
     1283        e1000_interrupt_handler_impl(nic_data, icr);
    12911284}
    12921285
    … …  
    13121305 *
    13131306 */
    1314 static int e1000_poll_mode_change(nic_t *nic, nic_poll_mode_t mode,
     1307static int e1000_poll_mode_change(nic_t *nic_data, nic_poll_mode_t mode,
    13151308    const struct timeval *period)
    13161309{
    1317         assert(nic);
    1318        
    1319         e1000_t *e1000 = nic_get_specific(nic);
    1320         assert(e1000);
     1310        assert(nic_data);
     1311       
     1312        e1000_t *e1000_data = nic_get_specific(nic_data);
     1313        assert(e1000_data);
    13211314       
    13221315        switch (mode) {
    13231316        case NIC_POLL_IMMEDIATE:
    1324                 E1000_REG_WRITE(e1000, E1000_ITR, 0);
    1325                 e1000_enable_interrupts(e1000);
     1317                E1000_REG_WRITE(e1000_data, E1000_ITR, 0);
     1318                e1000_enable_interrupts(e1000_data);
    13261319                break;
    13271320        case NIC_POLL_ON_DEMAND:
    1328                 e1000_disable_interrupts(e1000);
     1321                e1000_disable_interrupts(e1000_data);
    13291322                break;
    13301323        case NIC_POLL_PERIODIC:
    13311324                assert(period);
    13321325                uint16_t itr_interval = e1000_calculate_itr_interval(period);
    1333                 E1000_REG_WRITE(e1000, E1000_ITR, (uint32_t) itr_interval);
    1334                 e1000_enable_interrupts(e1000);
     1326                E1000_REG_WRITE(e1000_data, E1000_ITR, (uint32_t) itr_interval);
     1327                e1000_enable_interrupts(e1000_data);
    13351328                break;
    13361329        default:
    … …  
    13431336/** Initialize receive registers
    13441337 *
    1345  * @param e1000 E1000 data structure
    1346  *
    1347  */
    1348 static void e1000_initialize_rx_registers(e1000_t *e1000)
    1349 {
    1350         E1000_REG_WRITE(e1000, E1000_RDLEN, E1000_RX_PACKETS_COUNT * 16);
    1351         E1000_REG_WRITE(e1000, E1000_RDH, 0);
     1338 * @param e1000_data E1000 data structure
     1339 *
     1340 */
     1341static void e1000_initialize_rx_registers(e1000_t * e1000_data)
     1342{
     1343        E1000_REG_WRITE(e1000_data, E1000_RDLEN, E1000_RX_PACKETS_COUNT * 16);
     1344        E1000_REG_WRITE(e1000_data, E1000_RDH, 0);
    13521345       
    13531346        /* It is not posible to let HW use all descriptors */
    1354         E1000_REG_WRITE(e1000, E1000_RDT, E1000_RX_PACKETS_COUNT - 1);
     1347        E1000_REG_WRITE(e1000_data, E1000_RDT, E1000_RX_PACKETS_COUNT - 1);
    13551348       
    13561349        /* Set Broadcast Enable Bit */
    1357         E1000_REG_WRITE(e1000, E1000_RCTL, RCTL_BAM);
     1350        E1000_REG_WRITE(e1000_data, E1000_RCTL, RCTL_BAM);
    13581351}
    13591352
    13601353/** Initialize receive structure
    13611354 *
    1362  * @param nic NIC data
     1355 * @param nic_data NIC data
    13631356 *
    13641357 * @return EOK if succeed
    … …  
    13661359 *
    13671360 */
    1368 static int e1000_initialize_rx_structure(nic_t *nic)
    1369 {
    1370         e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    1371         fibril_mutex_lock(&e1000->rx_lock);
    1372        
    1373         int rc = dmamem_map_anonymous(
    1374             E1000_RX_PACKETS_COUNT * sizeof(e1000_rx_descriptor_t),
    1375             AS_AREA_READ | AS_AREA_WRITE, 0, &e1000->rx_ring_phys,
    1376             &e1000->rx_ring_virt);
     1361static int e1000_initialize_rx_structure(nic_t *nic_data)
     1362{
     1363        e1000_t *e1000_data = DRIVER_DATA_NIC(nic_data);
     1364        fibril_mutex_lock(&e1000_data->rx_lock);
     1365       
     1366        int rc = dmamem_map(&e1000_data->rx_ring,
     1367            SIZE2PAGES(E1000_RX_PACKETS_COUNT * sizeof(e1000_rx_descriptor_t)),
     1368            AS_AREA_READ | AS_AREA_WRITE, 0);
    13771369        if (rc != EOK)
    13781370                return rc;
    13791371       
    1380         E1000_REG_WRITE(e1000, E1000_RDBAH,
    1381             (uint32_t) (PTR_TO_U64(e1000->rx_ring_phys) >> 32));
    1382         E1000_REG_WRITE(e1000, E1000_RDBAL,
    1383             (uint32_t) PTR_TO_U64(e1000->rx_ring_phys));
    1384        
    1385         e1000->rx_ring_packets =
     1372        E1000_REG_WRITE(e1000_data, E1000_RDBAH,
     1373            (uint32_t) (PTR_TO_U64(e1000_data->rx_ring.phys) >> 32));
     1374        E1000_REG_WRITE(e1000_data, E1000_RDBAL,
     1375            (uint32_t) PTR_TO_U64(e1000_data->rx_ring.phys));
     1376       
     1377        e1000_data->rx_ring_packets =
    13861378            malloc(E1000_RX_PACKETS_COUNT * sizeof(packet_t *));
    13871379        // FIXME: Check return value
    … …  
    13911383            offset < E1000_RX_PACKETS_COUNT;
    13921384            offset++)
    1393                 e1000_fill_new_rx_descriptor(nic, offset);
    1394        
    1395         e1000_initialize_rx_registers(e1000);
    1396        
    1397         fibril_mutex_unlock(&e1000->rx_lock);
     1385                e1000_fill_new_rx_descriptor(nic_data, offset);
     1386       
     1387        e1000_initialize_rx_registers(e1000_data);
     1388       
     1389        fibril_mutex_unlock(&e1000_data->rx_lock);
    13981390        return EOK;
    13991391}
    … …  
    14011393/** Uninitialize receive structure
    14021394 *
    1403  * @param nic NIC data
    1404  *
    1405  */
    1406 static void e1000_uninitialize_rx_structure(nic_t *nic)
    1407 {
    1408         e1000_t *e1000 = DRIVER_DATA_NIC(nic);
     1395 * @param nic_data NIC data
     1396 *
     1397 */
     1398static void e1000_uninitialize_rx_structure(nic_t *nic_data)
     1399{
     1400        e1000_t *e1000_data = DRIVER_DATA_NIC(nic_data);
    14091401       
    14101402        /* Write descriptor */
    … …  
    14121404            offset < E1000_RX_PACKETS_COUNT;
    14131405            offset++) {
    1414                 packet_t *packet = *(e1000->rx_ring_packets + offset);
    1415                 nic_dma_unlock_packet(packet, E1000_MAX_RECEIVE_PACKET_SIZE);
    1416                 nic_release_packet(nic, packet);
     1406                packet_t *packet = *(e1000_data->rx_ring_packets + offset);
     1407                nic_dma_unlock_packet(packet);
     1408                nic_release_packet(nic_data, packet);
    14171409        }
    14181410       
    1419         free(e1000->rx_ring_packets);
    1420         dmamem_unmap_anonymous(e1000->rx_ring_virt);
     1411        free(e1000_data->rx_ring_packets);
     1412        dmamem_unmap(&e1000_data->rx_ring);
    14211413}
    14221414
    14231415/** Clear receive descriptor ring
    14241416 *
    1425  * @param e1000 E1000 data
    1426  *
    1427  */
    1428 static void e1000_clear_rx_ring(e1000_t *e1000)
     1417 * @param e1000_data E1000 data
     1418 *
     1419 */
     1420static void e1000_clear_rx_ring(e1000_t * e1000_data)
    14291421{
    14301422        /* Write descriptor */
    … …  
    14321424            offset < E1000_RX_PACKETS_COUNT;
    14331425            offset++)
    1434                 e1000_clear_rx_descriptor(e1000, offset);
     1426                e1000_clear_rx_descriptor(e1000_data, offset);
    14351427}
    14361428
    14371429/** Initialize filters
    14381430 *
    1439  * @param e1000 E1000 data
    1440  *
    1441  */
    1442 static void e1000_initialize_filters(e1000_t *e1000)
     1431 * @param e1000_data E1000 data
     1432 *
     1433 */
     1434static void e1000_initialize_filters(e1000_t *e1000_data)
    14431435{
    14441436        /* Initialize address filter */
    1445         e1000->unicast_ra_count = 0;
    1446         e1000->multicast_ra_count = 0;
    1447         e1000_clear_unicast_receive_addresses(e1000);
     1437        e1000_data->unicast_ra_count = 0;
     1438        e1000_data->multicast_ra_count = 0;
     1439        e1000_clear_unicast_receive_addresses(e1000_data);
    14481440}
    14491441
    14501442/** Initialize VLAN
    14511443 *
    1452  * @param e1000 E1000 data
    1453  *
    1454  */
    1455 static void e1000_initialize_vlan(e1000_t *e1000)
    1456 {
    1457         e1000->vlan_tag_add = false;
     1444 * @param e1000_data E1000 data
     1445 *
     1446 */
     1447static void e1000_initialize_vlan(e1000_t *e1000_data)
     1448{
     1449        e1000_data->vlan_tag_add = false;
    14581450}
    14591451
    14601452/** Fill MAC address from EEPROM to RA[0] register
    14611453 *
    1462  * @param e1000 E1000 data
    1463  *
    1464  */
    1465 static void e1000_fill_mac_from_eeprom(e1000_t *e1000)
     1454 * @param e1000_data E1000 data
     1455 *
     1456 */
     1457static void e1000_fill_mac_from_eeprom(e1000_t *e1000_data)
    14661458{
    14671459        /* MAC address from eeprom to RA[0] */
    14681460        nic_address_t address;
    1469         e1000_eeprom_get_address(e1000, &address);
    1470         e1000_write_receive_address(e1000, 0, &address, true);
     1461        e1000_eeprom_get_address(e1000_data, &address);
     1462        e1000_write_receive_address(e1000_data, 0, &address, true);
    14711463}
    14721464
    … …  
    14791471 *
    14801472 */
    1481 static void e1000_initialize_registers(e1000_t *e1000)
    1482 {
    1483         E1000_REG_WRITE(e1000, E1000_ITR,
     1473static void e1000_initialize_registers(e1000_t *e1000_data)
     1474{
     1475        E1000_REG_WRITE(e1000_data, E1000_ITR,
    14841476            e1000_calculate_itr_interval_from_usecs(
    14851477            E1000_DEFAULT_INTERRUPT_INTERVAL_USEC));
    1486         E1000_REG_WRITE(e1000, E1000_FCAH, 0);
    1487         E1000_REG_WRITE(e1000, E1000_FCAL, 0);
    1488         E1000_REG_WRITE(e1000, E1000_FCT, 0);
    1489         E1000_REG_WRITE(e1000, E1000_FCTTV, 0);
    1490         E1000_REG_WRITE(e1000, E1000_VET, VET_VALUE);
    1491         E1000_REG_WRITE(e1000, E1000_CTRL, CTRL_ASDE);
     1478        E1000_REG_WRITE(e1000_data, E1000_FCAH, 0);
     1479        E1000_REG_WRITE(e1000_data, E1000_FCAL, 0);
     1480        E1000_REG_WRITE(e1000_data, E1000_FCT, 0);
     1481        E1000_REG_WRITE(e1000_data, E1000_FCTTV, 0);
     1482        E1000_REG_WRITE(e1000_data, E1000_VET, VET_VALUE);
     1483        E1000_REG_WRITE(e1000_data, E1000_CTRL, CTRL_ASDE);
    14921484}
    14931485
    14941486/** Initialize transmit registers
    14951487 *
    1496  * @param e1000 E1000 data.
    1497  *
    1498  */
    1499 static void e1000_initialize_tx_registers(e1000_t *e1000)
    1500 {
    1501         E1000_REG_WRITE(e1000, E1000_TDLEN, E1000_TX_PACKETS_COUNT * 16);
    1502         E1000_REG_WRITE(e1000, E1000_TDH, 0);
    1503         E1000_REG_WRITE(e1000, E1000_TDT, 0);
    1504        
    1505         E1000_REG_WRITE(e1000, E1000_TIPG,
     1488 * @param e1000_data E1000 data.
     1489 *
     1490 */
     1491static void e1000_initialize_tx_registers(e1000_t *e1000_data)
     1492{
     1493        E1000_REG_WRITE(e1000_data, E1000_TDLEN, E1000_TX_PACKETS_COUNT * 16);
     1494        E1000_REG_WRITE(e1000_data, E1000_TDH, 0);
     1495        E1000_REG_WRITE(e1000_data, E1000_TDT, 0);
     1496       
     1497        E1000_REG_WRITE(e1000_data, E1000_TIPG,
    15061498            10 << TIPG_IPGT_SHIFT |
    15071499            8 << TIPG_IPGR1_SHIFT |
    15081500            6 << TIPG_IPGR2_SHIFT);
    15091501       
    1510         E1000_REG_WRITE(e1000, E1000_TCTL,
     1502        E1000_REG_WRITE(e1000_data, E1000_TCTL,
    15111503            0x0F << TCTL_CT_SHIFT /* Collision Threshold */ |
    15121504            0x40 << TCTL_COLD_SHIFT /* Collision Distance */ |
    … …  
    15161508/** Initialize transmit structure
    15171509 *
    1518  * @param e1000 E1000 data.
    1519  *
    1520  */
    1521 static int e1000_initialize_tx_structure(e1000_t *e1000)
    1522 {
    1523         fibril_mutex_lock(&e1000->tx_lock);
    1524        
    1525         int rc = dmamem_map_anonymous(
    1526             E1000_TX_PACKETS_COUNT * sizeof(e1000_tx_descriptor_t),
    1527             AS_AREA_READ | AS_AREA_WRITE, 0, &e1000->tx_ring_phys,
    1528             &e1000->tx_ring_virt);
     1510 * @param e1000_data E1000 data.
     1511 *
     1512 */
     1513static int e1000_initialize_tx_structure(e1000_t *e1000_data)
     1514{
     1515        fibril_mutex_lock(&e1000_data->tx_lock);
     1516       
     1517        int rc = dmamem_map(&e1000_data->tx_ring,
     1518            SIZE2PAGES(E1000_TX_PACKETS_COUNT * sizeof(e1000_tx_descriptor_t)),
     1519            AS_AREA_READ | AS_AREA_WRITE, 0);
    15291520        if (rc != EOK)
    15301521                return rc;
    15311522       
    1532         bzero(e1000->tx_ring_virt,
     1523        bzero(e1000_data->tx_ring.virt,
    15331524            E1000_TX_PACKETS_COUNT * sizeof(e1000_tx_descriptor_t));
    15341525       
    1535         E1000_REG_WRITE(e1000, E1000_TDBAH,
    1536             (uint32_t) (PTR_TO_U64(e1000->tx_ring_phys) >> 32));
    1537         E1000_REG_WRITE(e1000, E1000_TDBAL,
    1538             (uint32_t) PTR_TO_U64(e1000->tx_ring_phys));
    1539        
    1540         e1000->tx_ring_packets =
     1526        E1000_REG_WRITE(e1000_data, E1000_TDBAH,
     1527            (uint32_t) (PTR_TO_U64(e1000_data->tx_ring.phys) >> 32));
     1528        E1000_REG_WRITE(e1000_data, E1000_TDBAL,
     1529            (uint32_t) PTR_TO_U64(e1000_data->tx_ring.phys));
     1530       
     1531        e1000_data->tx_ring_packets =
    15411532            malloc(E1000_TX_PACKETS_COUNT * sizeof(packet_t *));
    15421533        // FIXME: Check return value
    15431534       
    1544         e1000_initialize_tx_registers(e1000);
    1545        
    1546         fibril_mutex_unlock(&e1000->tx_lock);
     1535        e1000_initialize_tx_registers(e1000_data);
     1536       
     1537        fibril_mutex_unlock(&e1000_data->tx_lock);
    15471538        return EOK;
    15481539}
    … …  
    15501541/** Uninitialize transmit structure
    15511542 *
    1552  * @param nic NIC data
    1553  *
    1554  */
    1555 static void e1000_uninitialize_tx_structure(e1000_t *e1000)
    1556 {
    1557         free(e1000->tx_ring_packets);
    1558         dmamem_unmap_anonymous(e1000->tx_ring_virt);
     1543 * @param nic_data NIC data
     1544 *
     1545 */
     1546static void e1000_uninitialize_tx_structure(e1000_t *e1000_data)
     1547{
     1548        free(e1000_data->tx_ring_packets);
     1549        dmamem_unmap(&e1000_data->tx_ring);
    15591550}
    15601551
    15611552/** Clear transmit descriptor ring
    15621553 *
    1563  * @param nic NIC data
    1564  *
    1565  */
    1566 static void e1000_clear_tx_ring(nic_t *nic)
     1554 * @param nic_data NIC data
     1555 *
     1556 */
     1557static void e1000_clear_tx_ring(nic_t *nic_data)
    15671558{
    15681559        /* Write descriptor */
    … …  
    15701561            offset < E1000_TX_PACKETS_COUNT;
    15711562            offset++)
    1572                 e1000_clear_tx_descriptor(nic, offset);
     1563                e1000_clear_tx_descriptor(nic_data, offset);
    15731564}
    15741565
    15751566/** Enable transmit
    15761567 *
    1577  * @param e1000 E1000 data
    1578  *
    1579  */
    1580 static void e1000_enable_tx(e1000_t *e1000)
     1568 * @param e1000_data E1000 data
     1569 *
     1570 */
     1571static void e1000_enable_tx(e1000_t *e1000_data)
    15811572{
    15821573        /* Set Transmit Enable Bit */
    1583         E1000_REG_WRITE(e1000, E1000_TCTL,
    1584             E1000_REG_READ(e1000, E1000_TCTL) | (TCTL_EN));
     1574        E1000_REG_WRITE(e1000_data, E1000_TCTL,
     1575            E1000_REG_READ(e1000_data, E1000_TCTL) | (TCTL_EN));
    15851576}
    15861577
    15871578/** Disable transmit
    15881579 *
    1589  * @param e1000 E1000 data
    1590  *
    1591  */
    1592 static void e1000_disable_tx(e1000_t *e1000)
     1580 * @param e1000_data E1000 data
     1581 *
     1582 */
     1583static void e1000_disable_tx(e1000_t *e1000_data)
    15931584{
    15941585        /* Clear Transmit Enable Bit */
    1595         E1000_REG_WRITE(e1000, E1000_TCTL,
    1596             E1000_REG_READ(e1000, E1000_TCTL) & ~(TCTL_EN));
     1586        E1000_REG_WRITE(e1000_data, E1000_TCTL,
     1587            E1000_REG_READ(e1000_data, E1000_TCTL) & ~(TCTL_EN));
    15971588}
    15981589
    15991590/** Reset E1000 device
    16001591 *
    1601  * @param e1000 The E1000 data
    1602  *
    1603  */
    1604 static int e1000_reset(nic_t *nic)
    1605 {
    1606         e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    1607        
    1608         E1000_REG_WRITE(e1000, E1000_CTRL, CTRL_RST);
     1592 * @param e1000_data The E1000 data
     1593 *
     1594 */
     1595static int e1000_reset(nic_t *nic_data)
     1596{
     1597        e1000_t *e1000_data = DRIVER_DATA_NIC(nic_data);
     1598       
     1599        E1000_REG_WRITE(e1000_data, E1000_CTRL, CTRL_RST);
    16091600       
    16101601        /* Wait for the reset */
    … …  
    16121603       
    16131604        /* check if RST_BIT cleared */
    1614         if (E1000_REG_READ(e1000, E1000_CTRL) & (CTRL_RST))
     1605        if (E1000_REG_READ(e1000_data, E1000_CTRL) & (CTRL_RST))
    16151606                return EINVAL;
    16161607       
    1617         e1000_initialize_registers(e1000);
    1618         e1000_initialize_rx_registers(e1000);
    1619         e1000_initialize_tx_registers(e1000);
    1620         e1000_fill_mac_from_eeprom(e1000);
    1621         e1000_initialize_filters(e1000);
    1622         e1000_initialize_vlan(e1000);
     1608        e1000_initialize_registers(e1000_data);
     1609        e1000_initialize_rx_registers(e1000_data);
     1610        e1000_initialize_tx_registers(e1000_data);
     1611        e1000_fill_mac_from_eeprom(e1000_data);
     1612        e1000_initialize_filters(e1000_data);
     1613        e1000_initialize_vlan(e1000_data);
    16231614       
    16241615        return EOK;
    … …  
    16271618/** Activate the device to receive and transmit packets
    16281619 *
    1629  * @param nic NIC driver data
     1620 * @param nic_data NIC driver data
    16301621 *
    16311622 * @return EOK if activated successfully
    … …  
    16331624 *
    16341625 */
    1635 static int e1000_on_activating(nic_t *nic)
    1636 {
    1637         assert(nic);
    1638        
    1639         e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    1640        
    1641         fibril_mutex_lock(&e1000->rx_lock);
    1642         fibril_mutex_lock(&e1000->tx_lock);
    1643         fibril_mutex_lock(&e1000->ctrl_lock);
    1644        
    1645         e1000_enable_interrupts(e1000);
    1646        
    1647         nic_enable_interrupt(nic, e1000->irq);
    1648        
    1649         e1000_clear_rx_ring(e1000);
    1650         e1000_enable_rx(e1000);
    1651        
    1652         e1000_clear_tx_ring(nic);
    1653         e1000_enable_tx(e1000);
    1654        
    1655         uint32_t ctrl = E1000_REG_READ(e1000, E1000_CTRL);
     1626static int e1000_on_activating(nic_t *nic_data)
     1627{
     1628        assert(nic_data);
     1629       
     1630        e1000_t *e1000_data = DRIVER_DATA_NIC(nic_data);
     1631       
     1632        fibril_mutex_lock(&e1000_data->rx_lock);
     1633        fibril_mutex_lock(&e1000_data->tx_lock);
     1634        fibril_mutex_lock(&e1000_data->ctrl_lock);
     1635       
     1636        e1000_enable_interrupts(e1000_data);
     1637       
     1638        nic_enable_interrupt(nic_data, e1000_data->irq);
     1639       
     1640        e1000_clear_rx_ring(e1000_data);
     1641        e1000_enable_rx(e1000_data);
     1642       
     1643        e1000_clear_tx_ring(nic_data);
     1644        e1000_enable_tx(e1000_data);
     1645       
     1646        uint32_t ctrl = E1000_REG_READ(e1000_data, E1000_CTRL);
    16561647        ctrl |= CTRL_SLU;
    1657         E1000_REG_WRITE(e1000, E1000_CTRL, ctrl);
    1658        
    1659         fibril_mutex_unlock(&e1000->ctrl_lock);
    1660         fibril_mutex_unlock(&e1000->tx_lock);
    1661         fibril_mutex_unlock(&e1000->rx_lock);
     1648        E1000_REG_WRITE(e1000_data, E1000_CTRL, ctrl);
     1649       
     1650        fibril_mutex_unlock(&e1000_data->ctrl_lock);
     1651        fibril_mutex_unlock(&e1000_data->tx_lock);
     1652        fibril_mutex_unlock(&e1000_data->rx_lock);
    16621653       
    16631654        return EOK;
    … …  
    16661657/** Callback for NIC_STATE_DOWN change
    16671658 *
    1668  * @param nic NIC driver data
     1659 * @param nic_data NIC driver data
    16691660 *
    16701661 * @return EOK if succeed
    … …  
    16721663 *
    16731664 */
    1674 static int e1000_on_down_unlocked(nic_t *nic)
    1675 {
    1676         e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    1677        
    1678         uint32_t ctrl = E1000_REG_READ(e1000, E1000_CTRL);
     1665static int e1000_on_down_unlocked(nic_t *nic_data)
     1666{
     1667        e1000_t *e1000_data = DRIVER_DATA_NIC(nic_data);
     1668       
     1669        uint32_t ctrl = E1000_REG_READ(e1000_data, E1000_CTRL);
    16791670        ctrl &= ~CTRL_SLU;
    1680         E1000_REG_WRITE(e1000, E1000_CTRL, ctrl);
    1681        
    1682         e1000_disable_tx(e1000);
    1683         e1000_disable_rx(e1000);
    1684        
    1685         nic_disable_interrupt(nic, e1000->irq);
    1686         e1000_disable_interrupts(e1000);
     1671        E1000_REG_WRITE(e1000_data, E1000_CTRL, ctrl);
     1672       
     1673        e1000_disable_tx(e1000_data);
     1674        e1000_disable_rx(e1000_data);
     1675       
     1676        nic_disable_interrupt(nic_data, e1000_data->irq);
     1677        e1000_disable_interrupts(e1000_data);
    16871678       
    16881679        /*
    … …  
    16971688/** Callback for NIC_STATE_DOWN change
    16981689 *
    1699  * @param nic NIC driver data
     1690 * @param nic_data NIC driver data
    17001691 *
    17011692 * @return EOK if succeed
    … …  
    17031694 *
    17041695 */
    1705 static int e1000_on_down(nic_t *nic)
    1706 {
    1707         e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    1708        
    1709         fibril_mutex_lock(&e1000->rx_lock);
    1710         fibril_mutex_lock(&e1000->tx_lock);
    1711         fibril_mutex_lock(&e1000->ctrl_lock);
    1712        
    1713         int rc = e1000_on_down_unlocked(nic);
    1714        
    1715         fibril_mutex_unlock(&e1000->ctrl_lock);
    1716         fibril_mutex_unlock(&e1000->tx_lock);
    1717         fibril_mutex_unlock(&e1000->rx_lock);
     1696static int e1000_on_down(nic_t *nic_data)
     1697{
     1698        e1000_t *e1000_data = DRIVER_DATA_NIC(nic_data);
     1699       
     1700        fibril_mutex_lock(&e1000_data->rx_lock);
     1701        fibril_mutex_lock(&e1000_data->tx_lock);
     1702        fibril_mutex_lock(&e1000_data->ctrl_lock);
     1703       
     1704        int rc = e1000_on_down_unlocked(nic_data);
     1705       
     1706        fibril_mutex_unlock(&e1000_data->ctrl_lock);
     1707        fibril_mutex_unlock(&e1000_data->tx_lock);
     1708        fibril_mutex_unlock(&e1000_data->rx_lock);
    17181709       
    17191710        return rc;
    … …  
    17221713/** Callback for NIC_STATE_STOPPED change
    17231714 *
    1724  * @param nic NIC driver data
     1715 * @param nic_data NIC driver data
    17251716 *
    17261717 * @return EOK if succeed
    … …  
    17281719 *
    17291720 */
    1730 static int e1000_on_stopping(nic_t *nic)
    1731 {
    1732         e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    1733        
    1734         fibril_mutex_lock(&e1000->rx_lock);
    1735         fibril_mutex_lock(&e1000->tx_lock);
    1736         fibril_mutex_lock(&e1000->ctrl_lock);
    1737        
    1738         int rc = e1000_on_down_unlocked(nic);
     1721static int e1000_on_stopping(nic_t *nic_data)
     1722{
     1723        e1000_t *e1000_data = DRIVER_DATA_NIC(nic_data);
     1724       
     1725        fibril_mutex_lock(&e1000_data->rx_lock);
     1726        fibril_mutex_lock(&e1000_data->tx_lock);
     1727        fibril_mutex_lock(&e1000_data->ctrl_lock);
     1728       
     1729        int rc = e1000_on_down_unlocked(nic_data);
    17391730        if (rc == EOK)
    1740                 rc = e1000_reset(nic);
    1741        
    1742         fibril_mutex_unlock(&e1000->ctrl_lock);
    1743         fibril_mutex_unlock(&e1000->tx_lock);
    1744         fibril_mutex_unlock(&e1000->rx_lock);
     1731                rc = e1000_reset(nic_data);
     1732       
     1733        fibril_mutex_unlock(&e1000_data->ctrl_lock);
     1734        fibril_mutex_unlock(&e1000_data->tx_lock);
     1735        fibril_mutex_unlock(&e1000_data->rx_lock);
    17451736       
    17461737        return rc;
    … …  
    17571748        assert(!dev->driver_data);
    17581749       
    1759         nic_t *nic = nic_create_and_bind(dev);
    1760         if (!nic)
     1750        nic_t *nic_data = nic_create_and_bind(dev);
     1751        if (!nic_data)
    17611752                return NULL;
    17621753       
    1763         e1000_t *e1000 = malloc(sizeof(e1000_t));
    1764         if (!e1000) {
     1754        e1000_t *e1000_data = malloc(sizeof(e1000_t));
     1755        if (!e1000_data) {
    17651756                nic_unbind_and_destroy(dev);
    17661757                return NULL;
    17671758        }
    17681759       
    1769         bzero(e1000, sizeof(e1000_t));
    1770        
    1771         nic_set_specific(nic, e1000);
    1772         nic_set_write_packet_handler(nic, e1000_write_packet);
    1773         nic_set_state_change_handlers(nic, e1000_on_activating,
     1760        bzero(e1000_data, sizeof(e1000_t));
     1761       
     1762        nic_set_specific(nic_data, e1000_data);
     1763        nic_set_write_packet_handler(nic_data, e1000_write_packet);
     1764        nic_set_state_change_handlers(nic_data, e1000_on_activating,
    17741765            e1000_on_down, e1000_on_stopping);
    1775         nic_set_filtering_change_handlers(nic,
     1766        nic_set_filtering_change_handlers(nic_data,
    17761767            e1000_on_unicast_mode_change, e1000_on_multicast_mode_change,
    17771768            e1000_on_broadcast_mode_change, NULL, e1000_on_vlan_mask_change);
    1778         nic_set_poll_handlers(nic, e1000_poll_mode_change, e1000_poll);
    1779        
    1780         fibril_mutex_initialize(&e1000->ctrl_lock);
    1781         fibril_mutex_initialize(&e1000->rx_lock);
    1782         fibril_mutex_initialize(&e1000->tx_lock);
    1783         fibril_mutex_initialize(&e1000->eeprom_lock);
    1784        
    1785         return e1000;
     1769        nic_set_poll_handlers(nic_data, e1000_poll_mode_change, e1000_poll);
     1770       
     1771        fibril_mutex_initialize(&e1000_data->ctrl_lock);
     1772        fibril_mutex_initialize(&e1000_data->rx_lock);
     1773        fibril_mutex_initialize(&e1000_data->tx_lock);
     1774        fibril_mutex_initialize(&e1000_data->eeprom_lock);
     1775       
     1776        return e1000_data;
    17861777}
    17871778
    … …  
    18341825        assert(dev->driver_data != NULL);
    18351826       
    1836         e1000_t *e1000 = DRIVER_DATA_DEV(dev);
     1827        e1000_t *e1000_data = DRIVER_DATA_DEV(dev);
    18371828       
    18381829        if (hw_resources->irqs.count != 1)
    18391830                return EINVAL;
    18401831       
    1841         e1000->irq = hw_resources->irqs.irqs[0];
    1842         e1000->reg_base_phys =
     1832        e1000_data->irq = hw_resources->irqs.irqs[0];
     1833        e1000_data->phys_reg_base =
    18431834            MEMADDR_TO_PTR(hw_resources->mem_ranges.ranges[0].address);
    18441835       
    … …  
    18871878{
    18881879        /* Allocate driver data for the device. */
    1889         e1000_t *e1000 = e1000_create_dev_data(dev);
    1890         if (e1000 == NULL)
     1880        e1000_t *e1000_data = e1000_create_dev_data(dev);
     1881        if (e1000_data == NULL)
    18911882                return ENOMEM;
    18921883       
    … …  
    18991890       
    19001891        rc = pci_config_space_read_16(dev->parent_sess, PCI_DEVICE_ID,
    1901             &e1000->device_id);
     1892            &e1000_data->device_id);
    19021893        if (rc != EOK) {
    19031894                e1000_dev_cleanup(dev);
    … …  
    19181909static int e1000_pio_enable(ddf_dev_t *dev)
    19191910{
    1920         e1000_t *e1000 = DRIVER_DATA_DEV(dev);
    1921        
    1922         int rc = pio_enable(e1000->reg_base_phys, 8 * PAGE_SIZE,
    1923             &e1000->reg_base_virt);
     1911        e1000_t *e1000_data = DRIVER_DATA_DEV(dev);
     1912       
     1913        int rc = pio_enable(e1000_data->phys_reg_base, 8 * PAGE_SIZE,
     1914            &e1000_data->virt_reg_base);
    19241915        if (rc != EOK)
    19251916                return EADDRNOTAVAIL;
    … …  
    19431934       
    19441935        /* Device initialization */
    1945         nic_t *nic = dev->driver_data;
    1946         e1000_t *e1000 = DRIVER_DATA_NIC(nic);
     1936        nic_t *nic_data = dev->driver_data;
     1937        e1000_t *e1000_data = DRIVER_DATA_NIC(nic_data);
    19471938       
    19481939        /* Map registers */
    … …  
    19511942                goto err_destroy;
    19521943       
    1953         e1000_initialize_registers(e1000);
    1954         rc = e1000_initialize_tx_structure(e1000);
     1944        e1000_initialize_registers(e1000_data);
     1945        rc = e1000_initialize_tx_structure(e1000_data);
    19551946        if (rc != EOK)
    19561947                goto err_pio;
    19571948       
    1958         fibril_mutex_lock(&e1000->rx_lock);
    1959        
    1960         e1000_fill_mac_from_eeprom(e1000);
    1961         e1000_initialize_filters(e1000);
    1962        
    1963         fibril_mutex_unlock(&e1000->rx_lock);
    1964        
    1965         e1000_initialize_vlan(e1000);
    1966        
    1967         rc = nic_register_as_ddf_fun(nic, &e1000_dev_ops);
     1949        fibril_mutex_lock(&e1000_data->rx_lock);
     1950       
     1951        e1000_fill_mac_from_eeprom(e1000_data);
     1952        e1000_initialize_filters(e1000_data);
     1953       
     1954        fibril_mutex_unlock(&e1000_data->rx_lock);
     1955       
     1956        e1000_initialize_vlan(e1000_data);
     1957       
     1958        rc = nic_register_as_ddf_fun(nic_data, &e1000_dev_ops);
    19681959        if (rc != EOK)
    19691960                goto err_tx_structure;
    19701961       
    1971         rc = e1000_register_int_handler(nic);
     1962        rc = e1000_register_int_handler(nic_data);
    19721963        if (rc != EOK)
    19731964                goto err_tx_structure;
    19741965       
    1975         rc = nic_connect_to_services(nic);
     1966        rc = nic_connect_to_services(nic_data);
    19761967        if (rc != EOK)
    19771968                goto err_irq;
    19781969       
    1979         rc = e1000_initialize_rx_structure(nic);
     1970        rc = e1000_initialize_rx_structure(nic_data);
    19801971        if (rc != EOK)
    19811972                goto err_irq;
    19821973       
    19831974        nic_address_t e1000_address;
    1984         e1000_get_address(e1000, &e1000_address);
    1985         rc = nic_report_address(nic, &e1000_address);
     1975        e1000_get_address(e1000_data, &e1000_address);
     1976        rc = nic_report_address(nic_data, &e1000_address);
    19861977        if (rc != EOK)
    19871978                goto err_rx_structure;
    … …  
    19901981        period.tv_sec = 0;
    19911982        period.tv_usec = E1000_DEFAULT_INTERRUPT_INTERVAL_USEC;
    1992         rc = nic_report_poll_mode(nic, NIC_POLL_PERIODIC, &period);
     1983        rc = nic_report_poll_mode(nic_data, NIC_POLL_PERIODIC, &period);
    19931984        if (rc != EOK)
    19941985                goto err_rx_structure;
    … …  
    19971988       
    19981989err_rx_structure:
    1999         e1000_uninitialize_rx_structure(nic);
     1990        e1000_uninitialize_rx_structure(nic_data);
    20001991err_irq:
    20011992        unregister_interrupt_handler(dev, DRIVER_DATA_DEV(dev)->irq);
    20021993err_tx_structure:
    2003         e1000_uninitialize_tx_structure(e1000);
     1994        e1000_uninitialize_tx_structure(e1000_data);
    20041995err_pio:
    20051996        // TODO: e1000_pio_disable(dev);
    … …  
    20192010 *
    20202011 */
    2021 static uint16_t e1000_eeprom_read(e1000_t *e1000, uint8_t eeprom_address)
    2022 {
    2023         fibril_mutex_lock(&e1000->eeprom_lock);
     2012static uint16_t e1000_eeprom_read(e1000_t *e1000_data, uint8_t eeprom_address)
     2013{
     2014        fibril_mutex_lock(&e1000_data->eeprom_lock);
    20242015       
    20252016        uint32_t eerd_done;
    20262017        uint32_t eerd_address_offset;
    20272018       
    2028         switch (e1000->device_id) {
     2019        switch (e1000_data->device_id) {
    20292020        case 0x107c:
    20302021        case 0x1013:
    … …  
    20492040        uint32_t write_data = EERD_START |
    20502041            (((uint32_t) eeprom_address) << eerd_address_offset);
    2051         E1000_REG_WRITE(e1000, E1000_EERD, write_data);
    2052        
    2053         uint32_t eerd = E1000_REG_READ(e1000, E1000_EERD);
     2042        E1000_REG_WRITE(e1000_data, E1000_EERD, write_data);
     2043       
     2044        uint32_t eerd = E1000_REG_READ(e1000_data, E1000_EERD);
    20542045        while ((eerd & eerd_done) == 0) {
    20552046                usleep(1);
    2056                 eerd = E1000_REG_READ(e1000, E1000_EERD);
     2047                eerd = E1000_REG_READ(e1000_data, E1000_EERD);
    20572048        }
    20582049       
    2059         fibril_mutex_unlock(&e1000->eeprom_lock);
     2050        fibril_mutex_unlock(&e1000_data->eeprom_lock);
    20602051       
    20612052        return (uint16_t) (eerd >> EERD_DATA_OFFSET);
    … …  
    20722063 *
    20732064 */
    2074 static int e1000_get_address(e1000_t *e1000, nic_address_t *address)
    2075 {
    2076         fibril_mutex_lock(&e1000->rx_lock);
     2065static int e1000_get_address(e1000_t *e1000_data, nic_address_t *address)
     2066{
     2067        fibril_mutex_lock(&e1000_data->rx_lock);
    20772068       
    20782069        uint8_t *mac0_dest = (uint8_t *) address->address;
    … …  
    20832074        uint8_t *mac5_dest = (uint8_t *) address->address + 5;
    20842075       
    2085         uint32_t rah = E1000_REG_READ(e1000, E1000_RAH_ARRAY(0));
    2086         uint32_t ral = E1000_REG_READ(e1000, E1000_RAL_ARRAY(0));
     2076        uint32_t rah = E1000_REG_READ(e1000_data, E1000_RAH_ARRAY(0));
     2077        uint32_t ral = E1000_REG_READ(e1000_data, E1000_RAL_ARRAY(0));
    20872078       
    20882079        *mac0_dest = (uint8_t) ral;
    … …  
    20932084        *mac5_dest = (uint8_t) (rah >> 8);
    20942085       
    2095         fibril_mutex_unlock(&e1000->rx_lock);
     2086        fibril_mutex_unlock(&e1000_data->rx_lock);
    20962087        return EOK;
    20972088};
    … …  
    21072098static int e1000_set_addr(ddf_fun_t *dev, const nic_address_t *addr)
    21082099{
    2109         nic_t *nic = NIC_DATA_DEV(dev);
    2110         e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    2111        
    2112         fibril_mutex_lock(&e1000->rx_lock);
    2113         fibril_mutex_lock(&e1000->tx_lock);
    2114        
    2115         int rc = nic_report_address(nic, addr);
     2100        nic_t *nic_data = NIC_DATA_DEV(dev);
     2101        e1000_t *e1000_data = DRIVER_DATA_NIC(nic_data);
     2102       
     2103        fibril_mutex_lock(&e1000_data->rx_lock);
     2104        fibril_mutex_lock(&e1000_data->tx_lock);
     2105       
     2106        int rc = nic_report_address(nic_data, addr);
    21162107        if (rc == EOK)
    2117                 e1000_write_receive_address(e1000, 0, addr, false);
    2118        
    2119         fibril_mutex_unlock(&e1000->tx_lock);
    2120         fibril_mutex_unlock(&e1000->rx_lock);
     2108                e1000_write_receive_address(e1000_data, 0, addr, false);
     2109       
     2110        fibril_mutex_unlock(&e1000_data->tx_lock);
     2111        fibril_mutex_unlock(&e1000_data->rx_lock);
    21212112       
    21222113        return rc;
    21232114}
    21242115
    2125 static void e1000_eeprom_get_address(e1000_t *e1000,
     2116static void e1000_eeprom_get_address(e1000_t *e1000_data,
    21262117    nic_address_t *address)
    21272118{
    … …  
    21302121        uint16_t *mac4_dest = (uint16_t *) (address->address + 4);
    21312122       
    2132         *mac0_dest = e1000_eeprom_read(e1000, 0);
    2133         *mac2_dest = e1000_eeprom_read(e1000, 1);
    2134         *mac4_dest = e1000_eeprom_read(e1000, 2);
     2123        *mac0_dest = e1000_eeprom_read(e1000_data, 0);
     2124        *mac2_dest = e1000_eeprom_read(e1000_data, 1);
     2125        *mac4_dest = e1000_eeprom_read(e1000_data, 2);
    21352126}
    21362127
    21372128/** Send packet
    21382129 *
    2139  * @param nic    NIC driver data structure
    2140  * @param packet Packet to send
     2130 * @param nic_data NIC driver data structure
     2131 * @param packet   Packet to send
    21412132 *
    21422133 * @return EOK if succeed
    … …  
    21442135 *
    21452136 */
    2146 static void e1000_write_packet(nic_t *nic, packet_t *packet)
    2147 {
    2148         assert(nic);
    2149        
    2150         e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    2151         fibril_mutex_lock(&e1000->tx_lock);
    2152        
    2153         uint32_t tdt = E1000_REG_READ(e1000, E1000_TDT);
     2137static void e1000_write_packet(nic_t *nic_data, packet_t *packet)
     2138{
     2139        assert(nic_data);
     2140       
     2141        e1000_t *e1000_data = DRIVER_DATA_NIC(nic_data);
     2142        fibril_mutex_lock(&e1000_data->tx_lock);
     2143       
     2144        uint32_t tdt = E1000_REG_READ(e1000_data, E1000_TDT);
    21542145        e1000_tx_descriptor_t *tx_descriptor_addr = (e1000_tx_descriptor_t *)
    2155             (e1000->tx_ring_virt + tdt * sizeof(e1000_tx_descriptor_t));
     2146            (e1000_data->tx_ring.virt + tdt * sizeof(e1000_tx_descriptor_t));
    21562147       
    21572148        bool descriptor_available = false;
    … …  
    21642155        if (tx_descriptor_addr->status & TXDESCRIPTOR_STATUS_DD) {
    21652156                descriptor_available = true;
    2166                 packet_t *old_packet = *(e1000->tx_ring_packets + tdt);
     2157                packet_t *old_packet = *(e1000_data->tx_ring_packets + tdt);
    21672158                if (old_packet) {
    2168                         size_t old_packet_size = packet_get_data_length(old_packet);
    2169                         nic_dma_unlock_packet(old_packet, old_packet_size);
    2170                         nic_release_packet(nic, old_packet);
     2159                        nic_dma_unlock_packet(old_packet);
     2160                        nic_release_packet(nic_data, old_packet);
    21712161                }
    21722162        }
    … …  
    21742164        if (!descriptor_available) {
    21752165                /* Packet lost */
    2176                 fibril_mutex_unlock(&e1000->tx_lock);
     2166                fibril_mutex_unlock(&e1000_data->tx_lock);
    21772167                return;
    21782168        }
    … …  
    21802170        size_t packet_size = packet_get_data_length(packet);
    21812171       
    2182         void *phys;
    2183         int rc = nic_dma_lock_packet(packet, packet_size, &phys);
    2184         if (rc != EOK) {
    2185                 fibril_mutex_unlock(&e1000->tx_lock);
     2172        void *phys_addr = nic_dma_lock_packet(packet);
     2173        if (!phys_addr) {
     2174                fibril_mutex_unlock(&e1000_data->tx_lock);
    21862175                return;
    21872176        }
    21882177       
    2189         *(e1000->tx_ring_packets + tdt) = packet;
     2178        *(e1000_data->tx_ring_packets + tdt) = packet;
    21902179       
    21912180        tx_descriptor_addr->phys_addr =
    2192             PTR_TO_U64(phys + packet->data_start);
     2181            PTR_TO_U64(phys_addr + packet->data_start);
    21932182        tx_descriptor_addr->length = packet_size;
    21942183       
    … …  
    22032192        tx_descriptor_addr->checksum_offset = 0;
    22042193        tx_descriptor_addr->status = 0;
    2205         if (e1000->vlan_tag_add) {
    2206                 tx_descriptor_addr->special = e1000->vlan_tag;
     2194        if (e1000_data->vlan_tag_add) {
     2195                tx_descriptor_addr->special = e1000_data->vlan_tag;
    22072196                tx_descriptor_addr->command |= TXDESCRIPTOR_COMMAND_VLE;
    22082197        } else
    … …  
    22152204                tdt = 0;
    22162205       
    2217         E1000_REG_WRITE(e1000, E1000_TDT, tdt);
    2218        
    2219         fibril_mutex_unlock(&e1000->tx_lock);
     2206        E1000_REG_WRITE(e1000_data, E1000_TDT, tdt);
     2207       
     2208        fibril_mutex_unlock(&e1000_data->tx_lock);
    22202209}
    22212210
    … …  
    22262215                return rc;
    22272216       
    2228         nic_driver_implement(&e1000_driver_ops, &e1000_dev_ops,
    2229             &e1000_nic_iface);
     2217        nic_driver_implement(&e1000_driver_ops, &e1000_dev_ops, &e1000_nic_iface);
    22302218        return ddf_driver_main(&e1000_driver);
    22312219}
Note: See TracChangeset for help on using the changeset viewer.