Subversion Repositories Kolibri OS

#include 

#include 

#include 

#include 

{

    int result;

        return 0;

    {

        printk("Can't open /tmp0/1/acpi.log\nExit\n");

        return 0;

    }

//            printk(KERN_INFO PREFIX "Interpreter disabled.\n");

//            return -ENODEV;

//    }

//    result = acpi_bus_init();

//    if (result) {

//            disable_acpi();

//            return result;

//    }

//    acpi_scan_init();

//    acpi_ec_init();

//    acpi_debugfs_init();

//    acpi_sleep_proc_init();

//    acpi_wakeup_device_init();

{

    return AcpiGetRootPtr();

}

{

    return (void *)MapIoMem((addr_t)phys, size, PG_SW);

{

    u32 ptr = (u32)virt;

    ptr &= 0xFFFFF000;

}

{

    acpi_os_unmap_memory(virt, size);

}

{

    addr_t addr;

    void *virt;

        return 0;

        return -EINVAL;

    if (!virt)

        return -EIO;

}

{

    va_list args;

    va_start(args, fmt);

    acpi_os_vprintf(fmt, args);

    va_end(args);

}

{

    static char buffer[512];

    if (acpi_in_debugger) {

        kdb_printf("%s", buffer);

    } else {

            printk("%s", buffer);

    }

#else

    printk("%s", buffer);

#endif

}

{

     pr_warn(PREFIX

             "Override [%4.4s-%8.8s], this is unsafe: tainting kernel\n",

             table->signature, table->oem_table_id);

     add_taint(TAINT_OVERRIDDEN_ACPI_TABLE, LOCKDEP_NOW_UNRELIABLE);

}

acpi_os_table_override(struct acpi_table_header * existing_table,

                       struct acpi_table_header ** new_table)

{

    if (!existing_table || !new_table)

        return AE_BAD_PARAMETER;

    if (strncmp(existing_table->signature, "DSDT", 4) == 0)

        *new_table = (struct acpi_table_header *)AmlCode;

#endif

    if (*new_table != NULL)

        acpi_table_taint(existing_table);

    return AE_OK;

}

acpi_os_physical_table_override(struct acpi_table_header *existing_table,

                                acpi_physical_address *address,

                                u32 *table_length)

{

#ifndef CONFIG_ACPI_INITRD_TABLE_OVERRIDE

        *table_length = 0;

        *address = 0;

        return AE_OK;

#else

        int table_offset = 0;

        struct acpi_table_header *table;

        *address = 0;

                return AE_OK;

                if (table_offset + ACPI_HEADER_SIZE > all_tables_size) {

                        WARN_ON(1);

                        return AE_OK;

                }

                                           ACPI_HEADER_SIZE);

                        acpi_os_unmap_memory(table, ACPI_HEADER_SIZE);

                        WARN_ON(1);

                        return AE_OK;

                }

                        acpi_os_unmap_memory(table,

                                     ACPI_HEADER_SIZE);

                        continue;

                }

                if (memcmp(table->oem_table_id, existing_table->oem_table_id,

                           ACPI_OEM_TABLE_ID_SIZE)) {

                        acpi_os_unmap_memory(table,

                                     ACPI_HEADER_SIZE);

                        continue;

                }

                *table_length = table->length;

                acpi_os_unmap_memory(table, ACPI_HEADER_SIZE);

                *address = acpi_tables_addr + table_offset;

                break;

        } while (table_offset + ACPI_HEADER_SIZE < all_tables_size);

                acpi_table_taint(existing_table);

        return AE_OK;

#endif

}

        unsigned int    enable:1;

        unsigned int    dmi:1;

        unsigned int    cmdline:1;

        unsigned int    default_disabling:1;

#define OSI_STRING_ENTRIES_MAX 16       /* arbitrary */

    char string[OSI_STRING_LENGTH_MAX];

    bool enable;

};

        osi_setup_entries[OSI_STRING_ENTRIES_MAX] __initdata = {

    {"Module Device", true},

    {"Processor Device", true},

    {"3.0 _SCP Extensions", true},

    {"Processor Aggregator Device", true},

};

void __init acpi_osi_setup(char *str)

{

        struct osi_setup_entry *osi;

        bool enable = true;

        int i;

                return;

                printk(KERN_INFO PREFIX "_OSI method disabled\n");

                acpi_gbl_create_osi_method = FALSE;

                return;

        }

                str++;

                if (*str == '\0') {

                        osi_linux.default_disabling = 1;

                        return;

                } else if (*str == '*') {

                        acpi_update_interfaces(ACPI_DISABLE_ALL_STRINGS);

                        for (i = 0; i < OSI_STRING_ENTRIES_MAX; i++) {

                                osi = &osi_setup_entries[i];

                                osi->enable = false;

                        }

                        return;

                }

                enable = false;

        }

                osi = &osi_setup_entries[i];

                if (!strcmp(osi->string, str)) {

                        osi->enable = enable;

                        break;

                } else if (osi->string[0] == '\0') {

                        osi->enable = enable;

                        strncpy(osi->string, str, OSI_STRING_LENGTH_MAX);

                        break;

                }

        }

}

