Changes in / [3fe58d3c:7943c43] in mainline

Files:

• boot/grub.pc/stage2_eltorito (added)
• uspace/drv/nic/e1k/e1k.c (modified) (35 diffs)
• uspace/drv/nic/e1k/e1k.h (modified) (2 diffs)
• uspace/drv/nic/lo/lo.c (modified) (2 diffs)
• uspace/drv/nic/ne2k/dp8390.c (modified) (7 diffs)
• uspace/drv/nic/ne2k/dp8390.h (modified) (1 diff)
• uspace/drv/nic/ne2k/ne2k.c (modified) (1 diff)
• uspace/drv/nic/rtl8139/defs.h (modified) (11 diffs)
• uspace/drv/nic/rtl8139/driver.c (modified) (30 diffs)
• uspace/drv/nic/rtl8139/driver.h (modified) (3 diffs)
• uspace/lib/net/include/nil_remote.h (modified) (2 diffs)
• uspace/lib/net/nil/nil_remote.c (modified) (1 diff)
• uspace/lib/nic/include/nic.h (modified) (7 diffs)
• uspace/lib/nic/include/nic_rx_control.h (modified) (2 diffs)
• uspace/lib/nic/src/nic_driver.c (modified) (14 diffs)
• uspace/lib/nic/src/nic_rx_control.c (modified) (2 diffs)
• uspace/srv/hid/input/include/sun.h (added)
• uspace/srv/hid/input/port/dummy.c (added)
• uspace/srv/hid/input/port/sgcn.c (added)
• uspace/srv/hid/input/port/sun.c (added)
• uspace/srv/hid/input/port/z8530.c (added)
• uspace/srv/net/nil/eth/eth.c (modified) (2 diffs)
• uspace/srv/net/nil/nildummy/nildummy.c (modified) (2 diffs)

uspace/drv/nic/e1k/e1k.c

@@ -52 +52 @@
 #include <nil_remote.h>
 #include <ops/nic.h>
+#include <packet_client.h>
+#include <packet_remote.h>
+#include <net/packet_header.h>
 #include "e1k.h"
 
@@ -59 +62 @@
 
 /* Must be power of 8 */
-#define E1000_RX_FRAME_COUNT  128
-#define E1000_TX_FRAME_COUNT  128
+#define E1000_RX_PACKETS_COUNT  128
+#define E1000_TX_PACKETS_COUNT  128
 
 #define E1000_RECEIVE_ADDRESS  16
 
-/** Maximum sending frame size */
+/** Maximum sending packet size */
 #define E1000_MAX_SEND_FRAME_SIZE  2048
-/** Maximum receiving frame size */
-#define E1000_MAX_RECEIVE_FRAME_SIZE  2048
+/** Maximum receiving packet size */
+#define E1000_MAX_RECEIVE_PACKET_SIZE  2048
 
 /** nic_driver_data_t* -> e1000_t* cast */
@@ -134 +137 @@
         void *rx_ring_virt;
         
-        /** Ring of RX frames, physical address */
-        void **rx_frame_phys;
-        /** Ring of RX frames, virtual address */
-        void **rx_frame_virt;
+        /** Packets in rx ring  */
+        packet_t **rx_ring_packets;
         
         /** VLAN tag */
         uint16_t vlan_tag;
         
-        /** Add VLAN tag to frame */
+        /** Add VLAN tag to packet */
         bool vlan_tag_add;
         
@@ -476 +477 @@
 }
 
-/** Get state of acceptance of weird frames
+/** Get state of acceptance of weird packets
  *
  * @param      device Device to check
@@ -494 +495 @@
 };
 
-/** Set acceptance of weird frames
+/** Set acceptance of weird packets
  *
  * @param device Device to update
@@ -678 +679 @@
 }
 
-/** Disable receiving frames for default address
+/** Disable receiving packets for default address
  *
  * @param e1000 E1000 data structure
@@ -690 +691 @@
 }
 
-/** Enable receiving frames for default address
+/** Enable receiving packets for default address
  *
  * @param e1000 E1000 data structure
@@ -750 +751 @@
 }
 
-/** Enable accepting of broadcast frames
+/** Enable accepting of broadcast packets
  *
  * @param e1000 E1000 data structure
@@ -762 +763 @@
 }
 
-/** Disable accepting of broadcast frames
+/** Disable accepting of broadcast packets
  *
  * @param e1000 E1000 data structure
@@ -798 +799 @@
 }
 
-/** Set multicast frames acceptance mode
+/** Set multicast packets acceptance mode
  *
  * @param nic      NIC device to update
@@ -852 +853 @@
 }
 
-/** Set unicast frames acceptance mode
+/** Set unicast packets acceptance mode
  *
  * @param nic      NIC device to update
@@ -910 +911 @@
 }
 
-/** Set broadcast frames acceptance mode
+/** Set broadcast packets acceptance mode
  *
  * @param nic  NIC device to update
@@ -995 +996 @@
         if (vlan_mask) {
                 /*
-                 * Disable receiving, so that frame matching
+                 * Disable receiving, so that packet matching
                  * partially written VLAN is not received.
                  */
@@ -1062 +1063 @@
 }
 
-/** Fill receive descriptor with new empty buffer
- *
- * Store frame in e1000->rx_frame_phys
+/** Fill receive descriptor with new empty packet
+ *
+ * Store packet in e1000->rx_ring_packets
  *
  * @param nic    NIC data stricture
@@ -1073 +1074 @@
 {
         e1000_t *e1000 = DRIVER_DATA_NIC(nic);
-        
+        packet_t *packet =
+            nic_alloc_packet(nic, E1000_MAX_RECEIVE_PACKET_SIZE);
+        
+        assert(packet);
+        
+        *(e1000->rx_ring_packets + offset) = packet;
         e1000_rx_descriptor_t *rx_descriptor = (e1000_rx_descriptor_t *)
             (e1000->rx_ring_virt + offset * sizeof(e1000_rx_descriptor_t));
         
-        rx_descriptor->phys_addr = PTR_TO_U64(e1000->rx_frame_phys[offset]);
+        void *phys;
+        int rc =
+            nic_dma_lock_packet(packet, E1000_MAX_RECEIVE_PACKET_SIZE, &phys);
+        
+        if (rc == EOK)
+                rx_descriptor->phys_addr = PTR_TO_U64(phys + packet->data_start);
+        else
+                rx_descriptor->phys_addr = 0;
+        
         rx_descriptor->length = 0;
         rx_descriptor->checksum = 0;
@@ -1141 +1155 @@
 }
 
-/** Receive frames
+/** Receive packets
  *
  * @param nic NIC data
  *
  */
