Changeset 948911d in mainline for uspace/drv/nic/e1k/e1k.c


Ignore:
Timestamp:
2012-01-24T02:27:43Z (12 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
230385c
Parents:
8afeb04 (diff), 2df6f6fe (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Mainline changes.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r8afeb04 r948911d  
    4444#include <libarch/ddi.h>
    4545#include <as.h>
     46#include <ddf/log.h>
    4647#include <ddf/interrupt.h>
    4748#include <devman.h>
    … …  
    5152#include <nil_remote.h>
    5253#include <ops/nic.h>
    53 #include <packet_client.h>
    54 #include <packet_remote.h>
    55 #include <net/packet_header.h>
    5654#include "e1k.h"
    5755
    … …  
    6159
    6260/* Must be power of 8 */
    63 #define E1000_RX_PACKETS_COUNT  128
    64 #define E1000_TX_PACKETS_COUNT  128
     61#define E1000_RX_FRAME_COUNT  128
     62#define E1000_TX_FRAME_COUNT  128
    6563
    6664#define E1000_RECEIVE_ADDRESS  16
    6765
    68 /** Maximum receiving packet size */
    69 #define E1000_MAX_RECEIVE_PACKET_SIZE  2048
     66/** Maximum sending frame size */
     67#define E1000_MAX_SEND_FRAME_SIZE  2048
     68/** Maximum receiving frame size */
     69#define E1000_MAX_RECEIVE_FRAME_SIZE  2048
    7070
    7171/** nic_driver_data_t* -> e1000_t* cast */
    … …  
    111111/** E1000 device data */
    112112typedef struct {
     113        /** Device configuration */
     114        e1000_info_t info;
     115       
    113116        /** Physical registers base address */
    114117        void *reg_base_phys;
    … …  
    121124        void *tx_ring_virt;
    122125       
    123         /** Packets in tx ring  */
    124         packet_t **tx_ring_packets;
     126        /** Ring of TX frames, physical address */
     127        void **tx_frame_phys;
     128        /** Ring of TX frames, virtual address */
     129        void **tx_frame_virt;
    125130       
    126131        /** Physical rx ring address */
    … …  
    129134        void *rx_ring_virt;
    130135       
    131         /** Packets in rx ring  */
    132         packet_t **rx_ring_packets;
     136        /** Ring of RX frames, physical address */
     137        void **rx_frame_phys;
     138        /** Ring of RX frames, virtual address */
     139        void **rx_frame_virt;
    133140       
    134141        /** VLAN tag */
    135142        uint16_t vlan_tag;
    136143       
    137         /** Add VLAN tag to packet */
     144        /** Add VLAN tag to frame */
    138145        bool vlan_tag_add;
    139146       
    … …  
    143150        /** Used milticast Receive addrress count */
    144151        unsigned int multicast_ra_count;
    145        
    146         /** PCI device ID */
    147         uint16_t device_id;
    148152       
    149153        /** The irq assigned */
    … …  
    222226static int e1000_on_activating(nic_t *);
    223227static int e1000_on_stopping(nic_t *);
    224 static void e1000_write_packet(nic_t *, packet_t *);
     228static void e1000_send_frame(nic_t *, void *, size_t);
    225229
    226230/** Commands to deal with interrupt
    … …  
    472476}
    473477
    474 /** Get state of acceptance of weird packets
     478/** Get state of acceptance of weird frames
    475479 *
    476480 * @param      device Device to check
    … …  
    490494};
    491495
    492 /** Set acceptance of weird packets
     496/** Set acceptance of weird frames
    493497 *
    494498 * @param device Device to update
    … …  
    674678}
    675679
    676 /** Disable receiving packets for default address
     680/** Disable receiving frames for default address
    677681 *
    678682 * @param e1000 E1000 data structure
    … …  
    686690}
    687691
    688 /** Enable receiving packets for default address
     692/** Enable receiving frames for default address
    689693 *
    690694 * @param e1000 E1000 data structure
    … …  
    746750}
    747751
    748 /** Enable accepting of broadcast packets
     752/** Enable accepting of broadcast frames
    749753 *
    750754 * @param e1000 E1000 data structure
    … …  
    758762}
    759763
    760 /** Disable accepting of broadcast packets
     764/** Disable accepting of broadcast frames
    761765 *
    762766 * @param e1000 E1000 data structure
    … …  
    794798}
    795799
    796 /** Set multicast packets acceptance mode
     800/** Set multicast frames acceptance mode
    797801 *
    798802 * @param nic      NIC device to update
    … …  
    848852}
    849853
    850 /** Set unicast packets acceptance mode
     854/** Set unicast frames acceptance mode
    851855 *
    852856 * @param nic      NIC device to update
    … …  
    906910}
    907911
    908 /** Set broadcast packets acceptance mode
     912/** Set broadcast frames acceptance mode
    909913 *
    910914 * @param nic  NIC device to update
    … …  
    991995        if (vlan_mask) {
    992996                /*
    993                  * Disable receiving, so that packet matching
     997                 * Disable receiving, so that frame matching
    994998                 * partially written VLAN is not received.
    995999                 */
    … …  
    10581062}
    10591063
    1060 /** Fill receive descriptor with new empty packet
    1061  *
    1062  * Store packet in e1000->rx_ring_packets
     1064/** Fill receive descriptor with new empty buffer
     1065 *
     1066 * Store frame in e1000->rx_frame_phys
    10631067 *
    10641068 * @param nic    NIC data stricture
    … …  
    10691073{
    10701074        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    1071         packet_t *packet =
    1072             nic_alloc_packet(nic, E1000_MAX_RECEIVE_PACKET_SIZE);
    1073        
    1074         assert(packet);
    1075        
    1076         *(e1000->rx_ring_packets + offset) = packet;
     1075       
    10771076        e1000_rx_descriptor_t *rx_descriptor = (e1000_rx_descriptor_t *)
    10781077            (e1000->rx_ring_virt + offset * sizeof(e1000_rx_descriptor_t));
    10791078       
    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
    1087                 rx_descriptor->phys_addr = 0;
    1088        
     1079        rx_descriptor->phys_addr = PTR_TO_U64(e1000->rx_frame_phys[offset]);
    10891080        rx_descriptor->length = 0;
    10901081        rx_descriptor->checksum = 0;
    … …  
    11241115        e1000_tx_descriptor_t *tx_descriptor = (e1000_tx_descriptor_t *)
    11251116            (e1000->tx_ring_virt + offset * sizeof(e1000_tx_descriptor_t));
    1126        
    1127         if (tx_descriptor->length) {
    1128                 packet_t *old_packet = *(e1000->tx_ring_packets + offset);
    1129                 if (old_packet)
    1130                         nic_release_packet(nic, old_packet);
    1131         }
    11321117       
    11331118        tx_descriptor->phys_addr = 0;
    … …  
    11561141}
    11571142
    1158 /** Receive packets
     1143/** Receive frames
    11591144 *
    11601145 * @param nic NIC data
    11611146 *
    11621147 */
    1163 static void e1000_receive_packets(nic_t *nic)
     1148static void e1000_receive_frames(nic_t *nic)
    11641149{
    11651150        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    … …  
    11681153       
    11691154        uint32_t *tail_addr = E1000_REG_ADDR(e1000, E1000_RDT);
    1170         uint32_t next_tail = e1000_inc_tail(*tail_addr, E1000_RX_PACKETS_COUNT);
     1155        uint32_t next_tail = e1000_inc_tail(*tail_addr, E1000_RX_FRAME_COUNT);
    11711156       
    11721157        e1000_rx_descriptor_t *rx_descriptor = (e1000_rx_descriptor_t *)
    … …  
    11741159       
    11751160        while (rx_descriptor->status & 0x01) {
    1176                 uint32_t packet_size = rx_descriptor->length - E1000_CRC_SIZE;
     1161                uint32_t frame_size = rx_descriptor->length - E1000_CRC_SIZE;
    11771162               
    1178                 packet_t *packet = *(e1000->rx_ring_packets + next_tail);
    1179                 packet_suffix(packet, packet_size);
    1180                
    1181                 nic_dma_unlock_packet(packet, E1000_MAX_RECEIVE_PACKET_SIZE);
    1182                 nic_received_packet(nic, packet);
     1163                nic_frame_t *frame = nic_alloc_frame(nic, frame_size);
     1164                if (frame != NULL) {
     1165                        memcpy(frame->data, e1000->rx_frame_virt[next_tail], frame_size);
     1166                        nic_received_frame(nic, frame);
     1167                } else {
     1168                        ddf_msg(LVL_ERROR, "Memory allocation failed. Frame dropped.");
     1169                }
    11831170               
    11841171                e1000_fill_new_rx_descriptor(nic, next_tail);
    11851172               
    1186                 *tail_addr = e1000_inc_tail(*tail_addr, E1000_RX_PACKETS_COUNT);
    1187                 next_tail = e1000_inc_tail(*tail_addr, E1000_RX_PACKETS_COUNT);
     1173                *tail_addr = e1000_inc_tail(*tail_addr, E1000_RX_FRAME_COUNT);
     1174                next_tail = e1000_inc_tail(*tail_addr, E1000_RX_FRAME_COUNT);
    11881175               
    11891176                rx_descriptor = (e1000_rx_descriptor_t *)
    … …  
    12261213{
    12271214        if (icr & ICR_RXT0)
    1228                 e1000_receive_packets(nic);
     1215                e1000_receive_frames(nic);
    12291216}
    12301217
    … …  
    12751262}
    12761263
    1277 /** Force receiving all packets in the receive buffer
     1264/** Force receiving all frames in the receive buffer
    12781265 *
    12791266 * @param nic NIC data
    … …  
    13481335static void e1000_initialize_rx_registers(e1000_t *e1000)
    13491336{
    1350         E1000_REG_WRITE(e1000, E1000_RDLEN, E1000_RX_PACKETS_COUNT * 16);
     1337        E1000_REG_WRITE(e1000, E1000_RDLEN, E1000_RX_FRAME_COUNT * 16);
    13511338        E1000_REG_WRITE(e1000, E1000_RDH, 0);
    13521339       
    13531340        /* It is not posible to let HW use all descriptors */
    1354         E1000_REG_WRITE(e1000, E1000_RDT, E1000_RX_PACKETS_COUNT - 1);
     1341        E1000_REG_WRITE(e1000, E1000_RDT, E1000_RX_FRAME_COUNT - 1);
    13551342       
    13561343        /* Set Broadcast Enable Bit */
    … …  
    13721359       
    13731360        int rc = dmamem_map_anonymous(
    1374             E1000_RX_PACKETS_COUNT * sizeof(e1000_rx_descriptor_t),
     1361            E1000_RX_FRAME_COUNT * sizeof(e1000_rx_descriptor_t),
    13751362            AS_AREA_READ | AS_AREA_WRITE, 0, &e1000->rx_ring_phys,
    13761363            &e1000->rx_ring_virt);
    … …  
    13831370            (uint32_t) PTR_TO_U64(e1000->rx_ring_phys));
    13841371       
    1385         e1000->rx_ring_packets =
    1386             malloc(E1000_RX_PACKETS_COUNT * sizeof(packet_t *));
    1387         // FIXME: Check return value
    1388        
     1372        e1000->rx_frame_phys =
     1373            calloc(E1000_RX_FRAME_COUNT, sizeof(void *));
     1374        e1000->rx_frame_virt =
     1375            calloc(E1000_RX_FRAME_COUNT, sizeof(void *));
     1376        if (e1000->rx_frame_phys == NULL || e1000->rx_frame_virt == NULL) {
     1377                rc = ENOMEM;
     1378                goto error;
     1379        }
     1380       
     1381        size_t i;
     1382        void *frame_virt;
     1383        void *frame_phys;
     1384       
     1385        for (i = 0; i < E1000_RX_FRAME_COUNT; i++) {
     1386                rc = dmamem_map_anonymous(
     1387                    E1000_MAX_SEND_FRAME_SIZE, AS_AREA_READ | AS_AREA_WRITE,
     1388                    0, &frame_phys, &frame_virt);
     1389                if (rc != EOK)
     1390                        goto error;
     1391               
     1392                e1000->rx_frame_virt[i] = frame_virt;
     1393                e1000->rx_frame_phys[i] = frame_phys;
     1394        }
     1395       
     1396        /* Write descriptor */
     1397        for (i = 0; i < E1000_RX_FRAME_COUNT; i++)
     1398                e1000_fill_new_rx_descriptor(nic, i);
     1399       
     1400        e1000_initialize_rx_registers(e1000);
     1401       
     1402        fibril_mutex_unlock(&e1000->rx_lock);
     1403        return EOK;
     1404error:
     1405        for (i = 0; i < E1000_RX_FRAME_COUNT; i++) {
     1406                if (e1000->rx_frame_virt[i] != NULL) {
     1407                        dmamem_unmap_anonymous(e1000->rx_frame_virt[i]);
     1408                        e1000->rx_frame_virt[i] = NULL;
     1409                        e1000->rx_frame_phys[i] = NULL;
     1410                }
     1411        }
     1412        if (e1000->rx_frame_phys != NULL) {
     1413                free(e1000->rx_frame_phys);
     1414                e1000->rx_frame_phys = NULL;
     1415        }
     1416        if (e1000->rx_frame_virt != NULL) {
     1417                free(e1000->rx_frame_virt);
     1418                e1000->rx_frame_phys = NULL;
     1419        }
     1420        return rc;
     1421}
     1422
     1423/** Uninitialize receive structure
     1424 *
     1425 * @param nic NIC data
     1426 *
     1427 */
     1428static void e1000_uninitialize_rx_structure(nic_t *nic)
     1429{
     1430        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
     1431       
     1432        /* Write descriptor */
     1433        for (unsigned int offset = 0; offset < E1000_RX_FRAME_COUNT; offset++) {
     1434                dmamem_unmap_anonymous(e1000->rx_frame_virt[offset]);
     1435                e1000->rx_frame_virt[offset] = NULL;
     1436                e1000->rx_frame_phys[offset] = NULL;
     1437        }
     1438       
     1439        free(e1000->rx_frame_virt);
     1440        free(e1000->rx_frame_phys);
     1441        e1000->rx_frame_virt = NULL;
     1442        e1000->rx_frame_phys = NULL;
     1443        dmamem_unmap_anonymous(e1000->rx_ring_virt);
     1444}
     1445
     1446/** Clear receive descriptor ring
     1447 *
     1448 * @param e1000 E1000 data
     1449 *
     1450 */
     1451static void e1000_clear_rx_ring(e1000_t *e1000)
     1452{
    13891453        /* Write descriptor */
    13901454        for (unsigned int offset = 0;
    1391             offset < E1000_RX_PACKETS_COUNT;
    1392             offset++)
    1393                 e1000_fill_new_rx_descriptor(nic, offset);
    1394        
    1395         e1000_initialize_rx_registers(e1000);
    1396        
    1397         fibril_mutex_unlock(&e1000->rx_lock);
    1398         return EOK;
    1399 }
    1400 
    1401 /** Uninitialize receive structure
    1402  *
    1403  * @param nic NIC data
    1404  *
    1405  */
    1406 static void e1000_uninitialize_rx_structure(nic_t *nic)
    1407 {
    1408         e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    1409        
    1410         /* Write descriptor */
    1411         for (unsigned int offset = 0;
    1412             offset < E1000_RX_PACKETS_COUNT;
    1413             offset++) {
    1414                 packet_t *packet = *(e1000->rx_ring_packets + offset);
    1415                 nic_dma_unlock_packet(packet, E1000_MAX_RECEIVE_PACKET_SIZE);
    1416                 nic_release_packet(nic, packet);
    1417         }
    1418        
    1419         free(e1000->rx_ring_packets);
    1420         dmamem_unmap_anonymous(e1000->rx_ring_virt);
    1421 }
    1422 
    1423 /** Clear receive descriptor ring
    1424  *
    1425  * @param e1000 E1000 data
    1426  *
    1427  */
    1428 static void e1000_clear_rx_ring(e1000_t *e1000)
    1429 {
    1430         /* Write descriptor */
    1431         for (unsigned int offset = 0;
    1432             offset < E1000_RX_PACKETS_COUNT;
     1455            offset < E1000_RX_FRAME_COUNT;
    14331456            offset++)
    14341457                e1000_clear_rx_descriptor(e1000, offset);
    … …  
    14991522static void e1000_initialize_tx_registers(e1000_t *e1000)
    15001523{
    1501         E1000_REG_WRITE(e1000, E1000_TDLEN, E1000_TX_PACKETS_COUNT * 16);
     1524        E1000_REG_WRITE(e1000, E1000_TDLEN, E1000_TX_FRAME_COUNT * 16);
    15021525        E1000_REG_WRITE(e1000, E1000_TDH, 0);
    15031526        E1000_REG_WRITE(e1000, E1000_TDT, 0);
    … …  
    15211544static int e1000_initialize_tx_structure(e1000_t *e1000)
    15221545{
     1546        size_t i;
     1547       
    15231548        fibril_mutex_lock(&e1000->tx_lock);
    15241549       
     1550        e1000->tx_ring_phys = NULL;
     1551        e1000->tx_ring_virt = NULL;
     1552        e1000->tx_frame_phys = NULL;
     1553        e1000->tx_frame_virt = NULL;
     1554       
    15251555        int rc = dmamem_map_anonymous(
    1526             E1000_TX_PACKETS_COUNT * sizeof(e1000_tx_descriptor_t),
     1556            E1000_TX_FRAME_COUNT * sizeof(e1000_tx_descriptor_t),
    15271557            AS_AREA_READ | AS_AREA_WRITE, 0, &e1000->tx_ring_phys,
    15281558            &e1000->tx_ring_virt);
    15291559        if (rc != EOK)
    1530                 return rc;
     1560                goto error;
    15311561       
    15321562        bzero(e1000->tx_ring_virt,
    1533             E1000_TX_PACKETS_COUNT * sizeof(e1000_tx_descriptor_t));
     1563            E1000_TX_FRAME_COUNT * sizeof(e1000_tx_descriptor_t));
     1564       
     1565        e1000->tx_frame_phys = calloc(E1000_TX_FRAME_COUNT, sizeof(void *));
     1566        e1000->tx_frame_virt = calloc(E1000_TX_FRAME_COUNT, sizeof(void *));
     1567
     1568        if (e1000->tx_frame_phys == NULL || e1000->tx_frame_virt == NULL) {
     1569                rc = ENOMEM;
     1570                goto error;
     1571        }
     1572       
     1573        for (i = 0; i < E1000_TX_FRAME_COUNT; i++) {
     1574                rc = dmamem_map_anonymous(
     1575                    E1000_MAX_SEND_FRAME_SIZE, AS_AREA_READ | AS_AREA_WRITE,
     1576                    0, &e1000->tx_frame_phys[i], &e1000->tx_frame_virt[i]);
     1577                if (rc != EOK)
     1578                        goto error;
     1579        }
    15341580       
    15351581        E1000_REG_WRITE(e1000, E1000_TDBAH,
    … …  
    15381584            (uint32_t) PTR_TO_U64(e1000->tx_ring_phys));
    15391585       
    1540         e1000->tx_ring_packets =
    1541             malloc(E1000_TX_PACKETS_COUNT * sizeof(packet_t *));
    1542         // FIXME: Check return value
    1543        
    15441586        e1000_initialize_tx_registers(e1000);
    15451587       
    15461588        fibril_mutex_unlock(&e1000->tx_lock);
    15471589        return EOK;
     1590       
     1591error:
     1592        if (e1000->tx_ring_virt != NULL) {
     1593                dmamem_unmap_anonymous(e1000->tx_ring_virt);
     1594                e1000->tx_ring_virt = NULL;
     1595        }
     1596       
     1597        if (e1000->tx_frame_phys != NULL && e1000->tx_frame_virt != NULL) {
     1598                for (i = 0; i < E1000_TX_FRAME_COUNT; i++) {
     1599                        if (e1000->tx_frame_virt[i] != NULL) {
     1600                                dmamem_unmap_anonymous(e1000->tx_frame_virt[i]);
     1601                                e1000->tx_frame_virt[i] = NULL;
     1602                                e1000->tx_frame_phys[i] = NULL;
     1603                        }
     1604                }
     1605        }
     1606       
     1607        if (e1000->tx_frame_phys != NULL) {
     1608                free(e1000->tx_frame_phys);
     1609                e1000->tx_frame_phys = NULL;
     1610        }
     1611       
     1612        if (e1000->tx_frame_virt != NULL) {
     1613                free(e1000->tx_frame_virt);
     1614                e1000->tx_frame_phys = NULL;
     1615        }
     1616       
     1617        return rc;
    15481618}
    15491619
    … …  
    15551625static void e1000_uninitialize_tx_structure(e1000_t *e1000)
    15561626{
    1557         free(e1000->tx_ring_packets);
     1627        size_t i;
     1628       
     1629        for (i = 0; i < E1000_TX_FRAME_COUNT; i++) {
     1630                dmamem_unmap_anonymous(e1000->tx_frame_virt[i]);
     1631                e1000->tx_frame_virt[i] = NULL;
     1632                e1000->tx_frame_phys[i] = NULL;
     1633        }
     1634       
     1635        if (e1000->tx_frame_phys != NULL) {
     1636                free(e1000->tx_frame_phys);
     1637                e1000->tx_frame_phys = NULL;
     1638        }
     1639       
     1640        if (e1000->tx_frame_virt != NULL) {
     1641                free(e1000->tx_frame_virt);
     1642                e1000->tx_frame_phys = NULL;
     1643        }
    15581644        dmamem_unmap_anonymous(e1000->tx_ring_virt);
    15591645}
    … …  
    15681654        /* Write descriptor */
    15691655        for (unsigned int offset = 0;
    1570             offset < E1000_TX_PACKETS_COUNT;
     1656            offset < E1000_TX_FRAME_COUNT;
    15711657            offset++)
    15721658                e1000_clear_tx_descriptor(nic, offset);
    … …  
    16251711}
    16261712
    1627 /** Activate the device to receive and transmit packets
     1713/** Activate the device to receive and transmit frames
    16281714 *
    16291715 * @param nic NIC driver data
    … …  
    17701856       
    17711857        nic_set_specific(nic, e1000);
    1772         nic_set_write_packet_handler(nic, e1000_write_packet);
     1858        nic_set_send_frame_handler(nic, e1000_send_frame);
    17731859        nic_set_state_change_handlers(nic, e1000_on_activating,
    17741860            e1000_on_down, e1000_on_stopping);
    … …  
    18881974        /* Allocate driver data for the device. */
    18891975        e1000_t *e1000 = e1000_create_dev_data(dev);
    1890         if (e1000 == NULL)
     1976        if (e1000 == NULL) {
     1977                ddf_msg(LVL_ERROR, "Unable to allocate device softstate");
    18911978                return ENOMEM;
     1979        }
    18921980       
    18931981        /* Obtain and fill hardware resources info */
    18941982        int rc = e1000_get_resource_info(dev);
    18951983        if (rc != EOK) {
     1984                ddf_msg(LVL_ERROR, "Cannot obtain hardware resources");
    18961985                e1000_dev_cleanup(dev);
    18971986                return rc;
    18981987        }
    18991988       
     1989        uint16_t device_id;
    19001990        rc = pci_config_space_read_16(dev->parent_sess, PCI_DEVICE_ID,
    1901             &e1000->device_id);
     1991            &device_id);
    19021992        if (rc != EOK) {
     1993                ddf_msg(LVL_ERROR, "Cannot access PCI configuration space");
    19031994                e1000_dev_cleanup(dev);
    19041995                return rc;
     1996        }
     1997       
     1998        e1000_board_t board;
     1999        switch (device_id) {
     2000        case 0x100e:
     2001        case 0x1015:
     2002        case 0x1016:
     2003        case 0x1017:
     2004                board = E1000_82540;
     2005                break;
     2006        case 0x1013:
     2007        case 0x1018:
     2008        case 0x1078:
     2009                board = E1000_82541;
     2010                break;
     2011        case 0x1076:
     2012        case 0x1077:
     2013        case 0x107c:
     2014                board = E1000_82541REV2;
     2015                break;
     2016        case 0x100f:
     2017        case 0x1011:
     2018        case 0x1026:
     2019        case 0x1027:
     2020        case 0x1028:
     2021                board = E1000_82545;
     2022                break;
     2023        case 0x1010:
     2024        case 0x1012:
     2025        case 0x101d:
     2026        case 0x1079:
     2027        case 0x107a:
     2028        case 0x107b:
     2029                board = E1000_82546;
     2030                break;
     2031        case 0x1019:
     2032        case 0x101a:
     2033                board = E1000_82547;
     2034                break;
     2035        case 0x10b9:
     2036                board = E1000_82572;
     2037                break;
     2038        case 0x1096:
     2039                board = E1000_80003ES2;
     2040                break;
     2041        default:
     2042                ddf_msg(LVL_ERROR, "Device not supported (%#" PRIx16 ")",
     2043                    device_id);
     2044                e1000_dev_cleanup(dev);
     2045                return ENOTSUP;
     2046        }
     2047       
     2048        switch (board) {
     2049        case E1000_82540:
     2050        case E1000_82541:
     2051        case E1000_82541REV2:
     2052        case E1000_82545:
     2053        case E1000_82546:
     2054        case E1000_82572:
     2055                e1000->info.eerd_start = 0x01;
     2056                e1000->info.eerd_done = 0x10;
     2057                e1000->info.eerd_address_offset = 8;
     2058                e1000->info.eerd_data_offset = 16;
     2059                break;
     2060        case E1000_82547:
     2061        case E1000_80003ES2:
     2062                e1000->info.eerd_start = 0x01;
     2063                e1000->info.eerd_done = 0x02;
     2064                e1000->info.eerd_address_offset = 2;
     2065                e1000->info.eerd_data_offset = 16;
     2066                break;
    19052067        }
    19062068       
    … …  
    19352097int e1000_dev_add(ddf_dev_t *dev)
    19362098{
     2099        ddf_fun_t *fun;
    19372100        assert(dev);
    19382101       
    … …  
    19652128        e1000_initialize_vlan(e1000);
    19662129       
    1967         rc = nic_register_as_ddf_fun(nic, &e1000_dev_ops);
    1968         if (rc != EOK)
     2130        fun = ddf_fun_create(nic_get_ddf_dev(nic), fun_exposed, "port0");
     2131        if (fun == NULL)
    19692132                goto err_tx_structure;
     2133        nic_set_ddf_fun(nic, fun);
     2134        fun->ops = &e1000_dev_ops;
     2135        fun->driver_data = nic;
    19702136       
    19712137        rc = e1000_register_int_handler(nic);
    19722138        if (rc != EOK)
    1973                 goto err_tx_structure;
     2139                goto err_fun_create;
    19742140       
    19752141        rc = nic_connect_to_services(nic);
    … …  
    19942160                goto err_rx_structure;
    19952161       
     2162        rc = ddf_fun_bind(fun);
     2163        if (rc != EOK)
     2164                goto err_fun_bind;
     2165       
     2166        rc = ddf_fun_add_to_category(fun, DEVICE_CATEGORY_NIC);
     2167        if (rc != EOK)
     2168                goto err_add_to_cat;
     2169       
    19962170        return EOK;
    19972171       
     2172err_add_to_cat:
     2173        ddf_fun_unbind(fun);
     2174err_fun_bind:
    19982175err_rx_structure:
    19992176        e1000_uninitialize_rx_structure(nic);
    20002177err_irq:
    20012178        unregister_interrupt_handler(dev, DRIVER_DATA_DEV(dev)->irq);
     2179err_fun_create:
     2180        ddf_fun_destroy(fun);
     2181        nic_set_ddf_fun(nic, NULL);
    20022182err_tx_structure:
    20032183        e1000_uninitialize_tx_structure(e1000);
    … …  
    20232203        fibril_mutex_lock(&e1000->eeprom_lock);
    20242204       
    2025         uint32_t eerd_done;
    2026         uint32_t eerd_address_offset;
    2027        
    2028         switch (e1000->device_id) {
    2029         case 0x107c:
    2030         case 0x1013:
    2031         case 0x1018:
    2032         case 0x1019:
    2033         case 0x101A:
    2034         case 0x1076:
    2035         case 0x1077:
    2036         case 0x1078:
    2037         case 0x10b9:
    2038                 /* 82541xx and 82547GI/EI */
    2039                 eerd_done = EERD_DONE_82541XX_82547GI_EI;
    2040                 eerd_address_offset = EERD_ADDRESS_OFFSET_82541XX_82547GI_EI;
    2041                 break;
    2042         default:
    2043                 eerd_done = EERD_DONE;
    2044                 eerd_address_offset = EERD_ADDRESS_OFFSET;
    2045                 break;
    2046         }
    2047        
    20482205        /* Write address and START bit to EERD register */
    2049         uint32_t write_data = EERD_START |
    2050             (((uint32_t) eeprom_address) << eerd_address_offset);
     2206        uint32_t write_data = e1000->info.eerd_start |
     2207            (((uint32_t) eeprom_address) <<
     2208            e1000->info.eerd_address_offset);
    20512209        E1000_REG_WRITE(e1000, E1000_EERD, write_data);
    20522210       
    20532211        uint32_t eerd = E1000_REG_READ(e1000, E1000_EERD);
    2054         while ((eerd & eerd_done) == 0) {
     2212        while ((eerd & e1000->info.eerd_done) == 0) {
    20552213                usleep(1);
    20562214                eerd = E1000_REG_READ(e1000, E1000_EERD);
    … …  
    20592217        fibril_mutex_unlock(&e1000->eeprom_lock);
    20602218       
    2061         return (uint16_t) (eerd >> EERD_DATA_OFFSET);
     2219        return (uint16_t) (eerd >> e1000->info.eerd_data_offset);
    20622220}
    20632221
    … …  
    21352293}
    21362294
    2137 /** Send packet
     2295/** Send frame
    21382296 *
    21392297 * @param nic    NIC driver data structure
    2140  * @param packet Packet to send
     2298 * @param data   Frame data
     2299 * @param size   Frame size in bytes
    21412300 *
    21422301 * @return EOK if succeed
    … …  
    21442303 *
    21452304 */
    2146 static void e1000_write_packet(nic_t *nic, packet_t *packet)
     2305static void e1000_send_frame(nic_t *nic, void *data, size_t size)
    21472306{
    21482307        assert(nic);
    … …  
    21622321       
    21632322        /* Descriptor done */
    2164         if (tx_descriptor_addr->status & TXDESCRIPTOR_STATUS_DD) {
     2323        if (tx_descriptor_addr->status & TXDESCRIPTOR_STATUS_DD)
    21652324                descriptor_available = true;
    2166                 packet_t *old_packet = *(e1000->tx_ring_packets + tdt);
    2167                 if (old_packet) {
    2168                         size_t old_packet_size = packet_get_data_length(old_packet);
    2169                         nic_dma_unlock_packet(old_packet, old_packet_size);
    2170                         nic_release_packet(nic, old_packet);
    2171                 }
    2172         }
    21732325       
    21742326        if (!descriptor_available) {
    2175                 /* Packet lost */
     2327                /* Frame lost */
    21762328                fibril_mutex_unlock(&e1000->tx_lock);
    21772329                return;
    21782330        }
    21792331       
    2180         size_t packet_size = packet_get_data_length(packet);
    2181        
    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);
    2186                 return;
    2187         }
    2188        
    2189         *(e1000->tx_ring_packets + tdt) = packet;
    2190        
    2191         tx_descriptor_addr->phys_addr =
    2192             PTR_TO_U64(phys + packet->data_start);
    2193         tx_descriptor_addr->length = packet_size;
     2332        memcpy(e1000->tx_frame_virt[tdt], data, size);
     2333       
     2334        tx_descriptor_addr->phys_addr = PTR_TO_U64(e1000->tx_frame_phys[tdt]);
     2335        tx_descriptor_addr->length = size;
    21942336       
    21952337        /*
    … …  
    22122354       
    22132355        tdt++;
    2214         if (tdt == E1000_TX_PACKETS_COUNT)
     2356        if (tdt == E1000_TX_FRAME_COUNT)
    22152357                tdt = 0;
    22162358       
    … …  
    22282370        nic_driver_implement(&e1000_driver_ops, &e1000_dev_ops,
    22292371            &e1000_nic_iface);
     2372       
     2373        ddf_log_init(NAME, LVL_ERROR);
     2374        ddf_msg(LVL_NOTE, "HelenOS E1000 driver started");
    22302375        return ddf_driver_main(&e1000_driver);
    22312376}
Note: See TracChangeset for help on using the changeset viewer.