xref: /titanic_41/usr/src/uts/common/io/e1000g/e1000g_alloc.c (revision f4da9be01648d6afa604495d9b9956dddeb92a8c)

/*
 * This file is provided under a CDDLv1 license.  When using or
 * redistributing this file, you may do so under this license.
 * In redistributing this file this license must be included
 * and no other modification of this header file is permitted.
 *
 * CDDL LICENSE SUMMARY
 *
 * Copyright(c) 1999 - 2007 Intel Corporation. All rights reserved.
 *
 * The contents of this file are subject to the terms of Version
 * 1.0 of the Common Development and Distribution License (the "License").
 *
 * You should have received a copy of the License with this software.
 * You can obtain a copy of the License at
 *	http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 */

/*
 * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms of the CDDLv1.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*
 * **********************************************************************
 * Module Name:								*
 *   e1000galloc.c							*
 *									*
 * Abstract:								*
 *   This file contains some routines that take care of init,		*
 *   uninit, and memory allocation.					*
 *									*
 *									*
 *   This driver runs on the following hardware:			*
 *   - Wiseman based PCI gigabit ethernet adapters			*
 *									*
 * Environment:								*
 *   Kernel Mode -							*
 *									*
 * **********************************************************************
 */

#include "e1000g_sw.h"
#include "e1000g_debug.h"

#define	TX_SW_PKT_AREA_SZ \
	(sizeof (TX_SW_PACKET) * Adapter->NumTxSwPacket)

static int e1000g_alloc_tx_descriptors(e1000g_tx_ring_t *);
static int e1000g_alloc_rx_descriptors(e1000g_rx_ring_t *);
static void e1000g_free_tx_descriptors(e1000g_tx_ring_t *);
static void e1000g_free_rx_descriptors(e1000g_rx_ring_t *);
static int e1000g_alloc_tx_packets(e1000g_tx_ring_t *);
static int e1000g_alloc_rx_packets(e1000g_rx_ring_t *);
static void e1000g_free_tx_packets(e1000g_tx_ring_t *);
static void e1000g_free_rx_packets(e1000g_rx_ring_t *);
static int e1000g_alloc_dma_buffer(struct e1000g *, dma_buffer_t *, size_t);
static void e1000g_free_dma_buffer(dma_buffer_t *);
#ifdef __sparc
static int e1000g_alloc_dvma_buffer(struct e1000g *, dma_buffer_t *, size_t);
static void e1000g_free_dvma_buffer(dma_buffer_t *);
#endif
static int e1000g_alloc_descriptors(struct e1000g *Adapter);
static int e1000g_alloc_packets(struct e1000g *Adapter);
static PRX_SW_PACKET e1000g_alloc_rx_sw_packet(e1000g_rx_ring_t *);

#ifdef __sparc
static ddi_dma_lim_t e1000g_dma_limits = {
	(uint_t)0,		/* dlim_addr_lo */
	(uint_t)0xffffffff,	/* dlim_addr_hi */
	(uint_t)0xffffffff,	/* dlim_cntr_max */
	(uint_t)0xfc00fc,	/* dlim_burstsizes for 32 and 64 bit xfers */
	0x1,			/* dlim_minxfer */
	1024			/* dlim_speed */
};
#endif

#ifdef __sparc
static dma_type_t e1000g_dma_type = USE_DVMA;
#else
static dma_type_t e1000g_dma_type = USE_DMA;
#endif

extern krwlock_t e1000g_dma_type_lock;

int
e1000g_alloc_dma_resources(struct e1000g *Adapter)
{
	e1000g_tx_ring_t *tx_ring;
	e1000g_rx_ring_t *rx_ring;

	tx_ring = Adapter->tx_ring;
	rx_ring = Adapter->rx_ring;

	if (e1000g_alloc_descriptors(Adapter) != DDI_SUCCESS)
		return (DDI_FAILURE);

	if (e1000g_alloc_packets(Adapter) != DDI_SUCCESS) {
		e1000g_free_tx_descriptors(tx_ring);
		e1000g_free_rx_descriptors(rx_ring);
		return (DDI_FAILURE);
	}

	return (DDI_SUCCESS);
}

/*
 * **********************************************************************
 * Name:	e1000g_alloc_descriptors				*
 *									*
 * Description:								*
 *     This routine Allocates Neccesary Buffers for the device		*
 *     It allocates memory for						*
 *	 Transmit Descriptor Area					*
 *	 Receive Descrpitor Area					*
 *									*
 *     NOTE -- The device must have been reset before this routine	*
 *		      is called.					*
 *									*
 * Author:	       Hari Seshadri					*
 * Functions Called :							*
 *		       DDI mem functions called				*
 *     ddi_dma_alloc_handle() allocates a new  DMA  handle.  A  DMA	*
 *     handle  is  an  opaque  object used as a reference to subse-	*
 *     quently  allocated  DMA  resources.   ddi_dma_alloc_handle()	*
 *     accepts  as parameters the device information referred to by	*
 *     dip  and  the  device's  DMA  attributes  described   by   a	*
 *     ddi_dma_attr(9S)    structure.    A   successful   call   to	*
 *     ddi_dma_alloc_handle() fills in  the  value  pointed  to  by	*
 *     handlep.   A  DMA handle must only be used by the device for	*
 *     which it was allocated and is only valid for one  I/O  tran-	*
 *     saction at a time.						*
 *									*
 *     ddi_dma_mem_alloc() allocates memory for DMA transfers to or	*
 *     from a device.  The allocation will obey the alignment, pad-	*
 *     ding constraints and device granularity as specified by  the	*
 *     DMA    attributes    (see    ddi_dma_attr(9S))   passed   to	*
 *     ddi_dma_alloc_handle(9F) and the more restrictive attributes	*
 *     imposed by the system.Flags should be set to DDI_DMA_STREAMING	*
 *     if  the  device  is  doing  sequential,  unidirectional,		*
 *     block-sized, and block- aligned transfers to or from memory.	*
 *									*
 *									*
 *     ddi_dma_addr_bind_handle() allocates  DMA  resources  for  a	*
 *     memory  object such that a device can perform DMA to or from	*
 *     the object.  DMA resources  are  allocated  considering  the	*
 *     device's  DMA  attributes  as  expressed by ddi_dma_attr(9S)	*
 *     (see ddi_dma_alloc_handle(9F)).					*
 *     ddi_dma_addr_bind_handle() fills in  the  first  DMA  cookie	*
 *     pointed  to by cookiep with the appropriate address, length,	*
 *     and bus type.	*ccountp is set to the number of DMA  cookies	*
 *     representing this DMA object. Subsequent DMA cookies must be	*
 *     retrieved by calling ddi_dma_nextcookie(9F)  the  number  of	*
 *     times specified by *countp - 1.					*
 *									*
 * Arguments:								*
 *      Adapter - A pointer to context sensitive "Adapter" structure.	*
 *									*
 *									*
 * Returns:								*
 *      DDI_SUCCESS on success						*
 *	  DDI_FAILURE on error						*
 *									*
 * Modification log:							*
 * Date      Who  Description						*
 * --------  ---  -----------------------------------------------------	*
 * 11/11/98  Vinay  Cleaned the entire function to prevents panics and	*
 *		   memory corruption					*
 * 17/11/98  Vinay  Optimized it for proper usages of function calls	*
 * 30/04/99  Vinay  Resolved some more memory problems related to race	*
 *		  conditions						*
 * **********************************************************************
 */
