Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    re882e3a rec52752  
    4646#include <ddf/log.h>
    4747#include <ddf/interrupt.h>
     48#include <devman.h>
    4849#include <device/hw_res_parsed.h>
    4950#include <device/pci.h>
    … …  
    5152#include <nil_remote.h>
    5253#include <ops/nic.h>
     54#include <packet_client.h>
     55#include <packet_remote.h>
     56#include <net/packet_header.h>
    5357#include "e1k.h"
    5458
    … …  
    5862
    5963/* Must be power of 8 */
    60 #define E1000_RX_FRAME_COUNT  128
    61 #define E1000_TX_FRAME_COUNT  128
     64#define E1000_RX_PACKETS_COUNT  128
     65#define E1000_TX_PACKETS_COUNT  128
    6266
    6367#define E1000_RECEIVE_ADDRESS  16
    6468
    65 /** Maximum sending frame size */
     69/** Maximum sending packet size */
    6670#define E1000_MAX_SEND_FRAME_SIZE  2048
    67 /** Maximum receiving frame size */
    68 #define E1000_MAX_RECEIVE_FRAME_SIZE  2048
     71/** Maximum receiving packet size */
     72#define E1000_MAX_RECEIVE_PACKET_SIZE  2048
    6973
    7074/** nic_driver_data_t* -> e1000_t* cast */
    … …  
    133137        void *rx_ring_virt;
    134138       
    135         /** Ring of RX frames, physical address */
    136         void **rx_frame_phys;
    137         /** Ring of RX frames, virtual address */
    138         void **rx_frame_virt;
     139        /** Packets in rx ring  */
     140        packet_t **rx_ring_packets;
    139141       
    140142        /** VLAN tag */
    141143        uint16_t vlan_tag;
    142144       
    143         /** Add VLAN tag to frame */
     145        /** Add VLAN tag to packet */
    144146        bool vlan_tag_add;
    145147       
    … …  
    486488}
    487489
    488 /** Get state of acceptance of weird frames
     490/** Get state of acceptance of weird packets
    489491 *
    490492 * @param      device Device to check
    … …  
    504506};
    505507
    506 /** Set acceptance of weird frames
     508/** Set acceptance of weird packets
    507509 *
    508510 * @param device Device to update
    … …  
    688690}
    689691
    690 /** Disable receiving frames for default address
     692/** Disable receiving packets for default address
    691693 *
    692694 * @param e1000 E1000 data structure
    … …  
    700702}
    701703
    702 /** Enable receiving frames for default address
     704/** Enable receiving packets for default address
    703705 *
    704706 * @param e1000 E1000 data structure
    … …  
    760762}
    761763
    762 /** Enable accepting of broadcast frames
     764/** Enable accepting of broadcast packets
    763765 *
    764766 * @param e1000 E1000 data structure
    … …  
    772774}
    773775
    774 /** Disable accepting of broadcast frames
     776/** Disable accepting of broadcast packets
    775777 *
    776778 * @param e1000 E1000 data structure
    … …  
    808810}
    809811
    810 /** Set multicast frames acceptance mode
     812/** Set multicast packets acceptance mode
    811813 *
    812814 * @param nic      NIC device to update
    … …  
    862864}
    863865
    864 /** Set unicast frames acceptance mode
     866/** Set unicast packets acceptance mode
    865867 *
    866868 * @param nic      NIC device to update
    … …  
    920922}
    921923
    922 /** Set broadcast frames acceptance mode
     924/** Set broadcast packets acceptance mode
    923925 *
    924926 * @param nic  NIC device to update
    … …  
    10051007        if (vlan_mask) {
    10061008                /*
    1007                  * Disable receiving, so that frame matching
     1009                 * Disable receiving, so that packet matching
    10081010                 * partially written VLAN is not received.
    10091011                 */
    … …  
    10721074}
    10731075
    1074 /** Fill receive descriptor with new empty buffer
    1075  *
    1076  * Store frame in e1000->rx_frame_phys
     1076/** Fill receive descriptor with new empty packet
     1077 *
     1078 * Store packet in e1000->rx_ring_packets
    10771079 *
    10781080 * @param nic    NIC data stricture
    … …  
    10831085{
    10841086        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    1085        
     1087        packet_t *packet =
     1088            nic_alloc_packet(nic, E1000_MAX_RECEIVE_PACKET_SIZE);
     1089       
     1090        assert(packet);
     1091       
     1092        *(e1000->rx_ring_packets + offset) = packet;
    10861093        e1000_rx_descriptor_t *rx_descriptor = (e1000_rx_descriptor_t *)
    10871094            (e1000->rx_ring_virt + offset * sizeof(e1000_rx_descriptor_t));
    10881095       
    1089         rx_descriptor->phys_addr = PTR_TO_U64(e1000->rx_frame_phys[offset]);
     1096        void *phys;
     1097        int rc =
     1098            nic_dma_lock_packet(packet, E1000_MAX_RECEIVE_PACKET_SIZE, &phys);
     1099       
     1100        if (rc == EOK)
     1101                rx_descriptor->phys_addr = PTR_TO_U64(phys + packet->data_start);
     1102        else
     1103                rx_descriptor->phys_addr = 0;
     1104       
    10901105        rx_descriptor->length = 0;
    10911106        rx_descriptor->checksum = 0;
    … …  
    11511166}
    11521167
    1153 /** Receive frames
     1168/** Receive packets
    11541169 *
    11551170 * @param nic NIC data
    11561171 *
    11571172 */
    1158 static void e1000_receive_frames(nic_t *nic)
     1173static void e1000_receive_packets(nic_t *nic)
    11591174{
    11601175        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    … …  
    11631178       
    11641179        uint32_t *tail_addr = E1000_REG_ADDR(e1000, E1000_RDT);
    1165         uint32_t next_tail = e1000_inc_tail(*tail_addr, E1000_RX_FRAME_COUNT);
     1180        uint32_t next_tail = e1000_inc_tail(*tail_addr, E1000_RX_PACKETS_COUNT);
    11661181       
    11671182        e1000_rx_descriptor_t *rx_descriptor = (e1000_rx_descriptor_t *)
    … …  
    11691184       
    11701185        while (rx_descriptor->status & 0x01) {
    1171                 uint32_t frame_size = rx_descriptor->length - E1000_CRC_SIZE;
     1186                uint32_t packet_size = rx_descriptor->length - E1000_CRC_SIZE;
    11721187               
    1173                 nic_frame_t *frame = nic_alloc_frame(nic, frame_size);
    1174                 if (frame != NULL) {
    1175                         memcpy(frame->data, e1000->rx_frame_virt[next_tail], frame_size);
    1176                         nic_received_frame(nic, frame);
    1177                 } else {
    1178                         ddf_msg(LVL_ERROR, "Memory allocation failed. Frame dropped.");
    1179                 }
     1188                packet_t *packet = *(e1000->rx_ring_packets + next_tail);
     1189                packet_suffix(packet, packet_size);
     1190               
     1191                nic_dma_unlock_packet(packet, E1000_MAX_RECEIVE_PACKET_SIZE);
     1192                nic_received_packet(nic, packet);
    11801193               
    11811194                e1000_fill_new_rx_descriptor(nic, next_tail);
    11821195               
    1183                 *tail_addr = e1000_inc_tail(*tail_addr, E1000_RX_FRAME_COUNT);
    1184                 next_tail = e1000_inc_tail(*tail_addr, E1000_RX_FRAME_COUNT);
     1196                *tail_addr = e1000_inc_tail(*tail_addr, E1000_RX_PACKETS_COUNT);
     1197                next_tail = e1000_inc_tail(*tail_addr, E1000_RX_PACKETS_COUNT);
    11851198               
    11861199                rx_descriptor = (e1000_rx_descriptor_t *)
    … …  
    12231236{
    12241237        if (icr & ICR_RXT0)
    1225                 e1000_receive_frames(nic);
     1238                e1000_receive_packets(nic);
    12261239}
    12271240
    … …  
    12731286}
    12741287
    1275 /** Force receiving all frames in the receive buffer
     1288/** Force receiving all packets in the receive buffer
    12761289 *
    12771290 * @param nic NIC data
    … …  
    13461359static void e1000_initialize_rx_registers(e1000_t *e1000)
    13471360{
    1348         E1000_REG_WRITE(e1000, E1000_RDLEN, E1000_RX_FRAME_COUNT * 16);
     1361        E1000_REG_WRITE(e1000, E1000_RDLEN, E1000_RX_PACKETS_COUNT * 16);
    13491362        E1000_REG_WRITE(e1000, E1000_RDH, 0);
    13501363       
    13511364        /* It is not posible to let HW use all descriptors */
    1352         E1000_REG_WRITE(e1000, E1000_RDT, E1000_RX_FRAME_COUNT - 1);
     1365        E1000_REG_WRITE(e1000, E1000_RDT, E1000_RX_PACKETS_COUNT - 1);
    13531366       
    13541367        /* Set Broadcast Enable Bit */
    … …  
    13701383       
    13711384        int rc = dmamem_map_anonymous(
    1372             E1000_RX_FRAME_COUNT * sizeof(e1000_rx_descriptor_t),
     1385            E1000_RX_PACKETS_COUNT * sizeof(e1000_rx_descriptor_t),
    13731386            AS_AREA_READ | AS_AREA_WRITE, 0, &e1000->rx_ring_phys,
    13741387            &e1000->rx_ring_virt);
    … …  
    13811394            (uint32_t) PTR_TO_U64(e1000->rx_ring_phys));
    13821395       
    1383         e1000->rx_frame_phys =
    1384             calloc(E1000_RX_FRAME_COUNT, sizeof(void *));
    1385         e1000->rx_frame_virt =
    1386             calloc(E1000_RX_FRAME_COUNT, sizeof(void *));
    1387         if (e1000->rx_frame_phys == NULL || e1000->rx_frame_virt == NULL) {
    1388                 rc = ENOMEM;
    1389                 goto error;
    1390         }
    1391        
    1392         size_t i;
    1393         void *frame_virt;
    1394         void *frame_phys;
    1395        
    1396         for (i = 0; i < E1000_RX_FRAME_COUNT; i++) {
    1397                 rc = dmamem_map_anonymous(
    1398                     E1000_MAX_SEND_FRAME_SIZE, AS_AREA_READ | AS_AREA_WRITE,
    1399                     0, &frame_phys, &frame_virt);
    1400                 if (rc != EOK)
    1401                         goto error;
    1402                
    1403                 e1000->rx_frame_virt[i] = frame_virt;
    1404                 e1000->rx_frame_phys[i] = frame_phys;
    1405         }
     1396        e1000->rx_ring_packets =
     1397            malloc(E1000_RX_PACKETS_COUNT * sizeof(packet_t *));
     1398        // FIXME: Check return value
    14061399       
    14071400        /* Write descriptor */
    1408         for (i = 0; i < E1000_RX_FRAME_COUNT; i++)
    1409                 e1000_fill_new_rx_descriptor(nic, i);
     1401        for (unsigned int offset = 0;
     1402            offset < E1000_RX_PACKETS_COUNT;
     1403            offset++)
     1404                e1000_fill_new_rx_descriptor(nic, offset);
    14101405       
    14111406        e1000_initialize_rx_registers(e1000);
    … …  
    14131408        fibril_mutex_unlock(&e1000->rx_lock);
    14141409        return EOK;
    1415        
    1416 error:
    1417         for (i = 0; i < E1000_RX_FRAME_COUNT; i++) {
    1418                 if (e1000->rx_frame_virt[i] != NULL) {
    1419                         dmamem_unmap_anonymous(e1000->rx_frame_virt[i]);
    1420                         e1000->rx_frame_virt[i] = NULL;
    1421                         e1000->rx_frame_phys[i] = NULL;
    1422                 }
    1423         }
    1424        
    1425         if (e1000->rx_frame_phys != NULL) {
    1426                 free(e1000->rx_frame_phys);
    1427                 e1000->rx_frame_phys = NULL;
    1428         }
    1429        
    1430         if (e1000->rx_frame_virt != NULL) {
    1431                 free(e1000->rx_frame_virt);
    1432                 e1000->rx_frame_phys = NULL;
    1433         }
    1434        
    1435         return rc;
    14361410}
    14371411
    … …  
    14451419        e1000_t *e1000 = DRIVER_DATA_NIC(nic);
    14461420       
    1447         /* Write descriptor */
    1448         for (unsigned int offset = 0; offset < E1000_RX_FRAME_COUNT; offset++) {
    1449                 dmamem_unmap_anonymous(e1000->rx_frame_virt[offset]);
    1450                 e1000->rx_frame_virt[offset] = NULL;
    1451                 e1000->rx_frame_phys[offset] = NULL;
    1452         }
    1453        
    1454         free(e1000->rx_frame_virt);
    1455         free(e1000->rx_frame_phys);
    1456         e1000->rx_frame_virt = NULL;
    1457         e1000->rx_frame_phys = NULL;
    1458         dmamem_unmap_anonymous(e1000->rx_ring_virt);
    1459 }
    1460 
    1461 /** Clear receive descriptor ring
    1462  *
    1463  * @param e1000 E1000 data
    1464  *
    1465  */
    1466 static void e1000_clear_rx_ring(e1000_t *e1000)
    1467 {
    14681421        /* Write descriptor */
    14691422        for (unsigned int offset = 0;
    1470             offset < E1000_RX_FRAME_COUNT;
     1423            offset < E1000_RX_PACKETS_COUNT;
     1424            offset++) {
     1425                packet_t *packet = *(e1000->rx_ring_packets + offset);
     1426                nic_dma_unlock_packet(packet, E1000_MAX_RECEIVE_PACKET_SIZE);
     1427                nic_release_packet(nic, packet);
     1428        }
     1429       
     1430        free(e1000->rx_ring_packets);
     1431        dmamem_unmap_anonymous(e1000->rx_ring_virt);
     1432}
     1433
     1434/** Clear receive descriptor ring
     1435 *
     1436 * @param e1000 E1000 data
     1437 *
     1438 */
     1439static void e1000_clear_rx_ring(e1000_t *e1000)
     1440{
     1441        /* Write descriptor */
     1442        for (unsigned int offset = 0;
     1443            offset < E1000_RX_PACKETS_COUNT;
    14711444            offset++)
    14721445                e1000_clear_rx_descriptor(e1000, offset);
    … …  
    15371510static void e1000_initialize_tx_registers(e1000_t *e1000)
    15381511{
    1539         E1000_REG_WRITE(e1000, E1000_TDLEN, E1000_TX_FRAME_COUNT * 16);
     1512        E1000_REG_WRITE(e1000, E1000_TDLEN, E1000_TX_PACKETS_COUNT * 16);
    15401513        E1000_REG_WRITE(e1000, E1000_TDH, 0);
    15411514        E1000_REG_WRITE(e1000, E1000_TDT, 0);
    … …  
    15691542       
    15701543        int rc = dmamem_map_anonymous(
    1571             E1000_TX_FRAME_COUNT * sizeof(e1000_tx_descriptor_t),
     1544            E1000_TX_PACKETS_COUNT * sizeof(e1000_tx_descriptor_t),
    15721545            AS_AREA_READ | AS_AREA_WRITE, 0, &e1000->tx_ring_phys,
    15731546            &e1000->tx_ring_virt);
    … …  
    15761549       
    15771550        bzero(e1000->tx_ring_virt,
    1578             E1000_TX_FRAME_COUNT * sizeof(e1000_tx_descriptor_t));
    1579        
    1580         e1000->tx_frame_phys = calloc(E1000_TX_FRAME_COUNT, sizeof(void *));
    1581         e1000->tx_frame_virt = calloc(E1000_TX_FRAME_COUNT, sizeof(void *));
     1551            E1000_TX_PACKETS_COUNT * sizeof(e1000_tx_descriptor_t));
     1552       
     1553        e1000->tx_frame_phys = calloc(E1000_TX_PACKETS_COUNT, sizeof(void *));
     1554        e1000->tx_frame_virt = calloc(E1000_TX_PACKETS_COUNT, sizeof(void *));
    15821555
    15831556        if (e1000->tx_frame_phys == NULL || e1000->tx_frame_virt == NULL) {
    … …  
    15861559        }
    15871560       
    1588         for (i = 0; i < E1000_TX_FRAME_COUNT; i++) {
     1561        for (i = 0; i < E1000_TX_PACKETS_COUNT; i++) {
    15891562                rc = dmamem_map_anonymous(
    15901563                    E1000_MAX_SEND_FRAME_SIZE, AS_AREA_READ | AS_AREA_WRITE,
    … …  
    16111584       
    16121585        if (e1000->tx_frame_phys != NULL && e1000->tx_frame_virt != NULL) {
    1613                 for (i = 0; i < E1000_TX_FRAME_COUNT; i++) {
     1586                for (i = 0; i < E1000_TX_PACKETS_COUNT; i++) {
    16141587                        if (e1000->tx_frame_virt[i] != NULL) {
    16151588                                dmamem_unmap_anonymous(e1000->tx_frame_virt[i]);
    … …  
    16421615        size_t i;
    16431616       
    1644         for (i = 0; i < E1000_TX_FRAME_COUNT; i++) {
     1617        for (i = 0; i < E1000_TX_PACKETS_COUNT; i++) {
    16451618                dmamem_unmap_anonymous(e1000->tx_frame_virt[i]);
    16461619                e1000->tx_frame_virt[i] = NULL;
    … …  
    16571630                e1000->tx_frame_phys = NULL;
    16581631        }
    1659        
    16601632        dmamem_unmap_anonymous(e1000->tx_ring_virt);
    16611633}
    … …  
    16701642        /* Write descriptor */
    16711643        for (unsigned int offset = 0;
    1672             offset < E1000_TX_FRAME_COUNT;
     1644            offset < E1000_TX_PACKETS_COUNT;
    16731645            offset++)
    16741646                e1000_clear_tx_descriptor(nic, offset);
    … …  
    17271699}
    17281700
    1729 /** Activate the device to receive and transmit frames
     1701/** Activate the device to receive and transmit packets
    17301702 *
    17311703 * @param nic NIC driver data
    … …  
    20682040        case E1000_82545:
    20692041        case E1000_82546:
     2042        case E1000_82572:
    20702043                e1000->info.eerd_start = 0x01;
    20712044                e1000->info.eerd_done = 0x10;
    … …  
    20742047                break;
    20752048        case E1000_82547:
    2076         case E1000_82572:
    20772049        case E1000_80003ES2:
    20782050                e1000->info.eerd_start = 0x01;
    … …  
    21132085int e1000_dev_add(ddf_dev_t *dev)
    21142086{
    2115         ddf_fun_t *fun;
    21162087        assert(dev);
    21172088       
    … …  
    21442115        e1000_initialize_vlan(e1000);
    21452116       
    2146         fun = ddf_fun_create(nic_get_ddf_dev(nic), fun_exposed, "port0");
    2147         if (fun == NULL)
     2117        rc = nic_register_as_ddf_fun(nic, &e1000_dev_ops);
     2118        if (rc != EOK)
    21482119                goto err_tx_structure;
    2149         nic_set_ddf_fun(nic, fun);
    2150         fun->ops = &e1000_dev_ops;
    2151         fun->driver_data = nic;
    21522120       
    21532121        rc = e1000_register_int_handler(nic);
    21542122        if (rc != EOK)
    2155                 goto err_fun_create;
     2123                goto err_tx_structure;
    21562124       
    21572125        rc = nic_connect_to_services(nic);
    … …  
    21762144                goto err_rx_structure;
    21772145       
    2178         rc = ddf_fun_bind(fun);
    2179         if (rc != EOK)
    2180                 goto err_fun_bind;
    2181        
    2182         rc = ddf_fun_add_to_category(fun, DEVICE_CATEGORY_NIC);
    2183         if (rc != EOK)
    2184                 goto err_add_to_cat;
    2185        
    21862146        return EOK;
    21872147       
    2188 err_add_to_cat:
    2189         ddf_fun_unbind(fun);
    2190 err_fun_bind:
    21912148err_rx_structure:
    21922149        e1000_uninitialize_rx_structure(nic);
    21932150err_irq:
    21942151        unregister_interrupt_handler(dev, DRIVER_DATA_DEV(dev)->irq);
    2195 err_fun_create:
    2196         ddf_fun_destroy(fun);
    2197         nic_set_ddf_fun(nic, NULL);
    21982152err_tx_structure:
    21992153        e1000_uninitialize_tx_structure(e1000);
    … …  
    23412295       
    23422296        if (!descriptor_available) {
    2343                 /* Frame lost */
     2297                /* Packet lost */
    23442298                fibril_mutex_unlock(&e1000->tx_lock);
    23452299                return;
    … …  
    23702324       
    23712325        tdt++;
    2372         if (tdt == E1000_TX_FRAME_COUNT)
     2326        if (tdt == E1000_TX_PACKETS_COUNT)
    23732327                tdt = 0;
    23742328       
Note: See TracChangeset for help on using the changeset viewer.