Ticket #2841: acpi-battery.diff

build/jam/HaikuImage

@@ -142 +142 @@
         $(X86_ONLY)marvell_yukon $(X86_ONLY)syskonnect usb_ecm
         $(GPL_ONLY)bcm440x $(GPL_ONLY)bcm570x
 ;
-#BEOS_ADD_ONS_DRIVERS_ACPI = $(X86_ONLY)acpi_button ;
+BEOS_ADD_ONS_DRIVERS_ACPI = $(X86_ONLY)acpi_button ;
 BEOS_ADD_ONS_BUS_MANAGERS = pci $(X86_ONLY)ps2 $(X86_ONLY)isa ide scsi
         config_manager agp_gart usb firewire $(X86_ONLY)acpi
 ;
@@ -185 +185 @@
 # drivers
 AddNewDriversToHaikuImage disk scsi     : scsi_cd scsi_disk ;
 
+# acpi
+AddNewDriversToHaikuImage power : acpi_thermal acpi_battery ;
+
 # legacy drivers
 AddDriversToHaikuImage                          : console dprintf $(X86_ONLY)keyboard null
                                                                           random <driver>tty zero ;
@@ -199 +202 @@
 AddDriversToHaikuImage input            : ps2_hid usb_hid wacom ;
 AddDriversToHaikuImage misc                     : <driver>poke <driver>test ;
 AddDriversToHaikuImage net                      : $(BEOS_ADD_ONS_DRIVERS_NET) ;
-#AddDriversToHaikuImage power           : $(BEOS_ADD_ONS_DRIVERS_ACPI) ;
+AddDriversToHaikuImage power            : $(BEOS_ADD_ONS_DRIVERS_ACPI) ;
 
 # kernel
 AddFilesToHaikuImage beos system : <revisioned>kernel_$(TARGET_ARCH) ;

src/add-ons/kernel/bus_managers/acpi/acpi_module.c

@@ -13 +13 @@
 #include <PCI.h>
 
 
-//#define TRACE_ACPI_MODULE
+#define TRACE_ACPI_MODULE
 #ifdef TRACE_ACPI_MODULE
 #       define TRACE(x) dprintf x
 #else
@@ -112 +112 @@
                         get_device_hid(result, hid);
 
                         if (gDeviceManager->register_node(node, ACPI_DEVICE_MODULE_NAME, attrs, NULL, &deviceNode) == B_OK)
-                                acpi_enumerate_child_devices(deviceNode, result);
+            {
+                TRACE(("acpi_enumerate_child_devices: registered %s\n", hid));
+                //acpi_enumerate_child_devices(deviceNode, result);
+                acpi_enumerate_child_devices(node, result);
+            }
+            else
+            {
+                TRACE(("acpi_enumerate_child_devices: failed to register %s. Ignoring and continuing recursion\n", hid));
+                //acpi_enumerate_child_devices(node, result);
+            }
+
                         break;
                 }
                 case ACPI_TYPE_POWER:

src/add-ons/kernel/bus_managers/acpi/acpi_busman.c

@@ -22 +22 @@
 #include "acpixf.h"
 #include "acpi_priv.h"
 
-//#define TRACE_ACPI_BUS
+#define TRACE_ACPI_BUS
 #ifdef TRACE_ACPI_BUS
 #define TRACE(x...) dprintf("acpi: " x)
 #else
@@ -100 +100 @@
                                 }
                         }
 