static int
e1000g_alloc_descriptors(struct e1000g *Adapter)
{
	int result;
	e1000g_tx_ring_t *tx_ring;
	e1000g_rx_ring_t *rx_ring;

	tx_ring = Adapter->tx_ring;

	result = e1000g_alloc_tx_descriptors(tx_ring);
	if (result != DDI_SUCCESS)
		return (DDI_FAILURE);

	rx_ring = Adapter->rx_ring;

	result = e1000g_alloc_rx_descriptors(rx_ring);
	if (result != DDI_SUCCESS) {
		e1000g_free_tx_descriptors(tx_ring);
		return (DDI_FAILURE);
	}

	return (DDI_SUCCESS);
}

static int
e1000g_alloc_tx_descriptors(e1000g_tx_ring_t *tx_ring)
{
	int mystat;
	boolean_t alloc_flag;
	size_t size;
	size_t len;
	uintptr_t templong;
	uint_t cookie_count;
	dev_info_t *devinfo;
	ddi_dma_cookie_t cookie;
	struct e1000g *Adapter;

	Adapter = tx_ring->adapter;

	alloc_flag = B_FALSE;

	devinfo = Adapter->dip;

	/*
	 * Solaris 7 has a problem with allocating physically contiguous memory
	 * that is aligned on a 4K boundary. The transmit and rx descriptors
	 * need to aligned on a 4kbyte boundary. We first try to allocate the
	 * memory with DMA attributes set to 4K alignment and also no scatter/
	 * gather mechanism specified. In most cases, this does not allocate
	 * memory aligned at a 4Kbyte boundary. We then try asking for memory
	 * aligned on 4K boundary with scatter/gather set to 2. This works when
	 * the amount of memory is less than 4k i.e a page size. If neither of
	 * these options work or if the number of descriptors is greater than
	 * 4K, ie more than 256 descriptors, we allocate 4k extra memory and
	 * and then align the memory at a 4k boundary.
	 */
	size = sizeof (struct e1000_tx_desc) * Adapter->NumTxDescriptors;

	/*
	 * Memory allocation for the transmit buffer descriptors.
	 */
	/*
	 * DMA attributes set to asking for 4k alignment and no
	 * scatter/gather specified.
	 * This typically does not succeed for Solaris 7, but
	 * might work for Solaris 2.6
	 */
	tbd_dma_attr.dma_attr_sgllen = 1;

	/*
	 * Allocate a new DMA handle for the transmit descriptor
	 * memory area.
	 */
	mystat = ddi_dma_alloc_handle(devinfo, &tbd_dma_attr,
	    DDI_DMA_DONTWAIT, 0,
	    &tx_ring->tbd_dma_handle);

	if (mystat != DDI_SUCCESS) {
		e1000g_log(Adapter, CE_WARN,
		    "Could not allocate tbd dma handle: %d", mystat);
		tx_ring->tbd_dma_handle = NULL;
		return (DDI_FAILURE);
	}

	/*
	 * Allocate memory to DMA data to and from the transmit
	 * descriptors.
	 */
	mystat = ddi_dma_mem_alloc(tx_ring->tbd_dma_handle,
	    size,
	    &accattr, DDI_DMA_CONSISTENT,
	    DDI_DMA_DONTWAIT, 0,
	    (caddr_t *)&tx_ring->tbd_area,
	    &len, &tx_ring->tbd_acc_handle);

	if ((mystat != DDI_SUCCESS) ||
	    ((uintptr_t)tx_ring->tbd_area & (E1000_MDALIGN - 1))) {
		if (mystat == DDI_SUCCESS) {
			ddi_dma_mem_free(&tx_ring->tbd_acc_handle);
			tx_ring->tbd_acc_handle = NULL;
			tx_ring->tbd_area = NULL;
		}
		if (tx_ring->tbd_dma_handle != NULL) {
			ddi_dma_free_handle(&tx_ring->tbd_dma_handle);
			tx_ring->tbd_dma_handle = NULL;
		}
		alloc_flag = B_FALSE;
	} else
		alloc_flag = B_TRUE;

	/*
	 * Initialize the entire transmit buffer descriptor area to zero
	 */
	if (alloc_flag)
		bzero(tx_ring->tbd_area, len);

	/*
	 * If the previous DMA attributes setting could not give us contiguous
	 * memory or the number of descriptors is greater than the page size,
	 * we allocate 4K extra memory and then align it at a 4k boundary.
	 */
	if (!alloc_flag) {
		size = size + ROUNDOFF;

		/*
		 * DMA attributes set to no scatter/gather and 16 bit alignment
		 */
		tbd_dma_attr.dma_attr_align = 1;
		tbd_dma_attr.dma_attr_sgllen = 1;

		/*
		 * Allocate a new DMA handle for the transmit descriptor memory
		 * area.
		 */
		mystat = ddi_dma_alloc_handle(devinfo, &tbd_dma_attr,
		    DDI_DMA_DONTWAIT, 0,
		    &tx_ring->tbd_dma_handle);

		if (mystat != DDI_SUCCESS) {
			e1000g_log(Adapter, CE_WARN,
			    "Could not re-allocate tbd dma handle: %d", mystat);
			tx_ring->tbd_dma_handle = NULL;
			return (DDI_FAILURE);
		}

		/*
		 * Allocate memory to DMA data to and from the transmit
		 * descriptors.
		 */
		mystat = ddi_dma_mem_alloc(tx_ring->tbd_dma_handle,
		    size,
		    &accattr, DDI_DMA_CONSISTENT,
		    DDI_DMA_DONTWAIT, 0,
		    (caddr_t *)&tx_ring->tbd_area,
		    &len, &tx_ring->tbd_acc_handle);

		if (mystat != DDI_SUCCESS) {
			e1000g_log(Adapter, CE_WARN,
			    "Could not allocate tbd dma memory: %d", mystat);
			tx_ring->tbd_acc_handle = NULL;
			tx_ring->tbd_area = NULL;
			if (tx_ring->tbd_dma_handle != NULL) {
				ddi_dma_free_handle(&tx_ring->tbd_dma_handle);
				tx_ring->tbd_dma_handle = NULL;
			}
			return (DDI_FAILURE);
		} else
			alloc_flag = B_TRUE;

		/*
		 * Initialize the entire transmit buffer descriptor area to zero
		 */
		bzero(tx_ring->tbd_area, len);
		/*
		 * Memory has been allocated with the ddi_dma_mem_alloc call,
		 * but has not been aligned. We now align it on a 4k boundary.
		 */
		templong = P2NPHASE((uintptr_t)tx_ring->tbd_area, ROUNDOFF);
		len = size - templong;
		templong += (uintptr_t)tx_ring->tbd_area;
		tx_ring->tbd_area = (struct e1000_tx_desc *)templong;
	}	/* alignment workaround */

	/*
	 * Transmit buffer descriptor memory allocation succeeded
	 */
	ASSERT(alloc_flag);

	/*
	 * Allocates DMA resources for the memory that was allocated by
	 * the ddi_dma_mem_alloc call. The DMA resources then get bound to the
	 * the memory address
	 */
	mystat = ddi_dma_addr_bind_handle(tx_ring->tbd_dma_handle,
	    (struct as *)NULL, (caddr_t)tx_ring->tbd_area,
	    len, DDI_DMA_RDWR | DDI_DMA_CONSISTENT,
	    DDI_DMA_SLEEP, 0, &cookie, &cookie_count);

	if (mystat != DDI_SUCCESS) {
		e1000g_log(Adapter, CE_WARN,
		    "Could not bind tbd dma resource: %d", mystat);
		if (tx_ring->tbd_acc_handle != NULL) {
			ddi_dma_mem_free(&tx_ring->tbd_acc_handle);
			tx_ring->tbd_acc_handle = NULL;
			tx_ring->tbd_area = NULL;
		}
		if (tx_ring->tbd_dma_handle != NULL) {
			ddi_dma_free_handle(&tx_ring->tbd_dma_handle);
			tx_ring->tbd_dma_handle = NULL;
		}
		return (DDI_FAILURE);
	}

	ASSERT(cookie_count == 1);	/* 1 cookie */

	if (cookie_count != 1) {
		e1000g_log(Adapter, CE_WARN,
		    "Could not bind tbd dma resource in a single frag. "
		    "Count - %d Len - %d", cookie_count, len);
		e1000g_free_tx_descriptors(tx_ring);
		return (DDI_FAILURE);
	}

	/*
	 * The FirstTxDescriptor is initialized to the physical address that
	 * is obtained from the ddi_dma_addr_bind_handle call
	 */
	tx_ring->tbd_dma_addr = cookie.dmac_laddress;
	tx_ring->tbd_first = tx_ring->tbd_area;
	tx_ring->tbd_last = tx_ring->tbd_first +
	    (Adapter->NumTxDescriptors - 1);

	return (DDI_SUCCESS);
}

