/*{{{ int main(int argc, char **argv)*/
int main(int argc, char **argv)
{
XtAppContext context;
Widget topLevel;
Widget gauge;
/*{{{ check APM support*/
switch(apm_exists())
{
case 1:
fprintf(stderr, "xbattery:No APM support available\n");
exit(1);
case 2:
fprintf(stderr, "xbattery:Obsolete APM support in kernel\n");
exit(1);
}
/*}}}*/
topLevel = XtAppInitialize(&context, "XBattery",
options, XtNumber(options),
&argc, argv, NULL, NULL, 0);
gauge = XtCreateManagedWidget("gauge",
batteryGaugeWidgetClass, topLevel, NULL, 0);
XtRealizeWidget(topLevel);
XtAppMainLoop(context);
return 0;
}
/*
* power_management_initialise
*
* Initialise the power management code. Call this before you call anything
* else.
*
* In the case of success, NULL is returned. In case of failure, a
* localised error message is returned to give the user hints about what
* the problem might be. This error message is not to be freed.
*/
const char *
power_management_initialise (void (*callback) (void))
{
char *err;
#ifdef __linux__
struct stat statbuf;
#endif
#ifdef HAVE_UPOWER
err = battstat_upower_initialise (callback);
if( err == NULL ) /* UPOWER is up */
{
pm_initialised = 1;
using_upower = TRUE;
return NULL;
}
else
/* fallback to legacy methods */
g_free( err );
#endif
#ifdef __linux__
if (acpi_linux_init(&acpiinfo)) {
using_acpi = TRUE;
acpi_count = 0;
}
else
using_acpi = FALSE;
/* If neither ACPI nor APM could be read, but ACPI does seem to be
* installed, warn the user how to get ACPI working. */
if (!using_acpi && (apm_exists() == 1) &&
(stat("/proc/acpi", &statbuf) == 0)) {
using_acpi = TRUE;
acpi_count = 0;
return ERR_ACPID;
}
/* Watch for ACPI events and handle them immediately with acpi_callback(). */
if (using_acpi && acpiinfo.event_fd >= 0) {
acpiwatch = g_io_add_watch (acpiinfo.channel,
G_IO_IN | G_IO_ERR | G_IO_HUP,
acpi_callback, NULL);
}
#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
if (acpi_freebsd_init(&acpiinfo)) {
using_acpi = TRUE;
acpi_count = 0;
}
else
using_acpi = FALSE;
#endif
pm_initialised = 1;
return NULL;
}
int main(int argc, char **argv)
{
int i, rtcfd, retval;
struct rtc_time rtc_tm;
struct tm kernel_tm;
time_t kernel_time, new_time, old_time;
char *p;
int c;
int apmfd=-1; /* APM device file descriptor */
int isoffset; /* setting time offset */
int hour, minute; /* alarm time requested */
int hour1, minute1; /* backup for precise_mode */
int flag;
static int suspend_mode=0, wait_mode=0, debug_mode=0, precise_mode=0,
noapm_mode=0;
while (1) {
/* int this_option_optind = optind ? optind : 1; */
int option_index = 0;
static struct option long_options[] = {
{"help", 0, 0, 'h'},
{"debug", 0, 0, 'd'},
{"version", 0, 0, 'V'},
{"suspend", 0, 0, 's'},
{"standby", 0, 0, 'S'},
{"wait", 0, 0, 'w'},
{"noapm", 0, 0, 'n'},
{"precise", 0, 0, 'p'},
{0,0,0,0}
};
c = getopt_long(argc, argv, "hdVsSwnp", long_options, &option_index);
if (c == -1) break;
switch(c)
{
case 'h':
usage();
exit(0);
case 'V':
version();
exit(0);
case 'd':
debug_mode=1;
break;
case 's': /*suspend*/
suspend_mode=0;
break;
case 'S': /*standby*/
suspend_mode=1;
break;
case 'n': /*noapm*/
noapm_mode=1;
wait_mode=1;
break;
case 'w':
wait_mode=!precise_mode;
break;
case 'p':/*precise*/
precise_mode=1;
break;
case '?': /*unknown option*/
exit(1);
default:
fprintf(stderr,"unknown option return %d\n", c);
exit(1);
}
} /* end while (1) */
if (optind < argc) {
if (optind+1 != argc) {
fprintf(stderr,"To many arguments.\n"); usage();
exit(1);
}
p=argv[optind];
isoffset=0;
if (p[0]=='+') { p++; isoffset=1;}
if (2!=sscanf(p, "%d:%d", &hour, &minute)) {
fprintf(stderr,"apmsleep: Bad argument(s)\n");
exit(1);
}
hour1=hour; minute1=minute; /* backup */
} else {
fprintf(stderr,"apmsleep: missing argument.\n"); usage();
exit(1);
}
if (noapm_mode) suspend_mode=2;
/* argument processing finished */
if (geteuid()!=0) {
fprintf(stderr, "apmsleep: warning: This program must be run as root "
"or have the SUID attribute set\n");
}
/* check if APM is supported */
if (apm_exists()) {
fprintf(stderr, "apmsleep: Your kernel does not support APM.\n");
fprintf(stderr, "apmsleep: Recompile kernel with APM and "
"/dev/rtc support\n");
exit(1);
}
if (!noapm_mode) {
apmfd=open(APM_DEVICE, O_WRONLY);
if (apmfd < 0) {
fprintf(stderr, "apmsleep: Cannot open APM device.\n");
exit(1);
}
}
rtcfd = open ("/dev/rtc", O_RDONLY);
if (errno == EACCES) {
fprintf(stderr, "apmsleep: You don't have permission to "
"access /dev/rtc\n");
fprintf(stderr, "apmsleep: The program must be run as root "
"or have the SUID attribute set\n");
exit(errno);
}
if (rtcfd == -1) {
perror("/dev/rtc");
fprintf(stderr, "apmsleep: Your kernel does not support "
"the real time clock device\n");
fprintf(stderr, "apmsleep: Recompile kernel with APM and "
"/dev/rtc support\n");
exit(errno);
}
/* Read the RTC time/date */
retval = ioctl(rtcfd, RTC_RD_TIME, &rtc_tm);
if (retval == -1) {
perror("ioctl");
exit(errno);
}
/* Read Kernel time/date */
time(&kernel_time);
kernel_tm=*localtime(&kernel_time);
if (debug_mode) {
printf("Current RTC time is %02d:%02d:%02d.\n",
rtc_tm.tm_hour, rtc_tm.tm_min, rtc_tm.tm_sec);
printf("Current local time is %02d:%02d:%02d.\n",
kernel_tm.tm_hour, kernel_tm.tm_min, kernel_tm.tm_sec);
}
/* set alarm time in RTC */
if (isoffset) {
if (hour == 0 && minute == 0)
exit(0);
hour+=(int)rtc_tm.tm_hour;
minute+=(int)rtc_tm.tm_min;
hour1+=(int)kernel_tm.tm_hour;
minute1+=(int)kernel_tm.tm_min;
} else {
/* Special case - wake-up time equal current time
this may cause to systems to crash according to
a user report. Therefore, we do not suspend in this case. */
if (hour == kernel_tm.tm_hour && minute == kernel_tm.tm_min) {
printf("Wake-up time equal to current time. Suspend not required\n");
exit(0);
}
rtc_tm.tm_sec=0;
/* here we take difference between RTC and localtime into account */
minute+=(int)rtc_tm.tm_min - (int)kernel_tm.tm_min;
hour+=(int)rtc_tm.tm_hour - (int)kernel_tm.tm_hour;
}
while (minute<0) {minute +=60; hour--; }
while (minute>=60) {minute -=60; hour++; }
while (hour < 0) hour += 24;
hour %= 24;
rtc_tm.tm_min = minute;
rtc_tm.tm_hour = hour;
if (debug_mode)
printf("Setting RTC alarm time to %02d:%02d:%02d.\n",
hour, minute, rtc_tm.tm_sec);
retval = ioctl(rtcfd, RTC_ALM_SET, &rtc_tm);
if (retval == -1) {
perror("ioctl");
exit(errno);
}
/* Read back the current alarm settings */
retval = ioctl(rtcfd, RTC_ALM_READ, &rtc_tm);
if (retval == -1) {
perror("ioctl");
exit(errno);
}
if (debug_mode)
printf("RTC alarm time now set to %02d:%02d:%02d.\n",
rtc_tm.tm_hour, rtc_tm.tm_min, rtc_tm.tm_sec);
/* Enable alarm interrupts */
retval = ioctl(rtcfd, RTC_AIE_ON, 0);
if (retval == -1) {
perror("ioctl");
exit(errno);
}
/* Save time before suspending */
time(&new_time);
kernel_time=new_time;
if (fork()==0) {
/* suspend system -- called from within a child, to make
* sure we don't miss the time leap
*/
switch(suspend_mode) {
case 0:
apm_suspend(apmfd);
break;
case 1:
apm_standby(apmfd);
break;
}
exit(0);
}
if (debug_mode) {
printf("Waiting until clock jumps\n");
fflush(stdout);
}
flag=1; /* Note: flag is used as exit value */
if (precise_mode) {
/* wait for clock match alarm time */
if (debug_mode) printf("Wait for wakeup time\n");
do {
int diff;
/* Read Kernel time/date */
time(&kernel_time);
kernel_tm=*localtime(&kernel_time);
if (debug_mode)
printf("Time: %02d:%02d:%02d, wakeup time: %02d:%02d:%02d\n",
kernel_tm.tm_hour, kernel_tm.tm_min, kernel_tm.tm_sec,
hour1, minute1, 0);
diff= hour1*60 + minute1 - kernel_tm.tm_hour*60 - kernel_tm.tm_min;
diff %= (24*60);
flag=(diff!=0 && diff!=-1);
if (flag) sleep(10);
} while (flag);
} else {
/* wait for the actual sleep event */
do {
old_time=new_time;
sleep(2);
time(&new_time);
flag=difftime(new_time,old_time)<10.0;
/* check for time out */
if (flag && wait_mode==0 && difftime(new_time,kernel_time)>120.0)
break; /* timeout, flag is 1 */
} while (flag);
if (flag)
fprintf(stderr,"Time out -- no time leap happened\n");
else if (debug_mode)
printf("Time leap detected\n");
}
/* Waiting for child to finish */
wait(&i);
/* Disable alarm interrupts */
retval = ioctl(rtcfd, RTC_AIE_OFF, 0);
if (retval == -1) {
perror("ioctl");
exit(errno);
}
close(rtcfd);
if (!noapm_mode) close(apmfd);
return flag;
}
int pm_support(int use_this_battery)
{
Battery = use_this_battery;
if (!use_noflushd) fprintf(stderr, "use of noflushd is disabled\n");
if (!use_cpufreq) fprintf(stderr, "CPU frequency scaling disabled\n");
/* What kernel version are we running in? */
kernel_version = Get_Kernel_version();
/* check for specific hardware */
while (1)
{
/* is this a compal laptop? */
if (machine_is_compal())
{
machine = COMPAL;
fprintf(stderr, "detected Compal laptop, %s\n", compal_model);
break;
}
/* is this a dell laptop? */
if (machine_is_dell())
{
machine = DELL;
fprintf(stderr, "detected DELL laptop\n");
break;
}
/* Is this a Toshiba Laptop? */
if (machine_is_toshiba(&use_toshiba_hardware))
{
machine = TOSHIBA;
fprintf(stderr, "detected TOSHIBA laptop, %s\n", toshiba_model);
if (!use_toshiba_hardware) fprintf(stderr, "direct access to TOSHIBA hardware disabled\n");
break;
}
break;
}
/* Does this system support CPU frequency scaling? */
if (use_cpufreq)
{
use_cpufreq = check_cpufreq();
if (use_cpufreq) fprintf(stderr, "CPU frequency scaling available\n");
else fprintf(stderr, "CPU frequency scaling NOT available\n");
/* Set default governors if we were supplied none */
if (!cpufreq_offline_governor)
cpufreq_offline_governor = CPUFREQ_GOV_ONDEMAND;
if (!cpufreq_online_governor)
cpufreq_online_governor = CPUFREQ_GOV_PERFORMANCE;
}
/* Is this an acpi system? */
if (check_acpi())
{
pm_type= PM_ACPI;
fprintf(stderr, "Detected ACPI subsystem\n");
return 1;
}
/* Is this an APM system? */
if (apm_exists())
{
pm_type= PM_APM;
fprintf(stderr, "detected APM subsystem\n");
if (Battery != 1)
{
fprintf(stderr, "You must use ACPI to monitor any battery\n");
fprintf(stderr, "other than the first one. Cannot continue.\n");
exit(1);
}
return 1;
}
fprintf(stderr, "No power management subsystem detected\n");
return 0;
}
int main (int argc, char **argv) {
FILE *f;
parse_command_line(argc, argv);
/* Log to the console if not daemonizing. */
openlog("sleepd", LOG_PID | (daemonize ? 0 : LOG_PERROR), LOG_DAEMON);
/* Set up a signal handler for SIGTERM to clean up things. */
signal(SIGTERM, cleanup);
/* And a handler for SIGHUP, to reaload control file. */
signal(SIGHUP, loadcontrol);
loadcontrol(0);
if (! use_events) {
if (! have_irqs && ! autoprobe) {
fprintf(stderr, "No irqs specified.\n");
exit(1);
}
}
if (daemonize) {
if (daemon(0,0) == -1) {
perror("daemon");
exit(1);
}
if ((f=fopen(PID_FILE, "w")) == NULL) {
syslog(LOG_ERR, "unable to write %s", PID_FILE);
exit(1);
}
else {
fprintf(f, "%i\n", getpid());
fclose(f);
}
}
if (apm_exists() != 0) {
if (! sleep_command)
sleep_command=acpi_sleep_command;
/* Chosing between hal and acpi backends is tricky,
* because acpi may report no batteries due to the battery
* being absent (but inserted later), or due to battery
* info no longer being available by acpi in new kernels.
* Meanwhile, hal may fail if hald is not yet
* running, but might work later.
*
* The strategy used is to check if acpi reports an AC
* adapter, or a battery. If it reports neither, we assume
* that the kernel no longer supports acpi power info, and
* use hal.
*/
if (acpi_supported() &&
(acpi_ac_count > 0 || acpi_batt_count > 0)) {
use_acpi=1;
}
#ifdef HAL
else if (simplehal_supported()) {
use_simplehal=1;
}
else {
syslog(LOG_NOTICE, "failed to connect to hal on startup, but will try to use it anyway");
use_simplehal=1;
}
#else
else {
fprintf(stderr, "sleepd: no APM or ACPI support detected\n");
exit(1);
}
#endif
}
