os.c

linux和2410结合开发 用他可以生成2410所需的zImage文件

/******************************************************************************
 * 
 * Module Name: os.c - Linux OSL functions
 *		$Revision: 49 $
 *
 *****************************************************************************/

/*
 *  os.c - OS-dependent functions
 *
 *  Copyright (C) 2000 Andrew Henroid
 *  Copyright (C) 2001 Andrew Grover
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
/* Changes
 *
 * Christopher Liebman <[e-mail]> 2001-5-15
 * - Fixed improper kernel_thread parameters 
 */

#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/mm.h>
#include <linux/pci.h>
#include <linux/interrupt.h>
#include <linux/kmod.h>
#include <linux/delay.h>
#include <asm/io.h>
#include <acpi.h>

#ifdef CONFIG_ACPI_EFI
#include <asm/efi.h>
#endif

#ifdef _IA64
#include <asm/hw_irq.h>
#endif 

#define _COMPONENT	ACPI_OS_SERVICES
	MODULE_NAME	("os")

typedef struct 
{
    OSD_EXECUTION_CALLBACK  function;
    void		    *context;
} ACPI_OS_DPC;


/*****************************************************************************
 *			       Debugger Stuff
 *****************************************************************************/

#ifdef ENABLE_DEBUGGER

#include <linux/kdb.h>

/* stuff for debugger support */
int acpi_in_debugger = 0;
extern NATIVE_CHAR line_buf[80];

#endif


/*****************************************************************************
 *				    Globals
 *****************************************************************************/

static int acpi_irq_irq = 0;
static OSD_HANDLER acpi_irq_handler = NULL;
static void *acpi_irq_context = NULL;


/******************************************************************************
 *				   Functions
 *****************************************************************************/

acpi_status
acpi_os_initialize(void)
{
	return AE_OK;
}

acpi_status
acpi_os_terminate(void)
{
	if (acpi_irq_handler) {
		acpi_os_remove_interrupt_handler(acpi_irq_irq,
						 acpi_irq_handler);
	}

	return AE_OK;
}

s32
acpi_os_printf(const NATIVE_CHAR *fmt,...)
{
	s32 size;
	va_list args;
	va_start(args, fmt);
	size = acpi_os_vprintf(fmt, args);
	va_end(args);

	return size;
}

s32
acpi_os_vprintf(const NATIVE_CHAR *fmt, va_list args)
{
	static char buffer[512];
	int size = vsprintf(buffer, fmt, args);

#ifdef ENABLE_DEBUGGER
	if (acpi_in_debugger) {
		kdb_printf("%s", buffer);
	} else {
		printk("%s", buffer);
	}
#else
	printk("%s", buffer);
#endif

	return size;
}

void *
acpi_os_allocate(u32 size)
{
	return kmalloc(size, GFP_KERNEL);
}

void *
acpi_os_callocate(u32 size)
{
	void *ptr = acpi_os_allocate(size);
	if (ptr)
		memset(ptr, 0, size);

	return ptr;
}

void
acpi_os_free(void *ptr)
{
	kfree(ptr);
}


acpi_status
acpi_os_get_root_pointer(u32 flags, ACPI_PHYSICAL_ADDRESS *phys_addr)
{
#ifndef CONFIG_ACPI_EFI
	if (ACPI_FAILURE(acpi_find_root_pointer(flags, phys_addr))) {
		printk(KERN_ERR "ACPI: System description tables not found\n");
		return AE_ERROR;
	}
#else /*CONFIG_ACPI_EFI*/
	if (efi.acpi20)
		*phys_addr = (ACPI_PHYSICAL_ADDRESS) efi.acpi20;
	else if (efi.acpi)
		*phys_addr = (ACPI_PHYSICAL_ADDRESS) efi.acpi;
	else {
		printk(KERN_ERR "ACPI: System description tables not found\n");
		*phys_addr = NULL;
		return AE_ERROR;
	}
#endif /*CONFIG_ACPI_EFI*/

	return AE_OK;
}

acpi_status
acpi_os_map_memory(ACPI_PHYSICAL_ADDRESS phys, u32 size, void **virt)
{
	if (phys > ULONG_MAX) {
		printk(KERN_ERR "ACPI: Cannot map memory that high\n");
		return AE_ERROR;
	}

	*virt = ioremap((unsigned long) phys, size);
	if (!*virt)
		return AE_ERROR;

	return AE_OK;
}

void
acpi_os_unmap_memory(void *virt, u32 size)
{
	iounmap(virt);
}

acpi_status
acpi_os_get_physical_address(void *virt, ACPI_PHYSICAL_ADDRESS *phys)
{
	if(!phys || !virt)
		return AE_BAD_PARAMETER;

	*phys = virt_to_phys(virt);

	return AE_OK;
}

static void
acpi_irq(int irq, void *dev_id, struct pt_regs *regs)
{
	(*acpi_irq_handler)(acpi_irq_context);
}