static int
e1000g_alloc_rx_descriptors(e1000g_rx_ring_t *rx_ring)
{
	int mystat;
	boolean_t alloc_flag;
	size_t size;
	size_t len;
	uintptr_t templong;
	uint_t cookie_count;
	dev_info_t *devinfo;
	ddi_dma_cookie_t cookie;
	struct e1000g *Adapter;

	Adapter = rx_ring->adapter;

	alloc_flag = B_FALSE;

	devinfo = Adapter->dip;

	/*
	 * Memory allocation for the receive buffer descriptors.
	 */
	size = (sizeof (struct e1000_rx_desc)) * Adapter->NumRxDescriptors;

	/*
	 * Asking for aligned memory with DMA attributes set for 4k alignment
	 */
	tbd_dma_attr.dma_attr_sgllen = 1;
	tbd_dma_attr.dma_attr_align = E1000_MDALIGN;

	/*
	 * Allocate a new DMA handle for the receive descriptor
	 * memory area. re-use the tbd_dma_attr since rbd has
	 * same attributes.
	 */
	mystat = ddi_dma_alloc_handle(devinfo, &tbd_dma_attr,
	    DDI_DMA_DONTWAIT, 0,
	    &rx_ring->rbd_dma_handle);

	if (mystat != DDI_SUCCESS) {
		e1000g_log(Adapter, CE_WARN,
		    "Could not allocate rbd dma handle: %d", mystat);
		rx_ring->rbd_dma_handle = NULL;
		return (DDI_FAILURE);
	}
	/*
	 * Allocate memory to DMA data to and from the receive
	 * descriptors.
	 */
	mystat = ddi_dma_mem_alloc(rx_ring->rbd_dma_handle,
	    size,
	    &accattr, DDI_DMA_CONSISTENT,
	    DDI_DMA_DONTWAIT, 0,
	    (caddr_t *)&rx_ring->rbd_area,
	    &len, &rx_ring->rbd_acc_handle);

	/*
	 * Check if memory allocation succeeded and also if the
	 * allocated memory is aligned correctly.
	 */
	if ((mystat != DDI_SUCCESS) ||
	    ((uintptr_t)rx_ring->rbd_area & (E1000_MDALIGN - 1))) {
		if (mystat == DDI_SUCCESS) {
			ddi_dma_mem_free(&rx_ring->rbd_acc_handle);
			rx_ring->rbd_acc_handle = NULL;
			rx_ring->rbd_area = NULL;
		}
		if (rx_ring->rbd_dma_handle != NULL) {
			ddi_dma_free_handle(&rx_ring->rbd_dma_handle);
			rx_ring->rbd_dma_handle = NULL;
		}
		alloc_flag = B_FALSE;
	} else
		alloc_flag = B_TRUE;

	/*
	 * Initialize the allocated receive descriptor memory to zero.
	 */
	if (alloc_flag)
		bzero((caddr_t)rx_ring->rbd_area, len);

	/*
	 * If memory allocation did not succeed or if number of descriptors is
	 * greater than a page size ( more than 256 descriptors ), do the
	 * alignment yourself
	 */
	if (!alloc_flag) {
		tbd_dma_attr.dma_attr_align = 1;
		tbd_dma_attr.dma_attr_sgllen = 1;
		size = size + ROUNDOFF;
		/*
		 * Allocate a new DMA handle for the receive descriptor memory
		 * area. re-use the tbd_dma_attr since rbd has same attributes.
		 */
		mystat = ddi_dma_alloc_handle(devinfo, &tbd_dma_attr,
		    DDI_DMA_DONTWAIT, 0,
		    &rx_ring->rbd_dma_handle);

		if (mystat != DDI_SUCCESS) {
			e1000g_log(Adapter, CE_WARN,
			    "Could not re-allocate rbd dma handle: %d", mystat);
			rx_ring->rbd_dma_handle = NULL;
			return (DDI_FAILURE);
		}
		/*
		 * Allocate memory to DMA data to and from the receive
		 * descriptors.
		 */
		mystat = ddi_dma_mem_alloc(rx_ring->rbd_dma_handle,
		    size,
		    &accattr, DDI_DMA_CONSISTENT,
		    DDI_DMA_DONTWAIT, 0,
		    (caddr_t *)&rx_ring->rbd_area,
		    &len, &rx_ring->rbd_acc_handle);

		if (mystat != DDI_SUCCESS) {
			e1000g_log(Adapter, CE_WARN,
			    "Could not allocate rbd dma memory: %d", mystat);
			rx_ring->rbd_acc_handle = NULL;
			rx_ring->rbd_area = NULL;
			if (rx_ring->rbd_dma_handle != NULL) {
				ddi_dma_free_handle(&rx_ring->rbd_dma_handle);
				rx_ring->rbd_dma_handle = NULL;
			}
			return (DDI_FAILURE);
		} else
			alloc_flag = B_TRUE;

		/*
		 * Initialize the allocated receive descriptor memory to zero.
		 */
		bzero((caddr_t)rx_ring->rbd_area, len);
		templong = P2NPHASE((uintptr_t)rx_ring->rbd_area, ROUNDOFF);
		len = size - templong;
		templong += (uintptr_t)rx_ring->rbd_area;
		rx_ring->rbd_area = (struct e1000_rx_desc *)templong;
	}	/* alignment workaround */

	/*
	 * The memory allocation of the receive descriptors succeeded
	 */
	ASSERT(alloc_flag);

	/*
	 * Allocates DMA resources for the memory that was allocated by
	 * the ddi_dma_mem_alloc call.
	 */
	mystat = ddi_dma_addr_bind_handle(rx_ring->rbd_dma_handle,
		(struct as *)NULL, (caddr_t)rx_ring->rbd_area,
		len, DDI_DMA_RDWR | DDI_DMA_CONSISTENT,
		DDI_DMA_SLEEP, 0, &cookie, &cookie_count);

	if (mystat != DDI_SUCCESS) {
		e1000g_log(Adapter, CE_WARN,
		    "Could not bind rbd dma resource: %d", mystat);
		if (rx_ring->rbd_acc_handle != NULL) {
			ddi_dma_mem_free(&rx_ring->rbd_acc_handle);
			rx_ring->rbd_acc_handle = NULL;
			rx_ring->rbd_area = NULL;
		}
		if (rx_ring->rbd_dma_handle != NULL) {
			ddi_dma_free_handle(&rx_ring->rbd_dma_handle);
			rx_ring->rbd_dma_handle = NULL;
		}
		return (DDI_FAILURE);
	}

	ASSERT(cookie_count == 1);
	if (cookie_count != 1) {
		e1000g_log(Adapter, CE_WARN,
		    "Could not bind rbd dma resource in a single frag. "
		    "Count - %d Len - %d", cookie_count, len);
		e1000g_free_rx_descriptors(rx_ring);
		return (DDI_FAILURE);
	}
	/*
	 * Initialize the FirstRxDescriptor to the cookie address obtained
	 * from the ddi_dma_addr_bind_handle call.
	 */
	rx_ring->rbd_dma_addr = cookie.dmac_laddress;
	rx_ring->rbd_first = rx_ring->rbd_area;
	rx_ring->rbd_last = rx_ring->rbd_first +
	    (Adapter->NumRxDescriptors - 1);

	return (DDI_SUCCESS);
}

