/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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

#include <sys/types.h>
#include <sys/iommutsb.h>
#include <sys/systm.h>
#include <sys/sysmacros.h>
#include <sys/debug.h>
#include <sys/bootconf.h>
#include <sys/mutex.h>
#include <sys/platform_module.h>
#include <sys/cmn_err.h>

/*
 * The interfaces provided by this file will eventually no longer
 * be required once a physically contiguous memory allocator
 * is available.
 */

/*
 *  The TSB size and consequently the DVMA range is appropriated proportional
 *  to the physical memory size.
 *
 *     phys_mem_size	   iommu TSB size	DVMA size
 *	    <= 32MB		 64KB		 64MB
 *	    <= 128MB		256KB		256MB
 *	    <= 512MB		512KB		512MB
 *	     > 512MB		  1MB		  1GB
 *
 *  NOTE: The original Solaris 8 FCS allocations must be used with
 *        32-bit kernels.
 *
 */
static uint_t
resolve_tsb_size(pgcnt_t phys_mem_size)
{
	if (phys_mem_size <= 0x1000)
		return (0x10000);
	else if (phys_mem_size <= 0x4000)
		return (0x40000);
	else if (phys_mem_size <= 0x10000)
		return (0x80000);
	else
		return (0x100000);
}

/* TSB size must be a power of 2 between the minimum and the maximum. */
#define	MIN_TSB_BYTES	0x2000
#define	MAX_TSB_BYTES	0x100000

/*
 * Use boot to allocate the physically contiguous memory needed for the
 * IOMMU's TSB arrays until there is an interface for dynamically
 * allocated, physically contiguous memory.
 * The number IOMMUs at boot, niommu_tsbs, is set as a side effect
 * of map_wellknown_devices(). The number of TSBs allocated is
 * at least niommu_tsbs. On platforms supporting Dynamic Reconfiguration
 * the platmod routine set_platform_tsb_spares() returns the
 * maximum total number of TSBs expected. The final number of TSBs
 * allocated is set in iommu_tsb_num.
 *
 * WARNING - since this routine uses boot to allocate memory, it MUST
 * be called before the kernel takes over memory allocation from boot.
 */
#define	MAX_IOMMU_PER_AGENT	2
#define	MAX_TSB_ALLOC		(MAX_UPA * MAX_IOMMU_PER_AGENT)

static kmutex_t iommu_tsb_avail_lock;
static uint16_t iommu_tsb_avail[MAX_TSB_ALLOC];
#define	IOMMU_TSB_INUSE		0x8000u
static uint_t iommu_tsb_num;
#ifdef DEBUG
static uint_t iommu_tsb_nfree;
#endif /* DEBUG */

static caddr_t iommu_tsb_base;
static uint_t iommu_tsb_size;

uint_t niommu_tsbs;

/*
 * The following variables can be patched to override the auto-selection
 * of dvma space based on the amount of installed physical memory.
 * Not settable via /etc/system as it is read after iommu_tsb_init()
 * is called.
 */
uint_t iommu_tsb_size_min = MIN_TSB_BYTES;
uint_t iommu_tsb_size_max = MAX_TSB_BYTES;

