Ticket #8451: 0001-acpi_cpuidle-try-to-decode-cstate-from-acpi-_CST.patch

new file src/add-ons/kernel/drivers/power/acpi_cpuidle/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src add-ons kernel drivers power acpi_cpuidle ;
+
+SetSubDirSupportedPlatformsBeOSCompatible ;
+
+if $(TARGET_PLATFORM) != haiku {
+    # Needed for <ACPI.h>. Unfortunately we also get the other headers there,
+    # that we don't really want.
+    UsePublicHeaders drivers ;
+}
+
+KernelAddon acpi_cpuidle :
+    acpi_cpuidle.c
+    ;
+
+Depends acpi_cpuidle : acpi ;

new file src/add-ons/kernel/drivers/power/acpi_cpuidle/acpi_cpuidle.c

@@ +1 @@
+/*
+ * Copyright 2012, Haiku, Inc. All Rights Reserved.
+ *
+ * Distributed under the terms of the MIT License.
+ *
+ * Authors:
+ *      Yongcong Du <ycdu.vmcore@gmail.com>
+ */
+
+#include <KernelExport.h>
+#include <Drivers.h>
+#include <Errors.h>
+#include <string.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <ACPI.h>
+
+#define ACPI_CPUIDLE_MODULE_NAME "drivers/power/acpi_cpuidle/driver_v1"
+
+#define ACPI_CPUIDLE_DEVICE_MODULE_NAME "drivers/power/acpi_cpuidle/device_v1"
+
+/* Base Namespace devices are published to */
+#define ACPI_CPUIDLE_BASENAME "power/acpi_cpuidle/%d"
+
+// name of pnp generator of path ids
+#define ACPI_CPUIDLE_PATHID_GENERATOR "acpi_cpuidle/path_id"
+
+static device_manager_info *sDeviceManager;
+
+struct acpicpu_reg {
+    uint8   reg_desc;
+    uint16  reg_reslen;
+    uint8   reg_spaceid;
+    uint8   reg_bitwidth;
+    uint8   reg_bitoffset;
+    uint8   reg_accesssize;
+    uint64  reg_addr;
+} __packed;
+
+
+typedef struct acpi_ns_device_info {
+    device_node *node;
+    acpi_device_module_info *acpi;
+    acpi_device acpi_cookie;
+} acpi_cpuidle_device_info;
+
+
+static status_t
+acpi_cpuidle_open(void *_cookie, const char *path, int flags, void **cookie)
+{
+    acpi_cpuidle_device_info *device = (acpi_cpuidle_device_info *)_cookie;
+    *cookie = device;
+    return B_OK;
+}
+
+
+static void
+acpicpu_cstate_cst_add(acpi_object_type *object)
+{
+    acpi_object_type* pointer;
+    if (object->object_type != ACPI_TYPE_PACKAGE) {
+        dprintf("invalid _CST object\n");
+        return;
+    }
+    if (object->data.package.count != 4) {
+        dprintf("invalid _CST number\n");
+        return;
+    }
+    //type
+    pointer = &object->data.package.objects[1];
+    if (pointer->object_type != ACPI_TYPE_INTEGER) {
+        dprintf("invalid _CST elem type\n");
+        return;
+    }
+    uint32 n = pointer->data.integer;
+    if (n < 0 || n > 3) {
+        dprintf("invalid _CST elem value\n");
+        return;
+    }
+    dprintf("c%u\n", n);
+    //Latency
+    pointer = &object->data.package.objects[2];
+    if (pointer->object_type != ACPI_TYPE_INTEGER) {
+        dprintf("invalid _CST elem type\n");
+        return;
+    }
+    n = pointer->data.integer;
+    dprintf("Latency: %u\n", n);
+    //power
+    pointer = &object->data.package.objects[3];
+    if (pointer->object_type != ACPI_TYPE_INTEGER) {
+        dprintf("invalid _CST elem type\n");
+        return;
+    }
+    n = pointer->data.integer;
+    dprintf("power: %u\n", n);
+    //register
+    pointer = &object->data.package.objects[0];
+    if (pointer->object_type != ACPI_TYPE_BUFFER) {
+        dprintf("invalid _CST elem type\n");
+        return;
+    }
+    if (pointer->data.buffer.length < 15) {
+        dprintf("invalid _CST elem length\n");
+        return;
+    }
+    struct acpicpu_reg *reg = (struct acpicpu_reg *)pointer->data.buffer.buffer;
+    switch (reg->reg_spaceid) {
+        case ACPI_ADR_SPACE_SYSTEM_IO:
+            dprintf("IO method\n");
+            break;
+        case ACPI_ADR_SPACE_FIXED_HARDWARE:
+            dprintf("FFH method\n");
+            break;
+    }
+
+}
+
+
+static status_t
+acpi_cpuidle_read(void *_cookie, off_t position, void *buf, size_t *num_bytes)
+{
+    acpi_cpuidle_device_info* device = (acpi_cpuidle_device_info*)_cookie;
+
+    acpi_data buffer;
+    buffer.pointer = NULL;
+    buffer.length = ACPI_ALLOCATE_BUFFER;
+    acpi_object_type* object;
+    acpi_object_type* pointer;
+    status_t status = B_ERROR;
+    uint32 i;
+
+    if (*num_bytes < 1)
+        return B_IO_ERROR;
+    status = device->acpi->evaluate_method(device->acpi_cookie, "_CST", NULL,
+        &buffer);
+    if (status != B_OK) {
+        dprintf("failed to get _CST\n");
+        return B_IO_ERROR;
+    }
+
+    object = (acpi_object_type*)buffer.pointer;
+    if (object->object_type != ACPI_TYPE_PACKAGE)
+        dprintf("invalid _CST type\n");
+    if (object->data.package.count < 2)
+        dprintf("invalid _CST count\n");
+
+    pointer = object->data.package.objects;
+    if (pointer[0].object_type != ACPI_TYPE_INTEGER)
+        dprintf("invalid _CST type 2\n");
+    uint32 n = pointer[0].data.integer;
+    if (n != object->data.package.count-1)
+        dprintf("invalid _CST count 2\n");
+    if (n > 8)
+        dprintf("_CST has too many states\n");
+    for (i = 0; i < n; i++) {
+        pointer = &object->data.package.objects[i];
+        acpicpu_cstate_cst_add(pointer);
+    }
+
+    return B_OK;
+}
+
+
+static status_t
+acpi_cpuidle_write(void *cookie, off_t position, const void *buffer, size_t *num_bytes)
+{
+    return B_ERROR;
+}
+
+
+static status_t
+acpi_cpuidle_close (void *cookie)
+{
+    return B_OK;
+}
+
+
+static status_t
+acpi_cpuidle_free (void *cookie)
+{
+    return B_OK;
+}
+
+
+//  #pragma mark - driver module API
+
+
+static float
+acpi_cpuidle_support(device_node *parent)
+{
+    const char *bus;
+    uint32 device_type;
+
+    // make sure parent is really the ACPI bus manager
+    if (sDeviceManager->get_attr_string(parent, B_DEVICE_BUS, &bus, false))
+        return -1;
+
+    if (strcmp(bus, "acpi"))
+        return 0.0;
+
+    // check whether it's really a cpuidle Device
+    if (sDeviceManager->get_attr_uint32(parent, ACPI_DEVICE_TYPE_ITEM, &device_type, false) != B_OK
+        || device_type != ACPI_TYPE_PROCESSOR) {
+        return 0.0;
+    }
+
+    return 0.6;
+}
+
+
+static status_t
+acpi_cpuidle_register_device(device_node *node)
+{
+    device_attr attrs[] = {
+        { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { string: "ACPI CPU IDLE" }},
+        { NULL }
+    };
+
+    return sDeviceManager->register_node(node, ACPI_CPUIDLE_MODULE_NAME, attrs, NULL, NULL);
+}
+
+
+static status_t
+acpi_cpuidle_init_driver(device_node *node, void **_driverCookie)
+{
+    *_driverCookie = node;
+    return B_OK;
+}
+
+
+static void
+acpi_cpuidle_uninit_driver(void *driverCookie)
+{
+}
+
+
+static status_t
+acpi_cpuidle_register_child_devices(void *_cookie)
+{
+    device_node *node = _cookie;
+    int path_id;
+    char name[128];
+
+    path_id = sDeviceManager->create_id(ACPI_CPUIDLE_PATHID_GENERATOR);
+    if (path_id < 0) {
+        dprintf("acpi_cpuidle_register_child_devices: couldn't create a path_id\n");
+        return B_ERROR;
+    }
+    snprintf(name, sizeof(name), ACPI_CPUIDLE_BASENAME, path_id);
+
+    return sDeviceManager->publish_device(node, name, ACPI_CPUIDLE_DEVICE_MODULE_NAME);
+}
+
+static status_t
+acpi_cpuidle_init_device(void *_cookie, void **cookie)
+{
+    device_node *node = (device_node *)_cookie;
+    acpi_cpuidle_device_info *device;
+    device_node *parent;
+
+    device = (acpi_cpuidle_device_info *)calloc(1, sizeof(*device));
+    if (device == NULL)
+        return B_NO_MEMORY;
+
+    device->node = node;
+
+    parent = sDeviceManager->get_parent_node(node);
+    sDeviceManager->get_driver(parent, (driver_module_info **)&device->acpi,
+        (void **)&device->acpi_cookie);
+    sDeviceManager->put_node(parent);
+
+    *cookie = device;
+    return B_OK;
+}
+
+
+static void
+acpi_cpuidle_uninit_device(void *_cookie)
+{
+    acpi_cpuidle_device_info *device = (acpi_cpuidle_device_info *)_cookie;
+    free(device);
+}
+
+
+module_dependency module_dependencies[] = {
+    { B_DEVICE_MANAGER_MODULE_NAME, (module_info **)&sDeviceManager },
+    {}
+};
+
+
+driver_module_info acpi_cpuidle_driver_module = {
+    {
+        ACPI_CPUIDLE_MODULE_NAME,
+        0,
+        NULL
+    },
+
+    acpi_cpuidle_support,
+    acpi_cpuidle_register_device,
+    acpi_cpuidle_init_driver,
+    acpi_cpuidle_uninit_driver,
+    acpi_cpuidle_register_child_devices,
+    NULL,   // rescan
+    NULL,   // removed
+};
+
+
+struct device_module_info acpi_cpuidle_device_module = {
+    {
+        ACPI_CPUIDLE_DEVICE_MODULE_NAME,
+        0,
+        NULL
+    },
+
+    acpi_cpuidle_init_device,
+    acpi_cpuidle_uninit_device,
+    NULL,
+
+    acpi_cpuidle_open,
+    acpi_cpuidle_close,
+    acpi_cpuidle_free,
+    acpi_cpuidle_read,
+    acpi_cpuidle_write,
+    NULL,
+    NULL,
+
+    NULL,
+    NULL
+};
+
+module_info *modules[] = {
+    (module_info *)&acpi_cpuidle_driver_module,
+    (module_info *)&acpi_cpuidle_device_module,
+    NULL
+};