static void
e1000g_free_rx_descriptors(e1000g_rx_ring_t *rx_ring)
{
	if (rx_ring->rbd_dma_handle != NULL) {
		ddi_dma_unbind_handle(rx_ring->rbd_dma_handle);
	}
	if (rx_ring->rbd_acc_handle != NULL) {
		ddi_dma_mem_free(&rx_ring->rbd_acc_handle);
		rx_ring->rbd_acc_handle = NULL;
		rx_ring->rbd_area = NULL;
	}
	if (rx_ring->rbd_dma_handle != NULL) {
		ddi_dma_free_handle(&rx_ring->rbd_dma_handle);
		rx_ring->rbd_dma_handle = NULL;
	}
	rx_ring->rbd_dma_addr = NULL;
	rx_ring->rbd_first = NULL;
	rx_ring->rbd_last = NULL;
}

static void
e1000g_free_tx_descriptors(e1000g_tx_ring_t *tx_ring)
{
	if (tx_ring->tbd_dma_handle != NULL) {
		ddi_dma_unbind_handle(tx_ring->tbd_dma_handle);
	}
	if (tx_ring->tbd_acc_handle != NULL) {
		ddi_dma_mem_free(&tx_ring->tbd_acc_handle);
		tx_ring->tbd_acc_handle = NULL;
		tx_ring->tbd_area = NULL;
	}
	if (tx_ring->tbd_dma_handle != NULL) {
		ddi_dma_free_handle(&tx_ring->tbd_dma_handle);
		tx_ring->tbd_dma_handle = NULL;
	}
	tx_ring->tbd_dma_addr = NULL;
	tx_ring->tbd_first = NULL;
	tx_ring->tbd_last = NULL;
}