caddr_t
iommu_tsb_init(caddr_t alloc_base)
{
	size_t total_size;
	caddr_t base = (caddr_t)roundup((uintptr_t)alloc_base, MMU_PAGESIZE);
	uint_t tsb_min, tsb_max;
	uint_t tsb_size;
	uint_t ntsbs;

	/*
	 * determine the amount of physical memory required for the TSB arrays
	 *
	 * assumes niommu_tsbs has already been initialized, i.e.
	 * map_wellknown_devices()
	 *
	 * TSB space is allocated proportional to memory size (see
	 * resolve_tsb_size) but later constained by the limit obtained
	 * from get_dvma_property_limit in the nexus attach.
	 */
	tsb_size = resolve_tsb_size(physinstalled);

	tsb_min = MAX(iommu_tsb_size_min, MIN_TSB_BYTES);
	tsb_max = MIN(iommu_tsb_size_max, MAX_TSB_BYTES);

	if (tsb_min <= tsb_max) {
		uint_t sz;

		/* Ensure that min and max are powers of two. */
		/* guaranteed min and max are both between MIN/MAX_TSB_BYTES */
		for (sz = MAX_TSB_BYTES; !(sz & tsb_min); sz >>= 1)
			/* empty */;
		tsb_min = sz;
		for (sz = MAX_TSB_BYTES; !(sz & tsb_max); sz >>= 1)
			/* empty */;
		tsb_max = sz;

		/* guaranteed min still <= max */
		tsb_size = MIN(tsb_size, tsb_max);
		tsb_size = MAX(tsb_size, tsb_min);
	} else
		cmn_err(CE_WARN,
		    "iommutsb: bad iommu_tsb_size_min/max value pair");

	iommu_tsb_size = tsb_size;

	if (&set_platform_tsb_spares)
		ntsbs = set_platform_tsb_spares();
	else
		ntsbs = 0;
	ntsbs = MAX(ntsbs, niommu_tsbs);
	ntsbs = MIN(ntsbs, MAX_TSB_ALLOC);

	total_size = ntsbs * tsb_size;

	if (total_size == 0)
		return (alloc_base);

	/*
	 * allocate the physical memory for the TSB arrays
	 */
	if ((iommu_tsb_base = (caddr_t)BOP_ALLOC(bootops, base,
	    total_size, MMU_PAGESIZE)) == NULL)
		cmn_err(CE_PANIC, "Cannot allocate IOMMU TSB arrays");
	ASSERT(iommu_tsb_base == base);

	iommu_tsb_num = ntsbs;
#ifdef DEBUG
	iommu_tsb_nfree = iommu_tsb_num;
#endif /* DEBUG */

	return (base + total_size);
}

/*
 * External allocation interface to the nexus drivers (sbus, pci).
 * As an aid to debugging, the upaid or portid is recorded against
 * an allocation.
 */
uint16_t
iommu_tsb_alloc(uint16_t id)
{
	uint16_t tsbc;
	uint_t i;

	tsbc = IOMMU_TSB_COOKIE_NONE;
	mutex_enter(&iommu_tsb_avail_lock);
	for (i = 0; i < iommu_tsb_num; i++) {
		if (iommu_tsb_avail[i] == 0) {
			iommu_tsb_avail[i] = IOMMU_TSB_INUSE | id;
			tsbc = (uint16_t)i;
#ifdef DEBUG
			ASSERT(iommu_tsb_nfree != 0);
			iommu_tsb_nfree--;
#endif /* DEBUG */
			break;
		}
	}
	mutex_exit(&iommu_tsb_avail_lock);
	return (tsbc);
}

void
iommu_tsb_free(uint16_t tsbc)
{
	ASSERT(tsbc != IOMMU_TSB_COOKIE_NONE);
	ASSERT(tsbc < iommu_tsb_num);
	mutex_enter(&iommu_tsb_avail_lock);
	if (iommu_tsb_avail[tsbc] == 0) {
		cmn_err(CE_PANIC, "iommu_tsb_free(%d): tsb not in use", tsbc);
	}
	iommu_tsb_avail[tsbc] = 0;
#ifdef DEBUG
	ASSERT(iommu_tsb_nfree < iommu_tsb_num);
	iommu_tsb_nfree++;
#endif /* DEBUG */
	mutex_exit(&iommu_tsb_avail_lock);
}

/*ARGSUSED*/
uint_t
iommu_tsb_cookie_to_size(uint16_t tsbc)
{
	ASSERT(tsbc != IOMMU_TSB_COOKIE_NONE);
	ASSERT(tsbc < iommu_tsb_num);
	ASSERT(iommu_tsb_avail[tsbc] != 0);
	return (iommu_tsb_size);
}

uint64_t *
iommu_tsb_cookie_to_va(uint16_t tsbc)
{
	ASSERT(tsbc != IOMMU_TSB_COOKIE_NONE);
	ASSERT(tsbc < iommu_tsb_num);
	ASSERT(iommu_tsb_avail[tsbc] != 0);
	return ((uint64_t *)(iommu_tsb_base + (tsbc * iommu_tsb_size)));
}