+            acpiDisabled = false;
+
                         if (acpiDisabled) {
                                 ERROR("ACPI disabled\n");
                                 return ENOSYS;

src/add-ons/kernel/drivers/power/acpi_battery/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src add-ons kernel drivers power acpi_battery ;
+
+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_battery :
+        acpi_battery.c
+        ;
+
+Depends acpi_battery : acpi ;

src/add-ons/kernel/drivers/power/acpi_battery/acpi_battery.c

@@ +1 @@
+/*
+ * Copyright 2008, Haiku, Inc. All Rights Reserved.
+ *
+ * Distributed under the terms of the MIT License.
+ */
+
+#include <KernelExport.h>
+#include <Drivers.h>
+#include <Errors.h>
+#include <string.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <ACPI.h>
+#include "acpi_battery.h"
+
+#define ACPI_BATTERY_MODULE_NAME "drivers/power/acpi_battery/driver_v1"
+
+#define ACPI_BATTERY_DEVICE_MODULE_NAME "drivers/power/acpi_battery/device_v1"
+
+/* Base Namespace devices are published to */
+#define ACPI_BATTERY_BASENAME "power/acpi_battery/%d"
+
+// name of pnp generator of path ids
+#define ACPI_BATTERY_PATHID_GENERATOR "acpi_battery/path_id"
+
+static device_manager_info *sDeviceManager;
+
+typedef struct acpi_ns_device_info {
+        device_node *node;
+        acpi_device_module_info *acpi;
+        acpi_device acpi_cookie;
+} acpi_battery_device_info;
+
+static inline char *acpi_battery_units(struct acpi_battery_type *battery)
+{
+        return (battery->power_unit)?"mA":"mW";
+}
+
+static int acpi_extract_package(struct acpi_battery_type *battery,
+                                acpi_object_type *package,
+                                struct acpi_offsets *offsets, int num)
+{
+        int i;
+        acpi_object_type *element;
+
+        if (package->object_type != ACPI_TYPE_PACKAGE)
+                return B_ERROR;
+
+        for (i = 0; i < num; ++i) {
+                if (package->data.package.count <= i)
+                        return B_ERROR;
+
+                element = &package->data.package.objects[i];
+                if (offsets[i].mode) {
+                        uint8 *ptr = (uint8 *)battery + offsets[i].offset;
+                        if (element->object_type == ACPI_TYPE_STRING ||
+                            element->object_type == ACPI_TYPE_BUFFER)
+                                strncpy(ptr, element->data.string.string, 32);
+                        else if (element->object_type == ACPI_TYPE_INTEGER) {
+                                strncpy(ptr, (uint8 *)&element->data.integer,
+                                        sizeof(uint32));
+                                ptr[sizeof(uint32)] = 0;
+                        } else
+                                *ptr = 0; /* don't have value */
+                } else {
+                        int *x = (int *)((uint8 *)battery + offsets[i].offset);
+                        *x = (element->object_type == ACPI_TYPE_INTEGER) ?
+                                element->data.integer : -1;
+                }
+        }
+        return B_OK;
+}
+
+static status_t
+acpi_battery_init_device(void *_cookie, void **cookie)
+{
+        device_node *node = (device_node *)_cookie;
+        acpi_battery_device_info *device;
+        device_node *parent;
+        
+        device = (acpi_battery_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_battery_uninit_device(void *_cookie)
+{
+        acpi_battery_device_info *device = (acpi_battery_device_info *)_cookie;
+        free(device);
+}
+
+
+static status_t
+acpi_battery_open(void *_cookie, const char *path, int flags, void** cookie)
+{
+        acpi_battery_device_info *device = (acpi_battery_device_info *)_cookie;
+        *cookie = device;
+        return B_OK;
+}
+
+
+static status_t
+acpi_battery_control(void* _cookie, uint32 op, void* arg, size_t len)
+{
+        acpi_battery_device_info* device = (acpi_battery_device_info*)_cookie;
+        status_t err = B_ERROR;
+
+        acpi_battery_type *att = NULL;
+
+        size_t bufsize = sizeof(acpi_object_type);
+        acpi_object_type buf;
+
+        switch (op) {
+                case drvOpGetBatteryState: {
+                        dprintf("acpi_battery: GetBatteryState() ");
+                        att = (acpi_battery_type *)arg;
+
+                        err = device->acpi->evaluate_method(device->acpi_cookie, "_BST", &buf, bufsize, NULL, 0);
+
+                        if (err != B_OK)
+                                break;
+
+                        err = acpi_extract_package(att, &buf, state_offsets, ARRAY_SIZE(state_offsets));
+                        break;
+                }
+                case drvOpGetBatteryInfo: {
+                        dprintf("acpi_battery: GetBatteryInfo() ");
+                        att = (acpi_battery_type *)arg;
+
+                        err = device->acpi->evaluate_method(device->acpi_cookie, "_BIF", &buf, bufsize, NULL, 0);
+
+                        if (err != B_OK)
+                                break;
+
+                        err = acpi_extract_package(att, &buf, info_offsets, ARRAY_SIZE(info_offsets));
+                        break;
+                }
+        }
+
+        if (err == B_OK)
+                dprintf("OK\n");
+        else
+                dprintf("ERROR!\n");
+
+        return err;
+}
+
+
+static status_t
+acpi_battery_read(void* _cookie, off_t position, void *buf, size_t* num_bytes)
+{
+        acpi_battery_device_info* device = (acpi_battery_device_info*)_cookie;
+        acpi_battery_type battery;
+
+        if (*num_bytes < 1)
+                return B_IO_ERROR;
+
+        if (position == 0) {
+                size_t max_len = *num_bytes;
+                char *str = (char *)buf;
+
+                dprintf("acpi_battery: read()\n");
+
+                acpi_battery_control(device, drvOpGetBatteryInfo, &battery, 0);
+                acpi_battery_control(device, drvOpGetBatteryState, &battery, 0);
+
+                snprintf(str, max_len, "Capacity state: %s\n",
+                         (battery.state & 0x04) ? "critical" : "ok");
+
+                max_len -= strlen(str);
+                str += strlen(str);
+
+                if ((battery.state & 0x01) && (battery.state & 0x02))
+                        snprintf(str, max_len, "Charging state: charging/discharging\n");
+                else if (battery.state & 0x01)
+                        snprintf(str, max_len, "Charging state: discharging\n");
+                else if (battery.state & 0x02)
+                        snprintf(str, max_len, "Charging state: charging\n");
+                else
+                        snprintf(str, max_len, "Charging state: charged\n");
+
+                max_len -= strlen(str);
+                str += strlen(str);
+
+                if (battery.current_now == ACPI_BATTERY_VALUE_UNKNOWN)
+                        snprintf(str, max_len, "Present rate: unknown\n");
+                else
+                        snprintf(str, max_len, "Present rate: %d %s\n",
+                                 battery.current_now, acpi_battery_units(&battery));
+
+                max_len -= strlen(str);
+                str += strlen(str);
+
+                if (battery.capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
+                        snprintf(str, max_len, "Remaining capacity: unknown\n");
+                else
+                        snprintf(str, max_len, "Remaining capacity: %d %sh\n",
+                                 battery.capacity_now, acpi_battery_units(&battery));
+
+                max_len -= strlen(str);
+                str += strlen(str);
+                
+                if (battery.voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
+                        snprintf(str, max_len, "Present voltage: unknown\n");
+                else
+                        snprintf(str, max_len, "Present voltage: %d mV\n",
+                                 battery.voltage_now);
+
+                max_len -= strlen(str);
+                str += strlen(str);
+
+                //*num_bytes = strlen((char *)buf);
+
+                if (battery.design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
+                        snprintf(str, max_len, "Design capacity: unknown\n");
+                else
+                        snprintf(str, max_len, "Design capacity: %d %sh\n",
+                                 battery.design_capacity, acpi_battery_units(&battery));
+                
+                max_len -= strlen(str);
+                str += strlen(str);
+
+                if (battery.full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
+                        snprintf(str, max_len, "Last full capacity: unknown\n");
+                else
+                        snprintf(str, max_len, "Last full capacity: %d %sh\n",
+                                 battery.full_charge_capacity, acpi_battery_units(&battery));
+
+                max_len -= strlen(str);
+                str += strlen(str);
+
+                snprintf(str, max_len, "Battery technology: %srechareable\n",
+                         (!battery.technology)?"non-":"");
+                
+                max_len -= strlen(str);
+                str += strlen(str);
+
+                if (battery.design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
+                        snprintf(str, max_len, "Design voltage: unknown\n");
+                else
+                        snprintf(str, max_len, "Design voltage: %d mV\n",
+                                 battery.design_voltage);
+
+                max_len -= strlen(str);
+                str += strlen(str);
+
+                snprintf(str, max_len, "Design capacity warning: %d %sh\n",
+                         battery.design_capacity_warning, acpi_battery_units(&battery));
+
+                max_len -= strlen(str);
+                str += strlen(str);
+
+                snprintf(str, max_len, "Design capacity low: %d %sh\n",
+                         battery.design_capacity_low, acpi_battery_units(&battery));
+
+                max_len -= strlen(str);
+                str += strlen(str);
+
+                snprintf(str, max_len, "Capacity granularity 1: %d %sh\n",
+                         battery.capacity_granularity_1, acpi_battery_units(&battery));
+
+                max_len -= strlen(str);
+                str += strlen(str);
+
+                snprintf(str, max_len, "Capacity granularity 2: %d %sh\n",
+                         battery.capacity_granularity_2, acpi_battery_units(&battery));
+
+                max_len -= strlen(str);
+                str += strlen(str);
+
+                snprintf(str, max_len, "Model number: %s\n", battery.model_number);
+
+                max_len -= strlen(str);
+                str += strlen(str);
+
+                snprintf(str, max_len, "Serial number: %s\n", battery.serial_number);
+
+                max_len -= strlen(str);
+                str += strlen(str);
+
+                snprintf(str, max_len, "Battery type: %s\n", battery.type);
+
+                max_len -= strlen(str);
+                str += strlen(str);
+
+                snprintf(str, max_len, "OEM info: %s\n", battery.oem_info);
+
+                *num_bytes = strlen((char *)buf);
+                
+        } else {
+                *num_bytes = 0;
+        }
+
+        return B_OK;
+}
+
+
+static status_t
+acpi_battery_write(void* cookie, off_t position, const void* buffer, size_t* num_bytes)
+{
+        return B_ERROR;
+}
+
+
+static status_t
+acpi_battery_close (void* cookie)
+{
+        return B_OK;
+}
+
+
+static status_t
+acpi_battery_free (void* cookie)
+{       
+        return B_OK;
+}
+
+
+//      #pragma mark - driver module API
+
+
+static float
+acpi_battery_support(device_node *parent)
+{
+        const char *bus;
+        uint32 device_type;
+        const char *hid;
+
+        dprintf("acpi_battery_support\n");
+
+        // make sure parent is really the ACPI bus manager
+        if (sDeviceManager->get_attr_string(parent, B_DEVICE_BUS, &bus, false))
+        {
+                dprintf("acpi_battery: this is not an ACPI bus manager\n");
+                return -1;
+        }
+        
+        if (strcmp(bus, "acpi"))
+        {
+                dprintf("acpi_battery: bus acpi != %s\n", bus);
+                return 0.0;
+        }
+
+        // check whether it's really a device
+        if (sDeviceManager->get_attr_uint32(parent, ACPI_DEVICE_TYPE_ITEM, &device_type, false) != B_OK
+                || device_type != ACPI_TYPE_DEVICE) {
+                dprintf("acpi_battery: this is not an ACPI device\n");
+                return 0.0;
+        }
+
+        if (sDeviceManager->get_attr_string(parent, ACPI_DEVICE_HID_ITEM, &hid, false) != B_OK
+                || strcmp(hid, "PNP0C0A")) {
+                dprintf("acpi_battery: not a battery %s != PNP0C0A\n", hid);
+                return 0.0;
+        }
+
+        dprintf("acpi_battery: got it man!\n");
+
+        return 0.6;
+}
+
+
+static status_t
+acpi_battery_register_device(device_node *node)
+{
+        device_attr attrs[] = {
+                { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { string: "ACPI Battery" }},
+                { NULL }
+        };
+
+        return sDeviceManager->register_node(node, ACPI_BATTERY_MODULE_NAME, attrs, NULL, NULL);
+}
+
+
+static status_t
+acpi_battery_init_driver(device_node *node, void **_driverCookie)
+{
+        *_driverCookie = node;
+        return B_OK;
+}
+
+
+static void
+acpi_battery_uninit_driver(void *driverCookie)
+{
+}
+
+
+static status_t
+acpi_battery_register_child_devices(void *_cookie)
+{
+        device_node *node = _cookie;
+        int path_id;
+        char name[128];
+
+        dprintf("acpi_battery_register_child_devices\n");
+                
+        path_id = sDeviceManager->create_id(ACPI_BATTERY_PATHID_GENERATOR);
+        if (path_id < 0) {
+                dprintf("acpi_battery_register_child_devices: couldn't create a path_id\n");
+                return B_ERROR;
+        }
+        
+        snprintf(name, sizeof(name), ACPI_BATTERY_BASENAME, path_id);
+
+    /* TODO: register the other device (use state and info) */
+                
+        return sDeviceManager->publish_device(node, name, ACPI_BATTERY_DEVICE_MODULE_NAME);
+}
+
+
+module_dependency module_dependencies[] = {
+        { B_DEVICE_MANAGER_MODULE_NAME, (module_info **)&sDeviceManager },
+        {}
+};
+
+
+driver_module_info acpi_battery_driver_module = {
+        {
+                ACPI_BATTERY_MODULE_NAME,
+                0,
+                NULL
+        },
+
+        acpi_battery_support,
+        acpi_battery_register_device,
+        acpi_battery_init_driver,
+        acpi_battery_uninit_driver,
+        acpi_battery_register_child_devices,
+        NULL,   // rescan
+        NULL,   // removed
+};
+
+
+struct device_module_info acpi_battery_device_module = {
+        {
+                ACPI_BATTERY_DEVICE_MODULE_NAME,
+                0,
+                NULL
+        },
+
+        acpi_battery_init_device,
+        acpi_battery_uninit_device,
+        NULL,
+
+        acpi_battery_open,
+        acpi_battery_close,
+        acpi_battery_free,
+        acpi_battery_read,
+        acpi_battery_write,
+        NULL,
+        acpi_battery_control,
+
+        NULL,
+        NULL
+};
+
+module_info *modules[] = {
+        (module_info *)&acpi_battery_driver_module,
+        (module_info *)&acpi_battery_device_module,
+        NULL
+};

src/add-ons/kernel/drivers/power/acpi_battery/acpi_battery.h

@@ +1 @@
+/*
+ * Copyright 2008, Haiku, Inc. All Rights Reserved.
+ *
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _ACPI_BATTERY_H
+#define _ACPI_BATTERY_H
+
+#include <KernelExport.h>
+#include <ACPI.h>
+
+enum { /* ioctl op-codes */
+        drvOpGetBatteryState = B_DEVICE_OP_CODES_END + 1001,
+        drvOpGetBatteryInfo  = B_DEVICE_OP_CODES_END + 1002,
+};
+
+typedef struct acpi_battery_type acpi_battery_type;
+
+struct acpi_battery_type {
+        int current_now;
+        int capacity_now;
+        int voltage_now;
+        int design_capacity;
+        int full_charge_capacity;
+        int technology;
+        int design_voltage;
+        int design_capacity_warning;
+        int design_capacity_low;
+        int capacity_granularity_1;
+        int capacity_granularity_2;
+        char model_number[32];
+        char serial_number[32];
+        char type[32];
+        char oem_info[32];
+        int state;
+        int power_unit;
+};
+
+struct acpi_offsets {
+        size_t offset;          /* offset inside struct acpi_sbs_battery */
+        uint8 mode;                /* int or string? */
+};
+
+static struct acpi_offsets state_offsets[] = {
+        {offsetof(struct acpi_battery_type, state), 0},
+        {offsetof(struct acpi_battery_type, current_now), 0},
+        {offsetof(struct acpi_battery_type, capacity_now), 0},
+        {offsetof(struct acpi_battery_type, voltage_now), 0},
+};
+
+static struct acpi_offsets info_offsets[] = {
+        {offsetof(struct acpi_battery_type, power_unit), 0},
+        {offsetof(struct acpi_battery_type, design_capacity), 0},
+        {offsetof(struct acpi_battery_type, full_charge_capacity), 0},
+        {offsetof(struct acpi_battery_type, technology), 0},
+        {offsetof(struct acpi_battery_type, design_voltage), 0},
+        {offsetof(struct acpi_battery_type, design_capacity_warning), 0},
+        {offsetof(struct acpi_battery_type, design_capacity_low), 0},
+        {offsetof(struct acpi_battery_type, capacity_granularity_1), 0},
+        {offsetof(struct acpi_battery_type, capacity_granularity_2), 0},
+        {offsetof(struct acpi_battery_type, model_number), 1},
+        {offsetof(struct acpi_battery_type, serial_number), 1},
+        {offsetof(struct acpi_battery_type, type), 1},
+        {offsetof(struct acpi_battery_type, oem_info), 1},
+};
+
+#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
+#define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF
+
+#endif /* _ACPI_BATTERY_H */

src/add-ons/kernel/drivers/power/Jamfile

@@ -2 +2 @@
 
 SubInclude HAIKU_TOP src add-ons kernel drivers power acpi_button ;
 SubInclude HAIKU_TOP src add-ons kernel drivers power acpi_thermal ;
+SubInclude HAIKU_TOP src add-ons kernel drivers power acpi_battery ;