/*
 * **********************************************************************
 * Name:	e1000g_alloc_packets					*
 *									*
 * Description: This routine Allocates Neccesary Buffers for the device	*
 *      It allocates memory for						*
 *									*
 *	 Transmit packet Structure					*
 *	 Handle for Transmit buffers					*
 *	 Receive packet structure					*
 *	 Buffer for Receive packet					*
 *									*
 *									*
 *       For ddi memory alloc routine see e1000g_Txalloc description	*
 *       NOTE -- The device must have been reset before this routine	*
 *	       is called.						*
 *									*
 * Author:		   Hari Seshadri				*
 * Functions Called :							*
 *									*
 *									*
 *									*
 * Arguments:								*
 *      Adapter - A pointer to our context sensitive "Adapter"		*
 *		structure.						*
 *									*
 *									*
 * Returns:								*
 *      DDI_SUCCESS on sucess						*
 *	  DDI_FAILURE on error						*
 *									*
 *									*
 *									*
 * Modification log:							*
 * Date      Who  Description						*
 * --------  ---  -----------------------------------------------------	*
 * 30/04/99  VA   Cleaned code for memory corruptions, invalid DMA	*
 *		attributes and prevent panics				*
 * **********************************************************************
 */
static int
e1000g_alloc_packets(struct e1000g *Adapter)
{
	int result;
	e1000g_tx_ring_t *tx_ring;
	e1000g_rx_ring_t *rx_ring;

	tx_ring = Adapter->tx_ring;
	rx_ring = Adapter->rx_ring;

again:
	rw_enter(&e1000g_dma_type_lock, RW_READER);

	result = e1000g_alloc_tx_packets(tx_ring);
	if (result != DDI_SUCCESS) {
		if (e1000g_dma_type == USE_DVMA) {
			rw_exit(&e1000g_dma_type_lock);

			rw_enter(&e1000g_dma_type_lock, RW_WRITER);
			e1000g_dma_type = USE_DMA;
			rw_exit(&e1000g_dma_type_lock);

			e1000g_DEBUGLOG_0(Adapter, e1000g_CALLTRACE_LEVEL,
			    "No enough dvma resource for Tx packets, "
			    "trying to allocate dma buffers...\n");
			goto again;
		}
		rw_exit(&e1000g_dma_type_lock);

		e1000g_DEBUGLOG_0(Adapter, e1000g_INFO_LEVEL,
		    "Failed to allocate dma buffers for Tx packets\n");
		return (DDI_FAILURE);
	}

	result = e1000g_alloc_rx_packets(rx_ring);
	if (result != DDI_SUCCESS) {
		e1000g_free_tx_packets(tx_ring);
		if (e1000g_dma_type == USE_DVMA) {
			rw_exit(&e1000g_dma_type_lock);

			rw_enter(&e1000g_dma_type_lock, RW_WRITER);
			e1000g_dma_type = USE_DMA;
			rw_exit(&e1000g_dma_type_lock);

			e1000g_DEBUGLOG_0(Adapter, e1000g_CALLTRACE_LEVEL,
			    "No enough dvma resource for Rx packets, "
			    "trying to allocate dma buffers...\n");
			goto again;
		}
		rw_exit(&e1000g_dma_type_lock);

		e1000g_DEBUGLOG_0(Adapter, e1000g_INFO_LEVEL,
		    "Failed to allocate dma buffers for Rx packets\n");
		return (DDI_FAILURE);
	}

	rw_exit(&e1000g_dma_type_lock);

	return (DDI_SUCCESS);
}

#ifdef __sparc
static int
e1000g_alloc_dvma_buffer(struct e1000g *Adapter,
    dma_buffer_t *buf, size_t size)
{
	int mystat;
	dev_info_t *devinfo;
	ddi_dma_cookie_t cookie;

	devinfo = Adapter->dip;

	mystat = dvma_reserve(devinfo,
	    &e1000g_dma_limits,
	    Adapter->dvma_page_num,
	    &buf->dma_handle);

	if (mystat != DDI_SUCCESS) {
		buf->dma_handle = NULL;
		e1000g_DEBUGLOG_1(Adapter, e1000g_CALLTRACE_LEVEL,
		    "Could not allocate dvma buffer handle: %d\n", mystat);
		return (DDI_FAILURE);
	}

	buf->address = kmem_alloc(size, KM_NOSLEEP);

	if (buf->address == NULL) {
		if (buf->dma_handle != NULL) {
			dvma_release(buf->dma_handle);
			buf->dma_handle = NULL;
		}
		e1000g_DEBUGLOG_0(Adapter, e1000g_CALLTRACE_LEVEL,
		    "Could not allocate dvma buffer memory\n");
		return (DDI_FAILURE);
	}

	dvma_kaddr_load(buf->dma_handle,
	    buf->address, size, 0, &cookie);

	buf->dma_address = cookie.dmac_laddress;
	buf->size = size;
	buf->len = 0;

	return (DDI_SUCCESS);
}

