haiku.git

/*
 * Copyright 2009-2015, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Axel Dörfler, axeld@pinc-software.de
 *		Clemens Zeidler, haiku@clemens-zeidler.de
 */


#include "ACPIDriverInterface.h"

#include <errno.h>
#include <stdio.h>
#include <string.h>

#include <Autolock.h>
#include <Directory.h>
#include <Entry.h>
#include <Path.h>


static const char* kDriverDir = "/dev/power";


RateBuffer::RateBuffer()
	:
	fPosition(0),
	fSize(kRateBufferSize),
	fCurrentSize(0)
{
}


void
RateBuffer::AddRate(int32 rate)
{
	fRateBuffer[fPosition] = rate;
	fPosition ++;
	if (fPosition >= fSize)
		fPosition = 0;

	if (fCurrentSize < fSize)
		fCurrentSize ++;
}


int32
RateBuffer::GetMeanRate()
{
	int32 mean = 0;
	for (int8 i = 0; i < fCurrentSize; i++) {
		mean += fRateBuffer[i];
	}

	if (fCurrentSize == 0)
		return -1;

	return mean / fCurrentSize;
}


// #pragma mark -


Battery::Battery(int driverHandler)
	:
	fDriverHandler(driverHandler)
{
	_Init();
}


Battery::~Battery()
{
	close(fDriverHandler);
}


status_t
Battery::InitCheck()
{
	return fInitStatus;
}


status_t
Battery::UpdateBatteryInfo()
{
	acpi_battery_info info;
	if (ioctl(fDriverHandler, GET_BATTERY_INFO, &info,
			sizeof(acpi_battery_info)) != 0)
		return errno;

	if ((fExtendedBatteryInfo.last_full_charge > 0
			&& info.capacity > fExtendedBatteryInfo.last_full_charge)
		|| info.capacity < 0)
		return B_BAD_DATA;

	if ((fCachedInfo.capacity == 0 && info.capacity > 0)
		|| (fCachedInfo.capacity > 0 && info.capacity == 0)) {
		// if capacity went from zero to non-zero or vice-versa, we likely just had a battery
		// connected or disconnected from the system so refresh the full fExtendedBatteryInfo
		GetExtendedBatteryInfo(&fExtendedBatteryInfo);
	}

	fCachedInfo = info;
	return B_OK;
}


status_t
Battery::GetBatteryInfoCached(battery_info* info)
{
	info->state = fCachedInfo.state;
	info->current_rate = fCachedInfo.current_rate;
	info->capacity = fCachedInfo.capacity;
	info->full_capacity = fExtendedBatteryInfo.last_full_charge;
	if (info->full_capacity < 0)
		info->full_capacity = fExtendedBatteryInfo.design_capacity;

	fRateBuffer.AddRate(fCachedInfo.current_rate);
	if (fCachedInfo.current_rate > 0 && fRateBuffer.GetMeanRate() != 0) {
		info->time_left = 3600 * fCachedInfo.capacity
			/ fRateBuffer.GetMeanRate();
	} else
		info->time_left = -1;

	return B_OK;
}


status_t
Battery::GetExtendedBatteryInfo(acpi_extended_battery_info* info)
{
	if (ioctl(fDriverHandler, GET_EXTENDED_BATTERY_INFO, info,
			sizeof(acpi_extended_battery_info)) != 0)
		return errno;

	return B_OK;
}


void
Battery::_Init()
{
	uint32 magicId = 0;
	if (ioctl(fDriverHandler, IDENTIFY_DEVICE, &magicId, sizeof(uint32)) != 0) {
		fInitStatus = errno;
		return;
	}
	fInitStatus = GetExtendedBatteryInfo(&fExtendedBatteryInfo);
	if (fInitStatus != B_OK)
		return;

	printf("ACPI driver found\n");
	UpdateBatteryInfo();
}


// #pragma mark - ACPIDriverInterface


ACPIDriverInterface::ACPIDriverInterface()
	:
	fInterfaceLocker("acpi interface")
{
}


ACPIDriverInterface::~ACPIDriverInterface()
{
	for (int i = 0; i < fDriverList.CountItems(); i++)
		delete fDriverList.ItemAt(i);
}


status_t
ACPIDriverInterface::Connect()
{
	return _FindDrivers(kDriverDir);
}


status_t
ACPIDriverInterface::GetBatteryInfo(int32 index, battery_info* info)
{
	BAutolock autolock(fInterfaceLocker);
	if (index < 0 || index >= fDriverList.CountItems())
		return B_ERROR;

	return fDriverList.ItemAt(index)->GetBatteryInfoCached(info);
}


status_t
ACPIDriverInterface::GetExtendedBatteryInfo(int32 index,
	acpi_extended_battery_info* info)
{
	BAutolock autolock(fInterfaceLocker);
	if (index < 0 || index >= fDriverList.CountItems())
		return B_ERROR;

	return fDriverList.ItemAt(index)->GetExtendedBatteryInfo(info);
}


int32
ACPIDriverInterface::GetBatteryCount()
{
	return fDriverList.CountItems();
}


status_t
ACPIDriverInterface::_UpdateBatteryInfo()
{
	for (int i = 0; i < fDriverList.CountItems(); i++)
		fDriverList.ItemAt(i)->UpdateBatteryInfo();

	return B_OK;
}


void
ACPIDriverInterface::_WatchPowerStatus()
{
	const bigtime_t kUpdateInterval = 2000000;
		// every two seconds

	while (atomic_get(&fIsWatching) > 0) {
		_UpdateBatteryInfo();
		Broadcast(kMsgUpdate);
		acquire_sem_etc(fWaitSem, 1, B_RELATIVE_TIMEOUT, kUpdateInterval);
	}
}


status_t
ACPIDriverInterface::_FindDrivers(const char* dirpath)
{
	BDirectory dir(dirpath);
	BEntry entry;

	status_t status = B_ERROR;

	while (dir.GetNextEntry(&entry) == B_OK) {
		BPath path;
		entry.GetPath(&path);

		if (entry.IsDirectory()) {
			if (_FindDrivers(path.Path()) == B_OK)
				return B_OK;
		} else {
			int32 handler = open(path.Path(), O_RDWR);
			if (handler >= 0) {
				printf("try %s\n", path.Path());
				Battery* battery = new Battery(handler);
				if (battery->InitCheck() == B_OK
					&& fDriverList.AddItem(battery)) {
					status = B_OK;
				} else
					delete battery;
			}
		}
	}
	return status;
}