-static void e1000_receive_frames(nic_t *nic)
+static void e1000_receive_packets(nic_t *nic)
 {
         e1000_t *e1000 = DRIVER_DATA_NIC(nic);
@@ -1153 +1167 @@
         
         uint32_t *tail_addr = E1000_REG_ADDR(e1000, E1000_RDT);
-        uint32_t next_tail = e1000_inc_tail(*tail_addr, E1000_RX_FRAME_COUNT);
+        uint32_t next_tail = e1000_inc_tail(*tail_addr, E1000_RX_PACKETS_COUNT);
         
         e1000_rx_descriptor_t *rx_descriptor = (e1000_rx_descriptor_t *)
@@ -1159 +1173 @@
         
         while (rx_descriptor->status & 0x01) {
-                uint32_t frame_size = rx_descriptor->length - E1000_CRC_SIZE;
+                uint32_t packet_size = rx_descriptor->length - E1000_CRC_SIZE;
                 
-                nic_frame_t *frame = nic_alloc_frame(nic, frame_size);
-                if (frame != NULL) {
-                        memcpy(frame->data, e1000->rx_frame_virt[next_tail], frame_size);
-                        nic_received_frame(nic, frame);
-                } else {
-                        ddf_msg(LVL_ERROR, "Memory allocation failed. Frame dropped.");
-                }
+                packet_t *packet = *(e1000->rx_ring_packets + next_tail);
+                packet_suffix(packet, packet_size);
+                
+                nic_dma_unlock_packet(packet, E1000_MAX_RECEIVE_PACKET_SIZE);
+                nic_received_packet(nic, packet);
                 
                 e1000_fill_new_rx_descriptor(nic, next_tail);
                 
-                *tail_addr = e1000_inc_tail(*tail_addr, E1000_RX_FRAME_COUNT);
-                next_tail = e1000_inc_tail(*tail_addr, E1000_RX_FRAME_COUNT);
+                *tail_addr = e1000_inc_tail(*tail_addr, E1000_RX_PACKETS_COUNT);
+                next_tail = e1000_inc_tail(*tail_addr, E1000_RX_PACKETS_COUNT);
                 
                 rx_descriptor = (e1000_rx_descriptor_t *)
@@ -1213 +1225 @@
 {
         if (icr & ICR_RXT0)
-                e1000_receive_frames(nic);
+                e1000_receive_packets(nic);
 }
 
@@ -1262 +1274 @@
 }
 
-/** Force receiving all frames in the receive buffer
+/** Force receiving all packets in the receive buffer
  *
  * @param nic NIC data
@@ -1335 +1347 @@
 static void e1000_initialize_rx_registers(e1000_t *e1000)
 {
-        E1000_REG_WRITE(e1000, E1000_RDLEN, E1000_RX_FRAME_COUNT * 16);
+        E1000_REG_WRITE(e1000, E1000_RDLEN, E1000_RX_PACKETS_COUNT * 16);
         E1000_REG_WRITE(e1000, E1000_RDH, 0);
         
         /* It is not posible to let HW use all descriptors */
-        E1000_REG_WRITE(e1000, E1000_RDT, E1000_RX_FRAME_COUNT - 1);
+        E1000_REG_WRITE(e1000, E1000_RDT, E1000_RX_PACKETS_COUNT - 1);
         
         /* Set Broadcast Enable Bit */
@@ -1359 +1371 @@
         
         int rc = dmamem_map_anonymous(
-            E1000_RX_FRAME_COUNT * sizeof(e1000_rx_descriptor_t),
+            E1000_RX_PACKETS_COUNT * sizeof(e1000_rx_descriptor_t),
             AS_AREA_READ | AS_AREA_WRITE, 0, &e1000->rx_ring_phys,
             &e1000->rx_ring_virt);
@@ -1370 +1382 @@
             (uint32_t) PTR_TO_U64(e1000->rx_ring_phys));
         
-        e1000->rx_frame_phys =
-            calloc(E1000_RX_FRAME_COUNT, sizeof(void *));
-        e1000->rx_frame_virt =
-            calloc(E1000_RX_FRAME_COUNT, sizeof(void *));
-        if (e1000->rx_frame_phys == NULL || e1000->rx_frame_virt == NULL) {
-                rc = ENOMEM;
-                goto error;
-        }
-        
-        size_t i;
-        void *frame_virt;
-        void *frame_phys;
-        
-        for (i = 0; i < E1000_RX_FRAME_COUNT; i++) {
-                rc = dmamem_map_anonymous(
-                    E1000_MAX_SEND_FRAME_SIZE, AS_AREA_READ | AS_AREA_WRITE,
-                    0, &frame_phys, &frame_virt);
-                if (rc != EOK)
-                        goto error;
-                
-                e1000->rx_frame_virt[i] = frame_virt;
-                e1000->rx_frame_phys[i] = frame_phys;
-        }
+        e1000->rx_ring_packets =
+            malloc(E1000_RX_PACKETS_COUNT * sizeof(packet_t *));
+        // FIXME: Check return value
         
         /* Write descriptor */
-        for (i = 0; i < E1000_RX_FRAME_COUNT; i++)
-                e1000_fill_new_rx_descriptor(nic, i);
+        for (unsigned int offset = 0;
+            offset < E1000_RX_PACKETS_COUNT;
+            offset++)
+                e1000_fill_new_rx_descriptor(nic, offset);
         
         e1000_initialize_rx_registers(e1000);
@@ -1402 +1396 @@
         fibril_mutex_unlock(&e1000->rx_lock);
         return EOK;
-error:
-        for (i = 0; i < E1000_RX_FRAME_COUNT; i++) {
-                if (e1000->rx_frame_virt[i] != NULL) {
-                        dmamem_unmap_anonymous(e1000->rx_frame_virt[i]);
-                        e1000->rx_frame_virt[i] = NULL;
-                        e1000->rx_frame_phys[i] = NULL;
-                }
-        }
-        if (e1000->rx_frame_phys != NULL) {
-                free(e1000->rx_frame_phys);
-                e1000->rx_frame_phys = NULL;
-        }
-        if (e1000->rx_frame_virt != NULL) {
-                free(e1000->rx_frame_virt);
-                e1000->rx_frame_phys = NULL;
-        }
-        return rc;
 }
 
@@ -1430 +1407 @@
         e1000_t *e1000 = DRIVER_DATA_NIC(nic);
         