static void
e1000g_free_dvma_buffer(dma_buffer_t *buf)
{
	if (buf->dma_handle != NULL) {
		dvma_unload(buf->dma_handle, 0, -1);
	} else {
		return;
	}

	buf->dma_address = NULL;

	if (buf->address != NULL) {
		kmem_free(buf->address, buf->size);
		buf->address = NULL;
	}

	if (buf->dma_handle != NULL) {
		dvma_release(buf->dma_handle);
		buf->dma_handle = NULL;
	}

	buf->size = 0;
	buf->len = 0;
}
#endif

static int
e1000g_alloc_dma_buffer(struct e1000g *Adapter,
    dma_buffer_t *buf, size_t size)
{
	int mystat;
	dev_info_t *devinfo;
	ddi_dma_cookie_t cookie;
	size_t len;
	uint_t count;

	devinfo = Adapter->dip;

	mystat = ddi_dma_alloc_handle(devinfo,
	    &buf_dma_attr,
	    DDI_DMA_DONTWAIT, 0,
	    &buf->dma_handle);

	if (mystat != DDI_SUCCESS) {
		buf->dma_handle = NULL;
		e1000g_DEBUGLOG_1(Adapter, e1000g_CALLTRACE_LEVEL,
		    "Could not allocate dma buffer handle: %d\n", mystat);
		return (DDI_FAILURE);
	}

	mystat = ddi_dma_mem_alloc(buf->dma_handle,
	    size, &accattr2, DDI_DMA_STREAMING,
	    DDI_DMA_DONTWAIT, 0,
	    &buf->address,
	    &len, &buf->acc_handle);

	if (mystat != DDI_SUCCESS) {
		buf->acc_handle = NULL;
		buf->address = NULL;
		if (buf->dma_handle != NULL) {
			ddi_dma_free_handle(&buf->dma_handle);
			buf->dma_handle = NULL;
		}
		e1000g_DEBUGLOG_1(Adapter, e1000g_CALLTRACE_LEVEL,
		    "Could not allocate dma buffer memory: %d\n", mystat);
		return (DDI_FAILURE);
	}

	mystat = ddi_dma_addr_bind_handle(buf->dma_handle,
	    (struct as *)NULL,
	    buf->address,
	    len, DDI_DMA_READ | DDI_DMA_STREAMING,
	    DDI_DMA_SLEEP, 0, &cookie, &count);

	if (mystat != DDI_SUCCESS) {
		if (buf->acc_handle != NULL) {
			ddi_dma_mem_free(&buf->acc_handle);
			buf->acc_handle = NULL;
			buf->address = NULL;
		}
		if (buf->dma_handle != NULL) {
			ddi_dma_free_handle(&buf->dma_handle);
			buf->dma_handle = NULL;
		}
		e1000g_DEBUGLOG_1(Adapter, e1000g_CALLTRACE_LEVEL,
		    "Could not bind buffer dma handle: %d\n", mystat);
		return (DDI_FAILURE);
	}

	ASSERT(count == 1);
	if (count != 1) {
		if (buf->dma_handle != NULL) {
			ddi_dma_unbind_handle(buf->dma_handle);
		}
		if (buf->acc_handle != NULL) {
			ddi_dma_mem_free(&buf->acc_handle);
			buf->acc_handle = NULL;
			buf->address = NULL;
		}
		if (buf->dma_handle != NULL) {
			ddi_dma_free_handle(&buf->dma_handle);
			buf->dma_handle = NULL;
		}
		e1000g_DEBUGLOG_1(Adapter, e1000g_CALLTRACE_LEVEL,
		    "Could not bind buffer as a single frag. "
		    "Count = %d\n", count);
		return (DDI_FAILURE);
	}

	buf->dma_address = cookie.dmac_laddress;
	buf->size = len;
	buf->len = 0;

	return (DDI_SUCCESS);
}

static void
e1000g_free_dma_buffer(dma_buffer_t *buf)
{
	if (buf->dma_handle != NULL) {
		ddi_dma_unbind_handle(buf->dma_handle);
	} else {
		return;
	}

	buf->dma_address = NULL;

	if (buf->acc_handle != NULL) {
		ddi_dma_mem_free(&buf->acc_handle);
		buf->acc_handle = NULL;
		buf->address = NULL;
	}

	if (buf->dma_handle != NULL) {
		ddi_dma_free_handle(&buf->dma_handle);
		buf->dma_handle = NULL;
	}

	buf->size = 0;
	buf->len = 0;
}

