minix/drivers/net/dpeth/netbuff.c

   1 /*
   2 **  File:       netbuff.c       Jun. 10, 2000
   3 **
   4 **  Author:     Giovanni Falzoni <gfalzoni@inwind.it>
   5 **
   6 **  This file contains specific implementation of buffering
   7 **  for network packets.
   8 */
   9
  10 #include <minix/drivers.h>
  11 #include <minix/netdriver.h>
  12 #include "dp.h"
  13
  14 #if (HAVE_BUFFERS == 1)
  15
  16 static m_hdr_t *allocptr = NULL;
  17 static char tx_rx_buff[8192];
  18
  19 /*
  20 **  Name:       alloc_buff
  21 **  Function:   Allocates a buffer from the common pool.
  22 */
  23 void *alloc_buff(dpeth_t *dep, int size)
  24 {
  25   m_hdr_t *ptr, *wrk = allocptr;
  26   int units = ((size + sizeof(m_hdr_t) - 1) / sizeof(m_hdr_t)) + 1;
  27
  28   for (ptr = wrk->next;; wrk = ptr, ptr = ptr->next) {
  29         if (ptr->size >= units) {
  30                 /* Memory is available, carve requested size from pool */
  31                 if (ptr->size == units) {
  32                         wrk->next = ptr->next;
  33                 } else {
  34                         /* Get memory from top address */
  35                         ptr->size -= units;
  36                         ptr += ptr->size;
  37                         ptr->size = units;
  38                 }
  39                 allocptr = wrk;
  40                 return ptr + 1;
  41         }
  42         if (ptr == allocptr) break;
  43   }
  44   return NULL;                  /* No memory available */
  45 }
  46
  47 /*
  48 **  Name:       free_buff
  49 **  Function:   Returns a buffer to the common pool.
  50 */
  51 void free_buff(dpeth_t *dep, void *blk)
  52 {
  53   m_hdr_t *wrk, *ptr = (m_hdr_t *) blk - 1;
  54
  55   /* Scan linked list for the correct place */
  56   for (wrk = allocptr; !(ptr > wrk && ptr < wrk->next); wrk = wrk->next)
  57         if (wrk >= wrk->next && (ptr > wrk || ptr < wrk->next)) break;
  58
  59   /* Check if adjacent block is free and join blocks */
  60   if (ptr + ptr->size == wrk->next) {
  61         ptr->size += wrk->next->size;
  62         ptr->next = wrk->next->next;
  63   } else
  64         ptr->next = wrk->next;
  65   if (wrk + wrk->size == ptr) {
  66         wrk->size += ptr->size;
  67         wrk->next = ptr->next;
  68   } else
  69         wrk->next = ptr;
  70   allocptr = wrk;               /* Point allocptr to block just released */
  71 }
  72
  73 /*
  74 **  Name:       init_buff
  75 **  Function:   Initalizes driver data structures.
  76 */
  77 void init_buff(dpeth_t *dep, buff_t **tx_buff)
  78 {
  79
  80   /* Initializes buffer pool */
  81   if (allocptr == NULL) {
  82         m_hdr_t *rx = (m_hdr_t *) tx_rx_buff;
  83         rx->next = allocptr = rx;
  84         rx->size = 0;
  85         rx += 1;
  86         rx->next = NULL;
  87         rx->size = (sizeof(tx_rx_buff) / sizeof(m_hdr_t)) - 1;
  88         free_buff(dep, rx + 1);
  89         dep->de_recvq_tail = dep->de_recvq_head = NULL;
  90         if (tx_buff != NULL) {
  91                 *tx_buff = alloc_buff(dep,
  92                     NDEV_ETH_PACKET_MAX + sizeof(buff_t));
  93                 (*tx_buff)->size = 0;
  94         }
  95   }
  96 }
  97
  98 #endif                          /* HAVE_BUFFERS */
  99
 100 /** netbuff.c **/