-        /* Write descriptor */
-        for (unsigned int offset = 0; offset < E1000_RX_FRAME_COUNT; offset++) {
-                dmamem_unmap_anonymous(e1000->rx_frame_virt[offset]);
-                e1000->rx_frame_virt[offset] = NULL;
-                e1000->rx_frame_phys[offset] = NULL;
-        }
-        
-        free(e1000->rx_frame_virt);
-        free(e1000->rx_frame_phys);
-        e1000->rx_frame_virt = NULL;
-        e1000->rx_frame_phys = NULL;
-        dmamem_unmap_anonymous(e1000->rx_ring_virt);
-}
-
-/** Clear receive descriptor ring
- *
- * @param e1000 E1000 data
- *
- */
-static void e1000_clear_rx_ring(e1000_t *e1000)
-{
         /* Write descriptor */
         for (unsigned int offset = 0;
-            offset < E1000_RX_FRAME_COUNT;
+            offset < E1000_RX_PACKETS_COUNT;
+            offset++) {
+                packet_t *packet = *(e1000->rx_ring_packets + offset);
+                nic_dma_unlock_packet(packet, E1000_MAX_RECEIVE_PACKET_SIZE);
+                nic_release_packet(nic, packet);
+        }
+        
+        free(e1000->rx_ring_packets);
+        dmamem_unmap_anonymous(e1000->rx_ring_virt);
+}
+
+/** Clear receive descriptor ring
+ *
+ * @param e1000 E1000 data
+ *
+ */
+static void e1000_clear_rx_ring(e1000_t *e1000)
+{
+        /* Write descriptor */
+        for (unsigned int offset = 0;
+            offset < E1000_RX_PACKETS_COUNT;
             offset++)
                 e1000_clear_rx_descriptor(e1000, offset);
@@ -1522 +1498 @@
 static void e1000_initialize_tx_registers(e1000_t *e1000)
 {
-        E1000_REG_WRITE(e1000, E1000_TDLEN, E1000_TX_FRAME_COUNT * 16);
+        E1000_REG_WRITE(e1000, E1000_TDLEN, E1000_TX_PACKETS_COUNT * 16);
         E1000_REG_WRITE(e1000, E1000_TDH, 0);
         E1000_REG_WRITE(e1000, E1000_TDT, 0);
@@ -1554 +1530 @@
         
         int rc = dmamem_map_anonymous(
-            E1000_TX_FRAME_COUNT * sizeof(e1000_tx_descriptor_t),
+            E1000_TX_PACKETS_COUNT * sizeof(e1000_tx_descriptor_t),
             AS_AREA_READ | AS_AREA_WRITE, 0, &e1000->tx_ring_phys,
             &e1000->tx_ring_virt);
@@ -1561 +1537 @@
         
         bzero(e1000->tx_ring_virt,
-            E1000_TX_FRAME_COUNT * sizeof(e1000_tx_descriptor_t));
-        
-        e1000->tx_frame_phys = calloc(E1000_TX_FRAME_COUNT, sizeof(void *));
-        e1000->tx_frame_virt = calloc(E1000_TX_FRAME_COUNT, sizeof(void *));
+            E1000_TX_PACKETS_COUNT * sizeof(e1000_tx_descriptor_t));
+        
+        e1000->tx_frame_phys = calloc(E1000_TX_PACKETS_COUNT, sizeof(void *));
+        e1000->tx_frame_virt = calloc(E1000_TX_PACKETS_COUNT, sizeof(void *));
 
         if (e1000->tx_frame_phys == NULL || e1000->tx_frame_virt == NULL) {
@@ -1571 +1547 @@
         }
         
-        for (i = 0; i < E1000_TX_FRAME_COUNT; i++) {
+        for (i = 0; i < E1000_TX_PACKETS_COUNT; i++) {
                 rc = dmamem_map_anonymous(
                     E1000_MAX_SEND_FRAME_SIZE, AS_AREA_READ | AS_AREA_WRITE,
@@ -1596 +1572 @@
         
         if (e1000->tx_frame_phys != NULL && e1000->tx_frame_virt != NULL) {
-                for (i = 0; i < E1000_TX_FRAME_COUNT; i++) {
+                for (i = 0; i < E1000_TX_PACKETS_COUNT; i++) {
                         if (e1000->tx_frame_virt[i] != NULL) {
                                 dmamem_unmap_anonymous(e1000->tx_frame_virt[i]);
@@ -1627 +1603 @@
         size_t i;
         
-        for (i = 0; i < E1000_TX_FRAME_COUNT; i++) {
+        for (i = 0; i < E1000_TX_PACKETS_COUNT; i++) {
                 dmamem_unmap_anonymous(e1000->tx_frame_virt[i]);
                 e1000->tx_frame_virt[i] = NULL;
@@ -1654 +1630 @@
         /* Write descriptor */
         for (unsigned int offset = 0;
-            offset < E1000_TX_FRAME_COUNT;
+            offset < E1000_TX_PACKETS_COUNT;
             offset++)
                 e1000_clear_tx_descriptor(nic, offset);
@@ -1711 +1687 @@
 }
 
-/** Activate the device to receive and transmit frames
+/** Activate the device to receive and transmit packets
  *
  * @param nic NIC driver data
@@ -2307 +2283 @@
         
         if (!descriptor_available) {
-                /* Frame lost */
+                /* Packet lost */
                 fibril_mutex_unlock(&e1000->tx_lock);
                 return;
@@ -2336 +2312 @@
         
         tdt++;
-        if (tdt == E1000_TX_FRAME_COUNT)
+        if (tdt == E1000_TX_PACKETS_COUNT)
                 tdt = 0;
         

uspace/drv/nic/e1k/e1k.h

@@ -39 +39 @@
 #include <stdint.h>
 
-/** Ethernet CRC size after frame received in rx_descriptor */
+/** Ethernet CRC size after packet received in rx_descriptor */
 #define E1000_CRC_SIZE  4
 
@@ -109 +109 @@
 /** Transmit descriptor COMMAND field bits */
 typedef enum {
-        TXDESCRIPTOR_COMMAND_VLE = (1 << 6),   /**< VLAN frame Enable */
+        TXDESCRIPTOR_COMMAND_VLE = (1 << 6),   /**< VLAN Packet Enable */
         TXDESCRIPTOR_COMMAND_RS = (1 << 3),    /**< Report Status */
         TXDESCRIPTOR_COMMAND_IFCS = (1 << 1),  /**< Insert FCS */

uspace/drv/nic/lo/lo.c

@@ -42 +42 @@
 #include <async.h>
 #include <nic.h>
+#include <packet_client.h>
 
 #define NAME  "lo"
@@ -60 +61 @@
 static void lo_send_frame(nic_t *nic_data, void *data, size_t size)
 {
+        packet_t *packet;
+        int rc;
+
+        packet = nic_alloc_packet(nic_data, size);
+        if (packet == NULL)
+                return;
+
+        rc = packet_copy_data(packet, data, size);
+        if (rc != EOK)
+                return;
+
         nic_report_send_ok(nic_data, 1, size);
-        nic_received_noneth_frame(nic_data, data, size);
+        nic_received_noneth_packet(nic_data, packet);
 }
 

uspace/drv/nic/ne2k/dp8390.c

@@ -59 +59 @@
 #include <stdio.h>
 #include <libarch/ddi.h>
+#include <net/packet.h>
+#include <packet_client.h>
 #include "dp8390.h"
 
@@ -74 +76 @@
         uint8_t status;
         
-        /** Pointer to next frame */
+        /** Pointer to next packet */
         uint8_t next;
         
@@ -391 +393 @@
         /*
          * Reset the transmit ring. If we were transmitting a frame,
-         * we pretend that the frame is processed. Higher layers will
-         * retransmit if the frame wasn't actually sent.
+         * we pretend that the packet is processed. Higher layers will
+         * retransmit if the packet wasn't actually sent.
          */
         ne2k->sq.dirty = false;
@@ -446 +448 @@
                 return NULL;
         
-        bzero(frame->data, length);
+        void *buf = packet_suffix(frame->packet, length);
+        bzero(buf, length);
         uint8_t last = page + length / DP_PAGE;
         
@@ -452 +455 @@
                 size_t left = (ne2k->stop_page - page) * DP_PAGE
                     - sizeof(recv_header_t);
-                ne2k_download(ne2k, frame->data, page * DP_PAGE + sizeof(recv_header_t),
+                ne2k_download(ne2k, buf, page * DP_PAGE + sizeof(recv_header_t),
                     left);
-                ne2k_download(ne2k, frame->data + left, ne2k->start_page * DP_PAGE,
+                ne2k_download(ne2k, buf + left, ne2k->start_page * DP_PAGE,
                     length - left);
         } else {
-                ne2k_download(ne2k, frame->data, page * DP_PAGE + sizeof(recv_header_t),
+                ne2k_download(ne2k, buf, page * DP_PAGE + sizeof(recv_header_t),
                     length);
         }
@@ -538 +541 @@
                  * Update the boundary pointer
                  * to the value of the page
-                 * prior to the next frame to
+                 * prior to the next packet to
                  * be processed.
                  */
@@ -581 +584 @@
                 fibril_mutex_lock(&ne2k->sq_mutex);
                 if (ne2k->sq.dirty) {
-                        /* Prepare the buffer for next frame */
+                        /* Prepare the buffer for next packet */
                         ne2k->sq.dirty = false;
                         ne2k->sq.size = 0;

uspace/drv/nic/ne2k/dp8390.h

@@ -264 +264 @@
 extern void ne2k_send(nic_t *, void *, size_t);
 extern void ne2k_interrupt(nic_t *, uint8_t, uint8_t);
+extern packet_t *ne2k_alloc_packet(nic_t *, size_t);
 
 extern void ne2k_set_accept_mcast(ne2k_t *, int);

uspace/drv/nic/ne2k/ne2k.c

@@ -261 +261 @@
         /* Note: some frame with previous physical address may slip to NIL here
          * (for a moment the filtering is not exact), but ethernet should be OK with
-         * that. Some frames may also be lost, but this is not a problem.
+         * that. Some packet may also be lost, but this is not a problem.
          */
         ne2k_set_physical_address((ne2k_t *) nic_get_specific(nic_data), address);

uspace/drv/nic/rtl8139/defs.h

@@ -42 +42 @@
 #define RTL8139_IO_SIZE 256
 
-/** The maximal transmitted frame length in bytes allowed according to RTL8139
+/** The maximal transmitted packet length in bytes allowed according to RTL8139
  *  documentation (see SIZE part of TSD documentation)
  */
-#define RTL8139_FRAME_MAX_LENGTH 1792
+#define RTL8139_PACKET_MAX_LENGTH 1792
 
 
@@ -94 +94 @@
 
         CR      = 0x37,  /**< Command register, 1b */
-        CAPR    = 0x38,  /**< Current address of frame read, 2b */
+        CAPR    = 0x38,  /**< Current address of packet read, 2b */
         CBA     = 0x3a,  /**< Current buffer address, 2b */
 
@@ -282 +282 @@
         RCR_MulERINT = 1 << 17,    /**< Multiple early interrupt select */
 
-        /** Minimal error frame length (1 = 8B, 0 = 64B). If AER/AR is set, RER8
+        /** Minimal error packet length (1 = 8B, 0 = 64B). If AER/AR is set, RER8
          * is "Don't care"
          */
@@ -302 +302 @@
 
         RCR_WRAP              = 1 << 7,  /**< Rx buffer wrapped */
-        RCR_ACCEPT_ERROR      = 1 << 5,  /**< Accept error frame */
-        RCR_ACCEPT_RUNT       = 1 << 4,  /**< Accept Runt (8-64 bytes) frames */
+        RCR_ACCEPT_ERROR      = 1 << 5,  /**< Accept error packet */
+        RCR_ACCEPT_RUNT       = 1 << 4,  /**< Accept Runt (8-64 bytes) packets */
         RCR_ACCEPT_BROADCAST  = 1 << 3,  /**< Accept broadcast */
         RCR_ACCEPT_MULTICAST  = 1 << 2,  /**< Accept multicast */
         RCR_ACCEPT_PHYS_MATCH = 1 << 1,  /**< Accept device MAC address match */
-        RCR_ACCEPT_ALL_PHYS   = 1 << 0,  /**< Accept all frames with 
+        RCR_ACCEPT_ALL_PHYS   = 1 << 0,  /**< Accept all packets with 
                                           * phys. desticnation 
                                                                           */
@@ -362 +362 @@
         ANAR_ACK          = (1 << 14),  /**< Capability reception acknowledge */
         ANAR_REMOTE_FAULT = (1 << 13),  /**< Remote fault detection capability */
-        ANAR_PAUSE        = (1 << 10),  /**< Symetric pause frame capability */
+        ANAR_PAUSE        = (1 << 10),  /**< Symetric pause packet capability */
         ANAR_100T4        = (1 << 9),   /**< T4, not supported by the device */
         ANAR_100TX_FD     = (1 << 8),   /**< 100BASE_TX full duplex */
@@ -399 +399 @@
         CONFIG3_GNT_SELECT = (1 << 7),  /**< Gnt select */
         CONFIG3_PARM_EN    = (1 << 6),  /**< Parameter enabled (100MBit mode) */
-        CONFIG3_MAGIC      = (1 << 5),  /**< WoL Magic frame enable */
+        CONFIG3_MAGIC      = (1 << 5),  /**< WoL Magic packet enable */
         CONFIG3_LINK_UP    = (1 << 4),  /**< Wakeup if link is reestablished */
         CONFIG3_CLKRUN_EN  = (1 << 2),  /**< CLKRUN enabled */ /* TODO: check what does it mean */
@@ -416 +416 @@
 };
 
-/** Maximal runt frame size + 1 */
+/** Maximal runt packet size + 1 */
 #define RTL8139_RUNT_MAX_SIZE 64
 
-/** Bits in frame header */
-enum rtl8139_frame_header {
+/** Bits in packet header */
+enum rtl8139_packet_header {
         RSR_MAR  = (1 << 15),  /**< Multicast received */
         RSR_PAM  = (1 << 14),  /**< Physical address match */
@@ -426 +426 @@
 
         RSR_ISE  = (1 << 5),   /**< Invalid symbol error, 100BASE-TX only */
-        RSR_RUNT = (1 << 4),   /**< Runt frame (< RTL8139_RUNT_MAX_SIZE bytes) */
-
-        RSR_LONG = (1 << 3),   /**< Long frame (size > 4k bytes) */
+        RSR_RUNT = (1 << 4),   /**< Runt packet (< RTL8139_RUNT_MAX_SIZE bytes) */
+
+        RSR_LONG = (1 << 3),   /**< Long packet (size > 4k bytes) */
         RSR_CRC  = (1 << 2),   /**< CRC error */
         RSR_FAE  = (1 << 1),   /**< Frame alignment error */
-        RSR_ROK  = (1 << 0)    /**< Good frame received */
+        RSR_ROK  = (1 << 0)    /**< Good packet received */
 };
 
@@ -451 +451 @@
                                                                           */
 
-        APPEND_CRC = 1 << 16,        /**< Append CRC at the end of a frame */
+        APPEND_CRC = 1 << 16,        /**< Append CRC at the end of a packet */
 
         MXTxDMA_SHIFT = 8,  /**< Max. DMA Burst per TxDMA shift, burst = 16^value */
@@ -459 +459 @@
         TX_RETRY_COUNT_SIZE  = 4,            /**< Retries before aborting size */
 
-        CLEAR_ABORT = 1 << 0    /**< Retransmit aborted frame at the last 
+        CLEAR_ABORT = 1 << 0    /**< Retransmit aborted packet at the last 
                                   *  transmitted descriptor 
                                                           */
@@ -478 +478 @@
 extern const struct rtl8139_hwver_map rtl8139_versions[RTL8139_VER_COUNT + 1];
 
-/** Size in the frame header while copying from RxFIFO to Rx buffer */
+/** Size in the packet header while copying from RxFIFO to Rx buffer */
 #define RTL8139_EARLY_SIZE UINT16_C(0xfff0)
-/** The only supported pause frame time value */
+/** The only supported pause packet time value */
 #define RTL8139_PAUSE_VAL UINT16_C(0xFFFF)
 
-/** Size of the frame header in front of the received frame */
-#define RTL_FRAME_HEADER_SIZE 4
+/** Size of the packet header in front of the received frame */
+#define RTL_PACKET_HEADER_SIZE 4
 
 /** 8k buffer */

uspace/drv/nic/rtl8139/driver.c

@@ -39 +39 @@
 #include <io/log.h>
 #include <nic.h>
+#include <packet_client.h>
 #include <device/pci.h>
 
@@ -151 +152 @@
 }
 
-/** Update the mask of accepted frames in the RCR register according to
+/** Update the mask of accepted packets in the RCR register according to
  * rcr_accept_mode value in rtl8139_t
  *
@@ -169 +170 @@
 }
 
-/** Fill the mask of accepted multicast frames in the card registers
+/** Fill the mask of accepted multicast packets in the card registers
  *
  *  @param rtl8139  The rtl8139 private data
@@ -393 +394 @@
 #define rtl8139_tbuf_busy(tsd) ((pio_read_32(tsd) & TSD_OWN) == 0)
 
-/** Send frame with the hardware
+/** Send packet with the hardware
  *
  * note: the main_lock is locked when framework calls this function
@@ -411 +412 @@
         ddf_msg(LVL_DEBUG, "Sending frame");
 
-        if (size > RTL8139_FRAME_MAX_LENGTH) {
+        if (size > RTL8139_PACKET_MAX_LENGTH) {
                 ddf_msg(LVL_ERROR, "Send frame: frame too long, %zu bytes",
                     size);
@@ -436 +437 @@
         fibril_mutex_unlock(&rtl8139->tx_lock);
 
-        /* Get address of the buffer descriptor and frame data */
+        /* Get address of the buffer descriptor and packet data */
         void *tsd = rtl8139->io_port + TSD0 + tx_curr * 4;
         void *buf_addr = rtl8139->tx_buff[tx_curr];
@@ -504 +505 @@
 }
 
-/** Create frame structure from the buffer data
+/** Create packet structure from the buffer data
  *
  * @param nic_data      NIC driver data
  * @param rx_buffer     The receiver buffer
  * @param rx_size       The buffer size
- * @param frame_start   The offset where packet data start
- * @param frame_size    The size of the frame data
- *
- * @return The frame list node (not connected)
- */
-static nic_frame_t *rtl8139_read_frame(nic_t *nic_data,
-    void *rx_buffer, size_t rx_size, size_t frame_start, size_t frame_size)
-{
-        nic_frame_t *frame = nic_alloc_frame(nic_data, frame_size);
+ * @param packet_start  The offset where packet data start
+ * @param packet_size   The size of the packet data
+ *
+ * @return The packet   list node (not connected)
+ */
+static nic_frame_t *rtl8139_read_packet(nic_t *nic_data,
+    void *rx_buffer, size_t rx_size, size_t packet_start, size_t packet_size)
+{
+        nic_frame_t *frame = nic_alloc_frame(nic_data, packet_size);
         if (! frame) {
-                ddf_msg(LVL_ERROR, "Can not allocate frame for received frame.");
+                ddf_msg(LVL_ERROR, "Can not allocate frame for received packet.");
                 return NULL;
         }
 
-        void *ret = rtl8139_memcpy_wrapped(frame->data, rx_buffer, frame_start,
-            RxBUF_SIZE, frame_size);
+        void *packet_data = packet_suffix(frame->packet, packet_size);
+        if (!packet_data) {
+                ddf_msg(LVL_ERROR, "Can not get the packet suffix.");
+                nic_release_frame(nic_data, frame);
+                return NULL;
+        }
+
+        void *ret = rtl8139_memcpy_wrapped(packet_data, rx_buffer, packet_start,
+            RxBUF_SIZE, packet_size);
         if (ret == NULL) {
                 nic_release_frame(nic_data, frame);
@@ -560 +568 @@
 }
 
-/** Receive all frames in queue
+/** Receive all packets in queue
  *
  *  @param nic_data  The controller data
- *  @return The linked list of nic_frame_list_t nodes, each containing one frame
- */
-static nic_frame_list_t *rtl8139_frame_receive(nic_t *nic_data)
+ *  @return The linked list of packet_list_t nodes, each containing one packet
+ */
+static nic_frame_list_t *rtl8139_packet_receive(nic_t *nic_data)
 {
         rtl8139_t *rtl8139 = nic_get_specific(nic_data);
@@ -573 +581 @@
         nic_frame_list_t *frames = nic_alloc_frame_list();
         if (!frames)
-                ddf_msg(LVL_ERROR, "Can not allocate frame list for received frames.");
+                ddf_msg(LVL_ERROR, "Can not allocate frame list for received packets.");
 
         void *rx_buffer = rtl8139->rx_buff_virt;
@@ -597 +605 @@
         while (!rtl8139_hw_buffer_empty(rtl8139)) {
                 void *rx_ptr = rx_buffer + rx_offset % RxBUF_SIZE;
-                uint32_t frame_header = uint32_t_le2host( *((uint32_t*)rx_ptr) );
-                uint16_t size = frame_header >> 16;
-                uint16_t frame_size = size - RTL8139_CRC_SIZE;
-                /* received frame flags in frame header */
-                uint16_t rcs = (uint16_t) frame_header;
+                uint32_t packet_header = uint32_t_le2host( *((uint32_t*)rx_ptr) );
+                uint16_t size = packet_header >> 16;
+                uint16_t packet_size = size - RTL8139_CRC_SIZE;
+                /* received packet flags in packet header */
+                uint16_t rcs = (uint16_t) packet_header;
 
                 if (size == RTL8139_EARLY_SIZE) {
-                        /* The frame copying is still in progress, break receiving */
+                        /* The packet copying is still in progress, break receiving */
                         ddf_msg(LVL_DEBUG, "Early threshold reached, not completely coppied");
                         break;
@@ -610 +618 @@
 
                 /* Check if the header is valid, otherwise we are lost in the buffer */
-                if (size == 0 || size > RTL8139_FRAME_MAX_LENGTH) {
+                if (size == 0 || size > RTL8139_PACKET_MAX_LENGTH) {
                         ddf_msg(LVL_ERROR, "Receiver error -> receiver reset (size: %4"PRIu16", "
-                            "header 0x%4"PRIx16". Offset: %zu)", size, frame_header, 
+                            "header 0x%4"PRIx16". Offset: %zu)", size, packet_header, 
                             rx_offset);
                         goto rx_err;
@@ -621 +629 @@
                 }
 
-                cur_read += size + RTL_FRAME_HEADER_SIZE;
+                cur_read += size + RTL_PACKET_HEADER_SIZE;
                 if (cur_read > max_read)
                         break;
 
                 if (frames) {
-                        nic_frame_t *frame = rtl8139_read_frame(nic_data, rx_buffer,
-                            RxBUF_SIZE, rx_offset + RTL_FRAME_HEADER_SIZE, frame_size);
+                        nic_frame_t *frame = rtl8139_read_packet(nic_data, rx_buffer,
+                            RxBUF_SIZE, rx_offset + RTL_PACKET_HEADER_SIZE, packet_size);
 
                         if (frame)
@@ -634 +642 @@
 
                 /* Update offset */
-                rx_offset = ALIGN_UP(rx_offset + size + RTL_FRAME_HEADER_SIZE, 4);
-
-                /* Write lesser value to prevent overflow into unread frame
+                rx_offset = ALIGN_UP(rx_offset + size + RTL_PACKET_HEADER_SIZE, 4);
+
+                /* Write lesser value to prevent overflow into unread packet
                  * (the recomendation from the RealTech rtl8139 programming guide)
                  */
@@ -719 +727 @@
                 tx_used++;
 
-                /* If the frame was sent */
+                /* If the packet was sent */
                 if (tsd_value & TSD_TOK) {
                         size_t size = REG_GET_VAL(tsd_value, TSD_SIZE);
@@ -749 +757 @@
 }
 
-/** Receive all frames from the buffer
+/** Receive all packets from the buffer
  *
  *  @param rtl8139  driver private data
  */
-static void rtl8139_receive_frames(nic_t *nic_data)
+static void rtl8139_receive_packets(nic_t *nic_data)
 {
         assert(nic_data);
@@ -761 +769 @@
 
         fibril_mutex_lock(&rtl8139->rx_lock);
-        nic_frame_list_t *frames = rtl8139_frame_receive(nic_data);
+        nic_frame_list_t *frames = rtl8139_packet_receive(nic_data);
         fibril_mutex_unlock(&rtl8139->rx_lock);
 
@@ -817 +825 @@
         }
 
-        /* Check transmittion interrupts first to allow transmit next frames
+        /* Check transmittion interrupts first to allow transmit next packets
          * sooner
          */
@@ -824 +832 @@
         }
         if (isr & INT_ROK) {
-                rtl8139_receive_frames(nic_data);
+                rtl8139_receive_packets(nic_data);
         }
         if (isr & (INT_RER | INT_RXOVW | INT_FIFOOVW)) {
@@ -925 +933 @@
 }
 
-/** Activate the device to receive and transmit frames
+/** Activate the device to receive and transmit packets
  *
  *  @param nic_data  The nic driver data
@@ -1205 +1213 @@
                 goto failed;
 
-        /* Set default frame acceptance */
+        /* Set default packet acceptance */
         rtl8139->rcr_data.ucast_mask = RTL8139_RCR_UCAST_DEFAULT;
         rtl8139->rcr_data.mcast_mask = RTL8139_RCR_MCAST_DEFAULT;
         rtl8139->rcr_data.bcast_mask = RTL8139_RCR_BCAST_DEFAULT;
         rtl8139->rcr_data.defect_mask = RTL8139_RCR_DEFECT_DEFAULT;
-        /* Set receiver early treshold to 8/16 of frame length */
+        /* Set receiver early treshold to 8/16 of packet length */
         rtl8139->rcr_data.rcr_base = (0x8 << RCR_ERTH_SHIFT);
 
@@ -1469 +1477 @@
 };
 
-/** Check if pause frame operations are valid in current situation 
+/** Check if pause packet operations are valid in current situation 
  *
  *  @param rtl8139  RTL8139 private structure
@@ -1494 +1502 @@
 }
 
-/** Get current pause frame configuration
+/** Get current pause packet configuration
  *
  *  Values are filled with NIC_RESULT_NOT_AVAILABLE if the value has no sense in
@@ -1500 +1508 @@
  *
  *  @param[in]  fun         The DDF structure of the RTL8139
- *  @param[out] we_send     Sign if local constroller sends pause frame
- *  @param[out] we_receive  Sign if local constroller receives pause frame
- *  @param[out] time        Time filled in pause frames. 0xFFFF in rtl8139
+ *  @param[out] we_send     Sign if local constroller sends pause packets
+ *  @param[out] we_receive  Sign if local constroller receives pause packets
+ *  @param[out] time        Time filled in pause packets. 0xFFFF in rtl8139
  *
  *  @return EOK if succeed
@@ -1532 +1540 @@
 };
 
-/** Set current pause frame configuration
+/** Set current pause packet configuration
  *
  *  @param fun            The DDF structure of the RTL8139
- *  @param allow_send     Sign if local constroller sends pause frame
- *  @param allow_receive  Sign if local constroller receives pause frames
+ *  @param allow_send     Sign if local constroller sends pause packets
+ *  @param allow_receive  Sign if local constroller receives pause packets
  *  @param time           Time to use, ignored (not supported by device)
  *
- *  @return EOK if succeed, INVAL if the pause frame has no sence
+ *  @return EOK if succeed, INVAL if the pause packet has no sence
  */
 static int rtl8139_pause_set(ddf_fun_t *fun, int allow_send, int allow_receive, 
@@ -1788 +1796 @@
 }
 
-/** Set unicast frames acceptance mode
+/** Set unicast packets acceptance mode
  *
  *  @param nic_data  The nic device to update
@@ -1846 +1854 @@
 }
 
-/** Set multicast frames acceptance mode
+/** Set multicast packets acceptance mode
  *
  *  @param nic_data  The nic device to update
@@ -1891 +1899 @@
 }
 
-/** Set broadcast frames acceptance mode
+/** Set broadcast packets acceptance mode
  *
  *  @param nic_data  The nic device to update
@@ -1921 +1929 @@
 }
 
-/** Get state of acceptance of weird frames
+/** Get state of acceptance of weird packets
  *
  *  @param[in]  device  The device to check
@@ -1943 +1951 @@
 };
 
-/** Set acceptance of weird frames
+/** Set acceptance of weird packets
  *
  *  @param device  The device to update
@@ -2119 +2127 @@
 }
 
-/** Force receiving all frames in the receive buffer
+/** Force receiving all packets in the receive buffer
  *
  *  @param device  The device to receive

uspace/drv/nic/rtl8139/driver.h

@@ -39 +39 @@
 /** Transmittion buffers count */
 #define TX_BUFF_COUNT 4
-/** Size of buffer for one frame
+/** Size of buffer for one packet
  *  - 2kB
  */
@@ -49 +49 @@
 #define RTL8139_CRC_SIZE 4
 
-/** The default mode of accepting unicast frames */
+/** The default mode of accepting unicast packets */
 #define RTL8139_RCR_UCAST_DEFAULT RCR_ACCEPT_PHYS_MATCH
-/** The default mode of accepting multicast frames */
+/** The default mode of accepting multicast packets */
 #define RTL8139_RCR_MCAST_DEFAULT 0
-/** The default mode of accepting broadcast frames */
+/** The default mode of accepting broadcast packets */
 #define RTL8139_RCR_BCAST_DEFAULT RCR_ACCEPT_BROADCAST
-/** The default mode of accepting defect frames */
+/** The default mode of accepting defect packets */
 #define RTL8139_RCR_DEFECT_DEFAULT 0
 
@@ -112 +112 @@
         size_t tx_used;
 
-        /** Buffer for receiving frames */
+        /** Buffer for receiving packets */
         void *rx_buff_phys;
         void *rx_buff_virt;

uspace/lib/net/include/nil_remote.h

@@ -39 +39 @@
 #include <generic.h>
 #include <async.h>
-#include <sys/types.h>
 
 #define nil_bind_service(service, device_id, me, receiver) \
@@ -62 +61 @@
     size_t);
 extern int nil_device_state_msg(async_sess_t *, nic_device_id_t, sysarg_t);
-extern int nil_received_msg(async_sess_t *, nic_device_id_t, void *, size_t);
+extern int nil_received_msg(async_sess_t *, nic_device_id_t, packet_id_t);
 extern int nil_addr_changed_msg(async_sess_t *, nic_device_id_t,
     const nic_address_t *);

uspace/lib/net/nil/nil_remote.c

@@ -77 +77 @@
  */
 int nil_received_msg(async_sess_t *sess, nic_device_id_t device_id,
-    void *data, size_t size)
+    packet_id_t packet_id)
 {
-        async_exch_t *exch = async_exchange_begin(sess);
-
-        ipc_call_t answer;
-        aid_t req = async_send_1(exch, NET_NIL_RECEIVED, (sysarg_t) device_id,
-            &answer);
-        sysarg_t retval = async_data_write_start(exch, data, size);
-
-        async_exchange_end(exch);
-
-        if (retval != EOK) {
-                async_wait_for(req, NULL);
-                return retval;
-        }
-
-        async_wait_for(req, &retval);
-        return retval;
+        return generic_received_msg_remote(sess, NET_NIL_RECEIVED,
+            device_id, packet_id, 0, 0);
 }
 

uspace/lib/nic/include/nic.h

@@ -42 +42 @@
 #include <ddf/driver.h>
 #include <device/hw_res_parsed.h>
+#include <net/packet.h>
 #include <ops/nic.h>
 
@@ -60 +61 @@
 
 /**
- * Simple structure for sending lists of frames.
+ * Simple structure for sending the allocated frames (packets) in a list.
  */
 typedef struct {
         link_t link;
-        void *data;
-        size_t size;
+        packet_t *packet;
 } nic_frame_t;
 
@@ -71 +71 @@
 
 /**
- * Handler for writing frame data to the NIC device.
- * The function is responsible for releasing the frame.
+ * Handler for writing packet data to the NIC device.
+ * The function is responsible for releasing the packet.
  * It does not return anything, if some error is detected the function just
  * silently fails (logging on debug level is suggested).
@@ -158 +158 @@
  * @return ENOTSUP      If this filter cannot work on this NIC (e.g. the NIC
  *                                      cannot run in promiscuous node or the limit of WOL
- *                                      frames' specifications was reached).
+ *                                      packets' specifications was reached).
  * @return ELIMIT       If this filter must implemented in HW but currently the
  *                                      limit of these HW filters was reached.
@@ -233 +233 @@
 extern int nic_report_poll_mode(nic_t *, nic_poll_mode_t, struct timeval *);
 extern void nic_query_address(nic_t *, nic_address_t *);
-extern void nic_received_noneth_frame(nic_t *, void *, size_t);
+extern void nic_received_packet(nic_t *, packet_t *);
+extern void nic_received_noneth_packet(nic_t *, packet_t *);
 extern void nic_received_frame(nic_t *, nic_frame_t *);
 extern void nic_received_frame_list(nic_t *, nic_frame_list_t *);
@@ -247 +248 @@
 extern void nic_report_collisions(nic_t *, unsigned);
 
-/* Frame / frame list allocation and deallocation */
+/* Packet / frame / frame list allocation and deallocation */
+extern packet_t *nic_alloc_packet(nic_t *, size_t);
+extern void nic_release_packet(nic_t *, packet_t *);
 extern nic_frame_t *nic_alloc_frame(nic_t *, size_t);
 extern nic_frame_list_t *nic_alloc_frame_list(void);
@@ -272 +275 @@
 extern void nic_sw_period_stop(nic_t *);
 
+/* Packet DMA lock */
+extern int nic_dma_lock_packet(packet_t *, size_t, void **);
+extern int nic_dma_unlock_packet(packet_t *, size_t);
+
 #endif // __NIC_H__
 

uspace/lib/nic/include/nic_rx_control.h

@@ -46 +46 @@
 #include <fibril_synch.h>
 #include <net/device.h>
+#include <net/packet_header.h>
 
 #include "nic_addr_db.h"
@@ -119 +120 @@
         const nic_address_t *prev_addr, const nic_address_t *curr_addr);
 extern int nic_rxc_check(const nic_rxc_t *rxc,
-        const void *data, size_t size, nic_frame_type_t *frame_type);
+        const packet_t *packet, nic_frame_type_t *frame_type);
 extern void nic_rxc_hw_filtering(nic_rxc_t *rxc,
         int unicast_exact, int multicast_exact, int vlan_exact);

uspace/lib/nic/src/nic_driver.c

@@ -51 +51 @@
 #include <net_interface.h>
 #include <ops/nic.h>
+#include <packet_client.h>
+#include <packet_remote.h>
+#include <net/packet_header.h>
 #include <errno.h>
 
@@ -61 +64 @@
 
 /**
- * Initializes libraries required for NIC framework - logger
+ * Initializes libraries required for NIC framework - logger, packet manager
  *
  * @param name  Name of the device/driver (used in logging)
@@ -76 +79 @@
         snprintf(buffer, 256, "drv/" DEVICE_CATEGORY_NIC "/%s", name);
         
-        return EOK;
+        /* Initialize packet manager */
+        return pm_init();
 }
 
@@ -158 +162 @@
 
 /**
- * Setup send frame handler. This MUST be called in the add_device handler
+ * Setup write packet handler. This MUST be called in the add_device handler
  * if the nic_send_message_impl function is used for sending messages (filled
  * as send_message member of the nic_iface_t structure). The function must not
@@ -266 +270 @@
 }
 
-/** Allocate frame
+/**
+ * Just a wrapper over the packet_get_1_remote function
+ */
+packet_t *nic_alloc_packet(nic_t *nic_data, size_t data_size)
+{
+        return packet_get_1_remote(nic_data->net_session, data_size);
+}
+
+
+/**
+ * Just a wrapper over the pq_release_remote function
+ */
+void nic_release_packet(nic_t *nic_data, packet_t *packet)
+{
+        pq_release_remote(nic_data->net_session, packet_get_id(packet));
+}
+
+/** Allocate frame and packet
  *
  *  @param nic_data     The NIC driver data
- *  @param size         Frame size in bytes
+ *  @param packet_size  Size of packet
+ *  @param offload_size Size of packet offload
  *  @return pointer to allocated frame if success, NULL otherwise
  */
-nic_frame_t *nic_alloc_frame(nic_t *nic_data, size_t size)
+nic_frame_t *nic_alloc_frame(nic_t *nic_data, size_t packet_size)
 {
         nic_frame_t *frame;
@@ -291 +313 @@
         }
 
-        frame->data = malloc(size);
-        if (frame->data == NULL) {
+        packet_t *packet = nic_alloc_packet(nic_data, packet_size);
+        if (!packet) {
                 free(frame);
                 return NULL;
         }
 
-        frame->size = size;
+        frame->packet = packet;
         return frame;
 }
@@ -310 +332 @@
         if (!frame)
                 return;
-
-        if (frame->data != NULL) {
-                free(frame->data);
-                frame->data = NULL;
-                frame->size = 0;
-        }
-
+        if (frame->packet != NULL) {
+                nic_release_packet(nic_data, frame->packet);
+        }
         fibril_mutex_lock(&nic_globals.lock);
         if (nic_globals.frame_cache_size >= NIC_GLOBALS_MAX_CACHE_SIZE) {
@@ -586 +604 @@
 
 /**
- * The busy flag can be set to 1 only in the send_frame handler, to 0 it can
+ * The busy flag can be set to 1 only in the write_packet handler, to 0 it can
  * be set anywhere.
  *
@@ -595 +613 @@
 {
         /*
-         * When the function is called in send_frame handler the main lock is
+         * When the function is called in write_packet handler the main lock is
          * locked so no race can happen.
          * Otherwise, when it is unexpectedly set to 0 (even with main lock held
@@ -604 +622 @@
 
 /**
- * This is the function that the driver should call when it receives a frame.
- * The frame is checked by filters and then sent up to the NIL layer or
- * discarded. The frame is released.
- *
- * @param nic_data
- * @param frame         The received frame
+ * Provided for correct naming conventions.
+ * The packet is checked by filters and then sent up to the NIL layer or
+ * discarded, the frame is released.
+ *
+ * @param nic_data
+ * @param frame         The frame containing received packet
  */
 void nic_received_frame(nic_t *nic_data, nic_frame_t *frame)
 {
+        nic_received_packet(nic_data, frame->packet);
+        frame->packet = NULL;
+        nic_release_frame(nic_data, frame);
+}
+
+/**
+ * This is the function that the driver should call when it receives a packet.
+ * The packet is checked by filters and then sent up to the NIL layer or
+ * discarded.
+ *
+ * @param nic_data
+ * @param packet                The received packet
+ */
+void nic_received_packet(nic_t *nic_data, packet_t *packet)
+{
         /* Note: this function must not lock main lock, because loopback driver
-         *               calls it inside send_frame handler (with locked main lock) */
+         *               calls it inside write_packet handler (with locked main lock) */
+        packet_id_t pid = packet_get_id(packet);
+        
         fibril_rwlock_read_lock(&nic_data->rxc_lock);
         nic_frame_type_t frame_type;
-        int check = nic_rxc_check(&nic_data->rx_control, frame->data,
-            frame->size, &frame_type);
+        int check = nic_rxc_check(&nic_data->rx_control, packet, &frame_type);
         fibril_rwlock_read_unlock(&nic_data->rxc_lock);
         /* Update statistics */
         fibril_rwlock_write_lock(&nic_data->stats_lock);
-
+        /* Both sending message up and releasing packet are atomic IPC calls */
         if (nic_data->state == NIC_STATE_ACTIVE && check) {
                 nic_data->stats.receive_packets++;
-                nic_data->stats.receive_bytes += frame->size;
+                nic_data->stats.receive_bytes += packet_get_data_length(packet);
                 switch (frame_type) {
                 case NIC_FRAME_MULTICAST:
@@ -637 +671 @@
                 }
                 fibril_rwlock_write_unlock(&nic_data->stats_lock);
-                nil_received_msg(nic_data->nil_session, nic_data->device_id,
-                    frame->data, frame->size);
+                nil_received_msg(nic_data->nil_session, nic_data->device_id, pid);
         } else {
                 switch (frame_type) {
@@ -652 +685 @@
                 }
                 fibril_rwlock_write_unlock(&nic_data->stats_lock);
-        }
-        nic_release_frame(nic_data, frame);
+                nic_release_packet(nic_data, packet);
+        }
 }
 
 /**
  * This function is to be used only in the loopback driver. It's workaround
- * for the situation when the frame does not contain ethernet address.
+ * for the situation when the packet does not contain ethernet address.
  * The filtering is therefore not applied here.
  *
  * @param nic_data
- * @param data          Frame data
- * @param size          Frame size in bytes
- */
-void nic_received_noneth_frame(nic_t *nic_data, void *data, size_t size)
+ * @param packet
+ */
+void nic_received_noneth_packet(nic_t *nic_data, packet_t *packet)
 {
         fibril_rwlock_write_lock(&nic_data->stats_lock);
         nic_data->stats.receive_packets++;
-        nic_data->stats.receive_bytes += size;
+        nic_data->stats.receive_bytes += packet_get_data_length(packet);
         fibril_rwlock_write_unlock(&nic_data->stats_lock);
         
         nil_received_msg(nic_data->nil_session, nic_data->device_id,
-            data, size);
-}
-
-/**
- * Some NICs can receive multiple frames during single interrupt. These can
+            packet_get_id(packet));
+}
+
+/**
+ * Some NICs can receive multiple packets during single interrupt. These can
  * send them in whole list of frames (actually nic_frame_t structures), then
- * the list is deallocated and each frame is passed to the
+ * the list is deallocated and each packet is passed to the
  * nic_received_packet function.
  *
@@ -694 +726 @@
 
                 list_remove(&frame->link);
-                nic_received_frame(nic_data, frame);
+                nic_received_packet(nic_data, frame->packet);
+                frame->packet = NULL;
+                nic_release_frame(nic_data, frame);
         }
         nic_driver_release_frame_list(frames);
@@ -1295 +1329 @@
 }
 
+/** Lock packet for DMA usage
+ *
+ * @param packet
+ * @return physical address of packet
+ */
+int nic_dma_lock_packet(packet_t *packet, size_t size, void **phys)
+{
+        return dmamem_map(packet, SIZE2PAGES(size), 0, 0, phys);
+}
+
+/** Unlock packet after DMA usage
+ *
+ * @param packet
+ */
+int nic_dma_unlock_packet(packet_t *packet, size_t size)
+{
+        return dmamem_unmap(packet, size);
+}
+
 /** @}
  */

uspace/lib/nic/src/nic_rx_control.c

@@ -392 +392 @@
  *
  * @param rxc
- * @param frame     The probed frame
+ * @param packet        The probed frame
  *
  * @return True if the frame passes, false if it does not
  */
-int nic_rxc_check(const nic_rxc_t *rxc, const void *data, size_t size,
+int nic_rxc_check(const nic_rxc_t *rxc, const packet_t *packet,
         nic_frame_type_t *frame_type)
 {
         assert(frame_type != NULL);
-        uint8_t *dest_addr = (uint8_t *) data;
+        uint8_t *dest_addr = (uint8_t *) packet + packet->data_start;
         uint8_t *src_addr = dest_addr + ETH_ADDR;
-
-        if (size < 2 * ETH_ADDR)
-                return false;
 
         if (dest_addr[0] & 1) {
@@ -451 +448 @@
         if (!rxc->vlan_exact && rxc->vlan_mask != NULL) {
                 vlan_header_t *vlan_header = (vlan_header_t *)
-                        ((uint8_t *) data + 2 * ETH_ADDR);
+                        ((uint8_t *) packet + packet->data_start + 2 * ETH_ADDR);
                 if (vlan_header->tpid_upper == VLAN_TPID_UPPER &&
                         vlan_header->tpid_lower == VLAN_TPID_LOWER) {

uspace/srv/net/nil/eth/eth.c

@@ -814 +814 @@
 }
 
-static int eth_received(nic_device_id_t device_id)
-{
-        void *data;
-        size_t size;
-        int rc;
-        
-        rc = async_data_write_accept(&data, false, 0, 0, 0, &size);
-        if (rc != EOK)
-                return rc;
-        
-        packet_t *packet = packet_get_1_remote(eth_globals.net_sess, size);
-        if (packet == NULL)
-                return ENOMEM;
-        
-        void *pdata = packet_suffix(packet, size);
-        memcpy(pdata, data, size);
-        free(data);
-        
-        return nil_received_msg_local(device_id, packet);
-}
-
 static int eth_addr_changed(nic_device_id_t device_id)
 {
@@ -947 +926 @@
                 return EOK;
         case NET_NIL_RECEIVED:
-                rc = eth_received(IPC_GET_ARG1(*call));
+                rc = packet_translate_remote(eth_globals.net_sess, &packet,
+                    IPC_GET_ARG2(*call));
+                if (rc == EOK)
+                        rc = nil_received_msg_local(IPC_GET_ARG1(*call), packet);
+                
                 async_answer_0(callid, (sysarg_t) rc);
                 return rc;

uspace/srv/net/nil/nildummy/nildummy.c

@@ -370 +370 @@
 }
 
-static int nildummy_received(nic_device_id_t device_id)
-{
-        void *data;
-        size_t size;
-        int rc;
-
-        rc = async_data_write_accept(&data, false, 0, 0, 0, &size);
-        if (rc != EOK)
-                return rc;
-
-        packet_t *packet = packet_get_1_remote(nildummy_globals.net_sess, size);
-        if (packet == NULL)
-                return ENOMEM;
-
-        void *pdata = packet_suffix(packet, size);
-        memcpy(pdata, data, size);
-        free(pdata);
-
-        return nil_received_msg_local(device_id, packet);
-}
-
 int nil_module_message(ipc_callid_t callid, ipc_call_t *call,
     ipc_call_t *answer, size_t *answer_count)
@@ -452 +431 @@
         
         case NET_NIL_RECEIVED:
-                rc = nildummy_received(IPC_GET_ARG1(*call));
+                rc = packet_translate_remote(nildummy_globals.net_sess, &packet,
+                    IPC_GET_ARG2(*call));
+                if (rc == EOK)
+                        rc = nil_received_msg_local(IPC_GET_ARG1(*call), packet);
+                
                 async_answer_0(callid, (sysarg_t) rc);
                 return rc;