Changes in uspace/lib/nic/src/nic_driver.c [ea788701:6d8455d] in mainline

File:

• uspace/lib/nic/src/nic_driver.c (modified) (14 diffs)

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);
+}
+
 /** @}
  */