Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r321052f7 r6d8455d  
    5252#include <nil_remote.h>
    5353#include <ops/nic.h>
     54#include <packet_client.h>
     55#include <packet_remote.h>
     56#include <net/packet_header.h>
    5457#include "e1k.h"
    5558
    … …  
    5962
    6063/* Must be power of 8 */
    61 #define E1000_RX_FRAME_COUNT  128
    62 #define E1000_TX_FRAME_COUNT  128
     64#define E1000_RX_PACKETS_COUNT  128
     65#define E1000_TX_PACKETS_COUNT  128
    6366
    6467#define E1000_RECEIVE_ADDRESS  16
    6568
    66 /** Maximum sending frame size */
     69/** Maximum sending packet size */
    6770#define E1000_MAX_SEND_FRAME_SIZE  2048
    68 /** Maximum receiving frame size */
    69 #define E1000_MAX_RECEIVE_FRAME_SIZE  2048
     71/** Maximum receiving packet size */
     72#define E1000_MAX_RECEIVE_PACKET_SIZE  2048
    7073
    7174/** nic_driver_data_t* -> e1000_t* cast */
    … …  
    134137        void *rx_ring_virt;
    135138       
    136         /** Ring of RX frames, physical address */
    137         void **rx_frame_phys;
    138         /** Ring of RX frames, virtual address */
    139         void **rx_frame_virt;
     139        /** Packets in rx ring  */
     140        packet_t **rx_ring_packets;
    140141       
    141142        /** VLAN tag */
    142143        uint16_t vlan_tag;
    143144       
    144         /** Add VLAN tag to frame */
     145        /** Add VLAN tag to packet */
    145146        bool vlan_tag_add;
    146147       
    … …  
    476477}
    477478
    478 /** Get state of acceptance of weird frames
     479/** Get state of acceptance of weird packets
    479480 *
    480481 * @param      device Device to check
    … …  
    494495};
    495496
    496 /** Set acceptance of weird frames
     497/** Set acceptance of weird packets
    497498 *
    498499 * @param device Device to update
    … …  
    678679}
    679680
    680 /** Disable receiving frames for default address
     681/** Disable receiving packets for default address
    681682 *
    682683 * @param e1000 E1000 data structure
    … …  
    690691}
    691692
    692 /** Enable receiving frames for default address
     693/** Enable receiving packets for default address
    693694 *
    694695 * @param e1000 E1000 data structure
    … …  
    750751}
    751752
    752 /** Enable accepting of broadcast frames
     753/** Enable accepting of broadcast packets
    753754 *
    754755 * @param e1000 E1000 data structure
    … …  
    762763}
    763764
    764 /** Disable accepting of broadcast frames
     765/** Disable accepting of broadcast packets
    765766 *
    766767 * @param e1000 E1000 data structure
    … …  
    798799}
    799800
    800 /** Set multicast frames acceptance mode
     801/** Set multicast packets acceptance mode
    801802 *
    802803 * @param nic      NIC device to update
    … …  
    852853}
    853854
    854 /** Set unicast frames acceptance mode
     855/** Set unicast packets acceptance mode
    855856 *
    856857 * @param nic      NIC device to update
    … …  
    910911}
    911912
    912 /** Set broadcast frames acceptance mode
     913/** Set broadcast packets acceptance mode
    913914 *
    914915 * @param nic  NIC device to update
    … …  
    995996        if (vlan_mask) {
    996997                /*
    997                  * Disable receiving, so that frame matching
     998                 * Disable receiving, so that packet matching
    998999                 * partially written VLAN is not received.
    9991000                 */
    … …  
    10621063}
    10631064
    1064 /** Fill receive descriptor with new empty buffer
    1065  *
    1066  * Store frame in e1000->rx_frame_phys
     1065/** Fill receive descriptor with new empty packet
     1066 *
     1067 * Store packet in e1000->rx_ring_packets
    10671068 *
    10681069 * @param nic    NIC data stricture
    … …  
    10731074{
    10741075        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    1075        
     1076        packet_t *packet =
     1077            nic_alloc_packet(nic, E1000_MAX_RECEIVE_PACKET_SIZE);
     1078       
     1079        assert(packet);
     1080       
     1081        *(e1000->rx_ring_packets + offset) = packet;
    10761082        e1000_rx_descriptor_t *rx_descriptor = (e1000_rx_descriptor_t *)
    10771083            (e1000->rx_ring_virt + offset * sizeof(e1000_rx_descriptor_t));
    10781084       
    1079         rx_descriptor->phys_addr = PTR_TO_U64(e1000->rx_frame_phys[offset]);
     1085        void *phys;
     1086        int rc =
     1087            nic_dma_lock_packet(packet, E1000_MAX_RECEIVE_PACKET_SIZE, &phys);
     1088       
     1089        if (rc == EOK)
     1090                rx_descriptor->phys_addr = PTR_TO_U64(phys + packet->data_start);
     1091        else
     1092                rx_descriptor->phys_addr = 0;
     1093       
    10801094        rx_descriptor->length = 0;
    10811095        rx_descriptor->checksum = 0;
    … …  
    11411155}
    11421156
    1143 /** Receive frames
     1157/** Receive packets
    11441158 *
    11451159 * @param nic NIC data
    11461160 *
    11471161 */
    1148 static void e1000_receive_frames(nic_t *nic)
     1162static void e1000_receive_packets(nic_t *nic)
    11491163{
    11501164        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    … …  
    11531167       
    11541168        uint32_t *tail_addr = E1000_REG_ADDR(e1000, E1000_RDT);
    1155         uint32_t next_tail = e1000_inc_tail(*tail_addr, E1000_RX_FRAME_COUNT);
     1169        uint32_t next_tail = e1000_inc_tail(*tail_addr, E1000_RX_PACKETS_COUNT);
    11561170       
    11571171        e1000_rx_descriptor_t *rx_descriptor = (e1000_rx_descriptor_t *)
    … …  
    11591173       
    11601174        while (rx_descriptor->status & 0x01) {
    1161                 uint32_t frame_size = rx_descriptor->length - E1000_CRC_SIZE;
     1175                uint32_t packet_size = rx_descriptor->length - E1000_CRC_SIZE;
    11621176               
    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                 }
     1177                packet_t *packet = *(e1000->rx_ring_packets + next_tail);
     1178                packet_suffix(packet, packet_size);
     1179               
     1180                nic_dma_unlock_packet(packet, E1000_MAX_RECEIVE_PACKET_SIZE);
     1181                nic_received_packet(nic, packet);
    11701182               
    11711183                e1000_fill_new_rx_descriptor(nic, next_tail);
    11721184               
    1173                 *tail_addr = e1000_inc_tail(*tail_addr, E1000_RX_FRAME_COUNT);
    1174                 next_tail = e1000_inc_tail(*tail_addr, E1000_RX_FRAME_COUNT);
     1185                *tail_addr = e1000_inc_tail(*tail_addr, E1000_RX_PACKETS_COUNT);
     1186                next_tail = e1000_inc_tail(*tail_addr, E1000_RX_PACKETS_COUNT);
    11751187               
    11761188                rx_descriptor = (e1000_rx_descriptor_t *)
    … …  
    12131225{
    12141226        if (icr & ICR_RXT0)
    1215                 e1000_receive_frames(nic);
     1227                e1000_receive_packets(nic);
    12161228}
    12171229
    … …  
    12621274}
    12631275
    1264 /** Force receiving all frames in the receive buffer
     1276/** Force receiving all packets in the receive buffer
    12651277 *
    12661278 * @param nic NIC data
    … …  
    13351347static void e1000_initialize_rx_registers(e1000_t *e1000)
    13361348{
    1337         E1000_REG_WRITE(e1000, E1000_RDLEN, E1000_RX_FRAME_COUNT * 16);
     1349        E1000_REG_WRITE(e1000, E1000_RDLEN, E1000_RX_PACKETS_COUNT * 16);
    13381350        E1000_REG_WRITE(e1000, E1000_RDH, 0);
    13391351       
    13401352        /* It is not posible to let HW use all descriptors */
    1341         E1000_REG_WRITE(e1000, E1000_RDT, E1000_RX_FRAME_COUNT - 1);
     1353        E1000_REG_WRITE(e1000, E1000_RDT, E1000_RX_PACKETS_COUNT - 1);
    13421354       
    13431355        /* Set Broadcast Enable Bit */
    … …  
    13591371       
    13601372        int rc = dmamem_map_anonymous(
    1361             E1000_RX_FRAME_COUNT * sizeof(e1000_rx_descriptor_t),
     1373            E1000_RX_PACKETS_COUNT * sizeof(e1000_rx_descriptor_t),
    13621374            AS_AREA_READ | AS_AREA_WRITE, 0, &e1000->rx_ring_phys,
    13631375            &e1000->rx_ring_virt);
    … …  
    13701382            (uint32_t) PTR_TO_U64(e1000->rx_ring_phys));
    13711383       
    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         }
     1384        e1000->rx_ring_packets =
     1385            malloc(E1000_RX_PACKETS_COUNT * sizeof(packet_t *));
     1386        // FIXME: Check return value
    13951387       
    13961388        /* Write descriptor */
    1397         for (i = 0; i < E1000_RX_FRAME_COUNT; i++)
    1398                 e1000_fill_new_rx_descriptor(nic, i);
     1389        for (unsigned int offset = 0;
     1390            offset < E1000_RX_PACKETS_COUNT;
     1391            offset++)
     1392                e1000_fill_new_rx_descriptor(nic, offset);
    13991393       
    14001394        e1000_initialize_rx_registers(e1000);
    … …  
    14021396        fibril_mutex_unlock(&e1000->rx_lock);
    14031397        return EOK;
    1404 error:
    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;
    14211398}
    14221399
    … …  
    14301407        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    14311408       
    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  */
    1451 static void e1000_clear_rx_ring(e1000_t *e1000)
    1452 {
    14531409        /* Write descriptor */
    14541410        for (unsigned int offset = 0;
    1455             offset < E1000_RX_FRAME_COUNT;
     1411            offset < E1000_RX_PACKETS_COUNT;
     1412            offset++) {
     1413                packet_t *packet = *(e1000->rx_ring_packets + offset);
     1414                nic_dma_unlock_packet(packet, E1000_MAX_RECEIVE_PACKET_SIZE);
     1415                nic_release_packet(nic, packet);
     1416        }
     1417       
     1418        free(e1000->rx_ring_packets);
     1419        dmamem_unmap_anonymous(e1000->rx_ring_virt);
     1420}
     1421
     1422/** Clear receive descriptor ring
     1423 *
     1424 * @param e1000 E1000 data
     1425 *
     1426 */
     1427static void e1000_clear_rx_ring(e1000_t *e1000)
     1428{
     1429        /* Write descriptor */
     1430        for (unsigned int offset = 0;
     1431            offset < E1000_RX_PACKETS_COUNT;
    14561432            offset++)
    14571433                e1000_clear_rx_descriptor(e1000, offset);
    … …  
    15221498static void e1000_initialize_tx_registers(e1000_t *e1000)
    15231499{
    1524         E1000_REG_WRITE(e1000, E1000_TDLEN, E1000_TX_FRAME_COUNT * 16);
     1500        E1000_REG_WRITE(e1000, E1000_TDLEN, E1000_TX_PACKETS_COUNT * 16);
    15251501        E1000_REG_WRITE(e1000, E1000_TDH, 0);
    15261502        E1000_REG_WRITE(e1000, E1000_TDT, 0);
    … …  
    15541530       
    15551531        int rc = dmamem_map_anonymous(
    1556             E1000_TX_FRAME_COUNT * sizeof(e1000_tx_descriptor_t),
     1532            E1000_TX_PACKETS_COUNT * sizeof(e1000_tx_descriptor_t),
    15571533            AS_AREA_READ | AS_AREA_WRITE, 0, &e1000->tx_ring_phys,
    15581534            &e1000->tx_ring_virt);
    … …  
    15611537       
    15621538        bzero(e1000->tx_ring_virt,
    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 *));
     1539            E1000_TX_PACKETS_COUNT * sizeof(e1000_tx_descriptor_t));
     1540       
     1541        e1000->tx_frame_phys = calloc(E1000_TX_PACKETS_COUNT, sizeof(void *));
     1542        e1000->tx_frame_virt = calloc(E1000_TX_PACKETS_COUNT, sizeof(void *));
    15671543
    15681544        if (e1000->tx_frame_phys == NULL || e1000->tx_frame_virt == NULL) {
    … …  
    15711547        }
    15721548       
    1573         for (i = 0; i < E1000_TX_FRAME_COUNT; i++) {
     1549        for (i = 0; i < E1000_TX_PACKETS_COUNT; i++) {
    15741550                rc = dmamem_map_anonymous(
    15751551                    E1000_MAX_SEND_FRAME_SIZE, AS_AREA_READ | AS_AREA_WRITE,
    … …  
    15961572       
    15971573        if (e1000->tx_frame_phys != NULL && e1000->tx_frame_virt != NULL) {
    1598                 for (i = 0; i < E1000_TX_FRAME_COUNT; i++) {
     1574                for (i = 0; i < E1000_TX_PACKETS_COUNT; i++) {
    15991575                        if (e1000->tx_frame_virt[i] != NULL) {
    16001576                                dmamem_unmap_anonymous(e1000->tx_frame_virt[i]);
    … …  
    16271603        size_t i;
    16281604       
    1629         for (i = 0; i < E1000_TX_FRAME_COUNT; i++) {
     1605        for (i = 0; i < E1000_TX_PACKETS_COUNT; i++) {
    16301606                dmamem_unmap_anonymous(e1000->tx_frame_virt[i]);
    16311607                e1000->tx_frame_virt[i] = NULL;
    … …  
    16541630        /* Write descriptor */
    16551631        for (unsigned int offset = 0;
    1656             offset < E1000_TX_FRAME_COUNT;
     1632            offset < E1000_TX_PACKETS_COUNT;
    16571633            offset++)
    16581634                e1000_clear_tx_descriptor(nic, offset);
    … …  
    17111687}
    17121688
    1713 /** Activate the device to receive and transmit frames
     1689/** Activate the device to receive and transmit packets
    17141690 *
    17151691 * @param nic NIC driver data
    … …  
    23072283       
    23082284        if (!descriptor_available) {
    2309                 /* Frame lost */
     2285                /* Packet lost */
    23102286                fibril_mutex_unlock(&e1000->tx_lock);
    23112287                return;
    … …  
    23362312       
    23372313        tdt++;
    2338         if (tdt == E1000_TX_FRAME_COUNT)
     2314        if (tdt == E1000_TX_PACKETS_COUNT)
    23392315                tdt = 0;
    23402316       
Note: See TracChangeset for help on using the changeset viewer.