acpi_status
acpi_os_install_interrupt_handler(u32 irq, OSD_HANDLER handler, void *context)
{
#ifdef _IA64
	irq = isa_irq_to_vector(irq);
#endif /*_IA64*/
	acpi_irq_irq = irq;
	acpi_irq_handler = handler;
	acpi_irq_context = context;
	if (request_irq(irq,
			acpi_irq,
			SA_SHIRQ,
			"acpi",
			acpi_irq)) {
		printk(KERN_ERR "ACPI: SCI (IRQ%d) allocation failed\n", irq);
		return AE_ERROR;
	}

	return AE_OK;
}

acpi_status
acpi_os_remove_interrupt_handler(u32 irq, OSD_HANDLER handler)
{
	if (acpi_irq_handler) {
#ifdef _IA64
		irq = isa_irq_to_vector(irq);
#endif /*_IA64*/
		free_irq(irq, acpi_irq);
		acpi_irq_handler = NULL;
	}

	return AE_OK;
}

/*
 * Running in interpreter thread context, safe to sleep
 */

void
acpi_os_sleep(u32 sec, u32 ms)
{
	current->state = TASK_INTERRUPTIBLE;
	schedule_timeout(HZ * sec + (ms * HZ) / 1000);
}

void
acpi_os_stall(u32 us)
{
	if (us > 10000) {
		mdelay(us / 1000);
	}
	else {
		udelay(us);
	}
}

acpi_status
acpi_os_read_port(
	ACPI_IO_ADDRESS	port,
	void		*value,
	u32		width)
{
	u32 dummy;

	if (!value)
		value = &dummy;

	switch (width)
	{
	case 8:
		*(u8*)  value = inb(port);
		break;
	case 16:
		*(u16*) value = inw(port);
		break;
	case 32:
		*(u32*) value = inl(port);
		break;
	default:
		BUG();
	}

	return AE_OK;
}

acpi_status
acpi_os_write_port(
	ACPI_IO_ADDRESS	port,
	NATIVE_UINT	value,
	u32		width)
{
	switch (width)
	{
	case 8:
		outb(value, port);
		break;
	case 16:
		outw(value, port);
		break;
	case 32:
		outl(value, port);
		break;
	default:
		BUG();
	}

	return AE_OK;
}

acpi_status
acpi_os_read_memory(
	ACPI_PHYSICAL_ADDRESS	phys_addr,
	void			*value,
	u32			width)
{
	u32 dummy;

	if (!value)
		value = &dummy;

	switch (width)
	{
	case 8:
		*(u8*) value = *(u8*) phys_to_virt(phys_addr);
		break;
	case 16:
		*(u16*) value = *(u16*) phys_to_virt(phys_addr);
		break;
	case 32:
		*(u32*) value = *(u32*) phys_to_virt(phys_addr);
		break;
	default:
		BUG();
	}

	return AE_OK;
}

acpi_status
acpi_os_write_memory(
	ACPI_PHYSICAL_ADDRESS	phys_addr,
	u32			value,
	u32			width)
{
	switch (width)
	{
	case 8:
		*(u8*) phys_to_virt(phys_addr) = value;
		break;
	case 16:
		*(u16*) phys_to_virt(phys_addr) = value;
		break;
	case 32:
		*(u32*) phys_to_virt(phys_addr) = value;
		break;
	default:
		BUG();
	}

	return AE_OK;
}


#ifdef CONFIG_ACPI_PCI

/* Architecture-dependent low-level PCI configuration access functions. */
extern int (*pci_config_read)(int seg, int bus, int dev, int fn, int reg, int len, u32 *val);
extern int (*pci_config_write)(int seg, int bus, int dev, int fn, int reg, int len, u32 val);

acpi_status
acpi_os_read_pci_configuration (
	acpi_pci_id             *pci_id,
	u32                     reg,
	void                    *value,
	u32                     width)
{
	int			result = 0;
	if (!value)
		return AE_ERROR;

	switch (width)
	{
	case 8:
		result = pci_config_read(pci_id->segment, pci_id->bus, 
			pci_id->device, pci_id->function, reg, 1, value);
		break;
	case 16:
		result = pci_config_read(pci_id->segment, pci_id->bus, 
			pci_id->device, pci_id->function, reg, 2, value);
		break;
	case 32:
		result = pci_config_read(pci_id->segment, pci_id->bus, 
			pci_id->device, pci_id->function, reg, 4, value);
		break;
	default:
		BUG();
	}

	return (result ? AE_ERROR : AE_OK);
}

acpi_status
acpi_os_write_pci_configuration (
	acpi_pci_id             *pci_id,
	u32                     reg,
	NATIVE_UINT             value,
	u32                     width)
{
	int			result = 0;

	switch (width)
	{
	case 8:
		result = pci_config_write(pci_id->segment, pci_id->bus, 
			pci_id->device, pci_id->function, reg, 1, value);
		break;
	case 16:
		result = pci_config_write(pci_id->segment, pci_id->bus, 
			pci_id->device, pci_id->function, reg, 2, value);
		break;
	case 32:
		result = pci_config_write(pci_id->segment, pci_id->bus, 
			pci_id->device, pci_id->function, reg, 4, value);
		break;
	default:
		BUG();
	}

	return (result ? AE_ERROR : AE_OK);
}

#else /*CONFIG_ACPI_PCI*/

acpi_status
acpi_os_read_pci_configuration (
	acpi_pci_id	*pci_id,
	u32		reg,
	void		*value,
	u32		width)