1 /* $NetBSD: amrctl.c,v 1.10 2014/03/23 05:09:56 dholland Exp $ */ 2 3 /*- 4 * Copyright (c) 2002, Pierre David <Pierre.David@crc.u-strasbg.fr> 5 * Copyright (c) 2006, Jung-uk Kim <jkim@FreeBSD.org> 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice unmodified, this list of conditions, and the following 13 * disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 */ 29 30 #include <sys/cdefs.h> 31 #ifndef lint 32 __RCSID("$NetBSD: amrctl.c,v 1.10 2014/03/23 05:09:56 dholland Exp $"); 33 #endif 34 35 #include <stdio.h> 36 #include <stdlib.h> 37 #include <string.h> 38 #include <fcntl.h> 39 #include <err.h> 40 #include <errno.h> 41 #include <unistd.h> 42 43 #include <sys/ioctl.h> 44 45 #include <machine/param.h> 46 47 #include <dev/pci/amrio.h> 48 #include <dev/pci/amrreg.h> 49 50 #define NATTEMPTS 5 51 #define SLEEPTIME 100000 /* microseconds */ 52 53 static int nattempts = NATTEMPTS; /* # of attempts before giving up */ 54 static int sleeptime = SLEEPTIME; /* between attempts, in ms */ 55 56 #define AMR_BUFSIZE 1024 57 58 static int enq_result = AMR_STATUS_FAILED; 59 static char enq_buffer[AMR_BUFSIZE]; 60 61 #define AMR_MAX_NCTRLS 16 62 #define AMR_MAX_NSDEVS 16 63 64 static uint8_t nschan = 0; 65 66 /* 67 * Include lookup tables, and a function to match a code to a string. 68 * 69 * XXX Lookup tables cannot be included, since they require symbols from 70 * amrreg.h which need in turn the _KERNEL define. 71 */ 72 73 /* #define AMR_DEFINE_TABLES */ 74 /* #include "amr_tables.h" */ 75 76 static int amr_ioctl_enquiry(int, uint8_t, uint8_t, uint8_t); 77 __dead static void usage(const char *); 78 static int describe_card(int, int, int); 79 static char * describe_property(uint8_t, char *); 80 static const char * describe_state(int, uint8_t); 81 static void describe_battery(int, int, int, int, int); 82 static void describe_one_volume(int, int, uint32_t, uint8_t, uint8_t); 83 static void describe_one_drive(int, int, uint8_t); 84 static void describe_drive(int, int, int, int, int); 85 86 /* 87 * Offsets in an amr_user_ioctl.au_cmd [] array See amrio.h 88 */ 89 90 #define MB_COMMAND 0 91 #define MB_CHANNEL 1 92 #define MB_PARAM 2 93 #define MB_PAD 3 94 #define MB_DRIVE 4 95 96 #define FIRMWARE_40LD 1 97 #define FIRMWARE_8LD 2 98 99 static const struct { 100 const char *product; 101 const uint32_t signature; 102 } prodtable[] = { 103 { "Series 431", AMR_SIG_431 }, 104 { "Series 438", AMR_SIG_438 }, 105 { "Series 762", AMR_SIG_762 }, 106 { "Integrated HP NetRAID (T5)", AMR_SIG_T5 }, 107 { "Series 466", AMR_SIG_466 }, 108 { "Series 467", AMR_SIG_467 }, 109 { "Integrated HP NetRAID (T7)", AMR_SIG_T7 }, 110 { "Series 490", AMR_SIG_490 } 111 }; 112 113 static const struct { 114 const int code; 115 const char *ifyes, *ifno; 116 } proptable[] = { 117 { AMR_DRV_WRITEBACK, 118 "writeback", "write-through" }, 119 { AMR_DRV_READHEAD, 120 "read-ahead", "no-read-ahead" }, 121 { AMR_DRV_ADAPTIVE, 122 "adaptative-io", "no-adaptative-io" } 123 }; 124 125 static const struct { 126 const int code; 127 const char *status; 128 } statetable[] = { 129 { AMR_DRV_OFFLINE, "offline" }, 130 { AMR_DRV_DEGRADED, "degraded" }, 131 { AMR_DRV_OPTIMAL, "optimal" }, 132 { AMR_DRV_ONLINE, "online" }, 133 { AMR_DRV_FAILED, "failed" }, 134 { AMR_DRV_REBUILD, "rebuild" }, 135 { AMR_DRV_HOTSPARE, "hotspare" } 136 }; 137 138 static const struct { 139 const uint8_t code; 140 const char *status; 141 } battable[] = { 142 { AMR_BATT_MODULE_MISSING, "not present" }, 143 { AMR_BATT_LOW_VOLTAGE, "low voltage" }, 144 { AMR_BATT_TEMP_HIGH, "high temperature" }, 145 { AMR_BATT_PACK_MISSING, "pack missing" }, 146 { AMR_BATT_CYCLES_EXCEEDED, "cycle exceeded" } 147 }; 148 149 static const struct { 150 const uint8_t code; 151 const char *status; 152 } bcstatble[] = { 153 { AMR_BATT_CHARGE_DONE, "charge done" }, 154 { AMR_BATT_CHARGE_INPROG, "charge in progress" }, 155 { AMR_BATT_CHARGE_FAIL, "charge failed" } 156 }; 157 158 static int 159 amr_ioctl_enquiry(int fd, uint8_t cmd, uint8_t cmdsub, uint8_t cmdqual) 160 { 161 struct amr_user_ioctl am; 162 int r, i; 163 164 am.au_cmd[MB_COMMAND] = cmd; 165 am.au_cmd[MB_CHANNEL] = cmdsub; 166 am.au_cmd[MB_PARAM] = cmdqual; 167 am.au_cmd[MB_PAD] = 0; 168 am.au_cmd[MB_DRIVE] = 0; 169 170 am.au_buffer = enq_buffer; 171 am.au_length = AMR_BUFSIZE; 172 am.au_direction = AMR_IO_READ; 173 am.au_status = 0; 174 175 i = 0; 176 r = -1; 177 while (i < nattempts && r == -1) { 178 r = ioctl(fd, AMR_IO_COMMAND, &am); 179 if (r == -1) { 180 if (errno != EBUSY) { 181 warn("ioctl enquiry"); 182 return -1; 183 } else 184 usleep(sleeptime); 185 } 186 i++; 187 } 188 return am.au_status; 189 } 190 191 static void 192 usage(const char *prog) 193 { 194 fprintf(stderr, "usage: %s stat [-a num] [-b] " 195 "[-c ctlr|-f dev] [-g] [-l vol]\n\t\t" 196 "[-p drive|-s bus[:target]] [-t usec] [-v]\n\n\t" 197 "-a num\t\tnumber of retries\n\t" 198 "-b\t\tbattery status\n\t" 199 "-c ctrl\t\tcontroller ID\n\t" 200 "-f dev\t\tdevice path\n\t" 201 "-g\t\tprint global parameters\n\t" 202 "-l vol\t\tlogical volume ID\n\t" 203 "-p drive\tphysical drive ID\n\t" 204 "-s bus[:target]\tSCSI bus (and optinal target)\n\t" 205 "-t usec\t\tsleep time between retries\n\t" 206 "-v\t\tverbose output\n", 207 prog); 208 exit(1); 209 } 210 211 /****************************************************************************** 212 * Card description 213 */ 214 215 static int 216 describe_card(int fd, int verbosity, int globalparam) 217 { 218 struct amr_enquiry *ae; 219 uint32_t cardtype; 220 221 /* 222 * Try the 40LD firmware interface 223 */ 224 225 enq_result = amr_ioctl_enquiry(fd, AMR_CMD_CONFIG, 226 AMR_CONFIG_PRODUCT_INFO, 0); 227 if (enq_result == AMR_STATUS_SUCCESS) { 228 struct amr_prodinfo *ap; 229 230 ap = (struct amr_prodinfo *)enq_buffer; 231 nschan = ap->ap_nschan; 232 if (globalparam) { 233 printf("Product\t\t\t<%.80s>\n", ap->ap_product); 234 printf("Firmware\t\t%.16s\n", ap->ap_firmware); 235 printf("BIOS\t\t\t%.16s\n", ap->ap_bios); 236 printf("SCSI channels\t\t%d\n", ap->ap_nschan); 237 printf("Fibre loops\t\t%d\n", ap->ap_fcloops); 238 printf("Memory size\t\t%d MB\n", ap->ap_memsize); 239 if (verbosity >= 1) { 240 printf("Ioctl\t\t\t%d (%s)\n", FIRMWARE_40LD, 241 "40LD"); 242 printf("Signature\t\t0x%08x\n", 243 ap->ap_signature); 244 printf("Configsig\t\t0x%08x\n", 245 ap->ap_configsig); 246 printf("Subsystem\t\t0x%04x\n", 247 ap->ap_subsystem); 248 printf("Subvendor\t\t0x%04x\n", 249 ap->ap_subvendor); 250 printf("Notify counters\t\t%d\n", 251 ap->ap_numnotifyctr); 252 } 253 } 254 return FIRMWARE_40LD; 255 } 256 /* 257 * Try the 8LD firmware interface 258 */ 259 260 enq_result = amr_ioctl_enquiry(fd, AMR_CMD_EXT_ENQUIRY2, 0, 0); 261 ae = (struct amr_enquiry *)enq_buffer; 262 if (enq_result == AMR_STATUS_SUCCESS) { 263 cardtype = ae->ae_signature; 264 } else { 265 enq_result = amr_ioctl_enquiry(fd, AMR_CMD_ENQUIRY, 0, 0); 266 cardtype = 0; 267 } 268 269 if (enq_result == AMR_STATUS_SUCCESS) { 270 271 if (globalparam) { 272 const char *product = NULL; 273 char bios[100], firmware[100]; 274 size_t i; 275 276 for (i = 0; i < __arraycount(prodtable); i++) { 277 if (cardtype == prodtable[i].signature) { 278 product = prodtable[i].product; 279 break; 280 } 281 } 282 if (product == NULL) 283 product = "unknown card signature"; 284 285 /* 286 * HP NetRaid controllers have a special encoding of 287 * the firmware and BIOS versions. The AMI version 288 * seems to have it as strings whereas the HP version 289 * does it with a leading uppercase character and two 290 * binary numbers. 291 */ 292 293 if (ae->ae_adapter.aa_firmware[2] >= 'A' && 294 ae->ae_adapter.aa_firmware[2] <= 'Z' && 295 ae->ae_adapter.aa_firmware[1] < ' ' && 296 ae->ae_adapter.aa_firmware[0] < ' ' && 297 ae->ae_adapter.aa_bios[2] >= 'A' && 298 ae->ae_adapter.aa_bios[2] <= 'Z' && 299 ae->ae_adapter.aa_bios[1] < ' ' && 300 ae->ae_adapter.aa_bios[0] < ' ') { 301 302 /* 303 * looks like we have an HP NetRaid version 304 * of the MegaRaid 305 */ 306 307 if (cardtype == AMR_SIG_438) { 308 /* 309 * the AMI 438 is a NetRaid 3si in 310 * HP-land 311 */ 312 product = "HP NetRaid 3si"; 313 } 314 snprintf(firmware, sizeof(firmware), 315 "%c.%02d.%02d", 316 ae->ae_adapter.aa_firmware[2], 317 ae->ae_adapter.aa_firmware[1], 318 ae->ae_adapter.aa_firmware[0]); 319 snprintf(bios, sizeof(bios), 320 "%c.%02d.%02d", 321 ae->ae_adapter.aa_bios[2], 322 ae->ae_adapter.aa_bios[1], 323 ae->ae_adapter.aa_bios[0]); 324 } else { 325 snprintf(firmware, sizeof(firmware), "%.4s", 326 ae->ae_adapter.aa_firmware); 327 snprintf(bios, sizeof(bios), "%.4s", 328 ae->ae_adapter.aa_bios); 329 } 330 331 printf("Ioctl = %d (%s)\n", FIRMWARE_8LD, "8LD"); 332 printf("Product =\t<%s>\n", product); 333 printf("Firmware =\t%s\n", firmware); 334 printf("BIOS =\t%s\n", bios); 335 /* printf ("SCSI Channels =\t%d\n", ae->ae_nschan); */ 336 /* printf ("Fibre Loops =\t%d\n", ae->ae_fcloops); */ 337 printf("Memory size =\t%d MB\n", 338 ae->ae_adapter.aa_memorysize); 339 /* 340 * printf ("Notify counters =\t%d\n", 341 * ae->ae_numnotifyctr) ; 342 */ 343 } 344 return FIRMWARE_8LD; 345 } 346 /* 347 * Neither firmware interface succeeded. Abort. 348 */ 349 350 fprintf(stderr, "Firmware interface not supported\n"); 351 exit(1); 352 353 } 354 355 static char * 356 describe_property(uint8_t prop, char *buffer) 357 { 358 size_t i; 359 360 strcpy(buffer, "<"); 361 for (i = 0; i < __arraycount(proptable); i++) { 362 if (i > 0) 363 strcat(buffer, ","); 364 if (prop & proptable[i].code) 365 strcat(buffer, proptable[i].ifyes); 366 else 367 strcat(buffer, proptable[i].ifno); 368 } 369 strcat(buffer, ">"); 370 371 return buffer; 372 } 373 374 static const char * 375 describe_state(int verbosity, uint8_t state) 376 { 377 size_t i; 378 379 if ((AMR_DRV_PREVSTATE(state) == AMR_DRV_CURSTATE(state)) && 380 (AMR_DRV_CURSTATE(state) == AMR_DRV_OFFLINE) && verbosity == 0) 381 return NULL; 382 383 for (i = 0; i < __arraycount(statetable); i++) 384 if (AMR_DRV_CURSTATE(state) == statetable[i].code) 385 return (statetable[i].status); 386 387 return NULL; 388 } 389 390 /****************************************************************************** 391 * Battery status 392 */ 393 static void 394 describe_battery(int fd, int verbosity, int fwint, int bflags, int globalparam) 395 { 396 uint8_t batt_status; 397 size_t i; 398 399 if (fwint == FIRMWARE_40LD) { 400 enq_result = amr_ioctl_enquiry(fd, AMR_CMD_CONFIG, 401 AMR_CONFIG_ENQ3, AMR_CONFIG_ENQ3_SOLICITED_FULL); 402 if (enq_result == AMR_STATUS_SUCCESS) { 403 struct amr_enquiry3 *ae3; 404 405 ae3 = (struct amr_enquiry3 *)enq_buffer; 406 if (bflags || globalparam) { 407 batt_status = ae3->ae_batterystatus; 408 printf("Battery status\t\t"); 409 for (i = 0; i < __arraycount(battable); i++) { 410 if (batt_status & battable[i].code) 411 printf("%s, ", battable[i].status); 412 } 413 if (!(batt_status & 414 (AMR_BATT_MODULE_MISSING|AMR_BATT_PACK_MISSING))) { 415 for (i = 0; 416 i < __arraycount(bcstatble); i++) 417 if (bcstatble[i].code == 418 (batt_status & AMR_BATT_CHARGE_MASK)) 419 printf("%s", bcstatble[i].status); 420 } else 421 printf("charge unknown"); 422 if (verbosity) 423 printf(" (0x%02x)", batt_status); 424 printf("\n"); 425 } 426 } 427 } else if (fwint == FIRMWARE_8LD) { 428 /* Nothing to do here. */ 429 return; 430 } else { 431 fprintf(stderr, "Firmware interface not supported.\n"); 432 exit(1); 433 } 434 435 return; 436 } 437 438 /****************************************************************************** 439 * Logical volumes 440 */ 441 442 static void 443 describe_one_volume(int ldrv, int verbosity, 444 uint32_t size, uint8_t state, uint8_t prop) 445 { 446 float szgb; 447 int raid_level; 448 char propstr[MAXPATHLEN]; 449 const char *statestr; 450 451 szgb = ((float)size) / (1024 * 1024 * 2); /* size in GB */ 452 453 raid_level = prop & AMR_DRV_RAID_MASK; 454 455 printf("Logical volume %d\t", ldrv); 456 statestr = describe_state(verbosity, state); 457 printf("%s ", statestr); 458 printf("(%.2f GB, RAID%d", szgb, raid_level); 459 if (verbosity >= 1) { 460 describe_property(prop, propstr); 461 printf(" %s", propstr); 462 } 463 printf(")\n"); 464 } 465 466 /****************************************************************************** 467 * Physical drives 468 */ 469 470 static void 471 describe_one_drive(int pdrv, int verbosity, uint8_t state) 472 { 473 const char *statestr; 474 475 statestr = describe_state(verbosity, state); 476 if (statestr) { 477 if (nschan > 0) 478 printf("Physical drive %d:%d\t%s\n", 479 pdrv / AMR_MAX_NSDEVS, pdrv % AMR_MAX_NSDEVS, 480 statestr); 481 else 482 printf("Physical drive %d:\t%s\n", pdrv, statestr); 483 } 484 } 485 486 static void 487 describe_drive(int verbosity, int fwint, int ldrv, int sbus, int sdev) 488 { 489 int drv, pdrv = -1; 490 491 if (sbus > -1 && sdev > -1) 492 pdrv = (sbus * AMR_MAX_NSDEVS) + sdev; 493 if (nschan != 0) { 494 if (sbus > -1 && sbus >= nschan) { 495 fprintf(stderr, "SCSI channel %d does not exist.\n", sbus); 496 exit(1); 497 } else if (sdev > -1 && sdev >= AMR_MAX_NSDEVS) { 498 fprintf(stderr, "SCSI device %d:%d does not exist.\n", 499 sbus, sdev); 500 exit(1); 501 } 502 } 503 if (fwint == FIRMWARE_40LD) { 504 if (enq_result == AMR_STATUS_SUCCESS) { 505 struct amr_enquiry3 *ae3; 506 507 ae3 = (struct amr_enquiry3 *)enq_buffer; 508 if ((ldrv < 0 && sbus < 0) || ldrv >= 0) { 509 if (ldrv >= ae3->ae_numldrives) { 510 fprintf(stderr, "Logical volume %d " 511 "does not exist.\n", ldrv); 512 exit(1); 513 } 514 if (ldrv < 0) { 515 for (drv = 0; 516 drv < ae3->ae_numldrives; 517 drv++) 518 describe_one_volume(drv, 519 verbosity, 520 ae3->ae_drivesize[drv], 521 ae3->ae_drivestate[drv], 522 ae3->ae_driveprop[drv]); 523 } else { 524 describe_one_volume(ldrv, 525 verbosity, 526 ae3->ae_drivesize[ldrv], 527 ae3->ae_drivestate[ldrv], 528 ae3->ae_driveprop[ldrv]); 529 } 530 } 531 if ((ldrv < 0 && sbus < 0) || sbus >= 0) { 532 if (pdrv >= AMR_40LD_MAXPHYSDRIVES || 533 (nschan != 0 && pdrv >= (nschan * AMR_MAX_NSDEVS))) { 534 fprintf(stderr, "Physical drive %d " 535 "is out of range.\n", pdrv); 536 exit(1); 537 } 538 if (sbus < 0) { 539 for (drv = 0; 540 drv < AMR_40LD_MAXPHYSDRIVES; 541 drv++) { 542 if (nschan != 0 && 543 drv >= (nschan * AMR_MAX_NSDEVS)) 544 break; 545 describe_one_drive(drv, 546 verbosity, 547 ae3->ae_pdrivestate[drv]); 548 } 549 } else if (sdev < 0) { 550 for (drv = sbus * AMR_MAX_NSDEVS; 551 drv < ((sbus + 1) * AMR_MAX_NSDEVS); 552 drv++) { 553 if (nschan != 0 && 554 drv >= (nschan * AMR_MAX_NSDEVS)) 555 break; 556 describe_one_drive(drv, 557 verbosity, 558 ae3->ae_pdrivestate[drv]); 559 } 560 } else { 561 if (nschan != 0 && 562 pdrv < (nschan * AMR_MAX_NSDEVS)) 563 describe_one_drive(pdrv, 1, 564 ae3->ae_pdrivestate[pdrv]); 565 } 566 } 567 } 568 } else if (fwint == FIRMWARE_8LD) { 569 /* Nothing to do here. */ 570 return; 571 } else { 572 fprintf(stderr, "Firmware interface not supported.\n"); 573 exit(1); 574 } 575 } 576 577 /****************************************************************************** 578 * Main function 579 */ 580 581 int 582 main(int argc, char *argv[]) 583 { 584 int i; 585 int fd = -1; 586 int globalparam = 0, verbosity = 0; 587 int bflags = 0, fflags = 0, sflags = 0; 588 int lvolno = -1, physno = -1; 589 int sbusno = -1, targetno = -1; 590 char filename[MAXPATHLEN]; 591 char sdev[MAXPATHLEN]; 592 char *pdev; 593 594 extern char *optarg; 595 extern int optind; 596 597 /* 598 * Parse arguments 599 */ 600 if (argc < 2) 601 usage(argv[0]); 602 if (strcmp(argv[1], "stat") != 0) /* only stat implemented for now */ 603 usage(argv[0]); 604 605 optind = 2; 606 while ((i = getopt(argc, argv, "a:bc:f:gl:p:s:t:v")) != -1) 607 switch (i) { 608 case 'a': 609 nattempts = atoi(optarg); 610 break; 611 case 'b': 612 bflags++; 613 break; 614 case 'f': 615 snprintf(filename, MAXPATHLEN, "%s", optarg); 616 filename[MAXPATHLEN - 1] = '\0'; 617 fflags++; 618 break; 619 case 'g': 620 globalparam = 1; 621 break; 622 case 'l': 623 lvolno = atoi(optarg); 624 break; 625 case 'p': 626 physno = atoi(optarg); 627 break; 628 case 's': 629 snprintf(sdev, MAXPATHLEN, "%s", optarg); 630 sdev[MAXPATHLEN - 1] = '\0'; 631 sflags++; 632 break; 633 case 't': 634 sleeptime = atoi(optarg); 635 break; 636 case 'v': 637 verbosity++; 638 break; 639 case '?': 640 default: 641 usage(argv[0]); 642 } 643 argc -= optind; 644 argv += optind; 645 646 if (argc != 0) 647 usage(argv[0]); 648 649 if (!fflags) { 650 snprintf(filename, MAXPATHLEN, "/dev/amr0"); 651 } 652 653 fd = open(filename, O_RDONLY); 654 if (fd == -1) { 655 err(EXIT_FAILURE, "open"); 656 } 657 if (ioctl(fd, AMR_IO_VERSION, &i) == -1) { 658 err(EXIT_FAILURE, "ioctl version"); 659 } 660 661 if (sflags) { 662 if(physno > -1) 663 usage(argv[0]); 664 else { 665 sbusno = atoi(sdev); 666 if ((pdev = index(sdev, ':'))) 667 targetno = atoi(++pdev); 668 } 669 } else if (physno > -1) { 670 sbusno = physno / AMR_MAX_NSDEVS; 671 targetno = physno % AMR_MAX_NSDEVS; 672 } 673 674 if (globalparam && verbosity >= 1) 675 printf("Version\t\t\t%d\n", i); 676 #if 0 677 if (i != 1) { 678 fprintf(stderr, "Driver version (%d) not supported\n", i); 679 exit(1); 680 } 681 #endif 682 683 i = describe_card(fd, verbosity, globalparam); 684 describe_battery(fd, verbosity, i, bflags, globalparam); 685 if (!bflags || lvolno > -1 || physno > -1 || sbusno > -1 || targetno > -1) 686 describe_drive(verbosity, i, lvolno, sbusno, targetno); 687 688 return 0; 689 } 690