static int
e1000g_alloc_tx_packets(e1000g_tx_ring_t *tx_ring)
{
	int j;
	PTX_SW_PACKET packet;
	int mystat;
	dma_buffer_t *tx_buf;
	struct e1000g *Adapter = tx_ring->adapter;
	dev_info_t *devinfo = Adapter->dip;

	/*
	 * Memory allocation for the Transmit software structure, the transmit
	 * software packet. This structure stores all the relevant information
	 * for transmitting a single packet.
	 */
	tx_ring->packet_area =
	    kmem_zalloc(TX_SW_PKT_AREA_SZ, KM_NOSLEEP);

	if (tx_ring->packet_area == NULL)
		return (DDI_FAILURE);

	for (j = 0, packet = tx_ring->packet_area;
	    j < Adapter->NumTxSwPacket; j++, packet++) {

		ASSERT(packet != NULL);

		/*
		 * Pre-allocate dma handles for transmit. These dma handles
		 * will be dynamically bound to the data buffers passed down
		 * from the upper layers at the time of transmitting. The
		 * dynamic binding only applies for the packets that are larger
		 * than the tx_bcopy_thresh.
		 */
		switch (e1000g_dma_type) {
#ifdef __sparc
		case USE_DVMA:
			mystat = dvma_reserve(devinfo,
			    &e1000g_dma_limits,
			    Adapter->dvma_page_num,
			    &packet->tx_dma_handle);
			break;
#endif
		case USE_DMA:
			mystat = ddi_dma_alloc_handle(devinfo,
			    &tx_dma_attr,
			    DDI_DMA_DONTWAIT, 0,
			    &packet->tx_dma_handle);
			break;
		default:
			ASSERT(B_FALSE);
			break;
		}
		if (mystat != DDI_SUCCESS) {
			packet->tx_dma_handle = NULL;
			e1000g_DEBUGLOG_1(Adapter, e1000g_CALLTRACE_LEVEL,
			    "Could not allocate tx dma handle: %d\n", mystat);
			goto tx_pkt_fail;
		}

		/*
		 * Pre-allocate transmit buffers for small packets that the
		 * size is less than tx_bcopy_thresh. The data of those small
		 * packets will be bcopy() to the transmit buffers instead of
		 * using dynamical DMA binding. For small packets, bcopy will
		 * bring better performance than DMA binding.
		 */
		tx_buf = packet->tx_buf;

		switch (e1000g_dma_type) {
#ifdef __sparc
		case USE_DVMA:
			mystat = e1000g_alloc_dvma_buffer(Adapter,
			    tx_buf, Adapter->TxBufferSize);
			break;
#endif
		case USE_DMA:
			mystat = e1000g_alloc_dma_buffer(Adapter,
			    tx_buf, Adapter->TxBufferSize);
			break;
		default:
			ASSERT(B_FALSE);
			break;
		}
		if (mystat != DDI_SUCCESS) {
			ASSERT(packet->tx_dma_handle != NULL);
			switch (e1000g_dma_type) {
#ifdef __sparc
			case USE_DVMA:
				dvma_release(packet->tx_dma_handle);
				break;
#endif
			case USE_DMA:
				ddi_dma_free_handle(&packet->tx_dma_handle);
				break;
			default:
				ASSERT(B_FALSE);
				break;
			}
			packet->tx_dma_handle = NULL;
			e1000g_DEBUGLOG_0(Adapter, e1000g_CALLTRACE_LEVEL,
			    "Allocate Tx buffer fail\n");
			goto tx_pkt_fail;
		}

		packet->dma_type = e1000g_dma_type;
	} /* for */

	return (DDI_SUCCESS);

tx_pkt_fail:
	e1000g_free_tx_packets(tx_ring);

	return (DDI_FAILURE);
}

static int
e1000g_alloc_rx_packets(e1000g_rx_ring_t *rx_ring)
{
	int i;
	PRX_SW_PACKET packet;
	struct e1000g *Adapter;
	uint32_t packet_num;

	Adapter = rx_ring->adapter;

	/*
	 * Allocate memory for the RX_SW_PACKET structures. Each one of these
	 * structures will contain a virtual and physical address to an actual
	 * receive buffer in host memory. Since we use one RX_SW_PACKET per
	 * received packet, the maximum number of RX_SW_PACKETs that we'll
	 * need is equal to the number of receive descriptors that we've
	 * allocated.
	 *
	 * Pre allocation for recv packet buffer. The Recv intr constructs
	 * a new mp using this buffer
	 *
	 * On Wiseman these Receive buffers must be aligned with 256 byte
	 * boundary
	 * Vinay, Apr19,2000
	 */
	packet_num = Adapter->NumRxDescriptors + Adapter->NumRxFreeList;
	rx_ring->packet_area = NULL;

	for (i = 0; i < packet_num; i++) {
		packet = e1000g_alloc_rx_sw_packet(rx_ring);
		if (packet == NULL)
			goto rx_pkt_fail;

		packet->next = rx_ring->packet_area;
		rx_ring->packet_area = packet;
	}

	return (DDI_SUCCESS);

rx_pkt_fail:
	e1000g_free_rx_packets(rx_ring);

	return (DDI_FAILURE);
}

static PRX_SW_PACKET
e1000g_alloc_rx_sw_packet(e1000g_rx_ring_t *rx_ring)
{
	int mystat;
	PRX_SW_PACKET packet;
	dma_buffer_t *rx_buf;
	struct e1000g *Adapter;

	Adapter = rx_ring->adapter;

	packet = kmem_zalloc(sizeof (RX_SW_PACKET), KM_NOSLEEP);
	if (packet == NULL) {
		e1000g_DEBUGLOG_0(Adapter, e1000g_CALLTRACE_LEVEL,
		    "Cound not allocate memory for Rx SwPacket\n");
		return (NULL);
	}

	rx_buf = packet->rx_buf;

	/*
	 * Make sure that receive buffers are 256 byte aligned
	 */
	buf_dma_attr.dma_attr_align = Adapter->RcvBufferAlignment;

	switch (e1000g_dma_type) {
#ifdef __sparc
	case USE_DVMA:
		mystat = e1000g_alloc_dvma_buffer(Adapter,
		    rx_buf, Adapter->RxBufferSize);
		break;
#endif
	case USE_DMA:
		mystat = e1000g_alloc_dma_buffer(Adapter,
		    rx_buf, Adapter->RxBufferSize);
		break;
	default:
		ASSERT(B_FALSE);
		break;
	}

	if (mystat != DDI_SUCCESS) {
		if (packet != NULL)
			kmem_free(packet, sizeof (RX_SW_PACKET));

		e1000g_DEBUGLOG_0(Adapter, e1000g_CALLTRACE_LEVEL,
		    "Failed to allocate Rx buffer\n");
		return (NULL);
	}

	rx_buf->size -= E1000G_IPALIGNROOM;
	rx_buf->address += E1000G_IPALIGNROOM;
	rx_buf->dma_address += E1000G_IPALIGNROOM;

	packet->rx_ring = (caddr_t)rx_ring;
	packet->free_rtn.free_func = e1000g_rxfree_func;
	packet->free_rtn.free_arg = (char *)packet;
	/*
	 * esballoc is changed to desballoc which
	 * is undocumented call but as per sun,
	 * we can use it. It gives better efficiency.
	 */
	packet->mp = desballoc((unsigned char *)
	    rx_buf->address - E1000G_IPALIGNROOM,
	    rx_buf->size + E1000G_IPALIGNROOM,
	    BPRI_MED, &packet->free_rtn);

	if (packet->mp != NULL) {
		packet->mp->b_rptr += E1000G_IPALIGNROOM;
		packet->mp->b_wptr += E1000G_IPALIGNROOM;
	}

	packet->dma_type = e1000g_dma_type;

	return (packet);
}

