MIPS: Add Cavium OCTEON processor support files to...

#

# Makefile for the Cavium Octeon specific kernel interface routines

# under Linux.

#

# This file is subject to the terms and conditions of the GNU General Public

# License.  See the file "COPYING" in the main directory of this archive

# for more details.

#

# Copyright (C) 2005-2008 Cavium Networks

#

obj-y += cvmx-bootmem.o cvmx-l2c.o cvmx-sysinfo.o octeon-model.o

/***********************license start***************

 * Author: Cavium Networks

 *

 * Contact: support@caviumnetworks.com

 * This file is part of the OCTEON SDK

 *

 * Copyright (c) 2003-2008 Cavium Networks

 *

 * This file is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License, Version 2, as

 * published by the Free Software Foundation.

 *

 * This file is distributed in the hope that it will be useful, but

 * AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty

 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or

 * NONINFRINGEMENT.  See the GNU General Public License for more

 * details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this file; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

 * or visit http://www.gnu.org/licenses/.

 *

 * This file may also be available under a different license from Cavium.

 * Contact Cavium Networks for more information

 ***********************license end**************************************/

/*

 * Simple allocate only memory allocator.  Used to allocate memory at

 * application start time.

 */

#include <linux/kernel.h>

#include <asm/octeon/cvmx.h>

#include <asm/octeon/cvmx-spinlock.h>

#include <asm/octeon/cvmx-bootmem.h>

/*#define DEBUG */

static struct cvmx_bootmem_desc *cvmx_bootmem_desc;

/* See header file for descriptions of functions */

/*

 * Wrapper functions are provided for reading/writing the size and

 * next block values as these may not be directly addressible (in 32

 * bit applications, for instance.)  Offsets of data elements in

 * bootmem list, must match cvmx_bootmem_block_header_t.

 */

#define NEXT_OFFSET 0

#define SIZE_OFFSET 8

static void cvmx_bootmem_phy_set_size(uint64_t addr, uint64_t size)

{

	cvmx_write64_uint64((addr + SIZE_OFFSET) | (1ull << 63), size);

}

static void cvmx_bootmem_phy_set_next(uint64_t addr, uint64_t next)

{

	cvmx_write64_uint64((addr + NEXT_OFFSET) | (1ull << 63), next);

}

static uint64_t cvmx_bootmem_phy_get_size(uint64_t addr)

{

	return cvmx_read64_uint64((addr + SIZE_OFFSET) | (1ull << 63));

}

static uint64_t cvmx_bootmem_phy_get_next(uint64_t addr)

{

	return cvmx_read64_uint64((addr + NEXT_OFFSET) | (1ull << 63));

}

void *cvmx_bootmem_alloc_range(uint64_t size, uint64_t alignment,

			       uint64_t min_addr, uint64_t max_addr)

{

	int64_t address;

	address =

	    cvmx_bootmem_phy_alloc(size, min_addr, max_addr, alignment, 0);

	if (address > 0)

		return cvmx_phys_to_ptr(address);

	else

		return NULL;

}

void *cvmx_bootmem_alloc_address(uint64_t size, uint64_t address,

				 uint64_t alignment)

{

	return cvmx_bootmem_alloc_range(size, alignment, address,

					address + size);

}

void *cvmx_bootmem_alloc(uint64_t size, uint64_t alignment)

{

	return cvmx_bootmem_alloc_range(size, alignment, 0, 0);

}

int cvmx_bootmem_free_named(char *name)

{

	return cvmx_bootmem_phy_named_block_free(name, 0);

}

struct cvmx_bootmem_named_block_desc *cvmx_bootmem_find_named_block(char *name)

{

	return cvmx_bootmem_phy_named_block_find(name, 0);

}

void cvmx_bootmem_lock(void)

{

	cvmx_spinlock_lock((cvmx_spinlock_t *) &(cvmx_bootmem_desc->lock));

}

void cvmx_bootmem_unlock(void)

{

	cvmx_spinlock_unlock((cvmx_spinlock_t *) &(cvmx_bootmem_desc->lock));

}

