[apple/xnu.git] / iokit / Kernel / IOLib.c

/*
 * Copyright (c) 1998-2002 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * Copyright (c) 1999-2003 Apple Computer, Inc.  All Rights Reserved.
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The 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, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*
 * HISTORY
 *
 * 17-Apr-91   Portions from libIO.m, Doug Mitchell at NeXT.
 * 17-Nov-98   cpp
 *
 */

#include <IOKit/system.h>
#include <mach/sync_policy.h>
#include <machine/machine_routines.h>
#include <libkern/c++/OSCPPDebug.h>

#include <IOKit/assert.h>

#include <IOKit/IOReturn.h>
#include <IOKit/IOLib.h> 
#include <IOKit/IOKitDebug.h> 

mach_timespec_t IOZeroTvalspec = { 0, 0 };


/*
 * Global variables for use by iLogger
 * These symbols are for use only by Apple diagnostic code.
 * Binary compatibility is not guaranteed for kexts that reference these symbols.
 */

void *_giDebugLogInternal	= NULL;
void *_giDebugLogDataInternal	= NULL;
void *_giDebugReserved1		= NULL;
void *_giDebugReserved2		= NULL;


/*
 * Static variables for this module.
 */

static IOThreadFunc threadArgFcn;
static void * threadArgArg;
static lock_t * threadArgLock;


enum { kIOMaxPageableMaps = 16 };
enum { kIOPageableMapSize = 16 * 1024 * 1024 };
enum { kIOPageableMaxMapSize = 64 * 1024 * 1024 };

typedef struct {
    vm_map_t	map;
    vm_offset_t	address;
    vm_offset_t	end;
} IOMapData;

static struct {
    UInt32	count;
    UInt32	hint;
    IOMapData	maps[ kIOMaxPageableMaps ];
    mutex_t *	lock;
} gIOKitPageableSpace;


void IOLibInit(void)
{
    kern_return_t ret;

    static bool libInitialized;

    if(libInitialized)
        return;	

    threadArgLock = lock_alloc( true, NULL, NULL );

    gIOKitPageableSpace.maps[0].address = 0;
    ret = kmem_suballoc(kernel_map,
                    &gIOKitPageableSpace.maps[0].address,
                    kIOPageableMapSize,
                    TRUE,
                    TRUE,
                    &gIOKitPageableSpace.maps[0].map);
    if (ret != KERN_SUCCESS)
        panic("failed to allocate iokit pageable map\n");

    gIOKitPageableSpace.lock 		= mutex_alloc( 0 );
    gIOKitPageableSpace.maps[0].end	= gIOKitPageableSpace.maps[0].address + kIOPageableMapSize;
    gIOKitPageableSpace.hint		= 0;
    gIOKitPageableSpace.count		= 1;

    libInitialized = true;
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

/*
 * We pass an argument to a new thread by saving fcn and arg in some
 * locked variables and starting the thread at ioThreadStart(). This
 * function retrives fcn and arg and makes the appropriate call.
 *
 */

static void ioThreadStart( void )
{
    IOThreadFunc	fcn;
    void * 		arg;

    fcn = threadArgFcn;
    arg = threadArgArg;
    lock_done( threadArgLock);

    (*fcn)(arg);

    IOExitThread();
}

IOThread IOCreateThread(IOThreadFunc fcn, void *arg)
{
	IOThread thread;

	lock_write( threadArgLock);
	threadArgFcn = fcn;
	threadArgArg = arg;

	thread = kernel_thread( kernel_task, ioThreadStart);

	return(thread);
}


volatile void IOExitThread()
{
	(void) thread_terminate(current_act());
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */


void * IOMalloc(vm_size_t size)
{
    void * address;

    address = (void *)kalloc(size);
#if IOALLOCDEBUG
    if (address)
	debug_iomalloc_size += size;
#endif
    return address;
}

void IOFree(void * address, vm_size_t size)
{
    if (address) {
	kfree((vm_offset_t)address, size);
#if IOALLOCDEBUG
	debug_iomalloc_size -= size;
#endif
    }
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

void * IOMallocAligned(vm_size_t size, vm_size_t alignment)
{
    kern_return_t	kr;
    vm_address_t	address;
    vm_address_t	allocationAddress;
    vm_size_t		adjustedSize;
    vm_offset_t		alignMask;

    if (size == 0)
        return 0;
    if (alignment == 0) 
        alignment = 1;

    alignMask = alignment - 1;
    adjustedSize = size + sizeof(vm_size_t) + sizeof(vm_address_t);

    if (adjustedSize >= page_size) {

        kr = kernel_memory_allocate(kernel_map, &address,
					size, alignMask, 0);
	if (KERN_SUCCESS != kr)
	    address = 0;

    } else {

	adjustedSize += alignMask;

	if (adjustedSize >= page_size) {

	    kr = kernel_memory_allocate(kernel_map, &allocationAddress,
					    adjustedSize, 0, 0);
	    if (KERN_SUCCESS != kr)
		allocationAddress = 0;

	} else
	    allocationAddress = (vm_address_t) kalloc(adjustedSize);

        if (allocationAddress) {
            address = (allocationAddress + alignMask
                    + (sizeof(vm_size_t) + sizeof(vm_address_t)))
                    & (~alignMask);

            *((vm_size_t *)(address - sizeof(vm_size_t)
                            - sizeof(vm_address_t))) = adjustedSize;
            *((vm_address_t *)(address - sizeof(vm_address_t)))
                            = allocationAddress;
	} else
	    address = 0;
    }

    assert(0 == (address & alignMask));

#if IOALLOCDEBUG
    if( address)
	debug_iomalloc_size += size;
#endif

    return (void *) address;
}

void IOFreeAligned(void * address, vm_size_t size)
{
    vm_address_t	allocationAddress;
    vm_size_t		adjustedSize;

    if( !address)
	return;

    assert(size);

    adjustedSize = size + sizeof(vm_size_t) + sizeof(vm_address_t);
    if (adjustedSize >= page_size) {

        kmem_free( kernel_map, (vm_address_t) address, size);

    } else {
        adjustedSize = *((vm_size_t *)( (vm_address_t) address
                                - sizeof(vm_address_t) - sizeof(vm_size_t)));
        allocationAddress = *((vm_address_t *)( (vm_address_t) address
				- sizeof(vm_address_t) ));

	if (adjustedSize >= page_size)
	    kmem_free( kernel_map, (vm_address_t) allocationAddress, adjustedSize);
	else
	    kfree((vm_offset_t) allocationAddress, adjustedSize);
    }

#if IOALLOCDEBUG
    debug_iomalloc_size -= size;
#endif
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

void * IOMallocContiguous(vm_size_t size, vm_size_t alignment,
			   IOPhysicalAddress * physicalAddress)
{
    kern_return_t	kr;
    vm_address_t	address;
    vm_address_t	allocationAddress;
    vm_size_t		adjustedSize;
    vm_offset_t		alignMask;

    if (size == 0)
        return 0;
    if (alignment == 0) 
        alignment = 1;

    alignMask = alignment - 1;
    adjustedSize = (2 * size) + sizeof(vm_size_t) + sizeof(vm_address_t);

    if (adjustedSize >= page_size) {

        kr = kmem_alloc_contig(kernel_map, &address, size,
				alignMask, 0);
	if (KERN_SUCCESS != kr)
	    address = 0;

    } else {

	adjustedSize += alignMask;
        allocationAddress = (vm_address_t) kalloc(adjustedSize);

        if (allocationAddress) {

            address = (allocationAddress + alignMask
                    + (sizeof(vm_size_t) + sizeof(vm_address_t)))
                    & (~alignMask);

            if (atop(address) != atop(address + size - 1))
                address = round_page(address);

            *((vm_size_t *)(address - sizeof(vm_size_t)
                            - sizeof(vm_address_t))) = adjustedSize;
            *((vm_address_t *)(address - sizeof(vm_address_t)))
                            = allocationAddress;
	} else
	    address = 0;
    }

    if( address && physicalAddress)
	*physicalAddress = (IOPhysicalAddress) pmap_extract( kernel_pmap,
								 address );

    assert(0 == (address & alignMask));

#if IOALLOCDEBUG
    if( address)
	debug_iomalloc_size += size;
#endif

    return (void *) address;
}

void IOFreeContiguous(void * address, vm_size_t size)
{
    vm_address_t	allocationAddress;
    vm_size_t		adjustedSize;

    if( !address)
	return;

    assert(size);

    adjustedSize = (2 * size) + sizeof(vm_size_t) + sizeof(vm_address_t);
    if (adjustedSize >= page_size) {

        kmem_free( kernel_map, (vm_address_t) address, size);

    } else {
        adjustedSize = *((vm_size_t *)( (vm_address_t) address
                                - sizeof(vm_address_t) - sizeof(vm_size_t)));
        allocationAddress = *((vm_address_t *)( (vm_address_t) address
				- sizeof(vm_address_t) ));

        kfree((vm_offset_t) allocationAddress, adjustedSize);
    }

#if IOALLOCDEBUG
    debug_iomalloc_size -= size;
#endif
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

typedef kern_return_t (*IOIteratePageableMapsCallback)(vm_map_t map, void * ref);

kern_return_t IOIteratePageableMaps(vm_size_t size,
                    IOIteratePageableMapsCallback callback, void * ref)
{
    kern_return_t	kr = kIOReturnNotReady;
    vm_size_t		segSize;
    UInt32		attempts;
    UInt32		index;
    vm_offset_t		min;
    vm_map_t		map;

    if (size > kIOPageableMaxMapSize)
        return( kIOReturnBadArgument );

    do {
        index = gIOKitPageableSpace.hint;
        attempts = gIOKitPageableSpace.count;
        while( attempts--) {
            kr = (*callback)(gIOKitPageableSpace.maps[index].map, ref);
            if( KERN_SUCCESS == kr) {
                gIOKitPageableSpace.hint = index;
                break;
            }
            if( index)
                index--;
            else
                index = gIOKitPageableSpace.count - 1;
        }
        if( KERN_SUCCESS == kr)
            break;

        mutex_lock( gIOKitPageableSpace.lock );

        index = gIOKitPageableSpace.count;
        if( index >= (kIOMaxPageableMaps - 1)) {
            mutex_unlock( gIOKitPageableSpace.lock );
            break;
        }

        if( size < kIOPageableMapSize)
            segSize = kIOPageableMapSize;
        else
            segSize = size;

        min = 0;
        kr = kmem_suballoc(kernel_map,
                    &min,
                    segSize,
                    TRUE,
                    TRUE,
                    &map);
        if( KERN_SUCCESS != kr) {
            mutex_unlock( gIOKitPageableSpace.lock );
            break;
        }

        gIOKitPageableSpace.maps[index].map 	= map;
        gIOKitPageableSpace.maps[index].address = min;
        gIOKitPageableSpace.maps[index].end 	= min + segSize;
        gIOKitPageableSpace.hint 		= index;
        gIOKitPageableSpace.count 		= index + 1;

        mutex_unlock( gIOKitPageableSpace.lock );

    } while( true );

    return kr;
}

struct IOMallocPageableRef
{
    vm_address_t address;
    vm_size_t	 size;
};

static kern_return_t IOMallocPageableCallback(vm_map_t map, void * _ref)
{
    struct IOMallocPageableRef * ref = (struct IOMallocPageableRef *) _ref;
    kern_return_t	         kr;

    kr = kmem_alloc_pageable( map, &ref->address, ref->size );

    return( kr );
}

void * IOMallocPageable(vm_size_t size, vm_size_t alignment)
{
    kern_return_t	       kr = kIOReturnNotReady;
    struct IOMallocPageableRef ref;

    if (alignment > page_size)
        return( 0 );
    if (size > kIOPageableMaxMapSize)
        return( 0 );

    ref.size = size;
    kr = IOIteratePageableMaps( size, &IOMallocPageableCallback, &ref );
    if( kIOReturnSuccess != kr)
        ref.address = 0;

#if IOALLOCDEBUG
    if( ref.address)
       debug_iomalloc_size += round_page(size);
#endif

    return( (void *) ref.address );
}

vm_map_t IOPageableMapForAddress( vm_address_t address )
{
    vm_map_t	map = 0;
    UInt32	index;
    
    for( index = 0; index < gIOKitPageableSpace.count; index++) {
        if( (address >= gIOKitPageableSpace.maps[index].address)
         && (address < gIOKitPageableSpace.maps[index].end) ) {
            map = gIOKitPageableSpace.maps[index].map;
            break;
        }
    }
    if( !map)
        IOPanic("IOPageableMapForAddress: null");

    return( map );
}

void IOFreePageable(void * address, vm_size_t size)
{
    vm_map_t map;
    
    map = IOPageableMapForAddress( (vm_address_t) address);
    if( map)
        kmem_free( map, (vm_offset_t) address, size);

#if IOALLOCDEBUG
    debug_iomalloc_size -= round_page(size);
#endif
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

extern kern_return_t IOMapPages(vm_map_t map, vm_offset_t va, vm_offset_t pa,
			vm_size_t length, unsigned int options);

IOReturn IOSetProcessorCacheMode( task_t task, IOVirtualAddress address,
				  IOByteCount length, IOOptionBits cacheMode )
{
    IOReturn	ret = kIOReturnSuccess;
    vm_offset_t	physAddr;

    if( task != kernel_task)
	return( kIOReturnUnsupported );

    length = round_page(address + length) - trunc_page( address );
    address = trunc_page( address );

    // make map mode
    cacheMode = (cacheMode << kIOMapCacheShift) & kIOMapCacheMask;

    while( (kIOReturnSuccess == ret) && (length > 0) ) {

	physAddr = pmap_extract( kernel_pmap, address );
	if( physAddr)
            ret = IOMapPages( get_task_map(task), address, physAddr, page_size, cacheMode );
	else
	    ret = kIOReturnVMError;

	length -= page_size;
    }

    return( ret );
}


IOReturn IOFlushProcessorCache( task_t task, IOVirtualAddress address,
				  IOByteCount length )
{
    if( task != kernel_task)
	return( kIOReturnUnsupported );

#if __ppc__
    flush_dcache( (vm_offset_t) address, (unsigned) length, false );
#endif

    return( kIOReturnSuccess );
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

SInt32 OSKernelStackRemaining( void )
{
   SInt32 stack;

   stack = (((SInt32) &stack) & (KERNEL_STACK_SIZE - 1));

   return( stack );
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

void IOSleep(unsigned milliseconds)
{
    wait_result_t wait_result;

    wait_result = assert_wait_timeout(milliseconds, THREAD_UNINT);
    assert(wait_result == THREAD_WAITING);

    wait_result = thread_block(THREAD_CONTINUE_NULL);
    assert(wait_result == THREAD_TIMED_OUT);
}

/*
 * Spin for indicated number of microseconds.
 */
void IODelay(unsigned microseconds)
{
    extern void delay(int usec);

    delay(microseconds);
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

void IOLog(const char *format, ...)
{
	va_list ap;
	extern void conslog_putc(char);
	extern void logwakeup();

	va_start(ap, format);
	_doprnt(format, &ap, conslog_putc, 16);
	va_end(ap);
}

void IOPanic(const char *reason)
{
	panic(reason);
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

/*
 * Convert a integer constant (typically a #define or enum) to a string.
 */
static char noValue[80];	// that's pretty

const char *IOFindNameForValue(int value, const IONamedValue *regValueArray)
{
	for( ; regValueArray->name; regValueArray++) {
		if(regValueArray->value == value)
			return(regValueArray->name);
	}
	sprintf(noValue, "0x%x (UNDEFINED)", value);
	return((const char *)noValue);
}

IOReturn IOFindValueForName(const char *string, 
	const IONamedValue *regValueArray,
	int *value)
{
	for( ; regValueArray->name; regValueArray++) {
		if(!strcmp(regValueArray->name, string)) {
			*value = regValueArray->value;
			return kIOReturnSuccess;
		}
	}
	return kIOReturnBadArgument;
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

IOAlignment IOSizeToAlignment(unsigned int size)
{
    register int shift;
    const int intsize = sizeof(unsigned int) * 8;
    
    for (shift = 1; shift < intsize; shift++) {
	if (size & 0x80000000)
	    return (IOAlignment)(intsize - shift);
	size <<= 1;
    }
    return 0;
}

unsigned int IOAlignmentToSize(IOAlignment align)
{
    unsigned int size;
    
    for (size = 1; align; align--) {
	size <<= 1;
    }
    return size;
}

IOReturn IONDRVLibrariesInitialize( void )
{
    return( kIOReturnUnsupported );
}
Commit	Line	Data
1c79356b	1	/*
9bccf70c	2	* Copyright (c) 1998-2002 Apple Computer, Inc. All rights reserved.
1c79356b A	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
43866e37	6	* Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved.
1c79356b	7	*
43866e37 A	8	* This file contains Original Code and/or Modifications of Original Code
	9	* as defined in and that are subject to the Apple Public Source License
	10	* Version 2.0 (the 'License'). You may not use this file except in
	11	* compliance with the License. Please obtain a copy of the License at
	12	* http://www.opensource.apple.com/apsl/ and read it before using this
	13	* file.
	14	*
	15	* The Original Code and all software distributed under the License are
	16	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
1c79356b A	17	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
1c79356b A	18	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
43866e37 A	19	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	20	* Please see the License for the specific language governing rights and
	21	* limitations under the License.
1c79356b A	22	*
	23	* @APPLE_LICENSE_HEADER_END@
	24	*/
	25	/*
1c79356b A	26	* HISTORY
	27	*
	28	* 17-Apr-91 Portions from libIO.m, Doug Mitchell at NeXT.
	29	* 17-Nov-98 cpp
	30	*
	31	*/
	32
	33	#include <IOKit/system.h>
	34	#include <mach/sync_policy.h>
	35	#include <machine/machine_routines.h>
	36	#include <libkern/c++/OSCPPDebug.h>
	37
	38	#include <IOKit/assert.h>
	39
	40	#include <IOKit/IOReturn.h>
	41	#include <IOKit/IOLib.h>
	42	#include <IOKit/IOKitDebug.h>
	43
	44	mach_timespec_t IOZeroTvalspec = { 0, 0 };
	45
9bccf70c A	46
	47	/*
	48	* Global variables for use by iLogger
	49	* These symbols are for use only by Apple diagnostic code.
	50	* Binary compatibility is not guaranteed for kexts that reference these symbols.
	51	*/
	52
	53	void *_giDebugLogInternal = NULL;
	54	void *_giDebugLogDataInternal = NULL;
	55	void *_giDebugReserved1 = NULL;
	56	void *_giDebugReserved2 = NULL;
	57
	58
1c79356b A	59	/*
	60	* Static variables for this module.
	61	*/
	62
	63	static IOThreadFunc threadArgFcn;
de355530 A	64	static void * threadArgArg;
de355530 A	65	static lock_t * threadArgLock;
1c79356b A	66
	67
	68	enum { kIOMaxPageableMaps = 16 };
	69	enum { kIOPageableMapSize = 16 * 1024 * 1024 };
0b4e3aa0	70	enum { kIOPageableMaxMapSize = 64 * 1024 * 1024 };
1c79356b A	71
	72	typedef struct {
	73	vm_map_t map;
	74	vm_offset_t address;
	75	vm_offset_t end;
	76	} IOMapData;
	77
	78	static struct {
	79	UInt32 count;
	80	UInt32 hint;
	81	IOMapData maps[ kIOMaxPageableMaps ];
	82	mutex_t * lock;
	83	} gIOKitPageableSpace;
	84
	85
	86	void IOLibInit(void)
	87	{
	88	kern_return_t ret;
	89
	90	static bool libInitialized;
	91
	92	if(libInitialized)
	93	return;
	94
	95	threadArgLock = lock_alloc( true, NULL, NULL );
	96
	97	gIOKitPageableSpace.maps[0].address = 0;
	98	ret = kmem_suballoc(kernel_map,
	99	&gIOKitPageableSpace.maps[0].address,
	100	kIOPageableMapSize,
	101	TRUE,
	102	TRUE,
	103	&gIOKitPageableSpace.maps[0].map);
	104	if (ret != KERN_SUCCESS)
	105	panic("failed to allocate iokit pageable map\n");
	106
	107	gIOKitPageableSpace.lock = mutex_alloc( 0 );
	108	gIOKitPageableSpace.maps[0].end = gIOKitPageableSpace.maps[0].address + kIOPageableMapSize;
	109	gIOKitPageableSpace.hint = 0;
	110	gIOKitPageableSpace.count = 1;
	111
	112	libInitialized = true;
	113	}
	114
	115	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	116
	117	/*
	118	* We pass an argument to a new thread by saving fcn and arg in some
	119	* locked variables and starting the thread at ioThreadStart(). This
	120	* function retrives fcn and arg and makes the appropriate call.
	121	*
	122	*/
	123
	124	static void ioThreadStart( void )
	125	{
	126	IOThreadFunc fcn;
	127	void * arg;
	128
	129	fcn = threadArgFcn;
	130	arg = threadArgArg;
	131	lock_done( threadArgLock);
	132
	133	(*fcn)(arg);
	134
135	IOExitThread();
136	}
137
138	IOThread IOCreateThread(IOThreadFunc fcn, void *arg)
139	{
140	IOThread thread;
141
142	lock_write( threadArgLock);
143	threadArgFcn = fcn;
144	threadArgArg = arg;
145
146	thread = kernel_thread( kernel_task, ioThreadStart);
147
148	return(thread);
149	}
150
151
152	volatile void IOExitThread()
153	{
154	(void) thread_terminate(current_act());
155	}
156
157	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
158
159
160	void * IOMalloc(vm_size_t size)
161	{
162	void * address;
163
164	address = (void *)kalloc(size);
165	#if IOALLOCDEBUG
166	if (address)
167	debug_iomalloc_size += size;
168	#endif
169	return address;
170	}
171
172	void IOFree(void * address, vm_size_t size)
173	{
174	if (address) {
175	kfree((vm_offset_t)address, size);
176	#if IOALLOCDEBUG
177	debug_iomalloc_size -= size;
178	#endif
179	}
180	}
181
182	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
183
184	void * IOMallocAligned(vm_size_t size, vm_size_t alignment)
185	{
186	kern_return_t kr;
187	vm_address_t address;
188	vm_address_t allocationAddress;
189	vm_size_t adjustedSize;
190	vm_offset_t alignMask;
191
192	if (size == 0)
193	return 0;
194	if (alignment == 0)
195	alignment = 1;
196
197	alignMask = alignment - 1;
198	adjustedSize = size + sizeof(vm_size_t) + sizeof(vm_address_t);
199
200	if (adjustedSize >= page_size) {
201
202	kr = kernel_memory_allocate(kernel_map, &address,
9bccf70c A	203	size, alignMask, 0);
9bccf70c A	204	if (KERN_SUCCESS != kr)
1c79356b	205	address = 0;
1c79356b A	206
	207	} else {
	208
	209	adjustedSize += alignMask;
9bccf70c A	210
	211	if (adjustedSize >= page_size) {
	212
	213	kr = kernel_memory_allocate(kernel_map, &allocationAddress,
	214	adjustedSize, 0, 0);
	215	if (KERN_SUCCESS != kr)
	216	allocationAddress = 0;
	217
	218	} else
	219	allocationAddress = (vm_address_t) kalloc(adjustedSize);
1c79356b A	220
	221	if (allocationAddress) {
	222	address = (allocationAddress + alignMask
	223	+ (sizeof(vm_size_t) + sizeof(vm_address_t)))
	224	& (~alignMask);
	225
	226	((vm_size_t )(address - sizeof(vm_size_t)
	227	- sizeof(vm_address_t))) = adjustedSize;
	228	((vm_address_t )(address - sizeof(vm_address_t)))
	229	= allocationAddress;
	230	} else
	231	address = 0;
	232	}
	233
	234	assert(0 == (address & alignMask));
	235
	236	#if IOALLOCDEBUG
	237	if( address)
	238	debug_iomalloc_size += size;
	239	#endif
	240
	241	return (void *) address;
	242	}
	243
	244	void IOFreeAligned(void * address, vm_size_t size)
	245	{
	246	vm_address_t allocationAddress;
	247	vm_size_t adjustedSize;
	248
	249	if( !address)
	250	return;
	251
	252	assert(size);
	253
	254	adjustedSize = size + sizeof(vm_size_t) + sizeof(vm_address_t);
	255	if (adjustedSize >= page_size) {
	256
	257	kmem_free( kernel_map, (vm_address_t) address, size);
	258
	259	} else {
	260	adjustedSize = ((vm_size_t )( (vm_address_t) address
	261	- sizeof(vm_address_t) - sizeof(vm_size_t)));
	262	allocationAddress = ((vm_address_t )( (vm_address_t) address
	263	- sizeof(vm_address_t) ));
	264
9bccf70c A	265	if (adjustedSize >= page_size)
	266	kmem_free( kernel_map, (vm_address_t) allocationAddress, adjustedSize);
	267	else
	268	kfree((vm_offset_t) allocationAddress, adjustedSize);
1c79356b A	269	}
	270
	271	#if IOALLOCDEBUG
	272	debug_iomalloc_size -= size;
	273	#endif
	274	}
	275
	276	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	277
	278	void * IOMallocContiguous(vm_size_t size, vm_size_t alignment,
	279	IOPhysicalAddress * physicalAddress)
	280	{
	281	kern_return_t kr;
	282	vm_address_t address;
	283	vm_address_t allocationAddress;
	284	vm_size_t adjustedSize;
	285	vm_offset_t alignMask;
	286
	287	if (size == 0)
	288	return 0;
	289	if (alignment == 0)
	290	alignment = 1;
	291
	292	alignMask = alignment - 1;
	293	adjustedSize = (2 * size) + sizeof(vm_size_t) + sizeof(vm_address_t);
	294
de355530 A	295	if (adjustedSize >= page_size) {
	296
	297	kr = kmem_alloc_contig(kernel_map, &address, size,
	298	alignMask, 0);
1c79356b A	299	if (KERN_SUCCESS != kr)
1c79356b A	300	address = 0;
de355530 A	301
	302	} else {
	303
1c79356b	304	adjustedSize += alignMask;
9bccf70c A	305	allocationAddress = (vm_address_t) kalloc(adjustedSize);
9bccf70c A	306
1c79356b A	307	if (allocationAddress) {
	308
	309	address = (allocationAddress + alignMask
	310	+ (sizeof(vm_size_t) + sizeof(vm_address_t)))
	311	& (~alignMask);
	312
de355530 A	313	if (atop(address) != atop(address + size - 1))
de355530 A	314	address = round_page(address);
1c79356b A	315
	316	((vm_size_t )(address - sizeof(vm_size_t)
	317	- sizeof(vm_address_t))) = adjustedSize;
	318	((vm_address_t )(address - sizeof(vm_address_t)))
	319	= allocationAddress;
	320	} else
	321	address = 0;
	322	}
	323
de355530 A	324	if( address && physicalAddress)
	325	*physicalAddress = (IOPhysicalAddress) pmap_extract( kernel_pmap,
	326	address );
1c79356b A	327
	328	assert(0 == (address & alignMask));
	329
	330	#if IOALLOCDEBUG
	331	if( address)
	332	debug_iomalloc_size += size;
	333	#endif
	334
	335	return (void *) address;
	336	}
	337
	338	void IOFreeContiguous(void * address, vm_size_t size)
	339	{
de355530 A	340	vm_address_t allocationAddress;
de355530 A	341	vm_size_t adjustedSize;
1c79356b A	342
	343	if( !address)
	344	return;
	345
	346	assert(size);
	347
	348	adjustedSize = (2 * size) + sizeof(vm_size_t) + sizeof(vm_address_t);
	349	if (adjustedSize >= page_size) {
	350
	351	kmem_free( kernel_map, (vm_address_t) address, size);
	352
	353	} else {
	354	adjustedSize = ((vm_size_t )( (vm_address_t) address
	355	- sizeof(vm_address_t) - sizeof(vm_size_t)));
	356	allocationAddress = ((vm_address_t )( (vm_address_t) address
	357	- sizeof(vm_address_t) ));
	358
	359	kfree((vm_offset_t) allocationAddress, adjustedSize);
	360	}
	361
	362	#if IOALLOCDEBUG
	363	debug_iomalloc_size -= size;
	364	#endif
	365	}
	366
	367	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	368
0b4e3aa0 A	369	typedef kern_return_t (IOIteratePageableMapsCallback)(vm_map_t map, void ref);
	370
	371	kern_return_t IOIteratePageableMaps(vm_size_t size,
	372	IOIteratePageableMapsCallback callback, void * ref)
1c79356b A	373	{
1c79356b A	374	kern_return_t kr = kIOReturnNotReady;
1c79356b A	375	vm_size_t segSize;
	376	UInt32 attempts;
	377	UInt32 index;
	378	vm_offset_t min;
	379	vm_map_t map;
	380
1c79356b	381	if (size > kIOPageableMaxMapSize)
0b4e3aa0	382	return( kIOReturnBadArgument );
1c79356b A	383
	384	do {
	385	index = gIOKitPageableSpace.hint;
	386	attempts = gIOKitPageableSpace.count;
	387	while( attempts--) {
0b4e3aa0	388	kr = (*callback)(gIOKitPageableSpace.maps[index].map, ref);
1c79356b A	389	if( KERN_SUCCESS == kr) {
	390	gIOKitPageableSpace.hint = index;
	391	break;
	392	}
	393	if( index)
	394	index--;
	395	else
	396	index = gIOKitPageableSpace.count - 1;
	397	}
	398	if( KERN_SUCCESS == kr)
	399	break;
	400
	401	mutex_lock( gIOKitPageableSpace.lock );
	402
	403	index = gIOKitPageableSpace.count;
	404	if( index >= (kIOMaxPageableMaps - 1)) {
	405	mutex_unlock( gIOKitPageableSpace.lock );
	406	break;
	407	}
	408
	409	if( size < kIOPageableMapSize)
	410	segSize = kIOPageableMapSize;
	411	else
	412	segSize = size;
	413
	414	min = 0;
	415	kr = kmem_suballoc(kernel_map,
	416	&min,
	417	segSize,
	418	TRUE,
	419	TRUE,
	420	&map);
	421	if( KERN_SUCCESS != kr) {
	422	mutex_unlock( gIOKitPageableSpace.lock );
	423	break;
	424	}
	425
	426	gIOKitPageableSpace.maps[index].map = map;
	427	gIOKitPageableSpace.maps[index].address = min;
	428	gIOKitPageableSpace.maps[index].end = min + segSize;
	429	gIOKitPageableSpace.hint = index;
	430	gIOKitPageableSpace.count = index + 1;
	431
	432	mutex_unlock( gIOKitPageableSpace.lock );
	433
	434	} while( true );
	435
0b4e3aa0 A	436	return kr;
	437	}
	438
	439	struct IOMallocPageableRef
	440	{
	441	vm_address_t address;
	442	vm_size_t size;
	443	};
	444
	445	static kern_return_t IOMallocPageableCallback(vm_map_t map, void * _ref)
	446	{
	447	struct IOMallocPageableRef * ref = (struct IOMallocPageableRef *) _ref;
	448	kern_return_t kr;
	449
	450	kr = kmem_alloc_pageable( map, &ref->address, ref->size );
	451
	452	return( kr );
	453	}
	454
	455	void * IOMallocPageable(vm_size_t size, vm_size_t alignment)
	456	{
	457	kern_return_t kr = kIOReturnNotReady;
	458	struct IOMallocPageableRef ref;
	459
	460	if (alignment > page_size)
	461	return( 0 );
	462	if (size > kIOPageableMaxMapSize)
	463	return( 0 );
	464
	465	ref.size = size;
	466	kr = IOIteratePageableMaps( size, &IOMallocPageableCallback, &ref );
	467	if( kIOReturnSuccess != kr)
	468	ref.address = 0;
1c79356b A	469
1c79356b A	470	#if IOALLOCDEBUG
0b4e3aa0	471	if( ref.address)
de355530	472	debug_iomalloc_size += round_page(size);
1c79356b A	473	#endif
1c79356b A	474
0b4e3aa0	475	return( (void *) ref.address );
1c79356b A	476	}
	477
	478	vm_map_t IOPageableMapForAddress( vm_address_t address )
	479	{
	480	vm_map_t map = 0;
	481	UInt32 index;
	482
	483	for( index = 0; index < gIOKitPageableSpace.count; index++) {
	484	if( (address >= gIOKitPageableSpace.maps[index].address)
	485	&& (address < gIOKitPageableSpace.maps[index].end) ) {
	486	map = gIOKitPageableSpace.maps[index].map;
	487	break;
	488	}
	489	}
	490	if( !map)
	491	IOPanic("IOPageableMapForAddress: null");
	492
	493	return( map );
	494	}
	495
	496	void IOFreePageable(void * address, vm_size_t size)
	497	{
	498	vm_map_t map;
	499
	500	map = IOPageableMapForAddress( (vm_address_t) address);
	501	if( map)
	502	kmem_free( map, (vm_offset_t) address, size);
	503
	504	#if IOALLOCDEBUG
de355530	505	debug_iomalloc_size -= round_page(size);
1c79356b A	506	#endif
	507	}
	508
	509	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	510
	511	extern kern_return_t IOMapPages(vm_map_t map, vm_offset_t va, vm_offset_t pa,
	512	vm_size_t length, unsigned int options);
	513
	514	IOReturn IOSetProcessorCacheMode( task_t task, IOVirtualAddress address,
	515	IOByteCount length, IOOptionBits cacheMode )
	516	{
	517	IOReturn ret = kIOReturnSuccess;
de355530	518	vm_offset_t physAddr;
1c79356b A	519
	520	if( task != kernel_task)
	521	return( kIOReturnUnsupported );
	522
de355530 A	523	length = round_page(address + length) - trunc_page( address );
de355530 A	524	address = trunc_page( address );
1c79356b A	525
	526	// make map mode
	527	cacheMode = (cacheMode << kIOMapCacheShift) & kIOMapCacheMask;
	528
	529	while( (kIOReturnSuccess == ret) && (length > 0) ) {
	530
de355530 A	531	physAddr = pmap_extract( kernel_pmap, address );
	532	if( physAddr)
	533	ret = IOMapPages( get_task_map(task), address, physAddr, page_size, cacheMode );
	534	else
1c79356b A	535	ret = kIOReturnVMError;
	536
	537	length -= page_size;
	538	}
	539
	540	return( ret );
	541	}
	542
	543
	544	IOReturn IOFlushProcessorCache( task_t task, IOVirtualAddress address,
	545	IOByteCount length )
	546	{
	547	if( task != kernel_task)
	548	return( kIOReturnUnsupported );
	549
	550	#if __ppc__
de355530	551	flush_dcache( (vm_offset_t) address, (unsigned) length, false );
1c79356b A	552	#endif
	553
	554	return( kIOReturnSuccess );
	555	}
	556
	557	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	558
	559	SInt32 OSKernelStackRemaining( void )
	560	{
	561	SInt32 stack;
	562
	563	stack = (((SInt32) &stack) & (KERNEL_STACK_SIZE - 1));
	564
	565	return( stack );
	566	}
	567
	568	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	569
	570	void IOSleep(unsigned milliseconds)
	571	{
9bccf70c A	572	wait_result_t wait_result;
	573
	574	wait_result = assert_wait_timeout(milliseconds, THREAD_UNINT);
	575	assert(wait_result == THREAD_WAITING);
1c79356b	576
9bccf70c A	577	wait_result = thread_block(THREAD_CONTINUE_NULL);
9bccf70c A	578	assert(wait_result == THREAD_TIMED_OUT);
1c79356b A	579	}
	580
	581	/*
	582	* Spin for indicated number of microseconds.
	583	*/
	584	void IODelay(unsigned microseconds)
	585	{
	586	extern void delay(int usec);
	587
	588	delay(microseconds);
	589	}
	590
	591	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	592
	593	void IOLog(const char *format, ...)
	594	{
	595	va_list ap;
	596	extern void conslog_putc(char);
	597	extern void logwakeup();
	598
	599	va_start(ap, format);
	600	_doprnt(format, &ap, conslog_putc, 16);
	601	va_end(ap);
	602	}
	603
	604	void IOPanic(const char *reason)
	605	{
	606	panic(reason);
	607	}
	608
	609	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	610
	611	/*
	612	* Convert a integer constant (typically a #define or enum) to a string.
	613	*/
	614	static char noValue[80]; // that's pretty
	615
	616	const char IOFindNameForValue(int value, const IONamedValue regValueArray)
	617	{
	618	for( ; regValueArray->name; regValueArray++) {
	619	if(regValueArray->value == value)
	620	return(regValueArray->name);
	621	}
	622	sprintf(noValue, "0x%x (UNDEFINED)", value);
	623	return((const char *)noValue);
	624	}
	625
	626	IOReturn IOFindValueForName(const char *string,
	627	const IONamedValue *regValueArray,
	628	int *value)
	629	{
	630	for( ; regValueArray->name; regValueArray++) {
	631	if(!strcmp(regValueArray->name, string)) {
	632	*value = regValueArray->value;
	633	return kIOReturnSuccess;
	634	}
	635	}
	636	return kIOReturnBadArgument;
	637	}
	638
	639	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	640
	641	IOAlignment IOSizeToAlignment(unsigned int size)
	642	{
643	register int shift;
644	const int intsize = sizeof(unsigned int) * 8;
645
646	for (shift = 1; shift < intsize; shift++) {
647	if (size & 0x80000000)
648	return (IOAlignment)(intsize - shift);
649	size <<= 1;
650	}
651	return 0;
652	}
653
654	unsigned int IOAlignmentToSize(IOAlignment align)
655	{
656	unsigned int size;
657
658	for (size = 1; align; align--) {
659	size <<= 1;
660	}
661	return size;
662	}
0b4e3aa0 A	663
	664	IOReturn IONDRVLibrariesInitialize( void )
	665	{
	666	return( kIOReturnUnsupported );
	667	}