{

    if (osi_linux.enable != enable)

        osi_linux.enable = enable;

        acpi_osi_setup("Linux");

    else

        acpi_osi_setup("!Linux");

}

{

    printk(KERN_NOTICE PREFIX "DMI detected: %s\n", d->ident);

        return;

    set_osi_linux(enable);

}

{

    void *sem = (void*)handle;

        return AE_OK;

        return AE_BAD_PARAMETER;

        return AE_SUPPORT;

                      handle, units, timeout));

}

{

    void *sem = (void*)handle;

            return AE_OK;

            return AE_BAD_PARAMETER;

            return AE_SUPPORT;

                      units));

}

{

//    acpi_os_map_generic_address(&acpi_gbl_FADT.xpm1a_event_block);

//    acpi_os_map_generic_address(&acpi_gbl_FADT.xpm1b_event_block);

//    acpi_os_map_generic_address(&acpi_gbl_FADT.xgpe0_block);

//    acpi_os_map_generic_address(&acpi_gbl_FADT.xgpe1_block);

    if (acpi_gbl_FADT.flags & ACPI_FADT_RESET_REGISTER) {

            /*

             * Use acpi_os_map_generic_address to pre-map the reset

             * register if it's in system memory.

             */

            int rv;

            pr_debug(PREFIX "%s: map reset_reg status %d\n", __func__, rv);

    }

    acpi_os_initialized = true;

}

{

//        kacpid_wq = alloc_workqueue("kacpid", 0, 1);

//        kacpi_notify_wq = alloc_workqueue("kacpi_notify", 0, 1);

//        kacpi_hotplug_wq = alloc_ordered_workqueue("kacpi_hotplug", 0);

//        BUG_ON(!kacpid_wq);

//        BUG_ON(!kacpi_notify_wq);

//       BUG_ON(!kacpi_hotplug_wq);

//        acpi_install_interface_handler(acpi_osi_handler);

//        acpi_osi_setup_late();

        return AE_OK;

}

{

//        void *sem = (void*)handle;

//            return AE_BAD_PARAMETER;

//        sem = NULL;

}

                         u32 initial_units, acpi_handle * out_handle)

{

    *out_handle = (acpi_handle) 1;

    return (AE_OK);

}

acpi_os_create_mutex(acpi_handle * handle)

{

    struct mutex *mtx = NULL;

            return AE_NO_MEMORY;

}

{

    struct mutex *mtx = (struct mutex*)handle;

        return;

}

{

    struct mutex *mtx = (struct mutex*)handle;

        return AE_OK;

}

{

    struct mutex *mtx = (struct mutex*)handle;

};

{

    acpi_cpu_flags flags;

    spin_lock_irqsave(lockp, flags);

    return flags;

}

{

    spin_unlock_irqrestore(lockp, flags);

}

{

        switch (function) {

        case ACPI_SIGNAL_FATAL:

                printk(KERN_ERR PREFIX "Fatal opcode executed\n");

                break;

        case ACPI_SIGNAL_BREAKPOINT:

                /*

                 * AML Breakpoint

                 * ACPI spec. says to treat it as a NOP unless

                 * you are debugging.  So if/when we integrate

                 * AML debugger into the kernel debugger its

                 * hook will go here.  But until then it is

                 * not useful to print anything on breakpoints.

                 */

                break;

        default:

                break;

        }

}

{

        msleep(ms);

}

{

        while (us) {

                u32 delay = 1000;

                        delay = us;

                udelay(delay);

//                touch_nmi_watchdog();

                us -= delay;

        }

}

{

    msecs /= 10;

    if(!msecs) msecs = 1;

     "call *__imp__Delay"

     ::"b" (msecs));

     __asm__ __volatile__ (

     "":::"ebx");

                            acpi_osd_exec_callback function, void *context)

{

}

{

    u64 time_ns = ktime_to_ns(ktime_get());

    do_div(time_ns, 100);

    return time_ns;

}

{

    ktime_t t;

}

{

        asm volatile(

                "test %0,%0\n"

                "jz 3f\n"

                "jmp 1f\n"

                "1: jmp 2f\n"

                "2: dec %0\n"

                " jnz 2b\n"

                "3: dec %0\n"

                : "a" (loops)

        );

}

{

        int d0;

        asm("mull %%edx"

                : "=d" (xloops), "=&a" (d0)

                : "1" (xloops), ""

                (loops_per_jiffy * (HZ/4)));

}

{

        __const_udelay(usecs * 0x000010c7); /* 2**32 / 1000000 (rounded up) */

}

acpi_os_predefined_override(const struct acpi_predefined_names *init_val,

                            char **new_val)

{

        if (!init_val || !new_val)

                return AE_BAD_PARAMETER;

        if (!memcmp(init_val->name, "_OS_", 4) && strlen(acpi_os_name)) {

                printk(KERN_INFO PREFIX "Overriding _OS definition to '%s'\n",

                       acpi_os_name);

                *new_val = acpi_os_name;

        }

                printk(KERN_INFO PREFIX "Overriding _REV return value to 5\n");

                *new_val = (char *)5;

        }

}