int cvmx_bootmem_init(void *mem_desc_ptr)

{

	/* Here we set the global pointer to the bootmem descriptor

	 * block.  This pointer will be used directly, so we will set

	 * it up to be directly usable by the application.  It is set

	 * up as follows for the various runtime/ABI combinations:

	 *

	 * Linux 64 bit: Set XKPHYS bit

	 * Linux 32 bit: use mmap to create mapping, use virtual address

	 * CVMX 64 bit:  use physical address directly

	 * CVMX 32 bit:  use physical address directly

	 *

	 * Note that the CVMX environment assumes the use of 1-1 TLB

	 * mappings so that the physical addresses can be used

	 * directly

	 */

	if (!cvmx_bootmem_desc) {

#if   defined(CVMX_ABI_64)

		/* Set XKPHYS bit */

		cvmx_bootmem_desc = cvmx_phys_to_ptr(CAST64(mem_desc_ptr));

#else

		cvmx_bootmem_desc = (struct cvmx_bootmem_desc *) mem_desc_ptr;

#endif

	}

	return 0;

}

/*

 * The cvmx_bootmem_phy* functions below return 64 bit physical

 * addresses, and expose more features that the cvmx_bootmem_functions

 * above.  These are required for full memory space access in 32 bit

 * applications, as well as for using some advance features.  Most

 * applications should not need to use these.

 */

int64_t cvmx_bootmem_phy_alloc(uint64_t req_size, uint64_t address_min,

			       uint64_t address_max, uint64_t alignment,

			       uint32_t flags)

