DrvACPI.cpp@ 22943

Last change on this file since 22943 was 22277, checked in by vboxsync, 15 years ago
PDMDRVREG change (big changeset).
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 29.3 KB

Line
1	/* $Id: DrvACPI.cpp 22277 2009-08-16 21:12:50Z vboxsync $ */
2	/** @file
3	* DrvACPI - ACPI Host Driver.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 Sun Microsystems, Inc.
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18	* Clara, CA 95054 USA or visit http://www.sun.com if you need
19	* additional information or have any questions.
20	*/
21
22	/*******************************************************************************
23	* Header Files *
24	*******************************************************************************/
25	#define LOG_GROUP LOG_GROUP_DRV_ACPI
26
27	#ifdef RT_OS_WINDOWS
28	# include <windows.h>
29	#endif
30
31	#include <VBox/pdmdrv.h>
32	#include <VBox/log.h>
33	#include <iprt/assert.h>
34	#include <iprt/string.h>
35
36	#ifdef RT_OS_LINUX
37	# include <iprt/string.h>
38	# include <sys/types.h>
39	# include <dirent.h>
40	# include <stdio.h>
41	#endif
42
43	#ifdef RT_OS_DARWIN
44	# include <Carbon/Carbon.h>
45	# include <IOKit/ps/IOPowerSources.h>
46	# include <IOKit/ps/IOPSKeys.h>
47	#endif
48
49	#ifdef RT_OS_FREEBSD
50	# include <sys/ioctl.h>
51	# include <dev/acpica/acpiio.h>
52	# include <sys/types.h>
53	# include <sys/sysctl.h>
54	# include <stdio.h>
55	# include <errno.h>
56	# include <fcntl.h>
57	# include <unistd.h>
58	#endif
59
60	#include "Builtins.h"
61
62
63	/*******************************************************************************
64	* Structures and Typedefs *
65	*******************************************************************************/
66	/**
67	* ACPI driver instance data.
68	*/
69	typedef struct DRVACPI
70	{
71	/** The ACPI interface. */
72	PDMIACPICONNECTOR IACPIConnector;
73	/** The ACPI port interface. */
74	PPDMIACPIPORT pPort;
75	/** Pointer to the driver instance. */
76	PPDMDRVINS pDrvIns;
77	} DRVACPI, *PDRVACPI;
78
79
80	/**
81	* Queries an interface to the driver.
82	*
83	* @returns Pointer to interface.
84	* @returns NULL if the interface was not supported by the driver.
85	* @param pInterface Pointer to this interface structure.
86	* @param enmInterface The requested interface identification.
87	* @thread Any thread.
88	*/
89	static DECLCALLBACK(void *) drvACPIQueryInterface(PPDMIBASE pInterface, PDMINTERFACE enmInterface)
90	{
91	PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
92	PDRVACPI pThis = PDMINS_2_DATA(pDrvIns, PDRVACPI);
93	switch (enmInterface)
94	{
95	case PDMINTERFACE_BASE:
96	return &pDrvIns->IBase;
97	case PDMINTERFACE_ACPI_CONNECTOR:
98	return &pThis->IACPIConnector;
99	default:
100	return NULL;
101	}
102	}
103
104	/**
105	* Get the current power source of the host system.
106	*
107	* @returns status code
108	* @param pInterface Pointer to the interface structure containing the called function pointer.
109	* @param pPowerSource Pointer to the power source result variable.
110	*/
111	static DECLCALLBACK(int) drvACPIQueryPowerSource(PPDMIACPICONNECTOR pInterface,
112	PDMACPIPOWERSOURCE *pPowerSource)
113	{
114	#if defined(RT_OS_WINDOWS)
115	SYSTEM_POWER_STATUS powerStatus;
116	if (GetSystemPowerStatus(&powerStatus))
117	{
118	/* running on battery? */
119	if ( (powerStatus.ACLineStatus == 0)
120	\|\| (powerStatus.ACLineStatus == 255)
121	&& (powerStatus.BatteryFlag & 15))
122	{
123	*pPowerSource = PDM_ACPI_POWER_SOURCE_BATTERY;
124	}
125	/* running on AC link? */
126	else if (powerStatus.ACLineStatus == 1)
127	{
128	*pPowerSource = PDM_ACPI_POWER_SOURCE_OUTLET;
129	}
130	else
131	/* what the hell we're running on? */
132	{
133	*pPowerSource = PDM_ACPI_POWER_SOURCE_UNKNOWN;
134	}
135	}
136	else
137	{
138	AssertMsgFailed(("Could not determine system power status, error: 0x%x\n",
139	GetLastError()));
140	*pPowerSource = PDM_ACPI_POWER_SOURCE_UNKNOWN;
141	}
142	#elif defined (RT_OS_LINUX) /* !RT_OS_WINDOWS */
143	DIR *dfd;
144	struct dirent *dp;
145	FILE *statusFile = NULL;
146	char buff[NAME_MAX+50];
147
148	/* start with no result */
149	*pPowerSource = PDM_ACPI_POWER_SOURCE_UNKNOWN;
150
151	dfd = opendir("/proc/acpi/ac_adapter/");
152	if (dfd)
153	{
154	for (;;)
155	{
156	dp = readdir(dfd);
157	if (dp == 0)
158	break;
159	if (strcmp(dp->d_name, ".") == 0 \|\|
160	strcmp(dp->d_name, "..") == 0)
161	continue;
162	strcpy(buff, "/proc/acpi/ac_adapter/");
163	strcat(buff, dp->d_name);
164	strcat(buff, "/status");
165	statusFile = fopen(buff, "r");
166	/* there's another possible name for this file */
167	if (!statusFile)
168	{
169	strcpy(buff, "/proc/acpi/ac_adapter/");
170	strcat(buff, dp->d_name);
171	strcat(buff, "/state");
172	statusFile = fopen(buff, "r");
173	}
174	if (statusFile)
175	break;
176	}
177	closedir(dfd);
178	}
179
180	if (statusFile)
181	{
182	for (;;)
183	{
184	char buff2[1024];
185	if (fgets(buff2, sizeof(buff), statusFile) == NULL)
186	break;
187	if (strstr(buff2, "Status:") != NULL \|\|
188	strstr(buff2, "state:") != NULL)
189	{
190	if (strstr(buff2, "on-line") != NULL)
191	*pPowerSource = PDM_ACPI_POWER_SOURCE_OUTLET;
192	else
193	*pPowerSource = PDM_ACPI_POWER_SOURCE_BATTERY;
194	}
195	}
196	fclose(statusFile);
197	}
198	#elif defined (RT_OS_DARWIN) /* !RT_OS_LINUX */
199	*pPowerSource = PDM_ACPI_POWER_SOURCE_UNKNOWN;
200
201	CFTypeRef pBlob = IOPSCopyPowerSourcesInfo();
202	CFArrayRef pSources = IOPSCopyPowerSourcesList(pBlob);
203
204	CFDictionaryRef pSource = NULL;
205	const void *psValue;
206	bool result;
207
208	if (CFArrayGetCount(pSources) > 0)
209	{
210	for(int i = 0; i < CFArrayGetCount(pSources); ++i)
211	{
212	pSource = IOPSGetPowerSourceDescription(pBlob, CFArrayGetValueAtIndex(pSources, i));
213	/* If the source is empty skip over to the next one. */
214	if(!pSource)
215	continue;
216	/* Skip all power sources which are currently not present like a
217	* second battery. */
218	if (CFDictionaryGetValue(pSource, CFSTR(kIOPSIsPresentKey)) == kCFBooleanFalse)
219	continue;
220	/* Only internal power types are of interest. */
221	result = CFDictionaryGetValueIfPresent(pSource, CFSTR(kIOPSTransportTypeKey), &psValue);
222	if (result &&
223	CFStringCompare((CFStringRef)psValue, CFSTR(kIOPSInternalType), 0) == kCFCompareEqualTo)
224	{
225	/* Check which power source we are connect on. */
226	result = CFDictionaryGetValueIfPresent(pSource, CFSTR(kIOPSPowerSourceStateKey), &psValue);
227	if (result &&
228	CFStringCompare((CFStringRef)psValue, CFSTR(kIOPSACPowerValue), 0) == kCFCompareEqualTo)
229	*pPowerSource = PDM_ACPI_POWER_SOURCE_OUTLET;
230	else if (result &&
231	CFStringCompare((CFStringRef)psValue, CFSTR(kIOPSBatteryPowerValue), 0) == kCFCompareEqualTo)
232	*pPowerSource = PDM_ACPI_POWER_SOURCE_BATTERY;
233	}
234	}
235	}
236	CFRelease(pBlob);
237	CFRelease(pSources);
238	#elif defined(RT_OS_FREEBSD) /* !RT_OS_DARWIN */
239	int fAcLine = 0;
240	size_t cbParameter = sizeof(fAcLine);
241
242	int rc = sysctlbyname("hw.acpi.acline", &fAcLine, &cbParameter, NULL, NULL);
243
244	if (!rc)
245	{
246	if (fAcLine == 1)
247	*pPowerSource = PDM_ACPI_POWER_SOURCE_OUTLET;
248	else if (fAcLine == 0)
249	*pPowerSource = PDM_ACPI_POWER_SOURCE_BATTERY;
250	else
251	*pPowerSource = PDM_ACPI_POWER_SOURCE_UNKNOWN;
252	}
253	else
254	{
255	AssertMsg(errno == ENOENT, ("rc=%d (%s)\n", rc, strerror(errno)));
256	*pPowerSource = PDM_ACPI_POWER_SOURCE_OUTLET;
257	}
258	#else /* !RT_OS_FREEBSD either - what could this be? */
259	*pPowerSource = PDM_ACPI_POWER_SOURCE_OUTLET;
260	#endif /* !RT_OS_WINDOWS */
261	return VINF_SUCCESS;
262	}
263
264	/**
265	* @copydoc PDMIACPICONNECTOR::pfnQueryBatteryStatus
266	*/
267	static DECLCALLBACK(int) drvACPIQueryBatteryStatus(PPDMIACPICONNECTOR pInterface, bool *pfPresent,
268	PPDMACPIBATCAPACITY penmRemainingCapacity,
269	PPDMACPIBATSTATE penmBatteryState,
270	uint32_t *pu32PresentRate)
271	{
272	/* default return values for all architectures */
273	pfPresent = false; / no battery present */
274	*penmBatteryState = PDM_ACPI_BAT_STATE_CHARGED;
275	*penmRemainingCapacity = PDM_ACPI_BAT_CAPACITY_UNKNOWN;
276	pu32PresentRate = ~0; / present rate is unknown */
277
278	#if defined(RT_OS_WINDOWS)
279	SYSTEM_POWER_STATUS powerStatus;
280	if (GetSystemPowerStatus(&powerStatus))
281	{
282	/* 128 means no battery present */
283	*pfPresent = !(powerStatus.BatteryFlag & 128);
284	/* just forward the value directly */
285	*penmRemainingCapacity = (PDMACPIBATCAPACITY)powerStatus.BatteryLifePercent;
286	/* we assume that we are discharging the battery if we are not on-line and
287	* not charge the battery */
288	uint32_t uBs = PDM_ACPI_BAT_STATE_CHARGED;
289	if (powerStatus.BatteryFlag & 8)
290	uBs = PDM_ACPI_BAT_STATE_CHARGING;
291	else if (powerStatus.ACLineStatus == 0 \|\| powerStatus.ACLineStatus == 255)
292	uBs = PDM_ACPI_BAT_STATE_DISCHARGING;
293	if (powerStatus.BatteryFlag & 4)
294	uBs \|= PDM_ACPI_BAT_STATE_CRITICAL;
295	*penmBatteryState = (PDMACPIBATSTATE)uBs;
296	/* on Windows it is difficult to request the present charging/discharging rate */
297	}
298	else
299	{
300	AssertMsgFailed(("Could not determine system power status, error: 0x%x\n",
301	GetLastError()));
302	}
303	#elif defined(RT_OS_LINUX)
304	DIR *dfd;
305	struct dirent *dp;
306	FILE *statusFile = NULL;
307	FILE *infoFile = NULL;
308	char buff[NAME_MAX+50];
309	/* the summed up maximum capacity */
310	int maxCapacityTotal = ~0;
311	/* the summed up total capacity */
312	int currentCapacityTotal = ~0;
313	int presentRate = 0;
314	int presentRateTotal = 0;
315	bool fBatteryPresent = false, fCharging=false, fDischarging=false, fCritical=false;
316
317	dfd = opendir("/proc/acpi/battery/");
318	if (dfd)
319	{
320	for (;;)
321	{
322	dp = readdir(dfd);
323	if (dp == 0)
324	break;
325	if (strcmp(dp->d_name, ".") == 0 \|\|
326	strcmp(dp->d_name, "..") == 0)
327	continue;
328	strcpy(buff, "/proc/acpi/battery/");
329	strcat(buff, dp->d_name);
330	strcat(buff, "/status");
331	statusFile = fopen(buff, "r");
332	/* there is a 2nd variant of that file */
333	if (!statusFile)
334	{
335	strcpy(buff, "/proc/acpi/battery/");
336	strcat(buff, dp->d_name);
337	strcat(buff, "/state");
338	statusFile = fopen(buff, "r");
339	}
340	strcpy(buff, "/proc/acpi/battery/");
341	strcat(buff, dp->d_name);
342	strcat(buff, "/info");
343	infoFile = fopen(buff, "r");
344	/* we need both files */
345	if (!statusFile \|\| !infoFile)
346	{
347	if (statusFile)
348	fclose(statusFile);
349	if (infoFile)
350	fclose(infoFile);
351	break;
352	}
353
354	/* get 'present' status from the info file */
355	for (;;)
356	{
357	char buff2[1024];
358	if (fgets(buff2, sizeof(buff), infoFile) == NULL)
359	break;
360
361	if (strstr(buff2, "present:") != NULL)
362	{
363	if (strstr(buff2, "yes") != NULL)
364	fBatteryPresent = true;
365	}
366	}
367
368	/* move file pointer back to start of file */
369	fseek(infoFile, 0, SEEK_SET);
370
371	if (fBatteryPresent)
372	{
373	/* get the maximum capacity from the info file */
374	for (;;)
375	{
376	char buff2[1024];
377	int maxCapacity = ~0;
378	if (fgets(buff2, sizeof(buff), infoFile) == NULL)
379	break;
380	if (strstr(buff2, "last full capacity:") != NULL)
381	{
382	if (sscanf(buff2 + 19, "%d", &maxCapacity) <= 0)
383	maxCapacity = ~0;
384
385	/* did we get a valid capacity and it's the first value we got? */
386	if (maxCapacityTotal < 0 && maxCapacity > 0)
387	{
388	/* take this as the maximum capacity */
389	maxCapacityTotal = maxCapacity;
390	}
391	else
392	{
393	/* sum up the maximum capacity */
394	if (maxCapacityTotal > 0 && maxCapacity > 0)
395	maxCapacityTotal += maxCapacity;
396	}
397	/* we got all we need */
398	break;
399	}
400	}
401
402	/* get the current capacity/state from the status file */
403	bool gotRemainingCapacity=false, gotBatteryState=false,
404	gotCapacityState=false, gotPresentRate=false;
405	while (!gotRemainingCapacity \|\| !gotBatteryState \|\|
406	!gotCapacityState \|\| !gotPresentRate)
407	{
408	char buff2[1024];
409	int currentCapacity = ~0;
410	if (fgets(buff2, sizeof(buff), statusFile) == NULL)
411	break;
412	if (strstr(buff2, "remaining capacity:") != NULL)
413	{
414	if (sscanf(buff2 + 19, "%d", &currentCapacity) <= 0)
415	currentCapacity = ~0;
416
417	/* is this the first valid value we see? If so, take it! */
418	if (currentCapacityTotal < 0 && currentCapacity >= 0)
419	{
420	currentCapacityTotal = currentCapacity;
421	}
422	else
423	{
424	/* just sum up the current value */
425	if (currentCapacityTotal > 0 && currentCapacity > 0)
426	currentCapacityTotal += currentCapacity;
427	}
428	gotRemainingCapacity = true;
429	}
430	if (strstr(buff2, "charging state:") != NULL)
431	{
432	if (strstr(buff2 + 15, "discharging") != NULL)
433	fDischarging = true;
434	else if (strstr(buff2 + 15, "charging") != NULL)
435	fCharging = true;
436	gotBatteryState = true;
437	}
438	if (strstr(buff2, "capacity state:") != NULL)
439	{
440	if (strstr(buff2 + 15, "critical") != NULL)
441	fCritical = true;
442	gotCapacityState = true;
443	}
444	if (strstr(buff2, "present rate:") != NULL)
445	{
446	if (sscanf(buff2 + 13, "%d", &presentRate) <= 0)
447	presentRate = 0;
448	gotPresentRate = true;
449	}
450	}
451	}
452
453	if (presentRate)
454	{
455	if (fDischarging)
456	presentRateTotal -= presentRate;
457	else
458	presentRateTotal += presentRate;
459	}
460
461	if (statusFile)
462	fclose(statusFile);
463	if (infoFile)
464	fclose(infoFile);
465
466	}
467	closedir(dfd);
468	}
469
470	*pfPresent = fBatteryPresent;
471
472	/* charging/discharging bits are mutual exclusive */
473	uint32_t uBs = PDM_ACPI_BAT_STATE_CHARGED;
474	if (fDischarging)
475	uBs = PDM_ACPI_BAT_STATE_DISCHARGING;
476	else if (fCharging)
477	uBs = PDM_ACPI_BAT_STATE_CHARGING;
478	if (fCritical)
479	uBs \|= PDM_ACPI_BAT_STATE_CRITICAL;
480	*penmBatteryState = (PDMACPIBATSTATE)uBs;
481
482	if (presentRateTotal < 0)
483	presentRateTotal = -presentRateTotal;
484
485	if (maxCapacityTotal > 0 && currentCapacityTotal > 0)
486	{
487	/* calculate the percentage */
488	*penmRemainingCapacity = (PDMACPIBATCAPACITY)(((float)currentCapacityTotal / (float)maxCapacityTotal)
489	* PDM_ACPI_BAT_CAPACITY_MAX);
490	pu32PresentRate = (uint32_t)(((float)presentRateTotal / (float)maxCapacityTotal) 1000);
491	}
492	#elif defined(RT_OS_DARWIN)
493	CFTypeRef pBlob = IOPSCopyPowerSourcesInfo();
494	CFArrayRef pSources = IOPSCopyPowerSourcesList(pBlob);
495
496	CFDictionaryRef pSource = NULL;
497	const void *psValue;
498	bool result;
499
500	if (CFArrayGetCount(pSources) > 0)
501	{
502	for(int i = 0; i < CFArrayGetCount(pSources); ++i)
503	{
504	pSource = IOPSGetPowerSourceDescription(pBlob, CFArrayGetValueAtIndex(pSources, i));
505	/* If the source is empty skip over to the next one. */
506	if(!pSource)
507	continue;
508	/* Skip all power sources which are currently not present like a
509	* second battery. */
510	if (CFDictionaryGetValue(pSource, CFSTR(kIOPSIsPresentKey)) == kCFBooleanFalse)
511	continue;
512	/* Only internal power types are of interest. */
513	result = CFDictionaryGetValueIfPresent(pSource, CFSTR(kIOPSTransportTypeKey), &psValue);
514	if (result &&
515	CFStringCompare((CFStringRef)psValue, CFSTR(kIOPSInternalType), 0) == kCFCompareEqualTo)
516	{
517	PDMACPIPOWERSOURCE powerSource = PDM_ACPI_POWER_SOURCE_UNKNOWN;
518	/* First check which power source we are connect on. */
519	result = CFDictionaryGetValueIfPresent(pSource, CFSTR(kIOPSPowerSourceStateKey), &psValue);
520	if (result &&
521	CFStringCompare((CFStringRef)psValue, CFSTR(kIOPSACPowerValue), 0) == kCFCompareEqualTo)
522	powerSource = PDM_ACPI_POWER_SOURCE_OUTLET;
523	else if (result &&
524	CFStringCompare((CFStringRef)psValue, CFSTR(kIOPSBatteryPowerValue), 0) == kCFCompareEqualTo)
525	powerSource = PDM_ACPI_POWER_SOURCE_BATTERY;
526
527	/* At this point the power source is present. */
528	*pfPresent = true;
529	*penmBatteryState = PDM_ACPI_BAT_STATE_CHARGED;
530
531	int curCapacity = 0;
532	int maxCapacity = 1;
533	float remCapacity = 0.0f;
534
535	/* Fetch the current capacity value of the power source */
536	result = CFDictionaryGetValueIfPresent(pSource, CFSTR(kIOPSCurrentCapacityKey), &psValue);
537	if (result)
538	CFNumberGetValue((CFNumberRef)psValue, kCFNumberSInt32Type, &curCapacity);
539	/* Fetch the maximum capacity value of the power source */
540	result = CFDictionaryGetValueIfPresent(pSource, CFSTR(kIOPSMaxCapacityKey), &psValue);
541	if (result)
542	CFNumberGetValue((CFNumberRef)psValue, kCFNumberSInt32Type, &maxCapacity);
543
544	/* Calculate the remaining capacity in percent */
545	remCapacity = ((float)curCapacity/(float)maxCapacity * PDM_ACPI_BAT_CAPACITY_MAX);
546	*penmRemainingCapacity = (PDMACPIBATCAPACITY)remCapacity;
547
548	if (powerSource == PDM_ACPI_POWER_SOURCE_BATTERY)
549	{
550	/* If we are on battery power we are discharging in every
551	* case */
552	*penmBatteryState = PDM_ACPI_BAT_STATE_DISCHARGING;
553	int timeToEmpty = -1;
554	/* Get the time till the battery source will be empty */
555	result = CFDictionaryGetValueIfPresent(pSource, CFSTR(kIOPSTimeToEmptyKey), &psValue);
556	if (result)
557	CFNumberGetValue((CFNumberRef)psValue, kCFNumberSInt32Type, &timeToEmpty);
558	if (timeToEmpty != -1)
559	/* 0...1000 */
560	pu32PresentRate = (uint32_t)roundf((remCapacity / ((float)timeToEmpty/60.0)) 10.0);
561	}
562
563	if (powerSource == PDM_ACPI_POWER_SOURCE_OUTLET &&
564	CFDictionaryGetValueIfPresent(pSource, CFSTR(kIOPSIsChargingKey), &psValue))
565	{
566	/* We are running on an AC power source, but we also have a
567	* battery power source present. */
568	if (CFBooleanGetValue((CFBooleanRef)psValue) > 0)
569	{
570	/* This means charging. */
571	*penmBatteryState = PDM_ACPI_BAT_STATE_CHARGING;
572	int timeToFull = -1;
573	/* Get the time till the battery source will be charged */
574	result = CFDictionaryGetValueIfPresent(pSource, CFSTR(kIOPSTimeToFullChargeKey), &psValue);
575	if (result)
576	CFNumberGetValue((CFNumberRef)psValue, kCFNumberSInt32Type, &timeToFull);
577	if (timeToFull != -1)
578	/* 0...1000 */
579	pu32PresentRate = (uint32_t)roundf((100.0-(float)remCapacity) / ((float)timeToFull/60.0)) 10.0;
580	}
581	}
582
583	/* Check for critical */
584	int criticalValue = 20;
585	result = CFDictionaryGetValueIfPresent(pSource, CFSTR(kIOPSDeadWarnLevelKey), &psValue);
586	if (result)
587	CFNumberGetValue((CFNumberRef)psValue, kCFNumberSInt32Type, &criticalValue);
588	if (remCapacity < criticalValue)
589	penmBatteryState = (PDMACPIBATSTATE)(penmBatteryState \| PDM_ACPI_BAT_STATE_CRITICAL);
590	}
591	}
592	}
593	CFRelease(pBlob);
594	CFRelease(pSources);
595	#elif defined(RT_OS_FREEBSD)
596	/* We try to use /dev/acpi first and if that fails use the sysctls. */
597	bool fSuccess = true;
598	int FileAcpi = 0;
599	int rc = 0;
600
601	FileAcpi = open("/dev/acpi", O_RDONLY);
602	if (FileAcpi != -1)
603	{
604	bool fMilliWatt;
605	union acpi_battery_ioctl_arg BatteryIo;
606
607	memset(&BatteryIo, 0, sizeof(BatteryIo));
608	BatteryIo.unit = 0; /* Always use the first battery. */
609
610	/* Determine the power units first. */
611	if (ioctl(FileAcpi, ACPIIO_BATT_GET_BIF, &BatteryIo) == -1)
612	fSuccess = false;
613	else
614	{
615	if (BatteryIo.bif.units == ACPI_BIF_UNITS_MW)
616	fMilliWatt = true;
617	else
618	fMilliWatt = false; /* mA */
619
620	BatteryIo.unit = 0;
621	if (ioctl(FileAcpi, ACPIIO_BATT_GET_BATTINFO, &BatteryIo) == -1)
622	fSuccess = false;
623	else
624	{
625	if ((BatteryIo.battinfo.state & ACPI_BATT_STAT_NOT_PRESENT) == ACPI_BATT_STAT_NOT_PRESENT)
626	*pfPresent = false;
627	else
628	{
629	*pfPresent = true;
630
631	if (BatteryIo.battinfo.state & ACPI_BATT_STAT_DISCHARG)
632	*penmBatteryState = PDM_ACPI_BAT_STATE_DISCHARGING;
633	else if (BatteryIo.battinfo.state & ACPI_BATT_STAT_CHARGING)
634	*penmBatteryState = PDM_ACPI_BAT_STATE_CHARGING;
635	else
636	*penmBatteryState = PDM_ACPI_BAT_STATE_CHARGED;
637
638	if (BatteryIo.battinfo.state & ACPI_BATT_STAT_CRITICAL)
639	penmBatteryState = (PDMACPIBATSTATE)(penmBatteryState \| PDM_ACPI_BAT_STATE_CRITICAL);
640	}
641
642	if (BatteryIo.battinfo.cap != -1)
643	*penmRemainingCapacity = (PDMACPIBATCAPACITY)BatteryIo.battinfo.cap;
644
645	BatteryIo.unit = 0;
646	if (ioctl(FileAcpi, ACPIIO_BATT_GET_BST, &BatteryIo) == 0)
647	{
648	/* The rate can be either mW or mA but the ACPI device wants mW. */
649	if (BatteryIo.bst.rate != 0xffffffff)
650	{
651	if (fMilliWatt)
652	*pu32PresentRate = BatteryIo.bst.rate;
653	else if (BatteryIo.bst.volt != 0xffffffff)
654	{
655	/*
656	* The rate is in mA so we have to convert it.
657	* The current power rate can be calculated with P = U * I
658	*/
659	pu32PresentRate = (uint32_t)((((float)BatteryIo.bst.volt/1000.0) ((float)BatteryIo.bst.rate/1000.0)) * 1000.0);
660	}
661	}
662	}
663	}
664	}
665
666	close(FileAcpi);
667	}
668	else
669	fSuccess = false;
670
671	if (!fSuccess)
672	{
673	int fBatteryState = 0;
674	size_t cbParameter = sizeof(fBatteryState);
675
676	rc = sysctlbyname("hw.acpi.battery.state", &fBatteryState, &cbParameter, NULL, NULL);
677	if (!rc)
678	{
679	if ((fBatteryState & ACPI_BATT_STAT_NOT_PRESENT) == ACPI_BATT_STAT_NOT_PRESENT)
680	*pfPresent = false;
681	else
682	{
683	*pfPresent = true;
684
685	if (fBatteryState & ACPI_BATT_STAT_DISCHARG)
686	*penmBatteryState = PDM_ACPI_BAT_STATE_DISCHARGING;
687	else if (fBatteryState & ACPI_BATT_STAT_CHARGING)
688	*penmBatteryState = PDM_ACPI_BAT_STATE_CHARGING;
689	else
690	*penmBatteryState = PDM_ACPI_BAT_STATE_CHARGED;
691
692	if (fBatteryState & ACPI_BATT_STAT_CRITICAL)
693	penmBatteryState = (PDMACPIBATSTATE)(penmBatteryState \| PDM_ACPI_BAT_STATE_CRITICAL);
694
695	/* Get battery level. */
696	int curCapacity = 0;
697	cbParameter = sizeof(curCapacity);
698	rc = sysctlbyname("hw.acpi.battery.life", &curCapacity, &cbParameter, NULL, NULL);
699	if ((!rc) && (curCapacity >= 0))
700	*penmRemainingCapacity = (PDMACPIBATCAPACITY)curCapacity;
701
702	/* The rate can't be determined with sysctls. */
703	}
704	}
705	}
706	#endif /* RT_OS_FREEBSD */
707	return VINF_SUCCESS;
708	}
709
710	/**
711	* Destruct a driver instance.
712	*
713	* Most VM resources are freed by the VM. This callback is provided so that any non-VM
714	* resources can be freed correctly.
715	*
716	* @param pDrvIns The driver instance data.
717	*/
718	static DECLCALLBACK(void) drvACPIDestruct(PPDMDRVINS pDrvIns)
719	{
720	LogFlow(("drvACPIDestruct\n"));
721	}
722
723	/**
724	* Construct an ACPI driver instance.
725	*
726	* @copydoc FNPDMDRVCONSTRUCT
727	*/
728	static DECLCALLBACK(int) drvACPIConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfgHandle, uint32_t fFlags)
729	{
730	PDRVACPI pThis = PDMINS_2_DATA(pDrvIns, PDRVACPI);
731
732	/*
733	* Init the static parts.
734	*/
735	pThis->pDrvIns = pDrvIns;
736	/* IBase */
737	pDrvIns->IBase.pfnQueryInterface = drvACPIQueryInterface;
738	/* IACPIConnector */
739	pThis->IACPIConnector.pfnQueryPowerSource = drvACPIQueryPowerSource;
740	pThis->IACPIConnector.pfnQueryBatteryStatus = drvACPIQueryBatteryStatus;
741
742	/*
743	* Validate the config.
744	*/
745	if (!CFGMR3AreValuesValid(pCfgHandle, "\0"))
746	return VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES;
747
748	/*
749	* Check that no-one is attached to us.
750	*/
751	AssertMsgReturn(PDMDrvHlpNoAttach(pDrvIns) == VERR_PDM_NO_ATTACHED_DRIVER,
752	("Configuration error: Not possible to attach anything to this driver!\n"),
753	VERR_PDM_DRVINS_NO_ATTACH);
754
755	/*
756	* Query the ACPI port interface.
757	*/
758	pThis->pPort = (PPDMIACPIPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase,
759	PDMINTERFACE_ACPI_PORT);
760	if (!pThis->pPort)
761	{
762	AssertMsgFailed(("Configuration error: the above device/driver didn't export the ACPI port interface!\n"));
763	return VERR_PDM_MISSING_INTERFACE_ABOVE;
764	}
765
766	return VINF_SUCCESS;
767	}
768
769
770	/**
771	* ACPI driver registration record.
772	*/
773	const PDMDRVREG g_DrvACPI =
774	{
775	/* u32Version */
776	PDM_DRVREG_VERSION,
777	/* szDriverName */
778	"ACPIHost",
779	/* pszDescription */
780	"ACPI Host Driver",
781	/* fFlags */
782	PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
783	/* fClass. */
784	PDM_DRVREG_CLASS_ACPI,
785	/* cMaxInstances */
786	~0,
787	/* cbInstance */
788	sizeof(DRVACPI),
789	/* pfnConstruct */
790	drvACPIConstruct,
791	/* pfnDestruct */
792	drvACPIDestruct,
793	/* pfnIOCtl */
794	NULL,
795	/* pfnPowerOn */
796	NULL,
797	/* pfnReset */
798	NULL,
799	/* pfnSuspend */
800	NULL,
801	/* pfnResume */
802	NULL,
803	/* pfnAttach */
804	NULL,
805	/* pfnDetach */
806	NULL,
807	/* pfnPowerOff */
808	NULL,
809	/* pfnSoftReset */
810	NULL,
811	/* u32EndVersion */
812	PDM_DRVREG_VERSION
813	};
814

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/PC/DrvACPI.cpp@ 22943

Download in other formats: