memcpy(length, vendor->byte_data + 8, sizeof(*length));
 
   exit:
-       acpi_os_free(buffer.pointer);
+       kfree(buffer.pointer);
        return status;
 }
 
 
        obj = buffer.pointer;
        if (obj->type != ACPI_TYPE_BUFFER ||
            obj->buffer.length < sizeof(*lsapic)) {
-               acpi_os_free(buffer.pointer);
+               kfree(buffer.pointer);
                return -EINVAL;
        }
 
 
        if ((lsapic->header.type != ACPI_MADT_LSAPIC) ||
            (!lsapic->flags.enabled)) {
-               acpi_os_free(buffer.pointer);
+               kfree(buffer.pointer);
                return -EINVAL;
        }
 
        physid = ((lsapic->id << 8) | (lsapic->eid));
 
-       acpi_os_free(buffer.pointer);
+       kfree(buffer.pointer);
        buffer.length = ACPI_ALLOCATE_BUFFER;
        buffer.pointer = NULL;
 
        obj = buffer.pointer;
        if (obj->type != ACPI_TYPE_BUFFER ||
            obj->buffer.length < sizeof(*iosapic)) {
-               acpi_os_free(buffer.pointer);
+               kfree(buffer.pointer);
                return AE_OK;
        }
 
        iosapic = (struct acpi_table_iosapic *)obj->buffer.pointer;
 
        if (iosapic->header.type != ACPI_MADT_IOSAPIC) {
-               acpi_os_free(buffer.pointer);
+               kfree(buffer.pointer);
                return AE_OK;
        }
 
        gsi_base = iosapic->global_irq_base;
 
-       acpi_os_free(buffer.pointer);
+       kfree(buffer.pointer);
 
        /*
         * OK, it's an IOSAPIC MADT entry, look for a _PXM value to tell
 
 
        info = buffer.pointer;
        if (!(info->valid & ACPI_VALID_HID)) {
-               acpi_os_free(buffer.pointer);
+               kfree(buffer.pointer);
                return AE_ERROR;
        }
 
            (strcmp(hardware_id, ACPI_MEMORY_DEVICE_HID)))
                status = AE_ERROR;
 
-       acpi_os_free(buffer.pointer);
+       kfree(buffer.pointer);
        return status;
 }
 
 
                }
                hotk->methods = &model_conf[hotk->model];
                
-               acpi_os_free(model);
+               kfree(model);
 
                return AE_OK;
        }
                /* S1300A reports L84F, but L1400B too, account for that */
        }
 
-       acpi_os_free(model);
+       kfree(model);
 
        return AE_OK;
 }
        acpi_bus_unregister_driver(&asus_hotk_driver);
        remove_proc_entry(PROC_ASUS, acpi_root_dir);
 
-       acpi_os_free(asus_info);
+       kfree(asus_info);
 
        return;
 }
 
        }
 
       end:
-       acpi_os_free(buffer.pointer);
+       kfree(buffer.pointer);
 
        if (!result)
                (*bif) = (struct acpi_battery_info *)data.pointer;
        }
 
       end:
-       acpi_os_free(buffer.pointer);
+       kfree(buffer.pointer);
 
        if (!result)
                (*bst) = (struct acpi_battery_status *)data.pointer;
 
        }
 
       end:
-       acpi_os_free(buffer.pointer);
+       kfree(buffer.pointer);
 
        return AE_OK;
 }
 
                bbn = bus;
        }
       exit:
-       acpi_os_free(buffer.pointer);
+       kfree(buffer.pointer);
        return (int)bbn;
 }
 
                find->handle = handle;
        status = AE_OK;
       exit:
-       acpi_os_free(buffer.pointer);
+       kfree(buffer.pointer);
        return status;
 }
 
                info = buffer.pointer;
                if (info->address == find->address)
                        find->handle = handle;
-               acpi_os_free(buffer.pointer);
+               kfree(buffer.pointer);
        }
        return AE_OK;
 }
 
                acpi_get_name(dev->firmware_data, ACPI_FULL_PATHNAME, &buffer);
                DBG("Device %s -> %s\n", dev->bus_id, (char *)buffer.pointer);
-               acpi_os_free(buffer.pointer);
+               kfree(buffer.pointer);
        } else
                DBG("Device %s -> No ACPI support\n", dev->bus_id);
 #endif
 
 
                /* Caller used ACPI_ALLOCATE_BUFFER, free the return buffer */
 
-               acpi_os_free(return_buffer->pointer);
+               ACPI_FREE(return_buffer->pointer);
                return_buffer->pointer = NULL;
        }
 
 
                return kmalloc(size, GFP_KERNEL);
 }
 
-void acpi_os_free(void *ptr)
-{
-       kfree(ptr);
-}
-
-EXPORT_SYMBOL(acpi_os_free);
-
 acpi_status acpi_os_get_root_pointer(u32 flags, struct acpi_pointer *addr)
 {
        if (efi_enabled) {
 
        ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Deleting semaphore[%p].\n", handle));
 
-       acpi_os_free(sem);
+       kfree(sem);
        sem = NULL;
 
        return AE_OK;
 
                status = -EFAULT;
 
       end:
-       acpi_os_free(buffer.pointer);
+       kfree(buffer.pointer);
 
        return status;
 }
 
               sizeof(struct acpi_pct_register));
 
       end:
-       acpi_os_free(buffer.pointer);
+       kfree(buffer.pointer);
 
        return result;
 }
        }
 
       end:
-       acpi_os_free(buffer.pointer);
+       kfree(buffer.pointer);
 
        return result;
 }
        }
 
 end:
-       acpi_os_free(buffer.pointer);
+       kfree(buffer.pointer);
        return result;
 }
 
 
                goto end;
        }
 
-       acpi_os_free(buffer.pointer);
+       kfree(buffer.pointer);
 
        device->wakeup.flags.valid = 1;
        /* Power button, Lid switch always enable wakeup */
                        printk(KERN_ERR "Memory allocation error\n");
        }
 
-       acpi_os_free(buffer.pointer);
+       kfree(buffer.pointer);
 }
 
 static int acpi_device_set_context(struct acpi_device *device, int type)
 
 
        res = simple_read_from_buffer(buffer, count, ppos,
                                      dsdt.pointer, dsdt.length);
-       acpi_os_free(dsdt.pointer);
+       kfree(dsdt.pointer);
 
        return res;
 }
 
        res = simple_read_from_buffer(buffer, count, ppos,
                                      fadt.pointer, fadt.length);
-       acpi_os_free(fadt.pointer);
+       kfree(fadt.pointer);
 
        return res;
 }
 
 
        /* Free memory lists */
 
-       acpi_os_free(acpi_gbl_global_list);
+       ACPI_FREE(acpi_gbl_global_list);
        acpi_gbl_global_list = NULL;
 
-       acpi_os_free(acpi_gbl_ns_node_list);
+       ACPI_FREE(acpi_gbl_ns_node_list);
        acpi_gbl_ns_node_list = NULL;
 #endif
 
 
 
        /* Now we can delete the cache object */
 
-       acpi_os_free(cache);
+       ACPI_FREE(cache);
        return (AE_OK);
 }
 
 
 
        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Return value [%s]\n", *data));
 
-       acpi_os_free(buffer.pointer);
+       kfree(buffer.pointer);
 
        return AE_OK;
 }
                //kfree(list->handles);
        }
 
-       acpi_os_free(buffer.pointer);
+       kfree(buffer.pointer);
 
        return status;
 }
 
        video->attached_array = active_device_list;
        video->attached_count = count;
       out:
-       acpi_os_free(buffer.pointer);
+       kfree(buffer.pointer);
        return status;
 }
 
 
 
 #define ACPI_ALLOCATE(a)            acpi_ut_allocate((acpi_size)(a),_COMPONENT,_acpi_module_name,__LINE__)
 #define ACPI_ALLOCATE_ZEROED(a)     acpi_ut_allocate_zeroed((acpi_size)(a), _COMPONENT,_acpi_module_name,__LINE__)
-#define ACPI_FREE(a)                acpi_os_free(a)
+#define ACPI_FREE(a)                kfree(a)
 #define ACPI_MEM_TRACKING(a)
 
 #else
 
  */
 void *acpi_os_allocate(acpi_size size);
 
-void acpi_os_free(void *memory);
-
 acpi_status
 acpi_os_map_memory(acpi_physical_address physical_address,
                   acpi_size size, void __iomem ** logical_address);