{

	uint64_t head_addr;

	uint64_t ent_addr;

	/* points to previous list entry, NULL current entry is head of list */

	uint64_t prev_addr = 0;

	uint64_t new_ent_addr = 0;

	uint64_t desired_min_addr;

#ifdef DEBUG

	cvmx_dprintf("cvmx_bootmem_phy_alloc: req_size: 0x%llx, "

		     "min_addr: 0x%llx, max_addr: 0x%llx, align: 0x%llx\n",

		     (unsigned long long)req_size,

		     (unsigned long long)address_min,

		     (unsigned long long)address_max,

		     (unsigned long long)alignment);

#endif

	if (cvmx_bootmem_desc->major_version > 3) {

		cvmx_dprintf("ERROR: Incompatible bootmem descriptor "

			     "version: %d.%d at addr: %p\n",

			     (int)cvmx_bootmem_desc->major_version,

			     (int)cvmx_bootmem_desc->minor_version,

			     cvmx_bootmem_desc);

		goto error_out;

	}

	/*

	 * Do a variety of checks to validate the arguments.  The

	 * allocator code will later assume that these checks have

	 * been made.  We validate that the requested constraints are

	 * not self-contradictory before we look through the list of

	 * available memory.

	 */

	/* 0 is not a valid req_size for this allocator */

	if (!req_size)

		goto error_out;

	/* Round req_size up to mult of minimum alignment bytes */

	req_size = (req_size + (CVMX_BOOTMEM_ALIGNMENT_SIZE - 1)) &

		~(CVMX_BOOTMEM_ALIGNMENT_SIZE - 1);

	/*

	 * Convert !0 address_min and 0 address_max to special case of

	 * range that specifies an exact memory block to allocate.  Do

	 * this before other checks and adjustments so that this

	 * tranformation will be validated.

	 */

	if (address_min && !address_max)

		address_max = address_min + req_size;

	else if (!address_min && !address_max)

		address_max = ~0ull;  /* If no limits given, use max limits */

	/*

	 * Enforce minimum alignment (this also keeps the minimum free block

	 * req_size the same as the alignment req_size.

	 */

	if (alignment < CVMX_BOOTMEM_ALIGNMENT_SIZE)

		alignment = CVMX_BOOTMEM_ALIGNMENT_SIZE;

	/*

	 * Adjust address minimum based on requested alignment (round

	 * up to meet alignment).  Do this here so we can reject

	 * impossible requests up front. (NOP for address_min == 0)

	 */

	if (alignment)

		address_min = __ALIGN_MASK(address_min, (alignment - 1));

	/*

	 * Reject inconsistent args.  We have adjusted these, so this

	 * may fail due to our internal changes even if this check

	 * would pass for the values the user supplied.

	 */

	if (req_size > address_max - address_min)

		goto error_out;

	/* Walk through the list entries - first fit found is returned */

	if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING))

		cvmx_bootmem_lock();

	head_addr = cvmx_bootmem_desc->head_addr;

	ent_addr = head_addr;

	for (; ent_addr;

	     prev_addr = ent_addr,

	     ent_addr = cvmx_bootmem_phy_get_next(ent_addr)) {

		uint64_t usable_base, usable_max;

		uint64_t ent_size = cvmx_bootmem_phy_get_size(ent_addr);

		if (cvmx_bootmem_phy_get_next(ent_addr)

		    && ent_addr > cvmx_bootmem_phy_get_next(ent_addr)) {

			cvmx_dprintf("Internal bootmem_alloc() error: ent: "

				"0x%llx, next: 0x%llx\n",

				(unsigned long long)ent_addr,

				(unsigned long long)

				cvmx_bootmem_phy_get_next(ent_addr));

			goto error_out;

		}

		/*

		 * Determine if this is an entry that can satisify the

		 * request Check to make sure entry is large enough to

		 * satisfy request.

		 */

		usable_base =

		    __ALIGN_MASK(max(address_min, ent_addr), alignment - 1);

		usable_max = min(address_max, ent_addr + ent_size);

		/*

		 * We should be able to allocate block at address

		 * usable_base.

		 */

		desired_min_addr = usable_base;

		/*

		 * Determine if request can be satisfied from the

		 * current entry.

		 */

		if (!((ent_addr + ent_size) > usable_base

				&& ent_addr < address_max

				&& req_size <= usable_max - usable_base))

			continue;

		/*

		 * We have found an entry that has room to satisfy the

		 * request, so allocate it from this entry.  If end

		 * CVMX_BOOTMEM_FLAG_END_ALLOC set, then allocate from

		 * the end of this block rather than the beginning.

		 */

		if (flags & CVMX_BOOTMEM_FLAG_END_ALLOC) {

			desired_min_addr = usable_max - req_size;

			/*

			 * Align desired address down to required

			 * alignment.

			 */

			desired_min_addr &= ~(alignment - 1);

		}

		/* Match at start of entry */

		if (desired_min_addr == ent_addr) {

			if (req_size < ent_size) {

				/*

				 * big enough to create a new block

				 * from top portion of block.

				 */

				new_ent_addr = ent_addr + req_size;

				cvmx_bootmem_phy_set_next(new_ent_addr,

					cvmx_bootmem_phy_get_next(ent_addr));

				cvmx_bootmem_phy_set_size(new_ent_addr,

							ent_size -

							req_size);

				/*

				 * Adjust next pointer as following

				 * code uses this.

				 */

				cvmx_bootmem_phy_set_next(ent_addr,

							new_ent_addr);

			}

			/*

			 * adjust prev ptr or head to remove this

			 * entry from list.

			 */

			if (prev_addr)

				cvmx_bootmem_phy_set_next(prev_addr,

					cvmx_bootmem_phy_get_next(ent_addr));

			else

				/*

				 * head of list being returned, so

				 * update head ptr.

				 */

				cvmx_bootmem_desc->head_addr =

					cvmx_bootmem_phy_get_next(ent_addr);

			if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING))

				cvmx_bootmem_unlock();

			return desired_min_addr;

		}

		/*

		 * block returned doesn't start at beginning of entry,

		 * so we know that we will be splitting a block off

		 * the front of this one.  Create a new block from the

		 * beginning, add to list, and go to top of loop

		 * again.

		 *

		 * create new block from high portion of

		 * block, so that top block starts at desired

		 * addr.

		 */

		new_ent_addr = desired_min_addr;

		cvmx_bootmem_phy_set_next(new_ent_addr,

					cvmx_bootmem_phy_get_next

					(ent_addr));

		cvmx_bootmem_phy_set_size(new_ent_addr,

					cvmx_bootmem_phy_get_size

					(ent_addr) -

					(desired_min_addr -

						ent_addr));

		cvmx_bootmem_phy_set_size(ent_addr,

					desired_min_addr - ent_addr);

		cvmx_bootmem_phy_set_next(ent_addr, new_ent_addr);

		/* Loop again to handle actual alloc from new block */

	}