void
e1000g_free_rx_sw_packet(PRX_SW_PACKET packet)
{
	dma_buffer_t *rx_buf;

	if (packet->mp != NULL) {
		freemsg(packet->mp);
		packet->mp = NULL;
	}

	rx_buf = packet->rx_buf;
	ASSERT(rx_buf->dma_handle != NULL);

	rx_buf->size += E1000G_IPALIGNROOM;
	rx_buf->address -= E1000G_IPALIGNROOM;

	switch (packet->dma_type) {
#ifdef __sparc
	case USE_DVMA:
		e1000g_free_dvma_buffer(rx_buf);
		break;
#endif
	case USE_DMA:
		e1000g_free_dma_buffer(rx_buf);
		break;
	default:
		ASSERT(B_FALSE);
		break;
	}

	packet->dma_type = USE_NONE;

	kmem_free(packet, sizeof (RX_SW_PACKET));
}

static void
e1000g_free_rx_packets(e1000g_rx_ring_t *rx_ring)
{
	PRX_SW_PACKET packet, next_packet;

	rw_enter(&e1000g_rx_detach_lock, RW_WRITER);
	for (packet = rx_ring->packet_area; packet != NULL;
	    packet = packet->next) {
		if (packet->flag & E1000G_RX_SW_SENDUP) {
			e1000g_mblks_pending++;
			packet->flag |= E1000G_RX_SW_DETACHED;
		}
	}
	rw_exit(&e1000g_rx_detach_lock);

	packet = rx_ring->packet_area;
	rx_ring->packet_area = NULL;

	for (; packet != NULL; packet = next_packet) {
		next_packet = packet->next;

		if (packet->flag & E1000G_RX_SW_DETACHED)
			continue;

		ASSERT((packet->flag & E1000G_RX_SW_SENDUP) == 0);
		e1000g_free_rx_sw_packet(packet);
	}
}

static void
e1000g_free_tx_packets(e1000g_tx_ring_t *tx_ring)
{
	int j;
	struct e1000g *Adapter;
	PTX_SW_PACKET packet;
	dma_buffer_t *tx_buf;

	Adapter = tx_ring->adapter;

	for (j = 0, packet = tx_ring->packet_area;
	    j < Adapter->NumTxSwPacket; j++, packet++) {

		if (packet == NULL)
			break;

		/* Free the Tx DMA handle for dynamical binding */
		if (packet->tx_dma_handle != NULL) {
			switch (packet->dma_type) {
#ifdef __sparc
			case USE_DVMA:
				dvma_release(packet->tx_dma_handle);
				break;
#endif
			case USE_DMA:
				ddi_dma_free_handle(&packet->tx_dma_handle);
				break;
			default:
				ASSERT(B_FALSE);
				break;
			}
			packet->tx_dma_handle = NULL;
		} else {
			/*
			 * If the dma handle is NULL, then we don't
			 * need to check the packets left. For they
			 * have not been initialized or have been freed.
			 */
			break;
		}

		tx_buf = packet->tx_buf;

		switch (packet->dma_type) {
#ifdef __sparc
		case USE_DVMA:
			e1000g_free_dvma_buffer(tx_buf);
			break;
#endif
		case USE_DMA:
			e1000g_free_dma_buffer(tx_buf);
			break;
		default:
			ASSERT(B_FALSE);
			break;
		}

		packet->dma_type = USE_NONE;
	}
	if (tx_ring->packet_area != NULL) {
		kmem_free(tx_ring->packet_area, TX_SW_PKT_AREA_SZ);
		tx_ring->packet_area = NULL;
	}
}

/*
 * **********************************************************************
 * Name:      e1000g_release_dma_resources				*
 *									*
 * Description:								*
 *     This function release any pending buffers. that has been		*
 *     previously allocated						*
 *									*
 * Parameter Passed:							*
 *									*
 * Return Value:							*
 *									*
 * Functions called:							*
 *									*
 *									*
 * **********************************************************************
 */
void
e1000g_release_dma_resources(register struct e1000g *Adapter)
{
	e1000g_tx_ring_t *tx_ring;
	e1000g_rx_ring_t *rx_ring;

	tx_ring = Adapter->tx_ring;
	rx_ring = Adapter->rx_ring;

	/*
	 * Release all the handles, memory and DMA resources that are
	 * allocated for the transmit buffer descriptors.
	 */
	e1000g_free_tx_descriptors(tx_ring);

	/*
	 * Release all the handles, memory and DMA resources that are
	 * allocated for the receive buffer descriptors.
	 */
	e1000g_free_rx_descriptors(rx_ring);

	/*
	 * Free Tx packet resources
	 */
	e1000g_free_tx_packets(tx_ring);

	/*
	 * TX resources done, now free RX resources
	 */
	e1000g_free_rx_packets(rx_ring);
}