/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*
 * @OSF_FREE_COPYRIGHT@
 */
/*
 * HISTORY
 * 
 * Revision 1.1.1.1  1998/09/22 21:05:38  wsanchez
 * Import of Mac OS X kernel (~semeria)
 *
 * Revision 1.1.1.1  1998/03/07 02:25:39  wsanchez
 * Import of OSF Mach kernel (~mburg)
 *
 * Revision 1.3.17.7  1995/08/21  20:33:13  devrcs
 * 	ri-osc CR1547:  Fix himem buffer translation to cope with non
 * 	page-aligned addresses.
 * 	[1995/08/08  16:51:58  bolinger]
 *
 * Revision 1.3.17.6  1995/02/24  15:51:12  alanl
 * 	DIPC:  Merge from nmk17b2 to nmk18b8.
 * 	Notes:  lock package cleanup.
 * 	[95/01/23            alanl]
 * 	[95/02/24            alanl]
 * 
 * Revision 1.3.17.5  1995/01/26  22:14:52  ezf
 * 	removed extraneous CMU CR
 * 	[1995/01/26  20:24:45  ezf]
 * 
 * Revision 1.3.17.4  1995/01/10  04:51:04  devrcs
 * 	mk6 CR801 - merge up from nmk18b4 to nmk18b7
 * 	* Rev 1.3.17.3  1994/10/21  18:41:39  joe
 * 	  Added ETAP support
 * 	[1994/12/09  20:37:48  dwm]
 * 
 * 	mk6 CR764 - s/spinlock/simple_lock/ (name change only)
 * 	[1994/11/10  05:25:33  dwm]
 * 
 * 	mk6 CR668 - 1.3b26 merge
 * 	* Revision 1.3.5.8  1994/05/06  18:44:06  tmt
 * 	Fix prototypes for new device signatures.
 * 	* Revision 1.3.5.6  1993/12/10  18:08:15  jeffc
 * 	CR10305 -- locking bug in himem_reserve(): change call to
 * 	vm_page_free to VM_PAGE_FREE.
 * 	* Revision 1.3.5.5  1993/11/19  17:56:58  jeffc
 * 	CR10125 -- Uninitialized lock in himem_convert. Add himem_init
 * 	CR9461 -- Locking bug in himem_convert - must retake lock after
 * 	thread_sleep.
 * 	* End1.3merge
 * 	[1994/11/04  09:07:39  dwm]
 * 
 * Revision 1.3.17.1  1994/06/14  03:04:20  toshi
 * 	Merge MK6 and NMK17
 * 	[1994/06/14  01:06:55  toshi]
 * 
 * Revision 1.3.15.2  1994/06/08  21:14:24  dswartz
 * 	Preemption merge.
 * 	[1994/06/08  21:12:29  dswartz]
 * 
 * Revision 1.3.15.1  1994/05/19  20:30:23  dwm
 * 	mk6 CR 74.  Locking bug in himem_reserve(): use VM_PAGE_FREE.
 * 	mk6 CR 9461.  Init hil_lock used by himem_convert();
 * 	retake lock after sleeping.
 * 	[1994/05/19  20:30:07  dwm]
 * 
 * Revision 1.3.11.1  1994/02/09  07:27:07  bernadat
 * 	Added himem_init() for module initialization.
 * 	[93/08/12            paire]
 * 
 * 	Take back hil_lock lock on return from thread_sleep()
 * 	[93/07/16            bernadat]
 * 
 * 	Add vm_page_gobble() calls where needed. (dwm bug #542)
 * 	Change from NORMA_MK14.6 [1993/02/09  22:24:00  dwm]
 * 	[93/07/16            bernadat]
 * 	[94/02/08            bernadat]
 * 
 * Revision 1.3.5.4  1993/08/09  19:37:19  dswartz
 * 	Add ANSI prototypes - CR#9523
 * 	[1993/08/06  17:50:02  dswartz]
 * 
 * Revision 1.3.5.3  1993/08/03  22:21:26  bernard
 * 	CR#9523 - ANSI prototype fixes.
 * 	[1993/08/03  15:34:10  bernard]
 * 
 * Revision 1.3.5.2  1993/06/09  02:25:18  gm
 * 	CR9157 - Find himem.h in the right place.
 * 	[1993/05/28  17:27:23  brezak]
 * 
 * Revision 1.3  1993/04/19  16:09:46  devrcs
 * 	make endif tags ansi compliant/include files
 * 	[1993/02/20  21:46:44  david]
 * 
 * 	Print an appropriate message when going out of HIMEM pages.
 * 	[93/01/26            bernadat]
 * 
 * Revision 1.2  1992/11/25  01:07:08  robert
 * 	integrate changes below for norma_14
 * 	[1992/11/13  19:28:44  robert]
 * 
 * $EndLog$
 */

/*
 * support of memory above 16 Megs for DMA limited to memory
 * below 16 Megs. Copies high memory lo low memory before DMA
 * write operations and does the reverse at completion time for
 * DMA read operations
 */