error_out:

	/* We didn't find anything, so return error */

	if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING))

		cvmx_bootmem_unlock();

	return -1;

}

int __cvmx_bootmem_phy_free(uint64_t phy_addr, uint64_t size, uint32_t flags)

{

	uint64_t cur_addr;

	uint64_t prev_addr = 0;	/* zero is invalid */

	int retval = 0;

#ifdef DEBUG

	cvmx_dprintf("__cvmx_bootmem_phy_free addr: 0x%llx, size: 0x%llx\n",

		     (unsigned long long)phy_addr, (unsigned long long)size);

#endif

	if (cvmx_bootmem_desc->major_version > 3) {

		cvmx_dprintf("ERROR: Incompatible bootmem descriptor "

			     "version: %d.%d at addr: %p\n",

			     (int)cvmx_bootmem_desc->major_version,

			     (int)cvmx_bootmem_desc->minor_version,

			     cvmx_bootmem_desc);

		return 0;

	}

	/* 0 is not a valid size for this allocator */

	if (!size)

		return 0;

	if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING))

		cvmx_bootmem_lock();

	cur_addr = cvmx_bootmem_desc->head_addr;

	if (cur_addr == 0 || phy_addr < cur_addr) {

		/* add at front of list - special case with changing head ptr */

		if (cur_addr && phy_addr + size > cur_addr)

			goto bootmem_free_done;	/* error, overlapping section */

		else if (phy_addr + size == cur_addr) {

			/* Add to front of existing first block */

			cvmx_bootmem_phy_set_next(phy_addr,

						  cvmx_bootmem_phy_get_next

						  (cur_addr));

			cvmx_bootmem_phy_set_size(phy_addr,

						  cvmx_bootmem_phy_get_size

						  (cur_addr) + size);

			cvmx_bootmem_desc->head_addr = phy_addr;

		} else {

			/* New block before first block.  OK if cur_addr is 0 */

			cvmx_bootmem_phy_set_next(phy_addr, cur_addr);

			cvmx_bootmem_phy_set_size(phy_addr, size);

			cvmx_bootmem_desc->head_addr = phy_addr;

		}

		retval = 1;

		goto bootmem_free_done;

	}

	/* Find place in list to add block */

	while (cur_addr && phy_addr > cur_addr) {

		prev_addr = cur_addr;

		cur_addr = cvmx_bootmem_phy_get_next(cur_addr);

	}

	if (!cur_addr) {

		/*

		 * We have reached the end of the list, add on to end,

		 * checking to see if we need to combine with last

		 * block

		 */

		if (prev_addr + cvmx_bootmem_phy_get_size(prev_addr) ==

		    phy_addr) {

			cvmx_bootmem_phy_set_size(prev_addr,

						  cvmx_bootmem_phy_get_size

						  (prev_addr) + size);

		} else {

			cvmx_bootmem_phy_set_next(prev_addr, phy_addr);

			cvmx_bootmem_phy_set_size(phy_addr, size);

			cvmx_bootmem_phy_set_next(phy_addr, 0);

		}

		retval = 1;

		goto bootmem_free_done;

	} else {

		/*

		 * insert between prev and cur nodes, checking for

		 * merge with either/both.

		 */

		if (prev_addr + cvmx_bootmem_phy_get_size(prev_addr) ==

		    phy_addr) {

			/* Merge with previous */

			cvmx_bootmem_phy_set_size(prev_addr,

						  cvmx_bootmem_phy_get_size

						  (prev_addr) + size);

			if (phy_addr + size == cur_addr) {

				/* Also merge with current */

				cvmx_bootmem_phy_set_size(prev_addr,

					cvmx_bootmem_phy_get_size(cur_addr) +

					cvmx_bootmem_phy_get_size(prev_addr));

				cvmx_bootmem_phy_set_next(prev_addr,

					cvmx_bootmem_phy_get_next(cur_addr));

			}

			retval = 1;

			goto bootmem_free_done;

		} else if (phy_addr + size == cur_addr) {

			/* Merge with current */

			cvmx_bootmem_phy_set_size(phy_addr,

						  cvmx_bootmem_phy_get_size

						  (cur_addr) + size);

			cvmx_bootmem_phy_set_next(phy_addr,

						  cvmx_bootmem_phy_get_next

						  (cur_addr));

			cvmx_bootmem_phy_set_next(prev_addr, phy_addr);

			retval = 1;

			goto bootmem_free_done;

		}

		/* It is a standalone block, add in between prev and cur */

		cvmx_bootmem_phy_set_size(phy_addr, size);

		cvmx_bootmem_phy_set_next(phy_addr, cur_addr);

		cvmx_bootmem_phy_set_next(prev_addr, phy_addr);

	}

	retval = 1;

