Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset c4be33a in mainline


Ignore:
Timestamp:
2011-12-16T21:15:37Z (10 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master
Children:
792807f
Parents:
c8751452
Message:

e1k: reflect infrastructure changes, more code cleanup, enable by default

Files:
1 added
3 edited

Legend:

Unmodified
Added
Removed
  • boot/Makefile.common

    rc8751452 rc4be33a  
    123123        test/test3 \
    124124        nic/lo \
    125         nic/ne2k
     125        nic/ne2k \
     126        nic/e1k
    126127
    127128RD_DRV_CFG =
     
    203204        $(USPACE_PATH)/srv/net/cfg/general \
    204205        $(USPACE_PATH)/srv/net/cfg/lo.nic \
    205         $(USPACE_PATH)/srv/net/cfg/ne2k.nic
     206        $(USPACE_PATH)/srv/net/cfg/ne2k.nic \
     207        $(USPACE_PATH)/srv/net/cfg/e1k.nic
    206208endif
    207209
  • uspace/drv/nic/e1k/e1k.c

    rc8751452 rc4be33a  
    7070
    7171/** nic_driver_data_t* -> e1000_t* cast */
    72 #define DRIVER_DATA_NIC(nic_data) \
    73         ((e1000_t *) nic_get_specific(nic_data))
     72#define DRIVER_DATA_NIC(nic) \
     73        ((e1000_t *) nic_get_specific(nic))
    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_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))
     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))
    110110
    111111/** E1000 device data */
    112 typedef struct e1000_data {
     112typedef struct {
    113113        /** Physical registers base address */
    114         void *phys_reg_base;
     114        void *reg_base_phys;
    115115        /** Virtual registers base address */
    116         void *virt_reg_base;
    117         /** Tx ring */
    118         dmamem_t tx_ring;
     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       
    119123        /** Packets in tx ring  */
    120124        packet_t **tx_ring_packets;
    121         /** Rx ring */
    122         dmamem_t rx_ring;
     125       
     126        /** Physical rx ring address */
     127        void *rx_ring_phys;
     128        /** Virtual rx ring address */
     129        void *rx_ring_virt;
     130       
    123131        /** Packets in rx ring  */
    124132        packet_t **rx_ring_packets;
     133       
    125134        /** VLAN tag */
    126135        uint16_t vlan_tag;
     136       
    127137        /** Add VLAN tag to packet */
    128138        bool vlan_tag_add;
     139       
    129140        /** Used unicast Receive Address count */
    130141        unsigned int unicast_ra_count;
     142       
    131143        /** Used milticast Receive addrress count */
    132144        unsigned int multicast_ra_count;
     145       
    133146        /** PCI device ID */
    134147        uint16_t device_id;
     148       
    135149        /** The irq assigned */
    136150        int irq;
     151       
    137152        /** Lock for CTRL register */
    138153        fibril_mutex_t ctrl_lock;
     154       
    139155        /** Lock for receiver */
    140156        fibril_mutex_t rx_lock;
     157       
    141158        /** Lock for transmitter */
    142159        fibril_mutex_t tx_lock;
     160       
    143161        /** Lock for EEPROM access */
    144162        fibril_mutex_t eeprom_lock;
     
    225243                .cmd = CMD_PIO_WRITE_32,
    226244                .addr = NULL,
    227                 .value = 0xFFFFFFFF
     245                .value = 0xffffffff
    228246        },
    229247        {
     
    280298        assert(state);
    281299       
    282         e1000_t *e1000_data = DRIVER_DATA_DEV(dev);
    283         if (E1000_REG_READ(e1000_data, E1000_STATUS) & (STATUS_LU))
     300        e1000_t *e1000 = DRIVER_DATA_DEV(dev);
     301        if (E1000_REG_READ(e1000, E1000_STATUS) & (STATUS_LU))
    284302                *state = NIC_CS_PLUGGED;
    285303        else
     
    300318    nic_channel_mode_t *duplex, nic_role_t *role)
    301319{
    302         e1000_t *e1000_data = DRIVER_DATA_DEV(dev);
    303         uint32_t status = E1000_REG_READ(e1000_data, E1000_STATUS);
     320        e1000_t *e1000 = DRIVER_DATA_DEV(dev);
     321        uint32_t status = E1000_REG_READ(e1000, E1000_STATUS);
    304322       
    305323        if (status & STATUS_FD)
     
    323341}
    324342
    325 static 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);
     343static 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);
    330348       
    331349        if (ctrl & CTRL_SLU) {
    332350                ctrl &= ~(CTRL_SLU);
    333                 fibril_mutex_unlock(&e1000_data->ctrl_lock);
     351                fibril_mutex_unlock(&e1000->ctrl_lock);
    334352                usleep(10);
    335                 fibril_mutex_lock(&e1000_data->ctrl_lock);
     353                fibril_mutex_lock(&e1000->ctrl_lock);
    336354                ctrl |= CTRL_SLU;
    337355        }
    338356       
    339         fibril_mutex_unlock(&e1000_data->ctrl_lock);
    340        
    341         e1000_link_restart(e1000_data);
     357        fibril_mutex_unlock(&e1000->ctrl_lock);
     358       
     359        e1000_link_restart(e1000);
    342360}
    343361
     
    354372                return EINVAL;
    355373       
    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);
     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);
    360378       
    361379        ctrl |= CTRL_FRCSPD;
     
    376394                ctrl |= CTRL_SPEED_10 << CTRL_SPEED_SHIFT;
    377395       
    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);
     396        E1000_REG_WRITE(e1000, E1000_CTRL, ctrl);
     397       
     398        fibril_mutex_unlock(&e1000->ctrl_lock);
     399       
     400        e1000_link_restart(e1000);
    383401       
    384402        return EOK;
     
    395413static int e1000_autoneg_enable(ddf_fun_t *dev, uint32_t advertisement)
    396414{
    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);
     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);
    402420       
    403421        ctrl &= ~(CTRL_FRCSPD);
     
    405423        ctrl |= CTRL_ASDE;
    406424       
    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);
     425        E1000_REG_WRITE(e1000, E1000_CTRL, ctrl);
     426       
     427        fibril_mutex_unlock(&e1000->ctrl_lock);
     428       
     429        e1000_link_restart(e1000);
    412430       
    413431        return EOK;
     
    423441static int e1000_autoneg_disable(ddf_fun_t *dev)
    424442{
    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);
     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);
    430448       
    431449        ctrl |= CTRL_FRCSPD;
     
    433451        ctrl &= ~(CTRL_ASDE);
    434452       
    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);
     453        E1000_REG_WRITE(e1000, E1000_CTRL, ctrl);
     454       
     455        fibril_mutex_unlock(&e1000->ctrl_lock);
     456       
     457        e1000_link_restart(e1000);
    440458       
    441459        return EOK;
     
    462480static int e1000_defective_get_mode(ddf_fun_t *device, uint32_t *mode)
    463481{
    464         e1000_t *e1000_data = DRIVER_DATA_DEV(device);
     482        e1000_t *e1000 = DRIVER_DATA_DEV(device);
    465483       
    466484        *mode = 0;
    467         uint32_t rctl = E1000_REG_READ(e1000_data, E1000_RCTL);
     485        uint32_t rctl = E1000_REG_READ(e1000, E1000_RCTL);
    468486        if (rctl & RCTL_SBP)
    469487                *mode = NIC_DEFECTIVE_BAD_CRC | NIC_DEFECTIVE_SHORT;
     
    483501static int e1000_defective_set_mode(ddf_fun_t *device, uint32_t mode)
    484502{
    485         e1000_t *e1000_data = DRIVER_DATA_DEV(device);
     503        e1000_t *e1000 = DRIVER_DATA_DEV(device);
    486504        int rc = EOK;
    487505       
    488         fibril_mutex_lock(&e1000_data->rx_lock);
    489        
    490         uint32_t rctl = E1000_REG_READ(e1000_data, E1000_RCTL);
     506        fibril_mutex_lock(&e1000->rx_lock);
     507       
     508        uint32_t rctl = E1000_REG_READ(e1000, E1000_RCTL);
    491509        bool short_mode = (mode & NIC_DEFECTIVE_SHORT ? true : false);
    492510        bool bad_mode = (mode & NIC_DEFECTIVE_BAD_CRC ? true : false);
     
    499517                rc = ENOTSUP;
    500518       
    501         E1000_REG_WRITE(e1000_data, E1000_RCTL, rctl);
    502        
    503         fibril_mutex_unlock(&e1000_data->rx_lock);
     519        E1000_REG_WRITE(e1000, E1000_RCTL, rctl);
     520       
     521        fibril_mutex_unlock(&e1000->rx_lock);
    504522        return rc;
    505523};
     
    507525/** Write receive address to RA registr
    508526 *
    509  * @param e1000_data E1000 data structure
     527 * @param e1000      E1000 data structure
    510528 * @param position   RA register position
    511529 * @param address    Ethernet address
     
    513531 *
    514532 */
    515 static void e1000_write_receive_address(e1000_t *e1000_data,
    516     unsigned int position, const nic_address_t * address,
    517     bool set_av_bit)
     533static void e1000_write_receive_address(e1000_t *e1000, unsigned int position,
     534    const nic_address_t * address, bool set_av_bit)
    518535{
    519536        uint8_t *mac0 = (uint8_t *) address->address;
     
    533550                rah |= RAH_AV;
    534551        else
    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);
     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);
    540556}
    541557
     
    544560 *  Clear Address Valid bit
    545561 *
    546  * @param e1000_data E1000 data structure
    547  * @param position   RA register position
    548  *
    549  */
    550 static 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));
     562 * @param e1000    E1000 data structure
     563 * @param position RA register position
     564 *
     565 */
     566static void e1000_disable_receive_address(e1000_t *e1000, unsigned int position)
     567{
     568        uint32_t rah = E1000_REG_READ(e1000, E1000_RAH_ARRAY(position));
    555569        rah = rah & ~RAH_AV;
    556         E1000_REG_WRITE(e1000_data, E1000_RAH_ARRAY(position), rah);
     570        E1000_REG_WRITE(e1000, E1000_RAH_ARRAY(position), rah);
    557571}
    558572
    559573/** Clear all unicast addresses from RA registers
    560574 *
    561  * @param e1000_data E1000 data structure
    562  *
    563  */
    564 static void e1000_clear_unicast_receive_addresses(e1000_t *e1000_data)
     575 * @param e1000 E1000 data structure
     576 *
     577 */
     578static void e1000_clear_unicast_receive_addresses(e1000_t *e1000)
    565579{
    566580        for (unsigned int ra_num = 1;
    567             ra_num <= e1000_data->unicast_ra_count;
     581            ra_num <= e1000->unicast_ra_count;
    568582            ra_num++)
    569                 e1000_disable_receive_address(e1000_data, ra_num);
    570        
    571         e1000_data->unicast_ra_count = 0;
     583                e1000_disable_receive_address(e1000, ra_num);
     584       
     585        e1000->unicast_ra_count = 0;
    572586}
    573587
    574588/** Clear all multicast addresses from RA registers
    575589 *
    576  * @param e1000_data E1000 data structure
    577  *
    578  */
    579 static void e1000_clear_multicast_receive_addresses(e1000_t *e1000_data)
     590 * @param e1000 E1000 data structure
     591 *
     592 */
     593static void e1000_clear_multicast_receive_addresses(e1000_t *e1000)
    580594{
    581595        unsigned int first_multicast_ra_num =
    582             E1000_RECEIVE_ADDRESS - e1000_data->multicast_ra_count;
     596            E1000_RECEIVE_ADDRESS - e1000->multicast_ra_count;
    583597       
    584598        for (unsigned int ra_num = E1000_RECEIVE_ADDRESS - 1;
    585599            ra_num >= first_multicast_ra_num;
    586600            ra_num--)
    587                 e1000_disable_receive_address(e1000_data, ra_num);
    588        
    589         e1000_data->multicast_ra_count = 0;
     601                e1000_disable_receive_address(e1000, ra_num);
     602       
     603        e1000->multicast_ra_count = 0;
    590604}
    591605
    592606/** Return receive address filter positions count usable for unicast
    593607 *
    594  * @param e1000_data E1000 data structure
     608 * @param e1000 E1000 data structure
    595609 *
    596610 * @return receive address filter positions count usable for unicast
    597611 *
    598612 */
    599 static unsigned int get_free_unicast_address_count(e1000_t *e1000_data)
    600 {
    601         return E1000_RECEIVE_ADDRESS - 1 - e1000_data->multicast_ra_count;
     613static unsigned int get_free_unicast_address_count(e1000_t *e1000)
     614{
     615        return E1000_RECEIVE_ADDRESS - 1 - e1000->multicast_ra_count;
    602616}
    603617
    604618/** Return receive address filter positions count usable for multicast
    605619 *
    606  * @param e1000_data E1000 data structure
     620 * @param e1000 E1000 data structure
    607621 *
    608622 * @return receive address filter positions count usable for multicast
    609623 *
    610624 */
    611 static unsigned int get_free_multicast_address_count(e1000_t *e1000_data)
    612 {
    613         return E1000_RECEIVE_ADDRESS - 1 - e1000_data->unicast_ra_count;
     625static unsigned int get_free_multicast_address_count(e1000_t *e1000)
     626{
     627        return E1000_RECEIVE_ADDRESS - 1 - e1000->unicast_ra_count;
    614628}
    615629
    616630/** Write unicast receive addresses to receive address filter registers
    617631 *
    618  * @param e1000_data E1000 data structure
    619  * @param addr       Pointer to address array
    620  * @param addr_cnt   Address array count
    621  *
    622  */
    623 static void e1000_add_unicast_receive_addresses(e1000_t *e1000_data,
     632 * @param e1000    E1000 data structure
     633 * @param addr     Pointer to address array
     634 * @param addr_cnt Address array count
     635 *
     636 */
     637static void e1000_add_unicast_receive_addresses(e1000_t *e1000,
    624638    const nic_address_t *addr, size_t addr_cnt)
    625639{
    626         assert(addr_cnt <= get_free_unicast_address_count(e1000_data));
     640        assert(addr_cnt <= get_free_unicast_address_count(e1000));
    627641       
    628642        nic_address_t *addr_iterator = (nic_address_t *) addr;
     
    632646            ra_num <= addr_cnt;
    633647            ra_num++) {
    634                 e1000_write_receive_address(e1000_data, ra_num, addr_iterator, true);
     648                e1000_write_receive_address(e1000, ra_num, addr_iterator, true);
    635649                addr_iterator++;
    636650        }
     
    639653/** Write multicast receive addresses to receive address filter registers
    640654 *
    641  * @param e1000_data E1000 data structure
    642  * @param addr       Pointer to address array
    643  * @param addr_cnt   Address array count
    644  *
    645  */
    646 static void e1000_add_multicast_receive_addresses(e1000_t *e1000_data,
     655 * @param e1000    E1000 data structure
     656 * @param addr     Pointer to address array
     657 * @param addr_cnt Address array count
     658 *
     659 */
     660static void e1000_add_multicast_receive_addresses(e1000_t *e1000,
    647661    const nic_address_t *addr, size_t addr_cnt)
    648662{
    649         assert(addr_cnt <= get_free_multicast_address_count(e1000_data));
     663        assert(addr_cnt <= get_free_multicast_address_count(e1000));
    650664       
    651665        nic_address_t *addr_iterator = (nic_address_t *) addr;
     
    655669            ra_num >= first_multicast_ra_num;
    656670            ra_num--) {
    657                 e1000_write_receive_address(e1000_data, ra_num, addr_iterator, true);
     671                e1000_write_receive_address(e1000, ra_num, addr_iterator, true);
    658672                addr_iterator++;
    659673        }
     
    662676/** Disable receiving packets for default address
    663677 *
    664  * @param e1000_data E1000 data structure
    665  *
    666  */
    667 static void disable_ra0_address_filter(e1000_t *e1000_data)
    668 {
    669         uint32_t rah0 = E1000_REG_READ(e1000_data, E1000_RAH_ARRAY(0));
     678 * @param e1000 E1000 data structure
     679 *
     680 */
     681static void disable_ra0_address_filter(e1000_t *e1000)
     682{
     683        uint32_t rah0 = E1000_REG_READ(e1000, E1000_RAH_ARRAY(0));
    670684        rah0 = rah0 & ~RAH_AV;
    671         E1000_REG_WRITE(e1000_data, E1000_RAH_ARRAY(0), rah0);
     685        E1000_REG_WRITE(e1000, E1000_RAH_ARRAY(0), rah0);
    672686}
    673687
    674688/** Enable receiving packets for default address
    675689 *
    676  * @param e1000_data E1000 data structure
    677  *
    678  */
    679 static void enable_ra0_address_filter(e1000_t *e1000_data)
    680 {
    681         uint32_t rah0 = E1000_REG_READ(e1000_data, E1000_RAH_ARRAY(0));
     690 * @param e1000 E1000 data structure
     691 *
     692 */
     693static void enable_ra0_address_filter(e1000_t *e1000)
     694{
     695        uint32_t rah0 = E1000_REG_READ(e1000, E1000_RAH_ARRAY(0));
    682696        rah0 = rah0 | RAH_AV;
    683         E1000_REG_WRITE(e1000_data, E1000_RAH_ARRAY(0), rah0);
     697        E1000_REG_WRITE(e1000, E1000_RAH_ARRAY(0), rah0);
    684698}
    685699
    686700/** Disable unicast promiscuous mode
    687701 *
    688  * @param e1000_data E1000 data structure
    689  *
    690  */
    691 static void e1000_disable_unicast_promisc(e1000_t *e1000_data)
    692 {
    693         uint32_t rctl = E1000_REG_READ(e1000_data, E1000_RCTL);
     702 * @param e1000 E1000 data structure
     703 *
     704 */
     705static void e1000_disable_unicast_promisc(e1000_t *e1000)
     706{
     707        uint32_t rctl = E1000_REG_READ(e1000, E1000_RCTL);
    694708        rctl = rctl & ~RCTL_UPE;
    695         E1000_REG_WRITE(e1000_data, E1000_RCTL, rctl);
     709        E1000_REG_WRITE(e1000, E1000_RCTL, rctl);
    696710}
    697711
    698712/** Enable unicast promiscuous mode
    699713 *
    700  * @param e1000_data E1000 data structure
    701  *
    702  */
    703 static void e1000_enable_unicast_promisc(e1000_t *e1000_data)
    704 {
    705         uint32_t rctl = E1000_REG_READ(e1000_data, E1000_RCTL);
     714 * @param e1000 E1000 data structure
     715 *
     716 */
     717static void e1000_enable_unicast_promisc(e1000_t *e1000)
     718{
     719        uint32_t rctl = E1000_REG_READ(e1000, E1000_RCTL);
    706720        rctl = rctl | RCTL_UPE;
    707         E1000_REG_WRITE(e1000_data, E1000_RCTL, rctl);
     721        E1000_REG_WRITE(e1000, E1000_RCTL, rctl);
    708722}
    709723
    710724/** Disable multicast promiscuous mode
    711725 *
    712  * @param e1000_data E1000 data structure
    713  *
    714  */
    715 static void e1000_disable_multicast_promisc(e1000_t *e1000_data)
    716 {
    717         uint32_t rctl = E1000_REG_READ(e1000_data, E1000_RCTL);
     726 * @param e1000 E1000 data structure
     727 *
     728 */
     729static void e1000_disable_multicast_promisc(e1000_t *e1000)
     730{
     731        uint32_t rctl = E1000_REG_READ(e1000, E1000_RCTL);
    718732        rctl = rctl & ~RCTL_MPE;
    719         E1000_REG_WRITE(e1000_data, E1000_RCTL, rctl);
     733        E1000_REG_WRITE(e1000, E1000_RCTL, rctl);
    720734}
    721735
    722736/** Enable multicast promiscuous mode
    723737 *
    724  * @param e1000_data E1000 data structure
    725  *
    726  */
    727 static void e1000_enable_multicast_promisc(e1000_t *e1000_data)
    728 {
    729         uint32_t rctl = E1000_REG_READ(e1000_data, E1000_RCTL);
     738 * @param e1000 E1000 data structure
     739 *
     740 */
     741static void e1000_enable_multicast_promisc(e1000_t *e1000)
     742{
     743        uint32_t rctl = E1000_REG_READ(e1000, E1000_RCTL);
    730744        rctl = rctl | RCTL_MPE;
    731         E1000_REG_WRITE(e1000_data, E1000_RCTL, rctl);
     745        E1000_REG_WRITE(e1000, E1000_RCTL, rctl);
    732746}
    733747
    734748/** Enable accepting of broadcast packets
    735749 *
    736  * @param e1000_data E1000 data structure
    737  *
    738  */
    739 static void e1000_enable_broadcast_accept(e1000_t *e1000_data)
    740 {
    741         uint32_t rctl = E1000_REG_READ(e1000_data, E1000_RCTL);
     750 * @param e1000 E1000 data structure
     751 *
     752 */
     753static void e1000_enable_broadcast_accept(e1000_t *e1000)
     754{
     755        uint32_t rctl = E1000_REG_READ(e1000, E1000_RCTL);
    742756        rctl = rctl | RCTL_BAM;
    743         E1000_REG_WRITE(e1000_data, E1000_RCTL, rctl);
     757        E1000_REG_WRITE(e1000, E1000_RCTL, rctl);
    744758}
    745759
    746760/** Disable accepting of broadcast packets
    747761 *
    748  * @param e1000_data E1000 data structure
    749  *
    750  */
    751 static void e1000_disable_broadcast_accept(e1000_t *e1000_data)
    752 {
    753         uint32_t rctl = E1000_REG_READ(e1000_data, E1000_RCTL);
     762 * @param e1000 E1000 data structure
     763 *
     764 */
     765static void e1000_disable_broadcast_accept(e1000_t *e1000)
     766{
     767        uint32_t rctl = E1000_REG_READ(e1000, E1000_RCTL);
    754768        rctl = rctl & ~RCTL_BAM;
    755         E1000_REG_WRITE(e1000_data, E1000_RCTL, rctl);
     769        E1000_REG_WRITE(e1000, E1000_RCTL, rctl);
    756770}
    757771
    758772/** Enable VLAN filtering according to VFTA registers
    759773 *
    760  * @param e1000_data E1000 data structure
    761  *
    762  */
    763 static void e1000_enable_vlan_filter(e1000_t *e1000_data)
    764 {
    765         uint32_t rctl = E1000_REG_READ(e1000_data, E1000_RCTL);
     774 * @param e1000 E1000 data structure
     775 *
     776 */
     777static void e1000_enable_vlan_filter(e1000_t *e1000)
     778{
     779        uint32_t rctl = E1000_REG_READ(e1000, E1000_RCTL);
    766780        rctl = rctl | RCTL_VFE;
    767         E1000_REG_WRITE(e1000_data, E1000_RCTL, rctl);
     781        E1000_REG_WRITE(e1000, E1000_RCTL, rctl);
    768782}
    769783
    770784/** Disable VLAN filtering
    771785 *
    772  * @param e1000_data E1000 data structure
    773  *
    774  */
    775 static void e1000_disable_vlan_filter(e1000_t *e1000_data)
    776 {
    777         uint32_t rctl = E1000_REG_READ(e1000_data, E1000_RCTL);
     786 * @param e1000 E1000 data structure
     787 *
     788 */
     789static void e1000_disable_vlan_filter(e1000_t *e1000)
     790{
     791        uint32_t rctl = E1000_REG_READ(e1000, E1000_RCTL);
    778792        rctl = rctl & ~RCTL_VFE;
    779         E1000_REG_WRITE(e1000_data, E1000_RCTL, rctl);
     793        E1000_REG_WRITE(e1000, E1000_RCTL, rctl);
    780794}
    781795
    782796/** Set multicast packets acceptance mode
    783797 *
    784  * @param nic_data NIC device to update
     798 * @param nic      NIC device to update
    785799 * @param mode     Mode to set
    786800 * @param addr     Address list (used in mode = NIC_MULTICAST_LIST)
     
    790804 *
    791805 */
    792 static 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);
     806static 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);
    796810        int rc = EOK;
    797811       
    798         fibril_mutex_lock(&e1000_data->rx_lock);
     812        fibril_mutex_lock(&e1000->rx_lock);
    799813       
    800814        switch (mode) {
    801815        case NIC_MULTICAST_BLOCKED:
    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);
     816                e1000_clear_multicast_receive_addresses(e1000);
     817                e1000_disable_multicast_promisc(e1000);
     818                nic_report_hw_filtering(nic, -1, 1, -1);
    805819                break;
    806820        case NIC_MULTICAST_LIST:
    807                 e1000_clear_multicast_receive_addresses(e1000_data);
    808                 if (addr_cnt > get_free_multicast_address_count(e1000_data)) {
     821                e1000_clear_multicast_receive_addresses(e1000);
     822                if (addr_cnt > get_free_multicast_address_count(e1000)) {
    809823                        /*
    810824                         * Future work: fill MTA table
     
    812826                         * in the NIC library.
    813827                         */
    814                         e1000_enable_multicast_promisc(e1000_data);
    815                         nic_report_hw_filtering(nic_data, -1, 0, -1);
     828                        e1000_enable_multicast_promisc(e1000);
     829                        nic_report_hw_filtering(nic, -1, 0, -1);
    816830                } else {
    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);
     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);
    820834                }
    821835                break;
    822836        case NIC_MULTICAST_PROMISC:
    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);
     837                e1000_enable_multicast_promisc(e1000);
     838                e1000_clear_multicast_receive_addresses(e1000);
     839                nic_report_hw_filtering(nic, -1, 1, -1);
    826840                break;
    827841        default:
     
    830844        }
    831845       
    832         fibril_mutex_unlock(&e1000_data->rx_lock);
     846        fibril_mutex_unlock(&e1000->rx_lock);
    833847        return rc;
    834848}
     
    836850/** Set unicast packets acceptance mode
    837851 *
    838  * @param nic_data NIC device to update
     852 * @param nic      NIC device to update
    839853 * @param mode     Mode to set
    840854 * @param addr     Address list (used in mode = NIC_MULTICAST_LIST)
     
    844858 *
    845859 */
    846 static 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);
     860static 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);
    850864        int rc = EOK;
    851865       
    852         fibril_mutex_lock(&e1000_data->rx_lock);
     866        fibril_mutex_lock(&e1000->rx_lock);
    853867       
    854868        switch (mode) {
    855869        case NIC_UNICAST_BLOCKED:
    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);
     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);
    860874                break;
    861875        case NIC_UNICAST_DEFAULT:
    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);
     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);
    866880                break;
    867881        case NIC_UNICAST_LIST:
    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);
     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);
    873887                } else {
    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);
     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);
    877891                }
    878892                break;
    879893        case NIC_UNICAST_PROMISC:
    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);
     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);
    884898                break;
    885899        default:
     
    888902        }
    889903       
    890         fibril_mutex_unlock(&e1000_data->rx_lock);
     904        fibril_mutex_unlock(&e1000->rx_lock);
    891905        return rc;
    892906}
     
    894908/** Set broadcast packets acceptance mode
    895909 *
    896  * @param nic_data NIC device to update
    897  * @param mode     Mode to set
     910 * @param nic  NIC device to update
     911 * @param mode Mode to set
    898912 *
    899913 * @return EOK
    900914 *
    901915 */
    902 static 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);
     916static int e1000_on_broadcast_mode_change(nic_t *nic, nic_broadcast_mode_t mode)
     917{
     918        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    906919        int rc = EOK;
    907920       
    908         fibril_mutex_lock(&e1000_data->rx_lock);
     921        fibril_mutex_lock(&e1000->rx_lock);
    909922       
    910923        switch (mode) {
    911924        case NIC_BROADCAST_BLOCKED:
    912                 e1000_disable_broadcast_accept(e1000_data);
     925                e1000_disable_broadcast_accept(e1000);
    913926                break;
    914927        case NIC_BROADCAST_ACCEPTED:
    915                 e1000_enable_broadcast_accept(e1000_data);
     928                e1000_enable_broadcast_accept(e1000);
    916929                break;
    917930        default:
     
    920933        }
    921934       
    922         fibril_mutex_unlock(&e1000_data->rx_lock);
     935        fibril_mutex_unlock(&e1000->rx_lock);
    923936        return rc;
    924937}
     
    926939/** Check if receiving is enabled
    927940 *
    928  * @param e1000_data E1000 data structure
     941 * @param e1000 E1000 data structure
    929942 *
    930943 * @return true if receiving is enabled
    931944 *
    932945 */
    933 static bool e1000_is_rx_enabled(e1000_t *e1000_data)
    934 {
    935         if (E1000_REG_READ(e1000_data, E1000_RCTL) & (RCTL_EN))
     946static bool e1000_is_rx_enabled(e1000_t *e1000)
     947{
     948        if (E1000_REG_READ(e1000, E1000_RCTL) & (RCTL_EN))
    936949                return true;
    937950       
     
    941954/** Enable receiving
    942955 *
    943  * @param e1000_data E1000 data structure
    944  *
    945  */
    946 static void e1000_enable_rx(e1000_t *e1000_data)
     956 * @param e1000 E1000 data structure
     957 *
     958 */
     959static void e1000_enable_rx(e1000_t *e1000)
    947960{
    948961        /* Set Receive Enable Bit */
    949         E1000_REG_WRITE(e1000_data, E1000_RCTL,
    950             E1000_REG_READ(e1000_data, E1000_RCTL) | (RCTL_EN));
     962        E1000_REG_WRITE(e1000, E1000_RCTL,
     963            E1000_REG_READ(e1000, E1000_RCTL) | (RCTL_EN));
    951964}
    952965
    953966/** Disable receiving
    954967 *
    955  * @param e1000_data E1000 data structure
    956  *
    957  */
    958 static void e1000_disable_rx(e1000_t *e1000_data)
     968 * @param e1000 E1000 data structure
     969 *
     970 */
     971static void e1000_disable_rx(e1000_t *e1000)
    959972{
    960973        /* Clear Receive Enable Bit */
    961         E1000_REG_WRITE(e1000_data, E1000_RCTL,
    962             E1000_REG_READ(e1000_data, E1000_RCTL) & ~(RCTL_EN));
     974        E1000_REG_WRITE(e1000, E1000_RCTL,
     975            E1000_REG_READ(e1000, E1000_RCTL) & ~(RCTL_EN));
    963976}
    964977
    965978/** Set VLAN mask
    966979 *
    967  * @param nic_data  NIC device to update
     980 * @param nic       NIC device to update
    968981 * @param vlan_mask VLAN mask
    969982 *
    970983 */
    971 static 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);
     984static 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);
    977990       
    978991        if (vlan_mask) {
     
    981994                 * partially written VLAN is not received.
    982995                 */
    983                 bool rx_enabled = e1000_is_rx_enabled(e1000_data);
     996                bool rx_enabled = e1000_is_rx_enabled(e1000);
    984997                if (rx_enabled)
    985                         e1000_disable_rx(e1000_data);
     998                        e1000_disable_rx(e1000);
    986999               
    9871000                for (unsigned int i = 0; i < NIC_VLAN_BITMAP_SIZE; i += 4) {
     
    9911004                            (((uint32_t) vlan_mask->bitmap[i + 2]) << 16) |
    9921005                            (((uint32_t) vlan_mask->bitmap[i + 3]) << 24);
    993                         E1000_REG_WRITE(e1000_data, E1000_VFTA_ARRAY(i / 4), bitmap_part);
     1006                        E1000_REG_WRITE(e1000, E1000_VFTA_ARRAY(i / 4), bitmap_part);
    9941007                }
    9951008               
    996                 e1000_enable_vlan_filter(e1000_data);
     1009                e1000_enable_vlan_filter(e1000);
    9971010                if (rx_enabled)
    998                         e1000_enable_rx(e1000_data);
     1011                        e1000_enable_rx(e1000);
    9991012        } else
    1000                 e1000_disable_vlan_filter(e1000_data);
    1001        
    1002         fibril_mutex_unlock(&e1000_data->rx_lock);
     1013                e1000_disable_vlan_filter(e1000);
     1014       
     1015        fibril_mutex_unlock(&e1000->rx_lock);
    10031016}
    10041017
     
    10261039                return ENOTSUP;
    10271040       
    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);
     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);
    10361049        if (strip)
    10371050                ctrl |= CTRL_VME;
     
    10391052                ctrl &= ~CTRL_VME;
    10401053       
    1041         E1000_REG_WRITE(e1000_data, E1000_CTRL, ctrl);
    1042        
    1043         fibril_mutex_unlock(&e1000_data->ctrl_lock);
     1054        E1000_REG_WRITE(e1000, E1000_CTRL, ctrl);
     1055       
     1056        fibril_mutex_unlock(&e1000->ctrl_lock);
    10441057        return EOK;
    10451058}
     
    10471060/** Fill receive descriptor with new empty packet
    10481061 *
    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  */
    1055 static 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);
     1062 * Store packet in e1000->rx_ring_packets
     1063 *
     1064 * @param nic    NIC data stricture
     1065 * @param offset Receive descriptor offset
     1066 *
     1067 */
     1068static 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);
    10591073       
    10601074        assert(packet);
    10611075       
    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
     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
    10731087                rx_descriptor->phys_addr = 0;
    10741088       
     
    10821096/** Clear receive descriptor
    10831097 *
    1084  * @param e1000_data E1000 data
    1085  * @param offset     Receive descriptor offset
    1086  *
    1087  */
    1088 static void e1000_clear_rx_descriptor(e1000_t *e1000_data, unsigned int offset)
     1098 * @param e1000  E1000 data
     1099 * @param offset Receive descriptor offset
     1100 *
     1101 */
     1102static void e1000_clear_rx_descriptor(e1000_t *e1000, unsigned int offset)
    10891103{
    10901104        e1000_rx_descriptor_t *rx_descriptor = (e1000_rx_descriptor_t *)
    1091             (e1000_data->rx_ring.virt +
    1092             offset * sizeof(e1000_rx_descriptor_t));
     1105            (e1000->rx_ring_virt + offset * sizeof(e1000_rx_descriptor_t));
    10931106       
    10941107        rx_descriptor->length = 0;
     
    11011114/** Clear receive descriptor
    11021115 *
    1103  * @param nic_data NIC data
    1104  * @param offset   Receive descriptor offset
    1105  *
    1106  */
    1107 static 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));
     1116 * @param nic    NIC data
     1117 * @param offset Receive descriptor offset
     1118 *
     1119 */
     1120static 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));
    11141126       
    11151127        if (tx_descriptor->length) {
    1116                 packet_t * old_packet = *(e1000_data->tx_ring_packets + offset);
     1128                packet_t *old_packet = *(e1000->tx_ring_packets + offset);
    11171129                if (old_packet)
    1118                         nic_release_packet(nic_data, old_packet);
     1130                        nic_release_packet(nic, old_packet);
    11191131        }
    11201132       
     
    11461158/** Receive packets
    11471159 *
    1148  * @param nic_data NIC data
    1149  *
    1150  */
    1151 static 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);
     1160 * @param nic NIC data
     1161 *
     1162 */
     1163static 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);
    11581170        uint32_t next_tail = e1000_inc_tail(*tail_addr, E1000_RX_PACKETS_COUNT);
    11591171       
    11601172        e1000_rx_descriptor_t *rx_descriptor = (e1000_rx_descriptor_t *)
    1161             (e1000_data->rx_ring.virt +
    1162             next_tail * sizeof(e1000_rx_descriptor_t));
     1173            (e1000->rx_ring_virt + next_tail * sizeof(e1000_rx_descriptor_t));
    11631174       
    11641175        while (rx_descriptor->status & 0x01) {
    11651176                uint32_t packet_size = rx_descriptor->length - E1000_CRC_SIZE;
    11661177               
    1167                 packet_t *packet = *(e1000_data->rx_ring_packets + next_tail);
     1178                packet_t *packet = *(e1000->rx_ring_packets + next_tail);
    11681179                packet_suffix(packet, packet_size);
    11691180               
    1170                 nic_dma_unlock_packet(packet);
    1171                 nic_received_packet(nic_data, packet);
     1181                nic_dma_unlock_packet(packet, E1000_MAX_RECEIVE_PACKET_SIZE);
     1182                nic_received_packet(nic, packet);
    11721183               
    1173                 e1000_fill_new_rx_descriptor(nic_data, next_tail);
     1184                e1000_fill_new_rx_descriptor(nic, next_tail);
    11741185               
    11751186                *tail_addr = e1000_inc_tail(*tail_addr, E1000_RX_PACKETS_COUNT);
     
    11771188               
    11781189                rx_descriptor = (e1000_rx_descriptor_t *)
    1179                     (e1000_data->rx_ring.virt +
    1180                     next_tail * sizeof(e1000_rx_descriptor_t));
     1190                    (e1000->rx_ring_virt + next_tail * sizeof(e1000_rx_descriptor_t));
    11811191        }
    11821192       
    1183         fibril_mutex_unlock(&e1000_data->rx_lock);
     1193        fibril_mutex_unlock(&e1000->rx_lock);
    11841194}
    11851195
    11861196/** Enable E1000 interupts
    11871197 *
    1188  * @param e1000_data E1000 data structure
    1189  *
    1190  */
    1191 static void e1000_enable_interrupts(e1000_t *e1000_data)
    1192 {
    1193         E1000_REG_WRITE(e1000_data, E1000_IMS, ICR_RXT0);
     1198 * @param e1000 E1000 data structure
     1199 *
     1200 */
     1201static void e1000_enable_interrupts(e1000_t *e1000)
     1202{
     1203        E1000_REG_WRITE(e1000, E1000_IMS, ICR_RXT0);
    11941204}
    11951205
    11961206/** Disable E1000 interupts
    11971207 *
    1198  * @param e1000_data E1000 data structure
    1199  *
    1200  */
    1201 static void e1000_disable_interrupts(e1000_t *e1000_data)
    1202 {
    1203         E1000_REG_WRITE(e1000_data, E1000_IMS, 0);
     1208 * @param e1000 E1000 data structure
     1209 *
     1210 */
     1211static void e1000_disable_interrupts(e1000_t *e1000)
     1212{
     1213        E1000_REG_WRITE(e1000, E1000_IMS, 0);
    12041214}
    12051215
     
    12091219 * and e1000_poll()
    12101220 *
    1211  * @param nic_data NIC data
    1212  * @param icr      ICR register value
    1213  *
    1214  */
    1215 static void e1000_interrupt_handler_impl(nic_t *nic_data, uint32_t icr)
     1221 * @param nic NIC data
     1222 * @param icr ICR register value
     1223 *
     1224 */
     1225static void e1000_interrupt_handler_impl(nic_t *nic, uint32_t icr)
    12161226{
    12171227        if (icr & ICR_RXT0)
    1218                 e1000_receive_packets(nic_data);
     1228                e1000_receive_packets(nic);
    12191229}
    12201230
     
    12301240{
    12311241        uint32_t icr = (uint32_t) IPC_GET_ARG2(*icall);
    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);
     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);
    12371247}
    12381248
     
    12421252 * structure.
    12431253 *
    1244  * @param nic_data Driver data
     1254 * @param nic Driver data
    12451255 *
    12461256 * @return EOK if the handler was registered
     
    12481258 *
    12491259 */
    1250 inline static int e1000_register_int_handler(nic_t *nic_data)
    1251 {
    1252         e1000_t *e1000_data = DRIVER_DATA_NIC(nic_data);
     1260inline static int e1000_register_int_handler(nic_t *nic)
     1261{
     1262        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    12531263       
    12541264        /* Lock the mutex in whole driver while working with global structure */
    12551265        fibril_mutex_lock(&irq_reg_mutex);
    12561266       
    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);
     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);
    12651272       
    12661273        fibril_mutex_unlock(&irq_reg_mutex);
     
    12701277/** Force receiving all packets in the receive buffer
    12711278 *
    1272  * @param nic_data NIC data
    1273  *
    1274  */
    1275 static 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);
     1279 * @param nic NIC data
     1280 *
     1281 */
     1282static 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);
    12841291}
    12851292
     
    13051312 *
    13061313 */
    1307 static int e1000_poll_mode_change(nic_t *nic_data, nic_poll_mode_t mode,
     1314static int e1000_poll_mode_change(nic_t *nic, nic_poll_mode_t mode,
    13081315    const struct timeval *period)
    13091316{
    1310         assert(nic_data);
    1311        
    1312         e1000_t *e1000_data = nic_get_specific(nic_data);
    1313         assert(e1000_data);
     1317        assert(nic);
     1318       
     1319        e1000_t *e1000 = nic_get_specific(nic);
     1320        assert(e1000);
    13141321       
    13151322        switch (mode) {
    13161323        case NIC_POLL_IMMEDIATE:
    1317                 E1000_REG_WRITE(e1000_data, E1000_ITR, 0);
    1318                 e1000_enable_interrupts(e1000_data);
     1324                E1000_REG_WRITE(e1000, E1000_ITR, 0);
     1325                e1000_enable_interrupts(e1000);
    13191326                break;
    13201327        case NIC_POLL_ON_DEMAND:
    1321                 e1000_disable_interrupts(e1000_data);
     1328                e1000_disable_interrupts(e1000);
    13221329                break;
    13231330        case NIC_POLL_PERIODIC:
    13241331                assert(period);
    13251332                uint16_t itr_interval = e1000_calculate_itr_interval(period);
    1326                 E1000_REG_WRITE(e1000_data, E1000_ITR, (uint32_t) itr_interval);
    1327                 e1000_enable_interrupts(e1000_data);
     1333                E1000_REG_WRITE(e1000, E1000_ITR, (uint32_t) itr_interval);
     1334                e1000_enable_interrupts(e1000);
    13281335                break;
    13291336        default:
     
    13361343/** Initialize receive registers
    13371344 *
    1338  * @param e1000_data E1000 data structure
    1339  *
    1340  */
    1341 static 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);
     1345 * @param e1000 E1000 data structure
     1346 *
     1347 */
     1348static 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);
    13451352       
    13461353        /* It is not posible to let HW use all descriptors */
    1347         E1000_REG_WRITE(e1000_data, E1000_RDT, E1000_RX_PACKETS_COUNT - 1);
     1354        E1000_REG_WRITE(e1000, E1000_RDT, E1000_RX_PACKETS_COUNT - 1);
    13481355       
    13491356        /* Set Broadcast Enable Bit */
    1350         E1000_REG_WRITE(e1000_data, E1000_RCTL, RCTL_BAM);
     1357        E1000_REG_WRITE(e1000, E1000_RCTL, RCTL_BAM);
    13511358}
    13521359
    13531360/** Initialize receive structure
    13541361 *
    1355  * @param nic_data NIC data
     1362 * @param nic NIC data
    13561363 *
    13571364 * @return EOK if succeed
     
    13591366 *
    13601367 */
    1361 static 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);
     1368static 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);
    13691377        if (rc != EOK)
    13701378                return rc;
    13711379       
    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 =
     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 =
    13781386            malloc(E1000_RX_PACKETS_COUNT * sizeof(packet_t *));
    13791387        // FIXME: Check return value
     
    13831391            offset < E1000_RX_PACKETS_COUNT;
    13841392            offset++)
    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);
     1393                e1000_fill_new_rx_descriptor(nic, offset);
     1394       
     1395        e1000_initialize_rx_registers(e1000);
     1396       
     1397        fibril_mutex_unlock(&e1000->rx_lock);
    13901398        return EOK;
    13911399}
     
    13931401/** Uninitialize receive structure
    13941402 *
    1395  * @param nic_data NIC data
    1396  *
    1397  */
    1398 static void e1000_uninitialize_rx_structure(nic_t *nic_data)
    1399 {
    1400         e1000_t *e1000_data = DRIVER_DATA_NIC(nic_data);
     1403 * @param nic NIC data
     1404 *
     1405 */
     1406static void e1000_uninitialize_rx_structure(nic_t *nic)
     1407{
     1408        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    14011409       
    14021410        /* Write descriptor */
     
    14041412            offset < E1000_RX_PACKETS_COUNT;
    14051413            offset++) {
    1406                 packet_t *packet = *(e1000_data->rx_ring_packets + offset);
    1407                 nic_dma_unlock_packet(packet);
    1408                 nic_release_packet(nic_data, packet);
     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);
    14091417        }
    14101418       
    1411         free(e1000_data->rx_ring_packets);
    1412         dmamem_unmap(&e1000_data->rx_ring);
     1419        free(e1000->rx_ring_packets);
     1420        dmamem_unmap_anonymous(e1000->rx_ring_virt);
    14131421}
    14141422
    14151423/** Clear receive descriptor ring
    14161424 *
    1417  * @param e1000_data E1000 data
    1418  *
    1419  */
    1420 static void e1000_clear_rx_ring(e1000_t * e1000_data)
     1425 * @param e1000 E1000 data
     1426 *
     1427 */
     1428static void e1000_clear_rx_ring(e1000_t *e1000)
    14211429{
    14221430        /* Write descriptor */
     
    14241432            offset < E1000_RX_PACKETS_COUNT;
    14251433            offset++)
    1426                 e1000_clear_rx_descriptor(e1000_data, offset);
     1434                e1000_clear_rx_descriptor(e1000, offset);
    14271435}
    14281436
    14291437/** Initialize filters
    14301438 *
    1431  * @param e1000_data E1000 data
    1432  *
    1433  */
    1434 static void e1000_initialize_filters(e1000_t *e1000_data)
     1439 * @param e1000 E1000 data
     1440 *
     1441 */
     1442static void e1000_initialize_filters(e1000_t *e1000)
    14351443{
    14361444        /* Initialize address filter */
    1437         e1000_data->unicast_ra_count = 0;
    1438         e1000_data->multicast_ra_count = 0;
    1439         e1000_clear_unicast_receive_addresses(e1000_data);
     1445        e1000->unicast_ra_count = 0;
     1446        e1000->multicast_ra_count = 0;
     1447        e1000_clear_unicast_receive_addresses(e1000);
    14401448}
    14411449
    14421450/** Initialize VLAN
    14431451 *
    1444  * @param e1000_data E1000 data
    1445  *
    1446  */
    1447 static void e1000_initialize_vlan(e1000_t *e1000_data)
    1448 {
    1449         e1000_data->vlan_tag_add = false;
     1452 * @param e1000 E1000 data
     1453 *
     1454 */
     1455static void e1000_initialize_vlan(e1000_t *e1000)
     1456{
     1457        e1000->vlan_tag_add = false;
    14501458}
    14511459
    14521460/** Fill MAC address from EEPROM to RA[0] register
    14531461 *
    1454  * @param e1000_data E1000 data
    1455  *
    1456  */
    1457 static void e1000_fill_mac_from_eeprom(e1000_t *e1000_data)
     1462 * @param e1000 E1000 data
     1463 *
     1464 */
     1465static void e1000_fill_mac_from_eeprom(e1000_t *e1000)
    14581466{
    14591467        /* MAC address from eeprom to RA[0] */
    14601468        nic_address_t address;
    1461         e1000_eeprom_get_address(e1000_data, &address);
    1462         e1000_write_receive_address(e1000_data, 0, &address, true);
     1469        e1000_eeprom_get_address(e1000, &address);
     1470        e1000_write_receive_address(e1000, 0, &address, true);
    14631471}
    14641472
     
    14711479 *
    14721480 */
    1473 static void e1000_initialize_registers(e1000_t *e1000_data)
    1474 {
    1475         E1000_REG_WRITE(e1000_data, E1000_ITR,
     1481static void e1000_initialize_registers(e1000_t *e1000)
     1482{
     1483        E1000_REG_WRITE(e1000, E1000_ITR,
    14761484            e1000_calculate_itr_interval_from_usecs(
    14771485            E1000_DEFAULT_INTERRUPT_INTERVAL_USEC));
    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);
     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);
    14841492}
    14851493
    14861494/** Initialize transmit registers
    14871495 *
    1488  * @param e1000_data E1000 data.
    1489  *
    1490  */
    1491 static 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,
     1496 * @param e1000 E1000 data.
     1497 *
     1498 */
     1499static 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,
    14981506            10 << TIPG_IPGT_SHIFT |
    14991507            8 << TIPG_IPGR1_SHIFT |
    15001508            6 << TIPG_IPGR2_SHIFT);
    15011509       
    1502         E1000_REG_WRITE(e1000_data, E1000_TCTL,
     1510        E1000_REG_WRITE(e1000, E1000_TCTL,
    15031511            0x0F << TCTL_CT_SHIFT /* Collision Threshold */ |
    15041512            0x40 << TCTL_COLD_SHIFT /* Collision Distance */ |
     
    15081516/** Initialize transmit structure
    15091517 *
    1510  * @param e1000_data E1000 data.
    1511  *
    1512  */
    1513 static 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);
     1518 * @param e1000 E1000 data.
     1519 *
     1520 */
     1521static 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);
    15201529        if (rc != EOK)
    15211530                return rc;
    15221531       
    1523         bzero(e1000_data->tx_ring.virt,
     1532        bzero(e1000->tx_ring_virt,
    15241533            E1000_TX_PACKETS_COUNT * sizeof(e1000_tx_descriptor_t));
    15251534       
    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 =
     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 =
    15321541            malloc(E1000_TX_PACKETS_COUNT * sizeof(packet_t *));
    15331542        // FIXME: Check return value
    15341543       
    1535         e1000_initialize_tx_registers(e1000_data);
    1536        
    1537         fibril_mutex_unlock(&e1000_data->tx_lock);
     1544        e1000_initialize_tx_registers(e1000);
     1545       
     1546        fibril_mutex_unlock(&e1000->tx_lock);
    15381547        return EOK;
    15391548}
     
    15411550/** Uninitialize transmit structure
    15421551 *
    1543  * @param nic_data NIC data
    1544  *
    1545  */
    1546 static void e1000_uninitialize_tx_structure(e1000_t *e1000_data)
    1547 {
    1548         free(e1000_data->tx_ring_packets);
    1549         dmamem_unmap(&e1000_data->tx_ring);
     1552 * @param nic NIC data
     1553 *
     1554 */
     1555static void e1000_uninitialize_tx_structure(e1000_t *e1000)
     1556{
     1557        free(e1000->tx_ring_packets);
     1558        dmamem_unmap_anonymous(e1000->tx_ring_virt);
    15501559}
    15511560
    15521561/** Clear transmit descriptor ring
    15531562 *
    1554  * @param nic_data NIC data
    1555  *
    1556  */
    1557 static void e1000_clear_tx_ring(nic_t *nic_data)
     1563 * @param nic NIC data
     1564 *
     1565 */
     1566static void e1000_clear_tx_ring(nic_t *nic)
    15581567{
    15591568        /* Write descriptor */
     
    15611570            offset < E1000_TX_PACKETS_COUNT;
    15621571            offset++)
    1563                 e1000_clear_tx_descriptor(nic_data, offset);
     1572                e1000_clear_tx_descriptor(nic, offset);
    15641573}
    15651574
    15661575/** Enable transmit
    15671576 *
    1568  * @param e1000_data E1000 data
    1569  *
    1570  */
    1571 static void e1000_enable_tx(e1000_t *e1000_data)
     1577 * @param e1000 E1000 data
     1578 *
     1579 */
     1580static void e1000_enable_tx(e1000_t *e1000)
    15721581{
    15731582        /* Set Transmit Enable Bit */
    1574         E1000_REG_WRITE(e1000_data, E1000_TCTL,
    1575             E1000_REG_READ(e1000_data, E1000_TCTL) | (TCTL_EN));
     1583        E1000_REG_WRITE(e1000, E1000_TCTL,
     1584            E1000_REG_READ(e1000, E1000_TCTL) | (TCTL_EN));
    15761585}
    15771586
    15781587/** Disable transmit
    15791588 *
    1580  * @param e1000_data E1000 data
    1581  *
    1582  */
    1583 static void e1000_disable_tx(e1000_t *e1000_data)
     1589 * @param e1000 E1000 data
     1590 *
     1591 */
     1592static void e1000_disable_tx(e1000_t *e1000)
    15841593{
    15851594        /* Clear Transmit Enable Bit */
    1586         E1000_REG_WRITE(e1000_data, E1000_TCTL,
    1587             E1000_REG_READ(e1000_data, E1000_TCTL) & ~(TCTL_EN));
     1595        E1000_REG_WRITE(e1000, E1000_TCTL,
     1596            E1000_REG_READ(e1000, E1000_TCTL) & ~(TCTL_EN));
    15881597}
    15891598
    15901599/** Reset E1000 device
    15911600 *
    1592  * @param e1000_data The E1000 data
    1593  *
    1594  */
    1595 static 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);
     1601 * @param e1000 The E1000 data
     1602 *
     1603 */
     1604static 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);
    16001609       
    16011610        /* Wait for the reset */
     
    16031612       
    16041613        /* check if RST_BIT cleared */
    1605         if (E1000_REG_READ(e1000_data, E1000_CTRL) & (CTRL_RST))
     1614        if (E1000_REG_READ(e1000, E1000_CTRL) & (CTRL_RST))
    16061615                return EINVAL;
    16071616       
    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);
     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);
    16141623       
    16151624        return EOK;
     
    16181627/** Activate the device to receive and transmit packets
    16191628 *
    1620  * @param nic_data NIC driver data
     1629 * @param nic NIC driver data
    16211630 *
    16221631 * @return EOK if activated successfully
     
    16241633 *
    16251634 */
    1626 static 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);
     1635static 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);
    16471656        ctrl |= CTRL_SLU;
    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);
     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);
    16531662       
    16541663        return EOK;
     
    16571666/** Callback for NIC_STATE_DOWN change
    16581667 *
    1659  * @param nic_data NIC driver data
     1668 * @param nic NIC driver data
    16601669 *
    16611670 * @return EOK if succeed
     
    16631672 *
    16641673 */
    1665 static 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);
     1674static 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);
    16701679        ctrl &= ~CTRL_SLU;
    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);
     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);
    16781687       
    16791688        /*
     
    16881697/** Callback for NIC_STATE_DOWN change
    16891698 *
    1690  * @param nic_data NIC driver data
     1699 * @param nic NIC driver data
    16911700 *
    16921701 * @return EOK if succeed
     
    16941703 *
    16951704 */
    1696 static 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);
     1705static 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);
    17091718       
    17101719        return rc;
     
    17131722/** Callback for NIC_STATE_STOPPED change
    17141723 *
    1715  * @param nic_data NIC driver data
     1724 * @param nic NIC driver data
    17161725 *
    17171726 * @return EOK if succeed
     
    17191728 *
    17201729 */
    1721 static 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);
     1730static 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);
    17301739        if (rc == EOK)
    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);
     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);
    17361745       
    17371746        return rc;
     
    17481757        assert(!dev->driver_data);
    17491758       
    1750         nic_t *nic_data = nic_create_and_bind(dev);
    1751         if (!nic_data)
     1759        nic_t *nic = nic_create_and_bind(dev);
     1760        if (!nic)
    17521761                return NULL;
    17531762       
    1754         e1000_t *e1000_data = malloc(sizeof(e1000_t));
    1755         if (!e1000_data) {
     1763        e1000_t *e1000 = malloc(sizeof(e1000_t));
     1764        if (!e1000) {
    17561765                nic_unbind_and_destroy(dev);
    17571766                return NULL;
    17581767        }
    17591768       
    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,
     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,
    17651774            e1000_on_down, e1000_on_stopping);
    1766         nic_set_filtering_change_handlers(nic_data,
     1775        nic_set_filtering_change_handlers(nic,
    17671776            e1000_on_unicast_mode_change, e1000_on_multicast_mode_change,
    17681777            e1000_on_broadcast_mode_change, NULL, e1000_on_vlan_mask_change);
    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;
     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;
    17771786}
    17781787
     
    18251834        assert(dev->driver_data != NULL);
    18261835       
    1827         e1000_t *e1000_data = DRIVER_DATA_DEV(dev);
     1836        e1000_t *e1000 = DRIVER_DATA_DEV(dev);
    18281837       
    18291838        if (hw_resources->irqs.count != 1)
    18301839                return EINVAL;
    18311840       
    1832         e1000_data->irq = hw_resources->irqs.irqs[0];
    1833         e1000_data->phys_reg_base =
     1841        e1000->irq = hw_resources->irqs.irqs[0];
     1842        e1000->reg_base_phys =
    18341843            MEMADDR_TO_PTR(hw_resources->mem_ranges.ranges[0].address);
    18351844       
     
    18781887{
    18791888        /* Allocate driver data for the device. */
    1880         e1000_t *e1000_data = e1000_create_dev_data(dev);
    1881         if (e1000_data == NULL)
     1889        e1000_t *e1000 = e1000_create_dev_data(dev);
     1890        if (e1000 == NULL)
    18821891                return ENOMEM;
    18831892       
     
    18901899       
    18911900        rc = pci_config_space_read_16(dev->parent_sess, PCI_DEVICE_ID,
    1892             &e1000_data->device_id);
     1901            &e1000->device_id);
    18931902        if (rc != EOK) {
    18941903                e1000_dev_cleanup(dev);
     
    19091918static int e1000_pio_enable(ddf_dev_t *dev)
    19101919{
    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);
     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);
    19151924        if (rc != EOK)
    19161925                return EADDRNOTAVAIL;
     
    19341943       
    19351944        /* Device initialization */
    1936         nic_t *nic_data = dev->driver_data;
    1937         e1000_t *e1000_data = DRIVER_DATA_NIC(nic_data);
     1945        nic_t *nic = dev->driver_data;
     1946        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    19381947       
    19391948        /* Map registers */
     
    19421951                goto err_destroy;
    19431952       
    1944         e1000_initialize_registers(e1000_data);
    1945         rc = e1000_initialize_tx_structure(e1000_data);
     1953        e1000_initialize_registers(e1000);
     1954        rc = e1000_initialize_tx_structure(e1000);
    19461955        if (rc != EOK)
    19471956                goto err_pio;
    19481957       
    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);
     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);
    19591968        if (rc != EOK)
    19601969                goto err_tx_structure;
    19611970       
    1962         rc = e1000_register_int_handler(nic_data);
     1971        rc = e1000_register_int_handler(nic);
    19631972        if (rc != EOK)
    19641973                goto err_tx_structure;
    19651974       
    1966         rc = nic_connect_to_services(nic_data);
     1975        rc = nic_connect_to_services(nic);
    19671976        if (rc != EOK)
    19681977                goto err_irq;
    19691978       
    1970         rc = e1000_initialize_rx_structure(nic_data);
     1979        rc = e1000_initialize_rx_structure(nic);
    19711980        if (rc != EOK)
    19721981                goto err_irq;
    19731982       
    19741983        nic_address_t e1000_address;
    1975         e1000_get_address(e1000_data, &e1000_address);
    1976         rc = nic_report_address(nic_data, &e1000_address);
     1984        e1000_get_address(e1000, &e1000_address);
     1985        rc = nic_report_address(nic, &e1000_address);
    19771986        if (rc != EOK)
    19781987                goto err_rx_structure;
     
    19811990        period.tv_sec = 0;
    19821991        period.tv_usec = E1000_DEFAULT_INTERRUPT_INTERVAL_USEC;
    1983         rc = nic_report_poll_mode(nic_data, NIC_POLL_PERIODIC, &period);
     1992        rc = nic_report_poll_mode(nic, NIC_POLL_PERIODIC, &period);
    19841993        if (rc != EOK)
    19851994                goto err_rx_structure;
     
    19881997       
    19891998err_rx_structure:
    1990         e1000_uninitialize_rx_structure(nic_data);
     1999        e1000_uninitialize_rx_structure(nic);
    19912000err_irq:
    19922001        unregister_interrupt_handler(dev, DRIVER_DATA_DEV(dev)->irq);
    19932002err_tx_structure:
    1994         e1000_uninitialize_tx_structure(e1000_data);
     2003        e1000_uninitialize_tx_structure(e1000);
    19952004err_pio:
    19962005        // TODO: e1000_pio_disable(dev);
     
    20102019 *
    20112020 */
    2012 static uint16_t e1000_eeprom_read(e1000_t *e1000_data, uint8_t eeprom_address)
    2013 {
    2014         fibril_mutex_lock(&e1000_data->eeprom_lock);
     2021static uint16_t e1000_eeprom_read(e1000_t *e1000, uint8_t eeprom_address)
     2022{
     2023        fibril_mutex_lock(&e1000->eeprom_lock);
    20152024       
    20162025        uint32_t eerd_done;
    20172026        uint32_t eerd_address_offset;
    20182027       
    2019         switch (e1000_data->device_id) {
     2028        switch (e1000->device_id) {
    20202029        case 0x107c:
    20212030        case 0x1013:
     
    20402049        uint32_t write_data = EERD_START |
    20412050            (((uint32_t) eeprom_address) << eerd_address_offset);
    2042         E1000_REG_WRITE(e1000_data, E1000_EERD, write_data);
    2043        
    2044         uint32_t eerd = E1000_REG_READ(e1000_data, E1000_EERD);
     2051        E1000_REG_WRITE(e1000, E1000_EERD, write_data);
     2052       
     2053        uint32_t eerd = E1000_REG_READ(e1000, E1000_EERD);
    20452054        while ((eerd & eerd_done) == 0) {
    20462055                usleep(1);
    2047                 eerd = E1000_REG_READ(e1000_data, E1000_EERD);
     2056                eerd = E1000_REG_READ(e1000, E1000_EERD);
    20482057        }
    20492058       
    2050         fibril_mutex_unlock(&e1000_data->eeprom_lock);
     2059        fibril_mutex_unlock(&e1000->eeprom_lock);
    20512060       
    20522061        return (uint16_t) (eerd >> EERD_DATA_OFFSET);
     
    20632072 *
    20642073 */
    2065 static int e1000_get_address(e1000_t *e1000_data, nic_address_t *address)
    2066 {
    2067         fibril_mutex_lock(&e1000_data->rx_lock);
     2074static int e1000_get_address(e1000_t *e1000, nic_address_t *address)
     2075{
     2076        fibril_mutex_lock(&e1000->rx_lock);
    20682077       
    20692078        uint8_t *mac0_dest = (uint8_t *) address->address;
     
    20742083        uint8_t *mac5_dest = (uint8_t *) address->address + 5;
    20752084       
    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));
     2085        uint32_t rah = E1000_REG_READ(e1000, E1000_RAH_ARRAY(0));
     2086        uint32_t ral = E1000_REG_READ(e1000, E1000_RAL_ARRAY(0));
    20782087       
    20792088        *mac0_dest = (uint8_t) ral;
     
    20842093        *mac5_dest = (uint8_t) (rah >> 8);
    20852094       
    2086         fibril_mutex_unlock(&e1000_data->rx_lock);
     2095        fibril_mutex_unlock(&e1000->rx_lock);
    20872096        return EOK;
    20882097};
     
    20982107static int e1000_set_addr(ddf_fun_t *dev, const nic_address_t *addr)
    20992108{
    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);
     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);
    21072116        if (rc == EOK)
    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);
     2117                e1000_write_receive_address(e1000, 0, addr, false);
     2118       
     2119        fibril_mutex_unlock(&e1000->tx_lock);
     2120        fibril_mutex_unlock(&e1000->rx_lock);
    21122121       
    21132122        return rc;
    21142123}
    21152124
    2116 static void e1000_eeprom_get_address(e1000_t *e1000_data,
     2125static void e1000_eeprom_get_address(e1000_t *e1000,
    21172126    nic_address_t *address)
    21182127{
     
    21212130        uint16_t *mac4_dest = (uint16_t *) (address->address + 4);
    21222131       
    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);
     2132        *mac0_dest = e1000_eeprom_read(e1000, 0);
     2133        *mac2_dest = e1000_eeprom_read(e1000, 1);
     2134        *mac4_dest = e1000_eeprom_read(e1000, 2);
    21262135}
    21272136
    21282137/** Send packet
    21292138 *
    2130  * @param nic_data NIC driver data structure
    2131  * @param packet   Packet to send
     2139 * @param nic    NIC driver data structure
     2140 * @param packet Packet to send
    21322141 *
    21332142 * @return EOK if succeed
     
    21352144 *
    21362145 */
    2137 static 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);
     2146static 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);
    21452154        e1000_tx_descriptor_t *tx_descriptor_addr = (e1000_tx_descriptor_t *)
    2146             (e1000_data->tx_ring.virt + tdt * sizeof(e1000_tx_descriptor_t));
     2155            (e1000->tx_ring_virt + tdt * sizeof(e1000_tx_descriptor_t));
    21472156       
    21482157        bool descriptor_available = false;
     
    21552164        if (tx_descriptor_addr->status & TXDESCRIPTOR_STATUS_DD) {
    21562165                descriptor_available = true;
    2157                 packet_t *old_packet = *(e1000_data->tx_ring_packets + tdt);
     2166                packet_t *old_packet = *(e1000->tx_ring_packets + tdt);
    21582167                if (old_packet) {
    2159                         nic_dma_unlock_packet(old_packet);
    2160                         nic_release_packet(nic_data, 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);
    21612171                }
    21622172        }
     
    21642174        if (!descriptor_available) {
    21652175                /* Packet lost */
    2166                 fibril_mutex_unlock(&e1000_data->tx_lock);
     2176                fibril_mutex_unlock(&e1000->tx_lock);
    21672177                return;
    21682178        }
     
    21702180        size_t packet_size = packet_get_data_length(packet);
    21712181       
    2172         void *phys_addr = nic_dma_lock_packet(packet);
    2173         if (!phys_addr) {
    2174                 fibril_mutex_unlock(&e1000_data->tx_lock);
     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);
    21752186                return;
    21762187        }
    21772188       
    2178         *(e1000_data->tx_ring_packets + tdt) = packet;
     2189        *(e1000->tx_ring_packets + tdt) = packet;
    21792190       
    21802191        tx_descriptor_addr->phys_addr =
    2181             PTR_TO_U64(phys_addr + packet->data_start);
     2192            PTR_TO_U64(phys + packet->data_start);
    21822193        tx_descriptor_addr->length = packet_size;
    21832194       
     
    21922203        tx_descriptor_addr->checksum_offset = 0;
    21932204        tx_descriptor_addr->status = 0;
    2194         if (e1000_data->vlan_tag_add) {
    2195                 tx_descriptor_addr->special = e1000_data->vlan_tag;
     2205        if (e1000->vlan_tag_add) {
     2206                tx_descriptor_addr->special = e1000->vlan_tag;
    21962207                tx_descriptor_addr->command |= TXDESCRIPTOR_COMMAND_VLE;
    21972208        } else
     
    22042215                tdt = 0;
    22052216       
    2206         E1000_REG_WRITE(e1000_data, E1000_TDT, tdt);
    2207        
    2208         fibril_mutex_unlock(&e1000_data->tx_lock);
     2217        E1000_REG_WRITE(e1000, E1000_TDT, tdt);
     2218       
     2219        fibril_mutex_unlock(&e1000->tx_lock);
    22092220}
    22102221
     
    22152226                return rc;
    22162227       
    2217         nic_driver_implement(&e1000_driver_ops, &e1000_dev_ops, &e1000_nic_iface);
     2228        nic_driver_implement(&e1000_driver_ops, &e1000_dev_ops,
     2229            &e1000_nic_iface);
    22182230        return ddf_driver_main(&e1000_driver);
    22192231}
  • uspace/drv/nic/e1k/e1k.h

    rc8751452 rc4be33a  
    4949
    5050/** Receive descriptior */
    51 typedef struct e1000_rx_descriptor {
     51typedef struct {
    5252        /** Buffer Address - physical */
    5353        uint64_t phys_addr;
     
    5757        uint16_t checksum;
    5858        /** Status field */
    59          uint8_t status;
     59        uint8_t status;
    6060        /** Errors field */
    6161        uint8_t errors;
     
    6565
    6666/** Legacy transmit descriptior */
    67 typedef struct e1000_tx_descriptor {
     67typedef struct {
    6868        /** Buffer Address - physical */
    6969        uint64_t phys_addr;
     
    7575        uint8_t command;
    7676        /** Status field, upper bits are reserved */
    77          uint8_t status;
     77        uint8_t status;
    7878        /** Checksum Start Field */
    7979        uint8_t checksum_start_field;
Note: See TracChangeset for help on using the changeset viewer.