#include <cpus.h>
#include <platforms.h>
#include <kern/lock.h>
#include <mach/vm_param.h>
#include <vm/vm_page.h>
#include <i386/AT386/himem.h>
#include <kern/kalloc.h>
#include <kern/spl.h>
#include <mach/boolean.h>
#include <kern/misc_protos.h>
#include <i386/AT386/misc_protos.h>
#include <i386/pmap.h>

hil_t		hil_head;
decl_simple_lock_data(,hil_lock)

#if	HIMEM_STATS
int himem_request;	/* number of requests */
int himem_used;		/* number of times used */
#endif	/* HIMEM_STATS */

void
himem_init(
	void)
{
	simple_lock_init(&hil_lock, 0);
}

/* 
 * Called by drivers, this indicates himem that this driver might need
 * to allocate as many as npages pages in a single I/O DMA transfer
 */

void
himem_reserve(
	int		npages)
{
	register		i = 0;
	vm_page_t		free_head = VM_PAGE_NULL;
	vm_page_t		low;
	hil_t			hil;
	spl_t			ipl;
	extern pmap_paddr_t_t	avail_end;

	if (avail_end <= HIGH_MEM)
		return;
	kprintf("looking for low mem pages\n");
	hil = (hil_t)kalloc(npages*sizeof(struct himem_link));
	if (hil == (hil_t)0) 
		panic("himem_reserve: kalloc failed\n");

	for (i=0; i < npages-1; i++)
		(hil+i)->next = hil+i+1;

	/*
	 * This is the only way of getting low physical pages 
	 * wtithout changing VM internals
	 */
	for (i=0; i != npages;) {
		if ((low = vm_page_grab()) == VM_PAGE_NULL)
			panic("No low memory pages for himem\n");
		vm_page_gobble(low); /* mark as consumed internally */
		if (_high_mem_page(low->phys_addr)) {
			low->pageq.next = (queue_entry_t)free_head;
			free_head = low;
		} else {
			(hil+i)->low_page = low->phys_addr;
			i++;
		}
	}
	kprintf("freeing high pages back\n");
	for (low = free_head; low; low = free_head) {
		free_head = (vm_page_t) low->pageq.next;
		VM_PAGE_FREE(low);
        }

	ipl = splhi();
	simple_lock(&hil_lock);
	(hil+npages-1)->next = hil_head;
	hil_head = hil;
	simple_unlock(&hil_lock);
	splx(ipl);
}

/*
 * Called by driver at DMA initialization time. Converts a high memory
 * physical page to a low memory one. If operation is a write, 
 * [phys_addr, phys_addr+length-1] is copied to new page. Caller must
 * provide a pointer to a pointer to a himem_list. This is used to store
 * all the conversions and is use at completion time to revert the pages.
 * This pointer must point to a null hil_t value for the call on the first
 * page of a DMA transfer.
 */

vm_offset_t
himem_convert(
	vm_offset_t	phys_addr,
	vm_size_t	length,
	int		io_op,
	hil_t		*hil)
{
	hil_t		h;
	spl_t		ipl;
	vm_offset_t	offset = phys_addr & (I386_PGBYTES - 1);

	assert (offset + length <= I386_PGBYTES);

	ipl = splhi();
	simple_lock(&hil_lock);
	while (!(h = hil_head)) { 
		printf("WARNING: out of HIMEM pages\n");
		thread_sleep_simple_lock((event_t)&hil_head,
					 simple_lock_addr(hil_lock),
					 THREAD_UNINT);
		/* hil_lock relocked */
	}
	hil_head = hil_head->next;
	simple_unlock(&hil_lock);
	splx(ipl);
	
	h->high_addr = phys_addr;

	if (io_op == D_WRITE) {
	  bcopy_phys((addr64_t)phys_addr, (addr64_t)(h->low_page + offset),
		length);
	  h->length = 0;
	} else {
	  h->length = length;
	}
	h->offset = offset;

	assert(!*hil || (*hil)->high_addr);

	h->next = *hil;
	*hil = h;
	return(h->low_page + offset);
}

/*
 * Called by driver at DMA completion time. Converts a list of low memory
 * physical page to the original high memory one. If operation was read, 
 * [phys_addr, phys_addr+lenght-1] is copied to original page
 */

void
himem_revert(
	hil_t		hil)
{
	hil_t		next;
	boolean_t	wakeup = FALSE;
	spl_t		ipl;

	while(hil) {
		if (hil->length) {
			bcopy_phys((addr64_t)hil->low_page + hil->offset),
				(addr64_t)(hil->high_addr),
			      hil->length);
		}
		hil->high_addr = 0;
		hil->length = 0;
		hil->offset = 0;
		next = hil->next;
		ipl = splhi();
		simple_lock(&hil_lock);
		if (!(hil->next = hil_head))
			wakeup = TRUE;
		hil_head = hil;
		simple_unlock(&hil_lock);
		splx(ipl);
		hil = next;
	}
	if (wakeup)
		thread_wakeup((event_t)&hil_head);
}