bootmem_free_done:

	if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING))

		cvmx_bootmem_unlock();

	return retval;

}

struct cvmx_bootmem_named_block_desc *

	cvmx_bootmem_phy_named_block_find(char *name, uint32_t flags)

{

	unsigned int i;

	struct cvmx_bootmem_named_block_desc *named_block_array_ptr;

#ifdef DEBUG

	cvmx_dprintf("cvmx_bootmem_phy_named_block_find: %s\n", name);

#endif

	/*

	 * Lock the structure to make sure that it is not being

	 * changed while we are examining it.

	 */

	if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING))

		cvmx_bootmem_lock();

	/* Use XKPHYS for 64 bit linux */

	named_block_array_ptr = (struct cvmx_bootmem_named_block_desc *)

	    cvmx_phys_to_ptr(cvmx_bootmem_desc->named_block_array_addr);

#ifdef DEBUG

	cvmx_dprintf

	    ("cvmx_bootmem_phy_named_block_find: named_block_array_ptr: %p\n",

	     named_block_array_ptr);

#endif

	if (cvmx_bootmem_desc->major_version == 3) {

		for (i = 0;

		     i < cvmx_bootmem_desc->named_block_num_blocks; i++) {

			if ((name && named_block_array_ptr[i].size

			     && !strncmp(name, named_block_array_ptr[i].name,

					 cvmx_bootmem_desc->named_block_name_len

					 - 1))

			    || (!name && !named_block_array_ptr[i].size)) {

				if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING))

					cvmx_bootmem_unlock();

				return &(named_block_array_ptr[i]);

			}

		}

	} else {

		cvmx_dprintf("ERROR: Incompatible bootmem descriptor "

			     "version: %d.%d at addr: %p\n",

			     (int)cvmx_bootmem_desc->major_version,

			     (int)cvmx_bootmem_desc->minor_version,

			     cvmx_bootmem_desc);

	}

	if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING))

		cvmx_bootmem_unlock();

	return NULL;

}

int cvmx_bootmem_phy_named_block_free(char *name, uint32_t flags)

{

	struct cvmx_bootmem_named_block_desc *named_block_ptr;

	if (cvmx_bootmem_desc->major_version != 3) {

		cvmx_dprintf("ERROR: Incompatible bootmem descriptor version: "

			     "%d.%d at addr: %p\n",

			     (int)cvmx_bootmem_desc->major_version,

			     (int)cvmx_bootmem_desc->minor_version,

			     cvmx_bootmem_desc);

		return 0;

	}

#ifdef DEBUG

	cvmx_dprintf("cvmx_bootmem_phy_named_block_free: %s\n", name);

#endif

	/*

	 * Take lock here, as name lookup/block free/name free need to

	 * be atomic.

	 */

	cvmx_bootmem_lock();

	named_block_ptr =

	    cvmx_bootmem_phy_named_block_find(name,

					      CVMX_BOOTMEM_FLAG_NO_LOCKING);

	if (named_block_ptr) {

#ifdef DEBUG

		cvmx_dprintf("cvmx_bootmem_phy_named_block_free: "

			     "%s, base: 0x%llx, size: 0x%llx\n",

			     name,

			     (unsigned long long)named_block_ptr->base_addr,

			     (unsigned long long)named_block_ptr->size);

#endif

		__cvmx_bootmem_phy_free(named_block_ptr->base_addr,

					named_block_ptr->size,

					CVMX_BOOTMEM_FLAG_NO_LOCKING);

		named_block_ptr->size = 0;

		/* Set size to zero to indicate block not used. */

	}

	cvmx_bootmem_unlock();

	return named_block_ptr != NULL;	/* 0 on failure, 1 on success */

}

