release/src/router/apcupsd/src/drivers/apcsmart/smart.c

   1
   2 /*
   3  *  apcsmart.c -- The decoding of the chatty little beasts.
   4  *                  THE LOOK-A-LIKE ( UPSlink(tm) Language )
   5  *
   6  *  apcupsd.c  -- Simple Daemon to catch power failure signals from a
   7  *                  BackUPS, BackUPS Pro, or SmartUPS (from APCC).
   8  *               -- Now SmartMode support for SmartUPS and BackUPS Pro.
   9  *
  10  *  Copyright (C) 1996-99 Andre M. Hedrick <andre@suse.com>
  11  *  All rights reserved.
  12  *
  13  */
  14
  15 /*
  16  * Parts of the information below was taken from apcd.c & apcd.h
  17  *
  18  * Definitons file for APC SmartUPS daemon
  19  *
  20  *  Copyright (c) 1995 Pavel Korensky
  21  *  All rights reserved
  22  *
  23  *  IN NO EVENT SHALL PAVEL KORENSKY BE LIABLE TO ANY PARTY FOR
  24  *  DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
  25  *  OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF PAVEL KORENSKY
  26  *  HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  *  PAVEL KORENSKY SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT
  29  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  30  *  A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS"
  31  *  BASIS, AND PAVEL KORENSKY HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT,
  32  *  UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  33  *
  34  *  Pavel Korensky            pavelk@dator3.anet.cz
  35  *
  36  *  8.11.1995
  37  *
  38  *  P.S. I have absolutely no connection with company APC. I didn't sign any
  39  *  non-disclosure agreement and I didn't got the protocol description anywhere.
  40  *  The whole protocol decoding was made with a small program for capturing
  41  *  serial data on the line. So, I think that everybody can use this software
  42  *  without any problem.
  43  *
  44  */
  45
  46 /*
  47    Copyright (C) 1999-2004 Kern Sibbald
  48
  49    This program is free software; you can redistribute it and/or
  50    modify it under the terms of the GNU General Public License as
  51    published by the Free Software Foundation; either version 2 of
  52    the License, or (at your option) any later version.
  53
  54    This program is distributed in the hope that it will be useful,
  55    but WITHOUT ANY WARRANTY; without even the implied warranty of
  56    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  57    General Public License for more details.
  58
  59    You should have received a copy of the GNU General Public
  60    License along with this program; if not, write to the Free
  61    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  62    MA 02111-1307, USA.
  63
  64  */
  65
  66
  67 #include "apc.h"
  68 #include "apcsmart.h"
  69
  70 /* How long to wait before declaring commlost */
  71 #define COMMLOST_TIMEOUT_MS (20*1000)
  72
  73 /* Convert UPS response to enum and string */
  74 static SelfTestResult decode_testresult(char* str)
  75 {
  76    /*
  77     * Responses are:
  78     * "OK" - good battery,
  79     * "BT" - failed due to insufficient capacity,
  80     * "NG" - failed due to overload,
  81     * "NO" - no results available (no test performed in last 5 minutes)
  82     */
  83    if (str[0] == 'O' && str[1] == 'K')
  84       return TEST_PASSED;
  85    else if (str[0] == 'B' && str[1] == 'T')
  86       return TEST_FAILCAP;
  87    else if (str[0] == 'N' && str[1] == 'G')
  88       return TEST_FAILLOAD;
  89
  90    return TEST_NONE;
  91 }
  92
  93 /* Convert UPS response to enum and string */
  94 static LastXferCause decode_lastxfer(char *str)
  95 {
  96    Dmsg1(80, "Transfer reason: %c\n", *str);
  97
  98    switch (*str) {
  99    case 'N':
 100       return XFER_NA;
 101    case 'R':
 102       return XFER_RIPPLE;
 103    case 'H':
 104       return XFER_OVERVOLT;
 105    case 'L':
 106       return XFER_UNDERVOLT;
 107    case 'T':
 108       return XFER_NOTCHSPIKE;
 109    case 'O':
 110       return XFER_NONE;
 111    case 'K':
 112       return XFER_FORCED;
 113    case 'S':
 114       return XFER_SELFTEST;
 115    default:
 116       return XFER_UNKNOWN;
 117    }
 118 }
 119
 120 int apc_enable(UPSINFO *ups)
 121 {
 122    /* Enable APC Smart UPS */
 123    smart_poll('Y', ups);
 124    smart_poll('Y', ups);
 125    return 1;
 126 }
 127
 128 /*********************************************************************
 129  *
 130  * Send a charcter to the UPS and get
 131  * its response. Returns a pointer to the response string.
 132  *
 133  */
 134 char *smart_poll(char cmd, UPSINFO *ups)
 135 {
 136    static char answer[2000];
 137    int stat, retry;
 138
 139    *answer = 0;
 140    if (ups->fd == -1)
 141       return answer;
 142
 143    /* Don't retry Y/SM command */
 144    retry = (cmd == 'Y') ? 0 : 2;
 145
 146    do {
 147       write(ups->fd, &cmd, 1);
 148       stat = getline(answer, sizeof answer, ups);
 149
 150       /* If nothing returned, the link is probably down */
 151       if (*answer == 0 && stat == FAILURE) {
 152          UPSlinkCheck(ups);           /* wait for link to come up */
 153          *answer = 0; /* UPSlinkCheck invokes us recursively, so clean up */
 154       }
 155    } while (*answer == 0 && stat == FAILURE && retry--);
 156
 157    return answer;
 158 }
 159
 160 int writechar(char a, UPSINFO *ups)
 161 {
 162   return write(ups->fd, &a, 1);
 163 }
 164
 165 /*
 166  * If s == NULL we are just waiting on FD for status changes.
 167  * If s != NULL we are asking the UPS to tell us the value of something.
 168  *
 169  * If s == NULL there is a much more fine-grained locking.
 170  */
 171 int getline(char *s, int len, UPSINFO *ups)
 172 {
 173    int i = 0;
 174    int ending = 0;
 175    char c;
 176    int retval;
 177    int wait;
 178
 179    if (s != NULL)
 180       wait = TIMER_FAST;   /* 1 sec, expect fast response */
 181    else
 182       wait = ups->wait_time;
 183
 184 #ifdef HAVE_MINGW
 185    /* Set read() timeout since we have no select() support. */
 186    {
 187       COMMTIMEOUTS ct;
 188       HANDLE h = (HANDLE)_get_osfhandle(ups->fd);
 189       ct.ReadIntervalTimeout = MAXDWORD;
 190       ct.ReadTotalTimeoutMultiplier = MAXDWORD;
 191       ct.ReadTotalTimeoutConstant = wait * 1000;
 192       ct.WriteTotalTimeoutMultiplier = 0;
 193       ct.WriteTotalTimeoutConstant = 0;
 194       SetCommTimeouts(h, &ct);
 195    }
 196 #endif
 197
 198    while (!ending) {
 199 #if !defined(HAVE_MINGW)
 200       fd_set rfds;
 201       struct timeval tv;
 202
 203       FD_ZERO(&rfds);
 204       FD_SET(ups->fd, &rfds);
 205       tv.tv_sec = wait;
 206       tv.tv_usec = 0;
 207
 208       errno = 0;
 209       retval = select((ups->fd) + 1, &rfds, NULL, NULL, &tv);
 210
 211       switch (retval) {
 212       case 0:                     /* No chars available in TIMER seconds. */
 213          return FAILURE;
 214       case -1:
 215          if (errno == EINTR || errno == EAGAIN) {       /* assume SIGCHLD */
 216             continue;
 217          } else if (errno == EBADF) {
 218             return FAILURE;               /* We're probably shutting down */
 219          }
 220          Error_abort1("Select error on UPS FD. %s\n", strerror(errno));
 221          break;
 222       default:
 223          break;
 224       }
 225 #endif
 226
 227       do {
 228          retval = read(ups->fd, &c, 1);
 229       } while (retval == -1 && (errno == EAGAIN || errno == EINTR));
 230       if (retval == 0) {
 231          return FAILURE;
 232       }
 233
 234       switch (c) {
 235          /*
 236           * Here we can be called in two ways:
 237           *
 238           * s == NULL
 239           *     The shm lock is not held so we must hold it here.
 240           *
 241           * s != NULL
 242           *     We are called from a routine that have
 243           *     already held the shm lock so no need to hold it
 244           *     another time. Simply update the UPS structure
 245           *     fields and the shm will be updated when
 246           *     write_unlock is called by the calling
 247           *     routine.
 248           *
 249           * If something changes on the UPS, a special character is
 250           * sent over the serial line but no \n\r sequence is sent:
 251           * only a single character. This way if s == NULL, if we
 252           * receive a character like this we must return immediately
 253           * and not wait for a string completion.
 254           */
 255       case UPS_ON_BATT:           /* UPS_ON_BATT = '!'   */
 256          if (s == NULL)
 257             write_lock(ups);
 258          ups->clear_online();
 259          Dmsg0(80, "Got UPS ON BATT.\n");
 260          if (s == NULL) {
 261             write_unlock(ups);
 262             ending = 1;
 263          }
 264          break;
 265       case UPS_REPLACE_BATTERY:   /* UPS_REPLACE_BATTERY = '#'   */
 266          if (s == NULL)
 267             write_lock(ups);
 268          ups->set_replacebatt();
 269          Dmsg0(80, "Got UPS REPLACE_BATT.\n");
 270          if (s == NULL) {
 271             write_unlock(ups);
 272             ending = 1;
 273          }
 274          break;
 275       case UPS_ON_LINE:           /* UPS_ON_LINE = '$'   */
 276          if (s == NULL)
 277             write_lock(ups);
 278          ups->set_online();
 279          Dmsg0(80, "Got UPS ON LINE.\n");
 280          if (s == NULL) {
 281             write_unlock(ups);
 282             ending = 1;
 283          }
 284          break;
 285       case BATT_LOW:              /* BATT_LOW    = '%'   */
 286          if (s == NULL)
 287             write_lock(ups);
 288          ups->set_battlow();
 289          Dmsg0(80, "Got UPS BATT_LOW.\n");
 290          if (s == NULL) {
 291             write_unlock(ups);
 292             ending = 1;
 293          }
 294          break;
 295       case BATT_OK:               /* BATT_OK     = '+'   */
 296          if (s == NULL)
 297             write_lock(ups);
 298          ups->clear_battlow();
 299          Dmsg0(80, "Got UPS BATT_OK.\n");
 300          if (s == NULL) {
 301             write_unlock(ups);
 302             ending = 1;
 303          }
 304          break;
 305
 306       case UPS_EPROM_CHANGE:      /* UPS_EPROM_CHANGE = '|' */
 307       case UPS_TRAILOR:           /* UPS_TRAILOR = ':'      */
 308          break;
 309
 310          /* NOTE: The UPS terminates what it sends to us
 311           * with a \r\n. Thus the line feed signals the
 312           * end of what we are to receive.
 313           */
 314       case UPS_LF:                /* UPS_LF      = '\n'  */
 315          if (s != NULL)
 316             ending = 1;            /* This what we waited for */
 317          break;
 318       case UPS_CR:                /* UPS_CR      = '\r'  */
 319          break;
 320       default:
 321          if (s != NULL) {
 322             if (i + 1 < len)
 323                s[i++] = c;
 324             else
 325                ending = 1;         /* no more room in buffer */
 326          }
 327          break;
 328       }
 329    }
 330
 331    if (s != NULL) {
 332       s[i] = '\0';
 333    }
 334    return SUCCESS;
 335 }
 336
 337 /*********************************************************************/
 338 /* Note this routine MUST be called with the UPS write lock held! */
 339 void UPSlinkCheck(UPSINFO *ups)
 340 {
 341    struct timeval now, prev, start;
 342    static int linkcheck = FALSE;
 343
 344    if (linkcheck)
 345       return;
 346
 347    linkcheck = TRUE;               /* prevent recursion */
 348
 349    tcflush(ups->fd, TCIOFLUSH);
 350    if (strcmp(smart_poll('Y', ups), "SM") == 0) {
 351       linkcheck = FALSE;
 352       ups->clear_commlost();
 353       return;
 354    }
 355
 356    write_unlock(ups);
 357
 358    gettimeofday(&start, NULL);
 359    prev = start;
 360
 361    tcflush(ups->fd, TCIOFLUSH);
 362    while (strcmp(smart_poll('Y', ups), "SM") != 0) {
 363       /* Declare commlost only if COMMLOST_TIMEOUT_MS has expired */
 364       gettimeofday(&now, NULL);
 365       if (TV_DIFF_MS(start, now) >= COMMLOST_TIMEOUT_MS) {
 366          /* Generate commlost event if we've not done so yet */
 367          if (!ups->is_commlost()) {
 368             ups->set_commlost();
 369             generate_event(ups, CMDCOMMFAILURE);
 370             prev = now;
 371          }
 372
 373          /* Log an event every 10 minutes */
 374          if (TV_DIFF_MS(prev, now) >= 10*60*1000) {
 375             log_event(ups, event_msg[CMDCOMMFAILURE].level,
 376                event_msg[CMDCOMMFAILURE].msg);
 377             prev = now;
 378          }
 379       }
 380
 381       /*
 382        * This sleep should not be necessary since the smart_poll()
 383        * routine normally waits TIMER_FAST (1) seconds. However,
 384        * in case the serial port is broken and generating spurious
 385        * characters, we sleep to reduce CPU consumption.
 386        */
 387       sleep(1);
 388       tcflush(ups->fd, TCIOFLUSH);
 389    }
 390
 391    write_lock(ups);
 392
 393    if (ups->is_commlost()) {
 394       ups->clear_commlost();
 395       generate_event(ups, CMDCOMMOK);
 396    }
 397
 398    linkcheck = FALSE;
 399 }
 400
 401 /*********************************************************************
 402  *
 403  *  This subroutine is called to load our shared memory with
 404  *  information that is changing inside the UPS depending
 405  *  on the state of the UPS and the mains power.
 406  */
 407 int apcsmart_ups_read_volatile_data(UPSINFO *ups)
 408 {
 409    time_t now;
 410    char *answer;
 411
 412    /*
 413     * We need it for self-test start time.
 414     */
 415    now = time(NULL);
 416
 417    write_lock(ups);
 418
 419    UPSlinkCheck(ups);              /* make sure serial port is working */
 420
 421    ups->poll_time = time(NULL);    /* save time stamp */
 422
 423    /* UPS_STATUS */
 424    if (ups->UPS_Cap[CI_STATUS]) {
 425       char status[10];
 426       int retries = 5;             /* Number of retries on status read */
 427
 428     again:
 429       answer = smart_poll(ups->UPS_Cmd[CI_STATUS], ups);
 430       Dmsg1(80, "Got CI_STATUS: %s\n", answer);
 431       strncpy(status, answer, sizeof(status));
 432
 433       /*
 434        * The Status command may return "SM" probably because firmware
 435        * is in a state where it still didn't updated its internal status
 436        * register. In this case retry to read the register. To be sure
 437        * not to get stuck here, we retry only 5 times.
 438        *
 439        * XXX
 440        *
 441        * If this fails, apcupsd may not be able to detect a status
 442        * change and will have unpredictable behavior. This will be fixed
 443        * once we will handle correctly the own apcupsd Status word.
 444        */
 445       if (status[0] == 'S' && status[1] == 'M' && (retries-- > 0))
 446          goto again;
 447
 448       ups->Status &= ~0xFF;        /* clear APC byte */
 449       ups->Status |= strtoul(status, NULL, 16) & 0xFF;  /* set APC byte */
 450    }
 451
 452    /* ONBATT_STATUS_FLAG -- line quality */
 453    if (ups->UPS_Cap[CI_LQUAL]) {
 454       answer = smart_poll(ups->UPS_Cmd[CI_LQUAL], ups);
 455       Dmsg1(80, "Got CI_LQUAL: %s\n", answer);
 456       astrncpy(ups->linequal, answer, sizeof(ups->linequal));
 457    }
 458
 459    /* Reason for last transfer to batteries */
 460    if (ups->UPS_Cap[CI_WHY_BATT]) {
 461       answer = smart_poll(ups->UPS_Cmd[CI_WHY_BATT], ups);
 462       Dmsg1(80, "Got CI_WHY_BATT: %s\n", answer);
 463       ups->lastxfer = decode_lastxfer(answer);
 464       /*
 465        * XXX
 466        *
 467        * See if this is a self test rather than power failure
 468        * But not now !
 469        * When we will be ready we will copy the code below inside
 470        * the driver entry point, for performing this check inside the
 471        * driver.
 472        */
 473    }
 474
 475    /* Results of last self test */
 476    if (ups->UPS_Cap[CI_ST_STAT]) {
 477       answer = smart_poll(ups->UPS_Cmd[CI_ST_STAT], ups);
 478       Dmsg1(80, "Got CI_ST_STAT: %s\n", answer);
 479       ups->testresult = decode_testresult(answer);
 480    }
 481
 482    /* LINE_VOLTAGE */
 483    if (ups->UPS_Cap[CI_VLINE]) {
 484       answer = smart_poll(ups->UPS_Cmd[CI_VLINE], ups);
 485       Dmsg1(80, "Got CI_VLINE: %s\n", answer);
 486       ups->LineVoltage = atof(answer);
 487    }
 488
 489    /* UPS_LINE_MAX */
 490    if (ups->UPS_Cap[CI_VMAX]) {
 491       answer = smart_poll(ups->UPS_Cmd[CI_VMAX], ups);
 492       Dmsg1(80, "Got CI_VMAX: %s\n", answer);
 493       ups->LineMax = atof(answer);
 494    }
 495
 496    /* UPS_LINE_MIN */
 497    if (ups->UPS_Cap[CI_VMIN]) {
 498       answer = smart_poll(ups->UPS_Cmd[CI_VMIN], ups);
 499       Dmsg1(80, "Got CI_VMIN: %s\n", answer);
 500       ups->LineMin = atof(answer);
 501    }
 502
 503    /* OUTPUT_VOLTAGE */
 504    if (ups->UPS_Cap[CI_VOUT]) {
 505       answer = smart_poll(ups->UPS_Cmd[CI_VOUT], ups);
 506       Dmsg1(80, "Got CI_VOUT: %s\n", answer);
 507       ups->OutputVoltage = atof(answer);
 508    }
 509
 510    /* BATT_FULL Battery level percentage */
 511    if (ups->UPS_Cap[CI_BATTLEV]) {
 512       answer = smart_poll(ups->UPS_Cmd[CI_BATTLEV], ups);
 513       Dmsg1(80, "Got CI_BATTLEV: %s\n", answer);
 514       ups->BattChg = atof(answer);
 515    }
 516
 517    /* BATT_VOLTAGE */
 518    if (ups->UPS_Cap[CI_VBATT]) {
 519       answer = smart_poll(ups->UPS_Cmd[CI_VBATT], ups);
 520       Dmsg1(80, "Got CI_VBATT: %s\n", answer);
 521       ups->BattVoltage = atof(answer);
 522    }
 523
 524    /* UPS_LOAD */
 525    if (ups->UPS_Cap[CI_LOAD]) {
 526       answer = smart_poll(ups->UPS_Cmd[CI_LOAD], ups);
 527       Dmsg1(80, "Got CI_LOAD: %s\n", answer);
 528       ups->UPSLoad = atof(answer);
 529    }
 530
 531    /* LINE_FREQ */
 532    if (ups->UPS_Cap[CI_FREQ]) {
 533       answer = smart_poll(ups->UPS_Cmd[CI_FREQ], ups);
 534       Dmsg1(80, "Got CI_FREQ: %s\n", answer);
 535       ups->LineFreq = atof(answer);
 536    }
 537
 538    /* UPS_RUNTIME_LEFT */
 539    if (ups->UPS_Cap[CI_RUNTIM]) {
 540       answer = smart_poll(ups->UPS_Cmd[CI_RUNTIM], ups);
 541       Dmsg1(80, "Got CI_RUNTIM: %s\n", answer);
 542       ups->TimeLeft = atof(answer);
 543    }
 544
 545    /* UPS_TEMP */
 546    if (ups->UPS_Cap[CI_ITEMP]) {
 547       answer = smart_poll(ups->UPS_Cmd[CI_ITEMP], ups);
 548       Dmsg1(80, "Got CI_ITEMP: %s\n", answer);
 549       ups->UPSTemp = atof(answer);
 550    }
 551
 552    /* DIP_SWITCH_SETTINGS */
 553    if (ups->UPS_Cap[CI_DIPSW]) {
 554       answer = smart_poll(ups->UPS_Cmd[CI_DIPSW], ups);
 555       Dmsg1(80, "Got CI_DIPSW: %s\n", answer);
 556       ups->dipsw = strtoul(answer, NULL, 16);
 557    }
 558
 559    /* Register 1 */
 560    if (ups->UPS_Cap[CI_REG1]) {
 561       answer = smart_poll(ups->UPS_Cmd[CI_REG1], ups);
 562       Dmsg1(80, "Got CI_REG1: %s\n", answer);
 563       ups->reg1 = strtoul(answer, NULL, 16);
 564    }
 565
 566    /* Register 2 */
 567    if (ups->UPS_Cap[CI_REG2]) {
 568       answer = smart_poll(ups->UPS_Cmd[CI_REG2], ups);
 569       Dmsg1(80, "Got CI_REG2: %s\n", answer);
 570       ups->reg2 = strtoul(answer, NULL, 16);
 571       ups->set_battpresent(!(ups->reg2 & 0x20));
 572    }
 573
 574    /* Register 3 */
 575    if (ups->UPS_Cap[CI_REG3]) {
 576       answer = smart_poll(ups->UPS_Cmd[CI_REG3], ups);
 577       Dmsg1(80, "Got CI_REG3: %s\n", answer);
 578       ups->reg3 = strtoul(answer, NULL, 16);
 579    }
 580
 581    /* Humidity percentage */
 582    if (ups->UPS_Cap[CI_HUMID]) {
 583       answer = smart_poll(ups->UPS_Cmd[CI_HUMID], ups);
 584       Dmsg1(80, "Got CI_HUMID: %s\n", answer);
 585       ups->humidity = atof(answer);
 586    }
 587
 588    /* Ambient temperature */
 589    if (ups->UPS_Cap[CI_ATEMP]) {
 590       answer = smart_poll(ups->UPS_Cmd[CI_ATEMP], ups);
 591       Dmsg1(80, "Got CI_ATEMP: %s\n", answer);
 592       ups->ambtemp = atof(answer);
 593    }
 594
 595    /* Hours since self test */
 596    if (ups->UPS_Cap[CI_ST_TIME]) {
 597       answer = smart_poll(ups->UPS_Cmd[CI_ST_TIME], ups);
 598       Dmsg1(80, "Got CI_ST_TIME: %s\n", answer);
 599       ups->LastSTTime = atof(answer);
 600    }
 601
 602    apc_enable(ups);                /* reenable APC serial UPS */
 603
 604    write_unlock(ups);
 605
 606    return SUCCESS;
 607 }
 608
 609 /*********************************************************************
 610  *
 611  *  This subroutine is called to load our shared memory with
 612  *  information that is static inside the UPS.        Hence it
 613  *  normally would only be called once when starting up the
 614  *  UPS.
 615  */
 616 int apcsmart_ups_read_static_data(UPSINFO *ups)
 617 {
 618    char *answer;
 619
 620    /* Everything from here on down is non-volitile, that is
 621     * we do not expect it to change while the UPS is running
 622     * unless we explicitly change it.
 623     */
 624
 625    /* SENSITIVITY */
 626    if (ups->UPS_Cap[CI_SENS]) {
 627       answer = smart_poll(ups->UPS_Cmd[CI_SENS], ups);
 628       Dmsg1(80, "Got CI_SENS: %s\n", answer);
 629       astrncpy(ups->sensitivity, answer, sizeof(ups->sensitivity));
 630    }
 631
 632    /* WAKEUP_DELAY */
 633    if (ups->UPS_Cap[CI_DWAKE]) {
 634       answer = smart_poll(ups->UPS_Cmd[CI_DWAKE], ups);
 635       Dmsg1(80, "Got CI_DWAKE: %s\n", answer);
 636       ups->dwake = (int)atof(answer);
 637    }
 638
 639    /* SLEEP_DELAY */
 640    if (ups->UPS_Cap[CI_DSHUTD]) {
 641       answer = smart_poll(ups->UPS_Cmd[CI_DSHUTD], ups);
 642       Dmsg1(80, "Got CI_DSHUTD: %s\n", answer);
 643       ups->dshutd = (int)atof(answer);
 644    }
 645
 646    /* LOW_TRANSFER_LEVEL */
 647    if (ups->UPS_Cap[CI_LTRANS]) {
 648       answer = smart_poll(ups->UPS_Cmd[CI_LTRANS], ups);
 649       Dmsg1(80, "Got CI_LTRANS: %s\n", answer);
 650       ups->lotrans = (int)atof(answer);
 651    }
 652
 653    /* HIGH_TRANSFER_LEVEL */
 654    if (ups->UPS_Cap[CI_HTRANS]) {
 655       answer = smart_poll(ups->UPS_Cmd[CI_HTRANS], ups);
 656       Dmsg1(80, "Got CI_HTRANS: %s\n", answer);
 657       ups->hitrans = (int)atof(answer);
 658    }
 659
 660    /* UPS_BATT_CAP_RETURN */
 661    if (ups->UPS_Cap[CI_RETPCT]) {
 662       answer = smart_poll(ups->UPS_Cmd[CI_RETPCT], ups);
 663       Dmsg1(80, "Got CI_RETPCT: %s\n", answer);
 664       ups->rtnpct = (int)atof(answer);
 665    }
 666
 667    /* ALARM_STATUS */
 668    if (ups->UPS_Cap[CI_DALARM]) {
 669       answer = smart_poll(ups->UPS_Cmd[CI_DALARM], ups);
 670       Dmsg1(80, "Got CI_DALARM: %s\n", answer);
 671       astrncpy(ups->beepstate, answer, sizeof(ups->beepstate));
 672    }
 673
 674    /* LOWBATT_SHUTDOWN_LEVEL */
 675    if (ups->UPS_Cap[CI_DLBATT]) {
 676       answer = smart_poll(ups->UPS_Cmd[CI_DLBATT], ups);
 677       Dmsg1(80, "Got CI_DLBATT: %s\n", answer);
 678       ups->dlowbatt = (int)atof(answer);
 679    }
 680
 681    /* UPS_NAME */
 682    if (ups->upsname[0] == 0 && ups->UPS_Cap[CI_IDEN]) {
 683       answer = smart_poll(ups->UPS_Cmd[CI_IDEN], ups);
 684       Dmsg1(80, "Got CI_IDEN: %s\n", answer);
 685       astrncpy(ups->upsname, answer, sizeof(ups->upsname));
 686    }
 687
 688    /* UPS_SELFTEST */
 689    if (ups->UPS_Cap[CI_STESTI]) {
 690       answer = smart_poll(ups->UPS_Cmd[CI_STESTI], ups);
 691       Dmsg1(80, "Got CI_STESTI: %s\n", answer);
 692       astrncpy(ups->selftest, answer, sizeof(ups->selftest));
 693    }
 694
 695    /* UPS_MANUFACTURE_DATE */
 696    if (ups->UPS_Cap[CI_MANDAT]) {
 697       answer = smart_poll(ups->UPS_Cmd[CI_MANDAT], ups);
 698       Dmsg1(80, "Got CI_MANDAT: %s\n", answer);
 699       astrncpy(ups->birth, answer, sizeof(ups->birth));
 700    }
 701
 702    /* UPS_SERIAL_NUMBER */
 703    if (ups->UPS_Cap[CI_SERNO]) {
 704       answer = smart_poll(ups->UPS_Cmd[CI_SERNO], ups);
 705       Dmsg1(80, "Got CI_SERNO: %s\n", answer);
 706       astrncpy(ups->serial, answer, sizeof(ups->serial));
 707    }
 708
 709    /* UPS_BATTERY_REPLACE */
 710    if (ups->UPS_Cap[CI_BATTDAT]) {
 711       answer = smart_poll(ups->UPS_Cmd[CI_BATTDAT], ups);
 712       Dmsg1(80, "Got CI_BATTDAT: %s\n", answer);
 713       astrncpy(ups->battdat, answer, sizeof(ups->battdat));
 714    }
 715
 716    /* Nominal output voltage when on batteries */
 717    if (ups->UPS_Cap[CI_NOMOUTV]) {
 718       answer = smart_poll(ups->UPS_Cmd[CI_NOMOUTV], ups);
 719       Dmsg1(80, "Got CI_NOMOUTV: %s\n", answer);
 720       ups->NomOutputVoltage = (int)atof(answer);
 721    }
 722
 723    /* Nominal battery voltage */
 724    if (ups->UPS_Cap[CI_NOMBATTV]) {
 725       answer = smart_poll(ups->UPS_Cmd[CI_NOMBATTV], ups);
 726       Dmsg1(80, "Got CI_NOMBATTV: %s\n", answer);
 727       ups->nombattv = atof(answer);
 728    }
 729
 730    /* Firmware revision */
 731    if (ups->UPS_Cap[CI_REVNO]) {
 732       answer = smart_poll(ups->UPS_Cmd[CI_REVNO], ups);
 733       Dmsg1(80, "Got CI_REVNO: %s\n", answer);
 734       astrncpy(ups->firmrev, answer, sizeof(ups->firmrev));
 735    }
 736
 737    /* Number of external batteries installed */
 738    if (ups->UPS_Cap[CI_EXTBATTS]) {
 739       answer = smart_poll(ups->UPS_Cmd[CI_EXTBATTS], ups);
 740       Dmsg1(80, "Got CI_EXTBATTS: %s\n", answer);
 741       ups->extbatts = (int)atof(answer);
 742    }
 743
 744    /* Number of bad batteries installed */
 745    if (ups->UPS_Cap[CI_BADBATTS]) {
 746       answer = smart_poll(ups->UPS_Cmd[CI_BADBATTS], ups);
 747       Dmsg1(80, "Got CI_BADBATTS: %s\n", answer);
 748       ups->badbatts = (int)atof(answer);
 749    }
 750
 751    /* UPS model */
 752    if (ups->UPS_Cap[CI_UPSMODEL]) {
 753       answer = smart_poll(ups->UPS_Cmd[CI_UPSMODEL], ups);
 754       if (ups->UPS_Cmd[CI_UPSMODEL] == APC_CMD_OLDFWREV) {
 755          /* Derive UPS model from old fw rev */
 756          astrncpy(ups->upsmodel, get_model_from_oldfwrev(answer),
 757                   sizeof(ups->upsmodel));
 758       } else {
 759          astrncpy(ups->upsmodel, answer, sizeof(ups->upsmodel));
 760       }
 761       Dmsg1(80, "Got CI_UPSMODEL: %s\n", ups->upsmodel);
 762    }
 763
 764    /* EPROM Capabilities */
 765    if (ups->UPS_Cap[CI_EPROM]) {
 766       answer = smart_poll(ups->UPS_Cmd[CI_EPROM], ups);
 767       Dmsg1(80, "Got CI_EPROM: %s\n", answer);
 768       astrncpy(ups->eprom, answer, sizeof(ups->eprom));
 769    }
 770
 771    return SUCCESS;
 772 }
 773
 774 int apcsmart_ups_entry_point(UPSINFO *ups, int command, void *data)
 775 {
 776    int retries = 5;                /* Number of retries if reason is NA (see below) */
 777    char ans[20];
 778
 779    switch (command) {
 780    case DEVICE_CMD_SET_DUMB_MODE:
 781       /* Set dumb mode for a smart UPS */
 782       write(ups->fd, "R", 1);      /* enter dumb mode */
 783       *ans = 0;
 784       getline(ans, sizeof(ans), ups);
 785       printf("Going dumb: %s\n", ans);
 786       break;
 787
 788    case DEVICE_CMD_GET_SELFTEST_MSG:
 789       /* Results of last self test */
 790       if (ups->UPS_Cap[CI_ST_STAT]) {
 791          ups->testresult = decode_testresult(
 792             smart_poll(ups->UPS_Cmd[CI_ST_STAT], ups));
 793       }
 794       break;
 795
 796    case DEVICE_CMD_CHECK_SELFTEST:
 797
 798       Dmsg0(80, "Checking self test.\n");
 799       /*
 800        * XXX
 801        *
 802        * One day we will do this test inside the driver and not as an
 803        * entry point.
 804        */
 805       /* Reason for last transfer to batteries */
 806       if (ups->UPS_Cap[CI_WHY_BATT]) {
 807          ups->lastxfer = XFER_NA;
 808          while (ups->lastxfer == XFER_NA && retries--) {
 809             ups->lastxfer = decode_lastxfer(
 810                smart_poll(ups->UPS_Cmd[CI_WHY_BATT], ups));
 811             if (ups->lastxfer == XFER_NA) {
 812                Dmsg0(80, "Transfer reason still not available.\n");
 813                if (retries > 0)
 814                   sleep(2);           /* debounce */
 815
 816                /*
 817                 * Be careful because if we go out of here without
 818                 * knowing the reason of transfer (i.e. the reason
 819                 * is "NA", apcupsd will think this is a power failure
 820                 * even if it is a self test. Not much of a problem
 821                 * as this should not happen.
 822                 * We allow 5 retries for reading reason from UPS before
 823                 * giving up.
 824                 */
 825             } else if (ups->lastxfer == XFER_SELFTEST) {
 826                ups->SelfTest = time(NULL);
 827                Dmsg1(80, "Self Test time: %s", ctime(&ups->SelfTest));
 828             }
 829          }
 830       }
 831       break;
 832
 833    default:
 834       return FAILURE;
 835       break;
 836    }
 837
 838    return SUCCESS;
 839 }