#include <syscall.h>
#include <linux/ktime.h>
typedef unsigned int addr_t;
#define ACPI_NAME_SIZE 4
#define ACPI_OEM_ID_SIZE 6
#define ACPI_OEM_TABLE_ID_SIZE 8
#define ACPI_RSDP_CHECKSUM_LENGTH 20
#define ACPI_RSDP_XCHECKSUM_LENGTH 36
typedef struct __attribute__((packed))
{
u32 sig;
u32 len;
u8 rev;
u8 csum;
char oem_id[ACPI_OEM_ID_SIZE];
char oem_tid[ACPI_OEM_TABLE_ID_SIZE];
u32 oem_rev;
u32 creator_id;
u32 creator_rev;
}acpi_thead_t;
typedef struct __attribute__((packed))
{
u8 space_id; /* Address space where struct or register exists */
u8 bit_width; /* Size in bits of given register */
u8 bit_offset; /* Bit offset within the register */
u8 access_width; /* Minimum Access size (ACPI 3.0) */
u64 address; /* 64-bit address of struct or register */
}acpi_address_t;
typedef struct __attribute__((packed))
{
acpi_thead_t header; /* Common ACPI table header */
u32 id; /* Hardware ID of event timer block */
acpi_address_t address; /* Address of event timer block */
u8 sequence; /* HPET sequence number */
u16 minimum_tick; /* Main counter min tick, periodic mode */
u8 flags;
}acpi_hpet_t;
typedef struct __attribute__((packed))
{
acpi_thead_t header;
u32 ptrs[0];
}acpi_rsdt_t;
typedef struct __attribute__((packed))
{
acpi_thead_t header;
u64 ptrs[0];
}acpi_xsdt_t;
typedef struct __attribute__((packed))
{
u64 sig;
u8 csum;
char oemid[6];
u8 rev;
u32 rsdt_ptr;
u32 rsdt_len;
u64 xsdt_ptr;
u8 xcsum;
u8 _rsvd_33[3];
}acpi_rsdp_t;
#define OS_BASE 0x80000000
#define ACPI20_PC99_RSDP_START (OS_BASE + 0x0e0000)
#define ACPI20_PC99_RSDP_END (OS_BASE + 0x100000)
#define ACPI20_PC99_RSDP_SIZE (ACPI20_PC99_RSDP_END - ACPI20_PC99_RSDP_START)
static acpi_thead_t* (*sdt_find)(void *sdt, u32 sig);
static u8 acpi_tb_checksum (u8 *buffer, u32 len)
{
u8 sum = 0;
u8 *end = buffer + len;
while (buffer < end)
{
sum = (u8)(sum + *(buffer++));
}
return sum;
}
static acpi_rsdp_t* acpi_locate()
{
addr_t p;
for (p = ACPI20_PC99_RSDP_START; p < ACPI20_PC99_RSDP_END; p+=16)
{
acpi_rsdp_t* r = (acpi_rsdp_t*) p;
if (r->sig != 0x2052545020445352 )
continue;
if (acpi_tb_checksum ((u8*)r, ACPI_RSDP_CHECKSUM_LENGTH) != 0)
continue;
if ((r->rev >= 2) &&
(acpi_tb_checksum ((u8*)r, ACPI_RSDP_XCHECKSUM_LENGTH) != 0))
continue;
return r;
};
return NULL;
};
acpi_thead_t* rsdt_find(acpi_rsdt_t *rsdt, u32 sig)
{
acpi_thead_t *head = NULL;
u32 i;
for (i = 0; i < ((rsdt->header.len-sizeof(acpi_thead_t))/
sizeof(rsdt->ptrs[0])); i++)
{
u32 ptr = rsdt->ptrs[i];
acpi_thead_t* t = (acpi_thead_t*)MapIoMem(ptr, 8192, PG_SW);
if (t->sig == sig)
{
head = t;
break;
};
FreeKernelSpace(t);
}
return head;
};
acpi_thead_t* xsdt_find(acpi_xsdt_t *xsdt, u32 sig)
{
acpi_thead_t *head = NULL;
u32 i;
for (i = 0; i < ((xsdt->header.len-sizeof(acpi_thead_t))/
sizeof(xsdt->ptrs[0])); i++)
{
u32 ptr = xsdt->ptrs[i];
acpi_thead_t* t = (acpi_thead_t*)MapIoMem(ptr, 8192, PG_SW);
if (t->sig == sig)
{
head = t;
break;
};
FreeKernelSpace(t);
}
return head;
};
static void dump_rsdt(acpi_rsdt_t *rsdt)
{
int i;
for (i = 0; i < ((rsdt->header.len-sizeof(acpi_thead_t))/
sizeof(rsdt->ptrs[0])); i++)
{
u32 ptr = rsdt->ptrs[i];
dbgprintf("%s ptr= %p\n", __FUNCTION__, ptr);
acpi_thead_t* t = (acpi_thead_t*)MapIoMem(ptr, 8192, PG_SW);
dbgprintf("%s t= %x\n", __FUNCTION__, t);
char *p = (char*)&t->sig;
printf("sig %d: %x %c%c%c%c base %p\n", i
, t
->sig
, p[0],p[1],p[2],p[3],rsdt->ptrs[i]);
FreeKernelSpace(t);
};
};
typedef struct
{
u64 hpet_cap; /* capabilities */
u64 res0; /* reserved */
u64 hpet_config; /* configuration */
u64 res1; /* reserved */
u64 hpet_isr; /* interrupt status reg */
u64 res2[25]; /* reserved */
union { /* main counter */
volatile u64 _hpet_mc64;
u32 _hpet_mc32;
unsigned long _hpet_mc;
} _u0;
u64 res3; /* reserved */
struct hpet_timer {
u64 hpet_config; /* configuration/cap */
union { /* timer compare register */
u64 _hpet_hc64;
u32 _hpet_hc32;
unsigned long _hpet_compare;
} _u1;
u64 hpet_fsb[2]; /* FSB route */
} hpet_timers[1];
}hpet_t;
#define HPET_ID 0x000
#define HPET_PERIOD 0x004
#define HPET_CFG 0x010
#define HPET_STATUS 0x020
#define HPET_COUNTER 0x0f0
#define HPET_ID_NUMBER 0x00001f00
#define HPET_ID_NUMBER_SHIFT 8
#define HPET_CFG_ENABLE 0x001
static void *hpet_virt_address;
inline unsigned int hpet_readl(unsigned int a)
{
return readl(hpet_virt_address + a);
}
static inline void hpet_writel(unsigned int d, unsigned int a)
{
writel(d, hpet_virt_address + a);
}
static void hpet_start_counter(void)
{
unsigned int cfg = hpet_readl(HPET_CFG);
cfg |= HPET_CFG_ENABLE;
hpet_writel(cfg, HPET_CFG);
}
u64 read_htime()
{
u32 eflags;
u64 val;
eflags = safe_cli();
asm volatile(
"1:\n"
"mov 0xf4(%%ebx), %%edx\n"
"mov 0xf0(%%ebx), %%eax\n"
"mov 0xf4(%%ebx), %%ecx\n"
"cmpl %%edx, %%ecx\n"
"jnz 1b\n"
:"=A"(val)
:"b" (hpet_virt_address)
:"ecx");
safe_sti(eflags);
return val;
}
static u32 period;
void init_hpet()
{
void *sdt = NULL;
acpi_rsdp_t *rsdp = acpi_locate();
if (unlikely(rsdp == NULL))
{
printf("No ACPI RSD table\n"); return ;
};
printf("rsd base address %p\n", rsdp
);
if(rsdp->rev > 1)
{
sdt = (void*)(u32)rsdp->xsdt_ptr;
sdt_find = xsdt_find;
}
else
{
sdt = (void*)rsdp->rsdt_ptr;
sdt_find = rsdt_find;
};
printf("sdt address %p\n", sdt
);
if (sdt == NULL)
{
printf("Invalid ACPI RSD table\n"); return ;
};
sdt = MapIoMem(sdt, 128*1024, PG_SW);
printf("sdt mapped address %x\n", sdt
);
acpi_hpet_t *tbl = (acpi_hpet_t*)sdt_find(sdt, 0x54455048);
u32 hpet_address = tbl->address.address;
hpet_virt_address = (void*)MapIoMem(hpet_address,1024, PG_SW|0x18);
printf("hpet address %x mapped at %x\n", hpet_address
, hpet_virt_address
);
u32 timers, l, h;
l = hpet_readl(HPET_ID);
h = hpet_readl(HPET_PERIOD);
period = h / 1000000;
timers = ((l & HPET_ID_NUMBER) >> HPET_ID_NUMBER_SHIFT) + 1;
printk(KERN_INFO "hpet: ID: 0x%x, PERIOD: 0x%x\n", l, h);
l = hpet_readl(HPET_CFG);
h = hpet_readl(HPET_STATUS);
printk(KERN_INFO "hpet: CFG: 0x%x, STATUS: 0x%x\n", l, h);
l = hpet_readl(HPET_COUNTER);
h = hpet_readl(HPET_COUNTER+4);
printk(KERN_INFO "hpet: COUNTER_l: 0x%x, COUNTER_h: 0x%x\n", l, h);
hpet_start_counter();
}