/***********************license start***************

 * Author: Cavium Networks

 *

 * Contact: support@caviumnetworks.com

 * This file is part of the OCTEON SDK

 *

 * Copyright (c) 2003-2008 Cavium Networks

 *

 * This file is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License, Version 2, as

 * published by the Free Software Foundation.

 *

 * This file is distributed in the hope that it will be useful, but

 * AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty

 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or

 * NONINFRINGEMENT.  See the GNU General Public License for more

 * details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this file; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

 * or visit http://www.gnu.org/licenses/.

 *

 * This file may also be available under a different license from Cavium.

 * Contact Cavium Networks for more information

 ***********************license end**************************************/

/*

 * This module provides system/board/application information obtained

 * by the bootloader.

 */

#include <asm/octeon/cvmx.h>

#include <asm/octeon/cvmx-spinlock.h>

#include <asm/octeon/cvmx-sysinfo.h>

/**

 * This structure defines the private state maintained by sysinfo module.

 *

 */

static struct {

	struct cvmx_sysinfo sysinfo;	   /* system information */

	cvmx_spinlock_t lock;	   /* mutex spinlock */

} state = {

	.lock = CVMX_SPINLOCK_UNLOCKED_INITIALIZER

};

/*

 * Global variables that define the min/max of the memory region set

 * up for 32 bit userspace access.

 */

uint64_t linux_mem32_min;

uint64_t linux_mem32_max;

uint64_t linux_mem32_wired;

uint64_t linux_mem32_offset;

/**

 * This function returns the application information as obtained

 * by the bootloader.  This provides the core mask of the cores

 * running the same application image, as well as the physical

 * memory regions available to the core.

 *

 * Returns  Pointer to the boot information structure

 *

 */

struct cvmx_sysinfo *cvmx_sysinfo_get(void)

{

	return &(state.sysinfo);

}

/**

 * This function is used in non-simple executive environments (such as

 * Linux kernel, u-boot, etc.)  to configure the minimal fields that

 * are required to use simple executive files directly.

 *

 * Locking (if required) must be handled outside of this

 * function

 *

 * @phy_mem_desc_ptr:

 *                   Pointer to global physical memory descriptor

 *                   (bootmem descriptor) @board_type: Octeon board

 *                   type enumeration

 *

 * @board_rev_major:

 *                   Board major revision

 * @board_rev_minor:

 *                   Board minor revision

 * @cpu_clock_hz:

 *                   CPU clock freqency in hertz

 *

 * Returns 0: Failure

 *         1: success

 */

int cvmx_sysinfo_minimal_initialize(void *phy_mem_desc_ptr,

				    uint16_t board_type,

				    uint8_t board_rev_major,

				    uint8_t board_rev_minor,

				    uint32_t cpu_clock_hz)

{

	/* The sysinfo structure was already initialized */

	if (state.sysinfo.board_type)

		return 0;

	memset(&(state.sysinfo), 0x0, sizeof(state.sysinfo));

	state.sysinfo.phy_mem_desc_ptr = phy_mem_desc_ptr;

	state.sysinfo.board_type = board_type;

	state.sysinfo.board_rev_major = board_rev_major;

	state.sysinfo.board_rev_minor = board_rev_minor;

	state.sysinfo.cpu_clock_hz = cpu_clock_hz;

	return 1;

}